Gewähren von Zugriff auf Lambda für Aurora Aufrufen einer Lambda-Funktion mit einer nativen Funktion Aufrufen einer Lambda-Funktion mit einer Stored Procedure (veraltet)

Aufrufen einer Lambda-Funktion aus einem Amazon Aurora MySQL-DB-Cluster

Sie können eine AWS Lambda-Funktion von einem Amazon Aurora MySQL-kompatiblen Edition-DB-Cluster mit der nativen Funktion lambda_sync oder lambda_async aufrufen. Damit Sie eine Lambda-Funktion von einem Aurora MySQL aufrufen können, benötigt der Aurora-DB-Cluster Zugriff auf Lambda. Details zum Gewähren des Zugriffs auf Aurora MySQL finden Sie unter Gewähren von Zugriff auf Lambda für Aurora. Informationen zu den gespeicherten lambda_sync- und lambda_async-Funktionen finden Sie unter Aufrufen einer Lambda-Funktion mit einer nativen Aurora MySQL-Funktion.

Sie können eine AWS Lambda-Funktion auch mithilfe einer gespeicherten Prozedur aufrufen. Die Verwendung einer gespeicherten Prozedur ist jedoch veraltet. Wir empfehlen nachdrücklich die Verwendung einer Aurora MySQL-nativen Funktion, wenn Sie eine der folgenden Aurora MySQL-Versionen nutzen:

Aurora MySQL Version 2 für MySQL 5.7-kompatible Cluster.
Aurora MySQL Version 3.01 und höher für MySQL 8.0-kompatible Cluster. Die gespeicherte Prozedur ist in Aurora MySQL Version 3 nicht verfügbar.

Themen

Gewähren von Zugriff auf Lambda für Aurora
Aufrufen einer Lambda-Funktion mit einer nativen Aurora MySQL-Funktion
Aufrufen einer Lambda-Funktion mit einer Aurora MySQL-Stored Procedure (veraltet)

Gewähren von Zugriff auf Lambda für Aurora

Bevor Sie Lambda-Funktionen von einem Aurora MySQL DB-Cluster aufrufen können, stellen Sie sicher, dass Sie Ihrem Cluster zuerst die Berechtigung für den Zugriff auf Lambda erteilen.

So gewähren Sie Aurora MySQL Zugriff auf Lambda:

Erstellen Sie eine AWS Identity and Access Management-(IAM)-Richtlinie, die die Berechtigungen bereitstellt, die Ihrem Aurora-MySQL-DB-Cluster gestatten, Lambda-Funktionen aufzurufen. Detaillierte Anweisungen finden Sie unter Erstellen einer IAM-Zugriffsrichtlinie für AWS Lambda-Ressourcen.
Erstellen Sie eine IAM-Rolle und fügen Sie der neuen IAM-Rolle die IAM-Richtlinie hinzu, die Sie in Erstellen einer IAM-Zugriffsrichtlinie für AWS Lambda-Ressourcen erstellt haben. Detaillierte Anweisungen finden Sie unter Erstellen einer IAM-Rolle, um Amazon Aurora den Zugriff auf AWS-Services zu erlauben.
Sie müssen für den Amazon-Ressourcennamen (ARN) der neuen IAM-Rolle den DB-Cluster-Parameter aws_default_lambda_role festlegen.

Wenn das Cluster Teil einer globalen Aurora-Datenbank ist, wenden Sie dieselbe Einstellung auf jeden Aurora-Cluster in der globalen Datenbank an.

Weitere Informationen zu DB-Cluster-Parametern finden Sie unter Amazon Aurora-DB-Cluster und DB-Instance-Parameter.
Weisen Sie die Rolle, die Sie in Erstellen einer IAM-Rolle, um Amazon Aurora den Zugriff auf AWS-Services zu erlauben erstellt haben, diesem DB-Cluster zu, um Datenbankbenutzern in einem Aurora MySQL DB-Cluster den Aufruf von Lambda-Funktionen zu erlauben. Weitere Informationen zum Zuordnen einer IAM-Rolle zu einem DB-Cluster finden Sie unter Zuweisen einer IAM-Rolle zu einem Amazon-Aurora-MySQL-DB-Cluster.

Wenn das Cluster Teil einer globalen Aurora-Datenbank ist, verknüpfen Sie die Rolle mit jedem Aurora-Cluster in der globalen Datenbank.
Konfigurieren Sie Ihren Aurora MySQL-DB-Cluster so, dass er ausgehende Verbindungen zu Lambda zulässt. Detaillierte Anweisungen finden Sie unter Aktivieren der Netzwerkkommunikation von Amazon Aurora MySQL zu anderen AWS-Services.

Wenn das Cluster Teil einer globalen Aurora-Datenbank ist, aktivieren Sie ausgehende Verbindungen für jeden Aurora-Cluster in der globalen Datenbank.

Aufrufen einer Lambda-Funktion mit einer nativen Aurora MySQL-Funktion

Anmerkung

Sie können die nativen Funktionen lambda_sync und lambda_async aufrufen, wenn Sie Aurora MySQL Version 2 oder Aurora MySQL Version 3.01 und höher verwenden. Weitere Informationen zu den Aurora MySQL-Versionen erhalten Sie unter Datenbank-Engine-Updates für Amazon Aurora MySQL.

Sie können eine AWS Lambda-Funktion in einem Aurora-MySQL-DB-Cluster durch den Aufruf der nativen Funktionen lambda_sync und lambda_async aufrufen. Dieser Ansatz kann hilfreich sein, wenn Sie Ihre Datenbank in Aurora MySQL in andere AWS-Services integrieren möchten. Beispielsweise soll jedes Mal, wenn eine Zeile in eine bestimmte Tabelle der Datenbank eingefügt wird, eine Benachrichtigung mit Amazon Simple Notification Service (Amazon SNS) gesendet werden.

Inhalt

Arbeiten mit nativen Funktionen zum Aufrufen einer Lambda-Funktion

Arbeiten mit nativen Funktionen zum Aufrufen einer Lambda-Funktion

Die Funktionen lambda_sync und lambda_async sind eingebaute, native Funktionen, die eine Lambda-Funktion synchron oder asynchron aufrufen. Wenn Sie das Ergebnis der Ausführung der aufgerufenen Lambda-Funktion kennen müssen, bevor Sie zu einer anderen Aktion übergehen, verwenden Sie die synchrone Funktion lambda_sync. Wenn Sie das Ergebnis der Ausführung der aufgerufenen Lambda-Funktion nicht kennen müssen, bevor Sie zu einer anderen Aktion übergehen, verwenden Sie die asynchrone Funktion lambda_async.

Gewähren der Rolle in Aurora MySQL Version 3

In Aurora MySQL Version 3 muss dem Benutzer, der eine native Funktion aufruft, die AWS_LAMBDA_ACCESS-Rolle gewährt werden. Um einem Benutzer diese Rolle zuzuweisen, stellen Sie als Administrator eine Verbindung zur DB-Instance her und führen Sie die folgende Anweisung aus.


GRANT AWS_LAMBDA_ACCESS TO user@domain-or-ip-address

Sie können diese Rolle widerrufen, indem Sie die folgende Anweisung ausführen.


REVOKE AWS_LAMBDA_ACCESS FROM user@domain-or-ip-address

Tipp

Wenn Sie die Rollentechnik in Aurora MySQL Version 3 verwenden, können Sie die Rolle auch mit der Anweisung SET ROLE role_name oder SET ROLE ALL aktivieren. Wenn Sie mit dem MySQL 8.0-Rollensystem nicht vertraut sind, finden Sie in Rollenbasiertes Berechtigungsmodell weitere Informationen. Weitere Informationen finden Sie unter Using roles im MySQL-Referenzhandbuch.

Dies gilt nur für die aktuelle aktive Sitzung. Wenn Sie sich wieder verbinden, müssen Sie die SET ROLE-Anweisung noch einmal ausführen, um Berechtigungen zu gewähren. Weitere Informationen finden Sie unter SET ROLE-Anweisung im MySQL-Referenzhandbuch.

Sie können den DB-Cluster-Parameter activate_all_roles_on_login zum automatischen Aktivieren aller Rollen verwenden, wenn ein Benutzer eine Verbindung mit einer DB-Instance herstellt. Wenn dieser Parameter festgelegt ist, müssen Sie die SET ROLE-Anweisung nicht explizit aufrufen, um eine Rolle zu aktivieren. Weitere Informationen finden Sie unter activate_all_roles_on_login im MySQL-Referenzhandbuch.

Wenn Sie beim Versuch, eine Lambda-Funktion aufzurufen, eine Fehlermeldung wie die folgende erhalten, führen Sie eine SET ROLE-Anweisung aus.


SQL Error [1227] [42000]: Access denied; you need (at least one of) the Invoke Lambda privilege(s) for this operation

Gewähren der Berechtigung in Aurora MySQL Version 2

In Aurora MySQL Version 2 muss dem Benutzer, der eine native Funktion aufruft, die INVOKE LAMBDA-Berechtigung gewährt werden. Um einem Benutzer diese Berechtigung zu erteilen, stellen Sie als Administrator eine Verbindung zur DB-Instance her und führen Sie die folgende Anweisung aus.


GRANT INVOKE LAMBDA ON *.* TO user@domain-or-ip-address

Sie können das Recht für einen anderen Benutzer mithilfe der folgenden Anweisung erteilen.


REVOKE INVOKE LAMBDA ON *.* FROM user@domain-or-ip-address

Syntax für die lambda_sync-Funktion

Sie rufen die Funktion lambda_sync synchron zum Aufruftyp RequestResponse auf. Die Funktion gibt das Ergebnis des Aufrufs von Lambda in einer JSON-Nutzlast zurück. Die Funktion weist die folgende Syntax auf.


lambda_sync (
  lambda_function_ARN,
  JSON_payload
)

Parameter für die lambda_sync-Funktion

Die Funktion lambda_sync hat die folgenden Parameter.

lambda_function_ARN: Der Amazon-Ressourcenname (ARN) der aufzurufenden Lambda-Funktion.
JSON-Nutzlast: Die Nutzlast für die aufgerufene Lambda-Funktion im JSON-Format.

Anmerkung

Aurora MySQL Version 3 unterstützt die JSON-Parsingfunktionen von MySQL 8.0. Aurora MySQL-Version 2 enthält diese Funktionen jedoch nicht. JSON-Parsing ist nicht erforderlich, wenn eine Lambda-Funktion einen atomaren Wert zurückgibt, wie z. B. eine Zahl oder einen String.

Beispiel für die lambda_sync-Funktion

Die folgende Abfrage, die auf lambda_sync basiert, ruft die Lambda-Funktion BasicTestLambda synchron mithilfe der ARN-Funktion auf. Die Nutzlast für die Funktion ist {"operation": "ping"}.


SELECT lambda_sync(
    'arn:aws:lambda:us-east-1:123456789012:function:BasicTestLambda',
    '{"operation": "ping"}');

Syntax für die lambda_async-Funktion

Sie rufen die Funktion lambda_async asynchron zum Aufruftyp Event auf. Die Funktion gibt das Ergebnis des Aufrufs von Lambda in einer JSON-Nutzlast zurück. Die Funktion weist die folgende Syntax auf.


lambda_async (
  lambda_function_ARN,
  JSON_payload
)

Parameter für die lambda_async-Funktion

Die Funktion lambda_async hat die folgenden Parameter.

lambda_function_ARN: Der Amazon-Ressourcenname (ARN) der aufzurufenden Lambda-Funktion.
JSON-Nutzlast: Die Nutzlast für die aufgerufene Lambda-Funktion im JSON-Format.

Anmerkung

Beispiel für die lambda_async-Funktion

Die folgende Abfrage, die auf lambda_async basiert, ruft die Lambda-Funktion BasicTestLambda asynchron mithilfe der ARN-Funktion auf. Die Nutzlast für die Funktion ist {"operation": "ping"}.


SELECT lambda_async(
    'arn:aws:lambda:us-east-1:123456789012:function:BasicTestLambda',
    '{"operation": "ping"}');

Aufrufen einer Lambda-Funktion innerhalb eines Auslösers

Sie können Auslöser verwenden, um Lambda für datenmodifizierende Anweisungen aufzurufen. Das folgende Beispiel verwendet die native lambda_async-Funktion und speichert das Ergebnis in einer Variablen.


mysql>SET @result=0;
mysql>DELIMITER //
mysql>CREATE TRIGGER myFirstTrigger
      AFTER INSERT
          ON Test_trigger FOR EACH ROW
      BEGIN
      SELECT lambda_async(
          'arn:aws:lambda:us-east-1:123456789012:function:BasicTestLambda',
          '{"operation": "ping"}')
          INTO @result;
      END; //
mysql>DELIMITER ;

Anmerkung

Auslöser werden nicht einmal pro SQL-Anweisung ausgeführt, sondern einmal pro geänderter Zeile, jeweils für eine einzelne Zeile. Wenn ein Trigger ausgeführt wird, ist der Prozess synchron. Die datenmodifizierende Anweisung wird nur zurückgegeben, wenn der Trigger abgeschlossen ist.

Seien Sie vorsichtig, wenn Sie eine AWS Lambda-Funktion aus Auslösern in Tabellen aufrufen, die einen hohen Schreibdatenverkehr aufweisen. Die Auslöser INSERT, UPDATE und DELETE werden pro Zeile aktiviert. Ein Workload mit hohem Schreibdatenverkehr in einer Tabelle mit den Auslösern INSERT, UPDATE oder DELETE führt zu einer hohen Anzahl von Aufrufen Ihrer AWS Lambda-Funktion.

Aufrufen einer Lambda-Funktion mit einer Aurora MySQL-Stored Procedure (veraltet)

Sie können eine AWS Lambda-Funktion in einem Aurora-MySQL-DB-Cluster durch den Aufruf der Prozedur mysql.lambda_async aufrufen. Dieser Ansatz kann hilfreich sein, wenn Sie Ihre Datenbank in Aurora MySQL in andere AWS-Services integrieren möchten. Beispielsweise soll jedes Mal, wenn eine Zeile in eine bestimmte Tabelle der Datenbank eingefügt wird, eine Benachrichtigung mit Amazon Simple Notification Service (Amazon SNS) gesendet werden.

Inhalt

Überlegungen zu Aurora MySQL-Versionen

Ab Aurora MySQL Version 2 können Sie die native Funktionsmethode anstelle dieser gespeicherten Prozeduren verwenden, um eine Lambda-Funktion aufzurufen. Weitere Informationen zu den nativen Funktionen finden Sie unter Arbeiten mit nativen Funktionen zum Aufrufen einer Lambda-Funktion.

In Aurora MySQL Version 2 wird die gespeicherte Prozedur mysql.lambda_async nicht mehr unterstützt. Es wird dringend empfohlen, stattdessen native Lambda-Funktionen zu verwenden.

In Aurora MySQL Version 3 ist die gespeicherte Prozedur nicht verfügbar.

Verwenden der Prozedur „mysql.lambda async“ zum Aufrufen einer Lambda-Funktion (veraltet)

Bei mysql.lambda_async handelt es sich um eine integrierte gespeicherte Prozedur, mit der eine Lambda-Funktion asynchron aufgerufen wird. Zur Nutzung dieser Prozedur muss der Datenbankbenutzer über die EXECUTE-Berechtigung für die gespeicherte Prozedur mysql.lambda_async verfügen.

Syntax

Die Prozedur mysql.lambda_async verwendet die folgende Syntax.


CALL mysql.lambda_async (
  lambda_function_ARN,
  lambda_function_input
)

Parameter

Die Prozedur mysql.lambda_async hat die folgenden Parameter.

lambda_function_ARN: Der Amazon-Ressourcenname (ARN) der aufzurufenden Lambda-Funktion.
lambda_function_input: Die Eingabezeichenfolge im JSON-Format für die aufgerufene Lambda-Funktion.

Beispiele

Als bewährte Methode wird empfohlen, Aufrufe der Prozedur mysql.lambda_async in einer gespeicherten Prozedur zu verpacken, die aus verschiedenen Quellen aufgerufen werden kann, wie zum Beispiel Auslöser oder Clientcode. Mit dieser Methode werden Probleme mit Impedanzfehlanpassungen vermieden, zudem wird der Aufruf von Lambda-Funktionen vereinfacht.

Anmerkung

Die Aufrufe der Prozedur mysql.lambda_async sind asynchron, Auslöser jedoch synchron. Eine Anweisung, die zu einer hohen Anzahl an Auslöseraktivierungen führt, wartet nicht, bis der AWS Lambda-Funktionsaufruf abgeschlossen ist – sie wartet jedoch, bis die Auslöser abgeschlossen sind, bevor die Kontrolle an den Client zurückgegeben wird.

Beispiel: Aufrufen einer AWS Lambda-Funktion zum Senden einer E-Mail

Im folgenden Beispiel wird eine gespeicherte Prozedur erstellt, die Sie in Ihrem Datenbankcode aufrufen können, um eine E-Mail mit einer Lambda-Funktion zu senden.

AWS Lambda-Funktion


import boto3

ses = boto3.client('ses')

def SES_send_email(event, context):

    return ses.send_email(
        Source=event['email_from'],
        Destination={
            'ToAddresses': [
            event['email_to'],
            ]
        },

        Message={
            'Subject': {
            'Data': event['email_subject']
            },
            'Body': {
                'Text': {
                    'Data': event['email_body']
                }
            }
        }
    )

Gespeicherte Prozedur


DROP PROCEDURE IF EXISTS SES_send_email;
DELIMITER ;;
  CREATE PROCEDURE SES_send_email(IN email_from VARCHAR(255),
                                  IN email_to VARCHAR(255),
                                  IN subject VARCHAR(255),
                                  IN body TEXT) LANGUAGE SQL
  BEGIN
    CALL mysql.lambda_async(
         'arn:aws:lambda:us-west-2:123456789012:function:SES_send_email',
         CONCAT('{"email_to" : "', email_to,
             '", "email_from" : "', email_from,
             '", "email_subject" : "', subject,
             '", "email_body" : "', body, '"}')
     );
  END
  ;;
DELIMITER ;

Abrufen der gespeicherten Prozedur zum Aufrufen der AWS Lambda-Funktion


mysql> call SES_send_email('example_from@amazon.com', 'example_to@amazon.com', 'Email subject', 'Email content');

Beispiel: Aufrufen einer AWS Lambda-Funktion zum Veröffentlichen eines Ereignisses von einem Auslöser

Im folgenden Beispiel wird eine gespeicherte Prozedur erstellt, die ein Ereignis mithilfe von Amazon SNS veröffentlicht. Der Code ruft die Prozedur von einem Auslöser auf, wenn eine Zeile zu einer Tabelle hinzugefügt wird.

AWS Lambda-Funktion


import boto3

sns = boto3.client('sns')

def SNS_publish_message(event, context):

    return sns.publish(
        TopicArn='arn:aws:sns:us-west-2:123456789012:Sample_Topic',
        Message=event['message'],
        Subject=event['subject'],
        MessageStructure='string'
    )

Gespeicherte Prozedur


DROP PROCEDURE IF EXISTS SNS_Publish_Message;
DELIMITER ;;
CREATE PROCEDURE SNS_Publish_Message (IN subject VARCHAR(255),
                                      IN message TEXT) LANGUAGE SQL
BEGIN
  CALL mysql.lambda_async('arn:aws:lambda:us-west-2:123456789012:function:SNS_publish_message',
     CONCAT('{ "subject" : "', subject,
            '", "message" : "', message, '" }')
     );
END
;;
DELIMITER ;

Tabelle


CREATE TABLE 'Customer_Feedback' (
  'id' int(11) NOT NULL AUTO_INCREMENT,
  'customer_name' varchar(255) NOT NULL,
  'customer_feedback' varchar(1024) NOT NULL,
  PRIMARY KEY ('id')
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Auslöser


DELIMITER ;;
CREATE TRIGGER TR_Customer_Feedback_AI
  AFTER INSERT ON Customer_Feedback
  FOR EACH ROW
BEGIN
  SELECT CONCAT('New customer feedback from ', NEW.customer_name), NEW.customer_feedback INTO @subject, @feedback;
  CALL SNS_Publish_Message(@subject, @feedback);
END
;;
DELIMITER ;

Einfügen einer Tabellenzeile zum Auslösen der Benachrichtigung


mysql> insert into Customer_Feedback (customer_name, customer_feedback) VALUES ('Sample Customer', 'Good job guys!');

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Speichern von Daten in Textdateien in Amazon S3

Veröffentlichen von Aurora MySQL-Protokollen in - CloudWatch Protokollen