Fase 1: creazione di una tabella DynamoDB con un flusso abilitato Fase 2: creazione di un ruolo di esecuzione Lambda Fase 3: creazione di un argomento Amazon SNS Fase 4: creazione e test di una funzione Lambda Fase 5: creazione e test di un trigger

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

Argomenti

Fase 1: creazione di una tabella DynamoDB con un flusso abilitato
Fase 2: creazione di un ruolo di esecuzione Lambda
Fase 3: creazione di un argomento Amazon SNS
Fase 4: creazione e test di una funzione Lambda
Fase 5: creazione e test di un trigger

In questo tutorial, creerai un AWS Lambda trigger per elaborare un flusso da una tabella DynamoDB.

Lo scenario di questo tutorial è Woofer, un semplice social network. Gli utenti di Woofer comunicano tramite i bark, brevi messaggi di testo che vengono inviati ad altri utenti di Woofer. Il seguente diagramma illustra i componenti e il flusso di lavoro di questa applicazione.

Flusso di lavoro dell'applicazione Woofer di una tabella DynamoDB, stream record, funzione Lambda e argomento Amazon SNS.

Un utente scrive un elemento in una tabella DynamoDB (BarkTable). Ogni item della tabella rappresenta un bark.
Viene scritto un nuovo record di flusso per riflettere l'aggiunta di un nuovo item a BarkTable.
Il nuovo stream record attiva una funzione (). AWS Lambda publishNewBark
Se il record di flusso indica che è stato aggiunto un nuovo elemento a BarkTable, la funzione Lambda legge i dati dal record di flusso e pubblica un messaggio in un argomento di Amazon Simple Notification Service (Amazon SNS).
Questo messaggio è ricevuto dai sottoscrittori dell'argomento Amazon SNS. (In questo tutorial, l'unico sottoscrittore è un indirizzo e-mail).

Prima di iniziare

Questo tutorial utilizza il. AWS Command Line Interface AWS CLI Se non è stato ancora fatto, seguire le istruzioni contenute nella Guida per l'utente di AWS Command Line Interface per installare e configurare la AWS CLI.

Fase 1: creazione di una tabella DynamoDB con un flusso abilitato

In questa fase, viene creata crea una tabella DynamoDB (BarkTable) per memorizzare tutti i bark degli utenti di Woofer. La chiave primaria è costituita da Username (chiave di partizione) e Timestamp (chiave di ordinamento). Entrambi questi attributi sono di tipo stringa.

In BarkTable è abilitato un flusso. Più avanti in questo tutorial, crei un trigger associando una AWS Lambda funzione allo stream.

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.

Fase 2: creazione di un ruolo di esecuzione Lambda

In questo passaggio, crei un ruolo AWS Identity and Access Management (IAM) (WooferLambdaRole) e gli assegni le autorizzazioni. Questo ruolo viene utilizzato dalla funzione Lambda creata in Fase 4: creazione e test di una funzione Lambda.

Puoi creare anche una policy per il ruolo. La policy conterrà tutte le autorizzazioni necessarie alla funzione Lambda nella fase di runtime.

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:

Eseguire una funzione Lambda (publishNewBark). Questa funzione viene creata in una fase successiva di questo tutorial.
Accedi ad Amazon CloudWatch Logs. La funzione Lambda scrive la diagnostica nei CloudWatch registri in fase di esecuzione.
Leggere i dati dal flusso di DynamoDB per BarkTable.
Pubblicare i messaggi su Amazon SNS.

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

Fase 3: creazione di un argomento Amazon SNS

In questa fase, viene creato un argomento Amazon SNS (wooferTopic) e viene registrato un indirizzo e-mail su di esso. La funzione Lambda utilizza questo argomento per pubblicare nuovi bark degli utenti di Woofer.

Immettere il seguente comando per creare un nuovo argomento Amazon SNS.
```
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.

Fase 4: creazione e test di una funzione Lambda

In questo passaggio, crei una AWS Lambda funzione (publishNewBark) da cui elaborare i record di flusso. BarkTable

La funzione publishNewBark elabora solo gli eventi di flusso che corrispondono a nuovi item in BarkTable. La funzione legge i dati di questo evento, quindi richiama Amazon SNS perché li pubblichi.

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 si crea la funzione Lambda, si specifica l'Amazon Resource Name (ARN) per WooferLambdaRole che hai creato in Fase 2: creazione di un ruolo di esecuzione Lambda. Immetti il comando seguente per recuperare questo ARN.
```
aws iam get-role --role-name WooferLambdaRole
```
Nell'output, cerca l'ARN di WooferLambdaRole.
```
...
"Arn": "arn:aws:iam::region:role/service-role/WooferLambdaRole"
...
```
Immetti il seguente comando per creare la funzione Lambda. Sostituisci roleARN con l'ARN di 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
```

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.

Nota

AWS Lambda scrive informazioni diagnostiche su Amazon CloudWatch Logs. Se si verificano errori nella funzione Lambda, è possibile utilizzare queste informazioni diagnostiche per la risoluzione dei problemi:

Apri la CloudWatch console all'indirizzo https://console.aws.amazon.com/cloudwatch/.
Nel riquadro di navigazione scegli Logs (Log).
Scegli il seguente gruppo di log: /aws/lambda/publishNewBark
Scegli il flusso di log più recente per visualizzare l'output e gli errori della funzione.

Fase 5: creazione e test di un trigger

In Fase 4: creazione e test di una funzione Lambda, è stato eseguito il test della funzione Lambda per verificarne la corretta esecuzione. In questa fase, è possibile creare un trigger associando la funzione Lambda (publishNewBark) a un'origine eventi (il flusso BarkTable).

Quando crei il trigger, è necessario specificare l'ARN del flusso BarkTable. Immetti il comando seguente per recuperare questo ARN.
```
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 l'ARN del flusso effettivo.


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.

Nota

Apri la CloudWatch console all'indirizzo https://console.aws.amazon.com/cloudwatch/.
Nel riquadro di navigazione scegli Logs (Log).
Scegli il seguente gruppo di log: /aws/lambda/publishNewBark
Scegli il flusso di log più recente per visualizzare l'output e gli errori della funzione.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Streams e trigger DynamoDB AWS Lambda

Tutorial n. 2: Elaborazione di alcuni eventi