Nginx json-logboeken verzenden met Vector naar Clickhouse en Elasticsearch

vector, ontworpen om loggegevens, statistieken en gebeurtenissen te verzamelen, transformeren en verzenden.

→ GitHub

Het is geschreven in de Rust-taal en wordt gekenmerkt door hoge prestaties en een laag RAM-verbruik in vergelijking met zijn analogen. Daarnaast wordt veel aandacht besteed aan functies die verband houden met correctheid, in het bijzonder de mogelijkheid om niet-verzonden gebeurtenissen op te slaan in een buffer op schijf en bestanden te roteren.

Architectonisch gezien is Vector een gebeurtenisrouter die berichten ontvangt van een of meer bronnen, optioneel toe te passen op deze berichten transformatiesen stuur ze naar een of meer afvoeren.

Vector is een vervanging voor filebeat en logstash, het kan in beide rollen optreden (logs ontvangen en verzenden), meer details hierover Online.

Als in Logstash de keten is gebouwd als invoer → filter → uitvoer, dan is dat in Vector het geval bronnen → transformaties → wastafels

Voorbeelden vindt u in de documentatie.

Deze instructie is een herziene instructie van Vjatsjeslav Rakinski. De originele instructies bevatten geoip-verwerking. Bij het testen van geoip vanaf een intern netwerk gaf vector een foutmelding.

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

Als iemand geoip moet verwerken, raadpleeg dan de originele instructies van Vjatsjeslav Rakinski.

We zullen de combinatie van Nginx (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → afzonderlijk configureren in Clickhouse en afzonderlijk in Elasticsearch. Wij installeren 4 servers. Al kun je het omzeilen met 3 servers.

Het schema is ongeveer zo.

Schakel Selinux uit op al uw servers

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

We installeren een HTTP-serveremulator + hulpprogramma's op alle servers

Als HTTP-serveremulator zullen we gebruiken nodejs-stub-server van Maxim Ignatenko

Nodejs-stub-server heeft geen rpm. Hier maak er een toerental voor. rpm zal worden gebouwd met behulp van Fedora Kopr

Voeg de antonpatsev/nodejs-stub-server-repository toe

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

Installeer nodejs-stub-server, Apache benchmark en screen terminal multiplexer op alle servers

yum -y install stub_http_server screen mc httpd-tools screen

Ik heb de responstijd van stub_http_server in het bestand /var/lib/stub_http_server/stub_http_server.js gecorrigeerd, zodat er meer logboeken waren.

var max_sleep = 10;

Laten we stub_http_server starten.

systemctl start stub_http_server
systemctl enable stub_http_server

Clickhouse-installatie op server3

ClickHouse maakt gebruik van de SSE 4.2-instructieset, dus tenzij anders aangegeven, wordt ondersteuning hiervoor in de gebruikte processor een extra systeemvereiste. Hier is de opdracht om te controleren of de huidige processor SSE 4.2 ondersteunt:

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

Eerst moet je de officiële repository verbinden:

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

Om pakketten te installeren, moet u de volgende opdrachten uitvoeren:

sudo yum install -y clickhouse-server clickhouse-client

Laat clickhouse-server luisteren naar de netwerkkaart in het bestand /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Het logboekniveau wijzigen van traceren naar debuggen

debug

Standaard compressie-instellingen:

min_compress_block_size  65536
max_compress_block_size  1048576

Om Zstd-compressie te activeren, werd geadviseerd om de configuratie niet aan te raken, maar om DDL te gebruiken.

Ik kon niet vinden hoe ik zstd-compressie via DDL in Google kon gebruiken. Dus ik liet het zoals het was.

Collega's die zstd-compressie gebruiken in Clickhouse, deel alstublieft de instructies.

Om de server als een daemon te starten, voer je het volgende uit:

service clickhouse-server start

Laten we nu verder gaan met het opzetten van Clickhouse

Ga naar Klikhuis

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP van de server waarop Clickhouse is geïnstalleerd.

Laten we een vectordatabase maken

CREATE DATABASE vector;

Laten we controleren of de database bestaat.

show databases;

Maak een vector.logs-tabel.

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

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;

We controleren of de tabellen zijn gemaakt. Laten we lanceren clickhouse-client en doe een verzoek.

Laten we naar de vectordatabase gaan.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Laten we naar de tabellen kijken.

show tables;

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

Elasticsearch installeren op de 4e server om dezelfde gegevens naar Elasticsearch te sturen ter vergelijking met Clickhouse

Voeg een openbare rpm-sleutel toe

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

Laten we 2 repository's maken:

/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

Installeer elasticsearch en kibana

yum install -y kibana elasticsearch

Omdat het in 1 kopie zal zijn, moet je het volgende toevoegen aan het bestand /etc/elasticsearch/elasticsearch.yml:

discovery.type: single-node

Zodat de vector gegevens naar elasticsearch kan sturen vanaf een andere server, laten we network.host wijzigen.

network.host: 0.0.0.0

Om verbinding te maken met kibana, wijzigt u de parameter server.host in het bestand /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Oud en neem elasticsearch op in autostart

systemctl enable elasticsearch
systemctl start elasticsearch

en kibana

systemctl enable kibana
systemctl start kibana

Elasticsearch configureren voor modus met één knooppunt 1 scherf, 0 replica. Hoogstwaarschijnlijk heeft u een cluster van een groot aantal servers en hoeft u dit niet te doen.

Voor toekomstige indexen werkt u de standaardsjabloon bij:

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

installatie vector als vervanging voor Logstash op server 2

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

Laten we Vector instellen als vervanging voor Logstash. Het bestand /etc/vector/vector.toml bewerken

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

U kunt de sectie transforms.nginx_parse_add_defaults aanpassen.

Als Vjatsjeslav Rakinski gebruikt deze configuraties voor een kleine CDN en er kunnen verschillende waarden in upstream_* zijn

Bijvoorbeeld:

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

Als dit niet uw situatie is, kan dit gedeelte worden vereenvoudigd

Laten we service-instellingen maken voor 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

Nadat u de tabellen hebt gemaakt, kunt u Vector uitvoeren

systemctl enable vector
systemctl start vector

Vectorlogboeken kunnen als volgt worden bekeken:

journalctl -f -u vector

Dergelijke vermeldingen zouden in de logboeken moeten staan

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

Op de client (webserver) - 1e server

Op de server met nginx moet je ipv6 uitschakelen, omdat de logtabel in clickhouse het veld gebruikt upstream_addr IPv4, aangezien ik binnen het netwerk geen ipv6 gebruik. Als ipv6 niet is uitgeschakeld, zullen er fouten optreden:

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

Misschien lezers, voeg ipv6-ondersteuning toe.

Maak het bestand /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

De instellingen toepassen

sysctl --system

Laten we nginx installeren.

Nginx-repositorybestand /etc/yum.repos.d/nginx.repo toegevoegd

[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

Installeer het nginx-pakket

yum install -y nginx

Eerst moeten we het logformaat in Nginx configureren in het bestand /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;
}

Om uw huidige configuratie niet te verbreken, kunt u met Nginx verschillende access_log-richtlijnen hebben

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

Vergeet niet een regel toe te voegen om te logroteren voor nieuwe logs (tenzij het logbestand eindigt met .log)

Verwijder default.conf uit /etc/nginx/conf.d/

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

Voeg virtuele host /etc/nginx/conf.d/vhost1.conf toe

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

Voeg virtuele host /etc/nginx/conf.d/vhost2.conf toe

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

Voeg virtuele host /etc/nginx/conf.d/vhost3.conf toe

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

Voeg virtuele host /etc/nginx/conf.d/vhost4.conf toe

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

Voeg virtuele hosts (172.26.10.106 ip van de server waarop nginx is geïnstalleerd) toe aan alle servers in het bestand /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

En als alles dan klaar is

nginx -t 
systemctl restart nginx

Laten we het nu zelf installeren vector

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

Laten we een instellingenbestand maken voor systemd /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

En configureer de Filebeat-vervanging in de configuratie /etc/vector/vector.toml. IP-adres 172.26.10.108 is het IP-adres van de logserver (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"

Vergeet niet de vectorgebruiker aan de gewenste groep toe te voegen, zodat hij logbestanden kan lezen. Nginx in centos maakt bijvoorbeeld logboeken met adm-groepsrechten.

usermod -a -G adm vector

Laten we de vectorservice starten

systemctl enable vector
systemctl start vector

Vectorlogboeken kunnen als volgt worden bekeken:

journalctl -f -u vector

Er zou een dergelijke vermelding in de logboeken moeten staan

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

Stress testen

Het testen wordt uitgevoerd met behulp van Apache benchmark.

Het httpd-tools-pakket is op alle servers geïnstalleerd

We beginnen met testen met behulp van de Apache-benchmark vanaf 4 verschillende servers in het scherm. Eerst lanceren we de screenterminal-multiplexer en daarna beginnen we te testen met behulp van de Apache-benchmark. Hoe u met het scherm kunt werken, vindt u in статье.

Van de 1e server

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

Van de 2e server

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

Van de 3e server

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

Van de 4e server

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

Laten we de gegevens in Clickhouse controleren

Ga naar Klikhuis

clickhouse-client -h 172.26.10.109 -m

Een SQL-query maken

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

Ontdek de grootte van tafels in 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;

Laten we eens kijken hoeveel logbestanden in Clickhouse in beslag namen.

De logtabelgrootte is 857.19 MB.

De grootte van dezelfde gegevens in de index in Elasticsearch is 4,5 GB.

Als u geen gegevens in de vector opgeeft in de parameters, neemt Clickhouse 4500/857.19 = 5.24 keer minder dan in Elasticsearch.

In vector wordt standaard het compressieveld gebruikt.

Telegramchat door klikhuis
Telegramchat door Elasticsearch
Telegramchat door "Verzameling en analyse van het systeem berichten"

Bron: www.habr.com