Exercice - Ajouter une phase de prévisualisation à votre pipeline

• 3 minutes

Vous voulez ajouter une phase supplémentaire à votre pipeline afin de pouvoir vérifier les modifications qui seront apportées à votre environnement Azure.

Pendant ce processus, vous allez :

Mettre à jour la définition du pipeline en y ajoutant une phase de prévisualisation

Ici, vous ajoutez une nouvelle phase à votre pipeline qui exécute l’opération de simulation.

1. Dans Visual Studio Code, ouvrez le fichier azure-pipelines.yml dans le dossier deploy.

2. Entre les phases Validation et Déploiement, ajoutez la définition suivante pour la phase Prévisualisation :

   - stage: Preview
     jobs:
     - job: PreviewAzureChanges
       displayName: Preview Azure changes
       steps:
         - task: AzureCLI@2
           name: RunWhatIf
           displayName: Run what-if
           inputs:
             azureSubscription: $(ServiceConnectionName)
             scriptType: 'bash'
             scriptLocation: 'inlineScript'
             inlineScript: |
               az deployment group what-if \
                 --resource-group $(ResourceGroupName) \
                 --template-file deploy/main.bicep \
                 --parameters environmentType=$(EnvironmentType)
   

3. Enregistrez les modifications apportées au fichier.

Ajouter un environnement

1. Dans votre navigateur, accédez à Pipelines>Environnements.

   

2. Sélectionnez Créer un environnement.

   

3. Entrez Website comme nom d’environnement.

   Laissez la description vide. Dans Ressource, sélectionnez Aucune.

   Notes

   Dans Azure Pipelines, les environnements sont utilisés pour activer les fonctionnalités de déploiement. Certaines de ces fonctionnalités s’appliquent seulement quand vous effectuez un déploiement sur Kubernetes ou sur des machines virtuelles. Dans ce module, nous n’utilisons pas ces fonctionnalités et vous pouvez les ignorer.

4. Sélectionnez Create (Créer).

   

Ajouter une vérification d’approbation au pipeline

1. Sélectionnez l’onglet Approbations et vérifications dans la partie supérieure gauche de l’écran.

   

2. Sélectionnez Approbations.

   

3. Dans la zone de texte Approbateurs, tapez votre nom et sélectionnez-vous.

4. Sélectionnez le bouton avec la flèche en regard de Avancé.

   Notez que, par défaut, les approbateurs sont autorisés à approuver les exécutions qu’ils ont déclenchées. Comme vous êtes la seule personne qui va utiliser ce pipeline, laissez cette case cochée.

5. Sélectionnez Create (Créer).

   

Mettre à jour la définition du pipeline pour exiger un environnement et une approbation

Ici, vous configurez la phase Deploy pour qu’elle s’exécute sur l’environnement Website que vous avez créé précédemment. Vous convertissez la phase Deploy pour exécuter un travail de déploiement au lieu d’un travail standard, puis vous la configurez pour un déploiement sur l’environnement.

1. Dans Visual Studio Code, dans le fichier azure-pipelines.yml, remplacez la définition de la phase Deploy par ce code :

   - stage: Deploy
     jobs:
     - deployment: DeployWebsite
       displayName: Deploy website
       environment: Website
       strategy:
         runOnce:
           deploy:
             steps:
               - checkout: self
   
               - task: AzureResourceManagerTemplateDeployment@3
                 name: DeployBicepFile
                 displayName: Deploy Bicep file
                 inputs:
                   connectedServiceName: $(ServiceConnectionName)
                   deploymentName: $(Build.BuildNumber)
                   location: $(deploymentDefaultLocation)
                   resourceGroupName: $(ResourceGroupName)
                   csmFile: deploy/main.bicep
                   overrideParameters: >
                     -environmentType $(EnvironmentType)
   

   Notez que vous définissez une nouvelle étape checkout. Contrairement aux travaux normaux, les travaux de déploiement doivent être configurés pour extraire (télécharger) les fichiers depuis votre dépôt Git. Si vous n’effectuez pas cette étape, le travail de déploiement ne pourra pas lire votre fichier Bicep. À la place, vous pouvez envisager d’utiliser des artefacts de pipeline pour envoyer des fichiers entre des phases de pipeline. Vous trouverez des liens vers des informations supplémentaires sur les artefacts dans le récapitulatif.

2. Enregistrez le fichier .

Vérifier et commiter votre définition de pipeline

1. Vérifiez que votre fichier azure-pipelines.yml est similaire au code ci-dessous :

   trigger:
     batch: true
     branches:
       include:
       - main
   
   pool:
     vmImage: ubuntu-latest
   
   variables:
     - name: deploymentDefaultLocation
       value: westus3
   
   stages:
   
   - stage: Lint
     jobs:
     - job: LintCode
       displayName: Lint code
       steps:
         - script: |
             az bicep build --file deploy/main.bicep
           name: LintBicepCode
           displayName: Run Bicep linter
   
   - stage: Validate
     jobs:
     - job: ValidateBicepCode
       displayName: Validate Bicep code
       steps:
         - task: AzureResourceManagerTemplateDeployment@3
           name: RunPreflightValidation
           displayName: Run preflight validation
           inputs:
             connectedServiceName: $(ServiceConnectionName)
             location: $(deploymentDefaultLocation)
             deploymentMode: Validation
             resourceGroupName: $(ResourceGroupName)
             csmFile: deploy/main.bicep
             overrideParameters: >
               -environmentType $(EnvironmentType)
   
   - stage: Preview
     jobs:
     - job: PreviewAzureChanges
       displayName: Preview Azure changes
       steps:
         - task: AzureCLI@2
           name: RunWhatIf
           displayName: Run what-if
           inputs:
             azureSubscription: $(ServiceConnectionName)
             scriptType: 'bash'
             scriptLocation: 'inlineScript'
             inlineScript: |
               az deployment group what-if \
                 --resource-group $(ResourceGroupName) \
                 --template-file deploy/main.bicep \
                 --parameters environmentType=$(EnvironmentType)
   
   - stage: Deploy
     jobs:
     - deployment: DeployWebsite
       displayName: Deploy website
       environment: Website
       strategy:
         runOnce:
           deploy:
             steps:
               - checkout: self
   
               - task: AzureResourceManagerTemplateDeployment@3
                 name: DeployBicepFile
                 displayName: Deploy Bicep file
                 inputs:
                   connectedServiceName: $(ServiceConnectionName)
                   deploymentName: $(Build.BuildNumber)
                   location: $(deploymentDefaultLocation)
                   resourceGroupName: $(ResourceGroupName)
                   csmFile: deploy/main.bicep
                   overrideParameters: >
                     -environmentType $(EnvironmentType)
   

   Si ce n’est pas le cas, faites-le correspondre à cet exemple, puis enregistrez-le.

2. Commitez et poussez (push) vos modifications à votre dépôt Git en exécutant les commandes suivantes dans le terminal Visual Studio Code :

   git add .
   git commit -m "Add preview stage"
   git push
   

Exécuter le pipeline et passer en revue les résultats de la simulation

1. Dans votre navigateur, accédez à votre pipeline.

2. Sélectionnez l’exécution la plus récente de votre pipeline.

   Attendez que le pipeline termine les étapes Vérification lint, Validation et Prévisualisation. Azure Pipelines met automatiquement à jour la page avec l’état le plus récent, mais il est toutefois conseillé d’actualiser régulièrement cette page.

3. Si vous êtes invité à accorder l’autorisation d’accéder à une ressource, sélectionnez Afficher, puis Autoriser.

4. Notez qu’Azure Pipelines vous demande une approbation. Vous recevez également un e-mail vous informant que le pipeline a besoin de votre approbation.

   

   Avant d’approuver la poursuite du pipeline, vous allez passer en revue les résultats de la simulation pour vérifier qu’ils correspondent à vos attentes.

5. Sélectionnez la phase Prévisualisation.

6. Sélectionnez l’étape Exécuter la simulation pour examiner les modifications signalées par la commande de simulation.

7. Notez que le journal du pipeline fournit des résultats de simulation similaires au code suivant :

   Resource and property changes are indicated with these symbols:
     + Create
     ~ Modify
     = Nochange
   
   The deployment will update the following scope:
   
   Scope: /subscriptions/f0750bbe-ea75-4ae5-b24d-a92ca601da2c/resourceGroups/ToyWebsiteTest
   
     ~ Microsoft.Web/sites/toy-website-nbfnedv766snk [2021-01-15]
       + properties.siteConfig.localMySqlEnabled:   false
       + properties.siteConfig.netFrameworkVersion: "v4.6"
   
     = Microsoft.Insights/components/toywebsite [2020-02-02]
     = Microsoft.Storage/storageAccounts/mystoragenbfnedv766snk [2021-04-01]
     = Microsoft.Web/serverfarms/toy-website [2021-01-15]
   
   Resource changes: 1 to modify, 3 no change.
   

   L’opération de simulation a détecté une modification de la ressource de site web. Cependant, les modifications qu’elle a détectées sont du bruit. Elles ne représentent pas de véritables changements de votre ressource. L’équipe Azure travaille à réduire progressivement le bruit. En attendant, pour ces deux propriétés spécifiques, vous pouvez ignorer les modifications détectées.

   Vous pouvez aussi voir un élément dans le résultat de la simulation pour le type de ressource microsoft.alertsmanagement/smartDetectorAlertRules/Failure Anomalies - toywebsite. Application Insights crée cette ressource automatiquement. La commande de simulation détecte qu’aucune modification n’est apportée à la ressource.

Approuver l’exécution du pipeline

1. Sélectionnez la flèche gauche pour revenir aux détails de l’exécution du pipeline.

   

2. Sélectionnez le bouton Passer en revue dans le panneau d’approbation.

3. Dans la zone Commentaire, entrez Reviewed what-if results (Résultats de la simulation vérifiés).

4. Sélectionnez Approuver.

   

Observer le déploiement réussi

1. Une fois que vous avez approuvé l’exécution du pipeline, vous voyez que la phase Deploy commence à s’exécuter.

   Attendez que la phase se termine.

2. Notez que l’exécution du pipeline s’est terminée avec succès.