Executar ciclos para repetir ações em fluxos de trabalho para Azure Logic Apps

Aplica-se a: Azure Logic Apps (Consumo + Standard)

Para executar as mesmas ações em cada item de um array ou coleção, ou repetir ações até que algo termine no fluxo de trabalho da sua aplicação lógica, adicione a ação Control chamada For each ou Until ao seu fluxo de trabalho, respetivamente:

Action	Tarefa
Para cada	Repita uma ou mais ações nos itens de uma matriz ou coleção. Aplica-se apenas a arrays e coleções. Dica: Se tiver um accionador que processa matrizes e pretender executar uma instância do fluxo de trabalho para cada item da matriz, defina a propriedade Split on do accionador para dividir a matriz. Para informações, veja Limites de Concorrência, Looping e Debate.
Until	Repita uma ou mais ações até que uma condição seja cumprida ou um estado específico mude. O seu fluxo de trabalho executa primeiro todas as ações no ciclo e depois verifica a condição ou estado. Se a condição se verificar, o ciclo para. Caso contrário, o loop se repete. Para informações, veja Limites de Concorrência, Looping e Debate.

Este guia mostra como adicionar um ciclo ao seu fluxo de trabalho, executar iterações sequencialmente e evitar ciclos intermináveis. Avança para a tarefa que queres:

• Adicione um ciclo For Each ao seu fluxo de trabalho
• Executar cada iteração sequencialmente
• Adiciona um ciclo Until ao teu fluxo de trabalho
• Prevenir ciclos intermináveis

Nota

Para documentação do Power Automate, consulte Loops de utilização.

Pré-requisitos

• Uma conta do Azure e uma subscrição do Azure. Crie uma conta Azure gratuita.

• O fluxo de trabalho da aplicação lógica onde pretende executar o ciclo, incluindo um gatilho que inicia esse fluxo de trabalho.

  Antes de poderes adicionar uma ação de loop, o teu fluxo de trabalho deve começar com um gatilho como primeiro passo.

Este guia utiliza o portal Azure, mas pode usar o Visual Studio Code e a correspondente extensão Azure Logic Apps para construir fluxos de trabalho de Logic App:

• Criar fluxos de trabalho de consumo no Visual Studio Code
• Criar fluxos de trabalho padrão no Visual Studio Code

Para considerações de cada ciclo

A ação Para cada repete uma ou mais ações em cada item da matriz ou da coleção.

• A ação Para cada funciona apenas em arrays e coleções.

• A ação For each processa um número limitado de itens da matriz.

• Por defeito, para cada ação as iterações correm em paralelo. Comportamentos chave a conhecer:

  Comportamento	O que significa
  Paralelo por defeito	Ao contrário do Apply to each loop do Power Automate, as iterações não se executam uma de cada vez. Se o seu cenário precisar de processamento sequencial, veja Executar para cada iteração sequencialmente. Por exemplo, para pausar a iteração seguinte numa ação Para cada utilizando a ação Atraso, configure cada iteração para ser executada sequencialmente.
  Laços aninhados	Uma ação Para cada aninhada é sempre executada sequencialmente. Para correr em paralelo, cria e chama um fluxo de trabalho filho.
  Variables	Variável de incremento, variável de diminuição e Acrescentar à variável podem devolver resultados imprevisíveis em ciclos paralelos. Para garantir que as variáveis num ciclo produzem resultados previsíveis das operações sobre essas variáveis durante cada iteração, execute o ciclo sequencialmente.

• As ações num ciclo For each utilizam a função item() para referir e processar cada item no array. Se você especificar dados que não estão em uma matriz, o fluxo de trabalho falhará.

Adicione um ciclo For Each ao seu fluxo de trabalho

O fluxo de trabalho de exemplo a seguir envia um resumo diário para um RSS feed de site. O fluxo de trabalho usa uma ação For each que envia um e-mail para cada item novo.

1. No portal do Azure, crie um fluxo de trabalho de aplicativo lógico com as seguintes etapas na ordem especificada:

   • O gatilho RSS denominado Quando um item de feed é publicado

     Siga estes passos gerais para adicionar um acionador a um fluxo de trabalho de uma aplicação lógica Consumption ou Standard.

   • A ação do Outlook.com ou do Office 365 Outlook denominada Enviar um e-mail

     Siga estes passos gerais para adicionar uma ação a um fluxo de trabalho de uma aplicação lógica Consumo ou Padrão.

2. No estruturador, entre o acionador e a ação Enviar um e-mail, adicione a ação com o nome Para cada, seguindo os passos gerais com base no seu tipo de fluxo de trabalho:

   • Consumo
   • Standard

3. Agora construa o loop:

   1. Na ação Para cada, selecione dentro da caixa Selecionar um resultado dos passos anteriores para ver as opções de entrada e, em seguida, selecione o ícone de relâmpago.

   2. Na lista de conteúdo dinâmico que se abre, em Quando um item de feed é publicado, selecione Ligações do feed, que corresponde a uma saída em matriz do gatilho RSS.

      Nota

      Se a saída Ligações de feed não aparecer, selecione Ver mais junto ao rótulo da secção do acionador. Na lista de conteúdo dinâmico, você pode selecionar apenas saídas de etapas anteriores.

      

      O exemplo seguinte mostra a saída selecionada do array:

      

   3. Para executar uma ação existente em cada item do array, arraste a ação Enviar um e-mail para o ciclo Para cada.

      O seu fluxo de trabalho é o seguinte exemplo:

      

4. Salve seu fluxo de trabalho.

5. Para testar manualmente seu fluxo de trabalho, na barra de ferramentas do designer, selecione Executar>Executar.

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: Executar sequencialmente as iterações do ciclo

Por predefinição, as iterações numa ação For each são executadas em paralelo. No entanto, se tiver ciclos aninhados ou variáveis dentro de ciclos das quais espera resultados previsíveis, deve executar esses ciclos sequencialmente, um de cada vez.

1. No estruturador, selecione a ação Para cada para abrir o painel de informações e, em seguida, selecione Definições.

2. Em Controle de simultaneidade, altere a configuração de Desativado para Ativado.

3. Mova o controle deslizante Grau de paralelismo para 1.

   

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, adicione o operationOptions parâmetro e defina o valor do parâmetro como Sequential:

"actions": {
   "For_each": {
      "actions": {
         "Send_an_email_(V2)": { }
      },
      "foreach": "@triggerBody()?['links']",
      "runAfter": {},
      "type": "Foreach",
      "operationOptions": "Sequential"
   }
}

Considerações sobre o ciclo until

A ação Until executa e repete uma ou mais ações até que a condição especificada necessária seja satisfeita. Se a condição se verificar, o ciclo para. Caso contrário, o loop se repete. Para mais informações, veja limites de concorrência, de ciclo e de desagrupamento.

A lista seguinte contém alguns cenários comuns em que pode utilizar uma ação Até:

• Chame um endpoint até obter a resposta pretendida.

• Crie um registro em um banco de dados. Aguarde até que um campo específico nesse registro seja aprovado. Continue o processamento.

Por padrão, a ação Até é bem-sucedida ou falha das seguintes maneiras:

• O loop Until terá êxito se todas as ações dentro do loop forem bem-sucedidas e se o limite do loop for atingido, com base no comportamento run after.

• Se todas as ações na última iteração do loop Until forem bem-sucedidas, todo o loop Until será marcado como Succeeded.

• Se alguma ação falhar na última iteração do loop Até, todo o loop Até será marcado como Falhou.

• Se alguma ação falhar em uma iteração diferente da última iteração, a próxima iteração continuará a ser executada e toda a ação Until não será marcada como Falha.

  Para fazer com que a ação falhe, altere o comportamento padrão na definição JSON do loop adicionando o parâmetro chamado operationOptions, e definindo o valor como FailWhenLimitsReached, por exemplo:

  "Until": {
     "actions": {
       "Execute_stored_procedure": {
         <...>
         }
       },
       "expression": "@equals(variables('myUntilStop'), true)",
       "limit": {
         "count": 5,
         "timeout": "PT1H"
       },
       "operationOptions": "FailWhenLimitsReached",
       "runAfter": {
       "Initialize_variable": [
         "Succeeded"
       ]
     },
  "type": "Until"
  }
  

Adiciona um ciclo Until ao teu fluxo de trabalho

O seguinte exemplo de fluxo de trabalho começa às 8:00 da manhã todos os dias. O fluxo de trabalho usa a ação Até para incrementar uma variável até que o valor seja igual a 10. Em seguida, o fluxo de trabalho envia um e-mail que confirma o valor atual. O 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 e-mail, as etapas gerais permanecerão as mesmas, mas parecerão ligeiramente diferentes.

1. No portal do Azure, crie um recurso de aplicativo lógico com um fluxo de trabalho em branco.

2. No designer, adicione o acionador incorporado Schedule com o nome Recorrência, ao seguir os passos gerais consoante o tipo de fluxo de trabalho:

   • Consumo
   • Standard

3. No gatilho de Recorrência, forneça as seguintes informações:

   Parâmetro	valor
   Intervalo	1
   Frequência	Dia
   At these hours (A estas horas)	8
   Nestes minutos	00

   Nestas horas e nestes minutos aparecem depois de definir Frequência para Dia.

   O exemplo seguinte mostra como o gatilho de Recorrência aparece:

   

4. No designer, adicione a ação incorporada Variáveis chamada Inicializar variável seguindo os passos gerais com base no seu tipo de fluxo de trabalho:

   • Consumo
   • Standard

5. Na ação Inicializar variável , forneça a seguinte informação:

   Parâmetro	valor	Descrição
   Nome	Limite	O nome da tua variável.
   Tipo	Inteiro	O tipo de dado da sua variável.
   Valor	0	O valor inicial da tua variável.

   

6. Na ação Inicializar variável , adicione a ação incorporada Controlo chamada Até seguindo os passos gerais baseados no tipo de fluxo de trabalho:

   • Consumo
   • Standard

7. Na ação Até, defina a condição de paragem para o ciclo:

   1. Selecione dentro da caixa Loop Until e depois selecione o ícone de relâmpago para abrir a lista de conteúdos dinâmicos.

   2. Na lista, em Variáveis, selecione a variável chamada Limite.

   3. Em Contagem, insira 10 como o valor de comparação.

   

8. Dentro da ação Até , selecione +>Adicionar uma ação.

9. Adicione a ação incorporada Variables chamada variável Increment à ação Until seguindo os passos gerais baseados no tipo de fluxo de trabalho:

   • Consumo
   • Standard

10. Na ação Variável de incremento, forneça os seguintes valores para incrementar o valor da variável Limite em 1:

    Parâmetro	valor
    Limite	Selecione a variável Limit .
    Valor	1

    

11. Fora e abaixo da ação Até , adicione uma ação que envie um email seguindo os passos gerais consoante o tipo de fluxo de trabalho:

    • Consumo
    • Standard

    Este exemplo continua com a ação do Office 365 Outlook chamada Enviar um email.

12. Na ação de email, forneça os seguintes valores:

    Parâmetro	valor	Descrição
    Para	< 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 e, em seguida, selecione o ícone de relâmpago. 2. Na lista de conteúdo dinâmico que se abre, junto ao cabeçalho da secçã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.

    O exemplo seguinte mostra como a sua ação de email aparece:

    

13. Salve seu fluxo de trabalho.

Testar o fluxo de trabalho

Para testar manualmente o fluxo de trabalho do aplicativo lógico:

• Na barra de ferramentas do designer, na opção Executar , selecione Executar.

Depois que o fluxo de trabalho começar a ser executado, você receberá um e-mail com o conteúdo especificado:

Evite ciclos infinitos

A ação Até interrompe a execução com base nos parâmetros opcionais Contagem e Tempo Limite . Certifique-se de definir esses valores de parâmetro de acordo:

Parâmetro	Descrição
Contagem	O número máximo de iterações executadas antes da saída do loop. Para os limites predefinido e máximo do número de ações Until que um fluxo de trabalho pode ter, consulte Limites de concorrência, repetição em ciclo e debatching.
Tempo limite	O tempo máximo durante o qual a ação Until, incluindo todas as iterações, é executada antes de o ciclo terminar. 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 se inicia porque a condição de tempo limite é atingida. Para os limites predefinidos e máximos do valor de Timeout, consulte Limites de concorrência, de repetição em ciclo e de desagregação em lotes.

Revise o histórico de execuções das iterações do ciclo Until

Quando visualiza o histórico de execução de um fluxo de trabalho que inclui um ciclo Until, o estado detalhado e os resultados das ações dentro do ciclo só estão disponíveis após o ciclo concluir toda a sua execução. Enquanto o loop Until ainda está a executar as suas iterações, a ação do loop mostra o estado Running , mas não podes expandir ou percorrer os resultados individuais da iteração até que o loop saia.

O ciclo termina quando se verifica uma das seguintes condições:

• A expressão especificada avalia-se como verdadeira.
• O ciclo atinge o limite de Count.
• O ciclo atinge o limite de Timeout .

Depois de o ciclo terminar, pode selecionar a ação Until no histórico de execução para visualizar cada iteração e o estado das ações filhas dentro dessa iteração.

Nota

Se o seu ciclo Until for executado durante um período prolongado, tem de esperar que o ciclo termine completamente antes de poder consultar o histórico de execução para ver os resultados das iterações individuais. Para monitorizar ciclos de longa duração e em andamento, considere adicionar ações de registo ou notificação dentro do ciclo que emitam estado de forma independente, por exemplo, enviando uma mensagem para uma fila ou atualizando uma variável que um branch paralelo possa ler.

Até à definição da ação (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 de ciclo Until invoca um terminal HTTP, que cria um recurso. O ciclo termina quando o corpo da resposta HTTP é devolvido com o estado Completed. Para evitar ciclos intermináveis, o ciclo também é interrompido se ocorrer alguma das seguintes condições:

• O ciclo foi executado 10 vezes conforme especificado pelo atributo count. O padrão é 60 vezes.

• O ciclo foi executado durante duas horas, conforme especificado pelo atributo timeout 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"
            },
            "runAfter": {},
            "type": "ApiConnection"
         }
      },
      "expression": "@equals(body('Create_new_resource'), 'Completed')",
      "limit": {
         "count": 10,
         "timeout": "PT2H"
      },
      "runAfter": {}
   }
}

Passos seguintes

Adicione uma condição ao seu fluxo de trabalho

Conteúdo relacionado

• Executar etapas com base em uma condição (ação de condição)
• Executar etapas com base em valores diferentes (ação de alternância)
• Executar ou mesclar etapas paralelas (ramificações)
• Executar etapas com base no estado das ações agrupadas (escopos)