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

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.

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:

• Estrutura e sintaxe do modelo do Azure Resource Manager
• Práticas recomendadas para modelos do Azure Resource Manager
• Desenvolva modelos do Azure Resource Manager para consistência de nuvem

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

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

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

<logic-app-name>.json

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:

• Recomendações de segurança para parâmetros de modelo
• Melhorar a segurança para parâmetros de modelo
• Passar valores de parâmetros protegidos com o Azure Key Vault

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:

  • Recomendações de segurança para parâmetros de modelo

  • Melhorar a segurança para parâmetros de modelo

  • Passar valores de parâmetros protegidos com o Azure Key Vault

• 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": {}
}

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:

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

• Definição de recurso de fluxo de trabalho

• Definição de recurso de conta de integração

• Artefatos de conta de integração:

  • Definição de recurso do contrato

  • Definição de recurso do assembly

  • Definição de recurso de configuração de lote

  • Definição de recurso de certificado

  • Definição de Recurso de mapa

  • Definição de Recurso de parceiro

  • Definição de Recurso de esquema

  • Definição de Recurso de sessão

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.

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:

• 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:

  • Recomendações de segurança para parâmetros de ação

  • Recomendações de segurança para parâmetros em definições de fluxo de trabalho

  • Passar valores de parâmetros de segurança com o Azure Key Vault

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. Além disso, se a sua conexão usar um recurso de gateway de dados local, essa definição de recurso existirá separadamente da definição de recurso do conector. Para obter mais informações, consulte Definições de recursos do gateway de dados local e Microsoft.Web connectionGateways.

O seguinte exemplo mostra onde você pode encontrar definições de recurso de conexã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, 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": {}
}

Definições de recursos do gateway de dados local

Se a sua conexão usar um recurso de gateway de dados local, essa definição de recurso existirá 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 é exibida na janela de código.

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

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 Entra para autorizar conexões para um aplicativo lógico registrado no Microsoft Entra ID. 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')]"
      }
   }
}

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:

• Criar uma entidade de serviço usando o portal do Azure
• Criar uma entidade de serviço do Azure com o Azure PowerShell
• Criar uma entidade de serviço com um certificado usando o Azure PowerShell

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