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 il test e uno per la produzione.

All'inizio della pipeline, gli sviluppatori impegnano le modifiche al codebase di esempio. Questa azione attiva la pipeline per creare l'applicazione, pacchettizzarla come file ZIP e caricare il file ZIP su Cloud Storage.

Il pacchetto viene quindi rilasciato automaticamente nell'ambiente di sviluppo tramite un aggiornamento in sequenza. Una volta testato, la release può promuovere la release in modo che ne venga eseguito il deployment nell'ambiente di produzione.

Questo tutorial è destinato agli sviluppatori e ai tecnici DevOps. Si presume di avere una conoscenza di base di .NET Framework, Windows Server, IIS, Azure Pipelines e Compute Engine. Il tutorial richiede anche di avere l'accesso amministrativo a un account DevOps di Azure.

Obiettivi

Utilizza i gruppi di istanze gestite di Compute Engine per implementare i deployment in sequenza.
Configurare 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 possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Consulta la pagina dei prezzi di DevOps di Azure per conoscere le eventuali tariffe applicabili 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 gestione di identità e accessi (IAM) possano essere concessi singolarmente. Per semplicità, questo tutorial utilizza un singolo progetto per gli ambienti di sviluppo e produzione.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

Vai al selettore progetti

Abilita le API Compute Engine and Cloud Storage.
Abilita le API

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Assicurati di avere un account DevOps di Azure e di avere l'accesso come amministratore. Se non hai ancora un account DevOps di Azure, puoi registrarti sulla home page di Azure DevOps.

Crea un progetto Azure Azure

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 DevOps di Azure.

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

Al termine della procedura di importazione, viene visualizzato il codice sorgente del repository dotnet-docs-samples.
Nel menu, fai clic su Repository > Rami.
Sposta il mouse sul ramo main. Sulla destra viene visualizzato il pulsante ....
Fai clic su ... > Imposta come ramo predefinito.

Creazione continua

Ora puoi utilizzare Azure Pipelines per configurare una pipeline di build. Per ogni commit di cui è stato eseguito il push nel repository Git, Azure Pipelines crea il codice, lo pacchettizza in un file ZIP e pubblica il pacchetto risultante nell'archiviazione interna di Azure Pipelines.

In seguito, configurerai una pipeline di rilascio che utilizza i pacchetti dallo spazio di archiviazione di Azure Pipelines e ne esegue il deployment in Compute Engine.

Crea una definizione di build

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

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

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

Esegui il commit delle modifiche e inviale a Azure Pipelines.
Studio visivo
1. Apri Team Explorer e fai clic sull'icona Home.
2. Fai clic su Modifiche.
3. Inserisci un messaggio di commit, ad esempio Add pipeline definition.
4. Fai clic su Commit All and Push.
Riga di comando
1. Archiviazione temporanea di 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 ad Azure DevOps:
```
git push
```
Nel menu DevOps di Azure, seleziona Pipelines e fai clic su Crea pipeline.
Seleziona Azure Repos Git.
Seleziona il tuo repository.
Nella pagina Controlla la pipeline YAML, fai clic su Esegui.

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

Deployment continuo

Ora che Azure Pipelines crea automaticamente il tuo codice per ogni commit, puoi concentrare l'attenzione sul deployment.

A differenza di altri sistemi di integrazione continua, Azure Pipelines distingue tra creazione e deployment e fornisce un set specializzato di strumenti etichettati come Release Management per tutte le attività relative al deployment.

Azure Pipelines Release Management si basa sui seguenti concetti:

Una release si riferisce a un insieme di elementi che costituiscono una versione specifica dell'app e che di solito sono il risultato di un processo di compilazione.
Il deployment si riferisce al processo di prendere una release e di eseguirne il deployment in un ambiente specifico.
Un deployment esegue un set di attività che possono essere raggruppate nei job.
Le fasi ti consentono di segmentare la pipeline e possono essere utilizzate per orchestrare i deployment in più ambienti, ad esempio ambienti di sviluppo e test.

Configura l'attivazione della pipeline di rilascio ogni volta che viene completata una nuova build. La pipeline è composta da tre fasi:

Nella prima fase, la pipeline prende il pacchetto dell'applicazione dall'area di archiviazione degli artefatti delle pipeline di Azure e lo pubblica in un bucket Cloud Storage, in modo che il pacchetto sia accessibile da Compute Engine.
Nella seconda fase, la pipeline aggiorna l'ambiente di sviluppo utilizzando un aggiornamento in sequenza.
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 della build

Creare un bucket Cloud Storage per l'archiviazione dei pacchetti dell'applicazione. In seguito, configurerai Compute Engine in modo che le nuove istanze VM possano estrarre automaticamente i pacchetti dell'applicazione da questo bucket.

Nella console Google Cloud, passa al progetto appena creato.
Apri Cloud Shell.

Vai a Cloud Shell
Per risparmiare tempo, imposta 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 in merito alla zona da scegliere, utilizza us-central1-a.

Esempio:
```
gcloud config set project devops-test-project-12345
gcloud config set compute/zone us-central1-a
```
Crea un nuovo bucket Cloud Storage per i pacchetti di applicazioni:
```
gsutil mb 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 superano una determinata età.

Configura un account di servizio per Azure Pipelines

Creare un account di servizio Google Cloud che Azure Pipelines possa utilizzare per accedere al progetto Google Cloud.

Crea un account di servizio per Azure Pipelines:

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

Concedi al visualizzatore oggetti Storage (roles/storage.objectViewer) e al creatore oggetti Storage (roles/storage.objectCreator) i ruoli IAM all'account di servizio azure-pipelines in modo che le pipeline di Azure possano caricare i pacchetti dell'applicazione 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

Concedi il ruolo Amministratore Compute (roles/compute.admin) all'account di servizio azure-pipelines in modo che le pipeline di Azure possano 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

Genera una chiave dell'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

Devi avere la chiave dell'account di servizio in uno dei seguenti passaggi.

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 inoltre la creazione di un bilanciatore del carico HTTP.

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

Concedi il ruolo IAM Visualizzatore oggetti Storage (roles/storage.objectViewer) all'account di servizio per consentire alle istanze VM di scaricare pacchetti di applicazioni da Cloud Storage:
```
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$DEV_SERVICE_ACCOUNT \
    --role roles/storage.objectViewer
```

Concedi all'account di servizio azure-pipelines l'autorizzazione 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

Crea un modello di istanza che utilizza un'immagine di base di Windows Server 2019 standard. Utilizzerai questo modello solo inizialmente, perché ogni build genererà 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

Creare un controllo di integrità HTTP. Poiché l'applicazione non dispone di un endpoint dedicato al controllo di integrità, puoi eseguire una query sul percorso /.
```
gcloud compute http-health-checks create clouddemo-dev-http \
    --check-interval=10s --unhealthy-threshold=10 \
    --request-path=/
```
Crea un gruppo di istanze gestite basato sul modello di istanza iniziale. Per semplicità, i seguenti comandi creano un gruppo di istanze gestite a livello di zona. Tuttavia, puoi utilizzare lo stesso approccio per i gruppi di istanze gestite a livello di area geografica che distribuiscono istanze VM in più di una zona.
```
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
```

Crea un servizio di backend del bilanciatore del carico che utilizzi il controllo di integrità HTTP e il gruppo di istanze gestite 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)

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

Crea una regola firewall che consenta al bilanciatore del carico di Google di inviare richieste HTTP alle istanze annotate con il tag gclb-backend. Successivamente applichi questo tag 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
```

Configura l'ambiente di produzione

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

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=/

Crea un altro gruppo di istanze gestite basato sul modello di istanza iniziale 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

Crea un servizio di backend del bilanciatore del carico che utilizzi il controllo di integrità HTTP e il gruppo di istanze gestite 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)

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:

Nel menu Azure DevOps, seleziona Pipelines > Release.
Fai clic su Nuova pipeline.
Dall'elenco dei modelli, seleziona Job vuoto.
Quando ti viene chiesto un nome per la fase, inserisci Publish.
Nella parte superiore dello schermo, assegna un nome alla release clouddemo-ComputeEngine.
Nel diagramma della pipeline, accanto ad Artefatti, fai clic su Aggiungi.
Seleziona Build e aggiungi le seguenti impostazioni:
- Origine: seleziona il repository Git che contiene il file azure-pipelines.yml.
- Versione predefinita: Latest
- Alias origine: CloudDemo.Web
Fai clic su Add (Aggiungi).
Nella casella Elemento, fai clic su Trigger di deployment continuo (l'icona del fulmine) per aggiungere un trigger di deployment.
In Trigger di deployment continuo, imposta l'opzione su Abilitato.
Fai clic su Salva.
Se vuoi, inserisci un commento, quindi conferma facendo clic su OK.

La pipeline ora ha il seguente aspetto:

Screenshot della pipeline in Azure Pipelines

Pubblica in Cloud Storage

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

In Azure Pipelines, passa alla scheda Tasks.
Fai clic su Job agente e configura le seguenti impostazioni:
- Pool di agenti: Azure Pipelines
- Specifica dell'agente: ubuntu-latest
Accanto a Job agente, fai clic su Aggiungi un'attività a job agente .
Seleziona l'attività bash e fai clic su Add (Aggiungi).

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

Nome visualizzato: Publish to Cloud Storage
Tipo: inline

Script:

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

    # Download application package from Cloud Storage
    gsutil 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)

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

Questo script esegue le seguenti operazioni:

Genera uno script di avvio che configura IIS.
Configura Google Cloud CLI in modo da utilizzare la chiave dell'account di servizio della variabile di ambiente per l'autenticazione in Google Cloud.
Carica il pacchetto dell'applicazione e lo script di avvio su Cloud Storage.

Passa alla scheda Variabili e aggiungi le seguenti variabili.

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

Fai clic su Salva.
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 in sequenza all'ambiente di sviluppo.

In Pipelines di Azure, passa alla scheda Pipeline.
Nella casella Fasi, seleziona Aggiungi > Nuova fase.
Dall'elenco dei modelli, seleziona Job vuoto.
Quando ti viene chiesto un nome per la fase, inserisci Dev.
Fai clic sull'icona a forma di lampo della fase appena creata.
Configura le seguenti impostazioni:
- Seleziona l'attivatore: After stage
- Fasi: Publish
Tieni il mouse sulla scheda Attività e fai clic su Attività > Dev.
Fai clic su Job agente e configura le seguenti impostazioni:
- Pool di agenti: Azure Pipelines
- Specifica dell'agente: ubuntu-latest
Accanto a Job agente, fai clic su Aggiungi un'attività a job agente .
Seleziona l'attività bash e fai clic su Add (Aggiungi).

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

Nome visualizzato: Rolling deploy
Tipo: 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:

Configura Google Cloud CLI in modo da utilizzare la chiave dell'account di servizio della variabile di ambiente per l'autenticazione in Google Cloud.
Crea un nuovo modello di istanza che utilizza lo script di avvio generato dalla fase precedente.
Aggiorna il gruppo di istanze esistente per utilizzare il nuovo modello di istanza. Tieni presente che questo comando non fa ancora sostituire o aggiornare nessuna delle VM esistenti. Garantisce invece che tutte le VM future in questo gruppo di istanze vengano create dal nuovo modello.
Avvia un aggiornamento in sequenza, facendo sì che il gruppo di istanze esistente sostituisca le VM esistenti con nuove VM in modo continuativo.

Fai clic su Salva.
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.

In Pipelines di Azure, passa alla scheda Pipeline.
Nella casella Fasi, seleziona Aggiungi > Nuova fase.
Dall'elenco dei modelli, seleziona Job vuoto.
Quando ti viene chiesto un nome per la fase, inserisci Prod.
Fai clic sull'icona a forma di lampo della fase appena creata.
Configura le seguenti impostazioni:
- Seleziona l'attivatore: After stage
- Fasi: Dev
- Approvazioni precedenti al deployment: (abilitate)
- Approvatori: seleziona il tuo nome utente.
Tieni il mouse sulla scheda Attività e fai clic su Attività > Prod.
Fai clic su Job agente e configura le seguenti impostazioni:
- Pool di agenti: Azure Pipelines
- Specifica dell'agente: ubuntu-latest
Accanto a Job agente, fai clic su Aggiungi un'attività al job agente per aggiungere un passaggio alla fase.
Seleziona l'attività bash e fai clic su Add (Aggiungi).

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

Nome visualizzato: Rolling deploy
Tipo: 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)

Fai clic su Salva.
Se vuoi, inserisci un commento e conferma facendo clic su OK.

esegui la pipeline.

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

Sul computer locale, apri il file applications\clouddemo\net4\CloudDemo.Mvc\Views\Home\Index.cshtml dal repository Git che hai clonato in precedenza.
Modifica il valore di ViewBag.Title da Home Page a This app runs on GKE.
Esegui il commit delle modifiche e inviale ad Azure Pipelines.
Studio visivo
1. Apri Team Explorer e fai clic sull'icona Home.
2. Fai clic su Modifiche.
3. Inserisci un messaggio di commit, ad esempio Change site title.
4. Fai clic su Commit All and Push.
Riga di comando
1. Archiviazione temporanea di 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 ad Azure Pipelines:
```
git push
```
Nel menu DevOps di Azure, seleziona Pipelines.

Viene attivata una build.
Una volta completata la build, seleziona Pipelines > Releases. Viene avviato un processo di rilascio.
Fai clic su Release-1 per aprire la pagina dei dettagli e attendi lo stato della fase Dev per passare a Riuscito.
Nella console Google Cloud, seleziona Servizi di rete > Bilanciamento del carico > clouddemo-dev.

Prendi nota dell'indirizzo IP del frontend.
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 è stato eseguito il deployment dell'applicazione e sta utilizzando il titolo personalizzato.

Inizialmente potresti visualizzare un errore perché il bilanciatore del carico richiede qualche minuto per diventare disponibile.
In Pipelines di Azure, fai clic sul pulsante Approva nella fase di produzione per promuovere il deployment nell'ambiente di produzione.

Se non vedi il pulsante, potrebbe essere necessario approvare o rifiutare una release precedente.
Se vuoi, inserisci un commento, quindi conferma facendo clic su Approva.
Attendi che lo stato dell'ambiente Prod passi a Riuscito.
Nella console Google Cloud, seleziona Servizi di rete > Bilanciamento del carico > clouddemo-prod.

Prendi nota dell'indirizzo IP del frontend.
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 è stato eseguito il deployment dell'applicazione e sta utilizzando il titolo personalizzato.

Esegui la pulizia

Per evitare che ti vengano addebitati altri 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 dei servizi DevOps di Azure. L'eliminazione del progetto Azure Pipelines causa la perdita di tutte le modifiche al codice sorgente.

Elimina i progetti di sviluppo e produzione di Google Cloud

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Scopri di più sulle best practice per la gestione delle immagini.
Scopri come eseguire il deployment di un gruppo SQL Server a disponibilità elevata su Compute Engine.
Ulteriori informazioni su .NET su Google Cloud Platform.
Installa Cloud Tools for Visual Studio.
Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Dai un'occhiata al nostro Centro di architettura cloud.

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

Obiettivi

Costi

Prima di iniziare

Crea un progetto Azure Azure

Creazione continua

Crea una definizione di build

Studio visivo

Riga di comando

Deployment continuo

Crea un bucket Cloud Storage per gli artefatti della build

Configura un account di servizio per Azure Pipelines

Configura l'ambiente di sviluppo

Configura l'ambiente di produzione

Configura la pipeline di rilascio

Pubblica in Cloud Storage

Esegui il deployment dell'ambiente di sviluppo

Esegui il deployment dell'ambiente di produzione

esegui la pipeline.

Studio visivo

Riga di comando

Esegui la pulizia

Elimina il progetto Azure Pipelines

Elimina i progetti di sviluppo e produzione di Google Cloud

Passaggi successivi