# Tutorial 1: Usar filtros para processar todos os eventos com o Amazon DynamoDB e o AWS Lambda usando a AWS CLI
Neste tutorial, você cria um acionador do AWS Lambda para processar um fluxo de uma tabela do DynamoDB.
**Topics**
+ [Etapa 1: criar uma tabela do DynamoDB com um fluxo habilitado](#Streams.Lambda.Tutorial.CreateTable)
+ [Etapa 2: criar uma função de execução do Lambda](#Streams.Lambda.Tutorial.CreateRole)
+ [Etapa 3: criar um tópico do Amazon SNS](#Streams.Lambda.Tutorial.SNSTopic)
+ [Etapa 4: criar e testar uma função do Lambda](#Streams.Lambda.Tutorial.LambdaFunction)
+ [Etapa 5: criar e testar um acionador](#Streams.Lambda.Tutorial.CreateTrigger)
O cenário deste tutorial é o Woofer, uma rede social simples. Os usuários do Woofer se comunicam usando *barks* (mensagens de texto curtas) que são enviados a outros usuários do Woofer. O diagrama a seguir mostra os componentes e o fluxo de trabalho desse aplicativo.
![\[Fluxo de trabalho da aplicação Woofer de uma tabela do DynamoDB, registro de fluxos, função do Lambda e tópico do Amazon SNS.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/StreamsAndTriggers.png)
1. Um usuário grava um item em uma tabela do DynamoDB (`BarkTable`). Cada item na tabela representa um bark.
1. Um novo registro de fluxo é gravado para refletir que um novo item foi adicionado à `BarkTable`.
1. O novo registro de fluxo aciona uma função do AWS Lambda (`publishNewBark`).
1. Se o registro de fluxo indicar que um novo item foi adicionado à `BarkTable`, a função do Lambda lerá os dados do registro de fluxo e publicará uma mensagem em um tópico no Amazon Simple Notification Service (Amazon SNS).
1. A mensagem é recebida pelos assinantes do tópico do Amazon SNS. (Neste tutorial, o único assinante é um endereço de e-mail.)
**Antes de começar**
Este tutorial usa a AWS Command Line Interface AWS CLI. Se você ainda não tiver feito isso, siga as instruções de instalação no [Guia do usuário do AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/) para instalar e configurar a AWS CLI.
## Etapa 1: criar uma tabela do DynamoDB com um fluxo habilitado
Nesta etapa, você cria uma tabela do DynamoDB (`BarkTable`) para armazenar todos os barks dos usuários do Woofer. A chave primária é composta de `Username` (chave de partição) e de `Timestamp` (chave de classificação). Ambos os atributos são do tipo string.
`BarkTable` tem um fluxo habilitado. Mais adiante neste tutorial, você criará um acionador associando uma função do AWS Lambda ao fluxo.
1. Use o seguinte comando para criar a tabela.
```
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. Na saída, procure o `LatestStreamArn`.
```
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```
Anote a `region` e o `accountID`, pois eles serão necessários para as outras etapas deste tutorial.
## Etapa 2: criar uma função de execução do Lambda
Nesta etapa, você cria uma função do AWS Identity and Access Management (IAM) (`WooferLambdaRole`) e atribui permissões a ela. Essa função será usada pela função do Lambda que você cria em [Etapa 4: criar e testar uma função do Lambda](#Streams.Lambda.Tutorial.LambdaFunction).
Você também cria uma política para a função. A política contém todas as permissões de que a função do Lambda precisa em tempo de execução.
1. Crie um arquivo denominado `trust-relationship.json` com os conteúdos a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Insira o seguinte comando para criar a `WooferLambdaRole`.
```
aws iam create-role --role-name WooferLambdaRole \
--path "/service-role/" \
--assume-role-policy-document file://trust-relationship.json
```
1. Crie um arquivo denominado `role-policy.json` com os conteúdos a seguir. (Substitua `region` e `accountID` por sua região e seu ID de conta da AWS.)
------
#### [ 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": [
"*"
]
}
]
}
```
------
A política tem quatro declarações que fornecem permissões à `WooferLambdaRole` para fazer o seguinte:
+ Execute uma função do Lambda (`publishNewBark`). Você cria a função mais adiante neste tutorial.
+ Acesse o Amazon CloudWatch Logs. A função do Lambda grava o diagnóstico no CloudWatch Logs em tempo de execução.
+ Leia os dados do fluxo do DynamoDB para `BarkTable`.
+ Publique mensagens no Amazon SNS.
1. Execute o seguinte comando para anexar a política à função `WooferLambdaRole`.
```
aws iam put-role-policy --role-name WooferLambdaRole \
--policy-name WooferLambdaRolePolicy \
--policy-document file://role-policy.json
```
## Etapa 3: criar um tópico do Amazon SNS
Nesta etapa, você cria um tópico do Amazon SNS (`wooferTopic`) e inscreve um endereço de e-mail nele. A função do Lambda usa esse tópico para publicar novos barks de usuários do Woofer.
1. Digite o seguinte comando para criar um novo tópico do Amazon SNS.
```
aws sns create-topic --name wooferTopic
```
1. Digite o seguinte comando para inscrever um endereço de e-mail no `wooferTopic`. (Substitua `region` e `accountID` por sua região e ID da conta da AWS e substitua `example@example.com` por um endereço de e-mail válido.)
```
aws sns subscribe \
--topic-arn arn:aws:sns:region:accountID:wooferTopic \
--protocol email \
--notification-endpoint example@example.com
```
1. O Amazon SNS envia uma mensagem de confirmação ao seu endereço de e-mail. Selecione o link **Confirm subscription** (Confirmar assinatura) na mensagem para concluir o processo de assinatura.
## Etapa 4: criar e testar uma função do Lambda
Nesta etapa, você cria uma função do AWS Lambda (`publishNewBark`) para processar registros de fluxo da `BarkTable`.
A função `publishNewBark` processa apenas os eventos de fluxo que correspondem a novos itens na `BarkTable`. A função lê dados de um evento como esse e, em seguida, invoca o Amazon SNS; para publicá-lo.
1. Crie um arquivo denominado `publishNewBark.js` com os conteúdos a seguir. (Substitua `region` e `accountID` por sua região e seu ID de conta da AWS.)
```
'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. Crie um arquivo zip para conter `publishNewBark.js`. Se você tiver o utilitário de linha de comando zip, poderá digitar o seguinte comando para fazer isso.
```
zip publishNewBark.zip publishNewBark.js
```
1. Ao criar a função do Lambda, você especifica o nome do recurso da Amazon (ARN) da `WooferLambdaRole` que você criou em [Etapa 2: criar uma função de execução do Lambda](#Streams.Lambda.Tutorial.CreateRole). Digite o seguinte comando para recuperar o ARN.
```
aws iam get-role --role-name WooferLambdaRole
```
Na saída, procure o ARN da `WooferLambdaRole`.
```
...
"Arn": "arn:aws:iam::region:role/service-role/WooferLambdaRole"
...
```
Use o seguinte comando para criar a função do Lambda. Substitua *roleARN* pelo ARN da `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. Agora teste o `publishNewBark` para verificar se ele funciona. Para fazer isso, você deve fornecer informações semelhantes a um registro real do DynamoDB Streams.
Crie um arquivo denominado `payload.json` com os conteúdos a seguir. Substitua `region` e `accountID` por sua Região da AWS e seu ID de conta.
```
{
"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"
}
]
}
```
Use o seguinte comando para testar a função `publishNewBark`.
```
aws lambda invoke --function-name publishNewBark --payload file://payload.json --cli-binary-format raw-in-base64-out output.txt
```
Se o teste for bem-sucedido, você verá a seguinte saída.
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
```
Além disso, o arquivo `output.txt` conterá o seguinte texto.
```
"Successfully processed 1 records."
```
Você também receberá uma nova mensagem de e-mail dentro de alguns minutos.
**nota**
AWS LambdaO grava informações de diagnóstico no Amazon CloudWatch Logs. Se você encontrar erros em sua função do Lambda, poderá usar essas informações de diagnóstico para fins de solução de problemas:
Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
No painel de navegação, selecione **Logs**.
Escolha o grupo de logs a seguir: `/aws/lambda/publishNewBark`
Escolha o fluxo de logs mais recente para visualizar a saída (e os erros) da função.
## Etapa 5: criar e testar um acionador
Em [Etapa 4: criar e testar uma função do Lambda](#Streams.Lambda.Tutorial.LambdaFunction), você testou a função do Lambda para garantir que ela fosse executada corretamente. Nesta etapa, você cria um *acionador* associando a função do Lambda (`publishNewBark`) à origem de um evento (o fluxo `BarkTable`).
1. Ao criar o acionador, você deve especificar o ARN do fluxo de `BarkTable`. Digite o seguinte comando para recuperar o ARN.
```
aws dynamodb describe-table --table-name BarkTable
```
Na saída, procure o `LatestStreamArn`.
```
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
```
1. Insira o seguinte comando para criar o acionador. Substitua `streamARN` pelo ARN do fluxo atual.
```
aws lambda create-event-source-mapping \
--region region \
--function-name publishNewBark \
--event-source streamARN \
--batch-size 1 \
--starting-position TRIM_HORIZON
```
1. Teste o acionador. Insira o seguinte comando para adicionar um item 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"}
```
Você deve receber uma nova mensagem de e-mail dentro de alguns minutos.
1. Abra o console do DynamoDB e adicione mais alguns itens a `BarkTable`. Você deve especificar valores para os atributos `Username` e `Timestamp`. (Você também deve especificar um valor para `Message`, embora isso não seja obrigatório.) Você deve receber uma nova mensagem de e-mail para cada item que adicionar a `BarkTable`.
A função do Lambda processa apenas novos itens que você adiciona a `BarkTable`. Se você atualizar ou excluir um item na tabela, a função não fará nada.
**nota**
O AWS Lambda grava informações de diagnóstico no Amazon CloudWatch Logs. Se você encontrar erros em sua função do Lambda, poderá usar essas informações de diagnóstico para fins de solução de problemas.
Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
No painel de navegação, selecione **Logs**.
Escolha o grupo de logs a seguir: `/aws/lambda/publishNewBark`
Escolha o fluxo de logs mais recente para visualizar a saída (e os erros) da função.