Amazon Athena ಮತ್ತು Cube.js ಬಳಸಿಕೊಂಡು 🥇Nginx ಲಾಗ್ ಅನಾಲಿಟಿಕ್ಸ್

ವಿಶಿಷ್ಟವಾಗಿ, Nginx ನ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ವಾಣಿಜ್ಯ ಉತ್ಪನ್ನಗಳು ಅಥವಾ Prometheus + Grafana ನಂತಹ ಸಿದ್ಧ-ಸಿದ್ಧ ಮುಕ್ತ-ಮೂಲ ಪರ್ಯಾಯಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಮೇಲ್ವಿಚಾರಣೆ ಅಥವಾ ನೈಜ-ಸಮಯದ ವಿಶ್ಲೇಷಣೆಗೆ ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ, ಆದರೆ ಐತಿಹಾಸಿಕ ವಿಶ್ಲೇಷಣೆಗೆ ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿಲ್ಲ. ಯಾವುದೇ ಜನಪ್ರಿಯ ಸಂಪನ್ಮೂಲದಲ್ಲಿ, nginx ಲಾಗ್‌ಗಳಿಂದ ಡೇಟಾದ ಪ್ರಮಾಣವು ವೇಗವಾಗಿ ಬೆಳೆಯುತ್ತಿದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಲು, ಹೆಚ್ಚು ವಿಶೇಷವಾದದ್ದನ್ನು ಬಳಸುವುದು ತಾರ್ಕಿಕವಾಗಿದೆ.

ನೀವು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ ಅಥೇನಾ ಲಾಗ್‌ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು, Nginx ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಓಪನ್ ಸೋರ್ಸ್ cube.js ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಡೇಟಾದಿಂದ ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ಹೇಗೆ ಜೋಡಿಸುವುದು ಎಂದು ನಾನು ತೋರಿಸುತ್ತೇನೆ. ಸಂಪೂರ್ಣ ಪರಿಹಾರ ವಾಸ್ತುಶಿಲ್ಪ ಇಲ್ಲಿದೆ:

TL:DR;
ಮುಗಿದ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗೆ ಲಿಂಕ್ ಮಾಡಿ.

ನಾವು ಬಳಸುವ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ನಿರರ್ಗಳವಾಗಿ, ಸಂಸ್ಕರಣೆಗಾಗಿ - AWS ಕೈನೆಸಿಸ್ ಡೇಟಾ ಫೈರ್‌ಹೋಸ್ и AWS ಅಂಟುಶೇಖರಣೆಗಾಗಿ - AWS S3. ಈ ಬಂಡಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು nginx ಲಾಗ್‌ಗಳನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಇತರ ಈವೆಂಟ್‌ಗಳು ಮತ್ತು ಇತರ ಸೇವೆಗಳ ಲಾಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ನಿಮ್ಮ ಸ್ಟಾಕ್‌ಗಾಗಿ ನೀವು ಕೆಲವು ಭಾಗಗಳನ್ನು ಒಂದೇ ರೀತಿಯ ಭಾಗಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ನೀವು nginx ನಿಂದ ನೇರವಾಗಿ ಕೈನೆಸಿಸ್‌ಗೆ ಲಾಗ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು, fluentd ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡಬಹುದು ಅಥವಾ ಇದಕ್ಕಾಗಿ logstash ಅನ್ನು ಬಳಸಬಹುದು.

Nginx ಲಾಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತಿದೆ

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, Nginx ಲಾಗ್‌ಗಳು ಈ ರೀತಿ ಕಾಣುತ್ತವೆ:

4/9/2019 12:58:17 PM1.1.1.1 - - [09/Apr/2019:09:58:17 +0000] "GET /sign-up HTTP/2.0" 200 9168 "https://example.com/sign-in" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36" "-"
4/9/2019 12:58:17 PM1.1.1.1 - - [09/Apr/2019:09:58:17 +0000] "GET /sign-in HTTP/2.0" 200 9168 "https://example.com/sign-up" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36" "-"

ಅವುಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಬಹುದು, ಆದರೆ Nginx ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಸರಿಪಡಿಸಲು ಇದು ತುಂಬಾ ಸುಲಭವಾಗಿದೆ ಇದರಿಂದ ಅದು JSON ನಲ್ಲಿ ಲಾಗ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

log_format json_combined escape=json '{ "created_at": "$msec", '
            '"remote_addr": "$remote_addr", '
            '"remote_user": "$remote_user", '
            '"request": "$request", '
            '"status": $status, '
            '"bytes_sent": $bytes_sent, '
            '"request_length": $request_length, '
            '"request_time": $request_time, '
            '"http_referrer": "$http_referer", '
            '"http_x_forwarded_for": "$http_x_forwarded_for", '
            '"http_user_agent": "$http_user_agent" }';

access_log  /var/log/nginx/access.log  json_combined;

ಶೇಖರಣೆಗಾಗಿ S3

ದಾಖಲೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು, ನಾವು S3 ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಲಾಗ್‌ಗಳನ್ನು ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಅಥೇನಾ ನೇರವಾಗಿ S3 ನಲ್ಲಿ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಹುದು. ನಂತರ ಲೇಖನದಲ್ಲಿ ಲಾಗ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ಸೇರಿಸುವುದು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ, ಆದರೆ ಮೊದಲು ನಮಗೆ S3 ನಲ್ಲಿ ಕ್ಲೀನ್ ಬಕೆಟ್ ಅಗತ್ಯವಿದೆ, ಇದರಲ್ಲಿ ಬೇರೆ ಏನನ್ನೂ ಸಂಗ್ರಹಿಸಲಾಗುವುದಿಲ್ಲ. ನಿಮ್ಮ ಬಕೆಟ್ ಅನ್ನು ನೀವು ಯಾವ ಪ್ರದೇಶದಲ್ಲಿ ರಚಿಸುತ್ತೀರಿ ಎಂಬುದನ್ನು ಮುಂಚಿತವಾಗಿ ಪರಿಗಣಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ, ಏಕೆಂದರೆ ಎಲ್ಲಾ ಪ್ರದೇಶಗಳಲ್ಲಿ ಅಥೇನಾ ಲಭ್ಯವಿಲ್ಲ.

ಅಥೇನಾ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಸರ್ಕ್ಯೂಟ್ ಅನ್ನು ರಚಿಸುವುದು

ಲಾಗ್‌ಗಳಿಗಾಗಿ ಅಥೇನಾದಲ್ಲಿ ಟೇಬಲ್ ಅನ್ನು ರಚಿಸೋಣ. ನೀವು ಕೈನೆಸಿಸ್ ಫೈರ್‌ಹೋಸ್ ಅನ್ನು ಬಳಸಲು ಯೋಜಿಸಿದರೆ ಬರೆಯಲು ಮತ್ತು ಓದಲು ಇದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಅಥೇನಾ ಕನ್ಸೋಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ಟೇಬಲ್ ಅನ್ನು ರಚಿಸಿ:

SQL ಟೇಬಲ್ ರಚನೆ

CREATE EXTERNAL TABLE `kinesis_logs_nginx`(
  `created_at` double, 
  `remote_addr` string, 
  `remote_user` string, 
  `request` string, 
  `status` int, 
  `bytes_sent` int, 
  `request_length` int, 
  `request_time` double, 
  `http_referrer` string, 
  `http_x_forwarded_for` string, 
  `http_user_agent` string)
ROW FORMAT SERDE 
  'org.apache.hadoop.hive.ql.io.orc.OrcSerde' 
STORED AS INPUTFORMAT 
  'org.apache.hadoop.hive.ql.io.orc.OrcInputFormat' 
OUTPUTFORMAT 
  'org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat'
LOCATION
  's3://<YOUR-S3-BUCKET>'
TBLPROPERTIES ('has_encrypted_data'='false');

ಕೈನೆಸಿಸ್ ಫೈರ್‌ಹೋಸ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

Kinesis Firehose ಆಯ್ದ ಸ್ವರೂಪದಲ್ಲಿ Nginx ನಿಂದ S3 ಗೆ ಸ್ವೀಕರಿಸಿದ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತದೆ, ಅದನ್ನು YYYY/MM/DD/HH ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಡೈರೆಕ್ಟರಿಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ. ಡೇಟಾವನ್ನು ಓದುವಾಗ ಇದು ಸೂಕ್ತವಾಗಿ ಬರುತ್ತದೆ. ನೀವು ಸಹಜವಾಗಿ, fluentd ನಿಂದ S3 ಗೆ ನೇರವಾಗಿ ಬರೆಯಬಹುದು, ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು JSON ಅನ್ನು ಬರೆಯಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಫೈಲ್‌ಗಳ ದೊಡ್ಡ ಗಾತ್ರದ ಕಾರಣ ಇದು ನಿಷ್ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, PrestoDB ಅಥವಾ Athena ಅನ್ನು ಬಳಸುವಾಗ, JSON ನಿಧಾನವಾದ ಡೇಟಾ ಸ್ವರೂಪವಾಗಿದೆ. ಆದ್ದರಿಂದ ಕೈನೆಸಿಸ್ ಫೈರ್‌ಹೋಸ್ ಕನ್ಸೋಲ್ ತೆರೆಯಿರಿ, "ವಿತರಣಾ ಸ್ಟ್ರೀಮ್ ರಚಿಸಿ" ಕ್ಲಿಕ್ ಮಾಡಿ, "ಡೆಲಿವರಿ" ಕ್ಷೇತ್ರದಲ್ಲಿ "ನೇರ PUT" ಆಯ್ಕೆಮಾಡಿ:

ಮುಂದಿನ ಟ್ಯಾಬ್‌ನಲ್ಲಿ, "ರೆಕಾರ್ಡ್ ಫಾರ್ಮ್ಯಾಟ್ ಪರಿವರ್ತನೆ" - "ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ" ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ರೆಕಾರ್ಡಿಂಗ್ ಸ್ವರೂಪವಾಗಿ "ಅಪಾಚೆ ORC" ಆಯ್ಕೆಮಾಡಿ. ಕೆಲವು ಸಂಶೋಧನೆಗಳ ಪ್ರಕಾರ ಓವನ್ ಒ'ಮ್ಯಾಲಿ, ಇದು PrestoDB ಮತ್ತು Athena ಗಾಗಿ ಸೂಕ್ತ ಸ್ವರೂಪವಾಗಿದೆ. ನಾವು ಮೇಲೆ ರಚಿಸಿದ ಕೋಷ್ಟಕವನ್ನು ಸ್ಕೀಮಾವಾಗಿ ಬಳಸುತ್ತೇವೆ. ನೀವು ಕೈನೆಸಿಸ್‌ನಲ್ಲಿ ಯಾವುದೇ S3 ಸ್ಥಳವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ; ಟೇಬಲ್‌ನಿಂದ ಸ್ಕೀಮಾವನ್ನು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ. ಆದರೆ ನೀವು ಬೇರೆ S3 ಸ್ಥಳವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ಈ ಕೋಷ್ಟಕದಿಂದ ಈ ದಾಖಲೆಗಳನ್ನು ಓದಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ನಾವು ಶೇಖರಣೆಗಾಗಿ S3 ಮತ್ತು ನಾವು ಮೊದಲು ರಚಿಸಿದ ಬಕೆಟ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ. ಆವ್ಸ್ ಗ್ಲೂ ಕ್ರಾಲರ್, ನಾನು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಮಾತನಾಡುತ್ತೇನೆ, ಎಸ್ 3 ಬಕೆಟ್‌ನಲ್ಲಿ ಪೂರ್ವಪ್ರತ್ಯಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದನ್ನು ಖಾಲಿ ಬಿಡುವುದು ಮುಖ್ಯ.

ನಿಮ್ಮ ಲೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಉಳಿದ ಆಯ್ಕೆಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು; ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಡೀಫಾಲ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತೇನೆ. S3 ಕಂಪ್ರೆಷನ್ ಲಭ್ಯವಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಆದರೆ ORC ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಸ್ಥಳೀಯ ಸಂಕೋಚನವನ್ನು ಬಳಸುತ್ತದೆ.

ನಿರರ್ಗಳವಾಗಿ

ಈಗ ನಾವು ಲಾಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಸ್ವೀಕರಿಸಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೇವೆ, ನಾವು ಕಳುಹಿಸುವಿಕೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗಿದೆ. ನಾವು ಬಳಸುತ್ತೇವೆ ನಿರರ್ಗಳವಾಗಿ, ಏಕೆಂದರೆ ನಾನು ರೂಬಿಯನ್ನು ಪ್ರೀತಿಸುತ್ತೇನೆ, ಆದರೆ ನೀವು ಲಾಗ್‌ಸ್ಟಾಶ್ ಅನ್ನು ಬಳಸಬಹುದು ಅಥವಾ ನೇರವಾಗಿ ಕೈನೆಸಿಸ್‌ಗೆ ಲಾಗ್‌ಗಳನ್ನು ಕಳುಹಿಸಬಹುದು. Fluentd ಸರ್ವರ್ ಅನ್ನು ಹಲವಾರು ವಿಧಗಳಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬಹುದು, ನಾನು ಡಾಕರ್ ಬಗ್ಗೆ ಹೇಳುತ್ತೇನೆ ಏಕೆಂದರೆ ಅದು ಸರಳ ಮತ್ತು ಅನುಕೂಲಕರವಾಗಿದೆ.

ಮೊದಲಿಗೆ, ನಮಗೆ fluent.conf ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅಗತ್ಯವಿದೆ. ಅದನ್ನು ರಚಿಸಿ ಮತ್ತು ಮೂಲವನ್ನು ಸೇರಿಸಿ:

ಮಾದರಿ ಮುಂದೆ
ಪೋರ್ಟ್ 24224
ಬಂಧಿಸು 0.0.0.0

ಈಗ ನೀವು Fluentd ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ನಿಮಗೆ ಹೆಚ್ಚು ಸುಧಾರಿತ ಕಾನ್ಫಿಗರೇಶನ್ ಅಗತ್ಯವಿದ್ದರೆ, ಹೋಗಿ ಡಾಕರ್ ಹಬ್ ನಿಮ್ಮ ಚಿತ್ರವನ್ನು ಹೇಗೆ ಜೋಡಿಸುವುದು ಸೇರಿದಂತೆ ವಿವರವಾದ ಮಾರ್ಗದರ್ಶಿ ಇದೆ.

$ docker run 
  -d 
  -p 24224:24224 
  -p 24224:24224/udp 
  -v /data:/fluentd/log 
  -v <PATH-TO-FLUENT-CONF>:/fluentd/etc fluentd 
  -c /fluentd/etc/fluent.conf
  fluent/fluentd:stable

ಈ ಸಂರಚನೆಯು ಮಾರ್ಗವನ್ನು ಬಳಸುತ್ತದೆ /fluentd/log ಕಳುಹಿಸುವ ಮೊದಲು ದಾಖಲೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು. ನೀವು ಇದನ್ನು ಮಾಡದೆಯೇ ಮಾಡಬಹುದು, ಆದರೆ ನೀವು ಮರುಪ್ರಾರಂಭಿಸಿದಾಗ, ಬ್ಯಾಕ್ ಬ್ರೇಕಿಂಗ್ ಕಾರ್ಮಿಕರೊಂದಿಗೆ ಸಂಗ್ರಹವಾಗಿರುವ ಎಲ್ಲವನ್ನೂ ನೀವು ಕಳೆದುಕೊಳ್ಳಬಹುದು. ನೀವು ಯಾವುದೇ ಪೋರ್ಟ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು; 24224 ಡೀಫಾಲ್ಟ್ Fluentd ಪೋರ್ಟ್ ಆಗಿದೆ.

ಈಗ ನಾವು Fluentd ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, ನಾವು Nginx ಲಾಗ್‌ಗಳನ್ನು ಅಲ್ಲಿಗೆ ಕಳುಹಿಸಬಹುದು. ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಡಾಕರ್ ಕಂಟೇನರ್‌ನಲ್ಲಿ Nginx ಅನ್ನು ರನ್ ಮಾಡುತ್ತೇವೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಡಾಕರ್ Fluentd ಗಾಗಿ ಸ್ಥಳೀಯ ಲಾಗಿಂಗ್ ಡ್ರೈವರ್ ಅನ್ನು ಹೊಂದಿದೆ:

$ docker run 
--log-driver=fluentd 
--log-opt fluentd-address=<FLUENTD-SERVER-ADDRESS>
--log-opt tag="{{.Name}}" 
-v /some/content:/usr/share/nginx/html:ro 
-d 
nginx

ನೀವು Nginx ಅನ್ನು ವಿಭಿನ್ನವಾಗಿ ಚಲಾಯಿಸಿದರೆ, ನೀವು ಲಾಗ್ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸಬಹುದು, Fluentd ಹೊಂದಿದೆ ಫೈಲ್ ಟೈಲ್ ಪ್ಲಗಿನ್.

ಮೇಲೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಲಾಗ್ ಪಾರ್ಸಿಂಗ್ ಅನ್ನು ಫ್ಲೂಯೆಂಟ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ಸೇರಿಸೋಣ:

<filter YOUR-NGINX-TAG.*>
  @type parser
  key_name log
  emit_invalid_record_to_error false
  <parse>
    @type json
  </parse>
</filter>

ಮತ್ತು ಬಳಸಿ ಕೈನೆಸಿಸ್‌ಗೆ ಲಾಗ್‌ಗಳನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತಿದೆ ಕಿನೆಸಿಸ್ ಫೈರ್‌ಹೋಸ್ ಪ್ಲಗಿನ್:

<match YOUR-NGINX-TAG.*>
    @type kinesis_firehose
    region region
    delivery_stream_name <YOUR-KINESIS-STREAM-NAME>
    aws_key_id <YOUR-AWS-KEY-ID>
    aws_sec_key <YOUR_AWS-SEC_KEY>
</match>

ಅಥೇನಾ

ನೀವು ಎಲ್ಲವನ್ನೂ ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದರೆ, ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ (ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಕಿನೆಸಿಸ್ ದಾಖಲೆಗಳು ಪ್ರತಿ 10 ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ) ನೀವು S3 ನಲ್ಲಿ ಲಾಗ್ ಫೈಲ್‌ಗಳನ್ನು ನೋಡಬೇಕು. ಕಿನೆಸಿಸ್ ಫೈರ್‌ಹೋಸ್‌ನ "ಮೇಲ್ವಿಚಾರಣೆ" ಮೆನುವಿನಲ್ಲಿ ನೀವು S3 ನಲ್ಲಿ ಎಷ್ಟು ಡೇಟಾವನ್ನು ದಾಖಲಿಸಲಾಗಿದೆ, ಹಾಗೆಯೇ ದೋಷಗಳನ್ನು ನೋಡಬಹುದು. ಕೈನೆಸಿಸ್ ಪಾತ್ರಕ್ಕೆ S3 ಬಕೆಟ್‌ಗೆ ಬರೆಯುವ ಪ್ರವೇಶವನ್ನು ನೀಡಲು ಮರೆಯಬೇಡಿ. ಕಿನೆಸಿಸ್ ಏನನ್ನಾದರೂ ಪಾರ್ಸ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ಅದು ಅದೇ ಬಕೆಟ್‌ಗೆ ದೋಷಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ.

ಈಗ ನೀವು ಅಥೇನಾದಲ್ಲಿ ಡೇಟಾವನ್ನು ವೀಕ್ಷಿಸಬಹುದು. ನಾವು ದೋಷಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿರುವ ಇತ್ತೀಚಿನ ವಿನಂತಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯೋಣ:

SELECT * FROM "db_name"."table_name" WHERE status > 499 ORDER BY created_at DESC limit 10;

ಪ್ರತಿ ವಿನಂತಿಗಾಗಿ ಎಲ್ಲಾ ದಾಖಲೆಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಈಗ ನಮ್ಮ ಲಾಗ್‌ಗಳನ್ನು ORC ಯಲ್ಲಿ S3 ನಲ್ಲಿ ಸಂಸ್ಕರಿಸಲಾಗಿದೆ ಮತ್ತು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ, ಸಂಕುಚಿತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ವಿಶ್ಲೇಷಣೆಗೆ ಸಿದ್ಧವಾಗಿದೆ. ಕಿನೆಸಿಸ್ ಫೈರ್‌ಹೋಸ್ ಪ್ರತಿ ಗಂಟೆಗೆ ಅವುಗಳನ್ನು ಡೈರೆಕ್ಟರಿಗಳಾಗಿ ಆಯೋಜಿಸಿದೆ. ಆದಾಗ್ಯೂ, ಟೇಬಲ್ ಅನ್ನು ವಿಭಜಿಸದೆ ಇರುವವರೆಗೆ, ಅಪರೂಪದ ವಿನಾಯಿತಿಗಳೊಂದಿಗೆ ಅಥೆನಾ ಪ್ರತಿ ವಿನಂತಿಯ ಮೇಲೆ ಸಾರ್ವಕಾಲಿಕ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ. ಎರಡು ಕಾರಣಗಳಿಗಾಗಿ ಇದು ದೊಡ್ಡ ಸಮಸ್ಯೆಯಾಗಿದೆ:

ಡೇಟಾದ ಪ್ರಮಾಣವು ನಿರಂತರವಾಗಿ ಬೆಳೆಯುತ್ತಿದೆ, ಪ್ರಶ್ನೆಗಳನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ;
ಪ್ರತಿ ವಿನಂತಿಗೆ ಕನಿಷ್ಠ 10 MB ಯೊಂದಿಗೆ ಸ್ಕ್ಯಾನ್ ಮಾಡಿದ ಡೇಟಾದ ಪರಿಮಾಣದ ಆಧಾರದ ಮೇಲೆ ಅಥೇನಾಗೆ ಬಿಲ್ ಮಾಡಲಾಗುತ್ತದೆ.

ಇದನ್ನು ಸರಿಪಡಿಸಲು, ನಾವು AWS ಗ್ಲೂ ಕ್ರಾಲರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು S3 ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಕ್ರಾಲ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅಂಟು ಮೆಟಾಸ್ಟೋರ್‌ಗೆ ವಿಭಾಗದ ಮಾಹಿತಿಯನ್ನು ಬರೆಯುತ್ತದೆ. ಅಥೇನಾವನ್ನು ಪ್ರಶ್ನಿಸುವಾಗ ವಿಭಾಗಗಳನ್ನು ಫಿಲ್ಟರ್ ಆಗಿ ಬಳಸಲು ಇದು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ಇದು ಪ್ರಶ್ನೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಮಾತ್ರ ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ.

Amazon Glue Crawler ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

Amazon Glue Crawler S3 ಬಕೆಟ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ವಿಭಾಗಗಳೊಂದಿಗೆ ಕೋಷ್ಟಕಗಳನ್ನು ರಚಿಸುತ್ತದೆ. AWS ಗ್ಲೂ ಕನ್ಸೋಲ್‌ನಿಂದ ಅಂಟು ಕ್ರಾಲರ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ನೀವು ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಬಕೆಟ್ ಅನ್ನು ಸೇರಿಸಿ. ನೀವು ಹಲವಾರು ಬಕೆಟ್‌ಗಳಿಗೆ ಒಂದು ಕ್ರಾಲರ್ ಅನ್ನು ಬಳಸಬಹುದು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಬಕೆಟ್‌ಗಳ ಹೆಸರುಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಹೆಸರುಗಳೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಕೋಷ್ಟಕಗಳನ್ನು ರಚಿಸುತ್ತದೆ. ನೀವು ಈ ಡೇಟಾವನ್ನು ನಿಯಮಿತವಾಗಿ ಬಳಸಲು ಯೋಜಿಸುತ್ತಿದ್ದರೆ, ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ಕ್ರಾಲರ್‌ನ ಉಡಾವಣಾ ವೇಳಾಪಟ್ಟಿಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಮರೆಯದಿರಿ. ನಾವು ಎಲ್ಲಾ ಟೇಬಲ್‌ಗಳಿಗೆ ಒಂದು ಕ್ರಾಲರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದು ಪ್ರತಿ ಗಂಟೆಗೆ ಚಲಿಸುತ್ತದೆ.

ವಿಭಜಿತ ಕೋಷ್ಟಕಗಳು

ಕ್ರಾಲರ್‌ನ ಮೊದಲ ಉಡಾವಣೆಯ ನಂತರ, ಪ್ರತಿ ಸ್ಕ್ಯಾನ್ ಮಾಡಿದ ಬಕೆಟ್‌ಗೆ ಕೋಷ್ಟಕಗಳು ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಗೋಚರಿಸಬೇಕು. ಅಥೇನಾ ಕನ್ಸೋಲ್ ತೆರೆಯಿರಿ ಮತ್ತು Nginx ಲಾಗ್‌ಗಳೊಂದಿಗೆ ಟೇಬಲ್ ಅನ್ನು ಹುಡುಕಿ. ಏನನ್ನಾದರೂ ಓದಲು ಪ್ರಯತ್ನಿಸೋಣ:

SELECT * FROM "default"."part_demo_kinesis_bucket"
WHERE(
  partition_0 = '2019' AND
  partition_1 = '04' AND
  partition_2 = '08' AND
  partition_3 = '06'
  );

ಈ ಪ್ರಶ್ನೆಯು ಏಪ್ರಿಲ್ 6, 7 ರಂದು ಬೆಳಿಗ್ಗೆ 8 ರಿಂದ 2019 ಗಂಟೆಯವರೆಗೆ ಸ್ವೀಕರಿಸಿದ ಎಲ್ಲಾ ದಾಖಲೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. ಆದರೆ ವಿಭಜನೆಯಾಗದ ಟೇಬಲ್‌ನಿಂದ ಓದುವುದಕ್ಕಿಂತ ಇದು ಎಷ್ಟು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ? ಅದೇ ದಾಖಲೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯೋಣ ಮತ್ತು ಆಯ್ಕೆಮಾಡೋಣ, ಅವುಗಳನ್ನು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಮೂಲಕ ಫಿಲ್ಟರ್ ಮಾಡೋಣ:

ಕೇವಲ ಒಂದು ವಾರದ ಲಾಗ್‌ಗಳೊಂದಿಗೆ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ 3.59 ಸೆಕೆಂಡುಗಳು ಮತ್ತು 244.34 ಮೆಗಾಬೈಟ್‌ಗಳ ಡೇಟಾ. ವಿಭಜನೆಯ ಮೂಲಕ ಫಿಲ್ಟರ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸೋಣ:

ಸ್ವಲ್ಪ ವೇಗವಾಗಿ, ಆದರೆ ಮುಖ್ಯವಾಗಿ - ಕೇವಲ 1.23 ಮೆಗಾಬೈಟ್ ಡೇಟಾ! ಬೆಲೆಯಲ್ಲಿ ಪ್ರತಿ ವಿನಂತಿಗೆ ಕನಿಷ್ಠ 10 ಮೆಗಾಬೈಟ್‌ಗಳಿಲ್ಲದಿದ್ದರೆ ಅದು ಹೆಚ್ಚು ಅಗ್ಗವಾಗಿರುತ್ತದೆ. ಆದರೆ ಇದು ಇನ್ನೂ ಉತ್ತಮವಾಗಿದೆ, ಮತ್ತು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ವ್ಯತ್ಯಾಸವು ಹೆಚ್ಚು ಪ್ರಭಾವಶಾಲಿಯಾಗಿರುತ್ತದೆ.

Cube.js ಅನ್ನು ಬಳಸಿಕೊಂಡು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು

ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ಜೋಡಿಸಲು, ನಾವು Cube.js ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಚೌಕಟ್ಟನ್ನು ಬಳಸುತ್ತೇವೆ. ಇದು ಸಾಕಷ್ಟು ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ನಾವು ಎರಡರಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ: ವಿಭಜನಾ ಫಿಲ್ಟರ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ಪೂರ್ವ-ಒಗ್ಗೂಡಿಸುವಿಕೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬಳಸುವ ಸಾಮರ್ಥ್ಯ. ಇದು ಡೇಟಾ ಸ್ಕೀಮಾವನ್ನು ಬಳಸುತ್ತದೆ ಡೇಟಾ ಸ್ಕೀಮಾ, SQL ಅನ್ನು ರಚಿಸಲು ಮತ್ತು ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು Javascript ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ಡೇಟಾ ಸ್ಕೀಮಾದಲ್ಲಿ ವಿಭಜನಾ ಫಿಲ್ಟರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಮಾತ್ರ ನಾವು ಸೂಚಿಸಬೇಕಾಗಿದೆ.

ಹೊಸ Cube.js ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸೋಣ. ನಾವು ಈಗಾಗಲೇ AWS ಸ್ಟಾಕ್ ಅನ್ನು ಬಳಸುತ್ತಿರುವುದರಿಂದ, ನಿಯೋಜನೆಗಾಗಿ ಲ್ಯಾಂಬ್ಡಾವನ್ನು ಬಳಸುವುದು ತಾರ್ಕಿಕವಾಗಿದೆ. ನೀವು Heroku ಅಥವಾ Docker ನಲ್ಲಿ Cube.js ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ಹೋಸ್ಟ್ ಮಾಡಲು ಯೋಜಿಸಿದರೆ ಪೀಳಿಗೆಗೆ ನೀವು ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಬಳಸಬಹುದು. ದಸ್ತಾವೇಜನ್ನು ಇತರರನ್ನು ವಿವರಿಸುತ್ತದೆ ಹೋಸ್ಟಿಂಗ್ ವಿಧಾನಗಳು.

$ npm install -g cubejs-cli
$ cubejs create nginx-log-analytics -t serverless -d athena

cube.js ನಲ್ಲಿ ಡೇಟಾಬೇಸ್ ಪ್ರವೇಶವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಜನರೇಟರ್ .env ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದರಲ್ಲಿ ನಿಮ್ಮ ಕೀಗಳನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಅಥೇನಾ.

ಈಗ ನಮಗೆ ಬೇಕು ಡೇಟಾ ಸ್ಕೀಮಾ, ಇದರಲ್ಲಿ ನಮ್ಮ ಲಾಗ್‌ಗಳನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಾವು ನಿಖರವಾಗಿ ಸೂಚಿಸುತ್ತೇವೆ. ಅಲ್ಲಿ ನೀವು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳಿಗೆ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಹೇಗೆ ಲೆಕ್ಕ ಹಾಕಬೇಕು ಎಂಬುದನ್ನು ಸಹ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ schema, ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ Logs.js. nginx ಗಾಗಿ ಉದಾಹರಣೆ ಡೇಟಾ ಮಾದರಿ ಇಲ್ಲಿದೆ:

ಮಾದರಿ ಕೋಡ್

const partitionFilter = (from, to) => `
    date(from_iso8601_timestamp(${from})) <= date_parse(partition_0 || partition_1 || partition_2, '%Y%m%d') AND
    date(from_iso8601_timestamp(${to})) >= date_parse(partition_0 || partition_1 || partition_2, '%Y%m%d')
    `

cube(`Logs`, {
  sql: `
  select * from part_demo_kinesis_bucket
  WHERE ${FILTER_PARAMS.Logs.createdAt.filter(partitionFilter)}
  `,

  measures: {
    count: {
      type: `count`,
    },

    errorCount: {
      type: `count`,
      filters: [
        { sql: `${CUBE.isError} = 'Yes'` }
      ]
    },

    errorRate: {
      type: `number`,
      sql: `100.0 * ${errorCount} / ${count}`,
      format: `percent`
    }
  },

  dimensions: {
    status: {
      sql: `status`,
      type: `number`
    },

    isError: {
      type: `string`,
      case: {
        when: [{
          sql: `${CUBE}.status >= 400`, label: `Yes`
        }],
        else: { label: `No` }
      }
    },

    createdAt: {
      sql: `from_unixtime(created_at)`,
      type: `time`
    }
  }
});

ಇಲ್ಲಿ ನಾವು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ FILTER_PARAMSವಿಭಜನಾ ಫಿಲ್ಟರ್‌ನೊಂದಿಗೆ SQL ಪ್ರಶ್ನೆಯನ್ನು ರಚಿಸಲು.

ನಾವು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲು ಬಯಸುವ ಮೆಟ್ರಿಕ್‌ಗಳು ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸಹ ಹೊಂದಿಸುತ್ತೇವೆ ಮತ್ತು ಪೂರ್ವ-ಒಗ್ಗೂಡಿಸುವಿಕೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ. Cube.js ಪೂರ್ವ-ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾದೊಂದಿಗೆ ಹೆಚ್ಚುವರಿ ಕೋಷ್ಟಕಗಳನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದು ಬಂದಾಗ ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನವೀಕರಿಸುತ್ತದೆ. ಇದು ಪ್ರಶ್ನೆಗಳನ್ನು ವೇಗಗೊಳಿಸುವುದಲ್ಲದೆ, ಅಥೇನಾವನ್ನು ಬಳಸುವ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಈ ಮಾಹಿತಿಯನ್ನು ಡೇಟಾ ಸ್ಕೀಮಾ ಫೈಲ್‌ಗೆ ಸೇರಿಸೋಣ:

preAggregations: {
  main: {
    type: `rollup`,
    measureReferences: [count, errorCount],
    dimensionReferences: [isError, status],
    timeDimensionReference: createdAt,
    granularity: `day`,
    partitionGranularity: `month`,
    refreshKey: {
      sql: FILTER_PARAMS.Logs.createdAt.filter((from, to) => 
        `select
           CASE WHEN from_iso8601_timestamp(${to}) + interval '3' day > now()
           THEN date_trunc('hour', now()) END`
      )
    }
  }
}

ಬಳಸಿದ ಎಲ್ಲಾ ಮೆಟ್ರಿಕ್‌ಗಳಿಗೆ ಡೇಟಾವನ್ನು ಪೂರ್ವ-ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ತಿಂಗಳ ಮೂಲಕ ವಿಭಜನೆಯನ್ನು ಬಳಸುವುದು ಅಗತ್ಯವೆಂದು ನಾವು ಈ ಮಾದರಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ. ಪೂರ್ವ-ಒಗ್ಗೂಡಿಸುವಿಕೆ ವಿಭಜನೆ ಡೇಟಾ ಸಂಗ್ರಹಣೆ ಮತ್ತು ನವೀಕರಣವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ವೇಗಗೊಳಿಸುತ್ತದೆ.

ಈಗ ನಾವು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ಜೋಡಿಸಬಹುದು!

Cube.js ಬ್ಯಾಕೆಂಡ್ ಒದಗಿಸುತ್ತದೆ REST API ಅನ್ನು ಮತ್ತು ಜನಪ್ರಿಯ ಮುಂಭಾಗದ ಚೌಕಟ್ಟುಗಳಿಗಾಗಿ ಕ್ಲೈಂಟ್ ಲೈಬ್ರರಿಗಳ ಒಂದು ಸೆಟ್. ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಕ್ಲೈಂಟ್‌ನ ರಿಯಾಕ್ಟ್ ಆವೃತ್ತಿಯನ್ನು ಬಳಸುತ್ತೇವೆ. Cube.js ಡೇಟಾವನ್ನು ಮಾತ್ರ ಒದಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಮಗೆ ದೃಶ್ಯೀಕರಣ ಲೈಬ್ರರಿ ಅಗತ್ಯವಿದೆ - ನಾನು ಅದನ್ನು ಇಷ್ಟಪಡುತ್ತೇನೆ ಮರುಚಾರ್ಟ್ಸ್, ಆದರೆ ನೀವು ಯಾವುದನ್ನಾದರೂ ಬಳಸಬಹುದು.

Cube.js ಸರ್ವರ್ ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ JSON ಫಾರ್ಮ್ಯಾಟ್, ಇದು ಅಗತ್ಯವಿರುವ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, Nginx ದಿನಕ್ಕೆ ಎಷ್ಟು ದೋಷಗಳನ್ನು ನೀಡಿದೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ನೀವು ಈ ಕೆಳಗಿನ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಬೇಕು:

{
  "measures": ["Logs.errorCount"],
  "timeDimensions": [
    {
      "dimension": "Logs.createdAt",
      "dateRange": ["2019-01-01", "2019-01-07"],
      "granularity": "day"
    }
  ]
}

NPM ಮೂಲಕ Cube.js ಕ್ಲೈಂಟ್ ಮತ್ತು ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್ ಲೈಬ್ರರಿಯನ್ನು ಸ್ಥಾಪಿಸೋಣ:

$ npm i --save @cubejs-client/core @cubejs-client/react

ನಾವು ಘಟಕಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ cubejs и QueryRendererಡೇಟಾವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಸಂಗ್ರಹಿಸಲು:

ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಕೋಡ್

import React from 'react';
import { LineChart, Line, XAxis, YAxis } from 'recharts';
import cubejs from '@cubejs-client/core';
import { QueryRenderer } from '@cubejs-client/react';

const cubejsApi = cubejs(
  'YOUR-CUBEJS-API-TOKEN',
  { apiUrl: 'http://localhost:4000/cubejs-api/v1' },
);

export default () => {
  return (
    <QueryRenderer
      query={{
        measures: ['Logs.errorCount'],
        timeDimensions: [{
            dimension: 'Logs.createdAt',
            dateRange: ['2019-01-01', '2019-01-07'],
            granularity: 'day'
        }]
      }}
      cubejsApi={cubejsApi}
      render={({ resultSet }) => {
        if (!resultSet) {
          return 'Loading...';
        }

        return (
          <LineChart data={resultSet.rawData()}>
            <XAxis dataKey="Logs.createdAt"/>
            <YAxis/>
            <Line type="monotone" dataKey="Logs.errorCount" stroke="#8884d8"/>
          </LineChart>
        );
      }}
    />
  )
}

ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಮೂಲಗಳು ಇಲ್ಲಿ ಲಭ್ಯವಿದೆ ಕೋಡ್ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್.

ಮೂಲ: www.habr.com

Amazon Athena ಮತ್ತು Cube.js ಅನ್ನು ಬಳಸಿಕೊಂಡು Nginx ಲಾಗ್ ಅನಾಲಿಟಿಕ್ಸ್