ClickHouse+Python+Nginx: tutorial rápido sobre cómo manejar sus registros

Motivación

No hay nada más importante que tener un buen nivel de observabilidad del servicio y no es posible sin un almacenamiento rápido y confiable para los registros de la aplicación. Una de las soluciones más populares hoy en día es ELK ( E lasticSearch- Logstash- Kibana ), pero no es tan universal como podría parecer.

Planteamiento del problema

ELK es una solución flexible, conveniente y compleja para recopilar y analizar registros. Es un filtrado de consultas escalable, robusto, flexible y universal. Sin embargo, existen desventajas al utilizar ELK:

• Alto consumo de recursos de memoria y CPU.
• Degradación de la velocidad de búsqueda e índice junto con un número creciente de registros
• sobrecarga del índice de búsqueda de texto completo
• QueryDSL complicado

Todo esto me hace preguntarme: ¿existe una alternativa a ELK cuando hablamos de registros?

Aquí está mi lista de requisitos para la solución de manejo de registros:

• agregación rápida y flexible
• inserción rápida, selección rápida
• fácil de configurar y con mínimos recursos
• solución compatible con grafana

Sin embargo, es bueno tener una herramienta flexible y rápida para realizar análisis periódicos y ad hoc. Seamos más específicos sobre el sistema que voy a implementar:

• Procese más de 20 millones de líneas de registro que son registros de acceso de Nginx
• Obtenga la cantidad de respuestas HTTP incorrectas (4xx, 5xx)
• Obtenga contadores de bots y rastreadores y la URL que visitan
• Obtenga las 5 principales direcciones IP que son robots sospechosos

Qué es ClickHouse y por qué decidí usarlo

ClickHouse es un sistema de gestión de bases de datos SQL orientado a columnas de alto rendimiento para el procesamiento analítico en línea tal como se declara.

Las características más importantes para mí fueron:

• El almacenamiento orientado a columnas significa que ClickHouse leerá desde el disco sólo si es necesario.
• ClickHouse puede aprovechar todos los recursos disponibles (núcleos de CPU y discos) para ejecutar incluso una sola consulta.
• Compresión de datos
• Soporte SQL, por último pero no menos importante

Solución técnica

Tutorial de repositorio de Github

Puede encontrar el tutorial junto con un generador de registros en GitHub .

Configura ClickHouse y conéctate

En primer lugar, creemos docker-compose.yml para definir ambos servicios. ( https://github.com/bp72/nginxlogprocessor/blob/init-commit/docker-compose.yml )

 version: '3.6' services: ch: image: clickhouse/clickhouse-server container_name: clickhouse restart: always volumes: - clickhousedata:/var/lib/clickhouse/ ports: - '8123:8123' - '9000:9000' ulimits: memlock: soft: -1 hard: -1 nofile: soft: 262144 hard: 262144 # This capabilities prevents Docker from complaining about lack of those cap_add: - SYS_NICE - NET_ADMIN - IPC_LOCK volumes: clickhousedata:

Ejecutémoslo y verifiquemos si todo está funcionando: conéctese a la instancia de ClickHouse usando el cliente ClickHouse desde el contenedor acoplable y verifique si está disponible a través del host local y el puerto.

 > docker-compose up -d [+] Running 3/3 ⠿ Network nginxlogprocessor_default Created 0.1s ⠿ Container clickhouse Started 0.6s

Para conectarme a la instancia prefiero el cliente ClickHouse

 docker-compose exec ch clickhouse-client ClickHouse client version 23.9.1.1854 (official build). Connecting to localhost:9000 as user default. Connected to ClickHouse server version 23.9.1 revision 54466. a8c8da069d94 :)

Crear bases de datos y tablas.

Ahora, cuando todo esté configurado, creemos bases de datos y tablas: base de datos para rastrear los registros procesados y base de datos para un servicio específico, por ejemplo, nginx , y la primera tabla nginx.access .

Una de las ventajas importantes de ClickHouse es la sintaxis SQL para definiciones y consultas. No es estrictamente un estándar SQL, pero está muy cerca de él.

 CREATE DATABASE IF NOT EXISTS nginx CREATE DATABASE IF NOT EXISTS logs CREATE TABLE IF NOT EXISTS nginx.access ( reqid String, ts DateTime64(3), level Enum(''=0, 'debug'=1, 'info'=2, 'warn'=3 ,'error'=4), domain String, uri String, ua String, ref String, is_bot Boolean, is_mobile Boolean, is_tablet Boolean, is_pc Boolean, client String, duration Float32, response_code UInt16, addrIPv4 Nullable(IPv4), addrIPv6 Nullable(IPv6), upstream_connect_time Float32, upstream_header_time Float32, upstream_response_time Float32 ) ENGINE MergeTree PRIMARY KEY reqid ORDER BY reqid CREATE TABLE IF NOT EXISTS logs.logfiles ( filename String ) ENGINE MergeTree PRIMARY KEY filename ORDER BY filename

Si observa más de cerca la declaración CREATE TABLE , puede ver tipos ligeramente diferentes y tipos completamente nuevos como Enum e IPv4. ClickHouse intenta reducir el uso de recursos y, para ello, lo optimiza con funciones interesantes como Enum. Es básicamente una asignación clave-valor de una cadena a un int de 8 bits o 16 bits, que se convierte automáticamente al insertarlo, convierte el valor de la cadena a int y, al seleccionarlo, se convierte en el sentido opuesto ( enlace ).

IPv4, IPv6 son los tipos especiales para almacenar direcciones de la manera más óptima (como unsigned int) y representarlas de una manera legible por humanos, por lo que básicamente en el momento de la inserción usted proporciona una representación de cadena de IP-addr y ClickHouse hace todo para usted: lo almacena como int y el servidor lo descomprime al seleccionarlo.

Inserción de registros

La ideología de ClickHouse es insertar rápido. Para ello, ClickHouse maneja las inserciones por lotes mejor que una por una.

Entonces el script de inserción no es muy complicado. La función readFile produce fragmentos de datos de 50.000 registros como máximo para que el cliente ClickHouse los inserte. Cada elemento de fragmento representa la lista de valores relativos a los nombres de las columnas en la lista de columnas .

 # it's not an actual code. # the working implementation you can find at https://github.com/bp72/nginxlogprocessor import clickhouse_connect from config import CLICKHOUSE_HOST, CLICKHOUSE_PORT from log import log client = clickhouse_connect.get_client(host=CLICKHOUSE_HOST, port=CLICKHOUSE_PORT) def loadToClickHouse(client, chunk): cols = [ 'reqid', 'ts', 'level', 'domain', 'uri', 'ua', 'ref', 'is_bot', 'is_mobile', 'is_tablet', 'is_pc', 'client', 'duration', 'response_code', 'addrIPv4', 'addrIPv6', 'upstream_connect_time', 'upstream_header_time', 'upstream_response_time', ] client.insert('nginx.access', chunk, column_names=cols) def processFeed(feed, client, chunk_size=10_000): total = 0 for chunk in readFile(feed, chunk_size=chunk_size): total += len(chunk) loadToClickHouse(client, chunk=chunk) log.info(f'process {feed=} inserted={len(chunk)} {total=}')

La ejecución y el tiempo reales que tengo en mi PC, puede ver que el análisis y la inserción del archivo de registros de 800k tomó 21 segundos de tiempo de ejecución de Python. ¡Nada mal!

 > .venv/bin/python ./main.py I:2023-10-15 12:44:02 [18764] f=transport.py:1893 Connected (version 2.0, client OpenSSH_8.9p1) I:2023-10-15 12:44:02 [18764] f=transport.py:1893 Authentication (publickey) successful! I:2023-10-15 12:44:02 [18764] f=fetcher.py:14 connect host='*.*.*.*' port=22 user='root' password=None I:2023-10-15 12:44:02 [18764] f=fetcher.py:18 run cmd='ls /var/log/nginx/*access*.log-*' I:2023-10-15 12:44:02 [18764] f=fetcher.py:34 download src=/var/log/nginx/access.log-2023100812.gz dst=/tmp/access.log-2023100812.gz I:2023-10-15 12:44:07 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=50000 I:2023-10-15 12:44:08 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=100000 I:2023-10-15 12:44:10 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=150000 I:2023-10-15 12:44:11 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=200000 I:2023-10-15 12:44:13 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=250000 I:2023-10-15 12:44:14 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=300000 I:2023-10-15 12:44:15 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=350000 I:2023-10-15 12:44:17 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=400000 I:2023-10-15 12:44:18 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=450000 I:2023-10-15 12:44:20 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=500000 I:2023-10-15 12:44:21 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=550000 I:2023-10-15 12:44:23 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=600000 I:2023-10-15 12:44:24 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=650000 I:2023-10-15 12:44:25 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=700000 I:2023-10-15 12:44:27 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=750000 I:2023-10-15 12:44:28 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=50000 total=800000 I:2023-10-15 12:44:28 [18764] f=main.py:20 process feed='/tmp/access.log-2023100812.gz' inserted=2190 total=802190 I:2023-10-15 12:44:28 [18764] f=fetcher.py:34 download src=/var/log/nginx/access.log-2023100814.gz dst=/tmp/access.log-2023100814.gz I:2023-10-15 12:44:31 [18764] f=main.py:20 process feed='/tmp/access.log-2023100814.gz' inserted=50000 total=50000 I:2023-10-15 12:44:32 [18764] f=main.py:20 process feed='/tmp/access.log-2023100814.gz' inserted=50000 total=100000 I:2023-10-15 12:44:33 [18764] f=main.py:20 process feed='/tmp/access.log-2023100814.gz' inserted=30067 total=130067

Análisis de registros y detección de problemas.

ClickHouse utiliza SQL para consultar la base de datos, lo cual resulta muy cómodo para la mayoría de los ingenieros de software e intuitivamente simple.

Comencemos por verificar la cantidad de registros que tenemos, son 22 millones.

 a8c8da069d94 :) select count(1) from nginx.access; SELECT count(1) FROM nginx.access Query id: f94881f3-2a7d-4039-9646-a6f614adb46c ┌──count()─┐ │ 22863822 │ └──────────┘

Es fácil tener consultas con diferentes desgloses, lo que podría ser útil para la detección y solución de problemas; por ejemplo, me gustaría saber desde qué dirección IP se analiza el host en busca de vulnerabilidades.

Esta consulta demuestra cómo las consultas de datos flexibles se pueden comparar con ELK. CON .. COM declaración y IN / NOT IN, subconsulta, agregación y filtración hacen que ClickHouse sea muy conveniente.

 a8c8da069d94 :) with baduri as (select uri, count(1) from nginx.access where response_code = 404 and uri not in ('/about/', '/favicon.ico') group by 1 having count(1) > 3 order by 2 desc limit 10) select IPv4NumToStringClassC(addrIPv4), count(1) from nginx.access where uri in (select uri from baduri) and addrIPv4 is not null group by 1 order by 2 desc limit 5 WITH baduri AS ( SELECT uri, count(1) FROM nginx.access WHERE (response_code = 404) AND (uri NOT IN ('/about/', '/favicon.ico')) GROUP BY 1 HAVING count(1) > 3 ORDER BY 2 DESC LIMIT 10 ) SELECT IPv4NumToStringClassC(addrIPv4), count(1) FROM nginx.access WHERE (uri IN ( SELECT uri FROM baduri )) AND (addrIPv4 IS NOT NULL) GROUP BY 1 ORDER BY 2 DESC LIMIT 5 Query id: cf9bea33-212b-4c58-b6af-8e0aaae50b83 ┌─IPv4NumToStringClassC(addrIPv4)─┬─count()─┐ │ 8.219.64.xxx │ 961 │ │ 178.128.220.xxx │ 378 │ │ 103.231.78.xxx │ 338 │ │ 157.245.200.xxx │ 324 │ │ 116.203.28.xxx │ 260 │ └─────────────────────────────────┴─────────┘ 5 rows in set. Elapsed: 0.150 sec. Processed 45.73 million rows, 1.81 GB (303.88 million rows/s., 12.01 GB/s.) Peak memory usage: 307.49 MiB.

Obtengamos los 5 uri más populares por dominio. Esta consulta utiliza la práctica función LIMIT x BY <campo>.

 a8c8da069d94 :) select domain, uri, count(1) from nginx.access where domain in ('example.com', 'nestfromthebest.com', 'az.org') group by 1, 2 order by 1, 3 desc limit 5 by domain SELECT domain, uri, count(1) FROM nginx.access WHERE domain IN ('example.com', 'nestfromthebest.com', 'az.org') GROUP BY 1, 2 ORDER BY 1 ASC, 3 DESC LIMIT 5 BY domain Query id: 2acd328c-ed82-4d36-916b-8f2ecf764a9d ┌─domain──────┬─uri────────────┬─count()─┐ │ az.org │ /about/ │ 382543 │ │ az.org │ /contacts/ │ 42066 │ │ az.org │ /category/id7 │ 2722 │ │ az.org │ /category/id14 │ 2704 │ │ az.org │ /category/id2 │ 2699 │ │ example.com │ /about/ │ 381653 │ │ example.com │ /contacts/ │ 42023 │ │ example.com │ /category/id2 │ 2694 │ │ example.com │ /category/id8 │ 2688 │ │ example.com │ /category/id13 │ 2670 │ └─────────────┴────────────────┴─────────┘ ┌─domain──────────────┬─uri────────────┬─count()─┐ │ nestfromthebest.com │ /about/ │ 383377 │ │ nestfromthebest.com │ /contacts/ │ 42100 │ │ nestfromthebest.com │ /category/id8 │ 2726 │ │ nestfromthebest.com │ /category/id14 │ 2700 │ │ nestfromthebest.com │ /category/id4 │ 2696 │ └─────────────────────┴────────────────┴─────────┘ 15 rows in set. Elapsed: 0.062 sec. Processed 23.97 million rows, 918.43 MB (388.35 million rows/s., 14.88 GB/s.) Peak memory usage: 98.67 MiB.

Conclusión

ClickHouse es una gran herramienta para almacenar y manipular datos específicos, como registros, a gran escala. Definitivamente vale la pena aprender más y comprender, por ejemplo, la estructura de datos anidados, las herramientas de muestreo, las funciones de ventana y otros.

¡Espero que hayas disfrutado de este pequeño artículo y te haya resultado útil!