Nginx'i JSON logide saatmine Vectoriga Clickhouse'i ja Elasticsearch'i

Vector, mis valmistatud logide, mõõdikute ja sündmuste andmete kogumiseks, töötlemiseks ja edastamiseks.

→ Github

Rust keeles looduna on see kõrge jõudluse ja madala mälu tarbimisega võrreldes analoogidega. Lisaks on suur tähelepanu pööratud korrektsuse funktsioonidele, sealhulgas võimalusele salvestada edastamata sündmusi ajutiselt kettale ja failide rotatsioonile.

Arhitektuuriliselt on Vector sündmuste marsruuter, mis võtab vastu sõnumeid ühelt või mitmelt allikatest, rakendades valikuliselt nendele sõnumitele muutmine, ja edastab need ühte või mitmesse sissejuhatusse.

Vector on filebeat'i ja logstash'i asendaja, see võib toimida mõlemas rollis (logide vastuvõtjana ja saatjana), täiendavateks üksikasjadeks vaata nende veebilehel.

Kui Logstash'i ahel ehitatakse nagu input → filter → output, siis Vectoris on see sources → muundamised → sinks

Näiteid saab vaadata dokumentatsioonis.

See juhend on ümbertöödeldud juhend Vyacheslav Rakhinski. Originaalses juhendis on geoip töötlemine. Minu testimisel sisemisest võrgust andis Vector geoip osas vea.

05. aug 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 keegi peab geoip-d töötlema, pöörduge originaalinstruktsiooni poole Vyacheslav Rakhinski.

Seame üles ühenduse Nginxi (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → eraldi Clickhouse'is ja eraldi Elasticsearchis. Paigaldame 4 serverit. Kuigi kolme serveriga on võimalik läbi saada.

Schema on umbes selline.

Kudisime Selinuxi kõikidest teie serveritest välja

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

Paigaldame kõikidele serveritele HTTP-serveri emulaatori + utiliidid

Kuna HTTP serveri emulaatorina kasutame nodejs-stub-server alates Maxim Ignatenko

Nodejs-stub-serveril pole rpm-i. Siit loome tale rpm. RPM koguneb abil Fedora Copr

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 benchmarki ja terminali multiplexer'i screen kõikidele 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 rohkem oleks.

var max_sleep = 10;

Käivitame stub_http_server'i.

systemctl start stub_http_server
systemctl enable stub_http_server

Clickhouse'i paigaldamine kolmandal serveril

ClickHouse kasutab SSE 4.2 käskude komplekti, seega muutub selle toetamine kasutatavas protsessoris lisaksüsteemi nõudeks, kui ei öelda teisiti. Siin on käsk, et kontrollida, kas praegune protsessor toetab SSE 4.2:

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

Esiteks peate ühendama ametliku repo:

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 peate täitma järgmised käsud:

sudo yum install -y clickhouse-server clickhouse-client

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

0.0.0.0

Muudame logimistasemest trace tasemele debug

debug

Pakkumise seadistused on vaikeseaded:

min_compress_block_size  65536
max_compress_block_size  1048576

Zstd pakkimise aktiveerimiseks soovitati konfiguratsiooni mitte muuta, vaid rakendada DDL-d.

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

Kollegid, kes kasutavad zstd pakkimist Clickhouse'is — palun jagage juhiseid.

Serveri käivitamiseks kui deemon, täitke:

service clickhouse-server start

Nüüd liigume Clickhouse'i seadistamise juurde

Logime sisse Clickhouse'isse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — Clickhouse'i installinud serveri IP.

Loome andmebaasi vector

CREATE DATABASE vector;

Kontrollime, kas andmebaas eksisteerib.

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, kas tabelid on loodud. Käivitame clickhouse-client ja teeme päringu.

Läheme andmebaasi vector.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Vaata tabelid.

show tables;

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

Elasticsearch'i paigaldamine neljandale serverile nende andmete saatmiseks Elasticsearch'i, et võrrelda Clickhouse'iga.

Lisame avaliku rpm-võtme

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

Loome 2 hoidlat:

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

[elasticsearch]
name=Elasticsearch hoidla 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 hoidla 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

Paigaldame Elasticsearch'i ja Kibana

yum install -y kibana elasticsearch

Kuna seda on üks eksemplar, tuleb faili /etc/elasticsearch/elasticsearch.yml lisada:

discovery.type: single-node

Kuna vector peab andmeid teiselt serverilt Elasticsearch'i saatma, muudame network.host.

network.host: 0.0.0.0

Kuna Kibana'ga ühenduse saamiseks peame muutma server.host parameetrit failis /etc/kibana/kibana.yml.

server.host: "0.0.0.0"

Käivitage ja lisage elasticsearch automaatne käivitus

systemctl enable elasticsearch
systemctl start elasticsearch

ja kibana

systemctl enable kibana
systemctl start kibana

Elasticsearchi konfigureerimine ühe sõlme režiimi jaoks 1 shard, 0 koopiat. Tõenäoliselt on teil kluster, mis koosneb suurest hulgast serveritest ja teil pole seda vaja teha.

Uuendame vaikimisi mall tulevaste indeksite jaoks:

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

Installeerimine Vector Logstashi asendamiseks teisel serveril

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

Seadistame Vectori Logstashi asendamiseks. Redigeerige 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"

Saate kohandada sektsiooni transforms.nginx_parse_add_defaults.

Kuna Vjačeslav Rakhinski kasutab neid konfiguratsioone väikese CDN-i jaoks ja seal võib upstream_* sisaldada mitut 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 teie olukord, siis seda sektsiooni saab lihtsustada

Loome teenuse seaded systemd jaoks /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 saate Vectori käivitada

systemctl enable vector
systemctl start vector

Vectori logisid saab vaadata järgmiselt

journalctl -f -u vector

Logides peaksid olema sellised kirjed

INFO vector::topology::builder: Tervisekontroll: Läbiti.
INFO vector::topology::builder: Tervisekontroll: Läbiti.

Kliendil (veebiserver) — 1. server

nginx serveris tuleb ipv6 välja lülitada, kuna clickhouse logide tabelis kasutatakse välja upstream_addr IPv4, kuna ma ei kasuta ipv6-d sisevõrgus. Kui ipv6 ei lülita välja, siis tekivad vead:

DB::Exception: Kehtetu IPv4 väärtus.: (klahvi upstream_addr väärtuse lugemisel)

Võib-olla lisatakse toetust ipv6.

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-i.

Lisa nginx repost faili /etc/yum.repos.d/nginx.repo

[nginx-stable]
name=nginx stabiilne 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

Esialgu peame seadistama Nginx logiformaadi failis /etc/nginx/nginx.conf

user  nginx;
# peate seadistama töötajate protsessid vastavalt oma CPU tuumadele, nginx ei saa kasu suurema määra seadmisest
worker_processes auto; # mõned viimased versioonid arvutavad seda automaatselt

# failide deskriptorite arv, mida nginx kasutab
# maksimaalne FD-de piir on serveris tavaliselt määratud operatsioonisüsteemi poolt.
# kui te FD-sid ei seadista, siis kasutatakse OS seadistusi, mis on vaikimisi 2000
worker_rlimit_nofile 100000;

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

# annab konfigureerimisfaili konteksti, milles määratakse soovitused, mis mõjutavad ühenduste töötlemist.
events {
    # määrab, kui palju kliente teenindatakse ühe töötaja kohta
    # maksimaalne kliente = worker_connections * worker_processes
    # maksimaalne kliente on samuti piiratud süsteemi saadaval olevate soklite ühenduste arvuga (~64k)
    worker_connections 4000;

    # optimeeritud paljude klientide teenindamiseks iga lõimega, hädavajalik linuxi jaoks -- testimiskeskkonnas
    use epoll;

    # aktsepteerib nii palju ühendusi kui võimalik, võib üle koormata töötaja ühendused, kui seatakse liiga madalaks -- testimiskeskkonnas
    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 praegust konfiguratsiooni ei kahjustaks, võimaldab Nginx kasutada mitmeid access_log direktiive

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

Ärge unustage logrotate'i reeglit uute logide jaoks (kui logifail ei lõpe .logiga)

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

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

Lisame virtuaalset hosti /etc/nginx/conf.d/vhost1.conf

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

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

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

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

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

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

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

Lisame failisse /etc/hosts virtuaalsed hostid (172.26.10.106 on nginx'i paigaldatud serveri IP) 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 seda Vector

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

Loodame seadete 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

Seame konfigureerime Filebeat asenduse faili /etc/vector/vector.toml. IP-aadress 172.26.10.108 on logiserver (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 rühm oma logifailide lugemiseks. Näiteks loob nginx CentOS-is logisid rühmaga adm.

usermod -a -G adm vector

Käivitame vector teenuse

systemctl enable vector
systemctl start vector

Vectori logisid saab vaadata järgmiselt

journalctl -f -u vector

Logides peaks olema selline kant.

INFO vector::topology::builder: Tervisetest: Läbiti.

Koormustestimine

Testime Apache benchmarki abil.

Kõikidele serveritele on installitud paketihttpd-tools.

Alustame testimist Apache benchmarkiga 4 erinevast serverist screenis. Esiteks käivitame terminali multiplexer screeni, seejärel käivitame testimise Apache benchmarkiga. Kuidas screeniga töötada, leiate artiklis.

Esimesest serverist

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

Teisest serverist

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

C 3. serverist

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

C 4. serverist

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

Kontrollime andmeid Clickhouse'is

Logime sisse Clickhouse'isse

clickhouse-client -h 172.26.10.109 -m

Teeme SQL päringu

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

Saame teada Clickhouse'i tabelite suurused

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;

Saame teada, kui palju koht logid Clickhouse'is võtavad.

Tabeli logs suurus on 857,19 MB.

Samade andmete suurus indeksis Elasticsearchis on 4,5 GB.

Kui Clickhouse'is ei osutada parameetrites vektorit, võtavad andmed 4500/857,19 = 5,24 korda vähem kui Elasticsearchis.

Vektori puhul kasutatakse väljal compression vaikimisi.

Telegrami vestlus Clickhouse
Telegrami vestlus Elasticsearch
Telegrami vestlus "Süsteemsete teadetete kogumine ja analüüs"

Allikas: habr.com