Exercice : Déployer un workflow Azure Logic Apps de base à l’aide d’un modèle ARM

Effectué

Dans cette unité, nous déployons un workflow dans Azure Logic Apps à l’aide d’un modèle Azure Resource Manager.

Création de ressources dans Azure

Habituellement, nous créons d’abord un groupe de ressources destiné à contenir tous les éléments que nous devons créer. Un groupe de ressources nous aide à administrer l’ensemble des machines virtuelles, disques, interfaces réseau et autres éléments qui composent notre solution.

Nous pouvons créer un groupe de ressources avec la commande Azure CLI az group create. Cette commande prend un --name pour communiquer un nom de groupe de ressources unique dans notre abonnement. La commande prend également un --location pour communiquer la région Azure par défaut pour les ressources.

Toutefois, nous utilisons l’environnement de bac à sable Azure gratuit. Vous n’avez donc pas besoin de créer un groupe de ressources. Au lieu de cela, vous pouvez utiliser le groupe de ressources créé précédemment [nom du groupe de ressources bac à sable] dans cet exercice.

Télécharger et examiner un modèle Resource Manager de base

1. En haut de la fenêtre Cloud Shell, sélectionnez l’icône Plus (...), puis sélectionnez Paramètres>Accéder à la version classique.

2. À partir de Cloud Shell, exécutez la commande curl suivante pour télécharger le modèle à partir de GitHub :

   curl https://raw.githubusercontent.com/MicrosoftDocs/mslearn-logic-apps-and-arm-templates/master/basic-template/template.json > basic-template.json
   

3. Pour afficher le modèle, ouvrez-le dans l’éditeur intégré :

   code basic-template.json
   

   La définition du workflow d’application logique décrite dans template.json est indiquée dans la description suivante :

   {
       "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
       "contentVersion": "1.0.0.0",
       "parameters": {},
       "variables": {},
       "resources": [
           {
               "type": "Microsoft.Logic/workflows",
               "apiVersion": "2017-07-01",
               "name": "HelloLogicAppsTemplate",
               "location": "westus2",
               "properties": {
                   "state": "Enabled",
                   "definition": {
                       "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
                       "contentVersion": "1.0.0.0",
                       "parameters": {},
                       "triggers": {
                           "manual": {
                               "type": "Request",
                               "kind": "Http",
                               "inputs": {
                                   "method": "GET",
                                   "schema": {}
                               }
                           }
                       },
                       "actions": {
                           "Response": {
                               "runAfter": {},
                               "type": "Response",
                               "kind": "Http",
                               "inputs": {
                                   "body": "Hello Logic Apps Template!",
                                   "statusCode": 200
                               }
                           }
                       },
                       "outputs": {}
                   },
                   "parameters": {}
               }
           }
       ],
       "outputs": {
           "logicAppUrl": {
              "type": "string",
              "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
           }
        }
   }
   

   Comme le montre la définition JSON précédente et le suggère le nom du modèle, ce workflow d’application logique est basique. Examinons les principaux composants de cette application.

   Dans l’extrait de code suivant, nous voyons que l’application se nomme HelloLogicAppsTemplate. Ce nom est codé en dur dans le modèle. L’emplacement auquel l’application s’exécute est également codé en dur en westus2.

   "name": "HelloLogicAppsTemplate",
   "location": "westus2",
   

   En faisant défiler vers le bas jusqu’à la section triggers, nous constatons que le workflow est déclenché avec une requête HTTP GET. Le déclencheur est nommé manual.

   "triggers": {
       "manual": {
           "type": "Request",
           "kind": "Http",
           "inputs": {
               "method": "GET",
               "schema": {}
           }
       }
   },
   

   Plus bas, dans la section actions, nous constatons que ce workflow contient une étape ou action. Cette action répond à la requête avec le message Hello Azure Logic Apps Template!.

   "actions": {
       "Response": {
           "runAfter": {},
           "type": "Response",
           "kind": "Http",
           "inputs": {
               "body": "Hello Logic Apps Template!",
               "statusCode": 200
           }
       }
   },
   

   La section sorties du modèle Resource Manager a une seule sortie appelée logicAppUrl. Cette variable de sortie reprend l’URL de la ressource de l’application logique déployée. Cette URL facilite le test de l’application. La sortie utilise listCallbackURL pour créer l’URL, mais le nom du workflow et le nom du déclencheur sont tous deux codés en dur ici.

   "outputs": {
       "logicAppUrl": {
          "type": "string",
          "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
       }
    }
   

   Nous allons maintenant déployer cette application logique et la tester.

Valider et déployer le modèle

Pour déployer notre ressource d’application logique, nous allons utiliser la commande az deployment group create, car nous effectuons le déploiement sur groupe de ressources. Quand vous réalisez un déploiement à l’aide de cette commande, vous pouvez choisir de déployer un modèle à distance en spécifiant son emplacement avec le paramètre --template-uri. Dans notre cas, comme nous souhaitons déployer le modèle que nous avons localement, nous allons définir le paramètre --template-file.

1. À partir de Cloud Shell, exécutez az deployment group validate pour valider le modèle :

   az deployment group validate \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" \
   --template-file basic-template.json
   

   L’argument --template-file pointe vers le modèle local. Le nom de fichier du modèle est basic-template.json.

   Vous verrez un grand bloc de code JSON comme sortie, qui indique que le modèle a été validé.

   Azure Resource Manager renseigne les paramètres du modèle et vérifie que le modèle s’exécute correctement dans votre abonnement.

   Si la validation a échoué, vous verrez une description détaillée de l’échec dans la sortie.

2. Exécutez la commande az deployment group create suivante dans Cloud Shell pour déployer la ressource d’application logique définie par notre modèle de base sur notre groupe de ressources de bac à sable :

   az deployment group create \
   --name MyDeployment \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" \
   --template-file basic-template.json
   

   Cette commande ressemble à la commande précédente, mais inclut l’argument --name pour donner un nom à votre déploiement.

   L’exécution de cette commande prend deux à trois minutes. Une fois le déploiement terminé, vous verrez un autre grand bloc de code JSON comme sortie qui décrit le déploiement. Vous verrez provisioningState dans le résultat JSON avec la valeur Succeeded.

Vérifier le déploiement

1. Exécutez az deployment group show pour vérifier le déploiement :

   az deployment group show \
   --name MyDeployment \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" 
   

   Vous voyez le même bloc JSON que celui que vous avez vu précédemment. Vous pouvez exécuter cette commande ultérieurement si vous avez besoin de ces détails sur le déploiement. La sortie est structurée en JSON pour l’exploiter plus facilement dans d’autres outils que vous pouvez utiliser pour suivre vos déploiements et votre utilisation du cloud.

2. Pour voir l’application en action, recherchez la valeur logicAppUrl dans le résultat JSON. Sélectionnez l’URL, ou copiez-la et collez-la dans une nouvelle fenêtre de navigateur. La page affiche le message Hello Azure Logic Apps Template!, comme indiqué dans la capture d’écran suivante :

   

Félicitations ! Vous avez déployé avec succès un workflow d’application logique à l’aide d’un modèle Azure Resource Manager.

Comme nous l’avons noté dans cet exercice, le modèle de base possède de nombreuses valeurs codées en dur. Ces valeurs rendent le modèle moins souple que nous le voudrions. Nous pouvons améliorer la situation en utilisant des paramètres.