Partager via

Déployer sur des machines virtuelles Linux dans un environnement

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022

Vous pouvez ajouter des machines virtuelles en tant que ressources dans des environnements Azure Pipelines et les cibler pour les déploiements. Pour un flux de travail d’intégration continue et de déploiement continu (CI/CD), l’historique de déploiement de l’environnement fournit une traçabilité pour chaque machine virtuelle jusqu'à la validation de déclenchement.

Cet article explique comment configurer un pipeline Azure DevOps pour les déploiements sur plusieurs ressources de machine virtuelle Linux dans un environnement. Ces instructions créent et déploient une application JavaScript ou Java, mais vous pouvez les adapter à n’importe quelle application qui publie un package de déploiement web.

Pour plus d’informations sur les environnements et les ressources ciblés par un travail de déploiement, consultez la définition de schéma YAML de jobs.deployment.environment . Pour plus d’informations sur les travaux de déploiement, consultez la définition de jobs.deployment .

Prérequis

En outre, pour les applications JavaScript ou Node.js :

Important

  • Pour déployer des applications, les ressources de machine virtuelle de l’environnement cible doivent avoir tous les logiciels, dépendances, autorisations et connexions nécessaires installés et configurés.
  • Pour utiliser le code source GitHub, vous avez besoin d’une connexion de service GitHub. GitHub peut également vous inviter à vous connecter, installer l’application GitHub Azure Pipelines ou autoriser Azure Pipelines. Pour terminer chaque processus, suivez les instructions à l’écran. Pour plus d’informations, veuillez consulter la section Accès aux référentiels GitHub.

Créer un environnement et ajouter des machines virtuelles Linux

Dans votre projet Azure Pipelines, créez un environnement et ajoutez vos machines virtuelles Linux en tant que ressources d’environnement en suivant les instructions fournies à l’adresse Créer un environnement et ajouter une machine virtuelle.

Exécutez le script d’inscription de l’agent copié sur chaque machine virtuelle pour l’inscrire dans l’environnement. Vous pouvez également affecter des balises aux machines virtuelles individuelles en répondant aux invites interactives.

Créer et exécuter le pipeline de compilation

Créez un pipeline CI qui génère et déploie votre application chaque fois qu’il existe une validation sur la main branche de votre dépôt de code.

Créer le pipeline YAML

  1. Dans votre projet Azure DevOps, sélectionnez Pipelines>Nouveau pipeline ou Créer un pipeline, puis sélectionnez GitHub comme emplacement de votre code source.
  2. Dans l’écran Sélectionner un référentiel , sélectionnez votre exemple de référentiel forked.
  3. Dans l’écran Configurer votre pipeline, sélectionnez Pipeline de démarrage.
  4. Dans l’écran Vérifier votre YAML de pipeline, remplacez le code de démarrage généré par le code suivant, en fonction de votre runtime.

Ajouter la tâche de build

Le Build job exécute des tâches pour générer et tester votre projet, puis téléverse les résultats de la construction vers un drop emplacement. Ce travail s’exécute sur les agents de build spécifiés dans le pipeline pool, et non sur vos machines virtuelles d’environnement Linux.

Le pipeline suivant génère et teste votre projet Node.js avec npm, puis empaquette la sortie et le charge dans un emplacement de dépôt.

trigger:
- main

pool:
  vmImage: ubuntu-latest

jobs:  
- job: Build
  displayName: Build
  steps:
  - task: UseNode@1
    inputs:
      version: '16.x'
    displayName: 'Install Node.js'
  - script: |
      npm install
      npm run build --if-present
      npm run test --if-present
    displayName: 'npm install, build and test'
  - task: ArchiveFiles@2
    displayName: 'Archive files'
    inputs:
      rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
      includeRootFolder: false
      archiveType: tar
      tarCompression: gz
      archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).gz
      replaceExistingArchive: true
  - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).gz
    artifact: drop

Pour plus d’informations, passez en revue les étapes de création d’une build dans Générer votre application Node.js avec gulp.

Exécuter le pipeline

Pour enregistrer votre fichier azure-pipelines.yml dans votre dépôt et lancer le pipeline CI/CD, sélectionnez Enregistrer et exécuter, puis sélectionnez Enregistrer et réexécuter .

Une fois le pipeline terminé, consultez la page Résumé du projet pour vérifier que le projet de build s’est exécuté correctement et qu’un artefact publié apparaît sous Références.

Ajouter et exécuter la tâche de déploiement

Un travail de déploiement exécute preDeploy, deploy, routeTraffic, et postRouteTraffic des hooks de cycle de vie une seule fois, puis exécute soit on: success soit on: failure. Si vous déployez sur des machines virtuelles d’environnement, la preDeploy phase s’exécute sur l’agent de build, et non sur les machines virtuelles de l’environnement. Toutes les autres étapes s’exécutent sur des machines virtuelles inscrites dans l’environnement.

  1. L’étape facultative preDeploy s’exécute avant le déploiement. Vous pouvez utiliser cette étape pour l’orchestration, la préparation des machines virtuelles et des artefacts et les vérifications d’intégrité.
  2. L’étape deploy déploie l’objet de déploiement sur les machines virtuelles de l’environnement cible.
  3. L’étape facultative routeTraffic peut appliquer la redirection du trafic.
  4. L’étape facultative postRouteTraffic peut effectuer des diagnostics de santé et des notifications.
  5. Les étapes personnalisées on.failure et on.success peuvent fournir des notifications ou une récupération.

Un travail de déploiement vers un environnement avec resourceType: VirtualMachine requiert que les machines virtuelles de cet environnement soient capables d'exécuter toutes les tâches de la pipeline, telles que Bash ou Azure CLI. Vous pouvez utiliser l’étape preDeploy pour installer les logiciels et autorisations nécessaires sur les machines virtuelles cibles.

Par exemple, si une étape de déploiement utilise Azure CLI, les machines virtuelles de l’agent doivent avoir Azure CLI installée et disponible sur le chemin d’accès de l’utilisateur de l’agent. L’utilisateur de l’agent doit avoir l’autorisation d’exécuter l’interface CLI et doit s’authentifier auprès d’Azure. Vous devrez peut-être ajouter l’utilisateur de l’agent aux sudoers ou configurer des variables d’environnement pour automatiser l’installation.

Vous pouvez utiliser un preDeploy script pour installer Azure CLI sur les machines virtuelles cibles. Pour vous authentifier auprès d’Azure, vous pouvez exécuter az login ou, pour l’automatisation, créer un principal de service et exécuter az login --service-principal lors d'une étape preDeploy.

Ajouter le travail de déploiement

L'exemple de tâche de déploiement suivant démarre lorsque la tâche Build est terminée avec succès. Pour ajouter la tâche à votre pipeline :

  1. Sélectionnez l’icône Autres actions en haut à droite dans la page Résumé , sélectionnez Modifier le pipeline et ajoutez le code suivant à la fin de votre pipeline. Remplacez <environment-name> par le nom de l’environnement que vous avez créé.

    Si vous le souhaitez, vous pouvez sélectionner des machines virtuelles spécifiques de l’environnement pour recevoir le déploiement à l’aide du tags paramètre et spécifier la <VMtag> machine virtuelle que vous avez définie.

    - deployment: VMDeploy
  displayName: Web deploy
  dependsOn: Build
  condition: succeeded()
  environment:
    name: <environment-name>
    resourceType: VirtualMachine
    tags: <VMtag> # VMs to deploy to

  2. Ajoutez un strategy à la deployment tâche. La stratégie de déploiement runOnce est la plus simple et s’exécute par défaut si vous ne spécifiez strategypas . Cette stratégie exécute les étapes de déploiement une fois sur chaque machine virtuelle de l’environnement, sans parallélisme ni gestion du trafic.

      strategy:
     runOnce:
       deploy:
          steps:
          - script: echo my first deployment

  3. Après avoir ajouté le travail de déploiement, sélectionnez Valider et enregistrer, puis sélectionnez Enregistrer, Exécuter, puis Réexécuter. Avec chaque exécution de ce travail, des enregistrements d'historique de déploiement sont réalisés pour l'environnement.

    Remarque

    La première fois que vous exécutez le pipeline qui utilise l’environnement, vous devez accorder l’autorisation pour toutes les exécutions du pipeline pour accéder au pool d’agents et à l’environnement. Sélectionnez le symbole en attente en regard du travail sur l’écran Résumé de l’exécution du pipeline, puis sélectionnez Autoriser pour accorder les autorisations nécessaires.

Stratégie de déploiement propagé

Vous pouvez utiliser une stratégie de rolling au lieu de runOnce. Une stratégie de déploiement propagée peut orchestrer le parallélisme, les vérifications d’intégrité et le routage du trafic. Bien que la runOnce stratégie s’exécute sur une seule machine virtuelle à la fois, un déploiement propagé peut s’exécuter en parallèle sur des ensembles de machines virtuelles cibles allant jusqu’à cinq, selon le maxParallel paramètre.

Le maxParallel paramètre définit le nombre ou le pourcentage de machines virtuelles qui doivent rester disponibles, ce qui garantit que l’application peut gérer les demandes et réduire le temps d’arrêt global pendant les déploiements. Ce paramètre détermine également les conditions de réussite et d’échec du déploiement.

Pour plus d’informations sur la stratégie de déploiement continu, consultez la définition de schéma jobs.deployment.strategy.rolling .

Exemple de travail de déploiement

Les déploiements sur des ressources de machine virtuelle nécessitent que toutes les applications, dépendances et autorisations requises soient installées et configurées. Vous devez préinstaller manuellement ces exigences, ou le pipeline doit les installer ou les implémenter.

Le déploiement d’applications Java sur les ressources de machine virtuelle est plus facile à implémenter, car il est autonome. La machine virtuelle Java (JVM) est souvent préinstallée sur les agents de machine virtuelle, et vous n’avez pas besoin de vous soucier des dépendances d’application, des autorisations ou de la gestion des packages. Vous pouvez simplement télécharger le fichier JAR, puis l’exécuter avec java -jar.

L’application Node.js nécessite Node, éventuellement npm dépendances, et un gestionnaire de services comme systemd doit être présent et configuré sur chaque machine virtuelle de l’agent. Pour être automatisé, le script de déploiement de pipeline doit être non actif et capable de redémarrer et de gérer le service de l’application.

Le travail de déploiement YAML rolling suivant pour l’application JavaScript dépend de la réussite Build de l’étape de compilation. Le travail de déploiement suppose que les exigences suivantes sont déjà préinstallées ou préconfigurées sur chaque machine virtuelle de l’agent. Pour une automatisation complète, vous pouvez installer et configurer ces applications et services sur les machines virtuelles dans le cadre du pipeline.

  • Node.js 16.x est installé, et npm est disponible dans le PATH de l'agent de build.
  • Système avec un fichier de service systemd configuré pour le service qui démarre l’application Node.js, par exemple /etc/systemd/system/pipelines-javascript.service.
  • Sudo sans mot de passe pour l'utilisateur de l'agent, pour les commandes nécessaires, défini avec NOPASSWD: dans /etc/sudoers.
  • Autorisations d’écriture pour l’utilisateur de l’agent sur /opt/pipelines-javascript ou sur d'autres cibles de déploiement.

Conseil / Astuce

Pour la plupart des applications Node.js, envisagez de déployer sur Azure App Service ou d’utiliser des travaux de pipeline standard avec des agents hébergés par Microsoft, au lieu d’utiliser des travaux de déploiement. Cette approche est plus simple et évite la surcharge opérationnelle de la gestion des environnements de machine virtuelle. Le déploiement vers des ressources de machine virtuelle spécifiques convient le mieux aux scénarios nécessitant un contrôle direct des serveurs de machines virtuelles, une orchestration avancée ou une infrastructure héritée.

- stage: Deploy
  displayName: Rolling Deploy to VMs
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: RollingDeploy
    displayName: Rolling deploy to Ubuntu VMs
    environment:
      name: <environment-name>
      resourceType: VirtualMachine
    strategy:
      rolling:
        maxParallel: 1   #or 2 for parallel. For percentages, use x%
        preDeploy:
          steps:
          - download: current
            artifact: drop
          - script: echo "Pre-deploy on $(hostname)"
        deploy:
          steps:
          - script: |
              echo "Unpacking Node.js app on $(hostname)"
              sudo mkdir -p /opt/pipelines-javascript
              sudo tar -xzf $(Pipeline.Workspace)/drop/$(Build.BuildId).tar.gz -C /opt/pipelines-javascript --strip-components=1
              cd /opt/pipelines-javascript
              echo "Installing production dependencies"
              sudo npm ci --only=production
              echo "Restarting Node.js service"
              sudo systemctl restart pipelines-javascript
            displayName: 'Extract, install, and restart Node.js service'
        routeTraffic:
          steps:
          - script: echo "Routing traffic on $(hostname)"
        postRouteTraffic:
          steps:
          - script: echo "Post-route health check on $(hostname)"
        on:
          failure:
            steps:
            - script: echo "Deployment failed on $(hostname)"
          success:
            steps:
            - script: echo "Deployment succeeded on $(hostname)"

Traçabilité du pipeline d’accès dans l’environnement

L’onglet Déploiements d’environnement fournit une traçabilité complète des validations et des éléments de travail et un historique de déploiement entre pipelines pour l’environnement.

Capture d’écran de la vue Déploiements.

Contenu connexe

  • Last updated on