Exercício – Implantar um fluxo de trabalho básico dos Aplicativos Lógicos do Azure usando um modelo do ARM

  • 8 minutos

Nesta unidade, implantaremos um fluxo de trabalho de Aplicativos Lógicos do Azure usando um modelo do Azure Resource Manager.

Criando recursos no Azure

Geralmente, primeiro se cria um grupo de recursos para conter todos os itens que precisarão ser criados. Um grupo de recursos ajuda a administrar todas as VMs (máquinas virtuais), os discos, os adaptadores de rede e outros elementos que compõem a solução como uma unidade.

Podemos criar um grupo de recursos com o comando az group create da CLI do Azure. Esse comando usa um --name para fornecer um nome de grupo de recursos exclusivo na assinatura. O comando também usa um --location para fornecer a região padrão do Azure para os recursos.

Como estamos usando o ambiente gratuito da área restrita do Azure, você não precisa criar um grupo de recursos. Nesse caso, você pode usar o grupo de recursos já criado [nome do grupo de recursos de área restrita] neste exercício.

Baixar e examinar um modelo do Resource Manager básico

  1. Na parte superior da janela do Cloud Shell, selecione o ícone Mais (...) e selecione Configurações>Ir para a versão clássica.

  2. No Cloud Shell, execute o seguinte comando curl para baixar o modelo do GitHub:

    curl https://raw.githubusercontent.com/MicrosoftDocs/mslearn-logic-apps-and-arm-templates/master/basic-template/template.json > basic-template.json

  3. Para exibir o modelo, abra-o no editor interno:

    code basic-template.json

    A definição do fluxo de trabalho de aplicativo lógico descrita em template.json é mostrada na seguinte listagem:

    {
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {},
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Logic/workflows",
            "apiVersion": "2017-07-01",
            "name": "HelloLogicAppsTemplate",
            "location": "westus2",
            "properties": {
                "state": "Enabled",
                "definition": {
                    "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
                    "contentVersion": "1.0.0.0",
                    "parameters": {},
                    "triggers": {
                        "manual": {
                            "type": "Request",
                            "kind": "Http",
                            "inputs": {
                                "method": "GET",
                                "schema": {}
                            }
                        }
                    },
                    "actions": {
                        "Response": {
                            "runAfter": {},
                            "type": "Response",
                            "kind": "Http",
                            "inputs": {
                                "body": "Hello Logic Apps Template!",
                                "statusCode": 200
                            }
                        }
                    },
                    "outputs": {}
                },
                "parameters": {}
            }
        }
    ],
    "outputs": {
        "logicAppUrl": {
           "type": "string",
           "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
        }
     }
}

    Como você pode ver na definição JSON anterior, e como o nome do modelo sugere, este fluxo de trabalho de aplicativo lógico é básico. Vamos examinar os principais componentes deste aplicativo.

    No snippet a seguir, vemos que o aplicativo se chama HelloLogicAppsTemplate. Este nome está embutido em código no modelo. A localização no qual o aplicativo é executado também está embutida em código como westus2.

    "name": "HelloLogicAppsTemplate",
"location": "westus2",

    Rolando para baixo até a seção triggers, vemos que o fluxo de trabalho é disparado com uma solicitação HTTP GET. O gatilho é denominado manual.

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

    Mais adiante, na seção ações, aprendemos que este fluxo de trabalho contém uma etapa ou ação. Essa ação responde à solicitação com a mensagem Hello Azure Logic Apps Template!.

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

    A seção outputs do modelo do Resource Manager tem uma só saída chamada logicAppUrl. Essa variável de saída lista a URL do recurso de aplicativo lógico implantado. Essa URL facilita o teste do aplicativo. A saída usa listCallbackURL para criar a URL, mas o nome do fluxo de trabalho e o nome do gatilho são embutidos em código aqui.

    "outputs": {
    "logicAppUrl": {
       "type": "string",
       "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
    }
 }

    Agora vamos implantar esse aplicativo lógico e testá-lo.

Validar e implantar o modelo

Para implantar o recurso de aplicativo lógico, usaremos o comando az deployment group create, pois estamos implantando em um grupo de recursos. Ao implantar usando esse comando, é possível optar por implantar um modelo remoto especificando seu local com o parâmetro --template-uri. Em nosso caso, queremos implantar o modelo que temos localmente, portanto, definiremos o parâmetro --template-file.

  1. No Cloud Shell, execute az deployment group validate para validar o modelo:

    az deployment group validate \
--resource-group "<rgn>[sandbox resource group name]</rgn>" \
--template-file basic-template.json

    O argumento --template-file aponta para o modelo local. O nome do arquivo do modelo é basic-template.json.

    Você verá um grande bloco JSON como saída, o que lhe informa que o modelo passou na validação.

    O Azure Resource Manager preenche os parâmetros de modelo e verifica se o modelo seria executado com êxito em sua assinatura.

    Se a validação falhasse, você veria uma descrição detalhada da falha na saída.

  2. Execute o seguinte comando az deployment group create no Cloud Shell para implantar o recurso de aplicativo lógico definido pelo modelo básico no grupo de recursos de área restrita:

    az deployment group create \
--name MyDeployment \
--resource-group "<rgn>[sandbox resource group name]</rgn>" \
--template-file basic-template.json

    Esse comando se parece com o comando anterior, mas também inclui o argumento --name para fornecer um nome à implantação.

    Esse comando leva entre dois e três minutos para ser concluído. Quando a implantação for concluída, você verá como saída outro grande bloco JSON que descreve a implantação. Você verá provisioningState no resultado JSON com o valor Succeeded.

Verificar a implantação

  1. Execute az deployment group show para verificar a implantação:

    az deployment group show \
--name MyDeployment \
--resource-group "<rgn>[sandbox resource group name]</rgn>"

    Você verá o mesmo bloco JSON que já havia visto. Se você precisar desses detalhes sobre a implantação, poderá executar esse comando mais tarde. A saída é estruturada como JSON para facilitar o feed em outras ferramentas que você pode usar para acompanhar as suas implantações e o uso de nuvem.

  2. Para ver o aplicativo em ação, localize o valor logicAppUrl no resultado JSON. Selecione a URL e ou copie-a e cole-a em uma nova janela do navegador. A página exibirá a mensagem Olá, modelo dos Aplicativos Lógicos do Azure!, conforme mostra a seguinte captura de tela:

    Captura de tela com o navegador da Web exibindo a resposta do fluxo de trabalho de aplicativo lógico básico.

Parabéns! Você implantou com êxito um fluxo de trabalho de aplicativo lógico usando um modelo do Azure Resource Manager.

Conforme observamos neste exercício, o modelo básico tem muitos valores embutidos em código. Esses valores deixam o modelo menos flexível do que gostaríamos. Podemos aprimorar a situação usando parâmetros.