

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

# Manipular parâmetros nos fluxos de trabalho do Step Functions
<a name="input-output-inputpath-params"></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).

Os campos `InputPath`, `Parameters` e `ResultSelector` fornecem uma maneira de manipular o JSON à medida que ele se move por seu fluxo de trabalho. `InputPath` pode limitar a entrada que será transmitida filtrando a notação JSON por meio de um caminho (consulte [Usando JSONPath caminhos](amazon-states-language-paths.md)). Com o campo `Parameters`, é possível transmitir uma coleção de pares de valor-chave usando valores estáticos ou seleções da entrada usando um caminho.

 O `ResultSelector` campo fornece uma forma de manipular o resultado do estado antes de ser `ResultPath` aplicado. 

AWS Step Functionsaplica o `InputPath` campo primeiro e depois o `Parameters` campo. É possível primeiro filtrar a entrada bruta para uma seleção desejada usando `InputPath` e, então, aplicar `Parameters` para manipular ainda mais essa entrada ou adicionar novos valores. Em seguida, você pode usar o campo `ResultSelector` para manipular a saída do estado antes da aplicação de `ResultPath`.

## InputPath
<a name="input-output-inputpath"></a>

Use `InputPath` para selecionar uma parte da entrada de estado. 

Por exemplo, vamos supor que a entrada para seu estado inclua o seguinte:

```
{
  "comment": "Example for InputPath.",
  "dataset1": {
    "val1": 1,
    "val2": 2,
    "val3": 3
  },
  "dataset2": {
    "val1": "a",
    "val2": "b",
    "val3": "c"
  }
}
```

Você poderá aplicar `InputPath`.

```
"InputPath": "$.dataset2",
```

Com o `InputPath` anterior, o JSON transmitido como a entrada é exibido a seguir.

```
{
  "val1": "a",
  "val2": "b",
  "val3": "c"
}
```

**nota**  
Um caminho pode gerar uma seleção de valores. Considere o seguinte exemplo.  

```
{ "a": [1, 2, 3, 4] }
```
Se você aplicar o caminho `$.a[0:2]`, o resultado será o que é mostrado a seguir.  

```
[ 1, 2 ]
```

## Parâmetros
<a name="input-output-parameters"></a>

Esta seção descreve as diferentes formas de usar o campo Parâmetros. 

### Pares de chave/valor
<a name="input-output-parameters-keyvalue"></a>

Use o campo `Parameters` para criar um conjunto de pares de chave-valor que serão transmitidos como entrada. Os valores de cada um podem ser valores estáticos, incluídos na definição da máquina de estado, ou selecionados na entrada ou no objeto de contexto por meio de um caminho. Para os pares de chave-valor, em que o valor é selecionado usando um caminho, o nome da chave deve terminar em `.$`. 

Por exemplo, vamos supor que você forneça a entrada a seguir. 

```
{
  "comment": "Example for Parameters.",
  "product": {
    "details": {
       "color": "blue",
       "size": "small",
       "material": "cotton"
    },
    "availability": "in stock",
    "sku": "2317",
    "cost": "$23"
  }
}
```

Para selecionar algumas das informações, você poderá especificar esses parâmetros na definição da máquina de estado. 

```
"Parameters": {
        "comment": "Selecting what I care about.",
        "MyDetails": {
          "size.$": "$.product.details.size",
          "exists.$": "$.product.availability",
          "StaticValue": "foo"
        }
      },
```

Dada a entrada anterior e o campo `Parameters`, este é o JSON que será transmitido.

```
{
  "comment": "Selecting what I care about.",
  "MyDetails": {
      "size": "small",
      "exists": "in stock",
      "StaticValue": "foo"
  }
},
```

Além da entrada, é possível acessar um objeto JSON especial, conhecido como o objeto de contexto. O objeto de contexto inclui informações sobre a execução da máquina de estado. Consulte [Acessar dados de execução do objeto de contexto no Step Functions](input-output-contextobject.md).

### Recursos conectados
<a name="input-output-parameters-connected"></a>

O campo `Parameters` também pode transmitir informações para recursos conectados. Por exemplo, se o estado da sua tarefa for orquestrar um AWS Batch trabalho, você poderá passar os parâmetros relevantes da API diretamente para as ações da API desse serviço. Para obter mais informações, consulte:
+ [Transmitir parâmetros a uma API de serviço no Step Functions](connect-parameters.md)
+ [Integração de produtos da ](integrate-services.md)

### Amazon S3
<a name="input-output-parameters-s3"></a>

Se a quantidade de dados da função do Lambda que você está transmitindo entre estados puder ultrapassar 262.144 bytes, recomendamos o uso do Amazon S3 para armazenar os dados e implementar um dos seguintes métodos:
+ Use o *estado Mapa Distribuído* em seu fluxo de trabalho para que o estado `Map` possa ler a entrada diretamente das fontes de dados do Amazon S3. Para obter mais informações, consulte [Modo distribuído](state-map-distributed.md).
+ Analise o nome do recurso da Amazon (ARN) do bucket no parâmetro `Payload` para obter o nome do bucket e o valor da chave. Para obter mais informações, consulte [Usando o Amazon S3 ARNs em vez de transmitir grandes cargas em Step Functions](sfn-best-practices.md#avoid-exec-failures).

Como alternativa, é possível ajustar a implementação para passar cargas menores em suas execuções.

## ResultSelector
<a name="input-output-resultselector"></a>

 Use o campo `ResultSelector` para manipular um resultado do estado antes da aplicação de `ResultPath`. O campo `ResultSelector` permite criar uma coleção de pares de chave-valor, em que os valores são estáticos ou selecionados a partir do resultado do estado. Usando o campo `ResultSelector`, você pode escolher quais partes do resultado de um estado deseja passar para o campo `ResultPath`.

**nota**  
Com o campo `ResultPath`, você pode adicionar a saída do campo `ResultSelector` à entrada original.

`ResultSelector` é um campo opcional nos seguintes estados:
+ [Estado de mapa do fluxo de trabalho](state-map.md)
+ [Estado de tarefa do fluxo de trabalho](state-task.md)
+ [Estado paralelo do fluxo de trabalho](state-parallel.md)

Por exemplo, as integrações de serviço do Step Functions retornam metadados além da carga útil no resultado. `ResultSelector` pode selecionar partes do resultado e mesclá-las com a entrada de estado com `ResultPath`. Neste exemplo, queremos selecionar apenas `resourceType` e `ClusterId` mesclá-los com a entrada de estado de um createCluster.sync do Amazon EMR. Considerando o seguinte:

```
{
  "resourceType": "elasticmapreduce",
  "resource": "createCluster.sync",
  "output": {
    "SdkHttpMetadata": {
      "HttpHeaders": {
        "Content-Length": "1112",
        "Content-Type": "application/x-amz-JSON-1.1",
        "Date": "Mon, 25 Nov 2019 19:41:29 GMT",
        "x-amzn-RequestId": "1234-5678-9012"
      },
      "HttpStatusCode": 200
    },
    "SdkResponseMetadata": {
      "RequestId": "1234-5678-9012"
    },
    "ClusterId": "AKIAIOSFODNN7EXAMPLE"
  }
}
```

Em seguida, você pode selecionar `resourceType` e `ClusterId` usando `ResultSelector`:

```
"Create Cluster": {
  "Type": "Task",
  "Resource": "arn:aws:states:::elasticmapreduce:createCluster.sync",
  "Parameters": {
    <some parameters>
  },
  "ResultSelector": {
    "ClusterId.$": "$.output.ClusterId",
    "ResourceType.$": "$.resourceType"
  },
  "ResultPath": "$.EMROutput",
  "Next": "Next Step"
}
```

Com a entrada fornecida, usar `ResultSelector` gera:

```
{
  "OtherDataFromInput": {},
  "EMROutput": {
      "ClusterId": "AKIAIOSFODNN7EXAMPLE",
      "ResourceType": "elasticmapreduce",
  }
}
```

### Nivelamento de uma matriz de matrizes
<a name="flatten-array-of-arrays-result-selector"></a>

Se o estado [Estado paralelo do fluxo de trabalho](state-parallel.md) ou [Estado de mapa do fluxo de trabalho](state-map.md) em suas máquinas de estado retornar uma matriz de matrizes, você poderá transformá-las em uma matriz nivelada com o campo [ResultSelector](#input-output-resultselector). Você pode incluir esse campo na definição do estado Paralelo ou Mapa para manipular o resultado desses estados.

Para nivelar matrizes, use a sintaxe `[*]` no campo `ResultSelector`, conforme mostrado no exemplo a seguir.

```
"ResultSelector": {
    "flattenArray.$": "$[*][*]"
  }
```

Para exemplos mostrando como nivelar uma matriz, consulte a *Etapa 3* nos seguintes tutoriais:
+ [Processar dados em lote em uma função do Lambda no Step Functions](tutorial-itembatcher-param-task.md)
+ [Processar itens individuais com uma função do Lambda no Step Functions](tutorial-itembatcher-single-item-process.md)