Amazon Athena, Cube.js എന്നിവ ഉപയോഗിച്ച് Nginx ലോഗ് അനലിറ്റിക്‌സ്

സാധാരണഗതിയിൽ, വാണിജ്യ ഉൽപ്പന്നങ്ങളോ റെഡിമെയ്ഡ് ഓപ്പൺ സോഴ്‌സ് ഇതരമാർഗങ്ങളായ Prometheus + Grafana, Nginx-ന്റെ പ്രവർത്തനം നിരീക്ഷിക്കുന്നതിനും വിശകലനം ചെയ്യുന്നതിനും ഉപയോഗിക്കുന്നു. നിരീക്ഷണത്തിനോ തത്സമയ വിശകലനത്തിനോ ഇത് ഒരു നല്ല ഓപ്ഷനാണ്, എന്നാൽ ചരിത്രപരമായ വിശകലനത്തിന് വളരെ സൗകര്യപ്രദമല്ല. ഏതൊരു ജനപ്രിയ ഉറവിടത്തിലും, nginx ലോഗുകളിൽ നിന്നുള്ള ഡാറ്റയുടെ അളവ് അതിവേഗം വളരുകയാണ്, കൂടാതെ ഒരു വലിയ അളവിലുള്ള ഡാറ്റ വിശകലനം ചെയ്യുന്നതിന്, കൂടുതൽ പ്രത്യേകമായ എന്തെങ്കിലും ഉപയോഗിക്കുന്നത് യുക്തിസഹമാണ്.

നിങ്ങൾക്ക് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ ലേഖനത്തിൽ ഞാൻ നിങ്ങളോട് പറയും അഥീന ലോഗുകൾ വിശകലനം ചെയ്യാൻ, Nginx ഉദാഹരണമായി എടുത്ത്, ഓപ്പൺ സോഴ്‌സ് cube.js ഫ്രെയിംവർക്ക് ഉപയോഗിച്ച് ഈ ഡാറ്റയിൽ നിന്ന് ഒരു അനലിറ്റിക്കൽ ഡാഷ്‌ബോർഡ് എങ്ങനെ കൂട്ടിച്ചേർക്കാമെന്ന് ഞാൻ കാണിക്കും. പൂർണ്ണമായ പരിഹാര വാസ്തുവിദ്യ ഇതാ:

TL:DR;
പൂർത്തിയായ ഡാഷ്‌ബോർഡിലേക്കുള്ള ലിങ്ക്.

ഞങ്ങൾ ഉപയോഗിക്കുന്ന വിവരങ്ങൾ ശേഖരിക്കാൻ ഒഴുക്കുള്ള, പ്രോസസ്സിംഗിനായി - AWS Kinesis ഡാറ്റ ഫയർഹോസ് и 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 ഉപയോഗിക്കും. ലോഗുകൾ ഒരിടത്ത് സംഭരിക്കാനും വിശകലനം ചെയ്യാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു, കാരണം 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 ഫോർമാറ്റിലുള്ള ഡയറക്ടറികളായി വിഭജിക്കും. ഡാറ്റ വായിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകും. നിങ്ങൾക്ക് തീർച്ചയായും fluentd-ൽ നിന്ന് S3-ലേക്ക് നേരിട്ട് എഴുതാൻ കഴിയും, എന്നാൽ ഈ സാഹചര്യത്തിൽ നിങ്ങൾ JSON എഴുതേണ്ടിവരും, ഫയലുകളുടെ വലിയ വലിപ്പം കാരണം ഇത് കാര്യക്ഷമമല്ല. കൂടാതെ, PrestoDB അല്ലെങ്കിൽ Athena ഉപയോഗിക്കുമ്പോൾ, JSON ഏറ്റവും വേഗത കുറഞ്ഞ ഡാറ്റ ഫോർമാറ്റാണ്. അതിനാൽ Kinesis Firehose കൺസോൾ തുറക്കുക, "ഡെലിവറി സ്ട്രീം സൃഷ്‌ടിക്കുക" ക്ലിക്ക് ചെയ്യുക, "ഡെലിവറി" ഫീൽഡിൽ "direct PUT" തിരഞ്ഞെടുക്കുക:

അടുത്ത ടാബിൽ, "റെക്കോർഡ് ഫോർമാറ്റ് പരിവർത്തനം" - "പ്രാപ്തമാക്കി" തിരഞ്ഞെടുത്ത് റെക്കോർഡിംഗ് ഫോർമാറ്റായി "അപ്പാച്ചെ ORC" തിരഞ്ഞെടുക്കുക. ചില ഗവേഷണ പ്രകാരം ഓവൻ ഒമാലി, PrestoDB, Athena എന്നിവയ്‌ക്കുള്ള ഒപ്റ്റിമൽ ഫോർമാറ്റാണിത്. ഞങ്ങൾ മുകളിൽ സൃഷ്ടിച്ച പട്ടിക ഒരു സ്കീമയായി ഉപയോഗിക്കുന്നു. Kinesis-ൽ നിങ്ങൾക്ക് ഏത് S3 ലൊക്കേഷനും വ്യക്തമാക്കാനാകുമെന്നത് ശ്രദ്ധിക്കുക; പട്ടികയിൽ നിന്ന് സ്കീമ മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ. എന്നാൽ നിങ്ങൾ മറ്റൊരു S3 ലൊക്കേഷൻ വ്യക്തമാക്കുകയാണെങ്കിൽ, ഈ പട്ടികയിൽ നിന്ന് നിങ്ങൾക്ക് ഈ റെക്കോർഡുകൾ വായിക്കാൻ കഴിയില്ല.

സംഭരണത്തിനായി ഞങ്ങൾ S3 തിരഞ്ഞെടുക്കുകയും ഞങ്ങൾ മുമ്പ് സൃഷ്ടിച്ച ബക്കറ്റും തിരഞ്ഞെടുക്കുക. ഞാൻ കുറച്ച് കഴിഞ്ഞ് സംസാരിക്കുന്ന Aws Glue Crawler, ഒരു S3 ബക്കറ്റിൽ പ്രിഫിക്സുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയില്ല, അതിനാൽ ഇത് ശൂന്യമായി വിടേണ്ടത് പ്രധാനമാണ്.

നിങ്ങളുടെ ലോഡിനെ ആശ്രയിച്ച് ശേഷിക്കുന്ന ഓപ്ഷനുകൾ മാറ്റാവുന്നതാണ്; ഞാൻ സാധാരണയായി സ്ഥിരമായവയാണ് ഉപയോഗിക്കുന്നത്. S3 കംപ്രഷൻ ലഭ്യമല്ല, എന്നാൽ ORC സ്ഥിരസ്ഥിതിയായി നേറ്റീവ് കംപ്രഷൻ ഉപയോഗിക്കുന്നു.

ഒഴുക്കുള്ള

ലോഗുകൾ സംഭരിക്കുന്നതിനും സ്വീകരിക്കുന്നതിനും ഞങ്ങൾ ഇപ്പോൾ ക്രമീകരിച്ചിരിക്കുന്നു, ഞങ്ങൾ അയയ്ക്കുന്നത് ക്രമീകരിക്കേണ്ടതുണ്ട്. ഞങ്ങൾ ഉപയോഗിക്കും ഒഴുക്കുള്ള, കാരണം എനിക്ക് റൂബിയെ ഇഷ്ടമാണ്, എന്നാൽ നിങ്ങൾക്ക് Logstash ഉപയോഗിക്കാം അല്ലെങ്കിൽ നേരിട്ട് kinesis-ലേക്ക് ലോഗുകൾ അയയ്ക്കാം. 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-ലേക്ക് ലോഗുകൾ അയക്കുന്നത് ഉപയോഗിച്ച് കിനിസിസ് ഫയർഹോസ് പ്ലഗിൻ:

<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 ബക്കറ്റിലേക്ക് എഴുത്ത് ആക്സസ് നൽകാൻ മറക്കരുത്. Kinesis-ന് എന്തെങ്കിലും പാഴ്‌സ് ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ, അത് അതേ ബക്കറ്റിലേക്ക് പിശകുകൾ ചേർക്കും.

ഇപ്പോൾ നിങ്ങൾക്ക് അഥീനയിലെ ഡാറ്റ കാണാൻ കഴിയും. പിശകുകൾ നൽകിയ ഏറ്റവും പുതിയ അഭ്യർത്ഥനകൾ നമുക്ക് കണ്ടെത്താം:

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

ഓരോ അഭ്യർത്ഥനയ്ക്കും എല്ലാ രേഖകളും സ്കാൻ ചെയ്യുന്നു

ഇപ്പോൾ ഞങ്ങളുടെ ലോഗുകൾ ORC-യിലെ S3-ൽ പ്രോസസ്സ് ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്തു, കംപ്രസ്സുചെയ്‌ത് വിശകലനത്തിന് തയ്യാറാണ്. Kinesis Firehose അവയെ ഓരോ മണിക്കൂറിലും ഡയറക്ടറികളായി ക്രമീകരിച്ചു. എന്നിരുന്നാലും, ടേബിൾ പാർട്ടീഷൻ ചെയ്യാത്തിടത്തോളം, അപൂർവമായ ഒഴിവാക്കലുകളോടെ എല്ലാ അഭ്യർത്ഥനകളിലും അഥീന എല്ലാ സമയ ഡാറ്റയും ലോഡ് ചെയ്യും. രണ്ട് കാരണങ്ങളാൽ ഇത് ഒരു വലിയ പ്രശ്നമാണ്:

• ഡാറ്റയുടെ അളവ് നിരന്തരം വർദ്ധിച്ചുകൊണ്ടിരിക്കുന്നു, ചോദ്യങ്ങളുടെ വേഗത കുറയ്ക്കുന്നു;
• ഓരോ അഭ്യർത്ഥനയ്ക്കും കുറഞ്ഞത് 10 MB എന്ന തോതിൽ സ്‌കാൻ ചെയ്‌ത ഡാറ്റയുടെ വോളിയം അടിസ്ഥാനമാക്കിയാണ് അഥീന ബിൽ ചെയ്യുന്നത്.

ഇത് പരിഹരിക്കാൻ, ഞങ്ങൾ AWS Glue Crawler ഉപയോഗിക്കുന്നു, അത് S3-ലെ ഡാറ്റ ക്രോൾ ചെയ്യുകയും പാർട്ടീഷൻ വിവരങ്ങൾ ഗ്ലൂ മെറ്റാസ്റ്റോറിലേക്ക് എഴുതുകയും ചെയ്യും. അഥീനയെ അന്വേഷിക്കുമ്പോൾ പാർട്ടീഷനുകൾ ഒരു ഫിൽട്ടറായി ഉപയോഗിക്കാൻ ഇത് ഞങ്ങളെ അനുവദിക്കും, കൂടാതെ ഇത് അന്വേഷണത്തിൽ വ്യക്തമാക്കിയ ഡയറക്ടറികൾ മാത്രം സ്കാൻ ചെയ്യും.

Amazon Glue Crawler സജ്ജീകരിക്കുന്നു

ആമസോൺ ഗ്ലൂ ക്രാളർ S3 ബക്കറ്റിലെ എല്ലാ ഡാറ്റയും സ്കാൻ ചെയ്യുകയും പാർട്ടീഷനുകളുള്ള പട്ടികകൾ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. AWS ഗ്ലൂ കൺസോളിൽ നിന്ന് ഒരു ഗ്ലൂ ക്രാളർ സൃഷ്‌ടിച്ച് നിങ്ങൾ ഡാറ്റ സംഭരിക്കുന്ന സ്ഥലത്ത് ഒരു ബക്കറ്റ് ചേർക്കുക. നിരവധി ബക്കറ്റുകൾക്കായി നിങ്ങൾക്ക് ഒരു ക്രാളർ ഉപയോഗിക്കാം, ഈ സാഹചര്യത്തിൽ അത് ബക്കറ്റുകളുടെ പേരുകളുമായി പൊരുത്തപ്പെടുന്ന പേരുകൾ ഉപയോഗിച്ച് നിർദ്ദിഷ്ട ഡാറ്റാബേസിൽ പട്ടികകൾ സൃഷ്ടിക്കും. ഈ ഡാറ്റ പതിവായി ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ രീതിയിൽ Crawler-ന്റെ ലോഞ്ച് ഷെഡ്യൂൾ കോൺഫിഗർ ചെയ്യുന്നത് ഉറപ്പാക്കുക. എല്ലാ ടേബിളുകൾക്കും ഞങ്ങൾ ഒരു ക്രാളർ ഉപയോഗിക്കുന്നു, അത് ഓരോ മണിക്കൂറിലും പ്രവർത്തിക്കുന്നു.

വിഭജിച്ച പട്ടികകൾ

ക്രാളറിന്റെ ആദ്യ വിക്ഷേപണത്തിന് ശേഷം, സ്കാൻ ചെയ്ത ഓരോ ബക്കറ്റിനും വേണ്ടിയുള്ള പട്ടികകൾ ക്രമീകരണങ്ങളിൽ വ്യക്തമാക്കിയ ഡാറ്റാബേസിൽ ദൃശ്യമാകും. അഥീന കൺസോൾ തുറന്ന് 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