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 et transformer des données avec JSONata.

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 état ou un État du flux de travail réussi état peut inclure les champs de traitement d'entrée et de sortie, tels que InputPathResultPath, ouOutputPath. De plus, les État du flux de travail de choix états État du flux de travail en attente et ne prennent pas en charge le ResultPath champ. Avec ces champs, vous pouvez utiliser a JsonPathpour 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.

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 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:us-east-1: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 utilisantOutputPath, 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. OutputPathfiltre 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. InputPathenvoie uniquement le lambda nœud de l'entrée à la fonction Lambda.

2. ResultPath insère le résultat en tant qu'enfant du nœud data dans l'entrée d'origine.

3. OutputPathfiltre 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.

Exemple 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.

Note

Pour voir l'exemple complet, consultez How to use JSON Path in Step Functions.

{
  "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": "[e-mail]",
      "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.

Filtrer la sortie d'état à l'aide OutputPath

OutputPathVous 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.