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.
# Procesamiento de entradas y salidas en Step Functions
**Administrar el estado con variables y JSONata**
Step Functions agregó recientemente variables y JSONata para administrar el estado y transformar los datos.
Obtenga más información en la entrada del blog [Simplificar la experiencia del desarrollador con variables y JSONata ](https://aws.amazon.com/blogs/compute/simplifying-developer-experience-with-variables-and-jsonata-in-aws-step-functions/) en AWS Step Functions
Cuando una ejecución de Step Functions recibe una entrada JSON, pasa dichos datos al primer estado en el flujo de trabajo como entrada.
Con JSONata, puede recuperar la entrada de estado de`$states.input`. Las ejecuciones de su máquina de estado también proporcionan esos datos de entrada iniciales en el [Objeto Context (Contexto)](input-output-contextobject.md). Puede recuperar la entrada original de la máquina de estado en cualquier punto de su flujo de trabajo desde `$states.context.Execution.Input`.
Cuando los estados terminan, su salida está disponible para el *siguiente* estado de la máquina de estado. Las entradas del estado pasarán de forma predeterminada como salida de estado, a menos que **modifique** la salida del estado. Para los datos que pueda necesitar en pasos posteriores, considere la posibilidad de almacenarlos en variables. Para obtener más información, consulte [Transmisión de datos entre estados con variables](workflow-variables.md).
**QueryLanguage recomendación**
Para las nuevas máquinas de estado, recomendamos el lenguaje de JSONata consulta. En las máquinas de estados que no especifican un idioma de consulta, el valor predeterminado de la máquina de estados es JSONPath para garantizar la compatibilidad con versiones anteriores. Debe optar por utilizarla JSONata para sus máquinas de estados o estados individuales.
**Procesando entradas y salidas con JSONata**
Con JSONata las expresiones, puede seleccionar y transformar datos. En el campo `Arguments`, puede personalizar los datos que se envían a la acción. El resultado se puede transformar en una salida de estado personalizada en el campo `Output`. También puede almacenar datos en variables en el campo `Assign`. Para obtener más información, consulte [Transformar datos con JSONata](transforming-data.md).
El siguiente diagrama muestra cómo se mueve la información de JSON a través del estado de una JSONata tarea.
![\[Diagram showing JSONata task state flow with input, arguments, output, and action components.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/vars-jsonata.png)
**Procesar la entrada y la salida con JSONPath**
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
Para las máquinas de estados que las utilizan JSONPath, los siguientes campos controlan el flujo de datos de un estado a `InputPath` otro:`Parameters`,`ResultSelector`,`ResultPath`, y`OutputPath`. Cada JSONPath campo puede manipular JSON a medida que se mueve por cada estado del flujo de trabajo.
JSONPath los campos pueden usar [rutas](amazon-states-language-paths.md) para seleccionar partes del JSON de la entrada o del resultado. Una ruta es una cadena, que empieza por `$` e identifica nodos dentro de texto JSON. Las rutas de Step Functions utilizan [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)sintaxis.
El siguiente diagrama muestra cómo se mueve la información de JSON a través del estado de una JSONPath tarea. `InputPath`Selecciona las partes de la entrada JSON para pasarlas a la tarea del `Task` estado (por ejemplo, una AWS Lambda función). Puede ajustar los datos que se envían a su acción en el campo `Parameters`. A continuación, con `ResultSelector`, puede seleccionar partes del resultado de la acción para transferirlas. `ResultPath` selecciona la combinación de entrada de estado y resultados de la tarea para pasarlos a la salida. `OutputPath` puede filtrar la salida JSON para limitar aún más la información que se pasa a la salida.
![\[Orden de los filtros: InputPath, Parámetros ResultSelector, ResultPath, y OutputPath.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/vars-jsonpath.png)
**Topics**
+ [Transmisión de datos entre estados con variables](workflow-variables.md)
+ [Transformación de datos con JSONata In Step Functions](transforming-data.md)
+ [Acceso a los datos de ejecución desde el objeto Context en Step Functions](input-output-contextobject.md)
+ [Uso de JSONPath rutas](amazon-states-language-paths.md)
+ [Manipulación de los parámetros en los flujos de trabajo de Step Functions](input-output-inputpath-params.md)
+ [Ejemplo: Manipulación de datos de estado con rutas en flujos de trabajo de Step Functions](input-output-example.md)
+ [Especificación de la salida de estado mediante ResultPath Step Functions](input-output-resultpath.md)
+ [Campos de entrada y salida del estado Map en Step Functions](input-output-fields-dist-map.md)
# Transmisión de datos entre estados con variables
**Administración del estado con variables y JSONata**
Step Functions ha agregado recientemente variables y JSONata para administrar el estado y transformar los datos.
Obtenga más información en la entrada del blog [Simplifying developer experience with variables and JSONata in AWS Step Functions](https://aws.amazon.com/blogs/compute/simplifying-developer-experience-with-variables-and-jsonata-in-aws-step-functions/)
En el siguiente vídeo se describen las variables y JSONata en Step Functions con un ejemplo de DynamoDB:
Con las variables y la salida de estado, puede transmitir datos entre los pasos de su flujo de trabajo.
Con las variables de flujo de trabajo, puede almacenar datos en un paso y recuperarlos en pasos futuros. Por ejemplo, puede almacenar una respuesta de la API que contenga los datos que puede que necesite más adelante. Por el contrario, la salida de estado solo se puede usar como entrada para el siguiente paso.
## Resumen conceptual de las variables
Con las variables de flujo de trabajo, puede almacenar datos para consultarlos más adelante. Por ejemplo, el paso 1 puede almacenar el resultado de una solicitud de API para que una parte de esa solicitud pueda reutilizarse más adelante en el paso 5.
En el siguiente escenario, la máquina de estado obtiene los datos de una API una vez. En el paso 1, el flujo de trabajo almacena los datos de la API devueltos (hasta 256 KiB por estado) en una variable “x” para utilizarlos en pasos posteriores.
Sin variables, sería necesario pasar los datos a través de la salida del paso 1 al paso 2, al paso 3 y al paso 4 para usarlos en el paso 5. ¿Qué pasa si esos pasos intermedios no necesitan los datos? Pasar los datos de un estado a otro a través de las salidas y las entradas supondría un esfuerzo innecesario.
Con las variables, puede almacenar datos y utilizarlos en cualquier paso futuro. También puede modificar, reorganizar o añadir pasos sin interrumpir el flujo de los datos. Dada la flexibilidad de las variables, es posible que solo necesite usar la **salida** para devolver datos de los subflujos de trabajo Parallel y Map, y al final de la ejecución de la máquina de estado.
![\[Diagram showing step 1 assigning a value to $x, used in step 5.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/vars-diag-opt1.png)
**Estados que admiten variables**
Los siguientes tipos de estado admiten `Assign` para declarar y asignar valores a las variables: *Pass, Task, Map, Parallel, Choice, Wait.*
Para configurar una variable, proporcione un objeto JSON con nombres y valores de variables:
```
"Assign": {
"productName": "product1",
"count" : 42,
"available" : true
}
```
Para hacer referencia a una variable, anexe al nombre un signo de dólar (`$`), por ejemplo, `$productName`.
## Variable reservada: \$1states
Step Functions define una única variable reservada llamada **`$states`**. En los estados de JSONata, se asignan las siguientes estructuras a `$states` para su uso en las expresiones de JSONata:
```
# Reserved $states variable in JSONata states
$states = {
"input": // Original input to the state
"result": // API or sub-workflow's result (if successful)
"errorOutput": // Error Output (only available in a Catch)
"context": // Context object
}
```
Al introducir un estado, Step Functions asigna la entrada de estado a **`$states.input`**. El valor de `$states.input` se puede utilizar en todos los campos que acepten expresiones de JSONata. `$states.input` siempre hace referencia a la entrada de estado original.
Para los estados `Task`, `Parallel`, y `Map`:
+ **`$states.result`** hace referencia al resultado sin procesar de la API o del subflujo de trabajo si se ha realizado correctamente.
+ **`$states.errorOutput`** hace referencia a la salida de error si la API o el subflujo de trabajo produjo un error.
`$states.errorOutput` se puede usar en `Assign` u `Output` del campo `Catch`.
Al crear, actualizar o validar la máquina de estado se detectarán los intentos de acceso a `$states.result` o `$states.errorOutput` en campos y estados que no son accesibles.
El objeto `$states.context` brinda a sus flujos de trabajo información sobre su ejecución específica, como `StartTime`, el token de la tarea y la entrada inicial del flujo de trabajo. Para obtener más información, consulte [Acceso a los datos de ejecución desde el objeto Context en Step Functions](input-output-contextobject.md).
## Sintaxis de nombre de variable
Los nombres de las variables siguen las reglas de los identificadores Unicode, tal como se describe en el [Unicode® Standard Annex \$131](https://unicode.org/reports/tr31/). El primer carácter del nombre de una variable debe ser un carácter ID\$1Start de Unicode y el segundo y los siguientes caracteres deben ser caracteres ID\$1Continue de Unicode. La longitud máxima de un nombre de variable es 80.
La convención de nombres de variables es similar a las reglas de JavaScript y otros lenguajes de programación.
## Ámbito de la variable
Los flujos de trabajo de Step Functions evitan las condiciones de carrera con variables mediante el uso de un ámbito *local del flujo de trabajo*.
El ámbito local del flujo de trabajo incluye todos los estados dentro del campo **Estados** de una máquina de estado, pero no los estados dentro de los estados Parallel o Map. Los estados dentro de los estados Parallel o Map pueden hacer referencia a variables de ámbito externo, pero crean y mantienen sus propias variables y valores locales del flujo de trabajo independientes.
Las ramas `Parallel` y las iteraciones `Map` pueden acceder a los valores de las variables desde **ámbitos externos**, pero no tienen acceso a los valores de las variables de otras ramas o iteraciones simultáneas. Al gestionar los errores, el campo `Assign` de un `Catch` puede asignar valores a las variables del ámbito externo, es decir, el ámbito en el que existe el estado Parallel/Map.
Excepción: Los **estados Distributed Map** no pueden hacer referencia actualmente a variables en ámbitos externos.
Una variable existe en un ámbito si algún estado del ámbito le asigna un valor. Para evitar errores comunes, una variable asignada en un ámbito interno no puede tener el mismo nombre que una asignada en un ámbito externo. Por ejemplo, si el ámbito de nivel superior asigna un valor a una variable llamada `myVariable`, ningún otro ámbito (dentro de `Map`, `Parallel`) podrá asignarlo también a `myVariable`.
El acceso a las variables depende del ámbito actual. Los estados Parallel y Map tienen su propio ámbito, pero pueden acceder a variables de ámbitos externos.
Cuando se complete un estado Parallel o Map, todas sus variables quedarán fuera del ámbito y dejarán de ser accesibles. Utilice el **campo Output** para pasar los datos de las ramas Parallel y de las iteraciones Map.
## Asignación de campo en ASL
El campo `Assign` en ASL se usa para asignar valores a una o más variables. El campo `Assign` está disponible en el nivel superior de cada estado (excepto `Succeed` y `Fail`), dentro de las reglas de estado `Choice` y dentro de los campos `Catch`. Por ejemplo:
```
# Example of Assign with JSONata
"Store inputs": {
"Type": "Pass",
"Next": "Get Current Price",
"Comment": "Store the input desired price into a variable: $desiredPrice",
"Assign": {
"desiredPrice": "{% $states.input.desired_price %}",
"maximumWait": "{% $states.input.max_days %}"
}
},
```
El campo `Assign` toma un objeto JSON. Cada campo de nivel superior nombra una variable para asignarla. En los ejemplos anteriores, los nombres de las variables son `desiredPrice` y `maximumWait`. Cuando se utiliza JSONata, `{% ... %}` indica una expresión de JSONata que puede contener variables o expresiones más complejas. Para obtener más información sobre las expresiones de JSONata, consulte la [documentación de JSONata.org](https://docs.jsonata.org/overview.html).
Cuando se utiliza **JSONata** como lenguaje de consulta, el siguiente diagrama muestra cómo se procesan en paralelo los campos **Assign** y **Output**. Tenga en cuenta lo que implica: *la asignación de valores variables no afectará a la salida del estado.*
![\[Diagram showing a comparison of JSONPath and JSONata flow.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/vars-jsonata.png)
En el siguiente ejemplo de JSONata se recupera `order.product` desde la entrada del estado. La variable `currentPrice` se establece en un valor del resultado de la tarea.
```
# Example of Task with JSONata assignment from result
{
"Type": "Task",
...
"Assign": {
"product": "{% $states.input.order.product %}",
"currentPrice": "{% $states.result.Payload.current_price %}"
},
"Next": "the next state"
}
```
Nota: **No puede** asignar un valor a una parte de una variable. Por ejemplo, puede `"Assign":{"x":42}`, pero no puede `"Assign":{"x.y":42}` o `"Assign":{"x[2]":42}`.
## Orden de evaluación en un campo de asignación
Todas las referencias de variables en los estados de Step Functions utilizan los valores tal como estaban en la **entrada del estado**.
El hecho anterior es importante para entender cómo el campo `Assign` asigna valores a una o más variables. En primer lugar, se calculan los nuevos valores y, a continuación, Step Functions asigna los nuevos valores a las variables. Los nuevos valores de las variables estarán disponibles a partir del **siguiente **estado. Por ejemplo, considere el siguiente campo `Assign`:
```
# Starting values: $x=3, $a=6
"Assign": {
"x": "{% $a %}",
"nextX": "{% $x %}"
}
# Ending values: $x=6, $nextX=3
```
En el ejemplo anterior, se asigna la variable `x` y se hace referencia a ella.
Recuerde que ***primero se evalúan*** todas las expresiones y, a continuación, se realizan las asignaciones. Los valores recién asignados estarán disponibles en el **siguiente** estado.
Repasemos el ejemplo en detalle. Supongamos que, en un estado anterior, a `$x` se le asignó un valor de tres (3) y a `$a` se le asignó a un valor de seis (6). Los siguientes pasos describen el proceso:
1. Todas las expresiones se evalúan utilizando los valores **actuales** de todas las variables.
La expresión `"{% $a %}"` se evaluará como 6 y `"{% $x %}"` se evaluará como 3.
1. A continuación, se realizan las asignaciones:
A `$x` se le asignará el valor seis (6)
A `$nextX` se le asignará tres (3)
Nota: Si `$x` no se hubiera asignado previamente, el ejemplo **generaría un error** porque `$x` estaría *sin definir*.
En resumen, Step Functions evalúa **todas** las expresiones y, a continuación, realiza las asignaciones. **No** importa el orden en que aparecen las variables en el campo `Assign`.
## Límites
El tamaño máximo de una única variable es de 256 KiB, tanto para los flujos de trabajo estándar como rápidos.
El tamaño máximo combinado de todas las variables de un único campo `Assign` también es de 256 KiB. Por ejemplo, puede asignar X e Y a 128 KiB, pero no puede asignar X e Y a 256 KiB en el mismo campo `Assign`.
El tamaño total de todas las variables almacenadas no puede superar los 10 MiB por ejecución.
## Uso de variables en los estados de JSONPath
Las variables también están disponibles en los estados que utilizan JSONPath como lenguaje de consulta.
Puede hacer referencia a una variable en cualquier campo que acepte una expresión de JSONPath (sintaxis `$.` o `$$.`), a excepción de `ResultPath`, que especifica una ubicación en la entrada de estado para inyectar el resultado del estado. No se pueden usar variables en `ResultPath`.
En JSONPath, el símbolo `$` hace referencia al valor “actual” y `$$` representa el objeto Context del estado. Las expresiones de JSONPath pueden empezar con `$.` como en `$.customer.name`. Puede acceder al contexto con `$$.` como en `$$.Execution.Id`.
Para hacer referencia a una variable, también se utiliza el símbolo `$` antes del nombre de la variable, por ejemplo, `$x` o `$order.numItems`.
En los campos de **JSONPath** que aceptan funciones intrínsecas, las variables se pueden utilizar en los argumentos, por ejemplo `States.Format('The order number is {}', $order.number)`.
En el siguiente diagrama se ilustra cómo el paso de asignación de una tarea de **JSONPath** se produce al mismo tiempo que el ResultSelector:
![\[Logical diagram of a state that uses JSONPath query language.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/vars-jsonpath.png)
**Asignación de variables en JSONPath**
Las asignaciones de variables de JSONPath se comportan de forma similar a las plantillas de carga útil. Los campos que terminan con `.$` indican que el valor es una expresión de JSONPath que Step Functions evalúa como un valor durante la ejecución de la máquina de estado (por ejemplo: `$.order..product` y `$.order.total`).
```
# Example of Assign with JSONPath
{
"Type": "Task",
...
"Assign": {
"products.$": "$.order..product",
"orderTotal.$": "$.order.total"
},
"Next": "the next state"
}
```
En el caso de los estados de JSONPath, el valor de `$` en un campo `Assign` depende del tipo de estado. En los estados `Task,` `Map`, `Parallel`, `$` hace referencia al resultado de la API/subflujo de trabajo. En el estado `Choice` y `Wait`, `$` hace referencia a la *entrada efectiva*, que es el valor después de que `InputPath` se haya aplicado a la entrada de estado. Para `Pass`, `$` hace referencia al resultado, ya sea generado por el campo `Result` o por los campos `InputPath`/`Parameters`.
En el siguiente ejemplo de JSONPath se asigna un objeto JSON a la variable `details`, el resultado de la expresión de JSONPath `$.result.code` a `resultCode` y el resultado de la expresión de JSONPath `States.Format('Hello {}', $customer.name)` a `message`. Si estaba en un estado `Task`, entonces `$` en `$.order.items` y `$.result.code` hace referencia al resultado de la API. A la variable `startTime` se le asigna un valor del objeto Context, `$$.Execution.StartTime`.
```
"Assign": {
"details": {
"status": "SUCCESS",
"lineItems.$": "$.order.items"
},
"resultCode.$": "$.result.code",
"message.$": "States.Format('Hello {}', $customer.name)",
"startTime.$": "$$.Execution.StartTime"
}
```
# Transformación de datos con JSONata In Step Functions
Con JSONata él, obtiene un potente lenguaje de consultas y expresiones de código abierto para **seleccionar** y **transformar** los datos en sus flujos de trabajo. Para obtener una breve introducción y una JSONata referencia completa, consulte la [documentación de JSONata .org](https://docs.jsonata.org/overview.html).
**JSONata Versión compatible**
Step Functions es compatible con JSONata la versión 2.0.6.
En el siguiente vídeo se describen las variables y, JSONata en Step Functions, con un ejemplo de DynamoDB:
Debe optar por utilizar el lenguaje de JSONata consulta y transformación para los flujos de trabajo existentes. Al crear un flujo de trabajo en la consola, le recomendamos que elija la JSONata máquina de estados de nivel superior. `QueryLanguage` Para los flujos de trabajo nuevos o existentes que se utilicen JSONPath, la consola ofrece una opción para convertir estados individuales en. JSONata
Tras JSONata seleccionarlos, los campos del flujo de trabajo se reducirán de cinco JSONPath campos (`InputPath``Parameters``ResultSelector``ResultPath`,, y`OutputPath`) a solo dos campos: `Arguments` y`Output`. Además, **no** utilizará `.$` en nombres clave de objetos JSON.
Si es la primera vez que utiliza Step Functions, solo necesita saber que JSONata las expresiones utilizan la siguiente sintaxis:
**JSONata sintaxis:** `"{% %}"`
Los siguientes ejemplos de código muestran una conversión de JSONPath a JSONata:
```
# Original sample using JSONPath
{
"QueryLanguage": "JSONPath", // Set explicitly; could be set and inherited from top-level
"Type": "Task",
...
"Parameters": {
"static": "Hello",
"title.$": "$.title",
"name.$": "$customerName", // With $customerName declared as a variable
"not-evaluated": "$customerName"
}
}
```
```
# Sample after conversion to JSONata
{
"QueryLanguage": "JSONata", // Set explicitly; could be set and inherited from top-level
"Type": "Task",
...
"Arguments": { // JSONata states do not have Parameters
"static": "Hello",
"title": "{% $states.input.title %}",
"name": "{% $customerName %}", // With $customerName declared as a variable
"not-evaluated": "$customerName"
}
}
```
Con la entrada `{ "title" : "Doctor" }` y la variable `customerName` asignadas a `"María"`, ambas máquinas de estado producirán el siguiente resultado de JSON:
```
{
"static": "Hello",
"title": "Doctor",
"name": "María",
"not-evaluated": "$customerName"
}
```
En el siguiente diagrama, puede ver una representación gráfica que muestra cómo la conversión JSONPath (izquierda) a JSONata (derecha) reducirá la complejidad de los pasos en sus máquinas de estado:
![\[Diagrama que compara los campos de los JSONata estados JSONPath y los estados.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/compare-jsonpath-jsonata.png)
Puede (opcionalmente) seleccionar y transformar los datos de la entrada de estado en **argumentos** para enviarlos a la acción integrada. A continuación JSONata, puede (opcionalmente) seleccionar y transformar **los resultados** de la acción para asignarlos a las variables y para obtener el estado **Salida**.
Nota: Los pasos **Assign** y **Output** se producen en **paralelo**. Si decide transformar los datos durante la asignación de variables, esos datos transformados **no** estarán disponibles en el paso Output. Debe volver a aplicar la JSONata transformación en el paso de salida.
![\[Diagrama lógico de un estado que utiliza un lenguaje de JSONata consulta.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/vars-jsonata.png)
## QueryLanguage campo
En las definiciones de ASL de su flujo de trabajo, hay un campo `QueryLanguage` en el nivel superior de la definición de una máquina de estado y en los estados individuales. Al configurar estados `QueryLanguage` internos individuales, puede adoptarlos de forma incremental JSONata en una máquina de estados existente en lugar de actualizarla de una sola vez.
El campo `QueryLanguage` se puede definir en `"JSONPath"` o `"JSONata"`. Si se omite el campo de nivel superior `QueryLanguage`, el valor predeterminado es `"JSONPath"`. Si un estado contiene un campo de nivel de estado `QueryLanguage`, Step Functions utilizará el lenguaje de consulta especificado para ese estado. Si el estado no contiene ningún campo `QueryLanguage`, utilizará el lenguaje de consulta especificado en el campo de nivel superior `QueryLanguage`.
## Escribir JSONata expresiones en cadenas JSON
Cuando una cadena del valor de un campo ASL, un campo de objeto JSON o un elemento de matriz JSON está rodeada de `{% %}` caracteres, esa cadena se evaluará como JSONata . Tenga en cuenta que la cadena debe empezar con `{%` sin espacios iniciales y debe terminar con `%}` sin espacios finales. Si abre o cierra la expresión de forma incorrecta, se producirá un error de validación.
Presentamos algunos ejemplos:
+ `"TimeoutSeconds" : "{% $timeout %}"`
+ `"Arguments" : {"field1" : "{% $name %}"}` en un estado `Task`
+ `"Items": [1, "{% $two %}", 3]` en un estado `Map`
No todos los campos de ASL son aceptables. JSONata Por ejemplo, el campo `Type` de cada estado se debe establecer en una cadena constante. Del mismo modo, el campo `Resource` del estado `Task` debe ser una cadena constante. El `Items` campo de `Map` estado aceptará una matriz JSON, un objeto JSON o una JSONata expresión que deba dar como resultado una matriz u objeto.
## Variable reservada: \$1states
Step Functions define una única variable reservada llamada **`$states`**. En JSONata los estados, se asignan las siguientes estructuras `$states` para su uso en JSONata las expresiones:
```
# Reserved $states variable in JSONata states
$states = {
"input": // Original input to the state
"result": // API or sub-workflow's result (if successful)
"errorOutput": // Error Output (only available in a Catch)
"context": // Context object
}
```
Al introducir un estado, Step Functions asigna la entrada de estado a **`$states.input`**. El valor de se `$states.input` puede usar en todos los campos que aceptan JSONata expresiones. `$states.input`siempre hace referencia a la entrada de estado original.
Para los estados `Task`, `Parallel`, y `Map`:
+ **`$states.result`**se refiere al resultado bruto de la API o del subflujo de trabajo si se ha realizado correctamente.
+ **`$states.errorOutput`**hace referencia a la salida de error si la API o el subflujo de trabajo fallaron.
`$states.errorOutput` se puede usar en `Assign` u `Output` del campo `Catch`.
Al crear, actualizar o validar la máquina de estado se detectarán los intentos de acceso a `$states.result` o `$states.errorOutput` en campos y estados que no son accesibles.
El objeto `$states.context` brinda a sus flujos de trabajo información sobre su ejecución específica, como `StartTime`, el token de la tarea y la entrada inicial del flujo de trabajo. Para obtener más información, consulte[Acceso a los datos de ejecución desde el objeto Context en Step Functions](input-output-contextobject.md).
## Gestión de errores de expresión
En tiempo de ejecución, JSONata la evaluación de la expresión puede fallar por varios motivos, como los siguientes:
+ **Error de tipo**: una expresión, como `{% $x + $y %}`, fallará si `$x` o `$y` no es un número.
+ **Incompatibilidad de tipo**: una expresión podría evaluarse como un tipo que el campo no aceptará. Por ejemplo, el campo `TimeoutSeconds` requiere una entrada numérica, por lo que la expresión `{% $timeout %}` fallará si `$timeout` devuelve una cadena.
+ **Valor fuera de rango**: una expresión que produzca un valor que se encuentra fuera del rango aceptable de un campo producirá un error. Por ejemplo, una expresión como `{% $evaluatesToNegativeNumber %}` fallará en el campo `TimeoutSeconds`.
+ **Error de devolución de un resultado**: JSON no puede representar una expresión de valor indefinido, por lo que la expresión `{% $data.thisFieldDoesNotExist %}` generaría un error.
En cada caso, el intérprete generará el error: `States.QueryEvaluationError`. Los estados Task, Map y Parallel pueden proporcionar un campo `Catch` para que detecte el error y un campo `Retry` para volver a intentarlo en caso de error.
## Convertir de JSONPath a JSONata
En las siguientes secciones se comparan y explican las diferencias entre el código escrito con JSONPath y JSONata.
### No más campos de ruta
El ASL requiere que los desarrolladores usen `Path` versiones de los campos, por `TimeoutSecondsPath` ejemplo, para seleccionar un valor de los datos de estado al usarlos JSONPath. Cuando los usa JSONata, deja de usar `Path` campos porque ASL interpretará automáticamente JSONata las expresiones `{% %}` cerradas en campos que no sean de Path, como. `TimeoutSeconds`
+ JSONPath ejemplo heredado: `"TimeoutSecondsPath": "$timeout"`
+ JSONata : `"TimeoutSeconds": "{% $timeout %}"`
Del mismo modo, el `Map` estado se `ItemsPath` ha sustituido por el `Items` campo que acepta una matriz JSON, un objeto JSON o una JSONata expresión que debe dar como resultado una matriz u objeto.
### Objetos JSON
ASL usa el término *plantilla de carga útil* para describir un objeto JSON que puede contener JSONPath expresiones `Parameters` y valores de `ResultSelector` campo. ASL no utilizará el término plantilla de carga útil JSONata porque la JSONata evaluación se realiza para todas las cadenas, independientemente de que se produzcan por sí solas o dentro de un objeto JSON o una matriz JSON.
### No más .\$1
ASL requiere que añadas '`.$`' a los nombres de campo de las plantillas de carga útil que vayas a utilizar y a las funciones intrínsecas. JSONPath Al especificar `"QueryLanguage":"JSONata"`, ya no se utiliza la convención “`.$`” para nombres de campo de objetos JSON. En su lugar, encierra las expresiones entre caracteres JSONata . `{% %}` Utiliza la misma convención para todos los campos con valores de cadena, independientemente de la profundidad con la que se encuentre el objeto dentro de otras matrices u objetos.
### Campos Arguments y Output
Si `QueryLanguage` se establece en`JSONata`, los campos de I/O procesamiento antiguos se deshabilitarán (`InputPath`, `Parameters``ResultSelector`, `ResultPath` y`OutputPath`) y la mayoría de los estados tendrán dos campos nuevos: `Arguments` y`Output`.
JSONata proporciona una forma más sencilla de realizar I/O transformaciones en comparación con los campos utilizados con JSONPath. JSONatasus características hacen que sea `Arguments` `Output` más capaz que los cinco campos anteriores con JSONPath. Estos nuevos nombres de campo también ayudan a simplificar el ASL y a aclarar el modelo para pasar y devolver valores.
Los campos `Arguments` y `Output` (y otros campos similares, como los del estado `Map` `ItemSelector`) aceptarán un objeto JSON, como:
```
"Arguments": {
"field1": 42,
"field2": "{% jsonata expression %}"
}
```
O bien, puedes usar una JSONata expresión directamente, por ejemplo:
```
"Output": "{% jsonata expression %}"
```
La salida también puede aceptar cualquier tipo de valor JSON, por ejemplo: `"Output":true`, `"Output":42`.
Los `Output` campos `Arguments` y solo son compatibles JSONata, por lo que no es válido usarlos con flujos de trabajo que sí los utilicen JSONPath. Por el contrario `InputPath` `Parameters``ResultSelector`, solo se admiten los campos `ResultPath``OutputPath`,,,, y otros JSONPath campos JSONPath, por lo que no es válido utilizar campos basados en rutas cuando se utilizan JSONata como flujo de trabajo de nivel superior o como lenguaje de consulta de estado.
### Estado de paso
El **Resultado** opcional en un estado Pass se trataba anteriormente como el *resultado* de una tarea virtual. Con el idioma JSONata seleccionado como flujo de trabajo o consulta de estado, ahora puede usar el nuevo campo **de salida**.
### Estado Choice
Cuando se utilizan JSONPath, los estados de elección tienen una entrada `Variable` y numerosas rutas de comparación, como las siguientes`NumericLessThanEqualsPath`:
```
# JSONPath choice state sample, with Variable and comparison path
"Check Price": {
"Type": "Choice",
"Default": "Pause",
"Choices": [
{
"Variable": "$.current_price.current_price",
"NumericLessThanEqualsPath": "$.desired_price",
"Next": "Send Notification"
} ],
}
```
Con JSONata, el estado de elección tiene un `Condition` lugar en el que puede usar una JSONata expresión:
```
# Choice state after JSONata conversion
"Check Price": {
"Type": "Choice",
"Default": "Pause"
"Choices": [
{
"Condition": "{% $current_price <= $states.input.desired_priced %}",
"Next": "Send Notification"
} ]
```
Nota: Las variables y los campos de comparación solo están disponibles para JSONPath. La condición solo está disponible para JSONata.
## JSONata ejemplos
Los siguientes ejemplos se pueden crear en Workflow Studio para experimentar con ellos JSONata. Puede crear y ejecutar las máquinas de estado o utilizar el **estado Pass** para pasar datos e incluso modificar la definición de la máquina de estado.
### Ejemplo: entrada y salida
En este ejemplo, se muestra cómo `$states.input` utilizar la entrada de estado y el `Output` campo para especificar la salida de estado cuando se opta por ello JSONata.
```
{
"Comment": "Input and Output example using JSONata",
"QueryLanguage": "JSONata",
"StartAt": "Basic Input and Output",
"States": {
"Basic Input and Output": {
"QueryLanguage": "JSONata",
"Type": "Succeed",
"Output": {
"lastName": "{% 'Last=>' & $states.input.customer.lastName %}",
"orderValue": "{% $states.input.order.total %}"
}
}
}
}
```
Cuando el flujo de trabajo se ejecuta con lo siguiente como entrada:
```
{
"customer": {
"firstName": "Martha",
"lastName": "Rivera"
},
"order": {
"items": 7,
"total": 27.91
}
}
```
El estado Test o la ejecución de la máquina de estado devolverá la siguiente salida JSON:
```
{
"lastName": "Last=>Rivera",
"orderValue": 27.91
}
```
![\[Captura de pantalla que muestra la entrada y la salida de un estado sometido a prueba.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/jsonata-basic-io.png)
### Ejemplo: filtrar con JSONata
Puede filtrar los datos con los [operadores de JSONata ruta](https://docs.jsonata.org/path-operators). Por ejemplo, imagine que tiene una lista de productos para introducir y solo quiere procesar productos que contienen cero calorías. Puede crear una definición de máquina de estado con la siguiente ASL y probar el estado `FilterDietProducts` con la entrada de ejemplo que aparece a continuación.
**Indique la definición de la máquina con la que filtrar JSONata**
```
{
"Comment": "Filter products using JSONata",
"QueryLanguage": "JSONata",
"StartAt": "FilterDietProducts",
"States": {
"FilterDietProducts": {
"Type": "Pass",
"Output": {
"dietProducts": "{% $states.input.products[calories=0] %}"
},
"End": true
}
}
}
```
**Ejemplo de entrada para la prueba**
```
{
"products": [
{
"calories": 140,
"flavour": "Cola",
"name": "Product-1"
},
{
"calories": 0,
"flavour": "Cola",
"name": "Product-2"
},
{
"calories": 160,
"flavour": "Orange",
"name": "Product-3"
},
{
"calories": 100,
"flavour": "Orange",
"name": "Product-4"
},
{
"calories": 0,
"flavour": "Lime",
"name": "Product-5"
}
]
}
```
**Salida de probar el paso en su máquina de estado**
```
{
"dietProducts": [
{
"calories": 0,
"flavour": "Cola",
"name": "Product-2"
},
{
"calories": 0,
"flavour": "Lime",
"name": "Product-5"
}
]
}
```
![\[Ejemplo de salida para JSONata las expresiones que se están probando.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/test-state-jsonata.png)
## JSONata funciones proporcionadas por Step Functions
JSONata contiene bibliotecas de funciones para funciones de cadena, numéricas, de agregación, booleanas, de matriz, de objetos, de fecha/hora y de orden superior. Step Functions proporciona JSONata funciones adicionales que puede utilizar en sus JSONata expresiones. Estas funciones integradas sustituyen a las funciones intrínsecas de Step Functions. Las funciones intrínsecas solo están disponibles en los estados que utilizan el lenguaje de JSONPath consulta.
Nota: JSONata Las funciones integradas que requieren valores enteros como parámetros redondearán automáticamente los números no enteros proporcionados.
**\$1partition:** JSONata equivale a una función `States.ArrayPartition` intrínseca para particionar una matriz grande.
El primer parámetro es la matriz que se va a particionar, el segundo parámetro es un número entero que representa el tamaño de fragmento. El valor de retorno será una matriz bidimensional. El intérprete divide la matriz de entrada en varias matrices del tamaño especificado por el tamaño del fragmento. La longitud del último fragmento de matriz puede ser menor que la longitud de los fragmentos de matriz anteriores si el número de elementos restantes de la matriz es menor que el tamaño del fragmento.
```
"Assign": {
"arrayPartition": "{% $partition([1,2,3,4], $states.input.chunkSize) %}"
}
```
**\$1range**: JSONata equivalente a una función `States.ArrayRange` intrínseca para generar una matriz de valores.
Esta función toma tres argumentos. El primer argumento es un número entero que representa el primer elemento de la nueva matriz, el segundo argumento un número entero que representa el elemento final de la nueva matriz y el tercer argumento es el número entero del valor delta para los elementos de la nueva matriz. El valor de retorno es una matriz de valores recién generada que va desde el primer argumento de la función hasta el segundo argumento de la función, con los elementos intermedios ajustados por el delta. El valor delta puede ser positivo o negativo, lo que incrementará o disminuirá cada elemento desde el último hasta alcanzar o superar el valor final.
```
"Assign": {
"arrayRange": "{% $range(0, 10, 2) %}"
}
```
**\$1hash**: JSONata equivalente a la función `States.Hash` intrínseca para calcular el valor hash de una entrada determinada.
Esta función toma dos argumentos. El primer argumento es la cadena de origen a la que se va a aplicar la función de hash. El segundo argumento es una cadena que representa el algoritmo de hash para el cálculo del hash. El algoritmo de hash debe tener uno de los siguientes valores: `"MD5"`, `"SHA-1"`, `"SHA-256"`, `"SHA-384"`, `"SHA-512"`. El valor de retorno es una cadena del hash calculado de los datos.
Esta función se creó porque no JSONata admite de forma nativa la capacidad de calcular hashes.
```
"Assign": {
"myHash": "{% $hash($states.input.content, $hashAlgorithmName) %}"
}
```
**\$1random**: JSONata equivalente a la función `States.MathRandom` intrínseca para devolver un número aleatorio n donde. `0 ≤ n < 1`
La función toma un argumento entero *opcional* que representa el valor de inicio de la función aleatoria. Si utiliza esta función con el mismo valor de inicio, devolverá un número idéntico.
Esta función sobrecargada se creó porque la JSONata función integrada [https://docs.jsonata.org/numeric-functions#random](https://docs.jsonata.org/numeric-functions#random)no acepta un valor inicial.
```
"Assign": {
"randNoSeed": "{% $random() %}",
"randSeeded": "{% $random($states.input.seed) %}"
}
```
**\$1uuid**: JSONata versión de la función intrínseca. `States.UUID`
La función no toma argumentos. Esta función devuelve un UUID v4.
Esta función se creó porque no JSONata admite de forma nativa la capacidad de generar. UUIDs
```
"Assign": {
"uniqueId": "{% $uuid() %}"
}
```
**\$1parse**: JSONata función para deserializar cadenas JSON.
La función toma un JSON representado en forma de cadena como único argumento.
JSONata admite esta funcionalidad a través de`$eval`; sin embargo, no `$eval` es compatible con los flujos de trabajo de Step Functions.
```
"Assign": {
"deserializedPayload": "{% $parse($states.input.json_string) %}"
}
```
# Acceso a los datos de ejecución desde el objeto Context en Step Functions
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
El objeto Context es una estructura JSON interna que está disponible durante una ejecución y contiene información sobre la máquina de estados y la ejecución. El contexto proporciona a sus flujos de trabajo información sobre su ejecución específica. Sus flujos de trabajo pueden hacer referencia al objeto de contexto en una JSONata expresión con`$states.context`.
## Acceso al objeto Contexto
**Para acceder al objeto Context en JSONata**
Para acceder al objeto Context en JSONata estados, `$states.context` utilícelo en una JSONata expresión.
```
{
"ExecutionID" : "{% $states.context.Execution.Id %}"
}
```
**Para acceder al objeto Context en JSONPath**
Para acceder al objeto Context en JSONPath, primero hay que `.$` añadirlo al final de la clave para indicar que el valor es una ruta. A continuación, anexe el valor `$$.` para seleccionar un nodo en el objeto Context.
```
{
"ExecutionID.$": "$$.Execution.Id"
}
```
JSONPath los estados pueden hacer referencia al contexto (`$$.`) desde los siguientes JSONPath campos:
+ `InputPath`
+ `OutputPath`
+ `ItemsPath` (en los estados Map)
+ `Variable` (en los estados Choice)
+ `ResultSelector`
+ `Parameters`
+ Operadores de comparación entre variables
## Campos de objeto Context
El objeto Context incluye información acerca de la máquina de estado, el estado, la ejecución y la tarea. El objeto JSON Context incluye nodos para cada tipo de datos en el siguiente formato:
```
{
"Execution": {
"Id": "String",
"Input": {},
"Name": "String",
"RoleArn": "String",
"StartTime": "Format: ISO 8601",
"RedriveCount": Number,
"RedriveTime": "Format: ISO 8601"
},
"State": {
"EnteredTime": "Format: ISO 8601",
"Name": "String",
"RetryCount": Number
},
"StateMachine": {
"Id": "String",
"Name": "String"
},
"Task": {
"Token": "String"
}
}
```
Durante una ejecución, el objeto Context se rellena con datos relevantes.
En algunas ocasiones, se añaden nuevos campos al contexto. Si está procesando el contexto JSON directamente, le recomendamos que elabore un código que pueda gestionar sin problemas los nuevos campos desconocidos. Por ejemplo, si utiliza la biblioteca Jackson para deserializar JSON, le recomendamos establecer `FAIL_ON_UNKNOWN_PROPERTIES` en `false` en su `ObjectMapper` para evitar una `UnrecognizedPropertyException`.
El objeto Context `RedriveTime` solo está disponible si ha redriven una ejecución. Si ha utilizado [redriven a Map Run](redrive-map-run.md), el objeto de contexto `RedriveTime` solo está disponible para los flujos de trabajo secundarios de tipo estándar. Para un redriven Map Run con flujos de trabajo secundarios de tipo Express, `RedriveTime` no está disponible.
El contenido de una ejecución en curso incluye información detallada en el siguiente formato:
```
{
"Execution": {
"Id": "arn:aws:states:region:123456789012:execution:stateMachineName:executionName",
"Input": {
"key": "value"
},
"Name": "executionName",
"RoleArn": "arn:aws:iam::123456789012:role...",
"StartTime": "2025-08-27T10:04:42Z"
},
"State": {
"EnteredTime": "2025-08-27T10:04:42.001Z",
"Name": "Test",
"RetryCount": 3
},
"StateMachine": {
"Id": "arn:aws:states:region:123456789012:stateMachine:stateMachineName",
"Name": "stateMachineName"
},
"Task": {
"Token": "h7XRiCdLtd/83p1E0dMccoxlzFhglsdkzpK9mBVKZsp7d9yrT1W"
}
}
```
**Formato de marca temporal con fracciones de segundo**
Step Functions sigue la ISO8601 especificación que establece que la salida puede ser de cero, tres, seis o nueve dígitos según sea necesario. Cuando una marca temporal tiene cero fracciones de segundo, Step Functions elimina los ceros finales en lugar de rellenar la salida.
Si crea código que consume marcas temporales de Step Functions, el código debe poder procesar un número variable de fracciones de segundo.
## Datos del objeto Context para los estados Map
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
Al procesar un [estado `Map`](state-map.md), el contexto también contendrá `Index`, `Value` y `Source`.
Para cada iteración de `Map` estado, `Index` contiene el número de índice del elemento de matriz que se está procesando actualmente, `Value` contiene el elemento de matriz que se está procesando y `Source` será el InputType de`CSV`, `JSON``JSONL`, o`PARQUET`.
Dentro de un estado `Map`, el objeto Context incluye los datos siguientes:
```
"Map": {
"Item": {
"Index" : Number,
"Key" : "String", // Only valid for JSON objects
"Value" : "String",
"Source": "String"
}
}
```
Solo están disponibles en un estado `Map` y se pueden especificar en el campo `ItemSelector (Map)`.
**nota**
Debe definir parámetros desde el objeto Context en el bloque `ItemSelector` del estado `Map` principal, no dentro de los estados incluidos en la sección `ItemProcessor`.
Si una máquina de estados utiliza un **JSONPath**`Map`estado, puede inyectar información del objeto Context de la siguiente manera.
```
{
"StartAt": "ExampleMapState",
"States": {
"ExampleMapState": {
"Type": "Map",
"ItemSelector": {
"ContextIndex.$": "$$.Map.Item.Index",
"ContextValue.$": "$$.Map.Item.Value",
"ContextSource.$": "$$.Map.Item.Source"
},
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "INLINE"
},
"StartAt": "TestPass",
"States": {
"TestPass": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
Por ejemplo JSONata, se puede acceder a la información adicional del contexto del estado del mapa desde la `$states.context` variable:
```
{
"StartAt": "ExampleMapState",
"States": {
"ExampleMapState": {
"Type": "Map",
"ItemSelector": {
"ContextIndex": "{% $states.context.Map.Item.Index %}",
"ContextValue": "{% $states.context.Map.Item.Value %}",
"ContextSource": "{% $states.context.Map.Item.Source %}"
},
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "INLINE"
},
"StartAt": "TestPass",
"States": {
"TestPass": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
Si ejecuta la máquina de estado anterior con la siguiente entrada, `Index` y `Value` se insertan en la salida.
```
[
{
"who": "bob"
},
{
"who": "meg"
},
{
"who": "joe"
}
]
```
El resultado de la ejecución devuelve los valores de los elementos `Index` y `Value` de cada una de las tres iteraciones de la siguiente manera:
```
[
{
"ContextIndex": 0,
"ContextValue": {
"who": "bob"
},
"ContextSource" : "STATE_DATA"
},
{
"ContextIndex": 1,
"ContextValue": {
"who": "meg"
},
"ContextSource" : "STATE_DATA"
},
{
"ContextIndex": 2,
"ContextValue": {
"who": "joe"
},
"ContextSource" : "STATE_DATA"
}
]
```
Tenga en cuenta que `$states.context.Map.Item.Source` será una de las siguientes:
+ Para la entrada de estado, el valor será: `STATE_DATA`
+ Para `Amazon S3 LIST_OBJECTS_V2` con `Transformation=NONE`, el valor mostrará la URI de S3 del bucket. Por ejemplo: `S3://bucket-name`.
+ Para el resto de tipos de entrada, el valor será la URI de Amazon S3. Por ejemplo: `S3://bucket-name/object-key`.
# Uso de JSONPath rutas
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
En Amazon States Language, una *ruta* es una cadena que comienza por `$` y se puede utilizar para identificar componentes en el texto JSON. Las rutas siguen la [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)sintaxis, que solo está disponible cuando `QueryLanguage` se establece en JSONPath. Puede especificar una ruta para acceder a los subconjuntos de la entrada al especificar valores para `InputPath`, `ResultPath` y `OutputPath`.
Debe utilizar la notación entre corchetes si el nombre de campo contiene algún carácter que no esté incluido en la `member-name-shorthand` definición de la regla [JsonPath ABNF](https://www.ietf.org/archive/id/draft-ietf-jsonpath-base-21.html#jsonpath-abnf). Por lo tanto, para codificar caracteres especiales, como los signos de puntuación (excepto`_`), debe utilizar la notación entre corchetes. Por ejemplo, `$.abc.['def ghi']`.
## Rutas de referencia
Una *ruta de referencia* es una ruta cuya sintaxis está limitada de tal forma que solo puede identificar un único nodo en una estructura JSON:
+ Solo puede obtener acceso a los campos de objeto con la notación de punto (`.`) y corchete (`[ ]`).
+ Funciones como `length()` no son compatibles.
+ Los operadores léxicos, que no son simbólicos, como `subsetof` no están admitidos.
+ No se admite el filtrado por expresiones regulares o por referencia a otro valor de la estructura JSON.
+ Los operadores `@`, `,`, `:` y `?` no son compatibles
Por ejemplo, si los datos de entrada del estado contienen los valores siguientes:
```
{
"foo": 123,
"bar": ["a", "b", "c"],
"car": {
"cdr": true
}
}
```
Las siguientes rutas de referencia devolverían lo siguiente.
```
$.foo => 123
$.bar => ["a", "b", "c"]
$.car.cdr => true
```
Algunos estados utilizan rutas y rutas de referencia para controlar el flujo de una máquina de estado o para configurar los valores o las opciones del estado. Para obtener más información, consulte [Modelar el procesamiento de las rutas de entrada y salida del flujo de trabajo con un simulador de flujo de datos](https://aws.amazon.com/blogs/compute/modeling-workflow-input-output-path-processing-with-data-flow-simulator/) y [Utilización JSONPath eficaz](https://aws.amazon.com/blogs/compute/using-jsonpath-effectively-in-aws-step-functions/) en. AWS Step Functions
### Aplanamiento de una matriz de matrices
Si el estado [Estado Parallel de un flujo de trabajo](state-parallel.md) o [Estado del flujo de trabajo Map](state-map.md) de las máquinas de estado devuelve una matriz de matrices, puede transformarlas en una matriz plana con el campo [ResultSelector](input-output-inputpath-params.md#input-output-resultselector). Puede incluir este campo dentro de la definición de estados Parallel o Map para manipular el resultado de estos estados.
Para aplanar matrices, utilice la sintaxis: `[*]` en el campo `ResultSelector`, como se muestra en el siguiente ejemplo.
```
"ResultSelector": {
"flattenArray.$": "$[*][*]"
}
```
Para ver ejemplos que muestran cómo aplanar una matriz, consulte el *Paso 3* de los siguientes tutoriales:
+ [Procesamiento de datos de lotes con una función de Lambda en Step Functions](tutorial-itembatcher-param-task.md)
+ [Procesamiento de elementos individuales con una función de Lambda en Step Functions](tutorial-itembatcher-single-item-process.md)
# Manipulación de los parámetros en los flujos de trabajo de Step Functions
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
Los campos `InputPath`, `Parameters` y `ResultSelector` proporcionan una forma de manipular JSON a medida que se mueve a través del flujo de trabajo. `InputPath` puede limitar la entrada que se mueve mediante el filtrado de la notación JSON a través de una ruta (consulte [Uso de JSONPath rutas](amazon-states-language-paths.md)). Con el campo `Parameters`, puede pasar un conjunto de pares clave-valor, utilizando valores estáticos o selecciones de la entrada mediante una ruta.
El campo `ResultSelector` proporciona una forma de manipular el resultado del estado antes de aplicar `ResultPath`.
AWS Step Functionsaplica primero el `InputPath` campo y, después, el `Parameters` campo. Puede filtrar primero la entrada sin procesar para obtener la selección que desee mediante `InputPath` y, a continuación, aplicar `Parameters` para continuar manipulando esa entrada o para añadir valores nuevos. A continuación, puede utilizar el campo `ResultSelector` para manipular la salida del estado antes de aplicar `ResultPath`.
## InputPath
Utilice `InputPath` para seleccionar una parte de la entrada del estado.
Por ejemplo, suponga que la entrada del estado incluye lo siguiente:
```
{
"comment": "Example for InputPath.",
"dataset1": {
"val1": 1,
"val2": 2,
"val3": 3
},
"dataset2": {
"val1": "a",
"val2": "b",
"val3": "c"
}
}
```
Puede aplicar esta `InputPath`.
```
"InputPath": "$.dataset2",
```
Con dicha `InputPath`, lo siguiente es el objeto JSON que se pasa como la entrada.
```
{
"val1": "a",
"val2": "b",
"val3": "c"
}
```
**nota**
Una ruta puede generar una selección de valores. Considere el siguiente ejemplo.
```
{ "a": [1, 2, 3, 4] }
```
Si aplica la ruta `$.a[0:2]`, el resultado es el siguiente.
```
[ 1, 2 ]
```
## Parameters
En esta sección se describen las diferentes formas en las que puede utilizar el campo Parameters.
### Pares clave-valor
Utilice el campo `Parameters` para crear una colección de pares clave-valor que se pasan como entrada. Los valores pueden ser valores estáticos que se incluyen en la definición de la máquina de estado, o pueden seleccionarse en la entrada o en el objeto Context con una ruta. Para los pares clave-valor cuyo valor se selecciona mediante una ruta, el nombre de la clave debe terminar por `.$`.
Por ejemplo, suponga que proporciona la siguiente entrada.
```
{
"comment": "Example for Parameters.",
"product": {
"details": {
"color": "blue",
"size": "small",
"material": "cotton"
},
"availability": "in stock",
"sku": "2317",
"cost": "$23"
}
}
```
Para seleccionar parte de la información, puede especificar estos parámetros en la definición de la máquina de estado.
```
"Parameters": {
"comment": "Selecting what I care about.",
"MyDetails": {
"size.$": "$.product.details.size",
"exists.$": "$.product.availability",
"StaticValue": "foo"
}
},
```
Con la entrada anterior y el campo `Parameters`, este es el objeto JSON que se pasa.
```
{
"comment": "Selecting what I care about.",
"MyDetails": {
"size": "small",
"exists": "in stock",
"StaticValue": "foo"
}
},
```
Además de la entrada, puede acceder a un objeto JSON especial conocido como el objeto Context. El objeto Context incluye información acerca de la ejecución de la máquina de estado. Consulte [Acceso a los datos de ejecución desde el objeto Context en Step Functions](input-output-contextobject.md).
### Recursos conectados
El campo `Parameters` también puede pasar información a recursos conectados. Por ejemplo, si el estado de tu tarea es organizar un AWS Batch trabajo, puedes pasar los parámetros de la API pertinentes directamente a las acciones de la API de ese servicio. Para obtener más información, consulte lo siguiente:
+ [Cómo pasar parámetros a una API de servicio en Step Functions](connect-parameters.md)
+ [Integración de los servicios de ](integrate-services.md)
### Amazon S3
Si los datos de la función de Lambda que pasa de un estado a otro pueden crecer hasta superar los 262 144 bytes, le recomendamos que utilice Amazon S3 para almacenar los datos e implementar uno de los siguientes métodos:
+ Utilice el *estado Map Distributed* en el flujo de trabajo para que el estado `Map` pueda leer la entrada directamente de las fuentes de datos de Amazon S3. Para obtener más información, consulte [Modo distribuido](state-map-distributed.md).
+ Analice el nombre de recurso de Amazon (ARN) del bucket en el parámetro `Payload` para obtener el nombre de bucket y el valor de clave. Para obtener más información, consulte [Uso de Amazon S3 ARNs en lugar de transferir grandes cargas en Step Functions](sfn-best-practices.md#avoid-exec-failures).
También puede ajustar la implementación para que se pasen cargas más pequeñas en las ejecuciones.
## ResultSelector
Utilice el campo `ResultSelector` para manipular el resultado de un estado antes de aplicar `ResultPath`. El campo `ResultSelector` permite crear una colección de pares de clave-valor, donde los valores son estáticos o se seleccionan del resultado del estado. Con el campo `ResultSelector`, puede elegir qué partes del resultado de un estado desea pasar al campo `ResultPath`.
**nota**
Con el campo `ResultPath`, puede añadir la salida del campo `ResultSelector` a la entrada original.
`ResultSelector` es un campo opcional en los siguientes estados:
+ [Estado del flujo de trabajo Map](state-map.md)
+ [Estado de un flujo de trabajo de tarea](state-task.md)
+ [Estado Parallel de un flujo de trabajo](state-parallel.md)
Por ejemplo, las integraciones de servicios de Step Functions devuelven metadatos además de la carga del resultado. `ResultSelector` puede seleccionar partes del resultado y combinarlas con la entrada de estado con `ResultPath`. En este ejemplo, queremos seleccionar solo `resourceType` y `ClusterId` y combinar eso con la entrada de estado de un createCluster.sync de Amazon EMR. Dado lo siguiente:
```
{
"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"
}
}
```
Puede seleccionar entonces `resourceType` y `ClusterId` mediante `ResultSelector`:
```
"Create Cluster": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:createCluster.sync",
"Parameters": {
},
"ResultSelector": {
"ClusterId.$": "$.output.ClusterId",
"ResourceType.$": "$.resourceType"
},
"ResultPath": "$.EMROutput",
"Next": "Next Step"
}
```
Con la entrada dada, el uso de `ResultSelector` produce:
```
{
"OtherDataFromInput": {},
"EMROutput": {
"ClusterId": "AKIAIOSFODNN7EXAMPLE",
"ResourceType": "elasticmapreduce",
}
}
```
### Aplanamiento de una matriz de matrices
Si el estado [Estado Parallel de un flujo de trabajo](state-parallel.md) o [Estado del flujo de trabajo Map](state-map.md) de las máquinas de estado devuelve una matriz de matrices, puede transformarlas en una matriz plana con el campo [ResultSelector](#input-output-resultselector). Puede incluir este campo dentro de la definición de estados Parallel o Map para manipular el resultado de estos estados.
Para aplanar matrices, utilice la sintaxis: `[*]` en el campo `ResultSelector`, como se muestra en el siguiente ejemplo.
```
"ResultSelector": {
"flattenArray.$": "$[*][*]"
}
```
Para ver ejemplos que muestran cómo aplanar una matriz, consulte el *Paso 3* de los siguientes tutoriales:
+ [Procesamiento de datos de lotes con una función de Lambda en Step Functions](tutorial-itembatcher-param-task.md)
+ [Procesamiento de elementos individuales con una función de Lambda en Step Functions](tutorial-itembatcher-single-item-process.md)
# 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.
# Especificación de la salida de estado mediante ResultPath Step Functions
**Administración del estado y transformación de los datos**
Esta página hace referencia a JSONPath. Step Functions agregó recientemente variables y JSONata para administrar el estado y transformar los datos.
Obtenga información sobre cómo [pasar datos con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
La salida de un estado puede ser una copia de su entrada, el resultado que produce (por ejemplo, la salida de una función de Lambda del estado `Task`) o una combinación de su entrada y del resultado. Use `ResultPath` para controlar qué combinación de estos se pasa a la salida del estado.
Los siguientes tipos de estado pueden generar un resultado y pueden incluir `ResultPath:`
+ [Estado Pass de un flujo de trabajo](state-pass.md)
+ [Estado de un flujo de trabajo de tarea](state-task.md)
+ [Estado Parallel de un flujo de trabajo](state-parallel.md)
+ [Estado del flujo de trabajo Map](state-map.md)
Use `ResultPath` para combinar un resultado de tarea con una entrada de tarea o para seleccionar uno de estos. La ruta que se proporciona a `ResultPath` controla la información que se pasa a la salida.
**nota**
`ResultPath` se limita al uso de [rutas de referencia](amazon-states-language-paths.md#amazon-states-language-reference-paths), que limitan el ámbito para que la ruta solo tenga que identificar un único nodo en JSON. Consulte [Rutas de referencia](amazon-states-language-paths.md#amazon-states-language-reference-paths) en [Amazon States Language](concepts-amazon-states-language.md).
## Se usa ResultPath para reemplazar la entrada con el resultado de la tarea
Si no especifica una `ResultPath`, el comportamiento predeterminado es el mismo que `"ResultPath": "$"`. El estado reemplazará toda la entrada de estado por el resultado de la tarea.
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": "$"
# Task result
"Hello, Step Functions!"
# State Output
"Hello, Step Functions!"
```
**nota**
`ResultPath` se utiliza para incluir contenido a partir del resultado con la entrada, antes de pasarlo a la salida. Pero, si no se especifica `ResultPath`, la acción predeterminada consiste en reemplazar toda la entrada.
## Descarte del resultado y conservación de la entrada original
Si establece `ResultPath` en `null`, el estado pasará la **entrada original** a la salida. La carga útil de entrada del estado se copiará directamente en la salida, independientemente del resultado de la tarea.
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": null
# Task result
"Hello, Step Functions!"
# State Output
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
```
## Se utiliza ResultPath para incluir el resultado con la entrada
Si especifica una ruta para ResultPath, la salida de estado combinará la entrada de estado y el resultado de la tarea:
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": "$.taskresult"
# Task result
"Hello, Step Functions!"
# State Output
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions",
"taskresult" : "Hello, Step Functions!"
}
```
También puede insertar el resultado en un nodo secundario de la entrada. Establezca `ResultPath` como se indica a continuación.
```
"ResultPath": "$.strings.lambdaresult"
```
Dada la siguiente entrada:
```
{
"comment": "An input comment.",
"strings": {
"string1": "foo",
"string2": "bar",
"string3": "baz"
},
"who": "AWS Step Functions"
}
```
El resultado de la tarea se insertaría como un elemento secundario del nodo `strings` en la entrada.
```
{
"comment": "An input comment.",
"strings": {
"string1": "foo",
"string2": "bar",
"string3": "baz",
"lambdaresult": "Hello, Step Functions!"
},
"who": "AWS Step Functions"
}
```
La salida de estado ahora incluye el JSON de entrada original con el resultado como nodo secundario.
## Se utiliza ResultPath para actualizar un nodo de la entrada con el resultado
Si especificas un nodo existente para ResultPath, el resultado de la tarea sustituirá a ese nodo existente:
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": "$.comment"
# Task result
"Hello, Step Functions!"
# State Output
{
"comment": "Hello, Step Functions!",
"details": "Default example",
"who" : "Step Functions"
}
```
## Se utiliza ResultPath para incluir tanto el error como la entrada en un `Catch`
En algunos casos, es posible que desee conservar la entrada original con el error. Utilice `ResultPath` en un `Catch` para incluir el error con la entrada original, en lugar de sustituirla.
```
"Catch": [{
"ErrorEquals": ["States.ALL"],
"Next": "NextTask",
"ResultPath": "$.error"
}]
```
Si la instrucción `Catch` anterior detecta un error, incluye el resultado en un nodo `error` dentro de la entrada de estado. Por ejemplo, con la siguiente entrada:
```
{"foo": "bar"}
```
La salida de estado al detectar un error es la siguiente.
```
{
"foo": "bar",
"error": {
"Error": "Error here"
}
}
```
Para obtener más información sobre el control de errores, consulte lo siguiente:
+ [Control de errores en los flujos de trabajo de Step Functions](concepts-error-handling.md)
+ [Tratamiento de condiciones de error en una máquina de estado de Step Functions](tutorial-handling-error-conditions.md)
# Campos de entrada y salida del estado Map en Step Functions
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
Los estados Map iteran una colección de elementos de un conjunto de datos. Algunos ejemplos de conjuntos de datos son:
+ Matrices y objetos JSON de estados anteriores.
+ Archivos de datos individuales almacenados en Amazon S3 en formatos como JSON, JSONL, CSV o archivos Parquet.
+ Referencias a varios objetos, como los manifiestos de Athena y los archivos de inventario de Amazon S3
Un mapa repite un conjunto de pasos para cada elemento del conjunto de datos. Puede configurar la entrada que recibe el `Map state` y la salida que genera el mapa mediante una serie de opciones de configuración. Step Functions aplica cada opción en su *estado Map Distributed* en el orden que se muestra en la siguiente lista. Según el caso de uso, es posible que no necesite aplicar todos los campos.
1. [ItemReader (Mapa)](input-output-itemreader.md): se utiliza para leer sus elementos de datos
1. [ItemsPath ( JSONPath Solo mapa)](input-output-itemspath.md)o **Items (JSONata)**: opcional; se usa para especificar elementos en su conjunto de datos
1. [ItemSelector (Map)](input-output-itemselector.md) (opcional): se utiliza para seleccionar y modificar elementos del conjunto de datos
1. [ItemBatcher (Map)](input-output-itembatcher.md): se utiliza para procesar grupos de elementos cuando se procesan grandes conjuntos de elementos
1. [ResultWriter (Mapa)](input-output-resultwriter.md): ofrece opciones para generar resultados a partir de flujos de trabajo secundarios
# ItemReader (Mapa)
El campo `ItemReader` es un objeto JSON que especifica un conjunto de datos y su ubicación. Un *estado Map Distributed* usa este conjunto de datos como entrada.
El siguiente ejemplo muestra la sintaxis del `ItemReader` campo en un flujo de trabajo **JSONPathbasado**, para un conjunto de datos de un archivo delimitado por texto que se almacena en un bucket de Amazon S3.
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "FIRST_ROW"
},
"Resource": "arn:aws:states:::s3:getObject",
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "csvDataset/ratings.csv",
"VersionId": "BcK42coT2jE1234VHLUvBV1yLNod2OEt"
}
}
```
En el siguiente flujo de trabajo **JSONatabasado**, observe que `Parameters` se sustituye por **Arguments**.
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "FIRST_ROW"
},
"Resource": "arn:aws:states:::s3:getObject",
"Arguments": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "csvDataset/ratings.csv"
"VersionId": "BcK42coT2jE1234VHLUvBV1yLNod2OEt"
}
}
```
## Contenido del ItemReader campo
El contenido del campo `ItemReader` varía según el conjunto de datos. Por ejemplo, si el conjunto de datos es una matriz JSON transferida desde un paso anterior del flujo de trabajo, el campo `ItemReader` se omite. Si el conjunto de datos es un origen de datos de Amazon S3, este campo contiene los siguientes subcampos.
**`Resource`**
La acción de integración de la API de Amazon S3 que utilizará Step Functions, como `arn:aws:states:::s3:getObject`
**`Arguments (JSONata) or Parameters (JSONPath)`**
Un objeto JSON que especifica el nombre del bucket de Amazon S3 y la clave de objeto en los que se almacena el conjunto de datos.
Si el bucket tiene habilitado el control de versiones, también puede proporcionar la versión del objeto de Amazon S3.
**`ReaderConfig`**
Un objeto JSON que especifica los detalles siguientes:
+ `InputType`
Acepta uno de los siguientes valores: `CSV`, `JSON`, `JSONL`, `PARQUET`, `MANIFEST`.
Especifica el tipo de origen de datos de Amazon S3, como un archivo delimitado por texto (`CSV`), un objeto, un archivo JSON, líneas de JSON, un archivo de Parquet, un manifiesto de Athena o una lista de inventario de Amazon S3. En Workflow Studio, puede seleccionar un tipo de entrada del **origen de elementos de S3**.
La mayoría de los tipos de entrada que utilizan la recuperación `S3GetObject` también admiten los campos `ExpectedBucketOwner` y `VersionId` en sus parámetros. Los archivos de Parquet son la única excepción que no admite `VersionId`.
Los archivos de entrada admiten los siguientes tipos de compresión externa: GZIP, ZSTD.
Ejemplos de nombres de archivo: `myObject.jsonl.gz` y `myObject.csv.zstd`.
Nota: Los archivos de Parquet son un tipo de archivo binario que se comprime internamente. Se admite la compresión GZIP, ZSTD y Snappy.
+ `Transformation`
*Opcional.* El valor será `NONE` o `LOAD_AND_FLATTEN`.
Si no se especifica, se asumirá `NONE`. Si se establece en `LOAD_AND_FLATTEN`, también debe establecer `InputType`.
Comportamiento predeterminado: el mapa recorrerá en iteración los **objetos de metadatos** devueltos por las llamadas a `S3:ListObjectsV2`. Si se establece en `LOAD_AND_FLATTEN`, el mapa leerá y procesará los **objetos de datos** reales a los que se hace referencia en la lista de resultados.
+ `ManifestType`
*Opcional.* El valor será `ATHENA_DATA` o `S3_INVENTORY`.
Nota: Si se establece en `S3_INVENTORY`, **no** se debe especificar también `InputType` porque se asume que el tipo es `CSV`.
+ `CSVDelimiter`
Puede especificar este campo cuando `InputType` es `CSV` o `MANIFEST`.
Acepta uno de los siguientes valores: `COMMA` (predeterminado), `PIPE`, `SEMICOLON`, `SPACE`, `TAB`.
**nota**
Con el campo `CSVDelimiter`, `ItemReader` puede procesar archivos que estén delimitados por caracteres distintos de una coma. Las referencias a los “archivos CSV” también incluyen los archivos que utilizan delimitadores alternativos especificados por el campo `CSVDelimiter`.
+ `CSVHeaderLocation`
Puede especificar este campo cuando `InputType` es `CSV` o `MANIFEST`.
Acepta uno de los siguientes valores para especificar la ubicación del encabezado de la columna:
+ `FIRST_ROW` – Utilice esta opción si la primera línea del archivo es el encabezado.
+ `GIVEN` – Utilice esta opción para especificar el encabezado dentro de la definición de la máquina de estado.
Por ejemplo, si el archivo contiene los datos siguientes.
```
1,307,3.5,1256677221
1,481,3.5,1256677456
1,1091,1.5,1256677471
...
```
Puede proporcionar la siguiente matriz JSON como encabezado CSV.
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "GIVEN",
"CSVHeaders": [
"userId",
"movieId",
"rating",
"timestamp"
]
}
}
```
**Tamaño del encabezado CSV**
Step Functions admite encabezados de hasta 10 KiB para archivos delimitados por texto.
+ `ItemsPointer`
*Opcional.* Puede especificar este campo cuando `InputType` esté`JSON`.
`ItemsPointer`usa JSONPointer la sintaxis para seleccionar una matriz u objeto específico anidado en el archivo JSON. JSONPointer es una sintaxis estandarizada diseñada exclusivamente para navegar y hacer referencia a ubicaciones dentro de documentos JSON.
JSONPointer la sintaxis utiliza barras diagonales (/) para separar cada nivel de anidación, con índices matriciales representados como números sin corchetes. Por ejemplo:
+ `/Data/Contents`- hace referencia a la matriz Contents del objeto Data
+ `/Data/Contents/0`- hace referencia al primer elemento de la matriz de contenidos
La posición inicial de la matriz de destino debe estar dentro de los primeros 16 MB del archivo JSON y la JSONPointer ruta debe tener una longitud inferior a 2000 caracteres.
Por ejemplo, si el archivo JSON contiene:
```
{"data": {"items": [{"id": 1}, {"id": 2}]}}
```
Deberías especificar que `"ItemsPointer": "/data/items"` se procese la matriz de elementos.
+ `MaxItems`
De forma predeterminada, el estado `Map` recorre en iteración todos los elementos del conjunto de datos especificado. Al establecer `MaxItems`, puede limitar el número de elementos de datos que se pasan al estado `Map`. Por ejemplo, si proporciona un archivo delimitado por texto que contiene 1000 filas y establece un límite de 100, el intérprete pasará *solo* 100 filas al *estado Distributed Map*. El estado `Map` procesa los elementos en orden secuencial, a partir de la fila siguiente al encabezado.
Para **JSONPath**los flujos de trabajo, puede usar `MaxItemsPath` una *ruta de referencia* a un par clave-valor en la entrada de estado que se resuelve en un número entero. Tenga en cuenta que puede especificar `MaxItems` o `MaxItemsPath`, pero no **ambos**.
**nota**
Puede especificar un límite de hasta 100 000 000 después del cual `Distributed Map` dejará de leer elementos.
**Requisitos para la cuenta y la región**
Los buckets de Amazon S3 deben estar en la misma máquina de estado Cuenta de AWS y al Región de AWS igual que ella.
*Tenga en cuenta que, aunque su máquina de estados pueda acceder a archivos en depósitos distintos Cuentas de AWS que estén en el mismo lugar Región de AWS, Step Functions solo admite la publicación de objetos en depósitos de Amazon S3 que estén en la misma Cuenta de AWS máquina de estados o en la Región de AWS misma ubicación.*
## Procesamiento de conjuntos de datos anidados (actualizado el 11 de septiembre de 2025)
Con el nuevo parámetro `Transformation`, puede especificar un valor de `LOAD_AND_FLATTEN` y el mapa leerá los objetos de datos **reales** a los que se hace referencia en la lista de resultados de una llamada a `S3:ListObjectsV2`.
Antes de esta versión, era necesario crear Distributed Maps anidados para **recuperar** los metadatos y, posteriormente, **procesar** los datos reales. El primer mapa recorrería en iteración los **metadatos** devueltos por `S3:ListObjectsV2` e invocaría los flujos de trabajo secundarios. Otro mapa dentro de cada máquina de estado secundaria leería los **datos reales** de los archivos individuales. Con la opción de transformación, puede realizar ambos pasos a la vez.
Imagine que quiere realizar una auditoría diaria de los últimos 24 archivos de registro que su sistema produce cada hora y almacena en Amazon S3. Su estado Distributed Map puede mostrar los archivos de registro con `S3:ListObjectsV2` y luego recorrer en iteración los *metadatos* de cada objeto, o bien ahora puede cargar y analizar los objetos de **datos reales** almacenados en su bucket de Amazon S3.
El uso de la opción `LOAD_AND_FLATTEN` puede aumentar la escalabilidad, reducir los recuentos de ejecuciones de Map abierto y procesar varios objetos de forma simultánea. Los trabajos de Athena y Amazon EMR suelen generar resultados que se pueden procesar con la nueva configuración.
A continuación se muestra un ejemplo de los parámetros en una definición `ItemReader`:
```
{
"QueryLanguage": "JSONata",
"States": {
...
"Map": {
...
"ItemReader": {
"Resource": "arn:aws:states:::s3:listObjectsV2",
"ReaderConfig": {
// InputType is required if Transformation is LOAD_AND_FLATTEN.
"InputType": "CSV | JSON | JSONL | PARQUET",
// Transformation is OPTIONAL and defaults to NONE if not present
"Transformation": "NONE | LOAD_AND_FLATTEN"
},
"Arguments": {
"Bucket": "amzn-s3-demo-bucket1",
"Prefix": "{% $states.input.PrefixKey %}"
}
},
...
}
}
```
## Ejemplos de conjuntos de datos
Puede especificar una de las opciones siguientes como conjunto de datos:
+ [Datos JSON de un paso anterior](#itemsource-json-array)
+ [Lista de objetos de Amazon S3](#itemsource-example-s3-object-data)
+ [Objetos de Amazon S3 transformados por LOAD\$1AND\$1FLATTEN](#itemsource-example-s3-object-data-flatten)
+ [Archivo JSON en un bucket de Amazon S3](#itemsource-example-json-data)
+ [Archivo de líneas JSON en un bucket de Amazon S3](#itemsource-example-json-lines-data)
+ [Archivo CSV en un bucket de Amazon S3](#itemsource-example-csv-data)
+ [Archivo de Parquet en un bucket de Amazon S3](#itemsource-example-parquet-data)
+ [Manifiesto de Athena (procesa varios elementos)](#itemsource-example-athena-manifest-data)
+ [Inventario de Amazon S3 (procesa varios elementos)](#itemsource-example-s3-inventory)
**nota**
Step Functions necesita los permisos adecuados para obtener acceso a los conjuntos de datos de Amazon S3 que utilice. Para obtener información sobre las políticas de IAM para los conjuntos de datos, consulte [Recomendaciones de políticas de IAM para conjuntos de datos](#itemreader-iam-policies).
### Datos JSON de un paso anterior
Un *estado Map Distributed* puede aceptar una entrada JSON transferida desde un paso anterior del flujo de trabajo.
La entrada puede ser una matriz JSON, un objeto JSON o una matriz dentro de un nodo de un objeto JSON.
Step Functions recorrerá en iteración directamente sobre los elementos de una matriz o los pares clave-valor de un objeto JSON.
Para seleccionar un nodo específico que contenga una matriz o un objeto JSON anidado de la entrada, puede usar la expresión `ItemsPath ( JSONPath Solo mapa)` o usar una JSONata expresión en el `Items` campo para los estados. JSONata
Para procesar los elementos individuales, el *estado Distributed Map* inicia la ejecución de un flujo de trabajo secundario para cada elemento. Las siguientes pestañas muestran ejemplos de la entrada que se transfiere al estado `Map` y la entrada correspondiente a la ejecución de un flujo de trabajo secundario.
**nota**
El campo `ItemReader` no es necesario cuando el conjunto de datos son datos JSON de un paso anterior.
------
#### [ Input passed to the Map state ]
Considera la siguiente matriz JSON de tres elementos.
```
"facts": [
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
},
{
"verdict": "mostly-true",
"statement_date": "5/18/2016",
"statement_source": "news"
}
]
```
------
#### [ Input passed to a child workflow execution ]
El *estado Map Distributed* inicia tres ejecuciones de flujos de trabajo secundarios. Cada ejecución recibe un elemento de matriz como entrada. El siguiente ejemplo muestra la entrada recibida por la ejecución de un flujo de trabajo secundario.
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
------
### Lista de objetos de Amazon S3
Un *estado Map Distributed* puede iterar sobre los objetos que se almacenan en un bucket de Amazon S3. Cuando la ejecución del flujo de trabajo alcanza el `Map` estado, Step Functions invoca la acción de la API [ListObjectsV2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html), que devuelve una matriz de **metadatos del objeto** Amazon S3. En esta matriz, cada elemento contiene datos, como **ETag**una **clave**, de los datos reales almacenados en el depósito.
Para procesar los elementos individuales de la matriz, el *estado Map Distributed* inicia la ejecución de un flujo de trabajo secundario. Por ejemplo, suponga que su bucket de Amazon S3 contiene 100 imágenes. A continuación, la matriz devuelta tras invocar la acción de la API `ListObjectsV2` contiene 100 elementos de metadatos. A continuación, el *estado Distributed Map* inicia 100 ejecuciones de flujos de trabajo secundarios para procesar cada elemento.
Para procesar los objetos de datos directamente, sin flujos de trabajo anidados, puede elegir la opción de transformación LOAD\$1AND\$1FLATTEN para procesar los elementos **directamente**.
**nota**
Step Functions también incluirá un elemento para cada **carpeta **que cree en un bucket de Amazon S3 utilizando la **consola** de Amazon S3. Los elementos de la carpeta provocan el inicio de más ejecuciones de flujos de trabajo secundarios.
Para evitar crear ejecuciones de flujo de trabajo secundarias adicionales para cada carpeta, le recomendamos que utilice la AWS CLI para crear carpetas. Para obtener más información, consulte [Uso de comandos de S3 de alto nivel](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-buckets-creating) en la *Guía del usuario de AWS Command Line Interface *.
Step Functions necesita los permisos adecuados para obtener acceso a los conjuntos de datos de Amazon S3 que utilice. Para obtener información sobre las políticas de IAM para los conjuntos de datos, consulte [Recomendaciones de políticas de IAM para conjuntos de datos](#itemreader-iam-policies).
En las siguientes pestañas se muestran ejemplos de la sintaxis del campo `ItemReader` y de la entrada que se transfiere a la ejecución de un flujo de trabajo secundario para este conjunto de datos.
------
#### [ ItemReader syntax ]
En este ejemplo, ha organizado los datos, que incluyen imágenes, archivos JSON y objetos, dentro de un prefijo llamado `processData` en un bucket de Amazon S3 llamado `amzn-s3-demo-bucket`.
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:listObjectsV2",
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Prefix": "processData"
}
}
```
------
#### [ Input passed to a child workflow execution ]
El *estado Distributed Map* inicia tantas ejecuciones de flujos de trabajo secundarios como el número de elementos de metadatos presentes en el bucket de Amazon S3. El siguiente ejemplo muestra la entrada recibida por la ejecución de un flujo de trabajo secundario.
```
{
"Etag": "\"05704fbdccb224cb01c59005bebbad28\"",
"Key": "processData/images/n02085620_1073.jpg",
"LastModified": 1668699881,
"Size": 34910,
"StorageClass": "STANDARD"
}
```
------
### Objetos de Amazon S3 transformados por `LOAD_AND_FLATTEN`
Gracias a la compatibilidad mejorada con S3 ListObjects V2 como fuente de entrada en Distributed Map, sus máquinas de estado pueden leer y procesar varios **objetos de datos directamente de los** buckets de Amazon S3, ¡lo que elimina la necesidad de mapas anidados para procesar los metadatos\$1
Con la opción `LOAD_AND_FLATTEN`, su máquina de estado hará lo siguiente:
+ Leer el **contenido real** de cada objeto mostrado por la llamada `ListObjectsV2` de Amazon S3.
+ Analice el contenido en función de InputType (CSV, JSON, JSONL, Parquet).
+ Creer elementos a partir del contenido del archivo (filas/registros) en lugar de los metadatos.
Con la opción de transformación, ya no necesitará Distributed Maps anidados para procesar los metadatos. El uso de la opción LOAD\$1AND\$1FLATTEN aumenta la escalabilidad, reduce los recuentos de ejecuciones de Map activo y procesa varios objetos de forma simultánea.
En la siguiente configuración se muestran los valores para un `ItemReader`:
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:listObjectsV2",
"ReaderConfig": {
"InputType": "JSON",
"Transformation": "LOAD_AND_FLATTEN"
},
"Arguments": {
"Bucket": "S3_BUCKET_NAME",
"Prefix": "S3_BUCKET_PREFIX"
}
}
```
**Recomendación de prefijo de bucket**
Le recomendamos incluir una barra diagonal final en el prefijo. Por ejemplo, si selecciona datos con un prefijo de `folder1`, su máquina de estado procesará `folder1/myData.csv` y `folder10/myData.csv`. El uso de `folder1/` procesará estrictamente una sola carpeta.
### Archivo JSON en un bucket de Amazon S3
Un *estado Map Distributed* puede aceptar un archivo JSON almacenado en un bucket de Amazon S3 como conjunto de datos. El archivo JSON debe contener una matriz u objeto JSON.
Cuando la ejecución del flujo de trabajo alcanza el `Map` estado, Step Functions invoca la acción de la [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)API para recuperar el archivo JSON especificado.
Si el archivo JSON contiene una estructura de objetos anidados, puede seleccionar el nodo específico con su conjunto de datos con un `ItemsPointer`. Por ejemplo, la siguiente configuración extraería una lista anidada de *productos destacados* del *inventario*.
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "JSON",
"ItemsPointer": "/inventory/products/featured"
},
"Arguments": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "nested-data-file.json"
}
}
```
A continuación, el estado `Map` se repite sobre cada elemento de la matriz e inicia la ejecución de un flujo de trabajo secundario para cada elemento. Por ejemplo, si el archivo JSON contiene 1000 elementos de matriz, el estado `Map` inicia 1000 ejecuciones de flujos de trabajo secundarios.
**nota**
La entrada de ejecución utilizada para iniciar la ejecución de un flujo de trabajo secundario no puede superar los 256 KiB. Sin embargo, Step Functions permite leer un elemento de hasta 8 MB de un archivo delimitado por texto, un archivo JSON o líneas JSON si, a continuación, se aplica el campo `ItemSelector` opcional para reducir el tamaño del elemento.
Step Functions admite 10 GB como tamaño máximo de un archivo individual en Amazon S3.
Step Functions necesita los permisos adecuados para obtener acceso a los conjuntos de datos de Amazon S3 que utilice. Para obtener información sobre las políticas de IAM para los conjuntos de datos, consulte [Recomendaciones de políticas de IAM para conjuntos de datos](#itemreader-iam-policies).
En las siguientes pestañas se muestran ejemplos de la sintaxis del campo `ItemReader` y de la entrada que se transfiere a la ejecución de un flujo de trabajo secundario para este conjunto de datos.
Para este ejemplo, imagine que tiene un archivo JSON llamado `factcheck.json`. Ha almacenado este archivo en un prefijo llamado `jsonDataset` en un bucket de Amazon S3. A continuación se muestra un ejemplo de conjunto de datos JSON.
```
[
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
},
{
"verdict": "mostly-true",
"statement_date": "5/18/2016",
"statement_source": "news"
},
...
]
```
------
#### [ ItemReader syntax ]
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "JSON"
},
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "jsonDataset/factcheck.json"
}
}
```
------
#### [ Input to a child workflow execution ]
El *estado Map Distributed* inicia tantas ejecuciones de flujos de trabajo secundarios como el número de elementos de la matriz presentes en el archivo JSON. El siguiente ejemplo muestra la entrada recibida por la ejecución de un flujo de trabajo secundario.
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
------
### Archivo de líneas JSON en un bucket de Amazon S3
Un *estado Distributed Map* puede aceptar un archivo de líneas JSON almacenado en un bucket de Amazon S3 como conjunto de datos.
**nota**
La entrada de ejecución utilizada para iniciar la ejecución de un flujo de trabajo secundario no puede superar los 256 KiB. Sin embargo, Step Functions permite leer un elemento de hasta 8 MB de un archivo delimitado por texto, un archivo JSON o líneas JSON si, a continuación, se aplica el campo `ItemSelector` opcional para reducir el tamaño del elemento.
Step Functions admite 10 GB como tamaño máximo de un archivo individual en Amazon S3.
Step Functions necesita los permisos adecuados para obtener acceso a los conjuntos de datos de Amazon S3 que utilice. Para obtener información sobre las políticas de IAM para los conjuntos de datos, consulte [Recomendaciones de políticas de IAM para conjuntos de datos](#itemreader-iam-policies).
En las siguientes pestañas se muestran ejemplos de la sintaxis del campo `ItemReader` y de la entrada que se transfiere a la ejecución de un flujo de trabajo secundario para este conjunto de datos.
Para este ejemplo, imagine que tiene un archivo de líneas JSON llamado `factcheck.jsonl`. Ha almacenado este archivo en un prefijo llamado `jsonlDataset` en un bucket de Amazon S3. A continuación, se muestra un ejemplo del contenido de un archivo.
```
{"verdict": "true", "statement_date": "6/11/2008", "statement_source": "speech"}
{"verdict": "false", "statement_date": "6/7/2022", "statement_source": "television"}
{"verdict": "mostly-true", "statement_date": "5/18/2016", "statement_source": "news"}
```
------
#### [ ItemReader syntax ]
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "JSONL"
},
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "jsonlDataset/factcheck.jsonl"
}
}
```
------
#### [ Input to a child workflow execution ]
El *estado Map Distributed* inicia tantas ejecuciones de flujos de trabajo secundarios como el número de líneas presentes en el archivo JSON. El siguiente ejemplo muestra la entrada recibida por la ejecución de un flujo de trabajo secundario.
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
------
### Archivo CSV en un bucket de Amazon S3
**nota**
Con el campo `CSVDelimiter`, `ItemReader` puede procesar archivos que estén delimitados por caracteres distintos de una coma. Las referencias a los “archivos CSV” también incluyen los archivos que utilizan delimitadores alternativos especificados por el campo `CSVDelimiter`.
Un *estado Map Distributed* puede aceptar un archivo delimitado por texto almacenado en un bucket de Amazon S3 como conjunto de datos. Si usa un archivo delimitado por texto como conjunto de datos, debe especificar un encabezado de columna. Para obtener información sobre cómo especificar un encabezado, consulte [Contenido del ItemReader campo](#itemreader-field-contents).
Step Functions analiza los archivos delimitados por texto según las siguientes reglas:
+ El delimitador que separa los campos se especifica en. `CSVDelimiter` *ReaderConfig* El valor predeterminado del delimitador es `COMMA`.
+ Los retornos de carro son un delimitador que separa los **registros**.
+ Los campos se tratan como cadenas. Para las conversiones de tipos de datos, utilice la función intrínseca `States.StringToJson` en [ItemSelector (Map)](input-output-itemselector.md).
+ No es necesario incluir comillas dobles (" ") para delimitar cadenas. No obstante, las cadenas entre comillas dobles pueden contener comas y retornos de carro sin que funcionen como delimitadores de registro.
+ Para conservar las comillas dobles en una secuencia de conservación, repítalas.
+ Las barras diagonales invertidas (\$1) son otra forma de evitar los caracteres especiales. Las barras diagonales invertidas solo funcionan con otras barras diagonales invertidas, comillas dobles y el separador de campos configurado, como una coma o una barra vertical. La barra diagonal invertida seguida de cualquier otro carácter se elimina en silencio.
+ Para conservar las barras diagonales invertidas repitiéndolas. Por ejemplo:
```
path,size
C:\\Program Files\\MyApp.exe,6534512
```
+ Las barras diagonales invertidas que evitan las comillas dobles (`\"`) solo funcionan cuando se incluyen en pares, por lo que recomendamos evitar las comillas dobles repitiéndolas: `""`
+ Si el número de campos de una fila es **inferior** al número de campos del encabezado, Step Functions proporciona **cadenas vacías** para los valores que faltan.
+ Si el número de campos de una fila es **mayor** que el número de campos del encabezado, Step Functions **omite** los campos adicionales.
Para obtener más información acerca de cómo Step Functions analiza un archivo delimitado por texto, consulte [Example of parsing an input CSV file](example-csv-parse-dist-map.md#example-csv-parse).
Cuando la ejecución del flujo de trabajo alcanza el `Map` estado, Step Functions invoca la acción de la [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)API para recuperar el archivo especificado. A continuación, el estado `Map` recorre en iteración cada fila del archivo e inicia la ejecución de un flujo de trabajo secundario para procesar los elementos de cada fila. Por ejemplo, suponga que proporciona un archivo delimitado por texto que contiene 100 filas como entrada. Entonces, el intérprete pasa cada fila al estado `Map`. El estado `Map` procesa los elementos en orden de serie, a partir de la fila siguiente al encabezado.
**nota**
La entrada de ejecución utilizada para iniciar la ejecución de un flujo de trabajo secundario no puede superar los 256 KiB. Sin embargo, Step Functions permite leer un elemento de hasta 8 MB de un archivo delimitado por texto, un archivo JSON o líneas JSON si, a continuación, se aplica el campo `ItemSelector` opcional para reducir el tamaño del elemento.
Step Functions admite 10 GB como tamaño máximo de un archivo individual en Amazon S3.
Step Functions necesita los permisos adecuados para obtener acceso a los conjuntos de datos de Amazon S3 que utilice. Para obtener información sobre las políticas de IAM para los conjuntos de datos, consulte [Recomendaciones de políticas de IAM para conjuntos de datos](#itemreader-iam-policies).
En las siguientes pestañas se muestran ejemplos de la sintaxis del campo `ItemReader` y de la entrada que se transfiere a la ejecución de un flujo de trabajo secundario para este conjunto de datos.
------
#### [ ItemReader syntax ]
Por ejemplo, supongamos que tiene un archivo CSV llamado `ratings.csv`. A continuación, ha almacenado este archivo dentro de un prefijo llamado `csvDataset` en un bucket de Amazon S3.
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "FIRST_ROW",
"CSVDelimiter": "PIPE"
},
"Resource": "arn:aws:states:::s3:getObject",
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "csvDataset/ratings.csv"
}
}
```
------
#### [ Input to a child workflow execution ]
El *estado Map Distributed* inicia tantas ejecuciones de flujos de trabajo secundarios como el número de filas presentes en el archivo CSV, excluida la fila del encabezado, si está en el archivo. El siguiente ejemplo muestra la entrada recibida por la ejecución de un flujo de trabajo secundario.
```
{
"rating": "3.5",
"movieId": "307",
"userId": "1",
"timestamp": "1256677221"
}
```
------
### Archivo de Parquet en un bucket de Amazon S3
Los archivos de Parquet se pueden utilizar como origen de entrada. Los archivos de Apache Parquet almacenados en Amazon S3 proporcionan un procesamiento de datos en columnas eficiente y a escala.
Cuando se utilicen archivos de Parquet, se aplicarán las siguientes condiciones:
+ 256 MB es el tamaño máximo de un grupo de filas y 5 MB es el tamaño máximo de pie de página. Si proporciona archivos de entrada que superan cualquiera de estos límites, la máquina de estado devolverá un error de tiempo de ejecución.
+ El campo `VersionId` **no** se admite para `InputType=Parquet`.
+ La compresión de datos interna con GZIP, ZSTD y Snappy es compatible de forma nativa. No son necesarias extensiones de nombre de archivo.
A continuación, se muestra un ejemplo de configuración de ASL para `InputType` establecido en Parquet:
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "PARQUET"
},
"Arguments": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "my-parquet-data-file-1.parquet"
}
}
```
**Procesamiento de trabajos a gran escala**
Para trabajos a gran escala, Step Functions utilizará muchos lectores de entrada. Los lectores intercalan su procesamiento, lo que puede provocar que algunos lectores se detengan mientras otros avanzan. Se espera un progreso intermitente a gran escala.
### Manifiesto de Athena (procesa varios elementos)
Puede usar los archivos de manifiesto de Athena, generados a partir de los resultados de la consulta `UNLOAD`, para especificar el **origen** de los archivos de datos de su estado Map. Se establece `ManifestType` en `ATHENA_DATA`, y `InputType` en `CSV`, `JSONL` o `Parquet`.
Al ejecutar una consulta `UNLOAD`, Athena genera un archivo de manifiesto de datos además de los objetos de datos reales. El archivo de manifiesto proporciona una lista CSV estructurada de los archivos de datos. Los archivos de datos y de manifiesto se guardan en la ubicación de resultados de consulta de Athena en Amazon S3.
```
UNLOAD () TO 'S3_URI_FOR_STORING_DATA_OBJECT' WITH (format = 'JSON')
```
Descripción conceptual del proceso, en resumen:
1. Seleccione sus datos de una tabla mediante una consulta `UNLOAD` en Athena.
1. Athena generará un archivo de manifiesto (CSV) y los objetos de datos en Amazon S3.
1. Configure Step Functions para leer el archivo de manifiesto y procesar la entrada.
La característica puede procesar los formatos de salida CSV, JSONL y Parquet de Athena. Todos los objetos a los que se hace referencia en un único archivo de manifiesto deben tener el mismo InputType formato. Tenga en cuenta que los objetos CSV exportados mediante una consulta `UNLOAD` **no **incluyen el encabezado en la primera línea. Compruebe `CSVHeaderLocation` si tiene que proporcionar los encabezados de columnas.
El contexto del mapa también incluirá una `$states.context.Map.Item.Source` para que pueda personalizar el procesamiento en función del origen de los datos.
A continuación se muestra un ejemplo de configuración de un `ItemReader` configurado para usar un manifiesto de Athena:
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"ManifestType": "ATHENA_DATA",
"InputType": "CSV | JSONL | PARQUET"
},
"Arguments": {
"Bucket": "",
"Key": "-manifest.csv"
}
}
```
**Uso del patrón de manifiesto de Athena en Workflow Studio**
Un escenario común para el procesamiento de datos es aplicar un Map a los datos procedentes de una consulta UNLOAD de Athena. El Map invoca una función de Lambda para procesar cada elemento descrito en el manifiesto de Athena. Step Functions Workflow Studio proporciona un patrón listo para usar que combina todos estos componentes en un bloque que puede arrastrar al lienzo de su máquina de estado.
### Inventario S3 (procesa varios artículos)
Un *estado Map Distributed* puede aceptar un archivo de manifiesto de inventario de Amazon S3 almacenado en un bucket de Amazon S3 como conjunto de datos.
Cuando la ejecución del flujo de trabajo alcanza el `Map` estado, Step Functions invoca la acción de la [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)API para recuperar el archivo de manifiesto de inventario de Amazon S3 especificado.
De forma predeterminada, el estado `Map` recorre en iteración los **objetos** del inventario para devolver una matriz de metadatos de objetos de inventario de Amazon S3.
Si especificas que ManifestType es S3\$1INVESTORY, no se puede especificar. InputType
**nota**
Step Functions admite 10 GB como tamaño máximo de un archivo individual en un informe de inventario de Amazon S3 tras la descompresión. Sin embargo, Step Functions puede procesar más de 10 GB si cada archivo individual tiene menos de 10 GB.
Step Functions necesita los permisos adecuados para obtener acceso a los conjuntos de datos de Amazon S3 que utilice. Para obtener información sobre las políticas de IAM para los conjuntos de datos, consulte [Recomendaciones de políticas de IAM para conjuntos de datos](#itemreader-iam-policies).
A continuación se muestra un ejemplo de un archivo de inventario de ejemplo en formato CSV: Este archivo incluye los objetos denominados `csvDataset` y`imageDataset`, que se almacenan en un bucket de Amazon S3 que lleva ese nombre `amzn-s3-demo-source-bucket`.
```
"amzn-s3-demo-source-bucket","csvDataset/","0","2022-11-16T00:27:19.000Z"
"amzn-s3-demo-source-bucket","csvDataset/titles.csv","3399671","2022-11-16T00:29:32.000Z"
"amzn-s3-demo-source-bucket","imageDataset/","0","2022-11-15T20:00:44.000Z"
"amzn-s3-demo-source-bucket","imageDataset/n02085620_10074.jpg","27034","2022-11-15T20:02:16.000Z"
...
```
**importante**
Step Functions no admite un informe de inventario de Amazon S3 definido por el usuario como conjunto de datos.
El formato de salida del informe de inventario de Amazon S3 debe ser CSV.
Para obtener más información sobre los inventarios de Amazon S3 y cómo configurarlos, consulte [Inventario de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html).
El siguiente ejemplo de un archivo de manifiesto de inventario de Amazon S3 muestra los encabezados CSV de los metadatos de los objetos de inventario.
```
{
"sourceBucket" : "amzn-s3-demo-source-bucket",
"destinationBucket" : "arn:aws:s3:::amzn-s3-demo-inventory",
"version" : "2016-11-30",
"creationTimestamp" : "1668560400000",
"fileFormat" : "CSV",
"fileSchema" : "Bucket, Key, Size, LastModifiedDate",
"files" : [ {
"key" : "amzn-s3-demo-bucket/destination-prefix/data/20e55de8-9c21-45d4-99b9-46c732000228.csv.gz",
"size" : 7300,
"MD5checksum" : "a7ff4a1d4164c3cd55851055ec8f6b20"
} ]
}
```
En las siguientes pestañas se muestran ejemplos de la sintaxis del campo `ItemReader` y de la entrada que se transfiere a la ejecución de un flujo de trabajo secundario para este conjunto de datos.
------
#### [ ItemReader syntax ]
```
"ItemReader": {
"ReaderConfig": {
"InputType": "MANIFEST"
},
"Resource": "arn:aws:states:::s3:getObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Key": "destination-prefix/amzn-s3-demo-bucket/config-id/YYYY-MM-DDTHH-MMZ/manifest.json"
}
}
```
------
#### [ Input to a child workflow execution ]
```
{
"LastModifiedDate": "2022-11-16T00:29:32.000Z",
"Bucket": "amzn-s3-demo-source-bucket",
"Size": "3399671",
"Key": "csvDataset/titles.csv"
}
```
En función de los campos que haya seleccionado al configurar el informe de inventario de Amazon S3, el contenido del archivo `manifest.json` puede variar con respecto al ejemplo.
------
## Recomendaciones de políticas de IAM para conjuntos de datos
Al crear flujos de trabajo con la consola de Step Functions, Step Functions puede generar automáticamente políticas de IAM basadas en los recursos de la definición de flujo de trabajo. Las políticas generadas incluyen los privilegios mínimos necesarios para permitir que la función de máquina de estado invoque la acción de la `[StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)` API para los AWS recursos de *estado y acceso del mapa distribuido*, como los buckets y objetos de Amazon S3 y las funciones de Lambda.
Le recomendamos que incluya únicamente los permisos necesarios en las políticas de IAM. Por ejemplo, si el flujo de trabajo incluye un estado `Map` en modo Distribuido, aplique las políticas al bucket y a la carpeta de Amazon S3 específicos que contengan los datos.
**importante**
Si especifica un bucket y un objeto de Amazon S3, o un prefijo, con una [ruta de referencia](amazon-states-language-paths.md#amazon-states-language-reference-paths) a un par clave-valor existente en la entrada del *estado Map Distributed*, no olvide actualizar las políticas de IAM para el flujo de trabajo. Limite las políticas hasta los nombres de objeto y bucket a los que se dirige la ruta en tiempo de ejecución.
Los siguientes ejemplos muestran técnicas para conceder los privilegios mínimos necesarios para acceder a sus conjuntos de datos de Amazon S3 mediante la [ListObjectsV2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html) y las acciones de la [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)API.
**Example condición que usa un objeto de Amazon S3 como conjunto de datos**
La siguiente condición otorga privilegios mínimos para acceder a los objetos de una carpeta `processImages` de un bucket de Amazon S3.
```
"Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ],
"Condition": {
"StringLike": {
"s3:prefix": [ "processImages" ]
}
}
```
**Example uso de un archivo CSV como conjunto de datos**
En el siguiente ejemplo se muestran las acciones necesarias para acceder a un archivo CSV denominado `ratings.csv`.
```
"Action": [ "s3:GetObject" ],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/csvDataset/ratings.csv"
]
```
**Example uso de un inventario de Amazon S3 como conjunto de datos**
A continuación, se muestran ejemplos de recursos para un manifiesto de inventario y archivos de datos de Amazon S3.
```
"Resource": [
"arn:aws:s3:::myPrefix/amzn-s3-demo-bucket/myConfig-id/YYYY-MM-DDTHH-MMZ/manifest.json",
"arn:aws:s3:::myPrefix/amzn-s3-demo-bucket/myConfig-id/data/*"
]
```
**Example usar ListObjects V2 para restringirlo a un prefijo de carpeta**
Al usar [ListObjectsV2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html), se generarán dos políticas. Una es necesaria para poder **mostrar** el contenido del bucket (`ListBucket`) y otra política permitirá **recuperar los objetos** del bucket (`GetObject`).
A continuación, se muestran ejemplos de acciones, recursos y una condición:
```
"Action": [ "s3:ListBucket" ],
"Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ],
"Condition": {
"StringLike": {
"s3:prefix": [ "/path/to/your/json/" ]
}
}
```
```
"Action": [ "s3:GetObject" ],
"Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/path/to/your/json/*" ]
```
Tenga en cuenta que `GetObject` no se limitará al ámbito y utilizará un comodín (`*`) para el objeto.
# ItemsPath ( JSONPath Solo mapa)
**Administración del estado y transformación de los datos**
Esta página hace referencia a JSONPath. Step Functions agregó recientemente variables y JSONata para administrar el estado y transformar los datos.
Obtenga información sobre cómo [pasar datos con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
En los estados JSONPath basados, usa el `ItemsPath` campo para seleccionar una matriz u objeto dentro de una entrada JSON proporcionada a un `Map` estado. De forma predeterminada, un estado `Map` establece `ItemsPath` en `$`, lo que selecciona toda la entrada.
+ Si la entrada al `Map` estado es una matriz JSON, ejecuta una iteración para cada elemento de la matriz y pasa ese elemento a la iteración como entrada
+ Si la entrada al `Map` estado es un objeto JSON, ejecuta una iteración para cada par clave-valor del objeto y pasa el par a la iteración como entrada
**nota**
Puede usar `ItemsPath` en el *estado Map Distributed* solo si usa una entrada JSON pasada desde un estado anterior del flujo de trabajo.
El valor de `ItemsPath` debe ser una ruta de [referencia y esa ruta](amazon-states-language-paths.md#amazon-states-language-reference-paths) debe dar como resultado una matriz u objeto JSON. Por ejemplo, supongamos que la entrada a un estado `Map` incluye dos matrices, como en el siguiente ejemplo.
```
{
"ThingsPiratesSay": [
{
"say": "Avast!"
},
{
"say": "Yar!"
},
{
"say": "Walk the Plank!"
}
],
"ThingsGiantsSay": [
{
"say": "Fee!"
},
{
"say": "Fi!"
},
{
"say": "Fo!"
},
{
"say": "Fum!"
}
]
}
```
En este caso, puede especificar qué matriz se ha de utilizar para las iteraciones del estado `Map` seleccionándola mediante `ItemsPath`. La siguiente definición de máquina de estado especifica la matriz `ThingsPiratesSay` en la entrada mediante `ItemsPath`. A continuación, ejecuta una iteración del estado de paso `SayWord` para cada elemento de la matriz `ThingsPiratesSay`.
```
{
"StartAt": "PiratesSay",
"States": {
"PiratesSay": {
"Type": "Map",
"ItemsPath": "$.ThingsPiratesSay",
"ItemProcessor": {
"StartAt": "SayWord",
"States": {
"SayWord": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
En el caso de los objetos JSON anidados, puede `ItemsPath` utilizarlos para seleccionar un objeto específico dentro de la entrada. Considera la siguiente entrada con datos de configuración anidados:
```
{
"environment": "production",
"servers": {
"web": {
"server1": {"port": 80, "status": "active"},
"server2": {"port": 8080, "status": "inactive"}
},
"database": {
"primary": {"host": "db1.example.com", "port": 5432},
"replica": {"host": "db2.example.com", "port": 5432}
}
}
}
```
Para recorrer en iteración el objeto del servidor web, debe `ItemsPath` configurarlo de la siguiente manera: `$.servers.web`
```
{
"StartAt": "ProcessWebServers",
"States": {
"ProcessWebServers": {
"Type": "Map",
"ItemsPath": "$.servers.web",
"ItemProcessor": {
"StartAt": "CheckServer",
"States": {
"CheckServer": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
Al procesar la entrada, el `Map` estado aplica `ItemsPath` después de [`InputPath`](input-output-inputpath-params.md#input-output-inputpath). Opera en la entrada efectiva al estado, después de que `InputPath` filtre la entrada.
Para obtener más información acerca de los estados `Map`, consulte los temas siguientes:
+ [Estado Map](state-map.md)
+ [Modos de procesamiento del estado Map](state-map.md#concepts-map-process-modes)
+ [Repetir acciones con Inline Map](tutorial-map-inline.md)
+ [Procesamiento de entrada y salida del estado `Map` en línea](state-map-inline.md#inline-map-state-output)
# ItemSelector (Map)
**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).
De forma predeterminada, la entrada efectiva para el estado `Map` es el conjunto de elementos de datos individuales presentes en la entrada de estado sin procesar. Con el campo `ItemSelector`, puede anular los valores de los elementos de datos antes de que se pasen al estado `Map`.
Para anular los valores, especifique una entrada JSON válida que contenga un conjunto de pares clave-valor. Los pares pueden ser valores estáticos proporcionados en la definición de la máquina de estado, valores seleccionados de la entrada de estado mediante una [ruta](amazon-states-language-paths.md) o valores a los que se acceda desde el [objeto Context](input-output-contextobject.md).
Si especifica pares clave-valor mediante una ruta o un objeto Context, el nombre de la clave debe terminar en `.$`.
**nota**
El campo `ItemSelector` reemplaza al campo `Parameters` dentro del estado `Map`. Si utiliza el campo `Parameters` en las definiciones de estado `Map` para crear entradas personalizadas, le recomendamos que lo sustituya por `ItemSelector`.
Puede especificar el campo `ItemSelector` tanto en un *estado Map en línea* como en un *estado Map Distributed*.
Por ejemplo, considere la siguiente entrada JSON que contiene una matriz de tres elementos dentro del nodo `imageData`. Por cada *iteración del estado `Map`*, se pasa un elemento de matriz a la iteración como entrada.
```
[
{
"resize": "true",
"format": "jpg"
},
{
"resize": "false",
"format": "png"
},
{
"resize": "true",
"format": "jpg"
}
]
```
Con el campo `ItemSelector`, puede definir una entrada JSON personalizada para anular la entrada original, como se muestra en el siguiente ejemplo. Luego, Step Functions pasa esta entrada personalizada a cada *iteración del estado `Map`*. La entrada personalizada contiene un valor estático para `size` y el valor de los datos de un objeto Context para el estado `Map`. El objeto Context `$$.Map.Item.Value` contiene el valor de cada elemento de datos individual.
```
{
"ItemSelector": {
"size": 10,
"value.$": "$$.Map.Item.Value"
}
}
```
El siguiente ejemplo muestra la entrada recibida por una iteración del *estado Map en línea*:
```
{
"size": 10,
"value": {
"resize": "true",
"format": "jpg"
}
}
```
**sugerencia**
Para ver un ejemplo completo de un *estado Map Distributed* que usa el campo `ItemSelector`, consulte [Copiar datos CSV a gran escala mediante Distributed Map](tutorial-map-distributed.md).
# ItemBatcher (Map)
**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).
El campo `ItemBatcher` es un objeto JSON que especifica el procesamiento de un grupo de elementos en una sola ejecución de flujo de trabajo secundario. Utilice el procesamiento por lotes cuando procese archivos CSV o matrices JSON de gran tamaño, o conjuntos grandes de objetos de Amazon S3.
En el ejemplo siguiente se muestra la sintaxis del campo `ItemBatcher`. En la siguiente sintaxis, el número máximo de elementos que debe procesar cada ejecución de flujo de trabajo secundario se establece en 100.
```
{
"ItemBatcher": {
"MaxItemsPerBatch": 100
}
}
```
De forma predeterminada, cada elemento de un conjunto de datos se pasa como entrada a las ejecuciones individuales de los flujos de trabajo secundarios. Por ejemplo, supongamos que especifica un archivo JSON como entrada que contiene la siguiente 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 la entrada dada, cada ejecución del flujo de trabajo secundario recibe un elemento de matriz como entrada. En el siguiente ejemplo, se muestra la entrada de la ejecución de un flujo de trabajo secundario:
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
Para ayudar a optimizar el rendimiento y el costo del trabajo de procesamiento, seleccione un tamaño de lote que equilibre la cantidad de elementos con el tiempo de procesamiento de los elementos. Si utiliza el procesamiento por lotes, Step Functions añade los elementos a una matriz de **elementos**. A continuación, pasa la matriz como entrada a cada ejecución del flujo de trabajo secundario. En el siguiente ejemplo se muestra un lote de dos elementos que se pasan como entrada a la ejecución de un flujo de trabajo secundario:
```
{
"Items": [
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
}
]
}
```
**sugerencia**
Para obtener más información sobre el uso del campo `ItemBatcher` en los flujos de trabajo, pruebe los siguientes tutoriales y talleres:
[Procesamiento de un lote completo de datos dentro de una función de Lambda](tutorial-itembatcher-param-task.md)
[Realizar iteraciones sobre los elementos de un lote dentro de las ejecuciones de flujos de trabajo secundarios](tutorial-itembatcher-single-item-process.md)
[Distributed Map y recursos relacionados](https://catalog.workshops.aws/stepfunctions/use-cases/distributed-map) en *The AWS Step Functions Workshop*
**Contents**
+ [Campos para especificar el procesamiento por lotes de elementos](#input-output-itembatcher-subfields)
## Campos para especificar el procesamiento por lotes de elementos
Para agrupar elementos, especifique el número máximo de elementos a agrupar, el tamaño máximo del lote o ambos. Debe especificar uno de estos valores para agrupar los elementos.
**Número máximo de elementos por lote**
Especifica el número máximo de elementos que procesa cada ejecución de flujo de trabajo secundario. El intérprete limita el número de elementos agrupados en la matriz `Items` a este valor. Si se especifica un número y un tamaño de lote, el intérprete reduce el número de elementos de un lote para evitar superar el límite de tamaño de lote especificado.
Si no se especifica este valor, pero se proporciona un valor para el tamaño máximo del lote, Step Functions procesa tantos elementos como sea posible en cada ejecución del flujo de trabajo secundario sin superar el tamaño máximo del lote en bytes.
Por ejemplo, imagine que realiza una ejecución con un archivo JSON de entrada que contiene 1130 nodos. Si se especifica un valor máximo de elementos para cada lote de 100, Step Functions crea 12 lotes. De estos, 11 lotes contienen 100 elementos cada uno, mientras que el duodécimo lote contiene los 30 elementos restantes.
También puede especificar el número máximo de elementos para cada lote como una [ruta de referencia](amazon-states-language-paths.md#amazon-states-language-reference-paths) a un par clave-valor existente en la entrada de *estado Map Distributed*. Esta ruta debe convertirse en un número entero positivo.
Por ejemplo, en el caso de la entrada siguiente:
```
{
"maxBatchItems": 500
}
```
Puede especificar el número máximo de elementos que va a agrupar mediante una ruta de referencia (**solo JSONPath**) de la siguiente manera:
```
{
...
"Map": {
"Type": "Map",
"MaxConcurrency": 2000,
"ItemBatcher": {
"MaxItemsPerBatchPath": "$.maxBatchItems"
}
...
...
}
}
```
Para los estados **basados en JSONata**, también puede proporcionar una expresión de JSONata que evalúe un número entero positivo.
Puede especificar el subcampo `MaxItemsPerBatch` o `MaxItemsPerBatchPath (JSONPath only)`, pero no ambos.
**Número máximo de KiB por lote**
Especifica el tamaño máximo de un lote en bytes, hasta 256 KiB. Si se especifica un número y un tamaño de lote máximos, Step Functions reduce el número de elementos de un lote para evitar superar el límite de tamaño de lote especificado.
También puede especificar el número máximo de elementos para cada lote como una [ruta de referencia](amazon-states-language-paths.md#amazon-states-language-reference-paths) a un par clave-valor existente en la entrada de *estado Map Distributed*. Esta ruta debe convertirse en un número entero positivo.
Si se utiliza el procesamiento por lotes y no se especifica un tamaño de lote máximo, el intérprete procesa tantos elementos como pueda procesar (hasta 256 KiB) en cada ejecución del flujo de trabajo secundario.
Por ejemplo, en el caso de la entrada siguiente:
```
{
"batchSize": 131072
}
```
Puede especificar el tamaño máximo del lote mediante una ruta de referencia de la siguiente manera:
```
{
...
"Map": {
"Type": "Map",
"MaxConcurrency": 2000,
"ItemBatcher": {
"MaxInputBytesPerBatchPath": "$.batchSize"
}
...
...
}
}
```
Para los estados **basados en JSONata**, también puede proporcionar una expresión de JSONata que evalúe un número entero positivo.
Puede especificar el subcampo `MaxInputBytesPerBatch` o `MaxInputBytesPerBatchPath` (solo JSONPath), pero no ambos.
**Entrada por lotes**
Si lo desea, también puede especificar una entrada JSON fija para incluirla en cada lote que se pase a la ejecución de cada flujo de trabajo secundario. Step Functions fusiona esta entrada con la entrada de cada ejecución individual del flujo de trabajo secundario. Por ejemplo, dada la siguiente entrada fija de una fecha de verificación de datos en una serie de elementos:
```
"ItemBatcher": {
"BatchInput": {
"factCheck": "December 2022"
}
}
```
Cada ejecución de un flujo de trabajo secundario recibe lo siguiente 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 los estados **basados en JSONata**, puede proporcionar expresiones de JSONata directamente a BatchInput o usar expresiones de JSONata dentro de objetos o matrices JSON.
# ResultWriter (Mapa)
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
El campo `ResultWriter` es un objeto JSON que proporciona opciones para los resultados de salida de las ejecuciones de flujos de trabajo secundarios iniciadas por un estado Distributed Map. Puede especificar diferentes opciones de formato para los resultados de salida junto con la ubicación de Amazon S3 para almacenarlos si decide exportarlos. Step Functions no exporta estos resultados de forma predeterminada.
**Topics**
+ [Contenido del ResultWriter campo](#input-output-resultwriter-field-contents)
+ [Ejemplos](#input-output-resultwriter-examples)
+ [Exportación a Amazon S3](#input-output-resultwriter-exporting-to-S3)
+ [Políticas de IAM para ResultWriter](#resultwriter-iam-policies)
## Contenido del ResultWriter campo
El campo `ResultWriter` contiene los siguientes subcampos. La elección de los campos determina el formato de la salida y si se exporta a Amazon S3.
**`ResultWriter`**
Un objeto JSON que especifica los detalles siguientes:
+ `Resource`
La acción de la API de Amazon S3 que Step Functions invoca para exportar los resultados de la ejecución.
+ `Parameters`
Un objeto JSON que especifica el nombre del bucket de Amazon S3 y el prefijo que almacena el resultado de la ejecución.
+ `WriterConfig`
Este campo le permite configurar las siguientes opciones.
+ `Transformation`
+ `NONE`: devuelve la salida de las ejecuciones del flujo de trabajo secundario sin cambios, además de los metadatos del flujo de trabajo. Es el valor predeterminado al exportar los resultados de la ejecución del flujo de trabajo secundario a Amazon S3 y no se especifica `WriterConfig`.
+ `COMPACT`: devuelve el resultado de las ejecuciones del flujo de trabajo secundario. Es el valor predeterminado cuando no se especifica `ResultWriter`.
+ `FLATTEN`: devuelve el resultado de las ejecuciones del flujo de trabajo secundario. Si la ejecución de un flujo de trabajo secundario devuelve una matriz, esta opción aplana la matriz antes de devolver el resultado a una salida de estado o de escribir el resultado en un objeto de Amazon S3.
**nota**
Si se produce un error en la ejecución de un flujo de trabajo secundario, Step Functions devuelve el resultado de la ejecución sin cambios. Los resultados equivaldrían a haber establecido `Transformation` en `NONE`.
+ `OutputType`
+ `JSON`: formatea los resultados como una matriz JSON.
+ `JSONL`: formatea los resultados como líneas JSON
**Combinaciones de campos obligatorios**
El campo `ResultWriter` no puede estar vacío. Debe especificar uno de estos conjuntos de subcampos.
+ `WriterConfig`: para obtener una vista previa de la salida formateada, sin guardar los resultados en Amazon S3.
+ `Resource` y `Parameters`: para guardar los resultados en Amazon S3 sin formato adicional.
+ Los tres campos `WriterConfig`, `Resource` y `Parameters`: para formatear el resultado y guardarlo en Amazon S3.
## Ejemplos de configuraciones y salida de transformación
En los temas siguientes se muestran las posibles opciones de configuración para `ResultWriter` y ejemplos de los resultados procesados de las distintas opciones de transformación.
+ [ResultWriter configuraciones](#input-output-resultwriter-example-configurations)
+ [Transformaciones](#input-output-resultwriter-example-transformations)
### Ejemplos de ResultWriter configuraciones
En los siguientes ejemplos se muestran las configuraciones con las posibles combinaciones de los tres campos: `WriterConfig`, `Resources` y `Parameters`.
**Solo *WriterConfig***
Este ejemplo configura cómo se presenta la salida del estado en la vista previa, con el formato de salida y la transformación especificados en el campo `WriterConfig`. Los campos `Resource` y `Parameters` inexistentes, que habrían proporcionado las especificaciones del bucket de Amazon S3, implican el recurso de la *salida de estado*. Los resultados se pasan al siguiente estado.
```
"ResultWriter": {
"WriterConfig": {
"Transformation": "FLATTEN",
"OutputType": "JSON"
}
}
```
**Solo *recursos* y *parámetros***
En este ejemplo se exporta la salida del estado al bucket de Amazon S3 especificado, sin el formato ni la transformación adicionales que habría especificado el campo `WriterConfig` inexistente.
```
"ResultWriter": {
"Resource": "arn:aws:states:::s3:putObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
```
**Los tres campos: *WriterConfig**Recursos* y *parámetros***
En este ejemplo se formatea la salida del estado según las especificaciones del campo `WriterConfig`. También la exporta a un bucket de Amazon S3 según las especificaciones de los campos `Resource` y `Parameters`.
```
"ResultWriter": {
"WriterConfig": {
"Transformation": "FLATTEN",
"OutputType": "JSON"
},
"Resource": "arn:aws:states:::s3:putObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
}
```
### Ejemplos de transformaciones
Para estos ejemplos, supongamos que cada ejecución del flujo de trabajo secundario devuelve una salida, que es una matriz de objetos.
```
[
{
"customer_id": "145538",
"order_id": "100000"
},
{
"customer_id": "898037",
"order_id": "100001"
}
]
```
En estos ejemplos se muestra la salida formateada para diferentes valores `Transformation`, con `OutputType` de `JSON`.
**Transformación NONE**
Este es un ejemplo del resultado procesado cuando se utiliza la transformación `NONE`. La salida no cambia e incluye los metadatos del flujo de trabajo.
```
[
{
"ExecutionArn": "arn:aws:states:region:account-id:execution:orderProcessing/getOrders:da4e9fc7-abab-3b27-9a77-a277e463b709",
"Input": ...,
"InputDetails": {
"Included": true
},
"Name": "da4e9fc7-abab-3b27-9a77-a277e463b709",
"Output": "[{\"customer_id\":\"145538\",\"order_id\":\"100000\"},{\"customer_id\":\"898037\",\"order_id\":\"100001\"}]",
"OutputDetails": {
"Included": true
},
"RedriveCount": 0,
"RedriveStatus": "NOT_REDRIVABLE",
"RedriveStatusReason": "Execution is SUCCEEDED and cannot be redriven",
"StartDate": "2025-02-04T01:49:50.099Z",
"StateMachineArn": "arn:aws:states:region:account-id:stateMachine:orderProcessing/getOrders",
"Status": "SUCCEEDED",
"StopDate": "2025-02-04T01:49:50.163Z"
},
...
{
"ExecutionArn": "arn:aws:states:region:account-id:execution:orderProcessing/getOrders:f43a56f7-d21e-3fe9-a40c-9b9b8d0adf5a",
"Input": ...,
"InputDetails": {
"Included": true
},
"Name": "f43a56f7-d21e-3fe9-a40c-9b9b8d0adf5a",
"Output": "[{\"customer_id\":\"169881\",\"order_id\":\"100005\"},{\"customer_id\":\"797471\",\"order_id\":\"100006\"}]",
"OutputDetails": {
"Included": true
},
"RedriveCount": 0,
"RedriveStatus": "NOT_REDRIVABLE",
"RedriveStatusReason": "Execution is SUCCEEDED and cannot be redriven",
"StartDate": "2025-02-04T01:49:50.135Z",
"StateMachineArn": "arn:aws:states:region:account-id:stateMachine:orderProcessing/getOrders",
"Status": "SUCCEEDED",
"StopDate": "2025-02-04T01:49:50.227Z"
}
]
```
**Transformation COMPACT**
Este es un ejemplo del resultado procesado cuando se utiliza la transformación `COMPACT`. Tenga en cuenta que se trata de la salida combinada de las ejecuciones del flujo de trabajo secundario con la estructura de matriz original.
```
[
[
{
"customer_id": "145538",
"order_id": "100000"
},
{
"customer_id": "898037",
"order_id": "100001"
}
],
...,
[
{
"customer_id": "169881",
"order_id": "100005"
},
{
"customer_id": "797471",
"order_id": "100006"
}
]
]
```
**Transformación: FLATTEN**
Este es un ejemplo del resultado procesado cuando se utiliza la transformación `FLATTEN`. Tenga en cuenta que se trata de la salida combinada del flujo de trabajo secundario que ejecuta matrices aplanadas en una sola matriz.
```
[
{
"customer_id": "145538",
"order_id": "100000"
},
{
"customer_id": "898037",
"order_id": "100001"
},
...
{
"customer_id": "169881",
"order_id": "100005"
},
{
"customer_id": "797471",
"order_id": "100006"
}
]
```
## Exportación a Amazon S3
**importante**
Asegúrese de que el depósito de Amazon S3 que utiliza para exportar los resultados de una ejecución de mapas esté en la misma máquina de estados Cuenta de AWS y Región de AWS que esté en su máquina de estados. De lo contrario, la ejecución de la máquina de estado fallará y se producirá el error `States.ResultWriterFailed`.
La exportación de los resultados a un bucket de Amazon S3 es útil si el tamaño de la carga de salida es superior a 256 KiB. Step Functions consolida todos los datos de ejecución del flujo de trabajo secundario, como la entrada y salida de la ejecución, el ARN y el estado de ejecución. A continuación, exporta las ejecuciones con el mismo estado a sus archivos respectivos en la ubicación de Amazon S3 especificada.
En el siguiente ejemplo, se muestra la sintaxis del `ResultWriter` campo utilizado `Parameters` para exportar los resultados de la ejecución del flujo de trabajo secundario. **JSONPath** En este ejemplo, los resultados se almacenan en un bucket llamado `amzn-s3-demo-destination-bucket` dentro de un prefijo llamado `csvProcessJobs`.
```
{
"ResultWriter": {
"Resource": "arn:aws:states:::s3:putObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
}
}
```
En el **JSONata**caso de los estados, `Parameters` se sustituirá por`Arguments`.
```
{
"ResultWriter": {
"Resource": "arn:aws:states:::s3:putObject",
"Arguments": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
}
}
```
**sugerencia**
En Workflow Studio, puede exportar los resultados de la ejecución del flujo de trabajo secundario seleccionando **Exportar los resultados del estado Map a Amazon S3**. A continuación, escriba el nombre del bucket de Amazon S3 y el prefijo donde desea exportar los resultados.
Step Functions necesita los permisos adecuados para acceder al bucket y a la carpeta a los que desea exportar los resultados. Para obtener información acerca de la política de IAM necesarias, consulte [Políticas de IAM para ResultWriter](#resultwriter-iam-policies).
Si exporta los resultados de la ejecución del flujo de trabajo secundario, la ejecución del *estado Map Distributed* devuelve el ARN del Map Run y los datos sobre la ubicación de exportación de Amazon S3 en el siguiente formato:
```
{
"MapRunArn": "arn:aws:states:us-east-2:account-id:mapRun:csvProcess/Map:ad9b5f27-090b-3ac6-9beb-243cd77144a7",
"ResultWriterDetails": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Key": "csvProcessJobs/ad9b5f27-090b-3ac6-9beb-243cd77144a7/manifest.json"
}
}
```
Step Functions exporta las ejecuciones con el mismo estado a sus respectivos archivos. Por ejemplo, si las ejecuciones de flujos de trabajo secundarios dieron como resultado 500 resultados satisfactorios y 200 con error, Step Functions creará dos archivos en la ubicación de Amazon S3 especificada para los resultados correctos y erróneos. En este ejemplo, el archivo de resultados con éxito contiene los 500 resultados con éxito, mientras que el archivo de resultados con error contiene los 200 resultados con error.
Para un intento de ejecución determinado, Step Functions crea los siguientes archivos en la ubicación de Amazon S3 especificada en función del resultado de la ejecución:
+ `manifest.json` – Contiene metadatos de Map Run, como la ubicación de exportación, el ARN del Map Run e información sobre los archivos de resultados.
Si ha utilizado [redriven](redrive-map-run.md) con un Map Run, el archivo `manifest.json` contendrá referencias a todas las ejecuciones correctas de flujos de trabajo secundarios en todos los intentos de un Map Run. Sin embargo, este archivo contiene referencias a las ejecuciones con errores y pendientes de un uso específico de redrive.
+ `SUCCEEDED_n.json` – Contiene los datos consolidados de todas las ejecuciones correctas de flujos de trabajo secundarios. *n* representa el número de índice del archivo. El número de índice comienza en 0. Por ejemplo, `SUCCEEDED_1.json`.
+ `FAILED_n.json` – Contiene los datos consolidados de todas las ejecuciones de flujos de trabajo secundarios con error, con tiempo de espera agotado o anuladas. Utilice este archivo para recuperarse de ejecuciones con error. *n* representa el índice del archivo. El número de índice comienza en 0. Por ejemplo, `FAILED_1.json`.
+ `PENDING_n.json` – Contiene los datos consolidados de todas las ejecuciones de flujos de trabajo secundarios que no se iniciaron porque el Map Run produjo un error o se anuló. *n* representa el índice del archivo. El número de índice comienza en 0. Por ejemplo, `PENDING_1.json`.
Step Functions admite archivos de resultados individuales de hasta 5 GB. Si el tamaño de un archivo supera los 5 GB, Step Functions crea otro archivo para escribir el resto de los resultados de la ejecución y añade un número de índice al nombre del archivo. Por ejemplo, si el tamaño del archivo `SUCCEEDED_0.json` supera los 5 GB, Step Functions crea un archivo `SUCCEEDED_1.json` para registrar los resultados restantes.
Si no especifica que se exporten los resultados de la ejecución del flujo de trabajo secundario, la ejecución de la máquina de estado devuelve una matriz de resultados de la ejecución del flujo de trabajo secundario, como se muestra en el siguiente ejemplo:
```
[
{
"statusCode": 200,
"inputReceived": {
"show_id": "s1",
"release_year": "2020",
"rating": "PG-13",
"type": "Movie"
}
},
{
"statusCode": 200,
"inputReceived": {
"show_id": "s2",
"release_year": "2021",
"rating": "TV-MA",
"type": "TV Show"
}
},
...
]
```
**nota**
Si el tamaño de salida devuelto supera los 256 KiB, se produce un error en la ejecución de la máquina de estado y se devuelve un error `States.DataLimitExceeded`.
## Políticas de IAM para ResultWriter
Al crear flujos de trabajo con la consola de Step Functions, Step Functions puede generar automáticamente políticas de IAM basadas en los recursos de la definición de flujo de trabajo. Las políticas generadas incluyen los privilegios mínimos necesarios para permitir que la función de máquina de estado invoque la acción de la `[StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)` API para los AWS recursos de *estado y acceso del mapa distribuido*, como los buckets y objetos de Amazon S3 y las funciones de Lambda.
Le recomendamos que incluya únicamente los permisos necesarios en las políticas de IAM. Por ejemplo, si el flujo de trabajo incluye un estado `Map` en modo Distribuido, aplique las políticas al bucket y a la carpeta de Amazon S3 específicos que contengan los datos.
**importante**
Si especifica un bucket y un objeto de Amazon S3, o un prefijo, con una [ruta de referencia](amazon-states-language-paths.md#amazon-states-language-reference-paths) a un par clave-valor existente en la entrada del *estado Map Distributed*, no olvide actualizar las políticas de IAM para el flujo de trabajo. Limite las políticas hasta los nombres de objeto y bucket a los que se dirige la ruta en tiempo de ejecución.
El siguiente ejemplo de política de IAM otorga los privilegios mínimos necesarios para escribir los resultados de la ejecución del flujo de trabajo secundario en una carpeta nombrada *csvJobs* en un bucket de Amazon S3 mediante la acción de `[PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)` API.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/csvJobs/*"
]
}
]
}
```
Si el bucket de Amazon S3 en el que está escribiendo el resultado de la ejecución del flujo de trabajo secundario está cifrado con una AWS Key Management Service (AWS KMS) clave, debe incluir los AWS KMS permisos necesarios en su política de IAM. Para obtener más información, consulte [Permisos de IAM para un bucket de Amazon S3 AWS KMS key cifrado](iam-policies-eg-dist-map.md#multiupload-dmap-result-policy).
# Cómo analiza Step Functions los archivos CSV de entrada
**Administración del estado y transformación de los datos**
Obtenga información sobre cómo [pasar datos entre estados con variables](workflow-variables.md) y cómo [transformar datos con JSONata](transforming-data.md).
Step Functions analiza los archivos delimitados por texto según las siguientes reglas:
+ El delimitador que separa los campos se especifica `CSVDelimiter` en *ReaderConfig*. El valor predeterminado del delimitador es `COMMA`.
+ Los retornos de carro son un delimitador que separa los **registros**.
+ Los campos se tratan como cadenas. Para las conversiones de tipos de datos, utilice la función intrínseca `States.StringToJson` en [ItemSelector (Map)](input-output-itemselector.md).
+ No es necesario incluir comillas dobles (" ") para delimitar cadenas. No obstante, las cadenas entre comillas dobles pueden contener comas y retornos de carro sin que funcionen como delimitadores de registro.
+ Para conservar las comillas dobles en una secuencia de conservación, repítalas.
+ Las barras diagonales invertidas (\$1) son otra forma de evitar los caracteres especiales. Las barras diagonales invertidas solo funcionan con otras barras diagonales invertidas, comillas dobles y el separador de campos configurado, como una coma o una barra vertical. La barra diagonal invertida seguida de cualquier otro carácter se elimina en silencio.
+ Para conservar las barras diagonales invertidas repitiéndolas. Por ejemplo:
```
path,size
C:\\Program Files\\MyApp.exe,6534512
```
+ Las barras diagonales invertidas que evitan las comillas dobles (`\"`) solo funcionan cuando se incluyen en pares, por lo que recomendamos evitar las comillas dobles repitiéndolas: `""`
+ Si el número de campos de una fila es **inferior** al número de campos del encabezado, Step Functions proporciona **cadenas vacías** para los valores que faltan.
+ Si el número de campos de una fila es **mayor** que el número de campos del encabezado, Step Functions **omite** los campos adicionales.
**Ejemplo de análisis de un archivo CSV de entrada**
Supongamos que ha proporcionado un archivo CSV denominado `myCSVInput.csv` que contiene una fila como entrada. A continuación, ha almacenado este archivo en un bucket de Amazon S3 denominado `amzn-s3-demo-bucket`. El archivo CSV el siguiente.
```
abc,123,"This string contains commas, a double quotation marks (""), and a newline (
)",{""MyKey"":""MyValue""},"[1,2,3]"
```
La siguiente máquina de estado lee este archivo CSV y utiliza [ItemSelector (Map)](input-output-itemselector.md) para convertir los tipos de datos de algunos de los campos.
```
{
"StartAt": "Map",
"States": {
"Map": {
"Type": "Map",
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "DISTRIBUTED",
"ExecutionType": "STANDARD"
},
"StartAt": "Pass",
"States": {
"Pass": {
"Type": "Pass",
"End": true
}
}
},
"End": true,
"Label": "Map",
"MaxConcurrency": 1000,
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "GIVEN",
"CSVHeaders": [
"MyLetters",
"MyNumbers",
"MyString",
"MyObject",
"MyArray"
]
},
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "myCSVInput.csv"
}
},
"ItemSelector": {
"MyLetters.$": "$$.Map.Item.Value.MyLetters",
"MyNumbers.$": "States.StringToJson($$.Map.Item.Value.MyNumbers)",
"MyString.$": "$$.Map.Item.Value.MyString",
"MyObject.$": "States.StringToJson($$.Map.Item.Value.MyObject)",
"MyArray.$": "States.StringToJson($$.Map.Item.Value.MyArray)"
}
}
}
}
```
Cuando ejecuta esta máquina de estado, produce el siguiente resultado.
```
[
{
"MyNumbers": 123,
"MyObject": {
"MyKey": "MyValue"
},
"MyString": "This string contains commas, a double quote (\"), and a newline (\n)",
"MyLetters": "abc",
"MyArray": [
1,
2,
3
]
}
]
```