Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Accès aux données d'exécution depuis l'objet Context dans Step Functions
**Gestion de l'état et transformation des données**
Découvrez comment [transmettre des données entre états avec des variables](workflow-variables.md) et [transformer des données avec JSONata](transforming-data.md).
L'objet Context est une structure JSON interne disponible lors d'une exécution et contenant des informations sur votre machine à états et sur l'exécution. Le contexte fournit à vos flux de travail des informations sur leur exécution spécifique. Vos flux de travail peuvent faire référence à l'objet Context dans une JSONata expression avec`$states.context`.
## Accès à l'objet Context
**Pour accéder à l'objet Context dans JSONata**
Pour accéder à l'objet Context dans JSONata les états, `$states.context` utilisez-le dans une JSONata expression.
```
{
"ExecutionID" : "{% $states.context.Execution.Id %}"
}
```
**Pour accéder à l'objet Context dans JSONPath**
Pour accéder à l'objet Context dans JSONPath, vous devez d'abord l'ajouter `.$` à la fin de la clé pour indiquer que la valeur est un chemin. Ajoutez ensuite la valeur avec `$$.` pour sélectionner un nœud dans l'objet Context.
```
{
"ExecutionID.$": "$$.Execution.Id"
}
```
JSONPath les états peuvent faire référence au contexte (`$$.`) à partir des JSONPath champs suivants :
+ `InputPath`
+ `OutputPath`
+ `ItemsPath`(dans les états de la carte)
+ `Variable`(dans les États de Choice)
+ `ResultSelector`
+ `Parameters`
+ Opérateurs de comparaison de variables à variables
## Champs d'objets contextuels
L'objet Context inclut des informations sur la machine à états, l'état, l'exécution et la tâche. L'objet Context JSON inclut des nœuds pour chaque type de données au format suivant :
```
{
"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"
}
}
```
Lors d'une exécution, l'objet Context est renseigné avec les données pertinentes.
Parfois, de nouveaux champs sont ajoutés au contexte. Si vous traitez directement le contexte JSON, nous vous recommandons de créer un code capable de gérer facilement les nouveaux champs inconnus. Par exemple, si vous utilisez la bibliothèque Jackson pour désamorcer le code JSON, nous vous recommandons de définir la `FAIL_ON_UNKNOWN_PROPERTIES` valeur `false` dans votre `ObjectMapper` pour éviter un. `UnrecognizedPropertyException`
`RedriveTime`L'objet de contexte n'est disponible que si vous avez redriven une exécution. Si c'est le cas [redriven a Map Run](redrive-map-run.md), l'objet de `RedriveTime` contexte n'est disponible que pour les flux de travail enfants de type Standard. Pour un redriven Map Run avec des flux de travail enfants de type Express, `RedriveTime` ce n'est pas disponible.
Le contenu d'une exécution en cours inclut des informations spécifiques au format suivant :
```
{
"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"
}
}
```
**Format d'horodatage avec des fractions de secondes**
Step Functions suit la ISO8601 spécification qui indique que la sortie peut être de zéro, trois, six ou neuf chiffres selon les besoins. Lorsqu'un horodatage ne comporte aucune fraction de seconde, Step Functions supprime les zéros suivants au lieu de compléter la sortie.
Si vous créez du code qui utilise les horodatages de Step Functions, votre code doit être capable de traiter un nombre variable de fractions de secondes.
## Données d'objets contextuels pour les états de la carte
**Gestion de l'état et transformation des données**
Découvrez comment [transmettre des données entre états avec des variables](workflow-variables.md) et [transformer des données avec JSONata](transforming-data.md).
Lors du traitement d'un [`Map`état](state-map.md), le contexte contient également `Index``Value`, et`Source`.
Pour chaque itération d'`Map`état, `Index` contient le numéro d'index de l'élément du tableau en cours de traitement, `Value` contient l'élément du tableau en cours de traitement et `Source` sera le chiffre InputType de`CSV`, `JSON``JSONL`, ou`PARQUET`.
Dans un `Map` état, l'objet Context inclut les données suivantes :
```
"Map": {
"Item": {
"Index" : Number,
"Key" : "String", // Only valid for JSON objects
"Value" : "String",
"Source": "String"
}
}
```
Ils ne sont disponibles que dans un `Map` état et peuvent être spécifiés dans le `ItemSelector (Carte)` champ.
**Note**
Vous devez définir les paramètres à partir de l'objet Context dans le `ItemSelector` bloc de `Map` l'état principal, et non dans les états inclus dans la `ItemProcessor` section.
Étant donné qu'une machine à états utilise un **JSONPath**`Map`état, vous pouvez injecter des informations à partir de l'objet Context comme suit.
```
{
"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
}
}
}
```
En effet JSONata, les informations contextuelles supplémentaires sur l'état de la carte sont accessibles à partir de 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 vous exécutez la machine d'état précédente avec l'entrée suivante, les éléments `Index` et `Value` sont insérés dans la sortie.
```
[
{
"who": "bob"
},
{
"who": "meg"
},
{
"who": "joe"
}
]
```
Le résultat de l'exécution renvoie les valeurs de `Index` et `Value` les éléments pour chacune des trois itérations, comme suit :
```
[
{
"ContextIndex": 0,
"ContextValue": {
"who": "bob"
},
"ContextSource" : "STATE_DATA"
},
{
"ContextIndex": 1,
"ContextValue": {
"who": "meg"
},
"ContextSource" : "STATE_DATA"
},
{
"ContextIndex": 2,
"ContextValue": {
"who": "joe"
},
"ContextSource" : "STATE_DATA"
}
]
```
Notez que ce `$states.context.Map.Item.Source` sera l'un des suivants :
+ Pour la saisie de l'état, la valeur sera : `STATE_DATA`
+ Pour `Amazon S3 LIST_OBJECTS_V2` with`Transformation=NONE`, la valeur indiquera l'URI S3 du compartiment. Par exemple : `S3://bucket-name`.
+ Pour tous les autres types d'entrée, la valeur sera l'URI Amazon S3. Par exemple : `S3://bucket-name/object-key`.