Motores de almacenamiento
- Lección 11 de 40
- 14 min
- Intermedio
- 13 pasos
Del «guardado» al disco: cómo reparte un motor los datos entre memoria y disco, y por qué cada diseño favorece las lecturas o las escrituras.
- Escrituras perdidas en un corte
- 0
- Escrituras por segundo
- 200.000
- fsync por segundo
- 5.000
- Lecturas por búsqueda
- 1
- Columnas leídas
- —
- petición
- respuesta
- lote
- esperando en cola
Paso 1 de 13
Concepto
Memoria y disco
Un servidor de base de datos guarda datos en dos sitios. La memoria (RAM) responde en nanosegundos, pero se borra si el proceso cae o se va la luz. El disco conserva todo tras un apagón, pero confirmar que un dato ya está físicamente escrito (una llamada fsync) cuesta miles de veces más.
El motor de almacenamiento es la pieza de la base de datos que decide qué va a cada sitio y cuándo. Todos los diseños de esta lección responden a la misma pregunta: ¿cómo consigo la velocidad de la RAM sin renunciar a la seguridad del disco?
Paso 2 de 13
Problema
Rápido pero frágil: primero la RAM, el disco ya llegará
El motor más simple cambia la página en memoria, responde «guardado» al instante y copia las páginas modificadas al disco cada pocos segundos, en segundo plano. Escribe rapidísimo: en este ejemplo, 500.000 escrituras por segundo.
Hasta que se va la luz. Todo lo cambiado desde la última copia desaparece, incluidos pedidos que ya le confirmaste al cliente. Con una copia cada 4 s, son 4 × 500.000 = 2 millones de escrituras perdidas. Y la página que se estaba escribiendo justo en ese instante queda a medias: una página rota (torn page) que ya no sirve.
Qué cambió
- Responder «guardado» en cuanto cambia la memoria
- Un corte borra los últimos 4 s de escrituras
- Una página queda escrita a medias
Paso 3 de 13
Solución
Anótalo antes: el log de escritura anticipada
Escribir en disco cada página modificada antes de responder sería seguro, pero lentísimo: reescribir 8 KB en una posición cualquiera del disco para cambiar una fila de 100 bytes.
En su lugar, el motor describe el cambio en pocos bytes, lo añade al final de un archivo de log y lo fuerza a disco con fsync antes de responder. Es el WAL (write-ahead log, log de escritura anticipada). Añadir al final de un archivo es de lo más barato que puede hacer un disco. Las páginas se cambian en memoria y se copian al disco más tarde, sin prisa.
Con un fsync de 0,2 ms por transacción (valor de ejemplo para un SSD), el techo es 1 s ÷ 0,2 ms = 5.000 escrituras por segundo. Tus números serán otros; la proporción entre diseños se mantiene.
Qué cambió
- Log WAL: añadir al final y hacer fsync
- «Guardado» solo cuando la entrada del log está en disco
- Las páginas se copian después, en segundo plano
Paso 4 de 13
Compromiso
Caso: ¿qué tan seguro es «guardado»?
Un fsync por transacción pone el techo en 5.000 escrituras por segundo. Con miles de commits por segundo, ese paso se convierte en el cuello de botella.
El commit en grupo lo alivia sin perder seguridad: las transacciones que llegan casi a la vez comparten un solo fsync. Con 8 por grupo: 5.000 fsync/s × 8 = 40.000 escrituras por segundo.
Más allá hay un dial: muchas bases de datos permiten hacer fsync por temporizador (cada 100 ms, cada segundo) en vez de en cada commit. El rendimiento se multiplica, a cambio de perder los últimos instantes de escrituras «guardadas» si hay un corte.
Qué cambió
- Commit en grupo: un fsync para 8 transacciones
- Escrituras: de 5.000 a 40.000 por segundo
- Opcional: fsync por temporizador, más rápido pero con pérdida posible
Paso 5 de 13
Técnica
El log no puede crecer sin fin
Si nadie lo recorta, el log crece sin límite, y recuperarse de un corte obligaría a releer días de cambios. Por eso, cada pocos minutos, el motor hace un checkpoint: copia al archivo de datos todas las páginas modificadas, anota «hasta aquí, todo está en las páginas» y descarta el log anterior.
Tras un corte, basta con releer el log escrito desde el último checkpoint: de unos segundos a pocos minutos de trabajo.
Qué cambió
- Checkpoint: copiar las páginas modificadas y recortar el log
- La recuperación relee solo el log desde el checkpoint
Paso 6 de 13
Concepto
El motor clásico: páginas en un B-tree, cambiadas en su sitio
Lo que acabamos de montar es el diseño de la mayoría de las bases de datos relacionales. Los datos viven en páginas de tamaño fijo organizadas en un B-tree; en algunos motores la propia tabla es ese árbol. Para cambiar una fila, el motor busca su página y la modifica en su sitio, con el log como red de seguridad.
Brilla al leer. En un árbol de 4 niveles (ejemplo), cualquier fila está a 4 lecturas de página, casi siempre ya en memoria, y las claves vecinas viven en páginas vecinas, así que recorrer un rango sale barato.
Qué cambió
- Lecturas: 4 páginas, casi todas desde memoria
- Escrituras: buscar la página y cambiarla en su sitio
Paso 7 de 13
Problema
Caso: una avalancha de escrituras
Ahora cambia la carga: lecturas de sensores, mensajes de chat, clics. 200.000 escrituras pequeñas por segundo (ejemplo), cada una con una clave distinta, así que cada una cae en una página distinta. La memoria se llena de páginas modificadas y todas deben volver, tarde o temprano, a su sitio en el disco: una página entera por unos pocos bytes cambiados.
El log aguanta sin problema, porque es secuencial. Las escrituras de páginas sueltas, no: los checkpoints se retrasan y el rendimiento se queda en lo que el disco aguante de escrituras aleatorias, unas 40.000 por segundo en este ejemplo. Las otras 160.000 no caben.
Qué cambió
- Carga: 200.000 escrituras pequeñas/s con claves dispersas
- Toda la memoria está llena de páginas modificadas; los checkpoints se retrasan
- El rendimiento se queda en 40.000 escrituras/s
Paso 8 de 13
Solución
Nunca en su sitio: el LSM-tree
Otro diseño abandona la idea de que cada fila tenga un hogar fijo. Una escritura va al log y a una estructura ordenada en memoria, la memtable. Nada más: no hay página que buscar.
Cuando la memtable se llena, se vuelca al disco de una sola vez como un archivo ordenado e inmutable, una SSTable, y empieza una memtable nueva. Todas las escrituras a disco son secuenciales. Es el LSM-tree (log-structured merge tree, árbol de fusión estructurado en log), habitual en bases de datos pensadas para escribir mucho.
El log sigue haciendo 5.000 fsync por segundo; con más carga, cada grupo junta más transacciones: 200.000 ÷ 5.000 = 40 por fsync.
Qué cambió
- Páginas en memoria → memtable ordenada
- Una memtable llena se vuelca como un archivo ordenado
- Todas las escrituras a disco son secuenciales: 200.000/s
Paso 9 de 13
Problema
Caso: ¿dónde está mi clave?
Ahora lo difícil es leer. El valor más reciente de una clave puede estar en la memtable o en cualquier SSTable. Hay que mirar de la más nueva a la más antigua, y una clave escrita hace mucho (o que no existe) obligaría a revisar todos los archivos.
Dos trucos lo arreglan. Cada SSTable lleva un filtro de Bloom, que responde «seguro que aquí no está» sin tocar el disco, y un pequeño índice que dice dónde empieza cada rango de claves. Así, una búsqueda típica lee un solo archivo.
Qué cambió
- Una búsqueda podría revisar todas las SSTables
- Un filtro de Bloom y un índice pequeño por archivo
- La mayoría de las búsquedas leen un solo archivo
Paso 10 de 13
Técnica
Compactación: ordenar en segundo plano
Los archivos se acumulan, y los antiguos están llenos de valores ya sobrescritos o borrados. Un proceso en segundo plano los va fusionando: lee varios archivos ordenados, escribe uno nuevo que guarda solo el valor más reciente de cada clave y borra los originales.
Eso es la compactación. Limita cuántos archivos mira una lectura y libera espacio. También es el precio del diseño: cada byte se reescribe varias veces a lo largo de su vida, y la compactación compite por el disco con el tráfico real.
Qué cambió
- La compactación fusiona tres archivos en uno
- Se descartan los valores sobrescritos y las lápidas que ya no tapan nada
- Menos archivos que revisar en cada lectura
Paso 11 de 13
Compromiso
¿B-tree o LSM?
Muchas lecturas, consultas por rangos y transacciones: un B-tree. Muchísimas escrituras y datos enormes que casi solo crecen: un LSM-tree.
No es blanco o negro: hay bases de datos SQL modernas que funcionan sobre un motor LSM, y motores B-tree que aguantan muy bien la escritura con un buen disco.
Paso 12 de 13
Concepto
Caso: ¿filas o columnas?
Queda un eje más. Los dos motores anteriores guardan cada fila junta: perfecto para leer o cambiar registros completos. Pero un analista pide SELECT SUM(precio) FROM pedidos sobre 2.000 millones de filas, y un almacén por filas tiene que leer las 40 columnas de cada fila para sumar una sola.
Un almacén columnar guarda cada columna en su propio archivo. La consulta lee solo precio, la cuadragésima parte de los datos: si la tabla ocupa 4 TB (ejemplo), lee unos 100 GB en vez de 4 TB. Y como los valores parecidos quedan juntos, se comprimen mucho mejor. Así recorren los almacenes de datos analíticos miles de millones de filas en segundos.
Qué cambió
- Consulta analítica: SUM(precio) sobre 2.000 millones de filas
- Almacén por filas: se leen todas las columnas de todas las filas
- Almacén columnar: 1 columna de 40
Paso 13 de 13
Resumen
Resumen
La memoria es rápida y olvidadiza; el disco, duradero y lento. El motor de almacenamiento une los dos.
El log WAL hace que «guardado» sea verdad: añadir, fsync y entonces responder.
Cada cuánto haces fsync es un dial de durabilidad: conoce dónde está el tuyo.
Los B-trees cambian las páginas en su sitio: lecturas predecibles, escrituras dispersas.
Los LSM-trees solo añaden: escrituras rápidas, pagadas con compactación y lecturas más complejas.
Los almacenes columnares sirven al análisis leyendo solo las columnas que pide la consulta.
← → paso · R repetir · Espacio pausa
Aprenderás
- Qué hace falta para que «guardado» sobreviva a un apagón (visto)
- fsync, commit en grupo y checkpoints (visto)
- Cómo lee y escribe un motor basado en B-tree (visto)
- Memtable, SSTables, filtros de Bloom y compactación en un LSM-tree (visto)
- Cuándo elegir B-tree o LSM, filas o columnas (visto)