Visão geral: implantação de automatização para 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 a implantação do seu aplicativo lógico, você poderá expandir a definição de fluxo de trabalho subjacente do aplicativo lógico para 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 conhecido como parametrização, você pode implantar aplicativos lógicos de forma repetida e consistente com base em necessidades de implantação diferentes.

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 armazenar essas cadeias de caracteres em um arquivo de parâmetros separado. Assim você pode alterar esses valores sem precisar atualizar e reimplantar o modelo. Para cenários em que você tem valores de parâmetro confidenciais ou que devem ser protegidos, como senhas e segredos, você pode armazenar esses valores no Azure Key Vault e fazer com que o arquivo de parâmetros recupere esses valores. No entanto, nesses cenários, você faria a reimplantação para recuperar os valores atuais.

Esta visão geral descreve os atributos em um modelo do Resource Manager que inclui uma definição de fluxo de trabalho do aplicativo lógico. O modelo e sua definição de fluxo de trabalho usam a sintaxe JSON, mas existem algumas diferenças porque a definição de 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 de definição de fluxo de trabalho diferem no modo referenciar parâmetros e nos valores que eles podem aceitar.

Dica

A maneira mais fácil de obter um modelo de aplicativo lógico parametrizado válido que está, na maioria das vezes, pronto para implantação, é usando o Visual Studio (versão Community gratuita ou superior) e as ferramentas de Aplicativos Lógicos do Azure para o Visual Studio. Você pode criar seu aplicativo lógico no Visual Studio ou Localizar e baixar um aplicativo lógico existente do Azure no Visual Studio.

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

O exemplo de aplicativo lógico neste tópico usa um gatilho do Outlook do Office 365 que é acionado quando chega um novo email e uma ação de Armazenamento de Blobs 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 saber mais sobre modelos do Resource Manager, confira os artigos a seguir:

Para 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 conhecer mais exemplos de modelos de aplicativo lógico, confira estes exemplos:

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 Resource Manager segue essa estrutura, que é descrita por completo 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 Descrição
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, o local, as conexões do seu aplicativo lógico 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 mais tarde neste tópico. Para saber mais detalhes em geral, consulte Parâmetros – Estrutura e sintaxe do modelo do Resource Manager.
resources Define os recursos para criar ou atualizar e implantar em um grupo de recursos do Azure, assim como seu aplicativo lógico, conexões, contas de armazenamento do Azure e assim por diante. Para saber mais detalhes em geral, consulte Recursos – Estrutura e sintaxe do modelo do Resource Manager.

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, verifique se está usando maiúsculas ou minúsculas.

Parâmetros de 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 sua lógica usa para acessar outros serviços e sistemas por meio de conectores gerenciados

  • Outros recursos de 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 (entre empresas), o objeto de nível superior do modelo parameters 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 é descrita por completo em Parâmetros – Estrutura e sintaxe do modelo do 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 do seu aplicativo lógico
  • ID usada 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": {}
}

Exceto para parâmetros que manipulam valores confidenciais ou que devem ser protegidos, como nomes de dados, 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 usados para esses parâmetros de modelo são fornecidos pelo exemplo arquivo de parâmetros descrito mais tarde neste tópico.

Para saber mais sobre como proteger os parâmetros de modelo, consulte estes tópicos:

Outros objetos de modelo costumam referenciar parâmetros de modelo para que eles possam usar os valores que passam por parâmetros de modelo, por exemplo:

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

  • Em um nível mais profundo na definição de recurso do aplicativo lógico, o objeto de parâmetros da definição de fluxo de trabalho declara parâmetros para os valores a serem usados no runtime 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 de HTTP usa para autenticação. Para especificar os valores de parâmetros de definição de fluxo de trabalho use o parameters objeto que está fora da definição de fluxo de trabalho, mas ainda está dentro da sua definição de recurso de aplicativo lógico. Nesse objeto externo parameters, você pode referenciar parâmetros de modelo já declarados, que podem aceitar valores na implantação de um arquivo de parâmetros.

Para referenciar parâmetros, as funções e expressõ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 saber mais sobre essas diferenças, consulte Referencias a Parâmetros, mais adiante neste tópico.

Melhores Práticas - parâmetros de modelo

Estas são algumas das melhores práticas para definir parâmetros:

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

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

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

Para saber mais sobre melhores práticas de modelo, consulte Melhores práticas 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 arquivos de parâmetros diferentes com base nas suas necessidades de implantação. Este é o formato de nome de arquivo a ser usado:

  • Nome do arquivo de 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 do Key Vault para passar um valor de parâmetro protegido 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 já declarados 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 de modelo

Seu modelo tem um resources objeto, que é uma matriz que contém definições para cada recurso criado e implantado no Azure, como a definição de recurso do aplicativo lógico, as definições de recurso de conexãoe quaisquer outros recursos que seu aplicativo lógico precisa para a 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": {}
}

Observação

Os modelos podem incluir definições de recursos para vários aplicativos lógicos, portanto, verifique se todos os recursos do aplicativo lógico especificam o mesmo grupo de recursos do Azure. Ao implantar o modelo em um grupo de recursos do Azure usando o Visual Studio é solicitado que você insira o aplicativo lógico que deseja abrir. Além disso, o projeto do grupo de recursos do Azure pode conter mais de um modelo, portanto, verifique se você selecionou o arquivo de parâmetros correto quando solicitado.

Exibir definições de recursos

Para examinar as definições de recursos de 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 com parâmetro válido que esteja quase sempre pronto para implantação.

Para saber mais sobre os recursos de modelo e seus atributos em geral, confira estes tópicos:

Definição de recurso de aplicativo lógico

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

  • O estado do aplicativo lógico na implantação
  • A ID de toda conta de integração usada pelo seu aplicativo lógico
  • A definição de fluxo de trabalho do seu aplicativo lógico
  • Um parameters objeto que define os valores a serem usados no runtime
  • Outras informações de recurso sobre seu aplicativo lógico, como nome, tipo, local, parâmetros de configuração de runtime 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": {}
}

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

Atributo Obrigatório Type Descrição
state Sim String O estado do aplicativo lógico na implantação, em que Enabled significa que seu aplicativo lógico está ativo e Disabled significa que seu aplicativo lógico está inativo. Por exemplo, se não estiver pronto para que seu aplicativo lógico fique ativo, mas deseja implantar uma versão de rascunho, você poderá usar a Disabled opção.
integrationAccount Não Objeto Se seu aplicativo lógico usa uma conta de integração, que armazena artefatos para cenários B2B (entre empresas), esse objeto inclui o atributo id, que especifica a ID da conta de integração.
definition Sim Objeto A definição de fluxo de trabalho subjacente do aplicativo lógico, que é o mesmo objeto que aparece na exibição de código e é descrita por completo 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 runtime do aplicativo lógico. Para saber mais, consulte parâmetros e definição de Fluxo de Trabalho.

Para exibir os atributos na definição de fluxo de trabalho do aplicativo lógico, alterne de "modo de exibição de design" para "exibição de código" no portal do Azure, no Visual Studio ou usando uma ferramenta como o Azure Resource Explorer.
parameters Não Objeto Valores de parâmetro de definição de fluxo de trabalho para usar no runtime do aplicativo lógico. As definições de parâmetro para esses valores aparecem dentro do objeto de parâmetros da definição de fluxo de trabalho. Além disso, se seu aplicativo lógico usar conectores gerenciados para acessar outros serviços e sistemas, esse objeto incluirá um $connections objeto que define os valores de conexão para usar no runtime.
accessControl Não Objeto Para especificar atributos de segurança para seu aplicativo lógico, como restringir o acesso IP para solicitações de gatilhos ou entradas e saídas de histórico de execução. Para saber mais, confira Acesso seguro em aplicativo lógicos.
runtimeConfiguration Não Objeto Para especificar toda operationOptions propriedade que controle a forma como seu aplicativo lógico se comporta no runtime. Por exemplo, você pode executar seu aplicativo lógico no modo de alta taxa de transferência.

Para saber mais sobre definições de recursos para esses objetos de Aplicativos Lógicos, consulte tipos de recursos Microsoft.Logic:

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

A definição de fluxo de trabalho do aplicativo lógico aparece no objeto definition, que aparece no objeto properties dentro da definição de recurso do aplicativo lógico. Esse definition objeto é o mesmo objeto que aparece na exibição de código e é descrito por completo 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 parameters objeto de declaração interno no qual você pode definir novos parâmetros ou editar os já existentes para os valores usados pela definição de fluxo de trabalho no runtime. Em seguida, você pode referenciar esses parâmetros dentro do gatilho ou a 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 de parâmetros de definição de fluxo de trabalho use o parameters objeto que está fora da definição de fluxo de trabalho, mas ainda está dentro da sua definição de recurso de aplicativo lógico. Nesse objeto externo parameters, você pode então referenciar parâmetros de modelo já declarados, que podem aceitar valores na implantação de um arquivo de parâmetros.

Dica

A melhor prática é não referenciar diretamente os parâmetros de modelo, que são avaliados na implantação, de dentro da definição de fluxo de trabalho. Ao invés disso, declare um parâmetro de definição de fluxo de trabalho, que você pode definir no parameters objeto que está fora da definição de fluxo de trabalho, mas ainda está dentro da sua definição de recurso de aplicativo lógico. Para saber mais, confira Referencias a Parâmetros.

Essa sintaxe mostra onde você pode declarar parâmetros nos níveis de definição de modelo e fluxo de trabalho e onde é possível definir esses valores de parâmetro referenciando os 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 de definição de fluxo de trabalho seguro

Para um parâmetro de definição de fluxo de trabalho que manipula informações confidenciais, senhas, chaves de acesso ou segredos no runtime, declare ou edite o parâmetro para usar o securestring ou secureobject tipo de parâmetro. Você pode referenciar esse parâmetro em toda a 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 do parâmetro de definição de fluxo de trabalho, use o parameters objeto que está fora de sua definição de fluxo de trabalho, mas ainda está dentro de sua definição de recurso de aplicativo lógico para referenciar parâmetros de modelo. Enfim, para passar o valor para o parâmetro de modelo na implantação, armazene esse valor no Azure Key Vault e faça referência a esse cofre de chaves no arquivo de parâmetros que é usado pelo seu modelo na implantação.

Este modelo de exemplo mostra como você pode concluir essas tarefas definindo parâmetros protegidos quando necessário para que você possa armazenar seus valores no Azure Key Vault:

  • Declare parâmetros protegidos para os valores usados para autenticar o acesso.
  • Use esses valores nos níveis de definição de modelo e de 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"
        }
     }
   }
}

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

Para verificar se o designer de aplicativo lógico pode mostrar corretamente os parâmetros de definição de fluxo de trabalho, siga estas melhores práticas:

Para saber mais sobre parâmetros de definição de fluxo de trabalho, consulte Parâmetros - Linguagem de Definição de Fluxo de trabalho.

Definições de recurso 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 resources contém as definições de recurso para essas conexões. Embora você crie conexões de dentro de um aplicativo lógico, as conexões são recursos do Azure separados com suas próprias definições de recurso. Para revisar essas definições de recursos 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 com parâmetro válido que esteja quase sempre 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 referenciam 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. Verifique se as conexões usam o mesmo grupo e localização de recursos do Azure que o seu aplicativo lógico.

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

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

  • Fora da sua definição de fluxo de trabalho, mas ainda dentro da definição de recurso do aplicativo lógico, outro parameters objeto define os valores para usar no runtime do parâmetro $connections referenciando parâmetros de modelo correspondentes. Esses valores usam expressões de modelo para referenciar 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 em Azure Key Vault. Para passar esses valores para os parâmetros de modelo, você referência a esse cofre de chaves no arquivo de parâmetros usado pelo modelo na implantação. Para saber mais sobre as diferenças dos parâmetros para referenciar, consulte Referencias a Parâmetros, mais adiante neste tópico.

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

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

  • A definição de recurso do aplicativo lógico tem um objeto dependsOn que especifica as dependências nas conexões usadas pelo seu 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 é anexado a um número, que é incrementado a cada nova conexão criada, por exemplo, office365, office365-1 e assim por diante.

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

Parâmetros de conexão de segurança

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

Este é um exemplo que fornece o nome da conta e a chave de acesso para uma conexão de Armazenamento de Blobs 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": {}
}

Autenticação de 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 as conexões OAuth para gerar tokens de acesso válidos para autenticar suas credenciais. Para saber mais, consulte Autorizar conexões OAuth.

Algumas conexões dão suporte ao uso de uma entidade de serviço do Microsoft Azure AD (Azure Active Directory) para autorizar conexões para um aplicativo lógico que é registrado no Microsoft Azure AD. Por exemplo, essa definição de recurso de conexão do Azure Data Lake mostra como referenciar os parâmetros de modelo que identificam as informações da entidade de serviço e como o modelo declara esses parâmetros:

Definições 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 Descrição
token:clientId A ID do aplicativo ou do cliente associada à entidade de serviço
token:clientSecret O valor de chave associado à entidade de serviço
token:TenantId A ID de diretório do locatário do Microsoft Azure AD
token:grantType O tipo de concessão solicitado deve ser client_credentials. Para saber mais, confira a plataforma de identidade da Microsoft e o fluxo de credenciais do cliente OAuth 2.0.

Definições de parâmetro de modelo

O objeto de nível superior do modelo parameters declara esses 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 saber mais sobre como trabalhar com entidades de serviço, consulte estes tópicos:

Referências a parâmetros

Para referenciar parâmetros de modelo, você pode usar expressões de modelo com funções de modelo avaliadas na implantação. As expressões de modelo usam colchetes ( [] ):

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

Para referenciar parâmetros de definição de fluxo de trabalho, use as expressões e funções de Linguagem de Definição de Fluxo de trabalho avaliadas no tempo de execução. Você pode observar 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 no runtime. No entanto, evite usar parâmetros de modelo, expressões e sintaxe em sua definição de fluxo de trabalho porque o designer de aplicativo lógico é compatível com elementos do modelo. Além disso, a sintaxe e as expressões do modelo podem complicar o seu código devido a diferenças de quando as expressões são avaliadas.

Em vez disso, siga estas etapas gerais para declarar e referenciar os parâmetros de definição de fluxo de trabalho a serem usados no runtime. Declare e referencie os parâmetros de modelo para usar na implantação e especifique os valores para passar na implantação usando um arquivo de parâmetros. Para saber todos os detalhes, consulte a seção anterior deste tópico definição e parâmetros de fluxo de trabalho.

  1. Criar seu modelo e declarar os parâmetros de modelo dos valores para aceitar e usar na implantação.

  2. Na sua definição de fluxo de trabalho, declarar os parâmetros dos valores para aceitar e usar no runtime. Em seguida, você pode referenciar esses valores em toda a sua definição de fluxo de trabalho.

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

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

Modelo de exemplo completo

Este é o modelo de exemplo com parâmetros que é 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óximas etapas

Criar modelos de aplicativo lógico