Schritt 1: Erstellen einer DynamoDB-Tabelle mit einem aktivierten Stream Schritt 2: Erstellen einer Lambda-Ausführungsrolle Schritt 3: Erstellen eines Amazon-SNS-Themas Schritt 4: Erstellen und Testen einer Lambda-Funktion Schritt 5: Erstellen und Testen eines Auslösers

Tutorial #1: Verwenden von Filtern zur Verarbeitung aller Ereignisse mit Amazon DynamoDB und AWS Lambda Verwendung der AWS CLI

Themen

Schritt 1: Erstellen einer DynamoDB-Tabelle mit einem aktivierten Stream
Schritt 2: Erstellen einer Lambda-Ausführungsrolle
Schritt 3: Erstellen eines Amazon-SNS-Themas
Schritt 4: Erstellen und Testen einer Lambda-Funktion
Schritt 5: Erstellen und Testen eines Auslösers

In diesem Tutorial erstellen Sie einen AWS Lambda Trigger, um einen Stream aus einer DynamoDB-Tabelle zu verarbeiten.

Das Szenario für dieses Tutorial ist Woofer, ein einfaches soziales Netzwerk. Woofer-Benutzer kommunizieren mit einer kurzen Textnachricht Barks („Bellen”), die an andere Woofer-Benutzer gesendet werden. Das folgende Diagramm zeigt die Komponenten und den Workflow für diese Anwendung.

Woofer-Anwendungsworkflow mit einer DynamoDB-Tabelle, einem Stream-Datensatz, einer Lambda-Funktion und einem Amazon SNS SNS-Thema.

Ein Benutzer schreibt ein Element in eine DynamoDB-Tabelle (BarkTable). Jedes Element in der Tabelle steht für eine Textnachricht („Bark”).
Ein neuer Stream-Datensatz wird erstellt, um zu berücksichtigen, dass ein neues Element der BarkTable hinzugefügt wurde.
Der neue Stream-Datensatz löst eine AWS Lambda Funktion aus (). publishNewBark
Wenn der Stream-Datensatz angibt, dass ein neues Element BarkTable hinzugefügt wurde, liest die Lambda-Funktion die Daten aus dem Stream-Datensatz und veröffentlicht eine Nachricht für ein Thema im Amazon Simple Notification Service (Amazon SNS).
Die Nachricht wird von den Abonnenten des Amazon-SNS-Themas empfangen. (In diesem Tutorial ist der einzige Abonnent eine E-Mail-Adresse.)

Bevor Sie beginnen

Dieses Tutorial verwendet die AWS Command Line Interface AWS CLI. Folgen Sie den Anweisungen im AWS Command Line Interface -Benutzerhandbuch zum Installieren und Konfigurieren der AWS CLI.

Schritt 1: Erstellen einer DynamoDB-Tabelle mit einem aktivierten Stream

In diesem Schritt erstellen Sie eine DynamoDB-Tabelle (BarkTable), um alle Textnachrichten von Woofer-Benutzern zu speichern. Der Primärschlüssel besteht aus Username (Partitionsschlüssel) und Timestamp (Sortierschlüssel). Bei beiden Attributen handelt es sich um Zeichenfolgen.

Für BarkTable ist ein Stream aktiviert. Später in diesem Tutorial erstellen Sie einen Trigger, indem Sie dem Stream eine AWS Lambda Funktion zuordnen.

Verwenden Sie den folgenden Befehl, um die Tabelle zu erstellen.


aws dynamodb create-table \
    --table-name BarkTable \
    --attribute-definitions AttributeName=Username,AttributeType=S AttributeName=Timestamp,AttributeType=S \
    --key-schema AttributeName=Username,KeyType=HASH  AttributeName=Timestamp,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
    --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES

Suchen Sie in der Ausgabe nach dem LatestStreamArn.
```
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```
Notieren Sie sich die region und die accountID, da Sie sie für die anderen Schritte in diesem Tutorial benötigen.

Schritt 2: Erstellen einer Lambda-Ausführungsrolle

In diesem Schritt erstellen Sie eine AWS Identity and Access Management (IAM-) Rolle (WooferLambdaRole) und weisen ihr Berechtigungen zu. Diese Rolle wird von der Lambda-Funktion verwendet, die Sie in Schritt 4: Erstellen und Testen einer Lambda-Funktion erstellen.

Außerdem legen Sie eine Richtlinie für die Rolle fest. Die Richtlinie enthält alle Berechtigungen, die die Lambda-Funktion zur Laufzeit benötigt.

Erstellen Sie eine Datei mit dem Namen trust-relationship.json und dem folgenden Inhalt.


{
   "Version": "2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Principal": {
         "Service": "lambda.amazonaws.com"
       },
       "Action": "sts:AssumeRole"
     }
   ]
 }

Geben Sie den folgenden Befehl ein, um WooferLambdaRole zu erstellen.


aws iam create-role --role-name WooferLambdaRole \
    --path "/service-role/" \
    --assume-role-policy-document file://trust-relationship.json

Erstellen Sie eine Datei mit dem Namen role-policy.json und dem folgenden Inhalt. (Ersetzen Sie region und accountID durch Ihre AWS Region und Konto-ID.)


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:region:accountID:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:DescribeStream",
                "dynamodb:GetRecords",
                "dynamodb:GetShardIterator",
                "dynamodb:ListStreams"
            ],
            "Resource": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "sns:Publish"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}

Die Richtlinie enthält vier Anweisungen, damit WooferLambdaRole folgende Aufgaben ausführen kann:

Führen Sie eine Lambda-Funktion (publishNewBark). Die Funktion erstellen Sie zu einem späteren Zeitpunkt in diesem Tutorial.
Greifen Sie auf Amazon CloudWatch Logs zu. Die Lambda-Funktion schreibt zur Laufzeit Diagnosen in CloudWatch Logs.
Lesen von Daten aus dem DynamoDB Stream für BarkTable.
Veröffentlichen Sie Nachrichten in Amazon SNS.

Führen Sie den folgenden Befehl aus, um die Richtlinie WooferLambdaRole anzufügen:


aws iam put-role-policy --role-name WooferLambdaRole \
    --policy-name WooferLambdaRolePolicy \
    --policy-document file://role-policy.json

Schritt 3: Erstellen eines Amazon-SNS-Themas

In diesem Schritt erstellen Sie ein Amazon-SNS-Thema (wooferTopic) und abonnieren es für eine E-Mail-Adresse. Ihre Lambda-Funktion verwendet dieses Thema zum Veröffentlichen neuer Barks von Woofer-Benutzern.

Geben Sie den folgenden Befehl ein, um ein neues Amazon-SNS-Thema zu erstellen.
```
aws sns create-topic --name wooferTopic
```
Geben Sie den folgenden Befehl ein, um wooferTopic für eine E-Mail-Adresse zu abonnieren. (Ersetzen Sie region bzw. accountID durch Ihre AWS -Region bzw. die Konto-ID und example@example.com durch eine gültige E-Mail-Adresse.)
```
aws sns subscribe \
    --topic-arn arn:aws:sns:region:accountID:wooferTopic \
    --protocol email \
    --notification-endpoint example@example.com
```
Amazon SNS sendet eine Bestätigungsnachricht an Ihre E-Mail-Adresse. Klicken Sie auf den Link Confirm subscription (Abonnement bestätigen) in dieser E-Mail, um Ihr Abonnement abzuschließen.

Schritt 4: Erstellen und Testen einer Lambda-Funktion

In diesem Schritt erstellen Sie eine AWS Lambda Funktion (publishNewBark) zur Verarbeitung von BarkTable Stream-Datensätzen.

Die publishNewBark-Funktion verarbeitet nur die Stream-Ereignisse, die neuen Elementen in BarkTable entsprechen. Die Funktion liest Daten eines entsprechenden Ereignisses und ruft Amazon SNS auf, um es zu veröffentlichen.

Erstellen Sie eine Datei mit dem Namen publishNewBark.js und dem folgenden Inhalt. Ersetzen Sie region und accountID durch Ihre AWS Region und Konto-ID.


'use strict';
var AWS = require("aws-sdk");
var sns = new AWS.SNS();

exports.handler = (event, context, callback) => {

    event.Records.forEach((record) => {
        console.log('Stream record: ', JSON.stringify(record, null, 2));

        if (record.eventName == 'INSERT') {
            var who = JSON.stringify(record.dynamodb.NewImage.Username.S);
            var when = JSON.stringify(record.dynamodb.NewImage.Timestamp.S);
            var what = JSON.stringify(record.dynamodb.NewImage.Message.S);
            var params = {
                Subject: 'A new bark from ' + who,
                Message: 'Woofer user ' + who + ' barked the following at ' + when + ':\n\n ' + what,
                TopicArn: 'arn:aws:sns:region:accountID:wooferTopic'
            };
            sns.publish(params, function(err, data) {
                if (err) {
                    console.error("Unable to send message. Error JSON:", JSON.stringify(err, null, 2));
                } else {
                    console.log("Results from sending message: ", JSON.stringify(data, null, 2));
                }
            });
        }
    });
    callback(null, `Successfully processed ${event.Records.length} records.`);
};

Erstellen Sie eine ZIP-Datei mit publishNewBark.js. Wenn Sie das ZIP-Befehlszeilen-Dienstprogramm verwenden, geben Sie dazu den folgenden Befehl ein.
```
zip publishNewBark.zip publishNewBark.js
```
Beim Erstellen der Lambda-Funktion geben Sie den Amazon-Ressourcennamen (ARN) für WooferLambdaRole an, den Sie in Schritt 2: Erstellen einer Lambda-Ausführungsrolle erstellt haben. Geben Sie den folgenden Befehl ein, um diesen ARN abzurufen.
```
aws iam get-role --role-name WooferLambdaRole
```
Suchen Sie in der Ausgabe nach dem ARN für WooferLambdaRole.
```
...
"Arn": "arn:aws:iam::region:role/service-role/WooferLambdaRole"
...
```
Verwenden Sie den folgenden Befehl, um die Lambda-Funktion zu erstellen. Ersetzen Sie roleARN durch den ARN für WooferLambdaRole.
```
aws lambda create-function \
    --region region \
    --function-name publishNewBark \
    --zip-file fileb://publishNewBark.zip \
    --role roleARN \
    --handler publishNewBark.handler \
    --timeout 5 \
    --runtime nodejs16.x
```

Testen Sie die publishNewBark-Funktion. Stellen Sie dazu eine Eingabe bereit, die einem echten Datensatz aus DynamoDB Streams ähnelt.

Erstellen Sie eine Datei mit dem Namen payload.json und dem folgenden Inhalt. Ersetzen Sie region und accountID durch Ihre AWS-Region Konto-ID.


{
    "Records": [
        {
            "eventID": "7de3041dd709b024af6f29e4fa13d34c",
            "eventName": "INSERT",
            "eventVersion": "1.1",
            "eventSource": "aws:dynamodb",
            "awsRegion": "region",
            "dynamodb": {
                "ApproximateCreationDateTime": 1479499740,
                "Keys": {
                    "Timestamp": {
                        "S": "2016-11-18:12:09:36"
                    },
                    "Username": {
                        "S": "John Doe"
                    }
                },
                "NewImage": {
                    "Timestamp": {
                        "S": "2016-11-18:12:09:36"
                    },
                    "Message": {
                        "S": "This is a bark from the Woofer social network"
                    },
                    "Username": {
                        "S": "John Doe"
                    }
                },
                "SequenceNumber": "13021600000000001596893679",
                "SizeBytes": 112,
                "StreamViewType": "NEW_IMAGE"
            },
            "eventSourceARN": "arn:aws:dynamodb:region:account ID:table/BarkTable/stream/2016-11-16T20:42:48.104"
        }
    ]
}

Verwenden Sie den folgenden Befehl, um die publishNewBark-Funktion zu erstellen.


aws lambda invoke --function-name publishNewBark --payload file://payload.json --cli-binary-format raw-in-base64-out output.txt

Wenn der Test erfolgreich war, sehen Sie die folgende Ausgabe.


{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}

Darüber hinaus enthält die output.txt-Datei folgenden Text.


"Successfully processed 1 records."

Außerdem erhalten Sie in wenigen Minuten eine neue E-Mail-Nachricht.

Anmerkung

AWS Lambda schreibt Diagnoseinformationen in Amazon CloudWatch Logs. Wenn Fehler mit Ihrer Lambda-Funktion auftreten, können Sie folgende Diagnoseverfahren zur Fehlerbehebung verwenden:

Öffnen Sie die CloudWatch Konsole unter https://console.aws.amazon.com/cloudwatch/.
Wählen Sie im Navigationsbereich Logs (Logs) aus.
Wählen Sie die folgende Protokollgruppe aus: /aws/lambda/publishNewBark
Wählen Sie den aktuellen Protokoll-Stream aus, um die Ausgabe (und Fehler) der Funktion zu sehen.

Schritt 5: Erstellen und Testen eines Auslösers

In Schritt 4: Erstellen und Testen einer Lambda-Funktion haben Sie die Lambda-Funktion getestet, um sicherzustellen, dass sie korrekt ausgeführt wird. In diesem Schritt erstellen Sie einen Auslöser, indem Sie die Lambda-Funktion (publishNewBark) mit einer Ereignisquelle (dem BarkTable-Stream) verknüpfen.

Wenn Sie den Auslöser erstellen, müssen Sie den ARN für den BarkTable-Stream angeben. Geben Sie den folgenden Befehl ein, um diesen ARN abzurufen.
```
aws dynamodb describe-table --table-name BarkTable
```
Suchen Sie in der Ausgabe nach dem LatestStreamArn.
```
...
 "LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```

Geben Sie den folgenden Befehl ein, um den Auslöser zu erstellen. Ersetzen Sie streamARN durch den tatsächlichen Stream-ARN.


aws lambda create-event-source-mapping \
    --region region \
    --function-name publishNewBark \
    --event-source streamARN  \
    --batch-size 1 \
    --starting-position TRIM_HORIZON

Testen Sie den Auslöser. Geben Sie dazu den folgenden Befehl ein, um BarkTable ein Element hinzuzufügen.
```
aws dynamodb put-item \
    --table-name BarkTable \
    --item Username={S="Jane Doe"},Timestamp={S="2016-11-18:14:32:17"},Message={S="Testing...1...2...3"}
```
Sie erhalten in wenigen Minuten eine neue E-Mail-Nachricht.
Öffnen Sie die DynamoDB-Konsole und fügen Sie BarkTable weitere Elemente hinzu. Sie müssen Werte für die Attribute Username und Timestamp angeben. (Sie sollten auch einen Wert für Message angeben, auch wenn er nicht erforderlich ist.) Sie erhalten eine neue E-Mail-Nachricht für jedes Element, das Sie BarkTable hinzufügen.

Die Lambda-Funktion verarbeitet nur neue Elemente, die Sie BarkTable hinzufügen. Wenn Sie ein Element in der Tabelle aktualisieren oder löschen, hat die Funktion keine Auswirkung.

Anmerkung

AWS Lambda schreibt Diagnoseinformationen in Amazon CloudWatch Logs. Wenn Fehler mit Ihrer Lambda-Funktion auftreten, können Sie folgende Diagnoseverfahren zur Fehlerbehebung verwenden.

Öffnen Sie die CloudWatch Konsole unter https://console.aws.amazon.com/cloudwatch/.
Wählen Sie im Navigationsbereich Logs (Logs) aus.
Wählen Sie die folgende Protokollgruppe aus: /aws/lambda/publishNewBark
Wählen Sie den aktuellen Protokoll-Stream aus, um die Ausgabe (und Fehler) der Funktion zu sehen.

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

DynamoDB Streams und -Trigger AWS Lambda

Tutorial 2: Verarbeiten einiger Ereignisse