GuíaIntermedio
Guía de Patrones de Resiliencia y Confiabilidad
Aprende a hacer que un sistema distribuido sobreviva a las fallas de sus partes: timeouts, reintentos con backoff y jitter, idempotencia, circuit breakers, bulkheads, degradación elegante y load shedding. El eje de la guía es la falla parcial —en un sistema distribuido siempre hay algo caído o lento— y cómo evitar que la falla de una dependencia se convierta en la caída de todo el sistema. Trabajas sobre un solo caso de principio a fin: el flujo de checkout de Mercado, donde `orders` llama a `payments` y `shipping`, y esas dependencias fallan y se ponen lentas de verdad. Todo se simula y se mide en Python con tasas de falla y latencia configurables: vas a medir el thread exhaustion sin timeout, el retry storm sin backoff, cuántas llamadas se ahorra un circuit breaker cuando el servicio está muerto, cómo un bulkhead aísla una dependencia lenta para que no agote a las demás, y el success rate del checkout antes y después de blindarlo. El capstone combina todos los patrones sobre el checkout completo de Mercado y mide el resultado.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Entender la falla parcial y la falla en cascada: por qué en distribuido algo siempre está caído o lento
- Poner timeouts correctos (conexión y lectura) y medir cómo evitan el agotamiento de hilos/conexiones
- Reintentar con backoff exponencial y jitter para evitar el retry storm, y saber cuándo NO reintentar
- Implementar idempotencia con `idempotency_key` para que un reintento no cobre ni ejecute una operación dos veces
- Aplicar circuit breakers (estados `CLOSED`/`OPEN`/`HALF_OPEN`) para dejar de golpear a un servicio muerto y medir la recuperación automática
- Aislar dependencias con bulkheads para que una lenta no agote el pool de las demás
- Diseñar degradación elegante y load shedding para que el sistema falle suave, no duro, bajo sobrecarga
- Blindar de punta a punta un flujo real combinando todos los patrones, midiendo el success rate y la latencia antes y después
Antes de empezar
Qué necesitas traer
Es para ti si...
- Backend devs cuyo servicio llama a dependencias poco confiables (red, terceros, otros microservicios) y no sabe cómo blindarlo
- Devs que ya pusieron un `try/except` alrededor de una llamada externa pero nunca midieron si realmente ayuda
- Cualquiera que necesite entender circuit breakers, bulkheads o backoff antes de usar una librería como resilience4j o Polly
- Equipos que sufrieron una falla en cascada y quieren aprender a diseñar contra ella con criterio, no con parches
Requisitos y materiales
- Python básico (todas las simulaciones y mediciones de esta guía se ejecutan en Python)
- Haber construido un servicio backend que llama a otro servicio o API externa
- No se requiere experiencia previa con librerías de resiliencia ni con sistemas distribuidos
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Presentación del módulo: el día que `shipping` tumbó todo el checkout
- 2. La falla parcial: en distribuido, algo siempre está roto
- 3. Las falacias de la computación distribuida
- 4. La falla en cascada: cómo una dependencia lenta tumba todo
- 5. El pool exhaustion: por qué `shipping` lento agota los hilos de `orders`
- 6. Por qué el monolito no tenía este problema
- 7. El mapa de los puntos de falla del checkout de Mercado
- 8. Mini-proyecto: mapea los modos de falla del checkout de Mercado
- 1. Presentación del módulo: el asesino silencioso
- 2. Qué es un timeout
- 3. Exhaustion del pool sin timeouts
- 4. Timeout de conexión vs de lectura
- 5. Elegir el valor desde el p99
- 6. El timeout como contrato de tiempo
- 7. Timeouts en cadena y presupuesto de tiempo
- 8. Proyecto: pon timeouts al checkout de Mercado y mide
- 1. Presentación del módulo: el reintento que cobra dos veces
- 2. El doble cargo del reintento, medido
- 3. La idempotency key
- 4. Cómo el servidor deduplica y guarda el resultado
- 5. Operaciones idempotentes por diseño
- 6. PUT vs POST vs GET
- 7. El mito del exactly-once
- 8. Proyecto: haz idempotente el `charge` de Mercado y pruébalo con reintentos
- 1. Presentación del módulo: deja de golpear a un muerto
- 2. El costo de seguir llamando a un muerto, medido
- 3. Los tres estados del circuit breaker
- 4. De CLOSED a OPEN: abrir por umbral
- 5. HALF_OPEN y la recuperación automática
- 6. Circuit breaker vs. retry: insistir vs. rendirse
- 7. Elegir el umbral y el cooldown
- 8. Proyecto: ponle un breaker a `shipping` en Mercado y mide
- 1. Presentación del módulo: el recorrido de vuelta
- 2. Mide la línea base sin protección
- 3. Contén la explosión con timeouts
- 4. Haz que `payments` reintente sin cobrar dos veces
- 5. Aísla y corta a `shipping`
- 6. Degrada y descarta para seguir en pie
- 7. Mide el antes y el después
- 8. Proyecto: haz resiliente el checkout de Mercado
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!