IDs únicos a escala
- Lección 15 de 40
- 13 min
- Intermedio
- 12 pasos
Con una sola base de datos, un contador basta. Cuando escriben muchas máquinas a la vez, elegir el id deja de ser un detalle.
- IDs repetidos
- 0
- Bits por ID
- 64
- Llamadas por 1000 altas
- 0
- petición
- respuesta
Paso 1 de 12
Concepto
Cada fila necesita su nombre
Un pedido, un usuario, un pago: cada fila lleva un identificador que no puede repetirse jamás. Otras tablas lo guardan para apuntar a ella, aparece en las URL y alguien de soporte lo dicta por teléfono.
Con una única base de datos, esto sale gratis: una columna autoincremental (AUTO_INCREMENT, SERIAL o IDENTITY) entrega 3810, 3811, 3812… y la propia base de datos se asegura de no repetir ninguno.
Paso 2 de 12
Problema
Dos shards, dos contadores
La tabla de pedidos crece y la reparten en dos shards. Cada shard es una base de datos independiente con su propio contador, y los dos acaban de entregar el 3812.
Ahora dos pedidos distintos comparten id. Un enlace a /pedidos/3812, una entrada de caché o un reembolso pueden referirse a cualquiera de los dos. Y si algún día juntas o vuelves a repartir los shards, las filas chocan.
Qué cambió
- Shard B, con su propio contador
- El pedido 3812 existe dos veces
Paso 3 de 12
Solución
Opción 1: un contador compartido
Saca el contador de los shards y llévalo a un servicio pequeño que solo hace una cosa: dar el siguiente número. Es un servidor de tickets. Antes de cada alta, el servidor de apps le pide un id.
Vuelven los ids únicos y siguen ordenados por fecha. A cambio, cada alta suma un viaje de red más, y si el servidor de tickets cae, nadie puede crear nada.
Qué cambió
- Servidor de tickets
- Cada alta pide antes su id
- Un nuevo punto único de fallo
Paso 4 de 12
Técnica
Reparte bloques, no números sueltos
Pide menos veces. Cada servidor de apps reserva de golpe un bloque, por ejemplo de 1000 ids, y los va entregando desde su memoria. Es un viaje de red por cada 1000 altas, y si el servidor de tickets cae, cada servidor aguanta hasta agotar su bloque.
El precio: los ids ya no siguen el orden de creación entre servidores (el 5003 del servidor 2 puede ser anterior al 4700 del servidor 1), y si un servidor se reinicia, los números que no usó de su bloque se pierden.
Qué cambió
- Cada servidor reserva 1000 ids por llamada
- 1 llamada por cada 1000 altas
- Orden estricto por fecha entre servidores
Paso 5 de 12
Solución
Opción 2: un número que nadie más elegirá
O deja de coordinar. Un UUID versión 4 tiene 128 bits, de los que 122 son aleatorios. Lo puede generar cualquier servidor, móvil o script sin preguntar a nadie.
¿Pueden salir dos iguales? En teoría sí. En la práctica, para tener un 50 % de probabilidad de una sola repetición habría que generar mil millones por segundo durante unos 86 años.
Qué cambió
- Servidor de tickets
- Cada servidor genera ids aleatorios de 128 bits
- Cero coordinación
Paso 6 de 12
Problema
Ids aleatorios dentro del índice
Dentro de cada shard, la clave primaria vive en un árbol B ordenado por id. Con un contador, cada fila nueva cae en la última página, que siempre está en memoria. Con un id aleatorio, cae en una página cualquiera.
Cuando el índice ya no cabe en memoria, muchas altas tienen que leer antes una página del disco, y las páginas se van partiendo por todo el árbol. Las inserciones pueden volverse varias veces más lentas y el índice se llena de páginas a medio llenar.
Qué cambió
- Dentro de un shard: el índice de la clave primaria
- Las altas se reparten por todas las páginas
Paso 7 de 12
Solución
Pon la hora delante
Conserva el azar, pero empieza por la hora. Un UUID versión 7 dedica sus primeros 48 bits a los milisegundos desde 1970 y rellena casi todo el resto con bits aleatorios.
Los ids nuevos son mayores que los viejos, así que las altas vuelven al final del índice. Siguen sin necesitar coordinación, y ordenar por id vuelve a ser ordenar por fecha de creación.
Qué cambió
- UUID v4 → UUID v7
- Las altas vuelven a la última página
Paso 8 de 12
Solución
Opción 3: tiempo, máquina y secuencia en 64 bits
Si necesitas ids de 64 bits, ordenados por tiempo y generados a gran ritmo sin contador central, mete tres campos en un solo número: es la idea de los IDs tipo Snowflake.
Una marca de tiempo en milisegundos, el id de la máquina que lo genera y una secuencia que cuenta dentro de cada milisegundo. Dos máquinas nunca chocan porque su id de máquina es distinto; una máquina nunca se repite gracias a la secuencia.
Qué cambió
- UUID → ids de 64 bits tipo Snowflake
- Cada servidor recibe un id de máquina al arrancar
Paso 9 de 12
Problema
El reloj da un paso atrás
Estos ids solo son únicos si el reloj de una máquina no repite un milisegundo. Pero los relojes se corrigen: la sincronización de hora detecta que el servidor 1 va 1,5 s adelantado y lo atrasa. Durante 1,5 s emitiría ids con tiempos que ya usó, es decir, duplicados.
La defensa es sencilla: el generador recuerda la última marca de tiempo que emitió. Si el reloj marca una hora anterior, espera (o rechaza pedir ids) hasta que el tiempo la supere.
Qué cambió
- El reloj del servidor 1 retrocede 1,5 s
- El generador espera a superar su última marca
- Sin duplicados: ese servidor pausa sus altas 1,5 s
Paso 10 de 12
Compromiso
Lo que un id cuenta de ti
Los ids acaban en las URL, y la gente los lee. Un competidor hace un pedido el lunes (/pedidos/20410) y otro el martes (/pedidos/20722): ya sabe que recibes unos 312 pedidos al día.
Los ids secuenciales también se recorren fácil: cambia /facturas/20410 por /facturas/20411 y mira qué responde. Y los ids con hora delatan el momento exacto en que se creó cada cosa.
Qué cambió
- Un competidor que lee los ids de las URL
- Ids públicos aleatorios; las claves internas siguen ordenadas
Paso 11 de 12
Compromiso
Qué id para qué trabajo
¿Una sola base de datos? Usa su contador. ¿Muchos escritores sin nada compartido? UUID v7. ¿Ids numéricos compactos a muy alto ritmo? Tipo Snowflake.
Si necesitas números cortos y ya tienes un servicio central fiable, los bloques de un servidor de tickets también funcionan bien.
Paso 12 de 12
Resumen
Resumen
Un contador por base de datos deja de ser único en cuanto repartes los datos en shards.
Un servidor de tickets lo arregla; repartir bloques quita el viaje extra en cada alta.
UUID v4 no necesita a nadie, pero dispersa las altas por el índice; UUID v7 pone la hora delante para evitarlo.
Tipo Snowflake: tiempo, máquina y secuencia en 64 bits; vigila los relojes que retroceden.
Los ids delatan volumen y fechas. Nunca los uses como control de acceso.
← → paso · R repetir · Espacio pausa
Aprenderás
- Ver por qué el contador de la base de datos falla al repartir los datos (visto)
- Usar un servidor de tickets y repartir bloques de ids (visto)
- Entender UUID v4 y qué hacen las claves aleatorias a un índice (visto)
- Generar ids ordenados por tiempo: UUID v7 e IDs tipo Snowflake (visto)
- Protegerte de relojes que retroceden y de ids que dan pistas (visto)