ക്വാർക്കസ് നിർബന്ധിതവും ക്രിയാത്മകവുമായ പ്രോഗ്രാമിംഗിനെ എങ്ങനെ സംയോജിപ്പിക്കുന്നു

ഈ വർഷം കണ്ടെയ്‌നർ തീമുകൾ ഗൗരവമായി വികസിപ്പിക്കാൻ ഞങ്ങൾ പദ്ധതിയിടുന്നു, ക്ലൗഡ്-നേറ്റീവ് ജാവ и കുബേർനെറ്റ്. ഈ വിഷയങ്ങളുടെ യുക്തിസഹമായ തുടർച്ച ക്വാർക്കസ് ചട്ടക്കൂടിനെക്കുറിച്ചുള്ള ഒരു കഥയായിരിക്കും പരിഗണിച്ചു ഹബ്രെയിൽ. ഇന്നത്തെ ലേഖനം "സബറ്റോമിക് സൂപ്പർഫാസ്റ്റ് ജാവ"യുടെ രൂപകൽപ്പനയെ കുറിച്ചും ക്വാർക്കസ് എന്റർപ്രൈസിന് നൽകുന്ന വാഗ്ദാനത്തെ കുറിച്ചും കുറവാണ്.

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

സൂപ്പർഫാസ്റ്റ് സബ് ആറ്റോമിക് ജാവ ഒരു പുതിയ തലത്തിലെത്തി!

42 റിലീസുകൾ, 8 മാസത്തെ കമ്മ്യൂണിറ്റി വർക്ക്, 177 അതിശയിപ്പിക്കുന്ന ഡെവലപ്പർമാർ - എല്ലാറ്റിന്റെയും ഫലം 2019 നവംബറിൽ പുറത്തിറങ്ങി. ക്വാർക്കസ് 1.0, പ്രോജക്റ്റിന്റെ വികസനത്തിലെ ഒരു സുപ്രധാന നാഴികക്കല്ല് അടയാളപ്പെടുത്തുന്ന ഒരു റിലീസ്, ധാരാളം രസകരമായ സവിശേഷതകളും കഴിവുകളും വാഗ്ദാനം ചെയ്യുന്നു (നിങ്ങൾക്ക് അവയെക്കുറിച്ച് കൂടുതൽ വായിക്കാം പ്രഖ്യാപനം).

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

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

ആദ്യം, നമുക്ക് ചരിത്രം നോക്കാം.

സ്ട്രീമുകളും കണ്ടെയ്നറുകളും

പതിപ്പ് 8u131 മുതൽ, എർഗണോമിക്സ് പ്രവർത്തനത്തിലെ മെച്ചപ്പെടുത്തലുകൾ കാരണം ജാവ കൂടുതലോ കുറവോ കണ്ടെയ്നറുകൾ പിന്തുണയ്ക്കാൻ തുടങ്ങി. പ്രത്യേകിച്ചും, JVM-ന് ഇപ്പോൾ അത് എത്ര പ്രൊസസർ കോറുകളിൽ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് അറിയാം, അതനുസരിച്ച് ത്രെഡ് പൂളുകൾ-സാധാരണയായി ഫോർക്ക്/ജോയിൻ പൂളുകൾ കോൺഫിഗർ ചെയ്യാൻ കഴിയും. തീർച്ചയായും, ഇത് വളരെ മികച്ചതാണ്, എന്നാൽ നമുക്ക് HTTP സെർവ്‌ലെറ്റുകൾ ഉപയോഗിക്കുകയും ടോംകാറ്റ്, ജെട്ടി മുതലായവയിൽ പ്രവർത്തിക്കുകയും ചെയ്യുന്ന ഒരു പരമ്പരാഗത വെബ് ആപ്ലിക്കേഷൻ ഉണ്ടെന്ന് പറയാം. തൽഫലമായി, ഈ ആപ്ലിക്കേഷൻ ഓരോ അഭ്യർത്ഥനയ്ക്കും ഒരു പ്രത്യേക ത്രെഡ് നൽകുകയും I/O പ്രവർത്തനങ്ങൾക്കായി കാത്തിരിക്കുമ്പോൾ ഈ ത്രെഡ് തടയാൻ അനുവദിക്കുകയും ചെയ്യും, ഉദാഹരണത്തിന്, ഡാറ്റാബേസ്, ഫയലുകൾ അല്ലെങ്കിൽ മറ്റ് സേവനങ്ങൾ ആക്സസ് ചെയ്യുമ്പോൾ. അതായത്, അത്തരമൊരു ആപ്ലിക്കേഷന്റെ വലുപ്പം ലഭ്യമായ കോറുകളുടെ എണ്ണത്തെ ആശ്രയിക്കുന്നില്ല, മറിച്ച് ഒരേസമയം അഭ്യർത്ഥനകളുടെ എണ്ണത്തെ ആശ്രയിച്ചിരിക്കുന്നു. കൂടാതെ, കോറുകളുടെ എണ്ണത്തിൽ കുബെർനെറ്റസിലെ ക്വാട്ടകളോ പരിധികളോ ഇവിടെ വലിയ തോതിൽ സഹായകമാകില്ല, മാത്രമല്ല കാര്യം ആത്യന്തികമായി ത്രോട്ടിലിംഗിൽ അവസാനിക്കും എന്നാണ്.

മെമ്മറി ക്ഷീണം

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

ക്വാട്ടകളും പരിധികളും

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

പിന്നെ ഇതെല്ലാം എന്തുചെയ്യണം?

ലളിതമായി പറഞ്ഞാൽ, അസിൻക്രണസ്, നോൺ-ബ്ലോക്കിംഗ് I/O ലൈബ്രറികളും Netty പോലുള്ള ചട്ടക്കൂടുകളും ഉപയോഗിക്കുക, Vert.x അല്ലെങ്കിൽ അക്ക. അവയുടെ പ്രതിപ്രവർത്തന സ്വഭാവം കാരണം കണ്ടെയ്‌നറുകളിൽ പ്രവർത്തിക്കാൻ അവ വളരെ അനുയോജ്യമാണ്. I/O തടയാത്തതിന് നന്ദി, ഒരേ ത്രെഡിന് ഒരേസമയം ഒന്നിലധികം അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. ഒരു അഭ്യർത്ഥന I/O ഫലങ്ങൾക്കായി കാത്തിരിക്കുമ്പോൾ, ത്രെഡ് പ്രോസസ്സിംഗ് അത് റിലീസ് ചെയ്യുകയും മറ്റൊരു അഭ്യർത്ഥന ഏറ്റെടുക്കുകയും ചെയ്യുന്നു. ഒടുവിൽ I/O ഫലങ്ങൾ വരുമ്പോൾ, ആദ്യ അഭ്യർത്ഥനയുടെ പ്രോസസ്സിംഗ് തുടരുന്നു. ഒരേ ത്രെഡിനുള്ളിലെ അഭ്യർത്ഥനകളുടെ ഇന്റർലീവ് പ്രോസസ്സിംഗ് വഴി, നിങ്ങൾക്ക് മൊത്തം ത്രെഡുകളുടെ എണ്ണം കുറയ്ക്കാനും അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള വിഭവ ഉപഭോഗം കുറയ്ക്കാനും കഴിയും.

നോൺ-ബ്ലോക്കിംഗ് I/O ഉപയോഗിച്ച്, സമാന്തരമായി നടപ്പിലാക്കാൻ കഴിയുന്ന I/O ത്രെഡുകളുടെ എണ്ണം നിർണ്ണയിക്കുന്നതിനാൽ കോറുകളുടെ എണ്ണം ഒരു പ്രധാന പാരാമീറ്ററായി മാറുന്നു. ശരിയായി ഉപയോഗിക്കുമ്പോൾ, കോറുകൾക്കിടയിൽ ലോഡ് ഫലപ്രദമായി വിതരണം ചെയ്യാനും കുറച്ച് ഉറവിടങ്ങളുള്ള ഉയർന്ന ജോലിഭാരങ്ങൾ കൈകാര്യം ചെയ്യാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

എങ്ങനെ, അതെല്ലാം?

ഇല്ല, മറ്റെന്തെങ്കിലും ഉണ്ട്. റിയാക്ടീവ് പ്രോഗ്രാമിംഗ് വിഭവങ്ങൾ മികച്ച രീതിയിൽ ഉപയോഗിക്കാൻ സഹായിക്കുന്നു, മാത്രമല്ല ഒരു വിലയും നൽകുന്നു. പ്രത്യേകിച്ചും, നോൺ-ബ്ലോക്കിംഗ് തത്വങ്ങൾക്കനുസൃതമായി കോഡ് മാറ്റിയെഴുതുകയും I/O ത്രെഡുകൾ തടയുന്നത് ഒഴിവാക്കുകയും വേണം. ഇത് വികസനത്തിന്റെയും നിർവ്വഹണത്തിന്റെയും തികച്ചും വ്യത്യസ്തമായ മാതൃകയാണ്. കൂടാതെ, ഉപയോഗപ്രദമായ ധാരാളം ലൈബ്രറികൾ ഇവിടെയുണ്ടെങ്കിലും, ഇത് ഇപ്പോഴും സാധാരണ ചിന്താരീതിയിൽ സമൂലമായ മാറ്റമാണ്.

ആദ്യം, അസമന്വിതമായി പ്രവർത്തിക്കുന്ന കോഡ് എങ്ങനെ എഴുതാമെന്ന് നിങ്ങൾ പഠിക്കേണ്ടതുണ്ട്. നിങ്ങൾ നോൺ-ബ്ലോക്കിംഗ് I/O ഉപയോഗിക്കാൻ തുടങ്ങിക്കഴിഞ്ഞാൽ, ഒരു അഭ്യർത്ഥനയ്ക്കുള്ള പ്രതികരണം ലഭിക്കുമ്പോൾ എന്താണ് സംഭവിക്കേണ്ടതെന്ന് നിങ്ങൾ വ്യക്തമായി വ്യക്തമാക്കേണ്ടതുണ്ട്. തടയലും കാത്തിരിപ്പും ഇനി പ്രവർത്തിക്കില്ല. പകരം, നിങ്ങൾക്ക് കോൾബാക്കുകൾ കൈമാറാം, റിയാക്ടീവ് പ്രോഗ്രാമിംഗ് അല്ലെങ്കിൽ തുടർച്ച ഉപയോഗിക്കുക. എന്നാൽ അത് മാത്രമല്ല: നോൺ-ബ്ലോക്കിംഗ് I/O ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾക്ക് എല്ലായിടത്തും തടയാത്ത സെർവറുകളും ക്ലയന്റുകളും ആവശ്യമാണ്. എച്ച്ടിടിപിയുടെ കാര്യത്തിൽ, എല്ലാം ലളിതമാണ്, പക്ഷേ ഡാറ്റാബേസുകൾ, ഫയൽ സിസ്റ്റങ്ങൾ എന്നിവയും അതിലേറെയും ഉണ്ട്.

മൊത്തത്തിലുള്ള എൻഡ്-ടു-എൻഡ് റിയാക്‌റ്റിവിറ്റി കാര്യക്ഷമത വർദ്ധിപ്പിക്കുമെങ്കിലും, പ്രായോഗികമായി അത്തരമൊരു മാറ്റം ബുദ്ധിമുട്ടാണ്. അതിനാൽ, ക്രിയാത്മകവും അനിവാര്യവുമായ കോഡ് സംയോജിപ്പിക്കാനുള്ള കഴിവ് ഇനിപ്പറയുന്നവയ്ക്കായി ഒരു മുൻവ്യവസ്ഥയായി മാറുന്നു:

1. സോഫ്‌റ്റ്‌വെയർ സിസ്റ്റത്തിന്റെ ഏറ്റവും ലോഡുചെയ്ത മേഖലകളിൽ വിഭവങ്ങൾ ഫലപ്രദമായി ഉപയോഗിക്കുക;
2. അതിന്റെ ശേഷിക്കുന്ന ഭാഗങ്ങളിൽ ലളിതമായ ശൈലി കോഡ് ഉപയോഗിക്കുക.

ക്വാർക്കസിനെ പരിചയപ്പെടുത്തുന്നു

യഥാർത്ഥത്തിൽ, ഇതാണ് ക്വാർക്കസിന്റെ സാരാംശം - ഒരൊറ്റ റൺടൈം പരിതസ്ഥിതിയിൽ പ്രതിപ്രവർത്തനവും അനിവാര്യവുമായ മോഡലുകൾ സംയോജിപ്പിക്കുക.

Quarkus, Vert.x, Netty എന്നിവയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, ഡെവലപ്പറെ സഹായിക്കുന്നതിന് മുകളിൽ നിരവധി റിയാക്ടീവ് ചട്ടക്കൂടുകളും വിപുലീകരണങ്ങളും ഉണ്ട്. എച്ച്ടിടിപി മൈക്രോസർവീസുകൾ മാത്രമല്ല, ഇവന്റ്-ഡ്രൈവ് ആർക്കിടെക്ചറുകളും നിർമ്മിക്കുന്നതിനാണ് ക്വാർക്കസ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. അതിന്റെ പ്രതിപ്രവർത്തന സ്വഭാവം കാരണം, ഇത് സന്ദേശമയയ്‌ക്കൽ സംവിധാനങ്ങളിൽ (അപ്പാച്ചെ കാഫ്ക, എഎംക്യുപി, മുതലായവ) വളരെ ഫലപ്രദമായി പ്രവർത്തിക്കുന്നു.

നിർബന്ധിതവും ക്രിയാത്മകവുമായ കോഡിനായി ഒരേ റിയാക്ടീവ് എഞ്ചിൻ എങ്ങനെ ഉപയോഗിക്കാം എന്നതാണ് തന്ത്രം.

ക്വാർക്കസ് ഇത് മികച്ച രീതിയിൽ ചെയ്യുന്നു. നിർബന്ധിതവും പ്രതിപ്രവർത്തനവും തമ്മിലുള്ള തിരഞ്ഞെടുപ്പ് വ്യക്തമാണ് - രണ്ടിനും ഒരു റിയാക്ടീവ് കേർണൽ ഉപയോഗിക്കുക. ഇവന്റ്-ലൂപ്പ് ത്രെഡിലൂടെ കടന്നുപോകുന്ന മിക്കവാറും എല്ലാം കൈകാര്യം ചെയ്യുന്ന വേഗതയേറിയതും തടയാത്തതുമായ കോഡാണ് ഇത് ശരിക്കും സഹായിക്കുന്നത്, അതായത് IO ത്രെഡ്. എന്നാൽ നിങ്ങൾക്ക് ക്ലാസിക് REST അല്ലെങ്കിൽ ക്ലയന്റ്-സൈഡ് ആപ്ലിക്കേഷനുകൾ ഉണ്ടെങ്കിൽ, ക്വാർക്കസിന് അത്യാവശ്യമായ ഒരു പ്രോഗ്രാമിംഗ് മോഡൽ തയ്യാറാണ്. ഉദാഹരണത്തിന്, ക്വാർക്കസിലെ HTTP പിന്തുണ ഒരു നോൺ-ബ്ലോക്കിംഗ്, റിയാക്ടീവ് എഞ്ചിൻ (Eclipse Vert.x, Netty) ഉപയോഗത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. നിങ്ങളുടെ ആപ്ലിക്കേഷന് ലഭിച്ച എല്ലാ HTTP അഭ്യർത്ഥനകളും ആദ്യം ഒരു ഇവന്റ് ലൂപ്പിലൂടെ (IO ത്രെഡ്) കൈമാറുകയും അഭ്യർത്ഥനകൾ നിയന്ത്രിക്കുന്ന കോഡിന്റെ ഭാഗത്തേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു. ലക്ഷ്യസ്ഥാനത്തെ ആശ്രയിച്ച്, അഭ്യർത്ഥന മാനേജുമെന്റ് കോഡ് ഒരു പ്രത്യേക ത്രെഡിനുള്ളിൽ വിളിക്കാം (വർക്കർ ത്രെഡ് എന്ന് വിളിക്കപ്പെടുന്ന, സെർവ്ലെറ്റുകളുടെയും Jax-RS-ന്റെയും കാര്യത്തിൽ ഉപയോഗിക്കുന്നു) അല്ലെങ്കിൽ ഉറവിടം I/O ത്രെഡ് (റിയാക്ടീവ് റൂട്ട്) ഉപയോഗിക്കുക.

മെസേജിംഗ് സിസ്റ്റം കണക്ടറുകൾ, Vert.x എഞ്ചിന്റെ മുകളിൽ പ്രവർത്തിക്കുന്ന നോൺ-ബ്ലോക്ക് ക്ലയന്റുകളെ ഉപയോഗിക്കുന്നു. അതിനാൽ, നിങ്ങൾക്ക് സന്ദേശമയയ്ക്കൽ മിഡിൽവെയർ സിസ്റ്റങ്ങളിൽ നിന്ന് ഫലപ്രദമായി സന്ദേശങ്ങൾ അയയ്ക്കാനും സ്വീകരിക്കാനും പ്രോസസ്സ് ചെയ്യാനും കഴിയും.

സൈറ്റിൽ Quarkus.io ക്വാർക്കസ് ഉപയോഗിച്ച് ആരംഭിക്കാൻ നിങ്ങളെ സഹായിക്കുന്ന ചില നല്ല ട്യൂട്ടോറിയലുകൾ ഇതാ:

• റിയാക്ടീവ് റൂട്ടുകൾ ഉപയോഗിക്കുന്നു
• റിയാക്ടീവ് SQL ക്ലയന്റുകൾ
• റിയാക്ടീവ് മെസേജിംഗിനൊപ്പം അപ്പാച്ചെ കാഫ്ക ഉപയോഗിക്കുന്നു
• റിയാക്ടീവ് മെസേജിംഗിനൊപ്പം AMQP ഉപയോഗിക്കുന്നു
• Vertx API ഉപയോഗിക്കുന്നു

ഒരു ബ്രൗസറിൽ റിയാക്ടീവ് പ്രോഗ്രാമിംഗിന്റെ വിവിധ വശങ്ങൾ നിങ്ങളെ പഠിപ്പിക്കുന്നതിന് ഞങ്ങൾ ഓൺലൈൻ ഹാൻഡ്-ഓൺ ട്യൂട്ടോറിയലുകളും സൃഷ്ടിച്ചിട്ടുണ്ട്, IDE ആവശ്യമില്ല, കമ്പ്യൂട്ടർ ആവശ്യമില്ല. നിങ്ങൾക്ക് ഈ പാഠങ്ങൾ കണ്ടെത്താനാകും ഇവിടെ.

ഉപയോഗപ്രദമായ ഉറവിടങ്ങൾ

• ക്വാർക്കസ് പരീക്ഷിക്കുന്നതിനുള്ള 4 കാരണങ്ങൾ
• ക്വാർക്കസ് പ്രൊജക്റ്റ് വെബ്സൈറ്റ് - quarkus.io
• GitHub-ലെ ക്വാർക്കസ് പ്രോജക്റ്റ് - github.com/quarkusio/quarkus
• ക്വാർക്കസ് പ്രൊജക്റ്റ് ട്വിറ്റർ - twitter.com/QuarkusIO
• ക്വാർക്കസ് പ്രോജക്റ്റ് ചാറ്റ് - quarkusio.zulipchat.com
• ക്വാർക്കസ് പ്രോജക്ട് ഫോറങ്ങൾ - group.google.com/forum/#!ഫോറം/quarkus-dev

വിഷയവുമായി പരിചയപ്പെടാൻ ക്വാർക്കസിനെക്കുറിച്ചുള്ള 10 വീഡിയോ പാഠങ്ങൾ

അവർ വെബ്സൈറ്റിൽ പറയുന്നതുപോലെ Quarkus.io, ക്വാർക്കസ് - ആണ് കുബേർനെറ്റ്-ഓറിയന്റഡ് ജാവ സ്റ്റാക്ക്, GraalVM, OpenJDK HotSpot എന്നിവയ്‌ക്കായി രൂപകൽപ്പന ചെയ്‌തതും മികച്ച ജാവ ലൈബ്രറികളിൽ നിന്നും മാനദണ്ഡങ്ങളിൽ നിന്നും കൂട്ടിച്ചേർക്കപ്പെട്ടതുമാണ്.

വിഷയം മനസ്സിലാക്കാൻ നിങ്ങളെ സഹായിക്കുന്നതിന്, ക്വാർക്കസിന്റെ വിവിധ വശങ്ങളും അതിന്റെ ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങളും ഉൾക്കൊള്ളുന്ന 10 വീഡിയോ ട്യൂട്ടോറിയലുകൾ ഞങ്ങൾ തിരഞ്ഞെടുത്തു:

1. ക്വാർക്കസ് അവതരിപ്പിക്കുന്നു: കുബർനെറ്റസിനായുള്ള അടുത്ത തലമുറ ജാവ ചട്ടക്കൂട്

തോമസ് ക്വാർൺസ്ട്രോമും ജേസൺ ഗ്രീനും എഴുതിയത്
കുബർനെറ്റുകൾക്കും സെർവർലെസ് എൻവയോൺമെന്റുകൾക്കുമായി ഒരു ജാവ പ്ലാറ്റ്‌ഫോം സൃഷ്‌ടിക്കുക എന്നതാണ് ക്വാർക്കസ് പ്രോജക്‌റ്റിന്റെ ലക്ഷ്യം, കൂടാതെ റിയാക്‌റ്റീവും നിർബന്ധിതവുമായ പ്രോഗ്രാമിംഗ് മോഡലുകളെ ഒരൊറ്റ റൺടൈം പരിതസ്ഥിതിയിലേക്ക് സംയോജിപ്പിക്കുക, അതുവഴി ഡെവലപ്പർമാർക്ക് വിശാലമായ ശ്രേണിയിലുള്ള ആപ്ലിക്കേഷൻ ആർക്കിടെക്‌ചറുകളിൽ പ്രവർത്തിക്കുമ്പോൾ അവരുടെ സമീപനം അയവില്ലാതെ മാറ്റാനാകും. ചുവടെയുള്ള ആമുഖ പ്രഭാഷണത്തിൽ കൂടുതൽ കണ്ടെത്തുക.

2. ക്വാർക്കസ്: സൂപ്പർഫാസ്റ്റ് സബ്ടോമിക് ജാവ

എഴുതിയത്: ബർ സട്ടർ
DevNation Live-ൽ നിന്നുള്ള ഈ വീഡിയോ ട്യൂട്ടോറിയൽ, Kubernetes/OpenShift പരിതസ്ഥിതിയിൽ എന്റർപ്രൈസ് Java ആപ്ലിക്കേഷനുകൾ, API-കൾ, മൈക്രോസർവീസുകൾ, സെർവർലെസ് ഫംഗ്‌ഷനുകൾ എന്നിവ ഒപ്റ്റിമൈസ് ചെയ്യാൻ Quarkus എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണിക്കുന്നു, അവയെ വളരെ ചെറുതും വേഗതയേറിയതും കൂടുതൽ അളക്കാവുന്നതുമാക്കി മാറ്റുന്നു.

3. ക്വാർക്കസും ഗ്രാൽവിഎമ്മും: ഹൈബർനേറ്റിനെ സൂപ്പർ സ്പീഡിലേക്ക് ത്വരിതപ്പെടുത്തുകയും ഉപ ആറ്റോമിക് വലുപ്പത്തിലേക്ക് ചുരുക്കുകയും ചെയ്യുന്നു

രചയിതാവ്: സാൻ ഗ്രിനോവെറോ
ക്വാർക്കസ് എങ്ങനെ ഉണ്ടായി, അത് എങ്ങനെ പ്രവർത്തിക്കുന്നു, ഹൈബർനേറ്റ് ORM പോലെയുള്ള സങ്കീർണ്ണമായ ലൈബ്രറികൾ നേറ്റീവ് GraalVM ഇമേജുകൾക്ക് അനുയോജ്യമാക്കാൻ ഇത് നിങ്ങളെ എങ്ങനെ അനുവദിക്കുന്നുവെന്ന് അവതരണത്തിൽ നിന്ന് നിങ്ങൾ മനസ്സിലാക്കും.

4. സെർവർലെസ് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കാൻ പഠിക്കുക

രചയിതാവ്: മാർട്ടിൻ ലൂഥർ
ക്വാർക്കസ് ഉപയോഗിച്ച് ഒരു ലളിതമായ ജാവ ആപ്ലിക്കേഷൻ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും നെറ്റീവിൽ ഒരു സെർവർലെസ് ആപ്ലിക്കേഷനായി വിന്യസിക്കുന്നത് എങ്ങനെയെന്നും ചുവടെയുള്ള വീഡിയോ കാണിക്കുന്നു.

5. ക്വാർക്കസ്: രസകരമായ കോഡിംഗ് നടത്തുക

രചയിതാവ്: എഡ്സൺ യാനഗ
നിങ്ങളുടെ ആദ്യ ക്വാർക്കസ് പ്രോജക്റ്റ് സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു വീഡിയോ ഗൈഡ്, എന്തുകൊണ്ടാണ് ക്വാർക്കസ് ഡവലപ്പർമാരുടെ ഹൃദയം കീഴടക്കുന്നത് എന്ന് മനസ്സിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

6. ജാവയും കണ്ടെയ്‌നറുകളും - ഒരുമിച്ച് അവരുടെ ഭാവി എന്തായിരിക്കും

മാർക്ക് ലിറ്റിൽ പോസ്റ്റ് ചെയ്തത്
ഈ അവതരണം ജാവയുടെ ചരിത്രം പരിചയപ്പെടുത്തുകയും ക്വാർക്കസ് ജാവയുടെ ഭാവിയാകുന്നത് എന്തുകൊണ്ടാണെന്ന് വിശദീകരിക്കുകയും ചെയ്യുന്നു.

7. ക്വാർക്കസ്: സൂപ്പർഫാസ്റ്റ് സബ്ടോമിക് ജാവ

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

8. ക്വാർക്കസ്, സബ് ആറ്റോമിക് റോക്കറ്റ് സംവിധാനങ്ങൾ

രചയിതാവ്: ക്ലെമന്റ് എസ്കോഫിയർ
GraalVM-മായി സംയോജിപ്പിക്കുന്നതിലൂടെ, ക്വാർക്കസ് ഒരു അൾട്രാ ഫാസ്റ്റ് വികസന അനുഭവവും ഒരു സബ് ആറ്റോമിക് റൺടൈം പരിതസ്ഥിതിയും നൽകുന്നു. ക്വാർക്കസിന്റെ പ്രതിപ്രവർത്തന വശത്തെക്കുറിച്ചും റിയാക്ടീവ്, സ്ട്രീമിംഗ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന് അത് എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ചും രചയിതാവ് സംസാരിക്കുന്നു.

9. എക്ലിപ്സ് മൈക്രോപ്രൊഫൈലിൽ ക്വാർക്കസും ദ്രുത ആപ്ലിക്കേഷൻ വികസനവും

രചയിതാവ്: ജോൺ ക്ലിംഗൻ
Eclipse MicroProfile, Quarkus എന്നിവ സംയോജിപ്പിക്കുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് പതിനായിരക്കണക്കിന് മില്ലിസെക്കൻഡിൽ സമാരംഭിക്കുന്ന പൂർണ്ണ ഫീച്ചർ ചെയ്ത കണ്ടെയ്നറൈസ്ഡ് മൈക്രോപ്രൊഫൈൽ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാൻ കഴിയും. Kubernetes പ്ലാറ്റ്‌ഫോമിൽ വിന്യാസത്തിനായി കണ്ടെയ്‌നറൈസ് ചെയ്‌ത മൈക്രോപ്രൊഫൈൽ ആപ്ലിക്കേഷൻ എങ്ങനെ കോഡ് ചെയ്യാം എന്നതിനെ കുറിച്ച് വീഡിയോ വിശദമായി വിവരിക്കുന്നു.

10. ജാവ, "ടർബോ" പതിപ്പ്

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

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