Crea una canalización de CI/CD con Azure Pipelines y Cloud Run

En este instructivo, se muestra cómo usar Azure Pipelines, Cloud Run y Container Registry para crear una canalización de integración continua/implementación continua (CI/CD) para una aplicación web ASP.NET MVC Core.

La canalización de CI/CD usa dos Google Cloud proyectos, uno para desarrollo y otro para producción, como se muestra en el siguiente diagrama.

Arquitectura de cómo las canalizaciones de compilación y lanzamiento de Azure interactúan con las canalizaciones de producción y desarrollo de Google Cloud.

Al comienzo de la canalización, los desarrolladores confirman los cambios en la base de código de ejemplo. Esta acción activa la canalización para crear una versión y, después, implementarla en Cloud Run en el clúster de desarrollo. Luego, un administrador de versiones promociona la versión para que se implemente en el proyecto de producción.

Este instructivo está dirigido a ingenieros DevOps y desarrolladores. Se supone que tienes conocimientos básicos de .NET, Azure Pipelines, Cloud Run y git. Para completar este instructivo, necesitas acceso de administrador a una cuenta de Azure DevOps.

Objetivos

Conectar Artifact Registry a Azure Pipelines para publicar imágenes de Docker
Prepara una app de muestra de.NET para implementarla en Cloud Run.
Configurar la autenticación entre Azure Pipelines y Google Cloud
Usar la administración de versiones de Azure Pipelines para organizar las implementaciones de Cloud Run

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para obtener una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios de Google Cloud nuevos cumplan con los requisitos para acceder a una prueba gratuita.

Cuando completes las tareas que se describen en este documento, podrás borrar los recursos que creaste para evitar que se te siga facturando. Para obtener más información, consulta Realiza una limpieza.

Consulta la página de precios de Azure DevOps para conocer las tarifas que podrían aplicarse por su uso.

Antes de comenzar

En este instructivo, usas dos proyectos separados, uno de desarrollo y otro de producción. Usar proyectos distintos te permite probar actualizaciones antes de implementarlos en producción y también te permite administrar funciones y permisos de Identity and Access Management (IAM) de forma individual.

Crea un proyecto de Google Cloud para el desarrollo. En el instructivo, se hace referencia a este proyecto como el proyecto de desarrollo.
Crea un proyecto de Google Cloud para la producción. En el instructivo, se hace referencia a este proyecto como el proyecto de producción.
Verify that billing is enabled for your Google Cloud project.
Asegúrate de tener una cuenta de Azure DevOps y de tener acceso de administrador a ella. Si todavía no tienes una cuenta de Azure DevOps, puedes registrarte en su página principal.

Crea un proyecto de Azure DevOps

Azure DevOps se usa con el fin de administrar el código fuente, ejecutar compilaciones y pruebas, y organizar la implementación en GKE. Para comenzar, crea un proyecto en tu cuenta de Azure DevOps.

Ve a la página principal de Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
Haz clic en Nuevo proyecto.
Ingresa un nombre de proyecto, como CloudDemo.
Configura la Visibilidad como Privada y, luego, haz clic en Crear proyecto.
Después de crear el proyecto, haz clic en Repos en el menú de la izquierda.
Haz clic en Importar para bifurcar el repositorio de dotnet-docs-samples desde GitHub y, luego, establece los siguientes valores:
- Tipo de repositorio: Git
- URL de clonación: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
Haga clic en Import.

Una vez completado el proceso de importación, verás el código fuente del repositorio de dotnet-docs-samples.

Conecta Azure Pipelines a Artifact Registry

Antes de configurar la integración continua para la app de CloudDemo, debes conectar Azure Pipelines a Artifact Registry. Esta conexión permite que Azure Pipelines publique imágenes de contenedor en Artifact Registry.

Configura una cuenta de servicio para publicar imágenes

Crea una cuenta de servicio deGoogle Cloud en tu proyecto de producción:

En la consola de Google Cloud , cambia al proyecto de producción.
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell
Inicializa las siguientes variables de entorno:
```
DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID
```
Reemplaza lo siguiente:
- DEV_PROJECT_ID: El ID del proyecto de desarrollo
- PROD_PROJECT_ID: El ID del proyecto de producción

Habilita la API de Artifact Registry en el proyecto de producción:

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

Crea un repositorio de Artifact Registry para almacenar tus imágenes de Docker:
```
gcloud artifacts repositories create docker  \
    --project=$PROD_PROJECT_ID \
    --repository-format=docker \
    --location REGION
```
Reemplaza REGION por la región de tu repositorio de Artifact Registry, por ejemplo, us-central1.

Crea una cuenta de servicio que Azure Pipelines use para publicar imágenes de Docker:

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

Otorga el rol de escritor de Artifact Registry (roles/artifactregistry.writer) a la cuenta de servicio para permitir que Azure Pipelines envíe a 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 clave de cuenta de servicio:

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

Visualiza el contenido del archivo de claves de la cuenta de servicio:
```
echo $(<azure-pipelines-publisher-oneline.json)
```
Necesitas la clave de la cuenta de servicio en uno de los siguientes pasos.

Crea una conexión de servicio para Artifact Registry

En Azure Pipelines, crea una conexión de servicio nueva para Artifact Registry:

En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, selecciona Canalizaciones > Conexiones de servicio.
Haz clic en Crear conexión de servicio.
En la lista, selecciona Registro de Docker y, luego, haz clic en Siguiente.
En el diálogo, ingresa valores para los siguientes campos:
- Tipo de registro: Otros
- Registro de Docker: https://REGION-docker.pkg.dev/PROD_PROJECT_ID/docker/
  
  Reemplaza lo siguiente:
  - REGION: la región de tu repositorio de Artifact Registry
  - PROD_PROJECT_ID: El nombre de tu proyecto de producción
- ID de Docker: _json_key
- Contraseña: Pega el contenido de azure-pipelines-publisher-oneline.json
- Nombre de conexión del servicio: gcr-tutorial
Haz clic en Guardar para crear la conexión.

Compila de forma continua

Ahora puedes usar Azure Pipelines para configurar la integración continua. Por cada confirmación que se envía al repositorio de Git, Azure Pipelines compila el código y empaqueta los artefactos de la compilación en un contenedor de Docker. Luego, el contenedor se publica en Artifact Registry.

El repositorio ya contiene el siguiente 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"]

Ahora, debes crear una canalización nueva que use la sintaxis YAML:

Mediante Visual Studio o un cliente git de línea de comandos, clona el repositorio de Git nuevo.
En la raíz del repositorio, crea un archivo llamado azure-pipelines.yml.

Copia el siguiente código en el archivo:

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

Reemplaza PROJECT_ID por el nombre de tu proyecto de producción y, luego, guarda el archivo.

Debido a que Cloud Run es un entorno basado en Linux, la canalización utiliza agentes de compilación basados en Linux.

Confirma los cambios y envíalos a Azure Pipelines.
Visual Studio
1. Abre Team Explorer y haz clic en el ícono de página principal.
2. Haz clic en Cambios.
3. Ingresa un mensaje de confirmación, como Add pipeline definition.
4. Haz clic en Confirmar todo y enviar.
Línea de comandos
1. Almacena en etapa intermedia todos los archivos modificados:
  git add -A
2. Confirma los cambios en el repositorio local:
  git commit -m "Add pipeline definition"
3. Envía los cambios a Azure DevOps:
  git push
En el menú de Azure DevOps, selecciona Canalizaciones y, luego, haz clic en Crear canalización.
Selecciona Azure Repos Git.
Selecciona tu repositorio.
En la página Revisar la canalización de YAML, haz clic en Ejecutar.

Se activará una compilación nueva. La compilación puede llevar alrededor de dos minutos.
Para verificar que la imagen se publicó en Artifact Registry, cambia a tu proyecto de producción en la consola de Google Cloud , selecciona Artifact Registry > docker y, luego, haz clic en CloudDemo.

Se muestra una sola imagen y su etiqueta. La etiqueta corresponde al ID numérico de la compilación que se ejecutó en Azure Pipelines.

Implementa de forma continua

Debido a que Azure Pipelines compila el código de forma automática y publica las imágenes de Docker de cada confirmación, ahora puedes enfocarte en la implementación.

A diferencia de otros sistemas de integración continua, Azure Pipelines distingue entre la implementación y la compilación, y ofrece un conjunto especializado de herramientas etiquetadas como Administración de versiones para todas las tareas relacionadas con la implementación.

La Administración de versiones de Azure Pipelines se basa en los siguientes conceptos:

El término versión hace referencia a un conjunto de artefactos que conforman una versión específica de la app y que, por lo general, son el resultado de un proceso de compilación.
La implementación se refiere al proceso de tomar una actualización e implementarla en un entorno específico.
Una implementación realiza un conjunto de tareas, que se pueden agrupar en trabajos.
Las etapas te permiten segmentar la canalización y se pueden usar para organizar implementaciones en varios entornos, por ejemplo, entornos de desarrollo y prueba.

Configura tu canalización de actualización para que se active cada vez que se complete una compilación nueva. La canalización consta de dos etapas: desarrollo y producción. En cada etapa, la canalización de actualización usa la imagen de Docker que produce la canalización de compilación y, luego, la canalización la implementa en Cloud Run.

La canalización de compilación que configuraste antes etiqueta cada imagen de Docker con el ID de compilación antes de publicarla en Artifact Registry. Por lo tanto, en la canalización de la versión, usas la variable $BUILD_BUILDID para identificar la imagen de Docker correcta que se implementará.

Configura Cloud Run

Cloud Run es un entorno completamente administrado y sin servidores, por lo que no necesitas aprovisionar ninguna infraestructura. Para ayudar a mantener tus implementaciones de Cloud Run seguras, debes configurar IAM.

La implementación y la ejecución de un servicio de Cloud Run implica varias identidades, como se muestra en el siguiente diagrama.

Identidades que se ejecutan como cuentas de servicio en una implementación de Cloud Run

Cada una de estas identidades se implementa como una cuenta de servicio y se usa para un propósito específico, como se describe en la siguiente tabla.

Cuenta de servicio	Usado por	Propósito	Funciones necesarias
Publicador de Azure Pipelines	Canalización de compilación	Publica imágenes de Docker en Artifact Registry	`roles/artifactregistry.writer` (solo el proyecto de producción)
Implementador de Azure Pipelines	Canalización de versión	Inicia implementaciones de Cloud Run	`roles/run.admin`
		Inicia el servicio de CloudDemo	`roles/iam.serviceAccountUser`
Agente de servicio de Cloud Run	Cloud Run	Extrae imágenes de Docker desde Artifact Registry	`roles/artifactregistry.reader` (solo el proyecto de producción)
Ejecutor de CloudDemo (cuenta de servicio del entorno de ejecución)	Servicio de CloudDemo	Accede a los recursos en Google Cloud	Ninguno

Creaste y configuraste la cuenta de servicio del publicador de Azure Pipelines. En las siguientes secciones, crearás y configurarás las cuentas de servicio restantes.

Configura la cuenta de servicio de Cloud Run

Abre Cloud Shell
Inicializa las siguientes variables de entorno:
```
DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID
```
Reemplaza lo siguiente:
- DEV_PROJECT_ID: El ID del proyecto de desarrollo
- PROD_PROJECT_ID: El ID del proyecto de producción
Habilita las API de Cloud Run y Compute Engine en los proyectos de desarrollo y producción:
```
gcloud services enable run.googleapis.com --project=$DEV_PROJECT_ID
gcloud services enable run.googleapis.com --project=$PROD_PROJECT_ID
```
Si habilitas estas API, se crearán las cuentas del agente de servicio de Cloud Run en tus proyectos.

Otorga a las dos cuentas de agente de servicio de Cloud Run acceso a Artifact Registry en el proyecto de producción donde se almacenan tus imágenes de 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 la cuenta de ejecutor de CloudDemo

Ahora puedes configurar la cuenta del ejecutor de CloudDemo, que es una cuenta de servicio del entorno de ejecución personalizada para el servicio de CloudDemo:

Crea una cuenta de servicio llamada 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 la cuenta del implementador de Azure Pipelines

Por último, crea y configura la cuenta del implementador de Azure Pipelines, que la canalización de la versión de Azure usa para implementar en Cloud Run.

Crea una cuenta de servicio llamada 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

Asigna los roles de IAM necesarios para implementar servicios o revisiones nuevos de Cloud Run en el proyecto de desarrollo:

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

Asigna el mismo conjunto de funciones para el proyecto de producción:

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 clave de cuenta de servicio:

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

Usa el resultado de este comando cuando configures la canalización de la versión.

Configura la canalización de la versión

Ahora puedes volver a Azure Pipelines para automatizar la implementación, que incluye los siguientes pasos:

Implementar en el entorno de desarrollo
Solicitar aprobación manual antes de iniciar una implementación en el entorno de producción
Implementar en el entorno de producción

Crea una definición de la versión

Primero, crea una definición de la versión:

En el menú de Azure DevOps, selecciona Canalizaciones > Versiones.
Haz clic en Nueva canalización.
En la lista de plantillas, selecciona Trabajo vacío.
Cuando se te solicite un nombre para la etapa, ingresa Development.
En la parte superior de la pantalla, nombra la canalización CloudDemo.
En el diagrama de la canalización, junto a Artifacts (Artefactos), haz clic en Add (Agregar).
Selecciona Compilar y agrega la siguiente configuración:
- Tipo de origen: Compilación
- Origen (canalización de compilación): selecciona la definición de compilación (solo debe haber una opción)
- Versión predeterminada: Más reciente
- Alias de origen: build
Haz clic en Agregar.
En el cuadro Artefacto, haz clic en el ícono del rayo Desencadenador de implementación continua para agregar un desencadenador de implementación.
En Desencadenador de implementación continua, establece la opción como Habilitado.
Haz clic en Guardar.
Si lo deseas, ingresa un comentario y, luego, haz clic en Aceptar para confirmar.

La canalización se muestra de la siguiente manera.

Implementa en el proyecto de desarrollo

Con la definición de la versión creada, ahora puedes configurar la implementación de Cloud Run para el proyecto de desarrollo.

En el menú, cambia a la pestaña Tareas.
Haz clic en Trabajo de agente.
Configura Agent specification como ubuntu-22.04.
Junto a Trabajo de agente, haz clic en Add a task to agent job para agregar un paso a la fase.
Selecciona la tarea Línea de comandos y haz clic en Agregar.

Haz clic en la tarea recién agregada y establece la siguiente configuración:

Nombre visible: Deploy image to development project

Secuencia de comandos:

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)

Este comando obtiene una clave de cuenta de servicio de una variable de entorno y, luego, usa la CLI de gcloud para implementar la aplicación en Cloud Run. La CLI de gcloud está disponible de forma predeterminada en los agentes de Azure Pipelines.

Cambia a la pestaña Variables y agrega las siguientes variables.

Nombre	Valor	Secreto
`ServiceAccountKey`	Clave de cuenta de servicio creada antes para `azure-pipelines-deployer`	Sí
`ContainerRegistry.ProjectId`	ID del proyecto de producción.
`CloudRun.Region`	Región que seleccionaste antes para implementar los recursos de Artifact Registry.
`CloudRun.ProjectId.Development`	ID del proyecto de desarrollo.
`CloudRun.ProjectId.Production`	ID del proyecto de producción.

Haz clic en Guardar.
Si lo deseas, ingresa un comentario y, luego, haz clic en Aceptar para confirmar.

Implementa en el clúster de producción

Por último, configura la implementación en el proyecto de producción:

En el menú, pasa a la pestaña Canalización.
En la casilla Etapas, selecciona Agregar > Nueva etapa.
En la lista de plantillas, selecciona Trabajo vacío.
Cuando se te solicite un nombre para la etapa, ingresa Production.
Haz clic en el ícono del rayo de la etapa recién creada.
Establece la siguiente configuración:
1. Seleccionar activador: After stage
2. Etapas: Desarrollo
3. Aprobaciones previas a la implementación: (habilitadas)
4. Aprobadores: Selecciona tu nombre de usuario.
La canalización muestra una vista similar a la siguiente.
Pasa a la pestaña Tareas.
Mantén el mouse sobre la pestaña Tareas y selecciona Tareas > Producción
Haz clic en Trabajo de agente.
Configura Agent specification como ubuntu-22.04.
Haz clic en Add a task to agent job para agregar un paso a la fase.
Selecciona la tarea Línea de comandos y, luego, haz clic en Agregar.

Haz clic en la tarea recién agregada y establece la siguiente configuración:

Nombre visible: Deploy image to production project

Secuencia de comandos:

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)

Haz clic en Guardar.
Si lo deseas, ingresa un comentario y, luego, haz clic en Aceptar para confirmar.

Ejecuta la canalización

Ahora que configuraste toda la canalización, realiza un cambio en el código fuente para probarla:

En tu computadora local, abre el archivo applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\Index.cshtml desde el repositorio de Git que clonaste antes.
Cambia el valor de ViewBag.Title de Home Page a Home Page Cloud Run.
Confirma tus cambios y envíalos a Azure Pipelines.
Visual Studio
1. Abre Team Explorer y haz clic en el ícono de página principal.
2. Haz clic en Cambios.
3. Ingresa un mensaje de confirmación, como Change site title.
4. Haz clic en Confirmar todo y enviar.
Línea de comandos
1. Almacena en etapa intermedia todos los archivos modificados:
  git add -A
2. Confirma los cambios en el repositorio local:
  git commit -m "Change site title"
3. Envía los cambios a Azure Pipelines:
  git push
En el menú de Azure DevOps, selecciona Canalizaciones. Se activará una compilación.
Cuando se complete la compilación, selecciona Canalizaciones > Versiones. Se iniciará un proceso de actualización.
Haz clic en Release-1 para abrir la página de detalles y espera a que el estado de la etapa de Desarrollo cambie a Correcto.
En la consola de Google Cloud , cambia al proyecto de desarrollo.
En el menú, selecciona Procesamiento > Cloud Run.

El servicio clouddemo se implementa correctamente.
Haz clic en clouddemo para ver más detalles.

Se muestra una URL que indica que Cloud Run aprovisionó el servicio.
Abre la URL en una pestaña nueva del navegador para verificar que la app de CloudDemo esté implementada y se use el título personalizado.
En Azure Pipelines, haz clic en Aprobar (junto a la etapa Producción) para promover la implementación en el entorno de producción.
Ingresa un comentario (opcional).
Para confirmar, haz clic en Aprobar y espera a que el estado del entorno de Producción cambie a Correcto.
En la consola de Google Cloud , cambia al proyecto de producción.
En el menú, selecciona Procesamiento > Cloud Run.

El servicio de clouddemo se implementa en el proyecto de producción.
Haz clic en clouddemo para ver más detalles.

Se muestra una URL que indica que Cloud Run aprovisionó el servicio.
Abre la URL en una pestaña nueva del navegador para verificar que la app de CloudDemo esté implementada en producción y se use el título personalizado.

Limpia

Para evitar que se generen más costos después de completar este instructivo, borra las entidades que creaste.

Borra el proyecto de Azure Pipelines

Para borrar el proyecto de Azure Pipelines, consulta la documentación de servicios de Azure DevOps. Si borras el proyecto de Azure Pipelines, se perderán todos los cambios del código fuente.

Borra los proyectos de Google Cloud desarrollo y producción

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo el contenido. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los IDs personalizados de los proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID personalizado del proyecto que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

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.

¿Qué sigue?

Configura un dominio personalizado para tu servicio de Cloud Run.
Aprende a usar Azure Pipelines para implementar la misma app en Google Kubernetes Engine.
Obtén más información para implementar apps de .NET en Google Cloud.
Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.