ਐਮਾਜ਼ਾਨ ਐਥੀਨਾ ਅਤੇ Cube.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Nginx ਲੌਗ ਵਿਸ਼ਲੇਸ਼ਣ

ਆਮ ਤੌਰ 'ਤੇ, ਵਪਾਰਕ ਉਤਪਾਦ ਜਾਂ ਤਿਆਰ ਕੀਤੇ ਓਪਨ-ਸੋਰਸ ਵਿਕਲਪ, ਜਿਵੇਂ ਕਿ ਪ੍ਰੋਮੀਥੀਅਸ + ਗ੍ਰਾਫਾਨਾ, ਦੀ ਵਰਤੋਂ Nginx ਦੇ ਸੰਚਾਲਨ ਦੀ ਨਿਗਰਾਨੀ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਨਿਗਰਾਨੀ ਜਾਂ ਰੀਅਲ-ਟਾਈਮ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਇੱਕ ਵਧੀਆ ਵਿਕਲਪ ਹੈ, ਪਰ ਇਤਿਹਾਸਕ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ। ਕਿਸੇ ਵੀ ਪ੍ਰਸਿੱਧ ਸਰੋਤ 'ਤੇ, nginx ਲੌਗਸ ਤੋਂ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਤੇਜ਼ੀ ਨਾਲ ਵਧ ਰਹੀ ਹੈ, ਅਤੇ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਡੇਟਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ, ਕਿਸੇ ਹੋਰ ਵਿਸ਼ੇਸ਼ ਚੀਜ਼ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਤਰਕਪੂਰਨ ਹੈ।

ਇਸ ਲੇਖ ਵਿਚ ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗਾ ਕਿ ਤੁਸੀਂ ਕਿਵੇਂ ਵਰਤ ਸਕਦੇ ਹੋ ਅਥੀਨਾ ਲਾਗਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ, Nginx ਨੂੰ ਇੱਕ ਉਦਾਹਰਨ ਵਜੋਂ ਲੈ ਕੇ, ਅਤੇ ਮੈਂ ਦਿਖਾਵਾਂਗਾ ਕਿ ਓਪਨ-ਸੋਰਸ cube.js ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਸ ਡੇਟਾ ਤੋਂ ਇੱਕ ਵਿਸ਼ਲੇਸ਼ਣਾਤਮਕ ਡੈਸ਼ਬੋਰਡ ਨੂੰ ਕਿਵੇਂ ਇਕੱਠਾ ਕਰਨਾ ਹੈ। ਇੱਥੇ ਪੂਰਾ ਹੱਲ ਆਰਕੀਟੈਕਚਰ ਹੈ:

TL:DR;
ਮੁਕੰਮਲ ਹੋਏ ਡੈਸ਼ਬੋਰਡ ਨਾਲ ਲਿੰਕ ਕਰੋ.

ਜਾਣਕਾਰੀ ਇਕੱਠੀ ਕਰਨ ਲਈ ਜੋ ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ ਪ੍ਰਵਾਹ, ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ - AWS Kinesis ਡਾਟਾ ਫਾਇਰਹੋਜ਼ и 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 ਵਿੱਚ ਇੱਕ ਸਾਫ਼ ਬਾਲਟੀ ਦੀ ਲੋੜ ਹੈ, ਜਿਸ ਵਿੱਚ ਹੋਰ ਕੁਝ ਵੀ ਸਟੋਰ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ. ਇਹ ਪਹਿਲਾਂ ਤੋਂ ਵਿਚਾਰਨ ਯੋਗ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਸ ਖੇਤਰ ਵਿੱਚ ਆਪਣੀ ਬਾਲਟੀ ਬਣਾ ਰਹੇ ਹੋਵੋਗੇ, ਕਿਉਂਕਿ ਐਥੀਨਾ ਸਾਰੇ ਖੇਤਰਾਂ ਵਿੱਚ ਉਪਲਬਧ ਨਹੀਂ ਹੈ।

ਅਥੀਨਾ ਕੰਸੋਲ ਵਿੱਚ ਇੱਕ ਸਰਕਟ ਬਣਾਉਣਾ

ਆਉ ਲਾਗਾਂ ਲਈ ਐਥੀਨਾ ਵਿੱਚ ਇੱਕ ਸਾਰਣੀ ਬਣਾਈਏ। ਜੇਕਰ ਤੁਸੀਂ Kinesis Firehose ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਹੇ ਹੋ ਤਾਂ ਇਹ ਲਿਖਣ ਅਤੇ ਪੜ੍ਹਨ ਦੋਵਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। ਐਥੀਨਾ ਕੰਸੋਲ ਖੋਲ੍ਹੋ ਅਤੇ ਇੱਕ ਸਾਰਣੀ ਬਣਾਓ:

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 ਸਟ੍ਰੀਮ ਬਣਾਉਣਾ

Kinesis Firehose ਚੁਣੇ ਗਏ ਫਾਰਮੈਟ ਵਿੱਚ Nginx ਤੋਂ S3 ਤੱਕ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਲਿਖੇਗਾ, ਇਸਨੂੰ YYYY/MM/DD/HH ਫਾਰਮੈਟ ਵਿੱਚ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ। ਡਾਟਾ ਪੜ੍ਹਣ ਵੇਲੇ ਇਹ ਕੰਮ ਆਵੇਗਾ। ਤੁਸੀਂ, ਬੇਸ਼ਕ, fluentd ਤੋਂ S3 ਨੂੰ ਸਿੱਧਾ ਲਿਖ ਸਕਦੇ ਹੋ, ਪਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਤੁਹਾਨੂੰ JSON ਲਿਖਣਾ ਪਏਗਾ, ਅਤੇ ਇਹ ਫਾਈਲਾਂ ਦੇ ਵੱਡੇ ਆਕਾਰ ਦੇ ਕਾਰਨ ਅਯੋਗ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, PrestoDB ਜਾਂ Athena ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, JSON ਸਭ ਤੋਂ ਹੌਲੀ ਡਾਟਾ ਫਾਰਮੈਟ ਹੈ। ਇਸ ਲਈ Kinesis Firehose ਕੰਸੋਲ ਖੋਲ੍ਹੋ, "ਡਿਲੀਵਰੀ ਸਟ੍ਰੀਮ ਬਣਾਓ" 'ਤੇ ਕਲਿੱਕ ਕਰੋ, "ਡਿਲੀਵਰੀ" ਖੇਤਰ ਵਿੱਚ "ਸਿੱਧਾ ਪੁਟ" ਚੁਣੋ:

ਅਗਲੀ ਟੈਬ ਵਿੱਚ, “ਰਿਕਾਰਡ ਫਾਰਮੈਟ ਪਰਿਵਰਤਨ” - “ਯੋਗ” ਚੁਣੋ ਅਤੇ ਰਿਕਾਰਡਿੰਗ ਫਾਰਮੈਟ ਵਜੋਂ “ਅਪਾਚੇ ORC” ਚੁਣੋ। ਕੁਝ ਖੋਜ ਦੇ ਅਨੁਸਾਰ ਓਵੇਨ ਓ'ਮੈਲੀ, ਇਹ PrestoDB ਅਤੇ Athena ਲਈ ਅਨੁਕੂਲ ਫਾਰਮੈਟ ਹੈ। ਅਸੀਂ ਉੱਪਰ ਬਣਾਈ ਗਈ ਸਾਰਣੀ ਨੂੰ ਇੱਕ ਸਕੀਮਾ ਵਜੋਂ ਵਰਤਦੇ ਹਾਂ। ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਤੁਸੀਂ ਕਾਇਨੇਸਿਸ ਵਿੱਚ ਕੋਈ ਵੀ S3 ਸਥਾਨ ਨਿਰਧਾਰਿਤ ਕਰ ਸਕਦੇ ਹੋ; ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵੱਖਰਾ S3 ਸਥਾਨ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਸਾਰਣੀ ਤੋਂ ਇਹਨਾਂ ਰਿਕਾਰਡਾਂ ਨੂੰ ਪੜ੍ਹਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੋਗੇ।

ਅਸੀਂ ਸਟੋਰੇਜ ਅਤੇ ਉਸ ਬਾਲਟੀ ਲਈ S3 ਚੁਣਦੇ ਹਾਂ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਬਣਾਈ ਸੀ। Aws ਗਲੂ ਕ੍ਰਾਲਰ, ਜਿਸ ਬਾਰੇ ਮੈਂ ਥੋੜ੍ਹੀ ਦੇਰ ਬਾਅਦ ਗੱਲ ਕਰਾਂਗਾ, ਇੱਕ S3 ਬਾਲਟੀ ਵਿੱਚ ਅਗੇਤਰਾਂ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦਾ, ਇਸਲਈ ਇਸਨੂੰ ਖਾਲੀ ਛੱਡਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਬਾਕੀ ਵਿਕਲਪਾਂ ਨੂੰ ਤੁਹਾਡੇ ਲੋਡ ਦੇ ਅਧਾਰ ਤੇ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ; ਮੈਂ ਆਮ ਤੌਰ 'ਤੇ ਡਿਫੌਲਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ। ਨੋਟ ਕਰੋ ਕਿ 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>

ਅਤੇ ਵਰਤ ਕੇ Kinesis ਨੂੰ ਲਾਗ ਭੇਜਣ kinesis firehose ਪਲੱਗਇਨ:

<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 ਵਿੱਚ ਲੌਗ ਫਾਈਲਾਂ ਦੇਖਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। Kinesis Firehose ਦੇ "ਨਿਗਰਾਨੀ" ਮੀਨੂ ਵਿੱਚ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ S3 ਵਿੱਚ ਕਿੰਨਾ ਡਾਟਾ ਰਿਕਾਰਡ ਕੀਤਾ ਗਿਆ ਹੈ, ਨਾਲ ਹੀ ਗਲਤੀਆਂ ਵੀ। Kinesis ਰੋਲ ਲਈ S3 ਬਾਲਟੀ ਨੂੰ ਲਿਖਣ ਦੀ ਪਹੁੰਚ ਦੇਣਾ ਨਾ ਭੁੱਲੋ। ਜੇਕਰ Kinesis ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਪਾਰਸ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਸੇ ਬਾਲਟੀ ਵਿੱਚ ਤਰੁੱਟੀਆਂ ਨੂੰ ਜੋੜ ਦੇਵੇਗਾ।

ਹੁਣ ਤੁਸੀਂ ਐਥੀਨਾ ਵਿੱਚ ਡੇਟਾ ਦੇਖ ਸਕਦੇ ਹੋ। ਆਉ ਉਹਨਾਂ ਨਵੀਨਤਮ ਬੇਨਤੀਆਂ ਨੂੰ ਲੱਭੀਏ ਜਿਹਨਾਂ ਲਈ ਅਸੀਂ ਗਲਤੀਆਂ ਵਾਪਸ ਕੀਤੀਆਂ ਹਨ:

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

ਹਰੇਕ ਬੇਨਤੀ ਲਈ ਸਾਰੇ ਰਿਕਾਰਡਾਂ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਹੁਣ ਸਾਡੇ ਲੌਗਸ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ORC ਵਿੱਚ S3 ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਸੰਕੁਚਿਤ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਤਿਆਰ ਹੈ। Kinesis Firehose ਨੇ ਉਹਨਾਂ ਨੂੰ ਹਰ ਘੰਟੇ ਲਈ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਸੰਗਠਿਤ ਕੀਤਾ. ਹਾਲਾਂਕਿ, ਜਿੰਨਾ ਚਿਰ ਸਾਰਣੀ ਨੂੰ ਵੰਡਿਆ ਨਹੀਂ ਜਾਂਦਾ, ਅਥੀਨਾ ਹਰ ਬੇਨਤੀ 'ਤੇ, ਦੁਰਲੱਭ ਅਪਵਾਦਾਂ ਦੇ ਨਾਲ ਆਲ-ਟਾਈਮ ਡੇਟਾ ਲੋਡ ਕਰੇਗੀ। ਇਹ ਦੋ ਕਾਰਨਾਂ ਕਰਕੇ ਇੱਕ ਵੱਡੀ ਸਮੱਸਿਆ ਹੈ:

• ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਲਗਾਤਾਰ ਵਧ ਰਹੀ ਹੈ, ਸਵਾਲਾਂ ਨੂੰ ਹੌਲੀ ਕਰ ਰਿਹਾ ਹੈ;
• ਐਥੀਨਾ ਨੂੰ ਸਕੈਨ ਕੀਤੇ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਦੇ ਆਧਾਰ 'ਤੇ ਬਿਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪ੍ਰਤੀ ਬੇਨਤੀ ਘੱਟੋ-ਘੱਟ 10 MB ਦੇ ਨਾਲ।

ਇਸ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ, ਅਸੀਂ AWS ਗਲੂ ਕ੍ਰਾਲਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਜੋ S3 ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਕ੍ਰੌਲ ਕਰੇਗਾ ਅਤੇ ਗਲੂ ਮੇਟਾਸਟੋਰ ਵਿੱਚ ਭਾਗ ਜਾਣਕਾਰੀ ਲਿਖ ਦੇਵੇਗਾ। ਇਹ ਸਾਨੂੰ ਏਥੀਨਾ ਤੋਂ ਪੁੱਛਗਿੱਛ ਕਰਨ ਵੇਲੇ ਭਾਗਾਂ ਨੂੰ ਫਿਲਟਰ ਵਜੋਂ ਵਰਤਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ, ਅਤੇ ਇਹ ਸਿਰਫ਼ ਪੁੱਛਗਿੱਛ ਵਿੱਚ ਦਿੱਤੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਨੂੰ ਸਕੈਨ ਕਰੇਗਾ।

ਐਮਾਜ਼ਾਨ ਗਲੂ ਕ੍ਰਾਲਰ ਸੈਟ ਅਪ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

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 ਸਟੈਕ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਇਸ ਲਈ ਤੈਨਾਤੀ ਲਈ Lambda ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਲਾਜ਼ੀਕਲ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ 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