Aufrufen einer AWS Lambda Funktion aus einem Aurora PostgreSQL-DB-Cluster ( PostgreSQL-DB-Instance) - Amazon Aurora
Schritt 1: Konfigurieren ausgehender VerbindungenSchritt 2: Konfigurieren von IAM für Ihren Cluster und LambdaSchritt 3: Installieren der ErweiterungSchritt 4: Verwenden von Lambda-HilfsfunktionenSchritt 5: Aufrufen einer Lambda-Funktion Schritt 6: Erteilen von Berechtigungen für Benutzer

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 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? im AWS Lambda Entwicklerhandbuch.

Anmerkung

Das Aufrufen von AWS Lambda Funktionen wird in Aurora PostgreSQL 11.9 und höher unterstützt (einschließlich Aurora Serverless v2).

Im Folgenden finden Sie Zusammenfassungen der notwendigen Schritte.

Weitere Informationen über Lambda-Funktionen finden Sie unter Erste Schritte mit Lambda und Grundlagen von AWS Lambda im AWS Lambda -Entwicklerhandbuch.

Themen

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 AWS CLI Alternativ können Sie über die AWS Management Console 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 Management Console oder die AWS CLI verwenden.

    Um den Zugriff auf Lambda einzurichten, verwenden Sie AWS Management Console 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. Sie können Ihre VPC auch mit einem VPC-Endpunkt für Lambda konfigurieren. Weitere Informationen finden Sie unter VPC-Endpunkte 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, 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.

  2. Verwenden Sie den AWS CLI Befehl create-role, um eine IAM-Rolle 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"
        }
    ]
}'

  3. Wenden Sie die Richtlinie mithilfe des Befehls auf die Rolle an. attach-role-policy 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

  4. 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 der aws_lambda-Erweiterung für einen Aurora-PostgreSQL-DB-Cluster

Diese Erweiterung bietet Ihrem Aurora-PostgreSQL-DB-Cluster die Möglichkeit, Lambda-Funktionen von PostgreSQL aus aufzurufen.

aws_lambda-Erweiterung in einem Aurora-PostgreSQL-DB-Cluster installieren

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

  2. 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 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, wenn sie sich nicht in derselben Region wie Ihre Aurora befindet.

Um die Daten zum Lambda-Funktionsnamen zu speichern, verwenden Sie die 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_lambda.invoke-Funktion verwendet werden. Beispiele finden Sie unter Schritt 5: Aufrufen einer Lambda-Funktion von Ihrem Aurora-PostgreSQL-DB-Cluster.

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 im for AWS CLI AWS Lambda
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

  2. 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 .

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

  2. 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;