Global variables - CloudFlow - Centre de documentation Alibaba Cloud

Lorsque les données d'un workflow transitent par plusieurs états, chaque état reçoit la sortie de l'état précédent en tant qu'entrée. Le transfert de variables état par état complexifie le partage des données entre les différents états. CloudFlow met à disposition un mécanisme de variables globales pour simplifier ce processus et améliorer l'efficacité.

Limites

Si ces limites ne répondent pas à vos besoins, vous pouvez soumettre un ticket.

Élément	Valeur maximale
Longueur d'une clé de variable	128 octets
Longueur d'une valeur de variable	256 Kio

Notes

Important

Le champ $Output dans GlobalConstructor fait référence à la sortie brute de l'état Task, et non au résultat de construction généré par OutputConstructor.
Le champ $Global dans OutputConstructor fait référence à la valeur brute avant la construction effectuée par GlobalConstructor.

Limites liées à la taille du contexte

Lorsque CloudFlow transmet des données à l'aide de $Global, les sorties de InputConstructor et de OutputConstructor doivent respecter la limite imposant que la taille du contexte ne dépasse pas 64 Kio.

Conditions de concurrence

Les variables globales fournissent un espace de stockage clé-valeur au niveau de l'exécution, accessible en lecture et en écriture depuis tous les états tout au long du cycle de vie de l'exécution. Lorsqu'une logique parallèle, telle que Map ou Parallel, est présente dans un flux, les données risquent d'être écrasées entre différents états. Tenez compte des recommandations suivantes :

Utilisez des clés différentes pour écrire des variables globales dans les différentes branches des états Parallel.
N'écrivez pas de variables globales dans les états Map. Toutes les définitions d'itération d'un état Map sont identiques. Par conséquent, les noms de variables dans GlobalConstructor seront les mêmes. Les variables portant le même nom, écrites depuis différentes branches, s'écraseront mutuellement.
Une exécution enfant en mode distribué ne peut pas accéder aux variables globales de l'exécution parente, car les niveaux d'Execution des exécutions enfant et parente diffèrent.

Utiliser les variables globales pour transmettre des données

Les variables globales offrent un espace de stockage clé-valeur au niveau de l'exécution. N'importe quel état d'un workflow peut écrire des données dans la variable globale à la fin de son exécution afin de transmettre ces données à d'autres états pour consommation.

Dans la figure ci-dessus, l'état A utilise GlobalConstructor pour stocker les données correspondant à $Input.key_a, issues de l'entrée amont, dans la variable variable_a des variables globales. L'état A utilise également GlobalConstructor pour stocker les données correspondant à $Output.key_b présentes dans la sortie de l'état A, dans la variable variable_b des variables globales. Le workflow utilise InputConstructor pour extraire les valeurs de variable_a et de variable_b depuis les variables globales et les transmettre en tant qu'entrées à l'état Z. Ainsi, les données sont transmises entre les états.

Les entrées et sorties des workflows CloudFlow servent à transmettre explicitement des données entre les tâches, garantissant ainsi l'indépendance et la clarté de chaque tâche. Les variables globales permettent de maintenir des états partagés entre les tâches ou des configurations de ressources globales. L'utilisation conjointe des entrées, des sorties et des variables globales permet de concevoir un système efficace et flexible. La figure ci-dessus compare InputConstructor, OutputConstructor et GlobalConstructor. Description :

InputConstructor($Context,$Global), OutputConstructor($Context,$Global) et GlobalConstructor($Context,$Global) indiquent que InputConstructor, OutputConstructor et GlobalConstructor peuvent référencer $Context et $Global pour extraire des informations.
$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 que l'ensemble des variables est stocké dans $Global afin de mettre à jour les variables globales partagées.
$Output représente le résultat de l'appel de la tâche. Si l'appel est initié en mode de rappel asynchrone, la valeur de $Output correspond au résultat du rappel.
Dans le diagramme, $Global représente les variables globales, accessibles tout au long de l'exécution du workflow.

Création et mise à jour des variables globales

Les variables globales sont créées et mises à jour à l'aide de GlobalConstructor. Lorsque l'exécution d'un état se termine, GlobalConstructor est exécuté. La définition de machine d'états suivante illustre l'utilisation de GlobalConstructor.

Type: StateMachine
Name: MyWorkFlow
SpecVersion: v1
StartAt: InvokeFunction
States:
  - Type: Task
    Name: InvokeFunction
    Action: FC:InvokeFunction
    TaskMode: RequestComplete
    Parameters:
      resourceArn: >-
        acs:fc:cn-hangzhou:123456:functions/myFunction/LATEST
      invocationType: Sync
      body.$: $Input 
    GlobalConstructor:
      InvokeFunctionResultHeader.$: $Output.Header
      InvokeFunctionResultBody.$: $Output.Body
    End: true

La structure de données de GlobalConstructor est Map[String]Any.
InvokeFunctionResultHeader.$: $Output. Header et InvokeFunctionResultBody.$: $Output. Body indiquent que l'en-tête (header) et le corps (body) de la valeur renvoyée par la fonction sont stockés séparément dans les clés InvokeFunctionResultHeader et InvokeFunctionResultBody des variables globales.

Lecture des variables globales

CloudFlow définit le mot-clé $Global pour la lecture des variables globales. Dans tous les scénarios prenant en charge la construction d'expressions, il est possible d'accéder à l'espace de stockage global de l'exécution actuelle en utilisant $Global. Les états peuvent extraire les valeurs de l'espace de stockage global en spécifiant des clés explicites. La définition de machine d'états suivante montre comment utiliser $Global.

Type: StateMachine
Name: MyWorkFlow
SpecVersion: v1
StartAt: InvokeFunction1
States:
  - Type: Task
    Name: InvokeFunction1
    Action: FC:InvokeFunction
    TaskMode: RequestComplete
    Parameters:
      invocationType: Sync
      resourceArn: acs:fc:cn-hangzhou:123456:functions/myFunction/LATEST
    GlobalConstructor:
      InvokeFunctionPayload.$: $Output.Body
    Next: InvokeFunction
  - Type: Task
    Name: InvokeFunction
    Action: FC:InvokeFunction
    TaskMode: RequestComplete
    Parameters:
      resourceArn: acs:fc:cn-hangzhou:123456:functions/myFunction/LATEST
      invocationType: Sync
      body.$: $Global.InvokeFunctionPayload
    OutputConstructor:
      demo.$: $Global
    End: true

Lorsqu'un état est exécuté, la fonction InvokeFunction exécute GlobalConstructor pour stocker le corps de la valeur de retour de InvokeFunction1 dans la clé InvokeFunctionPayload des variables globales.
InvokeFunction utilise l'expression $Global.InvokeFunctionPayload dans Parameters pour extraire la valeur de la clé InvokeFunctionPayload depuis l'espace de stockage global et la transmettre en tant que champ body à l'état Task pour exécution.
L'état InvokeFunction utilise OutputConstructor pour consulter les valeurs dans $Global. Une fois l'exécution terminée, le panneau de sortie du workflow affiche la valeur de InvokeFunctionPayload comme étant "hello world\n", ce qui confirme que la variable globale a été lue avec succès.