Tutorial: uso de una estrategia de implementación de valor controlado para implementaciones de Kubernetes.

Azure DevOps Services | Azure DevOps Server 2022

En esta guía paso a paso se explica cómo utilizar la tarea de manifiesto de Kubernetes con la estrategia canary. Una estrategia de implementación de valor controlado implementa nuevas versiones de una aplicación junto a versiones estables de producción.

Use el flujo de trabajo asociado para implementar el código y comparar las implementaciones de aplicaciones de línea base y de valor controlado. En función de la evaluación, decida si va a promover o rechazar la implementación de valor controlado.

En este tutorial se usan Docker Registry y las conexiones de servicio de Azure Resource Manager para conectarse a los recursos de Azure. En el caso de un clúster privado de Azure Kubernetes Service (AKS) o un clúster que tiene cuentas locales deshabilitadas, una conexión de servicio de Azure Resource Manager es la mejor manera de conectarse.

Requisitos previos

• Un proyecto de Azure DevOps con al menos permisos de usuario.

• Una cuenta de Azure. Cree una cuenta gratuita.

• Una instancia de Azure Container Registry con privilegios de inserción.

• Un clúster de Azure Kubernetes Service )AKS) implementado. Puede adjuntar el clúster de AKS al clúster de Azure Container Registry al implementar el clúster de AKS o después.

• Una cuenta de GitHub. Creación de una cuenta gratuita de GitHub

• Una bifurcación del repositorio de GitHub https://github.com/MicrosoftDocs/azure-pipelines-canary-k8s.

  Importante

  Durante los procedimientos siguientes GitHub, es posible que se le pida que cree una conexión de servicio de GitHub o que se redirija a GitHub para iniciar sesión, instalar Azure Pipelines o autorizar Azure Pipelines. Siga las instrucciones que aparecen en pantalla para completar el proceso. Para más información, consulte Acceso a repositorios de GitHub.

Archivos del repositorio de GitHub

El repositorio de GitHub contiene los siguientes archivos:

Archivo	Descripción
./app/app.py	Un servidor web simple basado en Flask. El archivo configura un contador personalizado para el número de respuestas buenas y malas, en función del valor de la variable success_rate.
./app/Dockerfile	Se utiliza para construir la imagen con cada cambio en app.py. Cada cambio desencadena la canalización de compilación para compilar la imagen e insertarla en el registro de contenedor.
./manifests/deployment.yml	Contiene la especificación de la carga de trabajo de implementación sampleapp correspondiente a la imagen publicada. Este archivo de manifiesto se utiliza para la versión estable del objeto de implementación y para obtener las variantes de línea base y valor controlado de las cargas de trabajo.
./manifests/service.yml	Crea el servicio sampleapp. Este servicio enruta las solicitudes a los pods activados por las implementaciones estables, de línea base y de valor controlado.
./misc/fortio.yml	Configura una implementación de fortio. Esta implementación es una herramienta de prueba de carga que envía un flujo de solicitudes al servicio sampleapp implementado. El flujo de solicitud se enruta a los pods de las tres implementaciones: estable, de línea base y de valor controlado.

Creación de conexiones de servicio

1. En el proyecto en Azure DevOps, vaya a Configuración del proyecto>Canalizaciones>Conexiones de servicio.
2. Cree una conexión del servicio Docker Registry denominada azure-pipelines-canary-acr que esté asociada a la instancia de Azure Container Registry.
3. Cree una Conexión de servicio de Azure Resource Manager con la identidad de carga de trabajo denominada azure-pipelines-canary-k8s para el grupo de recursos.

Adición de la fase de compilación

1. En el proyecto de Azure DevOps, vaya a Canalizaciones>Crear canalización o Nueva canalización.

2. Seleccione GitHub para la ubicación del código y seleccione el repositorio azure-pipelines-canary-k8s bifurcado.

3. En la pestaña Configurar, elija Canalización inicial.

4. En la pestaña Revisar, reemplace el YAML de la canalización con el código siguiente.

   trigger:
   - main
   
   pool:
     vmImage: ubuntu-latest
   
   variables:
     imageName: azure-pipelines-canary-k8s # name of ACR image
     dockerRegistryServiceConnection: azure-pipelines-canary-acr # name of ACR service connection
     imageRepository: 'azure-pipelines-canary-k8s' # name of image repository
     containerRegistry: example.azurecr.io # name of Azure container registry
     tag: '$(Build.BuildId)'
   
   stages:
   - stage: Build
     displayName: Build stage
     jobs:  
     - job: Build
       displayName: Build
       pool:
         vmImage: ubuntu-latest
       steps:
       - task: Docker@2
         displayName: Build and push image
         inputs:
           containerRegistry: $(dockerRegistryServiceConnection)
           repository: $(imageName)
           command: buildAndPush
           Dockerfile: app/Dockerfile
           tags: |
             $(tag)
   

   Si la conexión del servicio de registro de Docker que ha creado está asociada a un registro de contenedor con nombre example.azurecr.io, la imagen se establece en example.azurecr.io/azure-pipelines-canary-k8s:$(Build.BuildId).

5. Seleccione Guardar y ejecutar y asegúrese de que el trabajo se ejecuta correctamente.

Edición del archivo de manifiesto

En la bifurcación del repositorio, edite manifests/deployment.yml para reemplazar <foobar> por la dirección URL del registro de contenedor, por ejemplo example.azurecr.io/azure-pipelines-canary-k8s.

Configurar la implementación continua

Ahora, configure la implementación continua, implemente la fase de valor controlado y promueva o rechace el valor controlado a través de la aprobación manual.

Creación de un entorno

Puede realizar la implementación con YAML o clásico.

YAML

1. En el proyecto de Azure DevOps, vaya a Canalizaciones>Entornos y seleccione Crear entorno o Nuevo entorno.
2. En la primera pantalla de Nuevo entorno, escriba akscanary en Nombre, seleccione Kubernetes en Recurso y seleccione Siguiente.
3. Rellene la pantalla Recursos de Kubernetes de la siguiente manera:
   • Proveedor: seleccione Azure Kubernetes Service.
   • Suscripción de Azure: seleccione su suscripción de Azure.
   • Clúster: Seleccione el clúster de AKS.
   • Espacio de nombres: seleccione Nuevo y escriba canarydemo.
4. Seleccione Validar y crear.

Adición de la fase de valor controlado

1. Vaya a Canalizaciones, seleccione la canalización que ha creado y seleccione Editar.

2. Reemplace todo el YAML de la canalización con el siguiente código.

   Este código cambia el paso Docker@2 que ejecutó anteriormente para usar una fase y agrega dos pasos más para copiar los manifiestos y directorios misc como artefactos para las fases consecutivas que se van a usar.

   El código también mueve algunos valores a variables para facilitar el uso más adelante en la canalización. En la variable containerRegistry, sustituya <example> por el nombre de su registro de contenedor.

   trigger:
   - main
   
   pool:
     vmImage: ubuntu-latest
   
   variables:
     imageName: azure-pipelines-canary-k8s
     dockerRegistryServiceConnection: azure-pipelines-canary-acr
     imageRepository: 'azure-pipelines-canary-k8s'
     containerRegistry: <example>.azurecr.io
     tag: '$(Build.BuildId)'
   
   stages:
   - stage: Build
     displayName: Build stage
     jobs:  
     - job: Build
       displayName: Build
       pool:
         vmImage: ubuntu-latest
       steps:
       - task: Docker@2
         displayName: Build and push image
         inputs:
           containerRegistry: $(dockerRegistryServiceConnection)
           repository: $(imageName)
           command: buildAndPush
           Dockerfile: app/Dockerfile
           tags: |
             $(tag)
   
       - publish: manifests
         artifact: manifests
   
       - publish: misc
         artifact: misc
   

3. Agregue otra fase al final del archivo YAML para implementar la versión canary. Reemplace los valores my-resource-group y my-aks-cluster por el grupo de recursos y el nombre del clúster de Azure Kubernetes Service.

   trigger:
   - main
   
   pool:
     vmImage: ubuntu-latest
   
   variables:
     imageName: azure-pipelines-canary-k8s
     dockerRegistryServiceConnection: azure-pipelines-canary-acr
     imageRepository: 'azure-pipelines-canary-k8s'
     containerRegistry: yourcontainerregistry.azurecr.io #update with container registry
     tag: '$(Build.BuildId)'
   
   stages:
   - stage: Build
     displayName: Build stage
     jobs:  
     - job: Build
       displayName: Build
       pool:
         vmImage: ubuntu-latest
       steps:
       - task: Docker@2
         displayName: Build and push image
         inputs:
           containerRegistry: $(dockerRegistryServiceConnection)
           repository: $(imageName)
           command: buildAndPush
           Dockerfile: app/Dockerfile
           tags: |
             $(tag)
   
       - publish: manifests
         artifact: manifests
   
       - publish: misc
         artifact: misc
   
   - stage: DeployCanary
     displayName: Deploy canary
     dependsOn: Build
     condition: succeeded()
   
     jobs:
     - deployment: Deploycanary
       displayName: Deploy canary
       pool:
         vmImage: ubuntu-latest
       environment: 'akscanary'
       strategy:
         runOnce:
           deploy:
             steps:
             - task: KubernetesManifest@1
               displayName: Create Docker Registry Secret
               inputs:
                 action: 'createSecret'
                 connectionType: 'azureResourceManager'
                 azureSubscriptionConnection: 'azure-pipelines-canary-sc'
                 azureResourceGroup: 'my-resource-group'
                 kubernetesCluster: 'my-aks-cluster'
                 secretType: 'dockerRegistry'
                 secretName: 'my-acr-secret'
                 dockerRegistryEndpoint: 'azure-pipelines-canary-acr'
   
             - task: KubernetesManifest@1
               displayName: Deploy to Kubernetes cluster
               inputs:
                 action: 'deploy'
                 connectionType: 'azureResourceManager'
                 azureSubscriptionConnection: 'azure-pipelines-canary-sc'
                 azureResourceGroup: 'my-resource-group'
                 kubernetesCluster: 'my-aks-cluster'
                 strategy: 'canary'
                 percentage: '25'
                 manifests: |
                   $(Pipeline.Workspace)/manifests/deployment.yml
                   $(Pipeline.Workspace)/manifests/service.yml
                 containers: '$(containerRegistry)/$(imageRepository):$(tag)'
                 imagePullSecrets: 'my-acr-secret'
   
             - task: KubernetesManifest@1
               displayName: Deploy Forbio to Kubernetes cluster
               inputs:
                 action: 'deploy'
                 connectionType: 'azureResourceManager'
                 azureSubscriptionConnection: 'azure-pipelines-canary-sc'
                 azureResourceGroup: 'my-resource-group'
                 kubernetesCluster: 'my-aks-cluster'
                 manifests: '$(Pipeline.Workspace)/misc/*'
   

4. Seleccione Validar y guardar y guarde la canalización directamente en la rama principal.

Clásico

1. Vaya a Canalizaciones>Versiones>Nueva>Canalización de versión nueva. Asígnele el nombre CanaryK8sDemo.
2. En el modelo posterior para seleccionar una plantilla para la fase 1, elija Trabajo vacío. Asigne a la fase el nombre de Implementar valor controlado.
3. Seleccione Agregar un artefacto y elija GitHub.
   • Elija una conexión de servicio de Git existente o cree una nueva a través de la cual se pueda acceder al repositorio bifurcado. A continuación, elija lo mismo en la lista desplegable Origen (repositorio).
   • Rama predeterminada: principal
   • Versión predeterminada: elija la versión más reciente de la rama predeterminada.
   • Alias de origen: azure-pipelines-canary-k8s
   • Para confirmar las entradas, elija Agregar.
4. Seleccione Agregar un artefacto y elija Azure Container Registry o Docker Hub, en función del registro de contenedor que haya elegido anteriormente, en la sección "Requisitos previos". Proporcione los valores adecuados para las listas desplegables de entrada para buscar el registro de contenedor. Proporcione imagen como alias para este artefacto y confirme las entradas eligiendo Agregar. Cuando se haya agregado el artefacto, seleccione el icono de relámpago en la tarjeta de artefacto para habilitar el desencadenador de implementación continua.
5. En la fase Implementar valor controlado que creó, seleccione el vínculo 1 trabajo, 0 tarea para ir a la ventana para agregar trabajos y fases.
6. Seleccione Trabajo del agente. En la ventana de configuración, en la lista desplegable Grupo de agentes, elija Hosted Ubuntu 22.04.
7. Seleccione el signo + en la fila de trabajo del agente para agregar una nueva tarea. Agregue la tarea Implementar manifiestos de Kubernetes con la siguiente configuración:
   • Nombre para mostrar: Crear secreto
   • Acción: Crear secreto
   • Conexión de servicio de Kubernetes: azure-pipelines-canary-k8s
   • Espacio de nombres: espacio de nombres dentro del clúster en el que desea implementar.
   • Tipo de secreto: dockerRegistry
   • Nombre del secreto: azure-pipelines-canary-k8s
   • Conexión del servicio del registro de Docker: azure-pipelines-canary-k8s
8. Agregue otra tarea Implementar manifiestos de Kubernetes con la siguiente configuración:
   • Nombre para mostrar: Implementar valores controlados
   • Acción: Implementar
   • Conexión de servicio de Kubernetes: azure-pipelines-canary-k8s
   • Espacio de nombres: espacio de nombres dentro del clúster en el que desea implementar.
   • Estrategia: valor controlado
   • Porcentaje: 25
   • Manifiestos: azure-pipelines-canary-k8s/manifests/*
   • Contenedores: <example>/azure-pipelines-canary-k8s:$(Release.Artifacts.image.BuildId), donde <example> se va a reemplazar por la dirección URL del registro de contenedor.
   • ImagePullSecrets: azure-pipelines-canary-k8s
9. Agregue otra tarea Implementar manifiestos de Kubernetes con la siguiente configuración:
   • Nombre para mostrar: Implementar Fortio y ServiceMonitor
   • Acción: Implementar
   • Conexión de servicio de Kubernetes: azure-pipelines-canary-k8s
   • Espacio de nombres: espacio de nombres dentro del clúster en el que desea implementar.
   • Estrategia: Ninguna
   • Manifiestos: azure-pipelines-canary-k8s/misc/*

Adición de aprobación manual para promover o rechazar la implementación de valor controlado

Puede intervenir manualmente con YAML o Clásico.

YAML

1. Cree un nuevo entorno de Kubernetes denominado akspromote.
2. Abra el nuevo entorno akspromote en la lista de entornos y seleccione Aprobaciones en la pestaña Aprobaciones y comprobaciones.
3. En la pantalla Aprobaciones, agregue su propia cuenta de usuario en Aprobadores.
4. Expanda Avanzado y asegúrese de que la opción Permitir que los aprobadores aprueben sus propias ejecuciones esté seleccionada.
5. Seleccione Crear.

Adición de fases de promoción y rechazo a la canalización

1. Vaya a Canalizaciones, seleccione la canalización que ha creado y seleccione Editar.

2. Agregue la siguiente fase PromoteRejectCanary al final del archivo YAML que promueve los cambios.

   - stage: PromoteRejectCanary
     displayName: Promote or Reject canary
     dependsOn: DeployCanary
     condition: succeeded()
   
     jobs:
     - deployment: PromoteCanary
       displayName: Promote Canary
       pool: 
         vmImage: ubuntu-latest
       environment: 'akspromote'
       strategy:
         runOnce:
           deploy:
             steps:      
             - task: KubernetesManifest@1
               displayName: Create Docker Registry Secret for akspromote
               inputs:
                 action: 'createSecret'
                 connectionType: 'azureResourceManager'
                 azureSubscriptionConnection: 'azure-pipelines-canary-sc'
                 azureResourceGroup: 'my-resource-group'
                 kubernetesCluster: 'my-aks-cluster'
                 secretType: 'dockerRegistry'
                 secretName: 'my-acr-secret'
                 dockerRegistryEndpoint: 'azure-pipelines-canary-acr'
   
             - task: KubernetesManifest@1
               displayName: promote canary
               inputs:
                 action: 'promote'
                 connectionType: 'azureResourceManager'
                 azureSubscriptionConnection: 'azure-pipelines-canary-sc'
                 azureResourceGroup: 'my-resource-group'
                 kubernetesCluster: 'my-aks-cluster'
                 strategy: 'canary'
                 manifests: '$(Pipeline.Workspace)/manifests/*'
                 containers: '$(containerRegistry)/$(imageRepository):$(tag)'
                 imagePullSecrets: 'my-acr-secret'
       ```
   
   

3. Agregue la siguiente fase RejectCanary al final del archivo que revierte los cambios.

   - stage: RejectCanary
     displayName: Reject canary
     dependsOn: PromoteRejectCanary
     condition: failed()
   
     jobs:
     - deployment: RejectCanary
       displayName: Reject Canary
       pool: 
         vmImage: ubuntu-latest
       environment: 'akscanary'
       strategy:
         runOnce:
           deploy:
             steps:        
             - task: KubernetesManifest@1
               displayName: Create Docker Registry Secret for reject canary
               inputs:
                 action: 'createSecret'
                 connectionType: 'azureResourceManager'
                 azureSubscriptionConnection: 'azure-pipelines-canary-sc'
                 azureResourceGroup: 'kubernetes-testing'
                 kubernetesCluster: 'my-aks-cluster'
                 secretType: 'dockerRegistry'
                 secretName: 'my-acr-secret'
                 dockerRegistryEndpoint: 'azure-pipelines-canary-acr'    
             - task: KubernetesManifest@1
               displayName: Reject canary deployment
               inputs:
                 action: 'reject'
                 connectionType: 'azureResourceManager'
                 azureSubscriptionConnection: 'azure-pipelines-canary-sc'
                 azureResourceGroup: 'my-resource-group'
                 kubernetesCluster: 'my-aks-cluster'
                 namespace: 'default'
                 strategy: 'canary'
                 manifests: '$(Pipeline.Workspace)/manifests/*'
       ```
   

4. Seleccione Validar y guardar y guarde la canalización directamente en la rama principal.

Clásico

1. Seleccione la pestaña Canalización para volver a la vista de canalización. Agregue una nueva fase denominada Promover o rechazar valores controlados, en función de la plantilla de trabajo vacía.
2. Agregue un trabajo sin agente a esta fase y vuelva a ordenar este trabajo para que sea el primer trabajo de esta fase. Asigne a este trabajo sin agente el nombre de Promover o rechazar la entrada.
3. Agregue una tarea de Intervención manual a este trabajo y cambie el nombre para mostrar de la tarea a Promover o rechazar valores controlados.
4. Configure el trabajo del agente vacío actualmente colocado después del trabajo sin agente Promover o rechazar entrada.
   • Nombre para mostrar: Promover valores controlados
   • Grupo de agentes: Ubuntu 22.04 hospedado
   • Ejecutar este trabajo: elija para ejecutar solo cuando todos los trabajos anteriores se hayan realizado correctamente.
5. Agregue la tarea Implementar manifiestos de Kubernetes con la siguiente configuración en el trabajo Promover valor controlado.
   • Nombre para mostrar: Promover valores controlados
   • Acción: Promover
   • Conexión de servicio de Kubernetes: azure-pipelines-canary-k8s
   • Espacio de nombres: espacio de nombres dentro del clúster en el que desea implementar.
   • Estrategia: valor controlado
   • Porcentaje: 25
   • Manifiestos: azure-pipelines-canary-k8s/manifests/*
   • Contenedores: <example>/azure-pipelines-canary-k8s:$(Release.Artifacts.image.BuildId), donde se reemplaza <example> por la dirección URL del registro de contenedor.
   • ImagePullSecrets: azure-pipelines-canary-k8s
6. Agregue otro trabajo de agente con la siguiente configuración, después del trabajo de agente Promover valor controlado.
   • Nombre para mostrar: Rechazar valores controlados
   • Grupo de agentes: Ubuntu 22.04 hospedado
   • Ejecutar este trabajo: elija para ejecutar solo cuando se haya producido un error en un trabajo anterior.
7. Agregue la tarea Implementar manifiestos de Kubernetes con la siguiente configuración en el trabajo Rechazar valor controlado.
   • Nombre para mostrar: Rechazar valores controlados
   • Acción: Rechazar
   • Conexión de servicio de Kubernetes: azure-pipelines-canary-k8s
   • Espacio de nombres: espacio de nombres dentro del clúster en el que desea implementar.
   • Estrategia: valor controlado
   • Porcentaje: 25
   • Manifiestos: azure-pipelines-canary-k8s/manifests/*

Implementación de una versión estable

Para la primera ejecución de la canalización, la versión estable de las cargas de trabajo y sus versiones de línea de base o de valor controlado no existen en el clúster. Implemente una versión estable de la carga de trabajo sampleapp como se indica a continuación.

Puede implementar una versión estable con YAML o Clásico.

YAML

1. En app/app.py, cambie success_rate = 50 por success_rate = 100. Este cambio desencadena la canalización, compilando e insertando la imagen en el registro de contenedor, y también desencadena la fase DeployCanary.
2. Dado que configuró una aprobación en el entorno akspromote, la versión espera antes de ejecutar esa fase. En la página resumen de la ejecución de compilación, seleccione Revisar y, a continuación, seleccione Aprobar.

Una vez aprobada, la canalización implementa la versión estable de la carga de trabajo sampleapp de manifests/deployment.yml en el espacio de nombres.

Clásico

1. En app/app.py, cambie success_rate = 50 por success_rate = 100. Este cambio desencadena la canalización, lo que conduce a una compilación e inserción de la imagen en el registro de contenedor. El desencadenador de implementación continua, configurado anteriormente en el evento de inserción de imágenes, provoca que se desencadene la canalización de versión.
2. En la canalización de versión CanaryK8sDemo, seleccione la fase Promover o rechazar valor controlado de la versión, donde está esperando la intervención manual.
3. Seleccione Reanudar/Rechazar y, a continuación, seleccione Reanudar en el cuadro de diálogo posterior. Esto implementa la versión estable de las cargas de trabajo (la implementación sampleapp en manifests/deployment.yml) en el espacio de nombres.

Inicio del flujo de trabajo de valor controlado y rechazo de la aprobación

La versión estable de la carga de trabajo sampleapp ahora existe en el clúster. A continuación, realice el siguiente cambio en la aplicación de simulación.

YAML

1. En app/app.py, cambie success_rate = 50 por success_rate = 100. Este cambio desencadena la canalización, compilando e insertando la imagen en el registro de contenedor, y también desencadena la fase DeployCanary.
2. Dado que configuró una aprobación en el entorno akspromote, la versión espera antes de ejecutar esa fase.
3. En la página de resumen de la ejecución de compilación, seleccione Revisar y, a continuación, seleccione Rechazar en el cuadro de diálogo posterior. Esto rechaza la implementación.

Una vez rechazada, la canalización impide la implementación de código.

Clásico

1. En app/app.py, cambie success_rate = 50 por success_rate = 100. Este cambio desencadena la canalización, lo que conduce a una compilación e inserción de la imagen en el registro de contenedor. El desencadenador de implementación continua, configurado anteriormente en el evento de inserción de imágenes, provoca que se desencadene la canalización de versión.
2. En la canalización de versión CanaryK8sDemo, seleccione la fase Promover o rechazar valor controlado de la versión, donde está esperando la intervención manual.
3. Seleccione Reanudar/Rechazar y, a continuación, seleccione Rechazar en el cuadro de diálogo posterior. Esto rechaza la implementación.

Limpiar

Si no va a seguir usando esta aplicación, elimine el grupo de recursos en Azure Portal y el proyecto de Azure DevOps.