Nuestro setup de ClickHouse para escalar
ObsessionDB escala ClickHouse® por los dos lados de la carga. En ingesta, una migración cargó cientos de terabytes en pocos días a más de 300 inserts por segundo, y un solo nodo de 32 CPU mantuvo 31,8 millones de filas por segundo durante 90 minutos. En lectura, una tabla de 203.000 millones de filas y 56 TB responde lookups aleatorios con un p99 por debajo del segundo. Por debajo hay una sola copia de los datos en object storage, compute sin estado, merges guiados por localidad y settings que puedes usar en cualquier cluster de ClickHouse.
La semana pasada publicamos nuestro setup para reducir la latencia. Este artículo va del otro eje del escalado de ClickHouse: qué le pasa al mismo cluster cuando los datos se multiplican por diez y el ritmo de ingesta sube con ellos.
Las dos curvas salen de varias capas de decisiones sobre dónde viven los bytes y qué nodo hace cada trabajo. La primera mitad del artículo recorre esas capas una a una y compara cada una con lo que haría un cluster autogestionado en la misma situación. La segunda mitad es la caja de herramientas: los settings que permiten escalar en cualquier cluster, divididos en ingesta, merges y queries.
El setup, capa por capa
Añadir un nodo a uno de nuestros clusters no mueve datos. Casi todas las capas que vienen a continuación se apoyan en esa propiedad, y es justo la que un cluster autogestionado no consigue por mucho que toque los settings.
Una sola copia de los datos, compute sin estado
Alloy es nuestro motor de almacenamiento, desarrollado sobre la API de SharedMergeTree. Los metadatos de cada tabla viven en una capa de coordinación, los datos se guardan en object storage como objetos inmutables y los nodos de compute no guardan nada persistente. Cuando entra un nodo, se suscribe a los metadatos y empieza a servir; su tramo del anillo de caché se va llenando con el primer acceso. Cuando sale, cede sus claves al siguiente nodo del ranking y el anillo se recompone. Nuestra documentación de escalado lo resume en una línea: cambiar la forma del cluster no mueve datos, sin re-sharding ni rebalanceos. En Construir sobre un ClickHouse desacoplado contamos qué cambia para las tablas que van encima.
ReplicatedMergeTree, el motor que usa un cluster autogestionado, guarda una copia completa de los bytes en cada réplica y las coordina a través de Keeper. Tres réplicas de una tabla de 54 GiB ocupan unos 162 GiB. Cada tabla lógica se convierte en una tabla _local por shard más una fachada Distributed, y cada ALTER se lanza ON CLUSTER, donde puede aplicarse en unos shards y fallar en otros. Nosotros trabajamos así durante un año; añadir un shard suponía copiar más de 25 TB.
Poner un disco S3 debajo de MergeTree no cambia nada de esto. Con una política de almacenamiento por niveles, cada réplica sigue teniendo su propia copia de los ficheros en S3, y los metadatos de las partes se quedan en el disco local de cada nodo. La replicación zero-copy comparte los objetos pero deja los metadatos en local, y la documentación de ClickHouse avisa de que no está lista para producción. Viene desactivada por defecto desde la 22.8. El almacenamiento por niveles es un nivel frío con el mismo acoplamiento.
Compute separado sobre los mismos objetos
Antes, un cluster equivalía a una sola mezcla de cargas de trabajo. Como en los nodos no hay nada persistente, un segundo grupo de nodos puede leer los mismos objetos sin que los dos grupos compitan por memoria ni por ancho de banda. A nuestros clientes les ponemos los nodos que sirven en un grupo y, si hace falta, un nodo aparte en otro para los backfills y las reconstrucciones pesadas. Los trabajos de reingesta funcionan igual: van en infraestructura aislada y no en los nodos que sirven la API.
La versión extrema es un datashare: el compute de otra organización lee tus objetos en solo lectura, sin copias ni réplicas, y ninguna de las dos partes puede comerse los recursos de la otra.
La caché distribuida
Todas las lecturas pasan por la caché distribuida. Cada nodo aporta su NVMe a un único anillo con rendezvous hashing, y cada parte entra en caché en el momento en que se escribe, así que las particiones más recientes ya están calientes en su primera lectura. Traer datos de otro nodo cuesta menos de un milisegundo, mientras que object storage tarda decenas de milisegundos en la mediana y cientos en la cola, como medimos en el artículo de latencia. Su ancho de banda crece con el cluster: 20 nodos dan 20 veces la red de uno; una caché centralizada se queda en unas tres. Dimensiónala para que el working set de cada nodo quepa en torno al 80 % de su disco de caché (la documentación tiene la fórmula); si no, tu latencia acabará siendo la de object storage. Ese artículo también explica cómo se comporta la caché bajo carga.
Merges que se quedan donde están los datos
Si las partes cayeran al azar, un cluster de seis nodos con almacenamiento compartido haría en local solo el 17 % de los merges: una posibilidad entre seis de que las entradas estén en el nodo que hace el trabajo. Nuestros clusters con más carga rondan el 70 % en local. Según nuestras cuentas, la diferencia supone unas cuatro veces menos ancho de banda de merge con seis nodos, y donde se nota ese margen es en el benchmark de 10.000 millones de filas: hacemos merges de partes de hasta 150 GB sin congestionar la red.
El mecanismo no tiene scheduler. En un cluster sin estado, cualquier nodo puede hacer el merge de cualquier conjunto de partes, porque las partes viven en object storage. Todos los nodos ejecutan el mismo selector de merges y aplican el mismo ranking de rendezvous hashing para responder a una pregunta local: si son el nodo mejor situado para ese conjunto candidato. El nodo que encabeza el ranking para esas entradas se encarga del merge, y la parte resultante va a parar a su propietario en el ranking, que es adonde se enrutarán después las lecturas de esa parte. La documentación describe la colocación como algo que surge de que todos los nodos apliquen el mismo ranking a la misma información. Hay dos settings, y no hace falta tocarlos: cache_locality_aware_merges está activado, y min_bytes_for_locality_aware_merges vale 100 MB por defecto para que las partes diminutas, que son la mayoría, se fusionen donde haya un hueco libre en lugar de acumularse en un nodo.
Un merge suele leer varios cientos de partes de entrada. En un cluster con colocación aleatoria, la proporción de esas entradas que está en la caché del nodo que hace el merge es 1/N, así que cada nodo que añades obliga a mover más bytes por la red para el mismo trabajo de merge. Con localidad, la proporción local se mantiene cerca del 70 % aunque N crezca. Ahí está toda la diferencia: añadir nodos ayuda a los merges aquí y los perjudica en un cluster de almacenamiento compartido que coloca los merges al azar.
Queries que van a buscar los datos donde están calientes
Nuestro fan-out de parallel replicas se diferencia del de ClickHouse estándar en el enrutado. El planificador de lecturas reutiliza el mismo ranking de rendezvous hashing que coloca los merges: cada sub-query coge primero los rangos que su propio nodo tiene en el anillo de caché, y luego roba los que quedan al siguiente nodo del ranking, no a uno cualquiera, así que la tasa de aciertos se mantiene aunque el propietario esté ocupado. En la tabla de 56 TB, en un caso idealizado de lectura por red, la misma query tardó 1,3 s en un nodo, 1,0 s en seis nodos con parallel replicas sin más, y 0,5 s en esos mismos seis nodos con enrutado por localidad.
ClickHouse open source añadió en la 26.6 un segundo modo de ejecución, todavía experimental, la ejecución distribuida multi-stage, y la 26.8 le sumó un optimizador basado en costes. El planificador divide la query en etapas conectadas por intercambios de tipo scatter, broadcast, gather y shuffle, de modo que un GROUP BY de alta cardinalidad ya no tiene que pasar todos los resultados parciales por la memoria de un único coordinador. Lo estamos probando en la 26.8. En septiembre, en nuestro cluster de pruebas de tres nodos, una agregación de alta cardinalidad fue 2,86 veces más rápida que en un solo nodo, y otra más pesada, que falla en un nodo y también con parallel replicas, termina con ejecución multi-stage y con mucha menos memoria.
La caja de herramientas: qué hace escalar cualquier cluster de ClickHouse
Las cinco capas vienen con la plataforma. Los settings de abajo son los que dependen de ti, en cualquier cluster, y deciden si esas capas llegan a servir de algo.
Ingesta
Agrupa los inserts. ClickHouse recomienda en torno a un insert por segundo por tabla, con miles de filas en cada uno. Muchos inserts pequeños generan muchas partes pequeñas, y todas tienen que pasar después por un merge. Con async inserts, el agrupado lo hace el servidor. Deja wait_for_async_insert = 1 para que, si un insert falla, te enteres, y ponle al cliente un timeout más largo del que necesita el servidor; si no, un reintento escribirá las mismas filas dos veces. Desde la 26.8, max_insert_threads usa por defecto todos los cores, lo que genera más partes y le quita CPU a los merges; en cargas masivas, fíjalo en un valor bajo.
| Setting | Qué aporta | Qué cuesta |
|---|---|---|
| Agrupar, ~1 insert/s por tabla | Menos partes, menos merges | Algo de latencia en el cliente |
async_insert = 1, wait_for_async_insert = 1 | Agrupado en el servidor | Un timeout que hay que dimensionar |
max_insert_threads (auto desde la 26.8) | Cargas masivas más rápidas | Más partes, menos CPU para merges |
deduplicate_insert = enable | Los reintentos no duplican filas | Solo dentro de la ventana de dedup |
Merges
Un merge reescribe un conjunto de partes en una sola, y el proceso sigue hasta que las partes llegan a unos 150 GB. Un nodo estándar ejecuta hasta 32 merges a la vez y empieza por las partes pequeñas, así que tener pocas partes te ayuda más que cualquier ajuste del pool. Dos cosas que aprendimos por las malas: OPTIMIZE FINAL sobre partes de más de 150 GB puede fallar, y FINAL va más lento con cada parte que tiene que leer, así que do_not_merge_across_partitions_select_final = 1 es una mejora que sale barata en tablas particionadas.
| Setting | Qué aporta | Qué cuesta |
|---|---|---|
background_pool_size | Más merges en paralelo | CPU y memoria que pierden las queries |
parts_to_delay_insert / parts_to_throw_insert | Un aviso antes de Too many parts | Subirlos solo aplaza el trabajo |
min_age_to_force_merge_seconds | Las particiones sin actividad también compactan | Reescrituras programadas |
do_not_merge_across_partitions_select_final | FINAL más barato | Nada en una tabla particionada |
Queries
Arregla el patrón de acceso antes de añadir nodos. Un cliente nos pidió dos nodos más; tenía una query que escaneaba un petabyte al día, y un solo índice redujo un 99,5 % la CPU del cluster. max_threads usa por defecto todos los cores; en lookups con muchos inserts a la vez, fijarlo en 4 u 8 por query nos dio un p99 estable. Las parallel replicas ayudan en los scans grandes y perjudican a los point lookups, así que actívalas por query, con parallel_replicas_min_number_of_rows_per_replica como salvaguarda. Después de añadir nodos, lanza SYSTEM PREWARM para que los datos ya estén calientes en la caché.
| Setting | Qué aporta | Qué cuesta |
|---|---|---|
| Una sort key que encaje con el filtro | Se salta gránulos en vez de escanear | Un rediseño, una sola vez |
max_threads de 4 a 8 por query de lookup | p99 estable con carga mixta | Velocidad máxima en scans anchos |
enable_parallel_replicas por query | Los scans grandes aprovechan todo el cluster | Sobrecarga en queries pequeñas |
SYSTEM PREWARM tras redimensionar | Los nodos nuevos arrancan en caliente | Tiempo de red por adelantado |
Lo que suman las capas
Las capas se notan en los tres ejes con los que se mide un cluster de ClickHouse: lo rápido que ingiere datos, lo rápido que los procesa y lo rápido que responde.
Primero la ingesta, porque es donde un cluster replicado se queda antes sin margen. En ReplicatedMergeTree, un insert se escribe una vez y luego se copia a cada réplica, con unas diez entradas en Keeper por INSERT (cuenta con unos pocos cientos de inserts por segundo para todo el cluster), y cada réplica repite todos los merges sobre su propia copia. Aquí un insert es una sola escritura: el nodo que lo recibe escribe la parte una vez, a través de la caché distribuida hasta object storage, pasa los metadatos a la capa de coordinación, y el resto de nodos recibe un aviso de parte nueva y precalienta el índice sin copiar un solo byte. El packed storage mete todas las columnas de una parte en un único objeto: unas 15 veces menos escrituras en partes anchas. Los números lo confirman. En junio, un nodo de 32 CPU mantuvo 31,8 millones de filas por segundo durante 90 minutos, alrededor de un millón de filas por segundo por CPU, con los merges funcionando todo el rato. La migración del artículo de Numia cargó cientos de terabytes de más de veinte cadenas en pocos días, a más de 300 inserts por segundo por tabla, y el cuello de botella fueron los clientes que alimentaban el cluster; una hora punta de mayo en ese mismo cluster generó 335.000 partes nuevas y entre dos y tres millones de peticiones a object storage sin un solo error de merge ni de almacenamiento. Más avanzado el verano, el backfill de un cliente fue a cinco o seis millones de filas por segundo en nueve nodos, y dos clientes en prueba de concepto, ambos con experiencia en ClickHouse Cloud, nos dijeron que no habían visto antes ese ritmo de ingesta.
Es en los merges donde añadir nodos compensa o pasa factura. Como cualquier nodo puede hacer el merge de cualquier conjunto de partes, la capacidad de merge crece con el cluster en vez de repetirse en cada réplica, y el enrutado por localidad mantiene cerca del 70 % de las entradas de los merges en el nodo que hace el trabajo, frente al 17 % que daría una colocación aleatoria en seis nodos: unas cuatro veces menos ancho de banda de merge. Ese margen es lo que nos permite hacer merges de partes de hasta 150 GB sin congestionar la red, y explica que los ritmos de ingesta de arriba se mantengan mientras corre la compactación que generan.
Las queries leen la misma copia única de los datos, caliente desde el momento en que se escribe, y cada lectura va al nodo que la tiene. La tabla de 56 TB responde lookups a direcciones aleatorias con un p99 de 703 ms en seis nodos, y el dataset de 18 TB servido con vistas materializadas se quedó por debajo de 410 ms de p99 en 25.000 queries con cinco nodos. Las parallel replicas se encargan de los scans pesados (16,3 veces más rápido en la query más exigente del benchmark de 10.000 millones de filas, siempre por query), y la ejecución multi-stage de la 26.8 cubre las agregaciones de alta cardinalidad que ni un solo nodo ni las parallel replicas resuelven bien.
El último eje es lo que te cuesta cambiar la forma del cluster. Añadir o quitar un nodo no mueve datos, un trabajo pesado puede ir en su propio grupo de compute sin que la API se entere, y la factura es compute más almacenamiento, sin cobro por query; por eso la curva de coste por terabyte de la introducción baja a medida que crecen los datos.
Si algo no va bien, baja por esta tabla. Cada fila es más barata de comprobar que la siguiente, y la mayoría de los tickets se cierran antes de llegar al final.
| Síntoma | Qué mirar primero | Qué hacer |
|---|---|---|
| Inserts limitados o rechazados | Partes por partición en system.parts | Agrupa; luego sube los umbrales en esa tabla y paga la deuda de merges más adelante |
| Los merges se retrasan más cuantos más nodos añades | Volumen de fetches entre nodos durante las ventanas de merge | Merges guiados por localidad, o menos nodos y más grandes |
| Los scans grandes no notan cuántos nodos tienes | enable_parallel_replicas por query, con el analyzer activado | Reparte solo los patrones pesados y mantén la salvaguarda de filas mínimas; en la 26.8, ejecución multi-stage para agregaciones de alta cardinalidad |
| Un backfill ralentiza la API | En qué nodos corre el trabajo | Compute separado sobre los mismos objetos |
| Los reintentos cuentan doble | La ventana de dedup comparada con tu intervalo de reintento | Dedup por bloque en los inserts; vistas idempotentes para el fan-out |
| Todo en verde y aun así lento con N nodos | Peticiones a S3 por query, working set de la caché frente al disco | Has llegado al límite de la arquitectura; no hay setting que lo mueva |
La última cuestión es la forma del propio cluster. Nuestra regla de dimensionado: las operaciones pesadas tipo warehouse piden menos nodos con recursos más concentrados, porque un merge o un join grandes necesitan la memoria de un único nodo; servir con SLA estrictos y demanda elástica pide una flota más grande, por el disco de caché y la capacidad de scan en paralelo; en caso de duda, menos nodos y más grandes, y nunca menos de tres. Un cluster de dos nodos pierde la mitad de su capacidad durante un rolling update. Uno de nueve pierde el 11 %.
Todo esto sirve a una misma promesa en los dos ejes: menos hardware para el mismo rendimiento, o más rendimiento con el mismo hardware. Si tu cluster no se comporta así, lo miramos contigo. Nuestra auditoría de rendimiento parte de tu query log y tu recuento de partes, aplica esta checklist y otras más a fondo, y te devuelve las conclusiones, uses ObsessionDB o no.
FAQ
Con ReplicatedMergeTree, cada réplica nueva repite todos los merges: aporta concurrencia, pero solo acelera una query si esta se reparte entre nodos. En almacenamiento compartido sin enrutado por localidad, la proporción de las entradas de un merge que ya está en local cae como 1/N, así que cada nodo que añades mueve más bytes en los merges. Revisa antes el patrón de acceso: la última vez que nos pidieron "más nodos", lo que faltaba era un índice.
La documentación recomienda en torno a un insert por segundo por tabla, en lotes de 10.000 a 100.000 filas. Cada insert crea al menos una parte que luego tendrá que pasar por un merge, así que el límite lo marca la capacidad de merge. Hemos tenido clientes por encima de 300 inserts por segundo por tabla, pero con lotes grandes y un pool de merges con margen.
Los inserts crean partes más deprisa de lo que los merges en segundo plano consiguen combinarlas, y cuando una partición supera parts_to_throw_insert (3.000 en open source, 600 en nuestra plataforma), ClickHouse rechaza los inserts. Lo habitual es que se deba a inserts pequeños y frecuentes o a demasiadas particiones. Primero agrupa, luego revisa la clave de partición, y sube el umbral solo como solución puente mientras los merges se ponen al día.
En scans pesados y agregaciones grandes, donde la lectura se puede repartir entre nodos; en el benchmark de 10.000 millones de filas llegamos a ir 16,3 veces más rápido con 20 nodos. En global, no: en esa misma prueba, un point lookup pasó de 0,5 s a 37 s. Actívalas por query, deja parallel_replicas_min_number_of_rows_per_replica como salvaguarda y ten en cuenta que las projections se ignoran con lecturas en paralelo.
No. Una política de almacenamiento por niveles mueve las partes frías a un disco S3, pero cada réplica sigue teniendo su propia copia de los objetos y sus propios metadatos de partes en disco local, y las réplicas se siguen coordinando a través de Keeper. Separar implica una sola copia de los datos, los metadatos fuera de los nodos y un compute que puedes añadir o sustituir sin mover nada.
Sí, en tablas replicadas. Cada bloque insertado recibe un hash que se guarda en Keeper, y si un reintento trae un bloque con el mismo hash, se descarta; open source guarda los últimos 10.000 hashes durante una hora. Las tablas destino de las vistas materializadas solo quedan cubiertas si deduplicate_blocks_in_dependent_materialized_views está activado, y los async inserts que pasan por una vista que emite varios bloques fallan con NOT_IMPLEMENTED.
Seguir Leyendo
Publicado originalmente en obsessionDB. Lee el artículo original aquí.
ClickHouse is a registered trademark of ClickHouse, Inc. https://clickhouse.com