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
—
AppAppMemoriaRAMMemoriaLog WALsecuencialLog WALArchivo de datos · páginas de 8 KBSSTable 1 (la más antigua)SSTable 2SSTable 3SSTable 4 (la más nueva)ConsultaanalíticaConsulta analíticaAlmacén columnarpáginas en uso · nanosegundoscorte de luz · 4 s perdidospágina rotafsync antes de «guardado»1 fsync para 8 transaccionesEl dial de durabilidadfsync en cada commitno pierde nada · el más lentocommit en grupono pierde nada · fsync compartidofsync cada 100 msrápido · pierde hasta 100 mssin fsync propioel más rápido · pierde segundosvalores de ejemplocheckpoint: copiando páginaslog antiguo descartado4 lecturas de páginaB-tree · una copia por fila100%200.000 escrituras/sllena de páginas modificadasmemtable ordenadavolcado: una escritura secuencialla más nuevaSSTables · la más antiguamemtable: GET user:42 · no estáfiltro: no estáfiltro: no estáfiltro: no estáquizá → encontradamemtable ordenadafusionada · solo lo más nuevola más nuevavolcadoarchivos inmutablesB-tree o LSM-treeB-treeLSM-treeescribepáginas sueltasen secuencialeepocas páginasarchivos + filtroespaciopáginas con huecoscompactode fondocheckpointscompactaciónfilas: lee las 40 columnaslee 1 columna de 40memtable ordenadala más nuevavolcado
  • 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.

Aprenderás

  • Qué hace falta para que «guardado» sobreviva a un apagón
  • fsync, commit en grupo y checkpoints
  • Cómo lee y escribe un motor basado en B-tree
  • Memtable, SSTables, filtros de Bloom y compactación en un LSM-tree
  • Cuándo elegir B-tree o LSM, filas o columnas