Senden von Nginx-JSON-Protokollen mit Vector an Clickhouse und Elasticsearch

Vector, entwickelt zum Sammeln, Umwandeln und Senden von Protokolldaten, Metriken und Ereignissen.

→ Github

Da es in der Rust-Sprache geschrieben ist, zeichnet es sich im Vergleich zu seinen Gegenstücken durch hohe Leistung und geringen RAM-Verbrauch aus. Darüber hinaus wird großen Wert auf Funktionen im Zusammenhang mit der Korrektheit gelegt, insbesondere auf die Möglichkeit, nicht gesendete Ereignisse in einem Puffer auf der Festplatte zu speichern und Dateien zu rotieren.

Architektonisch ist Vector ein Event-Router, der Nachrichten von einem oder mehreren empfängt von Quellen, optional auf diese Nachrichten anwendend Transformationen, und senden Sie sie an einen oder mehrere Abflüsse.

Vector ist ein Ersatz für Filebeat und Logstash, es kann in beiden Rollen agieren (Protokolle empfangen und senden), weitere Details dazu Webseite.

Wenn in Logstash die Kette als Eingabe → Filter → Ausgabe aufgebaut ist, dann ist dies in Vector der Fall Quellen → Transformationen → Senken

Beispiele finden Sie in der Dokumentation.

Bei dieser Anleitung handelt es sich um eine überarbeitete Anleitung von Wjatscheslaw Rachinski. Die Originalanleitung enthält GeoIP-Verarbeitung. Beim Testen von GeoIP aus einem internen Netzwerk gab Vector einen Fehler aus.

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

Wenn jemand GeoIP verarbeiten muss, lesen Sie die Originalanweisungen von Wjatscheslaw Rachinski.

Wir werden die Kombination von Nginx (Zugriffsprotokolle) → Vector (Client | Filebeat) → Vector (Server | Logstash) → separat in Clickhouse und separat in Elasticsearch konfigurieren. Wir werden 4 Server installieren. Obwohl Sie es mit 3 Servern umgehen können.

Das Schema ist ungefähr so.

Deaktivieren Sie Selinux auf allen Ihren Servern

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

Wir installieren auf allen Servern einen HTTP-Server-Emulator + Dienstprogramme

Als HTTP-Server-Emulator werden wir verwenden nodejs-stub-server aus Maxim Ignatenko

Der Nodejs-Stub-Server verfügt über kein RPM. Hier Erstellen Sie rpm dafür. rpm wird mit erstellt Fedora Copr

Fügen Sie das Repository antonpatsev/nodejs-stub-server hinzu

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

Installieren Sie nodejs-stub-server, Apache Benchmark und Screen Terminal Multiplexer auf allen Servern

yum -y install stub_http_server screen mc httpd-tools screen

Ich habe die Antwortzeit von stub_http_server in der Datei /var/lib/stub_http_server/stub_http_server.js korrigiert, sodass mehr Protokolle vorhanden waren.

var max_sleep = 10;

Starten wir stub_http_server.

systemctl start stub_http_server
systemctl enable stub_http_server

Clickhouse-Installation auf Server 3

ClickHouse verwendet den SSE 4.2-Befehlssatz. Sofern nicht anders angegeben, ist die Unterstützung dafür im verwendeten Prozessor eine zusätzliche Systemanforderung. Hier ist der Befehl, um zu überprüfen, ob der aktuelle Prozessor SSE 4.2 unterstützt:

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

Zuerst müssen Sie das offizielle 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

Um Pakete zu installieren, müssen Sie die folgenden Befehle ausführen:

sudo yum install -y clickhouse-server clickhouse-client

Erlauben Sie Clickhouse-Server, die Netzwerkkarte in der Datei /etc/clickhouse-server/config.xml abzuhören

<listen_host>0.0.0.0</listen_host>

Ändern der Protokollierungsebene von Trace auf Debug

debuggen

Standardkomprimierungseinstellungen:

min_compress_block_size  65536
max_compress_block_size  1048576

Um die Zstd-Komprimierung zu aktivieren, wurde empfohlen, nicht die Konfiguration anzufassen, sondern DDL zu verwenden.

Ich konnte in Google nicht finden, wie man die ZSTD-Komprimierung über DDL verwendet. Also habe ich es so gelassen, wie es ist.

Kollegen, die die ZSTD-Komprimierung in Clickhouse verwenden, teilen bitte die Anweisungen mit.

Um den Server als Daemon zu starten, führen Sie Folgendes aus:

service clickhouse-server start

Kommen wir nun zur Einrichtung von Clickhouse

Gehen Sie zu Clickhouse

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 – IP des Servers, auf dem Clickhouse installiert ist.

Lassen Sie uns eine Vektordatenbank erstellen

CREATE DATABASE vector;

Überprüfen wir, ob die Datenbank vorhanden ist.

show databases;

Erstellen Sie eine vector.logs-Tabelle.

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

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;

Wir prüfen, ob die Tabellen erstellt wurden. Lasst uns starten clickhouse-client und stellen Sie eine Anfrage.

Gehen wir zur Vektordatenbank.

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

Schauen wir uns die Tabellen an.

show tables;

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

Installieren Sie Elasticsearch auf dem 4. Server, um dieselben Daten zum Vergleich mit Clickhouse an Elasticsearch zu senden

Fügen Sie einen öffentlichen RPM-Schlüssel hinzu

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

Lassen Sie uns zwei Repo erstellen:

/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

Installieren Sie Elasticsearch und Kibana

yum install -y kibana elasticsearch

Da es sich um eine Kopie handelt, müssen Sie Folgendes zur Datei /etc/elasticsearch/elasticsearch.yml hinzufügen:

discovery.type: single-node

Damit dieser Vektor Daten von einem anderen Server an Elasticsearch senden kann, ändern wir network.host.

network.host: 0.0.0.0

Um eine Verbindung zu Kibana herzustellen, ändern Sie den Parameter server.host in der Datei /etc/kibana/kibana.yml

server.host: "0.0.0.0"

Alt und Elasticsearch in den Autostart einbeziehen

systemctl enable elasticsearch
systemctl start elasticsearch

und Kibana

systemctl enable kibana
systemctl start kibana

Konfigurieren von Elasticsearch für den Einzelknotenmodus 1 Shard, 0 Replikat. Höchstwahrscheinlich verfügen Sie über einen Cluster mit einer großen Anzahl von Servern und müssen dies nicht tun.

Aktualisieren Sie für zukünftige Indizes die Standardvorlage:

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

Einstellung Vector als Ersatz für Logstash auf Server 2

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

Lassen Sie uns Vector als Ersatz für Logstash einrichten. Bearbeiten der Datei /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"

Sie können den Abschnitt transforms.nginx_parse_add_defaults anpassen.

Als Wjatscheslaw Rachinski verwendet diese Konfigurationen für ein kleines CDN und es können mehrere Werte in upstream_* vorhanden sein

Zum Beispiel:

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

Wenn dies nicht der Fall ist, kann dieser Abschnitt vereinfacht werden

Lassen Sie uns Diensteinstellungen für systemd /etc/systemd/system/vector.service erstellen

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

Nachdem Sie die Tabellen erstellt haben, können Sie Vector ausführen

systemctl enable vector
systemctl start vector

Vektorprotokolle können wie folgt angezeigt werden:

journalctl -f -u vector

Solche Einträge sollten in den Protokollen vorhanden sein

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

Auf dem Client (Webserver) - 1. Server

Auf dem Server mit Nginx müssen Sie IPv6 deaktivieren, da die Protokolltabelle in Clickhouse das Feld verwendet upstream_addr IPv4, da ich im Netzwerk kein IPv6 verwende. Wenn IPv6 nicht deaktiviert ist, treten folgende Fehler auf:

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

Vielleicht, liebe Leser, fügen Sie IPv6-Unterstützung hinzu.

Erstellen Sie die Datei /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

Anwenden der Einstellungen

sysctl --system

Lass uns Nginx installieren.

Nginx-Repository-Datei /etc/yum.repos.d/nginx.repo hinzugefügt

[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

Installieren Sie das Nginx-Paket

yum install -y nginx

Zuerst müssen wir das Protokollformat in Nginx in der Datei /etc/nginx/nginx.conf konfigurieren

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;
}

Um Ihre aktuelle Konfiguration nicht zu beschädigen, ermöglicht Ihnen Nginx die Verwendung mehrerer access_log-Anweisungen

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

Vergessen Sie nicht, eine Regel zu logrotate für neue Protokolle hinzuzufügen (wenn die Protokolldatei nicht mit .log endet).

Entfernen Sie default.conf aus /etc/nginx/conf.d/

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

Fügen Sie den virtuellen Host /etc/nginx/conf.d/vhost1.conf hinzu

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

Fügen Sie den virtuellen Host /etc/nginx/conf.d/vhost2.conf hinzu

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

Fügen Sie den virtuellen Host /etc/nginx/conf.d/vhost3.conf hinzu

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

Fügen Sie den virtuellen Host /etc/nginx/conf.d/vhost4.conf hinzu

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

Fügen Sie allen Servern virtuelle Hosts (IP 172.26.10.106 des Servers, auf dem Nginx installiert ist) zur Datei /etc/hosts hinzu:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

Und wenn dann alles fertig ist

nginx -t 
systemctl restart nginx

Jetzt installieren wir es selbst Vector

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

Erstellen wir eine Einstellungsdatei 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

Und konfigurieren Sie den Filebeat-Ersatz in der Konfiguration /etc/vector/vector.toml. IP-Adresse 172.26.10.108 ist die IP-Adresse des Log-Servers (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"

Vergessen Sie nicht, den Vektorbenutzer zur erforderlichen Gruppe hinzuzufügen, damit er Protokolldateien lesen kann. Beispielsweise erstellt Nginx in Centos Protokolle mit Adm-Gruppenrechten.

usermod -a -G adm vector

Starten wir den Vektordienst

systemctl enable vector
systemctl start vector

Vektorprotokolle können wie folgt angezeigt werden:

journalctl -f -u vector

Es sollte einen solchen Eintrag in den Protokollen geben

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

Belastbarkeitstest

Die Tests werden mit dem Apache-Benchmark durchgeführt.

Das httpd-tools-Paket wurde auf allen Servern installiert

Wir beginnen mit dem Testen mithilfe des Apache-Benchmarks von 4 verschiedenen Servern im Bildschirm. Zuerst starten wir den Screen-Terminal-Multiplexer und beginnen dann mit dem Testen mithilfe des Apache-Benchmarks. Wie Sie mit dem Bildschirm arbeiten, erfahren Sie in Artikel.

Vom 1. Server

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

Vom 2. Server

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

Vom 3. Server

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

Vom 4. Server

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

Lassen Sie uns die Daten in Clickhouse überprüfen

Gehen Sie zu Clickhouse

clickhouse-client -h 172.26.10.109 -m

Erstellen einer SQL-Abfrage

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

Finden Sie die Größe der Tische in Clickhouse heraus

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;

Lassen Sie uns herausfinden, wie viele Protokolle in Clickhouse beansprucht wurden.

Die Größe der Protokolltabelle beträgt 857.19 MB.

Die Größe derselben Daten im Index in Elasticsearch beträgt 4,5 GB.

Wenn Sie in den Parametern keine Daten im Vektor angeben, benötigt Clickhouse 4500/857.19 = 5.24-mal weniger als in Elasticsearch.

Im Vektor wird standardmäßig das Komprimierungsfeld verwendet.

Telegram-Chat von Clickhouse
Telegram-Chat von Elasticsearch
Telegram-Chat von „Sammlung und Analyse des Systems Beiträge"

Source: habr.com