„Nginx json“ žurnalų siuntimas naudojant „Vector“ į „Clickhouse“ ir „Elasticsearch“.

vektorius, skirtas rinkti, transformuoti ir siųsti žurnalo duomenis, metriką ir įvykius.

→ GitHub

Parašytas Rust kalba, jis pasižymi dideliu našumu ir mažu RAM suvartojimu, palyginti su analogais. Be to, daug dėmesio skiriama funkcijoms, susijusioms su teisingumu, ypač galimybe išsaugoti neišsiųstus įvykius į disko buferį ir pasukti failus.

Architektūriniu požiūriu Vector yra įvykių maršrutizatorius, kuris gauna pranešimus iš vieno ar kelių šaltiniai, pasirinktinai taikomas šiems pranešimams transformacijosir išsiųsti juos vienam ar keliems kanalizacijos.

„Vector“ yra „filebeat“ ir „logstash“ pakaitalas, jis gali atlikti abu vaidmenis (gauti ir siųsti žurnalus), daugiau informacijos apie juos Dabar naršo.

Jei Logstash grandinė yra sukurta kaip įvestis → filtras → išvestis, tada Vector šaltiniai → transformuoja → kriauklės

Pavyzdžius galima rasti dokumentacijoje.

Ši instrukcija yra pataisyta instrukcija iš Viačeslavas Rachinskis. Originaliose instrukcijose yra geoip apdorojimas. Bandant geoip iš vidinio tinklo, vektorius davė klaidą.

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

Jei kam reikia apdoroti geoip, vadovaukitės originaliomis instrukcijomis iš Viačeslavas Rachinskis.

Nginx (prieigos žurnalai) → Vector (klientas | Filebeat) → Vector (serveris | Logstash) → derinį sukonfigūruosime atskirai „Clickhouse“ ir atskirai „Elasticsearch“. Įdiegsime 4 serverius. Nors jūs galite jį apeiti su 3 serveriais.

Schema yra maždaug tokia.

Išjunkite „Selinux“ visuose savo serveriuose

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

Visuose serveriuose įdiegiame HTTP serverio emuliatorių + komunalines paslaugas

Mes naudosime kaip HTTP serverio emuliatorių nodejs-stub-server nuo Maksimas Ignatenko

Nodejs-stub-serveris neturi apsisukimų per minutę. Čia sukurti jam apsukų skaičių. rpm bus pastatytas naudojant Fedora Copr

Pridėkite antonpatsev/nodejs-stub-server saugyklą

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

Įdiekite nodejs-stub-server, Apache etaloną ir ekrano terminalo multiplekserį visuose serveriuose

yum -y install stub_http_server screen mc httpd-tools screen

Pataisiau stub_http_server atsako laiką /var/lib/stub_http_server/stub_http_server.js faile, kad būtų daugiau žurnalų.

var max_sleep = 10;

Paleiskite stub_http_serverį.

systemctl start stub_http_server
systemctl enable stub_http_server

Clickhouse diegimas 3 serveryje

ClickHouse naudoja SSE 4.2 instrukcijų rinkinį, todėl jei nenurodyta kitaip, jo palaikymas naudojamame procesoriuje tampa papildomu sistemos reikalavimu. Čia yra komanda, skirta patikrinti, ar dabartinis procesorius palaiko SSE 4.2:

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

Pirmiausia turite prijungti oficialią saugyklą:

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

Norėdami įdiegti paketus, turite paleisti šias komandas:

sudo yum install -y clickhouse-server clickhouse-client

Leisti clickhouse-server klausytis tinklo plokštės faile /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Registravimo lygio keitimas iš sekimo į derinimo lygį

derinti

Standartiniai suspaudimo nustatymai:

min_compress_block_size  65536
max_compress_block_size  1048576

Norint suaktyvinti Zstd glaudinimą, buvo patarta neliesti konfigūracijos, o naudoti DDL.

„Google“ neradau, kaip naudoti zstd glaudinimą per DDL. Taigi palikau taip, kaip yra.

Kolegos, naudojantys zstd glaudinimą Clickhouse, pasidalinkite instrukcijomis.

Norėdami paleisti serverį kaip demoną, paleiskite:

service clickhouse-server start

Dabar pereikime prie Clickhouse nustatymo

Eikite į Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 – serverio, kuriame įdiegtas Clickhouse, IP.

Sukurkime vektorinę duomenų bazę

CREATE DATABASE vector;

Patikrinkim, ar yra duomenų bazė.

show databases;

Sukurkite vector.logs lentelę.

/* Это таблица где хранятся логи как есть */

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;

Mes patikriname, ar lentelės buvo sukurtos. Paleidžiame clickhouse-client ir pateikti prašymą.

Eikime į vektorių duomenų bazę.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Pažiūrėkime į lenteles.

show tables;

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

Įdiegti elasticsearch 4-ajame serveryje, kad tie patys duomenys būtų siunčiami į Elasticsearch, kad būtų galima palyginti su Clickhouse

Pridėkite viešąjį apsukų skaičių

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

Sukurkime 2 atpirkimo sandorius:

/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

Įdiekite elasticsearch ir kibana

yum install -y kibana elasticsearch

Kadangi tai bus 1 kopija, prie /etc/elasticsearch/elasticsearch.yml failo turite pridėti:

discovery.type: single-node

Kad šis vektorius galėtų siųsti duomenis į elasticsearch iš kito serverio, pakeiskime network.host.

network.host: 0.0.0.0

Norėdami prisijungti prie kibana, pakeiskite server.host parametrą faile /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Senas ir įtraukite elasticsearch į automatinį paleidimą

systemctl enable elasticsearch
systemctl start elasticsearch

ir kibana

systemctl enable kibana
systemctl start kibana

„Elasticsearch“ konfigūravimas vieno mazgo režimui 1 fragmentas, 0 kopija. Labiausiai tikėtina, kad turėsite daug serverių ir jums to nereikės.

Jei norite naudoti būsimus indeksus, atnaujinkite numatytąjį šabloną:

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

Montavimas vektorius kaip Logstash pakaitalas serveryje 2

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

Nustatykime Vector kaip Logstash pakaitalą. Failo /etc/vector/vector.toml redagavimas

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

Galite koreguoti skiltį transforms.nginx_parse_add_defaults.

Kaip Viačeslavas Rachinskis naudoja šias konfigūracijas mažam CDN ir gali būti kelios vertės prieš srovę_*

Pavyzdžiui:

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

Jei tai ne jūsų situacija, šį skyrių galima supaprastinti

Sukurkime sistemosd /etc/systemd/system/vector.service paslaugų nustatymus

# /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

Sukūrę lenteles galite paleisti Vector

systemctl enable vector
systemctl start vector

Vektorinius žurnalus galima peržiūrėti taip:

journalctl -f -u vector

Žurnaluose turėtų būti tokie įrašai

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

Kliente (žiniatinklio serveryje) - 1-asis serveris

Serveryje su nginx turite išjungti ipv6, nes žurnalų lentelėje Clickhouse naudojamas laukas upstream_addr IPv4, nes aš nenaudoju ipv6 tinkle. Jei ipv6 nėra išjungtas, bus klaidų:

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

Galbūt skaitytojai, pridėkite ipv6 palaikymą.

Sukurkite failą /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

Taikant nustatymus

sysctl --system

Įdiegkime nginx.

Pridėtas nginx saugyklos failas /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

Įdiekite nginx paketą

yum install -y nginx

Pirmiausia turime sukonfigūruoti žurnalo formatą Nginx faile /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;
}

Kad nepažeistumėte dabartinės konfigūracijos, „Nginx“ leidžia turėti kelias access_log direktyvas

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

Nepamirškite pridėti taisyklės logrotate naujiems žurnalams (jei žurnalo failas nesibaigia .log)

Pašalinkite default.conf iš /etc/nginx/conf.d/

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

Pridėkite virtualų pagrindinį kompiuterį /etc/nginx/conf.d/vhost1.conf

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

Pridėkite virtualų pagrindinį kompiuterį /etc/nginx/conf.d/vhost2.conf

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

Pridėkite virtualų pagrindinį kompiuterį /etc/nginx/conf.d/vhost3.conf

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

Pridėkite virtualų pagrindinį kompiuterį /etc/nginx/conf.d/vhost4.conf

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

Pridėkite virtualius pagrindinius kompiuterius (serverio, kuriame įdiegtas nginx, 172.26.10.106 IP) prie visų serverių į /etc/hosts failą:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Ir jei viskas bus paruošta

nginx -t 
systemctl restart nginx

Dabar įsidiegkime patys vektorius

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

Sukurkime systemd /etc/systemd/system/vector.service nustatymų failą

[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

Ir sukonfigūruokite Filebeat pakeitimą /etc/vector/vector.toml konfigūracijose. IP adresas 172.26.10.108 yra žurnalo serverio (vektoriaus serverio) IP adresas.

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"

Nepamirškite įtraukti vektorinio vartotojo į reikiamą grupę, kad jis galėtų skaityti žurnalo failus. Pavyzdžiui, nginx in centos sukuria žurnalus su adm grupės teisėmis.

usermod -a -G adm vector

Pradėkime vektorinę paslaugą

systemctl enable vector
systemctl start vector

Vektorinius žurnalus galima peržiūrėti taip:

journalctl -f -u vector

Žurnaluose turėtų būti toks įrašas

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

Testavimas nepalankiausiomis sąlygomis

Testavimas atliekamas naudojant Apache etaloną.

httpd-tools paketas buvo įdiegtas visuose serveriuose

Pradedame testavimą naudodami Apache etaloną iš 4 skirtingų serverių ekrane. Pirmiausia paleidžiame ekrano terminalo multiplekserį, o tada pradedame testavimą naudodami „Apache“ etaloną. Kaip dirbti su ekranu galite rasti straipsnis.

Iš 1 serverio

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

Iš 2 serverio

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

Iš 3 serverio

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

Iš 4 serverio

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

Patikrinkime „Clickhouse“ duomenis

Eikite į Clickhouse

clickhouse-client -h 172.26.10.109 -m

SQL užklausos kūrimas

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

Sužinokite Clickhouse lentelių dydį

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;

Sužinokime, kiek rąstų užėmė Clickhouse.

Žurnalų lentelės dydis yra 857.19 MB.

Tų pačių duomenų dydis Elasticsearch indekse yra 4,5 GB.

Jei parametruose nenurodysite duomenų vektoriuje, Clickhouse užima 4500/857.19 = 5.24 karto mažiau nei Elasticsearch.

Vektoryje glaudinimo laukas naudojamas pagal numatytuosius nustatymus.

Telegramos pokalbis clickhouse
Telegramos pokalbis Elasticearch
„Telegram“ pokalbis „Sistemos rinkimas ir analizė pranešimus"

Šaltinis: www.habr.com