Přehled: Automatizace nasazení pro Azure Logic Apps pomocí šablon Azure Resource ManagerOverview: Automate deployment for Azure Logic Apps by using Azure Resource Manager templates

Až budete připraveni automatizovat vytváření a nasazení aplikace logiky, můžete svou definici pracovního postupu vaší aplikace logiky rozšířit do šablony Azure Resource Manager.When you're ready to automate creating and deploying your logic app, you can expand your logic app's underlying workflow definition into an Azure Resource Manager template. Tato šablona definuje infrastrukturu, prostředky, parametry a další informace pro zřizování a nasazení aplikace logiky.This template defines the infrastructure, resources, parameters, and other information for provisioning and deploying your logic app. Definováním parametrů pro hodnoty, které se liší v nasazení, označované také jako Parametrizace, můžete opakovaně a konzistentně nasazovat aplikace logiky na základě různých potřeb nasazení.By defining parameters for values that vary at deployment, also known as parameterizing, you can repeatedly and consistently deploy logic apps based on different deployment needs.

Například pokud nasadíte do prostředí pro vývoj, testování a produkci, pravděpodobně pro každé prostředí použijete různé připojovací řetězce.For example, if you deploy to environments for development, test, and production, you likely use different connection strings for each environment. Můžete deklarovat parametry šablony, které přijímají různé připojovací řetězce, a pak tyto řetězce Uložit do samostatného souboru parametrů.You can declare template parameters that accept different connection strings and then store those strings in a separate parameters file. Tímto způsobem můžete tyto hodnoty změnit, aniž byste museli šablonu aktualizovat a znovu nasadit.That way, you can change those values without having to update and redeploy the template. V případě scénářů, kde máte citlivé hodnoty parametrů, nebo musí být zabezpečené, jako jsou hesla a tajné kódy, můžete tyto hodnoty uložit v Azure Key Vault a nechat si soubory parametrů tyto hodnoty načíst.For scenarios where you have parameter values that are sensitive or must be secured, such as passwords and secrets, you can store those values in Azure Key Vault and have your parameters file retrieve those values. V těchto scénářích se však znovu nasadí, aby se načetly aktuální hodnoty.However, in these scenarios, you'd redeploy to retrieve the current values.

Tento přehled popisuje atributy v šabloně Správce prostředků, které obsahují definici pracovního postupu aplikace logiky.This overview describes the attributes in a Resource Manager template that includes a logic app workflow definition. Šablona i definice pracovního postupu používají syntaxi JSON, ale některé rozdíly existují, protože definice pracovního postupu také následuje po schématu jazyka definice pracovního postupu.Both the template and your workflow definition use JSON syntax, but some differences exist because the workflow definition also follows the Workflow Definition Language schema. Například výrazy šablony a výrazy definice pracovního postupu se liší v tom, jak odkazují na parametry a hodnoty, které mohou přijmout.For example, template expressions and workflow definition expressions differ in how they reference parameters and the values that they can accept.

Tip

Pro nejjednodušší způsob, jak získat platnou šablonu parametrizované aplikace logiky, která je většinou připravená pro nasazení, použijte Visual Studio (zdarma Community Edition nebo vyšší) a nástroje Azure Logic Apps pro Visual Studio.For the easiest way to get a valid parameterized logic app template that's mostly ready for deployment, use Visual Studio (free Community edition or greater) and the Azure Logic Apps Tools for Visual Studio. Pak můžete vytvořit aplikaci logiky v aplikaci Visual Studio nebo Najít a stáhnout existující aplikaci logiky z Azure do sady Visual Studio.You can then either create your logic app in Visual Studio or find and download an existing logic app from Azure into Visual Studio.

Nebo můžete vytvořit šablony aplikace logiky pomocí Azure PowerShell s modulem LogicAppTemplate.Or, you can create logic app templates by using Azure PowerShell with the LogicAppTemplate module.

Ukázková aplikace logiky v tomto tématu používá aktivační proceduru Office 365 Outlook , která se aktivuje při přijetí nového e-mailu, a akci Azure Blob Storage , která vytvoří objekt BLOB pro tělo e-mailu a nahraje tento objekt blob do kontejneru úložiště Azure.The example logic app in this topic uses an Office 365 Outlook trigger that fires when a new email arrives and an Azure Blob Storage action that creates a blob for the email body and uploads that blob to an Azure storage container. Příklady také ukazují, jak parametrizovat hodnoty, které se liší v nasazení.The examples also show how to parameterize values that vary at deployment.

Další informace o šablonách Správce prostředků najdete v těchto tématech:For more information about Resource Manager templates, see these topics:

Ukázkové šablony aplikací logiky najdete v těchto příkladech:For sample logic app templates, see these examples:

Informace o prostředcích šablon specifických pro Logic Apps, účty pro integraci a artefakty integračních účtů najdete v tématu typy prostředků Microsoft. Logic.For template resource information specific to logic apps, integration accounts, and integration account artifacts, see Microsoft.Logic resource types.

Struktura šablonTemplate structure

Na nejvyšší úrovni se Správce prostředků šablona řídí touto strukturou, která je plně popsána v tématu Azure Resource Manager struktura šablony a syntaxe :At the top level, a Resource Manager template follows this structure, which is fully described in the Azure Resource Manager template structure and syntax topic:

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

Pro šablonu aplikace logiky, primárně pracujete s těmito objekty šablony:For a logic app template, you primarily work with these template objects:

AtributAttribute PopisDescription
parameters Deklaruje parametry šablony pro přijetí hodnot, které se mají použít při vytváření a přizpůsobení prostředků pro nasazení v Azure.Declares the template parameters for accepting the values to use when creating and customizing resources for deployment in Azure. Tyto parametry například přijímají hodnoty pro název a umístění vaší aplikace logiky, připojení a další prostředky, které jsou nezbytné pro nasazení.For example, these parameters accept the values for your logic app's name and location, connections, and other resources necessary for deployment. Tyto hodnoty parametrů můžete uložit do souboru parametrů, který je popsán dále v tomto tématu.You can store these parameter values in a parameters file, which is described later in this topic. Obecné podrobnosti naleznete v tématu Parameters-správce prostředků Structure a syntax šablony.For general details, see Parameters - Resource Manager template structure and syntax.
resources Definuje prostředky pro vytvoření nebo aktualizaci a nasazení skupiny prostředků Azure, například vaší aplikace logiky, připojení, účtů Azure Storage atd.Defines the resources to create or update and deploy to an Azure resource group, such as your logic app, connections, Azure storage accounts, and so on. Obecné podrobnosti naleznete v tématu Resources-správce prostředků Structure a syntax šablony.For general details, see Resources - Resource Manager template structure and syntax.

Šablona vaší aplikace logiky používá tento formát názvu souboru:Your logic app template uses this file name format:

<Logic-App-name>. JSON<logic-app-name>.json

Důležité

Syntaxe šablony rozlišuje velká a malá písmena, takže se ujistěte, že používáte konzistentní použití velkých a malých písmen.Template syntax is case-sensitive so make sure that you use consistent casing.

Parametry šablonyTemplate parameters

Šablona aplikace logiky má více parameters objektů, které existují na různých úrovních a provádějí různé funkce.A logic app template has multiple parameters objects that exist at different levels and perform different functions. Například na nejvyšší úrovni můžete deklarovat parametry šablony pro hodnoty, které chcete přijmout a použít při nasazení při vytváření a nasazování prostředků v Azure, například:For example, at the top level, you can declare template parameters for the values to accept and use at deployment when creating and deploying resources in Azure, for example:

  • Vaše aplikace logikyYour logic app

  • Připojení, která vaše logika používá pro přístup k dalším službám a systémům prostřednictvím spravovaných konektorůConnections that your logic uses to access other services and systems through managed connectors

  • Další prostředky, které vaše aplikace logiky potřebuje k nasazeníOther resources that your logic app needs for deployment

    Například pokud vaše aplikace logiky používá integrační účet pro scénáře B2B (Business-to-Business), objekt parameters nejvyšší úrovně šablony deklaruje parametr, který přijímá ID prostředku pro tento účet integrace.For example, if your logic app uses an integration account for business-to-business (B2B) scenarios, the template's top-level parameters object declares the parameter that accepts the resource ID for that integration account.

Zde je obecná struktura a syntaxe pro definici parametru, která je plně popsána parametry-správce prostředků strukturou šablony a syntaxí:Here is the general structure and syntax for a parameter definition, which is fully described by Parameters - Resource Manager template structure and syntax:

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

Tento příklad ukazuje jenom parametry šablony pro hodnoty používané k vytvoření a nasazení těchto prostředků v Azure:This example shows just the template parameters for the values used to create and deploy these resources in Azure:

  • Název a umístění vaší aplikace logikyName and location for your logic app
  • ID, které se má použít pro účet pro integraci, který je propojený s aplikací logikyID to use for an integration account that's linked to the logic app
{
   "$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",
         "min length": 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": {}
}

S výjimkou parametrů, které zpracovávají citlivé hodnoty, nebo musí být zabezpečené, jako jsou uživatelská jména, hesla a tajné klíče, všechny tyto parametry zahrnují defaultValue atributy, i když v některých případech jsou výchozí hodnoty prázdné hodnoty.Except for parameters that handle values that are sensitive or must be secured, such as usernames, passwords, and secrets, all these parameters include defaultValue attributes, although in some cases, the default values are empty values. Hodnoty nasazení, které se mají použít pro tyto parametry šablony, jsou k dispozici v souboru ukázkových parametrů popsaných dále v tomto tématu.The deployment values to use for these template parameters are provided by the sample parameters file described later in this topic.

Chcete-li zabezpečit parametry šablony, přečtěte si tato témata:To secure template parameters, see these topics:

Jiné objekty šablon často odkazují na parametry šablony, aby mohli použít hodnoty, které předávají parametry šablony, například:Other template objects often reference template parameters so that they can use the values that pass through template parameters, for example:

  • Objekt prostředků šablony, popsaný dále v tomto tématu, definuje všechny prostředky v Azure, které chcete vytvořit a nasadit, například definici prostředků vaší aplikace logiky.Your template's resources object, described later in this topic, defines each resource in Azure that you want to create and deploy, such as your logic app's resource definition. Tyto prostředky často používají hodnoty parametrů šablony, jako je název a umístění aplikace logiky a informace o připojení.These resources often use template parameter values, such as your logic app's name and location and connection information.

  • V hlubší úrovni definice prostředků vaší aplikace logiky objekt parametrů definice pracovního postupu deklaruje parametry pro hodnoty, které se mají použít v modulu runtime vaší aplikace logiky.At a deeper level in your logic app's resource definition, your workflow definition's parameters object declares parameters for the values to use at your logic app's runtime. Můžete například deklarovat parametry definice pracovního postupu pro uživatelské jméno a heslo, které Trigger HTTP používá pro ověřování.For example, you can declare workflow definition parameters for the username and password that an HTTP trigger uses for authentication. Pokud chcete zadat hodnoty pro parametry definice pracovního postupu, použijte objekt parameters, který je mimo vaši definici pracovního postupu, ale ještě v definici prostředků vaší aplikace logiky.To specify the values for workflow definition parameters, use the parameters object that's outside your workflow definition but still inside your logic app's resource definition. V tomto vnějším parameters objekt můžete odkazovat na dříve deklarované parametry šablony, které mohou přijmout hodnoty při nasazení ze souboru parametrů.In this outer parameters object, you can reference previously declared template parameters, which can accept values at deployment from a parameters file.

Při odkazování na parametry používají výrazy šablony a funkce odlišnou syntaxi a chovají se jinak než výrazy a funkce definice pracovního postupu.When referencing parameters, template expressions and functions use different syntax and behave differently from workflow definition expressions and functions. Další informace o těchto rozdílech naleznete v části odkazy na parametry dále v tomto tématu.For more information about these differences, see References to parameters later in this topic.

Osvědčené postupy – parametry šablonyBest practices - template parameters

Tady je několik osvědčených postupů pro definování parametrů:Here are some best practices for defining parameters:

  • Deklarovat parametry pouze pro hodnoty, které se liší v závislosti na potřebách nasazení.Declare parameters only for values that vary, based on your deployment needs. Nedeklarujte parametry pro hodnoty, které zůstávají stejné napříč různými požadavky na nasazení.Don't declare parameters for values that stay the same across different deployment requirements.

  • Zahrňte atribut defaultValue, který může zadat prázdné hodnoty pro všechny parametry s výjimkou hodnot, které jsou citlivé nebo musí být zabezpečené.Include the defaultValue attribute, which can specify empty values, for all parameters except for values that are sensitive or must be secured. Pro uživatelská jména, hesla a tajné klíče vždy používejte zabezpečené parametry.Always use secured parameters for user names, passwords, and secrets. Pokud chcete skrýt nebo chránit citlivé hodnoty parametrů, postupujte podle pokynů v těchto tématech:To hide or protect sensitive parameter values, follow the guidance in these topics:

  • Chcete-li odlišit názvy parametrů šablony z názvů parametrů definice pracovního postupu, můžete použít názvy parametrů popisné šablony, například: TemplateFabrikamPasswordTo differentiate template parameter names from workflow definition parameter names, you can use descriptive template parameter names, for example: TemplateFabrikamPassword

Další doporučené postupy pro šablonu najdete v tématu osvědčené postupy pro parametry šablon.For more template best practices, see Best practices for template parameters.

Soubor parametrů šablonyTemplate parameters file

Chcete-li zadat hodnoty parametrů šablony, uložte tyto hodnoty do souboru parametrů.To provide the values for template parameters, store those values in a parameters file. Tímto způsobem můžete použít různé soubory parametrů v závislosti na potřebách nasazení.That way, you can use different parameters files based on your deployment needs. Tady je formát názvu souboru, který se má použít:Here is the file name format to use:

  • Název souboru šablony aplikace logiky: <Logic-App-Name>. JSONLogic app template file name: <logic-app-name>.json
  • Název souboru parametrů: <Logic-App-Name>. Parameters. JSONParameters file name: <logic-app-name>.parameters.json

Tady je struktura v souboru parametrů, která obsahuje odkaz na Trezor klíčů pro předání hodnoty zabezpečeného parametru s Azure Key Vault:Here is the structure inside the parameters file, which includes a key vault reference for passing a secure parameter value with 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>
   }
}

Tento příklad souboru parametrů určuje hodnoty pro parametry šablony deklarované dříve v tomto tématu:This example parameters file specifies the values for the template parameters declared earlier in this topic:

{
   "$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"
      }
   }
}

Prostředky šablonTemplate resources

Vaše šablona obsahuje objekt resources, což je pole, které obsahuje definice jednotlivých prostředků pro vytvoření a nasazení v Azure, jako je definice prostředků vaší aplikace logiky, všechny definice prostředků připojenía všechny další prostředky, které vaše aplikace logiky potřebuje k nasazení.Your template has a resources object, which is an array that contains definitions for each resource to create and deploy in Azure, such as your logic app's resource definition, any connection resource definitions, and any other resources that your logic app needs for deployment.

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

Poznámka

Šablony můžou zahrnovat definice prostředků pro několik aplikací logiky, takže se ujistěte, že všechny prostředky aplikace logiky určují stejnou skupinu prostředků Azure.Templates can include resource definitions for multiple logic apps, so make sure that all your logic app resources specify the same Azure resource group. Když nasadíte šablonu do skupiny prostředků Azure pomocí sady Visual Studio, zobrazí se výzva k zadání aplikace logiky, kterou chcete otevřít.When you deploy the template to an Azure resource group by using Visual Studio, you're prompted for which logic app that you want to open. Projekt skupiny prostředků Azure taky může obsahovat víc než jednu šablonu, takže po zobrazení výzvy vyberte správný soubor parametrů.Also, your Azure resource group project can contain more than one template, so make sure that you select the correct parameters file when prompted.

Obecné informace o prostředcích šablon a jejich atributech najdete v těchto tématech:For general information about template resources and their attributes, see these topics:

Definice prostředků aplikace logikyLogic app resource definition

Definice prostředků vaší aplikace logiky začíná objektem properties, který obsahuje tyto informace:Your logic app's resource definition starts with the properties object, which includes this information:

  • Stav vaší aplikace logiky při nasazeníYour logic app's state at deployment
  • ID pro libovolný účet pro integraci, který používá aplikace logikyThe ID for any integration account used by your logic app
  • Definice pracovního postupu vaší aplikace logikyYour logic app's workflow definition
  • Objekt parameters, který nastaví hodnoty, které se mají použít za běhuA parameters object that sets the values to use at runtime
  • Další informace o zdroji vaší aplikace logiky, jako je název, typ, umístění atd.Other resource information about your logic app, such as name, type, location, and so on
{
   "$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": {}
         },
         "name": "[parameters('LogicAppName')]", // Template parameter reference
         "type": "Microsoft.Logic/workflows",
         "location": "[parameters('LogicAppLocation')]", // Template parameter reference
         "tags": {
           "displayName": "LogicApp"
         },
         "apiVersion": "2016-06-01",
         "dependsOn": [
         ]
      }
      // End logic app resource definition
   ],
   "outputs": {}
}

Tady jsou atributy, které jsou specifické pro vaši definici prostředků aplikace logiky:Here are the attributes that are specific to your logic app resource definition:

AtributAttribute Požaduje seRequired TypType PopisDescription
state AnoYes ŘetězecString Stav vaší aplikace logiky při nasazení, kde Enabled znamená, že vaše aplikace logiky je živá a Disabled znamená, že vaše aplikace logiky je neaktivní.Your logic app's state at deployment where Enabled means your logic app is live and Disabled means that your logic app is inactive. Pokud například nejste připraveni k tomu, aby aplikace logiky byla v provozu, ale chcete nasadit koncept verze, můžete použít možnost Disabled.For example, if you're not ready for your logic app to go live but want to deploy a draft version, you can use the Disabled option.
integrationAccount NeNo ObjektObject Pokud vaše aplikace logiky používá účet pro integraci, který ukládá artefakty pro scénáře B2B (Business-to-Business), tento objekt zahrnuje atribut id, který určuje ID pro účet pro integraci.If your logic app uses an integration account, which stores artifacts for business-to-business (B2B) scenarios, this object includes the id attribute, which specifies the ID for the integration account.
definition AnoYes ObjektObject Základní definice pracovního postupu aplikace logiky, což je stejný objekt, který se zobrazuje v zobrazení kódu a je plně popsán v tématu Referenční dokumentace schématu pro jazyk definice pracovního postupu .Your logic app's underlying workflow definition, which is the same object that appears in code view and is fully described in the Schema reference for Workflow Definition Language topic. V této definici pracovního postupu objekt parameters deklaruje parametry pro hodnoty, které se mají použít při běhu aplikace logiky.In this workflow definition, the parameters object declares parameters for the values to use at logic app runtime. Další informace najdete v tématu definice a parametry pracovního postupu.For more information, see Workflow definition and parameters.

Chcete-li zobrazit atributy v definici pracovního postupu vaší aplikace logiky, přepněte z "zobrazení návrhu" na "zobrazení kódu" v Azure Portal nebo v aplikaci Visual Studio nebo pomocí nástroje, jako je například Azure Resource Explorer.To view the attributes in your logic app's workflow definition, switch from "design view" to "code view" in the Azure portal or Visual Studio, or by using a tool such as Azure Resource Explorer.

parameters NeNo ObjektObject Hodnoty parametrů definice pracovního postupu , které se mají použít v prostředí Logic App runtimeThe workflow definition parameter values to use at logic app runtime. Definice parametrů těchto hodnot se zobrazí uvnitř objektu parametrů definice pracovního postupu.The parameter definitions for these values appear inside your workflow definition's parameters object. Také Pokud vaše aplikace logiky používá spravované konektory pro přístup k jiným službám a systémům, tento objekt obsahuje objekt $connections, který nastaví hodnoty připojení, které se mají použít za běhu.Also, if your logic app uses managed connectors for accessing other services and systems, this object includes a $connections object that sets the connection values to use at runtime.
accessControl NeNo ObjektObject Pro zadání atributů zabezpečení pro vaši aplikaci logiky, jako je například omezení přístupu IP k aktivačním událostem žádosti nebo vstupy a výstupy historie spouštění.For specifying security attributes for your logic app, such as restricting IP access to request triggers or run history inputs and outputs. Další informace najdete v tématu zabezpečený přístup k Logic Apps.For more information, see Secure access to logic apps.

Informace o prostředcích šablon specifických pro Logic Apps, účty pro integraci a artefakty integračních účtů najdete v tématu typy prostředků Microsoft. Logic.For template resource information specific to logic apps, integration accounts, and integration account artifacts, see Microsoft.Logic resource types.

Definice a parametry pracovního postupuWorkflow definition and parameters

Definice pracovního postupu vaší aplikace logiky se zobrazí v objektu definition, který se zobrazí v objektu properties v definici prostředků vaší aplikace logiky.Your logic app's workflow definition appears in the definition object, which appears in the properties object inside your logic app's resource definition. Tento objekt definition je stejný objekt, který se zobrazí v zobrazení kódu a je plně popsán v tématu reference schématu pro jazyk definice pracovního postupu .This definition object is the same object that appears in code view and is fully described in the Schema reference for Workflow Definition Language topic. Definice pracovního postupu zahrnuje vnitřní objekt deklarace parameters, kde můžete definovat nové nebo upravit existující parametry pro hodnoty, které jsou používány vaší definicí pracovního postupu za běhu.Your workflow definition includes an inner parameters declaration object where you can define new or edit existing parameters for the values that are used by your workflow definition at runtime. Pak můžete odkazovat na tyto parametry uvnitř triggeru nebo akcí v pracovním postupu.You can then reference these parameters inside the trigger or actions in your workflow. Ve výchozím nastavení je tento objekt parameters prázdný, pokud aplikace logiky nevytváří připojení k jiným službám a systémům prostřednictvím spravovaných konektorů.By default, this parameters object is empty unless your logic app creates connections to other services and systems through managed connectors.

Pokud chcete nastavit hodnoty pro parametry definice pracovního postupu, použijte objekt parameters, který je mimo vaši definici pracovního postupu, ale ještě v definici prostředků vaší aplikace logiky.To set the values for workflow definition parameters, use the parameters object that's outside your workflow definition but still inside your logic app's resource definition. V tomto vnějším parameters objektu pak můžete odkazovat na dříve deklarované parametry šablony, které mohou přijmout hodnoty při nasazení ze souboru parametrů.In this outer parameters object, you can then reference your previously declared template parameters, which can accept values at deployment from a parameters file.

Tip

V souladu s osvědčeným postupem neodkazujte přímo na parametry šablony, které jsou vyhodnocovány při nasazení, a to v rámci definice pracovního postupu.As a best practice, don't directly reference template parameters, which are evaluated at deployment, from inside the workflow definition. Místo toho deklarujte parametr definice pracovního postupu, který pak můžete nastavit v objektu parameters, který je mimo vaši definici pracovního postupu, ale ještě v definici prostředků vaší aplikace logiky.Instead, declare a workflow definition parameter, which you can then set in the parameters object that's outside your workflow definition but still inside your logic app's resource definition. Další informace naleznete v tématu odkazy na parametry.For more information, see References to parameters.

Tato syntaxe ukazuje, kde můžete deklarovat parametry na úrovni šablony i definice pracovního postupu spolu s tím, kde můžete nastavit tyto hodnoty parametrů odkazem na parametry šablony a definice pracovního postupu:This syntax shows where you can declare parameters at both the template and workflow definition levels along with where you can set those parameter values by referencing the template and workflow definition parameters:

{
   "$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>": "[parameters('<template-parameter-name>')]"
            },
            "accessControl": {}
         },
         <other-logic-app-resource-definition-attributes>
      }
      // End logic app resource definition
   ],
   "outputs": {}
}

Parametry definice zabezpečeného pracovního postupuSecure workflow definition parameters

Pro parametr definice pracovního postupu, který zpracovává citlivé informace, hesla, přístupové klíče nebo tajné klíče za běhu, deklarujte nebo upravte parametr pro použití securestring nebo secureobject typu parametru.For a workflow definition parameter that handles sensitive information, passwords, access keys, or secrets at runtime, declare or edit the parameter to use the securestring or secureobject parameter type. Na tento parametr můžete odkazovat v rámci definice pracovního postupu.You can reference this parameter throughout and within your workflow definition. Na nejvyšší úrovni šablony deklarujte parametr, který má stejný typ pro zpracování těchto informací při nasazení.At the template's top level, declare a parameter that has the same type to handle this information at deployment.

Pokud chcete nastavit hodnotu parametru definice pracovního postupu, použijte objekt parameters, který je mimo vaši definici pracovního postupu, ale ještě v definici prostředků vaší aplikace logiky se odkazuje na parametr šablony.To set the value for the workflow definition parameter, use the parameters object that's outside your workflow definition but still inside your logic app resource definition to reference the template parameter. Nakonec, pokud chcete předat hodnotu parametru šablony při nasazení, uložte tuto hodnotu do Azure Key Vault a odkazujte na tento trezor klíčů v souboru parametrů , který je použit vaší šablonou při nasazení.Finally, to pass the value to your template parameter at deployment, store that value in Azure Key Vault and reference that key vault in the parameters file that's used by your template at deployment.

Tato příklad šablony ukazuje, jak můžete tyto úlohy dokončit definováním zabezpečených parametrů v případě potřeby, abyste mohli ukládat jejich hodnoty do Azure Key Vault:This example template shows how you can complete these tasks by defining secured parameters when necessary so that you can store their values in Azure Key Vault:

  • Deklarujete zabezpečené parametry pro hodnoty používané k ověření přístupu.Declare secure parameters for the values used to authenticate access.
  • Tyto hodnoty použijte jak na úrovni šablony, tak na úrovni definice pracovního postupu.Use these values at both the template and workflow definition levels.
  • Zadejte tyto hodnoty pomocí souboru parametrů.Provide these values by using a parameters file.

ŠablonaTemplate

{
   "$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": "[parameters('TemplateAuthenticationType')]", // Template parameter reference
               "fabrikamPassword": "[parameters('TemplateFabrikamPassword')]", // Template parameter reference
               "fabrikamUserName": "[parameters('TemplateFabrikamUserName')]" // Template parameter reference
            },
            "accessControl": {}
         },
         <other-logic-app-resource-attributes>
      }
      // End logic app resource definition
   ],
   "outputs": {}
}

Soubor parametrůParameters file

{
   "$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"
        }
     }
   }
}

Osvědčené postupy – parametry definice pracovního postupuBest practices - workflow definition parameters

Abyste se ujistili, že návrhář aplikace logiky může správně zobrazit parametry definice pracovního postupu, použijte tyto osvědčené postupy:To make sure that the Logic App Designer can correctly show workflow definition parameters, follow these best practices:

Další informace o parametrech definice pracovního postupu najdete v tématu parametry – jazyk definice pracovního postupu.For more information about workflow definition parameters, see Parameters - Workflow Definition Language.

Definice prostředků připojeníConnection resource definitions

Když aplikace logiky vytvoří a použije připojení k ostatním službám a systému pomocí spravovaných konektorů, objekt resources vaší šablony obsahuje definice prostředků pro tato připojení.When your logic app creates and uses connections to other services and system by using managed connectors, your template's resources object contains the resource definitions for those connections.

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

Definice prostředků připojení odkazují na parametry nejvyšší úrovně šablony pro jejich hodnoty, což znamená, že tyto hodnoty můžete zadat v nasazení pomocí souboru parametrů.Connection resource definitions reference the template's top-level parameters for their values, which means you can provide these values at deployment by using a parameters file. Zajistěte, aby připojení používala stejnou skupinu prostředků Azure a umístění jako vaše aplikace logiky.Make sure that connections use the same Azure resource group and location as your logic app.

Tady je příklad definice prostředků pro připojení Office 365 Outlook a odpovídajících parametrů šablony:Here is an example resource definition for an Office 365 Outlook connection and the corresponding template parameters:

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

Definice prostředků vaší aplikace logiky funguje také s definicemi prostředků připojení v těchto způsobech:Your logic app's resource definition also works with connection resource definitions in these ways:

  • V rámci definice pracovního postupu objekt parameters deklaruje $connections parametr pro hodnoty připojení, které se mají použít v prostředí Logic App runtime.Inside your workflow definition, the parameters object declares a $connections parameter for the connection values to use at logic app runtime. Aktivační událost nebo akce, která vytváří připojení, používá také odpovídající hodnoty, které přecházejí z tohoto parametru $connections.Also, the trigger or action that creates a connection uses the corresponding values that pass through this $connections parameter.

  • Mimo definici pracovního postupu, ale pořád i v definici prostředků vaší aplikace logiky, další objekt parameters nastaví hodnoty, které se mají použít za běhu pro $connections parametr odkazem na odpovídající parametry šablony.Outside your workflow definition but still inside your logic app's resource definition, another parameters object sets the values to use at runtime for the $connections parameter by referencing the corresponding template parameters. Tyto hodnoty pomocí výrazů šablony odkazují na prostředky, které bezpečně ukládají metadata pro připojení ve vaší aplikaci logiky.These values use template expressions to reference resources that securely store the metadata for the connections in your logic app.

    Metadata můžou například zahrnovat připojovací řetězce a přístupové tokeny, které můžete ukládat v Azure Key Vault.For example, metadata can include connection strings and access tokens, which you can store in Azure Key Vault. Chcete-li tyto hodnoty předat parametrům šablony, odkazujte na tento trezor klíčů v souboru parametrů , který je použit vaší šablonou při nasazení.To pass those values to your template parameters, you reference that key vault in the parameters file that's used by your template at deployment. Další informace o rozdílech v referenčních parametrech naleznete v tématu odkazy na parametry dále v tomto tématu.For more information about differences in referencing parameters, see References to parameters later in this topic.

    Když otevřete definici pracovního postupu aplikace logiky v zobrazení kód prostřednictvím Azure Portal nebo sady Visual Studio, objekt $connections se zobrazí mimo vaši definici pracovního postupu, ale na stejné úrovni.When you open your logic app's workflow definition in code view through the Azure portal or Visual Studio, the $connections object appears outside your workflow definition but at the same level. Toto řazení v zobrazení kódu usnadňuje odkazování těchto parametrů při ruční aktualizaci definice pracovního postupu:This ordering in code view makes these parameters easier to reference when you manually update the workflow definition:

    {
       "$connections": {<workflow-definition-parameter-connection-values-runtime},
       "definition": {<workflow-definition>}
    }
    
  • Definice prostředků vaší aplikace logiky obsahuje objekt dependsOn, který určuje závislosti na připojeních, která vaše aplikace logiky používá.Your logic app's resource definition has a dependsOn object that specifies the dependencies on the connections used by your logic app.

Každé vytvořené připojení má v Azure jedinečný název.Each connection that you create has a unique name in Azure. Když vytvoříte několik připojení ke stejné službě nebo systému, každý název připojení se připojí s číslem, které se zvýší u každého nového vytvořeného připojení, například office365, office365-1atd.When you create multiple connections to the same service or system, each connection name is appended with a number, which increments with each new connection created, for example, office365, office365-1, and so on.

Tento příklad ukazuje interakce mezi definicí prostředků vaší aplikace logiky a definicí prostředků připojení pro Office 365 Outlook:This example shows the interactions between your logic app's resource definition and a connection resource definition for 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": {}
}

Parametry zabezpečeného připojeníSecure connection parameters

Pro parametr připojení, který zpracovává citlivé informace, hesla, přístupové klíče a tajné kódy, zahrnuje definice prostředků připojení parameterValues objekt, který určuje tyto hodnoty ve formátu dvojice název-hodnota.For a connection parameter that handles sensitive information, passwords, access keys, or secrets, the connection's resource definition includes a parameterValues object that specifies these values in name-value pair format. Chcete-li skrýt tyto informace, můžete deklarovat nebo upravit parametry šablony pro tyto hodnoty pomocí typů parametrů securestring nebo secureobject.To hide this information, you can declare or edit the template parameters for these values by using the securestring or secureobject parameter types. Tyto informace pak můžete uložit v Azure Key Vault.You can then store that information in Azure Key Vault. Chcete-li tyto hodnoty předat parametrům šablony, odkazujte na tento trezor klíčů v souboru parametrů , který je použit vaší šablonou při nasazení.To pass those values to your template parameters, you reference that key vault in the parameters file that's used by your template at deployment.

Tady je příklad, který poskytuje název účtu a přístupový klíč pro připojení k Azure Blob Storage:Here is an example that provides the account name and access key for an Azure Blob Storage connection:

Soubor parametrůParameters file

{
   "$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"
         }
      }
   }
}

ŠablonaTemplate

{
   "$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": "2016-06-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": {}
}

Ověřování připojeníAuthenticate connections

Po nasazení aplikace logiky funguje na konci až po platné parametry.After deployment, your logic app works end-to-end with valid parameters. Přesto však musíte autorizovat všechna připojení OAuth pro vygenerování platných přístupových tokenů pro ověřování vašich přihlašovacích údajů.However, you must still authorize any OAuth connections to generate valid access tokens for authenticating your credentials. Další informace najdete v tématu autorizace připojení OAuth.For more information, see Authorize OAuth connections.

Některá připojení podporují použití instančního objektu služby Azure Active Directory (Azure AD) k autorizaci připojení pro aplikaci logiky, která je zaregistrovaná ve službě Azure AD.Some connections support using an Azure Active Directory (Azure AD) service principal to authorize connections for a logic app that's registered in Azure AD. Například tato definice prostředku Azure Data Lake připojení ukazuje, jak odkazovat na parametry šablony, které zpracovávají informace o instančním objektu a jak šablona deklaruje tyto parametry:For example, this Azure Data Lake connection resource definition shows how to reference the template parameters that handle the service principal's information and how the template declares these parameters:

Definice prostředků připojeníConnection resource definition

{
   <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')]"
      }
   }
}
AtributAttribute PopisDescription
token:clientId ID aplikace nebo klienta přidružené k vašemu objektu službyThe application or client ID associated with your service principal
token:clientSecret Hodnota klíče přidružená k objektu službyThe key value associated with your service principal
token:TenantId ID adresáře pro vašeho tenanta Azure ADThe directory ID for your Azure AD tenant
token:grantType Požadovaný typ udělení, který musí být client_credentials.The requested grant type, which must be client_credentials. Další informace najdete v tématu tok přihlašovacích údajů klienta Microsoft Identity Platform a OAuth 2,0.For more information, see Microsoft identity platform and the OAuth 2.0 client credentials flow.

Definice parametrů šablonyTemplate parameter definitions

Objekt parameters nejvyšší úrovně šablony deklaruje tyto parametry pro příklad připojení:The template's top-level parameters object declares these parameters for the example connection:

{
   "$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
}

Další informace o práci s instančními objekty najdete v těchto tématech:For more information about working with service principals, see these topics:

Odkazy na parametryReferences to parameters

Chcete-li odkazovat na parametry šablony, můžete použít výrazy šablony s funkcemi šablony, které jsou vyhodnocovány při nasazení.To reference template parameters, you can use template expressions with template functions, which are evaluated at deployment. Výrazy šablony používají hranaté závorky ( [] ):Template expressions use square brackets ([]):

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

Chcete-li odkazovat na parametry definice pracovního postupu, použijte výrazy a funkce jazyka definice pracovního postupu, které jsou vyhodnocovány za běhu.To reference workflow definition parameters, you use Workflow Definition Language expressions and functions, which are evaluated at runtime. Můžete si všimnout, že některé funkce šablon a funkce definice pracovního postupu mají stejný název.You might notice that some template functions and workflow definition functions have the same name. Výrazy definice pracovního postupu začínají symbolem "at" ( @ ):Workflow definition expressions start with the "at" symbol (@):

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

Hodnoty parametrů šablony můžete předat do definice pracovního postupu, aby se vaše aplikace logiky použila za běhu.You can pass template parameter values to your workflow definition for your logic app to use at runtime. Nepoužívejte však parametry šablony, výrazy a syntaxi v definici pracovního postupu, protože Návrhář aplikace logiky nepodporuje prvky šablony.However, avoid using template parameters, expressions, and syntax in your workflow definition because the Logic App Designer doesn't support template elements. Syntaxe šablony a výrazy mohou také zkomplikovat kód z důvodu rozdílů v době, kdy jsou výrazy vyhodnocovány.Also, template syntax and expressions can complicate your code due to differences in when expressions are evaluated.

Místo toho postupujte podle těchto obecných kroků k deklaraci a odkazování na parametry definice pracovního postupu, které se mají použít při spuštění, deklaraci a odkazování parametrů šablony pro použití při nasazení a určení hodnot, které se mají předat při nasazení, pomocí souboru parametrů.Instead, follow these general steps to declare and reference the workflow definition parameters to use at runtime, declare and reference the template parameters to use at deployment, and specify the values to pass in at deployment by using a parameters file. Úplné podrobnosti najdete v části definice a parametry pracovního postupu výše v tomto tématu.For full details, see the Workflow definition and parameters section earlier in this topic.

  1. Vytvořte šablonu a deklarujte parametry šablony pro hodnoty, které chcete přijmout a použít při nasazení.Create your template and declare the template parameters for the values to accept and use at deployment.

  2. V definici pracovního postupu deklarujte parametry pro hodnoty, které se mají přijmout a použít za běhu.In your workflow definition, declare the parameters for the values to accept and use at runtime. Pak můžete na tyto hodnoty odkazovat v rámci definice pracovního postupu a.You can then reference these values throughout and within your workflow definition.

  3. V objektu parameters, který je mimo vaši definici pracovního postupu, ale ještě v definici prostředků vaší aplikace logiky, nastavte hodnoty pro parametry definice pracovního postupu odkazem na odpovídající parametry šablony.In the parameters object that's outside your workflow definition but still inside your logic app's resource definition, set the values for your workflow definition parameters by referencing the corresponding template parameters. Tímto způsobem můžete hodnoty parametrů šablony předat do parametrů definice pracovního postupu.That way, you can pass template parameter values into your workflow definition parameters.

  4. V souboru parametrů zadejte hodnoty pro šablonu, která se má použít při nasazení.In the parameters file, specify the values for your template to use at deployment.

Úplný příklad šablonyFull example template

Tady je parametrizovaná vzorová šablona, kterou používají příklady tohoto tématu:Here is the parameterized sample template that's used by this topic's examples:

{
  "$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",
         "min length": 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": "2016-06-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": {}
}

Další krokyNext steps