CloudFlow:Passage de données

Vue d'ensemble

Vous pouvez combiner et imbriquer des états dans CloudFlow. Les données présentes dans l'environnement d'exécution d'un état constituent le contexte. Ces données se répartissent dans les catégories suivantes :

• Données de flux : incluent le nom et la région du flux, les noms des états qui composent le flux, ainsi que le rôle Resource Access Management (RAM) utilisé pour exécuter le flux.

• Données d'exécution : incluent le nom et l'entrée de l'exécution, l'entrée et la sortie de l'état actuel, le jeton utilisé pour le rappel, les informations d'erreur générées pendant l'exécution et le nombre de tentatives pour la gestion des erreurs.

Accès aux données

Utilisez l'expression $Context fournie par le système pour accéder aux données relatives aux flux et à leur exécution, qu'il s'agisse de données statiques ou dynamiques. Le contexte contient les éléments suivants :

{
  "Execution": {
    "Name": "String",
    "Input": {},
    "RoleArn": "String"
  },
  "Current": {
    "Name": "String",
    "Input": {},
    "Output": {},
    "Error": {
      "Code": "String",
      "Detail": "String"
    },
    "RetryCount": "Number",
    "TaskToken": "String"
  }
}

Le contexte permet de construire des données dans les scénarios suivants :

• Constructeurs d'entrée et de sortie. Pour plus d'informations, consultez la rubrique Entrées et sorties.

• Champ ItemsPath dans les états Map. Exemple : $Context.Current.Input.

• Champ Condition dans les états Choice. Exemple : $Context.Current.Input.Size>=1024.

• Détermination des informations pour la gestion des erreurs. Exemples : $Context.Current.Error.Code et $Context.Current.Error.Detail.

• Transmission des jetons de rappel de tâche. Exemple : $Context.Current.TaskToken.

CloudFlow propose les raccourcis fréquemment utilisés $Input et $Output. Utilisez-les pour accéder rapidement à l'entrée et à la sortie du nœud actuel.

• $Input équivaut à $Context.Current.Input.

• $Output équivaut à $Context.Current.Output.

Passage de données

La logique d'entrée et de sortie varie selon les états. Si aucun constructeur d'entrée ou de sortie n'est défini, les états appliquent la logique suivante :

• Pass, Succeed, Fail et Wait : ces états acceptent des entrées et utilisent les entrées d'origine non traitées comme sorties.

• Choice : cet état accepte uniquement des entrées et les transmet à l'état de destination sans retourner de sorties. Par exemple, l'état Choice peut transmettre les entrées à la branche Default. Il peut également les acheminer vers une branche spécifique pour vérifier si les conditions requises sont remplies. Si tel est le cas, l'état Choice transmet les entrées à l'état suivant.

• Parallel : le système effectue des copies profondes d'une entrée et les transmet simultanément à plusieurs branches. Les sorties de l'état sont au format Map[String]Any. La clé dans Map[String]Any correspond au nom implicite Branch N d'une branche parallèle. La valeur représente le résultat réel du traitement de l'entrée dans la branche parallèle.

• Map : le système détermine si une entrée est un tableau ou un objet Map[String]Any. Si l'entrée de l'état Map n'est pas un tableau et que vous ne spécifiez pas le contenu à itérer via le paramètre ItemsPath, le système extrait automatiquement les valeurs de l'état Map sous forme de tableau itératif. Le système parcourt ensuite ce tableau. Les éléments du tableau servent d'entrées au processeur d'itération. Les sorties de l'état Map sont au format Map[String]Any. La clé dans Map[String]Any est la chaîne Items. La valeur est un tableau composé de plusieurs résultats d'itération.

• Task : cet état accepte les données d'entrée provenant de l'état précédent ou d'une source de données externe, exécute une logique métier spécifique dans un script de tâche, utilise l'expression $Context pour accéder aux données et les manipuler, puis transmet le résultat de l'exécution de la tâche en tant que données de sortie aux états suivants ou les stocke dans un système externe.

Exemple

Type: StateMachine
Name: DataTransferExample
SpecVersion: v1
StartAt: Step1
States:
  - Type: Pass
    Name: Step1
    Next: Step2
  - Type: Parallel
    Name: Step2
    InputConstructor:
      FieldA: 123
    Branches:
      - StartAt: Pass1
        States:
          - Type: Pass
            Name: Pass1
            End: true
      - StartAt: Pass2
        States:
          - Type: Pass
            Name: Pass2
            End: true
    Next: Step3
  - Type: Pass
    Name: Step3
    End: true

Dans l'exemple ci-dessus, un InputConstructor est utilisé dans un état Parallel nommé Step2 pour construire un objet JSON contenant la propriété FieldA, dont la valeur est 123. Par défaut, l'entrée est transmise à ParallelBranch #0 et ParallelBranch #1. Par exemple, dans la branche ParallelBranch #0, l'entrée est transmise à l'état Pass1. Le code suivant illustre les données de contexte de l'état Pass1.

{
  "Execution": {
    "Name": "xxxx-xxxx-xxxx-xxxx",
    "Input": {},
    "RoleArn": "xxxx"
  },
  "Current": {
    "Name": "Pass1",
    "Input": {
      "FieldA": 123
    },
    "Output": {
      "FieldA": 123
    },
    "Error": null,
    "RetryCount": 0
  }
}