Creating a CI/CD pipeline with Azure Pipelines and Compute Engine

Last reviewed 2023-03-09 UTC

Questo tutorial mostra come utilizzare Azure Pipelines e Compute Engine per creare una pipeline di integrazione continua/deployment continuo (CI/CD) per un'applicazione web ASP.NET MVC. L'applicazione utilizza Microsoft Internet Information Services e viene eseguita su Windows Server.

La pipeline CI/CD utilizza due ambienti separati, uno per i test e uno per la produzione.

All'inizio della pipeline, gli sviluppatori eseguono il commit delle modifiche al codebase di esempio. Questa azione attiva la pipeline per creare l'applicazione, comprimerla come file ZIP e caricarla in Cloud Storage.

Il pacchetto viene poi rilasciato automaticamente nell'ambiente di sviluppo utilizzando un aggiornamento progressivo. Una volta testata la release, un release manager può promuoverla in modo che venga implementata nell'ambiente di produzione.

Questo tutorial è rivolto a sviluppatori e ingegneri DevOps. Presuppone che tu abbia conoscenze di base di .NET Framework, Windows Server, IIS, Azure Pipelines e Compute Engine. Il tutorial richiede anche l'accesso amministrativo a un account Azure DevOps.

Obiettivi

  • Utilizza i gruppi di istanze gestite di Compute Engine per implementare i deployment in sequenza.
  • Configura una pipeline CI/CD in Azure Pipelines per orchestrare i processi di creazione, creazione e deployment.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Consulta la pagina dei prezzi di Azure DevOps per eventuali tariffe che potrebbero essere applicate all'utilizzo di Azure DevOps.

Prima di iniziare

In genere è consigliabile utilizzare progetti separati per i carichi di lavoro di sviluppo e produzione, in modo che i ruoli e le autorizzazioni di Identity and Access Management (IAM) possano essere concessi singolarmente. Per semplicità, questo tutorial utilizza un singolo progetto per gli ambienti di sviluppo e produzione.

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Enable the Compute Engine and Cloud Storage APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  3. Verify that billing is enabled for your Google Cloud project.

  4. Assicurati di avere un account Azure DevOps e l'accesso amministrativo. Se non hai ancora un account Azure DevOps, puoi registrarti nella home page di Azure DevOps.

Crea un progetto Azure DevOps

Utilizzi Azure DevOps per gestire il codice sorgente, eseguire build e test e orchestrare il deployment in Compute Engine. Per iniziare, crea un progetto nel tuo account Azure DevOps.

  1. Vai alla home page di Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
  2. Fai clic su Nuovo progetto.
  3. Inserisci un nome per il progetto, ad esempio CloudDemo.
  4. Imposta Visibilità su Privato, quindi fai clic su Crea.
  5. Dopo aver creato il progetto, fai clic su Repository nel menu a sinistra.
  6. Fai clic su Importa per creare un fork del repository dotnet-docs-samples da GitHub, quindi imposta i seguenti valori:
    • Tipo di repository: Git
    • URL clone: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git

  7. Fai clic su Importa.

    Al termine del processo di importazione, viene visualizzato il codice sorgente del repository dotnet-docs-samples.

  8. Nel menu, fai clic su Repository > Branch.

  9. Sposta il mouse sopra il ramo main. A destra viene visualizzato un pulsante ….

  10. Fai clic su … > Imposta come ramo predefinito.

Creazione continua

Ora puoi utilizzare Azure Pipelines per configurare una pipeline di build. Per ogni commit inserito nel repository Git, Azure Pipelines compila il codice, lo comprime in un file ZIP e pubblica il pacchetto risultante nell'archivio interno di Azure Pipelines.

In un secondo momento, configuri una pipeline di rilascio che utilizza i pacchetti dallo spazio di archiviazione di Azure Pipelines e li implementa in Compute Engine.

Creare una definizione di build

Crea una nuova definizione di build in Azure Pipelines che utilizzi la sintassi YAML:

  1. Utilizzando Visual Studio o un client a riga di comando git, clona il nuovo repository Git.
  2. Nella radice del repository, crea un file denominato azure-pipelines.yml.

  3. Copia il seguente codice e incollalo nel file:

    resources:
- repo: self
  fetchDepth: 1
trigger:
- main
variables:
  artifactName: 'CloudDemo.Mvc'
jobs:
- job: Build
  displayName: Build application
  condition: succeeded()
  pool:
    vmImage: windows-latest
    demands:
    - msbuild
    - visualstudio
  variables:
    Solution: 'applications/clouddemo/net4/CloudDemo.Mvc.sln'
    BuildPlatform: 'Any CPU'
    BuildConfiguration: 'Release'
    ArtifactName: 'CloudDemo.Web'
  steps:
  - task: NuGetCommand@2
    displayName: 'NuGet restore'
    inputs:
      restoreSolution: '$(Solution)'
  - task: VSBuild@1
    displayName: 'Build solution'
    inputs:
      solution: '$(Solution)'
      msbuildArgs: '/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true /p:PackageLocation="$(build.artifactstagingdirectory)\\"'
      platform: '$(BuildPlatform)'
      configuration: '$(BuildConfiguration)'
  - task: PublishBuildArtifacts@1
    displayName: 'Publish Artifact'
    inputs:
      PathtoPublish: '$(build.artifactstagingdirectory)/CloudDemo.Mvc.zip'
      ArtifactName: '$(ArtifactName)'

  4. Esegui il commit delle modifiche e inviale ad Azure Pipelines.

    Visual Studio

    1. Apri Team Explorer e fai clic sull'icona Home.
    2. Fai clic su Modifiche.
    3. Inserisci un messaggio di commit come Add pipeline definition.
    4. Fai clic su Esegui commit di tutto e push.

    Riga di comando

    1. Organizza tutti i file modificati:

      git add -A

    2. Esegui il commit delle modifiche nel repository locale:

      git commit -m "Add pipeline definition"

    3. Esegui il push delle modifiche in Azure DevOps:

      git push

  5. Nel menu Azure DevOps, seleziona Pipeline e poi fai clic su Crea pipeline.

  6. Seleziona Azure Repos Git.

  7. Seleziona il repository.

  8. Nella pagina Esamina il file YAML della pipeline, fai clic su Esegui.

    Viene attivata una nuova build. Il completamento della build potrebbe richiedere circa 2 minuti. Al termine della build, il pacchetto dell'applicazione CloudDemo.Mvc.zip, che contiene tutti i file dell'applicazione web, è disponibile nell'area di archiviazione interna degli artefatti di Azure Pipelines.

Deployment continuo

Ora che Azure Pipelines compila automaticamente il codice per ogni commit, puoi concentrarti sulla distribuzione.

A differenza di altri sistemi di integrazione continua, Azure Pipelines distingue tra la compilazione e il deployment e fornisce un insieme specializzato di strumenti etichettati Release Management per tutte le attività correlate al deployment.

Azure Pipelines Release Management si basa sui seguenti concetti:

  • Una release si riferisce a un insieme di artefatti che costituiscono una versione specifica della tua app e che di solito sono il risultato di un processo di compilazione.
  • Il deployment si riferisce al processo di acquisizione di una release e al suo deployment in un ambiente specifico.
  • Un deployment esegue un insieme di attività, che possono essere raggruppate in job.
  • Le fasi ti consentono di segmentare la pipeline e possono essere utilizzate per orchestrare le implementazioni in più ambienti, ad esempio ambienti di sviluppo e test.

Configuri la pipeline di rilascio in modo che venga attivata ogni volta che viene completata una nuova build. La pipeline è composta da tre fasi:

  1. Nella prima fase, la pipeline prende il pacchetto dell'applicazione dall'area di archiviazione degli artefatti di Azure Pipelines e lo pubblica in un bucket Cloud Storage in modo che sia accessibile a Compute Engine.
  2. Nella seconda fase, la pipeline aggiorna l'ambiente di sviluppo utilizzando un aggiornamento progressivo.
  3. Nella fase finale, dopo l'approvazione, la pipeline aggiorna l'ambiente di produzione utilizzando un aggiornamento in sequenza.

Crea un bucket Cloud Storage per gli artefatti di build

Crea un bucket Cloud Storage per archiviare i pacchetti dell'applicazione. In un secondo momento, configurerai Compute Engine in modo che le nuove istanze VM possano estrarre automaticamente i pacchetti di applicazioni da questo bucket.

  1. Nella console Google Cloud , passa al progetto appena creato.

  2. Apri Cloud Shell.

    Vai a Cloud Shell

  3. Per risparmiare tempo, imposta i valori predefiniti per l'ID progetto e la zona Compute Engine:

    gcloud config set project PROJECT_ID
gcloud config set compute/zone ZONE

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud e sostituisci ZONE con il nome della zona che utilizzerai per creare le risorse. Se hai dubbi su quale zona scegliere, utilizza us-central1-a.

    Esempio:

    gcloud config set project devops-test-project-12345
gcloud config set compute/zone us-central1-a

  4. Crea un nuovo bucket Cloud Storage per i pacchetti di applicazioni:

    gcloud storage buckets create gs://$(gcloud config get-value core/project)-artifacts

    Se non vuoi conservare i pacchetti dell'applicazione di tutte le build, potresti configurare una regola del ciclo di vita degli oggetti per eliminare i file che hanno superato una determinata età.

Configurare un account di servizio per Azure Pipelines

Crea un Google Cloud service account che Azure Pipelines possa utilizzare per accedere al tuo progetto Google Cloud .

  1. Crea un account di servizio per Azure Pipelines:

    AZURE_PIPELINES_SERVICE_ACCOUNT=$(gcloud iam service-accounts create azure-pipelines --format "value(email)")

  2. Concedi i ruoli IAM Storage Object Viewer (roles/storage.objectViewer) e Storage Object Creator (roles/storage.objectCreator) al account di servizio azure-pipelines in modo che Azure Pipelines possa caricare i pacchetti di applicazioni in Cloud Storage:

    gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/storage.objectViewer
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/storage.objectCreator

  3. Concedi il ruolo Amministratore Compute (roles/compute.admin) al account di servizio azure-pipelines in modo che Azure Pipelines possa gestire le istanze VM:

    gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/compute.admin

  4. Genera una chiave del account di servizio:

    gcloud iam service-accounts keys create azure-pipelines-key.json \
  --iam-account=$AZURE_PIPELINES_SERVICE_ACCOUNT

cat azure-pipelines-key.json | base64 -w 0;echo

rm azure-pipelines-key.json

    Avrai bisogno della chiave del account di servizio in uno dei passaggi successivi.

Configura l'ambiente di sviluppo

Prima di poter configurare i passaggi in Azure Pipelines per automatizzare il deployment, devi preparare l'ambiente di sviluppo. Questa preparazione include la creazione di un gruppo di istanze gestite che gestirà le istanze VM del server web. Include anche la creazione di un bilanciatore del carico HTTP.

  1. In Cloud Shell, crea un account di servizio per il gruppo di istanze gestite:

    DEV_SERVICE_ACCOUNT=$(gcloud iam service-accounts create clouddemo-dev --format "value(email)")

  2. Concedi il ruolo IAM Storage Object Viewer (roles/storage.objectViewer) al account di servizio in modo che le istanze VM possano scaricare i pacchetti dell'applicazione da Cloud Storage:

    gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$DEV_SERVICE_ACCOUNT \
    --role roles/storage.objectViewer

  3. Concedi l'autorizzazione all'account di servizio azure-pipelines per utilizzare l'account di servizio clouddemo-dev:

    gcloud iam service-accounts add-iam-policy-binding $DEV_SERVICE_ACCOUNT \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/iam.serviceAccountUser

  4. Crea un modello di istanza che utilizzi un'immagine standard di Windows Server 2019 Core. Utilizzerai questo modello solo inizialmente, perché ogni build produrrà un nuovo modello.

    gcloud compute instance-templates create clouddemo-initial \
    --machine-type n1-standard-2 \
    --image-family windows-2019-core \
    --image-project windows-cloud \
    --service-account $DEV_SERVICE_ACCOUNT \
    --scopes https://www.googleapis.com/auth/devstorage.read_only \
    --tags gclb-backend

  5. Crea un controllo di integrità HTTP. Poiché l'applicazione non ha un endpoint di controllo di integrità dedicato, puoi eseguire query sul percorso /.

    gcloud compute http-health-checks create clouddemo-dev-http \
    --check-interval=10s --unhealthy-threshold=10 \
    --request-path=/

  6. Crea un gruppo di istanze gestite basato sul modello di istanza iniziale. Per semplicità, i seguenti comandi creano un gruppo di istanze gestite zonale. Tuttavia, puoi utilizzare lo stesso approccio per i gruppi di istanze gestite regionali che distribuiscono le istanze VM in più zone.

    gcloud compute instance-groups managed create clouddemo-dev \
    --template=clouddemo-initial \
    --http-health-check=clouddemo-dev-http \
    --initial-delay=2m \
    --size=1 && \
gcloud compute instance-groups set-named-ports clouddemo-dev --named-ports http:80

  7. Crea un servizio di backend del bilanciatore del carico che utilizzi il controllo di integrità HTTP e il gruppo di istanze gestite che hai creato in precedenza:

    gcloud compute backend-services create clouddemo-dev-backend \
    --http-health-checks clouddemo-dev-http \
    --port-name http --protocol HTTP --global && \
gcloud compute backend-services add-backend clouddemo-dev-backend \
    --instance-group clouddemo-dev --global \
    --instance-group-zone=$(gcloud config get-value compute/zone)

  8. Crea un frontend del bilanciatore del carico:

    gcloud compute url-maps create clouddemo-dev --default-service clouddemo-dev-backend && \
gcloud compute target-http-proxies create clouddemo-dev-proxy --url-map=clouddemo-dev && \
gcloud compute forwarding-rules create clouddemo-dev-fw-rule --global --target-http-proxy clouddemo-dev-proxy --ports=80

  9. Crea una regola firewall che consenta al bilanciatore del carico Google di inviare richieste HTTP alle istanze annotate con il tag gclb-backend. Applicherai questo tag in un secondo momento alle istanze VM del servizio web.

    gcloud compute firewall-rules create gclb-backend --source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gclb-backend --allow tcp:80

Configurare l'ambiente di produzione

La configurazione dell'ambiente di produzione richiede una sequenza di passaggi simile a quella per la configurazione dell'ambiente di sviluppo.

  1. In Cloud Shell, crea un controllo di integrità HTTP:

    gcloud compute http-health-checks create clouddemo-prod-http \
    --check-interval=10s --unhealthy-threshold=10 \
    --request-path=/

  2. Crea un altro gruppo di istanze gestite basato sul modello di istanza iniziale che hai creato in precedenza:

    gcloud compute instance-groups managed create clouddemo-prod \
    --template=clouddemo-initial \
    --http-health-check=clouddemo-prod-http \
    --initial-delay=2m \
    --size=1 && \
gcloud compute instance-groups set-named-ports clouddemo-prod --named-ports http:80

  3. Crea un servizio di backend del bilanciatore del carico che utilizzi il controllo di integrità HTTP e il gruppo di istanze gestite che hai creato in precedenza:

    gcloud compute backend-services create clouddemo-prod-backend --http-health-checks clouddemo-prod-http --port-name http --protocol HTTP --global && \
gcloud compute backend-services add-backend clouddemo-prod-backend --instance-group clouddemo-prod --global --instance-group-zone=$(gcloud config get-value compute/zone)

  4. Crea un frontend del bilanciatore del carico:

    gcloud compute url-maps create clouddemo-prod --default-service clouddemo-prod-backend && \
gcloud compute target-http-proxies create clouddemo-prod-proxy --url-map=clouddemo-prod && \
gcloud compute forwarding-rules create clouddemo-prod-fw-rule --global --target-http-proxy clouddemo-prod-proxy --ports=80

Configura la pipeline di rilascio

Crea una nuova definizione di release:

  1. Nel menu Azure DevOps, seleziona Pipeline > Release.
  2. Fai clic su Nuova pipeline.
  3. Dall'elenco dei modelli, seleziona Lavoro vuoto.
  4. Quando ti viene chiesto un nome per lo stage, inserisci Publish.
  5. Nella parte superiore dello schermo, dai un nome alla release clouddemo-ComputeEngine.
  6. Nel diagramma della pipeline, fai clic su Aggiungi accanto ad Artefatti.

  7. Seleziona Build e aggiungi le seguenti impostazioni:

    • Origine: seleziona il repository Git contenente il file azure-pipelines.yml.
    • Versione predefinita: Latest
    • Alias origine: CloudDemo.Web

  8. Fai clic su Aggiungi.

  9. Nella casella Artefatto, fai clic su Trigger di deployment continuo (l'icona del fulmine) per aggiungere un trigger di deployment.

  10. In Trigger di deployment continuo, imposta l'opzione su Attivato.

  11. Fai clic su Salva.

  12. Se vuoi, inserisci un commento, quindi conferma facendo clic su Ok.

La pipeline ora ha questo aspetto:

Screenshot della pipeline in Azure Pipelines

Pubblica su Cloud Storage

Ora che hai creato la definizione della release, puoi aggiungere i passaggi per pubblicare il pacchetto dell'applicazione in Cloud Storage.

  1. In Azure Pipelines, passa alla scheda Attività.
  2. Fai clic su Job dell'agente e configura le seguenti impostazioni:
    • Pool di agenti: Azure Pipelines
    • Specifiche dell'agente: ubuntu-latest
  3. Accanto a Agent job (Lavoro dell'agente), fai clic su Add a task to agent job (Aggiungi un'attività al lavoro dell'agente) .
  4. Seleziona l'attività bash e fai clic su Aggiungi.

  5. Fai clic sull'attività appena aggiunta e configura le seguenti impostazioni:

    • Nome visualizzato: Publish to Cloud Storage
    • Type: inline

    • Script:

      cat << "EOF" > CloudDemo.Mvc.deploy.ps1
    $ErrorActionPreference = "Stop"

    # Download application package from Cloud Storage
    gcloud storage cp gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).zip $env:TEMP\app.zip

    # Install IIS
    Enable-WindowsOptionalFeature -Online -FeatureName `
        NetFx4Extended-ASPNET45, `
        IIS-WebServerRole, `
        IIS-WebServer, `
        IIS-CommonHttpFeatures, `
        IIS-HttpErrors, `
        IIS-HttpRedirect, `
        IIS-ApplicationDevelopment, `
        IIS-HealthAndDiagnostics, `
        IIS-HttpLogging, `
        IIS-LoggingLibraries, `
        IIS-RequestMonitor, `
        IIS-HttpTracing, `
        IIS-Security, `
        IIS-RequestFiltering, `
        IIS-Performance, `
        IIS-WebServerManagementTools, `
        IIS-IIS6ManagementCompatibility, `
        IIS-Metabase, `
        IIS-DefaultDocument, `
        IIS-ApplicationInit, `
        IIS-NetFxExtensibility45, `
        IIS-ISAPIExtensions, `
        IIS-ISAPIFilter, `
        IIS-ASPNET45, `
        IIS-HttpCompressionStatic

    # Extract application package to wwwroot
    New-Item -ItemType directory -Path $env:TEMP\app
    Add-Type -AssemblyName System.IO.Compression.FileSystem
    [System.IO.Compression.ZipFile]::ExtractToDirectory("$env:TEMP\app.zip", "$env:TEMP\app")
    Remove-Item $env:TEMP\app.zip
    Move-Item -Path $(dir -recurse $env:TEMP\app\**\PackageTmp | % { $_.FullName }) -Destination c:\inetpub\wwwroot\app -force

    # Configure IIS web application pool and application
    Import-Module WebAdministration
    New-WebAppPool clouddemo-net4
    Set-ItemProperty IIS:\AppPools\clouddemo-net4 managedRuntimeVersion v4.0
    New-WebApplication -Name clouddemo -Site 'Default Web Site' -PhysicalPath c:\inetpub\wwwroot\app -ApplicationPool clouddemo-net4

    # Grant read/execute access to the application pool user
    &icacls C:\inetpub\wwwroot\app\ /grant "IIS AppPool\clouddemo-net4:(OI)(CI)(RX)"
EOF

gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d)

gcloud storage cp $(System.ArtifactsDirectory)/CloudDemo.Web/CloudDemo.Web/CloudDemo.Mvc.zip gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).zip
gcloud storage cp CloudDemo.Mvc.deploy.ps1 gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1

    Questo script esegue le seguenti operazioni:

    1. Genera uno script di avvio che configura IIS.
    2. Configura Google Cloud CLI in modo che utilizzi la chiave del account di servizio dalla variabile di ambiente per l'autenticazione a Google Cloud.
    3. Carica il pacchetto dell'applicazione e lo script di avvio in Cloud Storage.

  6. Passa alla scheda Variabili e aggiungi le seguenti variabili.

    Nome Valore Segreto
    ServiceAccountKey Chiave del service account creata per azure-pipelines-deployer in precedenza. Sì
    CloudDemo.ProjectId L'ID progetto del tuo progetto Google Cloud .
    CloudDemo.Zone La zona che hai specificato in precedenza durante l'esecuzione di gcloud config set compute/zone (ad esempio, us-central1-a)

  7. Fai clic su Salva.

  8. Se vuoi, inserisci un commento, quindi conferma facendo clic su Ok.

Esegui il deployment dell'ambiente di sviluppo

Ora puoi aggiungere i passaggi per avviare un deployment graduale all'ambiente di sviluppo.

  1. In Azure Pipelines, passa alla scheda Pipeline.
  2. Nella casella Fasi, seleziona Aggiungi > Nuova fase.
  3. Dall'elenco dei modelli, seleziona Lavoro vuoto.
  4. Quando ti viene chiesto un nome per lo stage, inserisci Dev.
  5. Fai clic sull'icona a forma di fulmine della fase appena creata.

  6. Configura le seguenti impostazioni:

    • Seleziona trigger: After stage
    • Tappe: Publish

  7. Tieni il mouse sopra la scheda Attività e fai clic su Attività > Sviluppo.

  8. Fai clic su Agent job e configura le seguenti impostazioni:

    • Pool di agenti: Azure Pipelines
    • Specifiche dell'agente: ubuntu-latest

  9. Accanto a Agent job (Lavoro dell'agente), fai clic su Add a task to agent job (Aggiungi un'attività al lavoro dell'agente) .

  10. Seleziona l'attività bash e fai clic su Aggiungi.

  11. Fai clic sull'attività appena aggiunta e configura le seguenti impostazioni:

    • Nome visualizzato: Rolling deploy
    • Type: inline

    • Script:

      INSTANCE_TEMPLATE=clouddemo-$(Build.BuildId)-$(Release.ReleaseId)

gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d)

gcloud compute instance-templates create $INSTANCE_TEMPLATE \
  --machine-type n1-standard-2 \
  --image-family windows-2019-core \
  --image-project windows-cloud \
  --service-account clouddemo-dev@$(CloudDemo.ProjectId).iam.gserviceaccount.com \
  --scopes https://www.googleapis.com/auth/devstorage.read_only \
  --tags gclb-backend \
  --metadata sysprep-specialize-script-url=gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1 \
  --project $(CloudDemo.ProjectId) \

gcloud compute instance-groups managed set-instance-template clouddemo-dev \
  --template $INSTANCE_TEMPLATE \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

gcloud compute instance-groups managed rolling-action start-update clouddemo-dev \
  --version template=$INSTANCE_TEMPLATE \
  --type proactive \
  --max-unavailable 0 \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

    Questo script esegue le seguenti operazioni:

    1. Configura Google Cloud CLI in modo che utilizzi la chiave del account di servizio dalla variabile di ambiente per l'autenticazione a Google Cloud.
    2. Crea un nuovo modello di istanza che utilizza lo script di avvio generato nella fase precedente.
    3. Aggiorna il gruppo di istanze esistente in modo che utilizzi il nuovo modello di istanza. Tieni presente che questo comando non causa ancora la sostituzione o l'aggiornamento di nessuna delle VM esistenti. ma garantisce che tutte le VM future in questo gruppo di istanze vengano create dal nuovo modello.
    4. Avvia un aggiornamento in sequenza, causando la sostituzione del gruppo di istanze esistente con nuove VM in modo sequenziale.

  12. Fai clic su Salva.

  13. Se vuoi, inserisci un commento e conferma facendo clic su Ok.

Esegui il deployment dell'ambiente di produzione

Infine, devi configurare il deployment nell'ambiente di produzione.

  1. In Azure Pipelines, passa alla scheda Pipeline.
  2. Nella casella Fasi, seleziona Aggiungi > Nuova fase.
  3. Dall'elenco dei modelli, seleziona Lavoro vuoto.
  4. Quando ti viene chiesto un nome per lo stage, inserisci Prod.
  5. Fai clic sull'icona a forma di fulmine della fase appena creata.

  6. Configura le seguenti impostazioni:

    • Seleziona trigger: After stage
    • Tappe: Dev
    • Approvazioni pre-deployment: (attivate)
    • Approvatori: seleziona il tuo nome utente.

  7. Tieni il mouse sopra la scheda Attività e fai clic su Attività > Prod.

  8. Fai clic su Agent job e configura le seguenti impostazioni:

    • Pool di agenti: Azure Pipelines
    • Specifiche dell'agente: ubuntu-latest

  9. Accanto a Lavoro dell'agente, fai clic su Aggiungi un'attività al lavoro dell'agente per aggiungere un passaggio alla fase.

  10. Seleziona l'attività bash e fai clic su Aggiungi.

  11. Fai clic sull'attività appena aggiunta e configura le seguenti impostazioni:

    • Nome visualizzato: Rolling deploy
    • Type: inline

    • Script:

      INSTANCE_TEMPLATE=clouddemo-$(Build.BuildId)-$(Release.ReleaseId)

gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d)

gcloud compute instance-templates create $INSTANCE_TEMPLATE \
  --machine-type n1-standard-2 \
  --image-family windows-2019-core \
  --image-project windows-cloud \
  --service-account clouddemo-prod@$(CloudDemo.ProjectId).iam.gserviceaccount.com \
  --scopes https://www.googleapis.com/auth/devstorage.read_only \
  --tags gclb-backend \
  --metadata sysprep-specialize-script-url=gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1 \
  --project $(CloudDemo.ProjectId) \

gcloud compute instance-groups managed set-instance-template clouddemo-prod \
  --template $INSTANCE_TEMPLATE \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

gcloud compute instance-groups managed rolling-action start-update clouddemo-prod \
  --version template=$INSTANCE_TEMPLATE \
  --type proactive \
  --max-unavailable 0 \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

  12. Fai clic su Salva.

  13. Se vuoi, inserisci un commento e conferma facendo clic su Ok.

esegui la pipeline.

Ora che hai configurato l'intera pipeline, puoi testarla apportando una modifica al codice sorgente:

  1. Sul computer locale, apri il file applications\clouddemo\net4\CloudDemo.Mvc\Views\Home\Index.cshtml dal repository Git che hai clonato in precedenza.
  2. Modifica il valore di ViewBag.Title da Home Page a This app runs on GKE.

  3. Esegui il commit delle modifiche e poi inviale ad Azure Pipelines.

    Visual Studio

    1. Apri Team Explorer e fai clic sull'icona Home.
    2. Fai clic su Modifiche.
    3. Inserisci un messaggio di commit come Change site title.
    4. Fai clic su Esegui commit di tutto e push.

    Riga di comando

    1. Organizza tutti i file modificati:

      git add -A

    2. Esegui il commit delle modifiche nel repository locale:

      git commit -m "Change site title"

    3. Esegui il push delle modifiche in Azure Pipelines:

      git push

  4. Nel menu Azure DevOps, seleziona Pipeline.

    Viene attivata una build.

  5. Al termine della build, seleziona Pipeline > Release. Viene avviata una procedura di rilascio.

  6. Fai clic su Release-1 per aprire la pagina dei dettagli e attendi che lo stato della fase Dev passi a Riuscito.

  7. Nella console Google Cloud , seleziona Servizi di rete > Bilanciamento del carico > clouddemo-dev.

    Prendi nota dell'indirizzo IP del frontend.

  8. Apri una nuova finestra del browser e vai al seguente indirizzo:

    http://IP_ADDRESS/clouddemo/

    dove IP_ADDRESS è l'indirizzo IP del frontend.

    Osserva che l'applicazione è stata implementata e utilizza il titolo personalizzato.

    Inizialmente potresti visualizzare un errore perché il bilanciatore del carico impiega alcuni minuti per diventare disponibile.

  9. In Azure Pipelines, fai clic sul pulsante Approva nella fase Prod per promuovere il deployment nell'ambiente di produzione.

    Se non vedi il pulsante, potresti dover prima approvare o rifiutare una release precedente.

  10. Se vuoi, inserisci un commento, quindi conferma facendo clic su Approva.

  11. Attendi che lo stato dell'ambiente Prod passi a Riuscito.

  12. Nella console Google Cloud , seleziona Servizi di rete > Bilanciamento del carico > clouddemo-prod.

    Prendi nota dell'indirizzo IP del frontend.

  13. Apri una nuova finestra del browser e vai al seguente indirizzo:

    http://IP_ADDRESS/clouddemo/

    dove IP_ADDRESS è l'indirizzo IP del frontend.

    Osserva che l'applicazione è stata implementata e utilizza il titolo personalizzato.

Esegui la pulizia

Per evitare di incorrere in ulteriori costi dopo aver completato questo tutorial, elimina le entità che hai creato.

Elimina il progetto Azure Pipelines

Per eliminare il progetto Azure Pipelines, consulta la documentazione di Azure DevOps Services. L'eliminazione del progetto Azure Pipelines comporta la perdita di tutte le modifiche al codice sorgente.

Elimina i progetti di sviluppo e produzione Google Cloud

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi