Étape 1 : créer une table DynamoDB avec un flux activé Étape 2 : créer un rôle d'exécution Lambda Étape 3 : créer une rubrique Amazon SNS Étape 4 : créer et tester une fonction Lambda Étape 5 : créer et tester un déclencheur

Tutoriel #1 : Utilisation de filtres pour traiter tous les événements avec Amazon AWS Lambda DynamoDB et utilisation du AWS CLI

Rubriques

Étape 1 : créer une table DynamoDB avec un flux activé
Étape 2 : créer un rôle d'exécution Lambda
Étape 3 : créer une rubrique Amazon SNS
Étape 4 : créer et tester une fonction Lambda
Étape 5 : créer et tester un déclencheur

Dans ce didacticiel, vous allez créer un AWS Lambda déclencheur pour traiter un flux provenant d'une table DynamoDB.

Le scénario de ce didacticiel est Woofer, un réseau social simple. Les utilisateurs de Woofer communiquent avec des aboiements (messages textuels brefs) qui sont envoyés à d'autres utilisateurs de Woofer. Le schéma suivant illustre les composants et le flux de travail de cette application.

Flux de travail d'application Woofer comprenant une table DynamoDB, un enregistrement de flux, une fonction Lambda et une rubrique Amazon SNS.

Un utilisateur écrit un élément dans une table DynamoDB (BarkTable). Chaque élément de la table représente un aboiement.
Un nouvel enregistrement de flux est écrit pour refléter l'ajout de ce nouvel élément à BarkTable.
Le nouvel enregistrement du flux déclenche une AWS Lambda fonction (publishNewBark).
Si le registre de flux indique qu'un nouvel élément a été ajouté à BarkTable, la fonction Lambda lit les données du registre de flux et publie un message sur une rubrique dans Amazon Simple Notification Service (Amazon SNS).
Le message est reçu par les abonnés à la rubrique Amazon SNS. Dans le cadre de ce didacticiel, le seul abonné est une adresse e-mail.

Avant de commencer

Ce didacticiel utilise le AWS Command Line Interface AWS CLI. Si vous ne l'avez déjà fait, suivez les instructions du Guide de l'utilisateur AWS Command Line Interface pour installer et configurer l' AWS CLI.

Étape 1 : créer une table DynamoDB avec un flux activé

Au cours de cette étape, vous allez créer une table DynamoDB (BarkTable) pour stocker tous les aboiements des utilisateurs de Woofer. La clé primaire se compose de Username (clé de partition) et de Timestamp (clé de tri). Les deux attributs sont de type string (chaîne).

BarkTable a un flux activé. Plus loin dans ce didacticiel, vous allez créer un déclencheur en associant une AWS Lambda fonction au flux.

Utilisez la commande suivante pour créer le flux.


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

Dans la sortie, recherchez le LatestStreamArn.
```
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```
Notez region et accountID, car vous en aurez besoin pour les autres étapes de ce didacticiel.

Étape 2 : créer un rôle d'exécution Lambda

Au cours de cette étape, vous créez un rôle AWS Identity and Access Management (IAM) (WooferLambdaRole) et vous lui attribuez des autorisations. Ce rôle sera utilisé par la fonction Lambda que vous allez créer dans Étape 4 : créer et tester une fonction Lambda.

Vous allez également créer une politique pour le rôle. Cette politique contient toutes les autorisations dont la fonction Lambda a besoin lors de l'exécution.

Créez un fichier nommé trust-relationship.json avec les contenus suivants.


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

Entrez la commande suivante pour créer WooferLambdaRole.


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

Créez un fichier nommé role-policy.json avec les contenus suivants. (Remplacez region et accountID par votre AWS région et votre numéro de compte.)


{
    "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": [
                "*"
            ]
        }
    ]
}

La politique comporte quatre instructions pour autoriser WooferLambdaRole à effectuer les opérations suivantes :

Exécutez une fonction Lambda (publishNewBark). Vous allez créer cette fonction plus tard dans le cadre de ce didacticiel.
Accédez à Amazon CloudWatch Logs. La fonction Lambda écrit les diagnostics dans les CloudWatch journaux au moment de l'exécution.
Lisez les données du flux DynamoDB pour BarkTable.
Publiez des messages sur Amazon SNS.

Exécutez la commande suivante pour associer la politique à WooferLambdaRole.


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

Étape 3 : créer une rubrique Amazon SNS

Au cours de cette étape, vous allez créer une rubrique Amazon SNS (wooferTopic) et y abonner une adresse e-mail. Votre fonction Lambda utilise cette rubrique pour publier de nouveaux aboiements des utilisateurs de Woofer.

Entrez la commande suivante pour créer une rubrique Amazon SNS.
```
aws sns create-topic --name wooferTopic
```
Tapez la commande suivante pour abonner une adresse e-mail à wooferTopic. (Remplacez region et accountID par votre région AWS et votre ID de compte, puis remplacez example@example.com par une adresse e-mail valide.)
```
aws sns subscribe \
    --topic-arn arn:aws:sns:region:accountID:wooferTopic \
    --protocol email \
    --notification-endpoint example@example.com
```
Amazon SNS envoie un message de confirmation à votre adresse e-mail. Cliquez sur le lien Confirm subscription (Confirmer l'abonnement) de ce message pour finaliser le processus d'abonnement.

Étape 4 : créer et tester une fonction Lambda

Au cours de cette étape, vous créez une AWS Lambda fonction (publishNewBark) pour traiter les enregistrements de flux à partir deBarkTable.

La fonction publishNewBark traite uniquement les événements de flux qui correspondent aux nouveaux éléments de BarkTable. La fonction lit les données d'un tel événement, puis appelle Amazon SNS pour les publier.

Créez un fichier nommé publishNewBark.js avec les contenus suivants. Remplacez region et accountID par votre AWS région et votre numéro de compte.


'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.`);
};

Créez un fichier zip pour publishNewBark.js. Si vous disposez de l'utilitaire de ligne de commande pour zipper, vous pouvez taper la commande suivante.
```
zip publishNewBark.zip publishNewBark.js
```
Lorsque vous créez la fonction Lambda, vous spécifiez l'Amazon Resource Name (ARN) pour WooferLambdaRole, que vous avez créé dans Étape 2 : créer un rôle d'exécution Lambda. Tapez la commande suivante pour extraire cet ARN.
```
aws iam get-role --role-name WooferLambdaRole
```
Dans la sortie, recherchez l'ARN pour WooferLambdaRole.
```
...
"Arn": "arn:aws:iam::region:role/service-role/WooferLambdaRole"
...
```
Utilisez la commande suivante pour créer la fonction Lambda. Remplacez roleARN par l'ARN de 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
```

Maintenant, testez publishNewBark pour vérifier le bon fonctionnement. Pour cela, vous entrez des informations similaires à un registre réel de DynamoDB Streams.

Créez un fichier nommé payload.json avec les contenus suivants. Remplacez region et accountID par votre Région AWS identifiant de compte.


{
    "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"
        }
    ]
}

Utilisez la commande suivante pour tester la fonction publishNewBark.


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

Si le test est réussi, vous verrez la sortie suivante.


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

De plus, le fichier output.txt contiendra le texte suivant.


"Successfully processed 1 records."

Vous recevrez également un nouveau message électronique quelques minutes après.

Note

AWS Lambda écrit des informations de diagnostic dans Amazon CloudWatch Logs. Si vous rencontrez des erreurs avec la fonction Lambda, vous pouvez utiliser ces diagnostics à des fins de dépannage :

Ouvrez la CloudWatch console à l'adresse https://console.aws.amazon.com/cloudwatch/.
Dans le panneau de navigation, sélectionnez Logs (Journaux).
Choisissez le groupe de journal suivant : /aws/lambda/publishNewBark
Choisissez le dernier flux de journal pour consulter la sortie (et les erreurs) de la fonction.

Étape 5 : créer et tester un déclencheur

Dans Étape 4 : créer et tester une fonction Lambda, vous avez testé la fonction Lambda pour vérifier qu'elle s'exécutait correctement. Au cours de cette étape, vous allez créer un déclencheur en associant la fonction Lambda (publishNewBark) à une source d'événement (le flux BarkTable).

Lorsque vous créez le déclencheur, vous devez spécifier l'ARN du flux BarkTable. Tapez la commande suivante pour extraire cet ARN.
```
aws dynamodb describe-table --table-name BarkTable
```
Dans la sortie, recherchez le LatestStreamArn.
```
...
 "LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```

Tapez la commande suivante pour créer le déclencheur. Remplacez streamARN par l'ARN du flux réel.


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

Testez le déclencheur. Tapez la commande suivante pour ajouter un élément à BarkTable.
```
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"}
```
Vous devriez recevoir un nouveau message électronique quelques minutes après.
Ouvrez la console DynamoDB et ajoutez quelques éléments à BarkTable. Vous devez spécifier les valeurs des attributs Username et Timestamp. Vous devez également spécifier une valeur pour Message, bien que cela ne soit pas obligatoire. Vous devriez recevoir un nouveau message électronique pour chaque élément ajouté à BarkTable.

La fonction Lambda traite uniquement les nouveaux éléments que vous ajoutez à BarkTable. Si vous mettez à jour ou supprimez un élément dans la table, la fonction ne fait rien.

Note

AWS Lambda écrit des informations de diagnostic dans Amazon CloudWatch Logs. Si vous rencontrez des erreurs avec la fonction Lambda, vous pouvez utiliser ces diagnostics à des fins de dépannage.

Ouvrez la CloudWatch console à l'adresse https://console.aws.amazon.com/cloudwatch/.
Dans le panneau de navigation, sélectionnez Logs (Journaux).
Choisissez le groupe de journal suivant : /aws/lambda/publishNewBark
Choisissez le dernier flux de journal pour consulter la sortie (et les erreurs) de la fonction.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Streams et déclencheurs DynamoDB AWS Lambda

Tutoriel n° 2 : Traitement de certains événements