Conceptos Básicos de Resiliencia

8 ejemplos para empezar con la Resiliencia para backends de Node.js: 6 básicos y 2 intermedios.

Prerrequisitos

• Node.js 24.18.0 con fetch nativo y AbortSignal.timeout.
• Servicio HTTP detrás de Kubernetes, ECS o similar para sondas de salud/preparación.

Ejemplos Básicos

1. Tiempo de Espera para fetch Saliente

Las llamadas descendentes colgadas agotan tu pool de conexiones.

const response = await fetch("https://api.partner.com/data", {
  signal: AbortSignal.timeout(5_000),
});

• AbortSignal.timeout disponible en Node 18+ - sin setTimeout manual.
• Mapea TimeoutError a 504 o a una política de reintentos ascendente.
• Tiempos de espera más cortos en rutas orientadas al usuario que en trabajos por lotes.

Relacionado: Tiempos de espera en todas partes - matriz completa de tiempos de espera

2. Falla Rápido en la Configuración de Inicio

No sirvas tráfico con un entorno inválido.

import { z } from "zod";
 
const Env = z.object({
  DATABASE_URL: z.string().url(),
  PORT: z.coerce.number().default(3000),
});
 
export const env = Env.parse(process.env); // lanza un error antes de listen()

• El proceso sale con un código distinto de cero - el orquestador se reinicia con la configuración corregida.
• La preparación permanece en falso hasta que la migración de la base de datos se complete si dependes de eso.
• Es mejor un despliegue fallido que errores silenciosos en tiempo de ejecución en cada solicitud.

Relacionado: Conceptos Básicos de Configuración - análisis de entorno con Zod

3. Liveness vs Readiness

Dile a Kubernetes si debe reiniciar o dejar de enviar tráfico.

app.get("/health", (_req, res) => res.json({ ok: true }));
 
app.get("/ready", async (_req, res) => {
  try {
    await db.query("SELECT 1");
    res.json({ ready: true });
  } catch {
    res.status(503).json({ ready: false });
  }
});

• Liveness: el proceso no está bloqueado - verificación barata.
• Readiness: las dependencias están disponibles - falla cuando la base de datos está caída para que kube la elimine del balanceador de carga.
• No pongas verificaciones lentas en liveness - bucles de reinicio.

Relacionado: Conceptos Básicos de Observabilidad - patrones de sonda

4. Apagado Elegante en SIGTERM

Drena el tráfico HTTP en curso antes de salir en el despliegue.

const server = app.listen(3000);
 
process.on("SIGTERM", () => {
  server.close(() => {
    logger.info({ event: "shutdown_complete" });
    process.exit(0);
  });
  setTimeout(() => process.exit(1), 30_000).unref();
});

• server.close deja de aceptar nuevas conexiones; finaliza las activas.
• Forzar la salida después de 30 segundos si el drenaje se detiene - coincide con terminationGracePeriodSeconds de k8s.
• Cierra los pools de DB y el SDK de OTel en el mismo manejador de apagado.

Relacionado: Degradación Elegante - modos de desactivación de funciones

5. Reintentar Solo Cuando Sea Seguro

Un POST sin claves de idempotencia puede cobrar dos veces.

async function safeGetWithRetry(url: string, attempts = 3): Promise<Response> {
  for (let i = 0; i < attempts; i++) {
    try {
      const res = await fetch(url, { signal: AbortSignal.timeout(3_000) });
      if (res.status < 500) return res;
    } catch (err) {
      if (i === attempts - 1) throw err;
    }
    await delay(100 * 2 ** i);
  }
  throw new Error("unreachable");
}

• Reintentar GET y PUT idempotentes - seguros por semántica HTTP (con salvedades).
• Reintentar 5xx, no 4xx (los errores del cliente no se curarán).
• El backoff exponencial reduce el efecto de estampida.

Relacionado: Reintentos con Backoff - jitter e idempotencia

6. Devolver Errores Explícitos, No Bloqueos

Los usuarios y los balanceadores de carga necesitan una respuesta dentro del SLA.

app.use((req, res, next) => {
  const timer = setTimeout(() => {
    if (!res.headersSent) {
      res.status(504).json({ error: "Gateway Timeout" });
    }
  }, 30_000);
  res.on("finish", () => clearTimeout(timer));
  next();
});

• El tiempo de espera a nivel de servidor es el último recurso - prefiere los tiempos de espera por salida.
• Registra el 504 con requestId para correlación.
• Alinea con el tiempo de espera de inactividad del balanceador de carga (a menudo 60s).

Relacionado: Tiempos de espera en todas partes - tiempos de espera del servidor

Ejemplos Intermedios

7. Esquema de Disyuntor

Deja de llamar a una dependencia que falla para permitirle recuperarse.

let failures = 0;
const THRESHOLD = 5;
let openUntil = 0;
 
async function callBilling() {
  if (Date.now() < openUntil) throw new Error("Circuit open");
  try {
    const result = await billingClient.charge();
    failures = 0;
    return result;
  } catch (err) {
    failures++;
    if (failures >= THRESHOLD) openUntil = Date.now() + 30_000;
    throw err;
  }
}

• El circuito abierto falla rápidamente las solicitudes locales - ahorra hilos y carga descendente.
• Reintento semiabierto después del enfriamiento - en producción usa la biblioteca opossum.
• Combina con la degradación elegante para la experiencia del usuario.

Relacionado: Disyuntores - patrones de opossum

8. Bulkhead: Limitar Llamadas Salientes Concurrentes

Un proveedor lento no puede consumir todos los sockets.

import { Semaphore } from "async-mutex"; // o pool personalizado
 
const vendorSem = new Semaphore(10);
 
async function callVendor() {
  const [, release] = await vendorSem.acquire();
  try {
    return await fetch(VENDOR_URL, { signal: AbortSignal.timeout(2_000) });
  } finally {
    release();
  }
}

• Limita las llamadas concurrentes a una integración frágil - patrón bulkhead.
• Las solicitudes restantes fallan rápidamente localmente en lugar de hacer cola indefinidamente.
• Ajusta el límite según el SLA del proveedor y el tamaño de tu pool.

Relacionado: Disyuntores - bulkhead con opossum

Versiones de la pila: Esta página fue escrita para Node.js 24.18.0 (LTS activa), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 y NestJS 11.