Timeouts, plazos, reintentos con backoff y jitter, circuit breaker, bulkheads y deslastre de carga para contener fallos parciales y medirlos.
Un viernes, el servicio de recomendaciones empieza a tardar treinta segundos en lugar de ochenta milisegundos. No está caído: responde, pero tarde. La página de pago lo llama para mostrar «también te puede interesar», sus hilos se quedan esperando, el pool de conexiones se agota y, al cabo de unos minutos, nadie puede pagar. Para empeorarlo, cada capa reintenta lo que le falla y multiplica la carga sobre el servicio que ya no podía con ella. Un detalle secundario tumbó la función principal.
La resiliencia es la capacidad de un sistema de seguir prestando lo más importante, aunque sea degradado, cuando una parte falla o se vuelve lenta, y de recuperarse sin intervención heroica. No consiste en evitar los fallos, sino en contenerlos: decidir cuánto esperas, cuántas veces insistes, cuándo dejas de llamar, qué aíslas y qué sacrificas.
Este artículo recorre esos mecanismos en el orden en que suelen aplicarse (timeouts y plazos, reintentos, circuit breaker, bulkheads, deslastre de carga y degradación), cómo comprobarlos con chaos engineering y cómo medirlos. Deja fuera dos temas vecinos: la teoría de consistencia está en CAP, PACELC y consistencia y la compensación de transacciones, en sagas, outbox e idempotencia.
Las versiones de bibliotecas son de octubre de 2026 (GitHub y NuGet). Los artículos de la Amazon Builders' Library redirigen ahora a builder.aws.com. No consulté directamente el libro Release It!: lo que se dice de él viene del artículo de Martin Fowler y de reseñas, y está señalado así.
En un solo proceso, una llamada a función termina o lanza una excepción. En un sistema distribuido hay un tercer resultado: no sabes qué pasó. La petición pudo perderse, ejecutarse sin que llegara la respuesta o seguir en curso. Además, el sistema rara vez está entero caído o entero sano; casi siempre hay algo degradado.
Las falacias de la computación distribuida resumen las suposiciones que llevan a olvidarlo. Según el artículo de Arnon Rotem-Gal-Oz y la entrada de Wikipedia, L Peter Deutsch, entonces en Sun Microsystems, recogió siete en 1994 a partir del trabajo de otros colegas de Sun, y James Gosling añadió la octava hacia 1997. Cada una tiene una consecuencia de diseño:
Una dependencia caída falla rápido: la conexión se rechaza y el llamante sigue. Una dependencia lenta retiene hilos, conexiones y memoria mientras espera. El capítulo sobre fallos en cascada del libro de SRE de Google lo describe como latencia bimodal: una fracción pequeña de peticiones colgadas hasta un plazo largo puede ocupar la mayoría de los hilos y dejar sin servicio al resto. Por eso casi todos los mecanismos de este artículo buscan lo mismo: convertir la lentitud en un fallo rápido y acotado.
El timeout es la primera defensa y la más olvidada. Marc Brooker, en su artículo de la Builders' Library sobre timeouts, reintentos y backoff, recomienda ponerlo en cualquier llamada remota, incluso entre procesos de la misma máquina, y distinguir el timeout de conexión del timeout de petición. No asumas que el cliente que usas trae uno razonable: la documentación de gRPC, por ejemplo, avisa de que por defecto no fija ningún plazo.
Para elegir el valor, el mismo artículo propone partir de una tasa aceptable de falsos timeouts (por ejemplo, 0,1 %) y usar el percentil correspondiente de la latencia de la dependencia (el p99,9 en ese caso). Dos matices que añade:
Un timeout por salto no basta. Si el borde concede 2 s al usuario y cada servicio intermedio fija 2 s a su propia llamada, el trabajo sigue aguas abajo mucho después de que el usuario haya recibido un error. La alternativa es un plazo (deadline): se fija una vez, arriba, y cada salto pasa a la siguiente llamada solo el tiempo que queda.
sequenceDiagram participant U as Usuario participant E as Borde participant C as Checkout participant P as Precios U->>E: GET /checkout Note over E: plazo total 2000 ms E->>C: llamada (restan 1950 ms) Note over C: 300 ms de trabajo propio C->>P: llamada (restan 1650 ms) P-->>C: respuesta C-->>E: respuesta E-->>U: 200
El libro de SRE recomienda exactamente eso: fijar el plazo en lo alto de la pila, restar el tiempo consumido en cada salto y comprobar el tiempo restante antes de cada etapa para no hacer trabajo que el cliente ya abandonó. Añade la propagación de la cancelación: si la petición ya no puede tener éxito, cancela el trabajo relacionado en toda la cadena en lugar de dejar que agote su plazo. gRPC transmite el tiempo restante como duración y no como hora absoluta, lo que evita depender de relojes sincronizados; su documentación advierte de que la propagación automática depende del lenguaje.
La forma del contrato basta para orientar el diseño: el plazo y la señal de cancelación viajan con la llamada.
// Forma orientativa: el contexto de la llamada lleva el plazo y la cancelación type CallContext = { readonly deadline: number; // instante límite en ms, del reloj del proceso readonly signal: AbortSignal; // se activa si el llamante abandona }; export declare function remainingMs(ctx: CallContext): number; export declare function getQuote(ctx: CallContext, sku: string): Promise<Quote>;
Reintentar resuelve los fallos transitorios: un paquete perdido, una réplica que se reinicia, un pico breve. Brooker los llama egoístas: el cliente gasta más tiempo del servidor para mejorar sus propias probabilidades. Con fallos raros es un buen trato; en sobrecarga, empeora el problema. Tres condiciones antes de reintentar:
429
503
Retry-After
Reintentar al instante concentra la carga en el peor momento. El backoff exponencial separa los intentos (por ejemplo, 50 ms, 100 ms, 200 ms…) con un tope máximo. Pero si mil clientes fallan a la vez y todos esperan exactamente lo mismo, vuelven a llegar a la vez. El jitter añade aleatoriedad a la espera para desincronizarlos.
Brooker comparó variantes en una entrada del blog de arquitectura de AWS de marzo de 2015. El equal jitter (conservar media espera y aleatorizar la otra mitad) fue el peor de los aleatorizados; el full jitter (esperar un valor al azar entre cero y el tope exponencial) y el decorrelated jitter quedaron cerca, sin un ganador claro. Su conclusión es que el backoff con jitter debería ser el enfoque estándar para clientes remotos.
El peligro real aparece cuando varias capas reintentan. Si cada una de cinco capas hace hasta tres intentos, la base de datos del fondo puede recibir 3⁵ = 243 veces la carga original: es el ejemplo de Brooker. El libro de SRE muestra el mismo efecto con otros números. Las dos fuentes coinciden en el remedio: reintenta en un solo punto de la pila. Brooker sugiere hacerlo en una sola capa para operaciones baratas; el libro de SRE, en la capa inmediatamente superior a la que rechaza la petición.
Limitar intentos por petición no basta: con mucha concurrencia, tres intentos por petición siguen siendo el triple de carga. Un presupuesto de reintento limita los reintentos en proporción al tráfico:
La política entera cabe en una configuración por dependencia; esta es su forma, no valores recomendados:
# Forma orientativa de una política por dependencia pricing: connectTimeout: 100ms requestTimeout: 300ms # p99,9 observado más margen retry: maxAttempts: 3 # incluye el primer intento backoff: { base: 50ms, max: 1s, jitter: full } retryOn: [connect-failure, '503', '429'] budgetRatio: 0.1 # reintentos / peticiones en la ventana
Los reintentos insisten; el circuit breaker hace lo contrario: cuando una dependencia falla de forma sostenida, deja de llamarla durante un tiempo y devuelve un error inmediato. Martin Fowler lo describe en su bliki el 6 de marzo de 2014 y atribuye su popularidad a Michael Nygard y su libro Release It! (Pragmatic Bookshelf, primera edición de 2007 y segunda de 2018).
stateDiagram-v2 [*] --> Cerrado Cerrado --> Abierto: fallos superan el umbral Abierto --> SemiAbierto: vence el tiempo de espera SemiAbierto --> Cerrado: la llamada de prueba funciona SemiAbierto --> Abierto: la llamada de prueba falla
Lo que el artículo de Fowler deja como decisiones de diseño:
Un breaker por dependencia, o por instancia cuando el fallo afecta a una sola réplica, evita que una pieza enferma corte el tráfico hacia las sanas.
Brooker señala que los circuit breakers introducen un comportamiento modal (el sistema se porta distinto según el estado) que es difícil de probar y que puede alargar la recuperación, y prefiere el presupuesto con cubo de fichas. No son incompatibles, pero conviene saber qué problema resuelve cada uno: el presupuesto limita la amplificación; el breaker, además, libera al llamante de esperar.
El nombre viene de los mamparos de un barco: compartimentos estancos para que una vía de agua no inunde el casco entero. Es otro de los patrones de estabilidad que se atribuyen a Release It!. En software significa repartir los recursos escasos para que una dependencia lenta solo pueda agotar su parte: un pool de conexiones o de hilos por dependencia, un semáforo que limita las llamadas concurrentes a cada una o cuotas por cliente o por inquilino (ver multi-tenancy).
En el ejemplo inicial, un bulkhead de veinte llamadas concurrentes hacia recomendaciones habría dejado esas veinte bloqueadas y el resto del pool libre para pagar. Algunas herramientas usan otros nombres para lo mismo: lo que Envoy llama circuit breaking son en realidad límites por clúster de conexiones, peticiones pendientes, peticiones en curso y reintentos activos, más cercano a un bulkhead que al breaker de Fowler.
Los mecanismos anteriores protegen al llamante. Los dos siguientes protegen al servidor cuando le llega más trabajo del que puede hacer.
Backpressure es que el consumidor marque el ritmo al productor. La especificación Reactive Streams (1.0, abril de 2015) se definió como un estándar de flujos asíncronos con backpressure no bloqueante, y Java 9 incorporó sus interfaces como java.util.concurrent.Flow: el suscriptor pide un número de elementos y el productor no envía más. Cómo se aplica a colas y logs (prefetch, longitud máxima, lag) está en caché, colas y streaming.
java.util.concurrent.Flow
El deslastre de carga (load shedding) es rechazar a propósito parte del tráfico al acercarse a la saturación para seguir sirviendo bien el resto. El libro de SRE propone basarlo en CPU, memoria o longitud de cola, y menciona dos técnicas para colas: servir en orden LIFO o usar CoDel, porque las peticiones que llevan mucho esperando probablemente ya no interesan a nadie. También describe rechazar antes las peticiones de menor criticidad. La Builders' Library dedica un artículo entero al tema ("Using load shedding to avoid overload").
Rechazar bien también es diseño: responde 503 o 429 (RFC 6585, abril de 2012) con Retry-After para que el cliente sepa cuánto esperar, y hazlo pronto y barato, antes de gastar trabajo en la petición. El limitador de tasa por cliente, que comparte técnicas con el deslastre, se trata en escalabilidad y casos clásicos.
Entre funcionar del todo y fallar hay un término medio: hacer menos trabajo por petición. El libro de SRE pone ejemplos como buscar en un subconjunto de datos en caché o usar un algoritmo de ordenación más barato. En producto suele verse así: ocultar las recomendaciones, mostrar un catálogo genérico, servir el último valor conocido con su antigüedad visible o aceptar un pedido y confirmar el stock después.
Dos advertencias de las fuentes:
La regla práctica: un valor por defecto es aceptable cuando equivocarse es barato y visible (unas recomendaciones genéricas), y peligroso cuando el dato decide dinero o permisos (un precio o un permiso «por defecto»). En ese segundo caso, falla de forma explícita.
Ninguno de estos mecanismos está probado hasta que falla algo de verdad. El chaos engineering adelanta ese momento. Su origen está en Netflix: el equipo presentó Chaos Monkey en diciembre de 2010, en una entrada sobre lo aprendido al migrar a AWS, como un servicio que termina instancias al azar para obligar a diseñar servicios que las sobrevivan; lo publicó como código abierto en julio de 2012. El sitio Principles of Chaos Engineering lo define como la disciplina de experimentar sobre un sistema para ganar confianza en su capacidad de soportar condiciones turbulentas en producción; el artículo «Chaos Engineering» (Basiri y otros, IEEE Software, 2016) usa casi la misma definición, referida a sistemas distribuidos.
Los principios del sitio son cinco: formular una hipótesis sobre el estado estable, entendido como una salida medible del sistema (rendimiento, tasa de errores, percentiles de latencia) y no sus atributos internos; variar eventos del mundo real (un servidor que muere, respuestas malformadas, un pico de tráfico); experimentar en producción; automatizar los experimentos para que corran de forma continua; y minimizar el radio de impacto. En la práctica conviene empezar pequeño y con un botón para parar.
Antes de llegar a producción, el libro de SRE propone pruebas de carga hasta romper cada componente, con rampas graduales y picos bruscos, comprobar si el sistema vuelve solo a la normalidad y desconectar dependencias no críticas para verificar que no arrastran a las críticas. Ese último experimento habría detectado el problema de las recomendaciones antes del viernes.
La resiliencia se mide con el vocabulario de atributos de calidad: SLI, SLO y presupuesto de error, con percentiles y no medias. Ese artículo explica cómo fijarlos; aquí importa qué señales mirar para saber si los mecanismos funcionan:
Parte de esto puede vigilarse en CI como fitness function: por ejemplo, una regla que falle si un cliente HTTP se construye sin timeout explícito.
Estado a octubre de 2026, según sus repositorios y registros de paquetes:
Si usas una malla de servicios y además una biblioteca, decide en cuál de las dos capas viven los reintentos: si ambas reintentan, vuelves a la amplificación.
400
403
El escenario del principio, con números ilustrativos. La página de pago llama a cuatro dependencias y el borde concede un plazo total de 1,5 s:
El razonamiento, paso a paso:
Consultadas en octubre de 2026. El libro Release It! no se consultó directamente: sus datos vienen del artículo de Fowler, de Wikipedia y de reseñas.
Resiliencia en sistemas distribuidos