Considérations relatives à l'utilisation de l' TestState API Utilisation des niveaux d'inspection dans TestState l'API IAM autorisations d'utilisation de l' TestState API Tester un état (console)Tester un état en utilisant AWS CLI Test et débogage du flux de données d'entrée et de sortie

Utiliser l' TestState API pour tester un état dans Step Functions

L'TestStateAPI accepte la définition d'un état unique et l'exécute. Vous pouvez tester un état sans créer de machine à états ni mettre à jour une machine à états existante.

À l'aide de TestState l'API, vous pouvez tester les éléments suivants :

Flux de données de traitement d'entrée et de sortie d'un État.
Une Service AWS intégration avec d'autres Services AWS demandes et réponses
Une demande et une réponse à une tâche HTTP

Pour tester un état, vous pouvez également utiliser Step Functions console, AWS Command Line Interface (AWS CLI), ou le SDK.

L'TestStateAPI assume un rôle IAM qui doit contenir les éléments requis IAM autorisations pour les ressources auxquelles votre État accède. Pour plus d'informations sur les autorisations dont un État peut avoir besoin, consultezIAM autorisations d'utilisation de l' TestState API.

Rubriques

Considérations relatives à l'utilisation de l' TestState API
Utilisation des niveaux d'inspection dans TestState l'API
IAM autorisations d'utilisation de l' TestState API
Tester un état (console)
Tester un état en utilisant AWS CLI
Test et débogage du flux de données d'entrée et de sortie

Considérations relatives à l'utilisation de l' TestState API

À l'aide de l'TestStateAPI, vous ne pouvez tester qu'un seul état à la fois. Les états que vous pouvez tester sont les suivants :

Lorsque vous utilisez l'TestStateAPI, gardez à l'esprit les considérations suivantes.

L' TestState API ne prend pas en charge les éléments suivants :
- État du flux de travail des tâchesÉtats qui utilisent les types de ressources suivants :
  - Activité
  - Modèles d'intégration des services de type .sync ou .waitForTaskToken
- État du flux de travail parallèleétat
- État du flux de travail cartographiqueétat
Un test peut durer jusqu'à cinq minutes. Si un test dépasse cette durée, il échoue avec l'States.Timeouterreur.

Utilisation des niveaux d'inspection dans TestState l'API

Pour tester un état à l'aide de l'TestStateAPI, vous devez fournir la définition de cet état. Le test renvoie ensuite une sortie. Pour chaque État, vous pouvez spécifier la quantité de détails que vous souhaitez afficher dans les résultats des tests. Ces informations fournissent des informations supplémentaires sur l'état que vous testez. Par exemple, si vous avez utilisé des filtres de traitement des données d'entrée et de sortie, tels que InputPathou ResultPathdans un état, vous pouvez afficher les résultats intermédiaires et finaux du traitement des données.

Step Functions fournit les niveaux suivants pour spécifier les détails que vous souhaitez afficher :

INFOS
DÉBOGAGE
TRACE

Tous ces niveaux renvoient également les nextState champs status et. statusindique le statut de l'exécution de l'état. Par exemple, SUCCEEDEDFAILED,RETRIABLE, etCAUGHT_ERROR. nextStateindique le nom du prochain état vers lequel effectuer la transition. Si vous n'avez pas défini d'état suivant dans votre définition, ce champ renvoie une valeur vide.

Pour plus d'informations sur le test d'un état à l'aide de ces niveaux d'inspection dans le Step Functions console et AWS CLI, voir Tester un état (console) etTester un état en utilisant AWS CLI.

Niveau d'inspection INFO

Si le test réussit, ce niveau indique l'état de sortie. Si le test échoue, ce niveau indique le résultat de l'erreur. Par défaut, Step Functions définit le niveau d'inspection sur INFO si vous ne spécifiez aucun niveau.

L'image suivante montre un test de réussite du statut Pass. Le niveau d'inspection pour cet état est défini sur INFO et le résultat correspondant à l'état apparaît dans l'onglet Sortie.

Capture d'écran de la sortie au niveau INFO pour un test réussi.

L'image suivante montre un test qui a échoué pour un état de tâche lorsque le niveau d'inspection est défini sur INFO. L'onglet Sortie affiche le résultat d'erreur qui inclut le nom de l'erreur et une explication détaillée de la cause de cette erreur.

Capture d'écran de la sortie au niveau INFO pour un test raté.

Niveau d'inspection DEBUG

Si le test réussit, ce niveau indique l'état de sortie et le résultat du traitement des données d'entrée et de sortie.

Si le test échoue, ce niveau indique le résultat de l'erreur. Ce niveau indique les résultats intermédiaires du traitement des données jusqu'au point de défaillance. Supposons, par exemple, que vous ayez testé un état de tâche qui invoque un Lambda . Imaginez que vous ayez appliqué les Filtrer la sortie d'état à l'aide OutputPath filtres InputPath Paramètres,Spécification de la sortie d'état à l'aide ResultPath de in Step Functions, et à l'état de la tâche. Supposons que l'invocation ait échoué. Dans ce cas, le DEBUG niveau affiche les résultats du traitement des données en fonction de l'application des filtres dans l'ordre suivant :

input— Entrée d'état brute
afterInputPath— Saisie après Step Functions applique le InputPath filtre.
afterParameters— La saisie effective après Step Functions applique le Parameters filtre.

Les informations de diagnostic disponibles à ce niveau peuvent vous aider à résoudre les problèmes liés à une intégration de services ou à un flux de traitement des données d'entrée et de sortie que vous avez peut-être défini.

L'image suivante montre un test de réussite du statut Pass. Le niveau d'inspection pour cet état est défini sur DEBUG. L'onglet Traitement des entrées/sorties de l'image suivante montre le résultat de l'application de Parameterssur l'entrée prévue pour cet état.

Capture d'écran de la sortie au niveau DEBUG pour un test réussi.

L'image suivante montre un test qui a échoué pour un état de tâche lorsque le niveau d'inspection est défini sur DEBUG. L'onglet Traitement des entrées/sorties de l'image suivante montre le résultat du traitement des données d'entrée et de sortie pour l'état jusqu'à sa défaillance.

Capture d'écran de la sortie au niveau DEBUG pour un test raté.

Niveau d'inspection TRACE

Step Functions fournit le niveau TRACE pour tester une tâche HTTP. Ce niveau renvoie des informations sur la requête HTTP qui Step Functions fait et répond qu'une API HTTPS renvoie. La réponse peut contenir des informations, telles que les en-têtes et le corps de la demande. De plus, vous pouvez visualiser l'état de sortie et le résultat du traitement des données d'entrée et de sortie à ce niveau.

Si le test échoue, ce niveau indique le résultat de l'erreur.

Ce niveau ne s'applique qu'à la tâche HTTP. Step Functions génère une erreur si vous utilisez ce niveau pour d'autres types d'états.

Lorsque vous définissez le niveau d'inspection sur TRACE, vous pouvez également consulter les secrets inclus dans la EventBridge connexion. Pour ce faire, vous devez définir le revealSecrets paramètre sur true dans l'TestStateAPI. En outre, vous devez vous assurer que IAM l'utilisateur qui appelle l' TestState API est autorisé à effectuer cette states:RevealSecrets action. Pour un exemple de IAM politique qui définit l'states:RevealSecretsautorisation, voirIAM autorisations d'utilisation de l' TestState API. Sans cette autorisation, Step Functions renvoie une erreur de refus d'accès.

Si vous définissez le revealSecrets paramètre surfalse, Step Functions omet tous les secrets contenus dans les données de requête et de réponse HTTP.

L'image suivante montre un test de réussite d'une tâche HTTP. Le niveau d'inspection pour cet état est défini sur TRACE. L'onglet Requête et réponse HTTP de l'image suivante montre le résultat de l'appel d'API HTTPS.

Capture d'écran de la sortie au niveau TRACE pour un test réussi.

IAM autorisations d'utilisation de l' TestState API

Le IAM l'utilisateur qui appelle l'TestStateAPI doit être autorisé à effectuer les iam:PassRole actions states:TestState et. En outre, si vous définissez le paramètre RevealSecrets surtrue, vous devez vous assurer que IAM l'utilisateur est autorisé à effectuer l'states:RevealSecretsaction. Sans cette autorisation, Step Functions renvoie une erreur de refus d'accès.

Vous devez également vous assurer que votre rôle d'exécution contient les éléments requis IAM autorisations pour les ressources auxquelles votre État accède. Pour plus d'informations sur les autorisations dont un État peut avoir besoin, consultez la section Gestion des rôles d'exécution.

Procédez comme suit : IAM Un exemple de politique définit les states:RevealSecrets autorisations states:TestStateiam:PassRole, et.


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "states:TestState",
        "states:RevealSecrets",
        "iam:PassRole"
      ],
      "Resource": "*"
    }
  ]
}

Tester un état (console)

Vous pouvez tester un état dans la console et vérifier l'état de sortie ou le flux de traitement des données d'entrée et de sortie. Pour une tâche HTTP, vous pouvez tester la requête et la réponse HTTP brutes.

Pour tester un état

Ouvrez la console Step Functions.
Choisissez Créer une machine à états pour commencer à créer une machine à états ou choisissez une machine à états existante.
Dans Workflow Studio, choisissez l'état que vous souhaitez tester. Mode de conception
Choisissez Test state dans le Panneau Inspector panneau de Workflow Studio.
Dans la boîte de dialogue État du test, procédez comme suit :
1. Pour Rôle d'exécution, choisissez un rôle d'exécution pour tester l'état. Assurez-vous que vous disposez des éléments requis IAM autorisations pour l'état que vous souhaitez tester.
2. (Facultatif) Fournissez toute entrée JSON dont l'état sélectionné a besoin pour le test.
3. Pour le niveau d'inspection, sélectionnez l'une des options suivantes en fonction des valeurs que vous souhaitez afficher :
  - INFO — Affiche l'état de sortie dans l'onglet Sortie si le test réussit. Si le test échoue, INFO affiche le résultat de l'erreur, qui inclut le nom de l'erreur et une explication détaillée de la cause de cette erreur. Par défaut, Step Functions définit le niveau d'inspection sur INFO si vous ne sélectionnez aucun niveau.
  - DEBUG — Affiche l'état de sortie et le résultat du traitement des données d'entrée et de sortie en cas de réussite du test. Si le test échoue, DEBUG affiche le résultat de l'erreur, qui inclut le nom de l'erreur et une explication détaillée de la cause de cette erreur.
  - TRACE — Affiche la requête et la réponse HTTP brutes et est utile pour vérifier les en-têtes, les paramètres de requête et d'autres détails spécifiques à l'API. Cette option n'est disponible que pour la tâche HTTP.
    
    Vous pouvez éventuellement choisir de sélectionner Révéler les secrets. Associé à TRACE, ce paramètre vous permet de voir les données sensibles que EventBridge des inserts de connexion, tels que des clés d'API. Le IAM l'identité utilisateur que vous utilisez pour accéder à la console doit être autorisée à effectuer l'states:RevealSecretsaction. Sans cette autorisation, Step Functions génère une erreur de refus d'accès lorsque vous lancez le test. Pour un exemple de IAM politique qui définit l'states:RevealSecretsautorisation, voirIAM autorisations d'utilisation de l' TestState API.
4. Choisissez Démarrer le test.

Tester un état en utilisant AWS CLI

Vous pouvez tester un état pris en charge à l'aide de l'TestStateAPI du AWS CLI. Cette API accepte la définition d'un état et l'exécute.

Pour chaque État, vous pouvez spécifier la quantité de détails que vous souhaitez afficher dans les résultats des tests. Ces informations fournissent des informations supplémentaires sur l'exécution de l'État, notamment le résultat du traitement des données d'entrée et de sortie et les informations de requête et de réponse HTTP. Les exemples suivants présentent les différents niveaux d'inspection que vous pouvez spécifier pour l' TestState API. N'oubliez pas de remplacer le italicized texte par les informations spécifiques à votre ressource.

Cette section contient les exemples suivants qui décrivent comment vous pouvez utiliser les différents niveaux d'inspection qui Step Functions prévoit dans le AWS CLI:

Utilisation d'INFO InspectionLevel
Utilisation de DEBUG InspectionLevel
Utilisation de TRACE InspectionLevel
Utilisation de l'utilitaire jq dans AWS CLI pour filtrer et imprimer la réponse HTTP renvoyée par TestState l'API

Exemple 1 : utilisation d'INFO InspectionLevel pour tester un état Choice

Pour tester un état à l'aide du INFO paramètre InspectionLevel dans le AWS CLI, exécutez la test-state commande comme indiqué dans l'exemple suivant.


aws stepfunctions test-state \
    --definition '{"Type": "Choice", "Choices": [{"Variable": "$.number", "NumericEquals": 1, "Next": "Equals 1"}, {"Variable": "$.number", "NumericEquals": 2, "Next": "Equals 2"}], "Default": "No Match"}' \
    --role-arn arn:aws:iam::123456789012:role/myRole \
    --input '{"number": 2}'

Cet exemple utilise un état Choice pour déterminer le chemin d'exécution de cet état en fonction de l'entrée numérique que vous fournissez. Par défaut, Step Functions définit le inspectionLevel to INFO si vous ne définissez pas de niveau.

Step Functions renvoie le résultat suivant.


{
    "output": "{\"number\": 2}",
    "nextState": "Equals 2",
    "status": "SUCCEEDED"
}

Exemple 2 : utilisation de DEBUG InspectionLevel pour déboguer le traitement des données d'entrée et de sortie dans un état Passage

Pour tester un état à l'aide du DEBUG paramètre InspectionLevel dans le AWS CLI, exécutez la test-state commande comme indiqué dans l'exemple suivant.


aws stepfunctions test-state \
    --definition '{"Type": "Pass", "InputPath": "$.payload", "Parameters": {"data": 1}, "ResultPath": "$.result", "OutputPath": "$.result.data", "Next": "Another State"}' \
    --role-arn arn:aws:iam::123456789012:role/myRole \
    --input '{"payload": {"foo": "bar"}}' \
    --inspection-level DEBUG

Cet exemple utilise un Passer l'état du flux de travail état pour montrer comment Step Functions filtre et manipule les données JSON d'entrée à l'aide des filtres de traitement des données d'entrée et de sortie. Cet exemple utilise les filtres suivants : InputPathParamètres,Spécification de la sortie d'état à l'aide ResultPath de in Step Functions, etFiltrer la sortie d'état à l'aide OutputPath.

Step Functions renvoie le résultat suivant.


{
    "output": "1",
    "inspectionData": {
        "input": "{\"payload\": {\"foo\": \"bar\"}}",
        "afterInputPath": "{\"foo\":\"bar\"}",
        "afterParameters": "{\"data\":1}",
        "afterResultSelector": "{\"data\":1}",
        "afterResultPath": "{\"payload\":{\"foo\":\"bar\"},\"result\":{\"data\":1}}"
    },
    "nextState": "Another State",
    "status": "SUCCEEDED"
}

Exemple 3 : utilisation de TRACE InspectionLevel et RevealSecrets pour inspecter la requête HTTP envoyée à une API HTTPS

Pour tester une tâche HTTP en utilisant TRACE InspectionLevel avec le paramètre RevealSecrets dans le AWS CLI, exécutez la test-state commande comme indiqué dans l'exemple suivant.


aws stepfunctions test-state \
    --definition '{"Type": "Task", "Resource": "arn:aws:states:::http:invoke", "Parameters": {"Method": "GET", "Authentication": {"ConnectionArn": "arn:aws:events:us-east-1:123456789012:connection/MyConnection/0000000-0000-0000-0000-000000000000"}, "ApiEndpoint": "https://httpbin.org/get", "Headers": {"definitionHeader": "h1"}, "RequestBody": {"message": "Hello from Step Functions!"}, "QueryParameters": {"queryParam": "q1"}}, "End": true}' \
    --role-arn arn:aws:iam::123456789012:role/myRole \
    --inspection-level TRACE \
    --reveal-secrets

Cet exemple teste si la tâche HTTP appelle l'API HTTPS spécifiée,https://httpbin.org/. Il affiche également les données de requête et de réponse HTTP pour l'appel d'API.


{
    "output": "{\"Headers\":{\"date\":[\"Tue, 21 Nov 2023 00:06:17 GMT\"],\"access-control-allow-origin\":[\"*\"],\"content-length\":[\"620\"],\"server\":[\"gunicorn/19.9.0\"],\"access-control-allow-credentials\":[\"true\"],\"content-type\":[\"application/json\"]},\"ResponseBody\":{\"args\":{\"QueryParam1\":\"QueryParamValue1\",\"queryParam\":\"q1\"},\"headers\":{\"Authorization\":\"Basic XXXXXXXX\",\"Content-Type\":\"application/json; charset=UTF-8\",\"Customheader1\":\"CustomHeaderValue1\",\"Definitionheader\":\"h1\",\"Host\":\"httpbin.org\",\"Range\":\"bytes=0-262144\",\"Transfer-Encoding\":\"chunked\",\"User-Agent\":\"Amazon|StepFunctions|HttpInvoke|us-east-1\",\"X-Amzn-Trace-Id\":\"Root=1-0000000-0000-0000-0000-000000000000\"},\"origin\":\"12.34.567.891\",\"url\":\"https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1\"},\"StatusCode\":200,\"StatusText\":\"OK\"}",
    "inspectionData": {
        "input": "{}",
        "afterInputPath": "{}",
        "afterParameters": "{\"Method\":\"GET\",\"Authentication\":{\"ConnectionArn\":\"arn:aws:events:us-east-1:123456789012:connection/foo/a59c10f0-a315-4c1f-be6a-559b9a0c6250\"},\"ApiEndpoint\":\"https://httpbin.org/get\",\"Headers\":{\"definitionHeader\":\"h1\"},\"RequestBody\":{\"message\":\"Hello from Step Functions!\"},\"QueryParameters\":{\"queryParam\":\"q1\"}}",
        "result": "{\"Headers\":{\"date\":[\"Tue, 21 Nov 2023 00:06:17 GMT\"],\"access-control-allow-origin\":[\"*\"],\"content-length\":[\"620\"],\"server\":[\"gunicorn/19.9.0\"],\"access-control-allow-credentials\":[\"true\"],\"content-type\":[\"application/json\"]},\"ResponseBody\":{\"args\":{\"QueryParam1\":\"QueryParamValue1\",\"queryParam\":\"q1\"},\"headers\":{\"Authorization\":\"Basic XXXXXXXX\",\"Content-Type\":\"application/json; charset=UTF-8\",\"Customheader1\":\"CustomHeaderValue1\",\"Definitionheader\":\"h1\",\"Host\":\"httpbin.org\",\"Range\":\"bytes=0-262144\",\"Transfer-Encoding\":\"chunked\",\"User-Agent\":\"Amazon|StepFunctions|HttpInvoke|us-east-1\",\"X-Amzn-Trace-Id\":\"Root=1-0000000-0000-0000-0000-000000000000\"},\"origin\":\"12.34.567.891\",\"url\":\"https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1\"},\"StatusCode\":200,\"StatusText\":\"OK\"}",
        "afterResultSelector": "{\"Headers\":{\"date\":[\"Tue, 21 Nov 2023 00:06:17 GMT\"],\"access-control-allow-origin\":[\"*\"],\"content-length\":[\"620\"],\"server\":[\"gunicorn/19.9.0\"],\"access-control-allow-credentials\":[\"true\"],\"content-type\":[\"application/json\"]},\"ResponseBody\":{\"args\":{\"QueryParam1\":\"QueryParamValue1\",\"queryParam\":\"q1\"},\"headers\":{\"Authorization\":\"Basic XXXXXXXX\",\"Content-Type\":\"application/json; charset=UTF-8\",\"Customheader1\":\"CustomHeaderValue1\",\"Definitionheader\":\"h1\",\"Host\":\"httpbin.org\",\"Range\":\"bytes=0-262144\",\"Transfer-Encoding\":\"chunked\",\"User-Agent\":\"Amazon|StepFunctions|HttpInvoke|us-east-1\",\"X-Amzn-Trace-Id\":\"Root=1-0000000-0000-0000-0000-000000000000\"},\"origin\":\"12.34.567.891\",\"url\":\"https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1\"},\"StatusCode\":200,\"StatusText\":\"OK\"}",
        "afterResultPath": "{\"Headers\":{\"date\":[\"Tue, 21 Nov 2023 00:06:17 GMT\"],\"access-control-allow-origin\":[\"*\"],\"content-length\":[\"620\"],\"server\":[\"gunicorn/19.9.0\"],\"access-control-allow-credentials\":[\"true\"],\"content-type\":[\"application/json\"]},\"ResponseBody\":{\"args\":{\"QueryParam1\":\"QueryParamValue1\",\"queryParam\":\"q1\"},\"headers\":{\"Authorization\":\"Basic XXXXXXXX\",\"Content-Type\":\"application/json; charset=UTF-8\",\"Customheader1\":\"CustomHeaderValue1\",\"Definitionheader\":\"h1\",\"Host\":\"httpbin.org\",\"Range\":\"bytes=0-262144\",\"Transfer-Encoding\":\"chunked\",\"User-Agent\":\"Amazon|StepFunctions|HttpInvoke|us-east-1\",\"X-Amzn-Trace-Id\":\"Root=1-0000000-0000-0000-0000-000000000000\"},\"origin\":\"12.34.567.891\",\"url\":\"https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1\"},\"StatusCode\":200,\"StatusText\":\"OK\"}",
        "request": {
            "protocol": "https",
            "method": "GET",
            "url": "https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1",
            "headers": "[definitionHeader: h1, Authorization: Basic XXXXXXXX, CustomHeader1: CustomHeaderValue1, User-Agent: Amazon|StepFunctions|HttpInvoke|us-east-1, Range: bytes=0-262144]",
            "body": "{\"message\":\"Hello from Step Functions!\",\"BodyKey1\":\"BodyValue1\"}"
        },
        "response": {
            "protocol": "https",
            "statusCode": "200",
            "statusMessage": "OK",
            "headers": "[date: Tue, 21 Nov 2023 00:06:17 GMT, content-type: application/json, content-length: 620, server: gunicorn/19.9.0, access-control-allow-origin: *, access-control-allow-credentials: true]",
            "body": "{\n  \"args\": {\n    \"QueryParam1\": \"QueryParamValue1\", \n    \"queryParam\": \"q1\"\n  }, \n  \"headers\": {\n    \"Authorization\": \"Basic XXXXXXXX\", \n    \"Content-Type\": \"application/json; charset=UTF-8\", \n    \"Customheader1\": \"CustomHeaderValue1\", \n    \"Definitionheader\": \"h1\", \n    \"Host\": \"httpbin.org\", \n    \"Range\": \"bytes=0-262144\", \n    \"Transfer-Encoding\": \"chunked\", \n    \"User-Agent\": \"Amazon|StepFunctions|HttpInvoke|us-east-1\", \n    \"X-Amzn-Trace-Id\": \"Root=1-0000000-0000-0000-0000-000000000000\"\n  }, \n  \"origin\": \"12.34.567.891\", \n  \"url\": \"https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1\"\n}\n"
        }
    },
    "status": "SUCCEEDED"
}

Afficher plus

Afficher moins

Exemple 4 : Utilisation de l'utilitaire jq pour filtrer et imprimer la réponse renvoyée par l' TestState API

L' TestState API renvoie les données JSON sous forme de chaînes échappées dans sa réponse. Procédez comme suit : AWS CLI example étend l'exemple 3 et utilise l'jqutilitaire pour filtrer et imprimer la réponse HTTP renvoyée par l' TestState API dans un format lisible par l'homme. Pour plus d'informations jq et ses instructions d'installation, consultez jq on GitHub.


aws stepfunctions test-state \
    --definition '{"Type": "Task", "Resource": "arn:aws:states:::http:invoke", "Parameters": {"Method": "GET", "Authentication": {"ConnectionArn": "arn:aws:events:us-east-1:123456789012:connection/MyConnection/0000000-0000-0000-0000-000000000000"}, "ApiEndpoint": "https://httpbin.org/get", "Headers": {"definitionHeader": "h1"}, "RequestBody": {"message": "Hello from Step Functions!"}, "QueryParameters": {"queryParam": "q1"}}, "End": true}' \
    --role-arn arn:aws:iam::123456789012:role/myRole \
    --inspection-level TRACE \
    --reveal-secrets \
    | jq '.inspectionData.response.body | fromjson'

L'exemple suivant montre le résultat renvoyé dans un format lisible par l'homme.


{
  "args": {
    "QueryParam1": "QueryParamValue1",
    "queryParam": "q1"
  },
  "headers": {
    "Authorization": "Basic XXXXXXXX",
    "Content-Type": "application/json; charset=UTF-8",
    "Customheader1": "CustomHeaderValue1",
    "Definitionheader": "h1",
    "Host": "httpbin.org",
    "Range": "bytes=0-262144",
    "Transfer-Encoding": "chunked",
    "User-Agent": "Amazon|StepFunctions|HttpInvoke|us-east-1",
    "X-Amzn-Trace-Id": "Root=1-0000000-0000-0000-0000-000000000000"
  },
  "origin": "12.34.567.891",
  "url": "https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1"
}

Test et débogage du flux de données d'entrée et de sortie

L'TestStateAPI est utile pour tester et déboguer les données qui circulent dans votre flux de travail. Cette section fournit quelques concepts clés et explique comment les utiliser TestState à cette fin.

Concepts clés

Entrée Step Functions, le processus de filtrage et de manipulation des données JSON lorsqu'elles passent par les états de votre machine à états est appelé traitement des entrées et des sorties. Pour plus d'informations sur la façon dont cela fonctionne, consultez Traitement des entrées et des sorties dans Step Functions.

Tous les types d'états du Amazon States Language (ASL) (Task, Parallel, Map, Pass, Wait, Choice, Succeed et Fail) partagent un ensemble de champs communs permettant de filtrer et de manipuler les données JSON qui les traversent. Ces champs sont les suivants : InputPath Paramètres,ResultSelector,Spécification de la sortie d'état à l'aide ResultPath de in Step Functions, etFiltrer la sortie d'état à l'aide OutputPath. Support pour chaque domaine varie d'un État à l'autre. Au moment de l'exécution, Step Functions applique chaque champ dans un ordre spécifique. Le schéma suivant montre l'ordre dans lequel ces champs sont appliqués aux données dans un état de tâche :

Ordre des filtres : InputPath, Paramètres ResultSelector, ResultPath, et OutputPath.

La liste suivante décrit l'ordre d'application des champs de traitement d'entrée et de sortie présentés dans le diagramme.

L'entrée d'état correspond aux données JSON transmises à l'état actuel à partir d'un état précédent.
InputPathfiltre une partie de l'entrée d'état brut.
Paramètresconfigure l'ensemble de valeurs à transmettre à la tâche.
La tâche exécute un travail et renvoie un résultat.
ResultSelectorsélectionne un ensemble de valeurs à ne pas inclure dans le résultat de la tâche.
Spécification de la sortie d'état à l'aide ResultPath de in Step Functionscombine le résultat avec l'entrée d'état brute ou remplace le résultat par celle-ci.
Filtrer la sortie d'état à l'aide OutputPathfiltre une partie de la sortie pour passer à l'état suivant.
La sortie d'état correspond aux données JSON passées de l'état actuel à l'état suivant.

Ces champs de traitement d'entrée et de sortie sont facultatifs. Si vous n'utilisez aucun de ces champs dans votre définition d'état, la tâche consommera l'entrée d'état brute et renverra le résultat de la tâche en tant que sortie d'état.

Utilisation TestState pour inspecter le traitement des entrées et des sorties

Lorsque vous appelez l'TestStateAPI et que vous définissez le inspectionLevel paramètre surDEBUG, la réponse de l'API inclut un objet appeléinspectionData. Cet objet contient des champs qui vous aident à inspecter la manière dont les données ont été filtrées ou manipulées dans l'état dans lequel elles ont été exécutées. L'exemple suivant montre l'inspectionDataobjet correspondant à un état de tâche.


"inspectionData":   {
  "input": string, 
  "afterInputPath": string, 
  "afterParameters": string, 
  "result": string, 
  "afterResultSelector": string, 
  "afterResultPath": string,
  "output": string 
}

Dans cet exemple, chaque champ contenant le after préfixe affiche les données après l'application d'un champ particulier. Par exemple, afterInputPath montre l'effet de l'application du InputPath champ pour filtrer l'entrée d'état brute. Le schéma suivant met en correspondance chaque champ de définition ASL avec le champ correspondant dans l'inspectionDataobjet :

Schéma illustrant le mappage des champs ASL avec InspectionData.

Pour des exemples d'utilisation de l' TestState API pour déboguer le traitement des entrées et des sorties, consultez les pages suivantes :

Tester un état à l'aide du niveau d'inspection DEBUG dans Step Functions console
Tester un état à l'aide du niveau d'inspection DEBUG dans AWS CLI

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Test et débogage

Step Functions Local (non pris en charge)