Sharding
- Lección 13 de 40
- 11 min
- Intermedio
- 9 pasos
Llega un punto en que ni la máquina más grande aguanta tus datos ni tus escrituras. La salida es partirlos en trozos y repartirlos. Elegir cómo partirlos es lo difícil.
- Shards
- 4
- Escrituras en el más cargado
- 10.000 pet/s
- Peso del más cargado
- 25%
- Datos por shard
- 5 TB
- petición
- respuesta
- petición lenta
- esperando en cola
- lote
Paso 1 de 9
Problema
Una sola máquina ya no alcanza
La base de datos de usuarios ocupa 20 TB y recibe 40.000 escrituras por segundo. Las réplicas de lectura alivian las consultas, pero cada escritura sigue pasando por un único líder, y todos los datos tienen que caber en sus discos.
Ya compraste la máquina más grande que había y va al 98 %. Además, cualquier copia de seguridad, restauración o réplica nueva tarda casi un día en copiar 20 TB. Las cifras de esta lección son un escenario de ejemplo.
Paso 2 de 9
Solución
Dividir los datos: sharding
El sharding parte una base de datos grande en varias más pequeñas, los shards. Cada una guarda una parte de las filas y recibe solo las escrituras de esa parte.
La clave de shard decide dónde vive cada fila. Aquí usamos rangos de user_id: del 1 al 25 millones en A, del 25 al 50 en B, y así. La app (o un router delante) mira el rango y manda cada consulta al shard que toca.
En este ejemplo cada shard es una máquina más modesta que aguanta unas 20.000 escrituras/s: con 10.000 va al 50 %.
Qué cambió
- 4 shards de 5 TB
- Clave de shard: rangos de user_id
- Escrituras por shard: 40.000 → 10.000/s
Paso 3 de 9
Problema
Los rangos crean puntos calientes
Los user_id crecen con el tiempo, así que cada alta nueva cae en el último rango. Y los usuarios recién llegados son los que más escriben: el shard D se lleva el 78 % de las escrituras (31.200/s) mientras A apenas recibe el 6 %.
D no da abasto y las escrituras hacen cola. Pasa lo mismo con cualquier clave que llegue en orden: fechas, números de pedido, nombres por orden alfabético.
Algunas bases de datos particionadas por rangos parten en dos un rango muy cargado de forma automática, pero si todas las escrituras van al final, el problema simplemente se muda al último trozo.
Qué cambió
- Shard D: 78 % de las escrituras
- Shard A: 6 %
- Cola de escrituras en D
Paso 4 de 9
Solución
Pasar la clave por un hash
En lugar de rangos, calcula un hash de la clave y quédate con el resto de dividir entre el número de shards: shard = hash(user_id) % 4.
Ids consecutivos dan hashes que no se parecen, así que los usuarios nuevos y su tráfico se reparten por igual: cada shard vuelve a 10.000 escrituras/s.
Qué cambió
- Clave de shard: hash(user_id) % 4
- Shard más cargado: 78 % → 25 %
Paso 5 de 9
Problema
Caso: la celebridad
El hash reparte las claves, no el tráfico. Una cantante con decenas de millones de seguidores es el usuario 42 y vive en el shard C como cualquiera. Pero cada «me gusta» a sus publicaciones escribe en su fila.
Solo ella genera 24.000 escrituras/s. Con las 4.000 normales de C, ese shard recibe 28.000/s (el 70 %) y no da abasto, mientras A, B y D van al 20 %. A esto se le llama clave caliente o problema de la celebridad.
Qué cambió
- Usuario 42: 24.000 escrituras/s
- Shard C: 70 % de las escrituras
Paso 6 de 9
Solución
Cachearla o partirla
Si la clave está caliente por lecturas (todo el mundo abre su perfil), pon una caché delante del shard: la mayoría de las visitas nunca llegan a la base de datos.
Si está caliente por escrituras, como su contador de «me gusta», pártela: cada «me gusta» suma 1 a likes:42#n con n al azar entre 0 y 7. Esas 8 subclaves caen en shards distintos (aquí, dos por shard) y para leer el total se suman las 8.
Las 24.000 escrituras/s se reparten en 6.000 por shard; con las 4.000 normales, cada shard vuelve a unas 10.000/s.
Qué cambió
- Lecturas calientes servidas desde caché
- likes:42 partido en 8 subclaves
- Shard más cargado: 70 % → 25 %
Paso 7 de 9
Compromiso
Consultas que recorren todos los shards
Buscar un usuario es rápido: hash del id y una pregunta a un solo shard. Pero «los 10 usuarios con más seguidores» no va por user_id: la app tiene que preguntar a los 4 shards y juntar las respuestas.
Estas consultas de dispersión y recolección (scatter-gather) tardan lo que tarde el shard más lento, y los joins entre shards son difíciles de hacer bien.
Qué cambió
- Una consulta → los 4 shards
- La respuesta espera al más lento
Paso 8 de 9
Problema
Añadir un shard lo mueve casi todo
Los shards se llenan y añades un quinto. Pero hash % 4 pasa a ser hash % 5, y para cerca del 80 % de los usuarios el resto cambia: su fila tiene que mudarse a otro shard.
Solo se queda donde estaba la clave cuyo resto es igual dividiendo entre 4 y entre 5: 4 de cada 20 valores. Hay que mover unos 16 TB entre shards mientras el sistema sigue atendiendo. Al terminar, cada shard queda con 4 TB y 8.000 escrituras/s.
Qué cambió
- Shard E
- hash % 4 → hash % 5
- ≈ 80 % de las filas cambian de shard
Paso 9 de 9
Resumen
Resumen
El sharding reparte datos y escrituras entre varias máquinas.
La clave de shard decide dónde vive cada fila y tiene que repartir la carga por igual.
Los rangos crean puntos calientes; el hash reparte la carga pero dispersa las consultas por rango.
Una sola clave caliente se cachea (lecturas) o se parte en subclaves (escrituras).
Las consultas que no usan la clave de shard tocan todos los shards; cambiar N en hash % N mueve casi todos los datos.
← → paso · R repetir · Espacio pausa
Aprenderás
- Por qué las réplicas no reparten las escrituras (visto)
- Claves de shard: por rangos o por hash (visto)
- Claves calientes: el problema de la celebridad (visto)
- Lo que cuesta una consulta que cruza shards (visto)
- Por qué añadir un shard duele (visto)