Distribuire su macchine virtuali Linux in un ambiente

2025-04-01

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

Questa guida introduttiva illustra come configurare una pipeline di Azure DevOps per la distribuzione in più risorse di macchine virtuali Linux in un ambiente. È possibile usare queste istruzioni per qualsiasi app che pubblica un pacchetto di distribuzione Web.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Organizzazione e progetto di Azure DevOps. Iscriversi ad Azure Pipelines.

JavaScript
Java

Per le app JavaScript o Node.js, almeno due macchine virtuali Linux configurate con Nginx in Azure.

Esegui un fork del codice di esempio

Se si ha già un'app in GitHub che si vuole distribuire, è possibile creare una pipeline per tale codice.

Se sei un nuovo utente, fai il fork di questo repository su GitHub:

JavaScript
Java

https://github.com/MicrosoftDocs/pipelines-javascript

https://github.com/spring-projects/spring-petclinic

Nota

Petclinic è un'applicazione Spring Boot creata con Maven.

Creare un ambiente con macchine virtuali Linux

È possibile aggiungere macchine virtuali come risorse all'interno degli ambienti e specificarle come destinazione per le distribuzioni con più macchine virtuali. La cronologia di distribuzione per l'ambiente fornisce la tracciabilità dalla macchina virtuale al commit.

Aggiungere una risorsa macchina virtuale

Nel progetto Azure DevOps, vai a Pipelines>Ambienti e quindi seleziona Crea ambiente o Nuovo ambiente.
Nella prima schermata Nuovo ambiente aggiungere un nome e una descrizione facoltativa.
In Risorsa selezionare Macchine virtuali e quindi avanti.
Nella schermata successiva Nuovo ambiente scegliere Linux in Sistema operativo.
Copiare lo script di registrazione di Linux. Lo script è lo stesso per tutte le macchine virtuali Linux aggiunte all'ambiente.

Screenshot della creazione della macchina virtuale.

Nota

Il token di accesso personale dell'utente connesso viene pre-inserito nello script e scade dopo tre ore.
Selezionare Chiudi e notare che viene creato il nuovo ambiente.
Eseguire lo script copiato in ogni macchina virtuale di destinazione da registrare nell'ambiente.

Nota

Se nella macchina virtuale è già in esecuzione un altro agente, specificare un nome univoco per l'agente da registrare nell'ambiente.

Dopo aver registrato la macchina virtuale, viene visualizzata come risorsa nella scheda Risorse dell'ambiente.

Screenshot della visualizzazione delle risorse della macchina virtuale.

Per copiare nuovamente lo script per la creazione di altre risorse, ad esempio se il pat scade, selezionare Aggiungi risorsa nella pagina dell'ambiente.

Aggiungere e gestire tag

I tag sono un modo per specificare come destinazione un set specifico di macchine virtuali in un ambiente per la distribuzione. Non esiste alcun limite al numero di tag che è possibile usare. I tag sono limitati a 256 caratteri ciascuno.

È possibile aggiungere tag o rimuovere tag per le macchine virtuali nello script di registrazione interattivo o tramite l'interfaccia utente selezionando Altre azioni per una risorsa macchina virtuale. Per questa guida introduttiva, assegnare un tag diverso a ogni macchina virtuale nell'ambiente in uso.

Screenshot della visualizzazione tag.

Definire una pipeline di compilazione CI

È necessaria una pipeline di compilazione di integrazione continua (CI) che pubblica l'app Web e uno script di distribuzione da eseguire localmente nel server Linux. Configurare la pipeline di compilazione CI in base al runtime che si vuole usare.

Importante

Durante le procedure di GitHub, potrebbe essere richiesto di creare una connessione al servizio GitHub o di essere reindirizzati a GitHub per accedere, installare Azure Pipelines o autorizzare Azure Pipelines. Seguire le istruzioni visualizzate per completare il processo. Per altre informazioni, vedere Accedere ai repository GitHub.

Nel progetto Azure DevOps selezionare Pipelines>Crea Pipeline e quindi selezionare GitHub come percorso del codice sorgente.
Nella schermata Seleziona un repository, selezionare il tuo repository di esempio forkato.
Nella schermata Configura la pipeline, selezionare Pipeline di base. Azure Pipelines genera un file YAML denominato azure-pipelines.yml per la pipeline.
Selezionare la freccia del menu a discesa accanto a Salva ed esegui, selezionare Salva e quindi selezionare nuovamente Salva. Il file viene salvato nel tuo repository GitHub derivato.

Modificare il codice

Selezionare Modifica e sostituire il contenuto del file azure-pipelines.yml con il codice seguente. Aggiungi a questo YAML nelle fasi successive.

JavaScript
Java

Il codice seguente compila il progetto Node.js con npm.

    trigger:
    - main
    
    pool:
      vmImage: ubuntu-latest
    
    stages:
    - stage: Build
      displayName: Build stage
      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: zip
            archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
            replaceExistingArchive: true
        - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
          artifact: drop

Per altre informazioni, vedere la procedura descritta in Creare l'app Node.js con gulp per creare una compilazione.

Il codice seguente compila il progetto Java ed esegue test con Apache Maven.

    trigger:
    - main
    
    pool:
      vmImage: ubuntu-latest
    
    stages:
    - stage: Build
      displayName: Build stage
      jobs:  
      - job: Build
        displayName: Build Maven Project
        steps:
        - task: Maven@4
          displayName: 'Maven Package'
          inputs:
            mavenPomFile: 'pom.xml'
        - task: CopyFiles@2
          displayName: 'Copy Files to artifact staging directory'
          inputs:
            SourceFolder: '$(System.DefaultWorkingDirectory)'
            Contents: '**/target/*.?(war|jar)'
            TargetFolder: $(Build.ArtifactStagingDirectory)
        - upload: $(Build.ArtifactStagingDirectory)
          artifact: drop

Per altre informazioni, vedere la procedura descritta in Compilare l'app Java con Maven per creare una compilazione.

Esegui la tua pipeline

Selezionare Convalida e salva, quindi selezionare Salva, selezionare Esegui e selezionare di nuovo Esegui.

Dopo l'esecuzione della pipeline, verificare che il processo sia stato eseguito correttamente e che venga visualizzato un artefatto pubblicato.

Eseguire la distribuzione nelle macchine virtuali Linux

Modifica la pipeline per aggiungere il seguente processo di distribuzione. Sostituire <environment name> con il nome dell'ambiente creato in precedenza. Seleziona macchine virtuali specifiche dall'ambiente per ricevere la distribuzione specificando il <VM tag> che hai definito per ciascuna macchina virtuale.
```
jobs:  
- deployment: VMDeploy
  displayName: Web deploy
  environment:
    name:  <environment name>
    resourceType: VirtualMachine
    tags: <VM tag> # Update value for VMs to deploy to
  strategy:
```
Per altre informazioni, vedere la definizione completa jobs.deployment.

Per ulteriori informazioni sulla parola chiave environment e le risorse mirate da un processo di distribuzione, consultare la definizione di jobs.deployment.environment.

Specificare runOnce o rolling come strategy di distribuzione.

runOnce è la strategia di distribuzione più semplice. Gli hook del ciclo di vita preDeploy, deploy, routeTraffic e postRouteTraffic vengono eseguiti una sola volta. on: success Viene quindi eseguito on:failure.

Il codice seguente mostra un processo di distribuzione per runOnce:
```
jobs:
- deployment: VMDeploy
  displayName: Web deploy
  environment:
    name: <environment name>
    resourceType: VirtualMachine
    tags: <VM tag>
  strategy:
    runOnce:
      deploy:
        steps:
        - script: echo my first deployment
```

Il codice seguente illustra un frammento YAML per la rolling strategia di distribuzione, usando una pipeline Java. È possibile aggiornare fino a cinque destinazioni in ogni iterazione. Il maxParallel parametro specifica il numero di destinazioni che possono essere distribuite in parallelo.

La maxParallel selezione rappresenta il numero assoluto o la percentuale di destinazioni che devono rimanere disponibili in qualsiasi momento, escludendo le destinazioni in fase di distribuzione, e determina le condizioni di successo e fallimento durante l'implementazione.

jobs: 
- deployment: VMDeploy
  displayName: web
  environment:
    name: <environment name>
    resourceType: VirtualMachine
    tags: <VM tag>
  strategy:
      rolling:
        maxParallel: 2  #for percentages, mention as x%
        preDeploy:
          steps:
          - download: current
            artifact: drop
          - script: echo initialize, cleanup, backup, install certs
        deploy:
          steps:
          - task: Bash@3
            inputs:
              targetType: 'inline'
              script: |
                # Modify deployment script based on the app type
                echo "Starting deployment script run"
                sudo java -jar '$(Pipeline.Workspace)/drop/**/target/*.jar'
        routeTraffic:
          steps:
          - script: echo routing traffic
        postRouteTraffic:
          steps:
          - script: echo health check post-route traffic
        on:
          failure:
            steps:
            - script: echo Restore from backup! This is on failure
          success:
            steps:
            - script: echo Notify! This is on success

Con ogni esecuzione di questo processo, la cronologia di distribuzione viene registrata nell'ambiente creato e di cui hai registrato le macchine virtuali.

Tracciabilità della pipeline di accesso nell'ambiente

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

Screenshot della visualizzazione delle distribuzioni.