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.
Spécification de la sortie d'état à l'aide ResultPath des flux de travail Step Functions
La sortie d'un état peut être une copie de son entrée, le résultat qu'il génère (par exemple, la sortie d'une fonction Lambda pour l'état d'une Task) ou une combinaison de l'entrée et du résultat. Utilisez ResultPath pour contrôler les combinaisons de ces stratégies transmises à la sortie de l'état.
Les types d'état suivants peuvent générer un résultat et peuvent inclure ResultPath:
Utilisez ResultPath pour combiner un résultat de tâche avec une entrée de tâche ou pour sélectionner l'une de ces règles. Le chemin que vous fournissez à ResultPath détermine quelles informations sont transmises à la sortie.
Note
ResultPathse limite à l'utilisation de chemins de référence, qui limitent la portée de manière à ne pouvoir identifier qu'un seul nœud dansJSON. Voir Chemins de référence dans le document Langage des états d'Amazon.
Ces exemples sont basés sur la machine à états et la fonction Lambda décrites dans le Création d'une machine d'état Step Functions utilisant Lambda didacticiel. Passez en revue ce didacticiel et testez les différentes sorties en essayant d'indiquer différents chemins dans un champ ResultPath.
Utilisez ResultPath pour :
Astuce
Utilisez le simulateur de flux de données de la console Step Functions
ResultPath À utiliser pour remplacer l'entrée par le résultat
Si vous n'indiquez pas de ResultPath, le comportement par défaut est tel que si vous aviez indiqué "ResultPath": "$". Étant donné que cette option indique à l'état de remplacer la totalité de l'entrée par le résultat, l'entrée de l'état est complètement remplacée par le résultat issu du résultat de la tâche.
Le schéma suivant montre comment ResultPath peut totalement remplacer l'entrée par le résultat de la tâche.
Utilisez la machine à états et la fonction Lambda décrites dansCréation d'une machine d'état Step Functions utilisant Lambda, et remplacez le type d'intégration de service par AWS SDKintégration pour la fonction Lambda. Pour ce faire, spécifiez la fonction Lambda Amazon Resource Name (ARN) dans le Resource champ de l'Taskétat, comme indiqué dans l'exemple suivant. AWS SDKL'intégration garantit que le résultat de l'Taskétat ne contient que la sortie de la fonction Lambda, sans aucune métadonnée.
{
"StartAt":"CallFunction",
"States":{
"CallFunction": {
"Type":"Task",
"Resource":"arn:aws:lambda:us-east-2:123456789012:function:HelloFunction",
"End": true
}
}
} Transmettez ensuite l'entrée suivante :
{ "comment": "This is a test of the input and output of a Task state.", "details": "Default example", "who": "AWS Step Functions" }
La fonction Lambda fournit le résultat suivant.
"Hello, AWS Step Functions!"
Astuce
Vous pouvez consulter ce résultat sur la Step Functionsconsole
S'il ResultPath n'est pas spécifié dans l'état, ou s'il "ResultPath":
"$" est défini, l'entrée de l'état est remplacée par le résultat de la fonction Lambda, et la sortie de l'état est la suivante.
"Hello, AWS Step Functions!"
Note
ResultPath est utilisé pour inclure du contenu issu du résultat avec les données d'entrée, avant de les transmettre à la sortie. Toutefois, si ResultPath n'est pas spécifié, le comportement par défaut consiste à remplacer la totalité de l'entrée.
Supprimer le résultat et conserver l'entrée d'origine
Si vous définissez ResultPath sur null, il transmet l'entrée d'origine à la sortie. À l'aide de "ResultPath": null, la charge utile d'entrée de l'état est copiée directement dans la sortie, sans tenir compte du résultat.
Le diagramme suivant montre comment un null ResultPath copie l'entrée directement dans la sortie.
ResultPath À utiliser pour inclure le résultat dans l'entrée
Le schéma suivant montre comment ResultPath peut inclure le résultat avec l'entrée.
En utilisant la machine à états et la fonction Lambda décrites dans le Création d'une machine d'état Step Functions utilisant Lambda didacticiel, nous pourrions transmettre l'entrée suivante.
{ "comment": "This is a test of the input and output of a Task state.", "details": "Default example", "who": "AWS Step Functions" }
Le résultat de la fonction Lambda est le suivant.
"Hello, AWS Step Functions!"
Pour préserver l'entrée, insérez le résultat de la fonction Lambda, puis passez la combinaison JSON à l'état suivant, nous pourrions ResultPath définir ce qui suit.
"ResultPath": "$.taskresult"
Cela inclut le résultat de la fonction Lambda avec l'entrée d'origine.
{ "comment": "This is a test of input and output of a Task state.", "details": "Default behavior example", "who": "AWS Step Functions", "taskresult": "Hello, AWS Step Functions!" }
La sortie de la fonction Lambda est ajoutée à l'entrée d'origine sous forme de valeur pour. taskresult L'entrée, y compris la nouvelle valeur insérée, est transmise à l'état suivant.
Vous pouvez également insérer le résultat dans un nœud enfant de l'entrée. Définissez ResultPath comme suit.
"ResultPath": "$.strings.lambdaresult"
Commencez une exécution avec l'entrée suivante.
{ "comment": "An input comment.", "strings": { "string1": "foo", "string2": "bar", "string3": "baz" }, "who": "AWS Step Functions" }
Le résultat de la fonction Lambda est inséré en tant qu'enfant du strings nœud dans l'entrée.
{ "comment": "An input comment.", "strings": { "string1": "foo", "string2": "bar", "string3": "baz", "lambdaresult": "Hello, AWS Step Functions!" }, "who": "AWS Step Functions" }
La sortie d'état inclut désormais l'entrée d'origine JSON avec le résultat en tant que nœud enfant.
ResultPath À utiliser pour mettre à jour un nœud dans l'entrée avec le résultat
Le schéma suivant montre ResultPath comment mettre à jour la valeur des JSON nœuds existants dans l'entrée avec les valeurs du résultat de la tâche.
En utilisant l'exemple de la machine à états et de la fonction Lambda décrits dans le Création d'une machine d'état Step Functions utilisant Lambda didacticiel, nous pourrions transmettre l'entrée suivante.
{ "comment": "This is a test of the input and output of a Task state.", "details": "Default example", "who": "AWS Step Functions" }
Le résultat de la fonction Lambda est le suivant.
Hello, AWS Step Functions!
Au lieu de préserver l'entrée et d'insérer le résultat en tant que nouveau nœud dans leJSON, nous pouvons remplacer un nœud existant.
Par exemple, tout comme le fait d'omettre ou de paramétrer "ResultPath": "$" remplace l'ensemble du nœud, vous pouvez spécifier un nœud en particulier à remplacer par le résultat.
"ResultPath": "$.comment"
Comme le comment nœud existe déjà dans l'entrée d'état, le paramètre ResultPath to "$.comment" remplace ce nœud dans l'entrée par le résultat de la fonction Lambda. Sans filtrer davantage par OutputPath, les données suivantes sont transmises à la sortie.
{ "comment": "Hello, AWS Step Functions!", "details": "Default behavior example", "who": "AWS Step Functions", }
La valeur du comment nœud"This is a test of the input and output
of a Task state.", est remplacée par le résultat de la fonction Lambda : "Hello, AWS
Step Functions!" dans la sortie d'état.
ResultPath À utiliser pour inclure à la fois une erreur et une entrée dans un Catch
Le didacticiel Gestion des conditions d'erreur à l'aide d'une machine à états Step Functions explique comment utiliser une machine d'état pour intercepter une erreur. Dans certains cas, il se peut que vous souhaitiez conserver l'entrée d'origine avec l'erreur. Utilisez ResultPath dans un champ Catch pour inclure l'erreur avec l'entrée d'origine, au lieu de la remplacer :
"Catch": [{ "ErrorEquals": ["States.ALL"], "Next": "NextTask", "ResultPath": "$.error" }]
Si l'instruction Catch précédente intercepte une erreur, elle inclut le résultat dans un nœud error avec l'entrée d'état. Par exemple, pour l'entrée suivante :
{"foo": "bar"}
La sortie de l'état lors de l'interception de l'erreur est :
{ "foo": "bar", "error": { "Error": "Error here" } }
Pour plus d'informations sur la gestion des erreurs, voir :
