Criar loops para repetir ações em fluxos de trabalho com os Aplicativos Lógicos do Azure
Aplica-se a: Aplicativos Lógicos do Azure (Consumo + Padrão)
Os Aplicativos Lógicos do Azure incluem as seguintes ações de loop que você pode usar em seu fluxo de trabalho:
Para repetir uma ou mais ações em itens em uma matriz, adicione o Para cada ação ao seu fluxo de trabalho.
Como alternativa, se você tiver um gatilho que recebe uma matriz e quiser executar uma iteração para cada item de matriz, poderá desagrupar essa matriz com a propriedade de gatilho SplitOn.
Para repetir uma ou mais ações até que uma condição seja atendida ou um estado mude, adicione a ação Até ao seu fluxo de trabalho.
Seu fluxo de trabalho primeiro executa todas as ações dentro do loop e, em seguida, verifica a condição ou o estado. Se a condição for atendida, o loop será interrompido. Caso contrário, o loop se repete. Para obter os limites padrão e máximo do número de loops Until que um fluxo de trabalho pode ter, consulte Limites de simultaneidade, looping e desloteamento.
Pré-requisitos
Uma conta e subscrição do Azure. Se não tiver uma subscrição, inscreva-se numa conta do Azure gratuita.
Conhecimento básico sobre fluxos de trabalho de aplicativos lógicos
Para cada
O Para cada ação funciona apenas em matrizes e repete uma ou mais ações em cada item de uma matriz. A lista a seguir contém algumas considerações para quando você deseja usar um Para cada ação:
O Para cada ação pode processar um número limitado de itens de matriz. Para esse limite, consulte Limites de simultaneidade, looping e debatching.
Por padrão, os ciclos ou iterações em um Para cada ação são executados ao mesmo tempo em paralelo.
Esse comportamento difere do Power Automate's Apply para cada loop onde as iterações são executadas uma de cada vez, ou sequencialmente. No entanto, você pode configurar sequencial para cada iteração. Por exemplo, se você quiser pausar a próxima iteração em um Para cada ação usando a ação Atrasar, será necessário configurar cada iteração para ser executada sequencialmente.
Como exceção ao comportamento padrão, as iterações aninhadas de For each action sempre são executadas sequencialmente, não em paralelo. Para executar operações em paralelo para itens em um loop aninhado, crie e chame um fluxo de trabalho de aplicativo lógico filho.
Para obter resultados previsíveis de operações em variáveis durante cada iteração, execute as iterações sequencialmente. Por exemplo, quando uma iteração em execução simultânea termina, as operações Increment, Decrement e Append to variable retornam resultados previsíveis. No entanto, durante cada iteração no loop em execução simultânea, essas operações podem retornar resultados imprevisíveis.
Ações em um Para cada loop Use a
item()função para referenciar e processar cada item na matriz. Se você especificar dados que não estão em uma matriz, o fluxo de trabalho falhará.
O fluxo de trabalho de exemplo a seguir envia um resumo diário para um RSS feed de site. O fluxo de trabalho usa um Para cada ação que envia um email para cada novo item.
Com base no fluxo de trabalho Consumo ou Padrão, siga as etapas correspondentes:
No portal do Azure, crie um exemplo de fluxo de trabalho do aplicativo lógico de consumo com as seguintes etapas na ordem especificada:
O gatilho RSS chamado Quando um item de feed é publicado
Para obter mais informações, siga estas etapas gerais para adicionar um gatilho.
A ação do Outlook Outlook.com ou Office 365 chamada Enviar um email
Para obter mais informações, siga estas etapas gerais para adicionar uma ação.
Siga as mesmas etapas gerais para adicionar a ação Para cada ação entre o gatilho RSS e Enviar um e-mail em seu fluxo de trabalho.
Agora construa o loop:
Selecione dentro da caixa Selecionar uma saída das etapas anteriores para que a lista de conteúdo dinâmico seja aberta.
Na lista Adicionar conteúdo dinâmico, na seção Quando um item de feed é publicado, selecione Links de feed, que é uma saída de matriz do gatilho RSS.
Nota
Se a saída Links de feed não aparecer, ao lado do rótulo da seção de gatilho, selecione Ver mais. Na lista de conteúdo dinâmico, você pode selecionar apenas saídas de etapas anteriores.
Quando terminar, a saída da matriz selecionada aparecerá como no exemplo a seguir:
Para executar uma ação existente em cada item da matriz, arraste a ação Enviar um email para o loop Para cada um.
Agora, seu fluxo de trabalho se parece com o exemplo a seguir:
Quando tiver terminado, guarde o fluxo de trabalho.
Para testar manualmente seu fluxo de trabalho, na barra de ferramentas do designer, selecione Executar Execução de Gatilho>.
Para cada definição de ação (JSON)
Se você estiver trabalhando na visualização de código, poderá definir a For_each ação na definição JSON do seu fluxo de trabalho, por exemplo:
"actions": {
"For_each": {
"actions": {
"Send_an_email_(V2)": {
"type": "ApiConnection",
"inputs": {
"body": {
"Body": "@{item()}",
"Subject": "New CNN post @{triggerBody()?['publishDate']}",
"To": "me@contoso.com"
},
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/v2/Mail"
},
"runAfter": {}
}
},
"foreach": "@triggerBody()?['links']",
"runAfter": {},
"type": "Foreach"
}
},
Para cada um: Executar sequencialmente
Por padrão, as iterações em um loop For each são executadas ao mesmo tempo em paralelo. No entanto, quando você tem loops aninhados ou variáveis dentro dos loops onde você espera resultados previsíveis, você deve executar esses loops um de cada vez ou sequencialmente.
No canto superior direito de cada ação, selecione as reticências (...) >Configurações.
Em Controle de simultaneidade, altere a configuração de Desativado para Ativado.
Mova o controle deslizante Grau de paralelismo para 1 e selecione Concluído.
Para cada definição de ação (JSON): Executar sequencialmente
Se você estiver trabalhando na visualização de código com a For_each ação na definição JSON do seu fluxo de trabalho, poderá usar a Sequential opção adicionando o operationOptions parâmetro, por exemplo:
"actions": {
"For_each": {
"actions": {
"Send_an_email_(V2)": { }
},
"foreach": "@triggerBody()?['links']",
"runAfter": {},
"type": "Foreach",
"operationOptions": "Sequential"
}
}
Até
A ação Até é executada e repete uma ou mais ações até que a condição especificada necessária seja atendida. Se a condição for atendida, o loop será interrompido. Caso contrário, o loop se repete. Para obter os limites padrão e máximo do número de ações ou iterações Until que um fluxo de trabalho pode ter, consulte Limites de simultaneidade, looping e debatching.
A lista a seguir contém alguns cenários comuns em que você pode usar uma ação Till :
Ligue para um ponto de extremidade até obter a resposta desejada.
Crie um registro em um banco de dados. Aguarde até que um campo específico nesse registro seja aprovado. Continue o processamento.
No fluxo de trabalho de exemplo a seguir, a partir das 8h00 todos os dias, a ação Until incrementa uma variável até que o valor da variável seja igual a 10. Em seguida, o fluxo de trabalho envia um e-mail que confirma o valor atual.
Nota
Este exemplo usa o Office 365 Outlook, mas você pode usar qualquer provedor de email suportado pelos Aplicativos Lógicos do Azure. Se você usar outra conta de email, as etapas gerais permanecerão as mesmas, mas sua interface do usuário poderá parecer ligeiramente diferente.
No portal do Azure, crie um recurso de aplicativo lógico de consumo com um fluxo de trabalho em branco.
No designer, siga estas etapas gerais para adicionar o gatilho interno de Recorrência chamado Agenda ao seu fluxo de trabalho.
No gatilho Recorrência , especifique o intervalo, a frequência e a hora do dia para que o gatilho seja acionado.
Property valor Intervalo 1 Frequência Day At these hours (A estas horas) 8 Para adicionar o parâmetro Nestas horas, abra a lista Adicionar novo parâmetro e selecione Nessas horas, que aparece somente depois que você define Frequência como Dia.
Quando terminar, o gatilho Recorrência se parece com o exemplo a seguir:
Sob o gatilho, siga estas etapas gerais para adicionar a ação interna Variáveis chamada Inicializar variável ao seu fluxo de trabalho.
Na ação Inicializar variável, forneça os seguintes valores:
Property valor Descrição Nome Limite O nome da sua variável Tipo Inteiro O tipo de dados da sua variável Valor 0 Valor inicial da sua variável 
Na ação Inicializar variável, siga estas etapas gerais para adicionar a ação interna Controle chamada Até ao seu fluxo de trabalho.
Na ação Até, forneça os seguintes valores para configurar a condição de parada para o loop.
Selecione dentro da caixa mais à esquerda chamada Escolha um valor, que abre automaticamente a lista de conteúdo dinâmico.
Na lista, em Variáveis, selecione a variável chamada Limite.
Na lista de operadores do meio, selecione o é igual a operador.
Na caixa mais à direita chamada Escolha um valor, digite 10 como o valor de comparação.
Dentro da ação Até, selecione Adicionar uma ação.
Na caixa de pesquisa Escolha uma operação, siga estas etapas gerais para adicionar a ação interna Variáveis chamada Variável de incremento à ação Até.
Na ação Variável de incremento, forneça os seguintes valores para incrementar o valor da variável Limite em 1:
Property valor Nome Selecione a variável Limit . Valor 1 
Fora e em Até ação, siga estas etapas gerais para adicionar uma ação que envia email.
Este exemplo continua com a ação do Office 365 Outlook chamada Enviar um email.
Na ação de email, forneça os seguintes valores:
Property valor Description De <e-mail-address@domain> O endereço de e-mail do destinatário. Para testar, use seu próprio endereço de e-mail. Assunto O valor atual para a variável "Limit" é: Limit O assunto do e-mail. Para este exemplo, certifique-se de incluir a variável Limit para confirmar se o valor atual atende à condição especificada:
1. Selecione dentro da caixa Assunto para que a lista de conteúdo dinâmico apareça.
2. Na lista de conteúdo dinâmico, ao lado do cabeçalho da seção Variáveis , selecione Ver mais.
3. Selecione Limite.Corpo <conteúdo de e-mail> O conteúdo da mensagem de email que você deseja enviar. Para este exemplo, insira o texto desejado. Quando terminar, sua ação de email será semelhante ao exemplo a seguir:
Salve seu fluxo de trabalho.
Testar o fluxo de trabalho
Para testar manualmente o fluxo de trabalho do aplicativo lógico, siga as etapas com base no fato de você ter um aplicativo lógico Consumo ou Padrão.
Depois que o fluxo de trabalho começar a ser executado, você receberá um e-mail com o conteúdo especificado:
Evite loops intermináveis
A ação Até interrompe a execução com base nas seguintes propriedades, que você pode exibir selecionando Alterar limites na ação. Certifique-se de definir esses valores de propriedade de acordo:
| Property | Descrição |
|---|---|
| Contagem | O número máximo de iterações executadas antes da saída do loop. Para obter os limites padrão e máximo do número de ações Until que um fluxo de trabalho pode ter, consulte Limites de simultaneidade, looping e debatching. |
| Tempo limite | A quantidade máxima de tempo que a ação Till , incluindo todas as iterações, é executada antes que o loop saia. Este valor é especificado no formato ISO 8601 e é avaliado para cada iteração. Se qualquer ação no loop demorar mais do que o limite de tempo limite, a iteração atual não será interrompida. No entanto, a próxima iteração não é iniciada porque a condição de limite de tempo limite é atendida. Para obter os limites padrão e máximo no valor de tempo limite, consulte Simultaneidade, looping e limites de deslote. |
Definição de "até" (JSON)
Se você estiver trabalhando na visualização de código, poderá definir uma Until ação na definição JSON do seu fluxo de trabalho, por exemplo:
"actions": {
"Initialize_variable": {
// Definition for initialize variable action
},
"Send_an_email": {
// Definition for send email action
},
"Until": {
"type": "Until",
"actions": {
"Increment_variable": {
"type": "IncrementVariable",
"inputs": {
"name": "Limit",
"value": 1
},
"runAfter": {}
}
},
"expression": "@equals(variables('Limit'), 10)",
// To prevent endless loops, an "Until" loop
// includes these default limits that stop the loop.
"limit": {
"count": 60,
"timeout": "PT1H"
},
"runAfter": {
"Initialize_variable": [
"Succeeded"
]
}
}
}
Este exemplo Until loop chama um ponto de extremidade HTTP, que cria um recurso. O loop para quando o corpo da resposta HTTP retorna com Completed status. Para evitar loops intermináveis, o loop também para se alguma das seguintes condições acontecer:
O loop foi executado 10 vezes,
countconforme especificado pelo atributo. O padrão é 60 vezes.O loop foi executado por duas horas,
timeoutconforme especificado pelo atributo no formato ISO 8601. O padrão é uma hora.
"actions": {
"myUntilLoopName": {
"type": "Until",
"actions": {
"Create_new_resource": {
"type": "Http",
"inputs": {
"body": {
"resourceId": "@triggerBody()"
},
"url": "https://domain.com/provisionResource/create-resource",
"body": {
"resourceId": "@triggerBody()"
}
},
"runAfter": {},
"type": "ApiConnection"
}
},
"expression": "@equals(triggerBody(), 'Completed')",
"limit": {
"count": 10,
"timeout": "PT2H"
},
"runAfter": {}
}
}