Paso 1: crear una tabla de DynamoDB con un flujo habilitado Paso 2: crear un rol de ejecución para Lambda Paso 3: crear un tema de Amazon SNS Paso 4: crear y probar una función Lambda Paso 5: crear y probar un disparador

Tutorial n.º 1: Uso de filtros para procesar todos los eventos con Amazon DynamoDB y AWS Lambda mediante la AWS CLI

Temas

Paso 1: crear una tabla de DynamoDB con un flujo habilitado
Paso 2: crear un rol de ejecución para Lambda
Paso 3: crear un tema de Amazon SNS
Paso 4: crear y probar una función Lambda
Paso 5: crear y probar un disparador

En este tutorial, creará un desencadenador AWS Lambda para procesar una transmisión de una tabla de DynamoDB.

El escenario en que tiene lugar este tutorial es Woofer, una red social sencilla. Los usuarios de Woofer se comunican utilizando ladridos (mensajes de texto breves) que se envían a otros usuarios de Woofer. En el siguiente diagrama se muestran los componentes y el flujo de trabajo de esta aplicación.

Flujo de trabajo de una aplicación Woofer de una tabla de DynamoDB, un registro de flujo, una función de Lambda y un tema de Amazon SNS.

Un usuario escribe un elemento en una tabla de DynamoDB (BarkTable). Cada elemento de la tabla representa un ladrido.
Se escribe un nuevo registro de secuencia para reflejar que se ha agregado un elemento nuevo a BarkTable.
El nuevo registro de secuencia activa una función de AWS Lambda (publishNewBark).
Si el registro de transmisión indica que se ha agregado un nuevo elemento a BarkTable, la función de Lambda lee los datos del registro de transmisión y publica un mensaje en un tema de Amazon Simple Notification Service (Amazon SNS).
Los suscriptores a ese tema de Amazon SNS reciben el mensaje. En este tutorial, el único suscriptor es una dirección de correo electrónico.

Antes de empezar

En este tutorial se utiliza la AWS Command Line Interface AWS CLI. Si aún no lo ha hecho, siga las instrucciones que figuran en la Guía del usuario de AWS Command Line Interface para instalar y configurar la AWS CLI.

Paso 1: crear una tabla de DynamoDB con un flujo habilitado

En este paso, va a crear una tabla de DynamoDB (BarkTable) para almacenar todos los ladridos de los usuarios de Woofer. La clave principal consta de Username (clave de partición) y Timestamp (clave de ordenación). Ambos atributos son de tipo String.

BarkTable tiene una secuencia habilitada. Más adelante en este tutorial, asociará una función de AWS Lambda a la secuencia para crear un disparador.

Introduzca el siguiente comando para crear la tabla.


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

Busque LatestStreamArn en los resultados.
```
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```
Anote el valor de region y accountID, porque los necesitará para los demás pasos de este tutorial.

Paso 2: crear un rol de ejecución para Lambda

En este paso, va a crear un rol de AWS Identity and Access Management (IAM) (WooferLambdaRole) y a asignarle permisos. El rol lo utilizará la función de Lambda que va a crear en Paso 4: crear y probar una función Lambda.

Asimismo, va a crear una política para el rol. La política contendrá todos los permisos que la función de Lambda va a necesitar en tiempo de ejecución.

Cree un archivo denominado trust-relationship.json con el siguiente contenido.


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

Escriba el siguiente comando para crear WooferLambdaRole.


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

Cree un archivo denominado role-policy.json con el siguiente contenido. (Sustituya region y accountID por su región de AWSy su ID de cuenta).


{
    "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 política tiene cuatro instrucciones que permiten que WooferLambdaRole realice las siguientes acciones:

Ejecute una función Lambda (publishNewBark). Creará la función más adelante en este tutorial.
Acceder a Amazon CloudWatch Logs. La función de Lambda escribe diagnósticos en CloudWatch Logs en tiempo de ejecución.
Leer datos de la transmisión de DynamoDB relativos a BarkTable.
Publicar mensajes en Amazon SNS.

Introduzca el siguiente comando para asociar la política al WooferLambdaRole.


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

Paso 3: crear un tema de Amazon SNS

En este paso, va a crear un tema de Amazon SNS (wooferTopic) y suscribe una dirección de correo electrónico a ese tema. La función de Lambda utiliza este tema para publicar los ladridos nuevos de los usuarios de Woofer.

Ingrese el siguiente comando para crear un nuevo tema de Amazon SNS.
```
aws sns create-topic --name wooferTopic
```
Introduzca el siguiente comando para suscribir una dirección de correo electrónico a wooferTopic. (Sustituya region y accountID por su región de AWS y su ID de cuenta; además, sustituya example@example.com por una dirección de correo electrónico válida).
```
aws sns subscribe \
    --topic-arn arn:aws:sns:region:accountID:wooferTopic \
    --protocol email \
    --notification-endpoint example@example.com
```
Amazon SNS envía un mensaje de confirmación a la dirección de correo electrónico indicada. Elija el enlace Confirm subscription (Confirmar suscripción) del mensaje para completar el proceso de suscripción.

Paso 4: crear y probar una función Lambda

En este paso, va a crear una función de AWS Lambda (publishNewBark) para procesar los registros de secuencia de BarkTable.

La función publishNewBark solamente procesa los eventos de la secuencia que corresponden a elementos nuevos de BarkTable. La función lee los datos de esos eventos y, a continuación, llama a Amazon SNS para publicarlos.

Cree un archivo denominado publishNewBark.js con el siguiente contenido. Sustituya region y accountID por su región de AWS y su ID de cuenta.


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

Cree un archivo zip que contenga publishNewBark.js. Si tiene la utilidad de línea de comandos zip, puede introducir el siguiente comando para hacerlo.
```
zip publishNewBark.zip publishNewBark.js
```
Al crear la función de Lambda, debe especificar el nombre de recurso de Amazon (ARN) de WooferLambdaRole, que creó en Paso 2: crear un rol de ejecución para Lambda. Introduzca el siguiente comando para recuperar este ARN.
```
aws iam get-role --role-name WooferLambdaRole
```
Busque ARN para WooferLambdaRole en los resultados.
```
...
"Arn": "arn:aws:iam::region:role/service-role/WooferLambdaRole"
...
```
Ingrese el siguiente comando para crear la función de Lambda. Sustituya roleARN por el 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
```

Ahora pruebe publishNewBark para comprobar que funciona. Para ello, le facilitamos información de entrada que parece un registro auténtico de DynamoDB Streams.

Cree un archivo denominado payload.json con el siguiente contenido. Sustituya region y accountID por su Región de AWS y su ID de cuenta.


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

Introduzca el siguiente comando para probar la función de publishNewBark.


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

Si la prueba se realiza correctamente, aparecerá el siguiente resultado.


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

Además, el archivo output.txt contendrá el siguiente texto.


"Successfully processed 1 records."

También recibirá un nuevo mensaje de correo electrónico dentro de unos minutos.

nota

AWS Lambda escribe la información de diagnóstico en Amazon CloudWatch Logs. Si se produce cualquier error en la función Lambda, puede utilizar esos diagnósticos para solucionar el problema:

Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.
En el panel de navegación, elija Logs.
Elija el grupo de log siguiente: /aws/lambda/publishNewBark
Elija la última secuencia de log para ver el resultado (y los errores) de la función.

Paso 5: crear y probar un disparador

En Paso 4: crear y probar una función Lambda, hemos probado la función Lambda para asegurarnos de que se ejecutaba correctamente. En este paso, va a crear un disparador. Para ello, asociará la función de Lambda (publishNewBark) con el origen de eventos (la secuencia BarkTable).

Al crear el disparador, debe especificar el ARN de la secuencia de BarkTable. Introduzca el siguiente comando para recuperar este ARN.
```
aws dynamodb describe-table --table-name BarkTable
```
Busque LatestStreamArn en los resultados.
```
...
 "LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```

Introduzca el siguiente comando para crear el disparador. Sustituya streamARN por el ARN de la secuencia real.


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

Prueba el disparador. Introduzca el siguiente comando para agregar 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"}
```
Debería recibir un nuevo mensaje de correo electrónico dentro de unos minutos.
Abra la consola de DynamoDB y agregue algunos elementos más a BarkTable. Debe especificar valores para los atributos Username y Timestamp. También debe especificar un valor para Message, aunque no es obligatorio. Debe recibir un nuevo mensaje de correo electrónico por cada elemento que agregue a BarkTable.

La función de Lambda procesa solamente los elementos nuevos que se agregan a BarkTable. Si actualiza o elimina un elemento de la tabla, la función no hace nada.

nota

AWS Lambda escribe la información de diagnóstico en Amazon CloudWatch Logs. Si se produce cualquier error en la función Lambda, puede utilizar esos diagnósticos para solucionar el problema.

Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.
En el panel de navegación, elija Logs.
Elija el grupo de log siguiente: /aws/lambda/publishNewBark
Elija la última secuencia de log para ver el resultado (y los errores) de la función.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

DynamoDB Streams y disparadores de AWS Lambda

Tutorial n.º 2: Procesamiento de algunos eventos