Invio dei log json di Nginx utilizzando Vector in Clickhouse ed Elasticsearch

Vector, progettata per raccogliere, trasformare e inviare dati di log, metriche ed eventi.

→ Github

Scritta in Rust, offre elevate prestazioni e un basso consumo di memoria rispetto ai concorrenti. Inoltre, è prestata particolare attenzione alle funzionalità relative all'accuratezza, in particolare alla possibilità di memorizzare eventi non inviati in un buffer su disco e alla rotazione dei file.

Architettonicamente, Vector è un router di eventi che accetta messaggi da una o più sorgenti, applicando facoltativamente su questi messaggi trasformazioni, e inviandoli a uno o più sink.

Vector è un'alternativa a filebeat e logstash, può svolgere entrambi i ruoli (ricevere e inviare log), maggiori dettagli sui loro sito.

Se in Logstash la catena è costruita come input → filter → output, in Vector è sources → trasformazioni → sinks

Esempi possono essere visti nella documentazione.

Questa è un'istruzione rielaborata di Vyacheslav Rakhinskiy. Nell'istruzione originale è prevista la gestione di geoip. Durante il test del geoip dalla rete interna, Vector restituisce un errore.

05 ago 06:25:31.889 DEBUG transform{name=nginx_parse_rename_fields type=rename_fields}: vector::transforms::rename_fields: Il campo non esisteva field=«geoip.country_name» rate_limit_secs=30

Se qualcuno ha bisogno di elaborare geoip, si prega di consultare le istruzioni originali di Vyacheslav Rakhinskiy.

Stiamo configurando la catena Nginx (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → separatamente in Clickhouse e separatamente in Elasticsearch. Installeremo 4 server. Anche se si può fare con 3 server.

Lo schema è approssimativamente così.

Disabilitiamo Selinux su tutti i vostri server

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

Su tutti i server installiamo un emulatore del server HTTP + utilità

Utilizzeremo come emulatore di server HTTP nodejs-stub-server da Maxim Ignatenko

Nodejs-stub-server non ha rpm. Qui creiamo il suo rpm. La creazione dell'rpm avverrà tramite Fedora Copr

Aggiungiamo il repository antonpatsev/nodejs-stub-server

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

Installa nodejs-stub-server, Apache benchmark e il multiplexor terminale screen su tutti i server

yum -y install stub_http_server screen mc httpd-tools screen

Ho corretto nel file /var/lib/stub_http_server/stub_http_server.js il tempo di risposta del stub_http_server per avere più log.

var max_sleep = 10;

Avviamo stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Installazione di Clickhouse sul 3° server

ClickHouse utilizza un set di istruzioni SSE 4.2, quindi, a meno che non sia diversamente specificato, il supporto nel processore utilizzato diventa un requisito aggiuntivo per il sistema. Ecco il comando per verificare se l'attuale processore supporta SSE 4.2:

grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 supportato" || echo "SSE 4.2 non supportato"

Per prima cosa, bisogna abilitare il repository ufficiale:

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

Per installare i pacchetti, eseguire i seguenti comandi:

sudo yum install -y clickhouse-server clickhouse-client

Consenti a clickhouse-server di ascoltare la scheda di rete nel file /etc/clickhouse-server/config.xml

0.0.0.0

Cambia il livello di logging da trace a debug

debug

Le impostazioni di compressione sono standard:

min_compress_block_size  65536
max_compress_block_size  1048576

Per attivare la compressione Zstd è consigliato non modificare la configurazione, ma utilizzare DDL.

Non ho trovato su Google come applicare la compressione zstd tramite DDL. Quindi l'ho lasciato così com'è.

Colleghi, chi utilizza la compressione zstd in Clickhouse — per favore condividete le istruzioni.

Per avviare il server come demone, eseguire:

service clickhouse-server start

Ora passiamo alla configurazione di Clickhouse

Accediamo a Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP del server dove è installato Clickhouse.

Creiamo il database vector

CREATE DATABASE vector;

Verifichiamo che il database esista.

show databases;

Creiamo la tabella 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;

Verifichiamo che siano state create le tabelle. Avviamo clickhouse-client e facciamo la richiesta.

Passiamo al database vector.

use vector;

Ok.

0 righe nel set. Tempo trascorso: 0.001 sec.

Controlliamo le tabelle.

show tables;

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

Installazione di elasticsearch sul quarto server per inviare gli stessi dati a Elasticsearch per il confronto con Clickhouse

Aggiungiamo la chiave pubblica rpm

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

Creiamo 2 repository:

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

[elasticsearch]
name=Repository di Elasticsearch per pacchetti 7.x
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=Repository di Kibana per pacchetti 7.x
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

Installeremo elasticsearch e kibana

yum install -y kibana elasticsearch

Poiché ci sarà in un'unica istanza, nel file /etc/elasticsearch/elasticsearch.yml è necessario aggiungere:

discovery.type: single-node

Per consentire a vector di inviare dati a elasticsearch da un altro server, modifichiamo network.host.

network.host: 0.0.0.0

Per collegarci a kibana, modifichiamo il parametro server.host nel file /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Avviamo e attiviamo elasticsearch all'avvio automatico

systemctl enable elasticsearch
systemctl start elasticsearch

e kibana

systemctl enable kibana
systemctl start kibana

Configurazione di Elasticsearch per la modalità single-node con 1 shard e 0 repliche. Probabilmente avrete un cluster di molti server e non dovrete fare questo.

Per i futuri indici, aggiorniamo il modello predefinito:

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"}}' 

Installazione Vector come sostituzione di Logstash su 2 server

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

Configuriamo Vector come sostituzione di Logstash. Modifichiamo il file /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"

Potete modificare la sezione transforms.nginx_parse_add_defaults.

Poiché Vyacheslav Rakhinsky usa queste configurazioni per un piccolo CDN e lì in upstream_* possono arrivare più valori

Ad esempio:

"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"

Se questa non è la vostra situazione, potete semplificare questa sezione

Creiamo le impostazioni del servizio per 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

Dopo aver creato le tabelle, potete avviare Vector

systemctl enable vector
systemctl start vector

I log di vector possono essere visualizzati così

journalctl -f -u vector

Nei log dovrebbero esserci tali registrazioni

INFO vector::topology::builder: Controllo di salute: Superato.
INFO vector::topology::builder: Controllo di salute: Superato.

Sul client (Web server) — primo server

Sul server con nginx è necessario disabilitare ipv6, poiché nella tabella logs in clickhouse viene utilizzato il campo upstream_addr IPv4, poiché non utilizzo ipv6 all'interno della rete. Se non disabiliti ipv6, si genereranno errori:

DB::Exception: Valore IPv4 non valido.: (mentre si legge il valore della chiave upstream_addr)

Forse i lettori, aggiungete supporto per ipv6.

Creiamo il file /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

Applichiamo le impostazioni

sysctl --system

Installeremo nginx.

Aggiunto il file del repository 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

Installeremo il pacchetto nginx

yum install -y nginx

Per iniziare, dobbiamo configurare il formato dei log in Nginx nel file /etc/nginx/nginx.conf

user  nginx;
# è necessario impostare i processi worker in base ai core della CPU, nginx non trae vantaggio dall'impostare più di così
worker_processes auto; # alcune ultime versioni lo calcolano automaticamente

# numero di file descriptor utilizzati per nginx
# il limite massimo di FDs sul server è di solito imposto dal sistema operativo.
# se non imposti i FD, le impostazioni del sistema operativo verranno utilizzate, che per impostazione predefinita è 2000
worker_rlimit_nofile 100000;

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

# fornisce il contesto del file di configurazione in cui vengono specificate le direttive che influenzano l'elaborazione delle connessioni.
events {
    # determina quanti clienti verranno serviti per worker
    # max clienti = worker_connections * worker_processes
    # il numero massimo di clienti è anche limitato dal numero di connessioni socket disponibili sul sistema (~64k)
    worker_connections 4000;

    # ottimizzato per servire molti clienti con ogni thread, essenziale per linux -- per ambiente di test
    use epoll;

    # accetta il maggior numero possibile di connessioni, potrebbe allagare le connessioni worker se impostato troppo basso -- per ambiente di test
    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;      # Nuovo log in formato json

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

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

Per non compromettere la tua attuale configurazione, Nginx consente di avere più direttive access_log

access_log  /var/log/nginx/access.log  main;            # Log standard
access_log  /var/log/nginx/access.json.log vector;      # Nuovo log in formato json

Non dimenticare di aggiungere una regola in logrotate per i nuovi log (se il file di log non termina con .log)

Rimuoviamo default.conf da /etc/nginx/conf.d/

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

Aggiungiamo l'host virtuale /etc/nginx/conf.d/vhost1.conf

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

Aggiungiamo l'host virtuale /etc/nginx/conf.d/vhost2.conf

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

Aggiungiamo l'host virtuale /etc/nginx/conf.d/vhost3.conf

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

Aggiungiamo l'host virtuale /etc/nginx/conf.d/vhost4.conf

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

Aggiungiamo nel file /etc/hosts gli host virtuali (172.26.10.106 è l'IP del server dove è installato nginx) su tutti i server:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

E se tutto è pronto allora

nginx -t 
systemctl restart nginx

Ora installeremo il software Vector

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

Creeremo il file di configurazione per 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

E configureremo la sostituzione di Filebeat nel file /etc/vector/vector.toml. L'indirizzo IP 172.26.10.108 è l'indirizzo IP del server log (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"

Non dimenticare di aggiungere l'utente vector al gruppo necessario affinché possa leggere i file di log. Ad esempio, nginx in centos crea i log con i diritti del gruppo adm.

usermod -a -G adm vector

Avviamo il servizio vector

systemctl enable vector
systemctl start vector

I log di vector possono essere visualizzati così

journalctl -f -u vector

Nei log dovrebbe esserci la seguente registrazione

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

Carico di test

Il test viene effettuato con Apache benchmark.

Il pacchetto httpd-tools è stato installato su tutti i server

Iniziamo il test utilizzando Apache benchmark da 4 diversi server in screen. Prima avviamo il multiplexer terminale screen, poi eseguiamo il test con Apache benchmark. Come lavorare con screen puoi trovare in articolo.

Dal 1° server

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

Dal 2° server

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

Dal server 3

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

Dal server 4

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

Verifichiamo i dati in Clickhouse

Accediamo a Clickhouse

clickhouse-client -h 172.26.10.109 -m

Facciamo una query SQL

SELEZIONA * DA 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 │                       │
└──────────────┴─────────────────────┴─────────────┴─────────┴────────────────┴────────────────────┴───────────────────┴─────────────┴────────────────┴────────────────┴────────────────┴──────────────┴──────────────────┴─────────────────┴──────────────────────────┴───────────────────────┴───────────────┴─────────────┴─────────────┴───────────────┴───────────────┴─────────────────────────┴─────────────────────┴───────────────────────┴───────────────────────┴──────────────────────┴──────────────────────────┴────────────────────────┴─────────────────┴───────────────────────

Scopriamo le dimensioni delle tabelle in 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;

Scopriamo quanto spazio occupano i log in Clickhouse.

La dimensione della tabella logs occupa 857.19 MB.

La dimensione degli stessi dati nell'indice in Elasticsearch occupa 4,5 GB.

Se nel parametro vector non si specifica, in Clickhouse i dati occupano 4500/857.19 = 5.24 volte meno rispetto a Elasticsearch.

Nel vector, il campo compression è utilizzato per default.

Chat di Telegram su Clickhouse
Chat di Telegram su Elasticsearch
Chat di Telegram su "Raccolta e analisi dei messaggi di sistema messaggi"

Fonte: habr.com