Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Integration von Amazon Aurora PostgreSQL mit anderen Services AWS
Amazon Aurora lässt sich in andere AWS Services integrieren, sodass Sie Ihren Aurora PostgreSQL-DB-Cluster erweitern können, um zusätzliche Funktionen in der AWS Cloud zu nutzen. Ihr Aurora PostgreSQL-DB-Cluster kann AWS Dienste verwenden, um Folgendes zu tun:
+ Performance Ihrer Aurora PostgreSQL-DB-Instances mit Amazon-RDS-Performance-Insights schnell ermitteln, anzeigen und beurteilen. Performance Insights lässt sich auf vorhandene Amazon-RDS-Überwachungsfunktionen erweitern, damit Sie die Performance Ihrer Datenbank darstellen und mögliche Probleme analysieren können. Mit dem Performance-Insights-Dashboard können Sie die Datenbankauslastung visualisieren und die Auslastung nach Wartezeiten, SQL-Anweisungen, Hosts oder Benutzern filtern. Weitere Informationen zu Performance Insights finden Sie unter [Überwachung mit Performance Insights auf ](USER_PerfInsights.md).
+ Konfigurieren Sie Ihren Aurora PostgreSQL-DB-Cluster für die Veröffentlichung von Protokolldaten in Amazon CloudWatch Logs. CloudWatch Protokolle bieten einen äußerst dauerhaften Speicher für Ihre Protokolldatensätze. Mit CloudWatch Logs können Sie eine Echtzeitanalyse der Protokolldaten durchführen und diese CloudWatch zur Erstellung von Alarmen und zur Anzeige von Metriken verwenden. Weitere Informationen finden Sie unter [Veröffentlichen von Aurora-PostgreSQL-Protokollen in Amazon CloudWatch Logs](AuroraPostgreSQL.CloudWatch.md).
+ Importieren Sie Daten von einem Amazon S3-Bucket zu einem Aurora PostgreSQL DB-Cluster oder exportieren Sie Daten von einem Aurora PostgreSQL DB-Cluster zu einem Amazon S3-Bucket. Weitere Informationen erhalten Sie unter [Importieren von Amazon S3 in einen Aurora-PostgreSQL-DB-Cluster](USER_PostgreSQL.S3Import.md) und [Exportieren von Daten aus einem/einer Aurora PostgreSQL-DB-Cluster zu Amazon S3](postgresql-s3-export.md).
+ Hinzufügen von auf Machine Learning basierenden Vorhersagen zu Datenbankanwendungen unter Verwendung der SQL-Sprache. Aurora Machine Learning verwendet eine hochoptimierte Integration zwischen der Aurora-Datenbank und den AWS Machine Learning (ML) -Diensten SageMaker KI und Amazon Comprehend. Weitere Informationen finden Sie unter [Verwendung von Amazon Aurora Machine Learning mit Aurora PostgreSQL](postgresql-ml.md).
+ Rufen Sie AWS Lambda Funktionen aus einem Aurora PostgreSQL-DB-Cluster auf. Verwenden Sie dazu die `aws_lambda` PostgreSQL-Erweiterung, die mit Aurora PostgreSQL bereitgestellt wird. Weitere Informationen finden Sie unter [Aufrufen einer AWS Lambda Funktion aus einem Aurora PostgreSQL-DB-Cluster ( PostgreSQL-DB-Instance)](PostgreSQL-Lambda.md).
+ Integrieren Sie Abfragen von Amazon Redshift und Aurora PostgreSQL. Weitere Informationen finden Sie im [*Amazon Redshift Database Developer Guide* unter Getting started with using federated queries to PostgreSQL](https://docs.aws.amazon.com/redshift/latest/dg/getting-started-federated.html).
# Importieren von Amazon S3 in einen Aurora-PostgreSQL-DB-Cluster
Sie können Daten, die mit Amazon Simple Storage Service gespeichert wurden, in eine Tabelle auf einer Aurora PostgreSQL DB-Cluster-Instance importieren. Um dies zu tun, installieren Sie zuerst die `aws_s3`-Erweiterung von Aurora 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 zu importieren, muss Ihre Datenbank PostgreSQL Version 10.7 oder höher verwenden. Aurora PostgreSQL
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*.
**Anmerkung**
Das Importieren von Daten aus Amazon S3 wird für Aurora Serverless v1 nicht unterstützt. Es wird für Aurora Serverless v2 unterstützt.
**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 Aurora PostgreSQL-DB-Cluster () importieren](USER_PostgreSQL.S3Import.FileFormats.md)
+ [Funktionsreferenz](USER_PostgreSQL.S3Import.Reference.md)
# Installieren der Erweiterung aws\$1s3
Bevor Sie Amazon S3 mit Ihrem Aurora-PostgreSQL-DB-Cluster 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 Instance eines Aurora-PostgreSQL-DB-Clusters zu einem Amazon-S3-Bucket. Weitere Informationen finden Sie unter [Exportieren von Daten aus einem/einer Aurora PostgreSQL-DB-Cluster 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 Writer-Instance Ihres DB-Clusters von Aurora 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 Aurora PostgreSQL :**
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 Instance Ihres Aurora PostgreSQL-DB-Clusters, 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/AuroraUserGuide/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 Ihrem Aurora-PostgreSQL-DB-Cluster 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 Aurora PostgreSQL-DB-Cluster () 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 RDS für PostgreSQL-DB-Instance des 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 Aurora PostgreSQL DB-Cluster- 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 Cluster zu.
**Anmerkung**
Sie können einem Aurora Serverless v1-DB-Cluster keine IAM-Rolle zuordnen, daher gelten die folgenden Schritte nicht.
**So geben Sie einer Aurora PostgreSQL DB-Cluster über eine IAM-Rolle Zugriff auf Amazon S3:**
1. Erstellen Sie eine IAM-Richtlinie.
Diese Richtlinie enthält die Bucket- und Objektberechtigungen, die Ihrer Aurora PostgreSQL DB-Cluster- 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 Aurora PostgreSQL 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 Aurora 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 Aurora PostgreSQL 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:cluster:clustername"
}
}
}
]
}'
```
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:cluster:clustername"
}
}
}
]
}'
```
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 Cluster 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-Cluster- ü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-Cluster- 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 Cluster-** 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 einen PostgreSQL-DB-Cluster mithilfe der CLI hinzu:**
+ Verwenden Sie den folgenden Befehl, um die Rolle mit dem Namen `my-db-cluster` zum PostgreSQL DB-Cluster 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-cluster \
--db-cluster-identifier my-db-cluster \
--feature-name s3Import \
--role-arn your-role-arn \
--region your-region
```
Für Windows:
```
aws rds add-role-to-db-cluster ^
--db-cluster-identifier my-db-cluster ^
--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. [AddRoleToDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AddRoleToDBCluster.html)
## 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 Aurora-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 Aurora PostgreSQL-DB-Cluster () 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 Cluster, 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 Aurora PostgreSQL DB-Cluster-.
```
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 Aurora PostgreSQL-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-Cluster- 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 und Availability 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 und Availability 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 und Availability 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.
# Exportieren von Daten aus einem/einer Aurora PostgreSQL-DB-Cluster zu Amazon S3
Sie können Daten aus einem Aurora-PostgreSQL-DB-Cluster abfragen und direkt in Dateien exportieren, die in einem Amazon-S3-Bucket gespeichert sind. Dazu installieren Sie zuerst die Erweiterung von Aurora PostgreSQL `aws_s3`. Diese Erweiterung stellt die Funktionen bereit, die Sie zum Exportieren von Abfrageergebnissen nach Amazon S3 verwenden. Im Folgenden erfahren Sie, wie Sie die Erweiterung installieren und Daten nach Amazon S3 exportieren.
Sie können nur von einer bereitgestellten oder einer DB-Instance von Aurora Serverless v2 aus exportieren. Diese Schritte werden für Aurora Serverless v1 nicht unterstützt.
**Anmerkung**
Kontoübergreifender Export nach Amazon S3 wird nicht unterstützt.
Alle derzeit verfügbaren Aurora-PostgreSQL-Versionen unterstützen den Export von Daten nach Amazon Simple Storage Service. Ausführliche Versionsinformationen finden Sie unter [Aktualisierungen von Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) im Abschnitt *Versionshinweise für Aurora PostgreSQL*.
Wenn Sie keinen Bucket für Ihren Export eingerichtet haben, lesen Sie die folgenden Themen im *Benutzerhandbuch von Amazon Simple Storage Service*.
+ [Einrichten von Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/setting-up-s3.html)
+ [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)
Standardmäßig verwenden die von Aurora PostgreSQL nach Amazon S3 exportierten Daten serverseitige Verschlüsselung mit. Von AWS verwalteter Schlüssel Sie können alternativ einen vom Kunden verwalteten Schlüssel verwenden, den Sie bereits erstellt haben. Wenn Sie die Bucket-Verschlüsselung verwenden, muss der Amazon S3 S3-Bucket mit dem AWS Key Management Service (AWS KMS) -Schlüssel (SSE-KMS) verschlüsselt werden. Derzeit werden Buckets, die mit Schlüsseln verschlüsselt sind, die von Amazon S3 (SSE-S3) verwaltet werden, nicht unterstützt.
**Anmerkung**
Sie können DB- und DB-Cluster-Snapshot-Daten mit der AWS-Managementkonsole AWS CLI, oder Amazon RDS-API in Amazon S3 speichern. Weitere Informationen finden Sie unter [Exportieren von Daten von DB-Cluster-Snapshots nach Amazon S3](aurora-export-snapshot.md).
**Topics**
+ [Installieren der Erweiterung aws\$1s3](#USER_PostgreSQL.S3Export.InstallExtension)
+ [Übersicht über das Exportieren von Daten zu Amazon S3](#postgresql-s3-export-overview)
+ [Angeben des Amazon S3-Dateipfads für den Export](#postgresql-s3-export-file)
+ [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](postgresql-s3-export-access-bucket.md)
+ [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md)
+ [Funktionsreferenz](postgresql-s3-export-functions.md)
+ [Fehlerbehebung beim Zugriff auf Amazon S3](postgresql-s3-export-troubleshoot.md)
## Installieren der Erweiterung aws\$1s3
Bevor Sie Amazon Simple Storage Service mit Ihrem DB-Cluster voon Aurora PostgreSQL verwenden können, müssen Sie die Erweiterung `aws_s3` installieren. Diese Erweiterung bietet Funktionen zum Exportieren von Daten aus der Writer-Instance eines DB-Clusters von Aurora PostgreSQL in einen Amazon-S3-Bucket Sie stellt außerdem Funktionen zum Importieren von Daten aus Amazon S3 bereit. Weitere Informationen finden Sie unter [Importieren von Amazon S3 in einen Aurora-PostgreSQL-DB-Cluster](USER_PostgreSQL.S3Import.md). Die Erweiterung `aws_s3` hängt von einigen Hilfsfunktionen in der Erweiterung `aws_commons` ab, die bei Bedarf automatisch installiert wird.
**So installieren Sie die Erweiterung `aws_s3`**
1. Verwenden Sie psql (oder pgAdmin), um eine Verbindung mit der Writer-Instance Ihres DB-Clusters von Aurora PostgreSQL als Benutzer mit `rds_superuser`-Berechtigungen herzustellen. Wenn Sie beim Einrichten den Standardnamen beibehalten haben, stellen Sie eine Verbindung als `postgres` her.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Führen Sie den folgenden Befehl aus, um die Erweiterung zu installieren.
```
postgres=> CREATE EXTENSION aws_s3 CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
1. Wenn Sie überprüfen möchten, ob die Erweiterung installiert wurde, können Sie psql-Metabefehl `\dx` verwenden.
```
postgres=> \dx
List of installed extensions
Name | Version | Schema | Description
-------------+---------+------------+---------------------------------------------
aws_commons | 1.2 | public | Common data types across AWS services
aws_s3 | 1.1 | public | AWS S3 extension for importing data from S3
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
(3 rows)
```
Die Funktionen zum Importieren von Daten aus Amazon S3 und Exportieren von Daten nach Amazon S3 sind jetzt verfügbar.
### Stellen Sie sicher, dass Ihre Aurora PostgreSQL Exporte nach Amazon S3 unterstützt
Sie können überprüfen, ob Ihre Version von Aurora PostgreSQL den Export nach Amazon S3 unterstützt, indem Sie den Befehl `describe-db-engine-versions` verwenden. Im folgenden Beispiel wird überprüft, ob Version 10.14 nach Amazon S3 exportieren kann.
```
aws rds describe-db-engine-versions --region us-east-1 \
--engine aurora-postgresql --engine-version 10.14 | grep s3Export
```
Wenn die Ausgabe die Zeichenfolge `"s3Export"` enthält, unterstützt die Engine Amazon S3-Exporte. Ansonsten unterstützt die Engine sie nicht.
## Übersicht über das Exportieren von Daten zu Amazon S3
Verwenden Sie das folgende Verfahren, um in einer Aurora PostgreSQL Datenbank gespeicherte Daten in einen Amazon S3 Bucket zu exportieren.
**So exportieren Sie Aurora PostgreSQLDaten nach S3**
1. Identifizieren Sie einen Amazon S3-Dateipfad, der zum Exportieren von Daten verwendet werden soll. Weitere Informationen zu diesem Prozess finden Sie unter [Angeben des Amazon S3-Dateipfads für den Export](#postgresql-s3-export-file).
1. Erteilen Sie die Berechtigung für den Zugriff auf den Amazon S3-Bucket.
Um Daten in eine Amazon S3-Datei zu exportieren, erteilen Sie dem/der Aurora PostgreSQL-DB-Cluster die Berechtigung, auf den Amazon S3-Bucket zuzugreifen, den der Export für die Speicherung verwendet. Dazu gehören die folgenden Schritte:
1. Erstellen Sie eine IAM-Richtlinie, die Zugriff auf einen Amazon S3-Bucket bietet, in den Sie exportieren möchten.
1. Erstellen Sie eine IAM-Rolle.
1. Fügen Sie die erstellte Richtlinie an die erstellte Rolle an.
1. Fügen Sie diese IAM-Rolle zu Ihrem DB-Cluster Ihrer hinzu.
Weitere Informationen zu diesem Prozess finden Sie unter [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](postgresql-s3-export-access-bucket.md).
1. Identifizieren Sie eine Datenbankabfrage, um die Daten abzurufen. Exportieren Sie die Abfragedaten, indem Sie die Funktion `aws_s3.query_export_to_s3` aufrufen.
Nachdem Sie die vorangegangenen Vorbereitungsaufgaben abgeschlossen haben, verwenden Sie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion, um Abfrageergebnisse in Amazon S3 zu exportieren. Weitere Informationen zu diesem Prozess finden Sie unter [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
## Angeben des Amazon S3-Dateipfads für den Export
Geben Sie die folgenden Informationen an, um den Speicherort in Amazon S3 zu identifizieren, in den Sie Daten exportieren möchten:
+ Bucket-Name – Ein *Bucket* ist ein Container für Amazon S3-Objekte oder -Dateien.
Weitere Informationen zum Speichern von Daten mit Amazon S3 finden Sie unter [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) und [Arbeiten mit Objekten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-downloading-objects.html) im *Benutzerhandbuch für Amazon Simple Storage Service*.
+ Dateipfad – Der Dateipfad gibt an, wo der Export im Amazon S3-Bucket gespeichert wird. Der Dateipfad besteht aus Folgendem:
+ Ein optionales Pfadpräfix, das einen Pfad für virtuelle Ordner identifiziert.
+ Ein Dateipräfix, das eine oder mehrere Dateien identifiziert, die gespeichert werden sollen. Größere Exporte werden in mehreren Dateien gespeichert, jeweils mit einer maximalen Größe von ca. 6 GB. Die zusätzlichen Dateinamen haben das gleiche Dateipräfix, aber mit `_partXX` angefügt. `XX` stellt 2, dann 3 usw. dar.
Beispielsweise ist ein Dateipfad mit einem `exports`-Ordner und einem `query-1-export`-Dateipräfix `/exports/query-1-export`.
+ AWS Region (optional) — Die AWS Region, in der sich der Amazon S3 S3-Bucket befindet. Wenn Sie keinen AWS Regionswert angeben, speichert Aurora Ihre Dateien in Amazon S3 in derselben AWS Region wie die exportierende .
**Anmerkung**
Derzeit muss die AWS Region mit der Region der exportierenden identisch sein.
Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[ Regionen und Availability Zones](Concepts.RegionsAndAvailabilityZones.md).
Um die Amazon S3-Dateiinformationen darüber zu speichern, wo der Export gespeichert werden soll, können Sie die [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri)-Funktion verwenden, um eine zusammengesetzte `aws_commons._s3_uri_1`-Struktur wie folgt zu erstellen.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Sie geben diesen `s3_uri_1`-Wert später als Parameter im Aufruf der [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion an. Beispiele finden Sie unter [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
# Einrichten des Zugriffs auf einen Amazon-S3-Bucket
Um Daten zu Amazon S3 zu exportieren, erteilen Sie Ihrem PostgreSQL-DB-Cluster die Berechtigung, auf den Amazon S3-Bucket zuzugreifen, in den die Dateien aufgenommen werden sollen.
Führen Sie dazu die folgenden Schritte aus.
**So erteilen Sie einem PostgreSQL-DB-Cluster Zugriff auf Amazon S3 über eine IAM-Rolle**
1. Erstellen Sie eine IAM-Richtlinie.
Diese Richtlinie enthält die Bucket- und Objektberechtigungen, die IhremPostgreSQL-DB-Cluster den Zugriff auf Amazon S3 ermöglichen.
Führen Sie beim Erstellen dieser Richtlinie die folgenden Schritte aus:
1. Nehmen Sie die folgenden erforderlichen Aktionen in die Richtlinie auf, um die Übertragung von Dateien aus Ihrem PostgreSQL-DB-Cluster in einen Amazon S3-Bucket zu gestatten:
+ `s3:PutObject`
+ `s3:AbortMultipartUpload`
1. Geben Sie den Amazon-Ressourcennamen (ARN) ein, der den Amazon S3-Bucket und die Objekte im Bucket identifiziert. Das ARN-Format für den Zugriff auf Amazon S3 lautet: `arn:aws:s3:::amzn-s3-demo-bucket/*`
Weitere Informationen zum Erstellen einer IAM-Richtlinie für Aurora PostgreSQL finden Sie unter [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Siehe auch [Tutorial: Erstellen und Anfügen Ihrer ersten vom Kunden verwalteten Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) im *IAM-Benutzerhandbuch*.
Mit dem folgenden AWS CLI Befehl wird eine IAM-Richtlinie `rds-s3-export-policy` mit diesen Optionen erstellt. Sie gewährt Zugriff auf einen Bucket namens *amzn-s3-demo-bucket*.
**Warnung**
Es wird empfohlen, die Datenbank innerhalb einer privaten VPC einzurichten, deren Endpunktrichtlinien für den Zugriff auf bestimmte Buckets konfiguriert sind. Weitere Informationen finden Sie unter [Verwenden von Endpunktrichtlinien für Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html#vpc-endpoints-policies-s3) im Amazon VPC Benutzerhandbuch.
Es wird dringend empfohlen, keine Richtlinie mit Zugriff auf alle Ressourcen zu erstellen. Dieser Zugriff kann eine Bedrohung für die Datensicherheit darstellen. Wenn Sie eine Richtlinie erstellen, die `S3:PutObject` Zugriff auf alle Ressourcen mit `"Resource":"*"` gewährt, kann ein Benutzer mit Exportberechtigungen Daten in alle Buckets in Ihrem Konto exportieren. Darüber hinaus kann der Benutzer Daten in *jeden öffentlich beschreibbaren Bucket in Ihrer AWS -Region* exportieren.
Notieren Sie nach dem Erstellen der Richtlinie den Amazon-Ressourcennamen (ARN) der Richtlinie. Sie benötigen den ARN für einen nachfolgenden Schritt, in dem Sie die Richtlinie an eine IAM-Rolle anhängen.
```
aws iam create-policy --policy-name rds-s3-export-policy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3export",
"Action": [
"s3:PutObject*",
"s3:ListBucket",
"s3:GetObject*",
"s3:DeleteObject*",
"s3:GetBucketLocation",
"s3:AbortMultipartUpload"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
1. Erstellen Sie eine IAM-Rolle.
Sie tun dies, damit Aurora PostgreSQL in Ihrem Namen diese IAM-Rolle übernehmen kann, um auf Ihre Amazon S3-Buckets zuzugreifen. Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.
Wir empfehlen die Verwendung von `[aws:SourceArn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)` und `[aws:SourceAccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)` globaler Bedingungskontext-Schlüssel in ressourcenbasierten Richtlinien, um die Berechtigungen des Dienstes auf eine bestimmte Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.
Wenn Sie sowohl globale Kontextschlüssel nutzen und der `aws:SourceArn`-Wert enthält die Konto-ID, muss der `aws:SourceAccount`-Wert und das Konto im `aws:SourceArn`-Wert die gleiche Konto-ID verwenden, wenn er in der gleichen Richtlinienanweisung verwendet wird.
+ Verwenden von `aws:SourceArn` wenn Sie einen serviceübergreifenden Zugriff für eine einzelne Ressource wünschen.
+ Verwenden von `aws:SourceAccount` wenn Sie zulassen möchten, dass eine Ressource in diesem Konto mit der betriebsübergreifenden Verwendung verknüpft wird.
Verwenden Sie in der Richtlinie den `aws:SourceArn` globalen Kontextschlüssel mit dem vollständigen ARN der Ressource. Das folgende Beispiel zeigt, wie Sie dazu den AWS CLI Befehl verwenden, um eine Rolle mit dem Namen `rds-s3-export-role` zu erstellen.
**Example**
Für Linux, macOS oder Unix:
```
aws iam create-role \
--role-name rds-s3-export-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:cluster:dbname"
}
}
}
]
}'
```
Für Windows:
```
aws iam create-role ^
--role-name rds-s3-export-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:cluster:dbname"
}
}
}
]
}'
```
1. Fügen Sie die erstellte IAM-Richtlinie der IAM-Rolle an, die Sie erstellt haben.
Mit dem folgenden AWS CLI Befehl wird die zuvor erstellte Richtlinie an die Rolle `rds-s3-export-role.` Replace `your-policy-arn` mit dem Richtlinien-ARN angehängt, den Sie in einem früheren Schritt notiert haben.
```
aws iam attach-role-policy --policy-arn your-policy-arn --role-name rds-s3-export-role
```
1. Fügen Sie die IAM-Rolle der DB Cluster hinzu. Sie tun dies, indem Sie das AWS-Managementkonsole oder verwenden AWS CLI, wie im Folgenden beschrieben.
## Konsole
**So fügen Sie eine IAM-Rolle für eine PostgreSQL DB-Cluster- ü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-Cluster- aus, um ihre Details anzuzeigen.
1. Wählen Sie auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** im Bereich **Manage IAM roles (IAM-Rollen verwalten)** die Rolle aus, die unter **Add IAM roles to this instance (IAM-Rollen zu dieser Instance hinzufügen)** hinzugefügt werden soll.
1. Wählen Sie unter **Funktion** die Option **s3Export** aus.
1. Wählen Sie **Rolle hinzufügen**.
## AWS CLI
**So fügen Sie eine IAM-Rolle für einen PostgreSQL-DB-Cluster mithilfe der CLI hinzu:**
+ Verwenden Sie den folgenden Befehl, um die Rolle mit dem Namen `my-db-cluster` zum PostgreSQL DB-Cluster hinzuzufügen. Ersetzen Sie *`your-role-arn`* durch den Rollen-ARN, den Sie im vorherigen Schritt notiert haben. Verwenden Sie `s3Export` für den Wert der `--feature-name`-Option.
**Example**
Für Linux, macOS oder Unix:
```
aws rds add-role-to-db-cluster \
--db-cluster-identifier my-db-cluster \
--feature-name s3Export \
--role-arn your-role-arn \
--region your-region
```
Für Windows:
```
aws rds add-role-to-db-cluster ^
--db-cluster-identifier my-db-cluster ^
--feature-name s3Export ^
--role-arn your-role-arn ^
--region your-region
```
# Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3
Exportieren Sie Ihre PostgreSQL-Daten nach Amazon S3, indem Sie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion aufrufen.
**Topics**
+ [Voraussetzungen](#postgresql-s3-export-examples-prerequisites)
+ [Aufruf von aws\$1s3.query\$1export\$1to\$1s3](#postgresql-s3-export-examples-basic)
+ [Exportieren in eine CSV-Datei, die ein benutzerdefiniertes Trennzeichen verwendet](#postgresql-s3-export-examples-custom-delimiter)
+ [Exportieren in eine Binärdatei mit Codierung](#postgresql-s3-export-examples-encoded)
## Voraussetzungen
Bevor Sie die `aws_s3.query_export_to_s3`-Funktion verwenden, müssen Sie die folgenden Voraussetzungen erfüllen:
+ Installieren Sie die erforderlichen PostgreSQL-Erweiterungen, wie unter beschriebe [Übersicht über das Exportieren von Daten zu Amazon S3](postgresql-s3-export.md#postgresql-s3-export-overview).
+ Legen Sie fest, wohin die Daten nach Amazon S3 exportiert werden sollen, wie unter beschriebe [Angeben des Amazon S3-Dateipfads für den Export](postgresql-s3-export.md#postgresql-s3-export-file).
+ Stellen Sie sicher, dass die Exportzugriff auf Amazon S3 hat (wie unter [Einrichten des Zugriffs auf einen Amazon-S3-Bucket](postgresql-s3-export-access-bucket.md) beschrieben).
In den folgenden Beispielen wird eine Datenbanktabelle namens verwende `sample_table`. In diesen Beispielen werden die Daten in einen Bucket namens exportier *amzn-s3-demo-bucket*. Die Beispieltabelle und die Daten werden mit den folgenden SQL-Anweisungen in psql erstellt.
```
psql=> CREATE TABLE sample_table (bid bigint PRIMARY KEY, name varchar(80));
psql=> INSERT INTO sample_table (bid,name) VALUES (1, 'Monday'), (2,'Tuesday'), (3, 'Wednesday');
```
## Aufruf von aws\$1s3.query\$1export\$1to\$1s3
Im Folgenden werden die grundlegenden Möglichkeiten zum Aufrufen der [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion dargestellt.
In diesen Beispielen wird die Variable `s3_uri_1` zum Identifizieren einer Struktur verwendet, die die Informationen zur Identifizierung der Amazon S3-Datei enthält. Verwenden Sie die Funktion [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri), um die Struktur zu erstellen.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Obwohl die Parameter für die folgenden zwei `aws_s3.query_export_to_s3`-Funktionsaufrufe unterschiedlich sind, sind die Ergebnisse für diese Beispiele identisch. Alle Zeilen der `sample_table`-Tabelle werden in einen Bucket namens *amzn-s3-demo-bucket* exportiert.
```
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1');
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1', options :='format text');
```
Die Parameter werden wie folgt beschrieben:
+ `'SELECT * FROM sample_table'` – Der erste Parameter ist eine erforderliche Textzeichenfolge, die eine SQL-Abfrage enthält. Die PostgreSQL-Engine führt diese Abfrage aus. Die Ergebnisse der Abfrage werden in den S3-Bucket kopiert, der in anderen Parametern identifiziert wurde.
+ `:'s3_uri_1'` – Dieser Parameter ist eine Struktur, die die Datei Amazon S3 identifiziert. In diesem Beispiel wird die zuvor erstellte Struktur anhand einer Variablen identifiziert. Sie können die Struktur stattdessen erstellen, indem Sie den Funktionsaufruf `aws_commons.create_s3_uri` wie folgt inline in den Funktionsaufruf `aws_s3.query_export_to_s3` einschließen.
```
SELECT * from aws_s3.query_export_to_s3('select * from sample_table',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'sample-filepath', 'us-west-2')
);
```
+ `options :='format text'` – Der `options`-Parameter ist eine optionale Textzeichenfolge, die `COPY`-PostgreSQL-Argumente enthält. Beim Kopiervorgang werden die Argumente und das Format des [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html)-Befehls verwendet.
Wenn die angegebene Datei nicht im Amazon S3-Bucket vorhanden ist, wird sie erstellt. Wenn die Datei bereits vorhanden ist, wird sie überschrieben. Die Syntax für den Zugriff auf die exportierten Daten in Amazon S3 ist die folgende.
```
s3-region://bucket-name[/path-prefix]/file-prefix
```
Größere Exporte werden in mehreren Dateien gespeichert, jeweils mit einer maximalen Größe von ca. 6 GB. Die zusätzlichen Dateinamen haben das gleiche Dateipräfix, aber mit `_partXX` angefügt. `XX` stellt 2, dann 3 usw. dar. Angenommen, Sie geben den Pfad, in dem Sie Datendateien speichern, wie folgt an.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
```
Wenn der Export drei Datendateien anlegen muss, enthält der Amazon S3-Bucket die folgenden Datendateien.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part2
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part3
```
Die vollständige Referenz für diese Funktion und weitere Aufrufmöglichkeiten finden Sie unter [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Weitere Informationen zum Zugriff auf Dateien in Amazon S3 finden Sie unter [View an object](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) im *Amazon Simple Storage Service User Guide.*
## Exportieren in eine CSV-Datei, die ein benutzerdefiniertes Trennzeichen verwendet
Das folgende Beispiel zeigt, wie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion zum Exportieren von Daten in eine Datei aufgerufen wird, die ein benutzerdefiniertes Trennzeichen verwendet. Im Beispiel werden Argumente des Befehls [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html) verwendet, um das CSV-Dateiformat (durch Kommas getrennte Werte) und ein Doppelpunkt (:)-Trennzeichen anzugeben.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format csv, delimiter $$:$$');
```
## Exportieren in eine Binärdatei mit Codierung
Das folgende Beispiel zeigt, wie die [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3)-Funktion zum Exportieren von Daten in eine Binärdatei mit Windows-1253-Codierung aufgerufen wird.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format binary, encoding WIN1253');
```
# Funktionsreferenz
**Topics**
+ [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3)
+ [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri)
## aws\$1s3.query\$1export\$1to\$1s3
Exportiert ein PostgreSQL-Abfrageergebnis in einen Amazon S3-Bucket. Die Erweiterung `aws_s3` stellt die Funktion `aws_s3.query_export_to_s3` bereit.
Die zwei erforderlichen Parameter sind `query` und `s3_info`. Diese definieren die zu exportierende Abfrage und identifizieren den Amazon S3-Bucket, in den exportiert werden soll. Ein optionaler Parameter namens `options` ermöglicht die Definition verschiedener Exportparameter. Beispiele für die Verwendung der `aws_s3.query_export_to_s3`-Funktion finden Sie unter [Exportieren von Abfragedaten mithilfe der Funktion aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
**Syntax**
```
aws_s3.query_export_to_s3(
query text,
s3_info aws_commons._s3_uri_1,
options text,
kms_key text
)
```Eingabeparameter
*query*
Eine erforderliche Textzeichenfolge, die eine SQL-Abfrage enthält, die von der PostgreSQL-Engine ausgeführt wird. Die Ergebnisse dieser Abfrage werden in einen S3-Bucket kopiert, der im `s3_info`-Parameter identifiziert wurde.
*s3\$1info*
Ein zusammengesetzter `aws_commons._s3_uri_1`-Typ mit den folgenden Informationen zum S3-Objekt:
+ `bucket` – Der Name des Amazon S3-Buckets, der die Datei enthalten soll.
+ `file_path` – Der Amazon S3-Dateiname und der -Pfad.
+ `region`— Die AWS Region, in der sich der Bucket befindet. Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[ Regionen und Availability Zones](Concepts.RegionsAndAvailabilityZones.md).
Derzeit muss dieser Wert dieselbe AWS Region wie die der exportierenden sein. Die Standardeinstellung ist die AWS Region der exportierenden .
Informationen zum Erstellen einer zusammengesetzten `aws_commons._s3_uri_1`-Struktur finden Sie in der [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri)-Funktion.
*options*
Eine optionale Textzeichenfolge mit Argumenten für den PostgreSQL `COPY`-Befehl. Diese Argumente geben an, wie die Daten beim Exportieren kopiert werden sollen. Weitere Informationen finden Sie in der [PostgreSQL COPY-Dokumentation](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Eine optionale Textzeichenfolge, die den vom Kunden verwalteten KMS-Schlüssel des S3-Buckets enthält, in den die Daten exportiert werden sollen.
### Alternative Eingabeparameter
Zum Testen können Sie statt des Parameters `s3_info` eine erweiterte Gruppe von Parametern verwenden. Nachfolgend sind weitere Syntaxvariationen für die Funktion `aws_s3.query_export_to_s3` aufgeführt.
Statt den Parameter `s3_info` zum Identifizieren einer Amazon S3-Datei zu verwenden, nutzen Sie die Kombination aus den Parametern `bucket`, `file_path` und `region`.
```
aws_s3.query_export_to_s3(
query text,
bucket text,
file_path text,
region text,
options text,
kms_key text
)
```
*query*
Eine erforderliche Textzeichenfolge, die eine SQL-Abfrage enthält, die von der PostgreSQL-Engine ausgeführt wird. Die Ergebnisse dieser Abfrage werden in einen S3-Bucket kopiert, der im `s3_info`-Parameter identifiziert wurde.
*bucket*
Eine erforderliche Textzeichenfolge mit dem Namen des Amazon S3-Buckets, der die Datei enthält.
*file\$1path*
Eine erforderliche Textzeichenfolge, die den Amazon S3-Dateinamen einschließlich des Pfads der Datei enthält.
*Region*
Eine optionale Textzeichenfolge, die die AWS Region enthält, in der sich der Bucket befindet. Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[ Regionen und Availability Zones](Concepts.RegionsAndAvailabilityZones.md).
Derzeit muss dieser Wert dieselbe AWS Region wie die der exportierenden sein. Die Standardeinstellung ist die AWS Region der exportierenden .
*options*
Eine optionale Textzeichenfolge mit Argumenten für den PostgreSQL `COPY`-Befehl. Diese Argumente geben an, wie die Daten beim Exportieren kopiert werden sollen. Weitere Informationen finden Sie in der [PostgreSQL COPY-Dokumentation](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Eine optionale Textzeichenfolge, die den vom Kunden verwalteten KMS-Schlüssel des S3-Buckets enthält, in den die Daten exportiert werden sollen.
### Ausgabeparameter
```
aws_s3.query_export_to_s3(
OUT rows_uploaded bigint,
OUT files_uploaded bigint,
OUT bytes_uploaded bigint
)
```
*rows\$1uploaded*
Die Anzahl der Tabellenzeilen, die für die angegebene Abfrage erfolgreich in Amazon S3 hochgeladen wurden.
*files\$1uploaded*
Die Anzahl der in Amazon S3 hochgeladenen Dateien. Dateien werden in Größen von ca. 6 GB erstellt. Jeder weiteren erstellten Datei wird `_partXX` an den Namen angehängt. `XX` stellt 2, dann 3 usw. nach Bedarf dar.
*bytes\$1uploaded*
Die Gesamtanzahl der in Amazon S3 hochgeladenen Bytes.
### Beispiele
```
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2','format text');
```
## aws\$1commons.create\$1s3\$1uri
Erstellt eine `aws_commons._s3_uri_1`-Struktur für die Amazon S3-Dateiinformationen. Die Ergebnisse der Funktion `aws_commons.create_s3_uri` werden im Parameter `s3_info` der Funktion [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3) verwendet. Ein Beispiel für die Verwendung der `aws_commons.create_s3_uri`-Funktion finden Sie unter [Angeben des Amazon S3-Dateipfads für den Export](postgresql-s3-export.md#postgresql-s3-export-file).
**Syntax**
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```Eingabeparameter
*bucket*
Eine erforderliche Textzeichenfolge mit dem Namen des Amazon S3-Buckets für die Datei.
*file\$1path*
Eine erforderliche Textzeichenfolge, die den Amazon S3-Dateinamen einschließlich des Pfads der Datei enthält.
*Region*
Eine erforderliche Textzeichenfolge, die die AWS Region enthält, in der sich die Datei befindet. Eine Liste der AWS Regionsnamen und der zugehörigen Werte finden Sie unter[ Regionen und Availability Zones](Concepts.RegionsAndAvailabilityZones.md).
# Fehlerbehebung beim Zugriff auf Amazon S3
Wenn beim Versuch, Daten nach Amazon S3 zu exportieren, Verbindungsprobleme auftreten, bestätigen Sie zunächst, dass die Regeln für den ausgehenden Zugriff für die mit Ihrer DB-Instance verknüpfte VPC-Sicherheitsgruppe Netzwerkkonnektivität zulassen. Insbesondere muss die Sicherheitsgruppe über eine Regel verfügen, die es der DB-Instance erlaubt, TCP-Datenverkehr über Port 443 und an eine beliebige IPv4-Adresse (0.0.0.0/0) zu senden. Weitere Informationen finden Sie unter [Ermöglichen des Zugriffs auf den DB-Cluster in der VPC durch Erstellen einer Sicherheitsgruppe](CHAP_SettingUp_Aurora.md#CHAP_SettingUp_Aurora.SecurityGroup).
Empfehlungen finden Sie im Folgenden:
+ [Fehlerbehebung für Amazon Aurora-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*
# Aufrufen einer AWS Lambda Funktion aus einem Aurora PostgreSQL-DB-Cluster ( PostgreSQL-DB-Instance)
AWS Lambda ist ein ereignisgesteuerter Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Es ist für die Verwendung mit vielen AWS Diensten verfügbar, einschließlich Aurora PostgreSQL PostgreSQL. Sie können beispielsweise Lambda-Funktionen verwenden, um Ereignisbenachrichtigungen aus einer Datenbank zu verarbeiten oder Daten aus Dateien zu laden, wann immer eine neue Datei in Amazon S3 hochgeladen wird. Weitere Informationen zu Lambda finden Sie unter [Was ist AWS Lambda?](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) im *AWS Lambda Entwicklerhandbuch*.
**Anmerkung**
Das Aufrufen von AWS Lambda Funktionen wird in Aurora PostgreSQL 11.9 und höher (einschließlich) unterstützt. Aurora Serverless v2
Im Folgenden finden Sie Zusammenfassungen der notwendigen Schritte.
Weitere Informationen über Lambda-Funktionen finden Sie unter [Erste Schritte mit Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) und [Grundlagen von AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-foundation.html) im *AWS Lambda -Entwicklerhandbuch*.
**Topics**
+ [Schritt 1: Konfigurieren Sie Ihren Aurora PostgreSQL DB-Cluster für ausgehende Verbindungen zu AWS Lambda](#PostgreSQL-Lambda-network)
+ [Schritt 2: Konfigurieren Sie IAM für Ihren Aurora PostgreSQL-DB-Cluster, und AWS Lambda](#PostgreSQL-Lambda-access)
+ [Schritt 3: Installieren Sie die `aws_lambda` Erweiterung für eine Aurora](#PostgreSQL-Lambda-install-extension)
+ [Schritt 4: Verwenden von Lambda-Hilfsfunktionen mit Ihrem Aurora-PostgreSQL-DB-Cluster (optional)](#PostgreSQL-Lambda-specify-function)
+ [Schritt 5: Aufrufen einer Lambda-Funktion von Ihrem Aurora-PostgreSQL-DB-Cluster](#PostgreSQL-Lambda-invoke)
+ [Schritt 6: Erteilen der Berechtigung, Lambda-Funktionen aufzurufen, für andere Benutzer](#PostgreSQL-Lambda-grant-users-permissions)
+ [Beispiele: Aufrufen von Lambda-Funktionen von Ihrem Aurora-PostgreSQL-DB-Cluster](PostgreSQL-Lambda-examples.md)
+ [Fehlermeldungen von Lambda-Funktionen](PostgreSQL-Lambda-errors.md)
+ [Referenz für AWS Lambda-Funktionen und -Parameter](PostgreSQL-Lambda-functions.md)
## Schritt 1: Konfigurieren Sie Ihren Aurora PostgreSQL DB-Cluster für ausgehende Verbindungen zu AWS Lambda
Lambda-Funktionen werden immer in einer Amazon-VPC ausgeführt, die dem AWS Lambda Service gehört. Lambda wendet Netzwerkzugriffs- und Sicherheitsregeln auf diese VPC an und pflegt und überwacht die VPC automatisch. Ihr DB-Cluster von Aurora-PostgreSQL muss Netzwerkdatenverkehr an die VPC des Lambda-Services senden. Wie Sie dies konfigurieren, hängt davon ab, ob die primäre DB-Instance Ihres Aurora-DB-Clusters öffentlich oder privat ist.
+ **Öffentlicher Aurora PostgreSQL-DB-Cluster ** — Die primäre eines DB-Clusters ist öffentlich, wenn sie sich in einem öffentlichen Subnetz auf Ihrer VPC befindet und wenn die Eigenschaft "" der Instance lautet. PubliclyAccessible `true` Um den Wert dieser Eigenschaft zu ermitteln, können Sie den Befehl verwenden. [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) AWS CLI Alternativ können Sie über die AWS-Managementkonsole die Registerkarte **Connectivity & security** (Konnektivität und Sicherheit) öffnen und prüfen, ob **Publicly accessible** (Öffentlich zugänglich) auf **Yes** (Ja) eingestellt ist. Wenn Sie überprüfen möchten, ob sich die Instance im öffentlichen Subnetz Ihrer VPC befindet, können Sie die AWS-Managementkonsole oder die AWS CLI verwenden.
Um den Zugriff auf Lambda einzurichten, verwenden Sie AWS-Managementkonsole oder, AWS CLI um eine ausgehende Regel für die Sicherheitsgruppe Ihrer VPC zu erstellen. Die ausgehende Regel gibt an, dass TCP Port 443 verwenden kann, um Pakete an beliebige IPv4 Adressen (0.0.0.0/0) zu senden.
+ **Private Aurora PostgreSQL DB-Cluster ** — In diesem Fall befindet sich die Eigenschaft "PubliclyAccessible" der Instance in einem privaten Subnetz `false` oder sie befindet sich in einem privaten Subnetz. Damit die Instance mit Lambda arbeiten kann, können Sie ein Network Address Translation (NAT)-Gateway verwenden. Weitere Informationen finden Sie unter [NAT-Gateways](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html). Sie können Ihre VPC auch mit einem VPC-Endpunkt für Lambda konfigurieren. Weitere Informationen finden Sie unter [VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) im *Amazon-VPC-Benutzerhandbuch*. Der Endpunkt gibt Antworten auf Aufrufe Ihrer Lambda-Funktionen von Ihrem DB-Cluster von Aurora PostgreSQL zurück.
Ihre VPC kann jetzt auf Netzwerkebene mit der AWS Lambda VPC interagieren. Als Nächstes konfigurieren Sie die Berechtigungen mithilfe von IAM.
## Schritt 2: Konfigurieren Sie IAM für Ihren Aurora PostgreSQL-DB-Cluster, und AWS Lambda
Das Aufrufen von Lambda-Funktionen von Ihrem Aurora-PostgreSQL-DB-Cluster erfordert bestimmte Berechtigungen. Um die erforderlichen Berechtigungen zu konfigurieren, empfehlen wir Ihnen, eine IAM-Richtlinie zu erstellen, die es ermöglicht, Lambda-Funktionen aufzurufen, diese Richtlinie einer Rolle zuzuweisen und die Rolle dann auf Ihren DB-Cluster anzuwenden. Dieser Ansatz gewährt dem DB-Cluster Berechtigungen zum Aufrufen der angegebenen Lambda-Funktion in Ihrem Namen. Nachfolgend wird beschrieben, wie Sie dazu die AWS CLI verwenden können.
**IAM-Berechtigungen für die Verwendung Ihrer Cluster mit Lambda konfigurieren**
1. Verwenden Sie den AWS CLI Befehl [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html), um eine IAM-Richtlinie zu erstellen, die es Ihrer Aurora ermöglicht, die angegebene Lambda-Funktion aufzurufen. (Die Anweisungs-ID (Sid) ist eine optionale Beschreibung für Ihre Richtlinienanweisung und hat keine Auswirkungen auf die Verwendung.) Diese Richtlinie gewährt Ihrem Aurora-DB-Cluster die Mindestberechtigungen zum Aufrufen der angegebenen Lambda-Funktion.
```
aws iam create-policy --policy-name rds-lambda-policy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToExampleFunction",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:aws-region:444455556666:function:my-function"
}
]
}'
```
Alternativ können Sie die vordefinierte `AWSLambdaRole`-Richtlinie verwenden, mit der Sie alle Ihre Lambda-Funktionen aufrufen können. Weitere Informationen finden Sie unter [Identitätsbasierte IAM-Richtlinien für Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-identity-based.html#access-policy-examples-aws-managed).
1. Verwenden Sie den AWS CLI Befehl [create-role, um eine IAM-Rolle](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) zu erstellen, die die Richtlinie zur Laufzeit annehmen kann.
```
aws iam create-role --role-name rds-lambda-role --assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
1. Wenden Sie die Richtlinie mithilfe des Befehls auf die Rolle an. [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html) AWS CLI
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \
--role-name rds-lambda-role --region aws-region
```
1. [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-role-to-db-cluster.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-role-to-db-cluster.html) AWS CLI Dieser letzte Schritt erlaubt den Datenbankbenutzern Ihres DB-Clusters, Lambda-Funktionen aufzurufen.
```
aws rds add-role-to-db-cluster \
--db-cluster-identifier my-cluster-name \
--feature-name Lambda \
--role-arn arn:aws:iam::444455556666:role/rds-lambda-role \
--region aws-region
```
Wenn die VPC- und die IAM-Konfigurationen abgeschlossen sind, können Sie jetzt die `aws_lambda`-Erweiterung installieren. (Beachten Sie, dass Sie die Erweiterung jederzeit installieren können, bis Sie jedoch die richtige VPC-Unterstützung und IAM-Berechtigungen eingerichtet haben, hat die `aws_lambda`-Erweiterung keinerlei Auswirkungen auf die Funktionen Ihrer Aurora-PostgreSQL-DB-Cluster.)
## Schritt 3: Installieren Sie die `aws_lambda` Erweiterung für eine Aurora
Diese Erweiterung bietet Ihrem Aurora-PostgreSQL-DB-Cluster die Möglichkeit, Lambda-Funktionen von PostgreSQL aus aufzurufen.
**So installieren Sie die `aws_lambda` Erweiterung in Ihrem Aurora PostgreSQL-DB-Cluster ()**
Verwenden Sie die PostgreSQL-`psql`-Befehlszeile oder das pgAdmin-Tool, um Ihren Aurora-PostgreSQL-DB-Cluster zu verbinden.
1. Verbinden Sie Ihren Aurora-PostgreSQL-DB-Cluster als Benutzer mit `rds_superuser`-Berechtigungen. Im Beispiel wird der `postgres`-Standardbenutzer dargestellt.
```
psql -h cluster-instance.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432
```
1. Installieren Sie die `aws_lambda`-Erweiterung. Die `aws_commons`-Erweiterung ist auch erforderlich. Sie bietet Hilfsfunktionen für `aws_lambda` und viele andere Aurora-Erweiterungen für PostgreSQL. Wenn Sie noch nicht auf Ihrem Aurora-PostgreSQL-DB-Cluster installiert ist, wird sie mit `aws_lambda` wie folgt installiert.
```
CREATE EXTENSION IF NOT EXISTS aws_lambda CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
Die `aws_lambda`-Erweiterung wird in Ihrer primären, auf Ihrem Aurora-PostgreSQL-DB-Cluster befindlichen DB-Instance installiert. Sie können jetzt praktische Strukturen für den Aufruf Ihrer Lambda-Funktionen erstellen.
## Schritt 4: Verwenden von Lambda-Hilfsfunktionen mit Ihrem Aurora-PostgreSQL-DB-Cluster (optional)
Sie können die Hilfsfunktionen in der `aws_commons`-Erweiterung verwenden, um Entitäten vorzubereiten, die sich einfacher über PostgreSQL aufrufen lassen. Hierzu sind die folgenden Informationen zu Ihren Lambda-Funktionen erforderlich:
+ **Funktionsname** – Der Name, der Amazon-Ressourcenname (ARN), die Version oder der Alias der Lambda-Funktion. Die in [Schritt 2: Konfigurieren von IAM für Ihren Cluster und Lambda](#PostgreSQL-Lambda-access) erstellte IAM-Richtlinie benötigt den ARN, daher empfehlen wir Ihnen, den ARN Ihrer Funktion zu verwenden.
+ **AWS Region** — (Optional) Die AWS Region, in der sich die Lambda-Funktion befindet, falls sie sich nicht in derselben Region wie Ihre Aurora befindet.
Um die Daten zum Lambda-Funktionsnamen zu speichern, verwenden Sie die [aws\$1commons.create\$1lambda\$1function\$1arn](PostgreSQL-Lambda-functions.md#aws_commons.create_lambda_function_arn)-Funktion. Diese Hilfsfunktion erstellt eine zusammengesetzte `aws_commons._lambda_function_arn_1`-Struktur mit den Details, die von der Aufruffunktion benötigt werden. Im Folgenden finden Sie drei alternative Ansätze zum Einrichten dieser zusammengesetzten Struktur.
```
SELECT aws_commons.create_lambda_function_arn(
'my-function',
'aws-region'
) AS aws_lambda_arn_1 \gset
```
```
SELECT aws_commons.create_lambda_function_arn(
'111122223333:function:my-function',
'aws-region'
) AS lambda_partial_arn_1 \gset
```
```
SELECT aws_commons.create_lambda_function_arn(
'arn:aws:lambda:aws-region:111122223333:function:my-function'
) AS lambda_arn_1 \gset
```
Jeder dieser Werte kann in Aufrufen der [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke)-Funktion verwendet werden. Beispiele finden Sie unter [Schritt 5: Aufrufen einer Lambda-Funktion von Ihrem Aurora-PostgreSQL-DB-Cluster](#PostgreSQL-Lambda-invoke).
## Schritt 5: Aufrufen einer Lambda-Funktion von Ihrem Aurora-PostgreSQL-DB-Cluster
Die `aws_lambda.invoke`-Funktion verhält sich synchron oder asynchron, je nach `invocation_type`. Die beiden Alternativen für diesen Parameter sind `RequestResponse` (der Standardwert) und `Event`, wie folgt.
+ **`RequestResponse`** – Dieser Aufrufstyp ist *synchron*. Dies ist das Standardverhalten, wenn der Aufruf erfolgt, ohne einen Aufruftyp anzugeben. Die Antwort-Nutzlast beinhaltet die Ergebnisse der `aws_lambda.invoke`-Funktion. Verwenden Sie diesen Aufruftyp, wenn Ihr Workflow Ergebnisse von der Lambda-Funktion erhalten muss, bevor er fortfährt.
+ **`Event`** – Dieser Aufrufstyp ist *asynchron*. Die Antwort umfasst keine Nutzlast, die Ergebnisse enthält. Verwenden Sie diesen Aufruftyp, wenn Ihr Workflow kein Ergebnis der Lambda-Funktion benötigt, um die Verarbeitung fortzusetzen.
Als einfacher Test Ihres Setups können Sie mittels `psql` eine Verbindung mit Ihrer DB-Instance herstellen und eine Beispielfunktion über die Befehlszeile aufrufen. Angenommen, Sie haben eine der Grundfunktionen Ihres Lambda-Services eingerichtet, z. B. die einfache Python-Funktion, die im folgenden Screenshot gezeigt wird.
![\[Beispiel für eine Lambda-Funktion, die AWS CLI im for gezeigt wird AWS Lambda\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/lambda_simple_function.png)
**Beispielfunktion aufrufen**
1. Stellen Sie per `psql` oder pgAdmin eine Verbindung zu Ihrer primären DB-Instance her.
```
psql -h cluster.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432
```
1. Rufen Sie die Funktion mit ihrem ARN auf.
```
SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('arn:aws:lambda:aws-region:444455556666:function:simple', 'us-west-1'), '{"body": "Hello from Postgres!"}'::json );
```
Die Antwort sieht wie folgt aus.
```
status_code | payload | executed_version | log_result
-------------+-------------------------------------------------------+------------------+------------
200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST |
(1 row)
```
Schlägt der Aufruf fehl, siehe [Fehlermeldungen von Lambda-Funktionen](PostgreSQL-Lambda-errors.md).
## Schritt 6: Erteilen der Berechtigung, Lambda-Funktionen aufzurufen, für andere Benutzer
An dieser Stelle in den Prozeduren können nur Sie als `rds_superuser` Ihre Lambda-Funktionen aufrufen. Damit andere Benutzer alle von Ihnen erstellten Funktionen aufrufen können, müssen Sie ihnen die entsprechende Berechtigung erteilen.
**Gewähren der Berechtigung zum Aufrufen von Lambda-Funktionen**
1. Stellen Sie per `psql` oder pgAdmin eine Verbindung zu Ihrer primären DB-Instance her.
```
psql -h cluster.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432
```
1. Führen Sie die folgenden SQL-Befehle aus:
```
postgres=> GRANT USAGE ON SCHEMA aws_lambda TO db_username;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA aws_lambda TO db_username;
```
# Beispiele: Aufrufen von Lambda-Funktionen von Ihrem Aurora-PostgreSQL-DB-Cluster
Nachfolgend finden Sie einige Beispiele für den Aufruf der [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke)-Funktion. Die meisten Beispiele verwenden die Verbundstruktur `aws_lambda_arn_1`, die Sie in [Schritt 4: Verwenden von Lambda-Hilfsfunktionen mit Ihrem Aurora-PostgreSQL-DB-Cluster (optional)](PostgreSQL-Lambda.md#PostgreSQL-Lambda-specify-function) erstellen, um die Übergabe der Funktionsdetails zu vereinfachen. Ein Beispiel für einen asynchronen Aufruf finden Sie unter [Beispiel: Asynchroner Ereignisaufruf (Event) von Lambda-Funktionen](#PostgreSQL-Lambda-Event). Alle anderen aufgelisteten Beispiele verwenden einen synchronen Aufruf.
Weitere Informationen zu Lambda-Aufruftypen finden Sie unter [Aufrufen von Lambda-Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html) im *AWS Lambda -Entwicklerhandbuch*. Mehr über `aws_lambda_arn_1` erfahren Sie unter [aws\$1commons.create\$1lambda\$1function\$1arn](PostgreSQL-Lambda-functions.md#aws_commons.create_lambda_function_arn).
**Topics**
+ [Beispiel: Synchroner (RequestResponse) -Aufruf von Lambda-Funktionen](#PostgreSQL-Lambda-RequestResponse)
+ [Beispiel: Asynchroner Ereignisaufruf (Event) von Lambda-Funktionen](#PostgreSQL-Lambda-Event)
+ [Beispiel: Erfassen des Lambda-Ausführungsprotokolls in einer Funktionsantwort](#PostgreSQL-Lambda-log-response)
+ [Beispiel: Einschließen von Client-Kontext in einer Lambda-Funktion](#PostgreSQL-Lambda-client-context)
+ [Beispiel: Aufrufen einer bestimmten Version einer Lambda-Funktion](#PostgreSQL-Lambda-function-version)
## Beispiel: Synchroner (RequestResponse) -Aufruf von Lambda-Funktionen
Es folgen zwei Beispiele für einen synchronen Lambda-Funktionsaufruf. Die Ergebnisse dieser `aws_lambda.invoke`-Funktionen sind identisch.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json);
```
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse');
```
Die Parameter werden wie folgt beschrieben:
+ `:'aws_lambda_arn_1'` – Dieser Parameter identifiziert die zusammengesetzte Struktur, die in [Schritt 4: Verwenden von Lambda-Hilfsfunktionen mit Ihrem Aurora-PostgreSQL-DB-Cluster (optional)](PostgreSQL-Lambda.md#PostgreSQL-Lambda-specify-function) erstellt wurde, mit der `aws_commons.create_lambda_function_arn`-Hilfsfunktion. Sie können diese Struktur wie folgt auch in Ihren `aws_lambda.invoke`-Aufruf einbinden.
```
SELECT * FROM aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'aws-region'),
'{"body": "Hello from Postgres!"}'::json
);
```
+ `'{"body": "Hello from PostgreSQL!"}'::json` – Die JSON-Nutzlast, die an die Lambda-Funktion übergeben werden soll.
+ `'RequestResponse'` – Der Lambda Aufruftyp.
## Beispiel: Asynchroner Ereignisaufruf (Event) von Lambda-Funktionen
Es folgt ein Beispiel für einen asynchronen Lambda-Funktionsaufruf. Der `Event`-Aufruftyp plant den Lambda-Funktionsaufruf mit der angegebenen Eingabe-Nutzlast und sofort Rückgabe. Verwenden Sie den `Event`-Aufruftyp in bestimmten Workflows, die nicht von den Ergebnissen der Lambda-Funktion abhängen.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'Event');
```
## Beispiel: Erfassen des Lambda-Ausführungsprotokolls in einer Funktionsantwort
Sie können die letzten 4 KB des Ausführungsprotokolls in die Funktionsantwort aufnehmen, indem Sie den Parameter `log_type` in Ihrem `aws_lambda.invoke`-Funktionsaufruf verwenden. Standardmäßig ist dieser Parameter auf `None` festgelegt, aber Sie können `Tail` angeben, um die Ergebnisse des Lambda-Ausführungsprotokolls in der Antwort zu erfassen, wie nachfolgend gezeigt.
```
SELECT *, select convert_from(decode(log_result, 'base64'), 'utf-8') as log FROM aws_lambda.invoke(:'aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'Tail');
```
Legen Sie den Parameter [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke) der `log_type`-Funktion auf `Tail`, um das Ausführungsprotokoll in die Antwort aufzunehmen. Der Standardwert für diesen `log_type`-Parameter ist `None`.
Das `log_result`, was zurückgegeben wird, ist eine `base64` codierte Zeichenfolge. Sie können den Inhalt mit einer Kombination der PostgreSQL-Funktionen `decode` und `convert_from` dekodieren.
Mehr über `log_type` erfahren Sie unter [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke).
## Beispiel: Einschließen von Client-Kontext in einer Lambda-Funktion
Die `aws_lambda.invoke`-Funktion hat einen `context`-Parameter, den Sie verwenden können, um Informationen getrennt von der Nutzlast zu übergeben, wie nachfolgend gezeigt.
```
SELECT *, convert_from(decode(log_result, 'base64'), 'utf-8') as log FROM aws_lambda.invoke(:'aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'Tail');
```
Um den Clientkontext einzuschließen, verwenden Sie ein JSON-Objekt für den Parameter [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke) der `context`-Funktion.
Weitere Informationen zum `context`-Parameter finden Sie in der [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke)-Referenz.
## Beispiel: Aufrufen einer bestimmten Version einer Lambda-Funktion
Sie können eine bestimmte Version einer Lambda-Funktion angeben, indem Sie den `qualifier`-Parameter mit dem `aws_lambda.invoke`-Aufruf einschließen. Im Folgenden finden Sie ein Beispiel, das diese Funktion mit `'custom_version'` als Alias für die Version erfüllt.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'None', NULL, 'custom_version');
```
Sie können auch einen Lambda-Funktionsqualifizierer wie folgt mit den Daten zum Funktionsnamen angeben.
```
SELECT * FROM aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function:custom_version', 'us-west-2'),
'{"body": "Hello from Postgres!"}'::json);
```
Weitere Informationen zu `qualifier` und anderen Parametern finden Sie in der [aws\$1lambda.invoke](PostgreSQL-Lambda-functions.md#aws_lambda.invoke)-Referenz.
# Fehlermeldungen von Lambda-Funktionen
In der folgenden Liste finden Sie Informationen zu Fehlermeldungen sowie mögliche Ursachen und Lösungen.
+ **VPC-Konfigurationsprobleme**
Probleme mit der VPC-Konfiguration können beim Versuch, eine Verbindung herzustellen, die folgenden Fehlermeldungen auslösen:
```
ERROR: invoke API failed
DETAIL: AWS Lambda client returned 'Unable to connect to endpoint'.
CONTEXT: SQL function "invoke" statement 1
```
Eine häufige Ursache für diesen Fehler ist eine falsch konfigurierte VPC-Sicherheitsgruppe. Stellen Sie sicher, dass eine Regel Port 443 Ihrer VPC-Sicherheitsgruppe für ausgehenden TCP-Datenverkehr öffnet, damit Ihre VPC eine Verbindung zur Lambda-VPC herstellen kann.
+ **Fehlende Berechtigungen, die zum Aufrufen von Lambda-Funktionen erforderlich sind**
Wenn eine der folgenden Fehlermeldungen angezeigt wird, verfügt der Benutzer (Rolle), der die Funktion aufruft, nicht über die entsprechenden Berechtigungen.
```
ERROR: permission denied for schema aws_lambda
```
```
ERROR: permission denied for function invoke
```
Ein Benutzer (Rolle) muss bestimmte Berechtigungen erhalten, um Lambda-Funktionen aufrufen zu können. Weitere Informationen finden Sie unter [Schritt 6: Erteilen der Berechtigung, Lambda-Funktionen aufzurufen, für andere Benutzer](PostgreSQL-Lambda.md#PostgreSQL-Lambda-grant-users-permissions).
+ **Unsachgemäße Handhabung von Fehlern in Ihren Lambda-Funktionen**
Wenn eine Lambda-Funktion während der Anforderungsverarbeitung eine Ausnahme auslöst, `aws_lambda.invoke` schlägt dies mit einem PostgreSQL-Fehler wie folgt fehl.
```
SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json);
ERROR: lambda invocation failed
DETAIL: "arn:aws:lambda:us-west-2:555555555555:function:my-function" returned error "Unhandled", details: "".
```
Kümmern Sie sich unbedingt um Fehler in Ihren Lambda-Funktionen oder in Ihrer PostgreSQL-Anwendung.
# Referenz für AWS Lambda-Funktionen und -Parameter
Im Folgenden finden Sie die Referenz für die Funktionen, die zum Aufrufen von Lambda-Funktionen mit Aurora PostgreSQL verwendet werden müssen.
**Topics**
+ [aws\$1lambda.invoke](#aws_lambda.invoke)
+ [aws\$1commons.create\$1lambda\$1function\$1arn](#aws_commons.create_lambda_function_arn)
+ [aws\$1lambda-Parameter](#aws_lambda.parameters)
## aws\$1lambda.invoke
Führt eine Lambda-Funktion für eine Aurora PostgreSQL DB-Cluster-RDS aus.
Weitere Informationen zum Aufrufen von Lambda-Funktionen finden Sie unter [Invoke (Aufrufen)](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) auch im *AWS Lambda-Entwicklerhandbuch.*
**Syntax**
------
#### [ JSON ]
```
aws_lambda.invoke(
IN function_name TEXT,
IN payload JSON,
IN region TEXT DEFAULT NULL,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSON DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSON,
OUT executed_version TEXT,
OUT log_result TEXT)
```
```
aws_lambda.invoke(
IN function_name aws_commons._lambda_function_arn_1,
IN payload JSON,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSON DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSON,
OUT executed_version TEXT,
OUT log_result TEXT)
```
------
#### [ JSONB ]
```
aws_lambda.invoke(
IN function_name TEXT,
IN payload JSONB,
IN region TEXT DEFAULT NULL,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSONB DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSONB,
OUT executed_version TEXT,
OUT log_result TEXT)
```
```
aws_lambda.invoke(
IN function_name aws_commons._lambda_function_arn_1,
IN payload JSONB,
IN invocation_type TEXT DEFAULT 'RequestResponse',
IN log_type TEXT DEFAULT 'None',
IN context JSONB DEFAULT NULL,
IN qualifier VARCHAR(128) DEFAULT NULL,
OUT status_code INT,
OUT payload JSONB,
OUT executed_version TEXT,
OUT log_result TEXT
)
```
------Eingabeparameter
**function\$1name**
Der spezifizierte Name der Lambda-Funktion. Der Wert kann der Funktionsname, ein ARN oder ein partieller ARN sein. Eine Auflistung möglicher Formate finden Sie unter [ Lambda Funktionsnamenformate](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_RequestParameters) im *AWS Lambda-Entwicklerhandbuch. *
*Nutzlast*
Die Eingabe für die Funktion Lambda. Das Format kann JSON oder JSONB sein. Weitere Informationen finden Sie in der PostgreSQL-Dokumentation zu [JSON Types](https://www.postgresql.org/docs/current/datatype-json.html).
*region*
(Optional) Die Lambda-Region für die Funktion. Standardmäßig verwendet Aurora die AWS-Region aus dem vollständigen ARN in der `function_name` oder die Aurora PostgreSQL -DB-Instance-Region. Wenn dieser Region-Wert mit dem im `function_name` ARN angegebenen Wert in Konflikt steht, wird ein Fehler ausgelöst.
*invocation\$1type*
Die Aufruftyp der Lambda-Funktion. Bei -Wert ist die Groß- und Kleinschreibung zu beachten. Die folgenden Werte sind möglich:
+ `RequestResponse` – Der Standardwert. Diese Art des Aufrufens für eine Lambda-Funktion ist synchron und gibt eine Antwortnutzlast im Ergebnis zurück. Verwenden Sie den `RequestResponse` Aufruftyp, wenn Ihr Workflow vom sofortigen Erhalt des Lambda-Funktionsergebnisses abhängt.
+ `Event` – Diese Art des Aufrufs für eine Lambda-Funktion ist asynchron und wird sofort ohne Rückgabe einer Nutzlast zurückgegeben. Verwenden Sie den `Event`-Aufruftyp, wenn Sie keine Ergebnisse der Lambda-Funktion benötigen, bevor Ihr Workflow weitergeht.
+ `DryRun` – Diese Art des Aufrufs testet den Zugriff, ohne die Lambda-Funktion auszuführen.
*log\$1typ*
Der Typ des Lambda-Protokolls, das im Ausgabeparameter `log_result` ausgegeben werden soll. Bei -Wert ist die Groß- und Kleinschreibung zu beachten. Die folgenden Werte sind möglich:
+ Tail – Der zurückgegebene Ausgabeparameter `log_result` enthält die letzten 4 KB des Ausführungsprotokolls.
+ Keiner – Es werden keine Lambda-Protokollinformationen zurückgegeben.
*context*
Client-Kontext im JSON- oder JSONB-Format. Zu verwendende Felder sind dann `custom` und `env`.
*Qualifier*
Ein Qualifier, der die aufzurufende Version einer Lambda-Funktion spezifiziert. Wenn dieser Wert mit einem im `function_name` ARN angegebenen Wert in Konflikt steht, wird ein Fehler ausgelöst.Ausgabeparameter
*status\$1code*
Ein HTTP-Status-Antwortcode. Weitere Informationen finden Sie unter [Lambda Antwortelemente aufrufen](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_ResponseElements) im *AWS Lambda-Entwicklerhandbuch.*
*Nutzlast*
Die von der ausgeführten Lambda-Funktion zurückgegebenen Daten. Das Format ist in JSON oder JSONB.
*executed\$1version*
Die Version der Lambda-Funktion, die ausgeführt wurde.
*log\$1resultat*
Die Ausführungsprotokollinformationen werden zurückgegeben, wenn der Wert `log_type` beim Aufruf der Lambda-Funktion `Tail` beträgt. Das Ergebnis enthält die letzten 4 KB des in Base64 codierten Ausführungsprotokolls.
## aws\$1commons.create\$1lambda\$1function\$1arn
Erstellt eine `aws_commons._lambda_function_arn_1`-Struktur für Daten zum Lambda Funktionsnamen. Sie können die Ergebnisse der `aws_commons.create_lambda_function_arn`-Funktion im Parameter `function_name` der [aws\$1lambda.invoke](#aws_lambda.invoke)-Funktion aws\$1lambda.invoke verwenden.
**Syntax**
```
aws_commons.create_lambda_function_arn(
function_name TEXT,
region TEXT DEFAULT NULL
)
RETURNS aws_commons._lambda_function_arn_1
```Eingabeparameter
*function\$1name*
Eine erforderliche Textzeichenfolge mit dem Lambda-Funktionsnamen. Der Wert kann ein Funktionsname, ein partieller ARN oder ein vollständiger ARN sein.
*region*
Eine optionale Textzeichenfolge mit der AWS-Region, in der sich die Lambda-Funktion befindet. Eine Liste der -Regionsnamen und der zugehörigen Werte finden Sie unter [ Regionen und Availability Zones](Concepts.RegionsAndAvailabilityZones.md).
## aws\$1lambda-Parameter
In der Tabelle finden Sie Parameter, die der `aws_lambda`-Funktion zugeordnet sind.
| Parameter | Beschreibung |
| --- | --- |
| `aws_lambda.connect_timeout_ms` | Dies ist ein dynamischer Parameter, der die maximale Wartezeit beim Herstellen einer Verbindung zu AWS Lambda festlegt. Der Standardwert ist `1000`. Die zulässigen Werte für diesen Parameter sind 1 bis 90000. |
| `aws_lambda.request_timeout_ms` | Dies ist ein dynamischer Parameter, der die maximale Wartezeit beim Warten auf eine Antwort von AWS Lambda festlegt. Der Standardwert ist `3000`. Die zulässigen Werte für diesen Parameter sind 1 bis 90000. |
| `aws_lambda.endpoint_override` | Gibt den Endpunkt an, der für die Verbindung mit AWS Lambda verwendet werden kann. Eine leere Zeichenfolge wählt den AWS-Lambda-Standardendpunkt für die Region aus. Sie müssen die Datenbank für diese Änderung des statischen Parameters neu starten, damit Änderungen wirksam werden. |
# Veröffentlichen von Aurora-PostgreSQL-Protokollen in Amazon CloudWatch Logs
Sie können Ihren Aurora-PostgreSQL-DB-Cluster so konfigurieren, dass Protokolldaten regelmäßig in Amazon CloudWatch Logs exportiert werden. Wenn Sie dies tun, werden Ereignisse aus dem PostgreSQL-Protokoll Ihres Aurora-PostgreSQL-DB-Clusters automatisch als Amazon CloudWatch Logs auf Amazon CloudWatch *veröffentlicht*. In CloudWatch finden Sie die exportierten Protokolldaten in einer *Protokollgruppe* für Ihren Aurora-PostgreSQL-DB-Cluster. Die Protokollgruppe enthält einen oder mehrere *Protokollstreams*, die die Ereignisse aus dem PostgreSQL-Protokoll von jeder Instance im Cluster enthalten.
Durch die Veröffentlichung der Protokolle in CloudWatch Logs können Sie die PostgreSQL-Protokolldatensätze in einem Speicher mit hoher Beständigkeit aufbewahren. Mit den in CloudWatch Logs verfügbaren Protokolldaten können Sie den Betrieb Ihres Clusters auswerten und verbessern. Sie können CloudWatch also verwenden, um Alarme zu erstellen und Metriken anzuzeigen. Weitere Informationen hierzu finden Sie unter [Überwachen von Protokollereignissen in Amazon CloudWatch](AuroraPostgreSQL.CloudWatch.Monitor.md).
**Anmerkung**
Das Veröffentlichen Ihrer PostgreSQL-Protokolle in CloudWatch Logs verbraucht Speicherplatz, und für diesen Speicher fallen Gebühren an. Löschen Sie CloudWatch Logs, die nicht mehr benötigt werden.
Das Deaktivieren der Option zum Exportieren von Protokollen für einen vorhandenen Aurora PostgreSQL DB-Cluster wirkt sich nicht auf Daten aus, die bereits in CloudWatch Logs gespeichert sind. Bestehende Protokolle bleiben in CloudWatch Logs verfügbar, basierend auf Ihren Protokollaufbewahrungseinstellungen. Weitere Informationen zu CloudWatch Logs finden Sie unter [Was ist CloudWatch Logs?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)
Aurora PostgreSQL unterstützt die Veröffentlichung von Protokollen in CloudWatch Logs für die folgenden Versionen.
+ 16.1 und alle höheren Versionen
+ 15.2 und höhere 15-Versionen
+ 14.3 und höhere 14-Versionen
+ 13.3 und höhere 13 Versionen
+ 12.8 und höhere 12 Versionen
+ 11.9 und höher 11 Versionen
Informationen zum Aktivieren der Option zum Veröffentlichen von Protokollen in CloudWatch Logs, zum Überwachen von Protokollereignissen in CloudWatch Logs und zum Analysieren von Protokollen mit CloudWatch Logs Insights finden Sie in den folgenden Themen.
**Topics**
+ [Aktivieren der Option zum Veröffentlichen von Protokollen in Amazon CloudWatch](AuroraPostgreSQL.CloudWatch.Publishing.md)
+ [Überwachen von Protokollereignissen in Amazon CloudWatch](AuroraPostgreSQL.CloudWatch.Monitor.md)
+ [Analysieren von Aurora-PostgreSQL-Protokollen mit CloudWatch Logs Insights](AuroraPostgreSQL.CloudWatch.Analyzing.md)
# Aktivieren der Option zum Veröffentlichen von Protokollen in Amazon CloudWatch
Um das PostgreSQL-DB-Cluster in CloudWatch Logs zu veröffentlichen, wählen Sie die Option **Log export** (Protokollexport) für den Cluster. Sie können die Log-Export-Einstellung beim Erstellen Ihres Aurora-PostgreSQL-DB-Clusters auswählen. Sie können den Cluster auch später ändern. Wenn Sie einen vorhandenen Cluster ändern, werden seine PostgreSQL-Protokolle von jeder Instance ab diesem Zeitpunkt im CloudWatch-Cluster veröffentlicht. Für Aurora PostgreSQL ist das PostgreSQL-Protokoll (`postgresql.log`) das einzige Protokoll, das auf Amazon CloudWatch veröffentlicht wird.
Sie können das AWS-Managementkonsole, das AWS CLI oder die RDS-API verwenden, um die Protokollexportfunktion für Ihren Aurora PostgreSQL DB-Cluster zu aktivieren.
## Konsole
Wählen Sie die Option Protokollexporte, um mit der Veröffentlichung der PostgreSQL-Protokolle aus Ihrem Aurora PostgreSQL DB-Cluster in CloudWatch Logs zu beginnen.
**So aktivieren Sie die Funktion zum Exportieren von Protokollen über die Konsole**
1. Öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie den Aurora-PostgreSQL-DB-Cluster, für den die Protokolldaten in CloudWatch Logs veröffentlicht werden sollen.
1. Wählen Sie **Ändern** aus.
1. Wählen Sie im Abschnitt **Log exports (Protokollexporte)** die Option **PostgreSQL log** aus.
1. Wählen Sie **Continue (Weiter)** und dann auf der Übersichtsseite **Modify cluster (Cluster ändern)**.
## AWS CLI
Sie können die Option zum Exportieren von Protokollen aktivieren, um die Veröffentlichung von Aurora-PostgreSQL-Protokollen in Amazon CloudWatch Logs mit AWS CLI zu starten. Hierzu führen Sie den Befehl [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) AWS CLI mit den folgenden Optionen aus:
+ `--db-cluster-identifier` – Die DB-Cluster-Kennung.
+ `--cloudwatch-logs-export-configuration` – Die Konfigurationseinstellung für die Protokolltypen, die für den Export in CloudWatch Logs für den DB-Cluster eingestellt werden sollen.
Sie können Aurora-PostgreSQL-Protokolle auch veröffentlichen, indem Sie einen der folgenden AWS CLI-Befehle ausführen:
+ [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html)
+ [restore-db-cluster-from-s3](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-from-s3.html)
+ [restore-db-cluster-from-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-from-snapshot.html)
+ [restore-db-cluster-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-to-point-in-time.html)
Führen Sie einen dieser AWS CLI-Befehle mit den folgenden Optionen aus:
+ `--db-cluster-identifier` – Die DB-Cluster-Kennung.
+ `--engine`— Die Datenbank-Engine.
+ `--enable-cloudwatch-logs-exports`— Konfigurationseinstellung für die Protokolltypen, die für den Export in CloudWatch Logs für den DB-Cluster aktiviert werden sollen.
Je nach ausgeführtem AWS CLI-Befehl müssen möglicherweise noch weitere Optionen angegeben werden.
**Example**
Der folgende Befehl erstellt einen Aurora-PostgreSQL-DB-Cluster zum Veröffentlichen von Protokolldateien in CloudWatch Logs.
Für Linux, macOS oder Unix:
```
1. aws rds create-db-cluster \
2. --db-cluster-identifier my-db-cluster \
3. --engine aurora-postgresql \
4. --enable-cloudwatch-logs-exports postgresql
```
Für Windows:
```
1. aws rds create-db-cluster ^
2. --db-cluster-identifier my-db-cluster ^
3. --engine aurora-postgresql ^
4. --enable-cloudwatch-logs-exports postgresql
```
**Example**
Der folgende Befehl modifiziert einen vorhandenen Aurora-PostgreSQL-DB-Cluster zum Veröffentlichen von Protokolldateien in CloudWatch Logs. Der `--cloudwatch-logs-export-configuration`-Wert ist ein JSON-Objekt. Der Schlüssel für dieses Objekt ist `EnableLogTypes` und sein Wert lautet `postgresql` und `instance`.
Für Linux, macOS oder Unix:
```
1. aws rds modify-db-cluster \
2. --db-cluster-identifier my-db-cluster \
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["postgresql","instance"]}'
```
Für Windows:
```
1. aws rds modify-db-cluster ^
2. --db-cluster-identifier my-db-cluster ^
3. --cloudwatch-logs-export-configuration '{\"EnableLogTypes\":[\"postgresql\",\"instance\"]}'
```
Wenn Sie die Windows-Befehlszeile verwenden, stellen Sie sicher, dass Sie doppelte Anführungszeichen (") im JSON-Code maskieren, indem Sie ihnen einen umgekehrten Schrägstrich (\$1) voranstellen.
**Example**
Das folgende Beispiel modifiziert einen vorhandenen Aurora-PostgreSQL-DB-Cluster zum Deaktivieren der Veröffentlichung von Protokolldateien in CloudWatch Logs. Der `--cloudwatch-logs-export-configuration`-Wert ist ein JSON-Objekt. Der Schlüssel für dieses Objekt ist `DisableLogTypes` und sein Wert lautet `postgresql` und `instance`.
Für Linux, macOS oder Unix:
```
aws rds modify-db-cluster \
--db-cluster-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"DisableLogTypes":["postgresql","instance"]}'
```
Für Windows:
```
aws rds modify-db-cluster ^
--db-cluster-identifier mydbinstance ^
--cloudwatch-logs-export-configuration "{\"DisableLogTypes\":[\"postgresql\",\"instance\"]}"
```
Bei Verwendung der Windows-Befehlszeile müssen doppelte Anführungszeichen (") im JSON-Code mit einem umgekehrten Schrägstrich (\$1) als Escape-Zeichen versehen werden.
## RDS-API
Sie können die Log-Export-Option aktivieren, um die Veröffentlichung von Aurora-PostgreSQL-Protokollen mit der RDS-API zu starten. Hierzu führen Sie den Vorgang [ModifyDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) mit den folgenden Optionen aus:
+ `DBClusterIdentifier` – Die DB-Cluster-ID.
+ `CloudwatchLogsExportConfiguration` – Konfigurationseinstellung für die Protokolltypen, die für den Export in CloudWatch Logs für den DB-Cluster aktiviert werden sollen.
Sie können Aurora PostgreSQL-Protokolle auch mit der RDS-API veröffentlichen, indem Sie eine der folgenden RDS-API-Operationen ausführen:
+ [CreateDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html)
+ [RestoreDBClusterFromS3](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromS3.html)
+ [RestoreDBClusterFromSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html)
+ [RestoreDBClusterToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html)
Führen Sie die RDS-API-Operation mit den folgenden Parametern aus:
+ `DBClusterIdentifier` – Die DB-Cluster-Kennung.
+ `Engine`— Die Datenbank-Engine.
+ `EnableCloudwatchLogsExports`— Konfigurationseinstellung für die Protokolltypen, die für den Export in CloudWatch Logs für den DB-Cluster aktiviert werden sollen.
Je nach ausgeführtem AWS CLI-Befehl müssen möglicherweise noch weitere Parameter angegeben werden.
# Überwachen von Protokollereignissen in Amazon CloudWatch
Da Aurora PostgreSQL-Protokollereignisse veröffentlicht und als Amazon CloudWatch Logs verfügbar sind, können Sie Ereignisse mit Amazon anzeigen und überwachen. CloudWatch Weitere Informationen zur Überwachung finden Sie unter An Logs [gesendete Protokolldaten anzeigen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData). CloudWatch
Wenn Sie Log exports (Protokollexporte) aktivieren, wird mit dem Präfix `/aws/rds/cluster/` automatisch eine neue Protokollgruppe mit dem Namen Ihrer Aurora PostgreSQL und dem Protokolltyp, wie im folgenden Muster erstellt.
```
/aws/rds/cluster/your-cluster-name/postgresql
```
Nehmen wir als Beispiel an, dass ein Aurora PostgreSQL-DB-Cluster mit dem Namen sein Protokoll nach Amazon CloudWatch Logs `docs-lab-apg-small` exportiert. Der Name der Protokollgruppe in Amazon CloudWatch wird im Folgenden angezeigt.
```
/aws/rds/cluster/docs-lab-apg-small/postgresql
```
Wenn bereits eine Protokollgruppe mit dem angegebenen Namen existiert, verwendet Aurora diese Protokollgruppe, um Protokolldaten für den Aurora-DB-Cluster zu exportieren. Jede DB-Instance im Aurora PostgreSQL DB-Cluster lädt ihr PostgreSQL-Protokoll als eigenständigen Protokollstream in die Protokollgruppe hoch. Sie können die Protokollgruppe und ihre Protokollstreams mithilfe der verschiedenen grafischen und analytischen Tools von Amazon untersuchen CloudWatch.
Sie können beispielsweise in den Protokollereignissen Ihres Aurora PostgreSQL-DB-Clusters nach Informationen suchen und Ereignisse mithilfe der CloudWatch Logs-Konsole, der oder der AWS CLI CloudWatch Logs-API filtern. Weitere Informationen finden Sie unter [Suchen und Filtern von Protokolldaten](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/MonitoringLogData.html) im *Amazon CloudWatch Logs-Benutzerhandbuch*.
Standardmäßig werden neue Protokollgruppen mit **Läuft niemals ab** für ihre Aufbewahrungszeit erstellt. Sie können die CloudWatch Logs-Konsole AWS CLI, die oder die CloudWatch Logs-API verwenden, um den Aufbewahrungszeitraum für Protokolle zu ändern. Weitere Informationen finden Sie unter [Ändern der Aufbewahrung von Protokolldaten in CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) im *Amazon CloudWatch Logs-Benutzerhandbuch*.
**Tipp**
Sie können die automatische Konfiguration verwenden AWS CloudFormation, um beispielsweise Protokollgruppen mit vordefinierten Aufbewahrungsfristen für Protokolle, Metrikfiltern und Zugriffsberechtigungen zu erstellen.
# Analysieren von Aurora-PostgreSQL-Protokollen mit CloudWatch Logs Insights
Wenn die PostgreSQL-Protokolle aus Ihrem Aurora-PostgreSQL-DB-Cluster als CloudWatch Logs veröffentlicht wurden, können Sie CloudWatch Logs Insights verwenden, um interaktiv Ihre Protokolldaten in Amazon CloudWatch Logs zu suchen und zu analysieren. CloudWatch Logs Insights umfasst eine Abfragesprache, Beispielabfragen und andere Tools zur Analyse Ihrer Protokolldaten, damit Sie potenzielle Probleme identifizieren und Korrekturen überprüfen können. Weitere Informationen finden Sie unter [Analyse von Protokolldaten mit CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) im *Amazon CloudWatch Logs-Benutzerhandbuch*.
**So analysieren Sie PostgreSQL-Protokolle mit CloudWatch Logs Insights**
1. Öffnen Sie die CloudWatch-Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Öffnen Sie im Navigationsbereich **Logs** (Protokolle) und wählen Sie **Log insights** (Protokoll-Erkenntnisse) aus.
1. Wählen Sie unter **Select log group(s)** (Protokollgruppe(n) auswählen) die Protokollgruppe für Ihren Aurora-PostgreSQL-DB-Cluster aus.
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-select-log-group.png)
1. Löschen Sie im Abfrage-Editor die aktuell angezeigte Abfrage und geben Sie Folgendes ein. Wählen Sie anschließend **Run query** (Abfrage ausführen) aus.
```
##Autovacuum execution time in seconds per 5 minute
fields @message
| parse @message "elapsed: * s" as @duration_sec
| filter @message like / automatic vacuum /
| display @duration_sec
| sort @timestamp
| stats avg(@duration_sec) as avg_duration_sec,
max(@duration_sec) as max_duration_sec
by bin(5 min)
```
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-query.png)
1. Wählen Sie die Registerkarte **Visualization (Visualisierung)** aus.
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-visualization.png)
1. Wählen Sie **Add to dashboard (Zu Dashboard hinzufügen)** aus.
1. Wählen Sie unter **Dashboard auswählen** entweder ein Dashboard aus oder geben Sie einen Namen ein, um ein neues Dashboard zu erstellen.
1. Wählen Sie unter **Widget-Typ** einen Widget-Typ für Ihre Visualisierung aus.
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-dashboard.png)
1. (Optional) Fügen Sie basierend auf Ihren Protokollabfrage-Ergebnissen weitere Widgets hinzu.
1. Wählen Sie **Add widget** aus.
1. Wählen Sie einen Widget-Typ aus, z. B. **Linie**.
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-widget.png)
1. Wählen Sie im Fenster **Zu diesem Dashboard hinzufügen** die Option **Protokolle** aus.
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-add-logs-to-dashboard.png)
1. Wählen Sie unter **Select log group(s)** die Protokollgruppe für Ihren DB-Cluster aus.
1. Löschen Sie im Abfrage-Editor die aktuell angezeigte Abfrage und geben Sie Folgendes ein. Wählen Sie anschließend **Run query** aus.
```
##Autovacuum tuples statistics per 5 min
fields @timestamp, @message
| parse @message "tuples: " as @tuples_temp
| parse @tuples_temp "* removed," as @tuples_removed
| parse @tuples_temp "remain, * are dead but not yet removable, " as @tuples_not_removable
| filter @message like / automatic vacuum /
| sort @timestamp
| stats avg(@tuples_removed) as avg_tuples_removed,
avg(@tuples_not_removable) as avg_tuples_not_removable
by bin(5 min)
```
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-query2.png)
1. Wählen Sie **Create widget** aus.
Ihr Dashboard sollte folgender Abbildung ähnlich sein.
![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/apg-cwl-insights-dashboard-two-graphs.png)