എങ്ങനെ, എന്തുകൊണ്ട് ഞങ്ങൾ 1C-യ്‌ക്കായി ഒരു ഉയർന്ന-ലോഡ് സ്കേലബിൾ സേവനം എഴുതി: എന്റർപ്രൈസ്: Java, PostgreSQL, Hazelcast

ഈ ലേഖനത്തിൽ നമ്മൾ എങ്ങനെ വികസിപ്പിച്ചെടുത്തു എന്നതിനെക്കുറിച്ച് സംസാരിക്കും ഇന്ററാക്ഷൻ സിസ്റ്റം – ക്ലയന്റ് ആപ്ലിക്കേഷനുകൾക്കും 1C: എന്റർപ്രൈസ് സെർവറുകൾക്കുമിടയിൽ വിവരങ്ങൾ കൈമാറുന്ന ഒരു സംവിധാനം - ഒരു ടാസ്‌ക് സജ്ജീകരിക്കുന്നത് മുതൽ ആർക്കിടെക്ചറിലൂടെയും നടപ്പിലാക്കൽ വിശദാംശങ്ങളിലൂടെയും ചിന്തിക്കുന്നത് വരെ.

ഗ്യാരണ്ടീഡ് ഡെലിവറിയുള്ള ഒരു വിതരണം ചെയ്യപ്പെടുന്ന, തെറ്റ്-സഹിഷ്ണുതയുള്ള സന്ദേശമയയ്‌ക്കൽ സംവിധാനമാണ് ഇന്ററാക്ഷൻ സിസ്റ്റം (ഇനിമുതൽ എസ്‌വി എന്ന് വിളിക്കുന്നു). SV രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത് ഉയർന്ന സ്കേലബിളിറ്റിയുള്ള ഒരു ഉയർന്ന ലോഡ് സേവനമായാണ്, ഒരു ഓൺലൈൻ സേവനമായും (1C നൽകിയത്) നിങ്ങളുടെ സ്വന്തം സെർവർ സൗകര്യങ്ങളിൽ വിന്യസിക്കാവുന്ന വൻതോതിൽ ഉൽപ്പാദിപ്പിക്കുന്ന ഉൽപ്പന്നമായും ലഭ്യമാണ്.

SV വിതരണ സംഭരണം ഉപയോഗിക്കുന്നു ഹാസൽകാസ്റ്റ് കൂടാതെ സെർച്ച് എഞ്ചിനും ഇലാസ്റ്റിസെര്ച്ച്. ജാവയെക്കുറിച്ചും PostgreSQL എങ്ങനെ തിരശ്ചീനമായി സ്കെയിൽ ചെയ്യുന്നുവെന്നും ഞങ്ങൾ സംസാരിക്കും.

പ്രശ്ന പ്രസ്താവന

എന്തുകൊണ്ടാണ് ഞങ്ങൾ ഇന്ററാക്ഷൻ സിസ്റ്റം സൃഷ്ടിച്ചതെന്ന് വ്യക്തമാക്കുന്നതിന്, 1C-യിലെ ബിസിനസ്സ് ആപ്ലിക്കേഷനുകളുടെ വികസനം എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് ഞാൻ നിങ്ങളോട് കുറച്ച് പറയും.

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

ക്ലയന്റ്-സെർവർ വികസന മാതൃക

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

ആപ്ലിക്കേഷൻ കോഡിൽ, &AtClient / &AtServer നിർദ്ദേശങ്ങൾ (&AtClient / &AtServer ഭാഷയുടെ ഇംഗ്ലീഷ് പതിപ്പിൽ) ഉപയോഗിച്ച് - എവിടെയാണ് കോഡ് എക്സിക്യൂട്ട് ചെയ്യേണ്ടതെന്ന് നടപടിക്രമങ്ങളുടെയും പ്രവർത്തനങ്ങളുടെയും തലക്കെട്ടുകൾ വ്യക്തമായി സൂചിപ്പിക്കണം. 1C ഡെവലപ്പർമാർ ഇപ്പോൾ നിർദ്ദേശങ്ങൾ യഥാർത്ഥമാണെന്ന് പറഞ്ഞുകൊണ്ട് എന്നെ തിരുത്തും കൂടുതൽ, എന്നാൽ ഞങ്ങൾക്ക് ഇത് ഇപ്പോൾ പ്രധാനമല്ല.

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

ഒരു ബട്ടൺ ക്ലിക്ക് കൈകാര്യം ചെയ്യുന്ന കോഡ്: ക്ലയന്റിൽ നിന്ന് ഒരു സെർവർ നടപടിക്രമം വിളിക്കുന്നത് പ്രവർത്തിക്കും, സെർവറിൽ നിന്ന് ഒരു ക്ലയന്റ് നടപടിക്രമം വിളിക്കുന്നത് പ്രവർത്തിക്കില്ല

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

ഒരു ടെലിഫോൺ കോൾ വരുമ്പോൾ ഒരു ആവശ്യവും ഉണ്ട് SIP- ഒരു കോൾ ചെയ്യുമ്പോൾ, ഇതിനെക്കുറിച്ച് ക്ലയന്റ് ആപ്ലിക്കേഷനെ അറിയിക്കുക, അതുവഴി കോളറിന്റെ നമ്പർ ഉപയോഗിച്ച് അത് കൌണ്ടർപാർട്ടി ഡാറ്റാബേസിൽ കണ്ടെത്താനും കോളിംഗ് കൌണ്ടർപാർട്ടിയെക്കുറിച്ചുള്ള ഉപയോക്തൃ വിവരങ്ങൾ കാണിക്കാനും കഴിയും. അല്ലെങ്കിൽ, ഉദാഹരണത്തിന്, ഒരു ഓർഡർ വെയർഹൗസിൽ എത്തുമ്പോൾ, ഇതിനെക്കുറിച്ച് ഉപഭോക്താവിന്റെ ക്ലയന്റ് ആപ്ലിക്കേഷനെ അറിയിക്കുക. പൊതുവേ, അത്തരമൊരു സംവിധാനം ഉപയോഗപ്രദമാകുന്ന നിരവധി കേസുകളുണ്ട്.

ഉത്പാദനം തന്നെ

ഒരു സന്ദേശമയയ്‌ക്കൽ സംവിധാനം സൃഷ്‌ടിക്കുക. വേഗതയേറിയതും വിശ്വസനീയവുമായ, ഉറപ്പുള്ള ഡെലിവറിയോടെ, സന്ദേശങ്ങൾ അയവോടെ തിരയാനുള്ള കഴിവ്. മെക്കാനിസത്തെ അടിസ്ഥാനമാക്കി, 1C ആപ്ലിക്കേഷനുകൾക്കുള്ളിൽ പ്രവർത്തിക്കുന്ന ഒരു മെസഞ്ചർ (സന്ദേശങ്ങൾ, വീഡിയോ കോളുകൾ) നടപ്പിലാക്കുക.

സിസ്റ്റം തിരശ്ചീനമായി അളക്കാൻ കഴിയുന്ന തരത്തിൽ രൂപകൽപ്പന ചെയ്യുക. നോഡുകളുടെ എണ്ണം വർദ്ധിപ്പിച്ചുകൊണ്ട് വർദ്ധിച്ചുവരുന്ന ലോഡ് മറയ്ക്കണം.

നടപ്പാക്കൽ

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

അതിനാൽ, എസ്‌വി ഒരു പ്രത്യേക ഉൽപ്പന്നമായി നിർമ്മിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു. സെർവറിന്റെ പ്രാദേശിക ഇൻസ്റ്റാളേഷനും കോൺഫിഗറേഷനുമായി ബന്ധപ്പെട്ട ഓവർഹെഡ് ചെലവുകൾ ഒഴിവാക്കാൻ ഞങ്ങളുടെ ക്ലൗഡിൽ (wss://1cdialog.com) ഞങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്ത CB സെർവർ ചെറിയ കമ്പനികൾ ഉപയോഗിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു. വലിയ ക്ലയന്റുകൾ അവരുടെ സൗകര്യങ്ങളിൽ സ്വന്തം സിബി സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുന്നത് ഉചിതമാണെന്ന് കണ്ടെത്തിയേക്കാം. ഞങ്ങളുടെ ക്ലൗഡ് SaaS ഉൽപ്പന്നത്തിലും ഞങ്ങൾ സമാനമായ ഒരു സമീപനം ഉപയോഗിച്ചു 1cഫ്രഷ് - ഇത് ക്ലയന്റുകളുടെ സൈറ്റുകളിൽ ഇൻസ്റ്റാളുചെയ്യുന്നതിനായി വൻതോതിൽ ഉൽപ്പാദിപ്പിക്കുന്ന ഉൽപ്പന്നമായി നിർമ്മിക്കുന്നു, കൂടാതെ ഞങ്ങളുടെ ക്ലൗഡിലും വിന്യസിച്ചിരിക്കുന്നു https://1cfresh.com/.

അപേക്ഷ

ലോഡും തെറ്റ് സഹിഷ്ണുതയും വിതരണം ചെയ്യുന്നതിന്, ഞങ്ങൾ ഒരു ജാവ ആപ്ലിക്കേഷനല്ല, മറിച്ച് നിരവധി, അവയ്ക്ക് മുന്നിൽ ഒരു ലോഡ് ബാലൻസറുമായി വിന്യസിക്കും. നിങ്ങൾക്ക് ഒരു നോഡിൽ നിന്ന് നോഡിലേക്ക് ഒരു സന്ദേശം കൈമാറണമെങ്കിൽ, Hazelcast-ൽ പ്രസിദ്ധീകരിക്കുക/സബ്‌സ്‌ക്രൈബ് ചെയ്യുക ഉപയോഗിക്കുക.

ക്ലയന്റും സെർവറും തമ്മിലുള്ള ആശയവിനിമയം വെബ്‌സോക്കറ്റ് വഴിയാണ്. ഇത് തത്സമയ സംവിധാനങ്ങൾക്ക് അനുയോജ്യമാണ്.

വിതരണം ചെയ്ത കാഷെ

ഞങ്ങൾ Redis, Hazelcast, Ehcache എന്നിവയിൽ നിന്ന് തിരഞ്ഞെടുത്തു. ഇത് 2015 ആണ്. റെഡിസ് ഇപ്പോൾ ഒരു പുതിയ ക്ലസ്റ്റർ പുറത്തിറക്കി (വളരെ പുതിയത്, ഭയപ്പെടുത്തുന്നതാണ്), ധാരാളം നിയന്ത്രണങ്ങളുള്ള സെന്റിനൽ ഉണ്ട്. ഒരു ക്ലസ്റ്ററിലേക്ക് എങ്ങനെ കൂട്ടിച്ചേർക്കണമെന്ന് Ehcache-ന് അറിയില്ല (ഈ പ്രവർത്തനം പിന്നീട് പ്രത്യക്ഷപ്പെട്ടു). Hazelcast 3.4 ഉപയോഗിച്ച് ഇത് പരീക്ഷിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു.
Hazelcast ബോക്‌സിന് പുറത്ത് ഒരു ക്ലസ്റ്ററിലേക്ക് കൂട്ടിച്ചേർക്കുന്നു. സിംഗിൾ നോഡ് മോഡിൽ, ഇത് വളരെ ഉപയോഗപ്രദമല്ല മാത്രമല്ല ഒരു കാഷെ ആയി മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ - ഡിസ്കിലേക്ക് ഡാറ്റ എങ്ങനെ ഡംപ് ചെയ്യണമെന്ന് ഇതിന് അറിയില്ല, നിങ്ങൾക്ക് ഒരേയൊരു നോഡ് നഷ്‌ടപ്പെടുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഡാറ്റ നഷ്‌ടപ്പെടും. ഞങ്ങൾ നിരവധി Hazelcasts വിന്യസിക്കുന്നു, അവയ്ക്കിടയിൽ ഞങ്ങൾ നിർണായക ഡാറ്റ ബാക്കപ്പ് ചെയ്യുന്നു. ഞങ്ങൾ കാഷെ ബാക്കപ്പ് ചെയ്യുന്നില്ല - ഞങ്ങൾ അത് കാര്യമാക്കുന്നില്ല.

ഞങ്ങളെ സംബന്ധിച്ചിടത്തോളം, Hazelcast ഇതാണ്:

• ഉപയോക്തൃ സെഷനുകളുടെ സംഭരണം. ഓരോ തവണയും ഒരു സെഷനായി ഡാറ്റാബേസിലേക്ക് പോകാൻ വളരെ സമയമെടുക്കും, അതിനാൽ ഞങ്ങൾ എല്ലാ സെഷനുകളും Hazelcast-ൽ ഇടുന്നു.
• കാഷെ. നിങ്ങൾ ഒരു ഉപയോക്തൃ പ്രൊഫൈലിനായി തിരയുകയാണെങ്കിൽ, കാഷെ പരിശോധിക്കുക. ഒരു പുതിയ സന്ദേശം എഴുതി - അത് കാഷെയിൽ ഇടുക.
• ആപ്ലിക്കേഷൻ സന്ദർഭങ്ങൾ തമ്മിലുള്ള ആശയവിനിമയത്തിനുള്ള വിഷയങ്ങൾ. നോഡ് ഒരു ഇവന്റ് സൃഷ്ടിക്കുകയും അത് Hazelcast വിഷയത്തിൽ സ്ഥാപിക്കുകയും ചെയ്യുന്നു. ഈ വിഷയത്തിലേക്ക് സബ്‌സ്‌ക്രൈബ് ചെയ്‌ത മറ്റ് ആപ്ലിക്കേഷൻ നോഡുകൾ ഇവന്റ് സ്വീകരിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു.
• ക്ലസ്റ്റർ ലോക്കുകൾ. ഉദാഹരണത്തിന്, ഞങ്ങൾ ഒരു അദ്വിതീയ കീ ഉപയോഗിച്ച് ഒരു ചർച്ച സൃഷ്ടിക്കുന്നു (1C ഡാറ്റാബേസിനുള്ളിലെ സിംഗിൾടൺ ചർച്ച):

conversationKeyChecker.check("БЕНЗОКОЛОНКА");

      doInClusterLock("БЕНЗОКОЛОНКА", () -> {

          conversationKeyChecker.check("БЕНЗОКОЛОНКА");

          createChannel("БЕНЗОКОЛОНКА");
      });

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

ഒരു DBMS തിരഞ്ഞെടുക്കുന്നു

PostgreSQL-ൽ പ്രവർത്തിക്കുകയും ഈ DBMS-ന്റെ ഡെവലപ്പർമാരുമായി സഹകരിക്കുകയും ചെയ്യുന്ന വിപുലവും വിജയകരവുമായ അനുഭവം ഞങ്ങൾക്കുണ്ട്.

ഒരു PostgreSQL ക്ലസ്റ്റർ ഉപയോഗിച്ച് ഇത് എളുപ്പമല്ല - ഉണ്ട് XL, XC, സിറ്റസ്, എന്നാൽ പൊതുവെ ഇവ ബോക്‌സിന് പുറത്ത് സ്കെയിൽ ചെയ്യുന്ന NoSQL-കളല്ല. NoSQL പ്രധാന സംഭരണമായി ഞങ്ങൾ പരിഗണിച്ചില്ല; ഞങ്ങൾ മുമ്പ് പ്രവർത്തിച്ചിട്ടില്ലാത്ത Hazelcast എടുത്താൽ മതിയായിരുന്നു.

നിങ്ങൾക്ക് ഒരു റിലേഷണൽ ഡാറ്റാബേസ് സ്കെയിൽ ചെയ്യണമെങ്കിൽ, അതിനർത്ഥം ഷാർഡിംഗ്. നിങ്ങൾക്കറിയാവുന്നതുപോലെ, ഷാർഡിംഗ് ഉപയോഗിച്ച് ഞങ്ങൾ ഡാറ്റാബേസിനെ പ്രത്യേക ഭാഗങ്ങളായി വിഭജിക്കുന്നു, അങ്ങനെ അവ ഓരോന്നും പ്രത്യേക സെർവറിൽ സ്ഥാപിക്കാൻ കഴിയും.

ഞങ്ങളുടെ ഷാർഡിംഗിന്റെ ആദ്യ പതിപ്പ്, ഞങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ഓരോ ടേബിളുകളും വ്യത്യസ്ത അനുപാതങ്ങളിൽ വ്യത്യസ്ത സെർവറുകളിലുടനീളം വിതരണം ചെയ്യാനുള്ള കഴിവ് ഊഹിച്ചു. സെർവർ A-യിൽ ധാരാളം സന്ദേശങ്ങളുണ്ട് - ദയവായി, നമുക്ക് ഈ പട്ടികയുടെ ഒരു ഭാഗം സെർവർ B ലേക്ക് മാറ്റാം. ഈ തീരുമാനം അകാല ഒപ്റ്റിമൈസേഷനെക്കുറിച്ച് കേവലം നിലവിളിച്ചു, അതിനാൽ ഞങ്ങൾ ഒരു മൾട്ടി-ടെനന്റ് സമീപനത്തിലേക്ക് സ്വയം പരിമിതപ്പെടുത്താൻ തീരുമാനിച്ചു.

നിങ്ങൾക്ക് മൾട്ടി-ടെന്റന്റിനെക്കുറിച്ച് വായിക്കാം, ഉദാഹരണത്തിന്, വെബ്സൈറ്റിൽ സിറ്റസ് ഡാറ്റ.

എസ്‌വിക്ക് ആപ്ലിക്കേഷൻ, സബ്‌സ്‌ക്രൈബർ എന്നീ ആശയങ്ങളുണ്ട്. ERP അല്ലെങ്കിൽ അക്കൗണ്ടിംഗ് പോലെയുള്ള ഒരു ബിസിനസ് ആപ്ലിക്കേഷന്റെ ഉപയോക്താക്കളും ബിസിനസ് ഡാറ്റയും ഉള്ള ഒരു നിർദ്ദിഷ്ട ഇൻസ്റ്റാളേഷനാണ് ആപ്ലിക്കേഷൻ. എസ്‌വി സെർവറിൽ അപേക്ഷ രജിസ്റ്റർ ചെയ്തിട്ടുള്ള ഒരു സ്ഥാപനമോ വ്യക്തിയോ ആണ് സബ്‌സ്‌ക്രൈബർ. ഒരു വരിക്കാരന് നിരവധി ആപ്ലിക്കേഷനുകൾ രജിസ്റ്റർ ചെയ്യാവുന്നതാണ്, ഈ ആപ്ലിക്കേഷനുകൾക്ക് പരസ്പരം സന്ദേശങ്ങൾ കൈമാറാനും കഴിയും. വരിക്കാരൻ ഞങ്ങളുടെ സിസ്റ്റത്തിൽ വാടകക്കാരനായി. നിരവധി സബ്‌സ്‌ക്രൈബർമാരിൽ നിന്നുള്ള സന്ദേശങ്ങൾ ഒരു ഫിസിക്കൽ ഡാറ്റാബേസിൽ കണ്ടെത്താനാകും; ഒരു സബ്‌സ്‌ക്രൈബർ വളരെയധികം ട്രാഫിക് സൃഷ്‌ടിക്കാൻ തുടങ്ങിയതായി ഞങ്ങൾ കാണുകയാണെങ്കിൽ, ഞങ്ങൾ അത് ഒരു പ്രത്യേക ഫിസിക്കൽ ഡാറ്റാബേസിലേക്ക് (അല്ലെങ്കിൽ ഒരു പ്രത്യേക ഡാറ്റാബേസ് സെർവറിലേക്ക് പോലും) നീക്കുന്നു.

എല്ലാ സബ്‌സ്‌ക്രൈബർ ഡാറ്റാബേസുകളുടെയും ലൊക്കേഷനെക്കുറിച്ചുള്ള വിവരങ്ങളുള്ള ഒരു റൂട്ടിംഗ് ടേബിൾ സംഭരിച്ചിരിക്കുന്ന ഒരു പ്രധാന ഡാറ്റാബേസ് ഞങ്ങളുടെ പക്കലുണ്ട്.

പ്രധാന ഡാറ്റാബേസ് ഒരു തടസ്സമാകുന്നത് തടയാൻ, ഞങ്ങൾ റൂട്ടിംഗ് ടേബിൾ (കൂടാതെ പതിവായി ആവശ്യമുള്ള മറ്റ് ഡാറ്റ) ഒരു കാഷെയിൽ സൂക്ഷിക്കുന്നു.

സബ്‌സ്‌ക്രൈബർമാരുടെ ഡാറ്റാബേസ് മന്ദഗതിയിലാകാൻ തുടങ്ങിയാൽ, ഞങ്ങൾ അതിനെ പാർട്ടീഷനുകളായി മുറിക്കും. ഞങ്ങൾ ഉപയോഗിക്കുന്ന മറ്റ് പദ്ധതികളിൽ pg_pathman.

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

ഒരു സിൻക്രണസ് പകർപ്പ് നഷ്ടപ്പെട്ടാൽ, അസിൻക്രണസ് പകർപ്പ് സിൻക്രണസ് ആയി മാറുന്നു.
പ്രധാന ഡാറ്റാബേസ് നഷ്‌ടപ്പെട്ടാൽ, സിൻക്രണസ് പകർപ്പ് പ്രധാന ഡാറ്റാബേസായി മാറുന്നു, അസിൻക്രണസ് പകർപ്പ് ഒരു സിൻക്രണസ് പകർപ്പായി മാറുന്നു.

തിരയലിനായി ഇലാസ്റ്റിക് തിരയൽ

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

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

[അത്, tek, ടെക്സ്, ടെക്സ്റ്റ്, ടെക്സ്റ്റുകൾ, ek, ex, ext, ടെക്സ്റ്റുകൾ, ks, kst, ksty, st, sty, you],

കൂടാതെ "ടെക്സ്റ്റ്" എന്ന വാക്കിന്റെ മൂലവും സംരക്ഷിക്കപ്പെടും. വാക്കിന്റെ തുടക്കത്തിലും മധ്യത്തിലും അവസാനത്തിലും തിരയാൻ ഈ സമീപനം നിങ്ങളെ അനുവദിക്കുന്നു.

വലിയ ചിത്രം

ലേഖനത്തിന്റെ തുടക്കം മുതൽ ചിത്രം ആവർത്തിക്കുക, പക്ഷേ വിശദീകരണങ്ങളോടെ:

• ബാലൻസർ ഇന്റർനെറ്റിൽ തുറന്നുകാട്ടി; ഞങ്ങൾക്ക് nginx ഉണ്ട്, അത് ഏതെങ്കിലും ആകാം.
• ജാവ ആപ്ലിക്കേഷൻ സംഭവങ്ങൾ Hazelcast വഴി പരസ്പരം ആശയവിനിമയം നടത്തുന്നു.
• ഞങ്ങൾ ഉപയോഗിക്കുന്ന ഒരു വെബ് സോക്കറ്റിൽ പ്രവർത്തിക്കാൻ നെറ്റി.
• ജാവ ആപ്ലിക്കേഷൻ ജാവ 8 ൽ എഴുതിയിരിക്കുന്നു, അതിൽ ബണ്ടിലുകൾ അടങ്ങിയിരിക്കുന്നു OSGi. ജാവ 10-ലേക്കുള്ള മൈഗ്രേഷനും മൊഡ്യൂളുകളിലേക്കുള്ള പരിവർത്തനവും പ്ലാനുകളിൽ ഉൾപ്പെടുന്നു.

വികസനവും പരിശോധനയും

എസ്‌വി വികസിപ്പിക്കുകയും പരീക്ഷിക്കുകയും ചെയ്യുന്ന പ്രക്രിയയിൽ, ഞങ്ങൾ ഉപയോഗിക്കുന്ന ഉൽപ്പന്നങ്ങളുടെ രസകരമായ നിരവധി സവിശേഷതകൾ ഞങ്ങൾ കണ്ടു.

ലോഡ് ടെസ്റ്റിംഗും മെമ്മറി ലീക്കുകളും

ഓരോ എസ്വി റിലീസിന്റെയും റിലീസ് ലോഡ് ടെസ്റ്റിംഗ് ഉൾക്കൊള്ളുന്നു. ഇത് വിജയിക്കുമ്പോൾ:

• ടെസ്റ്റ് ദിവസങ്ങളോളം പ്രവർത്തിച്ചു, സേവന പരാജയങ്ങളൊന്നും ഉണ്ടായില്ല
• പ്രധാന പ്രവർത്തനങ്ങൾക്കുള്ള പ്രതികരണ സമയം സുഖപ്രദമായ പരിധി കവിഞ്ഞില്ല
• മുമ്പത്തെ പതിപ്പിനെ അപേക്ഷിച്ച് പ്രകടനത്തിലെ അപചയം 10% ൽ കൂടുതലല്ല

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

ഞങ്ങൾ മൂന്ന് കോൺഫിഗറേഷനുകളിൽ ഇന്ററാക്ഷൻ സിസ്റ്റത്തിന്റെ ലോഡ് ടെസ്റ്റിംഗ് നടത്തുന്നു:

1. സമ്മർദ്ദ പരിശോധന
2. കണക്ഷനുകൾ മാത്രം
3. സബ്സ്ക്രൈബർ രജിസ്ട്രേഷൻ

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

ഉദാഹരണത്തിന്, സ്ട്രെസ് ടെസ്റ്റിന്റെ ഭാഗം ഇങ്ങനെയാണ്:

• ഉപയോക്താവ് ലോഗിൻ ചെയ്യുന്നു
  • നിങ്ങളുടെ വായിക്കാത്ത ചർച്ചകൾ അഭ്യർത്ഥിക്കുന്നു
  • 50% സന്ദേശങ്ങൾ വായിക്കാൻ സാധ്യതയുണ്ട്
  • 50% ടെക്‌സ്‌റ്റ് ചെയ്യാൻ സാധ്യതയുണ്ട്
  • അടുത്ത ഉപയോക്താവ്:
    • ഒരു പുതിയ ചർച്ച സൃഷ്ടിക്കാൻ 20% സാധ്യതയുണ്ട്
    • അതിന്റെ ഏതെങ്കിലും ചർച്ചകൾ ക്രമരഹിതമായി തിരഞ്ഞെടുക്കുന്നു
    • അകത്തേക്ക് പോകുന്നു
    • സന്ദേശങ്ങൾ, ഉപയോക്തൃ പ്രൊഫൈലുകൾ എന്നിവ അഭ്യർത്ഥിക്കുന്നു
    • ഈ ചർച്ചയിൽ നിന്ന് ക്രമരഹിതമായ ഉപയോക്താക്കൾക്കായി അഞ്ച് സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നു
    • ചർച്ച വിടുന്നു
    • 20 തവണ ആവർത്തിക്കുന്നു
    • ലോഗ് ഔട്ട്, സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിലേക്ക് തിരികെ പോകുന്നു

  • ഒരു ചാറ്റ്ബോട്ട് സിസ്റ്റത്തിലേക്ക് പ്രവേശിക്കുന്നു (അപ്ലിക്കേഷൻ കോഡിൽ നിന്നുള്ള സന്ദേശമയയ്‌ക്കൽ അനുകരിക്കുന്നു)
    • ഡാറ്റാ കൈമാറ്റത്തിനായി ഒരു പുതിയ ചാനൽ സൃഷ്ടിക്കാൻ 50% സാധ്യതയുണ്ട് (പ്രത്യേക ചർച്ച)
    • നിലവിലുള്ള ഏതെങ്കിലും ചാനലുകളിലേക്ക് സന്ദേശം എഴുതാൻ 50% സാധ്യതയുണ്ട്

"കണക്ഷനുകൾ മാത്രം" എന്ന രംഗം ഒരു കാരണത്താൽ പ്രത്യക്ഷപ്പെട്ടു. ഒരു സാഹചര്യമുണ്ട്: ഉപയോക്താക്കൾ സിസ്റ്റം ബന്ധിപ്പിച്ചിട്ടുണ്ട്, പക്ഷേ ഇതുവരെ ഉൾപ്പെട്ടിട്ടില്ല. ഓരോ ഉപയോക്താവും രാവിലെ 09:00 മണിക്ക് കമ്പ്യൂട്ടർ ഓണാക്കുകയും സെർവറുമായി ഒരു കണക്ഷൻ സ്ഥാപിക്കുകയും നിശബ്ദത പാലിക്കുകയും ചെയ്യുന്നു. ഈ ആളുകൾ അപകടകാരികളാണ്, അവരിൽ പലരും ഉണ്ട് - അവരുടെ പക്കലുള്ള ഒരേയൊരു പാക്കേജുകൾ PING/PONG ആണ്, എന്നാൽ അവർ സെർവറിലേക്കുള്ള കണക്ഷൻ നിലനിർത്തുന്നു (അവർക്ക് അത് നിലനിർത്താൻ കഴിയില്ല - ഒരു പുതിയ സന്ദേശം ഉണ്ടെങ്കിൽ എന്തുചെയ്യും). അത്തരം ധാരാളം ഉപയോക്താക്കൾ അരമണിക്കൂറിനുള്ളിൽ സിസ്റ്റത്തിലേക്ക് ലോഗിൻ ചെയ്യാൻ ശ്രമിക്കുന്ന ഒരു സാഹചര്യം ടെസ്റ്റ് പുനർനിർമ്മിക്കുന്നു. ഇത് ഒരു സ്ട്രെസ് ടെസ്റ്റിന് സമാനമാണ്, പക്ഷേ അതിന്റെ ശ്രദ്ധ കൃത്യമായി ഈ ആദ്യ ഇൻപുട്ടിലാണ് - അതിനാൽ പരാജയങ്ങളൊന്നും ഉണ്ടാകില്ല (ഒരു വ്യക്തി സിസ്റ്റം ഉപയോഗിക്കുന്നില്ല, അത് ഇതിനകം തന്നെ വീഴുന്നു - മോശമായ എന്തെങ്കിലും ചിന്തിക്കാൻ പ്രയാസമാണ്).

ആദ്യ ലോഞ്ച് മുതൽ സബ്‌സ്‌ക്രൈബർ രജിസ്‌ട്രേഷൻ സ്‌ക്രിപ്റ്റ് ആരംഭിക്കുന്നു. ഞങ്ങൾ ഒരു സ്ട്രെസ് ടെസ്റ്റ് നടത്തി, കത്തിടപാടുകൾക്കിടയിൽ സിസ്റ്റം മന്ദഗതിയിലല്ലെന്ന് ഉറപ്പായിരുന്നു. എന്നാൽ ഉപയോക്താക്കൾ വന്നു, കാലഹരണപ്പെട്ടതിനാൽ രജിസ്ട്രേഷൻ പരാജയപ്പെടാൻ തുടങ്ങി. രജിസ്റ്റർ ചെയ്യുമ്പോൾ ഞങ്ങൾ ഉപയോഗിച്ചു / dev / ക്രമരഹിതം, ഇത് സിസ്റ്റത്തിന്റെ എൻട്രോപ്പിയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. സെർവറിന് മതിയായ എൻട്രോപ്പി ശേഖരിക്കാൻ സമയമില്ലായിരുന്നു, ഒരു പുതിയ SecureRandom അഭ്യർത്ഥിച്ചപ്പോൾ, അത് പതിനായിരക്കണക്കിന് സെക്കൻഡ് മരവിച്ചു. ഈ സാഹചര്യത്തിൽ നിന്ന് രക്ഷപ്പെടാൻ നിരവധി മാർഗങ്ങളുണ്ട്, ഉദാഹരണത്തിന്: സുരക്ഷിതമല്ലാത്ത /dev/urandom-ലേക്ക് മാറുക, എൻട്രോപ്പി സൃഷ്ടിക്കുന്ന ഒരു പ്രത്യേക ബോർഡ് ഇൻസ്റ്റാൾ ചെയ്യുക, ക്രമരഹിതമായ നമ്പറുകൾ മുൻകൂട്ടി സൃഷ്ടിച്ച് അവയെ ഒരു കുളത്തിൽ സൂക്ഷിക്കുക. പൂളിലെ പ്രശ്നം ഞങ്ങൾ താൽക്കാലികമായി അവസാനിപ്പിച്ചു, എന്നാൽ അതിനുശേഷം ഞങ്ങൾ പുതിയ സബ്‌സ്‌ക്രൈബർമാരെ രജിസ്റ്റർ ചെയ്യുന്നതിനായി ഒരു പ്രത്യേക പരിശോധന നടത്തുന്നു.

ഞങ്ങൾ ഒരു ലോഡ് ജനറേറ്ററായി ഉപയോഗിക്കുന്നു ജെമെറ്റർ. വെബ്‌സോക്കറ്റിൽ എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് ഇതിന് അറിയില്ല; അതിന് ഒരു പ്ലഗിൻ ആവശ്യമാണ്. "jmeter websocket" എന്ന ചോദ്യത്തിനായുള്ള തിരയൽ ഫലങ്ങളിൽ ആദ്യത്തേത്: BlazeMeter-ൽ നിന്നുള്ള ലേഖനങ്ങൾ, ഏത് ശുപാർശ ചെയ്യുന്നു Maciej Zaleski യുടെ പ്ലഗിൻ.

അവിടെ നിന്നാണ് ഞങ്ങൾ തുടങ്ങാൻ തീരുമാനിച്ചത്.

ഗുരുതരമായ പരിശോധന ആരംഭിച്ചതിന് തൊട്ടുപിന്നാലെ, JMeter മെമ്മറി ചോർത്താൻ തുടങ്ങിയതായി ഞങ്ങൾ കണ്ടെത്തി.

പ്ലഗിൻ ഒരു പ്രത്യേക വലിയ സ്റ്റോറിയാണ്; 176 നക്ഷത്രങ്ങളുള്ള ഇതിന് ഗിത്തബിൽ 132 ഫോർക്കുകൾ ഉണ്ട്. 2015 മുതൽ രചയിതാവ് തന്നെ അതിന് പ്രതിജ്ഞാബദ്ധത പുലർത്തിയിട്ടില്ല (ഞങ്ങൾ ഇത് 2015 ൽ എടുത്തിരുന്നു, പിന്നീട് അത് സംശയം ഉയർത്തിയില്ല), മെമ്മറി ലീക്കുകൾ സംബന്ധിച്ച നിരവധി ഗിത്തബ് പ്രശ്‌നങ്ങൾ, 7 അൺക്ലോസ്ഡ് പുൾ അഭ്യർത്ഥനകൾ.
ഈ പ്ലഗിൻ ഉപയോഗിച്ച് ലോഡ് ടെസ്റ്റിംഗ് നടത്താൻ നിങ്ങൾ തീരുമാനിക്കുകയാണെങ്കിൽ, ഇനിപ്പറയുന്ന ചർച്ചകൾ ശ്രദ്ധിക്കുക:

1. ഒരു മൾട്ടി-ത്രെഡഡ് പരിതസ്ഥിതിയിൽ, ഒരു സാധാരണ ലിങ്ക്ഡ് ലിസ്റ്റ് ഉപയോഗിച്ചു, അതിന്റെ ഫലം NPE റൺടൈമിൽ. ConcurrentLinkedDeque ലേക്ക് മാറുന്നതിലൂടെയോ സമന്വയിപ്പിച്ച ബ്ലോക്കുകൾ വഴിയോ ഇത് പരിഹരിക്കാനാകും. ഞങ്ങൾ സ്വയം ആദ്യ ഓപ്ഷൻ തിരഞ്ഞെടുത്തു (https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/43).
2. മെമ്മറി ലീക്ക്; വിച്ഛേദിക്കുമ്പോൾ, കണക്ഷൻ വിവരങ്ങൾ ഇല്ലാതാക്കില്ല (https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/44).
3. സ്ട്രീമിംഗ് മോഡിൽ (സാമ്പിളിന്റെ അവസാനത്തിൽ വെബ്‌സോക്കറ്റ് അടച്ചിട്ടില്ലെങ്കിലും പ്ലാനിൽ പിന്നീട് ഉപയോഗിക്കുമ്പോൾ), പ്രതികരണ പാറ്റേണുകൾ പ്രവർത്തിക്കില്ല (https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/19).

ഇത് ഗിത്തബിലുള്ളവയിൽ ഒന്നാണ്. ഞങ്ങൾ ചെയ്തത്:

1. എടുത്തിട്ടുണ്ട് ഫോർക്ക് എലിറാൻ കോഗൻ (@elyrank) - ഇത് 1, 3 പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു
2. പരിഹരിച്ച പ്രശ്നം 2
3. 9.2.14 മുതൽ 9.3.12 വരെ പുതുക്കിയ ജെട്ടി
4. ത്രെഡ്‌ലോക്കലിൽ പൊതിഞ്ഞ സിമ്പിൾ ഡേറ്റ് ഫോർമാറ്റ്; SimpleDateFormat ത്രെഡ്-സുരക്ഷിതമല്ല, ഇത് റൺടൈമിൽ NPE-യിലേക്ക് നയിച്ചു
5. മറ്റൊരു മെമ്മറി ലീക്ക് പരിഹരിച്ചു (കണക്ഷൻ വിച്ഛേദിച്ചപ്പോൾ തെറ്റായി അടച്ചു)

എന്നിട്ടും ഒഴുകുന്നു!

ഒരു ദിവസം കൊണ്ടല്ല, രണ്ട് ദിവസങ്ങൾക്കുള്ളിൽ ഓർമ്മ തീർന്നു തുടങ്ങി. തീർത്തും സമയമില്ല, അതിനാൽ കുറച്ച് ത്രെഡുകൾ സമാരംഭിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു, പക്ഷേ നാല് ഏജന്റുമാരിൽ. കുറഞ്ഞത് ഒരാഴ്ചയെങ്കിലും ഇത് മതിയാകും.

രണ്ടു ദിവസം കഴിഞ്ഞു...

ഇപ്പോൾ Hazelcast മെമ്മറി തീർന്നു. രണ്ട് ദിവസത്തെ പരിശോധനയ്ക്ക് ശേഷം, ഹാസൽകാസ്റ്റ് മെമ്മറി കുറവിനെക്കുറിച്ച് പരാതിപ്പെടാൻ തുടങ്ങി, കുറച്ച് സമയത്തിന് ശേഷം ക്ലസ്റ്റർ തകർന്നു, നോഡുകൾ ഓരോന്നായി മരിക്കുന്നത് തുടരുകയാണെന്ന് ലോഗുകൾ കാണിച്ചു. ഞങ്ങൾ JVisualVM നെ hazelcast-ലേക്ക് കണക്റ്റുചെയ്‌തു, ഒരു “ഉയരുന്ന സോ” കണ്ടു - ഇത് പതിവായി GC എന്ന് വിളിക്കുന്നു, പക്ഷേ മെമ്മറി മായ്‌ക്കാൻ കഴിഞ്ഞില്ല.

hazelcast 3.4-ൽ, ഒരു മാപ്പ് / മൾട്ടിമാപ്പ് (map.destroy()) ഇല്ലാതാക്കുമ്പോൾ, മെമ്മറി പൂർണ്ണമായും സ്വതന്ത്രമാകുന്നില്ല:

github.com/hazelcast/hazelcast/issues/6317
github.com/hazelcast/hazelcast/issues/4888

ബഗ് ഇപ്പോൾ 3.5 ൽ പരിഹരിച്ചു, പക്ഷേ അക്കാലത്ത് അതൊരു പ്രശ്നമായിരുന്നു. ഡൈനാമിക് പേരുകളുള്ള പുതിയ മൾട്ടിമാപ്പുകൾ ഞങ്ങൾ സൃഷ്ടിക്കുകയും ഞങ്ങളുടെ യുക്തിക്കനുസരിച്ച് അവ ഇല്ലാതാക്കുകയും ചെയ്തു. കോഡ് ഇതുപോലെ കാണപ്പെട്ടു:

public void join(Authentication auth, String sub) {
    MultiMap<UUID, Authentication> sessions = instance.getMultiMap(sub);
    sessions.put(auth.getUserId(), auth);
}

public void leave(Authentication auth, String sub) {
    MultiMap<UUID, Authentication> sessions = instance.getMultiMap(sub);
    sessions.remove(auth.getUserId(), auth);

    if (sessions.size() == 0) {
        sessions.destroy();
    }
}

വിസോവ്:

service.join(auth1, "НОВЫЕ_СООБЩЕНИЯ_В_ОБСУЖДЕНИИ_UUID1");
service.join(auth2, "НОВЫЕ_СООБЩЕНИЯ_В_ОБСУЖДЕНИИ_UUID1");

ഓരോ സബ്‌സ്‌ക്രിപ്‌ഷനും മൾട്ടിമാപ്പ് സൃഷ്‌ടിക്കുകയും ആവശ്യമില്ലാത്തപ്പോൾ ഇല്ലാതാക്കുകയും ചെയ്‌തു. ഞങ്ങൾ മാപ്പ് ആരംഭിക്കാൻ തീരുമാനിച്ചു , കീ സബ്‌സ്‌ക്രിപ്‌ഷന്റെ പേരായിരിക്കും, മൂല്യങ്ങൾ സെഷൻ ഐഡന്റിഫയറുകളായിരിക്കും (ആവശ്യമെങ്കിൽ അതിൽ നിന്ന് നിങ്ങൾക്ക് ഉപയോക്തൃ ഐഡന്റിഫയറുകൾ ലഭിക്കും).

public void join(Authentication auth, String sub) {
    addValueToMap(sub, auth.getSessionId());
}

public void leave(Authentication auth, String sub) { 
    removeValueFromMap(sub, auth.getSessionId());
}

ചാർട്ടുകൾ മെച്ചപ്പെട്ടു.

ലോഡ് ടെസ്റ്റിംഗിനെക്കുറിച്ച് നമ്മൾ മറ്റെന്താണ് പഠിച്ചത്?

1. JSR223 ഗ്രൂവിയിൽ എഴുതുകയും കംപൈലേഷൻ കാഷെ ഉൾപ്പെടുത്തുകയും വേണം - ഇത് വളരെ വേഗതയുള്ളതാണ്. ലിങ്ക്.
2. സ്റ്റാൻഡേർഡ് ഗ്രാഫുകളേക്കാൾ Jmeter-Plugins ഗ്രാഫുകൾ മനസ്സിലാക്കാൻ എളുപ്പമാണ്. ലിങ്ക്.

ഹാസൽകാസ്റ്റുമായുള്ള ഞങ്ങളുടെ അനുഭവത്തെക്കുറിച്ച്

Hazelcast ഞങ്ങൾക്ക് ഒരു പുതിയ ഉൽപ്പന്നമായിരുന്നു, ഞങ്ങൾ ഇത് 3.4.1 പതിപ്പിൽ നിന്ന് പ്രവർത്തിക്കാൻ തുടങ്ങി, ഇപ്പോൾ ഞങ്ങളുടെ പ്രൊഡക്ഷൻ സെർവർ പതിപ്പ് 3.9.2 പ്രവർത്തിക്കുന്നു (എഴുതുമ്പോൾ, Hazelcast-ന്റെ ഏറ്റവും പുതിയ പതിപ്പ് 3.10 ആണ്).

ഐഡി ജനറേഷൻ

ഞങ്ങൾ പൂർണ്ണസംഖ്യ ഐഡന്റിഫയറുകൾ ഉപയോഗിച്ച് ആരംഭിച്ചു. ഒരു പുതിയ എന്റിറ്റിക്കായി നമുക്ക് മറ്റൊരു ലോംഗ് ആവശ്യമാണെന്ന് സങ്കൽപ്പിക്കുക. ഡാറ്റാബേസിലെ സീക്വൻസ് അനുയോജ്യമല്ല, ടേബിളുകൾ ഷാർഡിംഗിൽ ഉൾപ്പെടുന്നു - DB1-ൽ ഒരു സന്ദേശം ID=1 ഉം DB1-ൽ ഒരു സന്ദേശ ID=2 ഉം ഉണ്ടെന്ന് ഇത് മാറുന്നു, നിങ്ങൾക്ക് ഈ ഐഡി ഇലാസ്റ്റിക് സെർച്ചിലോ Hazelcast-ലോ ഇടാൻ കഴിയില്ല. , എന്നാൽ ഏറ്റവും മോശമായ കാര്യം, രണ്ട് ഡാറ്റാബേസുകളിൽ നിന്നുള്ള ഡാറ്റ ഒന്നായി സംയോജിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ (ഉദാഹരണത്തിന്, ഈ വരിക്കാർക്ക് ഒരു ഡാറ്റാബേസ് മതിയെന്ന് തീരുമാനിക്കുന്നത്). നിങ്ങൾക്ക് Hazelcast-ലേക്ക് നിരവധി AtomicLongs ചേർക്കുകയും അവിടെ കൌണ്ടർ സൂക്ഷിക്കുകയും ചെയ്യാം, തുടർന്ന് ഒരു പുതിയ ID നേടുന്നതിന്റെ പ്രകടനം incrementAndGet കൂടാതെ Hazelcast-ലേക്കുള്ള അഭ്യർത്ഥനയ്ക്കുള്ള സമയവുമാണ്. എന്നാൽ Hazelcast-ൽ കൂടുതൽ അനുയോജ്യമായ ഒന്ന് ഉണ്ട് - FlakeIdGenerator. ഓരോ ക്ലയന്റുമായി ബന്ധപ്പെടുമ്പോൾ, അവർക്ക് ഒരു ഐഡി ശ്രേണി നൽകുന്നു, ഉദാഹരണത്തിന്, ആദ്യത്തേത് - 1 മുതൽ 10 വരെ, രണ്ടാമത്തേത് - 000 മുതൽ 10 വരെ, അങ്ങനെ. ഇപ്പോൾ ക്ലയന്റിന് നൽകിയ ശ്രേണി അവസാനിക്കുന്നത് വരെ സ്വന്തമായി പുതിയ ഐഡന്റിഫയറുകൾ നൽകാനാകും. ഇത് വേഗത്തിൽ പ്രവർത്തിക്കുന്നു, എന്നാൽ നിങ്ങൾ ആപ്ലിക്കേഷൻ പുനരാരംഭിക്കുമ്പോൾ (ഒപ്പം Hazelcast ക്ലയന്റും), ഒരു പുതിയ സീക്വൻസ് ആരംഭിക്കുന്നു - അതിനാൽ ഒഴിവാക്കലുകൾ മുതലായവ. കൂടാതെ, ഐഡികൾ പൂർണ്ണസംഖ്യയായത് എന്തുകൊണ്ടാണെന്ന് ഡെവലപ്പർമാർക്ക് ശരിക്കും മനസ്സിലാകുന്നില്ല, പക്ഷേ വളരെ പൊരുത്തമില്ല. ഞങ്ങൾ എല്ലാം തൂക്കി UUID-കളിലേക്ക് മാറി.

വഴിയിൽ, ട്വിറ്റർ പോലെയാകാൻ ആഗ്രഹിക്കുന്നവർക്ക്, അത്തരമൊരു സ്നോകാസ്റ്റ് ലൈബ്രറി ഉണ്ട് - ഇത് ഹസൽകാസ്റ്റിന്റെ മുകളിലുള്ള സ്നോഫ്ലേക്കിന്റെ ഒരു നിർവ്വഹണമാണ്. നിങ്ങൾക്ക് ഇത് ഇവിടെ കാണാൻ കഴിയും:

github.com/noctarius/snowcast
github.com/twitter/snowflake

എന്നാൽ ഞങ്ങൾ ഇനി അതിലേക്ക് എത്തിയിട്ടില്ല.

TransactionalMap.replace

മറ്റൊരു ആശ്ചര്യം: TransactionalMap.replace പ്രവർത്തിക്കുന്നില്ല. ഇതാ ഒരു പരീക്ഷണം:

@Test
public void replaceInMap_putsAndGetsInsideTransaction() {

    hazelcastInstance.executeTransaction(context -> {
        HazelcastTransactionContextHolder.setContext(context);
        try {
            context.getMap("map").put("key", "oldValue");
            context.getMap("map").replace("key", "oldValue", "newValue");
            
            String value = (String) context.getMap("map").get("key");
            assertEquals("newValue", value);

            return null;
        } finally {
            HazelcastTransactionContextHolder.clearContext();
        }        
    });
}

Expected : newValue
Actual : oldValue

getForUpdate ഉപയോഗിച്ച് എനിക്ക് സ്വന്തമായി പകരം എഴുതേണ്ടി വന്നു:

protected <K,V> boolean replaceInMap(String mapName, K key, V oldValue, V newValue) {
    TransactionalTaskContext context = HazelcastTransactionContextHolder.getContext();
    if (context != null) {
        log.trace("[CACHE] Replacing value in a transactional map");
        TransactionalMap<K, V> map = context.getMap(mapName);
        V value = map.getForUpdate(key);
        if (oldValue.equals(value)) {
            map.put(key, newValue);
            return true;
        }

        return false;
    }
    log.trace("[CACHE] Replacing value in a not transactional map");
    IMap<K, V> map = hazelcastInstance.getMap(mapName);
    return map.replace(key, oldValue, newValue);
}

സാധാരണ ഡാറ്റാ ഘടനകൾ മാത്രമല്ല, അവയുടെ ഇടപാട് പതിപ്പുകളും പരിശോധിക്കുക. IMap പ്രവർത്തിക്കുന്നു, എന്നാൽ TransactionalMap നിലവിലില്ല.

പ്രവർത്തനരഹിതമായ ഒരു പുതിയ JAR ചേർക്കുക

ആദ്യം, ഞങ്ങളുടെ ക്ലാസുകളുടെ ഒബ്ജക്റ്റുകൾ Hazelcast-ൽ രേഖപ്പെടുത്താൻ ഞങ്ങൾ തീരുമാനിച്ചു. ഉദാഹരണത്തിന്, ഞങ്ങൾക്ക് ഒരു ആപ്ലിക്കേഷൻ ക്ലാസ് ഉണ്ട്, അത് സംരക്ഷിക്കാനും വായിക്കാനും ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. രക്ഷിക്കും:

IMap<UUID, Application> map = hazelcastInstance.getMap("application");
map.set(id, application);

ഞങ്ങൾ വായിക്കുന്നു:

IMap<UUID, Application> map = hazelcastInstance.getMap("application");
return map.get(id);

എല്ലാം പ്രവർത്തിക്കുന്നു. തുടർന്ന് തിരയുന്നതിനായി Hazelcast-ൽ ഒരു സൂചിക നിർമ്മിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു:

map.addIndex("subscriberId", false);

ഒരു പുതിയ എന്റിറ്റി എഴുതുമ്പോൾ, അവർക്ക് ClassNotFoundException ലഭിക്കാൻ തുടങ്ങി. Hazelcast സൂചികയിലേക്ക് ചേർക്കാൻ ശ്രമിച്ചു, പക്ഷേ ഞങ്ങളുടെ ക്ലാസിനെക്കുറിച്ച് ഒന്നും അറിയില്ലായിരുന്നു, കൂടാതെ ഈ ക്ലാസുള്ള ഒരു JAR അതിന് നൽകണമെന്ന് ആഗ്രഹിച്ചു. ഞങ്ങൾ അത് ചെയ്തു, എല്ലാം പ്രവർത്തിച്ചു, പക്ഷേ ഒരു പുതിയ പ്രശ്നം പ്രത്യക്ഷപ്പെട്ടു: ക്ലസ്റ്റർ പൂർണ്ണമായും നിർത്താതെ JAR എങ്ങനെ അപ്ഡേറ്റ് ചെയ്യാം? നോഡ്-ബൈ-നോഡ് അപ്‌ഡേറ്റ് സമയത്ത് Hazelcast പുതിയ JAR എടുക്കുന്നില്ല. ഈ ഘട്ടത്തിൽ സൂചിക തിരയലില്ലാതെ ജീവിക്കാമെന്ന് ഞങ്ങൾ തീരുമാനിച്ചു. എല്ലാത്തിനുമുപരി, നിങ്ങൾ ഒരു കീ-മൂല്യം സ്റ്റോറായി Hazelcast ഉപയോഗിക്കുകയാണെങ്കിൽ, എല്ലാം പ്രവർത്തിക്കുമോ? ശരിക്കുമല്ല. ഇവിടെയും IMap, TransactionalMap എന്നിവയുടെ സ്വഭാവം വ്യത്യസ്തമാണ്. IMap ശ്രദ്ധിക്കാത്തിടത്ത്, TransactionalMap ഒരു പിശക് വരുത്തുന്നു.

IMap. ഞങ്ങൾ 5000 വസ്തുക്കൾ എഴുതുന്നു, അവ വായിക്കുക. എല്ലാം പ്രതീക്ഷിക്കുന്നു.

@Test
void get5000() {
    IMap<UUID, Application> map = hazelcastInstance.getMap("application");
    UUID subscriberId = UUID.randomUUID();

    for (int i = 0; i < 5000; i++) {
        UUID id = UUID.randomUUID();
        String title = RandomStringUtils.random(5);
        Application application = new Application(id, title, subscriberId);
        
        map.set(id, application);
        Application retrieved = map.get(id);
        assertEquals(id, retrieved.getId());
    }
}

എന്നാൽ ഇത് ഒരു ഇടപാടിൽ പ്രവർത്തിക്കില്ല, ഞങ്ങൾക്ക് ഒരു ClassNotFoundException ലഭിക്കും:

@Test
void get_transaction() {
    IMap<UUID, Application> map = hazelcastInstance.getMap("application_t");
    UUID subscriberId = UUID.randomUUID();
    UUID id = UUID.randomUUID();

    Application application = new Application(id, "qwer", subscriberId);
    map.set(id, application);
    
    Application retrievedOutside = map.get(id);
    assertEquals(id, retrievedOutside.getId());

    hazelcastInstance.executeTransaction(context -> {
        HazelcastTransactionContextHolder.setContext(context);
        try {
            TransactionalMap<UUID, Application> transactionalMap = context.getMap("application_t");
            Application retrievedInside = transactionalMap.get(id);

            assertEquals(id, retrievedInside.getId());
            return null;
        } finally {
            HazelcastTransactionContextHolder.clearContext();
        }
    });
}

3.8-ൽ, യൂസർ ക്ലാസ് ഡിപ്ലോയ്‌മെന്റ് മെക്കാനിസം പ്രത്യക്ഷപ്പെട്ടു. നിങ്ങൾക്ക് ഒരു മാസ്റ്റർ നോഡ് നിശ്ചയിക്കുകയും അതിൽ JAR ഫയൽ അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യാം.

ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ സമീപനം പൂർണ്ണമായും മാറ്റി: ഞങ്ങൾ അത് സ്വയം JSON-ലേക്ക് സീരിയലൈസ് ചെയ്യുകയും Hazelcast-ൽ സംരക്ഷിക്കുകയും ചെയ്യുന്നു. Hazelcast-ന് ഞങ്ങളുടെ ക്ലാസുകളുടെ ഘടന അറിയേണ്ടതില്ല, പ്രവർത്തനരഹിതമാക്കാതെ തന്നെ അപ്‌ഡേറ്റ് ചെയ്യാം. ഡൊമെയ്ൻ ഒബ്‌ജക്‌റ്റുകളുടെ പതിപ്പ് നിയന്ത്രിക്കുന്നത് ആപ്ലിക്കേഷൻ ആണ്. ആപ്ലിക്കേഷന്റെ വ്യത്യസ്‌ത പതിപ്പുകൾ ഒരേ സമയം പ്രവർത്തിക്കാം, പുതിയ ആപ്ലിക്കേഷൻ പുതിയ ഫീൽഡുകളുള്ള ഒബ്‌ജക്‌റ്റുകൾ എഴുതുമ്പോൾ ഒരു സാഹചര്യം സാധ്യമാണ്, എന്നാൽ പഴയതിന് ഈ ഫീൽഡുകളെക്കുറിച്ച് ഇതുവരെ അറിയില്ല. അതേ സമയം, പുതിയ ഫീൽഡുകൾ ഇല്ലാത്ത പഴയ ആപ്ലിക്കേഷൻ എഴുതിയ ഒബ്‌ജക്‌റ്റുകൾ പുതിയ ആപ്ലിക്കേഷൻ വായിക്കുന്നു. ആപ്ലിക്കേഷനിൽ അത്തരം സാഹചര്യങ്ങൾ ഞങ്ങൾ കൈകാര്യം ചെയ്യുന്നു, എന്നാൽ ലാളിത്യത്തിനായി ഞങ്ങൾ ഫീൽഡുകൾ മാറ്റുകയോ ഇല്ലാതാക്കുകയോ ചെയ്യുന്നില്ല, പുതിയ ഫീൽഡുകൾ ചേർത്തുകൊണ്ട് ക്ലാസുകൾ വികസിപ്പിക്കുക മാത്രമാണ് ഞങ്ങൾ ചെയ്യുന്നത്.

ഉയർന്ന പ്രകടനം ഞങ്ങൾ എങ്ങനെ ഉറപ്പാക്കുന്നു

Hazelcast ലേക്കുള്ള നാല് യാത്രകൾ - നല്ലത്, രണ്ട് ഡാറ്റാബേസിലേക്ക് - മോശം

ഡാറ്റയ്‌ക്കായി കാഷെയിലേക്ക് പോകുന്നത് ഡാറ്റാബേസിലേക്ക് പോകുന്നതിനേക്കാൾ മികച്ചതാണ്, എന്നാൽ ഉപയോഗിക്കാത്ത റെക്കോർഡുകൾ സംഭരിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല. വികസനത്തിന്റെ അവസാന ഘട്ടം വരെ എന്ത് കാഷെ ചെയ്യണം എന്നതിനെക്കുറിച്ചുള്ള തീരുമാനം ഞങ്ങൾ ഉപേക്ഷിക്കുന്നു. പുതിയ പ്രവർത്തനം കോഡ് ചെയ്യുമ്പോൾ, ഞങ്ങൾ PostgreSQL-ലെ എല്ലാ ചോദ്യങ്ങളുടെയും ലോഗിംഗ് ഓണാക്കുകയും (log_min_duration_statement to 0) 20 മിനിറ്റ് ലോഡ് ടെസ്റ്റിംഗ് നടത്തുകയും ചെയ്യുന്നു. ശേഖരിച്ച ലോഗുകൾ ഉപയോഗിച്ച്, pgFouine, pgBadger പോലുള്ള യൂട്ടിലിറ്റികൾക്ക് വിശകലന റിപ്പോർട്ടുകൾ നിർമ്മിക്കാൻ കഴിയും. റിപ്പോർട്ടുകളിൽ, ഞങ്ങൾ പ്രാഥമികമായി മന്ദഗതിയിലുള്ളതും ഇടയ്ക്കിടെയുള്ളതുമായ ചോദ്യങ്ങൾക്കായി നോക്കുന്നു. മന്ദഗതിയിലുള്ള ചോദ്യങ്ങൾക്ക്, ഞങ്ങൾ ഒരു എക്സിക്യൂഷൻ പ്ലാൻ (എക്‌പ്ലെയ്ൻ) നിർമ്മിക്കുകയും അത്തരം ഒരു അന്വേഷണം ത്വരിതപ്പെടുത്താൻ കഴിയുമോ എന്ന് വിലയിരുത്തുകയും ചെയ്യുന്നു. ഒരേ ഇൻപുട്ട് ഡാറ്റയ്‌ക്കായുള്ള പതിവ് അഭ്യർത്ഥനകൾ കാഷെയിലേക്ക് നന്നായി യോജിക്കുന്നു. ഞങ്ങൾ ചോദ്യങ്ങൾ "ഫ്ലാറ്റ്" ആയി നിലനിർത്താൻ ശ്രമിക്കുന്നു, ഓരോ ചോദ്യത്തിനും ഒരു ടേബിൾ.

പ്രവർത്തനം

ഒരു ഓൺലൈൻ സേവനമെന്ന നിലയിൽ എസ്വി 2017 ലെ വസന്തകാലത്ത് പ്രവർത്തനക്ഷമമാക്കി, ഒരു പ്രത്യേക ഉൽപ്പന്നമെന്ന നിലയിൽ, എസ്വി 2017 നവംബറിൽ പുറത്തിറങ്ങി (അക്കാലത്ത് ബീറ്റ പതിപ്പ് നിലയിലായിരുന്നു).

ഒരു വർഷത്തിലേറെയായി പ്രവർത്തനത്തിൽ, സിബി ഓൺലൈൻ സേവനത്തിന്റെ പ്രവർത്തനത്തിൽ ഗുരുതരമായ പ്രശ്നങ്ങളൊന്നും ഉണ്ടായിട്ടില്ല. ഞങ്ങൾ ഓൺലൈൻ സേവനം നിരീക്ഷിക്കുന്നു സബ്ബിക്സ്, ശേഖരിക്കുകയും വിന്യസിക്കുകയും ചെയ്യുക മുള.

SV സെർവർ വിതരണം നേറ്റീവ് പാക്കേജുകളുടെ രൂപത്തിലാണ് വിതരണം ചെയ്യുന്നത്: RPM, DEB, MSI. കൂടാതെ വിൻഡോസിനായി ഞങ്ങൾ ഒരൊറ്റ EXE രൂപത്തിൽ ഒരൊറ്റ ഇൻസ്റ്റാളർ നൽകുന്നു, അത് ഒരു മെഷീനിൽ സെർവർ, Hazelcast, Elasticsearch എന്നിവ ഇൻസ്റ്റാൾ ചെയ്യുന്നു. ഇൻസ്റ്റാളേഷന്റെ ഈ പതിപ്പിനെ ഞങ്ങൾ ആദ്യം "ഡെമോ" പതിപ്പ് എന്നാണ് പരാമർശിച്ചത്, എന്നാൽ ഇത് ഏറ്റവും ജനപ്രിയമായ വിന്യാസ ഓപ്ഷനാണെന്ന് ഇപ്പോൾ വ്യക്തമായി.

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