Nuestro setup de ClickHouse para reducir la latencia
ObsessionDB reduce la latencia de las queries en ClickHouse® por capas. Nuestra caché NVMe distribuida convierte el viaje de ida y vuelta a S3, que en la cola se va a cientos de milisegundos, en un salto de 0,5 ms entre nodos, y cachea los datos en cuanto se escriben. Los índices de projection se mantienen residentes en memoria y con los umbrales bien ajustados a escala de terabytes. Por debajo están los settings que puede ajustar cualquier cluster de ClickHouse: los umbrales del índice de projection, la query condition cache y las parallel replicas.
Casi todos los consejos para afinar ClickHouse empiezan por la query: sort keys, PREWHERE, skip indexes. Esa capa importa, y nuestra guía de índices, projections y vistas materializadas explica cuándo tirar de cada uno. Este artículo trata de la capa de debajo: los settings de servidor y de query que deciden si la maquinaria que has montado llega siquiera a usarse. Los repasamos en el orden en que conviene revisarlos, empezando por lo único que ningún setting puede quitar.
En cualquier ClickHouse sobre S3, el nuestro incluido, el suelo de latencia lo pone el viaje a object storage, y más concretamente la cola de ese viaje. Según las mediciones de Quickwit, el primer byte típico de S3 ronda los 30 ms; la propia guía de rendimiento de AWS habla de 100 a 200 ms. Las dos cifras son medianas, y una query con fan-out no vive en la mediana: se divide en cientos de GETs y no termina hasta que llega el más lento. En la cola, S3 se va a 300 a 500 ms, así que una query que toca object storage unos cientos de veces se topa con esa cola en casi todas las ejecuciones. Añadir 30 ms a una query no suele importar. Lo que te mata es que cada query vaya al ritmo de la más lenta de sus cientos de peticiones.
Filesystem cache, query condition cache y caché distribuida
Para ahorrarse viajes a S3 hay varias capas, y cada una resuelve un problema distinto.
ClickHouse trae de serie dos cachés locales al nodo que influyen en la latencia sobre object storage. La filesystem cache guarda rangos de datos en bruto en el disco local, de modo que un gránulo que ya se leyó de S3 no vuelve a leerse de S3. La query condition cache recuerda qué gránulos no pasaron un filtro WHERE, para que la siguiente ejecución de ese filtro se los salte sin tocar datos.
Los clusters de ObsessionDB añaden una tercera caché por debajo de ambas: la distribuida, compartida entre todos los nodos del cluster, que suma más espacio en disco y sube bastante el hit rate.
La filesystem cache
La filesystem cache se configura a nivel de disco, no con un setting de query. Defines un disco de tipo cache encima del disco de object storage, y una política de almacenamiento tiene que hacer pasar la tabla por él:
<storage_configuration>
<disks>
<s3_cached>
<type>cache</type>
<disk>s3_main</disk>
<path>/var/lib/clickhouse/cache/</path>
<max_size>100Gi</max_size>
</s3_cached>
</disks>
<policies>
<s3>
<volumes>
<main><disk>s3_cached</disk></main>
</volumes>
</s3>
</policies>
</storage_configuration>
El setting de query solo da permiso para usar la caché. Si ninguna política pasa por el disco de caché, enable_filesystem_cache = 1 no habilita nada, y sin avisar por ningún lado: puedes tener un disco de caché perfectamente configurado en system.disks y que todas las lecturas sigan yendo a object storage, en la primera ejecución y en todas las siguientes.
Con una query contra system.query_log sales de dudas:
SELECT ProfileEvents['CachedReadBufferReadFromCacheBytes'] AS bytes_from_cache
FROM system.query_log
WHERE type = 'QueryFinish' AND query_id = '<your-query-id>';
Si sale cero en una query repetida, la caché no está en tu ruta de lectura. Lo siguiente es revisar system.storage_policies.
En el mismo bloque de configuración hay otras dos trampas. ClickHouse autogestionado solo llena la caché en las lecturas: enable_filesystem_cache_on_write_operations es false por defecto en open source (ClickHouse Cloud lo pone a true), y además el disco de caché tiene que declarar cache_on_write_operations, así que un cluster autogestionado de serie sirve en frío justo los datos más recientes.
Hemos incluido esta sección para dar el contexto completo de cachés del ecosistema, pero en ObsessionDB la tenemos desactivada por defecto. En un cluster, una caché local al nodo desperdicia NVMe: con seis nodos, una query tiene una posibilidad entre seis de caer donde los datos están calientes, y la cobertura parcial es peor de lo que sugiere el porcentaje, porque basta con unos pocos ficheros fríos por parte para que S3 vuelva a la ruta crítica de casi todas las lecturas. Si ese mismo NVMe se aporta a la caché distribuida, da servicio a todos los nodos y el hit rate se queda prácticamente en el 100 %. Nuestro objetivo es cero accesos en frío, y con caché local al nodo no se llega.
La query condition cache
La query condition cache guarda un bit por filtro y gránulo: si ese gránulo pasó o no ese WHERE. Está activada por defecto desde la 25.4, ocupa 100 MB de memoria salvo que cambies su tamaño y, con filtros selectivos repetidos, te da un orden de magnitud: hemos visto ejecuciones repetidas pasar de varios segundos a menos de 100 ms. Déjala activada. Los filtros sobre datos que casi solo reciben inserciones la aprovechan constantemente, y así son la mayoría de cargas analíticas.
Tiene una pega, y la pagan los benchmarks. La segunda ejecución de una query de prueba sale en parte de esta caché, así que tu comparativa de antes y después mide la caché y no el cambio. Pon use_query_condition_cache = 0 en cualquier entorno de medición que lo necesite, y en ningún otro sitio.
Los marks y los ficheros de índice tienen sus propias cachés, con sus propios fallos a escala; en projections de ClickHouse a escala contamos cómo los mantenemos residentes en una tabla de 20 TB y el p50 de 213 ms que conseguimos con ello.
La caché distribuida
La caché que más pesa en nuestra latencia es la distribuida. Cada nodo aporta su NVMe a un mesh compartido y el rendezvous hashing decide qué nodo guarda cada fichero, así que una parte cacheada en cualquier punto del cluster está a un salto de 0,5 ms de cualquier nodo, cuando esa misma lectura desde S3 cuesta decenas de milisegundos en la mediana y cientos en la cola. Funciona por debajo de Alloy, nuestro motor de almacenamiento desarrollado contra la API de SharedMergeTree, y es lo que nos permite dejar apagada la filesystem cache.
Se diferencia de las cachés nativas en tres cosas. Los datos se cachean en cuanto un nodo los escribe, y las particiones más recientes ya están calientes en su primera lectura. Los índices y los marks se precalientan en cuanto aparece una parte, la misma palanca que llevó una tabla de 20 TB a un p50 de 213 ms en projections a escala. Y el trabajo se manda al nodo que ya tiene los bytes: en nuestros dos clusters con más carga, alrededor del 70 % de los merges leen en local, cuando con el reparto natural un mesh de seis nodos se quedaría en torno al 17 %.
Las dos cachés nativas le ahorran a un nodo un viaje a S3. La distribuida se lo ahorra a todo el cluster, aguanta los cambios de tamaño y no tienes que configurar nada. El diseño completo está en el artículo sobre la caché distribuida stateless y en construir sobre ClickHouse desacoplado.
Projections a escala de terabytes
La caché decide lo rápido que llegan los bytes. Las projections deciden cuántos bytes hacen falta, y es ahí donde más se distancian nuestros clusters de los despliegues estándar y de ClickHouse Cloud. En setups tipo SharedMergeTree, las projections dejan de escalar a partir de unos pocos terabytes, porque el coste de seleccionar partes empieza a comerse la query. Nosotros tenemos una en una tabla de más de 20 TB y 200.000 millones de filas con un p50 de 213 ms; cómo hicimos las projections 10 veces más rápidas con 20 terabytes cuenta la ingeniería que hay detrás, y la mayor parte consiste en mantener residentes en memoria los ficheros de marks e índices.
Esa misma maquinaria esconde una trampa que puedes arreglar tú mismo. La 25.11 introdujo dos settings de umbral con un valor por defecto de 1.000.000 de filas, y la referencia oficial de settings describe el primero como el mínimo estimado de filas a leer de la tabla. Pero la comprobación se hace por parte (el umbral está en projectionsCommon.cpp, dentro del bucle que recorre las partes de datos), contra los rangos de filas seleccionados en cada parte. Resultado: una tabla formada por partes de menos de un millón de filas nunca llega a usar su índice de projection, da igual lo grande que sea, y con ingesta constante los merges en segundo plano no dejan de generar justo ese tipo de partes. En una tabla de 194.000 millones de filas, ese suelo era de 35 millones de filas y 1,6 GB leídos por query; con los umbrales a cero bajó a 26.000 filas y 369 KB:
SET min_table_rows_to_use_projection_index = 0; -- default 1,000,000
SET max_projection_rows_to_use_projection_index = 1e9; -- default 1,000,000
Un EXPLAIN indexes = 1 a secas muestra un full scan en ambos casos, porque el pruning del índice de projection ocurre en tiempo de lectura. Mira read_rows en system.query_log y luego EXPLAIN indexes = 1, projections = 1. Si un índice de projection es siquiera el mecanismo adecuado es otra decisión; índices vs. projections vs. vistas materializadas repasa las opciones escalón a escalón.
Los settings que merece la pena tocar
Todo lo anterior viene con la plataforma. Estas son las palancas que tienes tú, en cualquier ClickHouse. El diseño de la query es lo que más latencia mueve y tiene sus propias guías: sort keys, PREWHERE y skip indexes en optimización de queries en ClickHouse, y la forma del lookup en diccionarios y JOINs, donde un dictGet es 20 veces más rápido que el JOIN equivalente. Por debajo de la capa de query hay dos settings que merecen su propia advertencia: uno reparte una query entre máquinas y el otro aplaza trabajo dentro de una.
Las parallel replicas (enable_parallel_replicas = 1) ponen a todas las réplicas a trabajar en la misma query, en lugar de tenerlas solo como copia para failover. En un scan pesado o una agregación grande, el cluster se reparte la lectura y el tiempo total baja con el número de nodos. En un point lookup no hay nada que repartir y la coordinación es puro overhead: las queries pequeñas pueden gastar más en coordinarse de lo que ahorran, y las que llevan CTEs, subqueries o JOINs pueden ir directamente peor. parallel_replicas_min_number_of_rows_per_replica es la red de seguridad: por debajo del umbral, la query se queda en un solo nodo. Este setting llegó en la 24.10 y requiere el analyzer nuevo. No hay un número de réplicas que valga para todo: una query analítica pesada puede y debe usar todos los nodos, con mucha concurrencia conviene usar menos, y ClickHouse decide el número real a partir de una docena de settings, entre ellos las filas que espera leer. Trata max_parallel_replicas como algo que se ajusta por carga de trabajo.
Otro detalle: con la lectura en paralelo activada, el planner no usa projections en esa lectura. Si tu plan de latencia depende de una projection, y después de la sección anterior puede que sí, limita las parallel replicas a las queries con scans pesados con un SET por query, en lugar de activarlas globalmente.
La lazy materialization (query_plan_optimize_lazy_materialization) es su equivalente dentro del nodo: en queries top-N, ClickHouse solo lee las columnas pesadas de las filas que sobreviven al ORDER BY más el LIMIT. Medimos una columna ancha con un 0,45 % de lectura extra con ella activada y un 14,5 % sin ella. El límite está en query_plan_max_limit_for_lazy_materialization, 10.000 por defecto: un LIMIT por encima desactiva la optimización sin ningún aviso, así que un endpoint paginado al que le vas subiendo el tamaño de página puede pegarse un batacazo de rendimiento.
Qué setting para cada síntoma
Recorre los síntomas en orden; cada fila es más barata de comprobar que la de debajo.
| Síntoma | Qué mirar primero | Qué hacer |
|---|---|---|
| Las queries repetidas van tan lentas como en frío | CachedReadBufferReadFromCacheBytes en query_log | Haz que una política de almacenamiento pase por un disco de tipo cache |
| Una query selectiva hace full scan pese a tener índice de projection | read_rows, luego EXPLAIN indexes = 1, projections = 1 | min_table_rows_to_use_projection_index = 0 y sube el umbral máximo |
| El benchmark va mejor que producción | Los settings del entorno de pruebas | use_query_condition_cache = 0 en tests, activada en producción |
| Los scans pesados ignoran tu número de réplicas | enable_parallel_replicas, con el analyzer activado | Actívalas por perfil de query y mantén el mínimo de filas |
| Los point lookups empeoraron al activar parallel replicas | El uso de projections en esas queries | Limita las parallel replicas a los scans; projections y lectura en paralelo no se llevan bien |
| Las queries en frío siguen en segundos con todo lo anterior en verde | GETs a S3 por query | Estás en el suelo; la solución es la arquitectura de caché, no los settings |
Todo lo que hay por encima de la última fila funciona en cualquier despliegue de ClickHouse, autogestionado o gestionado, ObsessionDB incluido. La última fila explica por qué nuestros clusters aguantan con datasets enormes: caché al escribir, índices precalentados, enrutado por localidad e índices de projection residentes vienen de serie debajo de cada tabla, y no hay setting que pueda añadírselos a un cluster estándar. El benchmark de 10.000 millones de filas contra ClickHouse Cloud muestra lo que da de sí todo eso junto, y cómo consultamos 18 terabytes en menos de un segundo recorre capa por capa una carga de producción.
Si tu p99 no cuadra con tus settings, lo miramos contigo. Nuestra auditoría de rendimiento parte de tu query log real, le aplica esta checklist y otras más a fondo, y te entrega las conclusiones, acabes o no usando ObsessionDB.
FAQ
Mira primero read_rows en system.query_log. Desde la 25.11, dos settings de umbral (min_table_rows_to_use_projection_index, 1 millón por defecto, evaluado por parte) pueden descartar el índice de una projection en tablas con muchas partes pequeñas. Las projections materializadas a medias y las parallel replicas también acaban en full scan sin avisar.
No. El setting solo permite cachear; tiene que existir un disco de tipo cache y una política de almacenamiento que haga pasar tu tabla por él. Compruébalo con el profile event CachedReadBufferReadFromCacheBytes en una query repetida: si da cero, todas las lecturas siguen yendo a object storage, y la solución está en system.storage_policies, no en tu SQL.
O no hay ninguna caché en la ruta de lectura (revisa las políticas de almacenamiento) o la cobertura es parcial: una query que toca 100 partes paga la latencia de S3 si cada parte tiene un fichero frío. Además, la query condition cache solo se salta los gránulos filtrados; no cachea los datos que pasan el filtro.
En scans grandes y agregaciones, sí: las réplicas se reparten la lectura. En queries pequeñas, el overhead de coordinación puede superar lo que se ahorra, y las queries que usan projections las pierden con la lectura en paralelo. Actívalas por query o configura parallel_replicas_min_number_of_rows_per_replica en lugar de activarlas en todo el cluster.
La filesystem cache de ClickHouse es privada de cada nodo: se calienta con sus propias lecturas y la limita su propio disco. Con seis nodos, una query tiene una posibilidad entre seis de dar con datos calientes. Una caché distribuida junta el NVMe de todo el cluster con rendezvous hashing, así que todos los nodos acceden a ella y las partes sobreviven a los reescalados.
Una query va tan rápido como su petición a S3 más lenta. La mediana del primer byte parece razonable, decenas de milisegundos, pero la cola se va a 300 a 500 ms, y una query selectiva que toca cientos de gránulos se topa con esa cola en casi todas las ejecuciones. Las capas de caché, locales al nodo o distribuidas, están para sacar a S3 de la ruta de lectura.
Seguir Leyendo
Publicado originalmente en obsessionDB. Lee el artículo original aquí.
ClickHouse is a registered trademark of ClickHouse, Inc. https://clickhouse.com