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.
# Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung
Amazon RDS unterstützt native Backups und Wiederherstellungen für Microsoft SQL Server-Datenbanken unter Verwendung von vollständigen Sicherungsdateien (.bak-Dateien). Bei RDS greifen Sie auf in Amazon S3 gespeicherte Daten zu, anstatt das lokale Datensystem des Datenbankservers zu nutzen.
Beispielsweise können Sie auf Ihrem lokalen Server ein vollständiges Backup erstellen, dieses in S3 speichern und anschließend in einer verfügbaren Amazon-RDS-DB-Instance wiederherstellen. Ebenso können Sie über RDS Backups erstellen, in S3 speichern und dann dort wiederherstellen, wo Sie dies möchten.
Native Sicherung und Wiederherstellung sind in allen AWS Regionen für Single-AZ- und Multi-AZ-DB-Instances verfügbar, einschließlich Multi-AZ-DB-Instances mit Read Replicas. Native Backups und Wiederherstellungen sind für alle in Amazon RDS unterstützten Versionen von Microsoft SQL Server verfügbar.
Das folgende Diagramm veranschaulicht die unterstützten Szenarien.
![\[Architektur für native Backups und Wiederherstellungen\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/SQL-bak-file.png)
Die Verwendung nativer .bak-Dateien ist i. d. R. die schnellste Methode zum Sichern und Wiederherstellen von Datenbanken. Es gibt viele zusätzliche Vorteile bei der Verwendung nativer Backups und Wiederherstellungen. Sie können z. B. Folgendes tun:
+ Migrieren von Datenbanken zu oder aus Amazon RDS
+ Verschieben von Datenbanken zwischen RDS für SQL Server DB-Instances
+ Migrieren von Daten, Schemata, gespeicherten Prozeduren, Auslösern und anderem Datenbankcode in .bak-Dateien.
+ Einzelne Datenbanken anstelle von ganzen DB-Instances sichern und wiederherstellen
+ Erstellen Sie Kopien von Datenbanken zu Entwicklungs-, Test-, Trainings- und Demozwecken.
+ Speichern und übertragen Sie Sicherungsdateien mit Amazon S3, um zusätzlichen Schutz für die Notfallwiederherstellung zu gewährleisten.
+ Erstellen Sie native Backups von Datenbanken mit aktivierter TDE (Transparent Data Encryption) und stellen Sie diese Backups in lokalen Datenbanken wieder her. Weitere Informationen finden Sie unter [Unterstützung für transparente Datenverschlüsselung in SQL Server](Appendix.SQLServer.Options.TDE.md).
+ Stellen Sie native Backups von lokalen Datenbanken, deren TDE-Verschlüsselung aktiviert ist, auf DB-Instances von RDS für SQL Server wieder her. Weitere Informationen finden Sie unter [Unterstützung für transparente Datenverschlüsselung in SQL Server](Appendix.SQLServer.Options.TDE.md).
**Contents**
+ [
## Einschränkungen und Empfehlungen
](#SQLServer.Procedural.Importing.Native.Limitations)
+ [
# Einrichtung für native Backups und Wiederherstellungen
](SQLServer.Procedural.Importing.Native.Enabling.md)
+ [
## Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen
](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [
# Verwenden nativer Backups und Wiederherstellungen
](SQLServer.Procedural.Importing.Native.Using.md)
+ [
## Sichern einer Datenbank
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Examples)
+ [
## Wiederherstellen einer Datenbank
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Examples)
+ [
## Wiederherstellen eines Protokolls
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Examples)
+ [
## Abschluss einer Datenbankwiederherstellung
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore.Syntax)
+ [
## Arbeiten mit teilweise wiederhergestellten Datenbanken
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [
### Verwerfen einer teilweise wiederhergestellten Datenbank
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Drop.Partially.Restored)
+ [
### Snapshot-Wiederherstellung und point-in-time Wiederherstellungsverhalten für teilweise wiederhergestellte Datenbanken
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Snapshot.Restore)
+ [
## Abbrechen einer Aufgabe
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Cancel.Syntax)
+ [
## Verfolgen des Status von Aufgaben
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking)
+ [
### Usage
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Syntax)
+ [
### Beispiele
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Examples)
+ [
### Antwort
](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Response)
+ [
# Komprimieren von Sicherungsdateien
](SQLServer.Procedural.Importing.Native.Compression.md)
+ [
# Fehlerbehebung
](SQLServer.Procedural.Importing.Native.Troubleshooting.md)
+ [
# Importieren und Exportieren von SQL Server-Daten mithilfe anderer Methoden
](SQLServer.Procedural.Importing.Snapshots.md)
+ [
## Importieren von Daten in RDS für SQL Server mithilfe eines Snapshots
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Importing.Procedure)
+ [
### Importieren der Daten
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.Import)
+ [
#### Assistent für das Generieren und Veröffentlichen von Skripts
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ScriptWizard)
+ [
#### Assistent für den Import und Export
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ImportExportWizard)
+ [
#### Bulk-Kopie
](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.BulkCopy)
+ [
## Exportieren von Daten aus RDS für SQL Server
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting)
+ [
### SQL Server-Assistent für Import und Export (SQL Server Import and Export Wizard)
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSIEW)
+ [
### SQL Server-Assistent für das Generieren und Veröffentlichen von Skripts und Hilfsprogramm bcp
](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSGPSW)
+ [
# Verwenden des BCP-Dienstprogramms von Linux zum Importieren und Exportieren von Daten
](SQLServer.Procedural.Importing.BCP.Linux.md)
+ [
## Voraussetzungen
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Prerequisites)
+ [
## Installieren der Befehlszeilen-Tools von SQL Server unter Linux
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Installing)
+ [
## Exportieren von Daten aus RDS für SQL Server
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting)
+ [
### Grundlegende Syntax für den Export
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Basic)
+ [
### Exportbeispiel
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Example)
+ [
## Importieren von Daten in RDS für SQL Server
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing)
+ [
### Grundlegende Syntax für den Import
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Basic)
+ [
### Importbeispiel
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Example)
+ [
## Allgemeine BCP-Optionen
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Options)
+ [
## Bewährte Methoden und Überlegungen
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.BestPractices)
+ [
## Behebung häufiger Probleme
](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Troubleshooting)
## Einschränkungen und Empfehlungen
Folgende Einschränkungen gelten bei der Verwendung nativer Backups und Wiederherstellungen:
+ Sie können keine Backups in einem Amazon S3-Bucket in einer anderen AWS Region als Ihrer Amazon RDS-DB-Instance erstellen oder aus einem solchen Bucket wiederherstellen.
+ Sie können eine Datenbank nicht mit dem gleichen Namen wie eine vorhandene Datenbank wiederherstellen. Die Namen der Datenbank sind eindeutig.
+ Es wird dringend davon abgeraten, Backups aus einer Zeitzone für eine andere Zeitzone wiederherzustellen. Wenn Sie Backups aus einer bestimmten Zeitzone in einer anderen Zeitzone wiederherstellen, müssen Sie Ihre Abfragen und Anwendungen auf mögliche Auswirkungen der Zeitzonenänderung überprüfen.
+ RDS für Microsoft SQL Server hat eine Größenbeschränkung von 5 TB pro Datei. Für systemeigene Backups größerer Datenbanken können Sie Multidatei-Backups verwenden.
+ Die maximale Datenbankgröße, die zu S3 gesichert werden kann, hängt vom verfügbaren Arbeitsspeicher, der CPU, der I/O-Leistung und den Netzwerkressourcen der DB-Instance ab. Je größer die Datenbank ist, umso mehr Speicher verbraucht der Sicherungsagent.
+ Sie können gleichzeitig in nicht mehr als 10 Sicherungsdateien sichern oder aus ihnen wiederherstellen.
+ Ein differentielles Backup basiert auf dem letzten vollständigen Backup. Damit differentielle Backups funktionieren, darf kein Snapshot zwischen dem letzten vollständigen Backup und dem differentiellen Backup aufgenommen werden. Wenn Sie ein differentielles Backup erstellen möchten, aber ein manueller oder automatisierter Snapshot vorhanden ist, erstellen Sie ein weiteres vollständiges Backup, bevor Sie mit dem differentiellen Backup fortfahren.
+ Differenzielle und Protokollwiederherstellungen werden für Datenbanken mit Dateien, deren file\$1guid (eindeutige ID) auf eingestellt ist, nicht unterstütz `NULL`.
+ Sie können bis zu zwei Backup- oder Wiederherstellungsaufgaben gleichzeitig ausführen.
+ Sie können keine systemeigenen Protokollsicherungen von SQL Server auf Amazon RDS ausführen.
+ RDS unterstützt native Wiederherstellungen von Datenbanken mit einer Größe bis zu 64 TiB. Native Wiederherstellungen von Datenbanken auf SQL Server Express Edition sind auf 10 GB beschränkt.
+ Ein natives Backup der Datenbank ist nicht möglich während des Wartungsfensters bzw. während Amazon RDS einen Snapshot der Datenbank aufnimmt. Wenn sich eine native Sicherungsaufgabe mit dem täglichen RDS-Sicherungsfenster überschneidet, wird die native Sicherungsaufgabe abgebrochen.
+ Bei Multi-AZ-DB-Instances können Sie nur Datenbanken nativ wiederherstellen, die im vollständigen Wiederherstellungsmodell gesichert wurden.
+ Das Aufrufen der RDS-Verfahren zu nativen Backups und Wiederherstellungen innerhalb einer Transaktion wird nicht unterstützt.
+ Verwenden Sie eine symmetrische Verschlüsselung AWS KMS key , um Ihre Backups zu verschlüsseln. Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
+ Native Backup-Dateien werden mit dem angegebenen KMS-Schlüssel unter Verwendung des Verschlüsselungsmodus "Encryption-Only" verschlüsselt. Bei der Wiederherstellung verschlüsselter Sicherheitsdateien sollten Sie stets bedenken, dass diese Dateien mit dem Krypto-Modus "Nur Verschlüsselung" verschlüsselt wurden.
+ Eine Datenbank, die eine FILESTREAM-Dateigruppe enthält, kann nicht wiederhergestellt werden.
+ Die serverseitige Amazon S3 S3-Verschlüsselung mit AWS KMS (SSE-KMS) wird durch die Standardverschlüsselungskonfiguration Ihres S3-Buckets unterstützt, wenn Sie `@enable_bucket_default_encryption=1` zur gespeicherten Backup-Prozedur übergehen. Standardmäßig unterstützt die Wiederherstellung die serverseitige Verschlüsselung des S3-Objekts.
Wenn Sie einen KMS-Schlüssel für eine gespeicherte Prozedur bereitstellen, werden alle systemeigenen Sicherungen und Wiederherstellungen auf der Clientseite mit dem KMS-Schlüssel ver- und entschlüsselt. AWS speichert die Backups im S3-Bucket mit SSE-S3, wenn, `@enable_bucket_default_encryption=0` oder mit dem konfigurierten Standardverschlüsselungsschlüssel Ihres S3-Buckets, wenn. `@enable_bucket_default_encryption=1`
+ Bei Verwendung von S3 Access Points kann der Access Point nicht für die Verwendung einer internen RDS-VPC konfiguriert werden.
+ Für eine optimale Leistung empfehlen wir die Verwendung von Directory-Buckets oder Access Points für Directory-Buckets, sofern diese in Ihrer Region verfügbar sind.
Wenn Ihre Datenbank beim Anlegen, Kopieren und Wiederherstellen der Sicherungsdatei offline sein kann, empfehlen wir, Ihre Datenbank mithilfe nativer Backups und Wiederherstellungen zu RDS zu migrieren, Wenn Ihre lokale Datenbank nicht offline sein kann, empfehlen wir Ihnen, die zu verwenden, um Ihre Datenbank AWS Database Migration Service zu Amazon RDS zu migrieren. Weitere Informationen finden Sie unter [Was ist AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Native Backups und Wiederherstellungen sind nicht als Ersatz für die Datenwiederherstellungsfunktionen der regionsübergreifenden Snapshot-Kopierfunktion gedacht. Wir empfehlen Ihnen, Snapshot Copy zu verwenden, um Ihren Datenbank-Snapshot für die regionsübergreifende Notfallwiederherstellung in Amazon RDS in eine andere AWS Region zu kopieren. Weitere Informationen finden Sie unter [Kopieren eines DB-Snapshots für Amazon RDS](USER_CopySnapshot.md).
# Einrichtung für native Backups und Wiederherstellungen
Zum Einrichten nativer Backup und Wiederherstellungen benötigen Sie drei Komponenten:
1. Einen Amazon S3-Bucket zum Speichern Ihrer Sicherungsdateien
Sie müssen für Ihre Sicherungsdateien einen S3-Bucket verwenden und dann die Backups hochladen, die Sie zu RDS migrieren möchten. Wenn Sie bereits über einen Amazon S3-Bucket verfügen, können Sie diesen verwenden. Andernfalls können Sie [einen Bucket erstellen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html). Alternativ können Sie wählen, dass ein neuer Bucket für Sie erstellt wird, wenn Sie die Option `SQLSERVER_BACKUP_RESTORE` mithilfe der AWS-Managementkonsole hinzufügen.
Weitere Informationen zur Verwendung von S3 finden Sie im [Benutzerhandbuch für Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/).
1. Eine AWS Identity and Access Management (IAM-) Rolle für den Zugriff auf den Bucket.
Wenn Sie bereits über eine IAM-Rolle verfügen, können Sie diese verwenden. Alternativ können Sie wählen, dass eine neue IAM-Rolle für Sie erstellt wird, wenn Sie die Option `SQLSERVER_BACKUP_RESTORE` mithilfe der AWS-Managementkonsole hinzufügen. Alternativ können Sie manuell eine neue Rolle erstellen.
Wenn Sie eine neue IAM-Rolle manuell erstellen möchten, verwenden Sie die Methode, die im nächsten Abschnitt besprochen wird. Führen Sie dasselbe aus, wenn Sie einer vorhandenen IAM-Rolle Vertrauensstellungen und Berechtigungsrichtlinien zuordnen möchten.
1. Die Option `SQLSERVER_BACKUP_RESTORE` in einer Optionsgruppe auf Ihrer DB-Instance
Zur Aktivierung nativer Backups und Wiederherstellungen auf Ihrer DB-Instance fügen Sie einer Optionsgruppe auf Ihrer DB-Instance die Option `SQLSERVER_BACKUP_RESTORE` hinzu. Weitere Informationen und Anweisungen finden Sie unter [Unterstützung für native Sicherung und Backup in SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
## Manuelles Erstellen einer IAM-Rolle für native Backups und Wiederherstellungen
Wenn Sie manuell eine neue IAM-Rolle zur Verwendung mit nativen Backups und Wiederherstellungen erstellen möchten, ist dies möglich. In diesem Fall erstellen Sie eine Rolle für die Delegierung der Berechtigungen vom Amazon-RDS-Service zu Ihrem Amazon S3-Bucket. Wenn Sie eine IAM-Rolle erstellen, fügen Sie eine Vertrauensstellung und eine Berechtigungsrichtlinie an. Die Vertrauensstellung ermöglicht es RDS, diese Rolle zu übernehmen. Die Berechtigungsrichtlinie definiert die Aktionen, die über diese Rolle ausgeführt werden können. Weitere Informationen zum Erstellen der Rolle finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS -Service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html).
Für die Funktion zu nativen Backups und Wiederherstellungen verwenden Sie ähnliche Vertrauensbeziehungen und Berechtigungsrichtlinien wie in den in diesem Abschnitt gezeigten Beispielen. Im folgenden Beispiel wird der Service-Prinzipalname `rds.amazonaws.com` als Alias für alle Dienstkonten verwendet. In den anderen Beispielen wird durch Angabe eines Amazon-Ressourcennamens (ARN) einem anderen Konto, einem anderen Benutzer oder einer anderen Rolle der Zugriff auf die Vertrauensrichtlinie gewährt.
Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) und [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) in ressourcenbasierten Vertrauensbeziehungen, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.
Sie können beide globalen Bedingungskontextschlüssel verwenden und der Wert `aws:SourceArn` enthält die Konto-ID. Stellen Sie in diesen Fällen sicher, dass der Wert `aws:SourceAccount` und das Konto im Wert `aws:SourceArn` dieselbe Konto-ID verwenden, wenn sie in derselben Anweisung verwendet werden.
+ Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
+ Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.
Stellen Sie in der Vertrauensbeziehung sicher, dass Sie den globalen Bedingungskontextschlüssel `aws:SourceArn` mit dem vollständigen ARN der Ressourcen verwenden, die auf die Rolle zugreifen. Stellen Sie bei nativen Backups und Wiederherstellungen sicher, dass Sie sowohl die DB-Optionsgruppe als auch die DB-Instances einschließen, wie im folgenden Beispiel gezeigt.
**Example einer Vertrauensbeziehung mit globalem Kontextschlüssel für native Backups und Wiederherstellungen**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn": [
"arn:aws:rds:Region:0123456789:db:db_instance_identifier",
"arn:aws:rds:Region:0123456789:og:option_group_name"
],
"aws:SourceAccount": "0123456789"
}
}
}
]
}
```
Im folgenden Beispiel wird ein ARN zur Angabe einer Ressource verwendet. Weitere Informationen zur Verwendung ARNs finden Sie unter [Amazon-Ressourcennamen (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
**Example einer Berechtigungsrichtlinie für native Backups und Wiederherstellungen ohne Verschlüsselungsunterstützung**
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action":
[
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example Berechtigungsrichtlinie für native Backups und Wiederherstellungen mit Verschlüsselungsunterstützung**
Wenn Sie Ihre Sicherungsdateien verschlüsseln möchten, geben Sie in Ihrer Berechtigungsrichtlinie einen Verschlüsselungsschlüssel an. Weitere Informationen zu Verschlüsselungsschlüsseln finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) im *AWS Key Management Service -Entwicklerhandbuch*.
Sie müssen einen symmetrischen KMS-Verschlüsselungsschlüssel verwenden, um Ihre Backups zu verschlüsseln. Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
Die IAM-Rolle muss auch ein Schlüsselbenutzer und Schlüsseladministrator für den KMS-Schlüssel sein, d. h. sie muss in der Schlüsselrichtlinie angegeben werden. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToKey",
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:123456789012:key/key-id"
},
{
"Sid": "AllowAccessToS3",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Sid": "GetS3Info",
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example Berechtigungsrichtlinie für systemeigenes Backup und Wiederherstellung mithilfe von Access Points ohne Verschlüsselungsunterstützung**
Die für die Verwendung von S3-Zugriffspunkten erforderlichen Aktionen sind dieselben wie für S3-Buckets. Der Ressourcenpfad wird aktualisiert, sodass er dem ARN-Muster des S3-Zugriffspunkts entspricht.
Access Points müssen so konfiguriert sein, dass sie **Network Origin: Internet** verwenden, da RDS nicht privat veröffentlicht VPCs. S3-Verkehr von RDS-Instances wird nicht über das öffentliche Internet übertragen, da er privat abgewickelt wird VPCs.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap",
"arn:aws:s3:::underlying-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap/*",
"arn:aws:s3:::underlying-bucket/*"
]
}
]
}
```
**Example Berechtigungsrichtlinie für systemeigenes Backup und Wiederherstellung mithilfe von Zugriffspunkten für Verzeichnis-Buckets ohne Verschlüsselungsunterstützung**
Directory-Buckets verwenden einen anderen, [sitzungsbasierten Autorisierungsmechanismus](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-authenticating-authorizing.html) als Allzweck-Buckets, sodass die einzige erforderliche Berechtigung für die systemeigene Backup-Wiederherstellung die „s3express:“ -Berechtigung auf Bucket-Ebene ist. CreateSession [Um den Zugriff auf Objektebene zu konfigurieren, müssen Sie Access Points für Directory-Buckets verwenden.](https://docs.aws.amazon.com//AmazonS3/latest/userguide/access-points-directory-buckets-policies.html)
Access Points müssen so konfiguriert sein, dass sie **Network Origin: Internet** verwenden, da RDS nicht privat veröffentlicht. VPCs S3-Verkehr von RDS-Instances wird nicht über das öffentliche Internet übertragen, da er privat abgewickelt wird VPCs.
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action": "s3express:CreateSession",
"Resource":
[
"arn:aws:s3express:us-east-1:111122223333:accesspoint/amzn-s3-demo-accesspoint--use1-az6--xa-s3",
"arn:aws:s3express:us-east-1:111122223333:bucket/amzn-s3-demo-bucket--use1-az6--x-s3"
]
}
]
}
```
# Verwenden nativer Backups und Wiederherstellungen
Sobald Sie native Backups und Wiederherstellungen konfiguriert haben, können Sie mit deren Verwendung beginnen. Bauen Sie zuerst eine Verbindung zu Ihrer Microsoft SQL Server-Datenbank auf, und rufen Sie dann eine gespeicherte Amazon-RDS-Prozedur auf, um die Aufgabe zu erledigen. Anleitungen zum Herstellen einer Verbindung zu Ihrer Datenbank finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Einige der gespeicherten Prozeduren verlangen, dass Sie einen Amazon-Ressourcennamen (ARN) für Ihren Amazon S3-Bucket und die Datei angeben. Das Format für Ihren ARN lautet `arn:aws:s3:::bucket_name/file_name.extension`. Amazon S3 benötigt keine Kontonummer oder AWS Region in ARNs.
Wenn Sie auch einen optionalen KMS-Schlüssel angeben, lautet das Format für die ARN des Schlüssels `arn:aws:kms:region:account-id:key/key-id`. Weitere Informationen finden Sie unter [Amazon-Ressourcennamen (ARNs) und AWS Service-Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html). Sie müssen einen symmetrischen KMS-Verschlüsselungsschlüssel verwenden, um Ihre Backups zu verschlüsseln. Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
**Anmerkung**
Unabhängig davon, ob Sie einen KMS-Schlüssel verwenden oder nicht, ermöglichen die systemeigenen Sicherungs- und Wiederherstellungsaufgaben standardmäßig die serverseitige 256-Bit-Verschlüsselung mit Advanced Encryption Standard (AES) über SSE-S3 für auf S3 hochgeladene Dateien. Bei der Übergabe `@enable_bucket_default_encryption=1` an die gespeicherte Backup-Prozedur wird der konfigurierte Standardverschlüsselungsschlüssel Ihres S3-Buckets verwendet.
Anleitungen zum Aufrufen der einzelnen gespeicherten Prozeduren finden Sie in den folgenden Themen:
+ [Sichern einer Datenbank](#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Wiederherstellen einer Datenbank](#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Wiederherstellen eines Protokolls](#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Abschluss einer Datenbankwiederherstellung](#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Arbeiten mit teilweise wiederhergestellten Datenbanken](#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Abbrechen einer Aufgabe](#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Verfolgen des Status von Aufgaben](#SQLServer.Procedural.Importing.Native.Tracking)
## Sichern einer Datenbank
Verwenden Sie zum Sichern Ihrer Datenbank die gespeicherte Prozedur `rds_backup_database`.
**Anmerkung**
Ein Backup der Datenbank ist nicht möglich während des Wartungsfensters, oder wenn Amazon RDS gerade einen Snapshot der Datenbank erfasst.
### Usage
```
exec msdb.dbo.rds_backup_database
@source_db_name='database_name',
@s3_arn_to_backup_to='arn:aws:s3:::bucket_name/file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@overwrite_s3_backup_file=0|1],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'],
[@number_of_files=n],
[@enable_bucket_default_encryption=0|1];
```
Die folgenden Parameter sind erforderlich:
+ `@source_db_name` – Der Name der zu sichernden Datenbank.
+ `@s3_arn_to_backup_to`— Der ARN, der den Amazon S3 S3-Bucket, Access Point, Directory-Bucket oder Access Point für den Verzeichnis-Bucket angibt, der für das Backup verwendet werden soll, sowie den Namen der Backup-Datei.
Die Datei kann eine beliebige Erweiterung haben, üblicherweise wird jedoch `.bak` verwendet. Beachten Sie, dass der Access Point das folgende Format haben ARNs muss`arn:aws:s3:us-east-1:111122223333:access-point-name/object/key`.
Die folgenden Parameter sind optional:
+ `@kms_master_key_arn` – Der ARN für den symmetrischen KMS-Verschlüsselungsschlüssel, der für die Verschlüsselung des Objekts verwendet werden soll.
+ Sie können den Standard-Verschlüsselungsschlüssel nicht verwenden. Wenn Sie den Standardschlüssel verwenden, wird die Datenbank nicht gesichert.
+ Wenn Sie keine KMS-Schlüsselkennung angeben, wird die Sicherungsdatei nicht verschlüsselt. Weitere Informationen finden Sie unter [Verschlüsseln von Amazon-RDS-Ressourcen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html).
+ Wenn Sie einen KMS-Schlüssel angeben, wird eine client-seitige Verschlüsselung verwendet.
+ Amazon RDS unterstützt keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter [Erstellen symmetrischer KMS-Verschlüsselungsschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) im *AWS Key Management Service -Entwicklerhandbuch*.
+ `@overwrite_s3_backup_file` – Ein Wert, der angibt, ob eine vorhandene Sicherungsdatei überschrieben werden soll.
+ `0` – Eine vorhandene Datei wird nicht überschrieben. Dieser Wert ist der Standard.
Wenn Sie `@overwrite_s3_backup_file` auf 0 setzen, wird ein Fehler ausgegeben, wenn die Datei bereits vorhanden ist.
+ `1` – Eine vorhandene Datei mit dem angegebenen Namen wird überschrieben, auch wenn es sich nicht um eine Sicherungsdatei handelt.
+ `@type` – Der Typ der Backup.
+ `DIFFERENTIAL` – Erstellt eine differentielle Backup.
+ `FULL` – Erstellt eine vollständige Backup. Dieser Wert ist der Standard.
Eine differentielle Sicherung basiert auf der letzten vollständigen Sicherung. Damit differentielle Sicherungen funktionieren, darf kein Snapshot zwischen der letzten vollständigen Sicherung und der differentiellen Sicherung aufgenommen werden. Wenn Sie ein differentielles Backup erstellen wollen und ein Snapshot existiert, erstellen Sie ein weiteres vollständiges Backup, bevor Sie mit dem differentiellen Backup fortfahren.
Sie können das letzte vollständige Backup oder den Snapshot mit der folgenden Beispiel-SQL-Abfrage suchen:
```
select top 1
database_name
, backup_start_date
, backup_finish_date
from msdb.dbo.backupset
where database_name='mydatabase'
and type = 'D'
order by backup_start_date desc;
```
+ `@number_of_files` – Die Anzahl der Dateien, in die das Backup aufgeteilt wird (aufgeschlüsselt). Die maximale Anzahl ist 10.
+ Das Backup mehrerer Dateien wird sowohl für vollständige als auch für differenzielle Backups unterstützt.
+ Wenn Sie den Wert 1 eingeben oder den Parameter weglassen, wird eine einzelne Sicherungsdatei erstellt.
Geben Sie das Präfix an, das den Dateien gemeinsam ist, und danach das Suffix mit einem Sternchen (`*`). Das Sternchen kann sich an einer beliebigen *file\$1name* Stelle im S3-ARN ARN. Das Sternchen wird durch eine Reihe von alphanumerischen Zeichenfolgen in den generierten Dateien ersetzt, beginnend mit `1-of-number_of_files`.
Wenn beispielsweise die Dateinamen im S3-ARN `backup*.bak` lauten und Sie `@number_of_files=4` festlegen, sind die generierten Sicherungsdateien `backup1-of-4.bak`, `backup2-of-4.bak`, `backup3-of-4.bak` und `backup4-of-4.bak`.
+ Wenn einer der Dateinamen bereits vorhanden und `@overwrite_s3_backup_file` 0 ist, wird ein Fehler ausgegeben.
+ Backups mit mehreren Dateien können nur ein Sternchen im *file\$1name* Teil des S3-ARN haben.
+ Einzeldatei-Backups können eine beliebige Anzahl von Sternchen im *file\$1name* Teil des S3-ARN haben. Sternchen werden nicht aus dem generierten Dateinamen entfernt.
+ `@block_size` – Blockgröße (in Bytes), die die physische Blockgröße für Backup-Operationen angibt. Gültige Werte sind 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 und 65.536.
+ `@max_transfer_size`— Die maximale Übertragungsgröße gibt die Obergrenze des Datenvolumens (in Byte) an, das pro I/O Vorgang während des Backup-Vorgangs übertragen wird. Gültige Werte sind Vielfache von 65.536 Byte (64 KB) bis zu 4.194.304 Byte (4 MB).
+ `@buffer_count`— Gesamtzahl der I/O Puffer, die für den Backup-Prozess verwendet werden sollen.
+ `@enable_bucket_default_encryption`— Ein Wert, der angibt, ob die Standardverschlüsselungskonfiguration des S3-Buckets für die serverseitige Verschlüsselung in S3 verwendet werden soll. Verzeichnis-Buckets verwenden unabhängig von dieser Einstellung immer die Standard-Verschlüsselungskonfiguration des Buckets.
+ `0`— Die serverseitige Verschlüsselung verwendet die 256-Bit-Verschlüsselung des Advanced Encryption Standard (AES) über SSE-S3.
+ `1`[— Die serverseitige Verschlüsselung verwendet die konfigurierte Standardverschlüsselung Ihres S3-Buckets.](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-encryption.html)
### Beispiele
**Example für eine differenzielle Backup**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@overwrite_s3_backup_file=1,
@type='DIFFERENTIAL';
```
**Example des vollständigen Backups mit clientseitiger Verschlüsselung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example für ein Backup mehrerer Dateien**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4;
```
**Example für ein differenzielles Backup mehrerer Dateien**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@type='DIFFERENTIAL',
@number_of_files=4;
```
**Example für ein Backup mehrerer Dateien mit Verschlüsselung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@number_of_files=4;
```
**Example für ein Backup mehrerer Dateien mit S3-Überschreibung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@number_of_files=4;
```
**Example für ein Backup mit Blockgröße**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@block_size=512;
```
**Example für ein Backup mehrerer Dateien mit `@max_transfer_size` und `@buffer_count`**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4,
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example für ein Backup einer einzelnen Datei mit dem Parameter @number\$1of\$1files**
In diesem Beispiel wird eine Sicherungsdatei mit dem Namen generier `backup*.bak`.
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=1;
```
**Example des vollständigen Backups mit serverseitiger Verschlüsselung**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@type='FULL',
@enable_bucket_default_encryption=1;
```
**Example der vollständigen Sicherung über einen Access Point**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example der vollständigen Sicherung mithilfe eines Zugriffspunkts für einen Verzeichnis-Bucket**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3express:us-east-1:123456789012:accesspoint/my-access-point--use1-az6--xa-s3/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
## Wiederherstellen einer Datenbank
Rufen Sie zum Wiederherstellen Ihrer Datenbank die gespeicherte Prozedur `rds_restore_database` auf. Amazon RDS erstellt einen anfänglichen Snapshot der Datenbank nach Abschluss der Wiederherstellung und wenn die Datenbank offen ist.
### Usage
```
exec msdb.dbo.rds_restore_database
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/file_name.extension',
@with_norecovery=0|1,
[@keep_cdc=0|1],
[@data_file_volume='D:|H:|I:|J:'],
[@log_file_volume='D:|H:|I:|J:'],
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'];
```
Die folgenden Parameter sind erforderlich:
+ `@restore_db_name` – Der Name der wiederherzustellenden Datenbank. Die Namen der Datenbank sind eindeutig. Sie können eine Datenbank nicht mit dem gleichen Namen wie eine vorhandene Datenbank wiederherstellen.
+ `@s3_arn_to_restore_from` – Der ARN, der das Amazon S3-Präfix und den Namen der Sicherungsdateien anzeigt, die zum Wiederherstellen der Datenbank verwendet werden.
+ Geben Sie für das Backup einer einzelnen Datei den gesamten Dateinamen an.
+ Geben Sie für das Backup mehrerer Dateien das Präfix an, das den Dateien gemeinsam ist, und danach das Suffix mit einem Sternchen (`*`).
+ Wenn Sie einen Verzeichnis-Bucket verwenden, muss der ARN `/*` aufgrund von [Unterschieden für Verzeichnis-Buckets](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-differences.html) mit enden.
+ Wenn `@s3_arn_to_restore_from` leer ist, wird die folgende Fehlermeldung ausgegeben: S3 ARN prefix cannot be empty (Präfix des S3-ARN kann nicht leer sein).
Der folgende Parameter ist für differentielle Wiederherstellungen erforderlich, für vollständige Wiederherstellungen jedoch optional.
+ `@with_norecovery` – Die für die Wiederherstellungsoperation zu verwendende Wiederherstellungsklausel.
+ Setzen Sie sie für die Wiederherstellung mit RECOVERY auf `0`. In diesem Fall ist die Datenbank nach der Wiederherstellung online.
+ Setzen Sie sie für die Wiederherstellung mit NORECOVERY auf `1`. In diesem Fall verbleibt die Datenbank nach dem Abschluss der Wiederherstellungsaufgabe im Status RESTORING. Diese Vorgehensweise erlaubt spätere differentielle Wiederherstellungen.
+ Geben Sie für DIFFERENTIELLE Wiederherstellungen `0` oder `1` an.
+ Für `FULL`-Wiederherstellungen ist dieser Wert standardmäßig `0`.
Die folgenden Parameter sind optional:
+ `@keep_cdc`— Gibt an, ob die CDC-Konfiguration (Change Data Capture) in der wiederhergestellten Datenbank beibehalten werden soll. Wird auf gesetzt, `1` um KEEP\$1CDC zu aktivieren, um es zu deaktivieren. `0` Der Standardwert ist `0`.
+ `@data_file_volume`— Gibt den Laufwerksbuchstaben für Datenbankdatendateien an. Der Standardwert ist `D:`.
+ `@log_file_volume`— Gibt den Laufwerksbuchstaben für Datenbank-Logdateien an. Der Standardwert ist`D:`.
+ `@kms_master_key_arn` – Wenn Sie die Sicherungsdatei verschlüsselt haben, den KMS-Schlüssel, der zum Entschlüsseln der Datei verwendet werden soll.
Wenn Sie einen KMS-Schlüssel angeben, wird eine client-seitige Verschlüsselung verwendet.
+ `@type` – Der Typ der Wiederherstellung. Gültige Typen sind `DIFFERENTIAL` und `FULL`. Der Standardwert ist `FULL`.
+ `@block_size` – Blockgröße (in Bytes), die die physische Blockgröße für Backup-Operationen angibt. Gültige Werte sind 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 und 65.536.
+ `@max_transfer_size`— Die maximale Übertragungsgröße gibt die Obergrenze des Datenvolumens (in Byte) an, das pro I/O Vorgang während des Sicherungsvorgangs übertragen wird. Gültige Werte sind Vielfache von 65.536 Byte (64 KB) bis zu 4.194.304 Byte (4 MB).
+ `@buffer_count`— Gesamtzahl der I/O Puffer, die für den Backup-Prozess verwendet werden sollen.
**Anmerkung**
Bei differentiellen Wiederherstellungen muss sich die Datenbank entweder im Status RESTORING befinden, oder es muss bereits eine Aufgabe existieren, die mit NORECOVERY wiederherstellt.
Sie können differentielle Backups nicht später wiederherstellen, während die Datenbank online ist.
Sie können keine Wiederherstellungsaufgabe für eine Datenbank absenden, für die bereits eine Wiederherstellungsaufgabe mit RECOVERY aussteht.
Vollständige Wiederherstellungen mit NORECOVERY und KEEP\$1CDC werden nicht unterstützt.
Alle systemeigenen Wiederherstellungen werden auf Instances mit regionsübergreifenden Read Replicas nicht unterstützt.
Bei unterstützten Konfigurationen ist das Wiederherstellen einer Datenbank auf einer Multi-AZ-Instance mit Lesereplikaten mit dem Wiederherstellen einer Datenbank auf einer Multi-AZ-Instance vergleichbar. Sie müssen keine zusätzlichen Aktionen ausführen, um eine Datenbank auf einem Replikat wiederherzustellen.
### Beispiele
**Example für die Wiederherstellung einer einzelnen Datei**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
**Example für die Wiederherstellung mehrerer Dateien**
Um Fehler beim Wiederherstellen mehrerer Dateien zu vermeiden, stellen Sie sicher, dass alle Sicherungsdateien dasselbe Präfix haben, und dass dieses Präfix von keinen anderen Dateien verwendet wird.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*';
```
**Example für eine vollständige Datenbankwiederherstellung mit RECOVERY**
Die folgenden drei Beispiele führen die gleiche Aufgabe durch, vollständige Wiederherstellung mit RECOVERY.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
[@type='DIFFERENTIAL|FULL'];
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=0;
```
**Example für eine vollständige Datenbankwiederherstellung mit Verschlüsselung**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example für eine Wiederherstellung mit Blockgröße**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@block_size=512;
```
**Example für eine Wiederherstellung mehrerer Dateien mit @max\$1transfer\$1size und @buffer\$1count**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*',
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example für eine vollständige Datenbankwiederherstellung mit NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=1;
```
**Example für eine differenzielle Wiederherstellung mit NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=1;
```
**Example für eine differenzielle Wiederherstellung mit RECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=0;
```
**Example der vollständigen Datenbankwiederherstellung mit RECOVERY über einen Access Point**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@with_norecovery=0;
```
**Example der vollständigen Datenbankwiederherstellung mit KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Wiederherstellen eines Protokolls
Zum Wiederherstellen Ihres Protokolls rufen Sie die gespeicherte Prozedur `rds_restore_log` auf.
### Usage
```
exec msdb.dbo.rds_restore_log
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/log_file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@with_norecovery=0|1],
[@keep_cdc=0|1],
[@stopat='datetime'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n];
```
Die folgenden Parameter sind erforderlich:
+ `@restore_db_name` – Der Name der Datenbank, deren Protokoll wiederhergestellt werden soll.
+ `@s3_arn_to_restore_from` – Der ARN mit dem Amazon S3-Präfix und dem Namen der Protokolldatei für die Wiederherstellung des Protokolls. Die Datei kann eine beliebige Erweiterung haben, üblicherweise wird jedoch `.trn` verwendet.
Wenn `@s3_arn_to_restore_from` leer ist, wird die folgende Fehlermeldung ausgegeben: S3 ARN prefix cannot be empty (Präfix des S3-ARN kann nicht leer sein).
Die folgenden Parameter sind optional:
+ `@keep_cdc`— Gibt an, ob die Change Data Capture-Konfiguration (CDC) in der wiederhergestellten Datenbank beibehalten werden soll. Auf 1 setzen, um KEEP\$1CDC zu aktivieren, auf 0, um es zu deaktivieren. Der Standardwert lautet 0.
+ `@kms_master_key_arn` - Wenn Sie das Protokoll verschlüsselt haben, den KMS-Schlüssel, der zur Entschlüsselung des Protokolls verwendet werden soll.
+ `@with_norecovery` – Die für die Wiederherstellungsoperation zu verwendende Wiederherstellungsklausel. Dieser Wert ist standardmäßig `1`.
+ Setzen Sie sie für die Wiederherstellung mit RECOVERY auf `0`. In diesem Fall ist die Datenbank nach der Wiederherstellung online. Sie können differentielle Protokollsicherungen nicht später wiederherstellen, während die Datenbank online ist.
+ Setzen Sie sie für die Wiederherstellung mit NORECOVERY auf `1`. In diesem Fall verbleibt die Datenbank nach dem Abschluss der Wiederherstellungsaufgabe im Status RESTORING. Diese Vorgehensweise erlaubt spätere Protokollwiederherstellungen.
+ `@stopat` – Ein Wert, der angibt, dass die Datenbank zu ihrem Zustand am angegebenen Datum und zur angegebenen Uhrzeit (im Datetime-Format) wiederhergestellt wird. Nur vor diesem angegebenen Zeitpunkt geschriebene Transaktionsprotokolldatensätze werden auf die Datenbank angewendet.
Wenn dieser Parameter nicht angegeben wird (NULL ist), wird das vollständige Protokoll wiederhergestellt.
+ `@block_size` – Blockgröße (in Bytes), die die physische Blockgröße für Backup-Operationen angibt. Gültige Werte sind 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 und 65.536.
+ `@max_transfer_size`— Die maximale Übertragungsgröße gibt die Obergrenze des Datenvolumens (in Byte) an, das pro I/O Vorgang während des Backup-Vorgangs übertragen wird. Gültige Werte sind Vielfache von 65.536 Byte (64 KB) bis zu 4.194.304 Byte (4 MB).
+ `@buffer_count`— Gesamtzahl der I/O Puffer, die für den Backup-Prozess verwendet werden sollen.
**Anmerkung**
Bei Protokollwiederherstellungen muss sich die Datenbank entweder im Status RESTORING befinden, oder es muss bereits eine Aufgabe existieren, die mit NORECOVERY wiederherstellt.
Sie können differentielle Protokollsicherungen nicht wiederherstellen, während die Datenbank online ist.
Sie können keine Protokollwiederherstellungsaufgabe für eine Datenbank absenden, für die bereits eine Wiederherstellungsaufgabe mit RECOVERY aussteht.
### Beispiele
**Example für eine Protokollwiederherstellung**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example für eine Protokollwiederherstellung mit Verschlüsselung**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example für eine Protokollwiederherstellung mit NORECOVERY**
Die folgenden zwei Beispiele führen die gleiche Aufgabe durch, die Protokollwiederherstellung mit NORECOVERY.
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=1;
```
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example für eine Wiederherstellung mit Blockgröße**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@block_size=512;
```
**Example für eine Protokollwiederherstellung mit RECOVERY**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0;
```
**Example für eine Protokollwiederherstellung mit STOPAT-Klausel**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0,
@stopat='2019-12-01 03:57:09';
```
**Example der Protokollwiederherstellung mit KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Abschluss einer Datenbankwiederherstellung
Wenn die letzte Wiederherstellungsaufgabe auf der Datenbank mit `@with_norecovery=1` durchgeführt wurde, befindet sich die Datenbank jetzt im Status RESTORING. Öffnen Sie diese Datenbank für den normalen Betrieb mit der gespeicherten Prozedur `rds_finish_restore`.
### Usage
```
exec msdb.dbo.rds_finish_restore @db_name='database_name';
```
**Anmerkung**
Für diese Vorgehensweise muss sich die Datenbank im Status RESTORING ohne ausstehende Wiederherstellungsaufgaben befinden.
Verwenden Sie zum Abschluss der Wiederherstellung der Datenbank die Master-Anmeldeinformationen. Sie können auch die Benutzeranmeldung verwenden, die zuletzt die Datenbank oder das Protokoll mit NORECOVERY wiederhergestellt hat.
## Arbeiten mit teilweise wiederhergestellten Datenbanken
### Verwerfen einer teilweise wiederhergestellten Datenbank
Verwenden Sie zum Verwerfen einer teilweise wiederhergestellten Datenbank (die im Status RESTORING verbleibt) die gespeicherte Prozedur `rds_drop_database`.
```
exec msdb.dbo.rds_drop_database @db_name='database_name';
```
**Anmerkung**
Sie können keine DROP-Datenbankanfrage für eine Datenbank absenden, für die bereits eine ausstehende Wiederherstellungs- oder Wiederherstellungsabschlussaufgabe besteht.
Verwenden Sie zum Verwerfen der Datenbank die Master-Anmeldung. Sie können auch die Benutzeranmeldung verwenden, die zuletzt die Datenbank oder das Protokoll mit NORECOVERY wiederhergestellt hat.
### Snapshot-Wiederherstellung und point-in-time Wiederherstellungsverhalten für teilweise wiederhergestellte Datenbanken
Teilweise wiederhergestellte Datenbanken in der Quellinstanz (im Status point-in-time RESTORING belassen) werden während der Snapshot-Wiederherstellung und -Wiederherstellung aus der Zielinstanz gelöscht.
## Abbrechen einer Aufgabe
Zum Abbruch einer Sicherungs- oder Wiederherstellungsaufgabe rufen Sie die gespeicherte Prozedur `rds_cancel_task` auf.
**Anmerkung**
Eine FINISH\$1RESTORE-Aufgabe kann nicht abgebrochen werden.
### Usage
```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```
Der folgende Parameter ist erforderlich:
+ `@task_id` – ID der abzubrechenden Aufgabe Sie erhalten die ID der Aufgabe durch den Aufruf von `rds_task_status`.
## Verfolgen des Status von Aufgaben
Um den Status Ihrer Sicherungs- oder Wiederherstellungsaufgaben zu verfolgen, rufen Sie die gespeicherte Prozedur `rds_task_status` auf. Wenn Sie keine Parameter angeben, gibt die gespeicherte Prozedur den Status aller Aufgaben zurück. Der Status für Aufgaben wird etwa alle zwei Minuten aktualisiert. Der Abfrageverlauf wird 36 Tage gespeichert.
### Usage
```
exec msdb.dbo.rds_task_status
[@db_name='database_name'],
[@task_id=ID_number];
```
Die folgenden Parameter sind optional:
+ `@db_name` – Name der Datenbank, für die der Aufgabenstatus angezeigt werden soll
+ `@task_id` – ID der Aufgabe, für die der Aufgabenstatus angezeigt werden soll
### Beispiele
**Example für die Auflistung des Status für eine bestimmte Aufgabe**
```
exec msdb.dbo.rds_task_status @task_id=5;
```
**Example für die Auflistung des Status für eine bestimmte Datenbank und Aufgabe**
```
exec msdb.dbo.rds_task_status
@db_name='my_database',
@task_id=5;
```
**Example für die Auflistung aller Aufgaben und ihrer Status auf einer bestimmten Datenbank**
```
exec msdb.dbo.rds_task_status @db_name='my_database';
```
**Example für die Auflistung aller Aufgaben und ihrer Status auf der aktuellen Instance**
```
exec msdb.dbo.rds_task_status;
```
### Antwort
Die gespeicherte Prozedur `rds_task_status` gibt die folgenden Spalten zurück.
****
| Spalte | Beschreibung |
| --- | --- |
| `task_id` | Die ID der Aufgabe. |
| `task_type` | Aufgabentyp je nach Eingabeparametern, wie folgt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) Amazon RDS erstellt einen anfänglichen Snapshot der Datenbank nach ihrer Öffnung oder nach dem Abschluss der folgenden Wiederherstellungsaufgaben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `database_name` | Der Name der Datenbank, der die Aufgabe zugeordnet ist. |
| `% complete` | Der Fortschritt der Aufgabe als Prozentwert. |
| `duration (mins)` | Zeitdauer für die Ausführung der Aufgabe (in Minuten). |
| `lifecycle` | Der Status der Aufgabe. Die folgenden Status sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `task_info` | Zusätzliche Informationen über die Aufgabe. Wenn während des Sicherns oder Wiederherstellens einer Datenbank ein Fehler auftritt, enthält diese Spalte Informationen über den Fehler. Eine Liste möglicher Fehler und Abhilfemaßnahmen finden Sie unter [Fehlerbehebung](SQLServer.Procedural.Importing.Native.Troubleshooting.md). |
| `last_updated` | Datum und Uhrzeit der letzten Aktualisierung des Aufgabenstatus. Der Status wird jeweils nach 5 Prozent Fortschritt aktualisiert. |
| `created_at` | Datum und Uhrzeit, an denen die Aufgabe angelegt wurde. |
| S3\$1object\$1arn | Der ARN mit dem Amazon S3-Präfix und dem Namen der Datei, die gesichert oder wiederhergestellt wird. |
| `overwrite_s3_backup_file` | Wert des Parameters `@overwrite_s3_backup_file`, der beim Aufruf einer Sicherungsaufgabe angegeben wurde. Weitere Informationen finden Sie unter [Sichern einer Datenbank](#SQLServer.Procedural.Importing.Native.Using.Backup). |
| KMS\$1master\$1key\$1arn | Der ARN für den KMS-Schlüssel, der für die Verschlüsselung (für die Sicherung) und Entschlüsselung (für die Wiederherstellung) verwendet wird. |
| filepath | Gilt nicht für native Sicherungs- und Wiederherstellungsaufgaben |
| overwrite\$1file | Gilt nicht für native Sicherungs- und Wiederherstellungsaufgaben |
# Komprimieren von Sicherungsdateien
Zur Platzersparnis in Ihrem Amazon S3-Bucket können Sie Ihre Sicherungsdateien komprimieren. Weitere Informationen zum Komprimieren von Sicherungsdateien finden Sie unter [Sicherungskomprimierung](https://msdn.microsoft.com/en-us/library/bb964719.aspx) in der Microsoft-Dokumentation.
Die Komprimierung Ihrer Sicherungsdateien wird für die folgenden Datenbankversionen unterstützt:
+ Microsoft SQL Server Enterprise Edition
+ Microsoft SQL Server Standard Edition
Um die Komprimierung für Ihre Backup-Dateien zu verifizieren, führen Sie den folgenden Code aus:
```
1. exec rdsadmin.dbo.rds_show_configuration 'S3 backup compression';
```
Um die Komprimierung für Ihre Sicherungsdateien einzuschalten, führen Sie den folgenden Code aus:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'true';
```
Um die Komprimierung für Ihre Sicherungsdateien auszuschalten, führen Sie den folgenden Code aus:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'false';
```
# Fehlerbehebung
Die folgenden Probleme können bei der Verwendung nativer Backups und Wiederherstellungen auftreten.
****
| Problem | Vorschläge für die Fehlerbehebung |
| --- | --- |
| Die Option zur Backup/Wiederherstellung der Datenbank ist noch nicht aktiviert oder wird gerade aktiviert. Bitte versuchen Sie es später noch einmal. | Achten Sie darauf, die `SQLSERVER_BACKUP_RESTORE`-Option zur DB-Optionsgruppe hinzuzufügen, die mit Ihrer DB-Instance verbunden ist. Weitere Informationen finden Sie unter [Hinzufügen der Option „Native Sicherung und Backup“](Appendix.SQLServer.Options.BackupRestore.md#Appendix.SQLServer.Options.BackupRestore.Add). |
| Die EXECUTE-Berechtigung wurde für das Objekt „*rds\$1backup\$1database*“, Datenbank „msdb“, Schema „dbo“ verweigert. | Wenn Sie die gespeicherte Prozedur ausführen, stellen Sie sicher, dass Sie den Hauptbenutzer verwenden. Wenn dieser Fehler auch dann auftritt, wenn Sie als Hauptbenutzer angemeldet sind, kann dies daran liegen, dass die Administratorberechtigungen falsch zugeordnet sind. Um den Hauptbenutzer zurückzusetzen, verwenden Sie die AWS-Managementkonsole. Siehe [Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Die EXECUTE-Berechtigung wurde für das Objekt „*rds\$1restore\$1database*“, Datenbank „msdb“, Schema „dbo“ verweigert. | Wenn Sie die gespeicherte Prozedur ausführen, stellen Sie sicher, dass Sie den Hauptbenutzer verwenden. Wenn dieser Fehler auch dann auftritt, wenn Sie als Hauptbenutzer angemeldet sind, kann dies daran liegen, dass die Administratorberechtigungen falsch zugeordnet sind. Um den Hauptbenutzer zurückzusetzen, verwenden Sie die AWS-Managementkonsole. Siehe [Zurücksetzen der db\$1owner-Rollenmitgliedschaft für den Master-Benutzer für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Zugriff verweigert | Der Sicherungs- oder Wiederherstellungsprozess kann nicht auf die Sicherungsdatei zugreifen. Dies hat normalerweise Ursachen wie die folgenden: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Troubleshooting.html) |
| BACKUP-DATENBANK MIT KOMPRESSION wird in Edition nicht unterstützt | Die Komprimierung Ihrer Sicherungsdateien wird nur für Microsoft SQL Server Enterprise Edition und Standard Edition unterstützt. . Weitere Informationen finden Sie unter [Komprimieren von Sicherungsdateien](SQLServer.Procedural.Importing.Native.Compression.md). |
| Schlüssel existiert nicht | Sie haben versucht, ein verschlüsseltes Backup wiederherzustellen, haben aber keinen Verschlüsselungsschlüssel angegeben. Prüfen Sie Ihren Verschlüsselungsschlüssel und versuchen Sie es erneut. Weitere Informationen finden Sie unter [Wiederherstellen einer Datenbank](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). |
| Bitte geben Sie die Aufgabe mit dem richtigen Typ neu aus und überschreiben Sie die Eigenschaft | Wenn Sie versuchen, Ihre Datenbank zu sichern, und Sie den Namen einer bereits vorhandenen Datei angeben, aber die Eigenschaft "overwrite" auf "false" gesetzt haben, schlägt der Sicherungsvorgang fehl. Geben Sie zur Korrektur dieses Fehlers entweder den Namen einer noch nicht vorhandenen Datei an, oder setzen Sie die Eigenschaft "overwrite" auf "true". Weitere Informationen finden Sie unter [Sichern einer Datenbank](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup). Zudem ist es möglich, dass Sie Ihre Datenbank wiederherstellen wollten, aber versehentlich die gespeicherte Prozedur `rds_backup_database` aufgerufen haben. Rufen Sie in diesem Fall stattdessen die gespeicherte Prozedur `rds_restore_database` auf. Weitere Informationen finden Sie unter [Wiederherstellen einer Datenbank](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). Wenn Sie Ihre Datenbank wiederherstellen wollten und die gespeicherte Prozedur `rds_restore_database` aufgerufen haben, vergewissern Sie sich, dass Sie den Namen einer gültigen Sicherungsdatei angegeben haben. Weitere Informationen finden Sie unter [Verwenden nativer Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Using.md). |
| Bitte geben Sie einen Bucket an, der sich in der gleichen Region wie die RDS-Instance befindet | Sie können keine Backups zu einem Amazon-S3-Bucket in einer AWS-Region ausführen, die sich von der Ihrer Amazon-RDS-DB-Instance unterscheidet, oder Wiederherstellungen aus einem solchen Bucket ausführen. Sie können mithilfe von Amazon S3 Replikation die Sicherungsdatei in die korrekte AWS Region kopieren. Weitere Informationen finden Sie unter [Regionenübergreifende Replikation](https://docs.aws.amazon.com/AmazonS3/latest/userguide/crr.html) in der Amazon S3-Dokumentation. |
| Der angegebene Bucket existiert nicht | Stellen Sie sicher, dass Sie den korrekten ARN für Ihren Bucket und die Datei im richtigen Format angegeben haben. Weitere Informationen finden Sie unter [Verwenden nativer Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Using.md). |
| Der Benutzer ist nicht berechtigt, auf Ressourcen zu arbeiten | Sie haben einen verschlüsselten Vorgang angefragt, aber keine geeigneten AWS KMS-Berechtigungen angegeben. Überprüfen Sie, ob Sie die korrekten Berechtigungen haben oder fügen Sie diese hinzu. Weitere Informationen finden Sie unter [Einrichtung für native Backups und Wiederherstellungen](SQLServer.Procedural.Importing.Native.Enabling.md). |
| Die Wiederherstellungsaufgabe kann nicht aus mehr als 10 Sicherungsdateien wiederhergestellt werden). Bitte reduzieren Sie die Anzahl der übereinstimmenden Dateien und versuchen Sie es erneut. | Reduzieren Sie die Anzahl der Dateien, aus denen Sie wiederherstellen möchten. Sie können jede einzelne Datei bei Bedarf größer machen. |
| Die Datenbank '*database\$1name*' existiert bereits. Zwei Datenbanken, die sich nur nach Fall oder Akzent unterscheiden, sind nicht zulässig. Wählen Sie einen anderen Datenbanknamen aus. | Sie können eine Datenbank nicht mit dem gleichen Namen wie eine vorhandene Datenbank wiederherstellen. Die Namen der Datenbank sind eindeutig. |
# Importieren und Exportieren von SQL Server-Daten mithilfe anderer Methoden
Im Folgenden finden Sie Informationen zur Verwendung von Snapshots für den Import Ihrer Microsoft SQL Server-Daten zu Amazon RDS. Sie finden hier auch Informationen zur Verwendung von Snapshots für den Export Ihrer Daten von einer RDS DB-Instance mit SQL Server.
Wenn es Ihr Szenario unterstützt, ist es einfacher, Daten mithilfe der nativen Sicherungs- und Wiederherstellungsfunktionalität zu und aus Amazon RDS zu verschieben. Weitere Informationen finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
**Anmerkung**
Amazon RDS für Microsoft SQL Server unterstützt nicht das Importieren von Daten in die `msdb`-Datenbank.
## Importieren von Daten in RDS für SQL Server mithilfe eines Snapshots
**So können Sie Daten in eine SQL Server-DB-Instance mithilfe eines Snapshots importieren**
1. Erstellen Sie eine DB -Instance. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
1. Stoppen Sie den Zugriff von Anwendungen auf die gewünschte DB-Instance.
Wenn Sie den Zugriff auf Ihre DB-Instance blockieren, während Sie Daten importieren, läuft die Datenübertragung schneller. Zudem müssen Sie sich keine Sorgen über Konflikte machen, während die Daten geladen werden, wenn andere Anwendungen nicht in die DB-Instance schreiben können. Falls ein Problem auftritt und Sie zum vorherigen Datenbank-Snapshot zurückkehren müssen, verlieren Sie lediglich die importierten Daten. Sie können diese Daten dann nach der Behebung des Problems erneut importieren.
Weitere Informationen über die Zugriffskontrolle auf Ihre DB-Instance finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
1. Erstellen Sie einen Snapshot der Ziel-Datenbank.
Wenn die Zieldatenbank bereits Daten enthält, empfehlen wir Ihnen einen Snapshot dieser Datenbank zu machen, bevor Sie Daten importieren. Wenn etwas beim Datenimport schief geht oder Sie die Änderungen verwerfen möchten, können Sie den vorherigen Zustand der Datenbank mithilfe des Snapshots wiederherstellen. Weitere Informationen zu Datenbank-Snapshots finden Sie unter [Erstellen eines DB-Snapshots für eine DB-Instance mit Single-AZ für Amazon RDS](USER_CreateSnapshot.md).
**Anmerkung**
Wenn Sie einen Datenbank-Snapshot erstellen, werden die I/O-Operationen zur Datenbank für einen Moment (Millisekunden) ausgesetzt, während das Backup läuft.
1. Deaktivieren Sie automatische Backups für die Ziel-Datenbank.
Das Deaktivieren der automatischen Backups auf der DB-Ziel-Instance verbessert die Leistung beim Importieren Ihrer Daten, da Amazon RDS die Transaktionen nicht protokolliert, wenn automatische Backups deaktiviert sind. Jedoch müssen einige Dinge beachtet werden. Automatisierte Backups sind für zeitpunktbezogene Wiederherstellungen erforderlich. Sie können daher nicht eine Datenbank zu einem bestimmten Zeitpunkt wiederherstellen, während Sie Daten importieren. Darüber hinaus werden alle automatisierten Backups, die für die DB-Instance erstellt wurden, gelöscht - es sei denn, Sie möchten sie behalten.
Wenn Sie sich für die Aufbewahrung der automatisierten Backups entscheiden, können Sie sich vor versehentlichem Löschen von Daten schützen. Amazon RDS speichert außerdem die Eigenschaften der Datenbank-Instance zusammen mit jedem automatisierten Backup, um die Wiederherstellung zu erleichtern. Mit dieser Option können Sie eine gelöschte Datenbank-Instance auch nach dem Löschen auf einen bestimmten Zeitpunkt innerhalb der Aufbewahrungsfrist wiederherstellen. Automatische Backups werden am Ende des angegebenen Backup-Zeitraums automatisch gelöscht, genau wie bei einer aktiven Datenbank-Instance.
Sie können auch frühere Snapshots verwenden, um die Datenbank wiederherzustellen. Snapshots, die Sie erstellt haben, bleiben verfügbar. Weitere Informationen zu automatischen Backups finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md).
1. Deaktivieren Sie auswärtige Schlüsselbeschränkungen, wenn möglich.
Wenn Sie auswärtige Schlüsselbeschränkungen deaktivieren müssen, können Sie das folgende Skript verwenden.
```
--Disable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' NOCHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
GO
```
1. Verwerfen Sie Indizes, wenn möglich.
1. Deaktivieren Sie Auslöser, wenn möglich.
Wenn Sie Auslöser deaktivieren müssen, können Sie das folgende Skript verwenden.
```
--Disable triggers on all tables
DECLARE @enable BIT = 0;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
GO
```
1. Suchen Sie in der Quell-SQL Server-Instance nach Anmeldedaten, die Sie in die gewünschte DB-Instance importieren möchten.
SQL Server speichert Anmeldedaten und Passwörter in der `master`-Datenbank. Da Amazon RDS keinen Zugriff auf die `master`-Datenbank gewährt, können Sie Anmeldedaten und Passwörter nicht direkt in Ihre DB-Instance importieren. Stattdessen müssen Sie die `master`-Datenbank auf der SQL Server-Quell-Instance abfragen, um eine DDL (Data Definition Language)-Datei zu generieren. Diese Datei sollte alle Anmeldedaten und Passwörter enthalten, die Sie der DB-Ziel-Instance hinzufügen möchten. Diese Datei sollte auch die Rollenmitgliedschaften und Berechtigungen enthalten, die Sie übertragen möchten.
Weitere Informationen zum Abfragen der `master`-Datenbank finden Sie unter [Transfer logins and passwords between instances of SQL Server](https://learn.microsoft.com/en-us/troubleshoot/sql/database-engine/security/transfer-logins-passwords-between-instances) in der Microsoft Knowledge Base.
Die Ausgabe des Skripts ist ein anderes Skript, das Sie in der gewünschten DB-Instance ausführen können. Das Skript im Knowledge Base-Artikel hat den folgenden Code:
```
p.type IN
```
Jedes Mal wenn `p.type` erscheint, verwenden Sie stattdessen den folgenden Code:
```
p.type = 'S'
```
1. Importieren Sie Daten mithilfe der Methode in [Importieren der Daten](#ImportData.SQLServer.Import).
1. Gewähren Sie Anwendungen Zugriff auf die Ziel-DB-Instance.
Wenn Ihr Datenimport abgeschlossen ist, können Sie den Anwendungen, die Sie während des Imports blockiert haben, den Zugang zur DB-Instance gewähren. Weitere Informationen über die Zugriffskontrolle auf Ihre DB-Instance finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
1. Aktivieren Sie automatische Backups für die Ziel-DB-Instance.
Weitere Informationen zu automatischen Backups finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md).
1. Aktivieren Sie auswärtige Schlüsselbeschränkungen.
Wenn Sie auswärtige Schlüsselbeschränkungen vorher deaktiviert haben, können Sie diese jetzt mit dem folgenden Skript aktivieren.
```
--Enable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' CHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
```
1. Aktivieren Sie Indizes, wenn möglich.
1. Aktivieren Sie Auslöser, wenn möglich.
Wenn Sie Auslöser vorher deaktiviert haben, können Sie diese jetzt mit dem folgenden Skript aktivieren.
```
--Enable triggers on all tables
DECLARE @enable BIT = 1;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
```
### Importieren der Daten
Microsoft SQL Server Management Studio ist ein grafischer SQL Server-Client, der in allen Microsoft SQL Server Editionen enthalten ist, außer in der Express Edition. SQL Server Management Studio Express von Microsoft ist als kostenloser Download verfügbar. Sie finden diesen Download auf der [Microsoft-Website](https://www.microsoft.com/en-us/download).
**Anmerkung**
SQL Server Management Studio ist nur als Windows-basierte Anwendung verfügbar.
SQL Server Management Studio beinhaltet die folgenden Tools, die nützlich für den Import von Daten in eine SQL Server DB-Instance sind:
+ Assistent für das Generieren und Veröffentlichen von Skripts
+ Assistent für den Import und Export
+ Bulk-Kopie
#### Assistent für das Generieren und Veröffentlichen von Skripts
Der Assistent für das Generieren und Veröffentlichen von Skripts erstellt ein Skript, das das Schema einer Datenbank, die Daten selbst, oder beides enthält. Sie können ein Skript für eine Datenbank in Ihrer lokalen SQL Server-Bereitstellung generieren. Sie können dann das Skript ausführen, um die darin enthaltenen Informationen zu einer Amazon-RDS-DB-Instance zu übertragen.
**Anmerkung**
Bei Datenbanken mit einer Größe von 1 GiB oder mehr ist es effizienter, nur für das Datenbankschema ein Skript zu verwenden. Anschließend verwenden Sie den Assistenten für Import und Export oder die Massenkopierfunktion von SQL Server, um die Daten zu übertragen.
Weitere detaillierte Informationen über den Assistent für das Generieren und Veröffentlichen von Skripts finden Sie in der [Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms178078%28v=sql.105%29.aspx).
Beachten Sie im Assistenten besonders die erweiterten Optionen auf der Seite **Set Scripting Options** (Scripting-Optionen einstellen), um sicherzustellen, dass alle Inhalte, die im Skript enthalten sein sollen, ausgewählt wurden. Beispielsweise sind standardmäßig keine Datenbank-Auslöser im Skript enthalten.
Wenn das Skript generiert und gespeichert ist, können Sie SQL Server Management Studio verwenden, um sich mit Ihrer DB-Instance zu verbinden und das Skript auszuführen.
#### Assistent für den Import und Export
Der Import-Export-Assistent erstellt ein spezielles Paket mit Integrationsdiensten, die Sie verwenden können, um Daten aus Ihrer lokalen SQL Server-Datenbank in die gewünschte DB-Instance zu kopieren. Der Assistent kann filtern, welche Tabellen und sogar welche Tupel innerhalb von Tabellen in die bestimmte DB-Instance kopiert werden sollen.
**Anmerkung**
Der Import-Export-Assistent funktioniert gut mit großen Datensätzen, aber es ist nicht unbedingt der schnellste Weg, um Daten remote aus Ihrer lokalen Einrichtung zu exportieren. Eine schnellere Methode ist die SQL Server-Bulk-Kopie-Funktion.
Weitere detaillierte Informationen über den Import-Export-Assistenten finden Sie in der [ Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms140052%28v=sql.105%29.aspx).
Führen Sie im Assistenten auf der Seite **Choose a Destination** (Ziel auswählen) folgende Schritte aus:
+ Geben Sie im Feld **Servername** den Namen des Endpunkts für Ihre DB-Instance ein.
+ Wählen Sie als Server-Authentifizierungsmodus **Use SQL Server Authentication** (SQL Server-Authentifizierung verwenden) aus.
+ Geben Sie im Feld **Benutzername** und **Passwort** die Anmeldeinformationen für den Hauptbenutzer ein, den Sie für die DB-Instance erstellt haben.
#### Bulk-Kopie
Die SQL Server-Bulk-Kopie-Funktion ist eine effiziente Methode zum Kopieren von Daten aus einer Quelldatenbank auf Ihre DB-Instance. Bulk-Kopie schreibt die Daten, die Sie für die Datei festlegen, wie z. B. eine ASCII-Datei. Sie können die Bulk-Kopie nochmal ausführen, um die Inhalte der Datei in die gewünschte DB-Instance zu schreiben.
In diesem Abschnitt wird das Hilfsprogramm **bcp** verwendet, das in allen Editionen von SQL Server enthalten ist. Weitere detaillierte Informationen zu Bulk-Import und -Export-Operationen finden Sie in der [Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx).
**Anmerkung**
Bevor Sie eine Bulk-Kopie verwenden, müssen Sie zuerst Ihr Datenbankschema in die gewünschte DB-Instance importieren. Der Assistent für das Generieren und Veröffentlichen von Skripts, der vorher in diesem Thema beschrieben wurde, ist ein ausgezeichnetes Tool für diesen Zweck.
Der folgende Befehl stellt eine Verbindung zur lokalen SQL Server-Instance her. Er generiert eine tabulatorgetrennte Datei für eine angegebene Tabelle im C:\$1-Stammverzeichnis Ihrer bestehenden SQL Server-Bereitstellung. Die Tabelle wird durch ihren vollständigen, gültigen Namen angegeben und die Textdatei hat denselben Namen wie die kopierte Tabelle.
```
bcp dbname.schema_name.table_name out C:\table_name.txt -n -S localhost -U username -P password -b 10000
```
Der vorherige Code beinhaltet die folgenden Optionen:
+ `-n` gibt an, dass eine Massenkopie die nativen Datentypen der Daten verwendet, die zu kopieren sind.
+ `-S` gibt die SQL Server-Instance an, mit der sich das Hilfsprogramm *bcp* verbindet.
+ `-U` gibt den Benutzernamen des Kontos an, das in der SQL Server-Instance angemeldet wird.
+ `-P` gibt das Passwort für den Benutzer an `-U`.
+ `-b` gibt die Anzahl der Zeilen pro Batch importierter Daten an.
**Anmerkung**
Es könnte noch andere Parameter geben, die für Ihren Importvorgang wichtig sind. Beispielsweise könnten Sie den Parameter `-E` benötigen, der sich auf die Identitätswerte bezieht. Weitere Informationen finden Sie in der vollständigen Beschreibung der Befehlszeilensyntax für das Hilfsprogramm **bcp** in der [Microsoft SQL Server-Dokumentation](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.105%29.aspx).
Angenommen, eine Datenbank mit dem Namen `store`, die das Standardschema `dbo` verwendet, enthält eine Tabelle mit dem Namen `customers`. Das Benutzerkonto `admin` mit dem Passwort `insecure` kopiert 10 000 Zeilen aus der Tabelle `customers` in eine Datei mit dem Namen `customers.txt`.
```
bcp store.dbo.customers out C:\customers.txt -n -S localhost -U admin -P insecure -b 10000
```
Nachdem Sie die Datendatei erstellt haben, können Sie die Daten mit einem ähnlichen Befehl zu Ihrer DB-Instance hochladen. Erstellen Sie vorher die Datenbank und das Schema auf der DB-Ziel-Instance. Verwenden Sie dann das Argument `in`, um die Input-Datei anzugeben, anstelle von `out`, um die Output-Datei anzugeben. Anstelle der Verwendung von localhost zur Angabe der lokalen SQL Server-Instance, geben Sie den Endpunkt Ihrer DB-Instance an. Wenn Sie einen anderen Port als 1433 verwenden, geben Sie auch diesen an. Der Benutzername und das Passwort entsprechen den Angaben für den Master-Benutzer Ihrer DB-Instance. Die Syntax ist wie folgt.
```
bcp dbname.schema_name.table_name
in C:\table_name.txt -n -S endpoint,port -U master_user_name -P master_user_password -b 10000
```
Um mit dem vorherigen Beispiel fortzufahren, nehmen wir an, dass der Benutzername `admin` und das Passwort `insecure` lauten. Der Endpunkt für diese DB-Instance lautet `rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com` und verwendet Port 4080. Der Befehl lautet wie folgt.
```
bcp store.dbo.customers in C:\customers.txt -n -S rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com,4080 -U admin -P insecure -b 10000
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
## Exportieren von Daten aus RDS für SQL Server
Sie können eine der folgenden Optionen auswählen, um Daten aus einer RDS für SQL-Server-DB-Instance zu exportieren:
+ **Native Datenbanksicherung mithilfe einer vollständigen Sicherungsdatei (BAK)**: Die Verwendung von BAK-Dateien, um Datenbanken zu sichern, ist hochoptimiert und im Normalfall die schnellste Methode, um Daten zu exportieren. Weitere Informationen finden Sie unter [Importieren und Exportieren von SQL-Server-Datenbanken mithilfe nativer Sicherung und Wiederherstellung](SQLServer.Procedural.Importing.md).
+ **SQL Server Import and Export Wizard** – weitere Informationen finden Sie unter [SQL Server-Assistent für Import und Export (SQL Server Import and Export Wizard)](#SQLServer.Procedural.Exporting.SSIEW).
+ **SQL Server Generate and Publish Scripts Wizard und bcp-Hilfsprogramm**: Weitere Informationen finden Sie unter [SQL Server-Assistent für das Generieren und Veröffentlichen von Skripts und Hilfsprogramm bcp](#SQLServer.Procedural.Exporting.SSGPSW).
### SQL Server-Assistent für Import und Export (SQL Server Import and Export Wizard)
Sie können den SQL Server-Assistenten für Import und Export verwenden, um eine oder mehrere Tabellen, Ansichten oder Abfragen aus Ihrer RDS für SQL-Server-DB-Instance in einen anderen Datenspeicher zu kopieren. Dies ist die beste Wahl, wenn sich der Ziel-Datenspeicher nicht in SQL Server befindet. Weitere Informationen finden Sie unter [ SQL Server Import and Export Wizard](http://msdn.microsoft.com/en-us/library/ms141209%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
Der SQL Server-Assistent für Import und Export ist als Teil von Microsoft SQL Server Management Studio verfügbar. Dieser grafische SQL Server-Client ist in allen Microsoft SQL Server-Editionen außer in der Express Edition enthalten. SQL Server Management Studio ist nur als Windows-basierte Anwendung verfügbar. SQL Server Management Studio Express von Microsoft ist als kostenloser Download verfügbar. Sie finden diesen Download auf der [Microsoft-Website](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**So verwenden Sie SQL Server-Assistent für Import und Export, um Daten zu exportieren**
1. Stellen Sie in SQL Server Management Studio eine Verbindung mit Ihrer RDS für SQL-Server-DB-Instance her. Weitere detaillierte Informationen hierzu finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. Erweitern Sie im **Object Explorer** (Objektexplorer) den Abschnitt **Datenbanken**, öffnen Sie das Kontextmenü (rechter Mausklick) für die Quelldatenbank, wählen Sie **Aufgaben** und anschließend **Export Data** (Daten exportieren) aus. Der Assistent wird angezeigt.
1. Öffnen Sie die Seite **Choose a Data Source** (Datenquelle auswählen) und führen Sie folgende Schritte durch:
1. Wählen Sie für **Datenquelle** **SQL Server Native Client 11.0** aus.
1. Stellen Sie sicher, dass das Feld **Server name (Servername)** den Endpunkt Ihrer RDS für SQL-Server-DB-Instance anzeigt.
1. Wählen Sie **Use SQL Server Authentication (SQL Server-Authentifizierung verwenden)** aus. Geben Sie für **Benutzername** und **Passwort** den Hauptbenutzernamen und das Hauptpasswort Ihrer DB-Instance ein.
1. Stellen Sie sicher, dass das Feld **Datenbank** die Datenbank anzeigt, von der Sie Daten exportieren möchten.
1. Wählen Sie **Weiter**.
1. Führen Sie auf der Seite **Choose a Destination** (Ziel auswählen) folgende Schritte durch:
1. Geben Sie für **Ziel** die Zeichenfolge **SQL Server Native Client 11.0** an.
**Anmerkung**
Es sind weitere Zieldatenquellen verfügbar. Dazu gehören: .NET Framework-Datenanbieter, OLE DB-Anbieter, SQL Server Native Client-Anbieter, ADO.NET-Anbieter, Microsoft Office Excel, Microsoft Office Access und die Flat File-Quelle. Wenn Sie eine dieser Datenquellen auswählen, überspringen Sie den Rest von Schritt 4. Einzelheiten zu den Verbindungsinformationen, die als Nächstes anzugeben sind, finden Sie unter [Auswählen eines Ziels](http://msdn.microsoft.com/en-us/library/ms178430%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. Geben Sie für **Servername** den Servernamen der SQL Server-DB-Ziel-Instance an.
1. Wählen Sie den angemessenen Authentifizierungstyp aus. Geben Sie einen Benutzernamen und Passwort ein, wenn nötig.
1. Wählen Sie für **Datenbank** den Namen der Zieldatenbank aus oder wählen Sie **Neu** aus, um eine neue Datenbank zu erstellen, in die die exportierten Daten gespeichert werden.
Wenn Sie **New (Neu)** auswählen, finden Sie unter [Datenbank erstellen](http://msdn.microsoft.com/en-us/library/ms183323%28v=sql.110%29.aspx) in der SQL Server-Dokumentation weitere Einzelheiten über bereitzustellende Datenbankinformationen.
1. Wählen Sie **Weiter**.
1. Wählen Sie auf der Seite **Table Copy or Query** (Tabellenkopie oder -abfrage) die Option **Copy data from one or more tables or views** (Daten von einer oder mehreren Tabellen oder Ansichten kopieren) oder **Write a query to specify the data to transfer** (Anfrage zur Spezifizierung der Transferdaten schreiben) aus. Wählen Sie **Weiter**.
1. Wenn Sie **Write a query to specify the data to transfer** (Anfrage zur Spezifizierung der Transferdaten schreiben) auswählen, wird die Seite **Provide a Source Query** (Quellabfrage bereitstellen) angezeigt. Kopieren oder tippen Sie eine SQL-Abfrage ein und wählen Sie anschließend **Parse** (Parsen) aus, um sie zu überprüfen. Wenn die Abfrage bestätigt ist, klicken Sie auf **Weiter**.
1. Führen Sie auf der Seite **Select Source Tables and Views** (Quelltabellen oder -ansichten auswählen) die folgenden Schritte durch:
1. Wählen Sie die Tabellen und Ansichten, die Sie exportieren möchten, aus oder überprüfen Sie, dass die Abfrage, die sie getätigt haben, ausgewählt ist.
1. Wählen Sie **Edit Mappings** (Zuweisungen bearbeiten) aus und geben Sie die Datenbank- und Spaltenzuweisungsinformationen an. Weitere Informationen finden Sie unter [Spaltenzuordnungen](http://msdn.microsoft.com/en-us/library/ms189660%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. (Optional) Wählen Sie die Tabelle, Ansicht oder Abfrage aus und klicken Sie anschließend auf **Preview (Vorversion)**, um eine Vorversion der zu exportierenden Daten anzuzeigen.
1. Wählen Sie **Weiter**.
1. Auf der Seite **Run Package** (Paket ausführen) muss **Run immediately** (Sofort ausführen) ausgewählt sein. Wählen Sie **Weiter**.
1. Überprüfen Sie auf der Seite **Complete the Wizard** (Assistenten abschließen), dass die Details zum Datenexport wie erwartet sind. Wählen Sie **Finish** (Abschließen).
1. Wählen Sie auf der Seite **The execution was successful** (Ausführung erfolgreich) die Option **Schließen** aus.
### SQL Server-Assistent für das Generieren und Veröffentlichen von Skripts und Hilfsprogramm bcp
Sie können den SQL Server-Assistenten für das Generieren und Veröffentlichen von Skripts verwenden, um Skripts für eine gesamte Datenbank oder nur für ausgewählte Objekte zu erstellen. Sie können diese Skripts auf einer Ziel-SQL Server-DB-Instance ausführen, um die geskripteten Objekte neu zu erstellen. Sie können anschließend das Hilfsprogramm bcp verwenden, um einen Bulk-Export der Daten für die ausgewählten Objekte in die Ziel-DB-Instance durchzuführen. Diese Methode ist die beste Wahl, wenn Sie eine gesamte Datenbank (einschließlich Objekten, die keine Tabellen sind) oder große Datenmengen zwischen zwei SQL Server-DB-Instances verschieben möchten. Eine vollständige Beschreibung der bcp-Befehlszeilensyntax finden Sie unter [bcp-Dienstprogramm](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.110%29.aspx) in der Microsoft SQL Server-Dokumentation.
Der SQL Server-Assistent zum Generieren und Veröffentlichen von Skripts ist als Teil von Microsoft SQL Server Management Studio verfügbar. Dieser grafische SQL Server-Client ist in allen Microsoft SQL Server-Editionen außer in der Express Edition enthalten. SQL Server Management Studio ist nur als Windows-basierte Anwendung verfügbar. SQL Server Management Studio Express von Microsoft ist als [kostenloser Download](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio) verfügbar.
**So können Sie den SQL Server-Assistenten für das Generieren und Veröffentlichen von Skripts und das Hilfsprogramm bcp für einen Datenexport verwenden**
1. Stellen Sie in SQL Server Management Studio eine Verbindung mit Ihrer RDS für SQL-DB-Instance her. Weitere detaillierte Informationen hierzu finden Sie unter [Herstellen einer Verbindung mit Ihrer DB-Instance von Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. Erweitern Sie in **Object Explorer** (Objektexplorer) den Knotenpunkt **Datenbanken** und wählen Sie die Datenbank aus, die Sie skripten möchten.
1. Folgen Sie den Anweisungen in [Assistent zum Generieren und Veröffentlichen von Skripts](http://msdn.microsoft.com/en-us/library/bb895179%28v=sql.110%29.aspx) in der SQL Server-Dokumentation, um eine Skriptdatei zu erstellen.
1. Verbinden Sie sich in SQL Server Management Studio mit Ihrer Ziel-SQL Server-DB-Instance.
1. Mit ausgewählter SQL Server-DB-Ziel-Instance im **Object Explorer (Objektexplorer)** wählen Sie im Menü **File (Datei)** die Option **Open (Öffnen)** aus, wählen Sie **File (Datei)** und öffnen Sie die Skriptdatei.
1. Wenn Sie für die gesamte Datenbank ein Skript erstellt haben, prüfen Sie die Anweisung CREATE DATABASE im Skript. Stellen Sie sicher, dass die Datenbank an dem von Ihnen gewünschten Speicherort und mit den korrekten Parametern erstellt wird. Weitere Informationen finden Sie unter [CREATE DATABASE](http://msdn.microsoft.com/en-us/library/ms176061%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. Wenn Sie im Skript Benutzer für die Datenbank erstellen, überprüfen Sie, ob bereits Serveranmeldedaten in der Ziel-DB-Instance für diese Benutzer vorhanden sind. Wenn dies nicht der Fall ist, erstellen Sie Anmeldedaten für diese Benutzer. Andernfalls werden die geskripteten Befehle für das Erstellen der Datenbankbenutzer fehlschlagen. Weitere Informationen finden Sie unter [Erstellen eines Anmeldenamens](http://msdn.microsoft.com/en-us/library/aa337562%28v=sql.110%29.aspx) in der SQL Server-Dokumentation.
1. Wählen Sie im SQL-Editor-Menü **\$1Execute** aus, um die Skriptdatei auszuführen und die Datenbankobjekte zu erstellen. Sobald das Skript abgeschlossen ist, überprüfen Sie, dass alle Datenbankobjekte wie erwartet vorhanden sind.
1. Verwenden Sie das Hilfsprogramm bcp, um Daten aus der RDS für SQL-Server-DB-Instance in Dateien zu exportieren. Öffnen Sie eine Eingabeaufforderung und geben Sie den folgenden Befehl ein.
```
bcp database_name.schema_name.table_name out data_file -n -S aws_rds_sql_endpoint -U username -P password
```
Der vorherige Code beinhaltet die folgenden Optionen:
+ *table\$1name* ist der Name einer der Tabellen, die Sie in der Zieldatenbank neu erstellt haben und die jetzt mit Daten versehen wird.
+ *data\$1file* ist der vollständige Pfad und Name der Datei, die erstellt werden soll.
+ `-n` gibt an, dass eine Massenkopie die nativen Datentypen der Daten verwendet, die zu kopieren sind.
+ `-S` gibt die SQL Server-DB-Instance an, aus der exportiert werden soll.
+ `-U` gibt den zu verwendenden Benutzernamen an, wenn eine Verbindung mit der SQL Server-DB-Instance hergestellt wird.
+ `-P` gibt das Passwort für den Benutzer an `-U`.
Im Folgenden wird ein Beispielbefehl gezeigt.
```
bcp world.dbo.city out C:\Users\JohnDoe\city.dat -n -S sql-jdoe.1234abcd.us-west-2.rds.amazonaws.com,1433 -U JohnDoe -P ClearTextPassword
```
Wiederholen Sie diesen Schritt, bis Sie Dateien für alle Tabellen haben, die Sie exportieren möchten.
1. Bereiten Sie Ihre DB-Ziel-Instance für den Massenimport von Daten mithilfe der Anweisungen unter [Vorbereiten des Massenimports von Daten](http://msdn.microsoft.com/en-us/library/ms189989%28v=sql.110%29.aspx) in der SQL Server-Dokumentation vor.
1. Entscheiden Sie sich für eine Methode zum Massenimport, nachdem Sie die Leistung und andere wichtige Faktoren eingeschätzt haben, die unter [Informationen zu Massenimport- und Massenexportvorgängen](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx) in der SQL Server-Dokumentation aufgeführt werden.
1. Führen Sie einen Massenimport der Daten aus den mit dem bcp-Hilfsprogramm erstellten Datendateien aus. Befolgen Sie hierzu die Anweisungen unter [Im- und Exportieren von Massendaten mithilfe des Dienstprogramms bcp](http://msdn.microsoft.com/en-us/library/aa337544%28v=sql.110%29.aspx) oder [Importieren von Massendaten mithilfe von BULK INSERT oder OPENROWSET(BULK...)](http://msdn.microsoft.com/en-us/library/ms175915%28v=sql.110%29.aspx) in der SQL Server-Dokumentation, abhängig von Ihrer Entscheidung in Schritt 11.
# Verwenden des BCP-Dienstprogramms von Linux zum Importieren und Exportieren von Daten
Das BCP-Dienstprogramm bietet eine effiziente Möglichkeit, große Datenmengen zwischen Ihrer DB-Instance von RDS für SQL Server und Datendateien zu übertragen. Sie können BCP von Linux-Umgebungen aus verwenden, um Massendatenoperationen durchzuführen. Dies ist für Datenmigrationen, ETL-Prozesse und regelmäßige Datenübertragungen nützlich.
BCP unterstützt sowohl das Importieren von Daten aus Dateien in SQL-Server-Tabellen als auch das Exportieren von Daten aus SQL-Server-Tabellen in Dateien. Dies ist besonders effektiv für die Übertragung strukturierter Daten in verschiedenen Formaten, einschließlich Textdateien mit Trennzeichen.
## Voraussetzungen
Bevor Sie BCP mit Ihrer DB-Instance von RDS für SQL Server verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Eine Linux-Umgebung mit Netzwerkverbindung zu Ihrer DB-Instance von RDS für SQL Server
+ Befehlszeilen-Tools von Microsoft SQL Server, die auf Ihrem Linux-System installiert sind, einschließlich:
+ sqlcmd: Befehlszeilen-Abfrage-Tool von SQL Server
+ bcp: Dienstprogramm zum Massenkopieren
+ Gültige Anmeldeinformationen für Ihre DB-Instance von RDS für SQL Server
+ Netzwerkzugriff, der über Sicherheitsgruppen konfiguriert wird, um Verbindungen über den SQL-Server-Port zuzulassen (normalerweise 1433)
+ Geeignete Datenbankberechtigungen für die Operationen, die Sie ausführen möchten
## Installieren der Befehlszeilen-Tools von SQL Server unter Linux
Um BCP von Linux aus zu verwenden, müssen Sie die Befehlszeilen-Tools von Microsoft SQL Server installieren. Detaillierte Installationsanleitungen für Ihre spezifische Linux-Distribution finden Sie in der folgenden Microsoft-Dokumentation:
+ [Install sqlcmd and bcp the SQL Server command-line tools on Linux](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-tools)
+ [bcp utility](https://docs.microsoft.com/en-us/sql/tools/bcp-utility) – Vollständige Referenz für das BCP-Dienstprogramm
Stellen Sie nach der Installation sicher, dass die Tools in Ihrem PATH verfügbar sind, indem Sie folgenden Befehl ausführen:
```
bcp -v
sqlcmd -?
```
## Exportieren von Daten aus RDS für SQL Server
Sie können BCP verwenden, um Daten aus Ihrer DB-Instance von RDS für SQL Server in Dateien auf Ihrem Linux-System zu exportieren. Dies ist nützlich, um Backups zu erstellen, Daten zu analysieren oder Daten für die Migration vorzubereiten.
### Grundlegende Syntax für den Export
Die grundlegende Syntax für den Export von Daten mit BCP lautet:
```
bcp database.schema.table out output_file -S server_name -U username -P password [options]
```
Wobei gilt:
+ `database.schema.table` – Vollständig qualifizierter Tabellenname
+ `output_file` – Pfad und Name der Ausgabedatei
+ `server_name` – Ihr Endpunkt von RDS für SQL Server
+ `username` – Ihr Datenbankbenutzername
+ `password` – Ihr Datenbankpasswort
### Exportbeispiel
Das folgende Beispiel exportiert Daten aus einer Tabelle namens `customers` in der Datenbank `sales`:
```
bcp sales.dbo.customers out /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n"
```
Dieser Befehl:
+ exportiert Daten aus der Tabelle `customers`
+ speichert die Ausgabe unter `/home/user/customers.txt`
+ verwendet das Zeichenformat (`-c`)
+ verwendet Pipe (\$1) als Feldtrennzeichen (`-t "|"`)
+ verwendet Newline als Zeilentrennzeichen (`-r "\n"`)
## Importieren von Daten in RDS für SQL Server
Sie können BCP verwenden, um Daten aus Dateien auf Ihrem Linux-System in Ihre DB-Instance von RDS für SQL Server zu importieren. Dies ist nützlich für die Datenmigration, das Laden von Testdaten oder regelmäßige Datenaktualisierungen.
### Grundlegende Syntax für den Import
Die grundlegende Syntax für den Import von Daten mit BCP lautet:
```
bcp database.schema.table in input_file -S server_name -U username -P password [options]
```
Wobei gilt:
+ `database.schema.table` – Vollständig qualifizierter Name der Zieltabelle
+ `input_file` – Pfad und Name der Eingabedatei
+ `server_name` – Ihr Endpunkt von RDS für SQL Server
+ `username` – Ihr Datenbankbenutzername
+ `password` – Ihr Datenbankpasswort
### Importbeispiel
Das folgende Beispiel importiert Daten aus einer Datei in eine Tabelle namens `customers`:
```
bcp sales.dbo.customers in /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n" \
-b 1000
```
Dieser Befehl:
+ importiert Daten in die `customers`-Tabelle
+ liest Daten aus `/home/user/customers.txt`
+ verwendet das Zeichenformat (`-c`)
+ verwendet Pipe (\$1) als Feldtrennzeichen (`-t "|"`)
+ verwendet Newline als Zeilentrennzeichen (`-r "\n"`)
+ verarbeitet Daten in Stapeln von 1 000 Zeilen (`-b 1000`)
## Allgemeine BCP-Optionen
BCP bietet zahlreiche Optionen zur Steuerung der Datenformatierung und des Übertragungsverhaltens. Die folgende Tabelle beschreibt häufig verwendete Optionen:
| Option | Beschreibung |
| --- | --- |
| -c | Verwendet den Zeichendatentyp für alle Spalten |
| -n | Verwendet native Datenbank-Datentypen |
| -t | Gibt das Feldtrennzeichen an (Standard ist Tab) |
| -r | Gibt das Zeilentrennzeichen an (Standard ist Newline) |
| -b | Gibt die Stapelgröße für Massenoperationen an |
| -F | Gibt die erste Zeile an, die exportiert oder importiert werden soll |
| -L | Gibt die letzte Zeile an, die exportiert oder importiert werden soll |
| -e | Gibt eine Fehlerdatei zum Erfassen abgelehnter Zeilen an |
| -f | Gibt eine Formatdatei für die Datenformatierung an |
| -q | Verwendet Bezeichner in Anführungszeichen für Objektnamen |
## Bewährte Methoden und Überlegungen
Wenn Sie BCP mit RDS für SQL Server von Linux aus verwenden, sollten Sie die folgenden bewährte Methoden beachten:
+ **Stapelverarbeitung verwenden** – Verwenden Sie bei großen Datensätzen die Option `-b`, um Daten stapelweise zu verarbeiten. Dies verbessert die Leistung und ermöglicht eine bessere Wiederherstellung nach Fehlern.
+ **Fehler ordnungsgemäß behandeln** – Verwenden Sie die Option `-e`, um Fehlerinformationen und abgelehnte Zeilen zur Analyse in einer separaten Datei zu erfassen.
+ **Geeignete Datenformate wählen** – Verwenden Sie das Zeichenformat (`-c`) für plattformübergreifende Kompatibilität oder das native Format (`-n`) für eine bessere Leistung, wenn sowohl Quelle als auch Ziel SQL Server sind.
+ **Anmeldeinformationen schützen** – Vermeiden Sie es, Passwörter direkt in Befehlszeilen einzugeben. Erwägen Sie die Verwendung von Umgebungsvariablen oder Konfigurationsdateien mit entsprechenden Berechtigungen.
+ **Mit kleinen Datensätzen testen** – Bevor Sie große Datenmengen verarbeiten, testen Sie Ihre BCP-Befehle mit kleineren Datensätzen, um die Formatierung und Konnektivität zu überprüfen.
+ **Netzwerkkonnektivität überwachen** – Sorgen Sie für stabile Netzwerkverbindungen, insbesondere bei großen Datenübertragungen. Erwägen Sie die Verwendung von Tools wie `screen` oder `tmux` für lang andauernde Operationen.
+ **Datenintegrität validieren** – Überprüfen Sie nach der Datenübertragung die Zeilenanzahl und Daten stichprobenartig, um sicherzustellen, dass der Vorgang erfolgreich abgeschlossen wurde.
## Behebung häufiger Probleme
In der folgenden Tabelle werden häufig auftretende Probleme beschrieben, die bei der Verwendung von BCP unter Linux auftreten können, sowie deren Lösungen:
| Problem | Lösung |
| --- | --- |
| Verbindungs-Timeout oder Netzwerkfehler | Überprüfen Sie Ihren Amazon-RDS-Endpunkt, Ihre Sicherheitsgruppeneinstellungen und Ihre Netzwerkkonnektivität. Stellen Sie sicher, dass der SQL-Server-Port (normalerweise 1433) von Ihrem Linux-System aus zugänglich ist. |
| Authentication failures (Authentifizierungsfehler) | Überprüfen Sie Ihren Benutzernamen und Ihr Passwort. Stellen Sie sicher, dass der Datenbankbenutzer über die entsprechenden Berechtigungen für die von Ihnen ausgeführten Operationen verfügt. |
| Datenformatfehler | Überprüfen Sie Ihre Feld- und Zeilentrennzeichen. Stellen Sie sicher, dass das Datenformat den Erwartungen von BCP entspricht. Verwenden Sie Formatdateien für komplexe Datenstrukturen. |
| Fehler bei abgelehnter Berechtigung | Stellen Sie sicher, dass Ihr Datenbankbenutzer über INSERT-Berechtigungen für Importe oder SELECT-Berechtigungen für Exporte in den Zieltabellen verfügt. |
| Probleme mit der Handhabung großer Dateien | Verwenden Sie die Stapelverarbeitung mit der Option -b. Erwägen Sie, große Dateien in kleinere Teile aufzuteilen, um die Leistung zu verbessern und Fehler zu beheben. |
| Probleme mit der Zeichenkodierung | Stellen Sie sicher, dass Ihre Datendateien eine kompatible Zeichenkodierung verwenden. Verwenden Sie die Option -c für das Zeichenformat oder geben Sie die entsprechenden Codepages an. |