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

# ItemBatcher (mapa)
<a name="input-output-itembatcher"></a>

**Gerenciar estados e transformar dados**  
Saiba mais sobre como [transmitir dados entre estados com variáveis](workflow-variables.md) e [transformar dados com JSONata](transforming-data.md).

O campo `ItemBatcher` é um objeto JSON, que especifica o processamento de um grupo de itens na execução de um único fluxo de trabalho secundário. Use lotes ao processar arquivos CSV ou matrizes JSON grandes, ou conjuntos de objetos grandes do Amazon S3.

O exemplo a seguir mostra a sintaxe do campo `ItemBatcher`. Na sintaxe a seguir, o número máximo de itens que cada execução de fluxo de trabalho secundário deve processar é definido como cem.

```
{
  "ItemBatcher": {
    "MaxItemsPerBatch": 100
  }
}
```

Por padrão, cada item em um conjunto de dados é transmitido como entrada para execuções individuais de fluxos de trabalho secundários. Por exemplo, suponha que você especifique um arquivo JSON como entrada que contém a seguinte matriz:

```
[
  {
    "verdict": "true",
    "statement_date": "6/11/2008",
    "statement_source": "speech"
  },
  {
    "verdict": "false",
    "statement_date": "6/7/2022",
    "statement_source": "television"
  },
  {
    "verdict": "true",
    "statement_date": "5/18/2016",
    "statement_source": "news"
  },
  ...
]
```

Para a entrada fornecida, cada execução do fluxo de trabalho secundário recebe um item de matriz como entrada. O exemplo a seguir mostra a entrada da execução de um fluxo de trabalho secundário:

```
{
  "verdict": "true",
  "statement_date": "6/11/2008",
  "statement_source": "speech"
}
```

Para ajudar a otimizar o desempenho e o custo do seu trabalho de processamento, selecione um tamanho de lote que equilibre o número de itens em relação ao tempo de processamento deles. Se você usar lotes, o Step Functions adiciona os itens a uma matriz de **Itens**. Em seguida, ele transmite a matriz como entrada para a execução de cada fluxo de trabalho secundário. O exemplo a seguir mostra um lote de dois itens transmitido como entrada para a execução de um fluxo de trabalho secundário:

```
{
  "Items": [
    {
      "verdict": "true",
      "statement_date": "6/11/2008",
      "statement_source": "speech"
    },
    {
      "verdict": "false",
      "statement_date": "6/7/2022",
      "statement_source": "television"
    }
  ]
}
```

**dica**  
Para saber mais sobre como usar o campo `ItemBatcher` em seus fluxos de trabalho, experimente os seguintes tutoriais e workshops:  
[Processar um lote inteiro de dados em uma função do Lambda](tutorial-itembatcher-param-task.md)
[Iterar itens em um lote dentro das execuções do fluxo de trabalho secundário](tutorial-itembatcher-single-item-process.md)
[Mapa distribuído e recursos relacionados](https://catalog.workshops.aws/stepfunctions/use-cases/distributed-map) no *Workshop AWS Step Functions*

**Contents**
+ [Campos para especificar o agrupamento de itens em lotes](#input-output-itembatcher-subfields)

## Campos para especificar o agrupamento de itens em lotes
<a name="input-output-itembatcher-subfields"></a>

Para agrupar itens em lotes, especifique o número máximo de itens por lote, o tamanho máximo do lote ou ambos. É necessário especificar um desses valores para agrupar os itens. 

**Máximo de itens por lote**  
Especifica o número máximo de itens que a execução de cada fluxo de trabalho secundário processa. O intérprete limita o número de itens agrupados em lote na matriz `Items` a esse valor. Se você especificar o número e o tamanho do lote, o intérprete reduzirá o número de itens em um lote para evitar que o limite de tamanho do lote especificado seja excedido.   
Se você não especificar esse valor, mas fornecer um valor para o tamanho máximo do lote, o Step Functions processará o máximo de itens possível na execução de cada fluxo de trabalho secundário sem exceder o tamanho máximo do lote, em bytes.  
Por exemplo, imagine que você esteja executando uma execução com um arquivo JSON de entrada que contenha 1130 nós. Se você especificar um valor máximo de cem itens a cada lote, o Step Functions criará 12 lotes. Destes, 11 lotes conterão cem itens cada, enquanto o décimo segundo lote conterá os 30 itens restantes.  
Como alternativa, você pode especificar o número máximo de itens para cada lote como um [caminho de referência](amazon-states-language-paths.md#amazon-states-language-reference-paths) para um par de chave-valor existente na entrada do *estado Mapa Distribuído*. Esse caminho deve ser resolvido como um inteiro positivo.  
Por exemplo, dada a seguinte entrada:  

```
{
  "maxBatchItems": 500
}
```
Você pode especificar o número máximo de itens por lote usando um caminho de referência (**somente JSONPath**) da seguinte forma:  

```
{
  ...
  "Map": {
    "Type": "Map",
    "MaxConcurrency": 2000,
    "ItemBatcher": {
      "MaxItemsPerBatchPath": "$.maxBatchItems"
    }
    ...
    ...
  }
}
```
Para estados **baseados em JSONata**, você pode fornecer uma expressão JSONata que seja avaliada como um número inteiro positivo.  
Você pode especificar o `MaxItemsPerBatch` ou o subcampo `MaxItemsPerBatchPath (JSONPath only)`, mas não ambos.

**Máximo de KiB por lote**  
Especifica o tamanho máximo de um lote, em bytes, que é 256 KiB. Se você especificar tanto número quanto o tamanho máximos de um lote, o Step Functions reduzirá o número de itens em um lote para evitar que o limite de tamanho do lote especificado seja excedido.  
Como alternativa, você pode especificar o tamanho máximo do lote como um [caminho de referência](amazon-states-language-paths.md#amazon-states-language-reference-paths) para um par de chave-valor existente na entrada do *estado Mapa Distribuído*. Esse caminho deve ser resolvido como um inteiro positivo.  
Se você usar o agrupamento em lotes e não especificar um tamanho máximo para o lote, o intérprete processará o máximo possível de itens até 256 KiB em cada execução de um fluxo de trabalho secundário.
Por exemplo, dada a seguinte entrada:  

```
{
  "batchSize": 131072
}
```
Você pode especificar o tamanho máximo do lote usando um caminho de referência, da seguinte forma:  

```
{
  ...
  "Map": {
    "Type": "Map",
    "MaxConcurrency": 2000,
    "ItemBatcher": {
      "MaxInputBytesPerBatchPath": "$.batchSize"
    }
    ...
    ...
  }
}
```
Para estados **baseados em JSONata**, você pode fornecer uma expressão JSONata que seja avaliada como um número inteiro positivo.  
Você pode especificar o `MaxInputBytesPerBatch` ou o subcampo `MaxInputBytesPerBatchPath` (somente JSONPath), mas não ambos. 

**Entrada em lote**  
Opcionalmente, você também pode especificar a inclusão de uma entrada JSON fixa em cada lote transmitido para a execução de cada fluxo de trabalho secundário. O Step Functions mescla essa entrada com aquela para cada execução individual do fluxo de trabalho secundário. Por exemplo, dada a seguinte entrada fixa de uma data de verificação de fatos em uma matriz de itens:  

```
"ItemBatcher": {
    "BatchInput": {
        "factCheck": "December 2022"
    }
}
```
Cada execução do fluxo de trabalho secundário recebe o seguinte como entrada:  

```
{
  "BatchInput": {
    "factCheck": "December 2022"
  },
  "Items": [
    {
      "verdict": "true",
      "statement_date": "6/11/2008",
      "statement_source": "speech"
    },
    {
      "verdict": "false",
      "statement_date": "6/7/2022",
      "statement_source": "television"
    },
    ...
  ]
}
```
Para estados **baseados em JSONata**, você pode fornecer expressões JSONata diretamente para BatchInput ou usar expressões JSONata dentro de objetos ou matrizes JSON.