Sendante Nginx json-programojn uzante Vector al Clickhouse kaj Elasticsearch

vektoro, desegnita por kolekti, transformi kaj sendi protokolojn, metrikojn kaj eventojn.

→ GitHub

Estante skribita en la Rust-lingvo, ĝi estas karakterizita per alta rendimento kaj malalta RAM-konsumo kompare kun siaj analogoj. Krome, multe da atento estas donita al funkcioj rilataj al ĝusteco, precipe la kapablo konservi nesenditajn eventojn al bufro sur disko kaj turni dosierojn.

Arkitekture, Vector estas evento-enkursigilo, kiu ricevas mesaĝojn de unu aŭ pli fontoj, laŭvole aplikante super ĉi tiuj mesaĝoj transformoj, kaj sendante ilin al unu aŭ pli dreniloj.

Vektoro estas anstataŭaĵo por filebeat kaj logstash, ĝi povas agi en ambaŭ roloj (ricevi kaj sendi protokolojn), pli da detaloj pri ili ejo.

Se en Logstash la ĉeno estas konstruita kiel enigo → filtrilo → eligo tiam en Vector ĝi estas fontoj → transformas → enprofundigas

Ekzemploj troviĝas en la dokumentado.

Ĉi tiu instrukcio estas reviziita instrukcio de Vjaĉeslav Rakhinsky. La originalaj instrukcioj enhavas geoip-pretigon. Dum testado de geoip de interna reto, vektoro donis eraron.

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

Se iu bezonas prilabori geoip, tiam raportu al la originalaj instrukcioj de Vjaĉeslav Rakhinsky.

Ni agordos la kombinaĵon de Nginx (Alirprotokoloj) → Vektora (Kliento | Filebeat) → Vektora (Servilo | Logstash) → aparte en Clickhouse kaj aparte en Elasticsearch. Ni instalos 4 servilojn. Kvankam vi povas preteriri ĝin per 3 serviloj.

La skemo estas io tia.

Malebligu Selinux sur ĉiuj viaj serviloj

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

Ni instalas HTTP-servilan emulilon + ilojn sur ĉiuj serviloj

Kiel HTTP-servila emulilo ni uzos nodejs-stub-servilo el Maksimo Ignatenko

Nodejs-stub-server ne havas rpm. estas krei rpm por ĝi. rpm estos konstruita uzante Fedora Copr

Aldonu la deponejon antonpatsev/nodejs-stub-server

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

Instalu nodejs-stub-server, Apache benchmark kaj ekranfinan multipleksilon sur ĉiuj serviloj

yum -y install stub_http_server screen mc httpd-tools screen

Mi korektis la stub_http_server respondtempon en la /var/lib/stub_http_server/stub_http_server.js dosiero por ke estis pli da protokoloj.

var max_sleep = 10;

Ni lanĉu stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Instalado de Clickhouse sur la servilo 3

ClickHouse uzas la SSE 4.2 instrukciaĵon, do krom se alie specifita, subteno por ĝi en la procesoro uzita iĝas plia sistema postulo. Jen la komando por kontroli ĉu la nuna procesoro subtenas SSE 4.2:

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

Unue vi devas konekti la oficialan deponejon:

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

Por instali pakaĵojn vi devas ruli la jenajn komandojn:

sudo yum install -y clickhouse-server clickhouse-client

Permesu al clickhouse-server aŭskulti la retkarton en la dosiero /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Ŝanĝante la registran nivelon de spuro al senararigo

elpurigi

Normaj kunpremaj agordoj:

min_compress_block_size  65536
max_compress_block_size  1048576

Por aktivigi Zstd-kunpremadon, oni konsilis ne tuŝi la agordon, sed prefere uzi DDL.

Mi ne povis trovi kiel uzi zstd-kunpremadon per DDL en Guglo. Do mi lasis ĝin tia.

Kolegoj, kiuj uzas zstd-kunpremadon en Clickhouse, bonvolu dividi la instrukciojn.

Por lanĉi la servilon kiel demono, rulu:

service clickhouse-server start

Nun ni pluiru al agordo de Clickhouse

Iru al Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP de la servilo, kie estas instalita Clickhouse.

Ni kreu vektoran datumbazon

CREATE DATABASE vector;

Ni kontrolu, ke la datumbazo ekzistas.

show databases;

Krei tabelon 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;

Ni kontrolas, ke la tabeloj estas kreitaj. Ni lanĉu clickhouse-client kaj faru peton.

Ni iru al la vektora datumbazo.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Ni rigardu la tabelojn.

show tables;

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

Instalante elasticsearch sur la 4-a servilo por sendi la samajn datumojn al Elasticsearch por komparo kun Clickhouse

Aldonu publikan rpm-klavon

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

Ni kreu 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

Instalu elasticsearch kaj kibana

yum install -y kibana elasticsearch

Ĉar ĝi estos en 1 kopio, vi devas aldoni la jenon al la dosiero /etc/elasticsearch/elasticsearch.yml:

discovery.type: single-node

Do tiu vektoro povas sendi datumojn al elasticsearch de alia servilo, ni ŝanĝu network.host.

network.host: 0.0.0.0

Por konektiĝi al kibana, ŝanĝu la parametron server.host en la dosiero /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Malnova kaj inkluzivu elastan serĉon en aŭtomata starto

systemctl enable elasticsearch
systemctl start elasticsearch

kaj kibana

systemctl enable kibana
systemctl start kibana

Agordante Elasticsearch por unu-noda reĝimo 1 peceto, 0 kopio. Plej verŝajne vi havos areton de granda nombro da serviloj kaj vi ne bezonas fari tion.

Por estontaj indeksoj, ĝisdatigu la defaŭltan ŝablonon:

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

fikso vektoro kiel anstataŭaĵo por Logstash sur servilo 2

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

Ni starigu Vector kiel anstataŭaĵon por Logstash. Redaktante la dosieron /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"

Vi povas ĝustigi la transforms.nginx_parse_add_defaults sekcion.

Ekde Vjaĉeslav Rakhinsky uzas ĉi tiujn agordojn por malgranda CDN kaj povas esti pluraj valoroj en kontraŭfluo_*

Ekzemple:

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

Se ĉi tio ne estas via situacio, tiam ĉi tiu sekcio povas esti simpligita

Ni kreu servo-agordojn por 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

Post kreado de la tabeloj, vi povas ruli Vector

systemctl enable vector
systemctl start vector

Vektoraj protokoloj povas esti rigardataj jene:

journalctl -f -u vector

Devus esti enskriboj kiel ĉi tiu en la protokoloj

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

Sur la kliento (TTT-servilo) - 1-a servilo

Sur la servilo kun nginx, vi devas malŝalti ipv6, ĉar la protokolo-tabelo en clickhouse uzas la kampon upstream_addr IPv4, ĉar mi ne uzas ipv6 ene de la reto. Se ipv6 ne estas malŝaltita, estos eraroj:

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

Eble legantoj, aldonu ipv6-subtenon.

Kreu la dosieron /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

Aplikante la agordojn

sysctl --system

Ni instalu nginx.

Aldonita nginx-deponeja dosiero /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

Instalu la pakaĵon nginx

yum install -y nginx

Unue, ni devas agordi la protokolformaton en Nginx en la dosiero /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;
}

Por ne rompi vian nunan agordon, Nginx permesas al vi havi plurajn direktivojn access_log

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

Ne forgesu aldoni regulon al logrotate por novaj protokoloj (se la protokolo-dosiero ne finiĝas per .log)

Forigu default.conf de /etc/nginx/conf.d/

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

Aldonu virtualan gastiganton /etc/nginx/conf.d/vhost1.conf

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

Aldonu virtualan gastiganton /etc/nginx/conf.d/vhost2.conf

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

Aldonu virtualan gastiganton /etc/nginx/conf.d/vhost3.conf

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

Aldonu virtualan gastiganton /etc/nginx/conf.d/vhost4.conf

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

Aldonu virtualajn gastigantojn (172.26.10.106 ip de la servilo kie nginx estas instalita) al ĉiuj serviloj al la /etc/hosts dosiero:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Kaj se ĉio estas preta tiam

nginx -t 
systemctl restart nginx

Nun ni mem instalu ĝin vektoro

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

Ni kreu agordan dosieron por 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

Kaj agordu la anstataŭaĵon de Filebeat en la agordo /etc/vector/vector.toml. IP-adreso 172.26.10.108 estas la IP-adreso de la protokolo-servilo (Vektoro-Servilo)

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"

Ne forgesu aldoni la vektoran uzanton al la bezonata grupo, por ke li povu legi protokolojn. Ekzemple, nginx en centos kreas protokolojn kun adm-grupo-rajtoj.

usermod -a -G adm vector

Ni komencu la vektoran servon

systemctl enable vector
systemctl start vector

Vektoraj protokoloj povas esti rigardataj jene:

journalctl -f -u vector

Devus esti enskribo tia en la protokoloj

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

Streĉa Testado

Testado estas farita per Apache-komparnormo.

La pako httpd-tools estis instalita sur ĉiuj serviloj

Ni komencas testi uzante Apache-komparnormon de 4 malsamaj serviloj en ekrano. Unue, ni lanĉas la ekranan terminalan multipleksilon, kaj poste ni komencas testi uzante la Apache-komparnormon. Kiel labori kun ekrano vi povas trovi en artikolo.

De la unua servilo

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

De la unua servilo

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

De la unua servilo

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

De la unua servilo

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

Ni kontrolu la datumojn en Clickhouse

Iru al Clickhouse

clickhouse-client -h 172.26.10.109 -m

Farante SQL-demandon

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

Eltrovu la grandecon de tabloj en 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;

Ni eksciu, kiom da ŝtipoj uzis en Clickhouse.

La tabelo de protokoloj estas 857.19 MB.

La grandeco de la samaj datumoj en la indekso en Elasticsearch estas 4,5GB.

Se vi ne specifas datumojn en la vektoro en la parametroj, Clickhouse prenas 4500/857.19 = 5.24 fojojn malpli ol en Elasticsearch.

En vektora, la kunprema kampo estas uzata defaŭlte.

Telegram-babilado de klakdomo
Telegram-babilado de Elasta esploro
Telegram-babilado de "Kolekto kaj analizo de sistemo mesaĝoj"

fonto: www.habr.com