Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Microsoft SQL Server-Ressourcenkontrolle mit RDS für SQL Server
Resource Governor ist eine Funktion der SQL Server Enterprise Edition, mit der Sie Ihre Instance-Ressourcen präzise steuern können. Es ermöglicht Ihnen, spezifische Grenzwerte für die Nutzung von CPU, Arbeitsspeicher und physischen I/O Ressourcen durch Workloads festzulegen. Mit Resource Governor können Sie:
+ Vermeiden Sie die Monopolisierung von Ressourcen in Umgebungen mit mehreren Mandanten, indem Sie festlegen, wie verschiedene Workloads Instanzressourcen gemeinsam nutzen
+ Sorgen Sie für vorhersehbare Leistung, indem Sie spezifische Ressourcenlimits und Prioritäten für verschiedene Benutzer und Anwendungen festlegen
Sie können Resource Governor entweder auf einer vorhandenen oder einer neuen RDS for SQL Server-DB-Instance aktivieren.
Resource Governor verwendet drei grundlegende Konzepte:
+ **Ressourcenpool** — Ein Container, der die physischen Ressourcen Ihrer Instance (CPU, Arbeitsspeicher und I/O) verwaltet. Sie erhalten zwei integrierte Pools (intern und Standard) und können zusätzliche benutzerdefinierte Pools erstellen.
+ **Workload-Gruppe** — Ein Container für Datenbanksitzungen mit ähnlichen Eigenschaften. Jede Workload-Gruppe gehört zu einem Ressourcenpool. Sie erhalten zwei integrierte Workload-Gruppen (intern und Standard) und können zusätzliche benutzerdefinierte Workload-Gruppen erstellen.
+ **Klassifizierung** — Der Prozess, der anhand des Benutzernamens, Anwendungsnamens, Datenbanknamens oder Hostnamens bestimmt, welche Workload-Gruppe eingehende Sitzungen verarbeitet.
Weitere Informationen zur Resource Governor-Funktionalität in SQL Server finden Sie unter [Resource Governor](https://learn.microsoft.com/en-us/sql/relational-databases/resource-governor/resource-governor?view=sql-server-ver16) in der Microsoft-Dokumentation.
**Contents**
+ [
## Unterstützte Versionen und Regionen
](#ResourceGovernor.SupportedVersions)
+ [
## Einschränkungen und Empfehlungen
](#ResourceGovernor.Limitations)
+ [
# Aktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Enabling.md)
+ [
## Erstellen der Optionsgruppe für `RESOURCE_GOVERNOR`
](ResourceGovernor.Enabling.md#ResourceGovernor.OptionGroup)
+ [
## Hinzufügen der `RESOURCE_GOVERNOR`-Option zur Optionsgruppe
](ResourceGovernor.Enabling.md#ResourceGovernor.Add)
+ [
## Zuordnen der Optionsgruppe zu Ihrer DB-Instance
](ResourceGovernor.Enabling.md#ResourceGovernor.Apply)
+ [
# Verwenden von Microsoft SQL Server Resource Governor für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Using.md)
+ [
## Ressourcenpool verwalten
](ResourceGovernor.Using.md#ResourceGovernor.ManageResourcePool)
+ [
### Ressourcenpool erstellen
](ResourceGovernor.Using.md#ResourceGovernor.CreateResourcePool)
+ [
### Ressourcenpool ändern
](ResourceGovernor.Using.md#ResourceGovernor.AlterResourcePool)
+ [
### Ressourcenpool löschen
](ResourceGovernor.Using.md#ResourceGovernor.DropResourcePool)
+ [
## Arbeitslastgruppen verwalten
](ResourceGovernor.Using.md#ResourceGovernor.ManageWorkloadGroups)
+ [
### Workload-Gruppe erstellen
](ResourceGovernor.Using.md#ResourceGovernor.CreateWorkloadGroup)
+ [
### Workload-Gruppe ändern
](ResourceGovernor.Using.md#ResourceGovernor.AlterWorkloadGroup)
+ [
### Workload-Gruppe löschen
](ResourceGovernor.Using.md#ResourceGovernor.DropWorkloadGroup)
+ [
## Klassifikatorfunktion erstellen und registrieren
](ResourceGovernor.Using.md#ResourceGovernor.ClassifierFunction)
+ [
## Klassifizierer-Funktion löschen
](ResourceGovernor.Using.md#ResourceGovernor.DropClassifier)
+ [
## Klassifikatorfunktion deregistrieren
](ResourceGovernor.Using.md#ResourceGovernor.DeregisterClassifier)
+ [
## Statistik zurücksetzen
](ResourceGovernor.Using.md#ResourceGovernor.ResetStats)
+ [
## Änderungen der Konfiguration von Resource Governor
](ResourceGovernor.Using.md#ResourceGovernor.ConfigChanges)
+ [
## TempDB an einen Ressourcenpool binden
](ResourceGovernor.Using.md#ResourceGovernor.BindTempDB)
+ [
## TempDB von einem Ressourcenpool trennen
](ResourceGovernor.Using.md#ResourceGovernor.UnbindTempDB)
+ [
## Steuerung der Ressourcen für Cleanup
](ResourceGovernor.Using.md#ResourceGovernor.Cleanup)
+ [
## Überlegungen zur Multi-AZ-Bereitstellung
](#ResourceGovernor.Considerations)
+ [
## Überlegungen zu Read Replicas
](#ResourceGovernor.ReadReplica)
+ [
# Überwachen Sie die Microsoft SQL Server-Ressourcenkontrolle mithilfe von Systemansichten für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Monitoring.md)
+ [
## Laufzeitstatistiken für den Ressourcenpool
](ResourceGovernor.Monitoring.md#ResourceGovernor.ResourcePoolStats)
+ [
# Deaktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Disabling.md)
+ [
# Bewährte Methoden für die Konfiguration von Resource Governor auf RDS für SQL Server
](ResourceGovernor.BestPractices.md)
## Unterstützte Versionen und Regionen
Amazon RDS unterstützt Resource Governor für die folgenden SQL Server-Versionen und -Editionen in allen Ländern AWS-Regionen , in denen RDS für SQL Server verfügbar ist:
+ SQL Server 2022 Developer- und Enterprise-Editionen
+ SQL Server 2019 Enterprise Edition
+ SQL Server 2017 Enterprise Edition
+ SQL Server 2016 Enterprise Edition
## Einschränkungen und Empfehlungen
Die folgenden Einschränkungen und Empfehlungen gelten für Resource Governor:
+ Editions- und Serviceeinschränkungen:
+ Nur in der SQL Server Enterprise Edition verfügbar.
+ Die Ressourcenverwaltung ist auf die SQL Server Database Engine beschränkt. Die Ressourcenkontrolle für Analysis Services, Integration Services und Reporting Services wird nicht unterstützt.
+ Einschränkungen bei der Konfiguration:
+ Muss für alle Konfigurationen gespeicherte Amazon RDS-Prozeduren verwenden.
+ Systemeigene DDL-Anweisungen und SQL Server Management Studio-GUI-Konfigurationen werden nicht unterstützt.
+ Parameter des Ressourcenpools:
+ Poolnamen, die mit beginnen, werden `rds_` nicht unterstützt.
+ Interne und standardmäßige Änderungen am Ressourcenpool sind nicht zulässig.
+ Für die benutzerdefinierten Ressourcenpools werden die folgenden Ressourcenpoolparameter nicht unterstützt:
+ `MIN_MEMORY_PERCENT`
+ `MIN_CPU_PERCENT`
+ `MIN_IOPS_PER_VOLUME`
+ `AFFINITY`
+ Parameter der Workload-Gruppe:
+ Workload-Gruppennamen, die mit beginnen, werden `rds_` nicht unterstützt.
+ Eine Änderung der internen Workload-Gruppe ist nicht zulässig.
+ Für die Standard-Workload-Gruppe:
+ Nur der `REQUEST_MAX_MEMORY_GRANT_PERCENT` Parameter kann geändert werden.
+ Für die Standard-Workload-Gruppe `REQUEST_MAX_MEMORY_GRANT_PERCENT` muss der Wert zwischen 1 und 70 liegen.
+ Alle anderen Parameter sind gesperrt und können nicht geändert werden.
+ Benutzerdefinierte Workload-Gruppen ermöglichen die Änderung aller Parameter.
+ Einschränkungen der Classifier-Funktion:
+ Die Classifier-Funktion leitet Verbindungen zu benutzerdefinierten Workload-Gruppen auf der Grundlage bestimmter Kriterien (Benutzername, Datenbank, Host oder Anwendungsname) weiter.
+ Unterstützt bis zu zwei benutzerdefinierte Workload-Gruppen mit ihren jeweiligen Routing-Bedingungen.
+ Kombiniert Kriterien mit `AND` Bedingungen innerhalb jeder Gruppe.
+ Erfordert mindestens ein Routingkriterium pro Workload-Gruppe.
+ Nur die oben aufgeführten Klassifizierungsmethoden werden unterstützt.
+ Der Funktionsname muss mit beginnen`rg_classifier_`.
+ Standardgruppenzuweisung, wenn keine Bedingungen erfüllt sind.
# Aktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
Aktivieren Sie Resource Governor, indem Sie die `RESOURCE_GOVERNOR` Option zu Ihrer RDS for SQL Server-DB-Instance hinzufügen. Verwenden Sie den folgenden Prozess:
1. Erstellen Sie eine neue Optionsgruppe oder wählen Sie eine bestehende Optionsgruppe aus.
1. Fügen Sie die Option `RESOURCE_GOVERNOR` zur Optionsgruppe hinzu.
1. Ordnen Sie die Optionsgruppe der DB-Instance zu.
**Anmerkung**
Für die Aktivierung von Resource Governor über eine Optionsgruppe ist kein Neustart erforderlich.
## Erstellen der Optionsgruppe für `RESOURCE_GOVERNOR`
Um Resource Governor zu aktivieren, erstellen Sie eine Optionsgruppe oder ändern Sie eine Optionsgruppe, die der SQL Server-Edition und Version der DB-Instance entspricht, die Sie verwenden möchten. Um dieses Verfahren abzuschließen, verwenden Sie den AWS-Managementkonsole oder den AWS CLI.
### Konsole
Verwenden Sie das folgende Verfahren, um eine Optionsgruppe für SQL Server Enterprise Edition 2022 zu erstellen.
**So erstellen Sie die Optionsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group** (Gruppe erstellen) aus.
1. Führen Sie im Fenster **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie unter **Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihres AWS Kontos eindeutig ist, z. **resource-governor-ee-2022** B. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein, z. B. **RESOURCE\$1GOVERNOR option group for SQL Server EE 2022**. Die Beschreibung ist nur zur Information.
1. Wählen Sie für **Engine** die Option **sqlserver-ee** aus.
1. **Wählen Sie **16.00 für Major-Engine-Version** aus.**
1. Wählen Sie **Erstellen** aus.
### CLI
Mit dem folgenden Verfahren wird eine Optionsgruppe für SQL Server Enterprise Edition 2022 erstellt.
**So erstellen Sie die Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name resource-governor-ee-2022 \
--engine-name sqlserver-ee \
--major-engine-version 16.00 \
--option-group-description "RESOURCE_GOVERNOR option group for SQL Server EE 2022"
```
Für Windows:
```
aws rds create-option-group ^
--option-group-name resource-governor-ee-2022 ^
--engine-name sqlserver-ee ^
--major-engine-version 16.00 ^
--option-group-description "RESOURCE_GOVERNOR option group for SQL Server EE 2022"
```
## Hinzufügen der `RESOURCE_GOVERNOR`-Option zur Optionsgruppe
Verwenden Sie als Nächstes das AWS-Managementkonsole oder, AWS CLI um die `RESOURCE_GOVERNOR` Option zu Ihrer Optionsgruppe hinzuzufügen.
### Konsole
**Um die Option RESOURCE\$1GOVERNOR hinzuzufügen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe, die Sie gerade erstellt haben, in diesem Beispiel **resource-governor-ee-2022**.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. **Wählen Sie unter **Optionsdetails** **RESOURCE\$1GOVERNOR** als Optionsnamen aus.**
1. Wählen Sie unter **Planung** aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
### CLI
**So fügen Sie die Option `RESOURCE_GOVERNOR` hinzu**
+ Fügen Sie die Option `RESOURCE_GOVERNOR` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--option-group-name resource-governor-ee-2022 \
--options "OptionName=RESOURCE_GOVERNOR" \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name resource-governor-ee-2022 ^
--options "OptionName=RESOURCE_GOVERNOR" ^
--apply-immediately
```
## Zuordnen der Optionsgruppe zu Ihrer DB-Instance
Um die `RESOURCE_GOVERNOR` Optionsgruppe Ihrer DB-Instance zuzuordnen, verwenden Sie den oder den AWS-Managementkonsole . AWS CLI
### Konsole
Um die Aktivierung von Resource Governor abzuschließen, ordnen Sie Ihre `RESOURCE_GOVERNOR` Optionsgruppe einer neuen oder vorhandenen DB-Instance zu:
+ Ordnen Sie sie bei einer neuen DB-Instance zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ordnen Sie sie für eine vorhandene DB-Instance zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### CLI
Sie können die `RESOURCE_GOVERNOR` Optionsgruppe einer neuen oder vorhandenen DB-Instance zuordnen.
**Um eine Instance mit der `RESOURCE_GOVERNOR` Optionsgruppe zu erstellen**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier mytestsqlserverresourcegovernorinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-ee \
--engine-version 16.00 \
--license-model license-included \
--allocated-storage 100 \
--master-username admin \
--master-user-password password \
--storage-type gp2 \
--option-group-name resource-governor-ee-2022
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mytestsqlserverresourcegovernorinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-ee ^
--engine-version 16.00 ^
--license-model license-included ^
--allocated-storage 100 ^
--master-username admin ^
--master-user-password password ^
--storage-type gp2 ^
--option-group-name resource-governor-ee-2022
```
**So ändern Sie eine Instance, um die `RESOURCE_GOVERNOR`-Optionsgruppe zuzuordnen**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mytestinstance \
--option-group-name resource-governor-ee-2022 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mytestinstance ^
--option-group-name resource-governor-ee-2022 ^
--apply-immediately
```
# Verwenden von Microsoft SQL Server Resource Governor für Ihre RDS for SQL Server-Instanz
Nachdem Sie die Option Resource Governor zu Ihrer Optionsgruppe hinzugefügt haben, ist Resource Governor auf Datenbank-Engine-Ebene noch nicht aktiv. Um die Ressourcenkontrolle vollständig zu aktivieren, müssen Sie die gespeicherten Prozeduren von RDS für SQL Server verwenden, um sie zu aktivieren und die erforderlichen Resource Governor-Objekte zu erstellen. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Stellen Sie zunächst eine Verbindung zu Ihrer SQL Server-Datenbank her und rufen Sie dann die entsprechenden gespeicherten RDS-Prozeduren für SQL Server auf, um die Konfiguration abzuschließen. Anleitungen zum Herstellen einer Verbindung zu Ihrer Datenbank finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Anleitungen zum Aufrufen der einzelnen gespeicherten Prozeduren finden Sie in den folgenden Themen:
**Topics**
+ [
## Ressourcenpool verwalten
](#ResourceGovernor.ManageResourcePool)
+ [
## Arbeitslastgruppen verwalten
](#ResourceGovernor.ManageWorkloadGroups)
+ [
## Klassifikatorfunktion erstellen und registrieren
](#ResourceGovernor.ClassifierFunction)
+ [
## Klassifizierer-Funktion löschen
](#ResourceGovernor.DropClassifier)
+ [
## Klassifikatorfunktion deregistrieren
](#ResourceGovernor.DeregisterClassifier)
+ [
## Statistik zurücksetzen
](#ResourceGovernor.ResetStats)
+ [
## Änderungen der Konfiguration von Resource Governor
](#ResourceGovernor.ConfigChanges)
+ [
## TempDB an einen Ressourcenpool binden
](#ResourceGovernor.BindTempDB)
+ [
## TempDB von einem Ressourcenpool trennen
](#ResourceGovernor.UnbindTempDB)
+ [
## Steuerung der Ressourcen für Cleanup
](#ResourceGovernor.Cleanup)
## Ressourcenpool verwalten
### Ressourcenpool erstellen
Sobald Resource Governor in der Optionsgruppe aktiviert ist, können Sie benutzerdefinierte Ressourcenpools mithilfe von erstellen`rds_create_resource_pool`. Mit diesen Pools können Sie verschiedenen Workloads bestimmte Prozentsätze an CPU, Arbeitsspeicher und IOPS zuweisen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_create_resource_pool
@pool_name=value,
@MAX_CPU_PERCENT=value,
@CAP_CPU_PERCENT=value,
@MAX_MEMORY_PERCENT=value,
@MAX_IOPS_PER_VOLUME=value
```
Die folgenden Parameter sind erforderlich:
+ `@group_name`- Ist der Name einer vorhandenen benutzerdefinierten Workload-Gruppe.
+ `@pool_name`- Ist der benutzerdefinierte Name für den Ressourcenpool. *pool\$1name*ist alphanumerisch, kann bis zu 128 Zeichen lang sein, muss innerhalb einer Database Engine-Instanz eindeutig sein und muss den Regeln für Datenbankbezeichner entsprechen.
Die folgenden Parameter sind optional:
+ `@MAX_CPU_PERCENT`- Gibt die maximale durchschnittliche CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten, wenn es zu einem CPU-Konflikt kommt. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@CAP_CPU_PERCENT`— Gibt eine feste Obergrenze für die CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten. Schränkt die maximale CPU-Bandbreite auf den angegebenen Wert ein. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_MEMORY_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die Anfragen in diesem Ressourcenpool verwenden können. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_IOPS_PER_VOLUME`- Gibt die maximale Anzahl von I/O Vorgängen pro Sekunde (IOPS) pro Festplattenvolume an, die für den Ressourcenpool zulässig sind. Der zulässige Bereich für *value* liegt zwischen 0 und 2^31-1 (2.147.483.647). Geben Sie 0 an, um ein IOPS-Limit für den Pool aufzuheben. Der Standardwert ist 0.
**Beispiele**
Beispiel für die Erstellung eines Ressourcenpools mit allen Standardwerten:
```
--This creates resource pool 'SalesPool' with all default values
USE [msdb]
EXEC rds_create_resource_pool @pool_name = 'SalesPool';
--Apply changes
USE [msdb]
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_resource_pools
```
Beispiel für die Erstellung eines Ressourcenpools mit verschiedenen angegebenen Parametern:
```
--creates resource pool
USE [msdb]
EXEC dbo.rds_create_resource_pool
@pool_name='analytics',
@MAX_CPU_PERCENT = 30,
@CAP_CPU_PERCENT = 40,
@MAX_MEMORY_PERCENT = 20;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_resource_pools
```
### Ressourcenpool ändern
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_pool
@pool_name=value,
@MAX_CPU_PERCENT=value,
@CAP_CPU_PERCENT=value,
@MAX_MEMORY_PERCENT=value,
@MAX_IOPS_PER_VOLUME=value;
```
Die folgenden Parameter sind erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools. Das Ändern des Standardressourcenpools ist in Amazon RDS SQL Server nicht zulässig.
Mindestens einer der optionalen Parameter muss angegeben werden:
+ `@MAX_CPU_PERCENT`- Gibt die maximale durchschnittliche CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten, wenn es zu einem CPU-Konflikt kommt. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@CAP_CPU_PERCENT`— Gibt eine feste Obergrenze für die CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten. Schränkt die maximale CPU-Bandbreite auf den angegebenen Wert ein. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_MEMORY_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die Anfragen in diesem Ressourcenpool verwenden können. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_IOPS_PER_VOLUME`- Gibt die maximale Anzahl von I/O Vorgängen pro Sekunde (IOPS) pro Festplattenvolume an, die für den Ressourcenpool zulässig sind. Der zulässige Bereich für *value* liegt zwischen 0 und 2^31-1 (2.147.483.647). Geben Sie 0 an, um ein IOPS-Limit für den Pool aufzuheben. Der Standardwert ist 0.
**Beispiele**
```
--This alters resource pool
USE [msdb]
EXEC dbo.rds_alter_resource_pool
@pool_name='analytics',
@MAX_CPU_PERCENT = 10,
@CAP_CPU_PERCENT = 20,
@MAX_MEMORY_PERCENT = 50;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration.
select * from sys.resource_governor_resource_pools
```
### Ressourcenpool löschen
**Usage**
```
USE [msdb]
EXEC dbo.rds_drop_resource_pool
@pool_name=value;
```
Der folgende Parameter ist erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools.
**Anmerkung**
Das Löschen des internen oder Standardressourcenpools ist in SQL Server nicht zulässig.
**Beispiele**
```
--This drops resource pool
USE [msdb]
EXEC dbo.rds_drop_resource_pool
@pool_name='analytics'
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_resource_pools
```
## Arbeitslastgruppen verwalten
Workload-Gruppen, die mit und erstellt `rds_create_workload_group` und verwaltet werden`rds_alter_workload_group`, ermöglichen es Ihnen, Wichtigkeitsstufen, Speicherzuweisungen und andere Parameter für Gruppen von Abfragen festzulegen.
### Workload-Gruppe erstellen
**Usage**
```
USE [msdb]
EXEC dbo.rds_create_workload_group
@group_name = value,
@IMPORTANCE ={ LOW | MEDIUM | HIGH },
@REQUEST_MAX_MEMORY_GRANT_PERCENT =value,
@REQUEST_MAX_CPU_TIME_SEC = value ,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = value,
@MAX_DOP = value,
@GROUP_MAX_REQUESTS = value,
@pool_name = value
```
Die folgenden Parameter sind erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools.
+ `@group_name`- Ist der Name einer vorhandenen benutzerdefinierten Workload-Gruppe.
Die folgenden Parameter sind optional:
+ `@IMPORTANCE`— Gibt die relative Wichtigkeit einer Anfrage in der Workload-Gruppe an. Der Standardwert ist `MEDIUM`.
+ `@REQUEST_MAX_MEMORY_GRANT_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die eine einzelne Anforderung aus dem Pool beanspruchen kann. *value*ist ein Prozentsatz der Ressourcenpoolgröße, definiert durch`MAX_MEMORY_PERCENT`. Der Standardwert ist 25.
+ `@REQUEST_MAX_CPU_TIME_SEC`- Gibt die maximale CPU-Zeit in Sekunden an, die eine Batch-Anfrage verwenden kann. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0, was unbegrenzt bedeutet.
+ `@REQUEST_MEMORY_GRANT_TIMEOUT_SEC`- Gibt die maximale Zeit in Sekunden an, für die eine Abfrage warten kann, bis eine Speicherzuweisung aus dem Abfrage-Workspace-Speicher verfügbar wird. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* 0 verwendet eine interne Berechnung, die auf den Abfragekosten basiert, um die maximale Zeit zu bestimmen.
+ `@MAX_DOP`- Gibt den maximalen Grad an Parallelität (`MAXDOP`) für die parallel Abfrageausführung an. Der zulässige Bereich für *value* liegt zwischen 0 und 64. Die Standardeinstellung für *value* 0 verwendet die globale Einstellung.
+ `@GROUP_MAX_REQUESTS`= Gibt die maximale Anzahl gleichzeitiger Anfragen an, die in der Workload-Gruppe ausgeführt werden dürfen. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0 und erlaubt eine unbegrenzte Anzahl von Anfragen.
+ `@pool_name`= Ordnet die Workload-Gruppe dem benutzerdefinierten Ressourcenpool zu, der durch den Ressourcenpool identifiziert wird*pool\$1name*, oder mit dem `default` Ressourcenpool. Wenn *pool\$1name* nicht angegeben, ist die Workload-Gruppe dem integrierten `default` Pool zugeordnet.
**Beispiele**
```
--This creates workload group named 'analytics'
USE msdb;
EXEC dbo.rds_create_workload_group
@group_name = 'analytics',
@IMPORTANCE = 'HIGH',
@REQUEST_MAX_MEMORY_GRANT_PERCENT = 25,
@REQUEST_MAX_CPU_TIME_SEC = 0,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = 0,
@MAX_DOP = 0,
@GROUP_MAX_REQUESTS = 0,
@pool_name = 'analytics';
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_workload_groups
```
### Workload-Gruppe ändern
**Usage**
```
EXEC msdb.dbo.rds_alter_workload_group
@group_name = value,
@IMPORTANCE = 'LOW|MEDIUM|HIGH',
@REQUEST_MAX_MEMORY_GRANT_PERCENT = value,
@REQUEST_MAX_CPU_TIME_SEC = value,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = value,
@MAX_DOP = value,
@GROUP_MAX_REQUESTS = value,
@pool_name = value
```
Die folgenden Parameter sind erforderlich:
+ `@group_name`- Ist der Name einer Standard-Workload-Gruppe oder einer vorhandenen benutzerdefinierten Workload-Gruppe.
**Anmerkung**
Es `REQUEST_MAX_MEMORY_GRANT_PERCENT` wird nur das Ändern von Parametern in der Standard-Workload-Gruppe unterstützt. Für die Standard-Workload-Gruppe `REQUEST_MAX_MEMORY_GRANT_PERCENT` muss der Wert zwischen 1 und 70 liegen. In der Standard-Workload-Gruppe können keine anderen Parameter geändert werden. Alle Parameter können in der benutzerdefinierten Workload-Gruppe geändert werden.
Die folgenden Parameter sind optional:
+ `@IMPORTANCE`- Gibt die relative Wichtigkeit einer Anfrage in der Workload-Gruppe an. Der Standardwert ist MEDIUM.
+ `@REQUEST_MAX_MEMORY_GRANT_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die eine einzelne Anforderung aus dem Pool beanspruchen kann. *value*ist ein Prozentsatz der Ressourcenpoolgröße, definiert durch`MAX_MEMORY_PERCENT`. Der Standardwert ist 25. Bei Amazon RDS `REQUEST_MAX_MEMORY_GRANT_PERCENT` muss der Wert zwischen 1 und 70 liegen.
+ `@REQUEST_MAX_CPU_TIME_SEC`- Gibt die maximale CPU-Zeit in Sekunden an, die eine Batch-Anfrage verwenden kann. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0, was unbegrenzt bedeutet.
+ `@REQUEST_MEMORY_GRANT_TIMEOUT_SEC`- Gibt die maximale Zeit in Sekunden an, für die eine Abfrage warten kann, bis eine Speicherzuweisung aus dem Abfrage-Workspace-Speicher verfügbar wird. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* 0 verwendet eine interne Berechnung, die auf den Abfragekosten basiert, um die maximale Zeit zu bestimmen.
+ `@MAX_DOP`- Gibt den maximalen Grad an Parallelität (MAXDOP) für die parallel Abfrageausführung an. Der zulässige Bereich für *value* liegt zwischen 0 und 64. Die Standardeinstellung für *value* 0 verwendet die globale Einstellung.
+ `@GROUP_MAX_REQUESTS`— Gibt die maximale Anzahl gleichzeitiger Anfragen an, die in der Workload-Gruppe ausgeführt werden dürfen. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0 und erlaubt eine unbegrenzte Anzahl von Anfragen.
+ `@pool_name`- Ordnet die Workload-Gruppe dem benutzerdefinierten Ressourcenpool zu, der durch identifiziert wird*pool\$1name*.
**Beispiele**
Beispiel für die Änderung der Standard-Workload-Gruppe REQUEST\$1MAX\$1MEMORY\$1GRANT\$1PERCENT:
```
--Modify default workload group (set memory grant cap to 10%)
USE msdb
EXEC dbo.rds_alter_workload_group
@group_name = 'default',
@REQUEST_MAX_MEMORY_GRANT_PERCENT=10;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
SELECT * FROM sys.resource_governor_workload_groups WHERE name='default';
```
Beispiel für die Änderung einer nicht standardmäßigen Workload-Gruppe:
```
EXEC msdb.dbo.rds_alter_workload_group
@group_name = 'analytics',
@IMPORTANCE = 'HIGH',
@REQUEST_MAX_MEMORY_GRANT_PERCENT = 30,
@REQUEST_MAX_CPU_TIME_SEC = 3600,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = 60,
@MAX_DOP = 4,
@GROUP_MAX_REQUESTS = 100;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
```
Beispiel für das Verschieben einer nicht standardmäßigen Workload-Gruppe in einen anderen Ressourcenpool:
```
EXEC msdb.dbo.rds_alter_workload_group
@group_name = 'analytics',
@pool_name='abc'
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_workload_groups
```
### Workload-Gruppe löschen
**Usage**
```
EXEC msdb.dbo.rds_drop_workload_group
@group_name = value
```
Die folgenden Parameter sind erforderlich:
+ `@group_name`- Ist der Name einer vorhandenen benutzerdefinierten Workload-Gruppe.
**Beispiele**
```
--Drops a Workload Group:
EXEC msdb.dbo.rds_drop_workload_group
@group_name = 'analytics';
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_workload_groups
```
## Klassifikatorfunktion erstellen und registrieren
Dieses Verfahren erstellt eine Classifier-Funktion für die Ressourcenkontrolle in der Master-Datenbank, die Verbindungen zu benutzerdefinierten Workload-Gruppen auf der Grundlage bestimmter Kriterien (Benutzername, Datenbank, Host oder Anwendungsname) weiterleitet. Wenn die Ressourcenkontrolle aktiviert ist und in der Konfiguration der Ressourcenkontrolle eine Klassifizierungsfunktion angegeben ist, bestimmt die Funktionsausgabe die für neue Sitzungen verwendete Workload-Gruppe. In Ermangelung einer Klassifizierungsfunktion werden alle Sitzungen der `default` Gruppe zugeordnet.
**Features:**
+ Unterstützt bis zu zwei Workload-Gruppen mit ihren jeweiligen Routing-Bedingungen.
+ Kombiniert Kriterien mit `AND` Bedingungen innerhalb jeder Gruppe.
+ Erfordert mindestens ein Routingkriterium pro Workload-Gruppe.
+ Der Funktionsname muss mit beginnen`rg_classifier_`.
+ Standardgruppenzuweisung, wenn keine Bedingungen erfüllt sind.
Die Klassifizierungsfunktion weist die folgenden Eigenschaften und Verhaltensweisen auf:
+ Die Funktion ist im Serverbereich (in der Master-Datenbank) definiert.
+ Die Funktion ist mit Schemabindung definiert.
+ Die Funktion wird für jede neue Sitzung ausgewertet, auch wenn das Verbindungspooling aktiviert ist.
+ Die Funktion gibt den Workload-Gruppenkontext für die Sitzung zurück. Die Sitzung wird der vom Classifier zurückgegebenen Workload-Gruppe für die Dauer der Sitzung zugewiesen.
+ Wenn die Funktion NULL, Standard oder den Namen einer nicht existierenden Workload-Gruppe zurückgibt, wird der Sitzung der Standard-Workload-Gruppenkontext zugewiesen. Der Sitzung wird außerdem der Standardkontext zugewiesen, falls die Funktion aus irgendeinem Grund fehlschlägt.
+ Sie können mehrere Klassifikatorfunktionen erstellen. In SQL Server kann jedoch jeweils nur eine Klassifikatorfunktion registriert werden.
+ Die Klassifiziererfunktion kann nur gelöscht werden, wenn ihr Klassifiziererstatus mithilfe der Deregistrierungsprozedur (`EXEC dbo.msdb.rds_alter_resource_governor_configuration @deregister_function = 1;`) entfernt wird, die den Funktionsnamen auf NULL setzt, oder es wird eine andere Klassifiziererfunktion mit () registriert `EXEC dbo.msdb.rds_alter_resource_governor_configuration @classifier_function = ;`
+ In Ermangelung einer Klassifizierungsfunktion werden alle Sitzungen in die Standardgruppe eingeteilt.
+ Sie können eine Klassifikatorfunktion nicht ändern, solange sie in der Resource Governor-Konfiguration referenziert wird. Sie können die Konfiguration jedoch ändern, um eine andere Klassifizierungsfunktion zu verwenden. Wenn Sie Änderungen am Klassifikator vornehmen möchten, sollten Sie erwägen, ein Paar von Klassifikatorfunktionen zu erstellen. Sie könnten beispielsweise und erstellen`rg_classifier_a`. `rg_classifier_b`
**Usage**
```
EXEC msdb.dbo.rds_create_classifier_function
@function_name = value,
@workload_group1 = value,
@user_name1 = value,
@db_name1 = value,
@host_name1 = value,
@app_name1 = value,
@workload_group2 = value,
@user_name2 = value,
@db_name2 = value,
@host_name2 = value,
@app_name2 = value
```
Die folgenden Parameter sind erforderlich:
+ `@function_name`- Name der Klassifikatorfunktion. Muss beginnen mit `rg_classifier_`
+ `@workload_group1`- Name der ersten Workload-Gruppe
Die folgenden Parameter sind optional:
(Mindestens eines dieser Kriterien muss für Gruppe 1 angegeben werden)
+ `@user_name1`- Anmeldename für Gruppe 1
+ `@db_name1`- Datenbankname für Gruppe 1
+ `@host_name1`- Hostname für Gruppe 1
+ `@app_name1`- Anwendungsname für Gruppe 1
(Wenn Gruppe 2 angegeben ist, muss mindestens ein Kriterium angegeben werden)
+ `@workload_group2`- Name der zweiten Workload-Gruppe
+ `@user_name2`- Anmeldename für Gruppe 2
+ `@db_name2`- Datenbankname für Gruppe 2
+ `@host_name2`- Hostname für Gruppe 2
+ `@app_name2`- Anwendungsname für Gruppe 2
**Anmerkung**
Systemkonten, Datenbanken, Anwendungen und Hosts sind eingeschränkt.
**Beispiele**
Einfaches Beispiel mit einer Workload-Gruppe:
```
/*Create a classifier to route all requests from 'PowerBI' app to workload group
'reporting_group'*/
EXEC msdb.dbo.rds_create_classifier_function
@function_name = 'rg_classifier_a',
@workload_group1 = 'reporting_group',
@app_name1 = 'PowerBI';
--Register the classifier
EXEC msdb.dbo.rds_alter_resource_governor_configuration
@classifier_function = 'rg_classifier_a';
-- Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration
/*Query sys.resource_governor_configuration to validate that resource governor is enabled and is using the classifier function we created and registered*/
use master
go
SELECT OBJECT_SCHEMA_NAME(classifier_function_id) AS classifier_schema_name,
OBJECT_NAME(classifier_function_id) AS classifier_object_name,
is_enabled
FROM sys.resource_governor_configuration;
```
## Klassifizierer-Funktion löschen
**Usage**
```
USE [msdb]
EXEC dbo.rds_drop_classifier_function
@function_name = value;
```
Der folgende Parameter ist erforderlich:
+ `@function_name`- Ist der Name einer vorhandenen benutzerdefinierten Klassifikatorfunktion
**Beispiel**
```
EXEC msdb.dbo.rds_drop_classifier_function
@function_name = 'rg_classifier_b';
```
## Klassifikatorfunktion deregistrieren
Gehen Sie wie folgt vor, um die Registrierung der Klassifikatorfunktion aufzuheben. Nachdem die Registrierung der Funktion aufgehoben wurde, werden neue Sitzungen automatisch der Standard-Workload-Gruppe zugewiesen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_governor_configuration
@deregister_function = 1;
```
Für die Abmeldung ist der folgende Parameter erforderlich:
+ `@deregister_function`muss 1 sein
**Beispiel**
```
EXEC msdb.dbo.rds_alter_resource_governor_configuration
@deregister_function = 1;
GO
-- Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
```
## Statistik zurücksetzen
Die Resource Governor-Statistiken sind seit dem letzten Serverneustart kumulativ. Wenn Sie ab einem bestimmten Zeitpunkt Statistiken sammeln müssen, können Sie die Statistiken mithilfe der folgenden gespeicherten Amazon RDS-Prozedur zurücksetzen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_governor_configuration
@reset_statistics = 1;
```
Zum Zurücksetzen von Statistiken ist der folgende Parameter erforderlich:
+ `@reset_statistics`muss 1 sein
## Änderungen der Konfiguration von Resource Governor
Wenn Resource Governor nicht aktiviert ist, `rds_alter_resource_governor_configuration` aktiviert Resource Governor. Die Aktivierung der Ressourcenkontrolle hat folgende Ergebnisse:
+ Die Klassifizierungsfunktion, falls vorhanden, wird für neue Sitzungen ausgeführt, wobei sie Workload-Gruppen zugewiesen werden.
+ Die in der Resource Governor-Konfiguration angegebenen Ressourcengrenzwerte werden eingehalten und durchgesetzt.
+ Die in der Resource Governor-Konfiguration angegebenen Ressourcengrenzwerte werden eingehalten und durchgesetzt.
+ Anfragen, die vor der Aktivierung von Resource Governor bestanden haben, können von Konfigurationsänderungen betroffen sein, die bei der Aktivierung von Resource Governor vorgenommen wurden.
+ Bestehende Anfragen, bevor Resource Governor aktiviert wurde, können von allen Konfigurationsänderungen betroffen sein, die vorgenommen wurden, wenn Resource Governor aktiviert wurde.
+ Auf RDS für SQL Server `EXEC msdb.dbo.rds_alter_resource_governor_configuration` müssen alle Änderungen an der Resource Governor-Konfiguration ausgeführt werden, damit sie wirksam werden.
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_governor_configuration
```
## TempDB an einen Ressourcenpool binden
Mithilfe von Amazon RDS SQL Server Version 2019 und höher können Sie speicheroptimierte tempdb-Metadaten `rds_bind_tempdb_metadata_to_resource_pool` an einen bestimmten Ressourcenpool binden.
**Anmerkung**
Die speicheroptimierte Tempdb-Metadatenfunktion muss aktiviert werden, bevor tempdb-Metadaten an den Ressourcenpool gebunden werden können. Um diese Funktion auf Amazon RDS zu aktivieren, ist es ein statischer Parameter`tempdb metadata memory-optimized`.
Aktivieren Sie den statischen Parameter auf Amazon RDS und führen Sie einen Neustart ohne Failover durch, damit der Parameter wirksam wird:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name test-sqlserver-ee-2022 \
--parameters "ParameterName='tempdb metadata memory-optimized',ParameterValue=True,ApplyMethod=pending-reboot"
```
**Usage**
```
USE [msdb]
EXEC dbo.rds_bind_tempdb_metadata_to_resource_pool
@pool_name=value;
```
Der folgende Parameter ist erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools.
**Anmerkung**
Diese Änderung erfordert außerdem einen Neustart des SQL-Dienstes ohne Failover, damit sie wirksam wird, auch wenn die speicheroptimierte TempDB-Metadatenfunktion bereits aktiviert ist.
## TempDB von einem Ressourcenpool trennen
Entbindet speicheroptimierte tempdb-Metadaten aus einem Ressourcenpool.
**Anmerkung**
Diese Änderung erfordert außerdem einen Neustart des SQL-Dienstes ohne Failover, um wirksam zu werden
**Usage**
```
USE [msdb]
EXEC dbo.rds_unbind_tempdb_metadata_from_resource_pool
```
## Steuerung der Ressourcen für Cleanup
Mit diesem Verfahren werden alle zugehörigen Objekte bereinigt, nachdem Sie die Option „Ressourcenkontrolle“ aus der Optionsgruppe entfernt haben. Dadurch wird die Ressourcenkontrolle deaktiviert, die Standard-Workload-Gruppe auf die Standardeinstellungen zurückgesetzt und benutzerdefinierte Workload-Gruppen, Ressourcenpools und Klassifizierungsfunktionen entfernt.
**Schlüsselfunktionen**
+ Setzt die Standard-Workload-Gruppe auf die Standardeinstellungen zurück
+ Deaktiviert den Ressourcengouverneur
+ Entfernt benutzerdefinierte Workload-Gruppen
+ Entfernt benutzerdefinierte Ressourcenpools
+ Löscht Klassifikatorfunktionen
+ Entfernt die Tempdb-Ressourcenpool-Bindung, falls sie aktiviert ist
**Wichtig**
Bei dieser Bereinigung kann ein Fehler auftreten, wenn in der Workload-Gruppe aktive Sitzungen vorhanden sind. Warten Sie entweder, bis die aktiven Sitzungen abgeschlossen sind, oder beenden Sie die aktiven Sitzungen gemäß Ihren Geschäftsanforderungen. Es wird empfohlen, dies während des Wartungsfensters auszuführen.
Bei dieser Bereinigung kann ein Fehler auftreten, wenn ein Ressourcenpool an tempdb gebunden war und ein Neustart ohne Failover noch nicht stattgefunden hat. Wenn Sie zuvor einen Ressourcenpool an tempdb gebunden oder einen Ressourcenpool von tempdb getrennt haben, führen Sie einen Neustart ohne Failover durch, damit die Änderung wirksam wird. Es wird empfohlen, dies während des Wartungsfensters auszuführen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_cleanup_resource_governor
```
## Überlegungen zur Multi-AZ-Bereitstellung
RDS für SQL Server repliziert Resource Governor auf eine sekundäre Instanz in einer Multi-AZ-Bereitstellung. Sie können überprüfen, wann der geänderte und der neue Resource Governor zuletzt mit der sekundären Instanz synchronisiert wurden.
Verwenden Sie die folgende Abfrage, um die `last_sync_time` Replikation zu überprüfen:
```
SELECT * from msdb.dbo.rds_fn_server_object_last_sync_time();
```
Wenn in den Abfrageergebnissen die Synchronisierungszeit nach der Aktualisierungs- oder Erstellungszeit der Ressourcenkontrolle liegt, wird die Ressourcenkontrolle mit der Sekundärseite synchronisiert.
Um ein manuelles DB-Failover durchzuführen, um zu bestätigen, dass der Resource Governor repliziert, warten Sie zunächst, `last_sync_time` bis der aktualisiert wird. Fahren Sie dann mit dem Multi-AZ-Failover fort.
## Überlegungen zu Read Replicas
+ Verwenden Sie für SQL Server-Replikate in derselben Region wie die Quell-DB-Instance dieselbe Optionsgruppe wie die Quelle. Änderungen an der Optionsgruppe werden unabhängig von ihren Wartungsfenstern sofort auf die Replikate übertragen.
+ Wenn Sie ein regionsübergreifendes SQL Server-Replikat erstellen, erstellt RDS eine spezielle Optionsgruppe dafür.
+ Ein regionsübergreifendes SQL-Server-Replikat kann nicht aus seiner dedizierten Optionsgruppe entfernt werden. Die dedizierte Optionsgruppe eines regionsübergreifenden SQL-Server-Replikats kann nicht von anderen DB-Instances verwendet werden.
+ Bei der Option Resource Governor handelt es sich um nicht replizierte Optionen. Sie können nicht replizierte Optionen einer dedizierten Optionsgruppe hinzufügen oder daraus entfernen.
+ Wenn Sie ein regionsübergreifendes SQL-Server-Lesereplikat hochstufen, verhält sich das hochgestufte Lesereplikat genau so wie andere DB-Instances von SQL Server, einschließlich der Verwaltung seiner Optionen.
**Anmerkung**
Wenn Sie Resource Governor für eine Read Replica verwenden, müssen Sie manuell sicherstellen, dass Resource Governor auf Ihrer Read Replica mithilfe von gespeicherten Amazon RDS-Prozeduren konfiguriert wurde, nachdem die Option zur Optionsgruppe hinzugefügt wurde. Resource Governor-Konfigurationen werden nicht automatisch auf die Read Replica repliziert. Außerdem unterscheidet sich die Arbeitslast auf der Read Replica in der Regel von der der primären Instanz. Daher wird empfohlen, die Ressourcenkonfiguration auf der Replica auf der Grundlage Ihrer Arbeitslast und Ihres Instanztyps anzuwenden. Sie können diese gespeicherten Amazon RDS-Prozeduren auf Read Replica unabhängig voneinander ausführen, um Resource Governor für Read Replica zu konfigurieren.
# Überwachen Sie die Microsoft SQL Server-Ressourcenkontrolle mithilfe von Systemansichten für Ihre RDS for SQL Server-Instanz
Die Resource Governor-Statistiken sind seit dem letzten Serverneustart kumulativ. Wenn Sie ab einem bestimmten Zeitpunkt Statistiken sammeln müssen, können Sie die Statistiken mithilfe der folgenden gespeicherten Amazon RDS-Prozedur zurücksetzen:
```
EXEC msdb.dbo.rds_alter_resource_governor_configuration
@reset_statistics = 1;
```
## Laufzeitstatistiken für den Ressourcenpool
Für jeden Ressourcenpool verfolgt Resource Governor die CPU- und Speicherauslastung, out-of-memory Ereignisse, Speicherzuweisungen, I/O und andere Statistiken. Weitere Informationen finden Sie unter [sys.dm\$1resource\$1governor\$1resource\$1pools](https://learn.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/sys-dm-resource-governor-resource-pools-transact-sql?view=sql-server-ver17).
Die folgende Abfrage gibt eine Teilmenge der verfügbaren Statistiken für alle Ressourcenpools zurück:
```
SELECT rp.pool_id,
rp.name AS resource_pool_name,
wg.workload_group_count,
rp.statistics_start_time,
rp.total_cpu_usage_ms,
rp.target_memory_kb,
rp.used_memory_kb,
rp.out_of_memory_count,
rp.active_memgrant_count,
rp.total_memgrant_count,
rp.total_memgrant_timeout_count,
rp.read_io_completed_total,
rp.write_io_completed_total,
rp.read_bytes_total,
rp.write_bytes_total,
rp.read_io_stall_total_ms,
rp.write_io_stall_total_ms
FROM sys.dm_resource_governor_resource_pools AS rp
OUTER APPLY (
SELECT COUNT(1) AS workload_group_count
FROM sys.dm_resource_governor_workload_groups AS wg
WHERE wg.pool_id = rp.pool_id
) AS wg;
```
# Deaktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
Wenn Sie die Ressourcenkontrolle auf RDS für SQL Server deaktivieren, beendet der Dienst die Verwaltung von Arbeitslastressourcen. Bevor Sie Resource Governor deaktivieren, sollten Sie überprüfen, wie sich dies auf Ihre Datenbankverbindungen und Konfigurationen auswirkt.
Die Deaktivierung von Resource Governor hat die folgenden Ergebnisse:
+ Die Klassifizierungsfunktion wird nicht ausgeführt, wenn eine neue Verbindung geöffnet wird.
+ Neue Verbindungen werden automatisch der Standard-Workload-Gruppe zugeordnet.
+ Alle vorhandenen Einstellungen für Arbeitslastgruppen und Ressourcenpools werden auf ihre Standardwerte zurückgesetzt.
+ Wenn Grenzwerte erreicht werden, werden keine Ereignisse ausgelöst.
+ Änderungen an der Konfiguration von Resource Governor können vorgenommen werden, aber die Änderungen werden erst wirksam, wenn Resource Governor aktiviert ist.
Um Resource Governor zu deaktivieren, entfernen Sie die `RESOURCE_GOVERNOR` Option aus ihrer Optionsgruppe.
## Konsole
Mit dem folgenden Verfahren wird die Option `RESOURCE_GOVERNOR` entfernt.
**Um die Option RESOURCE\$1GOVERNOR aus ihrer Optionsgruppe zu entfernen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `RESOURCE_GOVERNOR` (`resource-governor-ee-2022` in den vorherigen Beispielen).
1. Wählen Sie **Delete option (Option löschen)** aus.
1. Wählen Sie unter **Löschoptionen** **RESOURCE\$1GOVERNOR** für Zu löschende **Optionen** aus.
1. Wählen Sie unter **Apply immediately** (Sofort anwenden) die Option **Yes** (Ja) aus, um die Option sofort zu löschen, oder **No** (Nein), um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Löschen** aus.
## CLI
Mit dem folgenden Verfahren wird die Option `RESOURCE_GOVERNOR` entfernt.
**Um die Option RESOURCE\$1GOVERNOR aus ihrer Optionsgruppe zu entfernen**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name resource-governor-ee-2022 \
--options RESOURCE_GOVERNOR \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name resource-governor-ee-2022 ^
--options RESOURCE_GOVERNOR ^
--apply-immediately
```
# Bewährte Methoden für die Konfiguration von Resource Governor auf RDS für SQL Server
Um den Ressourcenverbrauch zu kontrollieren, unterstützt RDS for SQL Server Resource Governor von Microsoft SQL Server. Die folgenden bewährten Methoden helfen Ihnen dabei, häufig auftretende Konfigurationsprobleme zu vermeiden und die Datenbankleistung zu optimieren.
1. Die Resource Governor-Konfiguration wird in der `master` Datenbank gespeichert. Es wird empfohlen, eine Kopie der Resource Governor-Konfigurationsskripten immer separat zu speichern.
1. Die Klassifizierungsfunktion verlängert die Verarbeitungszeit für die Anmeldung. Es wird daher empfohlen, komplexe Logik im Klassifikator zu vermeiden. Eine zu komplexe Funktion kann zu Verzögerungen bei der Anmeldung oder zu Verbindungszeitüberschreitungen führen, einschließlich Amazon RDS-Automatisierungssitzungen. Dies kann sich auf die Fähigkeit der Amazon RDS-Automatisierung auswirken, den Zustand der Instance zu überwachen. Daher wird immer empfohlen, die Classifier-Funktion vor der Implementierung in Produktionsumgebungen in einer Vorproduktionsumgebung zu testen.
1. Vermeiden Sie es, hohe Werte (über 70) für `REQUEST_MAX_MEMORY_GRANT_PERCENT` Workload-Gruppen festzulegen, da dies verhindern kann, dass die Datenbank-Instance ausreichend Speicher für andere gleichzeitige Abfragen zuweist, was möglicherweise zu Timeout-Fehlern bei der Speicherzuweisung führen kann (Fehler 8645). Umgekehrt könnte ein zu niedriger Wert (kleiner als 1) oder auf 0 verhindern, dass Abfragen, die Memory-Workspace benötigen (z. B. solche, die Sortier- oder Hashoperationen beinhalten), in benutzerdefinierten Workload-Gruppen ordnungsgemäß ausgeführt werden. RDS setzt diese Grenzwerte durch, indem es die Werte für Standard-Workload-Gruppen auf Werte zwischen 1 und 70 beschränkt.
1. Beim Binden von tempdb an einen Ressourcenpool erreicht der Pool nach dem Binden speicheroptimierter tempdb-Metadaten an einen Pool möglicherweise seine maximale Einstellung, und alle Abfragen, die verwendet werden, schlagen `tempdb` möglicherweise mit Fehlern fehl. out-of-memory Unter bestimmten Umständen kann der SQL Server möglicherweise beendet werden, wenn ein out-of-memory Fehler auftritt. Um die Wahrscheinlichkeit zu verringern, dass dies passiert, setzen Sie den Speicherpool `MAX_MEMORY_PERCENT` auf einen hohen Wert.