Tutorial de Azure Pipelines: Una guía completa de CI/CD para principiantes

Si tu proceso CI/CD se rompe constantemente o parece lento y torpe, no eres el único. He tenido que lidiar con compilaciones fallidas, entornos desajustados y compañeros de equipo que accidentalmente sobrescribían mi trabajo. Azure Pipelines elimina estas frustraciones con un servicio alojado en la nube que puede crear, probar y desplegar casi cualquier proyecto en cualquier plataforma.

Por eso, en este tutorial, te mostraré cómo hacerlo:

1. Crea tu primer Azure Pipeline
2. Construye tu proyecto en la nube
3. Añade pruebas automatizadas para detectar errores a tiempo
4. Despliega en la fase de preparación o de producción con una sola pulsación
5. Supervisa y optimiza tu canalización para que sea más rápida y fiable
6. Sigue las mejores prácticas probadas en proyectos del mundo real

¡Empecemos!

¿Qué es Azure Pipelines?

Azure Pipelines es una solución basada en la nube que simplifica el desarrollo, las pruebas y el despliegue de aplicaciones. 

Es un componente del conjunto de herramientas Azure DevOps, que da soporte a todo el ciclo de vida del desarrollo de software. También es una opción flexible para equipos de todos los tamaños, porque admite varias plataformas y lenguajes de programación. GitHub, Azure Repos y otros conocidos sistemas de control de versiones están integrados con él. 

Las características principales de Azure Pipelines incluyen: 

En mi experiencia, Azure Pipelines es útil para cualquiera que desee tener proper CI/CD dentro de su equipo. Es flexible, escalable y se integra bien con otros servicios de Azure.

Arquitectura de Azure Pipelines (Fuente: Microsoft).

Si buscas una comprensión más amplia de Azure DevOps más allá de los pipelines, este tutorial Azure DevOps warecorre todo el ciclo de vida de CI/CD de principio a fin.

Configurar tu primera canalización en Azure

Para trabajar con el entorno Azure Pipelines, primero debemos configurarlo todo para fomentar un proceso de creación, prueba y despliegue de extremo a extremo.

Requisitos previos

Antes de lanzarte a crear tu primera canalización, asegúrate de que tienes lo siguiente:

1. Configuración de la cuenta y la organización de Azure DevOps: Regístrate eno en una cuenta Azure DevOpsnt si aún no la tienes. Crea una organización para gestionar tus proyectos. 
2. Repositorio: Necesitarás un repositorio de código con un proyecto de ejemplo. Puede alojarse en Azure Repos o en GitHub. Para este tutorial, utilizaremos un proyecto Node.js sencillo.
3. Acceso al portal Azure: También necesitarás acceder a tl portal de Azure cuando quieras desplegar en servicios de Azure como Azure Kubernetes Service (AKS) y muchos más.

Si necesitas ponerte al día sobre el ecosistema Azure en general, te recomiendo que consultes el curso Comprender Microsoft Azure. 

Crear un nuevo proyecto y repositorio

Ahora que tu cuenta Azure DevOps y tu organización están configuradas, vamos a crear nuestro primer proyecto y repositorio.

• Crea un nuevo proyecto:
  • Accede a tu cuenta Azure DevOps.
  • Haz clic en Nuevo proyecto, dale un nombre (por ejemplo, "AzureDevOps-DataCamp-Tutorial") y elige la visibilidad (pública o privada).
  • Haz clic en Crear proyecto.

• Crea un repositorio:
  • Si utilizas Azure Repos, navega hasta la secciónRepos e inicializa un nuevo repositorio.
  • Alternativamente, puedes vincular un repositorio GitHub existente seleccionando Importar repositorio.
  • Ponle un nombre a tu repositorio, elige el tipo de repositorio (Git o TFVC), pega la URL de tu repositorio clonado y haz clic en Importar.

• Si utilizas GitHubpuedes vincular tu cuenta de GitHub a Azure DevOps yendo a la parte inferior izquierda de la interfaz de tu proyecto y seleccionando Configuración del proyecto > Conexiones GitHub > Conectar tu cuenta de GitHub.

Para este tutorial, utilizaremos Azure Repos como nuestro repositorio de código. Si estás empezando o no tienes una razón específica para elegir TFVC, te aconsejo que elijas Git.

Crear tu primera canalización

Es hora de crear nuestra primera tubería. Sigue los pasos que se indican a continuación:

• En tus Tuberías haz clic en Crear pipeline.

• Selecciona Azure Repos Git como fuente y elige tu repositorio.

• Puedes configurar tu canalización utilizando el editor YAML o Clásico. Vamos con YAML, una forma de definir la canalización basada en código.
• Guarda la tubería y ejecútala para ver si todo funciona correctamente.

Elegir YAML vs Editor Clásico

Azure Pipelines proporciona dos formas de definir tus pipelines:

• Canalizaciones YAML: Una forma codificada de describir tu canalización. Se definen en un archivo .yaml o .yml en tu repositorio de fuentes, lo que permite el versionado y una mejor colaboración.
• Editor clásico: El Editor clásico es una interfaz visual de arrastrar y soltar fácil de usar que es menos flexible para escenarios complejos.

En mi experiencia, las canalizaciones YAML proporcionan más flexibilidad y son mejores para los equipos quepermiten prácticas de Infraestructura como Código (IaC). Pero este Editor Clásico es perfecto para los más frescos, con una forma más visual de hacer las cosas. 

Sin embargo, para una escalabilidad a largo plazo, se recomiendan las canalizaciones YAML en lugar del Editor Clásico.

Construir con Azure Pipelines

Ahora, veamos cómo podemos construir con Azure Pipelines. 

En esta sección, especificaremos los pasos que Azure Pipelines realiza para construir tu código, como la instalación de dependencias, la compilación y la ejecución de pruebas. Vamos a expresar estos pasos en un archivo de configuración en nuestro repositorio de código fuente utilizando YAML, una forma sencilla y legible por humanos de describir los pasos de una receta.

Sintaxis de la canalización YAML

Aquí tienes un ejemplo sencillo de una canalización YAML:

# This section defines the trigger(s) for the pipeline.
# 'main' specifies that the pipeline will run whenever changes are pushed to the 'main' branch.
trigger:
- main  # automatically triggers this pipeline when changes are made to the 'main' branch.

# This defines the pool where the pipeline will run.
# 'ubuntu-latest' specifies the virtual machine image for executing tasks.
pool:
  vmImage: 'ubuntu-latest'  # This uses the latest Ubuntu image provided by Azure DevOps.

# Steps contain the individual tasks or actions that the pipeline will execute.
steps:
- script: echo Hello, world!  # A script task to run shell commands. This one prints "Hello, world!".
  displayName: 'Run my first pipeline script'  # A friendly name for this step, making it easier to identify in the pipeline logs.

Vamos a desglosar el código paso a paso:

• trigger: Especifica la rama que activa la canalización (por ejemplo, main).
• pool: Define el agente de construcción (por ejemplo, ubuntu-latest).
• steps: Enumera las tareas a ejecutar, como instalar dependencias y ejecutar un script de compilación.

Configurar los pasos de construcción

Para añadir pasos de compilación a tu canalización YAML, debes definir el "script" en la sección "pasos".

Para una aplicación sencilla de Node.js, por ejemplo, nuestro archivo azure-pipelines.yml de abajo contiene código que Azure DevOps creó automáticamente.

# Node.js
# Build a general Node.js project with npm.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: NodeTool@0
  inputs:
    versionSpec: '20.x'
  displayName: 'Install Node.js'

- script: |
    npm install
    npm run build
  displayName: 'npm install and build'

Echemos un vistazo a la construcción steps en el canal YAML anterior: 

1. Instala Node.js: Utiliza la tarea NodeTool@0 para especificar la versión de Node.js. 
2. Instala las dependencias: Ejecuta npm install para instalar las dependencias del proyecto. 
3. Compila el código (construye el proyecto): Ejecuta npm run build para compilar el código. 

Ejecutar el oleoducto

Nuestro pipeline puede activarse manualmente o configurarse para que se ejecute automáticamente cuando se produzcan eventos como el empuje de ramas.

• Disparo manual: Haz clic en Ejecutar canalización en la interfaz Azure DevOps para activar la canalización manualmente.

• Disparo automático: Establece desencadenantes basados en eventos del repositorio para enviar cambios a la rama main y desencadenar la canalización automáticamente. He aquí un ejemplo:

trigger:
- main

Después de ejecutar tu canalización, puedes ver los registros y solucionar cualquier problema.

Para acceder a los registros, ve al resumen de ejecución de tu pipeline y selecciona el trabajo o tarea específicos. Esto mostrará los registros de ese paso; como en la imagen de abajo, puedes elegir cualquier trabajo (Construir, Empujar o Actualizar) para ver los registros sin procesar.

Para solucionar problemas comunes, puedes comprobar tu canalización en busca de problemas comunes como tiempos de espera, limitaciones de recursos o configuraciones erróneas.

Añadir pruebas a tu pipeline

Añade pruebas a tu proceso para garantizar la calidad del código y detectar problemas en las primeras fases del desarrollo. En Azure Pipelines, puedes integrar pruebas unitarias, de integración o de otro tipo añadiendo pasos en la configuración de tu pipeline.

Configurar los pasos de la prueba

Incluye pasos de prueba en tu pipeline para garantizar la calidad del código. Puedes utilizar frameworks populares como Jest, Mocha o NUnit. Por ejemplo, aquí tienes cómo añadir pruebas unitarias con Jest:

- script: |
    npm test
  displayName: 'Run unit tests with Jest'

Ver los resultados de las pruebas

Hay informes de pruebas integrados en Azure Pipelines. Puedes configurar la publicación de los resultados de las pruebas para un seguimiento más sencillo y ver los resultados de las pruebas en los registros de la canalización. Así se hace:

• Primero, navega hasta Construye > Resultados de las pruebas.
• Para publicar los resultados de las pruebas, utiliza la tarea PublishTestResults@2 para mostrar los resultados. Esto facilita el seguimiento general. Por ejemplo:

- task: PublishTestResults@2
  inputs:
    testResultsFiles: '**/test-results.xml'
    testRunTitle: 'Unit Tests'

Despliegue con Azure Pipelines

En los pasos de despliegue de tu archivo YAML de canalización de Azure, puedes desplegar automáticamente tu aplicación en varios entornos, como pruebas, staging y producción. En esta sección, revisaremos algunas formas de desplegar con Azure Pipelines.

Despliegue en Azure Web Apps

Azure Web Apps es un servicio del Portal Azure que te permite desarrollar, desplegar y gestionar aplicaciones web a escala. 

Para desplegar en Azure Web Apps, debes vincular los dos servicios. He aquí cómo hacerlo:

• En la parte inferior izquierda de tu proyecto, ve a Configuración del proyecto y haz clic en Conexiones de servicio debajo de Tuberías sección.

• Haz clic en Nueva conexión de servicio y selecciona Gestor de Recursos Azure.

• Autentícate con tu cuenta Azure.
• Despliega en Azure App Service:
  • Vuelve a tus Pipelines y configura tu pipeline.
  • En tu pipeline, añade una tarea para desplegar en Azure.
  • Especifica el grupo de recursos y los detalles del servicio. 

He aquí un ejemplo de canalización de despliegue YAML para una sencilla aplicación Node.js en Azure App Service:

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1
  inputs:
    # This specifies your Azure subscription service connection
    azureSubscription: 'your-azure-subscription'
    # This specifies the name of your web app
    appName: 'your-app-name'
    # This specifies the location of the app package or files to be deployed
    package: '$(Build.ArtifactStagingDirectory)'

Vamos a desglosar el código anterior, para que puedas adaptarlo a tu caso de uso:

• Sustituye your-azure-subscription por el nombre de la conexión de servicio que da acceso a tu suscripción de Azure.
• Sustituye your-app-name por el nombre real de tu aplicación web en Azure. 
• Sustituye $(Build.ArtifactStagingDirectory) por el directorio donde colocar el paquete o los archivos de la aplicación web para su despliegue. $(Build.ArtifactStagingDirectory) - Esta variable apunta a la carpeta en la que se encuentran tus artefactos de compilación (los archivos de tu aplicación) una vez compilados.

Configurar el despliegue continuo (DC)

Una vez que todo nuestro código supera todas las pruebas y comprobaciones, el siguiente paso es configurar nuestro despliegue continuo. Sigue los pasos que se describen a continuación.

Modelo de despliegue de la canalización de versiones de Azure (Fuente: Microsoft)

• Crea una cadena de liberación:
• Ir a Tuberías > Lanzamientos y haz clic en Nueva pipeline.

• Selecciona la opción Despliegue de Azure App Service plantilla.

• Configura los entornos:
• Añadir y configurar Desarrollo, Puesta en escena, QAy Producción en los que quieres que se despliegue tu aplicación.

• Vincula el artefacto de tu proceso de creación como fuente del proceso de publicación seleccionando Añadir un artefacto.

• Configura aprobaciones y puertas:
• Es necesario establecer aprobaciones previas a la implantación para entornos sensibles, como los de producción. Por ejemplo, puede ser necesario que un jefe de equipo apruebe la liberación. También puedes añadir puertas como pruebas automatizadas o comprobaciones de seguimiento para garantizar que la implantación cumple las normas de calidad.

Según mi experiencia, esta fase es necesaria para mantener la estabilidad en entornos de desarrollo exigentes. Las aprobaciones y las puertas proporcionan control y garantizan que sólo el código de alta calidad llegue a la producción.

Despliegue en Kubernetes

Kubernetes facilita la ejecución de aplicaciones en contenedores fiables y escalables. Al utilizar Azure Kubernetes Service (AKS), obtienes un entorno gestionado que simplifica el despliegue y las operaciones. En esta sección, te explicaré cómo desplegar tu aplicación en AKS utilizando Azure Pipelines.

Prepara tu Cluster AKS

Puedes crear un clúster AKS utilizando el portal de Azure o la CLI. Aquí tienes un comando CLI Bash básico para aprovisionar el clúster:

az aks create \
  --resource-group <ResourceGroupName> \
  --name <AKSClusterName> \
  --node-count 3 \
  --enable-addons monitoring \
  --generate-ssh-keys

Vamos a desglosar el comando anterior:

• --resource-group: Indica el grupo de recursos de Azure en el que se creará el clúster AKS.
• --name: Se refiere al nombre de tu cluster AKS.
• --node-count: Establece el número de nodos del clúster (por ejemplo, 3 en este ejemplo).
• --enable-addons monitoring: Esto hace posible la supervisión y el análisis con Azure Monitor for Containers.
• --generate-ssh-keys: Esto genera automáticamente claves SSH para el acceso seguro al nodo si no se proporcionan.

No olvides sustituir y por los nombres reales de tu grupo de recursos y clúster.

Kubectl debe configurarse después de que tu clúster AKS esté configurado. Esto garantiza que tu agente de canalización u ordenador local pueda utilizar kubectl para comunicarse con el clúster.

Puedes acelerar tus tareas en Azure utilizando la línea de comandos aols: esta hoja de trucos de la CLI de Azure es una referencia práctica.

Crear un archivo YAML de despliegue 

Tomemos como ejemplo un archivo YAML de despliegue básico para desplegar una imagen Docker en Kubernetes:

# This defines the API version and the kind of Kubernetes resource we are creating.
# 'apps/v1' is the API version, and 'Deployment' is the resource type.
apiVersion: apps/v1
kind: Deployment

# Metadata contains information to identify the resource uniquely.
# 'name' specifies the name of the Deployment.
metadata:
  name: my-app  # Name of the Deployment, used for identification.

# "spec" specifies the intended deployment state.
spec:
  # Number of replicas/pods we want for this Deployment.
  replicas: 3  # Ensures high availability by running three app replicas.

  # Selector is used to define the labels that this Deployment will manage.
  selector:
    matchLabels:
      app: my-app  # This ensures that only Pods with the label 'app: my-app' are managed by this Deployment.

  # Template specifies the blueprint for the pods created by the Deployment.
  template:
    metadata:
      labels:
        app: my-app  # Labels for the Pods, matching the selector above.

    # A specification for the containers of the Pods.
    spec:
      containers:
      - name: my-app  # Name of the container. This is useful for linking to the container in logs, etc.
        image: mycontainerregistry.azurecr.io/my-app:latest  # Pull the container image you will call from your container registry.
        ports:
        - containerPort: 80  # The container listens on port 80.

Despliega utilizando Azure Pipelines

En tu canalización YAML, incluye una tarea para desplegar en AKS.

# This defines a task for deploying Kubernetes manifests within an Azure DevOps pipeline.
- task: KubernetesManifest@0  # Task type for working with Kubernetes manifest files.
  inputs:
    # This configures what to do with the Kubernetes manifest files.
    action: 'deploy'  # 'deploy' action ensures the Kubernetes manifests are applied to the cluster.

    # This defines the namespace where the Kubernetes resources will be deployed.
    namespace: 'default'  # 'default' is the namespace for deploying resources. Change if needed.

    # All this does is point to the manifest files that define the desired state of your Kubernetes resources.
    manifests: '$(Build.ArtifactStagingDirectory)/manifests/*.yaml'
    # The 'manifests' variable points to the location of all the YAML files (e.g., Deployment, Service, etc.) that will be applied during the deployment.

    # To access private container registry images, use the image pull secret.
    imagePullSecrets: 'my-registry-secret'
    # This instructs Kubernetes on which secret to use when pulling images from a private container registry.
    # Ensure that 'my-registry-secret' exists in the namespace before the deploy

Confirma y envía el archivo YAML para activar el despliegue.

AKS simplifica la orquestación de contenedores, facilitando la gestión del escalado, las actualizaciones y las reversiones. En mi experiencia, es imprescindible para las aplicaciones modernas nativas de la nube.