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

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.

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 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

Entrez la commande suivante pour créer un nouveau SNS sujet Amazon.

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.

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 le nom de ressource Amazon (ARN) pour WooferLambdaRole lequel vous l'avez créée. Étape 2 : créer un rôle d'exécution Lambda Entrez la commande suivante pour le récupérerARN.

aws iam get-role --role-name WooferLambdaRole

Dans le résultat, recherchez le ARN pourWooferLambdaRole.

...
"Arn": "arn:aws:iam::region:role/service-role/WooferLambdaRole"
...

Utilisez la commande suivante pour créer la fonction Lambda. Remplacez roleARN avec la ARN fourcheWooferLambdaRole.

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.

Lorsque vous créez le déclencheur, vous devez spécifier le déclencheur ARN pour le BarkTable flux. Entrez la commande suivante pour le récupérerARN.

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. streamARNRemplacez-le par le flux réelARN.

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.