A
função experimental do Workflows,
experimental.executions.map, inicia uma execução de fluxo de trabalho para cada
argumento correspondente e aguarda a conclusão de todas as execuções, retornando
uma lista em que cada elemento é resultado de uma execução.
Se você estiver usando experimental.executions.map para oferecer suporte ao trabalho paralelo, poderá migrar seu fluxo de trabalho para usar etapas paralelas, executando loops for comuns em paralelo.
Uma etapa parallel define uma parte do fluxo de trabalho em que duas ou mais etapas podem
ser executadas simultaneamente. Uma etapa parallel aguarda até que todas as etapas definidas nela sejam concluídas ou sejam interrompidas por uma exceção não processada. A execução continua em seguida. Como
experimental.executions.map, a ordem de execução não é garantida. Para mais detalhes, consulte a página de referência de sintaxe para etapas paralelas.
O uso de experimental.executions.map ou workflows.executions.run
requer uma cota de execuções simultâneas adicional.
No entanto, ao usar etapas paralelas com chamadas para conectores inline (consulte o exemplo do conector de tradução), nenhuma outra cota de execução é necessária.
Os exemplos a seguir ajudam você a substituir o uso de
experimental.executions.map por uma etapa parallel.
Fluxo de trabalho de tradução
Com base em um idioma de origem e um de destino, o fluxo de trabalho a seguir, chamado translate, usa o conector do Cloud Translation para traduzir um texto de entrada e retornar o resultado. A API Cloud Translation precisa estar ativada.
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 do exemplo anterior:
{
"text": "Bonjour",
"target": "en",
"source": "fr"
}
A saída será semelhante a esta:
{
"data": {
"translations": [
{
"translatedText": "Hello"
}
]
}
}
Fluxo de trabalho de tradução em lote usando experimental.executions.map
O fluxo de trabalho a seguir traduz um lote de textos. Para cada entrada,
experimental.executions.map executa o fluxo de trabalho translate criado
anteriormente.
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}"
}
}
]
}
}
A saída será semelhante a esta:
[
{
"data": {
"translations": [
{
"translatedText": "Bonjour le monde!"
}
]
}
},
{
"data": {
"translations": [
{
"translatedText": "Hello world!"
}
]
}
},
{
"data": {
"translations": [
{
"translatedText": "I don't speak Spanish!"
}
]
}
}
]
Substitua experimental.executions.map por uma repetição for:in.
Em vez de usar a função experimental, é possível usar um loop for:in paralelo
para traduzir o texto. No exemplo a seguir, o fluxo de trabalho secundário,
translate, pode ser usado no estado em que se encontra, e a saída precisa permanecer inalterada. Também
é possível iniciar outras execuções de fluxo de trabalho secundário em
ramificações paralelas.
Uma variável compartilhada, translated, é usada para armazenar os resultados e é preenchida com strings vazias para ativar a indexação de matrizes estáticas. Se a ordenação não for necessária, use
list.concat para anexar os
resultados. Todas as atribuições em etapas paralelas são atômicas.
YAML
JSON
Substitua experimental.executions.map por uma repetição for:range.
Em vez de usar a função experimental, é possível usar um loop for:range paralelo para traduzir o texto. Ao usar um loop for:range, é possível especificar o início e o fim de um intervalo de iteração. A saída deve permanecer inalterada.
YAML
JSON
in-line do código-fonte do fluxo de trabalho;
Se o fluxo de trabalho secundário for relativamente breve, inclua-o
diretamente no fluxo de trabalho principal para facilitar a leitura. Por exemplo, no
fluxo de trabalho a seguir, o código-fonte do fluxo de trabalho translate foi
in-line.