Executar ações com base no status do grupo usando escopos nos Aplicativos Lógicos do Azure

Aplica-se a: Aplicativos Lógicos do Azure (Consumo)

Para executar um grupo de ações apenas após outro grupo de ações ter sucesso ou falhar, pode encapsular as ações dependentes dentro de um escopo. Essa estrutura é útil quando você deseja organizar ações como um grupo lógico, avaliar o status desse grupo e executar ações baseadas no status do escopo. Depois que todas as ações em um escopo terminam de ser executadas, o escopo também recebe seu próprio status. Por exemplo, você pode usar escopos quando quiser implementar o tratamento de exceções e erros.

Para verificar o status de um escopo, você pode usar os mesmos critérios usados para determinar o status de execução de um aplicativo lógico, como Aprovado, Falhado, Cancelado e assim por diante. Por padrão, quando todas as ações do escopo são bem-sucedidas, o status do escopo é marcado como Bem-sucedido. Mas quando qualquer ação no escopo falha ou é cancelada, o status do escopo é marcado como Falha. Para limites de escopos, consulte Limites e configuração.

Por exemplo, aqui está um aplicativo lógico de alto nível que usa um escopo para executar ações específicas e uma condição para verificar o status do escopo. Se alguma ação no escopo falhar ou terminar inesperadamente, o escopo será marcado como Falha ou Anulado , respectivamente, e o aplicativo lógico enviará uma mensagem "Falha no escopo". Se todas as ações com escopo forem bem-sucedidas, a aplicação lógica enviará uma mensagem "Escopo bem-sucedido".

Prerequisites

• Uma conta Azure e uma assinatura. Se não tiver uma subscrição, inscreva-se numa conta gratuita do Azure.

• Uma conta de email de qualquer provedor de email suportado pelos Aplicativos Lógicos do Azure.

  Este exemplo usa Outlook.com. Se você usar um provedor diferente, o fluxo geral permanecerá o mesmo, mas sua interface do usuário parecerá diferente.

• Uma chave do Bing Maps. Para obter essa chave, consulte Obter uma chave do Bing Maps.

• Conhecimento básico sobre aplicativos lógicos

Criar aplicativo lógico de exemplo

Primeiro, crie este aplicativo lógico de exemplo para que você possa adicionar um escopo mais tarde:

• Um gatilho de Agendamento - Recorrência que verifica o serviço Bing Maps em um intervalo especificado
• Uma ação Bing Maps - Obter rota que verifica o tempo de viagem entre dois locais
• Uma ação de condição que verifica se o tempo de viagem excede o seu tempo de viagem especificado
• Uma ação que lhe envia um e-mail informando que o tempo de viagem atual excede o tempo especificado

Você pode salvar seu aplicativo lógico a qualquer momento, portanto, salve seu trabalho com frequência.

1. Entre no portal do Azure, se ainda não o fez. Criar uma aplicação lógica em branco.

2. Adicione o gatilho Schedule - Recurrence com estas configurações: Intervalo = "1" e Frequência = "Minuto"

   

   Tip

   Para simplificar visualmente sua exibição e ocultar os detalhes de cada ação no designer, recolha a forma de cada ação à medida que avança nessas etapas.

3. Adicione a ação Bing Maps - Obter rota .

   1. Se ainda não tiver uma ligação ao Bing Maps, ser-lhe-á pedido para criar uma ligação.

      Setting	Value	Description
      Nome da conexão	BingMapsConnection	Forneça um nome para sua conexão.
      Chave da API	< seu-Bing-Maps-chave>	Insira a chave do Bing Maps que você recebeu anteriormente.

   2. Configure sua ação Obter rota , conforme mostrado na tabela abaixo desta imagem:

      

      Para obter mais informações sobre esses parâmetros, consulte Calcular uma rota.

      Setting	Value	Description
      Ponto de passagem 1	< Início>	Insira a origem da sua rota.
      Ponto de passagem 2	< fim>	Insira o destino da sua rota.
      Avoid	None	Insira itens a serem evitados em sua rota, como rodovias, pedágios e assim por diante. Para valores possíveis, consulte Calcular uma rota.
      Optimize	timeWithTraffic	Selecione um parâmetro para otimizar sua rota, como distância, tempo com informações de trânsito atuais e assim por diante. Este exemplo usa este valor: "timeWithTraffic"
      Unidade de distância	< a sua preferência>	Introduza a unidade de distância para calcular o seu percurso. Este exemplo usa este valor: "Mile"
      Modo de viagem	Driving	Insira o modo de viagem para a sua rota. Este exemplo usa este valor "Condução"
      Data-Hora de Trânsito	None	Aplica-se apenas ao modo de trânsito.
      Date-Type Tipo de trânsito	None	Aplica-se apenas ao modo de trânsito.

4. Adicione uma condição que verifique se o tempo de viagem atual com tráfego excede um tempo especificado. Para este exemplo, siga estes passos:

   1. Renomeie a condição com esta descrição: Se o tempo de tráfego for maior do que o tempo especificado

   2. Na coluna mais à esquerda, selecione dentro da caixa Escolher um valor para que a lista de conteúdo dinâmico apareça. Nessa lista, selecione o campo Tráfego de Duração da Viagem , que é em segundos.

      

   3. Na caixa do meio, selecione este operador: é maior que

   4. Na coluna mais à direita, insira este valor de comparação, que é em segundos e equivalente a 10 minutos: 600

      Quando terminar, a sua condição será semelhante a este exemplo:

      

5. Na ramificação True , adicione uma ação "enviar e-mail" para seu provedor de e-mail. Configure esta ação seguindo as etapas abaixo desta imagem:

   

   1. No campo Para , insira seu endereço de e-mail para fins de teste.

   2. No campo Assunto , insira este texto:

      Time to leave: Traffic more than 10 minutes

   3. No campo Corpo , insira este texto com um espaço à direita:

      Travel time:

      Enquanto o cursor aparece no campo Corpo , a lista de conteúdo dinâmico permanece aberta para que você possa selecionar quaisquer parâmetros disponíveis neste momento.

   4. Na lista de conteúdo dinâmico, selecione Expressão.

   5. Localize e selecione a função div( ). Coloque o cursor entre parênteses da função.

   6. Enquanto o cursor estiver entre parênteses da função, selecione Conteúdo dinâmico para que a lista de conteúdo dinâmico apareça.

   7. Na seção Obter rota, selecione o campo Duração do Tráfego.

      

   8. Depois que o campo for resolvido para o formato JSON, adicione vírgula (,) seguida do número 60 para converter o valor em Duração do Tráfego de segundos para minutos.

      div(body('Get_route')?['travelDurationTraffic'],60)
      

      Sua expressão agora se parece com este exemplo:

      

   9. Quando tiver terminado, selecione OK.

   1. Depois que a expressão for resolvida, adicione este texto com um espaço em branco antes: minutes

      Seu campo Corpo agora se parece com este exemplo:

      

6. Salve o seu Logic App.

Em seguida, adicione um escopo para que você possa agrupar ações específicas e avaliar seu status.

Adicionar um âmbito

1. Se ainda não o fez, abra seu aplicativo lógico no designer de fluxo de trabalho.

2. Adicione um escopo no local do fluxo de trabalho desejado. Por exemplo, para adicionar um escopo entre as etapas existentes no fluxo de trabalho do aplicativo lógico, siga estas etapas:

   1. Mova o ponteiro sobre a seta onde pretende adicionar o âmbito. Selecione o sinal de adição (+) >Adicionar uma ação.

      

   2. Na caixa de pesquisa, digite "escopo" como filtro. Selecione a ação Escopo .

Adicionar etapas ao escopo

1. Agora, adicione as etapas ou arraste as etapas existentes que você deseja executar dentro do escopo. Neste exemplo, arraste estas ações para o escopo:

   • Obter rota
   • Se o tempo de tráfego for maior do que o tempo especificado, o que inclui as ramificações true e false

   Seu aplicativo lógico agora se parece com este exemplo:

   

2. No escopo, adicione uma condição que verifique o status do escopo. Renomeie a condição com esta descrição: Se o escopo falhou

   

3. Na condição, adicione essas expressões que verificam se o status do escopo é igual a "Falha" ou "Abortado".

   1. Para adicionar outra linha, selecione Adicionar.

   2. Em cada linha, selecione dentro da caixa à esquerda para que a lista de conteúdo dinâmico apareça. Na lista de conteúdo dinâmico, selecione Expressão. Na caixa de edição, introduza esta expressão e, em seguida, selecione OK:

      actions('Scope')?['status']

      

   3. Para ambas as linhas, selecionar é igual a como o operador.

   4. Para os valores de comparação, na primeira linha, insira Failed. Na segunda linha, digite Aborted.

      Quando terminar, a sua condição será semelhante a este exemplo:

      

      Agora, defina a propriedade da runAfter condição para que a condição verifique o status do escopo e execute a ação de correspondência que você definir em etapas posteriores.

   5. Na condição Se o escopo falhou selecione o botão de reticências (...) e, em seguida, selecione Configurar execução subsequente.

      

   6. Selecione todos estes estados de escopo: foi bem-sucedido, falhou, foi ignorado e ultrapassou o tempo limite

      

   7. Quando tiver terminado, selecione Concluído. A condição agora mostra um ícone de informação.

4. Nas ramificações True e False , adicione as ações que você deseja executar com base em cada status de escopo, por exemplo, envie um email ou mensagem.

   

5. Salve o seu Logic App.

Seu aplicativo lógico concluído agora se parece com este exemplo:

Testar o fluxo de trabalho

Na barra de ferramentas do designer, selecione Executar>Executar. Se todas as ações com escopo forem bem-sucedidas, você receberá uma mensagem Escopo bem-sucedido . Se alguma ação com escopo não for bem-sucedida, você receberá uma mensagem de falha no escopo .

Definição JSON

Se você estiver trabalhando na visualização de código, poderá definir um escopo na definição JSON do seu fluxo de trabalho. O exemplo a seguir mostra a definição de um escopo básico:

{
   "actions": {
      "Scope": {
         "type": "Scope",
         "actions": {
            "Http": {
               "inputs": {
                   "method": "GET",
                   "uri": "https://www.bing.com"
               },
               "runAfter": {},
               "type": "Http"
            }
         }
      }
   }
}

The following example shows the JSON definition for the trigger and actions in the preceding workflow:

``` json
"triggers": {
  "Recurrence": {
    "type": "Recurrence",
    "recurrence": {
       "frequency": "Minute",
       "interval": 1
    }
  }
},
"actions": {
  "If_scope_failed": {
    "type": "If",
    "actions": {
      "Scope_failed": {
        "type": "ApiConnection",
        "inputs": {
          "body": {
            "Body": "Scope failed. Scope status: @{action('Scope')}",
            "Subject": "Scope failed",
            "To": "<your-email@domain.com>"
          },
          "host": {
            "connection": {
              "name": "@parameters('$connections')['outlook']['connectionId']"
            }
          },
          "method": "post",
          "path": "/Mail"
        },
        "runAfter": {}
      }
    },
    "else": {
      "actions": {
        "Scope_succeeded": {
          "type": "ApiConnection",
          "inputs": {
            "body": {
              "Body": "Scope succeeded. Scope status: @{action('Scope')}",
              "Subject": "Scope succeeded",
              "To": "<your-email@domain.com>"
            },
            "host": {
              "connection": {
               "name": "@parameters('$connections')['outlook']['connectionId']"
              }
            },
            "method": "post",
            "path": "/Mail"
          },
          "runAfter": {}
        }
      }
    },
    "expression": {
      "or": [ 
         {
            "equals": [ 
              "@action('Scope')",
              "Failed"
            ]
         },
         {
            "equals": [
               "@action('Scope')",
               "Aborted"
            ]
         } 
      ]
    },
    "runAfter": {
      "Scope": [
        "Failed",
        "Skipped",
        "Succeeded",
        "TimedOut"
      ]
    }
  },
  "Scope": {
    "type": "Scope",
    "actions": {
      "Get_route": {
        "type": "ApiConnection",
        "inputs": {
          "host": {
            "connection": {
              "name": "@parameters('$connections')['bingmaps']['connectionId']"
            }
          },
          "method": "get",
          "path": "/REST/V1/Routes/Driving",
          "queries": {
            "distanceUnit": "Mile",
            "optimize": "timeWithTraffic",
            "travelMode": "Driving",
            "wp.0": "<start>",
            "wp.1": "<end>"
          }
        },
        "runAfter": {}
      },
      "If_traffic_time_is_more_than_specified_time": {
        "type": "If",
        "actions": {
          "Send_mail_when_traffic_exceeds_10_minutes": {
            "type": "ApiConnection",
            "inputs": {
              "body": {
                 "Body": "Travel time:@{div(body('Get_route')?['travelDurationTraffic'],60)} minutes",
                 "Subject": "Time to leave: Traffic more than 10 minutes",
                 "To": "<your-email@domain.com>"
              },
              "host": {
                "connection": {
                   "name": "@parameters('$connections')['outlook']['connectionId']"
                }
              },
              "method": "post",
              "path": "/Mail"
            },
            "runAfter": {}
          }
        },
        "expression": {
          "and" : [
            {
               "greater": [ 
                  "@body('Get_route')?['travelDurationTraffic']", 
                  600
               ]
            }
          ]
        },
        "runAfter": {
          "Get_route": [
            "Succeeded"
          ]
        }
      }
    },
    "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 e repetir etapas (ciclos)
• Executar ou mesclar etapas paralelas (ramificações)