CloudFlow:Entrées et sorties

Entrées des exécutions

Vous devez fournir des informations ou des données pour démarrer une exécution. Ces éléments peuvent servir d'entrée pour un ou plusieurs états. Lors de l'orchestration du workflow, accédez à l'entrée d'une exécution à l'aide de l'expression système $Context.Execution.Input.

Par exemple, la logique d'un système d'inscription en ligne des étudiants comprend trois processus : collecte des informations, vérification des données et inscription proprement dite. Les informations de base sur l'étudiant sont requises à chaque étape. Dans ce cas, transmettez ces informations de base en tant qu'entrée de l'exécution et configurez les trois états correspondants pour qu'ils y accèdent via l'expression système.

Dans la boîte de dialogue Execute Flow, définissez Execution Name sur test. Dans la section Execution Input, saisissez un objet JSON contenant les informations de base de l'étudiant dans l'éditeur JSON. Cet objet inclut des champs tels que name, age, gender, country, city, occupation, hobbies (tableau) et isActive (booléen).

Sorties des exécutions

La sortie d'une exécution correspond au résultat d'une exécution réussie. Il n'est pas possible d'accéder à la sortie d'une exécution via une variable système lors de l'orchestration du workflow.

Entrées d'un état

Lors de l'orchestration du workflow, utilisez l'expression système $Context.Current.Input ou sa forme abrégée $Input pour accéder à l'entrée de l'état actuel.

Sorties des états

Lors de l'orchestration du workflow, utilisez l'expression système $Context.Current.Output ou sa forme abrégée $Output pour accéder à la sortie de l'état actuel. Notez que la forme abrégée $Output est utilisable uniquement dans les portées des constructeurs de sortie.

Expressions système utilisables dans les constructeurs

Les expressions système suivantes sont disponibles dans les constructeurs :

• $Context : le cycle de vie de $Context couvre toute la période d'exécution du workflow. Pour plus d'informations sur $Context, consultez la rubrique Transmission des données.

• $Input : le cycle de vie de $Input débute lorsque le workflow entre dans l'état et se termine lorsqu'il en sort. $Input est la forme abrégée de $Context.Current.Input.

• $Output : le cycle de vie de $Output commence lorsque le workflow entre dans l'état de réponse à l'appel de tâche et prend fin à la sortie de cet état. $Output est la forme abrégée de $Context.Current.Output.

• $Global : le cycle de vie de $Global s'étend sur toute la durée d'exécution du workflow. Pour en savoir plus sur $Global, reportez-vous à la section Variables globales.

Le schéma ci-dessous illustre les cycles de vie des expressions système $Input, $Output, $Context et $Global, ainsi que les processus d'affectation dans les différents états.

• $Input représente l'entrée de l'exécution.

• Dans le schéma précédent, $Input=InputConstructor($Context,$Global) signifie que, dans cette portée, InputConstructor peut faire référence à $Context et $Global pour en extraire des informations. Le résultat de la construction est affecté à $Input.

• $Output correspond au résultat de l'appel de tâche. Si l'appel est initié en mode de rappel asynchrone, la valeur de $Output est le résultat du rappel.

• $Output=OutputConstructor($Context,$Global) indique que, dans cette portée, OutputConstructor peut accéder à $Context et $Global pour en extraire des informations. Le résultat de la construction est affecté à $output.

• $Global désigne les variables globales, accessibles tout au long de la période d'exécution du workflow.

• $Global=Merge($Global,GlobalConstructor($Context,$Global)) signifie que les variables construites par le constructeur global sont fusionnées avec les variables existantes dans $Global, puis l'ensemble est stocké dans $Global pour mettre à jour les variables globales partagées.

• $Context reste valide pendant toute l'exécution.

InputConstructor

InputConstructor construit l'entrée d'un workflow. Les expressions de InputConstructor diffèrent des expressions conditionnelles des états État Choice. Alors que les expressions conditionnelles ne renvoient que des valeurs booléennes, celles de InputConstructor peuvent retourner n'importe quel type de valeur. Utilisez les variables système suivantes dans le InputConstructor de l'état :

• $Context

• $Input

• $Global

La définition de machine d'état suivante illustre l'utilisation de InputConstructor.

Type: StateMachine
Name: test3-tx
SpecVersion: v1
StartAt: InvokeFunction1
States:
  - Type: Task
    Name: InvokeFunction
    Action: FC:InvokeFunction
    TaskMode: RequestComplete
    InputConstructor:
      FieldA.$: $Context.Execution.Input
      FieldB: World
      FieldC.$: length($Context.Execution.Input)
      FieldD.$: $Global.InvokeFunctionPayload
    Parameters:
      resourceArn: >-
        acs:fc:cn-hangzhou:123456:functions/myFunction1/LATEST
      invocationType: Sync
      body.$: $Input
    End: true
  - Type: Task
    Name: InvokeFunction1
    Action: FC:InvokeFunction
    TaskMode: RequestComplete
    Parameters:
      invocationType: Sync
      resourceArn: acs:fc:cn-hangzhou:123456:functions/myFunction1/LATEST
    GlobalConstructor:
      InvokeFunctionPayload.$: $Output.Body
    Next: InvokeFunction

• Dans l'exemple précédent, la structure de données de InputConstructor est Map[String]Any.

• FieldA.$: $Context.Execution.Input indique que la clé FieldA récupère dynamiquement la valeur depuis $Context.Execution.Input au lieu d'être traitée comme une chaîne.

• FieldB: World signifie que la chaîne statique 'World' est affectée à FieldB. Aucune récupération dynamique n'a lieu car la clé FieldB ne se termine pas par le marqueur .$.

• FieldC.$: length($Context.Execution.Input) utilise la fonction intégrée length pour obtenir la longueur de la valeur dans $Context.Execution.Input et l'affecte à FieldC. Pour consulter la liste des fonctions intégrées utilisables dans les constructeurs, reportez-vous à la rubrique Fonctions intégrées.

• L'expression FieldD.$: $Global. InvokeFunctionPayload extrait la valeur de la clé InvokeFunctionPayload dans l'espace de stockage global et la transmet en tant que champ FieldD à l'état Task.

OutputConstructor

Contrairement à InputConstructor, OutputConstructor s'exécute à un moment différent et prend en charge davantage de variables dans les expressions de contexte. Par exemple, si un constructeur d'entrée accepte uniquement $Context ou $Input, un constructeur de sortie peut utiliser $Output pour représenter la sortie, car l'appel de tâche a déjà généré ce résultat. Utilisez les variables système suivantes dans le OutputConstructor de l'état :

• $Context

• $Input

• $Output

• $Global

La définition de machine d'état suivante montre comment utiliser OutputConstructor.

Type: StateMachine
Name: test3-tx
SpecVersion: v1
StartAt: InvokeFunction1
States:
  - Type: Task
    Name: InvokeFunction1
    Action: FC:InvokeFunction
    TaskMode: RequestComplete
    Parameters:
      invocationType: Sync
      resourceArn: acs:fc:cn-hangzhou:123456:functions/myFunction1/LATEST
    GlobalConstructor:
      InvokeFunctionPayload.$: $Output.Body
    Next: InvokeFunction
  - Type: Task
    Name: InvokeFunction
    Action: FC:InvokeFunction
    TaskMode: RequestComplete
    Parameters:
      resourceArn: >-
        acs:fc:cn-hangzhou:123456:functions/myFunction1/LATEST
      invocationType: Sync
      body.$: $Input
    OutputConstructor:
      returnID.$: uuid()
      functionResult.$: $Output
      functionResultStr.$: jsonToString($Output)
      executionInput.$: $Context.Execution.Input
      lastOutput.$: $Input
      demo.$: $Global
    End: true

• Dans l'exemple ci-dessus, la structure de données de OutputConstructor est map[string]any.

• functionResult.$ récupère dynamiquement la sortie de l'état, executionInput.$ récupère dynamiquement l'entrée de l'exécution, et lastOutput.$ récupère dynamiquement l'entrée de l'état.

• returnID.$ obtient l'ID unique, tandis que functionResultStr.$ récupère une chaîne créée à partir de la sortie de l'état.