La función experimental de Workflows, experimental.executions.map, inicia la ejecución de un flujo de trabajo para cada argumento correspondiente, espera a que finalicen todas las ejecuciones y muestra una lista en la que cada elemento es el resultado de una ejecución.
Si usas experimental.executions.map para admitir el trabajo paralelo, puedes migrar el flujo de trabajo de modo que use pasos paralelos y ejecute bucles for comunes en paralelo.
Un paso parallel define una parte del flujo de trabajo en la que dos o más pasos se pueden ejecutar en simultáneo. Un paso parallel espera hasta que todos los pasos definidos se completen o se interrumpan por una excepción no controlada. Luego, la ejecución continúa. Al igual que experimental.executions.map, el orden de ejecución no está garantizado. Para obtener más información, consulta la página de referencia de sintaxis sobre pasos paralelos.
Ten en cuenta que el uso de experimental.executions.map o workflows.executions.run requiere una cuota de ejecuciones simultáneas adicional.
Sin embargo, cuando usas pasos paralelos con llamadas a conectores intercalados (consulta el ejemplo del conector de traducción), no se requiere una cuota de ejecución adicional.
Los siguientes ejemplos se diseñaron como ayuda para reemplazar el uso de experimental.executions.map por un paso parallel.
Flujo de trabajo de la traducción
En un idioma de origen y uno de destino, el siguiente flujo de trabajo, llamado translate, usa el conector de Cloud Translation para traducir texto de entrada y mostrar el resultado. Ten en cuenta que la API de Cloud Translation debe estar habilitada.
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}"
}
}
]
}
}
Entrada para el ejemplo anterior:
{
"text": "Bonjour",
"target": "en",
"source": "fr"
}
El resultado debe parecerse al siguiente:
{
"data": {
"translations": [
{
"translatedText": "Hello"
}
]
}
}
Flujo de trabajo de traducción por lotes con experimental.executions.map
El siguiente flujo de trabajo traduce un lote de textos. Para cada entrada, experimental.executions.map ejecuta el flujo de trabajo translate que se creó antes.
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}"
}
}
]
}
}
El resultado debe parecerse al siguiente:
[
{
"data": {
"translations": [
{
"translatedText": "Bonjour le monde!"
}
]
}
},
{
"data": {
"translations": [
{
"translatedText": "Hello world!"
}
]
}
},
{
"data": {
"translations": [
{
"translatedText": "I don't speak Spanish!"
}
]
}
}
]
Reemplaza experimental.executions.map por un bucle for:in.
En lugar de usar la función experimental, puedes usar un bucle for:in paralelo para traducir el texto. En el siguiente ejemplo, el flujo de trabajo secundario, translate, se puede usar tal como está, y el resultado no debería cambiarse. También tienes la opción de iniciar otras ejecuciones de flujos de trabajo secundarios en ramas paralelas.
Una variable compartida, translated, se usa para almacenar los resultados y se propaga con strings vacías a fin de habilitar la indexación de arreglos estáticos. Si no es necesario ordenar, puedes usar list.concat para adjuntar los resultados. Todas las asignaciones en pasos paralelos son atómicas.
YAML
JSON
Reemplaza experimental.executions.map por un bucle for:range.
En lugar de usar la función experimental, puedes usar un bucle for:range paralelo para traducir el texto. Cuando usas un bucle for:range, puedes especificar el comienzo y el final de un rango de iteración. El resultado no debería cambiar.
YAML
JSON
Cómo intercalar el código fuente del flujo de trabajo
Si el flujo de trabajo secundario es relativamente breve, te recomendamos incluirlo directamente en el flujo de trabajo principal para facilitar la legibilidad. Por ejemplo, en el siguiente flujo de trabajo, se intercala el código fuente para el flujo de trabajo translate.