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 no fluxo de trabalho:

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

    Como alternativa, se você tiver um gatilho que recebe uma matriz e deseja executar uma iteração para cada item de matriz, é possível fazer debatch dessa matriz com o SplitOn da propriedade de gatilho.

  • Para repetir uma ou mais ações até que uma condição seja atendida ou um estado 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

For each

A ação Para cada funciona somente em matrizes e repete uma ou mais ações em cada item em uma matriz. A lista a seguir contém algumas considerações para quando você deseja usar uma ação For each:

  • A ação For each 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 For each 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. No entanto, você pode configurar iterações sequenciais For each. Por exemplo, se você quiser pausar a próxima iteração em uma ação For each 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 For each aninhadas 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 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 For each 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 For each que envia um email para cada novo item.

Com base em se você possui um fluxo de trabalho de Consumo ou Standard, siga as etapas correspondentes:

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

  2. Siga as mesmas etapas gerais para adicionar a ação For each entre o gatilho RSS e a ação Enviar um email em seu fluxo de trabalho.

  3. Agora, compile o loop:

    1. Selecione a caixa Selecionar uma saída das etapas anteriores para que a lista de conteúdo dinâmico seja aberta.

    2. Na lista Adicionar conteúdo dinâmico, na seção 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.

      Screenshot shows Azure portal, Consumption workflow designer, action named For each, and opened dynamic content list.

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

      Screenshot shows Consumption workflow, action named For each, and selected array output.

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

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

      Screenshot shows Consumption workflow, action named For each, and action named Send an email, now inside For each loop.

  4. Quando terminar, salve o fluxo de trabalho.

  5. Para testar manualmente o fluxo de trabalho, na barra de ferramentas do designer, selecione Executar Gatilho>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"
   }
},

For each: 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 em que você espera resultados previsíveis, você deve executar um loop de cada vez ou sequencialmente.

  1. No canto superior direito da ação For each, selecione reticências (...) >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 e selecione Concluído.

    Screenshot shows Consumption workflow, action named For each, concurrency control setting turned on, and degree of parallelism slider set to 1.

Definição de ação For each (JSON): executar sequencialmente

Se você estiver trabalhando na exibição de código com a ação For_each na definição de JSON do fluxo de trabalho, você pode usar a opção Sequential adicionando o parâmetro operationOptions, por exemplo:

"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 que um fluxo de trabalho pode ter, veja Simultaneidade, looping e limites de 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.

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.

Observação

Este exemplo usa o Outlook do Office 365, mas você pode usar qualquer provedor de email que seja compatível com Aplicativos Lógicos do Azure. Se você usar uma outra conta de email, as etapas gerais serão as mesmas, mas a interface do usuário poderá parecer um pouco diferente.

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

  2. No designer, siga estas etapas gerais para adicionar o gatilho interno Recorrência chamado Agendamento para seu fluxo de trabalho.

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

    Propriedade Valor
    Intervalo 1
    Frequência Day
    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 de definir a Frequência como Dia.

    Screenshot shows Azure portal, Consumption workflow designer, and Recurrence trigger parameters with selected option for At these hours.

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

    Screenshot shows Azure portal, Consumption workflow, and Recurrence trigger parameters set up.

  4. No gatilho, siga estas etapas gerais para adicionar a ação interna Variáveis chamada Inicializar variável ao fluxo de trabalho.

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

    Propriedade Valor Descrição
    Nome Limit Nome da variável
    Tipo Inteiro Tipo de dados da variável
    Valor 0 Valor inicial de variável

    Screenshot shows Azure portal, Consumption workflow, and parameters for built-in action named Initialize variable.

  6. Na ação Inicializar variável, siga estas etapas gerais para adicionar a ação interna Controle chamada Until ao fluxo de trabalho.

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

    1. Marque a caixa mais à esquerda chamada Escolher um valor, que abre automaticamente a lista de conteúdo dinâmico.

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

    3. Na lista de operadores intermediários, selecione o operador é igual a.

    4. Na caixa mais à direita chamada Escolher um valor, insira 10 como o valor de comparação.

    Screenshot shows Consumption workflow and built-in action named Until with finished stop condition.

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

  9. Na caixa de pesquisa Escolher uma operação, siga estas etapas gerais para adicionar a ação interna Variáveis chamada Incrementar variável à ação Until.

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

    Propriedade Valor
    Nome Selecione a variável Limite.
    Valor 1

    Screenshot shows Consumption workflow and built-in action named Until with Name set to the Limit variable and Value set to 1.

  11. Fora e sob a ação Until, siga estas etapas gerais para adicionar uma ação que envia emails.

    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:

    Propriedade 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, certifique-se de incluir a variável Limit para confirmar se o valor atual atende à condição especificada:

    1. Selecione a 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 <email-conteúdo> 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:

    Screenshot shows Consumption workflow and action named Send an email with property values.

  13. Salve seu fluxo de trabalho.

Testar seu fluxo de trabalho

Para testar manualmente o fluxo de trabalho do aplicativo lógico, siga as etapas com base em se você tem um aplicativo lógico de Consumo ou Standard.

Na barra de ferramentas do designer, escolha Executar gatilho>Executar.

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

Screenshot shows sample email received from example workflow.

Impedir loops infinitos

A ação Until interrompe a execução com base nas propriedades a seguir, que você pode exibir selecionando Alterar limites na ação. Defina esses valores da propriedade adequadamente:

Propriedade Descrição
Count O número máximo de iterações que são executados antes da saída do loop.

Para obter os limites padrão e máximo no número de ações Until que um fluxo de trabalho pode ter, veja Simultaneidade, looping e limites de debatching.
Tempo limite A quantidade máxima de tempo que a ação Until, incluindo todas as iterações, é executada antes da saída do loop. Esse valor é especificado no formato ISO 8601 e é avaliado para cada iteração.

Se qualquer ação no loop demorar mais do que o tempo limite, a iteração atual não parará. No entanto, a próxima iteração será iniciada porque a condição de limite de tempo foi atendida.

Para obter os limites padrão e máximo no valor Tempo limite, veja Simultaneidade, loop e limites de debatching.

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",
               "body": {
                  "resourceId": "@triggerBody()"
               }
            },
            "runAfter": {},
            "type": "ApiConnection"
         }
      },
      "expression": "@equals(triggerBody(), 'Completed')",
      "limit": {
         "count": 10,
         "timeout": "PT2H"
      },
      "runAfter": {}
   }
}

Próximas etapas