CloudFlow:Entrées et sorties

Flux et étapes

Les données circulent souvent d'une étape à l'autre au sein d'un flux. Une étape définie dans le langage de définition de flux (FDL) s'apparente à une fonction dans les langages de programmation fonctionnelle : elle accepte une entrée et renvoie une sortie. La sortie est enregistrée dans la variable locale de l'étape parente (l'appelant). L'entrée et la sortie doivent être au format objet JSON. Le type de la variable locale varie selon l'étape. Par exemple, une étape de tâche utilise le résultat d'un appel de fonction Function Compute comme variable locale. Une étape parallèle utilise un tableau contenant les sorties de toutes ses branches comme variable locale. La taille totale de l'entrée, de la sortie et des variables locales d'une étape ne peut pas dépasser 32 Kio. Si cette limite est dépassée, l'exécution du flux échoue.

Si une étape contient une autre étape, l'étape externe est appelée étape parente et l'étape interne est appelée étape enfant. Le parent des étapes les plus externes est le flux lui-même. Deux étapes partageant la même étape parente sont des étapes sœurs.

Les flux et les étapes possèdent tous des entrées, des sorties et des variables locales. La liste suivante décrit leur transformation :

• Les mappages d'entrée d'étape (inputMappings) associent l'entrée et les variables locales d'une étape parente à l'entrée d'une étape enfant.

• Les mappages de sortie d'étape (outputMappings) associent l'entrée et les variables locales de l'étape actuelle à sa sortie.

• Les mappages d'entrée de flux (inputMappings) associent l'entrée fournie lors de l'exécution d'un flux par un utilisateur à l'entrée du flux.

• Les mappages de sortie de flux (outputMappings) associent l'entrée et les variables locales du flux à sa sortie.

La variable locale d'une étape parente stocke les sorties fusionnées de toutes ses étapes enfants. Si les sorties contiennent des clés portant le même nom, le résultat de l'étape exécutée en dernier écrase celui de l'étape exécutée précédemment. Dans la plupart des cas, il n'est pas nécessaire de spécifier les mappages d'entrée et de sortie : vous pouvez utiliser le comportement de mappage par défaut. Les transformations par défaut sont les suivantes :

• Si vous ne spécifiez aucun mappage d'entrée, l'entrée de l'étape enfant correspond à une fusion de l'entrée et des variables locales de son étape parente. Si les variables locales et l'entrée comportent des clés portant le même nom, les valeurs des variables locales écrasent celles de l'entrée.

• Si vous ne spécifiez aucun mappage de sortie, toutes les étapes, à l'exception des étapes parallèles et foreach, utilisent leurs variables locales comme sortie.

Pour mieux contrôler les entrées et les sorties, vous devez comprendre les règles de mappage détaillées.

La figure suivante illustre les mappages d'entrée et de sortie d'un exemple de flux. Dans cet exemple, step1 est l'étape parente de step2 et step3. step1 et step4 sont les étapes les plus externes.

version: v1
type: flow
steps:
  - type: parallel
    name: step1
    branches:
      - steps:
        - type: pass
          name: step2
      - steps:
        - type: pass
          name: step3
  - type: pass
    name: step4      

Le code suivant décrit ces mappages pour faciliter leur compréhension.

func flow(input0 Input) (output0 Output) {
  local0 := {}
  input1 := buildInput(step1InputMappings, input0, local0)
  output1 := step1(input1)
  save(local0, output1)
  input4 := buildInput(step4InputMappings, input0, local0)
  output4 := step4(input4)
  save(local0, output4)
  return buildOutput(flowOutputMappings, input0, local0)
}
func step1(input1 Input) (output1 Output) {
  local10 := {}
  input2 := buildInput(step2InputMappings, input1, local10)
  output2 := step2(input2)
  save(local10, output2)
  local11 := {}
  input3 := buildInput(step3InputMappings, input1, local11)
  output3 := step3(input3)
  save(local11, output3)
  return buildOutput(step1OutputMappings, [local10, local11])
}
func step2(input2 Input) (output2 Output) {
}
func step3(input3 Input) (output3 Output) {
}
func step4(input4 Input) (output4 Output) {
}       

Dans cet exemple, le flux contient deux étapes enfants : step1 et step4. step1 est une étape parallèle qui contient deux étapes enfants : step2 et step3.

1. Lorsque le système commence à exécuter le flux, il transforme l'entrée StartExecution en entrée du flux (input0) sur la base du mappage d'entrée du flux.

2. Au démarrage du flow, sa variable locale local0 est vide.

3. Le système prépare l'entrée input1 pour step1 en fonction de son mappage d'entrée (step1InputMappings). La source du mappage est l'entrée input0 et la variable locale local0 du flow.

4. Le système appelle step1, transmet l'entrée input1 et step1 renvoie la sortie output1.

   • Au démarrage de step1, sa variable locale local0 est vide. Étant donné que step1 est une étape parallèle, chaque branche possède sa propre variable locale afin d'éviter les problèmes d'accès concurrent.

   • Le système prépare l'entrée input2 pour step2 en fonction de son mappage d'entrée (step2InputMappings). La source du mappage est l'entrée input1 et la variable locale local10 de step1.

   • Le système appelle step2, transmet l'entrée input2 et step2 renvoie la sortie output2.

   • Le système enregistre la sortie de step2 dans la variable locale local10 de step1.

   • De même, le système appelle step3 et enregistre le résultat dans la variable locale local11 de step1.

5. Le système enregistre la sortie de step1 dans la variable locale local0 du flow.

6. De même, le système prépare l'entrée input4 pour step4 en fonction de son mappage d'entrée. La source du mappage est l'entrée input0 et la variable locale local0 du flow.

   Remarque

   À ce stade, la variable locale

   local0

   peut déjà contenir la sortie de

   step1

   . C'est ainsi que les données sont transmises entre

   step1

   et

   step4

   .

7. Le système appelle step4, transmet l'entrée input4 et step4 renvoie la sortie output4.

8. Le système enregistre la sortie de step4 dans la variable locale local0 du flow.

9. Enfin, le système transforme local0 en sortie du flux sur la base du mappage de sortie du flux.

Définitions de type

Les mappages d'entrée et de sortie sont des tableaux composés de paires target et source. Le champ source définit l'origine de la valeur d'un paramètre, tandis que le champ target définit le nom du paramètre de destination. Si une valeur source commence par $, il s'agit d'une expression JSON Path que le système analyse pour récupérer une valeur spécifique. Sinon, la valeur est traitée comme une constante. Par exemple, $input.key indique que la valeur du paramètre est celle de key au sein de l'objet input. Vous pouvez utiliser cet outil pour tester les expressions JSON Path.

• Source

  Le champ source prend en charge les valeurs constantes. Elles peuvent être de type number, string, boolean, array, object ou null.

  L'exemple suivant montre un mappage utilisant différents types de constantes et la sortie résultante.

  outputMappings:
    - target: int_key
      source: 1
    - target: bool_key
      source: true
    - target: string_key
      source: abc
    - target: float_key
      source: 1.234
    - target: null_key
      source: null
    - target: array1
      source: [1, 2, 3]
    - target: array2
      source:
        - 1
        - 2
        - 3
    - target: object1
      source: {a: b}
    - target: object2
      source:
        a: b          

  {
    "array1": [1, 2, 3],
    "array2": [1, 2, 3],
    "bool_key": true,
    "float_key": 1.234,
    "int_key": 1,
    "null_key": null,
    "object1": {
      "a": "b"
    },
    "object2": {
      "a": "b"
    },
    "string_key": "abc"
  }            

• Cible

  La cible doit être une constante de type chaîne.

Mappage d'entrée

Un mappage d'entrée transforme l'entrée de l'étape parente ($input), les variables locales de l'étape parente ($local) ou des constantes en entrée de l'étape enfant. Si vous ne spécifiez aucun mappage d'entrée, l'entrée et les variables locales de l'étape parente sont fusionnées et utilisées comme entrée de l'étape enfant. Si l'entrée et les variables locales de l'étape parente comportent des clés portant le même nom, la valeur des variables locales écrase celle de l'entrée.

inputMappings:
  - target: key1
    source: $input.key1
  - target: key2
    source: $local.key2
  - target: key3
    source: literal         

{
"key1":"value1"
}

{
    "key2":"value2"
    }

inputMappings:
      - target: key1
        source: $input.key1
      - target: key2
        source: $local.key2
      - target: key3
        source: literal

{
    "key1":"value1",
    "key2":"value2",
    "key3":"literal"
    }

{
"key1":"value1"
}

{
    "key2":"value2"
    }

{
    "key1":"value1",
    "key2":"value2"
    }

{
"key1":"value1"
}

{
    "key1":"value2"
    }

{
    "key1":"value2"
    }

Mappage de sortie

Un mappage de sortie transforme l'entrée de l'étape actuelle ($input), les variables locales ($local) ou des constantes en sortie de l'étape. Si vous ne spécifiez aucun mappage de sortie, les variables locales des étapes choice et loop sont utilisées comme sorties. Les étapes de tâche utilisent le résultat de l'exécution de la tâche comme sortie. Étant donné que les variables locales des étapes parallel et foreach sont des tableaux, vous devez définir un mappage de sortie pour transformer le résultat du tableau en objet JSON. Par défaut, leurs variables locales ne sont pas incluses dans la sortie. Pour plus d'informations, consultez les descriptions des étapes.

outputMappings:
  - target: key1
    source: $input.key1
  - target: key2
    source: $local.key2
  - target: key3
    source: literal          

{
"key1":"value1"
}

{
    "key2":"value2"
    }

outputMappings:
      - target: key1
        source: $input.key1
      - target: key2
        source: $local.key2
      - target: key3
        source: literal

{
    "key1":"value1",
    "key2":"value2",
    "key3":"literal"
    }

{
"key1":"value1"
}

[
      {
        "key2":"value2.1"
      },
      {
        "key2":"value2.2"
      }
    ]

outputMappings:
      - target: key1
        source: $input.key1
      - target: key2
        source: $local[*].key2
      - target: key3
        source: literal

{
      "key1":"value1",
      "key2":["value2,1","value2,2"],
      "key3":"literal"
    }

{
"key1":"value1"
}

{
    "key2":"value2"
    }

{
    "key2":"value2"
    }

Enregistrement des sorties dans les variables locales de l'étape parente

La sortie de l'étape enfant ($output) est fusionnée avec les variables locales de l'étape parente. Si les deux comportent des clés portant le même nom, la valeur de la sortie écrase la valeur correspondante dans les variables locales.

{
"key1":"value1"
}

{
    "key2":"value2"
    }

{
      "key1":"value1",
      "key2":"value2"
    }

{
"key1":"value11"
}

{
      "key1":"value1",
      "key2":"value2"
    }

{
      "key1":"value11",
      "key2":"value2"
    }