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. # Aufrufen einer AWS Lambda Funktion aus einem ) 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 . 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 einer AWS Lambda Funktion wird in den folgenden RDS-Versionen für PostgreSQL unterstützt: Alle PostgreSQL 18-Versionen Alle PostgreSQL 17-Versionen Alle PostgreSQL 16-Versionen Alle PostgreSQL 15-Versionen PostgreSQL 14.1 und höhere Unterversionen PostgreSQL 13.2 und höhere Unterversionen PostgreSQL 12.6 und höhere Unterversionen Die Einrichtung von für die Arbeit mit Lambda-Funktionen ist ein mehrstufiger Prozess, der IAM AWS Lambda, Ihre VPC und Ihre umfasst. 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 für ausgehende Verbindungen zu AWS Lambda](#PostgreSQL-Lambda-network) + [Schritt 2: Konfigurieren Sie IAM für Ihren und AWS Lambda](#PostgreSQL-Lambda-access) + [Schritt 3: Installieren Sie die `aws_lambda` Erweiterung für eine](#PostgreSQL-Lambda-install-extension) + [Schritt 4: Verwenden von Lambda-Hilfsfunktionen mit Ihrer RDS-for-PostgreSQL-DB-Instance (optional)](#PostgreSQL-Lambda-specify-function) + [Schritt 5: Aufrufen einer Lambda-Funktion von Ihrem RDS-for-PostgreSQL-DB-Instance](#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 Ihrer RDS-for-PostgreSQL-DB-Instance](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 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. Ihre DB-Instance von RDS für 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 öffentlich oder privat ist. + **Öffentlicher RDS für PostgreSQL-DB-Instance** — 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 RDS für PostgreSQL-DB-Instance** — 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 Ihrer DB-Instance von RDS für PostgreSQL zurück. Der VPC-Endpunkt verwendet seine eigene private DNS-Auflösung. RDS für PostgreSQL kann den Lambda-VPC-Endpunkt erst verwenden, wenn Sie den Wert von `rds.custom_dns_resolution` von seinem Standardwert 0 (nicht aktiviert) zu 1 ändern. Gehen Sie hierzu wie folgt vor: + Erstellen Sie eine benutzerdefinierte DB-Parametergruppe. + Ändern Sie den Wert des Parameters `rds.custom_dns_resolution` von seinem Standardwert `0` zu `1`. + Ändern Sie Ihre DB-Instance, um Ihre benutzerdefinierte DB-Parametergruppe zu verwenden. + Starten Sie die DB-Instance neu, damit der bearbeitete Parameter in Kraft tritt. 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 und AWS Lambda Das Aufrufen von Lambda-Funktionen von Ihrer RDS-for-PostgreSQL-DB-Instance 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 Ihre DB-Instance anzuwenden. Dieser Ansatz gewährt der DB-Instance 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 Amazon-RDS-Instance 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 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 Ihrer DB-Instance 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. AWS CLI Dieser letzte Schritt erlaubt den Datenbankbenutzern Ihrer DB-Instances, Lambda-Funktionen aufzurufen. ``` aws rds add-role-to-db-instance \ --db-instance-identifier my-instance-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 RDS-for-PostgreSQL-DB-Instances.) ## Schritt 3: Installieren Sie die `aws_lambda` Erweiterung für eine Zur Verwendung AWS Lambda mit Ihrem fügen Sie die PostgreSQL-Erweiterung zu Ihrem DB-Instance hinzu. Diese Erweiterung bietet Ihrer RDS-for-PostgreSQL-DB-Instance die Möglichkeit, Lambda-Funktionen von PostgreSQL aus aufzurufen. **So installieren Sie die `aws_lambda` Erweiterung in Ihrem )** Verwenden Sie die PostgreSQL-`psql`-Befehlszeile oder das pgAdmin-Tool, um Ihre RDS-for-PostgreSQL-DB-Instance zu verbinden. 1. Verbinden Sie Ihren Ihre RDS-for-PostgreSQL-DB-Instance als Benutzer mit `rds_superuser`-Berechtigungen. Im Beispiel wird der `postgres`-Standardbenutzer dargestellt. ``` psql -h 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 Ihrer RDS-for-PostgreSQL-DB-Instance 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 DB-Instance installiert. Sie können jetzt praktische Strukturen für den Aufruf Ihrer Lambda-Funktionen erstellen. ## Schritt 4: Verwenden von Lambda-Hilfsfunktionen mit Ihrer RDS-for-PostgreSQL-DB-Instance (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 Ihre Instance 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 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 RDS-for-PostgreSQL-DB-Instance](#PostgreSQL-Lambda-invoke). ## Schritt 5: Aufrufen einer Lambda-Funktion von Ihrem RDS-for-PostgreSQL-DB-Instance 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/UserGuide/images/lambda_simple_function.png) **Beispielfunktion aufrufen** 1. Stellen Sie per `psql` oder pgAdmin eine Verbindung zu Ihrer DB-Instance her. ``` psql -h instance.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 DB-Instance her. ``` psql -h instance.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 Ihrer RDS-for-PostgreSQL-DB-Instance 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 Ihrer RDS-for-PostgreSQL-DB-Instance (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 Ihrer RDS-for-PostgreSQL-DB-Instance (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. Wenn Ihre DB-Instance privat ist, überprüfen Sie das private DNS-Setup für Ihre VPC. Stellen Sie sicher, dass Sie den `rds.custom_dns_resolution` Parameter auf 1 setzen und die Einrichtung AWS PrivateLink wie unter beschrieben durchführen[Schritt 1: Konfigurieren Sie Ihren für ausgehende Verbindungen zu AWS Lambda](PostgreSQL-Lambda.md#PostgreSQL-Lambda-network). Weitere Informationen finden Sie unter [Interface VPC Endpoints ()AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#vpce-private-dns). + **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 RDS für 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 für PostgreSQL-DB-Instance 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 RDS die AWS-Region aus dem vollständigen ARN in der `function_name` oder die RDS für 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, Availability Zones und Local 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. |