Tutorial #1: Utilizzo dei filtri per elaborare tutti gli eventi con Amazon DynamoDB e utilizzo di AWS LambdaAWS CLI

Immetti il seguente comando per creare la tabella.

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

Nell'output, cerca LatestStreamArn.

...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...

Prendi nota dei valori region e accountID, in quanto sono necessari nelle altre fasi di questo tutorial.

Crea un file denominato trust-relationship.json con i seguenti contenuti.

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

Immetti il seguente comando per creare WooferLambdaRole.

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

Crea un file denominato role-policy.json con i seguenti contenuti. (Sostituisci region e inserisci accountID la tua AWS regione e l'ID dell'account.)

{
    "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 policy include quattro dichiarazioni che consentono a WooferLambdaRole di eseguire le seguenti operazioni:

Immetti il seguente comando per collegare la policy a WooferLambdaRole.

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

Inserisci il seguente comando per creare un nuovo SNS argomento Amazon.

aws sns create-topic --name wooferTopic

Immetti il comando seguente per sottoscrivere un indirizzo e-mail a wooferTopic. Sostituisci region e accountID con la regione e l'ID account AWS e sostituisci example@example.com con un indirizzo e-mail valido.

aws sns subscribe \
    --topic-arn arn:aws:sns:region:accountID:wooferTopic \
    --protocol email \
    --notification-endpoint example@example.com

Amazon SNS invia un messaggio di conferma al tuo indirizzo e-mail. Scegli il link Confirm subscription (Conferma sottoscrizione) per completare la procedura di sottoscrizione.

Crea un file denominato publishNewBark.js con i seguenti contenuti. Sostituisci region e accountID con la tua AWS regione e l'ID dell'account.

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

Crea un file zip che contenga publishNewBark.js. Per fare ciò, se disponi di una utility a riga di comando zip, puoi immettere il comando seguente.

zip publishNewBark.zip publishNewBark.js

Quando crei la funzione Lambda, specifichi il nome Amazon Resource Name (ARN) per WooferLambdaRole il quale hai creato. Fase 2: creazione di un ruolo di esecuzione Lambda Inserisci il seguente comando per recuperarlo. ARN

aws iam get-role --role-name WooferLambdaRole

Nell'output, cerca il ARN perWooferLambdaRole.

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

Immetti il seguente comando per creare la funzione Lambda. Replace (Sostituisci) roleARN con il ARN perWooferLambdaRole.

aws lambda create-function \
    --region region \
    --function-name publishNewBark \
    --zip-file fileb://publishNewBark.zip \
    --role roleARN \
    --handler publishNewBark.handler \
    --timeout 5 \
    --runtime nodejs16.x

Ora esegui il test di publishNewBark per verificare che funziona. Per fare ciò, fornire un input simile a un record reale da DynamoDB Streams.

Crea un file denominato payload.json con i seguenti contenuti. Sostituisci region e accountID con il tuo ID Regione AWS e quello dell'account.

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

Immetti il comando seguente per eseguire il test della funzione publishNewBark.

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

Se il test viene superato, viene visualizzato il seguente output.

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

Inoltre, il file output.txt conterrà il testo seguente.

"Successfully processed 1 records."

Entro pochi minuti riceverai anche un nuovo messaggio e-mail.

Quando crei il trigger, devi specificare il valore ARN per lo BarkTable stream. Immettete il seguente comando per recuperarloARN.

aws dynamodb describe-table --table-name BarkTable

Nell'output, cerca LatestStreamArn.

...
 "LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...

Immetti il comando seguente per creare il trigger. Sostituisci streamARN con lo stream ARN attuale.

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

Esegui il test del trigger. Immetti il comando seguente per aggiungere un elemento a 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"}

Dovresti ricevere un nuovo messaggio e-mail entro pochi minuti.

Aprire la console DynamoDB e aggiungere altri elementi a BarkTable. È necessario specificare i valori degli attributi Username e Timestamp. (Sebbene non sia obbligatorio, si dovrebbe inoltre specificare un valore per Message) Dovresti ricevere un nuovo messaggio e-mail per ogni item aggiunto a BarkTable.

La funzione Lambda elabora solo i nuovi elementi aggiunti a BarkTable. Se aggiorni o elimini un item della tabella, la funzione non esegue alcuna azione.