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 a fin de 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 proyectos de Google Cloud, 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 y desarrolladores de DevOps. Se supone que tienes conocimientos básicos de .NET Core, Azure Pipelines, Cloud Run y git. Para completar este instructivo, necesitas acceso de administrador a una cuenta de Azure DevOps.

Objetivos

  • Conectar Container Registry con Azure Pipelines para publicar imágenes de Docker
  • Preparar una app de muestra de .NET Core 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 generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar 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.

  1. Crea un proyecto de Google Cloud para el desarrollo. En el instructivo, se hace referencia a este proyecto como el proyecto de desarrollo.
  2. 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.

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

  4. 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 Cloud Run. Para comenzar, crea un proyecto en tu cuenta de Azure DevOps.

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

  7. 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 Container Registry

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

Configura una cuenta de servicio para publicar imágenes

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

  1. En la consola de Google Cloud, cambia al proyecto de producción.

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

    Activate Cloud Shell

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

  4. Habilita la API de Container Registry en el proyecto de producción:

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

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

  6. Otorga la función de IAM de administrador de almacenamiento (roles/storage.admin) a la cuenta de servicio para permitir que Azure Pipelines se envíe 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 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

  8. 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 Container Registry

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

  1. En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, selecciona Canalizaciones > Conexiones de servicio.
  2. Haz clic en Crear conexión de servicio.
  3. En la lista, selecciona Registro de Docker y, luego, haz clic en Siguiente.
  4. En el diálogo, ingresa valores para los siguientes campos:
    • Tipo de registro: Otros
    • Registro de Docker: https://gcr.io/PROD_PROJECT_ID, y reemplaza PROD_PROJECT_ID por el nombre de tu proyecto de producción (por ejemplo, https://gcr.io/azure-pipelines-test-project-12345).
    • ID de Docker: _json_key
    • Contraseña: Pega el contenido de azure-pipelines-publisher-oneline.json
    • Nombre de conexión del servicio: gcr-tutorial
  5. 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 Container Registry.

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

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

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

  3. Copia el siguiente código en el archivo:

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

    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.

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

  5. En el menú de Azure DevOps, selecciona Canalizaciones y, luego, haz clic en Crear canalización.

  6. Selecciona Azure Repos Git.

  7. Selecciona tu repositorio.

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

  9. Para verificar que la imagen se publicó en Container Registry, cambia al proyecto de producción en la consola de Google Cloud y selecciona Container Registry > Imágenes 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 Container 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 Container Registry roles/storage.admin (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 Container Registry roles/storage.objectViewer (solo el proyecto de producción)
Ejecutor de CloudDemo (cuenta de servicio del entorno de ejecución) Servicio de CloudDemo Accede a 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

  1. Abre Cloud Shell

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

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

  4. Otorga a las dos cuentas de agente de servicio de Cloud Run acceso a Container 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/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 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.

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

  2. Asigna las funciones de IAM necesarias para implementar nuevos servicios o revisiones 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

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

  4. 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:

  1. En el menú de Azure DevOps, selecciona Canalizaciones > Versiones.
  2. Haz clic en Nueva canalización.
  3. En la lista de plantillas, selecciona Trabajo vacío.
  4. Cuando se te solicite un nombre para la etapa, ingresa Development.
  5. En la parte superior de la pantalla, nombra la canalización CloudDemo.
  6. En el diagrama de la canalización, junto a Artifacts (Artefactos), haz clic en Add (Agregar).
  7. Selecciona Compilación y, luego, 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
  8. Haga clic en Agregar.
  9. En el cuadro Artefacto, haz clic en el ícono del rayo Desencadenador de implementación continua para agregar un desencadenador de implementación.
  10. En Desencadenador de implementación continua, establece la opción como Habilitado.
  11. Haz clic en Guardar.

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

    La canalización se muestra de la siguiente manera.

    Vista de la canalización de la configuración de implementación automatizada

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.

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

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

    1. Nombre visible: Deploy image to development project

    2. 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=gcr.io/$(ContainerRegistry.ProjectId)/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.

  7. 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 Cloud Run.
    CloudRun.ProjectId.Development ID del proyecto de desarrollo.
    CloudRun.ProjectId.Production ID del proyecto de producción.

  8. Haz clic en Guardar.

  9. 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:

  1. En el menú, pasa a la pestaña Canalización.
  2. En la casilla Etapas, selecciona Agregar > Nueva etapa.
  3. En la lista de plantillas, selecciona Trabajo vacío.
  4. Cuando se te solicite un nombre para la etapa, ingresa Production.
  5. Haz clic en el ícono del rayo de la etapa recién creada.

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

    Vista de la canalización de la configuración de implementación del clúster

  7. Pasa a la pestaña Tareas.

  8. Mantén el mouse sobre la pestaña Tareas y selecciona Tareas > Producción

  9. Haz clic en Trabajo de agente.

  10. Configura Agent specification como ubuntu-18.04.

  11. Haz clic en Add a task to agent job para agregar un paso a la fase.

  12. Selecciona la tarea Línea de comandos y, luego, haz clic en Agregar.

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

    1. Nombre visible: Deploy image to production project

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

  14. Haz clic en Guardar.

  15. 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:

  1. En tu computadora local, abre el archivo applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\Index.cshtml desde el repositorio de Git que clonaste antes.
  2. En la línea 26, cambia el valor de ViewBag.Title de Home Page a Home Page Cloud Run.

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

  4. En el menú de Azure DevOps, selecciona Canalizaciones. Se activará una compilación.

  5. Cuando se complete la compilación, selecciona Canalizaciones > Versiones. Se iniciará un proceso de actualización.

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

  7. En la consola de Google Cloud, cambia al proyecto de desarrollo.

  8. En el menú, selecciona Procesamiento > Cloud Run.

    El servicio clouddemo se implementa correctamente.

    Estado de implementación en Cloud Run

  9. Haz clic en clouddemo para ver más detalles.

    Se muestra una URL que indica que Cloud Run aprovisionó el servicio.

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

  11. En Azure Pipelines, haz clic en Aprobar (junto a la etapa Producción) para promover la implementación en el entorno de producción.

  12. Ingresa un comentario (opcional).

  13. Para confirmar, haz clic en Aprobar y espera a que el estado del entorno de Producción cambie a Correcto.

  14. En la consola de Google Cloud, cambia al proyecto de producción.

  15. En el menú, selecciona Procesamiento > Cloud Run.

    El servicio de clouddemo se implementa en el proyecto de producción.

  16. Haz clic en clouddemo para ver más detalles.

    Se muestra una URL que indica que Cloud Run aprovisionó el servicio.

  17. 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 desarrollo y producción de 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.

¿Qué sigue?