Créer, modifier ou étendre JSON pour les définitions de flux de travail d’application logique dans Azure Logic Apps

Article
01/04/2024

S’applique à : Azure Logic Apps (Consommation)

Lorsque vous créez des solutions d’intégration d’entreprise avec des workflow automatisés dans Azure Logic Apps, les définitions de workflow sous-jacentes utilisent le JavaScript Object Notation (JSON) simple et déclarative avec le schéma Langue de la définition du workflow (WDL) pour leur description et validation. Ces formats simplifient la lecture et la compréhension des définitions de workflow sans en savoir beaucoup sur le code. Lorsque vous désirez automatiser la création et le déploiement des ressources d’applications logiques, vous pouvez inclure des définitions de workflow en tant que ressources Azure dans des modèles Azure Resource Manager. Pour créer, gérer et déployer des applications logiques, vous pouvez utiliser Azure PowerShell, Azure CLI ou les API REST Azure Logic Apps.

Pour utiliser des définitions de workflow dans JSON, ouvrez l’éditeur en mode Code lorsque vous travaillez dans le portail Azure ou dans Visual Studio ou copiez la définition dans tout éditeur de votre choix. Si vous débutez avec Azure Logic Apps, consultez Créer un exemple de workflow d’application logique Consommation.

Notes

Certaines fonctionnalités Azure Logic Apps, telle que la définition des paramètres et de plusieurs déclencheurs dans les définitions de workflow, sont uniquement disponibles dans JSON, et pas le concepteur de workflow. Par conséquent, pour ces tâches, vous devez travailler en mode Code ou sur un autre éditeur.

Modifier JSON - portail Azure

Connectez-vous au portail Azure.
Dans le menu de gauche, choisissez Tous les services. Dans la zone de recherche, rechercher « applications logiques », puis à partir des résultats, sélectionnez votre application logique.
Dans le menu de l’application logique, sous Outils de développement, choisissez Affichage du code de l’application logique.

L’éditeur Mode Code s’ouvre et affiche la définition de votre workflow au format JSON.

Modifier JSON - Visual Studio

Avant de pouvoir travailler sur la définition de votre workflow dans Visual Studio, assurez-vous d’avoir installé les outils requis. Pour créer une application logique avec Visual Studio, consultez Démarrage rapide : Automatiser des tâches et des processus avec Azure Logic Apps - Visual Studio.

Dans Visual Studio, vous pouvez ouvrir des applications logiques précédemment créées et déployées directement depuis le portail Azure ou en tant que projets Azure Resource Manager à partir de Visual Studio.

Ouvrez la solution Visual Studio ou le projet Azure Resource Manager, qui contient votre application logique.
Recherchez et ouvrez la définition de votre workflow, qui par défaut s’affiche dans un modèle Resource Manager, nommé LogicApp.json. Vous pouvez utiliser et personnaliser ce modèle pour le déploiement vers différents environnements.
Ouvrez le menu contextuel de la définition et du modèle de votre workflow. Sélectionnez Ouvrir avec le Concepteur d’application logique.

Conseil

Si vous ne voyez pas cette commande dans Visual Studio 2019, vérifiez que vous avez les dernières mises à jour pour Visual Studio.
En bas du concepteur de workflow, choisissez Mode Code.

L’éditeur Mode Code s’ouvre et affiche la définition de votre workflow au format JSON.
Pour revenir au mode concepteur, en bas de l’éditeur Mode Code, choisissez Conception.

Paramètres

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. Si vous souhaitez réutiliser des valeurs dans votre application logique sans codage en dur ou qui varient en fonction de vos besoins en matière de déploiement, vous pouvez créer un modèle Azure Resource Manager pour votre définition de flux de travail afin de pouvoir également automatiser le déploiement d’applications logiques.

Suivez ces étapes générales pour paramétrer, ou définir et utiliser des paramètres, pour ces valeurs à la place. Vous pouvez ensuite fournir les valeurs dans un fichier de paramètres distinct qui transmet ces valeurs à votre modèle. De cette façon, vous pouvez modifier ces valeurs plus facilement sans avoir à mettre à jour et à redéployer votre application logique. Pour obtenir tous les détails, consultez Vue d’ensemble : Automatiser le déploiement pour les applications logiques avec des modèles Azure Resource Manager.

Dans votre modèle, définissez les paramètres de modèle et les paramètres de définition de flux de travail pour accepter les valeurs à utiliser au moment du déploiement et de l’exécution, respectivement.

Les paramètres de modèle sont définis dans une section de paramètres en dehors de votre définition de flux de travail, tandis que les paramètres de définition de flux de travail sont définis dans une section de paramètres à l’intérieur de votre définition de flux de travail.
Remplacez les valeurs codées en dur par des expressions qui font référence à ces paramètres. Les expressions de modèle utilisent une syntaxe différente des expressions de définition de flux de travail.

Évitez de compliquer votre code en n’utilisant pas d’expressions de modèle, qui sont évaluées au moment du déploiement, à l’intérieur d’expressions de définition de flux de travail, qui sont évaluées au moment de l’exécution. Utilisez uniquement des expressions de modèle en dehors de votre définition de flux de travail. Utilisez uniquement des expressions de définition de flux de travail à l’intérieur de votre définition de flux de travail.

Lorsque vous spécifiez les valeurs de vos paramètres de définition de flux de travail, vous pouvez référencer des paramètres de modèle à l’aide de la section de paramètres en dehors de votre définition de flux de travail, mais toujours à l’intérieur de la définition de ressource pour votre application logique. 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.
Stockez les valeurs de vos paramètres dans un fichier de paramètres séparé et incluez ce fichier dans votre déploiement.

Traiter des chaînes avec des fonctions

Azure Logic Apps possède différentes fonctions permettant de manipuler des chaînes. Par exemple, supposons que vous souhaitiez transmettre un nom de société d’une commande à un autre système. Toutefois, vous n’êtes pas sûr de la gestion correcte du codage de caractères. Vous pouvez effectuer un codage base64 sur cette chaîne, mais pour éviter les séquences d’échappement dans l’URL, il est conseillé de remplacer plusieurs caractères. De même, vous avez uniquement besoin d’une substring du nom de la société, car les cinq premiers caractères ne sont pas utilisés.

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder1",
        "companyName": "NAME=Contoso"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "request": {
      "type": "Request",
      "kind": "Http"
    }
  },
  "actions": {
    "order": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "https://www.example.com/?id=@{replace(replace(base64(substring(parameters('order').companyName,5,sub(length(parameters('order').companyName), 5) )),'+','-') ,'/' ,'_' )}"
      }
    }
  },
  "outputs": {}
}

Les étapes suivantes décrivent la façon dont cet exemple traite cette chaîne, de l’intérieur vers l’extérieur :

"uri": "https://www.example.com/?id=@{replace(replace(base64(substring(parameters('order').companyName,5,sub(length(parameters('order').companyName), 5) )),'+','-') ,'/' ,'_' )}"

Obtenez l’élément length() pour le nom de la société afin de récupérer le nombre total de caractères.
Pour obtenir une chaîne plus courte, soustrayez 5.
Obtenez à présent un élément substring(). Commencez à l’index 5, puis passez au reste de la chaîne.
Nous convertissons cette sous-chaîne en une chaîne base64().
À présent, exécutez l’action replace() pour remplacer tous les caractères + par des caractères -.
Pour finir, exécutez l’action replace() pour remplacer tous les caractères / par des caractères _.

Mapper des éléments de liste aux valeurs de propriété, puis utiliser des mappages en tant que paramètres

Pour obtenir des résultats différents en fonction de la valeur d’une propriété, vous pouvez créer un mappage qui associe chaque valeur de propriété à un résultat, puis utiliser ce mappage en tant que paramètre.

Par exemple, ce flux de travail définit certaines catégories en tant que paramètres et un mappage qui associe ces catégories à une URL spécifique. Tout d’abord, le flux de travail obtient une liste d’articles. Ensuite, le flux de travail utilise le mappage pour rechercher l’URL correspondant à la catégorie de chaque article.

La fonction intersection() vérifie si la catégorie correspond à une catégorie définie connue.
Après avoir obtenu une catégorie correspondante, l’exemple extrait l’élément du mappage à l’aide de crochets : parameters[...]

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "specialCategories": {
      "defaultValue": [
        "science",
        "google",
        "microsoft",
        "robots",
        "NSA"
      ],
      "type": "Array"
    },
    "destinationMap": {
      "defaultValue": {
        "science": "https://www.nasa.gov",
        "microsoft": "https://www.microsoft.com/en-us/default.aspx",
        "google": "https://www.google.com",
        "robots": "https://en.wikipedia.org/wiki/Robot",
        "NSA": "https://www.nsa.gov/"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "Request": {
      "type": "Request",
      "kind": "http"
    }
  },
  "actions": {
    "getArticles": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "https://ajax.googleapis.com/ajax/services/feed/load?v=1.0&q=https://feeds.wired.com/wired/index"
      }
    },
    "forEachArticle": {
      "type": "foreach",
      "foreach": "@body('getArticles').responseData.feed.entries",
      "actions": {
        "ifGreater": {
          "type": "if",
          "expression": "@greater(length(intersection(item().categories, parameters('specialCategories'))), 0)",
          "actions": {
            "getSpecialPage": {
              "type": "Http",
              "inputs": {
                "method": "GET",
                "uri": "@parameters('destinationMap')[first(intersection(item().categories, parameters('specialCategories')))]"
              }
            }
          }
        }
      },
      "runAfter": {
        "getArticles": [
          "Succeeded"
        ]
      }
    }
  }
}

Obtenir des données avec des fonctions de date

Pour obtenir des données à partir d’une source de données qui ne prend pas en charge des déclencheurs en mode natif, vous pouvez utiliser des fonctions de date pour utiliser plutôt des heures et des dates. Par exemple, cette expression recherche la durée des étapes de ce flux de travail, de l’intérieur vers l’extérieur :

"expression": "@less(actions('order').startTime,addseconds(utcNow(),-1))",

Dans l’action order, extrayez l’élément startTime.
Obtenez l’heure en cours avec l’élément utcNow().
Soustrayez une seconde :

addseconds(..., -1)

Vous pouvez utiliser d’autres unités de temps, par exemple minutes ou hours.
À présent, vous pouvez comparer ces deux valeurs.

Si la première valeur est inférieure à la seconde, plus d’une seconde s’est écoulée depuis que la commande a été passée.

Pour mettre en forme les dates, vous pouvez utiliser des formateurs de chaîne. Par exemple, pour obtenir RFC1123, utilisez utcnow('r'). En savoir plus sur la mise en forme des dates.

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder-id"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "Request": {
      "type": "request",
      "kind": "http"
    }
  },
  "actions": {
    "order": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "https://www.example.com/?id=@{parameters('order').id}"
      }
    },
    "ifTimingWarning": {
      "type": "If",
      "expression": "@less(actions('order').startTime,addseconds(utcNow(),-1))",
      "actions": {
        "timingWarning": {
          "type": "Http",
          "inputs": {
            "method": "GET",
            "uri": "https://www.example.com/?recordLongOrderTime=@{parameters('order').id}&currentTime=@{utcNow('r')}"
          }
        }
      },
      "runAfter": {
        "order": [
          "Succeeded"
        ]
      }
    }
  },
  "outputs": {}
}

Étapes suivantes

Instructions conditionnelles : Exécuter des étapes en fonction d’une condition dans des applications logiques
Instructions switch : Exécuter différentes étapes en fonction de valeurs spécifiques
Loops: Process arrays or repeat actions until a condition is met (Boucles : Traiter des tableaux ou répéter des actions jusqu’à ce qu’une condition soit remplie)
Exécuter ou joindre des étapes (branches) parallèles
Étendues : Exécuter des étapes en fonction de l’état d’un groupe
En savoir plus sur le schéma du langage de définition du flux de travail pour Azure Logic Apps
En savoir plus sur les actions et déclencheurs de flux de travail pour Azure Logic Apps