Creating a pipeline CI/CD with Azure Pipelines and 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 mostrato nel seguente diagramma.

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

All'inizio della pipeline, gli sviluppatori eseguono il commit delle modifiche alla codebase di esempio. Questa azione attiva la pipeline per creare una release e eseguirne il deployment su Cloud Run nel cluster di sviluppo. Un release manager promuove la release in modo che venga eseguito il deployment nel progetto di produzione.

Questo tutorial è rivolto a sviluppatori e ingegneri DevOps. Presuppone che tu abbia conoscenze di base di .NET, Azure Pipelines, Cloud Run e git. Per completare questo tutorial, devi disporre dell'accesso amministrativo a un account Azure DevOps.

Obiettivi

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

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 questo tutorial utilizzi due progetti separati, 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 di gestire individualmente ruoli e autorizzazioni di Identity and Access Management (IAM).

Crea un progetto Google Cloud per lo sviluppo. Il tutorial fa riferimento a questo progetto come progetto di sviluppo.
Crea un progetto Google Cloud per la produzione. Il tutorial si riferisce a questo progetto come progetto di produzione.
Verify that billing is enabled for your Google Cloud project.
Assicurati di avere un account Azure DevOps e di disporre dell'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 Cloud Run. Per iniziare, crea un progetto nel tuo account Azure DevOps.

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 progetto.
Dopo aver creato il progetto, fai clic su Repository 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
- URL clone: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
Fai clic su Importa.

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

Connessione di Azure Pipelines ad Artifact Registry

Prima di poter configurare l'integrazione continua per l'app CloudDemo, devi connettere 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 Google Cloud service account nel tuo progetto di produzione:

Nella console Google Cloud , passa al progetto di produzione.
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell
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

Abilita l'API Artifact Registry nel progetto di produzione:

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

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.

Crea un account di servizio che Azure Pipelines utilizza per pubblicare immagini Docker:

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

Concedi il ruolo Writer di Artifact Registry (roles/artifactregistry.writer) aaccount di serviziont per consentire ad Azure Pipelines di eseguire il push su Artifact 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/artifactregistry.writer \
    --project=$PROD_PROJECT_ID

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

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:

Nel menu DevOps di Azure, seleziona Impostazioni progetto, quindi seleziona Pipeline > Connessioni di servizio.
Fai clic su Crea connessione di servizio.
Dall'elenco, seleziona Docker Registry e poi fai clic su Avanti.
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
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:

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

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

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
Nel menu Azure DevOps, seleziona Pipeline e poi fai clic su Crea pipeline.
Seleziona Azure Repos Git.
Seleziona il repository.
Nella pagina Esamina il file YAML della pipeline, fai clic su Esegui.

Viene attivata una nuova build. Il completamento della build potrebbe richiedere circa due minuti.
Per verificare che l'immagine sia stata pubblicata in Artifact Registry, passa al progetto di produzione nella console Google Cloud , 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 creazione e il deployment e fornisce un insieme specializzato di strumenti denominato 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 i deployment 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 due fasi: sviluppo e produzione. In ogni fase, la pipeline di rilascio utilizza l'immagine Docker prodotta dalla pipeline di build, quindi 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.

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

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

Service account	Utilizzato da	Purpose	Ruoli richiesti
Azure Pipelines Publisher	Crea pipeline	Pubblicare immagini Docker in Artifact Registry	`roles/artifactregistry.writer` (solo progetto di produzione)
Azure Pipelines Deployer	Pipeline di rilascio	Avviare i deployment di Cloud Run	`roles/run.admin`
		Avvia il servizio CloudDemo	`roles/iam.serviceAccountUser`
Service agent Cloud Run	Cloud Run	Eseguire il pull delle immagini Docker da Artifact Registry	`roles/artifactregistry.reader` (solo progetto di produzione)
Runner CloudDemo (service account di runtime)	Servizio CloudDemo	Accedi alle risorse su Google Cloud	Nessuno

Hai creato e configurato l'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

Apri Cloud Shell.
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
Abilita le API Cloud Run e Compute Engine sia nel progetto di sviluppo che 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.

Concedi ai due service agent Cloud Run l'accesso ad Artifact 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/artifactregistry.reader

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member=serviceAccount:service-$PROD_PROJECT_NUMBER@serverless-robot-prod.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.iam.gserviceaccount.com

PROD_CLOUDDEMO_RUNNER=clouddemo-runner@$PROD_PROJECT_ID.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.

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

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

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

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.

Creare una definizione di release

Innanzitutto, crea una definizione di release:

Nel menu Azure DevOps, seleziona Pipeline > Release.
Fai clic su Nuova pipeline.
Dall'elenco dei modelli, seleziona Lavoro vuoto.
Quando ti viene chiesto un nome per lo stage, inserisci Development.
Nella parte superiore dello schermo, assegna un nome alla pipeline CloudDemo.
Nel diagramma della pipeline, fai clic su Aggiungi accanto ad Artefatti.
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
Fai clic su Aggiungi.
Nella casella Artefatto, 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 Attivato.
Fai clic su Salva.
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.

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

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

Nome visualizzato: Deploy image to development project

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=$(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.

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ì
`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.

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

Nel menu, passa alla scheda Pipeline.
Nella casella Fasi, seleziona Aggiungi > Nuova fase.
Dall'elenco dei modelli, seleziona Lavoro vuoto.
Quando ti viene chiesto un nome per lo stage, inserisci Production.
Fai clic sull'icona a forma di fulmine della fase appena creata.
Configura le seguenti impostazioni:
1. Seleziona trigger: Dopo la fase
2. Fasi: Sviluppo
3. Approvazioni pre-deployment: (attivate)
4. Approvatori: seleziona il tuo nome utente.
La pipeline mostra una visualizzazione simile alla seguente.
Passa alla scheda Attività.
Tieni il mouse sopra la scheda Attività e seleziona Attività > Produzione.
Fai clic su Agent job.
Imposta Specifica dell'agente su ubuntu-22.04.
Fai clic su Aggiungi un'attività al lavoro dell'agente per aggiungere un passaggio alla fase.
Seleziona l'attività Riga di comando e poi fai clic su Aggiungi.

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

Nome visualizzato: Deploy image to production project

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=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Production)

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

Sul computer locale, apri il file applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\Index.cshtml dal repository Git che hai clonato in precedenza.
Modifica il valore di ViewBag.Title da Home Page a Home Page Cloud Run.
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
Nel menu Azure DevOps, seleziona Pipeline. Viene attivata una build.
Al termine della build, seleziona Pipeline > Release. Viene avviata una procedura di rilascio.
Fai clic su Release-1 per aprire la pagina dei dettagli e attendi che lo stato della fase Sviluppo diventi Riuscito.
Nella console Google Cloud , passa al progetto di sviluppo.
Nel menu, seleziona Compute > Cloud Run.

Il servizio clouddemo è stato implementato correttamente.
Fai clic su clouddemo per visualizzare ulteriori dettagli.

Viene visualizzato un URL che mostra che Cloud Run ha eseguito il provisioning del servizio.
Apri l'URL in una nuova scheda del browser per verificare che l'app CloudDemo sia stata implementata e utilizzi il titolo personalizzato.
In Azure Pipelines, fai clic su Approva (accanto alla fase Produzione) per promuovere il deployment nell'ambiente di produzione.
(Facoltativo) Inserisci un commento.
Conferma facendo clic su Approva e attendi che lo stato dell'ambiente Produzione passi a Riuscito.
Nella console Google Cloud , passa al progetto di produzione.
Nel menu, seleziona Compute > Cloud Run.

Il servizio clouddemo viene implementato nel progetto di produzione.
Fai clic su clouddemo per visualizzare ulteriori dettagli.

Viene visualizzato un URL che mostra che Cloud Run ha eseguito il provisioning del servizio.
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.

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

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à descritte in questo documento, eliminerai anche tutto il lavoro che hai 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.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi

Configura un dominio personalizzato per il tuo servizio Cloud Run.
Scopri come utilizzare Azure Pipelines per eseguire il deployment della stessa app su Google Kubernetes Engine in alternativa.
Scopri di più sul deployment di app .NET su Google Cloud.
Esplora architetture, diagrammi e best practice di riferimento su Google Cloud. Consulta il nostro Cloud Architecture Center.