Condividi tramite

Distribuire su macchine virtuali Linux in un ambiente

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

È possibile aggiungere macchine virtuali come risorse all'interno degli ambienti Azure Pipelines e specificarle come destinazione per le distribuzioni. Per un flusso di lavoro di integrazione continua e distribuzione continua (CI/CD), la cronologia di distribuzione dell'ambiente fornisce la tracciabilità per ogni macchina virtuale al commit di attivazione.

Questo articolo illustra come configurare una pipeline di Azure DevOps per le distribuzioni in più risorse di macchine virtuali Linux in un ambiente. Queste istruzioni compilano e distribuiscono un'app JavaScript o Java, ma è possibile adattarle per qualsiasi app che pubblica un pacchetto di distribuzione Web.

Per altre informazioni sugli ambienti e le risorse di destinazione di un processo di distribuzione, vedere la definizione dello schema YAML jobs.deployment.environment . Per altre informazioni sui processi di distribuzione, vedere la definizione jobs.deployment.

Prerequisiti

Inoltre, per le app JavaScript o Node.js:

Importante

  • Per distribuire le app, le risorse di macchine virtuali dell'ambiente di destinazione devono disporre di tutto il software, le dipendenze, le autorizzazioni e gli account di accesso necessari installati e configurati.
  • Per usare il codice sorgente di GitHub, è necessaria una connessione al servizio GitHub. GitHub potrebbe anche richiedere di accedere, installare l'app GitHub di Azure Pipelines o autorizzare Azure Pipelines. Per completare ogni processo, seguire le istruzioni visualizzate. Per altre informazioni, vedere Accedere ai repository GitHub.

Creare un ambiente e aggiungere macchine virtuali Linux

Nel progetto Azure Pipelines creare un ambiente e aggiungere le macchine virtuali Linux come risorse di ambiente seguendo le istruzioni riportate in Creare un ambiente e aggiungere una macchina virtuale.

Eseguire lo script di registrazione dell'agente copiato in ogni macchina virtuale per registrarlo nell'ambiente. È anche possibile assegnare tag alle singole macchine virtuali rispondendo alle richieste interattive.

Creare ed eseguire la pipeline di compilazione

Creare una pipeline di integrazione continua che, ogni volta che è presente un commit nel ramo main del repository di codice, compila e rilascia la tua app.

Creare la pipeline YAML

  1. Nel progetto Azure DevOps selezionare Pipeline>nuova pipeline o Crea pipeline e quindi selezionare GitHub come percorso del codice sorgente.
  2. Nella schermata Seleziona un repository, selezionare il tuo repository di esempio forkato.
  3. Nella schermata Configura la pipeline, selezionare Pipeline di base.
  4. Nella schermata Esaminare il codice YAML della pipeline sostituire il codice iniziale generato con il codice seguente, a seconda del runtime.

Aggiungere il job di build

Il Build lavoro esegue compiti per compilare e testare il progetto e carica l'output di compilazione in una drop destinazione. Questo processo viene eseguito negli agenti di compilazione specificati nella pipeline pool, non nelle macchine virtuali dell'ambiente Linux.

La pipeline seguente compila e testa il progetto Node.js con npm, quindi impacchetta l'output e lo carica in una directory di rilascio.

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

Per altre informazioni, consultare i passaggi per la creazione di un build in Compilare l'app Node.js con gulp.

Eseguire la pipeline

Per salvare il file azure-pipelines.yml nel repository e avviare la pipeline CI/CD, selezionare Salva ed esegui, quindi selezionare Salva ed esegui di nuovo.

Al termine della pipeline, visualizzare la pagina Riepilogo del processo di compilazione per verificare che il processo di compilazione sia stato eseguito correttamente e che 1 artefatto pubblicato appaia al di sotto di Correlato.

Aggiungi ed esegui il processo di distribuzione

Un processo di distribuzione esegue preDeploygli hook del ciclo di vita , deploy, routeTraffice postRouteTraffic una sola volta e quindi esegue on: success o on: failure. Se si esegue la distribuzione nelle macchine virtuali dell'ambiente, la preDeploy fase viene eseguita nell'agente di compilazione, non nelle macchine virtuali dell'ambiente. Tutti gli altri passaggi vengono eseguiti nelle macchine virtuali registrate nell'ambiente.

  1. Il passaggio facoltativo preDeploy viene eseguito prima della distribuzione. È possibile usare questo passaggio per orchestrazione, preparazione di macchine virtuali e artefatti e controlli di integrità.
  2. Il deploy passaggio distribuisce l'oggetto di distribuzione nelle macchine virtuali dell'ambiente di destinazione.
  3. Il passaggio facoltativo routeTraffic può applicare il cambio di traffico.
  4. Il passaggio facoltativo postRouteTraffic può eseguire controlli di stato e notifiche.
  5. I passaggi personalizzati on.failure e on.success possono fornire notifiche o ripristino.

Un processo di distribuzione in un ambiente con resourceType: VirtualMachine richiede che le macchine virtuali dell'ambiente siano in grado di eseguire tutte le attività della pipeline, ad esempio Bash o l'interfaccia della riga di comando di Azure. È possibile usare il preDeploy passaggio per installare il software e le autorizzazioni necessarie per le macchine virtuali di destinazione.

Ad esempio, se un passaggio di distribuzione usa l'interfaccia della riga di comando di Azure, le macchine virtuali dell'agente devono avere l'interfaccia della riga di comando di Azure installata e disponibile nel percorso per l'utente dell'agente. L'utente dell'agente deve disporre dell'autorizzazione per eseguire l'interfaccia della riga di comando e deve eseguire l'autenticazione in Azure. Potrebbe essere necessario aggiungere l'utente dell'agente a sudoers o configurare le variabili di ambiente per automatizzare l'installazione.

È possibile usare uno preDeploy script per installare l'interfaccia della riga di comando di Azure nelle macchine virtuali di destinazione. Per eseguire l'autenticazione in Azure, è possibile eseguire az login, oppure per l'automazione, definire un principal del servizio ed eseguire az login --service-principal in una preDeploy fase.

Aggiungere il job di distribuzione

Il processo di distribuzione di esempio seguente viene avviato quando il processo Build viene completato con successo. Per aggiungere il processo nella pipeline:

  1. Selezionare l'icona Altre azioni in alto a destra nella pagina Riepilogo , selezionare Modifica pipeline e aggiungere il codice seguente alla fine della pipeline. Sostituire <environment-name> con il nome dell'ambiente creato.

    Facoltativamente, è possibile selezionare macchine virtuali specifiche dall'ambiente per ricevere la distribuzione usando il parametro tags e specificando il <VMtag> definito per la macchina virtuale.

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

  2. Aggiungi un strategy al deployment lavoro. La strategia di distribuzione runOnce è la più semplice ed eseguita per impostazione predefinita se non si specifica strategy. Questa strategia esegue i passaggi di distribuzione una sola volta in ogni macchina virtuale nell'ambiente, senza parallelismo o gestione del traffico.

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

  3. Dopo aver aggiunto il processo di distribuzione, selezionare Convalida e salva, quindi selezionare Salva, selezionare Esegui e selezionare di nuovo Esegui . Con ogni esecuzione di questo processo, i record della cronologia di distribuzione riguardano l'ambiente.

    Nota

    La prima volta che si esegue la pipeline che usa l'ambiente, è necessario concedere l'autorizzazione per tutte le esecuzioni della pipeline per accedere al pool di agenti e all'ambiente. Selezionare il simbolo In attesa accanto al processo nella schermata Riepilogo esecuzione pipeline e quindi selezionare Consenti per concedere le autorizzazioni necessarie.

Strategia di distribuzione in sequenza

È possibile usare una rolling strategia anziché una strategia di runOnce distribuzione . Una strategia di distribuzione continua può orchestrare il parallelismo, i controlli di integrità e il routing del traffico. Mentre la runOnce strategia viene eseguita su una singola macchina virtuale alla volta, una distribuzione in sequenza può essere eseguita in parallelo su set di fino a cinque macchine virtuali di destinazione, a seconda dell'impostazionemaxParallel.

Il maxParallel parametro imposta il numero o la percentuale di macchine virtuali che devono rimanere disponibili, assicurandosi che l'app possa gestire le richieste e ridurre i tempi di inattività complessivi durante le distribuzioni. Questo parametro determina anche le condizioni di esito positivo e negativo per la distribuzione.

Per altre informazioni sulla strategia di distribuzione in sequenza, vedere la definizione dello schema jobs.deployment.strategy.rolling .

Esempio di attività di distribuzione

Le distribuzioni nelle risorse delle macchine virtuali richiedono che tutte le app, le dipendenze e le autorizzazioni necessarie siano installate e configurate. È necessario preinstallare manualmente questi requisiti oppure la pipeline deve installarli o implementarli.

La distribuzione di app Java nelle risorse della macchina virtuale è più semplice da implementare perché è autonoma. La macchina virtuale Java (JVM) viene spesso preinstallata negli agenti di macchine virtuali e non è necessario preoccuparsi delle dipendenze delle app, delle autorizzazioni o della gestione dei pacchetti. È sufficiente scaricare il file JAR e quindi eseguirlo con java -jar.

L'app Node.js richiede Node, possibilmente dipendenze npm e un gestore di servizi come systemd per essere presente e configurato in ogni macchina virtuale dell'agente. Per essere automatizzato, lo script di distribuzione della pipeline deve essere non interattivo e in grado di riavviare e gestire il servizio dell'app.

Il processo di distribuzione YAML rolling seguente per l'app JavaScript dipende dal completamento corretto Build della fase. Il processo di distribuzione presuppone che i requisiti seguenti siano già preinstallati o preconfigurati in ogni macchina virtuale dell'agente. Per l'automazione completa, è possibile installare e configurare queste app e servizi nelle macchine virtuali come parte della pipeline.

  • Node.js 16.x installato e npm disponibile nel percorso dell'agente di compilazione.
  • Configurato con systemd e un file di servizio systemd per il servizio che avvia l'app Node.js, come ad esempio /etc/systemd/system/pipelines-javascript.service.
  • Sudo senza password per l'utente dell'agente per i comandi necessari, impostato con NOPASSWD: in /etc/sudoers.
  • Autorizzazioni di scrittura per l'utente dell'agente su /opt/pipelines-javascript o su un'altra destinazione di distribuzione.

Suggerimento

Per la maggior parte delle app Node.js, è consigliabile eseguire la distribuzione nel servizio app di Azure o usare processi di pipeline regolari con agenti ospitati da Microsoft, invece di usare i processi di distribuzione. Questo approccio è più semplice ed evita il sovraccarico operativo della gestione degli ambienti delle macchine virtuali. La distribuzione in risorse vm specifiche è più adatta per gli scenari che richiedono il controllo diretto dei server vm, dell'orchestrazione avanzata o dell'infrastruttura legacy.

- 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)"

Tracciabilità della pipeline di accesso nell'ambiente

La scheda Distribuzioni dell'ambiente fornisce la tracciabilità completa dei commit e degli elementi di lavoro e di una cronologia di distribuzione tra pipeline per l'ambiente.

Screenshot della visualizzazione delle distribuzioni.

Contenuto correlato

  • Last updated on