Amazon Athena மற்றும் Cube.js ஐப் பயன்படுத்தி 🥇Nginx பதிவு பகுப்பாய்வு

பொதுவாக, வணிக தயாரிப்புகள் அல்லது ப்ரோமிதியஸ் + கிராஃபானா போன்ற ஆயத்த திறந்த மூல மாற்றுகள் Nginx இன் செயல்பாட்டைக் கண்காணிக்கவும் பகுப்பாய்வு செய்யவும் பயன்படுத்தப்படுகின்றன. கண்காணிப்பு அல்லது நிகழ்நேர பகுப்பாய்வுக்கு இது ஒரு நல்ல வழி, ஆனால் வரலாற்று ஆய்வுக்கு மிகவும் வசதியானது அல்ல. எந்தவொரு பிரபலமான ஆதாரத்திலும், nginx பதிவுகளிலிருந்து தரவின் அளவு வேகமாக வளர்ந்து வருகிறது, மேலும் அதிக அளவிலான தரவை பகுப்பாய்வு செய்ய, மிகவும் சிறப்பு வாய்ந்த ஒன்றைப் பயன்படுத்துவது தர்க்கரீதியானது.

இந்த கட்டுரையில் நீங்கள் எவ்வாறு பயன்படுத்தலாம் என்பதை நான் உங்களுக்கு கூறுவேன் அதீனா பதிவுகளை பகுப்பாய்வு செய்ய, Nginx ஐ எடுத்துக்காட்டி, திறந்த மூல cube.js கட்டமைப்பைப் பயன்படுத்தி இந்தத் தரவிலிருந்து ஒரு பகுப்பாய்வு டாஷ்போர்டை எவ்வாறு இணைப்பது என்பதைக் காண்பிப்பேன். முழுமையான தீர்வு கட்டமைப்பு இங்கே:

TL:DR;
முடிக்கப்பட்ட டாஷ்போர்டுக்கான இணைப்பு.

நாங்கள் பயன்படுத்தும் தகவலை சேகரிக்க சரளமாக, செயலாக்கத்திற்கு - AWS கினிசிஸ் டேட்டா ஃபயர்ஹோஸ் и AWS பசை, சேமிப்பிற்காக - AWS S3. இந்த மூட்டையைப் பயன்படுத்தி, நீங்கள் nginx பதிவுகள் மட்டுமல்ல, பிற நிகழ்வுகள் மற்றும் பிற சேவைகளின் பதிவுகளையும் சேமிக்க முடியும். உங்கள் ஸ்டேக்கிற்கு ஒத்த சில பகுதிகளை நீங்கள் மாற்றலாம், எடுத்துக்காட்டாக, நீங்கள் nginx இலிருந்து நேரடியாக kinesis க்கு பதிவுகளை எழுதலாம், 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 ஐப் பயன்படுத்துவோம். Athena நேரடியாக 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 தேர்ந்தெடுக்கப்பட்ட வடிவத்தில் Nginx இலிருந்து S3 க்கு பெறப்பட்ட தரவை எழுதி, அதை YYYY/MM/DD/HH வடிவத்தில் கோப்பகங்களாகப் பிரிக்கும். தரவைப் படிக்கும்போது இது கைக்கு வரும். நீங்கள் நிச்சயமாக, சரளமாக இருந்து S3 க்கு நேரடியாக எழுதலாம், ஆனால் இந்த விஷயத்தில் நீங்கள் JSON ஐ எழுத வேண்டும், மேலும் கோப்புகளின் பெரிய அளவு காரணமாக இது திறனற்றது. கூடுதலாக, PrestoDB அல்லது Athena ஐப் பயன்படுத்தும் போது, JSON மெதுவான தரவு வடிவமாகும். எனவே Kinesis Firehose கன்சோலைத் திறந்து, "டெலிவரி ஸ்ட்ரீமை உருவாக்கு" என்பதைக் கிளிக் செய்து, "டெலிவரி" புலத்தில் "நேரடி PUT" என்பதைத் தேர்ந்தெடுக்கவும்:

அடுத்த தாவலில், "பதிவு வடிவமைப்பு மாற்றம்" - "இயக்கப்பட்டது" என்பதைத் தேர்ந்தெடுத்து, பதிவு வடிவமாக "அப்பாச்சி ORC" என்பதைத் தேர்ந்தெடுக்கவும். சில ஆய்வுகளின்படி ஓவன் ஓ'மல்லி, இது PrestoDB மற்றும் Athenaக்கான உகந்த வடிவமாகும். மேலே நாம் உருவாக்கிய அட்டவணையை ஒரு திட்டமாகப் பயன்படுத்துகிறோம். கினிசிஸில் எந்த S3 இருப்பிடத்தையும் நீங்கள் குறிப்பிடலாம் என்பதை நினைவில் கொள்ளவும்; அட்டவணையில் இருந்து ஸ்கீமா மட்டுமே பயன்படுத்தப்படுகிறது. ஆனால் நீங்கள் வேறு S3 இருப்பிடத்தைக் குறிப்பிட்டால், இந்த அட்டவணையில் இருந்து இந்தப் பதிவுகளைப் படிக்க முடியாது.

சேமிப்பிற்காக S3 மற்றும் நாங்கள் முன்பு உருவாக்கிய வாளியைத் தேர்ந்தெடுக்கிறோம். Aws Glue Crawler, நான் சிறிது நேரம் கழித்து பேசுவேன், S3 வாளியில் முன்னொட்டுகளுடன் வேலை செய்ய முடியாது, எனவே அதை காலியாக விடுவது முக்கியம்.

உங்கள் சுமையைப் பொறுத்து மீதமுள்ள விருப்பங்களை மாற்றலாம்; நான் வழக்கமாக இயல்புநிலையை பயன்படுத்துகிறேன். S3 சுருக்கம் இல்லை என்பதை நினைவில் கொள்ளவும், ஆனால் ORC இயல்பாகவே சொந்த சுருக்கத்தைப் பயன்படுத்துகிறது.

சரளமாக

இப்போது பதிவுகளை சேமிப்பதையும் பெறுவதையும் உள்ளமைத்துள்ளோம், அனுப்புவதை உள்ளமைக்க வேண்டும். பயன்படுத்துவோம் சரளமாக, ஏனென்றால் நான் ரூபியை விரும்புகிறேன், ஆனால் நீங்கள் Logstash ஐப் பயன்படுத்தலாம் அல்லது நேரடியாக கினேசிஸுக்கு பதிவுகளை அனுப்பலாம். 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 ஐ ஒரு Docker கண்டெய்னரில் இயக்குகிறோம், இதில் Docker 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>

அதீனா

நீங்கள் எல்லாவற்றையும் சரியாக உள்ளமைத்திருந்தால், சிறிது நேரத்திற்குப் பிறகு (இயல்புநிலையாக, Kinesis பதிவுகள் ஒவ்வொரு 10 நிமிடங்களுக்கும் ஒரு முறை தரவுகளைப் பெற்றன) நீங்கள் S3 இல் பதிவு கோப்புகளைப் பார்க்க வேண்டும். Kinesis Firehose இன் "கண்காணிப்பு" மெனுவில் S3 இல் எவ்வளவு தரவு பதிவு செய்யப்பட்டுள்ளது, அதே போல் பிழைகள் உள்ளன. Kinesis பாத்திரத்திற்கு S3 பக்கெட்டுக்கான எழுத்து அணுகலை வழங்க மறக்காதீர்கள். கினேசிஸால் எதையாவது அலச முடியவில்லை என்றால், அது அதே வாளியில் பிழைகளைச் சேர்க்கும்.

இப்போது நீங்கள் அதீனாவில் தரவைப் பார்க்கலாம். பிழைகளை வழங்கிய சமீபத்திய கோரிக்கைகளைக் கண்டறியவும்:

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

ஒவ்வொரு கோரிக்கைக்கும் அனைத்து பதிவுகளையும் ஸ்கேன் செய்கிறது

இப்போது எங்கள் பதிவுகள் ORC இல் S3 இல் செயலாக்கப்பட்டு சேமிக்கப்பட்டு, சுருக்கப்பட்டு பகுப்பாய்வுக்குத் தயாராக உள்ளன. Kinesis Firehose அவற்றை ஒவ்வொரு மணிநேரத்திற்கும் அடைவுகளாக ஒழுங்கமைத்தது. இருப்பினும், அட்டவணை பிரிக்கப்படாத வரை, அரிதான விதிவிலக்குகளுடன், ஒவ்வொரு கோரிக்கையிலும் அதீனா அனைத்து நேர தரவையும் ஏற்றும். இரண்டு காரணங்களுக்காக இது ஒரு பெரிய பிரச்சனை:

தரவுகளின் அளவு தொடர்ந்து வளர்ந்து வருகிறது, வினவல்களை மெதுவாக்குகிறது;
ஒரு கோரிக்கைக்கு குறைந்தபட்சம் 10 எம்பியுடன் ஸ்கேன் செய்யப்பட்ட டேட்டாவின் அளவின் அடிப்படையில் அதீனா கட்டணம் வசூலிக்கப்படுகிறது.

இதை சரிசெய்ய, நாங்கள் AWS Glue Crawler ஐப் பயன்படுத்துகிறோம், இது S3 இல் தரவை வலைவலம் செய்து, பகிர்வுத் தகவலை Glue Metastore இல் எழுதும். இது அதீனாவை வினவும்போது பகிர்வுகளை வடிகட்டியாகப் பயன்படுத்த அனுமதிக்கும், மேலும் இது வினவலில் குறிப்பிடப்பட்டுள்ள கோப்பகங்களை மட்டுமே ஸ்கேன் செய்யும்.

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 ஐ உருவாக்க மற்றும் தரவுத்தள வினவலை இயக்க ஜாவாஸ்கிரிப்ட்டில் எழுதப்பட்டது. தரவுத் திட்டத்தில் பகிர்வு வடிகட்டியை எவ்வாறு பயன்படுத்துவது என்பதை மட்டும் குறிப்பிட வேண்டும்.

புதிய 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

Amazon Athena மற்றும் Cube.js ஐப் பயன்படுத்தி Nginx பதிவு பகுப்பாய்வு