Partilhar via

Visão geral: Automatizar a implantação de Aplicativos Lógicos do Azure usando modelos do Azure Resource Manager

  • Artigo

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

Quando estiver pronto para automatizar a criação e implantação de seu aplicativo lógico, você poderá expandir a definição de fluxo de trabalho subjacente do aplicativo lógico em um modelo do Azure Resource Manager. Este modelo define a infraestrutura, os recursos, os parâmetros e outras informações para provisionar e implantar seu aplicativo lógico. Ao definir parâmetros para valores que variam na implantação, também conhecidos como parametrização, você pode implantar repetida e consistentemente aplicativos lógicos com base em diferentes necessidades de implantação.

Por exemplo, se você implantar em ambientes para desenvolvimento, teste e produção, provavelmente usará cadeias de conexão diferentes para cada ambiente. Você pode declarar parâmetros de modelo que aceitam cadeias de conexão diferentes e, em seguida, armazenar essas cadeias de caracteres em um arquivo de parâmetros separado. Dessa forma, você pode alterar esses valores sem precisar atualizar e reimplantar o modelo. Para cenários em que você tem valores de parâmetros confidenciais ou que devem ser protegidos, como senhas e segredos, você pode armazenar esses valores no Cofre de Chaves do Azure e fazer com que seu arquivo de parâmetros recupere esses valores. No entanto, nesses cenários, você reimplantaria para recuperar os valores atuais.

Esta visão geral descreve os atributos em um modelo do Gerenciador de Recursos que inclui uma definição de fluxo de trabalho de aplicativo lógico. Tanto o modelo quanto a definição do fluxo de trabalho usam a sintaxe JSON, mas existem algumas diferenças porque a definição do fluxo de trabalho também segue o esquema da Linguagem de Definição de Fluxo de Trabalho. Por exemplo, expressões de modelo e expressões de definição de fluxo de trabalho diferem em como referenciam parâmetros e os valores que podem aceitar.

Gorjeta

Para obter a maneira mais fácil de obter um modelo de aplicativo lógico parametrizado válido que esteja praticamente pronto para implantação, use o Visual Studio (edição gratuita da Comunidade ou superior) e as Ferramentas de Aplicativos Lógicos do Azure para Visual Studio. Em seguida, você pode criar seu aplicativo lógico no Visual Studio ou localizar e baixar um aplicativo lógico existente do Azure para o Visual Studio.

Ou, você pode criar modelos de aplicativo lógico usando o Azure PowerShell com o módulo LogicAppTemplate.

O aplicativo lógico de exemplo neste tópico usa um gatilho do Outlook do Office 365 que é acionado quando um novo email chega e uma ação de Armazenamento de Blob do Azure que cria um blob para o corpo do email e carrega esse blob em um contêiner de armazenamento do Azure. Os exemplos também mostram como parametrizar valores que variam na implantação.

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

Para obter informações de recursos de modelo específicas para aplicativos lógicos, contas de integração, artefatos de conta de integração e ambientes de serviço de integração, consulte Tipos de recursos Microsoft.Logic.

Para modelos de aplicativo lógico de exemplo, consulte estes exemplos:

  • Modelo completo usado para os exemplos deste tópico
  • Exemplo de modelo de aplicativo lógico de início rápido no GitHub

Para a API REST dos Aplicativos Lógicos, comece com a visão geral da API REST dos Aplicativos Lógicos do Azure.

Estrutura do modelo

No nível superior, um modelo do Gerenciador de Recursos segue essa estrutura, que é totalmente descrita no tópico Estrutura e sintaxe do modelo 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 aplicativo lógico, você trabalha principalmente com estes objetos de modelo:

Atributo Description
parameters Declara os parâmetros de modelo para aceitar os valores a serem usados ao criar e personalizar recursos para implantação no Azure. Por exemplo, esses parâmetros aceitam os valores para o nome e o local do seu aplicativo lógico, conexões e outros recursos necessários para a implantação. Você pode armazenar esses valores de parâmetro em um arquivo de parâmetros, que é descrito posteriormente neste tópico. Para obter detalhes gerais, consulte Parâmetros - Estrutura e sintaxe do modelo do Gerenciador de Recursos.
resources Define os recursos a serem criados ou atualizados e implantados em um grupo de recursos do Azure, como seu aplicativo lógico, conexões, contas de armazenamento do Azure e assim por diante. Para obter detalhes gerais, consulte Recursos - Estrutura e sintaxe do modelo do Gerenciador de Recursos.

Seu modelo de aplicativo lógico usa este formato de nome de arquivo:

<logic-app-name>.json

Importante

A sintaxe do modelo diferencia maiúsculas de minúsculas, portanto, certifique-se de usar uma caixa consistente.

Parâmetros do modelo

Um modelo de aplicativo lógico tem vários parameters objetos que existem em diferentes níveis e executam funções diferentes. Por exemplo, no nível superior, você pode declarar parâmetros de modelo para os valores a serem aceitos e usados na implantação ao criar e implantar recursos no Azure, por exemplo:

  • Seu aplicativo lógico

  • Conexões que seu aplicativo lógico usa para acessar outros serviços e sistemas por meio de conectores gerenciados

  • Outros recursos que seu aplicativo lógico precisa para implantação

    Por exemplo, se seu aplicativo lógico usa uma conta de integração para cenários B2B (business-to-business), o objeto de nível parameters superior do modelo declara o parâmetro que aceita a ID do recurso para essa conta de integração.

Aqui está a estrutura geral e a sintaxe para uma definição de parâmetro, que é totalmente descrita pela estrutura e sintaxe do modelo Parameters - Resource Manager:

"<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 usados para criar e implantar esses recursos no Azure:

  • Nome e localização da sua aplicação lógica
  • ID a ser usado para uma conta de integração vinculada ao aplicativo lógico
{
   "$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": {}
}

Com exceção dos parâmetros que manipulam valores confidenciais ou que devem ser protegidos, como nomes de usuário, senhas e segredos, todos esses parâmetros incluem defaultValue atributos, embora, em alguns casos, os valores padrão sejam valores vazios. Os valores de implantação a serem usados para esses parâmetros de modelo são fornecidos pelo arquivo de parâmetros de exemplo descrito posteriormente neste tópico.

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

Outros objetos de modelo geralmente fazem referência a parâmetros de modelo para que possam usar os valores que passam pelos parâmetros de modelo, por exemplo:

  • O objeto de recursos do modelo, descrito posteriormente neste tópico, define cada recurso no Azure que você deseja criar e implantar, como a definição de recurso do seu aplicativo lógico. Esses recursos geralmente usam valores de parâmetros de modelo, como o nome, o local e as informações de conexão do seu aplicativo lógico.

  • Em um nível mais profundo na definição de recursos do aplicativo lógico, o objeto de parâmetros da definição do fluxo de trabalho declara parâmetros para os valores a serem usados no tempo de execução do aplicativo lógico. Por exemplo, você pode declarar parâmetros de definição de fluxo de trabalho para o nome de usuário e senha que um gatilho HTTP usa para autenticação. Para especificar os valores para os parâmetros de definição do fluxo de trabalho, use o parameters objeto que está fora da definição do fluxo de trabalho, mas ainda dentro da definição de recursos do aplicativo lógico. Neste objeto externo parameters , você pode fazer referência a parâmetros de modelo declarados anteriormente, que podem aceitar valores na implantação a partir de um arquivo de parâmetros.

Ao fazer referência a parâmetros, expressões e funções de modelo usam sintaxe diferente e se comportam de forma diferente das expressões e funções de definição de fluxo de trabalho. Para obter mais informações sobre essas diferenças, consulte Referências a parâmetros posteriormente neste tópico.

Práticas recomendadas - parâmetros do modelo

Aqui estão algumas práticas recomendadas para definir parâmetros:

  • Declare parâmetros apenas para valores que variam, com base em suas necessidades de implantação. Não declare parâmetros para valores que permanecem os mesmos em diferentes requisitos de implantação.

  • Inclua o defaultValue atributo, que pode especificar valores vazios, para todos os parâmetros, exceto para valores que são confidenciais ou devem ser protegidos. Sempre use parâmetros seguros para nomes de usuário, senhas e segredos. Para ocultar ou proteger valores de parâmetros confidenciais, siga as orientações nestes tópicos:

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

Para obter mais práticas recomendadas de modelo, consulte Práticas recomendadas para parâmetros de modelo.

Arquivo de parâmetros de modelo

Para fornecer os valores para parâmetros de modelo, armazene esses valores em um arquivo de parâmetros. Dessa forma, você pode usar diferentes arquivos de parâmetros com base em suas necessidades de implantação. Aqui está o formato de nome de arquivo a ser usado:

  • Nome do arquivo do modelo do aplicativo lógico: <logic-app-name.json>
  • Nome do arquivo de parâmetros: <logic-app-name.parameters.json>

Aqui está a estrutura dentro do arquivo de parâmetros, que inclui uma referência de cofre de chave para passar 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 arquivo 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

Seu modelo tem um resources objeto, que é uma matriz que contém definições para cada recurso a ser criado e implantado no Azure, como a definição de recurso do seu aplicativo lógico, definições de recurso de conexão e quaisquer outros recursos que seu aplicativo lógico precisa para implantaçã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ários aplicativos lógicos, portanto, certifique-se de que todos os recursos do aplicativo lógico especifiquem o mesmo grupo de recursos do Azure. Quando você implanta o modelo em um grupo de recursos do Azure usando o Visual Studio, é solicitado qual aplicativo lógico deseja abrir. Além disso, seu projeto de grupo de recursos do Azure pode conter mais de um modelo, portanto, certifique-se de selecionar o arquivo de parâmetros correto quando solicitado.

Exibir definições de recursos

Para revisar as definições de recursos para todos os recursos em um grupo de recursos do Azure, baixe seu aplicativo lógico do Azure para o Visual Studio, que é a maneira mais fácil de criar um modelo de aplicativo lógico parametrizado válido que está praticamente pronto para implantação.

Para obter informações gerais sobre recursos de modelo e seus atributos, consulte estes tópicos:

Definição de recursos do aplicativo lógico

A definição de recursos de fluxo de trabalho do seu aplicativo lógico em um modelo começa com o properties objeto, que inclui estas informações:

  • O estado do seu aplicativo lógico na implantação
  • A ID de qualquer conta de integração usada pelo seu aplicativo lógico
  • Definição de fluxo de trabalho do seu aplicativo lógico
  • Um parameters objeto que define os valores a serem usados em tempo de execução
  • Outras informações de recursos sobre seu aplicativo lógico, como nome, tipo, local, quaisquer definições de configuração de tempo de execução e assim por diante
{
   "$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": {}
}

Aqui estão os atributos específicos para sua definição de recurso de aplicativo lógico:

Atributo Necessário Type Description
state Sim String O estado do seu aplicativo lógico na implantação significa Enabled que seu aplicativo lógico está ativo e Disabled significa que seu aplicativo lógico está inativo. Por exemplo, se você não estiver pronto para que seu aplicativo lógico entre em operação, mas quiser implantar uma versão de rascunho, poderá usar a Disabled opção.
integrationAccount Não Object Se seu aplicativo lógico usa uma conta de integração, que armazena artefatos para cenários B2B (business-to-business), esse objeto inclui o id atributo, que especifica a ID da conta de integração.
definition Sim Object A definição de fluxo de trabalho subjacente do seu aplicativo lógico, que é o mesmo objeto que aparece na visualização de código e é 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 serem usados no tempo de execução do aplicativo lógico. Para obter mais informações, consulte Definição e parâmetros do fluxo de trabalho.

Para exibir os atributos na definição de fluxo de trabalho do seu aplicativo lógico, alterne de "modo de exibição de design" para "modo de exibição de código" no portal do Azure ou no Visual Studio, ou usando uma ferramenta como o Gerenciador de Recursos do Azure.
parameters Não Object Os valores do parâmetro de definição de fluxo de trabalho a serem usados no tempo de execução do aplicativo lógico. As definições de parâmetros para esses valores aparecem dentro do objeto de parâmetros de definição do fluxo de trabalho. Além disso, se seu aplicativo lógico usa conectores gerenciados para acessar outros serviços e sistemas, esse objeto inclui um $connections objeto que define os valores de conexão a serem usados em tempo de execução.
accessControl Não Object Para especificar atributos de segurança para seu aplicativo lógico, como restringir o acesso IP a gatilhos de solicitação ou entradas e saídas do histórico de execução. Para obter mais informações, consulte Acesso seguro a aplicativos lógicos.
runtimeConfiguration Não Object Para especificar quaisquer operationOptions propriedades que controlam a maneira como seu aplicativo lógico se comporta em tempo de execução. Por exemplo, você pode executar seu aplicativo lógico no modo de alta taxa de transferência.

Para obter mais informações sobre definições de recursos para esses objetos de aplicativos lógicos, consulte Tipos de recursos Microsoft.Logic:

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

A definição de fluxo de trabalho do aplicativo lógico aparece no definition objeto, que aparece no objeto dentro da properties definição de recurso do aplicativo lógico. Esse definition objeto é o mesmo que aparece na exibição de código e é totalmente descrito no tópico Referência de esquema para linguagem de definição de fluxo de trabalho. Sua definição de fluxo de trabalho inclui um objeto de declaração interna parameters onde você pode definir parâmetros novos ou editar parâmetros existentes para os valores que são usados pela definição de fluxo de trabalho em tempo de execução. Em seguida, você pode fazer referência a esses parâmetros dentro do gatilho ou ações em seu fluxo de trabalho. Por padrão, esse parameters objeto está vazio, a menos que seu aplicativo lógico crie conexões com outros serviços e sistemas por meio de conectores gerenciados.

Para definir os valores para os parâmetros de definição do fluxo de trabalho, use o parameters objeto que está fora da definição do fluxo de trabalho, mas ainda dentro da definição de recursos do aplicativo lógico. Nesse objeto externo parameters , você pode fazer referência aos parâmetros de modelo declarados anteriormente, que podem aceitar valores na implantação a partir de um arquivo de parâmetros.

Gorjeta

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

Esta sintaxe mostra onde você pode declarar parâmetros nos níveis de definição de modelo e fluxo de trabalho, juntamente com onde você pode definir esses valores de parâmetro fazendo referência aos parâmetros de definição de modelo e 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 seguros de definição do fluxo de trabalho

Para um parâmetro de definição de fluxo de trabalho que lida com informações confidenciais, senhas, chaves de acesso ou segredos em tempo de execução, declare ou edite o parâmetro para usar o securestring tipo de parâmetro ou secureobject . Você pode fazer referência a esse parâmetro durante e dentro de sua definição de fluxo de trabalho. No nível superior do modelo, declare um parâmetro que tenha o mesmo tipo para lidar com essas informações na implantação.

Para definir o valor para o parâmetro de definição de fluxo de trabalho, use o parameters objeto que está fora da definição de fluxo de trabalho, mas ainda dentro da definição de recurso do aplicativo lógico para fazer referência ao parâmetro de modelo. Por fim, para passar o valor para o parâmetro do modelo na implantação, armazene esse valor no Cofre da Chave do Azure e faça referência a esse cofre de chaves no arquivo de parâmetros usado pelo modelo na implantação.

Este modelo de exemplo mostra como você pode concluir essas tarefas definindo parâmetros seguros quando necessário para que você possa armazenar seus valores no Cofre da Chave do Azure:

  • Declare parâmetros seguros para os valores usados para autenticar o acesso.
  • Use esses valores nos níveis de definição de modelo e fluxo de trabalho.
  • Forneça esses valores usando um arquivo 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": {}
}

Arquivo 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"
        }
     }
   }
}

Práticas recomendadas - parâmetros de definição de fluxo de trabalho

Para certificar-se de que o Logic App Designer pode mostrar corretamente os parâmetros de definição do fluxo de trabalho, siga estas práticas recomendadas:

Para obter mais informações sobre parâmetros de definição de fluxo de trabalho, consulte Parâmetros - Linguagem de definição de fluxo de trabalho.

Definições de recursos de conexão

Quando seu aplicativo lógico cria e usa conexões com outros serviços e sistema usando conectores gerenciados, o objeto do modelo contém as definições de resources recursos para essas conexões. Embora você crie conexões de dentro de um aplicativo lógico, as conexões são recursos separados do Azure com suas próprias definições de recursos. Além disso, se sua conexão usa um recurso de gateway de dados local, essa definição de recurso existe separadamente da definição de recurso do conector. Para obter mais informações, consulte Definições de recursos de gateway de dados local e Microsoft.Web connectionGateways.

Para revisar as definições de recursos de conexão, baixe seu aplicativo lógico do Azure para o Visual Studio, que é a maneira mais fácil de criar um modelo de aplicativo lógico parametrizado válido que está praticamente pronto para implantaçã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 conexão fazem referência aos parâmetros de nível superior do modelo para seus valores, para que você possa fornecer esses valores na implantação usando um arquivo de parâmetros. Certifique-se de que as conexões usam o mesmo grupo de recursos do Azure e o mesmo local que seu aplicativo lógico.

Aqui está um exemplo de definição de recurso para uma conexão do 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 do seu aplicativo lógico também funciona com definições de recursos de conexão das seguintes maneiras:

  • Dentro da definição do fluxo de trabalho, o parameters objeto declara um $connections parâmetro para os valores de conexão a serem usados no tempo de execução do aplicativo lógico. Além disso, o gatilho ou ação que cria uma conexão usa os valores correspondentes que passam por esse $connections parâmetro.

  • Fora da definição do fluxo de trabalho, mas ainda dentro da definição de recursos do aplicativo lógico, outro parameters objeto define os valores a serem usados no tempo de execução para o $connections parâmetro fazendo referência aos parâmetros de modelo correspondentes. Esses valores usam expressões de modelo para fazer referência a recursos que armazenam com segurança os metadados para as conexões em seu aplicativo lógico.

    Por exemplo, os metadados podem incluir cadeias de conexão e tokens de acesso, que você pode armazenar no Cofre de Chaves do Azure. Para passar esses valores para os parâmetros do modelo, faça referência a esse cofre de chaves no arquivo de parâmetros usado pelo modelo na implantação. Para obter mais informações sobre diferenças nos parâmetros de referência, consulte Referências a parâmetros mais adiante neste tópico.

    Quando você abre a definição de fluxo de trabalho do seu aplicativo lógico no modo de exibição de código por meio do portal do Azure ou do Visual Studio, o $connections objeto aparece fora da definição do fluxo de trabalho, mas no mesmo nível. Essa ordenação na visualização de código torna esses parâmetros mais fáceis de referenciar quando você atualiza manualmente a definição do fluxo de trabalho:

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

  • A definição de recursos do aplicativo lógico tem um dependsOn objeto que especifica as dependências nas conexões usadas pelo aplicativo lógico.

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

Este exemplo mostra as interações entre a definição de recurso do seu aplicativo lógico e uma definição de recurso de conexão para o 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": {}
}

Definições de recursos de gateway de dados local

Se sua conexão usa um recurso de gateway de dados local, essa definição de recurso existe separadamente da definição de recurso do conector. Para exibir a definição de recurso do gateway de dados, siga estas etapas:

  1. No portal do Azure, localize e exiba o recurso do Azure para seu gateway de dados local.

  2. No menu de recursos, em Automação, selecione Exportar modelo.

    Depois que o Azure gera o modelo, a definição de recurso do gateway aparece na janela de código.

Para obter mais informações, consulte Microsoft.Web connectionGateways.

Parâmetros de conexão seguros

Para um parâmetro de conexão que lida com informações confidenciais, senhas, chaves de acesso ou segredos, a definição de recurso da conexão inclui um parameterValues objeto que especifica esses valores no formato de par nome-valor. Para ocultar essas informações, você pode declarar ou editar os parâmetros do modelo para esses valores usando os securestring tipos de parâmetro ou secureobject . Em seguida, você pode armazenar essas informações no Cofre da Chave do Azure. Para passar esses valores para os parâmetros do modelo, faça referência a esse cofre de chaves no arquivo de parâmetros usado pelo modelo na implantação.

Aqui está um exemplo que fornece o nome da conta e a chave de acesso para uma conexão de Armazenamento de Blob do Azure:

Arquivo 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 conexões

Após a implantação, seu aplicativo lógico funciona de ponta a ponta com parâmetros válidos. No entanto, você ainda deve autorizar quaisquer conexões OAuth para gerar tokens de acesso válidos para autenticar suas credenciais. Para obter mais informações, consulte Autorizar conexões OAuth.

Algumas conexões oferecem suporte ao uso de uma entidade de serviço do Microsoft Entra para autorizar conexões para um aplicativo lógico registrado na ID do Microsoft Entra. Por exemplo, esta definição de recurso de conexão do Azure Data Lake mostra como fazer referência aos parâmetros de modelo que manipulam as informações da entidade de serviço e como o modelo declara esses parâmetros:

Definição de recurso de conexã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 Description
token:clientId O ID do aplicativo ou cliente associado à sua entidade de serviço
token:clientSecret O valor-chave associado à sua entidade de serviço
token:TenantId A ID do diretório para seu locatário do Microsoft Entra
token:grantType O tipo de subvenção solicitado, que deve ser client_credentials. Para obter mais informações, consulte Plataforma de identidade da Microsoft e o fluxo de credenciais do 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 conexã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 entidades de serviço, consulte estes tópicos:

Referências a parâmetros

Para fazer referência aos parâmetros do modelo, você pode usar expressões de modelo com funções de modelo, que são avaliadas na implantação. As expressões de modelo usam colchetes ([]):

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

Para fazer referência a parâmetros de definição de fluxo de trabalho, use expressões e funções da linguagem de definição de fluxo de trabalho, que são avaliadas em tempo de execução. Você pode notar 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>')"

Você pode passar valores de parâmetro de modelo para sua definição de fluxo de trabalho para seu aplicativo lógico usar em tempo de execução. No entanto, evite usar parâmetros, expressões e sintaxe de modelo em sua definição de fluxo de trabalho porque o Logic App Designer não oferece suporte a elementos de modelo. Além disso, a sintaxe e as expressões do modelo podem complicar seu código devido a diferenças no momento em que as expressões são avaliadas.

Em vez disso, siga estas etapas gerais para declarar e fazer referência aos parâmetros de definição de fluxo de trabalho a serem usados no tempo de execução, declarar e fazer referência aos parâmetros de modelo a serem usados na implantação e especificar os valores a serem transmitidos na implantação usando um arquivo de parâmetros. Para obter detalhes completos, consulte a seção Definição e parâmetros do fluxo de trabalho anteriormente neste tópico.

  1. Crie seu modelo e declare os parâmetros do modelo para os valores a serem aceitos e usados na implantação.

  2. Na definição do fluxo de trabalho, declare os parâmetros para os valores a serem aceitos e usados em tempo de execução. Em seguida, você pode fazer referência a esses valores em toda e dentro de sua definição de fluxo de trabalho.

  3. No objeto que está fora da parameters definição do fluxo de trabalho, mas ainda dentro da definição de recursos do aplicativo lógico, defina os valores para os parâmetros de definição do fluxo de trabalho fazendo referência aos parâmetros de modelo correspondentes. Dessa forma, você pode passar valores de parâmetros de modelo para seus parâmetros de definição de fluxo de trabalho.

  4. No arquivo de parâmetros, especifique os valores para seu modelo usar na implantação.

Modelo de exemplo completo

Aqui está o modelo de exemplo parametrizado usado 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": {}
}

Próximos passos

Criar modelos de aplicativo lógico