Partilhar via


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

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

    Como alternativa, se você tiver um gatilho que recebe uma matriz e quiser executar uma iteração para cada item de matriz, poderá desagrupar essa matriz com a propriedade de gatilho SplitOn.

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

Para cada

O Para cada ação funciona apenas em matrizes e repete uma ou mais ações em cada item de uma matriz. A lista a seguir contém algumas considerações para quando você deseja usar um 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. No entanto, você pode configurar sequencial para cada iteração. 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 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 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.

Com base no fluxo de trabalho Consumo ou Padrão, siga as etapas correspondentes:

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

  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. Selecione dentro da 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 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.

      A captura de tela mostra o portal do Azure, o designer de fluxo de trabalho de consumo, a ação nomeada Para cada um e a lista de conteúdo dinâmico aberta.

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

      A captura de tela mostra o fluxo de trabalho de consumo, a ação nomeada Para cada um e a saída da matriz selecionada.

    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:

      A captura de tela mostra o fluxo de trabalho de consumo, a ação chamada Para cada um e a ação chamada Enviar um e-mail, agora dentro de Para cada loop.

  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 Execução de Gatilho>.

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 loop For each são executadas ao mesmo tempo em paralelo. No entanto, quando você tem loops aninhados ou variáveis dentro dos loops onde você espera resultados previsíveis, você deve executar esses loops um de cada vez ou sequencialmente.

  1. No canto superior direito de cada ação, selecione as 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.

    A captura de tela mostra o fluxo de trabalho de consumo, a ação nomeada Para cada um, a configuração de controle de simultaneidade ativada e o controle deslizante de grau de paralelismo definido como 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, poderá usar a Sequential opção adicionando o operationOptions parâmetro, por exemplo:

"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 que um fluxo de trabalho pode ter, consulte Limites de simultaneidade, looping e debatching.

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.

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.

Nota

Este 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 email, as etapas gerais permanecerão as mesmas, mas sua interface do usuário poderá parecer ligeiramente 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 de Recorrência chamado Agenda ao seu fluxo de trabalho.

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

    Property valor
    Intervalo 1
    Frequência Day
    At these hours (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 que você define Frequência como Dia.

    A captura de tela mostra o portal do Azure, o designer de fluxo de trabalho de consumo e os parâmetros de gatilho de recorrência com a opção selecionada para Nessas horas.

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

    A captura de tela mostra o portal do Azure, o fluxo de trabalho de Consumo e os parâmetros de gatilho de Recorrência configurados.

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

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

    Property 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

    A captura de tela mostra o portal do Azure, o fluxo de trabalho de Consumo e os parâmetros para a ação interna chamada variável Inicializar.

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

  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 mais à esquerda chamada Escolha 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 do meio, selecione o é igual a operador.

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

    A captura de tela mostra o fluxo de trabalho de consumo e a ação interna chamada Até com a condição de parada concluída.

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

  9. Na caixa de pesquisa Escolha uma operação, siga estas etapas gerais para adicionar a ação interna Variáveis chamada Variável de incremento à ação Até.

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

    Property valor
    Nome Selecione a variável Limit .
    Valor 1

    A captura de tela mostra o fluxo de trabalho de Consumo e a ação interna chamada Até com Nome definido como a variável Limite e Valor definido como 1.

  11. Fora e em Até ação, siga estas etapas gerais para adicionar uma ação que envia email.

    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:

    Property valor Description
    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 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 <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:

    A captura de tela mostra o fluxo de trabalho de consumo e a ação chamada Enviar um e-mail com valores de propriedade.

  13. Salve seu fluxo de trabalho.

Testar o fluxo de trabalho

Para testar manualmente o fluxo de trabalho do aplicativo lógico, siga as etapas com base no fato de você ter um aplicativo lógico Consumo ou Padrão.

Na barra de ferramentas do designer, selecione Executar execução de gatilho>.

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

A captura de tela mostra um exemplo de e-mail recebido do fluxo de trabalho de exemplo.

Evite loops intermináveis

A ação Até interrompe a execução com base nas seguintes propriedades, que você pode exibir selecionando Alterar limites na ação. Certifique-se de definir esses valores de propriedade de acordo:

Property Descrição
Contagem O número máximo de iterações executadas antes da saída do loop.

Para obter os limites padrão e máximo do número de ações Until que um fluxo de trabalho pode ter, consulte Limites de simultaneidade, looping e debatching.
Tempo limite A quantidade máxima de tempo que a ação Till , incluindo todas as iterações, é executada antes que o loop saia. 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 é iniciada porque a condição de limite de tempo limite é atendida.

Para obter os limites padrão e máximo no valor de tempo limite, consulte Simultaneidade, looping e limites de deslote.

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

Próximos passos