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.
# Exemple : manipulation de données d'état à l'aide de chemins dans les flux de travail Step Functions
**Gestion de l'état et transformation des données**
Découvrez comment [transmettre des données entre états à l'aide de variables](workflow-variables.md) et [transformer des données avec JSONata](transforming-data.md).
Cette rubrique contient des exemples de manipulation du JSON d'entrée et de sortie d'état à l'aide des OutputPath champs InputPath ResultPath, et.
Tout état autre qu'un [État du flux de travail défaillant](state-fail.md) état ou un [État du flux de travail réussi](state-succeed.md) état peut inclure les champs de traitement d'entrée et de sortie, tels que `InputPath``ResultPath`, ou`OutputPath`. De plus, les [État du flux de travail choisi](state-choice.md) états [État du flux de travail en attente](state-wait.md) et ne prennent pas en charge le `ResultPath` champ. Avec ces champs, vous pouvez utiliser a [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)pour filtrer les données JSON au fur et à mesure qu'elles se déplacent dans votre flux de travail.
Vous pouvez également utiliser le `Parameters` champ pour manipuler les données JSON au fur et à mesure qu'elles se déplacent dans votre flux de travail. Pour obtenir des informations sur l'utilisation d'`Parameters`, veuillez consulter [Manipulation des paramètres dans les flux de travail Step Functions](input-output-inputpath-params.md).
Par exemple, commencez par la AWS Lambda fonction et la machine à états décrites dans le [Création d'une machine d'état Step Functions utilisant Lambda](tutorial-creating-lambda-state-machine.md) didacticiel. Modifiez la machine d'état afin qu'elle comprenne les éléments `InputPath`, `ResultPath` et `OutputPath` suivants.
```
{
"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
}
}
}
```
Commencez une exécution avec l'entrée suivante.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Supposons que les `extra` nœuds `comment` et peuvent être supprimés, mais que vous souhaitez inclure le résultat de la fonction Lambda et conserver les informations dans `data` le nœud.
Dans la machine d'état mise à jour, l'état `Task` est modifié pour traiter l'entrée pour la tâche.
```
"InputPath": "$.lambda",
```
Cette ligne dans la définition de la machine d'état limite l'entrée de tâche au nœud `lambda` de l'entrée d'état uniquement. La fonction Lambda reçoit uniquement l'objet JSON `{"who": "AWS Step Functions"}` en entrée.
```
"ResultPath": "$.data.lambdaresult",
```
Cela `ResultPath` indique à la machine à états d'insérer le résultat de la fonction Lambda dans un nœud nommé`lambdaresult`, en tant qu'enfant du `data` nœud dans l'entrée de la machine à états d'origine. Comme vous n'effectuez aucune autre manipulation sur l'entrée d'origine et sur le résultat en utilisant`OutputPath`, la sortie de l'état inclut désormais le résultat de la fonction Lambda avec l'entrée d'origine.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Mais notre objectif était de ne conserver que le `data` nœud et d'inclure le résultat de la fonction Lambda. `OutputPath`filtre ce JSON combiné avant de le transmettre à la sortie d'état.
```
"OutputPath": "$.data",
```
Ainsi, seul le nœud `data` de l'entrée d'origine est sélectionné (y compris l'enfant `lambdaresult` inséré par `ResultPath`) comme devant être transmis à la sortie. La sortie de l'état est filtrée sur ce qui suit.
```
{
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
}
```
Dans cet état `Task` :
1. `InputPath`envoie uniquement le `lambda` nœud de l'entrée à la fonction Lambda.
1. `ResultPath` insère le résultat en tant qu'enfant du nœud `data` dans l'entrée d'origine.
1. `OutputPath`filtre l'entrée d'état (qui inclut désormais le résultat de la fonction Lambda) afin qu'elle ne transmette que le `data` nœud à la sortie d'état.
**Example pour manipuler l'entrée, le résultat et la sortie finale de la machine à états d'origine en utilisant JsonPath**
Prenons l'exemple de la machine d'État suivante qui vérifie l'identité et l'adresse d'un demandeur d'assurance.
Pour voir l'exemple complet, consultez [How to use JSON Path 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 vous exécutez cette machine à états en utilisant l'entrée suivante, l'exécution échoue car les fonctions Lambda qui effectuent la vérification attendent uniquement les données à vérifier en entrée. Par conséquent, vous devez spécifier les nœuds qui contiennent les informations à vérifier à l'aide d'une méthode appropriée JsonPath.
```
{
"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
},
]
}
}
```
Pour spécifier le nœud que la fonction `check-identity` Lambda doit utiliser, utilisez le `InputPath` champ comme suit :
```
"InputPath": "$.data.identity"
```
Et pour spécifier le nœud que la fonction `check-address` Lambda doit utiliser, utilisez le `InputPath` champ comme suit :
```
"InputPath": "$.data.address"
```
Maintenant, si vous souhaitez enregistrer le résultat de la vérification dans l'entrée de la machine à états d'origine, utilisez le `ResultPath` champ comme suit :
```
"ResultPath": "$.results"
```
Toutefois, si vous n'avez besoin que des résultats d'identité et de vérification et que vous supprimez l'entrée d'origine, utilisez le `OutputPath` champ comme suit :
```
"OutputPath": "$.results"
```
Pour de plus amples informations, veuillez consulter [Traitement des entrées et des sorties dans Step Functions](concepts-input-output-filtering.md).
## Filtrer la sortie d'état à l'aide OutputPath
`OutputPath`Vous pouvez sélectionner une partie de l'état de sortie à passer à l'état suivant. Cette approche vous permet de filtrer les informations indésirables et de ne transmettre que la partie du JSON dont vous avez besoin.
Si vous ne spécifiez pas une valeur `OutputPath`, la valeur par défaut est `$`. Cela transmet la totalité du nœud JSON (déterminé par l'état d'entrée, la tâche et les résultats `ResultPath`) à l'état suivant.