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. # 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 | | --- | --- | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3  
	@db_name = 'testdb1',
            @backup_file_start_time='2022-08-23 00:00:00',
            @backup_file_end_time='2022-08-30 00:00:00';
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
           @db_name = 'testdb1',
           @backup_file_start_time='2022-08-23 00:00:00';
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
          @db_name = 'testdb1',
          @backup_file_end_time='2022-08-30 00:00:00';
| 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'. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
         @db_name='testdb1',
         @starting_lsn =1490000000040007,
         @ending_lsn =  1490000000050009;
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
        @db_name='testdb1',
        @starting_lsn =1490000000040007;
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
        @db_name='testdb1',
        @ending_lsn  =1490000000050009;
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
       @db_name='testdb1',
       @rds_backup_starting_seq_id= 2000,
       @rds_backup_ending_seq_id= 5000;
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
       @db_name='testdb1',
       @rds_backup_starting_seq_id= 2000;
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
      @db_name='testdb1',
      @rds_backup_ending_seq_id= 5000;
| 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. | | 
exec msdb.dbo.rds_tlog_backup_copy_to_S3
      @db_name='testdb1',
      @rds_backup_starting_seq_id= 2000;
      @rds_backup_ending_seq_id= 2000;
| 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). |