Microservicios Avanzado: Consistencia Distribuida y Operación

Curso de nivel avanzado dirigido a backend engineers que ya operan microservicios y necesitan dominar los patrones de consistencia distribuida, observabilidad y despliegue sin downtime. El participante aprenderá a diseñar arquitecturas event-driven con Redis Streams aplicando los patrones correctos de evento, implementar el patrón Saga en coreografía con compensaciones idempotentes, separar modelos de lectura y escritura con CQRS, instrumentar trazas distribuidas con correlation IDs end-to-end, asegurar la comunicación entre servicios con validación de JWT en cada servicio, desplegar sin downtime con blue-green y graceful shutdown, y definir SLOs con métricas en Prometheus y alertas en Grafana. Al finalizar, será capaz de diseñar, implementar y operar un sistema de microservicios de producción con transacciones distribuidas, trazabilidad completa y fiabilidad medida.

Al finalizar el curso, el participante será capaz de:

• Diseñar una arquitectura event-driven con Redis Streams aplicando los patrones event notification y event-carried state transfer, configurando consumer groups independientes para cada servicio consumidor y verificando que el sistema tolera el reinicio independiente de cualquier servicio sin pérdida de mensajes
• Implementar el patrón Saga en su variante de coreografía para una transacción distribuida de 3 pasos con Redis Streams, con acciones de compensación idempotentes verificadas mediante tests que simulan el fallo en cada punto de la transacción
• Diseñar una arquitectura CQRS separando el modelo de escritura del de lectura con proyecciones actualizadas vía eventos de forma asíncrona, justificando para cada escenario si la consistencia eventual es aceptable o requiere un mecanismo de "read your own writes"
• Instrumentar trazas distribuidas en un sistema de 3 servicios propagando correlation IDs end-to-end a través de llamadas HTTP y eventos Redis Streams, con logs estructurados en JSON que permitan diagnosticar una petición fallida en menos de 2 minutos
• Diseñar e implementar la estrategia de seguridad entre servicios: validación de JWT con verificación de firma en cada servicio receptor, lista explícita de servicios autorizados por endpoint, y tests que verifican el rechazo de tokens inválidos, expirados y de servicios no autorizados
• Implementar una estrategia de despliegue blue-green con Nginx para actualizar un microservicio sin downtime, configurando el graceful shutdown del servicio anterior y verificando con tests de peticiones concurrentes que no se produce ningún error 5xx durante el switch
• Definir los SLOs de un sistema de microservicios (disponibilidad, latencia P95 por servicio, tasa de error end-to-end) e implementar las métricas con Prometheus y las alertas preventivas en Grafana necesarias para verificar su cumplimiento

1. Arquitectura event-driven con Redis Streams Patrones de evento: event notification (trigger pequeño, consumidor llama al productor) vs event-carried state transfer (evento con datos completos, desacoplamiento temporal total); consumer groups en Redis Streams: por qué cada consumidor independiente necesita su propio grupo; Pending Entries List y recuperación de mensajes tras reinicio; idempotencia del consumidor: por qué at-least-once delivery hace obligatorio el diseño idempotente; cuándo usar event notification vs event-carried state transfer y trade-offs de cada patrón
2. Saga en coreografía: transacciones distribuidas con compensaciones Problema de las transacciones distribuidas: por qué ACID no funciona en microservicios; Saga como "undo log distribuido"; coreografía vs orquestación: diferencias estructurales y cuándo elegir cada una; diseño de la cadena de compensaciones: qué evento de fallo activa qué compensación; idempotencia de las compensaciones: registro de compensaciones por order_id para evitar doble-compensación en reintentos; tests de compensación: simular fallo en cada paso individual, no solo en el último
3. CQRS: modelos de lectura y escritura separados Problema que resuelve CQRS: cuando el modelo de escritura normalizado es inadecuado para las queries de lectura; separación de modelos: write model normalizado + read models desnormalizados especializados por query; proyecciones event-driven: flujo de actualización asíncrono via eventos; consistencia eventual: ventana de inconsistencia, cuándo es aceptable para el negocio; mecanismo "read your own writes" para escenarios donde el lag no es aceptable; CQRS no implica microservicios separados
4. Trazas distribuidas con correlation IDs Problema del diagnóstico en sistemas distribuidos sin trazabilidad: O(horas) vs O(minutos); correlation ID: generación en entry point, propagación en headers HTTP y en payload de eventos Redis; logs estructurados en JSON: campos mínimos (correlation_id, service, timestamp, level, message); centralización de logs; demostración de diagnóstico: grep por correlation_id recupera la traza completa; pitfall: no propagar el correlation_id al bus de eventos rompe la traza en el primer paso asíncrono
5. Seguridad entre servicios: JWT en cada servicio y autorizaciones Riesgo de validar JWT solo en gateway: blast radius de un servicio comprometido; validación de JWT con verificación de firma en cada servicio receptor (PyJWT, python-jose); claim de servicio emisor: cómo identificar qué servicio originó la petición; lista de servicios autorizados por endpoint: principio de mínimo privilegio; problema del "confused deputy": por qué pasar X-User-ID sin firma en headers es una vulnerabilidad; mecanismo de autenticación servicio-a-servicio: Client Credentials flow de OAuth2
6. Despliegue blue-green y SLOs con Prometheus/Grafana Despliegue blue-green: secuencia correcta (levantar green, health check, switch, drain de blue, terminar blue); graceful shutdown: SIGTERM + drain period para completar peticiones en vuelo; problema de las peticiones en vuelo sin graceful shutdown; test de cero downtime con peticiones concurrentes durante el switch; SLIs, SLOs y SLAs: diferencias y relación; error budget: qué es y cómo informa las decisiones de despliegue; instrumentación con prometheus_client: Histogram para latencia, Counter para errores; alertas preventivas por burn rate; panel de Grafana con estado de SLOs

• Python 3.10+ con pip: redis, fastapi, uvicorn, python-jose, prometheus_client, httpx, PyJWT
• Docker Desktop con Docker Compose v2 y al menos 12 GB de RAM disponibles (Prometheus + Grafana consumen ~1 GB adicional)
• Redis 7+ como contenedor: redis:7-alpine
• Nginx como load balancer para el ejercicio de blue-green: nginx:alpine
• Prometheus + Grafana en docker-compose: prom/prometheus:latest y grafana/grafana:latest
• Editor de código: VS Code con extensión REST Client para pruebas de endpoints

→ MSV01 — Microservicios: Patrones Fundamentales (Intermedio, 8h)

• Comparar la arquitectura de microservicios con la monolítica y seleccionar la adecuada para un caso de uso
• Descomponer un dominio en servicios con bounded contexts y responsabilidad única
• Diseñar contratos OpenAPI versionados y verificarlos con pruebas de integración
• Implementar un API gateway con JWT, enrutamiento y rate limiting
• Distinguir comunicación síncrona (httpx) de asíncrona (Redis Streams XREADGROUP + XACK)
• Implementar el patrón circuit breaker con tres estados y fallback de degradación controlada
• Diseñar la estrategia de datos con database-per-service y sincronización por eventos