# Tutorial n.º 1: Uso de filtros para procesar todos los eventos con Amazon DynamoDB y AWS Lambda mediante la AWS CLI
En este tutorial, creará un desencadenador AWS Lambda para procesar una transmisión de una tabla de DynamoDB.
**Topics**
+ [Paso 1: crear una tabla de DynamoDB con un flujo habilitado](#Streams.Lambda.Tutorial.CreateTable)
+ [Paso 2: crear un rol de ejecución para Lambda](#Streams.Lambda.Tutorial.CreateRole)
+ [Paso 3: crear un tema de Amazon SNS](#Streams.Lambda.Tutorial.SNSTopic)
+ [Paso 4: crear y probar una función Lambda](#Streams.Lambda.Tutorial.LambdaFunction)
+ [Paso 5: crear y probar un disparador](#Streams.Lambda.Tutorial.CreateTrigger)
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.\]](http://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/images/StreamsAndTriggers.png)
1. Un usuario escribe un elemento en una tabla de DynamoDB (`BarkTable`). Cada elemento de la tabla representa un ladrido.
1. Se escribe un nuevo registro de secuencia para reflejar que se ha agregado un elemento nuevo a `BarkTable`.
1. El nuevo registro de secuencia activa una función de AWS Lambda (`publishNewBark`).
1. 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).
1. 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](https://docs.aws.amazon.com/cli/latest/userguide/) 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.
1. 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
```
1. Busque en los resultados `LatestStreamArn`.
```
...
"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](#Streams.Lambda.Tutorial.LambdaFunction).
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.
1. Cree un archivo denominado `trust-relationship.json` con el siguiente contenido.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. 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
```
1. 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).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:us-east-1:111122223333:*"
},
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator",
"dynamodb:ListStreams"
],
"Resource": "arn:aws:dynamodb:us-east-1:111122223333: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.
1. 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.
1. Ingrese el siguiente comando para crear un nuevo tema de Amazon SNS.
```
aws sns create-topic --name wooferTopic
```
1. 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
```
1. 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.
1. 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.`);
};
```
1. 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
```
1. 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](#Streams.Lambda.Tutorial.CreateRole). Introduzca el siguiente comando para recuperar este ARN.
```
aws iam get-role --role-name WooferLambdaRole
```
Busque ARN para en los resultados `WooferLambdaRole`.
```
...
"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
```
1. 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/](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](#Streams.Lambda.Tutorial.LambdaFunction), 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`).
1. 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 en los resultados `LatestStreamArn`.
```
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```
1. 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
```
1. 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.
1. 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/](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.