Sender Nginx json-logger ved hjelp av Vector til Clickhouse og Elasticsearch

vektor, designet for å samle inn, transformere og sende loggdata, beregninger og hendelser.

→ Github

Den er skrevet på Rust-språket og er preget av høy ytelse og lavt RAM-forbruk sammenlignet med analogene. I tillegg rettes mye oppmerksomhet mot funksjoner knyttet til korrekthet, spesielt muligheten til å lagre usendte hendelser til en buffer på disken og rotere filer.

Arkitektonisk er Vector en hendelsesruter som mottar meldinger fra en eller flere kilder, eventuelt bruke over disse meldingene transformasjoner, og sende dem til en eller flere avløp.

Vector er en erstatning for filebeat og logstash, den kan fungere i begge rollene (motta og sende logger), mer detaljer om dem nettsted.

Hvis i Logstash er kjeden bygget som input → filter → output, så er det i Vector kilder → transforme → synker

Eksempler finnes i dokumentasjonen.

Denne instruksen er en revidert instruks fra Vyacheslav Rakhinsky. De originale instruksjonene inneholder geoip-behandling. Ved testing av geoip fra et internt nettverk ga vektor en feil.

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

Hvis noen trenger å behandle geoip, så referer til de originale instruksjonene fra Vyacheslav Rakhinsky.

Vi vil konfigurere kombinasjonen av Nginx (tilgangslogger) → Vektor (klient | Filebeat) → Vector (Server | Logstash) → separat i Clickhouse og separat i Elasticsearch. Vi skal installere 4 servere. Selv om du kan omgå det med 3 servere.

Opplegget er noe sånt som dette.

Deaktiver Selinux på alle serverne dine

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

Vi installerer en HTTP-serveremulator + verktøy på alle servere

Som en HTTP-serveremulator vil vi bruke nodejs-stub-server fra Maxim Ignatenko

Nodejs-stub-server har ikke en rpm. Her lage rpm for det. rpm vil bli kompilert ved hjelp av Fedora Copr

Legg til antonpatsev/nodejs-stub-server-depotet

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

Installer nodejs-stub-server, Apache benchmark og skjermterminalmultiplekser på alle servere

yum -y install stub_http_server screen mc httpd-tools screen

Jeg korrigerte stub_http_server-responstiden i filen /var/lib/stub_http_server/stub_http_server.js slik at det ble flere logger.

var max_sleep = 10;

La oss starte stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Klikkhus installasjon på server 3

ClickHouse bruker SSE 4.2 instruksjonssettet, så med mindre annet er spesifisert, blir støtte for det i prosessoren som brukes et ekstra systemkrav. Her er kommandoen for å sjekke om den nåværende prosessoren støtter SSE 4.2:

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

Først må du koble til det offisielle depotet:

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

For å installere pakker må du kjøre følgende kommandoer:

sudo yum install -y clickhouse-server clickhouse-client

Tillat clickhouse-server å lytte til nettverkskortet i filen /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Endring av loggingsnivå fra sporing til feilsøking

feilsøke

Standard komprimeringsinnstillinger:

min_compress_block_size  65536
max_compress_block_size  1048576

For å aktivere Zstd-komprimering ble det anbefalt å ikke berøre konfigurasjonen, men heller bruke DDL.

Jeg kunne ikke finne hvordan jeg bruker zstd-komprimering via DDL i Google. Så jeg lot det være som det er.

Kolleger som bruker zstd-komprimering i Clickhouse, vennligst del instruksjonene.

For å starte serveren som en demon, kjør:

service clickhouse-server start

La oss nå gå videre til å sette opp Clickhouse

Gå til Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP-adressen til serveren der Clickhouse er installert.

La oss lage en vektordatabase

CREATE DATABASE vector;

La oss sjekke at databasen eksisterer.

show databases;

Lag en vector.logs-tabell.

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

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;

Vi sjekker at tabellene er opprettet. La oss lansere clickhouse-client og kom med en forespørsel.

La oss gå til vektordatabasen.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

La oss se på tabellene.

show tables;

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

Installerer elasticsearch på den fjerde serveren for å sende de samme dataene til Elasticsearch for sammenligning med Clickhouse

Legg til en offentlig rpm-nøkkel

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

La oss lage 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

Installer elasticsearch og kibana

yum install -y kibana elasticsearch

Siden den vil være i 1 kopi, må du legge til følgende i filen /etc/elasticsearch/elasticsearch.yml:

discovery.type: single-node

Så den vektoren kan sende data til elasticsearch fra en annen server, la oss endre network.host.

network.host: 0.0.0.0

For å koble til kibana, endre server.host-parameteren i filen /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Gammel og inkluderer elasticsearch i autostart

systemctl enable elasticsearch
systemctl start elasticsearch

og kibana

systemctl enable kibana
systemctl start kibana

Konfigurere Elasticsearch for enkeltnodemodus 1 shard, 0 replika. Mest sannsynlig vil du ha en klynge med et stort antall servere, og du trenger ikke å gjøre dette.

For fremtidige indekser, oppdater standardmalen:

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

Installasjon vektor som erstatning for Logstash på server 2

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

La oss sette opp Vector som en erstatning for Logstash. Redigering av filen /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"

Du kan justere delen transforms.nginx_parse_add_defaults.

siden Vyacheslav Rakhinsky bruker disse konfigurasjonene for en liten CDN og det kan være flere verdier i upstream_*

For eksempel:

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

Hvis dette ikke er din situasjon, kan denne delen forenkles

La oss lage tjenesteinnstillinger for 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

Etter å ha laget tabellene, kan du kjøre Vector

systemctl enable vector
systemctl start vector

Vektorlogger kan sees slik:

journalctl -f -u vector

Det bør være oppføringer som dette i loggene

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

På klienten (webserver) - 1. server

På serveren med nginx må du deaktivere ipv6, siden loggtabellen i clickhouse bruker feltet upstream_addr IPv4, siden jeg ikke bruker ipv6 inne i nettverket. Hvis ipv6 ikke er slått av, vil det oppstå feil:

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

Kanskje lesere, legg til ipv6-støtte.

Opprett filen /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

Bruker innstillingene

sysctl --system

La oss installere nginx.

Lagt til nginx-depotfil /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

Installer nginx-pakken

yum install -y nginx

Først må vi konfigurere loggformatet i Nginx i filen /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;
}

For ikke å bryte din nåværende konfigurasjon, lar Nginx deg ha flere access_log-direktiver

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

Ikke glem å legge til en regel for å logrotere for nye logger (hvis loggfilen ikke slutter med .log)

Fjern default.conf fra /etc/nginx/conf.d/

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

Legg til virtuell vert /etc/nginx/conf.d/vhost1.conf

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

Legg til virtuell vert /etc/nginx/conf.d/vhost2.conf

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

Legg til virtuell vert /etc/nginx/conf.d/vhost3.conf

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

Legg til virtuell vert /etc/nginx/conf.d/vhost4.conf

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

Legg til virtuelle verter (172.26.10.106 ip av serveren der nginx er installert) til alle servere til filen /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Og hvis alt er klart da

nginx -t 
systemctl restart nginx

La oss nå installere det selv vektor

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

La oss lage en innstillingsfil for 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

Og konfigurer Filebeat-erstatningen i /etc/vector/vector.toml-konfigurasjonen. IP-adressen 172.26.10.108 er IP-adressen til loggserveren (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"

Ikke glem å legge vektorbrukeren til den nødvendige gruppen slik at han kan lese loggfiler. For eksempel oppretter nginx i centos logger med adm-grupperettigheter.

usermod -a -G adm vector

La oss starte vektortjenesten

systemctl enable vector
systemctl start vector

Vektorlogger kan sees slik:

journalctl -f -u vector

Det bør være en oppføring som dette i loggene

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

Stresstesting

Vi utfører testing med Apache benchmark.

httpd-tools-pakken ble installert på alle servere

Vi begynner å teste med Apache-benchmark fra 4 forskjellige servere på skjermen. Først starter vi skjermterminalmultiplekseren, og deretter begynner vi å teste ved å bruke Apache-benchmark. Hvordan jobbe med skjerm finner du i artikkel.

Fra 1. server

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

Fra 2. server

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

Fra 3. server

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

Fra 4. server

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

La oss sjekke dataene i Clickhouse

Gå til Clickhouse

clickhouse-client -h 172.26.10.109 -m

Lage en SQL-spørring

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

Finn ut størrelsen på bordene i 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;

La oss finne ut hvor mye logger tok opp i Clickhouse.

Størrelsen på loggtabellen er 857.19 MB.

Størrelsen på de samme dataene i indeksen i Elasticsearch er 4,5 GB.

Hvis du ikke spesifiserer data i vektoren i parameterne, tar Clickhouse 4500/857.19 = 5.24 ganger mindre enn i Elasticsearch.

I vektor brukes komprimeringsfeltet som standard.

Telegram chat av klikkhus
Telegram chat av Elasticsearch
Telegram chat av "Innsamling og analyse av system meldinger"

Kilde: www.habr.com