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

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

Para repetir ações em um fluxo de trabalho de aplicativo lógico, você pode adicionar o loop For each ou Until ao seu fluxo de trabalho, com base nas necessidades do seu cenário.

Com base no caso de uso, você pode escolher entre os seguintes tipos de ações de loop:

• Para repetir uma ou mais ações em itens em uma matriz ou coleção, adicione a ação For each ao fluxo de trabalho.

  Como alternativa, se você tiver um gatilho que possa manipular matrizes e quiser executar uma instância de fluxo de trabalho para cada item de matriz, poderá dividir a matriz definindo a propriedade do gatilho Dividir em.

• Para repetir uma ou mais ações até que uma condição seja atendida ou um estado específico seja alterado, adicione a ação Until ao fluxo de trabalho.

  O 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 é atendida, o loop para. Caso contrário, o loop repete. Para obter os limites padrão e máximo no número de loops Until que um fluxo de trabalho pode ter, veja Simultaneidade, looping e limites de debatching.

Pré-requisitos

• Uma conta e uma assinatura do Azure. Se você não tem uma assinatura, inscreva-se em uma conta gratuita do Azure.

• Um recurso de aplicativo lógico em que você pode criar e editar um fluxo de trabalho. Confira O que são Aplicativos Lógicos do Azure.

• O fluxo de trabalho e o recurso do aplicativo lógico em que você deseja repetir uma ação em um loop e um gatilho que inicia o fluxo de trabalho.

  Antes de adicionar uma ação de loop, seu fluxo de trabalho deve começar com um gatilho como a primeira etapa. Para obter mais informações, confira Adicionar um gatilho ou ação para criar um fluxo de trabalho.

As etapas a seguir usam o portal do Azure, mas com a extensão apropriada do Aplicativos Lógicos do Azure, você também pode usar as seguintes ferramentas para criar fluxos de trabalho de aplicativos lógicos:

• Fluxos de trabalho de Consumo: Visual Studio Code
• Fluxos de trabalho padrão: Visual Studio Code

Algumas etapas diferem um pouco com base em se você tem um fluxo de trabalho de Consumo ou Standard.

Para cada

A ação For each funciona apenas em matrizes. Esse loop repete uma ou mais ações em cada item em uma matriz. Analise as seguintes considerações para a ação For each:

• A ação Para cada pode processar um número limitado de itens de matriz. Para esse limite, veja Simultaneidade, looping e limites de debatching.

• Por padrão, os ciclos ou iterações em uma ação Para cada são executados ao mesmo tempo em paralelo.

  Esse comportamento é diferente do loop Aplicar a cada do Power Automate, em que as iterações são executadas uma por vez ou sequencialmente. Se o caso de uso exigir processamento sequencial, você poderá configurar iterações For each para ser executada uma de cada vez. Por exemplo, se você quiser pausar a próxima iteração em uma ação Para cada usando a ação Atrasar, será necessário definir cada iteração para ser executada sequencialmente.

  Como exceção ao comportamento padrão, as iterações da ação Para cada aninhadas sempre são executadas sequencialmente, não em paralelo. Para executar ações simultaneamente em itens de matriz em uma ação For each aninhada, crie e chame um fluxo de trabalho secundário.

• Para obter resultados previsíveis de operações em variáveis durante cada iteração, execute essas iterações sequencialmente. Por exemplo, quando uma iteração em execução simultânea termina, as operações Incrementar variável, Diminuir variável e Acrescentar à variável 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.

• 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á.

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. Siga as mesmas etapas gerais para adicionar a ação For each entre o gatilho RSS e a açãoSend an email em seu fluxo de trabalho.

3. Agora, compile o loop:

   1. No item For each, selecione dentro da caixa Selecionar uma saída das etapas anteriores e, em seguida, 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.

      

      Quando terminar, a saída da matriz selecionada será exibida como no exemplo a seguir:

      

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

      Agora, o fluxo de trabalho terá aparência semelhante à do exemplo a seguir:

      

4. Quando terminar, salve o 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: executar 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"
   }
}

Até

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 obter os limites padrão e máximo no número de iterações ou ações Until, veja Simultaneidade, looping e limites de divisão.

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_8": [
         "Succeeded"
       ]
     },
  "type": "Until"
  }
  

No fluxo de trabalho de exemplo a seguir, começando às 8h de cada dia, 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 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. Consulte o procedimento anterior.

2. No designer, siga as etapas gerais para adicionar o gatilho interno Agendar chamado Recorrência ao seu fluxo de trabalho de Consumo ou Standard.

3. No gatilho Recorrência, especifique o intervalo, a frequência e a hora para o gatilho ser acionado.

   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.

   Quando terminar, o gatilho Recorrência será semelhante ao exemplo a seguir:

   

4. No gatilho, siga estas etapas gerais para adicionar a ação interna Variáveis chamada Inicializar variável ao fluxo de trabalho do aplicativo lógico de Consumo ou Standard.

5. Na ação Inicializar variável, forneça os seguintes valores:

   Parâmetro	Valor	Descrição
   Nome	Limite	Nome da variável
   Tipo	Inteiro	Tipo de dados da variável
   Valor	0	Valor inicial de variável

   

6. Na ação Inicializar variáveis, siga estas etapas gerais para adicionar a ação interna de Controle chamada Until ao fluxo de trabalho do aplicativo lógico de Consumo ou Standard.

7. Na ação Until, forneça os valores a seguir para configurar a condição de parada para o loop.

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

   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. Siga estas etapas gerais para adicionar a ação interna de Variáveis denominada Variável de incremento à ação Until em seu fluxo de trabalho do aplicativo lógico de Consumo ou 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 na ação Until, siga estas etapas gerais para adicionar uma ação que envia emails em seu fluxo de trabalho do aplicativo lógico de Consumo ou 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.

    Quando terminar, a ação de email será semelhante ao exemplo a seguir:

    

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:

Definiçã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": {}
   }
}

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)