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á.
# Exemplo: manipular dados de estado com caminhos 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).
Este tópico contém exemplos de como manipular JSON de entrada e de saída de estado usando os campos InputPath, ResultPath e OutputPath.
Qualquer estado que não seja [Estado de falha do fluxo de trabalho](state-fail.md) ou [Estado de sucesso do fluxo de trabalho](state-succeed.md) pode incluir os campos de processamento de entrada e saída, como `InputPath`, `ResultPath` ou `OutputPath`. Além disso, os estados [Estado de espera do fluxo de trabalho](state-wait.md) e [Estado de escolha do fluxo de trabalho](state-choice.md) não são compatíveis com o campo `ResultPath`. Com esses campos, você pode usar um [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/) para filtrar os dados JSON à medida que eles se movem pelo seu fluxo de trabalho.
Você também pode usar o campo `Parameters` para manipular os dados JSON à medida que eles se movem pelo seu fluxo de trabalho. Para obter informações sobre como utilizar o `Parameters`, consulte [Manipular parâmetros nos fluxos de trabalho do Step Functions](input-output-inputpath-params.md).
Por exemplo, comece com a função do AWS Lambda e a máquina de estado descrita no tutorial [Como criar uma máquina de estado Step Functions que usa Lambda](tutorial-creating-lambda-state-machine.md). Modifique a máquina de estado para que ela inclua o `InputPath`, o `ResultPath` e o `OutputPath` a seguir.
```
{
"Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:HelloFunction",
"InputPath": "$.lambda",
"ResultPath": "$.data.lambdaresult",
"OutputPath": "$.data",
"End": true
}
}
}
```
Inicie uma execução usando a entrada a seguir.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Suponha que os nós `comment` e `extra` possam ser descartados, mas que você deseja incluir a saída da função do Lambda e preservar as informações no nó `data`.
Na máquina de estado atualizada, o estado `Task` é alterado para processar a entrada para a tarefa.
```
"InputPath": "$.lambda",
```
Essa linha na definição de máquina de estado limita a tarefa de entrada para apenas o nó `lambda` da entrada de estado. A função do Lambda recebe somente o objeto JSON `{"who": "AWS Step Functions"}` como entrada.
```
"ResultPath": "$.data.lambdaresult",
```
Esse `ResultPath` diz à máquina de estado para inserir o resultado da função do Lambda em um nó chamado `lambdaresult`, como um filho do nó `data` na entrada da máquina de estado original. Como você não está realizando nenhuma outra manipulação na entrada original e no resultado usando `OutputPath`, a saída do estado agora inclui o resultado da função do Lambda com a entrada original.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Porém, nosso objetivo era preservar apenas o nó `data` e incluir o resultado da função do Lambda. O `OutputPath` filtra esse JSON combinado antes de transmiti-lo para a saída do estado.
```
"OutputPath": "$.data",
```
Isso seleciona apenas o nó `data` da entrada original (incluindo o filho `lambdaresult` inserido por `ResultPath`) a ser passada para a saída. A saída do estado é filtrada como está a seguir.
```
{
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
}
```
Nesse estado `Task`:
1. O `InputPath` envia somente o nó `lambda` da entrada para a função do Lambda.
1. `ResultPath` insere o resultado como um filho do nó `data` na entrada original.
1. O `OutputPath` filtra a entrada de estado (que agora inclui o resultado da função do Lambda) para que ele transmita somente o nó `data` para a saída de estado.
**Example Para manipular a entrada, o resultado e a saída final da máquina de estado original usando JsonPath**
Considere a seguinte máquina de estado que verifica a identidade e o endereço de um solicitante de seguro.
Para ver o exemplo completo, consulte [Como usar o JSON Path no Step Functions](https://github.com/aws-samples/serverless-account-signup-service).
```
{
"Comment": "Sample state machine to verify an applicant's ID and address",
"StartAt": "Verify info",
"States": {
"Verify info": {
"Type": "Parallel",
"End": true,
"Branches": [
{
"StartAt": "Verify identity",
"States": {
"Verify identity": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:check-identity:$LATEST"
},
"End": true
}
}
},
{
"StartAt": "Verify address",
"States": {
"Verify address": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:check-address:$LATEST"
},
"End": true
}
}
}
]
}
}
}
```
Se você executar essa máquina de estado usando a entrada a seguir, a execução falhará porque as funções do Lambda que realizam a verificação esperam apenas os dados que precisam ser verificados como entrada. Portanto, você deve especificar os nós que contêm as informações a serem verificadas usando um JsonPath apropriado.
```
{
"data": {
"firstname": "Jane",
"lastname": "Doe",
"identity": {
"email": "jdoe@example.com",
"ssn": "123-45-6789"
},
"address": {
"street": "123 Main St",
"city": "Columbus",
"state": "OH",
"zip": "43219"
},
"interests": [
{
"category": "home",
"type": "own",
"yearBuilt": 2004
},
{
"category": "boat",
"type": "snowmobile",
"yearBuilt": 2020
},
{
"category": "auto",
"type": "RV",
"yearBuilt": 2015
},
]
}
}
```
Para especificar o nó que a função do Lambda `check-identity` deve usar, use o campo `InputPath` da seguinte forma:
```
"InputPath": "$.data.identity"
```
E para especificar o nó que a função do Lambda `check-address` deve usar, use o campo `InputPath` da seguinte forma:
```
"InputPath": "$.data.address"
```
Agora, se você quiser armazenar o resultado da verificação na entrada original da máquina de estado, use o campo `ResultPath` da seguinte forma:
```
"ResultPath": "$.results"
```
No entanto, se você precisar apenas dos resultados de identidade e verificação e descartar a entrada original, use o campo `OutputPath` da seguinte forma:
```
"OutputPath": "$.results"
```
Para obter mais informações, consulte [Processar entrada e saída no Step Functions](concepts-input-output-filtering.md).
## Filtrar a saída de estado usando OutputPath
Com o `OutputPath`, é possível selecionar parte da saída de estado para seguir para o próximo estado. Com essa abordagem, é possível filtrar informações indesejáveis e transmitir somente a parte do JSON necessária.
Se você não especificar um `OutputPath`, o valor padrão será `$`. Isso transmitirá todo o nó JSON (determinado pela entrada de estado, o resultado da tarefa e `ResultPath`) para o próximo estado.