Una caché con una tasa de aciertos (hit rate) del 99% suele presentarse como un éxito. Pero también es una afirmación sobre la base de datos que tiene detrás: esa base de datos solo ve el 1% de tu tráfico, y normalmente está dimensionada para lo que ve. Nadie lo dejó escrito, y es el número que más peso soporta en todo el diseño.
La aritmética
Imagina 10.000 solicitudes por segundo y una tasa de aciertos del 99%. El origen, la base de datos que hay detrás de la caché, ve 100 solicitudes por segundo. Ahí está cómodo: mucho margen, latencia baja, nada que despierte a nadie de madrugada.
Ahora la caché deja de ayudar: se reinicia vacía, o las entradas que usa este tráfico caducan a la vez, y todos los fallos de caché (cache miss) caen sobre el origen. La tasa de aciertos se va a cero y el origen ve 10.000 solicitudes por segundo. Es un salto de 100×, que llega de golpe, contra una base de datos aprovisionada para la cifra pequeña.
Lo que sigue no es una degradación suave. El origen se satura, la latencia sube, los clientes agotan el tiempo de espera y reintentan, y los reintentos añaden carga a un sistema que ya superó su capacidad. La caché vacía es el detonante; el bucle de reintentos es lo que lo mantiene caído cuando el detonante ya desapareció.
Por qué ocurre todo a la vez
El modo de fallo que más sorprende es el sincronizado. Si una flota de servidores calienta su caché en el mismo momento (un despliegue, un reinicio, una actualización programada), las entradas se escriben con pocos instantes de diferencia y con el mismo TTL, y caducan también con pocos instantes de diferencia. El diseño lleva dentro un despertador invisible, y suena para todas las réplicas a la vez.
- Un despliegue va reiniciando la flota y cada instancia arranca con su caché local vacía.
- El reinicio de un nodo de caché pierde de golpe su parte del espacio de claves.
- Un TTL uniforme escrito al mismo tiempo caduca al mismo tiempo.
- Una hot key (una sola entrada que atiende gran parte del tráfico) convierte una única caducidad en un fallo de caché en toda la flota.
Las tres respuestas habituales
- Single-flight (coalescencia de solicitudes): ante un fallo de caché, un solo cliente por clave recalcula y los demás esperan ese resultado en lugar de ir cada uno al origen. Es la que acota directamente la carga del origen: a una sola consulta en curso por clave, o por clave y por instancia cuando la coalescencia es local.
- Jitter en el TTL: repartir la caducidad en una ventana en lugar de un único instante, de modo que los fallos de caché de la flota lleguen escalonados y no juntos.
- Stale-while-revalidate: servir el valor caducado mientras un cliente lo refresca en segundo plano. Quien consulta ve datos algo viejos en lugar de una cola.
Se combinan, y resuelven partes distintas del problema. El jitter reparte los fallos de caché en el tiempo; el single-flight acota lo que una ráfaga de fallos puede hacerle al origen. Un diseño que solo tiene jitter sigue teniendo una hot key capaz de tumbar el origen por sí sola.
Verlo antes de que ocurra
Cuesta razonar sobre esto en una pizarra porque el número interesante, lo que recibe el origen, es el producto de otros dos que viven en cajas distintas: el tráfico que llega a la caché y su tasa de fallos. Cambia la tasa de aciertos y la carga de un componente tres saltos más allá se mueve en dos órdenes de magnitud.
En un lienzo de RodGrid los componentes tienen tipo, así que el simulador sabe qué caja es una caché y cuál está detrás de ella. El preset de estrés Estampida de caché pone el factor de aciertos de la caché a cero y vuelve a ejecutar el modelo, con lo que la nueva tasa de llegada al origen pasa a ser un número en el diagrama en lugar de un argumento en una reunión.