^
--tags Key="AWSRDSCustom",Value="custom-sqlserver"
```
------
## Schritt 5: Erstellen oder Modifizieren einer DB-Instance von RDS Custom für SQL Server
Erstellen oder modifizieren Sie eine DB-Instance von SQL Server für die Verwendung mit Ihrem Verzeichnis. Sie können die Konsole, CLI oder RDS-API verwenden, um eine DB-Instance einem Verzeichnis zuzuordnen. Sie können dafür eine der folgenden Möglichkeiten auswählen:
+ Erstellen Sie eine neue SQL Server-DB-Instance mithilfe der Konsole, des CLI-Befehls [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) oder der [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)-RDS-API-Operation.
Detaillierte Anweisungen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ändern Sie eine vorhandene SQL Server-DB-Instance mithilfe der Konsole, des CLI-Befehls [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) oder der [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)-RDS-API-Operation.
Detaillierte Anweisungen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
+ Stellen Sie eine SQL Server-DB-Instance aus einem DB-Snapshot mithilfe der Konsole, des CLI-Befehls [restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) oder der RDS-API-Operation [RestoreDBInstanceFromDBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html) wieder her.
Detaillierte Anweisungen finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
+ Stellen Sie eine SQL Server-DB-Instance aus einem Snapshot mithilfe der Konsole, des CLI-Befehls [restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) oder der RDS-API-Operation [RestoreDBInstanceToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) wieder her.
Detaillierte Anweisungen finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).
**Anmerkung**
Wenn Ihre Instance von RDS Custom für SQL Server bereits manuell mit einem AD verbunden ist, überprüfen Sie die Einstellungen für [Portregeln für die Netzwerkkonfiguration](custom-sqlserver-WinAuth.NWConfigPorts.md) und [Validieren des Netzwerks](custom-sqlserver-WinAuth.NWValidation.md) und führen Sie die Schritte 1 bis 4 aus. Aktualisieren Sie `--domain-fqdn`, `--domain-ou` und `--domain-auth-secret-arn` für Ihr AD, sodass Anmeldeinformationen und Konfigurationen für die Domain-Verbindung bei RDS Custom registriert sind, um CNAME zu überwachen, zu registrieren und Wiederherstellungsmaßnahmen zu ergreifen.
Wenn Sie die AWS CLI verwenden, sind die folgenden Parameter für die DB-Instance erforderlich, damit sie das erstellte Verzeichnis verwenden kann:
+ Verwenden Sie für den Parameter `--domain-fqdn` den vollständig qualifizierten Domain-Namen (FQDN) Ihres selbstverwalteten AD.
+ Verwenden Sie für den Parameter `--domain-ou` die Organisationseinheit, die Sie in Ihrem selbstverwalteten AD erstellt haben.
+ Verwenden Sie für den Parameter `--domain-auth-secret-arn` den Wert des **Secret-ARN**, den Sie erstellt haben.
**Wichtig**
Wenn Sie eine DB-Instance ändern, um sie einer selbstverwalteten AD-Domain oder AWS Managed Microsoft AD hinzuzufügen oder aus dieser zu entfernen, ist ein Neustart der DB-Instance erforderlich, damit die Änderung wirksam wird. Sie können wählen, ob Sie die Änderungen sofort übernehmen oder bis zum nächsten Wartungsfenster warten möchten. Wenn Sie die Option **Sofort anwenden** auswählen, führt dies bei einer DB-Instance mit Single-AZ zu Ausfallzeiten. Ein DB-Cluster mit Multi-AZ führt ein Failover durch, bevor ein Neustart ausgeführt wird. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
Mit dem folgenden CLI-Befehl wird eine neue DB-Instance von RDS Custom für SQL Server erstellt und einer selbstverwalteten oder AWS Managed Microsoft AD-Domain hinzugefügt.
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--engine custom-sqlserver-se \
--engine-version 15.00.4312.2.v1 \
--db-instance-identifier my-custom-instance \
--db-instance-class db.m5.large \
--allocated-storage 100 --storage-type io1 --iops 1000 \
--master-username my-master-username \
--master-user-password my-master-password \
--kms-key-id my-RDSCustom-key-id \
--custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance \
--domain-fqdn "corp.example.com" \
--domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" \
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" \
--db-subnet-group-name my-DB-subnet-grp \
--vpc-security-group-ids my-securitygroup-id \
--no-publicly-accessible \
--backup-retention-period 3 \
--port 8200 \
--region us-west-2 \
--no-multi-az
```
Für Windows:
```
aws rds create-db-instance ^
--engine custom-sqlserver-se ^
--engine-version 15.00.4312.2.v1 ^
--db-instance-identifier my-custom-instance ^
--db-instance-class db.m5.large ^
--allocated-storage 100 --storage-type io1 --iops 1000 ^
--master-usernamemy-master-username ^
--master-user-password my-master-password ^
--kms-key-id my-RDSCustom-key-id ^
--custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance ^
--domain-fqdn "corp.example.com" ^
--domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" ^
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" ^
--db-subnet-group-name my-DB-subnet-grp ^
--vpc-security-group-ids my-securitygroup-id ^
--no-publicly-accessible ^
--backup-retention-period 3 ^
--port 8200 ^
--region us-west-2 ^
--no-multi-az
```
**Wichtig**
Wenn Ihr NetBIOS für AWS Managed Microsoft AD **corpexample** lautet, wird es selbst als Organisationseinheit angezeigt. Jede zuvor erstellte neue Organisationseinheit wird als verschachtelte Organisationseinheit angezeigt. Für AWS Managed Microsoft AD setzen Sie den Wert `--domain-ou` auf `"OU=RDSCustomOU,OU=corpexample,DC=corp,DC=example,DC=com"`.
Mit dem folgenden Befehl wird eine vorhandene DB-Instance von RDS Custom für SQL Server so geändert, dass sie eine Active-Directory-Domain verwendet.
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier my-custom-instance \
--domain-fqdn "corp.example.com" \
--domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" \
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" \
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier my-custom-instance ^
--domain-fqdn "corp.example.com" ^
--domain-ou "OU=RDSCustomOU,DC=corp,DC=example,DC=com" ^
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:do-not-delete-rds-custom-my-AD-test-secret-123456" ^
```
Mit dem folgenden CLI-Befehl wird eine DB-Instance von RDS Custom für SQL Server aus einer Active-Directory-Domain entfernt.
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier my-custom-instance \
--disable-domain
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier my-custom-instance ^
--disable-domain
```
Wenn Sie die Konsole verwenden, um Ihre Instance zu erstellen oder zu ändern, klicken Sie auf **Windows-Authentifizierung für Microsoft SQL Server aktivieren**, um die folgenden Optionen zu sehen.
![\[Microsoft SQL Server-Windows-Authentifizierungsverzeichnis\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/custom-sqs-WinAuth.png)
Sie müssen sicherstellen, dass Ihr Domain-FQDN in die IP-Adressen des Domain-Controllers aufgelöst wird. Wenn Domain-Controller-IPs nicht aufgelöst werden, schlagen Domain-Verbindungsvorgänge fehl, aber die Erstellung der Instance von RDS Custom für SQL Server ist erfolgreich. Informationen zur Problembehebung finden Sie unter [Problembehebung bei Active Directory](custom-sqlserver-WinAuth.Troubleshoot.md).
## Schritt 6: Erstellen einer SQL-Server-Anmeldung für die Windows-Authentifizierung
Verwenden Sie die Anmeldeinformationen für den Amazon-RDS-Masterbenutzer, um eine Verbindung zur SQL-Server-DB-Instance herzustellen, wie Sie es bei jeder anderen DB-Instance tun würden. Da die DB-Instance mit der AD-Domain verbunden ist, können Sie SQL-Server-Anmeldungen und -Benutzer bereitstellen. Sie tun dies über das AD-Dienstprogramm für Benutzer und Gruppen in Ihrer AD-Domain. Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden.
Damit ein AD-Benutzer sich mit SQL Server authentifizieren kann, muss eine Windows-Anmeldung für SQL Server für den AD-Benutzer oder für eine Active-Directory-Gruppe, der der Benutzer angehört, vorliegen. Eine differenzierte Zugriffskontrolle wird durch das Gewähren und Widerrufen von Berechtigungen für diese SQL Server-Anmeldungen gewährleistet. Ein AD-Benutzer, der keine SQL-Server-Anmeldung hat oder zu keiner AD-Gruppe mit einer solchen Anmeldung gehört, kann nicht auf die DB-Instance von SQL Server zugreifen.
Die `ALTER ANY LOGIN`-Berechtigung ist erforderlich, um eine SQL-Server-Anmeldung für das AD zu erstellen. Wenn Sie mit dieser Berechtigung noch keine Anmeldungen erstellt haben, verbinden Sie sich mithilfe der SQL-Server-Authentifizierung als Hauptbenutzer der DB-Instance und erstellen Sie Ihre SQL-Server-Anmeldungen für das AD im Kontext des Hauptbenutzers.
Sie können einen Data Definition Language (DDL)-Befehl wie im Folgenden dargestellt ausführen, um eine SQL-Server-Anmeldung für einen AD-Benutzer oder eine AD-Gruppe zu erstellen.
```
USE [master]
GO
CREATE LOGIN [mydomain\myuser] FROM WINDOWS WITH DEFAULT_DATABASE = [master], DEFAULT_LANGUAGE = [us_english];
GO
```
Benutzer (sowohl menschliche Benutzer als auch Anwendungen) von Ihrer Domain können sich nun von einem über eine Domain verbundenen Client-Computer mithilfe der Windows-Authentifizierung an der Instance von RDS Custom für SQL Server anmelden.
## Schritt 7: Verwenden der Kerberos- oder NTLM-Authentifizierung
### NTLM-Authentifizierung mithilfe des RDS-Endpunkts
Jede DB-Instance von Amazon RDS hat einen Endpunkt und jeder Endpunkt hat einen DNS-Namen und eine Portnummer für die DB-Instance. Um eine Verbindung mir Ihrer DB-Instance mit einer SQL-Client-Anwendung herzustellen, benötigen Sie den DNS-Namen und die Portnummer für Ihre DB-Instance. Um sich mithilfe der NTLM-Authentifizierung zu authentifizieren, müssen Sie eine Verbindung zum RDS-Endpunkt herstellen.
Bei einer geplanten Datenbankwartung oder einer nicht geplanten Serviceunterbrechung erfolgt ein automatisches Failover von Amazon RDS zur aktuellen sekundären Datenbank, damit Vorgänge schnell und ohne manuelles Eingreifen fortgesetzt werden können. Die primären und sekundären Instances verwenden denselben Endpunkt, dessen physische Netzwerkadresse als Teil des Failover-Prozesses an das sekundäre Replikat übergeben wird. Sie müssen Ihre Anwendung nicht neu konfigurieren, wenn ein Failover auftritt.
### Kerberos-Authentifizierung
Für die Kerberos-basierte Authentifizierung für RDS Custom für SQL Server müssen Verbindungen zu einem bestimmten Service-Prinzipalnamen (SPN) hergestellt werden. Nach einem Failover-Ereignis ist der Anwendung der neue SPN jedoch möglicherweise nicht bekannt. Um dieses Problem zu lösen, bietet RDS Custom für SQL Server einen Kerberos-basierten Endpunkt.
Der Kerberos-basierte Endpunkt folgt einem bestimmten Format. Wenn Ihr RDS-Endpunkt `rds-instance-name.account-region-hash.aws-region.rds.amazonaws.com` ist, wäre `rds-instance-name.account-region-hash.aws-region.awsrds.fully qualified domain name (FQDN)` der entsprechende Kerberos-basierte Endpunkt.
Wenn der RDS-Endpunkt beispielsweise `ad-test.cocv6zwtircu.us-east-1.rds.amazonaws.com` ist und der Domain-Name `corp-ad.company.com` lautet, wäre der Kerberos-basierte Endpunkt `ad-test.cocv6zwtircu.us-east-1.awsrds.corp-ad.company.com`.
Dieser Kerberos-basierte Endpunkt kann zur Authentifizierung bei der SQL-Server-Instance mithilfe von Kerberos verwendet werden, auch nach einem Failover-Ereignis, da der Endpunkt automatisch aktualisiert wird, sodass er auf den neuen SPN der primären SQL-Server-Instance verweist.
### Auffinden Ihres CNAME
Um Ihren CNAME zu finden, stellen Sie eine Verbindung zu Ihrem Domain-Controller her und öffnen Sie den **DNS-Manager**. Navigieren Sie zu **Forward-Lookup-Zonen** und Ihrem FQDN.
Navigieren Sie durch **awsrds**, **aws-region** und **account and region specific hash**.
Wenn Sie die EC2-Instance von RDS Custom verbinden und versuchen, mithilfe von CNAME eine lokale Verbindung zur Datenbank herzustellen, verwendet Ihre Verbindung die NTLM-Authentifizierung anstelle von Kerberos.
Wenn nach der Verbindung mit CNAME vom Remote-Client aus eine NTLM-Verbindung zurückgegeben wird, überprüfen Sie, ob die erforderlichen Ports auf der Zulassungsliste stehen.
Wenn Sie überprüfen möchten, ob Ihre Verbindung Kerberos verwendet, führen Sie die folgende Abfrage aus:
```
SELECT net_transport, auth_scheme
FROM sys.dm_exec_connections
WHERE session_id = @@SSPID;
```
# Verwalten einer DB-Instance in einer Domäne
Sie können die Konsole, AWS CLI oder die Amazon-RDS-API verwenden, um Ihre DB-Instance und ihre Beziehung zu Ihrer Domäne zu verwalten. Beispielsweise können Sie die DB-Instance in Domänen, aus Domänen oder zwischen Domänen verschieben.
Sie können z. B. mithilfe der Amazon-RDS-API Folgendes tun:
+ Um erneut eine Domänenverbindung herzustellen, die aufgrund einer fehlerhaften Mitgliedschaft fehlgeschlagen ist, verwenden Sie die API-Operation [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) und geben Sie die aktuelle Verzeichnis-ID der Mitgliedschaft an.
+ Um den IAM-Rollennamen für die Mitgliedschaft zu aktualisieren, verwenden Sie die `ModifyDBInstance`-API-Operation und geben Sie die Verzeichnis-ID der aktuellen Mitgliedschaft und die neue IAM-Rolle an.
+ Um eine DB-Instance aus einer Domäne zu entfernen, verwenden Sie die `ModifyDBInstance`-API-Operation und geben Sie `none` als Domänenparameter an.
+ Um eine DB-Instance von einer Domäne in eine andere zu verschieben, verwenden Sie die `ModifyDBInstance` API-Operation. Geben Sie die Domänen-ID der neuen Domäne als Domänenparameter an.
+ Um die Mitgliedschaft für jede DB-Instance aufzulisten, führen Sie die API-Operation [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/DescribeDBInstances.html) aus.
## Wiederherstellen einer DB-Instance von RDS Custom für SQL Server und Hinzufügen zu einer Active-Directory-Domain
Sie können einen DB-Snapshot wiederherstellen oder eine zeitpunktbezogene Wiederherstellung (PITR) für eine DB-Instance von SQL Server vornehmen und diese dann zu einer Active-Directory-Domain hinzufügen. Wenn die DB-Instance wiederhergestellt wurde, modifizieren Sie die Instance, indem Sie den unter [Schritt 5: Erstellen oder Modifizieren einer DB-Instance von RDS Custom für SQL Server](custom-sqlserver-WinAuth.settingUp.md#custom-sqlserver-WinAuth.settingUp.CreateDBInstance) beschriebenen Prozess anwenden, um die DB-Instance einer AD-Domain hinzuzufügen.
# Grundlegendes zur Domänenmitgliedschaft
Nachdem Sie Ihre DB-Instance erstellt oder modifiziert haben, wird die Instance ein Mitglied der Domäne. Die AWS-Konsole gibt den Status der Domänenmitgliedschaft für die DB-Instance an. Der Status der DB-Instance kann einer der folgenden sein:
+ **joined** – Die Instance ist Mitglied der Domäne.
+ **joining** – Die Instance ist gerade im Prozess, Mitglied einer Domäne zu werden.
+ **pending-join** – Die Mitgliedschaft der Instance steht noch aus.
+ **pending-maintenance-join** – AWS versucht, die Instance im nächsten vorgesehenen Wartungsfenster zu einem Mitglieder der Domäne zu machen.
+ **pending-removal** – Das Entfernen der Instance von der Domäne steht noch aus.
+ **pending-maintenance-removal** – AWS versucht, die Instance im nächsten vorgesehenen Wartungsfenster von der Domäne zu entfernen.
+ **failed** – Ein Konfigurationsproblem hat verhindert, dass die Instance mit der Domäne verbunden werden konnte. Überprüfen und korrigieren Sie Ihre Konfiguration, bevor Sie den Befehl zu Änderung der Instance erneut ausführen.
+ **removing** – Die Instance wird gerade von der Domäne entfernt.
Eine Anfrage, Mitglied einer Domäne zu werden, kann wegen eines Netzwerkverbindungsproblems oder einer falschen IAM-Rolle fehlschlagen. Beispielsweise können Sie eine DB-Instance erstellen oder eine vorhandene Instance ändern und der Versuch, dass die DB-Instance Mitglied einer Domäne wird, wird fehlschlagen. Geben Sie in diesem Fall entweder den Befehl, um die DB-Instance zu erstellen oder zu ändern, neu aus oder ändern Sie die neu erstellte Instance, um der Domäne beizutreten.
# Problembehebung bei Active Directory
Die folgenden Probleme können auftreten, wenn Sie ein AD einrichten oder ändern.
| Fehlercode | Beschreibung | Häufige Ursachen | Vorschläge für die Fehlerbehebung |
| --- | --- | --- | --- |
| Fehler 2 / 0x2 | Die angegebene Datei wurde nicht gefunden. | Das Format oder der Speicherort für die Organisationseinheit, das/der mit dem Parameter `—domain-ou` angegeben wurde, ist ungültig. Das über AWS Secrets Manager angegebene Domain-Servicekonto verfügt nicht über die für den Beitritt zu der Organisationseinheit erforderlichen Berechtigungen. | Überprüfen Sie den Parameter `—domain-ou`. Stellen Sie sicher, dass das Domain-Servicekonto über die richtigen Berechtigungen für die Organisationseinheit verfügt. |
| Fehler 5 / 0x5 | Zugriff verweigert. | Falsch konfigurierte Berechtigungen für das Domain-Servicekonto oder das Computerkonto ist bereits in der Domain vorhanden. | Überprüfen Sie die Berechtigungen des Domain-Servicekontos in der Domain und stellen Sie sicher, dass das RDS-Computerkonto nicht doppelt in der Domain vorhanden ist. Sie können den Namen des RDS-Computerkontos überprüfen, indem Sie `SELECT @@SERVERNAME` auf Ihrer DB-Instance von RDS Custom für SQL Server ausführen. Versuchen Sie bei Verwendung von Multi-AZ, einen Neustart mit Failover durchzuführen, und überprüfen Sie dann das RDS-Computerkonto erneut. Weitere Informationen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md). |
| Fehler 87 / 0x57 | Der Parameter ist falsch. | Das über AWS Secrets Manager angegebene Domain-Servicekonto verfügt nicht über die richtigen Berechtigungen. Auch das Benutzerprofil ist möglicherweise beschädigt. | Prüfen Sie die Anforderungen für das Domain-Servicekonto. |
| Fehler 234 / 0xEA | Die angegebene Organisationseinheit ist nicht vorhanden. | Die mit dem Parameter `—domain-ou` angegebene Organisationseinheit ist in Ihrem AD nicht vorhanden. | Überprüfen Sie den Parameter `—domain-ou` und stellen Sie sicher, dass die angegebene Organisationseinheit in Ihrem AD vorhanden ist. |
| Fehler 1326 / 0x52E | Der Benutzername oder das Passwort ist falsch. | Die in AWS Secrets Manager angegebenen Anmeldeinformationen für das Domain-Servicekonto enthalten einen unbekannten Benutzernamen oder ein falsches Passwort. Möglicherweise ist das Domain-Konto auch in Ihrem AD deaktiviert. | Stellen Sie sicher, dass die in AWS Secrets Manager angegebenen Anmeldeinformationen korrekt sind und das Domain-Konto in Ihrem Active Directory aktiviert ist. |
| Fehler 1355 / 0x54B | Die angegebene Domain ist nicht vorhanden oder konnte nicht kontaktiert werden. | Die Domain ist ausgefallen, der angegebene Satz von DNS-IPs ist nicht erreichbar oder der angegebene FQDN ist nicht erreichbar. | Stellen Sie sicher, dass die Parameter `—domain-dns-ips` und `—domain-fqdn` korrekt sind. Überprüfen Sie die Netzwerkkonfiguration Ihrer DB-Instance von RDS Custom für SQL Server und stellen Sie sicher, dass Ihr AD erreichbar ist. |
| Fehler 1722 / 0x6BA | Der RPC-Server ist nicht verfügbar. | Der RPC-Service Ihrer AD-Domain konnte nicht erreicht werden. Dies könnte auf einen Service- oder Netzwerkfehler zurückzuführen sein. | Stellen Sie sicher, dass der RPC-Service auf Ihren Domain-Controllern ausgeführt wird und dass die TCP-Ports `135` und `49152-65535` in Ihrer Domain von Ihrer DB-Instance von RDS Custom für SQL Server aus erreichbar sind. |
| Fehler 2224 / 0x8B0 | Das Benutzerkonto besteht bereits. | Das Computerkonto, das zu Ihrem AD hinzugefügt werden soll, ist bereits vorhanden. | Ermitteln Sie das Computerkonto, indem Sie `SELECT @@SERVERNAME` auf Ihrer DB-Instance von RDS Custom für SQL Server ausführen, und entfernen Sie es dann vorsichtig aus Ihrem AD. |
| Fehler 2242 / 0x8c2 | Das Passwort dieses Benutzers ist abgelaufen. | Das über AWS Secrets Manager angegebene Passwort für das Domain-Servicekonto ist abgelaufen. | Aktualisieren Sie das Passwort für das Domain-Servicekonto, über das Sie Ihre DB-Instance von RDS Custom für SQL Server Ihrem AD hinzufügen. |
# Verwalten einer Multi-AZ-Bereitstellung für RDS Custom für SQL Server
Bei einer Multi-AZ-Bereitstellung einer DB-Instance für RDS Custom für SQL Server sorgt Amazon RDS für eine automatische Bereitstellung und Verwaltung eines synchronen Standby-Replikats in einer anderen Availability Zone (AZ). Die primäre DB-Instance wird über die Availability Zone synchron auf ein Standby-Replikat repliziert, um Datenredundanz zu erzielen.
**Wichtig**
Eine Multi-AZ-Bereitstellung für RDS Custom für SQL Server unterscheidet sich von Multi-AZ für RDS für SQL Server. Im Gegensatz zu Multi-AZ für RDS für SQL Server müssen Sie die Voraussetzungen für RDS Custom für SQL Server einrichten, bevor Sie Ihre Multi-AZ-DB-Instance erstellen, da RDS Custom in Ihrem eigenen Konto ausgeführt wird, für das Berechtigungen erforderlich sind.
Wenn Sie die Voraussetzungen nicht erfüllen, kann Ihre Multi-AZ-DB-Instance möglicherweise nicht ausgeführt werden oder wird automatisch in eine Single-AZ-DB-Instance geändert. Weitere Informationen über Voraussetzungen finden Sie unter [Einschränkungen für eine Multi-AZ-Bereitstellung mit RDS Custom für SQL Server](custom-sqlserver-multiaz.prerequisites.md).
Wenn Sie eine DB-Instance mit hoher Verfügbarkeit ausführen, kann dies die Verfügbarkeit bei geplanten Systemwartungen verbessern. Bei einer geplanten Datenbankwartung oder einer ungeplanten Serviceunterbrechung führt Amazon RDS automatisch einen Failover zur aktuellen sekundären DB-Instance durch. Mit dieser Funktion können Datenbankoperationen schnell ohne manuellen Eingriff fortgesetzt werden. Die Primär- und Standby-Instances verwenden denselben Endpunkt, dessen physische Netzwerkadresse als Teil des Failoverprozesses am sekundären Replica gespiegelt wird. Sie müssen Ihre Anwendung nicht neu konfigurieren, wenn ein Failover auftritt.
![\[RDS Custom für SQL Server unterstützt Multi-AZ.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/custom-sqlserver-multiaz-architecture.png)
Sie können eine Multi-AZ-Bereitstellung von RDS Custom für SQL Server erstellen, indem Sie bei der Erstellung einer DB-Instance von RDS Custom „Multi-AZ“ angeben. Sie können über die Konsole bestehende DB-Instances von RDS Custom für SQL Server in Multi-AZ-Bereitstellungen umwandeln, indem Sie die DB-Instance ändern und die Option „Multi-AZ“ angeben. Sie können auch eine Multi-AZ-Bereitstellung der DB-Instance mit der AWS-CLI oder der Amazon-RDS-API angeben.
In der RDS-Konsole wird die Availability Zone des Standby-Replikats (sekundäre AZ) angezeigt. Sie können auch den CLI-Befehl `describe-db-instances` oder die API-Operation `DescribeDBInstances` verwenden, um die sekundäre AZ zu suchen.
DB-Instances von RDS Custom für SQL Server mit Multi-AZ-Bereitstellungen können im Vergleich zu einer Single-AZ-Bereitstellung eine höhere Schreib- und Commit-Latenz aufweisen. Dieser Anstieg kann aufgrund der synchronen Datenreplikation zwischen DB-Instances entstehen. Die Latenz kann sich entsprechend ändern, wenn Ihre Bereitstellung ein Failover auf ein Standby-Replikat durchführt, obwohl AWS selbst mit einer Netzwerkanbindung zwischen Availability Zones mit einer geringen Latenz konzipiert ist.
**Anmerkung**
Für Produktions-Workloads empfehlen wir die Verwendung einer DB-Instance-Klasse mit bereitgestellten IOPS (Eingabe-/Ausgabevorgänge pro Sekunde) für eine schnelle, konsistente Leistung. Weitere Informationen zu DB-Instance-Klassen finden Sie unter [Anforderungen und Einschränkungen für Amazon RDS Custom für SQL Server](custom-reqs-limits-MS.md).
**Topics**
+ [Verfügbarkeit von Regionen und Versionen](#custom-sqlserver-multiaz.regionversion)
+ [Einschränkungen für eine Multi-AZ-Bereitstellung für RDS Custom für SQL Server](#custom-sqlserver-multiaz.limitations)
+ [Einschränkungen für eine Multi-AZ-Bereitstellung mit RDS Custom für SQL Server](custom-sqlserver-multiaz.prerequisites.md)
+ [Erstellen einer Multi-AZ-Bereitstellung von RDS Custom für SQL Server](#custom-sqlserver-multiaz.creating)
+ [Ändern einer Single-AZ-Bereitstellung von RDS Custom für SQL Server in eine Multi-AZ-Bereitstellung](custom-sqlserver-multiaz.modify-saztomaz.md)
+ [Ändern einer Multi-AZ-Bereitstellung von RDS Custom für SQL Server in eine Single-AZ-Bereitstellung](custom-sqlserver-multiaz.modify-maztosaz.md)
+ [Failover-Prozess einer Multi-AZ-Bereitstellung für RDS Custom für SQL Server](custom-sqlserver-multiaz.failover.md)
## Verfügbarkeit von Regionen und Versionen
Multi-AZ-Bereitstellungen für RDS Custom für SQL Server werden für die folgenden SQL-Server-Editionen unterstützt:
+ SQL Server 2022 und 2019: Enterprise-, Standard-, Web- und Developer-Edition
**Anmerkung**
Multi-AZ-Bereitstellungen für RDS Custom für SQL Server werden auf SQL Server 2019 CU8 (15.00.4073.23) oder niedrigeren Versionen nicht unterstützt.
Multi-AZ-Bereitstellungen für RDS Custom für SQL Server sind in allen Regionen verfügbar, in denen RDS Custom für SQL Server verfügbar ist. Weitere Informationen zur regionalen Verfügbarkeit von Multi-AZ-Bereitstellungen für RDS Custom für SQL Server finden Sie unter [Unterstützte Regionen und DB-Engines für RDS Custom für SQL Server](Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.md#Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.sq).
## Einschränkungen für eine Multi-AZ-Bereitstellung für RDS Custom für SQL Server
Bei Multi-AZ-Bereitstellungen für RDS Custom für SQL Server gelten folgende Einschränkungen:
+ Regionsübergreifende Multi-AZ-Bereitstellungen werden nicht unterstützt.
+ Sie können die sekundäre DB-Instance nicht so konfigurieren, dass sie die Datenbankleseaktivität akzeptiert.
+ Wenn Sie eine Custom Engine Version (CEV) mit einer Multi-AZ-Bereitstellung verwenden, nutzt Ihre sekundäre DB-Instance diese CEV auch. Die sekundäre DB-Instance kann keine andere CEV verwenden.
# Einschränkungen für eine Multi-AZ-Bereitstellung mit RDS Custom für SQL Server
Wenn Sie über eine Single-AZ-Bereitstellung für RDS Custom für SQL Server verfügen, sind die folgenden zusätzlichen Voraussetzungen erforderlich, bevor Sie diese in eine Multi-AZ-Bereitstellung ändern können. Sie können auswählen, ob Sie die Voraussetzungen manuell oder mit der zur Verfügung gestellten CloudFormation-Vorlage erfüllen möchten. Die neueste CloudFormation-Vorlage enthält die Voraussetzungen sowohl für Single-AZ- als auch Multi-AZ-Bereitstellungen.
**Wichtig**
Zur Vereinfachung der Einrichtung empfehlen wir, dass Sie die neueste CloudFormation-Vorlagendatei verwenden, die in den Anweisungen zur Netzwerkeinrichtung enthalten ist, um die Voraussetzungen zu erstellen. Weitere Informationen finden Sie unter [Konfiguration mit CloudFormation](custom-setup-sqlserver.md#custom-setup-sqlserver.cf).
**Anmerkung**
Wenn Sie eine vorhandene Single-AZ-Bereitstellung von RDS Custom für SQL Server in eine Multi-AZ-Bereitstellung ändern, müssen Sie diese Voraussetzungen erfüllen. Wenn Sie die Voraussetzungen nicht erfüllen, schlägt die Multi-AZ-Einrichtung fehl. Führen Sie zum Erfüllen dieser Voraussetzungen die Schritte unter [Ändern einer Single-AZ-Bereitstellung von RDS Custom für SQL Server in eine Multi-AZ-Bereitstellung](custom-sqlserver-multiaz.modify-saztomaz.md) aus.
+ Aktualisieren Sie die Regeln für eingehenden und ausgehenden Datenverkehr der RDS-Sicherheitsgruppe, um Port 1120 zuzulassen.
+ Fügen Sie Ihrer privaten Netzwerk-Zugriffssteuerungsliste (ACL) eine Regel hinzu, die TCP-Ports `0-65535` für die DB-Instance-VPC zulässt.
+ Erstellen Sie neue VPC-Endpoints von Amazon SQS, die es der DB-Instance von RDS Custom für SQL Server ermöglichen, mit SQS zu kommunizieren.
+ Aktualisieren Sie die SQS-Berechtigungen in der Instance-Profilrolle.
## Erstellen einer Multi-AZ-Bereitstellung von RDS Custom für SQL Server
Wenn Sie eine Multi-AZ-Bereitstellung RDS Custom für SQL Server erstellen möchten, folgen Sie den Schritten unter [Erstellen und Herstellen einer Verbindung mit einer DB-Instance für Amazon RDS Custom für SQL Server](custom-creating-sqlserver.md).
**Wichtig**
Zur Vereinfachung der Einrichtung empfehlen wir, dass Sie die neueste CloudFormation-Vorlagendatei verwenden, die in den Anweisungen zur Netzwerkeinrichtung enthalten ist. Weitere Informationen finden Sie unter [Konfiguration mit CloudFormation](custom-setup-sqlserver.md#custom-setup-sqlserver.cf).
Das Erstellen einer Multi-AZ-Bereitstellung kann einige Minuten in Anspruch nehmen.
# Ändern einer Single-AZ-Bereitstellung von RDS Custom für SQL Server in eine Multi-AZ-Bereitstellung
Sie können eine vorhandene DB-Instance von RDS Custom für SQL Server von einer Single-AZ-Bereitstellung in eine Multi-AZ-Bereitstellung ändern. Wenn Sie die DB-Instance ändern, führt Amazon RDS mehrere Aktionen aus:
+ Es wird ein Snapshot der primären DB-Instance aufgenommen.
+ Erstellt neue Volumes für das Standby-Replikat aus dem Snapshot. Diese Volumes werden im Hintergrund initialisiert, und die maximale Volume-Leistung wird erreicht, nachdem die Daten vollständig initialisiert wurden.
+ Die synchrone Replikation auf Blockebene zwischen der primären und sekundären DB-Instance wird aktiviert.
**Wichtig**
Wir empfehlen, Ihre DB-Instance von RDS Custom für SQL Server möglichst nicht in Zeiten hoher Aktivität von einer Single-AZ- in eine Multi-AZ-Bereitstellung auf einer Produktions-DB-Instance zu ändern.
AWS verwendet einen Snapshot, um die Standby-Instance zu erstellen, um Ausfallzeiten bei der Konvertierung von Single-AZ zu Multi-AZ zu vermeiden, aber die Leistung kann während und nach der Konvertierung zu Multi-AZ beeinträchtigt werden. Diese Auswirkung kann bei Workloads erheblich sein, die empfindlich auf Schreiblatenz reagieren. Diese Funktion ermöglicht zwar die schnelle Wiederherstellung großer Volumes aus Snapshots, kann jedoch aufgrund der synchronen Replikation zu einer erhöhten Latenz von I/O Vorgängen führen. Diese Latenz kann sich auf die Leistung Ihrer Datenbank auswirken.
**Anmerkung**
Wenn Sie Ihre DB-Instance von RDS Custom für SQL Server vor dem 29. August 2024 erstellt haben, aktualisieren Sie vor der Änderung auf die neueste Unterversion.
Führen Sie für Instances von SQL Server 2019 ein Upgrade der DB-Engine-Version auf `15.00.4410.1.v1` oder höher durch.
Führen Sie für Instances von SQL Server 2022 ein Upgrade der DB-Engine-Version auf `16.00.4150.1.v1` oder höher durch.
**Topics**
+ [Konfiguration der Voraussetzungen für die Änderung einer Single-AZ- zu einer Multi-AZ-Bereitstellung mit CloudFormation](#custom-sqlserver-multiaz.modify-saztomaz-prereqs.cf)
+ [Konfigurieren der Voraussetzungen für die manuelle Änderung einer Single-AZ- in eine Multi-AZ-Bereitstellung](#custom-sqlserver-multiaz.modify-saztomaz-prereqs.manual)
+ [Ändern Sie mithilfe der RDS-Konsole, AWS CLI oder RDS-API.](#custom-sqlserver-multiaz.modify-saztomaz-afterprereqs)
## Konfiguration der Voraussetzungen für die Änderung einer Single-AZ- zu einer Multi-AZ-Bereitstellung mit CloudFormation
Um eine Multi-AZ-Bereitstellung zu verwenden, müssen Sie sicherstellen, dass Sie die neueste CloudFormation Vorlage mit den Voraussetzungen angewendet haben, oder die neuesten Voraussetzungen manuell konfigurieren. Wenn Sie die neueste Vorlage CloudFormation für die Voraussetzungen bereits angewendet haben, können Sie diese Schritte überspringen.
Um die Voraussetzungen für die Multi-AZ-Bereitstellung von RDS Custom for SQL Server zu konfigurieren, verwenden Sie CloudFormation
1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Um den Assistenten zum Erstellen von Stacks zu starten, wählen Sie den vorhandenen Stack aus, mit dem Sie eine Single-AZ-Bereitstellung erstellt haben, und klicken Sie auf **Aktualisieren**.
Die Seite **Stack aktualisieren** wird angezeigt.
1. Wählen Sie für **Voraussetzung – Vorlage vorbereiten** die Option **Aktuelle Vorlage ersetzen** aus.
1. Gehen Sie für **Specify template** (Vorlage angeben) wie folgt vor:
1. Laden Sie die neueste CloudFormation Vorlagendatei herunter. Öffnen Sie das Kontextmenü (Rechtsklick) für den Link ([custom-sqlserver-onboard.zip](samples/custom-sqlserver-onboard.zip)) und wählen Sie **Link speichern unter**.
1. Speichern und extrahieren Sie die Datei `custom-sqlserver-onboard.json` auf Ihrem Computer.
1. Wählen Sie unter **Templete source (Vorlagenquelle)** den Wert **Upload a template file (Vorlagendatei hochladen)** aus.
1. Navigieren Sie unter **Choose file** (Datei auswählen) zur Datei `custom-sqlserver-onboard.json` und wählen Sie sie aus.
1. Wählen Sie **Weiter** aus.
Die Seite **Specify DB Details** (DB-Details angeben) wird angezeigt.
1. Wenn Sie die Standardoptionen beibehalten möchten, wählen Sie **Next** (Weiter) aus.
Die Seite **Erweiterte Optionen** wird angezeigt.
1. Wenn Sie die Standardoptionen beibehalten möchten, wählen Sie **Next** (Weiter) aus.
1. Wenn Sie die Standardoptionen beibehalten möchten, wählen Sie **Next** (Weiter) aus.
1. Führen Sie auf der Seite **Änderungen überprüfen** die folgenden Schritte aus:
1. Aktivieren Sie unter **Capabilities** (Funktionen) das Kontrollkästchen ****I acknowledge that CloudFormation , das bestätigt, dass IAM-Ressourcen mit benutzerdefinierten Namen erstellen kann****.
1. Wählen Sie **Absenden** aus.
1. Vergewissern Sie sich, dass das Update erfolgreich ist. Für den Status eines erfolgreichen Vorgangs wird `UPDATE_COMPLETE` angezeigt.
Wenn das Update fehlschlägt, wird jede neue Konfiguration, die im Aktualisierungsprozess angegeben wurde, rückgängig gemacht. Die vorhandene Ressource ist weiterhin verwendbar. Wenn Sie beispielsweise Netzwerk-ACL-Regeln mit den Nummern 18 und 19 hinzufügen, es aber bereits Regeln mit diesen Nummern gibt, würde das Update den folgenden Fehler zurückgeben: `Resource handler returned message: "The network acl entry identified by 18 already exists.` In diesem Szenario können Sie die vorhandenen ACL-Regeln so ändern, dass sie eine Nummer unter 18 verwenden, und dann die Aktualisierung erneut versuchen.
## Konfigurieren der Voraussetzungen für die manuelle Änderung einer Single-AZ- in eine Multi-AZ-Bereitstellung
**Wichtig**
Um die Einrichtung zu vereinfachen, empfehlen wir, die neueste CloudFormation Vorlagendatei zu verwenden, die in den Anweisungen zur Netzwerkeinrichtung enthalten ist. Weitere Informationen finden Sie unter [Konfiguration der Voraussetzungen für die Änderung einer Single-AZ- zu einer Multi-AZ-Bereitstellung mit CloudFormation](#custom-sqlserver-multiaz.modify-saztomaz-prereqs.cf).
Wenn Sie Voraussetzungen manuell konfigurieren möchten, führen Sie die folgenden Schritte aus.
1. Öffnen Sie die Amazon-VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie **Endpunkt** aus. Die**Erstellen eines Endpunkts**wird angezeigt.
1. Wählen Sie unter **Servicekategorie** die Option **AWS -Services** aus.
1. Suchen Sie unter **Dienste** nach *SQS*
1. Wählen Sie unter **VPC** die VPC aus, in der Ihre DB-Instance von RDS Custom für SQL Server bereitgestellt wird.
1. Wählen Sie unter **Subnetze** die Subnetze aus, in denen Ihre DB-Instance von RDS Custom für SQL Server bereitgestellt wird.
1. Wählen Sie **unter Sicherheitsgruppen** die *-vpc-endpoint-sg* Gruppe aus.
1. Wählen Sie für **Richtlinie** die Option **Benutzerdefiniert** aus.
1. Ersetzen Sie in Ihrer benutzerdefinierten Richtlinie die *AWS partition*,*Region*, *accountId* und *IAM-Instance-role* durch Ihre eigenen Werte.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Condition": {
"StringLike": {
"aws:ResourceTag/AWSRDSCustom": "custom-sqlserver"
}
},
"Action": [
"SQS:SendMessage",
"SQS:ReceiveMessage",
"SQS:DeleteMessage",
"SQS:GetQueueUrl"
],
"Resource": "arn:aws:sqs:us-east-1:111122223333:do-not-delete-rds-custom-*",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{IAM-Instance-role}"
}
}
]
}
```
------
1. Aktualisieren Sie das **Instance-Profil** mit der Berechtigung, auf Amazon SQS zuzugreifen. Ersetzen Sie die *AWS partition*, *Region* und *accountId* durch Ihre eigenen Werte.
```
{
"Sid": "SendMessageToSQSQueue",
"Effect": "Allow",
"Action": [
"SQS:SendMessage",
"SQS:ReceiveMessage",
"SQS:DeleteMessage",
"SQS:GetQueueUrl"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:do-not-delete-rds-custom-*"
}
],
"Condition": {
"StringLike": {
"aws:ResourceTag/AWSRDSCustom": "custom-sqlserver"
}
}
}
>
```
1. Aktualisieren Sie die Regeln für eingehenden und ausgehenden Datenverkehr der Amazon-RDS-Sicherheitsgruppe, um Port 1120 zuzulassen.
1. Wählen Sie **unter Sicherheitsgruppen** die *-rds-custom-instance-sg* Gruppe aus.
1. Erstellen Sie für **eingehende Regeln** eine **benutzerdefinierte TCP-Regel**, um Ports *1120* aus der *-rds-custom-instance-sg* Quellgruppe zuzulassen.
1. Erstellen Sie für **ausgehende Regeln** eine **benutzerdefinierte TCP-Regel**, um den Port zur *1120* *-rds-custom-instance-sg* Zielgruppe zuzulassen.
1. Fügen Sie Ihrer privaten Netzwerk-Zugriffssteuerungsliste (ACL) eine Regel hinzu, die TCP-Ports `0-65535` für das Quellsubnetz der DB-Instance zulässt.
**Anmerkung**
Notieren Sie sich beim Erstellen einer **Regel für eingehenden Datenverkehr** und einer **Regel für ausgehenden Datenverkehr** die höchste vorhandene **Regelnummer**. Die neuen Regeln, die Sie erstellen, müssen eine **Regelnummer** unter 100 haben und dürfen mit keiner vorhandenen **Regelnummer** übereinstimmen.
1. Wählen Sie **unter Netzwerk ACLs** die *-private-network-acl* Gruppe aus.
1. Erstellen Sie für **eingehende Regeln** eine **All-TCP-Regel, um TCP-Ports** `0-65535` mit einer Quelle von *privatesubnet1* und *privatesubnet2* zuzulassen.
1. Erstellen Sie für **ausgehende Regeln** eine **All-TCP-Regel, um TCP-Ports** den Zugang zu Ziel *privatesubnet1* - und `0-65535` zu ermöglichen. *privatesubnet2*
## Ändern Sie mithilfe der RDS-Konsole, AWS CLI oder RDS-API.
Nachdem Sie die Voraussetzungen erfüllt haben, können Sie eine RDS Custom for SQL Server-DB-Instance mithilfe der RDS-Konsole, AWS CLI oder RDS-API von einer Single-AZ- zu einer Multi-AZ-Bereitstellung ändern.
### Konsole
**So ändern Sie eine Single-AZ-Bereitstellung von RDS Custom für SQL Server in eine Multi-AZ-Bereitstellung**
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 in der Amazon-RDS-Konsole **Databases (Datenbanken)** aus.
Der Bereich **Databases (Datenbanken)** wird angezeigt.
1. Wählen Sie die DB-Instance von RDS Custom für SQL Server aus, die Sie ändern möchten.
1. Wählen Sie unter **Aktionen** die Option **In Multi-AZ-Bereitstellung konvertieren ** aus.
1. Damit Änderungen sofort übernommen werden, wählen Sie die Option **Sofort anwenden** auf der Seite **Bestätigung** aus. Die Auswahl dieser Option verursacht keine Ausfallzeiten, kann jedoch zur Beeinträchtigung der Leistung führen. Sie können die Aktualisierung auch im nächsten Wartungsfenster übernehmen. Weitere Informationen finden Sie unter [Verwenden der Einstellung „Planen von Änderungen“](USER_ModifyInstance.ApplyImmediately.md).
1. Wählen Sie auf der Seite **Bestätigung** die Option **Konvertieren in Multi-AZ** aus.
### AWS CLI
Um mithilfe von zu einer Multi-AZ-DB-Instance-Bereitstellung zu konvertieren AWS CLI, rufen Sie den [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)Befehl auf und legen Sie die `--multi-az` Option fest. Geben Sie die DB-Instance-Kennung und die Werte für andere Optionen an, die geändert werden sollen. Informationen zu den jeweiligen Optionen finden Sie unter [Einstellungen für DB-Instances](USER_ModifyInstance.Settings.md).
**Example**
Mit dem folgenden Code wird `mycustomdbinstance` geändert, indem die Option `--multi-az` hinzugefügt wird. Die Änderungen werden während des nächsten Wartungsfensters (mit ) übernommen `--no-apply-immediately`. Verwenden Sie `--apply-immediately`, damit Änderungen sofort angewendet werden. Weitere Informationen finden Sie unter [Verwenden der Einstellung „Planen von Änderungen“](USER_ModifyInstance.ApplyImmediately.md).
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mycustomdbinstance \
--multi-az \
--no-apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mycustomdbinstance ^
--multi-az \ ^
--no-apply-immediately
```
### RDS-API
Um mit der RDS-API in eine Multi-AZ-DB-Instance-Bereitstellung zu konvertieren, rufen Sie den DBInstance Vorgang [Modify](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) auf und setzen Sie den `MultiAZ` Parameter auf true.
# Ändern einer Multi-AZ-Bereitstellung von RDS Custom für SQL Server in eine Single-AZ-Bereitstellung
Sie können eine vorhandene DB-Instance von RDS Custom für SQL Server von einer Multi-AZ-Bereitstellung in eine Single-AZ-Bereitstellung ändern.
## Konsole
**So ändern Sie eine vorhandene DB-Instance von RDS Custom für SQL Server von einer Multi-AZ-Bereitstellung in eine Single-AZ-Bereitstellung.**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie in der Amazon-RDS-Konsole **Databases (Datenbanken)** aus.
Der Bereich **Databases (Datenbanken)** wird angezeigt.
1. Wählen Sie die DB-Instance von RDS Custom für SQL Server aus, die Sie ändern möchten.
1. Wählen Sie für die **Multi-AZ-Bereitstellung** die Option **Nein** aus.
1. Damit Änderungen sofort übernommen werden, wählen Sie die Option **Sofort anwenden** auf der Seite **Bestätigung** aus. Die Auswahl dieser Option verursacht keine Ausfallzeiten, kann jedoch zur Beeinträchtigung der Leistung führen. Sie können die Aktualisierung auch im nächsten Wartungsfenster übernehmen. Weitere Informationen finden Sie unter [Verwenden der Einstellung „Planen von Änderungen“](USER_ModifyInstance.ApplyImmediately.md).
1. Klicken Sie auf der Seite **Bestätigung** auf **DB-Instance ändern**.
## AWS CLI
Wenn Sie eine Multi-AZ-Bereitstellung mit der AWS CLI in eine Single-AZ-Bereitstellung ändern möchten, rufen Sie den Befehl [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) auf und fügen Sie die Option `--no-multi-az` hinzu. Geben Sie die DB-Instance-Kennung und die Werte für andere Optionen an, die geändert werden sollen. Informationen zu den jeweiligen Optionen finden Sie unter [Einstellungen für DB-Instances](USER_ModifyInstance.Settings.md).
**Example**
Mit dem folgenden Code wird `mycustomdbinstance` geändert, indem die Option `--no-multi-az` hinzugefügt wird. Die Änderungen werden während des nächsten Wartungsfensters (mit ) übernommen `--no-apply-immediately`. Verwenden Sie `--apply-immediately`, damit Änderungen sofort angewendet werden. Weitere Informationen finden Sie unter [Verwenden der Einstellung „Planen von Änderungen“](USER_ModifyInstance.ApplyImmediately.md).
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mycustomdbinstance \
--no-multi-az \
--no-apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mycustomdbinstance ^
--no-multi-az \ ^
--no-apply-immediately
```
## RDS-API
Wenn Sie eine Multi-AZ-Bereitstellung mit der RDS-API in eine Single-AZ-Bereitstellung ändern möchten, rufen Sie die Operation [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) auf und legen Sie den Parameter `MultiAZ` auf `false` fest.
# Failover-Prozess einer Multi-AZ-Bereitstellung für RDS Custom für SQL Server
Wenn ein geplanter oder ungeplanter Ausfall Ihrer DB-Instance durch einen Infrastrukturdefekt resultiert, wechselt Amazon RDS automatisch zu einem Standby-Replikat in einer anderen Availability Zone, wenn Sie Multi-AZ aktiviert haben. Die Dauer, bis der Failover-Prozess abgeschlossen ist, hängt von der Datenbankaktivität sowie von anderen Bedingungen zu dem Zeitpunkt ab, an dem die primäre DB-Instance ausgefallen ist. Der Failover-Prozess dauert normalerweise 60-120 Sekunden. Diese Failover-Dauer kann sich verlängern, wenn umfangreiche Transaktionen oder zeitintensive Wiederherstellungsprozesse durchgeführt werden. Wenn der Failover-Prozess abgeschlossen ist, kann es noch einmal etwas dauern, bis die RDS-Konsole die Daten für die neue Availability Zone anzeigt.
**Anmerkung**
Sie können ein Failover manuell erzwingen, wenn Sie eine DB-Instance mit Failover neu starten. Weitere Informationen über das Neustarten einer DB-Instance finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md).
Amazon RDS führt den Failover-Prozess automatisch durch, sodass der Datenbankbetrieb so schnell wie möglich und ohne Verwaltungseingriff wieder aufgenommen werden kann. Die primäre DB-Instance schaltet automatisch auf das Standby-Replikat um, wenn eine der in der folgenden Tabelle beschriebenen Bedingungen eintritt: Sie können diese Failover-Gründe im RDS-Ereignisprotokoll einsehen.
****
| Failover-Grund | Beschreibung |
| --- | --- |
| `The operating system for the RDS Custom for SQL Server Multi-AZ DB instance is being patched in an offline operation` | Ein Failover wurde während des Wartungsfensters für einen Betriebssystem-Patch oder ein Sicherheitsupdate ausgelöst. Weitere Informationen finden Sie unter [Warten einer DB-Instance](USER_UpgradeDBInstance.Maintenance.md). |
| `The primary host of the RDS Custom for SQL Server Multi-AZ DB instance is unhealthy.` | Die Multi-AZ-DB-Instance-Bereitstellung hat eine beeinträchtigte primäre DB-Instance erkannt und ein Failover eingeleitet. |
| `The primary host of the RDS Custom for SQL Server Multi-AZ DB instance is unreachable due to loss of network connectivity.` | Die RDS-Überwachung hat einen Fehler bei der Erreichbarkeit des Netzwerks für die primäre DB-Instance festgestellt und ein Failover ausgelöst. |
| `The RDS Custom for SQL Server Multi-AZ DB instance was modified by the customer.` | Eine Änderung der DB-Instance hat ein Failover ausgelöst. Weitere Informationen finden Sie unter [Ändern einer RDS Custom for SQL Server-DB-Instance](custom-managing.modify-sqlserver.md). |
| `The storage volume of the primary host of the RDS Custom for SQL Server Multi-AZ DB instance experienced a failure.` | Die Multi-AZ-DB-Instance-Bereitstellung hat ein Speicherproblem der primären DB-Instance erkannt und ein Failover eingeleitet. |
| `The user requested a failover of the RDS Custom for SQL Server Multi-AZ DB instance.` | Die Multi-AZ-DB-Instance von RDS Custom für SQL Server wurde mit einem Failover neu gestartet. Weitere Informationen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md). |
| `The RDS Custom for SQL Server Multi-AZ primary DB instance is busy or unresponsive.` | Die primäre DB-Instance reagiert nicht. Wir empfehlen, die folgenden Schritte auszuprobieren: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/custom-sqlserver-multiaz.failover.html) |
Um festzustellen, ob Ihre Multi-AZ-DB-Instance erfolgreich ausgeführt wurde, können Sie Folgendes tun:
+ Sie können Benachrichtigungen per E-Mail oder per SMS für DB-Ereignisse abonnieren, bei denen ein Failover ausgelöst wird. Weitere Informationen über -Ereignisse finden Sie unter [Arbeiten mit Amazon-RDS-Ereignisbenachrichtigungen](USER_Events.md).
+ Sie können Ihre DB-Ereignisse über die RDS-Konsole oder mittels API-Operationen anzeigen.
+ Zeigen Sie den aktuellen Status Ihrer Multi-AZ-DB-Instance-Bereitstellung von RDS Custom für SQL Server mithilfe der RDS-Konsole, der CLI oder von API-Vorgängen an.
## Time to Live (TTL)-Einstellungen für Anwendungen, die eine Multi-AZ-Bereitstellung von RDS Custom für SQL Server verwenden
Bei dem Failover-Prozess wird der DNS-Datensatz (Domain Name System) der DB-Instance so geändert, dass er auf die Standby-DB-Instance verweist. Als Ergebnis müssen alle bestehenden Verbindungen zu Ihrer DB-Instance neu hergestellt werden. Stellen Sie sicher, dass der Time to Live (TTL)-Konfigurationswert für den DNS-Cache niedrig ist, und stellen Sie sicher, dass Ihre Anwendung DNS nicht für längere Zeit zwischenspeichert. Ein hoher TTL-Wert kann verhindern, dass Ihre Anwendung nach einem Failover schnell wieder eine Verbindung mit der DB-Instance herstellt.
# Sichern und Wiederherstellen einer DB-Instance von Amazon RDS Custom für SQL Server
Wie Amazon RDS erstellt RDS Custom automatisierte Backups Ihrer DB-Instance von RDS Custom für SQL Server und speichert diese, wenn die Aufbewahrung für Sicherungen aktiviert ist. Sie können Ihre DB-Instance auch sichern, indem Sie manuell einen DB-Snapshot erstellen. Die automatisierten Backups bestehen aus Snapshot-Backups und Transaktionsprotokoll-Backups. Snapshot-Backups werden für das gesamte Speichervolumen der DB-Instance während des von Ihnen angegebenen Backup-Fensters erstellt. In regelmäßigen Abständen werden Transaktionsprotokoll-Backups für die PITR-fähigen Datenbanken erstellt. RDS Custom speichert die automatischen Backups Ihrer DB-Instance gemäß der angegebenen Aufbewahrungsfrist für Backups. Sie können automatisierte Backups verwenden, um Ihre DB-Instance auf einen Zeitpunkt innerhalb des Aufbewahrungszeitraums für Backups wiederherzustellen.
Sie können Snapshot-Backups auch manuell erstellen. Sie können eine neue DB-Instance aus diesen Snapshot-Backups erstellen. Weitere Informationen zum manuellen Erstellen eines DB-Snapshots finden Sie unter [Erstellen eines Snapshots von RDS Custom für SQL Server](custom-backup-sqlserver.creating.md).
Obwohl Snapshot-Backups betrieblich als vollständige Backups fungieren, werden Ihnen nur die inkrementellen Speichernutzungen in Rechnung gestellt. Der erste Snapshot einer RDS Custom DB-Instance enthält die Daten der vollständigen DB-Instance. Bei den nachfolgenden Snapshots derselben Datenbank handelt es sich um inkrementelle Snapshots, d. h. es werden nur die Daten gespeichert, die sich seit der letzten Snapshot-Speicherung geändert haben.
**Topics**
+ [Erstellen eines Snapshots von RDS Custom für SQL Server](custom-backup-sqlserver.creating.md)
+ [Wiederherstellen von einem DB-Snapshot von RDS Custom für SQL Server](custom-backup-sqlserver.restoring.md)
+ [Wiederherstellen einer Instance von RDS Custom für SQL Server auf einen bestimmten Zeitpunkt](custom-backup.pitr-sqs.md)
+ [Löschen eines Snapshots von RDS Custom für SQL Server](custom-backup-sqlserver.deleting.md)
+ [Löschen von automatisierten Backups von RDS Custom für SQL Server](custom-backup-sqlserver.deleting-backups.md)
# Erstellen eines Snapshots von RDS Custom für SQL Server
RDS Custom für SQL Server erstellt einen Snapshot für das Speichervolume Ihrer DB-Instance, damit die gesamte DB-Instance gesichert wird und nicht nur einzelne Datenbanken. Wenn Sie einen Snapshot erstellen, geben Sie an, welche DB-Instance von RDS Custom für SQL Server gesichert werden soll. Geben Sie dann dem DB-Snapshot einen Namen, sodass über diesen eine Wiederherstellung zu einem späteren Zeitpunkt möglich ist.
Wenn Sie einen Snapshot erstellen, erstellt RDS Custom für SQL Server einen Amazon-EBS-Snapshot für Volume `(D:)`, das das Datenbank-Volume ist, das der DB-Instance angefügt ist. Damit Snapshots einfach mit einer bestimmten DB-Instance verknüpft werden können, werden sie mit `DBSnapshotIdentifier`, `DbiResourceId` und `VolumeType` getaggt.
Das Erstellen eines DB-Snapshots führt zu einer kurzen I/O-Suspendierung. Diese Suspendierung kann je nach Größe und Klasse Ihrer DB-Instance einige Sekunden bis einige Minuten dauern. Die Erstellungszeit für Snapshots variiert je nach Gesamtanzahl und Größe Ihrer Datenbank. Weitere Informationen zur Anzahl der Datenbanken, die für eine Wiederherstellung zu einem bestimmten Zeitpunkt (PITR) in Frage kommen, finden Sie unter [Anzahl der Datenbanken, die für PITR in Frage kommen, pro Instance-Klassentyp](custom-backup.pitr-sqs.md#custom-backup.pitr.sqlserver.eligiblecountperinstance).
Da der Snapshot das gesamte Speichervolume umfasst, wirkt sich die Größe von Dateien, wie z. B. temporäre Dateien, auch auf die Zeit aus, die zum Erstellen des Snapshots benötigt wird. Weitere Informationen zum Erstellen von Snapshots finden Sie unter [Erstellen eines DB-Snapshots für eine DB-Instance mit Single-AZ für Amazon RDS](USER_CreateSnapshot.md).
Erstellen Sie einen Snapshot von RDS Custom für SQL Server mit der Konsole oder der AWS CLI.
## Konsole
**So erstellen Sie einen benutzerdefinierten RDS Snapshot**
1. Melden Sie sich bei der AWS-Managementkonsole an 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 **Datenbanken** aus.
1. Wählen Sie in der Liste der RDS Custom die DB-Instance, für die Sie einen Snapshot erstellen möchten.
1. Wählen Sie für **Aktionen** die Option **Take snapshot (Snapshot aufnehmen)**.
Das Fenster **Take DB Snapshot (DB-Snapshot erstellen)** wird angezeigt.
1. Geben Sie den Namen des Snapshots in das Feld **Snapshot name (Snapshot-Name)** ein.
1. Wählen Sie **Take Snapshot (Snapshot erstellen)** aus.
## AWS CLI
Sie erstellen einen Snapshot Ihrer RDS Custom DB-Instance unter Verwendung des [erstellen-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-snapshot.html) AWS CLI-Befehls.
Folgende Optionen stehen Ihnen zur Verfügung:
+ `--db-instance-identifier` — Identifiziert, welche RDS-DB-Instance Sie sichern werden
+ `--db-snapshot-identifier` — Benennt Ihren RDS-Snapshot, sodass Sie später wiederherstellen können
In diesem Beispiel erstellen Sie den DB-Snapshot *`my-custom-snapshot`* für die RDS Custom DB-Instance mit dem Namen `my-custom-instance`.
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds create-db-snapshot \
2. --db-instance-identifier my-custom-instance \
3. --db-snapshot-identifier my-custom-snapshot
```
Windows:
```
1. aws rds create-db-snapshot ^
2. --db-instance-identifier my-custom-instance ^
3. --db-snapshot-identifier my-custom-snapshot
```
# Wiederherstellen von einem DB-Snapshot von RDS Custom für SQL Server
Wenn Sie eine DB-Instance von RDS Custom für SQL Server wiederherstellen, geben Sie den Namen des DB-Snapshots und einen Namen für die neue Instance an. Sie können nicht von einem Snapshot auf eine vorhandene RDS-DB-Instance wiederherstellen. Bei der Wiederherstellung wird eine neue DB-Instance von RDS Custom für SQL Server erstellt.
Bei der Wiederherstellung aus einem Snapshot wird das Speicher-Volume auf den Zeitpunkt zurückgesetzt, zu dem der Snapshot erstellt wurde. Dies schließt alle Datenbanken und alle anderen Dateien ein, die auf dem Volume `(D:)` vorhanden waren.
## Konsole
**Wiederherstellen einer RDS Custom DB-Instance aus einem DB-Snapshot**
1. Melden Sie sich bei der AWS-Managementkonsole an 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 die Option **Snapshots**.
1. Wählen Sie den DB-Snapshot für die Wiederherstellung aus.
1. Wählen Sie in **Actions (Aktionen)** die Option **Restore Snapshot (Snapshot wiederherstellen)** aus.
1. Geben Sie auf der Seite **Restore DB instance** (DB-Instance wiederherstellen) unter **DB-Instance-Kennung** den Namen der wiederhergestellten RDS Custom Instance ein.
1. Klicken Sie auf **Restore DB Instance** (DB-Instance wiederherstellen).
## AWS CLI
Sie stellen einen RDS Custom DB-Snapshot wieder her, indem Sie den [restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) AWS CLI-Befehl nutzen.
Wenn der Snapshot, von dem Sie wiederherstellen, für eine private DB-Instance bestimmt ist, geben Sie beide die richtigen `db-subnet-group-name` und `no-publicly-accessible` an. Andernfalls ist die DB-Instance standardmäßig öffentlich zugänglich. Die folgenden Optionen sind erforderlich:
+ `db-snapshot-identifier` — Identifiziert den Snapshot, aus dem wiederhergestellt werden soll
+ `db-instance-identifier` — Gibt den Namen der RDS Custom DB-Instance an, die aus dem DB-Snapshot erstellt werden soll
+ `custom-iam-instance-profile` – Gibt das Instance-Profil an, das mit der zugrunde liegenden Amazon-EC2-Instance einer RDS-Custom-DB-Instance verknüpft ist.
Der folgende Code stellt den Snapshot mit dem Namen `my-custom-snapshot` zu `my-custom-instance` her.
**Example**
Für Linux, macOS oder Unix:
```
aws rds restore-db-instance-from-db-snapshot \
--db-snapshot-identifier my-custom-snapshot \
--db-instance-identifier my-custom-instance \
--custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance \
--no-publicly-accessible
```
Windows:
```
aws rds restore-db-instance-from-db-snapshot ^
--db-snapshot-identifier my-custom-snapshot ^
--db-instance-identifier my-custom-instance ^
--custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance ^
--no-publicly-accessible
```
# Wiederherstellen einer Instance von RDS Custom für SQL Server auf einen bestimmten Zeitpunkt
Sie können eine DB-Instanceeinen DB-Cluster zu einem bestimmten Zeitpunkt wiederherstellen, indem Sie eine neue DB-Instanceeinen neuen DB-Cluster erstellen. Um PITR zu unterstützen, muss für Ihre DB-Instances die Sicherheitsaufbewahrung aktiviert sein.
Die späteste wiederherstellbare Zeit für eine DB-Instance von RDS Custom für SQL Server hängt von mehreren Faktoren ab, liegt jedoch normalerweise innerhalb von 5 Minuten vor dem aktuellen Zeitpunkt. Um den letzten wiederherstellbaren Zeitpunkt für eine DB-Instance zu ermitteln, verwenden Sie den AWS CLI [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)Befehl und sehen Sie sich den Wert an, der im `LatestRestorableTime` Feld für die DB-Instance zurückgegeben wurde. Um die neueste Wiederherstellungszeit für jede DB-Instance in der Amazon-RDS-Konsole anzuzeigen, wählen Sie **Automatische Backups**.
Sie können die Backup auf jeden beliebigen Zeitpunkt innerhalb des Aufbewahrungszeitraums für Backups vornehmen. Um den frühesten wiederherstellbaren Zeitpunkt für jede DB-Instance anzuzeigen, wählen Sie **Automatische Backups** in der Amazon-RDS-Konsole aus.
Allgemeine Informationen zu PITR finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).
**Topics**
+ [Überlegungen zu PITRs für RDS Custom für SQL Server](#custom-backup.pitr.sqlserver)
+ [Anzahl der Datenbanken, die für PITR in Frage kommen, pro Instance-Klassentyp](#custom-backup.pitr.sqlserver.eligiblecountperinstance)
+ [Datenbanken für PITR nicht berechtigt machen](#custom-backup.pitr.sqlserver.ineligible)
+ [Transaktionsprotokolle in Amazon S3](#custom-backup.pitr.sqlserver.tlogs)
+ [PITR Restore mit der, der oder der RDS-API. AWS-Managementkonsole AWS CLI](#custom-backup.pitr-sqs-concli)
## Überlegungen zu PITRs für RDS Custom für SQL Server
In RDS Custom für SQL Server unterscheidet sich PITR in folgenden wichtigen Weisen von PITR in Amazon RDS:
+ PITR stellt nur die Datenbanken in der DB-Instance wieder her. Es stellt das Betriebssystem oder die Dateien auf dem Laufwerk C: nicht wieder her.
+ Für eine RDS Custom für SQL Server DB-Instance wird eine Datenbank automatisch gesichert und ist nur unter den folgenden Bedingungen für PITR berechtigt:
+ Die Datenbank ist online.
+ Sein Wiederherstellungsmodell ist auf `FULL` gesetzt.
+ Es ist beschreibbar.
+ Es hat seine physischen Dateien auf dem Laufwerk D:.
+ Sie ist nicht in der `rds_pitr_blocked_databases`-Tabelle aufgeführt. Weitere Informationen finden Sie unter [Datenbanken für PITR nicht berechtigt machen](#custom-backup.pitr.sqlserver.ineligible).
+ Die Datenbanken, die für PITR in Frage kommen, werden durch die Reihenfolge ihrer Datenbank-ID bestimmt. RDS Custom für SQL Server erlaubt bis zu 5 000 Datenbanken pro DB-Instance. Die maximale Anzahl von Datenbanken, die durch einen PITR-Vorgang für eine RDS-Custom-for-SQL-Server-DB-Instance wiederhergestellt werden, hängt vom Instance-Klassentyp ab. Weitere Informationen finden Sie unter [Anzahl der Datenbanken, die für PITR in Frage kommen, pro Instance-Klassentyp](#custom-backup.pitr.sqlserver.eligiblecountperinstance).
Andere Datenbanken, die nicht Teil von PITR sind, können aus DB-Snapshots wiederhergestellt werden, einschließlich der automatisierten Snapshot-Backups, die für PITR verwendet werden.
+ Das Hinzufügen einer neuen Datenbank, das Umbenennen einer Datenbank oder das Wiederherstellen einer Datenbank, die für PITR berechtigt ist, initiiert einen Snapshot der DB-Instance.
+ Die maximale Anzahl von Datenbanken, die für PITR in Frage kommen, ändert sich je nach Klassentyp der Ziel-Instance, wenn die Datenbank-Instance einen Skalierungsberechnungsvorgang durchläuft. Wenn die Instance hochskaliert wird, sodass mehr Datenbanken auf der Instance für PITR in Frage kommen, wird ein neuer Snapshot erstellt.
+ Wiederhergestellte Datenbanken haben denselben Namen wie in der Quell-DB-Instance. Wenn Sie möchten, können Sie einen anderen Namen eingeben.
+ `AWSRDSCustomSQLServerIamRolePolicy`erfordert Zugriff auf andere AWS Dienste. Weitere Informationen finden Sie unter [Fügen Sie eine Zugriffsrichtlinie hinzu zu AWSRDSCustom SQLServer InstanceRole](custom-setup-sqlserver.md#custom-setup-sqlserver.iam.add-policy).
+ Zeitzonenänderungen werden für RDS Custom für SQL Server nicht unterstützt. Wenn Sie die Zeitzone des Betriebssystems oder der DB-Instance ändern, funktioniert PITR (und andere Automatisierung) nicht.
## Anzahl der Datenbanken, die für PITR in Frage kommen, pro Instance-Klassentyp
Die folgende Tabelle zeigt die maximale Anzahl von Datenbanken, die für PITR-Anwendungen in Frage kommen, basierend auf dem Instance-Klassentyp.
| Typ der Instance-Klasse | Maximale Anzahl der Datenbanken, die für PITR in Frage kommen |
| --- | --- |
| db.\$1.large | 100 |
| db.\$1.xlarge zu db.\$1.2xlarge | 150 |
| db.\$1.4xlarge zu db.\$1.8xlarge | 300 |
| db.\$1.12xlarge zu db.\$1.16xlarge | 600 |
| db.\$1.24xlarge, db.\$132xlarge | 1000 |
`*` *stellt die unterschiedlichen Typen von Instance-Klassen dar.*
Die maximale Anzahl von Datenbanken, die für PITR in einer DB-Instance in Frage kommen, hängt vom Instance-Klassentyp ab. Die Anzahl reicht von 100 bei den kleinsten Instance-Klassentypen bis zu 1000 bei den größten Instance-Klassentypen, die von RDS Custom für SQL Server unterstützt werden. SQL-Server-Systemdatenbanken `(master, model, msdb, tempdb)` unterliegen nicht dieser Beschränkung. Wenn eine DB-Instance je nach Typ der Ziel-Instance-Klasse hoch- oder herunterskaliert wird, aktualisiert RDS Custom automatisch die Anzahl der Datenbanken, die für PITR in Frage kommen. RDS Custom für SQL Server will send `RDS-EVENT-0352`, wenn sich die maximale Anzahl von Datenbanken, die für PITR-Anwendungen in Frage kommen, auf einer -DB-Instance ändert. Weitere Informationen finden Sie unter [Benutzerdefinierte Engine-Versionsereignisse](USER_Events.Messages.md#USER_Events.Messages.CEV).
**Anmerkung**
Die PITR-Unterstützung für mehr als 100 Datenbanken ist nur für DB-Instances verfügbar, die nach dem 26. August 2023 erstellt wurden. Für Instances, die vor dem 26. August 2023 erstellt wurden, beträgt die maximale Anzahl von Datenbanken, die für PITR in Frage kommen, 100, unabhängig von der Instance-Klasse. Um die PITR-Unterstützung für mehr als 100 Datenbanken auf DB-Instances zu aktivieren, die vor dem 26. August 2023 erstellt wurden, können Sie die folgende Aktion ausführen:
Aktualisieren Sie die DB-Engine-Version auf 15.00.4322.2.v1 oder höher
Während eines PITR-Vorgangs stellt RDS Custom alle Datenbanken wieder her, die zum Zeitpunkt der Wiederherstellung Teil von PITR auf der Quell-DB-Instance waren. Sobald die Ziel-DB-Instance die Wiederherstellungsvorgänge abgeschlossen hat und die Sicherung aktiviert ist, beginnt die DB-Instance mit der Sicherung auf der Grundlage der maximalen Anzahl von Datenbanken, die für PITR auf der Ziel-DB-Instance in Frage kommen.
Wenn Ihre DB-Instance beispielsweise auf einer `db.*.xlarge` mit 200 Datenbanken läuft:
1. RDS Custom für SQL Server wählt die ersten 150 Datenbanken, sortiert nach ihrer Datenbank-ID, für die PITR-Sicherung aus.
1. Sie ändern die Instance so, dass sie auf db.\$1.4xlarge skaliert wird.
1. Sobald der Skalierungsrechenvorgang abgeschlossen ist, wählt RDS Custom für SQL Server die ersten 300 Datenbanken, sortiert nach ihrer Datenbank-ID, für die PITR-Sicherung aus. Jede der 200 Datenbanken, die die PITR-Anforderungen erfüllen, kommt nun für PITR in Frage.
1. Sie ändern jetzt die Instance, sodass sie wieder auf db.\$1.xlarge herunterskaliert wird.
1. Sobald der Skalierungsrechenvorgang abgeschlossen ist, wählt RDS Custom für SQL Server erneut die ersten 150 Datenbanken, sortiert nach ihrer Datenbank-ID, für die PITR-Backup aus.
## Datenbanken für PITR nicht berechtigt machen
Sie können wählen, ob einzelne Datenbanken von PITR ausgeschlossen werden sollen. Um dies zu tun, legen Sie ihre `database_id`-Werte in eine `rds_pitr_blocked_databases`-Tabelle. Verwenden Sie den folgenden -Befehl, um die Tabelle zu erstellen.
**So erstellen Sie die Tabelle „rds\$1pitr\$1blocked\$1databases“**
+ Führen Sie das folgende Skript aus.
```
create table msdb..rds_pitr_blocked_databases
(
database_id INT NOT NULL,
database_name SYSNAME NOT NULL,
db_entry_updated_date datetime NOT NULL DEFAULT GETDATE(),
db_entry_updated_by SYSNAME NOT NULL DEFAULT CURRENT_USER,
PRIMARY KEY (database_id)
);
```
Eine Liste der berechtigten und nicht berechtigten Datenbanken finden Sie in der `RI.End`-Datei im `RDSCustomForSQLServer/Instances/DB_instance_resource_ID/TransactionLogMetadata`-Verzeichnis im Amazon S3-Bucket `do-not-delete-rds-custom-$ACCOUNT_ID-$REGION-unique_identifier`. Weitere Informationen zur Datei `RI.End` finden Sie unter [Transaktionsprotokolle in Amazon S3](#custom-backup.pitr.sqlserver.tlogs).
Sie können die Liste der Datenbanken, die für PITR in Frage kommen, auch mithilfe des folgenden SQL-Skripts ermitteln. Setzen Sie die `@limit`-Variable auf die maximale Anzahl von Datenbanken, die für PITR in der Instance-Klasse in Frage kommen. Weitere Informationen finden Sie unter [Anzahl der Datenbanken, die für PITR in Frage kommen, pro Instance-Klassentyp](#custom-backup.pitr.sqlserver.eligiblecountperinstance).
**So ermitteln Sie die Liste der für PITR in Frage kommenden Datenbanken in einer DB-Instance-Klasse**
+ Führen Sie das folgende Skript aus.
```
DECLARE @Limit INT;
SET @Limit = (insert-database-instance-limit-here);
USE msdb;
IF (EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'dbo' AND TABLE_NAME = 'rds_pitr_blocked_databases'))
WITH TABLE0 AS (
SELECT hdrs.database_id as DatabaseId, sdb.name as DatabaseName, 'ALWAYS_ON_NOT_WRITABLE_REPLICA' as Reason, NULL as DatabaseNameOnPitrTable
FROM sys.dm_hadr_database_replica_states hdrs
INNER JOIN sys.databases sdb ON sdb.database_id = hdrs.database_id
WHERE (hdrs.is_local = 1 AND hdrs.is_primary_replica = 0)
OR (sys.fn_hadr_is_primary_replica (sdb.name) = 1 AND DATABASEPROPERTYEX (sdb.name, 'Updateability') = 'READ_ONLY')
),
TABLE1 as (
SELECT dbs.database_id as DatabaseId, sysdbs.name as DatabaseName, 'OPTOUT' as Reason,
CASE WHEN dbs.database_name = sysdbs.name THEN NULL ELSE dbs.database_name END AS DatabaseNameOnPitrTable
FROM msdb.dbo.rds_pitr_blocked_databases dbs
INNER JOIN sys.databases sysdbs ON dbs.database_id = sysdbs.database_id
WHERE sysdbs.database_id > 4
),
TABLE2 as (
SELECT
db.name AS DatabaseName,
db.create_date AS CreateDate,
db.state_desc AS DatabaseState,
db.database_id AS DatabaseId,
rs.database_guid AS DatabaseGuid,
rs.last_log_backup_lsn AS LastLogBackupLSN,
rs.recovery_fork_guid RecoveryForkGuid,
rs.first_recovery_fork_guid AS FirstRecoveryForkGuid,
db.recovery_model_desc AS RecoveryModel,
db.is_auto_close_on AS IsAutoClose,
db.is_read_only as IsReadOnly,
NEWID() as FileName,
CASE WHEN(db.state_desc = 'ONLINE'
AND db.recovery_model_desc != 'SIMPLE'
AND((db.is_auto_close_on = 0 and db.collation_name IS NOT NULL) OR db.is_auto_close_on = 1))
AND db.is_read_only != 1
AND db.user_access = 0
AND db.source_database_id IS NULL
AND db.is_in_standby != 1
THEN 1 ELSE 0 END AS IsPartOfSnapshot,
CASE WHEN db.source_database_id IS NULL THEN 0 ELSE 1 END AS IsDatabaseSnapshot
FROM sys.databases db
INNER JOIN sys.database_recovery_status rs
ON db.database_id = rs.database_id
WHERE DB_NAME(db.database_id) NOT IN('tempdb') AND
db.database_id NOT IN (SELECT DISTINCT DatabaseId FROM TABLE1) AND
db.database_id NOT IN (SELECT DISTINCT DatabaseId FROM TABLE0)
),
TABLE3 as(
Select @Limit+count(DatabaseName) as TotalNumberOfDatabases from TABLE2 where TABLE2.IsPartOfSnapshot=1 and DatabaseName in ('master','model','msdb')
)
SELECT TOP(SELECT TotalNumberOfDatabases from TABLE3) DatabaseName,CreateDate,DatabaseState,DatabaseId from TABLE2 where TABLE2.IsPartOfSnapshot=1
ORDER BY TABLE2.DatabaseID ASC
ELSE
WITH TABLE0 AS (
SELECT hdrs.database_id as DatabaseId, sdb.name as DatabaseName, 'ALWAYS_ON_NOT_WRITABLE_REPLICA' as Reason, NULL as DatabaseNameOnPitrTable
FROM sys.dm_hadr_database_replica_states hdrs
INNER JOIN sys.databases sdb ON sdb.database_id = hdrs.database_id
WHERE (hdrs.is_local = 1 AND hdrs.is_primary_replica = 0)
OR (sys.fn_hadr_is_primary_replica (sdb.name) = 1 AND DATABASEPROPERTYEX (sdb.name, 'Updateability') = 'READ_ONLY')
),
TABLE1 as (
SELECT
db.name AS DatabaseName,
db.create_date AS CreateDate,
db.state_desc AS DatabaseState,
db.database_id AS DatabaseId,
rs.database_guid AS DatabaseGuid,
rs.last_log_backup_lsn AS LastLogBackupLSN,
rs.recovery_fork_guid RecoveryForkGuid,
rs.first_recovery_fork_guid AS FirstRecoveryForkGuid,
db.recovery_model_desc AS RecoveryModel,
db.is_auto_close_on AS IsAutoClose,
db.is_read_only as IsReadOnly,
NEWID() as FileName,
CASE WHEN(db.state_desc = 'ONLINE'
AND db.recovery_model_desc != 'SIMPLE'
AND((db.is_auto_close_on = 0 and db.collation_name IS NOT NULL) OR db.is_auto_close_on = 1))
AND db.is_read_only != 1
AND db.user_access = 0
AND db.source_database_id IS NULL
AND db.is_in_standby != 1
THEN 1 ELSE 0 END AS IsPartOfSnapshot,
CASE WHEN db.source_database_id IS NULL THEN 0 ELSE 1 END AS IsDatabaseSnapshot
FROM sys.databases db
INNER JOIN sys.database_recovery_status rs
ON db.database_id = rs.database_id
WHERE DB_NAME(db.database_id) NOT IN('tempdb') AND
db.database_id NOT IN (SELECT DISTINCT DatabaseId FROM TABLE0)
),
TABLE2 as(
SELECT @Limit+count(DatabaseName) as TotalNumberOfDatabases from TABLE1 where TABLE1.IsPartOfSnapshot=1 and DatabaseName in ('master','model','msdb')
)
select top(select TotalNumberOfDatabases from TABLE2) DatabaseName,CreateDate,DatabaseState,DatabaseId from TABLE1 where TABLE1.IsPartOfSnapshot=1
ORDER BY TABLE1.DatabaseID ASC
```
**Anmerkung**
Die Datenbanken, bei denen es sich nur um symbolische Links handelt, sind ebenfalls von Datenbanken ausgeschlossen, die für PITR-Operationen in Frage kommen. Die obige Abfrage filtert nicht nach diesen Kriterien.
## Transaktionsprotokolle in Amazon S3
Der Aufbewahrungszeitraum für Backups bestimmt, ob Transaktionsprotokolle für RDS Custom für SQL Server DB-Instances automatisch extrahiert und auf Amazon S3 hochgeladen werden. Ein Wert ungleich Null bedeutet, dass automatische Backups erstellt werden und der RDS Custom Agent die Transaktionsprotokolle alle 5 Minuten auf S3 hochlädt.
Transaktionsprotokolldateien auf S3 werden im Ruhezustand mit dem AWS KMS key die Sie angegeben haben, als Sie Ihre DB-Instance erstellt haben. Weitere Informationen finden Sie unter [Schutz von Daten durch serverseitige](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) Verschlüsselung im *Amazon Simple Storage Service User Guide*.
Die Transaktionsprotokolle für jede Datenbank werden in einen S3-Bucket namens `do-not-delete-rds-custom-$ACCOUNT_ID-$REGION-unique_identifier` hochgeladen. Das `RDSCustomForSQLServer/Instances/DB_instance_resource_ID`-Verzeichnis im S3-Bucket enthält zwei Unterverzeichnisse:
+ `TransactionLogs` — Enthält die Transaktionsprotokolle für jede Datenbank und ihre jeweiligen Metadaten.
Der Name der Transaktionslog-Datei folgt dem Muster `yyyyMMddHHmm.database_id.timestamp`, Beispiel:
```
202110202230.11.1634769287
```
Derselbe Dateiname mit dem Suffix `_metadata` enthält Informationen über das Transaktionslog wie Log-Sequenznummern, Datenbankname und `RdsChunkCount`. `RdsChunkCount`bestimmt, wie viele physische Dateien eine einzelne Transaktionslogdatei darstellen. Möglicherweise sehen Sie Dateien mit Suffixen `_0001`, `_0002` und so weiter, was die physischen Teile einer Transaktionslogdatei bedeutet. Wenn Sie eine Chunked Transaktionslogdatei verwenden möchten, müssen Sie die Chunks nach dem Herunterladen zusammenführen.
Betrachten Sie ein Szenario, in dem Sie folgende Dateien haben:
+ `202110202230.11.1634769287`
+ ` 202110202230.11.1634769287_0001`
+ ` 202110202230.11.1634769287_0002 `
+ ` 202110202230.11.1634769287_metadata`
Das `RdsChunkCount` ist `3`. Die Reihenfolge zum Zusammenführen der Dateien ist die folgende: `202110202230.11.1634769287`, ` 202110202230.11.1634769287_0001`, `202110202230.11.1634769287_0002`.
+ `TransactionLogMetadata` — Enthält Metadateninformationen über jede Iteration der Transaktionslog-Extraktion.
Die `RI.End` enthält Informationen für alle Datenbanken, deren Transaktionsprotokolle extrahiert wurden, und für alle Datenbanken, die vorhanden sind, aber ihre Transaktionsprotokolle nicht extrahiert wurden. Der `RI.End`-Dateiname folgt dem Muster `yyyyMMddHHmm.RI.End.timestamp`, Beispiel:
```
202110202230.RI.End.1634769281
```
## PITR Restore mit der, der oder der RDS-API. AWS-Managementkonsole AWS CLI
Sie können eine RDS Custom for SQL Server-DB-Instance zu einem bestimmten Zeitpunkt mithilfe der AWS-ManagementkonsoleAWS CLI, der oder der RDS-API wiederherstellen.
### Konsole
**Wiederherstellen einer DB-Instance eines RDS Custom zu einer bestimmten Zeit**
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 **Automated backups** (Automatisierte Backups) aus.
1. Wählen Sie die RDS Custom DB-Instance aus, die Sie wiederherstellen möchten.
1. Wählen Sie unter **Aktionen** die Option **Wiederherstellen auf einen bestimmten Zeitpunkt** aus.
Anschließend wird das Fenster **Restore to point in time (Zu einem bestimmten Zeitpunkt wiederherstellen)** angezeigt.
1. Wählen Sie **Späteste Wiederherstellungszeit**, um auf den spätesten möglichen Zeitpunkt wiederherzustellen oder wählen Sie **Benutzerdefiniert**, um eine Zeit auszuwählen.
Geben Sie bei der Auswahl von **Custom** das Datum und die Uhrzeit ein, zu der Sie den Instance-Cluster wiederherstellen möchten.
Zeiten werden in Ihrer lokalen Zeitzone angezeigt, die durch einen Offset von Coordinated Universal Time (UTC) angezeigt wird. UTC-5 ist beispielsweise Eastern Standard Time/Central Daylight Time.
1. Geben Sie für **DB-Instance-Kennung** den Namen der wiederhergestellten RDS Custom DB-Ziel-Instance ein. Der Name muss eindeutig sein.
1. Wählen Sie bei Bedarf andere Optionen aus, z. B. DB-Instance-Class.
1. Wählen Sie **Wiederherstellen auf einen bestimmten Zeitpunkt** aus.
### AWS CLI
Sie stellen eine DB-Instance zu einem bestimmten Zeitpunkt wieder her, indem Sie den point-in-time AWS CLI Befehl [ restore-db-instance-to-](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) verwenden, um eine neue benutzerdefinierte RDS-DB-Instance zu erstellen.
Verwenden Sie eine der folgenden Optionen, um die Sicherung anzugeben, von der wiederhergestellt werden soll:
+ `--source-db-instance-identifier mysourcedbinstance`
+ `--source-dbi-resource-id dbinstanceresourceID`
+ `--source-db-instance-automated-backups-arn backupARN`
Die Option `custom-iam-instance-profile` ist erforderlich.
Der folgende Befehl stellt `my-custom-db-instance` auf eine neue DB-Instance namens `my-restored-custom-db-instance` wieder her, und zwar zum angegebenen Zeitpunkt.
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds restore-db-instance-to-point-in-time \
2. --source-db-instance-identifier my-custom-db-instance\
3. --target-db-instance-identifier my-restored-custom-db-instance \
4. --custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance \
5. --restore-time 2022-10-14T23:45:00.000Z
```
Für Windows:
```
1. aws rds restore-db-instance-to-point-in-time ^
2. --source-db-instance-identifier my-custom-db-instance ^
3. --target-db-instance-identifier my-restored-custom-db-instance ^
4. --custom-iam-instance-profile AWSRDSCustomInstanceProfileForRdsCustomInstance ^
5. --restore-time 2022-10-14T23:45:00.000Z
```
# Löschen eines Snapshots von RDS Custom für SQL Server
Sie können DB-Snapshots löschen, die mit RDS Custom für SQL Server verwaltet werden, wenn Sie sie nicht mehr benötigen. Der Löschvorgang ist sowohl für Amazon-RDS- als auch für RDS Custom DB-Instances identisch.
Die Amazon-EBS-Snapshots für die Binär- und Root-Volumes bleiben länger in Ihrem Konto, da sie möglicherweise mit einigen Instances verknüpft sind, die in Ihrem Konto oder mit anderen Snapshots von RDS Custom für SQL Server ausgeführt werden. Diese EBS-Snapshots werden automatisch gelöscht, nachdem sie nicht mehr mit vorhandenen Ressourcen von RDS Custom für SQL Server (DB-Instances oder Backups) in Verbindung stehen.
## Konsole
**So löschen Sie einen Snapshot Ihrer RDS-DB-Instance**
1. Melden Sie sich bei der AWS-Managementkonsole an 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 die Option **Snapshots**.
1. Wählen Sie den DB-Snapshot aus, den Sie löschen möchten.
1. Wählen Sie unter **Actions (Aktionen)** die Option **Delete Snapshot (Snapshot löschen)** aus.
1. Wählen Sie auf der Bestätigungsseite die Option **Löschen** aus.
## AWS CLI
Um einen benutzerdefinierten RDS-Snapshot zu löschen, verwenden Sie den AWS CLI-Vefehl [delete-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-snapshot.html).
Die folgenden Optionen sind erforderlich:
+ `--db-snapshot-identifier` — Der zu löschende Snapshot
Das folgende Beispiel löscht den Cluster-Snapshot `my-custom-snapshot`.
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds delete-db-snapshot \
2. --db-snapshot-identifier my-custom-snapshot
```
Windows:
```
1. aws rds delete-db-snapshot ^
2. --db-snapshot-identifier my-custom-snapshot
```
# Löschen von automatisierten Backups von RDS Custom für SQL Server
Sie können aufbewahrte automatisierte Backups für RDS Custom für SQL Server löschen, wenn sie nicht mehr benötigt werden. Das Verfahren entspricht dem Verfahren zum Löschen von Amazon-RDS-Backups.
## Konsole
**So löschen Sie eine aufbewahrte automatisierte Backup:**
1. Melden Sie sich bei der AWS-Managementkonsole an 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 **Automated backups** (Automatisierte Backups) aus.
1. Wählen Sie **Retained (Aufbewahrt)**.
1. Wählen Sie die aufbewahrte automatisierte Sicherung, die Sie löschen möchten.
1. Klicken Sie bei ** Actions** auf **Delete**.
1. Geben Sie auf der Bestätigungsseite **delete me** und wählen Sie **Löschen** aus.
## AWS CLI
Sie können eine aufbewahrte automatisierte Sicherung mit dem AWS CLI-Befehl [delete-db-instance-automated-backup](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance-automated-backup.html) löschen.
Zum Löschen einer aufbewahrten automatisierten Sicherung werden die folgenden Optionen verwendet.
+ `--dbi-resource-id` – Die Ressourcenkennung für die Quell-RDS-Custom-DB-Instance.
Sie finden die Ressourcenkennung für die Quell-DB-Instance eines aufbewahrten automatisierten Backups mit dem AWS CLI-Befehl [describe-db-instance-automated-backups](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instance-automated-backups.html).
Im folgenden Beispiel wird das aufbewahrte automatisierte Backup mit der Quell-DB-Instance-Ressourcenkennung `custom-db-123ABCEXAMPLE` gelöscht.
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds delete-db-instance-automated-backup \
2. --dbi-resource-id custom-db-123ABCEXAMPLE
```
Windows:
```
1. aws rds delete-db-instance-automated-backup ^
2. --dbi-resource-id custom-db-123ABCEXAMPLE
```
# Kopieren eines DB-Snapshots von Amazon RDS Custom für SQL Server
Mit RDS Custom für SQL Server können Sie automatisierte Backups und manuelle DB-Snapshots kopieren. Nach dem Kopieren eines Snapshots ist die Kopie ein manueller Snapshot. Sie können mehrere Kopien eines automatisierten Backups oder eines manuellen Snapshots erstellen, aber jede Kopie muss über eine eindeutige Kennung verfügen.
Sie können einen Snapshot nur innerhalb desselben AWS Kontos zwischen verschiedenen Standorten kopieren, in AWS-Regionen denen RDS Custom for SQL Server verfügbar ist. Die folgenden Vorgänge werden derzeit nicht unterstützt:
+ DB-Snapshots innerhalb derselben AWS-Region kopieren.
+ DB-Snapshots zwischen AWS Konten kopieren.
RDS Custom für SQL Server unterstützt das inkrementelle Kopieren von Snapshots. Weitere Informationen finden Sie unter [Überlegungen zum inkrementellen Kopieren von Snapshots](USER_CopySnapshot.md#USER_CopySnapshot.Incremental).
**Topics**
+ [Einschränkungen](#custom-copying-snapshot-sqlserver.Limitations)
+ [Umgang mit Verschlüsselungen](#custom-copying-snapshot-sqlserver.Encryption)
+ [Regionsübergreifendes Kopieren](#custom-copying-snapshot-sqlserver.XRCopy)
+ [Snapshots von DB-Instances, die mit Custom Engine Versions (CEV) erstellt wurden](#custom-copying-snapshot-sqlserver.CEVSnap)
+ [Erteilen Sie die erforderlichen Berechtigungen für Ihren IAM-Prinzipal](#custom-copying-snapshot-sqlserver.GrantPermIAM)
+ [Kopieren eines DB-Snapshots](#custom-copying-snapshot-sqlserver.CopyingDBSnapshot)
## Einschränkungen
Die folgenden Einschränkungen gelten für das Kopieren eines DB-Snapshots für RDS für SQL Server:
+ Wenn Sie einen Quell-Snapshot löschen, bevor der Ziel-Snapshot verfügbar ist, kann das Kopieren des Snapshots fehlschlagen. Verifizieren Sie, dass der Ziel-Snapshot den Status `AVAILABLE` hat, bevor Sie den Quell-Snapshot löschen.
+ Sie können in Ihrer Anfrage zum Kopieren von DB-Snapshots keinen Namen für eine Optionsgruppe angeben oder eine Optionsgruppe kopieren.
+ Wenn Sie vor oder während des Kopiervorgangs abhängige AWS Ressourcen des Quell-DB-Snapshots löschen, kann Ihre Anfrage zum Kopieren des Snapshots asynchron fehlschlagen.
+ Wenn Sie die Service Master Key (SMK)-Sicherungsdatei für Ihre Quell-DB-Instance löschen, die im vom RDS Custom verwalteten S3-Bucket in Ihrem Konto gespeichert ist, wird die DB-Snapshot-Kopie asynchron erfolgreich ausgeführt. Bei Funktionen von SQL Server, die von SMK abhängig sind, wie z. B. TDE-fähige Datenbanken, treten jedoch Probleme auf. Weitere Informationen finden Sie unter [Problembehebung beim Status PENDING\$1RECOVERY für TDE-fähige Datenbanken in RDS Custom für SQL Server](custom-troubleshooting-sqlserver.md#custom-troubleshooting-sqlserver.pending_recovery).
+ Das Kopieren von DB-Snapshots innerhalb desselben AWS-Region wird derzeit nicht unterstützt.
+ Das Kopieren von DB-Snapshots zwischen AWS Konten wird derzeit nicht unterstützt.
Die Einschränkungen beim Kopieren eines DB-Snapshots von Amazon RDS gelten auch für RDS Custom für SQL Server. Weitere Informationen finden Sie unter [Einschränkungen](USER_CopySnapshot.md#USER_CopySnapshot.Limitations).
## Umgang mit Verschlüsselungen
Alle DB-Instances und DB-Snapshots von RDS Custom für SQL Server werden mit KMS-Schlüsseln verschlüsselt. Sie können nur einen verschlüsselten Snapshot in einen verschlüsselten Snapshot kopieren. Daher müssen Sie einen KMS-Schlüssel angeben, der im Ziel AWS-Region für Ihre Anfrage zum Kopieren von DB-Snapshots gültig ist.
Der Quell-Snapshot bleibt den gesamten Kopiervorgang über verschlüsselt. Amazon RDS verwendet Umschlagverschlüsselung, um Daten während des Kopiervorgangs mit dem angegebenen KMS-Schlüssel der Ziel- AWS-Region zu schützen. Weitere Informationen zur [Envelope-Verschlüsselung](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#enveloping) finden Sie im *AWS Key Management Service -Entwicklerhandbuch*.
## Regionsübergreifendes Kopieren
Sie können DB-Snapshots über AWS-Regionen hinweg kopieren. Es gibt jedoch bestimmte Einschränkungen und Überlegungen für das Kopieren von regionsübergreifenden Snapshots.
### Autorisieren von RDS zur Kommunikation beim Kopieren AWS-Regionen von Snapshots
Nachdem eine regionsübergreifenden DB-Snapshot-Kopieranforderung erfolgreich verarbeitet wurde, startet RDS die Kopie. Es wird eine Autorisierungsanforderung für RDS für den Zugriff auf den Quell-Snapshot erstellt. Diese Autorisierungsanforderung verknüpft den Quell-DB-Snapshot mit dem Ziel-DB-Snapshot. Dadurch kann RDS nur in den angegebenen Ziel-Snapshot kopieren.
RDS verifiziert die Autorisierung unter Verwendung der `rds:CrossRegionCommunication`-Berechtigung in der serviceverknüpften IAM-Rolle. Wenn die Kopie autorisiert ist, kann RDS mit der Quellregion kommunizieren und den Kopiervorgang abschließen.
RDS hat keinen Zugriff auf DB-Snapshots, die nicht zuvor durch eine DBSnapshot Kopieranforderung autorisiert wurden. Die Autorisierung wird widerrufen, wenn der Kopiervorgang abgeschlossen ist.
RDS verwendet die serviceverknüpfte Rolle, um die Autorisierung in der Quellregion zu überprüfen. Das Kopieren schlägt fehl, wenn Sie die serviceverknüpfte Rolle während des Kopiervorgangs löschen.
Weitere Informationen finden Sie unter [Verwenden von serviceverknüpften Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html) im *AWS Identity and Access Management -Benutzerhandbuch*.
### Anmeldeinformationen verwenden AWS -Security-Token-Service
Sitzungstoken vom Endpunkt global AWS -Security-Token-Service (AWS STS) sind nur in Regionen gültig AWS-Regionen , die standardmäßig aktiviert sind (kommerzielle Regionen). Wenn Sie Anmeldeinformationen aus dem `assumeRole` API-Vorgang in verwenden AWS STS, verwenden Sie den regionalen Endpunkt, wenn es sich bei der Quellregion um eine Opt-in-Region handelt. Andernfalls schlägt die Anforderung fehl. Ihre Anmeldeinformationen müssen in beiden Regionen gültig sein. Dies gilt nur für Opt-in-Regionen, wenn Sie den regionalen AWS STS Endpunkt verwenden.
Um den globalen Endpunkt zu verwenden, stellen Sie sicher, dass er für beide Regionen in den Vorgängen aktiviert ist. Stellen Sie den globalen Endpunkt `Valid` in den AWS STS Kontoeinstellungen AWS-Regionen auf „Alle“ ein.
Weitere Informationen finden Sie unter [Verwalten von AWS STS in einer AWS-Region](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html) im *AWS Identity and Access Management Benutzerhandbuch*.
## Snapshots von DB-Instances, die mit Custom Engine Versions (CEV) erstellt wurden
Bei einem DB-Snapshot einer DB-Instance, die eine [Custom Engine Version (CEV)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-cev-sqlserver.html) verwendet, ordnet RDS die CEV dem DB-Snapshot zu. Um einen Quell-DB-Snapshot, der einem CEV zugeordnet ist, hinüber zu kopieren AWS-Regionen, kopiert RDS den CEV zusammen mit dem Quell-DB-Snapshot in die Zielregion.
Wenn Sie mehrere DB-Snapshots, die derselben CEV zugeordnet sind, in dieselbe Zielregion kopieren, kopiert die erste Kopieranforderung die zugehörige CEV. Beim Kopiervorgang der folgenden Anforderungen wird die ursprünglich kopierte CEV gefunden und mit den folgenden DB-Snapshot-Kopien verknüpft. Die vorhandene CEV-Kopie muss den Status `AVAILABLE` haben, damit sie den DB-Snapshot-Kopien zugeordnet werden kann.
Um einen mit einer CEV verknüpften DB-Snapshot zu kopieren, muss die IAM-Richtlinie des Anforderers über die erforderlichen Berechtigungen verfügen, um sowohl das Kopieren von DB-Snapshots als auch das zugehörige CEV-Kopieren zu autorisieren. Die folgenden Berechtigungen sind in der IAM-Richtlinie Ihres Anforderers erforderlich, um das zugehörige CEV-Kopieren zu ermöglichen:
+ `rds:CopyCustomDBEngineVersion` – Ihr IAM-Principal, der die Anfrage gestellt hat, muss die Berechtigung haben, die Quell-CEV zusammen mit dem Quell-DB-Snapshot in die Zielregion zu kopieren. Die Anforderung zum Kopieren des Snapshots schlägt aufgrund von Autorisierungsfehlern fehl, wenn Ihr anfordernder IAM-Prinzipal nicht autorisiert ist, die Quell-CEV zu kopieren.
+ `ec2:CreateTags` – Das zugrunde liegende EC2-AMI der Quell-CEV wird im Rahmen der CEV-Kopie in die Zielregion kopiert. RDS Custom versucht, das AMI mit dem Tag `AWSRDSCustom` zu kennzeichnen, bevor das AMI kopiert wird. Stellen Sie sicher, dass Ihr IAM-Prinzipal, der die Anfrage gestellt hat, berechtigt ist, das Tag für das AMI zu erstellen, das der Quell-CEV in der Quellregion zugrunde liegt.
Weitere Informationen zu den Berechtigungen für das Kopieren von CEVs finden Sie unter [Erteilen Sie die erforderlichen Berechtigungen für Ihren IAM-Prinzipal](#custom-copying-snapshot-sqlserver.GrantPermIAM).
## Erteilen Sie die erforderlichen Berechtigungen für Ihren IAM-Prinzipal
Stellen Sie sicher, dass Sie über ausreichende Zugriffsrechte verfügen, um einen DB-Snapshot von RDS Custom für SQL Server zu kopieren. Die IAM-Rolle oder der Benutzer (als IAM-Prinzipal bezeichnet) zum Kopieren eines DB-Snapshots mit der Konsole oder der CLI, muss eine der folgenden Richtlinien haben, um eine DB-Instance erfolgreich zu erstellen:
+ Die Richtlinie `AdministratorAccess` oder
+ Die folgende `AmazonRDSFullAccess`-Richtlinie zeigt die zusätzlichen Berechtigungen.
```
s3:CreateBucket
s3:GetBucketPolicy
s3:PutBucketPolicy
kms:CreateGrant
kms:DescribeKey
ec2:CreateTags
```
RDS Custom verwendet diese Berechtigungen beim Kopieren von Snapshots über mehrere AWS-Regionen hinweg. Mit diesen Berechtigungen werden Ressourcen in Ihrem Konto konfiguriert, die für benutzerdefinierte RDS-Operationen erforderlich sind. Weitere Informationen zu `kms:CreateGrant`-Berechtigung finden Sie unter [AWS KMS key Verwaltung](Overview.Encryption.Keys.md).
Die folgende Beispiel-JSON-Richtlinie gewährt die erforderlichen Berechtigungen zusätzlich zur `AmazonRDSFullAccess`-Berechtigung.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CreateS3BucketAndReadWriteBucketPolicy",
"Effect": "Allow",
"Action": [
"s3:CreateBucket",
"s3:PutBucketPolicy",
"s3:GetBucketPolicy"
],
"Resource": "arn:aws:s3:::do-not-delete-rds-custom-*"
},
{
"Sid": "CreateKmsGrant",
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:DescribeKey"
],
"Resource": "*"
},
{
"Sid": "CreateEc2Tags",
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "*"
}
]
}
```
------
**Anmerkung**
Stellen Sie sicher, dass die aufgelisteten Berechtigungen nicht durch Dienststeuerungsrichtlinien (SCPs), Berechtigungsgrenzen oder Sitzungsrichtlinien eingeschränkt sind, die dem IAM-Prinzipal zugeordnet sind.
Wenn Sie Bedingungen mit Kontextschlüsseln in der IAM-Richtlinie des Anforderers verwenden, können bestimmte Bedingungen dazu führen, dass die Anfrage fehlschlägt. Weitere Informationen zu häufigen Fallstricken aufgrund von IAM-Richtlinienbedingungen finden Sie unter [Anfordern einer Regionsübergreifende Kopie für DB-Snapshots](USER_CopySnapshot.md#USER_CopySnapshot.AcrossRegions.Policy).
## Kopieren eines DB-Snapshots
Gehen Sie wie folgt vor, um einen DB-Snapshot zu kopieren. Für jedes AWS Konto können Sie bis zu 20 DB-Snapshots gleichzeitig von einem AWS-Region zum anderen kopieren. Wenn Sie einen DB-Snapshot in einen anderen kopieren AWS-Region, erstellen Sie einen manuellen DB-Snapshot, der in diesem AWS-Region gespeichert wird. Beim Kopieren eines DB-Snapshots aus der Quelle AWS-Region fallen Amazon RDS-Datenübertragungsgebühren an. Weitere Informationen zu den Kosten von Datenübertragungen finden Sie unter [Amazon RDS – Preise](https://aws.amazon.com/rds/pricing/).
Nachdem die DB-Snapshot-Kopie in der neuen Version erstellt wurde AWS-Region, verhält sich die DB-Snapshot-Kopie genauso wie alle anderen DB-Snapshots in dieser Version. AWS-Region
Sie können einen DB-Snapshot mit der AWS-Managementkonsole AWS CLI, oder der Amazon RDS-API kopieren.
------
#### [ Console ]
Das folgende Verfahren kopiert einen DB-Snapshot von RDS Custom für SQL Server mithilfe der AWS-Managementkonsole.
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 die Option **Snapshots**.
1. Wählen Sie den DB-Snapshot von RDS Custom für SQL Server aus, den Sie kopieren möchten.
1. Wählen Sie in der Dropdown-Liste **Aktionen** die Option **Snapshot kopieren** aus.
![\[Die Seite Snapshot kopieren in der Amazon-RDS-Konsole. Die Einstellungen werden auf der Seite geladen.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/XRSC-Snapshot-Copy.png)
1. Um den DB-Snapshot in einen anderen zu kopieren AWS-Region, setzen Sie **Destination Region** auf den erforderlichen Wert.
**Anmerkung**
Für das Ziel AWS-Region muss dieselbe Datenbank-Engine-Version verfügbar sein wie für die Quelle AWS-Region.
1. Geben Sie unter **Neue DB-Snapshot-Kennung** einen eindeutigen Namen für den DB-Snapshot ein. Sie können mehrere Kopien eines automatisierten Backups oder eines manuellen Snapshots erstellen, aber jede Kopie muss über eine eindeutige Kennung verfügen.
1. (Optional) Wählen Sie **Copy Tags (Tags kopieren)**, um Tags und Werte aus dem Snapshot in die Kopie des Snapshots zu übernehmen.
1. Geben Sie für die **Verschlüsselung** den KMS-Schlüsselbezeichner an, der zur Verschlüsselung der DB-Snapshot-Kopie verwendet werden soll.
**Anmerkung**
RDS Custom für SQL Server verschlüsselt alle DB-Snapshots. Sie können keinen unverschlüsselten DB-Snapshot erstellen.
1. Wählen Sie **Snapshot kopieren** aus.
RDS Custom für SQL Server erstellt eine DB-Snapshot-Kopie Ihrer DB-Instance in der von Ihnen ausgewählten AWS-Region .
------
#### [ AWS CLI ]
Sie können einen DB-Snapshot von RDS Custom for SQL Server mithilfe des AWS CLI Befehls kopieren [https://docs.aws.amazon.com/cli/latest/reference/rds/copy-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/copy-db-snapshot.html). Wenn Sie den Snapshot in einen neuen kopieren AWS-Region, führen Sie den Befehl im neuen aus AWS-Region. Zum Kopieren eines DB-Snapshots werden die folgenden Optionen verwendet. Nicht alle Optionen werden in allen Szenarien benötigt.
+ `--source-db-snapshot-identifier` – Der Bezeichner des Quell-DB-Snapshots.
+ Wenn sich der Quell-Snapshot in einer anderen Version AWS-Region als der Kopie befindet, geben Sie einen gültigen DB-Snapshot-ARN an. Beispiel, `arn:aws:rds:us-west-2:123456789012:snapshot:instance1-snapshot-12345678`.
+ `--target-db-snapshot-identifier` – Der Bezeichner für die neue Kopie des DB-Snapshots.
+ `--kms-key-id` – Der KMS-Schlüsselbezeichner für einen verschlüsselten DB-Snapshot. Der KMS-Schlüsselbezeichner ist der Amazon Resource Name (ARN), der Schlüsselbezeichner oder der Schlüsselalias für den KMS-Schlüssel.
+ Wenn Sie einen verschlüsselten Snapshot in eine andere AWS-Region kopieren, müssen Sie einen KMS-Schlüssel für die Ziel- AWS-Region angeben. KMS-Schlüssel sind spezifisch für AWS-Region das, in dem sie erstellt wurden, und Sie können nur AWS-Region dann Verschlüsselungsschlüssel verwenden, AWS-Region wenn ein Schlüssel für mehrere Regionen verwendet wird. Weitere Informationen über multiregionale Schlüssel finden Sie unter [Verwenden von multiregionalen Schlüsseln in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html).
+ `--copy-tags` – Geben Sie die Tags und Werte aus dem Quell-Snapshot in der Kopie des Snapshots an.
Die folgenden Optionen werden für das Kopieren eines DB-Snapshots von RDS Custom für SQL Server nicht unterstützt:
+ `--copy-option-group `
+ `--option-group-name`
+ `--pre-signed-url`
+ `--target-custom-availability-zone`
Im folgenden Codebeispiel wird ein verschlüsselter DB-Snapshot aus der Region USA West (Oregon) in die Region US East (N. Virginia) kopiert. Führen Sie den Befehl in der Zielregion (us-east-1) aus.
Für Linux, macOS oder Unix:
```
aws rds copy-db-snapshot \
--region us-east-1 \
--source-db-snapshot-identifier arn:aws:rds:us-west-2:123456789012:snapshot:instance1-snapshot-12345678 \
--target-db-snapshot-identifier mydbsnapshotcopy \
--kms-key-id a1b2c3d4-1234-5678-wxyz-a1b2c3d4d5e6
```
Für Windows:
```
aws rds copy-db-snapshot ^
--region us-east-1 ^
--source-db-snapshot-identifier arn:aws:rds:us-west-2:123456789012:snapshot:instance1-snapshot-12345678 ^
--target-db-snapshot-identifier mydbsnapshotcopy ^
--kms-key-id a1b2c3d4-1234-5678-wxyz-a1b2c3d4d5e6
```
------
#### [ RDS API ]
Sie können einen DB-Snapshot von RDS Custom for SQL Server mithilfe der Amazon RDS-API-Operation [Copy kopieren DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CopyDBSnapshot.html). Wenn Sie den Snapshot in eine neue AWS-Region kopieren, führen Sie die Aktion in der neuen AWS-Region aus. Zum Kopieren eines DB-Snapshots werden die folgenden Parameter verwendet. Nicht alle Parameter sind erforderlich:
+ `SourceDBSnapshotIdentifier` – Der Bezeichner des Quell-DB-Snapshots.
+ Wenn sich der Quell-Snapshot in einer anderen Version AWS-Region als der Kopie befindet, geben Sie einen gültigen DB-Snapshot-ARN an. Beispiel, `arn:aws:rds:us-west-2:123456789012:snapshot:instance1-snapshot-12345678`.
+ `TargetDBSnapshotIdentifier` – Der Bezeichner für die neue Kopie des DB-Snapshots.
+ `KmsKeyId` – Der KMS-Schlüsselbezeichner für einen verschlüsselten DB-Snapshot. Der KMS-Schlüsselbezeichner ist der Amazon Resource Name (ARN), der Schlüsselbezeichner oder der Schlüsselalias für den KMS-Schlüssel.
+ Wenn Sie einen verschlüsselten Snapshot in eine andere AWS-Region kopieren, müssen Sie einen KMS-Schlüssel für die Ziel- AWS-Region angeben. KMS-Schlüssel sind spezifisch für AWS-Region das, in dem sie erstellt wurden, und Sie können nur AWS-Region dann Verschlüsselungsschlüssel verwenden, AWS-Region wenn ein Schlüssel für mehrere Regionen verwendet wird. Weitere Informationen über multiregionale Schlüssel finden Sie unter [Verwenden von multiregionalen Schlüsseln in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html).
+ `CopyTags` – Setzen Sie diesen Parameter auf `true`, damit Tags und Werte aus dem Quell-Snapshot in die Kopie des Snapshots übernommen werden. Der Standardwert ist `false`.
Die folgenden Optionen werden für das Kopieren eines DB-Snapshots von RDS Custom für SQL Server nicht unterstützt:
+ `CopyOptionGroup`
+ `OptionGroupName`
+ `PreSignedUrl`
+ `TargetCustomAvailabilityZone`
Der folgende Code erstellt eine Kopie eines Snapshots mit dem neuen Namen `mydbsnapshotcopy` in der US East (N. Virginia)-Region.
```
https://rds.us-east-1.amazonaws.com/
?Action=CopyDBSnapshot
&KmsKeyId=a1b2c3d4-1234-5678-wxyz-a1b2c3d4d5e6
&SourceDBSnapshotIdentifier=arn%3Aaws%3Ards%3Aus-west-2%3A123456789012%3Asnapshot%3Ainstance1-snapshot-12345678
&TargetDBSnapshotIdentifier=mydbsnapshotcopy
&Version=2014-10-31
&X-Amz-Algorithm=AWS4-HMAC-SHA256
&X-Amz-Credential=AKIADQKE4SARGYLE/20161117/us-east-1/rds/aws4_request
&X-Amz-Date=20161117T221704Z
&X-Amz-SignedHeaders=content-type;host;user-agent;x-amz-content-sha256;x-amz-date
&X-Amz-Signature=da4f2da66739d2e722c85fcfd225dc27bba7e2b8dbea8d8612434378e52adccf
```
------
# Migration einer lokalen Datenbank zu Amazon RDS Custom for SQL Server
Sie können den folgenden Prozess verwenden, um eine lokale Microsoft SQL Server-Datenbank mithilfe einer nativen Sicherung und Backup auf Amazon RDS Custom for SQL Server zu migrieren:
1. Machen Sie eine vollständige Sicherung der Datenbank auf der lokalen DB-Instance.
1. Laden Sie die Sicherungsdatei in Amazon S3 hoch.
1. Laden Sie die Sicherungsdatei von S3 auf Ihre RDS Custom für SQL-DB-Instance herunter.
1. Stellen Sie eine Datenbank mit der heruntergeladenen Sicherungsdatei auf der RDS Custom for SQL Server DB-Instance wieder her.
Dieser Prozess erklärt die Migration einer Datenbank von lokal zu RDS Custom for SQL Server unter Verwendung einer nativen vollständigen Sicherung und Backup. Um die Schnittzeit während des Migrationsprozesses zu verkürzen, können Sie auch Differentialsicherungen oder Protokollsicherungen verwenden.
Allgemeine Informationen zur nativen Sicherung und Wiederherstellung für RDS for SQL Server finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
**Topics**
+ [Voraussetzungen](#custom-migrating.prereqs)
+ [Sichern der lokalen Datenbank](#custom-migrating.backup)
+ [Hochladen der Sicherungsdatei auf Amazon S3](#custom-migrating.upload)
+ [Herunterladen der Sicherungsdatei aus Amazon S3](#custom-migrating.upload)
+ [Wiederherstellen der Sicherungsdatei in der RDS Custom für SQL-DB-Instance](#custom-migrating.restore)
## Voraussetzungen
Führen Sie vor der Migration der Datenbank folgende Aufgaben aus:
1. Konfigurieren Sie Remotedesktopverbindung (RDP) für Ihre RDS Custom für SQL-DB-Instance. Weitere Informationen finden Sie unter [Verbinden mit Ihrer RDS Custom DB-Instance über RDP](custom-creating-sqlserver.rdp.md).
1. Konfigurieren Sie den Zugriff auf Amazon S3, damit Sie die Datenbanksicherungsdatei hochladen und herunterladen können.
## Sichern der lokalen Datenbank
Sie verwenden das native SQL Server-Backup, um eine vollständige Sicherung der Datenbank auf der lokalen DB-Instance durchzuführen.
Das folgende Beispiel zeigt eine Sicherung einer Datenbank namens`mydatabase` mit der `COMPRESSION`-Option angegeben, um die Größe der Sicherungsdatei zu reduzieren.
**So sichern Sie die lokale Datenbank**
1. Stellen Sie mithilfe von SQL Server Management Studio (SSMS) eine Verbindung mit der lokalen SQL Server-Instance her.
1. Führen Sie den folgenden Befehl aus, um ein zu markieren.
```
backup database mydatabase to
disk ='C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\Backup\mydb-full-compressed.bak'
with compression;
```
## Hochladen der Sicherungsdatei auf Amazon S3
Die benutzen AWS-Managementkonsole, um die Sicherungsdatei `mydb-full-compressed.bak` an Amazon S3 hochzuladen.
**Laden Sie die Sicherungsdatei nach S3 hoch**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Wählen Sie in der Liste **Buckets** den Namen des Buckets aus, in den Ihre Dateien hochgeladen werden sollen.
1. Klicken Sie auf **Upload**.
1. Führen Sie im Fenster **Upload** einen der folgenden Schritte aus:
+ Drag-and-drop `mydb-full-compressed.bak` zum **Hochladen**-Fenster.
+ Klicken Sie auf **Datei hinzufügen**, wählen Sie `mydb-full-compressed.bak` und klicken Sie auf **Öffnen**.
Amazon S3 lädt Ihre Sicherungsdatei als S3-Objekt hoch. Wenn der Upload abgeschlossen ist, wird auf der Seite **Upload: status** eine Erfolgsmeldung angezeigt.
## Herunterladen der Sicherungsdatei aus Amazon S3
Sie verwenden die Konsole, um die Sicherungsdatei von S3 auf die RDS Custom for SQL Server DB-Instanz herunterzuladen.
**Laden Sie die Sicherungsdatei aus S3 herunter**
1. Stellen Sie mithilfe von RDP eine Verbindung mit Ihrer RDS Custom für SQL-DB-Instance her.
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Wählen Sie in der Liste **Buckets** den Namen des Buckets aus, in den Ihre Dateien hochgeladen werden sollen.
1. Wählen Sie die Sicherungsdatei `mydb-full-compressed.bak` aus.
1. Wählen Sie für **Aktionen** die Option **Herunterladen** aus.
1. Öffnen Sie das Kontextmenü (rechte Maustaste) für den bereitgestellten Link und wählen Sie **Save Link As** (Link speichern unter) aus.
1. Speichern Sie die `mydb-full-compressed.bak`-Datei im Verzeichnis `D:\rdsdbdata\BACKUP`.
## Wiederherstellen der Sicherungsdatei in der RDS Custom für SQL-DB-Instance
Verwenden Sie die native SQL Server-Backup, um die Sicherungsdatei in Ihrer RDS Custom für SQL-DB-Instance wiederherzustellen.
In diesem Beispiel wird die Aktion `MOVE` angegeben, da sich die Daten- und Protokolldateiverzeichnisse von der lokalen DB-Instance unterscheiden.
**So stellen Sie die Sicherungsdatei wieder her**
1. Stellen Sie mithilfe von SSMS eine Verbindung mit Ihrer RDS Custom für SQL-DB-Instance her.
1. Führen Sie den folgenden Befehl aus, um ein zu markieren.
```
restore database mydatabase from disk='D:\rdsdbdata\BACKUP\mydb-full-compressed.bak'
with move 'mydatabase' to 'D:\rdsdbdata\DATA\mydatabase.mdf',
move 'mydatabase_log' to 'D:\rdsdbdata\DATA\mydatabase_log.ldf';
```
# RDS Custom für SQL Server-Betriebssystemupdates
RDS Custom for SQL Server bietet die folgenden Methoden, um Betriebssystemupdates auf Ihre RPEV-Instanzen (RDS Provided Engine Version) anzuwenden:
+ *Wartungsaktionen für Systemupdates*
+ *Upgrades kleinerer Datenbankversionen*
+ Zu den Aktualisierungen der DB-Minor-Engine-Versionen mit RPEV gehören aktuelle Betriebssystemupdates. Dieser Ansatz ist besonders nützlich, wenn Sie Betriebssystemupdates mit Upgrades für kleinere Versionen von SQL Server kombinieren möchten. Weitere Informationen finden Sie unter [Aktualisieren einer DB-Instance von Amazon RDS Custom für SQL Server](custom-upgrading-sqlserver.md).
## Szenarien für Betriebssystemupdates
Es gibt zwei Möglichkeiten, Betriebssystemupdates für Ihre RDS Custom for SQL Server-Instanzen zu verwalten:
+ Bei Single-AZ-Instances ist die Instanz während des Betriebssystem-Updates nicht verfügbar.
+ Bei Multi-AZ-Bereitstellungen wendet RDS Betriebssystemupdates auf folgende Weise an:
+ Zunächst führt RDS ein Betriebssystemupdate auf der Standby-Instance durch.
+ RDS führt einen Failover zur aktualisierten Standby-DB-Instance durch und macht sie damit zur neuen primären DB-Instance.
+ Schließlich führt RDS ein Betriebssystem-Update auf der neuen Standby-DB-Instance durch.
Die Ausfallzeit bei Multi-AZ-Bereitstellungen entspricht der Zeit, die für den Failover benötigt wird.
## Anwenden von Betriebssystemupdates mithilfe von Wartungsaktionen für Systemupdates
Um Betriebssystemupdates auf Ihre Amazon RDS RPEV-Instances anzuwenden, können Sie die AWS-Managementkonsole AWS CLI, oder RDS-API verwenden. Weitere Informationen finden Sie unter [Betriebssystemupdates für RDS-DB-Instances](USER_UpgradeDBInstance.Maintenance.md#OS_Updates).
**Example**
Für Linux, macOS oder Unix:
**Schritt 1: Suchen Sie nach verfügbaren Updates**
Verwenden Sie den `describe-pending-maintenance-actions` Befehl, um zu überprüfen, ob Betriebssystem-Updates für Ihre Instances verfügbar sind:
```
aws rds describe-pending-maintenance-actions
```
Beispielantwort:
```
{
"PendingMaintenanceActions": [
{
"ResourceIdentifier": "arn:aws:rds:us-east-1:111122223333:db:my-sqlserver-instance",
"PendingMaintenanceActionDetails": [
{
"Action": "system-update",
"Description": "New Operating System update is available"
}
]
}
]
}
```
Der Aktionstyp `system-update` gibt an, dass ein Betriebssystem-Update für Ihre Instanz verfügbar ist.
**Schritt 2: Wenden Sie das Betriebssystem-Update an**
Verwenden Sie den `apply-pending-maintenance-action` Befehl, um das Update zu planen:
```
aws rds apply-pending-maintenance-action \
--resource-identifier arn:aws:rds:us-east-1:111122223333:db:my-sqlserver-instance \
--apply-action system-update \
--opt-in-type immediate
```
Die `opt-in-type` Eingabe hat die folgenden Optionen:
+ `immediate`: Wenden Sie das Update sofort an
+ `next-maintenance`: Wenden Sie das Update während des nächsten geplanten Wartungsfensters an
+ `undo-opt-in`: Brechen Sie ein zuvor geplantes Update ab
Beispielantwort:
```
{
"ResourcePendingMaintenanceActions": {
"ResourceIdentifier": "arn:aws:rds:us-east-1:111122223333:db:my-sqlserver-instance",
"PendingMaintenanceActionDetails": [
{
"Action": "system-update",
"AutoAppliedAfterDate": "2024-04-10T20:41:01.695000+00:00",
"ForcedApplyDate": "2024-04-10T20:41:01.694000+00:00",
"CurrentApplyDate": "2024-04-10T20:41:01.695000+00:00",
"Description": "New Operating System update is available"
}
]
}
}
```
## Benachrichtigungen über Betriebssystem-Updates
Wenn Sie benachrichtigt werden möchten, sobald ein neuer optionaler System-Patch verfügbar ist, können Sie [RDS-EVENT-0230](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.Messages.html#RDS-EVENT-0230) in der Kategorie „Sicherheitspatch-Ereignis“ abonnieren. Informationen zum Abonnieren von RDS-Ereignissen finden Sie unter [Amazon RDS-Ereignisbenachrichtigung abonnieren](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.Subscribing.html).
## Überlegungen
Für Betriebssystem-Updates gelten die folgenden Überlegungen und Einschränkungen:
+ Alle Betriebssystemanpassungen, die am Laufwerk C:\$1 vorgenommen wurden, bleiben bei Betriebssystemupdates nicht erhalten.
+ Wir empfehlen, vor der Installation von Updates einen manuellen Snapshot zu erstellen.
# Aktualisieren einer DB-Instance von Amazon RDS Custom für SQL Server
Sie können eine DB-Instance von Amazon RDS Custom für SQL Server aktualisieren, indem Sie sie so ändern, dass sie eine neue DB-Engine-Version verwendet. Allgemeine Informationen zum Upgrade von DB-Instances finden Sie unter [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md).
**Topics**
+ [Übersicht über Upgrades in RDS Custom für SQL Server](#custom-upgrading-sqlserver.Overview)
+ [Engine-Hauptversion- und -Unterversion-Upgrades](#custom-upgrading-sqlserver.Upgrade)
+ [Datenbank-Kompatibilitätsstufe](#custom-upgrading-sqlserver.Major.Compatibility)
## Übersicht über Upgrades in RDS Custom für SQL Server
Amazon RDS Custom für SQL Server unterstützt Haupt- und Unterversion-Upgrades. Unterversion-Upgrades können Sicherheits-Patches, Bugfixes und Verbesserungen der Engine enthalten. Microsoft veröffentlicht diese Updates als kumulative Updates (CUs). Hauptversion-Upgrades führen neue Features und Engine-Änderungen zwischen den Versionen ein, z. B. ein Upgrade von SQL Server 2019 auf 2022. Sie können beide Upgrades sofort oder während der geplanten Wartungsfenster anwenden. Um mögliche Probleme mit der Abwärtskompatibilität zu vermeiden, empfehlen wir, Ihre Anwendungen vor dem Upgrade in einer Umgebung außerhalb der Produktionsumgebung zu testen.
RDS Custom für SQL Server ermöglicht Upgrades der von RDS bereitgestellten Engine-Version (RPEV) sowie der benutzerdefinierten Engine-Version (CEV).
+ Die von RDS bereitgestellten Engine-Versionen (RPEV) enthalten aktuelle Betriebssystem-Patches und kumulative Updates (CU) für SQL Server.
+ Für eine benutzerdefinierte Engine-Version (CEV) müssen Sie einen zweistufigen Prozess ausführen. Erstellen Sie zunächst eine neue CEV mit Ihrer SQL-Server-Zielversion, siehe [Vorbereitung der Erstellung einer CEV für RDS Custom für SQL Server](custom-cev-sqlserver.preparing.md). Diese Zielversion muss Ihrer aktuellen Version entsprechen oder neuer sein. Sobald die neue CEV erstellt wurde, ändern Sie Ihre Datenbank-Instance so, dass sie diese neue Version verwendet. Weitere Informationen finden Sie unter [Performing a minor version upgrade for Amazon RDS Custom für SQL Server CEV with Multi-AZ](https://aws.amazon.com/blogs/database/performing-a-minor-version-upgrade-for-amazon-rds-custom-for-sql-server-cev-with-multi-az/).
Wenden Sie keine kumulativen Updates für SQL Server direkt auf Ihre laufende RDS-Custom-Instance an. Sobald Sie eine CEV mit einer bestimmten SQL-Server-Version (z. B. SQL Server 2022 CU16) erstellt haben, wird die Instance durch direktes Anwenden eines neueren kumulativen Updates aus dem Support-Umfang entfernt und es wird der Fehler `SP-S3006` gemeldet. Um eine bestehende SQL-Server-Instance mithilfe einer CEV zu patchen, erstellen Sie eine neue CEV, die das gewünschte kumulative Update enthält, und ändern Sie dann Ihre bestehende Instance so, dass sie zur neuen CEV wechselt.
Wenn Sie ein Upgrade einer DB-Instance von RDS Custom für SQL Server in einer Multi-AZ-Bereitstellung durchführen, führt RDS Custom für SQL Server fortlaufende Upgrades für Ihre Instance aus. Bei diesem Ansatz werden Ausfallzeiten minimiert, indem jeweils eine Instance aktualisiert wird. RDS führt die folgenden Aktionen aus, um fortlaufende Upgrades durchzuführen:
1. Aktualisieren Sie die Standby-DB-Instance.
1. Führen Sie ein Failover zur aktualisierten Standby-DB-Instance durch, wodurch diese zur neuen primären DB-Instance wird.
1. Aktualisieren Sie die neue Standby-DB-Instance.
Die Ausfallzeit der DB-Instance bei Multi-AZ-Bereitstellungen entspricht der Zeit, die für den Failover benötigt wird.
Die folgenden Einschränkungen gelten für Upgrades einer DB-Instance von RDS Custom für SQL Server:
+ Benutzerdefinierte DB-Optionen und Parametergruppen werden nicht unterstützt.
+ Zusätzliche Speicher-Volumes, die Sie an Ihre DB-Instance von RDS Custom für SQL Server anfügen, sind nach dem Upgrade nicht angefügt.
+ Bei CEVs wird die direkte Anwendung von kumulativen Updates für SQL Server nicht unterstützt, was dazu führt, dass die Instance aus dem Support-Umfang entfernt wird.
## Engine-Hauptversion- und -Unterversion-Upgrades
Upgrades sowohl der Haupt- als auch der Unterversion der Engine sind irreversibel und müssen immer auf eine neuere Version angewendet werden. Um verfügbare Zielversionen zu identifizieren, verwenden Sie die AWS-Managementkonsole und wählen Sie aus den verfügbaren Versionen aus, wenn Sie Ihre DB-Instance ändern. Verwenden Sie alternativ den CLI-Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) oder den RDS-API-Befehl [DescribeDBEngineVersions](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBEngineVersions.html).
Für Linux, macOS oder Unix:
```
aws rds describe-db-engine-versions \
--engine custom-sqlserver-se \
--engine-version 15.00.4322.2.v1 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" \
--output table
```
Für Windows:
```
aws rds describe-db-engine-versions ^
--engine custom-sqlserver-se ^
--engine-version 15.00.4322.2.v1 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" ^
--output table
```
Die Ausgabe zeigt die verfügbaren Engine-Zielversionen:
```
--------------------------
|DescribeDBEngineVersions|
+------------------------+
| EngineVersion |
+------------------------+
| 15.00.4410.1.v1 |
| 15.00.4415.2.v1 |
| 15.00.4430.1.v1 |
| 16.00.4165.4.v1 |
| 16.00.4175.1.v1 |
| 16.00.4185.3.v1 |
+------------------------+
```
Nachdem Sie Ihre Zielversion identifiziert haben, verwenden Sie die AWS-Managementkonsole und befolgen Sie die Anleitungen unter [Ändern einer RDS Custom for SQL Server-DB-Instance](custom-managing.modify-sqlserver.md). Verwenden Sie alternativ den CLI-Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) oder den RDS-API-Befehl [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html).
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier DB_INSTANCE_IDENTIFIER \
--engine-version ENGINE_VERSION \
--allow-major-version-upgrade \
--region Region \
--no-apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier DB_INSTANCE_IDENTIFIER ^
--engine-version ENGINE_VERSION ^
--allow-major-version-upgrade ^
--region Region ^
--no-apply-immediately
```
**Anmerkung**
Sie müssen den Parameter `--allow-major-version-upgrade` angeben, um Hauptversion-Upgrades durchzuführen.
## Datenbank-Kompatibilitätsstufe
Sie können Microsoft SQL Server-Kompatibilitätsgrade verwenden, um einige Verhaltensweisen von Datenbanken zu justieren und somit vorherige Versionen von SQL Server zu simulieren. Weitere Informationen finden Sie unter [Compatibility Level](https://msdn.microsoft.com/en-us/library/bb510680.aspx) in der Microsoft-Dokumentation.
Wenn Sie Ihre DB-Instance upgraden, behalten alle bestehenden Datenbanken ihren ursprünglichen Kompatibilitätsgrad. Wenn Sie beispielsweise von SQL Server 2019 auf SQL Server 2022 upgraden, behalten alle bestehenden Datenbanken den Kompatibilitätsgrad von 150. Jede Datenbank, die nach dem Upgrade erstellt wird, verfügt über den Kompatibilitätsgrad 160.
Sie können den Kompatibilitätsgrad einer Datenbank ändern, indem Sie den Befehl ALTER DATABASE verwenden. Wenn Sie beispielsweise eine Datenbank mit dem Namen `customeracct` ändern möchten, damit diese mit SQL Server 2022 kompatibel ist, führen Sie folgenden Befehl aus:
```
1. ALTER DATABASE customeracct SET COMPATIBILITY_LEVEL = 160
```
# Beheben von DB-Problemen für Amazon RDS Custom für SDL Server
Das Modell der gemeinsamen Verantwortung von RDS Custom bietet Zugriff auf Betriebssystem-Shell-Ebene und Zugriff auf Datenbankadministratoren. RDS Custom führt Ressourcen in Ihrem Konto aus, im Gegensatz zu Amazon RDS, das Ressourcen in einem Systemkonto ausführt. Mit einem größeren Zugang kommt eine größere Verantwortung mit sich. In den folgenden Abschnitten erfahren Sie, wie Sie Probleme mit Amazon RDS Custom für SQL Server-DB-Instances beheben können.
**Anmerkung**
In diesem Abschnitt wird die Problembehandlung mit RDS Custom für SQL Server behandelt. Zur Fehlerbehebung bei RDS Custom für Oracle vgl. [Beheben von DB-Problemen für Amazon RDS Custom für Oracle](custom-troubleshooting.md).
**Topics**
+ [Anzeigen von benutzerdefinierten RDS-Ereignissen](#custom-troubleshooting-sqlserver.support-perimeter.viewing-events)
+ [Abonnieren von RDS-Custom-Ereignissen](#custom-troubleshooting-sqlserver.support-perimeter.subscribing)
+ [Beheben von CEV-Fehlern für RDS Custom für SQL Server](#custom-troubleshooting-sqlserver.cev)
+ [Korrigieren von nicht unterstützten Konfigurationen in RDS Custom für SQL Server](#custom-troubleshooting-sqlserver.fix-unsupported)
+ [Problembehebung für `Storage-Full` in RDS Custom für SQL Server](#custom-troubleshooting-storage-full)
+ [Problembehebung beim Status PENDING\$1RECOVERY für TDE-fähige Datenbanken in RDS Custom für SQL Server](#custom-troubleshooting-sqlserver.pending_recovery)
## Anzeigen von benutzerdefinierten RDS-Ereignissen
Das Verfahren zum Anzeigen von Ereignissen ist für RDS Custom- und Amazon RDS DB-Instances gleich. Weitere Informationen finden Sie unter [Anzeigen von Amazon-RDS-Ereignissen](USER_ListEvents.md).
Verwenden Sie den `describe-events` Befehl AWS CLI, um die benutzerdefinierte RDS-Ereignisbenachrichtigung mit dem anzuzeigen. RDS Custom führt mehrere neue Ereignisse ein. Die Ereigniskategorien sind die gleichen wie für Amazon RDS. Eine Liste der Ereignisse finden Sie unter [Amazon RDS-Ereigniskategorien und Ereignisnachrichten ](USER_Events.Messages.md).
Im folgenden Beispiel werden Details zu den Ereignissen abgerufen, die für die angegebene RDS Custom DB-Instance aufgetreten sind.
```
1. aws rds describe-events \
2. --source-identifier my-custom-instance \
3. --source-type db-instance
```
## Abonnieren von RDS-Custom-Ereignissen
Das Verfahren zum Abonnieren von Ereignissen ist für RDS Custom- und Amazon RDS DB-Instances gleich. Weitere Informationen finden Sie unter [Abonnieren von Amazon-RDS-Ereignisbenachrichtigungen](USER_Events.Subscribing.md).
Verwenden Sie den Befehl `create-event-subscription`, um Ereignisbenachrichtigungen von RDS Custom zu abonnieren. Nutzen Sie die folgenden erforderlichen Parameter:
+ `--subscription-name`
+ `--sns-topic-arn`
Im folgenden Beispiel wird ein Abonnement für Backup- und Wiederherstellungsereignisse für eine RDS Custom DB-Instance im aktuellen AWS -Konto. Sie können auch anfordern, dass Benachrichtigungen an ein bestimmtes Amazon-SNS-Thema (Amazon Simple Notification Service) gesendet werden, die `--sns-topic-arn` bestimmt.
```
1. aws rds create-event-subscription \
2. --subscription-name my-instance-events \
3. --source-type db-instance \
4. --event-categories '["backup","recovery"]' \
5. --sns-topic-arn arn:aws:sns:us-east-1:123456789012:interesting-events
```
## Beheben von CEV-Fehlern für RDS Custom für SQL Server
Wenn Sie versuchen, eine CEV zu erstellen, kann dieser Vorgang fehlschlagen. In diesem Fall gibt RDS Custom die Ereignismeldung `RDS-EVENT-0198` aus. Weitere Informationen zum Anzeigen von RDS-Ereignissen finden Sie unter [Amazon RDS-Ereigniskategorien und Ereignisnachrichten ](USER_Events.Messages.md).
Verwenden Sie die folgenden Informationen, um mögliche Ursachen zu beheben.
****
| Fehlermeldung | Vorschläge für die Fehlerbehebung |
| --- | --- |
| `Custom Engine Version creation expected a Sysprep’d AMI. Retry creation using a Sysprep’d AMI.` | Führen Sie Sysprep auf der EC2-Instance aus, die Sie aus dem AMI erstellt haben. Weitere Informationen zur Vorbereitung eines AMI mit Sysprep finden Sie unter [Erstellen eines standardisierten Amazon Machine Image (AMI) mit Sysprep](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/Creating_EBSbacked_WinAMI.html#sysprep-using-ec2launchv2). |
| `EC2 Image permissions for image (AMI_ID) weren't found for customer (Customer_ID). Verify customer (Customer_ID) has valid permissions on the EC2 Image.` | Stellen Sie sicher, dass Ihr Konto und Ihr Profil, die für die Erstellung verwendet wurden, über die erforderlichen Berechtigungen für `create EC2 Instance` und für `Describe Images` für das ausgewählte AMI verfügen. |
| `Failed to rebuild databases with server collation (collation name) due to missing setup.exe file for SQL Server.` | Stellen Sie sicher, dass die `setup`-Datei unter `C:\Program Files\Microsoft SQL Server\nnn\Setup Bootstrap\SQLnnnn\setup.exe` verfügbar ist. |
| `Image (AMI_ID) doesn't exist in your account (ACCOUNT_ID). Verify (ACCOUNT_ID) is the owner of the EC2 image.` | Stellen Sie sicher, dass das AMI im selben Kundenkonto vorhanden ist. |
| `Image id (AMI_ID) isn't valid. Specify a valid image id, and try again.` | Der Name des AMI ist falsch. Stellen Sie sicher, dass die richtige AMI-ID angegeben ist. |
| `Image (AMI_ID) operating system platform isn't supported. Specify a valid image, and try again.` | Wählen Sie ein unterstütztes AMI, das Windows Server mit SQL Server Enterprise, Standard oder Web Edition enthält. Wählen Sie ein AMI mit einem der folgenden Nutzungsoperationscodes aus dem EC2 Marketplace: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/custom-troubleshooting-sqlserver.html) |
| `SQL Server Web Edition isn't supported for creating a Custom Engine Version using Bring Your Own Media. Specify a valid image, and try again.` | Verwenden Sie ein AMI, das eine unterstützte Edition von SQL Server enthält. Weitere Informationen finden Sie unter [Versionsunterstützung für RDS Custom für SQL Server CEVs](custom-cev-sqlserver.preparing.md#custom-cev-sqlserver.preparing.VersionSupport). |
| `The custom engine version can't be the same as the OEV engine version. Specify a valid CEV, and try again.` | Classic Engine-Versionen von RDS Custom für SQL Server werden nicht unterstützt. Zum Beispiel Version **15.00.4073.23.v1**. Verwenden Sie eine unterstützte Versionsnummer. |
| `The custom engine version isn't in an active state. Specify a valid CEV, and try again.` | Die CEV muss sich im Status `AVAILABLE` befinden, damit der Vorgang abgeschlossen werden kann. Ändern Sie die CEV von `INACTIVE` in `AVAILABLE`. |
| `The custom engine version isn't valid for an upgrade. Specify a valid CEV with an engine version greater or equal to (X), and try again.` | Die Ziel-CEV ist nicht gültig. Überprüfen Sie die Anforderungen für einen gültigen Upgrade-Pfad. |
| `The custom engine version isn't valid. Names can include only lowercase letters (a-z), dashes (-), underscores (_), and periods (.). Specify a valid CEV, and try again.` | Halten Sie sich an die erforderliche CEV-Benennungskonvention. Weitere Informationen finden Sie unter [Anforderungen für RDS Custom für SQL Server CEVs](custom-cev-sqlserver.preparing.md#custom-cev-sqlserver.preparing.Requirements). |
| `The custom engine version isn't valid. Specify valid database engine version, and try again. Example: 15.00.4073.23-cev123.` | Eine nicht unterstützte DB-Engine-Version wurde bereitgestellt. Verwenden Sie eine unterstützte DB-Engine-Version. |
| `The expected architecture is (X) for image (AMI_ID), but architecture (Y) was found.` | Verwenden Sie ein AMI, das auf der **x86\$164**-Architektur basiert. |
| `The expected owner of image (AMI_ID) is customer account ID (ACCOUNT_ID), but owner (ACCOUNT_ID) was found.` | Erstellen Sie die EC2-Instance aus dem AMI, für das Sie die Berechtigung haben. Führen Sie Sysprep auf der EC2-Instance aus, um ein Basis-Image zu erstellen und zu speichern. |
| `The expected platform is (X) for image (AMI_ID), but platform (Y) was found.` | Verwenden Sie ein AMI, das auf der Windows-Plattform basiert. |
| `The expected root device type is (X) for image %s, but root device type (Y) was found.` | Erstellen Sie das AMI mit dem EBS-Gerätetyp. |
| `The expected SQL Server edition is (X), but (Y) was found.` | Wählen Sie ein unterstütztes AMI, das Windows Server mit SQL Server Enterprise, Standard oder Web Edition enthält. Wählen Sie ein AMI mit einem der folgenden Nutzungsoperationscodes aus dem EC2 Marketplace: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/custom-troubleshooting-sqlserver.html) |
| `The expected state is (X) for image (AMI_ID), but the following state was found: (Y).` | Stellen Sie sicher, dass sich das AMI im Status `AVAILABLE` befindet. |
| `The provided Windows OS name (X) isn’t valid. Make sure the OS is one of the following: (Y).` | Verwenden Sie ein unterstütztes Windows-Betriebssystem. |
| `Unable to find bootstrap log file in path.` | Stellen Sie sicher, dass die Protokolldatei unter `C:\Program Files\Microsoft SQL Server\nnn\Setup Bootstrap\Log\Summary.txt` verfügbar ist. |
| `RDS expected a Windows build version greater than or equal to (X), but found version (Y).`. | Verwenden Sie ein AMI mit einer Betriebssystem-Build-Version von mindestens **14393**. |
| `RDS expected a Windows major version greater than or equal to (X), but found version (Y).`. | Verwenden Sie ein AMI mit einer Betriebssystem-Hauptversion von mindestens **10.0** oder höher. |
## Korrigieren von nicht unterstützten Konfigurationen in RDS Custom für SQL Server
Aufgrund des Modells der geteilten Verantwortung liegt es in Ihrer Verantwortung, Konfigurationsprobleme zu beheben, die Ihre RDS Custom für SQL Server-DB-Instance in den Zustand `unsupported-configuration` versetzen. Wenn das Problem in der AWS Infrastruktur liegt, können Sie es mit der Konsole oder AWS CLI dem beheben. Wenn das Problem mit dem Betriebssystem oder der Datenbankkonfiguration besteht, können Sie sich beim Host anmelden, um es zu beheben.
**Anmerkung**
In diesem Abschnitt wird erläutert, wie Sie nicht unterstützte Konfigurationen in RDS Custom für SQL Server beheben. Weitere Informationen zum Konfigurieren von RDS Custom für Oracle finden Sie unter [Fehlerbehebung bei nicht unterstützten Konfigurationen in RDS Custom für Oracle](custom-troubleshooting.md#custom-troubleshooting.fix-unsupported).
In den folgenden Tabellen finden Sie Beschreibungen der Benachrichtigungen und Ereignisse, die der Support-Perimeter sendet, und Informationen dazu, wie Sie die Probleme beheben können. Diese Benachrichtigungen und der Support-Umfang können sich ändern. Hintergrundinformationen zum Support-Perimeter finden Sie unter [Support-Perimeter in RDS Custom](custom-concept.md#custom-troubleshooting.support-perimeter). Beschreibungen der Ereignisse finden Sie unter [Amazon RDS-Ereigniskategorien und Ereignisnachrichten ](USER_Events.Messages.md).
| Ereigniscode | Bereich „Konfiguration“ | RDS Event-Meldung | Validierungsprozess |
| --- | --- | --- | --- |
| `SP-S0000` | Manuelle nicht unterstützte Konfiguration | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: `X`. | Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. |
**AWS Ressource (Infrastruktur)**
| Ereigniscode | Bereich „Konfiguration“ | RDS Event-Meldung | Validierungsprozess |
| --- | --- | --- | --- |
| `SP-S1001` | Status der EC2-Instance | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die zugrunde liegende EC2-Instance %s wurde angehalten, ohne die RDS-Instance anzuhalten. Sie können dieses Problem lösen, indem Sie die zugrunde liegende EC2-Instance starten und sicherstellen, dass die Binär- und Datenvolumes angehängt sind. Wenn Sie die RDS-Instance anhalten möchten, stellen Sie zunächst sicher, dass sich die zugrunde liegende EC2-Instance im Status VERFÜGBAR befindet, und halten Sie dann die RDS-Instance mithilfe der RDS-Konsole oder CLI an. | Um den Status einer DB-Instance zu überprüfen, verwenden Sie die Konsole oder führen Sie den folgenden AWS CLI -Befehl aus: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep DBInstanceStatus
|
| `SP-S1002` | Status der EC2-Instance | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Der Status der RDS-DB-Instance ist auf `STOPPED` festgelegt, aber die zugrunde liegende EC2-Instance %s wurde gestartet. Sie lösen dieses Problem, indem Sie die zugrunde liegende EC2-Instance anhalten. Wenn Sie die RDS-Instance starten möchten, verwenden Sie die Konsole oder CLI. | Verwenden Sie den folgenden AWS CLI Befehl, um den Status einer DB-Instance zu überprüfen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep DBInstanceStatus
Sie können den Status der EC2-Instance auch mithilfe der EC2-Konsole überprüfen. Um eine DB-Instance zu starten, verwenden Sie die Konsole oder führen Sie den folgenden AWS CLI -Befehl aus: aws rds start-db-instance \
--db-instance-identifier db-instance-name
|
| `SP-S1003` | EC2-Instance-Klasse | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Es besteht eine Diskrepanz zwischen der erwarteten und der konfigurierten DB-Instance-Klasse des EC2-Hosts. Sie lösen dieses Problem, indem Sie die DB-Instance-Klasse in ihren ursprünglichen Klassentyp ändern. | Verwenden Sie den folgenden CLI-Befehl, um die erwartete DB-Instance-Klasse zu überprüfen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep DBInstanceClass
|
| `SP-S1004` | Zugriff auf EBS-Speichervolume nicht möglich | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Der Zugriff auf das ursprüngliche EBS-Speichervolume %s, das der EC2-Instance zugeordnet war, ist derzeit nicht möglich. | |
| `SP-S1005` | EBS-Speichervolume getrennt | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt Das ursprüngliche EBS-Speichervolume „volume-id“ ist nicht angefügt. Sie können dieses Problem lösen, indem Sie das der EC2-Instance zugeordnete EBS-Volume anhängen. | Verwenden Sie nach dem erneuten Anhängen des EBS-Volumes die folgenden CLI-Befehle, um zu überprüfen, ob das EBS-Volume „volume-id“ richtig an die RDS-Instance angehängt ist: aws ec2 describe-volumes \
--volume-ids volume-id |grep InstanceId
|
| `SP-S1006` | Größe des EBS-Speichervolumes | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Es besteht eine Diskrepanz zwischen den erwarteten und den konfigurierten Einstellungen des EBS-Speichervolumes „volume-id“. Die Größe des Volumes wurde auf EC2-Ebene manuell geändert. Der ursprüngliche Wert lautete [%s]. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | Verwenden Sie den folgenden CLI-Befehl, um die Details zur Größe des EBS-Volumes „volume-id“ mit den Details der RDS-Instance zu vergleichen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep AllocatedStorage
Verwenden Sie den folgenden CLI-Befehl, um die tatsächliche Größe des zugewiesenen Volumes anzuzeigen: aws ec2 describe-volumes \
--volume-ids |grep Size
|
| `SP-S1007` | Konfiguration des EBS-Speichervolumes | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Es besteht eine Diskrepanz zwischen den erwarteten und den konfigurierten Einstellungen des EBS-Speichervolumes „volume-id“. Sie können dieses Problem beheben, indem Sie die Konfiguration des EBS-Speichervolumes [IOPS, Durchsatz, Volume-Typ] auf EC2-Ebene in ihre ursprünglichen Werte [IOPS: %s, Durchsatz: %s, Volume-Typ: %s] ändern. Verwenden Sie für künftige Speicheränderungen die RDS-Konsole oder CLI. Die Größe des Volumes wurde auch auf EC2-Ebene manuell geändert. Der ursprüngliche Wert lautete [%s]. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | Verwenden Sie den folgenden CLI-Befehl, um die Details zum Volume-Typ des EBS-Volumes „volume-id“ mit den Details der RDS-Instance zu vergleichen. Stellen Sie sicher, dass die Werte auf EBS-Ebene mit den Werten auf RDS-Ebene übereinstimmen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep StorageType
So ermitteln Sie den erwarteten Wert für den Speicherdurchsatz auf RDS-Ebene: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep StorageThroughput
So ermitteln Sie den erwarteten Wert für Volume-IOPS auf RDS-Ebene: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep Iops
So ermitteln Sie den aktuellen Speichertyp auf EC2-Ebene: aws ec2 describe-volumes \
--volume-ids |grep VolumeType
So ermitteln Sie den aktuellen Wert für den Speicherdurchsatz auf EC2-Ebene: aws ec2 describe-volumes \
--volume-ids |grep Throughput
So ermitteln Sie den aktuellen Wert für Volume-IOPS auf EC2-Ebene: aws ec2 describe-volumes \
--volume-ids |grep Iops
|
| `SP-S1008` | Größe und Konfiguration des EBS-Speichervolumes | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Es besteht eine Diskrepanz zwischen den erwarteten und den konfigurierten Einstellungen des EBS-Speichervolumes „volume-id“. Sie können dieses Problem beheben, indem Sie die Konfiguration des EBS-Speichervolumes [IOPS, Durchsatz, Volume-Typ] auf EC2-Ebene in ihre ursprünglichen Werte [IOPS: %s, Durchsatz: %s, Volume-Typ: %s] ändern. Verwenden Sie für künftige Speicheränderungen die RDS-Konsole oder CLI. Die Größe des Volumes wurde auch auf EC2-Ebene manuell geändert. Der ursprüngliche Wert lautete [%s]. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | Verwenden Sie den folgenden CLI-Befehl, um die Details zum Volume-Typ des EBS-Volumes „volume-id“ mit den Details der RDS-Instance zu vergleichen. Stellen Sie sicher, dass die Werte auf EBS-Ebene mit den Werten auf RDS-Ebene übereinstimmen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep StorageType
So ermitteln Sie den erwarteten Wert für den Speicherdurchsatz auf RDS-Ebene: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep StorageThroughput
So ermitteln Sie den erwarteten Wert für Volume-IOPS auf RDS-Ebene: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep Iops
So ermitteln Sie den aktuellen Speichertyp auf EC2-Ebene: aws ec2 describe-volumes \
--volume-ids |grep VolumeType
So ermitteln Sie den aktuellen Wert für den Speicherdurchsatz auf EC2-Ebene: aws ec2 describe-volumes \
--volume-ids |grep Throughput
So ermitteln Sie den aktuellen Wert für Volume-IOPS auf EC2-Ebene: aws ec2 describe-volumes \
--volume-ids |grep Iops
So ermitteln Sie die erwartete Größe des zugewiesenen Volumes: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep AllocatedStorage
So ermitteln Sie die tatsächliche Größe des zugewiesenen Volumes: aws ec2 describe-volumes \
--volume-ids |grep Size
|
| `SP-S1009` | SQS-Berechtigungen | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Amazon Simple Queue Service (SQS)-Berechtigungen für das IAM-Instance-Profil fehlen. Sie können dieses Problem lösen, indem Sie sicherstellen, dass das dem Host zugeordnete IAM-Profil über die folgenden Berechtigungen verfügt: ["SQS: „, "SQS: SendMessage „, "SQS: ReceiveMessage „, "SQS: DeleteMessage „]. GetQueueUrl | |
| `SP-S1010` | SQS-VPC-Endpunkt | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Eine VPC-Endpunktrichtlinie blockiert die Amazon Simple Queue Service (SQS)-Operationen. Sie können dieses Problem beheben, indem Sie Ihre VPC-Endpunktrichtlinie so ändern, dass sie die erforderlichen SQS-Aktionen zulässt. | |
| `SP-S1011` | Event-Bus-Richtlinie | Der Status der benutzerdefinierten RDS-DB-Instance ist auf [Nicht unterstützte Konfiguration] gesetzt, und zwar aus folgenden Gründen: Die ressourcenbasierte Richtlinie für Ihren Event-Bus arn:aws:events:region- 1:123456789012:event-bus/default verweigert Amazon events: actions. CloudWatch PutEvents Beheben Sie dieses Problem, indem PutEvents Sie Ihre ressourcenbasierte Richtlinie so ändern, dass Ereignisse zulässig sind: Aktionen für %s. EventBus | |
| `SP-S1012` | CloudWatch VPC-Berechtigungen | Der Status der benutzerdefinierten RDS-DB-Instance ist auf [Nicht unterstützte Konfiguration] gesetzt, weil: Einer VPC-Endpunktrichtlinie fehlen Berechtigungen für den Zugriff auf CloudWatch Amazon-Ereignisse. Beheben Sie dieses Problem, indem Sie Ihre VPC-Endpunktrichtlinie so ändern, dass Ereignisse zulässig sind: PutEvents on EventBus arn:aws:events:region- 1:123456789012:event-bus/default. | |
| `SP-S1013` | Service-Kontrollrichtlinie | Der Status der RDS Custom DB-Instance ist auf [Nicht unterstützte Konfiguration] gesetzt, und zwar aus folgenden Gründen: In Ihrer AWS Organizations Servicekontrollrichtlinie fehlen die Zugriffsberechtigungen für CloudWatch Amazon-Ereignisse. Beheben Sie dieses Problem, indem Sie Ihre Servicesteuerungsrichtlinie so ändern, dass Ereignisse zulässig sind: PutEvents on EventBus arn:aws:events:region- 1:123456789012:event-bus/default. | |
| `SP-S1014` | IAM-Instanzprofil | Der Status der benutzerdefinierten RDS-DB-Instance ist auf [Nicht unterstützte Konfiguration] gesetzt, und zwar aus folgenden Gründen: Die %s-Berechtigungen Ihres IAM-Instance-Profils verweigern CloudWatch Amazon-Ereignisse. Beheben Sie dieses Problem, indem Sie ["events: PutEvents „] auf 'Zulassen' setzen und Ereignisse zulassen: PutEvents on EventBus arn:aws:events:region- 1:123456789012:event-bus/default in Ihrem mit der Instance verknüpften IAM-Profil. | |
| `SP-S1015` | IAM-Instanzprofil | Der Status der benutzerdefinierten RDS-DB-Instance ist auf [Nicht unterstützte Konfiguration] gesetzt, und zwar aus folgenden Gründen: In Ihrem IAM-Instance-Profil %s fehlen CloudWatch Amazon-Eventberechtigungen. Beheben Sie dieses Problem, indem Sie die Berechtigungen ["events: PutEvents „] und das Zulassen von Events: PutEvents on EventBus arn:aws:events:region- 1:123456789012:event-bus/default in Ihr mit der Instance verknüpftes IAM-Profil aufnehmen. | |
| `SP-S1016` | IAM-Berechtigungsgrenze | Der Status der benutzerdefinierten RDS-DB-Instance ist auf [Nicht unterstützte Konfiguration] gesetzt, und zwar aus folgenden Gründen: Ihr IAM-Instance-Profil %s hat eine Berechtigungsgrenze, die CloudWatch Amazon-Ereignisse ablehnt. Beheben Sie dieses Problem, indem Sie ["events: PutEvents „] für EventBus arn:aws:events:region- 1:123456789012:event-bus/default in der Berechtigungsgrenze Ihres IAM-Instance-Profils auf „Zulassen“ setzen. | |
**Betriebssystem**
| Ereigniscode | Bereich „Konfiguration“ | RDS Event-Meldung | Validierungsprozess |
| --- | --- | --- | --- |
| `SP-S2001` | SQL-Servicestatus | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Der SQL-Server-Service wurde nicht gestartet. Sie können dieses Problem beheben, indem Sie den SQL-Server-Service auf dem Host neu starten. Wenn es sich bei dieser DB-Instance um eine Multi-AZ-Instance handelt und ein Neustart fehlschlägt, halten Sie den Host an und starten ihn erneut, um ein Failover einzuleiten. | |
| `SP-S2002` | Status des RDS-Custom-Agenten | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Der Agent-Service für RDS Custom ist nicht installiert oder konnte nicht gestartet werden. Sie können dieses Problem beheben, indem Sie das Windows-Ereignisprotokoll überprüfen, um festzustellen, warum der Service nicht gestartet werden kann, und die entsprechenden Korrekturmaßnahmen ergreifen. Wenn Sie weitere Unterstützung benötigen, erstellen Sie einen Support-Fall. | Melden Sie sich beim Host an und stellen Sie sicher, dass der RDS Custom Agent ausgeführt wird. Sie können die folgenden Befehle verwenden, um den Agenten-Status anzuzeigen. $name = "RDSCustomAgent"
$service = Get-Service $name
Write-Host $service.Status
Wenn der Status nicht `Running` ist, können Sie den Service mit dem folgenden Befehl starten: Start-Service $name
Wenn der Agent nicht gestartet werden kann, sehen Sie in den Windows-Ereignissen nach, warum das so ist. Der Agent verlangt, dass ein Windows-Benutzer den Service startet. Stellen Sie sicher, dass ein Windows-Benutzer vorhanden ist und über die Berechtigungen zum Ausführen des Service verfügt. |
| `SP-S2003` | SSM-Agenten-Status | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Der Agenten-Service für Amazon SSM ist nicht erreichbar. Sie können dieses Problem beheben, indem Sie den Dienststatus mit dem Befehl überprüfen oder den Dienst mit starten. `Get-Service AmazonSSMAgent` PowerShell `Start-Service AmazonSSMAgent` Stellen Sie sicher, dass ausgehender HTTPS-Verkehr (Port 443) zu den regionalen Endpunkten **ssm**, **ssmmessages** und **ec2messages** zugelassen wird. | Weitere Informationen finden Sie unter [Fehlerbehebung bei SSM-Agent](https://docs.aws.amazon.com/systems-manager/latest/userguide/troubleshooting-ssm-agent.html). Informationen zur Fehlerbehebung bei SSM-Endpunkten finden Sie unter [Keine Verbindung mit SSM-Endpunkten möglich](https://docs.aws.amazon.com/systems-manager/latest/userguide/troubleshooting-ssm-agent.html#systems-manager-ssm-agent-troubleshooting-endpoint-access) und [Problembehebung bei der Verfügbarkeit verwalteter Knoten mithilfe von ssm-cli](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-cli.html#agent-ts-ssm-cli). |
| `SP-S2004` | Anmeldung des RDS-Custom-Agenten | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Bei der SQL-Anmeldung `"$HOSTNAME/RDSAgent”` ist ein unerwartetes Problem aufgetreten. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | |
| `SP-S2005` | Zeitzone | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die Zeitzone auf der Amazon-EC2-Instance [%s] wurde geändert. Sie können dieses Problem beheben, indem Sie die Zeitzone wieder in die Einstellung ändern, die bei der Instance-Erstellung angegeben wurde. Wenn Sie eine Instance mit einer bestimmten Zeitzone erstellen möchten, finden Sie weitere Informationen in der Dokumentation zu RDS Custom. | Führen Sie den `Get-Timezone` PowerShell Befehl aus, um die Zeitzone zu bestätigen. Weitere Informationen finden Sie unter [Lokale Zeitzone für DB-Instances von RDS Custom für SQL Server](custom-reqs-limits-MS.TimeZone.md). |
| `SP-S2006` | Version der Hochverfügbarkeits-Softwarelösung | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die Hochverfügbarkeits-Softwarelösung der aktuellen Instance unterscheidet sich von der erwarteten Version. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | |
| `SP-S2007` | Konfiguration der Hochverfügbarkeits-Softwarelösung | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die Konfigurationseinstellungen der Hochverfügbarkeits-Softwarelösung auf der Instance %s wurden in unerwartete Werte geändert. Um dieses Problem zu beheben, starten Sie die EC2-Instance neu. Wenn Sie die EC2-Instance neu starten, werden die Einstellungen automatisch auf die erforderliche Konfiguration für die Hochverfügbarkeits-Softwarelösung aktualisiert. | |
| SP-S2008 | SQL-Server-Service | Die benutzerdefinierte RDS-DB-Instance ist auf [Nicht unterstützte Konfiguration] gesetzt: Der Dienst SQLServer (MSSQLServer) ist auf dem Host nicht vorhanden. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | Sie können die folgenden Befehle verwenden, um den Agenten-Status anzuzeigen. $name = "MSSQLServer"
$service = Get-Service $name
Write-Host $service.Status
|
| SP-S2009 | SSL-Zertifikat | Die DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Nicht selbstsignierte SSL-Zertifikate führen zu Störungen in RDS. Um dieses Problem zu beheben, entfernen Sie die nicht selbstsignierten Zertifikate aus dem vertrauenswürdigen Stammzertifikatspeicher. | Führen Sie den folgenden PowerShell Befehl aus, um nicht selbstsignierte Zertifikate zu überprüfen. Get-ChildItem cert:\LocalMachine\root -Recurse | Where-Object {$_.Issuer -ne $_.Subject -and $_.Issuer -notlike "*RDSCustomAgentCA*"} Weitere Informationen finden Sie unter [HTTP-Fehler 403.16 beim Versuch, auf eine Website zuzugreifen, die auf IIS gehostet wird](https://learn.microsoft.com/en-us/troubleshoot/developer/webapps/iis/site-behavior-performance/http-403-forbidden-access-website). |
| SP-S2010 | Status des Root-Volume-Speicher | Die DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Der Speicher auf dem Stamm-Volume ist voll. Um dieses Problem zu beheben, geben Sie mindestens 500 MiB Speicherplatz auf dem EBS-Stammvolume „volume-id“ frei oder erhöhen Sie die Volume-Größe und ändern Sie die Größe des Laufwerks C auf der EC2-Instance „instance-id“. Die Änderungen an der Größe des Stamme-Volumes bleiben nicht bestehen, wenn Sie die EC2-Instance ersetzen. | Verwenden Sie den folgenden Befehl, um den verfügbaren Speicherplatz auf dem Stamm-Volume (C:) anzuzeigen. (Get-PSDrive -Name C).Free / 1MB
Weitere Informationen zum Ändern des EBS-Stamm-Volumes finden Sie unter [Wie](https://forums.aws.amazon.com/knowledge-center/expand-ebs-root-volume-windows). |
**Datenbank**
| Ereigniscode | Bereich „Konfiguration“ | RDS Event-Meldung | Validierungsprozess |
| --- | --- | --- | --- |
| `SP-S3001` | Shared-Memory-Protokoll für SQL Server | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Das Shared-Memory-Protokoll für SQL Server ist deaktiviert. Sie können dieses Problem lösen, indem Sie das Shared-Memory-Protokoll im SQL Server Configuration Manager aktivieren. | Sie können dies validieren, indem Sie Folgendes überprüfen: **SQL Server Configuration Manager > SQL-Server-Netzwerkkonfiguration > Protokolle für MSSQLSERVER > Shared Memory** ist „Aktiviert“. Starten Sie SQL-Server-Prozess neu, nachdem Sie das Protokoll aktiviert haben. |
| `SP-S3002` | Servicehauptschlüssel | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Automatisierung von RDS kann das Backup des Servicehauptschlüssels (SMK) nicht als Teil der neuen SMK-Generation übernehmen. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | |
| `SP-S3003` | Servicehauptschlüssel | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die Metadaten zum Servicehauptschlüssel (SMK) fehlen oder sind unvollständig. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | |
| `SP-S3004` | DB-Engine-Version und -Edition | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Es besteht eine Diskrepanz zwischen der erwarteten und der installierten Version und Edition von SQL Server: Das Ändern der SQL-Server-Edition wird auf RDS Custom für SQL Server nicht unterstützt. Außerdem wird das manuelle Ändern der SQL-Server-Version auf der EC2-Instance von RDS Custom nicht unterstützt. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | Führen Sie die folgende Abfrage aus, um die SQL-Version abzurufen: select @@version
Führen Sie den folgenden AWS CLI Befehl aus, um die Version und Edition der RDS-SQL-Engine abzurufen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep EngineVersion
aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep Engine
Weitere Informationen erhalten Sie unter [Ändern einer RDS Custom for SQL Server-DB-Instance](custom-managing.modify-sqlserver.md) und [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md). |
| `SP-S3005` | DB-Engine-Edition | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die aktuelle SQL-Server-Edition entspricht nicht der erwarteten SQL-Server-Edition [%s]: Das Ändern der SQL-Server-Edition wird auf RDS Custom für SQL Server nicht unterstützt. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. | Führen Sie die folgende Abfrage aus, um die SQL-Edition abzurufen:
**Example**
```
select @@version
``` Führen Sie den folgenden AWS CLI Befehl aus, um die RDS SQL Engine-Edition abzurufen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep Engine
|
| `SP-S3006` | DB Engine Version | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die aktuelle SQL-Server-Version entspricht nicht der erwarteten SQL-Server-Version [%s]: Sie können die SQL-Server-Version auf der EC2-Instance von RDS Custom nicht manuell ändern. Um dieses Problem zu beheben, erstellen Sie einen Support-Fall. Für future Änderungen an der SQL Server-Version können Sie die Instanz über die AWS RDS-Konsole oder über den modify-db-instance CLI-Befehl ändern. | Führen Sie die folgende Abfrage aus, um die SQL-Version abzurufen:
**Example**
```
select @@version
``` Führen Sie den folgenden AWS CLI Befehl aus, um die RDS-SQL-Engine-Version abzurufen: aws rds describe-db-instances \
--db-instance-identifier db-instance-name |grep EngineVersion
Weitere Informationen erhalten Sie unter [Ändern einer RDS Custom for SQL Server-DB-Instance](custom-managing.modify-sqlserver.md) und [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md). |
| `SP-S3007` | Speicherort für Datenbankdateien | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Datenbankdateien werden außerhalb des Laufwerks D:\$1 konfiguriert. Sie können dieses Problem beheben, indem Sie sicherstellen, dass alle Datenbankdateien, einschließlich ROW, LOG, FILESTREAM usw., auf dem Laufwerk D:\$1 gespeichert sind. | Führen Sie die folgende Abfrage aus, um den Speicherort von Datenbankdateien aufzulisten, die sich nicht unter dem Standardpfad befinden: USE master;
SELECT physical_name as files_not_in_default_path
FROM sys.master_files
WHERE SUBSTRING(physical_name,1,3)!='D:\';
|
| `SP-S3008` | Grenze für Datenbankanzahl überschritten | Der Status der DB-Instance von RDS Custom ist aus folgendem Grund auf [Nicht unterstützte Konfiguration] festgelegt: Die Gesamtzahl der Datenbanken auf der DB-Instance überschreitet die Höchstgrenze von 5000. Um dieses Problem zu beheben, reduzieren Sie die Anzahl der Datenbanken, sodass sie unter der unterstützten Grenze liegt. | Verwenden Sie den folgenden Befehl, um die Gesamtzahl der Datenbanken anzuzeigen: SELECT COUNT(name) as databaseCount
FROM sys.databases
WHERE name not in ('tempdb','master','model','msdb','DWDiagnostics','DWConfiguration','DWQueue');
|
## Problembehebung für `Storage-Full` in RDS Custom für SQL Server
RDS Custom überwacht auch das Stamm-Volume (C:). Die DB-Instance von RDS Custom für SQL Server wechselt in den Status `unsupported-configuration`, wenn auf dem Stamm-Volume weniger als 500 MiB Festplattenspeicher verfügbar sind. Weitere Informationen finden Sie unter `Event SP-S2010` in [Korrigieren von nicht unterstützten Konfigurationen in RDS Custom für SQL Server](#custom-troubleshooting-sqlserver.fix-unsupported).
## Problembehebung beim Status PENDING\$1RECOVERY für TDE-fähige Datenbanken in RDS Custom für SQL Server
SQL-Server-Datenbanken mit aktivierter transparenter Datenverschlüsselung (TDE) verbleiben möglicherweise im Status `PENDING_RECOVERY`, wenn bei der automatischen Entschlüsselung Probleme auftreten. Dies ist in der Regel nach einer Wiederherstellung der DB-Instance der Fall, wenn die Backup-Datei für den Servicehauptschlüssel (SMK) der Quell-DB-Instance, die im von RDS Custom verwalteten S3-Bucket in Ihrem Konto gespeichert ist, vor Abschluss der Wiederherstellung gelöscht wurde.
Um die automatische Entschlüsselung zu aktivieren und die TDE-fähigen Datenbanken online zu schalten, müssen Sie den Datenbankhauptschlüssel (DMK) mit seinem Passwort öffnen und den DMK mithilfe des SMK verschlüsseln.
Verwenden Sie die folgenden SQL-Server-Befehle als Referenz:
```
-- Identify PENDING_RECOVERY TDE databases
USE MASTER;
GO
SELECT name, is_encrypted, state_desc FROM sys.databases;
GO
-- Open DMK using password
OPEN MASTER KEY DECRYPTION BY PASSWORD = '';
GO
-- Encrypt DMK using SMK
ALTER MASTER KEY ADD ENCRYPTION BY SERVICE MASTER KEY;
GO
-- Close SMK
CLOSE MASTER KEY;
GO
-- Bring the TDE databases online
ALTER DATABASE SET ONLINE;
GO
-- Verify TDE databases are now in ONLINE state
SELECT name, is_encrypted, state_desc FROM sys.databases;
GO
```