

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.

# Integration einer Amazon RDS für SQL Server-DB-Instance mit Amazon S3
<a name="User.SQLServer.Options.S3-integration"></a>

Sie können Dateien zwischen einer DB-Instance mit Amazon RDS für SQL Server und einem Amazon S3-Bucket übertragen. Dabei können Sie Amazon S3 mit SQL Server-Funktionen wie etwa BULK INSERT verwenden. Sie können beispielsweise .csv-, .xml-, .txt- und andere Dateien aus Amazon S3 zum Host der DB-Instance herunterladen und die Daten aus `D:\S3\` in die Datenbank laden. Alle Dateien werden in `D:\S3\` auf der DB-Instance gespeichert.

Die folgenden Einschränkungen gelten:

**Anmerkung**  
Der Datenverkehr zwischen dem RDS-Host und S3 wird über VPC-Endpunkte in RDS intern VPCs für alle SQL Server-Funktionen geleitet, die S3 verwenden. Dieser Datenverkehr verwendet den RDS-Instance-Endpunkt ENI nicht. S3-Bucket-Richtlinien können den RDS-Datenverkehr nicht durch Netzwerkbedingungen einschränken.
+ Dateien im `D:\S3`-Ordner werden nach einem Failover auf Multi-AZ-Instances auf dem Standby-Replikat gelöscht. Weitere Informationen finden Sie unter [Multi-AZ-Einschränkungen für die S3-Integration](#S3-MAZ).
+ Die DB-Instance und der S3-Bucket müssen sich in derselben AWS Region befinden.
+ Wenn Sie mehr als eine S3-Integrationsaufgabe gleichzeitig ausführen, werden die Aufgaben sequenziell und nicht parallel ausgeführt.
**Anmerkung**  
S3-Integrationsaufgaben verwenden dieselbe Warteschlange wie native Backup- und Wiederherstellungsaufgaben. Sie können maximal zwei Aufgaben gleichzeitig in dieser Warteschlange haben. Daher blockieren zwei laufende native Backup- und Wiederherstellungsaufgaben alle S3-Integrationsaufgaben.
+ Sie müssen die S3-Integrationsfunktion auf den wiederhergestellten Instances erneut aktivieren. Die S3-Integration wird nicht von der Quell-Instance auf die wiederhergestellte Instance übertragen. Dateien in `D:\S3` werden auf einer wiederhergestellten Instance gelöscht.
+ Der Download auf die DB-Instance ist auf 100 Dateien begrenzt. Anders ausgedrückt: Es können sich nicht mehr als 100 Dateien in befinde `D:\S3\`.
+ Nur Dateien ohne Dateierweiterungen oder mit den folgenden Dateierweiterungen werden zum Download unterstützt: .abf, .asdatabase, .bcp, .configsettings, .csv, .dat, .deploymentoptions, .deploymenttargets, .fmt, .info, .ispac, .lst, .tbl, .txt, .xml und .xmla.
+ Der S3-Bucket muss denselben Besitzer haben wie die zugehörige Rolle AWS Identity and Access Management (IAM). Daher wird die kontoübergreifende S3-Integration nicht unterstützt.
+ Der S3-Bucket kann nicht für die Öffentlichkeit zugänglich sein.
+ Die Dateigröße für Uploads von RDS auf S3 ist auf 50 GB pro Datei begrenzt.
+ Die Dateigröße für Downloads von S3 auf RDS ist auf das von S3 unterstützte Maximum beschränkt.

**Topics**
+ [Voraussetzungen für die Integration von RDS-for-SQL-Server mit S3](Appendix.SQLServer.Options.S3-integration.preparing.md)
+ [Aktivieren der RDS für SQL Server-Integration mit S3](Appendix.SQLServer.Options.S3-integration.enabling.md)
+ [Übertragen von Dateien zwischen RDS for SQL Server und Amazon S3](Appendix.SQLServer.Options.S3-integration.using.md)
+ [Auflisten von Dateien auf der RDS DB-Instance](Appendix.SQLServer.Options.S3-integration.using.listing-files.md)
+ [Löschen von Dateien auf der RDS DB-Instance](Appendix.SQLServer.Options.S3-integration.using.deleting-files.md)
+ [Überwachung des Status einer Dateiübertragungsaufgabe](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md)
+ [Abbrechen einer Aufgabe](Appendix.SQLServer.Options.S3-integration.canceltasks.md)
+ [Multi-AZ-Einschränkungen für die S3-Integration](#S3-MAZ)
+ [Aktivieren der RDS für SQL Server-Integration mit S3](Appendix.SQLServer.Options.S3-integration.disabling.md)

Weitere Informationen zum Arbeiten mit Dateien in Amazon S3 finden Sie unter [Erste Schritte mit Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3).

# Voraussetzungen für die Integration von RDS-for-SQL-Server mit S3
<a name="Appendix.SQLServer.Options.S3-integration.preparing"></a>

Bevor Sie beginnen, suchen oder erstellen Sie den S3-Bucket, den Sie verwenden möchten. Fügen Sie weiterhin Berechtigungen hinzu, so dass die RDS DB-Instance auf den S3-Bucket zugreifen kann. Zur Konfiguration dieses Zugriffs erstellen Sie eine IAM-Richtlinie und eine IAM-Rolle.

## Konsole
<a name="Appendix.SQLServer.Options.S3-integration.preparing.console"></a>

**So erstellen Sie eine IAM-Richtlinie für den Zugriff auf Amazon S3:**

1. Wählen Sie in der [IAM Management-Konsole](https://console.aws.amazon.com/iam/home?#home) im Navigationsbereich **Policies (Richtlinien)**.

1. Erstellen Sie eine neue Richtlinie, und verwenden Sie die Registerkarte **Visual editor** für die folgenden Schritte.

1. Geben Sie unter **Service** **S3** ein, und wählen Sie dann den **S3**-Service.

1. Wählen Sie unter **Actions (Aktionen)** Folgendes, um den Zugang zu gewähren, den Ihre DB-Instance benötigt.
   + `ListAllMyBuckets` – erforderlich
   + `ListBucket` – erforderlich
   + `GetBucketAcl` – erforderlich
   + `GetBucketLocation` – erforderlich
   + `GetObject` – erforderlich für das Herunterladen von Dateien von S3 zu `D:\S3\`
   + `PutObject` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
   + `ListMultipartUploadParts` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
   + `AbortMultipartUpload` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3

1. Für **Resources (Ressourcen)** hängen die angezeigten Optionen davon ab, welche Aktionen Sie im vorherigen Schritt ausgewählt haben. Möglicherweise sehen Sie Optionen für **Bucket**, **Object (Objekt)** oder beide. Geben Sie für beide den jeweiligen Amazon-Ressourcennamen (ARN) an.

   Geben Sie für **Bucket** den ARN für den Bucket an, den Sie verwenden möchten. Wenn Ihr Bucket beispielsweise den Namen *amzn-s3-demo-bucket* hat, setzen Sie den ARN auf `arn:aws:s3:::amzn-s3-demo-bucket`.

   Geben Sie für **Object (Objekt)** den ARN für den Bucket ein, und wählen Sie dann eine der folgenden Optionen:
   + Um Zugriff auf alle Dateien in dem angegebenen Bucket zu gewähren, wählen Sie **Any (Beliebig)** für **Bucket name (Name des Buckets)** und **Object name (Name des Objekts)**.
   + Um Zugriff auf bestimmte Dateien oder Ordner im Bucket zu gewähren, geben ARNs Sie die spezifischen Buckets und Objekte an, auf die SQL Server zugreifen soll. 

1. Befolgen Sie die Anweisungen in der Konsole, bis Sie die Richtlinie fertig erstellt haben.

   Vorstehendes ist eine verkürzte Anleitung zur Einrichtung einer Richtlinie. Ausführlichere Anweisungen zum Erstellen von IAM-Richtlinien finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.

**So erstellen Sie eine IAM-Rolle, die die IAM-Richtlinie aus der vorherigen Prozedur verwendet:**

1. Wählen Sie in der [IAM Management-Konsole](https://console.aws.amazon.com/iam/home?#home) im Navigationsbereich **Roles (Rollen)**.

1. Erstellen Sie eine neue IAM-Rolle, und wählen Sie die folgenden Optionen, wenn sie in der Konsole angezeigt werden:
   + **AWSService nicht zulässig**
   + **RDS**
   + **RDS – Add Role to Database (Rolle zu Datenbank hinzufügen**

   Wählen Sie dann unten **Next permissions (Nächste Berechtigungen)**.

1. Geben Sie für **Attach permissions policies (Berechtigungsrichtlinien anfügen)** den Namen der vorher erstellten IAM-Richtlinie ein. Wählen Sie dann eine Richtlinie aus der Liste aus.

1. Befolgen Sie die Anweisungen in der Konsole, bis Sie die Rolle fertig erstellt haben.

   Vorstehendes ist eine verkürzte Anleitung zur Einrichtung einer Rolle. Wenn Sie eine ausführlichere Anleitung zum Erstellen einer Rolle wünschen, vgl. [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) im *IAM-Benutzerhandbuch*.

## AWS CLI
<a name="Appendix.SQLServer.Options.S3-integration.preparing.CLI"></a>

Sie können Amazon RDS wie folgt Zugriff auf einen Amazon-S3-Bucket gewähren:

1. Erstellen Sie eine IAM-Richtlinie, die Amazon RDS Zugriff auf einen S3-Bucket gewährt.

1. Erstellen Sie eine IAM-Rolle, die Amazon RDS in Ihrem Auftrag annehmen kann, um auf Ihre S3-Buckets zuzugreifen.

   Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.

1. Fügen Sie die erstellte IAM-Richtlinie der IAM-Rolle an, die Sie erstellt haben.

**So erstellen Sie die -IAM-Richtlinie**

Schließen Sie die jeweiligen Aktionen ein, um den Zugriff zu gewähren, den Ihre DB-Instance erfordert:
+ `ListAllMyBuckets` – erforderlich
+ `ListBucket` – erforderlich
+ `GetBucketAcl` – erforderlich
+ `GetBucketLocation` – erforderlich
+ `GetObject` – erforderlich für das Herunterladen von Dateien von S3 zu `D:\S3\`
+ `PutObject` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
+ `ListMultipartUploadParts` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3
+ `AbortMultipartUpload` – erforderlich für das Hochladen von Dateien von `D:\S3\` zu S3

1. Mit dem folgenden AWS CLI Befehl wird eine IAM-Richtlinie `rds-s3-integration-policy` mit diesen Optionen erstellt. Sie gewährt Zugriff auf einen Bucket namens *amzn-s3-demo-bucket*.  
**Example**  

   Für Linux, macOS oder Unix:

   ```
   aws iam create-policy \
   	 --policy-name rds-s3-integration-policy \
   	 --policy-document '{
   	        "Version": "2012-10-17",		 	 	 
   	        "Statement": [
   	            {
   	                "Effect": "Allow",
   	                "Action": "s3:ListAllMyBuckets",
   	                "Resource": "*"
   	            },
   	            {
   	                "Effect": "Allow",
   	                "Action": [
   	                    "s3:ListBucket",
   	                    "s3:GetBucketAcl",
   	                    "s3:GetBucketLocation"
   	                ],
   	                "Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
   	            },
   	            {
   	                "Effect": "Allow",
   	                "Action": [
   	                    "s3:GetObject",
   	                    "s3:PutObject",
   	                    "s3:ListMultipartUploadParts",
   	                    "s3:AbortMultipartUpload"
   	                ],
   	                "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/key_prefix/*"
   	            }
   	        ]
   	    }'
   ```

   Für Windows:

   Achten Sie darauf, dass Sie die Zeilenenden so ändern, dass Ihre Schnittstelle sie unterstützt (`^` anstelle von `\`). Unter Windows müssen Sie dazu alle doppelten Anführungszeichen mit dem Escape-Zeichen versehe `\`. Um dies für alle Anführungszeichen in JSON zu vermeiden, können Sie sie stattdessen in eine Datei speichern und als Parameter einführen. 

   Erstellen Sie zuerst die `policy.json`-Datei mit der folgenden Berechtigungsrichtlinie:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:ListAllMyBuckets",
               "Resource": "*"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:ListBucket",
                   "s3:GetBucketACL",
                   "s3:GetBucketLocation"
               ],
               "Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:PutObject",
                   "s3:ListMultipartUploadParts",
                   "s3:AbortMultipartUpload"
               ],
               "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/key_prefix/*"
           }
       ]
   }
   ```

------

   Verwenden Sie dann den folgenden Befehl, um die Richtlinie zu erstellen:

   ```
   aws iam create-policy ^
        --policy-name rds-s3-integration-policy ^
        --policy-document file://file_path/assume_role_policy.json
   ```

1. Notieren Sie nach dem Erstellen der Richtlinie den Amazon-Ressourcennamen (ARN) der Richtlinie. Sie benötigen den ARN bei einem späteren Schritt.

**So erstellen Sie die IAM-Rolle**
+ Mit dem folgenden AWS CLI Befehl wird die `rds-s3-integration-role` IAM-Rolle für diesen Zweck erstellt.  
**Example**  

  Für Linux, macOS oder Unix:

  ```
  aws iam create-role \
  	   --role-name rds-s3-integration-role \
  	   --assume-role-policy-document '{
  	     "Version": "2012-10-17",		 	 	 
  	     "Statement": [
  	       {
  	         "Effect": "Allow",
  	         "Principal": {
  	            "Service": "rds.amazonaws.com"
  	          },
  	         "Action": "sts:AssumeRole"
  	       }
  	     ]
  	   }'
  ```

  Für Windows:

  Achten Sie darauf, dass Sie die Zeilenenden so ändern, dass Ihre Schnittstelle sie unterstützt (`^` anstelle von `\`). Unter Windows müssen Sie dazu alle doppelten Anführungszeichen mit dem Escape-Zeichen versehe `\`. Um dies für alle Anführungszeichen in JSON zu vermeiden, können Sie sie stattdessen in eine Datei speichern und als Parameter einführen. 

  Erstellen Sie zuerst die `assume_role_policy.json`-Datei mit der folgenden Richtlinie:

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Principal": {
                  "Service": [
                      "rds.amazonaws.com"
                  ]
              },
              "Action": "sts:AssumeRole"
          }
      ]
  }
  ```

------

  Verwenden Sie anschließend den folgenden Befehl zum Erstellen der IAM-Rolle:

  ```
  aws iam create-role ^
       --role-name rds-s3-integration-role ^
       --assume-role-policy-document file://file_path/assume_role_policy.json
  ```  
**Example die Verwendung des globalen Bedingungskontextschlüssels zum Erstellen der IAM-Rolle**  

  Wir empfehlen die Verwendung der globalen Bedingungskontextschlüssel [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) und [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) in ressourcenbasierten Richtlinien, um die Berechtigungen des Services auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.

  Sie können beide globalen Bedingungskontextschlüssel verwenden und der Wert `aws:SourceArn` enthält die Konto-ID. Stellen Sie in diesen Fällen sicher, dass der Wert `aws:SourceAccount` und das Konto im Wert `aws:SourceArn` dieselbe Konto-ID verwenden, wenn sie in derselben Richtlinienanweisung verwendet werden.
  + Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
  + Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.

  Stellen Sie in der Richtlinie sicher, dass Sie den globalen Bedingungskontextschlüssel `aws:SourceArn` mit dem vollständigen Amazon-Ressourcennamen (ARN) der Ressourcen verwenden, die auf die Rolle zugreifen. Stellen Sie bei der S3-Integration sicher, dass Sie die DB-Instance einbeziehen ARNs, wie im folgenden Beispiel gezeigt.

  Für Linux, macOS oder Unix:

  ```
  aws iam create-role \
  	   --role-name rds-s3-integration-role \
  	   --assume-role-policy-document '{
  	     "Version": "2012-10-17",		 	 	 
  	     "Statement": [
  	       {
  	         "Effect": "Allow",
  	         "Principal": {
  	            "Service": "rds.amazonaws.com"
  	          },
  	         "Action": "sts:AssumeRole",
                  "Condition": {
                      "StringEquals": {
                          "aws:SourceArn":"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
                      }
                  }
  	       }
  	     ]
  	   }'
  ```

  Für Windows:

  Fügen Sie den globalen Bedingungskontextschlüssel zu `assume_role_policy.json` hinzu.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Principal": {
                  "Service": [
                      "rds.amazonaws.com"
                  ]
              },
              "Action": "sts:AssumeRole",
              "Condition": {
                  "StringEquals": {
                      "aws:SourceArn":"arn:aws:rds:Region:my_account_ID:db:db_instance_identifier"
                  }
              }
          }
      ]
  }
  ```

------

**IAM-Richtlinie an die IAM-Rolle anfügen**
+ Mit dem folgenden AWS CLI Befehl wird die Richtlinie an die angegebene `rds-s3-integration-role` Rolle angehängt. Ersetzen Sie `your-policy-arn` durch den Richtlinien-ARN, den Sie im vorherigen Schritt notiert haben.  
**Example**  

  Für Linux, macOS oder Unix:

  ```
  aws iam attach-role-policy \
  	   --policy-arn your-policy-arn \
  	   --role-name rds-s3-integration-role
  ```

  Für Windows:

  ```
  aws iam attach-role-policy ^
  	   --policy-arn your-policy-arn ^
  	   --role-name rds-s3-integration-role
  ```

# Aktivieren der RDS für SQL Server-Integration mit S3
<a name="Appendix.SQLServer.Options.S3-integration.enabling"></a>

Im folgenden Abschnitt erfahren Sie, wie Sie die Amazon S3-Integration mit Amazon RDS für SQL Server aktivieren. Zur Arbeit mit der S3-Integration muss Ihre DB-Instance mit der IAM-Rolle verbunden sein, die Sie vorher erstellt haben, bevor Sie den Funktionsnamenparameter `S3_INTEGRATION` verwenden.

**Anmerkung**  
Um eine IAM-Rolle zu einer DB-Instance hinzufügen zu können, muss der Status der DB-Instance **available (verfügbar)** sein.

## Konsole
<a name="Appendix.SQLServer.Options.S3-integration.enabling.console"></a>

**So ordnen Sie Ihre IAM-Rolle Ihrer DB-Instance zu**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Wählen Sie den Namen der RDS für SQL Server-DB-Instance, um ihre Details anzuzeigen.

1. Wählen Sie auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** im Bereich **Manage IAM roles (IAM-Rollen verwalten)** die IAM-Rolle aus, die unter **Add IAM roles to this instance (IAM-Rollen zu dieser Instance hinzufügen)** hinzugefügt werden soll.

1. Wählen Sie unter **Feature (Funktion)** die Option **S3\$1INTEGRATION** aus.  
![\[Hinzufügen der S3_INTEGRATION-Rolle\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/ora-s3-integration-role.png)

1. Wählen Sie **Rolle hinzufügen**.

## AWS CLI
<a name="Appendix.SQLServer.Options.S3-integration.enabling.cli"></a>

**So fügen Sie die IAM-Rolle der RDS für SQL Server-DB-Instance hinzu:**
+ Der folgende AWS CLI-Befehl fügt Ihre IAM-Rolle einer RDS für SQL Server-DB-Instance mit der Bezeichnung `mydbinstance` hinzu.  
**Example**  

  Für Linux, macOS oder Unix:

  ```
  aws rds add-role-to-db-instance \
  	   --db-instance-identifier mydbinstance \
  	   --feature-name S3_INTEGRATION \
  	   --role-arn your-role-arn
  ```

  Für Windows:

  ```
  aws rds add-role-to-db-instance ^
  	   --db-instance-identifier mydbinstance ^
  	   --feature-name S3_INTEGRATION ^
  	   --role-arn your-role-arn
  ```

  Ersetzen Sie `your-role-arn` durch den Rollen-ARN, den Sie im vorherigen Schritt notiert haben. Für die Option `S3_INTEGRATION` muss `--feature-name` angegeben werden.

# Übertragen von Dateien zwischen RDS for SQL Server und Amazon S3
<a name="Appendix.SQLServer.Options.S3-integration.using"></a>

Sie können gespeicherte Amazon RDS-Prozesse zum Herunterladen und Hochladen von Dateien zwischen Amazon S3 und Ihrer RDS DB-Instance verwenden. Sie können auch gespeicherte Amazon RDS-Prozeduren zum Auflisten und Löschen von Dateien auf der RDS-Instance verwenden.

Die Dateien, die Sie von S3 herunter- und hochladen, werden im Ordner `D:\S3` gespeichert. Dies ist der einzige Ordner, den Sie zum Zugriff auf Ihre Dateien verwenden können. Sie können Ihre Dateien in Unterordnern organisieren, die für Sie erstellt werden, wenn Sie beim Download den Zielordner einschließen.

Einige der gespeicherten Prozesse verlangen, dass Sie einen Amazon-Ressourcennamen (ARN) für Ihren S3-Bucket und die Datei angeben. Das Format für Ihren ARN lautet `arn:aws:s3:::amzn-s3-demo-bucket/file_name`. Amazon S3 benötigt keine Kontonummer oder AWS Region in ARNs.

S3-Integrationsaufgaben werden sequenziell ausgeführt und nutzen dieselbe Warteschlange wie native Sicherungs- und Wiederherstellungsaufgaben. Sie können maximal zwei Aufgaben gleichzeitig in dieser Warteschlange haben. Der Verarbeitungsbeginn für jede Aufgabe kann bis zu fünf Minuten in Anspruch nehmen.

## Herunterladen von Dateien aus einem Amazon S3-Bucket zu einer SQL Server-DB-Instance
<a name="Appendix.SQLServer.Options.S3-integration.using.download"></a>

Verwenden Sie zum Herunterladen von Dateien aus einem S3-Bucket zu einer RDS for SQL Server-DB-Instance die gespeicherte Prozedur Amazon RDS `msdb.dbo.rds_download_from_s3` mit den folgenden Parametern.


| Parametername | Datentyp | Standard | Erforderlich | Beschreibung | 
| --- | --- | --- | --- | --- | 
|  `@s3_arn_of_file`  |  NVARCHAR  |  –  |  Erforderlich  |  Der S3-ARN der herunterzuladenden Datei, zum Beispiel:: `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv`  | 
|  `@rds_file_path`  |  NVARCHAR  |  –  |  Optional  |  Der Dateipfad für die RDS-Instance. Wenn nichts angegeben ist, ist der Dateipfad `D:\S3\<filename in s3>`. RDS unterstützt absolute und relative Pfade. Wenn Sie einen Unterordner erstellen möchten, schließen Sie ihn in den Dateipfad ein.  | 
|  `@overwrite_file`  |  INT  |  0  |  Optional  | Die vorhandene Datei überschreiben:  0 Nicht überschreiben 1 = Überschreiben | 

Sie können Dateien ohne Dateierweiterung und Dateien mit den folgenden Dateierweiterungen herunterladen: .bcp, .csv, .dat, .fmt, .info, .lst, .tbl, .txt und .xml.

**Anmerkung**  
Dateien mit der Dateierweiterung „.ispac“ werden zum Download unterstützt, wenn SQL Server Integration Services aktiviert ist. Weitere Informationen zum Aktivieren von SSIS finden Sie unter [SQL Server Integration Services](Appendix.SQLServer.Options.SSIS.md).  
Dateien mit den folgenden Dateierweiterungen werden für den Download unterstützt, wenn SQL Server Analysis Services aktiviert ist: .abf, .asdatabase, .configsettings, .deploymentoptions, .deploymenttargets und .xmla. Weitere Informationen zum Aktivieren von SSAS finden Sie unter [SQL Server Analysis Services](Appendix.SQLServer.Options.SSAS.md).

Das folgende Beispiel zeigt die gespeicherte Prozedur für den Download von Dateien von S3. 

```
exec msdb.dbo.rds_download_from_s3
	    @s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/bulk_data.csv',
	    @rds_file_path='D:\S3\seed_data\data.csv',
	    @overwrite_file=1;
```

Die Beispieloperation `rds_download_from_s3` erstellt einen Ordner mit der Bezeichnung `seed_data` in `D:\S3\`, wenn der Ordner noch nicht vorhanden ist. Dann lädt das Beispiel die Quelldatei `bulk_data.csv` von S3 zu einer neuen Datei mit der Bezeichnung `data.csv` auf der DB-Instance herunter. Wenn die Datei bereits vorhanden war, wird sie überschrieben, da der Parameter `@overwrite_file` auf `1` gesetzt ist.

## Hochladen von Dateien von einer SQL Server-DB-Instance zu einem Amazon S3-Bucket
<a name="Appendix.SQLServer.Options.S3-integration.using.upload"></a>

Verwenden Sie zum Hochladen von Dateien aus einer RDS for SQL Server-DB-Instance zu einem S3-Bucket die gespeicherte Prozedur Amazon RDS `msdb.dbo.rds_upload_to_s3` mit den folgenden Parametern.


| Parametername | Datentyp | Standard | Erforderlich | Beschreibung | 
| --- | --- | --- | --- | --- | 
|  `@s3_arn_of_file`  |  NVARCHAR  |  –  |  Erforderlich  |  Der S3-ARN der in S3 zu erstellenden Datei, zum Beispiel: `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv`  | 
|  `@rds_file_path`  |  NVARCHAR  |  –  |  Erforderlich  | Der Dateipfad der zu S3 hochzuladenden Datei. Es werden absolute und relative Pfade unterstützt. | 
|  `@overwrite_file`  |  INT  |  –  |  Optional  |  Die vorhandene Datei überschreiben:  0 Nicht überschreiben 1 = Überschreiben  | 

Das folgende Beispiel lädt die Datei mit der Bezeichnung `data.csv` von dem angegebenen Speicherort in `D:\S3\seed_data\` zu einer Datei `new_data.csv` in dem von dem ARN angegebenen S3-Bucket hoch.

```
exec msdb.dbo.rds_upload_to_s3 
		@rds_file_path='D:\S3\seed_data\data.csv',
		@s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/new_data.csv',
		@overwrite_file=1;
```

Wenn die Datei in S3 bereits vorhanden war, wird sie überschrieben, da der Parameter @overwrite\$1file auf gesetzt is `1`.

# Auflisten von Dateien auf der RDS DB-Instance
<a name="Appendix.SQLServer.Options.S3-integration.using.listing-files"></a>

Verwenden Sie zum Auflisten der auf der DB-Instance verfügbaren Dateien eine gespeicherte Prozedur und eine Funktion. Führen Sie zunächst die folgende gespeicherte Prozedur aus, um Dateidetails von den Dateien in zu erfasse `D:\S3\`. 

```
exec msdb.dbo.rds_gather_file_details;
```

Die gespeicherte Prozedur gibt die ID der Aufgabe zurück. Wie andere Aufgaben wird diese gespeicherte Prozedur asynchron ausgeführt. Sobald der Status der Aufgabe `SUCCESS` ist, können Sie die Aufgaben-ID in der `rds_fn_list_file_details`-Funktion verwenden, um die vorhandenen Dateien und Verzeichnisse in D:\$1S3\$1 wie nachfolgend gezeigt aufzulisten.

```
SELECT * FROM msdb.dbo.rds_fn_list_file_details(TASK_ID);
```

Die `rds_fn_list_file_details`-Funktion gibt eine Tabelle mit den folgenden Spalten zurück:


| Ausgabeparameter | Beschreibung | 
| --- | --- | 
| filepath | Absoluter Pfad der Datei (zum Beispie, D:\$1S3\$1mydata.csv) | 
| size\$1in\$1bytes | Dateigröße (in Bytes) | 
| last\$1modified\$1utc | Letztes Änderungsdatum/-uhrzeit im UTC-Format | 
| is\$1directory | Option, die angibt, ob es sich bei dem Element um ein Verzeichnis handelt (true/false). | 

# Löschen von Dateien auf der RDS DB-Instance
<a name="Appendix.SQLServer.Options.S3-integration.using.deleting-files"></a>

Verwenden Sie zum Löschen der auf der DB-Instance verfügbaren Dateien die gespeicherte Prozedur Amazon RDS `msdb.dbo.rds_delete_from_filesystem` mit den folgenden Parametern. 


| Parametername | Datentyp | Standard | Erforderlich | Beschreibung | 
| --- | --- | --- | --- | --- | 
|  `@rds_file_path`  |  NVARCHAR  |  –  |  Erforderlich  | Der Dateipfad der zu löschenden Datei. Es werden absolute und relative Pfade unterstützt.  | 
|  `@force_delete`  |  INT  | 0 |  Optional  |  Zum Löschen eines Verzeichnisses muss diese Markierung eingeschlossen und auf gesetzt werde `1`. `1` = Löschen eines Verzeichnisses Dieser Parameter wird ignoriert, wenn Sie eine Datei löschen.  | 

Zum Löschen eines Verzeichnisses muss `@rds_file_path` mit einem umgekehrten Schrägstrich (`\`) enden, und `@force_delete` muss auf `1` gesetzt sein.

Im folgenden Beispiel wird die Datei gelösch `D:\S3\delete_me.txt`.

```
exec msdb.dbo.rds_delete_from_filesystem
    @rds_file_path='D:\S3\delete_me.txt';
```

Im folgenden Beispiel wird das Verzeichnis gelösch `D:\S3\example_folder\`.

```
exec msdb.dbo.rds_delete_from_filesystem
    @rds_file_path='D:\S3\example_folder\',
    @force_delete=1;
```

# Überwachung des Status einer Dateiübertragungsaufgabe
<a name="Appendix.SQLServer.Options.S3-integration.using.monitortasks"></a>

Rufen Sie zum Nachverfolgen des Status Ihrer S3-Integrationsaufgabe die `rds_fn_task_status`-Funktion auf. Dazu sind zwei Parameter erforderlich. Der erste Parameter sollte immer `NULL` sein, da er sich nicht auf die S3-Integration bezieht. Der zweite Parameter akzeptiert eine Aufgaben-ID.

Um eine Liste aller Aufgaben anzuzeigen, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf `0`, wie im folgenden Beispiel gezeigt.

```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```

Um eine bestimmte Aufgabe zu erhalten, setzen Sie den ersten Parameter auf `NULL` und den zweiten Parameter auf die Aufgaben-ID, wie im folgenden Beispiel gezeigt,

```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```

Die `rds_fn_task_status`-Funktion gibt die folgenden Informationen zurück.


|  Ausgabeparameter  |  Beschreibung  | 
| --- | --- | 
|  `task_id`  |  Die ID der Aufgabe.  | 
|  `task_type`  |  Für die S3-Integration können Aufgaben die folgenden Aufgabentypen haben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html)  | 
|  `database_name`  | Nicht verwendbar für S3-Integrationsaufgaben. | 
|  `% complete`  |  Verlauf der Aufgabe als Prozentwert.  | 
|  `duration(mins)`  |  Zeitdauer für die Ausführung der Aufgabe (in Minuten).  | 
|  `lifecycle`  |  Der Status der Aufgabe. Die folgenden Status sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html)  | 
|  `task_info`  |  Zusätzliche Informationen über die Aufgabe. Wenn bei der Verarbeitung ein Fehler auftritt, enthält diese Spalte Informationen zu dem Fehler.   | 
|  `last_updated`  |  Datum und Uhrzeit der letzten Aktualisierung des Aufgabenstatus.   | 
|  `created_at`  |  Datum und Uhrzeit, an denen die Aufgabe angelegt wurde.  | 
|  `S3_object_arn`  |  Der ARN des S3-Objekts, von dem der Download oder zu dem der Upload stattfand.  | 
|  `overwrite_S3_backup_file`  |  Nicht verwendbar für S3-Integrationsaufgaben.  | 
|  `KMS_master_key_arn`  |  Nicht verwendbar für S3-Integrationsaufgaben.  | 
|  `filepath`  |  Der Dateipfad auf der RDS DB-Instance.  | 
|  `overwrite_file`  |  Eine Option, die anzeigt, ob eine bestehende Datei überschrieben wird.  | 
|  `task_metadata`  |  Nicht verwendbar für S3-Integrationsaufgaben.  | 

# Abbrechen einer Aufgabe
<a name="Appendix.SQLServer.Options.S3-integration.canceltasks"></a>

Verwenden Sie zum Abbrechen von S3-Integrationsaufgaben die gespeicherte `msdb.dbo.rds_cancel_task`-Prozedur mit dem Parameter `task_id`. Laufende Lösch- und Auflistungsaufgaben können nicht abgebrochen werden. Das folgende Beispiel zeigt eine Anforderung zum Abbrechen einer Aufgabe. 

```
exec msdb.dbo.rds_cancel_task @task_id = 1234;
```

Verwenden Sie für die Anzeige einer Übersicht über alle Aufgaben und ihre Aufgaben-IDs die `rds_fn_task_status`-Funktion wie in [Überwachung des Status einer Dateiübertragungsaufgabe](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md) beschrieben.

## Multi-AZ-Einschränkungen für die S3-Integration
<a name="S3-MAZ"></a>

Bei Multi-AZ-Instances werden Dateien im `D:\S3`-Ordner nach einem Failover auf dem Standby-Replikat gelöscht. Ein Failover kann beispielsweise bei Änderungen der DB-Instance geplant werden, z. B. beim Ändern der Instance-Klasse oder beim Aktualisieren der Engine-Version. Oder ein Failover kann während eines Ausfalls der primären Instance ungeplant sein.

**Anmerkung**  
Es wird nicht empfohlen, den `D:\S3`-Ordner für die Dateispeicherung zu verwenden. Die bewährte Methode besteht darin, erstellte Dateien in Amazon S3 hochzuladen, um sie beständig zu machen, und Dateien herunterzuladen, wenn Sie Daten importieren müssen.

Um die letzte Failover-Zeit zu bestimmen, können Sie das gespeicherte `msdb.dbo.rds_failover_time`-Verfahren verwenden. Weitere Informationen finden Sie unter [Ermitteln der letzten Failover-Zeit für Amazon RDS für SQL Server](Appendix.SQLServer.CommonDBATasks.LastFailover.md).

**Example Kein Failover in letzter Zeit**  
Dieses Beispiel zeigt die Ausgabe, wenn in den Fehlerprotokollen kein aktuelles Failover vorhanden ist. Seit 2020-04-29 23:59:00.01 ist kein Failover aufgetreten.  
Daher sind alle nach dieser Zeit heruntergeladenen Dateien, die nicht mit dem gespeicherten `rds_delete_from_filesystem`-Verfahren gelöscht wurden, weiterhin auf dem aktuellen Host verfügbar. Dateien, die vor diesem Zeitpunkt heruntergeladen wurden, sind möglicherweise ebenfalls verfügbar.  


| errorlog\$1available\$1from | recent\$1failover\$1time | 
| --- | --- | 
|  2020-04-29 23:59:00.0100000  |  Null  | 

**Example Failover in letzter Zeit**  
Dieses Beispiel zeigt die Ausgabe, wenn ein Failover in den Fehlerprotokollen vorliegt. Das letzte Failover erfolgte am 2020-05-05 18:57:51.89.  
Auf alle nach dieser Zeit heruntergeladenen Dateien, die nicht mit dem gespeicherten `rds_delete_from_filesystem`-Verfahren gelöscht wurden, kann auf dem aktuellen Host weiterhin zugegriffen werden.  


| errorlog\$1available\$1from | recent\$1failover\$1time | 
| --- | --- | 
|  2020-04-29 23:59:00.0100000  |  2020-05-05 18:57:51.8900000  | 

# Aktivieren der RDS für SQL Server-Integration mit S3
<a name="Appendix.SQLServer.Options.S3-integration.disabling"></a>

Nachfolgend erfahren Sie, wie Sie die Amazon S3-Integration mit Amazon RDS für SQL Server deaktivieren. Dateien in `D:\S3\` werden nicht gelöscht, wenn die S3-Integration deaktiviert wird.

**Anmerkung**  
Um eine IAM-Rolle von einer DB-Instance löschen zu können, muss der Status der DB-Instance sei `available`.

## Konsole
<a name="Appendix.SQLServer.Options.S3-integration.disabling.console"></a>

**So entfernen Sie die Zuweisung Ihrer IAM-Rolle zu DB-Instance:**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Wählen Sie den Namen der RDS für SQL Server-DB-Instance, um ihre Details anzuzeigen.

1. Wählen Sie auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** im Bereich **Manage IAM roles (IAM-Rollen verwalten)** die IAM-Rolle aus, die entfernt werden soll.

1. Wählen Sie **Delete (Löschen)**.

## AWS CLI
<a name="Appendix.SQLServer.Options.S3-integration.disabling.cli"></a>

**So entfernen Sie die IAM-Rolle von der RDS für SQL Server-DB-Instance:**
+ Der folgende AWS CLI-Befehl entfernt die IAM-Rolle von einer RDS für SQL Server-DB-Instance mit der Bezeichnung `mydbinstance`.  
**Example**  

  Für Linux, macOS oder Unix:

  ```
  aws rds remove-role-from-db-instance \
  	   --db-instance-identifier mydbinstance \
  	   --feature-name S3_INTEGRATION \
  	   --role-arn your-role-arn
  ```

  Für Windows:

  ```
  aws rds remove-role-from-db-instance ^
  	   --db-instance-identifier mydbinstance ^
  	   --feature-name S3_INTEGRATION ^
  	   --role-arn your-role-arn
  ```

  Ersetzen Sie `your-role-arn` durch den jeweiligen ARN der IAM-Rolle für die Option `--feature-name`.