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 seu caso de uso, você pode escolher entre os seguintes tipos de ações de loop:

• Para repetir uma ou mais ações em itens de uma matriz ou coleção, adicione a ação Para cada ao seu 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á desagrupar a matriz definindo a propriedade Split on trigger.

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

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

• O recurso de aplicativo lógico e fluxo de trabalho onde 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 primeira etapa. Para obter mais informações, consulte 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 dos 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 ligeiramente com base no fato de você ter um fluxo de trabalho Consumo ou Padrão.

Para cada

O Para cada ação funciona apenas em matrizes. Esse loop repete uma ou mais ações em cada item de uma matriz. Analise as seguintes considerações 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. Se o seu caso de uso exigir processamento sequencial, você pode configurar Para cada iteração para executar uma de cada vez. 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 ações simultaneamente em itens de matriz em um aninhado Para cada ação, crie e chame um fluxo de trabalho 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.

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 Consumo ou Padrão .

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

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

2. 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.

3. Agora construa o loop:

   1. Na caixa Para cada item, selecione dentro da caixa Selecionar uma saída das etapas anteriores e, em seguida, selecione o ícone de relâmpago.

   2. Na lista de conteúdo dinâmico que é aberta, em 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:

      

   3. 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:

      

4. Quando tiver terminado, guarde o 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 um: Executar sequencialmente

Por padrão, as iterações em um Para cada ação são executadas ao mesmo tempo em paralelo. No entanto, se você tiver loops aninhados ou tiver variáveis dentro de loops onde espera resultados previsíveis, deverá executar esses loops um de cada vez sequencialmente.

1. No designer, selecione Para cada ação para abrir o painel de informações e, em seguida, selecione Configuraçõ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"
   }
}

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 , consulte Simultaneidade, looping e limites de desloteamento.

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.

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

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. 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. 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 Consumo ou Padrão .

3. No gatilho Recorrência , especifique o intervalo, a frequência e o tempo para o disparo do gatilho.

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

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

   Quando terminar, o gatilho Recorrência se parece com o exemplo a seguir:

   

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

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

   Parâmetro	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

   

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

7. Na ação Até, forneça os seguintes valores 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. Dentro da ação Até , selecione +>Adicionar uma ação.

9. Siga estas etapas gerais para adicionar a ação interna Variáveis chamada Variável de incremento à ação Até no fluxo de trabalho do aplicativo lógico Consumo ou Padrão .

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 sob a ação Até , siga estas etapas gerais para adicionar uma ação que envia email no fluxo de trabalho do aplicativo lógico Consumo ou Padrão .

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

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

    

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 loops intermináveis

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:

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, count conforme especificado pelo atributo. O padrão é 60 vezes.

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

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 status da ação agrupada (escopos)