Odosielanie protokolov Nginx json pomocou Vector do Clickhouse a Elasticsearch

vektor, určený na zhromažďovanie, transformáciu a odosielanie údajov denníkov, metrík a udalostí.

→ GitHub

Je napísaný v jazyku Rust a vyznačuje sa vysokým výkonom a nízkou spotrebou RAM v porovnaní s jeho analógmi. Okrem toho sa veľká pozornosť venuje funkciám súvisiacim so správnosťou, najmä možnosti ukladať neodoslané udalosti do vyrovnávacej pamäte na disku a otáčať súbory.

Architektonicky je Vector smerovač udalostí, ktorý prijíma správy od jedného alebo viacerých zdroje, voliteľne sa vzťahuje na tieto správy transformáciía ich odoslanie jednému alebo viacerým odtoky.

Vector je náhradou za filebeat a logstash, môže pôsobiť v oboch rolách (prijímať a odosielať protokoly), viac podrobností o nich Online.

Ak je v Logstash reťazec zostavený ako vstup → filter → výstup, potom vo Vector je zdroje → transformácia → drezy

Príklady nájdete v dokumentácii.

Tento pokyn je revidovaný pokyn z Vjačeslav Rakhinský. Pôvodný návod obsahuje spracovanie geoipov. Pri testovaní geoip z internej siete vektor vykázal chybu.

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

Ak niekto potrebuje spracovať geoip, potom si pozrite pôvodný návod z Vjačeslav Rakhinský.

Nakonfigurujeme kombináciu Nginx (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → samostatne v Clickhouse a samostatne v Elasticsearch. Nainštalujeme 4 servery. Aj keď to môžete obísť 3 servermi.

Schéma je asi takáto.

Zakážte Selinux na všetkých svojich serveroch

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

Na všetky servery inštalujeme emulátor HTTP servera + utility

Ako emulátor HTTP servera budeme používať nodejs-stub-server od Maxim Ignatenko

Nodejs-stub-server nemá otáčky za minútu. Tu vytvorte pre to otáčky za minútu. rpm sa skompiluje pomocou Fedora Copr

Pridajte archív antonpatsev/nodejs-stub-server

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

Nainštalujte nodejs-stub-server, benchmark Apache a multiplexer obrazovky terminálu na všetky servery

yum -y install stub_http_server screen mc httpd-tools screen

Opravil som čas odozvy stub_http_server v súbore /var/lib/stub_http_server/stub_http_server.js, aby bolo viac protokolov.

var max_sleep = 10;

Spustíme stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Inštalácia Clickhouse na serveri 3

ClickHouse používa inštrukčnú sadu SSE 4.2, takže pokiaľ nie je uvedené inak, jej podpora v použitom procesore sa stáva ďalšou systémovou požiadavkou. Tu je príkaz na kontrolu, či aktuálny procesor podporuje SSE 4.2:

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

Najprv musíte pripojiť oficiálne úložisko:

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

Ak chcete nainštalovať balíky, musíte spustiť nasledujúce príkazy:

sudo yum install -y clickhouse-server clickhouse-client

Povoliť clickhouse-server počúvať sieťovú kartu v súbore /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Zmena úrovne protokolovania zo sledovania na ladenie

ladiť

Štandardné nastavenia kompresie:

min_compress_block_size  65536
max_compress_block_size  1048576

Na aktiváciu kompresie Zstd sa odporúča nedotýkať sa konfigurácie, ale radšej použiť DDL.

V Google som nenašiel, ako používať kompresiu zstd cez DDL. Tak som to nechal tak.

Kolegovia, ktorí používajú kompresiu zstd v Clickhouse, zdieľajte pokyny.

Ak chcete spustiť server ako démon, spustite:

service clickhouse-server start

Teraz prejdime k nastaveniu Clickhouse

Prejdite do Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP servera, kde je nainštalovaný Clickhouse.

Vytvorme vektorovú databázu

CREATE DATABASE vector;

Skontrolujeme, či databáza existuje.

show databases;

Vytvorte tabuľku 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;

Skontrolujeme, či sú tabuľky vytvorené. Poďme spustiť clickhouse-client a podať žiadosť.

Poďme k vektorovej databáze.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Pozrime sa na tabuľky.

show tables;

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

Inštalácia elasticsearch na 4. server na odosielanie rovnakých údajov do Elasticsearch na porovnanie s Clickhouse

Pridajte verejný kľúč rpm

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

Vytvorme 2 repo:

/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

Nainštalujte elasticsearch a kibana

yum install -y kibana elasticsearch

Keďže bude v 1 kópii, musíte do súboru /etc/elasticsearch/elasticsearch.yml pridať nasledovné:

discovery.type: single-node

Aby vektor mohol odosielať údaje do elasticsearch z iného servera, zmeňme network.host.

network.host: 0.0.0.0

Ak sa chcete pripojiť ku kibana, zmeňte parameter server.host v súbore /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Staré a zahrnuté elasticsearch do automatického spustenia

systemctl enable elasticsearch
systemctl start elasticsearch

a kibana

systemctl enable kibana
systemctl start kibana

Konfigurácia Elasticsearch pre režim s jedným uzlom 1 fragment, 0 replika. S najväčšou pravdepodobnosťou budete mať klaster veľkého počtu serverov a nemusíte to robiť.

Pre budúce indexy aktualizujte predvolenú šablónu:

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

Inštalácia vektor ako náhrada za Logstash na serveri 2

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

Nastavme Vector ako náhradu za Logstash. Úprava súboru /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"

Môžete upraviť sekciu transforms.nginx_parse_add_defaults.

Ako Vjačeslav Rakhinský používa tieto konfigurácie pre malé CDN a v upstream_* môže byť niekoľko hodnôt

napríklad:

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

Ak toto nie je vaša situácia, potom je možné túto časť zjednodušiť

Vytvorme nastavenia služby pre 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

Po vytvorení tabuliek môžete spustiť Vector

systemctl enable vector
systemctl start vector

Vektorové protokoly je možné zobraziť takto:

journalctl -f -u vector

Takéto záznamy by mali byť v denníkoch

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

Na klientovi (Web server) - 1. server

Na serveri s nginx musíte zakázať ipv6, pretože tabuľka protokolov v clickhouse používa pole upstream_addr IPv4, keďže ipv6 vo vnútri siete nepoužívam. Ak ipv6 nie je vypnutý, vyskytnú sa chyby:

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

Možno čitatelia, pridajte podporu ipv6.

Vytvorte súbor /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

Aplikovanie nastavení

sysctl --system

Poďme nainštalovať nginx.

Pridaný súbor úložiska 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

Nainštalujte balík nginx

yum install -y nginx

Najprv musíme nakonfigurovať formát denníka v Nginx v súbore /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;
}

Aby nedošlo k narušeniu vašej aktuálnej konfigurácie, Nginx vám umožňuje mať niekoľko direktív access_log

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

Nezabudnite pridať pravidlo na logrotate pre nové protokoly (ak súbor protokolu nekončí príponou .log)

Odstrániť default.conf z /etc/nginx/conf.d/

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

Pridajte virtuálneho hostiteľa /etc/nginx/conf.d/vhost1.conf

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

Pridajte virtuálneho hostiteľa /etc/nginx/conf.d/vhost2.conf

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

Pridajte virtuálneho hostiteľa /etc/nginx/conf.d/vhost3.conf

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

Pridajte virtuálneho hostiteľa /etc/nginx/conf.d/vhost4.conf

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

Pridajte virtuálnych hostiteľov (172.26.10.106 ip servera, kde je nainštalovaný nginx) na všetky servery do súboru /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

A ak je všetko pripravené

nginx -t 
systemctl restart nginx

Teraz si to nainštalujeme sami vektor

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

Vytvorme súbor nastavení pre 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

A nakonfigurujte náhradu Filebeat v konfigurácii /etc/vector/vector.toml. IP adresa 172.26.10.108 je IP adresa log servera (Vektorový 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"

Nezabudnite pridať používateľa vektora do požadovanej skupiny, aby mohol čítať protokolové súbory. Napríklad nginx v centos vytvára denníky s právami skupiny adm.

usermod -a -G adm vector

Začnime vektorovú službu

systemctl enable vector
systemctl start vector

Vektorové protokoly je možné zobraziť takto:

journalctl -f -u vector

V protokoloch by mal byť takýto záznam

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

Záťažové testovanie

Testovanie vykonávame pomocou benchmarku Apache.

Balík httpd-tools bol nainštalovaný na všetkých serveroch

Začíname testovať pomocou benchmarku Apache zo 4 rôznych serverov na obrazovke. Najprv spustíme multiplexer obrazovky terminálu a potom začneme testovať pomocou benchmarku Apache. Ako pracovať s obrazovkou nájdete v článok.

Z 1 servera

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

Z 2 servera

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

Z 3 servera

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

Z 4 servera

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

Pozrime sa na údaje v Clickhouse

Prejdite do Clickhouse

clickhouse-client -h 172.26.10.109 -m

Vytvorenie SQL dotazu

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

Zistite veľkosť stolov v 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;

Poďme zistiť, koľko polená zabralo v Clickhouse.

Veľkosť tabuľky protokolov je 857.19 MB.

Veľkosť rovnakých údajov v indexe v Elasticsearch je 4,5 GB.

Ak v parametroch neuvediete údaje vo vektore, Clickhouse zaberie 4500/857.19 = 5.24 krát menej ako v Elasticsearch.

Vo vektore sa predvolene používa pole kompresie.

Telegramový rozhovor od clickhouse
Telegramový rozhovor od ElasticSearch
Telegramový rozhovor od "Zber a analýza systému správy"

Zdroj: hab.com