Descrição geral: Automatizar a implementação do Azure Logic Apps com modelos do Azure Resource Manager

  • Artigo

Aplica-se a: Azure Logic Apps (Consumo)

Quando estiver pronto para automatizar a criação e implementação da sua aplicação lógica, pode expandir a definição de fluxo de trabalho subjacente da sua aplicação lógica para um modelo de Resource Manager do Azure. Este modelo define a infraestrutura, os recursos, os parâmetros e outras informações para aprovisionar e implementar a sua aplicação lógica. Ao definir parâmetros para valores que variam na implementação, também conhecido como parametrização, pode implementar repetida e consistentemente aplicações lógicas com base em diferentes necessidades de implementação.

Por exemplo, se implementar em ambientes para desenvolvimento, teste e produção, provavelmente utilizará cadeias de ligação diferentes para cada ambiente. Pode declarar parâmetros de modelo que aceitam cadeias de ligação diferentes e, em seguida, armazenar essas cadeias num ficheiro de parâmetros separado. Dessa forma, pode alterar esses valores sem ter de atualizar e reimplementar o modelo. Para cenários em que tem valores de parâmetros confidenciais ou têm de ser protegidos, como palavras-passe e segredos, pode armazenar esses valores no Azure Key Vault e fazer com que o ficheiro de parâmetros obtenha esses valores. No entanto, nestes cenários, reimplementaria para obter os valores atuais.

Esta descrição geral descreve os atributos num modelo de Resource Manager que inclui uma definição de fluxo de trabalho de aplicação lógica. Tanto o modelo como a definição do fluxo de trabalho utilizam sintaxe JSON, mas existem algumas diferenças porque a definição do fluxo de trabalho também segue o esquema de Linguagem de Definição de Fluxo de Trabalho. Por exemplo, as expressões de modelo e as expressões de definição de fluxo de trabalho diferem na forma como referenciam os parâmetros e os valores que podem aceitar.

Dica

Para obter uma forma mais fácil de obter um modelo de aplicação lógica parametrizada válido que esteja maioritariamente pronto para implementação, utilize o Visual Studio (edição gratuita da Comunidade ou superior) e as Ferramentas do Azure Logic Apps para Visual Studio. Em seguida, pode criar a sua aplicação lógica no Visual Studio ou localizar e transferir uma aplicação lógica existente do Azure para o Visual Studio.

Em alternativa, pode criar modelos de aplicações lógicas com Azure PowerShell com o módulo LogicAppTemplate.

A aplicação lógica de exemplo neste tópico utiliza um Office 365 acionador do Outlook que é acionado quando é recebido um novo e-mail e uma ação de Armazenamento de Blobs do Azure que cria um blob para o corpo do e-mail e carrega esse blob para um contentor de armazenamento do Azure. Os exemplos também mostram como parametrizar valores que variam na implementação.

Para obter mais informações sobre Resource Manager modelos, veja estes tópicos:

Para obter informações de recursos de modelo específicas de aplicações lógicas, contas de integração, artefactos de conta de integração e ambientes de serviço de integração, veja Tipos de recursos Microsoft.Logic.

Para modelos de aplicações lógicas de exemplo, veja estes exemplos:

Para a API REST do Logic Apps, comece com a Descrição geral da API REST do Azure Logic Apps.

Estrutura do modelo

No nível superior, um modelo de Resource Manager segue esta estrutura, que está totalmente descrita no tópico de sintaxe e estrutura de modelos do Azure Resource Manager:

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   "parameters": {},
   "variables": {},
   "functions": [],
   "resources": [],
   "outputs": {}
}

Para um modelo de aplicação lógica, trabalha principalmente com estes objetos de modelo:

Atributo Descrição
parameters Declara os parâmetros do modelo para aceitar os valores a utilizar ao criar e personalizar recursos para implementação no Azure. Por exemplo, estes parâmetros aceitam os valores para o nome e localização da sua aplicação lógica, ligações e outros recursos necessários para a implementação. Pode armazenar estes valores de parâmetros num ficheiro de parâmetros, que é descrito mais adiante neste tópico. Para obter detalhes gerais, veja Parameters - Resource Manager template structure and syntax (Parâmetros – Resource Manager estrutura e sintaxe do modelo).
resources Define os recursos para criar ou atualizar e implementar num grupo de recursos do Azure, como a sua aplicação lógica, ligações, contas de armazenamento do Azure, etc. Para obter detalhes gerais, veja Resources - Resource Manager template structure and syntax (Recursos – Resource Manager estrutura e sintaxe do modelo).

O seu modelo de aplicação lógica utiliza este formato de nome de ficheiro:

<logic-app-name>. json

Importante

A sintaxe do modelo é sensível às maiúsculas e minúsculas, por isso, certifique-se de que utiliza maiúsculas e minúsculas consistentes.

Parâmetros do modelo

Um modelo de aplicação lógica tem vários parameters objetos que existem em diferentes níveis e executam funções diferentes. Por exemplo, no nível superior, pode declarar parâmetros de modelo para os valores aceitarem e utilizarem na implementação ao criar e implementar recursos no Azure, por exemplo:

  • A sua aplicação lógica

  • Ligações que a sua aplicação lógica utiliza para aceder a outros serviços e sistemas através de conectores geridos

  • Outros recursos de que a sua aplicação lógica precisa para implementação

    Por exemplo, se a sua aplicação lógica utilizar uma conta de integração para cenários de empresa-empresa (B2B), o objeto de nível parameters superior do modelo declara o parâmetro que aceita o ID de recurso dessa conta de integração.

Eis a estrutura geral e a sintaxe de uma definição de parâmetro, que é totalmente descrita por Parameters - Resource Manager estrutura e sintaxe do modelo:

"<parameter-name>": {
   "type": "<parameter-type>",
   "defaultValue": <default-parameter-value>,
   <other-parameter-attributes>,
   "metadata": {
      "description": "<parameter-description>"
   }
},

Este exemplo mostra apenas os parâmetros de modelo para os valores utilizados para criar e implementar estes recursos no Azure:

  • Nome e localização da sua aplicação lógica
  • ID a utilizar para uma conta de integração associada à aplicação lógica
{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   // Template parameters
   "parameters": {
      "LogicAppName": {
         "type": "string",
         "minLength": 1,
         "maxLength": 80,
         "defaultValue": "MyLogicApp",
         "metadata": {
            "description": "The resource name for the logic app"
         }
      },
      "LogicAppLocation": {
         "type": "string",
         "minLength": 1,
         "defaultValue": "[resourceGroup().location]",
         "metadata": {
            "description": "The resource location for the logic app"
         }
      },
      "LogicAppIntegrationAccount": {
         "type":"string",
         "minLength": 1,
         "defaultValue": "/subscriptions/<Azure-subscription-ID>/resourceGroups/fabrikam-integration-account-rg/providers/Microsoft.Logic/integrationAccounts/fabrikam-integration-account",
         "metadata": {
            "description": "The ID to use for the integration account"
         }
      }
   },
   "variables": {},
   "functions": [],
   "resources": [],
   "outputs": {}
}

Exceto para parâmetros que processam valores confidenciais ou que têm de ser protegidos, como nomes de utilizador, palavras-passe e segredos, todos estes parâmetros incluem defaultValue atributos, embora, em alguns casos, os valores predefinidos sejam valores vazios. Os valores de implementação a utilizar para estes parâmetros de modelo são fornecidos pelo ficheiro de parâmetros de exemplo descrito mais adiante neste tópico.

Para obter mais informações sobre como proteger parâmetros de modelo, veja estes tópicos:

Outros objetos de modelo referenciam frequentemente parâmetros de modelo para que possam utilizar os valores que passam pelos parâmetros do modelo, por exemplo:

  • O objeto de recursos do modelo, descrito mais adiante neste tópico, define cada recurso no Azure que pretende criar e implementar, como a definição de recursos da sua aplicação lógica. Estes recursos utilizam frequentemente valores de parâmetros de modelo, como o nome e as informações de localização e ligação da sua aplicação lógica.

  • A um nível mais profundo na definição de recursos da sua aplicação lógica, o objeto de parâmetros da definição de fluxo de trabalho declara parâmetros para os valores a utilizar no runtime da sua aplicação lógica. Por exemplo, pode declarar parâmetros de definição de fluxo de trabalho para o nome de utilizador e palavra-passe que um acionador HTTP utiliza para autenticação. Para especificar os valores dos parâmetros de definição do fluxo de trabalho, utilize o parameters objeto que está fora da definição do fluxo de trabalho, mas ainda dentro da definição de recursos da aplicação lógica. Neste objeto externo parameters , pode referenciar parâmetros de modelo declarados anteriormente, que podem aceitar valores na implementação a partir de um ficheiro de parâmetros.

Ao referenciar parâmetros, as expressões e funções de modelo utilizam sintaxe diferente e comportam-se de forma diferente das expressões e funções de definição de fluxo de trabalho. Para obter mais informações sobre estas diferenças, veja Referências a parâmetros mais adiante neste tópico.

Melhores práticas - parâmetros de modelo

Seguem-se algumas das melhores práticas para definir parâmetros:

  • Declare parâmetros apenas para valores que variem, com base nas suas necessidades de implementação. Não declare parâmetros para valores que permanecem iguais em diferentes requisitos de implementação.

  • Inclua o defaultValue atributo, que pode especificar valores vazios, para todos os parâmetros, exceto para valores confidenciais ou que têm de ser protegidos. Utilize sempre parâmetros protegidos para nomes de utilizador, palavras-passe e segredos. Para ocultar ou proteger valores de parâmetros confidenciais, siga a documentação de orientação nestes tópicos:

  • Para diferenciar nomes de parâmetros de modelo dos nomes de parâmetros de definição de fluxo de trabalho, pode utilizar nomes de parâmetros de modelo descritivos, por exemplo: TemplateFabrikamPassword

Para obter mais práticas recomendadas para modelos, veja Melhores práticas para parâmetros de modelo.

Ficheiro de parâmetros de modelo

Para fornecer os valores para parâmetros de modelo, armazene esses valores num ficheiro de parâmetros. Dessa forma, pode utilizar ficheiros de parâmetros diferentes com base nas suas necessidades de implementação. Eis o formato de nome de ficheiro a utilizar:

  • Nome de ficheiro do modelo de aplicação lógica:<logic-app-name.json>
  • Nome do ficheiro de parâmetros: <logic-app-name.parameters.json>

Eis a estrutura dentro do ficheiro de parâmetros, que inclui uma referência do cofre de chaves para transmitir um valor de parâmetro seguro com o Azure Key Vault:

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
   "contentVersion": "1.0.0.0",
   // Template parameter values
   "parameters": {
      "<parameter-name-1>": {
         "value": "<parameter-value>"
      },
      "<parameter-name-2>": {
         "value": "<parameter-value>"
      },
      "<secured-parameter-name>": {
         "reference": {
            "keyVault": {
               "id": "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group-name>/Microsoft.KeyVault/vaults/<key-vault-name>"
            },
            "secretName: "<secret-name>"
         }
      },
      <other-parameter-values>
   }
}

Este ficheiro de parâmetros de exemplo especifica os valores para os parâmetros de modelo declarados anteriormente neste tópico:

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
   "contentVersion": "1.0.0.0",
   // Template parameter values
   "parameters": {
      "LogicAppName": {
         "value": "Email-Processor-Logic-App"
      },
      "LogicAppLocation": {
         "value": "westeurope"
      }
   }
}

Recursos do modelo

O seu modelo tem um resources objeto, que é uma matriz que contém definições para cada recurso criar e implementar no Azure, como a definição de recursos da sua aplicação lógica, definições de recursos de ligação e quaisquer outros recursos de que a sua aplicação lógica precise para implementação.

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   "parameters": {<template-parameters>},
   "variables": {},
   "functions": [],
   "resources": [
      {
         <logic-app-resource-definition>
      },
      // Start connection resource definitions
      {
         <connection-resource-definition-1>
      },
      {
         <connection-resource-definition-2>
      }
   ],
   "outputs": {}
}

Nota

Os modelos podem incluir definições de recursos para várias aplicações lógicas, por isso certifique-se de que todos os recursos da aplicação lógica especificam o mesmo grupo de recursos do Azure. Quando implementa o modelo num grupo de recursos do Azure com o Visual Studio, é-lhe pedido que abrisse a aplicação lógica que pretende abrir. Além disso, o projeto do grupo de recursos do Azure pode conter mais do que um modelo, por isso, certifique-se de que seleciona o ficheiro de parâmetros correto quando lhe for pedido.

Ver definições de recursos

Para rever as definições de recursos de todos os recursos num grupo de recursos do Azure, transfira a sua aplicação lógica do Azure para o Visual Studio, que é a forma mais fácil de criar um modelo de aplicação lógica parametrizada válido que está maioritariamente pronto para implementação.

Para obter informações gerais sobre os recursos de modelo e os respetivos atributos, veja estes tópicos:

Definição de recurso da aplicação lógica

A definição de recurso de fluxo de trabalho da aplicação lógica num modelo começa com o properties objeto, que inclui estas informações:

  • O estado da aplicação lógica na implementação
  • O ID de qualquer conta de integração utilizada pela sua aplicação lógica
  • Definição do fluxo de trabalho da sua aplicação lógica
  • Um parameters objeto que define os valores a utilizar no runtime
  • Outras informações de recursos sobre a sua aplicação lógica, como o nome, o tipo, a localização, quaisquer definições de configuração do runtime, etc.
{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   "parameters": {<template-parameters>},
   "variables": {},
   "functions": [],
   "resources": [
      {
         // Start logic app resource definition
         "properties": {
            "state": "<Enabled or Disabled>",
            "integrationAccount": {
               "id": "[parameters('LogicAppIntegrationAccount')]" // Template parameter reference
            },
            "definition": {<workflow-definition>},
            "parameters": {<workflow-definition-parameter-values>},
            "accessControl": {},
            "runtimeConfiguration": {}
         },
         "name": "[parameters('LogicAppName')]", // Template parameter reference
         "type": "Microsoft.Logic/workflows",
         "location": "[parameters('LogicAppLocation')]", // Template parameter reference
         "tags": {
           "displayName": "LogicApp"
         },
         "apiVersion": "2019-05-01",
         "dependsOn": [
         ]
      }
      // End logic app resource definition
   ],
   "outputs": {}
}

Eis os atributos específicos da definição de recursos da aplicação lógica:

Atributo Necessário Tipo Descrição
state Sim String O estado da aplicação lógica na implementação Enabled significa que a sua aplicação lógica está em direto e Disabled significa que a sua aplicação lógica está inativa. Por exemplo, se não estiver pronto para a sua aplicação lógica entrar em direto, mas quiser implementar uma versão de rascunho, pode utilizar a opção Disabled .
integrationAccount No Objeto Se a sua aplicação lógica utilizar uma conta de integração, que armazena artefactos para cenários empresariais (B2B), este objeto inclui o id atributo, que especifica o ID da conta de integração.
definition Yes Objeto A definição de fluxo de trabalho subjacente da sua aplicação lógica, que é o mesmo objeto que aparece na vista de código e está totalmente descrita no tópico Referência de esquema para Linguagem de Definição de Fluxo de Trabalho . Nesta definição de fluxo de trabalho, o parameters objeto declara parâmetros para os valores a utilizar no runtime da aplicação lógica. Para obter mais informações, veja Definição e parâmetros do Fluxo de Trabalho.

Para ver os atributos na definição de fluxo de trabalho da sua aplicação lógica, mude de "vista de estrutura" para "vista de código" no portal do Azure ou Visual Studio ou através de uma ferramenta como o Azure Resource Explorer.
parameters No Objeto Os valores dos parâmetros de definição de fluxo de trabalho a utilizar no runtime da aplicação lógica. As definições de parâmetro para estes valores aparecem dentro do objeto de parâmetros da definição do fluxo de trabalho. Além disso, se a sua aplicação lógica utilizar conectores geridos para aceder a outros serviços e sistemas, este objeto inclui um $connections objeto que define os valores de ligação a utilizar no runtime.
accessControl No Objeto Para especificar atributos de segurança para a sua aplicação lógica, como restringir o acesso de IP a acionadores de pedidos ou executar entradas e saídas do histórico de execuções. Para obter mais informações, veja Acesso seguro a aplicações lógicas.
runtimeConfiguration No Objeto Para especificar quaisquer operationOptions propriedades que controlem a forma como a sua aplicação lógica se comporta no tempo de execução. Por exemplo, pode executar a sua aplicação lógica no modo de débito elevado.

Para obter mais informações sobre definições de recursos para estes objetos do Logic Apps, veja Tipos de recursos Microsoft.Logic:

Definição e parâmetros do fluxo de trabalho

A definição de fluxo de trabalho da aplicação lógica é apresentada no definition objeto, que aparece no objeto dentro properties da definição de recursos da sua aplicação lógica. Este definition objeto é o mesmo objeto que aparece na vista de código e está totalmente descrito no tópico Referência de esquema para Linguagem de Definição de Fluxo de Trabalho . A definição do fluxo de trabalho inclui um objeto de declaração interna parameters onde pode definir parâmetros novos ou editar os valores que são utilizados pela definição do fluxo de trabalho no runtime. Em seguida, pode referenciar estes parâmetros dentro do acionador ou ações no fluxo de trabalho. Por predefinição, este parameters objeto está vazio, a menos que a sua aplicação lógica crie ligações a outros serviços e sistemas através de conectores geridos.

Para definir os valores dos parâmetros de definição de fluxo de trabalho, utilize o parameters objeto que está fora da definição do fluxo de trabalho, mas ainda dentro da definição de recursos da sua aplicação lógica. Neste objeto externo parameters , pode referenciar os parâmetros de modelo anteriormente declarados, que podem aceitar valores na implementação a partir de um ficheiro de parâmetros.

Dica

Como melhor prática, não faça referência direta aos parâmetros do modelo, que são avaliados na implementação, a partir da definição do fluxo de trabalho. Em vez disso, declare um parâmetro de definição de fluxo de trabalho, que pode definir no parameters objeto que está fora da definição do fluxo de trabalho, mas ainda dentro da definição de recursos da sua aplicação lógica. Para obter mais informações, veja Referências a parâmetros.

Esta sintaxe mostra onde pode declarar parâmetros nos níveis de definição do modelo e do fluxo de trabalho, juntamente com onde pode definir esses valores de parâmetros ao referenciar os parâmetros de definição do modelo e do fluxo de trabalho:

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   // Template parameters
   "parameters": {
      "<template-parameter-name>": {
         "type": "<parameter-type>",
         "defaultValue": "<parameter-default-value>",
         "metadata": {
            "description": "<parameter-description>"
         }
      }
   },
   "variables": {},
   "functions": [],
   "resources": [
      {
         // Start logic app resource definition
         "properties": {
            <other-logic-app-resource-properties>,
            "definition": {
               "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
               "actions": {<action-definitions>},
               // Workflow definition parameters
               "parameters": {
                  "<workflow-definition-parameter-name>": {
                     "type": "<parameter-type>",
                     "defaultValue": "<parameter-default-value>",
                     "metadata": {
                        "description": "<parameter-description>"
                     }
                  }
               },
               "triggers": {
                  "<trigger-name>": {
                     "type": "<trigger-type>",
                     "inputs": {
                         // Workflow definition parameter reference
                         "<attribute-name>": "@parameters('<workflow-definition-parameter-name')"
                     }
                  }
               },
               <...>
            },
            // Workflow definition parameter value
            "parameters": {
               "<workflow-definition-parameter-name>": { 
                  "value": "[parameters('<template-parameter-name>')]"
               }
            },
            "accessControl": {}
         },
         <other-logic-app-resource-definition-attributes>
      }
      // End logic app resource definition
   ],
   "outputs": {}
}

Parâmetros de definição de fluxo de trabalho seguros

Para um parâmetro de definição de fluxo de trabalho que processa informações confidenciais, palavras-passe, chaves de acesso ou segredos no runtime, declare ou edite o parâmetro para utilizar o securestring tipo ou secureobject parâmetro. Pode referenciar este parâmetro em toda e dentro da definição do fluxo de trabalho. No nível superior do modelo, declare um parâmetro que tenha o mesmo tipo para processar estas informações na implementação.

Para definir o valor para o parâmetro de definição do fluxo de trabalho, utilize o parameters objeto que está fora da definição do fluxo de trabalho, mas ainda dentro da definição do recurso da aplicação lógica para referenciar o parâmetro de modelo. Por fim, para transmitir o valor para o parâmetro de modelo na implementação, armazene esse valor no Azure Key Vault e faça referência a esse cofre de chaves no ficheiro de parâmetros utilizado pelo modelo na implementação.

Este modelo de exemplo mostra como pode concluir estas tarefas ao definir parâmetros protegidos quando necessário para que possa armazenar os respetivos valores no Azure Key Vault:

  • Declare parâmetros protegidos para os valores utilizados para autenticar o acesso.
  • Utilize estes valores nos níveis de definição do modelo e do fluxo de trabalho.
  • Forneça estes valores através de um ficheiro de parâmetros.

Modelo

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   "parameters": {
      <previously-defined-template-parameters>,
      // Additional template parameters for passing values to use in workflow definition
      "TemplateAuthenticationType": {
         "type": "string",
         "defaultValue": "",
         "metadata": {
            "description": "The type of authentication used for the Fabrikam portal"
         }
      },
      "TemplateFabrikamPassword": {
         "type": "securestring",
         "metadata": {
            "description": "The password for the Fabrikam portal"
         }
      },
      "TemplateFabrikamUserName": {
         "type": "securestring",
         "metadata": {
            "description": "The username for the Fabrikam portal"
         }
      }
   },
   "variables": {},
   "functions": [],
   "resources": [
      {
         // Start logic app resource definition
         "properties": {
            <other-logic-app-resource-properties>,
            // Start workflow definition
            "definition": {
               "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
               "actions": {<action-definitions>},
               // Workflow definition parameters
               "parameters": {
                  "authenticationType": {
                     "type": "string",
                     "defaultValue": "",
                     "metadata": {
                        "description": "The type of authentication used for the Fabrikam portal"
                     }
                  },
                  "fabrikamPassword": {
                     "type": "securestring",
                     "metadata": {
                        "description": "The password for the Fabrikam portal"
                     }
                  },
                  "fabrikamUserName": {
                     "type": "securestring",
                     "metadata": {
                        "description": "The username for the Fabrikam portal"
                     }
                  }
               },
               "triggers": {
                  "HTTP": {
                     "inputs": {
                        "authentication": {
                           // Reference workflow definition parameters
                           "password": "@parameters('fabrikamPassword')",
                           "type": "@parameters('authenticationType')",
                           "username": "@parameters('fabrikamUserName')"
                        }
                     },
                     "recurrence": {<...>},
                     "type": "Http"
                  }
               },
               <...>
            },
            // End workflow definition
            // Start workflow definition parameter values
            "parameters": {
               "authenticationType": {
                  "value": "[parameters('TemplateAuthenticationType')]" // Template parameter reference
               },
               "fabrikamPassword": {                  
                  "value": "[parameters('TemplateFabrikamPassword')]" // Template parameter reference
               },
               "fabrikamUserName": {
                  "value": "[parameters('TemplateFabrikamUserName')]" // Template parameter reference
               }
            },
            "accessControl": {}
         },
         <other-logic-app-resource-attributes>
      }
      // End logic app resource definition
   ],
   "outputs": {}
}

Ficheiro de parâmetros

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
   "contentVersion": "1.0.0.0",
   // Template parameter values
   "parameters": {
      <previously-defined-template-parameter-values>,
     "TemplateAuthenticationType": {
        "value": "Basic"
     },
     "TemplateFabrikamPassword": {
        "reference": {
           "keyVault": {
              "id": "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group-name>/Microsoft.KeyVault/vaults/fabrikam-key-vault"
           },
           "secretName": "FabrikamPassword"
        }
     },
     "TemplateFabrikamUserName": {
        "reference": {
           "keyVault": {
              "id": "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group-name>/Microsoft.KeyVault/vaults/fabrikam-key-vault"
           },
           "secretName": "FabrikamUserName"
        }
     }
   }
}

Melhores práticas – parâmetros de definição de fluxo de trabalho

Para se certificar de que o Estruturador de Aplicações Lógicas consegue mostrar corretamente os parâmetros de definição do fluxo de trabalho, siga estas melhores práticas:

Para obter mais informações sobre os parâmetros de definição do fluxo de trabalho, veja Parameters - Workflow Definition Language (Parâmetros – Linguagem de Definição do Fluxo de Trabalho).

Definições de recursos de ligação

Quando a aplicação lógica cria e utiliza ligações para outros serviços e sistema através de conectores geridos, o objeto do resources modelo contém as definições de recursos dessas ligações. Embora crie ligações a partir de uma aplicação lógica, as ligações são recursos do Azure separados com as suas próprias definições de recursos. Para rever estas definições de recursos de ligação, transfira a sua aplicação lógica do Azure para o Visual Studio, que é a forma mais fácil de criar um modelo de aplicação lógica parametrizada válido que esteja maioritariamente pronto para implementação.

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   "parameters": {<template-parameters>},
   "variables": {},
   "functions": [],
   "resources": [
      {
         <logic-app-resource-definition>
      },
      // Start connection resource definitions
      {
         <connection-resource-definition-1>
      },
      {
         <connection-resource-definition-2>
      }
   ],
   "outputs": {}
}

As definições de recursos de ligação referenciam os parâmetros de nível superior do modelo para os respetivos valores, para que possa fornecer estes valores na implementação através de um ficheiro de parâmetros. Certifique-se de que as ligações utilizam o mesmo grupo de recursos e localização do Azure que a sua aplicação lógica.

Eis um exemplo de definição de recurso para uma ligação Office 365 Outlook e os parâmetros de modelo correspondentes:

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   // Template parameters
   "parameters": {
      "LogicAppName": {<parameter-definition>},
      "LogicAppLocation": {<parameter-definition>},
      "office365_1_Connection_Name": {
         "type": "string",
         "defaultValue": "office365",
         "metadata": {
            "description": "The resource name for the Office 365 Outlook connection"
         }
      },
      "office365_1_Connection_DisplayName": {
         "type": "string",
         "defaultValue": "",
         "metadata": {
            "description": "The display name for the Office 365 Outlook connection"
         }
      }
   },
   "variables": {},
   "functions": [],
   "resources": [
      {
         <logic-app-resource-definition>
      },
      // Office 365 Outlook API connection resource definition
      {
         "type": "Microsoft.Web/connections",
         "apiVersion": "2016-06-01",
         // Template parameter reference for connection name
         "name": "[parameters('office365_1_Connection_Name')]",
         // Template parameter reference for connection resource location. Must match logic app location.
         "location": "[parameters('LogicAppLocation')]",
         "properties": {
            "api": {
               // Connector ID
               "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'office365')]"
            },
            // Template parameter reference for connection display name
            "displayName": "[parameters('office365_1_Connection_DisplayName')]"
         }
      }
   ],
   "outputs": {}
}

A definição de recursos da sua aplicação lógica também funciona com definições de recursos de ligação desta forma:

  • Dentro da definição do fluxo de trabalho, o parameters objeto declara um $connections parâmetro para os valores de ligação a utilizar no runtime da aplicação lógica. Além disso, o acionador ou ação que cria uma ligação utiliza os valores correspondentes que passam por este $connections parâmetro.

  • Fora da definição do fluxo de trabalho, mas ainda dentro da definição de recurso da aplicação lógica, outro parameters objeto define os valores a utilizar no runtime para o $connections parâmetro ao referenciar os parâmetros de modelo correspondentes. Estes valores utilizam expressões de modelo para referenciar recursos que armazenam em segurança os metadados das ligações na sua aplicação lógica.

    Por exemplo, os metadados podem incluir cadeias de ligação e tokens de acesso, que pode armazenar no Azure Key Vault. Para transmitir esses valores aos parâmetros do modelo, faça referência a esse cofre de chaves no ficheiro de parâmetros utilizado pelo modelo na implementação. Para obter mais informações sobre as diferenças na referência de parâmetros, veja Referências a parâmetros mais adiante neste tópico.

    Quando abre a definição de fluxo de trabalho da sua aplicação lógica na vista de código através do portal do Azure ou do Visual Studio, o $connections objeto aparece fora da definição do fluxo de trabalho, mas ao mesmo nível. Esta ordenação na vista de código facilita a referência destes parâmetros quando atualiza manualmente a definição do fluxo de trabalho:

    {
   "$connections": {<workflow-definition-parameter-connection-values-runtime},
   "definition": {<workflow-definition>}
}

  • A definição de recursos da aplicação lógica tem um dependsOn objeto que especifica as dependências das ligações utilizadas pela sua aplicação lógica.

Cada ligação que criar tem um nome exclusivo no Azure. Quando cria várias ligações para o mesmo serviço ou sistema, cada nome de ligação é acrescentado a um número, que incrementa com cada nova ligação criada, por exemplo, office365, office365-1e assim sucessivamente.

Este exemplo mostra as interações entre a definição de recursos da sua aplicação lógica e uma definição de recurso de ligação para Office 365 Outlook:

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   // Template parameters
   "parameters": {
      "LogicAppName": {<parameter-definition>},
      "LogicAppLocation": {<parameter-definition>},
      "office365_1_Connection_Name": {<parameter-definition>},
      "office365_1_Connection_DisplayName": {<parameter-definition>}
   },
   "variables": {},
   "functions": [],
   "resources": [
      {
         // Start logic app resource definition
         "properties": {
            <...>,
            "definition": {
               <...>,
               "parameters": {
                  // Workflow definition "$connections" parameter
                  "$connections": {
                     "defaultValue": {},
                     "type": "Object"
                  }
               },
               <...>
            },
            "parameters": {
               // Workflow definition "$connections" parameter values to use at runtime
               "$connections": {
                  "value": {
                     "office365": {
                        // Template parameter references
                        "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'office365')]",
                        "connectionId": "[resourceId('Microsoft.Web/connections', parameters('office365_1_Connection_Name'))]",
                        "connectionName": "[parameters('office365_1_Connection_Name')]"
                     }
                  }
               }
            }
         },
         <other-logic-app-resource-information>,
         "dependsOn": [
            "[resourceId('Microsoft.Web/connections', parameters('office365_1_Connection_Name'))]"
         ]
         // End logic app resource definition
      },
      // Office 365 Outlook API connection resource definition
      {
         "type": "Microsoft.Web/connections",
         "apiVersion": "2016-06-01",
         // Template parameter reference for connection name
         "name": "[parameters('office365_1_Connection_Name')]",
         // Template parameter reference for connection resource location. Must match logic app location.
         "location": "[parameters('LogicAppLocation')]",
         "properties": {
            "api": {
               // Connector ID
               "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'office365')]"
            },
            // Template parameter reference for connection display name
            "displayName": "[parameters('office365_1_Connection_DisplayName')]"
         }
      }
   ],
   "outputs": {}
}

Parâmetros de ligação seguros

Para um parâmetro de ligação que processa informações confidenciais, palavras-passe, chaves de acesso ou segredos, a definição de recurso da ligação inclui um parameterValues objeto que especifica estes valores no formato de par nome-valor. Para ocultar estas informações, pode declarar ou editar os parâmetros do modelo para estes valores com os securestring tipos de parâmetro ou secureobject . Em seguida, pode armazenar essas informações no Azure Key Vault. Para transmitir esses valores aos parâmetros do modelo, faça referência a esse cofre de chaves no ficheiro de parâmetros utilizado pelo modelo na implementação.

Eis um exemplo que fornece o nome da conta e a chave de acesso para uma ligação Armazenamento de Blobs do Azure:

Ficheiro de parâmetros

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
   "contentVersion": "1.0.0.0",
   // Template parameter values
   "parameters": {
      "LogicAppName": {
         "value": "Email-Processor-Logic-App"
      },
      "LogicAppLocation": {
         "value": "westeurope"
      },
      "azureblob_1_Connection_Name": {
         "value": "Fabrikam-Azure-Blob-Storage-Connection"
      },
      "azureblob_1_Connection_DisplayName": {
         "value": "Fabrikam-Storage"
      },
      "azureblob_1_accountName": {
         "value": "Fabrikam-Storage-Account"
      },
      "azureblob_1_accessKey": {
         "reference": {
            "keyVault": {
               "id": "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group-name>/Microsoft.KeyVault/vaults/fabrikam-key-vault"
            },
            "secretName": "FabrikamStorageKey"
         }
      }
   }
}

Modelo

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   // Template parameters
   "parameters": {
      "LogicAppName": {<parameter-definition>},
      "LogicAppLocation": {<parameter-definition>},
      "azureblob_1_Connection_Name": {<parameter-definition>},
      "azureblob_1_Connection_DisplayName": {<parameter-definition>},
      "azureblob_1_accountName": {
         "type": "string",
         "defaultValue": "",
         "metadata": {
            "description": "Name of the storage account the connector should use."
         }
      },
      "azureblob_1_accessKey": {
         "type": "secureobject",
         "metadata": {
            "description": "Specify a valid primary/secondary storage account access key."
         }
      }
   },
   "variables": {},
   "functions": [],
   "resources": [
      {
         "properties": {
            "state": "Disabled",
            "definition": {
               "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
               "actions": {
                  // Azure Blob Storage action
                  "Create_blob": {
                     "type": "ApiConnection",
                     "inputs": {
                        "host": {
                           "connection": {
                              // Workflow definition parameter reference for values to use at runtime
                              "name": "@parameters('$connections')['azureblob']['connectionId']"
                           }
                        },
                     },
                     "method": "post",
                     "body": "@triggerBody()?['Body']",
                     "path": "/datasets/default/files",
                     "queries": {
                        "folderPath": "/emails",
                        "name": "@triggerBody()?['Subject']",
                        "queryParametersSingleEncoded": true
                     },
                     "runAfter": {},
                     "runtimeConfiguration": {
                        "contentTransfer": {
                           "transferMode": "Chunked"
                        }
                     }
                  }
               },
               "parameters": {
                  // Workflow definition parameter for values to use at runtime
                  "$connections": {
                     "defaultValue": {},
                     "type": "Object"
                  }
               },
               "triggers": {<trigger-definition>},
               "contentVersion": "1.0.0.0",
               "outputs": {}
            },
            "parameters": {
               "$connections": {
                  "value": {
                     // Template parameter references for values to use at runtime
                     "azureblob": {
                        "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'azureblob')]",
                        "connectionId": "[resourceId('Microsoft.Web/connections', parameters('azureblob_1_Connection_Name'))]",
                        "connectionName": "[parameters('azureblob_1_Connection_Name')]"
                    }
                  }
               }
            },
            "name": "[parameters('LogicAppName')]",
            "type": "Microsoft.Logic/workflows",
            "location": "[parameters('LogicAppLocation')]",
            "tags": {
               "displayName": "LogicApp"
            },
            "apiVersion": "2019-05-01",
            // Template parameter reference for value to use at deployment
            "dependsOn": [
               "[resourceId('Microsoft.Web/connections', parameters('azureblob_1_Connection_Name'))]"
            ]
         }
      },
      // Azure Blob Storage API connection resource definition
      {
         "type": "Microsoft.Web/connections",
         "apiVersion": "2016-06-01",
         "name": "[parameters('azureblob_1_Connection_Name')]",
         "location": "[parameters('LogicAppLocation')]",
         "properties": {
            "api": {
               "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'azureblob')]"
            },
            "displayName": "[parameters('azureblob_1_Connection_DisplayName')]",
            // Template parameter reference for values to use at deployment
            "parameterValues": {
               "accountName": "[parameters('azureblob_1_accountName')]",
               "accessKey": "[parameters('azureblob_1_accessKey')]"
            }
         }
      }
   ],
   "outputs": {}
}

Autenticar ligações

Após a implementação, a aplicação lógica funciona ponto a ponto com parâmetros válidos. No entanto, ainda tem de autorizar quaisquer ligações OAuth para gerar tokens de acesso válidos para autenticar as suas credenciais. Para obter mais informações, veja Autorizar ligações OAuth.

Algumas ligações suportam a utilização de um principal de serviço do Azure Active Directory (Azure AD) para autorizar ligações para uma aplicação lógica registada no Azure AD. Por exemplo, esta definição de recurso de ligação do Azure Data Lake mostra como referenciar os parâmetros do modelo que processam as informações do principal de serviço e como o modelo declara estes parâmetros:

Definição de recurso de ligação

{
   <other-template-objects>
   "type": "Microsoft.Web/connections",
   "apiVersion": "2016-06-01",
   "name": "[parameters('azuredatalake_1_Connection_Name')]",
   "location": "[parameters('LogicAppLocation')]",
   "properties": {
      "api": {
         "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', 'resourceGroup().location', '/managedApis/', 'azuredatalake')]"
      },
      "displayName": "[parameters('azuredatalake_1_Connection_DisplayName')]",
      "parameterValues": {
         "token:clientId": "[parameters('azuredatalake_1_token:clientId')]",
         "token:clientSecret": "[parameters('azuredatalake_1_token:clientSecret')]",
         "token:TenantId": "[parameters('azuredatalake_1_token:TenantId')]",
         "token:grantType": "[parameters('azuredatalake_1_token:grantType')]"
      }
   }
}
Atributo Descrição
token:clientId O ID de cliente ou aplicação associado ao principal de serviço
token:clientSecret O valor da chave associado ao principal de serviço
token:TenantId O ID do diretório do seu inquilino Azure AD
token:grantType O tipo de concessão pedido, que tem de ser client_credentials. Para obter mais informações, veja plataforma de identidades da Microsoft e o fluxo de credenciais de cliente OAuth 2.0.

Definições de parâmetros de modelo

O objeto de nível parameters superior do modelo declara estes parâmetros para a ligação de exemplo:

{
   "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   "parameters": {
      "azuredatalake_1_Connection_Name": {
        "type": "string",
        "defaultValue": "azuredatalake"
      },
      "azuredatalake_1_Connection_DisplayName": {
        "type": "string",
        "defaultValue": "<connection-name>"
      },
      "azuredatalake_1_token:clientId": {
        "type": "securestring",
        "metadata": {
          "description": "Client (or Application) ID of the Azure Active Directory application."
        }
      },
      "azuredatalake_1_token:clientSecret": {
        "type": "securestring",
        "metadata": {
          "description": "Client secret of the Azure Active Directory application."
        }
      },
      "azuredatalake_1_token:TenantId": {
        "type": "securestring",
        "metadata": {
          "description": "The tenant ID of for the Azure Active Directory application."
        }
      },
      "azuredatalake_1_token:resourceUri": {
        "type": "string",
        "metadata": {
          "description": "The resource you are requesting authorization to use."
        }
      },
      "azuredatalake_1_token:grantType": {
        "type": "string",
        "metadata": {
          "description": "Grant type"
        },
        "defaultValue": "client_credentials",
        "allowedValues": [
          "client_credentials"
        ]
      },
      // Other template parameters
   }
   // Other template objects
}

Para obter mais informações sobre como trabalhar com principais de serviço, veja estes tópicos:

Referências a parâmetros

Para referenciar parâmetros de modelo, pode utilizar expressões de modelo com funções de modelo, que são avaliadas na implementação. As expressões de modelo utilizam parênteses retos ([]):

"<attribute-name>": "[parameters('<template-parameter-name>')]"

Para referenciar parâmetros de definição de fluxo de trabalho, utilize expressões e funções de Linguagem de Definição de Fluxo de Trabalho, que são avaliadas no runtime. Poderá reparar que algumas funções de modelo e funções de definição de fluxo de trabalho têm o mesmo nome. As expressões de definição de fluxo de trabalho começam com o símbolo "at" (@):

"<attribute-name>": "@parameters('<workflow-definition-parameter-name>')"

Pode transmitir valores de parâmetros de modelo para a definição de fluxo de trabalho para a sua aplicação lógica utilizar no runtime. No entanto, evite utilizar parâmetros de modelo, expressões e sintaxe na definição do fluxo de trabalho porque o Estruturador de Aplicações Lógicas não suporta elementos de modelo. Além disso, a sintaxe e as expressões do modelo podem complicar o código devido a diferenças no momento em que as expressões são avaliadas.

Em vez disso, siga estes passos gerais para declarar e referenciar os parâmetros de definição do fluxo de trabalho a utilizar no runtime, declarar e referenciar os parâmetros do modelo a utilizar na implementação e especificar os valores a transmitir na implementação com um ficheiro de parâmetros. Para obter detalhes completos, veja a secção Definição e parâmetros do Fluxo de Trabalho anteriormente neste tópico.

  1. Crie o seu modelo e declare os parâmetros do modelo para que os valores aceitem e utilizem na implementação.

  2. Na definição do fluxo de trabalho, declare os parâmetros dos valores a aceitar e utilizar no runtime. Em seguida, pode referenciar estes valores em toda e dentro da definição do fluxo de trabalho.

  3. parameters No objeto que está fora da definição do fluxo de trabalho, mas ainda dentro da definição de recurso da sua aplicação lógica, defina os valores para os parâmetros de definição do fluxo de trabalho ao referenciar os parâmetros de modelo correspondentes. Dessa forma, pode transmitir valores de parâmetros de modelo para os parâmetros de definição do fluxo de trabalho.

  4. No ficheiro de parâmetros, especifique os valores para o seu modelo utilizar na implementação.

Modelo de exemplo completo

Eis o modelo de exemplo parametrizado que é utilizado pelos exemplos deste tópico:

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
   "parameters": {
      "LogicAppName": {
         "type": "string",
         "minLength": 1,
         "maxLength": 80,
         "defaultValue": "MyLogicApp",
         "metadata": {
            "description": "The resource name to use for the logic app"
         }
      },
      "LogicAppLocation": {
         "type": "string",
         "minLength": 1,
         "defaultValue": "[resourceGroup().location]",
         "metadata": {
            "description": "The resource location to use for the logic app"
         }
      },
      "office365_1_Connection_Name": {
         "type": "string",
         "defaultValue": "office365",
         "metadata": {
            "description": "The resource name to use for the Office 365 Outlook connection"
         }
      },
      "office365_1_Connection_DisplayName": {
         "type": "string",
         "defaultValue": "",
         "metadata": {
            "description": "The display name to use for the Office 365 Outlook connection"
         }
      },
      "azureblob_1_Connection_Name": {
         "type": "string",
         "defaultValue": "azureblob",
         "metadata": {
            "description": "The resource name to use for the Azure Blob storage account connection"
         }
      },
      "azureblob_1_Connection_DisplayName": {
         "type": "string",
         "defaultValue": "",
         "metadata": {
            "description": "Name of the storage account the connector should use."
         }

      },
      "azureblob_1_accountName": {
         "type": "string",
         "defaultValue": "",
         "metadata": {
            "description": "Name of the storage account the connector should use."
         }
      },
      "azureblob_1_accessKey": {
         "type": "securestring",
         "metadata": {
            "description": "Specify a valid primary/secondary storage account access key."
         }
      },
      "LogicAppIntegrationAccount": {
         "type":"string",
         "minLength": 1,
         "defaultValue": "/subscriptions/<Azure-subscription-ID>/resourceGroups/fabrikam-integration-account-rg/providers/Microsoft.Logic/integrationAccounts/fabrikam-integration-account",
         "metadata": {
            "description": "The ID to use for the integration account"
         }
      }
   },
   "variables": {},
   "resources": [
      {
         "properties": {
            "state": "Disabled",
            "integrationAccount": {
              "id": "[parameters('LogicAppIntegrationAccount')]"
            },
            "definition": {
               "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
               "actions": {
                  "Create_blob": {
                     "type": "ApiConnection",
                     "inputs": {
                        "host": {
                           "connection": {
                              "name": "@parameters('$connections')['azureblob']['connectionId']"
                           }
                        }
                     },
                     "method": "post",
                     "body": "@triggerBody()?['Body']",
                     "path": "/datasets/default/files",
                     "queries": {
                        "folderPath": "/emails",
                        "name": "@triggerBody()?['Subject']",
                        "queryParametersSingleEncoded": true
                     },
                     "runAfter": {},
                     "runtimeConfiguration": {
                        "contentTransfer": {
                           "transferMode": "Chunked"
                        }
                     }
                  }
               },
               "parameters": {
                  "$connections": {
                     "defaultValue": {},
                     "type": "Object"
                  }
               },
               "triggers": {
                  "When_a_new_email_arrives": {
                     "type": "ApiConnection",
                     "inputs": {
                        "host": {
                           "connection": {
                              "name": "@parameters('$connections')['office365']['connectionId']"
                           }
                        },
                        "method": "get",
                        "path": "/Mail/OnNewEmail",
                        "queries": {
                           "folderPath": "Inbox",
                           "importance": "Any",
                           "fetchOnlyWithAttachment": false,
                           "includeAttachments": false
                        }
                     },
                     "recurrence": {
                        "frequency": "Day",
                        "interval": 1
                     },
                     "splitOn": "@triggerBody()?['value']"
                  }
               },
               "contentVersion": "1.0.0.0",
               "outputs": {}
            },
            "parameters": {
               "$connections": {
                  "value": {
                     "azureblob": {
                        "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'azureblob')]",
                        "connectionId": "[resourceId('Microsoft.Web/connections', parameters('azureblob_1_Connection_Name'))]",
                        "connectionName": "[parameters('azureblob_1_Connection_Name')]"
                     },
                     "office365": {
                        "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'office365')]",
                        "connectionId": "[resourceId('Microsoft.Web/connections', parameters('office365_1_Connection_Name'))]",
                        "connectionName": "[parameters('office365_1_Connection_Name')]"
                     }
                  }
               }
            },
            "accessControl": {}
         },
         "name": "[parameters('LogicAppName')]",
         "type": "Microsoft.Logic/workflows",
         "location": "[parameters('LogicAppLocation')]",
         "tags": {
            "displayName": "LogicApp"
         },
         "apiVersion": "2019-05-01",
         "dependsOn": [
            "[resourceId('Microsoft.Web/connections', parameters('azureblob_1_Connection_Name'))]",
            "[resourceId('Microsoft.Web/connections', parameters('office365_1_Connection_Name'))]"
         ]
      },
      {
         "type": "Microsoft.Web/connections",
         "apiVersion": "2016-06-01",
         "name": "[parameters('office365_1_Connection_Name')]",
         "location": "[parameters('LogicAppLocation')]",
         "properties": {
            "api": {
                "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'office365')]"
            },
            "displayName": "[parameters('office365_1_Connection_DisplayName')]"
         }
      },
      {
         "type": "Microsoft.Web/connections",
         "apiVersion": "2016-06-01",
         "name": "[parameters('azureblob_1_Connection_Name')]",
         "location": "[parameters('LogicAppLocation')]",
         "properties": {
            "api": {
               "id": "[concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('LogicAppLocation'), '/managedApis/', 'azureblob')]"
            },
            "displayName": "[parameters('azureblob_1_Connection_DisplayName')]",
            "parameterValues": {
               "accountName": "[parameters('azureblob_1_accountName')]",
               "accessKey": "[parameters('azureblob_1_accessKey')]"
            }
         }
      }
   ],
   "outputs": {}
}

Passos seguintes

Criar modelos de aplicação lógica