Creating a pipeline CI/CD with Azure Pipelines and Cloud Run

Connessione di Azure Pipelines ad Artifact Registry

Prima di poter configurare l'integrazione continua per l'app CloudDemo, devi collegare Azure Pipelines ad Artifact Registry. Questa connessione consente ad Azure Pipelines di pubblicare immagini container in Artifact Registry.

Configura un account di servizio per la pubblicazione delle immagini

Crea un Cloud de Confiance service account nel progetto di produzione:

1. Nella console Cloud de Confiance , passa al progetto di produzione.

2. Nella console Cloud de Confiance , attiva Cloud Shell.

   Attiva Cloud Shell

3. Inizializza le seguenti variabili di ambiente:

   DEV_PROJECT_ID=DEV_PROJECT_ID
   PROD_PROJECT_ID=PROD_PROJECT_ID
   

   Sostituisci quanto segue:

   • DEV_PROJECT_ID: l'ID progetto del tuo progetto di sviluppo
   • PROD_PROJECT_ID: l'ID progetto del tuo progetto di produzione

4. Abilita l'API Artifact Registry nel progetto di produzione:

   gcloud services enable artifactregistry.googleapis.com \
       --project=$PROD_PROJECT_ID
   

5. Crea un repository Artifact Registry per archiviare le tue immagini Docker:

   gcloud artifacts repositories create docker  \
       --project=$PROD_PROJECT_ID \
       --repository-format=docker \
       --location REGION
   

   Sostituisci REGION con la regione del tuo repository Artifact Registry, ad esempio us-central1.

6. Crea un account di servizio utilizzato da Azure Pipelines per pubblicare immagini Docker:

   gcloud iam service-accounts create azure-pipelines-publisher \
       --display-name="Azure Pipelines Publisher" \
       --project=$PROD_PROJECT_ID
   

7. Concedi il ruolo Writer di Artifact Registry (roles/artifactregistry.writer) al account di servizio per consentire ad Azure Pipelines di eseguire il push su Artifact Registry:

   AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$PROD_PROJECT_ID.s3ns.iam.gserviceaccount.com
   
   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
       --role roles/artifactregistry.writer \
       --project=$PROD_PROJECT_ID
   

8. Genera una chiave del account di servizio:

   gcloud iam service-accounts keys create azure-pipelines-publisher.json \
       --iam-account $AZURE_PIPELINES_PUBLISHER \
       --project=$PROD_PROJECT_ID
   
   tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json
   

9. Visualizza i contenuti del file della chiave del account di servizio:

   echo $(<azure-pipelines-publisher-oneline.json)
   

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

Crea una connessione al servizio per Artifact Registry

In Azure Pipelines, crea una nuova connessione al servizio per Artifact Registry:

1. Nel menu DevOps di Azure, seleziona Impostazioni progetto, quindi Pipeline > Connessioni di servizio.
2. Fai clic su Crea connessione di servizio.
3. Dall'elenco, seleziona Docker Registry e poi fai clic su Avanti.

4. Nella finestra di dialogo, inserisci i valori per i seguenti campi:

   • Tipo di registry: Altri

   • Docker Registry: https://REGION-docker.pkg.dev/PROD_PROJECT_ID/docker/

     Sostituisci quanto segue:

     • REGION: la regione del repository Artifact Registry
     • PROD_PROJECT_ID: il nome del progetto di produzione

   • ID Docker: _json_key

   • Password: incolla i contenuti di azure-pipelines-publisher-oneline.json.

   • Nome della connessione di servizio: gcr-tutorial

5. Fai clic su Salva per creare la connessione.

Creazione continua

Ora puoi utilizzare Azure Pipelines per configurare l'integrazione continua. Per ogni commit di cui viene eseguito il push nel repository Git, Azure Pipelines compila il codice e inserisce gli artefatti di build in un container Docker. Il container viene quindi pubblicato in Artifact Registry.

Il repository contiene già il Dockerfile seguente:

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
# 
#   http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

FROM mcr.microsoft.com/dotnet/aspnet:6.0
EXPOSE 8080

#------------------------------------------------------------------------------
# Copy publishing artifacts.
#------------------------------------------------------------------------------

WORKDIR /app
COPY CloudDemo.MvcCore/bin/Release/net6.0/publish/ /app/

ENV ASPNETCORE_URLS=http://0.0.0.0:8080

#------------------------------------------------------------------------------
# Run application in Kestrel.
#------------------------------------------------------------------------------

ENTRYPOINT ["dotnet", "CloudDemo.MvcCore.dll"]

Ora crea una nuova pipeline che utilizza la sintassi YAML:

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

3. Copia il seguente codice nel file:

   resources:
   - repo: self
     fetchDepth: 1
   pool:
     vmImage: ubuntu-22.04
   trigger:
   - master
   variables:
     TargetFramework: 'net6.0'
     BuildConfiguration: 'Release'
     DockerImageName: 'PROD_PROJECT_ID/docker/CloudDemo'
   steps:
   - task: DotNetCoreCLI@2
     displayName: Publish
     inputs:
       projects: 'applications/clouddemo/netcore/CloudDemo.MvcCore.sln'
       publishWebProjects: false
       command: publish
       arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
       zipAfterPublish: false
       modifyOutputPath: false
   - task: PublishBuildArtifacts@1
     displayName: 'Publish Artifact'
     inputs:
       PathtoPublish: '$(build.artifactstagingdirectory)'
   - task: Docker@2
     displayName: 'Login to Container Registry'
     inputs:
       command: login
       containerRegistry: 'gcr-tutorial'
   - task: Docker@2
     displayName: 'Build and push image'
     inputs:
       Dockerfile: 'applications/clouddemo/netcore/Dockerfile'
       command: buildAndPush
       repository: '$(DockerImageName)'

   Sostituisci PROJECT_ID con il nome del progetto di produzione e poi salva il file.

   Poiché Cloud Run è un ambiente basato su Linux, la pipeline utilizza agenti di build basati su Linux.

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 Review your pipeline YAML (Esamina il file YAML della pipeline), fai clic su Run (Esegui).

   Viene attivata una nuova build. Il completamento della build potrebbe richiedere circa due minuti.

9. Per verificare che l'immagine sia stata pubblicata in Artifact Registry, passa al progetto di produzione nella console Cloud de Confiance , seleziona Artifact Registry > docker, quindi fai clic su CloudDemo.

   Vengono visualizzate una singola immagine e il relativo tag. Il tag corrisponde all'ID numerico della build eseguita in Azure Pipelines.

Deployment continuo

Con Azure Pipelines che crea automaticamente il codice e pubblica le immagini Docker per ogni commit, ora puoi concentrarti sul deployment.

A differenza di altri sistemi di integrazione continua, Azure Pipelines distingue tra la compilazione e il deployment e fornisce un insieme specializzato di strumenti denominati 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 dell'app e che di solito sono il risultato di un processo di build.
• Il deployment si riferisce al processo di acquisizione di una release e del 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 i deployment in più ambienti, ad esempio gli ambienti di sviluppo e di test.

Configuri la pipeline di rilascio in modo che venga attivata ogni volta che viene completata una nuova build. La pipeline è costituita da due fasi: sviluppo e produzione. In ogni fase, la pipeline di rilascio utilizza l'immagine Docker prodotta dalla pipeline di build, quindi la pipeline la esegue il deployment in Cloud Run.

La pipeline di build che hai configurato in precedenza tagga ogni immagine Docker con l'ID build prima di pubblicarla in Artifact Registry. Pertanto, nella pipeline di rilascio, utilizzi la variabile $BUILD_BUILDID per identificare l'immagine Docker corretta da implementare.

Configura Cloud Run

Cloud Run è un ambiente serverless completamente gestito, quindi non devi eseguire il provisioning di alcuna infrastruttura. Per proteggere i deployment di Cloud Run, devi configurare IAM.

Il deployment e l'esecuzione di un servizio Cloud Run coinvolgono più identità, come mostrato nel seguente diagramma.

Ognuna di queste identità viene implementata come account di servizio e viene utilizzata per uno scopo specifico, come descritto nella tabella seguente.

Hai creato e configurato il account di servizio Publisher di Azure Pipelines. Nelle sezioni successive, crea e configura gli account di servizio rimanenti.

Configura l'account di servizio Cloud Run

1. Apri Cloud Shell.

2. Inizializza le seguenti variabili di ambiente:

   DEV_PROJECT_ID=DEV_PROJECT_ID
   PROD_PROJECT_ID=PROD_PROJECT_ID
   

   Sostituisci quanto segue:

   • DEV_PROJECT_ID: l'ID progetto del tuo progetto di sviluppo
   • PROD_PROJECT_ID: l'ID progetto del tuo progetto di produzione

3. Abilita le API Cloud Run e Compute Engine sia nel progetto di sviluppo sia in quello di produzione:

   gcloud services enable run.googleapis.com --project=$DEV_PROJECT_ID
   gcloud services enable run.googleapis.com --project=$PROD_PROJECT_ID
   

   L'abilitazione di queste API comporta la creazione degli account dell'agente di servizio Cloud Run nei tuoi progetti.

4. Concedi ai due service agent Cloud Run l'accesso ad Artifact Registry nel progetto di produzione in cui sono archiviate le immagini Docker:

   DEV_PROJECT_NUMBER=$(gcloud projects describe $DEV_PROJECT_ID \
       --format='value(projectNumber)')
   PROD_PROJECT_NUMBER=$(gcloud projects describe $PROD_PROJECT_ID \
       --format='value(projectNumber)')
   
   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member=serviceAccount:service-$DEV_PROJECT_NUMBER@serverless-robot-prod.s3ns-system.iam.gserviceaccount.com \
       --role roles/artifactregistry.reader
   
   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member=serviceAccount:service-$PROD_PROJECT_NUMBER@serverless-robot-prod.s3ns-system.iam.gserviceaccount.com \
       --role roles/artifactregistry.reader
   

Configura l'account runner CloudDemo

Ora puoi configurare l'account runner CloudDemo, che è un service account di runtime personalizzato per il servizio CloudDemo:

• Crea un account di servizio denominato CloudDemo-runner:

  gcloud iam service-accounts create clouddemo-runner \
      --display-name="CloudDemo Runner" \
      --project=$DEV_PROJECT_ID
  
  gcloud iam service-accounts create clouddemo-runner \
      --display-name="CloudDemo Runner" \
      --project=$PROD_PROJECT_ID
  
  DEV_CLOUDDEMO_RUNNER=clouddemo-runner@$DEV_PROJECT_ID.s3ns.iam.gserviceaccount.com
  
  PROD_CLOUDDEMO_RUNNER=clouddemo-runner@$PROD_PROJECT_ID.s3ns.iam.gserviceaccount.com
  

Configura l'account Azure Pipelines Deployer

Infine, crea e configura l'account Azure Pipelines Deployer, che la pipeline di rilascio di Azure utilizza per il deployment su Cloud Run.

1. Crea un account di servizio denominato azure-pipelines-deployer:

   gcloud iam service-accounts create azure-pipelines-deployer \
       --display-name="Azure Pipelines Deployer" \
       --project=$PROD_PROJECT_ID
   
   AZURE_PIPELINES_DEPLOYER=azure-pipelines-deployer@$PROD_PROJECT_ID.s3ns.iam.gserviceaccount.com
   

2. Assegna i ruoli IAM richiesti per eseguire il deployment di nuovi servizi o revisioni Cloud Run nel progetto di sviluppo:

   gcloud projects add-iam-policy-binding $DEV_PROJECT_ID \
       --member serviceAccount:$AZURE_PIPELINES_DEPLOYER \
       --role roles/run.admin
   
   gcloud iam service-accounts add-iam-policy-binding \
       $DEV_CLOUDDEMO_RUNNER \
       --member=serviceAccount:$AZURE_PIPELINES_DEPLOYER \
       --role="roles/iam.serviceAccountUser" \
       --project=$DEV_PROJECT_ID
   

3. Assegna lo stesso insieme di ruoli per il progetto di produzione:

   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member serviceAccount:$AZURE_PIPELINES_DEPLOYER \
       --role roles/run.admin
   
   gcloud iam service-accounts add-iam-policy-binding \
       $PROD_CLOUDDEMO_RUNNER \
       --member=serviceAccount:$AZURE_PIPELINES_DEPLOYER \
       --role="roles/iam.serviceAccountUser" \
       --project=$PROD_PROJECT_ID
   

4. Genera una chiave del account di servizio:

   gcloud iam service-accounts keys create azure-pipelines-deployer.json \
       --iam-account=$AZURE_PIPELINES_DEPLOYER \
       --project=$PROD_PROJECT_ID
   
   cat azure-pipelines-deployer.json | base64 -w 0
   

   Utilizzi l'output di questo comando quando configuri la pipeline di rilascio.

Configura la pipeline di rilascio

Ora puoi tornare ad Azure Pipelines per automatizzare il deployment, che include i seguenti passaggi:

• Deployment nell'ambiente di sviluppo.
• Richiedere l'approvazione manuale prima di avviare un deployment nell'ambiente di produzione.
• Deployment nell'ambiente di produzione.

Crea una definizione di release

Innanzitutto, crea una 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 Development.
5. Nella parte superiore dello schermo, assegna un nome alla pipeline CloudDemo.
6. Nel diagramma della pipeline, fai clic su Aggiungi accanto ad Artefatti.
7. Seleziona Crea e poi aggiungi le seguenti impostazioni:
   • Tipo di origine: Build
   • Origine (crea pipeline): seleziona la definizione di build (dovrebbe esserci una sola opzione)
   • Versione predefinita: Ultima
   • Alias origine: build
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 viene visualizzata in modo simile al seguente.

    

Esegui il deployment nel progetto di sviluppo

Ora che la definizione della release è stata creata, puoi configurare il deployment di Cloud Run nel progetto di sviluppo.

1. Nel menu, passa alla scheda Attività.
2. Fai clic su Agent job.
3. Imposta Agent specification su ubuntu-22.04.
4. Accanto a Lavoro dell'agente, fai clic su Aggiungi un'attività al lavoro dell'agente add per aggiungere un passaggio alla fase.
5. Seleziona l'attività Riga di comando e fai clic su Aggiungi.

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

   1. Nome visualizzato: Deploy image to development project

   2. Script:

      gcloud auth activate-service-account \
          --quiet \
          --key-file <(echo $(ServiceAccountKey) | base64 -d) && \
      gcloud run deploy clouddemo \
          --quiet \
          --service-account=clouddemo-runner@$(CloudRun.ProjectId.Development).s3ns.iam.gserviceaccount.com \
          --allow-unauthenticated \
          --image=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/clouddemo:$BUILD_BUILDID \
          --platform=managed \
          --region=$(CloudRun.Region) \
          --project=$(CloudRun.ProjectId.Development)
      

      Questo comando recupera una chiave del account di servizio da una variabile di ambiente e poi utilizza gcloud CLI per eseguire il deployment dell'applicazione in Cloud Run. gcloud CLI è disponibile per impostazione predefinita sugli agenti Azure Pipelines.

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

   Nome	Valore	Secret
   ServiceAccountKey	Chiave del service account creata per azure-pipelines-deployer in precedenza.	Sì
   ContainerRegistry.ProjectId	L'ID progetto del tuo progetto di produzione.
   CloudRun.Region	La regione che hai selezionato in precedenza per il deployment delle risorse Artifact Registry.
   CloudRun.ProjectId.Development	L'ID progetto del tuo progetto di sviluppo.
   CloudRun.ProjectId.Production	L'ID progetto del tuo progetto di produzione.

8. Fai clic su Salva.

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

Esegui il deployment nel cluster di produzione

Infine, configura il deployment nel progetto di produzione:

1. Nel menu, 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 Production.
5. Fai clic sull'icona a forma di fulmine della fase appena creata.

6. Configura le seguenti impostazioni:

   1. Seleziona trigger: Dopo la fase
   2. Stages (Palchi): Development (Sviluppo)
   3. Approvazioni pre-deployment: (attivate)
   4. Approvatori: seleziona il tuo nome utente.

   La pipeline mostra una visualizzazione simile alla seguente.

   

7. Passa alla scheda Tasks.

8. Tieni il mouse sopra la scheda Attività e seleziona Attività > Produzione.

9. Fai clic su Agent job.

10. Imposta Agent specification su ubuntu-22.04.

11. Fai clic su Aggiungi un'attività al lavoro dell'agente add per aggiungere un passaggio alla fase.

12. Seleziona l'attività Riga di comando e poi fai clic su Aggiungi.

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

    1. Nome visualizzato: Deploy image to production project

    2. Script:

       gcloud auth activate-service-account \
           --quiet \
           --key-file <(echo $(ServiceAccountKey) | base64 -d) && \
       gcloud run deploy clouddemo \
           --quiet \
           --service-account=clouddemo-runner@$(CloudRun.ProjectId.Production).s3ns.iam.gserviceaccount.com \
           --allow-unauthenticated \
           --image=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/clouddemo:$BUILD_BUILDID \
           --platform=managed \
           --region=$(CloudRun.Region) \
           --project=$(CloudRun.ProjectId.Production)
       

14. Fai clic su Salva.

15. Se vuoi, inserisci un commento, quindi 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\netcore\CloudDemo.MvcCore\Views\Home\Index.cshtml dal repository Git che hai clonato in precedenza.
2. Modifica il valore di ViewBag.Title da Home Page a Home Page Cloud Run.

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 Sviluppo diventi Riuscito.

7. Nella Cloud de Confiance console, passa al progetto di sviluppo.

8. Nel menu, seleziona Compute > Cloud Run.

   Il servizio clouddemo è stato implementato correttamente.

   

9. Fai clic su clouddemo per visualizzare ulteriori dettagli.

   Viene visualizzato un URL che mostra che Cloud Run ha eseguito il provisioning del servizio.

10. Apri l'URL in una nuova scheda del browser per verificare che l'app CloudDemo sia stata implementata e utilizzi il titolo personalizzato.

11. In Azure Pipelines, fai clic su Approva (accanto alla fase Produzione) per promuovere il deployment nell'ambiente di produzione.

12. (Facoltativo) Inserisci un commento.

13. Conferma facendo clic su Approva e attendi che lo stato dell'ambiente Produzione diventi Riuscito.

14. Nella console Cloud de Confiance , passa al progetto di produzione.

15. Nel menu, seleziona Compute > Cloud Run.

    Il servizio clouddemo viene implementato nel progetto di produzione.

16. Fai clic su clouddemo per visualizzare ulteriori dettagli.

    Viene visualizzato un URL che mostra che Cloud Run ha eseguito il provisioning del servizio.

17. Apri l'URL in una nuova scheda del browser per verificare che l'app CloudDemo sia stata implementata in produzione e che utilizzi il titolo personalizzato.