ലോകിയിൽ നിന്ന് ലോഗുകൾ ശേഖരിക്കുന്നു

Badoo-ൽ ഞങ്ങൾ പുതിയ സാങ്കേതികവിദ്യകൾ നിരന്തരം നിരീക്ഷിക്കുകയും അവ ഞങ്ങളുടെ സിസ്റ്റത്തിൽ ഉപയോഗിക്കണമോ വേണ്ടയോ എന്ന് വിലയിരുത്തുകയും ചെയ്യുന്നു. ഈ പഠനങ്ങളിൽ ഒന്ന് സമൂഹവുമായി പങ്കിടാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ലോഗ് അഗ്രഗേഷൻ സിസ്റ്റമായ ലോകിക്കാണ് ഇത് സമർപ്പിച്ചിരിക്കുന്നത്.

ലോഗുകൾ സംഭരിക്കുന്നതിനും കാണുന്നതിനുമുള്ള ഒരു പരിഹാരമാണ് ലോകി, അവ വിശകലനം ചെയ്യുന്നതിനും പ്രോമിത്യൂസിന് ഡാറ്റ അയയ്‌ക്കുന്നതിനുമുള്ള ഒരു വഴക്കമുള്ള സംവിധാനവും ഈ സ്റ്റാക്ക് നൽകുന്നു. മെയ് മാസത്തിൽ, മറ്റൊരു അപ്‌ഡേറ്റ് പുറത്തിറങ്ങി, അത് സ്രഷ്‌ടാക്കൾ സജീവമായി പ്രമോട്ട് ചെയ്യുന്നു. ലോകിക്ക് എന്തുചെയ്യാൻ കഴിയും, അത് എന്ത് അവസരങ്ങൾ നൽകുന്നു, ഞങ്ങൾ ഇപ്പോൾ ഉപയോഗിക്കുന്ന സ്റ്റാക്കായ ELK ന് പകരമായി അതിന് എത്രത്തോളം പ്രവർത്തിക്കാനാകും എന്നതിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടായിരുന്നു.

എന്താണ് ലോകി

ഒരു സമ്പൂർണ്ണ ലോഗിംഗ് സിസ്റ്റത്തിനായുള്ള ഒരു കൂട്ടം ഘടകങ്ങളാണ് ഗ്രാഫാന ലോക്കി. സമാനമായ മറ്റ് സിസ്റ്റങ്ങളിൽ നിന്ന് വ്യത്യസ്തമായി, ലോഗ് മെറ്റാഡാറ്റ - ലേബലുകൾ (പ്രോമിത്യൂസിൽ ഉള്ളത് പോലെ) മാത്രം സൂചികയിലാക്കുകയെന്ന ആശയത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ലോക്കി.

ഹോം പേജ്, സാമൂഹികം

ലോകി ഉപയോഗിച്ച് നിങ്ങൾക്ക് എന്തുചെയ്യാൻ കഴിയും എന്നതിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, "മെറ്റാഡാറ്റ മാത്രം സൂചികയിലാക്കുകയെന്ന ആശയം" എന്താണ് അർത്ഥമാക്കുന്നതെന്ന് വ്യക്തമാക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. nginx ലോഗിൽ നിന്നുള്ള ഒരു വരിയുടെ ഉദാഹരണം ഉപയോഗിച്ച്, Elasticsearch പോലെയുള്ള പരമ്പരാഗത പരിഹാരങ്ങളിലെ ലോകി സമീപനവും ഇൻഡെക്സിംഗ് സമീപനവും താരതമ്യം ചെയ്യാം:

172.19.0.4 - - [01/Jun/2020:12:05:03 +0000] "GET /purchase?user_id=75146478&item_id=34234 HTTP/1.1" 500 8102 "-" "Stub_Bot/3.0" "0.001"

പരമ്പരാഗത സിസ്റ്റങ്ങൾ, നിരവധി തനതായ user_id, item_id മൂല്യങ്ങളുള്ള ഫീൽഡുകൾ ഉൾപ്പെടെ മുഴുവൻ വരിയും പാഴ്‌സ് ചെയ്യുന്നു, കൂടാതെ എല്ലാം വലിയ സൂചികകളിൽ സംഭരിക്കുന്നു. മിക്കവാറും എല്ലാ ഡാറ്റയും സൂചികയിലായതിനാൽ നിങ്ങൾക്ക് സങ്കീർണ്ണമായ അന്വേഷണങ്ങൾ വേഗത്തിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയും എന്നതാണ് ഈ സമീപനത്തിന്റെ പ്രയോജനം. എന്നാൽ നിങ്ങൾ ഇതിന് പണം നൽകണം, ഇൻഡെക്സ് വലുതായി മാറുന്നു, അത് മെമ്മറി ആവശ്യകതകളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു. തൽഫലമായി, ലോഗുകളുടെ ഫുൾ-ടെക്സ്റ്റ് സൂചിക, ലോഗുകളുമായി തന്നെ വലുപ്പത്തിൽ താരതമ്യപ്പെടുത്താവുന്നതാണ്. അതിലൂടെ വേഗത്തിൽ തിരയുന്നതിന്, സൂചിക മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യണം. കൂടുതൽ ലോഗുകൾ, സൂചിക അതിവേഗം വർദ്ധിക്കുകയും അത് കൂടുതൽ മെമ്മറി ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

ലോക്കി സമീപനത്തിന് ആവശ്യമായ ഡാറ്റ മാത്രം സ്‌ട്രിംഗിൽ നിന്ന് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യേണ്ടതുണ്ട്, അവയുടെ മൂല്യങ്ങളുടെ എണ്ണം ചെറുതാണ്. ഇതുവഴി നമുക്ക് ഒരു ചെറിയ സൂചിക ലഭിക്കും, കൂടാതെ സമയവും സൂചികയിലാക്കിയ ഫീൽഡുകളും ഉപയോഗിച്ച് ഡാറ്റ ഫിൽട്ടർ ചെയ്‌ത് തിരയാനും തുടർന്ന് സാധാരണ എക്‌സ്‌പ്രഷനുകളോ സബ്‌സ്‌ട്രിംഗ് തിരയലുകളോ ഉപയോഗിച്ച് ബാക്കിയുള്ളവ സ്‌കാൻ ചെയ്‌ത് തിരയാനും കഴിയും. ഈ പ്രക്രിയ ഏറ്റവും വേഗതയേറിയതായി തോന്നുന്നില്ല, പക്ഷേ ലോക്കി അഭ്യർത്ഥനയെ പല ഭാഗങ്ങളായി വിഭജിക്കുകയും സമാന്തരമായി അവ നടപ്പിലാക്കുകയും ഒരു ചെറിയ സമയത്തിനുള്ളിൽ വലിയ അളവിലുള്ള ഡാറ്റ പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു. അവയിലെ ഷാർഡുകളുടെയും സമാന്തര അഭ്യർത്ഥനകളുടെയും എണ്ണം ക്രമീകരിക്കാവുന്നതാണ്; അതിനാൽ, ഓരോ യൂണിറ്റ് സമയത്തിനും പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന ഡാറ്റയുടെ അളവ് നൽകിയിരിക്കുന്ന വിഭവങ്ങളുടെ അളവിനെ ആശ്രയിച്ചിരിക്കുന്നു.

ഒരു വലിയ ഫാസ്റ്റ് ഇൻഡക്സും ഒരു ചെറിയ സമാന്തര ബ്രൂട്ട്-ഫോഴ്സ് ഇൻഡക്സും തമ്മിലുള്ള ഈ വ്യാപാരം സിസ്റ്റത്തിന്റെ വില നിയന്ത്രിക്കാൻ ലോകിയെ അനുവദിക്കുന്നു. നിങ്ങളുടെ ആവശ്യങ്ങൾക്കനുസരിച്ച് ഇത് അയവായി ക്രമീകരിക്കാനും വികസിപ്പിക്കാനും കഴിയും.

ലോക്കി സ്റ്റാക്കിൽ മൂന്ന് ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു: പ്രോംടെയിൽ, ലോക്കി, ഗ്രാഫാന. പ്രോംടെയിൽ ലോഗുകൾ ശേഖരിക്കുകയും അവ പ്രോസസ്സ് ചെയ്യുകയും ലോകിയിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു. ലോകി അവരെ സൂക്ഷിക്കുന്നു. ഗ്രാഫാനയ്ക്ക് ലോകിയിൽ നിന്ന് ഡാറ്റ അഭ്യർത്ഥിക്കാനും അത് കാണിക്കാനും കഴിയും. പൊതുവേ, ലോഗുകൾ സംഭരിക്കുന്നതിനും അവയിലൂടെ തിരയുന്നതിനും മാത്രമല്ല ലോകി ഉപയോഗിക്കാൻ കഴിയും. പ്രോമിത്യൂസ് വഴി ഉപയോഗിച്ച് ഇൻകമിംഗ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിനും വിശകലനം ചെയ്യുന്നതിനും മുഴുവൻ സ്റ്റാക്കും മികച്ച അവസരങ്ങൾ നൽകുന്നു.
ഇൻസ്റ്റലേഷൻ പ്രക്രിയയുടെ ഒരു വിവരണം കണ്ടെത്താം ഇവിടെ.

ലോഗ് തിരയൽ

ഗ്രാഫാന - എക്സ്പ്ലോറർ എന്ന പ്രത്യേക ഇന്റർഫേസിൽ നിങ്ങൾക്ക് ലോഗുകൾ തിരയാൻ കഴിയും. അന്വേഷണങ്ങൾ LogQL ഭാഷയാണ് ഉപയോഗിക്കുന്നത്, ഇത് Prometheus ഉപയോഗിക്കുന്ന PromQL-ന് സമാനമാണ്. തത്വത്തിൽ, ഇത് ഒരു വിതരണം ചെയ്ത grep ആയി കണക്കാക്കാം.

തിരയൽ ഇന്റർഫേസ് ഇതുപോലെ കാണപ്പെടുന്നു:

ചോദ്യം തന്നെ രണ്ട് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു: സെലക്ടറും ഫിൽട്ടറും. ലോഗുകളിലേക്ക് അസൈൻ ചെയ്‌തിരിക്കുന്ന ഇൻഡെക്‌സ് ചെയ്‌ത മെറ്റാഡാറ്റ (ലേബലുകൾ) പ്രകാരമുള്ള തിരയലാണ് സെലക്ടർ, കൂടാതെ സെലക്ടർ നിർവചിച്ച റെക്കോർഡുകൾ ഫിൽട്ടർ ചെയ്യുന്ന ഒരു തിരയൽ സ്‌ട്രിംഗോ റീജക്‌സ്‌പിയോ ആണ് ഫിൽട്ടർ. നൽകിയിരിക്കുന്ന ഉദാഹരണത്തിൽ: ചുരുണ്ട ബ്രാക്കറ്റുകളിൽ - സെലക്ടർ, ശേഷമുള്ള എല്ലാം - ഫിൽട്ടർ.

{image_name="nginx.promtail.test"} |= "index"

ലോകി പ്രവർത്തിക്കുന്ന രീതി കാരണം, ഒരു സെലക്ടർ ഇല്ലാതെ നിങ്ങൾക്ക് അഭ്യർത്ഥനകൾ നടത്താൻ കഴിയില്ല, എന്നാൽ ലേബലുകൾ ഏകപക്ഷീയമായി ജനറിക് ആക്കാം.

ചുരുണ്ട ബ്രേസുകളിലെ മൂല്യത്തിന്റെ പ്രധാന മൂല്യമാണ് സെലക്ടർ. =, != ഓപ്പറേറ്റർമാർ അല്ലെങ്കിൽ റെഗുലർ എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് സെലക്ടറുകളെ സംയോജിപ്പിച്ച് വ്യത്യസ്ത തിരയൽ വ്യവസ്ഥകൾ വ്യക്തമാക്കാം:

{instance=~"kafka-[23]",name!="kafka-dev"} 
// Найдёт логи с лейблом instance, имеющие значение kafka-2, kafka-3, и исключит dev 

സെലക്ടർക്ക് ലഭിച്ച എല്ലാ ഡാറ്റയും ഫിൽട്ടർ ചെയ്യുന്ന ഒരു വാചകം അല്ലെങ്കിൽ regexp ആണ് ഫിൽട്ടർ.

മെട്രിക്സ് മോഡിൽ ലഭിച്ച ഡാറ്റയെ അടിസ്ഥാനമാക്കി അഡ്-ഹോക്ക് ഗ്രാഫുകൾ നേടുന്നത് സാധ്യമാണ്. ഉദാഹരണത്തിന്, സൂചിക സ്ട്രിംഗ് അടങ്ങുന്ന ഒരു എൻട്രിയുടെ nginx ലോഗുകളിൽ സംഭവിക്കുന്നതിന്റെ ആവൃത്തി നിങ്ങൾക്ക് കണ്ടെത്താനാകും:

സവിശേഷതകളുടെ പൂർണ്ണമായ വിവരണം ഡോക്യുമെന്റേഷനിൽ കാണാം LogQL.

ലോഗ് പാഴ്സിംഗ്

ലോഗുകൾ ശേഖരിക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട്:

• ലോഗുകൾ ശേഖരിക്കുന്നതിനുള്ള സ്റ്റാക്കിന്റെ സ്റ്റാൻഡേർഡ് ഘടകമായ പ്രോംടെയിലിന്റെ സഹായത്തോടെ.
• ഉപയോഗിക്കുന്ന ഡോക്കർ കണ്ടെയ്‌നറിൽ നിന്ന് നേരിട്ട് ലോകി ഡോക്കർ ലോഗിംഗ് ഡ്രൈവർ.
• ലോകിയിലേക്ക് ഡാറ്റ അയയ്‌ക്കാൻ കഴിയുന്ന Fluentd അല്ലെങ്കിൽ Fluent Bit ഉപയോഗിക്കുക. പ്രോംടെയിലിൽ നിന്ന് വ്യത്യസ്തമായി, അവർക്ക് ഏതാണ്ട് ഏത് തരത്തിലുള്ള ലോഗിനും റെഡിമെയ്ഡ് പാഴ്‌സറുകൾ ഉണ്ട് കൂടാതെ മൾട്ടിലൈൻ ലോഗുകളും കൈകാര്യം ചെയ്യാൻ കഴിയും.

സാധാരണയായി പ്രോംടെയിൽ പാഴ്സിംഗിനായി ഉപയോഗിക്കുന്നു. ഇത് മൂന്ന് കാര്യങ്ങൾ ചെയ്യുന്നു:

• ഡാറ്റ ഉറവിടങ്ങൾ കണ്ടെത്തുന്നു.
• അവയിൽ ലേബലുകൾ അറ്റാച്ചുചെയ്യുക.
• ലോകിയിലേക്ക് ഡാറ്റ അയയ്ക്കുന്നു.

നിലവിൽ പ്രോംടെയിലിന് പ്രാദേശിക ഫയലുകളിൽ നിന്നും systemd ജേണലിൽ നിന്നുമുള്ള ലോഗുകൾ വായിക്കാൻ കഴിയും. ലോഗുകൾ ശേഖരിക്കുന്ന എല്ലാ മെഷീനുകളിലും ഇത് ഇൻസ്റ്റാൾ ചെയ്തിരിക്കണം.

Kubernetes-മായി സംയോജനമുണ്ട്: Promtail, Kubernetes REST API വഴി ക്ലസ്റ്ററിന്റെ അവസ്ഥ സ്വയമേവ കണ്ടെത്തുകയും ഒരു നോഡിൽ നിന്നോ സേവനത്തിൽ നിന്നോ പോഡിൽ നിന്നോ ലോഗുകൾ ശേഖരിക്കുന്നു, ഉടൻ തന്നെ Kubernetes-ൽ നിന്നുള്ള മെറ്റാഡാറ്റയെ അടിസ്ഥാനമാക്കി ലേബലുകൾ പോസ്റ്റുചെയ്യുന്നു (പോഡിന്റെ പേര്, ഫയലിന്റെ പേര് മുതലായവ).

പൈപ്പ്‌ലൈൻ ഉപയോഗിച്ച് ലോഗിൽ നിന്നുള്ള ഡാറ്റയെ അടിസ്ഥാനമാക്കി നിങ്ങൾക്ക് ലേബലുകൾ തൂക്കിയിടാനും കഴിയും. പൈപ്പ്ലൈൻ പ്രോംടെയിലിൽ നാല് തരം ഘട്ടങ്ങൾ അടങ്ങിയിരിക്കാം. കൂടുതൽ വിശദാംശങ്ങൾ - ഇൻ ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ, ഞാൻ ഉടൻ തന്നെ ചില സൂക്ഷ്മതകൾ ശ്രദ്ധിക്കും.

1. പാഴ്സിംഗ് ഘട്ടങ്ങൾ. ഇതാണ് RegEx, JSON എന്നിവയുടെ ഘട്ടം. ഈ ഘട്ടത്തിൽ, എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിലേക്ക് ഞങ്ങൾ ലോഗുകളിൽ നിന്ന് ഡാറ്റ എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നു. എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിലേക്ക് ഞങ്ങൾക്ക് ആവശ്യമായ ഫീൽഡുകൾ പകർത്തിയോ അല്ലെങ്കിൽ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിലേക്ക് പേരുള്ള ഗ്രൂപ്പുകളെ "മാപ്പ് ചെയ്‌തിരിക്കുന്ന" റെഗുലർ എക്‌സ്‌പ്രഷനുകളിലൂടെയോ (RegEx) നിങ്ങൾക്ക് JSON-ൽ നിന്ന് എക്‌സ്‌ട്രാക്റ്റുചെയ്യാനാകും. എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പ് ഒരു കീ-മൂല്യം സംഭരണമാണ്, ഇവിടെ കീ എന്നത് ഫീൽഡിന്റെ പേരാണ്, മൂല്യം ലോഗുകളിൽ നിന്നുള്ള അതിന്റെ മൂല്യമാണ്.
2. പരിവർത്തന ഘട്ടങ്ങൾ. ഈ ഘട്ടത്തിന് രണ്ട് ഓപ്ഷനുകളുണ്ട്: ട്രാൻസ്ഫോർമേഷൻ, അവിടെ ഞങ്ങൾ ട്രാൻസ്ഫോർമേഷൻ നിയമങ്ങൾ സജ്ജീകരിക്കുന്നു, കൂടാതെ ഉറവിടം - എക്‌സ്‌ട്രാക്റ്റുചെയ്‌ത മാപ്പിൽ നിന്ന് പരിവർത്തനത്തിനുള്ള ഡാറ്റ ഉറവിടം. എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിൽ അത്തരമൊരു ഫീൽഡ് ഇല്ലെങ്കിൽ, അത് സൃഷ്‌ടിക്കും. അങ്ങനെ, എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിനെ അടിസ്ഥാനമാക്കിയുള്ളതല്ലാത്ത ലേബലുകൾ സൃഷ്‌ടിക്കാൻ കഴിയും. ഈ ഘട്ടത്തിൽ, നമുക്ക് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിലെ ഡാറ്റ വളരെ ശക്തമായ ഒരു ഉപയോഗിച്ച് കൈകാര്യം ചെയ്യാൻ കഴിയും golang ടെംപ്ലേറ്റ്. കൂടാതെ, എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പ് പാഴ്‌സിംഗ് സമയത്ത് പൂർണ്ണമായി ലോഡുചെയ്‌തുവെന്ന് ഞങ്ങൾ ഓർക്കണം, ഇത് സാധ്യമാക്കുന്നു, ഉദാഹരണത്തിന്, അതിലെ മൂല്യം പരിശോധിക്കുന്നത്: “{{if .tag}ടാഗ് മൂല്യം നിലവിലുണ്ട്{end}}”. ടെംപ്ലേറ്റ് വ്യവസ്ഥകൾ, ലൂപ്പുകൾ, റീപ്ലേസ്, ട്രിം എന്നിവ പോലുള്ള ചില സ്ട്രിംഗ് ഫംഗ്‌ഷനുകൾ പിന്തുണയ്ക്കുന്നു.
3. പ്രവർത്തന ഘട്ടങ്ങൾ. ഈ ഘട്ടത്തിൽ, വേർതിരിച്ചെടുത്തത് ഉപയോഗിച്ച് നിങ്ങൾക്ക് എന്തെങ്കിലും ചെയ്യാൻ കഴിയും:
   • എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത ഡാറ്റയിൽ നിന്ന് ഒരു ലേബൽ സൃഷ്‌ടിക്കുക, അത് ലോകി സൂചികയിലാക്കും.
   • ലോഗിൽ നിന്ന് ഇവന്റ് സമയം മാറ്റുക അല്ലെങ്കിൽ സജ്ജീകരിക്കുക.
   • ലോകിയിലേക്ക് പോകുന്ന ഡാറ്റ (ലോഗ് ടെക്സ്റ്റ്) മാറ്റുക.
   • മെട്രിക്‌സ് സൃഷ്‌ടിക്കുക.
4. ഫിൽട്ടറിംഗ് ഘട്ടങ്ങൾ. മാച്ച് ഘട്ടം, ഒന്നുകിൽ നമുക്ക് /dev/null ആവശ്യമില്ലാത്ത റെക്കോർഡുകൾ അയയ്‌ക്കാം അല്ലെങ്കിൽ കൂടുതൽ പ്രോസസ്സിംഗിനായി അയയ്‌ക്കാനാകും.

സാധാരണ nginx ലോഗുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന്റെ ഉദാഹരണം ഉപയോഗിച്ച്, Promtail ഉപയോഗിച്ച് നിങ്ങൾക്ക് എങ്ങനെ ലോഗുകൾ പാഴ്‌സ് ചെയ്യാമെന്ന് ഞാൻ കാണിക്കും.

പരിശോധനയ്‌ക്കായി, പരിഷ്‌ക്കരിച്ച nginx jwilder/nginx-proxy:alpine ഇമേജും nginx-proxy ആയി HTTP വഴി സ്വയം അന്വേഷിക്കാൻ കഴിയുന്ന ഒരു ചെറിയ ഡെമണും എടുക്കാം. ഡെമണിന് നിരവധി എൻഡ്‌പോയിന്റുകളുണ്ട്, അതിന് വ്യത്യസ്ത വലുപ്പത്തിലുള്ള പ്രതികരണങ്ങൾ നൽകാൻ കഴിയും, വ്യത്യസ്ത HTTP സ്റ്റാറ്റസുകളും വ്യത്യസ്ത കാലതാമസങ്ങളും.

ഡോക്കർ കണ്ടെയ്‌നറുകളിൽ നിന്ന് ഞങ്ങൾ ലോഗുകൾ ശേഖരിക്കും, അത് /var/lib/docker/containers/ പാതയിൽ കാണാം. / -json.log

docker-compose.yml-ൽ ഞങ്ങൾ Promtail സജ്ജീകരിക്കുകയും കോൺഫിഗറിലേക്കുള്ള പാത വ്യക്തമാക്കുകയും ചെയ്യുന്നു:

promtail:
  image: grafana/promtail:1.4.1
 // ...
 volumes:
   - /var/lib/docker/containers:/var/lib/docker/containers:ro
   - promtail-data:/var/lib/promtail/positions
   - ${PWD}/promtail/docker.yml:/etc/promtail/promtail.yml
 command:
   - '-config.file=/etc/promtail/promtail.yml'
 // ...

promtail.yml-ലേക്ക് ലോഗുകളിലേക്കുള്ള പാത ചേർക്കുക (കോൺഫിഗറിൽ ഒരു "ഡോക്കർ" ഓപ്ഷൻ ഉണ്ട്, അത് ഒരു വരിയിൽ തന്നെ ചെയ്യുന്നു, പക്ഷേ അത് അത്ര വ്യക്തമാകില്ല):

scrape_configs:
 - job_name: containers

   static_configs:
       labels:
         job: containerlogs
         __path__: /var/lib/docker/containers/*/*log  # for linux only

ഈ കോൺഫിഗറേഷൻ പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ, ലോകിക്ക് എല്ലാ കണ്ടെയ്‌നറുകളിൽ നിന്നും ലോഗുകൾ ലഭിക്കും. ഇത് ഒഴിവാക്കാൻ, ഞങ്ങൾ docker-compose.yml-ലെ ടെസ്റ്റ് nginx-ന്റെ ക്രമീകരണങ്ങൾ മാറ്റുന്നു - ടാഗ് ഫീൽഡിലേക്ക് ലോഗിംഗ് ചേർക്കുക:

proxy:
 image: nginx.test.v3
//…
 logging:
   driver: "json-file"
   options:
     tag: "{{.ImageName}}|{{.Name}}"

promtail.yml എഡിറ്റ് ചെയ്‌ത് പൈപ്പ്‌ലൈൻ സജ്ജീകരിക്കുക. രേഖകൾ ഇപ്രകാരമാണ്:

{"log":"u001b[0;33;1mnginx.1    | u001b[0mnginx.test 172.28.0.3 - - [13/Jun/2020:23:25:50 +0000] "GET /api/index HTTP/1.1" 200 0 "-" "Stub_Bot/0.1" "0.096"n","stream":"stdout","attrs":{"tag":"nginx.promtail.test|proxy.prober"},"time":"2020-06-13T23:25:50.66740443Z"}
{"log":"u001b[0;33;1mnginx.1    | u001b[0mnginx.test 172.28.0.3 - - [13/Jun/2020:23:25:50 +0000] "GET /200 HTTP/1.1" 200 0 "-" "Stub_Bot/0.1" "0.000"n","stream":"stdout","attrs":{"tag":"nginx.promtail.test|proxy.prober"},"time":"2020-06-13T23:25:50.702925272Z"}

പൈപ്പ്ലൈൻ ഘട്ടങ്ങൾ:

 - json:
     expressions:
       stream: stream
       attrs: attrs
       tag: attrs.tag

ഇൻകമിംഗ് JSON-ൽ നിന്ന് ഞങ്ങൾ സ്ട്രീം, attrs, attrs.tag ഫീൽഡുകൾ (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) എക്‌സ്‌ട്രാക്റ്റുചെയ്‌ത് എക്‌സ്‌ട്രാക്റ്റുചെയ്‌ത മാപ്പിൽ ഇടുന്നു.

 - regex:
     expression: ^(?P<image_name>([^|]+))|(?P<container_name>([^|]+))$
     source: "tag"

എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിൽ ടാഗ് ഫീൽഡ് ഇടാൻ കഴിയുമെങ്കിൽ, regexp ഉപയോഗിച്ച് ഞങ്ങൾ ചിത്രത്തിന്റെയും കണ്ടെയ്‌നറിന്റെയും പേരുകൾ എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നു.

 - labels:
     image_name:
     container_name:

ഞങ്ങൾ ലേബലുകൾ നൽകുന്നു. എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത ഡാറ്റയിൽ ഇമേജ്_നെയിം, കണ്ടെയ്‌നർ_നെയിം എന്നീ കീകൾ കണ്ടെത്തിയാൽ, അവയുടെ മൂല്യങ്ങൾ ഉചിതമായ ലേബലുകളിലേക്ക് അസൈൻ ചെയ്യപ്പെടും.

 - match:
     selector: '{job="docker",container_name="",image_name=""}'
     action: drop

image_name, container_name എന്നീ ലേബലുകൾ ഇല്ലാത്ത എല്ലാ ലോഗുകളും ഞങ്ങൾ നിരസിക്കുന്നു.

  - match:
     selector: '{image_name="nginx.promtail.test"}'
     stages:
       - json:
           expressions:
             row: log

image_name nginx.promtail.test എന്നതിന് തുല്യമായ എല്ലാ ലോഗുകൾക്കും, സോഴ്‌സ് ലോഗിൽ നിന്ന് ലോഗ് ഫീൽഡ് ഞങ്ങൾ എക്‌സ്‌ട്രാക്റ്റുചെയ്‌ത് വരി കീ ഉപയോഗിച്ച് എക്‌സ്‌ട്രാക്റ്റുചെയ്‌ത മാപ്പിലേക്ക് ഇടുന്നു.

  - regex:
         # suppress forego colors
         expression: .+nginx.+|.+[0m(?P<virtual_host>[a-z_.-]+) +(?P<nginxlog>.+)
         source: logrow

സാധാരണ എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ ഇൻപുട്ട് സ്ട്രിംഗ് മായ്‌ക്കുകയും nginx വെർച്വൽ ഹോസ്റ്റും nginx ലോഗ് ലൈനും പുറത്തെടുക്കുകയും ചെയ്യുന്നു.

     - regex:
         source: nginxlog
         expression: ^(?P<ip>[w.]+) - (?P<user>[^ ]*) [(?P<timestamp>[^ ]+).*] "(?P<method>[^ ]*) (?P<request_url>[^ ]*) (?P<request_http_protocol>[^ ]*)" (?P<status>[d]+) (?P<bytes_out>[d]+) "(?P<http_referer>[^"]*)" "(?P<user_agent>[^"]*)"( "(?P<response_time>[d.]+)")?

പതിവ് എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച് nginx ലോഗ് പാഴ്സ് ചെയ്യുക.

    - regex:
           source: request_url
           expression: ^.+.(?P<static_type>jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|pdf|txt|tar|wav|bmp|rtf|js|flv|swf|html|htm)$
     - regex:
           source: request_url
           expression: ^/photo/(?P<photo>[^/?.]+).*$
       - regex:
           source: request_url
           expression: ^/api/(?P<api_request>[^/?.]+).*$

request_url പാഴ്‌സ് ചെയ്യുക. regexp-ന്റെ സഹായത്തോടെ, അഭ്യർത്ഥനയുടെ ഉദ്ദേശ്യം ഞങ്ങൾ നിർണ്ണയിക്കുന്നു: സ്റ്റാറ്റിക്സ്, ഫോട്ടോകൾ, API എന്നിവയിലേക്ക്, എക്‌സ്‌ട്രാക്റ്റുചെയ്‌ത മാപ്പിൽ അനുബന്ധ കീ സജ്ജമാക്കുക.

       - template:
           source: request_type
           template: "{{if .photo}}photo{{else if .static_type}}static{{else if .api_request}}api{{else}}other{{end}}"

ടെംപ്ലേറ്റിലെ സോപാധിക ഓപ്പറേറ്റർമാർ ഉപയോഗിച്ച്, എക്‌സ്‌ട്രാക്റ്റുചെയ്‌ത മാപ്പിൽ ഞങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്ത ഫീൽഡുകൾ പരിശോധിക്കുകയും request_type ഫീൽഡിനായി ആവശ്യമായ മൂല്യങ്ങൾ സജ്ജമാക്കുകയും ചെയ്യുന്നു: ഫോട്ടോ, സ്റ്റാറ്റിക്, API. പരാജയപ്പെട്ടാൽ മറ്റൊന്ന് നൽകുക. ഇപ്പോൾ request_type-ൽ അഭ്യർത്ഥന തരം അടങ്ങിയിരിക്കുന്നു.

       - labels:
           api_request:
           virtual_host:
           request_type:
           status:

എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിൽ ഉൾപ്പെടുത്താൻ ഞങ്ങൾക്ക് കഴിഞ്ഞതിന്റെ അടിസ്ഥാനത്തിൽ ഞങ്ങൾ api_request, virtual_host, request_type, സ്റ്റാറ്റസ് (HTTP സ്റ്റാറ്റസ്) എന്നീ ലേബലുകൾ സജ്ജീകരിച്ചു.

       - output:
           source: nginx_log_row

ഔട്ട്പുട്ട് മാറ്റുക. എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിൽ നിന്ന് വൃത്തിയാക്കിയ nginx ലോഗ് ഇപ്പോൾ ലോകിയിലേക്ക് പോകുന്നു.

മുകളിലുള്ള കോൺഫിഗറേഷൻ പ്രവർത്തിപ്പിച്ചതിന് ശേഷം, ഓരോ എൻട്രിയും ലോഗിൽ നിന്നുള്ള ഡാറ്റയെ അടിസ്ഥാനമാക്കി ലേബൽ ചെയ്തിരിക്കുന്നത് കാണാം.

ധാരാളം മൂല്യങ്ങളുള്ള (കാർഡിനാലിറ്റി) ലേബലുകൾ എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നത് ലോകിയെ ഗണ്യമായി മന്ദഗതിയിലാക്കുമെന്ന് ഓർമ്മിക്കുക. അതായത്, നിങ്ങൾ സൂചികയിൽ ഇടരുത്, ഉദാഹരണത്തിന്, user_id. ലേഖനത്തിൽ ഇതിനെക്കുറിച്ച് കൂടുതൽ വായിക്കുകലോകിയിലെ ലേബലുകൾക്ക് ലോഗ് അന്വേഷണങ്ങൾ എങ്ങനെ വേഗത്തിലും എളുപ്പത്തിലും ആക്കാനാകും". എന്നാൽ സൂചികകളില്ലാതെ നിങ്ങൾക്ക് user_id ഉപയോഗിച്ച് തിരയാൻ കഴിയില്ലെന്ന് ഇതിനർത്ഥമില്ല. തിരയുമ്പോൾ ഫിൽട്ടറുകൾ ഉപയോഗിക്കേണ്ടത് ആവശ്യമാണ് (ഡാറ്റ അനുസരിച്ച് "ഗ്രാബ്"), ഇവിടെയുള്ള സൂചിക ഒരു സ്ട്രീം ഐഡന്റിഫയറായി പ്രവർത്തിക്കുന്നു.

ലോഗ് ദൃശ്യവൽക്കരണം

LogQL ഉപയോഗിച്ച് ഗ്രാഫാന ചാർട്ടുകൾക്കായുള്ള ഒരു ഡാറ്റ ഉറവിടമായി ലോകിക്ക് പ്രവർത്തിക്കാനാകും. ഇനിപ്പറയുന്ന സവിശേഷതകൾ പിന്തുണയ്ക്കുന്നു:

• നിരക്ക് - സെക്കൻഡിൽ റെക്കോർഡുകളുടെ എണ്ണം;
• കാലക്രമേണ എണ്ണുക - നൽകിയിരിക്കുന്ന ശ്രേണിയിലെ റെക്കോർഡുകളുടെ എണ്ണം.

Sum, Avg എന്നിവയും മറ്റുള്ളവയും സമാഹരിക്കുന്ന പ്രവർത്തനങ്ങളുമുണ്ട്. നിങ്ങൾക്ക് വളരെ സങ്കീർണ്ണമായ ഗ്രാഫുകൾ നിർമ്മിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, HTTP പിശകുകളുടെ എണ്ണത്തിന്റെ ഒരു ഗ്രാഫ്:

ലോക്കിയുടെ ഡിഫോൾട്ട് ഡാറ്റാ ഉറവിടം പ്രോമിത്യൂസ് ഡാറ്റാ ഉറവിടത്തേക്കാൾ പ്രവർത്തനക്ഷമമല്ല (ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ലെജൻഡ് മാറ്റാൻ കഴിയില്ല), എന്നാൽ ലോക്കിയെ ഒരു പ്രോമിത്യൂസ് തരം ഉറവിടമായി ബന്ധിപ്പിക്കാൻ കഴിയും. ഇത് ഡോക്യുമെന്റ് ചെയ്ത പെരുമാറ്റമാണോ എന്ന് എനിക്ക് ഉറപ്പില്ല, പക്ഷേ ഡെവലപ്പർമാരിൽ നിന്നുള്ള പ്രതികരണമനുസരിച്ച് വിലയിരുത്തുന്നു “ലോക്കിയെ പ്രോമിത്യൂസ് ഡാറ്റാസോഴ്‌സായി എങ്ങനെ ക്രമീകരിക്കാം? · ലക്കം #1222 · ഗ്രാഫാന/ലോകി”, ഉദാഹരണത്തിന്, ഇത് തികച്ചും നിയമപരമാണ് കൂടാതെ ലോക്കി PromQL-മായി പൂർണ്ണമായും പൊരുത്തപ്പെടുന്നു.

Prometheus എന്ന് ടൈപ്പ് ചെയ്ത് ലോക്കി ഡാറ്റാ ഉറവിടമായി ചേർത്ത് URL /loki ചേർക്കുക:

ഞങ്ങൾ പ്രോമിത്യൂസിൽ നിന്നുള്ള മെട്രിക്‌സ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് പോലെ നിങ്ങൾക്ക് ഗ്രാഫുകൾ നിർമ്മിക്കാൻ കഴിയും:

പ്രവർത്തനത്തിലെ പൊരുത്തക്കേട് താൽക്കാലികമാണെന്നും ഡവലപ്പർമാർ ഭാവിയിൽ ഇത് പരിഹരിക്കുമെന്നും ഞാൻ കരുതുന്നു.

മെട്രിക്സ്

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

promtail.yml-ലേക്ക് മറ്റൊരു വിഭാഗം ചേർക്കുക:

- match:
   selector: '{request_type="api"}'
   stages:
     - metrics:
         http_nginx_response_time:
           type: Histogram
           description: "response time ms"
           source: response_time
           config:
             buckets: [0.010,0.050,0.100,0.200,0.500,1.0]
- match:
   selector: '{request_type=~"static|photo"}'
   stages:
     - metrics:
         http_nginx_response_bytes_sum:
           type: Counter
           description: "response bytes sum"
           source: bytes_out
           config:
             action: add
         http_nginx_response_bytes_count:
           type: Counter
           description: "response bytes count"
           source: bytes_out
           config:
             action: inc

എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത മാപ്പിൽ നിന്നുള്ള ഡാറ്റയെ അടിസ്ഥാനമാക്കി മെട്രിക്‌സ് നിർവ്വചിക്കാനും അപ്‌ഡേറ്റ് ചെയ്യാനും ഓപ്‌ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഈ മെട്രിക്കുകൾ ലോകിയിലേക്ക് അയച്ചിട്ടില്ല - അവ പ്രോംടെയിൽ /മെട്രിക്സ് എൻഡ്‌പോയിന്റിൽ ദൃശ്യമാകും. ഈ ഘട്ടത്തിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുന്നതിന് പ്രോമിത്യൂസ് കോൺഫിഗർ ചെയ്തിരിക്കണം. മുകളിലെ ഉദാഹരണത്തിൽ, request_type="api" എന്നതിനായി ഞങ്ങൾ ഒരു ഹിസ്റ്റോഗ്രാം മെട്രിക് ശേഖരിക്കുന്നു. ഇത്തരത്തിലുള്ള മെട്രിക്സ് ഉപയോഗിച്ച് പെർസെന്റൈലുകൾ ലഭിക്കുന്നത് സൗകര്യപ്രദമാണ്. സ്റ്റാറ്റിക്സിനും ഫോട്ടോകൾക്കുമായി, ശരാശരി കണക്കാക്കാൻ ബൈറ്റുകളുടെ ആകെത്തുകയും ബൈറ്റുകൾ ലഭിച്ച വരികളുടെ എണ്ണവും ഞങ്ങൾ ശേഖരിക്കുന്നു.

അളവുകളെക്കുറിച്ച് കൂടുതൽ വായിക്കുക ഇവിടെ.

പ്രോംടെയിലിൽ ഒരു പോർട്ട് തുറക്കുക:

promtail:
     image: grafana/promtail:1.4.1
     container_name: monitoring.promtail
     expose:
       - 9080
     ports:
       - "9080:9080"

promtail_custom പ്രിഫിക്‌സുള്ള മെട്രിക്‌സ് പ്രത്യക്ഷപ്പെട്ടിട്ടുണ്ടെന്ന് ഞങ്ങൾ ഉറപ്പാക്കുന്നു:

പ്രൊമിത്യൂസിനെ സജ്ജീകരിക്കുന്നു. ജോലി പ്രോംടെയിൽ ചേർക്കുക:

- job_name: 'promtail'
 scrape_interval: 10s
 static_configs:
   - targets: ['promtail:9080']

ഒപ്പം ഒരു ഗ്രാഫ് വരയ്ക്കുക:

ഇതുവഴി നിങ്ങൾക്ക് കണ്ടെത്താനാകും, ഉദാഹരണത്തിന്, വേഗത കുറഞ്ഞ നാല് ചോദ്യങ്ങൾ. ഈ മെട്രിക്കുകൾക്കായി നിങ്ങൾക്ക് നിരീക്ഷണം ക്രമീകരിക്കാനും കഴിയും.

സ്കെയിലിംഗ്

ലോക്കി സിംഗിൾ ബൈനറി മോഡിലും ഷാർഡഡ് മോഡിലും (തിരശ്ചീനമായി അളക്കാവുന്ന മോഡ്) ആകാം. രണ്ടാമത്തെ സാഹചര്യത്തിൽ, ഇത് ക്ലൗഡിലേക്ക് ഡാറ്റ സംരക്ഷിക്കാൻ കഴിയും, കൂടാതെ ചങ്കുകളും സൂചികയും പ്രത്യേകം സംഭരിക്കുന്നു. പതിപ്പ് 1.5 ൽ, ഒരിടത്ത് സംഭരിക്കുന്നതിനുള്ള കഴിവ് നടപ്പിലാക്കുന്നു, പക്ഷേ ഇത് ഉൽപ്പാദനത്തിൽ ഉപയോഗിക്കാൻ ഇതുവരെ ശുപാർശ ചെയ്തിട്ടില്ല.

സൂചികകൾ സംഭരിക്കുന്നതിന്, തിരശ്ചീനമായി അളക്കാവുന്ന ഡാറ്റാബേസുകൾ ഉപയോഗിക്കുക: കസാന്ദ്ര, ബിഗ്‌ടേബിൾ അല്ലെങ്കിൽ ഡൈനാമോഡിബി, S3-അനുയോജ്യമായ സ്റ്റോറേജിൽ ചങ്കുകൾ സംഭരിക്കാം. ലോകിയുടെ മറ്റ് ഭാഗങ്ങൾ - വിതരണക്കാർ (എഴുതാൻ), ക്വറിയർ (ചോദ്യങ്ങൾക്ക്) - നിലയില്ലാത്തതും തിരശ്ചീനമായി സ്കെയിൽ ചെയ്യുന്നതുമാണ്.

DevOpsDays Vancouver 2019 കോൺഫറൻസിൽ, പങ്കെടുത്തവരിൽ ഒരാളായ Callum Styan, ലോകിയോടൊപ്പം തന്റെ പ്രോജക്റ്റിന് മൊത്തം വലുപ്പത്തിന്റെ 1% ൽ താഴെയുള്ള സൂചികയുള്ള പെറ്റബൈറ്റ് ലോഗുകൾ ഉണ്ടെന്ന് പ്രഖ്യാപിച്ചു: "ലോകി എങ്ങനെയാണ് മെട്രിക്സും ലോഗുകളും പരസ്പരബന്ധിതമാക്കുന്നത് - നിങ്ങളുടെ പണം ലാഭിക്കുകയും ചെയ്യുന്നു".

ലോകിയുടെയും ELKയുടെയും താരതമ്യം

സൂചിക വലിപ്പം

തത്ഫലമായുണ്ടാകുന്ന സൂചിക വലുപ്പം പരിശോധിക്കുന്നതിന്, മുകളിലുള്ള പൈപ്പ്ലൈൻ ക്രമീകരിച്ചിരിക്കുന്ന nginx കണ്ടെയ്നറിൽ നിന്ന് ഞാൻ ലോഗുകൾ എടുത്തു. ലോഗ് ഫയലിൽ ആകെ 406 MB വോളിയമുള്ള 624 ലൈനുകൾ അടങ്ങിയിരിക്കുന്നു. ഒരു മണിക്കൂറിനുള്ളിൽ ലോഗുകൾ സൃഷ്ടിച്ചു, സെക്കൻഡിൽ ഏകദേശം 109 റെക്കോർഡുകൾ.

ലോഗിൽ നിന്നുള്ള രണ്ട് വരികളുടെ ഒരു ഉദാഹരണം:

ELK സൂചികയിലാക്കിയപ്പോൾ, ഇത് 30,3 MB എന്ന സൂചിക വലുപ്പം നൽകി:

ലോകിയുടെ കാര്യത്തിൽ, ഇത് ഏകദേശം 128 KB സൂചികയും ഏകദേശം 3,8 MB ഡാറ്റയും ചങ്കുകളിൽ നൽകി. ലോഗ് കൃത്രിമമായി ജനറേറ്റുചെയ്‌തതും വൈവിധ്യമാർന്ന ഡാറ്റ ഫീച്ചർ ചെയ്തിട്ടില്ലെന്നതും ശ്രദ്ധിക്കേണ്ടതാണ്. ഒറിജിനൽ ഡോക്കർ JSON ലോഗ് ഡാറ്റ സഹിതമുള്ള ഒരു ലളിതമായ ജിസിപ്പ് 95,4% കംപ്രഷൻ നൽകി, വൃത്തിയാക്കിയ nginx ലോഗ് മാത്രമേ ലോകിയിലേക്ക് അയച്ചിട്ടുള്ളൂ എന്നതിനാൽ, 4 MB-യിലേക്കുള്ള കംപ്രഷൻ മനസ്സിലാക്കാവുന്നതേയുള്ളൂ. ലോകി ലേബലുകൾക്കുള്ള തനതായ മൂല്യങ്ങളുടെ ആകെ എണ്ണം 35 ആയിരുന്നു, ഇത് സൂചികയുടെ ചെറിയ വലിപ്പം വിശദീകരിക്കുന്നു. ELK-യ്‌ക്ക്, ലോഗും മായ്‌ച്ചു. അങ്ങനെ, ലോക്കി യഥാർത്ഥ ഡാറ്റ 96%, ELK 70% എന്നിങ്ങനെ ചുരുക്കി.

മെമ്മറി ഉപഭോഗം

പ്രോമിത്യൂസിന്റെയും ELK യുടെയും മുഴുവൻ സ്റ്റാക്കും താരതമ്യം ചെയ്താൽ, ലോക്കി "തിന്നുന്നു" പല മടങ്ങ് കുറവാണ്. Go സേവനം ജാവ സേവനത്തേക്കാൾ കുറവാണ് ഉപയോഗിക്കുന്നതെന്ന് വ്യക്തമാണ്, കൂടാതെ Heap Elasticsearch JVM ന്റെ വലുപ്പവും ലോകിക്ക് അനുവദിച്ച മെമ്മറിയും താരതമ്യം ചെയ്യുന്നത് തെറ്റാണ്, എന്നിരുന്നാലും, ലോക്കി വളരെ കുറച്ച് മെമ്മറി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഇതിന്റെ സിപിയു ഗുണം അത്ര വ്യക്തമല്ല, പക്ഷേ അത് നിലവിലുണ്ട്.

വേഗത

ലോകി ലോഗുകൾ വേഗത്തിൽ "വിഴുങ്ങുന്നു". സ്പീഡ് പല ഘടകങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു - ഏതുതരം ലോഗുകൾ, എത്ര സങ്കീർണ്ണമാണ് ഞങ്ങൾ അവയെ പാഴ്‌സ് ചെയ്യുന്നു, നെറ്റ്‌വർക്ക്, ഡിസ്ക് മുതലായവ - എന്നാൽ ഇത് തീർച്ചയായും ELK-യേക്കാൾ ഉയർന്നതാണ് (എന്റെ പരിശോധനയിൽ - ഏകദേശം രണ്ട് തവണ). ലോകി സൂചികയിൽ വളരെ കുറച്ച് ഡാറ്റ ഇടുന്നു, അതിനനുസരിച്ച്, ഇൻഡെക്‌സിംഗിൽ കുറച്ച് സമയം ചെലവഴിക്കുന്നു എന്ന വസ്തുത ഇത് വിശദീകരിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, തിരയൽ വേഗതയിൽ സ്ഥിതി വിപരീതമാണ്: ലോകി കുറച്ച് ജിഗാബൈറ്റുകളേക്കാൾ വലിയ ഡാറ്റയിൽ മന്ദഗതിയിലാകുന്നു, അതേസമയം ELK-യെ സംബന്ധിച്ചിടത്തോളം തിരയൽ വേഗത ഡാറ്റ വലുപ്പത്തെ ആശ്രയിക്കുന്നില്ല.

ലോഗ് തിരയൽ

ലോഗ് സെർച്ച് കഴിവുകളുടെ കാര്യത്തിൽ ലോകി ELK-യെക്കാൾ വളരെ താഴ്ന്നതാണ്. പതിവ് എക്സ്പ്രഷനുകളുള്ള ഗ്രെപ്പ് ഒരു ശക്തമായ കാര്യമാണ്, പക്ഷേ ഇത് മുതിർന്നവരുടെ ഡാറ്റാബേസിനേക്കാൾ താഴ്ന്നതാണ്. റേഞ്ച് അന്വേഷണങ്ങളുടെ അഭാവം, ലേബലുകളാൽ മാത്രം കൂട്ടിച്ചേർക്കൽ, ലേബലുകളില്ലാതെ തിരയാനുള്ള കഴിവില്ലായ്മ - ഇതെല്ലാം ലോകിയിൽ താൽപ്പര്യമുള്ള വിവരങ്ങൾ തിരയുന്നതിൽ ഞങ്ങളെ പരിമിതപ്പെടുത്തുന്നു. ലോകി ഉപയോഗിച്ച് ഒന്നും കണ്ടെത്താനാകില്ലെന്ന് ഇത് അർത്ഥമാക്കുന്നില്ല, എന്നാൽ നിങ്ങൾ ആദ്യം പ്രോമിത്യൂസ് ചാർട്ടുകളിൽ ഒരു പ്രശ്നം കണ്ടെത്തുമ്പോൾ, ഈ ലേബലുകൾ ഉപയോഗിച്ച് ലോഗുകളിൽ എന്താണ് സംഭവിച്ചതെന്ന് നോക്കുമ്പോൾ, ലോഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിന്റെ ഒഴുക്ക് ഇത് നിർവചിക്കുന്നു.

ഇന്റർഫേസ്

ആദ്യം, ഇത് മനോഹരമാണ് (ക്ഷമിക്കണം, എതിർക്കാൻ കഴിഞ്ഞില്ല). ഗ്രാഫാനയ്ക്ക് മനോഹരമായി കാണപ്പെടുന്ന ഇന്റർഫേസ് ഉണ്ട്, എന്നാൽ കിബാന കൂടുതൽ പ്രവർത്തനക്ഷമമാണ്.

ലോകി ഗുണവും ദോഷവും

പ്ലസ്സുകളിൽ, ലോക്കി യഥാക്രമം പ്രോമിത്യൂസുമായി സംയോജിക്കുന്നു എന്നത് ശ്രദ്ധിക്കാവുന്നതാണ്, ഞങ്ങൾക്ക് മെട്രിക്സും ബോക്‌സിന് പുറത്ത് അലേർട്ടിംഗും ലഭിക്കും. പ്രോമിത്യൂസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച ഒരു സേവന കണ്ടെത്തൽ ഉള്ളതിനാലും ലേബലുകൾ സ്വയമേവ അറ്റാച്ചുചെയ്യുന്നതിനാലും ലോഗുകൾ ശേഖരിക്കുന്നതിനും അവയെ കുബർനെറ്റസ് പോഡുകൾ ഉപയോഗിച്ച് സംഭരിക്കുന്നതിനും ഇത് സൗകര്യപ്രദമാണ്.

പോരായ്മകളിൽ - മോശം ഡോക്യുമെന്റേഷൻ. പ്രോംടെയിലിന്റെ സവിശേഷതകളും കഴിവുകളും പോലുള്ള ചില കാര്യങ്ങൾ, കോഡ് പഠിക്കുന്ന പ്രക്രിയയിൽ മാത്രമാണ് ഞാൻ കണ്ടെത്തിയത്, ഓപ്പൺ സോഴ്‌സിന്റെ പ്രയോജനം. മറ്റൊരു പോരായ്മ ദുർബലമായ പാഴ്സിംഗ് കഴിവുകളാണ്. ഉദാഹരണത്തിന്, ലോകിക്ക് മൾട്ടിലൈൻ ലോഗുകൾ പാഴ്‌സ് ചെയ്യാൻ കഴിയില്ല. കൂടാതെ, ലോക്കി താരതമ്യേന യുവ സാങ്കേതികവിദ്യയാണെന്ന വസ്തുതയും പോരായ്മകളിൽ ഉൾപ്പെടുന്നു (റിലീസ് 1.0 2019 നവംബറിലായിരുന്നു).

തീരുമാനം

ലോഗ് അഗ്രഗേഷൻ, ലോഗ് തിരയൽ, നിരീക്ഷണം, ലോഗുകളുടെ വിശകലനം എന്നിവയുടെ നിരവധി പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന, ചെറുതും ഇടത്തരവുമായ പ്രോജക്റ്റുകൾക്ക് അനുയോജ്യമായ 100% രസകരമായ സാങ്കേതികവിദ്യയാണ് ലോകി.

Badoo-ൽ ഞങ്ങൾ ലോകി ഉപയോഗിക്കുന്നില്ല, കാരണം ഞങ്ങൾക്ക് അനുയോജ്യമായ ഒരു ELK സ്റ്റാക്ക് ഞങ്ങളുടെ പക്കലുണ്ട്, അത് വർഷങ്ങളായി വിവിധ ഇഷ്‌ടാനുസൃത പരിഹാരങ്ങളാൽ വളർന്നു. ലോഗുകളിലെ തിരയലാണ് ഞങ്ങളെ സംബന്ധിച്ചിടത്തോളം ഇടർച്ച. പ്രതിദിനം ഏകദേശം 100 GB ലോഗുകൾ ഉള്ളതിനാൽ, എല്ലാം കണ്ടെത്തി കുറച്ച് കൂടി വേഗത്തിൽ അത് ചെയ്യാൻ കഴിയുന്നത് ഞങ്ങൾക്ക് പ്രധാനമാണ്. ചാർട്ടിംഗിനും നിരീക്ഷണത്തിനുമായി, ഞങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായതും പരസ്പരം സംയോജിപ്പിച്ചതുമായ മറ്റ് പരിഹാരങ്ങൾ ഞങ്ങൾ ഉപയോഗിക്കുന്നു. ലോക്കി സ്റ്റാക്കിന് വ്യക്തമായ നേട്ടങ്ങളുണ്ട്, പക്ഷേ അത് നമുക്ക് ഉള്ളതിനേക്കാൾ കൂടുതൽ നൽകില്ല, മാത്രമല്ല അതിന്റെ നേട്ടങ്ങൾ മൈഗ്രേറ്റിംഗ് ചെലവിനേക്കാൾ കൂടുതലാകില്ല.

ഗവേഷണത്തിന് ശേഷം ഞങ്ങൾക്ക് ലോകി ഉപയോഗിക്കാൻ കഴിയില്ലെന്ന് വ്യക്തമായെങ്കിലും, തിരഞ്ഞെടുക്കുന്നതിന് ഈ പോസ്റ്റ് നിങ്ങളെ സഹായിക്കുമെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു.

ലേഖനത്തിൽ ഉപയോഗിച്ചിരിക്കുന്ന കോഡുള്ള ശേഖരം സ്ഥിതിചെയ്യുന്നു ഇവിടെ.

അവലംബം: www.habr.com