ਵੈਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Nginx json ਲੌਗਸ ਨੂੰ Clickhouse ਅਤੇ Elasticsearch ਨੂੰ ਭੇਜਣਾ

ਵੈਕਟਰ, ਲੌਗ ਡੇਟਾ, ਮੈਟ੍ਰਿਕਸ ਅਤੇ ਇਵੈਂਟਾਂ ਨੂੰ ਇਕੱਤਰ ਕਰਨ, ਬਦਲਣ ਅਤੇ ਭੇਜਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ।

→ GitHub

ਜੰਗਾਲ ਭਾਸ਼ਾ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਇਹ ਇਸਦੇ ਐਨਾਲਾਗਸ ਦੇ ਮੁਕਾਬਲੇ ਉੱਚ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਘੱਟ RAM ਦੀ ਖਪਤ ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸ਼ੁੱਧਤਾ ਨਾਲ ਸਬੰਧਤ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਬਹੁਤ ਧਿਆਨ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ, ਡਿਸਕ ਦੇ ਬਫਰ ਅਤੇ ਫਾਈਲਾਂ ਨੂੰ ਘੁੰਮਾਉਣ ਲਈ ਨਾ ਭੇਜੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਦੀ ਯੋਗਤਾ.

ਆਰਕੀਟੈਕਚਰਲ ਤੌਰ 'ਤੇ, ਵੈਕਟਰ ਇੱਕ ਇਵੈਂਟ ਰਾਊਟਰ ਹੈ ਜੋ ਇੱਕ ਜਾਂ ਵੱਧ ਤੋਂ ਸੁਨੇਹੇ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਸਰੋਤ, ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਇਹਨਾਂ ਸੁਨੇਹਿਆਂ 'ਤੇ ਲਾਗੂ ਕਰਨਾ ਤਬਦੀਲੀਆਂ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਨੂੰ ਭੇਜਣਾ ਨਾਲੀਆਂ.

ਵੈਕਟਰ ਫਾਈਲਬੀਟ ਅਤੇ ਲੌਗਸਟੈਸ਼ ਦਾ ਬਦਲ ਹੈ, ਇਹ ਦੋਵੇਂ ਭੂਮਿਕਾਵਾਂ (ਲਾਗ ਪ੍ਰਾਪਤ ਕਰਨਾ ਅਤੇ ਭੇਜਣਾ) ਵਿੱਚ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ, ਉਹਨਾਂ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਸਾਈਟ.

ਜੇਕਰ ਲੌਗਸਟੈਸ਼ ਵਿੱਚ ਚੇਨ ਨੂੰ ਇਨਪੁਟ → ਫਿਲਟਰ → ਆਉਟਪੁੱਟ ਦੇ ਤੌਰ ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ ਤਾਂ ਵੈਕਟਰ ਵਿੱਚ ਇਹ ਹੈ ਸਰੋਤ → ਬਦਲਦਾ ਹੈ → ਡੁੱਬਦਾ ਹੈ

ਉਦਾਹਰਨਾਂ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਮਿਲ ਸਕਦੀਆਂ ਹਨ।

ਇਹ ਹਦਾਇਤ ਤੋਂ ਇੱਕ ਸੋਧਿਆ ਹੋਇਆ ਨਿਰਦੇਸ਼ ਹੈ ਵਿਆਚੇਸਲਾਵ ਰਾਖਿਨਸਕੀ. ਮੂਲ ਨਿਰਦੇਸ਼ਾਂ ਵਿੱਚ geoip ਪ੍ਰੋਸੈਸਿੰਗ ਸ਼ਾਮਲ ਹੈ। ਇੱਕ ਅੰਦਰੂਨੀ ਨੈੱਟਵਰਕ ਤੋਂ geoip ਦੀ ਜਾਂਚ ਕਰਦੇ ਸਮੇਂ, ਵੈਕਟਰ ਨੇ ਇੱਕ ਗਲਤੀ ਦਿੱਤੀ।

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

ਜੇ ਕਿਸੇ ਨੂੰ ਜੀਓਆਈਪੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਮੂਲ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਵੇਖੋ ਵਿਆਚੇਸਲਾਵ ਰਾਖਿਨਸਕੀ.

ਅਸੀਂ Nginx (ਐਕਸੈਸ ਲੌਗ) → ਵੈਕਟਰ (ਕਲਾਇੰਟ | ਫਾਈਲਬੀਟ) → ਵੈਕਟਰ (ਸਰਵਰ | ਲੌਗਸਟੈਸ਼) → ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਕਲਿਕਹਾਊਸ ਵਿੱਚ ਅਤੇ ਵੱਖਰੇ ਤੌਰ 'ਤੇ Elasticsearch ਵਿੱਚ ਸੰਰਚਿਤ ਕਰਾਂਗੇ। ਅਸੀਂ 4 ਸਰਵਰ ਸਥਾਪਿਤ ਕਰਾਂਗੇ। ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਇਸ ਨੂੰ 3 ਸਰਵਰਾਂ ਨਾਲ ਬਾਈਪਾਸ ਕਰ ਸਕਦੇ ਹੋ।

ਸਕੀਮ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।

ਆਪਣੇ ਸਾਰੇ ਸਰਵਰਾਂ 'ਤੇ ਸੇਲਿਨਕਸ ਨੂੰ ਅਸਮਰੱਥ ਬਣਾਓ

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

ਅਸੀਂ ਸਾਰੇ ਸਰਵਰਾਂ 'ਤੇ ਇੱਕ HTTP ਸਰਵਰ ਇਮੂਲੇਟਰ + ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੇ ਹਾਂ

ਇੱਕ HTTP ਸਰਵਰ ਈਮੂਲੇਟਰ ਵਜੋਂ ਅਸੀਂ ਵਰਤਾਂਗੇ nodejs-ਸਟੱਬ-ਸਰਵਰ ਤੱਕ ਮੈਕਸਿਮ ਇਗਨਾਟੇਨਕੋ

Nodejs-stub-server ਕੋਲ rpm ਨਹੀਂ ਹੈ। ਇਹ ਇਸ ਲਈ ਹੈ ਇਸਦੇ ਲਈ rpm ਬਣਾਓ। rpm ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾਵੇਗਾ ਫੇਡੋਰਾ ਕਾਪਰ

antonpatsev/nodejs-stub-server ਰਿਪੋਜ਼ਟਰੀ ਸ਼ਾਮਲ ਕਰੋ

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

ਸਾਰੇ ਸਰਵਰਾਂ 'ਤੇ nodejs-stub-server, Apache ਬੈਂਚਮਾਰਕ ਅਤੇ ਸਕ੍ਰੀਨ ਟਰਮੀਨਲ ਮਲਟੀਪਲੈਕਸਰ ਸਥਾਪਿਤ ਕਰੋ

yum -y install stub_http_server screen mc httpd-tools screen

ਮੈਂ /var/lib/stub_http_server/stub_http_server.js ਫਾਈਲ ਵਿੱਚ stub_http_server ਜਵਾਬ ਸਮਾਂ ਠੀਕ ਕੀਤਾ ਹੈ ਤਾਂ ਜੋ ਹੋਰ ਲੌਗਸ ਹੋਣ।

var max_sleep = 10;

ਚਲੋ stub_http_server ਲਾਂਚ ਕਰੀਏ।

systemctl start stub_http_server
systemctl enable stub_http_server

ਕਲਿਕਹਾਊਸ ਇੰਸਟਾਲੇਸ਼ਨ ਸਰਵਰ 3 'ਤੇ

ਕਲਿਕਹਾਊਸ SSE 4.2 ਨਿਰਦੇਸ਼ ਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਜਦੋਂ ਤੱਕ ਹੋਰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ, ਵਰਤੇ ਗਏ ਪ੍ਰੋਸੈਸਰ ਵਿੱਚ ਇਸਦਾ ਸਮਰਥਨ ਇੱਕ ਵਾਧੂ ਸਿਸਟਮ ਲੋੜ ਬਣ ਜਾਂਦਾ ਹੈ। ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਕਮਾਂਡ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਪ੍ਰੋਸੈਸਰ SSE 4.2 ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ:

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

ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਅਧਿਕਾਰਤ ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਜੁੜਨ ਦੀ ਲੋੜ ਹੈ:

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

ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡਾਂ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ:

sudo yum install -y clickhouse-server clickhouse-client

ਕਲਿੱਕਹਾਊਸ-ਸਰਵਰ ਨੂੰ ਫਾਇਲ /etc/clickhouse-server/config.xml ਵਿੱਚ ਨੈੱਟਵਰਕ ਕਾਰਡ ਸੁਣਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿਓ

<listen_host>0.0.0.0</listen_host>

ਲੌਗਿੰਗ ਪੱਧਰ ਨੂੰ ਟਰੇਸ ਤੋਂ ਡੀਬੱਗ ਤੱਕ ਬਦਲਣਾ

ਡੀਬੱਗ

ਸਟੈਂਡਰਡ ਕੰਪਰੈਸ਼ਨ ਸੈਟਿੰਗਜ਼:

min_compress_block_size  65536
max_compress_block_size  1048576

Zstd ਕੰਪਰੈਸ਼ਨ ਨੂੰ ਸਰਗਰਮ ਕਰਨ ਲਈ, ਇਸ ਨੂੰ ਸੰਰਚਨਾ ਨੂੰ ਨਾ ਛੂਹਣ ਦੀ ਸਲਾਹ ਦਿੱਤੀ ਗਈ ਸੀ, ਸਗੋਂ DDL ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ ਗਈ ਸੀ।

ਮੈਨੂੰ Google ਵਿੱਚ DDL ਰਾਹੀਂ zstd ਕੰਪਰੈਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ ਇਹ ਨਹੀਂ ਲੱਭ ਸਕਿਆ। ਇਸ ਲਈ ਮੈਂ ਇਸਨੂੰ ਜਿਵੇਂ ਹੈ ਛੱਡ ਦਿੱਤਾ.

ਸਹਿਕਰਮੀ ਜੋ ਕਲਿਕਹਾਊਸ ਵਿੱਚ zstd ਕੰਪਰੈਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਕਿਰਪਾ ਕਰਕੇ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰੋ।

ਸਰਵਰ ਨੂੰ ਡੈਮਨ ਵਜੋਂ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਚਲਾਓ:

service clickhouse-server start

ਹੁਣ ਆਓ ਕਲਿਕਹਾਊਸ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਲਈ ਅੱਗੇ ਵਧੀਏ

ਕਲਿਕਹਾਊਸ 'ਤੇ ਜਾਓ

clickhouse-client -h 172.26.10.109 -m

172.26.10.109 — ਸਰਵਰ ਦਾ IP ਜਿੱਥੇ ਕਲਿਕਹਾਊਸ ਇੰਸਟਾਲ ਹੈ।

ਚਲੋ ਇੱਕ ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਬਣਾਈਏ

CREATE DATABASE vector;

ਚਲੋ ਜਾਂਚ ਕਰੀਏ ਕਿ ਡੇਟਾਬੇਸ ਮੌਜੂਦ ਹੈ।

show databases;

ਇੱਕ 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;

ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਟੇਬਲ ਬਣਾਏ ਗਏ ਹਨ। ਚਲੋ ਲਾਂਚ ਕਰੀਏ clickhouse-client ਅਤੇ ਇੱਕ ਬੇਨਤੀ ਕਰੋ।

ਚਲੋ ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਤੇ ਚੱਲੀਏ।

use vector;

Ok.

0 rows in set. Elapsed: 0.001 sec.

ਆਉ ਟੇਬਲਾਂ ਨੂੰ ਵੇਖੀਏ.

show tables;

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

ਕਲਿਕਹਾਊਸ ਨਾਲ ਤੁਲਨਾ ਕਰਨ ਲਈ ਉਹੀ ਡੇਟਾ Elasticsearch ਨੂੰ ਭੇਜਣ ਲਈ ਚੌਥੇ ਸਰਵਰ 'ਤੇ elasticsearch ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ

ਇੱਕ ਜਨਤਕ rpm ਕੁੰਜੀ ਜੋੜੋ

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

ਆਓ 2 ਰੈਪੋ ਬਣਾਈਏ:

/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

elasticsearch ਅਤੇ kibana ਇੰਸਟਾਲ ਕਰੋ

yum install -y kibana elasticsearch

ਕਿਉਂਕਿ ਇਹ 1 ਕਾਪੀ ਵਿੱਚ ਹੋਵੇਗਾ, ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੇ ਨੂੰ /etc/elasticsearch/elasticsearch.yml ਫਾਈਲ ਵਿੱਚ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ:

discovery.type: single-node

ਤਾਂ ਜੋ ਵੈਕਟਰ ਕਿਸੇ ਹੋਰ ਸਰਵਰ ਤੋਂ elasticsearch ਨੂੰ ਡੇਟਾ ਭੇਜ ਸਕੇ, ਆਓ network.host ਨੂੰ ਬਦਲੀਏ।

network.host: 0.0.0.0

ਕਿਬਾਨਾ ਨਾਲ ਜੁੜਨ ਲਈ, ਫਾਈਲ ਵਿੱਚ ਸਰਵਰ.ਹੋਸਟ ਪੈਰਾਮੀਟਰ ਬਦਲੋ /etc/kibana/kibana.yml

server.host: "0.0.0.0"

ਪੁਰਾਣੀ ਅਤੇ ਆਟੋਸਟਾਰਟ ਵਿੱਚ elasticsearch ਸ਼ਾਮਲ ਕਰੋ

systemctl enable elasticsearch
systemctl start elasticsearch

ਅਤੇ ਕਿਬਾਨਾ

systemctl enable kibana
systemctl start kibana

ਸਿੰਗਲ-ਨੋਡ ਮੋਡ 1 ਸ਼ਾਰਡ, 0 ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਲਈ Elasticsearch ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ। ਜ਼ਿਆਦਾਤਰ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਸਰਵਰਾਂ ਦਾ ਇੱਕ ਕਲੱਸਟਰ ਹੋਵੇਗਾ ਅਤੇ ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਭਵਿੱਖੀ ਸੂਚਕਾਂਕ ਲਈ, ਡਿਫੌਲਟ ਟੈਮਪਲੇਟ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ:

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

ਸੈਟਿੰਗ ਵੈਕਟਰ ਸਰਵਰ 2 'ਤੇ Logstash ਦੇ ਬਦਲ ਵਜੋਂ

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

ਚਲੋ ਲੌਗਸਟੈਸ਼ ਦੇ ਬਦਲ ਵਜੋਂ ਵੈਕਟਰ ਨੂੰ ਸੈਟ ਅਪ ਕਰੀਏ। ਫਾਇਲ ਨੂੰ ਸੋਧਣਾ /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"

ਤੁਸੀਂ transforms.nginx_parse_add_defaults ਭਾਗ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰ ਸਕਦੇ ਹੋ।

ਲੈ ਵਿਆਚੇਸਲਾਵ ਰਾਖਿਨਸਕੀ ਇੱਕ ਛੋਟੇ CDN ਲਈ ਇਹਨਾਂ ਸੰਰਚਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ upstream_* ਵਿੱਚ ਕਈ ਮੁੱਲ ਹੋ ਸਕਦੇ ਹਨ

ਉਦਾਹਰਨ ਲਈ:

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

ਜੇ ਇਹ ਤੁਹਾਡੀ ਸਥਿਤੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸ ਭਾਗ ਨੂੰ ਸਰਲ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ

ਚਲੋ 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

ਟੇਬਲ ਬਣਾਉਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਵੈਕਟਰ ਚਲਾ ਸਕਦੇ ਹੋ

systemctl enable vector
systemctl start vector

ਵੈਕਟਰ ਲੌਗਸ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:

journalctl -f -u vector

ਲਾਗਾਂ ਵਿੱਚ ਇਸ ਤਰ੍ਹਾਂ ਦੀਆਂ ਐਂਟਰੀਆਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ

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

ਕਲਾਇੰਟ (ਵੈੱਬ ਸਰਵਰ) 'ਤੇ - ਪਹਿਲਾ ਸਰਵਰ

nginx ਵਾਲੇ ਸਰਵਰ 'ਤੇ, ਤੁਹਾਨੂੰ ipv6 ਨੂੰ ਅਯੋਗ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਕਿਉਂਕਿ ਕਲਿੱਕਹਾਊਸ ਵਿੱਚ ਲੌਗਸ ਟੇਬਲ ਖੇਤਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ upstream_addr IPv4, ਕਿਉਂਕਿ ਮੈਂ ਨੈੱਟਵਰਕ ਦੇ ਅੰਦਰ ipv6 ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦਾ। ਜੇਕਰ ipv6 ਬੰਦ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਗਲਤੀਆਂ ਹੋਣਗੀਆਂ:

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

ਸ਼ਾਇਦ ਪਾਠਕ, ipv6 ਸਹਿਯੋਗ ਜੋੜੋ।

ਫਾਇਲ ਬਣਾਓ /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

ਸੈਟਿੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

sysctl --system

ਚਲੋ nginx ਇੰਸਟਾਲ ਕਰੀਏ।

nginx ਰਿਪੋਜ਼ਟਰੀ ਫਾਈਲ /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

nginx ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰੋ

yum install -y nginx

ਪਹਿਲਾਂ, ਸਾਨੂੰ Nginx ਵਿੱਚ ਲਾਗ ਫਾਰਮੈਟ ਨੂੰ /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;
}

ਤੁਹਾਡੀ ਮੌਜੂਦਾ ਸੰਰਚਨਾ ਨੂੰ ਨਾ ਤੋੜਨ ਲਈ, Nginx ਤੁਹਾਨੂੰ ਕਈ ਐਕਸੈਸ_ਲੌਗ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ

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

ਨਵੇਂ ਲੌਗਸ ਲਈ ਲੌਗਰੋਟੇਟ ਕਰਨ ਲਈ ਇੱਕ ਨਿਯਮ ਜੋੜਨਾ ਨਾ ਭੁੱਲੋ (ਜੇਕਰ ਲੌਗ ਫਾਈਲ .log ਨਾਲ ਖਤਮ ਨਹੀਂ ਹੁੰਦੀ ਹੈ)

/etc/nginx/conf.d/ ਤੋਂ default.conf ਹਟਾਓ

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

ਵਰਚੁਅਲ ਹੋਸਟ /etc/nginx/conf.d/vhost1.conf ਸ਼ਾਮਲ ਕਰੋ

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

ਵਰਚੁਅਲ ਹੋਸਟ /etc/nginx/conf.d/vhost2.conf ਸ਼ਾਮਲ ਕਰੋ

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

ਵਰਚੁਅਲ ਹੋਸਟ /etc/nginx/conf.d/vhost3.conf ਸ਼ਾਮਲ ਕਰੋ

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

ਵਰਚੁਅਲ ਹੋਸਟ /etc/nginx/conf.d/vhost4.conf ਸ਼ਾਮਲ ਕਰੋ

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

/etc/hosts ਫਾਈਲ ਵਿੱਚ ਸਾਰੇ ਸਰਵਰਾਂ ਵਿੱਚ ਵਰਚੁਅਲ ਹੋਸਟ (ਸਰਵਰ ਦਾ 172.26.10.106 ip ਜਿੱਥੇ nginx ਇੰਸਟਾਲ ਹੈ) ਸ਼ਾਮਲ ਕਰੋ:

172.26.10.106 vhost1
172.26.10.106 vhost2
172.26.10.106 vhost3
172.26.10.106 vhost4

ਅਤੇ ਜੇ ਸਭ ਕੁਝ ਤਿਆਰ ਹੈ

nginx -t 
systemctl restart nginx

ਹੁਣ ਇਸ ਨੂੰ ਆਪਣੇ ਆਪ ਇੰਸਟਾਲ ਕਰੀਏ ਵੈਕਟਰ

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

ਚਲੋ 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

ਅਤੇ /etc/vector/vector.toml ਸੰਰਚਨਾ ਵਿੱਚ ਫਾਈਲਬੀਟ ਬਦਲਣ ਦੀ ਸੰਰਚਨਾ ਕਰੋ। IP ਐਡਰੈੱਸ 172.26.10.108 ਲਾਗ ਸਰਵਰ (ਵੈਕਟਰ-ਸਰਵਰ) ਦਾ IP ਪਤਾ ਹੈ।

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"

ਯੂਜ਼ਰ ਵੈਕਟਰ ਨੂੰ ਢੁਕਵੇਂ ਸਮੂਹ ਵਿੱਚ ਜੋੜਨਾ ਨਾ ਭੁੱਲੋ ਤਾਂ ਜੋ ਇਹ ਲੌਗ ਫਾਈਲਾਂ ਪੜ੍ਹ ਸਕੇ। ਉਦਾਹਰਣ ਵਜੋਂ, nginx in centos ਐਡਮ ਗਰੁੱਪ ਅਧਿਕਾਰਾਂ ਨਾਲ ਲੌਗ ਬਣਾਉਂਦਾ ਹੈ।

usermod -a -G adm vector

ਆਉ ਵੈਕਟਰ ਸੇਵਾ ਸ਼ੁਰੂ ਕਰੀਏ

systemctl enable vector
systemctl start vector

ਵੈਕਟਰ ਲੌਗਸ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:

journalctl -f -u vector

ਲੌਗਸ ਵਿੱਚ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ

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

ਤਣਾਅ ਟੈਸਟਿੰਗ

ਅਸੀਂ ਅਪਾਚੇ ਬੈਂਚਮਾਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟਿੰਗ ਕਰਦੇ ਹਾਂ।

httpd-ਟੂਲ ਪੈਕੇਜ ਸਭ ਸਰਵਰਾਂ ਉੱਤੇ ਇੰਸਟਾਲ ਕੀਤਾ ਗਿਆ ਸੀ

ਅਸੀਂ ਸਕ੍ਰੀਨ ਵਿੱਚ 4 ਵੱਖ-ਵੱਖ ਸਰਵਰਾਂ ਤੋਂ ਅਪਾਚੇ ਬੈਂਚਮਾਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ। ਪਹਿਲਾਂ, ਅਸੀਂ ਸਕ੍ਰੀਨ ਟਰਮੀਨਲ ਮਲਟੀਪਲੈਕਸਰ ਨੂੰ ਲਾਂਚ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਅਸੀਂ ਅਪਾਚੇ ਬੈਂਚਮਾਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ। ਸਕ੍ਰੀਨ ਦੇ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਲੱਭ ਸਕਦੇ ਹੋ ਲੇਖ.

1 ਸਰਵਰ ਤੋਂ

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

2 ਸਰਵਰ ਤੋਂ

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

3 ਸਰਵਰ ਤੋਂ

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

4 ਸਰਵਰ ਤੋਂ

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

ਆਉ ਕਲਿਕਹਾਊਸ ਵਿੱਚ ਡੇਟਾ ਦੀ ਜਾਂਚ ਕਰੀਏ

ਕਲਿਕਹਾਊਸ 'ਤੇ ਜਾਓ

clickhouse-client -h 172.26.10.109 -m

ਇੱਕ SQL ਪੁੱਛਗਿੱਛ ਬਣਾਉਣਾ

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

ਕਲਿਕਹਾਊਸ ਵਿੱਚ ਟੇਬਲ ਦੇ ਆਕਾਰ ਦਾ ਪਤਾ ਲਗਾਓ

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;

ਆਓ ਇਹ ਪਤਾ ਕਰੀਏ ਕਿ ਕਲਿਕਹਾਊਸ ਵਿੱਚ ਕਿੰਨੇ ਲੌਗਸ ਲਏ ਗਏ ਹਨ।

ਲਾਗ ਟੇਬਲ ਦਾ ਆਕਾਰ 857.19 MB ਹੈ।

Elasticsearch ਵਿੱਚ ਸੂਚਕਾਂਕ ਵਿੱਚ ਸਮਾਨ ਡੇਟਾ ਦਾ ਆਕਾਰ 4,5GB ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਪੈਰਾਮੀਟਰਾਂ ਵਿੱਚ ਵੈਕਟਰ ਵਿੱਚ ਡੇਟਾ ਨਿਰਦਿਸ਼ਟ ਨਹੀਂ ਕਰਦੇ ਹੋ, ਤਾਂ Clickhouse Elasticsearch ਨਾਲੋਂ 4500/857.19 = 5.24 ਗੁਣਾ ਘੱਟ ਲੈਂਦਾ ਹੈ।

ਵੈਕਟਰ ਵਿੱਚ, ਕੰਪਰੈਸ਼ਨ ਫੀਲਡ ਮੂਲ ਰੂਪ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।

ਦੁਆਰਾ ਟੈਲੀਗ੍ਰਾਮ ਚੈਟ ਕਲਿੱਕਹਾਊਸ
ਦੁਆਰਾ ਟੈਲੀਗ੍ਰਾਮ ਚੈਟ ਲਲਸੀ ਖੋਜ
ਟੈਲੀਗ੍ਰਾਮ ਚੈਟ ਦੁਆਰਾ "ਸਿਸਟਮ ਦਾ ਸੰਗ੍ਰਹਿ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਸੁਨੇਹੇ"

ਸਰੋਤ: www.habr.com