Descrever um fluxo de trabalho de Aplicativos Lógicos do Azure usando a Linguagem de Definição de Fluxo de Trabalho

  • 12 minutos

Você define a estrutura e o fluxo de trabalho de um fluxo de trabalho do Aplicativo Lógico do Azure usando um documento JSON. Este documento contém uma descrição JSON dos elementos que compõem o fluxo de trabalho do aplicativo lógico e o esquema da Linguagem de Definição de Fluxo de Trabalho o valida. A maneira mais fácil de explicar o esquema é examinar um fluxo de trabalho existente criado usando o designer de fluxo de trabalho no portal do Azure e, em seguida, exibir a descrição JSON do aplicativo lógico.

No cenário de exemplo, você deseja fornecer aos consultores fluxos de trabalho comuns que eles possam adaptar às necessidades específicas das universidades com as quais trabalham. Quer que seja o mais fácil possível personalizar e implementar cada fluxo de trabalho, portanto, decide ver o código associado ao fluxo de trabalho, ou seja, a definição do fluxo de trabalho do JSON.

Estruturador de fluxos de trabalho

O designer de fluxo de trabalho permite criar e depurar graficamente o fluxo de trabalho para um fluxo de trabalho de aplicativo lógico. O designer também permite que os desenvolvedores olhem sob o capô de um fluxo de trabalho para ver como ele é implementado. A imagem a seguir mostra um exemplo de um fluxo de trabalho simples, que é acionado pelo envio de uma solicitação HTTP GET para uma URL especificada. O resultado é devolvido na resposta HTTP. Neste exemplo, o fluxo de trabalho está enviando de volta uma mensagem simples Hello Logic Apps Template! .

Diagrama mostrando a visão geral do designer de fluxo de trabalho.

Agora, vamos examinar a linguagem de definição de fluxo de trabalho usada pelo modelo JSON.

Vista de código

A janela Visualização de código mostra o documento JSON que descreve o fluxo de trabalho. No aplicativo de exemplo, o JSON tem esta aparência:

{
    "definition": {
        "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
        "actions": {
            "Response": {
                "inputs": {
                    "body": "Hello Azure Logic Apps Template!",
                    "statusCode": 200
                },
                "kind": "Http",
                "runAfter": {},
                "type": "Response"
            }
        },
        "contentVersion": "1.0.0.0",
        "outputs": {},
        "parameters": {},
        "triggers": {
            "manual": {
                "inputs": {
                    "method": "GET",
                    "schema": {}
                },
                "kind": "Http",
                "type": "Request"
            }
        }
    }
}

Observe as definition seções no escopo que se relacionam com as ações e gatilhos mostrados no designer. Você pode editar o código JSON neste documento para refletir quaisquer alterações necessárias na funcionalidade do fluxo de trabalho do aplicativo lógico. Você também pode adicionar outras ações e especificar como a lógica no fluxo de trabalho é executada de uma ação para outra.

Secção Triggers (Acionadores)

A triggers seção contém a descrição do tipo de gatilho e como ele pode ser invocado. Neste exemplo, o acionador é um acionador HTTP simples que é executado em resposta a um pedido HTTP GET.

"triggers": {
    "manual": {
        "inputs": {
            "method": "GET",
            "schema": {}
        },
        "kind": "Http",
        "type": "Request"
    }
}

Um acionador tem de incluir os seguintes elementos:

  • Um nome exclusivo dentro do fluxo de trabalho. No exemplo anterior, o nome padrão do gatilho é manual, mas você pode substituir o nome padrão por um identificador mais significativo.

  • O tipo de acionador. O tipo indica o evento que faz com que o acionador seja executado. Um Request gatilho é executado em resposta a uma solicitação HTTP. Outros tipos de acionadores disponíveis incluem:

    • Recurrence para criar um gatilho que é executado de acordo com uma agenda recorrente.

    • HttpWebhook para ouvir eventos em um ponto de extremidade.

    • ApiConnection para responder a eventos acionados por outros serviços do Azure, como uma mensagem que chega em uma fila de mensagens, uma mensagem de email e assim por diante. O tipo de gatilho ApiConnection é generalizado e você especifica mais detalhes indicando o tipo do serviço e quaisquer informações de conexão necessárias.

  • A inputs secção. Esta seção especifica os dados que definem o comportamento do gatilho. Para um gatilho de solicitação, o indica o method tipo de solicitação HTTP que faz com que o gatilho seja executado. Para um ApiConnection gatilho, a inputs seção contém informações sobre como se conectar ao recurso que aciona o evento (uma cadeia de conexão da fila de mensagens, por exemplo). Se o gatilho for um Request gatilho, a seção da schema definição de entrada especifica o esquema ao qual a carga útil do corpo da solicitação deve estar em conformidade. As solicitações HTTP GET não têm um corpo de solicitação, portanto, o schema está vazio no exemplo anterior.

O exemplo a seguir mostra a definição de outro Request gatilho que inicia um fluxo de trabalho e recebe solicitações HTTP POST. Uma solicitação POST normalmente fornece um corpo de solicitação contendo os dados a serem postados. O corpo do pedido neste exemplo contém um nome do cliente e o endereço, que é composto pela rua e cidade.

"mypostrequest": {
   "type": "Request",
   "kind": "Http",
   "inputs": {
      "method": "POST",
      "schema": {
         "type": "object",
         "properties": {
            "customerName": {
               "type": "String"
            },
            "customerAddress": { 
               "type": "Object",
               "properties": {
                  "streetAddress": {
                     "type": "string"
                  },
                  "city": {
                     "type": "string"
                  }
               }
            }
         }
      }
   }
}

Um acionador também pode especificar condições. O acionador será acionado apenas se estas condições forem cumpridas. O utilizador define as condições numa secção opcional, conditions. Por exemplo, talvez você queira executar o gatilho mypostrequest (mostrado no exemplo anterior), somente se o corpo da solicitação especificar uma cidade de New York:

"mypostrequest": {
   "type": "Request",
   "kind": "Http",
   "inputs": {
      ...
   }
   "conditions": [
      {
        "expression": "@equals(triggerOutputs()['body']['customerAddress']['city'], 'New York')"
      }
   ]
}

Secção Actions (Ações)

A seção de actions um aplicativo lógico define a lógica e a estrutura do fluxo de trabalho. A secção contém uma série de ações. Uma ação é um bloco de construção básico para a construção de fluxos de trabalho. As ações recebem entradas e produzem saídas, que são passadas para a próxima ação no fluxo de trabalho. A tabela a seguir lista diferentes tipos de ação disponíveis:

Ação Descrição
ApiConnection Envia uma solicitação HTTP para um serviço específico. Esse tipo de ação permite integrar um fluxo de trabalho de aplicativo lógico com recursos do Azure, como o Barramento de Serviço do Azure, a Grade de Eventos do Azure e outros. A ação necessita de entradas que incluem uma cadeia de ligação para aceder ao serviço, bem como quaisquer informações adicionais e parâmetros necessários para invocar o serviço.
Compose Combina várias entradas e expressões num único resultado.
Function Permite-lhe chamar uma Função do Azure.
HTTP Envia uma solicitação HTTP para um ponto de extremidade HTTP em vez de um serviço do Azure.
Join Usa uma matriz de itens de dados como entrada e gera cadeia de caracteres contendo esses itens separados por um delimitador especificado.
Parse Analisa um documento JSON em um conjunto de tokens usando um esquema especificado.
Query Filtra os itens em uma matriz de entrada usando uma condição especificada.
Response Cria uma resposta para um pedido HTTP.
Table Gera uma tabela HTML de uma matriz de objetos JSON.
Terminate Cancela um fluxo de trabalho imediatamente.
Wait Pausa o fluxo de trabalho por um intervalo especificado ou até que ocorra um tempo limite.
Workflow Executa outro fluxo de trabalho de aplicativo lógico.
Condition Um conjunto de tipos de ação (Foreach, If, Switch, e Until) que permite implementar o fluxo programático de controle em um fluxo de trabalho. Pode iterar itens numa coleção, tomar decisões com base nos valores dos parâmetros de entrada e efetuar ciclos até que uma condição seja cumprida.
InitializeVariable,
IncrementVariable,
DecrementVariable,
e ainda SetVariable		 Define, inicializa, atribui e modifica variáveis que pode transmitir entre itens de ação num fluxo de trabalho.

Tal como um acionador, cada ação tem de ter um nome exclusivo no fluxo de trabalho. No exemplo a seguir, o nome da ação padrão é Response, mas você pode usar um identificador válido e mais significativo. Uma ação deve ter uma inputs seção que especifique os dados nos quais a ação funciona. Na ação Resposta, você pode especificar os dados para uma expressão a ser retornada na mensagem de resposta, juntamente com um código de status HTTP.

Em nossa definição básica de fluxo de trabalho, a ação gera uma resposta HTTP onde o corpo é uma mensagem curta.

"actions": {
    "Response": {
        "inputs": {
            "body": "Hello Azure Logic Apps Template!",
            "statusCode": 200
        },
        "kind": "Http",
        "runAfter": {},
        "type": "Response"
    }
}

A runAfter seção indica onde a ação é executada na sequência do fluxo de trabalho. No exemplo anterior, existe apenas uma ação, pelo que é sempre executada quando o acionador é acionado. Se o fluxo de trabalho tiver várias ações, você poderá especificar o nome de uma ação e um status para essa ação nesta seção. A ação é executada se for runAfter concluída com o status especificado. O código seguinte mostra um exemplo. A ação mySecondAction é executada após myFirstAction, mas somente se myFirstAction terminar com um status de Succeeded:

"actions": {
    "mySecondAction": {
        "inputs": {
            ...
        },
        "runAfter": {
            "myFirstAction": [
                "Succeeded"
            ]
        },
        "type": ...
    },
    "myFirstAction": {
        "inputs": {
            ...
        },
        "runAfter": {},
        "type": ...
    }
}

Secção Outputs (Resultados)

Use a outputs seção para definir os dados que seu fluxo de trabalho pode retornar quando a execução for concluída. Poderia monitorizar um estado ou dados específicos para cada execução do fluxo de trabalho. Você pode examinar a saída de cada execução de um fluxo de trabalho usando o histórico de execução dos Aplicativos Lógicos do Azure, que está disponível no portal do Azure ou na API REST do Fluxo de Trabalho.

O formato da seção tem esta outputs aparência:

"outputs": {
  "<key-name>": {
    "type": "<key-type>",
    "value": "<key-value>"
  }
}

Expressões de fluxo de trabalho

Você pode usar uma expressão de fluxo de trabalho no lugar de qualquer valor fixo, variável ou constante. Você também pode colocar uma expressão em qualquer lugar em um valor de cadeia de caracteres JSON prefixando a expressão com o sinal at (@). Por exemplo, pode utilizar a função @parameters numa expressão para obter o valor de um parâmetro com nome (os parâmetros são descritos na secção seguinte).

"customerFullName": "Bill Frost",
"accountName": "@parameters('customerName')"

Os Aplicativos Lógicos do Azure fornecem funções internas que você pode usar para criar expressões complexas:

  • Funções de cadeia de caracteres: Para concatenar ou dividir cadeias de caracteres, converter caracteres entre maiúsculas e minúsculas e procurar substrings.
  • Funções de coleção: para detetar se uma coleção contém itens que correspondem a um padrão específico, recuperar itens de uma coleção e combinar coleções.
  • Funções de comparação lógica: Para detetar se os operandos são iguais, diferentes, numericamente maiores ou numericamente menores do que os outros.
  • Funções de conversão: Para alterar o tipo ou formato de dados.
  • Funções matemáticas: tais como add, sub, div, e mul, além de várias outras.
  • Funções de data e hora: Para analisar e processar datas e horas.
  • Funções de fluxo de trabalho: para recuperar informações sobre os dados passados para uma ação de fluxo de trabalho. Por exemplo, a parameter função (mostrada anteriormente) busca o valor de um parâmetro nomeado e a body função (mostrada anteriormente) retorna os dados que estão sendo gerados por uma ação.
  • Funções de manipulação JSON e XML: Para analisar e processar documentos JSON e XML.

Você pode definir variáveis na inputs seção de uma InitializeVariable ação e pode manipular essas variáveis usando expressões. Leia o valor de uma variável usando a variables função. O exemplo a seguir usa uma InitializeVariable ação para criar uma variável inteira chamada myIntegerVariable e inicializá-la em 99. Este exemplo também mostra uma Condition ação com o If tipo. A condição usa uma expressão para testar o valor da myIntegerVariable variável e, se corresponder ao valor 100, a condição usa uma ação HTTP para executar uma solicitação GET.

"actions": {
    "Condition": {
        "actions": {
            "HTTP": {
                "inputs": {
                    "method": "GET",
                    "uri": "http://dummyurl.com"
                },
                "runAfter": {},
                "type": "Http"
            }
        },
        "expression": {
            "equals": [
                "@variables('myIntegerVariable')",
                100
            ]
        }        ,
        "runAfter": {
            "Initialize": [
                "Succeeded"
            ]
        },
        "type": "If"
    },
    "Initialize": {
        "inputs": {
            "variables": [
                {
                    "name": "myIntegerVariable",
                    "type": "Integer",
                    "value": 99
                }
            ]
        },
        "runAfter": {},
        "type": "InitializeVariable"
    }
}

Secção Parâmetros

A parameters seção permite parametrizar um fluxo de trabalho. No runtime, pode fornecer valores para cada um destes parâmetros. Você pode fazer referência aos parâmetros em qualquer lugar do fluxo de trabalho onde possa usar uma constante ou expressão.

Pode adicionar uma definição de parâmetros com um valor predefinido. Se não fornecer um valor para o parâmetro no runtime, é utilizado o valor predefinido. O exemplo a seguir mostra como definir um parâmetro chamado cityParam. O parâmetro é usado dentro da condição para a mypostrequest ação. Executa a ação apenas se o documento do pedido contiver uma cidade que corresponda ao valor do parâmetro. O valor do parâmetro padrão é New York:


    "definition": {
        "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
        "actions": {
            ...
        },
        "contentVersion": "1.0.0.0",
        "outputs": {},
        "parameters": {
            "cityParam": {
                "defaultValue": "New York",
                "type": "String"
            }
        },
        "triggers": {
            "mypostrequest": {
                "conditions": [
                    {
                        "expression": "@equals(triggerOutputs()['body']['customerAddress']['city'], parameters('cityParam'))"
                    }
                ],
                "inputs": {
                    ...
                },
                "kind": "Http",
                "type": "Request"
            }
        }
    }
}

Verifique o seu conhecimento

1.

Você deseja que seu fluxo de trabalho dos Aplicativos Lógicos do Azure seja executado a cada três minutos. Em qual das seguintes secções da definição de fluxo de trabalho definiria este comportamento recorrente?

2.

Em que secção de uma definição de fluxo de trabalho pode enviar uma resposta a um pedido HTTP que devolva o corpo de uma mensagem, um código de estado e cabeçalhos de mensagens?

3.

Em que secção da definição de fluxo de trabalho se especifica um valor a devolver quando um fluxo de trabalho for concluído?