Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Ejemplo: Manipulación de datos de estado con rutas en flujos de trabajo de Step Functions
**Administración del estado y transformación de los datos**
Obtenga información sobre la [Transmisión de datos entre estados con variables](workflow-variables.md) y la [Transformación de datos con JSONata](transforming-data.md).
Este tema contiene ejemplos de cómo manipular el JSON de entrada y salida de estado mediante los campos InputPath, ResultPath y OutputPath.
Cualquier estado que no sea un estado [Estado de flujo de trabajo con error](state-fail.md) o un estado [Estado Succeed de un flujo de trabajo](state-succeed.md) puede incluir los campos de procesamiento de entrada y salida, tales como `InputPath`, `ResultPath` o `OutputPath`. Además, los estados [Estado Wait de un flujo de trabajo](state-wait.md) y [Estado del flujo de trabajo de elección](state-choice.md) no admiten el campo `ResultPath`. Con estos campos, puede usar [JSONPath](https://datatracker.ietf.org/wg/jsonpath/about/) para filtrar los datos JSON a medida que avanzan por el flujo de trabajo.
También puede usar el campo `Parameters` para manipular los datos JSON a medida que avanzan por el flujo de trabajo. Para obtener más información sobre del uso de `Parameters`, consulte [Manipulación de los parámetros en los flujos de trabajo de Step Functions](input-output-inputpath-params.md).
Por ejemplo, comience por la función de AWS Lambda y la máquina de estado que se describe en el tutorial [Creación de una máquina de estado de Step Functions que utilice Lambda](tutorial-creating-lambda-state-machine.md). Modifique la máquina de estado de forma que incluya el siguiente `InputPath`, `ResultPath` y `OutputPath`.
```
{
"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 una ejecución utilizando la siguiente entrada.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Supongamos que los nodos `comment` y `extra` se puedan descartar, pero que desea incluir la salida de la función de Lambda y conservar la información en el nodo `data`.
En la máquina de estado actualizada, el estado `Task` se modifica para procesar la entrada a la tarea.
```
"InputPath": "$.lambda",
```
Esta línea en la definición de la máquina de estado limita la entrada de tarea a solo el nodo `lambda` de la entrada del estado. La función de Lambda recibe solo el objeto JSON `{"who": "AWS Step Functions"}` como entrada.
```
"ResultPath": "$.data.lambdaresult",
```
Esta `ResultPath` indica a la máquina de estado que inserte el resultado de la función de Lambda en un nodo denominado `lambdaresult`, como elemento secundario del nodo `data` de la entrada de la máquina de estado original. Como no está realizando ninguna otra manipulación en la entrada original y en el resultado que utiliza `OutputPath`, la salida del estado ahora incluye el resultado de la función de Lambda con la entrada original.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Sin embargo, nuestro objetivo era conservar únicamente el nodo `data` e incluir el resultado de la función de Lambda. `OutputPath` filtra este JSON combinado antes de pasárselo al resultado del estado.
```
"OutputPath": "$.data",
```
Esto selecciona solo el nodo `data` de la entrada original (incluido el nodo secundario `lambdaresult` insertado por `ResultPath`) para pasarlo a la salida. La salida del estado se filtra para mostrar lo siguiente.
```
{
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
}
```
En este estado `Task`:
1. `InputPath` envía solo el nodo `lambda` desde la entrada a la función de Lambda.
1. `ResultPath` inserta el resultado como un elemento secundario del nodo `data` de la entrada original.
1. `OutputPath` filtra la entrada del estado (que ahora incluye el resultado de la función de Lambda) de forma que solo transfiere el nodo `data` a la salida del estado.
**Example para manipular la entrada, el resultado y la salida final de la máquina de estado original mediante JSONPath**
Considere la siguiente máquina de estado que verifica la identidad y la dirección de un solicitante de seguro.
Para ver el ejemplo completo, consulte [Cómo usar la ruta JSON in 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
}
}
}
]
}
}
}
```
Si ejecuta esta máquina de estado con la siguiente entrada, la ejecución producirá un error, porque las funciones de Lambda que realizan la verificación solo esperan los datos que deben verificarse como entrada. Por lo tanto, debe especificar los nodos que contienen la información que se va a verificar mediante un valor de JSONPath adecuado.
```
{
"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 el nodo que debe usar la función de Lambda `check-identity`, utilice el campo `InputPath` de la siguiente manera:
```
"InputPath": "$.data.identity"
```
Y para especificar el nodo que debe utilizar la función de Lambda `check-address`, utilice el campo `InputPath` de la siguiente manera:
```
"InputPath": "$.data.address"
```
Ahora, si desea almacenar el resultado de la verificación en la entrada original de la máquina de estado, utilice el campo `ResultPath` de la siguiente manera:
```
"ResultPath": "$.results"
```
Sin embargo, si solo necesita los resultados de identidad y verificación y descarta la entrada original, utilice el campo `OutputPath` de la siguiente manera:
```
"OutputPath": "$.results"
```
Para obtener más información, consulte [Procesamiento de entradas y salidas en Step Functions](concepts-input-output-filtering.md).
## Filtrado de la salida de estado mediante OutputPath
`OutputPath` le permite seleccionar una parte de la salida de estado para pasar al siguiente estado. Con este enfoque, puede filtrar la información no deseada y transmitir solo la parte del JSON que necesite.
Si no especifica una `OutputPath`, el valor predeterminado es `$`. Esto pasa todo el nodo JSON (determinado por la entrada de estado, el resultado de la tarea y `ResultPath`) al siguiente estado.