Dërgimi i logeve Nginx json me Vector në Clickhouse dhe Elasticsearch

Vector, e caktuar për mbledhjen, transformimin dhe dërgimin e të dhënave nga logs, metrika dhe ngjarje.

→ Github

E shkruar në gjuhën Rust, ajo karakterizohet nga një performancë e lartë dhe një konsum të ulët të memories në krahasim me alternativat. Për më tepër, është vënë një vëmendje e madhe në aspektet që lidhen me korrektësinë, veçanërisht mundësitë e ruajtjes së ngjarjeve të papara në memorie dhe rotacionin e skedarëve.

Arkitektura e Vector është një ruter ngjarjesh që pranon mesazhe nga një ose më shumë burime, duke aplikuar opsionalisht transformime, dhe duke i dërguar ato në një ose më shumë grupe lidhjesh..

Vector është një zëvendësim për filebeat dhe logstash, ai mund të funksionojë në të dy rolet (të marrë dhe të dërgojë loge), më shumë detaje mbi ta website.

Nëse në Logstash zinxhiri ndërttohet si input → filter → output, atëherë në Vector kjo është sources → transformon → kanale

Shembuj mund të shihni në dokumentacion.

Ky udhëzim është një rishikim i udhëzimit nga Vyacheslav Rakhinsky. Në udhëzimin origjinal ka përpunim geoip. Gjatë testimit tim, geoip nga rrjeti i brendshëm, vector jepte një gabim.

Aug 05 06:25:31.889 DEBUG transform{name=nginx_parse_rename_fields type=rename_fields}: vector::transforms::rename_fields: Fusha nuk ekziston, fusha=«geoip.country_name» rate_limit_secs=30

Nëse dikush ka nevojë të përpunojë geoip, atëherë lutem referojuni udhëzimit origjinal nga Vyacheslav Rakhinsky.

Do të konfigurojmë lidhjen Nginx (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → veçmas në Clickhouse dhe veçmas në Elasticsearch. Do të instalojmë 4 servera. Megjithatë, mund të mjaftojnë 3 servera.

Skema është afërsisht kështu.

Çaktivizojmë Selinux në të gjithë serverat tuaj

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

Në të gjithë serverat instalojmë emulatorin e serverit HTTP + utilitetet

Si emulator të serverit HTTP do të përdorim nodejs-stub-server nga Maxim Ignatenko

Nodejs-stub-server nuk ka rpm. Këtu e krijojmë rpm. Do të ndërtohet rpm nga Fedora Copr

Shtojmë depozitarin antonpatsev/nodejs-stub-server

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

Instalojmë nodejs-stub-server, Apache benchmark dhe terminalin multiplexer screen në të gjithë serverat

yum -y install stub_http_server screen mc httpd-tools screen

Kam rregulluar në skedarin \/var\/lib\/stub_http_server\/stub_http_server.js kohën e përgjigjes së stub_http_server që të ketë më shumë loge.

var max_sleep = 10;

Do ta ndajmë stub_http_server.

systemctl start stub_http_server\nsystemctl enable stub_http_server

Instalimi i Clickhouse në serverin 3

ClickHouse përdor një grup instrukcionesh SSE 4.2, prandaj, nëse nuk tregohet ndryshe, mbështetja e saj në procesorin e përdorur bëhet një kërkesë shtesë për sistemin. Ja 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 duhet të lidhni depozitën zyrtare:

sudo yum install -y yum-utils\nsudo rpm --import https://repo.clickhouse.tech/CLICKHOUSE-KEY.GPG\nsudo yum-config-manager --add-repo https://repo.clickhouse.tech/rpm/stable/x86_64

Për të instaluar paketat duhet të ekzekutoni komandat ndjekëse:

sudo yum install -y clickhouse-server clickhouse-client

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

0.0.0.0

Ndryshojmë nivelin e regjistrimit nga trace në debug

debug

Cilësimet e kompresimit janë standart:

min_compress_block_size  65536\nmax_compress_block_size  1048576

Për të aktivizuar kompresimin Zstd, është këshilluar të mos e prekni konfigurimin, por më mirë ta aplikoni DDL.

Si të aplikojë kompresimin zstd përmes DDL në Google nuk e kam gjetur. Prandaj e lashë siç ishte.

Të dashur kolegë, kush përdor kompresimin zstd në Clickhouse — ju lutem ndani udhëzimet.

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

service clickhouse-server start

Tani kalojmë në konfigurimin e Clickhouse.

Hyjmë në Clickhouse.

clickhouse-client -h 172.26.10.109 -m

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

Do të krijojmë BD-në vector.

CREATE DATABASE vector;

Verifikojmë që BD të ekzistojë.

show databases;

Krijojmë tabelën 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;

Verifikojmë që tabelat janë krijuar. Nisemi: clickhouse-client dhe bëjmë kërkesën.

Kalojmë në BD-në vector.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Shikojmë tabelat.

show tables;

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

Instalimi i elasticsearch në serverin e katërt për dërgimin e të dhënave të njëjta në Elasticsearch për krahasim me Clickhouse.

Do të shtojmë çelësin publik rpm.

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

Do 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

Do të instalojmë elasticsearch dhe kibana.

yum install -y kibana elasticsearch

Pasi do të jetë në një ekzemplar, në skedarin /etc/elasticsearch/elasticsearch.yml duhet të shtoni:

discovery.type: single-node

Për të lejuar këtë vector të dërgojë të dhëna në elasticsearch nga një server tjetër ndryshojmë network.host.

network.host: 0.0.0.0

Për të lidhur me kibana ndryshojmë parametër server.host në skedarin /etc/kibana/kibana.yml.

server.host: "0.0.0.0"

Nisemi dhe aktivizojmë elasticsearch në nisje automatike.

systemctl enable elasticsearch
systemctl start elasticsearch

dhe kibana.

systemctl enable kibana
systemctl start kibana

Konfigurimi i Elasticsearch për modin single-node 1 shard, 0 replica. Prandaj ka shumë mundësi që do të keni një klaster me shumë serverë dhe nuk keni nevojë ta bëni këtë.

Për indeksat e ardhshëm përditësojmë shabllonin e parazgjedhur:

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

Instalimi Vector si 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

Do të konfiguroni Vector si zëvendësim për Logstash. Redaktoni skedarin /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.

Meqenëse Vyacheslav Rakhinsky përdor këto konfigurations për një CDN të vogël dhe aty në upstream_* mund të vijnë disa vlera.

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, mund ta thjeshtoni këtë seksion.

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ë nisin Vector.

systemctl enable vector
systemctl start vector

Logs për vector mund të shihen kështu:

journalctl -f -u vector

Në log duhet të ketë këto regjistrime:

INFO vector::topology::builder: Healthcheck: Kaloi.
INFO vector::topology::builder: Healthcheck: Kaloi.

Në klient (Web server) — serveri i parë

Në serverin me nginx është e nevojshme të çaktivizohet ipv6, pasi në tabelën logs në clickhouse përdoret fusha upstream_addr IPv4, pasi unë nuk përdor ipv6 brenda rrjetit. Nëse ipv6 nuk çaktivizohet, do të ketë gabime:

DB::Exception: Vlerë e pavlefshme IPv4.: (ndërsa lexon vlerën e çelësit upstream_addr)

Ndoshta lexuesit, të shtojnë mbështetje për ipv6.

Krijojmë 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

Zbatim cilësimet

sysctl --system

Të instalojmë nginx.

Shtova skedarin e depozitës nginx /etc/yum.repos.d/nginx.repo

[nginx-stable]
name=depo e qëndrueshme nginx
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Të instalojmë paketën nginx.

yum install -y nginx

Fillimisht duhet të konfiguroni formatin e logeve në Nginx në skedarin /etc/nginx/nginx.conf

përdorues nginx;
# duhet të vendosni proceset e punës sipas bërthamave të CPU-së tuaj, nginx nuk përfiton nga vendosja e më shumë se kaq
worker_processes auto; #disa versione të fundit e llogarisin automatikisht

# numri i descriptorëve të skedarëve të përdorur për nginx
# kufiri për FD-të maksimale në server zakonisht është vendosur nga OS.
# nëse nuk vendosni FD, atëherë do të përdoren cilësimet e OS, të cilat janë në mënyrë default 2000
worker_rlimit_nofile 100000;

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

# siguron kontekstin e skedarit të konfigurimit në të cilin specifikohen direktivat që ndikojnë në procesimin e lidhjeve.
events {
    # përcakton sa shumë klientë do të shërbehen për çdo punëtor
    # klientët maksimale = lidhjet_e_punës * proceset_e_punës
    # klientët maksimale gjithashtu kufizohen nga numri i lidhjeve socket të disponueshme në sistem (~64k)
    worker_connections 4000;

    # optimizuar për të shërbyer shumë klientë me çdo thread, thelbësor për linux -- për ambientin e testimit
    use epoll;

    # pranoni aq shumë lidhje sa të jetë e mundur, mund të mbingarkojë lidhjet e punëtorëve nëse vendoset shumë ulët -- për ambientin e testimit
    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;      # Log i ri në format 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 lejon të ketë disa drejtime access_log

access_log  /var/log/nginx/access.log  main;            # Logu standard
access_log  /var/log/nginx/access.json.log vector;      # Logu i ri në format json

Mos harroni të shtoni një rregull në logrotate për logët e reja (nëse skedari log nuk përfundon në .log)

Fshijmë default.conf nga /etc/nginx/conf.d/

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

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

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

Shtojmë hostin virtual në /etc/nginx/conf.d/vhost2.conf

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

Shtojmë hostin virtual në /etc/nginx/conf.d/vhost3.conf

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

Shtojmë hostin virtual në /etc/nginx/conf.d/vhost4.conf

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

Shtojmë në skedarin /etc/hosts hostet virtuale (172.26.10.106 ip i serverit ku është instaluar nginx) në të gjithë serverat:

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 do të instalojmë vetë Vector

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

Do të krijojmë skedarin e konfigurimit për systemd në /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 do të konfigurimizojmë zëvendësimin e Filebeat në konfigurimin e /etc/vector/vector.toml. Adresa IP 172.26.10.108 është adresa IP e serverit të logëve (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"

Mos harroni të shtoni përdoruesin vector në grupin e duhur që ai të mund të lexojë skedaret e logëve. Për shembull, nginx në centos krijon loge me të drejtat e grupit adm.

usermod -a -G adm vector

Do ta nisim shërbimin vector

systemctl enable vector
systemctl start vector

Logs për vector mund të shihen kështu:

journalctl -f -u vector

Në log duhet të jetë një regjistrim i tillë

INFO vector::topology::builder: Healthcheck: Kaloi.

Testimi i ngarkesës

Testimi realizohet me ndihmën e Apache benchmark.

Në të gjithë serverat është instaluar paketa httpd-tools

Nisim testimin me ndihmën e Apache benchmark nga 4 servera të ndryshëm në screen. Së pari, nisim multiplexer terminalin screen, dhe pastaj fillojmë testimin me Apache benchmark. Si të punoni me screen mund ta gjeni në artikulli ynë.

Nga serveri 1

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

Nga serveri 2

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

Nga serveri 3

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

Nga serveri 4

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

Do të kontrollojmë të dhënat në Clickhouse

Hyjmë në Clickhouse.

clickhouse-client -h 172.26.10.109 -m

Bëjmë kërkesë 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 │                       │
└──────────────┴─────────────────────┴─────────────┴─────────┴────────────────┴────────────────────┴───────────────────┴─────────────┴────────────────┴────────────────┴────────────────┴──────────────┴──────────────────┴─────────────────┴──────────────────────────┴───────────────────────┴───────────────┴─────────────┴─────────────┴───────────────┴───────────────┴─────────────────────────┴─────────────────────┴───────────────────────┴───────────────────────┴──────────────────────┴──────────────────────────┴────────────────────────┴─────────────────┴───────────────────────

Të gjejmë 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;

Të gjejmë se sa hapësirë kanë zënë log-et në Clickhouse.

Madhësia e tabelës logs zë 857.19 MB.

Këto të dhëna në indeksin e Elasticsearch zënë 4.5GB.

Nëse në parametrat e vector nuk specifikohet, të dhënat në Clickhouse zënë 4500/857.19 = 5.24 herë më pak se në Elasticsearch.

Fushën compression në vector e përdorim me parazgjedhje.

Biseda në Telegram për Clickhouse
Biseda në Telegram për Elasticsearch
Biseda në Telegram për "Mbledhja dhe analiza e sistemeve mesazhe"

Burimi: habr.com