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 Lambda-Funktion mit einer Aurora MySQL-Stored Procedure (veraltet)
<a name="AuroraMySQL.Integrating.ProcLambda"></a>

Sie können eine AWS Lambda Funktion aus einem Aurora MySQL-DB-Cluster aufrufen, indem Sie die `mysql.lambda_async` Prozedur aufrufen. Dieser Ansatz kann nützlich sein, wenn Sie Ihre Datenbank, die auf Aurora MySQL läuft, in andere AWS Dienste 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. 

**Contents**
+ [Überlegungen zu Aurora MySQL-Versionen](#AuroraMySQL.Integrating.ProcLambda.caveats)
+ [Verwenden der Prozedur „mysql.lambda async“ zum Aufrufen einer Lambda-Funktion (veraltet)](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async)
  + [Syntax](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Syntax)
  + [Parameters](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Parameters)
  + [Beispiele](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Examples)

## Überlegungen zu Aurora MySQL-Versionen
<a name="AuroraMySQL.Integrating.ProcLambda.caveats"></a>

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](AuroraMySQL.Integrating.NativeLambda.md#AuroraMySQL.Integrating.NativeLambda.lambda_functions).

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)
<a name="AuroraMySQL.Integrating.Lambda.mysql_lambda_async"></a>

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
<a name="AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Syntax"></a>

Die Prozedur `mysql.lambda_async` verwendet die folgende Syntax.

```
CALL mysql.lambda_async (
  lambda_function_ARN,
  lambda_function_input
)
```

### Parameters
<a name="AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Parameters"></a>

Die Prozedur `mysql.lambda_async` hat die folgenden Parameter.

* lambda\$1function\$1ARN *  
Der Amazon-Ressourcenname (ARN) der aufzurufenden Lambda-Funktion.

* lambda\$1function\$1input *  
Die Eingabezeichenfolge im JSON-Format für die aufgerufene Lambda-Funktion.

### Beispiele
<a name="AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Examples"></a>

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**  
Seien Sie vorsichtig, wenn Sie eine AWS Lambda Funktion über Trigger in Tabellen aufrufen, die einen hohen Schreibverkehr haben. `INSERT`,`UPDATE`, und `DELETE` Trigger 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.   
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.

**Example Beispiel: Rufen Sie eine AWS Lambda Funktion zum Senden von E-Mails auf**  
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');
```

**Example Beispiel: Rufen Sie eine AWS Lambda Funktion auf, um ein Ereignis über einen Trigger zu veröffentlichen**  
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!');
```