Présentation : Automatiser le déploiement pour le service Azure Logic Apps à l’aide de modèles Resource ManagerOverview: Automate deployment for Azure Logic Apps by using Azure Resource Manager templates

Lorsque vous êtes prêt à automatiser la création et le déploiement de votre application logique, vous pouvez développer la définition de flux de travail sous-jacente de votre application logique en un modèle 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. Ce modèle définit l’infrastructure, les ressources, les paramètres et d’autres informations pour l’approvisionnement et le déploiement de votre application logique.This template defines the infrastructure, resources, parameters, and other information for provisioning and deploying your logic app. En définissant des paramètres pour des valeurs qui varient lors du déploiement, opération également appelée paramétrage, vous pouvez déployer de façon répétée et cohérente des applications logiques en fonction de différents besoins de déploiement.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.

Par exemple, si vous déployez dans des environnements à des fins de développement, de test et de production, vous utiliserez probablement des chaînes de connexion différentes pour chaque environnement.For example, if you deploy to environments for development, test, and production, you likely use different connection strings for each environment. Vous pouvez déclarer des paramètres de modèle qui acceptent différentes chaînes de connexion, puis stocker celles-ci dans un fichier de paramètres séparé.You can declare template parameters that accept different connection strings and then store those strings in a separate parameters file. De cette façon, vous pouvez modifier ces valeurs sans avoir à mettre à jour et à redéployer le modèle.That way, you can change those values without having to update and redeploy the template. Pour les scénarios où vous avez des valeurs de paramètre sensibles ou qui doivent être sécurisées, telles que des mots de passe et des secrets, vous pouvez les stocker dans Azure Key Vault et faire en sorte que votre fichier de paramètres récupère ces valeurs.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. Cependant, dans ces scénarios, vous devez effectuer un redéploiement pour récupérer les valeurs actuelles.However, in these scenarios, you'd redeploy to retrieve the current values.

La présente vue d’ensemble décrit les attributs d’un modèle de Resource Manager incluant une définition de flux de travail d’application logique.This overview describes the attributes in a Resource Manager template that includes a logic app workflow definition. Tant le modèle que votre définition de flux de travail utilisent la syntaxe JSON, mais il existe des différences, car la définition de flux de travail suit également le schéma du Langage de définition du flux de travail.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. Par exemple, les expressions de modèle et les expressions de définition de flux de travail diffèrent par la manière dont elles font référence aux paramètres et par les valeurs qu’elles peuvent accepter.For example, template expressions and workflow definition expressions differ in how they reference parameters and the values that they can accept.

Conseil

La manière la plus simple d’obtenir un modèle d’application logique paramétré valide prêt pour le déploiement consiste à utiliser Visual Studio (version Community Edition gratuite ou version ultérieure) et les outils Azure Logic Apps pour 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. Vous pouvez ensuite créer votre application logique dans Visual Studio ou rechercher et télécharger une application logique existante d’Azure dans 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.

Vous pouvez également créer des modèles d’application logique en utilisant Azure PowerShell avec le module LogicAppTemplate.Or, you can create logic app templates by using Azure PowerShell with the LogicAppTemplate module.

L’exemple d’application logique présenté dans cette rubrique utilise un déclencheur Outlook Office 365 qui s’active lors de l’arrivée d’un nouvel e-mail, ainsi qu’une action de Stockage Blob Azure qui crée un blob pour le corps de l’e-mail et charge ce blob dans un conteneur de stockage 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. Les exemples montrent également comment paramétrer des valeurs qui varient lors du déploiement.The examples also show how to parameterize values that vary at deployment.

Pour plus d’informations sur les modèles Resource Manager, voir les rubriques suivantes :For more information about Resource Manager templates, see these topics:

Pour plus d’informations sur les ressources de modèle spécifiques pour les applications logiques, les comptes d’intégration, les artefacts de compte d’intégration et les environnements de service d’intégration, consultez Types de ressources Microsoft.Logic.For template resource information specific to logic apps, integration accounts, integration account artifacts, and integration service environments, see Microsoft.Logic resource types.

Pour des exemples de modèles d’applications logiques, voir :For sample logic app templates, see these examples:

Pour l’API REST Logic Apps, commencez par la Vue d’ensemble de l’API REST Azure Logic Apps.For the Logic Apps REST API, start with the Azure Logic Apps REST API overview.

Structure du modèleTemplate structure

Au niveau supérieur, un modèle Resource Manager suit cette structure entièrement décrite dans la rubrique Structure et syntaxe du modèle Azure Resource Manager :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": {}
}

Pour un modèle d’application logique, vous travaillez principalement avec les objets de modèle suivants :For a logic app template, you primarily work with these template objects:

AttributAttribute DescriptionDescription
parameters Déclare les paramètres de modèle pour l’acceptation des valeurs à utiliser lors de la création et de la personnalisation des ressources pour un déploiement vers Azure.Declares the template parameters for accepting the values to use when creating and customizing resources for deployment in Azure. Par exemple, ces paramètres acceptent les valeurs du nom et de l’emplacement de votre application logique, des connexions et des autres ressources nécessaires au déploiement.For example, these parameters accept the values for your logic app's name and location, connections, and other resources necessary for deployment. Vous pouvez stocker ces valeurs de paramètre dans un fichier de paramètres décrit plus loin dans cette rubrique.You can store these parameter values in a parameters file, which is described later in this topic. Pour plus de détails, voir Paramètres – Structure et syntaxe de modèle Resource Manager.For general details, see Parameters - Resource Manager template structure and syntax.
resources Définit les ressources à créer ou mettre à jour, ainsi qu’à déployer vers un groupe de ressources Azure, telles que votre application logique, vos connexions, vos comptes de stockage Azure, etc.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. Pour des détails généraux, voir Ressources – Structure et syntaxe de modèle Resource Manager.For general details, see Resources - Resource Manager template structure and syntax.

Votre modèle d’application logique utilise le format de nom de fichier suivant :Your logic app template uses this file name format:

<nom-application-logique>. Json<logic-app-name>.json

Important

La syntaxe du modèle respectant la casse, veillez à utiliser une casse cohérente.Template syntax is case-sensitive so make sure that you use consistent casing.

Paramètres de modèleTemplate parameters

Un modèle d’application logique comporte plusieurs objets parameters existant à différents niveaux et exécutant différentes fonctions.A logic app template has multiple parameters objects that exist at different levels and perform different functions. Par exemple, au niveau supérieur, vous pouvez déclarer des paramètres de modèle pour les valeurs à accepter et à utiliser lors de la création et du déploiement de ressources dans Azure, par exemple :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:

  • Votre application logiqueYour logic app

  • Connexions que votre logique utilise pour accéder à d’autres services et systèmes via des Connecteurs managésConnections that your logic uses to access other services and systems through managed connectors

  • Autres ressources dont votre application logique a besoin pour le déploiementOther resources that your logic app needs for deployment

    Par exemple, si votre application logique utilise un compte d’intégration pour les scénarios interentreprises (B2B), l’objet parameters de niveau supérieur du modèle déclare le paramètre qui accepte l’ID de ressource pour ce compte d’intégration.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.

Voici la structure et la syntaxe générales d’une définition de paramètre, qui sont décrites en détail dans Paramètres – Structure et syntaxe de modèle Resource Manager :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>"
   }
},

Cet exemple présente uniquement les paramètres de modèle applicables aux valeurs utilisées pour créer et déployer ces ressources dans Azure :This example shows just the template parameters for the values used to create and deploy these resources in Azure:

  • Nom et emplacement de votre application logiqueName and location for your logic app
  • ID à utiliser pour un compte d’intégration lié à l’application logiqueID 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",
         "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": {}
}

À l’exception des paramètres qui traitent des valeurs sensibles ou qui doivent être sécurisées, tels que des noms d’utilisateur, mots de passe ou secrets, tous ces paramètres incluent des attributs defaultValue, même si, dans certains cas, les valeurs par défaut sont vides.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. Les valeurs de déploiement à utiliser pour ces paramètres de modèle sont fournies par l’exemple de fichier de paramètres décrit plus loin dans cette rubrique.The deployment values to use for these template parameters are provided by the sample parameters file described later in this topic.

Pour plus d’informations sur la sécurisation des paramètres de modèle, consultez les rubriques suivantes :For more information about securing template parameters, see these topics:

D’autres objets de modèle référencent souvent des paramètres de modèle afin de pouvoir utiliser les valeurs transmises par des paramètres de modèle, par exemple :Other template objects often reference template parameters so that they can use the values that pass through template parameters, for example:

  • L’objet de ressources de votre modèle décrit plus loin dans cette rubrique définit chaque ressource dans Azure, que vous pouvez créer et déployer, telle que la définition de ressource de votre application logique.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. Ces ressources utilisent souvent des valeurs de paramètre de modèle, telles que le nom et l’emplacement de votre application logique, ainsi que des informations de connexion.These resources often use template parameter values, such as your logic app's name and location and connection information.

  • À un niveau plus profond dans la définition de ressource de votre application logique, l’objet de paramètres de votre définition de flux de travail déclare des paramètres pour les valeurs à utiliser lors de l’exécution de votre application logique.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. Par exemple, vous pouvez déclarer des paramètres de définition de flux de travail pour le nom d’utilisateur et le mot de passe qu’un déclencheur HTTP utilise pour l’authentification.For example, you can declare workflow definition parameters for the username and password that an HTTP trigger uses for authentication. Pour spécifier les valeurs pour des paramètres de définition de flux de travail, utilisez l’objet parameters qui est en dehors de votre définition de flux de travail mais toujours à l’intérieur de la définition de ressource de votre application logique.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. Dans cet objet parameters externe, vous pouvez référencer des paramètres de modèle précédemment déclarés, qui peuvent accepter des valeurs lors du déploiement à partir d’un fichier de paramètres.In this outer parameters object, you can reference previously declared template parameters, which can accept values at deployment from a parameters file.

Lors du référencement des paramètres, les expressions et fonctions de modèle utilisent une syntaxe différente et se comportent différemment des expressions et fonctions de définition de flux de travail.When referencing parameters, template expressions and functions use different syntax and behave differently from workflow definition expressions and functions. Pour plus d’informations sur ces différences, voir Références aux paramètres plus loin dans cette rubrique.For more information about these differences, see References to parameters later in this topic.

Meilleures pratiques – Paramètres de modèleBest practices - template parameters

Voici quelques meilleures pratiques pour la définition de paramètres :Here are some best practices for defining parameters:

  • Déclarez des paramètres uniquement pour des valeurs qui varient, en fonction de vos besoins de déploiement.Declare parameters only for values that vary, based on your deployment needs. Ne déclarez pas de paramètres pour des valeurs qui ne changent pas en fonction des différentes exigences de déploiement.Don't declare parameters for values that stay the same across different deployment requirements.

  • Incluez l’attribut defaultValue, qui peut spécifier des valeurs vides, pour tous les paramètres, à l’exception des valeurs sensibles ou qui doivent être sécurisées.Include the defaultValue attribute, which can specify empty values, for all parameters except for values that are sensitive or must be secured. Utilisez toujours des paramètres sécurisés pour les noms d’utilisateur, mots de passe et secrets.Always use secured parameters for user names, passwords, and secrets. Pour masquer ou protéger les valeurs de paramètres sensibles, suivez les instructions des rubriques suivantes :To hide or protect sensitive parameter values, follow the guidance in these topics:

  • Pour différencier les noms de paramètre de modèle des noms de paramètre de définition de flux de travail, vous pouvez utiliser des noms de paramètre de modèle descriptifs, par exemple : TemplateFabrikamPasswordTo differentiate template parameter names from workflow definition parameter names, you can use descriptive template parameter names, for example: TemplateFabrikamPassword

Pour d’autres meilleures pratiques en lien avec les modèles, voir Meilleures pratiques pour les paramètres de modèle.For more template best practices, see Best practices for template parameters.

Fichier de paramètres de modèleTemplate parameters file

Pour fournir les valeurs des paramètres de modèle, stockez ces valeurs dans un fichier de paramètres.To provide the values for template parameters, store those values in a parameters file. De cette façon, vous pouvez utiliser différents fichiers de paramètres en fonction de vos besoins de déploiement.That way, you can use different parameters files based on your deployment needs. Voici le format de nom de fichier à utiliser :Here is the file name format to use:

  • Nom de fichier de modèle d’application logique : <nom-application-logique>.jsonLogic app template file name: <logic-app-name>.json
  • Nom de fichier de paramètres : <nom-application-logique>.parameters.jsonParameters file name: <logic-app-name>.parameters.json

Voici la structure interne du fichier de paramètres, qui inclut une référence de coffre de clés pour transmettre une valeur de paramètre sécurisée avec Azure Key Vault :Here is the structure inside the parameters file, which includes a key vault reference for passing a secured 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>
   }
}

Cet exemple de fichier de paramètres spécifie les valeurs des paramètres de modèle déclarés précédemment dans cette rubrique :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"
      }
   }
}

Ressources de modèleTemplate resources

Votre modèle inclut un objet resources qui est un tableau contenant des définitions de chaque ressource à créer et à déployer dans Azure, telles que la définition de ressource de votre application logique, les définitions de ressources de connexion, ainsi que toutes les autres ressources nécessaires au déploiement de votre application logique.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, 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": {}
}

Notes

Des modèles pouvant inclure des définitions de ressources pour plusieurs applications logiques, assurez-vous que toutes vos ressources d’application logique spécifient le même groupe de ressources 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. Lorsque vous déployez le modèle sur un groupe de ressources Azure à l’aide de Visual Studio, vous êtes invité à indiquer l’application logique que vous voulez ouvrir.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. Par ailleurs, votre projet de groupe de ressources Azure pouvant contenir plusieurs modèles, veillez à sélectionner le fichier de paramètres approprié lorsque vous y êtes invité.Also, your Azure resource group project can contain more than one template, so make sure that you select the correct parameters file when prompted.

Afficher les définitions de ressourcesView resource definitions

Pour passer en revue les définitions de toutes les ressources d’un groupe de ressources Azure, téléchargez votre application logique dans Visual Studio à partir d’Azure, qui est le moyen le plus simple de créer un modèle d’application logique paramétré valide et dans l’ensemble prêt à être déployé.To review the resource definitions for all the resources in an Azure resource group, download your logic app from Azure into Visual Studio, which is the easiest way to create a valid parameterized logic app template that's mostly ready for deployment.

Pour des informations générales sur les ressources de modèle et leurs attributs, voir les rubriques suivantes :For general information about template resources and their attributes, see these topics:

Définition de ressource d’application logiqueLogic app resource definition

La définition de ressource de flux de travail dans un modèle de votre application logique commence par l’objet properties qui contient les informations suivantes :Your logic app's workflow resource definition in a template starts with the properties object, which includes this information:

  • État de votre application logique lors du déploiementYour logic app's state at deployment
  • ID de tout compte d’intégration utilisé par votre application logiqueThe ID for any integration account used by your logic app
  • Définition de flux de travail de votre application logiqueYour logic app's workflow definition
  • Objet parameters qui définit les valeurs à utiliser lors de l’exécutionA parameters object that sets the values to use at runtime
  • Autres informations de ressources concernant votre application logique, telles que le nom, le type, l’emplacement, les paramètres de configuration du runtime, etc.Other resource information about your logic app, such as name, type, location, any runtime configuration settings, 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": {},
            "runtimeConfiguration": {}
         },
         "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": {}
}

Voici les attributs spécifiques de la définition de ressource de votre application logique :Here are the attributes that are specific to your logic app resource definition:

AttributAttribute ObligatoireRequired TypeType DescriptionDescription
state OuiYes StringString État de votre application logique lors du déploiement, où Enabled signifie que votre application logique est active et Disabled signifie qu’elle est inactive.Your logic app's state at deployment where Enabled means your logic app is live and Disabled means that your logic app is inactive. Par exemple, si vous n’êtes pas prêt à mettre en ligne votre application logique mais souhaitez déployer une version brouillon, vous pouvez utiliser l’option 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 NonNo ObjectObject Si votre application logique utilise un compte d’intégration qui stocke des artefacts pour des scénarios interentreprises (B2B), cet objet inclut l’attribut id qui spécifie l’ID du compte d’intégration.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 OuiYes ObjectObject Définition de flux de travail sous-jacent de votre application logique, qui est l’objet qui s’affiche en mode Code et qui est décrit en détail dans la rubrique Référence de schéma pour le langage de définition de flux de travail.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. Dans cette définition de flux de travail, l’objet parameters déclare des paramètres pour les valeurs à utiliser lors de l’exécution de l’application logique.In this workflow definition, the parameters object declares parameters for the values to use at logic app runtime. Pour plus d’informations, voir Définition et paramètres de flux de travail.For more information, see Workflow definition and parameters.

Pour afficher les attributs dans la définition de flux de travail de votre application logique, passez du « mode Création » au « mode Code » dans le portail Azure ou Visual Studio, ou en vous servant d’un outil tel qu’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 NonNo ObjectObject Valeurs de paramètre de définition de flux de travail à utiliser lors de l’exécution d’une application logique.The workflow definition parameter values to use at logic app runtime. Les définitions de paramètre de ces valeurs apparaissent dans l’objet de paramètres de votre définition de flux de travail​​.The parameter definitions for these values appear inside your workflow definition's parameters object. De plus, si votre application logique utilise des connecteurs managés pour accéder à d’autres services et systèmes, cet objet inclut un objet $connections qui définit les valeurs de connexion à utiliser lors de l’exécution.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 NonNo ObjectObject Utilisé pour spécifier des attributs de sécurité pour votre application logique, tels qu’une restriction d’accès IP aux déclencheurs de demandes ou aux entrées et sorties de l’historique d’exécution.For specifying security attributes for your logic app, such as restricting IP access to request triggers or run history inputs and outputs. Pour plus d’informations, voir Accès sécurisé aux applications logiques.For more information, see Secure access to logic apps.
runtimeConfiguration NonNo ObjectObject Pour spécifier des propriétés operationOptions qui contrôlent le comportement de votre application logique au moment de l’exécution.For specifying any operationOptions properties that control the way that your logic app behaves at run time. Par exemple, vous pouvez exécuter votre application logique en mode de débit élevé.For example, you can run your logic app in high throughput mode.

Pour plus d’informations sur les définitions de ressources pour ces objets Logic Apps, consultez Types de ressources Microsoft.Logic :For more information about resource definitions for these Logic Apps objects, see Microsoft.Logic resource types:

Définition et paramètres de flux de travailWorkflow definition and parameters

La définition de flux de travail de votre application logique apparaît dans l’objet definition qui apparaît dans l’objet properties dans la définition de ressource de votre application logique.Your logic app's workflow definition appears in the definition object, which appears in the properties object inside your logic app's resource definition. Cet objet definition est celui qui s’affiche en mode Code et qui est décrit en détail dans la rubrique Référence de schéma pour le langage de définition de flux de travail.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. Votre définition de flux de travail inclut un objet de déclaration parameters interne dans lequel vous pouvez définir de nouveaux paramètres ou modifier des paramètres existants pour les valeurs utilisées par votre définition de flux de travail au moment de l’exécution.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. Vous pouvez ensuite référencer ces paramètres dans le déclencheur ou des actions dans votre flux de travail.You can then reference these parameters inside the trigger or actions in your workflow. Par défaut, cet objet parameters est vide, à moins que votre application logique crée des connexions à d’autres services et systèmes via des connecteurs managés.By default, this parameters object is empty unless your logic app creates connections to other services and systems through managed connectors.

Pour définir les valeurs pour des paramètres de définition de flux de travail, utilisez l’objet parameters qui est en dehors de votre définition de flux de travail mais toujours à l’intérieur de la définition de ressource de votre application logique.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. Dans cet objet parameters externe, vous pouvez ensuite référencer vos paramètres de modèle précédemment déclarés, qui peuvent accepter des valeurs lors du déploiement à partir d’un fichier de paramètres.In this outer parameters object, you can then reference your previously declared template parameters, which can accept values at deployment from a parameters file.

Conseil

En tant que meilleure pratique, ne référencez pas des paramètres de modèle qui sont évalués lors du déploiement, directement à partir de la définition de flux de travail.As a best practice, don't directly reference template parameters, which are evaluated at deployment, from inside the workflow definition. Au lieu de cela, déclarez un paramètre de définition de flux de travail que vous pouvez ensuite définir dans l’objet parameters qui est en dehors de votre définition de flux de travail mais toujours à l’intérieur de la définition de ressource de votre application logique.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. Pour plus d’informations, voir Références aux paramètres.For more information, see References to parameters.

Cette syntaxe indique où vous pouvez déclarer des paramètres aux niveaux de définition de modèle et de flux de travail, ainsi que où vous pouvez définir ces valeurs de paramètre en référençant les paramètres de modèle et de définition de flux de travail :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>": { 
                  "value": "[parameters('<template-parameter-name>')]"
               }
            },
            "accessControl": {}
         },
         <other-logic-app-resource-definition-attributes>
      }
      // End logic app resource definition
   ],
   "outputs": {}
}

Paramètres de définition du flux de travail sécuriséSecure workflow definition parameters

Pour un paramètre de définition de flux de travail qui traite des informations sensibles, des mots de passe, des clés d’accès ou des secrets lors de l’exécution, déclarez ou modifiez le paramètre pour utiliser le type de paramètre securestring ou secureobject.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. Vous pouvez référencer ce paramètre dans votre définition de flux de travail.You can reference this parameter throughout and within your workflow definition. Au niveau supérieur du modèle, déclarez un paramètre du même type pour gérer ces informations lors du déploiement.At the template's top level, declare a parameter that has the same type to handle this information at deployment.

Pour définir la valeur pour le paramètre de définition de flux de travail, utilisez l’objet parameters qui est en dehors de votre définition de flux de travail mais toujours à l’intérieur de la définition de ressource de votre application logique pour référencer le paramètre de modèle.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. Enfin, pour transmettre la valeur à votre paramètre de modèle lors du déploiement, stockez-la dans Vault Key Azure et référencez ce coffre de clés dans le fichier de paramètres utilisé par votre modèle lors du déploiement.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.

Cet exemple de modèle montre comment accomplir ces tâches en définissant des paramètres sécurisés lorsque cela est nécessaire pour pouvoir stocker leurs valeurs dans 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:

  • Déclarez des paramètres sécurisés pour les valeurs utilisées pour authentifier l’accès.Declare secured parameters for the values used to authenticate access.
  • Utilisez ces valeurs aux niveaux de définition de modèle et de flux de travail.Use these values at both the template and workflow definition levels.
  • Fournissez ces valeurs à l’aide d’un fichier de paramètres.Provide these values by using a parameters file.

ModèleTemplate

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

Fichier de paramètresParameters 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"
        }
     }
   }
}

Meilleures pratiques – Paramètres de définition de flux de travailBest practices - workflow definition parameters

Pour vous assurer que le Concepteur d’application logique peut afficher correctement les paramètres de définition de flux de travail, suivez les meilleures pratiques suivantes :To make sure that the Logic App Designer can correctly show workflow definition parameters, follow these best practices:

Pour plus d’informations sur les paramètres de définition de flux de travail, voir Paramètres – Langage de définition du flux de travail.For more information about workflow definition parameters, see Parameters - Workflow Definition Language.

Définitions de ressources de connexionConnection resource definitions

Lorsque votre application logique crée et utilise des connexions à d’autres services et système à l’aide de connecteurs managés, l’objet resources de votre modèle contient les définitions de ressources pour ces connexions.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. Bien que vous ayez créé des connexions à partir d’une application logique, les connexions sont des ressources Azure distinctes avec leurs propres définitions de ressource.Although you create connections from within a logic app, connections are separate Azure resources with their own resource definitions. Pour passer en revue ces définitions de ressources de connexion, téléchargez votre application logique dans Visual Studio à partir d’Azure, qui est le moyen le plus simple de créer un modèle d’application logique paramétré valide et dans l’ensemble prêt à être déployé.To review these connection resource definitions, download your logic app from Azure into Visual Studio, which is the easiest way to create a valid parameterized logic app template that's mostly ready 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": {}
}

Les définitions de ressources de connexion font référence aux paramètres de niveau supérieur du modèle pour leurs valeurs, donc vous pouvez fournir ces valeurs lors du déploiement à l’aide d’un fichier de paramètres.Connection resource definitions reference the template's top-level parameters for their values so you can provide these values at deployment by using a parameters file. Assurez-vous que les connexions utilisent les mêmes groupe de ressources et emplacement Azure que votre application logique.Make sure that connections use the same Azure resource group and location as your logic app.

Voici un exemple de définition de ressource pour une connexion Outlook Office 365 et les paramètres de modèle correspondants :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": {}
}

La définition de ressource de votre application logique fonctionne également avec des définitions de ressources de connexion des manières suivantes :Your logic app's resource definition also works with connection resource definitions in these ways:

  • Dans votre définition de flux de travail, l’objet parameters déclare un paramètre $connections pour les valeurs de connexion à utiliser lors de l’exécution de l’application logique.Inside your workflow definition, the parameters object declares a $connections parameter for the connection values to use at logic app runtime. De plus, le déclencheur ou l’action qui créent une connexion utilisent les valeurs correspondantes que ce paramètre $connections transmet.Also, the trigger or action that creates a connection uses the corresponding values that pass through this $connections parameter.

  • En dehors de votre définition de flux de travail mais toujours à l’intérieur de la définition de ressource de votre application logique, un autre objet parameters définit les valeurs à utiliser lors de l’exécution pour le paramètre $connections en faisant référence aux paramètres de modèle correspondants.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. Ces valeurs utilisent des expressions de modèle pour référencer des ressources qui stockent en toute sécurité les métadonnées pour les connexions dans votre application logique.These values use template expressions to reference resources that securely store the metadata for the connections in your logic app.

    Par exemple, les métadonnées peuvent inclure des chaînes de connexion et jetons d’accès que vous pouvez stocker dans Azure Key Vault.For example, metadata can include connection strings and access tokens, which you can store in Azure Key Vault. Pour transmettre ces valeurs à vos paramètres de modèle, vous référencez ce coffre de clés dans le fichier de paramètres utilisé par votre modèle lors du déploiement.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. Pour plus d’informations sur les différences de référencement de paramètres, voir Références aux paramètres plus loin dans cette rubrique.For more information about differences in referencing parameters, see References to parameters later in this topic.

    Lorsque vous ouvrez la définition de flux de travail de votre application logique en mode Code dans le portail Azure ou Visual Studio, l’objet $connections apparaît en dehors de votre définition de flux de travail, mais au même niveau.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. Cette commande en mode Code facilite le référencement de ces paramètres lorsque vous mettez à jour manuellement la définition de flux de travail :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>}
    }
    
  • La définition de ressource de votre application logique contient un objet dependsOn qui spécifie les dépendances des connexions utilisées par votre application logique.Your logic app's resource definition has a dependsOn object that specifies the dependencies on the connections used by your logic app.

Chaque connexion que vous créez a un nom unique dans Azure.Each connection that you create has a unique name in Azure. Lorsque vous créez plusieurs connexions au même service ou système, un nombre est ajouté à chaque nom de connexion, qui est incrémenté à chaque nouvelle connexion créée, par exemple, office365, office365-1, etc.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.

Cet exemple montre les interactions entre la définition de ressource de votre application logique et une définition de ressource de connexion pour 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": {}
}

Paramètres de connexion sécuriséeSecure connection parameters

Pour un paramètre de connexion qui traite des informations sensibles, des mots de passe, des clés d’accès ou des secrets, la définition de ressource de la connexion inclut un objet parameterValues spécifiant ces valeurs dans un format de paire nom-valeur.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. Pour masquer ces informations, vous pouvez déclarer ou modifier les paramètres de modèle pour ces valeurs en utilisant les types de paramètres securestring ou secureobject.To hide this information, you can declare or edit the template parameters for these values by using the securestring or secureobject parameter types. Vous pouvez ensuite stocker ces informations dans Azure Key Vault .You can then store that information in Azure Key Vault. Pour transmettre ces valeurs à vos paramètres de modèle, vous référencez ce coffre de clés dans le fichier de paramètres utilisé par votre modèle lors du déploiement.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.

Voici un exemple fournissant le nom du compte et la clé d’accès pour une connexion de Stockage Blob Azure :Here is an example that provides the account name and access key for an Azure Blob Storage connection:

Fichier de paramètresParameters 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"
         }
      }
   }
}

ModèleTemplate

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

Authentifiez les connexionsAuthenticate connections

Après le déploiement, votre application logique fonctionne de bout en bout avec des paramètres valides.After deployment, your logic app works end-to-end with valid parameters. Toutefois, vous devez encore autoriser les connexions OAuth à générer des jetons d’accès valides pour l’authentification de vos informations d’identification.However, you must still authorize any OAuth connections to generate valid access tokens for authenticating your credentials. Pour plus d’informations, voir Autoriser des connexions OAuth.For more information, see Authorize OAuth connections.

Certaines connexions prennent en charge l’utilisation d’un principal de service Azure Active Directory (Azure AD) pour autoriser les connexions d’une application logique inscrite dans 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. Par exemple, cette définition de ressource de connexion Azure Data Lake montre comment référencer les paramètres de modèle qui gèrent les informations du principal de service, et comment le modèle déclare ces paramètres :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:

Définition de ressource de connexionConnection 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')]"
      }
   }
}
AttributAttribute DescriptionDescription
token:clientId Application ou ID client associés à votre principal de serviceThe application or client ID associated with your service principal
token:clientSecret Valeur de clé associée à votre principal de serviceThe key value associated with your service principal
token:TenantId ID de répertoire de votre locataire Azure ADThe directory ID for your Azure AD tenant
token:grantType Type d’autorisation demandée, qui doit être client_credentials.The requested grant type, which must be client_credentials. Pour plus d’informations, voir Plateforme d’identités Microsoft et flux d’informations d’identification du client OAuth 2.0.For more information, see Microsoft identity platform and the OAuth 2.0 client credentials flow.

Définitions de paramètre de modèleTemplate parameter definitions

L’objet parameters de niveau supérieur du modèle déclare ces paramètres pour l’exemple de connexion :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
}

Pour plus d’informations sur l’utilisation des principaux de service, voir les rubriques suivantes :For more information about working with service principals, see these topics:

Références aux paramètresReferences to parameters

Pour référencer des paramètres de modèle, vous pouvez utiliser des expressions de modèle avec des fonctions de modèle qui sont évaluées lors du déploiement.To reference template parameters, you can use template expressions with template functions, which are evaluated at deployment. Les expressions de modèle utilisent des crochets ([]) :Template expressions use square brackets ([]):

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

Pour référencer des paramètres de définition de flux de travail, vous utilisez des expressions et fonctions du Langage de définition du flux de travail, qui sont évaluées au moment de l’exécution.To reference workflow definition parameters, you use Workflow Definition Language expressions and functions, which are evaluated at runtime. Vous remarquerez peut-être que certaines fonctions de modèle et fonctions de définition de flux de travail portent le même nom.You might notice that some template functions and workflow definition functions have the same name. Les expressions de définition de flux de travail commencent par le symbole d’arobase ( @ ) :Workflow definition expressions start with the "at" symbol (@):

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

Vous pouvez transmettre des valeurs de paramètre de modèle à votre définition de flux de travail pour que votre application logique puisse les utiliser au moment de l’exécution.You can pass template parameter values to your workflow definition for your logic app to use at runtime. Cependant, évitez d’utiliser des paramètres, des expressions et une syntaxe de modèle dans la définition de votre flux de travail, car le Concepteur d’application logique ne prend pas en charge les éléments de modèle.However, avoid using template parameters, expressions, and syntax in your workflow definition because the Logic App Designer doesn't support template elements. Par ailleurs, une syntaxe et des expressions de modèle peuvent compliquer votre code en raison de différences entre les moments où les expressions sont évaluées.Also, template syntax and expressions can complicate your code due to differences in when expressions are evaluated.

Suivez plutôt ces étapes générales pour déclarer et référencer les paramètres de définition de flux de travail à utiliser lors de l’exécution, déclarer et référencer les paramètres de modèle à utiliser lors du déploiement, et spécifier les valeurs à transmettre lors du déploiement à l’aide d’un fichier de paramètres.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. Pour plus de détails, voir la section Définition et paramètres de flux de travail plus haut dans cette rubrique.For full details, see the Workflow definition and parameters section earlier in this topic.

  1. Créez votre modèle et déclarez les paramètres de modèle pour les valeurs à accepter et à utiliser lors du déploiement.Create your template and declare the template parameters for the values to accept and use at deployment.

  2. Dans votre définition de flux de travail, déclarez les paramètres des valeurs à accepter et à utiliser lors de l’exécution.In your workflow definition, declare the parameters for the values to accept and use at runtime. Vous pouvez ensuite référencer ces valeurs dans votre définition de flux de travail.You can then reference these values throughout and within your workflow definition.

  3. Dans l’objet parameters qui est en dehors de votre définition de flux de travail mais toujours à l’intérieur de la définition de ressource de votre application logique, définissez les valeurs des paramètres de définition de votre flux de travail en référençant les paramètres de modèle correspondants.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. De cette façon, vous pouvez transmettre les valeurs de paramètre de modèle dans les paramètres de définition de votre flux de travail.That way, you can pass template parameter values into your workflow definition parameters.

  4. Dans le fichier de paramètres, spécifiez les valeurs de votre modèle à utiliser lors du déploiement.In the parameters file, specify the values for your template to use at deployment.

Exemple de modèle completFull example template

Voici l’exemple de modèle paramétré utilisé dans les exemples de cette rubrique :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",
         "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": "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": {}
}

Étapes suivantesNext steps