Saltar a contenido

Progressive Delivery

En Kubernetes estándar, la estrategia por defecto para actualizar una aplicación es el Rolling Update: Kubernetes reemplaza los Pods viejos por los nuevos uno a uno. El problema es que, si la nueva versión tiene un bug que crashea en producción, tus usuarios lo notarán casi de inmediato.

El Progressive Delivery mitiga este riesgo liberando la nueva versión de forma gradual y controlada. Las estrategias más comunes son:

  • Blue/Green: Tienes un entorno completo con la versión vieja (Blue) y otro con la nueva (Green). Cambias el tráfico al Green de golpe, y si algo falla, regresas al Blue instantáneamente.
  • Canary Release: Envías solo una pequeña porción del tráfico (ej. 10%) a la nueva versión. Si todo va bien, aumentas el porcentaje progresivamente (25%, 50%, 100%).

¿Qué es Analysis (Análisis)?

El Análisis es el "cerebro" automatizado detrás del despliegue progresivo.

En un Canary manual, tú mandarías el 10% del tráfico, abrirías tus dashboards de monitoreo (Prometheus, Datadog, etc.), mirarías si hay errores durante 15 minutos, y luego decidirías si avanzar o retroceder.

Argo Rollouts automatiza esto usando AnalysisTemplates. Mientras se ejecuta el despliegue progresivo, Argo Rollouts consulta métricas reales de tu proveedor de observabilidad.

  • Si las métricas son saludables (ej. 99% de éxito en peticiones HTTP): El Rollout continúa automáticamente al siguiente paso (ej. subir al 50% de tráfico).
  • Si las métricas fallan (ej. picos de latencia o consumo de CPU): Argo Rollouts aborta el despliegue de inmediato y devuelve el 100% del tráfico a la versión anterior de forma automática.

[!IMPORTANT] An AnalysisTemplate is a reusable blueprint for a health check, and an AnalysisRun is the live execution of that template.

Laboratorio Práctico: Canary con Análisis Simulado

Vamos a hacer un laboratorio real. Como configurar Prometheus en local puede ser tedioso para una primera prueba, usaremos un AnalysisTemplate que ejecuta un Job simple de Kubernetes para simular una validación exitosa.

Requisitos: Un clúster local (Minikube, Kind o Docker Desktop) y kubectl.

Paso 1: Crear el Archivo del Laboratorio

Crea un archivo llamado laboratorio-rollout.yaml y pega el siguiente contenido. Este archivo contiene:

  1. Un Service para exponer la app.
  2. Un AnalysisTemplate que ejecuta un contenedor rápido (simulando un check de métricas que responde "OK").
  3. El Rollout configurado para hacer un Canary del 25%, luego hacer el Análisis, y si pasa, ir al 100%.
---
apiVersion: v1
kind: Service
metadata:
  name: rollout-demo
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: rollout-demo
---
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: simulate-success
spec:
  metrics:
  - name: dummy-check
    # Simulamos un chequeo exitoso levantando un pod que termina en "exit 0"
    provider:
      job:
        spec:
          template:
            spec:
              containers:
              - name: test
                image: alpine:latest
                command: [sh, -c, "sleep 5 && exit 0"]
              restartPolicy: Never
---
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: rollout-demo
spec:
  replicas: 4
  selector:
    matchLabels:
      app: rollout-demo
  template:
    metadata:
      labels:
        app: rollout-demo
    spec:
      containers:
      - name: rollouts-demo
        image: argoproj/rollouts-demo:blue
        ports:
        - containerPort: 8080
  strategy:
    canary:
      steps:
      - setWeight: 25
      # Realiza el análisis antes de seguir avanzando
      - analysis:
          templates:
          - templateName: simulate-success
      - pause: {duration: 10s}
      - setWeight: 100

Paso 2: Ejecutar y Observar la Magia

Aplica los manifiestos iniciales en tu clúster:

kubectl apply -f laboratorio-rollout.yaml

Ahora, abre dos terminales.

En la Terminal 1, ejecuta el dashboard visual de Argo Rollouts en tu terminal. Esto te permitirá ver el progreso en tiempo real:

kubectl argo rollouts get rollout rollout-demo --watch

En la Terminal 2, vamos a forzar una actualización cambiando la imagen de "blue" a "yellow" para detonar el proceso de Progressive Delivery:

kubectl argo rollouts set image rollout-demo rollouts-demo=argoproj/rollouts-demo:yellow

¿Qué verás en la Terminal 1?

  1. Argo Rollouts creará solo 1 Pod nuevo (que representa el 25% de tus 4 réplicas totales).
  2. Automáticamente, disparará el AnalysisRun (lanzando el Job de Alpine).
  3. Verás el estado del análisis en la terminal. Al ser un exit 0, pasará exitosamente después de 5 segundos.
  4. Tras una breve pausa de 10 segundos, Argo Rollouts escalará la nueva versión a 4 Pods y terminará los antiguos, completando el ciclo al 100%.