🥇Invio di log JSON Nginx utilizzando Vector a Clickhouse ed Elasticsearch

Vettoriale (Vector), progettato per raccogliere, trasformare e inviare dati di registro, metriche ed eventi.

Essendo scritto in linguaggio Rust, è caratterizzato da prestazioni elevate e basso consumo di RAM rispetto ai suoi analoghi. Inoltre, viene prestata molta attenzione alle funzioni legate alla correttezza, in particolare alla possibilità di salvare gli eventi non inviati in un buffer su disco e ruotare i file.

Dal punto di vista architettonico, Vector è un router di eventi che riceve messaggi da uno o più di fonti, applicandolo facoltativamente a questi messaggi trasformazionee inviandoli a uno o più drenaggi.

Vector sostituisce filebeat e logstash, può agire in entrambi i ruoli (ricevere e inviare log), maggiori dettagli su di essi sito web.

Se in Logstash la catena è costruita come input → filtro → output, in Vector lo è fonti → trasforma → lavelli

Gli esempi possono essere trovati nella documentazione.

Questa istruzione è un'istruzione rivista da Viacheslav Rakhinsky. Le istruzioni originali contengono l'elaborazione geoip. Durante il test di GeoIP da una rete interna, Vector ha restituito un errore.

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

Se qualcuno ha bisogno di elaborare geoip, fare riferimento alle istruzioni originali di Viacheslav Rakhinsky.

Configureremo la combinazione di Nginx (Log di accesso) → Vector (Client | Filebeat) → Vector (Server | Logstash) → separatamente in Clickhouse e separatamente in Elasticsearch. Installeremo 4 server. Anche se puoi bypassarlo con 3 server.

Lo schema è qualcosa del genere.

Disabilita Selinux su tutti i tuoi server

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

Installiamo un emulatore di server HTTP + utilità su tutti i server

Come emulatore del server HTTP utilizzeremo nodejs-stub-server от Maxim Ignatenko

Nodejs-stub-server non ha un numero di giri. Qui creare un numero di giri per questo. rpm verrà compilato utilizzando Fedora Copr

Aggiungi 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, benchmark Apache e multiplexer terminale schermo su tutti i server

yum -y install stub_http_server screen mc httpd-tools screen

Ho corretto il tempo di risposta stub_http_server nel file /var/lib/stub_http_server/stub_http_server.js in modo che ci fossero più log.

var max_sleep = 10;

Lanciamo stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Installazione ClickHouse sul server 3

ClickHouse utilizza il set di istruzioni SSE 4.2, quindi, se non diversamente specificato, il supporto nel processore utilizzato diventa un requisito di sistema aggiuntivo. Ecco il comando per verificare se il processore corrente supporta SSE 4.2:

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

Per prima cosa devi collegare 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 è necessario 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

<listen_host>0.0.0.0</listen_host>

Modifica del livello di registrazione da traccia a debug

mettere a punto

Impostazioni di compressione standard:

min_compress_block_size  65536
max_compress_block_size  1048576

Per attivare la compressione Zstd si consiglia di non toccare il config, ma piuttosto di utilizzare DDL.

Non sono riuscito a trovare come utilizzare la compressione zstd tramite DDL in Google. Quindi l'ho lasciato così com'è.

Colleghi che utilizzano la compressione zstd in Clickhouse, condividete le istruzioni.

Per avviare il server come demone, eseguire:

service clickhouse-server start

Passiamo ora alla configurazione di Clickhouse

Vai a ClickHouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP del server su cui è installato Clickhouse.

Creiamo un database vettoriale

CREATE DATABASE vector;

Verifichiamo che il database esista.

show databases;

Crea una 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;

Controlliamo che le tabelle siano state create. Lanciamo clickhouse-client e fare una richiesta.

Andiamo al database dei vettori.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Diamo un'occhiata alle tabelle.

show tables;

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

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

Aggiungi una chiave RPM pubblica

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

Creiamo 2 repository:

/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

Installa elasticsearch e kibana

yum install -y kibana elasticsearch

Poiché sarà in 1 copia, è necessario aggiungere quanto segue al file /etc/elasticsearch/elasticsearch.yml:

discovery.type: single-node

Affinché quel vettore possa inviare dati a elasticsearch da un altro server, cambiamo network.host.

network.host: 0.0.0.0

Per connettersi a kibana, modificare il parametro server.host nel file /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Vecchio e includi elasticsearch nell'avvio automatico

systemctl enable elasticsearch
systemctl start elasticsearch

e Kibana

systemctl enable kibana
systemctl start kibana

Configurazione di Elasticsearch per la modalità a nodo singolo 1 shard, 0 replica. Molto probabilmente avrai un cluster con un gran numero di server e non avrai bisogno di farlo.

Per gli indici futuri, aggiorna 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 Vettoriale (Vector) in sostituzione di Logstash sul server 2

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

Impostiamo Vector come sostituto di Logstash. Modificando il file /etc/vettore/vettore.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"

Puoi modificare la sezione transforms.nginx_parse_add_defaults.

Come Viacheslav Rakhinsky utilizza queste configurazioni per un piccolo CDN e possono esserci diversi valori in upstream_*

Per 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 tua situazione, questa sezione può essere semplificata

Creiamo le impostazioni del servizio per systemd /etc/systemd/system/vettore.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, puoi eseguire Vector

systemctl enable vector
systemctl start vector

I log vettoriali possono essere visualizzati in questo modo:

journalctl -f -u vector

Dovrebbero esserci voci come questa nei log

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

Sul client (server Web) - 1° server

Sul server con nginx, devi disabilitare ipv6, poiché la tabella dei log in clickhouse utilizza il campo upstream_addr IPv4, poiché non utilizzo IPv6 all'interno della rete. Se ipv6 non è disattivato, si verificheranno errori:

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

Forse lettori, aggiungete il supporto IPv6.

Creare 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

Applicazione delle impostazioni

sysctl --system

Installiamo 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

Installa il pacchetto nginx

yum install -y nginx

Per prima cosa dobbiamo configurare il formato del log in Nginx nel file /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;
}

Per non interrompere la configurazione attuale, Nginx ti consente di avere diverse direttive access_log

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

Non dimenticare di aggiungere una regola per registrare i nuovi log (a meno che il file di log non termini con .log)

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

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

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

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

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

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

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

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

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

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

Aggiungi host virtuali (ip 172.26.10.106 del server su cui è installato nginx) a tutti i server nel file /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

E se tutto sarà pronto allora

nginx -t 
systemctl restart nginx

Ora installiamolo da soli Vettoriale (Vector)

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

Creiamo un file di impostazioni per systemd /etc/systemd/system/vettore.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 configura la sostituzione di Filebeat nella configurazione /etc/vettore/vettore.toml. L'indirizzo IP 172.26.10.108 è l'indirizzo IP del server di 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"

Non dimenticare di aggiungere il vettore utente al gruppo appropriato in modo che possa leggere i file di log. Ad esempio, nginx in centos crea registri con diritti di gruppo adm.

usermod -a -G adm vector

Avviamo il servizio vettoriale

systemctl enable vector
systemctl start vector

I log vettoriali possono essere visualizzati in questo modo:

journalctl -f -u vector

Dovrebbe esserci una voce come questa nei log

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

Prove di stress

Effettuiamo test utilizzando il benchmark Apache.

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

Iniziamo i test utilizzando il benchmark Apache da 4 diversi server sullo schermo. Innanzitutto, lanciamo il multiplexer del terminale su schermo, quindi iniziamo i test utilizzando il benchmark Apache. Come lavorare con lo schermo che 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 3° server

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

Dal 4° server

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

Controlliamo i dati in Clickhouse

Vai a ClickHouse

clickhouse-client -h 172.26.10.109 -m

Effettuare una query 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 │                       │
└──────────────┴─────────────────────┴─────────────┴─────────┴────────────────┴────────────────────┴───────────────────┴─────────────┴────────────────┴────────────────┴────────────────┴──────────────┴──────────────────┴─────────────────┴──────────────────────────┴───────────────────────┴───────────────┴─────────────┴─────────────┴───────────────┴───────────────┴─────────────────────────┴─────────────────────┴───────────────────────┴───────────────────────┴──────────────────────┴──────────────────────────┴────────────────────────┴─────────────────┴───────────────────────

Scopri la dimensione dei tavoli 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 quanti log sono stati occupati in Clickhouse.