Executar loops para repetir ações em fluxos de trabalho do Aplicativos Lógicos do Azure

Aplica-se a: Aplicativos Lógicos do Azure (Consumo + Padrão)

Para executar as mesmas ações em cada item de uma matriz ou coleção, ou repetir ações até que algo seja concluído no fluxo de trabalho do seu aplicativo lógico, adicione ao seu fluxo de trabalho a ação Controle chamada For each ou Until, respectivamente:

Este guia mostra como adicionar um loop ao seu fluxo de trabalho, executar iterações sequencialmente e evitar loops intermináveis. Pule direto para a tarefa que você quer:

• Adicione um ciclo For Each ao seu fluxo de trabalho
• Executar para cada uma das iterações sequencialmente
• Adicione um loop Until ao seu fluxo de trabalho
• Prevenir loops intermináveis

Pré-requisitos

• Uma conta e uma assinatura do Azure. Obtenha uma conta gratuita do Azure.

• O fluxo de trabalho do aplicativo lógico no qual você deseja executar o loop, incluindo um gatilho que inicia o fluxo de trabalho.

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

Este guia usa o portal do Azure, mas você pode usar o Visual Studio Code e a correspondente extensão Aplicativos Lógicos do Azure 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

Considerações para cada loop

A ação For each repete uma ou mais ações em cada item do array ou da coleção.

• A ação For each funciona apenas com arrays e coleções.

• A ação Para cada processa um número limitado de itens do array.

• Por padrão, para cada ação, as iterações são executadas em paralelo. Comportamentos-chave a conhecer:

  Behavior	O que significa
  Paralelo por padrão	Ao contrário do loop do Power Automate Apply to each, as iterações não são executadas uma de cada vez. Se seu cenário precisar de processamento sequencial, consulte Executar para cada iteração sequencialmente. Por exemplo, para pausar a próxima iteração em uma ação Para cada usando a ação Atrasar, configure cada iteração para ser executada sequencialmente.
  Laços aninhados	Uma ação Para cada aninhada sempre é executada sequencialmente. Para rodar em paralelo, crie e chame um fluxo de trabalho filho.
  Variables	Variável de incremento, variável de decrescente e Acrescentar à variável podem devolver resultados imprevisíveis em loops paralelos. Para garantir que as variáveis em um loop produzam resultados previsíveis das operações sobre essas variáveis durante cada iteração, execute o loop sequencialmente.

• As ações em um loop Para cada usam a função item() para fazer referência e processar cada item na matriz. Se você especificar dados que não estejam 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 um site. O fluxo de trabalho usa uma ação Para cada que envia um email para cada novo item.

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

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

     Siga estas etapas gerais para adicionar um gatilho a um fluxo de trabalho de aplicativo lógico de Consumo ou Standard.

   • A ação do Outlook.com ou Office 365 Outlook chamada Enviar um email

     Siga estas etapas gerais para adicionar uma ação a um fluxo de trabalho de aplicativo lógico de Consumo ou Standard.

2. No Designer, entre o gatilho e a ação Enviar um e-mail, adicione a ação chamada Para cada, seguindo as etapas gerais com base no tipo de fluxo de trabalho:

   • Consumo
   • Standard

3. Agora, compile o loop:

   1. Na ação Para cada, selecione dentro da caixa Selecionar uma saída das etapas anteriores para ver as opções de entrada e, então, selecione o ícone de raio.

   2. Na lista de conteúdo dinâmico que é exibida, em Quando um item do feed é publicado, selecione Links de feed, que é uma saída de matriz do gatilho RSS.

      Observação

      Se a saída Links do Feed não aparecer, selecione Ver mais ao lado do rótulo da seção de gatilho. Na lista de conteúdo dinâmico, você pode selecionar apenas saídas das etapas anteriores.

      

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

      

   3. Para executar uma ação existente em cada item de matriz, arraste a ação Enviar um email para o loop Para cada.

      Seu fluxo de trabalho é o seguinte exemplo:

      

4. Salve seu fluxo de trabalho.

5. Para testar manualmente o 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 exibição de código, será possível definir a ação For_each na definição JSON do 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: execute iterações de loop sequencialmente

Por padrão, as iterações em uma ação For each são executadas ao mesmo tempo em paralelo. No entanto, se você tiver loops aninhados ou variáveis dentro dos loops em que você espera resultados previsíveis, você deve executar um loop de cada vez sequencialmente.

1. No designer, selecione a ação For each para abrir o painel de informações e selecione Configurações.

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

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

   

Definição de ação Para cada (JSON): executar sequencialmente

Se você estiver trabalhando na exibição de código com a ação For_each na definição JSON do fluxo de trabalho, adicione o parâmetro operationOptions 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 loop Until

A ação Until é executada e repete uma ou mais ações até que a condição necessária seja atendida. Se a condição é atendida, o loop para. Caso contrário, o loop repete. Para mais informações, veja Limites de Concorrência, Looping e Debatching.

A lista a seguir contém alguns cenários comuns em que você pode usar uma ação Until:

• Chamar um ponto de extremidade até obter a resposta desejada.

• Criar um registro em um banco de dados. Aguardar até que um campo específico nesse registro seja aprovado. Continuar o processamento.

Por padrão, a ação Until é 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 de loop for atingido, com base no comportamento após a execução.

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

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

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

  Para a ação falhar, 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"
  }
  

Adicione um loop Until ao seu fluxo de trabalho

O seguinte exemplo de fluxo de trabalho começa às 8h 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 email que confirma o valor atual. O exemplo usa o Office 365 Outlook, mas você pode usar qualquer provedor de email compatível com os Aplicativos Lógicos do Azure. Se você usar uma outra conta de email, as etapas gerais serão as mesmas, mas parecem um pouco 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 gatilho embutido Schedule chamado Recurrence seguindo os passos gerais baseados no tipo de fluxo de trabalho:

   • Consumo
   • Standard

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

   Parâmetro	Valor
   Intervalo	1
   Frequência	Day
   A estas horas	8
   A estes minutos	00

   Nessas horas e nesses minutos aparecem depois que você define Frequência como Dia.

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

   

4. No designer, adicione a ação embutida Variáveis chamada Inicialize variable seguindo os passos gerais baseados no tipo de fluxo de trabalho:

   • Consumo
   • Standard

5. Na ação Inicializar variável , forneça as seguintes informações:

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

   

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

   • Consumo
   • Standard

7. Na ação Até que, defina a condição de parada para o loop:

   1. Selecione dentro da caixa Loop Until e depois selecione o ícone do raio para abrir a lista dinâmica de conteúdo.

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

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

   

8. Na ação Until, selecione +>Adicionar uma ação.

9. Adicione a ação embutida 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 Incrementar variável, forneça os seguintes valores para incrementar o valor da variável Limite em 1:

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

    

11. Fora e abaixo da ação Until, adicione uma ação que envie um e-mail seguindo as etapas gerais de acordo com 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	< endereço de email@domínio>	O endereço de email do destinatário. Para testes, use seu próprio endereço de email.
    Assunto	O valor atual da variável "Limite" é:Limite	O assunto do email. Para este exemplo, inclua a variável Limite para confirmar se o valor atual atende à condição especificada: 1. Selecione dentro da caixa Assunto e selecione o ícone de raio. 2. Na lista de conteúdo dinâmico que é aberta, ao lado do cabeçalho da seção Variáveis, selecione Ver mais. 3. Selecione Limite.
    Corpo	< conteúdo do email>	O conteúdo da mensagem de email que deseja enviar. Para esse exemplo, insira o texto de sua escolha.

    O exemplo a seguir mostra como sua ação de e-mail aparece:

    

13. Salve seu fluxo de trabalho.

Testar seu fluxo de trabalho

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

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

Após o fluxo de trabalho iniciar a execução, você receberá um email com o conteúdo especificado:

Impedir loops infinitos

A ação Until interrompe a execução com base nos parâmetros Contagem e Tempo limite opcionais. Defina esses parâmetros da propriedade de acordo:

Revisar o histórico de execução das iterações do loop Until

Quando você exibe o histórico de execuções de um fluxo de trabalho que inclui um loop Until , o status detalhado e os resultados das ações dentro do loop só ficam disponíveis depois que todo o loop concluir sua execução. Enquanto o loop Until ainda está executando suas iterações, a ação do loop mostra o status Running, mas você não pode expandir ou percorrer os resultados individuais de cada iteração até que o loop termine.

O loop é encerrado quando uma das seguintes condições é atendida:

• A expressão especificada é avaliada como true.
• O laço atinge o limite Count.
• O loop atinge o tempo limite .

Após a conclusão do loop, você pode selecionar a ação Until no histórico de execução para exibir cada iteração e o status das ações filho dentro dessa iteração.

Definição da ação Until (JSON)

Se você estiver trabalhando na exibição de código, será possível definir uma ação Until na definição JSON do 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"
         ]
      }
   }
}

Neste exemplo, o loop Until chama um ponto de extremidade HTTP, que cria um recurso. O loop para quando o corpo da resposta HTTP retorna com o status Completed. Para impedir loops infinitos, o loop também irá parar se as condições a seguir ocorrerem:

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

• O loop 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": {}
   }
}

Próximas Etapas 

Conteúdo relacionado

• Executar etapas baseadas em uma condição (ações condicionais)
• Executar etapas baseadas em valores diferentes (instruções de opção)
• Executar ou mesclar etapas paralelas (branches)
• Executar etapas baseadas no status da ação agrupada (escopos)