Crea una canalización de IC/EC con Azure Pipelines y Google Kubernetes Engine

En este instructivo, aprenderás a usar Azure Pipelines (antes llamado Visual Studio Team Services), Google Kubernetes Engine (GKE) y Container Registry para crear una canalización de integración continua/implementación continua (IC/EC). En el instructivo, se usa la aplicación web ASP.NET MusicStore, que está basada en ASP.NET Core.

La canalización de IC/EC usa dos clústeres de GKE separados, uno para las pruebas y otro para la producción. Al comienzo de la canalización, los desarrolladores confirman cambios en la base de código de ejemplo. Esta acción activa la canalización para crear una nueva versión y, luego, implementarla en el clúster de desarrollo. Un administrador de versiones puede promover la versión para que se implemente en el clúster de producción. En el siguiente diagrama, se ilustra este proceso.

Diagrama conceptual de la canalización de CI/CD en el que se muestra cómo los desarrolladores y los usuarios finales interactúan con la aplicación

En el instructivo, se da por sentado que tienes conocimientos básicos de .NET Core, Azure Pipelines y GKE. Para este instructivo también es necesario tener acceso de administrador a una cuenta de Azure DevOps.

Objetivos

  • Conectar Container Registry con Azure Pipelines para publicar imágenes de Docker
  • Preparar una aplicación de muestra de .NET Core para implementarla en GKE
  • Autenticar de forma segura en GKE sin tener que usar la autenticación heredada
  • Usar la administración de versiones de Azure Pipelines para organizar las implementaciones de GKE

Costos

En este instructivo, se usan componentes facturables de Google Cloud, que incluyen lo siguiente:

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Consulta la página de precios de Azure DevOps para conocer las tarifas que podrían aplicarse por su uso.

Antes de comenzar

Por lo general, se recomienda usar proyectos diferentes para las cargas de trabajo de desarrollo y producción a fin de que las funciones y los permisos de administración de identidades y accesos (IAM) se puedan conceder de forma individual. Por cuestiones prácticas, en este instructivo se usa un solo proyecto para ambos clústeres de GKE, el de desarrollo y el de producción.

  1. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  2. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  3. Asegúrate de tener una cuenta de Azure DevOps y de contar con acceso de administrador. Si todavía no tienes una cuenta de Azure DevOps, puedes registrarte en la página principal de Azure DevOps.

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 nuevo en la cuenta de Azure DevOps.

  1. Ve a la página principal de Azure DevOps (https://dev.azure.com/[YOUR_AZURE_DEVOPS_ORGANIZATION]).
  2. Haz clic en Crear proyecto.
  3. Ingresa un nombre de proyecto, como Music Store.
  4. Configura la Visibilidad como Privada y, luego, haz clic en Crear proyecto.
  5. Una vez que el proyecto se haya creado, en el menú de la izquierda, haz clic en Repositorios.
  6. Haz clic en Importar para bifurcar el repositorio de Music Store desde GitHub. Configura los siguientes valores:

    • Source type (Tipo de fuente): Git
    • Clone URL (URL de clonación):
          https://github.com/aspnet/MusicStore.git
          
    • La casilla de verificación Requires authorization (Requiere autorización) no debe quedar seleccionada.

    Captura de pantalla del cuadro de diálogo “Import a Git repository” (Importar un repositorio de Git)

  7. Haz clic en Import (Importar).

    Una vez completado el proceso de importación, verás el código fuente de la aplicación MusicStore.

Compila de forma continua

Ahora puedes usar Azure Pipelines para configurar la integración continua. Para 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.

Crea una rama de prueba

Este instructivo se compiló y probó con la versión 2.0.0 de la aplicación Music Store. Para asegurarte de usar la misma versión, crea una rama nueva basada en la etiqueta rel/2.0.0, como se indica a continuación:

  1. En el menú de Azure DevOps, selecciona Repositorios > Etiquetas.
  2. En la lista de etiquetas, expande rel y, luego, haz clic con el botón derecho en el ícono que está junto a 2.0.0.
  3. Selecciona Rama nueva.
  4. Ingresa testing como el nombre de la rama y, luego, haz clic en Create branch (Crear rama) para confirmar las selecciones.

    Captura de pantalla del cuadro de diálogo “Create a branch” (Crear una rama) de Azure Pipelines

De forma predeterminada, Azure Pipelines espera que el código resida en la rama master. Para que use la rama testing, debes cambiar la rama predeterminada.

  1. En el menú de Azure DevOps, selecciona Configuración del proyecto.
  2. Selecciona Repos > Repositorios.
  3. En la lista de repositorios, selecciona el repositorio de Git que importaste. Debería tener el mismo nombre que tu proyecto de Azure DevOps.
  4. Expande la lista de ramas; para ello, haz clic en la flecha que se encuentra junto a Ramas.
  5. Selecciona la rama de prueba.

    Aparecerá un botón junto al nombre de la rama.

  6. Haz clic en y selecciona Establecer como rama predeterminada.

Compilar el código

Una vez que creaste la rama, puedes comenzar a automatizar la compilación. Debido a que MusicStore es una aplicación de ASP.NET Core, la compilación incluye cuatro pasos:

  • Descargar y, luego, instalar dependencias
  • Compilar el código
  • Ejecutar pruebas de unidades
  • Publicar los resultados de la compilación

Más adelante, agregarás pasos adicionales para implementar en GKE. Debido a que GKE es un entorno basado en Linux, configurarás el proceso de compilación para que se ejecute en agentes de compilación basados en Linux.

Crea una canalización de compilación

Para definir una canalización de compilación nueva, agrega un archivo YAML al repositorio de Git de la siguiente manera:

  1. Clona el repositorio de Git nuevo mediante Visual Studio o un cliente de Git de la línea de comandos.
  2. En la raíz del lugar de trabajo de Git, crea un archivo nuevo llamado azure-pipelines.yml.
  3. Copia el siguiente código y pégalo en el archivo:

    resources:
        - repo: self
          fetchDepth: 1
        queue:
          name: Hosted Ubuntu 1604
        trigger:
        - testing
        variables:
          TargetFramework: 'netcoreapp2.0'
          RestoreBuildProjects: 'samples/**/*.csproj'
          TestProjects: 'test/MusicStore.Test/*.csproj'
          BuildConfiguration: 'Release'
          DockerImageName: '[PROJECT-ID]/musicstore'
        steps:
        - task: DotNetCoreCLI@2
          displayName: Restore
          inputs:
            command: restore
            projects: '$(RestoreBuildProjects)'
            feedsToUse: config
            nugetConfigPath: NuGet.config
        - task: DotNetCoreCLI@2
          displayName: Build
          inputs:
            projects: '$(RestoreBuildProjects)'
            arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
        - task: DotNetCoreCLI@2
          displayName: Test
          inputs:
            command: test
            projects: '$(TestProjects)'
            arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
        - task: DotNetCoreCLI@2
          displayName: Publish
          inputs:
            command: publish
            publishWebProjects: True
            arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
            zipAfterPublish: false
            modifyOutputPath: false
        
  4. En la sección variables, reemplaza [PROJECT_ID] por el nombre del proyecto de Google Cloud y, luego, guarda el archivo.

  5. 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 en la parte superior izquierda para ver la página principal.
    2. Haz clic en Cambios.
    3. Ingresa un mensaje de confirmación, como Add build 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 build definition"
          
    3. Envía los cambios a Azure DevOps:

          git push
          
  6. En el menú de Azure DevOps, selecciona Canalizaciones > Compilaciones.

    Observa que se creó una definición de compilación basada en el archivo YAML que confirmaste en el repositorio de Git.

Publica imágenes de Docker

Para implementar la aplicación MusicStore en GKE, esta debe estar empaquetada como un contenedor de Docker y publicada en Container Registry. Ahora extenderás la definición de compilación para automatizar estos pasos.

Configura una cuenta de servicio para publicar imágenes

La conexión a Container Registry requiere que Azure Pipelines pueda autenticarse con GCP. Para poder hacerlo, crea una cuenta de servicio en GCP exclusiva de este propósito.

  1. Cambia al proyecto en Cloud Console y abre Cloud Shell.

    Abrir Cloud Shell

  2. Para ahorrar tiempo cuando escribas el ID del proyecto y las opciones de la zona de Compute Engine, establece los valores de configuración predeterminados mediante la ejecución de los siguientes comandos:

    gcloud config set project [PROJECT_ID]
        gcloud config set compute/zone [ZONE]

    Reemplaza [PROJECT_ID] por el ID del proyecto de GCP y reemplaza [ZONE] por el nombre de la zona que usarás para crear recursos. Si no sabes qué zona elegir, usa us-central1-a.

    Ejemplo:

    gcloud config set project azure-pipelines-test-project-12345
        gcloud config set compute/zone us-central1-a
  3. Habilita la API de Container Registry para tu proyecto:

    gcloud services enable containerregistry.googleapis.com
  4. Crea una cuenta de servicio para que Azure Pipelines publique las imágenes de Docker:

    gcloud iam service-accounts create azure-pipelines-publisher --display-name "Azure Pipelines Publisher"
  5. Asigna la función de IAM de administrador de almacenamiento a la cuenta de servicio:

        PROJECT_NUMBER=$(gcloud projects describe \
            $(gcloud config get-value core/project) \
            --format='value(projectNumber)')
    
        AZURE_PIPELINES_PUBLISHER=$(gcloud iam service-accounts list \
            --filter="displayName:Azure Pipelines Publisher" \
            --format='value(email)')
    
        gcloud projects add-iam-policy-binding \
            $(gcloud config get-value core/project) \
            --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
            --role roles/storage.admin
        
  6. Genera una clave de cuenta de servicio:

    gcloud iam service-accounts keys create \
            azure-pipelines-publisher.json --iam-account $AZURE_PIPELINES_PUBLISHER
    
        tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json
  7. Haz clic en el botón Launch code editor (Iniciar editor de código), que se encuentra en la esquina superior derecha de Cloud Shell:

    Captura de pantalla del ícono “Launch code editor” (Iniciar editor de código) en la barra de menú de Cloud Shell

  8. Abre el archivo llamado azure-pipelines-publisher-oneline.json. Necesitarás el contenido de este archivo en uno de los pasos siguientes.

Conecta Azure Pipelines a Container Registry

Una vez creada la cuenta de servicio, puedes conectar Azure Pipelines a Container Registry.

  1. En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, Canalizaciones > Conexiones de servicio.
  2. Haz clic en Crear conexión de servicio.
  3. En la lista, selecciona Registro de Docker y 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/[PROJECT-ID], en el que [PROJECT-ID] es el nombre del proyecto de Google Cloud.

      Ejemplo: https://gcr.io/azure-pipelines-test-project-12345

    • ID de Docker: _json_key

    • Contraseña de Docker: Pega el contenido de azure-pipelines-publisher-oneline.json

    • Nombre de la conexión de servicio: gcr-tutorial

  5. Haz clic en Guardar para crear la conexión.

Crea un Dockerfile

  1. En la raíz del lugar de trabajo de Git, crea un archivo nuevo con el nombre Dockerfile.
  2. Copia el siguiente código, pégalo en el archivo y, luego, guarda el archivo:

    FROM microsoft/aspnetcore:2.0.0
        WORKDIR /app
        COPY samples/MusicStore/bin/Release/netcoreapp2.0/publish /app/
        ENTRYPOINT ["dotnet", "MusicStore.dll"]
  3. Crea otro archivo con el nombre deployment.yaml en la raíz del lugar de trabajo de Git. Por ahora, deja el archivo vacío.

  4. Confirma los cambios:

    Visual Studio

    1. Abre Team Explorer y haz clic en el ícono de página principal en la parte superior izquierda para ver la página principal.
    2. Haz clic en Cambios.
    3. Ingresa un mensaje de confirmación, como Add Dockerfile and placeholder for the Kubernetes manifest.
    4. Haz clic en Confirmar todo.

    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 Dockerfile and placeholder for the Kubernetes manifest"
          

Expande la definición de compilación para compilar una imagen de Docker

Con todos los archivos necesarios ingresados, ahora puedes extender la definición de compilación.

  1. Abre el archivo azure-pipelines.yml.
  2. Agrega el siguiente fragmento de código al archivo para extender la definición de compilación.

    - task: CmdLine@1
          displayName: 'Lock image version in deployment.yaml'
          inputs:
            filename: /bin/bash
            arguments: '-c "awk ''{gsub(\"MUSICSTORE_IMAGE\", \"gcr.io/$(DockerImageName):$(Build.BuildId)\", $0); print}'' deployment.yaml > $(build.artifactstagingdirectory)/deployment.yaml"'
        - task: PublishBuildArtifacts@1
          displayName: 'Publish Artifact'
          inputs:
            PathtoPublish: '$(build.artifactstagingdirectory)'
        - task: Docker@0
          displayName: 'Build image'
          inputs:
            containerregistrytype: 'Container Registry'
            dockerRegistryConnection: 'gcr-tutorial'
            imageName: '$(DockerImageName):$(Build.BuildId)'
        - task: Docker@0
          displayName: 'Publish image'
          inputs:
            containerregistrytype: 'Container Registry'
            dockerRegistryConnection: 'gcr-tutorial'
            action: 'Push an image'
            imageName: '$(DockerImageName):$(Build.BuildId)'
        
  3. 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 en la parte superior izquierda para ver la página principal.
    2. Haz clic en Cambios.
    3. Ingresa un mensaje de confirmación, como Extend build definition to build Docker image.
    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 "Extend build definition to build Docker image"
          
    3. Envía los cambios a Azure DevOps:

          git push
          
  4. En el menú de Azure DevOps, selecciona Canalizaciones > Compilaciones.

    Nota que se activó de forma automática una compilación nueva. La compilación puede llevar alrededor de 2 minutos.

    Si la compilación falla con el mensaje de error Step input dockerRegistryConnection references service connection gcr-tutorial which could not be found, es posible que debas volver a guardar la canalización.

  5. Para verificar que la imagen se haya publicado en Container Registry, ve a Cloud Console, selecciona Container Registry > Imágenes y, luego, haz clic en musicstore.

    Nota que hay una sola imagen y que la etiqueta de esta se corresponde con el ID numérico de la compilación que se ejecutó en Azure Pipelines.

    Captura de pantalla de la lista de imágenes en Container Registry

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 brinda un conjunto de herramientas especializadas 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 aplicación y que suelen ser el resultado de un proceso de compilación.
  • El término implementación hace referencia al proceso de tomar una versión para implementarla en un entorno específico.
  • Una implementación realiza un conjunto de tareas, que se pueden agrupar en trabajos.
  • Las etapas permiten que segmentes la canalización, y se las puede usar para organizar implementaciones en varios entornos, por ejemplo, entornos de desarrollo y pruebas.

El artefacto principal que produce el proceso de compilación de MusicStore es la imagen de Docker. Sin embargo, debido a que la imagen de Docker se publica en Container Registry, está fuera del alcance de Azure Pipelines. Por ende, la imagen no funciona bien como definición de una versión.

Para implementar en Kubernetes, también necesitas un manifiesto, que se parece a una factura de materiales. El manifiesto define los recursos que Kubernetes debe crear y administrar y, además, especifica la versión exacta de la imagen de Docker que se usará. El manifiesto de Kubernetes es adecuado para funcionar como el artefacto que define la versión en la Administración de versiones de Azure Pipelines.

Configura la implementación de Kubernetes

Para ejecutar MusicStore en Kubernetes, necesitarás los siguientes recursos:

  • Una implementación que defina un solo pod que ejecute la imagen de Docker producida por la compilación
  • Un servicio NodePort que hace que el pod sea accesible para el balanceador de cargas
  • Un Ingress que exponga la aplicación a la Internet pública mediante un balanceador de cargas de HTTP(S) de Cloud

Con la aplicación MusicStore, puedes usar SQL Server o una base de datos incorporada y almacenada de forma local. Para simplificar el proceso, usa la configuración predeterminada que depende de la base de datos incorporada, aunque tiene las siguientes dos restricciones:

  • Solo se puede ejecutar una copia del pod a la vez. De lo contrario, los usuarios podrían ver datos diferentes según el pod que les entregue contenido.
  • Los cambios en los datos se pierden cuando se reinicia el pod, a menos que modifiques la implementación para que use volúmenes persistentes (no trataremos este caso en el instructivo).

Para definir estos recursos de Kubernetes, realiza los siguientes pasos:

  1. Abre deployment.yaml, pega el siguiente código y, luego, guarda el archivo:

    apiVersion: v1
        kind: Service
        metadata:
          name: musicstore
        spec:
          ports:
          - port: 80
            targetPort: 80
            protocol: TCP
            name: http
          selector:
            app: musicstore
          type: NodePort
    
        ---
        apiVersion: extensions/v1beta1
        kind: Ingress
        metadata:
          name: musicstore
        spec:
          backend:
            serviceName: musicstore
            servicePort: 80
    
        ---
        apiVersion: extensions/v1beta1
        kind: Deployment
        metadata:
          name: musicstore
        spec:
          replicas: 1
          template:
            metadata:
              labels:
                app: musicstore
            spec:
              containers:
              - name: musicstore
                image: MUSICSTORE_IMAGE
                ports:
                  - containerPort: 80
                livenessProbe:      # Used by deployment controller
                  httpGet:
                    path: /
                    port: 80
                  initialDelaySeconds: 5
                  periodSeconds: 5
                readinessProbe:     # Used by Ingress/GCLB
                  httpGet:
                    path: /
                    port: 80
                  initialDelaySeconds: 3
                  periodSeconds: 5
                resources:
                  limits:
                    memory: 1024Mi
                  requests:
                    memory: 768Mi
        
  2. 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 en la parte superior izquierda para ver la página principal.
    2. Haz clic en Cambios.
    3. Ingresa un mensaje de confirmación, como Add Kubernetes manifest.
    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 Kubernetes manifest"
          
    3. Envía los cambios a Azure DevOps:

          git push
          

Configura los entornos de desarrollo y producción

Antes de volver a la Administración de versiones de Azure Pipelines, debes crear los clústeres de GKE.

Crea clústeres de GKE

  1. En GCP, abre una instancia de Cloud Shell.
  2. Para ahorrar tiempo cuando escribas el ID del proyecto y las opciones de la zona de Compute Engine, establece los valores de configuración predeterminados mediante la ejecución de los siguientes comandos:

    gcloud config set project [PROJECT_ID]
        gcloud config set compute/zone [ZONE]

    Ejemplo:

    gcloud config set project azure-pipelines-test-project-12345
        gcloud config set compute/zone us-central1-a
  3. Habilita la API de GKE para tu proyecto:

    gcloud services enable container.googleapis.com
  4. Crea el clúster de desarrollo mediante el siguiente comando. Ten en cuenta que puede tomar unos minutos en completarse:

    gcloud container clusters create azure-pipelines-cicd-dev
  5. Crea el clúster de producción mediante el siguiente comando. Ten en cuenta que puede tomar unos minutos en completarse:

    gcloud container clusters create azure-pipelines-cicd-prod

Conecta Azure Pipelines al clúster de desarrollo

Así como puedes usar Azure Pipelines para conectarte a un registro externo de Docker, como Container Registry, Azure Pipelines admite la integración de clústeres de Kubernetes externos.

Es posible autenticarse en Container Registry mediante una cuenta de servicio de Google Cloud, pero Azure Pipelines no admite el uso de cuentas de servicio de Google Cloud para la autenticación con GKE. En su lugar, debes usar una cuenta de servicio de Kubernetes.

Por lo tanto, para conectar Azure Pipelines al clúster de desarrollo, primero debes crear una cuenta de servicio de Kubernetes.

  1. En Cloud Shell, conéctate al clúster de desarrollo:

    gcloud container clusters get-credentials azure-pipelines-cicd-dev
  2. Crea una cuenta de servicio de Kubernetes para Azure Pipelines:

    kubectl create serviceaccount azure-pipelines-deploy
  3. Asigna la función cluster-admin a la cuenta de servicio mediante la creación de una vinculación de función de clúster:

    kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy
  4. Define la dirección IP del clúster:

        gcloud container clusters describe azure-pipelines-cicd-dev --format=value\(endpoint\)
        

    Necesitarás esta dirección en un momento.

  5. En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, Canalizaciones > Conexiones de servicio.

  6. Haz clic en Nueva conexión de servicio.

  7. Selecciona Kubernetes y haz clic en Siguiente.

  8. Establece la siguiente configuración:

    • Método de autenticación: Cuenta de servicio
    • URL del servidor: https://[MASTER-IP]/. Reemplaza [MASTER-IP] por la dirección IP que definiste antes
    • Secreto: Ejecuta el siguiente comando en Cloud Shell y copia el resultado:
      kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml
    • Nombre de la conexión de servicio: azure-pipelines-cicd-dev
  9. Haz clic en Guardar.

Conecta Azure Pipelines al clúster de producción

Para conectar Azure Pipelines a tu clúster de producción, puedes seguir el mismo enfoque.

  1. En Cloud Shell, conéctate al clúster de producción:

    gcloud container clusters get-credentials azure-pipelines-cicd-prod
  2. Crea una cuenta de servicio de Kubernetes para Azure Pipelines:

    kubectl create serviceaccount azure-pipelines-deploy
  3. Asigna la función cluster-admin a la cuenta de servicio mediante la creación de una vinculación de función de clúster:

    kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy
  4. Define la dirección IP del clúster:

        gcloud container clusters describe azure-pipelines-cicd-prod --format=value\(endpoint\)
        

    Necesitarás esta dirección en un momento.

  5. En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, Canalizaciones > Conexiones de servicio.

  6. Haz clic en Nueva conexión de servicio.

  7. Selecciona Kubernetes y haz clic en Siguiente.

  8. Establece la siguiente configuración:

    • Método de autenticación: Cuenta de servicio
    • URL del servidor: https://[MASTER-IP]/. Reemplaza [MASTER-IP] por la dirección IP que definiste antes
    • Secreto: Ejecuta el siguiente comando en Cloud Shell y copia el resultado:
      kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml
    • Nombre de la conexión de servicio: azure-pipelines-cicd-prod
  9. Haz clic en Guardar.

Configura la canalización de la versión

Después de configurar la infraestructura de GKE, vuelve a Azure Pipelines a fin de automatizar la implementación, lo que incluye las siguientes acciones:

  • 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

Cómo crear una definición de la versión

Como primer paso, crea una nueva 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 Dev.
  5. En la parte superior de la pantalla, nombra la versión MusicStore-KubernetesEngine.
  6. En el diagrama de la canalización, junto a Artefactos, haz clic en Agregar.
  7. Selecciona Compilar y agrega la siguiente configuración:

    • Fuente (canalización de compilación): selecciona la definición de compilación (solo debe haber una opción)
    • Versión predeterminada: Latest
    • Alias de origen: manifest
  8. Haz clic en Agregar.

  9. En el cuadro Artifacts (Artefacto), haz clic en el ícono de rayo para agregar un activador de implementación.

  10. En Activador 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 Guardar para confirmarlo.

La canalización ahora se ve de la siguiente manera:

Captura de pantalla de la canalización actualizada en Azure Pipelines

Implementa en el clúster de desarrollo

Una vez que creaste la definición de la versión, puedes configurar la implementación en el clúster de desarrollo de GKE.

  1. En el menú de la canalización, pasa a la pestaña Tareas.
  2. Haz clic en Trabajo de agente.
  3. Configura la Especificación del agente como ubuntu-16.04.
  4. Junto a Trabajo de agente, haz clic en el ícono + para agregar un paso a la fase.
  5. Selecciona la tarea Implementar en Kubernetes y haz clic en Agregar.
  6. Haz clic en la tarea recién agregada y establece la siguiente configuración:

    • Nombre visible: Deploy
    • Acción: implementar
    • Conexión de servicio de Kubernetes: azure-pipelines-cicd-dev
    • Espacio de nombres: default
    • Estrategia: ninguna
    • Manifiestos: manifest/drop/deployment.yaml
  7. Haz clic en Guardar.

  8. 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 clúster de producción de GKE.

  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 Prod.
  5. Haz clic en el ícono del rayo de la etapa recién creada.
  6. Establece la siguiente configuración:

    • Seleccionar activador: After stage
    • Etapas: Dev
    • Aprobaciones previas a la implementación: (habilitadas)
    • Responsables de aprobación: Selecciona tu propio nombre de usuario.

    La canalización ahora se ve de la siguiente manera:

    Captura de pantalla de la canalización actualizada en Azure Pipelines

  7. Pasa a la pestaña Tasks (Tareas).

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

  9. Haz clic en Trabajo de agente.

  10. Configura la Especificación del agente como ubuntu-16.04.

  11. Haz clic en el ícono + para agregar un paso a la fase.

  12. Selecciona la tarea Implementar en Kubernetes y haz clic en Agregar.

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

    • Nombre visible: Deploy
    • Acción: implementar
    • Conexión de servicio de Kubernetes: azure-pipelines-cicd-prod
    • Espacio de nombres: default
    • Estrategia: ninguna
    • Manifiestos: manifest/drop/deployment.yaml
  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 ya configuraste toda la canalización, debes probarla mediante un cambio en el código fuente.

  1. En el lugar de trabajo de Git, abre el archivo samples\MusicStore\config.json.
  2. En la línea 3, cambia el parámetro SiteTitle a ASP.NET MVC Music Store running on Google Kubernetes Engine.
  3. 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 en la parte superior izquierda para ver la 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 DevOps:

          git push
          
  4. En el menú de Azure DevOps, selecciona Canalizaciones > Compilaciones y observa que una compilación se activó de forma automática:

    Captura de pantalla en la que se muestra la lista de compilaciones en curso, con la compilación de Music Store en progreso

    Pueden pasar alrededor de 2 minutos hasta que el estado cambia a Finalizada.

  5. Cuando se termine la compilación, selecciona Pipelines (Canalizaciones) > Releases (Versiones) y verás que se inicia un proceso de actualización:

    Captura de pantalla en la que se muestra que comenzó el 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 Dev (Desarrollo) cambie a Succeeded (Finalizada). Puede que tengas que hacer clic en el botón Refresh (Actualizar) en el menú o volver a cargar la página del navegador para actualizar el estado.

  7. En Cloud Console, selecciona Kubernetes Engine > Ingress y servicios.

  8. Ubica el servicio de Ingress del clúster azure-pipelines-cicd-dev y espera a que su estado cambie a Correcto. Esto podría llevar varios minutos.

  9. Abre el vínculo en la columna Extremos de la misma fila. Es posible que al principio te encuentres con un error debido a que el balanceador de cargas tarda unos minutos para estar disponible. Cuando esté listo, verás que Music Store se implementó y usa el título personalizado:

    Captura de pantalla en la que se muestra la app Music Store en ejecución en una página del navegador

  10. En Azure Pipelines, haz clic en el botón Approve (Aprobar) ubicado en la etapa de Prod (Producción) para promover la implementación en el entorno de producción:

    Captura de pantalla en la que se muestra la página de actualización y el mensaje “Hay una aprobación previa a la implementación pendiente… Aprobar o rechazar”

    Si no ves el botón, es posible que primero debas aprobar o rechazar una versión anterior.

  11. Si lo deseas, ingresa un comentario y, luego, haz clic en Approve (Aprobar) para confirmarlo.

  12. Espera a que el estado del entorno de Prod (Producción) cambie a Finalizado. Es posible que tengas que actualizar la página de forma manual en el navegador.

  13. En Cloud Console, actualiza la página Servicios.

  14. Ubica el servicio de Ingress del clúster azure-pipelines-cicd-prod y espera a que su estado cambie a Correcto. Esto podría llevar varios minutos.

  15. Abre el vínculo en la columna Extremos de la misma fila. De nuevo, es posible que al principio te encuentres con un error, debido a que el balanceador de cargas tarda unos minutos en estar disponible. Cuando esté listo, verás la app MusicStore con el título personalizado, pero esta vez se estará ejecutando en el clúster de producción.

Realiza una limpieza

Para evitar que se generen costos adicionales una vez que completes este instructivo, borra las entidades que creaste.

Borra el proyecto de Azure Pipelines

Borra el proyecto en Azure Pipelines. Ten en cuenta que esto hará que todos los cambios realizados en el código fuente también se pierdan.

Borra el proyecto de GCP

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  3. En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.

Próximos pasos