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

Vector, e caktuar për mbledhjen, transformimin dhe dërgimin e të dhënave të regjistrave, metrikave dhe ngjarjeve.

→ Github

Duke u shkruar në gjuhën Rust, ai ofron performancë të lartë dhe konsum të ulët të memories në krahasim me alternativat. Për më tepër, janë kushtuar vëmendje të madhe funksioneve që lidhen me saktësinë, veçanërisht mundësive për të ruajtur ngjarjet e papërfshira në një bufer në disk dhe rotacionin e skedarëve.

Arkitektura e Vector është një rrugëzim ngjarjesh, që pranon mesazhe nga një ose më shumë burime, duke aplikuar opcionalisht mbi këto mesazhe transformime, dhe duke i dërguar ato në një ose më shumë kanale..

Vector është një zëvendësim për filebeat dhe logstash, ai mund të luajë të dy rolet (të marrë dhe të dërgojë regjistrat), më shumë detaje në të internetit.

Nëse në Logstash zinxhiri ndërtohet si input → filter → output, në Vector është sources → transformon → zjarre

Shembujt mund të shihen në dokumentacion.

Ky udhëzues është një përpunim i udhëzimit nga Vyacheslav Rakhinsky. Në udhëzimin origjinal ka përpunim geoip. Gjatë testimit të 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 ekzistonte fushë=«geoip.country_name» rate_limit_secs=30

Nëse dikujt i nevojitet të përpunojë geoip, ju lutem konsultohuni me udhëzimin origjinal nga Vyacheslav Rakhinsky.

Do të konfiguroni lidhjen Nginx (Regjistrat e aksesit) → Vector (Klienti | Filebeat) → Vector (Serveri | Logstash) → veçmas në Clickhouse dhe veçmas në Elasticsearch. Do të vendosim 4 servera. Megjithatë, është e mundur të kalojmë me 3 servera.

Skema është përafërsisht kjo.

Çaktivizoni Selinux në të gjithë serverat tuaj

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

Në të gjitha serverat instaloni emulatorin e serverit HTTP + utilitetet

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

Nodejs-stub-server nuk ka rpm. Këtu do ta krijojmë rpm. Do të ndërtohet rpm me ndihmën e Fedora Copr

Shtoni repositorin antonpatsev/nodejs-stub-server

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

Instaloni nodejs-stub-server, Apache benchmark dhe muxhionin e terminalit screen në të gjithë serverat

yum -y install stub_http_server screen mc httpd-tools screen

E 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ë regjistra.

var max_sleep = 10;

Do ta nisim stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Instalimi i Clickhouse në serverin 3

ClickHouse përdor një grup instruksionesh SSE 4.2, prandaj, nëse nuk specifikohet ndryshe, mbështetja në procesorin përdorues të bëhet një kërkesë shtesë për sistemin. Këtu është komanda për të kontrolluar nëse procesori aktual mbështet SSE 4.2:

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

Së pari, duhet të lidhni repositorin zyrtar:

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

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

sudo yum install -y clickhouse-server clickhouse-client

Lejojini clickhouse-server të dëgjojë kartën rrjetë në skedarin /etc/clickhouse-server/config.xml

0.0.0.0

Ndryshoni nivelin e regjistrimit nga trace në debug

debug

Konfigurimet e kompresimit janë standarde:

min_compress_block_size  65536
max_compress_block_size  1048576

Për aktivizimin e kompresimit Zstd, është rekomanduar që konfigurimi të mos preket dhe të aplikohet më mirë DDL.

Nuk kam gjetur se si të aplikoj kompresionin zstd përmes DDL në Google. Prandaj e la siç është.

Kolegë, kush përdor kompresionin 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.

Krijojmë databazën vector

CREATE DATABASE vector;

Të kontrollojmë se databaza ekziston.

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;

Kontrollojmë se tabelat janë krijuar. Nisim clickhouse-client dhe bëjmë një kërkesë.

Kalojmë në databazë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

Shtojmë çelësin publik rpm

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

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

Duke qenë se do të ketë një ekzemplar, në skedarin /etc/elasticsearch/elasticsearch.yml duhet të shtojmë:

discovery.type: single-node

Për të mundësuar që 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’u lidhur me kibana, ndryshojmë parametrin server.host në skedarin /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Nisim dhe aktivizojmë në autostart elasticsearch

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. Ndoshta do të keni një klaster me numër të madh serverash dhe nuk do t'ju nevojitet ta bëni këtë.

Për indekset e ardhshme, 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

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"

Mund të redaktoni seksionin transforms.nginx_parse_add_defaults.

Sepse Viacheslav Rakhinskiy përdor këto konfigurations për një CDN të vogël dhe aty në upstream_* mund të mbërrijnë 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, atëherë kjo seksion mund të thjeshtohet.

Do të krijojmë konfigurimet e shërbimit për systemd në /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

Pasi të krijohen tabelat, mund të nisni Vector.

systemctl enable vector
systemctl start vector

Log-et e vector mund të shihen kështu:

journalctl -f -u vector

Në log, duhet të ketë këto shënime:

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

Në klient (Serveri Web) — serveri i parë.

Në serverin me nginx, duhet të çaktivizohet ipv6, pasi në tabelën e log-eve në clickhouse përdoret fushë. upstream_addr IPv4, sepse nuk po përdor ipv6 brenda rrjetit. Nëse ipv6 nuk çaktivizohet, do të ketë gabime:

DB::Exception: Vlera e pavlefshme IPv4.: (kur lexohet vlera e çelësit upstream_addr)

Mundësisht lexuesit, të shtohet 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

Aplikojmë konfigurimet.

sysctl --system

Do të instalojmë nginx.

Shtova skedarin e repository-t nginx në /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

Do të instalojmë paketën nginx.

yum install -y nginx

Për fillim, na duhet të konfigurojmë formatin e log-eve në Nginx në skedarin /etc/nginx/nginx.conf.

përdorues nginx;
# duhet të vendosni proceset e punës bazuar në bërthamat e CPU-së, 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 FDs më të larta në server zakonisht vendoset nga OS.
# nëse nuk vendosni FD, atëherë cilësimet e OS do të përdoren, që është me të drejtë 2000
worker_rlimit_nofile 100000;

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

# ofron kontekstin e skedarit të konfigurimit ku janë specifikuar direktivat që ndikojnë në përpunimin e lidhjeve.
events {
    # përcakton sa klientë do të shërbehen për proces punëtor
    # max klientë = worker_connections * worker_processes
    # max klientët gjithashtu është i kufizuar nga numri i lidhjeve të soketëve të disponueshme në sistem (~64k)
    worker_connections 4000;

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

    # pranoni sa më shumë lidhje të jetë e mundur, mund të mbingarkojë lidhjet e punës nëse vendoset shumë e 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ë formatin 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 e lejon të keni disa direktiva access_log.

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

Mos harroni të shtoni rregull në logrotate për logët e rinj (nëse skedari i logut nuk përfundon me .log).

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

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

Shtoni një host virtual në /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ë hostet virtuale në skedarin /etc/hosts (172.26.10.106 ip serveri ku është instaluar nginx) në të gjitha 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

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 konfiguroni zëvendësimin e Filebeat në konfigurimin /etc/vector/vector.toml. Adresa IP 172.26.10.108 është adresa IP e serverit të log (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 haroni të shtoni përdoruesin vector në grupin e nevojshëm që të mund të lexojë skedarët e log. Për shembull, nginx në centos krijon log me privilegjet e grupit adm.

usermod -a -G adm vector

Të fillojmë shërbimin vector

systemctl enable vector
systemctl start vector

Log-et e vector mund të shihen kështu:

journalctl -f -u vector

Në log duhet të ketë këtë përshkrim

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

Testimi i ngarkesës

Testimi kryhet me ndihmën e Apache benchmark.

Pakoja httpd-tools është instaluar në të gjithë serverat

Po fillojmë testimin duke përdorur Apache benchmark nga 4 servera të ndryshëm në screen. Së pari, fillojmë multiplexerin terminal screen, dhe pastaj fillojmë testimin duke përdorur Apache benchmark. Si të punoni me screen, mund ta gjeni në artikullin.

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

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

Mësojmë 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;

Mësojmë sa hapësirë zënë log-et në Clickhouse.

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

Të dhënat e njëjta në indeksin e Elasticsearch zënë 4.5GB.

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

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

Grupi në Telegram për Clickhouse
Grupi në Telegram për Elasticsearch
Grupi në Telegram për "Mbledhja dhe analiza e sistemeve të mesazheve"

Burimi: habr.com