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 von Amazon S3 in eine DB-Instance von RDS für PostgreSQL
Sie können Daten, die mit Amazon Simple Storage Service gespeichert wurden, in eine Tabelle auf einer RDS für PostgreSQL DB-Instance importieren. Um dies zu tun, installieren Sie zuerst die `aws_s3`-Erweiterung von RDS für PostgreSQL. Diese Erweiterung stellt die Funktionen bereit, die Sie zum Importieren von einem Amazon S3 Bucket verwenden. Ein *Bucket* ist ein Amazon S3 Container für Objekte und Dateien. Die Daten können sich in einer Datei mit kommagetrennten Werten (CSV), einer Textdatei oder einer komprimierten Datei (GZIP) befinden. Im Folgenden erfahren Sie, wie Sie die Erweiterung installieren und Daten aus Amazon S3 in eine Tabelle importieren.
Um von Simple Storage Service (Amazon S3) in RDS for PostgreSQL zu importieren, muss Ihre Datenbank PostgreSQL Version 10.7 oder höher verwenden.
Wenn Sie keine Daten in Amazon S3 gespeichert haben, müssen Sie zunächst einen Bucket erstellen und die Daten speichern. Weitere Informationen finden Sie in den folgenden Themen im *Benutzerhandbuch zum Amazon Simple Storage Service*.
+ [Erstellen Sie einen Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#creating-bucket)
+ [Hinzufügen eines Objekts zu einem Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket)
Das kontoübergreifende Importieren aus Amazon S3 wird unterstützt. Weitere Informationen finden Sie unter [Gewähren kontoübergreifender Berechtigungen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html) im *Benutzerhandbuch zu Amazon Simple Storage Service*.
Sie können den vom Kunden verwalteten Schlüssel für die Verschlüsselung verwenden, wenn Sie Daten aus S3 importieren. Weitere Informationen finden Sie unter [In AWS KMS gespeicherte KMS-Schlüssel](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) im *Benutzerhandbuch zu Amazon Simple Storage Service*.
**Topics**
+ [Installieren der Erweiterung aws\$1s3](USER_PostgreSQL.S3Import.InstallExtension.md)
+ [Übersicht über den Import von Daten aus Amazon S3-Daten](USER_PostgreSQL.S3Import.Overview.md)
+ [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](USER_PostgreSQL.S3Import.AccessPermission.md)
+ [Daten von Amazon S3 in Ihren ) importieren](USER_PostgreSQL.S3Import.FileFormats.md)
+ [Funktionsreferenz](USER_PostgreSQL.S3Import.Reference.md)
# Installieren der Erweiterung aws\$1s3
Bevor Sie Amazon S3 mit Ihrer DB-Instance von RDS für PostgreSQL verwenden können müssen Sie die `aws_s3`-Erweiterung installieren. Diese Erweiterung bietet Funktionen zum Importieren von Daten aus einem Amazon S3. Sie bietet auch Funktionen zum Exportieren von Daten aus einer DB-Instance von RDS für PostgreSQL zu einem Amazon-S3-Bucket. Weitere Informationen finden Sie unter [Exportieren von Daten aus einem/einer RDS für PostgreSQL-DB-Instance zu Amazon S3](postgresql-s3-export.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.
# Übersicht über den Import von Daten aus Amazon S3-Daten
**So importieren Sie S3-Daten in Amazon RDS:**
Sammeln Sie zunächst die Details, die Sie der Funktion zur Verfügung stellen müssen. Dazu gehören der Name der Tabelle auf der Ihre RDS for PostgreSQL-DB-Instance sowie der Bucket-Name, der Dateipfad, der Dateityp und der AWS-Region Speicherort der Amazon S3 S3-Daten. Weitere Informationen finden Sie unter [Kopieren von Objekten ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) im *Benutzerhandbuch zu Amazon Simple Storage Service*.
**Anmerkung**
Der mehrteilige Datenimport aus Amazon S3 wird derzeit nicht unterstützt.
1. Ermittelt den Namen der Tabelle, in die die `aws_s3.table_import_from_s3`-Funktion die Daten importieren soll. Mit dem folgenden Befehl wird beispielsweise eine Tabelle `t1` erstellt, die in späteren Schritten verwendet werden kann.
```
postgres=> CREATE TABLE t1
(col1 varchar(80),
col2 varchar(80),
col3 varchar(80));
```
1. Rufen Sie die Details zum Amazon-S3-Bucket und die zu importierenden Daten ab. Öffnen Sie dazu die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)und wählen Sie **Buckets**. Suchen Sie den Bucket, der Ihre Daten enthält, in der Liste. Wählen Sie den Bucket aus, öffnen Sie die Seite Objektübersicht und wählen Sie dann Properties (Eigenschaften).
Notieren Sie sich den Namen, den Pfad AWS-Region, den und den Dateityp des Buckets. Sie benötigen den Amazon-Ressourcenname (ARN) später, um den Zugriff auf Amazon S3 über eine IAM-Rolle einzurichten. Weitere Informationen finden Sie unter [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](USER_PostgreSQL.S3Import.AccessPermission.md). In der folgenden Abbildung sehen Sie ein Beispiel.
![\[Bild eines Dateiobjekts in einem Amazon-S3-Bucket.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/aws_s3_import-export_s3_bucket-info.png)
1. Sie können den Pfad zu den Daten im Amazon S3 S3-Bucket überprüfen, indem Sie den AWS CLI Befehl verwenden`aws s3 cp`. Wenn die Informationen korrekt sind, lädt dieser Befehl eine Kopie der Amazon S3-Datei herunter.
```
aws s3 cp s3://amzn-s3-demo-bucket/sample_file_path ./
```
1. Richten Sie Berechtigungen auf Ihrer DB-Instance von RDS für PostgreSQL ein, um den Zugriff auf die Datei im Amazon-S3-Bucket zu gestatten. Dazu verwenden Sie entweder eine AWS Identity and Access Management (IAM-) Rolle oder Sicherheitsanmeldedaten. Weitere Informationen finden Sie unter [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](USER_PostgreSQL.S3Import.AccessPermission.md).
1. Geben Sie den Pfad und andere gesammelte Amazon S3-Objektdetails (siehe Schritt 2) an die `create_s3_uri`-Funktion zum Erstellen eines Amazon S3-URI-Objekts. Weitere Informationen zu dieser Funktion finden Sie unter [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri). Es folgt ein Beispiel für die Erstellung dieses Objekts während einer psql-Sitzung.
```
postgres=> SELECT aws_commons.create_s3_uri(
'docs-lab-store-for-rpg',
'versions_and_jdks_listing.csv',
'us-west-1'
) AS s3_uri \gset
```
Im nächsten Schritt übergeben Sie dieses Objekt (`aws_commons._s3_uri_1`) an die `aws_s3.table_import_from_s3`-Funktion, um die Daten in die Tabelle zu importieren.
1. Rufen Sie die `aws_s3.table_import_from_s3`-Funktion zum Importieren der Daten aus Amazon S3 in Ihre Tabelle auf. Referenz-Informationen finden Sie unter [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). Beispiele finden Sie unter [Daten von Amazon S3 in Ihren ) importieren](USER_PostgreSQL.S3Import.FileFormats.md).
# Einrichten des Zugriffs auf einen Amazon-S3-Bucket
Um Daten aus einer Amazon S3-Datei zu importieren, erteilen Sie dem/der des RDS für PostgreSQL-DB-Clusters die Berechtigung, auf den Amazon S3-Bucket zuzugreifen, in dem sich die Datei befindet. Sie können den Zugriff auf einen Amazon S3-Bucket auf zwei Arten erlaubt, wie in den folgenden Themen beschrieben.
**Topics**
+ [Verwenden einer IAM-Rolle für den Zugriff auf einen Amazon S3-Bucket](#USER_PostgreSQL.S3Import.ARNRole)
+ [Verwenden von Sicherheitsanmeldeinformationen für den Zugriff auf einen Amazon S3-Bucket](#USER_PostgreSQL.S3Import.Credentials)
+ [Fehlerbehebung beim Zugriff auf Amazon S3](#USER_PostgreSQL.S3Import.troubleshooting)
## Verwenden einer IAM-Rolle für den Zugriff auf einen Amazon S3-Bucket
Bevor Sie Daten aus einer Amazon S3-Datei laden, geben Sie Ihrer -RDS für PostgreSQL DB-Instance die Berechtigung, auf den Amazon S3-Bucket der Datei zuzugreifen. Auf diese Weise müssen Sie keine zusätzlichen Anmeldeinformationen verwalten oder im [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3)-Funktionsaufruf angeben.
Erstellen Sie dazu eine IAM-Richtlinie, die den Zugriff auf den Amazon S3-Bucket ermöglicht. Erstellen Sie eine IAM-Rolle und hängen Sie die Richtlinie an die Rolle an. Weisen Sie dann die IAM-Rolle Ihrer DB Instance zu.
**So geben Sie einer RDS for PostgreSQL DB-Instance über eine IAM-Rolle Zugriff auf Amazon S3:**
1. Erstellen Sie eine IAM-Richtlinie.
Diese Richtlinie enthält die Bucket- und Objektberechtigungen, die Ihrer -RDS für PostgreSQL DB-Instance den Zugriff auf Amazon S3 ermöglichen.
Nehmen Sie die folgenden erforderlichen Aktionen in die Richtlinie auf, um die Übertragung von Dateien von einem Amazon S3-Bucket nach Amazon RDS zu ermöglichen:
+ `s3:GetObject`
+ `s3:ListBucket`
Nehmen Sie die folgenden Ressourcen in die Richtlinie auf, um den Amazon S3-Bucket und Objekte im Bucket zu identifizieren. Dies zeigt das Amazon Resource Name (ARN) Format für den Zugriff auf Amazon S3 an.
+ arn:aws:s3::: *amzn-s3-demo-bucket*
+ arn:aws:s3::: /\$1 *amzn-s3-demo-bucket*
Weitere Informationen zum Erstellen einer IAM-Richtlinie für 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*.
Der folgende AWS CLI Befehl erstellt eine IAM-Richtlinie mit diesen Optionen. `rds-s3-import-policy` Sie gewährt Zugriff auf einen Bucket namens *amzn-s3-demo-bucket*.
**Anmerkung**
Notieren Sie sich den Amazon-Ressourcennamen (ARN) der Richtlinie, der vom Befehl zurückgegeben wurde. Sie benötigen den ARN in einem nachfolgenden Schritt, in dem Sie die Richtlinie an eine IAM-Rolle anhängen.
**Example**
Für Linux, macOS oder Unix:
```
aws iam create-policy \
--policy-name rds-s3-import-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3import",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
Für Windows:
```
aws iam create-policy ^
--policy-name rds-s3-import-policy ^
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3import",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"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-import-role` zu erstellen.
**Example**
Für Linux, macOS oder Unix:
```
aws iam create-role \
--role-name rds-s3-import-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-import-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 im vorherigen Schritt erstellte Richtlinie der Rolle `rds-s3-import-role` Replace `your-policy-arn` mit dem Richtlinien-ARN zugeordnet, den Sie in einem früheren Schritt notiert haben.
**Example**
Für Linux, macOS oder Unix:
```
aws iam attach-role-policy \
--policy-arn your-policy-arn \
--role-name rds-s3-import-role
```
Für Windows:
```
aws iam attach-role-policy ^
--policy-arn your-policy-arn ^
--role-name rds-s3-import-role
```
1. Fügen Sie die IAM-Rolle der DB Instance hinzu.
Dazu verwenden Sie das AWS-Managementkonsole oder 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** im Bereich **Manage IAM roles** (IAM-Rollen verwalten) die Rolle aus, die unter **Add IAM roles (IAM-Rollen hinzufügen) zu diesen Instances** hinzugefügt werden soll.
1. Wählen Sie unter **Feature (Funktion)** die Option **s3Import** 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 `s3Import` 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 s3Import \
--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 s3Import ^
--role-arn your-role-arn ^
--region your-region
```
### RDS-API
Um eine IAM-Rolle für eine mithilfe der Amazon RDS-API hinzuzufügen, rufen Sie den Vorgang auf.
## Verwenden von Sicherheitsanmeldeinformationen für den Zugriff auf einen Amazon S3-Bucket
Wenn Sie es vorziehen, können Sie Sicherheitsanmeldeinformationen verwenden, um den Zugriff auf einen Amazon S3-Bucket zu ermöglichen, anstatt den Zugriff mit einer IAM-Rolle zu ermöglichen. Dazu geben Sie die `credentials`-Parameter im [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3)-Funktionsaufruf an.
Der `credentials` Parameter ist eine Struktur vom Typ`aws_commons._aws_credentials_1`, die Anmeldeinformationen enthält. AWS Verwenden Sie die Funktion [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials), um den Zugriffs- und den Geheimschlüssel in einer `aws_commons._aws_credentials_1`-Struktur festzulegen, wie nachfolgend dargestellt.
```
postgres=> SELECT aws_commons.create_aws_credentials(
'sample_access_key', 'sample_secret_key', '')
AS creds \gset
```
Nachdem Sie die `aws_commons._aws_credentials_1 `-Struktur erstellt haben, verwenden Sie die Funktion [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) mit dem Parameter `credentials`, um die Daten zu importieren, wie nachfolgend gezeigt.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't', '', '(format csv)',
:'s3_uri',
:'creds'
);
```
Sie können auch den Funktionsaufruf [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) in den Funktionsaufruf `aws_s3.table_import_from_s3` einbinden.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't', '', '(format csv)',
:'s3_uri',
aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
);
```
## Fehlerbehebung beim Zugriff auf Amazon S3
Wenn Sie beim Versuch, Daten aus Amazon S3 zu importieren, auf Verbindungsprobleme stoßen, finden Sie im Folgenden Empfehlungen:
+ [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*
# Daten von Amazon S3 in Ihren ) importieren
Sie importieren Daten aus Ihrem Amazon-S3-Bucket mithilfe der `table_import_from_s3`-Funktion der aws\$1s3-Erweiterung. Referenz-Informationen finden Sie unter [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
**Anmerkung**
Die folgenden Beispiele verwenden die IAM-Rollen-Methode, um den Zugriff auf den Amazon-S3-Bucket zu ermöglichen. Daher enthalten die `aws_s3.table_import_from_s3`-Funktionsaufrufe keine Berechtigungsnachweisparameter.
Nachfolgend ist ein typisches Beispiel aufgeführt.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't1',
'',
'(format csv)',
:'s3_uri'
);
```
Es werden folgende Parameter verwendet:
+ `t1` – Der Name für die Tabelle in der PostgreSQL DB Instance, in die die Daten kopiert werden.
+ `''` – Eine optionale Liste mit Spalten in der Datenbanktabelle. Mithilfe dieses Parameters können Sie angeben, welche Spalten der S3-Daten in die Tabellenspalten übernommen werden sollen. Wenn keine Spalten angegeben sind, werden alle Spalten in die Tabelle kopiert. Ein Beispiel zum Verwenden einer Spaltenliste finden Sie unter [Importieren einer Amazon S3-Datei, die ein benutzerdefiniertes Trennzeichen verwendet](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
+ `(format csv)` – PostgreSQL COPY-Argumente. Der Kopiervorgang verwendet die Argumente und das Format des [PostgreSQL-Befehls COPY](https://www.postgresql.org/docs/current/sql-copy.html), um die Daten zu importieren. Zu den Optionen für das Format gehören kommagetrennte Werte (CSV), Text und Binärwerte. Der Standard ist Text.
+ `s3_uri` – Eine Struktur mit den Informationen zum Identifizieren der Amazon S3-Datei. Ein Beispiel für die Verwendung der Funktion [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) zum Erstellen einer `s3_uri`-Struktur finden Sie unter [Übersicht über den Import von Daten aus Amazon S3-Daten](USER_PostgreSQL.S3Import.Overview.md).
Weitere Informationen zu dieser Funktion finden Sie unter [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
Die Funktion gibt `aws_s3.table_import_from_s3` zurück. Weitere Informationen zum Angeben von anderen Dateien für den Import aus einem Amazon S3-Bucket finden Sie in einem der folgenden Beispiele.
**Anmerkung**
Beim Importieren einer Datei mit 0 Byte tritt ein Fehler auf.
**Topics**
+ [Importieren einer Amazon S3-Datei, die ein benutzerdefiniertes Trennzeichen verwendet](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter)
+ [Importieren einer Amazon S3-komprimierten Datei (gzip)](#USER_PostgreSQL.S3Import.FileFormats.gzip)
+ [Importieren einer kodierten Amazon S3-Datei](#USER_PostgreSQL.S3Import.FileFormats.Encoded)
## Importieren einer Amazon S3-Datei, die ein benutzerdefiniertes Trennzeichen verwendet
Das folgende Beispiel zeigt, wie man eine Datei importiert, die ein benutzerdefiniertes Trennzeichen verwendet. Außerdem wird veranschaulicht, wie mit dem `column_list`-Parameter der Funktion [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) kontrolliert wird, wo die Daten in der Datenbanktabelle platziert werden.
Für dieses Beispiel wird angenommen, dass die folgenden Informationen in durch Pipe-Zeichen getrennte Spalten in der Amazon S3-Datei angeordnet sind.
```
1|foo1|bar1|elephant1
2|foo2|bar2|elephant2
3|foo3|bar3|elephant3
4|foo4|bar4|elephant4
...
```
**So importieren Sie eine Datei, die ein benutzerdefiniertes Trennzeichen verwendet:**
1. Erstellen Sie eine Tabelle in der Datenbank für die importierten Daten.
```
postgres=> CREATE TABLE test (a text, b text, c text, d text, e text);
```
1. Verwenden Sie die folgende Form der Funktion [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3), um Daten aus der Amazon S3-Datei zu importieren.
Zur Angabe der Datei können Sie auch den Funktionsaufruf [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) in den Funktionsaufruf `aws_s3.table_import_from_s3` einbinden.
```
postgres=> SELECT aws_s3.table_import_from_s3(
'test',
'a,b,d,e',
'DELIMITER ''|''',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'pipeDelimitedSampleFile', 'us-east-2')
);
```
Die Daten befinden sich nun in den folgenden Spalten der Tabelle.
```
postgres=> SELECT * FROM test;
a | b | c | d | e
---+------+---+---+------+-----------
1 | foo1 | | bar1 | elephant1
2 | foo2 | | bar2 | elephant2
3 | foo3 | | bar3 | elephant3
4 | foo4 | | bar4 | elephant4
```
## Importieren einer Amazon S3-komprimierten Datei (gzip)
Das folgende Beispiel zeigt, wie eine mit gzip komprimierte Datei aus Amazon S3 importiert wird. Die Datei, die Sie importieren, muss die folgenden Amazon-S3-Metadaten aufweisen:
+ Schlüssel: `Content-Encoding`
+ Wert: `gzip`
Wenn Sie die Datei mithilfe von hochladen AWS-Managementkonsole, werden die Metadaten in der Regel vom System übernommen. Informationen zum Hochladen von Dateien auf Amazon S3 mithilfe der AWS-Managementkonsole AWS CLI, der oder der API finden Sie unter [Hochladen von Objekten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
Weitere Informationen zu Amazon-S3-Metadaten und zu vom System bereitgestellten Metadaten finden Sie unter [Bearbeiten von Objektmetadaten in der Amazon-S3-Konsole](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-object-metadata.html) im *Benutzerhandbuch für Amazon Simple Storage Service*.
Importieren Sie die gzip-Datei folgendermaßen in Ihrer -RDS for PostgreSQL DB-Instance.
```
postgres=> CREATE TABLE test_gzip(id int, a text, b text, c text, d text);
postgres=> SELECT aws_s3.table_import_from_s3(
'test_gzip', '', '(format csv)',
'amzn-s3-demo-bucket', 'test-data.gz', 'us-east-2'
);
```
## Importieren einer kodierten Amazon S3-Datei
Das folgende Beispiel zeigt, wie eine Datei aus Amazon S3 mit Windows-1252-Kodierung importiert wird.
```
postgres=> SELECT aws_s3.table_import_from_s3(
'test_table', '', 'encoding ''WIN1252''',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'SampleFile', 'us-east-2')
);
```
# Funktionsreferenz
**Topics**
+ [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3)
+ [aws\$1commons.create\$1s3\$1uri](#USER_PostgreSQL.S3Import.create_s3_uri)
+ [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials)
## aws\$1s3.table\$1import\$1from\$1s3
Importiert Amazon S3-Daten in eine Amazon RDS-Tabelle. Die Erweiterung `aws_s3` stellt die Funktion `aws_s3.table_import_from_s3` bereit. Der Rückgabewert ist Text.
### Syntax
Die erforderlichen Parameter sind `table_name`, `column_list` und `options`. Diese Parameter identifizieren die Datenbanktabelle und geben an, wie die Daten in die Tabelle kopiert werden.
Sie können auch die folgenden Parameter verwenden:
+ Die zu importierende Amazon S3-Datei wird mit dem Parameter `s3_info` übergeben. Wenn Sie diesen Parameter verwenden, wird der Zugriff auf Amazon S3 von einer IAM-Rolle für die PostgreSQL DB--Instance bereitgestellt.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
s3_info aws_commons._s3_uri_1
)
```
+ Die Anmeldeinformationen für den Zugriff auf Amazon S3 werden mit dem Parameter `credentials` übergeben. Mit diesem Parameter verwenden Sie keine IAM-Rolle.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
s3_info aws_commons._s3_uri_1,
credentials aws_commons._aws_credentials_1
)
```
### Parameters
*table\$1name*
Eine erforderliche Textzeichenfolge mit dem Namen der PostgreSQL-Datenbanktabelle, in die die Daten importiert werden sollen.
*column\$1list*
Eine erforderliche Textzeichenfolge mit einer optionalen Liste der Tabellenspalten der PostgreSQL-Datenbank, in die die Daten kopiert werden sollen. Wenn die Zeichenfolge leer ist, werden alle Spalten der Tabelle verwendet. Ein Beispiel finden Sie unter [Importieren einer Amazon S3-Datei, die ein benutzerdefiniertes Trennzeichen verwendet](USER_PostgreSQL.S3Import.FileFormats.md#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
*options*
Eine erforderliche Textzeichenfolge mit Argumenten für den PostgreSQL `COPY`-Befehl. Diese Parameter legen fest, wie die Daten in die PostgreSQL-Tabelle kopiert werden. Weitere Informationen finden Sie in der [PostgreSQL COPY-Dokumentation](https://www.postgresql.org/docs/current/sql-copy.html).
*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 enthält.
+ `file_path` – Der Amazon S3-Dateiname einschließlich des Pfads der Datei.
+ `region`— Die AWS Region, 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).
*Anmeldedaten*
Ein zusammengesetzter `aws_commons._aws_credentials_1`-Typ mit den folgenden Anmeldeinformationen, die für den Importvorgang verwendet werden sollen:
+ Zugriffsschlüssel
+ Geheimschlüssel
+ Sitzungs-Token
Hinweise zum Erstellen einer zusammengesetzten `aws_commons._aws_credentials_1`-Struktur finden Sie unter [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials).
### Alternative Syntax
Zum Testen können Sie statt der Parameter `s3_info` und `credentials` eine erweiterte Gruppe von Parametern verwenden. Nachfolgend sind weitere Syntaxvariationen für die Funktion `aws_s3.table_import_from_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`. Mit dieser Form der Funktion wird der Zugriff auf Amazon S3 mit einer IAM-Rolle für die PostgreSQL-DB-Instance bereitgestellt.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
bucket text,
file_path text,
region text
)
```
+ Statt den Parameter `credentials` zum Angeben einer Amazon S3-Datei zu verwenden, nutzen Sie die Kombination aus den Parametern `access_key`, `session_key` und `session_token`.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
bucket text,
file_path text,
region text,
access_key text,
secret_key text,
session_token text
)
```
### Alternative Parameter
*bucket*
Eine Textzeichenfolge mit den Namen des Amazon S3-Buckets, der die Datei enthält.
*file\$1path*
Eine Textzeichenfolge, die den Amazon S3-Dateinamen einschließlich des Pfades der Datei enthält.
*Region*
Eine Textzeichenfolge, die den AWS-Region Speicherort der Datei angibt. Eine Liste der AWS-Region Namen und zugehörigen Werte finden Sie unter[Regionen, Availability Zones und Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
*access\$1key*
Eine Textzeichenfolge mit dem Zugriffsschlüssel, der für den Importvorgang verwendet werden soll. Der Standardwert ist „NULL“.
*secret\$1key*
Eine Textzeichenfolge mit dem Geheimschlüssel, der für den Importvorgang verwendet werden soll. Der Standardwert ist „NULL“.
*session\$1token*
(Optional) Eine Textzeichenfolge mit dem Sitzungsschlüssel, der für den Importvorgang verwendet werden soll. Der Standardwert ist „NULL“.
## 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.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3) verwendet.
### Syntax
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```
### Parameters
*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 AWS-Region , die den Inhalt der Datei enthält. Eine Liste der AWS-Region Namen und der zugehörigen Werte finden Sie unter[Regionen, Availability Zones und Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
## aws\$1commons.create\$1aws\$1credentials
Legt einen Zugriffs- und einen Geheimschlüssel in einer `aws_commons._aws_credentials_1`-Struktur fest. Die Ergebnisse der Funktion `aws_commons.create_aws_credentials` werden im Parameter `credentials` der Funktion [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3) verwendet.
### Syntax
```
aws_commons.create_aws_credentials(
access_key text,
secret_key text,
session_token text
)
```
### Parameters
*access\$1key*
Eine erforderliche Textzeichenfolge mit dem Zugriffsschlüssel, der zum Importieren einer Amazon S3-Datei verwendet werden soll. Der Standardwert ist „NULL“.
*secret\$1key*
Eine erforderliche Textzeichenfolge mit dem Geheimschlüssel, der zum Importieren einer Amazon S3-Datei verwendet werden soll. Der Standardwert ist „NULL“.
*session\$1token*
Eine erforderliche Textzeichenfolge mit dem Sitzungs-Token, der zum Importieren einer Amazon S3-Datei verwendet werden soll. Der Standardwert ist „NULL“. Wenn Sie ein optionales `session_token` angeben, können Sie temporäre Anmeldeinformationen verwenden.