Creazione di una pipeline CI/CD con Azure Pipelines e Cloud Run

Questo tutorial mostra come utilizzare Azure Pipelines, Cloud Run e Container Registry per creare una pipeline di integrazione continua/deployment continuo (CI/CD) per un'applicazione web ASP.NET MVC Core.

La pipeline CI/CD utilizza due progetti Google Cloud, uno per lo sviluppo e uno per la produzione, come mostra il diagramma seguente.

Architettura di come le pipeline di build e release di Azure interagiscono con le pipeline di produzione e sviluppo di Google Cloud.

All'inizio della pipeline, gli sviluppatori eseguono il commit delle modifiche al codebase di esempio. Questa azione fa sì che la pipeline crei una release e ne esegua il deployment in Cloud Run nel cluster di sviluppo. Quindi, un release manager promuove la release in modo che venga sottoposta a deployment nel progetto di produzione.

Questo tutorial è destinato agli sviluppatori e ai tecnici DevOps. Si presume che tu abbia una conoscenza di base di .NET Core, Azure Pipelines, Cloud Run e git. Per completare questo tutorial, devi disporre dell'accesso amministrativo a un account DevOps di Azure.

Obiettivi

  • Connetti Container Registry ad Azure Pipelines per la pubblicazione delle immagini Docker.
  • Preparare un'app di esempio.NET Core per il deployment in Cloud Run.
  • Configura l'autenticazione tra Azure Pipelines e Google Cloud.
  • Usa la gestione delle release di Azure Pipelines per orchestrare i deployment di Cloud Run.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

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 questo tutorial utilizzerai due progetti distinti, uno per lo sviluppo e uno per la produzione. L'utilizzo di progetti separati ti consente di testare le release prima di eseguirne il deployment in produzione e ti consente anche di gestire singolarmente i ruoli e le autorizzazioni di Identity and Access Management (IAM).

  1. Creare un progetto Google Cloud per lo sviluppo. Il tutorial fa riferimento a questo progetto come progetto di sviluppo.
  2. Creare un progetto Google Cloud per la produzione. Il tutorial fa riferimento a questo progetto come progetto di produzione.

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Assicurati di avere un account Azure DevOps 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 Cloud Run. Per iniziare, crea un progetto nel tuo account DevOps di Azure.

  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 progetto.
  5. Dopo aver creato il progetto, fai clic su Repos 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
    • Clona URL: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git

  7. Fai clic su Import (Importa).

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

Connessione di pipeline Azure a Container Registry

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

Configura un account di servizio per pubblicare le immagini

Crea un account di servizio Google Cloud nel tuo progetto di produzione:

  1. Nella console Google Cloud, passa al progetto di produzione.

  2. In the Google Cloud console, activate Cloud Shell.

    Activate 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 del tuo progetto di sviluppo
    • PROD_PROJECT_ID: l'ID del tuo progetto di produzione

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

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

  5. 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

  6. Concedi il ruolo IAM Amministratore archiviazione (roles/storage.admin) all'account di servizio per consentire il push delle pipeline Azure a Container Registry:

    AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$PROD_PROJECT_ID.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
    --role roles/storage.admin \
    --project=$PROD_PROJECT_ID

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

  8. Visualizza i contenuti del file della chiave dell'account di servizio:

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

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

Crea una connessione a un servizio per Container Registry

In Azure Pipelines, crea una nuova connessione di servizio per Container Registry:

  1. Nel menu DevOps di Azure, seleziona Impostazioni progetto, quindi Pipelines > Connessioni del servizio.
  2. Fai clic su Crea connessione servizio.
  3. Seleziona Docker Registry dall'elenco, quindi fai clic su Next (Avanti).
  4. Nella finestra di dialogo, inserisci i valori per i seguenti campi:
    • Tipo di registry: Altri
    • Docker Registry: https://gcr.io/PROD_PROJECT_ID, che sostituisce PROD_PROJECT_ID con il nome del tuo progetto di produzione (ad esempio https://gcr.io/azure-pipelines-test-project-12345).
    • ID dock: _json_key
    • Password: incolla i contenuti di azure-pipelines-publisher-oneline.json.
    • Nome connessione servizio: gcr-tutorial
  5. Fai clic su Salva per creare la connessione.

Creazione continua

Ora puoi utilizzare le pipeline di Azure per configurare l'integrazione continua. Per ogni commit inviato al repository Git, Azure Pipelines crea il codice e pacchettizza gli artefatti di build in un container Docker. Il container viene quindi pubblicato in Container Registry.

Il repository contiene già il seguente Dockerfile:

Applications/clouddemo/netcore/Dockerfile 
#
# 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 creerai una nuova pipeline che utilizza la sintassi YAML:

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

  3. Copia il seguente codice nel file:

    resources:
- repo: self
  fetchDepth: 1
queue:
  name: Hosted Ubuntu 1604
trigger:
- master
variables:
  TargetFramework: 'net6.0'
  BuildConfiguration: 'Release'
  DockerImageName: 'PROD_PROJECT_ID/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 tuo progetto di produzione, quindi 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 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

  5. Nel menu DevOps di Azure, seleziona Pipelines e fai clic su Crea pipeline.

  6. Seleziona Azure Repos Git.

  7. Seleziona il tuo repository.

  8. Nella pagina Controlla la pipeline YAML, fai clic su 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 Container Registry, passa al tuo progetto di produzione nella console Google Cloud, seleziona Container Registry > Immagini, quindi fai clic su CloudDemo.

    Vengono visualizzate una singola immagine e il tag di questa immagine. Il tag corrisponde all'ID numerico della build che è stato eseguito in Azure Pipelines.

Deployment continuo

Con Azure Pipelines, che crea automaticamente il tuo codice e pubblica immagini Docker per ogni commit, ora puoi concentrarti 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 per la gestione delle release 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 per gli ambienti di sviluppo e test.

Configura l'attivazione della pipeline di rilascio ogni volta che viene completata una nuova build. La pipeline si compone di due fasi: sviluppo e produzione. In ogni fase, la pipeline di rilascio utilizza l'immagine Docker prodotta dalla pipeline di build, quindi ne esegue il deployment in Cloud Run.

La pipeline di build configurata in precedenza tagga ogni immagine Docker con l'ID build prima di pubblicarla in Container Registry. Pertanto, nella pipe di rilascio, utilizzi la variabile $BUILD_BUILDID per identificare l'immagine Docker giusta di cui eseguire il deployment.

Configura Cloud Run

Cloud Run è un ambiente serverless completamente gestito, per cui non è necessario eseguire il provisioning di alcuna infrastruttura. Per contribuire alla sicurezza dei deployment di Cloud Run, devi configurare IAM.

Il deployment e l'esecuzione di un servizio Cloud Run prevedono più identità, come mostra il seguente diagramma.

Identità che vengono eseguite come account di servizio in un deployment di Cloud Run.

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

Account di servizio Usata da Purpose Ruoli richiesti
Publisher Azure Azure Crea pipeline Pubblica immagini Docker in Container Registry roles/storage.admin (solo progetto di produzione)
Deployer pipeline Azure Pipeline di rilascio Avvia deployment Cloud Run roles/run.admin
Avvia il servizio CloudDemo roles/iam.serviceAccountUser
Agente di servizio Cloud Run Cloud Run Esegui il pull delle immagini Docker da Container Registry roles/storage.objectViewer (solo progetto di produzione)
Runner CloudDemo (account di servizio runtime) Servizio CloudDemo Accesso alle risorse su Google Cloud Nessuno

Hai creato e configurato l'account di servizio Publisher di Azure Pipelines. Nelle sezioni seguenti, creerai e configurerai 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 del tuo progetto di sviluppo
    • PROD_PROJECT_ID: l'ID del tuo progetto di produzione

  3. Abilitare le API Cloud Run e Compute Engine sia nei progetti di sviluppo che in quelli di prodotto:

    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 di agente di servizio Cloud Run nei progetti.

  4. Concedi ai due account di agente di servizio Cloud Run l'accesso a Container Registry nel progetto di produzione in cui sono archiviate le tue 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.iam.gserviceaccount.com \
    --role roles/storage.objectViewer

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member=serviceAccount:service-$PROD_PROJECT_NUMBER@serverless-robot-prod.iam.gserviceaccount.com \
    --role roles/storage.objectViewer

Configura l'account runner CloudDemo

Ora puoi configurare l'account runner CloudDemo, che è un account di servizio in esecuzione 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.iam.gserviceaccount.com

PROD_CLOUDDEMO_RUNNER=clouddemo-runner@$PROD_PROJECT_ID.iam.gserviceaccount.com

Configura l'account Deployer Deployer di Azure Pipelines

Infine, crea e configura l'account Azure Pipelines Deployer, che la pipeline di rilascio Azure usa per eseguire il deployment in 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.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 dell'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

    Puoi utilizzare 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 in corso...
  • Richiedere l'approvazione manuale prima di avviare un deployment nell'ambiente di produzione.
  • Deployment nell'ambiente di produzione in corso...

Crea una definizione di release

Innanzitutto, crea una definizione di release:

  1. Nel menu Azure DevOps, seleziona Pipelines > Release.
  2. Fai clic su Nuova pipeline.
  3. Dall'elenco dei modelli, seleziona Job vuoto.
  4. Quando ti viene chiesto un nome per la fase, inserisci Development.
  5. Nella parte superiore dello schermo, assegna un nome alla pipeline CloudDemo.
  6. Nel diagramma della pipeline, accanto ad Artefatti, fai clic su Aggiungi.
  7. Seleziona Build e aggiungi le seguenti impostazioni:
    • Tipo di origine: build
    • Origine (pipeline di build): seleziona la definizione di build (deve esserci una sola opzione)
    • Versione predefinita: Più recente
    • Alias origine: build
  8. Fai clic su Add (Aggiungi).
  9. Nella casella Elemento, 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 Abilitato.
  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.

    Visualizzazione pipeline della configurazione del deployment automatico.

Esegui il deployment nel progetto di sviluppo

Dopo aver creato la definizione della release, puoi configurare il deployment di Cloud Run nel progetto di sviluppo.

  1. Nel menu, passa alla scheda Attività.
  2. Fai clic su Job agente.
  3. Imposta Specifica dell'agente su ubuntu-18.04.
  4. Accanto a Job agente, fai clic su Aggiungi un'attività al job agente 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).iam.gserviceaccount.com \
    --allow-unauthenticated \
    --image=gcr.io/$(ContainerRegistry.ProjectId)/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Development)

      Questo comando ottiene una chiave dell'account di servizio da una variabile di ambiente e quindi utilizza l'interfaccia alla gcloud CLI per eseguire il deployment dell'applicazione in Cloud Run. Gcloud CLI è disponibile per impostazione predefinita sugli agenti di Azure Pipelines.

  7. 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ì
    ContainerRegistry.ProjectId ID del progetto di produzione.
    CloudRun.Region Regione selezionata in precedenza in cui eseguire il deployment delle risorse Cloud Run.
    CloudRun.ProjectId.Development ID del progetto di sviluppo.
    CloudRun.ProjectId.Production ID del progetto di produzione.

  8. Fai clic su Salva.

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

Eseguire il deployment nel cluster di produzione

Infine, configurerai 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 Job vuoto.
  4. Quando ti viene chiesto un nome per la fase, inserisci Production.
  5. Fai clic sull'icona a forma di lampo della fase appena creata.

  6. Configura le seguenti impostazioni:

    1. Seleziona trigger: dopo la fase.
    2. Fasi: sviluppo
    3. Approvazioni precedenti al deployment: (abilitate)
    4. Approvatori: seleziona il tuo nome utente.

    La pipeline visualizza una vista simile alla seguente.

    Visualizzazione pipeline della configurazione del deployment del cluster.

  7. Passa alla scheda Attività.

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

  9. Fai clic su Job agente.

  10. Imposta Specifica dell'agente su ubuntu-18.04.

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

  12. Seleziona l'attività Riga di comando, quindi 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).iam.gserviceaccount.com \
    --allow-unauthenticated \
    --image=gcr.io/$(ContainerRegistry.ProjectId)/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 eseguendo una modifica del 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. Nella riga 26, modifica il valore di ViewBag.Title da Home Page a Home Page Cloud Run.

  3. 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

  4. Nel menu DevOps di Azure, seleziona Pipelines. Viene attivata una build.

  5. Una volta terminata la build, seleziona Pipelines > Release. Viene avviato un processo di rilascio.

  6. Fai clic su Release-1 per aprire la pagina dei dettagli e attendi lo stato della fase di Sviluppo per passare a Riuscito.

  7. Nella console Google Cloud, passa al progetto di sviluppo.

  8. Nel menu, seleziona Compute > Cloud Run.

    Il deployment del servizio clouddemo è stato eseguito correttamente.

    Stato del deployment in Cloud Run.

  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 sottoposta a deployment e utilizzi il titolo personalizzato.

  11. In Pipelines di Azure, fai clic su Approva (accanto alla fase di 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 di produzione passi a Riuscito.

  14. Nella console Google Cloud, passa al progetto di produzione.

  15. Nel menu, seleziona Compute > Cloud Run.

    Il deployment del servizio clouddemo viene eseguito 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 sia stato eseguito il deployment in produzione dell'app CloudDemo e che utilizzi 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

  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