# Construyendo Sistemas Resilientes con Next.js > Mejores prácticas para garantizar alta disponibilidad y rendimiento en aplicaciones web modernas. > > 2024-08-22 — y7.hk ## Arquitectura Primero Next.js suele ser la columna vertebral de las aplicaciones web modernas. Garantizar la resiliencia requiere una mezcla de buenas decisiones arquitectónicas y herramientas adecuadas. Aprovechando Server Components y error boundaries bien implementados, puedes construir aplicaciones web extremadamente resilientes que degradan con elegancia en lugar de colapsar por completo. ### Static Generation vs SSR Siempre que sea posible, usa Incremental Static Regeneration (ISR) por defecto. Esto garantiza que, aunque tus APIs backend estén temporalmente caídas, los usuarios seguirán viendo la última versión compilada con éxito. Pero el tradeoff es real: ISR te da resiliencia a costa de frescura. SSR te da frescura a costa de una dependencia dura del backend. ```tsx // app/blog/[slug]/page.tsx export const revalidate = 300; // 5 minutos export default async function Post({ params }) { const post = await fetchPost(params.slug); // cacheado + revalidado return
; } ``` Cuando mi API de origen cayó 40 minutos durante un incidente de Cloudflare el año pasado, todas las páginas ISR de y7.hk siguieron sirviendo HTML viejo-pero-válido. Las páginas SSR del mismo sitio devolvieron 500. Ese experimento me costó un 4% del tráfico mensual — y cambió para siempre cómo pienso en la estrategia de renderizado. **Regla general:** ISR para todo lo que pueda tener 5–60 minutos de antigüedad (posts de blog, páginas de producto, marketing). SSR solo cuando los datos viejos rompen el producto (dashboards en vivo, estado de auth, datos en tiempo real). ### Los Error Boundaries son Mamparos Sin boundaries, un solo widget que falla tira toda la página. Con boundaries, cada sección falla independientemente. ```tsx // app/components/Section.tsx 'use client'; import { Component, ReactNode } from 'react'; export class Section extends Component< { children: ReactNode; fallback?: ReactNode }, { hasError: boolean } > { state = { hasError: false }; static getDerivedStateFromError() { return { hasError: true }; } render() { if (this.state.hasError) { return this.props.fallback ??
Sección no disponible
; } return this.props.children; } } ``` Envuelve cada unidad independiente — widgets del sidebar, secciones de comentarios, dashboards de analítica — en su propio boundary. El usuario ve una caja gris donde estaba el widget, no una pantalla en blanco. Aprendí esto por las malas en un dashboard Web3 donde un solo timeout de RPC tumbó toda la vista del portfolio. Un boundary alrededor del ticker de precios habría salvado la sesión. ### Los Reintentos Necesitan Backoff Los reintentos ciegos amplifican los fallos. El backoff exponencial con jitter distribuye la carga y le da al upstream espacio para recuperarse. ```ts async function fetchWithRetry( fn: () => Promise, attempts = 3, baseDelay = 300 ): Promise { for (let i = 0; i < attempts; i++) { try { return await fn(); } catch (err) { if (i === attempts - 1) throw err; const jitter = Math.random() * baseDelay; await new Promise(r => setTimeout(r, baseDelay * 2 ** i + jitter)); } } throw new Error('unreachable'); } ``` Dos reglas que sigo: 1. **Nunca reintentar 4xx.** Un 404 no se convierte en 200 con un retry. 2. **Limitar la espera total.** Si el usuario lleva 8+ segundos mirando un spinner, muestra el fallback UI y déjalo continuar. ### Los Circuit Breakers Cortan Fallos en Cascada Los reintentos resuelven errores transitorios. Los circuit breakers resuelven errores persistentes. Si tu backend lleva 30 segundos fallando, deja de golpearlo — abre el circuito y sirve respuestas degradadas inmediatamente. ```ts class Breaker { private failures = 0; private openUntil = 0; constructor(private threshold = 5, private cooldown = 30_000) {} async call(fn: () => Promise): Promise { if (Date.now() < this.openUntil) throw new Error('Circuit open'); try { const result = await fn(); this.failures = 0; return result; } catch (e) { if (++this.failures >= this.threshold) { this.openUntil = Date.now() + this.cooldown; } throw e; } } } ``` Sin un breaker, un upstream lento se convierte en una flota de procesos Node colgados. Con uno, obtienes fallos rápidos y un sistema que se recupera en cuanto el upstream vuelve. ### Edge Caching con stale-while-revalidate El header `Cache-Control` es la capa de resiliencia más barata que tienes. `stale-while-revalidate` permite al edge servir la última copia en caché mientras obtiene una fresca en background. ``` Cache-Control: public, s-maxage=60, stale-while-revalidate=600 ``` Esta es la diferencia entre "la API está caída, el sitio está caído" y "la API está caída, algunos usuarios ven datos de hasta 10 minutos de antigüedad". ### Fallback UI como Feature Los fallbacks no son lo que muestras cuando algo se rompe — son parte del diseño. Toda sección asíncrona tiene tres estados: - **Loading:** skeleton que coincide con el layout final (sin layout shift). - **Success:** el contenido real. - **Error:** una versión degradada que aún permite al usuario trabajar. Si tu widget de precios falla, no muestres un error rojo — muestra los últimos precios cacheados con un badge pequeño de "actualizado hace 12 min". Si el sistema de comentarios falla, muestra el hilo de solo lectura y oculta el input. ### Tolerancia Offline Los Service Workers no son solo para PWAs. Un SW mínimo que cachea el app shell y las últimas 5 páginas visitadas te da tolerancia offline real en wifi de hotel inestable y a 10.000 metros de altura — lo cual, si eres yo, es un porcentaje no trivial de tu navegación. ```ts // sw.ts — cache-first para estáticos, network-first para páginas self.addEventListener('fetch', (e) => { const url = new URL(e.request.url); if (url.pathname.startsWith('/_next/static/')) { e.respondWith(caches.match(e.request).then(r => r ?? fetch(e.request))); } }); ``` ### Fallos Reales que He Sufrido - **Caída de Cloudflare edge KV:** toda página que dependía de KV devolvió 500. Las páginas ISR sobrevivieron. - **El CMS upstream me rate-limiteó durante un pico de tráfico.** No tenía breaker; Next.js siguió golpeando el CMS hasta que recibí un IP ban duro. Ahora toda llamada externa pasa por un breaker con cooldown de 30s. - **Un solo `` tumbó todo el dashboard** cuando el WebSocket se cayó. Después de añadir un boundary, el resto de la UI siguió viva mientras el ticker se reconectaba en silencio. ## Checklist de Resiliencia - [ ] ISR/SSG para contenido que tolera 5+ minutos de antigüedad - [ ] `stale-while-revalidate` en toda ruta cacheable - [ ] Error boundary alrededor de todo widget independiente - [ ] Backoff exponencial + jitter en retries; nunca reintentar 4xx - [ ] Circuit breaker en toda llamada a servicio externo - [ ] Skeleton + fallback + estado de error para toda UI async - [ ] Service worker cacheando el app shell - [ ] Kill-switch documentado para features no críticos (analítica, recomendaciones) ## El Punto La resiliencia no es una feature que se atornilla al final. Es la arquitectura misma. Cada capa — renderizado, caché, fetching, UI — tiene su modo de fallo diseñado desde el inicio. Constrúyelos temprano, y los incidentes que habrían sido outages se convierten en degradaciones silenciosas que nadie nota.