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 Daten in PostgreSQL in Amazon RDS
Angenommen, Sie verfügen über eine bestehende PostgreSQL-Bereitstellung, die Sie zu Amazon RDS verschieben möchten. Wie komplex diese Aufgabe ist, hängt von der Größe Ihrer Datenbank und den Arten von Datenbankobjekten ab, die Sie übertragen. Nehmen wir beispielsweise eine Datenbank mit mehreren Gigabyte an Datensätzen, einschließlich der gespeicherten Prozeduren und Auslöser. Eine solche Datenbank ist komplizierter als eine einfache Datenbank mit nur wenigen Megabyte an Testdaten und ohne Auslöser oder gespeicherten Prozeduren.
Unter den folgenden Bedingungen empfehlen wir Ihnen die Verwendung von nativen PostgreSQL-Datenbank-Migrationstools:
+ Sie möchten eine homogene Migration durchführen, bei der die Ausgangsdatenbank denselben Datenbank-Engine hat wie die Zieldatenbank.
+ Sie möchten eine komplette Datenbank migrieren.
+ Die nativen Tools erlauben Ihnen, Ihr System mit einer minimalen Ausfallzeit zu migrieren.
In den meisten anderen Fällen ist die Durchführung einer Datenbankmigration mit dem AWS Database Migration Service (AWS DMS) der beste Ansatz. AWS DMS kann Datenbanken ohne Ausfallzeiten migrieren und bei vielen Datenbank-Engines die fortlaufende Replikation fortsetzen, bis Sie bereit sind, zur Zieldatenbank zu wechseln. Mithilfe von AWS DMS können Sie entweder zu derselben Datenbank-Engine oder zu einer anderen Datenbank-Engine migrieren. Wenn Sie zu einer anderen Datenbank-Engine als Ihrer Quelldatenbank migrieren, können Sie die AWS Schema Conversion Tool ()AWS SCT verwenden. Sie verwenden AWS SCT es, um Schemaobjekte zu migrieren, die nicht von migriert wurden. AWS DMS Weitere Informationen zu AWS DMS finden Sie unter [Was ist? AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Modifizieren Sie die DB-Parametergruppe so, dass sie *nur* die folgenden Einstellungen für Ihren Import enthält. Sie sollten die Parametereinstellungen testen, um festzustellen, welches die effizientesten Einstellungen für Ihre DB-Instance-Größe sind. Nach der Import abgeschlossen wurde, müssen Sie auch diese Parameter auf die Produktionswerte zurücksetzen.
Ändern Sie die Einstellungen für Ihre DB-Instance wie folgt:
+ Deaktivieren Sie die DB-Instance-Backups (Sicherungsaufbewahrung auf 0 setzen).
+ Deaktivieren Sie Multi-AZ.
Modifizieren Sie die DB-Parametergruppe so, dass sie die folgenden Einstellungen enthält. Sie sollten beim Importieren von Daten nur diese Einstellungen verwenden. Sie sollten die Parametereinstellungen testen, um festzustellen, welches die effizientesten Einstellungen für Ihre DB-Instance-Größe sind. Nach der Import abgeschlossen wurde, müssen Sie auch diese Parameter auf die Produktionswerte zurücksetzen.
| Parameter | Empfohlene Werte beim Importieren | Beschreibung |
| --- | --- | --- |
| `maintenance_work_mem` | 524288, 1048576, 2097152 oder 4194304 (in KB). Diese Einstellungen sind vergleichbar mit 512 MB, 1 GB, 2 GB und 4 GB. | Der Wert für diese Einstellung hängt von der Größe Ihres Hosts ab. Dieser Parameter wird während der CREATE INDEX-Anweisungen verwendet und jeder parallele Befehl kann so viel Speicherplatz benötigen. Berechnen Sie den besten Wert, sodass Sie diesen Wert nicht zu hoch einstellen und Gefahr laufen, keinen Speicherplatz mehr zu haben. |
| `max_wal_size` | 256 (für Version 9.6), 4096 (für Version 10 und höher) | Maximale Größe, um das WAL während automatischer Kontrollpunkte zunehmen zu lassen. Eine Erhöhung dieses Parameters kann den Zeitaufwand für die Wiederherstellung nach dem Absturz erhöhen. Dieser Parameter ersetzt `checkpoint_segments` für PostgreSQL 9.6 und höher. Für PostgreSQL-Version 9.6 liegt dieser Wert auf 16 MB-Einheiten. Bei späteren Versionen liegt der Wert bei 1 MB Einheiten. In Version 9.6 bedeutet das beispielsweise 128 Blöcke mit einer Größe von jeweils 16 MB. In Version 12.4 bedeutet das 2 048 Blöcke mit einer Größe von jeweils 1 MB. |
| `checkpoint_timeout` | 1800 | Der Wert für diese Einstellung erlaubt eine seltenere WAL-Rotation. |
| `synchronous_commit` | Aus | Deaktivieren Sie diese Einstellungen, um Schreibvorgänge zu beschleunigen. Wenn dieser Parameter auf „off“ gestellt wird, kann dadurch das Risiko von Datenverlusten bei einem Serverausfall steigen (stellen Sie FSYNC nicht auf „off“). |
| `wal_buffers` | 8192 | Dieser Wert wird in 8 KB-Einheiten angegeben. Dies wiederum erhöht Ihre WAL-Erzeugungsgeschwindigkeit |
| `autovacuum` | 0 | Deaktivieren Sie den Selbstbereinigungsparameter für PostgreSQL während dem Laden von Daten, sodass dieser keine Ressourcen verbraucht |
Verwenden Sie den Befehl `pg_dump -Fc` (komprimiert) oder den Befehl `pg_restore -j` (parallel) mit diesen Einstellungen.
**Anmerkung**
Der PostgreSQL-Befehl `pg_dumpall` erfordert super\$1user-Berechtigungen, die nicht gewährt werden, wenn Sie eine DB-Instance erstellen, sodass er nicht für das Importieren von Daten verwendet werden kann.
**Topics**
+ [Importieren einer PostgreSQL-Datenbank aus einer Amazon EC2-Instance](PostgreSQL.Procedural.Importing.EC2.md)
+ [Verwenden des Befehls \$1copy zum Importieren von Daten in eine Tabelle auf einer PostgreSQL-DB-Instance](PostgreSQL.Procedural.Importing.Copy.md)
+ [Importieren von Amazon S3 in eine DB-Instance von RDS für PostgreSQL](USER_PostgreSQL.S3Import.md)
+ [Transport von PostgreSQL-Datenbanken zwischen DB-Instances](PostgreSQL.TransportableDB.md)
# Importieren einer PostgreSQL-Datenbank aus einer Amazon EC2-Instance
Wenn Sie in einem PostgreSQL-Server auf einer Amazon-EC2-Instance Daten haben und diese in eine PostgreSQL-DB-Instance verschieben möchten, können Sie diesen Prozess zum Migrieren der Daten nutzen.
1. Erstellen Sie eine Datei mit pg\$1dump, die zu ladenden Daten enthält
1. Erstellen Sie die DB-Ziel-Instance
1. Verwenden Sie *psql*, um die Datenbank auf der DB-Instance zu erstellen und die Daten zu laden
1. Erstellen Sie einen DB-Snapshot der DB-Instance
Die folgenden Abschnitte enthalten weitere Informationen zu den oben aufgeführten Schritten.
## Schritt 1: Erstellen einer Datei, die zu ladenden Daten enthält, mit pg\$1dump
Das Dienstprogramm `pg_dump` verwendet den Befehl COPY, um ein Schema sowie eine Daten-Dumpdatei einer PostgreSQL-Datenbank zu erstellen. Das durch `pg_dump` erzeugte Dump-Skript lädt Daten in eine Datenbank mit demselben Namen und erstellt die Tabellen, Indizes und Fremdschlüssel. Sie können den Befehl `pg_restore` und den Parameter `-d` verwenden, um die Daten in einer Datenbank mit einem anderen Namen wiederherzustellen.
Bevor Sie die Daten-Dumpdatei erstellen, sollten Sie die zu dumpenden Tabellen abfragen, um die Zeilenanzahl zu ermitteln und diese in der DB-Ziel-Instance zu bestätigen.
Der folgende Befehl erstellt eine Dump-Datei mit dem Namen mydb2dump.sql für eine Datenbank mit dem Namen mydb2.
```
prompt>pg_dump dbname=mydb2 -f mydb2dump.sql
```
## Schritt 2: Erstellen einer DB-Ziel-Instance
Erstellen Sie die DB-Ziel-Instance für PostgreSQL entweder über die Amazon-RDS-Konsole, AWS CLI oder über die API. Achten Sie darauf, dass beim Erstellen der Instance die Einstellung der Sicherungsaufbewahrung auf 0 festgelegt ist und deaktivieren Sie Multi-AZ. Dadurch wird der Datenimport beschleunigt. Bevor Sie die Daten dumpen können, müssen Sie eine Datenbank auf der Instance erstellen. Die Datenbank kann den gleichen Namen wie die in den Dumpdaten enthaltene Datenbank haben. Alternativ können Sie auch eine Datenbank mit einem anderen Namen erstellen. In diesem Fall verwenden Sie den Befehl `pg_restore` und den Parameter `-d`, um die Daten in einer Datenbank mit einem neuen Namen wiederherzustellen.
Beispielsweise können die folgenden Befehle für das Dumpen, Wiederherstellen und Umbenennen einer Datenbank verwendet werden.
```
pg_dump -Fc -v -h [endpoint of instance] -U [master username] [database] > [database].dump
createdb [new database name]
pg_restore -v -h [endpoint of instance] -U [master username] -d [new database name] [database].dump
```
## Schritt 3: Verwenden von psql zum Erstellen der Datenbank auf der DB-Instance und zum Laden der Daten
Sie können dieselbe Verbindung nutzen, die Sie für die Ausführung des Befehls pg\$1dump verwendet haben, um eine Verbindung mit der DB-Ziel-Instance herzustellen und die Datenbank neu zu erstellen. Mit *psql* können Sie den Masterbenutzername und das Masterpasswort verwenden, um die Datenbank auf der DB-Instance zu erstellen
Im folgenden Beispiel wird *psql* sowie auch eine Dump-Datei mit dem Namen mydb2dump.sql verwendet, um eine Datenbank mit dem Namen mydb2 auf einer PostgreSQL-DB-Instance mit dem Namen mypginstance zu erstellen:
Für Linux, macOS oder Unix:
```
psql \
-f mydb2dump.sql \
--host mypginstance.555555555555.aws-region.rds.amazonaws.com \
--port 8199 \
--username myawsuser \
--password password \
--dbname mydb2
```
Für Windows:
```
psql ^
-f mydb2dump.sql ^
--host mypginstance.555555555555.aws-region.rds.amazonaws.com ^
--port 8199 ^
--username myawsuser ^
--password password ^
--dbname mydb2
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
## Schritt 4: Erstellen Sie einen DB-Snapshot der DB-Instance
Sobald Sie verifiziert haben, dass die Daten in die DB-Instance geladen wurden, empfehlen wir Ihnen einen DB-Snapshot der PostgreSQL-DB-Ziel-Instance zu erstellen. -DB-Snapshots sind vollständige Backups von Ihrer DB-Instance, die für eine Backup Ihrer DB-Instance auf einen bekannten Zustand verwendet werden können. Ein DB-Snapshot, der sofort nach einem Ladevorgang erstellt wird, bewahrt Sie davor, die Daten bei einem Fehler erneut laden zu müssen. Einen solchen Snapshot können Sie auch als Ausgangspunkt für neue DB-Instances verwenden. Weitere Informationen zum Erstellen eines DB-Snapshots finden Sie unter [Erstellen eines DB-Snapshots für eine DB-Instance mit Single-AZ für Amazon RDS](USER_CreateSnapshot.md).
# Verwenden des Befehls \$1copy zum Importieren von Daten in eine Tabelle auf einer PostgreSQL-DB-Instance
Der PostgreSQL-Befehl `\copy` ist ein Meta-Befehl, der im interaktiven `psql`-Client-Tool verfügbar ist. Sie können `\copy` verwenden, um Daten in eine Tabelle auf Ihrer DB-Instance von RDS für PostgreSQL zu importieren. Um den `\copy`-Befehl zu verwenden, müssen Sie zuerst die Tabellenstruktur auf der Ziel-DB-Instance erstellen, damit `\copy` ein Ziel für die zu kopierenden Daten hat.
Sie können `\copy` verwenden, um Daten aus einer CSV-Datei (durch Kommas getrennte Werte) zu laden, z. B. aus einer Datei, die exportiert und auf Ihrer Client-Workstation gespeichert wurde.
Um die CSV-Daten in die Ziel-DB-Instance von RDS für PostgreSQL zu importieren, stellen Sie zuerst über eine Verbindung mit der Ziel-DB-Instance her `psql`.
```
psql --host=db-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=target-db
```
Führen Sie dann den `\copy`-Befehl mit den folgenden Parametern aus, um das Ziel für die Daten und ihr Format zu identifizieren.
+ `target_table` – Der Name der Tabelle, die die Daten erhalten soll, die aus der CSV-Datei kopiert werden.
+ `column_list` – Spaltenspezifikationen für die Tabelle.
+ `'filename'` – Der vollständige Pfad zur CSV-Datei auf Ihrer lokalen Workstation.
```
\copy target_table from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV;
```
Wenn die CSV-Datei Spaltenüberschriften-Informationen enthält, können Sie diese Version des Befehls und der Parameter verwenden.
```
\copy target_table (column-1, column-2, column-3, ...)
from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV HEADER;
```
Wenn der `\copy`-Befehl fehlschlägt, gibt PostgreSQL Fehlermeldungen aus.
Erstellen Sie eine neue DB-Instance in der Datenbank-Vorschauumgebung mit dem Befehl `psql` und dem Metabefehl `\copy`, wie in den folgenden Beispielen gezeigt. In diesem Beispiel wird *source-table* als Name für die Quelltabelle verwendet, *source-table.csv* für die CSV-Datei und *target-db* für die Zieldatenbank:
Für Linux, macOS oder Unix:
```
$psql target-db \
-U \
-p \
-h \
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Für Windows:
```
$psql target-db ^
-U ^
-p ^
-h ^
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Alle Details zum `\copy`-Befehl finden Sie auf der [psql](http://www.postgresql.org/docs/current/static/app-psql.html)-Seite in der PostgreSQL-Dokumentation, im Bereich *Metabefehle*.
# 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.
# Transport von PostgreSQL-Datenbanken zwischen DB-Instances
Mit der Verwendung von PostgreSQL-Transportdatenbanken für Amazon RDS können Sie eine PostgreSQL-Datenbank zwischen zwei DB-Instances bewegen. Dies ist eine sehr schnelle Möglichkeit, große Datenbanken zwischen verschiedenen DB-Instances zu migrieren. Um diesen Ansatz zu verwenden, müssen Ihre DB-Instances beide die gleiche Hauptversion von PostgreSQL ausführen.
Diese Funktion erfordert, dass Sie die `pg_transport`-Erweiterung sowohl für die Quell- als auch die Ziel-DB-Instance installieren. Die `pg_transport`-Erweiterung bietet einen physischen Transportmechanismus, der die Datenbankdateien mit minimaler Verarbeitung verschiebt. Dieser Mechanismus bewegt Daten viel schneller als herkömmliche Abfragen- und Ladeprozesse mit weniger Ausfallzeiten.
**Anmerkung**
PostgreSQL-Transportdatenbanken sind in RDS for PostgreSQL Version 11.5 und höher und RDS for PostgreSQL Version 10.10 und höher verfügbar.
Um eine PostgreSQL-DB-Instance von einer DB-Instance von RDS for PostgreSQL zu einer anderen zu transportieren, richten Sie zuerst die Quell- und Zielinstances ein, wie in [ Einrichten einer DB-Instance für den Transport](PostgreSQL.TransportableDB.Setup.md) beschrieben. Anschließend können Sie die Datenbank mit der unter [ Transport einer PostgreSQL-Datenbank](PostgreSQL.TransportableDB.Transporting.md) beschriebenen Funktion transportieren.
**Topics**
+ [Was passiert beim Datenbanktransport?](#PostgreSQL.TransportableDB.DuringTransport)
+ [Einschränkungen für die Verwendung von PostgreSQL-Transportdatenbanken](#PostgreSQL.TransportableDB.Limits)
+ [Einrichten des Transports einer PostgreSQL-Datenbank](PostgreSQL.TransportableDB.Setup.md)
+ [Transportieren einer PostgreSQL-Datenbank von der Quelle zum Ziel](PostgreSQL.TransportableDB.Transporting.md)
+ [Funktionsreferenz für transportable Datenbanken](PostgreSQL.TransportableDB.transport.import_from_server.md)
+ [Parameterreferenz für transportable Datenbanken](PostgreSQL.TransportableDB.Parameters.md)
## Was passiert beim Datenbanktransport?
Die Funktion PostgreSQL-Transportdatenbanken verwendet ein Pull-Modell, um die Datenbank aus der Quell-DB-Instance in das Ziel zu importieren. Die `transport.import_from_server`-Funktion erstellt die In-Transit-Datenbank auf der Ziel-DB-Instance. Die In-Transit-Datenbank ist auf der Ziel-DB-Instance für die Dauer des Transports nicht zugänglich.
Wenn der Transport beginnt, werden alle aktuellen Sitzungen auf der Quelldatenbank beendet. Alle anderen Datenbanken als die Quelldatenbank auf der Quell-DB-Instance sind vom Transport nicht betroffen.
Die Quelldatenbank wird in einen speziellen schreibgeschützten Modus versetzt. Während es sich in diesem Modus befindet, können Sie sich mit der Quelldatenbank verbinden und schreibgeschützte Abfragen durchführen. Allerdings sind schreibende Abfragen und einige andere Arten von Befehlen blockiert. Von diesen Einschränkungen ist nur die spezifische Quelldatenbank betroffen, die transportiert wird.
Während des Transports können Sie für die Ziel-DB-Instance keine Point-in-time-Wiederherstellung durchführen. Dies liegt daran, dass der Transport nicht transaktional ist und das PostgreSQL-Write-Ahead-Protokoll nicht verwendet, um Änderungen aufzuzeichnen. Wenn für die Ziel-DB-Instance automatische Backups aktiviert sind, wird nach Abschluss des Transports automatisch eine Sicherung erstellt. Point-in-timeWiederherstellungen sind für bestimmte Zeiten *nach* Abschluss des Backups verfügbar.
Wenn der Transport fehlschlägt, versucht die `pg_transport`-Erweiterung, alle Änderungen an den Quell- und Ziel-DB-Instances rückgängig zu machen. Dazu gehört auch das Entfernen der teilweise transportierten Datenbank auf dem Ziel. Abhängig von der Art des Fehlers kann es vorkommen, dass die Quelldatenbank weiterhin schreibende Abfragen ablehnt. Verwenden Sie in diesem Fall den folgenden Befehl, um schreibende Abfragen zu ermöglichen.
```
ALTER DATABASE db-name SET default_transaction_read_only = false;
```
## Einschränkungen für die Verwendung von PostgreSQL-Transportdatenbanken
Transportdatenbanken haben folgende Einschränkungen:
+ **Lesereplikate** – Sie können keine Transportdatenbanken für Lesereplikate oder übergeordnete Instances von Lesereplikaten verwenden.
+ **Nicht unterstützte Spaltentypen** – Sie können die `reg`-Datentypen nicht in Datenbanktabellen verwenden, die Sie mit dieser Methode transportieren möchten. Diese Typen hängen vom Systemkatalogobjekt IDs (OIDs) ab, das sich während des Transports häufig ändert.
+ **Tablespaces** – Alle Quelldatenbankobjekte müssen sich im Standard-Tablespace `pg_default` befinden.
+ **Kompatibilität** – Sowohl die Quell- als auch die Ziel-DB-Instance müssen die gleiche Hauptversion von PostgreSQL ausführen.
+ **Erweiterungen** – Auf der Quell-DB-Instance kann nur das `pg_transport` installiert sein.
+ **Rollen und ACLs** — Die Zugriffsberechtigungen und Besitzinformationen der Quelldatenbank werden nicht auf die Zieldatenbank übertragen. Alle Datenbankobjekte werden erstellt und gehören dem lokalen Zielbenutzer des Transports.
+ **Gleichzeitige Transporte** – Eine einzelne DB-Instance kann bis zu 32 gleichzeitige Transporte unterstützen, einschließlich Importe und Exporte, wenn Worker-Prozesse ordnungsgemäß konfiguriert wurden.
+ **Nur DB-Instances von RDS for PostgreSQL** – Transportable PostgreSQL-Datenbanken werden nur auf DB-Instances von RDS for PostgreSQL unterstützt. Sie können es nicht mit lokalen Datenbanken oder Datenbanken verwenden, die auf Amazon EC2 ausgeführt werden.
# Einrichten des Transports einer PostgreSQL-Datenbank
Stellen Sie vor Beginn sicher, dass Ihre DB-Instances von RDS für PostgreSQL die folgenden Anforderungen erfüllen:
+ Die DB-Instances von RDS für PostgreSQL für die Quelle und das Ziel müssen die gleiche Version von PostgreSQL ausführen.
+ Die Ziel-DB darf keine Datenbank mit dem gleichen Namen wie die Quell-DB haben, die Sie transportieren möchten.
+ Das Konto, das Sie zum Ausführen des Transports verwenden, benötigt `rds_superuser`-Berechtigungen sowohl für die Quell-DB als auch für die Ziel-DB.
+ Die Sicherheitsgruppe für die Quell-DB-Instance muss eingehenden Zugriff von der Ziel-DB-Instance zulassen. Dies ist möglicherweise bereits der Fall, wenn sich Ihre Quell- und Ziel-DB-Instances in der VPC befinden. Weitere Informationen zu Sicherheitsgruppen finden Sie unter [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
Für den Transport von Datenbanken von einer Quell-DB-Instance zu einer Ziel-DB-Instance sind mehrere Änderungen an der DB-Parametergruppe erforderlich, die mit jeder Instance verknüpft ist. Das bedeutet, dass Sie eine benutzerdefinierte DB-Parametergruppe für die Quell-DB-Instance erstellen und eine benutzerdefinierte DB-Parametergruppe für die Ziel-DB-Instance erstellen müssen.
**Anmerkung**
Wenn Ihre DB-Instances bereits mit benutzerdefinierten DB-Parametergruppen konfiguriert sind, können Sie mit Schritt 2 im folgenden Verfahren beginnen.
**Konfigurieren Sie die benutzerdefinierten DB-Gruppenparameter für den Transport von Datenbanken wie folgt:**
Verwenden Sie für die folgenden Schritte ein Konto mit `rds_superuser`-Berechtigungen.
1. Wenn die Quell- und Ziel-DB-Instances eine Standard-DB-Parametergruppe verwenden, müssen Sie eine benutzerdefinierte DB-Parametergruppe mit der entsprechenden Version für Ihre Instances erstellen. Sie tun dies, damit Sie Werte für mehrere Parameter ändern können. Weitere Informationen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
1. Ändern Sie in der benutzerdefinierten DB-Parametergruppe die Werte für die folgenden Parameter:
+ `shared_preload_libraries` – Fügen Sie `pg_transport` zur Liste der Bibliotheken hinzu.
+ `pg_transport.num_workers` – Der Standardwert ist 3. Erhöhen oder reduzieren Sie diesen Wert nach Bedarf für Ihre Datenbank. Für eine 200-GB-Datenbank empfehlen wir nicht größer als 8. Beachten Sie, dass Sie, wenn Sie den Standardwert für diesen Parameter erhöhen, auch den Wert von `max_worker_processes` erhöhen sollten.
+ `pg_transport.work_mem` – Der Standardwert beträgt je nach PostgreSQL-Version entweder 128 MB oder 256 MB. Die Standardeinstellung kann normalerweise unverändert bleiben.
+ `max_worker_processes` – Der Wert dieses Parameters muss unter Verwendung der folgenden Berechnung festgelegt werden:
```
(3 * pg_transport.num_workers) + 9
```
Dieser Wert ist am Ziel erforderlich, um verschiedene Hintergrund-Worker-Prozesse abzuwickeln, die am Transport beteiligt sind. Weitere Informationen über `max_worker_processes,` finden Sie unter [Ressourcennutzung](https://www.postgresql.org/docs/current/runtime-config-resource.html) in der PostgreSQL-Dokumentation.
Weitere Informationen zu `pg_transport`-Parametern finden Sie unter [Parameterreferenz für transportable Datenbanken](PostgreSQL.TransportableDB.Parameters.md).
1. Starten Sie die Quell-DB-Instances von RDS für PostgreSQL und die Ziel-Instance neu, damit die Einstellungen für die Parameter wirksam werden.
1. Stellen Sie eine Verbindung zu Ihrer Quell-DB-Instance von RDS für PostgreSQL her.
```
psql --host=source-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Entfernen Sie fremde Erweiterungen aus dem öffentlichen Schema der DB-Instance. Während des eigentlichen Transportvorgangs ist nur die `pg_transport`-Erweiterung zulässig.
1. Installieren Sie die `pg_transport`-Erweiterung wie folgt:
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
1. Stellen Sie eine Verbindung zu Ihrer Ziel-DB-Instance von RDS für PostgreSQL her. Entfernen Sie alle fremden Erweiterungen und installieren Sie dann die `pg_transport`-Erweiterung.
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
# Transportieren einer PostgreSQL-Datenbank von der Quelle zum Ziel
Nachdem Sie den in [Einrichten des Transports einer PostgreSQL-Datenbank](PostgreSQL.TransportableDB.Setup.md) beschriebenen Prozess abgeschlossen haben, können Sie den Transport starten. Führen Sie dazu die Funktion `transport.import_from_server` auf der Ziel-DB-Instance aus. In der folgenden Syntax finden Sie die Funktionsparameter.
```
SELECT transport.import_from_server(
'source-db-instance-endpoint',
source-db-instance-port,
'source-db-instance-user',
'source-user-password',
'source-database-name',
'destination-user-password',
false);
```
Der im Beispiel gezeigte `false`-Wert teilt der Funktion mit, dass es sich nicht um einen Trockenlauf handelt. Um die Transporteinrichtung zu testen, können Sie `true` für die Option `dry_run` angeben, wenn Sie die Funktion aufrufen, wie im Folgenden gezeigt:
```
postgres=> SELECT transport.import_from_server(
'docs-lab-source-db.666666666666aws-region.rds.amazonaws.com', 5432,
'postgres', '********', 'labdb', '******', true);
INFO: Starting dry-run of import of database "labdb".
INFO: Created connections to remote database (took 0.03 seconds).
INFO: Checked remote cluster compatibility (took 0.05 seconds).
INFO: Dry-run complete (took 0.08 seconds total).
import_from_server
--------------------
(1 row)
```
Die INFO-Zeilen werden ausgegeben, da der `pg_transport.timing`-Parameter auf seinen Standardwert eingestellt ist, `true`. Legen Sie `dry_run` auf `false` fest, wenn Sie den Befehl ausführen und die Quelldatenbank wie folgt in das Ziel importiert wird:
```
INFO: Starting import of database "labdb".
INFO: Created connections to remote database (took 0.02 seconds).
INFO: Marked remote database as read only (took 0.13 seconds).
INFO: Checked remote cluster compatibility (took 0.03 seconds).
INFO: Signaled creation of PITR blackout window (took 2.01 seconds).
INFO: Applied remote database schema pre-data (took 0.50 seconds).
INFO: Created connections to local cluster (took 0.01 seconds).
INFO: Locked down destination database (took 0.00 seconds).
INFO: Completed transfer of database files (took 0.24 seconds).
INFO: Completed clean up (took 1.02 seconds).
INFO: Physical transport complete (took 3.97 seconds total).
import_from_server
--------------------
(1 row)
```
Für diese Funktion müssen Sie Passwörter für Datenbankbenutzer angeben. Daher empfehlen wir Ihnen, die Passwörter der Benutzerrollen, die Sie für den Transportvorgang verwendet haben, nach Abschluss des Transports zu ändern. Oder Sie können SQL-Bind-Variablen verwenden, um temporäre Benutzerrollen zu erstellen. Verwenden Sie diese temporären Rollen für den Transport und entfernen Sie die Rollen anschließend.
Falls Ihr Transport nicht erfolgreich ist, wird möglicherweise eine Fehlermeldung ähnlich der folgenden angezeigt:
```
pg_transport.num_workers=8 25% of files transported failed to download file data
```
Die Fehlermeldung „Dateidaten konnte nicht heruntergeladen werden“ zeigt an, dass die Anzahl der Worker-Prozesse für die Größe der Datenbank nicht korrekt festgelegt ist. Möglicherweise müssen Sie den für `pg_transport.num_workers` festgelegten Wert erhöhen oder verringern. Jeder Fehler meldet den Prozentsatz der Fertigstellung, sodass Sie die Auswirkungen Ihrer Änderungen sehen können. Wenn Sie beispielsweise die Einstellung in einem Fall von 8 auf 4 ändern, führte dies zu Folgendem:
```
pg_transport.num_workers=4 75% of files transported failed to download file data
```
Beachten Sie, dass der Parameter `max_worker_processes` auch während des Transportvorgangs berücksichtigt wird. Mit anderen Worten, Sie müssen möglicherweise sowohl `pg_transport.num_workers` als auch `max_worker_processes` ändern, um die Datenbank erfolgreich zu transportieren. Das gezeigte Beispiel hat endlich funktioniert, als die `pg_transport.num_workers` wurde auf 2 eingestellt wurde:
```
pg_transport.num_workers=2 100% of files transported
```
Weitere Hinweise zur `transport.import_from_server`-Funktion und ihren Parametern finden Sie unter [Funktionsreferenz für transportable Datenbanken](PostgreSQL.TransportableDB.transport.import_from_server.md).
# Funktionsreferenz für transportable Datenbanken
Die `transport.import_from_server`-Funktion transportiert eine PostgreSQL-Datenbank, indem sie sie von einer Quell-DB-Instance in eine Ziel-DB-Instance importiert. Dies geschieht durch die Verwendung eines physischen Datenbankverbindungs-Transportmechanismus.
Vor dem Start des Transports überprüft diese Funktion, ob die Quell- und Ziel-DB-Instances dieselbe Version haben und für die Migration kompatibel sind. Es bestätigt auch, dass die Ziel-DB-Instance über genügend Speicherplatz für die Quelle verfügt.
**Syntax**
```
transport.import_from_server(
host text,
port int,
username text,
password text,
database text,
local_password text,
dry_run bool
)
```
**Rückgabewert**
Keine.
**Parameter**
Die Beschreibung der Parameter der `transport.import_from_server`-Funktion finden Sie in der folgenden Tabelle.
****
| Parameter | Beschreibung |
| --- | --- |
| host | Der Endpunkt der Quell-DB-Instance. |
| port | Eine ganze Zahl, die den Port der Quell-DB-Instance darstellt. PostgreSQL DB-Instances verwenden häufig den Port 5432. |
| username | Der Benutzer der Quell-DB-Instance. Dieser Benutzer muss Mitglied der Rolle `rds_superuser` sein. |
| password | Das Benutzerpasswort der Quell-DB-Instance. |
| database | Der Name der Datenbank in der zu transportierenden Quell-DB-Instance. |
| local\$1password | Das lokale Passwort des aktuellen Benutzers für die Ziel-DB-Instance. Dieser Benutzer muss Mitglied der Rolle `rds_superuser` sein. |
| dry\$1run | Ein optionaler boolescher Wert, der angibt, ob ein Trockenlauf durchgeführt werden soll. Die Voreinstellung ist `false`, was bedeutet, dass der Transport durchgeführt wird.Um die Kompatibilität zwischen der Quell- und der Ziel-DB-Instance zu bestätigen, ohne den eigentlichen Transport durchzuführen, legen Sie dry\$1run auf true fest. |
**Beispiel**
Ein Beispiel finden Sie unter [Transportieren einer PostgreSQL-Datenbank von der Quelle zum Ziel](PostgreSQL.TransportableDB.Transporting.md).
# Parameterreferenz für transportable Datenbanken
Mehrere Parameter steuern das Verhalten der `pg_transport`-Erweiterung. Im Folgenden finden Sie Beschreibungen dieser Parameter.
**`pg_transport.num_workers`**
Die Anzahl der für den Transportprozess zu verwendenden Worker. Die Voreinstellung ist 3. Gültige Werte sind 1–32. Selbst die größten Datenbanktransporte erfordern in der Regel weniger als acht Worker. Der Wert dieser Einstellung für die Ziel-DB-Instance wird während des Transports sowohl vom Ziel als auch von der Quelle verwendet.
**`pg_transport.timing` **
Gibt an, ob während des Transports Zeitinformationen übermittelt werden sollen. Der Standardwert ist `true`, was bedeutet, dass Zeitinformationen gemeldet werden. Es wird empfohlen, diesen Parameter auf `true` festzulegen, damit Sie den Fortschritt überwachen können. Eine Beispielausgabe finden Sie unter [Transportieren einer PostgreSQL-Datenbank von der Quelle zum Ziel](PostgreSQL.TransportableDB.Transporting.md).
**`pg_transport.work_mem`**
Die maximale Menge an Speicher, die für jeden Worker zugewiesen werden kann. Der Standardwert ist 131072 Kilobyte (KB) oder 262144 KB (256 MB), abhängig von der PostgreSQL-Version. Der Mindestwert beträgt 64 Megabyte (65536 KB). Gültige Werte sind in Kilobyte (KBs) als binäre Basis-2-Einheiten angegeben, wobei 1 KB = 1024 Byte ist.
Der Transport benötigt möglicherweise weniger Speicher als in diesem Parameter angegeben. Selbst große Datenbanktransporte benötigen normalerweise weniger als 256 MB (262144 KB) Speicher pro Worker.