La fonction expérimentale de Workflows, experimental.executions.map, lance une exécution de workflow pour chaque argument correspondant et attend la fin de toutes les exécutions, renvoyant ainsi une liste dans laquelle chaque élément est le résultat d'une exécution.
Si vous utilisez experimental.executions.map pour gérer le travail en parallèle, vous pouvez migrer votre workflow afin d'utiliser des étapes parallèles à la place, en exécutant des boucles for ordinaires en parallèle.
Une étape parallel définit une partie de votre workflow dans laquelle deux étapes ou plus peuvent s'exécuter simultanément. Une étape parallel attend que toutes les étapes qui y sont définies soient terminées ou qu'elles soient interrompues par une exception non gérée. L'exécution se poursuit. Comme pour experimental.executions.map, l'ordre d'exécution n'est pas garanti. Pour en savoir plus, consultez la page de référence de la syntaxe pour connaître les étapes parallèles.
Notez que l'utilisation de experimental.executions.map ou de workflows.executions.run nécessite un quota d'exécutions simultanées supplémentaire.
Toutefois, lorsque vous utilisez des étapes parallèles avec des appels de connecteurs intégrés (voir l'exemple de connecteur de traduction), aucun quota d'exécution supplémentaire n'est requis.
Les exemples suivants sont destinés à vous aider à remplacer l'utilisation de experimental.executions.map par une étape parallel.
Workflow de traduction
Avec une langue source et une langue cible, le workflow suivant, nommé translate, utilise le connecteur Cloud Translation pour traduire du texte d'entrée et renvoyer le résultat. Notez que l'API Cloud Translation doit être activée.
YAML
main:
params: [args]
steps:
- basic_translate:
call: googleapis.translate.v2.translations.translate
args:
body:
q: ${args.text}
target: ${args.target}
format: "text"
source: ${args.source}
result: r
- return_step:
return: ${r}
JSON
{
"main": {
"params": [
"args"
],
"steps": [
{
"basic_translate": {
"call": "googleapis.translate.v2.translations.translate",
"args": {
"body": {
"q": "${args.text}",
"target": "${args.target}",
"format": "text",
"source": "${args.source}"
}
},
"result": "r"
}
},
{
"return_step": {
"return": "${r}"
}
}
]
}
}
Entrée pour l'exemple précédent:
{
"text": "Bonjour",
"target": "en",
"source": "fr"
}
La sortie doit ressembler à ceci :
{
"data": {
"translations": [
{
"translatedText": "Hello"
}
]
}
}
Workflow de traduction par lots à l'aide de experimental.executions.map
Le workflow suivant permet de traduire un lot de textes. Pour chaque entrée, experimental.executions.map exécute le workflow translate créé précédemment.
YAML
main:
steps:
- init:
assign:
- workflow_id: "translate"
- texts_to_translate:
- text: "hello world!"
source: "en"
target: "fr"
- text: "你好 世界！"
source: "zh-CN"
target: "en"
- text: "No hablo español!"
source: "es"
target: "en"
- translate_texts:
call: experimental.executions.map
args:
workflow_id: ${workflow_id}
arguments: ${texts_to_translate}
result: translated
- return:
return: ${translated}
JSON
{
"main": {
"steps": [
{
"init": {
"assign": [
{
"workflow_id": "translate"
},
{
"texts_to_translate": [
{
"text": "hello world!",
"source": "en",
"target": "fr"
},
{
"text": "你好 世界！",
"source": "zh-CN",
"target": "en"
},
{
"text": "No hablo español!",
"source": "es",
"target": "en"
}
]
}
]
}
},
{
"translate_texts": {
"call": "experimental.executions.map",
"args": {
"workflow_id": "${workflow_id}",
"arguments": "${texts_to_translate}"
},
"result": "translated"
}
},
{
"return": {
"return": "${translated}"
}
}
]
}
}
La sortie doit ressembler à ceci :
[
{
"data": {
"translations": [
{
"translatedText": "Bonjour le monde!"
}
]
}
},
{
"data": {
"translations": [
{
"translatedText": "Hello world!"
}
]
}
},
{
"data": {
"translations": [
{
"translatedText": "I don't speak Spanish!"
}
]
}
}
]
Remplacer experimental.executions.map par une boucle for:in
Au lieu d'utiliser la fonction expérimentale, vous pouvez utiliser une boucle for:in parallèle pour traduire le texte. Dans l'exemple suivant, le workflow secondaire, translate, peut être utilisé tel quel et le résultat ne doit pas changer. Vous avez également la possibilité de lancer d'autres exécutions de workflow secondaire dans des branches parallèles.
Une variable partagée, translated, est utilisée pour stocker les résultats et est renseignée avec des chaînes vides pour permettre l'indexation de tableau statique. Si le tri n'est pas nécessaire, vous pouvez utiliser list.concat pour ajouter les résultats. Toutes les attributions effectuées dans des étapes parallèles sont atomiques.
YAML
JSON
Remplacer experimental.executions.map par une boucle for:range
Au lieu d'utiliser la fonction expérimentale, vous pouvez utiliser une boucle for:range parallèle pour traduire le texte. À l'aide d'une boucle for:range, vous pouvez spécifier le début et la fin d'une plage d'itérations. Le résultat ne doit pas changer.
YAML
JSON
Intégrer le code source du workflow
Si le workflow secondaire est relativement bref, vous pouvez l'inclure directement dans le workflow principal pour une meilleure lisibilité. Par exemple, dans le workflow suivant, le code source du workflow translate a été intégré.