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á. # Usar o estado de mapa no modo inline em fluxos de trabalho do Step Functions **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). Por padrão, os estados `Map` são executados no modo **inline**. No modo inline, o estado Mapa aceita somente uma matriz JSON como entrada. Ele recebe essa matriz de uma etapa anterior no fluxo de trabalho. Nesse modo, cada iteração do estado `Map` é executada no contexto do fluxo de trabalho que contém o estado `Map`. O Step Functions adiciona o histórico de execução dessas iterações ao histórico de execuções do fluxo de trabalho principal. Nesse modo, o estado `Map` oferece suporte para até 40 iterações simultâneas. Um estado `Map` definido como **Inline** é conhecido como *estado Mapa inline*. Use o estado `Map` no modo Em linha se o histórico de execução do fluxo de trabalho não exceder 25 mil entradas ou se você não precisar de mais de 40 iterações simultâneas. Para obter uma introdução ao uso do *estado Mapa inline*, consulte o tutorial [Repetir ações com o mapa inline](tutorial-map-inline.md). **Topics** + [Principais conceitos neste tópico](#key-concepts-inline-map) + [Campos do estado Mapa inline](#map-state-inline-additional-fields) + [Campos descontinuados](#map-state-inline-deprecated-fields) + [Exemplo de estado de mapa embutido () JSONPath](#inline-map-state-examples) + [Exemplo de estado Mapa inline com `ItemSelector`.](#inline-map-state-example-params) + [Processamento de entrada e saída do estado `Map` inline.](#inline-map-state-output) ## Principais conceitos neste tópico **Modo inline** Um modo de processamento simultâneo limitado do estado `Map`. Nesse modo, cada iteração do estado `Map` é executada no contexto do fluxo de trabalho que contém o estado `Map`. O Step Functions adiciona o histórico de execução dessas iterações ao histórico de execuções do fluxo de trabalho principal. Os estados `Map` são executados no modo inline como padrão. Esse modo aceita somente uma matriz JSON como entrada e é compatível com até 40 iterações simultâneas. **Estado Mapa inline** Um estado `Map` definido como modo **inline**. **Fluxo de trabalho do mapa** O conjunto de etapas que o estado `Map` executa para cada iteração. **Iteração do estado Mapa** Uma repetição do fluxo de trabalho definida dentro do estado `Map`. ## Campos do estado Mapa inline Para usar o *estado Mapa inline* em fluxos de trabalho, especifique um ou mais dos campos a seguir. Você especifica esses campos além dos [campos de estado comuns](statemachine-structure.md#amazon-states-language-common-fields). **`Type` (Obrigatório)** Define o tipo de estado, como `Map`. **`ItemProcessor` (Obrigatório)** Contém os seguintes objetos JSON que especificam a definição e o modo de processamento estado `Map`. A definição contém o conjunto de etapas a serem repetidas para processar cada item da matriz. + `ProcessorConfig`— Um objeto JSON opcional que especifica o modo de processamento do estado `Map`. Esse objeto contém o subcampo `Mode`. Esse campo é padronizado como `INLINE`, que usa o estado `Map` no modo inline. Nesse modo, a falha de qualquer iteração causa uma falha no estado `Map`. Todas as iterações param quando uma falha ocorre no estado `Map`. + `StartAt`— Especifica uma string que indica o primeiro estado em um fluxo de trabalho. Essa string diferencia maiúsculas de minúsculas e deve corresponder ao nome de um dos objetos de estado. Esse estado é executado primeiro para cada item no conjunto de dados. Qualquer entrada de execução fornecida ao estado `Map` é transmitida primeiro para o estado `StartAt`. + `States` – Um objeto JSON que contém um conjunto de [estados](workflow-states.md) delimitado por vírgulas. Nesse objeto, você define o [Map workflow](#mapwflow). **nota** Os estados no campo `ItemProcessor` só podem fazer a transição entre si. Nenhum estado fora do campo `ItemProcessor` pode fazer a transição para um estado dentro dele. O campo `ItemProcessor` substitui o campo `Iterator`, agora obsoleto. Embora você possa continuar a incluir estados de `Map` que usam o campo `Iterator`, é altamente recomendável substituir esse campo por `ItemProcessor`. No momento, o [Step Functions Local](sfn-local.md) não é compatível com o campo `ItemProcessor`. Recomendamos o uso do campo `Iterator` com o Step Functions Local. **`Items`(Opcional, JSONata somente)** Uma matriz JSON ou uma JSONata expressão que deve ser avaliada como uma matriz. **`ItemsPath`(Opcional, JSONPath somente)** Especifica um [caminho de referência](amazon-states-language-paths.md#amazon-states-language-reference-paths) usando a [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)sintaxe. Esse caminho seleciona o nó JSON que contém a matriz de itens dentro da entrada de estado. Para obter mais informações, consulte [ItemsPath (Mapa, JSONPath somente)](input-output-itemspath.md). **`ItemSelector` (Opcional)** Substitui os valores da matriz de entrada antes de serem transmitidos para cada iteração do estado `Map`. Nesse campo, você especifica um JSON válido que contém um conjunto de pares de valores-chave. Esses pares podem conter espaços ou um destes itens: + Valores estáticos selecionados na definição da máquina de estado. + Valores selecionados da entrada de estado usando um [caminho](amazon-states-language-paths.md). + Valores acessados a partir do [objeto de contexto](input-output-contextobject.md). Para obter mais informações, consulte [ItemSelector (mapa)](input-output-itemselector.md). O campo `ItemSelector` substitui o campo `Parameters`, agora obsoleto. Embora você possa continuar a incluir estados de `Map` que usam o campo `Parameters`, é altamente recomendável substituir esse campo por `ItemSelector`. **`MaxConcurrency` (Opcional)** Especifica um valor inteiro que fornece o limite superior do número de iterações do estado `Map` que podem ser executadas em paralelo. Por exemplo, um valor `MaxConcurrency` de 10 limitará o estado `Map` a 10 iterações simultâneas em execução ao mesmo tempo. Nos JSONata estados, você pode especificar uma JSONata expressão que seja avaliada como um número inteiro. As iterações simultâneas podem ser limitadas. Quando isso ocorre, algumas iterações não começarão até que as iterações anteriores sejam concluídas. A probabilidade de isso ocorrer aumenta quando sua matriz de entrada tem mais de 40 itens. Para aumentar a capacidade de processamento simultâneo, considere [Modo distribuído](state-map-distributed.md). O valor padrão é `0`, o que não limita a capacidade de processamento simultâneo. O Step Functions invoca iterações da forma mais simultânea possível. Um valor `MaxConcurrency` de `1` invoca o `ItemProcessor` uma vez para cada elemento da matriz. Os itens na matriz são processados na ordem em que aparecem na entrada. O Step Functions não iniciará uma nova iteração até concluir a iteração anterior. **`MaxConcurrencyPath`(Opcional, JSONPath somente)** Para fornecer dinamicamente um valor máximo de processamento simultâneo a partir da entrada de estado usando um caminho de referência, use `MaxConcurrencyPath`. Quando resolvido, o caminho de referência deve selecionar um campo cujo valor seja um número inteiro não negativo. Um estado `Map` não pode incluir `MaxConcurrency` e `MaxConcurrencyPath`. **`ResultPath`(Opcional, JSONPath somente)** Especifica onde na entrada armazenar a saída das iterações do estado `Map`. Em seguida, o estado Mapa filtra a entrada conforme especificado pelo campo [`OutputPath`](input-output-example.md#input-output-outputpath), se especificado. Em seguida, ele usa a entrada filtrada como saída do estado. Para obter mais informações, consulte [Processamento de entrada e saída](concepts-input-output-filtering.md). **`ResultSelector`(Opcional, JSONPath somente)** Transmitir um conjunto de pares de valores-chave, em que os valores são estáticos ou selecionados a partir do resultado. Para obter mais informações, consulte [ResultSelector](input-output-inputpath-params.md#input-output-resultselector). Se o estado Paralelo ou Mapa usado nas máquinas de estado retornar uma matriz de matrizes, você poderá transformá-las em uma matriz nivelada com o campo [ResultSelector](input-output-inputpath-params.md#input-output-resultselector). Para obter mais informações, consulte [Nivelamento de uma matriz de matrizes](input-output-inputpath-params.md#flatten-array-of-arrays-result-selector). **`Retry` (Opcional)** Uma matriz de objetos, chamados Retriers, que definem uma política de novas tentativas. Os estados usam uma política de nova tentativa quando encontram erros de runtime. Para obter mais informações, consulte [Exemplos de máquina de estado usando repetição e captura](concepts-error-handling.md#error-handling-examples). Se você definir Retriers para o *estado Mapa inline*, a política de nova tentativa se aplicará a todas as iterações do estado `Map`, em vez de somente às iterações com falha. Por exemplo, o estado `Map` contém duas iterações concluídas com êxito e uma com falha. Se você tiver definido o campo `Retry` para o estado `Map`, a política de repetição se aplicará a todas as três iterações do estado `Map`, em vez de apenas à iteração com falha. **`Catch` (Opcional)** Uma matriz de objetos, chamados Catchers, que definem um estado de fallback. Os estados executarão um catcher se encontrarem erros de runtime e não tiverem uma política de nova tentativa ou se a política de nova tentativa estiver esgotada. Para obter mais informações, consulte [Estados de fallback](concepts-error-handling.md#error-handling-fallback-states). **`Output`(Opcional, JSONata somente)** Usado para especificar e transformar a saída do estado. Quando especificado, o valor substitui o padrão de saída de estado. O campo de saída aceita qualquer valor JSON (objeto, matriz, string, número, booleano, nulo). Qualquer valor de string, incluindo aqueles dentro de objetos ou matrizes, será avaliado como JSONata se estivesse cercado por \$1%%\$1 caracteres. A saída também aceita uma JSONata expressão diretamente, por exemplo: “Output”: “\$1% jsonata expression%\$1” Para obter mais informações, consulte [Transformando dados com Step JSONata Functions](transforming-data.md). ** `Assign` (Opcional)** Usado para armazenar variáveis. O `Assign` campo aceita um objeto JSON com key/value pares que definem nomes de variáveis e seus valores atribuídos. Qualquer valor de string, incluindo aqueles dentro de objetos ou matrizes, será avaliado como JSONata quando cercado por `{% %}` caracteres Para obter mais informações, consulte [Transmitir dados entre estados com variáveis](workflow-variables.md). ## Campos descontinuados **nota** Embora você possa continuar a incluir estados de `Map` que usam o campo `Iterator`, é altamente recomendável substituir por `ItemProcessor` e `Parameters` por `ItemSelector`. ** `Iterator`** Especifica um objeto JSON que define um conjunto de etapas que processam cada elemento da matriz. **`Parameters`** Especifica um conjunto de pares de valores-chave, no qual os valores podem conter espaços ou um destes itens: + Valores estáticos selecionados na definição da máquina de estado. + Valores selecionados da entrada usando um [caminho](amazon-states-language-paths.md). ## Exemplo de estado de mapa embutido () JSONPath Considere os seguintes dados de entrada para um estado `Map` no modo inline****. ``` { "ship-date": "2016-03-14T01:59:00Z", "detail": { "delivery-partner": "UQS", "shipped": [ { "prod": "R31", "dest-code": 9511, "quantity": 1344 }, { "prod": "S39", "dest-code": 9511, "quantity": 40 }, { "prod": "R31", "dest-code": 9833, "quantity": 12 }, { "prod": "R40", "dest-code": 9860, "quantity": 887 }, { "prod": "R40", "dest-code": 9511, "quantity": 1220 } ] } } ``` Dada a entrada anterior, o `Map` estado no exemplo a seguir invoca uma AWS Lambda função nomeada `ship-val` uma vez para cada item da matriz no `shipped` campo. ``` "Validate All": { "Type": "Map", "InputPath": "$.detail", "ItemProcessor": { "ProcessorConfig": { "Mode": "INLINE" }, "StartAt": "Validate", "States": { "Validate": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "OutputPath": "$.Payload", "Parameters": { "FunctionName": "arn:aws:lambda:us-east-2:account-id:function:ship-val:$LATEST" }, "End": true } } }, "End": true, "ResultPath": "$.detail.shipped", "ItemsPath": "$.shipped" } ``` Cada iteração do estado `Map` enviará um item na matriz, selecionada com o campo [`ItemsPath`](input-output-itemspath.md) como entrada para a função do Lambda `ship-val`. Os valores a seguir são um exemplo de entrada que o estado `Map` envia para uma invocação da função do Lambda: ``` { "prod": "R31", "dest-code": 9511, "quantity": 1344 } ``` Quando concluída, a saída do estado `Map` é uma matriz JSON, onde cada item é a saída de uma iteração. Nesse caso, essa matriz contém a saída da função do Lambda `ship-val`. ## Exemplo de estado Mapa inline com `ItemSelector`. Vamos supor que a função do Lambda `ship-val` no exemplo anterior também precise de informações sobre a transportadora da remessa. Essas informações são adicionadas aos itens na matriz para cada iteração. Você pode incluir informações da entrada, juntamente com informações específicas à iteração atual do estado `Map`. Observe o campo `ItemSelector` no exemplo a seguir. ``` "Validate-All": { "Type": "Map", "InputPath": "$.detail", "ItemsPath": "$.shipped", "MaxConcurrency": 0, "ResultPath": "$.detail.shipped", "ItemSelector": { "parcel.$": "$$.Map.Item.Value", "courier.$": "$.delivery-partner" }, "ItemProcessor": { "StartAt": "Validate", "States": { "Validate": { "Type": "Task", "Resource": "arn:aws:lambda:region:account-id:function:ship-val", "End": true } } }, "End": true } ``` O bloco `ItemSelector` substitui a entrada das iterações por um nó JSON. Esse nó contém os dados do item atual do [objeto de contexto](input-output-contextobject.md#contextobject-map) e as informações da transportadora do campo `delivery-partner` da entrada do estado `Map`. O exemplo a seguir é um entrada para uma única iteração. O estado `Map` transmite essa entrada para uma invocação da função do Lambda `ship-val`. ``` { "parcel": { "prod": "R31", "dest-code": 9511, "quantity": 1344 }, "courier": "UQS" } ``` No exemplo anterior do *estado Mapa inline*, o campo `ResultPath` produz uma saída no mesmo formato da entrada. No entanto, ele substitui o campo `detail.shipped` por uma matriz na qual cada elemento é a saída da invocação do Lambda `ship-val` de cada iteração. Para ver mais informações sobre como usar o *estado Mapa inline* e seus campos, consulte o seguinte: + [Repetir ações com o mapa inline](tutorial-map-inline.md) + [Processar entrada e saída no Step Functions](concepts-input-output-filtering.md) + [ItemsPath (Mapa, JSONPath somente)](input-output-itemspath.md) + [Dados de objeto de contexto para estados de mapa](input-output-contextobject.md#contextobject-map) ## Processamento de entrada e saída do estado `Map` inline. Para um determinado estado `Map`, o [`InputPath`](input-output-inputpath-params.md#input-output-inputpath) seleciona um subconjunto da entrada do estado. A entrada de um estado `Map` deve incluir uma matriz JSON. O estado `Map` executa a seção `ItemProcessor` uma vez para cada item na matriz. Se você especificar o campo [`ItemsPath`](input-output-itemspath.md), o estado `Map` selecionará onde na entrada encontrar a matriz sobre a qual iterar. Se não for especificado, o valor de `ItemsPath` será `$`, e a seção `ItemProcessor` esperará que a matriz seja a única entrada. Se você especificar o campo `ItemsPath`, seu valor deverá ser um [caminho de referência](amazon-states-language-paths.md#amazon-states-language-reference-paths). O estado `Map` aplica esse caminho à entrada efetiva depois de aplicar o `InputPath`. O `ItemsPath` deve identificar um campo cujo valor seja uma matriz JSON. A entrada para cada iteração, por padrão, é um único elemento do campo de matriz identificado pelo valor `ItemsPath`. Você pode substituir esse valor pelo campo `ItemSelector (mapa)`. Quando concluída, a saída do estado `Map` é uma matriz JSON, onde cada item é a saída de uma iteração. Para ver mais informações sobre entradas e saídas do estado Mapa inline, consulte: + [Repetir ações com o mapa inline](tutorial-map-inline.md) + [Exemplo de estado Mapa inline com `ItemSelector`.](#inline-map-state-example-params) + [Processar entrada e saída no Step Functions](concepts-input-output-filtering.md) + [Dados de objeto de contexto para estados de mapa](input-output-contextobject.md#contextobject-map) + [Processar dados de uma fila com um estado de mapa no Step Functions](sample-map-state.md)