

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.

# Tutorial: Verwenden einer Lambda-Funktion für den Zugriff auf eine Amazon-RDS-Datenbank
<a name="rds-lambda-tutorial"></a>

In diesem Tutorial verwenden Sie eine Lambda-Funktion, um Daten über RDS-Proxy in eine [Amazon Relational Database Service](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) (Amazon RDS)-Datenbank zu schreiben. Ihre Lambda-Funktion liest Datensätze aus einer Amazon Simple Queue Service (Amazon SQS)-Warteschlange und schreibt ein neues Element in eine Tabelle in Ihrer Datenbank, sobald eine Nachricht hinzugefügt wird. In diesem Beispiel verwenden Sie die AWS-Managementkonsole , um Ihrer Warteschlange manuell Nachrichten hinzuzufügen. Das folgende Diagramm zeigt die AWS Ressourcen, die Sie zur Durchführung des Tutorials verwenden.

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_1.png)


Mit Amazon RDS können Sie eine verwaltete relationale Datenbank in der Cloud mithilfe gängiger Datenbankprodukte wie Microsoft SQL Server, MariaDB, MySQL, Oracle Database und PostgreSQL ausführen. Wenn Sie Lambda für den Zugriff auf Ihre Datenbank verwenden, können Sie Daten als Reaktion auf Ereignisse lesen und schreiben, z. B. wenn sich ein neuer Kunde auf Ihrer Website registriert. Ihre Funktion, Datenbank-Instance und der Proxy skalieren automatisch, um Zeiten hoher Nachfrage gerecht zu werden.

Führen Sie für dieses Tutorial die folgenden Aufgaben aus:

1. Starten Sie eine RDS for MySQL-Datenbank-Instance und einen Proxy in Ihrer AWS-Konto Standard-VPC.

1. Erstellen und testen Sie eine Lambda-Funktion, die eine neue Tabelle in Ihrer Datenbank erstellt und Daten in diese schreibt.

1. Erstellen Sie eine Amazon-SQS-Warteschlange und konfigurieren Sie sie so, dass Ihre Lambda-Funktion aufgerufen wird, wenn eine neue Nachricht hinzugefügt wird.

1. Testen Sie das komplette Setup, indem Sie Nachrichten mithilfe von zu Ihrer Warteschlange hinzufügen AWS-Managementkonsole und die Ergebnisse mithilfe von CloudWatch Logs überwachen.

Wenn Sie diese Schritte ausführen, lernen Sie Folgendes:
+ Verwenden von Amazon RDS, um eine Datenbank-Instance und einen Proxy zu erstellen und eine Lambda-Funktion mit dem Proxy zu verbinden.
+ Verwenden von Lambda, um Erstellungs- und Lesevorgänge in einer Amazon-RDS-Datenbank durchzuführen
+ Verwenden von Amazon SQS zum Aufrufen einer Lambda-Funktion

Sie können dieses Tutorial mit dem AWS-Managementkonsole oder dem AWS Command Line Interface (AWS CLI) abschließen.

## Voraussetzungen
<a name="vpc-rds-prereqs"></a>

Bevor Sie die Schritte in diesem Abschnitt abschließen, stellen Sie sicher, dass Sie folgende Voraussetzungen erfüllen:
+ [Melden Sie sich an für ein AWS-Konto](CHAP_SettingUp.md#sign-up-for-aws)
+ [Erstellen eines Benutzers mit Administratorzugriff](CHAP_SettingUp.md#create-an-admin)

## Erstellen einer DB-Instance von Amazon RDS
<a name="vpc-rds-create-RDS-instance"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step1.png)


Eine DB-Instance von Amazon RDS ist eine isolierte Datenbankumgebung, die in der AWS Cloud ausgeführt wird. Eine Instance kann mehrere von Benutzern erstellte Datenbanken enthalten. Sofern Sie nichts anderes angeben, erstellt Amazon RDS neue Datenbank-Instances in der Standard-VPC, die in Ihrer AWS-Konto enthalten ist. Weitere Informationen zu Amazon VPC finden Sie im [Benutzerhandbuch von Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).

In diesem Tutorial erstellen Sie eine neue Instance in Ihrer AWS-Konto Standard-VPC und erstellen eine Datenbank mit dem Namen dieser `ExampleDB` Instance. Sie können Ihre DB-Instance und Datenbank entweder mit dem AWS-Managementkonsole oder dem AWS CLI erstellen.

**So erstellen Sie eine Datenbank-Instance**

1. Öffnen Sie die Amazon-RDS-Konsole und wählen Sie **Datenbank erstellen** aus.

1. Lassen Sie die **Standard-Erstellungsoption** aktiviert und wählen Sie dann unter **Engine-Optionen** die Option **MySQL** aus.

1. Wählen Sie unter **Vorlagen** die Option **Kostenloses Kontingent** oder **Sandbox** aus. **Kostenloses Kontingent** wird für Konten mit kostenlosem Kontingent angezeigt. **Sandbox** wird für Konten mit kostenpflichtigem Tarif angezeigt.

1. Geben Sie unter **Settings (Einstellungen)** für die **DB instance identifier (DB-Instance-Kennung)** **MySQLForLambda** ein.

1. Gehen Sie wie folgt vor, um Ihren Benutzernamen und Ihr Passwort zu erstellen:

   1. Belassen Sie in den **Einstellungen für Anmeldeinformationen** den **Hauptbenutzernamen** bei `admin`.

   1. Geben Sie als **Master-Passwort** ein Passwort ein und bestätigen Sie es, um auf Ihre Datenbank zuzugreifen.

1. Geben Sie den Datenbanknamen an, indem Sie wie folgt vorgehen:
   + Lassen Sie alle verbleibenden Standardoptionen ausgewählt und scrollen Sie nach unten zum Abschnitt **Zusätzliche Konfiguration**.
   + Erweitern Sie diesen Bereich und geben Sie **ExampleDB** als **Anfänglicher Datenbankname** ein.

1. Lassen Sie alle verbleibenden Standardoptionen ausgewählt und wählen Sie **Create database (Datenbank erstellen)**.

## Erstellen einer Lambda-Funktion und eines Proxys
<a name="auto-create-Lambda"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step2.png)


Sie können die RDS-Konsole verwenden, um eine Lambda-Funktion und einen Proxy in derselben VPC wie die Datenbank zu erstellen. 

**Anmerkung**  
Sie können diese zugehörigen Ressourcen nur erstellen, wenn Ihre Datenbank die Erstellung abgeschlossen hat und sich im Status **Verfügbar** befindet.

**So erstellen Sie eine zugehörige Funktion und einen Proxy**

1. Überprüfen Sie auf der Seite **Datenbanken**, ob sich Ihre Datenbank im Status **Verfügbar** befindet. Ist dies der Fall, fahren Sie mit dem nächsten Schritt fort. Andernfalls warten Sie, bis Ihre Datenbank verfügbar ist.

1. Wählen Sie Ihre Datenbank und die Option **Lambda-Verbindung einrichten** unter **Aktionen** aus.

1. Wählen Sie auf der Seite **Lambda-Verbindung einrichten** die Option **Neue Funktion erstellen** aus.

   Legen Sie den Wert im Feld **Neuer Lambda-Funktionsname** auf **LambdaFunctionWithRDS** fest.

1. Wählen Sie im Abschnitt **RDS-Proxy** die Option **Über RDS-Proxy verbinden** aus. Wählen Sie dann **Neuen Proxy erstellen** aus.
   + Wählen Sie für **Datenbank-Anmeldeinformationen** die Option **Datenbank-Benutzername und Passwort** aus.
   + Geben Sie für **Benutzername** den Namen `admin` an.
   + Geben Sie unter **Passwort** das Passwort ein, das Sie für Ihre DB-Instance erstellt haben. 

1. Wählen Sie **Einrichten** aus, um die Erstellung des Proxys und der Lambda-Funktion abzuschließen.

Der Assistent schließt die Einrichtung ab und stellt einen Link zur Lambda-Konsole bereit, über den Sie Ihre neue Funktion überprüfen können. Notieren Sie sich den Proxy-Endpunkt, bevor Sie zur Lambda-Konsole wechseln.

## Erstellen einer Funktionsausführungsrolle
<a name="vpc-rds-create-execution-role"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step3.png)


Bevor Sie Ihre Lambda-Funktion erstellen, erstellen Sie eine Ausführungsrolle, um Ihrer Funktion die erforderlichen Berechtigungen zu geben. Für dieses Tutorial benötigt Lambda die Berechtigung, die Netzwerkverbindung zu der VPC, die Ihre Datenbank-Instance enthält, zu verwalten und Nachrichten aus einer Amazon-SQS-Warteschlange abzufragen.

Um Ihrer Lambda-Funktion die erforderlichen Berechtigungen zu geben, verwendet dieses Tutorial von IAM verwaltete Richtlinien. Dies sind Richtlinien, die Berechtigungen für viele häufige Anwendungsfälle erteilen und in Ihrem AWS-Konto verfügbar sind. Weitere Informationen über die Verwendung verwalteter Richtlinien finden Sie unter [Best Practices für Richtlinien](security_iam_id-based-policy-examples.md#security_iam_service-with-iam-policy-best-practices).

**So erstellen Sie eine Lambda-Ausführungsrolle**

1. Öffnen Sie die Seite [Roles (Rollen)](https://console.aws.amazon.com/iamv2/home#/roles) Ihrer IAM-Konsole und wählen Sie **Create role (Rolle erstellen)**.

1. Wählen Sie als **Vertrauenswürdiger Entitätstyp** die Option **AWS Service** und als **Anwendungsfall** die Option **Lambda** aus.

1. Wählen Sie **Weiter** aus.

1. Fügen Sie die von IAM verwalteten Richtlinien hinzu, indem Sie wie folgt vorgehen:

   1. Verwenden Sie das Richtliniensuchfeld zur Suche nach **AWSLambdaSQSQueueExecutionRole**.

   1. Aktivieren Sie in der Ergebnisliste das Kontrollkästchen neben der Rolle und wählen Sie **Clear filters (Filter löschen)**.

   1. Verwenden Sie das Richtliniensuchfeld zur Suche nach **AWSLambdaVPCAccessExecutionRole**.

   1. Aktivieren Sie in der Ergebnisliste das Kontrollkästchen neben der Rolle und wählen Sie **Next (Weiter)**.

1. Geben Sie für **Role name (Rollenname)** den Namen **lambda-vpc-sqs-role** ein und wählen Sie dann **Create role (Rolle erstellen)**.

Später im Tutorial benötigen Sie den Amazon-Ressourcennamen (ARN) der Ausführungsrolle, die Sie gerade erstellt haben.

**So suchen Sie nach einem Ausführungsrollen-ARN**

1. Öffnen Sie die Seite [Rollen](https://console.aws.amazon.com/iamv2/home#/roles) Ihrer IAM-Konsole und wählen Sie Ihre Rolle (`lambda-vpc-sqs-role`) aus.

1.  Kopieren Sie den **Rollen-ARN**, der im Abschnitt **Zusammenfassung** angezeigt wird.

## Erstellen eines Lambda-Bereitstellungspakets
<a name="vpc-rds-create-deployment-package"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step4.png)


Der folgende Python-Beispielcode verwendet das [PyMySQL-Paket](https://pymysql.readthedocs.io/en/latest/), um eine Verbindung zu Ihrer Datenbank zu öffnen. Wenn Sie Ihre Funktion zum ersten Mal aufrufen, wird auch eine neue Tabelle namens `Customer` erstellt. Die Tabelle verwendet das folgende Schema, wobei `CustID` der Primärschlüssel ist:

```
Customer(CustID, Name)
```

Die Funktion verwendet auch PyMy SQL, um dieser Tabelle Datensätze hinzuzufügen. Die Funktion fügt Datensätze mit Kunden IDs und Namen hinzu, die in Nachrichten angegeben sind, die Sie zu Ihrer Amazon SQS SQS-Warteschlange hinzufügen werden.

Der Code stellt die Verbindung mit Ihrer Datenbank außerhalb der Handlerfunktion her. Durch das Erstellen der Verbindung im Initialisierungscode kann die Verbindung durch nachfolgende Aufrufe Ihrer Funktion wiederverwendet werden, was die Leistung verbessert. In einer Produktionsanwendung können Sie die [bereitgestellte Parallelität](https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html) auch verwenden, um eine angeforderte Anzahl von Datenbankverbindungen zu initialisieren. Diese Verbindungen sind verfügbar, sobald Ihre Funktion aufgerufen wird.

```
import sys
import logging
import pymysql
import json
import os

# rds settings
user_name = os.environ['USER_NAME']
password = os.environ['PASSWORD']
rds_proxy_host = os.environ['RDS_PROXY_HOST']
db_name = os.environ['DB_NAME']

logger = logging.getLogger()
logger.setLevel(logging.INFO)

# create the database connection outside of the handler to allow connections to be
# re-used by subsequent function invocations.
try:
        conn = pymysql.connect(host=rds_proxy_host, user=user_name, passwd=password, db=db_name, connect_timeout=5)
except pymysql.MySQLError as e:
    logger.error("ERROR: Unexpected error: Could not connect to MySQL instance.")
    logger.error(e)
    sys.exit(1)

logger.info("SUCCESS: Connection to RDS for MySQL instance succeeded")

def lambda_handler(event, context):
    """
    This function creates a new RDS database table and writes records to it
    """
    message = event['Records'][0]['body']
    data = json.loads(message)
    CustID = data['CustID']
    Name = data['Name']

    item_count = 0
    sql_string = f"insert into Customer (CustID, Name) values(%s, %s)"

    with conn.cursor() as cur:
        cur.execute("create table if not exists Customer ( CustID  int NOT NULL, Name varchar(255) NOT NULL, PRIMARY KEY (CustID))")
        cur.execute(sql_string, (CustID, Name))
        conn.commit()
        cur.execute("select * from Customer")
        logger.info("The following items have been added to the database:")
        for row in cur:
            item_count += 1
            logger.info(row)
    conn.commit()

    return "Added %d items to RDS for MySQL table" %(item_count)
```

**Anmerkung**  
In diesem Beispiel werden Ihre Anmeldeinformationen für den Datenbankzugriff als Umgebungsvariablen gespeichert. In Produktionsanwendungen empfehlen wir, die Option [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) als sicherere Option zu verwenden. Hinweis: Wenn sich Ihre Lambda-Funktion in einer VPC befindet, müssen Sie einen VPC-Endpunkt erstellen, um eine Verbindung zu Secrets Manager herzustellen. Weitere Informationen finden Sie unter [Verwenden einer Lambda-Funktion für den Zugriff auf Amazon RDS in einer Amazon VPC](https://aws.amazon.com/blogs/security/how-to-connect-to-aws-secrets-manager-service-within-a-virtual-private-cloud/). 

 Um die PyMy SQL-Abhängigkeit in Ihren Funktionscode aufzunehmen, erstellen Sie ein ZIP-Bereitstellungspaket. Die folgenden Befehle funktionieren für Linux, macOS oder Unix:

**So erstellen Sie ein ZIP-Bereitstellungspaket**

1. Speichern Sie den Beispielcode als Datei mit dem Namen `lambda_function.py`. 

1. Erstellen Sie in demselben Verzeichnis, in dem Sie Ihre `lambda_function.py` Datei erstellt haben, ein neues Verzeichnis mit dem Namen `package` und installieren Sie die PyMy SQL-Bibliothek. 

   ```
   mkdir package
   pip install --target package pymysql
   ```

1. Erstellen Sie eine ZIP-Datei, die Ihren Anwendungscode und die PyMy SQL-Bibliothek enthält. Führen Sie unter Linux oder MacOS die folgenden CLI-Befehle aus. Verwenden Sie unter Windows Ihr bevorzugtes ZIP-Tool, um die `lambda_function.zip`-Datei zu erstellen. Ihre Quellcodedatei `lambda_function.py` und die Ordner, die Ihre Abhängigkeiten enthalten, müssen im Stammverzeichnis der ZIP-Datei installiert sein.

   ```
   cd package
   zip -r ../lambda_function.zip .
   cd ..
   zip lambda_function.zip lambda_function.py
   ```

   Sie können Ihr Bereitstellungspaket auch in einer virtuellen Python-Umgebung erstellen. Siehe [Bereitstellen von Python-Lambda-Funktionen mit ZIP-Dateiarchiven](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-package-with-dependency).

## Aktualisieren der Lambda-Funktion
<a name="vpc-rds-update-function"></a>

Mit dem soeben erstellten ZIP-Paket aktualisieren Sie nun Ihre Lambda-Funktion über die Lambda-Konsole. Damit Ihre Funktion auf Ihre Datenbank zugreifen kann, müssen Sie außerdem Umgebungsvariablen mit Ihren Zugangsdaten konfigurieren.

**So aktualisieren Sie die Lambda-Funktion**

1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie Ihre Funktion `LambdaFunctionWithRDS` aus.

1. Wählen Sie auf der Registerkarte **Laufzeiteinstellungen** die Option **Bearbeiten** aus, um die **Laufzeit** der Funktion auf **Python 3.10** zu ändern.

1. Ändern Sie den **Handler** in `lambda_function.lambda_handler`.

1. Wählen Sie im Bereich **Code** die Option **Hochladen von** und dann **ZIP-Datei** aus.

1. Wählen Sie die `lambda_function.zip`-Datei aus, die Sie in der vorherigen Phase erstellt haben, und wählen Sie **Save (Speichern)**.

Konfigurieren Sie nun die Funktion mit der zuvor erstellten Ausführungsrolle. Dadurch erhält die Funktion die Berechtigungen, die sie benötigt, um auf Ihre Datenbank-Instance zuzugreifen und eine Amazon-SQS-Warteschlange abzufragen.

**So konfigurieren Sie die Ausführungsrolle der Funktion**

1. Wählen Sie auf der Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Registerkarte **Konfiguration** und dann **Berechtigungen** aus.

1. Wählen Sie unter **Ausführungsrolle** die Option **Bearbeiten** aus.

1. Wählen Sie unter **Vorhandene Rolle** Ihre Ausführungsrolle (`lambda-vpc-sqs-role`) aus.

1. Wählen Sie **Speichern**.

**So konfigurieren Sie dei Umgebungsvariablen Ihrer Funktion**

1. Wählen Sie auf der Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Registerkarte **Konfiguration** und dann **Berechtigungsvariablen** aus.

1. Wählen Sie **Bearbeiten** aus.

1. Gehen Sie wie folgt vor, um Ihre Anmeldeinformationen für den Datenbankzugriff hinzuzufügen:

   1. Wählen Sie **Umgebungsvariable hinzufügen** und geben Sie dann **USER\$1NAME** für **Schlüssel** und **admin** für **Wert** ein.

   1. Wählen Sie **Umgebungsvariable hinzufügen** und geben Sie dann **DB\$1NAME** für **Schlüssel** und **ExampleDB** für **Wert** ein.

   1. Wählen Sie **Umgebungsvariable hinzufügen** und geben Sie dann **PASSWORD** für **Schlüssel** und für **Wert** das Passwort ein, das Sie bei der Erstellung Ihrer Datenbank gewählt haben.

   1. Wählen Sie **Umgebungsvariable hinzufügen** aus und geben Sie dann **RDS\$1PROXY\$1HOST** für **Schlüssel** und für **Wert** den RDS-Proxy-Endpunkt ein, den Sie zuvor notiert haben.

   1. Wählen Sie **Speichern**.

## Testen Ihrer Lambda-Funktion in der Konsole.
<a name="vpc-rds-test-function"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step5.png)


Sie können jetzt die Lambda-Konsole verwenden, um Ihre Funktion zu testen. Sie erstellen ein Testereignis, das die Daten nachahmt, die Ihre Funktion erhält, wenn Sie sie in der letzten Phase des Tutorials mit Amazon SQS aufrufen. Ihr Testereignis enthält ein JSON-Objekt, das eine Kunden-ID und einen Kundennamen angibt, die der von Ihrer Funktion erstellten `Customer`-Tabelle hinzugefügt werden sollen.

**Lambda-Funktion testen**

1. Öffnen Sie die Seite [Functions (Funktionen)](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie eine Funktion aus.

1. Wählen Sie den Abschnitt **Testen** aus.

1. Wählen Sie **Neues Ereignis erstellen** aus und geben Sie **myTestEvent** als Ereignisnamen ein.

1. Kopieren Sie den folgenden Code in **Event JSON (Ereignis-JSON)** und wählen Sie **Save (Speichern)**.

   ```
   {
     "Records": [
       {
         "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
         "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
         "body": "{\n     \"CustID\": 1021,\n     \"Name\": \"Martha Rivera\"\n}",
         "attributes": {
           "ApproximateReceiveCount": "1",
           "SentTimestamp": "1545082649183",
           "SenderId": "AIDAIENQZJOLO23YVJ4VO",
           "ApproximateFirstReceiveTimestamp": "1545082649185"
         },
         "messageAttributes": {},
         "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
         "eventSource": "aws:sqs",
         "eventSourceARN": "arn:aws:sqs:us-west-2:123456789012:my-queue",
         "awsRegion": "us-west-2"
       }
     ]
   }
   ```

1. Wählen Sie **Test** aus.

Auf der Registerkarte **Ausführungsergebnisse** sollten in den **Funktionsprotokollen** ähnliche Ergebnisse wie die folgenden angezeigt werden:

```
[INFO] 2023-02-14T19:31:35.149Z bdd06682-00c7-4d6f-9abb-89f4bbb4a27f The following items have been added to the database:
[INFO] 2023-02-14T19:31:35.149Z bdd06682-00c7-4d6f-9abb-89f4bbb4a27f (1021, 'Martha Rivera')
```

## Erstellen einer Amazon-SQS-Warteschlange
<a name="vpc-rds-create-queue"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step6.png)


Sie haben die Integration Ihrer Lambda-Funktion und der Amazon-RDS-Datenbank-Instance erfolgreich getestet. Jetzt erstellen Sie die Amazon-SQS-Warteschlange, mit der Sie Ihre Lambda-Funktion in der letzten Phase des Tutorials aufrufen werden.

**So erstellen Sie die Amazon-SQS-Warteschlange (Konsole)**

1. Öffnen Sie die Seite [Queues (Warteschlangen)](https://console.aws.amazon.com/sqs/v2/home#/queues) der Amazon-SQS-Konsole und wählen Sie **Create queue (Warteschlange erstellen)** aus.

1. Belassen Sie den **Type (Typ)** auf **Standard** und geben Sie **LambdaRDSQueue** als Namen Ihrer Warteschlange ein.

1. Lassen Sie alle Standardoptionen ausgewählt und wählen Sie **Create queue (Warteschlange erstellen)**.

## Erstellen einer Zuordnung von Ereignisquellen, um Ihre Lambda-Funktion aufzurufen
<a name="vpc-rds-create-event-source-mapping"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step7.png)


Ein [Zuordnung von Ereignisquellen](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html) ist eine Ressource in Lambda, die Elemente aus einem Stream oder einer Warteschlange liest und eine Lambda-Funktion aufruft. Wenn Sie eine Zuordnung von Ereignisquellen konfigurieren, können Sie eine Batchgröße angeben, sodass Datensätze aus Ihrem Stream oder Ihrer Warteschlange zu einer einzigen Nutzlast zusammengefasst werden. In diesem Beispiel legen Sie die Batchgröße auf 1 fest, sodass Ihre Lambda-Funktion jedes Mal aufgerufen wird, wenn Sie eine Nachricht an Ihre Warteschlange senden. Sie können die Zuordnung der Ereignisquelle entweder mit der AWS CLI oder der Lambda-Konsole konfigurieren.

**So erstellen Sie eine Zuordnung von Ereignisquellen (Konsole)**

1. Öffnen Sie die Seite [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funktionen) der Lambda-Konsole und wählen Sie Ihre Funktion (`LambdaFunctionWithRDS`) aus.

1. Wählen Sie im Abschnitt **Funktionsübersicht** die Option **Auslöser hinzufügen** aus.

1. Wählen Sie als Quelle **Amazon SQS** und dann den Namen Ihrer Warteschlange (`LambdaRDSQueue`) aus.

1. Geben Sie für **Batch size (Stapelgröße)** **1** ein.

1. Belassen Sie alle anderen Optionen auf den Standardwerten und wählen Sie **Add (Hinzufügen)**.

Sie sind jetzt bereit, Ihre vollständige Einrichtung zu testen, indem Sie Ihrer Amazon-SQS-Warteschlange eine Nachricht hinzufügen.

## Testen und Überwachen Ihrer Einrichtung
<a name="vpc-rds-test-setup"></a>

![\[\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/TUT_Lambda_step8.png)


Um Ihre vollständige Einrichtung zu testen, fügen Sie mithilfe der Konsole Nachrichten zu Ihrer Amazon-SQS-Warteschlange hinzu. Anschließend überprüfen Sie mithilfe von CloudWatch Logs, dass Ihre Lambda-Funktion wie erwartet Datensätze in Ihre Datenbank schreibt.

**So testen und überwachen Sie Ihre Einrichtung**

1. Öffnen Sie die Seite [Queues (Warteschlangen)](https://console.aws.amazon.com/sqs/v2/home#/queues) der Amazon-SQS-Konsole und wählen Sie Ihre Warteschlange (`LambdaRDSQueue`) aus.

1. Wählen Sie **Nachrichten senden und empfangen** aus und fügen Sie den folgenden JSON in den **Nachrichtentext** im Abschnitt **Nachricht senden** ein.

   ```
   {
       "CustID": 1054,
       "Name": "Richard Roe"
   }
   ```

1. Klicken Sie auf **Send Message (Nachricht senden)**.

   Wenn Sie Ihre Nachricht an die Warteschlange senden, ruft Lambda Ihre Funktion über Ihre Zuordnung von Ereignisquellen auf. Um zu überprüfen, ob Lambda Ihre Funktion wie erwartet aufgerufen hat, überprüfen Sie mithilfe von CloudWatch Logs, ob die Funktion den Kundennamen und die Kunden-ID in Ihre Datenbanktabelle geschrieben hat.

1. Öffnen Sie die Seite [Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home#logsV2:log-groups) der CloudWatch Konsole und wählen Sie die Protokollgruppe für Ihre Funktion aus ()`/aws/lambda/LambdaFunctionWithRDS`.

1. Wählen Sie im Abschnitt **Protokollstreams** den neuesten Protokollstream aus.

   Ihre Tabelle sollte zwei Kundendatensätze enthalten, einen aus jedem Aufruf Ihrer Funktion. Im Protokollstream werden Ihnen Nachrichten ähnlich der folgenden angezeigt:

   ```
   [INFO] 2023-02-14T19:06:43.873Z 45368126-3eee-47f7-88ca-3086ae6d3a77 The following items have been added to the database:
   [INFO] 2023-02-14T19:06:43.873Z 45368126-3eee-47f7-88ca-3086ae6d3a77 (1021, 'Martha Rivera')
   [INFO] 2023-02-14T19:06:43.873Z 45368126-3eee-47f7-88ca-3086ae6d3a77 (1054, 'Richard Roe')
   ```

## Bereinigen Ihrer Ressourcen
<a name="rds-tutorial-cleanup"></a>

Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Indem Sie AWS Ressourcen löschen, die Sie nicht mehr verwenden, verhindern Sie, dass Ihr AWS Konto unnötig belastet wird.

**So löschen Sie die Lambda-Funktion:**

1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.

1. Wählen Sie die Funktion aus, die Sie erstellt haben.

1. Wählen Sie **Aktionen**, **Löschen** aus.

1. Wählen Sie **Löschen** aus.

**So löschen Sie die Ausführungsrolle**

1. Öffnen Sie die Seite [Roles](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.

1. Wählen Sie die von Ihnen erstellte Ausführungsrolle aus.

1. Wählen Sie **Delete role (Rolle löschen)** aus.

1. Wählen Sie **Yes, delete (Ja, löschen)** aus.

**So löschen Sie die MySQL-DB-Instance**

1. Öffnen Sie die Seite [Datenbanken](https://console.aws.amazon.com//rds/home#databases:) der Amazon-RDS-Konsole.

1. Wählen Sie die von Ihnen erstellte Datenbank aus.

1. Wählen Sie **Aktionen**, **Löschen** aus.

1. Deaktivieren Sie das Kontrollkästchen für **Abschließenden Snapshot erstellen**.

1. Geben Sie **delete me** in das Textfeld ein.

1. Wählen Sie **Löschen** aus.

**So löschen Sie die Amazon-SQS-Warteschlange**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon SQS SQS-Konsole unter [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/).

1. Wählen Sie die Warteschlange aus, die Sie erstellt haben.

1. Wählen Sie **Löschen** aus.

1. Geben Sie **delete** in das Textfeld ein.

1. Wählen Sie **Löschen** aus.