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á.

# Processar itens individuais com uma função do Lambda no Step Functions
<a name="tutorial-itembatcher-single-item-process"></a>

Neste tutorial, você usa o campo [ItemBatcher (mapa)](input-output-itembatcher.md) do *estado Mapa Distribuído* (Mapa distribuído) para processar um lote inteiro de itens dentro de uma função do Lambda. O *estado Mapa Distribuído* (Mapa distribuído) inicia quatro execuções do fluxo de trabalho secundário. Cada um desses fluxos de trabalho secundários executa um *estado Mapa inline*. Para cada iteração, o *estado Mapa inline* invoca uma função do Lambda e passa um só item do lote para a função. A função do Lambda então processa o item e retorna o resultado.

Você vai criar uma máquina de estado que executa a multiplicação em uma matriz de números inteiros. Digamos que a matriz de números inteiros que você fornece como entrada é `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` e o fator de multiplicação é `7`. Então, a matriz resultante formada após a multiplicação desses números inteiros por um fator de sete será `[7, 14, 21, 28, 35, 42, 49, 56, 63, 70]`.

## Etapa 1: Criar a máquina de estado
<a name="itembatcher-single-item-process-create-state-machine"></a>

Nesta etapa, você cria o protótipo de fluxo de trabalho da máquina de estado que passa um só item de um lote de itens a cada invocação da função do Lambda que você vai criar na [Etapa 2](#itembatcher-single-item-process-config-resource).
+ Use a definição a seguir para criar uma máquina de estado usando o [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/). Para obter informações sobre como criar uma máquina de estado, consulte [Etapa 1: Criar o protótipo do fluxo de trabalho](tutorial-map-distributed.md#use-dist-map-create-workflow) no tutorial [Introdução ao uso do estado Mapa Distribuído](tutorial-map-distributed.md).

  Nessa máquina de estado, você define um *estado de Mapa distribuído* que aceita uma matriz de 10 números inteiros como entrada e passa esses itens de matriz para as execuções do fluxo de trabalho secundário em lotes. Cada execução de fluxo de trabalho secundário recebe um lote de três itens como entrada e executa um *estado Mapa inline*. Cada iteração do *estado Mapa inline* invoca uma função do Lambda e passa um só item do lote para a função. Essa função então multiplica o item por um fator de `7` e retorna o resultado.

  A saída da execução de cada fluxo de trabalho secundário é uma matriz JSON que contém o resultado da multiplicação de cada um dos itens transmitidos.
**Importante**  
[Substitua o Nome do recurso da Amazon (ARN) da função do Lambda no código a seguir pelo ARN da função que você vai criar na Etapa 2.](#itembatcher-single-item-process-config-resource)

  ```
  {
    "StartAt": "Pass",
    "States": {
      "Pass": {
        "Type": "Pass",
        "Next": "Map",
        "Result": {
          "MyMultiplicationFactor": 7,
          "MyItems": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        }
      },
      "Map": {
        "Type": "Map",
        "ItemProcessor": {
          "ProcessorConfig": {
            "Mode": "DISTRIBUTED",
            "ExecutionType": "STANDARD"
          },
          "StartAt": "InnerMap",
          "States": {
            "InnerMap": {
              "Type": "Map",
              "ItemProcessor": {
                "ProcessorConfig": {
                  "Mode": "INLINE"
                },
                "StartAt": "Lambda Invoke",
                "States": {
                  "Lambda Invoke": {
                    "Type": "Task",
                    "Resource": "arn:aws:states:::lambda:invoke",
                    "OutputPath": "$.Payload",
                    "Parameters": {
                      "Payload.$": "$",
                      "FunctionName": "arn:aws:lambda:{{region}}:{{account-id}}:function:{{functionName}}"
                    },
                    "Retry": [
                      {
                        "ErrorEquals": [
                          "Lambda.ServiceException",
                          "Lambda.AWSLambdaException",
                          "Lambda.SdkClientException",
                          "Lambda.TooManyRequestsException"
                        ],
                        "IntervalSeconds": 2,
                        "MaxAttempts": 6,
                        "BackoffRate": 2
                      }
                    ],
                    "End": true
                  }
                }
              },
              "End": true,
              "ItemsPath": "$.Items",
              "ItemSelector": {
                "MyMultiplicationFactor.$": "$.BatchInput.MyMultiplicationFactor",
                "MyItem.$": "$$.Map.Item.Value"
              }
            }
          }
        },
        "End": true,
        "Label": "Map",
        "MaxConcurrency": 1000,
        "ItemsPath": "$.MyItems",
        "ItemBatcher": {
          "MaxItemsPerBatch": 3,
          "BatchInput": {
            "MyMultiplicationFactor.$": "$.MyMultiplicationFactor"
          }
        }
      }
    }
  }
  ```

## Etapa 2: Criar a função do Lambda
<a name="itembatcher-single-item-process-config-resource"></a>

Nesta etapa, você vai criar a função do Lambda que processa cada item passado do lote.

**Importante**  
Verifique se a função do Lambda está na mesma Região da AWS que a máquina de estado.

**Para criar a função do Lambda**

1. Use o [console do Lambda](https://console.aws.amazon.com/lambda/home) para criar uma função do Lambda **Python** chamada **ProcessSingleItem**. Para obter informações sobre como criar uma função do Lambda, consulte [Etapa 4: Configurar a função do Lambda](tutorial-map-distributed.md#use-dist-map-config-resource) no tutorial [Introdução ao uso do estado Mapa Distribuído](tutorial-map-distributed.md).

1. Copie o código a seguir para a função do Lambda e cole-o na seção **Origem do código** da função do Lambda.

   ```
   import json
   
   def lambda_handler(event, context):
       
       multiplication_factor = event['MyMultiplicationFactor']
       item = event['MyItem']
       
       result = multiplication_factor * item
       
       return {
           'statusCode': 200,
           'multiplied': result
       }
   ```

1. Depois de criar a função do Lambda, copie o ARN da função exibido no canto superior direito da página. Veja a seguir um exemplo de ARN, em que {{`function-name`}} é o nome da função do Lambda (nesse caso, `ProcessSingleItem`):

   ```
   arn:aws:lambda:{{region}}:123456789012:function:{{function-name}}
   ```

   Você precisará fornecer a função do ARN na máquina de estado criada na [Etapa 1](#itembatcher-single-item-process-create-state-machine).

1. Escolha **Implantar** para implantar essas alterações.

## Etapa 3: Executar a máquina de estado
<a name="itembatcher-param-task-run-state-machine"></a>

Quando você executa a [máquina de estado](#itembatcher-single-item-process-create-state-machine), o *estado Mapa Distribuído* inicia quatro execuções secundárias do fluxo de trabalho, em que cada execução processa três itens, enquanto uma execução processa um só item.

O exemplo a seguir mostra os dados passados a uma das invocações de função [`ProcessSingleItem`](#itembatcher-single-item-process-config-resource) dentro de uma execução de fluxo de trabalho secundário.

```
{
  "MyMultiplicationFactor": 7,
  "MyItem": 1
}
```

Com essa entrada, o exemplo a seguir mostra a saída que a função do Lambda retorna.

```
{
  "statusCode": 200,
  "multiplied": 7
}
```

Veja a seguir um exemplo de saída da matriz JSON para uma das execuções do fluxo de trabalho secundário.

```
[
  {
    "statusCode": 200,
    "multiplied": 7
  },
  {
    "statusCode": 200,
    "multiplied": 14
  },
  {
    "statusCode": 200,
    "multiplied": 21
  }
]
```

A máquina de estado retorna a seguinte saída que contém quatro matrizes para as quatro execuções do fluxo de trabalho secundário. Essas matrizes contêm os resultados da multiplicação dos itens de entrada individuais.

Por fim, a saída da máquina de estado é uma matriz chamada `multiplied` que combina todos os resultados de multiplicação retornados para as quatro execuções do fluxo de trabalho secundário.

```
[
  [
    {
      "statusCode": 200,
      "multiplied": 7
    },
    {
      "statusCode": 200,
      "multiplied": 14
    },
    {
      "statusCode": 200,
      "multiplied": 21
    }
  ],
  [
    {
      "statusCode": 200,
      "multiplied": 28
    },
    {
      "statusCode": 200,
      "multiplied": 35
    },
    {
      "statusCode": 200,
      "multiplied": 42
    }
  ],
  [
    {
      "statusCode": 200,
      "multiplied": 49
    },
    {
      "statusCode": 200,
      "multiplied": 56
    },
    {
      "statusCode": 200,
      "multiplied": 63
    }
  ],
  [
    {
      "statusCode": 200,
      "multiplied": 70
    }
  ]
]
```

Para combinar todos os resultados de multiplicação retornados pelas execuções do fluxo de trabalho secundário em uma só matriz de saída, você pode usar o campo [ResultSelector](input-output-inputpath-params.md#input-output-resultselector). Defina esse campo dentro do *estado Mapa Distribuído* (Mapa Distribuído) para encontrar todos os resultados, extrair os resultados individuais e combiná-los em uma só matriz de saída chamada `multiplied`.

Para usar o campo `ResultSelector`, atualize a definição da máquina de estado como mostra o exemplo a seguir.

```
{
  "StartAt": "Pass",
  "States": {
    ...
    ...
    "Map": {
      "Type": "Map",
      ...
      ...
      "ItemBatcher": {
        "MaxItemsPerBatch": 3,
        "BatchInput": {
          "MyMultiplicationFactor.$": "$.MyMultiplicationFactor"
        }
      },
      "ItemsPath": "$.MyItems",
      "ResultSelector": {
        "multiplied.$": "$..multiplied"
      }
    }
  }
}
```

A máquina de estado atualizada retorna uma matriz de saída consolidada, como mostra o exemplo a seguir.

```
{
  "multiplied": [7, 14, 21, 28, 35, 42, 49, 56, 63, 70]
}
```