Microservicios: Patrones Fundamentales

Curso de nivel intermedio dirigido a desarrolladores backend con experiencia en Docker multi-servicio que quieren diseñar e implementar sistemas distribuidos con arquitectura de microservicios. El participante aprenderá cuándo tiene sentido migrar de un monolito a microservicios, cómo descomponer un dominio usando bounded contexts, diseñar contratos OpenAPI versionados entre servicios, implementar un API gateway con autenticación y rate limiting, elegir entre comunicación síncrona y asíncrona con Redis Streams, implementar el patrón circuit breaker para degradación controlada, y diseñar la estrategia de datos de cada servicio de forma independiente. Al finalizar, será capaz de implementar y operar un sistema distribuido de 3-4 microservicios con comunicación correcta, resiliencia ante fallos y datos desacoplados.

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

• Comparar la arquitectura de microservicios con la monolítica y seleccionar la adecuada para un caso de uso dado, justificando el trade-off entre complejidad operacional y escalabilidad independiente por servicio
• Descomponer un dominio de negocio en servicios con responsabilidad única aplicando el principio de bounded context de Domain-Driven Design, identificando las señales de mal diseño (acoplamiento alto, responsabilidades mezcladas)
• Diseñar el contrato de comunicación entre servicios en formato OpenAPI versionado, verificando que ambos servicios respetan el contrato mediante al menos una prueba de integración
• Implementar un API gateway que centralice la verificación de JWT, el enrutamiento por path y el rate limiting por IP, verificando que los servicios internos no son accesibles directamente desde el exterior
• Distinguir entre comunicación síncrona (HTTP con httpx y timeout configurado) y asíncrona (Redis Streams con XADD, XREADGROUP y XACK) e implementar un flujo de cada tipo en Python
• Implementar el patrón circuit breaker con los tres estados (cerrado, abierto y semiabierto) para un servicio con latencia alta, configurando el fallback que permite la degradación controlada del sistema
• Diseñar la estrategia de datos de un sistema de microservicios aplicando el patrón "database per service" y la sincronización de estado compartido mediante eventos, justificando los trade-offs de consistencia eventual resultantes

1. Monolito vs microservicios: cuándo migrar y cómo descomponer el dominio Criterios de migración: cuándo un monolito es la decisión correcta y cuándo los microservicios aportan valor real (escalabilidad diferencial, equipos independientes, despliegue separado); señales de mal diseño en un monolito existente; bounded contexts de DDD como técnica de descomposición; responsabilidad única de servicio y cómo detectar cuando un servicio tiene demasiadas responsabilidades; antipatrón del microservicio distribuido (nano-servicios y chatty services)
2. Contratos entre servicios: OpenAPI, versionado y contract testing OpenAPI como contrato formal entre equipos: structure del documento, campos obligatorios y opcionales, códigos de error; breaking changes y periodos de transición con v1/v2 coexistentes; contract testing con Pact: consumer-driven contracts, cómo el proveedor verifica el pact del consumidor; por qué los tests de integración E2E son insuficientes para verificar contratos entre equipos distintos
3. Comunicación síncrona y asíncrona en Python Criterios de selección: cuándo la respuesta del llamado es condición para responder al cliente (síncrono) vs cuándo es una consecuencia asíncrona; HTTP síncrono con httpx: timeout configurado, manejo de 4xx y 5xx, reintentos; Redis Streams asíncrono: XADD para publicar, XREADGROUP + XACK para consumir con at-least-once delivery, consumer groups para múltiples consumidores independientes; idempotencia del consumidor
4. API gateway: autenticación centralizada, enrutamiento y rate limiting Responsabilidades del gateway: verificación de JWT, enrutamiento por path, rate limiting por IP, TLS termination, logging centralizado; por qué el bypass del gateway rompe el modelo de seguridad; configuración con Nginx como reverse proxy y rate limiter; configuración alternativa con Traefik; rutas públicas vs privadas; servicios internos sin puertos expuestos en docker-compose
5. Circuit breaker y resiliencia ante servicios lentos Problema del fallo en cascada: cómo un servicio lento bloquea workers y propaga el fallo a sus dependientes; tres estados del circuit breaker: cerrado (monitoriza), abierto (fast-fail con fallback), semiabierto (petición de prueba); configuración de umbrales con pybreaker: número de fallos, timeout de recuperación; fallback que permite degradación controlada (vs fallback que bloquea el flujo crítico); test que simula el fallo del servicio dependiente
6. Estrategia de datos: database per service y sincronización por eventos Antipatrón de base de datos compartida: por qué el acoplamiento de esquema impide el despliegue independiente; patrón database per service: cada servicio es propietario de sus datos; sincronización de estado compartido mediante eventos: evento bien diseñado con datos suficientes para que el consumidor actúe; ventana de consistencia eventual y cuándo es aceptable; manejo de fallos del consumidor con at-least-once delivery

• Python 3.10+ con pip: httpx, redis, fastapi, uvicorn, python-jose (JWT), pybreaker
• Docker Desktop con Docker Compose v2
• Redis 7+ (disponible como contenedor oficial redis:7-alpine)
• Cliente HTTP: curl o Postman para probar el API gateway
• Editor de código: VS Code con extensión REST Client o Thunder Client para probar endpoints

→ DCK02 — Docker: Imágenes, registros y distribución (Intermedio, 8h)

• Construir y publicar imágenes Docker optimizadas con multi-stage builds
• Gestionar docker-compose con múltiples servicios, redes internas y variables de entorno
• Configurar health checks y depends_on para controlar el orden de arranque entre servicios
• Exponer selectivamente puertos al host y aislar la comunicación interna entre contenedores

Competencia complementaria recomendada — REST APIs Iniciación (API01, 4h):

• Conocimiento básico de HTTP: métodos (GET, POST, PUT, DELETE), códigos de estado (2xx, 4xx, 5xx) y headers principales
• Construcción y consumo de endpoints REST con FastAPI o Flask en Python