Envío de registros json de Nginx usando Vector a Clickhouse y Elasticsearch

vector, diseñado para recopilar, transformar y enviar datos de registro, métricas y eventos.

→ Github

Al estar escrito en lenguaje Rust, se caracteriza por un alto rendimiento y un bajo consumo de RAM en comparación con sus análogos. Además, se presta mucha atención a las funciones relacionadas con la corrección, en particular, la capacidad de guardar eventos no enviados en un búfer del disco y rotar archivos.

Arquitectónicamente, Vector es un enrutador de eventos que recibe mensajes de uno o más de fuentes, aplicándose opcionalmente sobre estos mensajes transformacionesy enviarlos a uno o más desagües.

Vector es un reemplazo de filebeat y logstash, puede actuar en ambos roles (recibir y enviar registros), más detalles sobre ellos sitio web.

Si en Logstash la cadena se construye como entrada → filtro → salida, entonces en Vector es fuentes → transformadas → sumideros

Se pueden encontrar ejemplos en la documentación.

Esta instrucción es una instrucción revisada de Viacheslav Rakhinsky. Las instrucciones originales contienen procesamiento geoip. Al probar geoip desde una red interna, vector dio un error.

Aug 05 06:25:31.889 DEBUG transform{name=nginx_parse_rename_fields type=rename_fields}: vector::transforms::rename_fields: Field did not exist field=«geoip.country_name» rate_limit_secs=30

Si alguien necesita procesar geoip, consulte las instrucciones originales de Viacheslav Rakhinsky.

Configuraremos la combinación de Nginx (Registros de acceso) → Vector (Cliente | Filebeat) → Vector (Servidor | Logstash) → por separado en Clickhouse y por separado en Elasticsearch. Instalaremos 4 servidores. Aunque puedes evitarlo con 3 servidores.

El esquema es algo como esto.

Deshabilite Selinux en todos sus servidores

sed -i 's/^SELINUX=.*/SELINUX=disabled/g' /etc/selinux/config
reboot

Instalamos un emulador de servidor HTTP + utilidades en todos los servidores.

Como emulador de servidor HTTP usaremos servidor-stub-nodejs de Máximo Ignatenko

Nodejs-stub-server no tiene rpm. es cree rpm para ello. rpm se construirá usando Copr de Fedora

Agregue el repositorio antonpatsev/nodejs-stub-server

yum -y install yum-plugin-copr epel-release
yes | yum copr enable antonpatsev/nodejs-stub-server

Instale nodejs-stub-server, Apache benchmark y screen terminal multiplexor en todos los servidores

yum -y install stub_http_server screen mc httpd-tools screen

Corregí el tiempo de respuesta de stub_http_server en el archivo /var/lib/stub_http_server/stub_http_server.js para que hubiera más registros.

var max_sleep = 10;

Iniciemos stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

instalación de clickhouse en el servidor 3

ClickHouse utiliza el conjunto de instrucciones SSE 4.2, por lo que, a menos que se especifique lo contrario, su compatibilidad en el procesador utilizado se convierte en un requisito adicional del sistema. Aquí está el comando para verificar si el procesador actual es compatible con SSE 4.2:

grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 supported" || echo "SSE 4.2 not supported"

Primero necesitas conectar el repositorio oficial:

sudo yum install -y yum-utils
sudo rpm --import https://repo.clickhouse.tech/CLICKHOUSE-KEY.GPG
sudo yum-config-manager --add-repo https://repo.clickhouse.tech/rpm/stable/x86_64

Para instalar paquetes necesita ejecutar los siguientes comandos:

sudo yum install -y clickhouse-server clickhouse-client

Permita que clickhouse-server escuche la tarjeta de red en el archivo /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Cambiar el nivel de registro de seguimiento a depuración

depurar

Configuraciones de compresión estándar:

min_compress_block_size  65536
max_compress_block_size  1048576

Para activar la compresión Zstd, se recomendó no tocar la configuración, sino usar DDL.

No pude encontrar cómo usar la compresión zstd a través de DDL en Google. Así que lo dejé como está.

Colegas que usan la compresión zstd en Clickhouse, compartan las instrucciones.

Para iniciar el servidor como demonio, ejecute:

service clickhouse-server start

Ahora pasemos a configurar Clickhouse.

Ir a Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP del servidor donde está instalado Clickhouse.

Creemos una base de datos vectorial.

CREATE DATABASE vector;

Comprobemos que la base de datos existe.

show databases;

Cree una tabla vector.logs.

/* Это таблица где хранятся логи как есть */

CREATE TABLE vector.logs
(
    `node_name` String,
    `timestamp` DateTime,
    `server_name` String,
    `user_id` String,
    `request_full` String,
    `request_user_agent` String,
    `request_http_host` String,
    `request_uri` String,
    `request_scheme` String,
    `request_method` String,
    `request_length` UInt64,
    `request_time` Float32,
    `request_referrer` String,
    `response_status` UInt16,
    `response_body_bytes_sent` UInt64,
    `response_content_type` String,
    `remote_addr` IPv4,
    `remote_port` UInt32,
    `remote_user` String,
    `upstream_addr` IPv4,
    `upstream_port` UInt32,
    `upstream_bytes_received` UInt64,
    `upstream_bytes_sent` UInt64,
    `upstream_cache_status` String,
    `upstream_connect_time` Float32,
    `upstream_header_time` Float32,
    `upstream_response_length` UInt64,
    `upstream_response_time` Float32,
    `upstream_status` UInt16,
    `upstream_content_type` String,
    INDEX idx_http_host request_http_host TYPE set(0) GRANULARITY 1
)
ENGINE = MergeTree()
PARTITION BY toYYYYMMDD(timestamp)
ORDER BY timestamp
TTL timestamp + toIntervalMonth(1)
SETTINGS index_granularity = 8192;

Comprobamos que las tablas han sido creadas. vamos a lanzar clickhouse-client y hacer una solicitud.

Vayamos a la base de datos de vectores.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Miremos las tablas.

show tables;

┌─name────────────────┐
│ logs                │
└─────────────────────┘

Instalar elasticsearch en el cuarto servidor para enviar los mismos datos a Elasticsearch para compararlos con Clickhouse

Agregar una clave rpm pública

rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Creemos 2 repositorios:

/etc/yum.repos.d/elasticsearch.repo

[elasticsearch]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md

/etc/yum.repos.d/kibana.repo

[kibana-7.x]
name=Kibana repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

Instalar elasticsearch y kibana

yum install -y kibana elasticsearch

Dado que estará en 1 copia, debe agregar lo siguiente al archivo /etc/elasticsearch/elasticsearch.yml:

discovery.type: single-node

Para que ese vector pueda enviar datos a elasticsearch desde otro servidor, cambiemos network.host.

network.host: 0.0.0.0

Para conectarse a kibana, cambie el parámetro server.host en el archivo /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Antiguo e incluye elasticsearch en el inicio automático

systemctl enable elasticsearch
systemctl start elasticsearch

y kibana

systemctl enable kibana
systemctl start kibana

Configuración de Elasticsearch para modo de nodo único 1 fragmento, 0 réplica. Lo más probable es que tenga un clúster de una gran cantidad de servidores y no es necesario que haga esto.

Para índices futuros, actualice la plantilla predeterminada:

curl -X PUT http://localhost:9200/_template/default -H 'Content-Type: application/json' -d '{"index_patterns": ["*"],"order": -1,"settings": {"number_of_shards": "1","number_of_replicas": "0"}}' 

Instalación vector como reemplazo de Logstash en el servidor 2

yum install -y https://packages.timber.io/vector/0.9.X/vector-x86_64.rpm mc httpd-tools screen

Configuremos Vector como reemplazo de Logstash. Editando el archivo /etc/vector/vector.toml

# /etc/vector/vector.toml

data_dir = "/var/lib/vector"

[sources.nginx_input_vector]
  # General
  type                          = "vector"
  address                       = "0.0.0.0:9876"
  shutdown_timeout_secs         = 30

[transforms.nginx_parse_json]
  inputs                        = [ "nginx_input_vector" ]
  type                          = "json_parser"

[transforms.nginx_parse_add_defaults]
  inputs                        = [ "nginx_parse_json" ]
  type                          = "lua"
  version                       = "2"

  hooks.process = """
  function (event, emit)

    function split_first(s, delimiter)
      result = {};
      for match in (s..delimiter):gmatch("(.-)"..delimiter) do
          table.insert(result, match);
      end
      return result[1];
    end

    function split_last(s, delimiter)
      result = {};
      for match in (s..delimiter):gmatch("(.-)"..delimiter) do
          table.insert(result, match);
      end
      return result[#result];
    end

    event.log.upstream_addr             = split_first(split_last(event.log.upstream_addr, ', '), ':')
    event.log.upstream_bytes_received   = split_last(event.log.upstream_bytes_received, ', ')
    event.log.upstream_bytes_sent       = split_last(event.log.upstream_bytes_sent, ', ')
    event.log.upstream_connect_time     = split_last(event.log.upstream_connect_time, ', ')
    event.log.upstream_header_time      = split_last(event.log.upstream_header_time, ', ')
    event.log.upstream_response_length  = split_last(event.log.upstream_response_length, ', ')
    event.log.upstream_response_time    = split_last(event.log.upstream_response_time, ', ')
    event.log.upstream_status           = split_last(event.log.upstream_status, ', ')

    if event.log.upstream_addr == "" then
        event.log.upstream_addr = "127.0.0.1"
    end

    if (event.log.upstream_bytes_received == "-" or event.log.upstream_bytes_received == "") then
        event.log.upstream_bytes_received = "0"
    end

    if (event.log.upstream_bytes_sent == "-" or event.log.upstream_bytes_sent == "") then
        event.log.upstream_bytes_sent = "0"
    end

    if event.log.upstream_cache_status == "" then
        event.log.upstream_cache_status = "DISABLED"
    end

    if (event.log.upstream_connect_time == "-" or event.log.upstream_connect_time == "") then
        event.log.upstream_connect_time = "0"
    end

    if (event.log.upstream_header_time == "-" or event.log.upstream_header_time == "") then
        event.log.upstream_header_time = "0"
    end

    if (event.log.upstream_response_length == "-" or event.log.upstream_response_length == "") then
        event.log.upstream_response_length = "0"
    end

    if (event.log.upstream_response_time == "-" or event.log.upstream_response_time == "") then
        event.log.upstream_response_time = "0"
    end

    if (event.log.upstream_status == "-" or event.log.upstream_status == "") then
        event.log.upstream_status = "0"
    end

    emit(event)

  end
  """

[transforms.nginx_parse_remove_fields]
    inputs                              = [ "nginx_parse_add_defaults" ]
    type                                = "remove_fields"
    fields                              = ["data", "file", "host", "source_type"]

[transforms.nginx_parse_coercer]

    type                                = "coercer"
    inputs                              = ["nginx_parse_remove_fields"]

    types.request_length = "int"
    types.request_time = "float"

    types.response_status = "int"
    types.response_body_bytes_sent = "int"

    types.remote_port = "int"

    types.upstream_bytes_received = "int"
    types.upstream_bytes_send = "int"
    types.upstream_connect_time = "float"
    types.upstream_header_time = "float"
    types.upstream_response_length = "int"
    types.upstream_response_time = "float"
    types.upstream_status = "int"

    types.timestamp = "timestamp"

[sinks.nginx_output_clickhouse]
    inputs   = ["nginx_parse_coercer"]
    type     = "clickhouse"

    database = "vector"
    healthcheck = true
    host = "http://172.26.10.109:8123" #  Адрес Clickhouse
    table = "logs"

    encoding.timestamp_format = "unix"

    buffer.type = "disk"
    buffer.max_size = 104900000
    buffer.when_full = "block"

    request.in_flight_limit = 20

[sinks.elasticsearch]
    type = "elasticsearch"
    inputs   = ["nginx_parse_coercer"]
    compression = "none"
    healthcheck = true
    # 172.26.10.116 - сервер где установен elasticsearch
    host = "http://172.26.10.116:9200" 
    index = "vector-%Y-%m-%d"

Puede ajustar la sección transforms.nginx_parse_add_defaults.

desde Viacheslav Rakhinsky usa estas configuraciones para una CDN pequeña y puede haber varios valores en upstream_*

Por ejemplo:

"upstream_addr": "128.66.0.10:443, 128.66.0.11:443, 128.66.0.12:443"
"upstream_bytes_received": "-, -, 123"
"upstream_status": "502, 502, 200"

Si esta no es tu situación, entonces esta sección se puede simplificar.

Creemos configuraciones de servicio para systemd /etc/systemd/system/vector.service

# /etc/systemd/system/vector.service

[Unit]
Description=Vector
After=network-online.target
Requires=network-online.target

[Service]
User=vector
Group=vector
ExecStart=/usr/bin/vector
ExecReload=/bin/kill -HUP $MAINPID
Restart=no
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=vector

[Install]
WantedBy=multi-user.target

Después de crear las tablas, puede ejecutar Vector

systemctl enable vector
systemctl start vector

Los registros vectoriales se pueden ver así:

journalctl -f -u vector

Debería haber entradas como esta en los registros.

INFO vector::topology::builder: Healthcheck: Passed.
INFO vector::topology::builder: Healthcheck: Passed.

En el cliente (servidor web) - 1er servidor

En el servidor con nginx, debe deshabilitar ipv6, ya que la tabla de registros en clickhouse usa el campo upstream_addr IPv4, ya que no uso ipv6 dentro de la red. Si ipv6 no está desactivado, habrá errores:

DB::Exception: Invalid IPv4 value.: (while read the value of key upstream_addr)

Quizás lectores, agreguen soporte para ipv6.

Cree el archivo /etc/sysctl.d/98-disable-ipv6.conf

net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1

Aplicar la configuración

sysctl --system

Instalemos nginx.

Se agregó el archivo de repositorio nginx /etc/yum.repos.d/nginx.repo

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Instalar el paquete nginx

yum install -y nginx

Primero, necesitamos configurar el formato de registro en Nginx en el archivo /etc/nginx/nginx.conf

user  nginx;
# you must set worker processes based on your CPU cores, nginx does not benefit from setting more than that
worker_processes auto; #some last versions calculate it automatically

# number of file descriptors used for nginx
# the limit for the maximum FDs on the server is usually set by the OS.
# if you don't set FD's then OS settings will be used which is by default 2000
worker_rlimit_nofile 100000;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

# provides the configuration file context in which the directives that affect connection processing are specified.
events {
    # determines how much clients will be served per worker
    # max clients = worker_connections * worker_processes
    # max clients is also limited by the number of socket connections available on the system (~64k)
    worker_connections 4000;

    # optimized to serve many clients with each thread, essential for linux -- for testing environment
    use epoll;

    # accept as many connections as possible, may flood worker connections if set too low -- for testing environment
    multi_accept on;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

log_format vector escape=json
    '{'
        '"node_name":"nginx-vector",'
        '"timestamp":"$time_iso8601",'
        '"server_name":"$server_name",'
        '"request_full": "$request",'
        '"request_user_agent":"$http_user_agent",'
        '"request_http_host":"$http_host",'
        '"request_uri":"$request_uri",'
        '"request_scheme": "$scheme",'
        '"request_method":"$request_method",'
        '"request_length":"$request_length",'
        '"request_time": "$request_time",'
        '"request_referrer":"$http_referer",'
        '"response_status": "$status",'
        '"response_body_bytes_sent":"$body_bytes_sent",'
        '"response_content_type":"$sent_http_content_type",'
        '"remote_addr": "$remote_addr",'
        '"remote_port": "$remote_port",'
        '"remote_user": "$remote_user",'
        '"upstream_addr": "$upstream_addr",'
        '"upstream_bytes_received": "$upstream_bytes_received",'
        '"upstream_bytes_sent": "$upstream_bytes_sent",'
        '"upstream_cache_status":"$upstream_cache_status",'
        '"upstream_connect_time":"$upstream_connect_time",'
        '"upstream_header_time":"$upstream_header_time",'
        '"upstream_response_length":"$upstream_response_length",'
        '"upstream_response_time":"$upstream_response_time",'
        '"upstream_status": "$upstream_status",'
        '"upstream_content_type":"$upstream_http_content_type"'
    '}';

    access_log  /var/log/nginx/access.log  main;
    access_log  /var/log/nginx/access.json.log vector;      # Новый лог в формате json

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

Para no romper su configuración actual, Nginx le permite tener varias directivas access_log

access_log  /var/log/nginx/access.log  main;            # Стандартный лог
access_log  /var/log/nginx/access.json.log vector;      # Новый лог в формате json

No olvide agregar una regla a logrotate para registros nuevos (si el archivo de registro no termina en .log)

Eliminar default.conf de /etc/nginx/conf.d/

rm -f /etc/nginx/conf.d/default.conf

Agregar host virtual /etc/nginx/conf.d/vhost1.conf

server {
    listen 80;
    server_name vhost1;
    location / {
        proxy_pass http://172.26.10.106:8080;
    }
}

Agregar host virtual /etc/nginx/conf.d/vhost2.conf

server {
    listen 80;
    server_name vhost2;
    location / {
        proxy_pass http://172.26.10.108:8080;
    }
}

Agregar host virtual /etc/nginx/conf.d/vhost3.conf

server {
    listen 80;
    server_name vhost3;
    location / {
        proxy_pass http://172.26.10.109:8080;
    }
}

Agregar host virtual /etc/nginx/conf.d/vhost4.conf

server {
    listen 80;
    server_name vhost4;
    location / {
        proxy_pass http://172.26.10.116:8080;
    }
}

Agregue hosts virtuales (172.26.10.106 ip del servidor donde está instalado nginx) a todos los servidores en el archivo /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Y si todo está listo entonces

nginx -t 
systemctl restart nginx

Ahora instalémoslo nosotros mismos. vector

yum install -y https://packages.timber.io/vector/0.9.X/vector-x86_64.rpm

Creemos un archivo de configuración para systemd /etc/systemd/system/vector.service

[Unit]
Description=Vector
After=network-online.target
Requires=network-online.target

[Service]
User=vector
Group=vector
ExecStart=/usr/bin/vector
ExecReload=/bin/kill -HUP $MAINPID
Restart=no
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=vector

[Install]
WantedBy=multi-user.target

Y configure el reemplazo de Filebeat en la configuración /etc/vector/vector.toml. La dirección IP 172.26.10.108 es la dirección IP del servidor de registro (Vector-Server)

data_dir = "/var/lib/vector"

[sources.nginx_file]
  type                          = "file"
  include                       = [ "/var/log/nginx/access.json.log" ]
  start_at_beginning            = false
  fingerprinting.strategy       = "device_and_inode"

[sinks.nginx_output_vector]
  type                          = "vector"
  inputs                        = [ "nginx_file" ]

  address                       = "172.26.10.108:9876"

No olvide agregar el usuario del vector al grupo requerido para que pueda leer los archivos de registro. Por ejemplo, nginx en centos crea registros con derechos de grupo adm.

usermod -a -G adm vector

Comencemos el servicio de vectores.

systemctl enable vector
systemctl start vector

Los registros vectoriales se pueden ver así:

journalctl -f -u vector

Debería haber una entrada como esta en los registros.

INFO vector::topology::builder: Healthcheck: Passed.

Pruebas de estrés

Realizamos pruebas utilizando el benchmark Apache.

El paquete httpd-tools se instaló en todos los servidores.

Comenzamos las pruebas usando el benchmark Apache desde 4 servidores diferentes en pantalla. Primero, iniciamos el multiplexor del terminal de pantalla y luego comenzamos a realizar pruebas utilizando el punto de referencia de Apache. Cómo trabajar con la pantalla lo puedes encontrar en статье.

Del 1er servidor

while true; do ab -H "User-Agent: 1server" -c 100 -n 10 -t 10 http://vhost1/; sleep 1; done

Del 2er servidor

while true; do ab -H "User-Agent: 2server" -c 100 -n 10 -t 10 http://vhost2/; sleep 1; done

Del 3er servidor

while true; do ab -H "User-Agent: 3server" -c 100 -n 10 -t 10 http://vhost3/; sleep 1; done

Del 4er servidor

while true; do ab -H "User-Agent: 4server" -c 100 -n 10 -t 10 http://vhost4/; sleep 1; done

Comprobemos los datos en Clickhouse

Ir a Clickhouse

clickhouse-client -h 172.26.10.109 -m

Hacer una consulta SQL

SELECT * FROM vector.logs;

┌─node_name────┬───────────timestamp─┬─server_name─┬─user_id─┬─request_full───┬─request_user_agent─┬─request_http_host─┬─request_uri─┬─request_scheme─┬─request_method─┬─request_length─┬─request_time─┬─request_referrer─┬─response_status─┬─response_body_bytes_sent─┬─response_content_type─┬───remote_addr─┬─remote_port─┬─remote_user─┬─upstream_addr─┬─upstream_port─┬─upstream_bytes_received─┬─upstream_bytes_sent─┬─upstream_cache_status─┬─upstream_connect_time─┬─upstream_header_time─┬─upstream_response_length─┬─upstream_response_time─┬─upstream_status─┬─upstream_content_type─┐
│ nginx-vector │ 2020-08-07 04:32:42 │ vhost1      │         │ GET / HTTP/1.0 │ 1server            │ vhost1            │ /           │ http           │ GET            │             66 │        0.028 │                  │             404 │                       27 │                       │ 172.26.10.106 │       45886 │             │ 172.26.10.106 │             0 │                     109 │                  97 │ DISABLED              │                     0 │                0.025 │                       27 │                  0.029 │             404 │                       │
└──────────────┴─────────────────────┴─────────────┴─────────┴────────────────┴────────────────────┴───────────────────┴─────────────┴────────────────┴────────────────┴────────────────┴──────────────┴──────────────────┴─────────────────┴──────────────────────────┴───────────────────────┴───────────────┴─────────────┴─────────────┴───────────────┴───────────────┴─────────────────────────┴─────────────────────┴───────────────────────┴───────────────────────┴──────────────────────┴──────────────────────────┴────────────────────────┴─────────────────┴───────────────────────

Descubre el tamaño de las mesas en Clickhouse

select concat(database, '.', table)                         as table,
       formatReadableSize(sum(bytes))                       as size,
       sum(rows)                                            as rows,
       max(modification_time)                               as latest_modification,
       sum(bytes)                                           as bytes_size,
       any(engine)                                          as engine,
       formatReadableSize(sum(primary_key_bytes_in_memory)) as primary_keys_size
from system.parts
where active
group by database, table
order by bytes_size desc;

Averigüemos cuántos registros ocuparon en Clickhouse.

El tamaño de la tabla de registros es 857.19 MB.

El tamaño de los mismos datos en el índice en Elasticsearch es de 4,5 GB.

Si no especifica datos en el vector en los parámetros, Clickhouse toma 4500/857.19 = 5.24 veces menos que en Elasticsearch.

En vector, el campo de compresión se utiliza de forma predeterminada.

Chat de Telegram por casa de clic
Chat de Telegram por Elasticsearch
Chat de Telegram por "Recopilación y análisis del sistema. publicaciones"

Fuente: habr.com