Skickar Nginx json-loggar med Vector till Clickhouse och Elasticsearch

vektor, designad för att samla in, transformera och skicka loggdata, mätvärden och händelser.

→ Github

Den är skriven på språket Rust och kännetecknas av hög prestanda och låg RAM-förbrukning jämfört med dess analoger. Dessutom ägnas mycket uppmärksamhet åt funktioner relaterade till korrekthet, i synnerhet möjligheten att spara osända händelser till en buffert på disken och rotera filer.

Arkitektoniskt är Vector en händelserouter som tar emot meddelanden från en eller flera källor, valfritt att tillämpa över dessa meddelanden transformationeroch skicka dem till en eller flera avlopp.

Vector är en ersättning för filebeat och logstash, den kan agera i båda rollerna (ta emot och skicka loggar), mer information om dem Online.

Om kedjan i Logstash är byggd som input → filter → output så är den det i Vector källor → transformer → sänkor

Exempel finns i dokumentationen.

Denna instruktion är en reviderad instruktion från Vyacheslav Rakhinsky. De ursprungliga instruktionerna innehåller geoip-bearbetning. När man testade geoip från ett internt nätverk gav vektor ett fel.

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

Om någon behöver bearbeta geoip, se originalinstruktionerna från Vyacheslav Rakhinsky.

Vi kommer att konfigurera kombinationen av Nginx (Access logs) → Vector (Client | Filebeat) → Vector (Server | Logstash) → separat i Clickhouse och separat i Elasticsearch. Vi kommer att installera 4 servrar. Även om du kan kringgå det med 3 servrar.

Upplägget är ungefär så här.

Inaktivera Selinux på alla dina servrar

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

Vi installerar en HTTP-serveremulator + verktyg på alla servrar

Som en HTTP-serveremulator kommer vi att använda nodejs-stub-server från Maxim Ignatenko

Nodejs-stub-server har ingen rpm. Här skapa rpm för det. rpm kommer att kompileras med hjälp av Fedora Copr

Lägg till antonpatsev/nodejs-stub-server-förrådet

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

Installera nodejs-stub-server, Apache benchmark och skärmterminalmultiplexer på alla servrar

yum -y install stub_http_server screen mc httpd-tools screen

Jag korrigerade stub_http_server-svarstiden i filen /var/lib/stub_http_server/stub_http_server.js så att det blev fler loggar.

var max_sleep = 10;

Låt oss starta stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Clickhouse installation på server 3

ClickHouse använder SSE 4.2-instruktionsuppsättningen, så om inget annat anges blir stöd för det i den processor som används ett ytterligare systemkrav. Här är kommandot för att kontrollera om den aktuella processorn stöder SSE 4.2:

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

Först måste du ansluta det officiella förvaret:

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

För att installera paket måste du köra följande kommandon:

sudo yum install -y clickhouse-server clickhouse-client

Tillåt clickhouse-server att lyssna på nätverkskortet i filen /etc/clickhouse-server/config.xml

<listen_host>0.0.0.0</listen_host>

Ändra loggningsnivån från spårning till felsökning

felsöka

Standard komprimeringsinställningar:

min_compress_block_size  65536
max_compress_block_size  1048576

För att aktivera Zstd-komprimering rekommenderades det att inte röra konfigurationen, utan att använda DDL.

Jag kunde inte hitta hur man använder zstd-komprimering via DDL i Google. Så jag lämnade det som det är.

Kollegor som använder zstd-komprimering i Clickhouse, vänligen dela instruktionerna.

För att starta servern som en demon, kör:

service clickhouse-server start

Låt oss nu gå vidare till att ställa in Clickhouse

Gå till Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — IP för servern där Clickhouse är installerat.

Låt oss skapa en vektordatabas

CREATE DATABASE vector;

Låt oss kontrollera att databasen finns.

show databases;

Skapa 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 kontrollerar att tabellerna har skapats. Låt oss starta clickhouse-client och gör en begäran.

Låt oss gå till vektordatabasen.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Låt oss titta på tabellerna.

show tables;

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

Installerar elasticsearch på den fjärde servern för att skicka samma data till Elasticsearch för jämförelse med Clickhouse

Lägg till en offentlig rpm-nyckel

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

Låt oss skapa 2 repor:

/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

Installera elasticsearch och kibana

yum install -y kibana elasticsearch

Eftersom det kommer att finnas i en kopia, måste du lägga till följande i filen /etc/elasticsearch/elasticsearch.yml:

discovery.type: single-node

Så att vektorn kan skicka data till elasticsearch från en annan server, låt oss byta network.host.

network.host: 0.0.0.0

För att ansluta till kibana, ändra parametern server.host i filen /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Gammal och inkluderar elasticsearch i autostart

systemctl enable elasticsearch
systemctl start elasticsearch

och kibana

systemctl enable kibana
systemctl start kibana

Konfigurera Elasticsearch för läge med en nod 1 shard, 0 replika. Troligtvis kommer du att ha ett kluster med ett stort antal servrar och du behöver inte göra detta.

För framtida index, uppdatera standardmallen:

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

Installation vektor som ersättning för Logstash på server 2

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

Låt oss ställa in Vector som en ersättning för Logstash. Redigera 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 justera avsnittet transforms.nginx_parse_add_defaults.

Som Vyacheslav Rakhinsky använder dessa konfigurationer för ett litet CDN och det kan finnas flera värden i upstream_*

Till exempel:

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

Om detta inte är din situation kan det här avsnittet förenklas

Låt oss skapa serviceinställningar för systemd /etc/systemd/system/vector.service

# /etc/systemd/system/vector.service

[Unit]
Description=Vector
After=network-online.target
Requires=network-online.target

[Service]
User=vector
Group=vector
ExecStart=/usr/bin/vector
ExecReload=/bin/kill -HUP $MAINPID
Restart=no
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=vector

[Install]
WantedBy=multi-user.target

Efter att ha skapat tabellerna kan du köra Vector

systemctl enable vector
systemctl start vector

Vektorloggar kan ses så här:

journalctl -f -u vector

Det borde finnas sådana här poster i loggarna

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

På klienten (webbserver) - 1:a server

På servern med nginx måste du inaktivera ipv6, eftersom loggtabellen i clickhouse använder fältet upstream_addr IPv4, eftersom jag inte använder ipv6 i nätverket. Om ipv6 inte är avstängd kommer det att uppstå fel:

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

Kanske läsare, lägg till ipv6-stöd.

Skapa 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

Använder inställningarna

sysctl --system

Låt oss installera nginx.

Lade till nginx-förvarsfil /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

Installera nginx-paketet

yum install -y nginx

Först måste vi konfigurera 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;
}

För att inte bryta din nuvarande konfiguration låter Nginx dig ha flera access_log-direktiv

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

Glöm inte att lägga till en regel för att logrotera för nya loggar (om loggfilen inte slutar med .log)

Ta bort default.conf från /etc/nginx/conf.d/

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

Lägg till virtuell värd /etc/nginx/conf.d/vhost1.conf

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

Lägg till virtuell värd /etc/nginx/conf.d/vhost2.conf

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

Lägg till virtuell värd /etc/nginx/conf.d/vhost3.conf

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

Lägg till virtuell värd /etc/nginx/conf.d/vhost4.conf

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

Lägg till virtuella värdar (172.26.10.106 ip för servern där nginx är installerat) till alla servrar till filen /etc/hosts:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Och om allt är klart då

nginx -t 
systemctl restart nginx

Låt oss nu installera det själva vektor

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

Låt oss skapa en inställningsfil för 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

Och konfigurera Filebeat-ersättningen i /etc/vector/vector.toml config. IP-adress 172.26.10.108 är IP-adressen för loggservern (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"

Glöm inte att lägga till användarvektorn i lämplig grupp så att den kan läsa loggfiler. Till exempel nginx i centos skapar loggar med administratörsgruppsrättigheter.

usermod -a -G adm vector

Låt oss starta vektortjänsten

systemctl enable vector
systemctl start vector

Vektorloggar kan ses så här:

journalctl -f -u vector

Det borde finnas en sådan post i loggarna

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

Stresstestning

Vi utför tester med Apache benchmark.

Paketet httpd-tools installerades på alla servrar

Vi börjar testa med Apache benchmark från 4 olika servrar på skärmen. Först startar vi skärmterminalmultiplexern och sedan börjar vi testa med Apache-riktmärket. Hur man arbetar med skärm hittar du i artikeln.

Från 1:a servern

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

Från 2:a servern

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

Från 3:a servern

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

Från 4:a servern

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

Låt oss kontrollera data i Clickhouse

Gå till Clickhouse

clickhouse-client -h 172.26.10.109 -m

Göra en SQL-fråga

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

Ta reda på storleken på borden 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;

Låt oss ta reda på hur mycket stockar tog upp i Clickhouse.

Loggtabellens storlek är 857.19 MB.

Storleken på samma data i indexet i Elasticsearch är 4,5 GB.

Om du inte anger data i vektorn i parametrarna tar Clickhouse 4500/857.19 = 5.24 gånger mindre än i Elasticsearch.

I vektor används komprimeringsfältet som standard.

Telegramchatt av Klickhus
Telegramchatt av Elasticsearch
Telegramchatt av "Insamling och analys av system meddelanden"

Källa: will.com