# Caché en capas: navegador, CDN, Redis y base de datos

> Cada capa de caché resuelve un problema distinto y añade una forma nueva de servir datos viejos. El mapa completo.

- URL: https://urimarti.com/blog/cache-en-capas/
- Date: 2026-11-16
- Language: es
- Tags: cache, redis, cdn
- Author: Oriol Martí

"Ponle caché" es probablemente la respuesta más repetida a "esto va lento". Y suele funcionar. El problema es que "caché" no es una pieza: es una cadena de copias de los mismos datos, repartidas entre el navegador del usuario y el disco de la base de datos. Cada eslabón ahorra latencia y, a la vez, añade un sitio más donde puede vivir un dato viejo.

Este post es el mapa completo: qué capas hay, qué conviene guardar en cada una, cómo se invalidan y cuándo una de ellas sobra.

## El diagrama

```text
  Usuario
     │
     ▼
┌──────────────┐  Cache-Control, ETag
│  Navegador   │  privada, por usuario, no se puede invalidar desde fuera
└──────┬───────┘
       │ fallo
       ▼
┌──────────────┐  s-maxage, clave de caché, invalidaciones
│     CDN      │  compartida, cerca del usuario
└──────┬───────┘
       │ fallo
       ▼
┌──────────────┐
│  Aplicación  │──────▶ ┌──────────────┐  cache-aside, TTL, claves
│              │◀────── │    Redis     │  compartida entre instancias
└──────┬───────┘        └──────────────┘
       │ fallo
       ▼
┌──────────────┐  buffer pool, vistas materializadas
│ Base de datos│  la única fuente de verdad
└──────────────┘
```

Cuanto más arriba se resuelve una petición, más barata es. Una respuesta del navegador cuesta cero: ni siquiera sale a la red. Una de la CDN se sirve desde un nodo cercano sin tocar tu infraestructura. Una de Redis ahorra la consulta pero ya ha pasado por tu aplicación. Y la base de datos es el último recurso, la única que tiene la razón.

| Capa | Quién la comparte | Latencia típica | Cómo se invalida |
| --- | --- | --- | --- |
| **Navegador** | Un solo usuario | 0 (sin red) | No se puede: solo caduca o cambia la URL |
| **CDN** | Todos los usuarios de una región | Decenas de ms | TTL o invalidación por ruta |
| **Redis** | Todas las instancias de la aplicación | ~1 ms dentro de la red | TTL o borrado de la clave |
| **Base de datos** | Todo el sistema | Desde ms hasta segundos | No hace falta: es la verdad |

## Qué guardar en cada capa

### Navegador: lo que no cambia, o lo que se puede comprobar barato

El navegador es la caché más rápida y la más peligrosa, porque **no hay forma de invalidarla desde el servidor**. Lo que guardaste allí con un `max-age` de un día se queda un día, salvo que el usuario lo fuerce.

Por eso la regla es sencilla:

- **Assets con hash en el nombre** (`app.3f9a1c.js`, `logo.8b2e.svg`): `Cache-Control: max-age=31536000, immutable`. Si el contenido cambia, cambia el nombre, y la URL vieja deja de pedirse. Nunca hay que invalidarlos.
- **HTML y respuestas de API**: `max-age` muy corto o `0`, con `ETag` o `Last-Modified`. El navegador pregunta "¿ha cambiado?" y, si no, recibe un `304` sin cuerpo. Sigue habiendo ida y vuelta, pero casi no hay transferencia.
- **Respuestas con datos del usuario**: `private` (solo el navegador puede guardarla, nunca una caché compartida) o `no-store` si es sensible.

Es lo que hace [esta misma web](/blog/web-estatica-astro-s3-cloudfront/): los assets de `/_astro/` son inmutables para siempre y el HTML se revalida en cada visita.

### CDN: lo que es igual para muchos usuarios

La CDN es una caché compartida. Su valor está en que la misma respuesta sirva a miles de personas, así que lo que tiene sentido guardar es lo que no depende de quién lo pide: páginas públicas, imágenes, catálogos, respuestas de API públicas.

Dos detalles marcan la diferencia:

- **`s-maxage` separado de `max-age`.** Permite que la CDN guarde una página una hora mientras el navegador la revalida siempre. Así, cuando invalidas la CDN, el cambio llega a todos enseguida.
- **La clave de caché.** Por defecto, cualquier cabecera, cookie o parámetro que entre en la clave multiplica las variantes y hunde la tasa de aciertos. Y lo contrario es peor: si una respuesta personalizada acaba en la CDN con una clave que no distingue usuarios, el siguiente visitante ve los datos del anterior. Es uno de los incidentes de caché más graves que hay, y casi siempre empieza con una cabecera `Cache-Control` que nadie revisó.

`stale-while-revalidate` y `stale-if-error` merecen mención aparte: permiten servir la copia vieja mientras se pide una nueva, o mientras el origen está caído. Convierten la CDN en una capa de resiliencia, no solo de velocidad.

### Redis: lo que es caro de calcular y se pide a menudo

Redis vive dentro de tu red y lo comparten todas las instancias de la aplicación. Es el sitio para lo que cuesta obtener y se repite mucho: resultados de consultas pesadas, respuestas de otros servicios, sesiones, contadores, agregados.

El patrón habitual es **cache-aside**: la aplicación mira en Redis; si no está, lo busca en la base de datos, lo guarda con un TTL y lo devuelve.

```text
leer(clave):
  valor = redis.get(clave)
  si valor existe: devolver valor
  valor = base_de_datos.consultar(...)
  redis.set(clave, valor, TTL + jitter)
  devolver valor
```

Lo que separa una caché de Redis que ayuda de una que da problemas:

- **TTL con jitter.** Si mil claves se escriben a la vez con el mismo TTL, caducan a la vez y todas vuelven contra la base de datos en el mismo segundo. Un margen aleatorio reparte la caducidad.
- **Protección contra estampidas.** Cuando caduca una clave muy pedida, cien peticiones simultáneas la recalculan a la vez. Un bloqueo corto (solo una la recalcula y el resto espera o sirve la copia vieja) evita que la base de datos reciba cien veces la misma consulta cara.
- **Caché negativa.** Guardar también el "no existe" durante un tiempo corto. Si no, cada petición a un recurso inexistente atraviesa todas las capas hasta la base de datos.
- **Memoria acotada y política de expulsión.** Redis sin límite de memoria acaba siendo un problema de operaciones. Con `maxmemory` y `allkeys-lru`, lo que menos se usa se va solo.

Y una regla que no se negocia: **Redis no es la fuente de verdad**. Si mañana se vacía, la aplicación tiene que seguir funcionando, más lenta, pero correcta.

### Base de datos: la caché que ya tienes

Antes de añadir capas por encima, conviene recordar que la base de datos ya cachea. MongoDB (con WiredTiger), PostgreSQL y MySQL guardan en memoria las páginas que más se leen. Si el conjunto de datos que se consulta a diario cabe en esa memoria, la mayoría de lecturas no tocan el disco.

La antigua "caché de consultas" que guardaba resultados por texto de la consulta ha desaparecido casi en todas partes (MySQL la eliminó en la versión 8.0) porque se invalidaba con cada escritura y escalaba mal. Lo que sí funciona en esta capa:

- **Índices alineados con las consultas reales.** Un índice bueno hace más por la latencia que cualquier caché.
- **Memoria suficiente para el conjunto de trabajo.** A veces la mejor caché es una instancia con más RAM.
- **Vistas materializadas o tablas precalculadas** para agregados caros que se leen mucho y cambian poco. Es una caché, pero con las reglas de la base de datos.

## Invalidación: el problema de verdad

Guardar cosas es fácil. Lo difícil es saber cuándo dejan de ser ciertas.

### Los TTL se suman

Este es el detalle que más se olvida. Imagina un precio que pasa por tres capas:

```text
Redis:      TTL 10 min      ─┐
CDN:        s-maxage 5 min  ─┼─▶ peor caso: 10 + 5 + 1 = 16 min de precio viejo
Navegador:  max-age 1 min   ─┘
```

La CDN puede pedir la página justo cuando Redis tiene un valor de casi diez minutos, guardarla cinco más, y el navegador quedársela uno más. **El dato más viejo que puede ver un usuario es la suma de los TTL de todas las capas por las que pasa**, no el de la capa que estás mirando. Cuando alguien de negocio pregunta "¿cuánto tarda en verse un cambio?", la respuesta está en esa suma.

### Tres formas de invalidar

| Estrategia | Cómo funciona | Cuándo usarla |
| --- | --- | --- |
| **Caducidad (TTL)** | El dato muere solo pasado un tiempo | Cuando un retraso acotado es aceptable. Es la opción por defecto. |
| **Invalidación explícita** | Al escribir, se borra la clave en Redis o se invalida la ruta en la CDN | Cuando el cambio tiene que verse ya. Exige saber qué claves dependen de cada dato. |
| **Versionado** | El dato nuevo vive en una clave o URL nueva; la vieja deja de usarse | Assets, configuraciones, cualquier cosa con un número de versión. Es la única que funciona en el navegador. |

La invalidación explícita parece la mejor, pero tiene un coste escondido: cada escritura tiene que conocer todas las cachés que dependen de ese dato. Con el tiempo aparecen dependencias que nadie recuerda, y un cambio que "debería verse" no se ve. Por eso suelo combinarla con un TTL de seguridad: si una invalidación se pierde, el dato viejo al menos tiene fecha de caducidad.

### El orden importa

Cuando hay que invalidar varias capas, se hace **de dentro hacia fuera**: primero se escribe en la base de datos, luego se borra en Redis y por último se invalida la CDN. Si se hace al revés, la CDN puede volver a pedir el dato antes de que Redis se haya limpiado y quedarse otra vez con la versión vieja, ahora con un TTL nuevo.

Y aun en el orden correcto, entre leer de la base de datos y escribir en Redis puede colarse otra escritura. Por eso, en cache-aside, al escribir es más seguro **borrar la clave que actualizarla**: la siguiente lectura la recalculará con el dato bueno.

## Cuándo una capa sobra

Cada capa añade latencia ahorrada, pero también configuración, memoria, monitorización y otra forma de servir datos viejos. Algunas señales de que una sobra:

- **La tasa de aciertos es baja.** Una caché que acierta un 20% de las veces añade un salto de red al 80% de las peticiones a cambio de poco. Si no se mide la tasa de aciertos, no se sabe si la capa ayuda.
- **Los datos son personales y cambian a menudo.** Un carrito, un saldo o una bandeja de entrada no se comparten entre usuarios y cambian con cada acción. Ahí la CDN no aporta y Redis aporta poco.
- **La base de datos ya responde rápido.** Si la consulta tarda 2 ms con un buen índice, meter Redis delante ahorra casi nada y añade un sistema más que puede fallar.
- **El dato necesita consistencia fuerte.** El stock en el momento de pagar, los permisos o un saldo no se leen de una caché. Se pueden cachear para mostrar, pero la decisión se toma contra la fuente de verdad.
- **El problema real es otro.** A veces la caché tapa una consulta sin índice o una llamada síncrona que no debería estar en el camino crítico. En esos casos, [cambiar quién tiene los datos](/blog/readstore-frente-a-llamadas-sincronas/) resuelve más que cachearlos.

## Lo que me llevo

**Cada capa responde a una pregunta distinta.** El navegador evita la red, la CDN evita tu infraestructura, Redis evita el trabajo caro y la base de datos guarda la verdad. Si no sabes qué pregunta responde una capa, probablemente sobra.

**Lo inmutable no se invalida, se renombra.** Todo lo que se pueda versionar (assets, configuraciones, exportaciones) debería versionarse. Es la única invalidación que nunca falla.

**El retraso máximo es una suma.** Antes de prometer "los cambios se ven al momento", suma los TTL de todas las capas.

**La caché es una optimización, no una dependencia.** Si apagar Redis o la CDN rompe la aplicación en lugar de hacerla más lenta, la caché se ha convertido en una fuente de verdad sin las garantías de una.

La caché bien hecha es invisible: todo va rápido y nadie se pregunta por qué. La caché mal hecha también es invisible, hasta el día en que alguien ve un precio que ya no existe o los datos de otro usuario.

## Prompt

```text
Actúa como arquitecto backend senior: revisa la estrategia de caché de mi aplicación capa por capa y propón cambios concretos.

Capas a revisar, de fuera hacia dentro:
- Navegador: cabeceras Cache-Control por tipo de recurso. Assets con nombre con hash: max-age=31536000, immutable. HTML y APIs: max-age corto o 0 con ETag/Last-Modified para responder 304. Respuestas personales: private o no-store.
- CDN: s-maxage separado del max-age, clave de caché mínima (qué cabeceras, cookies y query params entran), Vary correcto, stale-while-revalidate y stale-if-error donde tenga sentido. Nunca cachear respuestas con datos de un usuario en una caché compartida.
- Caché de aplicación (Redis): patrón cache-aside, claves con versión, TTL con jitter, protección contra estampidas (un solo proceso recalcula), caché negativa para lo que no existe y política de expulsión (p. ej. allkeys-lru) con memoria acotada. Redis nunca es la fuente de verdad: si se vacía, la aplicación sigue funcionando, solo más lenta.
- Base de datos: que el conjunto de trabajo quepa en memoria (buffer pool), índices alineados con las consultas reales y vistas materializadas o tablas precalculadas para lo caro que se lee mucho.

Para cada dato cacheado, dime:
- En qué capa vive y por qué ahí.
- Cuánto puede llegar a estar desactualizado en el peor caso (la suma de los TTL de todas las capas por las que pasa).
- Cómo se invalida: TTL, invalidación explícita al escribir o URL versionada.

No hagas:
- Añadir una capa sin medir antes la tasa de aciertos y la latencia que ahorra.
- Cachear datos que necesitan consistencia fuerte (saldos, stock en el checkout, permisos) sin un plan explícito.

Verifica: tasa de aciertos por capa, qué pasa con la base de datos si Redis se vacía de golpe, y que un cambio de contenido se ve en el plazo que el negocio espera.

Antes de empezar, pregúntame lo que no puedas deducir (stack, CDN, qué datos toleran retraso) y explica cada decisión.
```
