Implémenter une démarche DevOps pour les Logic Apps dans Azure

La nouvelle approche des architectures modernes, et notamment la combinaison cloud et démarche DevOps, est devenue incontournable aujourd’hui. Elle apporte, en effet, plus de flexibilité à votre SI tout en diminuant le time to market indispensable pour les grands projets. Plus précisément, ces architectures modernes sont un ensemble de concepts et de modèles qui permettent de rendre les applications :

• plus rapides à implémenter,
• plus flexibles et élastiques,
• plus efficientes économiquement.

A travers cet article, je souhaite vous montrer pas à pas, comment déployer rapidement une ressource Logic App dans Azure avec une approche DevOps. En effet, il est important de déployer de façon uniforme votre Logic App  et ce quelque soit l’environnement, et de bien définir les variables de configuration.

Présentation du service Logic App

Avant d’entrer dans les détails, revenons sur ce que sont les Logic Apps. Ces derniers sont des ressources de type PaaS permettant l’intégration et l’orchestration de processus métiers ou techniques. Cette ressource est serverless, c’est-à-dire que vous n’avez pas à vous soucier de savoir quelle configuration matérielle choisir, Azure s’occupe de tout pour que le service réponde correctement en termes de temps d’exécution. De plus, quand on pense aux Logic Apps, il faut garder en tête deux choses : le workflow avec les actions possibles et les connecteurs :

• les connecteurs permettent d’interagir avec les autres composants de votre SI ou bien avec d’autres ressources Azure. Les plus connues sont Azure AD (Graph), Dynamics, Cosmos DB, Sharepoint online, etc. (Vous pouvez retrouver l’ensemble des connecteurs disponibles pour Logic App sur le site de Microsoft).
  
• la modélisation de votre workflow à travers une interface graphique sur laquelle vous ajoutez vos actions, manipulez les données à traiter et implémentez vos règles de gestion.

Dernier point, les Logic Apps historisent chacune de ses exécutions pour un meilleur suivi. Cela est utile à des fins de monitoring et de débogage.

Création de votre Logic App dans Visual Studio

1. Configuration de l’IDE

Dans Visual Studio, vous retrouverez le même éditeur visuel que celui disponible sur le portail Azure pour concevoir vos Logic Apps. Cela a l’immense avantage de pouvoir tester en local vos développements tout en bénéficiant du contrôle de code source (Git dans notre exemple).

Vous pouvez le télécharger depuis le menu d’extension de l’IDE ou bien depuis ce lien.

2. Création du projet Azure Resource Group

Maintenant, il faut créer un projet de type Azure Resource Group.

Ensuite, choisissez un template “Logic App” que vous souhaitez utiliser. Cela vous fera gagner du temps car Visual Studio crée une solution avec tous les fichiers nécessaires avec la bonne configuration.

Maintenant, vous disposez d’un projet sur lequel vous allez pouvoir travailler.

Nous avons donc ici :

• Deploy-AzureResourceGroup.ps1 : un script powershell pour déployer la Logic App dans le cloud.
• LogicApp.json : le template de la ressource au format JSON.
• LogicApp.parameters.json : les différents paramètres pouvant être appliqués au template LogicApp.json.

3. Développement de votre Logic App

Maintenant, 2 choix s’offrent à vous :

1. Créer from scratch la Logic App depuis le designer intégré à votre IDE
2. Importer une Logic App existante. Pour cela, il faut reprendre le JSON présent dans la “Logic App code view” et le coller dans le fichier “LogicApp.json”. Ainsi, pas besoin de recréer le composant !

4. Définir les paramètres

C’est ici qu’il faut bien avoir en tête les éléments qui vont être différents selon les environnements dans lesquels vous allez déployer le composant. Il faut bien penser aux URLs, chaînes de connexion, clés d’appels à l’API management (par exemple) qui peuvent changer.

Chaque paramètre doit être déclaré dans le fichier “*.parameters.json“. Voici un exemple avec les paramètres “Ocp-Apim-Subscription-Key” et “TenantName” :

{
     "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
     "contentVersion": "1.0.0.0",
     "parameters": {
         "Ocp-Apim-Subscription-Key": {
         "value": "enter a value here"
         },
     "TenantName": {
         "value": "untest@onmicrosoft.com"
      }
}

Ces paramètres seront réutilisés par la suite au niveau de la release definition (voir plus bas).

Configurer le pipeline DevOps dans VSTS (Visual Studio Team Services)

Maintenant que votre Logic App est terminée dans Visual Studio, vous pouvez utiliser VSTS pour avoir une logique DevOps. Ainsi, vous pourrez rapidement et de façon régulière déployer au plus tôt votre composant afin de le tester et bénéficier de feedbacks. Rappelez-vous bien que les composants doivent être déployés le plus tôt possible (environnement de développement par exemple) pour être testés et rapidement y apporter des corrections ou des améliorations.

1. Pousser votre code dans un projet VSTS

Maintenant, il faut associer votre code à un repository Git (par exemple) et le déployer dans VSTS :

• dans Visual studio, cliquez sur “Add to source control”
• une fois le repository Git créé, publiez-le sur votre projet d’équipe VSTS

• connectez-vous avec votre compte VSTS
• choisissez le domaine et le projet d’équipe (ou bien le créer au préalable)
• enfin, choisissez le repository name pour obtenir le résultat suivant :

• faites publish et le tour est joué, dans VSTS vous pouvez trouver votre code sous l’onglet adéquat :

2. Créer la définition de build

Première étape, il faut créer la build définition pour générer un artefact. Un artefact n’est autre que le résultat d’une build (dossier contenant les DLL par exemple) qui sera votre point de départ d’une release. Ici, il faut builder la solution créée précédemment. Pour cela dans VSTS :

• créez une nouvelle build definiton en allant sur l’onglet “Build and Release“
• cliquez sur “New”
• choisissez VSTS Git comme source

• choisissez maintenant de ne pas utiliser le template proposé car nous allons le faire (choisir empty process)
• cliquez sur “Phase 1” pour ajouter une action, choisir “Visual Studio Build” :

• ici, choisissez le projet que vous voulez builder, ie. le projet crée précédemment. Dans la partie Solution, choisir le sln correspondant
• ensuite, ajoutez une deuxième action de type “Publish Build artifacts“
• dans le “Path to publish“, sélectionnez le dossier contenant le projet
• donnez un nom a votre artifact ainsi qu’un publish location : Visual Studio Team Services/TFS. On obtient donc :

• sauvegardez et lancez un agent de build pour bénéficier d’un premier artefact.

3. Créer la définition de release

Une fois buildé, il faut maintenant déployer la Logic App avec des paramètres d’environnement. Il est important d’avoir un pipeline par composant qui doit s’installer sur l’ensemble des environnements que vous disposez, c’est-à-dire de l’environnement de développement à celui de production. Autre point important, dans DevOps, il faut veiller à toujours avoir un minimum d’artifact en entrée (dans la mesure du possible), un seul est l’idéal. En effet, il n’est pas nécessaire de redéployer tous les composants sur l’ensemble des environnements d’une part, et d’autre part cela permet de déployer plus rapidement et fréquemment.

• Créez une release definition vide (sans template).
• Sélectionnez l’artifact en entrée de chaîne, ie. celui issu de la build précédente.

• Ensuite, cliquez sur les actions de déploiement, ajouter une action de type “Azure Resource Group Deployment”.
• Saisissez toutes les informations nécessaires : nom du resource group, abonnement Azure, location, etc.
• Point important : bien sélectionner le template .json et le fichier de paramètres
  • Template : saisir où se trouve la Logic App dans le dossier contenant votre artifact LogicApp.json
  • Parameters : idem pour le fichier LogicApp.parameters.json

4. Saisir les paramètres d’environnement

Ici, il s’agit de définir les paramètres qui seront utilisés dans la Logic App et les séparer par environnement. La partie “Override parameters” permet de déclarer l’ensemble des paramètres qui seront utilisés par la Logic App. Il faut avoir en tête ces relations :

1. définition des paramètres dans la Logic App avec [parameters(‘nom de la variable’)
2. définition de ce paramètre dans le fichier paramètres : “*.parameters.json“
3. déclaration des variables au niveau de la release definition (onglet “variable” avec le nom de l’environnement)
4. utilisation de ces variables dans la release définition.

Vous pouvez mainenant déclarer vos variables dans l’onglet adéquat de VSTS. La colonne “Name” contient le nom du paramètre utilisé dans la release definition et la colonne “Value” contient réellement la valeur que vous voulez utiliser pour l’environnement donné, exemple :

Revenez dans la release definition, partie “Override template parameters“. VSTS vous affiche les variables qu’il a lu dans le fichier correspondant et vous propose de saisir des valeurs. Ici, vous pouvez, en effet, mettre ces informations en dur, mais il est préférable de faire référence à vos variables déclarées dans le fichier “*.parameters.json” et au niveau des variables du pipeline. On obtient donc :

Et voilà comment marier la méthodologie DevOps et les Logic Apps ! Le tour est joué ! Il ne vous reste plus qu’à sauvegarder la définition de release et à déployer sur chacun de vos environnements cibles.