Dërgimi i regjistrave Nginx json duke përdorur Vector në Clickhouse dhe Elasticsearch

Vektor, i krijuar për të mbledhur, transformuar dhe dërguar të dhëna regjistri, metrikë dhe ngjarje.

→ Github

Duke qenë i shkruar në gjuhën Rust, karakterizohet nga performanca e lartë dhe konsumi i ulët i RAM-it në krahasim me analogët e tij. Për më tepër, shumë vëmendje i kushtohet funksioneve që lidhen me korrektësinë, në veçanti, aftësisë për të ruajtur ngjarjet e padërguara në një tampon në disk dhe për të rrotulluar skedarët.

Arkitekturisht, Vector është një ruter ngjarjesh që merr mesazhe nga një ose më shumë burimet, duke aplikuar opsionalisht mbi këto mesazhe transformimet, dhe dërgimi i tyre në një ose më shumë kullon.

Vektori është një zëvendësim për filebeat dhe logstash, ai mund të veprojë në të dy rolet (të marrë dhe të dërgojë regjistrat), më shumë detaje mbi to Online.

Nëse në Logstash zinxhiri ndërtohet si hyrje → filtër → dalje, atëherë në Vector është Burime → transformon → mbytet

Shembujt mund të gjenden në dokumentacion.

Ky udhëzim është një udhëzim i rishikuar nga Vyacheslav Rakhinsky. Udhëzimet origjinale përmbajnë përpunimin geoip. Gjatë testimit të geoip nga një rrjet i brendshëm, vektori dha një gabim.

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

Nëse dikush ka nevojë të përpunojë geoip, atëherë referojuni udhëzimeve origjinale nga Vyacheslav Rakhinsky.

Ne do të konfigurojmë kombinimin e Nginx (Regjistrimet e hyrjes) → Vektori (Klienti | Filebeat) → Vektori (Serveri | Logstash) → veçmas në Clickhouse dhe veçmas në Elasticsearch. Do të instalojmë 4 serverë. Edhe pse mund ta anashkaloni me 3 serverë.

Skema është diçka e tillë.

Çaktivizoni Selinux në të gjithë serverët tuaj

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

Ne instalojmë një emulator të serverit HTTP + shërbime në të gjithë serverët

Ne do të përdorim si një emulator të serverit HTTP nodejs-cung-server nga Maksim Ignatenko

Nodejs-stub-server nuk ka një rpm. Këtu krijoni rpm për të. rpm do të përpilohet duke përdorur Fedora Copr

Shtoni depon e serverit antonpatsev/nodejs-stub

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

Instaloni serverin nodejs-stub, standardin Apache dhe multiplekserin e terminalit të ekranit në të gjithë serverët

yum -y install stub_http_server screen mc httpd-tools screen

E korrigjova kohën e përgjigjes së stub_http_server në skedarin /var/lib/stub_http_server/stub_http_server.js në mënyrë që të kishte më shumë regjistra.

var max_sleep = 10;

Le të hapim stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Instalimi i Clickhouse në serverin 3

ClickHouse përdor grupin e instruksioneve SSE 4.2, kështu që nëse nuk specifikohet ndryshe, mbështetja për të në procesorin e përdorur bëhet një kërkesë shtesë e sistemit. Këtu është komanda për të kontrolluar nëse procesori aktual mbështet SSE 4.2:

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

Së pari ju duhet të lidhni depon zyrtare:

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

Për të instaluar paketat, duhet të ekzekutoni komandat e mëposhtme:

sudo yum install -y clickhouse-server clickhouse-client

Lejo serverin clickhouse të dëgjojë kartën e rrjetit në skedarin /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Ndryshimi i nivelit të regjistrimit nga gjurmimi në korrigjim

rregulloj

Cilësimet standarde të kompresimit:

min_compress_block_size  65536
max_compress_block_size  1048576

Për të aktivizuar kompresimin Zstd, këshillohej të mos prekni konfigurimin, por më tepër të përdorni DDL.

Nuk gjeta se si të përdor kompresimin zstd përmes DDL në Google. Kështu që e lashë ashtu siç ishte.

Kolegët që përdorin kompresimin zstd në Clickhouse, ju lutemi shpërndani udhëzimet.

Për të nisur serverin si një demon, ekzekutoni:

service clickhouse-server start

Tani le të kalojmë te konfigurimi i Clickhouse

Shkoni në Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP e serverit ku është instaluar Clickhouse.

Le të krijojmë një bazë të dhënash vektoriale

CREATE DATABASE vector;

Le të kontrollojmë nëse baza e të dhënave ekziston.

show databases;

Krijo një 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;

Kontrollojmë që tabelat janë krijuar. Le të nisim clickhouse-client dhe bëni një kërkesë.

Le të shkojmë në bazën e të dhënave vektoriale.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Le të shohim tabelat.

show tables;

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

Instalimi i elasticsearch në serverin e 4-të për të dërguar të njëjtat të dhëna në Elasticsearch për krahasim me Clickhouse

Shto një çelës publik rpm

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

Le të krijojmë 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

Instaloni elasticsearch dhe kibana

yum install -y kibana elasticsearch

Meqenëse do të jetë në 1 kopje, duhet të shtoni sa vijon në skedarin /etc/elasticsearch/elasticsearch.yml:

discovery.type: single-node

Kështu që ai vektor mund të dërgojë të dhëna në elasticsearch nga një server tjetër, le të ndryshojmë network.host.

network.host: 0.0.0.0

Për t'u lidhur me kibana, ndryshoni parametrin server.host në skedarin /etc/kibana/kibana.yml

server.host: "0.0.0.0"

I vjetër dhe përfshin elasticsearch në autostart

systemctl enable elasticsearch
systemctl start elasticsearch

dhe kibana

systemctl enable kibana
systemctl start kibana

Konfigurimi i Elasticsearch për modalitetin me një nyje 1 copë, 0 kopje. Me shumë mundësi do të keni një grup me një numër të madh serverësh dhe nuk keni nevojë ta bëni këtë.

Për indekset e ardhshme, përditësoni shabllonin e paracaktuar:

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

Instalim Vektor si një zëvendësim për Logstash në serverin 2

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

Le të vendosim Vector si një zëvendësim për Logstash. Redaktimi i skedarit /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"

Ju mund të rregulloni seksionin transforms.nginx_parse_add_defaults.

Si Vyacheslav Rakhinsky përdor këto konfigurime për një CDN të vogël dhe mund të ketë disa vlera në rrjedhën e sipërme_*

Për shembull:

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

Nëse kjo nuk është situata juaj, atëherë ky seksion mund të thjeshtohet

Le të krijojmë cilësimet e shërbimit për 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

Pas krijimit të tabelave, mund të ekzekutoni Vector

systemctl enable vector
systemctl start vector

Regjistrat e vektorit mund të shihen si kjo:

journalctl -f -u vector

Duhet të ketë shënime të tilla në regjistrat

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

Në klient (server në internet) - serveri i parë

Në serverin me nginx, duhet të çaktivizoni ipv6, pasi tabela e regjistrave në clickhouse përdor fushën upstream_addr IPv4, pasi nuk e përdor ipv6 brenda rrjetit. Nëse ipv6 nuk fiket, do të ketë gabime:

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

Ndoshta lexuesit, shtoni mbështetje ipv6.

Krijo skedarin /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

Aplikimi i cilësimeve

sysctl --system

Le të instalojmë nginx.

U shtua skedari i depove 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

Instaloni paketën nginx

yum install -y nginx

Së pari, duhet të konfigurojmë formatin e regjistrit në Nginx në skedarin /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;
}

Për të mos prishur konfigurimin tuaj aktual, Nginx ju lejon të keni disa direktiva access_log

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

Mos harroni të shtoni një rregull për të logrotuar për regjistrat e rinj (nëse skedari i regjistrit nuk përfundon me .log)

Hiq default.conf nga /etc/nginx/conf.d/

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

Shto host virtual /etc/nginx/conf.d/vhost1.conf

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

Shto host virtual /etc/nginx/conf.d/vhost2.conf

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

Shto host virtual /etc/nginx/conf.d/vhost3.conf

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

Shto host virtual /etc/nginx/conf.d/vhost4.conf

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

Shtoni hostet virtualë (172.26.10.106 ip i serverit ku është instaluar nginx) te të gjithë serverët në skedarin /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Dhe nëse gjithçka është gati atëherë

nginx -t 
systemctl restart nginx

Tani le ta instalojmë vetë Vektor

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

Le të krijojmë një skedar cilësimesh për 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

Dhe konfiguroni zëvendësimin e Filebeat në konfigurimin /etc/vector/vector.toml. Adresa IP 172.26.10.108 është adresa IP e serverit të regjistrit (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"

Не забудте добавить юзера vector в нужную группу что бы он мог читать log файлы. Например, nginx в centos создает логи с правами группы adm.

usermod -a -G adm vector

Le të fillojmë shërbimin e vektorit

systemctl enable vector
systemctl start vector

Regjistrat e vektorit mund të shihen si kjo:

journalctl -f -u vector

Duhet të ketë një hyrje si kjo në regjistra

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

Testimi i stresit

Ne kryejmë testimin duke përdorur standardin Apache.

Paketa httpd-tools u instalua në të gjithë serverët

Ne fillojmë të testojmë duke përdorur standardin Apache nga 4 serverë të ndryshëm në ekran. Së pari, ne lëshojmë multiplekserin e terminalit të ekranit dhe më pas fillojmë testimin duke përdorur standardin Apache. Si të punoni me ekranin që mund ta gjeni artikull.

Nga serveri i parë

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

Nga serveri i parë

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

Nga serveri i parë

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

Nga serveri i parë

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

Le të kontrollojmë të dhënat në Clickhouse

Shkoni në Clickhouse

clickhouse-client -h 172.26.10.109 -m

Bërja e një pyetjeje 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 │                       │
└──────────────┴─────────────────────┴─────────────┴─────────┴────────────────┴────────────────────┴───────────────────┴─────────────┴────────────────┴────────────────┴────────────────┴──────────────┴──────────────────┴─────────────────┴──────────────────────────┴───────────────────────┴───────────────┴─────────────┴─────────────┴───────────────┴───────────────┴─────────────────────────┴─────────────────────┴───────────────────────┴───────────────────────┴──────────────────────┴──────────────────────────┴────────────────────────┴─────────────────┴───────────────────────

Zbuloni madhësinë e tabelave në 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;

Le të zbulojmë se sa shkrime morën në Clickhouse.

Madhësia e tabelës së regjistrave është 857.19 MB.

Madhësia e të njëjtave të dhëna në indeksin në Elasticsearch është 4,5 GB.

Nëse nuk specifikoni të dhëna në vektor në parametra, Clickhouse merr 4500/857.19 = 5.24 herë më pak se në Elasticsearch.

Në vektor, fusha e kompresimit përdoret si parazgjedhje.

Biseda në telegram nga Clickhouse
Biseda në telegram nga Elasticsearch
Biseda në telegram nga "Mbledhja dhe analiza e sistemit mesazheve"

Burimi: www.habr.com