As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Iterar um loop com uma função do Lambda no Step Functions
Neste tutorial, você irá implementar um padrão de design que usa uma máquina de estado e uma função de AWS Lambda para iterar um loop um número específico de vezes.
Use esse padrão de design sempre que precisar para controlar o número de loops em uma máquina de estado. Essa implementação pode ajudar você a dividir grandes tarefas ou execuções de longa execução em partes menores. Ela também será útil no encerramento de uma execução após um número específico de eventos. Você pode usar uma implementação semelhante para encerrar e reiniciar periodicamente uma execução de longa duração para evitar exceder as cotas de serviço para AWS Step Functions AWS Lambda, ou outros serviços. AWS
Antes de começar, leia o tutorial do [Como criar uma máquina de estado Step Functions que usa Lambda](tutorial-creating-lambda-state-machine.md) para garantir que você esteja familiarizado com o uso do Lambda e do Step Functions juntos.
## Etapa 1: Criar uma função do Lambda para iterar uma contagem
Ao usar uma função do Lambda, você pode controlar o número de iterações de um loop na sua máquina de estado. A função do Lambda a seguir recebe os valores de entrada para `count`, `index` e `step`. Ela retorna esses valores com um `index` atualizado e um valor booliano chamado `continue`. A função do Lambda definirá `continue` como `true` se `index` for menor que `count`.
A seguir, a máquina de estado implementa um estado de `Choice` que executa certa lógica de aplicação se `continue` for `true`, ou é encerrada se for `false`.
### Para criar a função do Lambda
1. Faça login no [console do Lambda](https://console.aws.amazon.com/lambda/home) e escolha **Criar função**.
1. Na página **Create function**, selecione **Author from scratch**.
1. Na seção **Informações básicas**, configure a função do Lambda da seguinte maneira:
1. Em **Function name** (Nome da função), insira `Iterator`.
1. Em **Runtime (Tempo de execução)**, selecione **Node.js**.
1. Em **Alterar a função de execução padrão**, escolha **Create a new role with basic Lambda permissions** (Criar uma função com permissões básicas do Lambda).
1. Escolha a opção **Criar função**.
1. Copie o código a seguir da função do Lambda na **Origem do código**.
```
export const handler = function (event, context, callback) {
let index = event.iterator.index
let step = event.iterator.step
let count = event.iterator.count
index = index + step
callback(null, {
index,
step,
count,
continue: index < count
})
}
```
Esse código aceita os valores de entrada `count`, `index` e `step`. Ele incrementa o `index` pelo valor da `step` e retorna esses valores e o booliano `continue`. O valor de `continue` é `true` se `index` for inferior a `count`.
1. Escolha **Implantar**.
## Etapa 2: Testar a função do Lambda
Execute a sua função do Lambda com valores numéricos para vê-la em operação. É possível fornecer valores de entrada para a função do Lambda que imitem uma iteração.
### Para testar a função do Lambda
1. Escolha **Testar**.
1. Na caixa de diálogo **Configurar evento de teste**, insira `TestIterator` na caixa **Nome do evento**.
1. Substitua os dados de exemplo pelo seguinte:
```
{
"Comment": "Test my Iterator function",
"iterator": {
"count": 10,
"index": 5,
"step": 1
}
}
```
Esses valores imitam o que pode ser proveniente de sua máquina de estado durante uma iteração. A função do Lambda incrementará o índice e exibirá `true` para `continue` quando o índice for menor que `count`. Para este teste, o índice já foi incrementado para `5`. O teste vai incrementar `index` para `6` e definir `continue` como `true`.
1. Escolha **Criar**.
1. Escolha **Testar** para testar a função do Lambda.
Os resultados do teste são exibidos na guia **Resultados da execução**.
1. Escolha a guia **Resultados da execução** para ver a saída.
```
{
"index": 6,
"step": 1,
"count": 10,
"continue": true
}
```
**nota**
Se você definir `index` como `9` e testar novamente, o `index` será incrementado para `10` e `continue` será `false`.
## Etapa 3: Criar uma máquina de estado
**Antes de sair do console do Lambda...**
Copie o ARN da função do Lambda. Cole-o em uma nota. Você precisará dele na próxima etapa.
Depois, você criará uma máquina de estado com os seguintes estados:
+ `ConfigureCount`: define os valores padrão para `count`, `index` e `step`.
+ `Iterator`: faz referência à função do Lambda que você criou anteriormente transmitindo os valores configurados em `ConfigureCount`.
+ `IsCountReached`: um estado de escolha que prossegue com o loop ou até o estado `Done`, com base no valor exibido pela função `Iterator`.
+ `ExampleWork`: um stub do trabalho que precisa ser feito. Neste exemplo, o fluxo de trabalho tem um estado `Pass`, mas, em uma solução real, você provavelmente usaria `Task`.
+ `Done`: estado final do fluxo de trabalho.
Como criar a máquina de estado no console:
1. Abra o [console do Step Functions](https://console.aws.amazon.com/states/home) e escolha **Create a state machine** (Criar uma máquina de estado).
**Importante**
Sua máquina de estado deve estar na mesma AWS conta e região da sua função Lambda.
1. Selecione o modelo **Em branco**.
1. No painel **Código**, cole o JSON a seguir que define a máquina de estado.
Para obter mais informações sobre a Amazon States Language, consulte [Estrutura da máquina de estado](statemachine-structure.md).
```
{
"Comment": "Iterator State Machine Example",
"StartAt": "ConfigureCount",
"States": {
"ConfigureCount": {
"Type": "Pass",
"Result": {
"count": 10,
"index": 0,
"step": 1
},
"ResultPath": "$.iterator",
"Next": "Iterator"
},
"Iterator": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:Iterate",
"ResultPath": "$.iterator",
"Next": "IsCountReached"
},
"IsCountReached": {
"Type": "Choice",
"Choices": [
{
"Variable": "$.iterator.continue",
"BooleanEquals": true,
"Next": "ExampleWork"
}
],
"Default": "Done"
},
"ExampleWork": {
"Comment": "Your application logic, to run a specific number of times",
"Type": "Pass",
"Result": {
"success": true
},
"ResultPath": "$.result",
"Next": "Iterator"
},
"Done": {
"Type": "Pass",
"End": true
}
}
}
```
1. Substitua o campo `Iterator Resource` pelo ARN real da função do Lambda `Iterator` criada anteriormente.
1. Selecione **Configuração** e insira um **nome** para a máquina de estado, como `IterateCount`.
**nota**
Os nomes das máquinas de estado, execuções e tarefas de atividade não devem exceder oitenta caracteres. Esses nomes devem ser exclusivos para sua conta e AWS região e não devem conter nenhum dos seguintes itens:
Espaço em branco
Caracteres curinga (`? *`)
Caracteres de colchete (`< > { } [ ]`)
Caracteres especiais (`" # % \ ^ | ~ ` $ & , ; : /`)
caracteres de controle (`\\u0000` - `\\u001f` ou `\\u007f` - `\\u009f`).
O Step Functions aceita nomes de máquina de estado, execuções, atividades e rótulos que contenham caracteres não ASCII. Como esses caracteres impedirão que a Amazon CloudWatch registre dados, recomendamos usar somente caracteres ASCII para que você possa acompanhar as métricas do Step Functions.
1. Em **Tipo**, aceite o valor padrão de **Padrão**. Em **Permissões**, escolha **Criar perfil**.
1. Escolha **Criar** e confirme as criações de perfil escolhendo **Confirmar**.
## Etapa 4: Iniciar uma nova execução
Assim que criar sua máquina de estado, poderá iniciar uma execução.
1. Na **IterateCount**página, escolha **Iniciar execução**.
1. (Opcional) Insira um nome de execução personalizado para substituir o padrão gerado.
**Nomes e registro em log não ASCII**
O Step Functions aceita nomes de máquina de estado, execuções, atividades e rótulos que contenham caracteres não ASCII. Como esses caracteres impedirão que a Amazon CloudWatch registre dados, recomendamos usar somente caracteres ASCII para que você possa acompanhar as métricas do Step Functions.
1. Escolha **Start Execution**.
Uma nova execução de sua máquina de estado inicia-se mostrando sua execução em andamento.
![\[Grafo da máquina de estado mostrando o estado Iterator azul, que indica o status em andamento.\]](http://docs.aws.amazon.com/pt_br/step-functions/latest/dg/images/tutorial-create-iterate-running.png)
A execução é incrementada em etapas, fazendo o acompanhamento da contagem com a função do Lambda. Em cada iteração, ela executa o exemplo mencionado no estado `ExampleWork` em sua máquina de estado.
Quando a contagem atingir o número especificado no estado `ConfigureCount` em sua máquina de estado, a execução fechará a iteração e será encerrada.
![\[Grafo da máquina de estado mostrando o estado Iterator e Done em verde para indicar que os dois foram bem-sucedidos.\]](http://docs.aws.amazon.com/pt_br/step-functions/latest/dg/images/tutorial-create-iterate-done.png)