Azure DevOps es la plataforma de Microsoft para CI/CD en entornos enterprise. Si trabajas con Azure, tarde o temprano necesitas dominar sus pipelines. En este post te explico como crearlos desde cero con ejemplos YAML reales. Si vienes de GitHub Actions, el post de GitHub Actions vs GitLab CI te ayudara a ver las diferencias.

Que es Azure Pipelines

Azure Pipelines es el modulo de CI/CD dentro de Azure DevOps. Lo mas importante: funciona con cualquier repositorio (GitHub, GitLab, Bitbucket) y puede desplegar en cualquier cloud, no solo Azure. Consulta la documentacion oficial de Azure Pipelines para mas detalle.

Conceptos clave de Azure Pipelines

• Pipeline: el proceso completo de CI/CD definido en YAML
• Stage: una fase del pipeline (Build, Test, Deploy)
• Job: conjunto de steps en el mismo agente
• Step: tarea individual — script o task del Marketplace
• Agent: maquina donde se ejecuta el job (Microsoft-hosted o self-hosted)
• Artifact: archivos generados por el pipeline (binarios, imagenes Docker)
• Environment: entorno de despliegue con aprobaciones y controles

Tu primer pipeline en Azure DevOps

El archivo se llama azure-pipelines.yml y va en la raiz del repositorio:

trigger:
  branches:
    include:
      - main

pool:
  vmImage: ubuntu-latest

steps:
  - script: echo "Hola desde Azure Pipelines!"
    displayName: Primer paso

  - script: |
      node --version
      npm --version
    displayName: Ver versiones

Pipeline CI con stages para Node.js

trigger:
  branches:
    include: [ main, develop ]

variables:
  NODE_VERSION: 20

stages:
  - stage: Build
    displayName: Build y Test
    jobs:
      - job: BuildTest
        pool:
          vmImage: ubuntu-latest
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: $(NODE_VERSION)
            displayName: Instalar Node.js
          - script: npm ci
            displayName: Instalar dependencias
          - script: npm run lint
            displayName: Linting
          - script: npm test
            displayName: Tests
          - task: PublishTestResults@2
            inputs:
              testResultsFormat: JUnit
              testResultsFiles: junit.xml
            displayName: Publicar resultados

  - stage: Deploy_Staging
    displayName: Deploy a Staging
    dependsOn: Build
    condition: succeeded()
    jobs:
      - deployment: DeployStaging
        pool:
          vmImage: ubuntu-latest
        environment: staging
        strategy:
          runOnce:
            deploy:
              steps:
                - script: echo "Desplegando en staging..."

  - stage: Deploy_Production
    displayName: Deploy a Produccion
    dependsOn: Deploy_Staging
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - deployment: DeployProd
        pool:
          vmImage: ubuntu-latest
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - script: echo "Desplegando en produccion..."

Pipeline con Docker y Azure Container Registry

El pipeline mas habitual en proyectos Azure: construye una imagen Docker, la sube al ACR y la despliega en AKS:

variables:
  ACR_NAME: miregistro
  IMAGE_NAME: mi-app

stages:
  - stage: Build
    jobs:
      - job: BuildPush
        pool:
          vmImage: ubuntu-latest
        steps:
          - task: Docker@2
            displayName: Build y Push a ACR
            inputs:
              command: buildAndPush
              containerRegistry: mi-acr-connection
              repository: $(IMAGE_NAME)
              dockerfile: Dockerfile
              tags: |
                $(Build.BuildId)
                latest

  - stage: Deploy
    dependsOn: Build
    jobs:
      - deployment: DeployAKS
        pool:
          vmImage: ubuntu-latest
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - task: KubernetesManifest@0
                  displayName: Deploy en AKS
                  inputs:
                    action: deploy
                    kubernetesServiceConnection: mi-aks-connection
                    namespace: default
                    manifests: $(Pipeline.Workspace)/manifests/*.yaml
                    containers: $(ACR_NAME).azurecr.io/$(IMAGE_NAME):$(Build.BuildId)

Variables y secretos en Azure Pipelines

# Variables en el YAML
variables:
  NODE_VERSION: 20
  APP_ENV: production

# Variables de grupo (definidas en Library de Azure DevOps)
variables:
  - group: mi-grupo-de-variables

# Secretos definidos en Library como secret
steps:
  - script: echo "Conectando a la base de datos"
    env:
      DATABASE_URL: $(DATABASE_URL)

Aprobaciones manuales antes de produccion

Una de las grandes ventajas de Azure DevOps: control de aprobaciones integrado en los Environments.

1. Ve a Pipelines – Environments
2. Selecciona el environment production
3. Haz clic en Approvals and checks
4. Añade Approvals con los usuarios aprobadores
5. El pipeline se pausara antes del deploy esperando aprobacion

Agentes: Microsoft-hosted vs self-hosted

Tipo	Ventajas	Cuando usarlo
Microsoft-hosted	Sin mantenimiento, siempre actualizado	Proyectos estandar
Self-hosted	Mas rapido, acceso a red privada, sin limite de minutos	Empresas con VPN o builds pesados

Conclusion

Azure Pipelines es una herramienta muy madura especialmente en entornos enterprise con Azure. El sistema de stages, environments y aprobaciones manuales es de los mas completos del mercado. Si tu empresa ya usa Azure, es la opcion natural — la integracion con ACR, AKS y App Service es mucho mas fluida que con otras plataformas.

En el proximo post veremos Como pasar de sysadmin a DevOps: hoja de ruta completa. Tienes dudas sobre Azure Pipelines? Dejame un comentario.