Guide de référence du schéma du langage de définition de workflow dans Azure Logic AppsSchema reference guide for the Workflow Definition Language in Azure Logic Apps

Quand vous créez une application logique dans Azure Logic Apps, elle dispose d’une définition de flux de travail sous-jacente qui décrit la logique réelle qui s’exécute dans votre application logique.When you create a logic app in Azure Logic Apps, your logic app has an underlying workflow definition that describes the actual logic that runs in your logic app. Cette définition de flux de travail utilise JSON et suit une structure validée par le schéma de langage de définition de flux de travail.That workflow definition uses JSON and follows a structure that's validated by the Workflow Definition Language schema. Cette référence fournit une vue d’ensemble de cette structure et de la façon dont le schéma définit les attributs dans votre définition de flux de travail.This reference provides an overview about this structure and how the schema defines attributes in your workflow definition.

Structure d’une définition de flux de travailWorkflow definition structure

Une définition de flux de travail inclut toujours un déclencheur afin d’instancier votre application logique, ainsi qu’une ou plusieurs actions qui s’exécutent après le déclencheur.A workflow definition always includes a trigger for instantiating your logic app, plus one or more actions that run after the trigger fires.

Voici la structure de haut niveau d’une définition de flux de travail :Here is the high-level structure for a workflow definition:

"definition": {
  "$schema": "<workflow-definition-language-schema-version>",
  "actions": { "<workflow-action-definitions>" },
  "contentVersion": "<workflow-definition-version-number>",
  "outputs": { "<workflow-output-definitions>" },
  "parameters": { "<workflow-parameter-definitions>" },
  "staticResults": { "<static-results-definitions>" },
  "triggers": { "<workflow-trigger-definitions>" }
}
AttributAttribute ObligatoireRequired DescriptionDescription
definition OuiYes Élément de départ de votre définition de flux de travailThe starting element for your workflow definition
$schema Uniquement en cas de référence externe à une définition de flux de travailOnly when externally referencing a workflow definition Emplacement du fichier de schéma JSON qui décrit la version du langage de définition de flux de travail, que vous pouvez trouver ici :The location for the JSON schema file that describes the Workflow Definition Language version, which you can find here:

https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json

actions NonNo Définitions d’une ou plusieurs actions à exécuter lors de l’exécution du flux de travail.The definitions for one or more actions to execute at workflow runtime. Pour plus d’informations, consultez Déclencheurs et actions.For more information, see Triggers and actions.

Nombre maximal d'actions : 250Maximum actions: 250

contentVersion NonNo Numéro de version de votre définition de flux de travail (1.0.0.0 par défaut).The version number for your workflow definition, which is "1.0.0.0" by default. Pour identifier et vérifier plus facilement la définition correcte lors du déploiement d’un flux de travail, spécifiez une valeur à utiliser.To help identify and confirm the correct definition when deploying a workflow, specify a value to use.
outputs NonNo Les définitions des sorties à renvoyer lors de l’exécution d’un flux de travail.The definitions for the outputs to return from a workflow run. Pour plus d’informations, consultez la section Sorties.For more information, see Outputs.

Nombre maximal de sorties : 10Maximum outputs: 10

parameters NonNo Les définitions pour un ou plusieurs paramètres qui passent les valeurs à utiliser au moment de l’exécution de votre application logique.The definitions for one or more parameters that pass the values to use at your logic app's runtime. Pour plus d’informations, consultez Paramètres.For more information, see Parameters.

Nombre maximal de paramètres : 50Maximum parameters: 50

staticResults NonNo Définitions d’un ou plusieurs résultats statiques renvoyés par les actions comme sorties fictives lorsque des résultats statiques sont activés sur ces actions.The definitions for one or more static results returned by actions as mock outputs when static results are enabled on those actions. Dans chaque définition d’action, l’attribut runtimeConfiguration.staticResult.name fait référence à la définition correspondante dans staticResults.In each action definition, the runtimeConfiguration.staticResult.name attribute references the corresponding definition inside staticResults. Pour plus d’informations, consultez Résultats statiques.For more information, see Static results.
triggers NonNo Définitions d’un ou plusieurs déclencheurs qui instancient votre flux de travail.The definitions for one or more triggers that instantiate your workflow. Vous pouvez définir plus d’un déclencheur, mais uniquement avec le langage de définition de flux de travail (vous ne pouvez pas le faire visuellement via le Concepteur Logic Apps).You can define more than one trigger, but only with the Workflow Definition Language, not visually through the Logic Apps Designer. Pour plus d’informations, consultez Déclencheurs et actions.For more information, see Triggers and actions.

Nombre maximal de déclencheurs : 10Maximum triggers: 10

Déclencheurs et actionsTriggers and actions

Dans une définition de flux de travail, les sections triggers et actions définissent les appels qui se produisent pendant l’exécution de votre flux de travail.In a workflow definition, the triggers and actions sections define the calls that happen during your workflow's execution. Pour obtenir des informations supplémentaires sur ces sections et connaître la syntaxe à utiliser, consultez Déclencheurs et actions du flux de travail.For syntax and more information about these sections, see Workflow triggers and actions.

ParamètresParameters

Le cycle de vie du déploiement a généralement des environnements différents pour le développement, le test, la mise en lots et la production.The deployment lifecycle usually has different environments for development, test, staging, and production. Lorsque vous déployez des applications logiques dans différents environnements, vous souhaiterez probablement utiliser des valeurs différentes, telles que des chaînes de connexion, en fonction de vos besoins en matière de déploiement.When deploying logic apps to various environments, you likely want to use different values, such as connection strings, based on your deployment needs. Ou bien, vous pouvez avoir des valeurs que vous souhaitez réutiliser dans votre application logique sans codage en dur ou codes qui changent souvent.Or, you might have values that you want to reuse throughout your logic app without hardcoding or that change often. Dans la section parameters de votre définition de flux de travail, vous pouvez définir ou modifier des paramètres pour les valeurs que votre application logique utilise au moment de l’exécution.In your workflow definition's parameters section, you can define or edit parameters for the values that your logic app uses at runtime. Vous devez d’abord définir ces paramètres avant de pouvoir référencer ces paramètres ailleurs dans votre définition de flux de travail.You must define these parameters first before you can reference these parameters elsewhere in your workflow definition.

Voici la structure générale d’une définition de paramètre :Here is the general structure for a parameter definition:

"parameters": {
   "<parameter-name>": {
      "type": "<parameter-type>",
      "defaultValue": <default-parameter-value>,
      "allowedValues": [ <array-with-permitted-parameter-values> ],
      "metadata": {
         "description": "<parameter-description>"
      }
   }
},
AttributAttribute ObligatoireRequired TypeType DescriptionDescription
<parameter-name><parameter-name> OuiYes StringString Le nom du paramètre que vous voulez définirThe name for the parameter that you want to define
<parameter-type><parameter-type> OuiYes int, float, string, bool, array, object, securestring, secureobjectint, float, string, bool, array, object, securestring, secureobject

Remarque : Pour tous les mots de passe, les clés et les secrets, utilisez les types securestring et secureobject car l'opération GET ne renvoie pas ces types.Note: For all passwords, keys, and secrets, use the securestring or secureobject types because the GET operation doesn't return these types. Pour plus d’informations sur la sécurisation des paramètres, consultez Recommandations de sécurité pour les paramètres d’action et d’entrée.For more information about securing parameters, see Security recommendations for action and input parameters.

Type du paramètreThe type for the parameter
<default-parameter-value><default-parameter-value> OuiYes Identique à typeSame as type La valeur par défaut du paramètre quand aucune valeur n’est spécifiée lors de l’instanciation du flux de travail.The default parameter value to use if no value is specified when the workflow instantiates. L’attribut defaultValue est requis pour que le concepteur d’applications logiques puisse afficher correctement le paramètre, mais vous pouvez spécifier une valeur vide.The defaultValue attribute is required so that the Logic App Designer can correctly show the parameter, but you can specify an empty value.
<array-with-permitted-parameter-values><array-with-permitted-parameter-values> NonNo ArrayArray Tableau regroupant les valeurs que le paramètre peut accepterAn array with values that the parameter can accept
<parameter-description><parameter-description> NonNo Objet JSONJSON object Tous les autres détails des paramètres, tels que la description du paramètreAny other parameter details, such as a description for the parameter

Ensuite, créez un modèle Azure Resource Manager pour votre définition de flux de travail, définissez les paramètres de modèle qui acceptent les valeurs que vous souhaitez au moment du déploiement, remplacez les valeurs codées en dur par des références au modèle ou à la définition du flux de travail et stockez les valeurs à utiliser au moment du déploiement dans un fichier de paramètres distinct.Next, create an Azure Resource Manager template for your workflow definition, define template parameters that accept the values you want at deployment, replace hardcoded values with references to template or workflow definition parameters as appropriate, and store the values to use at deployment in a separate parameter file. De cette façon, vous pouvez modifier ces valeurs plus facilement par le biais du fichier de paramètres sans avoir à mettre à jour et à redéployer votre application logique.That way, you can change those values more easily through the parameter file without having to update and redeploy your logic app. Pour les informations 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 de votre coffre de clés.For information that is sensitive or must be secured, such as usernames, passwords, and secrets, you can store those values in Azure Key Vault and have your parameter file retrieve those values from your key vault. Pour plus d’informations et des exemples sur la définition des paramètres au niveau du modèle et de la définition du flux de travail, consultez Vue d’ensemble : Automatiser le déploiement pour les applications logiques avec des modèles Azure Resource Manager.For more information and examples about defining parameters at the template and workflow definition levels, see Overview: Automate deployment for logic apps with Azure Resource Manager templates.

Résultats statiquesStatic results

Dans l’attribut staticResults, définissez une sortie outputs et status fictives que l’action renvoie lorsque le paramètre de résultat statique de l’action est activé.In the staticResults attribute, define an action's mock outputs and status that the action returns when the action's static result setting is turned on. Dans la définition de l’action, l’attribut runtimeConfiguration.staticResult.name fait référence au nom de la définition de résultat statique dans staticResults.In the action's definition, the runtimeConfiguration.staticResult.name attribute references the name for the static result definition inside staticResults. Découvrez comment Tester des applications logiques avec des données fictives en configurant des résultats statiques.Learn how you can test logic apps with mock data by setting up static results.

"definition": {
   "$schema": "<...>",
   "actions": { "<...>" },
   "contentVersion": "<...>",
   "outputs": { "<...>" },
   "parameters": { "<...>" },
   "staticResults": {
      "<static-result-definition-name>": {
         "outputs": {
            <output-attributes-and-values-returned>,
            "headers": { <header-values> },
            "statusCode": "<status-code-returned>"
         },
         "status": "<action-status>"
      }
   },
   "triggers": { "<...>" }
}
AttributAttribute ObligatoireRequired TypeType DescriptionDescription
<static-result-definition-name><static-result-definition-name> OuiYes StringString Nom de la définition de résultat statique qu’une définition d’action peut référencer via un objet runtimeConfiguration.staticResult.The name for a static result definition that an action definition can reference through a runtimeConfiguration.staticResult object. Pour plus d’informations, consultez Paramètres de configuration d’exécution.For more information, see Runtime configuration settings.

Vous pouvez utiliser n’importe quel nom unique.You can use any unique name that you want. Par défaut, ce nom unique est ajouté avec un nombre, qui est incrémenté si nécessaire.By default, this unique name is appended with a number, which is incremented as necessary.

<output-attributes-and-values-returned><output-attributes-and-values-returned> OuiYes VariableVaries Les configurations requises pour ces attributs varient selon différentes conditions.The requirements for these attributes vary based on different conditions. Par exemple, lorsque l’attribut status est Succeeded, l’attribut outputs inclut les attributs et les valeurs renvoyées comme sorties fictives par l’action.For example, when the status is Succeeded, the outputs attribute includes attributes and values returned as mock outputs by the action. Si l’attribut status est Failed, l’attribut outputs inclut l’attribut errors, qui est un tableau avec un ou plusieurs objets message avec des informations erronées.If the status is Failed, the outputs attribute includes the errors attribute, which is an array with one or more error message objects that have error information.
<header-values><header-values> NonNo JSONJSON Toute valeur renvoyée par l’actionAny header values returned by the action
<status-code-returned><status-code-returned> OuiYes StringString Code d’état retourné par l’actionThe status code returned by the action
<action-status><action-status> OuiYes StringString État de l’action, par exemple, Succeeded ou FailedThe action's status, for example, Succeeded or Failed

Par exemple, dans la définition de l’action HTTP, l’attribut runtimeConfiguration.staticResult.name fait référence à HTTP0 dans l’attribut staticResults, où les sorties fictives de l’action sont définies.For example, in this HTTP action definition, the runtimeConfiguration.staticResult.name attribute references HTTP0 inside the staticResults attribute where the mock outputs for the action are defined. L’attribut runtimeConfiguration.staticResult.staticResultOptions spécifie le paramètre du résultat statique Enabled sur l’action HTTP.The runtimeConfiguration.staticResult.staticResultOptions attribute specifies that the static result setting is Enabled on the HTTP action.

"actions": {
   "HTTP": {
      "inputs": {
         "method": "GET",
         "uri": "https://www.microsoft.com"
      },
      "runAfter": {},
      "runtimeConfiguration": {
         "staticResult": {
            "name": "HTTP0",
            "staticResultOptions": "Enabled"
         }
      },
      "type": "Http"
   }
},

L’action HTTP retourne les sorties dans la définition HTTP0 dans staticResults.The HTTP action returns the outputs in the HTTP0 definition inside staticResults. Dans cet exemple, pour le code d’état, la sortie fictive est OK.In this example, for the status code, the mock output is OK. Pour les valeurs d’en-tête, la sortie fictive est "Content-Type": "application/JSON".For header values, the mock output is "Content-Type": "application/JSON". Pour l’état de l’action, la sortie fictive est Succeeded.For the action's status, the mock output is Succeeded.

"definition": {
   "$schema": "<...>",
   "actions": { "<...>" },
   "contentVersion": "<...>",
   "outputs": { "<...>" },
   "parameters": { "<...>" },
   "staticResults": {
      "HTTP0": {
         "outputs": {
            "headers": {
               "Content-Type": "application/JSON"
            },
            "statusCode": "OK"
         },
         "status": "Succeeded"
      }
   },
   "triggers": { "<...>" }
},

ExpressionsExpressions

Avec JSON, vous pouvez avoir des valeurs littérales qui existent au moment du design, par exemple :With JSON, you can have literal values that exist at design time, for example:

"customerName": "Sophia Owen",
"rainbowColors": ["red", "orange", "yellow", "green", "blue", "indigo", "violet"],
"rainbowColorsCount": 7

Vous pouvez également avoir des valeurs qui n’existent pas avant l’exécution.You can also have values that don't exist until run time. Pour représenter ces valeurs, vous pouvez utiliser des expressions, qui sont évaluées au moment de l’exécution.To represent these values, you can use expressions, which are evaluated at run time. Une expression est une séquence qui peut contenir un ou plusieurs opérateurs, fonctions, variables, valeurs explicites ou constantes.An expression is a sequence that can contain one or more functions, operators, variables, explicit values, or constants. Dans votre définition de flux de travail, vous pouvez utiliser une expression n’importe où dans une valeur de chaîne JSON en faisant précéder l’expression d’une arobase (@).In your workflow definition, you can use an expression anywhere in a JSON string value by prefixing the expression with the at-sign (@). Quand une expression qui représente une valeur JSON est évaluée, le corps de l’expression est extrait en supprimant le caractère @, et une autre valeur JSON est systématiquement générée.When evaluating an expression that represents a JSON value, the expression body is extracted by removing the @ character, and always results in another JSON value.

Par exemple, pour la propriété customerName définie précédemment, vous pouvez obtenir la valeur de la propriété en utilisant la fonction parameters() dans une expression de fonction et en assignant cette valeur à la propriété accountName :For example, for the previously defined customerName property, you can get the property value by using the parameters() function in an expression and assign that value to the accountName property:

"customerName": "Sophia Owen",
"accountName": "@parameters('customerName')"

L’interpolation de chaîne permet également d’utiliser plusieurs expressions placées entre le caractère @ et des accolades ({}) à l’intérieur d’une chaîne.String interpolation also lets you use multiple expressions inside strings that are wrapped by the @ character and curly braces ({}). Voici la syntaxe :Here is the syntax:

@{ "<expression1>", "<expression2>" }

Le résultat est toujours une chaîne, ce qui rend cette fonctionnalité similaire à la fonction concat(), par exemple :The result is always a string, making this capability similar to the concat() function, for example:

"customerName": "First name: @{parameters('firstName')} Last name: @{parameters('lastName')}"

Si vous avez une chaîne littérale qui commence par le caractère @, faites précéder le caractère @ d’un autre caractère @ faisant office de caractère d’échappement : @@If you have a literal string that starts with the @ character, prefix the @ character with another @ character as an escape character: @@

Ces exemples montrent comment les expressions sont évaluées :These examples show how expressions are evaluated:

Valeur JSONJSON value RésultatsResult
"Sophia Owen""Sophia Owen" Renvoie les caractères suivants : 'Sophia Owen'Return these characters: 'Sophia Owen'
"array[1]""array[1]" Renvoie ces caractères : « array[1] »Return these characters: 'array[1]'
"@@""@@" Renvoie ces caractères sous forme de chaîne de un caractère : « @ »Return these characters as a one-character string: '@'
" @"" @" Renvoie ces caractères sous forme de chaîne de deux caractères : « @ »Return these characters as a two-character string: ' @'

Pour ces exemples, supposons que vous définissiez "January" pour "myBirthMonth" et le nombre 42 pour "myAge" :For these examples, suppose you define "myBirthMonth" equal to "January" and "myAge" equal to the number 42:

"myBirthMonth": "January",
"myAge": 42

Ces exemples montrent comment les expressions suivantes sont évaluées :These examples show how the following expressions are evaluated:

Expression JSONJSON expression RésultatsResult
"@parameters('myBirthMonth')""@parameters('myBirthMonth')" Renvoie la chaîne suivante : "January"Return this string: "January"
"@{parameters('myBirthMonth')}""@{parameters('myBirthMonth')}" Renvoie la chaîne suivante : "January"Return this string: "January"
"@parameters('myAge')""@parameters('myAge')" Renvoie le nombre suivant : 42Return this number: 42
"@{parameters('myAge')}""@{parameters('myAge')}" Renvoie le nombre suivant sous forme de chaîne : "42"Return this number as a string: "42"
"My age is @{parameters('myAge')}""My age is @{parameters('myAge')}" Renvoie la chaîne suivante : "My age is 42"Return this string: "My age is 42"
"@concat('My age is ', string(parameters('myAge')))""@concat('My age is ', string(parameters('myAge')))" Renvoie la chaîne suivante : "My age is 42"Return this string: "My age is 42"
"My age is @@{parameters('myAge')}""My age is @@{parameters('myAge')}" Renvoie la chaîne suivante, qui inclut l'expression : "My age is @{parameters('myAge')}`Return this string, which includes the expression: "My age is @{parameters('myAge')}`

Quand vous travaillez visuellement dans le Concepteur Logic Apps, vous pouvez créer des expressions via le Générateur d’expressions, par exemple :When you're working visually in the Logic Apps Designer, you can create expressions through the Expression builder, for example:

Concepteur d’applications logiques > Générateur d’expressions

Quand vous avez terminé, l’expression apparaît pour la propriété correspondante dans votre définition de flux de travail, par exemple, la propriété searchQuery ici :When you're done, the expression appears for the corresponding property in your workflow definition, for example, the searchQuery property here:

"Search_tweets": {
  "inputs": {
    "host": {
      "connection": {
        "name": "@parameters('$connections')['twitter']['connectionId']"
      }
    }
  },
  "method": "get",
  "path": "/searchtweets",
  "queries": {
    "maxResults": 20,
    "searchQuery": "Azure @{concat('firstName','', 'LastName')}"
  }
},

OutputsOutputs

Dans la section outputs, définissez les données que votre flux de travail peut renvoyer une fois son exécution terminée.In the outputs section, define the data that your workflow can return when finished running. Par exemple, pour suivre un état ou une valeur spécifique à chaque exécution, spécifiez le renvoi de cette donnée par la sortie du flux de travail.For example, to track a specific status or value from each run, specify that the workflow output returns that data.

Notes

Pour la réponse à des requêtes entrantes à partir de l’API REST d’un service, n’utilisez pas outputs.When responding to incoming requests from a service's REST API, do not use outputs. Utilisez le type d’action Response à la place.Instead, use the Response action type. Pour plus d’informations, consultez Déclencheurs et actions du flux de travail.For more information, see Workflow triggers and actions.

Voici la structure générale d’une définition de sortie :Here is the general structure for an output definition:

"outputs": {
  "<key-name>": {
    "type": "<key-type>",
    "value": "<key-value>"
  }
}
AttributAttribute ObligatoireRequired TypeType DescriptionDescription
<key-name><key-name> OuiYes StringString Nom de la clé de la valeur renvoyée pour la sortieThe key name for the output return value
<key-type><key-type> OuiYes int, float, string, securestring, bool, array, objet JSONint, float, string, securestring, bool, array, JSON object Type de la valeur renvoyée pour la sortieThe type for the output return value
<key-value><key-value> OuiYes Identique à <key-type>Same as <key-type> Valeur renvoyée pour la sortieThe output return value

Pour obtenir la sortie d’une exécution de flux de travail, examinez l’historique et les détails des exécutions de votre application logique dans le portail Azure ou utilisez l’API REST de flux de travail.To get the output from a workflow run, review your logic app's run history and details in the Azure portal or use the Workflow REST API. Vous pouvez également transmettre la sortie à des systèmes externes, par exemple Power BI, afin de créer des tableaux de bord.You can also pass output to external systems, for example, Power BI so that you can create dashboards.

OpérateursOperators

Dans les expressions et les fonctions, les opérateurs effectuent des tâches spécifiques, telles que référencer une propriété ou une valeur dans un tableau.In expressions and functions, operators perform specific tasks, such as reference a property or a value in an array.

OpérateurOperator TâcheTask
'' Pour utiliser une chaîne littérale en tant qu’entrée ou dans des expressions et des fonctions, vous devez placer la chaîne uniquement entre des guillemets simples, par exemple, '<myString>'.To use a string literal as input or in expressions and functions, wrap the string only with single quotation marks, for example, '<myString>'. N’utilisez pas de guillemets doubles (""), qui entrent en conflit avec le formatage JSON autour d’une expression entière.Do not use double quotation marks (""), which conflict with the JSON formatting around an entire expression. Par exemple :For example:

Oui : length('Hello')Yes: length('Hello')
Non : length("Hello")No: length("Hello")

Quand vous transmettez des tableaux ou des nombres, vous n’avez pas besoin de les placer entre des signes de ponctuation.When you pass arrays or numbers, you don't need wrapping punctuation. Par exemple :For example:

Oui : length([1, 2, 3])Yes: length([1, 2, 3])
Non : length("[1, 2, 3]")No: length("[1, 2, 3]")

[][] Pour référencer une valeur à une position spécifique (index) dans un tableau, utilisez des crochets.To reference a value at a specific position (index) in an array, use square brackets. Par exemple, pour obtenir le deuxième élément d’un tableau :For example, to get the second item in an array:

myArray[1]

.. Pour référencer une propriété d’un objet, utilisez l’opérateur point.To reference a property in an object, use the dot operator. Par exemple, pour obtenir la propriété name d’un objet JSON customer :For example, to get the name property for a customer JSON object:

"@parameters('customer').name"

?? Pour référencer les propriétés Null d’un objet sans erreur d’exécution, utilisez l’opérateur point d’interrogation.To reference null properties in an object without a runtime error, use the question mark operator. Par exemple, pour gérer les sorties Null d’un déclencheur, vous pouvez utiliser cette expression :For example, to handle null outputs from a trigger, you can use this expression:

@coalesce(trigger().outputs?.body?.<someProperty>, '<property-default-value>')

FonctionsFunctions

Certaines expressions obtiennent leurs valeurs à partir d’actions runtime qui peuvent ne pas encore exister au début de l’exécution de votre définition de flux de travail.Some expressions get their values from runtime actions that might not yet exist when your workflow definition starts to run. Pour référencer ou utiliser ces valeurs dans des expressions, vous pouvez faire appel à des fonctions fournies par le Langage de définition de workflow.To reference or work with these values in expressions, you can use functions that the Workflow Definition Language provides.

Étapes suivantesNext steps