🥇ಕ್ಲಿಕ್‌ಹೌಸ್ ಮತ್ತು ಎಲಾಸ್ಟಿಕ್‌ಸರ್ಚ್‌ಗೆ ವೆಕ್ಟರ್ ಬಳಸಿ Nginx json ಲಾಗ್‌ಗಳನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತಿದೆ

ವೆಕ್ಟರ್, ಲಾಗ್ ಡೇಟಾ, ಮೆಟ್ರಿಕ್‌ಗಳು ಮತ್ತು ಈವೆಂಟ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು, ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಕಳುಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

ರಸ್ಟ್ ಭಾಷೆಯಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿರುವುದರಿಂದ, ಅದರ ಅನಲಾಗ್‌ಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಇದು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಕಡಿಮೆ RAM ಬಳಕೆಯಿಂದ ನಿರೂಪಿಸಲ್ಪಟ್ಟಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಸರಿಯಾದತೆಗೆ ಸಂಬಂಧಿಸಿದ ಕಾರ್ಯಗಳಿಗೆ ಹೆಚ್ಚಿನ ಗಮನವನ್ನು ನೀಡಲಾಗುತ್ತದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ, ಕಳುಹಿಸದ ಈವೆಂಟ್‌ಗಳನ್ನು ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಬಫರ್‌ಗೆ ಉಳಿಸುವ ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು ತಿರುಗಿಸುವ ಸಾಮರ್ಥ್ಯ.

ವಾಸ್ತುಶಿಲ್ಪದ ಪ್ರಕಾರ, ವೆಕ್ಟರ್ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಸಂದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಈವೆಂಟ್ ರೂಟರ್ ಆಗಿದೆ ಮೂಲಗಳು, ಐಚ್ಛಿಕವಾಗಿ ಈ ಸಂದೇಶಗಳ ಮೇಲೆ ಅನ್ವಯಿಸುವುದು ರೂಪಾಂತರಗಳು, ಮತ್ತು ಅವುಗಳನ್ನು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನವರಿಗೆ ಕಳುಹಿಸುವುದು ಬರಿದಾಗುತ್ತದೆ.

ವೆಕ್ಟರ್ ಫೈಲ್‌ಬೀಟ್ ಮತ್ತು ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್‌ಗೆ ಬದಲಿಯಾಗಿದೆ, ಇದು ಎರಡೂ ಪಾತ್ರಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ (ಲಾಗ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಿ ಮತ್ತು ಕಳುಹಿಸಿ), ಅವುಗಳ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿವರಗಳು ಸೈಟ್.

ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್‌ನಲ್ಲಿ ಸರಪಳಿಯನ್ನು ಇನ್‌ಪುಟ್ → ಫಿಲ್ಟರ್ → ಔಟ್‌ಪುಟ್ ಆಗಿ ನಿರ್ಮಿಸಿದ್ದರೆ ಅದು ವೆಕ್ಟರ್‌ನಲ್ಲಿ ಮೂಲಗಳು → ರೂಪಾಂತರಗೊಳ್ಳುತ್ತದೆ → ಮುಳುಗುತ್ತದೆ

ಉದಾಹರಣೆಗಳನ್ನು ದಸ್ತಾವೇಜನ್ನು ಕಾಣಬಹುದು.

ಈ ಸೂಚನೆಯು ಪರಿಷ್ಕೃತ ಸೂಚನೆಯಾಗಿದೆ ವ್ಯಾಚೆಸ್ಲಾವ್ ರಾಖಿನ್ಸ್ಕಿ. ಮೂಲ ಸೂಚನೆಗಳು ಜಿಯೋಪ್ ಸಂಸ್ಕರಣೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಆಂತರಿಕ ನೆಟ್ವರ್ಕ್ನಿಂದ ಜಿಯೋಪ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವಾಗ, ವೆಕ್ಟರ್ ದೋಷವನ್ನು ನೀಡಿತು.

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 (ಪ್ರವೇಶ ಲಾಗ್‌ಗಳು) → ವೆಕ್ಟರ್ (ಕ್ಲೈಂಟ್ | ಫೈಲ್‌ಬೀಟ್) → ವೆಕ್ಟರ್ (ಸರ್ವರ್ | ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್) → ಸಂಯೋಜನೆಯನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಕ್ಲಿಕ್‌ಹೌಸ್‌ನಲ್ಲಿ ಮತ್ತು ಪ್ರತ್ಯೇಕವಾಗಿ ಎಲಾಸ್ಟಿಕ್‌ಸರ್ಚ್‌ನಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತೇವೆ. ನಾವು 4 ಸರ್ವರ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ. ನೀವು ಅದನ್ನು 3 ಸರ್ವರ್‌ಗಳೊಂದಿಗೆ ಬೈಪಾಸ್ ಮಾಡಬಹುದು.

ಯೋಜನೆಯು ಈ ರೀತಿಯದ್ದಾಗಿದೆ.

ನಿಮ್ಮ ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳಲ್ಲಿ Selinux ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ

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

ನಾವು ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳಲ್ಲಿ HTTP ಸರ್ವರ್ ಎಮ್ಯುಲೇಟರ್ + ಉಪಯುಕ್ತತೆಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ

HTTP ಸರ್ವರ್ ಎಮ್ಯುಲೇಟರ್ ಆಗಿ ನಾವು ಬಳಸುತ್ತೇವೆ nodejs-stub-server ರಿಂದ ಮ್ಯಾಕ್ಸಿಮ್ ಇಗ್ನಾಟೆಂಕೊ

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

ನಾನು stub_http_server ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವನ್ನು /var/lib/stub_http_server/stub_http_server.js ಫೈಲ್‌ನಲ್ಲಿ ಸರಿಪಡಿಸಿದ್ದೇನೆ ಇದರಿಂದ ಹೆಚ್ಚಿನ ಲಾಗ್‌ಗಳಿವೆ.

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 ಗೆ ಕಳುಹಿಸಲು 4 ನೇ ಸರ್ವರ್‌ನಲ್ಲಿ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟವನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

ಸಾರ್ವಜನಿಕ 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

ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟ ಮತ್ತು ಕಿಬಾನಾವನ್ನು ಸ್ಥಾಪಿಸಿ

yum install -y kibana elasticsearch

ಇದು 1 ಪ್ರತಿಯಲ್ಲಿರುವುದರಿಂದ, ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು /etc/elasticsearch/elasticsearch.yml ಫೈಲ್‌ಗೆ ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ:

discovery.type: single-node

ಆದ್ದರಿಂದ ವೆಕ್ಟರ್ ಮತ್ತೊಂದು ಸರ್ವರ್‌ನಿಂದ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟಕ್ಕೆ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಬಹುದು, ನಾವು network.host ಅನ್ನು ಬದಲಾಯಿಸೋಣ.

network.host: 0.0.0.0

ಕಿಬಾನಾಗೆ ಸಂಪರ್ಕಿಸಲು, /etc/kibana/kibana.yml ಫೈಲ್‌ನಲ್ಲಿ server.host ನಿಯತಾಂಕವನ್ನು ಬದಲಾಯಿಸಿ

server.host: "0.0.0.0"

ಹಳೆಯದು ಮತ್ತು ಸ್ವಯಂಪ್ರಾರಂಭದಲ್ಲಿ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟವನ್ನು ಸೇರಿಸಿ

systemctl enable elasticsearch
systemctl start elasticsearch

ಮತ್ತು ಕಿಬಾನಾ

systemctl enable kibana
systemctl start kibana

ಏಕ-ನೋಡ್ ಮೋಡ್ 1 ಚೂರು, 0 ಪ್ರತಿಕೃತಿಗಾಗಿ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತಿದೆ. ಹೆಚ್ಚಾಗಿ ನೀವು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಸರ್ವರ್‌ಗಳ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತೀರಿ ಮತ್ತು ನೀವು ಇದನ್ನು ಮಾಡಬೇಕಾಗಿಲ್ಲ.

ಭವಿಷ್ಯದ ಸೂಚಿಕೆಗಳಿಗಾಗಿ, ಡೀಫಾಲ್ಟ್ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ನವೀಕರಿಸಿ:

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 ನಲ್ಲಿ ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್‌ಗೆ ಬದಲಿಯಾಗಿ

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_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.

ಕ್ಲೈಂಟ್ನಲ್ಲಿ (ವೆಬ್ ಸರ್ವರ್) - 1 ನೇ ಸರ್ವರ್

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 ನಿರ್ದೇಶನಗಳನ್ನು ಹೊಂದಲು ಅನುಮತಿಸುತ್ತದೆ

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

ವರ್ಚುವಲ್ ಹೋಸ್ಟ್‌ಗಳನ್ನು (nginx ಸ್ಥಾಪಿಸಲಾದ ಸರ್ವರ್‌ನ 172.26.10.106 ip) ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳಿಗೆ /etc/hosts ಫೈಲ್‌ಗೆ ಸೇರಿಸಿ:

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 adm ಗುಂಪು ಹಕ್ಕುಗಳೊಂದಿಗೆ ಲಾಗ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ.

usermod -a -G adm vector

ವೆಕ್ಟರ್ ಸೇವೆಯನ್ನು ಪ್ರಾರಂಭಿಸೋಣ

systemctl enable vector
systemctl start vector

ವೆಕ್ಟರ್ ಲಾಗ್‌ಗಳನ್ನು ಈ ರೀತಿ ವೀಕ್ಷಿಸಬಹುದು:

journalctl -f -u vector

ಲಾಗ್‌ಗಳಲ್ಲಿ ಈ ರೀತಿಯ ನಮೂದು ಇರಬೇಕು

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

ಒತ್ತಡ ಪರೀಕ್ಷೆ

ನಾವು ಅಪಾಚೆ ಮಾನದಂಡವನ್ನು ಬಳಸಿಕೊಂಡು ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸುತ್ತೇವೆ.

ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳಲ್ಲಿ httpd-tools ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ

ನಾವು ಪರದೆಯ 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 ಆಗಿದೆ.

ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಲ್ಲಿ ವೆಕ್ಟರ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಕ್ಲಿಕ್‌ಹೌಸ್ ಎಲಾಸ್ಟಿಕ್‌ಸರ್ಚ್‌ಗಿಂತ 4500/857.19 = 5.24 ಪಟ್ಟು ಕಡಿಮೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ವೆಕ್ಟರ್ನಲ್ಲಿ, ಕಂಪ್ರೆಷನ್ ಕ್ಷೇತ್ರವನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್ ಮೂಲಕ ಕ್ಲಿಕ್ಹೌಸ್
ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್ ಮೂಲಕ Elasticsearch
"ನಿಂದ ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್ವ್ಯವಸ್ಥೆಯ ಸಂಗ್ರಹಣೆ ಮತ್ತು ವಿಶ್ಲೇಷಣೆ ಸಂದೇಶಗಳು"

ಮೂಲ: www.habr.com