Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Amazon RDS für Microsoft SQL Server
Amazon RDS unterstützt mehrere Versionen und Editionen von Microsoft SQL Server. Die folgende Tabelle enthält die neueste unterstützte Version der jeweiligen Hauptversion. Eine vollständige Liste der unterstützten Versionen, Editionen und RDS-Engine-Versionen finden Sie unter [Microsoft SQL Server-Versionen auf Amazon RDS](SQLServer.Concepts.General.VersionSupport.md).
| Hauptversion | Service Pack/GDR | Kumulatives Update | Unterversion | Knowledge-Base-Artikel | Veröffentlichungsdatum |
| --- | --- | --- | --- | --- | --- |
| SQL Server 2022 | Nicht zutreffend | CU23 | 16.0.4236.2 | [KB5078297](https://learn.microsoft.com/en-us/troubleshoot/sql/releases/sqlserver-2022/cumulativeupdate23) | 29. Januar 2026 |
| SQL Server 2019 | GDR | CU32 DDR | 15.0.4455,2 | [KB5068404](https://support.microsoft.com/en-us/topic/kb5068404-description-of-the-security-update-for-sql-server-2019-cu32-november-11-2025-c203bfbf-036e-46d2-bc10-6c01200dc48a) | 11. November 2025 |
| SQL Server 2017 | GDR | CU31 DDR | 14.0.3515,1 | [KB5068402](https://support.microsoft.com/en-us/topic/kb5068402-description-of-the-security-update-for-sql-server-2017-cu31-november-11-2025-1be08efe-ad14-4b95-a0de-ecbbf2703114) | 11. November 2025 |
| SQL Server 2016 | SP3 DDR | Nicht zutreffend | 13.0.6475,1 | [KB5068401](https://support.microsoft.com/en-us/topic/kb5068401-description-of-the-security-update-for-sql-server-2016-sp3-gdr-november-11-2025-59a59fc0-f673-45c2-b8de-492b95c0e423) | 11. November 2025 |
Weitere Informationen zur Lizenzierung für SQL Server finden Sie unter [Lizenzierung Microsoft SQL Server auf Amazon RDS](SQLServer.Concepts.General.Licensing.md). Informationen zu allen SQL Server Builds finden Sie in diesem Microsoft Support-Artikel: [Informationen zu den neuesten SQL Server Builds](https://support.microsoft.com/en-us/topic/kb957826-where-to-find-information-about-the-latest-sql-server-builds-43994ba5-9aed-2323-ea7c-d29fe9c4fbe8).
Mit Amazon RDS können Sie DB-Instances und DB-Snapshots, point-in-time Wiederherstellungen und automatisierte oder manuelle Backups erstellen. DB-Instance in SQL Server können innerhalb einer VPC verwendet werden. Sie können auch mithilfe von Secure Sockets Layer (SSL) eine Verbindung zu einer DB-Instance herstellen, die SQL Server ausführt. Und Sie können mithilfe von Transparent Data Encryption (TDE) Data-at-Rest verschlüsseln. Amazon RDS unterstützt derzeit Multi-AZ-Bereitstellungen für SQL Server mithilfe von SQL Server Database Mirroring (DBM) oder Always On Availability Groups (AGs) als Failover-Lösung mit hoher Verfügbarkeit.
Um eine verwaltete Service-Erfahrung zu bieten, stellt Amazon RDS keinen Shell-Zugriff auf DB-Instances bereit, und beschränkt den Zugriff auf bestimmte Systemprozeduren und -tabellen, die erweiterte Sonderrechte erfordern. Amazon RDS unterstützt den Zugriff auf Datenbanken auf einer DB-Instance mit jeder Standard-SQL-Client-Anwendung wie Microsoft SQL Server Management Studio. Amazon RDS erlaubt keinen direkten Hostzugriff auf eine DB-Instance über Telnet, Secure Shell (SSH) oder Windows Remote Desktop Connection. Wenn Sie eine DB-Instance erstellen, wird der Master-Benutzer der Rolle *db\$1owner* für alle Benutzerdatenbanken auf dieser Instance zugewiesen und hat alle Berechtigungen auf Datenbankebene, mit Ausnahme derjenigen, die für Backups verwendet werden. Amazon RDS verwaltet Backups für Sie.
Bevor Sie Ihre erste DB-Instance erstellen, sollten Sie die Schritte für die Einrichtung in diesem Leitfaden durchführen. Weitere Informationen finden Sie unter [Einrichten Ihrer Umgebung für Amazon RDS](CHAP_SettingUp.md).
**Topics**
+ [
## Häufige Verwaltungsaufgaben für Microsoft SQL Server in Amazon RDS
](#SQLServer.Concepts.General)
+ [
## Einschränkungen für Microsoft SQL Server-DB-Instances
](#SQLServer.Concepts.General.FeatureSupport.Limits)
+ [
# Unterstützung für Microsoft SQL Server-DB-Instance-Klassen
](SQLServer.Concepts.General.InstanceClasses.md)
+ [
# Optimieren Sie CPUs für RDS für SQL Server-Instanzen, die in der Lizenz enthalten sind
](SQLServer.Concepts.General.OptimizeCPU.md)
+ [
# Microsoft SQL Server-Sicherheit
](SQLServer.Concepts.General.FeatureSupport.UnsupportedRoles.md)
+ [
## Unterstützung zu Compliance-Programmen für Microsoft SQL Server-DB-Instances
](#SQLServer.Concepts.General.Compliance)
+ [
# Microsoft SQL Server-Versionen auf Amazon RDS
](SQLServer.Concepts.General.VersionSupport.md)
+ [
# Microsoft SQL Server-Funktionen auf Amazon RDS
](SQLServer.Concepts.General.FeatureSupport.md)
+ [
## Multi-AZ-Bereitstellungen, die die Microsoft SQL Server-Datenbankspiegelung oder AlwaysOn-Verfügbarkeitsgruppen verwenden
](#SQLServer.Concepts.General.Mirroring)
+ [
## Verwenden von Transparent Data Encryption zur Verschlüsselung ruhender Daten
](#SQLServer.Concepts.General.Options)
+ [
# Funktionen und gespeicherte Prozeduren für Amazon RDS für Microsoft SQL Server
](SQLServer.Concepts.General.StoredProcedures.md)
+ [
# Lokale Zeitzone für Microsoft SQL Server-DB-Instances
](SQLServer.Concepts.General.TimeZone.md)
+ [
# Lizenzierung Microsoft SQL Server auf Amazon RDS
](SQLServer.Concepts.General.Licensing.md)
+ [
# Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server
](USER_ConnectToMicrosoftSQLServerInstance.md)
+ [
# Arbeiten mit SQL Server Developer Edition auf RDS für SQL Server
](sqlserver-dev-edition.md)
+ [
# Arbeiten mit Active Directory mit RDS für SQL Server
](User.SQLServer.ActiveDirectoryWindowsAuth.md)
+ [
# Upgrades der DB-Engine von Microsoft SQL Server
](USER_UpgradeDBInstance.SQLServer.md)
+ [
# Arbeiten mit Speicher in RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.DatabaseStorage.md)
+ [
# Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung
](SQLServer.Procedural.Importing.md)
+ [
# Arbeiten mit Read Replicas für Microsoft SQL Server in Amazon RDS
](SQLServer.ReadReplicas.md)
+ [
# Multi-AZ-Bereitstellungen für Amazon RDS für Microsoft SQL Server
](USER_SQLServerMultiAZ.md)
+ [
# Zusätzliche Funktionen für Microsoft SQL Server auf Amazon RDS
](User.SQLServer.AdditionalFeatures.md)
+ [
# Optionen für die Microsoft SQL Server-Datenbank-Engine
](Appendix.SQLServer.Options.md)
+ [
# Häufige DBA-Aufgaben für Amazon RDS für Microsoft SQL Server
](Appendix.SQLServer.CommonDBATasks.md)
## Häufige Verwaltungsaufgaben für Microsoft SQL Server in Amazon RDS
Im Folgenden werden die Verwaltungsaufgaben veranschaulicht, die Sie mit einer Amazon RDS für SQL Server-DB-Instance am häufigsten durchführen. Bei jeder Aufgabe sind Links zu relevanter Dokumentation enthalten.
****
| Aufgabenbereich | Description | Relevante Dokumentation |
| --- | --- | --- |
| **Instance-Klassen, Speicher und PIOPS** | Wenn Sie eine DB-Instance zu Produktionszwecken erstellen, müssen Sie wissen, wie Instance-Klassen, Speichertypen und bereitgestellte IOPS in Amazon RDS funktionieren. | [Unterstützung für Microsoft SQL Server-DB-Instance-Klassen](SQLServer.Concepts.General.InstanceClasses.md) [Amazon-RDS-Speichertypen](CHAP_Storage.md#Concepts.Storage) |
| **Multi-AZ-Bereitstellungen** | Bei einer DB-Instance für die Produktion sollten Multi-AZ-Bereitstellungen eingesetzt werden. Multi-AZ-Bereitstellungen bieten eine erhöhte Verfügbarkeit, eine längere Lebensdauer von Daten sowie eine höhere Fehlertoleranz für DB-Instances. Multi-AZ-Bereitstellungen für SQL Server werden mithilfe der systemeigenen DBM- oder Technologie von SQL Server implementiert. AGs | [Konfigurieren und Verwalten einer Multi-AZ-Bereitstellung für Amazon RDS](Concepts.MultiAZ.md) [Multi-AZ-Bereitstellungen, die die Microsoft SQL Server-Datenbankspiegelung oder AlwaysOn-Verfügbarkeitsgruppen verwenden](#SQLServer.Concepts.General.Mirroring) |
| **Amazon Virtual Private Cloud (VPC)** | Wenn Ihr AWS Konto über eine Standard-VPC verfügt, wird Ihre DB-Instance automatisch in der Standard-VPC erstellt. Wenn Ihr Konto über keine Standard-VPC verfügt und Sie die DB-Instance in einer VPC erstellen möchten, müssen Sie zunächst die VPC und Subnetz-Gruppen erstellen. | [Arbeiten mit einer DB-Instance in einer VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Sicherheitsgruppen** | DB-Instances werden standardmäßig mit einer Firewall erstellt, die den Zugriff auf die Instance verhindert. Daher müssen Sie eine Sicherheitsgruppe mit den korrekten IP-Adressen und Netzwerkkonfigurationen erstellen, um auf die DB-Instance zuzugreifen. | [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md) |
| **Parametergruppen** | Wenn Ihre DB-Instance spezifische Datenbankparameter erfordert, sollten Sie vor der DB-Instance eine Parametergruppe erstellen. | [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Optionsgruppen** | Wenn Ihre DB-Instance spezifische Datenbankoptionen erfordert, sollten Sie vor der DB-Instance eine Optionsgruppe erstellen. | [Optionen für die Microsoft SQL Server-Datenbank-Engine](Appendix.SQLServer.Options.md) |
| **Herstellen einer Verbindung mit einer DB-Instance** | Nachdem Sie eine Sicherheitsgruppe erstellt und einer DB-Instance zugeordnet haben, können Sie über eine Standard-SQL-Client-Anwendung wie Microsoft SQL Server Management Studio eine Verbindung zu dieser DB-Instance aufbauen. | [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md) |
| **Backup und Wiederherstellung** | Beim Erstellen Ihrer DB-Instance können Sie automatisierte Backups konfigurieren. Sie können Ihre Datenbanken auch mithilfe von vollständigen Sicherungsdateien (.bak-Dateien) manuell sichern oder wiederherstellen. | [Einführung in Backups](USER_WorkingWithAutomatedBackups.md) [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md) |
| **Überwachung** | Sie können Ihre SQL Server-DB-Instance mithilfe von CloudWatch Amazon RDS-Metriken, Ereignissen und erweiterter Überwachung überwachen. | [Anzeigen von Metriken in der Amazon-RDS-Konsole](USER_Monitoring.md) [Anzeigen von Amazon-RDS-Ereignissen](USER_ListEvents.md) |
| **Protokolldateien** | Sie können auf die Protokolldateien für Ihre SQL Server-DB-Instance zugreifen. | [Überwachen von Amazon RDS-Protokolldateien](USER_LogAccess.md) [Datenbankprotokolldateien von Amazon RDS für Microsoft SQL Server](USER_LogAccess.Concepts.SQLServer.md) |
Es gibt auch erweiterte administrative Aufgaben für die Arbeit mit SQL Server-DB-Instances. Weitere Informationen finden Sie in der folgenden Dokumentation:
+ [Häufige DBA-Aufgaben für Amazon RDS für Microsoft SQL Server](Appendix.SQLServer.CommonDBATasks.md).
+ [Arbeiten mit AWS Managed Active Directory mit RDS für SQL Server](USER_SQLServerWinAuth.md)
+ [Zugriff auf die Datenbank tempdb](SQLServer.TempDB.md)
## Einschränkungen für Microsoft SQL Server-DB-Instances
Für die Amazon-RDS-Implementierung von Microsoft SQL Server in einer DB-Instance gelten einige Beschränkungen, die Sie kennen sollten:
+ Die maximale Anzahl von Datenbanken, die auf einer DB-Instance unterstützt werden, hängt vom Instance-Klassentyp und dem Verfügbarkeitsmodus ab — Single-AZ, Multi-AZ Database Mirroring (DBM) oder Multi-AZ Availability Groups (). AGs Die Microsoft SQL Server-Systemdatenbanken werden bei der Feststellung der Anzahl nicht mit berücksichtigt.
Die folgende Tabelle zeigt die maximale Anzahl unterstützter Datenbanken für die einzelnen Instance-Klassentypen und Verfügbarkeitsmodi. Durch diese Tabelle können Sie einfacher entscheiden, ob Sie den Instance-Klassentyp oder den Verfügbarkeitsmodus wechseln können. Wenn Ihre Quell-DB-Instance mehr Datenbanken hat als der Typ der Ziel-Instance-Klasse oder mehr als der Verfügbarkeitsmodus unterstützen kann, schlägt das Ändern der DB-Instance fehl. Sie können den Status Ihrer Anforderung im Bereich **Events (Ereignisse)** anzeigen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html)
\$1 stellt die unterschiedlichen Typen von Instance-Klassen dar.
Angenommen, Ihre DB-Instance wird auf einer db.\$1.16xlarge mit Single-AZ ausgeführt und verfügt über 76 Datenbanken. Sie ändern die DB-Instance, um ein Upgrade auf Multi-AZ Always On AGs durchzuführen. Dieses Upgrade schlägt fehl, da Ihre DB-Instance mehr Datenbanken enthält, als Ihre Ziel-Konfiguration unterstützen kann. Wenn Sie den Typ Ihrer Instance-Klasse stattdessen auf db.\$1.24xlarge upgraden, ist die Änderung erfolgreich.
Schlägt das Upgrade fehl, werden Ihnen Ereignisse und Nachrichten ähnlich der folgenden angezeigt:
+ Die Klasse der Datenbank-Instance kann nicht geändert werden. Die Instance verfügt über 76 Datenbanken, aber nach der Konvertierung würde sie nur 75 unterstützen 75.
+ Konvertierung der DB-Instance zu Multi-AZ nicht möglich: Die Instance verfügt über 76 Datenbanken, nach einer Konvertierung würden aber nur 75 unterstützt werden.
Wenn die point-in-time Wiederherstellung oder Snapshot-Wiederherstellung fehlschlägt, werden Ereignisse und Meldungen angezeigt, die den folgenden ähneln:
+ Datenbank-Instance auf incompatible-restore festgelegt. Die Instance verfügt über 76 Datenbanken, aber nach der Konvertierung würde sie nur 75 unterstützen 75.
+ Die folgenden Ports sind für Amazon RDS reserviert und Sie können sie nicht beim Erstellen der DB-Instance verwenden: `1234, 1434, 3260, 3343, 3389, 47001,` und `49152-49156`.
+ Client-Verbindungen von IP-Adressen im Bereich 169.254.0.0/16 sind nicht erlaubt. Dies ist der APIPA-Bereich (Automatic Private IP Addressing), der für die Local-Link-Adressierung verwendet wird.
+ SQL Server Standard Edition verwendet nur einen teil der verfügbaren Prozessoren, wenn die DB-Instance mehr Prozessoren als die Softwarelimits hat (24 Kerne, 4 Sockets und 128 GB RAM). Beispiele dafür sind die Instance-Klassen db.m5.24xlarge und db.r5.24xlarge.
Weitere Informationen finden Sie in der Tabelle der Maßstabsgrenzen unter [Editionen und unterstützte Funktionen von SQL Server 2019 (15.x)](https://docs.microsoft.com/en-us/sql/sql-server/editions-and-components-of-sql-server-version-15) in der Microsoft-Dokumentation.
+ Amazon RDS für SQL Server unterstützt nicht das Importieren von Daten in die msdb-Datenbank.
+ Sie können eine Datenbank in einer DB-Instance in einer SQL Server-Multi-AZ-Bereitstellung nicht umbenennen.
+ Stellen Sie sicher, dass Sie diese Richtlinien verwenden, wenn Sie die folgenden DB-Parameter auf RDS für SQL Server festlegen:
+ `max server memory (mb)` >= 256 MB
+ `max worker threads`>= (Anzahl der logischen Zeichen x CPUs 7)
Weitere Informationen zum Einstellen von DB-Parametern finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
+ Die maximale Speicherplatzgröße für SQL-Server-DB-Instances beträgt:
+ Allzweckspeicher (SSD): 16 TiB für alle Editionen
+ Speicher mit bereitgestellten IOPS: 64 TiB für alle Editionen
+ Magnetspeicher: 1 TiB für alle Editionen
In einem Szenario mit größerem Speicherbedarf ist es möglich, diese Beschränkung durch Sharding über mehrere DB-Instances zu umgehen. Diese Methode verlangt eine datenabhängige Routing-Logik in Anwendungen, die eine Verbindung zum Sharding-System aufbauen. Sie können ein bestehendes Sharding-Framework nutzen oder Sharding durch benutzerdefinierten Code einrichten. Wenn Sie ein vorhandenes Framework nutzen, kann dieses keine Komponenten auf dem Server installieren, auf dem sich die DB-Instance befindet.
+ Die Mindestspeicherplatzgröße für SQL-Server-DB-Instances beträgt:
+ General Purpose (SSD)-Speicher – 20 GiB für Enterprise, Standard, Web und Express Editionen
+ Bereitgestellter IOPS-Speicher – 20 GiB für Enterprise, Standard, Web und Express Editionen
+ Magnetspeicher-Speicher – 20 GiB für Enterprise, Standard, Web und Express Editionen
+ Amazon RDS unterstützt nicht das Ausführen dieser Services auf dem selben Server wie Ihre RDS-DB-Instance:
+ Data Quality Services
+ Master Data Services
Für die Verwendung dieser Funktionen sollten Sie SQL Server auf einer Amazon EC2-Instance installieren oder eine lokale SQL Server-Instance nutzen. In diesen Fällen agiert die EC2- oder SQL Server-Instance für Ihre SQL Server-DB-Instance in Amazon RDS als Server für die Master Data Services. Sie können SQL Server auf einer Amazon EC2-Instance mit Amazon EBS-Speicher unter Einhaltung der Microsoft-Lizenzrichtlinien installieren.
+ Aufgrund von Beschränkungen in Microsoft SQL Server reflektiert eine zeitpunktbezogene Wiederherstellung vor der erfolgreichen Ausführung von `DROP DATABASE` möglicherweise nicht den Zustand dieser Datenbank zu diesem Zeitpunkt. Beispiel: Der Zustand der verworfenen Datenbank wird in der Regel 5 Minuten vor Ausgabe des `DROP DATABASE`-Befehls wiederhergestellt. Diese Art der Wiederherstellung bedeutet, dass Sie die Transaktionen, die während dieser paar Minuten durchgeführt wurden, nicht auf der verworfenen Datenbank wiederherstellen können. Um dieses Problem zu umgehen, können Sie den Befehl `DROP DATABASE` erneut nach Abschluss der Wiederherstellungsoperation ausgeben. Durch Löschen einer Datenbank per Drop werden die Transaktionsprotokolle für diese Datenbank entfernt.
+ In SQL Server erstellen Sie die Datenbanken nach der DB-Instance. Die Datenbanknamen folgen den üblichen SQL-Server-Namensregeln mit den folgenden Unterschieden:
+ Datenbanknamen dürfen nicht mit beginne `rdsadmin`.
+ Sie können nicht mit einem Leerzeichen oder einem Tabulator beginnen oder enden.
+ Sie dürfen keine Zeichen enthalten, die eine neue Zeile erzeugen.
+ Sie dürfen kein einzelnes Anführungszeichen (`'`) enthalten.
+ Mit SQL Server Web Edition können Sie nur die **Dev/Test-Vorlage** verwenden, wenn Sie eine neue DB-Instance von RDS für SQL Server erstellen.
+ SQL Server Web Edition wurde für Webhoster und Webhoster entwickelt VAPs , um öffentliche und über das Internet zugängliche Webseiten, Websites, Webanwendungen und Webdienste zu hosten. Weitere Informationen finden Sie unter [Lizenzierung Microsoft SQL Server auf Amazon RDS](SQLServer.Concepts.General.Licensing.md).
# Unterstützung für Microsoft SQL Server-DB-Instance-Klassen
Die Rechen- und Speicherkapazität von DB-Instances wird über deren Klasse festgelegt. Die benötigte DB-Instance-Klasse richtet sich nach Ihren Rechen- und Speicheranforderungen. Weitere Informationen finden Sie unter [](Concepts.DBInstanceClass.md).
Die folgende Liste der DB-Instance-Klassen, die für Microsoft SQL Server unterstützt werden, finden Sie hier. Eine aktuelle Liste finden Sie in der RDS-Konsole: [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
Nicht alle DB-Instance-Klassen stehen für alle unterstützten SQL-Server-Nebenversionen zur Verfügung. Zum Beispiel sind einige neuere DB-Instance-Klassen wie db.r6i für ältere Nebenversionen nicht verfügbar. Sie können den AWS CLI Befehl [describe-orderable-db-instance-options](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-orderable-db-instance-options.html) verwenden, um herauszufinden, welche DB-Instance-Klassen für Ihre SQL Server-Edition und -Version verfügbar sind.
****
| SQL Server Edition | Supportbereich 2022 | Supportbereich 2019 | Supportbereich 2017 und 2016 |
| --- | --- | --- | --- |
| Enterprise Edition | `db.t3.xlarge`–`db.t3.2xlarge``db.r5.xlarge`–`db.r5.24xlarge``db.r5b.xlarge`–`db.r5b.24xlarge``db.r5d.xlarge`–`db.r5d.24xlarge``db.r6i.xlarge`–`db.r6i.32xlarge`db.r7i.xlarge–db.r7i.48xlarge`db.m5.xlarge`–`db.m5.24xlarge``db.m5d.xlarge`–`db.m5d.24xlarge``db.m6i.xlarge`–`db.m6i.32xlarge``db.m7i.xlarge`–`db.m7i.48xlarge``db.x2iedn.xlarge`–`db.x2iedn.32xlarge``db.z1d.xlarge`–`db.z1d.12xlarge` | `db.t3.xlarge`–`db.t3.2xlarge` `db.r5.xlarge`–`db.r5.24xlarge` `db.r5b.xlarge`–`db.r5b.24xlarge` `db.r5d.xlarge`–`db.r5d.24xlarge` `db.r6i.xlarge`–`db.r6i.32xlarge` `db.r7i.xlarge`–`db.r7i.48xlarge` `db.m5.xlarge`–`db.m5.24xlarge` `db.m5d.xlarge`–`db.m5d.24xlarge` `db.m6i.xlarge`–`db.m6i.32xlarge` `db.m7i.xlarge`–`db.m7i.48xlarge` `db.x2iedn.xlarge`–`db.x2iedn.32xlarge` `db.z1d.xlarge`–`db.z1d.12xlarge` | `db.t3.xlarge`–`db.t3.2xlarge` `db.r5.xlarge`–`db.r5.24xlarge` `db.r5b.xlarge`–`db.r5b.24xlarge` `db.r5d.xlarge`–`db.r5d.24xlarge` `db.r6i.xlarge`–`db.r6i.32xlarge` `db.r7i.xlarge`–`db.r7i.48xlarge` `db.m5.xlarge`–`db.m5.24xlarge` `db.m5d.xlarge`–`db.m5d.24xlarge` `db.m6i.xlarge`–`db.m6i.32xlarge` `db.m7i.xlarge`–`db.m7i.48xlarge` `db.x2iedn.xlarge`–`db.x2iedn.32xlarge` `db.z1d.xlarge`–`db.z1d.12xlarge` |
| Standard Edition | `db.t3.xlarge`–`db.t3.2xlarge``db.r5.large`–`db.r5.24xlarge``db.r5b.large`–`db.r5b.8xlarge``db.r5d.large`–`db.r5d.24xlarge``db.r6i.large`–`db.r6i.8xlarge`db.r7i.large–db.r7i.12xlarge`db.m5.large`–`db.m5.24xlarge``db.m5d.large`–`db.m5d.24xlarge``db.m6i.large`–`db.m6i.8xlarge``db.m7i.large`–`db.m7i.12xlarge``db.x2iedn.xlarge`–`db.x2iedn.8xlarge``db.z1d.large`–`db.z1d.12xlarge` | `db.t3.xlarge`–`db.t3.2xlarge` `db.r5.large`–`db.r5.24xlarge` `db.r5b.large`–`db.r5b.24xlarge` `db.r5d.large`–`db.r5d.24xlarge` `db.r6i.large`–`db.r6i.8xlarge` `db.r7i.large`–`db.r7i.12xlarge` `db.m5.large`–`db.m5.24xlarge` `db.m5d.large`–`db.m5d.24xlarge` `db.m6i.large`–`db.m6i.8xlarge` `db.m7i.large`–`db.m7i.12xlarge` `db.x2iedn.xlarge`–`db.x2iedn.32xlarge` `db.z1d.large`–`db.z1d.12xlarge` | `db.t3.xlarge`–`db.t3.2xlarge``db.r5.large`–`db.r5.24xlarge``db.r5b.large`–`db.r5b.24xlarge``db.r5d.large`–`db.r5d.24xlarge``db.r6i.large`–`db.r6i.8xlarge``db.r7i.large`–`db.r7i.12xlarge``db.m5.large`–`db.m5.24xlarge``db.m5d.large`–`db.m5d.24xlarge``db.m6i.large`–`db.m6i.8xlarge`db.m7i.large–db.m7i.12xlarge`db.x2iedn.xlarge`–`db.x2iedn.32xlarge``db.z1d.large`–`db.z1d.12xlarge` |
| Web Edition | `db.t3.small`–`db.t3.xlarge``db.r5.large`–`db.r5.4xlarge``db.r5b.large`–`db.r5b.4xlarge``db.r5d.large`–`db.r5d.4xlarge`db.r6i.large–db.r6i.4xlarge`db.r7i.large`–`db.r7i.4xlarge``db.m5.large`–`db.m5.4xlarge``db.m5d.large`–`db.m5d.4xlarge``db.m6i.large`–`db.m6i.4xlarge``db.m7i.large`–`db.m7i.4xlarge``db.z1d.large`–`db.z1d.13xlarge` | `db.t3.small`–`db.t3.2xlarge``db.r5.large`–`db.r5.4xlarge``db.r5b.large`–`db.r5b.4xlarge``db.r5d.large`–`db.r5d.4xlarge``db.r6i.large`–`db.r6i.4xlarge`db.r7i.large–db.r7i.4xlarge`db.m5.large`–`db.m5.4xlarge``db.m5d.large`–`db.m5d.4xlarge``db.m6i.large`–`db.m6i.4xlarge`db.m7i.large–db.m7i.4xlarge`db.z1d.large`–`db.z1d.3xlarge` | `db.t3.small`–`db.t3.2xlarge``db.r5.large`–`db.r5.4xlarge``db.r5b.large`–`db.r5b.4xlarge``db.r5d.large`–`db.r5d.4xlarge``db.r6i.large`–`db.r6i.4xlarge`db.r7i.large–db.r7i.4xlarge`db.m5.large`–`db.m5.4xlarge``db.m5d.large`–`db.m5d.4xlarge``db.m6i.large`–`db.m6i.4xlarge`db.m7i.large–db.m7i.4xlarge`db.z1d.large`–`db.z1d.3xlarge` |
| Express Edition | `db.t3.micro`–`db.t3.xlarge` | `db.t3.micro`–`db.t3.xlarge` | `db.t3.micro`–`db.t3.xlarge` |
| Developer Edition | `db.m6i.xlarge`–`db.m6i.32xlarge``db.r6i.xlarge`–`db.r6i.32xlarge` | | |
**Anmerkung**
Ab der Instance-Klasse der 7. Generation ist Hyper-Threading auf RDS SQL Server für Instance-Größen ab 2xlarge deaktiviert. [Dies führt dazu, dass die Gesamtzahl der verfügbaren v der Hälfte der Anzahl der CPUs verfügbaren V entspricht, die von der entsprechenden EC2-Instance unterstützt wird.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cpu-options-supported-instances-values.html) Beispielsweise unterstützt der EC2-Instance-Typ `m7i.2xlarge` standardmäßig 4 Kerne und 2 threadsPerCore, was insgesamt 8 v ergibt. CPUs Im Gegensatz dazu ergibt die `db.m7i.2xlarge` RDS-Instanz für SQL Server bei deaktiviertem Hyperthreading 4 Kerne und 1 threadsPerCore, insgesamt 4 V. CPUs
Ab den Instances der 7. Generation enthält Ihre Abrechnung eine detaillierte Aufschlüsselung der Lizenzgebühren für RDS-DB-Instances und Drittanbieter. Weitere Informationen finden Sie unter [Preise für RDS SQL Server](https://aws.amazon.com/rds/sqlserver/pricing/).
# Optimieren Sie CPUs für RDS für SQL Server-Instanzen, die in der Lizenz enthalten sind
Mit RDS for SQL Server können Sie Optimize CPU verwenden, indem Sie Prozessorfunktionen angeben, um die Anzahl der vCPUs auf Ihrer DB-Instance zu konfigurieren und dabei denselben Arbeitsspeicher und dieselbe IOPS beizubehalten. Sie können das gewünschte memory-to-CPU Verhältnis für bestimmte Datenbank-Workload-Anforderungen erreichen und die Lizenzkosten für Microsoft Windows OS und SQL Server reduzieren, die auf der Anzahl der vCPUs basieren.
Verwenden Sie die folgenden Parameter, um die Prozessorfunktion anzugeben:
```
--processor-features "Name=coreCount,Value=value" \
"Name=threadsPerCore,Value=value"
```
+ **CoreCount** — Geben Sie die Anzahl der CPU-Kerne für die DB-Instance an, um die Lizenzkosten für DB-Instances zu optimieren. Informationen [DB-Instance-Klassen, die Optimize CPU unterstützenUnterstützung für DB-Instance-Klassen](SQLServer.Concepts.General.OptimizeCPU.Support.md) zu den zulässigen Werten für die Anzahl der Kerne für einen ausgewählten Instance-Typ finden Sie unter.
+ **threadsPerCore**— Geben Sie die Threads pro Kern an, um die Anzahl der Threads pro CPU-Kern zu definieren. Informationen [DB-Instance-Klassen, die Optimize CPU unterstützenUnterstützung für DB-Instance-Klassen](SQLServer.Concepts.General.OptimizeCPU.Support.md) zu den zulässigen Werten für Threads pro Kern für einen ausgewählten Instanztyp finden Sie unter.
Beispielbefehl zum Erstellen einer RDS-Instanz für SQL Server mit CPU-Einstellungen optimieren:
```
aws rds create-db-instance \
--engine sqlserver-ee \
--engine-version 16.00 \
--license-model license-included \
--allocated-storage 300 \
--master-username myuser \
--master-user-password xxxxx \
--no-multi-az \
--vpc-security-group-ids myvpcsecuritygroup \
--db-subnet-group-name mydbsubnetgroup \
--db-instance-identifier my-rds-instance \
--db-instance-class db.m7i.8xlarge \
--processor-features "Name=coreCount,Value=8" "Name=threadsPerCore,Value=1"
```
In diesem Beispiel erstellen Sie eine `db.m7i.8xlarge` Instanz, die standardmäßig einen CoreCount von 16 hat. Wenn Sie Optimize CPU verwenden, entscheiden Sie sich für einen CoreCount von 8, was zu einer effektiven vCPU-Anzahl von 8 führt.
Wenn Sie die Instanz ohne den `--processor-features` Parameter erstellen, ist die Anzahl der Kerne standardmäßig auf 16 und die Anzahl der Threads pro Kern standardmäßig auf 1 festgelegt, was zu einer standardmäßigen vCPU-Anzahl von 16 führt.
Einige Überlegungen, die Sie bei der Angabe der Prozessorfunktionen beachten sollten:
+ **Erstellen** — Geben Sie `coreCount` sowohl den als auch `threadsPerCore` für den `processor-features` Parameter aus den zulässigen Werten an. Siehe [DB-Instance-Klassen, die Optimize CPU unterstützenUnterstützung für DB-Instance-Klassen](SQLServer.Concepts.General.OptimizeCPU.Support.md).
+ **Ändern** — Wenn Sie von einer Instance-Klasse, die mit Optimize CPU settings konfiguriert ist, zu einer anderen wechseln, die Optimize CPU-Einstellungen unterstützt, müssen Sie die Standard-Prozessoreinstellungen mithilfe des `--use-default-processor-features` Parameters angeben oder die Optionen während der Änderungsanforderung explizit definieren.
**Anmerkung**
Eine Änderung der vCPU-Anzahl kann Auswirkungen auf die mit der DB-Instance verbundenen Lizenzgebühren haben.
+ **Snapshot-Wiederherstellung** — Wenn ein Snapshot auf demselben Instance-Typ wie die Quelle wiederhergestellt wird, erbt die wiederhergestellte DB-Instance die CPU-Optimize-Einstellungen aus dem Snapshot. Wenn Sie die Wiederherstellung auf einen anderen Instance-Typ durchführen, müssen Sie die CPU-Optimize-Einstellungen für die Ziel-Instance definieren oder den `--use-default-processor-features` Parameter angeben.
+ **Point-in-time Wiederherstellung** — Point-in-time Wiederherstellung (PITR) beinhaltet die Wiederherstellung eines bestimmten Snapshots auf der Grundlage der festgelegten Zeit für PITR und das anschließende Anwenden aller Transaktionsprotokollsicherungen auf diesen Snapshot, wodurch die Instanz auf den angegebenen Zeitpunkt gebracht wird. Bei PITR werden die CPU-Optimize-Einstellungen `coreCount` und`threadsPerCore`, vom Quell-Snapshot (nicht vom Zeitpunkt) abgeleitet, sofern bei der PITR-Anfrage keine benutzerdefinierten Werte angegeben wurden. Wenn der verwendete Quell-Snapshot mit den CPU-Einstellungen optimieren aktiviert ist und Sie einen anderen Instance-Typ für PITR verwenden, müssen Sie die CPU-Optimize-Einstellungen für die Ziel-Instance definieren oder den Parameter angeben. `—-use-default-processor-features`
## Einschränkungen
Bei der Verwendung von Optimize CPU gelten die folgenden Einschränkungen:
+ Optimize CPU wird nur in den Editionen Enterprise, Standard und Web unterstützt.
+ Optimize CPU ist auf ausgewählten Instances verfügbar. Siehe [DB-Instance-Klassen, die Optimize CPU unterstützenUnterstützung für DB-Instance-Klassen](SQLServer.Concepts.General.OptimizeCPU.Support.md).
+ Das Anpassen der Anzahl der CPU-Kerne wird für Instance-Größen von `2xlarge` und mehr unterstützt. Bei diesen Instance-Typen beträgt die Mindestanzahl von vCPCUs, die für Optimize CPU unterstützt werden, 4.
+ Optimize CPU erlaubt nur 1 Thread pro Kern, da Hyper-Threading für Instances ab der 7. Generation, die Optimize CPU unterstützen, deaktiviert ist.
# DB-Instance-Klassen, die Optimize CPU unterstützen
RDS for SQL Server unterstützt Optimize CPU ab dem Instance-Klassentyp der 7. Generation. Darüber hinaus bietet RDS eine detaillierte Abrechnungsaufschlüsselung der Lizenzgebühren für RDS-DB-Instances und Drittanbieter, beginnend mit dem Instance-Klassentyp der 7. Generation, unabhängig davon, ob die Funktion „CPU optimieren“ aktiviert ist.
RDS for SQL Server bietet Unterstützung für Optimize CPU für bestimmte Instance-Größen, wobei die kleinste unterstützte Instance-Größe ist`2xlarge`. Die unterstützte Mindestkonfiguration ist 4 CPUs v. In der folgenden Tabelle sind die DB-Instance-Klassen aufgeführt, die Optimize CPU unterstützen, einschließlich ihrer standardmäßigen und gültigen Werte für CPU-Kerne, CPU-Threads pro Kern und vCPUs:
**Instances für allgemeine Zwecke**
| Instance-Typ | Standard: v CPUs | Standard-CPU-Kerne | Gültige CPU-Kerne | Gültige Threads pro Kern |
| --- | --- | --- | --- | --- |
| `m7i.large` | 2 | 1 | 1 | 2 |
| `m7i.xlarge` | 4 | 2 | 2 | 2 |
| `m7i.2xlarge` | 4 | 4 | 1,2,3,4 | 1 |
| `m7i.4xlarge` | 8 | 8 | 1,2,3,4,5,6,7,8 | 1 |
| `m7i.8xlarge` | 16 | 16 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 | 1 |
| `m7i.12xlarge` | 24 | 24 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24 | 1 |
| `m7i.16xlarge` | 32 | 32 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32 | 1 |
**RAM-optimierte Instances**
| Instance-Typ | Standard v CPUs | Standard-CPU-Kerne | Gültige CPU-Kerne | Gültige Threads pro Kern |
| --- | --- | --- | --- | --- |
| `r7i.large` | 2 | 1 | 1 | 2 |
| `r7i.xlarge` | 4 | 2 | 2 | 2 |
| `r7i.2xlarge` | 4 | 4 | 1,2,3,4 | 1 |
| `r7i.4xlarge` | 8 | 8 | 1,2,3,4,5,6,7,8 | 1 |
| `r7i.8xlarge` | 16 | 16 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 | 1 |
| `r7i.12xlarge` | 24 | 24 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24 | 1 |
| `r7i.16xlarge` | 32 | 32 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32 | 1 |
# Festlegen der CPU-Kerne und -Threads pro CPU-Kern für eine DB-Instance-Klasse
Sie können die Anzahl der CPU-Kerne und Threads pro Kern für die DB-Instance-Klasse konfigurieren, wenn Sie die folgenden Operationen durchführen:
+ [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md)
+ [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md)
+ [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md)
+ [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md)
**Anmerkung**
Wenn Sie eine DB-Instance ändern, um die Anzahl der CPU-Kerne oder Threads pro Kern zu konfigurieren, kommt es zu einem kurzen Ausfall, ähnlich wie beim Ändern der Instance-Klasse.
Stellen Sie die CPU-Kerne mithilfe der AWS CLI oder der AWS-Managementkonsole RDS-API ein.
## Konsole
**Um die Kerne einzustellen**
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 **Datenbank erstellen** aus.
1. Gehen Sie beim Einstellen der **Instance-Konfigurationsoptionen** wie folgt vor:
1. Wählen Sie die Option „**CPU optimieren**“.
1. Stellen Sie Ihre **vCPU-Option** ein, indem Sie die Anzahl der Kerne auswählen.
![\[Seite zum Erstellen der Datenbank beim Einstellen der OCPU-Einstellungen\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/OCPU-screenshot.png)
1. Nachdem Sie alle anderen Auswahlen abgeschlossen haben, wählen Sie Datenbank **erstellen** aus.
## AWS CLI
**Um die Kerne einzustellen**
1. Um Optimize CPU mit der AWS-CLI zu konfigurieren, fügen Sie die `--processor-features` Option in den Befehl ein. Geben Sie die Anzahl der CPU-Kerne mit dem `coreCount` und `threadsPerCore` als an`1`.
1. Verwenden Sie die folgende Syntax:
```
aws rds create-db-instance \
--engine sqlserver-ee \
--engine-version 16.00 \
--license-model license-included \
--allocated-storage 300 \
--master-username myuser \
--master-user-password xxxxx \
--no-multi-az \
--vpc-security-group-ids myvpcsecuritygroup \
--db-subnet-group-name mydbsubnetgroup \
--db-instance-identifier my-rds-instance \
--db-instance-class db.m7i.4xlarge \
--processor-features "Name=coreCount,Value=6" "Name=threadsPerCore,Value=1"
```
**Example zum Anzeigen gültiger Prozessorwerte für eine DB-Instance-Klasse**
Verwenden Sie den `describe-orderable-db-instance-options` Befehl, um die Standardwerte für VCPUs, Kerne und Threads pro Kern anzuzeigen. Die Ausgabe für den folgenden Befehl zeigt beispielsweise die Prozessoroptionen für die Instance-Klasse db.r7i.2xlarge.
```
aws rds describe-orderable-db-instance-options --engine sqlserver-ee \
--db-instance-class db.r7i.2xlarge
Sample output:
-------------------------------------------------------------
| DescribeOrderableDBInstanceOptions |
+-----------------------------------------------------------+
|| OrderableDBInstanceOptions ||
|+------------------------------------+--------------------+|
|| DBInstanceClass | db.r7i.2xlarge ||
|| Engine | sqlserver-ee ||
|| EngineVersion | 13.00.6300.2.v1 ||
|| LicenseModel | license-included ||
|| MaxIopsPerDbInstance | ||
|| MaxIopsPerGib | ||
|| MaxStorageSize | 64000 ||
|| MinIopsPerDbInstance | ||
|| MinIopsPerGib | ||
|| MinStorageSize | 20 ||
|| MultiAZCapable | True ||
|| OutpostCapable | False ||
|| ReadReplicaCapable | True ||
|| StorageType | gp2 ||
|| SupportsClusters | False ||
|| SupportsDedicatedLogVolume | False ||
|| SupportsEnhancedMonitoring | True ||
|| SupportsGlobalDatabases | False ||
|| SupportsIAMDatabaseAuthentication | False ||
|| SupportsIops | False ||
|| SupportsKerberosAuthentication | True ||
|| SupportsPerformanceInsights | True ||
|| SupportsStorageAutoscaling | True ||
|| SupportsStorageEncryption | True ||
|| SupportsStorageThroughput | False ||
|| Vpc | True ||
|+------------------------------------+--------------------+|
||| AvailabilityZones |||
||+-------------------------------------------------------+||
||| Name |||
||+-------------------------------------------------------+||
||| us-west-2a |||
||| us-west-2b |||
||| us-west-2c |||
||+-------------------------------------------------------+||
||| AvailableProcessorFeatures |||
||+-----------------+-----------------+-------------------+||
||| AllowedValues | DefaultValue | Name |||
||+-----------------+-----------------+-------------------+||
||| 1,2,3,4 | 4 | coreCount |||
||| 1 | 1 | threadsPerCore |||
||+-----------------+-----------------+-------------------+||
```
Darüber hinaus können Sie die folgenden Befehle ausführen, um Informationen zum Prozessor der DB-Instance-Klasse zu erhalten:
+ `describe-db-instances`— Zeigt die Prozessorinformationen für die angegebene DB-Instance an
+ `describe-db-snapshots`— Zeigt die Prozessorinformationen für den angegebenen DB-Snapshot
+ `describe-valid-db-instance-modifications`— Zeigt die gültigen Änderungen am Prozessor für die angegebene DB-Instance
In der Ausgabe des vorherigen Befehls sind die Werte für die Prozessorfunktionen angegeben, `null` wenn Optimize CPU nicht konfiguriert ist.
**Example zum Einstellen der Anzahl der CPU-Kerne für eine DB-Instance**
Im folgenden Beispiel wird die Änderung vorgenommen, *mydbinstance* indem die Anzahl der CPU-Kerne auf 4 threadsPerCore als 1 gesetzt wird. Wenden Sie die Änderungen sofort an, indem Sie `--apply-immediately` Wenn Sie die Änderungen während des nächsten geplanten Wartungsfensters anwenden möchten, lassen Sie die Option aus`--apply-immediately option`.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.r7i.8xlarge \
--processor-features "Name=coreCount,Value=4" "Name=threadsPerCore,Value=1" \
--apply-immediately
```
**Example der Rückkehr zu den Standard-Prozessoreinstellungen für eine DB-Instance**
Im folgenden Beispiel werden Änderungen vorgenommen, *mydbinstance* indem es auf die Standardwerte des Prozessors zurückgesetzt wird.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.r7i.8xlarge \
--use-default-processor-features \
--apply-immediately
```
# Microsoft SQL Server-Sicherheit
Die Microsoft SQL Server-Datenbank-Engine verwendet rollenbasierte Sicherheit. Der Master-Benutzername, den Sie beim Erstellen einer DB-Instance angeben, ist eine SQL Server-Authentifizierungsanmeldung, die den festen Serverrollen `processadmin`, `public` und `setupadmin` angehört.
Jeder Benutzer, der eine Datenbank erstellt, wird der db\$1owner-Rolle für diese Datenbank zugewiesen und er erhält die Berechtigungen für alle Datenbankebenen, außer für diejenigen, die für Datensicherungen verwendet werden. Amazon RDS verwaltet Backups für Sie.
Die folgenden Rollen auf Serverebene sind in Amazon RDS for SQL Server nicht verfügbar:
+ bulkadmin
+ dbcreator
+ diskadmin
+ securityadmin
+ serveradmin
+ sysadmin
Die folgenden Berechtigungen auf Serverebene sind für RDS for SQL Server DB-Instances nicht verfügbar:
+ EINE BELIEBIGE DATENBANK ÄNDERN
+ ALTER ANY EVENT NOTIFICATION
+ ALTER RESOURCES
+ ALTER SETTINGS (Sie können die API-Operationen der DB-Parametergruppe verwenden, um Parameter zu ändern; weitere Informationen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md))
+ AUTHENTICATE SERVER
+ CONTROL\$1SERVER
+ CREATE DDL EVENT NOTIFICATION
+ CREATE ENDPOINT
+ ERSTELLEN EINER SERVERROLLE
+ CREATE TRACE EVENT NOTIFICATION
+ EINE BELIEBIGE DATENBANK LÖSCHEN
+ EXTERNAL ACCESS ASSEMBLY
+ SHUTDOWN (Sie können stattdessen die RDS-Option zum Neustart verwenden.)
+ UNSAFE ASSEMBLY
+ JEDE BELIEBIGE VERFÜGBARKEITSGRUPPE ÄNDERN
+ ERSTELLEN EINER BELIEBIGEN VERFÜGBARKEITSGRUPPE
## SSL-Unterstützung für Microsoft SQL Server-DB-Instances
Sie können SSL zum Verschlüsseln von Verbindungen zwischen Ihren Anwendungen und Ihren Amazon RDS-DB-Instances verwenden, auf denen Microsoft SQL Server ausgeführt wird. Sie können auch erzwingen, dass alle Verbindungen zu Ihrer DB-Instance SSL verwenden. Wenn Sie Verbindungen erzwingen, um SSL zu verwenden, erfolgt dies für den Kunden transparent, der Kunde muss nichts tun, um SSL verwenden zu können.
SSL ist in allen AWS-Regionen und für alle unterstützten SQL Server-Editionen verfügbar. Weitere Informationen finden Sie unter [Verwenden von SSL mit einer Microsoft SQL Server-DB-Instance](SQLServer.Concepts.General.SSL.Using.md).
# Verwenden von SSL mit einer Microsoft SQL Server-DB-Instance
Sie können Ihre Secure Sockets Layer (SSL) zum Verschlüsseln von Verbindungen zwischen Ihren Client-Anwendungen und Ihren Amazon-RDS-DB-Instances verwenden, auf denen Microsoft SQL Server ausgeführt wird. SSL-Unterstützung ist in allen AWS Regionen für alle unterstützten SQL Server-Editionen verfügbar.
Wenn Sie eine SQL Server-DB-Instance erstellen, erstellt Amazon RDS ein SSL-Zertifikat für sie. Das SSL-Zertifikat enthält den DB-Instance-Endpunkt als allgemeinen Name (Common Name CN) für das SSL-Zertifikat, um gegen Spoofing-Angriffe zu schützen.
Es gibt 2 Möglichkeiten, SSL zu verwenden, um eine Verbindung zu Ihrer SQL Server-DB-Instance zu erstellen:
+ SSL für alle Verbindungen erzwingen – erfolgt für den Kunden transparent; der Kunde muss nichts unternehmen, um SSL verwenden zu können.
**Anmerkung**
Wenn Sie `rds.force_ssl` auf `1` festlegen und SSMS-Version 19.3, 20.0 und 20.2 verwenden, überprüfen Sie Folgendes:
Aktivieren Sie das **Zertifikat des vertrauenswürdigen Servers** in SSMS.
Importieren Sie das Zertifikat in Ihr System.
+ Spezifische Verbindungen verschlüsseln – richtet eine SSL-Verbindung von einem spezifischen Client-PC ein; Sie müssen Aktionen auf dem Client ausführen, um Verbindungen zu verschlüsseln.
Weitere Informationen zur Unterstützung von Transport Layer Security (TLS) für SQL Server finden Sie unter [TLS 1.2-Support für Microsoft SQL Server](https://support.microsoft.com/en-ca/help/3135244/tls-1-2-support-for-microsoft-sql-server).
## Erzwingen von Verbindungen mit Ihrer DB-Instance, um SSL zu verwenden
Sie können festlegen, dass für alle Verbindungen zu Ihrer DB-Instance SSL verwendet werden soll. Wenn Sie Verbindungen erzwingen, um SSL zu verwenden, erfolgt dies für den Kunden transparent, der Kunde muss nichts tun, um SSL verwenden zu können.
Wenn Sie SSL erzwingen möchten, verwenden Sie den `rds.force_ssl`-Parameter. Standardmäßig ist der `rds.force_ssl`-Parameter auf `0 (off)` festgelegt. Setzen Sie den `rds.force_ssl`-Parameter auf `1 (on)`, um Verbindungen zu erzwingen und SSL zu verwenden. Der `rds.force_ssl`-Parameter ist statisch, daher müssen Sie nach dem Ändern des Werts Ihre DB-Instance neu starten, damit die Änderung übernommen wird.
**So legen Sie fest, dass für alle Verbindungen zu Ihrer DB-Instance SSL verwendet wird**
1. Bestimmen Sie die Parametergruppe, die an Ihre DB-Instance angefügt ist:
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 oberen rechten Ecke der Amazon RDS-Konsole die AWS Region Ihrer DB-Instance aus.
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** und dann den Namen Ihrer DB-Instance aus, um deren Details anzuzeigen.
1. Wählen Sie die Registerkarte **Konfiguration** aus. Suchen Sie die **Parametergruppe** im Abschnitt.
1. Falls erforderlich, erstellen Sie eine neue Parametergruppe. Falls Ihre DB-Instance die standardmäßige Parametergruppe verwendet, müssen Sie eine neue Parametergruppe erstellen. Falls Ihre DB-Instance eine nicht standardmäßige Parametergruppe verwendet, können Sie die vorhandene Parametergruppe bearbeiten oder eine neue Parametergruppe erstellen. Falls Sie eine vorhandene Parametergruppe bearbeiten, wirkt sich die Änderung auf alle DB-Instances aus, die diese Parametergruppe verwenden.
Befolgen Sie die Anweisungen in , um eine neue Parametergruppe zu erstelle [Erstellen einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Creating.md).
1. Bearbeiten Sie Ihre neue oder vorhandene Parametergruppe, um den `rds.force_ssl`-Parameter auf `true` zu setzen. Befolgen Sie die Anweisungen in , um die Parametergruppe zu bearbeite [Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
1. Falls Sie eine neue Parametergruppe erstellt haben, ändern Sie Ihre DB-Instance, um die neue Parametergruppe anzufügen. Ändern Sie die Einstellung **DB-Parametergruppe** der DB-Instance. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
1. Starten Sie Ihre DB-Instance neu. Weitere Informationen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md).
## Verschlüsseln spezifischer Verbindungen
Sie können für alle Verbindungen zu Ihrer DB-Instance erzwingen, dass sie SSL verwenden, oder nur Verbindungen von bestimmten Client-Computern verschlüsseln. Um SSL auf einem spezifischen Client zu verwenden, müssen Sie Zertifikate für den Client-Computer abrufen, die Zertifikate auf dem Client-Computer importieren und dann die Verbindungen vom Client-Computer aus verschlüsseln.
**Anmerkung**
Alle nach dem 5. August 2014 erstellten SQL Server-Instances verwenden den DB-Instance-Endpunkt im Common Name (CN)-Feld des SSL-Zertifikats. Vor dem 5. August 2014 war die Verifizierung des SSL-Zertifikats für VPC-basierte SQL Server-Instances nicht verfügbar. Falls Sie über eine VPC-basierte SQL Server-DB-Instance verfügen, die vor dem 5. August 2014 erstellt wurde, und Sie eine Verifizierung des SSL-Zertifikats verwenden möchten und sicherstellen möchten, dass der Instance-Endpunkt als CN für das SSL-Zertifikat für diese DB-Instance enthalten ist, benennen Sie die Instance um. Wenn Sie eine DB-Instance umbenennen, wird ein neues Zertifikat bereitgestellt und die Instance neu gestartet, um das neue Zertifikat zu aktivieren.
### Herunterladen von Zertifikaten für Client-Computer
Zum Verschlüsseln von Verbindungen von einem Client-Computer mit einer Amazon-RDS-DB-Instance, auf der Microsoft SQL Server ausgeführt wird, benötigen Sie ein Zertifikat auf Ihrem Client-Computer.
Laden Sie das Zertifikat auf Ihren Client-Computer herunter. Sie können ein Stammzertifikat herunterladen, das für alle Regionen funktioniert. Sie können auch ein Zertifikatpaket herunterladen, das sowohl das alte als auch das neue Stammzertifikat enthält. Zusätzlich können Sie regionsspezifische Zwischenzertifikate herunterladen. Weitere Informationen zum Herunterladen von Zertifikaten finden Sie unter [](UsingWithRDS.SSL.md).
Nach dem Herunterladen des entsprechenden Zertifikats importieren Sie es anhand der Vorgehensweise im folgenden Abschnitt in Ihr Microsoft Windows-Betriebssystem.
### Importieren von Zertifikaten auf Client-Computer
Sie können die folgende Vorgehensweise verwenden, um Ihr Zertifikat in das Microsoft Windows-Betriebssystem auf Ihrem Client-Computer zu importieren.
**So importieren Sie das Zertifikat in Ihr Windows-Betriebssystem:**
1. Geben Sie im Menü **Start** den Befehl **Run** in das Suchfeld ein und drücken Sie die **Eingabetaste**.
1. Geben Sie in das Feld **Öffnen** **MMC** ein und wählen Sie dann **OK**.
1. Wählen Sie in der MMC-Konsole im Menü **File** (Datei) die Option **Add/Remove Snap-in** (Snap-in hinzufügen/entfernen).
1. Wählen Sie im Dialogfeld **Add or Remove Snap-ins** (Snap-ins hinzufügen oder entfernen) für **Available snap-ins** (Verfügbare Snap-ins) die Option **Certificates** und dann **Hinzufügen** aus.
1. Wählen Sie im Dialogfeld **Certificates snap-in** (Snap-In-Zertifikate) die Option **Computer account** (Computerkonto) aus und klicken Sie anschließend auf **Weiter**.
1. Wählen Sie im Dialogfeld **Select Computer** (Computer auswählen) die Option **Beenden** aus.
1. Wählen Sie im Dialogfeld **Add or Remove Snap-ins** (Snap-ins hinzufügen oder entfernen) **OK** aus.
1. Erweitern Sie in der MMC-Konsole **Zertifikate**, öffnen Sie per Rechtsklick das Kontextmenü für **Trusted Root Certification Authorities** (Vertrauenswürdige Stammzertifizierungsstellen), wählen Sie **All Tasks** (Alle Aufgaben) und wählen Sie dann **Importieren**.
1. Wählen Sie auf der ersten Seite des Assistenten zum Importieren von Zertifikaten **Weiter**.
1. Wählen Sie auf der zweiten Seite des Assistenten zum Importieren von Zertifikaten **Durchsuchen**. Ändern Sie im Suchfenster den Dateityp auf **All files (\$1.\$1)** (Alle Dateien (\$1.\$1)), da PEM keine standardmäßige Zertifikatserweiterung ist. Suchen Sie die PEM-Datei, die Sie zuvor heruntergeladen haben.
**Anmerkung**
Wenn Sie eine Verbindung von Windows-Clients wie SQL Server Management Studio (SSMS) herstellen, empfehlen wir, das Zertifikatsformat PKCS \$17 (.p7b) anstelle der Datei global-bundle.pem zu verwenden. Das .p7b-Format stellt sicher, dass die gesamte Zertifikatskette — einschließlich Stamm- und Zwischenzertifizierungsstellen () — korrekt in den Windows-Zertifikatsspeicher importiert wird. CAs Dadurch werden Verbindungsfehler vermieden, die auftreten können, wenn die obligatorische Verschlüsselung aktiviert ist, da durch PEM-Importe möglicherweise nicht die gesamte Kette ordnungsgemäß installiert wird.
1. Wählen Sie **Öffnen**, um die Zertifikatdatei auszuwählen und wählen Sie dann **Weiter**.
1. Wählen Sie auf der dritten Seite des Assistenten zum Importieren von Zertifikaten **Weiter**.
1. Wählen Sie auf der vierten Seite des Assistenten zum Importieren von Zertifikaten **Beenden**. Ein Dialogfeld zeigt an, dass der Import erfolgreich war.
1. Erweitern Sie in der MMC-Konsole **Zertifikate** und **Trusted Root Certification Authorities** (Vertrauenswürdige Stammzertifizierungsstellen) und wählen Sie dann **Zertifikate**. Suchen Sie das Zertifikat, um zu bestätigen, dass es existiert, wie hier gezeigt.
![\[In der MMC-Konsole ist im Navigationsbereich der Ordner „Zertifikate“ ausgewählt, der eine Unteroptionen von „Konsolenstamm“, „Zertifikate (Lokaler Computer)“ und „Vertrauenswürdige Stammzertifizierungsstelle“ ist. Wählen Sie auf der Hauptseite das erforderliche CA-Zertifikat aus.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/rds_sql_ssl_cert.png)
### Verschlüsseln von Verbindungen mit einer Amazon-RDS-DB-Instance, die Microsoft SQL Server ausführt
Nach dem Importieren eines Zertifikats in Ihren Client-Computer können Sie Ihre Verbindungen vom Client-Computer mit einer Amazon-RDS-DB-Instance, auf der Microsoft SQL Server ausgeführt wird, verschlüsseln.
Verwenden Sie für SQL Server Management Studio die folgende Vorgehensweise. Weitere Informationen über SQL Server Management Studio finden Sie unter [SQL Server Management Studio verwenden](http://msdn.microsoft.com/en-us/library/ms174173.aspx).
**So verschlüsseln Sie Verbindungen von SQL Server Management Studio**
1. Starten Sie SQL Server Management Studio.
1. Geben Sie für **Connect to server (Mit Server verbinden)** die Serverinformationen, den Anmeldebenutzernamen und das Passwort ein.
1. Wählen Sie **Optionen** aus.
1. Wählen Sie **Encrypt connection** (Verbindungen verschlüsseln) aus.
1. Wählen Sie **Connect (Verbinden)** aus.
1. Prüfen Sie, ob Ihre Verbindung verschlüsselt ist, indem Sie die folgende Abfrage ausführen. Die Abfrage muss `true` für `encrypt_option` zurückgeben.
```
select ENCRYPT_OPTION from SYS.DM_EXEC_CONNECTIONS where SESSION_ID = @@SPID
```
Verwenden Sie für jeden anderen SQL-Client die folgende Vorgehensweise.
**So verschlüsseln Sie Verbindungen von anderen SQL-Clients**
1. Fügen Sie `encrypt=true` an Ihre Verbindungszeichenfolge an. Diese Zeichenfolge ist möglicherweise als Option oder als Eigenschaft auf der Verbindungsseite in den GUI-Tools verfügbar.
**Anmerkung**
Zum Aktivieren der SSL-Verschlüsselung für Clients, die Verbindungen mittels JDBC herstellen, müssen Sie möglicherweise das Amazon-RDS-SQL-Zertifikat zum Java CA-Zertifikat-Store (cacerts) hinzufügen. Dies erledigen Sie mithilfe des Dienstprogramms [ Keytool](http://docs.oracle.com/javase/7/docs/technotes/tools/solaris/keytool.html).
1. Prüfen Sie, ob Ihre Verbindung verschlüsselt ist, indem Sie die folgende Abfrage ausführen. Die Abfrage muss `true` für `encrypt_option` zurückgeben.
```
select ENCRYPT_OPTION from SYS.DM_EXEC_CONNECTIONS where SESSION_ID = @@SPID
```
# Konfigurieren von Sicherheitsprotokollen und Verschlüsselungen von SQL Server
Sie können bestimmte Sicherheitsprotokolle und Verschlüsselungen mithilfe von DB-Parametern ein- und ausschalten. Die Sicherheitsparameter, die Sie konfigurieren können (mit Ausnahme von TLS Version 1.2), werden in der folgenden Tabelle angezeigt.
****
| DB-Parameter | Zulässige Werte (Standardwert in Fettdruck) | Beschreibung |
| --- | --- | --- |
| rds.tls10 | Standard, aktiviert, deaktiviert | TLS 1.0. |
| rds.tls11 | Standard, aktiviert, deaktiviert | TLS 1.1. |
| rds.tls12 | default | TLS 1.2. Dieser Wert kann nicht verändert werden. |
| rds.fips | 0, 1 | Wenn Sie den Parameter auf 1 setzen, erzwingt RDS die Verwendung von Modulen, die dem 140-2-Standard Federal Information Processing Standard (FIPS) entsprechen. Weitere Informationen finden Sie unter[ Verwenden von SQL Server 2016 im FIPS 140-2-konformen Modus](https://docs.microsoft.com/en-us/troubleshoot/sql/security/sql-2016-fips-140-2-compliant-mode) in der Microsoft-Dokumentation. |
| rds.rc4 | Standard, aktiviert, deaktiviert | RC4-Stream-Verschlüsselung |
| rds.diffie-hellman | Standard, aktiviert, deaktiviert | Diffie-Hellman-Schlüsselaustausch-Verschlüsselung. |
| rds.diffie-hellman-min-key-bit-length | Standard, 1024, 2048, 3072, 4096 | Minimale Bitlänge für Diffie-Hellman-Schlüssel. |
| rds.curve25519 | Standard, aktiviert, deaktiviert | Curve25519 Verschlüsselungsverfahren mit elliptischer Kurve. Dieser Parameter wird nicht für alle Engine-Versionen unterstützt. |
| rds.3des168 | Standard, aktiviert, deaktiviert | Dreifaches DES-Verschlüsselungsverfahren (Data Encryption Standard) mit einer 168-Bit-Schlüssellänge. |
**Anmerkung**
*Für Engine-Unterversionen nach 16.00.4120.1, 15.00.4365.2, 14.00.3465.1, 13.00.6435.1 und 12.00.6449.1 ist die Standardeinstellung für die DB-Parameter `rds.tls10`, `rds.tls11`, `rds.rc4`, `rds.curve25519` und `rds.3des168` auf deaktiviert* festgelegt. Andernfalls lautet die Standardeinstellung *aktiviert*.
Für Engine-Unterversionen nach 16.00.4120.1, 15.00.4365.2, 14.00.3465.1, 13.00.6435.1 und 12.00.6449.1 ist die Standardeinstellung für `rds.diffie-hellman-min-key-bit-length` 3072. Andernfalls lautet die Standardeinstellung 2048.
Gehen Sie wie folgt vor, um die Sicherheitsprotokolle und Verschlüsselungen zu konfigurieren:
1. Erstellen Sie eine benutzerdefinierte DB-Parametergruppe.
1. Ändern Sie die Parameter in der Parametergruppe.
1. Ordnen Sie die neue DB-Parametergruppe der DB-Instance zu.
Weitere Informationen zu DB-Parametergruppen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
## Erstellen der sicherheitsbezogenen Parametergruppe
Erstellen Sie eine Parametergruppe für Ihre sicherheitsbezogenen Parameter, die der SQL Server-Edition und der Version Ihrer DB-Instance entspricht.
### Konsole
Im folgenden Verfahren wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie **Create parameter group (Parametergruppe erstellen)**.
1. Führen Sie im Bereich **Parametergruppe erstellen** die folgenden Schritte aus:
1. Wählen Sie für **Parametergruppenfamilie** die Option **sqlserver-se-13.0** aus.
1. Geben Sie unter **Gruppenname** einen Bezeichner für die Parametergruppe ein, z. B. **sqlserver-ciphers-se-13**.
1. Geben Sie für **Beschreibung** den Text **Parameter group for security protocols and ciphers** ein.
1. Wählen Sie **Erstellen** aus.
### CLI
Im folgenden Verfahren wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-parameter-group \
--db-parameter-group-name sqlserver-ciphers-se-13 \
--db-parameter-group-family "sqlserver-se-13.0" \
--description "Parameter group for security protocols and ciphers"
```
Windows:
```
aws rds create-db-parameter-group ^
--db-parameter-group-name sqlserver-ciphers-se-13 ^
--db-parameter-group-family "sqlserver-se-13.0" ^
--description "Parameter group for security protocols and ciphers"
```
## Ändern von sicherheitsbezogenen Parametern
Ändern Sie den sicherheitsbezogenen Parameter in der Parametergruppe, die der SQL Server-Edition und der Version Ihrer DB-Instance entspricht.
### Konsole
Im folgenden Verfahren wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben. In diesem Beispiel wird TLS-Version 1.0 deaktiviert.
**So ändern Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie die Parametergruppe aus, z. B. **sqlserver-ciphers-se-13**.
1. Filtern Sie unter **Parameter** die Parameterliste nach **rds**.
1. Wählen Sie **Parameter bearbeiten** aus.
1. Wählen Sie **rds.tls10** aus.
1. Wählen Sie unter **Werte** die Option **deaktiviert** aus.
1. Wählen Sie **Änderungen speichern ** aus.
### CLI
Im folgenden Verfahren wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben. In diesem Beispiel wird TLS-Version 1.0 deaktiviert.
**So ändern Sie die Parametergruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name sqlserver-ciphers-se-13 \
--parameters "ParameterName='rds.tls10',ParameterValue='disabled',ApplyMethod=pending-reboot"
```
Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name sqlserver-ciphers-se-13 ^
--parameters "ParameterName='rds.tls10',ParameterValue='disabled',ApplyMethod=pending-reboot"
```
## Zuordnen der sicherheitsbezogenen Parametergruppe zu Ihrer DB-Instance
Um die Parametergruppe Ihrer DB-Instance zuzuordnen, verwenden Sie die AWS-Managementkonsole oder die AWS CLI.
### Konsole
Sie können die Parametergruppe einer neuen oder vorhandenen DB-Instance zuordnen:
+ Bei einer neuen DB-Instance ordnen Sie diese zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Bei einer vorhandenen DB-Instance ordnen Sie diese zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### CLI
Sie können die Parametergruppe einer neuen oder einer vorhandenen DB-Instance zuordnen.
**So erstellen Sie eine DB-Instance mit der Parametergruppe**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Parametergruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 13.00.5426.0.v1 \
--allocated-storage 100 \
--master-user-password secret123 \
--master-username admin \
--storage-type gp2 \
--license-model li \
--db-parameter-group-name sqlserver-ciphers-se-13
```
Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mydbinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 13.00.5426.0.v1 ^
--allocated-storage 100 ^
--master-user-password secret123 ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--db-parameter-group-name sqlserver-ciphers-se-13
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
**So ändern Sie eine DB-Instance und ordnen die Parametergruppe zu**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--db-parameter-group-name sqlserver-ciphers-se-13 \
--apply-immediately
```
Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--db-parameter-group-name sqlserver-ciphers-se-13 ^
--apply-immediately
```
# Aktualisieren von Anwendungen für die Verbindung mit Microsoft SQL Server-DB-Instances unter Verwendung neuer SSL/TLS-Zertifikate
Am 13. Januar 2023 veröffentlichte Amazon RDS neue Zertifizierungsstellen-Zertifikate (Certificate Authority, CA) zum Herstellen von Verbindungen mit Ihren RDS-DB-Instances mithilfe von Secure Socket Layer oder Transport Layer Security (SSL/TLS). Im Folgenden finden Sie Informationen dazu, wie Sie Ihre Anwendungen aktualisieren, um die neuen Zertifikate verwenden zu können.
In diesem Thema finden Sie Informationen dazu, wie Sie ermitteln, ob Client-Anwendungen für die Herstellung von Verbindungen mit Ihren DB-Instances SSL/TLS verwenden. Wenn dies der Fall ist, können Sie weiter überprüfen, ob diese Anwendungen zur Herstellung von Verbindungen Zertifikatverifizierungen erfordern.
**Anmerkung**
Einige Anwendungen sind so konfiguriert, dass sie nur dann Verbindungen mit SQL-Server-DB-Instances herstellen, wenn sie das Zertifikat auf dem Server erfolgreich identifizieren können.
Für solche Anwendungen müssen Sie die Trust Stores Ihrer Client-Anwendung aktualisieren, damit diese die neuen CA-Zertifikate enthalten.
Nach der Aktualisierung der CA-Zertifikate in den Trust Stores Ihrer Client-Anwendung können Sie die Zertifikate auf Ihren DB-Instances rotieren. Es wird nachdrücklich empfohlen, diese Verfahren vor der Implementierung in Produktionsumgebungen in einer Entwicklungs- oder Testumgebung zu testen.
Weitere Informationen zur Zertifikatrotation finden Sie unter [Ihr SSL/TLS Zertifikat rotieren](UsingWithRDS.SSL-certificate-rotation.md). Weitere Informationen zum Herunterladen von Zertifikaten finden Sie unter [](UsingWithRDS.SSL.md). Informationen zum Verwenden von SSL/TLS mit Microsoft SQL Server-DB-Instances finden Sie unter [Verwenden von SSL mit einer Microsoft SQL Server-DB-Instance](SQLServer.Concepts.General.SSL.Using.md).
**Topics**
+ [
## Ermitteln, ob Anwendungen Verbindungen mit Ihrer Microsoft SQL Server-DB-Instance mithilfe von SSL herstellen
](#ssl-certificate-rotation-sqlserver.determining-server)
+ [
## Ermitteln, ob ein Client zum Herstellen von Verbindungen Zertifikatverifizierungen erfordert
](#ssl-certificate-rotation-sqlserver.determining-client)
+ [
## Aktualisieren des Trust Stores Ihrer Anwendung
](#ssl-certificate-rotation-sqlserver.updating-trust-store)
## Ermitteln, ob Anwendungen Verbindungen mit Ihrer Microsoft SQL Server-DB-Instance mithilfe von SSL herstellen
Prüfen Sie die DB-Instance-Konfiguration auf den Wert des Parameters `rds.force_ssl`. Standardmäßig ist der Parameter `rds.force_ssl` auf 0 (aus) festgelegt. Wenn der Parameter `rds.force_ssl` auf 1 (ein) festgelegt ist, müssen Clients SSL/TLS für Verbindungen verwenden. Weitere Informationen zu Parametergruppen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
Führen Sie die folgende Abfrage durch, um die aktuelle Verschlüsselungsoption für alle offenen Verbindungen zu einer DB-Instance zu erhalten. Die Spalte `ENCRYPT_OPTION` zeigt `TRUE`, wenn die Verbindung verschlüsselt ist.
```
select SESSION_ID,
ENCRYPT_OPTION,
NET_TRANSPORT,
AUTH_SCHEME
from SYS.DM_EXEC_CONNECTIONS
```
Diese Abfrage zeigt nur die aktuellen Verbindungen. Sie zeigt nicht, ob Anwendungen, die sich in der Vergangenheit verbunden oder getrennt haben, SSL verwendeten.
## Ermitteln, ob ein Client zum Herstellen von Verbindungen Zertifikatverifizierungen erfordert
Sie können überprüfen, ob verschiedene Arten von Clients zum Herstellen von Verbindungen Zertifikatverifizierungen erfordern.
**Anmerkung**
Wenn Sie andere als die aufgeführten Konnektoren verwenden, konsultieren Sie deren Dokumentation für Informationen zur Durchsetzung verschlüsselter Verbindungen. Weitere Informationen finden Sie unter [Verbindungsmodule für Microsoft SQL-Datenbanken](https://docs.microsoft.com/en-us/sql/connect/sql-connection-libraries?view=sql-server-ver15) in der Microsoft SQL Server-Dokumentation.
### SQL Server Management Studio
Prüfen Sie, ob die Verschlüsselung für SQL Server Management Studio-Verbindungen erzwungen wird:
1. Starten Sie SQL Server Management Studio.
1. Geben Sie für **Connect to server (Mit Server verbinden)** die Serverinformationen, den Anmeldebenutzernamen und das Passwort ein.
1. Wählen Sie **Optionen** aus.
1. Prüfen Sie, ob auf der Verbindungsseite **Encrypt connection (Verbindung verschlüsseln)** ausgewählt ist.
Weitere Informationen über SQL Server Management Studio finden Sie unter [SQL Server Management Studio verwenden](http://msdn.microsoft.com/en-us/library/ms174173.aspx).
### Sqlcmd
Das folgende Beispiel mit dem `sqlcmd`-Client zeigt, wie die SQL Server-Verbindung eines Skripts überprüft werden kann, um festzustellen, ob für erfolgreiche Verbindungen ein gültiges Zertifikat erforderlich ist. Weitere Informationen finden Sie unter [Herstellen von Verbindungen mit sqlcmd](https://docs.microsoft.com/en-us/sql/connect/odbc/linux-mac/connecting-with-sqlcmd?view=sql-server-ver15) in der Microsoft SQL Server-Dokumentation.
Bei Verwendung von `sqlcmd` erfordert eine SSL-Verbindung die Verifizierung anhand des CA-Serverzertifikats, wenn Sie zum Verschlüsseln von Verbindungen das Befehlsargument `-N` angeben wie im folgenden Beispiel gezeigt.
```
$ sqlcmd -N -S dbinstance.rds.amazon.com -d ExampleDB
```
**Anmerkung**
Wenn `sqlcmd` mit der Option `-C` aufgerufen wird, wird dem Serverzertifikat vertraut, auch wenn dieses nicht mit dem clientseitigen Trust Store übereinstimmt.
### ADO.NET
Im folgenden Beispiel stellt die Anwendung Verbindungen über SSL her und das Serverzertifikat muss verifiziert werden.
```
using SQLC = Microsoft.Data.SqlClient;
...
static public void Main()
{
using (var connection = new SQLC.SqlConnection(
"Server=tcp:dbinstance.rds.amazon.com;" +
"Database=ExampleDB;User ID=LOGIN_NAME;" +
"Password=YOUR_PASSWORD;" +
"Encrypt=True;TrustServerCertificate=False;"
))
{
connection.Open();
...
}
```
### Java
Im folgenden Beispiel stellt die Anwendung Verbindungen über SSL her und das Serverzertifikat muss verifiziert werden.
```
String connectionUrl =
"jdbc:sqlserver://dbinstance.rds.amazon.com;" +
"databaseName=ExampleDB;integratedSecurity=true;" +
"encrypt=true;trustServerCertificate=false";
```
Zum Aktivieren der SSL-Verschlüsselung für Clients, die Verbindungen über JDBC herstellen, müssen Sie dem Java CA-Zertifikatspeicher möglicherweise das Amazon RDS-Zertifikat hinzufügen. Anweisungen hierzu finden Sie unter [Konfigurieren des Clients für Verschlüsselung](https://docs.microsoft.com/en-us/SQL/connect/jdbc/configuring-the-client-for-ssl-encryption?view=sql-server-2017) in der Microsoft SQL Server-Dokumentation. Sie können den Namen der Datei für das vertrauenswürdige CA-Zertifikat auch direkt bereitstellen, indem Sie der Verbindungszeichenfolge `trustStore=path-to-certificate-trust-store-file` anfügen.
**Anmerkung**
Wenn Sie in der Verbindungszeichenfolge `TrustServerCertificate=true` (oder entsprechend) verwenden, wird im Verbindungsvorgang die Vertrauenskettenvalidierung übersprungen. In diesem Fall stellt die Anwendung Verbindungen her, auch wenn das Zertifikat nicht verifiziert werden kann. Die Verwendung von `TrustServerCertificate=false` erzwingt die Zertifikatvalidierung und stellt eine bewährte Methode dar.
## Aktualisieren des Trust Stores Ihrer Anwendung
Sie können den Trust Store für Anwendungen aktualisieren, die Microsoft SQL Server verwenden. Detaillierte Anweisungen finden Sie unter [Verschlüsseln spezifischer Verbindungen](SQLServer.Concepts.General.SSL.Using.md#SQLServer.Concepts.General.SSL.Client). Anweisungen hierzu finden Sie auch unter [Konfigurieren des Clients für Verschlüsselung](https://docs.microsoft.com/en-us/SQL/connect/jdbc/configuring-the-client-for-ssl-encryption?view=sql-server-2017) in der Microsoft SQL Server-Dokumentation.
Wenn Sie ein anderes Betriebssystem als Microsoft Windows verwenden, finden Sie in der Dokumentation der Softwarebverteilung zur SSL/TLS-Implementierung Informationen dazu, wie Sie ein neues CA-Stammzertifikat hinzufügen. OpenSSL und GnuTLS sind Beispiele für verbreitete Optionen. Wenden Sie die Implementierungsmethode an, um das RDS-CA-Stammzertifikat als vertrauenswürdig anzugeben. Microsoft stellt Anweisungen zum Konfigurieren von Zertifikaten auf bestimmten Systemen bereit.
Informationen zum Herunterladen des Stammverzeichnisses finden Sie unter [](UsingWithRDS.SSL.md).
Beispiele für Skripte, die Zertifikate importieren, finden Sie unter [Beispielskript für den Import von Zertifikaten in Ihren Trust Store](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-sample-script).
**Anmerkung**
Wenn Sie den Trust Store aktualisieren, können Sie ältere Zertifikate beibehalten und die neuen Zertifikate einfach hinzufügen.
## Unterstützung zu Compliance-Programmen für Microsoft SQL Server-DB-Instances
AWS Die im Leistungsumfang enthaltenen Dienstleistungen wurden von einem externen Prüfer umfassend bewertet und führen zu einer Zertifizierung, Konformitätsbescheinigung oder Authority to Operate (ATO). Weitere Informationen finden Sie unter[AWS -Services im Rahmen des Compliance-Programms](https://aws.amazon.com/compliance/services-in-scope/).
### HIPAA-Unterstützung für Microsoft SQL Server-DB-Instances
Sie können Amazon RDS für Microsoft SQL Server-Datenbanken für die Erstellung von HIPAA-kompatiblen Anwendungen verwenden. Mit können Sie Gesundheitsdaten, darunter geschützte patientenbezogene Daten (protected health information, PHI), im Rahmen eines Geschäftspartnervertrags (Business Associate Agreement, BAA) speicher AWS. Weitere Informationen finden Sie unter [HIPAA-Compliance](https://aws.amazon.com/compliance/hipaa-compliance/).
Amazon RDS für SQL Server unterstützt HIPAA für folgende Versionen und Editions:
+ SQL Server 2022 Enterprise, Standard und Web Editionen
+ SQL Server 2019 Enterprise-, Standard- und Web-Editionen
+ SQL Server 2017 Enterprise-, Standard- und Web-Editionen
+ SQL Server 2016 Enterprise-, Standard- und Web-Editionen
Um die HIPAA-Unterstützung auf Ihrer DB-Instance zu aktivieren, richten Sie folgende drei Komponenten ein.
****
| Komponente | Details |
| --- | --- |
| Prüfung | Um eine Prüfung einzurichten, legen Sie den Parameter `rds.sqlserver_audit` auf den Wert `fedramp_hipaa` fest. Wenn Ihre DB-Instance noch keine benutzerdefinierte DB-Parametergruppe verwendet, müssen Sie eine benutzerdefinierte Parametergruppe erstellen und diese an Ihre DB-Instance anfügen, bevor Sie den Parameter `rds.sqlserver_audit` bearbeiten. Weitere Informationen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md). |
| Transportverschlüsselung | Um eine Transportverschlüsselung einzurichten, müssen alle Verbindungen mit Ihrer DB-Instance über Secure Sockets Layer (SSL) erfolgen. Weitere Informationen finden Sie unter [Erzwingen von Verbindungen mit Ihrer DB-Instance, um SSL zu verwenden](SQLServer.Concepts.General.SSL.Using.md#SQLServer.Concepts.General.SSL.Forcing). |
| Verschlüsselung im Ruhezustand | Es gibt zwei Möglichkeiten, die Verschlüsselung im Ruhezustand einzurichten: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html) |
# Microsoft SQL Server-Versionen auf Amazon RDS
Sie können eine beliebige aktuell unterstützte Microsoft SQL Server-Version festlegen, wenn Sie eine DB-Instance erstellen. Sie können die Microsoft SQL Server-Hauptversionen (wie z. B. Microsoft SQL Server 14.00) sowie eine beliebige Unterversion für die angegebene Hauptversion festlegen. Wenn keine Version angegeben wird, verwendet Amazon RDS standardmäßig eine unterstützte Version - in der Regel die aktuelle Version. Wenn die Hauptversion, jedoch nicht die Unterversion, festgelegt ist, verwendet Amazon RDS standardmäßig den letzten Release der Hauptversion, die Sie festgelegt haben.
Die folgende Tabelle zeigt die unterstützten SQL-Server-Versionen für alle Editionen und AWS -Regionen, sofern nicht anders angegeben.
**Anmerkung**
Sie können den [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) AWS CLI Befehl auch verwenden, um eine Liste der unterstützten Versionen sowie die Standardeinstellungen für neu erstellte DB-Instances anzuzeigen. Sie können die Hauptversionen Ihrer SQL Server-Datenbanken anzeigen, indem Sie den AWS CLI Befehl [describe-db-major-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-major-engine-versions.html) ausführen oder den API-Vorgang [Describe DBMajor EngineVersions](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBMajorEngineVersions.html) RDS verwenden.
| Hauptversion | Unterversion | RDS API `EngineVersion` und CLI `engine-version` |
| --- | --- | --- |
| SQL Server 2022 | 16.00.4236.2 () CU23 16,00.4230,2 (DDRCU22 ) 16,00.4225,2 (CU22) 16,00,4215,2 () CU21 16,00.4210,1 (DDRCU20 ) 16,00.4205,1 CU20 () 16,00,4195,2 (CU19) 16,00,4185,3 () CU18 16,00,4175,1 () CU17 16,00,4165,4 () CU16 16,00,4150,1 () CU15 16,00.4140,3 (DDRCU14 ) 16,00.4135,4 (CU14) 16,00,4131,2 () CU13 16,00,4125,3 () CU13 16,00.4120.1 (DDRCU12 ) 16,00.4115,5 (CU12) 16,00,4105,2 () CU11 16,00,4095,4 (CU10) 16,00,4085,2 () CU9 | `16.00.4236.2.v1` `16.00.4230.2.v1` `16.00.4225.2.v1` `16.00.4215.2.v1` `16.00.4210.1.v1` `16.00.4205.1.v1` `16.00.4195.2.v1` `16.00.4185.3.v1` `16.00.4175.1.v1` `16.00.4165.4.v1` `16.00.4150.1.v1` `16.00.4140.3.v1` `16.00.4135.4.v1` `16.00.4131.2.v1` `16.00.4125.3.v1` `16.00.4120.1.v1` `16.00.4115.5.v1` `16.00.4105.2.v1` `16.00.4095.4.v1` `16.00.4085.2.v1` |
| SQL Server 2019 | 15,00.4455,2 (DDRCU32 ) 15,00.4445,1 (CU32 DDR) 15,00.4440,1 (CU32 DDR) 15,00.4435,7 (CU32) 15,00,4430,1 () CU32 15,00,4420,2 () CU31 15,00,4415,2 () CU30 15,00.4410,1 (DDRCU29 ) 15,00.4395,2 CU28 () 15,00,4390,2 () CU28 15,00,4385,2 () CU28 15,00,4382,1 () CU27 15,00,4375,4 () CU27 15,00,4365,2 () CU26 15,00,4355,3 () CU25 15,00,4345,5 () CU24 15,00,4335,1 () CU23 15,00,4322,2 () CU22 15,00,4316,3 () CU21 15,00,4312,2 () CU20 15,00,4236,7 () CU16 15,00,4198,2 () CU15 15,00,4153,1 () CU12 15,00,4073,23 () CU8 15,00,4043,16 () CU5 | `15.00.4455.2.v1` `15.00.4445.1.v1` `15.00.4440.1.v1` `15.00.4435.7.v1` `15.00.4430.1.v1` `15.00.4420.2.v1` `15.00.4415.2.v1` `15.00.4410.1.v1` `15.00.4395.2.v1` `15.00.4390.2.v1` `15.00.4385.2.v1` `15.00.4382.1.v1` `15.00.4375.4.v1` `15.00.4365.2.v1` `15.00.4355.3.v1` `15.00.4345.5.v1` `15.00.4335.1.v1` `15.00.4322.2.v1` `15.00.4316.3.v1` `15.00.4312.2.v1` `15.00.4236.7.v1` `15.00.4198.2.v1` `15.00.4153.1.v1` `15.00.4073.23.v1` `15.00.4043.16.v1` |
| SQL Server 2017 | 14,00.3515,1 (DDRCU31 ) 14,00.3505,1 (CU31 DDR) 14,00.3500.1. (DDR) CU31 14.00.3495,9 (DDR) CU31 14,00.3485,1 (CU31 DDR) 14,00.3480,1 (CU31) 14,00.3475,1 () CU31 14,00.3471,2 () CU31 14,00.3465,1 () CU31 14,00,3460,9 () CU31 14,00.3451,2 () CU30 14,00.3421,10 () CU27 14,00.3401,7 () CU25 14,00,3381,3 (CU23) 14,00.3356,20 () CU22 14,00,3294,2 () CU20 14,00.3281,6 () CU19 | `14.00.3515.1.v1` `14.00.3505.1.v1` `14.00.3500.1.v1` `14.00.3495.9.v1` `14.00.3485.1.v1` `14.00.3480.1.v1` `14.00.3475.1.v1` `14.00.3471.2.v1` `14.00.3465.1.v1` `14.00.3460.9.v1` `14.00.3451.2.v1` `14.00.3421.10.v1` `14.00.3401.7.v1` `14.00.3381.3.v1` `14.00.3356.20.v1` `14.00.3294.2.v1` `14.00.3281.6.v1` |
| SQL Server 2016 | 13,00.6475,1 (GR) 13.00.6470.1 (DDR) 13.00.6465.1 (GDR) 13,00.6460,7 (DDR) 13.00.6455.2 (GDR) 13.00.6450.1 (DDR) 13.00.6445.1 (GDR) 13.00.6441.1 (DDR) 13.00.6435.1 (GDR) 13.00.6430.49 (GDR) 13.00.6419.1 (\$1 Hotfix) SP3 13.00.6300.2 SP3 () | `14.00.6475.1.v1` `14.00.6470.1.v1` `13.00.6465.1.v1` `13.00.6460.7.v1` `13.00.6455.2.v1` `13.00.6450.1.v1` `13.00.6445.1.v1` `13.00.6441.1.v1` `13.00.6435.1.v1` `13.00.6430.49.v1` `13.00.6419.1.v1` `13.00.6300.2.v1` |
## Versionsverwaltung in Amazon RDS
Amazon RDS beinhaltet flexibles Versionsmanagement, mit dem Sie steuern können, wann und wie die Ihre DB-Instance gepatcht oder aktualisiert wird. Dadurch können Sie Folgendes für Ihre DB-Engine durchführen:
+ Aufrechterhalten der Kompatibilität mit Datenbank-Engine-Patch-Versionen.
+ Testen neuer Patch-Versionen, um zu prüfen, ob Sie mit Ihrer Anwendung funktionieren, bevor Sie sie in der Produktion bereitstellen.
+ Planen und Ausführen von Versions-Upgrades, um Ihre Service Level Agreements und zeitlichen Anforderungen zu erfüllen.
### Microsoft SQL Server-Engine-Patching in Amazon RDS
Amazon RDS aggregiert regelmäßig offizielle Microsoft SQL Server-Datenbank-Patches in einer Version der DB-Instance-Engine, die für Amazon RDS spezifisch ist. Weitere Informationen über Microsoft SQL Server-Patches in jeder Version der Engine finden Sie unter [Versions- und Funktionsunterstützung in Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.FeatureSupport).
Derzeit können Sie alle Engine-Upgrades auf Ihrer DB-Instance manuell durchführen. Weitere Informationen finden Sie unter [Upgrades der DB-Engine von Microsoft SQL Server](USER_UpgradeDBInstance.SQLServer.md).
### Einstellungszeitplan für Engine-Hauptversionen von Microsoft SQL Server auf Amazon RDS
Die folgende Tabelle zeigt den geplanten Einstellungszeitplan für Engine-Hauptversionen von Microsoft SQL Server an.
| Date | Informationen |
| --- | --- |
| 14. Juli 2026 | Microsoft wird wichtige Patch-Updates für SQL Server 2016 einstellen. Weitere Informationen finden Sie in der [Microsoft-Dokumentation unter Microsoft SQL Server 2016](https://learn.microsoft.com/en-us/lifecycle/products/sql-server-2016). |
| 14. Juli 2026 | Amazon RDS plant, die Unterstützung von Microsoft SQL Server 2016 auf RDS for SQL Server einzustellen. Zu diesem Zeitpunkt wird die Migration aller verbleibenden Instances auf SQL Server 2017 (neueste verfügbare Nebenversion) geplant. Weitere Informationen finden Sie unter [Ankündigung: Amazon RDS for SQL Server beendet die Unterstützung für Microsoft SQL Server 2016](https://repost.aws/articles/ARGkeWligDSU-MQgBwUQj0nA/announcement-amazon-rds-for-sql-server-ending-support-for-microsoft-sql-server-2016). Um ein automatisches Upgrade von Microsoft SQL Server 2016 zu vermeiden, können Sie das Upgrade zu einem für Sie günstigen Zeitpunkt durchführen. Weitere Informationen finden Sie unter [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md). |
| 15. Januar 2026 | Amazon RDS beginnt, die Erstellung neuer RDS für SQL Server-DB-Instances mithilfe von Microsoft SQL Server 2016 zu deaktivieren. Weitere Informationen finden Sie unter [Ankündigung: Amazon RDS for SQL Server beendet die Unterstützung für Microsoft SQL Server 2016](https://repost.aws/articles/ARGkeWligDSU-MQgBwUQj0nA/announcement-amazon-rds-for-sql-server-ending-support-for-microsoft-sql-server-2016). |
| 9. Juli 2024 | Microsoft stellt kritische Patch-Updates für SQL Server 2014 ein. Weitere Informationen finden Sie unter [Microsoft SQL Server 2014](https://learn.microsoft.com/en-us/lifecycle/products/sql-server-2014) in der Microsoft-Dokumentation. |
| 1. Juni 2024 | Amazon RDS plant, die Unterstützung von Microsoft SQL Server 2014 in RDS für SQL Server zu beenden. Zu diesem Zeitpunkt wird geplant, dass alle verbleibenden Instances zu SQL Server 2016 migrieren (neueste verfügbare Unterversion). Weitere Informationen finden Sie unter [Ankündigung: Ende der Unterstützung für die Hauptversionen von Amazon RDS für SQL Server 2014](https://repost.aws/articles/AR-eyAH1PSSuevuZRUE9FV3A). Um ein automatisches Upgrade von Microsoft SQL Server 2014 zu vermeiden, können Sie ein Upgrade zu einem für Sie geeigneten Zeitpunkt durchführen. Weitere Informationen finden Sie unter [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md). |
| 12. Juli 2022 | Microsoft stellt kritische Patch-Updates für SQL Server 2012 ein. Weitere Informationen finden Sie unter [Microsoft SQL Server 2012](https://docs.microsoft.com/en-us/lifecycle/products/microsoft-sql-server-2012) in der Microsoft-Dokumentation. |
| 1. Juni 2022 | Amazon RDS plant, die Unterstützung von Microsoft SQL Server 2012 auf RDS für SQL Server zu beenden. Zu diesem Zeitpunkt wird geplant, dass alle verbleibenden Instances auf SQL Server 2014 migrieren (neueste verfügbare Unterversion). Weitere Informationen finden Sie unter [Ankündigung: Ende der Unterstützung für die Hauptversionen von Amazon RDS für SQL Server 2012](https://repost.aws/questions/QUFNiETqrMQ_WT_AXSxOYNOA). Um ein automatisches Upgrade von Microsoft SQL Server 2012 zu vermeiden, können Sie zu einem für Sie geeigneten Zeitpunkt upgraden. Weitere Informationen finden Sie unter [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md). |
| 1. September 2021 | Amazon RDS beginnt, die Erstellung neuer RDS für SQL Server DB-Instances mithilfe von Microsoft SQL Server 2012 zu deaktivieren. Weitere Informationen finden Sie unter [Ankündigung: Ende der Unterstützung für die Hauptversionen von Amazon RDS für SQL Server 2012](https://repost.aws/questions/QUFNiETqrMQ_WT_AXSxOYNOA). |
| 12. Juli 2019 | Das Amazon-RDS-Team hat die Unterstützung für Microsoft SQL Server 2008 R2 im Juni 2019 beendet. Verbleibende Instances mit Microsoft SQL Server 2008 R2 migrieren auf SQL Server 2012 (neueste Minor-Version verfügbar). Um ein automatisches Upgrade von Microsoft SQL Server 2008 R2 zu vermeiden, können Sie zu einem für Sie geeigneten Zeitpunkt upgraden. Weitere Informationen finden Sie unter [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md). |
| 25. April 2019 | Vor Ende April 2019 können Sie keine neuen Amazon RDS für SQL Server-Datenbank-Instances mehr erstellen, die SQL Server 2008 R2 verwenden. |
# Microsoft SQL Server-Funktionen auf Amazon RDS
Die unterstützten SQL Server-Versionen auf Amazon RDS enthalten die folgenden Funktionen. Im Allgemeinen enthält eine Version auch Funktionen aus den vorherigen Versionen, sofern in der Microsoft-Dokumentation nichts anderes angegeben ist.
**Topics**
+ [
## Funktionen von Microsoft SQL Server 2022
](#SQLServer.Concepts.General.FeatureSupport.2022)
+ [
## Funktionen von Microsoft SQL Server 2019
](#SQLServer.Concepts.General.FeatureSupport.2019)
+ [
## Funktionen von Microsoft SQL Server 2017
](#SQLServer.Concepts.General.FeatureSupport.2017)
+ [
## Funktionen von Microsoft SQL Server 2016
](#SQLServer.Concepts.General.FeatureSupport.2016)
+ [
## Ende der Unterstützung von Microsoft SQL Server 2014 in Amazon RDS
](#SQLServer.Concepts.General.FeatureSupport.2014)
+ [
## Microsoft SQL Server 2012 Ende der Unterstützung für Amazon RDS
](#SQLServer.Concepts.General.FeatureSupport.2012)
+ [
## Microsoft SQL Server 2008 R2 Ende der Unterstützung auf Amazon RDS
](#SQLServer.Concepts.General.FeatureSupport.2008)
+ [
# Unterstützung der Erfassung von Datenänderungen (Change Data Capture) für Microsoft SQL Server DB-Instances.
](SQLServer.Concepts.General.CDC.md)
+ [
# Nicht unterstützte Funktionen und Funktionen mit beschränkter Unterstützung
](SQLServer.Concepts.General.FeatureNonSupport.md)
## Funktionen von Microsoft SQL Server 2022
SQL Server 2022 enthält viele neue Funktionen, z. B. die folgenden:
+ Parametersensitive Planoptimierung: Ermöglicht mehrere zwischengespeicherte Pläne für eine einzelne parametrisierte Anweisung, wodurch möglicherweise Probleme beim Parameter-Sniffing reduziert werden.
+ SQL Server Ledger: Bietet die Möglichkeit, kryptografisch nachzuweisen, dass Ihre Daten nicht ohne Genehmigung geändert wurden.
+ Sofortige Dateiinitialisierung bei Wachstumsereignissen in Transaktionsprotokolldateien: Resultiert in einer schnelleren Ausführung von Protokollwachstumsereignissen bis zu 64 MB, auch für Datenbanken mit aktiviertem TDE.
+ Verbesserungen bei der Parallelität von Systemseiten-Latch: Reduziert Seiten-Latch-Konflikte beim Zuweisen und Aufheben der Zuweisung von Datenseiten und Datenerweiterungen und sorgt so für erhebliche Leistungsverbesserungen bei hohen `tempdb`-Workloads.
Eine vollständige Liste der Funktionen von SQL Server 2022 finden Sie unter [Was ist neu in SQL Server 2022 (16.x)?](https://learn.microsoft.com/en-us/sql/sql-server/what-s-new-in-sql-server-2022?view=sql-server-ver16) in der Microsoft-Dokumentation.
Eine Liste der nicht unterstützten Funktionen finden Sie unter [Nicht unterstützte Funktionen und Funktionen mit beschränkter Unterstützung](SQLServer.Concepts.General.FeatureNonSupport.md).
## Funktionen von Microsoft SQL Server 2019
SQL Server 2019 enthält viele neue Funktionen, z. B. die folgenden:
+ Beschleunigte Datenbankwiederherstellung (ADR) – reduziert die Wiederherstellungszeit bei Abstürzen nach einem Neustart oder einem Langzeit-Transaktions-Rollback.
+ Intelligente Abfrageverarbeitung (IQP):
+ Berechtigungs-Feedback im Zeilenmodus – korrigiert übermäßige Berechtigungen, die andernfalls zu verschwendetem Speicher und reduzierter Parallelität führen würden, automatisch.
+ Stapelmodus im Zeilenspeicher – aktiviert die Ausführung des Stapelmodus für analytische Workloads ohne Spaltenspeicher-Indizes.
+ Durch Tabellenvariable verzögerte Kompilierung – verbessert die Planqualität und die Gesamtleistung für Abfragen, bei denen Tabellenvariablen verwiesen werden.
+ Intelligente Leistung:
+ `OPTIMIZE_FOR_SEQUENTIAL_KEY` Indexoption – verbessert den Durchsatz für Einfügungen mit hoher Parallelität in Indizes.
+ Verbesserte Skalierbarkeit für indirekte Prüfpunkte – hilft Datenbanken mit hohen DML-Workloads.
+ PFS (Concurrent Page Free Space)-Aktualisierungen – aktiviert die Verarbeitung als freigegebener Latch und nicht als exklusiver Latch.
+ Überwachen von Verbesserungen:
+ `WAIT_ON_SYNC_STATISTICS_REFRESH` Wait-Typ – zeigt die kumulierte Zeit auf Instance-Ebene an, die mit synchrone Statistikaktualisierungsvorgänge benötigt wird.
+ Konfigurationen des Datenbankbereichs – umfassen `LIGHTWEIGHT_QUERY_PROFILING` und `LAST_QUERY_PLAN_STATS`.
+ Dynamische Verwaltungsfunktionen (DMFs) — Einschließlich `sys.dm_exec_query_plan_stats` und`sys.dm_db_page_info`.
+ Ausführliche Kürzungswarnungen – die Fehlermeldung bei Datenkürzung enthält standardmäßig Tabellen- und Spaltennamen sowie den gekürzten Wert.
+ Fortsetzbare Online-Indexerstellung – in SQL Server 2017 wird nur die fortsetzbare Online-Indexneuerstellung unterstützt.
Eine vollständige Liste der Funktionen von SQL Server 2019 finden Sie unter [Was ist neu in SQL Server 2019 (15.x)?](https://docs.microsoft.com/en-us/sql/sql-server/what-s-new-in-sql-server-ver15) in der Microsoft-Dokumentation.
Eine Liste der nicht unterstützten Funktionen finden Sie unter [Nicht unterstützte Funktionen und Funktionen mit beschränkter Unterstützung](SQLServer.Concepts.General.FeatureNonSupport.md).
## Funktionen von Microsoft SQL Server 2017
SQL Server 2017 enthält viele neue Funktionen, z. B. die folgenden:
+ Adaptive Abfrageverarbeitung
+ Automatische Plankorrektur (eine automatische Optimierungsfunktion)
+ GraphDB
+ Fortsetzbare Index-Umbauten
Eine vollständige Liste der Funktionen von SQL Server 2017 finden Sie unter [Was ist neu in SQL Server 2017?](https://docs.microsoft.com/en-us/sql/sql-server/what-s-new-in-sql-server-2017) in der Microsoft-Dokumentation.
Eine Liste der nicht unterstützten Funktionen finden Sie unter [Nicht unterstützte Funktionen und Funktionen mit beschränkter Unterstützung](SQLServer.Concepts.General.FeatureNonSupport.md).
## Funktionen von Microsoft SQL Server 2016
Amazon RDS unterstützt die folgenden Funktionen von SQL Server 2016:
+ „Always Encrypted“
+ JSON-Unterstützung
+ Betriebsanalysen
+ Abfragespeicher
+ Temporäre Tabellen
Eine vollständige Liste der Funktionen von SQL Server 2016 finden Sie unter [Was ist neu in SQL Server 2016?](https://docs.microsoft.com/en-us/sql/sql-server/what-s-new-in-sql-server-2016) in der Microsoft-Dokumentation.
## Ende der Unterstützung von Microsoft SQL Server 2014 in Amazon RDS
SQL Server 2014 hat das Ende der Unterstützung in Amazon RDS erreicht.
RDS aktualisiert alle vorhandenen DB-Instances, die noch SQL Server 2014 verwenden, auf die neueste Unterversion von SQL Server 2016. Weitere Informationen finden Sie unter [Versionsverwaltung in Amazon RDS](SQLServer.Concepts.General.VersionSupport.md#SQLServer.Concepts.General.Version-Management).
## Microsoft SQL Server 2012 Ende der Unterstützung für Amazon RDS
SQL Server 2012 hat das Ende der Unterstützung für Amazon RDS erreicht.
RDS aktualisiert alle vorhandenen DB-Instances, die noch SQL Server 2012 verwenden, auf die neueste Unterversion von SQL Server 2016. Weitere Informationen finden Sie unter [Versionsverwaltung in Amazon RDS](SQLServer.Concepts.General.VersionSupport.md#SQLServer.Concepts.General.Version-Management).
## Microsoft SQL Server 2008 R2 Ende der Unterstützung auf Amazon RDS
SQL Server 2008 R2 hat sein Support-Ende auf Amazon RDS erreicht.
RDS aktualisiert alle vorhandenen DB-Instances, die noch SQL Server 2008 R2 verwenden, auf die neueste Unterversion von SQL Server 2012. Weitere Informationen finden Sie unter [Versionsverwaltung in Amazon RDS](SQLServer.Concepts.General.VersionSupport.md#SQLServer.Concepts.General.Version-Management).
# Unterstützung der Erfassung von Datenänderungen (Change Data Capture) für Microsoft SQL Server DB-Instances.
Amazon RDS unterstützt auch die Erfassung von Datenänderungen (Change Data Capture, CDC) für Ihre DB-Instances, die auf Microsoft SQL Server laufen. CDC erfasst Änderungen an Daten in Ihren Tabellen und speichert Metadaten über jede Änderung, auf die Sie später zugreifen können. Weitere Informationen finden Sie unter [Change Data Capture](https://docs.microsoft.com/en-us/sql/relational-databases/track-changes/track-data-changes-sql-server#Capture) in der Microsoft-Dokumentation.
Amazon RDS unterstützt CDC für die folgenden SQL Server-Editionen und -Versionen:
+ Microsoft SQL Server Enterprise Edition (alle Versionen)
+ Microsoft SQL Server Standard Edition:
+ 2022
+ 2019
+ 2017
+ 2016 Version 13.00.4422.0 SP1 CU2 und höher
Um CDC für Ihre Amazon RDS DB-Instances zu verwenden, aktivieren oder deaktivieren Sie CDC zunächst auf Datenbankebene unter Verwendung der von RDS bereitgestellten gespeicherten Prozeduren. Anschließend kann jeder Benutzer, der die `db_owner`-Rolle für diese Datenbank besitzt, die gespeicherten Prozeduren von Microsoft verwenden, um CDC für diese Datenbank zu kontrollieren. Weitere Informationen finden Sie unter [Verwenden von Change Data Capture für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.CDC.md).
Sie können CDC und AWS Database Migration Service verwenden, um eine stetige Replikation von SQL Server DB-Instances zu aktivieren.
# Nicht unterstützte Funktionen und Funktionen mit beschränkter Unterstützung
Die folgenden Microsoft SQL Server-Funktionen werden in Amazon RDS nicht unterstützt:
+ Sichern in Microsoft Azure Blob Storage
+ Erweiterung des Puffer-Pools
+ Richtlinien für benutzerdefinierte Kennwörter
+ Data Quality Services
+ Datenbank-Protokollversand
+ Datenbank-Snapshots (Amazon RDS unterstützt nur DB-Instance-Snapshots)
+ Erweiterte gespeicherte Prozeduren, einschließlich xp\$1cmdshell
+ FILESTREAM-Unterstützung
+ Datenbanktabellen
+ Machine Learning and R Services (erfordert für die Installation Betriebssystemzugriff)
+ Wartungspläne
+ Performance-Datenauflister
+ Richtlinienbasierte Verwaltung
+ PolyBase
+ Replikation
+ Auslöser auf Serverebene
+ Service Broker-Endpunkte
+ Stretch-Datenbank
+ TRUSTWORTHY-Datenbankeigenschaft (erfordert eine Sysadmin-Rolle)
+ T-SQL-Endpunkte (alle Vorgänge, die CREATE ENDPOINT verwenden, sind nicht verfügbar)
+ WCF Data Services
Die folgenden Microsoft SQL Server-Funktionen werden in Amazon RDS nur begrenzt unterstützt:
+ Verteilte queries/linked Server. Weitere Informationen finden Sie unter [Implementieren von Verbindungsservern mit Amazon RDS für Microsoft SQL Server](https://aws.amazon.com/blogs/database/implement-linked-servers-with-amazon-rds-for-microsoft-sql-server/).
+ Common Runtime Language (CLR). Auf RDS für SQL Server 2016 und niedrigeren Versionen wird CLR in`SAFE`-Modus und nur mit Assembly-Bits. CLR wird auf RDS für SQL Server 2017 und höhere Versionen nicht unterstützt. Weitere Informationen finden Sie unter[Integration von Common Runtime Language](https://docs.microsoft.com/en-us/sql/relational-databases/clr-integration/common-language-runtime-integration-overview)in der Microsoft-Dokumentation.
+ Mit Oracle OLEDB verknüpfte Server in Amazon RDS für SQL Server. Weitere Informationen finden Sie unter [Support für mit Oracle OLEDB verknüpfte Server in Amazon RDS für SQL Server](Appendix.SQLServer.Options.LinkedServers_Oracle_OLEDB.md).
Die folgenden Funktionen werden in Amazon RDS für SQL Server 2022 nicht unterstützt:
+ Sperren einer Datenbank für einen Snapshot
+ Externe Datenquelle
+ Backup und Wiederherstellung auf S3-kompatiblem Objektspeicher
+ Integration des Objektspeichers
+ TLS 1.3 und MS-TDS 8.0
+ Offloading der Backup-Komprimierung mit QAT
+ SQL Server Analysis Services (SSAS)
+ Datenbankspiegelung mit Multi-AZ-Bereitstellungen. SQL Server Always On ist die einzige unterstützte Methode mit Multi-AZ-Bereitstellungen.
## Multi-AZ-Bereitstellungen, die die Microsoft SQL Server-Datenbankspiegelung oder AlwaysOn-Verfügbarkeitsgruppen verwenden
Amazon RDS unterstützt Multi-AZ-Bereitstellungen für DB-Instances, auf denen Microsoft SQL Server ausgeführt wird, mithilfe von SQL Server Database Mirroring (DBM) oder Always On Availability Groups (). AGs Multi-AZ-Bereitstellungen bieten eine erhöhte Verfügbarkeit, eine längere Lebensdauer von Daten sowie eine höhere Fehlertoleranz für DB-Instances. Im Falle einer geplanten Datenbankwartung oder einer ungeplanten Serviceunterbrechung schaltet Amazon RDS automatisch auf das up-to-date sekundäre Replikat um, sodass der Datenbankbetrieb schnell und ohne manuelles Eingreifen wieder aufgenommen werden kann. Die primären und sekundären Instances verwenden denselben Endpunkt, dessen physische Netzwerkadresse als Teil des Failoverprozesses an das passive sekundäre Replikat übergeben wird. Sie müssen Ihre Anwendung nicht neu konfigurieren, wenn ein Failover auftritt.
Amazon RDS verwaltet das Failover durch aktive Überwachung Ihrer Multi-AZ-Bereitstellung und Initiierung eines Failovers, wenn ein Problem mit Ihrer Primär-Instance auftritt. Failover treten nicht auf, wenn Standby- und Primär-Instance vollständig synchron sind. Amazon RDS verwaltet Ihre Multi-AZ-Bereitstellung aktiv durch automatisches Reparieren instabiler DB-Instances und erneutes Einrichten einer synchronen Replikation. Sie müssen nichts verwalten. Amazon RDS wickelt die Primär-Instance, den Zeugen und die Standby-Instance für Sie ab. Wenn Sie SQL Server Multi-AZ einrichten, konfiguriert RDS passive sekundäre Instances für alle Datenbanken auf der Instance.
Weitere Informationen finden Sie unter [Multi-AZ-Bereitstellungen für Amazon RDS für Microsoft SQL Server](USER_SQLServerMultiAZ.md).
## Verwenden von Transparent Data Encryption zur Verschlüsselung ruhender Daten
Amazon RDS unterstützt Microsoft SQL Server Transparent Data Encryption (TDE), die gespeicherte Daten transparent verschlüsselt. Amazon RDS verwendet Optionsgruppen, um diese Funktionen zu aktivieren und zu konfigurieren. Weitere Informationen zur Option TDE finden Sie unter [Unterstützung für transparente Datenverschlüsselung in SQL Server](Appendix.SQLServer.Options.TDE.md).
# Funktionen und gespeicherte Prozeduren für Amazon RDS für Microsoft SQL Server
Die folgenden Liste enthält Amazon-RDS-Funktionen und gespeicherte Prozeduren, mit denen SQL-Server-Aufgaben automatisiert werden können.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.StoredProcedures.html)
# Lokale Zeitzone für Microsoft SQL Server-DB-Instances
Die Zeitzone für eine Amazon RDS-MySQL-DB-Instance, die Microsoft SQL Server ausführt, wird standardmäßig eingestellt. Der aktuelle Standard ist Universal Coordinated Time (UTC). Sie können die Zeitzone für Ihre DB-Instance stattdessen auf eine lokale Zeitzone einstellen, damit sie mit der Zeitzone Ihrer Anwendungen übereinstimmt.
Sie legen die Zeitzone bei der Erstellung Ihrer DB-Instance fest. Sie können Ihre DB-Instance mithilfe der [AWS-Managementkonsole](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html), der Amazon-RDS-API-Aktion [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html.html) oder über den AWS CLI-Befehl [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) erstellen.
Wenn Ihre DB-Instance Teil einer Multi-AZ-Bereitstellung (mittels der SQL Server Datenbankspiegelung oder Verfügbarkeitsgruppen) ist, bleibt Ihre Zeitzone bei einem Failover auf die lokale Zeitzone eingestellt, die Sie festgelegt haben. Weitere Informationen finden Sie unter [Multi-AZ-Bereitstellungen, die die Microsoft SQL Server-Datenbankspiegelung oder AlwaysOn-Verfügbarkeitsgruppen verwenden](CHAP_SQLServer.md#SQLServer.Concepts.General.Mirroring).
Wenn Sie eine zeitpunktbezogene Wiederherstellung anfordern, geben Sie den Wiederherstellungszeitpunkt an. Die Uhrzeit wird in Ihrer lokalen Zeitzone angezeigt. Weitere Informationen finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).
Folgende Beschränkungen gelten beim Festlegen der lokalen Zeitzone für Ihre DB-Instance:
+ Sie können die Zeitzone einer bestehenden SQL Server DB-Instance nicht ändern.
+ Sie können einen Snapshot aus einer DB-Instance in einer Zeitzone nicht in eine DB-Instance in einer anderen Zeitzone wiederherstellen.
+ Es wird dringend davon abgeraten, eine Sicherungsdatei aus einer Zeitzone für eine andere Zeitzone wiederherzustellen. Wenn Sie eine Sicherungsdatei aus einer Zeitzone in einer anderen Zeitzone wiederherstellen, müssen Sie Ihre Abfragen und Anwendungen auf Auswirkungen durch die Zeitzonenänderung überprüfen. Weitere Informationen finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
## Unterstützte Zeitzonen
Sie können Ihre lokale Zeitzone auf einen der in der folgenden Tabelle gelisteten Werte einstellen.
| Zeitzone | Standardzeit-Versatz | Beschreibung | Hinweise |
| --- | --- | --- | --- |
| Afghanistan Standardzeit | (UTC\$104:30) | Kabul | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Alaska Standardzeit | (UTC–09:00) | Alaska | |
| Aleuten Normalzeit | (UTC–10:00) | Aleuten-Inseln | |
| Altai Normalzeit | (UTC\$107:00) | Barnaul, Gorno-Altaisk | |
| Arabische Normalzeit | (UTC\$103:00) | Kuwait, Riad | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Arabische Standardzeit | (UTC\$104:00) | Abu Dhabi, Muscat | |
| Arabische Normalzeit | (UTC\$103:00) | Bagdad | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Argentinien Normalzeit | (UTC–03:00) | Buenos Aires Stadt | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Astrachan Normalzeit | (UTC\$104:00) | Astrachan, Uljanowsk | |
| Atlantik Standardzeit | (UTC–04:00) | Atlantic Time (Kanada) | |
| AUS Central Standard Time | (UTC\$109:30) | Darwin | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Zentralaustralische Normalzeit | (UTC\$108:45) | Eucla | |
| AUS Ost Standardzeit | (UTC\$110:00) | Canberra, Melbourne, Sydney | |
| Aserbaidschan Normalzeit | (UTC\$104:00) | Baku | |
| Azoren Normalzeit | (UTC–01:00) | Azoren | |
| Bahia Normalzeit | (UTC–03:00) | Salvador | |
| Bangladesch Normalzeit | (UTC\$106:00) | Dhaka | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Belarus Standardzeit | (UTC\$103:00) | Minsk | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Bougainville Normalzeit | (UTC\$111:00) | Bougainville-Insel | |
| Canada Central Standard Time | (UTC–06:00) | Saskatchewan | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Kap Verde Standardzeit | (UTC–01:00) | Kapverdische Inseln | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Kaukasus Normalzeit | (UTC\$104:00) | Eriwan | |
| Cen. Australia Standard Time | (UTC\$109:30) | Adelaide | |
| Mittelamerikanische Standardzeit | (UTC–06:00) | Mittelamerika | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Zentralasiatische Standardzeit | (UTC\$106:00) | Astana | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Central Brazilian Standard Time | (UTC–04:00) | Cuiaba | |
| Mitteleuropäische Standardzeit | (UTC\$101:00) | Belgrad, Bratislava, Budapest, Ljubljana, Prag | |
| Mitteleuropäische Standardzeit | (UTC\$101:00) | Sarajevo, Skopje, Warschau, Zagreb | |
| Zentralpazifische Standardzeit | (UTC\$111:00) | Salomon-Inseln, Neukaledonien | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Central Standard Time | (UTC–06:00) | Central Time (USA und Kanada) | |
| Central Standard Time (Mexiko) | (UTC–06:00) | Guadalajara, Mexiko-Stadt, Monterrey | |
| Chatham-Inseln Normalzeit | (UTC\$112:45) | Chatham-Inseln | |
| China Standardzeit | (UTC\$108:00) | Beijing, Chongqing, Hongkong, Urumqi | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Kuba Normalzeit | (UTC–05:00) | Havanna | |
| Datumsgrenze, Normalzeit | (UTC–12:00) | Internationale Datumsgrenze West | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| O. Afrikanische Standardzeit | (UTC\$103:00) | Nairobi | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| O. Australia Standard Time | (UTC\$110:00) | Brisbane | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| O. Europäische Standardzeit | (UTC\$102:00) | Chisinau | |
| O. Südamerikanische Standardzeit | (UTC–03:00) | Brasilia | |
| Osterinsel Normalzeit | (UTC–06:00) | Osterinsel | |
| Ost Standardzeit | (UTC–05:00) | Ostküstenzeit (USA und Kanada) | |
| Östliche Normalzeit (Mexiko) | (UTC–05:00) | Chetumal | |
| Ägypten Normalzeit | (UTC\$102:00) | Kairo | |
| Jekaterinburg Normalzeit | (UTC\$105:00) | Jekaterinburg | |
| Fidschi Normalzeit | (UTC\$112:00) | Fidschi | |
| Finnland Normalzeit | (UTC\$102:00) | Helsinki, Kiew, Riga, Sofia, Tallinn, Wilna | |
| Georgien Standardzeit | (UTC\$104:00) | Tiflis | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| GMT Standardzeit | (UTC) | Dublin, Edinburgh, Lissabon, London | Diese Zeitzone ist nicht dieselbe wie Greenwich Mean Time. Diese Zeitzone berücksichtigt die Sommerzeit. |
| Grönland Standardzeit | (UTC–03:00) | Grönland | |
| Greenwich Standardzeit | (UTC) | Monrovia, Reykjavik | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| GTB Standardzeit | (UTC\$102:00) | Athen, Bukarest | |
| Haiti Normalzeit | (UTC–05:00) | Haiti | |
| Hawaii Standardzeit | (UTC–10:00) | Hawaii | |
| Indien Standardzeit | (UTC\$105:30) | Chennai, Kolkata, Mumbai, Neu-Delhi | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Iran Normalzeit | (UTC\$103:30) | Teheran | |
| Israel Normalzeit | (UTC\$102:00) | Jerusalem | |
| Jordanien Standardzeit | (UTC\$102:00) | Amman | |
| Kaliningrad Normalzeit | (UTC\$102:00) | Kaliningrad | |
| Kamtschatka Normalzeit | (UTC\$112:00) | Petropawlowsk-Kamtschatski – Alt | |
| Korea Standardzeit | (UTC\$109:00) | Seoul | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Libyen Normalzeit | (UTC\$102:00) | Tripolis | |
| Linieninseln Normalzeit | (UTC\$114:00) | Kiritimati-Insel | |
| Lord Howe Normalzeit | (UTC\$110:30) | Lord-Howe-Insel | |
| Magadan Normalzeit | (UTC\$111:00) | Magadan | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Magallan Normalzeit | (UTC–03:00) | Punta Arenas | |
| Marquesas Normalzeit | (UTC–09:30) | Marquesas-Inseln | |
| Mauritius Normalzeit | (UTC\$104:00) | Port Louis | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Mittlerer Osten Standardzeit | (UTC\$102:00) | Beirut | |
| Montevideo Normalzeit | (UTC–03:00) | Montevideo | |
| Marokko Normalzeit | (UTC\$101:00) | Casablanca | |
| Mountain Standard Time | (UTC–07:00) | Mountain Time (USA und Kanada) | |
| Mountain Standard Time (Mexiko) | (UTC–07:00) | Chihuahua, La Paz, Mazatlan | |
| Myanmar Normalzeit | (UTC\$106:30) | Yangon (Rangun) | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| N. Zentralasiatische Standardzeit | (UTC\$107:00) | Nowosibirsk | |
| Namibia Normalzeit | (UTC\$102:00) | Windhuk | |
| Nepal Normalzeit | (UTC\$105:45) | Kathmandu | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Neuseeland Standardzeit | (UTC\$112:00) | Auckland, Wellington | |
| Neufundland Standardzeit | (UTC–03:30) | Neufundland | |
| Norfolk Normalzeit | (UTC\$111:00) | Norfolkinsel | |
| Ost-Nordasiatische Normalzeit | (UTC\$108:00) | Irkutsk | |
| Nordasien Normalzeit | (UTC\$107:00) | Krasnojarsk | |
| Nordkorea Normalzeit | (UTC\$109:00) | Pjöngjang | |
| Omsk Normalzeit | (UTC\$106:00) | Omsk | |
| Pacific SA Standard Time | (UTC–03:00) | Santiago | |
| Pacific Standard Time | (UTC–08:00) | Pacific Time (USA und Kanada) | |
| Pacific Standard Time (Mexiko) | (UTC–08:00) | Baja California | |
| Pakistan Normalzeit | (UTC\$105:00) | Islamabad, Karatschi | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Paraguay Normalzeit | (UTC–04:00) | Asunción | |
| Romanische Normalzeit | (UTC\$101:00) | Brüssel, Kopenhagen, Madrid, Paris | |
| Russland Zeitzone 10 | (UTC\$111:00) | Tschokurdach | |
| Russland Zeitzone 11 | (UTC\$112:00) | Anadyr, Petropawlowsk-Kamtschatski | |
| Russland Zeitzone 3 | (UTC\$104:00) | Ischewsk, Samara | |
| Russische Standardzeit | (UTC\$103:00) | Moskau, St. Petersburg, Wolgograd | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Östl. Südamerika Normalzeit | (UTC–03:00) | Cayenne, Fortaleza | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| SA Pacific Standard Time | (UTC–05:00) | Bogota, Lima, Quito, Rio Branco | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Mittl. Südamerika Normalzeit | (UTC–04:00) | Georgetown, La Paz, Manaus, San Juan | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Saint Pierre Normalzeit | (UTC–03:00) | St. Pierre und Miquelon | |
| Sachalin Normalzeit | (UTC\$111:00) | Sachalin | |
| Samoa Normalzeit | (UTC\$113:00) | Samoa | |
| São Tomé Normalzeit | (UTC\$101:00) | São Tomé | |
| Saratow Normalzeit | (UTC\$104:00) | Saratow | |
| Südostasiatische Standardzeit | (UTC\$107:00) | Bangkok, Hanoi, Jakarta | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Singapur Standardzeit | (UTC\$108:00) | Kuala Lumpur, Singapur | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Südafrika Normalzeit | (UTC\$102:00) | Harare, Pretoria | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Sri Lanka Normalzeit | (UTC\$105:30) | Sri Jayawardenepura | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Sudan Normalzeit | (UTC\$102:00) | Khartum | |
| Syrien Normalzeit | (UTC\$102:00) | Damaskus | |
| Taipei Normalzeit | (UTC\$108:00) | Taipeh | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Tasmanien Normalzeit | (UTC\$110:00) | Hobart | |
| Tocantins Normalzeit | (UTC–03:00) | Araguaina | |
| Japanische Standardzeit | (UTC\$109:00) | Osaka, Sapporo, Tokio | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Tomsk Normalzeit | (UTC\$107:00) | Tomsk | |
| Tonga Normalzeit | (UTC\$113:00) | Nuku'alofa | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Transbaikal Normalzeit | (UTC\$109:00) | Tschita | |
| Türkei Normalzeit | (UTC\$103:00) | Istanbul | |
| Turks- und Caicosinseln Normalzeit | (UTC–05:00) | Turks- und Caicosinseln | |
| Ulan-Bator Normalzeit | (UTC\$108:00) | Ulan-Bator | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| US Eastern Standard Time | (UTC–05:00) | Indiana (Osten) | |
| US Mountain Standard Time | (UTC–07:00) | Arizona | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| UTC | UTC | Coordinated Universal Time | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| UTC–02 | (UTC–02:00) | Coordinated Universal Time–02 | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| UTC–08 | (UTC–08:00) | Coordinated Universal Time–08 | |
| UTC–09 | (UTC–09:00) | Coordinated Universal Time–09 | |
| UTC–11 | (UTC–11:00) | Coordinated Universal Time–11 | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| UTC\$112 | (UTC\$112:00) | Coordinated Universal Time\$112 | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| UTC\$113 | (UTC\$113:00) | Koordinierte Weltzeit\$113 | |
| Venezuela Normalzeit | (UTC–04:00) | Caracas | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Wladiwostok Normalzeit | (UTC\$110:00) | Wladiwostok | |
| Wolgograd Normalzeit | (UTC\$104:00) | Wolgograd | |
| W. Australia Standard Time | (UTC\$108:00) | Perth | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| W. Zentralafrikanische Standardzeit | (UTC\$101:00) | West-Zentralafrika | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| W. Europäische Standardzeit | (UTC\$101:00) | Amsterdam, Berlin, Bern, Rom, Stockholm, Wien | |
| W. Mongolei Normalzeit | (UTC\$107:00) | Hovd | |
| Westasien Normalzeit | (UTC\$105:00) | Aschgabat, Taschkent | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Westjordanland Normalzeit | (UTC\$102:00) | Gaza, Hebron | |
| Westpazifische Normalzeit | (UTC\$110:00) | Guam, Port Moresby | Diese Zeitzone berücksichtigt keine Sommerzeit. |
| Jakutsk Normalzeit | (UTC\$109:00) | Jakutsk | |
# Lizenzierung Microsoft SQL Server auf Amazon RDS
Beim Einrichten einer Amazon-RDS-DB-Instance für Microsoft SQL Server ist die Software-Lizenz enthalten.
Das bedeutet, dass Sie SQL Server-Lizenzen nicht separat erwerben müssen. AWS besitzt die Lizenz für die SQL Server-Datenbanksoftware. Amazon-RDS-Preise beinhalten die Softwarelizenz, die unterliegenden Hardware-Ressourcen sowie die Amazon-RDS-Verwaltungsfunktionen.
Amazon RDS unterstützt die folgenden Microsoft SQL Server-Editionen:
+ Enterprise
+ Standard
+ Web
+ Express
**Anmerkung**
SQL Server Web Edition wurde für Webhoster und Web entwickelt, VAPs um öffentliche und über das Internet zugängliche Webseiten, Websites, Webanwendungen und Webdienste zu hosten. Dieser Support-Umfang ist erforderlich, um den Nutzungsrechten von Microsoft zu entsprechen. Weitere Informationen finden Sie unter [AWS Servicebedingungen](https://aws.amazon.com/serviceterms).
Amazon RDS unterstützt Multi-AZ-Bereitstellungen für DB-Instances, auf denen Microsoft SQL Server ausgeführt wird, mithilfe von SQL Server Database Mirroring (DBM), Always On Availability Groups (AGs) und Replikation auf Blockebene für SQL Server Web Edition. Es bestehen keine weiteren Lizenzanforderungen für Multi-AZ-Bereitstellungen. Weitere Informationen finden Sie unter [Multi-AZ-Bereitstellungen für Amazon RDS für Microsoft SQL Server](USER_SQLServerMultiAZ.md).
## Wiederherstellen von DB-Instances, die aus Lizenzgründen beendet wurden
Amazon RDS erstellt Snapshots von DB-Instances, die aus Lizenzgründen beendet wurden. Wenn Ihre Instance aus Lizenzgründen beendet wurde, können Sie sie vom Snapshot in einer neuen DB-Instance wiederherstellen. Neue DB-Instances enthalten eine Lizenz.
Weitere Informationen finden Sie unter [Wiederherstellen von DB-Instances für Amazon RDS für SQL Server, die aus Lizenzgründen beendet wurden](Appendix.SQLServer.CommonDBATasks.RestoreLTI.md).
## Entwicklung und Test
Für Entwicklungs- und Testszenarien können Sie Express Edition für viele Entwicklungs-, Test- und andere Anforderungen außerhalb der Produktion verwenden. Sie können auch die Developer Edition verwenden, die alle Funktionen der SQL Server Enterprise Edition enthält, jedoch nur für den Einsatz außerhalb der Produktion lizenziert ist. Sie können die SQL Server Developer Edition auf RDS für SQL Server herunterladen und installieren. Weitere Informationen finden Sie unter [Arbeiten mit SQL Server Developer Edition auf RDS für SQL Server](sqlserver-dev-edition.md) Verwenden einer Custom Engine Version (CEV) mit Bring Your Own Media (BYOM). Auf dieselbe Weise können Sie auch die SQL Server Developer Edition auf RDS Custom for SQL Server herunterladen und installieren. Weitere Informationen finden Sie unter [Vorbereitung einer CEV mit Bring Your Own Media (BYOM)](custom-cev-sqlserver.preparing.md#custom-cev-sqlserver.preparing.byom). Weitere Informationen zu den Unterschieden zwischen SQL Server-Editionen finden Sie unter [Editionen und unterstützte Funktionen von SQL Server 2019](https://learn.microsoft.com/en-us/sql/sql-server/editions-and-components-of-sql-server-2019?view=sql-server-ver15) in der Microsoft-Dokumentation.
# Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server
Nachdem Amazon RDS Ihre DB-Instance bereitgestellt hat, können Sie die Verbindung zu dieser über eine beliebige Standard-SQL-Clientanwendung herstellen. In diesem Thema wird beschrieben, wie Sie mithilfe von Microsoft SQL Server Management Studio (SSMS) oder SQL Workbench/J die Verbindung zur DB-Instance herstellen.
Ein Beispiel mit einer Anleitung zum Erstellen und Verbinden für eine Beispiel-DB-Instance finden Sie unter [Erstellen einer DB-Instance von Microsoft SQL Server und Herstellen einer Verbindung](CHAP_GettingStarted.CreatingConnecting.SQLServer.md).
## Bevor Sie sich verbinden
Bevor Sie eine Verbindung zu Ihrer DB-Instance herstellen können, muss diese verfügbar und zugänglich sein.
1. Stellen Sie sicher, dass der Status laute `available`. Sie können dies auf der Detailseite für Ihre Instance im AWS-Managementkonsole oder überprüfen, indem Sie den [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) AWS CLI Befehl verwenden.
![\[Stellen Sie sicher, dass die DB-Instance verfügbar ist\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/sqlserver-available.png)
1. Stellen Sie sicher, dass sie für Ihre Quelle zugänglich ist. Abhängig von Ihrem Szenario muss sie möglicherweise nicht öffentlich zugänglich sein. Weitere Informationen finden Sie unter [Amazon VPC und Amazon RDS](USER_VPC.md).
1. Stellen Sie sicher, dass die eingehenden Regeln Ihrer VPC-Sicherheitsgruppe den Zugriff auf Ihre DB-Instance ermöglichen. Weitere Informationen finden Sie unter [Verbindung zur Amazon-RDS-DB-Instance kann nicht hergestellt werden](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
## Finden des Endpunkts und der Portnummer der DB-Instance
Sie benötigen sowohl den Endpunkt als auch die Portnummer, um die Verbindung zur DB-Instance herzustellen.
**So finden Sie den Endpunkt und den Port**
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 oberen rechten Ecke der Amazon RDS-Konsole die AWS Region Ihrer DB-Instance aus.
1. Suchen Sie den DNS-Namen (Domain Name System) (Endpunkt) und die Portnummer für Ihre DB-Instance:
1. Öffnen Sie die RDS-Konsole und wählen Sie **Databases (Datenbanken)** aus, um eine Liste Ihrer DB-Instances anzeigen zu lassen.
1. Wählen Sie den Namen der SQL Server-DB-Instance, um deren Details anzuzeigen.
1. Kopieren Sie auf der Registerkarte **Connectivity & security (Anbindung und Sicherheit)** den Endpunkt.
![\[Lokalisieren des Endpunkts und Ports einer DB-Instance\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQL-Connect-Endpoint.png)
1. Notieren Sie sich auch die Portnummer.
# Herstellen einer Verbindung zu Ihrer DB-Instance mit Microsoft SQL Server Management Studio
In diesem Verfahren stellen Sie mithilfe von Microsoft SQL Server Management Studio (SSMS) eine Verbindung zu Ihrer Beispiel-DB-Instance her. Eine eigenständige Version dieses Dienstprogramms zum Herunterladen finden Sie unter [SQL Server Management Studio (SSMS) herunterladen](https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) in der Microsoft-Dokumentation.
**So stellen Sie eine Verbindung zu einer DB-Instance mithilfe von SSMS her**
1. Starten Sie SQL Server Management Studio.
Das Dialogfeld **Connect to Server** (Mit Server verbinden) erscheint.
![\[Dialog "Mit Server verbinden"\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/RDSMSFTSQLConnect01.png)
1. Geben Sie die Informationen für Ihre DB-Instance an:
1. Wählen Sie für **Servertyp** die Option **Datenbank-Engine** aus.
1. Geben Sie für **Server name (Servername)** den DNS-Namen (Endpunkt) und die Portnummer für Ihre DB-Instance durch Komma getrennt an.
**Wichtig**
Ändern Sie den Doppelpunkt zwischen dem Endpunkt und der Portnummer in ein Komma.
Ihr Servername sollte wie im folgenden Beispiel aussehen.
```
database-2.cg034itsfake.us-east-1.rds.amazonaws.com,1433
```
1. Wählen Sie für **Authentifizierung** die Option **SQL Server-Authentifizierung** aus.
1. Geben Sie unter **Login (Anmeldename)** den Hauptbenutzernamen für Ihre DB-Instance ein.
1. Geben Sie unter **Password (Passwort)** das Passwort für Ihre DB-Instance ein.
1. Wählen Sie **Connect (Verbinden)** aus.
Nach wenigen Augenblicken stellt SSMS die Verbindung zur DB-Instance her.
Weitere Informationen für den Fall, dass keine Verbindung zur DB-Instance hergestellt werden kann, finden Sie unter [Überlegungen zu Sicherheitsgruppen](USER_ConnectToMicrosoftSQLServerInstance.Security.md) und [Fehlerbehebung bei Verbindungen mit Ihrer SQL Server-DB-Instance](USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting.md).
1. Ihre SQL Server-DB-Instance verfügt über integrierte Standard-Systemdatenbanken von SQL Server (`master`, `model`, `msdb`und `tempdb`). Führen Sie folgende Schritte aus, um die Systemdatenbanken zu durchforschen:
1. Wählen Sie in SSMS im Menü **Ansicht** die Option **Objekt-Explorer** aus.
1. Erweitern Sie die DB-Instance und dann **Datenbanken** und **Systemdatenbanken**.
![\[Objekt-Explorer zeigt die Systemdatenbanken an\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQL-SSMS-SystemDBs.png)
1. Ihre SQL-Server-DB-Instance kommt auch mit einer Datenbank namens `rdsadmin`. Amazon RDS verwendet diese Datenbank, um die Objekte für die Datenbankverwaltung zu speichern. Die Datenbank `rdsadmin` beinhaltet auch gespeicherte Prozeduren, die Sie ausführen können, um erweiterte Aufgaben durchzuführen. Weitere Informationen finden Sie unter [Häufige DBA-Aufgaben für Amazon RDS für Microsoft SQL Server](Appendix.SQLServer.CommonDBATasks.md).
1. Sie können nun wie üblich beginnen Ihre eigenen Datenbanken zu erstellen und Abfragen gegen Ihre DB-Instance und Datenbanken auszuführen. Gehen Sie wie folgt vor, um eine Testabfrage für die DB-Instance auszuführen:
1. Wählen Sie in SSMS im Menü **Datei** die Option **Neu** aus und wählen Sie anschließend **Abfrage mit bestehender Verbindung** aus.
1. Geben Sie die folgende SQL-Abfrage ein.
```
select @@VERSION
```
1. Führen Sie die Abfrage aus. SSMS gibt die SQL Server-Version Ihrer Amazon RDS-DB-Instance zurück.
![\[SQL-Abfragefenster\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQL-Connect-Query.png)
# Herstellen einer Verbindung zu Ihrer DB-Instance mit SQL Workbench/J
In diesem Beispiel wird gezeigt, wie Sie mithilfe des SQL Workbench/J-Datenbanktools eine Verbindung zu einer DB-Instance in der Microsoft SQL Server-Datenbank-Engine herstellen. Sie können SQL Workbench/J unter [SQL Workbench/J](http://www.sql-workbench.net/) herunterladen.
SQL Workbench/J verwendet JDBC, um eine Verbindung zur DB-Instance herzustellen. Sie benötigen auch den JDBC-Treiber für SQL Server. Sie können diesen Treiber unter [Download Microsoft JDBC Driver for SQL Server](https://learn.microsoft.com/en-us/sql/connect/jdbc/download-microsoft-jdbc-driver-for-sql-server?view=sql-server-ver16) herunterladen.
**So stellen Sie eine Verbindung zu einer DB-Instance mithilfe von SQL Workbench/J her**
1. Open-SQL-Workbench/J. Das Dialogfeld **Select Connection Profile (Verbindungsprofil auswählen)** wird wie folgt angezeigt.
![\[Dialogfeld "Select Connection Profile" (Verbindungsprofil auswählen)\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/workbench_profile.png)
1. Geben Sie im ersten Feld oben im Dialogfeld einen Namen für das Profil an.
1. Wählen Sie bei **Driver (Treiber)** die Option **SQL JDBC 4.0** aus.
1. Geben Sie unter **URL** **jdbc:sqlserver://** gefolgt vom Endpunkt Ihrer DB-Instance ein. Der URL-Wert könnte beispielsweise wie folgt lauten.
```
jdbc:sqlserver://sqlsvr-pdz.abcd12340.us-west-2.rds.amazonaws.com:1433
```
1. Geben Sie unter **Username (Benutzername)** den Hauptbenutzernamen der DB-Instance ein.
1. Geben Sie unter **Password (Passwort)** das Passwort für den Hauptbenutzer ein.
1. Wählen Sie in der Symbolleiste des Dialogfelds wie folgt das Speichersymbol aus.
![\[Speichern des Profils\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/save_example.png)
1. Klicken Sie auf **OK**. Nach wenigen Augenblicken stellt SQL Workbench/J die Verbindung zur DB-Instance her. Weitere Informationen für den Fall, dass keine Verbindung zur DB-Instance hergestellt werden kann, finden Sie unter [Überlegungen zu Sicherheitsgruppen](USER_ConnectToMicrosoftSQLServerInstance.Security.md) und [Fehlerbehebung bei Verbindungen mit Ihrer SQL Server-DB-Instance](USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting.md).
1. Geben Sie im Abfragebereich die folgende SQL-Abfrage ein.
```
select @@VERSION
```
1. Wählen Sie in der Symbolleiste wie folgt das Ausführungssymbol `Execute` aus.
![\[Run the query\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/execute_example.png)
Die Abfrage gibt wie nachfolgend angezeigt die Versionsinformation für Ihre DB-Instance zurück.
```
Microsoft SQL Server 2017 (RTM-CU22) (KB4577467) - 14.0.3356.20 (X64)
```
# Überlegungen zu Sicherheitsgruppen
Um eine Verbindung zu Ihrer DB-Instance herzustellen, muss Ihre DB-Instance einer Sicherheitsgruppe zugeordnet sein. Diese Sicherheitsgruppe enthält die IP-Adressen und die Netzwerkkonfiguration, die Sie für den Zugriff auf die DB-Instance verwenden. Sie haben der DB-Instance möglicherweise bereits direkt beim Erstellen eine geeignete Sicherheitsgruppe zugeordnet. Falls Sie beim Erstellen Ihrer DB-Instance eine standardmäßige, nicht konfigurierte Sicherheitsgruppe zugeordnet haben, verhindert die Firewall Ihrer DB-Instance jeglichen Verbindungsversuch.
In einigen Fällen müssen Sie möglicherweise eine neue Sicherheitsgruppe erstellen, um den Zugriff zu ermöglichen. Anweisungen zum Erstellen einer neuen Sicherheitsgruppe finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md). Ein Thema mit einer schrittweisen Anleitung zum Einrichten von Regeln für Ihre VPC-Sicherheitsgruppe finden Sie unter [Tutorial: Eine VPC zur Verwendung mit einem erstellen (IPv4 nur)](CHAP_Tutorials.WebServerDB.CreateVPC.md).
Nachdem Sie die neue Sicherheitsgruppe erstellt haben, ändern Sie Ihre DB-Instance, um ihr die Sicherheitsgruppe zuzuordnen. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
Sie können die Sicherheitsstufe mithilfe von SSL erhöhen, um Verbindungen zu Ihrer DB-Instance zu verschlüsseln. Weitere Informationen finden Sie unter [Verwenden von SSL mit einer Microsoft SQL Server-DB-Instance](SQLServer.Concepts.General.SSL.Using.md).
# Fehlerbehebung bei Verbindungen mit Ihrer SQL Server-DB-Instance
Die folgende Tabelle zeigt Fehlermeldungen, die möglicherweise auftreten, wenn Sie versuchen, eine Verbindung mit Ihrer SQL Server-DB-Instance herzustellen.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting.html)
**Anmerkung**
Weitere Informationen zu Verbindungsproblemen finden Sie unter [Verbindung zur Amazon-RDS-DB-Instance kann nicht hergestellt werden](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
# Arbeiten mit SQL Server Developer Edition auf RDS für SQL Server
RDS für SQL Server unterstützt die SQL Server Developer Edition. Die Developer Edition umfasst alle Funktionen der SQL Server Enterprise Edition, ist jedoch nur für den Einsatz außerhalb der Produktion lizenziert. Mithilfe der CEV-Funktion (Custom Engine Version) können Sie RDS-Instanzen für SQL Server Developer Edition mit Ihren eigenen Installationsmedien erstellen.
## Vorteile
Sie können RDS for SQL Server Developer Edition verwenden, um:
+ Niedrigere Kosten in Entwicklungs- und Testumgebungen bei gleichzeitiger Beibehaltung der Funktionsparität mit Produktionsdatenbanken.
+ Greifen Sie in Umgebungen außerhalb der Produktionsumgebung auf Funktionen der Enterprise Edition zu, ohne dass Lizenzgebühren für Unternehmen anfallen.
+ Verwenden Sie die automatisierten Verwaltungsfunktionen von Amazon RDS, einschließlich Backups, Patches und Überwachung.
**Anmerkung**
Die SQL Server Developer Edition ist nur für Entwicklungs- und Testzwecke lizenziert und kann nicht in Produktionsumgebungen verwendet werden.
## Verfügbarkeit in Regionen
RDS for SQL Server Developer Edition ist in den folgenden AWS Regionen verfügbar:
+ USA Ost (Nord-Virginia)
+ USA Ost (Ohio)
+ USA West (Oregon)
+ USA West (Nordkalifornien)
+ Asien-Pazifik (Mumbai)
+ Asia Pacific (Seoul)
+ Asien-Pazifik (Singapur)
+ Asien-Pazifik (Osaka)
+ Asien-Pazifik (Sydney)
+ Asien-Pazifik (Tokio)
+ Europa (Irland)
+ Europa (Frankfurt)
+ Europa (London)
+ Europa (Stockholm)
+ Europa (Paris)
+ Kanada (Zentral)
+ Südamerika (São Paulo)
+ Afrika (Kapstadt)
## Lizenzierung und Nutzung
Die SQL Server Developer Edition wird von Microsoft nur für Entwicklungs- und Testumgebungen lizenziert. Sie können die Developer Edition nicht als Produktionsserver verwenden. Wenn Sie SQL Server Developer Edition auf Amazon RDS verwenden, sind Sie für die Einhaltung der Lizenzbedingungen für die SQL Server Developer Edition von Microsoft verantwortlich. Sie zahlen nur für die AWS Infrastrukturkosten — es fallen keine zusätzlichen Lizenzgebühren für SQL Server an. Preisdetails finden Sie unter [Preise für RDS for SQL Server](https://aws.amazon.com/rds/sqlserver/pricing/).
## Voraussetzungen
Bevor Sie SQL Server Developer Edition auf RDS für SQL Server verwenden, stellen Sie sicher, dass Sie die folgenden Anforderungen erfüllen:
+ Sie müssen die Installationsbinärdateien direkt von Microsoft beziehen und sicherstellen, dass die Lizenzbedingungen von Microsoft eingehalten werden.
+ Sie benötigen Zugriff auf die folgenden Ressourcen, um eine Developer Edition-DB-Instance zu erstellen:
+ AWS Konto mit `AmazonRDSFullAccess` und `s3:GetObject` Berechtigungen.
+ Zum Speichern von Installationsmedien ist ein Amazon S3 S3-Bucket erforderlich. Sie benötigen eine ISO-Datei und eine kumulative Aktualisierungsdatei, um sie im Rahmen der CEV-Erstellung in den Amazon S3 S3-Bucket hochzuladen. Weitere Informationen finden Sie unter [Installationsmedien in einen Amazon S3 S3-Bucket hochladen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html).
+ Alle Installationsmediendateien müssen sich in demselben Amazon S3 S3-Bucket und demselben Ordnerpfad innerhalb dieses Amazon S3 S3-Buckets in derselben Region befinden, in der die benutzerdefinierte Engine-Version erstellt wurde.
### Unterstützte Versionen
Die Developer Edition auf RDS für SQL Server unterstützt die folgenden Versionen:
+ SQL Server 2022 CU 21 (16.00.4215.2)
+ SQL Server 2019 CU32 DDR (15.00.4455.2)
Verwenden Sie den folgenden Befehl, um alle unterstützten Engine-Versionen für die CEV-Erstellung in der Developer Edition aufzulisten: AWS CLI
```
aws rds describe-db-engine-versions --engine sqlserver-dev-ee --output json --query "{DBEngineVersions: DBEngineVersions[?Status=='requires-custom-engine-version'].{Engine: Engine, EngineVersion: EngineVersion, Status: Status, DBEngineVersionDescription: DBEngineVersionDescription}}"
```
Der Befehl gibt eine Ausgabe zurück, die dem folgenden Beispiel ähnelt:
```
{
"DBEngineVersions": [
{
"Engine": "sqlserver-dev-ee",
"EngineVersion": "16.00.4215.2.v1",
"Status": "requires-custom-engine-version",
"DBEngineDescription": "Microsoft SQL Server Enterprise Developer Edition",
"DBEngineVersionDescription": "SQL Server 2022 16.00.4215.2.v1"
}
]
}
```
Der Engine-Versionsstatus `requires_custom_engine_version` gibt die unterstützten Template-Engine-Versionen an. Diese Vorlagen zeigen, welche SQL Server-Versionen Sie importieren können.
## Einschränkungen
Die folgenden Einschränkungen gelten für die SQL Server Developer Edition auf Amazon RDS:
+ Wird derzeit nur für die Instance-Klassen M6i und R6i unterstützt.
+ Multi-AZ-Bereitstellungen und Read Replicas werden nicht unterstützt.
+ Sie müssen Ihre eigenen SQL Server-Installationsmedien bereitstellen und verwalten.
+ Benutzerdefinierte Engine-Versionen für SQL Server Developer Edition (sqlserver-dev-ee) können nicht region- oder kontoübergreifend gemeinsam genutzt werden.
# Vorbereiten eines CEV für RDS für SQL Server
## Voraussetzungen
Bevor Sie eine benutzerdefinierte Engine-Version erstellen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllt haben:
### Bereiten Sie die Installationsmedien für SQL Server Developer Edition vor
Sie müssen das Installationsmedium für die SQL Server Developer Edition von Microsoft beziehen und es für den Upload auf S3 vorbereiten.
**So laden Sie Installationsmedien von Microsoft herunter**
1. **Option A:** Verwenden Sie Ihr [Visual Studio-Abonnement](https://visualstudio.microsoft.com/subscriptions/), um die Developer Edition ISO herunterzuladen. Nur die englische Version wird unterstützt.
1. **Option B: Verwenden des SQL Server-Installationsprogramms**
1. Laden Sie das [Installationsprogramm für SQL Server Developer Edition](https://download.microsoft.com/download/c/c/9/cc9c6797-383c-4b24-8920-dc057c1de9d3/SQL2022-SSEI-Dev.exe) herunter.
1. Führen Sie das Installationsprogramm aus und wählen Sie „**Medien herunterladen**“, um die vollständige ISO-Datei herunterzuladen.
1. Wählen Sie **Englisch** als bevorzugte Sprache.
1. Wählen Sie **ISO** als Medientyp.
1. Wählen Sie **Herunterladen** aus.
**Um kumulative Updates herunterzuladen**
1. Besuchen Sie die [Microsoft Catalog Update-Seite](https://www.catalog.update.microsoft.com/Home.aspx).
1. Suchen Sie nach einer SQL Server Developer Edition, die von RDS für SQL Server unterstützt wird, zum Beispiel „SQL Server 2022 Cumulative Update“.
1. Laden Sie die neueste unterstützte ausführbare CU-Datei herunter und speichern Sie sie auf Ihrem Computer.
1. Beispieldateien: `SQLServer2022-KB5065865-x64.exe` (CU21 für SQL Server 2022)
**Wichtig**
RDS für SQL Server unterstützt nur bestimmte Cumulative Update (CU) -Versionen. Sie müssen genau die Version verwenden, die in der folgenden Tabelle aufgeführt ist. Verwenden Sie keine neueren CU-Versionen, auch wenn sie von Microsoft erhältlich sind, da diese möglicherweise nicht mit RDS kompatibel sind.
Alternativ können Sie die erforderliche Cumulative Update (CU) -Datei auch direkt von der folgenden Website herunterladen:
In der folgenden Tabelle sind die unterstützte Version der SQL Server Developer Edition und das entsprechende kumulative Update für die Verwendung mit RDS aufgeführt:
| SQL Server-Version | Unterstützte CUs | KB-Artikel | Dateiname herunterladen |
| --- | --- | --- | --- |
| SQL Server 2022 | `CU21` | [KB5065865](https://learn.microsoft.com/en-us/troubleshoot/sql/releases/sqlserver-2022/cumulativeupdate21) | `SQLServer2022-KB5065865-x64.exe` |
| SQL Server 2019 | `CU32 GDR` | [KB5068404](https://support.microsoft.com/en-us/topic/kb5068404-description-of-the-security-update-for-sql-server-2019-cu32-november-11-2025-c203bfbf-036e-46d2-bc10-6c01200dc48a) | `SQLServer2019-KB5068404-x64.exe` |
# Erstellen einer benutzerdefinierten Engine-Version für RDS for SQL Server
Eine benutzerdefinierte Engine-Version (CEV) für RDS for SQL Server besteht aus Ihren SQL Server Developer Edition-Installationsmedien, die in Amazon RDS importiert wurden. Es ist notwendig, das Basis-ISO-Installationsprogramm und die kumulativen Aktualisierungsdateien (.exe) in Ihren Amazon S3 S3-Bucket hochzuladen. Nach dem Hochladen sollten Sie RDS den Amazon S3 S3-Speicherort zur Verfügung stellen, damit dieser Ihr CEV herunterladen, validieren und anschließend erstellen kann.
## Einschränkungen bei der Benennung
Bei der Erstellung eines CEV müssen Sie bestimmte Benennungskonventionen beachten:
+ Der CEV-Name muss dem Muster folgen. `major-version.minor-version.customized-string`
+ `customized-string`kann 1—50 alphanumerische Zeichen, Unterstriche, Bindestriche und Punkte enthalten. Zum Beispiel: `16.00.4215.2.my-dev-cev` für SQL Server 2022.
Verwenden Sie den folgenden Befehl, um alle unterstützten Engine-Versionen aufzulisten:
```
aws rds describe-db-engine-versions --engine sqlserver-dev-ee --output json --query "{DBEngineVersions: DBEngineVersions[?Status=='requires-custom-engine-version'].{Engine: Engine, EngineVersion: EngineVersion, Status: Status, DBEngineVersionDescription: DBEngineVersionDescription}}"
{
"DBEngineVersions": [
{
"Engine": "sqlserver-dev-ee",
"EngineVersion": "16.00.4215.2.v1",
"Status": "requires-custom-engine-version",
"DBEngineDescription": "Microsoft SQL Server Enterprise Developer Edition",
"DBEngineVersionDescription": "SQL Server 2022 16.00.4215.2.v1"
}
]
}
```
## AWS CLI
**Um die benutzerdefinierte Engine-Version zu erstellen**
+ Verwenden Sie den Befehl [create-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/create-custom-db-engine-version.html).
Die folgenden Optionen sind erforderlich:
+ `--engine`
+ `--engine-version`
+ `--database-installation-files-s3-bucket-name`
+ `--database-installation-files`
+ `--region`
Sie können auch die folgenden Optionen angeben:
+ `--database-installation-files-s3-prefix`
+ `--description`
+ `--tags`
```
aws rds create-custom-db-engine-version \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.cev-dev-ss2022-cu21 \
--region us-west-2 \
--database-installation-files-s3-bucket-name my-s3-installation-media-bucket \
--database-installation-files-s3-prefix sqlserver-dev-media \
--database-installation-files "SQLServer2022-x64-ENU-Dev.iso" "SQLServer2022-KB5065865-x64.exe"
```
Die CEV-Erstellung dauert in der Regel 15-30 Minuten. Verwenden Sie den folgenden Befehl, um den Fortschritt der CEV-Erstellung zu überwachen:
```
# Check CEV status
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--region us-west-2
```
## Lebenszyklus eines RDS für SQL Server CEV
Bei der Arbeit mit SQL Server Developer Edition auf RDS für SQL Server durchlaufen Ihre benutzerdefinierten Engine-Versionen verschiedene Lebenszyklusstatus.
| Lebenszyklusstatus | Description | Wann es auftritt | Verfügbare Aktionen |
| --- | --- | --- | --- |
| noch ausstehende Validierung | Anfangszustand bei der Erstellung von CEV | Dies ist der Anfangszustand nach der Erstellung mit dem `create-custom-db-engine-version` Befehl. | Überwachen Sie den Status über`describe-db-engine-version`. |
| Validierung | Status der CEV-Validierung | Amazon RDS validiert Ihre benutzerdefinierte Engine-Version (CEV). Dieser asynchrone Vorgang kann einige Zeit in Anspruch nehmen. | Überwachen Sie den Status, bis die Überprüfung abgeschlossen ist. |
| available | Die Überprüfung der benutzerdefinierten Engine-Version (CEV) wurde erfolgreich abgeschlossen. | Die benutzerdefinierte Engine-Version (CEV) ist jetzt verfügbar. Amazon RDS hat Ihre SQL Server-ISO- und kumulativen Aktualisierungsdateien erfolgreich validiert. Sie können jetzt DB-Instances mit diesem CEV erstellen. | Erstellen Sie DB-Instances mit diesem CEV |
| failed | RDS for SQL Server kann die Custom Engine Version (CEV) nicht erstellen, da die Validierungsprüfung fehlgeschlagen ist. | Die ISO- und kumulative Medienvalidierung ist fehlgeschlagen. | Die ISO-Validierung ist fehlgeschlagen. Überprüfen Sie die Fehlerursache `describe-db-engine-version` unter, beheben Sie alle Dateiprobleme wie Hash-Abweichungen oder beschädigte Inhalte, und erstellen Sie dann Ihre benutzerdefinierte Engine-Version (CEV) neu. |
| deleting | Die benutzerdefinierte Engine-Version (CEV) wird gelöscht | Nach Kundenanrufen `delete-custom-db-engine-version` bis der Löschvorgang abgeschlossen ist. | Überwachen Sie den Status über`describe-db-engine-version`. |
| incompatible-installation-media | Amazon RDS konnte das für die benutzerdefinierte Engine-Version (CEV) bereitgestellte Installationsmedium nicht validieren | Die Validierung der Custom Engine Version (CEV) ist fehlgeschlagen. Diese ist ein Terminalstatus. | Informationen darüber, warum die Validierung fehlgeschlagen ist, finden Sie unter FailureReason via`describe-db-engine-versions`. Löschen Sie CEV. |
### Beschreiben Sie den CEV-Status
Sie können den Status Ihrer CEVs Nutzung von einsehen: AWS CLI
```
1. aws rds describe-db-engine-versions \
2. --engine sqlserver-dev-ee \
3. --engine-version 16.00.4215.2.my-dev-cev \
4. --region us-west-2 \
5. --query 'DBEngineVersions[0].{Version:EngineVersion,Status:Status}'
```
Beispielausgabe für
```
| DescribeDBEngineVersions |
+------------+---------------------------------+
| Status | Version |
+------------+---------------------------------+
| available | 16.00.4215.2.cev-dev-ss2022-cu21 |
+------------+---------------------------------+
```
Wenn ein CEV `failed` den Status anzeigt, können Sie den Grund mit dem folgenden Befehl ermitteln:
```
1. aws rds describe-db-engine-versions \
2. --engine sqlserver-dev-ee \
3. --engine-version 16.00.4215.2.my-dev-cev \
4. --region us-west-2 \
5. --query 'DBEngineVersions[0].{Version:EngineVersion,Status:Status,FailureReason:FailureReason}'
```
# Erstellen einer DB-Instance für RDS for SQL Server Developer Edition
Das Starten der Developer Edition-Instance auf RDS for SQL Server erfolgt in zwei Schritten: Erstellen Sie zunächst eine CEV mit`create-custom-db-engine-version`, Sobald Ihre benutzerdefinierte Engine-Version im verfügbaren Status ist, können Sie Amazon RDS-Datenbank-Instances mithilfe der CEV erstellen.
**Hauptunterschiede bei der Instanzerstellung in der Developer Edition**
| Parameter | Developer Edition |
| --- | --- |
| `--engine` | sqlserver-dev-ee |
| `--engine-version` | Version der benutzerdefinierten Engine (z. B. 16.00.4215.2. cev-dev-ss(2022) (cu21) |
| `--license-model` | bring-your-own-license |
## AWS CLI
Verwenden Sie den [create-db-instance](https://docs.aws.amazon.com//cli/latest/reference/rds/create-db-instance.html)Befehl mit den folgenden Parametern, um eine SQL Server Developer Edition-DB-Instance zu erstellen:
Die folgenden Optionen sind erforderlich:
+ `--db-instance-identifier`
+ `--db-instance-class`
+ `--engine` – `sqlserver-dev-ee`
+ `--region`
**Beispiele:**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier my-dev-sqlserver \
--db-instance-class db.m6i.xlarge \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--allocated-storage 200 \
--master-username admin \
--master-user-password changeThisPassword \
--license-model bring-your-own-license \
--no-multi-az \
--vpc-security-group-ids sg-xxxxxxxxx \
--db-subnet-group-name my-db-subnet-group \
--backup-retention-period 7 \
--region us-west-2
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier my-dev-sqlserver ^
--db-instance-class db.m6i.xlarge ^
--engine sqlserver-dev-ee ^
--engine-version 16.00.4215.2.cev-dev-ss2022-cu21 ^
--allocated-storage 200 ^
--master-username admin ^
--master-user-password master_user_password ^
--license-model bring-your-own-license ^
--no-multi-az ^
--vpc-security-group-ids sg-xxxxxxxxx ^
--db-subnet-group-name my-db-subnet-group ^
--backup-retention-period 7 ^
--region us-west-2
```
Weitere Informationen finden Sie unter [Erstellen einer DB-Instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html#USER_CreateDBInstance.Creating), um sie mithilfe der AWS Konsole zu erstellen.
# Anwenden von Upgrades für kleinere Datenbankversionen
Für RDS for SQL Server Developer Edition muss eine neue benutzerdefinierte Engine-Version (CEV) mit dem neuesten kumulativen Update erstellt werden, um das Upgrade der Datenbank-Nebenversion anwenden zu können. Upgrades der Datenbanknebenversionen für SQL Server Developer Edition umfassen die folgenden Schritte:
1. Überprüfen Sie vor dem Upgrade die aktuelle Engine-Version auf der Instance und identifizieren Sie die Zielversion der Datenbank-Engine aus den von Amazon RDS unterstützten Versionen. Weitere Informationen zu unterstützten SQL Server-Versionen in Amazon RDS finden Sie unter [Arbeiten mit SQL Server Developer Edition auf RDS für SQL Server](sqlserver-dev-edition.md).
1. Besorgen Sie sich Installationsmedien (ISO und CU), laden Sie sie hoch und [erstellen Sie dann eine neue benutzerdefinierte Engine-Version](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/sqlserver-dev-edition.creating-cev.html).
1. Wenden Sie das Upgrade der Datenbank-Nebenversion an, indem Sie Amazon RDS [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)mit dem neuen CEV verwenden.
```
aws rds modify-db-instance \
--db-instance-identifier \
--engine-version \
--no-apply-immediately ## use --apply-immediately for immediate update
```
**Anmerkung**
`--no-apply-immediately`(Standard), um die Änderungen im nächsten Wartungsfenster zu übernehmen.
# Benutzerdefinierte Engine-Versionen anzeigen und verwalten
Um all Ihre RDS for SQL Server Developer Edition anzuzeigen CEVs, verwenden Sie den `describe-db-engine-versions` Befehl mit der `--engine` Eingabe als`sqlserver-dev-ee`.
```
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--include-all \
--region us-west-2
```
Verwenden Sie den folgenden Befehl, um die Details eines bestimmten CEV anzuzeigen:
```
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.cev-dev-ss2022-cu21 \
--region us-west-2
```
**Anmerkung**
Dieser Befehl kehrt nur CEVs mit einem `available` Status zurück. Wenn Sie die Anzeige CEVs im Status „Gültig“ oder in einem anderen Status anzeigen möchten, fügen Sie das `--include-all` Kennzeichen hinzu.
## Löschen benutzerdefinierter Engine-Versionen
Bevor Sie eine CEV löschen, stellen Sie sicher, dass sie von keiner der folgenden Optionen verwendet wird:
+ Eine Amazon RDS-DB-Instance
+ Ein Snapshot einer Amazon RDS-DB-Instance
+ Ein automatisiertes Backup einer Amazon RDS-DB-Instance
**Anmerkung**
Sie können ein CEV nicht löschen, wenn ihm Ressourcen zugeordnet sind.
Verwenden Sie den Befehl [ delete-custom-db-engine-version, um eine benutzerdefinierte Engine-Version](https://docs.aws.amazon.com//cli/latest/reference/rds/delete-custom-db-engine-version.html) zu löschen.
+ `--engine`: Geben Sie `sqlserver-dev-ee` für Developer Edition an
+ `--engine-version`: Die genaue CEV-Versionskennung, die gelöscht werden soll
+ `--region`: AWS-Region wo das CEV existiert
```
aws rds delete-custom-db-engine-version \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--region us-west-2
```
Um den CEV-Löschvorgang zu überwachen, verwenden Sie den `describe-db-engine-versions` Befehl und geben Sie Ihre RDS for SQL Server CEV-Engine-Version an
```
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--region us-west-2
```
Statuswerte:
+ `deleting`: CEV-Löschung ist im Gange
+ Keine Ergebnisse zurückgegeben: CEV wurde erfolgreich gelöscht
# Problembehandlung bei SQL Server Developer Edition für RDS für SQL Server
In der folgenden Tabelle sind einige häufig auftretende Fehler und entsprechende Lösungen bei der Arbeit mit SQL Server Developer Edition for RDS for SQL Server aufgeführt
**Häufige Fehler und Lösungen**
| Fehlercode | Description | Lösung |
| --- | --- | --- |
| InvalidParameterValue | Ungültige CEV-Parameter oder Dateiverweise | Überprüfen Sie die Dateinamen, Pfade und die Parametersyntax |
| DBSubnetGroupNotFound | Die Subnetzgruppe ist nicht vorhanden | Erstellen Sie eine Subnetzgruppe oder überprüfen Sie den Namen |
| Ungültiger Status VPCNetwork | Problem mit der VPC-Konfiguration | Überprüfen Sie VPC, Subnetze und Routing-Tabellen |
| InvalidEngineVersion | CEV ist nicht verfügbar oder ungültig | Überprüfen Sie den CEV-Status und den Namen |
| Ungültige Klasse DBInstance | Instanzklasse wird nicht unterstützt | Wählen Sie die unterstützte Instanzklasse |
| Benutzerdefiniert DBEngine VersionQuotaExceededFault | Sie haben die maximale Anzahl an benutzerdefinierten Engine-Versionen erreicht | Erhöhen Sie bei Bedarf das Servicekontingent, oder löschen Sie bei CEVs Bedarf ungenutzte |
| CreateCustomDBEngineVersionFault | Amazon RDS konnte nicht auf die angegebene Installationsdatei im Amazon S3 S3-Bucket zugreifen. | Amazon RDS kann nicht auf die SQL Server-Installationsdateien am angegebenen Amazon S3 S3-Speicherort zugreifen. Erteilen Sie dem Amazon RDS Service Principal (rds.amazonaws.com) die s3: GetObject -Berechtigung in Ihrer Amazon S3 S3-Bucket-Richtlinie. Stellen Sie sicher, dass die Amazon S3 S3-Bucket-Region mit der Region übereinstimmt, in der Sie den CEV erstellen. |
# Arbeiten mit Active Directory mit RDS für SQL Server
Sie können eine RDS-für-SQL-Server-DB-Instance einer Microsoft Active Directory (AD)-Domain hinzufügen. Ihre AD-Domain kann auf AWS Managed AD innerhalb AWS oder in einem selbstverwalteten AD an einem Standort Ihrer Wahl, einschließlich Ihrer Unternehmensrechenzentren AWS EC2, auf oder bei anderen Cloud-Anbietern gehostet werden.
Sie können Domänenbenutzer mithilfe der NTLM-Authentifizierung und der Kerberos-Authentifizierung mit selbstverwaltetem Active Directory und authentifizieren. AWS Managed Microsoft AD
In den folgenden Abschnitten finden Sie Informationen zur Arbeit mit selbstverwaltetem Active Directory und AWS Managed Active Directory für Microsoft SQL Server auf Amazon RDS.
**Topics**
+ [
# Arbeiten mit selbstverwaltetem Active Directory mit einer DB-Instance von Amazon RDS für SQL Server
](USER_SQLServer_SelfManagedActiveDirectory.md)
+ [
# Arbeiten mit AWS Managed Active Directory mit RDS für SQL Server
](USER_SQLServerWinAuth.md)
# Arbeiten mit selbstverwaltetem Active Directory mit einer DB-Instance von Amazon RDS für SQL Server
Amazon RDS für SQL Server lässt sich nahtlos in Ihre selbstverwaltete Active Directory (AD)-Domain integrieren, unabhängig davon, wo Ihr AD gehostet wird – in Ihrem Rechenzentrum, in Amazon EC2 oder bei anderen Cloud-Anbietern. Diese Integration ermöglicht die direkte Benutzerauthentifizierung über NTLM- oder Kerberos-Protokolle, sodass keine komplexen Zwischen-Domains oder Gesamtstruktur-Vertrauensstellungen erforderlich sind. Wenn Sie eine Verbindung zu Ihrer DB-Instance von RDS für SQL Server herstellen, werden Authentifizierungsanfragen sicher an Ihre angegebene AD-Domain weitergeleitet, wobei Ihre bestehende Identitätsverwaltungsstruktur beibehalten und gleichzeitig die verwalteten Datenbankfunktionen von Amazon RDS genutzt werden.
**Topics**
+ [
## Verfügbarkeit von Regionen und Versionen
](#USER_SQLServer_SelfManagedActiveDirectory.RegionVersionAvailability)
+ [
# Voraussetzungen
](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md)
+ [
## Überlegungen
](#USER_SQLServer_SelfManagedActiveDirectory.Limitations)
+ [
# Einrichten eines selbstverwalteten Active Directory
](USER_SQLServer_SelfManagedActiveDirectory.SettingUp.md)
+ [
# Hinzufügen Ihrer DB-Instance zu Ihrem selbstverwalteten Active Directory
](USER_SQLServer_SelfManagedActiveDirectory.Joining.md)
+ [
# Verwalten einer DB-Instance in einer selbstverwalteten Active-Directory-Domain
](USER_SQLServer_SelfManagedActiveDirectory.Managing.md)
+ [
## Grundlegendes zur Mitgliedschaft in einer selbstverwalteten Active-Directory-Domain
](#USER_SQLServer_SelfManagedActiveDirectory.Understanding)
+ [
# Fehlerbehebung für selbstverwaltetes Active Directory
](USER_SQLServer_SelfManagedActiveDirectory.TroubleshootingSelfManagedActiveDirectory.md)
+ [
## Wiederherstellen einer SQL-Server-DB-Instance und Hinzufügen zu einer selbstverwalteten Active-Directory-Domain
](#USER_SQLServer_SelfManagedActiveDirectory.Restore)
## Verfügbarkeit von Regionen und Versionen
Amazon RDS unterstützt selbstverwaltetes AD für SQL Server mit NTLM und Kerberos in allen kommerziellen und. AWS-Regionen AWS GovCloud (US) Regions
# Voraussetzungen
Stellen Sie sicher, dass die folgenden Anforderungen erfüllt sind, bevor Sie eine RDS-für-SQL-Server-DB-Instance Ihrer selbstverwalteten AD-Domain hinzufügen.
**Topics**
+ [
## Konfigurieren Ihres On-Premises-AD
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.OnPremConfig)
+ [
## Konfigurieren Ihrer Netzwerkkonnektivität
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.NetworkConfig)
+ [
## Konfigurieren Ihres AD-Domain-Servicekontos
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.DomainAccountConfig)
+ [
## Konfigurieren der sicheren Kommunikation über LDAPS
](#USER_SQLServer_SelfManagedActiveDirectory.Requirements.LDAPS)
## Konfigurieren Ihres On-Premises-AD
Stellen Sie sicher, dass Sie über ein On-Premises-AD oder ein anderes selbstverwaltetes Microsoft-AD verfügen, der Sie die Amazon-RDS-für-SQL- Server-Instance hinzufügen können. Ihr On-Premises-AD sollte folgende Konfiguration aufweisen:
+ Wenn Sie AD-Standorte definiert haben, stellen Sie sicher, dass die Subnetze in der VPC, die Ihrer DB-Instance von RDS für SQL Server zugeordnet sind, an Ihrem AD-Standort definiert sind. Vergewissern Sie sich, dass keine Konflikte zwischen den Subnetzen in Ihrer VPC und den Subnetzen an Ihren anderen AD-Standorten bestehen.
+ Ihr AD-Domain-Controller weist die Domain-Funktionsebene Windows Server 2008 R2 oder höher auf.
+ Ihr AD-Domain-Name darf nicht im SLD-Format (Single Label Domain) vorliegen. RDS für SQL Server unterstützt keine SLD-Domains.
+ Der vollständig qualifizierte Domain-Name (Fully Qualified Domain Name, FQDN) für Ihr AD darf 47 Zeichen nicht überschreiten.
## Konfigurieren Ihrer Netzwerkkonnektivität
Stellen Sie sicher, dass die folgenden Netzwerkkonfigurationsanforderungen erfüllt sind:
+ Die Konnektivität zwischen der Amazon VPC, in der Sie die DB-Instance von RDS für SQL Server erstellen möchten, und Ihrem selbstverwalteten AD wurde konfiguriert. Sie können Konnektivität über AWS Direct Connect, AWS VPN, VPC-Peering oder AWS Transit Gateway einrichten.
+ Für VPC-Sicherheitsgruppen wurde die Standardsicherheitsgruppe für Ihre standardmäßige Amazon VPC bereits in der Konsole zu Ihrer RDS-für-SQL-Server-DB-Instance hinzugefügt. Stellen Sie sicher, dass die Sicherheitsgruppe und das VPC-Netzwerk ACLs für die Subnetze, in denen Sie Ihre RDS for SQL Server-DB-Instance erstellen, Datenverkehr auf den Ports und in den Anweisungen zulassen, die in der folgenden Abbildung dargestellt sind.
![\[Selbstverwaltetes AD – Netzwerkkonfiguration – Portregeln.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQLServer_SelfManagedActiveDirectory_Requirements_NetworkConfig.png)
In der folgenden Tabelle ist die Rolle der einzelnen Ports aufgeführt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/USER_SQLServer_SelfManagedActiveDirectory.Requirements.html)
+ Im Allgemeinen befinden sich die Domain-DNS-Server in den AD-Domain-Controllern. Zur Verwendung dieser Funktion müssen Sie den VPC-DHCP-Optionssatz nicht konfigurieren. Weitere Informationen finden Sie unter [DHCP-Optionssätze](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html) im *Amazon-VPC-Benutzerhandbuch*.
**Wichtig**
Wenn Sie ein VPC-Netzwerk verwenden ACLs, müssen Sie auch ausgehenden Datenverkehr auf dynamischen Ports (49152-65535) von Ihrer RDS for SQL Server-DB-Instance zulassen. Stellen Sie sicher, dass sich diese Datenverkehrsregeln auch auf den Firewalls widerspiegeln, die für die einzelnen AD-Domain-Controller, DNS-Server und RDS-für-SQL-Server-DB-Instances gelten.
Während für VPC-Sicherheitsgruppen Ports nur in der Richtung geöffnet werden müssen, in der der Netzwerkverkehr initiiert wird, ACLs erfordern die meisten Windows-Firewalls und VPC-Netzwerke, dass Ports in beide Richtungen geöffnet sind.
## Konfigurieren Ihres AD-Domain-Servicekontos
Stellen Sie sicher, dass die folgenden Anforderungen für ein AD-Domain-Servicekonto erfüllt sind:
+ Stellen Sie sicher, dass Sie in Ihrer selbstverwalteten AD-Domain über ein Domain-Servicekonto mit delegierten Berechtigungen zum Hinzufügen von Computern zu der Domain verfügen. Ein Domain-Servicekonto ist ein Benutzerkonto in Ihrem selbstverwalteten AD, an das die Berechtigung zur Ausführung bestimmter Aufgaben delegiert wurde.
+ An das Domain-Servicekonto müssen in der Organisationseinheit, der Sie Ihre RDS-für-SQL-Server-DB-Instance hinzufügen, die folgenden Berechtigungen delegiert werden:
+ Überprüfte Fähigkeit zum Schreiben in den DNS-Hostnamen
+ Überprüfte Fähigkeit zum Schreiben in den Prinzipalnamen des Service
+ Erstellen und Löschen von Computerobjekten
Dies sind die erforderlichen Mindestberechtigungen, um Computerobjekte zu Ihrem selbstverwalteten AD hinzuzufügen. Weitere Informationen finden Sie unter [Fehler beim Versuch, Computer einer Domain hinzuzufügen](https://learn.microsoft.com/en-US/troubleshoot/windows-server/identity/access-denied-when-joining-computers) in der Dokumentation zu Microsoft Windows Server.
+ Um die Kerberos-Authentifizierung zu verwenden, müssen Sie Ihrem AD-Domänendienstkonto Service Principal Names (SPNs) und DNS-Berechtigungen zuweisen:
+ **SPN schreiben**: Delegieren Sie die Berechtigung **SPN Schreiben** an das AD-Domain-Servicekonto in der Organisationseinheit, in der Sie der DB-Instance von RDS für SQL Server beitreten müssen. Diese Berechtigungen unterscheiden sich von validierten SPN-Schreibvorgängen.
+ **DNS-Berechtigungen**: Geben Sie die folgenden Berechtigungen für das AD-Domain-Servicekonto im DNS-Manager auf Serverebene für Ihren Domain-Controller ein:
+ Inhalt auflisten
+ Alle Eigenschaften lesen
+ Berechtigungen lesen
**Wichtig**
Verschieben Sie keine Computerobjekte, die RDS für SQL Server in der Organisationseinheit erstellt, nachdem Ihre DB-Instance erstellt wurde. Wenn Sie die zugehörigen Objekte verschieben, wird Ihre RDS-für-SQL-Server-DB-Instance falsch konfiguriert. Wenn Sie die von Amazon RDS erstellten Computerobjekte verschieben müssen, verwenden Sie den Vorgang [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API, um die Domänenparameter mit dem gewünschten Speicherort der Computerobjekte zu ändern.
## Konfigurieren der sicheren Kommunikation über LDAPS
Die Kommunikation über LDAPS wird für RDS zur Abfrage und zum Zugriff auf Computerobjekte sowie SPNs im Domänencontroller empfohlen. Um sicheres LDAP zu nutzen, verwenden Sie ein gültiges SSL-Zertifikat auf Ihrem Domain-Controller, das die Anforderungen für sicheres LDAPS erfüllt. Wenn auf dem Domain-Controller kein gültiges SSL-Zertifikat vorhanden ist, verwendet die DB-Instance von RDS für SQL Server standardmäßig LDAP. Weitere Informationen zur Gültigkeit von Zertifikaten finden Sie unter [Requirements for an LDAPS certificate](https://learn.microsoft.com/en-us/troubleshoot/windows-server/active-directory/enable-ldap-over-ssl-3rd-certification-authority#requirements-for-an-ldaps-certificate).
## Überlegungen
Beachten Sie Folgendes, wenn Sie eine DB-Instance von RDS für SQL Server zu einem selbstverwalteten AD hinzufügen:
+ Ihre DB-Instances werden mit dem AWS NTP-Dienst und nicht mit dem Zeitserver der AD-Domain synchronisiert. Für Datenbankverbindungen zwischen verknüpften SQL-Server-Instances innerhalb Ihrer AD-Domain können Sie nur die SQL-Authentifizierung und nicht die Windows-Authentifizierung verwenden.
+ Gruppenrichtlinienobjekteinstellungen aus Ihrer selbstverwalteten AD-Domäne werden nicht an Ihre RDS für SQL Server-Instanzen weitergegeben.
# Einrichten eines selbstverwalteten Active Directory
Gehen Sie wie folgt vor, um ein selbstverwaltetes AD einzurichten.
**Topics**
+ [
## Schritt 1: Erstellen einer Organisationseinheit in Ihrem AD
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateOU)
+ [
## Schritt 2: Erstellen eines AD-Domain-Servicekontos in Ihrem AD
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateADuser)
+ [
## Schritt 3: Delegieren der Kontrolle an das AD-Domain-Servicekonto
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.DelegateControl)
+ [
## Schritt 4: Erstellen Sie einen Schlüssel AWS KMS
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateKMSkey)
+ [
## Schritt 5: Erstellen Sie ein AWS Geheimnis
](#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateSecret)
## Schritt 1: Erstellen einer Organisationseinheit in Ihrem AD
**Wichtig**
Wir empfehlen, für jedes AWS Konto, das eine RDS for SQL Server-DB-Instance besitzt, die Ihrer selbstverwalteten AD-Domäne beigetreten ist, eine dedizierte Organisationseinheit und Dienstanmeldedaten zu erstellen, die auf diese Organisationseinheit beschränkt sind. Durch die Zuordnung einer Organisationseinheit und von Service-Anmeldeinformationen können Sie widersprüchliche Berechtigungen vermeiden und dem Prinzip der geringsten Berechtigung folgen.
**So erstellen Sie eine Organisationseinheit in Ihrem AD**
1. Stellen Sie als Domain-Administrator eine Verbindung zu Ihrer AD-Domain her.
1. Öffnen Sie **Active Directory-Benutzer und -Computer** und wählen Sie die Domain aus, in der Sie Ihre Organisationseinheit erstellen möchten.
1. Klicken Sie mit der rechten Maustaste auf die Domain und wählen Sie **Neu** und dann **Organisationseinheit** aus.
1. Geben Sie einen Namen für die Organisationseinheit ein.
1. Lassen Sie das Kontrollkästchen für **Container vor versehentlichem Löschen schützen** aktiviert.
1. Klicken Sie auf **OK**. Ihre neue Organisationseinheit wird unter Ihrer Domain angezeigt.
## Schritt 2: Erstellen eines AD-Domain-Servicekontos in Ihrem AD
Die Anmeldeinformationen des Domänendienstkontos werden für das Geheimnis in AWS Secrets Manager verwendet.
**So erstellen Sie ein AD-Domain-Servicekonto in Ihrem AD**
1. Öffnen Sie **Active-Directory-Benutzer und -Computer** und wählen Sie die Domain und die Organisationseinheit aus, in der Sie Ihren Benutzer erstellen möchten.
1. Klicken Sie mit der rechten Maustaste auf das Objekt **Benutzer** und wählen Sie **Neu** und dann **Benutzer** aus.
1. Geben Sie einen Vornamen, Nachnamen und Anmeldenamen für den Benutzer ein. Klicken Sie auf **Weiter**.
1. Geben Sie ein Passwort für den Benutzer ein. Wählen Sie nicht **Benutzer muss das Passwort bei der nächsten Anmeldung ändern** aus. Wählen Sie nicht **Konto ist deaktiviert** aus. Klicken Sie auf **Weiter**.
1. Klicken Sie auf **OK**. Ihr neuer Benutzer wird unter Ihrer Domain angezeigt.
## Schritt 3: Delegieren der Kontrolle an das AD-Domain-Servicekonto
**So delegieren Sie die Kontrolle an das AD-Domain-Servicekonto in Ihrer Domain**
1. Öffnen Sie das MMC-Snap-In **Active-Directory-Benutzer und -Computer** und wählen Sie die Domain aus, in der Sie Ihren Benutzer erstellen möchten.
1. Klicken Sie mit der rechten Maustaste auf die Organisationseinheit, die Sie zuvor erstellt haben, und wählen Sie **Kontrolle delegieren** aus.
1. Klicken Sie im **Assistenten für die Delegation der Kontrolle** auf **Weiter**.
1. Klicken Sie im Abschnitt **Benutzer oder Gruppen** auf **Hinzufügen**.
1. Geben Sie im Abschnitt **Benutzer, Computer oder Gruppen auswählen** das von Ihnen erstellte AD-Domain-Servicekonto ein und klicken Sie auf **Namen überprüfen**. Wenn Ihre AD-Domain-Servicekontoprüfung erfolgreich ist, klicken Sie auf **OK**.
1. Bestätigen Sie im Abschnitt **Benutzer oder Gruppen**, dass Ihr AD-Domain-Servicekonto hinzugefügt wurde, und klicken Sie auf **Weiter**.
1. Wählen Sie im Abschnitt **Zu delegierende Aufgaben** die Option **Eine zu delegierende benutzerdefinierte Aufgabe erstellen** aus und klicken Sie auf **Weiter**.
1. Gehen Sie im Abschnitt **Active-Directory-Objekttyp** wie folgt vor:
1. Wählen Sie **Nur die folgenden Objekte in dem Ordner** aus.
1. Wählen Sie **Computerobjekte** aus.
1. Wählen Sie **Ausgewählte Objekte in diesem Ordner erstellen** aus.
1. Wählen Sie **Ausgewählte Objekte in diesem Ordner löschen** aus und klicken Sie auf **Weiter**.
1. Gehen Sie im Abschnitt **Berechtigungen** wie folgt vor:
1. Behalten Sie die Auswahl von **Allgemein** bei.
1. Wählen Sie **Überprüfter Schreibvorgang in den DNS-Hostnamen** aus.
1. Wählen Sie **Überprüfter Schreibvorgang in den Service-Prinzipalnamen** aus und klicken Sie auf **Weiter**.
1. Um die Kerberos-Authentifizierung zu aktivieren, lassen Sie die Option **Eigenschaftsspezifisch** aktiviert und wählen Sie in der Liste die Option **Schreiben servicePrincipalName** aus.
1. Überprüfen und bestätigen Sie Ihre Einstellungen unter **Den Assistenten für die Delegation der Kontrolle abschließen** und klicken Sie auf **Fertig stellen**.
1. Öffnen Sie für die Kerberos-Authentifizierung den DNS-Manager und dann die **Servereigenschaften**.
1. Geben Sie im Windows-Dialogfeld `dnsmgmt.msc` ein.
1. Fügen Sie das AD-Domain-Servicekonto auf der Registerkarte **Sicherheit** hinzu.
1. Wählen Sie die Berechtigung **Lesen** aus und übernehmen Sie Ihre Änderungen.
## Schritt 4: Erstellen Sie einen Schlüssel AWS KMS
Der KMS-Schlüssel wird verwendet, um Ihr AWS Geheimnis zu verschlüsseln.
**Um einen Schlüssel zu erstellen AWS KMS**
**Anmerkung**
Verwenden Sie für den **Verschlüsselungsschlüssel** nicht den AWS Standard-KMS-Schlüssel. Stellen Sie sicher, dass Sie den AWS KMS Schlüssel in demselben AWS Konto erstellen, das die RDS for SQL Server-DB-Instance enthält, die Sie Ihrem selbstverwalteten AD hinzufügen möchten.
1. Wählen Sie in der AWS KMS Konsole **Create Key** aus.
1. Wählen Sie für **Schlüsseltyp** **Symmetrisch** aus.
1. Wählen Sie für **Schlüsselnutzung** die Option **Verschlüsseln und Entschlüsseln** aus.
1. Für **Advanced options (Erweiterte Optionen)**:
1. Wählen Sie unter **Schlüsselmaterialursprung** **KMS** aus.
1. Wählen Sie für **Regionalität** **Single-Region-Schlüssel** aus und klicken Sie auf **Weiter**.
1. Geben Sie für **Alias** einen Namen für den KMS-Schlüssel an.
1. (Optional) Geben Sie unter **Beschreibung** eine Beschreibung des KMS-Schlüssels an.
1. (Optional) Geben Sie für **Tags** ein Tag für den KMS-Schlüssel an und klicken Sie auf **Weiter**.
1. Geben Sie für **Schlüsseladministratoren** den Namen eines IAM-Benutzers an und wählen Sie ihn aus.
1. Lassen Sie für **Schlüssellöschung** das Kontrollkästchen für **Ermöglicht Schlüsseladministratoren das Löschen dieses Schlüssels** aktiviert und klicken Sie auf **Weiter**.
1. Geben Sie für **Schlüsselbenutzer** den IAM-Benutzer aus dem vorherigen Schritt an und wählen Sie ihn aus. Klicken Sie auf **Weiter**.
1. Prüfen Sie die Konfiguration.
1. Fügen Sie für **Schlüsselrichtlinie** Folgendes zur Richtlinien-**Anweisung** hinzu:
```
{
"Sid": "Allow use of the KMS key on behalf of RDS",
"Effect": "Allow",
"Principal": {
"Service": [
"rds.amazonaws.com"
]
},
"Action": "kms:Decrypt",
"Resource": "*"
}
```
1. Klicken Sie auf **Beenden**.
## Schritt 5: Erstellen Sie ein AWS Geheimnis
**So erstellen Sie ein Secret**
**Anmerkung**
Stellen Sie sicher, dass Sie das Geheimnis in demselben AWS Konto erstellen, das die RDS for SQL Server-DB-Instance enthält, die Sie Ihrem selbstverwalteten AD hinzufügen möchten.
1. Wählen Sie im AWS Secrets Manager die Option **Neues Geheimnis speichern** aus.
1. Als **Secret-Typ** wählen Sie **Anderer Secret-Typ** aus.
1. Fügen Sie für **Schlüssel/Wert-Paare** Ihre beiden Schlüssel hinzu:
1. Geben Sie als ersten Schlüssel `SELF_MANAGED_ACTIVE_DIRECTORY_USERNAME` ein.
1. Geben Sie als Wert für den ersten Schlüssel nur den Benutzernamen (ohne das Domain-Präfix) des AD-Benutzers ein. Geben Sie den Domain-Namen nicht an, da dies dazu führt, dass die Instance-Erstellung fehlschlägt.
1. Geben Sie als zweiten Schlüssel `SELF_MANAGED_ACTIVE_DIRECTORY_PASSWORD` ein.
1. Geben Sie als Wert des zweiten Schlüssels das Passwort ein, das Sie für den AD-Benutzer in Ihrer Domain erstellt haben.
1. Geben Sie als **Verschlüsselungsschlüssel** den KMS-Schlüssel ein, den Sie in einem vorherigen Schritt erstellt haben, und klicken Sie auf **Weiter**.
1. Geben Sie als **Secret-Name** einen aussagekräftigen Namen ein, anhand dessen Sie das Secret später leichter finden können.
1. (Optional) Geben Sie im Feld **Beschreibung** eine Beschreibung für den Secret-Namen ein.
1. Klicken Sie unter **Ressourcenberechtigung** auf **Bearbeiten**.
1. Fügen Sie der Berechtigungsrichtlinie folgende Richtlinie hinzu:
**Anmerkung**
Wir empfehlen Ihnen, die `aws:sourceAccount` und `aws:sourceArn` Bedingungen in der Police zu verwenden, um das Problem des *verwirrten Vertreters* zu vermeiden. Verwenden Sie Ihre AWS-Konto für `aws:sourceAccount` und die RDS for SQL Server-DB-Instance ARN für`aws:sourceArn`. Weitere Informationen finden Sie unter [Vermeidung des dienstübergreifenden Confused-Deputy-Problems](cross-service-confused-deputy-prevention.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Principal":
{
"Service": "rds.amazonaws.com"
},
"Action": "secretsmanager:GetSecretValue",
"Resource": "*",
"Condition":
{
"StringEquals":
{
"aws:sourceAccount": "123456789012"
},
"ArnLike":
{
"aws:sourceArn": "arn:aws:rds:us-west-2:123456789012:db:*"
}
}
}
]
}
```
------
1. Klicken Sie auf **Speichern** und dann auf **Weiter**.
1. Behalten Sie für **Rotationseinstellungen konfigurieren** die Standardwerte bei und wählen Sie **Weiter** aus.
1. Überprüfen Sie die Einstellungen für das Secret und klicken Sie auf **Speichern**.
1. Wählen Sie das von Ihnen erstellte Secret aus und kopieren Sie den Wert für den **Secret-ARN**. Dieser wird im nächsten Schritt bei der Einrichtung des selbstverwalteten Active Directory verwendet.
# Hinzufügen Ihrer DB-Instance zu Ihrem selbstverwalteten Active Directory
Gehen Sie wie folgt vor, um Ihre DB-Instance von RDS für SQL Server zu Ihrem selbstverwalteten AD hinzuzufügen:
## Schritt 1: Erstellen oder Ändern einer SQL Server-DB-Instance
Sie können die Konsole, die CLI oder die RDS-API verwenden, um eine RDS-für- SQL-Server-DB-Instance mit einer selbstverwalteten AD-Domain zu verknüpfen. Sie können dafür eine der folgenden Möglichkeiten auswählen:
+ Erstellen Sie mit der Konsole, dem [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)CLI-Befehl oder dem Vorgang [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) RDS API eine neue SQL Server-DB-Instance.
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 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)CLI-Befehls oder der Operation [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API.
Detaillierte Anweisungen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
+ Stellen Sie mithilfe der Konsole, des CLI-Befehls -db-snapshot oder des API-Vorgangs Restore From DBSnapshot RDS eine SQL [restore-db-instance-fromServer-DB-Instance DBInstance aus einem DB-Snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) [wieder her](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html).
Detaillierte Anweisungen finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
+ Stellen Sie eine SQL Server-DB-Instance point-in-time mithilfe der Konsole, des 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) CLI oder der Operation [Restore DBInstance ToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) RDS API in einer wieder her.
Detaillierte Anweisungen finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).
Wenn Sie den verwenden AWS CLI, sind die folgenden Parameter erforderlich, damit die DB-Instance die von Ihnen erstellte selbstverwaltete AD-Domäne 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 in einem vorherigen Schritt erstellt haben.
+ Verwenden Sie für den `--domain-dns-ips` Parameter die primären und sekundären IPv4 Adressen der DNS-Server für Ihr selbstverwaltetes AD. Wenn Sie keine sekundäre DNS-Server-IP-Adresse haben, geben Sie die primäre IP-Adresse zweimal ein.
Die folgenden CLI-Beispielbefehle zeigen, wie Sie eine RDS-für-SQL-Server-DB-Instance mit einer selbstverwalteten AD-Domain erstellen, ändern und entfernen.
**Wichtig**
Wenn Sie eine DB-Instance ändern, um sie einer selbstverwalteten AD-Domain 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 Single-AZ-DB-Instance zu Ausfallzeiten. Eine Multi-AZ-DB-Instance führt ein Failover durch, bevor ein Neustart ausgeführt wird. Weitere Informationen finden Sie unter [Verwenden der Einstellung „Planen von Änderungen“](USER_ModifyInstance.ApplyImmediately.md).
Mit dem folgenden CLI-Befehl wird eine neue RDS-für-SQL-Server-DB-Instance erstellt und einer selbstverwalteten AD-Domain hinzugefügt.
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier my-DB-instance \
--db-instance-class db.m5.xlarge \
--allocated-storage 50 \
--engine sqlserver-se \
--engine-version 15.00.4043.16.v1 \
--license-model license-included \
--master-username my-master-username \
--master-user-password my-master-password \
--domain-fqdn my_AD_domain.my_AD.my_domain \
--domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain \
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" \
--domain-dns-ips "10.11.12.13" "10.11.12.14"
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier my-DB-instance ^
--db-instance-class db.m5.xlarge ^
--allocated-storage 50 ^
--engine sqlserver-se ^
--engine-version 15.00.4043.16.v1 ^
--license-model license-included ^
--master-username my-master-username ^
--master-user-password my-master-password ^
--domain-fqdn my-AD-test.my-AD.mydomain ^
--domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain ^
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" \ ^
--domain-dns-ips "10.11.12.13" "10.11.12.14"
```
Mit dem folgenden CLI-Befehl wird eine vorhandene DB-Instance von RDS für SQL Server, so geändert, dass sie eine selbstverwaltete AD-Domain verwendet.
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier my-DB-instance \
--domain-fqdn my_AD_domain.my_AD.my_domain \
--domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain \
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" \
--domain-dns-ips "10.11.12.13" "10.11.12.14"
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier my-DBinstance ^
--domain-fqdn my_AD_domain.my_AD.my_domain ^
--domain-ou OU=my-AD-test-OU,DC=my-AD-test,DC=my-AD,DC=my-domain ^
--domain-auth-secret-arn "arn:aws:secretsmanager:region:account-number:secret:my-AD-test-secret-123456" ^
--domain-dns-ips "10.11.12.13" "10.11.12.14"
```
Mit dem folgenden CLI-Befehl wird eine DB-Instance von RDS für SQL Server aus einer selbstverwalteten AD-Domain entfernt.
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier my-DB-instance \
--disable-domain
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier my-DB-instance ^
--disable-domain
```
## Schritt 2: Verwenden der Kerberos- oder NTLM-Authentifizierung
### NTLM-Authentifizierung
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 oder zum Listener-Endpunkt herstellen, wenn Sie eine Multi-AZ-Bereitstellung verwenden.
Während einer geplanten Datenbankwartung oder einer ungeplanten Serviceunterbrechung führt Amazon RDS automatisch einen Failover zur up-to-date sekundären Datenbank durch, sodass der Betrieb schnell und ohne manuelles Eingreifen wieder aufgenommen werden kann. 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 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 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**.
![\[Ändern der Speichermenge einer DB-Instance\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/kerb-endpoint-selfManagedAD-RDSMS.png)
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;
```
Wenn Ihre Instance beim Herstellen einer Verbindung zu einem Kerberos-Endpunkt eine NTLM-Verbindung zurückgibt, überprüfen Sie Ihre Netzwerk- und Benutzerkonfigurationen. Siehe [Konfigurieren Ihrer Netzwerkkonnektivität](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.NetworkConfig).
## Schritt 3: SQL Server-Logins für die Windows-Authentifizierung erstellen
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 der selbstverwalteten AD-Domain hinzugefügt wurde, können Sie SQL-Server-Anmeldungen und -Benutzer bereitstellen. Sie tun dies über das AD-Dienstprogramm für Benutzer und Gruppen in Ihrer selbstverwalteten AD-Domain. Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden.
Damit sich ein Domain-Servicekonto eines selbstverwalteten AD mit SQL Server authentifizieren kann, muss eine Windows-Anmeldung für SQL Server für das Domain-Servicekonto des selbstverwalteten AD oder für eine Gruppe des selbstverwalteten AD, 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 Domain-Servicekonto des selbstverwalteten AD, das über keine SQL-Server-Anmeldung verfügt oder zu keiner Gruppe des selbstverwalteten AD mit einer solchen Anmeldung gehört, kann nicht auf die DB-Instance von SQL Server zugreifen.
Die Berechtigung ALTER ANY LOGIN ist erforderlich, um eine SQL-Server-Anmeldung für das selbstverwaltete AD zu erstellen. Wenn Sie mit dieser Berechtigung noch keine Anmeldungen erstellt haben, verbinden Sie sich mithilfe der SQL-Server-Authentifizierung als Masterbenutzer der DB-Instance und erstellen Sie Ihre SQL-Server-Anmeldungen für das selbstverwaltete AD im Kontext des Masterbenutzers.
Sie können einen Data Definition Language (DDL)-Befehl wie im Folgenden dargestellt ausführen, um eine SQL-Server-Anmeldung für ein Domain-Servicekonto des selbstverwalteten AD oder eine entsprechende Gruppe zu erstellen.
**Anmerkung**
Geben Sie Benutzer und Gruppen unter Verwendung des Anmeldenamens von Windows 2000 im Format a `my_AD_domain\my_AD_domain_user`. Sie können keinen User Principle Name (UPN) im Format verwenden *`my_AD_domain_user`*`@`*`my_AD_domain`*.
```
USE [master]
GO
CREATE LOGIN [my_AD_domain\my_AD_domain_user] FROM WINDOWS WITH DEFAULT_DATABASE = [master], DEFAULT_LANGUAGE = [us_english];
GO
```
Weitere Informationen finden Sie unter [ANMELDENAME ERSTELLEN (Transact-SQL)](https://msdn.microsoft.com/en-us/library/ms189751.aspx) in der Microsoft Developer Network-Dokumentation.
Benutzer (sowohl menschliche Benutzer als auch Anwendungen) aus Ihrer Domain können sich nun von einem einer selbstverwalteten AD-Domain hinzugefügten Client-Computer mithilfe der Windows-Authentifizierung mit der RDS-für-SQL-Server-Instance verbinden.
# Verwalten einer DB-Instance in einer selbstverwalteten Active-Directory-Domain
Sie können die Konsole oder die Amazon RDS-API verwenden AWS CLI, um Ihre DB-Instance und ihre Beziehung zu Ihrer selbstverwalteten AD-Domain 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 aufgrund einer fehlgeschlagenen Mitgliedschaft erneut zu versuchen, einer selbstverwalteten Domain beizutreten, verwenden Sie den Vorgang „DBInstanceAPI [ändern](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)“ und geben Sie dieselben Parameter an:
+ `--domain-fqdn`
+ `--domain-dns-ips`
+ `--domain-ou`
+ `--domain-auth-secret-arn`
+ Um eine DB-Instance aus einer selbstverwalteten Domain zu entfernen, verwenden Sie die API-Operation `ModifyDBInstance` und geben Sie `--disable-domain` als Domain-Parameter an.
+ Um eine DB-Instance von einer selbstverwalteten Domain in eine andere zu verschieben, verwenden Sie die API-Operation `ModifyDBInstance` und geben Sie die Domain-Parameter für die neue Domain an:
+ `--domain-fqdn`
+ `--domain-dns-ips`
+ `--domain-ou`
+ `--domain-auth-secret-arn`
+ [Verwenden Sie den Vorgang Describe API, um die selbstverwaltete AD-Domänenmitgliedschaft für jede DB-Instance aufzulisten. DBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/DescribeDBInstances.html)
## Grundlegendes zur Mitgliedschaft in einer selbstverwalteten Active-Directory-Domain
Nachdem Sie Ihre DB-Instance erstellt oder geändert und dabei AD-Details angegeben haben, wird die Instance ein Mitglied der selbstverwalteten AD-Domain. Die AWS Konsole zeigt den Status der selbstverwalteten Active Directory-Domänenmitgliedschaft für die DB-Instance an. Der Status der DB-Instance kann einer der folgenden sein:
+ **joined** – Die Instance ist Mitglied der AD-Domain.
+ **joining** – Die Instance ist gerade dabei, Mitglied der AD-Domain zu werden.
+ **pending-join** – Die Mitgliedschaft der Instance steht noch aus.
+ **pending-maintenance-join**— versucht, AWS die Instance während des nächsten geplanten Wartungsfensters zu einem Mitglied der AD-Domäne zu machen.
+ **pending-removal** – Das Entfernen der Instance von der AD-Domain steht noch aus.
+ **pending-maintenance-removal**— versucht, AWS die Instanz während des nächsten geplanten Wartungsfensters aus der AD-Domäne zu entfernen.
+ **failed** – Ein Konfigurationsproblem hat verhindert, dass die Instance der Domain beitreten 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 selbstverwalteten AD-Domain entfernt.
**Wichtig**
Eine Anfrage, Mitglied einer selbstverwalteten AD-Domain zu werden, kann wegen eines Netzwerkverbindungsproblems fehlschlagen. Es könnte beispielsweise sein, dass Sie eine DB-Instance erstellen oder eine vorhandene Instance ändern und der Versuch, die DB-Instance zu einem Mitglied einer selbstverwalteten AD-Domain zu machen, fehlschlägt. Geben Sie in diesem Fall entweder den Befehl zum Erstellen oder Ändern der DB-Instance neu aus oder ändern Sie die neu erstellte Instance, damit sie der selbstverwalteten AD-Domain beitreten kann.
# Fehlerbehebung für selbstverwaltetes Active Directory
Die folgenden Probleme können auftreten, wenn Sie ein selbstverwaltetes AD einrichten oder ändern.
****
| Fehlercode | Description | 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 Domänendienstkonto verfügt nicht über die erforderlichen Berechtigungen, um der Organisationseinheit beizutreten. | Überprüfen Sie den Parameter `—domain-ou`. Stellen Sie sicher, dass das Domain-Servicekonto über die richtigen Berechtigungen für die Organisationseinheit verfügt. Weitere Informationen finden Sie unter [Konfigurieren Ihres AD-Domain-Servicekontos](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.DomainAccountConfig). |
| 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 RDS-für-SQL-Server-DB-Instance 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 Domänendienstkonto 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. Weitere Informationen finden Sie unter [Konfigurieren Ihres AD-Domain-Servicekontos](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.DomainAccountConfig). |
| Fehler 234 / 0xEA | Die angegebene Organisationseinheit ist nicht vorhanden. | Die mit dem Parameter `—domain-ou` angegebene Organisationseinheit ist in Ihrem selbstverwalteten AD nicht vorhanden. | Überprüfen Sie den Parameter `—domain-ou` und stellen Sie sicher, dass die angegebene Organisationseinheit in Ihrem selbstverwalteten AD vorhanden ist. |
| Fehler 1326 / 0x52E | Der Benutzername oder das Passwort ist falsch. | Die in AWS Secrets Manager angegebenen Anmeldeinformationen für das Domänendienstkonto enthalten einen unbekannten Benutzernamen oder ein falsches Passwort. Möglicherweise ist das Domain-Konto auch in Ihrem selbstverwalteten AD deaktiviert. | Stellen Sie sicher, dass die in AWS Secrets Manager angegebenen Anmeldeinformationen korrekt sind und das Domain-Konto in Ihrem selbstverwalteten AD aktiviert ist. |
| Fehler 1355 / 0x54B | Die angegebene Domain ist nicht vorhanden oder konnte nicht kontaktiert werden. | Die Domain ist ausgefallen, der angegebene IPs DNS-Satz 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 RDS-für-SQL-Server-DB-Instance und stellen Sie sicher, dass Ihr selbstverwaltetes AD erreichbar ist. Weitere Informationen finden Sie unter [Konfigurieren Ihrer Netzwerkkonnektivität](USER_SQLServer_SelfManagedActiveDirectory.Requirements.md#USER_SQLServer_SelfManagedActiveDirectory.Requirements.NetworkConfig). |
| 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 RDS-für-SQL -Server-DB-Instance aus erreichbar sind. |
| Fehler 1727 / 0x6BF | Der Remote-Prozeduraufruf ist fehlgeschlagen und wurde nicht ausgeführt. | Netzwerkverbindungsproblem oder Firewall-Einschränkung blockiert die RPC-Kommunikation mit dem Domain-Controller. | Wenn Sie den VPC-übergreifenden Domain-Beitritt verwenden, überprüfen Sie, ob die VPC-übergreifende Kommunikation korrekt mit VPC-Peering oder Transit Gateway eingerichtet ist. Stellen Sie sicher, dass die hohen TCP-Ports `49152-65535` in Ihrer Domain von Ihrer DB-Instance von RDS für SQL Server aus erreichbar sind, einschließlich aller möglichen Firewall-Einschränkungen. |
| Fehler 2224 / 0x8B0 | Das Benutzerkonto besteht bereits. | Das Computerkonto, das zu Ihrem selbstverwalteten AD hinzugefügt werden soll, ist bereits vorhanden. | Ermitteln Sie das Computerkonto, indem Sie `SELECT @@SERVERNAME` auf Ihrer RDS-für-SQL-Server-DB-Instance ausführen, und entfernen Sie es dann vorsichtig aus Ihrem selbstverwalteten AD. |
| Fehler 2242 / 0x8c2 | Das Passwort dieses Benutzers ist abgelaufen. | Das Passwort für das über AWS Secrets Manager angegebene Domänendienstkonto ist abgelaufen. | Aktualisieren Sie das Passwort für das Domain-Servicekonto, über das Sie Ihre RDS-für-SQL-Server-DB-Instance Ihrem selbstverwalteten AD hinzufügen. |
Nachdem Sie Ihre DB-Instance zu einer selbstverwalteten Active-Directory-Domain hinzugefügt haben, erhalten Sie möglicherweise RDS-Ereignisse, die sich auf den Zustand Ihrer Domain beziehen.
```
Unhealthy domain state detected while attempt to verify or
configure your Kerberos endpoint in your domain on
node node_n. message
```
Bei Multi-AZ-Instances stellen Sie möglicherweise die Fehlerberichterstattung sowohl für Knoten1 als auch Knoten2 fest, was darauf hindeutet, dass die Kerberos-Konfiguration Ihrer Instance nicht für einen Failover bereit ist. Im Falle eines Failovers können Probleme bei der Authentifizierung mit Kerberos auftreten. Beheben Sie die Konfigurationsprobleme, um sicherzustellen, dass die Kerberos-Einrichtung gültig und aktuell ist. Bei Multi-AZ-Instances sind keine Aktionen erforderlich, um die Kerberos-Authentifizierung auf dem neuen primären Host zu verwenden, sofern alle Netzwerk- und Berechtigungskonfigurationen vorhanden sind.
Bei Single-AZ-Instances ist Knoten1 der Primärknoten. Wenn Ihre Kerberos-Authentifizierung nicht wie erwartet funktioniert, überprüfen Sie die Instance-Ereignisse und beheben Sie die Konfigurationsprobleme, um sicherzustellen, dass die Kerberos-Einrichtung gültig und aktuell ist.
## Wiederherstellen einer SQL-Server-DB-Instance und Hinzufügen zu einer selbstverwalteten Active-Directory-Domain
Sie können einen DB-Snapshot wiederherstellen oder eine point-in-time Wiederherstellung (PITR) für eine SQL Server-DB-Instance durchführen und sie dann einer selbstverwalteten Active Directory-Domäne hinzufügen. Wenn die DB-Instance wiederhergestellt wurde, ändern Sie die Instance, indem Sie den unter [Schritt 1: Erstellen oder Ändern einer SQL Server-DB-Instance](USER_SQLServer_SelfManagedActiveDirectory.Joining.md#USER_SQLServer_SelfManagedActiveDirectory.SettingUp.CreateModify) beschriebenen Prozess anwenden, um die DB-Instance einer selbstverwalteten AD-Domain hinzuzufügen.
# Arbeiten mit AWS Managed Active Directory mit RDS für SQL Server
Sie können AWS Managed Microsoft AD es verwenden, um Benutzer mit der Windows-Authentifizierung zu authentifizieren, wenn sie eine Verbindung zu Ihrer RDS for SQL Server-DB-Instance herstellen. Die DB-Instance funktioniert mit AWS Directory Service for Microsoft Active Directory, wird auch genannt AWS Managed Microsoft AD, um die Windows-Authentifizierung zu aktivieren. Wenn Benutzer sich mit einer SQL Server-DB-Instance authentifizieren, die mit einer vertrauenswürdigen Domäne verbunden ist, werden die Authentifizierungsanfragen an das Domänenverzeichnis weitergeleitet, das Sie mit erstellt habe Directory Service.
## Verfügbarkeit von Regionen und Versionen
Amazon RDS unterstützt nur die Verwendung AWS Managed Microsoft AD für die Windows-Authentifizierung. RDS unterstützt die Verwendung nicht AD Connector. Weitere Informationen finden Sie unter:
+ [Richtlinie zur Anwendungskompatibilität für AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_app_compatibility.html)
+ [Richtlinie zur Anwendungskompatibilität für AD-Connector](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ad_connector_app_compatibility.html)
Informationen zur Versions- und Regionsverfügbarkeit finden Sie unter [Kerberos-Authentifizierung mit RDS für SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.html#Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.sq).
## Übersicht zur Einrichtung einer Windows-Authentifizierung
Amazon RDS verwendet einen gemischten Modus für die Windows-Authentifizierung. Mit dieser Vorgehensweise verwendet der *Hauptbenutzer* (zum Erstellen der SQL Server-DB-Instance verwendeter Name und verwendetes Passwort ) die SQL-Authentifizierung. Da das Masterbenutzerkonto Anmeldedaten mit besonderen Berechtigungen enthält, sollte der Zugriff auf dieses Konto beschränkt sein.
Um mithilfe eines lokalen oder selbst gehosteten Microsoft Active Directory Windows-Authentifizierung abzurufen, erstellen Sie eine Gesamtstruktur-Vertrauensstellung. Die Vertrauensstellung kann uni- oder bidirektional sein. Weitere Informationen zum Einrichten von Forest Trusts mithilfe von Directory Service finden Sie unter [Wann sollte eine Vertrauensstellung erstellt werden?](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_setup_trust.html) im *AWS Directory Service Administratorhandbuch*.
Führen Sie die folgenden Schritte aus, um eine Windows-Authentifizierung für eine SQL Server-DB-Instance einzurichten. Diese Schritt werden unter noch genauer erklär [Einrichten einer Windows-Authentifizierung für SQL Server-DB-Instances](USER_SQLServerWinAuth.SettingUp.md):
1. Verwenden Sie AWS Managed Microsoft AD entweder über die AWS-Managementkonsole oder die Directory Service API, um ein AWS Managed Microsoft AD Verzeichnis zu erstellen.
1. Wenn Sie die AWS CLI oder Amazon RDS-API verwenden, um Ihre SQL Server-DB-Instance zu erstellen, erstellen Sie eine AWS Identity and Access Management (IAM-) Rolle. Diese Rolle verwendet die verwaltete IAM-Richtlinie `AmazonRDSDirectoryServiceAccess` und ermöglicht es Amazon RDS, Aufrufe an Ihr Verzeichnis durchzuführen. Wenn Sie die Konsole zum Erstellen der SQL Server-DB-Instance verwenden, erstellt AWS die IAM-Rolle für Sie.
Damit die Rolle Zugriff gewährt, muss der Endpunkt AWS -Security-Token-Service (AWS STS) in der AWS Region für Ihr AWS Konto aktiviert sein. AWS STS Endpunkte sind standardmäßig in allen AWS Regionen aktiv, und Sie können sie ohne weitere Aktionen verwenden. 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 *IAM-Benutzerhandbuch*.
1. Erstellen und konfigurieren Sie Benutzer und Gruppen im AWS Managed Microsoft AD Verzeichnis mithilfe der Microsoft Active Directory-Tools. Weitere Informationen zum Erstellen von Benutzern und Gruppen in Ihrem Active Directory finden Sie unter [Verwalten von Benutzern und Gruppen in AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups.html) im *AWS Directory Service Administrationshanbuch*.
1. Wenn Sie planen, das Verzeichnis und die DB-Instance an unterschiedlichen Orten zu lokalisieren VPCs, aktivieren Sie den vPC-übergreifenden Verkehr.
1. Verwenden Sie Amazon RDS, um eine neue SQL Server-DB-Instance entweder über die Konsole oder über die Amazon RDS-API zu erstellen. AWS CLI In der Anforderung zum Erstellen geben Sie den Domänenbezeichner an ("`d-*`"-Bezeichner), der beim Erstellen des Verzeichnisses generiert wurde, sowie den Namen der von Ihnen erstellten Rolle. Sie können auch eine vorhandene SQL Server-DB-Instance für die Verwendung der Windows-Authentifizierung ändern, indem Sie die Domänen- und IAM-Rollenparameter für die DB-Instance festlegen.
1. Verwenden Sie die Anmeldeinformationen für den Amazon-RDS-Hauptbenutzer, 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 AWS Managed Microsoft AD Domäne verbunden ist, können Sie SQL Server-Logins und Benutzer aus den Active Directory-Benutzern und -Gruppen in ihrer Domäne bereitstellen. (Diese werden als SQL Server "Windows"-Anmeldungen bezeichnet.) Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden.
Wenn Sie mithilfe der Amazon RDS-Konsole eine mit einer Domäne verbundene RDS for SQL Server-DB-Instance erstellen, AWS wird automatisch die `rds-directoryservice-access-role` IAM-Rolle erstellt. Diese Rolle ist für die Verwaltung von mit Domains verknüpften Instances unerlässlich und für die folgenden Operationen erforderlich:
+ Vornehmen von Konfigurationsänderungen an mit einer Domain verknüpften SQL-Server-Instances
+ Verwalten der Active-Directory-Integrationseinstellungen
+ Durchführen von Wartungsvorgängen auf mit Domains verknüpften Instances
**Wichtig**
Wenn Sie die IAM-Rolle `rds-directoryservice-access-role` löschen, können Sie über die Amazon-RDS-Konsole oder -API keine Änderungen mehr an Ihrer mit der Domain verknüpften SQL-Server-Instance vornehmen. Der Versuch, die Instance zu ändern, führt zu einer Fehlermeldung, die besagt: You don't have permission to iam:. CreateRole Um Zugriff anzufordern, kopieren Sie den folgenden Text und senden Sie ihn an Ihren AWS Administrator.
Dieser Fehler tritt auf, weil Amazon RDS die Rolle zur Verwaltung der Domain-Verbindung neu erstellen muss, aber nicht über die erforderlichen Berechtigungen verfügt. Außerdem ist dieser Fehler nicht angemeldet CloudTrail, was die Fehlerbehebung erschweren kann.
Wenn Sie die `rds-directoryservice-access-role` versehentlich löschen, müssen Sie über die Berechtigung `iam:CreateRole` verfügen, um sie neu zu erstellen, bevor Sie Änderungen an Ihrer mit der Domain verknüpften SQL-Server-Instance vornehmen können. Um die Rolle manuell neu zu erstellen, vergewissern Sie sich, dass ihr die verwaltete Richtlinie `AmazonRDSDirectoryServiceAccess` und die entsprechende Vertrauensstellung zugeordnet sind, damit der RDS-Service die Rolle übernehmen kann.
# Erstellen des Endpunkts für die Kerberos-Authentifizierung
Eine Kerberos-basierte Authentifizierung erfordert, dass der Endpunkt ein kundendefinierter Hostname, ein Zeitraum und dann der vollständig qualifizierte Domänenname (FQDN) ist. Im Folgenden sehen Sie ein Beispiel für einen Endpunkt, den Sie mit Kerberos-basierter Authentifizierung verwenden können. In diesem Beispiel lautet der Hostname der SQL Server-DB-Instance `ad-test` und der Domänenname `corp-ad.company.com`.
```
ad-test.corp-ad.company.com
```
Wenn Sie überprüfen möchten, ob Ihre Verbindung Kerberos verwendet, führen Sie die folgende Abfrage aus:
```
1. SELECT net_transport, auth_scheme
2. FROM sys.dm_exec_connections
3. WHERE session_id = @@SPID;
```
# Einrichten einer Windows-Authentifizierung für SQL Server-DB-Instances
Sie verwenden AWS Directory Service for Microsoft Active Directory, auch genannt AWS Managed Microsoft AD, um die Windows-Authentifizierung für eine SQL Server-DB-Instance einzurichten. Um die Windows-Authentifizierung einzurichten, führen Sie folgende Schritte aus.
## Schritt 1: Erstellen Sie ein Verzeichnis mit dem AWS Directory Service for Microsoft Active Directory
Directory Service erstellt ein vollständig verwaltetes Microsoft Active Directory in der AWS Cloud. Wenn Sie ein AWS Managed Microsoft AD Verzeichnis erstellen, Directory Service erstellt in Ihrem Namen zwei Domänencontroller und DNS-Server (Domain Name Service). Die Verzeichnis-Server werden in zwei Subnetzen in zwei verschiedenen Availability Zones in einer VPC erstellt. Diese Redundanz hilft sicherzustellen, dass Ihr Verzeichnis verfügbar bleibt, auch wenn ein Fehler auftritt.
Wenn Sie ein AWS Managed Microsoft AD Verzeichnis erstellen, Directory Service führt er in Ihrem Namen die folgenden Aufgaben aus:
+ Richtet ein Microsoft Active Directory in der VPC ein.
+ Erstellt ein Verzeichnisadministratorkonto mit dem Benutzernamen Admin und dem angegebenen Passwort. Mit diesem Konto verwalten Sie das Verzeichnis.
+ Erstellt eine Sicherheitsgruppe für die Verzeichniscontroller.
Wenn Sie eine starten AWS Directory Service for Microsoft Active Directory, AWS erstellt eine Organisationseinheit (OU), die alle Objekte Ihres Verzeichnisses enthält. Diese OU erhält den NetBIOS-Namen, den Sie beim Erstellen des Verzeichnisses eingegeben haben, und befindet sich im Domainstamm. Der Domänenstamm gehört und wird von verwaltet AWS.
Das *Admin*-Konto, das zusammen mit dem Verzeichnis AWS Managed Microsoft AD erstellt wurde, verfügt über die Berechtigungen für die häufigsten administrativen Aufgaben in Bezug auf Ihre OU:
+ Erstellen, Aktualisieren oder Löschen von Benutzern, Gruppen und Computern
+ Hinzufügen von Ressourcen zu Ihrer Domäne, etwa Datei- oder Druckserver, und anschließendes Gewähren der zugehörigen Ressourcenberechtigungen für Benutzer und Gruppen in der OU.
+ Erstellen Sie zusätzliche OUs Container.
+ Delegieren von Befugnissen.
+ Erstellen und Verknüpfen von Gruppenrichtlinien.
+ Wiederherstellen von gelöschten Objekten aus dem Active Directory-Papierkorb.
+ Führen Sie AD- und PowerShell DNS-Windows-Module im Active Directory-Webdienst aus.
Das Admin-Konto verfügt zudem über die Rechte zum Ausführen der folgenden domänenübergreifenden Aktivitäten:
+ Verwalten von DNS-Konfigurationen (Hinzufügen, Entfernen oder Aktualisieren von Datensätzen, Zonen und Weiterleitungen).
+ Aufrufen von DNS-Ereignisprotokollen.
+ Anzeigen von Sicherheitsereignisprotokollen.
**Um ein Verzeichnis zu erstellen mit AWS Managed Microsoft AD**
1. Wählen Sie im Navigationsbereich der [Directory Service -Konsole](https://console.aws.amazon.com/directoryservicev2/) die Option **Directories (Verzeichnisse)** und dann **Set up directory (Verzeichnis einrichten)** aus.
1. Wählen Sie **AWS Managed Microsoft AD**. Dies ist zurzeit die einzige für Amazon RDS unterstützte Option.
1. Wählen Sie **Weiter** aus.
1. Geben Sie auf der Seite **Enter directory information (Verzeichnisinformationen eingeben)** die folgenden Informationen ein:
**Edition**
Wählen Sie die Edition aus, die Ihre Anforderungen erfüllt.
**DNS-Name des Verzeichnisses**
Den vollständig qualifizierten Namen für das Verzeichnis, z. B. `corp.example.com`. Namen, die länger als 47 Zeichen sind, werden von SQL Server nicht unterstützt.
**NetBIOS-Name des Verzeichnisses**
Ein optionaler Kurzname für das Verzeichnis, z. B. `CORP`.
**Verzeichnisbeschreibung**
Eine optionale Beschreibung des Verzeichnisses.
**Administratorpasswort**
Das Passwort für den Verzeichnisadministrator. Während des Verzeichniserstellungsprozesses wird ein Administratorkonto mit dem Benutzernamen Admin und diesem Passwort angelegt.
Das Passwort für den Verzeichnisadministrator darf nicht das Wort „“ enthalte `admin`. Beachten Sie beim Passwort die Groß- und Kleinschreibung und es muss 8 bis 64 Zeichen lang sein. Zudem muss es mindestens ein Zeichen aus dreien der vier folgenden Kategorien enthalten:
+ Kleinbuchstaben (a – z)
+ Großbuchstaben (A – Z)
+ Zahlen (0 – 9)
+ Nicht-alphanumerische Zeichen (\$1\$1@\$1\$1%^&\$1\$1-\$1=`\$1\$1()\$1\$1[]:;"'<>,.?/)
**Passwort bestätigen**
Geben Sie das Administratorpasswort erneut ein.
1. Wählen Sie **Weiter** aus.
1. Geben Sie auf der Seite **Choose VPC and subnets (VPC und Subnetze wählen)** die folgenden Informationen an.
**VPC**
Wählen Sie die VPC für das Verzeichnis aus.
Sie können das Verzeichnis und die DB-Instance an unterschiedlichen Orten lokalisieren. Wenn Sie dies tun VPCs, stellen Sie jedoch sicher, dass Sie den VPC-übergreifenden Verkehr aktivieren. Weitere Informationen finden Sie unter [Schritt 4: Aktivieren des VPC-übergreifenden Datenverkehrs zwischen dem Verzeichnis und der DB-Instance](#USER_SQLServerWinAuth.SettingUp.VPC-Peering).
**Subnetze**
Wählen Sie Subnetze für die Verzeichnis-Server aus. Die beiden Subnetze müssen zu verschiedenen Availability-Zonen gehören.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie die Verzeichnisinformationen. Falls Sie noch Änderungen vornehmen möchten, klicken Sie auf **Previous (Zurück)**. Wenn die Informationen richtig sind, wählen Sie **Create directory (Verzeichnis erstellen)**.
![\[Seite Überprüfen und Erstellen\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth2.png)
Es dauert einige Minuten, bis das Verzeichnis erstellt wurde. Wenn es erfolgreich erstellt wurde, ändert sich der Wert **Status** in **Active (Aktiv)**.
Um Informationen über das Verzeichnis anzuzeigen, wählen Sie die Verzeichnis-ID in der Verzeichnisauflistung aus. Notieren Sie sich den Wert **Directory ID (Verzeichnis-ID)**. Sie benötigen diesen Wert, wenn Sie die SQL Server-DB-Instance erstellen oder modifizieren.
![\[Seite „Directory details (Verzeichnisdetails)“\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth3.png)
## Schritt 2: Erstellen der IAM-Rolle für die Verwendung durch Amazon RDS
Wenn Sie die Konsole zum Erstellen der SQL Server-DB-Instance verwenden, können Sie diesen Schritt überspringen. Wenn Sie zum Erstellen der SQL Server-DB-Instance die CLI oder RDS-API verwenden, müssen Sie eine IAM-Rolle erstellen, die die verwaltete IAM-Richtlinie `AmazonRDSDirectoryServiceAccess` verwendet. Diese Rolle ermöglicht es Amazon RDS, Directory Service für Sie Anrufe an die zu tätigen.
Wenn Sie statt der AWS verwalteten `AmazonRDSDirectoryServiceAccess` Richtlinie eine benutzerdefinierte Richtlinie für den Beitritt zu einer Domain verwenden, stellen Sie sicher, dass Sie die `ds:GetAuthorizedApplicationDetails` Aktion zulassen. Diese Anforderung gilt aufgrund einer Änderung der Directory Service API ab Juli 2019.
Die folgende IAM-Richtlinie (`AmazonRDSDirectoryServiceAccess`) ermöglicht den Zugriff auf Directory Service.
**Example IAM-Richtlinie für die Bereitstellung des Zugriffs auf Directory Service**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ds:DescribeDirectories",
"ds:AuthorizeApplication",
"ds:UnauthorizeApplication",
"ds:GetAuthorizedApplicationDetails"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) und [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) in ressourcenbasierten Vertrauensbeziehungen, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.
Sie können beide globalen Bedingungskontextschlüssel verwenden und der Wert `aws:SourceArn` enthält die Konto-ID. Stellen Sie in diesen Fällen sicher, dass der Wert `aws:SourceAccount` und das Konto im Wert `aws:SourceArn` dieselbe Konto-ID verwenden, wenn sie in derselben Anweisung verwendet werden.
+ Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
+ Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.
Stellen Sie in der Vertrauensbeziehung sicher, dass Sie den globalen Bedingungskontextschlüssel `aws:SourceArn` mit dem vollständigen Amazon-Ressourcennamen (ARN) der Ressourcen verwenden, die auf die Rolle zugreifen. Stellen Sie für die Windows-Authentifizierung sicher, dass Sie die DB-Instances einschließen, wie im folgenden Beispiel gezeigt.
**Example Vertrauensbeziehung mit dem globalen Bedingungskontextschlüssel für die Windows-Authentifizierung**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn": [
"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
]
}
}
}
]
}
```
Erstellen Sie eine IAM-Rolle mit dieser IAM-Richtlinie und Vertrauensbeziehung. Weitere Informationen zum Erstellen von IAM-Rollen finden Sie unter [Erstellen von kundenverwalteten Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html#create-managed-policy-console) im *IAM-Benutzerhandbuch*.
## Schritt 3: Erstellen und Konfigurieren von Benutzern und Gruppen
Sie können Benutzer und Gruppen mit dem Tool "Active Directory-Benutzer und -Computer" erstellen. Dieses Tool ist eines der "Active Directory Domain Services"- und "Active Directory Lightweight Directory Services"-Tools. „Benutzer“ sind Einzelpersonen oder Entitäten, die Zugriff auf Ihr Verzeichnis haben. Gruppen sind sehr nützlich, um Berechtigungen zu erteilen oder zu verweigern, anstatt diese Berechtigungen für jeden einzelnen Benutzer erstellen zu müssen.
Um Benutzer und Gruppen in einem Directory Service Verzeichnis zu erstellen, müssen Sie mit einer Windows EC2-Instance verbunden sein, die Mitglied des Directory Service Verzeichnisses ist. Außerdem müssen Sie als Benutzer angemeldet sein, der über Rechte zum Erstellen von Benutzern und Gruppen verfügt. Weitere Informationen finden [Sie unter Hinzufügen von Benutzern und Gruppen (Simple AD und AWS Managed Microsoft AD)](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/creating_ad_users_and_groups.html) im *AWS Directory Service Administratorhandbuch*.
## Schritt 4: Aktivieren des VPC-übergreifenden Datenverkehrs zwischen dem Verzeichnis und der DB-Instance
Wenn Sie beabsichtigen, das Verzeichnis und die DB-Instance in derselben VPC zu platzieren, überspringen Sie diesen Schritt und fahren Sie mit for [Schritt 5: Erstellen oder Modifizieren einer SQL Server-DB-Instance](#USER_SQLServerWinAuth.SettingUp.CreateModify).
[Wenn Sie planen, das Verzeichnis und die DB-Instance unterschiedlich zu lokalisieren VPCs, konfigurieren Sie den VPC-übergreifenden Verkehr mithilfe von VPC-Peering oder Transit Gateway.AWS](https://docs.aws.amazon.com/vpc/latest/tgw/what-is-transit-gateway.html)
Das folgende Verfahren ermöglicht den Datenverkehr zwischen VPCs mithilfe von VPC-Peering. Folgen Sie den Anleitungen unter [Was ist VPC Peering?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html) im *Handbuch zu Amazon Virtual Private Cloud-Peering*.
**Aktivieren des VPC-übergreifenden Datenverkehrs mit VPC Peering**
1. Richten Sie geeignete VPC-Routing-Regeln ein, um sicherzustellen, dass Netzwerk-Datenverkehr in beide Richtungen fließen kann.
1. Stellen Sie sicher, dass die Sicherheitsgruppe der DB-Instance eingehenden Datenverkehr von der Sicherheitsgruppe des Verzeichnisses empfangen kann.
1. Stellen Sie sicher, dass keine ACL-Regel (Network Access Control List) zum Blockieren des Datenverkehrs vorhanden ist.
Wenn ein anderes AWS Konto Eigentümer des Verzeichnisses ist, müssen Sie das Verzeichnis gemeinsam nutzen.
**Um das Verzeichnis von mehreren AWS Konten gemeinsam zu nutzen**
1. *Beginnen Sie mit der gemeinsamen Nutzung des Verzeichnisses mit dem AWS Konto, unter dem die DB-Instance erstellt werden soll. Folgen Sie dazu den Anweisungen im [Administratorhandbuch unter Tutorial: Teilen Ihres AWS Managed Microsoft AD Verzeichnisses für einen nahtlosen EC2-Domänenbeitritt](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_directory_sharing.html).Directory Service *
1. Melden Sie sich mit dem Konto für die DB-Instance bei der Directory Service Konsole an und stellen Sie sicher, dass die Domain den `SHARED` Status hat, bevor Sie fortfahren.
1. Notieren Sie sich den Wert der **Verzeichnis-ID**, während Sie mit dem Konto für die DB-Instance bei der Directory Service Konsole angemeldet sind. Sie verwenden diese Verzeichnis-ID, um die DB-Instance mit der Domäne zu verbinden.
## Schritt 5: Erstellen oder Modifizieren einer SQL Server-DB-Instance
Erstellen oder ändern Sie eine SQL Server-DB-Instance 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 mit der Konsole, dem [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)CLI-Befehl oder dem Vorgang [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) RDS API eine neue SQL Server-DB-Instance.
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 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)CLI-Befehls oder der Operation [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API.
Detaillierte Anweisungen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
+ Stellen Sie mithilfe der Konsole, des CLI-Befehls -db-snapshot oder des API-Vorgangs Restore From DBSnapshot RDS eine SQL [restore-db-instance-fromServer-DB-Instance DBInstance aus einem DB-Snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) [wieder her](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html).
Detaillierte Anweisungen finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
+ Stellen Sie eine SQL Server-DB-Instance point-in-time mithilfe der Konsole, des 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) CLI oder der Operation [Restore DBInstance ToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) RDS API in einer wieder her.
Detaillierte Anweisungen finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).
Die Windows-Authentifizierung wird nur für SQL Server-DB-Instances in einer VPC unterstützt.
Damit die DB-Instance das von Ihnen erstellte Domänenverzeichnis verwenden kann, ist Folgendes erforderlich:
+ Für **Directory (Verzeichnis)** müssen Sie den Domänenbezeichner (`d-ID`) auswählen, der beim Erstellen des Verzeichnisses generiert wurde.
+ Stellen Sie sicher, dass die VPC-Sicherheitsgruppe über eine ausgehende Regel verfügt, mit der die DB-Instance mit dem Verzeichnis kommunizieren kann.
![\[Microsoft SQL Server-Windows-Authentifizierungsverzeichnis\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth1.png)
Wenn Sie den verwenden AWS CLI, sind die folgenden Parameter erforderlich, damit die DB-Instance das von Ihnen erstellte Verzeichnis verwenden kann:
+ Für den `--domain`-Parameter verwenden Sie den Domänenbezeichner (`d-ID`), der beim Erstellen des Verzeichnisses generiert wurde.
+ Verwenden Sie für den `--domain-iam-role-name`-Parameter die von Ihnen erstellte Rolle, die die verwaltete IAM-Richtlinie `AmazonRDSDirectoryServiceAccess` verwendet.
Beispielsweise ändert der folgende CLI-Befehl eine DB-Instance zur Verwendung eines Verzeichnisses.
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--domain d-ID \
--domain-iam-role-name role-name
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--domain d-ID ^
--domain-iam-role-name role-name
```
**Wichtig**
Wenn Sie eine DB-Instance zur Aktivierung der Kerberos-Authentifizierung ändern, starten Sie die DB-Instance neu, nachdem Sie die Änderung vorgenommen haben.
## Schritt 6: Erstellen von SQL Server-Anmeldungen für die Windows-Authentifizierung
Verwenden Sie die Anmeldeinformationen für den Amazon-RDS-Hauptbenutzer, 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 AWS Managed Microsoft AD Domäne verbunden ist, können Sie SQL Server-Logins und -Benutzer bereitstellen. Sie tun dies über die Active Directory-Benutzer und -Gruppen in Ihrer Domäne. Datenbankberechtigungen werden über die Standard-SQL-Server-Berechtigungen verwaltet, die für die Windows-Anmeldungen gewährt und widerrufen werden.
Damit ein Active Directory-Benutzer sich mit SQL Server authentifizieren kann, muss eine SQL Server-Windows-Anmeldung für den Benutzer oder für eine 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 Benutzer, der keine SQL Server-Anmeldung hat oder zu keiner Gruppe mit einer solchen Anmeldung gehört, kann nicht auf die SQL Server-DB-Instance zugreifen.
Die Berechtigung ALTER ANY LOGIN ist erforderlich, um eine SQL Server-Anmeldung für das Active-Directory zu erstellen. Wenn Sie mit dieser Berechtigung noch keine Anmeldungen erstellt haben, verbinden Sie sich mithilfe der SQL Server-Authentifizierung als Masterbenutzer der DB-Instance.
Führen Sie den folgenden Data Definition Language (DDL)-Befehl aus, um eine SQL Server-Anmeldung für einen Active-Directory-Benutzer oder eine entsprechende Gruppe zu erstellen.
**Anmerkung**
Geben Sie Benutzer und Gruppen unter Verwendung des Anmeldenamens von Windows 2000 im Format a `domainName\login_name`. Sie können keinen User Principle Name (UPN) im Format verwenden *`login_name`*`@`*`DomainName`*.
Sie können eine Windows-Authentifizierungsanmeldung nur auf einer Instance von RDS für SQL Server mithilfe von T-SQL-Anweisungen erstellen. Sie können SQL Server Management Studio nicht verwenden, um eine Windows-Authentifizierungsanmeldung zu erstellen.
```
USE [master]
GO
CREATE LOGIN [mydomain\myuser] FROM WINDOWS WITH DEFAULT_DATABASE = [master], DEFAULT_LANGUAGE = [us_english];
GO
```
Weitere Informationen finden Sie unter [ANMELDENAME ERSTELLEN (Transact-SQL)](https://msdn.microsoft.com/en-us/library/ms189751.aspx) in der Microsoft Developer Network-Dokumentation.
Benutzer (sowohl menschliche Benutzer als auch Anwendungen) von Ihrer Domäne können sich nun von einem über eine Domäne verbundenen Client-Computer mithilfe der Windows-Authentifizierung an der RDS-for-SQL-Server-Instance anmelden.
# Verwalten einer DB-Instance in einer Domäne
Sie können die Konsole oder die Amazon RDS-API verwenden AWS CLI, um Ihre DB-Instance und ihre Beziehung zu Ihrer Domain 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 zu versuchen, einer Domain für eine fehlgeschlagene Mitgliedschaft beizutreten, verwenden Sie den Vorgang DBInstance API [modifizieren](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) und geben Sie die Verzeichnis-ID der aktuellen 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.
+ Verwenden Sie den DBInstances API-Vorgang [Describe](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/DescribeDBInstances.html), um die Mitgliedschaft für jede DB-Instance aufzulisten.
## Grundlegendes zur Domänenmitgliedschaft
Nachdem Sie Ihre DB-Instance erstellt oder modifiziert haben, wird die Instance ein Mitglied der Domäne. Die AWS Konsole zeigt den Status der Domain-Mitgliedschaft 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**— versucht, AWS die Instance während des nächsten geplanten Wartungsfensters zu einem Mitglied der Domain zu machen.
+ **pending-removal** – Das Entfernen der Instance von der Domäne steht noch aus.
+ **pending-maintenance-removal**— versucht, AWS die Instanz während des nächsten geplanten Wartungsfensters aus der Domain 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.
# Herstellen einer Verbindung zu SQL Server mithilfe der Windows-Authentifizierung
Um sich mithilfe der Windows-Authentifizierung mit dem SQL Server zu verbinden, müssen Sie als Domänenbenutzer an einem Computer angemeldet sein, der mit einer Domäne verbunden ist. Nach dem Starten des SQL Server Management Studios wählen Sie **Windows-Authentifizierung** als Authentifizierungsart, wie im Folgenden dargestellt.
![\[Verbindung zum SQL Server mithilfe der Windows-Authentifizierung\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/WinAuth4.png)
## Wiederherstellen einer SQL Server DB-Instance und Hinzufügen zu einer Domäne
Sie können einen DB-Snapshot wiederherstellen oder eine point-in-time Wiederherstellung (PITR) für eine SQL Server-DB-Instance durchführen und sie dann einer Domäne hinzufügen. Wenn die DB-Instance wiederhergestellt wurde, modifizieren Sie die Instance, indem Sie den unter [Schritt 5: Erstellen oder Modifizieren einer SQL Server-DB-Instance](USER_SQLServerWinAuth.SettingUp.md#USER_SQLServerWinAuth.SettingUp.CreateModify) beschriebenen Prozess anwenden, um die DB-Instance einer Domäne hinzuzufügen.
# Upgrades der DB-Engine von Microsoft SQL Server
Sofern Amazon RDS eine neue Version der Datenbank-Engine unterstützt, können Sie Ihre DB-Instances auf die neue Version aktualisieren. Es gibt zwei Arten von Upgrades für SQL Server DB-Instances: Hauptversionsupgrades und Unterversionsupgrades.
*Hauptversions-Upgrades* können Datenbankänderungen enthalten, die nicht mit vorhandenen Anwendungen rückwärts kompatibel sind. Daher müssen Sie Hauptversion-Upgrades Ihrer DB-Instances *manuell* durchführen. Sie können ein Hauptversions-Upgrade starten, indem Sie Ihre DB-Instance ändern. Bevor Sie jedoch ein Hauptversionsupgrade durchführen, empfehlen wir Ihnen, das Upgrade zu testen, indem Sie die in beschriebenen Schritte ausführe [Testen eines Upgrades von RDS für SQL Server](USER_UpgradeDBInstance.SQLServer.UpgradeTesting.md).
*Unterversion-Upgrades* enthalten nur Änderungen, die mit vorhandenen Anwendungen abwärtskompatibel sind. Sie können die Unterversion für Ihre DB-Instance auf zwei Arten aktualisieren:
+ *Manuell* – Modifizieren Sie Ihre DB-Instance, um das Upgrade zu initiieren.
+ *Automatisch* – Aktivieren Sie automatische Unterversion-Upgrades für Ihre DB-Instance.
Wenn Sie automatische Unterversion-Upgrades aktivieren, aktualisiert RDS für SQL Server Ihre Datenbank-Instance automatisch während der geplanten Wartungsfenster, wenn wichtige Sicherheitsupdates in einer neueren Unterversion verfügbar sind.
Für Engine-Unterversionen nach `16.00.4120.1`, `15.00.4365.2`, `14.00.3465.1` und `13.00.6435.1` sind die folgenden Sicherheitsprotokolle standardmäßig deaktiviert:
+ `rds.tls10` (TLS-1.0-Protokoll)
+ `rds.tls11` (TLS-1.1-Protokoll)
+ `rds.rc4`(RC4 Chiffre)
+ `rds.curve25519` (Curve25519-Verschlüsselung)
+ `rds.3des168` (Triple-DES-Verschlüsselung)
Für frühere Engine-Versionen aktiviert Amazon RDS diese Sicherheitsprotokolle standardmäßig.
```
...
"ValidUpgradeTarget": [
{
"Engine": "sqlserver-se",
"EngineVersion": "14.00.3281.6.v1",
"Description": "SQL Server 2017 14.00.3281.6.v1",
"AutoUpgrade": false,
"IsMajorVersionUpgrade": false
}
...
```
Weitere Informationen zur Durchführung von Upgrades finden Sie unter [Aktualisieren einer SQL Server-DB-Instance](#USER_UpgradeDBInstance.SQLServer.Upgrading). Weitere Informationen zu unterstützten SQL Server-Versionen in Amazon RDS finden Sie unter [Amazon RDS für Microsoft SQL Server](CHAP_SQLServer.md).
Amazon RDS unterstützt auch Upgrade-Rollout-Richtlinien zur Verwaltung automatischer Upgrades kleinerer Versionen für mehrere Datenbankressourcen und AWS-Konten. Weitere Informationen finden Sie unter [Verwendung der AWS Organizations Upgrade-Rollout-Richtlinie für automatische Upgrades kleinerer Versionen](RDS.Maintenance.AMVU.UpgradeRollout.md).
**Topics**
+ [
# Hauptversion-Upgrades von RDS für SQL Server
](USER_UpgradeDBInstance.SQLServer.Major.md)
+ [
# Überlegungen zu SQL-Server-Upgrades
](USER_UpgradeDBInstance.SQLServer.Considerations.md)
+ [
# Testen eines Upgrades von RDS für SQL Server
](USER_UpgradeDBInstance.SQLServer.UpgradeTesting.md)
+ [
## Aktualisieren einer SQL Server-DB-Instance
](#USER_UpgradeDBInstance.SQLServer.Upgrading)
+ [
## Aktualisieren veralteter DB-Instances vor dem Ende des Supports
](#USER_UpgradeDBInstance.SQLServer.DeprecatedVersions)
# Hauptversion-Upgrades von RDS für SQL Server
Amazon RDS unterstützt aktuell die folgenden Hauptversion-Upgrades für eine Microsoft SQL Server-DB-Instance.
Sie können Ihre vorhandene DB-Instance auf SQL Server 2017 oder 2019 aktualisieren. Bei SQL Server 2008 ist dies allerdings nicht möglich. Wenn Sie SQL Server 2008 auf die neueste Version aktualisieren möchten, müssen Sie zunächst ein Upgrade auf eine frühere Version durchführen.
****
| Aktuelle Version | Unterstützte Upgrade-Versionen |
| --- | --- |
| SQL Server 2019 | SQL Server 2022 |
| SQL Server 2017 | SQL Server 2022 SQL Server 2019 |
| SQL Server 2016 | SQL Server 2022 SQL Server 2019 SQL Server 2017 |
Sie können eine AWS CLI-Abfrage wie das folgende Beispiel verwenden, um die verfügbaren Upgrades für eine bestimmte Version der Datenbank-Engine zu finden.
**Example**
Für Linux, macOS oder Unix:
```
aws rds describe-db-engine-versions \
--engine sqlserver-se \
--engine-version 14.00.3281.6.v1 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" \
--output table
```
Für Windows:
```
aws rds describe-db-engine-versions ^
--engine sqlserver-se ^
--engine-version 14.00.3281.6.v1 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" ^
--output table
```
Die Ausgabe zeigt, dass Sie Version 14.00.3281.6 auf die neuesten Versionen von SQL Server 2017 oder 2019 aktualisieren können.
```
--------------------------
|DescribeDBEngineVersions|
+------------------------+
| EngineVersion |
+------------------------+
| 14.00.3294.2.v1 |
| 14.00.3356.20.v1 |
| 14.00.3381.3.v1 |
| 14.00.3401.7.v1 |
| 14.00.3421.10.v1 |
| 14.00.3451.2.v1 |
| 15.00.4043.16.v1 |
| 15.00.4073.23.v1 |
| 15.00.4153.1.v1 |
| 15.00.4198.2.v1 |
| 15.00.4236.7.v1 |
+------------------------+
```
## 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.
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 2016 kompatibel ist, führen Sie folgenden Befehl aus:
```
1. ALTER DATABASE customeracct SET COMPATIBILITY_LEVEL = 130
```
# Überlegungen zu SQL-Server-Upgrades
Amazon RDS macht zwei DB-Snapshots während des Upgrades. Der erste DB-Snapshot gehört zur DB-Instance, bevor Änderungen am Upgrade vorgenommen wurden. Der zweite DB-Snapshot wird nach Abschluss des Upgrades übernommen.
**Anmerkung**
Amazon RDS nimmt nur DB-Snapshots auf, wenn Sie den Sicherungsaufbewahrungszeitraum für Ihre DB-Instance auf eine Zahl größer als 0 festgelegt haben. Informationen über das Ändern Ihres Aufbewahrungszeitraums für Backups finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
Nachdem ein Upgrade abgeschlossen ist, können Sie nicht zur vorherigen Version der Datenbank-Engine zurückkehren. Wenn Sie zur vorherigen Version zurückkehren möchten, stellen Sie den DB-Snapshot wieder her, der vor dem Upgrade erstellt wurde, um eine neue DB-Instance zu erstellen.
Während eines Unterversion- oder Hauptversion-Upgrades von SQL Server zeigen die Metriken **Freier Speicherplatz** und **Tiefe der Datenträgerwarteschlange** den Wert `-1` an. Nachdem das Upgrade abgeschlossen ist, kehren beide Metriken wieder in den Ausgangszustand zurück.
Bevor Sie Ihre SQL-Server-Instance aktualisieren, sehen Sie sich die folgenden Informationen an.
**Topics**
+ [
## Bewährte Methoden vor dem Initiieren eines Upgrades
](#USER_UpgradeDBInstance.SQLServer.BestPractices)
+ [
## Überlegungen zu Multi-AZ
](#USER_UpgradeDBInstance.SQLServer.MAZ)
+ [
## Überlegungen zu Lesereplikaten
](#USER_UpgradeDBInstance.SQLServer.readreplica)
+ [
## Überlegungen zu Optionsgruppen
](#USER_UpgradeDBInstance.SQLServer.OGPG.OG)
+ [
## Überlegungen zu Parametergruppen
](#USER_UpgradeDBInstance.SQLServer.OGPG.PG)
## Bewährte Methoden vor dem Initiieren eines Upgrades
Bevor Sie mit dem Upgrade-Prozess beginnen, sollten Sie die folgenden vorbereitenden Schritte durchführen, um eine optimale Upgrade-Leistung zu gewährleisten und potenzielle Probleme zu minimieren:
Zeit- und Workload-Management
+ Planen Sie Upgrades in Zeiträumen mit geringem Transaktionsvolumen.
+ Minimieren Sie Schreibvorgänge während des Upgrade-Zeitraums.
Dadurch kann Amazon RDS Upgrades schneller abschließen, indem die Anzahl der Transaktionsprotokoll-Backupdateien reduziert wird, die RDS beim secondary-to-primary Pairing wiederherstellen muss.
Transaktionsmanagement
+ Identifizieren und überwachen Sie lang andauernde Transaktionen.
+ Stellen Sie sicher, dass alle wichtigen Transaktionen abgeschlossen sind, bevor Sie mit dem Upgrade beginnen.
+ Vermeiden Sie lang andauernde Transaktionen während des Upgrade-Zeitraums.
Protokolldateioptimierung
Überprüfen und optimieren Sie Transaktionsprotokolldateien:
+ Verkleinern Sie übergroße Protokolldateien.
+ Reduzieren Sie Muster mit hohem Protokollverbrauch.
+ Virtuelle Protokolldateien verwalten (VLFs).
+ Sorgen Sie für ausreichend freien Speicherplatz für den normalen Betrieb.
## Überlegungen zu Multi-AZ
Amazon RDS unterstützt Multi-AZ-Bereitstellungen für DB-Instances, auf denen Microsoft SQL Server ausgeführt wird, mithilfe von SQL Server Database Mirroring (DBM) oder Always On Availability Groups (). AGs Weitere Informationen finden Sie unter [Multi-AZ-Bereitstellungen für Amazon RDS für Microsoft SQL Server](USER_SQLServerMultiAZ.md).
Wenn in einer Multi-AZ-Bereitstellung (Mirroring/AlwaysOn) ein Upgrade angefordert wird, folgt RDS einer fortlaufenden Upgrade-Strategie für die primären und sekundären Instances. Fortlaufende Upgrades sorgen dafür, dass mindestens eine Instance für Transaktionen verfügbar ist, während die sekundäre Instance aktualisiert wird. Ein Ausfall entsteht voraussichtlich nur für die Dauer eines Failovers.
Während des Upgrades entfernt RDS die sekundäre Instance aus der Multi-AZ-Konfiguration, führt ein Upgrade der sekundären Instance durch und stellt alle Transaktionsprotokoll-Backups von der primären Instance wieder her, die während der Verbindungsunterbrechung erstellt wurden. Nachdem alle Protokoll-Backups wiederhergestellt wurden, verbindet RDS die aktualisierte sekundäre mit der primären Konfiguration. Wenn alle Datenbanken synchronisiert sind, führt RDS ein Failover zur aktualisierten sekundären Instance durch. Sobald das Failover abgeschlossen ist, fährt RDS mit dem Upgrade der alten primären Instance fort, stellt alle Backups der Transaktionsprotokolle wieder her und koppelt sie mit der neuen primären Instance.
Um diese Failover-Dauer zu minimieren, empfehlen wir, den Listener-Endpunkt für AlwaysOn AGs Verfügbarkeitsgruppen zu verwenden, wenn Clientbibliotheken verwendet werden, die die Verbindungsoption in der `MultiSubnetFailover` Verbindungszeichenfolge unterstützen. Bei Verwendung des Verfügbarkeitsgruppen-Listener-Endpunkts betragen die Failover-Zeiten in der Regel weniger als 10 Sekunden. Diese Dauer beinhaltet jedoch keine zusätzliche Zeit für die Wiederherstellung nach einem Absturz.
## Überlegungen zu Lesereplikaten
Während eines Datenbankversions-Upgrades aktualisiert Amazon RDS alle Ihre Lesereplikate zusammen mit der primären DB-Instance. Amazon RDS unterstützt keine separaten Datenbankversions-Upgrades für die Lesereplikate. Weitere Informationen über Lesereplikate finden Sie unter [Arbeiten mit Read Replicas für Microsoft SQL Server in Amazon RDS](SQLServer.ReadReplicas.md).
Wenn Sie ein Datenbankversions-Upgrade der primären DB-Instance durchführen, werden alle entsprechenden Lesereplikate automatisch aktualisiert. Amazon RDS aktualisiert alle Lesereplikate gleichzeitig, bevor die primäre DB-Instance aktualisiert wird. Lesereplikate sind möglicherweise erst verfügbar, wenn das Upgrade der Datenbankversion auf der primären DB-Instance abgeschlossen ist.
## Überlegungen zu Optionsgruppen
Wenn Ihre DB-Instance eine benutzerdefinierte DB-Optionsgruppe verwendet, kann Amazon RDS in einigen Fällen Ihre DB-Instance nicht automatisch einer neuen Optionsgruppe zuweisen. Wenn Sie zum Beispiel auf eine neue Hauptversion aktualisieren, müssen Sie eine neue Optionsgruppe angeben. Wir empfehlen, dass Sie eine neue Optionsgruppe erstellen und dieser dieselben Optionen hinzufügen, die Sie in Ihrer bestehenden benutzerdefinierten Optionsgruppe hatten.
Weitere Informationen finden Sie unter [Erstellen einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create) oder [Kopieren einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Copy).
## Überlegungen zu Parametergruppen
Wenn Ihre DB-Instance eine benutzerdefinierte DB-Parametergruppe verwendet:
+ Amazon RDS startet die DB-Instance nach einem Upgrade automatisch neu.
+ In einigen Fällen kann RDS Ihrer DB-Instance nicht automatisch eine neue Parametergruppe zuweisen.
Wenn Sie zum Beispiel auf eine neue Hauptversion aktualisieren, müssen Sie eine neue Parametergruppe angeben. Wir empfehlen, dass Sie eine neue Parametergruppe erstellen und die Parameter so konfigurieren wie in Ihrer bestehenden benutzerdefinierten Parametergruppe.
Weitere Informationen finden Sie unter [Erstellen einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Creating.md) oder [Kopieren einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Copying.md).
# Testen eines Upgrades von RDS für SQL Server
Bevor Sie ein neues Hauptversions-Upgrade für Ihre DB-Instance durchführen, sollten Sie Ihre Datenbank und alle Anwendungen, die Zugriff auf die Datenbank haben, sorgfältig auf die Kompatibilität mit der neuen Version prüfen. Wir empfehlen Ihnen folgendes Vorgehen.
**Um ein Hauptversions-Upgrade zu testen**
1. Informieren Sie sich unter [Upgrade SQL Server](https://docs.microsoft.com/en-us/sql/database-engine/install-windows/upgrade-sql-server) in der Microsoft-Dokumentation über die neue Version der Datenbank-Engine, um zu prüfen, ob es Kompatibilitätsprobleme geben könnte, die sich auf Ihre Datenbank oder Ihre Anwendungen auswirken könnten:
1. Wenn Ihre DB-Instance eine benutzerdefinierte Optionsgruppe verwendet, erstellen Sie eine neue Optionsgruppe, die kompatibel mit der neuen Version ist, auf die Sie upgraden. Weitere Informationen finden Sie unter [Überlegungen zu Optionsgruppen](USER_UpgradeDBInstance.SQLServer.Considerations.md#USER_UpgradeDBInstance.SQLServer.OGPG.OG).
1. Wenn Ihre DB-Instance eine benutzerdefinierte Parametergruppe verwendet, erstellen Sie eine neue Parametergruppe, die kompatibel mit der neuen Version ist, auf die Sie upgraden. Weitere Informationen finden Sie unter [Überlegungen zu Parametergruppen](USER_UpgradeDBInstance.SQLServer.Considerations.md#USER_UpgradeDBInstance.SQLServer.OGPG.PG).
1. Erstellen Sie einen DB-Snapshot der zu aktualisierenden DB-Instance. Weitere Informationen finden Sie unter [Erstellen eines DB-Snapshots für eine DB-Instance mit Single-AZ für Amazon RDS](USER_CreateSnapshot.md).
1. Stellen Sie den DB-Snapshot wieder her, um eine neue Test-DB-Instance zu erstellen. Weitere Informationen finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
1. Ändern Sie diese neue Test-DB-Instance mit den folgenden Methoden, um sie auf die neue Version upzugraden:
+ [Konsole](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.Console)
+ [AWS CLI](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.CLI)
+ [RDS-API](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.API)
1. Beurteilen Sie den Speicherplatz, den die upgegradete Instance verwendet, um zu bestimmen, ob das Upgrade zusätzlichen Speicherplatz benötigt.
1. Führen Sie so viele Qualitätssicherungstests mit der upgegradeten DB-Instance durch, wie nötig, um sicherzustellen, dass Ihre Datenbank und Anwendung mit der neuen Version korrekt ausgeführt werden. Führen Sie alle nötigen neuen Tests aus, um die Auswirkungen von Kompatibilitätsproblemen abzuwägen, die Sie in Schritt 1 bestimmt haben. Testen Sie alle gespeicherten Prozeduren und Funktionen. Leiten Sie Testversionen Ihrer Anwendungen an die aktualisierte DB-Instance weiter.
1. Wenn alle Tests erfolgreich sind, führen Sie das Upgrade für Ihre Produktions-DB-Instance durch. Wir empfehlen, dass Sie keine Schreiboperationen auf der DB-Instance zulassen, bis Sie bestätigen können, dass alles richtig ausgeführt wird.
## Aktualisieren einer SQL Server-DB-Instance
Informationen über ein manuelles oder automatisches Upgrade einer SQL Server-DB-Instance finden Sie unter:
+ [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md)
+ [Best practices for upgrading SQL Server 2008 R2 to SQL Server 2016 on Amazon RDS für SQL Server](https://aws.amazon.com/blogs/database/best-practices-for-upgrading-sql-server-2008-r2-to-sql-server-2016-on-amazon-rds-for-sql-server/)
**Wichtig**
Wenn Sie über Snapshots verfügen, die mit verschlüsselt sind, empfehlen wir Ihnen AWS KMS, ein Upgrade zu initiieren, bevor der Support endet.
## Aktualisieren veralteter DB-Instances vor dem Ende des Supports
Wenn eine Hauptversion veraltet ist, können Sie diese nicht mehr auf neuen DB-Instances installieren. RDS versucht automatisch, ein Upgrade für alle vorhandenen DB-Instances durchzuführen.
Wenn Sie eine veraltete DB-Instance wiederherstellen müssen, können Sie eine point-in-time Wiederherstellung (PITR) durchführen oder einen Snapshot wiederherstellen. Dadurch erhalten Sie vorübergehend Zugriff auf eine DB-Instance, die die veraltete Version verwendet. Wenn eine Hauptversion jedoch komplett veraltet ist, werden diese DB-Instances automatisch auf eine unterstützte Version aktualisiert.
# Arbeiten mit Speicher in RDS für SQL Server
Mit RDS for SQL Server können Sie Ihrer RDS for SQL Server-Instanz bis zu drei zusätzliche Volumes hinzufügen, die jeweils einem eindeutigen Windows-Laufwerksbuchstaben zugeordnet sind. Auf diese Weise können Sie Datenbankdateien über das `D:` Standardlaufwerk hinaus auf mehrere Volumes verteilen. Wenn Sie ein Speichervolume hinzufügen, erhalten Sie mehr Flexibilität bei der Verwaltung von Datenbankdateien und der Speicheroptimierung.
Zu den Vorteilen gehören:
+ **Flexible Dateiverteilung** — Verteilen Sie Datenbankdaten- und Protokolldateien auf mehrere Volumes, um die I/O-Leistung zu verbessern.
+ **Speicheroptimierung** — Verwenden Sie unterschiedliche Speichertypen und Konfigurationen für unterschiedliche Workload-Anforderungen.
+ **Skalierbarkeit** — Fügen Sie Speicherkapazität hinzu, ohne bestehende Volumes zu ändern.
**Topics**
+ [
## Überlegungen zur Verwendung zusätzlicher Speichervolumes mit RDS für SQL Server
](#SQLServer.ASV.Considerations)
+ [
## Mit RDS for SQL Server können Sie Speichervolumes hinzufügen, entfernen oder ändern
](#SQLServer.ASV.Management)
+ [
## Stellen Sie Vorgänge für zusätzliche Speichervolumes mit RDS für SQL Server wieder her
](#SQLServer.ASV.Restore)
+ [
## Anwendungsfälle für zusätzliche Speichervolumes mit RDS für SQL Server
](#SQLServer.ASV.UseCases)
## Überlegungen zur Verwendung zusätzlicher Speichervolumes mit RDS für SQL Server
Beachten Sie die folgenden Funktionen und Einschränkungen, wenn Sie zusätzliche Speichervolumes mit RDS für SQL Server verwenden:
+ Sie können Speichervolumes nur in SQL Server Standard Edition (SE), Enterprise Edition (EE) und Developer Edition (DEV-EE) hinzufügen.
+ Sie können bis zu 3 zusätzliche Speichervolumes pro Instanz hinzufügen.
+ Datenträgernamen werden den Windows-Laufwerksbuchstaben automatisch wie folgt zugeordnet:
+ `rdsdbdata2`— Laufwerk `H:`
+ `rdsdbdata3`— `I:` fahren
+ `rdsdbdata4`— `J:` fahren
+ TempDB-Dateien verwenden das `T:` Laufwerk weiterhin, wenn sie den NVMe Instanzspeicher verwenden. SQL Server-Audit-Dateien und Microsoft Business Intelligence (MSBI) -Dateien verbleiben auf dem `D:` Laufwerk.
+ Sie können nur die Speichertypen General Purpose SSD (gp3) und Provisioned IOPS SSD (io2) hinzufügen.
+ Die Mindestspeichergröße für zusätzliche Speichervolumes entspricht dem für das Standardlaufwerk festgelegten Grenzwert. `D:` Die maximale Speichergröße für Ihre DB-Instance beträgt insgesamt 256 TiB für alle Volumes.
+ Das Hinzufügen von Speicher-Volumes zu Instances mit Read Replicas oder zu Read Replica-Instances wird nicht unterstützt.
+ Das Hinzufügen von Speichervolumes zu Instanzen, die für regionsübergreifendes automatisiertes Backup aktiviert sind, wird nicht unterstützt.
+ Die Konfiguration zusätzlicher Speichervolumes für die automatische Speicherskalierung wird nicht unterstützt.
+ Das Verschieben von Dateien zwischen Volumes nach der Erstellung wird nicht unterstützt.
+ Sie können das `D:` Volume nicht löschen, aber Sie können andere Speichervolumes löschen, solange sie leer sind.
+ Das Ändern der Größe vorhandener Volumes während der Wiederherstellung oder point-in-time Wiederherstellung von Snapshots (PITR) wird nicht unterstützt. Sie können jedoch während der Wiederherstellung neue Speichervolumes hinzufügen.
## Mit RDS for SQL Server können Sie Speichervolumes hinzufügen, entfernen oder ändern
Mit der Taste AWS CLI oder können Sie zusätzliche Speichervolumes hinzufügen, ändern und entfernen AWS-Managementkonsole. Alle Operationen verwenden die `modify-db-instance` API-Operation mit dem `additional-storage-volumes` Parameter.
**Wichtig**
Wenn Sie zusätzliche Speichervolumes hinzufügen oder entfernen, wird die Aktion „Backup ausstehend“ angezeigt und es wird ein Sperrfenster für die point-in-time Wiederherstellung angezeigt. Dieses Fenster wird geschlossen, wenn der Backup-Workflow abgeschlossen ist.
**Topics**
+ [
### Hinzufügen von Speichervolumes
](#SQLServer.ASV.Adding)
+ [
### Skalierung zusätzlicher Speichervolumes
](#SQLServer.ASV.Scaling)
+ [
### Zusätzliche Speichervolumes werden entfernt
](#SQLServer.ASV.Removing)
### Hinzufügen von Speichervolumes
Sie können bis zu drei Speichervolumes über das `D:` Standardlaufwerk hinaus hinzufügen. Um Ihrer RDS for SQL Server-Instanz ein neues Speichervolume hinzuzufügen, verwenden Sie den `modify-db-instance` Befehl mit dem `additional-storage-volumes` Parameter.
Im folgenden Beispiel wird ein neues 4.000 GiB General Purpose SSD (GP3) -Volume mit dem Namen `rdsdbdata4` hinzugefügt.
```
aws rds modify-db-instance \
--db-instance-identifier my-sql-server-instance \
--region us-east-1 \
--additional-storage-volumes '[{"VolumeName":"rdsdbdata4","StorageType":"gp3","AllocatedStorage":4000}]' \
--apply-immediately
```
### Skalierung zusätzlicher Speichervolumes
Sie können jede Speichereinstellung für Ihre zusätzlichen Volumes ändern, mit Ausnahme der Speichergröße. Im folgenden Beispiel wird die IOPS-Einstellung für das `rdsdbdata2` Volume geändert.
```
aws rds modify-db-instance \
--db-instance-identifier my-sql-server-instance \
--region us-east-1 \
--additional-storage-volumes '[{"VolumeName":"rdsdbdata2","IOPS":4000}]' \
--apply-immediately
```
### Zusätzliche Speichervolumes werden entfernt
Sie können das `D:` Volume nicht löschen, aber Sie können andere Speichervolumes löschen, wenn sie leer sind.
**Warnung**
Bevor Sie ein zusätzliches Speichervolume entfernen, stellen Sie sicher, dass keine Datenbankdateien auf dem Volume gespeichert sind.
Im folgenden Beispiel wird das `rdsdbdata4` Volume entfernt.
```
aws rds modify-db-instance \
--db-instance-identifier my-sql-server-instance \
--region us-east-1 \
--additional-storage-volumes '[{"VolumeName":"rdsdbdata4","SetForDelete":true}]' \
--apply-immediately
```
## Stellen Sie Vorgänge für zusätzliche Speichervolumes mit RDS für SQL Server wieder her
Wenn Sie Ihre Datenbank wiederherstellen, können Sie Speichervolumes hinzufügen. Sie können auch die Speichereinstellungen vorhandener Volumes ändern.
**Topics**
+ [
### Snapshot-Wiederherstellung
](#SQLServer.ASV.SnapshotRestore)
+ [
### Point-in-time Wiederherstellung
](#SQLServer.ASV.PITR)
+ [
### Native Datenbankwiederherstellung
](#SQLServer.ASV.NativeRestore)
### Snapshot-Wiederherstellung
Bei der Wiederherstellung aus einem Snapshot können Sie neue zusätzliche Speichervolumes hinzufügen oder die Einstellungen für IOPS, Durchsatz und Speichertyp vorhandener Volumes ändern.
Das folgende Beispiel stellt eine DB-Instance aus einem Snapshot wieder her und ändert die IOPS-Einstellung für das Volume: `rdsdbdata2`
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier my-restored-instance \
--db-snapshot-identifier my-snapshot \
--region us-east-1 \
--additional-storage-volumes '[{"VolumeName":"rdsdbdata2","IOPS":5000}]'
```
### Point-in-time Wiederherstellung
Während der point-in-time Wiederherstellung (PITR) können Sie neue zusätzliche Speichervolumes mit benutzerdefinierten Konfigurationen hinzufügen.
Im folgenden Beispiel wird PITR ausgeführt und ein neues 5.000 GiB General Purpose SSD (gp3) -Volume hinzugefügt:
```
aws rds restore-db-instance-to-point-in-time \
--source-db-instance-identifier my-source-instance \
--target-db-instance my-pitr-instance \
--use-latest-restorable-time \
--region us-east-1 \
--additional-storage-volumes '[{"VolumeName":"rdsdbdata4","StorageType":"gp3","AllocatedStorage":5000,"IOPS":5000,"StorageThroughput":200}]'
```
### Native Datenbankwiederherstellung
Sie können die `rds_restore_database` gespeicherte Prozedur verwenden, um Datenbanken auf bestimmten zusätzlichen Speichervolumes wiederherzustellen. Zwei neue Parameter unterstützen die Volumenauswahl:
**`data_file_volume`**
Gibt den Laufwerksbuchstaben für Datenbankdatendateien an
**`log_file_volume`**
Gibt den Laufwerksbuchstaben für Datenbank-Logdateien an
Im folgenden Beispiel wird eine Datenbank mit Datendateien auf dem `H:` Laufwerk und Protokolldateien auf dem `I:` Laufwerk wiederhergestellt:
```
EXEC msdb.dbo.rds_restore_database
@restore_db_name='my_database',
@s3_arn_to_restore_from='arn:aws:s3:::my-bucket/backup-file.bak',
@data_file_volume='H:',
@log_file_volume='I:';
```
Wenn Sie keine Volume-Parameter angeben oder wenn Sie das `D:` Laufwerk für beide Parameter angeben, werden die Datenbankdateien auf dem `D:` Standardlaufwerk wiederhergestellt:
```
EXEC msdb.dbo.rds_restore_database
@restore_db_name='my_database',
@s3_arn_to_restore_from='arn:aws:s3:::my-bucket/backup-file.bak';
```
## Anwendungsfälle für zusätzliche Speichervolumes mit RDS für SQL Server
Zusätzliche Speichervolumes unterstützen verschiedene Datenbankverwaltungsszenarien. In den folgenden Abschnitten werden gängige Anwendungsfälle und Implementierungsansätze beschrieben.
**Topics**
+ [
### Datenbanken auf zusätzlichen Speichervolumes erstellen
](#SQLServer.ASV.NewDatabase)
+ [
### Erweiterung der Speicherkapazität
](#SQLServer.ASV.ExtendStorage)
+ [
### Datenbanken zwischen Volumes verschieben
](#SQLServer.ASV.MoveDatabase)
+ [
### Archivierung von Daten auf kostengünstigem Speicher
](#SQLServer.ASV.ArchiveData)
### Datenbanken auf zusätzlichen Speichervolumes erstellen
Mithilfe von Standard-SQL `CREATE DATABASE` Server-Anweisungen können Sie neue Datenbanken direkt auf zusätzlichen Speichervolumes erstellen.
Im folgenden Beispiel wird eine Datenbank mit Datendateien auf dem `H:` Laufwerk und Protokolldateien auf dem `I:` Laufwerk erstellt:
```
CREATE DATABASE MyDatabase
ON (
NAME = 'MyDatabase_Data',
FILENAME = 'H:\rdsdbdata\data\MyDatabase_Data.mdf',
SIZE = 100MB,
FILEGROWTH = 10MB
)
LOG ON (
NAME = 'MyDatabase_Log',
FILENAME = 'I:\rdsdbdata\data\MyDatabase_Log.ldf',
SIZE = 10MB,
FILEGROWTH = 10%
);
```
### Erweiterung der Speicherkapazität
Wenn das `D:` Standardlaufwerk seine maximale Kapazität erreicht hat, können Sie zusätzliche Speichervolumes hinzufügen, vorhandene Volumes skalieren und neue Daten- oder Protokolldateien auf den neuen Volumes erstellen.
**Um die Speicherkapazität zu erweitern**
1. Fügen Sie Ihrer Instance mithilfe des `modify-db-instance` Befehls ein Speicher-Volume hinzu.
1. Fügen Sie dem zusätzlichen Speichervolume eine neue Datendatei hinzu:
```
ALTER DATABASE MyDatabase
ADD FILE (
NAME = 'MyDatabase_Data2',
FILENAME = 'H:\rdsdbdata\data\MyDatabase_Data2.ndf',
SIZE = 500MB,
FILEGROWTH = 50MB
);
```
### Datenbanken zwischen Volumes verschieben
Um eine Datenbank auf ein anderes Volume zu verschieben, verwenden Sie den Sicherungs- und Wiederherstellungsansatz mit den `rds_backup_database` und `rds_restore_database` gespeicherten Prozeduren. Weitere Informationen finden Sie unter [Verwenden nativer Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Using.md).
**Um eine Datenbank auf ein anderes Volume zu verschieben**
1. Erstellen Sie eine Sicherungskopie der Datenbank mit`rds_backup_database`:
```
EXEC msdb.dbo.rds_backup_database
@source_db_name='MyDatabase',
@s3_arn_to_backup_to='arn:aws:s3:::my-bucket/database-backup.bak';
```
1. Stellen Sie die Datenbank auf dem Zielvolume wieder her:
```
EXEC msdb.dbo.rds_restore_database
@restore_db_name='MyDatabase_New',
@s3_arn_to_restore_from='arn:aws:s3:::my-bucket/database-backup.bak',
@data_file_volume='H:',
@log_file_volume='I:';
```
1. Löschen Sie die Datenbank von Ihrem alten Laufwerk, um den Speicherplatz freizugeben. Weitere Informationen finden Sie unter [Verwerfen einer Datenbank in einer DB-Instance in Amazon RDS für Microsoft SQL Server](Appendix.SQLServer.CommonDBATasks.DropMirrorDB.md).
### Archivierung von Daten auf kostengünstigem Speicher
Bei partitionierten Tabellen können Sie ältere Daten auf zusätzlichen Speichervolumes mit unterschiedlichen Leistungsmerkmalen archivieren.
**Um partitionierte Daten zu archivieren**
1. Fügen Sie ein Speichervolume mit dem entsprechenden Speichertyp und der entsprechenden Kapazität hinzu.
1. Erstellen Sie eine neue Dateigruppe auf dem zusätzlichen Speichervolume:
```
ALTER DATABASE MyDatabase
ADD FILEGROUP ArchiveFileGroup;
ALTER DATABASE MyDatabase
ADD FILE (
NAME = 'Archive_Data',
FILENAME = 'H:\rdsdbdata\data\Archive_Data.ndf',
SIZE = 1GB,
FILEGROWTH = 100MB
) TO FILEGROUP ArchiveFileGroup;
```
1. Verschieben Sie Partitionen mithilfe von SQL Server-Partitionsverwaltungsbefehlen in die neue Dateigruppe.
# Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung
Amazon RDS unterstützt native Backups und Wiederherstellungen für Microsoft SQL Server-Datenbanken unter Verwendung von vollständigen Sicherungsdateien (.bak-Dateien). Bei RDS greifen Sie auf in Amazon S3 gespeicherte Daten zu, anstatt das lokale Datensystem des Datenbankservers zu nutzen.
Beispielsweise können Sie auf Ihrem lokalen Server ein vollständiges Backup erstellen, dieses in S3 speichern und anschließend in einer verfügbaren Amazon-RDS-DB-Instance wiederherstellen. Ebenso können Sie über RDS Backups erstellen, in S3 speichern und dann dort wiederherstellen, wo Sie dies möchten.
Native Sicherung und Wiederherstellung sind in allen AWS Regionen für Single-AZ- und Multi-AZ-DB-Instances verfügbar, einschließlich Multi-AZ-DB-Instances mit Read Replicas. Native Backups und Wiederherstellungen sind für alle in Amazon RDS unterstützten Versionen von Microsoft SQL Server verfügbar.
Das folgende Diagramm veranschaulicht die unterstützten Szenarien.
![\[Architektur für native Backups und Wiederherstellungen\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQL-bak-file.png)
Die Verwendung nativer .bak-Dateien ist i. d. R. die schnellste Methode zum Sichern und Wiederherstellen von Datenbanken. Es gibt viele zusätzliche Vorteile bei der Verwendung nativer Backups und Wiederherstellungen. Sie können z. B. Folgendes tun:
+ Migrieren von Datenbanken zu oder aus Amazon RDS
+ Verschieben von Datenbanken zwischen RDS für SQL Server DB-Instances
+ Migrieren von Daten, Schemata, gespeicherten Prozeduren, Auslösern und anderem Datenbankcode in .bak-Dateien.
+ Einzelne Datenbanken anstelle von ganzen DB-Instances sichern und wiederherstellen
+ Erstellen Sie Kopien von Datenbanken zu Entwicklungs-, Test-, Trainings- und Demozwecken.
+ Speichern und übertragen Sie Sicherungsdateien mit Amazon S3, um zusätzlichen Schutz für die Notfallwiederherstellung zu gewährleisten.
+ Erstellen Sie native Backups von Datenbanken mit aktivierter TDE (Transparent Data Encryption) und stellen Sie diese Backups in lokalen Datenbanken wieder her. Weitere Informationen finden Sie unter [Unterstützung für transparente Datenverschlüsselung in SQL Server](Appendix.SQLServer.Options.TDE.md).
+ Stellen Sie native Backups von lokalen Datenbanken, deren TDE-Verschlüsselung aktiviert ist, auf DB-Instances von RDS für SQL Server wieder her. Weitere Informationen finden Sie unter [Unterstützung für transparente Datenverschlüsselung in SQL Server](Appendix.SQLServer.Options.TDE.md).
**Contents**
+ [
## Einschränkungen und Empfehlungen
](#SQLServer.Procedural.Importing.Native.Limitations)
+ [
# Einrichtung für native Backups und Wiederherstellungen
](SQLServer.Procedural.Importing.Native.Enabling.md)
+ [
## Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen
](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [
# Verwenden nativer Backups und Wiederherstellungen
](SQLServer.Procedural.Importing.Native.Using.md)
+ [
## Sichern einer Datenbank
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Examples)
+ [
## Wiederherstellen einer Datenbank
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Examples)
+ [
## Wiederherstellen eines Protokolls
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Examples)
+ [
## Abschluss einer Datenbankwiederherstellung
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore.Syntax)
+ [
## Arbeiten mit teilweise wiederhergestellten Datenbanken
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [
### Verwerfen einer teilweise wiederhergestellten Datenbank
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Drop.Partially.Restored)
+ [
### Snapshot-Wiederherstellung und point-in-time Wiederherstellungsverhalten für teilweise wiederhergestellte Datenbanken
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Snapshot.Restore)
+ [
## Abbrechen einer Aufgabe
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Cancel.Syntax)
+ [
## Verfolgen des Status von Aufgaben
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Examples)
+ [
### Antwort
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Response)
+ [
# Komprimieren von Sicherungsdateien
](SQLServer.Procedural.Importing.Native.Compression.md)
+ [
# Fehlerbehebung
](SQLServer.Procedural.Importing.Native.Troubleshooting.md)
+ [
# Importieren und Exportieren von SQL Server-Daten mithilfe anderer Methoden
](SQLServer.Procedural.Importing.Snapshots.md)
+ [
## Importieren von Daten in RDS für SQL Server mithilfe eines Snapshots
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Importing.Procedure)
+ [
### Importieren der Daten
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.Import)
+ [
#### Assistent für das Generieren und Veröffentlichen von Skripts
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ScriptWizard)
+ [
#### Assistent für den Import und Export
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ImportExportWizard)
+ [
#### Bulk-Kopie
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.BulkCopy)
+ [
## Exportieren von Daten aus RDS für SQL Server
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting)
+ [
### SQL Server-Assistent für Import und Export (SQL Server Import and Export Wizard)
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSIEW)
+ [
### SQL Server-Assistent für das Generieren und Veröffentlichen von Skripts und Hilfsprogramm bcp
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSGPSW)
+ [
# Verwenden des BCP-Dienstprogramms von Linux zum Importieren und Exportieren von Daten
](SQLServer.Procedural.Importing.BCP.Linux.md)
+ [
## Voraussetzungen
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Prerequisites)
+ [
## Installieren der Befehlszeilen-Tools von SQL Server unter Linux
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Installing)
+ [
## Exportieren von Daten aus RDS für SQL Server
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting)
+ [
### Grundlegende Syntax für den Export
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Basic)
+ [
### Exportbeispiel
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Example)
+ [
## Importieren von Daten in RDS für SQL Server
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing)
+ [
### Grundlegende Syntax für den Import
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Basic)
+ [
### Importbeispiel
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Example)
+ [
## Allgemeine BCP-Optionen
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Options)
+ [
## Bewährte Methoden und Überlegungen
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.BestPractices)
+ [
## Behebung häufiger Probleme
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Troubleshooting)
## Einschränkungen und Empfehlungen
Folgende Einschränkungen gelten bei der Verwendung nativer Backups und Wiederherstellungen:
+ Sie können keine Backups in einem Amazon S3-Bucket in einer anderen AWS Region als Ihrer Amazon RDS-DB-Instance erstellen oder aus einem solchen Bucket wiederherstellen.
+ Sie können eine Datenbank nicht mit dem gleichen Namen wie eine vorhandene Datenbank wiederherstellen. Die Namen der Datenbank sind eindeutig.
+ Es wird dringend davon abgeraten, Backups aus einer Zeitzone für eine andere Zeitzone wiederherzustellen. Wenn Sie Backups aus einer bestimmten Zeitzone in einer anderen Zeitzone wiederherstellen, müssen Sie Ihre Abfragen und Anwendungen auf mögliche Auswirkungen der Zeitzonenänderung überprüfen.
+ RDS für Microsoft SQL Server hat eine Größenbeschränkung von 5 TB pro Datei. Für systemeigene Backups größerer Datenbanken können Sie Multidatei-Backups verwenden.
+ Die maximale Datenbankgröße, die zu S3 gesichert werden kann, hängt vom verfügbaren Arbeitsspeicher, der CPU, der I/O-Leistung und den Netzwerkressourcen der DB-Instance ab. Je größer die Datenbank ist, umso mehr Speicher verbraucht der Sicherungsagent.
+ Sie können gleichzeitig in nicht mehr als 10 Sicherungsdateien sichern oder aus ihnen wiederherstellen.
+ Ein differentielles Backup basiert auf dem letzten vollständigen Backup. Damit differentielle Backups funktionieren, darf kein Snapshot zwischen dem letzten vollständigen Backup und dem differentiellen Backup aufgenommen werden. Wenn Sie ein differentielles Backup erstellen möchten, aber ein manueller oder automatisierter Snapshot vorhanden ist, erstellen Sie ein weiteres vollständiges Backup, bevor Sie mit dem differentiellen Backup fortfahren.
+ Differenzielle und Protokollwiederherstellungen werden für Datenbanken mit Dateien, deren file\$1guid (eindeutige ID) auf eingestellt ist, nicht unterstütz `NULL`.
+ Sie können bis zu zwei Backup- oder Wiederherstellungsaufgaben gleichzeitig ausführen.
+ Sie können keine systemeigenen Protokollsicherungen von SQL Server auf Amazon RDS ausführen.
+ RDS unterstützt native Wiederherstellungen von Datenbanken mit einer Größe bis zu 64 TiB. Native Wiederherstellungen von Datenbanken auf SQL Server Express Edition sind auf 10 GB beschränkt.
+ Ein natives Backup der Datenbank ist nicht möglich während des Wartungsfensters bzw. während Amazon RDS einen Snapshot der Datenbank aufnimmt. Wenn sich eine native Sicherungsaufgabe mit dem täglichen RDS-Sicherungsfenster überschneidet, wird die native Sicherungsaufgabe abgebrochen.
+ Bei Multi-AZ-DB-Instances können Sie nur Datenbanken nativ wiederherstellen, die im vollständigen Wiederherstellungsmodell gesichert wurden.
+ Das Aufrufen der RDS-Verfahren zu nativen Backups und Wiederherstellungen innerhalb einer Transaktion wird nicht unterstützt.
+ Verwenden Sie eine symmetrische Verschlüsselung AWS KMS key , um Ihre Backups zu verschlüsseln. Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
+ Native Backup-Dateien werden mit dem angegebenen KMS-Schlüssel unter Verwendung des Verschlüsselungsmodus "Encryption-Only" verschlüsselt. Bei der Wiederherstellung verschlüsselter Sicherheitsdateien sollten Sie stets bedenken, dass diese Dateien mit dem Krypto-Modus "Nur Verschlüsselung" verschlüsselt wurden.
+ Eine Datenbank, die eine FILESTREAM-Dateigruppe enthält, kann nicht wiederhergestellt werden.
+ Die serverseitige Amazon S3 S3-Verschlüsselung mit AWS KMS (SSE-KMS) wird durch die Standardverschlüsselungskonfiguration Ihres S3-Buckets unterstützt, wenn Sie `@enable_bucket_default_encryption=1` zur gespeicherten Backup-Prozedur übergehen. Standardmäßig unterstützt die Wiederherstellung die serverseitige Verschlüsselung des S3-Objekts.
Wenn Sie einen KMS-Schlüssel für eine gespeicherte Prozedur bereitstellen, werden alle systemeigenen Sicherungen und Wiederherstellungen auf der Clientseite mit dem KMS-Schlüssel ver- und entschlüsselt. AWS speichert die Backups im S3-Bucket mit SSE-S3, wenn, `@enable_bucket_default_encryption=0` oder mit dem konfigurierten Standardverschlüsselungsschlüssel Ihres S3-Buckets, wenn. `@enable_bucket_default_encryption=1`
+ Bei Verwendung von S3 Access Points kann der Access Point nicht für die Verwendung einer internen RDS-VPC konfiguriert werden.
+ Für eine optimale Leistung empfehlen wir die Verwendung von Directory-Buckets oder Access Points für Directory-Buckets, sofern diese in Ihrer Region verfügbar sind.
Wenn Ihre Datenbank beim Anlegen, Kopieren und Wiederherstellen der Sicherungsdatei offline sein kann, empfehlen wir, Ihre Datenbank mithilfe nativer Backups und Wiederherstellungen zu RDS zu migrieren, Wenn Ihre lokale Datenbank nicht offline sein kann, empfehlen wir Ihnen, die zu verwenden, um Ihre Datenbank AWS Database Migration Service zu Amazon RDS zu migrieren. Weitere Informationen finden Sie unter [Was ist AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Native Backups und Wiederherstellungen sind nicht als Ersatz für die Datenwiederherstellungsfunktionen der regionsübergreifenden Snapshot-Kopierfunktion gedacht. Wir empfehlen Ihnen, Snapshot Copy zu verwenden, um Ihren Datenbank-Snapshot für die regionsübergreifende Notfallwiederherstellung in Amazon RDS in eine andere AWS Region zu kopieren. Weitere Informationen finden Sie unter [Kopieren eines DB-Snapshots für Amazon RDS](USER_CopySnapshot.md).
# Einrichtung für native Backups und Wiederherstellungen
Zum Einrichten nativer Backup und Wiederherstellungen benötigen Sie drei Komponenten:
1. Einen Amazon S3-Bucket zum Speichern Ihrer Sicherungsdateien
Sie müssen für Ihre Sicherungsdateien einen S3-Bucket verwenden und dann die Backups hochladen, die Sie zu RDS migrieren möchten. Wenn Sie bereits über einen Amazon S3-Bucket verfügen, können Sie diesen verwenden. Andernfalls können Sie [einen Bucket erstellen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html). Alternativ können Sie wählen, dass ein neuer Bucket für Sie erstellt wird, wenn Sie die Option `SQLSERVER_BACKUP_RESTORE` mithilfe der AWS-Managementkonsole hinzufügen.
Weitere Informationen zur Verwendung von S3 finden Sie im [Benutzerhandbuch für Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/).
1. Eine AWS Identity and Access Management (IAM-) Rolle für den Zugriff auf den Bucket.
Wenn Sie bereits über eine IAM-Rolle verfügen, können Sie diese verwenden. Alternativ können Sie wählen, dass eine neue IAM-Rolle für Sie erstellt wird, wenn Sie die Option `SQLSERVER_BACKUP_RESTORE` mithilfe der AWS-Managementkonsole hinzufügen. Alternativ können Sie manuell eine neue Rolle erstellen.
Wenn Sie eine neue IAM-Rolle manuell erstellen möchten, verwenden Sie die Methode, die im nächsten Abschnitt besprochen wird. Führen Sie dasselbe aus, wenn Sie einer vorhandenen IAM-Rolle Vertrauensstellungen und Berechtigungsrichtlinien zuordnen möchten.
1. Die Option `SQLSERVER_BACKUP_RESTORE` in einer Optionsgruppe auf Ihrer DB-Instance
Zur Aktivierung nativer Backups und Wiederherstellungen auf Ihrer DB-Instance fügen Sie einer Optionsgruppe auf Ihrer DB-Instance die Option `SQLSERVER_BACKUP_RESTORE` hinzu. Weitere Informationen und Anweisungen finden Sie unter [Unterstützung für native Sicherung und Backup in SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
## Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen
Wenn Sie manuell eine neue IAM-Rolle zur Verwendung mit nativen Backups und Wiederherstellungen erstellen möchten, ist dies möglich. In diesem Fall erstellen Sie eine Rolle für die Delegierung der Berechtigungen vom Amazon-RDS-Service zu Ihrem Amazon S3-Bucket. Wenn Sie eine IAM-Rolle erstellen, fügen Sie eine Vertrauensstellung und eine Berechtigungsrichtlinie an. Die Vertrauensstellung ermöglicht es RDS, diese Rolle zu übernehmen. Die Berechtigungsrichtlinie definiert die Aktionen, die über diese Rolle ausgeführt werden können. Weitere Informationen zum Erstellen der Rolle finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS -Service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html).
Für die Funktion zu nativen Backups und Wiederherstellungen verwenden Sie ähnliche Vertrauensbeziehungen und Berechtigungsrichtlinien wie in den in diesem Abschnitt gezeigten Beispielen. Im folgenden Beispiel wird der Service-Prinzipalname `rds.amazonaws.com` als Alias für alle Dienstkonten verwendet. In den anderen Beispielen wird durch Angabe eines Amazon-Ressourcennamens (ARN) einem anderen Konto, einem anderen Benutzer oder einer anderen Rolle der Zugriff auf die Vertrauensrichtlinie gewährt.
Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) und [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) in ressourcenbasierten Vertrauensbeziehungen, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.
Sie können beide globalen Bedingungskontextschlüssel verwenden und der Wert `aws:SourceArn` enthält die Konto-ID. Stellen Sie in diesen Fällen sicher, dass der Wert `aws:SourceAccount` und das Konto im Wert `aws:SourceArn` dieselbe Konto-ID verwenden, wenn sie in derselben Anweisung verwendet werden.
+ Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
+ Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.
Stellen Sie in der Vertrauensbeziehung sicher, dass Sie den globalen Bedingungskontextschlüssel `aws:SourceArn` mit dem vollständigen ARN der Ressourcen verwenden, die auf die Rolle zugreifen. Stellen Sie bei nativen Backups und Wiederherstellungen sicher, dass Sie sowohl die DB-Optionsgruppe als auch die DB-Instances einschließen, wie im folgenden Beispiel gezeigt.
**Example einer Vertrauensbeziehung mit globalem Kontextschlüssel für native Backups und Wiederherstellungen**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn": [
"arn:aws:rds:Region:0123456789:db:db_instance_identifier",
"arn:aws:rds:Region:0123456789:og:option_group_name"
],
"aws:SourceAccount": "0123456789"
}
}
}
]
}
```
Im folgenden Beispiel wird ein ARN zur Angabe einer Ressource verwendet. Weitere Informationen zur Verwendung ARNs finden Sie unter [Amazon-Ressourcennamen (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
**Example einer Berechtigungsrichtlinie für native Backups und Wiederherstellungen ohne Verschlüsselungsunterstützung**
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action":
[
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example Berechtigungsrichtlinie für native Backups und Wiederherstellungen mit Verschlüsselungsunterstützung**
Wenn Sie Ihre Sicherungsdateien verschlüsseln möchten, geben Sie in Ihrer Berechtigungsrichtlinie einen Verschlüsselungsschlüssel an. Weitere Informationen zu Verschlüsselungsschlüsseln finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) im *AWS Key Management Service -Entwicklerhandbuch*.
Sie müssen einen symmetrischen KMS-Verschlüsselungsschlüssel verwenden, um Ihre Backups zu verschlüsseln. Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
Die IAM-Rolle muss auch ein Schlüsselbenutzer und Schlüsseladministrator für den KMS-Schlüssel sein, d. h. sie muss in der Schlüsselrichtlinie angegeben werden. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToKey",
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:123456789012:key/key-id"
},
{
"Sid": "AllowAccessToS3",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Sid": "GetS3Info",
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example Berechtigungsrichtlinie für systemeigenes Backup und Wiederherstellung mithilfe von Access Points ohne Verschlüsselungsunterstützung**
Die für die Verwendung von S3-Zugriffspunkten erforderlichen Aktionen sind dieselben wie für S3-Buckets. Der Ressourcenpfad wird aktualisiert, sodass er dem ARN-Muster des S3-Zugriffspunkts entspricht.
Access Points müssen so konfiguriert sein, dass sie **Network Origin: Internet** verwenden, da RDS nicht privat veröffentlicht VPCs. S3-Verkehr von RDS-Instances wird nicht über das öffentliche Internet übertragen, da er privat abgewickelt wird VPCs.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap",
"arn:aws:s3:::underlying-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap/*",
"arn:aws:s3:::underlying-bucket/*"
]
}
]
}
```
**Example Berechtigungsrichtlinie für systemeigenes Backup und Wiederherstellung mithilfe von Zugriffspunkten für Verzeichnis-Buckets ohne Verschlüsselungsunterstützung**
Directory-Buckets verwenden einen anderen, [sitzungsbasierten Autorisierungsmechanismus](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-authenticating-authorizing.html) als Allzweck-Buckets, sodass die einzige erforderliche Berechtigung für die systemeigene Backup-Wiederherstellung die „s3express:“ -Berechtigung auf Bucket-Ebene ist. CreateSession [Um den Zugriff auf Objektebene zu konfigurieren, müssen Sie Access Points für Directory-Buckets verwenden.](https://docs.aws.amazon.com//AmazonS3/latest/userguide/access-points-directory-buckets-policies.html)
Access Points müssen so konfiguriert sein, dass sie **Network Origin: Internet** verwenden, da RDS nicht privat veröffentlicht. VPCs S3-Verkehr von RDS-Instances wird nicht über das öffentliche Internet übertragen, da er privat abgewickelt wird VPCs.
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action": "s3express:CreateSession",
"Resource":
[
"arn:aws:s3express:us-east-1:111122223333:accesspoint/amzn-s3-demo-accesspoint--use1-az6--xa-s3",
"arn:aws:s3express:us-east-1:111122223333:bucket/amzn-s3-demo-bucket--use1-az6--x-s3"
]
}
]
}
```
# Verwenden nativer Backups und Wiederherstellungen
Sobald Sie native Backups und Wiederherstellungen konfiguriert haben, können Sie mit deren Verwendung beginnen. Bauen Sie zuerst eine Verbindung zu Ihrer Microsoft SQL Server-Datenbank auf, und rufen Sie dann eine gespeicherte Amazon-RDS-Prozedur auf, um die Aufgabe zu erledigen. Anleitungen zum Herstellen einer Verbindung zu Ihrer Datenbank finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Einige der gespeicherten Prozeduren verlangen, dass Sie einen Amazon-Ressourcennamen (ARN) für Ihren Amazon S3-Bucket und die Datei angeben. Das Format für Ihren ARN lautet `arn:aws:s3:::bucket_name/file_name.extension`. Amazon S3 benötigt keine Kontonummer oder AWS Region in ARNs.
Wenn Sie auch einen optionalen KMS-Schlüssel angeben, lautet das Format für die ARN des Schlüssels `arn:aws:kms:region:account-id:key/key-id`. Weitere Informationen finden Sie unter [Amazon-Ressourcennamen (ARNs) und AWS Service-Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html). Sie müssen einen symmetrischen KMS-Verschlüsselungsschlüssel verwenden, um Ihre Backups zu verschlüsseln. Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
**Anmerkung**
Unabhängig davon, ob Sie einen KMS-Schlüssel verwenden oder nicht, ermöglichen die systemeigenen Sicherungs- und Wiederherstellungsaufgaben standardmäßig die serverseitige 256-Bit-Verschlüsselung mit Advanced Encryption Standard (AES) über SSE-S3 für auf S3 hochgeladene Dateien. Bei der Übergabe `@enable_bucket_default_encryption=1` an die gespeicherte Backup-Prozedur wird der konfigurierte Standardverschlüsselungsschlüssel Ihres S3-Buckets verwendet.
Anleitungen zum Aufrufen der einzelnen gespeicherten Prozeduren finden Sie in den folgenden Themen:
+ [Sichern einer Datenbank](#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Wiederherstellen einer Datenbank](#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Wiederherstellen eines Protokolls](#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Abschluss einer Datenbankwiederherstellung](#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Arbeiten mit teilweise wiederhergestellten Datenbanken](#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Abbrechen einer Aufgabe](#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Verfolgen des Status von Aufgaben](#SQLServer.Procedural.Importing.Native.Tracking)
## Sichern einer Datenbank
Verwenden Sie zum Sichern Ihrer Datenbank die gespeicherte Prozedur `rds_backup_database`.
**Anmerkung**
Ein Backup der Datenbank ist nicht möglich während des Wartungsfensters, oder wenn Amazon RDS gerade einen Snapshot der Datenbank erfasst.
### Usage
```
exec msdb.dbo.rds_backup_database
@source_db_name='database_name',
@s3_arn_to_backup_to='arn:aws:s3:::bucket_name/file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@overwrite_s3_backup_file=0|1],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'],
[@number_of_files=n],
[@enable_bucket_default_encryption=0|1];
```
Die folgenden Parameter sind erforderlich:
+ `@source_db_name` – Der Name der zu sichernden Datenbank.
+ `@s3_arn_to_backup_to`— Der ARN, der den Amazon S3 S3-Bucket, Access Point, Directory-Bucket oder Access Point für den Verzeichnis-Bucket angibt, der für das Backup verwendet werden soll, sowie den Namen der Backup-Datei.
Die Datei kann eine beliebige Erweiterung haben, üblicherweise wird jedoch `.bak` verwendet. Beachten Sie, dass der Access Point das folgende Format haben ARNs muss`arn:aws:s3:us-east-1:111122223333:access-point-name/object/key`.
Die folgenden Parameter sind optional:
+ `@kms_master_key_arn` – Der ARN für den symmetrischen KMS-Verschlüsselungsschlüssel, der für die Verschlüsselung des Objekts verwendet werden soll.
+ Sie können den Standard-Verschlüsselungsschlüssel nicht verwenden. Wenn Sie den Standardschlüssel verwenden, wird die Datenbank nicht gesichert.
+ Wenn Sie keine KMS-Schlüsselkennung angeben, wird die Sicherungsdatei nicht verschlüsselt. Weitere Informationen finden Sie unter [Verschlüsseln von Amazon-RDS-Ressourcen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html).
+ Wenn Sie einen KMS-Schlüssel angeben, wird eine client-seitige Verschlüsselung verwendet.
+ Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
+ `@overwrite_s3_backup_file` – Ein Wert, der angibt, ob eine vorhandene Sicherungsdatei überschrieben werden soll.
+ `0` – Eine vorhandene Datei wird nicht überschrieben. Dieser Wert ist der Standard.
Wenn Sie `@overwrite_s3_backup_file` auf 0 setzen, wird ein Fehler ausgegeben, wenn die Datei bereits vorhanden ist.
+ `1` – Eine vorhandene Datei mit dem angegebenen Namen wird überschrieben, auch wenn es sich nicht um eine Sicherungsdatei handelt.
+ `@type` – Der Typ der Backup.
+ `DIFFERENTIAL` – Erstellt eine differentielle Backup.
+ `FULL` – Erstellt eine vollständige Backup. Dieser Wert ist der Standard.
Eine differentielle Sicherung basiert auf der letzten vollständigen Sicherung. Damit differentielle Sicherungen funktionieren, darf kein Snapshot zwischen der letzten vollständigen Sicherung und der differentiellen Sicherung aufgenommen werden. Wenn Sie ein differentielles Backup erstellen wollen und ein Snapshot existiert, erstellen Sie ein weiteres vollständiges Backup, bevor Sie mit dem differentiellen Backup fortfahren.
Sie können das letzte vollständige Backup oder den Snapshot mit der folgenden Beispiel-SQL-Abfrage suchen:
```
select top 1
database_name
, backup_start_date
, backup_finish_date
from msdb.dbo.backupset
where database_name='mydatabase'
and type = 'D'
order by backup_start_date desc;
```
+ `@number_of_files` – Die Anzahl der Dateien, in die das Backup aufgeteilt wird (aufgeschlüsselt). Die maximale Anzahl ist 10.
+ Das Backup mehrerer Dateien wird sowohl für vollständige als auch für differenzielle Backups unterstützt.
+ Wenn Sie den Wert 1 eingeben oder den Parameter weglassen, wird eine einzelne Sicherungsdatei erstellt.
Geben Sie das Präfix an, das den Dateien gemeinsam ist, und danach das Suffix mit einem Sternchen (`*`). Das Sternchen kann sich an einer beliebigen *file\$1name* Stelle im S3-ARN ARN. Das Sternchen wird durch eine Reihe von alphanumerischen Zeichenfolgen in den generierten Dateien ersetzt, beginnend mit `1-of-number_of_files`.
Wenn beispielsweise die Dateinamen im S3-ARN `backup*.bak` lauten und Sie `@number_of_files=4` festlegen, sind die generierten Sicherungsdateien `backup1-of-4.bak`, `backup2-of-4.bak`, `backup3-of-4.bak` und `backup4-of-4.bak`.
+ Wenn einer der Dateinamen bereits vorhanden und `@overwrite_s3_backup_file` 0 ist, wird ein Fehler ausgegeben.
+ Backups mit mehreren Dateien können nur ein Sternchen im *file\$1name* Teil des S3-ARN haben.
+ Einzeldatei-Backups können eine beliebige Anzahl von Sternchen im *file\$1name* Teil des S3-ARN haben. Sternchen werden nicht aus dem generierten Dateinamen entfernt.
+ `@block_size` – Blockgröße (in Bytes), die die physische Blockgröße für Backup-Operationen angibt. Gültige Werte sind 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 und 65.536.
+ `@max_transfer_size`— Die maximale Übertragungsgröße gibt die Obergrenze des Datenvolumens (in Byte) an, das pro I/O Vorgang während des Backup-Vorgangs übertragen wird. Gültige Werte sind Vielfache von 65.536 Byte (64 KB) bis zu 4.194.304 Byte (4 MB).
+ `@buffer_count`— Gesamtzahl der I/O Puffer, die für den Backup-Prozess verwendet werden sollen.
+ `@enable_bucket_default_encryption`— Ein Wert, der angibt, ob die Standardverschlüsselungskonfiguration des S3-Buckets für die serverseitige Verschlüsselung in S3 verwendet werden soll. Verzeichnis-Buckets verwenden unabhängig von dieser Einstellung immer die Standard-Verschlüsselungskonfiguration des Buckets.
+ `0`— Die serverseitige Verschlüsselung verwendet die 256-Bit-Verschlüsselung des Advanced Encryption Standard (AES) über SSE-S3.
+ `1`[— Die serverseitige Verschlüsselung verwendet die konfigurierte Standardverschlüsselung Ihres S3-Buckets.](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-encryption.html)
### Beispiele
**Example für eine differenzielle Backup**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@overwrite_s3_backup_file=1,
@type='DIFFERENTIAL';
```
**Example des vollständigen Backups mit clientseitiger Verschlüsselung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example für ein Backup mehrerer Dateien**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4;
```
**Example für ein differenzielles Backup mehrerer Dateien**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@type='DIFFERENTIAL',
@number_of_files=4;
```
**Example für ein Backup mehrerer Dateien mit Verschlüsselung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@number_of_files=4;
```
**Example für ein Backup mehrerer Dateien mit S3-Überschreibung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@number_of_files=4;
```
**Example für ein Backup mit Blockgröße**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@block_size=512;
```
**Example für ein Backup mehrerer Dateien mit `@max_transfer_size` und `@buffer_count`**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4,
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example für ein Backup einer einzelnen Datei mit dem Parameter @number\$1of\$1files**
In diesem Beispiel wird eine Sicherungsdatei mit dem Namen generier `backup*.bak`.
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=1;
```
**Example des vollständigen Backups mit serverseitiger Verschlüsselung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@type='FULL',
@enable_bucket_default_encryption=1;
```
**Example der vollständigen Sicherung über einen Access Point**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example der vollständigen Sicherung mithilfe eines Zugriffspunkts für einen Verzeichnis-Bucket**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3express:us-east-1:123456789012:accesspoint/my-access-point--use1-az6--xa-s3/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
## Wiederherstellen einer Datenbank
Rufen Sie zum Wiederherstellen Ihrer Datenbank die gespeicherte Prozedur `rds_restore_database` auf. Amazon RDS erstellt einen anfänglichen Snapshot der Datenbank nach Abschluss der Wiederherstellung und wenn die Datenbank offen ist.
### Usage
```
exec msdb.dbo.rds_restore_database
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/file_name.extension',
@with_norecovery=0|1,
[@keep_cdc=0|1],
[@data_file_volume='D:|H:|I:|J:'],
[@log_file_volume='D:|H:|I:|J:'],
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'];
```
Die folgenden Parameter sind erforderlich:
+ `@restore_db_name` – Der Name der wiederherzustellenden Datenbank. Die Namen der Datenbank sind eindeutig. Sie können eine Datenbank nicht mit dem gleichen Namen wie eine vorhandene Datenbank wiederherstellen.
+ `@s3_arn_to_restore_from` – Der ARN, der das Amazon S3-Präfix und den Namen der Sicherungsdateien anzeigt, die zum Wiederherstellen der Datenbank verwendet werden.
+ Geben Sie für das Backup einer einzelnen Datei den gesamten Dateinamen an.
+ Geben Sie für das Backup mehrerer Dateien das Präfix an, das den Dateien gemeinsam ist, und danach das Suffix mit einem Sternchen (`*`).
+ Wenn Sie einen Verzeichnis-Bucket verwenden, muss der ARN `/*` aufgrund von [Unterschieden für Verzeichnis-Buckets](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-differences.html) mit enden.
+ Wenn `@s3_arn_to_restore_from` leer ist, wird die folgende Fehlermeldung ausgegeben: S3 ARN prefix cannot be empty (Präfix des S3-ARN kann nicht leer sein).
Der folgende Parameter ist für differentielle Wiederherstellungen erforderlich, für vollständige Wiederherstellungen jedoch optional.
+ `@with_norecovery` – Die für die Wiederherstellungsoperation zu verwendende Wiederherstellungsklausel.
+ Setzen Sie sie für die Wiederherstellung mit RECOVERY auf `0`. In diesem Fall ist die Datenbank nach der Wiederherstellung online.
+ Setzen Sie sie für die Wiederherstellung mit NORECOVERY auf `1`. In diesem Fall verbleibt die Datenbank nach dem Abschluss der Wiederherstellungsaufgabe im Status RESTORING. Diese Vorgehensweise erlaubt spätere differentielle Wiederherstellungen.
+ Geben Sie für DIFFERENTIELLE Wiederherstellungen `0` oder `1` an.
+ Für `FULL`-Wiederherstellungen ist dieser Wert standardmäßig `0`.
Die folgenden Parameter sind optional:
+ `@keep_cdc`— Gibt an, ob die CDC-Konfiguration (Change Data Capture) in der wiederhergestellten Datenbank beibehalten werden soll. Wird auf gesetzt, `1` um KEEP\$1CDC zu aktivieren, um es zu deaktivieren. `0` Der Standardwert ist `0`.
+ `@data_file_volume`— Gibt den Laufwerksbuchstaben für Datenbankdatendateien an. Der Standardwert ist `D:`.
+ `@log_file_volume`— Gibt den Laufwerksbuchstaben für Datenbank-Logdateien an. Der Standardwert ist`D:`.
+ `@kms_master_key_arn` – Wenn Sie die Sicherungsdatei verschlüsselt haben, den KMS-Schlüssel, der zum Entschlüsseln der Datei verwendet werden soll.
Wenn Sie einen KMS-Schlüssel angeben, wird eine client-seitige Verschlüsselung verwendet.
+ `@type` – Der Typ der Wiederherstellung. Gültige Typen sind `DIFFERENTIAL` und `FULL`. Der Standardwert ist `FULL`.
+ `@block_size` – Blockgröße (in Bytes), die die physische Blockgröße für Backup-Operationen angibt. Gültige Werte sind 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 und 65.536.
+ `@max_transfer_size`— Die maximale Übertragungsgröße gibt die Obergrenze des Datenvolumens (in Byte) an, das pro I/O Vorgang während des Sicherungsvorgangs übertragen wird. Gültige Werte sind Vielfache von 65.536 Byte (64 KB) bis zu 4.194.304 Byte (4 MB).
+ `@buffer_count`— Gesamtzahl der I/O Puffer, die für den Backup-Prozess verwendet werden sollen.
**Anmerkung**
Bei differentiellen Wiederherstellungen muss sich die Datenbank entweder im Status RESTORING befinden, oder es muss bereits eine Aufgabe existieren, die mit NORECOVERY wiederherstellt.
Sie können differentielle Backups nicht später wiederherstellen, während die Datenbank online ist.
Sie können keine Wiederherstellungsaufgabe für eine Datenbank absenden, für die bereits eine Wiederherstellungsaufgabe mit RECOVERY aussteht.
Vollständige Wiederherstellungen mit NORECOVERY und KEEP\$1CDC werden nicht unterstützt.
Alle systemeigenen Wiederherstellungen werden auf Instances mit regionsübergreifenden Read Replicas nicht unterstützt.
Bei unterstützten Konfigurationen ist das Wiederherstellen einer Datenbank auf einer Multi-AZ-Instance mit Lesereplikaten mit dem Wiederherstellen einer Datenbank auf einer Multi-AZ-Instance vergleichbar. Sie müssen keine zusätzlichen Aktionen ausführen, um eine Datenbank auf einem Replikat wiederherzustellen.
### Beispiele
**Example für die Wiederherstellung einer einzelnen Datei**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
**Example für die Wiederherstellung mehrerer Dateien**
Um Fehler beim Wiederherstellen mehrerer Dateien zu vermeiden, stellen Sie sicher, dass alle Sicherungsdateien dasselbe Präfix haben, und dass dieses Präfix von keinen anderen Dateien verwendet wird.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*';
```
**Example für eine vollständige Datenbankwiederherstellung mit RECOVERY**
Die folgenden drei Beispiele führen die gleiche Aufgabe durch, vollständige Wiederherstellung mit RECOVERY.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
[@type='DIFFERENTIAL|FULL'];
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=0;
```
**Example für eine vollständige Datenbankwiederherstellung mit Verschlüsselung**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example für eine Wiederherstellung mit Blockgröße**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@block_size=512;
```
**Example für eine Wiederherstellung mehrerer Dateien mit @max\$1transfer\$1size und @buffer\$1count**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*',
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example für eine vollständige Datenbankwiederherstellung mit NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=1;
```
**Example für eine differenzielle Wiederherstellung mit NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=1;
```
**Example für eine differenzielle Wiederherstellung mit RECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=0;
```
**Example der vollständigen Datenbankwiederherstellung mit RECOVERY über einen Access Point**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@with_norecovery=0;
```
**Example der vollständigen Datenbankwiederherstellung mit KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Wiederherstellen eines Protokolls
Zum Wiederherstellen Ihres Protokolls rufen Sie die gespeicherte Prozedur `rds_restore_log` auf.
### Usage
```
exec msdb.dbo.rds_restore_log
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/log_file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@with_norecovery=0|1],
[@keep_cdc=0|1],
[@stopat='datetime'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n];
```
Die folgenden Parameter sind erforderlich:
+ `@restore_db_name` – Der Name der Datenbank, deren Protokoll wiederhergestellt werden soll.
+ `@s3_arn_to_restore_from` – Der ARN mit dem Amazon S3-Präfix und dem Namen der Protokolldatei für die Wiederherstellung des Protokolls. Die Datei kann eine beliebige Erweiterung haben, üblicherweise wird jedoch `.trn` verwendet.
Wenn `@s3_arn_to_restore_from` leer ist, wird die folgende Fehlermeldung ausgegeben: S3 ARN prefix cannot be empty (Präfix des S3-ARN kann nicht leer sein).
Die folgenden Parameter sind optional:
+ `@keep_cdc`— Gibt an, ob die Change Data Capture-Konfiguration (CDC) in der wiederhergestellten Datenbank beibehalten werden soll. Auf 1 setzen, um KEEP\$1CDC zu aktivieren, auf 0, um es zu deaktivieren. Der Standardwert lautet 0.
+ `@kms_master_key_arn` - Wenn Sie das Protokoll verschlüsselt haben, den KMS-Schlüssel, der zur Entschlüsselung des Protokolls verwendet werden soll.
+ `@with_norecovery` – Die für die Wiederherstellungsoperation zu verwendende Wiederherstellungsklausel. Dieser Wert ist standardmäßig `1`.
+ Setzen Sie sie für die Wiederherstellung mit RECOVERY auf `0`. In diesem Fall ist die Datenbank nach der Wiederherstellung online. Sie können differentielle Protokollsicherungen nicht später wiederherstellen, während die Datenbank online ist.
+ Setzen Sie sie für die Wiederherstellung mit NORECOVERY auf `1`. In diesem Fall verbleibt die Datenbank nach dem Abschluss der Wiederherstellungsaufgabe im Status RESTORING. Diese Vorgehensweise erlaubt spätere Protokollwiederherstellungen.
+ `@stopat` – Ein Wert, der angibt, dass die Datenbank zu ihrem Zustand am angegebenen Datum und zur angegebenen Uhrzeit (im Datetime-Format) wiederhergestellt wird. Nur vor diesem angegebenen Zeitpunkt geschriebene Transaktionsprotokolldatensätze werden auf die Datenbank angewendet.
Wenn dieser Parameter nicht angegeben wird (NULL ist), wird das vollständige Protokoll wiederhergestellt.
+ `@block_size` – Blockgröße (in Bytes), die die physische Blockgröße für Backup-Operationen angibt. Gültige Werte sind 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 und 65.536.
+ `@max_transfer_size`— Die maximale Übertragungsgröße gibt die Obergrenze des Datenvolumens (in Byte) an, das pro I/O Vorgang während des Backup-Vorgangs übertragen wird. Gültige Werte sind Vielfache von 65.536 Byte (64 KB) bis zu 4.194.304 Byte (4 MB).
+ `@buffer_count`— Gesamtzahl der I/O Puffer, die für den Backup-Prozess verwendet werden sollen.
**Anmerkung**
Bei Protokollwiederherstellungen muss sich die Datenbank entweder im Status RESTORING befinden, oder es muss bereits eine Aufgabe existieren, die mit NORECOVERY wiederherstellt.
Sie können differentielle Protokollsicherungen nicht wiederherstellen, während die Datenbank online ist.
Sie können keine Protokollwiederherstellungsaufgabe für eine Datenbank absenden, für die bereits eine Wiederherstellungsaufgabe mit RECOVERY aussteht.
### Beispiele
**Example für eine Protokollwiederherstellung**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example für eine Protokollwiederherstellung mit Verschlüsselung**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example für eine Protokollwiederherstellung mit NORECOVERY**
Die folgenden zwei Beispiele führen die gleiche Aufgabe durch, die Protokollwiederherstellung mit NORECOVERY.
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=1;
```
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example für eine Wiederherstellung mit Blockgröße**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@block_size=512;
```
**Example für eine Protokollwiederherstellung mit RECOVERY**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0;
```
**Example für eine Protokollwiederherstellung mit STOPAT-Klausel**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0,
@stopat='2019-12-01 03:57:09';
```
**Example der Protokollwiederherstellung mit KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Abschluss einer Datenbankwiederherstellung
Wenn die letzte Wiederherstellungsaufgabe auf der Datenbank mit `@with_norecovery=1` durchgeführt wurde, befindet sich die Datenbank jetzt im Status RESTORING. Öffnen Sie diese Datenbank für den normalen Betrieb mit der gespeicherten Prozedur `rds_finish_restore`.
### Usage
```
exec msdb.dbo.rds_finish_restore @db_name='database_name';
```
**Anmerkung**
Für diese Vorgehensweise muss sich die Datenbank im Status RESTORING ohne ausstehende Wiederherstellungsaufgaben befinden.
Verwenden Sie zum Abschluss der Wiederherstellung der Datenbank die Master-Anmeldeinformationen. Sie können auch die Benutzeranmeldung verwenden, die zuletzt die Datenbank oder das Protokoll mit NORECOVERY wiederhergestellt hat.
## Arbeiten mit teilweise wiederhergestellten Datenbanken
### Verwerfen einer teilweise wiederhergestellten Datenbank
Verwenden Sie zum Verwerfen einer teilweise wiederhergestellten Datenbank (die im Status RESTORING verbleibt) die gespeicherte Prozedur `rds_drop_database`.
```
exec msdb.dbo.rds_drop_database @db_name='database_name';
```
**Anmerkung**
Sie können keine DROP-Datenbankanfrage für eine Datenbank absenden, für die bereits eine ausstehende Wiederherstellungs- oder Wiederherstellungsabschlussaufgabe besteht.
Verwenden Sie zum Verwerfen der Datenbank die Master-Anmeldung. Sie können auch die Benutzeranmeldung verwenden, die zuletzt die Datenbank oder das Protokoll mit NORECOVERY wiederhergestellt hat.
### Snapshot-Wiederherstellung und point-in-time Wiederherstellungsverhalten für teilweise wiederhergestellte Datenbanken
Teilweise wiederhergestellte Datenbanken in der Quellinstanz (im Status point-in-time RESTORING belassen) werden während der Snapshot-Wiederherstellung und -Wiederherstellung aus der Zielinstanz gelöscht.
## Abbrechen einer Aufgabe
Zum Abbruch einer Sicherungs- oder Wiederherstellungsaufgabe rufen Sie die gespeicherte Prozedur `rds_cancel_task` auf.
**Anmerkung**
Eine FINISH\$1RESTORE-Aufgabe kann nicht abgebrochen werden.
### Usage
```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```
Der folgende Parameter ist erforderlich:
+ `@task_id` – ID der abzubrechenden Aufgabe Sie erhalten die ID der Aufgabe durch den Aufruf von `rds_task_status`.
## Verfolgen des Status von Aufgaben
Um den Status Ihrer Sicherungs- oder Wiederherstellungsaufgaben zu verfolgen, rufen Sie die gespeicherte Prozedur `rds_task_status` auf. Wenn Sie keine Parameter angeben, gibt die gespeicherte Prozedur den Status aller Aufgaben zurück. Der Status für Aufgaben wird etwa alle zwei Minuten aktualisiert. Der Abfrageverlauf wird 36 Tage gespeichert.
### Usage
```
exec msdb.dbo.rds_task_status
[@db_name='database_name'],
[@task_id=ID_number];
```
Die folgenden Parameter sind optional:
+ `@db_name` – Name der Datenbank, für die der Aufgabenstatus angezeigt werden soll
+ `@task_id` – ID der Aufgabe, für die der Aufgabenstatus angezeigt werden soll
### Beispiele
**Example für die Auflistung des Status für eine bestimmte Aufgabe**
```
exec msdb.dbo.rds_task_status @task_id=5;
```
**Example für die Auflistung des Status für eine bestimmte Datenbank und Aufgabe**
```
exec msdb.dbo.rds_task_status
@db_name='my_database',
@task_id=5;
```
**Example für die Auflistung aller Aufgaben und ihrer Status auf einer bestimmten Datenbank**
```
exec msdb.dbo.rds_task_status @db_name='my_database';
```
**Example für die Auflistung aller Aufgaben und ihrer Status auf der aktuellen Instance**
```
exec msdb.dbo.rds_task_status;
```
### Antwort
Die gespeicherte Prozedur `rds_task_status` gibt die folgenden Spalten zurück.
****
| Spalte | Beschreibung |
| --- | --- |
| `task_id` | Die ID der Aufgabe. |
| `task_type` | Aufgabentyp je nach Eingabeparametern, wie folgt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) Amazon RDS erstellt einen anfänglichen Snapshot der Datenbank nach ihrer Öffnung oder nach dem Abschluss der folgenden Wiederherstellungsaufgaben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `database_name` | Der Name der Datenbank, der die Aufgabe zugeordnet ist. |
| `% complete` | Der Fortschritt der Aufgabe als Prozentwert. |
| `duration (mins)` | Zeitdauer für die Ausführung der Aufgabe (in Minuten). |
| `lifecycle` | Der Status der Aufgabe. Die folgenden Status sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `task_info` | Zusätzliche Informationen über die Aufgabe. Wenn während des Sicherns oder Wiederherstellens einer Datenbank ein Fehler auftritt, enthält diese Spalte Informationen über den Fehler. Eine Liste möglicher Fehler und Abhilfemaßnahmen finden Sie unter [Fehlerbehebung](SQLServer.Procedural.Importing.Native.Troubleshooting.md). |
| `last_updated` | Datum und Uhrzeit der letzten Aktualisierung des Aufgabenstatus. Der Status wird jeweils nach 5 Prozent Fortschritt aktualisiert. |
| `created_at` | Datum und Uhrzeit, an denen die Aufgabe angelegt wurde. |
| S3\$1object\$1arn | Der ARN mit dem Amazon S3-Präfix und dem Namen der Datei, die gesichert oder wiederhergestellt wird. |
| `overwrite_s3_backup_file` | Wert des Parameters `@overwrite_s3_backup_file`, der beim Aufruf einer Sicherungsaufgabe angegeben wurde. Weitere Informationen finden Sie unter [Sichern einer Datenbank](#SQLServer.Procedural.Importing.Native.Using.Backup). |
| KMS\$1master\$1key\$1arn | Der ARN für den KMS-Schlüssel, der für die Verschlüsselung (für die Sicherung) und Entschlüsselung (für die Wiederherstellung) verwendet wird. |
| filepath | Gilt nicht für native Sicherungs- und Wiederherstellungsaufgaben |
| overwrite\$1file | Gilt nicht für native Sicherungs- und Wiederherstellungsaufgaben |
# Komprimieren von Sicherungsdateien
Zur Platzersparnis in Ihrem Amazon S3-Bucket können Sie Ihre Sicherungsdateien komprimieren. Weitere Informationen zum Komprimieren von Sicherungsdateien finden Sie unter [Sicherungskomprimierung](https://msdn.microsoft.com/en-us/library/bb964719.aspx) in der Microsoft-Dokumentation.
Die Komprimierung Ihrer Sicherungsdateien wird für die folgenden Datenbankversionen unterstützt:
+ Microsoft SQL Server Enterprise Edition
+ Microsoft SQL Server Standard Edition
Um die Komprimierung für Ihre Backup-Dateien zu verifizieren, führen Sie den folgenden Code aus:
```
1. exec rdsadmin.dbo.rds_show_configuration 'S3 backup compression';
```
Um die Komprimierung für Ihre Sicherungsdateien einzuschalten, führen Sie den folgenden Code aus:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'true';
```
Um die Komprimierung für Ihre Sicherungsdateien auszuschalten, führen Sie den folgenden Code aus:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'false';
```
# Fehlerbehebung
Die folgenden Probleme können bei der Verwendung nativer Backups und Wiederherstellungen auftreten.
****
| Problem | Vorschläge für die Fehlerbehebung |
| --- | --- |
| Die Option zur Backup/Wiederherstellung der Datenbank ist noch nicht aktiviert oder wird gerade aktiviert. Bitte versuchen Sie es später noch einmal. | Achten Sie darauf, die `SQLSERVER_BACKUP_RESTORE`-Option zur DB-Optionsgruppe hinzuzufügen, die mit Ihrer DB-Instance verbunden ist. Weitere Informationen finden Sie unter [Hinzufügen der Option „Native Sicherung und Backup“](Appendix.SQLServer.Options.BackupRestore.md#Appendix.SQLServer.Options.BackupRestore.Add). |
| Die EXECUTE-Berechtigung wurde für das Objekt „*rds\$1backup\$1database*“, Datenbank „msdb“, Schema „dbo“ verweigert. | Wenn Sie die gespeicherte Prozedur ausführen, stellen Sie sicher, dass Sie den Hauptbenutzer verwenden. Wenn dieser Fehler auch dann auftritt, wenn Sie als Hauptbenutzer angemeldet sind, kann dies daran liegen, dass die Administratorberechtigungen falsch zugeordnet sind. Um den Hauptbenutzer zurückzusetzen, verwenden Sie die AWS-Managementkonsole. Siehe [Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Die EXECUTE-Berechtigung wurde für das Objekt „*rds\$1restore\$1database*“, Datenbank „msdb“, Schema „dbo“ verweigert. | Wenn Sie die gespeicherte Prozedur ausführen, stellen Sie sicher, dass Sie den Hauptbenutzer verwenden. Wenn dieser Fehler auch dann auftritt, wenn Sie als Hauptbenutzer angemeldet sind, kann dies daran liegen, dass die Administratorberechtigungen falsch zugeordnet sind. Um den Hauptbenutzer zurückzusetzen, verwenden Sie die AWS-Managementkonsole. Siehe [Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Zugriff verweigert | Der Sicherungs- oder Wiederherstellungsprozess kann nicht auf die Sicherungsdatei zugreifen. Dies hat normalerweise Ursachen wie die folgenden: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Troubleshooting.html) |
| BACKUP-DATENBANK MIT KOMPRESSION wird in Edition nicht unterstützt | Die Komprimierung Ihrer Sicherungsdateien wird nur für Microsoft SQL Server Enterprise Edition und Standard Edition unterstützt. . Weitere Informationen finden Sie unter [Komprimieren von Sicherungsdateien](SQLServer.Procedural.Importing.Native.Compression.md). |
| Schlüssel existiert nicht | Sie haben versucht, ein verschlüsseltes Backup wiederherzustellen, haben aber keinen Verschlüsselungsschlüssel angegeben. Prüfen Sie Ihren Verschlüsselungsschlüssel und versuchen Sie es erneut. Weitere Informationen finden Sie unter [Wiederherstellen einer Datenbank](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). |
| Bitte geben Sie die Aufgabe mit dem richtigen Typ neu aus und überschreiben Sie die Eigenschaft | Wenn Sie versuchen, Ihre Datenbank zu sichern, und Sie den Namen einer bereits vorhandenen Datei angeben, aber die Eigenschaft "overwrite" auf "false" gesetzt haben, schlägt der Sicherungsvorgang fehl. Geben Sie zur Korrektur dieses Fehlers entweder den Namen einer noch nicht vorhandenen Datei an, oder setzen Sie die Eigenschaft "overwrite" auf "true". Weitere Informationen finden Sie unter [Sichern einer Datenbank](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup). Zudem ist es möglich, dass Sie Ihre Datenbank wiederherstellen wollten, aber versehentlich die gespeicherte Prozedur `rds_backup_database` aufgerufen haben. Rufen Sie in diesem Fall stattdessen die gespeicherte Prozedur `rds_restore_database` auf. Weitere Informationen finden Sie unter [Wiederherstellen einer Datenbank](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). Wenn Sie Ihre Datenbank wiederherstellen wollten und die gespeicherte Prozedur `rds_restore_database` aufgerufen haben, vergewissern Sie sich, dass Sie den Namen einer gültigen Sicherungsdatei angegeben haben. Weitere Informationen finden Sie unter [Verwenden nativer Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Using.md). |
| Bitte geben Sie einen Bucket an, der sich in der gleichen Region wie die RDS-Instance befindet | Sie können keine Backups zu einem Amazon-S3-Bucket in einer AWS-Region ausführen, die sich von der Ihrer Amazon-RDS-DB-Instance unterscheidet, oder Wiederherstellungen aus einem solchen Bucket ausführen. Sie können mithilfe von Amazon S3 Replikation die Sicherungsdatei in die korrekte AWS Region kopieren. Weitere Informationen finden Sie unter [Regionenübergreifende Replikation](https://docs.aws.amazon.com/AmazonS3/latest/userguide/crr.html) in der Amazon S3-Dokumentation. |
| Der angegebene Bucket existiert nicht | Stellen Sie sicher, dass Sie den korrekten ARN für Ihren Bucket und die Datei im richtigen Format angegeben haben. Weitere Informationen finden Sie unter [Verwenden nativer Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Using.md). |
| Der Benutzer ist nicht berechtigt, auf Ressourcen zu arbeiten | Sie haben einen verschlüsselten Vorgang angefragt, aber keine geeigneten AWS KMS-Berechtigungen angegeben. Überprüfen Sie, ob Sie die korrekten Berechtigungen haben oder fügen Sie diese hinzu. Weitere Informationen finden Sie unter [Einrichtung für native Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Enabling.md). |
| Die Wiederherstellungsaufgabe kann nicht aus mehr als 10 Sicherungsdateien wiederhergestellt werden). Bitte reduzieren Sie die Anzahl der übereinstimmenden Dateien und versuchen Sie es erneut. | Reduzieren Sie die Anzahl der Dateien, aus denen Sie wiederherstellen möchten. Sie können jede einzelne Datei bei Bedarf größer machen. |
| Die Datenbank '*database\$1name*' existiert bereits. Zwei Datenbanken, die sich nur nach Fall oder Akzent unterscheiden, sind nicht zulässig. Wählen Sie einen anderen Datenbanknamen aus. | Sie können eine Datenbank nicht mit dem gleichen Namen wie eine vorhandene Datenbank wiederherstellen. Die Namen der Datenbank sind eindeutig. |
# Importieren und Exportieren von SQL Server-Daten mithilfe anderer Methoden
Im Folgenden finden Sie Informationen zur Verwendung von Snapshots für den Import Ihrer Microsoft SQL Server-Daten zu Amazon RDS. Sie finden hier auch Informationen zur Verwendung von Snapshots für den Export Ihrer Daten von einer RDS DB-Instance mit SQL Server.
Wenn es Ihr Szenario unterstützt, ist es einfacher, Daten mithilfe der nativen Sicherungs- und Wiederherstellungsfunktionalität zu und aus Amazon RDS zu verschieben. Weitere Informationen finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
**Anmerkung**
Amazon RDS für Microsoft SQL Server unterstützt nicht das Importieren von Daten in die `msdb`-Datenbank.
## Importieren von Daten in RDS für SQL Server mithilfe eines Snapshots
**So können Sie Daten in eine SQL Server-DB-Instance mithilfe eines Snapshots importieren**
1. Erstellen Sie eine DB -Instance. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
1. Stoppen Sie den Zugriff von Anwendungen auf die gewünschte DB-Instance.
Wenn Sie den Zugriff auf Ihre DB-Instance blockieren, während Sie Daten importieren, läuft die Datenübertragung schneller. Zudem müssen Sie sich keine Sorgen über Konflikte machen, während die Daten geladen werden, wenn andere Anwendungen nicht in die DB-Instance schreiben können. Falls ein Problem auftritt und Sie zum vorherigen Datenbank-Snapshot zurückkehren müssen, verlieren Sie lediglich die importierten Daten. Sie können diese Daten dann nach der Behebung des Problems erneut importieren.
Weitere Informationen über die Zugriffskontrolle auf Ihre DB-Instance finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
1. Erstellen Sie einen Snapshot der Ziel-Datenbank.
Wenn die Zieldatenbank bereits Daten enthält, empfehlen wir Ihnen einen Snapshot dieser Datenbank zu machen, bevor Sie Daten importieren. Wenn etwas beim Datenimport schief geht oder Sie die Änderungen verwerfen möchten, können Sie den vorherigen Zustand der Datenbank mithilfe des Snapshots wiederherstellen. Weitere Informationen zu Datenbank-Snapshots finden Sie unter [Erstellen eines DB-Snapshots für eine DB-Instance mit Single-AZ für Amazon RDS](USER_CreateSnapshot.md).
**Anmerkung**
Wenn Sie einen Datenbank-Snapshot erstellen, werden die I/O-Operationen zur Datenbank für einen Moment (Millisekunden) ausgesetzt, während das Backup läuft.
1. Deaktivieren Sie automatische Backups für die Ziel-Datenbank.
Das Deaktivieren der automatischen Backups auf der DB-Ziel-Instance verbessert die Leistung beim Importieren Ihrer Daten, da Amazon RDS die Transaktionen nicht protokolliert, wenn automatische Backups deaktiviert sind. Jedoch müssen einige Dinge beachtet werden. Automatisierte Backups sind für zeitpunktbezogene Wiederherstellungen erforderlich. Sie können daher nicht eine Datenbank zu einem bestimmten Zeitpunkt wiederherstellen, während Sie Daten importieren. Darüber hinaus werden alle automatisierten Backups, die für die DB-Instance erstellt wurden, gelöscht - es sei denn, Sie möchten sie behalten.
Wenn Sie sich für die Aufbewahrung der automatisierten Backups entscheiden, können Sie sich vor versehentlichem Löschen von Daten schützen. Amazon RDS speichert außerdem die Eigenschaften der Datenbank-Instance zusammen mit jedem automatisierten Backup, um die Wiederherstellung zu erleichtern. Mit dieser Option können Sie eine gelöschte Datenbank-Instance auch nach dem Löschen auf einen bestimmten Zeitpunkt innerhalb der Aufbewahrungsfrist wiederherstellen. Automatische Backups werden am Ende des angegebenen Backup-Zeitraums automatisch gelöscht, genau wie bei einer aktiven Datenbank-Instance.
Sie können auch frühere Snapshots verwenden, um die Datenbank wiederherzustellen. Snapshots, die Sie erstellt haben, bleiben verfügbar. Weitere Informationen zu automatischen Backups finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md).
1. Deaktivieren Sie auswärtige Schlüsselbeschränkungen, wenn möglich.
Wenn Sie auswärtige Schlüsselbeschränkungen deaktivieren müssen, können Sie das folgende Skript verwenden.
```
--Disable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' NOCHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
GO
```
1. Verwerfen Sie Indizes, wenn möglich.
1. Deaktivieren Sie Auslöser, wenn möglich.
Wenn Sie Auslöser deaktivieren müssen, können Sie das folgende Skript verwenden.
```
--Disable triggers on all tables
DECLARE @enable BIT = 0;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
GO
```
1. Suchen Sie in der Quell-SQL Server-Instance nach Anmeldedaten, die Sie in die gewünschte DB-Instance importieren möchten.
SQL Server speichert Anmeldedaten und Passwörter in der `master`-Datenbank. Da Amazon RDS keinen Zugriff auf die `master`-Datenbank gewährt, können Sie Anmeldedaten und Passwörter nicht direkt in Ihre DB-Instance importieren. Stattdessen müssen Sie die `master`-Datenbank auf der SQL Server-Quell-Instance abfragen, um eine DDL (Data Definition Language)-Datei zu generieren. Diese Datei sollte alle Anmeldedaten und Passwörter enthalten, die Sie der DB-Ziel-Instance hinzufügen möchten. Diese Datei sollte auch die Rollenmitgliedschaften und Berechtigungen enthalten, die Sie übertragen möchten.
Weitere Informationen zum Abfragen der `master`-Datenbank finden Sie unter [Transfer logins and passwords between instances of SQL Server](https://learn.microsoft.com/en-us/troubleshoot/sql/database-engine/security/transfer-logins-passwords-between-instances) in der Microsoft Knowledge Base.
Die Ausgabe des Skripts ist ein anderes Skript, das Sie in der gewünschten DB-Instance ausführen können. Das Skript im Knowledge Base-Artikel hat den folgenden Code:
```
p.type IN
```
Jedes Mal wenn `p.type` erscheint, verwenden Sie stattdessen den folgenden Code:
```
p.type = 'S'
```
1. Importieren Sie Daten mithilfe der Methode in [Importieren der Daten](#ImportData.SQLServer.Import).
1. Gewähren Sie Anwendungen Zugriff auf die Ziel-DB-Instance.
Wenn Ihr Datenimport abgeschlossen ist, können Sie den Anwendungen, die Sie während des Imports blockiert haben, den Zugang zur DB-Instance gewähren. Weitere Informationen über die Zugriffskontrolle auf Ihre DB-Instance finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
1. Aktivieren Sie automatische Backups für die Ziel-DB-Instance.
Weitere Informationen zu automatischen Backups finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md).
1. Aktivieren Sie auswärtige Schlüsselbeschränkungen.
Wenn Sie auswärtige Schlüsselbeschränkungen vorher deaktiviert haben, können Sie diese jetzt mit dem folgenden Skript aktivieren.
```
--Enable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' CHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
```
1. Aktivieren Sie Indizes, wenn möglich.
1. Aktivieren Sie Auslöser, wenn möglich.
Wenn Sie Auslöser vorher deaktiviert haben, können Sie diese jetzt mit dem folgenden Skript aktivieren.
```
--Enable triggers on all tables
DECLARE @enable BIT = 1;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
```
### Importieren der Daten
Microsoft SQL Server Management Studio ist ein grafischer SQL Server-Client, der in allen Microsoft SQL Server Editionen enthalten ist, außer in der Express Edition. SQL Server Management Studio Express von Microsoft ist als kostenloser Download verfügbar. Sie finden diesen Download auf der [Microsoft-Website](https://www.microsoft.com/en-us/download).
**Anmerkung**
SQL Server Management Studio ist nur als Windows-basierte Anwendung verfügbar.
SQL Server Management Studio beinhaltet die folgenden Tools, die nützlich für den Import von Daten in eine SQL Server DB-Instance sind:
+ Assistent für das Generieren und Veröffentlichen von Skripts
+ Assistent für den Import und Export
+ Bulk-Kopie
#### Assistent für das Generieren und Veröffentlichen von Skripts
Der Assistent für das Generieren und Veröffentlichen von Skripts erstellt ein Skript, das das Schema einer Datenbank, die Daten selbst, oder beides enthält. Sie können ein Skript für eine Datenbank in Ihrer lokalen SQL Server-Bereitstellung generieren. Sie können dann das Skript ausführen, um die darin enthaltenen Informationen zu einer Amazon-RDS-DB-Instance zu übertragen.
**Anmerkung**
Bei Datenbanken mit einer Größe von 1 GiB oder mehr ist es effizienter, nur für das Datenbankschema ein Skript zu verwenden. Anschließend verwenden Sie den Assistenten für Import und Export oder die Massenkopierfunktion von SQL Server, um die Daten zu übertragen.
Weitere detaillierte Informationen über den Assistent für das Generieren und Veröffentlichen von Skripts finden Sie in der [Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms178078%28v=sql.105%29.aspx).
Beachten Sie im Assistenten besonders die erweiterten Optionen auf der Seite **Set Scripting Options** (Scripting-Optionen einstellen), um sicherzustellen, dass alle Inhalte, die im Skript enthalten sein sollen, ausgewählt wurden. Beispielsweise sind standardmäßig keine Datenbank-Auslöser im Skript enthalten.
Wenn das Skript generiert und gespeichert ist, können Sie SQL Server Management Studio verwenden, um sich mit Ihrer DB-Instance zu verbinden und das Skript auszuführen.
#### Assistent für den Import und Export
Der Import-Export-Assistent erstellt ein spezielles Paket mit Integrationsdiensten, die Sie verwenden können, um Daten aus Ihrer lokalen SQL Server-Datenbank in die gewünschte DB-Instance zu kopieren. Der Assistent kann filtern, welche Tabellen und sogar welche Tupel innerhalb von Tabellen in die bestimmte DB-Instance kopiert werden sollen.
**Anmerkung**
Der Import-Export-Assistent funktioniert gut mit großen Datensätzen, aber es ist nicht unbedingt der schnellste Weg, um Daten remote aus Ihrer lokalen Einrichtung zu exportieren. Eine schnellere Methode ist die SQL Server-Bulk-Kopie-Funktion.
Weitere detaillierte Informationen über den Import-Export-Assistenten finden Sie in der [ Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms140052%28v=sql.105%29.aspx).
Führen Sie im Assistenten auf der Seite **Choose a Destination** (Ziel auswählen) folgende Schritte aus:
+ Geben Sie im Feld **Servername** den Namen des Endpunkts für Ihre DB-Instance ein.
+ Wählen Sie als Server-Authentifizierungsmodus **Use SQL Server Authentication** (SQL Server-Authentifizierung verwenden) aus.
+ Geben Sie im Feld **Benutzername** und **Passwort** die Anmeldeinformationen für den Hauptbenutzer ein, den Sie für die DB-Instance erstellt haben.
#### Bulk-Kopie
Die SQL Server-Bulk-Kopie-Funktion ist eine effiziente Methode zum Kopieren von Daten aus einer Quelldatenbank auf Ihre DB-Instance. Bulk-Kopie schreibt die Daten, die Sie für die Datei festlegen, wie z. B. eine ASCII-Datei. Sie können die Bulk-Kopie nochmal ausführen, um die Inhalte der Datei in die gewünschte DB-Instance zu schreiben.
In diesem Abschnitt wird das Hilfsprogramm **bcp** verwendet, das in allen Editionen von SQL Server enthalten ist. Weitere detaillierte Informationen zu Bulk-Import und -Export-Operationen finden Sie in der [Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx).
**Anmerkung**
Bevor Sie eine Bulk-Kopie verwenden, müssen Sie zuerst Ihr Datenbankschema in die gewünschte DB-Instance importieren. Der Assistent für das Generieren und Veröffentlichen von Skripts, der vorher in diesem Thema beschrieben wurde, ist ein ausgezeichnetes Tool für diesen Zweck.
Der folgende Befehl stellt eine Verbindung zur lokalen SQL Server-Instance her. Er generiert eine tabulatorgetrennte Datei für eine angegebene Tabelle im C:\$1-Stammverzeichnis Ihrer bestehenden SQL Server-Bereitstellung. Die Tabelle wird durch ihren vollständigen, gültigen Namen angegeben und die Textdatei hat denselben Namen wie die kopierte Tabelle.
```
bcp dbname.schema_name.table_name out C:\table_name.txt -n -S localhost -U username -P password -b 10000
```
Der vorherige Code beinhaltet die folgenden Optionen:
+ `-n` gibt an, dass eine Massenkopie die nativen Datentypen der Daten verwendet, die zu kopieren sind.
+ `-S` gibt die SQL Server-Instance an, mit der sich das Hilfsprogramm *bcp* verbindet.
+ `-U` gibt den Benutzernamen des Kontos an, das in der SQL Server-Instance angemeldet wird.
+ `-P` gibt das Passwort für den Benutzer an `-U`.
+ `-b` gibt die Anzahl der Zeilen pro Batch importierter Daten an.
**Anmerkung**
Es könnte noch andere Parameter geben, die für Ihren Importvorgang wichtig sind. Beispielsweise könnten Sie den Parameter `-E` benötigen, der sich auf die Identitätswerte bezieht. Weitere Informationen finden Sie in der vollständigen Beschreibung der Befehlszeilensyntax für das Hilfsprogramm **bcp** in der [Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.105%29.aspx).
Angenommen, eine Datenbank mit dem Namen `store`, die das Standardschema `dbo` verwendet, enthält eine Tabelle mit dem Namen `customers`. Das Benutzerkonto `admin` mit dem Passwort `insecure` kopiert 10 000 Zeilen aus der Tabelle `customers` in eine Datei mit dem Namen `customers.txt`.
```
bcp store.dbo.customers out C:\customers.txt -n -S localhost -U admin -P insecure -b 10000
```
Nachdem Sie die Datendatei erstellt haben, können Sie die Daten mit einem ähnlichen Befehl zu Ihrer DB-Instance hochladen. Erstellen Sie vorher die Datenbank und das Schema auf der DB-Ziel-Instance. Verwenden Sie dann das Argument `in`, um die Input-Datei anzugeben, anstelle von `out`, um die Output-Datei anzugeben. Anstelle der Verwendung von localhost zur Angabe der lokalen SQL Server-Instance, geben Sie den Endpunkt Ihrer DB-Instance an. Wenn Sie einen anderen Port als 1433 verwenden, geben Sie auch diesen an. Der Benutzername und das Passwort entsprechen den Angaben für den Master-Benutzer Ihrer DB-Instance. Die Syntax ist wie folgt.
```
bcp dbname.schema_name.table_name
in C:\table_name.txt -n -S endpoint,port -U master_user_name -P master_user_password -b 10000
```
Um mit dem vorherigen Beispiel fortzufahren, nehmen wir an, dass der Benutzername `admin` und das Passwort `insecure` lauten. Der Endpunkt für diese DB-Instance lautet `rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com` und verwendet Port 4080. Der Befehl lautet wie folgt.
```
bcp store.dbo.customers in C:\customers.txt -n -S rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com,4080 -U admin -P insecure -b 10000
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
## Exportieren von Daten aus RDS für SQL Server
Sie können eine der folgenden Optionen auswählen, um Daten aus einer RDS für SQL-Server-DB-Instance zu exportieren:
+ **Native Datenbanksicherung mithilfe einer vollständigen Sicherungsdatei (BAK)**: Die Verwendung von BAK-Dateien, um Datenbanken zu sichern, ist hochoptimiert und im Normalfall die schnellste Methode, um Daten zu exportieren. Weitere Informationen finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
+ **SQL Server Import and Export Wizard** – weitere Informationen finden Sie unter [SQL Server-Assistent für Import und Export (SQL Server Import and Export Wizard)](#SQLServer.Procedural.Exporting.SSIEW).
+ **SQL Server Generate and Publish Scripts Wizard und bcp-Hilfsprogramm**: Weitere Informationen finden Sie unter [SQL Server-Assistent für das Generieren und Veröffentlichen von Skripts und Hilfsprogramm bcp](#SQLServer.Procedural.Exporting.SSGPSW).
### SQL Server-Assistent für Import und Export (SQL Server Import and Export Wizard)
Sie können den SQL Server-Assistenten für Import und Export verwenden, um eine oder mehrere Tabellen, Ansichten oder Abfragen aus Ihrer RDS für SQL-Server-DB-Instance in einen anderen Datenspeicher zu kopieren. Dies ist die beste Wahl, wenn sich der Ziel-Datenspeicher nicht in SQL Server befindet. Weitere Informationen finden Sie unter [ SQL Server Import and Export Wizard](http://msdn.microsoft.com/en-us/library/ms141209%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
Der SQL Server-Assistent für Import und Export ist als Teil von Microsoft SQL Server Management Studio verfügbar. Dieser grafische SQL Server-Client ist in allen Microsoft SQL Server-Editionen außer in der Express Edition enthalten. SQL Server Management Studio ist nur als Windows-basierte Anwendung verfügbar. SQL Server Management Studio Express von Microsoft ist als kostenloser Download verfügbar. Sie finden diesen Download auf der [Microsoft-Website](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**So verwenden Sie SQL Server-Assistent für Import und Export, um Daten zu exportieren**
1. Stellen Sie in SQL Server Management Studio eine Verbindung mit Ihrer RDS für SQL-Server-DB-Instance her. Weitere detaillierte Informationen hierzu finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. Erweitern Sie im **Object Explorer** (Objektexplorer) den Abschnitt **Datenbanken**, öffnen Sie das Kontextmenü (rechter Mausklick) für die Quelldatenbank, wählen Sie **Aufgaben** und anschließend **Export Data** (Daten exportieren) aus. Der Assistent wird angezeigt.
1. Öffnen Sie die Seite **Choose a Data Source** (Datenquelle auswählen) und führen Sie folgende Schritte durch:
1. Wählen Sie für **Datenquelle** **SQL Server Native Client 11.0** aus.
1. Stellen Sie sicher, dass das Feld **Server name (Servername)** den Endpunkt Ihrer RDS für SQL-Server-DB-Instance anzeigt.
1. Wählen Sie **Use SQL Server Authentication (SQL Server-Authentifizierung verwenden)** aus. Geben Sie für **Benutzername** und **Passwort** den Hauptbenutzernamen und das Hauptpasswort Ihrer DB-Instance ein.
1. Stellen Sie sicher, dass das Feld **Datenbank** die Datenbank anzeigt, von der Sie Daten exportieren möchten.
1. Wählen Sie **Weiter**.
1. Führen Sie auf der Seite **Choose a Destination** (Ziel auswählen) folgende Schritte durch:
1. Geben Sie für **Ziel** die Zeichenfolge **SQL Server Native Client 11.0** an.
**Anmerkung**
Es sind weitere Zieldatenquellen verfügbar. Dazu gehören: .NET Framework-Datenanbieter, OLE DB-Anbieter, SQL Server Native Client-Anbieter, ADO.NET-Anbieter, Microsoft Office Excel, Microsoft Office Access und die Flat File-Quelle. Wenn Sie eine dieser Datenquellen auswählen, überspringen Sie den Rest von Schritt 4. Einzelheiten zu den Verbindungsinformationen, die als Nächstes anzugeben sind, finden Sie unter [Auswählen eines Ziels](http://msdn.microsoft.com/en-us/library/ms178430%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. Geben Sie für **Servername** den Servernamen der SQL Server-DB-Ziel-Instance an.
1. Wählen Sie den angemessenen Authentifizierungstyp aus. Geben Sie einen Benutzernamen und Passwort ein, wenn nötig.
1. Wählen Sie für **Datenbank** den Namen der Zieldatenbank aus oder wählen Sie **Neu** aus, um eine neue Datenbank zu erstellen, in die die exportierten Daten gespeichert werden.
Wenn Sie **New (Neu)** auswählen, finden Sie unter [Datenbank erstellen](http://msdn.microsoft.com/en-us/library/ms183323%28v=sql.110%29.aspx) in der SQL Server-Dokumentation weitere Einzelheiten über bereitzustellende Datenbankinformationen.
1. Wählen Sie **Weiter**.
1. Wählen Sie auf der Seite **Table Copy or Query** (Tabellenkopie oder -abfrage) die Option **Copy data from one or more tables or views** (Daten von einer oder mehreren Tabellen oder Ansichten kopieren) oder **Write a query to specify the data to transfer** (Anfrage zur Spezifizierung der Transferdaten schreiben) aus. Wählen Sie **Weiter**.
1. Wenn Sie **Write a query to specify the data to transfer** (Anfrage zur Spezifizierung der Transferdaten schreiben) auswählen, wird die Seite **Provide a Source Query** (Quellabfrage bereitstellen) angezeigt. Kopieren oder tippen Sie eine SQL-Abfrage ein und wählen Sie anschließend **Parse** (Parsen) aus, um sie zu überprüfen. Wenn die Abfrage bestätigt ist, klicken Sie auf **Weiter**.
1. Führen Sie auf der Seite **Select Source Tables and Views** (Quelltabellen oder -ansichten auswählen) die folgenden Schritte durch:
1. Wählen Sie die Tabellen und Ansichten, die Sie exportieren möchten, aus oder überprüfen Sie, dass die Abfrage, die sie getätigt haben, ausgewählt ist.
1. Wählen Sie **Edit Mappings** (Zuweisungen bearbeiten) aus und geben Sie die Datenbank- und Spaltenzuweisungsinformationen an. Weitere Informationen finden Sie unter [Spaltenzuordnungen](http://msdn.microsoft.com/en-us/library/ms189660%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. (Optional) Wählen Sie die Tabelle, Ansicht oder Abfrage aus und klicken Sie anschließend auf **Preview (Vorversion)**, um eine Vorversion der zu exportierenden Daten anzuzeigen.
1. Wählen Sie **Weiter**.
1. Auf der Seite **Run Package** (Paket ausführen) muss **Run immediately** (Sofort ausführen) ausgewählt sein. Wählen Sie **Weiter**.
1. Überprüfen Sie auf der Seite **Complete the Wizard** (Assistenten abschließen), dass die Details zum Datenexport wie erwartet sind. Wählen Sie **Finish** (Abschließen).
1. Wählen Sie auf der Seite **The execution was successful** (Ausführung erfolgreich) die Option **Schließen** aus.
### SQL Server-Assistent für das Generieren und Veröffentlichen von Skripts und Hilfsprogramm bcp
Sie können den SQL Server-Assistenten für das Generieren und Veröffentlichen von Skripts verwenden, um Skripts für eine gesamte Datenbank oder nur für ausgewählte Objekte zu erstellen. Sie können diese Skripts auf einer Ziel-SQL Server-DB-Instance ausführen, um die geskripteten Objekte neu zu erstellen. Sie können anschließend das Hilfsprogramm bcp verwenden, um einen Bulk-Export der Daten für die ausgewählten Objekte in die Ziel-DB-Instance durchzuführen. Diese Methode ist die beste Wahl, wenn Sie eine gesamte Datenbank (einschließlich Objekten, die keine Tabellen sind) oder große Datenmengen zwischen zwei SQL Server-DB-Instances verschieben möchten. Eine vollständige Beschreibung der bcp-Befehlszeilensyntax finden Sie unter [bcp-Dienstprogramm](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.110%29.aspx) in der Microsoft SQL Server-Dokumentation.
Der SQL Server-Assistent zum Generieren und Veröffentlichen von Skripts ist als Teil von Microsoft SQL Server Management Studio verfügbar. Dieser grafische SQL Server-Client ist in allen Microsoft SQL Server-Editionen außer in der Express Edition enthalten. SQL Server Management Studio ist nur als Windows-basierte Anwendung verfügbar. SQL Server Management Studio Express von Microsoft ist als [kostenloser Download](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio) verfügbar.
**So können Sie den SQL Server-Assistenten für das Generieren und Veröffentlichen von Skripts und das Hilfsprogramm bcp für einen Datenexport verwenden**
1. Stellen Sie in SQL Server Management Studio eine Verbindung mit Ihrer RDS für SQL-DB-Instance her. Weitere detaillierte Informationen hierzu finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. Erweitern Sie in **Object Explorer** (Objektexplorer) den Knotenpunkt **Datenbanken** und wählen Sie die Datenbank aus, die Sie skripten möchten.
1. Folgen Sie den Anweisungen in [Assistent zum Generieren und Veröffentlichen von Skripts](http://msdn.microsoft.com/en-us/library/bb895179%28v=sql.110%29.aspx) in der SQL Server-Dokumentation, um eine Skriptdatei zu erstellen.
1. Verbinden Sie sich in SQL Server Management Studio mit Ihrer Ziel-SQL Server-DB-Instance.
1. Mit ausgewählter SQL Server-DB-Ziel-Instance im **Object Explorer (Objektexplorer)** wählen Sie im Menü **File (Datei)** die Option **Open (Öffnen)** aus, wählen Sie **File (Datei)** und öffnen Sie die Skriptdatei.
1. Wenn Sie für die gesamte Datenbank ein Skript erstellt haben, prüfen Sie die Anweisung CREATE DATABASE im Skript. Stellen Sie sicher, dass die Datenbank an dem von Ihnen gewünschten Speicherort und mit den korrekten Parametern erstellt wird. Weitere Informationen finden Sie unter [CREATE DATABASE](http://msdn.microsoft.com/en-us/library/ms176061%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. Wenn Sie im Skript Benutzer für die Datenbank erstellen, überprüfen Sie, ob bereits Serveranmeldedaten in der Ziel-DB-Instance für diese Benutzer vorhanden sind. Wenn dies nicht der Fall ist, erstellen Sie Anmeldedaten für diese Benutzer. Andernfalls werden die geskripteten Befehle für das Erstellen der Datenbankbenutzer fehlschlagen. Weitere Informationen finden Sie unter [Erstellen eines Anmeldenamens](http://msdn.microsoft.com/en-us/library/aa337562%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. Wählen Sie im SQL-Editor-Menü **\$1Execute** aus, um die Skriptdatei auszuführen und die Datenbankobjekte zu erstellen. Sobald das Skript abgeschlossen ist, überprüfen Sie, dass alle Datenbankobjekte wie erwartet vorhanden sind.
1. Verwenden Sie das Hilfsprogramm bcp, um Daten aus der RDS für SQL-Server-DB-Instance in Dateien zu exportieren. Öffnen Sie eine Eingabeaufforderung und geben Sie den folgenden Befehl ein.
```
bcp database_name.schema_name.table_name out data_file -n -S aws_rds_sql_endpoint -U username -P password
```
Der vorherige Code beinhaltet die folgenden Optionen:
+ *table\$1name* ist der Name einer der Tabellen, die Sie in der Zieldatenbank neu erstellt haben und die jetzt mit Daten versehen wird.
+ *data\$1file* ist der vollständige Pfad und Name der Datei, die erstellt werden soll.
+ `-n` gibt an, dass eine Massenkopie die nativen Datentypen der Daten verwendet, die zu kopieren sind.
+ `-S` gibt die SQL Server-DB-Instance an, aus der exportiert werden soll.
+ `-U` gibt den zu verwendenden Benutzernamen an, wenn eine Verbindung mit der SQL Server-DB-Instance hergestellt wird.
+ `-P` gibt das Passwort für den Benutzer an `-U`.
Im Folgenden wird ein Beispielbefehl gezeigt.
```
bcp world.dbo.city out C:\Users\JohnDoe\city.dat -n -S sql-jdoe.1234abcd.us-west-2.rds.amazonaws.com,1433 -U JohnDoe -P ClearTextPassword
```
Wiederholen Sie diesen Schritt, bis Sie Dateien für alle Tabellen haben, die Sie exportieren möchten.
1. Bereiten Sie Ihre DB-Ziel-Instance für den Massenimport von Daten mithilfe der Anweisungen unter [Vorbereiten des Massenimports von Daten](http://msdn.microsoft.com/en-us/library/ms189989%28v=sql.110%29.aspx) in der SQL Server-Dokumentation vor.
1. Entscheiden Sie sich für eine Methode zum Massenimport, nachdem Sie die Leistung und andere wichtige Faktoren eingeschätzt haben, die unter [Informationen zu Massenimport- und Massenexportvorgängen](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx) in der SQL Server-Dokumentation aufgeführt werden.
1. Führen Sie einen Massenimport der Daten aus den mit dem bcp-Hilfsprogramm erstellten Datendateien aus. Befolgen Sie hierzu die Anweisungen unter [Im- und Exportieren von Massendaten mithilfe des Dienstprogramms bcp](http://msdn.microsoft.com/en-us/library/aa337544%28v=sql.110%29.aspx) oder [Importieren von Massendaten mithilfe von BULK INSERT oder OPENROWSET(BULK...)](http://msdn.microsoft.com/en-us/library/ms175915%28v=sql.110%29.aspx) in der SQL Server-Dokumentation, abhängig von Ihrer Entscheidung in Schritt 11.
# Verwenden des BCP-Dienstprogramms von Linux zum Importieren und Exportieren von Daten
Das BCP-Dienstprogramm bietet eine effiziente Möglichkeit, große Datenmengen zwischen Ihrer DB-Instance von RDS für SQL Server und Datendateien zu übertragen. Sie können BCP von Linux-Umgebungen aus verwenden, um Massendatenoperationen durchzuführen. Dies ist für Datenmigrationen, ETL-Prozesse und regelmäßige Datenübertragungen nützlich.
BCP unterstützt sowohl das Importieren von Daten aus Dateien in SQL-Server-Tabellen als auch das Exportieren von Daten aus SQL-Server-Tabellen in Dateien. Dies ist besonders effektiv für die Übertragung strukturierter Daten in verschiedenen Formaten, einschließlich Textdateien mit Trennzeichen.
## Voraussetzungen
Bevor Sie BCP mit Ihrer DB-Instance von RDS für SQL Server verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Eine Linux-Umgebung mit Netzwerkverbindung zu Ihrer DB-Instance von RDS für SQL Server
+ Befehlszeilen-Tools von Microsoft SQL Server, die auf Ihrem Linux-System installiert sind, einschließlich:
+ sqlcmd: Befehlszeilen-Abfrage-Tool von SQL Server
+ bcp: Dienstprogramm zum Massenkopieren
+ Gültige Anmeldeinformationen für Ihre DB-Instance von RDS für SQL Server
+ Netzwerkzugriff, der über Sicherheitsgruppen konfiguriert wird, um Verbindungen über den SQL-Server-Port zuzulassen (normalerweise 1433)
+ Geeignete Datenbankberechtigungen für die Operationen, die Sie ausführen möchten
## Installieren der Befehlszeilen-Tools von SQL Server unter Linux
Um BCP von Linux aus zu verwenden, müssen Sie die Befehlszeilen-Tools von Microsoft SQL Server installieren. Detaillierte Installationsanleitungen für Ihre spezifische Linux-Distribution finden Sie in der folgenden Microsoft-Dokumentation:
+ [Install sqlcmd and bcp the SQL Server command-line tools on Linux](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-tools)
+ [bcp utility](https://docs.microsoft.com/en-us/sql/tools/bcp-utility) – Vollständige Referenz für das BCP-Dienstprogramm
Stellen Sie nach der Installation sicher, dass die Tools in Ihrem PATH verfügbar sind, indem Sie folgenden Befehl ausführen:
```
bcp -v
sqlcmd -?
```
## Exportieren von Daten aus RDS für SQL Server
Sie können BCP verwenden, um Daten aus Ihrer DB-Instance von RDS für SQL Server in Dateien auf Ihrem Linux-System zu exportieren. Dies ist nützlich, um Backups zu erstellen, Daten zu analysieren oder Daten für die Migration vorzubereiten.
### Grundlegende Syntax für den Export
Die grundlegende Syntax für den Export von Daten mit BCP lautet:
```
bcp database.schema.table out output_file -S server_name -U username -P password [options]
```
Wobei gilt:
+ `database.schema.table` – Vollständig qualifizierter Tabellenname
+ `output_file` – Pfad und Name der Ausgabedatei
+ `server_name` – Ihr Endpunkt von RDS für SQL Server
+ `username` – Ihr Datenbankbenutzername
+ `password` – Ihr Datenbankpasswort
### Exportbeispiel
Das folgende Beispiel exportiert Daten aus einer Tabelle namens `customers` in der Datenbank `sales`:
```
bcp sales.dbo.customers out /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n"
```
Dieser Befehl:
+ exportiert Daten aus der Tabelle `customers`
+ speichert die Ausgabe unter `/home/user/customers.txt`
+ verwendet das Zeichenformat (`-c`)
+ verwendet Pipe (\$1) als Feldtrennzeichen (`-t "|"`)
+ verwendet Newline als Zeilentrennzeichen (`-r "\n"`)
## Importieren von Daten in RDS für SQL Server
Sie können BCP verwenden, um Daten aus Dateien auf Ihrem Linux-System in Ihre DB-Instance von RDS für SQL Server zu importieren. Dies ist nützlich für die Datenmigration, das Laden von Testdaten oder regelmäßige Datenaktualisierungen.
### Grundlegende Syntax für den Import
Die grundlegende Syntax für den Import von Daten mit BCP lautet:
```
bcp database.schema.table in input_file -S server_name -U username -P password [options]
```
Wobei gilt:
+ `database.schema.table` – Vollständig qualifizierter Name der Zieltabelle
+ `input_file` – Pfad und Name der Eingabedatei
+ `server_name` – Ihr Endpunkt von RDS für SQL Server
+ `username` – Ihr Datenbankbenutzername
+ `password` – Ihr Datenbankpasswort
### Importbeispiel
Das folgende Beispiel importiert Daten aus einer Datei in eine Tabelle namens `customers`:
```
bcp sales.dbo.customers in /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n" \
-b 1000
```
Dieser Befehl:
+ importiert Daten in die `customers`-Tabelle
+ liest Daten aus `/home/user/customers.txt`
+ verwendet das Zeichenformat (`-c`)
+ verwendet Pipe (\$1) als Feldtrennzeichen (`-t "|"`)
+ verwendet Newline als Zeilentrennzeichen (`-r "\n"`)
+ verarbeitet Daten in Stapeln von 1 000 Zeilen (`-b 1000`)
## Allgemeine BCP-Optionen
BCP bietet zahlreiche Optionen zur Steuerung der Datenformatierung und des Übertragungsverhaltens. Die folgende Tabelle beschreibt häufig verwendete Optionen:
| Option | Beschreibung |
| --- | --- |
| -c | Verwendet den Zeichendatentyp für alle Spalten |
| -n | Verwendet native Datenbank-Datentypen |
| -t | Gibt das Feldtrennzeichen an (Standard ist Tab) |
| -r | Gibt das Zeilentrennzeichen an (Standard ist Newline) |
| -b | Gibt die Stapelgröße für Massenoperationen an |
| -F | Gibt die erste Zeile an, die exportiert oder importiert werden soll |
| -L | Gibt die letzte Zeile an, die exportiert oder importiert werden soll |
| -e | Gibt eine Fehlerdatei zum Erfassen abgelehnter Zeilen an |
| -f | Gibt eine Formatdatei für die Datenformatierung an |
| -q | Verwendet Bezeichner in Anführungszeichen für Objektnamen |
## Bewährte Methoden und Überlegungen
Wenn Sie BCP mit RDS für SQL Server von Linux aus verwenden, sollten Sie die folgenden bewährte Methoden beachten:
+ **Stapelverarbeitung verwenden** – Verwenden Sie bei großen Datensätzen die Option `-b`, um Daten stapelweise zu verarbeiten. Dies verbessert die Leistung und ermöglicht eine bessere Wiederherstellung nach Fehlern.
+ **Fehler ordnungsgemäß behandeln** – Verwenden Sie die Option `-e`, um Fehlerinformationen und abgelehnte Zeilen zur Analyse in einer separaten Datei zu erfassen.
+ **Geeignete Datenformate wählen** – Verwenden Sie das Zeichenformat (`-c`) für plattformübergreifende Kompatibilität oder das native Format (`-n`) für eine bessere Leistung, wenn sowohl Quelle als auch Ziel SQL Server sind.
+ **Anmeldeinformationen schützen** – Vermeiden Sie es, Passwörter direkt in Befehlszeilen einzugeben. Erwägen Sie die Verwendung von Umgebungsvariablen oder Konfigurationsdateien mit entsprechenden Berechtigungen.
+ **Mit kleinen Datensätzen testen** – Bevor Sie große Datenmengen verarbeiten, testen Sie Ihre BCP-Befehle mit kleineren Datensätzen, um die Formatierung und Konnektivität zu überprüfen.
+ **Netzwerkkonnektivität überwachen** – Sorgen Sie für stabile Netzwerkverbindungen, insbesondere bei großen Datenübertragungen. Erwägen Sie die Verwendung von Tools wie `screen` oder `tmux` für lang andauernde Operationen.
+ **Datenintegrität validieren** – Überprüfen Sie nach der Datenübertragung die Zeilenanzahl und Daten stichprobenartig, um sicherzustellen, dass der Vorgang erfolgreich abgeschlossen wurde.
## Behebung häufiger Probleme
In der folgenden Tabelle werden häufig auftretende Probleme beschrieben, die bei der Verwendung von BCP unter Linux auftreten können, sowie deren Lösungen:
| Problem | Lösung |
| --- | --- |
| Verbindungs-Timeout oder Netzwerkfehler | Überprüfen Sie Ihren Amazon-RDS-Endpunkt, Ihre Sicherheitsgruppeneinstellungen und Ihre Netzwerkkonnektivität. Stellen Sie sicher, dass der SQL-Server-Port (normalerweise 1433) von Ihrem Linux-System aus zugänglich ist. |
| Authentication failures (Authentifizierungsfehler) | Überprüfen Sie Ihren Benutzernamen und Ihr Passwort. Stellen Sie sicher, dass der Datenbankbenutzer über die entsprechenden Berechtigungen für die von Ihnen ausgeführten Operationen verfügt. |
| Datenformatfehler | Überprüfen Sie Ihre Feld- und Zeilentrennzeichen. Stellen Sie sicher, dass das Datenformat den Erwartungen von BCP entspricht. Verwenden Sie Formatdateien für komplexe Datenstrukturen. |
| Fehler bei abgelehnter Berechtigung | Stellen Sie sicher, dass Ihr Datenbankbenutzer über INSERT-Berechtigungen für Importe oder SELECT-Berechtigungen für Exporte in den Zieltabellen verfügt. |
| Probleme mit der Handhabung großer Dateien | Verwenden Sie die Stapelverarbeitung mit der Option -b. Erwägen Sie, große Dateien in kleinere Teile aufzuteilen, um die Leistung zu verbessern und Fehler zu beheben. |
| Probleme mit der Zeichenkodierung | Stellen Sie sicher, dass Ihre Datendateien eine kompatible Zeichenkodierung verwenden. Verwenden Sie die Option -c für das Zeichenformat oder geben Sie die entsprechenden Codepages an. |
# Arbeiten mit Read Replicas für Microsoft SQL Server in Amazon RDS
Sie verwenden Lesereplikate üblicherweise, um die Replikation zwischen Amazon-RDS-DB-Instances zu konfigurieren. Allgemeine Informationen zu Lesereplikaten finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
In diesem Abschnitt finden Sie spezifische Informationen zum Arbeiten mit Lesereplikaten unter Amazon RDS für SQL Server.
+ [Synchronisieren von Datenbankbenutzern und -objekten mit einem Lesereplikat von SQL Server](SQLServer.ReadReplicas.ObjectSynchronization.md)
+ [Fehlerbehebung für ein Problem mit einem SQL Server-Read Replica](SQLServer.ReadReplicas.Troubleshooting.md)
## Konfigurieren von Read Replicas für SQL Server
Bevor eine DB-Instance als Quell-Instance für die Replikation eingesetzt werden kann, müssen Sie automatische Sicherungen auf der Quell-DB-Instance aktivieren. Hierzu legen Sie für den Aufbewahrungszeitraum für Sicherungen einen anderen Wert als 0 fest. Durch das Festlegen dieses Bereitstellungstyps wird außerdem erzwungen, dass automatische Sicherungen aktiviert sind.
Das Erstellen eines SQL Server-Lesereplikats erfordert keinen Wartungsausfall für die primäre DB-Instance. Amazon RDS legt die erforderlichen Parameter und Berechtigungen für die Quelldatenbank-Instance und das Lesereplikat ohne Serviceunterbrechung fest. Ein Snapshot von der Quell-DB-Instance wird gemacht und dieser Snapshot wird zum Lesereplikat. Es findet kein Nutzungsausfall statt, wenn Sie ein Lesereplikat löschen.
Sie können bis zu 15 Lesereplikate aus einer Quell-DB-Instance erstellen. Damit die Replikation effektiv durchgeführt werden kann, empfehlen wir Ihnen, jedes Lesereplikat mit derselben Menge an Rechen- und Speicherressourcen wie die Quell-DB-Instance zu konfigurieren. Wenn Sie die Quell-DB-Instance skalieren, skalieren Sie auch die Lesereplikate.
Die SQL-Server-DB-Engine-Version der Quell-DB-Instance und alle Lese-Replikate müssen identisch sein. Amazon RDS aktualisiert die primäre Instance unmittelbar nach dem Upgrade der Lesereplikate, unabhängig vom Wartungsfenster. Weitere Informationen zum Aktualisieren der DB-Engine-Version finden Sie unter [Upgrades der DB-Engine von Microsoft SQL Server](USER_UpgradeDBInstance.SQLServer.md).
Damit ein Lesereplikat Änderungen von der Quelle empfängt und anwendet, sollte es über ausreichende Rechen- und Speicherressourcen verfügen. Wenn ein Lesereplikat die Kapazität von Rechen-, Netzwerk- und Speicherressourcen erreicht hat, stellt das Lesereplikat den Empfang und die Anwendung von Änderungen aus seiner Quelle ein. Sie können die Speicher- und CPU-Ressourcen eines Lesereplikats unabhängig von seiner Quelle und anderen Lesereplikaten ändern.
Informationen zum Erstellen eines Lesereplikats finden Sie unter [Erstellen eines Lesereplikats](USER_ReadRepl.Create.md).
## Read-Replica-Einschränkungen mit SQL Server
Die folgenden Einschränkungen gelten für SQL Server-Lesereplikate in Amazon RDS:
+ Lesereplikate sind nur auf der SQL Server Enterprise Edition (EE)-Engine verfügbar.
+ Lesereplikat sind für SQL-Server-Version 2016–2022 verfügbar.
+ Sie können bis zu 15 Lesereplikate aus einer Quell-DB-Instance erstellen. Die Replikation kann verzögert werden, wenn Ihre Quell-DB-Instance über mehr als 5 Lesereplikate verfügt.
+ Lesereplikate sind nur für DB-Instances verfügbar, die auf DB-Instance-Klassen mit vier oder mehr vCPUs ausgeführt werden.
+ Ein Lesereplikat unterstützt je nach Instance-Klassentyp und Verfügbarkeitsmodus bis zu 100 Datenbanken. Sie müssen Datenbanken auf der Quell-DB-Instance erstellen, um sie automatisch auf die Lesereplikate zu replizieren. Sie können keine einzelnen Datenbanken für die Replikation auswählen. Weitere Informationen finden Sie unter [Einschränkungen für Microsoft SQL Server-DB-Instances](CHAP_SQLServer.md#SQLServer.Concepts.General.FeatureSupport.Limits).
+ Sie können eine Datenbank nicht aus einem Lesereplikat entfernen. Um eine Datenbank zu entfernen, entfernen Sie sie mit der gespeicherten Prozedur `rds_drop_database` aus der Quell-DB-Instance. Weitere Informationen finden Sie unter [Verwerfen einer Datenbank in einer DB-Instance in Amazon RDS für Microsoft SQL Server](Appendix.SQLServer.CommonDBATasks.DropMirrorDB.md).
+ Wenn die Quell-DB-Instance Transparent Data Encryption (TDE) zur Verschlüsselung von Daten verwendet, konfiguriert das Lesereplikat TDE ebenfalls automatisch.
Wenn die Quell-DB-Instance einen KMS-Schlüssel zur Verschlüsselung von Daten verwendet, verwenden Lesereplikate in derselben Region denselben KMS-Schlüssel. Bei regionsübergreifenden Lesereplikaten müssen Sie beim Erstellen des Lesereplikats einen KMS-Schlüssel aus der Region des Lesereplikats angeben. Sie können den KMS-Schlüssel für ein Lesereplikat nicht ändern.
+ Lesereplikate haben dieselbe Zeitzone und Sortierung wie die Quell-DB-Instance, unabhängig von der Availability Zone, in der sie erstellt wurden.
+ Folgendes wird in Amazon RDS für SQL Server nicht unterstützt:
+ Backup-Aufbewahrung von Lesereplikaten
+ Zeitpunktbezogene Wiederherstellung aus Lesereplikaten
+ Manuelle Snapshots von Lesereplikaten
+ Multi-AZ-Lesereplikate
+ Erstellen von Lesereplikaten aus Lesereplikaten
+ Synchronisierung von Benutzeranmeldungen bei Lesereplikaten
+ Amazon RDS für SQL Server greift nicht ein, um eine hohe Replikationsverzögerung zwischen einer Quell-DB-Instance und ihren Lesereplikaten zu minimieren. Stellen Sie sicher, dass die Quell-DB-Instance und ihre Lesereplikate in Bezug auf Rechen- und Speicherkapazität die für ihre Betriebslast angemessene Größe aufweisen.
+ Sie können zwischen den Regionen AWS GovCloud (USA Ost) und AWS GovCloud (USA-West) replizieren, aber nicht in oder aus AWS GovCloud (US) Regions.
## Überlegungen zu Optionen für Replikate von RDS für SQL Server
Bevor Sie ein Replikat von RDS für SQL Server erstellen, sollten Sie die folgenden Anforderungen, Einschränkungen und Empfehlungen berücksichtigen:
+ Wenn sich Ihr SQL-Server-Replikat in derselben Region befindet wie die Quell-DB-Instance, stellen Sie sicher, dass es zur gleichen Optionsgruppe gehört wie die Quell-DB-Instance. Änderungen an der Quell-Optionsgruppe oder der Quell-Optionsgruppenmitgliedschaft werden von den Replikaten übernommen. Diese Änderungen werden unmittelbar, nachdem sie auf die Quell-DB-Instance angewandt wurden, auf die Replikate angewandt, ungeachtet des Wartungsfensters des Replikats.
Weitere Informationen über Optionsgruppen finden Sie unter [Arbeiten mit Optionsgruppen](USER_WorkingWithOptionGroups.md).
+ Wenn Sie ein regionsübergreifendes SQL-Server-Replikat erstellen, erstellt Amazon RDS dafür eine dedizierte Optionsgruppe.
Ein regionsübergreifendes SQL-Server-Replikat kann nicht aus seiner dedizierten Optionsgruppe entfernt werden. Die dedizierte Optionsgruppe eines regionsübergreifenden SQL-Server-Replikats kann nicht von anderen DB-Instances verwendet werden.
Bei den folgenden Optionen handelt es sich um replizierte Optionen. Wenn Sie einem regionsübergreifenden SQL-Server-Replikat replizierte Optionen hinzufügen möchten, fügen Sie es der Optionsgruppe der Quell-DB-Instance hinzu. Die Option wird auch auf allen Replikaten der Quell-DB-Instance installiert.
+ `TDE`
Bei den folgenden Optionen handelt es sich nicht um replizierte Optionen. Sie können nicht replizierte Optionen einer dedizierten Optionsgruppe hinzufügen oder daraus entfernen.
+ `MSDTC`
+ `SQLSERVER_AUDIT`
+ Wenn Sie die `SQLSERVER_AUDIT`-Option für ein regionsübergreifendes Replikat aktivieren möchten, fügen Sie die `SQLSERVER_AUDIT`-Option der dedizierten Optionsgruppe für das regionsübergreifende Lesereplikat und die Optionsgruppe der Quell-Instance hinzu. Indem Sie die `SQLSERVER_AUDIT`-Option für die Quell-Instance des regionsübergreifenden Lesereplikats von SQL Server hinzufügen, können Sie für jedes der regionsübergreifenden Lesereplikate der Quell-Instance ein Prüfobjekt auf Serverebene und Prüfspezifikationen auf Serverebene erstellen. Wenn Sie den regionsübergreifenden Lesereplikaten Zugriffberechtigungen für das Hochladen der abgeschlossenen Prüfprotokolle in einen Amazon-S3-Bucket gewähren möchten, fügen Sie der dedizierten Optionsgruppe die `SQLSERVER_AUDIT`-Option hinzu und konfigurieren Sie die Optionseinstellungen. Der als Ziel für die Überwachungsdateien verwendete Amazon-S3-Bucket muss sich in derselben Region befinden wie das regionsübergreifende Lesereplikat. Sie können die Optionseinstellung der `SQLSERVER_AUDIT`-Option für jedes regionsübergreifende Lesereplikat unabhängig ändern, sodass jedes Replikat in seiner jeweiligen Region auf einen Amazon-S3-Bucket zugreifen kann.
Die folgenden Optionen werden für Lesereplikate nicht unterstützt.
+ `SSRS`
+ `SSAS`
+ `SSIS`
Die folgenden Optionen werden für regionsübergreifende Lesereplikate teilweise unterstützt.
+ `SQLSERVER_BACKUP_RESTORE`
+ Die Quell-DB-Instance eines regionsübergreifenden SQL-Server-Replikats kann über die `SQLSERVER_BACKUP_RESTORE`-Option verfügen, Sie können jedoch erst systemeigene Wiederherstellungen für die Quell-DB-Instance durchführen, wenn Sie alle ihre regionsübergreifenden Replikate gelöscht haben. Alle vorhandenen systemeigenen Wiederherstellungsaufgaben werden bei der Erstellung eines regionsübergreifenden Replikats abgebrochen. Sie können die `SQLSERVER_BACKUP_RESTORE`-Option nicht einer dedizierten Optionsgruppe hinzufügen.
Weitere Informationen zu systemeigenen Backups und Wiederherstellungen finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
Wenn Sie ein regionsübergreifendes SQL-Server-Lesereplikat hochstufen, verhält sich das hochgestufte Lesereplikat genau so wie andere DB-Instances von SQL Server, einschließlich der Verwaltung seiner Optionen. Weitere Informationen über Optionsgruppen finden Sie unter [Arbeiten mit Optionsgruppen](USER_WorkingWithOptionGroups.md).
# Synchronisieren von Datenbankbenutzern und -objekten mit einem Lesereplikat von SQL Server
Es wird erwartet, dass alle Anmeldungen, benutzerdefinierten Serverrollen, SQL-Agent-Jobs oder andere Objekte auf Serverebene, die zum Zeitpunkt der Erstellung eines Lesereplikats in der primären DB-Instance existieren, im neu erstellten Lesereplikat vorhanden sind. Objekte auf Serverebene, die nach der Erstellung des Lesereplikats in der primären DB-Instance erstellt wurden, werden jedoch nicht automatisch repliziert. Sie müssen sie manuell im Lesereplikat erstellen.
Die Datenbankbenutzer werden automatisch von der primären DB-Instance in das Lesereplikat repliziert. Da sich die Lesereplikat-Datenbank im schreibgeschützten Modus befindet, kann die Sicherheits-ID (SID) des Datenbankbenutzers in der Datenbank nicht aktualisiert werden. Daher muss beim Erstellen von SQL-Anmeldungen im Lesereplikat unbedingt sichergestellt werden, dass die SID dieser Anmeldung mit der SID der entsprechenden SQL-Anmeldung in der primären DB-Instance übereinstimmt. Wenn Sie die SIDs SQL-Logins nicht synchronisieren, können sie nicht auf die Datenbank in der Read Replica zugreifen. Bei authentifizierten Windows Active Directory (AD)-Anmeldungen tritt dieses Problem nicht auf, da der SQL Server die SID von Active Directory bezieht.
**So synchronisieren Sie eine SQL-Anmeldung der primären DB-Instance mit dem Lesereplikat**
1. Stellen Sie eine Verbindung mit der primären DB-Instance her.
1. Erstellen Sie in der primären DB-Instance eine neue SQL-Anmeldung.
```
USE [master]
GO
CREATE LOGIN TestLogin1
WITH PASSWORD = 'REPLACE WITH PASSWORD';
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
1. Erstellen Sie einen neuen Datenbankbenutzer für die SQL-Anmeldung in der Datenbank.
```
USE [REPLACE WITH YOUR DB NAME]
GO
CREATE USER TestLogin1 FOR LOGIN TestLogin1;
GO
```
1. Überprüfen Sie die SID der neu erstellten SQL-Anmeldung in der primären DB-Instance.
```
SELECT name, sid FROM sys.server_principals WHERE name = 'TestLogin1';
```
1. Stellen Sie eine Verbindung mit dem Lesereplikat her. Erstellen Sie die neue SQL-Anmeldung.
```
CREATE LOGIN TestLogin1 WITH PASSWORD = 'REPLACE WITH PASSWORD', SID=REPLACE WITH sid FROM STEP #4;
```
**Wenn Sie Zugriff auf die Lesereplikat-Datenbank haben, können Sie den verwaisten Benutzer alternativ wie folgt korrigieren:**
1. Stellen Sie eine Verbindung mit dem Lesereplikat her.
1. Identifizieren Sie die verwaisten Benutzer in der Datenbank.
```
USE [REPLACE WITH YOUR DB NAME]
GO
EXEC sp_change_users_login 'Report';
GO
```
1. Erstellen Sie eine neue SQL-Anmeldung für den verwaisten Datenbankbenutzer.
```
CREATE LOGIN TestLogin1 WITH PASSWORD = 'REPLACE WITH PASSWORD', SID=REPLACE WITH sid FROM STEP #2;
```
Beispiel:
```
CREATE LOGIN TestLogin1 WITH PASSWORD = 'TestPa$$word#1', SID=0x1A2B3C4D5E6F7G8H9I0J1K2L3M4N5O6P;
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
# Fehlerbehebung für ein Problem mit einem SQL Server-Read Replica
Sie können die Replikationsverzögerung in Amazon CloudWatch überwachen, indem Sie die Amazon-RDS-Metrik `ReplicaLag` anzeigen. Weitere Informationen zur zeitlichen Verzögerung bei der Replikation finden Sie unter [Überwachen der Lesereplikation](USER_ReadRepl.Monitoring.md).
Wenn Replikationsverzögerung zu groß ist, können Sie die folgende Abfrage verwenden, um Informationen über die Verzögerung abzurufen.
```
SELECT AR.replica_server_name
, DB_NAME (ARS.database_id) 'database_name'
, AR.availability_mode_desc
, ARS.synchronization_health_desc
, ARS.last_hardened_lsn
, ARS.last_redone_lsn
, ARS.secondary_lag_seconds
FROM sys.dm_hadr_database_replica_states ARS
INNER JOIN sys.availability_replicas AR ON ARS.replica_id = AR.replica_id
--WHERE DB_NAME(ARS.database_id) = 'database_name'
ORDER BY AR.replica_server_name;
```
# Multi-AZ-Bereitstellungen für Amazon RDS für Microsoft SQL Server
Multi-AZ-Bereitstellungen bieten eine erhöhte Verfügbarkeit, eine längere Lebensdauer von Daten sowie eine höhere Fehlertoleranz für DB-Instances. Im Falle einer geplanten Datenbankwartung oder einer ungeplanten Serviceunterbrechung führt Amazon RDS automatisch einen Failover zur up-to-date 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.
Amazon RDS unterstützt Multi-AZ-Bereitstellungen für Microsoft SQL Server mithilfe von SQL Server Database Mirroring (DBM), Always On Availability Groups (AGs) oder Replikation auf Blockebene. Amazon RDS überwacht und pflegt die Integrität Ihrer Multi-AZ-Bereitstellung. Bei Problemen repariert RDS fehlerhafte DB-Instances automatisch, stellt die Synchronisierung neu her und initiiert Failover. Failover treten nur auf, wenn Standby- und Primär-Instance vollständig synchron sind. Sie müssen nichts verwalten.
Wenn Sie SQL Server Multi-AZ einrichten, konfiguriert RDS automatisch alle Datenbanken auf der Instance für die Verwendung von DBM oder Replikation auf Blockebene. AGs Amazon RDS verwaltet die primäre, die Zeugen-DB-Instance und die sekundäre DB-Instance für Sie, wenn Sie DBM konfigurieren oder AGs. Bei der Replikation auf Blockebene verarbeitet RDS die primäre und die sekundäre DB-Instance. Da die Konfiguration automatisch erfolgt, wählt RDS die DBM-, AGs Always-On-Replikation oder die Replikation auf Blockebene basierend auf der Version von SQL Server, die Sie bereitstellen.
Amazon RDS unterstützt Multi-AZ mit Always On AGs für die folgenden SQL Server-Versionen und -Editionen:
+ SQL Server 2022:
+ Standard Edition
+ Enterprise Edition
+ SQL Server 2019:
+ Standard Edition 15.00.4073.23 und höher
+ Enterprise Edition
+ SQL Server 2017:
+ Standard Edition 14.00.3401.7 und höher
+ Enterprise Edition 14.00.3049.1 und höher
+ SQL Server 2016: Enterprise Edition 13.00.5216.0 und höher
Amazon RDS unterstützt Multi-AZ mit DBM für die folgenden SQL Server-Versionen und -Editionen mit Ausnahme der zuvor erwähnten Versionen:
+ SQL Server 2019: Standard Edition 15.00.4043.16
+ SQL Server 2017: Standard und Enterprise Editions
+ SQL Server 2016: Standard und Enterprise Editions
Amazon RDS unterstützt Multi-AZ mit Replikation auf Blockebene für SQL Server 2022 Web Edition 16.00.4215.2 und höher.
**Anmerkung**
Nur neue DB-Instances, die mit 16.00.4215.2 oder höher erstellt wurden, unterstützen Multi-AZ-Bereitstellungen mit Replikation auf Blockebene. Die folgenden Einschränkungen gelten für bestehende SQL Server 2022 Web Edition-Instances:
Für bestehende Instanzen der Version 16.00.4215.2 müssen Sie einen Snapshot auf einer neuen Instanz mit derselben oder einer höheren Nebenversion wiederherstellen, um die Replikation auf Blockebene zu aktivieren.
SQL Server 2022-Webinstanzen mit einer älteren Nebenversion können auf die Nebenversion 16.00.4215.2 oder höher aktualisiert werden, um die Replikation auf Blockebene zu ermöglichen.
Sie können die folgende SQL-Abfrage verwenden, um festzustellen, ob es sich bei Ihrer SQL Server-DB-Instance um Single-AZ, Multi-AZ mit DBM oder Multi-AZ mit Always On handelt. AGs Diese Abfrage gilt nicht für Multi-AZ-Bereitstellungen auf SQL Server Web Edition.
```
SELECT CASE WHEN dm.mirroring_state_desc IS NOT NULL THEN 'Multi-AZ (Mirroring)'
WHEN dhdrs.group_database_id IS NOT NULL THEN 'Multi-AZ (AlwaysOn)'
ELSE 'Single-AZ'
END 'high_availability'
FROM sys.databases sd
LEFT JOIN sys.database_mirroring dm ON sd.database_id = dm.database_id
LEFT JOIN sys.dm_hadr_database_replica_states dhdrs ON sd.database_id = dhdrs.database_id AND dhdrs.is_local = 1
WHERE DB_NAME(sd.database_id) = 'rdsadmin';
```
Die Ausgabe sieht in etwa folgendermaßen aus:
```
high_availability
Multi-AZ (AlwaysOn)
```
## Hinzufügen von Multi-AZ zu einer Microsoft SQL Server-DB-Instance
Wenn Sie eine neue SQL Server-DB-Instance mit dem erstellen AWS-Managementkonsole, können Sie Multi-AZ mit Datenbankspiegelung (DBM), Always On oder Replikation auf AGs Blockebene hinzufügen. **Wählen Sie dazu in der Multi-AZ-Bereitstellung die **Option Ja (Mirroring/Always On/Block Level Replication)** aus.** Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
**Wenn Sie eine vorhandene SQL Server-DB-Instance mithilfe der Konsole ändern, können Sie Multi-AZ mit DBM oder Replikation auf Blockebene hinzufügen AGs, indem Sie bei der **Multi-AZ-Bereitstellung** auf der Seite DB-Instance ändern die Option **Ja (Mirroring/Always On/Block Level Replication)** auswählen.** Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
**Anmerkung**
Wenn auf Ihrer DB-Instance Database Mirroring (DBM) und nicht Always On Availability Groups (AGs) ausgeführt wird, müssen Sie möglicherweise die speicherinterne Optimierung deaktivieren, bevor Sie Multi-AZ hinzufügen. Deaktivieren Sie die In-Memory-Optimierung mit DBM, bevor Sie Multi-AZ hinzufügen, wenn Ihre DB-Instance SQL Server 2016 oder 2017 Enterprise Edition ausführt und die In-Memory-Optimierung aktiviert ist.
Wenn auf Ihrer DB-Instance eine Replikation auf Blockebene für SQL Server Web Editions ausgeführt AGs wird, ist dieser Schritt nicht erforderlich.
## Entfernen von Multi-AZ aus einer Microsoft SQL Server-DB-Instance
Wenn Sie eine vorhandene SQL Server-DB-Instance mithilfe von ändern AWS-Managementkonsole, können Sie Multi-AZ mit DBM oder Replikation AGs auf Blockebene entfernen. Sie können dies tun, indem Sie auf der Seite DB-Instance **ändern** unter **Multi-AZ-Bereitstellung** die Option **Nein (Spiegelung/Always On/Replikation auf Blockebene)** auswählen. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
# Einschränkungen, Hinweise und Empfehlungen für Microsoft SQL Server Multi-AZ-Bereitstellung
Im Folgenden sind einige Einschränkungen beim Arbeiten mit Multi-AZ-Bereitstellungen auf RDS für SQL Server-DB-Instances aufgeführt:
+ Regionsübergreifende Multi-AZ wird nicht unterstützt.
+ Das Beenden einer DB-Instance von RDS für SQL Server in einer Multi-AZ-Bereitstellung wird nicht unterstützt.
+ Sie können die sekundäre DB-Instance nicht so konfigurieren, dass sie die Datenbankleseaktivität akzeptiert.
+ Multi-AZ mit Always-On-Verfügbarkeitsgruppen (AGs) unterstützt die speicherinterne Optimierung.
+ Multi-AZ mit Always-On-Verfügbarkeitsgruppen (AGs) unterstützt keine Kerberos-Authentifizierung für den Verfügbarkeitsgruppen-Listener. Dies liegt daran, dass der Listener keinen Service-Prinzipalnamen (SPN, Service Principal Name) hat.
+ Multi-AZ mit Replikation auf Blockebene wird derzeit nur für SQL Server Web Edition-Instanzen unterstützt.
+ Sie können eine Datenbank in einer SQL Server-DB-Instance nicht umbenennen, die sich in einer SQL Server-Multi-AZ-Bereitstellung befindet. Falls Sie eine Datenbank in einer derartigen Instance umbenennen müssen, deaktivieren Sie erst Multi-AZ für die DB-Instance und benennen dann die Datenbank um. Aktivieren Sie letztendlich Multi-AZ wieder für die DB-Instance.
+ Sie können nur Multi-AZ-DB-Instances wiederherstellen, die mithilfe des vollständigen Wiederherstellungsmodells gesichert wurden.
+ Multi-AZ-Bereitstellungen haben ein Limit von 10 000 SQL-Server-Agent-Aufträgen.
Wenn Sie ein höheres Limit benötigen, fordern Sie eine Erhöhung an, indem Sie sich an uns wenden Support. Öffnen Sie die Seite des [AWS Support -Centers](https://console.aws.amazon.com/support/home#/), melden Sie sich an und wählen Sie **Fall erstellen** aus. Wählen Sie **Service Limit increase (Erhöhung des Servicelimits)**. Füllen Sie das Formular aus und senden Sie es ab.
+ Sie können keine Offline-Datenbank auf einer DB-Instance von SQL Server haben, die sich in einer Multi-AZ-Bereitstellung von SQL Server befindet.
+ RDS für SQL Server repliziert keine MSDB-Datenbankberechtigungen auf die sekundäre Instance. Wenn Sie diese Berechtigungen für die sekundäre Instance benötigen, müssen Sie sie manuell neu erstellen.
+ Volume-Metriken sind für den sekundären Host der Instance, die Replikation auf Blockebene verwendet, nicht verfügbar.
Hinweise zur Arbeit mit Multi-AZ-Bereitstellungen auf RDS für SQL Server-DB-Instances:
+ Amazon RDS macht den [Listener-Endpunkt der AGs Always-On-Verfügbarkeitsgruppe verfügbar](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/listeners-client-connectivity-application-failover). Der Endpunkt ist in der Konsole sichtbar und wird vom `DescribeDBInstances`-API-Vorgang als Eintrag im Feld mit den Endpunkten zurückgegeben.
+ Amazon RDS unterstützt [Failover bei mehreren Subnetzen in Verfügbarkeitsgruppen](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/listeners-client-connectivity-application-failover).
+ Zur Verwendung von SQL Server-Multi-AZ mit einer SQL Server-DB-Instance in einer Virtual Private Cloud (VPC) erstellen Sie zuerst eine DB-Subnetzgruppe, die Subnetze in mindestens zwei verschiedenen Availability Zones aufweist. Sie weisen anschließend die DB-Subnetzgruppe dem primären Replica der SQL Server-DB-Instance zu.
+ Wenn eine DB-Instance in eine Multi-AZ-Bereitstellung geändert wird, hat sie während der Änderung den Status **Modifying (Wird geändert …)**. Amazon RDS erstellt den Standby und erstellt ein Backup der primären DB-Instance. Wenn der Prozess abgeschlossen ist, ändert sich der Status der primären DB-Instance zu **Available (Verfügbar)**.
+ Multi-AZ-Bereitstellungen verwalten alle Datenbanken auf demselben Knoten. Bei einem Failover einer Datenbank auf dem primären Host erfolgt ein Failover für alle Ihre SQL Server-Datenbanken als Einheit auf Ihren Standby-Host. Amazon RDS stellt einen neuen fehlerfreien Host bereit und ersetzt den fehlerhaften Host.
+ Multi-AZ mit DBM oder Replikation auf Blockebene unterstützt ein einzelnes Standby-Replikat. AGs
+ Benutzer, Logins und Berechtigungen werden auf der sekundären Instance automatisch für Sie repliziert. Sie müssen sie nicht erneut erstellen. Benutzerdefinierte Serverrollen werden in DB-Instances repliziert, die Always-On-Replikation AGs oder Replikation auf Blockebene für Multi-AZ-Bereitstellungen verwenden.
+ In Multi-AZ-Bereitstellungen erstellt RDS for SQL Server SQL Server-Logins, um AlwaysOn oder Datenbankspiegelung zu ermöglichen. AGs RDS erstellt Anmeldungen mit dem folgenden Muster: `db__node1_login`, `db__node2_login` und `db__witness_login`.
+ RDS für SQL Server erstellt eine SQL-Server-Anmeldung, um den Zugriff auf Lesereplikate zu ermöglichen. RDS erstellt eine Anmeldung mit dem folgenden Muster: `db__node_login`.
+ In Multi-AZ-Bereitstellungen werden Aufträge von SQL Server Agent vom primären Host auf den sekundären Host repliziert, wenn die Auftragsreplikationsfunktion aktiviert ist. Weitere Informationen finden Sie unter [Aktivieren der Auftragsreplikation von SQL Server Agent](Appendix.SQLServer.CommonDBATasks.Agent.md#SQLServerAgent.Replicate).
+ Aufgrund der synchronen Datenreplikation kann es zu erhöhten Latenzen im Vergleich zur standardmäßigen Bereitstellung einer DB-Instance in einer einzigen Availability Zone kommen.
+ Die Failover-Zeiten sind von der Zeit abhängig, die für den Wiederherstellungsprozess benötigt wird. Große Transaktionen erhöhen die Failover-Zeit.
+ In SQL Server-Multi-AZ-Bereitstellungen wird bei einem Neustart mit Failover nur die primäre DB-Instance neu gestartet. Nach dem Failover wird die primäre DB-Instance zur neuen sekundären DB-Instance. Die Parameter werden für Multi-AZ-Instances möglicherweise nicht aktualisiert. Für einen Neustart ohne Failover starten sowohl die primäre als auch die sekundäre DB-Instance neu. Die Parameter werden nach dem Neustart aktualisiert. Wenn die DB-Instance nicht reagiert, empfehlen wir einen Neustart ohne Failover.
Empfehlungen für die Arbeit mit Multi-AZ-Bereitstellungen auf RDS für Microsoft SQL Server-DB-Instances:
+ Für Datenbanken, die in der Produktion oder Vorproduktion verwendet werden, empfehlen wir die folgenden Optionen:
+ Multi-AZ-Bereitstellungen für Hochverfügbarkeit
+ Provisioned IOPS für schnelle, konsistente Leistung
+ „Speicheroptimiert“ statt „Universell“
+ Sie können die Availability Zone (AZ) für die sekundäre Instance nicht auswählen. Berücksichtigen Sie dies daher bei der Bereitstellung von Anwendungshosts. Für Ihre Datenbank konnte kein Failover auf eine andere AZ durchgeführt werden, und die Anwendungshosts befinden sich möglicherweise nicht in derselben AZ wie die Datenbank. Aus diesem Grund empfehlen wir, dass Sie Ihre Anwendungshosts auf alle Hosts AZs in der jeweiligen Region verteilen. AWS
+ Um eine optimale Leistung zu erzielen, sollten Sie während eines großen Datenladevorgangs keine Datenbankspiegelung AGs, Always On oder Replikation auf Blockebene aktivieren. Falls der Datenladevorgang so schnell wie möglich ablaufen soll, schließen Sie den Datenladevorgang ab, bevor Sie Ihre DB-Instance in eine Multi-AZ-Bereitstellung konvertieren.
+ Anwendungen, die SQL Server-Datenbanken aufrufen, sollten über eine Ausnahmebehandlung verfügen, die Verbindungsfehler erfasst. Das folgende Codebeispiel zeigt einen try/catch Block, der einen Kommunikationsfehler abfängt. In diesem Beispiel beendet die Anweisung `break` die `while`-Schleife, wenn die Verbindung erfolgreich ist, versucht es jedoch bis zu zehnmal neu, wenn eine Ausnahme ausgelöst wird.
```
int RetryMaxAttempts = 10;
int RetryIntervalPeriodInSeconds = 1;
int iRetryCount = 0;
while (iRetryCount < RetryMaxAttempts)
{
using (SqlConnection connection = new SqlConnection(DatabaseConnString))
{
using (SqlCommand command = connection.CreateCommand())
{
command.CommandText = "INSERT INTO SOME_TABLE VALUES ('SomeValue');";
try
{
connection.Open();
command.ExecuteNonQuery();
break;
}
catch (Exception ex)
{
Logger(ex.Message);
iRetryCount++;
}
finally {
connection.Close();
}
}
}
Thread.Sleep(RetryIntervalPeriodInSeconds * 1000);
}
```
+ Verwenden Sie den `Set Partner Off` Befehl nicht, wenn Sie mit Multi-AZ-Instances arbeiten, die DBM oder verwenden. AGs Dieser Befehl wird auf Instances, die Replikation auf Blockebene verwenden, nicht unterstützt. Unterlassen Sie beispielsweise Folgendes:
```
--Don't do this
ALTER DATABASE db1 SET PARTNER off
```
+ Setzen Sie den Wiederherstellungsmodus nicht auf `simple`. Unterlassen Sie beispielsweise Folgendes:
```
--Don't do this
ALTER DATABASE db1 SET RECOVERY simple
```
+ Verwenden Sie den `DEFAULT_DATABASE` Parameter nicht, wenn Sie neue Logins auf Multi-AZ-DB-Instances erstellen, es sei denn, Sie verwenden die Replikation auf Blockebene für hohe Verfügbarkeit, da diese Einstellungen nicht auf den Standby-Spiegel angewendet werden können. Unterlassen Sie beispielsweise Folgendes:
```
--Don't do this
CREATE LOGIN [test_dba] WITH PASSWORD=foo, DEFAULT_DATABASE=[db2]
```
Unterlassen Sie zudem Folgendes:
```
--Don't do this
ALTER LOGIN [test_dba] WITH DEFAULT_DATABASE=[db3]
```
# Festlegen des Standorts der sekundären Instance
Sie können den Standort des sekundären Replica mithilfe der festlege AWS-Managementkonsole. Sie müssen den Standort der sekundären Instance kennen, wenn Sie Ihre primäre DB-Instance in einer VPC einrichten.
![\[Sekundäre AZ\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQLSvr-MultiAZ.png)
Sie können die Availability Zone der Sekundärseite auch mithilfe des AWS CLI Befehls `describe-db-instances` oder der RDS-API-Operation anzeigen`DescribeDBInstances`. Die Ausgabe zeigt die sekundäre AZ-Instance, in der sich der Standby-Spiegel befindet.
# Migrieren von der Datenbankspiegelung zu AlwaysOn-Verfügbarkeitsgruppen
In Version 14.00.3049.1 der Microsoft SQL Server Enterprise Edition sind Always-On-Verfügbarkeitsgruppen standardmäßig aktiviert.
Prüfen Sie erst Ihre Version, ehe Sie von der Datenbankspiegelung zu Verfügbarkeitsgruppen migrieren. Wenn Sie eine DB-Instance mit einer Version vor Enterprise Edition 13.00.5216.0 verwenden, patchen Sie die Instance zu Version 13.00.5216.0 oder höher. Wenn Sie eine DB-Instance mit einer Version vor Enterprise Edition 14.00.3049.1 verwenden, patchen Sie die Instance zu Version 14.00.3049.1 oder höher.
Wenn Sie ein Upgrade für eine gespiegelte DB-Instance vornehmen möchten, damit diese Verfügbarkeitsgruppen verwendet, führen Sie zunächst das Upgrade aus, ändern Sie dann die Instance, sodass Multi-AZ entfernt wird und ändern Sie sie dann erneut, um Multi-AZ hinzuzufügen. Dadurch wird Ihre Instance umgewandelt und verwendet AlwaysOn-Verfügbarkeitsgruppen.
# Zusätzliche Funktionen für Microsoft SQL Server auf Amazon RDS
In den folgenden Abschnitten finden Sie Informationen über das Augmentieren von Amazon RDS-Instances, auf denen die Microsoft SQL Server-DB-Engine ausgeführt wird.
**Topics**
+ [
# Verwenden der Passwortrichtlinie für SQL-Server-Anmeldungen bei RDS für SQL Server
](SQLServer.Concepts.General.PasswordPolicy.Using.md)
+ [
# Integration einer Amazon RDS für SQL Server-DB-Instance mit Amazon S3
](User.SQLServer.Options.S3-integration.md)
+ [
# Verwenden von Database Mail auf Amazon RDS für SQL Server
](SQLServer.DBMail.md)
+ [
# Instance-Speicher-Support für die tempdb-Datenbank in Amazon RDS for SQL Server
](SQLServer.InstanceStore.md)
+ [
# Verwenden erweiterter Datenereignisse mit Amazon RDS für Microsoft SQL Server.
](SQLServer.ExtendedEvents.md)
+ [
# Zugriff auf Transaktionsprotokoll-Backups mit RDS für SQL Server
](USER.SQLServer.AddlFeat.TransactionLogAccess.md)
# Verwenden der Passwortrichtlinie für SQL-Server-Anmeldungen bei RDS für SQL Server
Amazon RDS ermöglicht Ihnen, die Passwortrichtlinie für Ihre Amazon-RDS-DB-Instance festzulegen, auf der Microsoft SQL Server ausgeführt wird. Verwenden Sie diese Richtlinie, um die Komplexität, Länge und Sperranforderungen für Anmeldungen festzulegen, die die SQL-Server-Authentifizierung zur Authentifizierung bei Ihrer DB-Instance nutzen.
## Wichtige Begriffe
**Anmeldung**
In SQL Server wird ein Prinzipal auf Serverebene, der sich bei einer Datenbank-Instance authentifizieren kann, als **Anmeldung** bezeichnet. Bei anderen Datenbank-Engines wird dieser Prinzipal möglicherweise als *Benutzer* bezeichnet. In RDS für SQL Server kann eine Anmeldung mithilfe der SQL-Server-Authentifizierung oder der Windows-Authentifizierung authentifiziert werden.
**SQL-Server-Anmeldung**
Eine Anmeldung, die einen Benutzernamen und ein Passwort zur Authentifizierung mithilfe der SQL-Server-Authentifizierung verwendet, ist eine SQL-Server-Anmeldung. Die Passwortrichtlinie, die Sie mittels DB-Parameter konfigurieren, gilt nur für SQL-Server-Anmeldungen.
**Windows-Anmeldung**
Eine Anmeldung, die auf einem Windows-Prinzipal basiert und mithilfe der Windows-Authentifizierung authentifiziert wird, ist eine Windows-Anmeldung. Sie können die Passwortrichtlinie für Ihre Windows-Anmeldungen in Active Directory konfigurieren. Weitere Informationen finden Sie unter [Arbeiten mit Active Directory mit RDS für SQL Server](User.SQLServer.ActiveDirectoryWindowsAuth.md).
## Aktivieren und Deaktivieren der Richtlinie für die jeweilige Anmeldung
Jede SQL-Server-Anmeldung hat Flags für `CHECK_POLICY` und `CHECK_EXPIRATION`. Standardmäßig werden neue Anmeldungen mit `CHECK_POLICY` festgelegt auf `ON` und `CHECK_EXPIRATION`festgelegt auf `OFF` erstellt.
Wenn `CHECK_POLICY` für eine Anmeldung aktiviert ist, wird in RDS für SQL Server das Passwort anhand der Komplexitäts- und Mindestlängenanforderungen überprüft. Gegebenenfalls gelten die Sperrungsrichtlinien. Beispiel für eine T-SQL-Anweisung zum Aktivieren von `CHECK_POLICY` und `CHECK_EXPIRATION`:
```
ALTER LOGIN [master_user] WITH CHECK_POLICY = ON, CHECK_EXPIRATION = ON;
```
Wenn `CHECK_EXPIRATION` aktiviert ist, unterliegen Passwörter den Richtlinien für das Passwortalter. T-SQL-Anweisung, mit der überprüft wird, ob `CHECK_POLICY` und `CHECK_EXPIRATION` festgelegt wurden:
```
SELECT name, is_policy_checked, is_expiration_checked FROM sys.sql_logins;
```
## Parameter für die Passwortrichtlinie
Alle Parameter für die Passwortrichtlinie sind dynamisch und erfordern keinen DB-Neustart, damit sie wirksam werden. In der folgenden Tabelle sind die DB-Parameter aufgeführt, die Sie festlegen können, um die Passwortrichtlinie für SQL-Server-Anmeldungen zu ändern:
****
| DB-Parameter | Beschreibung | Zulässige Werte | Standardwert |
| --- | --- | --- | --- |
| rds.password\$1complexity\$1enabled | Beim Erstellen oder Ändern von Passwörtern für SQL-Server-Anmeldungen müssen die Anforderungen an die Passwortkomplexität erfüllt sein. Die folgenden Einschränkungen müssen erfüllt sein: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.PasswordPolicy.Using.html) | 0, 1 | 0 |
| rds.password\$1min\$1length | Die Mindestanzahl von Zeichen, die ein Passwort für eine SQL-Server-Anmeldung benötigt. | 0–14 | 0 |
| rds.password\$1min\$1age | Die Mindestanzahl von Tagen, die ein SQL-Server-Anmeldepasswort verwendet werden muss, bevor der Benutzer es ändern kann. Passwörter können sofort geändert werden, wenn sie auf 0 festgelegt sind. | 0–998 | 0 |
| rds.password\$1max\$1age | Die maximale Anzahl von Tagen, die ein SQL-Server-Anmeldepasswort verwendet werden kann. Danach muss der Benutzer es ändern. Passwörter laufen nie ab, wenn sie auf 0 festgelegt sind. | 0–999 | 42 |
| rds.password\$1lockout\$1threshold | Die Anzahl aufeinanderfolgender fehlgeschlagener Anmeldeversuche, die dazu führen, dass eine SQL-Server-Anmeldung gesperrt wird. | 0–999 | 0 |
| rds.password\$1lockout\$1duration | Die Anzahl der Minuten, die eine gesperrte SQL-Server-Anmeldung warten muss, bevor sie entsperrt wird. | 1–60 | 10 |
| rds.password\$1lockout\$1reset\$1counter\$1after | Die Anzahl der Minuten, die nach einem fehlgeschlagenen Anmeldeversuch vergehen müssen, bis der Zähler für fehlgeschlagene Anmeldeversuche auf 0 zurückgesetzt wird. | 1–60 | 10 |
**Anmerkung**
Weitere Informationen zur SQL-Server-Passwortrichtlinie finden Sie unter [Passwortrichtlinie](https://learn.microsoft.com/en-us/sql/relational-databases/security/password-policy).
Die Richtlinien für die Komplexität und Mindestlänge von Passwörtern gelten auch für DB-Benutzer in eingebundenen Datenbanken. Weitere Informationen finden Sie unter [Eingebundene Datenbanken](https://learn.microsoft.com/en-us/sql/relational-databases/databases/contained-databases).
Die folgenden Einschränkungen gelten für die Parameter der Passwortrichtlinie:
+ Der Parameter `rds.password_min_age` muss kleiner als `rds.password_max_age parameter` sein, sofern `rds.password_max_age` nicht auf 0 festgelegt ist.
+ Der Parameter `rds.password_lockout_reset_counter_after` muss kleiner als oder gleich dem Parameter `rds.password_lockout_duration` sein.
+ Wenn `rds.password_lockout_threshold` auf 0 festgelegt ist, gelten `rds.password_lockout_duration` und `rds.password_lockout_reset_counter_after` nicht.
### Überlegungen zu vorhandenen Anmeldungen
Nach der Änderung der Passwortrichtlinie für eine Instance werden vorhandene Passwörter für Anmeldungen **nicht** rückwirkend anhand der neuen Komplexitäts- und Längenanforderungen von Passwörtern bewertet. Es werden nur neue Passwörter anhand der neuen Richtlinie validiert.
SQL Server **bewertet** vorhandene Passwörter hinsichtlich ihrer Altersanforderungen.
Es ist möglich, dass Passwörter sofort ablaufen, sobald eine Passwortrichtlinie geändert wurde. Wenn beispielsweise für eine Anmeldung `CHECK_EXPIRATION` aktiviert ist, das Passwort zuletzt vor 100 Tagen geändert wurde und Sie den Parameter `rds.password_max_age` auf 5 Tage festlegen, läuft das Passwort sofort ab, sodass das Anmeldepasswort beim nächsten Anmeldeversuch geändert werden muss.
**Anmerkung**
RDS für SQL Server unterstützt keine Passwortverlaufsrichtlinien. Verlaufsrichtlinien verhindern, dass Anmeldungen zuvor benutzte Passwörter wiederverwenden.
### Überlegungen zu Multi-AZ-Bereitstellungen
Die Zähler für fehlgeschlagene Anmeldeversuche und die Sperrstatus für Multi-AZ-Instances werden nicht zwischen den Knoten repliziert. Falls eine Anmeldung beim Failover einer Multi-AZ-Instance gesperrt wird, kann es vorkommen, dass die Anmeldung auf dem neuen Knoten bereits entsperrt ist.
# Überlegungen zu Passwörtern für die Masteranmeldung
Wenn Sie eine DB-Instance von RDS für SQL Server erstellen, wird das Masterbenutzerpasswort nicht anhand der Passwortrichtlinie bewertet. Ein neues Masterpasswort wird auch nicht anhand des Passworts bewertet, wenn Vorgänge für den Masterbenutzer ausgeführt werden, insbesondere beim Festlegen von `MasterUserPassword` im Befehl `ModifyDBInstance`. In beiden Fällen können Sie ein Passwort für den Masterbenutzer festlegen, das zwar nicht Ihrer Passwortrichtlinie entspricht, aber der Vorgang kann trotzdem erfolgreich ausgeführt werden. Wenn die Richtlinie nicht erfüllt wird, versucht RDS, ein RDS-Ereignis auszulösen, und gibt die Empfehlung, ein sicheres Passwort festzulegen. Achten Sie darauf, nur sichere Passwörter für den Masterbenutzer zu verwenden.
RDS versucht, die folgenden Ereignismeldungen zu generieren, wenn das Masterbenutzerpasswort nicht den Anforderungen der Passwortrichtlinie entspricht:
+ Der Masterbenutzer wurde erstellt, aber das Passwort erfüllt nicht die Anforderungen der Mindestlänge Ihrer Passwortrichtlinie. Erwägen Sie die Verwendung eines stärkeren Passworts.
+ Der Masterbenutzer wurde erstellt, aber das Passwort erfüllt nicht die Komplexitätsanforderungen Ihrer Passwortrichtlinie. Erwägen Sie die Verwendung eines stärkeren Passworts.
+ Das Masterbenutzerpasswort wurde zurückgesetzt, aber das Passwort erfüllt nicht die Anforderungen der Mindestlänge Ihrer Passwortrichtlinie. Erwägen Sie die Verwendung eines stärkeren Passworts.
+ Das Masterbenutzerpasswort wurde zurückgesetzt, aber das Passwort erfüllt nicht die Komplexitätsanforderungen Ihrer Passwortrichtlinie. Erwägen Sie die Verwendung eines stärkeren Passworts.
Standardmäßig werden die Parameter `CHECK_POLICY` und `CHECK_EXPIRATION` bei der Erstellung des Masterbenutzers auf `OFF` festgelegt. Um die Passwortrichtlinie auf den Masterbenutzer anzuwenden, müssen Sie diese Flags nach der Erstellung der DB-Instance manuell für den Masterbenutzer aktivieren. Nachdem Sie diese Flags aktiviert haben, ändern Sie das Masterbenutzerpasswort direkt in SQL Server (z. B. über T-SQL-Anweisungen oder SSMS), um das neue Passwort anhand der Passwortrichtlinie zu validieren.
**Anmerkung**
Wenn der Masterbenutzer gesperrt wird, können Sie ihn entsperren, indem Sie das Masterbenutzerpasswort mithilfe des Befehls `ModifyDBInstance` zurücksetzen.
## Ändern des Master-Benutzerpassworts
Sie können das Masterbenutzerpasswort mit dem Befehl [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) ändern.
**Anmerkung**
Wenn Sie das Masterbenutzerpasswort zurücksetzen, setzt RDS verschiedene Berechtigungen des Masterbenutzers zurück, sodass dieser möglicherweise bestimmte Berechtigungen verliert. Durch das Zurücksetzen des Masterbenutzerpassworts wird auch der Masterbenutzer entsperrt, sofern dieser gesperrt war.
RDS validiert das neue Masterbenutzerpasswort und versucht, ein RDS-Ereignis auszulösen, wenn das Passwort nicht der Richtlinie entspricht. RDS legt das Passwort fest, auch wenn es nicht die Passwortrichtlinie erfüllt.
# Integration einer Amazon RDS für SQL Server-DB-Instance mit Amazon S3
Sie können Dateien zwischen einer DB-Instance mit Amazon RDS für SQL Server und einem Amazon S3-Bucket übertragen. Dabei können Sie Amazon S3 mit SQL Server-Funktionen wie etwa BULK INSERT verwenden. Sie können beispielsweise .csv-, .xml-, .txt- und andere Dateien aus Amazon S3 zum Host der DB-Instance herunterladen und die Daten aus `D:\S3\` in die Datenbank laden. Alle Dateien werden in `D:\S3\` auf der DB-Instance gespeichert.
Die folgenden Einschränkungen gelten:
**Anmerkung**
Der Datenverkehr zwischen dem RDS-Host und S3 wird über VPC-Endpunkte in RDS intern VPCs für alle SQL Server-Funktionen geleitet, die S3 verwenden. Dieser Datenverkehr verwendet den RDS-Instance-Endpunkt ENI nicht. S3-Bucket-Richtlinien können den RDS-Datenverkehr nicht durch Netzwerkbedingungen einschränken.
+ Dateien im `D:\S3`-Ordner werden nach einem Failover auf Multi-AZ-Instances auf dem Standby-Replikat gelöscht. Weitere Informationen finden Sie unter [Multi-AZ-Einschränkungen für die S3-Integration](#S3-MAZ).
+ Die DB-Instance und der S3-Bucket müssen sich in derselben AWS Region befinden.
+ Wenn Sie mehr als eine S3-Integrationsaufgabe gleichzeitig ausführen, werden die Aufgaben sequenziell und nicht parallel ausgeführt.
**Anmerkung**
S3-Integrationsaufgaben verwenden dieselbe Warteschlange wie native Backup- und Wiederherstellungsaufgaben. Sie können maximal zwei Aufgaben gleichzeitig in dieser Warteschlange haben. Daher blockieren zwei laufende native Backup- und Wiederherstellungsaufgaben alle S3-Integrationsaufgaben.
+ Sie müssen die S3-Integrationsfunktion auf den wiederhergestellten Instances erneut aktivieren. Die S3-Integration wird nicht von der Quell-Instance auf die wiederhergestellte Instance übertragen. Dateien in `D:\S3` werden auf einer wiederhergestellten Instance gelöscht.
+ Der Download auf die DB-Instance ist auf 100 Dateien begrenzt. Anders ausgedrückt: Es können sich nicht mehr als 100 Dateien in befinde `D:\S3\`.
+ Nur Dateien ohne Dateierweiterungen oder mit den folgenden Dateierweiterungen werden zum Download unterstützt: .abf, .asdatabase, .bcp, .configsettings, .csv, .dat, .deploymentoptions, .deploymenttargets, .fmt, .info, .ispac, .lst, .tbl, .txt, .xml und .xmla.
+ Der S3-Bucket muss denselben Besitzer haben wie die zugehörige Rolle AWS Identity and Access Management (IAM). Daher wird die kontoübergreifende S3-Integration nicht unterstützt.
+ Der S3-Bucket kann nicht für die Öffentlichkeit zugänglich sein.
+ Die Dateigröße für Uploads von RDS auf S3 ist auf 50 GB pro Datei begrenzt.
+ Die Dateigröße für Downloads von S3 auf RDS ist auf das von S3 unterstützte Maximum beschränkt.
**Topics**
+ [
# Voraussetzungen für die Integration von RDS-for-SQL-Server mit S3
](Appendix.SQLServer.Options.S3-integration.preparing.md)
+ [
# Aktivieren der RDS für SQL Server-Integration mit S3
](Appendix.SQLServer.Options.S3-integration.enabling.md)
+ [
# Übertragen von Dateien zwischen RDS for SQL Server und Amazon S3
](Appendix.SQLServer.Options.S3-integration.using.md)
+ [
# Auflisten von Dateien auf der RDS DB-Instance
](Appendix.SQLServer.Options.S3-integration.using.listing-files.md)
+ [
# Löschen von Dateien auf der RDS DB-Instance
](Appendix.SQLServer.Options.S3-integration.using.deleting-files.md)
+ [
# Überwachung des Status einer Dateiübertragungsaufgabe
](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md)
+ [
# Abbrechen einer Aufgabe
](Appendix.SQLServer.Options.S3-integration.canceltasks.md)
+ [
## Multi-AZ-Einschränkungen für die S3-Integration
](#S3-MAZ)
+ [
# Aktivieren der RDS für SQL Server-Integration mit S3
](Appendix.SQLServer.Options.S3-integration.disabling.md)
Weitere Informationen zum Arbeiten mit Dateien in Amazon S3 finden Sie unter [Erste Schritte mit Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3).
# Voraussetzungen für die Integration von RDS-for-SQL-Server mit S3
Bevor Sie beginnen, suchen oder erstellen Sie den S3-Bucket, den Sie verwenden möchten. Fügen Sie weiterhin Berechtigungen hinzu, so dass die RDS DB-Instance auf den S3-Bucket zugreifen kann. Zur Konfiguration dieses Zugriffs erstellen Sie eine IAM-Richtlinie und eine IAM-Rolle.
## Konsole
**So erstellen Sie eine IAM-Richtlinie für den Zugriff auf Amazon S3:**
1. Wählen Sie in der [IAM Management-Konsole](https://console.aws.amazon.com/iam/home?#home) im Navigationsbereich **Policies (Richtlinien)**.
1. Erstellen Sie eine neue Richtlinie, und verwenden Sie die Registerkarte **Visual editor** für die folgenden Schritte.
1. Geben Sie unter **Service** **S3** ein, und wählen Sie dann den **S3**-Service.
1. Wählen Sie unter **Actions (Aktionen)** Folgendes, um den Zugang zu gewähren, den Ihre DB-Instance benötigt.
+ `ListAllMyBuckets` – erforderlich
+ `ListBucket` – erforderlich
+ `GetBucketAcl` – erforderlich
+ `GetBucketLocation` – erforderlich
+ `GetObject` – erforderlich für das Herunterladen von Dateien von S3 zu `D:\S3\`
+ `PutObject` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
+ `ListMultipartUploadParts` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
+ `AbortMultipartUpload` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
1. Für **Resources (Ressourcen)** hängen die angezeigten Optionen davon ab, welche Aktionen Sie im vorherigen Schritt ausgewählt haben. Möglicherweise sehen Sie Optionen für **Bucket**, **Object (Objekt)** oder beide. Geben Sie für beide den jeweiligen Amazon-Ressourcennamen (ARN) an.
Geben Sie für **Bucket** den ARN für den Bucket an, den Sie verwenden möchten. Wenn Ihr Bucket beispielsweise den Namen *amzn-s3-demo-bucket* hat, setzen Sie den ARN auf `arn:aws:s3:::amzn-s3-demo-bucket`.
Geben Sie für **Object (Objekt)** den ARN für den Bucket ein, und wählen Sie dann eine der folgenden Optionen:
+ Um Zugriff auf alle Dateien in dem angegebenen Bucket zu gewähren, wählen Sie **Any (Beliebig)** für **Bucket name (Name des Buckets)** und **Object name (Name des Objekts)**.
+ Um Zugriff auf bestimmte Dateien oder Ordner im Bucket zu gewähren, geben ARNs Sie die spezifischen Buckets und Objekte an, auf die SQL Server zugreifen soll.
1. Befolgen Sie die Anweisungen in der Konsole, bis Sie die Richtlinie fertig erstellt haben.
Vorstehendes ist eine verkürzte Anleitung zur Einrichtung einer Richtlinie. Ausführlichere Anweisungen zum Erstellen von IAM-Richtlinien finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.
**So erstellen Sie eine IAM-Rolle, die die IAM-Richtlinie aus der vorherigen Prozedur verwendet:**
1. Wählen Sie in der [IAM Management-Konsole](https://console.aws.amazon.com/iam/home?#home) im Navigationsbereich **Roles (Rollen)**.
1. Erstellen Sie eine neue IAM-Rolle, und wählen Sie die folgenden Optionen, wenn sie in der Konsole angezeigt werden:
+ **AWSService nicht zulässig**
+ **RDS**
+ **RDS – Add Role to Database (Rolle zu Datenbank hinzufügen**
Wählen Sie dann unten **Next permissions (Nächste Berechtigungen)**.
1. Geben Sie für **Attach permissions policies (Berechtigungsrichtlinien anfügen)** den Namen der vorher erstellten IAM-Richtlinie ein. Wählen Sie dann eine Richtlinie aus der Liste aus.
1. Befolgen Sie die Anweisungen in der Konsole, bis Sie die Rolle fertig erstellt haben.
Vorstehendes ist eine verkürzte Anleitung zur Einrichtung einer Rolle. Wenn Sie eine ausführlichere Anleitung zum Erstellen einer Rolle wünschen, vgl. [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) im *IAM-Benutzerhandbuch*.
## AWS CLI
Sie können Amazon RDS wie folgt Zugriff auf einen Amazon-S3-Bucket gewähren:
1. Erstellen Sie eine IAM-Richtlinie, die Amazon RDS Zugriff auf einen S3-Bucket gewährt.
1. Erstellen Sie eine IAM-Rolle, die Amazon RDS in Ihrem Auftrag annehmen kann, um auf Ihre S3-Buckets zuzugreifen.
Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.
1. Fügen Sie die erstellte IAM-Richtlinie der IAM-Rolle an, die Sie erstellt haben.
**So erstellen Sie die -IAM-Richtlinie**
Schließen Sie die jeweiligen Aktionen ein, um den Zugriff zu gewähren, den Ihre DB-Instance erfordert:
+ `ListAllMyBuckets` – erforderlich
+ `ListBucket` – erforderlich
+ `GetBucketAcl` – erforderlich
+ `GetBucketLocation` – erforderlich
+ `GetObject` – erforderlich für das Herunterladen von Dateien von S3 zu `D:\S3\`
+ `PutObject` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
+ `ListMultipartUploadParts` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
+ `AbortMultipartUpload` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
1. Mit dem folgenden AWS CLI Befehl wird eine IAM-Richtlinie `rds-s3-integration-policy` mit diesen Optionen erstellt. Sie gewährt Zugriff auf einen Bucket namens *amzn-s3-demo-bucket*.
**Example**
Für Linux, macOS oder Unix:
```
aws iam create-policy \
--policy-name rds-s3-integration-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketAcl",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/key_prefix/*"
}
]
}'
```
Für Windows:
Achten Sie darauf, dass Sie die Zeilenenden so ändern, dass Ihre Schnittstelle sie unterstützt (`^` anstelle von `\`). Unter Windows müssen Sie dazu alle doppelten Anführungszeichen mit dem Escape-Zeichen versehe `\`. Um dies für alle Anführungszeichen in JSON zu vermeiden, können Sie sie stattdessen in eine Datei speichern und als Parameter einführen.
Erstellen Sie zuerst die `policy.json`-Datei mit der folgenden Berechtigungsrichtlinie:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketACL",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/key_prefix/*"
}
]
}
```
------
Verwenden Sie dann den folgenden Befehl, um die Richtlinie zu erstellen:
```
aws iam create-policy ^
--policy-name rds-s3-integration-policy ^
--policy-document file://file_path/assume_role_policy.json
```
1. Notieren Sie nach dem Erstellen der Richtlinie den Amazon-Ressourcennamen (ARN) der Richtlinie. Sie benötigen den ARN bei einem späteren Schritt.
**So erstellen Sie die IAM-Rolle**
+ Mit dem folgenden AWS CLI Befehl wird die `rds-s3-integration-role` IAM-Rolle für diesen Zweck erstellt.
**Example**
Für Linux, macOS oder Unix:
```
aws iam create-role \
--role-name rds-s3-integration-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
Für Windows:
Achten Sie darauf, dass Sie die Zeilenenden so ändern, dass Ihre Schnittstelle sie unterstützt (`^` anstelle von `\`). Unter Windows müssen Sie dazu alle doppelten Anführungszeichen mit dem Escape-Zeichen versehe `\`. Um dies für alle Anführungszeichen in JSON zu vermeiden, können Sie sie stattdessen in eine Datei speichern und als Parameter einführen.
Erstellen Sie zuerst die `assume_role_policy.json`-Datei mit der folgenden Richtlinie:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Verwenden Sie anschließend den folgenden Befehl zum Erstellen der IAM-Rolle:
```
aws iam create-role ^
--role-name rds-s3-integration-role ^
--assume-role-policy-document file://file_path/assume_role_policy.json
```
**Example die Verwendung des globalen Bedingungskontextschlüssels zum Erstellen der IAM-Rolle**
Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) und [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) in ressourcenbasierten Richtlinien, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.
Sie können beide globalen Bedingungskontextschlüssel verwenden und der Wert `aws:SourceArn` enthält die Konto-ID. Stellen Sie in diesen Fällen sicher, dass der Wert `aws:SourceAccount` und das Konto im Wert `aws:SourceArn` dieselbe Konto-ID verwenden, wenn sie in derselben Richtlinienanweisung verwendet werden.
+ Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
+ Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.
Stellen Sie in der Richtlinie sicher, dass Sie den globalen Bedingungskontextschlüssel `aws:SourceArn` mit dem vollständigen Amazon-Ressourcennamen (ARN) der Ressourcen verwenden, die auf die Rolle zugreifen. Stellen Sie bei der S3-Integration sicher, dass Sie die DB-Instance einbeziehen ARNs, wie im folgenden Beispiel gezeigt.
Für Linux, macOS oder Unix:
```
aws iam create-role \
--role-name rds-s3-integration-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn":"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
}
}
}
]
}'
```
Für Windows:
Fügen Sie den globalen Bedingungskontextschlüssel zu `assume_role_policy.json` hinzu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn":"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
}
}
}
]
}
```
------
**IAM-Richtlinie an die IAM-Rolle anfügen**
+ Mit dem folgenden AWS CLI Befehl wird die Richtlinie an die angegebene `rds-s3-integration-role` Rolle angehängt. Ersetzen Sie `your-policy-arn` durch den Richtlinien-ARN, den Sie im vorherigen Schritt notiert haben.
**Example**
Für Linux, macOS oder Unix:
```
aws iam attach-role-policy \
--policy-arn your-policy-arn \
--role-name rds-s3-integration-role
```
Für Windows:
```
aws iam attach-role-policy ^
--policy-arn your-policy-arn ^
--role-name rds-s3-integration-role
```
# Aktivieren der RDS für SQL Server-Integration mit S3
Im folgenden Abschnitt erfahren Sie, wie Sie die Amazon S3-Integration mit Amazon RDS für SQL Server aktivieren. Zur Arbeit mit der S3-Integration muss Ihre DB-Instance mit der IAM-Rolle verbunden sein, die Sie vorher erstellt haben, bevor Sie den Funktionsnamenparameter `S3_INTEGRATION` verwenden.
**Anmerkung**
Um eine IAM-Rolle zu einer DB-Instance hinzufügen zu können, muss der Status der DB-Instance **available (verfügbar)** sein.
## Konsole
**So ordnen Sie Ihre IAM-Rolle Ihrer DB-Instance zu**
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 den Namen der RDS für SQL Server-DB-Instance, um ihre Details anzuzeigen.
1. Wählen Sie auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** im Bereich **Manage IAM roles (IAM-Rollen verwalten)** die IAM-Rolle aus, die unter **Add IAM roles to this instance (IAM-Rollen zu dieser Instance hinzufügen)** hinzugefügt werden soll.
1. Wählen Sie unter **Feature (Funktion)** die Option **S3\$1INTEGRATION** aus.
![\[Hinzufügen der S3_INTEGRATION-Rolle\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/ora-s3-integration-role.png)
1. Wählen Sie **Rolle hinzufügen**.
## AWS CLI
**So fügen Sie die IAM-Rolle der RDS für SQL Server-DB-Instance hinzu:**
+ Der folgende AWS CLI-Befehl fügt Ihre IAM-Rolle einer RDS für SQL Server-DB-Instance mit der Bezeichnung `mydbinstance` hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-role-to-db-instance \
--db-instance-identifier mydbinstance \
--feature-name S3_INTEGRATION \
--role-arn your-role-arn
```
Für Windows:
```
aws rds add-role-to-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name S3_INTEGRATION ^
--role-arn your-role-arn
```
Ersetzen Sie `your-role-arn` durch den Rollen-ARN, den Sie im vorherigen Schritt notiert haben. Für die Option `S3_INTEGRATION` muss `--feature-name` angegeben werden.
# Übertragen von Dateien zwischen RDS for SQL Server und Amazon S3
Sie können gespeicherte Amazon RDS-Prozesse zum Herunterladen und Hochladen von Dateien zwischen Amazon S3 und Ihrer RDS DB-Instance verwenden. Sie können auch gespeicherte Amazon RDS-Prozeduren zum Auflisten und Löschen von Dateien auf der RDS-Instance verwenden.
Die Dateien, die Sie von S3 herunter- und hochladen, werden im Ordner `D:\S3` gespeichert. Dies ist der einzige Ordner, den Sie zum Zugriff auf Ihre Dateien verwenden können. Sie können Ihre Dateien in Unterordnern organisieren, die für Sie erstellt werden, wenn Sie beim Download den Zielordner einschließen.
Einige der gespeicherten Prozesse verlangen, dass Sie einen Amazon-Ressourcennamen (ARN) für Ihren S3-Bucket und die Datei angeben. Das Format für Ihren ARN lautet `arn:aws:s3:::amzn-s3-demo-bucket/file_name`. Amazon S3 benötigt keine Kontonummer oder AWS Region in ARNs.
S3-Integrationsaufgaben werden sequenziell ausgeführt und nutzen dieselbe Warteschlange wie native Sicherungs- und Wiederherstellungsaufgaben. Sie können maximal zwei Aufgaben gleichzeitig in dieser Warteschlange haben. Der Verarbeitungsbeginn für jede Aufgabe kann bis zu fünf Minuten in Anspruch nehmen.
## Herunterladen von Dateien aus einem Amazon S3-Bucket zu einer SQL Server-DB-Instance
Verwenden Sie zum Herunterladen von Dateien aus einem S3-Bucket zu einer RDS for SQL Server-DB-Instance die gespeicherte Prozedur Amazon RDS `msdb.dbo.rds_download_from_s3` mit den folgenden Parametern.
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `@s3_arn_of_file` | NVARCHAR | – | Erforderlich | Der S3-ARN der herunterzuladenden Datei, zum Beispiel:: `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv` |
| `@rds_file_path` | NVARCHAR | – | Optional | Der Dateipfad für die RDS-Instance. Wenn nichts angegeben ist, ist der Dateipfad `D:\S3\`. RDS unterstützt absolute und relative Pfade. Wenn Sie einen Unterordner erstellen möchten, schließen Sie ihn in den Dateipfad ein. |
| `@overwrite_file` | INT | 0 | Optional | Die vorhandene Datei überschreiben: 0 Nicht überschreiben 1 = Überschreiben |
Sie können Dateien ohne Dateierweiterung und Dateien mit den folgenden Dateierweiterungen herunterladen: .bcp, .csv, .dat, .fmt, .info, .lst, .tbl, .txt und .xml.
**Anmerkung**
Dateien mit der Dateierweiterung „.ispac“ werden zum Download unterstützt, wenn SQL Server Integration Services aktiviert ist. Weitere Informationen zum Aktivieren von SSIS finden Sie unter [SQL Server Integration Services](Appendix.SQLServer.Options.SSIS.md).
Dateien mit den folgenden Dateierweiterungen werden für den Download unterstützt, wenn SQL Server Analysis Services aktiviert ist: .abf, .asdatabase, .configsettings, .deploymentoptions, .deploymenttargets und .xmla. Weitere Informationen zum Aktivieren von SSAS finden Sie unter [SQL Server Analysis Services](Appendix.SQLServer.Options.SSAS.md).
Das folgende Beispiel zeigt die gespeicherte Prozedur für den Download von Dateien von S3.
```
exec msdb.dbo.rds_download_from_s3
@s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/bulk_data.csv',
@rds_file_path='D:\S3\seed_data\data.csv',
@overwrite_file=1;
```
Die Beispieloperation `rds_download_from_s3` erstellt einen Ordner mit der Bezeichnung `seed_data` in `D:\S3\`, wenn der Ordner noch nicht vorhanden ist. Dann lädt das Beispiel die Quelldatei `bulk_data.csv` von S3 zu einer neuen Datei mit der Bezeichnung `data.csv` auf der DB-Instance herunter. Wenn die Datei bereits vorhanden war, wird sie überschrieben, da der Parameter `@overwrite_file` auf `1` gesetzt ist.
## Hochladen von Dateien von einer SQL Server-DB-Instance zu einem Amazon S3-Bucket
Verwenden Sie zum Hochladen von Dateien aus einer RDS for SQL Server-DB-Instance zu einem S3-Bucket die gespeicherte Prozedur Amazon RDS `msdb.dbo.rds_upload_to_s3` mit den folgenden Parametern.
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `@s3_arn_of_file` | NVARCHAR | – | Erforderlich | Der S3-ARN der in S3 zu erstellenden Datei, zum Beispiel: `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv` |
| `@rds_file_path` | NVARCHAR | – | Erforderlich | Der Dateipfad der zu S3 hochzuladenden Datei. Es werden absolute und relative Pfade unterstützt. |
| `@overwrite_file` | INT | – | Optional | Die vorhandene Datei überschreiben: 0 Nicht überschreiben 1 = Überschreiben |
Das folgende Beispiel lädt die Datei mit der Bezeichnung `data.csv` von dem angegebenen Speicherort in `D:\S3\seed_data\` zu einer Datei `new_data.csv` in dem von dem ARN angegebenen S3-Bucket hoch.
```
exec msdb.dbo.rds_upload_to_s3
@rds_file_path='D:\S3\seed_data\data.csv',
@s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/new_data.csv',
@overwrite_file=1;
```
Wenn die Datei in S3 bereits vorhanden war, wird sie überschrieben, da der Parameter @overwrite\$1file auf gesetzt is `1`.
# Auflisten von Dateien auf der RDS DB-Instance
Verwenden Sie zum Auflisten der auf der DB-Instance verfügbaren Dateien eine gespeicherte Prozedur und eine Funktion. Führen Sie zunächst die folgende gespeicherte Prozedur aus, um Dateidetails von den Dateien in zu erfasse `D:\S3\`.
```
exec msdb.dbo.rds_gather_file_details;
```
Die gespeicherte Prozedur gibt die ID der Aufgabe zurück. Wie andere Aufgaben wird diese gespeicherte Prozedur asynchron ausgeführt. Sobald der Status der Aufgabe `SUCCESS` ist, können Sie die Aufgaben-ID in der `rds_fn_list_file_details`-Funktion verwenden, um die vorhandenen Dateien und Verzeichnisse in D:\$1S3\$1 wie nachfolgend gezeigt aufzulisten.
```
SELECT * FROM msdb.dbo.rds_fn_list_file_details(TASK_ID);
```
Die `rds_fn_list_file_details`-Funktion gibt eine Tabelle mit den folgenden Spalten zurück:
| Ausgabeparameter | Beschreibung |
| --- | --- |
| filepath | Absoluter Pfad der Datei (zum Beispie, D:\$1S3\$1mydata.csv) |
| size\$1in\$1bytes | Dateigröße (in Bytes) |
| last\$1modified\$1utc | Letztes Änderungsdatum/-uhrzeit im UTC-Format |
| is\$1directory | Option, die angibt, ob es sich bei dem Element um ein Verzeichnis handelt (true/false). |
# Löschen von Dateien auf der RDS DB-Instance
Verwenden Sie zum Löschen der auf der DB-Instance verfügbaren Dateien die gespeicherte Prozedur Amazon RDS `msdb.dbo.rds_delete_from_filesystem` mit den folgenden Parametern.
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `@rds_file_path` | NVARCHAR | – | Erforderlich | Der Dateipfad der zu löschenden Datei. Es werden absolute und relative Pfade unterstützt. |
| `@force_delete` | INT | 0 | Optional | Zum Löschen eines Verzeichnisses muss diese Markierung eingeschlossen und auf gesetzt werde `1`. `1` = Löschen eines Verzeichnisses Dieser Parameter wird ignoriert, wenn Sie eine Datei löschen. |
Zum Löschen eines Verzeichnisses muss `@rds_file_path` mit einem umgekehrten Schrägstrich (`\`) enden, und `@force_delete` muss auf `1` gesetzt sein.
Im folgenden Beispiel wird die Datei gelösch `D:\S3\delete_me.txt`.
```
exec msdb.dbo.rds_delete_from_filesystem
@rds_file_path='D:\S3\delete_me.txt';
```
Im folgenden Beispiel wird das Verzeichnis gelösch `D:\S3\example_folder\`.
```
exec msdb.dbo.rds_delete_from_filesystem
@rds_file_path='D:\S3\example_folder\',
@force_delete=1;
```
# Überwachung des Status einer Dateiübertragungsaufgabe
Rufen Sie zum Nachverfolgen des Status Ihrer S3-Integrationsaufgabe die `rds_fn_task_status`-Funktion auf. Dazu sind zwei Parameter erforderlich. Der erste Parameter sollte immer `NULL` sein, da er sich nicht auf die S3-Integration bezieht. Der zweite Parameter akzeptiert eine Aufgaben-ID.
Um eine Liste aller Aufgaben anzuzeigen, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf `0`, wie im folgenden Beispiel gezeigt.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```
Um eine bestimmte Aufgabe zu erhalten, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf die Aufgaben-ID, wie im folgenden Beispiel gezeigt,
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```
Die `rds_fn_task_status`-Funktion gibt die folgenden Informationen zurück.
| Ausgabeparameter | Beschreibung |
| --- | --- |
| `task_id` | Die ID der Aufgabe. |
| `task_type` | Für die S3-Integration können Aufgaben die folgenden Aufgabentypen haben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html) |
| `database_name` | Nicht verwendbar für S3-Integrationsaufgaben. |
| `% complete` | Verlauf der Aufgabe als Prozentwert. |
| `duration(mins)` | Zeitdauer für die Ausführung der Aufgabe (in Minuten). |
| `lifecycle` | Der Status der Aufgabe. Die folgenden Status sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html) |
| `task_info` | Zusätzliche Informationen über die Aufgabe. Wenn bei der Verarbeitung ein Fehler auftritt, enthält diese Spalte Informationen zu dem Fehler. |
| `last_updated` | Datum und Uhrzeit der letzten Aktualisierung des Aufgabenstatus. |
| `created_at` | Datum und Uhrzeit, an denen die Aufgabe angelegt wurde. |
| `S3_object_arn` | Der ARN des S3-Objekts, von dem der Download oder zu dem der Upload stattfand. |
| `overwrite_S3_backup_file` | Nicht verwendbar für S3-Integrationsaufgaben. |
| `KMS_master_key_arn` | Nicht verwendbar für S3-Integrationsaufgaben. |
| `filepath` | Der Dateipfad auf der RDS DB-Instance. |
| `overwrite_file` | Eine Option, die anzeigt, ob eine bestehende Datei überschrieben wird. |
| `task_metadata` | Nicht verwendbar für S3-Integrationsaufgaben. |
# Abbrechen einer Aufgabe
Verwenden Sie zum Abbrechen von S3-Integrationsaufgaben die gespeicherte `msdb.dbo.rds_cancel_task`-Prozedur mit dem Parameter `task_id`. Laufende Lösch- und Auflistungsaufgaben können nicht abgebrochen werden. Das folgende Beispiel zeigt eine Anforderung zum Abbrechen einer Aufgabe.
```
exec msdb.dbo.rds_cancel_task @task_id = 1234;
```
Verwenden Sie für die Anzeige einer Übersicht über alle Aufgaben und ihre Aufgaben-IDs die `rds_fn_task_status`-Funktion wie in [Überwachung des Status einer Dateiübertragungsaufgabe](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md) beschrieben.
## Multi-AZ-Einschränkungen für die S3-Integration
Bei Multi-AZ-Instances werden Dateien im `D:\S3`-Ordner nach einem Failover auf dem Standby-Replikat gelöscht. Ein Failover kann beispielsweise bei Änderungen der DB-Instance geplant werden, z. B. beim Ändern der Instance-Klasse oder beim Aktualisieren der Engine-Version. Oder ein Failover kann während eines Ausfalls der primären Instance ungeplant sein.
**Anmerkung**
Es wird nicht empfohlen, den `D:\S3`-Ordner für die Dateispeicherung zu verwenden. Die bewährte Methode besteht darin, erstellte Dateien in Amazon S3 hochzuladen, um sie beständig zu machen, und Dateien herunterzuladen, wenn Sie Daten importieren müssen.
Um die letzte Failover-Zeit zu bestimmen, können Sie das gespeicherte `msdb.dbo.rds_failover_time`-Verfahren verwenden. Weitere Informationen finden Sie unter [Ermitteln der letzten Failover-Zeit für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.LastFailover.md).
**Example Kein Failover in letzter Zeit**
Dieses Beispiel zeigt die Ausgabe, wenn in den Fehlerprotokollen kein aktuelles Failover vorhanden ist. Seit 2020-04-29 23:59:00.01 ist kein Failover aufgetreten.
Daher sind alle nach dieser Zeit heruntergeladenen Dateien, die nicht mit dem gespeicherten `rds_delete_from_filesystem`-Verfahren gelöscht wurden, weiterhin auf dem aktuellen Host verfügbar. Dateien, die vor diesem Zeitpunkt heruntergeladen wurden, sind möglicherweise ebenfalls verfügbar.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 2020-04-29 23:59:00.0100000 | Null |
**Example Failover in letzter Zeit**
Dieses Beispiel zeigt die Ausgabe, wenn ein Failover in den Fehlerprotokollen vorliegt. Das letzte Failover erfolgte am 2020-05-05 18:57:51.89.
Auf alle nach dieser Zeit heruntergeladenen Dateien, die nicht mit dem gespeicherten `rds_delete_from_filesystem`-Verfahren gelöscht wurden, kann auf dem aktuellen Host weiterhin zugegriffen werden.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 2020-04-29 23:59:00.0100000 | 2020-05-05 18:57:51.8900000 |
# Aktivieren der RDS für SQL Server-Integration mit S3
Nachfolgend erfahren Sie, wie Sie die Amazon S3-Integration mit Amazon RDS für SQL Server deaktivieren. Dateien in `D:\S3\` werden nicht gelöscht, wenn die S3-Integration deaktiviert wird.
**Anmerkung**
Um eine IAM-Rolle von einer DB-Instance löschen zu können, muss der Status der DB-Instance sei `available`.
## Konsole
**So entfernen Sie die Zuweisung Ihrer IAM-Rolle zu 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 den Namen der RDS für SQL Server-DB-Instance, um ihre Details anzuzeigen.
1. Wählen Sie auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** im Bereich **Manage IAM roles (IAM-Rollen verwalten)** die IAM-Rolle aus, die entfernt werden soll.
1. Wählen Sie **Delete (Löschen)**.
## AWS CLI
**So entfernen Sie die IAM-Rolle von der RDS für SQL Server-DB-Instance:**
+ Der folgende AWS CLI-Befehl entfernt die IAM-Rolle von einer RDS für SQL Server-DB-Instance mit der Bezeichnung `mydbinstance`.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-role-from-db-instance \
--db-instance-identifier mydbinstance \
--feature-name S3_INTEGRATION \
--role-arn your-role-arn
```
Für Windows:
```
aws rds remove-role-from-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name S3_INTEGRATION ^
--role-arn your-role-arn
```
Ersetzen Sie `your-role-arn` durch den jeweiligen ARN der IAM-Rolle für die Option `--feature-name`.
# Verwenden von Database Mail auf Amazon RDS für SQL Server
Sie können Database Mail verwenden, um E-Mail-Nachrichten aus Ihrer Amazon RDS auf der SQL Server-Datenbank-Instance an Benutzer zu senden. Die Nachrichten können Dateien und Abfrageergebnisse enthalten. Database Mail enthält die folgenden Komponenten:
+ **Konfigurations- und Sicherheitsobjekte** – Diese Objekte erstellen Profile und Konten und werden in der `msdb`-Datenbank gespeichert.
+ **Messaging-Objekte** – Diese Objekte umfassen die gespeicherte Prozedur [sp\$1send\$1dbmail](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql), die zum Senden von Nachrichten verwendet wird, und Datenstrukturen, die Informationen über Nachrichten enthalten. Sie sind in der `msdb`-Datenbank gespeichert.
+ **Objekte protokollieren und prüfen** – Database Mail schreibt Protokollierungsinformationen in die `msdb`-Datenbank und das Ereignisprotokoll der Microsoft Windows-Anwendung.
+ Die **ausführbare Datei von Database Mail** – `DatabaseMail.exe` liest aus einer Warteschlange in der `msdb`-Datenbank und sendet E-Mail-Nachrichten.
RDS unterstützt Database Mail für alle SQL Server-Versionen in Web, Standard und Enterprise Editions.
## Einschränkungen
Die folgenden Einschränkungen gelten für die Verwendung von Database Mail auf Ihrer SQL Server-DB-Instance:
+ Database Mail wird für SQL Server Express Edition nicht unterstützt.
+ Das Ändern der Database Mail-Konfigurationsparameter wird nicht unterstützt. Um die voreingestellten (Standard-)Werte zu sehen, verwenden Sie den gespeicherten Prozess [sysmail\$1help\$1configure\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-configure-sp-transact-sql).
+ Dateianhänge werden nicht vollständig unterstützt. Weitere Informationen finden Sie unter [Arbeiten mit Dateianlagen](#SQLServer.DBMail.Files).
+ Die maximale Größe des Dateianhangs beträgt 1 MB.
+ Database Mail erfordert zusätzliche Konfiguration für Multi-AZ DB-Instances. Weitere Informationen finden Sie unter [Überlegungen zu Multi-AZ-Bereitstellungen](#SQLServer.DBMail.MAZ).
+ Das Konfigurieren des SQL Server-Agenten zum Senden von E-Mail-Nachrichten an vordefinierte Operatoren wird nicht unterstützt.
# Aktivieren von Database Mail
Verwenden Sie den folgenden Prozess, um Database Mail für Ihre DB-Instance zu aktivieren:
1. Neue Parametergruppe erstellen.
1. Ändern Sie die Parametergruppe, um den Parameter `database mail xps` auf „1“ einzustellen.
1. Ordnen Sie die neue Parametergruppe der DB-Instance zu.
## Erstellen der Parametergruppe für Database Mail
Erstellen oder ändern Sie eine Parametergruppe für den `database mail xps`-Parameter, der der SQL Server-Edition und der Version Ihrer DB-Instance entspricht.
**Anmerkung**
Sie können auch eine vorhandene Parametergruppe ändern. Folgen Sie dem Verfahren unter [Ändern des Parameters, der Database Mail aktiviert](#DBMail.ModifyParamGroup).
### Konsole
Im folgenden Beispiel wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie **Create parameter group (Parametergruppe erstellen)**.
1. Führen Sie im Bereich **Parametergruppe erstellen** die folgenden Schritte aus:
1. Wählen Sie für **Parametergruppenfamilie** die Option **sqlserver-se-13.0** aus.
1. Geben Sie unter **Gruppenname** einen Bezeichner für die Parametergruppe ein, z. B. **dbmail-sqlserver-se-13**.
1. Geben Sie für **Beschreibung** den Text **Database Mail XPs** ein.
1. Wählen Sie **Create** aus.
### CLI
Im folgenden Beispiel wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-parameter-group \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--db-parameter-group-family "sqlserver-se-13.0" \
--description "Database Mail XPs"
```
Für Windows:
```
aws rds create-db-parameter-group ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--db-parameter-group-family "sqlserver-se-13.0" ^
--description "Database Mail XPs"
```
## Ändern des Parameters, der Database Mail aktiviert
Ändern Sie den `database mail xps`-Parameter in der Parametergruppe, die der SQL Server-Edition und der Version Ihrer DB-Instance entspricht.
Um Database Mail zu aktivieren, setzen Sie den Parameter `database mail xps` auf 1.
### Konsole
Im folgenden Beispiel wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben.
**So ändern Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie die Parametergruppe, z. B. **dbmail-sqlserver-se-13**.
1. Filtern Sie unter **Parameter** die Parameterliste nach **mail**.
1. Wählen Sie **database mail xps** aus.
1. Wählen Sie **Parameter bearbeiten** aus.
1. Geben Sie ei **1**.
1. Wählen Sie **Änderungen speichern ** aus.
### CLI
Im folgenden Beispiel wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben.
**So ändern Sie die Parametergruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--parameters "ParameterName='database mail xps',ParameterValue=1,ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--parameters "ParameterName='database mail xps',ParameterValue=1,ApplyMethod=immediate"
```
## Die Parametergruppe der DB-Instance zuordnen
Sie können das AWS-Managementkonsole oder verwenden AWS CLI , um die Datenbank-E-Mail-Parametergruppe mit der DB-Instance zu verknüpfen.
### Konsole
Sie können die Database Mail-Parametergruppe einer neuen oder einer vorhandenen DB-Instance zuordnen.
+ Bei einer neuen DB-Instance ordnen Sie diese zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Bei einer vorhandenen DB-Instance ordnen Sie diese zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### CLI
Sie können die Database Mail-Parametergruppe einer neuen oder einer vorhandenen DB-Instance zuordnen.
**So erstellen Sie eine DB-Instance mit der Parametergruppe Database Mail**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Parametergruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 13.00.5426.0.v1 \
--allocated-storage 100 \
--manage-master-user-password \
--master-username admin \
--storage-type gp2 \
--license-model li
--db-parameter-group-name dbmail-sqlserver-se-13
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mydbinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 13.00.5426.0.v1 ^
--allocated-storage 100 ^
--manage-master-user-password ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--db-parameter-group-name dbmail-sqlserver-se-13
```
**So ändern Sie eine DB-Instance und verknüpfen die Parametergruppe Database Mail**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--apply-immediately
```
# Konfigurieren von Database Mail
Sie führen die folgenden Aufgaben aus, um Database Mail zu konfigurieren:
1. Erstellen Sie das Database Mail-Profil.
1. Erstellen Sie das Database Mail-Konto.
1. Fügen Sie das Database Mail-Konto dem Database Mail-Profil hinzu.
1. Fügen Sie dem Database Mail-Profil Benutzer hinzu.
**Anmerkung**
Stellen Sie zum Konfigurieren von Database Mail sicher, dass Sie die Berechtigung zum `execute` für die gespeicherten Prozesse in der `msdb`-Datenbank haben.
## Erstellen des Database Mail-Profils
Um das Database Mail-Profil zu erstellen, verwenden Sie den gespeicherten Prozess [sysmail\$1add\$1profile\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql). Im folgenden Beispiel wird ein Profil namens erstell `Notifications`.
**So erstellen Sie das Profil**
+ Verwenden Sie die folgende SQL-Anweisung.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_profile_sp
@profile_name = 'Notifications',
@description = 'Profile used for sending outgoing notifications using Amazon SES.';
GO
```
## Erstellen des Database Mail-Kontos
Um das Database Mail-Konto zu erstellen, verwenden Sie den gespeicherten Prozess [sysmail\$1add\$1account\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql). Im folgenden Beispiel wird mithilfe des Amazon Simple Email Service ein Konto namens `SES` auf einer DB-Instance von RDS für SQL Server in einer privaten VPC erstellt.
Für die Verwendung von Amazon SES sind folgende Parameter erforderlich:
+ `@email_address` – eine von Amazon SES verifizierte Identität. Weitere Informationen finden Sie unter [Verifizieren von Identitäten in Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/verify-addresses-and-domains.html).
+ `@mailserver_name` – ein Amazon-SES-SMTP-Endpunkt. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit einem Amazon-SES-SMTP-Endpunkt](https://docs.aws.amazon.com/ses/latest/dg/smtp-connect.html).
+ `@username` – ein Amazon-SES-SMTP-Benutzername. Weitere Informationen finden Sie unter [Abrufen von Amazon-SES-SMTP-Anmeldeinformationen](https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html).
Verwenden Sie keinen AWS Identity and Access Management Benutzernamen.
+ `@password` – ein Amazon-SES-SMTP-Passwort. Weitere Informationen finden Sie unter [Abrufen von Amazon-SES-SMTP-Anmeldeinformationen](https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html).
**So erstellen Sie das Konto**
+ Verwenden Sie die folgende SQL-Anweisung.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_account_sp
@account_name = 'SES',
@description = 'Mail account for sending outgoing notifications.',
@email_address = 'nobody@example.com',
@display_name = 'Automated Mailer',
@mailserver_name = 'vpce-0a1b2c3d4e5f-01234567.email-smtp.us-west-2.vpce.amazonaws.com',
@port = 587,
@enable_ssl = 1,
@username = 'Smtp_Username',
@password = 'Smtp_Password';
GO
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen andere Anmeldeinformationen als hier angegeben an.
## Hinzufügen des Database Mail-Kontos zum Database Mail-Profil
Um das Database Mail-Konto dem Database Mail-Profil hinzuzufügen, verwenden Sie den gespeicherten Prozess [sysmail\$1add\$1profileaccount\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql). Im folgenden Beispiel wird das `SES`-Konto dem `Notifications`-Profil hinzugefügt.
**So fügen Sie das Konto dem Profil hinzu**
+ Verwenden Sie die folgende SQL-Anweisung.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp
@profile_name = 'Notifications',
@account_name = 'SES',
@sequence_number = 1;
GO
```
## Hinzufügen von Benutzern zum Database Mail-Profil
Um einem `msdb`-Datenbankprinzipal die Berechtigung zur Verwendung eines Database Mail-Profils zu erteilen, verwenden Sie den gespeicherten Prozess [sysmail\$1add\$1principalprofile\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql). Ein *Prinzipal* ist eine Entität, die SQL Server-Ressourcen anfordern kann. Der Datenbankprinzipal muss einem SQL Server-Authentifizierungsbenutzer, einem Windows-Authentifizierungsbenutzer oder einer Windows-Authentifizierungsgruppe zugeordnet werden.
Im folgenden Beispiel wird öffentlicher Zugriff auf das `Notifications`-Profil gewährt.
**So fügen Sie dem Profil einen Benutzer hinzu**
+ Verwenden Sie die folgende SQL-Anweisung.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp
@profile_name = 'Notifications',
@principal_name = 'public',
@is_default = 1;
GO
```
## In Amazon RDS gespeicherte Prozesse und Funktionen für Database Mail
Microsoft stellt [gespeicherte Prozeduren](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/database-mail-stored-procedures-transact-sql) für die Verwendung von Database Mail zur Verfügung, z. B. zum Erstellen, Auflisten, Aktualisieren und Löschen von Konten und Profilen. Darüber hinaus bietet RDS die in der folgenden Tabelle aufgeführten gespeicherten Prozeduren und Funktionen für Database Mail.
| Prozess/Funktion | Beschreibung |
| --- | --- |
| rds\$1fn\$1sysmail\$1allitems | Zeigt gesendete Nachrichten an, einschließlich der von anderen Benutzern übermittelten Nachrichten. |
| rds\$1fn\$1sysmail\$1event\$1log | Zeigt Ereignisse an, einschließlich solcher für Nachrichten, die von anderen Benutzern übermittelt wurden. |
| rds\$1fn\$1sysmail\$1mailanhänge | Zeigt Anhänge an, einschließlich solcher für Nachrichten, die von anderen Benutzern übermittelt wurden. |
| rds\$1sysmail\$1control | Startet und stoppt die Mail-Warteschlange (Prozess DatabaseMail.exe). |
| rds\$1sysmail\$1delete\$1mailitems\$1sp | Löscht E-Mail-Nachrichten, die von allen Benutzern aus den internen Tabellen von Database Mail gesendet wurden. |
# Senden von E-Mails mit Database Mail
Sie verwenden den gespeicherten Prozess [sp\$1send\$1dbmail](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql), um E-Mails mit Database Mail zu versenden.
## Usage
```
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'profile_name',
@recipients = 'recipient1@example.com[; recipient2; ... recipientn]',
@subject = 'subject',
@body = 'message_body',
[@body_format = 'HTML'],
[@file_attachments = 'file_path1; file_path2; ... file_pathn'],
[@query = 'SQL_query'],
[@attach_query_result_as_file = 0|1]';
```
Die folgenden Parameter sind erforderlich:
+ `@profile_name` – Der Name des Database Mail-Profils, von dem die Nachricht gesendet werden soll.
+ `@recipients` – Die durch Semikolons getrennte Liste der E-Mail-Adressen, an die die Nachricht gesendet werden soll.
+ `@subject` – Der Betreff der Nachricht.
+ `@body` – Der Text der Nachricht. Sie können auch eine angegebene Variable als Text verwenden.
Die folgenden Parameter sind optional:
+ `@body_format` – Dieser Parameter wird zusammen mit einer angegebenen Variable verwendet, um E-Mails im HTML-Format zu senden.
+ `@file_attachments` – Die durch Semikolons getrennte Liste von Nachrichtenanhängen. Dateipfade müssen absolute Pfade sein.
+ `@query` – Eine auszuführende SQL-Abfrage. Die Abfrageergebnisse können als Datei angehängt oder im Text der Nachricht enthalten sein.
+ `@attach_query_result_as_file` – Ob das Abfrageergebnis als Datei angehängt werden soll. Setzen Sie auf 0 für nein, 1 für ja. Der Standardwert ist 0.
## Beispiele
Die folgenden Beispiele veranschaulichen, wie Sie E-Mails versenden.
**Example das Senden einer Nachricht an einen einzelnen Empfänger**
```
USE msdb
GO
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'Automated DBMail message - 1',
@body = 'Database Mail configuration was successful.';
GO
```
**Example das Senden einer Nachricht an mehrere Empfänger**
```
USE msdb
GO
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'recipient1@example.com;recipient2@example.com',
@subject = 'Automated DBMail message - 2',
@body = 'This is a message.';
GO
```
**Example das Senden eines SQL-Abfrageergebnisses als Dateianhang**
```
USE msdb
GO
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'Test SQL query',
@body = 'This is a SQL query test.',
@query = 'SELECT * FROM abc.dbo.test',
@attach_query_result_as_file = 1;
GO
```
**Example das Senden einer Nachricht im HTML-Format**
```
USE msdb
GO
DECLARE @HTML_Body as NVARCHAR(500) = 'Hi,
Heading
See the report. Regards ';
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'Test HTML message',
@body = @HTML_Body,
@body_format = 'HTML';
GO
```
**Example des Sendens einer Nachricht mit einem Trigger, wenn ein bestimmtes Ereignis in der Datenbank auftritt**
```
USE AdventureWorks2017
GO
IF OBJECT_ID ('Production.iProductNotification', 'TR') IS NOT NULL
DROP TRIGGER Purchasing.iProductNotification
GO
CREATE TRIGGER iProductNotification ON Production.Product
FOR INSERT
AS
DECLARE @ProductInformation nvarchar(255);
SELECT
@ProductInformation = 'A new product, ' + Name + ', is now available for $' + CAST(StandardCost AS nvarchar(20)) + '!'
FROM INSERTED i;
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'New product information',
@body = @ProductInformation;
GO
```
# Anzeigen von Nachrichten, Protokollen und Anhängen
Sie verwenden gespeicherte RDS-Prozesse, um Nachrichten, Ereignisprotokolle und Anhänge anzuzeigen.
**So zeigen Sie alle E-Mails an**
+ Geben Sie die folgende SQL-Abfrage ein.
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_allitems(); --WHERE sent_status='sent' or 'failed' or 'unsent'
```
**So zeigen Sie alle E-Mail-Ereignisprotokolle an**
+ Geben Sie die folgende SQL-Abfrage ein.
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_event_log();
```
**So zeigen Sie alle E-Mail-Anhänge an**
+ Geben Sie die folgende SQL-Abfrage ein.
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_mailattachments();
```
# Löschen von Nachrichten
Sie verwenden die `rds_sysmail_delete_mailitems_sp` gespeicherte Prozedur, um Nachrichten zu löschen.
**Anmerkung**
RDS löscht automatisch Mail-Tabellenelemente, wenn die Daten des DBMail-Verlaufs mit einer Größe von 1 GB bei einer Aufbewahrungsdauer von mindestens 24 Stunden liegen.
Wenn Sie Postsendungen länger aufbewahren möchten, können Sie diese archivieren. Weitere Informationen finden Sie unter [Erstellen eines SQL Server-Agent-Jobs zum Archivieren von Database Mail-Nachrichten und Ereignisprotokollen](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/create-a-sql-server-agent-job-to-archive-database-mail-messages-and-event-logs) in der Microsoft-Dokumentation.
**So löschen Sie alle E-Mail-Nachrichten**
+ Verwenden Sie die folgende SQL-Anweisung.
```
DECLARE @GETDATE datetime
SET @GETDATE = GETDATE();
EXECUTE msdb.dbo.rds_sysmail_delete_mailitems_sp @sent_before = @GETDATE;
GO
```
**So löschen Sie alle E-Mail-Nachrichten mit einem bestimmten Status**
+ Mit der folgenden SQL-Anweisung löschen Sie alle fehlgeschlagenen Nachrichten.
```
DECLARE @GETDATE datetime
SET @GETDATE = GETDATE();
EXECUTE msdb.dbo.rds_sysmail_delete_mailitems_sp @sent_status = 'failed';
GO
```
# Starten und Anhalten der Mail-Warteschlange
Verwenden Sie die folgenden Anleitungen, um die DB-Mail-Warteschlange zu starten und anzuhalten:
**Topics**
+ [
## Starten der Mail-Warteschlange
](#SQLServer.DBMail.Start)
+ [
## Stoppen der Mail-Warteschlange
](#SQLServer.DBMail.Stop)
## Starten der Mail-Warteschlange
Sie verwenden die `rds_sysmail_control` gespeicherte Prozedur, um den Prozess Database Mail zu starten.
**Anmerkung**
Die Aktivierung von Database Mail startet automatisch die E-Mail-Warteschlange.
**So starten Sie die Mail-Warteschlange**
+ Verwenden Sie die folgende SQL-Anweisung.
```
EXECUTE msdb.dbo.rds_sysmail_control start;
GO
```
## Stoppen der Mail-Warteschlange
Sie verwenden die `rds_sysmail_control` gespeicherte Prozedur, um den Prozess Database Mail zu beenden.
**So stoppen Sie die Mail-Warteschlange**
+ Verwenden Sie die folgende SQL-Anweisung.
```
EXECUTE msdb.dbo.rds_sysmail_control stop;
GO
```
## Arbeiten mit Dateianlagen
Die folgenden Dateianhangserweiterungen werden in Database Mail-Nachrichten von RDS auf SQL Server nicht unterstützt: .ade, .adp, .apk, .appx, .appxbundle, .bat, .bak, .cab, .chm, .cmd, .com, .cpl, .dll, .dmg, .exe, .hta, .inf1, .ins, .isp, .iso, .jar, .job, .js, .jse, .ldf, .lib, .lnk, .mde, .mdf, .msc, .msi, .msix, .msixbundle, .msp, .mst, .nsh, .pif, .ps, .ps1, .psc1, .reg, .rgs, .scr, .sct, .shb, .shs, .svg, .sys, .u3p, .vb, .vbe, .vbs, .vbscript, .vxd, .ws, .wsc, .wsf und .wsh.
Database Mail verwendet den Microsoft Windows-Sicherheitskontext des aktuellen Benutzers, um den Zugriff auf Dateien zu steuern. Benutzer, die sich mit der SQL Server-Authentifizierung anmelden, können keine Dateien anhängen, die den `@file_attachments`-Parameter mit der `sp_send_dbmail` gespeicherten Prozedur verwenden. Windows erlaubt SQL Server nicht, Anmeldeinformationen von einem Remote-Computer an einen anderen Remote-Computer zu übermitteln. Daher kann Database Mail keine Dateien von einer Netzwerkfreigabe anhängen, wenn der Befehl von einem anderen Computer als dem Computer ausgeführt wird, auf dem SQL Server ausgeführt wird.
Sie können jedoch Jobs mit SQL Server Agent zum Anhängen von Dateien verwenden. Weitere Informationen zu SQL Server Agent finden Sie unter [Verwenden von SQL Server Agent für Amazon RDS](Appendix.SQLServer.CommonDBATasks.Agent.md) und unter [SQL Server Agent](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent) in der Microsoft-Dokumentation.
## Überlegungen zu Multi-AZ-Bereitstellungen
Wenn Sie Database Mail auf einer Multi-AZ-DB-Instance konfigurieren, wird die Konfiguration nicht automatisch an die sekundäre weitergegeben. Wir empfehlen, die Multi-AZ-Instance in eine Single-AZ-Instance zu konvertieren, Database Mail zu konfigurieren und dann die DB-Instance wieder in Multi-AZ zu konvertieren. Dann haben sowohl der primäre als auch der sekundäre Knoten die Database Mail-Konfiguration.
Wenn Sie eine Read Replica aus Ihrer Multi-AZ-Instance erstellen, für die Database Mail konfiguriert ist, erbt das Replikat die Konfiguration, jedoch ohne das Kennwort für den SMTP-Server. Aktualisieren Sie das Database Mail-Konto mit dem Passwort.
## Aufheben der SMTP-Einschränkung (Port 25)
AWS blockiert standardmäßig ausgehenden Datenverkehr auf SMTP (Port 25) für DB-Instances von RDS für SQL Server. Dies erfolgt basierend auf den Richtlinien des Eigentümers der Elastic-Network-Schnittstelle, um Spam zu verhindern. Sie können diese Einschränkung bei Bedarf aufheben. Weitere Informationen finden Sie unter [Wie entferne ich die Beschränkung für Anschluss 25 aus meiner Amazon-EC2-Instance oder Lambda-Funktion?](https://repost.aws/knowledge-center/ec2-port-25-throttle)
# Instance-Speicher-Support für die tempdb-Datenbank in Amazon RDS for SQL Server
Ein *Instance-Speicher* stellt für Ihre DB-Instance temporären Speicher auf Blockebene bereit. Dieser Speicher befindet sich auf Laufwerken, die physisch mit dem Hostcomputer verbunden sind. Diese Laufwerke verfügen über einen nicht-flüchtigen Memory Express (NVMe)-Instance-Speicher, der auf Solid-State-Laufwerken (SSD) basiert. Dieser Speicher ist für niedrige Latenzen, eine sehr hohe Random-I/O-Leistung und einen hohen sequentiellen Lesedurchsatz optimiert.
Durch das Speichern von `tempdb`-Datendateien und `tempdb`-Protokolldateien im Instance-Speicher können Sie im Vergleich zum Standardspeicher basierend auf Amazon EBS niedrigere Lese- und Schreiblatenzen erzielen.
**Anmerkung**
SQL Server-Datenbankdateien und Datenbankprotokolldateien werden nicht im Instance-Speicher platziert.
## Aktivieren des Instance-Speichers
Wenn RDS DB-Instances mit einem der folgenden Instance-Klassen bereitstellt, wird die `tempdb`-Datenbank automatisch in den Instance-Speicher eingefügt:
+ db.m5d
+ db.r5d
+ db.x2iedn
Um den Instance-Speicher zu aktivieren, führen Sie einen der folgenden Schritte aus:
+ Erstellen Sie eine SQL Server-DB-Instance mit einem dieser Instance-Typen. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Modifizieren Sie eine vorhandene SQL Server-DB-Instance, um eine davon zu verwenden. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
Der Instance-Speicher ist in allen AWS-Regionen verfügbar, in denen einer oder mehrere dieser Instance-Typen unterstützt werden. Weitere Informationen zu den Instance-Klassen `db.m5d` und `db.r5d` finden Sie unter [](Concepts.DBInstanceClass.md). Weitere Hinweise zu den von Amazon RDS for SQL Server unterstützten Instance-Klassen finden Sie unter [Unterstützung für Microsoft SQL Server-DB-Instance-Klassen](SQLServer.Concepts.General.InstanceClasses.md).
## Überlegungen zum Speicherort und zur Größe der Datei
Auf Instances ohne Instance-Speicher speichert RDS die Daten und Protokolldateien `tempdb` im Verzeichnis `D:\rdsdbdata\DATA`. Beide Dateien beginnen standardmäßig bei 8 MB.
Auf Instances mit Instance-Speicher speichert RDS die Daten und Protokolldateien `tempdb` im Verzeichnis `T:\rdsdbdata\DATA`.
Wann `tempdb` hat nur eine Datendatei (`tempdb.mdf`) und eine Protokolldatei (`templog.ldf`) hat, beginnt `templog.ldf` standardmäßig bei 8 MB und `tempdb.mdf` beginnt bei mindestens 80 % der Speicherkapazität der Instance. Zwanzig Prozent der Speicherkapazität oder 200 GB – je nachdem, was geringer ist – werden für den Start freigehalten. Mehrere `tempdb`-Datendateien teilen den Speicherplatz von 80 % gleichmäßig auf, während Protokolldateien immer eine Anfangsgröße von 8 MB haben.
Wenn Sie zum Beispiel Ihre DB-Instance-Klasse von `db.m5.2xlarge` zu `db.m5d.2xlarge` ändern, erhöht sich die Größe von `tempdb`-Datendateien von jeweils 8 MB auf 234 GB.
**Anmerkung**
Neben den Daten- und Protokolldateien `tempdb` im Instance-Speicher (`T:\rdsdbdata\DATA`), können Sie immer noch extra Daten und Protokolldateien `tempdb` auf dem Datenvolume (`D:\rdsdbdata\DATA`) erstellen. Diese Dateien haben immer eine Anfangsgröße von 8 MB.
## Überlegungen zu Backups
Möglicherweise müssen Sie Backups für lange Zeiträume aufbewahren, was im Laufe der Zeit Kosten verursacht. Die `tempdb`-Daten und -Protokollblöcke können sich je nach Workload sehr häufig ändern. Dies kann die Größe von DB-Snapshots erheblich erhöhen.
Wenn sich `tempdb` im Instance-Speicher befindet, enthalten Snapshots keine temporären Dateien. Dies bedeutet, dass die Snapshots kleiner sind und im Vergleich zu reinem EBS-Speicher weniger von der kostenlosen Sicherungszuweisung verbrauchen.
## Fehler „Voller Datenträger“
Wenn Sie den gesamten verfügbaren Speicherplatz im Instance-Speicher verwenden, erhalten Sie möglicherweise folgende Fehler:
+ Das Transaktionsprotokoll für die Datenbank 'tempdb' ist aufgrund von „ACTIVE\$1TRANSACTION“ voll.
+ In der Datenbank 'tempdb' konnte kein Speicherplatz für das Objekt 'dbo.SORT temporärer Speicher ausgeführt: 140738941419520' zugewiesen werden, da die Dateigruppe 'PRIMARY' voll ist. Schaffen Sie Speicherplatz, indem Sie nicht benötigte Dateien löschen, Objekte in die Dateigruppe verschieben, der Dateigruppe zusätzliche Dateien hinzufügen oder das automatische Erweitern für vorhandene Dateien in der Dateigruppe aktivieren.
Wenn der Instance-Speicher voll ist, können Sie eine oder mehrere der folgenden Aktionen ausführen:
+ Passen Sie Ihren Workload oder die Art der Nutzung von a `tempdb`.
+ Skalieren Sie auf die Verwendung einer DB-Instance-Klasse mit mehr NVMe-Speicher.
+ Verwenden Sie nicht länger den Instance-Speicher, sondern eine Instance-Klasse mit EBS-Speicher.
+ Verwenden Sie einen gemischten Modus, indem Sie sekundäre Daten oder Protokolldateien für `tempdb` zum EBS-Volume hinzufügen.
## Entfernen des Instance-Speichers
Um den Instance-Speicher zu entfernen, ändern Sie Ihre SQL Server-DB-Instance so, dass sie einen Instance-Typ verwendet, der keinen Instance-Speicher unterstützt, wie db.m5, db.r5 oder db.x1e.
**Anmerkung**
Wenn Sie den Instance-Speicher entfernen, werden die temporären Dateien in das Verzeichnis `D:\rdsdbdata\DATA` verschoben und auf 8 MB reduziert.
# Verwenden erweiterter Datenereignisse mit Amazon RDS für Microsoft SQL Server.
Sie können erweiterte Ereignisse in Microsoft SQL Server verwenden, um Informationen zum Debuggen und zur Fehlerbehebung für Amazon RDS für SQL Server zu erfassen. Erweiterte Ereignisse ersetzen SQL Trace und Server Profiler, die von Microsoft als veraltet aussortiert wurden. Erweiterte Ereignisse ähneln Profiler-Traces, haben jedoch eine genauere Kontrolle über die nachverfolgten Ereignisse. Erweiterte Ereignisse werden für SQL Server-Versionen 2016 und höher auf Amazon RDS unterstützt. Weitere Informationen finden Sie unter [Übersicht über erweiterte Ereignisse](https://docs.microsoft.com/en-us/sql/relational-databases/extended-events/extended-events) in der Microsoft-Dokumentation.
Erweiterte Ereignisse werden automatisch für Benutzer mit Master-Benutzerrechten in Amazon RDS für SQL Server aktiviert.
**Topics**
+ [
## Einschränkungen und Empfehlungen
](#SQLServer.ExtendedEvents.Limits)
+ [
## Konfigurieren von erweiterten Ereignissen auf RDS für SQL Server
](#SQLServer.ExtendedEvents.Config)
+ [
## Überlegungen zu Multi-AZ-Bereitstellungen
](#SQLServer.ExtendedEvents.MAZ)
+ [
## Abfragen von erweiterten Ereignisdateien
](#SQLServer.ExtendedEvents.Querying)
## Einschränkungen und Empfehlungen
Wenn Sie erweiterte Ereignisse von RDS für SQL Server verwenden, gelten die folgenden Einschränkungen:
+ Erweiterte Ereignisse werden nur für die Enterprise und Standard Editions unterstützt.
+ Sie können standardmäßige erweiterte Ereignissitzungen nicht ändern.
+ Stellen Sie sicher, dass Sie die Sitzungsspeicherpartition auf einstelle `NONE`.
+ Der Aufbewahrungsmodus für Sitzungsereignisse kann entweder `ALLOW_SINGLE_EVENT_LOSS` oder `ALLOW_MULTIPLE_EVENT_LOSS` sein.
+ Ereignisverfolgung für Windows (ETW) -Ziele wird nicht unterstützt.
+ Stellen Sie sicher, dass sich die Dateiziele im Verzeichnis `D:\rdsdbdata\log` befinden.
+ Um zusammengehörige Ziele zu paaren, setzen Sie die `respond_to_memory_pressure`-Eigenschaft auf `1`.
+ Der Zielspeicher des Ringpuffers darf nicht größer als 4 MB sein.
+ Die folgenden Aktionen werden nicht unterstützt:
+ `debug_break`
+ `create_dump_all_threads`
+ `create_dump_single_threads`
+ Das `rpc_completed` Ereignis wird in den folgenden Versionen und später unterstützt: 15.0.4083.2, 14.0.3370.1, 13.0.5865.1, 12.0.6433.1, 11.0.7507.2.
## Konfigurieren von erweiterten Ereignissen auf RDS für SQL Server
Auf RDS für SQL Server können Sie die Werte bestimmter Parameter von erweiterten Ereignissitzungen konfigurieren. In der folgenden Tabelle werden die konfigurierbaren Parameter beschrieben.
| Parametername | Beschreibung | RDS-Standardwert | Mindestwert | Maximaler Wert |
| --- | --- | --- | --- | --- |
| xe\$1session\$1max\$1memory | Angabe der maximalen Speichermenge, die der Sitzung für die Ereignispufferung zugewiesen werden soll. Dieser Wert entspricht der max\$1memory-Einstellung der Ereignissitzung. | 4 MB | 4 MB | 8 MB |
| xe\$1session\$1max\$1event\$1size | Angabe der maximalen Speichergröße an, die für große Ereignisse zulässig ist. Dieser Wert entspricht der max\$1event\$1size-Einstellung der Ereignissitzung. | 4 MB | 4 MB | 8 MB |
| xe\$1session\$1max\$1dispatch\$1latency | Angabe der Dauer der Pufferung von Ereignissen im Speicher, bevor sie an erweiterte Ereignissitzungsziele abgegeben werden. Dieser Wert entspricht der max\$1dispatch\$1latency-Einstellung der Ereignissitzung. | 30 Sekunden | 1 Sekunde | 30 Sekunden |
| xe\$1file\$1target\$1size | Festlegung der maximalen Größe des Dateiziels. Dieser Wert entspricht der max\$1file\$1size-Einstellung des Dateiziels. | 100 MB | 10 MB | 1 GB |
| xe\$1file\$1retention | Angabe der Aufbewahrungszeit für Dateien in Tagen, die von den Dateizielen von Ereignissitzungen generiert werden. | 7 Tage | 0 Tage | 7 Tage |
**Anmerkung**
Wenn Sie `xe_file_retention` auf Null setzen, werden .xel-Dateien automatisch entfernt, nachdem die Sperre für diese Dateien von SQL Server aufgehoben wurde. Die Sperre wird aufgehoben, wenn eine .xel-Datei die in eingestellte Größenbeschränkung erreich `xe_file_target_size`.
Sie können die in `rdsadmin.dbo.rds_show_configuration` gespeicherte Prozedur verwenden, um die aktuellen Werte dieser Parameter anzuzeigen. Verwenden Sie beispielsweise die folgende SQL-Anweisung, um die aktuelle Einstellung von anzuzeige `xe_session_max_memory`.
```
exec rdsadmin.dbo.rds_show_configuration 'xe_session_max_memory'
```
Sie können die in `rdsadmin.dbo.rds_set_configuration` gespeicherte Prozedur verwenden, um sie zu ändern. Verwenden Sie beispielsweise die folgende SQL-Anweisung, um `xe_session_max_memory` auf 4 MB festzulegen.
```
exec rdsadmin.dbo.rds_set_configuration 'xe_session_max_memory', 4
```
## Überlegungen zu Multi-AZ-Bereitstellungen
Wenn Sie eine erweiterte Ereignissitzung auf einer primären DB-Instance erstellen, wird sie nicht auf das Standby-Replikat übertragen. Sie können einen Failover haben und die erweiterte Ereignissitzung für die neue primäre DB-Instance erstellen. Oder Sie können die Multi-AZ-Konfiguration entfernen und dann erneut hinzufügen, um die erweiterte Ereignissitzung auf das Standby-Replikat zu übertragen. RDS stoppt alle nicht standardmäßigen erweiterten Ereignissitzungen auf dem Standby-Replikat, so dass diese Sitzungen keine Ressourcen im Standby verbrauchen. Nachdem ein Standby-Replikat zur primären DB-Instance wurde, sollten Sie daher die erweiterten Ereignissitzungen manuell auf der neuen primären DB-Instance starten.
**Anmerkung**
Dieser Ansatz gilt sowohl für Always On-Verfügbarkeitsgruppen als auch für die Datenbankspiegelung.
Sie können auch einen SQL Server Agent-Auftrag verwenden, um das Standby-Replikat nachzuverfolgen und die Sitzungen zu starten, wenn der Standby- zur primären DB-Instance wird. Verwenden Sie beispielsweise die folgende Abfrage in Ihrem Auftragsschritt für den SQL Server-Agenten, um Ereignissitzungen auf einer primären DB-Instance neu zu starten.
```
BEGIN
IF (DATABASEPROPERTYEX('rdsadmin','Updateability')='READ_WRITE'
AND DATABASEPROPERTYEX('rdsadmin','status')='ONLINE'
AND (DATABASEPROPERTYEX('rdsadmin','Collation') IS NOT NULL OR DATABASEPROPERTYEX('rdsadmin','IsAutoClose')=1)
)
BEGIN
IF NOT EXISTS (SELECT 1 FROM sys.dm_xe_sessions WHERE name='xe1')
ALTER EVENT SESSION xe1 ON SERVER STATE=START
IF NOT EXISTS (SELECT 1 FROM sys.dm_xe_sessions WHERE name='xe2')
ALTER EVENT SESSION xe2 ON SERVER STATE=START
END
END
```
Diese Abfrage startet die Ereignissitzungen `xe1` und `xe2` auf einer primären DB-Instance neu, wenn sich diese Sitzungen in einem gestoppten Zustand befinden. Sie können dieser Abfrage auch einen Zeitplan mit einem passenden Intervall hinzufügen.
## Abfragen von erweiterten Ereignisdateien
Sie können entweder SQL Server Management Studio oder die `sys.fn_xe_file_target_read_file`-Funktion verwenden, um Daten aus erweiterten Ereignissen anzuzeigen, die Dateiziele verwenden. Weitere Informationen zu dieser Funktion finden Sie in der Microsoft-Dokumentation unter [sys.fn\$1xe\$1file\$1target\$1read\$1file (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-functions/sys-fn-xe-file-target-read-file-transact-sql).
Dateiziele erweiterter Ereignisse können nur Dateien in das `D:\rdsdbdata\log`-Verzeichnis auf RDS für SQL Server schreiben.
Verwenden Sie beispielsweise die folgende SQL-Abfrage, um den Inhalt aller Dateien von erweiterten Ereignissitzungen aufzulisten, deren Namen mit beginne `xe`.
```
SELECT * FROM sys.fn_xe_file_target_read_file('d:\rdsdbdata\log\xe*', null,null,null);
```
# Zugriff auf Transaktionsprotokoll-Backups mit RDS für SQL Server
Mit Zugriff auf Transaktionsprotokoll-Backups für RDS für SQL Server können Sie die Transaktionsprotokoll-Backup-Dateien für eine Datenbank auflisten und sie in einen Ziel-Bucket von Amazon S3 kopieren. Indem Sie Transaktionsprotokoll-Backups in einen Amazon-S3-Bucket kopieren, können Sie sie in Kombination mit vollständigen und differentiellen Datenbank-Backups verwenden, um zeitpunktbezogene Datenbankwiederherstellungen durchzuführen. Sie verwenden gespeicherte RDS-Prozeduren, um den Zugriff auf Transaktionsprotokoll-Backups einzurichten, verfügbare Transaktionsprotokoll-Backups aufzulisten und sie in Ihren Amazon-S3-Bucket zu kopieren.
Der Zugriff auf Transaktionsprotokoll-Backups bietet die folgenden Funktionen und Vorteile:
+ Sie können die Metadaten verfügbarer Transaktionsprotokoll-Backups für eine Datenbank auf einer DB-Instance von RDS für SQL Server auflisten und anzeigen.
+ Sie können verfügbare Transaktionsprotokoll-Backups von RDS für SQL Server in einen Ziel-Bucket von Amazon S3 kopieren.
+ Führen Sie point-in-time Wiederherstellungen von Datenbanken durch, ohne eine gesamte DB-Instance wiederherstellen zu müssen. Weitere Informationen zum Wiederherstellen einer DB-Instance für einen bestimmten Zeitpunkt finden Sie unter [Wiederherstellen einer DB-Instance auf einen bestimmten Zeitpunkt für Amazon RDS](USER_PIT.md).
## Verfügbarkeit und Support
Der Zugriff auf Transaktionsprotokoll-Backups wird in allen AWS Regionen unterstützt. Der Zugriff auf Transaktionsprotokoll-Backups ist für alle in Amazon RDS unterstützten Editionen und Versionen von Microsoft SQL Server verfügbar.
## Voraussetzungen
Es müssen die folgenden Anforderungen erfüllt sein, um den Zugriff auf Transaktionsprotokoll-Backups zu aktivieren:
+ Automatisierte Backups müssen auf der DB-Instance aktiviert sein und die Backup-Aufbewahrung muss auf einen Wert von einem oder mehreren Tagen festgelegt werden. Weitere Informationen zur Aktivierung automatisierter Backups und zur Konfiguration einer Aufbewahrungsrichtlinie finden Sie unter [Aktivieren von automatisierten Backups](USER_WorkingWithAutomatedBackups.Enabling.md).
+ Ein Amazon-S3-Bucket muss im gleichen Konto und in derselben Region wie die Quell-DB-Instance existieren. Bevor Sie den Zugriff auf Transaktionsprotokoll-Backups aktivieren, wählen Sie einen vorhandenen Amazon-S3-Bucket aus oder [erstellen Sie einen neuen Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html), der für Ihre Transaktionsprotokoll-Backup-Dateien verwendet werden soll.
+ Eine Berechtigungsrichtlinie für den Amazon-S3-Bucket-muss wie folgt konfiguriert werden, damit Amazon RDS Transaktionsprotokolldateien hineinkopieren kann:
1. Legen Sie die Eigenschaft für den Objektkontobesitz für den Bucket auf **Bucket Owner Preferred** (Bucket-Eigentümer bevorzugt) fest.
1. Fügen Sie die folgende Richtlinie hinzu. In der Standardeinstellung ist keine Richtlinie vorhanden. Verwenden Sie daher die Zugriffssteuerungsliste (ACL) für den Bucket, um die Bucket-Richtlinie zu bearbeiten und hinzuzufügen.
Im folgenden Beispiel wird ein ARN zur Angabe einer Ressource verwendet. Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel `SourceArn` und `SourceAccount` in ressourcenbasierten Vertrauensbeziehungen, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Weitere Informationen zur Arbeit mit ARNs finden Sie unter [Amazon-Ressourcennamen (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) und[Amazon-Ressourcennamen (ARN) in Amazon RDS](USER_Tagging.ARN.md).
**Example einer Amazon-S3-Berechtigungsrichtlinie für den Zugriff auf Transaktionsprotokoll-Backups**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Only allow writes to my bucket with bucket owner full control",
"Effect": "Allow",
"Principal": {
"Service": "backups.rds.amazonaws.com"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/{customer_path}/*",
"Condition": {
"StringEquals": {
"s3:x-amz-acl": "bucket-owner-full-control",
"aws:sourceAccount": "{customer_account}",
"aws:sourceArn": "{db_instance_arn}"
}
}
}
]
}
```
------
+ Eine AWS Identity and Access Management (IAM-) Rolle für den Zugriff auf den Amazon S3 S3-Bucket. Wenn Sie bereits über eine IAM-Rolle verfügen, können Sie diese verwenden. Alternativ können Sie wählen, dass eine neue IAM-Rolle für Sie erstellt wird, wenn Sie die Option `SQLSERVER_BACKUP_RESTORE` mithilfe der AWS-Managementkonsole hinzufügen. Alternativ können Sie manuell eine neue Rolle erstellen. Weitere Informationen zum Erstellen und Konfigurieren einer IAM-Rolle mit `SQLSERVER_BACKUP_RESTORE` finden Sie unter [Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM).
+ Die Option `SQLSERVER_BACKUP_RESTORE` muss einer Optionsgruppe auf Ihrer DB-Instance hinzugefügt werden. Weitere Informationen zum Hinzufügen der Option `SQLSERVER_BACKUP_RESTORE` finden Sie unter [Unterstützung für native Sicherung und Backup in SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
**Anmerkung**
Wenn für Ihre DB-Instance die Speicherverschlüsselung aktiviert ist, müssen die AWS KMS (KMS) -Aktionen und der Schlüssel in der IAM-Rolle bereitgestellt werden, die in der Optionsgruppe für systemeigene Sicherung und Wiederherstellung bereitgestellt wird.
Wenn Sie die gespeicherte Prozedur `rds_restore_log` zur Durchführung von zeitpunktbezogenen Datenbankwiederherstellungen verwenden möchten, empfehlen wir optional, denselben Amazon-S3-Pfad für die systemeigene Sicherungs- und Wiederherstellungsoptionsgruppe und den Zugriff auf Transaktionsprotokoll-Backups zu verwenden. Diese Methode stellt sicher, dass Amazon RDS, wenn es die Rolle der Optionsgruppe zur Ausführung der Wiederherstellungsprotokollfunktionen übernimmt, Zugriff auf das Abrufen von Transaktionsprotokoll-Backups aus demselben Amazon-S3-Pfad hat.
+ Wenn die DB-Instance unabhängig vom Verschlüsselungstyp (AWS verwalteter Schlüssel oder vom Kunden verwalteter Schlüssel) verschlüsselt ist, müssen Sie in der IAM-Rolle und in der `rds_tlog_backup_copy_to_S3` gespeicherten Prozedur einen vom Kunden verwalteten KMS-Schlüssel angeben.
## Einschränkungen und Empfehlungen
Für den Zugriff auf Transaktionsprotokoll-Backups gelten die folgenden Einschränkungen und Empfehlungen:
+ Sie können die Transaktionsprotokoll-Backups der letzten sieben Tage für jede DB-Instance auflisten und kopieren, für die die Backup-Aufbewahrung zwischen 1 und 35 Tagen konfiguriert ist.
+ Ein Amazon-S3-Bucket, der für den Zugriff auf Transaktionsprotokoll-Backups verwendet wird, muss sich im gleichen Konto und in derselben Region wie die Quell-DB-Instance befinden. Kontoübergreifendes und regionsübergreifendes Kopieren wird nicht unterstützt.
+ Es kann nur ein Amazon-S3-Bucket als Ziel konfiguriert werden, in das Transaktionsprotokoll-Backups kopiert werden. Sie können mit der gespeicherten Prozedur `rds_tlog_copy_setup` einen neuen Ziel-Bucket von Amazon S3 auswählen. Weitere Informationen zur Auswahl eines neuen Ziel-Buckets von Amazon S3 finden Sie unter [Einrichten des Zugriffs auf Transaktionsprotokoll-Backups](USER.SQLServer.AddlFeat.TransactionLogAccess.Enabling.md).
+ Sie können den KMS-Schlüssel bei Verwendung der gespeicherten Prozedur `rds_tlog_backup_copy_to_S3` nicht angeben, wenn Ihre RDS-Instance nicht für die Speicherverschlüsselung aktiviert ist.
+ Das Kopieren mehrerer Konten wird nicht unterstützt. Die zum Kopieren verwendete IAM-Rolle erlaubt nur den Schreibzugriff auf Amazon-S3-Buckets innerhalb des Besitzerkontos der DB-Instance.
+ Auf einer DB-Instance von RDS für SQL Server können nur zwei gleichzeitige Aufgaben eines beliebigen Typs ausgeführt werden.
+ Für eine einzelne Datenbank kann zu einem bestimmten Zeitpunkt nur eine Kopieraufgabe ausgeführt werden. Wenn Sie Transaktionsprotokoll-Backups für mehrere Datenbanken auf der DB-Instance kopieren möchten, verwenden Sie für jede Datenbank eine separate Kopieraufgabe.
+ Wenn Sie ein Transaktionsprotokoll-Backup kopieren, das bereits mit demselben Namen im Amazon-S3-Bucket existiert, wird das vorhandene Transaktionsprotokoll-Backup überschrieben.
+ Sie können nur die gespeicherten Prozeduren ausführen, die Zugriff auf Transaktionsprotokoll-Backups auf der primären DB-Instance haben. Sie können diese gespeicherten Prozeduren nicht auf einem Lesereplikat von RDS für SQL Server oder auf einer sekundären Instance eines Multi-AZ-DB-Clusters ausführen.
+ Wenn die DB-Instance von RDS für SQL Server neu gestartet wird, während die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` ausgeführt wird, wird die Aufgabe automatisch von Anfang an neu gestartet, wenn die DB-Instance wieder online ist. Alle Transaktionsprotokoll-Backups, die während der Ausführung der Aufgabe vor dem Neustart in den Amazon-S3-Bucket kopiert wurden, werden überschrieben.
+ Die Systemdatenbanken von Microsoft SQL Server und die `RDSAdmin`-Datenbank können nicht für den Zugriff auf Transaktionsprotokoll-Backups konfiguriert werden.
+ Das Kopieren in mit SSE-KMS verschlüsselte Buckets wird nicht unterstützt.
# Einrichten des Zugriffs auf Transaktionsprotokoll-Backups
Wenn Sie den Zugriff auf Transaktionsprotokoll-Backups einrichten möchten, erfüllen Sie alle Anforderungen in der Liste im Abschnitt [Voraussetzungen](USER.SQLServer.AddlFeat.TransactionLogAccess.md#USER.SQLServer.AddlFeat.TransactionLogAccess.Requirements) und führen Sie dann die gespeicherte Prozedur `rds_tlog_copy_setup` aus. Das Verfahren ermöglicht den Zugriff auf die Funktion für Transaktionsprotokoll-Backups auf DB-Instance-Ebene. Sie müssen es nicht für jede einzelne Datenbank auf der DB-Instance ausführen.
**Wichtig**
Dem Datenbankbenutzer muss die `db_owner`-Rolle innerhalb von SQL Server für jede Datenbank zugewiesen werden, um die Funktion für den Zugriff auf Transaktionsprotokoll-Backups zu konfigurieren und zu verwenden.
**Example Verwendung:**
```
exec msdb.dbo.rds_tlog_copy_setup
@target_s3_arn='arn:aws:s3:::amzn-s3-demo-bucket/myfolder';
```
Der folgende Parameter ist erforderlich:
+ `@target_s3_arn` – Der ARN des Ziel-Buckets von Amazon S3, in den die Transaktionsprotokoll-Backup-Dateien kopiert werden sollen.
**Example Einrichten eines Ziel-Buckets von Amazon S3:**
```
exec msdb.dbo.rds_tlog_copy_setup @target_s3_arn='arn:aws:s3:::amzn-s3-demo-logging-bucket/mytestdb1';
```
Rufen Sie die gespeicherte Prozedur `rds_show_configuration` auf, um die Konfiguration zu überprüfen.
**Example Überprüfen der Konfiguration:**
```
exec rdsadmin.dbo.rds_show_configuration @name='target_s3_arn_for_tlog_copy';
```
Um den Zugriff auf Transaktionsprotokoll-Backups so zu ändern, dass sie auf einen anderen Amazon-S3-Bucket verweisen, können Sie den aktuellen Amazon-S3-Bucket-Wert anzeigen und die gespeicherte Prozedur `rds_tlog_copy_setup` mit einem neuen Wert für `@target_s3_arn` erneut ausführen.
**Example Anzeigen des vorhandenen Amazon-S3-Buckets, der für den Zugriff auf Transaktionsprotokoll-Backups konfiguriert ist**
```
exec rdsadmin.dbo.rds_show_configuration @name='target_s3_arn_for_tlog_copy';
```
**Example Aktualisieren auf einen neuen Ziel-Bucket von Amazon S3**
```
exec msdb.dbo.rds_tlog_copy_setup @target_s3_arn='arn:aws:s3:::amzn-s3-demo-logging-bucket1/mynewfolder';
```
# Verfügbare Transaktionsprotokoll-Backups auflisten
Mit RDS für SQL Server sind Transaktionsprotokoll-Backups für Datenbanken, die für die Verwendung des vollständigen Wiederherstellungsmodells konfiguriert sind, und für eine DB-Instance-Backup-Aufbewahrung, die auf einen oder mehrere Tage festgelegt ist, automatisch aktiviert. Wenn Sie den Zugriff auf Transaktionsprotokoll-Backups aktivieren, stehen Ihnen bis zu sieben Tage dieser Transaktionsprotokoll-Backups zur Verfügung, damit Sie sie in Ihren Amazon-S3-Bucket kopieren können.
Nachdem Sie den Zugriff auf Transaktionsprotokoll-Backups aktiviert haben, können Sie damit beginnen, verfügbare Transaktionsprotokoll-Backup-Dateien aufzulisten und zu kopieren.
**Auflisten von Transaktionsprotokoll-Backups**
Rufen Sie die `rds_fn_list_tlog_backup_metadata`-Funktion auf, um alle für eine einzelne Datenbank verfügbaren Transaktionsprotokoll-Backups aufzulisten. Sie können eine `ORDER BY`- oder eine `WHERE`-Klausel verwenden, wenn Sie die Funktion aufrufen.
**Example Auflistung und Filterung verfügbarer Transaktionsprotokoll-Backup-Dateien**
```
SELECT * from msdb.dbo.rds_fn_list_tlog_backup_metadata('mydatabasename');
SELECT * from msdb.dbo.rds_fn_list_tlog_backup_metadata('mydatabasename') WHERE rds_backup_seq_id = 3507;
SELECT * from msdb.dbo.rds_fn_list_tlog_backup_metadata('mydatabasename') WHERE backup_file_time_utc > '2022-09-15 20:44:01' ORDER BY backup_file_time_utc DESC;
```
![\[Ausgabe von rds_fn_list_tlog_backup_metadata\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_func.png)
Die Funktion `rds_fn_list_tlog_backup_metadata` gibt beispielsweise die folgende Ausgabe zurück:
****
| Name der Spalte | Datentyp | Description |
| --- | --- | --- |
| `db_name` | sysname | Der Datenbankname, der für die Auflistung der Transaktionsprotokoll-Backups angegeben wurde. |
| `db_id` | int | Die interne Datenbank-ID für den Eingabeparameter `db_name`. |
| `family_guid` | uniqueidentifier | Die eindeutige ID der ursprünglichen Datenbank zum Zeitpunkt der Erstellung. Dieser Wert bleibt unverändert, wenn die Datenbank wiederhergestellt wird, auch unter einem anderen Datenbanknamen. |
| `rds_backup_seq_id` | int | Die ID, die RDS intern verwendet, um eine Sequenznummer für jede Transaktionsprotokoll-Backup-Datei zu verwalten. |
| `backup_file_epoch` | bigint | Die Epochenzeit, zu der eine Transaktions-Backup-Datei generiert wurde. |
| `backup_file_time_utc` | datetime | Der in UTC umgerechnete Wert für den `backup_file_epoch`-Wert. |
| `starting_lsn` | numeric(25,0) | Die Protokollsequenznummer des ersten oder ältesten Protokolldatensatzes einer Transaktionsprotokoll-Backup-Datei. |
| `ending_lsn` | numeric(25,0) | Die Protokollsequenznummer des letzten oder nächsten Protokolldatensatzes einer Transaktionsprotokoll-Backup-Datei. |
| `is_log_chain_broken` | Bit | Ein boolescher Wert, der angibt, ob die Protokollkette zwischen der aktuellen Transaktionsprotokoll-Backup-Datei und der vorherigen Transaktionsprotokoll-Backup-Datei unterbrochen ist. |
| `file_size_bytes` | bigint | Die Größe des Transaktions-Backups in Byte. |
| `Error` | varchar(4000) | Fehlermeldung, wenn die `rds_fn_list_tlog_backup_metadata`-Funktion eine Ausnahme auslöst. NULL, wenn keine Ausnahmen vorliegen. |
# Kopieren von Transaktionsprotokoll-Backups
Rufen Sie die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` auf, um eine Reihe verfügbarer Transaktionsprotokoll-Backups für eine einzelne Datenbank in Ihren Amazon-S3-Bucket zu kopieren. Die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` initiiert eine neue Aufgabe zum Kopieren von Transaktionsprotokoll-Backups.
**Anmerkung**
Die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` kopiert die Transaktionsprotokoll-Backups, ohne sie anhand eines `is_log_chain_broken`-Attributs zu validieren. Aus diesem Grund sollten Sie eine ununterbrochene Protokollkette manuell bestätigen, bevor Sie di gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` ausführen. Weitere Erläuterungen finden Sie unter [Validierung der Backup-Protokollkette des Transaktionsprotokolls](#USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.LogChain).
**Example Verwendung der gespeicherten Prozedur `rds_tlog_backup_copy_to_S3`**
```
exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='mydatabasename',
[@kms_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@backup_file_start_time='2022-09-01 01:00:15'],
[@backup_file_end_time='2022-09-01 21:30:45'],
[@starting_lsn=149000000112100001],
[@ending_lsn=149000000120400001],
[@rds_backup_starting_seq_id=5],
[@rds_backup_ending_seq_id=10];
```
Die folgenden Eingabeparameter sind verfügbar:
****
| Parameter | Description |
| --- | --- |
| `@db_name` | Der Datenbankname, der zum Kopieren der Transaktionsprotokoll-Backups angegeben wurde |
| `@kms_key_arn` | Ein kundenseitig verwalteter KMS-Schlüssel. Wenn Sie Ihre DB-Instance mit einem AWS verwalteten KMS-Schlüssel verschlüsseln, müssen Sie einen vom Kunden verwalteten Schlüssel erstellen. Wenn Sie Ihre DB-Instance mit einem kundenseitig verwalteten Schlüssel verschlüsseln, können Sie denselben KMS-Schlüssel-ARN verwenden. |
| `@backup_file_start_time` | Der UTC-Zeitstempel, wie er in der Spalte `[backup_file_time_utc]` der Funktion `rds_fn_list_tlog_backup_metadata` bereitgestellt wird. |
| `@backup_file_end_time` | Der UTC-Zeitstempel, wie er in der Spalte `[backup_file_time_utc]` der Funktion `rds_fn_list_tlog_backup_metadata` bereitgestellt wird. |
| `@starting_lsn` | Die Protokollsequenznummer (LSN), wie sie in der Spalte `[starting_lsn]` der Funktion `rds_fn_list_tlog_backup_metadata` angegeben ist |
| `@ending_lsn` | Die Protokollsequenznummer (LSN), wie sie in der Spalte `[ending_lsn]` der Funktion `rds_fn_list_tlog_backup_metadata` angegeben ist. |
| `@rds_backup_starting_seq_id` | Die Protokollsequenz-ID, wie sie in der Spalte `[rds_backup_seq_id]` der Funktion `rds_fn_list_tlog_backup_metadata` angegeben ist. |
| `@rds_backup_ending_seq_id` | Die Protokollsequenz-ID, wie sie in der Spalte `[rds_backup_seq_id]` der Funktion `rds_fn_list_tlog_backup_metadata` angegeben ist. |
Sie können einen Satz von Zeit-, LSN- oder Sequenz-ID-Parametern angeben. Es ist nur ein Satz von Parametern erforderlich.
Sie können auch nur einen einzelnen Parameter in einem der Sätze angeben. Wenn Sie beispielsweise nur einen Wert für den `backup_file_end_time`-Parameter angeben, werden alle verfügbaren Transaktionsprotokoll-Backupdateien vor diesem Zeitpunkt innerhalb des Sieben-Tage-Limits in Ihren Amazon-S3-Bucket kopiert.
Im Folgenden sind die gültigen Eingabeparameterkombinationen für die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` aufgeführt.
****
| Angegebene Parameter | Erwartetes Ergebnis |
| --- | --- |
|
| Kopiert Transaktionsprotokoll-Backups der letzten sieben Tage und liegt zwischen dem angegebenen Bereich von `backup_file_start_time` und `backup_file_end_time`. In diesem Beispiel kopiert die gespeicherte Prozedur Transaktionsprotokoll-Backups, die zwischen '2022-08-23 00:00:00 'und '2022-08-30 00:00:00' generiert wurden. |
|
| Kopiert Transaktionsprotokoll-Backups der letzten sieben Tage und beginnt mit dem angegebenen Wert für `backup_file_start_time`. In diesem Beispiel kopiert die gespeicherte Prozedur die Transaktionsprotokoll-Backups von '2022-08-23 00:00:00' bis zum letzten Transaktionsprotokoll-Backup. |
|
| Kopiert Transaktionsprotokoll-Backups der letzten sieben Tage bis zum angegebenen Wert für `backup_file_end_time`. In diesem Beispiel kopiert die gespeicherte Prozedur Transaktionsprotokoll-Backups von '2022-08-23 00:00:00' bis '2022-08-30 00:00:00'. |
|
| Kopiert Transaktionsprotokoll-Backups, die in den letzten sieben Tagen verfügbar sind und zwischen dem angegebenen Bereich von `starting_lsn` und `ending_lsn` liegen. In diesem Beispiel kopiert die gespeicherte Prozedur die Transaktionsprotokoll-Backups der letzten sieben Tage mit einem LSN-Bereich zwischen 1490000000040007 und 1490000000050009. |
|
| Kopiert Transaktionsprotokoll-Backups, die in den letzten sieben Tagen verfügbar sind, ab dem für `starting_lsn` angegebenen Wert. In diesem Beispiel kopiert die gespeicherte Prozedur die Transaktionsprotokoll-Backups von LSN 1490000000040007 bis zum letzten Transaktionsprotokoll-Backup. |
|
| Kopiert Transaktionsprotokoll-Backups, die in den letzten sieben Tagen verfügbar sind, bis zu dem für `ending_lsn` angegebenen Wert. In diesem Beispiel kopiert die gespeicherte Prozedur die Transaktionsprotokoll-Backups ab der letzten sieben Tage bis zum LSN-Bereich 1490000000050009. |
|
| Kopiert Transaktionsprotokoll-Backups, die in den letzten sieben Tagen verfügbar sind und sich im angegebenen Bereich von `rds_backup_starting_seq_id` bis `rds_backup_ending_seq_id` befinden. In diesem Beispiel kopiert die gespeicherte Prozedur Transaktionsprotokoll-Backups ab den letzten sieben Tagen und innerhalb des angegebenen Sequenz-ID-Bereichs für RDS-Backups, beginnend bei seq\$1id 2000 bis seq\$1id 5000. |
|
| Kopiert Transaktionsprotokoll-Backups, die in den letzten sieben Tagen verfügbar sind, ab dem für `rds_backup_starting_seq_id` angegebenen Wert. In diesem Beispiel kopiert die gespeicherte Prozedur die Transaktionsprotokoll-Backups ab seq\$1id 2000 bis zum letzten Transaktionsprotokoll-Backup. |
|
| Kopiert Transaktionsprotokoll-Backups, die in den letzten sieben Tagen verfügbar sind, bis zu dem für `rds_backup_ending_seq_id` angegebenen Wert. In diesem Beispiel kopiert die gespeicherte Prozedur die Transaktionsprotokoll-Backups ab der letzten sieben Tage bis zu seq\$1id 5000. |
|
| Kopiert ein einzelnes Transaktionsprotokoll-Backup mit der angegebenen `rds_backup_starting_seq_id`, sofern innerhalb der letzten sieben Tage verfügbar. Bei diesem Beispiel kopiert die gespeicherte Prozedur ein einzelnes Transaktionsprotokoll-Backup mit einer seq\$1id von 2000, falls es innerhalb der letzten sieben Tage existiert. |
## Validierung der Backup-Protokollkette des Transaktionsprotokolls
Für Datenbanken, die für den Zugriff auf Transaktionsprotokoll-Backups konfiguriert sind, muss die automatische Aufbewahrung von Backups aktiviert sein. Durch die automatische Aufbewahrung von Backups werden die Datenbanken auf der DB-Instance auf das `FULL`-Wiederherstellungsmodell eingestellt. Um die zeitpunktbezogene Wiederherstellung für eine Datenbank zu unterstützen, sollten Sie das Datenbank-Wiederherstellungsmodell nicht ändern, da dies zu einer fehlerhaften Protokollkette führen kann. Wir empfehlen, die Datenbank auf das `FULL`-Wiederherstellungsmodell einzustellen.
Um die Protokollkette manuell zu validieren, bevor Sie die Transaktionsprotokoll-Backups kopieren, rufen Sie die `rds_fn_list_tlog_backup_metadata`-Funktion auf und überprüfen Sie die Werte in der `is_log_chain_broken`-Spalte. Ein Wert von „1" gibt an, dass die Protokollkette zwischen dem aktuellen Protokoll-Backup und dem vorherigen Protokoll-Backup unterbrochen wurde.
Das folgende Beispiel zeigt eine defekte Protokollkette in der Ausgabe der gespeicherten Prozedur `rds_fn_list_tlog_backup_metadata`.
![\[Ausgabe von rds_fn_list_tlog_backup_metadata mit Anzeige einer defekten Protokollkette.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_logchain_error.png)
In einer normalen Protokollette sollte der LSN-Wert (Log Sequence Number) für first\$1lsn für eine bestimmte rds\$1sequence\$1id mit dem Wert von last\$1lsn in der vorangegangenen rds\$1sequence\$1id übereinstimmen. In dem Bild hat die rds\$1sequence\$1id 45 einen first\$1lsn-Wert von 90987, was nicht mit dem last\$1lsn-Wert von 90985 für den vorangegangenen Wert von rds\$1sequence\$1id 44 übereinstimmt.
Weitere Informationen zur Transaktionsprotokollarchitektur und zu den Protokollsequenznummern von SQL Server finden Sie in der Dokumentation von Microsoft SQL Server unter [Transaction Log Logical Architecture](https://learn.microsoft.com/en-us/sql/relational-databases/sql-server-transaction-log-architecture-and-management-guide?view=sql-server-ver15#Logical_Arch).
# Amazon S3 Bucket – Ordner und Dateistruktur
Transaktionsprotokoll-Backups haben innerhalb eines Amazon-S3-Buckets die folgende Standardstruktur und Namenskonvention:
+ Unter dem `target_s3_arn`-Pfad wird für jede Datenbank ein neuer Ordner mit der Benennungsstruktur `{db_id}.{family_guid}` erstellt.
+ Innerhalb des Ordners haben Transaktionsprotokoll-Backups eine Dateinamenstruktur, die `{db_id}.{family_guid}.{rds_backup_seq_id}.{backup_file_epoch}` lautet.
+ Sie können die Details von `family_guid,db_id,rds_backup_seq_id and backup_file_epoch` mit der `rds_fn_list_tlog_backup_metadata`-Funktion einsehen.
Das folgende Beispiel veranschaulicht den Ordner und die Dateistruktur einer Reihe von Transaktionsprotokoll-Backups innerhalb eines Amazon-S3-Buckets.
![\[Struktur des Amazon-S3-Buckets mit Zugriff auf Transaktionsprotokolle\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_s3.png)
# Verfolgen des Status von Aufgaben
Um den Status Ihrer Kopieraufgaben zu verfolgen, rufen Sie die gespeicherte Prozedur `rds_task_status` auf. Wenn Sie keine Parameter angeben, gibt die gespeicherte Prozedur den Status aller Aufgaben zurück.
**Example Verwendung:**
```
exec msdb.dbo.rds_task_status
@db_name='database_name',
@task_id=ID_number;
```
Die folgenden Parameter sind optional:
+ `@db_name` – Name der Datenbank, für die der Aufgabenstatus angezeigt werden soll
+ `@task_id` – ID der Aufgabe, für die der Aufgabenstatus angezeigt werden soll
**Example Auflistung des Status für eine bestimmte Aufgaben-ID:**
```
exec msdb.dbo.rds_task_status @task_id=5;
```
**Example Auflistung des Status für eine bestimmte Datenbank und Aufgabe:**
```
exec msdb.dbo.rds_task_status@db_name='my_database',@task_id=5;
```
**Example Auflistung aller Aufgaben und ihrer Status für eine bestimmte Datenbank:**
```
exec msdb.dbo.rds_task_status @db_name='my_database';
```
**Example Auflistung aller Aufgaben und ihrer Status auf der aktuellen DB-Instance:**
```
exec msdb.dbo.rds_task_status;
```
# Abbrechen einer Aufgabe
Zum Abbrechen einer laufenden Aufgabe rufen Sie die gespeicherte Prozedur `rds_cancel_task` auf.
**Example Verwendung:**
```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```
Der folgende Parameter ist erforderlich:
+ `@task_id` – ID der abzubrechenden Aufgabe Sie können die ID der Aufgabe durch Aufrufen der gespeicherten Prozedur `rds_task_status` anzeigen.
Weitere Informationen zum Anzeigen und Abbrechen von laufenden Aufgaben finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
# Fehlerbehebung bei Problemen mit dem Zugriff auf Transaktionsprotokoll-Backups
Die folgenden Probleme können bei der Verwendung der gespeicherten Prozeduren für den Zugriff auf Transaktionsprotokoll-Backups auftreten.
****
| Gespeicherte Prozedur | Fehlermeldung | Problem | Vorschläge für die Fehlerbehebung |
| --- | --- | --- | --- |
| rds\$1tlog\$1copy\$1setup | Backups sind auf dieser DB-Instance deaktiviert. Aktivieren Sie DB-Instance-Backups mit einem Aufbewahrungswert von mindestens „1" und versuchen Sie es erneut. | Automatische Backups sind für die DB-Instance nicht aktiviert. | Die Aufbewahrung von DB-Instance-Backups muss mit einer Aufbewahrungsdauer von mindestens einem Tag aktiviert werden. Weitere Informationen zur Aktivierung von automatischen Backups und zur Konfiguration der Backup-Aufbewahrung finden Sie unter [Aufbewahrungszeitraum für Backups](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1copy\$1setup | Fehler beim Ausführen der gespeicherten Prozedur rds\$1tlog\$1copy\$1setup. Stellen Sie erneut eine Verbindung mit dem RDS-Endpunkt her und versuchen Sie es noch einmal. | Es ist ein interner Fehler aufgetreten. | Stellen Sie erneut eine Verbindung mit dem RDS-Endpunkt her und führen Sie die gespeicherte Prozedur `rds_tlog_copy_setup` noch einmal aus. |
| rds\$1tlog\$1copy\$1setup | Das Ausführen der gespeicherten Prozedur rds\$1tlog\$1backup\$1copy\$1setup innerhalb einer Transaktion wird nicht unterstützt. Stellen Sie sicher, dass in der Sitzung keine offenen Transaktionen vorhanden sind, und versuchen Sie es erneut. | Die gespeicherte Prozedur wurde innerhalb einer Transaktion mit `BEGIN` und `END` versucht. | Vermeiden Sie die Verwendung von `BEGIN` und `END` beim Ausführen der gespeicherten Prozedur `rds_tlog_copy_setup`. |
| rds\$1tlog\$1copy\$1setup | Der S3-Bucket-Name für den Eingabeparameter `@target_s3_arn` sollte mindestens ein anderes Zeichen als ein Leerzeichen enthalten. | Für den Eingabeparameter `@target_s3_arn` wurde ein falscher Wert angegeben. | Stellen Sie sicher, dass der Eingabeparameter `@target_s3_arn` den vollständigen ARN des Amazon-S3-Buckets angibt. |
| rds\$1tlog\$1copy\$1setup | Die `SQLSERVER_BACKUP_RESTORE`-Option ist nicht aktiviert oder wird gerade aktiviert. Aktivieren Sie die Option oder versuchen Sie es später noch einmal. | Die `SQLSERVER_BACKUP_RESTORE`-Option ist auf der DB-Instance nicht aktiviert oder wurde gerade aktiviert und wartet auf die interne Aktivierung. | Aktivieren Sie die `SQLSERVER_BACKUP_RESTORE`-Option, wie im Abschnitt „Anforderungen“ angegeben. Warten Sie einige Minuten und führen Sie die gespeicherte Prozedur `rds_tlog_copy_setup` erneut aus. |
| rds\$1tlog\$1copy\$1setup | Der Ziel-S3-ARN für den Eingabeparameter `@target_s3_arn` darf nicht leer oder null sein. | Für den Eingabeparameter `NULL` wurde ein `@target_s3_arn`-Wert angegeben oder der Wert wurde nicht angegeben. | Stellen Sie sicher, dass der Eingabeparameter `@target_s3_arn` den vollständigen ARN des Amazon-S3-Buckets angibt. |
| rds\$1tlog\$1copy\$1setup | Der Ziel-S3-ARN für den Eingabeparameter `@target_s3_arn` muss mit arn:aws beginnen. | Der Eingabeparameter `@target_s3_arn` wurde ohne `arn:aws` am Anfang angegeben. | Stellen Sie sicher, dass der Eingabeparameter `@target_s3_arn` den vollständigen ARN des Amazon-S3-Buckets angibt. |
| rds\$1tlog\$1copy\$1setup | Der Ziel-S3-ARN ist bereits auf den angegebenen Wert eingestellt. | Die gespeicherte Prozedur `rds_tlog_copy_setup` wurde zuvor ausgeführt und mit einem ARN des Amazon-S3-Buckets konfiguriert. | Wenn Sie den Wert des Amazon-S3-Buckets für den Zugriff auf Transaktionsprotokoll-Backups ändern möchten, geben Sie einen anderen `target S3 ARN` an. |
| rds\$1tlog\$1copy\$1setup | Es konnten keine Anmeldeinformationen für die Aktivierung des Zugriffs auf Transaktionsprotokoll-Backups generiert werden. Bestätigen Sie den bereitgestellten S3-Pfad-ARN `rds_tlog_copy_setup` und versuchen Sie es später erneut. | Beim Generieren der Anmeldeinformationen für den Zugriff auf Transaktionsprotokoll-Backups ist ein unbekannter Fehler aufgetreten. | Überprüfen Sie die Setup-Konfiguration und versuchen Sie es erneut. |
| rds\$1tlog\$1copy\$1setup | Sie können die gespeicherte Prozedur rds\$1tlog\$1copy\$1setup nicht ausführen, solange noch Aufgaben ausstehen. Warten Sie, bis die ausstehenden Aufgaben abgeschlossen sind, und versuchen Sie es erneut. | Es können immer nur zwei Aufgaben gleichzeitig ausgeführt werden. Es gibt ausstehende Aufgaben, die darauf warten, abgeschlossen zu werden. | Sehen Sie sich die ausstehenden Aufgaben an und warten Sie, bis diese abgeschlossen sind. Weitere Informationen zur Überwachung des Aufgabenstatus finden Sie unter [Verfolgen des Status von Aufgaben](USER.SQLServer.AddlFeat.TransactionLogAccess.TrackTaskStatus.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Eine Aufgabe zum Kopieren der T-Log-Backup-Datei wurde bereits für die Datenbank: %s mit der Aufgaben-ID: %d ausgegeben. Bitte versuchen Sie es später erneut. | Für eine bestimmte Datenbank kann jeweils nur eine Kopieraufgabe ausgeführt werden. Es gibt eine ausstehende Kopieraufgabe, die darauf wartet, abgeschlossen zu werden. | Sehen Sie sich die ausstehenden Aufgaben an und warten Sie, bis diese abgeschlossen sind. Weitere Informationen zur Überwachung des Aufgabenstatus finden Sie unter [Verfolgen des Status von Aufgaben](USER.SQLServer.AddlFeat.TransactionLogAccess.TrackTaskStatus.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Mindestens einer dieser drei Parametersätze muss angegeben werden. SET-1:(@backup\$1file\$1start\$1time, @backup\$1file\$1end\$1time) \$1 SET-2:(@starting\$1lsn, @ending\$1lsn) \$1 SET-3:(@rds\$1backup\$1starting\$1seq\$1id, @rds\$1backup\$1ending\$1seq\$1id) | Keiner der drei Parametersätze wurde bereitgestellt oder in einem bereitgestellten Parametersatz fehlt ein erforderlicher Parameter. | Sie können jeweils die Zeit-, LSN- oder Sequenz-ID-Parameter angeben. Ein Satz dieser drei Parametersätze ist erforderlich. Weitere Informationen zu erforderlichen Parametern finden Sie unter [Kopieren von Transaktionsprotokoll-Backups](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Backups sind auf Ihrer Instance deaktiviert. Bitte aktivieren Sie Backups und versuchen Sie es nach einer Weile erneut. | Automatische Backups sind für die DB-Instance nicht aktiviert. | Weitere Informationen zur Aktivierung von automatischen Backups und zur Konfiguration der Backup-Aufbewahrung finden Sie unter [Aufbewahrungszeitraum für Backups](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die angegebene Datenbank %s kann nicht gefunden werden. | Der für den Eingabeparameter `@db_name` angegebene Wert entspricht keinem Datenbanknamen auf der DB-Instance. | Verwenden Sie den richtigen Datenbanknamen. Führen Sie `SELECT * from sys.databases` aus, um alle Datenbanken nach Namen aufzulisten. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die gespeicherte Prozedur rds\$1tlog\$1backup\$1copy\$1to\$1S3 für SQL-Server-Systemdatenbanken oder die rdsadmin-Datenbank kann nicht ausgeführt werden. | Der für den Eingabeparameter `@db_name` angegebene Wert entspricht einem SQL-Server-Systemdatenbanknamen oder der RDSAdmin-Datenbank. | Die folgenden Datenbanken dürfen nicht für den Zugriff auf Transaktionsprotokoll-Backups verwendet werden: `master, model, msdb, tempdb, RDSAdmin.` |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Der Datenbankname für den Eingabeparameter @db\$1name darf nicht leer oder null sein. | Für den Eingabeparameter `@db_name` wurde ein leerer Wert oder `NULL` angegeben. | Verwenden Sie den richtigen Datenbanknamen. Führen Sie `SELECT * from sys.databases` aus, um alle Datenbanken nach Namen aufzulisten. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Der Aufbewahrungszeitraum für DB-Instance-Backups muss auf mindestens 1 festgelegt werden, um die gespeicherte Prozedur rds\$1tlog\$1backup\$1copy\$1setup auszuführen. | Automatische Backups sind für die DB-Instance nicht aktiviert. | Weitere Informationen zur Aktivierung von automatischen Backups und zur Konfiguration der Backup-Aufbewahrung finden Sie unter [Aufbewahrungszeitraum für Backups](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Fehler beim Ausführen der gespeicherten Prozedur rds\$1tlog\$1backup\$1copy\$1to\$1S3. Stellen Sie erneut eine Verbindung mit dem RDS-Endpunkt her und versuchen Sie es noch einmal. | Es ist ein interner Fehler aufgetreten. | Stellen Sie erneut eine Verbindung mit dem RDS-Endpunkt her und führen Sie die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` noch einmal aus. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Es kann nur einer dieser drei Parametersätze angegeben werden. SET-1:(@backup\$1file\$1start\$1time, @backup\$1file\$1end\$1time) \$1 SET-2:(@starting\$1lsn, @ending\$1lsn) \$1 SET-3:(@rds\$1backup\$1starting\$1seq\$1id, @rds\$1backup\$1ending\$1seq\$1id) | Es wurden mehrere Parametersätze angegeben. | Sie können jeweils die Zeit-, LSN- oder Sequenz-ID-Parameter angeben. Ein Satz dieser drei Parametersätze ist erforderlich. Weitere Informationen zu erforderlichen Parametern finden Sie unter [Kopieren von Transaktionsprotokoll-Backups](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Das Ausführen der gespeicherten Prozedur rds\$1tlog\$1backup\$1copy\$1to\$1S3 stored innerhalb einer Transaktion wird nicht unterstützt. Stellen Sie sicher, dass in der Sitzung keine offenen Transaktionen vorhanden sind, und versuchen Sie es erneut. | Die gespeicherte Prozedur wurde innerhalb einer Transaktion mit `BEGIN` und `END` versucht. | Vermeiden Sie die Verwendung von `BEGIN` und `END` beim Ausführen der gespeicherten Prozedur `rds_tlog_backup_copy_to_S3`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die angegebenen Parameter liegen außerhalb des Aufbewahrungszeitraums der Transaktionsprotokoll-Backups. Führen Sie die Funktion rds\$1fn\$1list\$1tlog\$1backup\$1metadata aus, um eine Liste der verfügbaren Transaktionsprotokoll-Backup-Dateien zu erhalten. | Für die angegebenen Eingabeparameter sind keine Transaktionsprotokoll-Backup verfügbar, die in das Aufbewahrungsfenster für Kopien passen. | Versuchen Sie es erneut mit einem gültigen Parametersatz. Weitere Informationen zu erforderlichen Parametern finden Sie unter [Kopieren von Transaktionsprotokoll-Backups](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Bei der Verarbeitung der Anfrage ist ein Berechtigungsfehler aufgetreten. Stellen Sie sicher, dass sich der Bucket in demselben Konto und derselben Region wie die DB-Instance befindet, und überprüfen Sie die S3-Bucket-Richtlinienberechtigungen anhand der Vorlage in der öffentlichen Dokumentation. | Es wurde ein Problem mit dem bereitgestellten S3-Bucket oder seinen Richtlinienberechtigungen festgestellt. | Vergewissern Sie sich, dass Ihre Einstellungen für den Zugriff auf Transaktionsprotokoll-Backups korrekt sind. Weitere Informationen zu den Einrichtungsanforderungen für Ihren S3-Bucket finden Sie unter [Voraussetzungen](USER.SQLServer.AddlFeat.TransactionLogAccess.md#USER.SQLServer.AddlFeat.TransactionLogAccess.Requirements). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Das Ausführen der gespeicherten Prozedur `rds_tlog_backup_copy_to_S3` auf einer RDS-Lesereplikat-Instance ist nicht zulässig. | Die gespeicherte Prozedur wurde auf einer RDS-Lesereplikat-Instance versucht. | Stellen Sie eine Verbindung mit der primären RDS-DB-Instance her, um die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` auszuführen. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die LSN für den Eingabeparameter `@starting_lsn` muss kleiner als `@ending_lsn` sein. | Der für den Eingabeparameter `@starting_lsn` angegebene Wert war größer als der Wert, der für den Eingabeparameter `@ending_lsn` angegeben wurde. | Stellen Sie sicher, dass der für den Eingabeparameter `@starting_lsn` angegebene Wert kleiner ist als der Wert, der für den Eingabeparameter `@ending_lsn` angegeben wurde. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` kann nur von den Mitgliedern der `db_owner`-Rolle in der Quelldatenbank ausgeführt werden. | Dem Konto, das versucht, die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` mit dem angegebenen `db_name` auszuführen, wurde die `db_owner`-Rolle nicht zugewiesen. | Stellen Sie sicher, dass das Konto, das die gespeicherte Prozedur ausführt, über die `db_owner`-Rolle mit dem angegebenen `db_name` verfügt. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die Sequenz-ID für den Eingabeparameter `@rds_backup_starting_seq_id` muss kleiner oder gleich `@rds_backup_ending_seq_id` sein. | Der für den Eingabeparameter `@rds_backup_starting_seq_id` angegebene Wert war größer als der Wert, der für den Eingabeparameter `@rds_backup_ending_seq_id` angegeben wurde. | Stellen Sie sicher, dass der für den Eingabeparameter `@rds_backup_starting_seq_id` angegebene Wert kleiner ist als der Wert, der für den Eingabeparameter `@rds_backup_ending_seq_id` angegeben wurde. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die SQLSERVER\$1BACKUP\$1RESTORE-Option ist nicht aktiviert oder wird gerade aktiviert. Aktivieren Sie die Option oder versuchen Sie es später noch einmal. | Die `SQLSERVER_BACKUP_RESTORE`-Option ist auf der DB-Instance nicht aktiviert oder wurde gerade aktiviert und wartet auf die interne Aktivierung. | Aktivieren Sie die `SQLSERVER_BACKUP_RESTORE`-Option, wie im Abschnitt „Anforderungen“ angegeben. Warten Sie einige Minuten und führen Sie die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` erneut aus. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Die Startzeit für den Eingabeparameter `@backup_file_start_time` muss kleiner als `@backup_file_end_time` sein. | Der für den Eingabeparameter `@backup_file_start_time` angegebene Wert war größer als der Wert, der für den Eingabeparameter `@backup_file_end_time` angegeben wurde. | Stellen Sie sicher, dass der für den Eingabeparameter `@backup_file_start_time` angegebene Wert kleiner ist als der Wert, der für den Eingabeparameter `@backup_file_end_time` angegeben wurde. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Wir konnten die Anfrage nicht bearbeiten, da wir keinen Zugriff hatten. Bitte überprüfen Sie Ihre Einstellungen und Berechtigungen für die Funktion. | Möglicherweise liegt ein Problem mit den Berechtigungen des Amazon-S3-Buckets vor oder der bereitgestellte Amazon-S3-Bucket befindet sich in einem anderen Konto oder einer anderen Region. | Stellen Sie sicher, dass die Richtlinienberechtigungen des Amazon-S3-Buckets den RDS-Zugriff ermöglichen. Vergewissern Sie sich, dass sich der Amazon-S3-Bucket im gleichen Konto und in derselben Region wie die DB-Instance befindet. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Sie können für Instances, die nicht speicherverschlüsselt sind, keinen KMS-Schlüssel-ARN als Eingabeparameter für die gespeicherte Prozedur angeben. | Wenn die Speicherverschlüsselung auf der DB-Instance nicht aktiviert ist, sollte der Eingabeparameter `@kms_key_arn` nicht angegeben werden. | Geben Sie keinen Eingabeparameter für `@kms_key_arn` an. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Sie müssen für speicherverschlüsselte Instances einen KMS-Schlüssel-ARN als Eingabeparameter für die gespeicherte Prozedur angeben. | Wenn die Speicherverschlüsselung auf der DB-Instance nicht aktiviert ist, muss der Eingabeparameter `@kms_key_arn` angegeben werden. | Geben Sie einen Eingabeparameter für `@kms_key_arn` mit einem Wert an, der dem ARN des Amazon-S3-Buckets entspricht, der für Transaktionsprotokoll-Backups verwendet werden soll. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Sie müssen die gespeicherte Prozedur `rds_tlog_copy_setup` ausführen und den `@target_s3_arn` festlegen, bevor Sie die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` ausführen. | Der Einrichtungsvorgang für den Zugriff auf Transaktionsprotokoll-Backups wurde nicht abgeschlossen, bevor versucht wurde, die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` auszuführen. | Führen Sie die gespeicherte Prozedur `rds_tlog_copy_setup` aus, bevor Sie die gespeicherte Prozedur `rds_tlog_backup_copy_to_S3` aufrufen. Weitere Informationen zur Ausführung des Einrichtungsvorgangs für den Zugriff auf Transaktionsprotokoll-Backups finden Sie unter [Einrichten des Zugriffs auf Transaktionsprotokoll-Backups](USER.SQLServer.AddlFeat.TransactionLogAccess.Enabling.md). |
# Optionen für die Microsoft SQL Server-Datenbank-Engine
In diesem Abschnitt finden Sie Beschreibungen für Optionen, die für Amazon-RDS-Instances verfügbar sind, welche die Microsoft SQL Server-DB-Engine ausführen. Damit diese Optionen aktiviert werden, fügen Sie diese einer Optionsgruppe hinzu und ordnen anschließend die Optionsgruppe Ihrer DB-Instance zu. Weitere Informationen finden Sie unter [Arbeiten mit Optionsgruppen](USER_WorkingWithOptionGroups.md).
Wenn Sie nach optionalen Funktionen suchen, die nicht über RDS-Optionsgruppen wie SSL, Microsoft Windows-Authentifizierung oder Amazon S3-Integration hinzugefügt wurden, finden Sie Informationen unter [Zusätzliche Funktionen für Microsoft SQL Server auf Amazon RDS](User.SQLServer.AdditionalFeatures.md).
Amazon RDS unterstützt die folgenden Optionen für Microsoft SQL Server-DB-Instances.
****
| Option | Options-ID | Engine-Editionen |
| --- | --- | --- |
| [Mit Oracle OLEDB verknüpfte Server](Appendix.SQLServer.Options.LinkedServers_Oracle_OLEDB.md) | `OLEDB_ORACLE` | SQL Server Enterprise Edition SQL Server Standard Edition |
| [Native Sicherung und Backup](Appendix.SQLServer.Options.BackupRestore.md) | `SQLSERVER_BACKUP_RESTORE` | SQL Server Enterprise Edition SQL Server Standard Edition SQL Server Web Edition SQL Server Express Edition |
| [Transparente Datenverschlüsselung in](Appendix.SQLServer.Options.TDE.md) | `TRANSPARENT_DATA_ENCRYPTION` (RDS-Konsole) `TDE`(AWS CLI und RDS-API) | SQL Server 2016—2022 Enterprise Edition SQL Server 2022 Standardausgabe |
| [SQL Server Audit](Appendix.SQLServer.Options.Audit.md) | `SQLSERVER_AUDIT` | In RDS unterstützen ab SQL Server 2016 alle Editionen von SQL Server Audits auf Serverebene, und Enterprise Edition unterstützt auch Audits auf Datenbankebene. Ab SQL Server SQL Server 2016 (13.x) SP1 unterstützen alle Editionen sowohl Audits auf Server- als auch auf Datenbankebene. Weitere Informationen finden Sie unter [SQL Server-Audit (Datenbank-Engine)](https://docs.microsoft.com/sql/relational-databases/security/auditing/sql-server-audit-database-engine?view=sql-server-2017) in der SQL Server-Dokumentation. |
| [SQL Server Analysis Services](Appendix.SQLServer.Options.SSAS.md) | `SSAS` | SQL Server Enterprise Edition SQL Server Standard Edition |
| [SQL Server Integration Services](Appendix.SQLServer.Options.SSIS.md) | `SSIS` | SQL Server Enterprise Edition SQL Server Standard Edition |
| [SQL Server Reporting Services](Appendix.SQLServer.Options.SSRS.md) | `SSRS` | SQL Server Enterprise Edition SQL Server Standard Edition |
| [Microsoft Distributed Transaction Coordinator](Appendix.SQLServer.Options.MSDTC.md) | `MSDTC` | In RDS unterstützen ab SQL Server 2016 alle Editionen von SQL Server verteilte Transaktionen. |
| [SQL Server-Ressourcenkontrolle](Appendix.SQLServer.Options.ResourceGovernor.md) | `RESOURCE_GOVERNOR` | SQL Server Enterprise Edition SQL Server 2022 Developer Edition |
## Auflisten der verfügbaren Optionen für Versionen und Editionen von SQL Server
Sie können den `describe-option-group-options` AWS CLI Befehl verwenden, um die verfügbaren Optionen für SQL Server-Versionen und -Editionen sowie die Einstellungen für diese Optionen aufzulisten.
Das folgende Beispiel zeigt die Optionen und Optionseinstellungen für SQL Server 2019 Enterprise Edition. Die Option `--engine-name` ist erforderlich.
```
aws rds describe-option-group-options --engine-name sqlserver-ee --major-engine-version 15.00
```
Die Ausgabe sieht in etwa folgendermaßen aus:
```
{
"OptionGroupOptions": [
{
"Name": "MSDTC",
"Description": "Microsoft Distributed Transaction Coordinator",
"EngineName": "sqlserver-ee",
"MajorEngineVersion": "15.00",
"MinimumRequiredMinorEngineVersion": "4043.16.v1",
"PortRequired": true,
"DefaultPort": 5000,
"OptionsDependedOn": [],
"OptionsConflictsWith": [],
"Persistent": false,
"Permanent": false,
"RequiresAutoMinorEngineVersionUpgrade": false,
"VpcOnly": false,
"OptionGroupOptionSettings": [
{
"SettingName": "ENABLE_SNA_LU",
"SettingDescription": "Enable support for SNA LU protocol",
"DefaultValue": "true",
"ApplyType": "DYNAMIC",
"AllowedValues": "true,false",
"IsModifiable": true,
"IsRequired": false,
"MinimumEngineVersionPerAllowedValue": []
},
...
{
"Name": "TDE",
"Description": "SQL Server - Transparent Data Encryption",
"EngineName": "sqlserver-ee",
"MajorEngineVersion": "15.00",
"MinimumRequiredMinorEngineVersion": "4043.16.v1",
"PortRequired": false,
"OptionsDependedOn": [],
"OptionsConflictsWith": [],
"Persistent": true,
"Permanent": false,
"RequiresAutoMinorEngineVersionUpgrade": false,
"VpcOnly": false,
"OptionGroupOptionSettings": []
}
]
}
```
# Support für mit Oracle OLEDB verknüpfte Server in Amazon RDS für SQL Server
Durch die Verknüpfung von Servern mit dem Oracle Provider für OLEDB auf RDS für SQL Server können Sie auf externe Datenquellen in einer Oracle-Datenbank zugreifen. Sie können Daten aus Remote-Oracle-Datenquellen lesen und Befehle auf Remote-Oracle-Datenbankservern außerhalb Ihrer DB-Instance von RDS für SQL Server ausführen. Mit Oracle OLEDB verknüpfte Server bieten folgende Möglichkeiten:
+ Direkter Zugriff auf andere Datenquellen als SQL Server
+ Abfragen verschiedener Oracle-Datenquellen mit derselben Abfrage, ohne die Daten zu verschieben
+ Ausgabe verteilter Abfragen, Aktualisierungen, Befehle und Transaktionen für Datenquellen in einem Unternehmens-Ökosystem
+ Integration von Verbindungen mit einer Oracle-Datenbank aus der Microsoft Business Intelligence Suite (SSIS, SSRS, SSAS)
+ Migration von einer Oracle-Datenbank zu RDS für SQL Server
Sie können einen oder mehrere verknüpfte Server für Oracle auf einer vorhandenen oder einer neuen DB-Instance von RDS für SQL Server aktivieren. Anschließend können Sie externe Oracle-Datenquellen in Ihre DB-Instance integrieren.
**Contents**
+ [
## Unterstützte Versionen und Regionen
](#LinkedServers_Oracle_OLEDB.VersionRegionSupport)
+ [
## Einschränkungen und Empfehlungen
](#LinkedServers_Oracle_OLEDB.Limitations)
+ [
## Aktivieren von verknüpften Servern mit Oracle
](#LinkedServers_Oracle_OLEDB.Enabling)
+ [
### Erstellen der Optionsgruppe für OLEDB\$1ORACLE
](#LinkedServers_Oracle_OLEDB.OptionGroup)
+ [
### Hinzufügen der `OLEDB_ORACLE`-Option zur Optionsgruppe
](#LinkedServers_Oracle_OLEDB.Add)
+ [
### Ändern der `OLEDB_ORACLE`-Versionsoption zu einer anderen Version
](#LinkedServers_Oracle_OLEDB.Modify)
+ [
### Zuordnen der Optionsgruppe zu Ihrer DB-Instance
](#LinkedServers_Oracle_OLEDB.Apply)
+ [
## Ändern der Eigenschaften des OLEDB-Providers
](#LinkedServers_Oracle_OLEDB.ModifyProviderProperties)
+ [
## Ändern der Eigenschaften des OLEDB-Treibers
](#LinkedServers_Oracle_OLEDB.ModifyDriverProperties)
+ [
## Deaktivieren von verknüpften Servern mit Oracle
](#LinkedServers_Oracle_OLEDB.Disable)
## Unterstützte Versionen und Regionen
RDS für SQL Server unterstützt mit Oracle OLEDB verknüpfte Server in den folgenden Versionen für SQL Server Standard und Enterprise Edition in allen Regionen:
+ SQL Server 2022, alle Versionen
+ SQL Server 2019, alle Versionen
+ SQL Server 2017, alle Versionen
Mit Oracle OLEDB verknüpfte Server werden für die folgenden Oracle-Database-Versionen unterstützt:
+ Oracle Database 21c, alle Versionen
+ Oracle Database 19c, alle Versionen
+ Oracle Database 18c, alle Versionen
Mit Oracle OLEDB verknüpfte Server werden für die folgenden OLEDB-Oracle-Treiberversionen unterstützt:
+ 21.7
+ 21,16
## Einschränkungen und Empfehlungen
Beachten Sie die folgenden Einschränkungen und Empfehlungen, die für mit Oracle OLEDB verknüpfte Server gelten:
+ Erlauben Sie Netzwerkverkehr, indem Sie der Sicherheitsgruppe für jede DB-Instance von RDS für SQL Server den entsprechenden TCP-Port hinzufügen. Wenn Sie beispielsweise einen verknüpften Server zwischen einer EC2-Oracle-DB-Instance und einer DB-Instance von RDS für SQL Server konfigurieren, müssen Sie Datenverkehr von der IP-Adresse der EC2-Oracle-DB-Instance zulassen. Außerdem müssen Sie den Datenverkehr auf dem Port zulassen, den SQL Server zum Überwachen der Datenbankkommunikation verwendet. Weitere Informationen zu Sicherheitsgruppen finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
+ Führen Sie einen Neustart der DB-Instance von RDS für SQL Server durch, nachdem Sie die `OLEDB_ORACLE`-Option in Ihrer Optionsgruppe aktiviert, deaktiviert oder geändert haben. Der Optionsgruppenstatus zeigt `pending_reboot` für diese Ereignisse an und ist erforderlich. Bei Multi-AZ-Instances von RDS for SQL Server mit aktivierter Spiegelungsoption wird ein Failover erwartet, wenn die Instanz nach der Erstellung AlwaysOn oder Wiederherstellung der neuen Instanz neu gestartet wird.
+ Es wird nur die einfache Authentifizierung mit einem Benutzernamen und einem Passwort für die Oracle-Datenquelle unterstützt.
+ Open Database Connectivity (ODBC)-Treiber werden nicht unterstützt. Nur die oben aufgeführten OLEDB-Treiberversionen werden unterstützt.
+ Verteilte Transaktionen (XA) werden unterstützt. Zur Aktivierung verteilter Transaktionen aktivieren Sie die `MSDTC`-Option in der Optionsgruppe für Ihre DB-Instance und stellen Sie sicher, dass XA-Transaktionen aktiviert sind. Weitere Informationen finden Sie unter [Unterstützung für Microsoft Distributed Transaction Coordinator in RDS für SQL Server](Appendix.SQLServer.Options.MSDTC.md).
+ Das Erstellen von Datenquellennamen (DSNs), die als Abkürzung für eine Verbindungszeichenfolge verwendet werden sollen, wird nicht unterstützt.
+ Die OLEDB-Treiberverfolgung wird nicht unterstützt. Sie können erweiterte SQL-Server-Ereignisse verwenden, um OLEDB-Ereignisse zu verfolgen. Weitere Informationen finden Sie unter [Set up Extended Events in RDS für SQL Server](https://aws.amazon.com/blogs/database/set-up-extended-events-in-amazon-rds-for-sql-server/).
+ Der Zugriff auf den Ordner „Catalogs“ (Kataloge) für einen verknüpften Oracle-Server wird mit SQL Server Management Studio (SSMS) nicht unterstützt.
## Aktivieren von verknüpften Servern mit Oracle
Aktivieren Sie mit Oracle verknüpfte Server, indem Sie die `OLEDB_ORACLE`-Option Ihrer DB-Instance von RDS für SQL Server hinzufügen. Verwenden Sie den folgenden Prozess:
1. Erstellen Sie eine neue Optionsgruppe oder wählen Sie eine bestehende Optionsgruppe aus.
1. Fügen Sie die Option `OLEDB_ORACLE` zur Optionsgruppe hinzu.
1. Wählen Sie eine Version des zu verwendenden OLEDB-Treibers aus.
1. Ordnen Sie die Optionsgruppe der DB-Instance zu.
1. Wir starten die DB-Instance neu.
### Erstellen der Optionsgruppe für OLEDB\$1ORACLE
Um mit verknüpften Servern mit Oracle zu arbeiten, erstellen Sie eine Optionsgruppe oder ändern Sie eine Optionsgruppe, die der SQL Server-Edition und der Version der DB-Instance entspricht, die Sie verwenden möchten. Verwenden Sie das AWS-Managementkonsole oder das, um dieses Verfahren abzuschließen AWS CLI.
#### Konsole
Mit der folgenden Prozedur wird eine Optionsgruppe für SQL Server Standard Edition 2019 erstellt.
**So erstellen Sie die Optionsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group** (Gruppe erstellen) aus.
1. Führen Sie im Fenster **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie unter **Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihres AWS Kontos eindeutig ist, z. **oracle-oledb-se-2019** B. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein, z. B. **OLEDB\$1ORACLE option group for SQL Server SE 2019**. Die Beschreibung ist nur zur Information.
1. Wählen Sie für **Engine** die Option **sqlserver-se** aus.
1. Wählen Sie im Feld **Major Engine Version** (Engine-Hauptversion) **15.00** aus.
1. Wählen Sie **Erstellen** aus.
#### CLI
Mit der folgenden Prozedur wird eine Optionsgruppe für SQL Server Standard Edition 2019 erstellt.
**So erstellen Sie die Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name oracle-oledb-se-2019 \
--engine-name sqlserver-se \
--major-engine-version 15.00 \
--option-group-description "OLEDB_ORACLE option group for SQL Server SE 2019"
```
Für Windows:
```
aws rds create-option-group ^
--option-group-name oracle-oledb-se-2019 ^
--engine-name sqlserver-se ^
--major-engine-version 15.00 ^
--option-group-description "OLEDB_ORACLE option group for SQL Server SE 2019"
```
### Hinzufügen der `OLEDB_ORACLE`-Option zur Optionsgruppe
Verwenden Sie als Nächstes das AWS-Managementkonsole oder, AWS CLI um die `OLEDB_ORACLE` Option zu Ihrer Optionsgruppe hinzuzufügen.
#### Konsole
**So fügen Sie die Option OLEDB\$1ORACLE hinzu**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe, die Sie gerade erstellt haben, in diesem Beispiel **oracle-oledb-se-2019**.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. Wählen Sie unter **Option details** (Optionsdetails) für **Option name** (Optionsname) die Option **OLEDB\$1ORACLE** aus.
1. Wählen Sie unter **Version** die Version des OLEDB-Oracle-Treibers aus, den Sie installieren möchten.
1. Wählen Sie unter **Planung** aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
#### CLI
**So fügen Sie die Option OLEDB\$1ORACLE hinzu**
+ Fügen Sie die Option `OLEDB_ORACLE` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--option-group-name oracle-oledb-se-2019 \
--options OptionName=OLEDB_ORACLE, OptionVersion=21.16 \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name oracle-oledb-se-2019 ^
--options OptionName=OLEDB_ORACLE, OptionVersion=21.16 ^
--apply-immediately
```
### Ändern der `OLEDB_ORACLE`-Versionsoption zu einer anderen Version
Um die `OLEDB_ORACLE` Optionsversion in eine andere Version zu ändern, verwenden Sie das AWS-Managementkonsole oder das AWS CLI.
#### Konsole
**So ändern Sie die Option OLEDB\$1ORACLE**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der `OLEDB_ORACLE` Option (**oracle-oledb-se-2019** im vorherigen Beispiel).
1. Wählen Sie **Modify option** (Option ändern) aus.
1. Wählen Sie unter **Option details** (Optionsdetails) für **Option name** (Optionsname) die Option **OLEDB\$1ORACLE** aus.
1. Wählen Sie für **Version** die OLEDB-Oracle-Treiberversion aus, die Sie verwenden möchten.
1. Wählen Sie unter **Planung** aus, ob die Option sofort oder während des nächsten Wartungsfensters geändert werden soll.
1. Wählen Sie **Modify option** (Option ändern) aus.
#### CLI
Um die `OLEDB_ORACLE`-Optionsversion zu ändern, verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/add-option-to-option-group.html](https://docs.aws.amazon.com/cli/latest/reference/rds/add-option-to-option-group.html)AWS CLI mit der Optionsgruppe und Optionsversion, die Sie verwenden möchten.
**So ändern Sie die Option OLEDB\$1ORACLE**
+
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--option-group-name oracle-oledb-se-2019 \
--options OptionName=OLEDB_ORACLE, OptionVersion=21.7 \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name oracle-oledb-se-2019 ^
--options OptionName=OLEDB_ORACLE, OptionVersion=21.7 ^
--apply-immediately
```
### Zuordnen der Optionsgruppe zu Ihrer DB-Instance
Um die `OLEDB_ORACLE` Optionsgruppe und die Parametergruppe mit Ihrer DB-Instance zu verknüpfen, verwenden Sie das AWS-Managementkonsole oder AWS CLI
#### Konsole
Um die Aktivierung von verknüpften Servern für Oracle abzuschließen, ordnen Sie Ihre `OLEDB_ORACLE`-Optionsgruppe einer neuen oder vorhandenen DB-Instance zu:
+ Ordnen Sie sie bei einer neuen DB-Instance zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ordnen Sie sie für eine vorhandene DB-Instance zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
#### CLI
Sie können die `OLEDB_ORACLE`-Optionsgruppe und die Parametergruppe einer neuen oder vorhandenen DB-Instance zuordnen.
**So erstellen Sie eine Instance mit der `OLEDB_ORACLE`-Optionsgruppe und der Parametergruppe**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier mytestsqlserveroracleoledbinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 15.0.4236.7.v1 \
--allocated-storage 100 \
--manage-master-user-password \
--master-username admin \
--storage-type gp2 \
--license-model li \
--domain-iam-role-name my-directory-iam-role \
--domain my-domain-id \
--option-group-name oracle-oledb-se-2019 \
--db-parameter-group-name my-parameter-group-name
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mytestsqlserveroracleoledbinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 15.0.4236.7.v1 ^
--allocated-storage 100 ^
--manage-master-user-password ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--domain-iam-role-name my-directory-iam-role ^
--domain my-domain-id ^
--option-group-name oracle-oledb-se-2019 ^
--db-parameter-group-name my-parameter-group-name
```
**So ändern Sie eine Instance, um die `OLEDB_ORACLE`-Optionsgruppe zuzuordnen**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mytestsqlserveroracleoledbinstance \
--option-group-name oracle-oledb-se-2019 \
--db-parameter-group-name my-parameter-group-name \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mytestsqlserveroracleoledbinstance ^
--option-group-name oracle-oledb-se-2019 ^
--db-parameter-group-name my-parameter-group-name ^
--apply-immediately
```
## Ändern der Eigenschaften des OLEDB-Providers
Sie können die Eigenschaften des OLEDB-Providers anzeigen und ändern. Nur der `master`-Benutzer kann diese Aufgabe ausführen. Alle verknüpften Server für Oracle, die auf der DB-Instance erstellt wurden, verwenden dieselben Eigenschaften dieses OLEDB-Providers. Rufen Sie die gespeicherte `sp_MSset_oledb_prop`-Prozedur auf, um die Eigenschaften des OLEDB-Providers zu ändern.
So ändern Sie die Eigenschaften des OLEDB-Providers
```
USE [master]
GO
EXEC sp_MSset_oledb_prop N'OraOLEDB.Oracle', N'AllowInProcess', 1
EXEC sp_MSset_oledb_prop N'OraOLEDB.Oracle', N'DynamicParameters', 0
GO
```
Die folgenden Eigenschaften können geändert werden:
****
| Name der Eigenschaft | Empfohlener Wert (1 = Ein, 0 = Aus) | Description |
| --- | --- | --- |
| `Dynamic parameter` | 1 | Erlaubt SQL-Platzhalter (dargestellt durch '?') in parametrisierten Abfragen. |
| `Nested queries` | 1 | Erlaubt verschachtelte `SELECT`-Anweisungen in der `FROM`-Klausel, z. B. Unterabfragen. |
| `Level zero only` | 0 | Nur OLEDB-Schnittstellen auf Basisebene werden für den Provider aufgerufen. |
| `Allow inprocess` | 1 | Wenn diese Option aktiviert ist, ermöglicht Microsoft SQL Server, dass der Provider als prozessinterner Server instanziiert wird. Legen Sie diese Eigenschaft auf 1 fest, um verknüpfte Oracle-Server zu verwenden. |
| `Non transacted updates` | 0 | Wenn ein Wert ungleich Null ist, erlaubt SQL Server Aktualisierungen. |
| `Index as access path` | Falsch | Wenn ein Wert ungleich Null ist, versucht SQL Server, Indizes des Providers zum Abrufen von Daten zu verwenden. |
| `Disallow adhoc access` | Falsch | Wenn diese Option festgelegt ist, erlaubt SQL Server keine Ausführung von Passthrough-Abfragen für den OLEDB-Provider. Diese Option kann zwar aktiviert werden, es ist jedoch manchmal angebracht, Passthrough-Abfragen auszuführen. |
| `Supports LIKE operator` | 1 | Zeigt an, dass der Provider Abfragen mit dem Schlüsselwort LIKE unterstützt. |
## Ändern der Eigenschaften des OLEDB-Treibers
Sie können die Eigenschaften des OLEDB-Treibers anzeigen und ändern, wenn Sie einen verknüpften Server für Oracle erstellen. Nur der `master`-Benutzer kann diese Aufgabe ausführen. Treibereigenschaften definieren, wie der OLEDB-Treiber Daten verarbeitet, wenn er mit einer Remote-Oracle-Datenquelle arbeitet. Die Treibereigenschaften sind für jeden verknüpften Oracle-Server spezifisch, der auf der DB-Instance erstellt wurde. Rufen Sie die gespeicherte `master.dbo.sp_addlinkedserver`-Prozedur auf, um die Eigenschaften des OLEDB-Treibers zu ändern.
Beispiel: So erstellen Sie einen verknüpften Server und kändern die `FetchSize`-Eigenschaft des OLEDB-Treibers
```
EXEC master.dbo.sp_addlinkedserver
@server = N'Oracle_link2',
@srvproduct=N'Oracle',
@provider=N'OraOLEDB.Oracle',
@datasrc=N'my-oracle-test.cnetsipka.us-west-2.rds.amazonaws.com:1521/ORCL',
@provstr='FetchSize=200'
GO
```
```
EXEC master.dbo.sp_addlinkedsrvlogin
@rmtsrvname=N'Oracle_link2',
@useself=N'False',
@locallogin=NULL,
@rmtuser=N'master',
@rmtpassword='Test#1234'
GO
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
## Deaktivieren von verknüpften Servern mit Oracle
Wenn Sie mit Oracle verknüpfte Server deaktivieren möchten, entfernen Sie die `OLEDB_ORACLE`-Option aus der Optionsgruppe.
**Wichtig**
Wenn Sie die Option entfernen, werden die vorhandenen verknüpften Serverkonfigurationen auf der DB-Instance nicht gelöscht. Sie müssen sie manuell löschen, um sie aus der DB-Instance zu entfernen.
Sie können die `OLEDB_ORACLE`-Option nach dem Entfernen erneut aktivieren, um die zuvor auf der DB-Instance konfigurierten verknüpften Serverkonfigurationen wiederzuverwenden.
### Konsole
Mit dem folgenden Verfahren wird die Option `OLEDB_ORACLE` entfernt.
**So entfernen Sie die OLEDB\$1ORACLE-Option aus der Optionsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `OLEDB_ORACLE` (`oracle-oledb-se-2019` in den vorherigen Beispielen).
1. Wählen Sie **Delete option (Option löschen)** aus.
1. Wählen Sie unter **Deletion options** (Löschoptionen) für **Options to delete** (Zu löschende Optionen) die Option **OLEDB\$1ORACLE** aus.
1. Wählen Sie unter **Apply immediately** (Sofort anwenden) die Option **Yes** (Ja) aus, um die Option sofort zu löschen, oder **No** (Nein), um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Löschen** aus.
### CLI
Mit dem folgenden Verfahren wird die Option `OLEDB_ORACLE` entfernt.
**So entfernen Sie die OLEDB\$1ORACLE-Option aus der Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name oracle-oledb-se-2019 \
--options OLEDB_ORACLE \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name oracle-oledb-se-2019 ^
--options OLEDB_ORACLE ^
--apply-immediately
```
# Verknüpfte Server mit Teradata ODBC in RDS für SQL Server
Durch die Unterstützung für verknüpfte Server mit dem Teradata-ODBC-Treiber auf RDS für SQL Server können Sie auf externe Datenquellen in einer Teradata-Datenbank zugreifen. Sie können Daten aus Remote-Teradata-Datenbankservern lesen und darauf Befehle außerhalb Ihrer DB-Instance von RDS für SQL Server ausführen. Verwenden Sie verknüpfte Server mit Teradata ODBC, um die folgenden Funktionen zu aktivieren:
+ Direkter Zugriff auf andere Datenquellen als SQL Server
+ Abfragen verschiedener Teradata-Datenquellen mit derselben Abfrage, ohne die Daten zu verschieben
+ Ausgabe verteilter Abfragen, Aktualisierungen, Befehle und Transaktionen für Datenquellen in einem Unternehmens-Ökosystem
+ Integration von Verbindungen mit einer Teradata-Datenbank aus der Microsoft Business Intelligence Suite (SSIS, SSRS, SSAS)
+ Migration von einer Teradata-Datenbank zu RDS für SQL Server
Sie können einen oder mehrere verknüpfte Server für Teradata auf einer vorhandenen oder einer neuen DB-Instance von RDS für SQL Server aktivieren. Anschließend können Sie externe Teradata-Datenquellen in Ihre DB-Instance integrieren.
**Topics**
+ [
## Unterstützte Versionen und Regionen
](#USER_SQLServerTeradata.VersionRegionSupport)
+ [
## Einschränkungen und Empfehlungen
](#USER_SQLServerTeradata.LimitsandRecommendations)
+ [
## Überlegungen zur Multi-AZ-Bereitstellung
](#USER_SQLServerTeradata.MultiAZ)
+ [
# Aktivieren von verknüpften Servern mit Teradata
](USER_SQLServerTeradata.Activate.md)
+ [
# Erstellen von verknüpften Servern mit Teradata
](USER_SQLServerTeradata.CreateLinkedServers.md)
+ [
# Deaktivieren von mit Teradata verknüpften Servern
](USER_SQLServerTeradata.Deactivate.md)
## Unterstützte Versionen und Regionen
RDS für SQL Server unterstützt verknüpfte Server mit Teradata ODBC in den folgenden Versionen für SQL Server Standard und Enterprise Edition in allen AWS-Regionen:
+ SQL Server 2022, alle Versionen
+ SQL Server 2019, alle Versionen
+ SQL Server 2017, alle Versionen
Die folgenden Teradata-Datenbankversionen unterstützen die Verknüpfung mit RDS für SQL Server
+ Teradata 17.20, alle Versionen
## Einschränkungen und Empfehlungen
Die folgenden Einschränkungen gelten für die Verknüpfung von Servern mit Teradata ODBC:
+ RDS für SQL Server unterstützt nur die einfache Authentifizierung mit einem Benutzernamen und einem Passwort für die Teradata-Quelle.
+ RDS für SQL Server unterstützt nur die Teradata-ODBC-Treiberversion 17.20.0.33.
+ RDS für SQL Server unterstützt keine Erstellung von Datenquellennamen (DSNs) zur Verwendung als Abkürzung für eine Verbindungszeichenfolge.
+ RDS für SQL Server unterstützt keine ODBC-Treiberverfolgung. Sie können erweiterte SQL-Server-Ereignisse verwenden, um ODBC-Ereignisse zu verfolgen. Weitere Informationen finden Sie unter [Set up Extended Events in RDS für SQL Server](https://aws.amazon.com/blogs/database/set-up-extended-events-in-amazon-rds-for-sql-server/).
+ RDS für SQL Server unterstützt keinen Zugriff auf den Katalogordner für einen verknüpften Teradata-Server mit SQL Server Management Studio (SSMS).
Beachten Sie bei der Verwendung von verknüpften Servern mit Teradata ODBC die folgenden Empfehlungen:
+ Erlauben Sie Netzwerkverkehr, indem Sie der Sicherheitsgruppe für jede DB-Instance von RDS für SQL Server den entsprechenden TCP-Port hinzufügen. Wenn Sie einen verknüpften Server zwischen einer Teradata-DB-Instance von EC2 und einer DB-Instance von RDS für SQL Server konfigurieren, müssen Sie Datenverkehr von der IP-Adresse der Teradata-DB-Instance von EC2 zulassen. Außerdem müssen Sie den Datenverkehr auf dem Port zulassen, den die DB-Instance von RDS für SQL Server zum Überwachen der Datenbankkommunikation verwendet. Weitere Informationen zu Sicherheitsgruppen finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
+ Verteilte Transaktionen (XA) werden unterstützt. Zur Aktivierung verteilter Transaktionen aktivieren Sie die `MSDTC`-Option in der Optionsgruppe für Ihre DB-Instance und stellen sicher, dass XA-Transaktionen aktiviert sind. Weitere Informationen finden Sie unter [Unterstützung für Microsoft Distributed Transaction Coordinator in RDS für SQL Server](Appendix.SQLServer.Options.MSDTC.md).
+ Die verknüpfte Teradata ODBC unterstützt SSL/TLS, solange dies auf dem Teradata-Server konfiguriert ist. Weitere Informationen finden Sie unter [Enable TLS Connectivity on Teradata Vantage](https://docs.teradata.com/r/Enterprise_IntelliFlex_Lake_VMware/Teradata-Call-Level-Interface-Version-2-Reference-for-Workstation-Attached-Systems-20.00/Mainframe-TLS-Connectivity-Supplement/Enable-TLS-Connectivity-on-Teradata-Vantage).
## Überlegungen zur Multi-AZ-Bereitstellung
RDS für SQL Server repliziert derzeit keine verknüpften Server auf den gespiegelten Datenbankserver (oder den sekundären Server der Always-On-Verfügbarkeitsgruppe) in einer Multi-AZ-Bereitstellung. Wenn die verknüpften Server hinzugefügt werden, bevor die Konfiguration geändert wird, um Spiegelung oder Always-On hinzuzufügen, werden die verknüpften Server für die vorhandenen verknüpften Server kopiert.
Alternativ können Sie die verknüpften Server auf der primären Instance erstellen, ein Failover auf die Hochverfügbarkeits-Server-Instance durchführen und dann die verknüpften Server erneut erstellen, sodass sie sich auf beiden Instances von RDS für SQL Server befinden.
# Aktivieren von verknüpften Servern mit Teradata
Aktivieren Sie verknüpfte Server mit Teradata, indem Sie die `ODBC_TERADATA`-Option Ihrer DB-Instance von RDS für SQL Server hinzufügen. Verwenden Sie den folgenden Prozess:
**Topics**
+ [
## Erstellen der Optionsgruppe für `ODBC_TERADATA`
](#USER_SQLServerTeradata.Activate.CreateOG)
+ [
## Hinzufügen der `ODBC_TERADATA`-Option zur Optionsgruppe
](#USER_SQLServerTeradata.Activate.AddOG)
+ [
## Zuordnen der Option `ODBC_TERADATA` zu Ihrer DB-Instance
](#USER_SQLServerTeradata.Activate.AssociateOG)
## Erstellen der Optionsgruppe für `ODBC_TERADATA`
Um mit verknüpften Servern mit Teradata zu arbeiten, erstellen Sie eine Optionsgruppe oder ändern Sie eine Optionsgruppe, die der SQL-Server-Edition und der Version der DB-Instance entspricht, die Sie verwenden möchten. Verwenden Sie die AWS-Managementkonsole oder die AWS CLI, um diesen Prozess abzuschließen.
### Konsole
Mit der folgenden Prozedur wird eine Optionsgruppe für SQL Server Standard Edition 2019 erstellt.
**So erstellen Sie die Optionsgruppe**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group (Gruppe erstellen)** aus.
1. Führen Sie im Fenster **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie unter **Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihres AWS-Konto nur einmal vorkommt, z. B. `teradata-odbc-se-2019`. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein.
1. Wählen Sie für **Engine** die Option **sqlserver-se** aus.
1. Wählen Sie im Feld **Major Engine Version** (Engine-Hauptversion) **15.00** aus.
1. Wählen Sie **Erstellen** aus.
### AWS CLI
Mit der folgenden Prozedur wird eine Optionsgruppe für SQL Server Standard Edition 2019 erstellt.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name teradata-odbc-se-2019 \
--engine-name sqlserver-se \
--major-engine-version 15.00 \
--option-group-description "ODBC_TERADATA option group for SQL Server SE 2019"
```
**Example**
Für Windows:
```
aws rds create-option-group ^
--option-group-name teradata-odbc-se-2019 ^
--engine-name sqlserver-se ^
--major-engine-version 15.00 ^
--option-group-description "ODBC_TERADATA option group for SQL Server SE 2019"
```
## Hinzufügen der `ODBC_TERADATA`-Option zur Optionsgruppe
Verwenden Sie als Nächstes die AWS-Managementkonsole oder AWS CLI, um die Option `ODBC_Teradata` zu Ihrer Optionsgruppe hinzuzufügen.
### Konsole
Mit der folgenden Prozedur wird eine Optionsgruppe für SQL Server Standard Edition 2019 erstellt.
**So fügen Sie die Option `ODBC_TERADATA` hinzu**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie Ihre neue Optionsgruppe aus.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. Unter **Optionsdetails**:
1. Wählen Sie **ODBC\$1TERADATA** als **Optionsname**.
1. Für `17.20.33.00` für die **Optionsversion**.
1. Wählen Sie unter „Planung“ aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
### AWS CLI
Mit dem folgenden Verfahren wird die Option `ODBC_TERADATA` zu Ihrer Optionsgruppe hinzugefügt.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--option-group-name teradata-odbc-se-2019 \
--options "OptionName=ODBC_TERADATA,OptionVersion=17.20.33.00" \
--apply-immediately
```
**Example**
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name teradata-odbc-se-2019 ^
--options "OptionName=ODBC_TERADATA,OptionVersion=17.20.33.00" ^
--apply-immediately
```
## Zuordnen der Option `ODBC_TERADATA` zu Ihrer DB-Instance
Verwenden Sie die AWS-Managementkonsole oder AWS CLI, um die Optionsgruppe `ODBC_TERADATA` Ihrer DB-Instance zuzuordnen.
### Konsole
Um die Aktivierung von verknüpften Servern für Teradata abzuschließen, ordnen Sie Ihre Optionsgruppe einer neuen oder vorhandenen DB-Instance zu:
+ Bei einer neuen DB-Instance ordnen Sie diese zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Bei einer vorhandenen DB-Instance ordnen Sie diese zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### AWS CLI
Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier mytestsqlserverteradataodbcinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 15.00 \
--license-model license-included \
--allocated-storage 100 \
--master-username admin \
--master-user-password password \
--storage-type gp2 \
--option-group-name teradata-odbc-se-2019
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mytestsqlserverteradataodbcinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 15.00 ^
--license-model license-included ^
--allocated-storage 100 ^
--master-username admin ^
--master-user-password password ^
--storage-type gp2 ^
--option-group-name teradata-odbc-se-2019
```
So ändern Sie eine Instance und ordnen die neue Optionsgruppe zu:
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mytestsqlserverteradataodbcinstance \
--option-group-name teradata-odbc-se-2019 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mytestsqlserverteradataodbcinstance ^
--option-group-name teradata-odbc-se-2019 ^
--apply-immediately
```
# Erstellen von verknüpften Servern mit Teradata
Führen Sie die folgenden Befehle aus, um einen verknüpften Server mit Teradata zu erstellen:
```
EXECUTE master.dbo.sp_addlinkedserver
@server = N'LinkedServer_NAME',
@srvproduct=N'',
@provider=N'MSDASQL',
@provstr=N'"PROVIDER=MSDASQL;DRIVER={Teradata Database ODBC Driver 17.20};
DBCName=Server;UID=user_name;PWD=user_password;
UseDataEncryption=YES/NO;SSLMODE=PREFER/ALLOW/DISABLE>;"',
@catalog='database'
```
```
EXECUTE master.dbo.sp_addlinkedsrvlogin
@rmtsrvname = N'LinkedServer_NAME',
@locallogin = NULL ,
@useself = N'False',
@rmtuser = N'user_name',
@rmtpassword = N'user_password'
```
Ein Beispiel für die oben genannten Befehle finden Sie hier:
```
EXECUTE master.dbo.sp_addlinkedserver
@server = N'LinkedServerToTeradata',
@srvproduct=N'',
@provider=N'MSDASQL',
@provstr=N'"PROVIDER=MSDASQL;DRIVER={Teradata Database ODBC Driver 17.20};
DBCName=my-teradata-test.cnetsipka.us-west-2.rds.amazonaws.com;
UID=master;
PWD=Test#1234;
UseDataEncryption=YES;
SSLMODE=PREFER;"',
@catalog='MyTestTeradataDB'
EXECUTE master.dbo.sp_addlinkedsrvlogin
@rmtsrvname = N'LinkedServerToTeradata',
@locallogin = NULL ,
@useself = N'False',
@rmtuser = N'master',
@rmtpassword = N'Test#1234'
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
# Deaktivieren von mit Teradata verknüpften Servern
Wenn Sie mit Teradata verknüpfte Server deaktivieren möchten, entfernen Sie die `ODBC_TERADATA`-Option aus der Optionsgruppe.
**Wichtig**
Wenn Sie die Option löschen, werden die vorhandenen verknüpften Serverkonfigurationen auf der DB-Instance nicht gelöscht. Sie müssen sie manuell löschen, um sie aus der DB-Instance zu entfernen.
Sie können die `ODBC_TERADATA`-Option nach dem Entfernen erneut aktivieren, um die zuvor auf der DB-Instance konfigurierten verknüpften Serverkonfigurationen wiederzuverwenden.
## Konsole
So entfernen Sie die `ODBC_TERADATA`-Option aus der Optionsgruppe
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der `ODBC_TERADATA`-Option.
1. Wählen Sie **Delete (Löschen)**.
1. Wählen Sie unter **Löschoptionen** für **Optionen zum Löschen** die Option `ODBC_TERADATA` aus.
1. Wählen Sie unter **Apply immediately** (Sofort anwenden) die Option **Yes** (Ja) aus, um die Option sofort zu löschen, oder **No** (Nein), um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Delete (Löschen)**.
## AWS CLI
Mit dem folgenden Befehl wird die Option `ODBC_TERADATA` entfernt.
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name teradata-odbc-se-2019 \
--options ODBC_TERADATA \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name teradata-odbc-se-2019 ^
--options ODBC_TERADATA ^
--apply-immediately
```
# Unterstützung für native Sicherung und Backup in SQL Server
Durch die Verwendung der nativen Sicherungen und Wiederherstellungen für SQL Server-Datenbanken können Sie eine differenzielle oder vollständige Sicherung Ihrer lokalen Datenbank erstellen und die Sicherungsdateien auf Amazon S3 speichern. Sie können die Wiederherstellung dann auf einer vorhandenen Amazon-RDS-DB-Instance durchführen, auf der SQL Server ausgeführt wird. Des Weiteren können Sie eine RDS für SQL Server-Datenbank sichern, in Amazon S3 speichern und an anderen Speicherorten wiederherstellen. Darüber hinaus können Sie die Sicherung auf einem lokalen Server oder einer anderen Amazon RDS DB-Instance mit SQL Server wiederherstellen. Weitere Informationen finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
Amazon RDS unterstützt die native Sicherung und Backup von Microsoft SQL Server-Datenbanken mithilfe von Dateien für differenzielle und vollständige Sicherungen (BAK-Dateien).
## Hinzufügen der Option „Native Sicherung und Backup“
Der allgemeine Prozess zum Hinzufügen der nativen Sicherungs- und Wiederherstellungsoption zu einer DB-Instance ist der folgende:
1. Erstellen Sie eine neue Optionsgruppe oder kopieren oder ändern Sie eine bestehende Optionsgruppe.
1. Fügen Sie die Option `SQLSERVER_BACKUP_RESTORE` zur Optionsgruppe hinzu.
1. Verknüpfen Sie eine AWS Identity and Access Management (IAM)-Rolle mit der Option. Die IAM-Rolle muss Zugriff auf einen S3-Bucket haben, um die Datenbanksicherungen zu speichern.
Das heißt, die Option muss als Optionseinstellung einen gültigen Amazon-Ressourcennamen (ARN) im Format habe `arn:aws:iam::account-id:role/role-name`. Weitere Informationen finden Sie unter [Amazon-Ressourcennamen (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-iam) im *Allgemeine AWS-Referenz.*
An die IAM-Rolle muss zudem eine Vertrauensbeziehung und eine Berechtigungsrichtlinie angehängt sein. Die Vertrauensbeziehung ermöglicht es RDS, die Rolle zu übernehmen, und die Berechtigungsrichtlinie definiert die Aktionen, welche die Rolle ausführen kann. Weitere Informationen finden Sie unter [Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM).
1. Ordnen Sie die Optionsgruppe der DB-Instance zu.
Nachdem Sie die native Sicherungs- und Wiederherstellungsoption hinzugefügt haben, müssen Sie Ihre DB-Instance nicht neu starten. Sobald die Optionsgruppe aktiv ist, können Sie sofort mit dem Sichern und Wiederherstellen beginnen.
### Konsole
**So fügen Sie die native Sicherungs- und Wiederherstellungsoption hinzu:**
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 **Option groups (Optionsgruppen)** aus.
1. Erstellen Sie eine neue Optionsgruppe oder verwenden Sie eine bestehende Optionsgruppe. Informationen zum Erstellen einer benutzerdefinierten DB-Optionsgruppe finden Sie unter [Erstellen einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
Um eine vorhandene Optionsgruppe zu verwenden, gehen Sie zum nächsten Schritt über.
1. Fügen Sie der Optionsgruppe die Option **SQLSERVER\$1BACKUP\$1RESTORE** hinzu. Weitere Informationen über das Hinzufügen von Optionen finden Sie unter [Hinzufügen einer Option zu einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Führen Sie eine der folgenden Aufgaben aus:
+ Um eine vorhandene IAM-Rolle und Amazon S3-Einstellungen zu verwenden, wählen Sie eine vorhandene IAM-Rolle für **IAM Role (IAM-Rolle)**. Wenn Sie eine vorhandene IAM-Rolle verwenden, verwendet RDS die für diese Rolle konfigurierten Amazon S3-Einstellungen.
+ Um eine neue Rolle zu erstellen und neue Amazon S3-Einstellungen zu konfigurieren, gehen Sie wie folgt vor:
1. Wählen Sie für **IAM Role (IAM-Rolle)** die Option **Create a New Role (Neue Rolle erstellen)** aus.
1. Wählen Sie für **S3-Bucket-Name**, einen vorhandenen S3-Bucket aus der Liste aus.
1. Geben Sie unter **S3-Ordnerpfad-Präfix (optional)** ein Präfix an, das für die in Ihrem Amazon S3-Bucket gespeicherten Dateien verwendet werden soll.
Dieses Präfix kann einen Dateipfad beinhalten, muss es aber nicht. Wenn Sie ein Präfix angeben, hängt RDS dieses Präfix an alle Sicherungsdateien an. RDS verwendet dann das Präfix während einer Wiederherstellung, um verwandte Dateien zu identifizieren und irrelevante Dateien zu ignorieren. Beispielsweise können Sie den S3-Bucket für andere Zwecke als das Speichern von Backup-Dateien verwenden. In diesem Fall können Sie das Präfix verwenden, um RDS eine native Sicherung und Backup nur für einen bestimmten Ordner und seine Unterordner durchführen zu lassen.
Wenn Sie das Präfix leer lassen, verwendet RDS kein Präfix, um Backup-Dateien oder wiederherzustellende Dateien zu identifizieren. Infolgedessen versucht RDS bei einer Wiederherstellung mit mehreren Dateien, jede Datei in jedem Ordner des S3-Buckets wiederherzustellen.
1. Für **Verschlüsselung aktivieren** wählen Sie das Käastchen aus, um die Sicherungsdatei zu verschlüsseln. Lassen Sie das Kontrollkästchen deaktiviert (Standardeinstellung), damit die Sicherungsdatei unverschlüsselt ist.
Wenn Sie **Enable encryption (Verschlüsselung aktivieren)** gewählt haben, wählen Sie einen Verschlüsselungscode für **AWS KMS key** aus. Weitere Informationen zu Verschlüsselungsschlüsseln finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) im *AWS Key Management Service-Entwicklerhandbuch*.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. Ordnen Sie die Optionsgruppe einer neuen oder bestehenden DB-Instance zu:
+ Weisen Sie bei einer neuen DB-Instance die Optionsgruppe beim Starten der Instance zu. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Weisen Sie bei einer bestehenden DB-Instance die Optionsgruppe zu, indem Sie die Instance ändern und die neue Optionsgruppe anhängen. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### CLI
Dieses Verfahren geht von den folgenden Annahmen aus:
+ Sie fügen die Option SQLSERVER\$1BACKUP\$1RESTORE zu einer bereits vorhandenen Optionsgruppe hinzu. Weitere Informationen über das Hinzufügen von Optionen finden Sie unter [Hinzufügen einer Option zu einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
+ Sie verknüpfen die Option mit einer bereits vorhandenen IAM-Rolle, die Zugriff auf einen S3-Bucket zum Speichern der Sicherungen hat.
+ Sie wenden die Optionsgruppe auf eine bereits existierende DB-Instance an. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
**So fügen Sie die native Sicherungs- und Wiederherstellungsoption hinzu:**
1. Fügen Sie die Option `SQLSERVER_BACKUP_RESTORE` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--apply-immediately \
--option-group-name mybackupgroup \
--options "OptionName=SQLSERVER_BACKUP_RESTORE, \
OptionSettings=[{Name=IAM_ROLE_ARN,Value=arn:aws:iam::account-id:role/role-name}]"
```
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name mybackupgroup ^
--options "[{\"OptionName\": \"SQLSERVER_BACKUP_RESTORE\", ^
\"OptionSettings\": [{\"Name\": \"IAM_ROLE_ARN\", ^
\"Value\": \"arn:aws:iam::account-id:role/role-name"}]}]" ^
--apply-immediately
```
**Anmerkung**
Bei Verwendung der Windows-Befehlszeile müssen doppelte Anführungszeichen (") im JSON-Code mit einem umgekehrten Schrägstrich (\$1) als Escape-Zeichen versehen werden.
1. Wenden Sie die Optionsgruppe auf die DB-Instance an.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--option-group-name mybackupgroup \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--option-group-name mybackupgroup ^
--apply-immediately
```
## Einstellungen für Native Sicherungs- und Wiederherstellungsoption ändern
Nachdem Sie die native Sicherungs- und Wiederherstellungsoption aktiviert haben, können Sie die Einstellungen für die Option ändern. Weitere Informationen über das Ändern von Optionseinstellungen finden Sie unter [Ändern einer Optionseinstellung](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption).
## Entfernen der Nativen Sicherungs- und Wiederherstellungsoption
Sie können die native Sicherung und Backup deaktivieren, indem Sie die Option aus Ihrer DB-Instance entfernen. Nachdem Sie die native Sicherungs- und Wiederherstellungsoption entfernt haben, müssen Sie Ihre DB-Instance nicht neu starten.
Um die native Sicherungs- und Wiederherstellungsoption aus einer DB-Instance zu entfernen, führen Sie einen der folgenden Schritte aus:
+ Entfernen Sie die -Option aus der zugehörigen Optionsgruppe. Diese Änderung wirkt sich auf alle DB-Instances aus, welche die betreffende Optionsgruppe verwenden. Weitere Informationen finden Sie unter [Entfernen einer Option aus einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Ändern Sie die DB-Instance und geben Sie eine andere Optionsgruppe an, welche die native Sicherungs- und Wiederherstellungsoption nicht enthält. Diese Änderung betrifft eine einzelne DB-Instance. Sie können die (leere) Standardoptionsgruppe oder eine andere benutzerdefinierte Optionsgruppe angeben. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
# Unterstützung für transparente Datenverschlüsselung in SQL Server
Amazon RDS unterstützt die Verwendung von transparenter Datenverschlüsselung (Transparent Data Encryption, TDE), um gespeicherte Daten auf Ihren DB-Instances mit Microsoft SQL Server zu verschlüsseln. TDE verschlüsselt die Daten automatisch, bevor sie in den Speicher geschrieben werden, und entschlüsselt sie automatisch, wenn die Daten aus dem Speicher gelesen werden.
Amazon RDS unterstützt TDE für die folgenden SQL Server-Versionen und -Editionen:
+ SQL Server 2022 Standard- und Enterprise-Editionen
+ SQL Server 2019: Standard- und Enterprise Editions
+ SQL Server 2017 Enterprise Edition
+ SQL Server 2016 Enterprise Edition
**Anmerkung**
RDS für SQL Server unterstützt keine TDE für schreibgeschützte Datenbanken.
Transparent Data Encryption für SQL Server verwaltet Verschlüsselungsschlüssel durch die Verwendung einer zweistufigen Schlüsselarchitektur. Zum Schutz der Datenverschlüsselungsschlüssel wird ein Zertifikat verwendet, das aus dem Datenbank-Hauptschlüssel generiert wird. Der Datenbankverschlüsselungsschlüssel führt die eigentliche Verschlüsselung und Entschlüsselung der Daten auf der Benutzerdatenbank aus. Amazon RDS sichert und verwaltet den Datenbank-Hauptschlüssel und das TDE-Zertifikat.
Transparent Data Encryption wird in Szenarien verwendet, in denen Sie sensible Daten verschlüsseln müssen. So beispielsweise, wenn Sie einem Drittanbieter Datendateien und Sicherungen zur Verfügung stellen möchten, oder in Fällen, oder in denen es um sicherheitsbezogene Fragen zur Einhaltung gesetzlicher Vorschriften geht. Sie können die Systemdatenbanken für SQL Server nicht verschlüsseln, wie z. B. `model`- oder `master`-Datenbanken.
Eine ausführliche Diskussion über Transparent Data Encryption ist nicht Gegenstand dieses Leitfadens, aber Sie sollten unbedingt die Sicherheitsstärken und -schwächen der einzelnen Verschlüsselungsalgorithmen und Schlüssel verstehen. Weitere Informationen zu transparenter Datenverschlüsselung für SQL Server finden Sie unter [Transparent Data Encryption (TDE)](http://msdn.microsoft.com/en-us/library/bb934049.aspx) auf der Microsoft-Website.
**Topics**
+ [
## Aktivieren von TDE für RDS für SQL Server
](#TDE.Enabling)
+ [
# Verschlüsseln von Daten in RDS for SQL Server
](TDE.Encrypting.md)
+ [
# Sichern und Wiederherstellen von TDE-Zertifikaten in RDS für SQL Server
](TDE.BackupRestoreRDS.md)
+ [
# Sichern und Wiederherstellen von TDE-Zertifikaten für lokale Datenbanken
](TDE.BackupRestoreOnPrem.md)
+ [
# Deaktivieren von TDE für RDS for SQL Server
](TDE.Disabling.md)
## Aktivieren von TDE für RDS für SQL Server
Wenn Sie Transparent Data Encryption für eine DB-Instance von RDS für SQL Server aktivieren möchten, geben Sie die TDE-Option in einer RDS-Optionsgruppe an, die dieser DB-Instance zugeordnet ist:
1. Bestimmen Sie, ob Ihre DB-Instance bereits mit einer Optionsgruppe verknüpft ist, die über die Option TDE verfügt. Um die Optionsgruppe anzuzeigen, der eine DB-Instance zugeordnet ist, verwenden Sie die RDS-Konsole, den [describe-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) AWS CLI Befehl oder die API-Operation [Describe DBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html).
1. Wenn die DB-Instance keiner Optionsgruppe zugeordnet ist, für die TDE aktiviert ist, haben Sie zwei Optionen. Sie können eine Optionsgruppe erstellen und die Option TDE hinzufügen oder Sie können die zugeordnete Optionsgruppe abändern und sie ihr hinzufügen.
**Anmerkung**
In der RDS-Konsole heißt die Option `TRANSPARENT_DATA_ENCRYPTION`. In der AWS CLI und der RDS-API ist sie benannt`TDE`.
Weitere Informationen zum Erstellen oder Ändern einer Optionsgruppe finden Sie unter [Arbeiten mit Optionsgruppen](USER_WorkingWithOptionGroups.md). Weitere Informationen zum Hinzufügen einer Option zu einer Optionsgruppe finden Sie unter [Hinzufügen einer Option zu einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Ordnen Sie der DB-Instance eine Optionsgruppe zu, die über die Option TDE verfügt. Weitere Informationen zum Zuordnen einer DB-Instance zu einer Optionsgruppe finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### Überlegungen zu Optionsgruppen
Die TDE-Option ist eine persistente Option. Sie können sie nur dann aus einer Optionsgruppe entfernen, wenn keine DB-Instances und Sicherungen mehr mit der Optionsgruppe verknüpft sind. Sobald Sie die TDE-Option einer Optionsgruppe hinzufügen, kann die Optionsgruppe nur mit DB-Instances verknüpft werden, die TDE verwenden. Weitere Information zu persistenten Optionen in einer Optionsgruppe, finden Sie unter [Übersicht über die Optionsgruppen](USER_WorkingWithOptionGroups.md#Overview.OptionGroups).
Da die Option TDE eine persistente Option ist, kann es zu einem Konflikt zwischen der Optionsgruppe und einer zugehörigen DB-Instance kommen. In folgenden Situationen können Konflikte auftreten:
+ Die aktuelle Optionsgruppe verfügt über die TDE-Option. Sie ersetzen sie durch eine Optionsgruppe, welche die TDE-Option nicht enthält.
+ Sie stellen von einem DB-Snapshot auf eine neue DB-Instance wieder her, die keine Optionsgruppe mit der TDE-Option enthält. Weitere Informationen zu diesem Szenario finden Sie unter [Überlegungen zu Optionsgruppen](USER_CopySnapshot.md#USER_CopySnapshot.Options).
### Überlegungen zur SQL Server-Performance
Die Leistung einer SQL-Server-DB-Instance kann durch Transparent Data Encryption beeinträchtigt werden.
Die Performance für unverschlüsselte Datenbanken kann ebenfalls beeinträchtigt werden, wenn sich die Datenbanken auf einer DB-Instance befinden, die mindestens eine verschlüsselte Datenbank besitzt. Daher empfehlen wir Ihnen, verschlüsselte und unverschlüsselte Datenbanken auf getrennten DB-Instances zu halten.
# Verschlüsseln von Daten in RDS for SQL Server
Wenn die TDE-Option einer Optionsgruppe hinzugefügt wird, generiert Amazon RDS ein Zertifikat, das im Verschlüsselungsprozess verwendet wird. Sie können das Zertifikat dann verwenden, um SQL-Anweisungen auszuführen, die Daten in einer Datenbank auf der DB-Instance verschlüsseln.
Das folgende Beispiel verwendet das von RDS erstellte Zertifikat genannt `RDSTDECertificateName` welches verwendet wird um eine Datenbank genannt `myDatabase`zu verschlüsseln.
```
1. ---------- Turning on TDE -------------
2.
3. -- Find an RDS TDE certificate to use
4. USE [master]
5. GO
6. SELECT name FROM sys.certificates WHERE name LIKE 'RDSTDECertificate%'
7. GO
8.
9. USE [myDatabase]
10. GO
11. -- Create a database encryption key (DEK) using one of the certificates from the previous step
12. CREATE DATABASE ENCRYPTION KEY WITH ALGORITHM = AES_256
13. ENCRYPTION BY SERVER CERTIFICATE [RDSTDECertificateName]
14. GO
15.
16. -- Turn on encryption for the database
17. ALTER DATABASE [myDatabase] SET ENCRYPTION ON
18. GO
19.
20. -- Verify that the database is encrypted
21. USE [master]
22. GO
23. SELECT name FROM sys.databases WHERE is_encrypted = 1
24. GO
25. SELECT db_name(database_id) as DatabaseName, * FROM sys.dm_database_encryption_keys
26. GO
```
Wie lange die Verschlüsselung einer SQL Server-Datenbank mit TDE dauert, ist von mehreren Faktoren abhängig. Dazu gehören die Größe der DB-Instance, ob bereitgestellter IOPS-Speicher für die Instance verwendet wird, die Datenmenge und andere Faktoren.
# Sichern und Wiederherstellen von TDE-Zertifikaten in RDS für SQL Server
RDS für SQL Server bietet gespeicherte Prozeduren zum Sichern, Wiederherstellen und Löschen von TDE-Zertifikaten. RDS für SQL Server bietet auch eine Funktion zum Anzeigen wiederhergestellter Benutzer-TDE-Zertifikate.
Benutzer-TDE-Zertifikate werden verwendet, um Datenbanken in RDS für SQL Server wiederherzustellen, die lokal sind und TDE aktiviert haben. Diese Zertifikate haben das Präfix `UserTDECertificate_`. Nach dem Wiederherstellen von Datenbanken und bevor sie zur Verwendung verfügbar gemacht werden, ändert RDS die Datenbanken, für die TDE aktiviert ist, so, dass RDS-generierte TDE-Zertifikate verwenden werden können. Diese Zertifikate haben das Präfix `RDSTDECertificate`.
Benutzer-TDE-Zertifikate bleiben auf der DB-Instance von RDS für SQL Server gespeichert, es sei denn, Sie entfernen sie mit der gespeicherten Prozedur `rds_drop_tde_certificate`. Weitere Informationen finden Sie unter [Entfernen wiederhergestellter TDE-Zertifikate](#TDE.BackupRestoreRDS.Drop).
Sie können ein Benutzer-TDE-Zertifikat verwenden, um andere Datenbanken aus der Quell-DB-Instance wiederherzustellen. Die wiederherzustellenden Datenbanken müssen dasselbe TDE-Zertifikat verwenden und TDE aktiviert haben. Sie müssen das entsprechende Zertifikat nicht erneut importieren (wiederherstellen).
**Topics**
+ [
## Voraussetzungen
](#TDE.BackupRestoreRDS.Prereqs)
+ [
## Einschränkungen
](#TDE.Limitations)
+ [
## Sichern eines TDE-Zertifikats
](#TDE.BackupRestoreRDS.Backup)
+ [
## Wiederherstellen eines TDE-Zertifikats
](#TDE.BackupRestoreRDS.Restore)
+ [
## Anzeigen wiederhergestellter TDE-Zertifikate
](#TDE.BackupRestoreRDS.Show)
+ [
## Entfernen wiederhergestellter TDE-Zertifikate
](#TDE.BackupRestoreRDS.Drop)
## Voraussetzungen
Bevor Sie TDE-Zertifikate in RDS für SQL Server sichern oder wiederherstellen können, müssen Sie die folgenden Schritte ausführen. Die ersten drei sind in [Einrichtung für native Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Enabling.md) beschrieben.
1. Erstellen Sie allgemeine Amazon S3 S3-Buckets oder Verzeichnis-Buckets zum Speichern von Dateien zum Sichern und Wiederherstellen.
Es wird empfohlen, separate Buckets für Datenbanksicherungen und für TDE-Zertifikatssicherungen zu verwenden.
1. Erstellen Sie eine IAM-Rolle zum Sichern und Wiederherstellen von Dateien.
Die IAM-Rolle muss sowohl ein Benutzer als auch ein Administrator für AWS KMS key sein.
Bei der Verwendung von Verzeichnis-Buckets sind keine zusätzlichen Berechtigungen erforderlich, [Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM) mit Ausnahme der Berechtigungen, die für Verzeichnis-Buckets erforderlich sind.
Bei der Verwendung von S3-Ressourcen benötigt die IAM-Rolle zusätzlich zu den Berechtigungen, die für erforderlich sind, auch die folgenden Berechtigungen: [Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ `s3:GetBucketAcl`, `s3:GetBucketLocation` und `s3:ListBucket` in der S3-Bucket-Ressource
1. Fügen Sie die Option `SQLSERVER_BACKUP_RESTORE` einer Optionsgruppe auf Ihrer DB-Instance hinzu.
Dies gilt zusätzlich zu der Option `TRANSPARENT_DATA_ENCRYPTION` (`TDE`).
1. Stellen Sie sicher, dass Sie einen symmetrischen KMS-Verschlüsselungsschlüssel zur Verfügung haben. Ihnen stehen folgende Optionen zur Verfügung:
+ Wenn ein KMS-Schlüssel in Ihrem Konto vorhanden ist, können Sie diesen verwenden. Es sind keine weiteren Maßnahmen erforderlich.
+ Wenn Sie keinen vorhandenen symmetrischen KMS-Verschlüsselungsschlüssel in Ihrem Konto haben, erstellen Sie einen KMS-Schlüssel, indem Sie den Anweisungen unter [Erstellen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch* folgen.
1. Aktivieren Sie die Amazon-S3-Integration, um Dateien zwischen der DB-Instance und Amazon S3 zu übertragen.
Weitere Informationen zum Aktivieren der Amazon-S3-Integration finden Sie unter [Integration einer Amazon RDS für SQL Server-DB-Instance mit Amazon S3](User.SQLServer.Options.S3-integration.md).
Beachten Sie, dass Verzeichnis-Buckets für die S3-Integration nicht unterstützt werden. Dieser Schritt ist nur für [Sichern und Wiederherstellen von TDE-Zertifikaten für lokale Datenbanken](TDE.BackupRestoreOnPrem.md) erforderlich.
## Einschränkungen
Die Verwendung von gespeicherten Prozeduren zum Sichern und Wiederherstellen von TDE-Zertifikaten unterliegt folgenden Einschränkungen:
+ Beide Optionen, sowohl `SQLSERVER_BACKUP_RESTORE` als auch `TRANSPARENT_DATA_ENCRYPTION` (`TDE`), müssen der Optionsgruppe hinzugefügt werden, die mit Ihrer DB-Instance verbunden ist.
+ Sicherung und Wiederherstellung von TDE-Zertifikaten werden auf Multi-AZ-DB-Instances nicht unterstützt.
+ Backup- und Wiederherstellungsaufgaben für das TDE-Zertifikat können nicht abgebrochen werden.
+ Sie können kein Benutzer-TDE-Zertifikat für die TDE-Verschlüsselung einer anderen Datenbank auf Ihrer DB-Instance von RDS für SQL Server verwenden. Sie können damit nur andere Datenbanken von der Quell-DB-Instance wiederherstellen, bei denen TDE aktiviert ist und die dasselbe TDE-Zertifikat verwenden.
+ Sie können nur Benutzer-TDE-Zertifikate löschen.
+ Die maximale Anzahl von Benutzer-TDE-Zertifikaten, die in RDS unterstützt werden, beträgt 10. Wenn die Anzahl 10 überschreitet, entfernen Sie nicht verwendete TDE-Zertifikate und versuchen Sie es erneut.
+ Der Zertifikatsname darf nicht leer oder null sein.
+ Beim Wiederherstellen eines Zertifikats darf der Zertifikatname das Schlüsselwort `RDSTDECERTIFICATE` nicht enthalten und muss mit dem Präfix `UserTDECertificate_` beginnen.
+ Der `@certificate_name`-Parameter darf nur die folgenden Zeichen enthalten: a–z, 0–9, @, \$1, \$1 und Unterstrich (\$1).
+ Die Dateierweiterungen für `@certificate_file_s3_arn` muss .cer (Groß-/Kleinschreibung wird nicht berücksichtigt) lauten.
+ Die Dateierweiterungen für `@private_key_file_s3_arn` muss .pvk (Groß-/Kleinschreibung wird nicht berücksichtigt) lauten.
+ Die S3-Metadaten für die private Schlüsseldatei müssen das Tag `x-amz-meta-rds-tde-pwd` enthalten. Weitere Informationen finden Sie unter [Sichern und Wiederherstellen von TDE-Zertifikaten für lokale Datenbanken](TDE.BackupRestoreOnPrem.md).
+ RDS für SQL Server unterstützt keine Verwendung von kontoübergreifenden Schlüsseln für TDE.
## Sichern eines TDE-Zertifikats
Verwenden Sie zum Sichern von TDE-Zertifikaten die gespeicherte Prozedur `rds_backup_tde_certificate`. Es hat die folgende Syntax.
```
EXECUTE msdb.dbo.rds_backup_tde_certificate
@certificate_name='UserTDECertificate_certificate_name | RDSTDECertificatetimestamp',
@certificate_file_s3_arn='arn:aws:s3:::bucket_name/certificate_file_name.cer',
@private_key_file_s3_arn='arn:aws:s3:::bucket_name/key_file_name.pvk',
@kms_password_key_arn='arn:aws:kms:region:account-id:key/key-id',
[@overwrite_s3_files=0|1];
```
Die folgenden Parameter sind erforderlich:
+ `@certificate_name` – Der Name des zu sichernden TDE-Zertifikats.
+ `@certificate_file_s3_arn` – Der Ziel-Amazon-Ressourcenname (ARN) für die Sicherungsdatei des Zertifikats in Amazon S3.
+ `@private_key_file_s3_arn` – Der Ziel-S3-ARN der privaten Schlüsseldatei, die das TDE-Zertifikat sichert.
+ `@kms_password_key_arn` – Der ARN des symmetrischen KMS-Schlüssels, der zum Verschlüsseln des Passworts des privaten Schlüssels verwendet wurde.
Der folgende Parameter ist optional:
+ `@overwrite_s3_files` – Gibt an, ob das vorhandene Zertifikat und die privaten Schlüsseldateien in S3 überschrieben werden sollen:
+ `0` – Die vorhandenen Dateien werden nicht überschrieben. Dieser Wert ist der Standard.
Wenn Sie `@overwrite_s3_files` auf 0 festlegen, wird ein Fehler ausgegeben, wenn eine Datei bereits vorhanden ist.
+ `1` – Eine vorhandene Datei mit dem angegebenen Namen wird überschrieben, auch wenn es sich nicht um eine Sicherungsdatei handelt.
**Example Sichern eines TDE-Zertifikats**
```
EXECUTE msdb.dbo.rds_backup_tde_certificate
@certificate_name='RDSTDECertificate20211115T185333',
@certificate_file_s3_arn='arn:aws:s3:::TDE_certs/mycertfile.cer',
@private_key_file_s3_arn='arn:aws:s3:::TDE_certs/mykeyfile.pvk',
@kms_password_key_arn='arn:aws:kms:us-west-2:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@overwrite_s3_files=1;
```
## Wiederherstellen eines TDE-Zertifikats
Verwenden Sie die gespeicherte Prozedur `rds_restore_tde_certificate` zum Wiederherstellen (Importieren) von Benutzer-TDE-Zertifikaten. Es hat die folgende Syntax.
```
EXECUTE msdb.dbo.rds_restore_tde_certificate
@certificate_name='UserTDECertificate_certificate_name',
@certificate_file_s3_arn='arn:aws:s3:::bucket_name/certificate_file_name.cer',
@private_key_file_s3_arn='arn:aws:s3:::bucket_name/key_file_name.pvk',
@kms_password_key_arn='arn:aws:kms:region:account-id:key/key-id';
```
Die folgenden Parameter sind erforderlich:
+ `@certificate_name` – Der Name des TDE-Zertifikats, das wiederhergestellt werden soll. Der Name muss mit dem Präfix `UserTDECertificate_` beginnen.
+ `@certificate_file_s3_arn` – Der S3-ARN der Sicherungsdatei, die zum Wiederherstellen des TDE-Zertifikats verwendet wurde.
+ `@private_key_file_s3_arn` – Der S3-ARN der Sicherungsdatei des privaten Schlüssels, die zum Wiederherstellen des TDE-Zertifikats verwendet wurde.
+ `@kms_password_key_arn` – Der ARN des symmetrischen KMS-Schlüssels, der zum Verschlüsseln des Passworts des privaten Schlüssels verwendet wurde.
**Example Wiederherstellen eines TDE-Zertifikats**
```
EXECUTE msdb.dbo.rds_restore_tde_certificate
@certificate_name='UserTDECertificate_myTDEcertificate',
@certificate_file_s3_arn='arn:aws:s3:::TDE_certs/mycertfile.cer',
@private_key_file_s3_arn='arn:aws:s3:::TDE_certs/mykeyfile.pvk',
@kms_password_key_arn='arn:aws:kms:us-west-2:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
## Anzeigen wiederhergestellter TDE-Zertifikate
Verwenden Sie die Funktion `rds_fn_list_user_tde_certificates` zum Wiederherstellen (Importieren) von Benutzer-TDE-Zertifikaten Es hat die folgende Syntax.
```
SELECT * FROM msdb.dbo.rds_fn_list_user_tde_certificates();
```
Die Ausgabe sieht in etwa folgendermaßen aus. Hier werden nicht alle Spalten angezeigt.
| | | | | | | | | | | |
| --- |--- |--- |--- |--- |--- |--- |--- |--- |--- |--- |
| name | certificate\$1id | principal\$1id | pvt\$1key\$1encryption\$1type\$1desc | issuer\$1name | cert\$1serial\$1number | thumbprint | subject | start\$1date | expiry\$1date | pvt\$1key\$1last\$1backup\$1date |
| UserTDECertificate\$1tde\$1cert | 343 | 1 | ENCRYPTED\$1BY\$1MASTER\$1KEY | AnyCompany Shipping | 79 3e 57 a3 69 fd 1d 9e 47 2c 32 67 1d 9c ca af | 0x6BB218B34110388680B FE1BA2D86C695096485B5 | AnyCompany Shipping | 2022-04-05 19:49:45.0000000 | 2023-04-05 19:49:45.0000000 | NULL |
## Entfernen wiederhergestellter TDE-Zertifikate
Verwenden Sie die gespeicherte Prozedur `rds_drop_tde_certificate`, um wiederhergestellte (importierte) Benutzer-TDE-Zertifikate zu löschen, die Sie nicht verwenden. Es hat die folgende Syntax.
```
EXECUTE msdb.dbo.rds_drop_tde_certificate @certificate_name='UserTDECertificate_certificate_name';
```
Der folgende Parameter ist erforderlich:
+ `@certificate_name` – Der Name des TDE-Zertifikats, das entfernt werden soll.
Sie können nur wiederhergestellte (importierte) TDE-Zertifikate löschen. Von RDS erstellte Zertifikate können nicht gelöscht werden.
**Example Entfernen eines TDE-Zertifikats**
```
EXECUTE msdb.dbo.rds_drop_tde_certificate @certificate_name='UserTDECertificate_myTDEcertificate';
```
# Sichern und Wiederherstellen von TDE-Zertifikaten für lokale Datenbanken
Sie können TDE-Zertifikate für lokale Datenbanken sichern und sie später in RDS für SQL Server wiederherstellen. Sie können auch ein TDE-Zertifikat von RDS für SQL Server auf einer lokalen DB-Instance wiederherstellen.
**Anmerkung**
RDS für SQL Server unterstützt keine Verwendung von kontoübergreifenden Schlüsseln für TDE.
Mit dem folgenden Verfahren werden ein TDE-Zertifikat und ein privater Schlüssel gesichert. Der private Schlüssel wird mit einem Datenschlüssel verschlüsselt, der aus Ihrem KMS-Schlüssel mit symmetrischer Verschlüsselung generiert wird.
**So sichern Sie ein lokales TDE-Zertifikat**
1. Generieren Sie den Datenschlüssel mit dem AWS CLI [generate-data-key](https://docs.aws.amazon.com/cli/latest/reference/kms/generate-data-key.html)Befehl.
```
aws kms generate-data-key \
--key-id my_KMS_key_ID \
--key-spec AES_256
```
Die Ausgabe sieht in etwa folgendermaßen aus.
```
{
"CiphertextBlob": "AQIDAHimL2NEoAlOY6Bn7LJfnxi/OZe9kTQo/XQXduug1rmerwGiL7g5ux4av9GfZLxYTDATAAAAfjB8BgkqhkiG9w0B
BwagbzBtAgEAMGgGCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQMyCxLMi7GRZgKqD65AgEQgDtjvZLJo2cQ31Vetngzm2ybHDc3d2vI74SRUzZ
2RezQy3sAS6ZHrCjfnfn0c65bFdhsXxjSMnudIY7AKw==",
"Plaintext": "U/fpGtmzGCYBi8A2+0/9qcRQRK2zmG/aOn939ZnKi/0=",
"KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-00ee-99ff-88dd-aa11bb22cc33"
}
```
Sie verwenden die Nur-Text-Ausgabe im nächsten Schritt als Passwort für den privaten Schlüssel.
1. Sichern Sie Ihr TDE-Zertifikat wie im folgenden Beispiel gezeigt.
```
BACKUP CERTIFICATE myOnPremTDEcertificate TO FILE = 'D:\tde-cert-backup.cer'
WITH PRIVATE KEY (
FILE = 'C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\DATA\cert-backup-key.pvk',
ENCRYPTION BY PASSWORD = 'U/fpGtmzGCYBi8A2+0/9qcRQRK2zmG/aOn939ZnKi/0=');
```
1. Speichern Sie die Sicherungsdatei des Zertifikats in Ihrem Amazon-S3-Zertifikat-Bucket.
1. Speichern Sie die Sicherungsdatei für den privaten Schlüssel in Ihrem S3-Zertifikat-Bucket mit dem folgenden Tag in den Metadaten der Datei:
+ Schlüssel: `x-amz-meta-rds-tde-pwd`
+ Wert: Der Wert `CiphertextBlob` aus der Generierung des Datenschlüssels (siehe folgendes Beispiel).
```
AQIDAHimL2NEoAlOY6Bn7LJfnxi/OZe9kTQo/XQXduug1rmerwGiL7g5ux4av9GfZLxYTDATAAAAfjB8BgkqhkiG9w0B
BwagbzBtAgEAMGgGCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQMyCxLMi7GRZgKqD65AgEQgDtjvZLJo2cQ31Vetngzm2ybHDc3d2vI74SRUzZ
2RezQy3sAS6ZHrCjfnfn0c65bFdhsXxjSMnudIY7AKw==
```
Mit dem folgenden Verfahren wird ein TDE-Zertifikat von RDS für SQL Server auf einer lokalen DB-Instance wiederhergestellt. Sie kopieren und stellen das TDE-Zertifikat auf Ihrer Ziel-DB-Instance mit der Zertifikatssicherung, der entsprechenden privaten Schlüsseldatei und dem Datenschlüssel wieder her. Das wiederhergestellte Zertifikat wird durch den Datenbank-Hauptschlüssel des neuen Servers verschlüsselt.
**So stellen Sie ein TDE-Zertifikat wieder her**
1. Kopieren Sie die Sicherungsdatei des TDE-Zertifikats und die private Schlüsseldatei von Amazon S3 auf die Ziel-Instance. Weitere Informationen zum Kopieren von Dateien aus Amazon S3 finden Sie unter [Übertragen von Dateien zwischen RDS for SQL Server und Amazon S3](Appendix.SQLServer.Options.S3-integration.using.md).
1. Entschlüsseln Sie den verschlüsselten Ausgabetext mit Ihrem KMS-Schlüssel, um den Nur-Text des Datenschlüssels abzurufen. Der Verschlüsselungstext befindet sich in den S3-Metadaten der Sicherungsdatei für private Schlüssel.
```
aws kms decrypt \
--key-id my_KMS_key_ID \
--ciphertext-blob fileb://exampleCiphertextFile | base64 -d \
--output text \
--query Plaintext
```
Sie verwenden die Nur-Text-Ausgabe im nächsten Schritt als Passwort für den privaten Schlüssel.
1. Verwenden Sie den folgenden SQL-Befehl, um das TDE-Zertifikat wiederherzustellen.
```
CREATE CERTIFICATE myOnPremTDEcertificate FROM FILE='D:\tde-cert-backup.cer'
WITH PRIVATE KEY (FILE = N'D:\tde-cert-key.pvk',
DECRYPTION BY PASSWORD = 'plain_text_output');
```
Weitere Informationen zur KMS-Entschlüsselung finden Sie unter [decrypt](https://docs.aws.amazon.com/cli/latest/reference/kms/decrypt.html) im KMS-Bereich der *AWS CLI -Befehlsreferenz*.
Nachdem das TDE-Zertifikat auf der Ziel-DB-Instance wiederhergestellt wurde, können Sie verschlüsselte Datenbanken mit diesem Zertifikat wiederherstellen.
**Anmerkung**
Sie können dasselbe TDE-Zertifikat verwenden, um mehrere SQL-Server-Datenbanken auf der Quell-DB-Instance zu verschlüsseln. Wenn Sie mehrere Datenbanken zu einer eine Ziel-Instance migrieren möchten, kopieren Sie das mit den Datenbanken verknüpfte TDE-Zertifikat nur einmal auf die Ziel-Instance.
# Deaktivieren von TDE für RDS for SQL Server
Wenn Sie TDE für eine DB-Instance von RDS for SQL deaktivieren möchten, stellen Sie zunächst sicher, dass keine verschlüsselten Objekte mehr auf der DB-Instance vorhanden sind. Entschlüsseln Sie dazu entweder die Objekte oder entfernen Sie sie. Wenn verschlüsselte Objekte auf der DB-Instance vorhanden sind, können Sie TDE für die DB-Instance nicht deaktivieren. Wenn ein Benutzer-TDE-Zertifikat für die Verschlüsselung wiederhergestellt (importiert) wurde, sollte es gelöscht werden. Wenn Sie die Konsole verwenden, um die TDE-Option aus einer Optionsgruppe zu entfernen, wird auf der Konsole angegeben, dass die Verarbeitung durchgeführt wird. Zudem wird ein Fehlerereignis erstellt, wenn die Optionsgruppe mit einer verschlüsselten DB-Instance oder einem DB-Snapshot verknüpft ist.
Das folgende Beispiel entfernt die TDE-Verschlüsselung aus einer Datenbank mit dem Namen `customerDatabase`.
```
1. ------------- Removing TDE ----------------
2.
3. USE [customerDatabase]
4. GO
5.
6. -- Turn off encryption of the database
7. ALTER DATABASE [customerDatabase]
8. SET ENCRYPTION OFF
9. GO
10.
11. -- Wait until the encryption state of the database becomes 1. The state is 5 (Decryption in progress) for a while
12. SELECT db_name(database_id) as DatabaseName, * FROM sys.dm_database_encryption_keys
13. GO
14.
15. -- Drop the DEK used for encryption
16. DROP DATABASE ENCRYPTION KEY
17. GO
18.
19. -- Drop a user TDE certificate if it was restored (imported)
20. EXECUTE msdb.dbo.rds_drop_tde_certificate @certificate_name='UserTDECertificate_certificate_name';
21.
22. -- Alter to SIMPLE Recovery mode so that your encrypted log gets truncated
23. USE [master]
24. GO
25. ALTER DATABASE [customerDatabase] SET RECOVERY SIMPLE
26. GO
```
Wenn alle Objekte entschlüsselt werden, haben Sie zwei Möglichkeiten:
1. Sie können die DB-Instance so ändern, dass sie einer Optionsgruppe ohne die Option TDE zugeordnet ist.
1. Sie können die TDE-Option aus der Optionsgruppe entfernen.
# SQL Server Audit
In Amazon RDS können Sie Microsoft SQL Server-Datenbanken mit dem integrierten Prüfmechanismus von SQL Server überwachen. Sie können Überwachungen und Überwachungsspezifikationen genau so erstellen, wie Sie dies für lokale Datenbankserver tun.
RDS lädt die abgeschlossenen Audit-Protokolle Ihren S3-Bucket mit der von Ihnen bereitgestellten IAM-Rolle hoch. Wenn Sie die Aufbewahrung aktivieren, behält RDS Ihre Audit-Protokolle für den festgelegten Zeitraum auf Ihrer DB-Instance bei.
Weitere Informationen finden Sie unter [SQL Server Audit (Datenbank-Engine)](https://docs.microsoft.com/sql/relational-databases/security/auditing/sql-server-audit-database-engine) in der Microsoft SQL Server-Dokumentation.
## SQL-Server-Audit mit Datenbankaktivitätsstreams
Sie können Datenbankaktivitätsstreams für RDS verwenden, um SQL-Server-Audit-Ereignisse in die Tools zur Überwachung der Datenbankaktivitäten von Imperva, McAfee und IBM zu integrieren. Weitere Informationen über die Überwachung mit Datenbankaktivitätsstreams für RDS SQL Server finden Sie unter [Prüfungen in Microsoft SQL Server](DBActivityStreams.md#DBActivityStreams.Overview.SQLServer-auditing)
**Topics**
+ [
## SQL-Server-Audit mit Datenbankaktivitätsstreams
](#Appendix.SQLServer.DAS.Audit)
+ [
## Support für SQL Server Audit
](#Appendix.SQLServer.Options.Audit.Support)
+ [
# Hinzufügen von SQL Server Audit zu DB-Instance-Optionen
](Appendix.SQLServer.Options.Audit.Adding.md)
+ [
# Verwenden von SQL Server Audit
](Appendix.SQLServer.Options.Audit.CreateAuditsAndSpecifications.md)
+ [
# Anzeigen von Audit-Protokollen
](Appendix.SQLServer.Options.Audit.AuditRecords.md)
+ [
## Verwenden von SQL Server Audit mit Multi-AZ-Instances
](#Appendix.SQLServer.Options.Audit.Multi-AZ)
+ [
# Konfigurieren eines S3-Buckets
](Appendix.SQLServer.Options.Audit.S3bucket.md)
+ [
# Manuelles Erstellen einer IAM-Rolle für SQL Server Audit
](Appendix.SQLServer.Options.Audit.IAM.md)
## Support für SQL Server Audit
In Amazon RDS unterstützen ab SQL Server 2016 alle Editionen von SQL Server Überwachungen auf Serverebene. Die Enterprise-Edition unterstützt zudem Überwachungen auf Datenbankebene. Ab SQL Server 2016 (13.x) SP1 unterstützen alle Editionen sowohl Audits auf Server- als auch auf Datenbankebene. Weitere Informationen finden Sie unter [SQL Server-Audit (Datenbank-Engine)](https://docs.microsoft.com/sql/relational-databases/security/auditing/sql-server-audit-database-engine) in der SQL Server-Dokumentation.
RDS unterstützt die Konfiguration der folgenden Optionseinstellungen für SQL Server Audit.
| Optionseinstellung | Zulässige Werte | Beschreibung |
| --- | --- | --- |
| IAM\$1ROLE\$1ARN | Ein gültiger Amazon Resource Name (ARN) im Format arn:aws:iam::account-id:role/role-name. | Der ARN der IAM-Rolle, der Zugriff auf den S3-Bucket gewährt, in dem Sie Ihre Audit-Protokolle speichern möchten. Weitere Informationen finden Sie unter [Amazon-Ressourcennamen (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-iam) im Allgemeine AWS-Referenz. |
| S3\$1BUCKET\$1ARN | Ein gültiger ARN im Format arn:aws:s3:::amzn-s3-demo-bucket oder arn:aws:s3:::amzn-s3-demo-bucket/key-prefix | Der ARN für den S3-Bucket, in dem Sie Ihre Audit-Protokolle speichern möchten. |
| ENABLE\$1COMPRESSION | true oder false | Steuert die Komprimierung des Überwachungsprotokolls. Standardmäßig ist die Komprimierung aktiviert (auf gesetz true). |
| RETENTION\$1TIME | 0 auf 840 | Die Aufbewahrungszeit (in Stunden), die SQL Server-Audit-Protokolle auf der RDS-Instance gespeichert werden. Die Aufbewahrung ist standardmäßig aktiviert. |
# Hinzufügen von SQL Server Audit zu DB-Instance-Optionen
Die Aktivierung von SQL Server Audit erfordert zwei Schritte: das Aktivieren der Option auf der DB-Instance und das Aktivieren der Funktion in SQL Server. Der Prozess für das Hinzufügen der SQL Server Audit-Option zu einer DB-Instance ist wie folgt:
1. Erstellen Sie eine neue Optionsgruppe oder kopieren oder ändern Sie eine bestehende Optionsgruppe.
1. Fügen Sie alle erforderlichen Optionen hinzu und konfigurieren Sie diese.
1. Ordnen Sie die Optionsgruppe der DB-Instance zu.
Nachdem Sie die SQL Server Audit-Option hinzugefügt haben, ist kein Neustart der DB-Instance erforderlich. Sobald die Optionsgruppe aktiv ist, können Sie Überwachungen erstellen und Audit-Protokolle in Ihrem S3-Bucket speichern.
**So fügen Sie SQL Server Audit-Optionen zur Optionsgruppe einer DB-Instance hinzu und konfigurieren sie**
1. Wählen Sie eine der folgenden Optionen aus:
+ Verwenden einer vorhandenen Optionsgruppe.
+ Erstellen einer benutzerdefinierten DB-Optionsgruppe und verwenden der Optionsgruppe. Weitere Informationen finden Sie unter [Erstellen einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Fügen Sie die Option **SQLSERVER\$1AUDIT** zur Optionsgruppe hinzu, und konfigurieren Sie die Optionseinstellungen. Weitere Informationen über das Hinzufügen von Optionen finden Sie unter [Hinzufügen einer Option zu einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
+ Wenn Sie bereits eine IAM-Rolle mit den erforderlichen Richtlinien haben, können Sie für **IAM role (IAM-Rolle)** diese Rolle auswählen. Zum Erstellen einer neuen IAM-Rolle wählen Sie **Create a New Role (Neue Rolle erstellen)** aus. Informationen zu den erforderlichen Richtlinien finden Sie unter [Manuelles Erstellen einer IAM-Rolle für SQL Server Audit](Appendix.SQLServer.Options.Audit.IAM.md).
+ Wenn Sie bereits einen S3-Bucket haben, den Sie verwenden möchten, wählen Sie diesen für **Select S3 destination (S3-Ziel auswählen)** aus.. Um einen S3-Bucket zu erstellen, wählen Sie **Einen neuen S3-Bucket erstellen** aus.
+ Lassen die Option **Enable Compression (Komprimierung aktivieren)** aktiviert, um Überwachungsdateien zu komprimieren. Die Komprimierung ist standardmäßig aktiviert. Deaktivieren Sie das Kontrollkästchen **Enable Compression (Komprimierung aktivieren)**, wenn keine Komprimierung erfolgen soll.
+ Wählen Sie für die Aufbewahrung von Überwachungsdatensätzen auf der DB-Instance die Option **Audit log retention (Aufbewahrung von Audit-Protokollen)** aus. Geben Sie einen Aufbewahrungszeitraum in Stunden an. Die maximale Aufbewahrungsdauer beträgt 35 Tage.
1. Wenden Sie die Optionsgruppe auf eine neue oder vorhandene DB-Instance an. Wählen Sie eine der folgenden Optionen aus:
+ Wenn Sie eine neue DB-Instance erstellen, weisen Sie die Optionsgruppe beim Start der Instance zu.
+ Weisen Sie bei einer bestehenden DB-Instance die Optionsgruppe zu, indem Sie die Instance ändern und die neue Optionsgruppe anhängen. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
## Ändern der SQL Server Audit-Option
Nach dem Aktivieren der SQL Server Audit-Option können Sie die Einstellungen ändern. Weitere Informationen über das Ändern von Optionseinstellungen finden Sie unter [Ändern einer Optionseinstellung](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption).
## Entfernen von SQL Server Audit aus DB-Instance-Optionen
Sie können die SQL Server Audit-Funktion ausschalten, indem Sie Überwachungen deaktivieren und dann die Option löschen.
**So wird die Überwachung entfernt**
1. Deaktivieren Sie alle Überwachungseinstellungen in SQL Server. Fragen Sie die SQL Server-Sicherheitskatalogansichten ab, um herauszufinden, wo Überwachungen durchgeführt werden. Weitere Informationen finden Sie unter [Sicherheitskatalogansichten](https://docs.microsoft.com/sql/relational-databases/system-catalog-views/security-catalog-views-transact-sql) in der Microsoft SQL Server-Dokumentation.
1. Löschen Sie die SQL Server Audit-Option von der DB-Instance. Wählen Sie eine der folgenden Optionen aus:
+ Löschen Sie die SQL Server Audit-Option aus der Optionsgruppe, die von der DB-Instance verwendet wird. Diese Änderung wirkt sich auf alle DB-Instances aus, die dieselbe Optionsgruppe verwenden. Weitere Informationen finden Sie unter [Entfernen einer Option aus einer Optionsgruppe](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Ändern Sie die DB-Instance und wählen Sie dann eine Optionsgruppe ohne SQL Server Audit-Option aus. Diese Änderung wirkt sich nur auf die DB-Instance aus, die Sie modifizieren. Sie können die (leere) Standardoptionsgruppe oder eine andere benutzerdefinierte Optionsgruppe angeben. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
1. Nach dem Löschen der SQL Server Audit-Option aus der DB-Instance müssen Sie die Instance nicht neu starten. Entfernen Sie nicht benötigte Überwachungsdateien aus Ihrem S3-Bucket.
# Verwenden von SQL Server Audit
Sie können Serverüberwachungen, Serverüberwachungs-Spezifikationen und Datenbanküberwachungs-Spezifikationen auf dieselbe Art steuern, wie Sie dies auch für Ihre lokalen Datenbankserver tun.
## Erstellen von Überwachungen
Sie erstellen Serverüberwachungen auf die gleiche Art wie Sie auch Überwachungen für lokale Datenbankserver erstellen. Weitere Informationen zum Erstellen von Serverüberwachungen finden Sie unter [CREATE SERVER AUDIT](https://docs.microsoft.com/sql/t-sql/statements/create-server-audit-transact-sql) in der Microsoft SQL Server-Dokumentation.
Halten Sie sich an die folgenden Beschränkungen, um Fehler zu vermeiden:
+ Überschreiten Sie nicht die maximale Anzahl unterstützter Serverüberwachungen von 50 pro Instance.
+ Weisen Sie SQL Server an, Daten in eine Binärdatei zu schreiben.
+ Verwenden Sie `RDS_` nicht als Präfix im Serverüberwachungsnamen.
+ Legen Sie für `FILEPATH` die Option `D:\rdsdbdata\SQLAudit` fest.
+ Geben Sie für `MAXSIZE` eine Größe zwischen 2 MB und 50 MB an.
+ Konfigurieren Sie nicht `MAX_ROLLOVER_FILES` oder `MAX_FILES`.
+ Konfigurieren Sie SQL Server nicht so, dass die DB-Instance heruntergefahren wird, wenn das Schreiben in den Überwachungsdatensatz fehlschlägt.
## Erstellen von Überwachungsspezifikationen
Sie erstellen Spezifikationen für Server- und Datenbanküberwachungen auf dieselbe Art und Weise, wie Sie dies auch für lokale Datenbankserver tun. Informationen zum Erstellen von Überwachungsspezifikationen finden Sie unter [CREATE SERVER AUDIT SPECIFICATION](https://docs.microsoft.com/sql/t-sql/statements/create-server-audit-specification-transact-sql) und [CREATE DATABASE AUDIT SPECIFICATION](https://docs.microsoft.com/sql/t-sql/statements/create-database-audit-specification-transact-sql) in der Microsoft SQL Server-Dokumentation.
Verwenden Sie `RDS_` nicht als Präfix im Namen der Spezifikation für die Server- oder Datenbanküberwachung, um Fehler zu vermeiden.
# Anzeigen von Audit-Protokollen
Ihre Audit-Protokolle werden in gespeicher `D:\rdsdbdata\SQLAudit`.
Nachdem SQL das Schreiben in die Audit-Protokolldatei abgeschlossen hat – nachdem die maximale Dateigröße erreicht wurde – lädt Amazon RDS die Datei in den S3-Bucket. Wenn die Aufbewahrung aktiviert ist, verschiebt Amazon RDS die Datei in den Aufbewahrungsordner: `D:\rdsdbdata\SQLAudit\transmitted`.
Informationen zu dem Konfigurieren der Aufbewahrung finden Sie unter [Hinzufügen von SQL Server Audit zu DB-Instance-Optionen](Appendix.SQLServer.Options.Audit.Adding.md).
Überwachungsdatensätze werden auf der DB-Instance aufbewahrt, bis die Audit-Protokolldatei hochgeladen wurde. Sie können die Überwachungsdatensätze anzeigen, wenn Sie den folgenden Befehl ausführen.
```
SELECT *
FROM msdb.dbo.rds_fn_get_audit_file
('D:\rdsdbdata\SQLAudit\*.sqlaudit'
, default
, default )
```
Sie können denselben Befehl zum Anzeigen der Überwachungsdatensätze in Ihrem Aufbewahrungsordner verwenden, indem Sie den Filter in änder `D:\rdsdbdata\SQLAudit\transmitted\*.sqlaudit`.
```
SELECT *
FROM msdb.dbo.rds_fn_get_audit_file
('D:\rdsdbdata\SQLAudit\transmitted\*.sqlaudit'
, default
, default )
```
## Verwenden von SQL Server Audit mit Multi-AZ-Instances
Bei Multi-AZ-Instances ähnelt der Prozess zum Senden von Audit-Protokolldateien an Amazon S3 dem Prozess bei Single-AZ-Instances. Es gibt jedoch einige wichtige Unterschiede:
+ Objekte der Spezifikation der Datenbanküberwachung werden auf allen Knoten repliziert.
+ Serverüberwachungen und Spezifikationen für Serverüberwachungen werden nicht auf sekundäre Knoten repliziert. Stattdessen müssen Sie diese manuell erstellen oder ändern.
So werden Serverüberwachungen oder eine Spezifikation für die Serverüberwachung von beiden Knoten erfasst:
1. Erstellen Sie eine Serverüberwachung oder eine Spezifikation für die Serverüberwachung auf dem primären Knoten.
1. Führen Sie ein Failover auf den sekundären Knoten durch und erstellen Sie eine Serverüberwachung oder eine Spezifikation für die Serverüberwachung mit demselben Namen und derselben GUID auf dem sekundären Knoten. Geben Sie die GUID mit dem Parameter `AUDIT_GUID` an.
# Konfigurieren eines S3-Buckets
Die Audit-Protokolldateien werden automatisch von der DB-Instance in Ihren S3-Bucket hochgeladen. Für den S3-Bucket, den Sie als Ziel für die Überwachungsdateien verwenden, gelten folgende Einschränkungen:
+ Sie muss sich in derselben AWS Region und demselben AWS Konto wie die DB-Instance befinden.
+ Er darf nicht öffentlich zugänglich sein.
+ Der Bucket-Eigentümer muss auch der Eigentümer der IAM-Rolle sein.
+ Ihre IAM-Rolle muss über Berechtigungen für den vom Kunden verwalteten KMS-Schlüssel verfügen, der mit der serverseitigen S3-Bucket-Verschlüsselung verknüpft ist.
Der Zielschlüssel, der zum Speichern der Daten verwendet wird, unterliegt folgendem Benennungsschema: `amzn-s3-demo-bucket/key-prefix/instance-name/audit-name/node_file-name.ext`
**Anmerkung**
Sie legen sowohl den Bucket-Namen als auch die Schlüsselpräfixwerte mit der Optionseinstellung `S3_BUCKET_ARN` fest.
Das Schema besteht aus den folgenden Elementen:
+ ***amzn-s3-demo-bucket*** – Der Name des S3-Buckets.
+ **`key-prefix`** – Das benutzerdefinierte Schlüsselpräfix, das Sie für die Audit-Protokolle verwenden möchten.
+ **`instance-name`** – Der Name Ihrer Amazon-RDS-Instance.
+ **`audit-name`** – Der Namen der Überwachung.
+ **`node`** – Die Kennung des Knotens, der die Quelle der Audit-Protokolle ist (`node1` oder `node2`). Es gibt einen Knoten für die Single-AZ-Instance und zwei Replikationsknoten für eine Multi-AZ-Instance. Dies sind keine primären und sekundären Knoten, da sich die Rolle für primär und sekundär mit der Zeit ändert. Stattdessen ist die Knoten-ID eine einfache Beschriftung.
+ **`node1`** – Der erste Replikationsknoten (bei Single-AZ gibt es nur einen Knoten).
+ **`node2`** – Der zweite Replikationsknoten (bei Multi-AZ gibt es zwei Knoten).
+ **`file-name`** – Der Name der Zieldatei. Der Dateiname wird von SQL Server unverändert übernommen.
+ **`ext`** – Die Erweiterung der Datei (`zip` oder `sqlaudit`):
+ **`zip`** – Bei aktivierter Komprimierung (Standard).
+ **`sqlaudit`** – Bei nicht aktivierter Komprimierung.
# Manuelles Erstellen einer IAM-Rolle für SQL Server Audit
Wenn Sie eine neue Option erstellen, werden in der Regel die IAM-Rolle und die IAM-Vertrauensrichtlinie für Sie AWS-Managementkonsole erstellt. Sie können jedoch manuell eine neue IAM-Rolle für die Verwendung mit SQL Server Audits erstellen, sodass Sie diese an mögliche weitere Anforderungen anpassen können. Dazu erstellen Sie eine IAM-Rolle und delegieren Berechtigungen, sodass der Amazon RDS-Service Ihren Amazon S3-Bucket verwenden kann. Beim Anlegen dieser IAM-Rolle geben Sie Vertrauens- und Berechtigungsrichtlinien an. Die Vertrauensrichtlinie erlaubt es Amazon RDS, diese Rolle zu übernehmen. Die Berechtigungsrichtlinie definiert die Aktionen, die über diese Rolle ausgeführt werden können. Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen für einen AWS Dienst](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) im *AWSIdentity and Access Management-Benutzerhandbuch*.
Sie können anhand der Beispiele in diesem Abschnitt die benötigten Vertrauensbeziehungen und Berechtigungsrichtlinien erstellen.
Das folgende Beispiel zeigt eine Vertrauensbeziehung für SQL Server Audit. Das *Service-Prinzipal* `rds.amazonaws.com` kommt zum Einsatz, um RDS das Schreiben in den S3-Bucket zu erlauben. Ein*Service-Prinzipal* ist eine Kennung, die verwendet wird, um einem Service Berechtigungen zu erteilen. Wann immer Sie auf diese Art Zugriff auf `rds.amazonaws.com` gewähren, erlauben Sie RDS, eine Aktion in Ihrem Namen auszuführen. Weitere Informationen zu Service-Prinzipalen finden Sie unter [AWSJSON-Richtlinienelemente: Prinzipal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html).
**Example Vertrauensbeziehung für SQL Server Audit**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) und [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) in ressourcenbasierten Vertrauensbeziehungen, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.
Sie können beide globalen Bedingungskontextschlüssel verwenden und der Wert `aws:SourceArn` enthält die Konto-ID. Stellen Sie in diesen Fällen sicher, dass der Wert `aws:SourceAccount` und das Konto im Wert `aws:SourceArn` dieselbe Konto-ID verwenden, wenn sie in derselben Anweisung verwendet werden.
+ Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
+ Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.
Stellen Sie in der Vertrauensbeziehung sicher, dass Sie den globalen Bedingungskontextschlüssel `aws:SourceArn` mit dem vollständigen Amazon-Ressourcennamen (ARN) der Ressourcen verwenden, die auf die Rolle zugreifen. Stellen Sie bei SQL Server Audit sicher, dass Sie sowohl die DB-Optionsgruppe als auch die DB-Instances einschließen, wie im folgenden Beispiel gezeigt.
**Example Vertrauensbeziehung mit dem globalen Bedingungskontextschlüssel für SQL Server Audit**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn": [
"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier",
"arn:aws:rds:Region:my_account_ID:og:option_group_name"
]
}
}
}
]
}
```
Im folgenden Beispiel einer Berechtigungsrichtlinie für SQL Server Audit, wird ein ARN für den Amazon S3 Bucket angegeben. Sie können ARNs damit ein bestimmtes Konto, einen bestimmten Benutzer oder eine bestimmte Rolle identifizieren, für die Sie Zugriff gewähren möchten. Weitere Informationen zur Verwendung ARNs finden Sie unter [Amazon-Ressourcennamen (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
**Example Berechtigungsrichtlinie für SQL Server Audit**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketACL",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/key_prefix/*"
}
]
}
```
**Anmerkung**
Die `s3:ListAllMyBuckets` Aktion ist erforderlich, um zu überprüfen, ob dasselbe AWS Konto sowohl den S3-Bucket als auch die SQL Server-DB-Instance besitzt. Die Aktion listet die Namen der Buckets in dem Konto auf.
S3-Bucket-Namespaces sind global. Wenn Sie Ihren Bucket versehentlich löschen, kann ein anderer Benutzer einen Bucket mit demselben Namen in einem anderen Konto erstellen. Dann werden die SQL Server-Prüfungsdaten in den neuen Bucket geschrieben.
# Unterstützung für SQL Server Analysis Services in Amazon RDS für SQL Server
Microsoft SQL Server Analysis Services (SSAS) ist Teil der Microsoft Business Intelligence (MSBI)-Suite. SSAS ist ein Online Analytical Processing (OLAP)- und Data Mining-Tool, das in SQL Server installiert ist. Sie verwenden SSAS, um Daten zu analysieren, anhand derer Sie Geschäftsentscheidungen treffen. SSAS unterscheidet sich von der relationalen SQL Server-Datenbank, da SSAS für Abfragen und Berechnungen optimiert ist, die in einer Business Intelligence-Umgebung üblich sind.
Sie können SSAS für vorhandene oder neue DB-Instances aktivieren. Es wird auf derselben DB-Instance wie Ihre Datenbank-Engine installiert. Weitere Informationen zu SSAS finden Sie in der Microsoft [Analysis Services-Dokumentation](https://docs.microsoft.com/en-us/analysis-services).
Amazon RDS unterstützt SSAS für SQL Server Standard und Enterprise Editions in den folgenden Versionen:
+ Tabellarischer Modus:
+ SQL Server 2019, Version 15.00.4043.16.v1 und höher
+ SQL Server 2017, Version 14.00.3223.3.v1 und höher
+ SQL Server 2016, version 13.00.5426.0.v1 und höher
+ Mehrdimensionaler Modus:
+ SQL Server 2019, Version 15.00.4153.1.v1 und höher
+ SQL Server 2017, Version 14.00.3381.3.v1 und höher
+ SQL Server 2016, Version 13.00.5882.1.v1 und höher
**Contents**
+ [
## Einschränkungen
](#SSAS.Limitations)
+ [
# Aktivieren von SSAS
](SSAS.Enabling.md)
+ [
## Erstellen einer Optionsgruppe für SSAS
](SSAS.Enabling.md#SSAS.OptionGroup)
+ [
## Hinzufügen der SSAS-Option zur Optionsgruppe
](SSAS.Enabling.md#SSAS.Add)
+ [
## Zuordnen der Optionsgruppe zu Ihrer DB-Instance
](SSAS.Enabling.md#SSAS.Apply)
+ [
## Zulassen des eingehenden Zugriffs auf Ihre VPC-Sicherheitsgruppe
](SSAS.Enabling.md#SSAS.InboundRule)
+ [
## Aktivieren der Amazon-S3-Integration
](SSAS.Enabling.md#SSAS.EnableS3)
+ [
# Bereitstellen von SSAS-Projekten auf Amazon RDS
](SSAS.Deploy.md)
+ [
# Überwachen des Status einer Bereitstellungsaufgabe
](SSAS.Monitor.md)
+ [
# Verwenden von SSAS auf Amazon RDS
](SSAS.Use.md)
+ [
## Einrichten eines Windows-authentifizierten Benutzers für SSAS
](SSAS.Use.md#SSAS.Use.Auth)
+ [
## Hinzufügen eines Domänenbenutzers als Datenbankadministrator
](SSAS.Use.md#SSAS.Admin)
+ [
## Erstellen eines SSAS-Proxys
](SSAS.Use.md#SSAS.Use.Proxy)
+ [
## Planen der SSAS-Datenbankverarbeitung mit SQL Server Agent
](SSAS.Use.md#SSAS.Use.Schedule)
+ [
## Widerrufen des SSAS-Zugriffs vom Proxy
](SSAS.Use.md#SSAS.Use.Revoke)
+ [
# Sichern einer SSAS-Datenbank
](SSAS.Backup.md)
+ [
# Wiederherstellen einer SSAS-Datenbank
](SSAS.Restore.md)
+ [
## Wiederherstellen einer DB-Instance zu einer bestimmten Zeit
](SSAS.Restore.md#SSAS.PITR)
+ [
# Ändern des SSAS-Modus
](SSAS.ChangeMode.md)
+ [
# Deaktivieren von SSAS
](SSAS.Disable.md)
+ [
# Fehlerbehebung von SSAS-Problemen
](SSAS.Trouble.md)
## Einschränkungen
Die folgenden Einschränkungen gelten für die Verwendung von SSAS auf RDS-for-SQL-Server:
+ RDS für SQL Server unterstützt die Ausführung von SSAS im tabellarischen oder mehrdimensionalen Modus. Weitere Informationen finden Sie unter [Comparing tabular and multidimensional solutions](https://docs.microsoft.com/en-us/analysis-services/comparing-tabular-and-multidimensional-solutions-ssas) in der Microsoft-Dokumentation.
+ Sie können jeweils nur einen SSAS-Modus verwenden. Bevor Sie den Modus ändern, sollten Sie alle SSAS-Datenbanken löschen.
Weitere Informationen finden Sie unter [Ändern des SSAS-Modus](SSAS.ChangeMode.md).
+ Multi-AZ-Instances werden nicht unterstützt.
+ Instances müssen selbstverwaltetes Active Directory oder AWS Directory Service for Microsoft Active Directory für die SSAS-Authentifizierung verwenden. Weitere Informationen finden Sie unter [Arbeiten mit Active Directory mit RDS für SQL Server](User.SQLServer.ActiveDirectoryWindowsAuth.md).
+ Benutzer erhalten keinen SSAS-Serveradministratorzugriff, können jedoch Administratorzugriff auf Datenbankebene erhalten.
+ Der einzige unterstützte Port für den Zugriff auf SSAS ist 2383.
+ Projekte können nicht direkt bereitgestellt werden. Dazu stellen wir eine gespeicherte RDS-Prozedur bereit. Weitere Informationen finden Sie unter [Bereitstellen von SSAS-Projekten auf Amazon RDS](SSAS.Deploy.md).
+ Die Verarbeitung während der Bereitstellung wird nicht unterstützt.
+ Die Verwendung von XMLA-Dateien für die Bereitstellung wird nicht unterstützt.
+ SSAS-Projekteingabedateien und Datenbanksicherungs-Ausgabedateien können sich nur im `D:\S3`-Ordner der DB-Instance befinden.
# Aktivieren von SSAS
Verwenden Sie den folgenden Prozess, um SSAS für Ihre DB-Instance zu aktivieren:
1. Erstellen Sie eine neue Optionsgruppe oder wählen Sie eine bestehende Optionsgruppe aus.
1. Fügen Sie die Option `SSAS` zur Optionsgruppe hinzu.
1. Ordnen Sie die Optionsgruppe der DB-Instance zu.
1. Erlauben Sie eingehenden Zugriff auf die (VPC)-Sicherheitsgruppe (Virtual Private Cloud) für den SSRS-Listener-Port.
1. Aktivieren der Amazon-S3-Integration
## Erstellen einer Optionsgruppe für SSAS
Verwenden Sie die AWS-Managementkonsole oder AWS CLI, um eine Optionsgruppe zu erstellen, die der SQL Server-Engine und der Version der DB-Instance entspricht, die Sie verwenden möchten.
**Anmerkung**
Sie können auch eine vorhandene Optionsgruppe verwenden, wenn es sich um die korrekte SQL Server-Engine und -Version handelt.
### Konsole
Mit der folgenden Konsolenprozedur wird eine Optionsgruppe für SQL Server Standard Edition 2017 erstellt.
**So erstellen Sie die Optionsgruppe**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group (Gruppe erstellen)** aus.
1. Führen Sie im Bereich **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie unter **Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihres AWS-Kontos nur einmal vorkommt, z. B. **ssas-se-2017**. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein, z. B. **SSAS option group for SQL Server SE 2017**. Die Beschreibung ist nur zur Information.
1. Wählen Sie für **Engine** die Option **sqlserver-se** aus.
1. Wählen Sie im Feld **Major Engine Version (Engine-Hauptversion)** **14.00** aus.
1. Wählen Sie **Erstellen** aus.
### CLI
Im folgenden CLI-Beispiel wird eine Optionsgruppe für SQL Server Standard Edition 2017 erstellt.
**So erstellen Sie die Optionsgruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name ssas-se-2017 \
--engine-name sqlserver-se \
--major-engine-version 14.00 \
--option-group-description "SSAS option group for SQL Server SE 2017"
```
Für Windows:
```
aws rds create-option-group ^
--option-group-name ssas-se-2017 ^
--engine-name sqlserver-se ^
--major-engine-version 14.00 ^
--option-group-description "SSAS option group for SQL Server SE 2017"
```
## Hinzufügen der SSAS-Option zur Optionsgruppe
Verwenden Sie als Nächstes die AWS-Managementkonsole oder AWS CLI, um die Option `SSAS` zur Optionsgruppe hinzuzufügen.
### Konsole
**So fügen Sie die Option SSAS hinzu**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe aus, die Sie gerade erstellt haben.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. Wählen Sie unter **Option details (Optionsdetails)** für **Option name (Optionsname)** die Option **SSAS** aus.
1. Führen Sie unter **Optionseinstellungen** die folgenden Schritte aus:
1. Geben Sie für **Max memory** (Maximaler Speicher) einen Wert im Bereich von 10 bis 80 ein.
**Max memory (Max. Speicher)** gibt den oberen Schwellenwert an, über dem SSAS beginnt, Speicher aggressiver freizugeben, um Platz für gerade ausgeführte Anforderungen und auch neue Anforderungen mit hoher Priorität zu schaffen. Die Zahl ist ein Prozentsatz des Gesamtspeichers der DB-Instance. Der erlaubte Wertebereich liegt zwischen 10–80; der Standardwert ist 45.
1. Wählen Sie für **Mode** (Modus) den SSAS-Servermodus **Tabular** (Tabellarisch) oder **Multidimensional** (Multidimensional) aus.
Wenn Ihnen die Einstellung **Mode** (Modus) nicht angezeigt wird, bedeutet das, dass der multidimensionale Modus in Ihrer AWS-Region nicht unterstützt wird. Weitere Informationen finden Sie unter [Einschränkungen](Appendix.SQLServer.Options.SSAS.md#SSAS.Limitations).
**Tabular** (Tabellarisch) ist die Standardeinstellung.
1. Wählen Sie für **Security groups (Sicherheitsgruppen)** die VPC-Sicherheitsgruppe aus, die der Option zugeordnet werden soll.
**Anmerkung**
Der Port für den Zugriff auf SSAS, 2383, ist vorbelegt.
1. Wählen Sie unter **Scheduling (Planung)** aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
### CLI
**So fügen Sie die Option SSAS hinzu**
1. Erstellen Sie beispielsweise `ssas-option.json`, eine JSON-Datei mit den folgenden Parametern:
+ `OptionGroupName` – Der Name der Optionsgruppe, die Sie zuvor erstellt oder ausgewählt haben (`ssas-se-2017` im folgenden Beispiel).
+ `Port` – Der Port, den Sie für den Zugriff auf SSAS verwenden. Der einzige unterstützte Port ist 2383.
+ `VpcSecurityGroupMemberships` – Mitgliedschaften für VPC-Sicherheitsgruppen für Ihre RDS-DB-Instance.
+ `MAX_MEMORY` – Der obere Schwellenwert, über dem SSAS beginnen sollte, Speicher aggressiver freizugeben, um Platz für gerade ausgeführte oder neue Anforderungen mit hoher Priorität zu schaffen. Die Zahl ist ein Prozentsatz des Gesamtspeichers der DB-Instance. Der erlaubte Wertebereich liegt zwischen 10–80; der Standardwert ist 45.
+ `MODE` – Der SSAS-Servermodus ist entweder `Tabular` oder `Multidimensional`. `Tabular` ist die Standardeinstellung.
Wenn Sie einen Fehler erhalten, dass die `MODE`-Einstellung nicht gültig ist, bedeutet das, dass der multidimensionale Modus in Ihrer AWS-Region nicht unterstützt wird. Weitere Informationen finden Sie unter [Einschränkungen](Appendix.SQLServer.Options.SSAS.md#SSAS.Limitations).
Nachfolgend finden Sie ein Beispiel für eine JSON-Datei mit SSAS-Optionseinstellungen.
```
{
"OptionGroupName": "ssas-se-2017",
"OptionsToInclude": [
{
"OptionName": "SSAS",
"Port": 2383,
"VpcSecurityGroupMemberships": ["sg-0abcdef123"],
"OptionSettings": [{"Name":"MAX_MEMORY","Value":"60"},{"Name":"MODE","Value":"Multidimensional"}]
}],
"ApplyImmediately": true
}
```
1. Fügen Sie die Option `SSAS` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--cli-input-json file://ssas-option.json \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--cli-input-json file://ssas-option.json ^
--apply-immediately
```
## Zuordnen der Optionsgruppe zu Ihrer DB-Instance
Sie können die Konsole oder die CLI verwenden, um die Optionsgruppe Ihrer DB-Instance zuzuordnen.
### Konsole
Ordnen Sie Ihre Optionsgruppe einer neuen oder vorhandenen DB-Instance zu:
+ Ordnen Sie bei einer neuen DB-Instance die Optionsgruppe der DB-Instance beim Start zu. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ändern Sie für eine vorhandene DB-Instance die Instance und ordnen Sie ihr die neue Optionsgruppe zu. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
**Anmerkung**
Wenn Sie eine vorhandene Instance verwenden, muss ihr bereits eine Active Directory-Domäne und eine AWS Identity and Access Management-(IAM)-Rolle zugeordnet sein. Wenn Sie eine neue Instance erstellen, geben Sie eine vorhandene Active Directory-Domäne und IAM-Rolle an. Weitere Informationen finden Sie unter [Arbeiten mit Active Directory mit RDS für SQL Server](User.SQLServer.ActiveDirectoryWindowsAuth.md).
### CLI
Sie können Ihre Optionsgruppe einer neuen oder vorhandenen DB-Instance zuordnen.
**Anmerkung**
Wenn Sie eine vorhandene Instance verwenden, muss ihr bereits eine Active Directory-Domäne und eine IAM-Rolle zugeordnet sein. Wenn Sie eine neue Instance erstellen, geben Sie eine vorhandene Active Directory-Domäne und IAM-Rolle an. Weitere Informationen finden Sie unter [Arbeiten mit Active Directory mit RDS für SQL Server](User.SQLServer.ActiveDirectoryWindowsAuth.md).
**So erstellen Sie eine DB-Instance, welche die Optionsgruppe verwendet**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier myssasinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 14.00.3223.3.v1 \
--allocated-storage 100 \
--manage-master-user-password \
--master-username admin \
--storage-type gp2 \
--license-model li \
--domain-iam-role-name my-directory-iam-role \
--domain my-domain-id \
--option-group-name ssas-se-2017
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier myssasinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 14.00.3223.3.v1 ^
--allocated-storage 100 ^
--manage-master-user-password ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--domain-iam-role-name my-directory-iam-role ^
--domain my-domain-id ^
--option-group-name ssas-se-2017
```
**So ändern Sie eine DB-Instance, um die Optionsgruppe zuzuordnen**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier myssasinstance \
--option-group-name ssas-se-2017 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier myssasinstance ^
--option-group-name ssas-se-2017 ^
--apply-immediately
```
## Zulassen des eingehenden Zugriffs auf Ihre VPC-Sicherheitsgruppe
Erstellen Sie eine Regel für eingehenden Datenverkehr für den angegebenen SSAS-Listener-Port in der VPC-Sicherheitsgruppe, die Ihrer DB-Instance zugeordnet ist. Weitere Informationen zum Einrichten von Sicherheitsgruppen finden Sie unter [Ermöglichen des Zugriffs auf Ihre DB-Instance in der VPC durch Erstellen einer Sicherheitsgruppe](CHAP_SettingUp.md#CHAP_SettingUp.SecurityGroup).
## Aktivieren der Amazon-S3-Integration
Verwenden Sie die Amazon-S3-Integration, um Modellkonfigurationsdateien für die Bereitstellung auf Ihren Host herunterzuladen. Weitere Informationen finden Sie unter [Integration einer Amazon RDS für SQL Server-DB-Instance mit Amazon S3](User.SQLServer.Options.S3-integration.md).
# Bereitstellen von SSAS-Projekten auf Amazon RDS
Auf RDS können Sie SSAS-Projekte nicht direkt mithilfe von SQL Server Management Studio (SSMS) bereitstellen. Verwenden Sie zum Bereitstellen von Projekten eine gespeicherte RDS-Prozedur.
**Anmerkung**
Die Verwendung von XMLA-Dateien für die Bereitstellung wird nicht unterstützt.
Stellen Sie vor der Bereitstellung von Projekten Folgendes sicher:
+ Die Amazon-S3-Integration ist aktiviert. Weitere Informationen finden Sie unter [Integration einer Amazon RDS für SQL Server-DB-Instance mit Amazon S3](User.SQLServer.Options.S3-integration.md).
+ Die `Processing Option`-Konfigurationseinstellung ist auf `Do Not Process` eingestellt. Diese Einstellung bedeutet, dass nach der Bereitstellung keine Verarbeitung erfolgt.
+ Sie verfügen über die Dateien `myssasproject.asdatabase` und `myssasproject.deploymentoptions`. Diese werden automatisch generiert, wenn Sie ein SSAS-Projekt erstellen.
**So stellen Sie ein SSAS-Projekt auf RDS bereit**
1. Laden Sie die `.asdatabase` (SSAS-Modell)-Datei aus Ihrem S3-Bucket in Ihre DB-Instance herunter, wie im folgenden Beispiel gezeigt. Weitere Informationen zu den Download-Parametern finden Sie unter [Herunterladen von Dateien aus einem Amazon S3-Bucket zu einer SQL Server-DB-Instance](Appendix.SQLServer.Options.S3-integration.using.md#Appendix.SQLServer.Options.S3-integration.using.download).
```
exec msdb.dbo.rds_download_from_s3
@s3_arn_of_file='arn:aws:s3:::bucket_name/myssasproject.asdatabase',
[@rds_file_path='D:\S3\myssasproject.asdatabase'],
[@overwrite_file=1];
```
1. Laden Sie die `.deploymentoptions`-Datei aus Ihrem S3-Bucket in Ihre DB-Instance herunter.
```
exec msdb.dbo.rds_download_from_s3
@s3_arn_of_file='arn:aws:s3:::bucket_name/myssasproject.deploymentoptions',
[@rds_file_path='D:\S3\myssasproject.deploymentoptions'],
[@overwrite_file=1];
```
1. Stellen Sie das Projekt bereit.
```
exec msdb.dbo.rds_msbi_task
@task_type='SSAS_DEPLOY_PROJECT',
@file_path='D:\S3\myssasproject.asdatabase';
```
# Überwachen des Status einer Bereitstellungsaufgabe
Rufen Sie die Funktion `rds_fn_task_status` auf, um den Status Ihrer Bereitstellungs- (oder Download)-Aufgabe zu verfolgen. Dazu sind zwei Parameter erforderlich. Der erste Parameter sollte immer `NULL` sein, da er sich nicht auf SSAS bezieht. Der zweite Parameter akzeptiert eine Aufgaben-ID.
Um eine Liste aller Aufgaben anzuzeigen, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf `0`, wie im folgenden Beispiel gezeigt.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```
Um eine bestimmte Aufgabe zu erhalten, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf die Aufgaben-ID, wie im folgenden Beispiel gezeigt,
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```
Die `rds_fn_task_status`-Funktion gibt die folgenden Informationen zurück.
| Ausgabeparameter | Beschreibung |
| --- | --- |
| `task_id` | Die ID der Aufgabe. |
| `task_type` | Für SSAS können Aufgaben die folgenden Aufgabentypen haben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SSAS.Monitor.html) |
| `database_name` | Gilt nicht für SSAS-Aufgaben. |
| `% complete` | Verlauf der Aufgabe als Prozentwert. |
| `duration (mins)` | Zeitdauer für die Ausführung der Aufgabe (in Minuten). |
| `lifecycle` | Der Status der Aufgabe. Die folgenden Status sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SSAS.Monitor.html) |
| `task_info` | Zusätzliche Informationen über die Aufgabe. Wenn bei der Verarbeitung ein Fehler auftritt, enthält diese Spalte Informationen zu dem Fehler. Weitere Informationen finden Sie unter [Fehlerbehebung von SSAS-Problemen](SSAS.Trouble.md). |
| `last_updated` | Datum und Uhrzeit der letzten Aktualisierung des Aufgabenstatus. |
| `created_at` | Datum und Uhrzeit, an denen die Aufgabe angelegt wurde. |
| `S3_object_arn` | Gilt nicht für SSAS-Aufgaben. |
| `overwrite_S3_backup_file` | Gilt nicht für SSAS-Aufgaben. |
| `KMS_master_key_arn` | Gilt nicht für SSAS-Aufgaben. |
| `filepath` | Gilt nicht für SSAS-Aufgaben. |
| `overwrite_file` | Gilt nicht für SSAS-Aufgaben. |
| `task_metadata` | Metadaten, die der SSAS-Aufgabe zugeordnet sind. |
# Verwenden von SSAS auf Amazon RDS
Nach der Bereitstellung des SSAS-Projekts können Sie die OLAP-Datenbank direkt auf SSMS verarbeiten.
**So verwenden Sie SSAS auf RDS**
1. Stellen Sie in SSMS eine Verbindung mit SSAS her, indem Sie den Benutzernamen und das Passwort für die Active Directory-Domäne verwenden.
1. Erweitern Sie **Databases (Datenbanken)**. Die neu bereitgestellte SSAS-Datenbank wird angezeigt.
1. Suchen Sie nach der Verbindungszeichenfolge und aktualisieren Sie den Benutzernamen und das Passwort, um Zugriff auf die SQL-Quelldatenbank zu erteilen. Dies ist für die Verarbeitung von SSAS-Objekten erforderlich.
1. Führen Sie für den tabellarischen Modus folgende Schritte aus:
1. Zeigen Sie die Registerkarte **Connections** (Verbindungen) an.
1. Öffnen Sie das Kontextmenü (rechte Maustaste) für das Verbindungsobjekt und wählen Sie dann **Properties** (Eigenschaften) aus.
1. Aktualisieren Sie den Benutzernamen und das Passwort in der Verbindungszeichenfolge.
1. Führen Sie für den multidimensionalen Modus folgende Schritte aus:
1. Zeigen Sie die Registerkarte **Data Sources** (Datenquellen) an.
1. Öffnen Sie das Kontextmenü (rechte Maustaste) für das Datenquellobjekt und wählen Sie dann **Properties** (Eigenschaften) aus.
1. Aktualisieren Sie den Benutzernamen und das Passwort in der Verbindungszeichenfolge.
1. Öffnen Sie das Kontextmenü (rechte Maustaste) für die SSAS-Datenbank, die Sie erstellt haben, und wählen Sie **Process Database (Datenbank verarbeiten)** aus.
Abhängig vom Umfang der Eingabedaten kann der Verarbeitungsvorgang einige Minuten dauern.
**Topics**
+ [
## Einrichten eines Windows-authentifizierten Benutzers für SSAS
](#SSAS.Use.Auth)
+ [
## Hinzufügen eines Domänenbenutzers als Datenbankadministrator
](#SSAS.Admin)
+ [
## Erstellen eines SSAS-Proxys
](#SSAS.Use.Proxy)
+ [
## Planen der SSAS-Datenbankverarbeitung mit SQL Server Agent
](#SSAS.Use.Schedule)
+ [
## Widerrufen des SSAS-Zugriffs vom Proxy
](#SSAS.Use.Revoke)
## Einrichten eines Windows-authentifizierten Benutzers für SSAS
Der Hauptadministrator (manchmal auch als Hauptnutzer bezeichnet) kann das folgende Codebeispiel verwenden, um eine Windows-authentifizierte Anmeldung einzurichten und die erforderlichen Prozessberechtigungen zu erteilen. Dadurch werden dem Domänenbenutzer Berechtigungen zum Ausführen von SSAS-Kundenaufgaben, zum Verwenden von S3-Dateiübertragungsverfahren, zum Erstellen von Anmeldeinformationen und zum Arbeiten mit dem SQL-Server-Agent-Proxy gewährt. Weitere Informationen finden Sie unter [Anmeldeinformationen (Datenbank-Engine)](https://docs.microsoft.com/en-us/sql/relational-databases/security/authentication-access/credentials-database-engine?view=sql-server-ver15) und [Erstellen eines SQL Server-Agent-Proxys](https://docs.microsoft.com/en-us/sql/ssms/agent/create-a-sql-server-agent-proxy?view=sql-server-ver15) in der Microsoft-Dokumentation.
Sie können Windows-authentifizierten Benutzern bei Bedarf einige oder alle der folgenden Berechtigungen erteilen.
**Example**
```
-- Create a server-level domain user login, if it doesn't already exist
USE [master]
GO
CREATE LOGIN [mydomain\user_name] FROM WINDOWS
GO
-- Create domain user, if it doesn't already exist
USE [msdb]
GO
CREATE USER [mydomain\user_name] FOR LOGIN [mydomain\user_name]
GO
-- Grant necessary privileges to the domain user
USE [master]
GO
GRANT ALTER ANY CREDENTIAL TO [mydomain\user_name]
GO
USE [msdb]
GO
GRANT EXEC ON msdb.dbo.rds_msbi_task TO [mydomain\user_name] with grant option
GRANT SELECT ON msdb.dbo.rds_fn_task_status TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_task_status TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_cancel_task TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_download_from_s3 TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_upload_to_s3 TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_delete_from_filesystem TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_gather_file_details TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_add_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_update_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_grant_login_to_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_revoke_login_from_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_delete_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_enum_login_for_proxy to [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_enum_proxy_for_subsystem TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_sqlagent_proxy TO [mydomain\user_name] with grant option
ALTER ROLE [SQLAgentUserRole] ADD MEMBER [mydomain\user_name]
GO
```
## Hinzufügen eines Domänenbenutzers als Datenbankadministrator
Sie können einen Domänenbenutzer als SSAS-Datenbankadministrator auf folgende Weise hinzufügen:
+ Ein Datenbankadministrator kann SSMS verwenden, um eine Rolle mit der Berechtigung `admin` zu erstellen und dann Benutzer zu dieser Rolle hinzufügen.
+ Sie können die folgende gespeicherte Prozedur verwenden.
```
exec msdb.dbo.rds_msbi_task
@task_type='SSAS_ADD_DB_ADMIN_MEMBER',
@database_name='myssasdb',
@ssas_role_name='exampleRole',
@ssas_role_member='domain_name\domain_user_name';
```
Die folgenden Parameter sind erforderlich:
+ `@task_type` – Der Typ der MSBI-Aufgabe, in diesem Fall `SSAS_ADD_DB_ADMIN_MEMBER`.
+ `@database_name` – Der Name der SSAS-Datenbank, der Sie Administratorrechte gewähren.
+ `@ssas_role_name` – Der Name der SSAS-Datenbankadministratorrolle. Wenn die Rolle noch nicht vorhanden ist, wird sie erstellt.
+ `@ssas_role_member` – Der SSAS-Datenbankbenutzer, den Sie der Administratorrolle hinzufügen.
## Erstellen eines SSAS-Proxys
Um die SSAS-Datenbankverarbeitung mit SQL Server Agent planen zu können, erstellen Sie SSAS-Anmeldeinformationen und einen SSAS-Proxy. Führen Sie diese Prozeduren als Windows-authentifizierter Benutzer aus.
**Erstellen von SSAS-Anmeldeinformationen**
+ Erstellen Sie die Anmeldeinformationen für den Proxy. Dazu können Sie SSMS oder die folgende SQL-Anweisung verwenden.
```
USE [master]
GO
CREATE CREDENTIAL [SSAS_Credential] WITH IDENTITY = N'mydomain\user_name', SECRET = N'mysecret'
GO
```
**Anmerkung**
`IDENTITY` muss eine domänenauthentifizierter Anmeldung sein. Ersetzen Sie `mysecret` durch das Passwort für die domänenauthentifizierte Anmeldung.
**Erstellen des SSAS-Proxys**
1. Verwenden Sie die folgende SQL-Anweisung, um den Proxy zu erstellen.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_add_proxy @proxy_name=N'SSAS_Proxy',@credential_name=N'SSAS_Credential',@description=N''
GO
```
1. Verwenden Sie die folgende SQL-Anweisung, um anderen Benutzern den Zugriff auf den Proxy zu gewähren.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_grant_login_to_proxy @proxy_name=N'SSAS_Proxy',@login_name=N'mydomain\user_name'
GO
```
1. Verwenden Sie die folgende SQL-Anweisung, um dem SSAS-Subsystem Zugriff auf den Proxy zu gewähren.
```
USE [msdb]
GO
EXEC msdb.dbo.rds_sqlagent_proxy @task_type='GRANT_SUBSYSTEM_ACCESS',@proxy_name='SSAS_Proxy',@proxy_subsystem='SSAS'
GO
```
**So zeigen Sie den Proxy und die Berechtigungserteilungen für den Proxy an**
1. Verwenden Sie die folgende SQL-Anweisung, um die Empfänger des Proxys anzuzeigen.
```
USE [msdb]
GO
EXEC sp_help_proxy
GO
```
1. Verwenden Sie die folgende SQL-Anweisung, um die Subsystemzuweisungen anzuzeigen.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_enum_proxy_for_subsystem
GO
```
## Planen der SSAS-Datenbankverarbeitung mit SQL Server Agent
Nachdem Sie die Anmeldeinformationen und den Proxy erstellt und SSAS-Zugriff auf den Proxy gewährt haben, können Sie einen SQL-Server-Agent-Auftrag erstellen, um die SSAS-Datenbankverarbeitung zu planen.
**Planen der SSAS-Datenbankverarbeitung**
+ Verwenden Sie SSMS oder T-SQL zum Erstellen des SQL-Server-Agent-Auftrags. Im folgenden Beispiel wird T-SQL verwendet. Sie können den Auftragszeitplan über SSMS oder T-SQL weiter konfigurieren.
+ Der Parameter `@command` beschreibt den Befehl XML for Analysis (XMLA), der vom SQL-Server-Agent-Auftrag ausgeführt werden soll. In diesem Beispiel wird die mehrdimensionale SSAS-Datenbankverarbeitung konfiguriert.
+ Der Parameter `@server` beschreibt den Ziel-SSAS-Servernamen des SQL-Server-Agent-Auftrags.
Um den SSAS-Dienst innerhalb derselben RDS-DB-Instance aufzurufen, in der sich der SQL-Server-Agent-Auftrag befindet, verwenden Sie `localhost:2383`.
Um den SSAS-Dienst von außerhalb der RDS-DB-Instance aufzurufen, verwenden Sie den RDS-Endpunkt. Sie können auch den Endpunkt von Kerberos Active Directory (AD) verwenden (`your-DB-instance-name.your-AD-domain-name`) wenn die RDS-DB-Instances von derselben Domäne verbunden werden. Stellen Sie bei externen DB-Instances sicher, dass Sie die VPC-Sicherheitsgruppe, die mit der RDS-DB-Instance verknüpft ist, ordnungsgemäß für eine sichere Verbindung konfigurieren.
Sie können die Abfrage weiter bearbeiten, um verschiedene XMLA-Operationen zu unterstützen. Nehmen Sie Änderungen vor, indem Sie die T-SQL-Abfrage direkt ändern oder die SSMS-Benutzeroberfläche nach der Erstellung von SQL-Server-Agent-Aufträgen verwenden.
```
USE [msdb]
GO
DECLARE @jobId BINARY(16)
EXEC msdb.dbo.sp_add_job @job_name=N'SSAS_Job',
@enabled=1,
@notify_level_eventlog=0,
@notify_level_email=0,
@notify_level_netsend=0,
@notify_level_page=0,
@delete_level=0,
@category_name=N'[Uncategorized (Local)]',
@job_id = @jobId OUTPUT
GO
EXEC msdb.dbo.sp_add_jobserver
@job_name=N'SSAS_Job',
@server_name = N'(local)'
GO
EXEC msdb.dbo.sp_add_jobstep @job_name=N'SSAS_Job', @step_name=N'Process_SSAS_Object',
@step_id=1,
@cmdexec_success_code=0,
@on_success_action=1,
@on_success_step_id=0,
@on_fail_action=2,
@on_fail_step_id=0,
@retry_attempts=0,
@retry_interval=0,
@os_run_priority=0, @subsystem=N'ANALYSISCOMMAND',
@command=N'ProcessFullUseExisting',
@server=N'localhost:2383',
@database_name=N'master',
@flags=0,
@proxy_name=N'SSAS_Proxy'
GO
```
## Widerrufen des SSAS-Zugriffs vom Proxy
Sie können den Zugriff auf das SSAS-Subsystem widerrufen und den SSAS-Proxy mithilfe der folgenden gespeicherten Prozesse löschen.
**So entziehen Sie den Zugriff und löschen den Proxy**
1. Widerrufen des Teilsystemzugriffs.
```
USE [msdb]
GO
EXEC msdb.dbo.rds_sqlagent_proxy @task_type='REVOKE_SUBSYSTEM_ACCESS',@proxy_name='SSAS_Proxy',@proxy_subsystem='SSAS'
GO
```
1. Widerrufen Sie die für den erteilten Berechtigungen Proxy.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_revoke_login_from_proxy @proxy_name=N'SSAS_Proxy',@name=N'mydomain\user_name'
GO
```
1. Löschen Sie den Proxy.
```
USE [msdb]
GO
EXEC dbo.sp_delete_proxy @proxy_name = N'SSAS_Proxy'
GO
```
# Sichern einer SSAS-Datenbank
Sie können SSAS-Datenbanksicherungsdateien nur im Ordner `D:\S3` der DB-Instance erstellen. Verwenden Sie Amazon S3, um die Sicherungsdateien in Ihren S3-Bucket zu verschieben.
Sie können eine SSAS-Datenbank wie folgt sichern:
+ Ein Domänenbenutzer mit der Rolle `admin` für eine bestimmte Datenbank kann SSMS verwenden, um die Datenbank im Ordner `D:\S3` zu sichern.
Weitere Informationen finden Sie unter [Hinzufügen eines Domänenbenutzers als Datenbankadministrator](SSAS.Use.md#SSAS.Admin).
+ Sie können die folgende gespeicherte Prozedur verwenden. Der gespeicherte Prozess unterstützt keine Verschlüsselung.
```
exec msdb.dbo.rds_msbi_task
@task_type='SSAS_BACKUP_DB',
@database_name='myssasdb',
@file_path='D:\S3\ssas_db_backup.abf',
[@ssas_apply_compression=1],
[@ssas_overwrite_file=1];
```
Die folgenden Parameter sind erforderlich:
+ `@task_type` – Der Typ der MSBI-Aufgabe, in diesem Fall `SSAS_BACKUP_DB`.
+ `@database_name` – Der Name der SSAS-Datenbank, die Sie sichern.
+ `@file_path` – Der Pfad für die SSAS-Sicherungsdatei. Die Erweiterung `.abf` ist erforderlich.
Die folgenden Parameter sind optional:
+ `@ssas_apply_compression` – Gibt an, ob SSAS-Sicherungen komprimiert werden sollen. Gültige Werte sind 1 (Ja) und 0 (Nein).
+ `@ssas_overwrite_file` – Gibt an, ob die SSAS-Sicherungsdatei überschrieben werden soll. Gültige Werte sind 1 (Ja) und 0 (Nein).
# Wiederherstellen einer SSAS-Datenbank
Verwenden Sie die folgende gespeicherte Prozedur, um eine SSAS-Datenbank aus einer Sicherung wiederherzustellen.
Sie können eine Datenbank nicht wiederherstellen, wenn eine vorhandene SSAS-Datenbank mit demselben Namen vorhanden ist. Die gespeicherte Prozedur zum Wiederherstellen unterstützt keine verschlüsselten Sicherungsdateien.
```
exec msdb.dbo.rds_msbi_task
@task_type='SSAS_RESTORE_DB',
@database_name='mynewssasdb',
@file_path='D:\S3\ssas_db_backup.abf';
```
Die folgenden Parameter sind erforderlich:
+ `@task_type` – Der Typ der MSBI-Aufgabe, in diesem Fall `SSAS_RESTORE_DB`.
+ `@database_name` – Der Name der neuen SSAS-Datenbank, in der Sie die Wiederherstellung durchführen.
+ `@file_path` – Der Pfad zur SSAS-Sicherungsdatei.
## Wiederherstellen einer DB-Instance zu einer bestimmten Zeit
Zeitpunktbezogene Wiederherstellung (PITR) gilt nicht für SSAS-Datenbanken. Wenn Sie PITR ausführen, sind nur die SSAS-Daten im letzten Snapshot vor der angeforderten Zeit auf der wiederhergestellten Instance verfügbar.
**So haben Sie aktuelle SSAS-Datenbanken auf einer wiederhergestellten DB-Instance**
1. Sichern Sie Ihre SSAS-Datenbanken im Ordner `D:\S3` der Quellinstance.
1. Übertragen Sie die Sicherungsdateien in den S3-Bucket.
1. Übertragen Sie die Sicherungsdateien aus dem S3-Bucket in den Ordner `D:\S3` auf der wiederhergestellten Instance.
1. Führen Sie die gespeicherte Prozedur aus, um die SSAS-Datenbanken auf der wiederhergestellten Instance wiederherzustellen.
Sie können das SSAS-Projekt auch erneut verarbeiten, um die Datenbanken wiederherzustellen.
# Ändern des SSAS-Modus
Sie können den Modus ändern, in dem SSAS ausgeführt wird – entweder tabellarisch oder mehrdimensional. Um den Modus zu ändern, verwenden Sie die AWS-Managementkonsole oder das AWS CLI, um die Optionseinstellungen in der SSAS-Option zu ändern.
**Wichtig**
Sie können jeweils nur einen SSAS-Modus verwenden. Stellen Sie sicher, dass Sie alle SSAS-Datenbanken löschen, bevor Sie den Modus ändern, da Sie ansonsten einen Fehler erhalten.
## Konsole
Der folgende Amazon-RDS-Konsolenprozess ändert den SSAS-Modus in „Tabellarisch“ und legt den Parameter `MAX_MEMORY` auf 70 Prozent fest.
**Ändern der SSAS-Option**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `SSAS` (`ssas-se-2017` in den vorherigen Beispielen), die Sie ändern möchten.
1. Wählen Sie **Modify option** (Option ändern) aus.
1. Ändern Sie die Optionseinstellungen:
1. Geben Sie für **Max memory** (Maximaler Speicher) **70** ein.
1. Wählen Sie für **Mode** (Modus) **Tabular** (Tabellarisch) aus.
1. Wählen Sie **Modify option** (Option ändern) aus.
## AWS CLI
Das folgende AWS CLI-Beispiel ändert den SSAS-Modus in „Tabellarisch“ und legt den Parameter `MAX_MEMORY` auf 70 % fest.
Damit der CLI-Befehl funktioniert, stellen Sie sicher, dass Sie alle erforderlichen Parameter angeben, auch wenn Sie sie nicht ändern.
**Ändern der SSAS-Option**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--option-group-name ssas-se-2017 \
--options "OptionName=SSAS,VpcSecurityGroupMemberships=sg-12345e67,OptionSettings=[{Name=MAX_MEMORY,Value=70},{Name=MODE,Value=Tabular}]" \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name ssas-se-2017 ^
--options OptionName=SSAS,VpcSecurityGroupMemberships=sg-12345e67,OptionSettings=[{Name=MAX_MEMORY,Value=70},{Name=MODE,Value=Tabular}] ^
--apply-immediately
```
# Deaktivieren von SSAS
Um SSAS zu deaktivieren, entfernen Sie die Option `SSAS` aus der Optionsgruppe.
**Wichtig**
Bevor Sie die Option `SSAS` entfernen, löschen Sie Ihre SSAS-Datenbanken.
Wir empfehlen dringend, dass Sie Ihre SSAS-Datenbanken sichern, bevor Sie sie löschen und die Option `SSAS` entfernen.
## Konsole
**So entfernen Sie die SSAS-Option aus der Optionsgruppe**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `SSAS` (`ssas-se-2017` in den vorherigen Beispielen), die Sie entfernen möchten.
1. Wählen Sie **Delete option (Option löschen)** aus.
1. Wählen Sie unter **Deletion options (Löschoptionen)** für **Options to delete (Zu löschende Optionen)** die Option **SSAS** aus.
1. Wählen Sie unter **Apply immediately (Sofort anwenden)** die Option **Yes (Ja)** aus, um die Option sofort zu löschen, oder **No (Nein)**, um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Delete (Löschen)**.
## AWS CLI
**So entfernen Sie die SSAS-Option aus der Optionsgruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name ssas-se-2017 \
--options SSAS \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name ssas-se-2017 ^
--options SSAS ^
--apply-immediately
```
# Fehlerbehebung von SSAS-Problemen
Bei der Verwendung von SSAS können die folgenden Probleme auftreten.
| Problem | Typ | Vorschläge für die Fehlerbehebung |
| --- | --- | --- |
| Die SSAS-Option kann nicht konfiguriert werden. Der angeforderte SSAS-Modus lautet new\$1mode, aber die aktuelle DB-Instance hat die Datenbanken number current\$1mode. Löschen Sie die vorhandenen Datenbanken bevor Sie zum Modus new\$1mode wechseln. Um erneut Zugriff auf den Modus current\$1mode zum Löschen einer Datenbank zu erhalten, können Sie entweder die aktuelle DB-Optionsgruppe aktualisieren oder eine neue Optionsgruppe mit %s als MODUS-Optionseinstellungswert für die SSAS-Option anfügen. | RDS-Ereignis | Sie können den SSAS-Modus nicht ändern, wenn Sie immer noch SSAS-Datenbanken haben, die den aktuellen Modus verwenden. Löschen Sie die SSAS-Datenbanken und versuchen Sie es dann erneut. |
| Die SSAS-Option kann nicht entfernt werden, da es Datenbanken mit dem Modus number existing gibt. Die SSAS-Option kann erst entfernt werden, wenn alle SSAS-Datenbanken gelöscht wurden. Fügen Sie die SSAS-Option erneut hinzu, löschen Sie alle SSAS-Datenbanken und versuchen Sie es erneut. | RDS-Ereignis | Sie können SSAS nicht deaktivieren, wenn Sie noch SSAS-Datenbanken haben. Löschen Sie die SSAS-Datenbanken und versuchen Sie es dann erneut. |
| Die SSAS-Option ist nicht aktiviert oder wird gerade aktiviert. Bitte versuchen Sie es später erneut. | Gespeicherte RDS-Prozesse | Sie können gespeicherte SSAS-Prozesse nicht ausführen, wenn die Option deaktiviert ist oder erneut aktiviert wird. |
| Die SSAS-Option ist falsch konfiguriert. Stellen Sie sicher, dass der Mitgliedschaftsstatus der Optionsgruppe „in-sync“ lautet, und überprüfen Sie die RDS-Ereignisprotokolle auf relevante SSAS-Konfigurationsfehlermeldungen. Versuchen Sie es im Anschluss erneut. Wenn weiterhin Fehler auftreten, wenden Sie sich an den AWS-Support. | Gespeicherte RDS-Prozesse | Sie können keine gespeicherten SSAS-Prozesse ausführen, wenn Ihre Mitgliedschaft für die Optionsgruppe sich nicht im Status `in-sync` befindet. Dies versetzt die SSAS-Option in einen falschen Konfigurationsstatus. Wenn sich der Mitgliedschaftsstatus Ihrer Optionsgruppe aufgrund der Änderung der SSAS-Option in `failed` ändert, gibt es zwei mögliche Gründe: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SSAS.Trouble.html) Konfigurieren Sie die SSAS-Option neu, da RDS jeweils nur einen SSAS-Modus zulässt und das Entfernen von SSAS-Optionen bei vorhandenen SSAS-Datenbanken nicht unterstützt. Überprüfen Sie die RDS-Ereignisprotokolle auf Konfigurationsfehler für Ihre SSAS-Instance und beheben Sie die Probleme entsprechend. |
| Bereitstellung fehlgeschlagen. Die Änderung kann nur auf einem Server bereitgestellt werden, der im Modus deployment\$1file\$1mode ausgeführt wird. Der aktuelle Servermodus lautet current\$1mode. | Gespeicherte RDS-Prozesse | Sie können eine tabellarische Datenbank nicht auf einem mehrdimensionalen Server oder eine mehrdimensionale Datenbank nicht auf einem tabellarischen Server bereitstellen. Stellen Sie sicher, dass Sie Dateien mit dem richtigen Modus verwenden, und überprüfen Sie, ob für die Optionseinstellung `MODE` der entsprechende Wert festgelegt wurde. |
| Die Wiederherstellung ist fehlgeschlagen. Die Backup-Datei kann nur auf einem Server wiederhergestellt werden, der im Modus restore\$1file\$1mode ausgeführt wird. Der aktuelle Servermodus lautet current\$1mode. | Gespeicherte RDS-Prozesse | Sie können eine tabellarische Datenbank nicht auf einem mehrdimensionalen Server oder eine mehrdimensionale Datenbank auf einem tabellarischen Server wiederherstellen. Stellen Sie sicher, dass Sie Dateien mit dem richtigen Modus verwenden, und überprüfen Sie, ob für die Optionseinstellung `MODE` der entsprechende Wert festgelegt wurde. |
| Die Wiederherstellung ist fehlgeschlagen. Die Backup-Datei und die RDS-DB-Instance-Versionen sind nicht kompatibel. | Gespeicherte RDS-Prozesse | Sie können eine SSAS-Datenbank nicht mit einer Version wiederherstellen, die mit der SQL-Server-Instance-Version nicht kompatibel ist. Weitere Informationen finden Sie unter [Compatibility levels for tabular models](https://docs.microsoft.com/en-us/analysis-services/tabular-models/compatibility-level-for-tabular-models-in-analysis-services) und unter [Compatibility level of a multidimensional database](https://docs.microsoft.com/en-us/analysis-services/multidimensional-models/compatibility-level-of-a-multidimensional-database-analysis-services) in der Microsoft-Dokumentation. |
| Die Wiederherstellung ist fehlgeschlagen. Die im Wiederherstellungsvorgang angegebene Backup-Datei ist beschädigt oder ist keine SSAS-Backup-Datei. Stellen Sie sicher, dass @rds\$1file\$1path korrekt formatiert ist. | Gespeicherte RDS-Prozesse | Sie können eine SSAS-Datenbank nicht mit einer beschädigten Datei wiederherstellen. Stellen Sie sicher, dass die Datei nicht beschädigt oder fehlerhaft ist. Dieser Fehler kann auch ausgelöst werden, wenn `@rds_file_path` nicht richtig formatiert ist (wenn beispielsweise doppelte Backslashes wie in `D:\S3\\incorrect_format.abf` enthalten sind). |
| Die Wiederherstellung ist fehlgeschlagen. Der Name der wiederhergestellten Datenbank darf keine reservierten Wörter oder die folgenden ungültigen Zeichen enthalten . , ; ' ` : / \$1\$1 \$1 \$1 ? \$1" & % \$1 \$1 \$1 = ( ) [ ] \$1 \$1 < >, oder länger als 100 Zeichen sein. | Gespeicherte RDS-Prozesse | Der Name der wiederhergestellten Datenbank darf keine reservierten Wörter oder ungültigen Zeichen enthalten oder länger als 100 Zeichen sein. Informationen zu SSAS-Objektbenennungskonventionen finden Sie unter [Object naming rules](https://docs.microsoft.com/en-us/analysis-services/multidimensional-models/olap-physical/object-naming-rules-analysis-services) in der Microsoft-Dokumentation. |
| Es wurde ein ungültiger Rollenname angegeben. Der Rollenname darf keine reservierten Strings enthalten. | Gespeicherte RDS-Prozesse | Der Rollenname darf keine reservierten Strings enthalten. Informationen zu SSAS-Objektbenennungskonventionen finden Sie unter [Object naming rules](https://docs.microsoft.com/en-us/analysis-services/multidimensional-models/olap-physical/object-naming-rules-analysis-services) in der Microsoft-Dokumentation. |
| Es wurde ein ungültiger Rollenname angegeben. Der Rollenname darf keines der folgenden reservierten Zeichen enthalten: . , ; ' ` : / \$1\$1 \$1 \$1 ? \$1" & % \$1 \$1 \$1 = ( ) [ ] \$1 \$1 < > | Gespeicherte RDS-Prozesse | Der Rollenname darf keine reservierten Zeichen enthalten. Informationen zu SSAS-Objektbenennungskonventionen finden Sie unter [Object naming rules](https://docs.microsoft.com/en-us/analysis-services/multidimensional-models/olap-physical/object-naming-rules-analysis-services) in der Microsoft-Dokumentation. |
# Unterstützung für SQL Server Integration Services in Amazon RDS für SQL Server
Microsoft SQL Server Integration Services (SSIS) ist eine Komponente, mit der Sie eine breite Palette von Datenmigrationsaufgaben ausführen können. SSIS ist eine Plattform für Datenintegrations- und Workflow-Anwendungen. Sie verfügt über ein Data Warehousing-Tool, das für Datenextraktion, Transformation und Laden (ETL) verwendet wird. Sie können dieses Tool auch verwenden, um die Wartung von SQL Server-Datenbanken und Aktualisierungen von mehrdimensionalen Cubedaten zu automatisieren.
SSIS-Projekte werden in Pakete organisiert, die als XML-basierte DTSX-Dateien gespeichert werden. Pakete können Kontrollflüsse und Datenflüsse enthalten. Zur Darstellung von ETL-Vorgängen verwenden Sie Datenflüsse. Nach der Bereitstellung werden Pakete in SQL Server in der SSISDB-Datenbank gespeichert. SSISDB ist eine OLTP-Datenbank (Online Transaction Processing) im vollständigen Wiederherstellungsmodus.
Amazon RDS für SQL Server unterstützt das Ausführen von SSIS direkt auf RDS-DB-Instance. Sie können SSIS für eine vorhandene oder neue DB-Instance aktivieren. SSIS wird auf derselben DB-Instance wie Ihre Datenbank-Engine installiert.
RDS unterstützt SSIS für die SQL Server Standard und Enterprise Edition in den folgenden Versionen:
+ SQL Server 2022, alle Versionen
+ SQL Server 2019, Version 15.00.4043.16.v1 und höher
+ SQL Server 2017, Version 14.00.3223.3.v1 und höher
+ SQL Server 2016, version 13.00.5426.0.v1 und höher
**Contents**
+ [
## Einschränkungen und Empfehlungen
](#SSIS.Limitations)
+ [
## Aktivieren von SSIS
](#SSIS.Enabling)
+ [
### Erstellen der Optionsgruppe für SSIS
](#SSIS.OptionGroup)
+ [
### Hinzufügen der SSIS-Option zur Optionsgruppe
](#SSIS.Add)
+ [
### Erstellen der Parametergruppe für SSIS
](#SSIS.CreateParamGroup)
+ [
### Ändern des Parameters für SSIS
](#SSIS.ModifyParam)
+ [
### Zuordnen der Options- und Parametergruppe zu Ihrer DB-Instance
](#SSIS.Apply)
+ [
### Aktivieren der S3-Integration
](#SSIS.EnableS3)
+ [
# Administrative Berechtigungen auf SSISDB
](SSIS.Permissions.md)
+ [
## Einrichten eines Windows-authentifizierten Benutzers für SSIS
](SSIS.Permissions.md#SSIS.Use.Auth)
+ [
# Bereitstellen eines SSIS-Projekts
](SSIS.Deploy.md)
+ [
# Überwachen des Status einer Bereitstellungsaufgabe
](SSIS.Monitor.md)
+ [
# Verwenden von SSIS
](SSIS.Use.md)
+ [
## Festlegen von Datenbankverbindungs-Managern für SSIS-Projekte
](SSIS.Use.md#SSIS.Use.ConnMgrs)
+ [
## Erstellen eines SSIS-Proxys
](SSIS.Use.md#SSIS.Use.Proxy)
+ [
## Planen eines SSIS-Pakets mit SQL Server-Agent
](SSIS.Use.md#SSIS.Use.Schedule)
+ [
## Widerrufen des SSIS-Zugriffs vom Proxy
](SSIS.Use.md#SSIS.Use.Revoke)
+ [
# Deaktivieren und Entfernen einer SSIS-Datenbank
](SSIS.DisableDrop.md)
+ [
## Deaktivieren von SSIS
](SSIS.DisableDrop.md#SSIS.Disable)
+ [
## Löschen der SSISDB-Datenbank
](SSIS.DisableDrop.md#SSIS.Drop)
## Einschränkungen und Empfehlungen
Die folgenden Einschränkungen und Empfehlungen gelten für die Ausführung von SSIS auf RDS für SQL Server:
+ Der DB-Instance muss eine Parametergruppe zugeordnet sein, wobei der Parameter `clr enabled` auf „1“ gesetzt ist. Weitere Informationen finden Sie unter [Ändern des Parameters für SSIS](#SSIS.ModifyParam).
**Anmerkung**
Wenn Sie den Parameter `clr enabled` auf SQL Server 2017 oder 2019 aktivieren, können Sie die Common Language Runtime (CLR) auf Ihrer DB-Instance nicht verwenden. Weitere Informationen finden Sie unter [Nicht unterstützte Funktionen und Funktionen mit beschränkter Unterstützung](SQLServer.Concepts.General.FeatureNonSupport.md).
+ Die folgenden Kontrollflussaufgaben werden unterstützt:
+ Analysis Services-Aufgabe „DDL ausführen“
+ Analysis Services-Verarbeitungsaufgabe
+ Masseneinfügungsaufgabe
+ Aufgabe „Datenbankintegrität überprüfen“
+ Datenfluss-Aufgabe
+ Aufgabe „Data Mining abfragen“
+ Datenprofilerstellungsaufgabe
+ Aufgabe „Paket ausführen“
+ Aufgabe „SQL Server-Agent-Auftrag ausführen“
+ Aufgabe „SQL ausführen“
+ Aufgabe „T-SQL-Anweisung ausführen“
+ Aufgabe „Bediener benachrichtigen“
+ Aufgabe „Index neu erstellen“
+ Aufgabe „Index neu organisieren“
+ Aufgabe „Datenbank verkleinern“
+ Aufgabe „Datenbank übertragen“
+ Aufgabe „Aufträge übertragen“
+ Aufgabe „Anmeldungen übertragen“
+ Task „SQL Server-Objekte übertragen“
+ Aufgabe „Statistik aktualisieren“
+ Es wird nur die Projektbereitstellung unterstützt.
+ Das Ausführen von SSIS-Paketen mithilfe von SQL Server-Agent wird unterstützt.
+ SSIS-Protokolldatensätze können nur in vom Benutzer erstellte Datenbanken eingefügt werden.
+ Verwenden Sie für die Arbeit mit Dateien nur den Ordner `D:\S3`. Dateien, die in einem anderen Verzeichnis gespeichert sind, werden gelöscht. Beachten Sie einige andere Details zum Dateispeicherort:
+ Platzieren Sie SSIS-Projekteingabe- und Ausgabedateien im Ordner `D:\S3`.
+ Ändern Sie für die Datenflussaufgabe den Speicherort für `BLOBTempStoragePath` und `BufferTempStoragePath` in eine Datei innerhalb des Ordners `D:\S3`. Der Dateipfad muss mit beginne `D:\S3\`.
+ Stellen Sie sicher, dass alle Parameter, Variablen und Ausdrücke, die für Dateiverbindungen verwendet werden, auf den Ordner `D:\S3` verweisen.
+ Bei Multi-AZ-Instances werden Dateien, die von SSIS im Ordner `D:\S3` erstellt wurden, nach einem Failover gelöscht. Weitere Informationen finden Sie unter [Multi-AZ-Einschränkungen für die S3-Integration](User.SQLServer.Options.S3-integration.md#S3-MAZ).
+ Laden Sie die von SSIS erstellten Dateien im Ordner `D:\S3` in Ihren Amazon S3-Bucket hoch, um sie dauerhaft zu machen.
+ Importieren von Spalten- und Exportspalten-Transformationen sowie die Skriptkomponente in der Datenflussaufgabe werden nicht unterstützt.
+ Sie können keine Dump bei ausgeführten SSIS-Paketen aktivieren, und Sie können keine Datentippeingaben für SSIS-Pakete hinzufügen.
+ Die SSIS-Scale-Out-Funktion wird nicht unterstützt.
+ Projekte können nicht direkt bereitgestellt werden. Dazu stellen wir gespeicherte RDS-Prozeduren bereit. Weitere Informationen finden Sie unter [Bereitstellen eines SSIS-Projekts](SSIS.Deploy.md).
+ Erstellen Sie SSIS-Projektdateien (.ispac) mit dem Schutzmodus `DoNotSavePasswords` für die Bereitstellung auf RDS.
+ SSIS wird auf immer eingeschalteten Instances mit Read Replicas nicht unterstützt.
+ Sie können die SSISDB-Datenbank, die der Option `SSIS` zugeordnet ist, nicht sichern.
+ Das Importieren und Wiederherstellen der SSISDB-Datenbank aus anderen SSIS-Instances wird nicht unterstützt.
+ Sie können eine Verbindung mit anderen DB-Instances von SQL Server oder mit einer Oracle-Datenquelle herstellen. Die Verbindung zu anderen Datenbank-Engines wie MySQL oder PostgreSQL wird für SSIS auf RDS für SQL Server nicht unterstützt. Weitere Informationen zum Herstellen einer Verbindung mit einer Oracle-Datenquelle finden Sie unter [Mit Oracle OLEDB verknüpfte Server](Appendix.SQLServer.Options.LinkedServers_Oracle_OLEDB.md).
+ SSIS unterstützt keine in eine Domäne eingebundene Instance mit einer ausgehenden Vertrauensstellung zu einer On-Premises-Domäne. Wenn Sie eine ausgehende Vertrauensstellung verwenden, führen Sie den SSIS-Job von einem Konto in der lokalen AWS Domäne aus.
+ Die Ausführung von Dateisystem-basierten Paketen wird nicht unterstützt.
## Aktivieren von SSIS
Sie aktivieren SSIS, indem Sie der DB-Instance die SSIS-Option hinzufügen. Verwenden Sie den folgenden Prozess:
1. Erstellen Sie eine neue Optionsgruppe oder wählen Sie eine bestehende Optionsgruppe aus.
1. Fügen Sie die Option `SSIS` zur Optionsgruppe hinzu.
1. Erstellen Sie eine neue Parametergruppe oder wählen Sie eine vorhandene Parametergruppe aus.
1. Ändern Sie die Parametergruppe, um den Parameter `clr enabled` auf „1“ einzustellen.
1. Ordnen Sie die Optionsgruppe und die Parametergruppe der DB-Instance zu.
1. Aktivieren Sie die Amazon S3-Integration.
**Anmerkung**
Wenn auf der DB-Instance bereits eine Datenbank mit dem Namen „SSISDB“ oder eine reservierte SSIS-Anmeldung vorhanden ist, können Sie SSIS für die Instance nicht aktivieren.
### Erstellen der Optionsgruppe für SSIS
Um mit SSIS zu arbeiten, erstellen Sie eine Optionsgruppe oder ändern Sie eine Optionsgruppe, die der SQL Server-Edition und der Version der DB-Instance entspricht, die Sie verwenden möchten. Verwenden Sie dazu das AWS-Managementkonsole oder das AWS CLI.
#### Konsole
Mit der folgenden Konsolenprozedur wird eine Optionsgruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Optionsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group** (Gruppe erstellen) aus.
1. Führen Sie im Fenster **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie unter **Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihres AWS Kontos eindeutig ist, z. **ssis-se-2016** B. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein, z. B. **SSIS option group for SQL Server SE 2016**. Die Beschreibung ist nur zur Information.
1. Wählen Sie für **Engine** die Option **sqlserver-se** aus.
1. Wählen Sie im Feld **Engine-Hauptversion** **13.00** aus.
1. Wählen Sie **Erstellen** aus.
#### CLI
Mit der folgenden Konsolenprozedur wird eine Optionsgruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name ssis-se-2016 \
--engine-name sqlserver-se \
--major-engine-version 13.00 \
--option-group-description "SSIS option group for SQL Server SE 2016"
```
Für Windows:
```
aws rds create-option-group ^
--option-group-name ssis-se-2016 ^
--engine-name sqlserver-se ^
--major-engine-version 13.00 ^
--option-group-description "SSIS option group for SQL Server SE 2016"
```
### Hinzufügen der SSIS-Option zur Optionsgruppe
Verwenden Sie als Nächstes das AWS-Managementkonsole oder, AWS CLI um die `SSIS` Option zu Ihrer Optionsgruppe hinzuzufügen.
#### Konsole
**So fügen Sie die SSIS-Option hinzu**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie in diesem Beispiel die gerade erstellte Optionsgruppe **ssis-se-2016** aus.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. Wählen Sie unter **Optionsdetails** für **Optionsname** die Option **SSIS** aus.
1. Wählen Sie unter **Scheduling (Planung)** aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
#### CLI
**So fügen Sie die SSIS-Option hinzu**
+ Fügen Sie die Option `SSIS` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--option-group-name ssis-se-2016 \
--options OptionName=SSIS \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name ssis-se-2016 ^
--options OptionName=SSIS ^
--apply-immediately
```
### Erstellen der Parametergruppe für SSIS
Erstellen oder ändern Sie eine Parametergruppe für den Parameter `clr enabled`, der der SQL Server-Edition und der Version der DB-Instance entspricht, die Sie für SSIS verwenden möchten.
#### Konsole
Im folgenden Verfahren wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie **Create parameter group (Parametergruppe erstellen)**.
1. Führen Sie im Bereich **Parametergruppe erstellen** die folgenden Schritte aus:
1. Wählen Sie für **Parametergruppenfamilie** die Option **sqlserver-se-13.0** aus.
1. Geben Sie unter **Gruppenname** einen Bezeichner für die Parametergruppe ein, z. B. **ssis-sqlserver-se-13**.
1. Geben Sie für **Beschreibung** den Text **clr enabled parameter group** ein.
1. Wählen Sie **Create** aus.
#### CLI
Im folgenden Verfahren wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-parameter-group \
--db-parameter-group-name ssis-sqlserver-se-13 \
--db-parameter-group-family "sqlserver-se-13.0" \
--description "clr enabled parameter group"
```
Für Windows:
```
aws rds create-db-parameter-group ^
--db-parameter-group-name ssis-sqlserver-se-13 ^
--db-parameter-group-family "sqlserver-se-13.0" ^
--description "clr enabled parameter group"
```
### Ändern des Parameters für SSIS
Ändern Sie den `clr enabled`-Parameter in der Parametergruppe, die der SQL Server-Edition und der Version Ihrer DB-Instance entspricht. Stellen Sie für SSIS den Parameter `clr enabled` auf „1“ ein.
#### Konsole
Im folgenden Verfahren wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben.
**So ändern Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie die Parametergruppe aus, z. B. **ssis-sqlserver-se-13**.
1. Filtern Sie unter **Parameter** die Parameterliste nach **clr**.
1. Wählen Sie **clr enabled**.
1. Wählen Sie **Parameter bearbeiten** aus.
1. Wählen Sie unter **Werte** die Option **1** aus.
1. Wählen Sie **Änderungen speichern ** aus.
#### CLI
Im folgenden Verfahren wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben.
**So ändern Sie die Parametergruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name ssis-sqlserver-se-13 \
--parameters "ParameterName='clr enabled',ParameterValue=1,ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name ssis-sqlserver-se-13 ^
--parameters "ParameterName='clr enabled',ParameterValue=1,ApplyMethod=immediate"
```
### Zuordnen der Options- und Parametergruppe zu Ihrer DB-Instance
Um die SSIS-Optionsgruppe und die Parametergruppe mit Ihrer DB-Instance zu verknüpfen, verwenden Sie den oder AWS-Managementkonsole AWS CLI
**Anmerkung**
Wenn Sie eine vorhandene Instance verwenden, muss dieser bereits eine Active Directory-Domäne und AWS Identity and Access Management (IAM) -Rolle zugeordnet sein. Wenn Sie eine neue Instance erstellen, geben Sie eine vorhandene Active Directory-Domäne und IAM-Rolle an. Weitere Informationen finden Sie unter [Arbeiten mit Active Directory mit RDS für SQL Server](User.SQLServer.ActiveDirectoryWindowsAuth.md).
#### Konsole
Um die Aktivierung von SSIS abzuschließen, ordnen Sie Ihre SSIS-Optionsgruppe und Parametergruppe einer neuen oder vorhandenen DB-Instance zu:
+ Ordnen Sie sie bei einer neuen DB-Instance zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ordnen Sie sie für eine vorhandene DB-Instance zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
#### CLI
Sie können die SSIS-Optionsgruppe und die Parametergruppe einer neuen oder vorhandenen DB-Instance zuordnen.
**So erstellen Sie eine Instance mit der SSIS-Optionsgruppe und der Parametergruppe**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier myssisinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 13.00.5426.0.v1 \
--allocated-storage 100 \
--manage-master-user-password \
--master-username admin \
--storage-type gp2 \
--license-model li \
--domain-iam-role-name my-directory-iam-role \
--domain my-domain-id \
--option-group-name ssis-se-2016 \
--db-parameter-group-name ssis-sqlserver-se-13
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier myssisinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 13.00.5426.0.v1 ^
--allocated-storage 100 ^
--manage-master-user-password ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--domain-iam-role-name my-directory-iam-role ^
--domain my-domain-id ^
--option-group-name ssis-se-2016 ^
--db-parameter-group-name ssis-sqlserver-se-13
```
**So ändern Sie eine Instance und ordnen die SSIS-Optionsgruppe und die Parametergruppe zu**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier myssisinstance \
--option-group-name ssis-se-2016 \
--db-parameter-group-name ssis-sqlserver-se-13 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier myssisinstance ^
--option-group-name ssis-se-2016 ^
--db-parameter-group-name ssis-sqlserver-se-13 ^
--apply-immediately
```
### Aktivieren der S3-Integration
Um SSIS-Projektdateien (.ispac) für die Bereitstellung auf Ihren Host herunterzuladen, verwenden Sie die S3-Dateiintegration. Weitere Informationen finden Sie unter [Integration einer Amazon RDS für SQL Server-DB-Instance mit Amazon S3](User.SQLServer.Options.S3-integration.md).
# Administrative Berechtigungen auf SSISDB
Wenn die Instance mit der Option SSIS erstellt oder geändert wird, ist das Ergebnis eine SSISDB-Datenbank mit den Rollen ssis\$1admin und ssis\$1logreader, die dem Masterbenutzer erteilt werden. Der Master-Benutzer verfügt über die folgenden Berechtigungen in SSISDB:
+ auf ssis\$1admin Rolle ändern
+ auf ssis\$1logreader-Rolle ändern
+ jeden Benutzer ändern
Da der Master-Benutzer ein SQL-authentifizierter Benutzer ist, können Sie den Master-Benutzer nicht zum Ausführen von SSIS-Paketen verwenden. Der Master-Benutzer kann diese Berechtigungen verwenden, um neue SSISDB-Benutzer zu erstellen und sie den Rollen ssis\$1admin und ssis\$1logreader hinzuzufügen. Dies ist nützlich, um Ihren Domänenbenutzern Zugriff für die Verwendung von SSIS zu gewähren.
## Einrichten eines Windows-authentifizierten Benutzers für SSIS
Der Masterbenutzer kann das folgende Codebeispiel verwenden, um eine Windows-authentifizierte Anmeldung in SSISDB einzurichten und die erforderlichen Prozedurberechtigungen zu erteilen. Dadurch werden dem Domänenbenutzer Berechtigungen zum Bereitstellen und Ausführen von SSIS-Paketen, zum Verwenden von S3-Dateiübertragungsverfahren, zum Erstellen von Anmeldeinformationen und zum Arbeiten mit dem SQL Server-Agent-Proxy gewährt. Weitere Informationen finden Sie unter [Anmeldeinformationen (Datenbank-Engine)](https://docs.microsoft.com/en-us/sql/relational-databases/security/authentication-access/credentials-database-engine?view=sql-server-ver15) und [Erstellen eines SQL Server-Agent-Proxys](https://docs.microsoft.com/en-us/sql/ssms/agent/create-a-sql-server-agent-proxy?view=sql-server-ver15) in der Microsoft-Dokumentation.
**Anmerkung**
Sie können Windows-authentifizierten Benutzern bei Bedarf einige oder alle der folgenden Berechtigungen erteilen.
**Example**
```
-- Create a server-level SQL login for the domain user, if it doesn't already exist
USE [master]
GO
CREATE LOGIN [mydomain\user_name] FROM WINDOWS
GO
-- Create a database-level account for the domain user, if it doesn't already exist
USE [SSISDB]
GO
CREATE USER [mydomain\user_name] FOR LOGIN [mydomain\user_name]
-- Add SSIS role membership to the domain user
ALTER ROLE [ssis_admin] ADD MEMBER [mydomain\user_name]
ALTER ROLE [ssis_logreader] ADD MEMBER [mydomain\user_name]
GO
-- Add MSDB role membership to the domain user
USE [msdb]
GO
CREATE USER [mydomain\user_name] FOR LOGIN [mydomain\user_name]
-- Grant MSDB stored procedure privileges to the domain user
GRANT EXEC ON msdb.dbo.rds_msbi_task TO [mydomain\user_name] with grant option
GRANT SELECT ON msdb.dbo.rds_fn_task_status TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_task_status TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_cancel_task TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_download_from_s3 TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_upload_to_s3 TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_delete_from_filesystem TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_gather_file_details TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_add_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_update_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_grant_login_to_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_revoke_login_from_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_delete_proxy TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_enum_login_for_proxy to [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.sp_enum_proxy_for_subsystem TO [mydomain\user_name] with grant option
GRANT EXEC ON msdb.dbo.rds_sqlagent_proxy TO [mydomain\user_name] WITH GRANT OPTION
-- Add the SQLAgentUserRole privilege to the domain user
USE [msdb]
GO
ALTER ROLE [SQLAgentUserRole] ADD MEMBER [mydomain\user_name]
GO
-- Grant the ALTER ANY CREDENTIAL privilege to the domain user
USE [master]
GO
GRANT ALTER ANY CREDENTIAL TO [mydomain\user_name]
GO
```
# Bereitstellen eines SSIS-Projekts
Auf RDS können Sie SSIS-Projekte nicht direkt mithilfe von SQL Server Management Studio (SSMS) oder SSIS-Verfahren bereitstellen. Verwenden Sie gespeicherte RDS-Prozeduren, um Projektdateien aus Amazon S3 herunterzuladen und anschließend bereitzustellen.
Melden Sie sich zum Ausführen der gespeicherten Prozeduren als beliebiger Benutzer an, dem Sie Berechtigungen für das Ausführen der gespeicherten Prozeduren erteilt haben. Weitere Informationen finden Sie unter [Einrichten eines Windows-authentifizierten Benutzers für SSIS](SSIS.Permissions.md#SSIS.Use.Auth).
**So stellen Sie das SSIS-Projekt bereit**
1. Laden Sie die Projektdatei (.ispac) herunter.
```
exec msdb.dbo.rds_download_from_s3
@s3_arn_of_file='arn:aws:s3:::bucket_name/ssisproject.ispac',
@rds_file_path='D:\S3\ssisproject.ispac',
@overwrite_file=1;
```
1. Übermitteln Sie die Bereitstellungsaufgabe und stellen Sie sicher, dass Sie Folgendes beachten:
+ Der Ordner ist im SSIS-Katalog vorhanden.
+ Der Projektname stimmt mit dem Projektnamen überein, den Sie beim Entwickeln des SSIS-Projekts verwendet haben.
```
exec msdb.dbo.rds_msbi_task
@task_type='SSIS_DEPLOY_PROJECT',
@folder_name='DEMO',
@project_name='ssisproject',
@file_path='D:\S3\ssisproject.ispac';
```
# Überwachen des Status einer Bereitstellungsaufgabe
Rufen Sie die Funktion `rds_fn_task_status` auf, um den Status Ihrer Bereitstellungsaufgabe zu verfolgen. Dazu sind zwei Parameter erforderlich. Der erste Parameter sollte immer `NULL` sein, da er sich nicht auf SSIS bezieht. Der zweite Parameter akzeptiert eine Aufgaben-ID.
Um eine Liste aller Aufgaben anzuzeigen, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf `0`, wie im folgenden Beispiel gezeigt.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```
Um eine bestimmte Aufgabe zu erhalten, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf die Aufgaben-ID, wie im folgenden Beispiel gezeigt,
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```
Die `rds_fn_task_status`-Funktion gibt die folgenden Informationen zurück.
| Ausgabeparameter | Beschreibung |
| --- | --- |
| `task_id` | Die ID der Aufgabe. |
| `task_type` | `SSIS_DEPLOY_PROJECT` |
| `database_name` | Gilt nicht für SSIS-Aufgaben. |
| `% complete` | Verlauf der Aufgabe als Prozentwert. |
| `duration (mins)` | Zeitdauer für die Ausführung der Aufgabe (in Minuten). |
| `lifecycle` | Der Status der Aufgabe. Die folgenden Status sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SSIS.Monitor.html) |
| `task_info` | Zusätzliche Informationen über die Aufgabe. Wenn bei der Verarbeitung ein Fehler auftritt, enthält diese Spalte Informationen zu dem Fehler. |
| `last_updated` | Datum und Uhrzeit der letzten Aktualisierung des Aufgabenstatus. |
| `created_at` | Datum und Uhrzeit, an denen die Aufgabe angelegt wurde. |
| `S3_object_arn` | Gilt nicht für SSIS-Aufgaben. |
| `overwrite_S3_backup_file` | Gilt nicht für SSIS-Aufgaben. |
| `KMS_master_key_arn` | Gilt nicht für SSIS-Aufgaben. |
| `filepath` | Gilt nicht für SSIS-Aufgaben. |
| `overwrite_file` | Gilt nicht für SSIS-Aufgaben. |
| `task_metadata` | Metadaten, die der SSIS-Aufgabe zugeordnet sind. |
# Verwenden von SSIS
Nachdem Sie das SSIS-Projekt im SSIS-Katalog bereitgestellt haben, können Sie Pakete direkt aus SSMS ausführen oder mithilfe des SQL Server-Agents planen. Sie müssen eine Windows-authentifizierte Anmeldung für die Ausführung von SSIS-Paketen verwenden. Weitere Informationen finden Sie unter [Einrichten eines Windows-authentifizierten Benutzers für SSIS](SSIS.Permissions.md#SSIS.Use.Auth).
**Topics**
+ [
## Festlegen von Datenbankverbindungs-Managern für SSIS-Projekte
](#SSIS.Use.ConnMgrs)
+ [
## Erstellen eines SSIS-Proxys
](#SSIS.Use.Proxy)
+ [
## Planen eines SSIS-Pakets mit SQL Server-Agent
](#SSIS.Use.Schedule)
+ [
## Widerrufen des SSIS-Zugriffs vom Proxy
](#SSIS.Use.Revoke)
## Festlegen von Datenbankverbindungs-Managern für SSIS-Projekte
Bei Einsatz eines Verbindungs-Managers können Sie die folgenden Authentifizierungstypen verwenden:
+ Für lokale Datenbankverbindungen mit AWS Managed Active Directory können Sie die SQL-Authentifizierung oder die Windows-Authentifizierung verwenden. Verwenden Sie für die Windows-Authentifizierung `DB_instance_name.fully_qualified_domain_name` als Servername der Verbindungszeichenfolge.
Ein Beispiel ist `myssisinstance.corp-ad.example.com`, wobei `myssisinstance` der Name der DB-Instance und `corp-ad.example.com` der vollqualifizierte Domänenname ist.
+ Verwenden Sie für Remoteverbindungen immer die SQL-Authentifizierung.
+ Für lokale Datenbankverbindungen mit selbstverwaltetem Active Directory können Sie die SQL-Authentifizierung oder die Windows-Authentifizierung verwenden. Verwenden Sie für die Windows-Authentifizierung `.` oder `LocalHost` als Servername der Verbindungszeichenfolge.
## Erstellen eines SSIS-Proxys
Um SSIS-Pakete mit SQL Server-Agent planen zu können, erstellen Sie SSIS-Anmeldeinformationen und einen SSIS-Proxy. Führen Sie diese Prozeduren als Windows-authentifizierter Benutzer aus.
**So erstellen Sie die SSIS-Anmeldeinformationen**
+ Erstellen Sie die Anmeldeinformationen für den Proxy. Dazu können Sie SSMS oder die folgende SQL-Anweisung verwenden.
```
USE [master]
GO
CREATE CREDENTIAL [SSIS_Credential] WITH IDENTITY = N'mydomain\user_name', SECRET = N'mysecret'
GO
```
**Anmerkung**
`IDENTITY` muss eine domänenauthentifizierter Anmeldung sein. Ersetzen Sie `mysecret` durch das Passwort für die domänenauthentifizierte Anmeldung.
Wandeln Sie bei jedem Wechsel des primären SSISDB-Hosts die SSIS-Proxy-Anmeldeinformationen ab, damit der neue Host darauf zugreifen kann.
**So erstellen Sie den SSIS-Proxy**
1. Verwenden Sie die folgende SQL-Anweisung, um den Proxy zu erstellen.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_add_proxy @proxy_name=N'SSIS_Proxy',@credential_name=N'SSIS_Credential',@description=N''
GO
```
1. Verwenden Sie die folgende SQL-Anweisung, um anderen Benutzern den Zugriff auf den Proxy zu gewähren.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_grant_login_to_proxy @proxy_name=N'SSIS_Proxy',@login_name=N'mydomain\user_name'
GO
```
1. Verwenden Sie die folgende SQL-Anweisung, um dem SSIS-Subsystem Zugriff auf den Proxy zu gewähren.
```
USE [msdb]
GO
EXEC msdb.dbo.rds_sqlagent_proxy @task_type='GRANT_SUBSYSTEM_ACCESS',@proxy_name='SSIS_Proxy',@proxy_subsystem='SSIS'
GO
```
**So zeigen Sie den Proxy und die Berechtigungserteilungen für den Proxy an**
1. Verwenden Sie die folgende SQL-Anweisung, um die Empfänger des Proxys anzuzeigen.
```
USE [msdb]
GO
EXEC sp_help_proxy
GO
```
1. Verwenden Sie die folgende SQL-Anweisung, um die Subsystemzuweisungen anzuzeigen.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_enum_proxy_for_subsystem
GO
```
## Planen eines SSIS-Pakets mit SQL Server-Agent
Nachdem Sie die Anmeldeinformationen und den Proxy erstellt und SSIS-Zugriff auf den Proxy gewährt haben, können Sie einen SQL Server-Agent-Auftrag erstellen, um das SSIS-Paket zu planen.
**So planen Sie das SSIS-Paket**
+ Sie können SSMS oder T-SQL zum Erstellen des SQL Server-Agent-Auftrags verwenden. Im folgenden Beispiel wird T-SQL verwendet.
```
USE [msdb]
GO
DECLARE @jobId BINARY(16)
EXEC msdb.dbo.sp_add_job @job_name=N'MYSSISJob',
@enabled=1,
@notify_level_eventlog=0,
@notify_level_email=2,
@notify_level_page=2,
@delete_level=0,
@category_name=N'[Uncategorized (Local)]',
@job_id = @jobId OUTPUT
GO
EXEC msdb.dbo.sp_add_jobserver @job_name=N'MYSSISJob',@server_name=N'(local)'
GO
EXEC msdb.dbo.sp_add_jobstep @job_name=N'MYSSISJob',@step_name=N'ExecuteSSISPackage',
@step_id=1,
@cmdexec_success_code=0,
@on_success_action=1,
@on_fail_action=2,
@retry_attempts=0,
@retry_interval=0,
@os_run_priority=0,
@subsystem=N'SSIS',
@command=N'/ISSERVER "\"\SSISDB\MySSISFolder\MySSISProject\MySSISPackage.dtsx\"" /SERVER "\"my-rds-ssis-instance.corp-ad.company.com/\""
/Par "\"$ServerOption::LOGGING_LEVEL(Int16)\"";1 /Par "\"$ServerOption::SYNCHRONIZED(Boolean)\"";True /CALLERINFO SQLAGENT /REPORTING E',
@database_name=N'master',
@flags=0,
@proxy_name=N'SSIS_Proxy'
GO
```
## Widerrufen des SSIS-Zugriffs vom Proxy
Sie können den Zugriff auf das SSIS-Subsystem widerrufen und den SSIS-Proxy mithilfe der folgenden gespeicherten Prozeduren löschen.
**So entziehen Sie den Zugriff und löschen den Proxy**
1. Widerrufen des Teilsystemzugriffs.
```
USE [msdb]
GO
EXEC msdb.dbo.rds_sqlagent_proxy @task_type='REVOKE_SUBSYSTEM_ACCESS',@proxy_name='SSIS_Proxy',@proxy_subsystem='SSIS'
GO
```
1. Widerrufen Sie die für den erteilten Berechtigungen Proxy.
```
USE [msdb]
GO
EXEC msdb.dbo.sp_revoke_login_from_proxy @proxy_name=N'SSIS_Proxy',@name=N'mydomain\user_name'
GO
```
1. Löschen Sie den Proxy.
```
USE [msdb]
GO
EXEC dbo.sp_delete_proxy @proxy_name = N'SSIS_Proxy'
GO
```
# Deaktivieren und Entfernen einer SSIS-Datenbank
Führen Sie die folgenden Schritte aus, um SSIS-Datenbanken zu deaktivieren oder zu entfernen:
**Topics**
+ [
## Deaktivieren von SSIS
](#SSIS.Disable)
+ [
## Löschen der SSISDB-Datenbank
](#SSIS.Drop)
## Deaktivieren von SSIS
Um SSIS zu deaktivieren, entfernen Sie die Option `SSIS` aus der Optionsgruppe.
**Wichtig**
Durch das Entfernen der Option wird die SSISDB-Datenbank nicht gelöscht, sodass Sie die Option sicher entfernen können, ohne die SSIS-Projekte zu verlieren.
Sie können die Option `SSIS` nach dem Entfernen erneut aktivieren, um die SSIS-Projekte wiederzuverwenden, die zuvor im SSIS-Katalog bereitgestellt wurden.
### Konsole
Mit dem folgenden Verfahren wird die Option `SSIS` entfernt.
**So entfernen Sie die SSIS-Option aus der Optionsgruppe**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `SSIS` (`ssis-se-2016` in den vorherigen Beispielen).
1. Wählen Sie **Delete option (Option löschen)** aus.
1. Wählen Sie unter **Löschoptionen** für **Zu löschende Optionen** die Option **SSIS** aus.
1. Wählen Sie unter **Apply immediately (Sofort anwenden)** die Option **Yes (Ja)** aus, um die Option sofort zu löschen, oder **No (Nein)**, um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Delete (Löschen)**.
### CLI
Mit dem folgenden Verfahren wird die Option `SSIS` entfernt.
**So entfernen Sie die SSIS-Option aus der Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name ssis-se-2016 \
--options SSIS \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name ssis-se-2016 ^
--options SSIS ^
--apply-immediately
```
## Löschen der SSISDB-Datenbank
Nach dem Entfernen der SSIS-Option wird die SSISDB-Datenbank nicht gelöscht. Um die SSISDB-Datenbank zu löschen, verwenden Sie die gespeicherte Prozedur `rds_drop_ssis_database`, nachdem Sie die SSIS-Option entfernt haben.
**So löschen Sie die SSIS-Datenbank**
+ Verwenden Sie die folgende gespeicherte Prozedur.
```
USE [msdb]
GO
EXEC dbo.rds_drop_ssis_database
GO
```
Wenn Sie nach dem Löschen der SSISDB-Datenbank die SSIS-Option erneut aktivieren, erhalten Sie einen neuen SSISDB-Katalog.
# Unterstützung für SQL Server Reporting Services in Amazon RDS für SQL Server
Microsoft SQL Server Reporting Services (SSRS) ist eine serverbasierte Anwendung, die für die Berichterstellung und -verteilung verwendet wird. Es ist Teil einer Suite von SQL Server-Services, die auch SQL Server Analysis Services (SSAS) und SQL Server Integration Services (SSIS) enthält. SSRS ist ein Service, der auf SQL Server basiert. Sie können damit Daten aus verschiedenen Datenquellen sammeln und auf eine Weise präsentieren, die leicht verständlich und für die Analyse bereit ist.
Amazon RDS für SQL Server unterstützt das Ausführen von SSRS direkt auf RDS-DB-Instances. Sie können SSRS auf vorhandenen oder neuen DB-Instances verwenden.
RDS unterstützt SSRS für SQL Server Standard und Enterprise Edition in den folgenden Versionen:
+ SQL Server 2022, alle Versionen
+ SQL Server 2019, Version 15.00.4043.16.v1 und höher
+ SQL Server 2017, Version 14.00.3223.3.v1 und höher
+ SQL Server 2016, Version 13.00.5820.21.v1 und höher
**Contents**
+ [
## Einschränkungen und Empfehlungen
](#SSRS.Limitations)
+ [
# Aktivieren von SSAS
](SSRS.Enabling.md)
+ [
## Erstellen einer Optionsgruppe für SSRS
](SSRS.Enabling.md#SSRS.OptionGroup)
+ [
## Hinzufügen der SSRS-Option zu Ihrer Optionsgruppe
](SSRS.Enabling.md#SSRS.Add)
+ [
## Zuordnen Ihrer Optionsgruppe zu Ihrer DB-Instance
](SSRS.Enabling.md#SSRS.Apply)
+ [
## Zulassen des eingehenden Zugriffs auf Ihre VPC-Sicherheitsgruppe
](SSRS.Enabling.md#SSRS.Inbound)
+ [
## Berichtsserverdatenbanken
](#SSRS.DBs)
+ [
## SSRS-Protokolldateien
](#SSRS.Logs)
+ [
# Zugriff auf das SSRS-Webportal
](SSRS.Access.md)
+ [
## Verwendung von SSL auf RDS
](SSRS.Access.md#SSRS.Access.SSL)
+ [
## Gewähren des Zugriffs für Domänenbenutzer
](SSRS.Access.md#SSRS.Access.Grant)
+ [
## Zugriff auf das Webportal
](SSRS.Access.md#SSRS.Access)
+ [
# Bereitstellen von Berichten und Konfigurieren von Berichtsdatenquellen
](SSRS.DeployConfig.md)
+ [
## Bereitstellen von Berichten zu SSRS
](SSRS.DeployConfig.md#SSRS.Deploy)
+ [
## Konfigurieren der Berichtsdatenquelle
](SSRS.DeployConfig.md#SSRS.ConfigureDataSource)
+ [
# Verwenden von SSRS E-Mail zum Senden von Berichten
](SSRS.Email.md)
+ [
# Widerrufen von Berechtigungen auf Systemebene
](SSRS.Access.Revoke.md)
+ [
# Überwachung des Status einer Aufgabe
](SSRS.Monitor.md)
+ [
# Deaktivieren und Löschen von SSRS-Datenbanken
](SSRS.DisableDelete.md)
+ [
## Deaktivieren von SSAS
](SSRS.DisableDelete.md#SSRS.Disable)
+ [
## Löschen der SSRS-Datenbanken
](SSRS.DisableDelete.md#SSRS.Drop)
## Einschränkungen und Empfehlungen
Die folgenden Einschränkungen und Empfehlungen gelten für die Ausführung von SSRS auf RDS für SQL Server:
+ Sie können SSRS nicht für DB-Instances verwenden, die Lesereplikate haben.
+ Instances müssen selbstverwaltetes Active Directory oder AWS Directory Service for Microsoft Active Directory für die SSRS-Webportal- und Webserverauthentifizierung verwenden. Weitere Informationen finden Sie unter [Arbeiten mit Active Directory mit RDS für SQL Server](User.SQLServer.ActiveDirectoryWindowsAuth.md).
+ Sie können die Datenbanken des Berichtsservers, die mit der Option SSIS erstellt wurden, nicht sichern.
+ Das Importieren und Wiederherstellen von Berichtsserverdatenbanken aus anderen SSRS-Instances wird nicht unterstützt. Weitere Informationen finden Sie unter [Berichtsserverdatenbanken](#SSRS.DBs).
+ Sie können SSRS nicht so konfigurieren, dass der standardmäßige SSL-Port (443) überwacht wird. Die zulässigen Werte sind 1150–49511, außer 1234, 1434, 3260, 3343, 3389 und 47001.
+ Abonnements per Microsoft Windows-Dateifreigabe werden nicht unterstützt.
+ Die Verwendung von Reporting Services Configuration Manager wird nicht unterstützt.
+ Das Erstellen und Ändern von Rollen wird nicht unterstützt.
+ Das Ändern der Eigenschaften des Berichtsservers wird nicht unterstützt.
+ Systemadministrator- und Systembenutzerrollen werden nicht erteilt.
+ Sie können Rollenzuweisungen auf Systemebene nicht über das Webportal bearbeiten.
# Aktivieren von SSAS
Verwenden Sie den folgenden Prozess, um SSAS für Ihre DB-Instance zu aktivieren:
1. Erstellen Sie eine neue Optionsgruppe oder wählen Sie eine bestehende Optionsgruppe aus.
1. Fügen Sie die Option `SSRS` zur Optionsgruppe hinzu.
1. Ordnen Sie die Optionsgruppe der DB-Instance zu.
1. Erlauben Sie eingehenden Zugriff auf die VPC-Sicherheitsgruppe (Virtual Private Cloud) für den SSRS-Listener-Port.
## Erstellen einer Optionsgruppe für SSRS
Um mit SSRS zu arbeiten, erstellen Sie eine Optionsgruppe, die der SQL Server-Engine und der Version der DB-Instance entspricht, die Sie verwenden möchten. Verwenden Sie dazu das AWS-Managementkonsole oder das AWS CLI.
**Anmerkung**
Sie können auch eine vorhandene Optionsgruppe verwenden, wenn es sich um die korrekte SQL Server-Engine und -Version handelt.
### Konsole
Mit der folgenden Prozedur wird eine Optionsgruppe für SQL Server Standard Edition 2017 erstellt.
**So erstellen Sie die Optionsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group** (Gruppe erstellen) aus.
1. Führen Sie im Bereich **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie **unter Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihrer Optionsgruppe einzigartig ist AWS-Konto, z. **ssrs-se-2017** B. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein, z. B. **SSRS option group for SQL Server SE 2017**. Die Beschreibung ist nur zur Information.
1. Wählen Sie für **Engine** die Option **sqlserver-se** aus.
1. Wählen Sie im Feld **Major Engine Version (Engine-Hauptversion)** **14.00** aus.
1. Wählen Sie **Erstellen** aus.
### CLI
Mit der folgenden Prozedur wird eine Optionsgruppe für SQL Server Standard Edition 2017 erstellt.
**So erstellen Sie die Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name ssrs-se-2017 \
--engine-name sqlserver-se \
--major-engine-version 14.00 \
--option-group-description "SSRS option group for SQL Server SE 2017"
```
Für Windows:
```
aws rds create-option-group ^
--option-group-name ssrs-se-2017 ^
--engine-name sqlserver-se ^
--major-engine-version 14.00 ^
--option-group-description "SSRS option group for SQL Server SE 2017"
```
## Hinzufügen der SSRS-Option zu Ihrer Optionsgruppe
Verwenden Sie als Nächstes das AWS-Managementkonsole oder, AWS CLI um die `SSRS` Option zu Ihrer Optionsgruppe hinzuzufügen.
### Konsole
**So fügen Sie die SSRS-Option hinzu**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die soeben erstellte Optionsgruppe aus, und wählen Sie dann **Option hinzufügen**.
1. Wählen Sie unter **Optionsdetails** für **Optionsname** die Option **SSRS** aus.
1. Führen Sie unter **Optionseinstellungen** die folgenden Schritte aus:
1. Geben Sie den Port ein, den der SSRS-Service überwachen soll. Der Standardwert ist 8443. Eine Liste der zulässigen Werte finden Sie unter [Einschränkungen und Empfehlungen](Appendix.SQLServer.Options.SSRS.md#SSRS.Limitations).
1. Geben Sie einen Wert für **Max. Speicher** ein.
**Max. Speicher** gibt den oberen Schwellenwert an, über dem keine neuen Speicherzuordnungsanforderungen für Berichtsserveranwendungen erteilt werden. Die Zahl ist ein Prozentsatz des Gesamtspeichers der DB-Instance. Die zulässigen Werte sind 10–80.
1. Wählen Sie für **Security groups (Sicherheitsgruppen)** die VPC-Sicherheitsgruppe aus, die der Option zugeordnet werden soll. Verwenden Sie dieselbe Sicherheitsgruppe, die Ihrer DB-Instance zugeordnet ist.
1. Um SSRS Email zum Senden von Berichten zu verwenden, wählen Sie die **E-Mail-Zustellungsoptionen konfigurieren**-Kontrollkästchen unter **E-Mail-Versand in Berichtsdiensten** und gehen Sie wie folgt vor:
1. Geben Sie unter **Absender-E-Mail-Adresse** die E-Mail-Adresse ein, die im Feld **Absender** der von SSRS Email gesendeten Nachrichten verwendet werden soll.
Geben Sie ein Benutzerkonto an, das die die die Berechtigung für das Senden von E-Mails vom SMTP-Server besitzt.
1. Für **SMTP-Server**, geben Sie den zu verwendenden SMTP-Server oder Gateway an.
Dabei kann es sich um eine IP-Adresse, den NetBIOS-Namen eines Computers im Intranet Ihres Unternehmens oder um einen vollqualifizierten Domänennamen handeln.
1. Für **SMTP-Anschluss**, geben Sie den Port ein, der für die Verbindung mit dem Mailserver verwendet werden soll. Der Standardwert ist 25.
1. So verwenden Sie die Authentifizierung:
1. Aktivieren Sie das Kontrollkästchen **Authentifizierung verwenden**.
1. Geben Sie für **Secret Amazon Resource Name (ARN)** den AWS Secrets Manager ARN für die Benutzeranmeldedaten ein.
Verwenden Sie das folgende Format:
**arn:aws:secretsmanager:*Region*:*AccountId*:secret:*SecretName*-*6RandomCharacters***
Beispiel:
**arn:aws:secretsmanager:*us-west-2*:*123456789012*:secret:*MySecret-a1b2c3***
Weitere Informationen über „creating the secret“ finden Sie in [Verwenden von SSRS E-Mail zum Senden von Berichten](SSRS.Email.md).
1. Aktivieren Sie das Kontrollkästchen **Secure Sockets Layer (SSL) verwenden**, um E-Mail-Nachrichten mit SSL zu verschlüsseln.
1. Wählen Sie unter **Planung** aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
### CLI
**So fügen Sie die SSRS-Option hinzu**
1. Erstellen Sie eine JSON-Datei, z. B. `ssrs-option.json`.
1. Setzen Sie die folgenden erforderlichen Parameter:
+ `OptionGroupName` – Der Name der Optionsgruppe, die Sie zuvor erstellt oder ausgewählt haben (`ssrs-se-2017` im folgenden Beispiel).
+ `Port` – Der Port, den der SSRS-Service überwachen soll. Der Standardwert ist 8443. Eine Liste der zulässigen Werte finden Sie unter [Einschränkungen und Empfehlungen](Appendix.SQLServer.Options.SSRS.md#SSRS.Limitations).
+ `VpcSecurityGroupMemberships` – VPC-Sicherheitsgruppenmitgliedschaften für Ihre RDS-DB-Instance.
+ `MAX_MEMORY` – Der obere Schwellenwert, über dem keine neuen Speicherzuordnungsanforderungen für Berichtsserveranwendungen erteilt werden. Die Zahl ist ein Prozentsatz des Gesamtspeichers der DB-Instance. Die zulässigen Werte sind 10–80.
1. (Optional) Legen Sie die folgenden Parameter für die Verwendung von SSRS-E-Mail fest:
+ `SMTP_ENABLE_EMAIL` – Einstellung auf `true`, um SSRS-E-Mail zu verwenden. Der Standardwert ist `false`.
+ `SMTP_SENDER_EMAIL_ADDRESS` - Die E-Mail-Adresse, die im **Von**-feld der von SSRS Email gesendeten Nachrichten verwendet werden soll. Geben Sie ein Benutzerkonto an, das die die die Berechtigung für das Senden von E-Mails vom SMTP-Server besitzt.
+ `SMTP_SERVER` – Der zu verwendende SMTP-Server oder Gateway. Dabei kann es sich um eine IP-Adresse, den NetBIOS-Namen eines Computers im Intranet Ihres Unternehmens oder um einen vollqualifizierten Domänennamen handeln.
+ `SMTP_PORT` – Der Port, der für die Verbindung mit dem Mailserver verwendet werden soll. Der Standardwert ist 25.
+ `SMTP_USE_SSL` – Einstellung auf `true`, um E-Mail-Nachrichten mit SSL zu verschlüsseln. Der Standardwert ist `true`.
+ `SMTP_EMAIL_CREDENTIALS_SECRET_ARN` – Der Secrets Manager Manager-ARN, der die Anmeldeinformationen des Benutzers enthält. Verwenden Sie das folgende Format:
**arn:aws:secretsmanager:*Region*:*AccountId*:secret:*SecretName*-*6RandomCharacters***
Weitere Informationen über „creating the secret“ finden Sie in [Verwenden von SSRS E-Mail zum Senden von Berichten](SSRS.Email.md).
+ `SMTP_USE_ANONYMOUS_AUTHENTICATION` – Einstellung auf `true` und nicht einschließen, `SMTP_EMAIL_CREDENTIALS_SECRET_ARN` wenn Sie keine Authentifizierung verwenden möchten.
Der Standardwert ist `false`, wenn `SMTP_ENABLE_EMAIL` ist `true`.
Das folgende Beispiel enthält die SSRS E-Mail-Parameter unter Verwendung des geheimen ARN.
```
{
"OptionGroupName": "ssrs-se-2017",
"OptionsToInclude": [
{
"OptionName": "SSRS",
"Port": 8443,
"VpcSecurityGroupMemberships": ["sg-0abcdef123"],
"OptionSettings": [
{"Name": "MAX_MEMORY","Value": "60"},
{"Name": "SMTP_ENABLE_EMAIL","Value": "true"}
{"Name": "SMTP_SENDER_EMAIL_ADDRESS","Value": "nobody@example.com"},
{"Name": "SMTP_SERVER","Value": "email-smtp.us-west-2.amazonaws.com"},
{"Name": "SMTP_PORT","Value": "25"},
{"Name": "SMTP_USE_SSL","Value": "true"},
{"Name": "SMTP_EMAIL_CREDENTIALS_SECRET_ARN","Value": "arn:aws:secretsmanager:us-west-2:123456789012:secret:MySecret-a1b2c3"}
]
}],
"ApplyImmediately": true
}
```
1. Fügen Sie die Option `SSRS` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--cli-input-json file://ssrs-option.json \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--cli-input-json file://ssrs-option.json ^
--apply-immediately
```
## Zuordnen Ihrer Optionsgruppe zu Ihrer DB-Instance
Verwenden Sie das AWS-Managementkonsole oder AWS CLI , um Ihre Optionsgruppe mit Ihrer DB-Instance zu verknüpfen.
Wenn Sie eine vorhandene DB-Instance verwenden, muss ihr bereits eine Active Directory-Domäne und eine AWS Identity and Access Management (IAM)-Rolle zugeordnet sein. Wenn Sie eine neue Instance erstellen, geben Sie eine vorhandene Active Directory-Domäne und IAM-Rolle an. Weitere Informationen finden Sie unter [Arbeiten mit Active Directory mit RDS für SQL Server](User.SQLServer.ActiveDirectoryWindowsAuth.md).
### Konsole
Sie können Ihre Optionsgruppe einer neuen oder vorhandenen DB-Instance zuordnen:
+ Ordnen Sie bei einer neuen DB-Instance die Optionsgruppe beim Starten der Instance zu. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ändern Sie für eine vorhandene DB-Instance die Instance und ordnen Sie die neue Optionsgruppe zu. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### CLI
Sie können Ihre Optionsgruppe einer neuen oder vorhandenen DB-Instance zuordnen.
**So erstellen Sie eine DB-Instance, die Ihre Optionsgruppe verwendet**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier myssrsinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 14.00.3223.3.v1 \
--allocated-storage 100 \
--manage-master-user-password \
--master-username admin \
--storage-type gp2 \
--license-model li \
--domain-iam-role-name my-directory-iam-role \
--domain my-domain-id \
--option-group-name ssrs-se-2017
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier myssrsinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 14.00.3223.3.v1 ^
--allocated-storage 100 ^
--manage-master-user-password ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--domain-iam-role-name my-directory-iam-role ^
--domain my-domain-id ^
--option-group-name ssrs-se-2017
```
**So ändern Sie eine DB-Instance für die Verwendung Ihrer Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier myssrsinstance \
--option-group-name ssrs-se-2017 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier myssrsinstance ^
--option-group-name ssrs-se-2017 ^
--apply-immediately
```
## Zulassen des eingehenden Zugriffs auf Ihre VPC-Sicherheitsgruppe
Um eingehenden Zugriff auf die VPC-Sicherheitsgruppe zu gewähren, die Ihrer DB-Instance zugeordnet ist, erstellen Sie eine eingehende Regel für den angegebenen SSRS-Listener-Port. Weitere Informationen zum Einrichten von Sicherheitsgruppen finden Sie unter [Ermöglichen des Zugriffs auf Ihre DB-Instance in der VPC durch Erstellen einer Sicherheitsgruppe](CHAP_SettingUp.md#CHAP_SettingUp.SecurityGroup).
## Berichtsserverdatenbanken
Wenn Ihre DB-Instance mit der Option SSRS verknüpft ist, werden zwei neue Datenbanken für Ihre DB-Instance erstellt:
+ `rdsadmin_ReportServer`
+ `rdsadmin_ReportServerTempDB`
Diese Datenbanken fungieren als ReportServer- und ReportServerTempDB-Datenbanken. SSRS speichert seine Daten in der ReportServer-Datenbank und speichert die Daten in der ReportServerTempDB-Datenbank zwischen. Weitere Informationen finden Sie unter [Berichtsserverdatenbank](https://learn.microsoft.com/en-us/sql/reporting-services/report-server/report-server-database-ssrs-native-mode?view=sql-server-ver15) in der Microsoft-Dokumentation.
RDS besitzt und verwaltet diese Datenbanken, sodass Datenbankoperationen auf ihnen wie ALTER und DROP nicht zulässig sind. Der Zugriff auf die Datenbank `rdsadmin_ReportServerTempDB` ist nicht zulässig. Sie können jedoch Lesevorgänge in der Datenbank `rdsadmin_ReportServer` ausführen.
## SSRS-Protokolldateien
Sie können SSRS-Protokolldateien auflisten, anzeigen und herunterladen. *SSRS-Protokolldateien folgen der Namenskonvention „ReportServerService\$1timestamp*.log“. Diese Berichtsserver-Protokolle befinden sich im Verzeichnis `D:\rdsdbdata\Log\SSRS`. (Das Verzeichnis `D:\rdsdbdata\Log` ist auch das übergeordnete Verzeichnis für Fehlerprotokolle und SQL-Server-Agent-Protokolle.) Weitere Informationen finden Sie unter [Anzeigen und Auflisten von Datenbank-Protokolldateien](USER_LogAccess.Procedural.Viewing.md).
Für vorhandene SSRS-Instances ist möglicherweise ein Neustart des SSRS-Service erforderlich, um auf Berichtsserverprotokolle zuzugreifen. Sie können den Service neu starten, indem Sie die `SSRS`-Option aktualisieren.
Weitere Informationen finden Sie unter [Arbeiten mit Microsoft-SQL-Server-Protokollen](Appendix.SQLServer.CommonDBATasks.Logs.md).
# Zugriff auf das SSRS-Webportal
Gehen Sie wie folgt vor, um auf das SSRS-Webportal zuzugreifen:
1. Aktivieren Sie Secure Sockets Layer (SSL).
1. Gewähren Sie Domänenbenutzern Zugriff.
1. Greifen Sie mit einem Browser und den Anmeldeinformationen des Domänenbenutzers auf das Webportal zu.
## Verwendung von SSL auf RDS
SSRS verwendet das HTTPS-SSL-Protokoll für seine Verbindungen. Um mit diesem Protokoll arbeiten zu können, importieren Sie ein SSL-Zertifikat in das Microsoft Windows-Betriebssystem auf Ihrem Client-Computer.
Weitere Informationen zu SSL-Zertifikaten finden Sie unter [](UsingWithRDS.SSL.md). Weitere Informationen über die Verwendung von SSL mit SQL Server finden Sie unter [Verwenden von SSL mit einer Microsoft SQL Server-DB-Instance](SQLServer.Concepts.General.SSL.Using.md).
## Gewähren des Zugriffs für Domänenbenutzer
Bei einer neuen SSRS-Aktivierung gibt es keine Rollenzuweisungen in SSRS. Um einem Domänenbenutzer oder einer Benutzergruppe Zugriff auf das Webportal zu gewähren, stellt RDS eine gespeicherte Prozedur bereit.
**So erteilen Sie einem Domänenbenutzer Zugriff auf das Webportal**
+ Verwenden Sie die folgende gespeicherte Prozedur.
```
exec msdb.dbo.rds_msbi_task
@task_type='SSRS_GRANT_PORTAL_PERMISSION',
@ssrs_group_or_username=N'AD_domain\user';
```
Dem Domänenbenutzer oder der Benutzergruppe wird die `RDS_SSRS_ROLE`-Systemrolle erteilt. Diese Rolle hat die folgenden Aufgaben auf Systemebene erteilt:
+ Führen Sie Berichte aus
+ Verwalten von Aufträgen
+ Verwalten von freigegebenen Zeitplänen
+ Anzeigen von freigegebenen Zeitplänen
Die Rolle `Content Manager` auf Elementebene im Stammordner wird ebenfalls gewährt.
## Zugriff auf das Webportal
Nachdem die `SSRS_GRANT_PORTAL_PERMISSION`-Aufgabe erfolgreich abgeschlossen wurde, haben Sie Zugriff auf das Portal über einen Webbrowser. Die Webportal-URL hat das folgende Format.
```
https://rds_endpoint:port/Reports
```
In diesem Format gilt Folgendes:
+ *`rds_endpoint`* – Der Endpunkt für die RDS-DB-Instance, die Sie mit SSRS verwenden.
Sie finden den Endpunkt auf der Registerkarte **Konnektivität und Sicherheit** für Ihre DB-Instance. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
+ `port` – Der Listener-Port für SSRS, den Sie in der `SSRS`-Option festgelegt haben.
**So greifen Sie auf das Webportal zu**
1. Geben Sie die Webportal-URL in Ihrem Browser ein.
```
https://myssrsinstance.cg034itsfake.us-east-1.rds.amazonaws.com:8443/Reports
```
1. Melden Sie sich mit den Anmeldeinformationen für einen Domänenbenutzer an, dem Sie Zugriff mit der `SSRS_GRANT_PORTAL_PERMISSION`-Aufgabe gewährt haben.
# Bereitstellen von Berichten und Konfigurieren von Berichtsdatenquellen
Verwenden Sie die folgenden Verfahren, um Berichte für SSRS bereitzustellen und die Berichtsdatenquellen zu konfigurieren:
**Topics**
+ [
## Bereitstellen von Berichten zu SSRS
](#SSRS.Deploy)
+ [
## Konfigurieren der Berichtsdatenquelle
](#SSRS.ConfigureDataSource)
## Bereitstellen von Berichten zu SSRS
Nachdem Sie Zugriff auf das Webportal haben, können Sie Berichte für das Webportal bereitstellen. Sie können das Upload-Tool im Webportal verwenden, um Berichte hochzuladen oder direkt über [SQL Server Data Tools (SSDT)](https://docs.microsoft.com/en-us/sql/ssdt/download-sql-server-data-tools-ssdt) bereitzustellen. Stellen Sie bei der Bereitstellung von SSDT Folgendes sicher:
+ Der Benutzer, der SSDT gestartet hat, hat Zugriff auf das SSRS-Webportal.
+ Der `TargetServerURL`-Wert in den SSRS-Projekteigenschaften ist auf den HTTPS-Endpunkt der RDS-DB-Instance mit dem Suffix `ReportServer` gesetzt, zum Beispiel:
```
https://myssrsinstance.cg034itsfake.us-east-1.rds.amazonaws.com:8443/ReportServer
```
## Konfigurieren der Berichtsdatenquelle
Nachdem Sie einen Bericht für SSRS bereitgestellt haben, sollten Sie die Berichtsdatenquelle konfigurieren. Achten Sie beim Konfigurieren der Berichtsdatenquelle auf Folgendes:
+ Für DB-Instances von RDS für SQL Server, die AWS Directory Service for Microsoft Active Directory angeschlossen sind, verwenden Sie den vollqualifizierten Domain-Namen (FQDN) als Datenquellennamen der Verbindungszeichenfolge. Ein Beispiel ist `myssrsinstance.corp-ad.example.com`, wobei `myssrsinstance` der Name der DB-Instance und `corp-ad.example.com` der vollqualifizierte Domänenname ist.
+ Für DB-Instances von RDS für SQL Server, die mit dem selbstverwalteten Active Directory verbunden sind, verwenden Sie `.` oder `LocalHost` als Datenquellenname der Verbindungszeichenfolge.
# Verwenden von SSRS E-Mail zum Senden von Berichten
SSRS enthält die SSRS E-Mail-Erweiterung, mit der Sie Berichte an Benutzer senden können.
Um SSRS Email zu konfigurieren, verwenden Sie die `SSRS`-Optionseinstellungen. Weitere Informationen finden Sie unter [Hinzufügen der SSRS-Option zu Ihrer Optionsgruppe](SSRS.Enabling.md#SSRS.Add).
Nachdem Sie SSRS Email konfiguriert haben, können Sie Berichte auf dem Berichtsserver abonnieren. Weitere Informationen finden Sie unter [E-Mail-Versand in Reporting Services](https://docs.microsoft.com/en-us/sql/reporting-services/subscriptions/e-mail-delivery-in-reporting-services) in der Microsoft-Dokumentation.
Die Integration mit AWS Secrets Manager ist erforderlich, damit SSRS-E-Mail auf RDS funktioniert. Um mit Secrets Manager zu integrieren, erstellen Sie ein Secret.
**Anmerkung**
Wenn Sie das Geheimnis später ändern, müssen Sie auch die `SSRS`-Option in der Optionsgruppe aktualisieren.
**Ein Secret für SSRS-E-Mail erstellen**
1. Befolgen Sie die Schritte unter [Erstellen eines Geheimnisses](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) im *AWS Secrets ManagerBenutzerhandbuch*.
1. Wählen Sie für **Select secret type (Secret-Typ auswählen)** die Option **Other type of secrets (Anderer Secret-Typ)** aus.
1. Für **Schlüssel-Wert-Paare** geben Sie Folgendes ein:
+ **SMTP\$1USERNAME** – Geben Sie einen Benutzer ein, der berechtigt ist, E-Mails vom SMTP-Server zu senden.
+ **SMTP\$1PASSWORD** – Geben Sie ein Passwort für den SMTP-Benutzer ein.
1. Verwenden Sie für den **Verschlüsselungscode** nicht die Standardeinstellung AWS KMS key. Verwenden Sie Ihren eigenen vorhandenen Schlüssel oder erstellen Sie einen neuen.
Die KMS-Schlüsselrichtlinie muss die `kms:Decrypt`-Aktion zulassen, zum Beispiel:
```
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"Service": [
"rds.amazonaws.com"
]
},
"Action": [
"kms:Decrypt"
],
"Resource": "*"
}
```
1. Führen Sie die Schritte unter [Anhängen einer Berechtigungsrichtlinie an ein Geheimnis](https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access_resource-policies.html) im *AWS Secrets ManagerBenutzerhandbuch aus*. Die Berechtigungsrichtlinie gibt die `secretsmanager:GetSecretValue`-Aktion an den `rds.amazonaws.com` Service Principal weiter.
Wir empfehlen Ihnen, die `aws:sourceAccount` und `aws:sourceArn` Bedingungen in der Police zu verwenden, um das Problem des *verwirrten Vertreters* zu vermeiden. Verwenden Sie Ihren AWS-Konto for `aws:sourceAccount` und den ARN für die Optionsgruppe`aws:sourceArn`. Weitere Informationen finden Sie unter [Vermeidung des dienstübergreifenden Confused-Deputy-Problems](cross-service-confused-deputy-prevention.md).
Das folgende Beispiel zeigt eine Berechtigungsrichtlinie.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement" : [ {
"Effect" : "Allow",
"Principal" : {
"Service" : "rds.amazonaws.com"
},
"Action" : "secretsmanager:GetSecretValue",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"aws:sourceAccount" : "123456789012"
},
"ArnLike" : {
"aws:sourceArn" : "arn:aws:rds:us-west-2:123456789012:og:ssrs-se-2017"
}
}
} ]
}
```
------
Weitere Beispiele finden Sie unter [Beispiele für Berechtigungsrichtlinien für AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access_examples.html) im *AWS Secrets ManagerBenutzerhandbuch*.
# Widerrufen von Berechtigungen auf Systemebene
Die `RDS_SSRS_ROLE`-Systemrolle verfügt nicht über ausreichende Berechtigungen zum Löschen von Rollenzuweisungen auf Systemebene. Verwenden Sie zum Entfernen eines Benutzers oder einer Benutzergruppe aus `RDS_SSRS_ROLE` dieselbe gespeicherte Prozedur, die Sie zum Erteilen der Rolle verwendet haben, verwenden Sie jedoch den `SSRS_REVOKE_PORTAL_PERMISSION`-Aufgabentyp.
**So widerrufen Sie den Zugriff eines Domänenbenutzers für das Webportal**
+ Verwenden Sie die folgende gespeicherte Prozedur.
```
exec msdb.dbo.rds_msbi_task
@task_type='SSRS_REVOKE_PORTAL_PERMISSION',
@ssrs_group_or_username=N'AD_domain\user';
```
Dadurch wird der Benutzer aus der `RDS_SSRS_ROLE`-Systemrolle gelöscht. Außerdem wird der Benutzer aus der `Content Manager`-Rolle auf Elementebene gelöscht, wenn der Benutzer sie hat.
# Überwachung des Status einer Aufgabe
Rufen Sie die `rds_fn_task_status`-Funktion auf, um den Status Ihrer Erteilungs- oder Widerrufsaufgabe zu verfolgen. Dazu sind zwei Parameter erforderlich. Der erste Parameter sollte immer `NULL` sein, da er sich nicht auf SSRS bezieht. Der zweite Parameter akzeptiert eine Aufgaben-ID.
Um eine Liste aller Aufgaben anzuzeigen, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf `0`, wie im folgenden Beispiel gezeigt.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```
Um eine bestimmte Aufgabe zu erhalten, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf die Aufgaben-ID, wie im folgenden Beispiel gezeigt,
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```
Die `rds_fn_task_status`-Funktion gibt die folgenden Informationen zurück.
| Ausgabeparameter | Beschreibung |
| --- | --- |
| `task_id` | Die ID der Aufgabe. |
| `task_type` | Für SSRS können Aufgaben die folgenden Aufgabentypen haben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SSRS.Monitor.html) |
| `database_name` | Gilt nicht für SSRS-Aufgaben. |
| `% complete` | Verlauf der Aufgabe als Prozentwert. |
| `duration (mins)` | Zeitdauer für die Ausführung der Aufgabe (in Minuten). |
| `lifecycle` | Der Status der Aufgabe. Die folgenden Status sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SSRS.Monitor.html) |
| `task_info` | Zusätzliche Informationen über die Aufgabe. Wenn bei der Verarbeitung ein Fehler auftritt, enthält diese Spalte Informationen zu dem Fehler. |
| `last_updated` | Datum und Uhrzeit der letzten Aktualisierung des Aufgabenstatus. |
| `created_at` | Datum und Uhrzeit, an denen die Aufgabe angelegt wurde. |
| `S3_object_arn` | Gilt nicht für SSRS-Aufgaben. |
| `overwrite_S3_backup_file` | Gilt nicht für SSRS-Aufgaben. |
| `KMS_master_key_arn` | Gilt nicht für SSRS-Aufgaben. |
| `filepath` | Gilt nicht für SSRS-Aufgaben. |
| `overwrite_file` | Gilt nicht für SSRS-Aufgaben. |
| `task_metadata` | Metadaten, die der SSRS-Aufgabe zugeordnet sind. |
# Deaktivieren und Löschen von SSRS-Datenbanken
Gehen Sie wie folgt vor, um SSRS zu deaktivieren und SSRS-Datenbanken zu löschen:
**Topics**
+ [
## Deaktivieren von SSAS
](#SSRS.Disable)
+ [
## Löschen der SSRS-Datenbanken
](#SSRS.Drop)
## Deaktivieren von SSAS
Um SSAS zu deaktivieren, entfernen Sie die Option `SSRS` aus der Optionsgruppe. Wenn Sie die Option entfernen, werden die SSRS-Datenbanken nicht gelöscht. Weitere Informationen finden Sie unter [Löschen der SSRS-Datenbanken](#SSRS.Drop).
Sie können SSRS wieder einschalten, indem Sie die `SSRS` Option wieder hinzufügen. Wenn Sie auch die SSRS-Datenbanken gelöscht haben, werden durch das Lesen der Option auf derselben DB-Instance neue Berichtsserver-Datenbanken erstellt.
### Konsole
**So entfernen Sie die SSRS-Option aus der Optionsgruppe**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `SSRS` (`ssrs-se-2017` in den vorherigen Beispielen).
1. Wählen Sie **Delete option (Option löschen)** aus.
1. Wählen Sie unter **Löschoptionen** für **Zu löschende Optionen** die Option **SSRS** aus.
1. Wählen Sie unter **Apply immediately (Sofort anwenden)** die Option **Yes (Ja)** aus, um die Option sofort zu löschen, oder **No (Nein)**, um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Delete (Löschen)**.
### CLI
**So entfernen Sie die SSRS-Option aus der Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name ssrs-se-2017 \
--options SSRS \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name ssrs-se-2017 ^
--options SSRS ^
--apply-immediately
```
## Löschen der SSRS-Datenbanken
Wenn Sie die `SSRS`-Option entfernen, werden die Berichtsserverdatenbanken nicht gelöscht. Verwenden Sie die folgende gespeicherte Prozedur, um sie zu löschen.
Um die Berichtsserverdatenbanken zu löschen, müssen Sie zuerst die `SSRS`-Option entfernen.
**So löschen Sie die SSRS-Datenbanken**
+ Verwenden Sie die folgende gespeicherte Prozedur.
```
exec msdb.dbo.rds_drop_ssrs_databases
```
# Unterstützung für Microsoft Distributed Transaction Coordinator in RDS für SQL Server
Eine *verteilte Transaktion* ist eine Datenbanktransaktion, an der zwei oder mehr Netzwerkhosts beteiligt sind. RDS für SQL Server unterstützt verteilte Transaktionen zwischen Hosts, wobei ein einzelner Host einer der folgenden sein kann:
+ RDS für SQL Server-DB-Instance
+ Lokaler SQL Server-Host
+ Amazon EC2-Host mit installiertem SQL Server
+ Alle anderen EC2-Host- oder RDS-DB-Instances mit einer Datenbank-Engine, die verteilte Transaktionen unterstützt
In RDS, beginnend mit SQL Server 2012 (Version 11.00.5058.0.v1 und höher), unterstützen alle Editionen von RDS für SQL Server verteilte Transaktionen. Die Unterstützung wird mithilfe von Microsoft Distributed Transaction Coordinator (MSDTC) bereitgestellt. Ausführliche Informationen zu MSDTC finden Sie unter [Distributed Transaction Coordinator](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/ms684146(v=vs.85)) in der Microsoft-Dokumentation.
**Contents**
+ [
## Einschränkungen
](#Appendix.SQLServer.Options.MSDTC.Limitations)
+ [
# Aktivieren von MSDTC
](Appendix.SQLServer.Options.MSDTC.Enabling.md)
+ [
## Erstellen der Optionsgruppe für MSDTC
](Appendix.SQLServer.Options.MSDTC.Enabling.md#Appendix.SQLServer.Options.MSDTC.OptionGroup)
+ [
## Hinzufügen der MSDTC-Option zur Optionsgruppe
](Appendix.SQLServer.Options.MSDTC.Enabling.md#Appendix.SQLServer.Options.MSDTC.Add)
+ [
## Erstellen der Parametergruppe für MSDTC
](Appendix.SQLServer.Options.MSDTC.Enabling.md#MSDTC.CreateParamGroup)
+ [
## Ändern des Parameters für MSDTC
](Appendix.SQLServer.Options.MSDTC.Enabling.md#ModifyParam.MSDTC)
+ [
## Zuordnen der Options- und Parametergruppe zur DB-Instance
](Appendix.SQLServer.Options.MSDTC.Enabling.md#MSDTC.Apply)
+ [
## Ändern der MSDTC-Option
](Appendix.SQLServer.Options.MSDTC.Enabling.md#Appendix.SQLServer.Options.MSDTC.Modify)
+ [
## Verwenden von Transaktionen
](#Appendix.SQLServer.Options.MSDTC.Using)
+ [
### Verwenden verteilter Transaktionen
](#Appendix.SQLServer.Options.MSDTC.UsingXA)
+ [
### XA-Transaktionen verwenden
](#MSDTC.XA)
+ [
### Verwenden der Transaktionsnachverfolgung
](#MSDTC.Tracing)
+ [
# Deaktivieren von MSDTC
](Appendix.SQLServer.Options.MSDTC.Disable.md)
+ [
# Problembehandlung bei MSDTC für RDS für SQL Server
](Appendix.SQLServer.Options.MSDTC.Troubleshooting.md)
## Einschränkungen
Die folgenden Einschränkungen gelten für die Verwendung von MSDTC auf RDS für SQL Server:
+ MSDTC wird auf Instances, welche die SQL Server-Datenbankspiegelung verwenden, nicht unterstützt. Weitere Informationen finden Sie unter [Transaktionen - Verfügbarkeitsgruppen und Datenbankspiegelung](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/transactions-always-on-availability-and-database-mirroring?view=sql-server-ver15#non-support-for-distributed-transactions).
+ Der Parameter `in-doubt xact resolution` muss auf 1 oder 2 gesetzt werden. Weitere Informationen finden Sie unter [Ändern des Parameters für MSDTC](Appendix.SQLServer.Options.MSDTC.Enabling.md#ModifyParam.MSDTC).
+ MSDTC erfordert, dass alle Hosts, die an verteilten Transaktionen beteiligt sind, mit ihren Hostnamen auflösbar sind. RDS verwaltet diese Funktionalität automatisch für domänengebundene Instances. Achten Sie jedoch bei eigenständigen Instances darauf, den DNS-Server manuell zu konfigurieren.
+ XA-Transaktionen (Java Database Connectivity) werden für SQL Server 2017, Version 14.00.3223.3 und höher, und SQL Server 2019, unterstützt.
+ Verteilte Transaktionen, die von Client-Dynamic-Link-Bibliotheken (DLLs) auf RDS-Instances abhängen, werden nicht unterstützt.
+ Die Verwendung benutzerdefinierter dynamischer XA-Verknüpfungsbibliotheken wird nicht unterstützt.
# Aktivieren von MSDTC
Verwenden Sie den folgenden Prozess, um MSDTC für Ihre DB-Instance zu aktivieren:
1. Erstellen Sie eine neue Optionsgruppe oder wählen Sie eine bestehende Optionsgruppe aus.
1. Fügen Sie die Option `MSDTC` zur Optionsgruppe hinzu.
1. Erstellen Sie eine neue Parametergruppe oder wählen Sie eine vorhandene Parametergruppe aus.
1. Ändern Sie die Parametergruppe, um den Parameter `in-doubt xact resolution` auf 1 oder 2 festzulegen.
1. Ordnen Sie die Optionsgruppe und die Parametergruppe der DB-Instance zu.
## Erstellen der Optionsgruppe für MSDTC
Verwenden Sie die AWS-Managementkonsole oder AWS CLI, um eine Optionsgruppe zu erstellen, die der SQL Server-Engine und der Version Ihrer DB-Instance entspricht.
**Anmerkung**
Sie können auch eine vorhandene Optionsgruppe verwenden, wenn es sich um die korrekte SQL Server-Engine und -Version handelt.
### Konsole
Mit der folgenden Konsolenprozedur wird eine Optionsgruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Optionsgruppe**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group (Gruppe erstellen)** aus.
1. Führen Sie im Bereich **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie unter **Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihres AWS-Kontos nur einmal vorkommt, z. B. **msdtc-se-2016**. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein, z. B. **MSDTC option group for SQL Server SE 2016**. Die Beschreibung ist nur zur Information.
1. Wählen Sie für **Engine** die Option **sqlserver-se** aus.
1. Wählen Sie im Feld **Engine-Hauptversion** **13.00** aus.
1. Wählen Sie **Erstellen** aus.
### CLI
Im folgenden Beispiel wird eine Optionsgruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Optionsgruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name msdtc-se-2016 \
--engine-name sqlserver-se \
--major-engine-version 13.00 \
--option-group-description "MSDTC option group for SQL Server SE 2016"
```
Für Windows:
```
aws rds create-option-group ^
--option-group-name msdtc-se-2016 ^
--engine-name sqlserver-se ^
--major-engine-version 13.00 ^
--option-group-description "MSDTC option group for SQL Server SE 2016"
```
## Hinzufügen der MSDTC-Option zur Optionsgruppe
Verwenden Sie als Nächstes die AWS-Managementkonsole oder AWS CLI, um die Option `MSDTC` zur Optionsgruppe hinzuzufügen.
Die folgenden Optionseinstellungen sind erforderlich:
+ **Port** – Der Port, den Sie für den Zugriff auf MSDTC verwenden. Zulässige Werte sind 1150–49151 mit Ausnahme von 1234, 1434, 3260, 3343, 3389 und 47001. Der Standardwert ist 5000.
Stellen Sie sicher, dass der zu verwendende Port in den Firewall-Regeln aktiviert ist. Stellen Sie außerdem sicher, dass dieser Port bei Bedarf in den ein- und ausgehenden Regeln für die Sicherheitsgruppe aktiviert ist, die Ihrer DB-Instance zugeordnet ist. Weitere Informationen finden Sie unter [Verbindung zur Amazon-RDS-DB-Instance kann nicht hergestellt werden](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
+ **Sicherheitsgruppen** – Die VPC-Sicherheitsgruppenmitgliedschaften für Ihre RDS-DB-Instance.
+ **Authentifizierungstyp** – Der Authentifizierungsmodus zwischen Hosts. Die folgenden Authentifizierungstypen werden unterstützt:
+ Gegenseitig – Die RDS-Instances werden gegenseitig mittels integrierter Authentifizierung authentifiziert. Wenn diese Option ausgewählt ist, müssen alle Instances, die dieser Optionsgruppe zugeordnet sind, einer Domäne zugeordnet sein.
+ Keine – Es wird keine Authentifizierung zwischen Hosts durchgeführt. Es wird nicht empfohlen, diesen Modus in Produktionsumgebungen zu verwenden.
+ **Transaktionsprotokollgröße** – Die Größe des MSDTC-Transaktionsprotokolls. Zulässige Werte sind 4–1024 MB. Die Standardgröße beträgt 4 MB.
Die folgenden Optionseinstellungen sind optional:
+ **Eingehende Verbindungen aktivieren** – Gibt an, ob eingehende MSDTC-Verbindungen zu Instances zugelassen werden sollen, die dieser Optionsgruppe zugeordnet sind.
+ **Ausgehende Verbindungen aktivieren** – Gibt an, ob ausgehende MSDTC-Verbindungen von Instances zugelassen werden sollen, die dieser Optionsgruppe zugeordnet sind.
+ **XA aktivieren** – Gibt an, ob XA-Transaktionen zugelassen werden sollen. Weitere Informationen zum XA-Protokoll finden Sie unter [XA-Spezifikation](https://publications.opengroup.org/c193).
+ **SNA LU aktivieren** – Gibt an, ob das SNA LU-Protokoll für verteilte Transaktionen verwendet werden kann. Weitere Informationen zur Unterstützung des SNA LU-Protokolls finden Sie unter [Verwalten von IBM CICS LU 6.2-Transaktionen](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/ms685136(v=vs.85)) in der Microsoft-Dokumentation.
### Konsole
**So fügen Sie die MSDTC-Option hinzu**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe aus, die Sie gerade erstellt haben.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. Wählen Sie unter **Optionsdetails** für **Optionsname** die Option **MSDTC** aus.
1. Unter **Optionseinstellungen**:
1. Geben Sie unter **Port** die Portnummer für den Zugriff auf MSDTC ein. Der Standardwert ist **5000**.
1. Wählen Sie für **Security groups (Sicherheitsgruppen)** die VPC-Sicherheitsgruppe aus, die der Option zugeordnet werden soll.
1. Wählen Sie für **Authentifizierungstyp** die Option **Gegenseitig** oder **Keine** aus.
1. Geben Sie für **Transaktionsprotokollgröße** einen Wert von 4–1024 ein. Der Standardwert ist **4**.
1. Führen Sie unter **Zusätzliche Konfiguration** die folgenden Schritte aus:
1. Wählen Sie für **Verbindungen** nach Bedarf die Option **Eingehende Verbindungen aktivieren** und **Ausgehende Verbindungen aktivieren** aus.
1. Wählen Sie für **Zulässige Protokolle** nach Bedarf die Option **XA aktivieren** und **SNA LU aktivieren** aus.
1. Wählen Sie unter **Scheduling (Planung)** aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
Um diese Option hinzuzufügen, ist kein Neustart erforderlich.
### CLI
**So fügen Sie die MSDTC-Option hinzu**
1. Erstellen Sie beispielsweise `msdtc-option.json`, eine JSON-Datei mit den folgenden erforderlichen Parametern.
```
{
"OptionGroupName":"msdtc-se-2016",
"OptionsToInclude": [
{
"OptionName":"MSDTC",
"Port":5000,
"VpcSecurityGroupMemberships":["sg-0abcdef123"],
"OptionSettings":[{"Name":"AUTHENTICATION","Value":"MUTUAL"},{"Name":"TRANSACTION_LOG_SIZE","Value":"4"}]
}],
"ApplyImmediately": true
}
```
1. Fügen Sie die Option `MSDTC` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--cli-input-json file://msdtc-option.json \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--cli-input-json file://msdtc-option.json ^
--apply-immediately
```
Es ist kein Neustart erforderlich.
## Erstellen der Parametergruppe für MSDTC
Erstellen oder ändern Sie eine Parametergruppe für den `in-doubt xact resolution`-Parameter, der der SQL Server-Edition und der Version Ihrer DB-Instance entspricht.
### Konsole
Im folgenden Beispiel wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie **Create parameter group (Parametergruppe erstellen)**.
1. Führen Sie im Bereich **Parametergruppe erstellen** die folgenden Schritte aus:
1. Wählen Sie für **Parametergruppenfamilie** die Option **sqlserver-se-13.0** aus.
1. Geben Sie unter **Gruppenname** einen Bezeichner für die Parametergruppe ein, z. B. **msdtc-sqlserver-se-13**.
1. Geben Sie für **Beschreibung** den Text **in-doubt xact resolution** ein.
1. Wählen Sie **Erstellen** aus.
### CLI
Im folgenden Beispiel wird eine Parametergruppe für SQL Server Standard Edition 2016 erstellt.
**So erstellen Sie die Parametergruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-parameter-group \
--db-parameter-group-name msdtc-sqlserver-se-13 \
--db-parameter-group-family "sqlserver-se-13.0" \
--description "in-doubt xact resolution"
```
Für Windows:
```
aws rds create-db-parameter-group ^
--db-parameter-group-name msdtc-sqlserver-se-13 ^
--db-parameter-group-family "sqlserver-se-13.0" ^
--description "in-doubt xact resolution"
```
## Ändern des Parameters für MSDTC
Ändern Sie den `in-doubt xact resolution`-Parameter in der Parametergruppe, die der SQL Server-Edition und der Version Ihrer DB-Instance entspricht.
Legen Sie für MSDTC den `in-doubt xact resolution`-Parameter auf einen der folgenden Parameter fest:
+ `1` – `Presume commit`. Alle unsicheren MSDTC-Transaktionen werden als übermittelt angesehen.
+ `2` – `Presume abort`. Alle unsicheren MSDTC-Transaktionen werden als gestoppt angesehen.
Weitere Informationen finden Sie unter [Lösung für unklare Transaktion (Serverkonfigurationsoption)](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/in-doubt-xact-resolution-server-configuration-option) in der Microsoft-Dokumentation.
### Konsole
Im folgenden Beispiel wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben.
**So ändern Sie die Parametergruppe**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie die Parametergruppe aus, z. B. **msdtc-sqlserver-se-13**.
1. Filtern Sie unter **Parameter** die Parameterliste nach **xact**.
1. Wählen Sie **in-doubt xact resolution** aus.
1. Wählen Sie **Parameter bearbeiten** aus.
1. Geben Sie **1** oder **2** ein.
1. Wählen Sie **Änderungen speichern ** aus.
### CLI
Im folgenden Beispiel wird die Parametergruppe geändert, die Sie für SQL Server Standard Edition 2016 erstellt haben.
**So ändern Sie die Parametergruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name msdtc-sqlserver-se-13 \
--parameters "ParameterName='in-doubt xact resolution',ParameterValue=1,ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name msdtc-sqlserver-se-13 ^
--parameters "ParameterName='in-doubt xact resolution',ParameterValue=1,ApplyMethod=immediate"
```
## Zuordnen der Options- und Parametergruppe zur DB-Instance
Sie können die AWS-Managementkonsole oder AWS CLI verwenden, um die MSDTC-Optionsgruppe und die Parametergruppe der DB-Instance zuzuordnen.
### Konsole
Sie können die MSDTC-Optionsgruppe und die Parametergruppe einer neuen oder vorhandenen DB-Instance zuordnen.
+ Ordnen Sie sie bei einer neuen DB-Instance zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ordnen Sie sie für eine vorhandene DB-Instance zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
**Anmerkung**
Wenn Sie eine vorhandene Instance verwenden, die einer Domäne beigetreten ist, muss ihr bereits eine Active Directory-Domäne und eine AWS Identity and Access Management (IAM)-Rolle zugeordnet sein. Wenn Sie eine neue Instance erstellen, die einer Domäne beigetreten ist, geben Sie eine vorhandene Active Directory-Domäne und IAM-Rolle an. Weitere Informationen finden Sie unter [Arbeiten mit AWS Managed Active Directory mit RDS für SQL Server](USER_SQLServerWinAuth.md).
### CLI
Sie können die MSDTC-Optionsgruppe und die Parametergruppe einer neuen oder vorhandenen DB-Instance zuordnen.
**Anmerkung**
Wenn Sie eine vorhandene Instance verwenden, die einer Domäne beigetreten ist, muss ihr bereits eine Active Directory-Domäne und eine IAM-Rolle zugeordnet sein. Wenn Sie eine neue Instance erstellen, die einer Domäne beigetreten ist, geben Sie eine vorhandene Active Directory-Domäne und IAM-Rolle an. Weitere Informationen finden Sie unter [Arbeiten mit AWS Managed Active Directory mit RDS für SQL Server](USER_SQLServerWinAuth.md).
**So erstellen Sie eine DB-Instance mit der MSDTC-Optionsgruppe und der Parametergruppe**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 13.00.5426.0.v1 \
--allocated-storage 100 \
--manage-master-user-password \
--master-username admin \
--storage-type gp2 \
--license-model li \
--domain-iam-role-name my-directory-iam-role \
--domain my-domain-id \
--option-group-name msdtc-se-2016 \
--db-parameter-group-name msdtc-sqlserver-se-13
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mydbinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 13.00.5426.0.v1 ^
--allocated-storage 100 ^
--manage-master-user-password ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--domain-iam-role-name my-directory-iam-role ^
--domain my-domain-id ^
--option-group-name msdtc-se-2016 ^
--db-parameter-group-name msdtc-sqlserver-se-13
```
**So ändern Sie eine DB-Instance und ordnen die MSDTC-Optionsgruppe und die Parametergruppe zu**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--option-group-name msdtc-se-2016 \
--db-parameter-group-name msdtc-sqlserver-se-13 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--option-group-name msdtc-se-2016 ^
--db-parameter-group-name msdtc-sqlserver-se-13 ^
--apply-immediately
```
## Ändern der MSDTC-Option
Nachdem Sie die Option `MSDTC` aktiviert haben, können Sie ihre Einstellungen ändern. Weitere Informationen über das Ändern von Optionseinstellungen finden Sie unter [Ändern einer Optionseinstellung](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption).
**Anmerkung**
Bei einigen Änderungen an den MSDTC-Optionseinstellungen muss der MSDTC-Service neu gestartet werden. Diese Anforderung kann sich auf die Ausführung verteilter Transaktionen auswirken.
## Verwenden von Transaktionen
### Verwenden verteilter Transaktionen
In Amazon RDS für SQL Server führen Sie verteilte Transaktionen auf die gleiche Weise aus wie verteilte Transaktionen, die lokal ausgeführt werden:
+ Mithilfe von heraufstufbaren `System.Transactions`-Transaktionen im .NET Framework, die verteilte Transaktionen optimieren, indem ihre Erstellung so lange verschoben wird, bis sie benötigt werden.
In diesem Fall erfolgt die Heraufstufung automatisch und erfordert keine Intervention. Wenn nur ein Ressourcenmanager innerhalb der Transaktion vorhanden ist, wird keine Heraufstufung durchgeführt. Weitere Informationen zu impliziten Transaktionsbereichen finden Sie unter [Implementieren einer impliziten Transaktion mit Transaktionsbereich](https://docs.microsoft.com/en-us/dotnet/framework/data/transactions/implementing-an-implicit-transaction-using-transaction-scope) in der Microsoft-Dokumentation.
Heraufstufbare Transaktionen werden mit folgenden .NET-Implementierungen unterstützt:
+ Beginnend mit ADO.NET 2.0 unterstützt `System.Data.SqlClient` heraufstufbare Transaktionen mit SQL Server. Weitere Informationen finden Sie unter [System.Transactions-Integration in SQL Server](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/system-transactions-integration-with-sql-server) in der Microsoft-Dokumentation.
+ ODP.NET unterstützt `System.Transactions`. Für die erste Verbindung, die im `TransactionsScope`-Bereich zu Oracle Database 11g Release 1 (Version 11.1) und höher geöffnet wurde, wird eine lokale Transaktion erstellt. Wenn eine zweite Verbindung geöffnet wird, wird diese Transaktion automatisch zu einer verteilten Transaktion heraufgestuft. Weitere Informationen zur Unterstützung verteilter Transaktionen in ODP.NET finden Sie unter [Microsoft Distributed Transaction Coordinator-Integration](https://docs.oracle.com/en/database/oracle/oracle-data-access-components/18.3/ntmts/using-mts-with-oracledb.html) in der Microsoft-Dokumentation.
+ Verwenden der `BEGIN DISTRIBUTED TRANSACTION`-Anweisung. Weitere Informationen finden Sie unter [BEGIN DISTRIBUTED TRANSACTION (Transact-SQL)](https://docs.microsoft.com/en-us/sql/t-sql/language-elements/begin-distributed-transaction-transact-sql) in der Microsoft-Dokumentation.
### XA-Transaktionen verwenden
Ab RDS für SQL Server 2017, Version 14.00.3223.3, können Sie verteilte Transaktionen mit JDBC steuern. Wenn Sie die`Enable XA`Optionseinstellung auf`true`im`MSDTC`aktiviert, aktiviert RDS automatisch JDBC-Transaktionen und gewährt die`SqlJDBCXAUser`-Rolle auf die`guest`-Benutzer. Dies ermöglicht die Ausführung verteilter Transaktionen über JDBC. Weitere Informationen, einschließlich eines Code-Beispiels, finden Sie unter unter.[XA-Transaktionen](https://docs.microsoft.com/en-us/sql/connect/jdbc/understanding-xa-transactions)in der Microsoft-Dokumentation.
### Verwenden der Transaktionsnachverfolgung
RDS unterstützt die Steuerung von MSDTC-Transaktionsnachverfolgungen und deren Herunterladen aus der RDS-DB-Instance zur Fehlerbehebung. Sie können Transaktionsnachverfolgungssitzungen steuern, indem Sie die folgende gespeicherte RDS-Prozedur ausführen.
```
exec msdb.dbo.rds_msdtc_transaction_tracing 'trace_action',
[@traceall='0|1'],
[@traceaborted='0|1'],
[@tracelong='0|1'];
```
Der folgende Parameter ist erforderlich:
+ `trace_action` – Die Nachverfolgungsaktion. Sie kann `START`, `STOP` oder `STATUS` sein.
Die folgenden Parameter sind optional:
+ `@traceall` – Setzen Sie auf 1, um alle verteilten Transaktionen nachzuverfolgen. Der Standardwert ist 0.
+ `@traceaborted` – Setzen Sie auf 1, um abgebrochene verteilte Transaktionen nachzuverfolgen. Der Standardwert ist 0.
+ `@tracelong` – Setzen Sie auf 1, um zeitintensive verteilte Transaktionen zu verfolgen. Der Standardwert ist 0.
**Example mit START-Nachverfolgungsaktion**
Um eine neue Transaktionsnachverfolgungssitzung zu starten, führen Sie die folgende Beispielanweisung aus.
```
exec msdb.dbo.rds_msdtc_transaction_tracing 'START',
@traceall='0',
@traceaborted='1',
@tracelong='1';
```
Es kann nur eine Transaktionsnachverfolgungssitzung gleichzeitig aktiv sein. Wenn ein neuer `START`-Befehl für die Nachverfolgungssitzung ausgegeben wird, während eine Nachverfolgungssitzung aktiv ist, wird ein Fehler zurückgegeben, und die aktive Nachverfolgungssitzung bleibt unverändert.
**Example mit STOP-Nachverfolgungsaktion**
Um eine Transaktionsnachverfolgungssitzung zu beenden, führen Sie die folgende Anweisung aus.
```
exec msdb.dbo.rds_msdtc_transaction_tracing 'STOP'
```
Diese Anweisung stoppt die aktive Transaktionsnachverfolgungssitzung und speichert die Transaktionsnachverfolgungsdaten im Protokollverzeichnis der RDS-DB-Instance. Die erste Zeile der Ausgabe enthält das Gesamtergebnis und die folgenden Zeilen zeigen Details der Operation an.
Im Folgenden finden Sie ein Beispiel für einen erfolgreichen Sitzungsstopp der Nachverfolgung.
```
OK: Trace session has been successfully stopped.
Setting log file to: D:\rdsdbdata\MSDTC\Trace\dtctrace.log
Examining D:\rdsdbdata\MSDTC\Trace\msdtctr.mof for message formats, 8 found.
Searching for TMF files on path: (null)
Logfile D:\rdsdbdata\MSDTC\Trace\dtctrace.log:
OS version 10.0.14393 (Currently running on 6.2.9200)
Start Time
End Time
Timezone is @tzres.dll,-932 (Bias is 0mins)
BufferSize 16384 B
Maximum File Size 10 MB
Buffers Written Not set (Logger may not have been stopped).
Logger Mode Settings (11000002) ( circular paged
ProcessorCount 1
Processing completed Buffers: 1, Events: 3, EventsLost: 0 :: Format Errors: 0, Unknowns: 3
Event traces dumped to d:\rdsdbdata\Log\msdtc_.log
```
Mit den detaillierten Informationen können Sie den Namen der generierten Protokolldatei abfragen. Weitere Informationen zum Herunterladen von Protokolldateien aus der RDS-DB-Instance finden Sie unter [Überwachen von Amazon RDS-Protokolldateien](USER_LogAccess.md).
Die Nachverfolgungssitzungsprotokolle verbleiben 35 Tage lang auf der Instance. Ältere Nachverfolgungssitzungsprotokolle werden automatisch gelöscht.
**Example mit STATUS-Nachverfolgungsaktion**
Um den Status einer Transaktionsnachverfolgungssitzung nachzuverfolgen, führen Sie die folgende Anweisung aus.
```
exec msdb.dbo.rds_msdtc_transaction_tracing 'STATUS'
```
Diese Anweisung gibt Folgendes als separate Zeilen der Ergebnismenge aus.
```
OK
SessionStatus:
TraceAll:
TraceAborted:
TraceLongLived:
```
Die erste Zeile gibt das Gesamtergebnis der Operation an: `OK` oder gegebenenfalls `ERROR` mit Details. Die folgenden Zeilen zeigen Details zum Status der Nachverfolgungssitzung an:
+ `SessionStatus` kann einer der folgenden sein:
+ `Started`, wenn eine Nachverfolgungssitzung ausgeführt wird.
+ `Stopped`, wenn keine Nachverfolgungssitzung ausgeführt wird.
+ Die Protokollierungssitzungs-Flags können `True` oder `False` abhängig davon sein, wie sie im `START`-Befehl festgelegt wurden.
# Deaktivieren von MSDTC
Um MSDTC zu deaktivieren, entfernen Sie die Option `MSDTC` aus der Optionsgruppe.
## Konsole
**So entfernen Sie die MSDTC-Option aus der Optionsgruppe**
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 **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `MSDTC` (`msdtc-se-2016` in den vorherigen Beispielen).
1. Wählen Sie **Delete option (Option löschen)** aus.
1. Wählen Sie unter **Löschoptionen** für **Zu löschende Optionen** die Option **MSDTC** aus.
1. Wählen Sie unter **Apply immediately (Sofort anwenden)** die Option **Yes (Ja)** aus, um die Option sofort zu löschen, oder **No (Nein)**, um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Delete (Löschen)**.
## CLI
**So entfernen Sie die MSDTC-Option aus der Optionsgruppe**
+ Verwenden Sie einen der folgenden Befehle.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name msdtc-se-2016 \
--options MSDTC \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name msdtc-se-2016 ^
--options MSDTC ^
--apply-immediately
```
# Problembehandlung bei MSDTC für RDS für SQL Server
In einigen Fällen haben Sie möglicherweise Probleme beim Herstellen einer Verbindung zwischen MSDTC, der auf einem Client-Computer ausgeführt wird, und dem MSDTC-Dienst, der auf einer RDS für SQL Server-DB-Instance ausgeführt wird. Wenn ja, stellen Sie Folgendes sicher:
+ Die eingehenden Regeln für die Sicherheitsgruppe, die der DB-Instance zugeordnet ist, sind korrekt konfiguriert. Weitere Informationen finden Sie unter [Verbindung zur Amazon-RDS-DB-Instance kann nicht hergestellt werden](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
+ Der Client-Computer ist korrekt konfiguriert.
+ Die MSDTC-Firewall-Regeln auf Ihrem Client-Computer sind aktiviert.
**So konfigurieren Sie den Client-Computer**
1. Öffnen Sie **Komponentendienste**.
Oder wählen Sie im **Server-Manager** die Option **Tools** und dann **Komponentendienste** aus.
1. Erweitern Sie **Komponentendienste**, erweitern Sie **Computer**, erweitern Sie **Arbeitsplatz** und erweitern Sie dann **Distributed Transaction Coordinator**.
1. Öffnen Sie das Kontextmenü (Rechtsklick) für **Lokaler DTC** und wählen Sie **Eigenschaften** aus.
1. Wählen Sie die Registerkarte **Sicherheit** aus.
1. Wählen Sie alle der folgenden Optionen aus:
+ **Netzwerk-DTC-Zugriff**
+ **Eingehende zulassen**
+ **Ausgehende zulassen**
1. Stellen Sie sicher, dass der richtige Authentifizierungsmodus gewählt ist:
+ **Gegenseitige Authentifizierung erforderlich** – Der Client-Computer ist mit derselben Domäne verbunden wie andere Knoten, die an einer verteilten Transaktion beteiligt sind, oder es ist eine Vertrauensstellung zwischen Domänen konfiguriert.
+ **Keine Authentifizierung erforderlich** – Alle anderen Fälle.
1. Wählen Sie **OK** aus, um Ihre Änderungen zu speichern.
1. Wenn Sie aufgefordert werden, den Dienst neu zu starten, wählen Sie **Ja**.
**So aktivieren Sie MSDTC-Firewall-Regeln**
1. Öffnen Sie die Windows-Firewall und wählen Sie dann **Erweiterte Einstellungen** aus.
Oder wählen Sie im **Server-Manager** die Option **Tools** und dann **Windows-Firewall mit erweiterter Sicherheit** aus.
**Anmerkung**
Abhängig von Ihrem Betriebssystem wird die Windows-Firewall möglicherweise als Windows Defender Firewall bezeichnet.
1. Wählen Sie im linken Bereich die Option **Eingehende Regeln** aus.
1. Aktivieren Sie die folgenden Firewall-Regeln, wenn sie noch nicht aktiviert sind:
+ **Distributed Transaction Coordinator (RPC)**
+ **Distributed Transaction Coordinator (RPC)-EPMAP**
+ **Distributed Transaction Coordinator (TCP-In)**
1. Schließen Sie die Windows-Firewall.
# Microsoft SQL Server-Ressourcenkontrolle mit RDS für SQL Server
Resource Governor ist eine Funktion der SQL Server Enterprise Edition, mit der Sie Ihre Instance-Ressourcen präzise steuern können. Es ermöglicht Ihnen, spezifische Grenzwerte für die Nutzung von CPU, Arbeitsspeicher und physischen I/O Ressourcen durch Workloads festzulegen. Mit Resource Governor können Sie:
+ Vermeiden Sie die Monopolisierung von Ressourcen in Umgebungen mit mehreren Mandanten, indem Sie festlegen, wie verschiedene Workloads Instanzressourcen gemeinsam nutzen
+ Sorgen Sie für vorhersehbare Leistung, indem Sie spezifische Ressourcenlimits und Prioritäten für verschiedene Benutzer und Anwendungen festlegen
Sie können Resource Governor entweder auf einer vorhandenen oder einer neuen RDS for SQL Server-DB-Instance aktivieren.
Resource Governor verwendet drei grundlegende Konzepte:
+ **Ressourcenpool** — Ein Container, der die physischen Ressourcen Ihrer Instance (CPU, Arbeitsspeicher und I/O) verwaltet. Sie erhalten zwei integrierte Pools (intern und Standard) und können zusätzliche benutzerdefinierte Pools erstellen.
+ **Workload-Gruppe** — Ein Container für Datenbanksitzungen mit ähnlichen Eigenschaften. Jede Workload-Gruppe gehört zu einem Ressourcenpool. Sie erhalten zwei integrierte Workload-Gruppen (intern und Standard) und können zusätzliche benutzerdefinierte Workload-Gruppen erstellen.
+ **Klassifizierung** — Der Prozess, der anhand des Benutzernamens, Anwendungsnamens, Datenbanknamens oder Hostnamens bestimmt, welche Workload-Gruppe eingehende Sitzungen verarbeitet.
Weitere Informationen zur Resource Governor-Funktionalität in SQL Server finden Sie unter [Resource Governor](https://learn.microsoft.com/en-us/sql/relational-databases/resource-governor/resource-governor?view=sql-server-ver16) in der Microsoft-Dokumentation.
**Contents**
+ [
## Unterstützte Versionen und Regionen
](#ResourceGovernor.SupportedVersions)
+ [
## Einschränkungen und Empfehlungen
](#ResourceGovernor.Limitations)
+ [
# Aktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Enabling.md)
+ [
## Erstellen der Optionsgruppe für `RESOURCE_GOVERNOR`
](ResourceGovernor.Enabling.md#ResourceGovernor.OptionGroup)
+ [
## Hinzufügen der `RESOURCE_GOVERNOR`-Option zur Optionsgruppe
](ResourceGovernor.Enabling.md#ResourceGovernor.Add)
+ [
## Zuordnen der Optionsgruppe zu Ihrer DB-Instance
](ResourceGovernor.Enabling.md#ResourceGovernor.Apply)
+ [
# Verwenden von Microsoft SQL Server Resource Governor für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Using.md)
+ [
## Ressourcenpool verwalten
](ResourceGovernor.Using.md#ResourceGovernor.ManageResourcePool)
+ [
### Ressourcenpool erstellen
](ResourceGovernor.Using.md#ResourceGovernor.CreateResourcePool)
+ [
### Ressourcenpool ändern
](ResourceGovernor.Using.md#ResourceGovernor.AlterResourcePool)
+ [
### Ressourcenpool löschen
](ResourceGovernor.Using.md#ResourceGovernor.DropResourcePool)
+ [
## Arbeitslastgruppen verwalten
](ResourceGovernor.Using.md#ResourceGovernor.ManageWorkloadGroups)
+ [
### Workload-Gruppe erstellen
](ResourceGovernor.Using.md#ResourceGovernor.CreateWorkloadGroup)
+ [
### Workload-Gruppe ändern
](ResourceGovernor.Using.md#ResourceGovernor.AlterWorkloadGroup)
+ [
### Workload-Gruppe löschen
](ResourceGovernor.Using.md#ResourceGovernor.DropWorkloadGroup)
+ [
## Klassifikatorfunktion erstellen und registrieren
](ResourceGovernor.Using.md#ResourceGovernor.ClassifierFunction)
+ [
## Klassifizierer-Funktion löschen
](ResourceGovernor.Using.md#ResourceGovernor.DropClassifier)
+ [
## Klassifikatorfunktion deregistrieren
](ResourceGovernor.Using.md#ResourceGovernor.DeregisterClassifier)
+ [
## Statistik zurücksetzen
](ResourceGovernor.Using.md#ResourceGovernor.ResetStats)
+ [
## Änderungen der Konfiguration von Resource Governor
](ResourceGovernor.Using.md#ResourceGovernor.ConfigChanges)
+ [
## TempDB an einen Ressourcenpool binden
](ResourceGovernor.Using.md#ResourceGovernor.BindTempDB)
+ [
## TempDB von einem Ressourcenpool trennen
](ResourceGovernor.Using.md#ResourceGovernor.UnbindTempDB)
+ [
## Steuerung der Ressourcen für Cleanup
](ResourceGovernor.Using.md#ResourceGovernor.Cleanup)
+ [
## Überlegungen zur Multi-AZ-Bereitstellung
](#ResourceGovernor.Considerations)
+ [
## Überlegungen zu Read Replicas
](#ResourceGovernor.ReadReplica)
+ [
# Überwachen Sie die Microsoft SQL Server-Ressourcenkontrolle mithilfe von Systemansichten für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Monitoring.md)
+ [
## Laufzeitstatistiken für den Ressourcenpool
](ResourceGovernor.Monitoring.md#ResourceGovernor.ResourcePoolStats)
+ [
# Deaktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
](ResourceGovernor.Disabling.md)
+ [
# Bewährte Methoden für die Konfiguration von Resource Governor auf RDS für SQL Server
](ResourceGovernor.BestPractices.md)
## Unterstützte Versionen und Regionen
Amazon RDS unterstützt Resource Governor für die folgenden SQL Server-Versionen und -Editionen in allen Ländern AWS-Regionen , in denen RDS für SQL Server verfügbar ist:
+ SQL Server 2022 Developer- und Enterprise-Editionen
+ SQL Server 2019 Enterprise Edition
+ SQL Server 2017 Enterprise Edition
+ SQL Server 2016 Enterprise Edition
## Einschränkungen und Empfehlungen
Die folgenden Einschränkungen und Empfehlungen gelten für Resource Governor:
+ Editions- und Serviceeinschränkungen:
+ Nur in der SQL Server Enterprise Edition verfügbar.
+ Die Ressourcenverwaltung ist auf die SQL Server Database Engine beschränkt. Die Ressourcenkontrolle für Analysis Services, Integration Services und Reporting Services wird nicht unterstützt.
+ Einschränkungen bei der Konfiguration:
+ Muss für alle Konfigurationen gespeicherte Amazon RDS-Prozeduren verwenden.
+ Systemeigene DDL-Anweisungen und SQL Server Management Studio-GUI-Konfigurationen werden nicht unterstützt.
+ Parameter des Ressourcenpools:
+ Poolnamen, die mit beginnen, werden `rds_` nicht unterstützt.
+ Interne und standardmäßige Änderungen am Ressourcenpool sind nicht zulässig.
+ Für die benutzerdefinierten Ressourcenpools werden die folgenden Ressourcenpoolparameter nicht unterstützt:
+ `MIN_MEMORY_PERCENT`
+ `MIN_CPU_PERCENT`
+ `MIN_IOPS_PER_VOLUME`
+ `AFFINITY`
+ Parameter der Workload-Gruppe:
+ Workload-Gruppennamen, die mit beginnen, werden `rds_` nicht unterstützt.
+ Eine Änderung der internen Workload-Gruppe ist nicht zulässig.
+ Für die Standard-Workload-Gruppe:
+ Nur der `REQUEST_MAX_MEMORY_GRANT_PERCENT` Parameter kann geändert werden.
+ Für die Standard-Workload-Gruppe `REQUEST_MAX_MEMORY_GRANT_PERCENT` muss der Wert zwischen 1 und 70 liegen.
+ Alle anderen Parameter sind gesperrt und können nicht geändert werden.
+ Benutzerdefinierte Workload-Gruppen ermöglichen die Änderung aller Parameter.
+ Einschränkungen der Classifier-Funktion:
+ Die Classifier-Funktion leitet Verbindungen zu benutzerdefinierten Workload-Gruppen auf der Grundlage bestimmter Kriterien (Benutzername, Datenbank, Host oder Anwendungsname) weiter.
+ Unterstützt bis zu zwei benutzerdefinierte Workload-Gruppen mit ihren jeweiligen Routing-Bedingungen.
+ Kombiniert Kriterien mit `AND` Bedingungen innerhalb jeder Gruppe.
+ Erfordert mindestens ein Routingkriterium pro Workload-Gruppe.
+ Nur die oben aufgeführten Klassifizierungsmethoden werden unterstützt.
+ Der Funktionsname muss mit beginnen`rg_classifier_`.
+ Standardgruppenzuweisung, wenn keine Bedingungen erfüllt sind.
# Aktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
Aktivieren Sie Resource Governor, indem Sie die `RESOURCE_GOVERNOR` Option zu Ihrer RDS for SQL Server-DB-Instance hinzufügen. Verwenden Sie den folgenden Prozess:
1. Erstellen Sie eine neue Optionsgruppe oder wählen Sie eine bestehende Optionsgruppe aus.
1. Fügen Sie die Option `RESOURCE_GOVERNOR` zur Optionsgruppe hinzu.
1. Ordnen Sie die Optionsgruppe der DB-Instance zu.
**Anmerkung**
Für die Aktivierung von Resource Governor über eine Optionsgruppe ist kein Neustart erforderlich.
## Erstellen der Optionsgruppe für `RESOURCE_GOVERNOR`
Um Resource Governor zu aktivieren, erstellen Sie eine Optionsgruppe oder ändern Sie eine Optionsgruppe, die der SQL Server-Edition und Version der DB-Instance entspricht, die Sie verwenden möchten. Um dieses Verfahren abzuschließen, verwenden Sie den AWS-Managementkonsole oder den AWS CLI.
### Konsole
Verwenden Sie das folgende Verfahren, um eine Optionsgruppe für SQL Server Enterprise Edition 2022 zu erstellen.
**So erstellen Sie die Optionsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie **Create group** (Gruppe erstellen) aus.
1. Führen Sie im Fenster **Create option group (Optionsgruppe erstellen)** Folgendes aus:
1. Geben Sie unter **Name** einen Namen für die Optionsgruppe ein, der innerhalb Ihres AWS Kontos eindeutig ist, z. **resource-governor-ee-2022** B. Der Name darf nur Buchstaben, Ziffern und Bindestriche enthalten.
1. Geben Sie unter **Beschreibung** eine kurze Beschreibung der Optionsgruppe ein, z. B. **RESOURCE\$1GOVERNOR option group for SQL Server EE 2022**. Die Beschreibung ist nur zur Information.
1. Wählen Sie für **Engine** die Option **sqlserver-ee** aus.
1. **Wählen Sie **16.00 für Major-Engine-Version** aus.**
1. Wählen Sie **Erstellen** aus.
### CLI
Mit dem folgenden Verfahren wird eine Optionsgruppe für SQL Server Enterprise Edition 2022 erstellt.
**So erstellen Sie die Optionsgruppe**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-option-group \
--option-group-name resource-governor-ee-2022 \
--engine-name sqlserver-ee \
--major-engine-version 16.00 \
--option-group-description "RESOURCE_GOVERNOR option group for SQL Server EE 2022"
```
Für Windows:
```
aws rds create-option-group ^
--option-group-name resource-governor-ee-2022 ^
--engine-name sqlserver-ee ^
--major-engine-version 16.00 ^
--option-group-description "RESOURCE_GOVERNOR option group for SQL Server EE 2022"
```
## Hinzufügen der `RESOURCE_GOVERNOR`-Option zur Optionsgruppe
Verwenden Sie als Nächstes das AWS-Managementkonsole oder, AWS CLI um die `RESOURCE_GOVERNOR` Option zu Ihrer Optionsgruppe hinzuzufügen.
### Konsole
**Um die Option RESOURCE\$1GOVERNOR hinzuzufügen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe, die Sie gerade erstellt haben, in diesem Beispiel **resource-governor-ee-2022**.
1. Wählen Sie **Add option (Option hinzufügen)**.
1. **Wählen Sie unter **Optionsdetails** **RESOURCE\$1GOVERNOR** als Optionsnamen aus.**
1. Wählen Sie unter **Planung** aus, ob die Option sofort oder während des nächsten Wartungsfensters hinzugefügt werden soll.
1. Wählen Sie **Add option (Option hinzufügen)**.
### CLI
**So fügen Sie die Option `RESOURCE_GOVERNOR` hinzu**
+ Fügen Sie die Option `RESOURCE_GOVERNOR` zur Optionsgruppe hinzu.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-option-to-option-group \
--option-group-name resource-governor-ee-2022 \
--options "OptionName=RESOURCE_GOVERNOR" \
--apply-immediately
```
Für Windows:
```
aws rds add-option-to-option-group ^
--option-group-name resource-governor-ee-2022 ^
--options "OptionName=RESOURCE_GOVERNOR" ^
--apply-immediately
```
## Zuordnen der Optionsgruppe zu Ihrer DB-Instance
Um die `RESOURCE_GOVERNOR` Optionsgruppe Ihrer DB-Instance zuzuordnen, verwenden Sie den oder den AWS-Managementkonsole . AWS CLI
### Konsole
Um die Aktivierung von Resource Governor abzuschließen, ordnen Sie Ihre `RESOURCE_GOVERNOR` Optionsgruppe einer neuen oder vorhandenen DB-Instance zu:
+ Ordnen Sie sie bei einer neuen DB-Instance zu, wenn Sie die Instance starten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Ordnen Sie sie für eine vorhandene DB-Instance zu, indem Sie die Instance ändern. Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
### CLI
Sie können die `RESOURCE_GOVERNOR` Optionsgruppe einer neuen oder vorhandenen DB-Instance zuordnen.
**Um eine Instance mit der `RESOURCE_GOVERNOR` Optionsgruppe zu erstellen**
+ Geben Sie denselben DB-Engine-Typ und dieselbe Hauptversion an, die Sie beim Erstellen der Optionsgruppe verwendet haben.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-db-instance \
--db-instance-identifier mytestsqlserverresourcegovernorinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-ee \
--engine-version 16.00 \
--license-model license-included \
--allocated-storage 100 \
--master-username admin \
--master-user-password password \
--storage-type gp2 \
--option-group-name resource-governor-ee-2022
```
Für Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mytestsqlserverresourcegovernorinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-ee ^
--engine-version 16.00 ^
--license-model license-included ^
--allocated-storage 100 ^
--master-username admin ^
--master-user-password password ^
--storage-type gp2 ^
--option-group-name resource-governor-ee-2022
```
**So ändern Sie eine Instance, um die `RESOURCE_GOVERNOR`-Optionsgruppe zuzuordnen**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mytestinstance \
--option-group-name resource-governor-ee-2022 \
--apply-immediately
```
Für Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mytestinstance ^
--option-group-name resource-governor-ee-2022 ^
--apply-immediately
```
# Verwenden von Microsoft SQL Server Resource Governor für Ihre RDS for SQL Server-Instanz
Nachdem Sie die Option Resource Governor zu Ihrer Optionsgruppe hinzugefügt haben, ist Resource Governor auf Datenbank-Engine-Ebene noch nicht aktiv. Um die Ressourcenkontrolle vollständig zu aktivieren, müssen Sie die gespeicherten Prozeduren von RDS für SQL Server verwenden, um sie zu aktivieren und die erforderlichen Resource Governor-Objekte zu erstellen. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Stellen Sie zunächst eine Verbindung zu Ihrer SQL Server-Datenbank her und rufen Sie dann die entsprechenden gespeicherten RDS-Prozeduren für SQL Server auf, um die Konfiguration abzuschließen. Anleitungen zum Herstellen einer Verbindung zu Ihrer Datenbank finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Anleitungen zum Aufrufen der einzelnen gespeicherten Prozeduren finden Sie in den folgenden Themen:
**Topics**
+ [
## Ressourcenpool verwalten
](#ResourceGovernor.ManageResourcePool)
+ [
## Arbeitslastgruppen verwalten
](#ResourceGovernor.ManageWorkloadGroups)
+ [
## Klassifikatorfunktion erstellen und registrieren
](#ResourceGovernor.ClassifierFunction)
+ [
## Klassifizierer-Funktion löschen
](#ResourceGovernor.DropClassifier)
+ [
## Klassifikatorfunktion deregistrieren
](#ResourceGovernor.DeregisterClassifier)
+ [
## Statistik zurücksetzen
](#ResourceGovernor.ResetStats)
+ [
## Änderungen der Konfiguration von Resource Governor
](#ResourceGovernor.ConfigChanges)
+ [
## TempDB an einen Ressourcenpool binden
](#ResourceGovernor.BindTempDB)
+ [
## TempDB von einem Ressourcenpool trennen
](#ResourceGovernor.UnbindTempDB)
+ [
## Steuerung der Ressourcen für Cleanup
](#ResourceGovernor.Cleanup)
## Ressourcenpool verwalten
### Ressourcenpool erstellen
Sobald Resource Governor in der Optionsgruppe aktiviert ist, können Sie benutzerdefinierte Ressourcenpools mithilfe von erstellen`rds_create_resource_pool`. Mit diesen Pools können Sie verschiedenen Workloads bestimmte Prozentsätze an CPU, Arbeitsspeicher und IOPS zuweisen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_create_resource_pool
@pool_name=value,
@MAX_CPU_PERCENT=value,
@CAP_CPU_PERCENT=value,
@MAX_MEMORY_PERCENT=value,
@MAX_IOPS_PER_VOLUME=value
```
Die folgenden Parameter sind erforderlich:
+ `@group_name`- Ist der Name einer vorhandenen benutzerdefinierten Workload-Gruppe.
+ `@pool_name`- Ist der benutzerdefinierte Name für den Ressourcenpool. *pool\$1name*ist alphanumerisch, kann bis zu 128 Zeichen lang sein, muss innerhalb einer Database Engine-Instanz eindeutig sein und muss den Regeln für Datenbankbezeichner entsprechen.
Die folgenden Parameter sind optional:
+ `@MAX_CPU_PERCENT`- Gibt die maximale durchschnittliche CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten, wenn es zu einem CPU-Konflikt kommt. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@CAP_CPU_PERCENT`— Gibt eine feste Obergrenze für die CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten. Schränkt die maximale CPU-Bandbreite auf den angegebenen Wert ein. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_MEMORY_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die Anfragen in diesem Ressourcenpool verwenden können. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_IOPS_PER_VOLUME`- Gibt die maximale Anzahl von I/O Vorgängen pro Sekunde (IOPS) pro Festplattenvolume an, die für den Ressourcenpool zulässig sind. Der zulässige Bereich für *value* liegt zwischen 0 und 2^31-1 (2.147.483.647). Geben Sie 0 an, um ein IOPS-Limit für den Pool aufzuheben. Der Standardwert ist 0.
**Beispiele**
Beispiel für die Erstellung eines Ressourcenpools mit allen Standardwerten:
```
--This creates resource pool 'SalesPool' with all default values
USE [msdb]
EXEC rds_create_resource_pool @pool_name = 'SalesPool';
--Apply changes
USE [msdb]
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_resource_pools
```
Beispiel für die Erstellung eines Ressourcenpools mit verschiedenen angegebenen Parametern:
```
--creates resource pool
USE [msdb]
EXEC dbo.rds_create_resource_pool
@pool_name='analytics',
@MAX_CPU_PERCENT = 30,
@CAP_CPU_PERCENT = 40,
@MAX_MEMORY_PERCENT = 20;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_resource_pools
```
### Ressourcenpool ändern
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_pool
@pool_name=value,
@MAX_CPU_PERCENT=value,
@CAP_CPU_PERCENT=value,
@MAX_MEMORY_PERCENT=value,
@MAX_IOPS_PER_VOLUME=value;
```
Die folgenden Parameter sind erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools. Das Ändern des Standardressourcenpools ist in Amazon RDS SQL Server nicht zulässig.
Mindestens einer der optionalen Parameter muss angegeben werden:
+ `@MAX_CPU_PERCENT`- Gibt die maximale durchschnittliche CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten, wenn es zu einem CPU-Konflikt kommt. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@CAP_CPU_PERCENT`— Gibt eine feste Obergrenze für die CPU-Bandbreite an, die alle Anfragen im Ressourcenpool erhalten. Schränkt die maximale CPU-Bandbreite auf den angegebenen Wert ein. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_MEMORY_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die Anfragen in diesem Ressourcenpool verwenden können. *value*ist eine Ganzzahl mit der Standardeinstellung 100. Der zulässige Bereich für *value* liegt zwischen 1 und 100.
+ `@MAX_IOPS_PER_VOLUME`- Gibt die maximale Anzahl von I/O Vorgängen pro Sekunde (IOPS) pro Festplattenvolume an, die für den Ressourcenpool zulässig sind. Der zulässige Bereich für *value* liegt zwischen 0 und 2^31-1 (2.147.483.647). Geben Sie 0 an, um ein IOPS-Limit für den Pool aufzuheben. Der Standardwert ist 0.
**Beispiele**
```
--This alters resource pool
USE [msdb]
EXEC dbo.rds_alter_resource_pool
@pool_name='analytics',
@MAX_CPU_PERCENT = 10,
@CAP_CPU_PERCENT = 20,
@MAX_MEMORY_PERCENT = 50;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration.
select * from sys.resource_governor_resource_pools
```
### Ressourcenpool löschen
**Usage**
```
USE [msdb]
EXEC dbo.rds_drop_resource_pool
@pool_name=value;
```
Der folgende Parameter ist erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools.
**Anmerkung**
Das Löschen des internen oder Standardressourcenpools ist in SQL Server nicht zulässig.
**Beispiele**
```
--This drops resource pool
USE [msdb]
EXEC dbo.rds_drop_resource_pool
@pool_name='analytics'
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_resource_pools
```
## Arbeitslastgruppen verwalten
Workload-Gruppen, die mit und erstellt `rds_create_workload_group` und verwaltet werden`rds_alter_workload_group`, ermöglichen es Ihnen, Wichtigkeitsstufen, Speicherzuweisungen und andere Parameter für Gruppen von Abfragen festzulegen.
### Workload-Gruppe erstellen
**Usage**
```
USE [msdb]
EXEC dbo.rds_create_workload_group
@group_name = value,
@IMPORTANCE ={ LOW | MEDIUM | HIGH },
@REQUEST_MAX_MEMORY_GRANT_PERCENT =value,
@REQUEST_MAX_CPU_TIME_SEC = value ,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = value,
@MAX_DOP = value,
@GROUP_MAX_REQUESTS = value,
@pool_name = value
```
Die folgenden Parameter sind erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools.
+ `@group_name`- Ist der Name einer vorhandenen benutzerdefinierten Workload-Gruppe.
Die folgenden Parameter sind optional:
+ `@IMPORTANCE`— Gibt die relative Wichtigkeit einer Anfrage in der Workload-Gruppe an. Der Standardwert ist `MEDIUM`.
+ `@REQUEST_MAX_MEMORY_GRANT_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die eine einzelne Anforderung aus dem Pool beanspruchen kann. *value*ist ein Prozentsatz der Ressourcenpoolgröße, definiert durch`MAX_MEMORY_PERCENT`. Der Standardwert ist 25.
+ `@REQUEST_MAX_CPU_TIME_SEC`- Gibt die maximale CPU-Zeit in Sekunden an, die eine Batch-Anfrage verwenden kann. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0, was unbegrenzt bedeutet.
+ `@REQUEST_MEMORY_GRANT_TIMEOUT_SEC`- Gibt die maximale Zeit in Sekunden an, für die eine Abfrage warten kann, bis eine Speicherzuweisung aus dem Abfrage-Workspace-Speicher verfügbar wird. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* 0 verwendet eine interne Berechnung, die auf den Abfragekosten basiert, um die maximale Zeit zu bestimmen.
+ `@MAX_DOP`- Gibt den maximalen Grad an Parallelität (`MAXDOP`) für die parallel Abfrageausführung an. Der zulässige Bereich für *value* liegt zwischen 0 und 64. Die Standardeinstellung für *value* 0 verwendet die globale Einstellung.
+ `@GROUP_MAX_REQUESTS`= Gibt die maximale Anzahl gleichzeitiger Anfragen an, die in der Workload-Gruppe ausgeführt werden dürfen. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0 und erlaubt eine unbegrenzte Anzahl von Anfragen.
+ `@pool_name`= Ordnet die Workload-Gruppe dem benutzerdefinierten Ressourcenpool zu, der durch den Ressourcenpool identifiziert wird*pool\$1name*, oder mit dem `default` Ressourcenpool. Wenn *pool\$1name* nicht angegeben, ist die Workload-Gruppe dem integrierten `default` Pool zugeordnet.
**Beispiele**
```
--This creates workload group named 'analytics'
USE msdb;
EXEC dbo.rds_create_workload_group
@group_name = 'analytics',
@IMPORTANCE = 'HIGH',
@REQUEST_MAX_MEMORY_GRANT_PERCENT = 25,
@REQUEST_MAX_CPU_TIME_SEC = 0,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = 0,
@MAX_DOP = 0,
@GROUP_MAX_REQUESTS = 0,
@pool_name = 'analytics';
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_workload_groups
```
### Workload-Gruppe ändern
**Usage**
```
EXEC msdb.dbo.rds_alter_workload_group
@group_name = value,
@IMPORTANCE = 'LOW|MEDIUM|HIGH',
@REQUEST_MAX_MEMORY_GRANT_PERCENT = value,
@REQUEST_MAX_CPU_TIME_SEC = value,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = value,
@MAX_DOP = value,
@GROUP_MAX_REQUESTS = value,
@pool_name = value
```
Die folgenden Parameter sind erforderlich:
+ `@group_name`- Ist der Name einer Standard-Workload-Gruppe oder einer vorhandenen benutzerdefinierten Workload-Gruppe.
**Anmerkung**
Es `REQUEST_MAX_MEMORY_GRANT_PERCENT` wird nur das Ändern von Parametern in der Standard-Workload-Gruppe unterstützt. Für die Standard-Workload-Gruppe `REQUEST_MAX_MEMORY_GRANT_PERCENT` muss der Wert zwischen 1 und 70 liegen. In der Standard-Workload-Gruppe können keine anderen Parameter geändert werden. Alle Parameter können in der benutzerdefinierten Workload-Gruppe geändert werden.
Die folgenden Parameter sind optional:
+ `@IMPORTANCE`- Gibt die relative Wichtigkeit einer Anfrage in der Workload-Gruppe an. Der Standardwert ist MEDIUM.
+ `@REQUEST_MAX_MEMORY_GRANT_PERCENT`- Gibt die maximale Menge an Abfrage-Workspace-Speicher an, die eine einzelne Anforderung aus dem Pool beanspruchen kann. *value*ist ein Prozentsatz der Ressourcenpoolgröße, definiert durch`MAX_MEMORY_PERCENT`. Der Standardwert ist 25. Bei Amazon RDS `REQUEST_MAX_MEMORY_GRANT_PERCENT` muss der Wert zwischen 1 und 70 liegen.
+ `@REQUEST_MAX_CPU_TIME_SEC`- Gibt die maximale CPU-Zeit in Sekunden an, die eine Batch-Anfrage verwenden kann. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0, was unbegrenzt bedeutet.
+ `@REQUEST_MEMORY_GRANT_TIMEOUT_SEC`- Gibt die maximale Zeit in Sekunden an, für die eine Abfrage warten kann, bis eine Speicherzuweisung aus dem Abfrage-Workspace-Speicher verfügbar wird. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* 0 verwendet eine interne Berechnung, die auf den Abfragekosten basiert, um die maximale Zeit zu bestimmen.
+ `@MAX_DOP`- Gibt den maximalen Grad an Parallelität (MAXDOP) für die parallel Abfrageausführung an. Der zulässige Bereich für *value* liegt zwischen 0 und 64. Die Standardeinstellung für *value* 0 verwendet die globale Einstellung.
+ `@GROUP_MAX_REQUESTS`— Gibt die maximale Anzahl gleichzeitiger Anfragen an, die in der Workload-Gruppe ausgeführt werden dürfen. *value*muss 0 oder eine positive Ganzzahl sein. Die Standardeinstellung für *value* ist 0 und erlaubt eine unbegrenzte Anzahl von Anfragen.
+ `@pool_name`- Ordnet die Workload-Gruppe dem benutzerdefinierten Ressourcenpool zu, der durch identifiziert wird*pool\$1name*.
**Beispiele**
Beispiel für die Änderung der Standard-Workload-Gruppe REQUEST\$1MAX\$1MEMORY\$1GRANT\$1PERCENT:
```
--Modify default workload group (set memory grant cap to 10%)
USE msdb
EXEC dbo.rds_alter_workload_group
@group_name = 'default',
@REQUEST_MAX_MEMORY_GRANT_PERCENT=10;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
SELECT * FROM sys.resource_governor_workload_groups WHERE name='default';
```
Beispiel für die Änderung einer nicht standardmäßigen Workload-Gruppe:
```
EXEC msdb.dbo.rds_alter_workload_group
@group_name = 'analytics',
@IMPORTANCE = 'HIGH',
@REQUEST_MAX_MEMORY_GRANT_PERCENT = 30,
@REQUEST_MAX_CPU_TIME_SEC = 3600,
@REQUEST_MEMORY_GRANT_TIMEOUT_SEC = 60,
@MAX_DOP = 4,
@GROUP_MAX_REQUESTS = 100;
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
```
Beispiel für das Verschieben einer nicht standardmäßigen Workload-Gruppe in einen anderen Ressourcenpool:
```
EXEC msdb.dbo.rds_alter_workload_group
@group_name = 'analytics',
@pool_name='abc'
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_workload_groups
```
### Workload-Gruppe löschen
**Usage**
```
EXEC msdb.dbo.rds_drop_workload_group
@group_name = value
```
Die folgenden Parameter sind erforderlich:
+ `@group_name`- Ist der Name einer vorhandenen benutzerdefinierten Workload-Gruppe.
**Beispiele**
```
--Drops a Workload Group:
EXEC msdb.dbo.rds_drop_workload_group
@group_name = 'analytics';
--Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
--Validate configuration
select * from sys.resource_governor_workload_groups
```
## Klassifikatorfunktion erstellen und registrieren
Dieses Verfahren erstellt eine Classifier-Funktion für die Ressourcenkontrolle in der Master-Datenbank, die Verbindungen zu benutzerdefinierten Workload-Gruppen auf der Grundlage bestimmter Kriterien (Benutzername, Datenbank, Host oder Anwendungsname) weiterleitet. Wenn die Ressourcenkontrolle aktiviert ist und in der Konfiguration der Ressourcenkontrolle eine Klassifizierungsfunktion angegeben ist, bestimmt die Funktionsausgabe die für neue Sitzungen verwendete Workload-Gruppe. In Ermangelung einer Klassifizierungsfunktion werden alle Sitzungen der `default` Gruppe zugeordnet.
**Features:**
+ Unterstützt bis zu zwei Workload-Gruppen mit ihren jeweiligen Routing-Bedingungen.
+ Kombiniert Kriterien mit `AND` Bedingungen innerhalb jeder Gruppe.
+ Erfordert mindestens ein Routingkriterium pro Workload-Gruppe.
+ Der Funktionsname muss mit beginnen`rg_classifier_`.
+ Standardgruppenzuweisung, wenn keine Bedingungen erfüllt sind.
Die Klassifizierungsfunktion weist die folgenden Eigenschaften und Verhaltensweisen auf:
+ Die Funktion ist im Serverbereich (in der Master-Datenbank) definiert.
+ Die Funktion ist mit Schemabindung definiert.
+ Die Funktion wird für jede neue Sitzung ausgewertet, auch wenn das Verbindungspooling aktiviert ist.
+ Die Funktion gibt den Workload-Gruppenkontext für die Sitzung zurück. Die Sitzung wird der vom Classifier zurückgegebenen Workload-Gruppe für die Dauer der Sitzung zugewiesen.
+ Wenn die Funktion NULL, Standard oder den Namen einer nicht existierenden Workload-Gruppe zurückgibt, wird der Sitzung der Standard-Workload-Gruppenkontext zugewiesen. Der Sitzung wird außerdem der Standardkontext zugewiesen, falls die Funktion aus irgendeinem Grund fehlschlägt.
+ Sie können mehrere Klassifikatorfunktionen erstellen. In SQL Server kann jedoch jeweils nur eine Klassifikatorfunktion registriert werden.
+ Die Klassifiziererfunktion kann nur gelöscht werden, wenn ihr Klassifiziererstatus mithilfe der Deregistrierungsprozedur (`EXEC dbo.msdb.rds_alter_resource_governor_configuration @deregister_function = 1;`) entfernt wird, die den Funktionsnamen auf NULL setzt, oder es wird eine andere Klassifiziererfunktion mit () registriert `EXEC dbo.msdb.rds_alter_resource_governor_configuration @classifier_function = ;`
+ In Ermangelung einer Klassifizierungsfunktion werden alle Sitzungen in die Standardgruppe eingeteilt.
+ Sie können eine Klassifikatorfunktion nicht ändern, solange sie in der Resource Governor-Konfiguration referenziert wird. Sie können die Konfiguration jedoch ändern, um eine andere Klassifizierungsfunktion zu verwenden. Wenn Sie Änderungen am Klassifikator vornehmen möchten, sollten Sie erwägen, ein Paar von Klassifikatorfunktionen zu erstellen. Sie könnten beispielsweise und erstellen`rg_classifier_a`. `rg_classifier_b`
**Usage**
```
EXEC msdb.dbo.rds_create_classifier_function
@function_name = value,
@workload_group1 = value,
@user_name1 = value,
@db_name1 = value,
@host_name1 = value,
@app_name1 = value,
@workload_group2 = value,
@user_name2 = value,
@db_name2 = value,
@host_name2 = value,
@app_name2 = value
```
Die folgenden Parameter sind erforderlich:
+ `@function_name`- Name der Klassifikatorfunktion. Muss beginnen mit `rg_classifier_`
+ `@workload_group1`- Name der ersten Workload-Gruppe
Die folgenden Parameter sind optional:
(Mindestens eines dieser Kriterien muss für Gruppe 1 angegeben werden)
+ `@user_name1`- Anmeldename für Gruppe 1
+ `@db_name1`- Datenbankname für Gruppe 1
+ `@host_name1`- Hostname für Gruppe 1
+ `@app_name1`- Anwendungsname für Gruppe 1
(Wenn Gruppe 2 angegeben ist, muss mindestens ein Kriterium angegeben werden)
+ `@workload_group2`- Name der zweiten Workload-Gruppe
+ `@user_name2`- Anmeldename für Gruppe 2
+ `@db_name2`- Datenbankname für Gruppe 2
+ `@host_name2`- Hostname für Gruppe 2
+ `@app_name2`- Anwendungsname für Gruppe 2
**Anmerkung**
Systemkonten, Datenbanken, Anwendungen und Hosts sind eingeschränkt.
**Beispiele**
Einfaches Beispiel mit einer Workload-Gruppe:
```
/*Create a classifier to route all requests from 'PowerBI' app to workload group
'reporting_group'*/
EXEC msdb.dbo.rds_create_classifier_function
@function_name = 'rg_classifier_a',
@workload_group1 = 'reporting_group',
@app_name1 = 'PowerBI';
--Register the classifier
EXEC msdb.dbo.rds_alter_resource_governor_configuration
@classifier_function = 'rg_classifier_a';
-- Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration
/*Query sys.resource_governor_configuration to validate that resource governor is enabled and is using the classifier function we created and registered*/
use master
go
SELECT OBJECT_SCHEMA_NAME(classifier_function_id) AS classifier_schema_name,
OBJECT_NAME(classifier_function_id) AS classifier_object_name,
is_enabled
FROM sys.resource_governor_configuration;
```
## Klassifizierer-Funktion löschen
**Usage**
```
USE [msdb]
EXEC dbo.rds_drop_classifier_function
@function_name = value;
```
Der folgende Parameter ist erforderlich:
+ `@function_name`- Ist der Name einer vorhandenen benutzerdefinierten Klassifikatorfunktion
**Beispiel**
```
EXEC msdb.dbo.rds_drop_classifier_function
@function_name = 'rg_classifier_b';
```
## Klassifikatorfunktion deregistrieren
Gehen Sie wie folgt vor, um die Registrierung der Klassifikatorfunktion aufzuheben. Nachdem die Registrierung der Funktion aufgehoben wurde, werden neue Sitzungen automatisch der Standard-Workload-Gruppe zugewiesen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_governor_configuration
@deregister_function = 1;
```
Für die Abmeldung ist der folgende Parameter erforderlich:
+ `@deregister_function`muss 1 sein
**Beispiel**
```
EXEC msdb.dbo.rds_alter_resource_governor_configuration
@deregister_function = 1;
GO
-- Apply changes
EXEC msdb.dbo.rds_alter_resource_governor_configuration;
```
## Statistik zurücksetzen
Die Resource Governor-Statistiken sind seit dem letzten Serverneustart kumulativ. Wenn Sie ab einem bestimmten Zeitpunkt Statistiken sammeln müssen, können Sie die Statistiken mithilfe der folgenden gespeicherten Amazon RDS-Prozedur zurücksetzen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_governor_configuration
@reset_statistics = 1;
```
Zum Zurücksetzen von Statistiken ist der folgende Parameter erforderlich:
+ `@reset_statistics`muss 1 sein
## Änderungen der Konfiguration von Resource Governor
Wenn Resource Governor nicht aktiviert ist, `rds_alter_resource_governor_configuration` aktiviert Resource Governor. Die Aktivierung der Ressourcenkontrolle hat folgende Ergebnisse:
+ Die Klassifizierungsfunktion, falls vorhanden, wird für neue Sitzungen ausgeführt, wobei sie Workload-Gruppen zugewiesen werden.
+ Die in der Resource Governor-Konfiguration angegebenen Ressourcengrenzwerte werden eingehalten und durchgesetzt.
+ Die in der Resource Governor-Konfiguration angegebenen Ressourcengrenzwerte werden eingehalten und durchgesetzt.
+ Anfragen, die vor der Aktivierung von Resource Governor bestanden haben, können von Konfigurationsänderungen betroffen sein, die bei der Aktivierung von Resource Governor vorgenommen wurden.
+ Bestehende Anfragen, bevor Resource Governor aktiviert wurde, können von allen Konfigurationsänderungen betroffen sein, die vorgenommen wurden, wenn Resource Governor aktiviert wurde.
+ Auf RDS für SQL Server `EXEC msdb.dbo.rds_alter_resource_governor_configuration` müssen alle Änderungen an der Resource Governor-Konfiguration ausgeführt werden, damit sie wirksam werden.
**Usage**
```
USE [msdb]
EXEC dbo.rds_alter_resource_governor_configuration
```
## TempDB an einen Ressourcenpool binden
Mithilfe von Amazon RDS SQL Server Version 2019 und höher können Sie speicheroptimierte tempdb-Metadaten `rds_bind_tempdb_metadata_to_resource_pool` an einen bestimmten Ressourcenpool binden.
**Anmerkung**
Die speicheroptimierte Tempdb-Metadatenfunktion muss aktiviert werden, bevor tempdb-Metadaten an den Ressourcenpool gebunden werden können. Um diese Funktion auf Amazon RDS zu aktivieren, ist es ein statischer Parameter`tempdb metadata memory-optimized`.
Aktivieren Sie den statischen Parameter auf Amazon RDS und führen Sie einen Neustart ohne Failover durch, damit der Parameter wirksam wird:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name test-sqlserver-ee-2022 \
--parameters "ParameterName='tempdb metadata memory-optimized',ParameterValue=True,ApplyMethod=pending-reboot"
```
**Usage**
```
USE [msdb]
EXEC dbo.rds_bind_tempdb_metadata_to_resource_pool
@pool_name=value;
```
Der folgende Parameter ist erforderlich:
+ `@pool_name`- Ist der Name eines vorhandenen benutzerdefinierten Ressourcenpools.
**Anmerkung**
Diese Änderung erfordert außerdem einen Neustart des SQL-Dienstes ohne Failover, damit sie wirksam wird, auch wenn die speicheroptimierte TempDB-Metadatenfunktion bereits aktiviert ist.
## TempDB von einem Ressourcenpool trennen
Entbindet speicheroptimierte tempdb-Metadaten aus einem Ressourcenpool.
**Anmerkung**
Diese Änderung erfordert außerdem einen Neustart des SQL-Dienstes ohne Failover, um wirksam zu werden
**Usage**
```
USE [msdb]
EXEC dbo.rds_unbind_tempdb_metadata_from_resource_pool
```
## Steuerung der Ressourcen für Cleanup
Mit diesem Verfahren werden alle zugehörigen Objekte bereinigt, nachdem Sie die Option „Ressourcenkontrolle“ aus der Optionsgruppe entfernt haben. Dadurch wird die Ressourcenkontrolle deaktiviert, die Standard-Workload-Gruppe auf die Standardeinstellungen zurückgesetzt und benutzerdefinierte Workload-Gruppen, Ressourcenpools und Klassifizierungsfunktionen entfernt.
**Schlüsselfunktionen**
+ Setzt die Standard-Workload-Gruppe auf die Standardeinstellungen zurück
+ Deaktiviert den Ressourcengouverneur
+ Entfernt benutzerdefinierte Workload-Gruppen
+ Entfernt benutzerdefinierte Ressourcenpools
+ Löscht Klassifikatorfunktionen
+ Entfernt die Tempdb-Ressourcenpool-Bindung, falls sie aktiviert ist
**Wichtig**
Bei dieser Bereinigung kann ein Fehler auftreten, wenn in der Workload-Gruppe aktive Sitzungen vorhanden sind. Warten Sie entweder, bis die aktiven Sitzungen abgeschlossen sind, oder beenden Sie die aktiven Sitzungen gemäß Ihren Geschäftsanforderungen. Es wird empfohlen, dies während des Wartungsfensters auszuführen.
Bei dieser Bereinigung kann ein Fehler auftreten, wenn ein Ressourcenpool an tempdb gebunden war und ein Neustart ohne Failover noch nicht stattgefunden hat. Wenn Sie zuvor einen Ressourcenpool an tempdb gebunden oder einen Ressourcenpool von tempdb getrennt haben, führen Sie einen Neustart ohne Failover durch, damit die Änderung wirksam wird. Es wird empfohlen, dies während des Wartungsfensters auszuführen.
**Usage**
```
USE [msdb]
EXEC dbo.rds_cleanup_resource_governor
```
## Überlegungen zur Multi-AZ-Bereitstellung
RDS für SQL Server repliziert Resource Governor auf eine sekundäre Instanz in einer Multi-AZ-Bereitstellung. Sie können überprüfen, wann der geänderte und der neue Resource Governor zuletzt mit der sekundären Instanz synchronisiert wurden.
Verwenden Sie die folgende Abfrage, um die `last_sync_time` Replikation zu überprüfen:
```
SELECT * from msdb.dbo.rds_fn_server_object_last_sync_time();
```
Wenn in den Abfrageergebnissen die Synchronisierungszeit nach der Aktualisierungs- oder Erstellungszeit der Ressourcenkontrolle liegt, wird die Ressourcenkontrolle mit der Sekundärseite synchronisiert.
Um ein manuelles DB-Failover durchzuführen, um zu bestätigen, dass der Resource Governor repliziert, warten Sie zunächst, `last_sync_time` bis der aktualisiert wird. Fahren Sie dann mit dem Multi-AZ-Failover fort.
## Überlegungen zu Read Replicas
+ Verwenden Sie für SQL Server-Replikate in derselben Region wie die Quell-DB-Instance dieselbe Optionsgruppe wie die Quelle. Änderungen an der Optionsgruppe werden unabhängig von ihren Wartungsfenstern sofort auf die Replikate übertragen.
+ Wenn Sie ein regionsübergreifendes SQL Server-Replikat erstellen, erstellt RDS eine spezielle Optionsgruppe dafür.
+ Ein regionsübergreifendes SQL-Server-Replikat kann nicht aus seiner dedizierten Optionsgruppe entfernt werden. Die dedizierte Optionsgruppe eines regionsübergreifenden SQL-Server-Replikats kann nicht von anderen DB-Instances verwendet werden.
+ Bei der Option Resource Governor handelt es sich um nicht replizierte Optionen. Sie können nicht replizierte Optionen einer dedizierten Optionsgruppe hinzufügen oder daraus entfernen.
+ Wenn Sie ein regionsübergreifendes SQL-Server-Lesereplikat hochstufen, verhält sich das hochgestufte Lesereplikat genau so wie andere DB-Instances von SQL Server, einschließlich der Verwaltung seiner Optionen.
**Anmerkung**
Wenn Sie Resource Governor für eine Read Replica verwenden, müssen Sie manuell sicherstellen, dass Resource Governor auf Ihrer Read Replica mithilfe von gespeicherten Amazon RDS-Prozeduren konfiguriert wurde, nachdem die Option zur Optionsgruppe hinzugefügt wurde. Resource Governor-Konfigurationen werden nicht automatisch auf die Read Replica repliziert. Außerdem unterscheidet sich die Arbeitslast auf der Read Replica in der Regel von der der primären Instanz. Daher wird empfohlen, die Ressourcenkonfiguration auf der Replica auf der Grundlage Ihrer Arbeitslast und Ihres Instanztyps anzuwenden. Sie können diese gespeicherten Amazon RDS-Prozeduren auf Read Replica unabhängig voneinander ausführen, um Resource Governor für Read Replica zu konfigurieren.
# Überwachen Sie die Microsoft SQL Server-Ressourcenkontrolle mithilfe von Systemansichten für Ihre RDS for SQL Server-Instanz
Die Resource Governor-Statistiken sind seit dem letzten Serverneustart kumulativ. Wenn Sie ab einem bestimmten Zeitpunkt Statistiken sammeln müssen, können Sie die Statistiken mithilfe der folgenden gespeicherten Amazon RDS-Prozedur zurücksetzen:
```
EXEC msdb.dbo.rds_alter_resource_governor_configuration
@reset_statistics = 1;
```
## Laufzeitstatistiken für den Ressourcenpool
Für jeden Ressourcenpool verfolgt Resource Governor die CPU- und Speicherauslastung, out-of-memory Ereignisse, Speicherzuweisungen, I/O und andere Statistiken. Weitere Informationen finden Sie unter [sys.dm\$1resource\$1governor\$1resource\$1pools](https://learn.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/sys-dm-resource-governor-resource-pools-transact-sql?view=sql-server-ver17).
Die folgende Abfrage gibt eine Teilmenge der verfügbaren Statistiken für alle Ressourcenpools zurück:
```
SELECT rp.pool_id,
rp.name AS resource_pool_name,
wg.workload_group_count,
rp.statistics_start_time,
rp.total_cpu_usage_ms,
rp.target_memory_kb,
rp.used_memory_kb,
rp.out_of_memory_count,
rp.active_memgrant_count,
rp.total_memgrant_count,
rp.total_memgrant_timeout_count,
rp.read_io_completed_total,
rp.write_io_completed_total,
rp.read_bytes_total,
rp.write_bytes_total,
rp.read_io_stall_total_ms,
rp.write_io_stall_total_ms
FROM sys.dm_resource_governor_resource_pools AS rp
OUTER APPLY (
SELECT COUNT(1) AS workload_group_count
FROM sys.dm_resource_governor_workload_groups AS wg
WHERE wg.pool_id = rp.pool_id
) AS wg;
```
# Deaktivieren der Microsoft SQL Server-Ressourcenkontrolle für Ihre RDS for SQL Server-Instanz
Wenn Sie die Ressourcenkontrolle auf RDS für SQL Server deaktivieren, beendet der Dienst die Verwaltung von Arbeitslastressourcen. Bevor Sie Resource Governor deaktivieren, sollten Sie überprüfen, wie sich dies auf Ihre Datenbankverbindungen und Konfigurationen auswirkt.
Die Deaktivierung von Resource Governor hat die folgenden Ergebnisse:
+ Die Klassifizierungsfunktion wird nicht ausgeführt, wenn eine neue Verbindung geöffnet wird.
+ Neue Verbindungen werden automatisch der Standard-Workload-Gruppe zugeordnet.
+ Alle vorhandenen Einstellungen für Arbeitslastgruppen und Ressourcenpools werden auf ihre Standardwerte zurückgesetzt.
+ Wenn Grenzwerte erreicht werden, werden keine Ereignisse ausgelöst.
+ Änderungen an der Konfiguration von Resource Governor können vorgenommen werden, aber die Änderungen werden erst wirksam, wenn Resource Governor aktiviert ist.
Um Resource Governor zu deaktivieren, entfernen Sie die `RESOURCE_GOVERNOR` Option aus ihrer Optionsgruppe.
## Konsole
Mit dem folgenden Verfahren wird die Option `RESOURCE_GOVERNOR` entfernt.
**Um die Option RESOURCE\$1GOVERNOR aus ihrer Optionsgruppe zu entfernen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Option groups (Optionsgruppen)** aus.
1. Wählen Sie die Optionsgruppe mit der Option `RESOURCE_GOVERNOR` (`resource-governor-ee-2022` in den vorherigen Beispielen).
1. Wählen Sie **Delete option (Option löschen)** aus.
1. Wählen Sie unter **Löschoptionen** **RESOURCE\$1GOVERNOR** für Zu löschende **Optionen** aus.
1. Wählen Sie unter **Apply immediately** (Sofort anwenden) die Option **Yes** (Ja) aus, um die Option sofort zu löschen, oder **No** (Nein), um sie während des nächsten Wartungsfensters zu löschen.
1. Wählen Sie **Löschen** aus.
## CLI
Mit dem folgenden Verfahren wird die Option `RESOURCE_GOVERNOR` entfernt.
**Um die Option RESOURCE\$1GOVERNOR aus ihrer Optionsgruppe zu entfernen**
+ Führen Sie einen der folgenden Befehle aus.
**Example**
Für Linux, macOS oder Unix:
```
aws rds remove-option-from-option-group \
--option-group-name resource-governor-ee-2022 \
--options RESOURCE_GOVERNOR \
--apply-immediately
```
Für Windows:
```
aws rds remove-option-from-option-group ^
--option-group-name resource-governor-ee-2022 ^
--options RESOURCE_GOVERNOR ^
--apply-immediately
```
# Bewährte Methoden für die Konfiguration von Resource Governor auf RDS für SQL Server
Um den Ressourcenverbrauch zu kontrollieren, unterstützt RDS for SQL Server Resource Governor von Microsoft SQL Server. Die folgenden bewährten Methoden helfen Ihnen dabei, häufig auftretende Konfigurationsprobleme zu vermeiden und die Datenbankleistung zu optimieren.
1. Die Resource Governor-Konfiguration wird in der `master` Datenbank gespeichert. Es wird empfohlen, eine Kopie der Resource Governor-Konfigurationsskripten immer separat zu speichern.
1. Die Klassifizierungsfunktion verlängert die Verarbeitungszeit für die Anmeldung. Es wird daher empfohlen, komplexe Logik im Klassifikator zu vermeiden. Eine zu komplexe Funktion kann zu Verzögerungen bei der Anmeldung oder zu Verbindungszeitüberschreitungen führen, einschließlich Amazon RDS-Automatisierungssitzungen. Dies kann sich auf die Fähigkeit der Amazon RDS-Automatisierung auswirken, den Zustand der Instance zu überwachen. Daher wird immer empfohlen, die Classifier-Funktion vor der Implementierung in Produktionsumgebungen in einer Vorproduktionsumgebung zu testen.
1. Vermeiden Sie es, hohe Werte (über 70) für `REQUEST_MAX_MEMORY_GRANT_PERCENT` Workload-Gruppen festzulegen, da dies verhindern kann, dass die Datenbank-Instance ausreichend Speicher für andere gleichzeitige Abfragen zuweist, was möglicherweise zu Timeout-Fehlern bei der Speicherzuweisung führen kann (Fehler 8645). Umgekehrt könnte ein zu niedriger Wert (kleiner als 1) oder auf 0 verhindern, dass Abfragen, die Memory-Workspace benötigen (z. B. solche, die Sortier- oder Hashoperationen beinhalten), in benutzerdefinierten Workload-Gruppen ordnungsgemäß ausgeführt werden. RDS setzt diese Grenzwerte durch, indem es die Werte für Standard-Workload-Gruppen auf Werte zwischen 1 und 70 beschränkt.
1. Beim Binden von tempdb an einen Ressourcenpool erreicht der Pool nach dem Binden speicheroptimierter tempdb-Metadaten an einen Pool möglicherweise seine maximale Einstellung, und alle Abfragen, die verwendet werden, schlagen `tempdb` möglicherweise mit Fehlern fehl. out-of-memory Unter bestimmten Umständen kann der SQL Server möglicherweise beendet werden, wenn ein out-of-memory Fehler auftritt. Um die Wahrscheinlichkeit zu verringern, dass dies passiert, setzen Sie den Speicherpool `MAX_MEMORY_PERCENT` auf einen hohen Wert.
# Häufige DBA-Aufgaben für Amazon RDS für Microsoft SQL Server
Dieser Abschnitt beschreibt die Amazon-RDS-spezifischen Implementierungen einiger häufiger DBA-Aufgaben für DB-Instances, auf denen die Microsoft-SQL-Server-Datenbank-Engine ausgeführt wird. Um eine verwaltete Service-Erfahrung zu bieten, stellt Amazon RDS keinen Shell-Zugriff auf DB-Instances bereit, und beschränkt den Zugriff auf bestimmte Systemprozeduren und -tabellen, die erweiterte Sonderrechte erfordern.
**Anmerkung**
Wenn Sie mit einer SQL Server DB-Instance arbeiten, können Sie Skripts für die Änderung einer neu erstellten Datenbank ausführen. Sie können jedoch nicht die [Modell]-Datenbank ändern, die von der Datenbank als Modell für neue Datenbanken verwendet wurde.
**Topics**
+ [
# Zugriff auf die Datenbank tempdb in Microsoft-SQL-Server-DB-Instances in Amazon RDS
](SQLServer.TempDB.md)
+ [
# Analysieren Ihrer Datenbank-Workload auf einer Amazon RDS for SQL Server DB-Instance mit Database Engine Tuning Advisor
](Appendix.SQLServer.CommonDBATasks.Workload.md)
+ [
# Ändern des `db_owner`- in das `rdsa`-Konto für Ihre Server-Datenbank in Amazon RDS für SQL
](Appendix.SQLServer.CommonDBATasks.ChangeDBowner.md)
+ [
# Verwalten von Sortierungen und Zeichensätzen für Amazon RDS für Microsoft SQL Server
](Appendix.SQLServer.CommonDBATasks.Collation.md)
+ [
# Erstellen eines Datenbankbenutzers für Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.CreateUser.md)
+ [
# Bestimmen eines Wiederherstellungsmodells für Ihre Datenbank in Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.DatabaseRecovery.md)
+ [
# Ermitteln der letzten Failover-Zeit für Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.LastFailover.md)
+ [
# Behebung von zeitpunktbezogenen Wiederherstellungsfehlern aufgrund einer Lücke bei der Protokollsequenznummer
](Appendix.SQLServer.CommonDBATasks.PITR-LSN-Gaps.md)
+ [
# Verweigern oder Zulassen des Anzeigens von Datenbanknamen für Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.ManageView.md)
+ [
# Deaktivieren schneller Einfügungen während des Massenladens für Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.DisableFastInserts.md)
+ [
# Verwerfen einer Datenbank in einer DB-Instance in Amazon RDS für Microsoft SQL Server
](Appendix.SQLServer.CommonDBATasks.DropMirrorDB.md)
+ [
# Umbenennen einer Datenbank in Amazon RDS für Microsoft SQL Server in einer Multi-AZ-Bereitstellung
](Appendix.SQLServer.CommonDBATasks.RenamingDB.md)
+ [
# Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.ResetPassword.md)
+ [
# Wiederherstellen von DB-Instances für Amazon RDS für SQL Server, die aus Lizenzgründen beendet wurden
](Appendix.SQLServer.CommonDBATasks.RestoreLTI.md)
+ [
# Übergang einer Server-Datenbank in Amazon RDS für SQL von OFFLINE zu ONLINE
](Appendix.SQLServer.CommonDBATasks.TransitionOnline.md)
+ [
# Verwenden von Change Data Capture für Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.CDC.md)
+ [
# Verwenden von SQL Server Agent für Amazon RDS
](Appendix.SQLServer.CommonDBATasks.Agent.md)
+ [
# Arbeiten mit Microsoft-SQL-Server-Protokollen
](Appendix.SQLServer.CommonDBATasks.Logs.md)
+ [
# Arbeiten mit Trace- und Dump-Dateien für Amazon RDS für SQL Server
](Appendix.SQLServer.CommonDBATasks.TraceFiles.md)
# Zugriff auf die Datenbank tempdb in Microsoft-SQL-Server-DB-Instances in Amazon RDS
Sie können auf die `tempdb`-Datenbank auf Ihren Microsoft-SQL-Server-DB-Instances auf Amazon RDS zugreifen. Sie können Code auf `tempdb` mit Transact-SQL über Microsoft SQL Server Management Studio (SSMS) oder über eine andere Standard-SQL-Clientanwendung ausführen. Weitere Informationen zum Herstellen einer Verbindung zur DB-Instance finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Der Hauptbenutzer der DB-Instance erhält `CONTROL`-Zugriff auf `tempdb`, so dass dieser Benutzer die `tempdb`-Datenbankoptionen ändern kann. Der Hauptbenutzer ist nicht der Besitzer der `tempdb`-Datenbank. Falls notwendig, kann der Hauptbenutzer anderen Benutzern den `CONTROL`-Zugriff gewähren, damit diese ebenfalls die `tempdb`-Datenbankoptionen ändern können.
**Anmerkung**
Für die `tempdb`-Datenbank können keine Datenbankkonsolenbefehle (Database Console Commands, DBCC) ausgeführt werden.
# Ändern der Datenbankoptionen für tempdb
Sie können die Datenbankoptionen für die `tempdb`-Datenbank auf den Amazon-RDS-DB-Instances ändern. Weitere Informationen darüber, welche Optionen geändert werden können, finden Sie unter [tempdb Database](https://msdn.microsoft.com/en-us/library/ms190768%28v=sql.120%29.aspx) in der Microsoft-Dokumentation.
Datenbankoptionen wie z. B. die Optionen für die maximale Dateigröße bleiben nach einem Neustart der DB-Instance bestehen. Sie können die Datenbankoptionen ändern, um die Leistung beim Datenimport zu optimieren und um Speicherplatzmangel vorzubeugen.
## Optimieren der Leistung beim Import von Daten
Setzen Sie die Eigenschaften `SIZE` und `FILEGROWTH` der Datenbank "tempdb" auf hohe Zahlenwerte, um beim Importieren von großen Datenmengen in die DB-Instance die Leistung zu optimieren. Weitere Informationen zur Optimierung von `tempdb` finden Sie unter [Optimieren der Leistung von tempdb](https://technet.microsoft.com/en-us/library/ms175527%28v=sql.120%29.aspx) in der Microsoft-Dokumentation.
Im folgenden Beispiel wird die Größe auf 100 GB und das Datenwachstum auf 10 Prozent eingestellt.
```
1. alter database[tempdb] modify file (NAME = N'templog', SIZE=100GB, FILEGROWTH = 10%)
```
## Vorbeugen von Speicherproblemen
Legen Sie einen Wert für die Eigenschaft `tempdb` fest, damit die `MAXSIZE`-Datenbank nicht den gesamten verfügbaren Speicherplatz belegt. Im folgenden Beispiel wird diese Eigenschaft auf 2048 MB festgelegt.
```
1. alter database [tempdb] modify file (NAME = N'templog', MAXSIZE = 2048MB)
```
# Verkleinern der Datenbank tempdb
Es gibt zwei Möglichkeiten, um die `tempdb`-Datenbank auf der Amazon-RDS-DB-Instance zu verkleinern. Sie können die Prozedur `rds_shrink_tempdbfile` verwenden oder einen Wert für die Eigenschaft `SIZE` definieren.
## Verwenden der Prozedur rds\$1shrink\$1tempdbfile
Mithilfe der Amazon-RDS-Prozedur `msdb.dbo.rds_shrink_tempdbfile` verkleinern Sie die `tempdb`-Datenbank. Sie können `rds_shrink_tempdbfile` nur aufrufen, wenn Sie `CONTROL`-Zugriff auf `tempdb` haben. Durch den Aufruf von `rds_shrink_tempdbfile` wird keine Betriebsunterbrechung der DB-Instance verursacht.
Die Prozedur `rds_shrink_tempdbfile` hat die folgenden Parameter.
****
| Parametername | Datentyp | Standard | Erforderlich | Beschreibung |
| --- | --- | --- | --- | --- |
| `@temp_filename` | SYSNAME | — | Erforderlich | Der logische Name der Datei, die verkleinert werden soll. |
| `@target_size` | int | Null | optional | Die neue Größe für diese Datei in Megabytes. |
Im folgenden Beispiel werden die Namen der Dateien für die `tempdb`-Datenbank abgerufen.
```
1. use tempdb;
2. GO
3.
4. select name, * from sys.sysfiles;
5. GO
```
Im folgenden Beispiel wird eine `tempdb`-Datenbankdatei mit dem Namen `test_file` verkleinert und die neue Größe auf `10` MB festgelegt:
```
1. exec msdb.dbo.rds_shrink_tempdbfile @temp_filename = N'test_file', @target_size = 10;
```
## Festlegen der Eigenschaft SIZE
Sie können die `tempdb`-Datenbank auch verkleinern, indem Sie die Eigenschaft `SIZE` festlegen und anschließend die DB-Instance neu starten. Weitere Informationen zum Neustart der DB-Instance finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md).
Im folgenden Beispiel wird die Eigenschaft `SIZE` auf 1024 MB festgelegt.
```
1. alter database [tempdb] modify file (NAME = N'templog', SIZE = 1024MB)
```
# TempDB-Konfiguration für Multi-AZ-Bereitstellungen
Sie sollten einige Punkte zur Verwendung der `tempdb`-Datenbank berücksichtigen, wenn sich Ihre DB-Instance von RDS für SQL Server in einer Multi-AZ-Bereitstellung mit Datenbankspiegelung oder Always-On-Verfügbarkeitsgruppen befindet.
Sie können keine `tempdb`-Daten von Ihrer primären DB-Instance auf Ihre sekundäre DB-Instance replizieren. Wenn Sie ein Failover zu einer sekundären DB-Instance durchführen, ist `tempdb` auf dieser sekundären DB-Instance leer.
Sie können die Konfiguration der `tempdb`-Datenbankoptionen, einschließlich der Einstellungen für Dateigröße und automatische Erweiterung, von Ihrer primären DB-Instance mit Ihrer sekundären DB-Instance synchronisieren. Die Synchronisation der `tempDB`-Konfiguration wird auf allen Versionen von RDS für SQL Server unterstützt. Sie können die automatische Synchronisation der `tempdb`-Konfiguration mithilfe der folgenden gespeicherten Prozedur aktivieren:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'TempDbFile';
```
**Wichtig**
Bevor Sie die gespeicherte Prozedur `rds_set_system_database_sync_objects` verwenden, stellen Sie sicher, dass Sie Ihre bevorzugte `tempdb`-Konfiguration auf Ihrer primären DB-Instance und nicht auf Ihrer sekundären DB-Instance festgelegt haben. Wenn Sie die Konfigurationsänderung auf Ihrer sekundären DB-Instance vorgenommen haben, könnte Ihre bevorzugte `tempdb`-Konfiguration gelöscht werden, wenn Sie die automatische Synchronisation aktivieren.
Sie können die folgende Funktion verwenden, um zu überprüfen, ob die automatische Synchronisation der `tempdb`-Konfiguration aktiviert ist:
```
SELECT * from msdb.dbo.rds_fn_get_system_database_sync_objects();
```
Wenn die automatische Synchronisation der `tempdb`-Konfiguration aktiviert ist, wird ein Wert für das Feld `object_class` zurückgegeben. Wenn sie deaktiviert ist, wird kein Wert zurückgegeben.
Sie können die folgende Funktion verwenden, um zu ermitteln, wann Objekte zuletzt synchronisiert wurden (in (UTC):
```
SELECT * from msdb.dbo.rds_fn_server_object_last_sync_time();
```
Wenn Sie beispielsweise die `tempdb`-Konfiguration um 01:00 Uhr geändert und dann die Funktion `rds_fn_server_object_last_sync_time` ausgeführt haben, sollte der für `last_sync_time` zurückgegebene Wert nach 01:00 Uhr liegen, was darauf hinweist, dass eine automatische Synchronisation stattgefunden hat.
Wenn Sie auch die Auftragsreplikation von SQL Server Agent verwenden, können Sie die Replikation sowohl für SQL-Agent-Aufträge als auch für die `tempdb`-Konfiguration aktivieren, indem Sie sie im Parameter `@object_type` angeben:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'SQLAgentJob,TempDbFile';
```
Weitere Informationen zur Auftragsreplikation von SQL Server Agent finden Sie unter [Aktivieren der Auftragsreplikation von SQL Server Agent](Appendix.SQLServer.CommonDBATasks.Agent.md#SQLServerAgent.Replicate).
Als Alternative zur Verwendung der gespeicherten Prozedur `rds_set_system_database_sync_objects`, um sicherzustellen, dass `tempdb`-Konfigurationsänderungen automatisch synchronisiert werden, können Sie eine der folgenden manuellen Methoden verwenden:
**Anmerkung**
Wir empfehlen, die automatische Synchronisation der `tempdb`-Konfiguration mithilfe der gespeicherten Prozedur `rds_set_system_database_sync_objects` zu aktivieren. Durch die automatische Synchronisation müssen Sie diese manuellen Aufgaben nicht jedes Mal ausführen, wenn Sie Ihre `tempdb`-Konfiguration ändern.
+ Ändern Sie zuerst die DB-Instance und deaktivieren Sie Multi-AZ. Dann modifizieren Sie "tempdb" und aktivieren abschließend wieder Multi-AZ. Durch diese Methode entsteht keine Ausfallzeit.
Weitere Informationen finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
+ Ändern Sie zuerst `tempdb` auf der ursprünglichen primären Instance, führen Sie dann manuell ein Failover durch, und ändern Sie dann `tempdb` auf der neuen primären Instance. Bei dieser Methode kommt es zu einem Ausfall.
Weitere Informationen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md).
# Analysieren Ihrer Datenbank-Workload auf einer Amazon RDS for SQL Server DB-Instance mit Database Engine Tuning Advisor
Database Engine Tuning Advisor ist eine von Microsoft bereitgestellte Client-Anwendung, die den Workload der Datenbank analysiert und einen optimalen Satz von Indizes für Ihre Microsoft SQL Server-Datenbanken basierend auf den Arten von Abfragen empfiehlt, die Sie ausführen. Wie auch SQL Server Management Studio kann der Optimierungshelfer von einem Client-Computer ausgeführt werden, der eine Verbindung zu Ihrer Amazon RDS-DB-Instance aufbaut, auf der SQL Server ausgeführt wird. Beim Clientcomputer kann es sich um einen lokalen hauseigenen Computer innerhalb Ihres Netzwerks oder um eine Amazon EC2-Windows-Instance handeln, die in der gleichen Region wie Ihre Amazon RDS-DB-Instance ausgeführt wird.
In diesem Abschnitt wird gezeigt, wie ein Workload für eine Analyse im Optimierungshelfer erfasst wird. Das ist die bevorzugte Vorgehensweise für die Erfassung einer Workload, da der Host-Zugriff auf die SQL Server-Instance durch Amazon RDS beschränkt wird. Weitere Informationen finden Sie unter [Database Engine Tuning Advisor](https://docs.microsoft.com/en-us/sql/relational-databases/performance/database-engine-tuning-advisor) in der Microsoft-Dokumentation.
Um den Optimierungshelfer zu verwenden, müssen Sie dem Helfer eine sogenannte Workload zur Verfügung stellen. Eine Workload besteht aus einer Reihe von Transact-SQL-Statements, die in einer oder in mehreren Datenbanken ausgeführt werden, die Sie optimieren möchten. Der Datenbank-Engine-Optimierungshelfer verwendet bei der Optimierung von Datenbanken Trace-Dateien, Trace-Tabellen, Transact-SQL-Skripts oder XML-Dateien als Workload-Input. Bei der Arbeit mit Amazon RDS kann eine Workload eine Datei auf einem Clientcomputer oder eine Datenbanktabelle in einer Amazon RDS for SQL Server-DB sein, die für Ihren Clientcomputer zugänglich ist. Die Datei oder Tabelle muss Abfragen für die zu optimierenden Datenbanken enthalten, die in einem Format vorliegen, das für eine erneute Wiedergabe geeignet ist.
Damit der Optimierungshelfer optimal arbeiten kann, muss eine Workload so realistisch sein wie möglich. Sie können eine Workload-Datei oder -Tabelle erzeugen, indem Sie ein Trace für Ihre DB-Instance durchführen. Sie können während der Ausführung eines Trace entweder eine Belastung Ihrer DB-Instance simulieren oder Ihre Anwendungen mit normaler Belastung ausführen.
Es gibt zwei Arten von Traces: clientseitig und serverseitig. Die Einrichtung eines clientseitigen Trace ist unkomplizierter und es können im SQL Server Profiler Trace-Ereignisse in Echtzeit erfasst werden. Die Einrichtung eines serverseitigen Trace ist komplizierter und erfordert etwas Transact-SQL-Scripting. Darüber hinaus wird durch den Trace Speicherplatz verbraucht, da der Trace in der Amazon RDS-DB-Instance in eine Datei geschrieben wird. Es ist wichtig, zu beachten, wie viel Speicherplatz die Ausführung eines serverseitigen Trace benötigt, da die DB-Instance in den Storage-Full-Status wechseln könnte und dann nicht mehr verfügbar ist, sobald der Speicherplatz ausgeht.
Sobald in SQL Server Profiler bei einer Client-seitigen Nachverfolgung eine ausreichende Menge an Daten erfasst wurde, können Sie die Workload-Datei erzeugen, indem Sie die Nachverfolgung entweder als Datei auf dem lokalen Computer oder in einer Datenbank-Tabelle auf einer DB-Instance speichern, die für den Client-Computer verfügbar ist. Der Hauptnachteil bei der Verwendung eines clientseitigen Trace ist der, dass unter großer Auslastung eventuell nicht alle Abfragen vom Trace erfasst werden. Das könnte die Effektivität der vom Datenbank-Engine-Optimierungshelfer durchgeführten Analyse negativ beeinträchtigen. Muss ein Trace unter großer Auslastung ausgeführt werden und Sie möchten sicherstellen, dass während einer Trace-Sitzung alle Abfragen erfasst werden, sollte ein serverseitiger Trace zum Einsatz kommen.
Für einen serverseitigen Trace müssen die Trace-Dateien in der DB-Instance in einer geeigneten Workload-Datei gespeichert oder der Trace in einer Tabelle in der DB-Instance gespeichert werden, nachdem der Trace abgeschlossen ist. Sie können den SQL Server Profiler verwenden, um den Trace in einer Datei auf Ihrem lokalen Computer zu speichern oder lassen den Optimierungshelfer aus der Trace-Tabelle in der DB-Instance lesen.
# Ausführung eines clientseitigen Trace in einer SQL Server-DB-Instance
**Ausführen einer clientseitigen Nachverfolgung in einer SQL Server-DB-Instance**
1. Starten Sie SQL Server Profiler. Sie finden das Tool im Ordner Leistungstools Ihres SQL Server-Instance-Ordners. Um einen clientseitigen Trace zu starten, muss eine Trace-Definitionsvorlage geladen oder definiert werden.
1. Wählen Sie im Menü SQL Server Profiler File die Option **New Trace (Neue Nachverfolgung)**. Im Dialogfeld **Connect to Server (Mit Server verbinden)** geben Sie DB-Instance-Endpunkt, Masterbenutzernamen und das Passwort für die Datenbank ein, für die eine Nachverfolgung ausgeführt werden soll.
1. Im Dialogfeld **Trace Properties (Eigenschaften der Nachverfolgung)** geben Sie einen Namen für die Nachverfolgung ein und wählen eine Definitionsvorlage für die Nachverfolgung aus. Die Standardvorlage TSQL\$1Replay wird mit der Anwendung geliefert. Diese Vorlage kann für das Definieren Ihres Trace bearbeitet werden. Ereignisse und Ereignisinformationen können unter der Registerkarte **Events Selection (Auswahl von Ereignissen)** im Dialogfeld **Trace Properties (Eigenschaften der Nachverfolgung)** bearbeitet werden.
Weitere Informationen zu Trace-Definitionsvorlagen und zur Verwendung von SQL Server Profiler zur Angabe eines clientseitigen Trace finden Sie in der Microsoft-Dokumentation in [Database Engine Tuning Advisor](https://docs.microsoft.com/en-us/sql/relational-databases/performance/database-engine-tuning-advisor).
1. Starten Sie den clientseitigen Trace und beobachten Sie die SQL-Abfragen in Echtzeit, die für Ihre DB-Instance ausgeführt werden.
1. Wählen Sie im Menü **File (Datei)** die Option **Stop Trace (Nachverfolgung beenden)** aus, sobald die Nachverfolgung abgeschlossen ist. Speichern Sie die Ergebnisse als Datei oder als Trace-Tabelle in Ihrer DB-Instance.
# Ausführung eines serverseitigen Trace in einer SQL Server-DB-Instance
Das Schreiben eines Skripts für das Erstellen eines serverseitigen Trace kann eine komplexe Angelegenheit sein und geht über dieses Dokument hinaus. Dieser Abschnitt enthält Beispiel-Skripts, die Sie als Beispiele verwenden können. Wie auch bei einem clientseitigen Trace liegt das Ziel darin, eine Workload-Datei oder eine Trace-Tabelle zu erstellen, die mit dem Datenbank-Engine-Optimierungshelfer geöffnet werden kann.
Hier ist ein gekürztes Beispiel-Script, das einen serverseitigen Trace startet und die Details in einer Workload-Datei erfasst. Der Trace wird zunächst in der Datei RDSTrace .trc im Verzeichnis D:\$1RDSDBDATA\$1Log gespeichert und alle 100 MB wird ein Rollover ausgeführt, sodass nachfolgende Trace-Dateien die Namen RDSTrace \$11.trc, \$12.trc usw. erhalten. RDSTrace
```
DECLARE @file_name NVARCHAR(245) = 'D:\RDSDBDATA\Log\RDSTrace';
DECLARE @max_file_size BIGINT = 100;
DECLARE @on BIT = 1
DECLARE @rc INT
DECLARE @traceid INT
EXEC @rc = sp_trace_create @traceid OUTPUT, 2, @file_name, @max_file_size
IF (@rc = 0) BEGIN
EXEC sp_trace_setevent @traceid, 10, 1, @on
EXEC sp_trace_setevent @traceid, 10, 2, @on
EXEC sp_trace_setevent @traceid, 10, 3, @on
. . .
EXEC sp_trace_setfilter @traceid, 10, 0, 7, N'SQL Profiler'
EXEC sp_trace_setstatus @traceid, 1
END
```
Das folgende Beispiel ist ein Script, mit dem ein Trace angehalten wird. Beachten Sie, dass ein vom vorherigen Script erstellter Trace solange ausgeführt wird, bis Sie den Trace explizit anhalten oder die Festplattenkapazität für den Vorgang nicht mehr ausreicht.
```
DECLARE @traceid INT
SELECT @traceid = traceid FROM ::fn_trace_getinfo(default)
WHERE property = 5 AND value = 1 AND traceid <> 1
IF @traceid IS NOT NULL BEGIN
EXEC sp_trace_setstatus @traceid, 0
EXEC sp_trace_setstatus @traceid, 2
END
```
Die Ergebnisse des serverseitigen Trace können in einer Datenbank-Tabelle gespeichert, und die Datenbank-Tabelle mithilfe der Funktion fn\$1trace\$1gettable als Workload für den Optimierungshelfer verwendet werden. Mit den folgenden Befehlen werden die Ergebnisse aller Dateien mit dem Namen RDSTrace .trc im Verzeichnis D:\$1rdsdbdata\$1Log, einschließlich aller Rollover-Dateien wie \$11.trc, in eine Tabelle mit dem Namen in der aktuellen Datenbank geladen. RDSTrace RDSTrace
```
SELECT * INTO RDSTrace
FROM fn_trace_gettable('D:\rdsdbdata\Log\RDSTrace.trc', default);
```
Um eine bestimmte Rollover-Datei in einer Tabelle zu speichern, z. B. die Datei RDSTrace \$11.trc, geben Sie den Namen der Rollover-Datei an und ersetzen Sie den Wert 1 anstelle von default als letzten Parameter für fn\$1trace\$1gettable.
```
SELECT * INTO RDSTrace_1
FROM fn_trace_gettable('D:\rdsdbdata\Log\RDSTrace_1.trc', 1);
```
# Ausführung des Optimierungshelfers mit einem Trace
Sobald Sie einen Trace erstellen, entweder als lokale Datei oder als Datenbank-Tabelle, können Sie den Optimierungshelfer für Ihre DB-Instance ausführen. Die Verwendung des Optimierungshelfers für Amazon RDS entspricht dem Vorgang der Arbeit mit einer eigenständigen Remote-SQL Server-Instance. Sie können entweder die Benutzerfläche des Optimierungshelfers auf Ihrem Client-Computer oder das Hilfsprogramm dta.exe von der Befehlszeile aus verwenden. In beiden Fällen müssen bei der Verwendung des Optimierungshelfers mithilfe des Endpunkts der DB-Instance eine Verbindung zur Amazon RDS-DB-Instance hergestellt und Ihr Master User Name und Master User Password eingegeben werden.
Das folgende Code-Beispiel demonstriert die Verwendung des Befehlszeilen-Hilfsprogramms dta.exe für eine Amazon RDS-DB-Instance mit dem Endpunkt **dta.cnazcmklsdei.us-east-1.rds.amazonaws.com**. Das Beispiel enthält den Master-Benutzernamen **admin** und das Master-Benutzerkennwort **test**, die zu tunende Beispieldatenbank heißt „machine“ **C:\$1RDSTrace.trc**. Der Befehlszeilenbeispielcode legt außerdem eine Nachverfolgungssitzung mit dem Namen **RDSTrace1** fest und legt die Output-Dateien auf dem lokalen Computer mit dem Namen **RDSTrace.sql** für das SQL-Output-Script, **RDSTrace.txt** für eine Ergebnisdatei und **RDSTrace.xml** für eine XML-Datei der Analyse fest. In der Datenbank RDSDTA wird außerdem eine Fehlertabelle mit dem Namen festgeleg **RDSTraceErrors**.
```
dta -S dta.cnazcmklsdei.us-east-1.rds.amazonaws.com -U admin -P test -D RDSDTA -if C:\RDSTrace.trc -s RDSTrace1 -of C:\ RDSTrace.sql -or C:\ RDSTrace.txt -ox C:\ RDSTrace.xml -e RDSDTA.dbo.RDSTraceErrors
```
Hier sehen Sie den gleichen Befehlszeilenbeispielcode mit der Ausnahme, dass es sich bei der Input-Workload um eine Tabelle in der Amazon RDS-Instance mit dem Namen **RDSTrace** handelt, die sich in der Datenbank **RDSDTA** befindet.
```
dta -S dta.cnazcmklsdei.us-east-1.rds.amazonaws.com -U admin -P test -D RDSDTA -it RDSDTA.dbo.RDSTrace -s RDSTrace1 -of C:\ RDSTrace.sql -or C:\ RDSTrace.txt -ox C:\ RDSTrace.xml -e RDSDTA.dbo.RDSTraceErrors
```
Eine vollständige Liste der Befehlszeilenparameter des dta-Dienstprogramms finden Sie unter [dta Utility](https://docs.microsoft.com/en-us/sql/tools/dta/dta-utility) in der Microsoft-Dokumentation.
# Ändern des `db_owner`- in das `rdsa`-Konto für Ihre Server-Datenbank in Amazon RDS für SQL
Wenn Sie eine Datenbank in einer RDS-für-SQL-Server-DB-Instance erstellen oder wiederherstellen, legt Amazon RDS den Besitzer der Datenbank auf `rdsa` fest. Wenn Sie eine Multi-AZ-Bereitstellung mit SQL Server Database Mirroring (DBM) oder Always On Availability Groups (AGs) haben, setzt Amazon RDS den Besitzer der Datenbank auf der sekundären DB-Instance auf. `NT AUTHORITY\SYSTEM` Der Besitzer der sekundären Datenbank kann erst geändert werden, wenn die sekundäre DB-Instance zur primären Rolle heraufgestuft wurde. In den meisten Fällen ist es bei der Ausführung von Abfragen unproblematisch, wenn der Besitzer der Datenbank auf `NT AUTHORITY\SYSTEM` festgelegt ist. Es kann dabei jedoch zu Fehlern kommen, wenn gespeicherte Systemprozeduren wie `sys.sp_updatestats` ausgeführt werden, für deren Ausführung erhöhte Berechtigungen erforderlich sind.
Sie können die folgende Abfrage verwenden, um den Besitzer der Datenbanken von `NT AUTHORITY\SYSTEM` zu identifizieren:
```
SELECT name FROM sys.databases WHERE SUSER_SNAME(owner_sid) = 'NT AUTHORITY\SYSTEM';
```
Sie können die gespeicherte Amazon-RDS-Prozedur `rds_changedbowner_to_rdsa` verwenden, um den Besitzer der Datenbank in `rdsa` zu ändern. Die folgenden Datenbanken dürfen nicht mit `rds_changedbowner_to_rdsa` verwendet werden: `master, model, msdb, rdsadmin, rdsadmin_ReportServer, rdsadmin_ReportServerTempDB, SSISDB`.
Rufen Sie die gespeicherte `rds_changedbowner_to_rdsa`-Prozedur auf und geben Sie den Namen der Datenbank an, um den Besitzer der Datenbank in `rdsa` zu ändern.
**Example Verwendung:**
```
exec msdb.dbo.rds_changedbowner_to_rdsa 'TestDB1';
```
Der folgende Parameter ist erforderlich:
+ `@db_name` – Der Name der Datenbank, deren Besitzer in `rdsa` geändert werden soll.
**Wichtig**
Sie können `rds_changedbowner_to_rdsa` nicht verwenden, um den Besitz einer Datenbank in einen anderen Anmeldenamen zu ändern als `rdsa`. Beispielsweise können Sie den Besitzer des Anmeldenamens, mit dem Sie die Datenbank erstellt haben, nicht ändern. Um die verloren gegangene Mitgliedschaft in der `db_owner`-Rolle für Ihren Master-Benutzer wiederherzustellen, wenn kein anderer Datenbankbenutzer verwendet werden kann, um die Mitgliedschaft zu gewähren, setzen Sie das Master-Benutzerpasswort zurück, um die Mitgliedschaft in der `db_owner`-Rolle zu erhalten. Weitere Informationen finden Sie unter [Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md).
# Verwalten von Sortierungen und Zeichensätzen für Amazon RDS für Microsoft SQL Server
Dieses Thema enthält Anleitungen zur Verwaltung von Sortierungen und Zeichensätzen für Microsoft SQL Server in Amazon RDS. Es wird erklärt, wie Sortierungen während der Datenbankerstellung konfiguriert und später geändert werden, um sicherzustellen, dass Textdaten entsprechend den Sprach- und Gebietsschemaanforderungen ordnungsgemäß behandelt werden. Darüber hinaus werden bewährte Methoden zur Aufrechterhaltung der Kompatibilität und Leistung in SQL-Server-Umgebungen in Amazon RDS behandelt.
SQL Server unterstützt das Sortieren auf verschiedenen Ebenen. Sie legen die Standardsortierung für den Server fest, wenn Sie die DB-Instance erstellen. Sie können die Sortierung auf der Ebene von Datenbanken, Tabellen und Spalten überschreiben.
**Topics**
+ [
## Sortierung auf Serverebene bei Microsoft SQL Server
](#Appendix.SQLServer.CommonDBATasks.Collation.Server)
+ [
## Sortierung auf Datenbankebene bei Microsoft SQL Server
](#Appendix.SQLServer.CommonDBATasks.Collation.Database-Table-Column)
## Sortierung auf Serverebene bei Microsoft SQL Server
Wenn Sie eine Microsoft SQL Server-DB-Instance erstellen können Sie die zu verwendende Sortierung des Servers festlegen. Wenn Sie keine andere Sortierung wählen, ist die Sortierung auf Serverebene standardmäßig SQL\$1Latin1\$1General\$1 \$1CI\$1AS. CP1 Die für den Server festgelegte Sortierung wird standardmäßig für alle Datenbanken und Datenbankobjekte verwendet.
**Anmerkung**
Sie können die Sortierung nicht ändern, wenn Sie aus einem DB-Snapshot wiederherstellen.
Derzeit unterstützt Amazon RDS die folgenden Sortierungen für Server:
| Kollation | Description |
| --- | --- |
| Arabic\$1CI\$1AS | Arabisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Chinesisch\$1PRC\$1 BIN2 | Chinesisch-VR China, Sortierreihenfolge für binäre Codepunkte |
| Chinese\$1PRC\$1CI\$1AS | Chinesisch-PRC, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Chinese\$1Taiwan\$1Stroke\$1CI\$1AS | Chinesisch-Taiwan-Stroke, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Danish\$1Norwegian\$1CI\$1AS | Dänisch-Norwegisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Danish\$1Norwegian\$1CI\$1AS\$1KS | Dänisch-Norwegisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, Beachtung des Kana-Typs, keine Beachtung der Breite |
| Danish\$1Norwegian\$1CI\$1AS\$1KS\$1WS | Dänisch-Norwegisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, Beachtung des Kana-Typs, Beachtung der Breite |
| Danish\$1Norwegian\$1CI\$1AS\$1WS | Dänisch-Norwegisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, Beachtung der Breite |
| Danish\$1Norwegian\$1CS\$1AI | Dänisch-Norwegisch, Beachtung der Groß-/Kleinschreibung, keine Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Danish\$1Norwegian\$1CS\$1AI\$1KS | Dänisch-Norwegisch, Beachtung der Groß-/Kleinschreibung, keine Beachtung von Akzenten, Beachtung des Kana-Typs, keine Beachtung der Breite |
| Finnish\$1Swedish\$1100\$1BIN | Finnisch-Schwedisch-100, binäre Sortierung |
| Finnisch\$1Schwedisch\$1100\$1 BIN2 | Finnisch-Schwedisch-100, binäre Codepunkt-Vergleichssortierung |
| Finnish\$1Swedish\$1100\$1CI\$1AI | Finnisch-Schwedisch-100, keine Beachtung der Groß-/Kleinschreibung, keine Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Finnish\$1Swedish\$1100\$1CI\$1AS | Finnisch-Schwedisch-100, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Finnish\$1Swedish\$1CI\$1AS | Finnisch, Schwedisch und Schwedisch (Finnland), Groß-/Kleinschreibung irrelevant, Diakritika relevant, Kana-Typ irrelevant, Breite irrelevant |
| French\$1CI\$1AS | Französisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Greek\$1CI\$1AS | Griechisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Greek\$1CS\$1AS | Griechisch, Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Hebrew\$1BIN | Hebräisch, binäre Sortierung |
| Hebrew\$1CI\$1AS | Hebräisch, Groß-/Kleinschreibung irrelevant, Diakritika relevant, Kana-Typ irrelevant, Breite irrelevant |
| Japanese\$1BIN | Japanisch, binäre Sortierung |
| Japanese\$1CI\$1AS | Japanisch, Groß-/Kleinschreibung irrelevant, Diakritika relevant, Kana-Typ irrelevant, Breite irrelevant |
| Japanese\$1CS\$1AS | Japanisch, Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Japanese\$1XJIS\$1140\$1CI\$1AS | Japanisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite, zusätzliche Zeichen, keine Beachtung der Variierungsauswahlzeichen |
| Japanese\$1XJIS\$1140\$1CI\$1AS\$1KS\$1VSS | Japanisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, Beachtung des Kana-Typs, keine Beachtung der Breite, zusätzliche Zeichen, Beachtung der Variierungsauswahlzeichen |
| Japanese\$1XJIS\$1140\$1CI\$1AS\$1VSS | Japanisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite, zusätzliche Zeichen, Beachtung der Variierungsauswahlzeichen |
| Japanese\$1XJIS\$1140\$1CS\$1AS\$1KS\$1WS | Japanisch, Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, Beachtung des Kana-Typs, Beachtung der Breite, zusätzliche Zeichen, keine Beachtung der Variierungsauswahlzeichen |
| Korean\$1Wansung\$1CI\$1AS | Koreanisch-Wansung, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Latin1\$1General\$1100\$1BIN | Latein1-Allgemein-100, binäre Sortierung |
| Lateinisch1\$1Allgemein\$1100\$1 BIN2 | Latin1-General-100, binäre Codepunkt-Sortierreihenfolge |
| Lateinisch1\$1Allgemein\$1100\$1 \$1 BIN2 UTF8 | Latin1-General-100, binäre Codepunkt-Sortierreihenfolge, UTF-8-kodiert |
| Latin1\$1General\$1100\$1CI\$1AS | Latein1-Allgemein-100, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Lateinisch1\$1Allgemein\$1100\$1CI\$1AS\$1SC\$1 UTF8 | Latin1-General-100, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, zusätzliche Zeichen, UTF-8-kodiert |
| Latin1\$1General\$1BIN | Latein1-Allgemein, binäre Sortierung |
| Latin1\$1Allgemein\$1 BIN2 | Latin1-General, binäre Codepunkt-Sortierreihenfolge |
| Latin1\$1General\$1CI\$1AI | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, keine Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Latin1\$1General\$1CI\$1AS | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Latin1\$1General\$1CI\$1AS\$1KS | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, Beachtung des Kana-Typs, keine Beachtung der Breite |
| Latin1\$1General\$1CS\$1AS | Latein1-Allgemein, Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Modern\$1Spanish\$1CI\$1AS | Spanisch-Modern, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Polish\$1CI\$1AS | Polnisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| SQL\$11xCompat\$1 \$1CI\$1AS CP850 | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 49 auf Codepage 850 für Daten, die nicht in Unicode codiert sind |
| SQL\$1Latin1\$1Allgemein\$1 \$1CI\$1AI CP1 | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, keine Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 54 auf Codepage 1252 für Daten, die nicht in Unicode codiert sind |
| **SQL\$1Latin1\$1General\$1 CP1 \$1CI\$1AS (Standard)** | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 52 auf Codepage 1252 für Daten, die nicht in Unicode codiert sind |
| SQL\$1Latin1\$1General\$1 CP1 \$1CS\$1AS | Latein1-Allgemein, Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 51 auf Codepage 1252 für Daten, die nicht in Unicode codiert sind |
| CP437SQL\$1Latin1\$1General\$1 \$1CI\$1AI | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, keine Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 34 auf Codepage 437 für Daten, die nicht in Unicode codiert sind |
| CP850SQL\$1Latin1\$1General\$1 \$1BIN | Latin1-General, binäre Sortierreihenfolge für Unicode-Daten, SQL-Server-Sortierreihenfolge 40 auf Codepage 850 für Daten, die nicht in Unicode codiert sind |
| CP850SQL\$1Latin1\$1Allgemein\$1 \$1 BIN2 | Lateinisch 1 (allgemein), binäre Codepoint-Sortierreihenfolge für Unicode-Daten, SQL Server-Sortierreihenfolge 40 auf Codepage 850 für Daten, die nicht in Unicode kodiert sind |
| CP850SQL\$1Latin1\$1Allgemein\$1 \$1CI\$1AI | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, keine Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 44 auf Codepage 850 für Daten, die nicht in Unicode codiert sind |
| CP850SQL\$1Latin1\$1General\$1 \$1CI\$1AS | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 42 auf Codepage 850 für Daten, die nicht in Unicode codiert sind |
| SQL\$1Latin1\$1General\$1Pref\$1 CP850 \$1CI\$1AS | Latein1-Allgemein-Präf, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 183 auf Codepage 850 für Daten, die nicht in Unicode codiert sind |
| CP1256SQL\$1Latin1\$1General\$1 \$1CI\$1AS | Latein1-Allgemein, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 146 auf Codepage 1256 für Daten, die nicht in Unicode codiert sind |
| CP1255SQL\$1Latin1\$1General\$1 \$1CS\$1AS | Latein1-Allgemein, Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite für Unicode-Daten, SQL-Server-Sortierreihenfolge 137 auf Codepage 1255 für Daten, die nicht in Unicode codiert sind |
| Thai\$1CI\$1AS | Thai, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
| Turkish\$1CI\$1AS | Türkisch, keine Beachtung der Groß-/Kleinschreibung, Beachtung von Akzenten, keine Beachtung des Kana-Typs, keine Beachtung der Breite |
Sie können die Liste der unterstützten Sortierungen auch programmgesteuert abrufen, indem Sie die AWS CLI verwenden:
```
aws rds describe-db-engine-versions --engine sqlserver-ee --list-supported-character-sets --query 'DBEngineVersions[].SupportedCharacterSets[].CharacterSetName' | sort -u
```
Auswahl der Sortierung:
+ Wenn Sie die Amazon-RDS-Konsole verwenden, wählen Sie beim Erstellen einer neuen DB-Instance **Additional configuration** (Zusätzliche Konfiguration) aus und geben Sie die Sortierung im Feld **Collation** (Sortierung) ein. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
+ Wenn Sie die verwenden, verwenden Sie die Option zusammen mit dem Befehl. AWS CLI`--character-set-name` `create-db-instance` Weitere Informationen finden Sie unter [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html).
+ Wenn Sie die Amazon-RDS-API verwenden, verwenden Sie den Parameter `CharacterSetName` mit der `CreateDBInstance`-Operation. Weitere Informationen finden Sie unter [Erstellen DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html).
## Sortierung auf Datenbankebene bei Microsoft SQL Server
Die Standardsortierung kann auf Datenbank-, Tabellen- oder Spaltenebene durch außer Kraft setzen der Sortierung beim Erstellen einer neuer Datenbank oder eines Datenbankobjekts geändert werden. Wenn Ihre Standard-Serversortierung beispielsweise SQL\$1Latin1\$1General\$1 \$1CI\$1AS ist, können Sie sie zur Unterstützung der Mohawk-Sortierung in CP1 Mohawk\$1100\$1CI\$1AS ändern. Selbst Argumente in einer Abfrage können einer Typumwandlung unterzogen werden, um bei Bedarf eine andere Sortierung zu verwenden.
Die folgende Abfrage würde beispielsweise die Standardsortierung für die Spalte in Mohawk\$1100\$1CI\$1AS ändern AccountName
```
CREATE TABLE [dbo].[Account]
(
[AccountID] [nvarchar](10) NOT NULL,
[AccountName] [nvarchar](100) COLLATE Mohawk_100_CI_AS NOT NULL
) ON [PRIMARY];
```
Die Microsoft SQL Server-DB-Engine unterstützt durch die integrierten Datentypen NCHAR, NVARCHAR und NTEXT auch Unicode. Wenn Sie z. B. CJK-Unterstützung benötigen, verwenden Sie diese Unicode-Datentypen für die Zeichenspeicherung und setzen bei der Erstellung Ihrer Datenbanken und Tabellen die Server-Standardsortierung außer Kraft. Hier sind verschiedene Links von Microsoft, die das Thema Sortierung und Unicode-Support für SQL Server behandeln:
+ [Arbeiten mit Sortierungen](http://msdn.microsoft.com/en-us/library/ms187582%28v=sql.105%29.aspx)
+ [Sortierung und internationale Terminologie](http://msdn.microsoft.com/en-us/library/ms143726%28v=sql.105%29)
+ [Verwenden von SQL Server-Sortierungen](http://msdn.microsoft.com/en-us/library/ms144260%28v=sql.105%29.aspx)
+ [Internationale Erwägungen für Datenbanken und Datenbank-Engine-Anwendungen](http://msdn.microsoft.com/en-us/library/ms190245%28v=sql.105%29.aspx)
# Erstellen eines Datenbankbenutzers für Amazon RDS für SQL Server
Sie können einen Datenbankbenutzer für Ihre DB-Instance von Amazon RDS für Microsoft SQL Server erstellen, indem Sie ein T-SQL-Skript wie im folgenden Beispiel ausführen. Verwenden Sie eine Anwendung wie SQL Server Management Suite (SSMS). Sie melden sich bei der DB-Instance als Hauptbenutzer an, der beim Erstellen der DB-Instance erstellt wurde.
```
--Initially set context to master database
USE [master];
GO
--Create a server-level login named theirname with password theirpassword
CREATE LOGIN [theirname] WITH PASSWORD = 'theirpassword';
GO
--Set context to msdb database
USE [msdb];
GO
--Create a database user named theirname and link it to server-level login theirname
CREATE USER [theirname] FOR LOGIN [theirname];
GO
```
Ein Beispiel für das Hinzufügen eines Datenbankbenutzers zu einer Rolle finden Sie unter [Hinzufügen eines Benutzers zur Rolle SQLAgentUser](SQLServerAgent.AddUser.md).
**Anmerkung**
Wenn Sie beim Hinzufügen eines Benutzers Berechtigungsfehler erhalten, können Sie die Berechtigungen wiederherstellen, indem Sie das Passwort für den DB-Instance-Hauptbenutzer ändern. Weitere Informationen finden Sie unter [Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md).
Es ist keine bewährte Methode, Master-Benutzerberechtigungen in Ihren Anwendungen zu klonen. Weitere Informationen finden Sie unter [So klonen Sie Master-Benutzerberechtigungen in Amazon RDS für SQL Server](https://aws.amazon.com/blogs/database/how-to-clone-master-user-permissions-in-amazon-rds-for-sql-server/).
# Bestimmen eines Wiederherstellungsmodells für Ihre Datenbank in Amazon RDS für SQL Server
In Amazon RDS sind Wiederherstellungsmodell, Aufbewahrungszeitraum und Datenbankstatus miteinander verknüpft.
Daher ist es wichtig, sich über die Konsequenzen klar zu werden, bevor eine Änderung an diesen Einstellungen vorgenommen wird. Jede Einstellung kann sich auf andere auswirken. Zum Beispiel:
+ Wenn Sie das Wiederherstellungsmodell einer Datenbank bei aktiviertem Aufbewahrungszeitraum auf SIMPLE oder BULK\$1LOGGED ändern, setzt Amazon RDS das Wiederherstellungsmodell innerhalb von fünf Minuten wieder auf FULL zurück. Es führt außerdem dazu, dass RDS einen Snapshot der DB-Instance erstellt.
+ Wenn Sie als Aufbewahrungszeitraum `0` Tage einstellen, stellt RDS als Wiederherstellungsmodus SIMPLE ein.
+ Wenn Sie das Wiederherstellungsmodell der Datenbank von SIMPLE auf eine beliebig andere Option ändern, während der Aufbewahrungszeitraum auf `0` eingestellt ist, setzt RDS das Wiederherstellungsmodell wieder auf SIMPLE zurück.
**Wichtig**
Das Wiederherstellungsmodell für Multi-AZ-Instances sollte niemals geändert werden, auch wenn dies möglich zu sein scheint, so z. B. mit ALTER DATABASE. Für Multi-AZ ist ein Aufbewahrungszeitraum für Backups und damit der vollständige (FULL) Wiederherstellungsmodus erforderlich. Wenn Sie das Wiederherstellungsmodell ändern, wird es von RDS sofort wieder in "FULL (Vollständig)" geändert.
Dieses automatische Zurücksetzen zwingt RDS, die Spiegelung vollständig neu zu erstellen. Während der Neuerstellung ist die Verfügbarkeit der Datenbank ca. 30–90 Minuten lang beeinträchtigt, bis die Spiegelung für ein Failover bereit ist. Bei der DB-Instance kann es genauso wie während der Konvertierung von Einzel-AZ in Multi-AZ ebenso zu Leistungseinschränkungen kommen. Wie lange die Leistung beeinträchtigt ist, ist von der Speichergröße der Datenbank abhängig – je größer die gespeicherte Datenbank, desto länger dauert die Beeinträchtigung an.
Weitere Informationen zu SQL Server-Wiederherstellungsmodellen finden Sie unter [Wiederherstellungsmodelle (SQL Server)](https://docs.microsoft.com/en-us/sql/relational-databases/backup-restore/recovery-models-sql-server) in der Microsoft-Dokumentation.
# Ermitteln der letzten Failover-Zeit für Amazon RDS für SQL Server
Um die letzte Failover-Zeit zu bestimmen, verwenden Sie das folgende gespeicherte Verfahren:
```
execute msdb.dbo.rds_failover_time;
```
Dieses Verfahren gibt die folgenden Informationen zurück.
****
| Ausgabeparameter | Beschreibung |
| --- | --- |
| errorlog\$1available\$1from | Zeigt die Zeit an, ab der Fehlerprotokolle im Protokollverzeichnis verfügbar sind. |
| recent\$1failover\$1time | Zeigt die letzte Failover-Zeit an, wenn sie in den Fehlerprotokollen verfügbar ist. Andernfalls wird angezeig `null`. |
**Anmerkung**
Das gespeicherte Verfahren durchsucht alle verfügbaren SQL Server-Fehlerprotokolle im Protokollverzeichnis, um die letzte Failover-Zeit abzurufen. Wenn die Failover-Nachrichten von SQL Server überschrieben wurden, wird die Failover-Zeit vom Verfahren nicht abgerufen.
**Example Kein Failover in letzter Zeit**
Dieses Beispiel zeigt die Ausgabe, wenn in den Fehlerprotokollen kein aktuelles Failover vorhanden ist. Seit 2020-04-29 23:59:00.01 ist kein Failover aufgetreten.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 2020-04-29 23:59:00.0100000 | Null |
**Example Failover in letzter Zeit**
Dieses Beispiel zeigt die Ausgabe, wenn ein Failover in den Fehlerprotokollen vorliegt. Das letzte Failover erfolgte am 2020-05-05 18:57:51.89.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 2020-04-29 23:59:00.0100000 | 2020-05-05 18:57:51.8900000 |
# Behebung von zeitpunktbezogenen Wiederherstellungsfehlern aufgrund einer Lücke bei der Protokollsequenznummer
Beim Versuch einer zeitpunktbezogenen Wiederherstellung (PITR) in RDS für SQL Server können Fehler auftreten, die auf Lücken in den Protokollsequenznummern (LSNs) zurückzuführen sind. Diese Lücken verhindern, dass RDS Ihre Datenbank zum angeforderten Zeitpunkt wiederherstellt, und RDS versetzt Ihre wiederherstellende Instance in den Status `incompatible-restore`.
Dies sind häufige Ursachen für dieses Problem:
+ Manuelle Änderungen am Datenbank-Wiederherstellungsmodell.
+ Änderungen des automatischen Wiederherstellungsmodells durch RDS aufgrund unzureichender Ressourcen für die Durchführung von Transaktionsprotokollsicherungen.
Führen Sie diese Abfrage aus, um LSN-Lücken in Ihrer Datenbank zu identifizieren:
```
SELECT * FROM msdb.dbo.rds_fn_list_tlog_backup_metadata(database_name)
ORDER BY backup_file_time_utc desc;
```
Wenn Sie eine LSN-Lücke entdecken, können Sie:
+ Einen Wiederherstellungspunkt vor der LSN-Lücke auswählen.
+ Warten und auf einen Zeitpunkt nach Abschluss der nächsten Instance-Sicherung wiederherstellen.
Um dieses Problem zu vermeiden, empfehlen wir, das Wiederherstellungsmodell Ihrer RDS-für -SQL-Server-Datenbanken nicht manuell zu ändern, da dies die Instance-Beständigkeit unterbricht. Wir empfehlen Ihnen außerdem, einen Instance-Typ mit ausreichenden Ressourcen für Ihre Arbeitslast zu wählen, um regelmäßige Backups der Transaktionsprotokolle sicherzustellen.
Weitere Informationen über das Transaktionsprotokollmanagement finden Sie unter [SQL Server transaction log architecture and management guide](https://learn.microsoft.com/en-us/sql/relational-databases/sql-server-transaction-log-architecture-and-management-guide?view=sql-server-ver16) in der Dokumentation zu Microsoft SQL Server.
# Verweigern oder Zulassen des Anzeigens von Datenbanknamen für Amazon RDS für SQL Server
Der Hauptbenutzer kann nicht `DENY VIEW ANY DATABASE TO LOGIN` festlegen, um Datenbanken vor einem Benutzer zu verbergen. Verwenden Sie stattdessen die folgende gespeicherte Prozedur, um diese Berechtigung zu ändern:
+ Den Zugriff auf *LOGIN* über die Datenbankansicht verweigern:
```
EXEC msdb.dbo.rds_manage_view_db_permission @permission=‘DENY’, @server_principal=‘LOGIN’
go
```
+ Den Zugriff auf *LOGIN* über die Datenbankansicht zulassen:
```
EXEC msdb.dbo.rds_manage_view_db_permission @permission='GRANT', @server_principal='LOGIN'
go
```
Berücksichtigen Sie Folgendes, wenn Sie diese gespeicherte Prozedur verwenden:
+ Datenbanknamen sind im SSMS und in den internen DMV (Dynamic Management Views; dynamische Verwaltungsansichten) verborgen. Datenbanknamen sind jedoch weiterhin in Audit-, Protokoll- und Metadatentabellen sichtbar. Dies sind gesicherte `VIEW ANY DATABASE`-Serverberechtigungen. Weitere Informationen finden Sie unter [ DENY Server Permissions](https://learn.microsoft.com/en-us/sql/t-sql/statements/deny-server-permissions-transact-sql?view=sql-server-ver16#permissions).
+ Sobald die Berechtigung wieder auf `GRANT` zurückgesetzt wurde (erlaubt), kann das *LOGIN* alle Datenbanken einsehen.
+ Wenn Sie *LOGIN* löschen und neu erstellen, wird die mit dem LOGIN verknüpfte Anzeigeberechtigung auf `ALLOW` zurückgesetzt.
+ Legen Sie für Multi-AZ-Instances die Berechtigung `DENY` oder `GRANT` nur für das *LOGIN* auf den primären Host fest. Die Änderungen werden automatisch auf den sekundären Host übertragen.
+ Diese Berechtigung ändert nur, ob ein Login die Datenbanknamen einsehen kann. Der Zugriff auf Datenbanken und die darin enthaltenen Objekte wird jedoch separat verwaltet.
# Deaktivieren schneller Einfügungen während des Massenladens für Amazon RDS für SQL Server
Ab SQL Server 2016 sind schnelle Einfügungen standardmäßig aktiviert. Schnelle Einfügungen nutzen die minimale Protokollierung, die auftritt, während sich die Datenbank im einfachen oder in massenprotokolliertem Wiederherstellungsmodell befindet, um die Einfügeleistung zu optimieren. Bei schnellen Einfügungen erhält jeder Massenladestapel neue Ausdehnungen, wobei die Zuweisungssuche nach vorhandenen Ausdehnungen mit freiem Speicherplatz umgangen wird, um die Einfügeleistung zu optimieren.
Bei schnellen Einfügungen können Massenlasten mit kleinen Stapelgrößen jedoch zu einem erhöhten ungenutzten Speicherplatz führen, der von Objekten genutzt wird. Wenn eine Erhöhung der Stapelgröße nicht möglich ist, kann das Aktivieren des Ablaufverfolgungs-Flags 692 dazu beitragen, ungenutzten reservierten Speicherplatz zu reduzieren, jedoch auf Kosten der Leistung. Durch das Aktivieren dieses Ablaufverfolgungs-Flags werden schnelle Einfügungen beim Massenladen von Daten in Heap- oder Cluster-Indizes deaktiviert.
Sie aktivieren den Ablaufverfolgungs-Flag 692 als Startup-Parameter mittels DB-Parametergruppen. Weitere Informationen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
Ablaufverfolgungs-Flag 692 wird für Amazon RDS SQL Server 2016 und höher unterstützt. Weitere Informationen zu Ablaufverfolgungs-Flags finden Sie unter [DBCC TRACEON - Trace-Flags](https://docs.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-traceon-trace-flags-transact-sql) in der Microsoft-Dokumentation.
# Verwerfen einer Datenbank in einer DB-Instance in Amazon RDS für Microsoft SQL Server
Sie können eine Datenbank einer Amazon-RDS-DB-Instance verwerfen, auf der Microsoft SQL Server in einer Single-AZ- oder Multi-AZ-Bereitstellung ausgeführt wird. Verwenden Sie den folgenden Befehl, um die Datenbank zu verwerfen:
```
--replace your-database-name with the name of the database you want to drop
EXECUTE msdb.dbo.rds_drop_database N'your-database-name'
```
**Anmerkung**
Verwenden Sie im Befehl einfache gerade Anführungszeichen. Typographische Anführungszeichen verursachen einen Fehler.
Nachdem Sie diese Vorgehensweise zum Löschen der Datenbank verwendet haben, löscht Amazon RDS alle vorhandenen Verbindungen zur Datenbank und entfernt den Sicherungsverlauf der Datenbank.
Gehen Sie wie folgt vor, um anderen Benutzern die Möglichkeit zur Sicherung und Wiederherstellung zu gewähren:
```
USE master
GO
CREATE LOGIN user1 WITH PASSWORD=N'changeThis', DEFAULT_DATABASE=master, CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF
GO
USE msdb
GO
CREATE USER user1 FOR LOGIN user1
GO
use msdb
GO
GRANT EXECUTE ON msdb.dbo.rds_backup_database TO user1
GO
GRANT EXECUTE ON msdb.dbo.rds_restore_database TO user1
GO
```
# Umbenennen einer Datenbank in Amazon RDS für Microsoft SQL Server in einer Multi-AZ-Bereitstellung
Gehen Sie wie folgt vor, um eine Multi-AZ nutzende Microsoft SQL Server-Datenbank-Instance umzubenennen:
1. Deaktivieren Sie zunächst Multi-AZ für die DB-Instance.
1. Ändern Sie den Datenbanknamen, indem Sie den Befehl ausführe `rdsadmin.dbo.rds_modify_db_name`.
1. Aktivieren Sie anschließend die Multi-AZ-Spiegelung oder AlwaysOn-Verfügbarkeitsgruppen für die DB-Instance, um den Ausgangszustand wiederherzustellen.
Weitere Informationen finden Sie unter [Hinzufügen von Multi-AZ zu einer Microsoft SQL Server-DB-Instance](USER_SQLServerMultiAZ.md#USER_SQLServerMultiAZ.Adding).
**Anmerkung**
Falls Ihre Instance keine Multi-AZ verwendet, müssen vor oder nach dem Ausführen von keinerlei Einstellungen geändert werde `rdsadmin.dbo.rds_modify_db_name`.
Sie können eine Datenbank auf einer Read-Replica-Quell-Instance nicht umbenennen.
**Beispiel: **Im folgenden Beispiel wird mithilfe der gespeicherten Prozedur `rdsadmin.dbo.rds_modify_db_name` die Datenbank **MOO** umbenannt in **ZAR**. Dies entspricht der ausgeführten Anweisung `DDL ALTER DATABASE [MOO] MODIFY NAME = [ZAR]`.
```
EXEC rdsadmin.dbo.rds_modify_db_name N'MOO', N'ZAR'
GO
```
# Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server
Wenn Sie Ihren Master-Benutzer von der `db_owner`-Rollenmitgliedschaft in Ihrer Datenbank für RDS für SQL Server ausschließen und kein anderer Datenbankbenutzer die Mitgliedschaft gewähren kann, können Sie die verloren gegangene Mitgliedschaft wiederherstellen, indem Sie das Master-Benutzerkennwort der DB-Instance ändern.
Durch die Änderung des Master-Benutzerpassworts der DB-Instance gewährt RDS den Datenbanken in der DB-Instance die `db_owner`-Mitgliedschaft, die möglicherweise versehentlich gesperrt wurde. Sie können das DB-Instance-Passwort ändern, indem Sie die Amazon RDS-Konsole, den AWS CLI Befehl [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)oder den Vorgang „DBInstanceAPI [modifizieren](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)“ verwenden. Weitere Informationen zum Ändern einer DB-Instance finden Sie unter [Ändern einer Amazon-RDS-DB-Instance](Overview.DBInstance.Modifying.md).
# Wiederherstellen von DB-Instances für Amazon RDS für SQL Server, die aus Lizenzgründen beendet wurden
Microsoft hat Amazon-RDS-Kunden, die ihre Microsoft-License-Mobility-Informationen nicht gemeldet haben, aufgefordert, ihre DB-Instance zu beenden. Amazon RDS erstellt Schnappschüsse dieser DB-Instances und diese lassen sich in eine neue DB-Instance mit dem Modell „Lizenz enthalten“ wiederherstellen.
Sie können aus einem Snapshot der Standard Edition die Standard Edition oder Enterprise Edition wiederherstellen.
Sie können aus einem Snapshot der Enterprise Edition die Standard Edition oder Enterprise Edition wiederherstellen.
**Für eine Wiederherstellung aus einem SQL Server-Snapshot, nachdem Amazon RDS einen abschließenden Snapshot Ihrer Instance erstellt hat**
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 Snapshot Ihrer SQL-Server-DB-Instance aus. Amazon RDS erstellt einen endgültigen Snapshot Ihrer DB-Instance. Der Name des beendeten Instance-Snapshots weist das Format au `instance_name-final-snapshot`. Wenn Ihr DB-Instance-Name beispielsweise lautet**mytest.cdxgahslksma.us-east-1.rds.com**, wird der endgültige Snapshot aufgerufen ** mytest-final-snapshot** und befindet sich in derselben AWS Region wie die ursprüngliche DB-Instance.
1. Wählen Sie unter **Actions (Aktionen)** die Option **Restore Snapshot (Snapshot wiederherstellen)**.
Das Fenster **Restore DB Instance (DB-Instance wiederherstellen)** wird angezeigt.
1. Für **License Model (Lizenzmodell)** wählen Sie **license-included (Lizenz enthalten)** aus.
1. Wählen Sie die SQL Server-DB-Engine, die Sie verwenden möchten.
1. Geben Sie für **DB Instance Identifier (DB-Instance-Kennung)** den Namen Ihrer wiederhergestellten DB-Instance ein.
1. Klicken Sie auf **Restore DB Instance** (DB-Instance wiederherstellen).
Weitere Informationen zum Wiederherstellen aus einem Snapshot finden Sie unter [Wiederherstellen auf eine DB-Instance](USER_RestoreFromSnapshot.md).
# Übergang einer Server-Datenbank in Amazon RDS für SQL von OFFLINE zu ONLINE
Der Übergang Ihrer Microsoft SQL Server-Datenbank in einer Amazon-RDS-DB-Instance von `OFFLINE` zu `ONLINE` ist möglich.
****
| SQL Server-Methode | Amazon-RDS-Methode |
| --- | --- |
| ONLINE *db\$1name* EINGESTELLTE DATENBANK ÄNDERN; | EXEC rdsadmin.dbo.rds\$1set\$1database\$1online *db\$1name* |
# Verwenden von Change Data Capture für Amazon RDS für SQL Server
Amazon RDS unterstützt auch die Erfassung von Datenänderungen (Change Data Capture, CDC) für Ihre DB-Instances, die auf Microsoft SQL Server laufen. CDC erfasst Änderungen an Daten in Ihren Tabellen. Es speichert Metadaten über jede Änderung, auf die Sie später zugreifen können. Weitere Informationen über die Arbeitsweise von CDC finden Sie unter [Change Data Capture](https://docs.microsoft.com/en-us/sql/relational-databases/track-changes/track-data-changes-sql-server#Capture) in der Microsoft-Dokumentation. Bevor Sie CDC für Ihre Amazon-RDS-DB-Instances verwenden, aktivieren Sie es in der Datenbank, indem Sie `msdb.dbo.rds_cdc_enable_db` ausführen. Nachdem CDC aktiviert wurde, kann jeder Benutzer, der `db_owner` dieser Datenbank ist, CDC für Tabellen in dieser Datenbank aktivieren oder deaktivieren.
**Wichtig**
Während einer Wiederherstellung wird CDC deaktiviert. Alle zugehörigen Metadaten werden automatisch aus der Datenbank entfernt. Dies gilt für Snapshot-Wiederherstellungen und point-in-time Wiederherstellungen. Nachdem Sie eine dieser Wiederherstellungsarten durchgeführt haben, können Sie CDC wieder aktivieren und nachzuverfolgende Tabellen neu festlegen.
Um CDC für eine DB-Instance zu aktivieren, führen Sie die gespeicherte `msdb.dbo.rds_cdc_enable_db`-Prozedur aus.
```
1. exec msdb.dbo.rds_cdc_enable_db 'database_name'
```
Um CDC für eine DB-Instance zu deaktivieren, führen Sie die gespeicherte `msdb.dbo.rds_cdc_disable_db`-Prozedur aus.
```
1. exec msdb.dbo.rds_cdc_disable_db 'database_name'
```
Um einem Benutzer CDC-Berechtigungen zu erteilen, gehen Sie wie folgt vor:
```
1. go
2. GRANT EXECUTE ON msdb.dbo.rds_cdc_enable_db TO User1
3. GRANT EXECUTE ON msdb.dbo.rds_cdc_disable_db TO User1
```
**Topics**
+ [
## Nachverfolgen von Tabellen mit Change Data Capture
](#Appendix.SQLServer.CommonDBATasks.CDC.tables)
+ [
## Change Data Capture-Aufträge
](#Appendix.SQLServer.CommonDBATasks.CDC.jobs)
+ [
## Change Data Capture für Multi-AZ-Instances
](#Appendix.SQLServer.CommonDBATasks.CDC.Multi-AZ)
## Nachverfolgen von Tabellen mit Change Data Capture
Nachdem CDC für die Datenbank aktiviert wurde, können Sie mit der Nachverfolgung spezifischer Tabellen beginnen. Sie wählen die nachzuverfolgenden Tabellen durch Ausführen von [sys.sp\$1cdc\$1enable\$1table](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-enable-table-transact-sql).
```
1. --Begin tracking a table
2. exec sys.sp_cdc_enable_table
3. @source_schema = N'source_schema'
4. , @source_name = N'source_name'
5. , @role_name = N'role_name'
6.
7. --The following parameters are optional:
8.
9. --, @capture_instance = 'capture_instance'
10. --, @supports_net_changes = supports_net_changes
11. --, @index_name = 'index_name'
12. --, @captured_column_list = 'captured_column_list'
13. --, @filegroup_name = 'filegroup_name'
14. --, @allow_partition_switch = 'allow_partition_switch'
15. ;
```
Um die CDC-Konfiguration für Ihre Tabellen anzuzeigen, führen Sie [sys.sp\$1cdc\$1help\$1change\$1data\$1capture](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-help-change-data-capture-transact-sql) aus.
```
1. --View CDC configuration
2. exec sys.sp_cdc_help_change_data_capture
3.
4. --The following parameters are optional and must be used together.
5. -- 'schema_name', 'table_name'
6. ;
```
Weitere Informationen zu CDC-Tabellen, Funktionen und gespeicherten Prozeduren in der SQL Server-Dokumentation finden Sie im Folgenden:
+ [Change Data Capture – gespeicherte Prozeduren (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/change-data-capture-stored-procedures-transact-sql)
+ [Change Data Capture – Funktionen (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-functions/change-data-capture-functions-transact-sql)
+ [Change Data Capture – Tabellen (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-tables/change-data-capture-tables-transact-sql)
## Change Data Capture-Aufträge
Wenn Sie CDC aktivieren, erstellt SQL Server die CDC-Aufträge. Datenbankbesitzer (`db_owner`) können die CDC-Aufträge anzeigen, erstellen, ändern und löschen. Sie gehören jedoch dem RDS-Systemkonto. Aus diesem Grund sind die Aufträge in nativen Ansichten, Prozeduren oder in SQL Server Management Studio nicht sichtbar.
Für die Kontrolle des Verhaltens von CDC in einer Datenbank verwenden Sie native SQL Server-Prozeduren wie [sp\$1cdc\$1enable\$1table](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-enable-table-transact-sql) und [sp\$1cdc\$1start\$1job](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-start-job-transact-sql). Für die Änderung der Parameter von CDC-Aufträgen wie `maxtrans` und `maxscans` verwenden Sie [sp\$1cdc\$1change\$1job](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-change-job-transact-sql).
Um weitere Informationen zu den CDC-Aufträgen zu erhalten, können Sie die folgenden dynamischen Verwaltungsansichten abfragen:
+ sys.dm\$1cdc\$1errors
+ sys.dm\$1cdc\$1log\$1scan\$1sessions
+ sysjobs
+ sysjobhistory
## Change Data Capture für Multi-AZ-Instances
Wenn Sie CDC für eine Multi-AZ-Instance verwenden, vergewissern Sie sich, dass die CDC-Auftragskonfiguration der Spiegelung mit derjenigen auf dem Prinzipal übereinstimmt. CDC-Aufträge werden auf die abgebilde `database_id`. Wenn sich die Datenbank IDs auf der Sekundärseite vom Prinzipal unterscheidet, werden die Jobs nicht der richtigen Datenbank zugeordnet. Um Fehler nach dem Failover zu vermeiden, verwirft RDS die Aufträge auf dem neuen Prinzipal und erstellt sie neu. Die neu erstellten Aufträge verwenden die Parameter, die der Prinzipal vor dem Failover aufgezeichnet hat.
Obwohl dieser Prozess schnell abläuft, ist es immer noch möglich, dass die CDC-Aufträge ausgeführt werden, bevor RDS sie korrigieren kann. Hier gibt es drei Möglichkeiten zum Erzwingen der Konsistenz der Parameter von primären und sekundären Replicas:
+ Verwenden Sie die gleichen Auftragsparameter für alle Datenbanken, die CDC aktiviert haben.
+ Bevor Sie die CDC-Auftragskonfiguration ändern, konvertieren Sie die Multi-AZ-Instance zu Single-AZ.
+ Übertragen Sie die Parameter manuell, wenn Sie sie auf dem Prinzipal ändern.
Um die CDC-Parameter anzuzeigen und zu definieren, mit denen die CDC-Aufträge nach einem Failover neu erstellt werden, verwenden Sie `rds_show_configuration` und `rds_set_configuration`.
Im folgenden Beispiel wird der Wert für zurückgegebe `cdc_capture_maxtrans`. Für alle Parameter, die auf `RDS_DEFAULT` gesetzt sind, konfiguriert RDS den Wert automatisch.
```
-- Show configuration for each parameter on either primary and secondary replicas.
exec rdsadmin.dbo.rds_show_configuration 'cdc_capture_maxtrans';
```
Um die Konfiguration auf dem sekundären Server einzurichten, führen Sie au `rdsadmin.dbo.rds_set_configuration`. Dieses Verfahren legt die Parameterwerte für alle Datenbanken auf dem sekundären Server fest. Diese Einstellungen werden nur nach einem Failover verwendet. Im folgenden Beispiel wird `maxtrans` für alle CDC-Erfassungsaufträge der Wert wie folgt festgelegt: *1000*
```
--To set values on secondary. These are used after failover.
exec rdsadmin.dbo.rds_set_configuration 'cdc_capture_maxtrans', 1000;
```
Um die CDC-Auftragsparameter auf dem Prinzipal festzulegen, verwenden Sie stattdessen [sys.sp\$1cdc\$1change\$1job](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-change-job-transact-sql).
# Verwenden von SQL Server Agent für Amazon RDS
Mit Amazon RDS können Sie SQL Server Agent in einer DB-Instance verwenden, in der Microsoft SQL Enterprise Edition, Standard Edition oder Web Edition ausgeführt wird. SQL Server Agent ist ein Service von Microsoft Windows für die Ausführung geplanter administrativer Aufgaben, so genannte Jobs. Sie können SQL Server Agent für die Ausführung von T-SQL-Jobs für den erneuten Aufbau von Indizes, die Ausführung von Beschädigungsprüfungen und für die Zusammenfassung von Daten in einer SQL Server-DB-Instance verwenden.
Wenn Sie eine SQL-Server-DB-Instance erstellen, wird der Hauptbenutzer mit der Rolle `SQLAgentUserRole` registriert.
SQL Server Agent kann einen Job nach Plan, als Antwort auf ein bestimmtes Ereignis oder auf Abruf ausführen. Weitere Informationen finden Sie unter [SQL Server Agent](http://msdn.microsoft.com/en-us/library/ms189237) in der Microsoft-Dokumentation.
**Anmerkung**
Vermeiden Sie es, Jobs zu planen, die während der Wartungs- und Backup-zeitfenster für Ihre DB-Instance ausgeführt werden. Die Wartungs- und Backup-Prozesse, die von AWS gestartet werden, könnten einen Job unterbrechen oder dazu führen, dass er abgebrochen wird.
In Multi-AZ-Bereitstellungen werden Aufträge von SQL Server Agent vom primären Host auf den sekundären Host repliziert, wenn die Auftragsreplikationsfunktion aktiviert ist. Weitere Informationen finden Sie unter [Aktivieren der Auftragsreplikation von SQL Server Agent](#SQLServerAgent.Replicate).
Multi-AZ-Bereitstellungen haben ein Limit von 10 000 SQL-Server-Agent-Aufträgen. Wenn Sie ein höheres Limit benötigen, können Sie Support kontaktieren, um eine Erhöhung anzufordern. Öffnen Sie die Seite des [AWS Support-Centers](https://console.aws.amazon.com/support/home#/), melden Sie sich an und wählen Sie **Fall erstellen** aus. Wählen Sie **Service Limit increase (Erhöhung des Servicelimits)**. Füllen Sie das Formular aus und senden Sie es ab.
Um den Verlauf eines einzelnen SQL Server Agent-Auftrags in SQL Server Management Studio (SSMS) anzuzeigen, öffnen Sie den Objektexplorer, klicken mit der rechten Maustaste auf den Auftrag und wählen dann **View History (Verlauf anzeigen)**.
Da der SQL Server-Agent auf einem verwalteten Host in einer DB-Instance ausgeführt wird, werden einige Aktionen nicht unterstützt:
+ Die Ausführung von Replikationsjobs und die Ausführung der Befehlszeilen-Skripts mithilfe von ActiveX, Windows Command-Shell oder Windows PowerShell werden nicht unterstützt.
+ Sie können SQL Server-Agent nicht manuell starten, stoppen oder neu starten.
+ E-Mail-Benachrichtigungen über SQL Server Agent sind von einer DB-Instance aus nicht verfügbar.
+ Warnungen und Operatoren von SQL Server-Agenten werden nicht unterstützt.
+ Die Verwendung von SQL Server-Agent zum Erstellen von Backups wird nicht unterstützt. Verwenden Sie Amazon RDS, um Ihre DB-Instance zu sichern.
+ Derzeit unterstützt RDS für SQL Server die Verwendung von SQL-Server-Agent-Tokens nicht.
## Aktivieren der Auftragsreplikation von SQL Server Agent
Sie können die Auftragsreplikation von SQL Server Agent mithilfe der folgenden gespeicherten Prozedur aktivieren:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'SQLAgentJob';
```
Sie können die gespeicherte Prozedur in allen SQL-Server-Versionen ausführen, die von Amazon RDS für SQL Server unterstützt werden. Es werden Aufträge in den folgenden Kategorien repliziert:
+ [Uncategorized (Local)]
+ [Uncategorized (Multi-Server)]
+ [Uncategorized]
+ Datenauflister
+ Database Engine Tuning Advisor
+ Datenbankwartung
+ Volltext
Es werden nur Aufträge, die T-SQL-Auftragsschritte verwenden, repliziert. Aufträge mit Schritttypen wie SQL Server Integration Services (SSIS), SQL Server Reporting Services (SSRS), Replikation und PowerShell werden nicht repliziert. Aufträge, die Datenbank-E-Mail und Objekte auf Serverebene verwenden, werden nicht repliziert.
**Wichtig**
Der primäre Host ist die Informationsquelle für die Replikation. Stellen Sie vor dem Aktivieren der Auftragsreplikation sicher, dass sich Ihre SQL-Server-Agent-Aufträge auf dem primären Host befinden. Andernfalls werden Ihre SQL-Server-Agent-Aufträge ggf. gelöscht, wenn Sie die Funktion aktivieren und sich neuere Aufträge auf dem sekundären Host befinden.
Sie können die folgende Funktion verwenden, um zu überprüfen, ob die Replikation aktiviert ist.
```
SELECT * from msdb.dbo.rds_fn_get_system_database_sync_objects();
```
Die T-SQL-Abfrage gibt Folgendes zurück, wenn die Aufträge von SQL Server Agent repliziert werden. Wenn sie nicht repliziert werden, wird für `object_class` kein Wert zurückgegeben.
![\[Aufträge von SQL Server Agent werden repliziert.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQLAgentJob.png)
Sie können die folgende Funktion verwenden, um zu ermitteln, wann Objekte zuletzt synchronisiert (UTC) wurden.
```
SELECT * from msdb.dbo.rds_fn_server_object_last_sync_time();
```
Angenommen, Sie ändern einen Auftrag von SQL Server Agent um 01:00 Uhr. Sie erwarten, dass die letzte Synchronisationszeit nach 01:00 Uhr liegt, was darauf hinweist, dass die Synchronisation stattgefunden hat.
Nach der Synchronisation wird erwartet, dass die für `date_created` und `date_modified` auf dem sekundären Knoten zurückgegebenen Werte übereinstimmen.
![\[Serverobjekte wurden zuletzt um 01:21:23 Uhr synchronisiert.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQLAgentJob_last_sync_time.png)
Wenn Sie auch die Replikation von `tempdb` verwenden, können Sie die Replikation sowohl für SQL-Agent-Aufträge als auch für die `tempdb`-Konfiguration aktivieren, indem Sie sie im Parameter `@object_type` angeben:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'SQLAgentJob,TempDbFile';
```
Weitere Informationen über die `tempdb`-Replikation finden Sie unter [TempDB-Konfiguration für Multi-AZ-Bereitstellungen](SQLServer.TempDB.MAZ.md).
# Rollen von SQL Server Agent
RDS für SQL Server unterstützt die folgenden Rollen von SQL Server Agent mit unterschiedlichen Berechtigungsebenen für die Verwaltung von Aufgaben:
+ **SQLAgentUserRole**
Berechtigungen
+ Eigene Aufträge, Zeitpläne und Operatoren erstellen und verwalten
+ Eigenschaften ihrer eigenen Aufträge und Zeitpläne anzeigen
+ Aufträge, die von anderen Benutzern erstellt wurden, können nicht angezeigt oder verwaltet werden
Diese Rolle eignet sich für Benutzer, die ihre eigenen Aufträge erstellen und verwalten müssen, aber keinen Zugriff auf Aufträge benötigen, die von anderen Benutzern erstellt wurden.
+ **SQLAgentReaderRole**
Berechtigungen
+ Alle Berechtigungen der SQLAgentUserRole
+ Liste aller Aufträge und Zeitpläne anzeigen, einschließlich derer, die von anderen erstellt wurden
+ Eigenschaften aller Aufträge anzeigen
+ Auftragshistorie einsehen
Diese Rolle eignet sich für Benutzer, die den Status aller Aufträge überwachen, diese aber nicht verwalten müssen.
+ **SQLAgentOperatorRole**
Berechtigungen
+ Alle Berechtigungen der SQLAgentUserRole und SQLAgentReaderRole
+ Aufträge ausführen, anhalten oder starten
+ Auftragshistorie verwalten
+ Aufträge und Zeitpläne aktivieren/deaktivieren
+ Operatoren und Proxys anzeigen
Diese Rolle bietet die umfassendsten Berechtigungen und eignet sich für Benutzer, die die volle Kontrolle über alle Aufträge haben müssen.
Verwenden Sie den folgenden Befehl, um Ihrem SQL-Server-Anmeldenamen die Rollen zuzuweisen:
```
USE msdb;
EXEC sp_addrolemember 'SQLAgentOperatorRole', 'username';
```
## Verwalten der SQLAgentOperatorRole in RDS für SQL Server
Um die aktuellen Aufträge anzuzeigen, müssen Sie Ihrem SQL-Server-Anmeldenamen die Rolle SQLAgentOperatorRole hinzufügen und sie entfernen, bevor Sie die Verbindung zu Ihrer Datenbank trennen.
Gehen Sie wie folgt vor, um die Struktur von SQL Server Agent in SQL Server Management Studio zu visualisieren:
**Anzeigen von SQL Server Agent in SQL Server Management Studio (SSMS)**
1. Melden Sie sich mit den RDS-Hauptanmeldeinformationen bei der Instance von RDS SQL Server an und weisen Sie dem gewünschten Benutzer die SQLAgentUserRole zu.
```
USE msdb
GO
IF NOT EXISTS(SELECT name FROM sys.database_principals WHERE name = 'UserName')
BEGIN
CREATE USER UserName FROM LOGIN UserName
END
GO
ALTER ROLE SQLAgentUserRole ADD MEMBER UserName
GO
GRANT ALTER ON ROLE::[SQLAgentOperatorRole] to UserName
GO
```
Mit diesen Befehlen wird der Benutzer in der `msdb`-Datenbank erstellt, falls er nicht existiert. Außerdem wird der Benutzer zur SQLAgentUserRole hinzugefügt, sodass die Struktur von SQL Server Agent in SSMS sichtbar ist. Darüber hinaus werden dem Benutzer Änderungsberechtigungen für die SQLAgentOperatorRole gewährt. Auf diese Weise kann der Benutzer sich selbst zu dieser Rolle hinzufügen oder daraus entfernen.
1. Um sich selbst zu der oben genannten Rolle hinzuzufügen, stellen Sie mit dem Benutzer, der die Aufträge sehen muss, eine Verbindung zur Instance von RDS SQL Server her und führen Sie das folgende Skript aus.
```
use msdb
go
ALTER ROLE SQLAgentOperatorRole ADD MEMBER UserName
GO
```
Danach klicken Sie mit der rechten Maustaste auf den Ordner **Aufträge** und wählen Sie **Aktualisieren**.
1. Wenn Sie diese Aktion ausführen, wird auf der Registerkarte **Aufträge** eine Schaltfläche mit einem Pluszeichen (**\$1**) angezeigt. Klicken Sie darauf, um die Liste der Aufträge für SQL Server Agent zu erweitern.
1.
**Wichtig**
Bevor Sie die Verbindung zur Instance von RDS SQL Server trennen, müssen Sie sich selbst aus der SQLAgentOperatorRole entfernen.
Um Ihren Anmeldenamen aus der SQLAgentOperatorRole zu entfernen, führen Sie die folgende Abfrage aus, bevor Sie Management Studio trennen oder schließen:
```
USE msdb
GO
ALTER ROLE SQLAgentOperatorRole DROP MEMBER UserName
GO
```
Weitere Informationen finden Sie unter [Leveraging SQLAgentOperatorRole in RDS SQL Server](https://aws.amazon.com/blogs/database/leveraging-sqlagentoperatorrole-in-rds-sql-server/).
# Hinzufügen eines Benutzers zur Rolle SQLAgentUser
Damit eine zusätzliche Anmeldung oder ein zusätzlicher Benutzer SQL Server Agent verwenden kann, müssen Sie sich als Hauptbenutzer anmelden und wie folgt vorgehen:
1. Erstellen Sie mithilfe des Befehls `CREATE LOGIN` eine weitere Anmeldung auf Serverebene.
1. Erstellen Sie mithilfe des Befehls `msdb` einen Benutzer in `CREATE USER` und verknüpfen Sie dann diesen Benutzer mit der Anmeldung, die Sie im vorherigen Schritt erstellt haben.
1. Fügen Sie den Benutzer`SQLAgentUserRole` mit der gespeicherten Systemprozedur `sp_addrolemember` hinzu.
Nehmen wir beispielsweise an, Ihr Hauptbenutzername lautet **admin** und Sie möchten einem Benutzer mit dem Namen **theirname** und dem Passwort **theirpassword** den Zugriff auf SQL Server Agent erlauben. In diesem Fall können Sie das folgende Verfahren verwenden.
**So fügen Sie zur Rolle SQLAgentUser einen Benutzer hinzu**
1. Melden Sie sich als Hauptbenutzer an.
1. Führen Sie die folgenden Befehle aus:
```
--Initially set context to master database
USE [master];
GO
--Create a server-level login named theirname with password theirpassword
CREATE LOGIN [theirname] WITH PASSWORD = 'theirpassword';
GO
--Set context to msdb database
USE [msdb];
GO
--Create a database user named theirname and link it to server-level login theirname
CREATE USER [theirname] FOR LOGIN [theirname];
GO
--Added database user theirname in msdb to SQLAgentUserRole in msdb
EXEC sp_addrolemember [SQLAgentUserRole], [theirname];
```
# Löschen eines SQL Server-Agent-Jobs
Sie verwenden die gespeicherte Prozedur `sp_delete_job`, um SQL Server-Agent-Jobs auf Amazon RDS für Microsoft SQL Server zu löschen.
Sie können SSMS nicht verwenden, um SQL Server-Agent-Jobs zu löschen. Falls Sie dies versuchen, erhalten Sie eine Fehlermeldung ähnlich der folgenden:
```
The EXECUTE permission was denied on the object 'xp_regread', database 'mssqlsystemresource', schema 'sys'.
```
Als verwalteter Service ist RDS von der Ausführung von Prozeduren ausgeschlossen, die auf die Windows-Registrierung zugreifen. Wenn Sie SSMS verwenden, versucht es, einen Prozess (`xp_regread`) auszuführen, für den RDS nicht autorisiert ist.
**Anmerkung**
Bei RDS für SQL Server dürfen nur Mitglieder der sysadmin-Rolle Jobs aktualisieren oder löschen, die einem anderen Anmeldenamen gehören. Weitere Informationen finden Sie unter [Leveraging SQLAgentOperatorRole in RDS SQL Server](https://aws.amazon.com/blogs/database/leveraging-sqlagentoperatorrole-in-rds-sql-server/).
**So löschen Sie einen SQL Server-Agent-Job**
+ Führen Sie die folgende T-SQL-Anweisung aus:
```
EXEC msdb..sp_delete_job @job_name = 'job_name';
```
# Arbeiten mit Microsoft-SQL-Server-Protokollen
Sie können die SQL-Server-Agent-Protokolle, Microsoft-SQL-Server-Fehlerprotokolle und SQL Server Reporting Services (SSRS)-Protokolle mit der Amazon-RDS-Konsole anzeigen, beobachten und herunterladen.
## Beobachten von Protokolldateien
Wenn Sie in der Amazon-RDS-Konsole ein Protokoll anzeigen, entsprechen dessen Inhalte diesem Moment. Das Beobachten eines Protokolls in der Konsole öffnet es in einem dynamischen Status, so dass die Aktualisierungen nahezu in Echtzeit angezeigt werden.
Lediglich das aktuelle Protokoll ist zur Beobachtung aktiv. Nehmen wir an, es werden die folgenden Protokolle angezeigt:
![\[Ein Bild des Abschnitts „Protokolle“ aus der Amazon-RDS-Konsole mit einem ausgewählten Fehlerprotokoll.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/logs_sqlserver.png)
Nur Protokoll/FEHLER, da das aktuelle Protokoll aktiv aktualisiert wird. Sie können auch andere beobachten, aber diese sind statisch und werden nicht aktualisiert.
## Archivieren von Protokolldateien
In der Amazon-RDS-Konsole werden die Protokolle für die letzte Woche bis zum heutigen Tag angezeigt. Die Protokolle können zur Referenzzwecken für einen späteren Zeitpunkt heruntergeladen und archiviert werden. Eine Möglichkeit, Protokolle zu archivieren, besteht darin, sie in einen Amazon S3-Bucket zu laden. Anweisungen zum Einrichten eines Amazon S3-Buckets und zum Hochladen einer Datei finden Sie unter [Amazon S3-Grundlagen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AmazonS3Basics.html) im *Handbuch "Erste Schritte" zu Amazon Simple Storage Service* unter **Erste Schritte**.
## Anzeigen von Fehler- und Agent-Protokollen
Um Microsoft SQL Server-Fehler- und Agent-Protokolle anzuzeigen, verwenden Sie die in Amazon RDS gespeicherte Prozedur `rds_read_error_log` mit den folgenden Parametern:
+ **`@index`** – die Version des abzurufenden Protokolls. Der Standardwert ist 0, der das aktuelle Fehlerprotokoll abruft. Legen Sie 1 fest, um das vorherige Protokoll abzurufen, legen Sie 2 fest, um das Protokoll davor abzurufen usw.
+ **`@type`** – die Art des abzurufenden Protokolls. Legen Sie 1 fest, um ein Fehlerprotokoll abzurufen. Legen Sie 2 fest, um ein Agent-Protokoll abzurufen.
**Example**
Das folgende Beispiel fordert das aktuelle Fehlerprotokoll an.
```
EXEC rdsadmin.dbo.rds_read_error_log @index = 0, @type = 1;
```
Weitere Informationen zu SQL Server-Fehlern finden Sie unter [Fehler der Datenbank-Engine](https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/database-engine-events-and-errors) in der Microsoft-Dokumentation.
# Arbeiten mit Trace- und Dump-Dateien für Amazon RDS für SQL Server
Dieser Abschnitt beschreibt das Arbeiten mit Trace- und Dump-Dateien für Ihre Amazon-RDS-DB-Instances, auf denen Microsoft SQL Server ausgeführt wird.
## Generieren einer Trace-SQL-Abfrage
```
1. declare @rc int
2. declare @TraceID int
3. declare @maxfilesize bigint
4.
5. set @maxfilesize = 5
6.
7. exec @rc = sp_trace_create @TraceID output, 0, N'D:\rdsdbdata\log\rdstest', @maxfilesize, NULL
```
## Anzeigen eines offenen Trace
```
1. select * from ::fn_trace_getinfo(default)
```
## Anzeigen der Trace-Inhalte
```
1. select * from ::fn_trace_gettable('D:\rdsdbdata\log\rdstest.trc', default)
```
## Festlegen des Aufbewahrungszeitraums für Trace- und Dump-Dateien
Trace- und Dump-Dateien können sich ansammeln und viel Festplattenspeicher belegen. Amazon RDS löscht automatisch Trace-und Dump-Dateien, die älter als sieben Tage sind.
Um den aktuellen Aufbewahrungszeitraum für Trace- und Dump-Dateien anzuzeigen, verwenden Sie die Prozedur `rds_show_configuration`, wie im folgenden Beispiel zu sehen ist.
```
1. exec rdsadmin..rds_show_configuration;
```
Um den Aufbewahrungszeitraum für Trace-Dateien zu ändern, verwenden Sie die Prozedur `rds_set_configuration` und legen `tracefile retention` in Minuten fest. Beim folgenden Beispiel wird der Aufbewahrungszeitraum für Trace-Dateien auf 24 Stunden festgelegt:
```
1. exec rdsadmin..rds_set_configuration 'tracefile retention', 1440;
```
Um den Aufbewahrungszeitraum für Dump-Dateien zu ändern, verwenden Sie die Prozedur `rds_set_configuration` und legen `dumpfile retention` in Minuten fest. Beim folgenden Beispiel wird der Aufbewahrungszeitraum für Dump-Dateien auf 3 Tage festgelegt:
```
1. exec rdsadmin..rds_set_configuration 'dumpfile retention', 4320;
```
Aus Sicherheitsgründen kann eine bestimmte Trace- oder Dump-Datei in einer SQL Server-DB-Instance nicht von Ihnen gelöscht werden. Damit alle ungenutzten Trace- oder Dump-Dateien gelöscht werden, legen sie den Aufbewahrungszeitraum für die Dateien auf 0 fest.