Odesílání protokolů Nginx json pomocí Vector do Clickhouse a Elasticsearch

vektor, navržený ke shromažďování, transformaci a odesílání protokolových dat, metrik a událostí.

→ GitHub

Je napsán v jazyce Rust a vyznačuje se vysokým výkonem a nízkou spotřebou RAM ve srovnání s jeho analogy. Velká pozornost je navíc věnována funkcím souvisejícím se správností, zejména pak možnosti ukládat neodeslané události do vyrovnávací paměti na disku a rotovat soubory.

Architektonicky je Vector směrovač událostí, který přijímá zprávy od jednoho nebo více Zdroje, volitelně se vztahuje na tyto zprávy transformacea jejich odeslání jednomu nebo více odtoky.

Vector je náhradou za filebeat a logstash, může vystupovat v obou rolích (přijímat a odesílat logy), další podrobnosti o nich webové stránky.

Pokud je v Logstash řetězec postaven jako vstup → filtr → výstup, pak ve Vectoru je zdroje → transformace → klesá

Příklady naleznete v dokumentaci.

Tento pokyn je revidovaný pokyn od Vjačeslav Rakhinský. Původní návod obsahuje zpracování geoip. Při testování geoip z interní sítě 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

Pokud by někdo potřeboval zpracovat geoip, tak se řiďte originálním návodem z Vjačeslav Rakhinský.

Nakonfigurujeme kombinaci Nginx (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → zvlášť v Clickhouse a zvlášť v Elasticsearch. Nainstalujeme 4 servery. I když to můžete obejít se 3 servery.

Schéma je něco takového.

Zakažte Selinux na všech svých serverech

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

Na všechny servery nainstalujeme emulátor HTTP serveru + utility

Jako emulátor HTTP serveru budeme používat nodejs-stub-server z Maxim Ignatenko

Nodejs-stub-server nemá otáčky za minutu. Zde vytvořte pro to otáčky za minutu. rpm bude zkompilován pomocí Fedora Copr

Přidejte úložiště antonpatsev/nodejs-stub-server

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

Nainstalujte nodejs-stub-server, benchmark Apache a multiplexer obrazovky terminálu na všechny servery

yum -y install stub_http_server screen mc httpd-tools screen

Opravil jsem dobu odezvy stub_http_server v souboru /var/lib/stub_http_server/stub_http_server.js, aby bylo více protokolů.

var max_sleep = 10;

Spustíme stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Instalace Clickhouse na serveru 3

ClickHouse používá instrukční sadu SSE 4.2, takže pokud není uvedeno jinak, její podpora v použitém procesoru se stává dalším požadavkem na systém. Zde je příkaz ke kontrole, zda aktuální procesor podporuje SSE 4.2:

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

Nejprve musíte připojit oficiální úložiště:

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

Chcete-li nainstalovat balíčky, musíte spustit následující příkazy:

sudo yum install -y clickhouse-server clickhouse-client

Povolit clickhouse-serveru naslouchat síťové kartě v souboru /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Změna úrovně protokolování z trasování na ladění

ladit

Standardní nastavení komprese:

min_compress_block_size  65536
max_compress_block_size  1048576

Pro aktivaci komprese Zstd bylo doporučeno nedotýkat se konfigurace, ale raději použít DDL.

Na Googlu jsem nenašel, jak používat kompresi zstd přes DDL. Tak jsem to nechal tak.

Kolegové, kteří používají kompresi zstd v Clickhouse, sdílejte prosím pokyny.

Chcete-li spustit server jako démona, spusťte:

service clickhouse-server start

Nyní přejdeme k nastavení Clickhouse

Přejděte do Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP serveru, kde je nainstalován Clickhouse.

Vytvoříme vektorovou databázi

CREATE DATABASE vector;

Zkontrolujeme, že databáze existuje.

show databases;

Vytvořte tabulku 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;

Zkontrolujeme, zda byly tabulky vytvořeny. Pojďme spustit clickhouse-client a podat žádost.

Pojďme k vektorové databázi.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Podívejme se na tabulky.

show tables;

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

Instalace elasticsearch na 4. server pro odesílání stejných dat do Elasticsearch pro porovnání s Clickhouse

Přidejte veřejný klíč rpm

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

Vytvoříme 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

Nainstalujte elasticsearch a kibana

yum install -y kibana elasticsearch

Protože bude v 1 kopii, musíte do souboru /etc/elasticsearch/elasticsearch.yml přidat následující:

discovery.type: single-node

Aby vektor mohl odesílat data do elasticsearch z jiného serveru, změňme network.host.

network.host: 0.0.0.0

Chcete-li se připojit ke kibaně, změňte parametr server.host v souboru /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Staré a zahrnout elasticsearch do automatického spuštění

systemctl enable elasticsearch
systemctl start elasticsearch

a kibana

systemctl enable kibana
systemctl start kibana

Konfigurace Elasticsearch pro režim s jedním uzlem 1 fragment, 0 replika. S největší pravděpodobností budete mít cluster velkého počtu serverů a nemusíte to dělat.

Pro budoucí indexy aktualizujte výchozí šablonu:

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

Instalace vektor jako náhrada za Logstash na serveru 2

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

Pojďme nastavit Vector jako náhradu za Logstash. Úprava souboru /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 upravit sekci transforms.nginx_parse_add_defaults.

Jak Vjačeslav Rakhinský používá tyto konfigurace pro malé CDN a v upstream_* může být několik hodnot

Napří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"

Pokud to není vaše situace, lze tuto část zjednodušit

Vytvořme nastavení služby pro 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 vytvoření tabulek můžete spustit Vector

systemctl enable vector
systemctl start vector

Vektorové protokoly lze zobrazit takto:

journalctl -f -u vector

V protokolech by měly být takové záznamy

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

Na klientovi (webovém serveru) - 1. server

Na serveru s nginx musíte zakázat ipv6, protože tabulka protokolů v clickhouse používá pole upstream_addr IPv4, protože nepoužívám ipv6 uvnitř sítě. Pokud není ipv6 vypnuto, dojde k chybám:

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

Možná čtenáři, přidejte podporu ipv6.

Vytvořte soubor /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

Použití nastavení

sysctl --system

Pojďme nainstalovat nginx.

Přidán soubor úložiště 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

Nainstalujte balíček nginx

yum install -y nginx

Nejprve musíme nakonfigurovat formát protokolu v Nginx v souboru /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 porušení vaší aktuální konfigurace, Nginx vám umožňuje mít několik direktiv access_log

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

Nezapomeňte přidat pravidlo pro logrotate pro nové protokoly (pokud soubor protokolu nekončí příponou .log)

Odebrat default.conf z /etc/nginx/conf.d/

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

Přidejte virtuálního hostitele /etc/nginx/conf.d/vhost1.conf

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

Přidejte virtuálního hostitele /etc/nginx/conf.d/vhost2.conf

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

Přidejte virtuálního hostitele /etc/nginx/conf.d/vhost3.conf

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

Přidejte virtuálního hostitele /etc/nginx/conf.d/vhost4.conf

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

Přidejte virtuální hostitele (172.26.10.106 ip serveru, kde je nainstalován nginx) na všechny servery do souboru /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

A pokud je vše připraveno

nginx -t 
systemctl restart nginx

Nyní si to nainstalujme sami vektor

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

Vytvořme soubor nastavení pro 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 konfiguraci /etc/vector/vector.toml. IP adresa 172.26.10.108 je IP adresa logovacího serveru (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"

Nezapomeňte přidat uživatelský vektor do příslušné skupiny, aby mohl číst soubory protokolu. Například nginx v centos vytváří protokoly s právy administrátorské skupiny.

usermod -a -G adm vector

Spustíme vektorovou službu

systemctl enable vector
systemctl start vector

Vektorové protokoly lze zobrazit takto:

journalctl -f -u vector

V protokolech by měl být takový záznam

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

Zátěžové testování

Testování provádíme pomocí benchmarku Apache.

Balíček httpd-tools byl nainstalován na všechny servery

Začínáme testovat pomocí benchmarku Apache ze 4 různých serverů na obrazovce. Nejprve spustíme multiplexer obrazovky terminálu a poté začneme testovat pomocí benchmarku Apache. Jak pracovat s obrazovkou najdete v článek.

Z 1. serveru

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

Z 2. serveru

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

Z 3. serveru

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

Z 4. serveru

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

Pojďme zkontrolovat data v Clickhouse

Přejděte do Clickhouse

clickhouse-client -h 172.26.10.109 -m

Vytvoření 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 │                       │
└──────────────┴─────────────────────┴─────────────┴─────────┴────────────────┴────────────────────┴───────────────────┴─────────────┴────────────────┴────────────────┴────────────────┴──────────────┴──────────────────┴─────────────────┴──────────────────────────┴───────────────────────┴───────────────┴─────────────┴─────────────┴───────────────┴───────────────┴─────────────────────────┴─────────────────────┴───────────────────────┴───────────────────────┴──────────────────────┴──────────────────────────┴────────────────────────┴─────────────────┴───────────────────────

Zjistěte velikost stolů 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;

Pojďme zjistit, kolik kulatiny zabralo v Clickhouse.

Velikost tabulky protokolů je 857.19 MB.

Velikost stejných dat v indexu v Elasticsearch je 4,5 GB.

Pokud v parametrech neuvedete data ve vektoru, Clickhouse vezme 4500/857.19 = 5.24krát méně než v Elasticsearch.

Ve vektoru se ve výchozím nastavení používá pole komprese.

Telegramový chat od clickhouse
Telegramový chat od Elastickýsearch
Telegramový chat od "Sběr a analýza systému zprávy"

Zdroj: www.habr.com