Nginx json logide saatmine Vectori abil Clickhouse'i ja Elasticsearchi

Vector, mis on mõeldud logi, mõõdikute ja sündmuste andmete kogumiseks, töötlemiseks ja saatmiseks.

→ Github

Write on Rust keeles, see pakub kõrget jõudlust ja madalat mälutarbimist võrreldes sarnaste lahendustega. Samuti on suurt tähelepanu pööratud korrektsete funktsioonide, sealhulgas võimaluste osas, et salvestada saatmata sündmusi kettale puhvri ja failide rullimise teel.

Arhitektuuriliselt on Vector sündmuste marsruuter, mis võtab sõnumeid vastu ühest või mitmest allikatest, rakendades nendele sõnumitele valikuliselt muundamisi, ja saadab need ühte või mitmesse sihtkohta.

Vector on filebeati ja logstashi asendaja, ta võib toimida mõlemas rollis (logide vastuvõtmine ja saatmine), rohkem teavet nende kohta veebisaidil.

Kui Logstashis on voog kujundatud kujul input → filter → output, siis Vectoris on see allikad → transforms → sihtkohad

Näiteid saab vaadata dokumentatsioonis.

See juhend on ümber töötatud juhend Vyacheslav Rakhinski. Originaalses juhendis on geoinfo töötlemine. Testides geoinfot sisevõrgus, andis vector tõrke.

Aug 05 06:25:31.889 DEBUG transform{name=nginx_parse_rename_fields type=rename_fields}: vector::transforms::rename_fields: Väli ei eksisteerinud field=«geoip.country_name» rate_limit_secs=30

Kui kellelgi on vaja geoinfot töödelda, siis pöörduge originaalse juhendi poole Vyacheslav Rakhinski.

Seame üles ühenduse Nginx (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → eraldi Clickhouse'is ja eraldi Elasticsearch'is. Paigaldame 4 serverit. Kuigi 3 serveriga saab ka hakkama.

Skeem on umbes selline.

Küljest lülitame Selinuxi välja kõikidel teie serveritel

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

Paigaldame kõigile serveritele HTTP serveri emulaatori + utiliidid

Emulaatorina kasutame HTTP teenust nodejs-stub-server alates Maxim Ignatenko

Nodejs-stub-server ei oma rpm. Siin loome sellele rpm-i. RPM koostatakse Fedora Copr abil.

Lisame reposi antonpatsev/nodejs-stub-server

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

Paigaldame nodejs-stub-serveri, Apache benchmark'i ja terminali multiplexer'i screen kõigile serveritele

yum -y install stub_http_server screen mc httpd-tools screen

Parandasin failis /var/lib/stub_http_server/stub_http_server.js stub_http_server'i vastuse aega, et logisid oleks rohkem.

var max_sleep = 10;

Käivitame stub_http_server'i.

systemctl start stub_http_server
systemctl enable stub_http_server

Clickhouse'i paigaldamine kolmandale serverile

ClickHouse kasutab SSE 4.2 käskude komplekti, seega muutub selle toega seotud protsessori tugi süsteemi täiendavaks nõudmiseks, kui ei ole märgitud teisiti. Siin on käsk, et kontrollida, kas praegune protsessor toetab SSE 4.2:

grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 toetatakse" || echo "SSE 4.2 ei ole toetatud"

Esiteks tuleb lisada ametlik register:

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

Pakettide installimiseks tuleb käitada järgmised käsud:

sudo yum install -y clickhouse-server clickhouse-client

Lubame clickhouse-serveril kuulata võrkaart failis /etc/clickhouse-server/config.xml

0.0.0.0

Muudame logimise taseme trace'ist debug'i

debug

Tehnilised seadistused on standardsed:

min_compress_block_size  65536
max_compress_block_size  1048576

Zstd kompressiooni aktiveerimiseks soovitati konfiguratsiooni mitte muuta, vaid rakendada DDL.

Kuidas rakendada zstd kompressiooni DDL kaudu, ei leidnud ma Google'ist. Seetõttu jätsin nii nagu on.

Kolleegid, kes kasutavad zstd kompressiooni Clickhouse'is — palun jagage juhiseid.

Serveri käitamiseks demonina, käida:

service clickhouse-server start

Nüüd liigume Clickhouse'i seadistamise juurde

Siseneme Clickhouse'i

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP server, kuhu Clickhouse on installitud.

Loome andmebaasi vector

CREATE DATABASE vector;

Kontrollime, et andmebaas on olemas.

show databases;

Loome tabeli 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;

Kontrollime, et tabelid on loodud. Käitame clickhouse-client ja teeme päringu.

Liigume andmebaasi vector.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Vaata tabeleid.

show tables;

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

Elasticsearch'i installimine neljandale serverile, et saata samu andmeid Elasticsearch'i, et võrrelda Clickhouse'iga

Lisame avaliku rpm võtme

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

Loome 2 registrit:

/etc/yum.repos.d/elasticsearch.repo

[elasticsearch]
name=Elasticsearch'i register 7.x pakettide jaoks
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 register 7.x pakettide jaoks
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

Installeerime elasticsearch'i ja kibana

yum install -y kibana elasticsearch

Kuna neid on üks, tuleb failis /etc/elasticsearch/elasticsearch.yml lisada:

discovery.type: single-node

Kuna vector peab andmeid teise serverisse elasticsearch'i saatma, muuda network.host.

network.host: 0.0.0.0

Kibana'ga ühenduse loomiseks muuda parameetrit server.host failis /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Käivitame ja lubame elasticsearch'i automaatse käivitamise

systemctl enable elasticsearch
systemctl start elasticsearch

ja kibana

systemctl enable kibana
systemctl start kibana

Elasticsearch'i seadistamine single-node režiimis 1 shard, 0 repliiki. Tõenäoliselt on teil klaster, mis koosneb suurest arvust serveritest ja teil ei ole seda teha vaja.

Tulevaste indeksite jaoks värskendame vaikimisi mall.

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

Paigaldamine Vector kuidas asendada Logstash teisel serveril

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

Seadistame Vectori Logstash'i asendamiseks. Redigeerime faili /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"

Sa saad kohandada jaotust transforms.nginx_parse_add_defaults.

Kuna Vyacheslav Rakhinsky kasutab neid konfiguratsioone väikese CDN-i jaoks ja seal upstream_* sektsioonis võib olla mitu väärtust

Näiteks:

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

Kui see ei ole sinu olukord, siis seda jaotust saab lihtsustada

Loome systemd teenuse seaded /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

Pärast tabelite loomist võime Vectori käivitada

systemctl enable vector
systemctl start vector

Vectori logisid saab vaadata nii

journalctl -f -u vector

Logides peaks olema sellised kirjed

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

Kliendil (Web server) — 1. server

Nginx serveris tuleb välja lülitada ipv6, kuna Clickhouse'is logide tabelis kasutatakse väljad upstream_addr IPv4, kuna ma ei kasuta ipv6 seesvõrgus. Kui ipv6 välja ei lülitata, siis võivad tekkida vead:

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

Võib-olla lugejad, lisada ipv6 toe.

Loome faili /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

Rakendame seaded

sysctl --system

Installeerime nginx.

Lisatud nginx-i repostiivisti fail /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

Installeerime nginx paketi

yum install -y nginx

Esiteks peame seadistama Nginx logide formaadi failis /etc/nginx/nginx.conf

user  nginx;
# Sa pead seadistama töötajate protsessid vastavalt oma CPU tuumadele, nginx ei saa kasu rohkematest protsessidest kui sul on tuumi.
worker_processes auto; #mõned viimased versioonid arvutavad selle automaatselt

# failide kirjeldajate arvu määramine, mida nginx kasutab
# piirang maksimaalsetele FD-dele serveris määratakse tavaliselt operatsioonisüsteemi poolt.
# kui sa ei määra FD-sid, siis kasutatakse OS seadeid, mis on vaikimisi 2000
worker_rlimit_nofile 100000;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

# määrab konfigureerimisfaili konteksti, milles on määratud direktiivid, mis mõjutavad ühenduste töötlemist.
events {
    # määrab, kui palju kliente saab iga töötaja teenindada
    # maksimaalsed kliendid = worker_connections * worker_processes
    # maksimumi piirab ka soklite ühenduste arv süsteemis (~64k)
    worker_connections 4000;

    # optimeeritud teenindama paljusid kliente iga niidi kohta, hädavajalik Linuxile -- testimis keskkonna jaoks
    use epoll;

    # aktsepteeri nii palju ühendusi kui võimalik, võib üle koormata töötaja ühendused, kui seatud liiga madalaks -- testimis keskkonna jaoks
    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;      # Uus logi json formaadis

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

Kuna ei soovita rikkuda teie praegust konfiguratsiooni, võimaldab Nginx omada mitmeid direktiive access_log

access_log  /var/log/nginx/access.log  main;            # Standardne logi
access_log  /var/log/nginx/access.json.log vector;      # Uus logi json formaadis

Ärge unustage lisada reeglit logrotate uutele logidele (kui logifail ei lõpe .log-ga)

Kustutame default.conf failist /etc/nginx/conf.d/

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

Lisame virtuaalse hosti failile /etc/nginx/conf.d/vhost1.conf

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

Lisame virtuaalse hosti /etc/nginx/conf.d/vhost2.conf

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

Lisame virtuaalse hosti /etc/nginx/conf.d/vhost3.conf

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

Lisame virtuaalse hosti /etc/nginx/conf.d/vhost4.conf

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

Lisame faili /etc/hosts virtuaalsed hostid (172.26.10.106, serveri IP, kus nginx on paigaldatud) kõigile serveritele:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Ja kui kõik on valmis, siis

nginx -t 
systemctl restart nginx

Nüüd paigaldame ise Vector

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

Loome seadistuse faili systemd jaoks /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

Ja seadistame Filebeat kompenseerimise failis /etc/vector/vector.toml. IP-aadress 172.26.10.108 — see on logiserveri (Vector-Server) IP-aadress.

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"

Ärge unustage lisada kasutaja vector vajalikku gruppi, et ta saaks lugeda logifaile. Näiteks, nginx genereerib CentOS-is logisid adm grupi õigustega.

usermod -a -G adm vector

Käivitame vectori teenuse

systemctl enable vector
systemctl start vector

Vectori logisid saab vaadata nii

journalctl -f -u vector

Logides peaks olema selline sissekanne

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

Koormuse testimine

Testimine toimub Apache benchmark'iga.

Kõigile serveritele on paigaldatud httpd-tools paketid.

Käivitame testimise Apache benchmarkiga 4 erinevast serverist screeni kaudu. Alustame terminali multiplexer screeni käivitamisest ja seejärel teostame testimise Apache benchmarkiga. Kuidas töötada screeniga, võite leida artiklis.

Esimese serveri kaudu

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

Teise serveri kaudu

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

Kolmanda serveri kaudu

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

Neljas server

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

Kontrollime andmeid Clickhouse'is

Siseneme Clickhouse'i

clickhouse-client -h 172.26.10.109 -m

Teeme SQL päringu

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

Selgitame, kui suured on tabelid Clickhouse'is

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;

Selgitame, kui palju ruumi logid Clickhouse'is võtavad.

Tabeli logs suurus on 857.19 MB.

Sama andmete maht indeksis Elasticsearchis on 4,5 GB.

Kui Clickhouse'is vektoris andmeid ei määrata, siis on need 4500/857,19 = 5,24 korda väiksemad kui Elasticsearchis.

Vektorifield compression kasutatakse vaikeväärtusena.

Telegrami jututuba Clickhouse
Telegrami jututuba Elasticsearch
Telegrami jututuba "Süsteemiteabe kogumine ja analüüs sõnumid"

Allikas: habr.com