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.
# Exportieren von Daten aus einem/einer RDS für PostgreSQL-DB-Instance zu Amazon S3
Sie können Daten aus einer DB-Instance von RDS für PostgreSQL abfragen und direkt in Dateien exportieren, die in einem Amazon-S3-Bucket gespeichert sind. Dazu installieren Sie zuerst die Erweiterung von RDS für PostgreSQL `aws_s3`. Diese Erweiterung stellt die Funktionen bereit, die Sie zum Exportieren von Abfrageergebnissen nach Amazon S3 verwenden. Im Folgenden erfahren Sie, wie Sie die Erweiterung installieren und Daten nach Amazon S3 exportieren.
**Anmerkung**
Kontoübergreifender Export nach Amazon S3 wird nicht unterstützt.
Alle derzeit verfügbaren Versionen von RDS für PostgreSQL unterstützen den Export von Daten nach Amazon Simple Storage Service. Ausführliche Versionsinformationen finden Sie unter [Aktualisierungen von Amazon RDS für PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-versions.html) im Abschnitt *Versionshinweise für Amazon RDS für PostgreSQL*.
Wenn Sie keinen Bucket für Ihren Export eingerichtet haben, lesen Sie die folgenden Themen im *Benutzerhandbuch von Amazon Simple Storage Service*.
+ [Einrichten von Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/setting-up-s3.html)
+ [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)
Standardmäßig verwenden die von RDS für PostgreSQL nach Amazon S3 exportierten Daten eine serverseitige Verschlüsselung mit einem Von AWS verwalteter Schlüssel Wenn Sie die Bucket-Verschlüsselung verwenden, muss der Amazon S3 S3-Bucket mit einem AWS Key Management Service (AWS KMS) -Schlüssel (SSE-KMS) verschlüsselt werden. Derzeit werden Buckets, die mit Schlüsseln verschlüsselt sind, die von Amazon S3 (SSE-S3) verwaltet werden, nicht unterstützt.
**Anmerkung**
Sie können DB-Snapshot-Daten mit der AWS-Managementkonsole AWS CLI, oder Amazon RDS-API in Amazon S3 speichern. Weitere Informationen finden Sie unter [Exportieren von DB-Snapshot-Daten nach Amazon S3 für Amazon RDS](USER_ExportSnapshot.md).
**Topics**
+ [Installieren der Erweiterung aws\$1s3](#USER_PostgreSQL.S3Export.InstallExtension)
+ [Übersicht über das Exportieren von Daten zu Amazon S3](#postgresql-s3-export-overview)
+ [Angeben des Amazon S3-Dateipfads für den Export](#postgresql-s3-export-file)
+ [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](postgresql-s3-export-access-bucket.md)
+ [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md)
+ [Funktionsreferenz](postgresql-s3-export-functions.md)
+ [Fehlerbehebung beim Zugriff auf Amazon S3](postgresql-s3-export-troubleshoot.md)
## Installieren der Erweiterung aws\$1s3
Bevor Sie Amazon Simple Storage Service mit Ihrer DB-Instance von RDS für PostgreSQL verwenden können, müssen Sie die Erweiterung `aws_s3` installieren. Diese Erweiterung bietet Funktionen zum Exportieren von Daten aus einer DB-Instance von RDS für PostgreSQL in einen Amazon-S3-Bucket Sie stellt außerdem Funktionen zum Importieren von Daten aus Amazon S3 bereit. Weitere Informationen finden Sie unter [Importieren von Amazon S3 in eine DB-Instance von RDS für PostgreSQL](USER_PostgreSQL.S3Import.md). Die Erweiterung `aws_s3` hängt von einigen Hilfsfunktionen in der Erweiterung `aws_commons` ab, die bei Bedarf automatisch installiert wird.
**So installieren Sie die Erweiterung `aws_s3`**
1. Verwenden Sie psql (oder pgAdmin), um eine Verbindung mit der DB-Instance von RDS für PostgreSQL als Benutzer mit `rds_superuser`-Berechtigungen herzustellen. Wenn Sie beim Einrichten den Standardnamen beibehalten haben, stellen Sie eine Verbindung als `postgres` her.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Führen Sie den folgenden Befehl aus, um die Erweiterung zu installieren.
```
postgres=> CREATE EXTENSION aws_s3 CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
1. Wenn Sie überprüfen möchten, ob die Erweiterung installiert wurde, können Sie psql-Metabefehl `\dx` verwenden.
```
postgres=> \dx
List of installed extensions
Name | Version | Schema | Description
-------------+---------+------------+---------------------------------------------
aws_commons | 1.2 | public | Common data types across AWS services
aws_s3 | 1.1 | public | AWS S3 extension for importing data from S3
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
(3 rows)
```
Die Funktionen zum Importieren von Daten aus Amazon S3 und Exportieren von Daten nach Amazon S3 sind jetzt verfügbar.
### Stellen Sie sicher, dass Ihre nach Amazon S3 unterstützt
Sie können überprüfen, ob Ihre Version von RDS für PostgreSQL den Export nach Amazon S3 unterstützt, indem Sie den Befehl `describe-db-engine-versions` verwenden. Im folgenden Beispiel wird die Unterstützung für Version 10.14 überprüft.
```
aws rds describe-db-engine-versions --region us-east-1
--engine postgres --engine-version 10.14 | grep s3Export
```
Wenn die Ausgabe die Zeichenfolge `"s3Export"` enthält, unterstützt die Engine Amazon S3-Exporte. Ansonsten unterstützt die Engine sie nicht.
## Übersicht über das Exportieren von Daten zu Amazon S3
Verwenden Sie das folgende Verfahren, um in einer Datenbank gespeicherte Daten in einen Amazon S3 Bucket zu exportieren.
**So exportieren Sie Daten nach S3**
1. Identifizieren Sie einen Amazon S3-Dateipfad, der zum Exportieren von Daten verwendet werden soll. Weitere Informationen zu diesem Prozess finden Sie unter [Angeben des Amazon S3-Dateipfads für den Export](#postgresql-s3-export-file).
1. Erteilen Sie die Berechtigung für den Zugriff auf den Amazon S3-Bucket.
Um Daten in eine Amazon S3-Datei zu exportieren, erteilen Sie dem/der RDS für PostgreSQL-DB-Instance die Berechtigung, auf den Amazon S3-Bucket zuzugreifen, den der Export für die Speicherung verwendet. Dazu gehören die folgenden Schritte:
1. Erstellen Sie eine IAM-Richtlinie, die Zugriff auf einen Amazon S3-Bucket bietet, in den Sie exportieren möchten.
1. Erstellen Sie eine IAM-Rolle.
1. Fügen Sie die erstellte Richtlinie an die erstellte Rolle an.
1. Fügen Sie diese IAM-Rolle zu Ihrem Ihrer DB-Instance hinzu.
Weitere Informationen zu diesem Prozess finden Sie unter [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](postgresql-s3-export-access-bucket.md).
1. Identifizieren Sie eine Datenbankabfrage, um die Daten abzurufen. Exportieren Sie die Abfragedaten, indem Sie die Funktion `aws_s3.query_export_to_s3` aufrufen.
Nachdem Sie die vorangegangenen Vorbereitungsaufgaben abgeschlossen haben, verwenden Sie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion, um Abfrageergebnisse in Amazon S3 zu exportieren. Weitere Informationen zu diesem Prozess finden Sie unter [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
## Angeben des Amazon S3-Dateipfads für den Export
Geben Sie die folgenden Informationen an, um den Speicherort in Amazon S3 zu identifizieren, in den Sie Daten exportieren möchten:
+ Bucket-Name – Ein *Bucket* ist ein Container für Amazon S3-Objekte oder -Dateien.
Weitere Informationen zum Speichern von Daten mit Amazon S3 finden Sie unter [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) und [Arbeiten mit Objekten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-downloading-objects.html) im *Benutzerhandbuch für Amazon Simple Storage Service*.
+ Dateipfad – Der Dateipfad gibt an, wo der Export im Amazon S3-Bucket gespeichert wird. Der Dateipfad besteht aus Folgendem:
+ Ein optionales Pfadpräfix, das einen Pfad für virtuelle Ordner identifiziert.
+ Ein Dateipräfix, das eine oder mehrere Dateien identifiziert, die gespeichert werden sollen. Größere Exporte werden in mehreren Dateien gespeichert, jeweils mit einer maximalen Größe von ca. 6 GB. Die zusätzlichen Dateinamen haben das gleiche Dateipräfix, aber mit `_partXX` angefügt. `XX` stellt 2, dann 3 usw. dar.
Beispielsweise ist ein Dateipfad mit einem `exports`-Ordner und einem `query-1-export`-Dateipräfix `/exports/query-1-export`.
+ AWS Region (optional) — Die AWS Region, in der sich der Amazon S3 S3-Bucket befindet. Wenn Sie keinen AWS Regionswert angeben, speichert Amazon RDS Ihre Dateien in Amazon S3 in derselben AWS Region wie die exportierende .
**Anmerkung**
Derzeit muss die AWS Region mit der Region der exportierenden identisch sein.
Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[Regionen, Availability Zones und Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
Um die Amazon S3-Dateiinformationen darüber zu speichern, wo der Export gespeichert werden soll, können Sie die [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri)-Funktion verwenden, um eine zusammengesetzte `aws_commons._s3_uri_1`-Struktur wie folgt zu erstellen.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Sie geben diesen `s3_uri_1`-Wert später als Parameter im Aufruf der [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion an. Beispiele finden Sie unter [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
# Einrichten des Zugriffs auf einen Amazon-S3-Bucket
Um Daten zu Amazon S3 zu exportieren, erteilen Sie Ihrer PostgreSQL-DB-Instance die Berechtigung, auf den Amazon S3-Bucket zuzugreifen, in den die Dateien aufgenommen werden sollen.
Führen Sie dazu die folgenden Schritte aus.
**So erteilen Sie einer PostgreSQL-DB-Instance Zugriff auf Amazon S3 über eine IAM-Rolle**
1. Erstellen Sie eine IAM-Richtlinie.
Diese Richtlinie enthält die Bucket- und Objektberechtigungen, die Ihrer PostgreSQL-DB-Instance den Zugriff auf Amazon S3 ermöglichen.
Führen Sie beim Erstellen dieser Richtlinie die folgenden Schritte aus:
1. Nehmen Sie die folgenden erforderlichen Aktionen in die Richtlinie auf, um die Übertragung von Dateien aus Ihrer PostgreSQL-DB-Instance in einen Amazon S3-Bucket zu gestatten:
+ `s3:PutObject`
+ `s3:AbortMultipartUpload`
1. Geben Sie den Amazon-Ressourcennamen (ARN) ein, der den Amazon S3-Bucket und die Objekte im Bucket identifiziert. Das ARN-Format für den Zugriff auf Amazon S3 lautet: `arn:aws:s3:::amzn-s3-demo-bucket/*`
Weitere Informationen zum Erstellen einer IAM-Richtlinie für Amazon RDS für PostgreSQL finden Sie unter [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Siehe auch [Tutorial: Erstellen und Anfügen Ihrer ersten vom Kunden verwalteten Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) im *IAM-Benutzerhandbuch*.
Mit dem folgenden AWS CLI Befehl wird eine IAM-Richtlinie `rds-s3-export-policy` mit diesen Optionen erstellt. Sie gewährt Zugriff auf einen Bucket namens *amzn-s3-demo-bucket*.
**Warnung**
Es wird empfohlen, die Datenbank innerhalb einer privaten VPC einzurichten, deren Endpunktrichtlinien für den Zugriff auf bestimmte Buckets konfiguriert sind. Weitere Informationen finden Sie unter [Verwenden von Endpunktrichtlinien für Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html#vpc-endpoints-policies-s3) im Amazon VPC Benutzerhandbuch.
Es wird dringend empfohlen, keine Richtlinie mit Zugriff auf alle Ressourcen zu erstellen. Dieser Zugriff kann eine Bedrohung für die Datensicherheit darstellen. Wenn Sie eine Richtlinie erstellen, die `S3:PutObject` Zugriff auf alle Ressourcen mit `"Resource":"*"` gewährt, kann ein Benutzer mit Exportberechtigungen Daten in alle Buckets in Ihrem Konto exportieren. Darüber hinaus kann der Benutzer Daten in *jeden öffentlich beschreibbaren Bucket in Ihrer AWS -Region* exportieren.
Notieren Sie nach dem Erstellen der Richtlinie den Amazon-Ressourcennamen (ARN) der Richtlinie. Sie benötigen den ARN für einen nachfolgenden Schritt, in dem Sie die Richtlinie an eine IAM-Rolle anhängen.
```
aws iam create-policy --policy-name rds-s3-export-policy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3export",
"Action": [
"s3:PutObject*",
"s3:ListBucket",
"s3:GetObject*",
"s3:DeleteObject*",
"s3:GetBucketLocation",
"s3:AbortMultipartUpload"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
1. Erstellen Sie eine IAM-Rolle.
Sie tun dies, damit Amazon RDS in Ihrem Namen diese IAM-Rolle übernehmen kann, um auf Ihre Amazon 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*.
Wir empfehlen die Verwendung von `[aws:SourceArn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)` und `[aws:SourceAccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)` globaler Bedingungskontext-Schlüssel in ressourcenbasierten Richtlinien, um die Berechtigungen des Dienstes 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.
Wenn Sie sowohl globale Kontextschlüssel nutzen und der `aws:SourceArn`-Wert enthält die Konto-ID, muss der `aws:SourceAccount`-Wert und das Konto im `aws:SourceArn`-Wert die gleiche Konto-ID verwenden, wenn er in der gleichen Richtlinienanweisung verwendet wird.
+ 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.
Verwenden Sie in der Richtlinie den `aws:SourceArn` globalen Kontextschlüssel mit dem vollständigen ARN der Ressource. Das folgende Beispiel zeigt, wie Sie dazu den AWS CLI Befehl verwenden, um eine Rolle mit dem Namen `rds-s3-export-role` zu erstellen.
**Example**
Für Linux, macOS oder Unix:
```
aws iam create-role \
--role-name rds-s3-export-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
Für Windows:
```
aws iam create-role ^
--role-name rds-s3-export-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
1. Fügen Sie die erstellte IAM-Richtlinie der IAM-Rolle an, die Sie erstellt haben.
Mit dem folgenden AWS CLI Befehl wird die zuvor erstellte Richtlinie an die Rolle `rds-s3-export-role.` Replace `your-policy-arn` mit dem Richtlinien-ARN angehängt, den Sie in einem früheren Schritt notiert haben.
```
aws iam attach-role-policy --policy-arn your-policy-arn --role-name rds-s3-export-role
```
1. Fügen Sie die IAM-Rolle der DB Instance hinzu. Sie tun dies, indem Sie das AWS-Managementkonsole oder verwenden AWS CLI, wie im Folgenden beschrieben.
## Konsole
**So fügen Sie eine IAM-Rolle für eine PostgreSQL DB--Instance über die Konsole hinzu:**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie den Namen der PostgreSQL DB--Instance aus, 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 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 **Funktion** die Option **s3Export** aus.
1. Wählen Sie **Rolle hinzufügen**.
## AWS CLI
**So fügen Sie eine IAM-Rolle für eine PostgreSQL-DB-Instance mithilfe der CLI hinzu**
+ Verwenden Sie den folgenden CLI-Befehl, um die IAM-Rolle zur RDS für PostgreSQL DB-Instance mit dem Namen `my-db-instance` hinzuzufügen. Ersetzen Sie *`your-role-arn`* durch den Rollen-ARN, den Sie im vorherigen Schritt notiert haben. Verwenden Sie `s3Export` für den Wert der `--feature-name`-Option.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-role-to-db-instance \
--db-instance-identifier my-db-instance \
--feature-name s3Export \
--role-arn your-role-arn \
--region your-region
```
Für Windows:
```
aws rds add-role-to-db-instance ^
--db-instance-identifier my-db-instance ^
--feature-name s3Export ^
--role-arn your-role-arn ^
--region your-region
```
# Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3
Exportieren Sie Ihre PostgreSQL-Daten nach Amazon S3, indem Sie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion aufrufen.
**Topics**
+ [Voraussetzungen](#postgresql-s3-export-examples-prerequisites)
+ [Aufruf von aws\$1s3.query\$1export\$1to\$1s3](#postgresql-s3-export-examples-basic)
+ [Exportieren in eine CSV-Datei, die ein benutzerdefiniertes Trennzeichen verwendet](#postgresql-s3-export-examples-custom-delimiter)
+ [Exportieren in eine Binärdatei mit Codierung](#postgresql-s3-export-examples-encoded)
## Voraussetzungen
Bevor Sie die `aws_s3.query_export_to_s3`-Funktion verwenden, müssen Sie die folgenden Voraussetzungen erfüllen:
+ Installieren Sie die erforderlichen PostgreSQL-Erweiterungen, wie unter beschriebe [Übersicht über das Exportieren von Daten zu Amazon S3](postgresql-s3-export.md#postgresql-s3-export-overview).
+ Legen Sie fest, wohin die Daten nach Amazon S3 exportiert werden sollen, wie unter beschriebe [Angeben des Amazon S3-Dateipfads für den Export](postgresql-s3-export.md#postgresql-s3-export-file).
+ Stellen Sie sicher, dass die Exportzugriff auf Amazon S3 hat (wie unter [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](postgresql-s3-export-access-bucket.md) beschrieben).
In den folgenden Beispielen wird eine Datenbanktabelle namens verwende `sample_table`. In diesen Beispielen werden die Daten in einen Bucket namens exportier *amzn-s3-demo-bucket*. Die Beispieltabelle und die Daten werden mit den folgenden SQL-Anweisungen in psql erstellt.
```
psql=> CREATE TABLE sample_table (bid bigint PRIMARY KEY, name varchar(80));
psql=> INSERT INTO sample_table (bid,name) VALUES (1, 'Monday'), (2,'Tuesday'), (3, 'Wednesday');
```
## Aufruf von aws\$1s3.query\$1export\$1to\$1s3
Im Folgenden werden die grundlegenden Möglichkeiten zum Aufrufen der [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion dargestellt.
In diesen Beispielen wird die Variable `s3_uri_1` zum Identifizieren einer Struktur verwendet, die die Informationen zur Identifizierung der Amazon S3-Datei enthält. Verwenden Sie die Funktion [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri), um die Struktur zu erstellen.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Obwohl die Parameter für die folgenden zwei `aws_s3.query_export_to_s3`-Funktionsaufrufe unterschiedlich sind, sind die Ergebnisse für diese Beispiele identisch. Alle Zeilen der `sample_table`-Tabelle werden in einen Bucket namens *amzn-s3-demo-bucket* exportiert.
```
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1');
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1', options :='format text');
```
Die Parameter werden wie folgt beschrieben:
+ `'SELECT * FROM sample_table'` – Der erste Parameter ist eine erforderliche Textzeichenfolge, die eine SQL-Abfrage enthält. Die PostgreSQL-Engine führt diese Abfrage aus. Die Ergebnisse der Abfrage werden in den S3-Bucket kopiert, der in anderen Parametern identifiziert wurde.
+ `:'s3_uri_1'` – Dieser Parameter ist eine Struktur, die die Datei Amazon S3 identifiziert. In diesem Beispiel wird die zuvor erstellte Struktur anhand einer Variablen identifiziert. Sie können die Struktur stattdessen erstellen, indem Sie den Funktionsaufruf `aws_commons.create_s3_uri` wie folgt inline in den Funktionsaufruf `aws_s3.query_export_to_s3` einschließen.
```
SELECT * from aws_s3.query_export_to_s3('select * from sample_table',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'sample-filepath', 'us-west-2')
);
```
+ `options :='format text'` – Der `options`-Parameter ist eine optionale Textzeichenfolge, die `COPY`-PostgreSQL-Argumente enthält. Beim Kopiervorgang werden die Argumente und das Format des [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html)-Befehls verwendet.
Wenn die angegebene Datei nicht im Amazon S3-Bucket vorhanden ist, wird sie erstellt. Wenn die Datei bereits vorhanden ist, wird sie überschrieben. Die Syntax für den Zugriff auf die exportierten Daten in Amazon S3 ist die folgende.
```
s3-region://bucket-name[/path-prefix]/file-prefix
```
Größere Exporte werden in mehreren Dateien gespeichert, jeweils mit einer maximalen Größe von ca. 6 GB. Die zusätzlichen Dateinamen haben das gleiche Dateipräfix, aber mit `_partXX` angefügt. `XX` stellt 2, dann 3 usw. dar. Angenommen, Sie geben den Pfad, in dem Sie Datendateien speichern, wie folgt an.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
```
Wenn der Export drei Datendateien anlegen muss, enthält der Amazon S3-Bucket die folgenden Datendateien.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part2
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part3
```
Die vollständige Referenz für diese Funktion und weitere Aufrufmöglichkeiten finden Sie unter [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Weitere Informationen zum Zugriff auf Dateien in Amazon S3 finden Sie unter [View an object](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) im *Amazon Simple Storage Service User Guide.*
## Exportieren in eine CSV-Datei, die ein benutzerdefiniertes Trennzeichen verwendet
Das folgende Beispiel zeigt, wie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion zum Exportieren von Daten in eine Datei aufgerufen wird, die ein benutzerdefiniertes Trennzeichen verwendet. Im Beispiel werden Argumente des Befehls [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html) verwendet, um das CSV-Dateiformat (durch Kommas getrennte Werte) und ein Doppelpunkt (:)-Trennzeichen anzugeben.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format csv, delimiter $$:$$');
```
## Exportieren in eine Binärdatei mit Codierung
Das folgende Beispiel zeigt, wie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion zum Exportieren von Daten in eine Binärdatei mit Windows-1253-Codierung aufgerufen wird.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format binary, encoding WIN1253');
```
# Funktionsreferenz
**Topics**
+ [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3)
+ [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri)
## aws\$1s3.query\$1export\$1to\$1s3
Exportiert ein PostgreSQL-Abfrageergebnis in einen Amazon S3-Bucket. Die Erweiterung `aws_s3` stellt die Funktion `aws_s3.query_export_to_s3` bereit.
Die zwei erforderlichen Parameter sind `query` und `s3_info`. Diese definieren die zu exportierende Abfrage und identifizieren den Amazon S3-Bucket, in den exportiert werden soll. Ein optionaler Parameter namens `options` ermöglicht die Definition verschiedener Exportparameter. Beispiele für die Verwendung der `aws_s3.query_export_to_s3`-Funktion finden Sie unter [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
**Syntax**
```
aws_s3.query_export_to_s3(
query text,
s3_info aws_commons._s3_uri_1,
options text,
kms_key text
)
```Eingabeparameter
*query*
Eine erforderliche Textzeichenfolge, die eine SQL-Abfrage enthält, die von der PostgreSQL-Engine ausgeführt wird. Die Ergebnisse dieser Abfrage werden in einen S3-Bucket kopiert, der im `s3_info`-Parameter identifiziert wurde.
*s3\$1info*
Ein zusammengesetzter `aws_commons._s3_uri_1`-Typ mit den folgenden Informationen zum S3-Objekt:
+ `bucket` – Der Name des Amazon S3-Buckets, der die Datei enthalten soll.
+ `file_path` – Der Amazon S3-Dateiname und der -Pfad.
+ `region`— Die AWS Region, in der sich der Bucket befindet. Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[Regionen, Availability Zones und Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
Derzeit muss dieser Wert dieselbe AWS Region wie die der exportierenden sein. Die Standardeinstellung ist die AWS Region der exportierenden .
Informationen zum Erstellen einer zusammengesetzten `aws_commons._s3_uri_1`-Struktur finden Sie in der [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri)-Funktion.
*options*
Eine optionale Textzeichenfolge mit Argumenten für den PostgreSQL `COPY`-Befehl. Diese Argumente geben an, wie die Daten beim Exportieren kopiert werden sollen. Weitere Informationen finden Sie in der [PostgreSQL COPY-Dokumentation](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Eine optionale Textzeichenfolge, die den vom Kunden verwalteten KMS-Schlüssel des S3-Buckets enthält, in den die Daten exportiert werden sollen.
### Alternative Eingabeparameter
Zum Testen können Sie statt des Parameters `s3_info` eine erweiterte Gruppe von Parametern verwenden. Nachfolgend sind weitere Syntaxvariationen für die Funktion `aws_s3.query_export_to_s3` aufgeführt.
Statt den Parameter `s3_info` zum Identifizieren einer Amazon S3-Datei zu verwenden, nutzen Sie die Kombination aus den Parametern `bucket`, `file_path` und `region`.
```
aws_s3.query_export_to_s3(
query text,
bucket text,
file_path text,
region text,
options text,
kms_key text
)
```
*query*
Eine erforderliche Textzeichenfolge, die eine SQL-Abfrage enthält, die von der PostgreSQL-Engine ausgeführt wird. Die Ergebnisse dieser Abfrage werden in einen S3-Bucket kopiert, der im `s3_info`-Parameter identifiziert wurde.
*bucket*
Eine erforderliche Textzeichenfolge mit dem Namen des Amazon S3-Buckets, der die Datei enthält.
*file\$1path*
Eine erforderliche Textzeichenfolge, die den Amazon S3-Dateinamen einschließlich des Pfads der Datei enthält.
*Region*
Eine optionale Textzeichenfolge, die die AWS Region enthält, in der sich der Bucket befindet. Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[Regionen, Availability Zones und Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
Derzeit muss dieser Wert dieselbe AWS Region wie die der exportierenden sein. Die Standardeinstellung ist die AWS Region der exportierenden .
*options*
Eine optionale Textzeichenfolge mit Argumenten für den PostgreSQL `COPY`-Befehl. Diese Argumente geben an, wie die Daten beim Exportieren kopiert werden sollen. Weitere Informationen finden Sie in der [PostgreSQL COPY-Dokumentation](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Eine optionale Textzeichenfolge, die den vom Kunden verwalteten KMS-Schlüssel des S3-Buckets enthält, in den die Daten exportiert werden sollen.
### Ausgabeparameter
```
aws_s3.query_export_to_s3(
OUT rows_uploaded bigint,
OUT files_uploaded bigint,
OUT bytes_uploaded bigint
)
```
*rows\$1uploaded*
Die Anzahl der Tabellenzeilen, die für die angegebene Abfrage erfolgreich in Amazon S3 hochgeladen wurden.
*files\$1uploaded*
Die Anzahl der in Amazon S3 hochgeladenen Dateien. Dateien werden in Größen von ca. 6 GB erstellt. Jeder weiteren erstellten Datei wird `_partXX` an den Namen angehängt. `XX` stellt 2, dann 3 usw. nach Bedarf dar.
*bytes\$1uploaded*
Die Gesamtanzahl der in Amazon S3 hochgeladenen Bytes.
### Beispiele
```
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2','format text');
```
## aws\$1commons.create\$1s3\$1uri
Erstellt eine `aws_commons._s3_uri_1`-Struktur für die Amazon S3-Dateiinformationen. Die Ergebnisse der Funktion `aws_commons.create_s3_uri` werden im Parameter `s3_info` der Funktion [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3) verwendet. Ein Beispiel für die Verwendung der `aws_commons.create_s3_uri`-Funktion finden Sie unter [Angeben des Amazon S3-Dateipfads für den Export](postgresql-s3-export.md#postgresql-s3-export-file).
**Syntax**
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```Eingabeparameter
*bucket*
Eine erforderliche Textzeichenfolge mit dem Namen des Amazon S3-Buckets für die Datei.
*file\$1path*
Eine erforderliche Textzeichenfolge, die den Amazon S3-Dateinamen einschließlich des Pfads der Datei enthält.
*Region*
Eine erforderliche Textzeichenfolge, die die AWS Region enthält, in der sich die Datei befindet. Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[Regionen, Availability Zones und Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
# Fehlerbehebung beim Zugriff auf Amazon S3
Wenn beim Versuch, Daten nach Amazon S3 zu exportieren, Verbindungsprobleme auftreten, bestätigen Sie zunächst, dass die Regeln für den ausgehenden Zugriff für die mit Ihrer DB-Instance verknüpfte VPC-Sicherheitsgruppe Netzwerkkonnektivität zulassen. Insbesondere muss die Sicherheitsgruppe über eine Regel verfügen, die es der DB-Instance erlaubt, TCP-Datenverkehr über Port 443 und an eine beliebige IPv4-Adresse (0.0.0.0/0) zu senden. Weitere Informationen finden Sie unter [Ermöglichen des Zugriffs auf Ihre DB-Instance in der VPC durch Erstellen einer Sicherheitsgruppe](CHAP_SettingUp.md#CHAP_SettingUp.SecurityGroup).
Empfehlungen finden Sie im Folgenden:
+ [Fehlerbehebung für Amazon RDS-Identität und -Zugriff](security_iam_troubleshoot.md)
+ [Fehlerbehebung bei Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/troubleshooting.html) im *Entwicklerhandbuch für Amazon Simple Storage Service*
+ [Fehlerbehebung bei Amazon S3 und IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_iam-s3.html) im *IAM-Benutzerhandbuch*