Wysyłanie logów Nginx json za pomocą Vector do Clickhouse i Elasticsearch

wektor, przeznaczony do gromadzenia, przekształcania i wysyłania danych dziennika, metryk i zdarzeń.

→ Github

Napisany w języku Rust, charakteryzuje się wysoką wydajnością i niskim zużyciem pamięci RAM w porównaniu do swoich odpowiedników. Dodatkowo dużo uwagi poświęcono funkcjom związanym z poprawnością, w szczególności możliwością zapisywania niewysłanych zdarzeń do bufora na dysku oraz rotacji plików.

Architektonicznie Vector jest routerem zdarzeń, który odbiera komunikaty od jednego lub więcej źródła, opcjonalnie stosując się do tych wiadomości przekształceniai wysyłanie ich do jednego lub więcej drenuje.

Vector zastępuje filebeat i logstash, może pełnić obie role (odbierać i wysyłać logi), więcej szczegółów na ich temat witryna internetowa.

Jeśli w Logstash łańcuch jest zbudowany jako wejście → filtr → wyjście, to w Vector tak jest źródła → transformacje → Zlewozmywaki

Przykłady można znaleźć w dokumentacji.

Niniejsza instrukcja jest poprawioną instrukcją z Wiaczesław Rachiński. Oryginalne instrukcje zawierają przetwarzanie geoip. Podczas testowania Geoip z sieci wewnętrznej, wektor dał błąd.

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

Jeśli ktoś potrzebuje przetworzyć geoip, zapoznaj się z oryginalnymi instrukcjami z Wiaczesław Rachiński.

Skonfigurujemy kombinację Nginx (dzienniki dostępu) → Vector (Klient | Filebeat) → Vector (Serwer | Logstash) → osobno w Clickhouse i osobno w Elasticsearch. Zainstalujemy 4 serwery. Chociaż można to ominąć za pomocą 3 serwerów.

Schemat jest mniej więcej taki.

Wyłącz Selinux na wszystkich swoich serwerach

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

Na wszystkich serwerach instalujemy emulator serwera HTTP + narzędzia

Jako emulatora serwera HTTP użyjemy nodejs-stub-server od Maksym Ignatenko

Serwer Nodejs-stub-server nie ma obrotów. Tutaj utwórz dla niego rpm. rpm zostanie zbudowany przy użyciu Fedora Copr

Dodaj repozytorium antonpatsev/nodejs-stub-server

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

Zainstaluj serwer nodejs-stub-server, test Apache i multiplekser terminala ekranowego na wszystkich serwerach

yum -y install stub_http_server screen mc httpd-tools screen

Poprawiłem czas odpowiedzi stub_http_server w pliku /var/lib/stub_http_server/stub_http_server.js, tak aby było więcej logów.

var max_sleep = 10;

Uruchommy stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Instalacja Clickhouse na serwerze 3

ClickHouse wykorzystuje zestaw instrukcji SSE 4.2, więc jeśli nie określono inaczej, obsługa go w zastosowanym procesorze staje się dodatkowym wymaganiem systemowym. Oto polecenie sprawdzające, czy bieżący procesor obsługuje SSE 4.2:

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

Najpierw musisz podłączyć oficjalne repozytorium:

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

Aby zainstalować pakiety, musisz uruchomić następujące polecenia:

sudo yum install -y clickhouse-server clickhouse-client

Zezwól serwerowi Clickhouse na nasłuchiwanie karty sieciowej w pliku /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Zmiana poziomu rejestrowania z śledzenia na debugowanie

debug

Standardowe ustawienia kompresji:

min_compress_block_size  65536
max_compress_block_size  1048576

Aby aktywować kompresję Zstd, zalecono nie dotykać konfiguracji, ale raczej użyć DDL.

Nie mogłem znaleźć w Google sposobu użycia kompresji zstd przez DDL. Więc zostawiłem to tak jak jest.

Koledzy, którzy stosują kompresję zstd w Clickhouse, podzielcie się instrukcją.

Aby uruchomić serwer jako demon, uruchom:

service clickhouse-server start

Przejdźmy teraz do konfiguracji Clickhouse

Idź do Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP serwera, na którym zainstalowany jest Clickhouse.

Stwórzmy wektorową bazę danych

CREATE DATABASE vector;

Sprawdźmy, czy baza danych istnieje.

show databases;

Utwórz tabelę 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;

Sprawdzamy, czy tabele zostały utworzone. Uruchommy clickhouse-client i złóż wniosek.

Przejdźmy do bazy wektorów.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Spójrzmy na tabele.

show tables;

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

Instalowanie Elasticsearch na czwartym serwerze w celu wysyłania tych samych danych do Elasticsearch w celu porównania z Clickhouse

Dodaj publiczny klucz RPM

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

Stwórzmy 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

Zainstaluj Elasticsearch i kibana

yum install -y kibana elasticsearch

Ponieważ będzie to 1 kopia, musisz dodać do pliku /etc/elasticsearch/elasticsearch.yml następujące informacje:

discovery.type: single-node

Aby wektor mógł wysyłać dane do Elasticsearch z innego serwera, zmieńmy network.host.

network.host: 0.0.0.0

Aby połączyć się z kibaną należy zmienić parametr server.host w pliku /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Stare i dołącz Elasticsearch do autostartu

systemctl enable elasticsearch
systemctl start elasticsearch

i kibanę

systemctl enable kibana
systemctl start kibana

Konfigurowanie Elasticsearch dla trybu jednowęzłowego 1 fragment, 0 replik. Najprawdopodobniej będziesz mieć klaster składający się z dużej liczby serwerów i nie musisz tego robić.

W przypadku przyszłych indeksów zaktualizuj szablon domyślny:

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

Instalacja wektor jako zamiennik Logstash na serwerze 2

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

Skonfigurujmy Vector jako zamiennik Logstash. Edycja pliku /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"

Możesz dostosować sekcję transforms.nginx_parse_add_defaults.

ponieważ Wiaczesław Rachiński używa tych konfiguracji dla małej sieci CDN, a w upstream_* może znajdować się kilka wartości

Na przykład:

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

Jeśli nie jest to Twoja sytuacja, tę sekcję można uprościć

Utwórzmy ustawienia usługi dla 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 utworzeniu tabel możesz uruchomić Vector

systemctl enable vector
systemctl start vector

Dzienniki wektorowe można przeglądać w następujący sposób:

journalctl -f -u vector

W logach powinny być takie wpisy

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

Na kliencie (serwerze internetowym) - pierwszy serwer

Na serwerze z nginx musisz wyłączyć ipv6, ponieważ tabela logów w Clickhouse używa pola upstream_addr IPv4, ponieważ nie używam protokołu IPv6 w sieci. Jeśli ipv6 nie zostanie wyłączone, pojawią się błędy:

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

Być może czytelnicy dodają obsługę protokołu IPv6.

Utwórz plik /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

Stosowanie ustawień

sysctl --system

Zainstalujmy Nginx.

Dodano plik repozytorium 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

Zainstaluj pakiet nginx

yum install -y nginx

Najpierw musimy skonfigurować format logu w Nginx w pliku /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 nie zepsuć bieżącej konfiguracji, Nginx pozwala na posiadanie kilku dyrektyw access_log

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

Nie zapomnij dodać reguły logrotate dla nowych logów (jeśli plik logu nie kończy się na .log)

Usuń default.conf z /etc/nginx/conf.d/

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

Dodaj hosta wirtualnego /etc/nginx/conf.d/vhost1.conf

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

Dodaj hosta wirtualnego /etc/nginx/conf.d/vhost2.conf

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

Dodaj hosta wirtualnego /etc/nginx/conf.d/vhost3.conf

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

Dodaj hosta wirtualnego /etc/nginx/conf.d/vhost4.conf

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

Dodaj wirtualne hosty (172.26.10.106 ip serwera, na którym jest zainstalowany nginx) do wszystkich serwerów w pliku /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

A jeśli wszystko będzie już gotowe

nginx -t 
systemctl restart nginx

Teraz zainstalujmy to sami wektor

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

Utwórzmy plik ustawień dla 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

I skonfiguruj zastąpienie Filebeat w konfiguracji /etc/vector/vector.toml. Adres IP 172.26.10.108 to adres IP serwera logów (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"

Nie zapomnij dodać wektora użytkownika do odpowiedniej grupy, aby mógł on odczytywać pliki dziennika. Na przykład nginx w centos tworzy logi z uprawnieniami grupy admin.

usermod -a -G adm vector

Uruchommy usługę wektorową

systemctl enable vector
systemctl start vector

Dzienniki wektorowe można przeglądać w następujący sposób:

journalctl -f -u vector

W logach powinien być taki wpis

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

Test naprężeń

Testy przeprowadzane są przy użyciu benchmarku Apache.

Pakiet httpd-tools został zainstalowany na wszystkich serwerach

Rozpoczynamy testowanie przy użyciu testu porównawczego Apache z 4 różnych serwerów na ekranie. Najpierw uruchamiamy multiplekser terminala ekranowego, a następnie rozpoczynamy testy z wykorzystaniem benchmarku Apache. Jak pracować z ekranem, który znajdziesz w Artykuł.

Z pierwszego serwera

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

Z pierwszego serwera

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

Z pierwszego serwera

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

Z pierwszego serwera

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

Sprawdźmy dane w Clickhouse

Idź do Clickhouse

clickhouse-client -h 172.26.10.109 -m

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

Sprawdź wielkość stołów w 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;

Przekonajmy się, ile logów zajęło Clickhouse.

Rozmiar tabeli dzienników wynosi 857.19 MB.

Rozmiar tych samych danych w indeksie w Elasticsearch wynosi 4,5 GB.

Jeśli w parametrach nie określisz danych w wektorze, Clickhouse pobiera 4500/857.19 = 5.24 razy mniej niż w Elasticsearch.

W wektorze domyślnie używane jest pole kompresji.

Czat telegramowy przez dom kliknięć
Czat telegramowy przez Elasticsearch
Czat telegramowy przez „Gromadzenie i analiza systemu wiadomości"

Źródło: www.habr.com