കോൺഫറൻസ് റിപ്പോർട്ടിന്റെ ട്രാൻസ്ക്രിപ്റ്റ് ഞങ്ങൾ വീണ്ടും പ്രസിദ്ധീകരിക്കുന്നു ഹൈലോഡ്++ 2016, കഴിഞ്ഞ വർഷം നവംബർ 7-8 തീയതികളിൽ മോസ്കോയ്ക്കടുത്തുള്ള സ്കോൾകോവോയിൽ നടന്നു. വ്ലാഡിമിർ പ്രൊട്ടസോവ് OpenResty, Lua എന്നിവ ഉപയോഗിച്ച് NGINX പ്രവർത്തനം എങ്ങനെ വിപുലീകരിക്കാമെന്ന് വിശദീകരിക്കുന്നു.

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

അപ്പോൾ അത് എത്ര മോശമാണെന്ന് നിങ്ങൾ മനസ്സിലാക്കുന്നു. ഞാൻ അൽപ്പം ജൂനിയറായപ്പോൾ, ഞാൻ വന്ന് ഈ രണ്ട് ടെറാബൈറ്റ് ഡാറ്റാബേസുകൾ നൽകി. ഇപ്പോൾ ഇവിടെയുള്ള എല്ലാവർക്കും വലിയ ഭാരമാണ്. ഞാൻ കോൺഫറൻസുകളിൽ പോയി ചോദിച്ചു: “കുട്ടികളേ, എന്നോട് പറയൂ, നിങ്ങൾക്ക് വലിയ ഡാറ്റയുണ്ട്, എല്ലാം രസകരമാണോ? നിങ്ങൾക്ക് അവിടെ എത്ര അടിസ്ഥാനങ്ങളുണ്ട്? അവർ എന്നോട് ഉത്തരം പറഞ്ഞു: "ഞങ്ങൾക്ക് 100 ജിഗാബൈറ്റുകൾ ഉണ്ട്!" ഞാൻ പറഞ്ഞു: “കൂൾ, 100 ജിഗാബൈറ്റ്!” എന്റെ പോക്കർ മുഖം എങ്ങനെ ശ്രദ്ധാപൂർവ്വം പരിപാലിക്കാമെന്ന് ഞാൻ സ്വയം ചിന്തിക്കുകയായിരുന്നു. നിങ്ങൾ വിചാരിക്കുന്നു, അതെ, ആൺകുട്ടികൾ ശാന്തരാണ്, തുടർന്ന് നിങ്ങൾ തിരികെ പോയി ഈ മൾട്ടി-ടെറാബൈറ്റ് ഡാറ്റാബേസുകൾ ഉപയോഗിച്ച് ടിങ്കർ ചെയ്യുക. ഇത് ഒരു ജൂനിയർ ആണ്. ഇത് എന്തൊരു പ്രഹരമാണെന്ന് നിങ്ങൾക്ക് ഊഹിക്കാനാകുമോ?

എനിക്ക് 20-ലധികം പ്രോഗ്രാമിംഗ് ഭാഷകൾ അറിയാം. ഞാൻ ജോലി ചെയ്യുമ്പോൾ എനിക്ക് മനസ്സിലാക്കേണ്ട ഒരു കാര്യമാണിത്. അവർ നിങ്ങൾക്ക് Erlang, C, C++, Lua, Python, Ruby, മറ്റെന്തെങ്കിലും കോഡ് നൽകുന്നു, നിങ്ങൾ എല്ലാം വെട്ടിക്കളയണം. പൊതുവേ, എനിക്ക് ചെയ്യേണ്ടിവന്നു. കൃത്യമായ എണ്ണം കണക്കാക്കാൻ കഴിഞ്ഞില്ല, പക്ഷേ എവിടെയോ 20-ാം തീയതി നഷ്‌ടപ്പെട്ടു.

സമാന്തരങ്ങൾ എന്താണെന്നും എന്താണ് ചെയ്യുന്നതെന്നും ഉള്ള എല്ലാവർക്കും അറിയാവുന്നതിനാൽ, ഞങ്ങൾ എത്ര ശാന്തരാണെന്നും എന്താണ് ചെയ്യുന്നതെന്നും ഞാൻ സംസാരിക്കില്ല. ഞങ്ങൾക്ക് ലോകമെമ്പാടും 13 ഓഫീസുകൾ ഉണ്ടെന്നും 300 ലധികം ജീവനക്കാർ ഉണ്ടെന്നും മോസ്കോ, ടാലിൻ, മാൾട്ട എന്നിവിടങ്ങളിൽ വികസനം ഉണ്ടെന്നും ഞാൻ നിങ്ങളോട് പറയും. നിങ്ങൾക്ക് വേണമെങ്കിൽ, ശൈത്യകാലത്ത് തണുപ്പാണെങ്കിൽ നിങ്ങൾക്ക് അത് എടുത്ത് മാൾട്ടയിലേക്ക് പോകാം, നിങ്ങളുടെ പുറം ചൂടാക്കേണ്ടതുണ്ട്.

പ്രത്യേകമായി, ഞങ്ങളുടെ വകുപ്പ് പൈത്തൺ 2 ൽ എഴുതുന്നു. ഞങ്ങൾ ബിസിനസ്സിലാണ്, ഫാഷനബിൾ സാങ്കേതികവിദ്യകൾ നടപ്പിലാക്കാൻ സമയമില്ല, അതിനാൽ ഞങ്ങൾ കഷ്ടപ്പെടുന്നു. ഞങ്ങൾ ജാംഗോ ഉപയോഗിക്കുന്നു, കാരണം അതിൽ എല്ലാം ഉണ്ട്, ഞങ്ങൾ അനാവശ്യമായത് എടുത്ത് വലിച്ചെറിഞ്ഞു. കൂടാതെ MySQL, Redis, NGINX എന്നിവയും. ഞങ്ങൾക്ക് മറ്റ് രസകരമായ നിരവധി കാര്യങ്ങളും ഉണ്ട്. ഞങ്ങൾക്ക് മോംഗോഡിബി ഉണ്ട്, ഞങ്ങൾക്ക് മുയലുകൾ ഓടുന്നു, ഞങ്ങൾക്ക് എല്ലാം ഉണ്ട് - പക്ഷേ ഇത് എന്റേതല്ല, ഞാൻ അത് ചെയ്യുന്നില്ല.

ഓപ്പൺ റെസ്റ്റി

ഞാൻ എന്നെ കുറിച്ച് പറഞ്ഞു. ഇന്ന് ഞാൻ എന്താണ് സംസാരിക്കാൻ പോകുന്നതെന്ന് നമുക്ക് നോക്കാം:

• എന്താണ് ഓപ്പൺ റെസ്റ്റി, അത് എന്താണ് കഴിക്കുന്നത്?
• പൈത്തൺ, നോഡ്‌ജെഎസ്, പി‌എച്ച്‌പി, ഗോ എന്നിവയും എല്ലാവർക്കും സന്തോഷമുള്ള മറ്റ് രസകരമായ കാര്യങ്ങളും ഉള്ളപ്പോൾ മറ്റൊരു ചക്രം പുനർനിർമ്മിക്കുന്നത് എന്തുകൊണ്ട്?
• ഒപ്പം ജീവിതത്തിൽ നിന്നുള്ള ഏതാനും ഉദാഹരണങ്ങളും. 3,5 മണിക്കൂർ ദൈർഘ്യമുള്ളതിനാൽ എനിക്ക് സംസാരം വളരെയധികം കുറയ്ക്കേണ്ടിവന്നു, അതിനാൽ കൂടുതൽ ഉദാഹരണങ്ങൾ ഉണ്ടാകില്ല.

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

എൻ‌ജി‌എൻ‌എക്‌സിന് ഇതിനകം കാഷിംഗും സ്റ്റാറ്റിക് ഉള്ളടക്കവും പൂർത്തിയായിട്ടുണ്ട്. ഇത് മാനുഷികമായി എങ്ങനെ ചെയ്യാമെന്നതിനെക്കുറിച്ച് നിങ്ങൾ വിഷമിക്കേണ്ടതില്ല, അങ്ങനെ നിങ്ങൾ എവിടെയെങ്കിലും വേഗത കുറയ്ക്കരുത്, അങ്ങനെ നിങ്ങൾക്ക് എവിടെയെങ്കിലും ഡിസ്ക്രിപ്റ്ററുകൾ നഷ്ടപ്പെടില്ല. Nginx വിന്യസിക്കാൻ വളരെ സൗകര്യപ്രദമാണ്, എന്താണ് എടുക്കേണ്ടതെന്ന് നിങ്ങൾ ചിന്തിക്കേണ്ടതില്ല - WSGI, PHP-FPM, Gunicorn, Unicorn. Nginx ഇൻസ്റ്റാൾ ചെയ്തു, അഡ്മിൻമാർക്ക് നൽകി, അത് എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് അവർക്കറിയാം. Nginx ഘടനാപരമായ രീതിയിൽ അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നു. ഞാൻ ഇതിനെക്കുറിച്ച് കുറച്ച് കഴിഞ്ഞ് സംസാരിക്കും. ചുരുക്കത്തിൽ, അഭ്യർത്ഥന സ്വീകരിക്കുമ്പോൾ, അത് പ്രോസസ്സ് ചെയ്യുമ്പോൾ, ഉപയോക്താവിന് ഉള്ളടക്കം നൽകുമ്പോൾ ഇതിന് ഒരു ഘട്ടമുണ്ട്.

Nginx രസകരമാണ്, പക്ഷേ ഒരു പ്രശ്‌നമുണ്ട്: കോൺഫിഗർ ചെയ്യാൻ കഴിയുമെങ്കിലും, കോൺഫിഗറിലേക്ക് ആൺകുട്ടികൾ തിങ്ങിനിറഞ്ഞ എല്ലാ രസകരമായ സവിശേഷതകളും ഉണ്ടായിരുന്നിട്ടും ഇത് വേണ്ടത്ര വഴക്കമുള്ളതല്ല. ഈ ശക്തി മതിയാവില്ല. അതുകൊണ്ടാണ് താവോബാവോയിൽ നിന്നുള്ള ആളുകൾ, വളരെക്കാലം മുമ്പ്, എട്ട് വർഷം മുമ്പ്, ലുവയെ അതിൽ നിർമ്മിച്ചതായി തോന്നുന്നു. അത് എന്താണ് നൽകുന്നത്?

• വലുപ്പം. അത് ചെറുതാണ്. LuaJIT ഏകദേശം 100-200 കിലോബൈറ്റ് മെമ്മറി ഓവർഹെഡും മിനിമം പെർഫോമൻസ് ഓവർഹെഡും നൽകുന്നു.
• വേഗത. LuaJIT വ്യാഖ്യാതാവ് പല സാഹചര്യങ്ങളിലും C യോട് അടുത്താണ്, ചില സാഹചര്യങ്ങളിൽ അത് ജാവയോട് നഷ്ടപ്പെടുന്നു, മറ്റുള്ളവയിൽ അത് അതിനെ മറികടക്കുന്നു. കുറച്ചു കാലത്തേക്ക് അത് ഏറ്റവും മികച്ച ജെഐടി കംപൈലറായ ആർട്ട് ഓഫ് ആർട്ടായി കണക്കാക്കപ്പെട്ടിരുന്നു. ഇപ്പോൾ തണുപ്പുള്ളവയുണ്ട്, പക്ഷേ അവ വളരെ ഭാരമുള്ളവയാണ്, ഉദാഹരണത്തിന്, അതേ V8. ചില JS വ്യാഖ്യാതാക്കളും ജാവ ഹോട്ട്‌സ്‌പോട്ടും ചില ഘട്ടങ്ങളിൽ വേഗതയുള്ളവയാണ്, എന്നാൽ ചില സ്ഥലങ്ങളിൽ അവ ഇപ്പോഴും നഷ്ടപ്പെടും.
• പഠിക്കാൻ എളുപ്പമാണ്. നിങ്ങൾക്ക് ഒരു പേൾ കോഡ് ബേസ് ഉണ്ടെങ്കിൽ, നിങ്ങൾ ബുക്കിംഗ് നടത്തുന്നില്ലെങ്കിൽ, നിങ്ങൾക്ക് പേൾ പ്രോഗ്രാമർമാരെ കണ്ടെത്താനാവില്ല. അവർ നിലവിലില്ലാത്തതിനാൽ, അവയെല്ലാം എടുത്തുകളഞ്ഞു, അവരെ പഠിപ്പിക്കുന്നത് ദീർഘവും ബുദ്ധിമുട്ടുള്ളതുമാണ്. നിങ്ങൾക്ക് മറ്റെന്തെങ്കിലും പ്രോഗ്രാമർമാരെ വേണമെങ്കിൽ, നിങ്ങൾ അവരെ വീണ്ടും പരിശീലിപ്പിക്കുകയോ അവരെ കണ്ടെത്തുകയോ ചെയ്യേണ്ടതായി വന്നേക്കാം. ലുവായുടെ കാര്യത്തിൽ, എല്ലാം ലളിതമാണ്. ഏത് ജൂനിയറിനും മൂന്ന് ദിവസം കൊണ്ട് ലുവാ പഠിക്കാം. അത് മനസ്സിലാക്കാൻ എനിക്ക് ഏകദേശം രണ്ട് മണിക്കൂർ എടുത്തു. രണ്ട് മണിക്കൂർ കഴിഞ്ഞ് ഞാൻ പ്രൊഡക്ഷനിൽ കോഡ് എഴുതുകയായിരുന്നു. ഏകദേശം ഒരാഴ്ച കഴിഞ്ഞ് അവൻ നേരെ പ്രൊഡക്ഷനിൽ പോയി പോയി.

തൽഫലമായി, ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

ഇവിടെ ഒരുപാട് ഉണ്ട്. ഓപ്പൺ റെസ്റ്റി ഒരു കൂട്ടം മൊഡ്യൂളുകൾ ശേഖരിച്ചു, ലുവാഷും എഞ്ചിനും. നിങ്ങൾക്ക് എല്ലാം തയ്യാറാണ് - വിന്യസിക്കുകയും പ്രവർത്തിക്കുകയും ചെയ്യുന്നു.

ഉദാഹരണങ്ങൾ

വരികൾ മതി, നമുക്ക് കോഡിലേക്ക് പോകാം. ഇതാ ഒരു ചെറിയ ഹലോ വേൾഡ്:

എന്താ അവിടെ? ഇതൊരു എഞ്ചിനുകളുടെ സ്ഥാനമാണ്. ഞങ്ങൾ വിഷമിക്കേണ്ട, ഞങ്ങൾ സ്വന്തം റൂട്ടിംഗ് എഴുതുന്നില്ല, ഞങ്ങൾ ചില റെഡിമെയ്ഡ് എടുക്കുന്നില്ല - ഞങ്ങൾക്ക് ഇതിനകം NGINX-ൽ ഉണ്ട്, ഞങ്ങൾ നല്ലതും അലസവുമായ ജീവിതം നയിക്കുന്നു.

content_by_lua_block ഞങ്ങൾ ഒരു Lua സ്ക്രിപ്റ്റ് ഉപയോഗിച്ചാണ് ഉള്ളടക്കം നൽകുന്നത് എന്ന് പറയുന്ന ഒരു ബ്ലോക്ക് ആണ്. നമ്മൾ എഞ്ചിൻസ് വേരിയബിൾ എടുക്കുന്നു remote_addr അത് അകത്താക്കി string.format. അതു പോലെ തന്നെ sprintf, ലുവയിൽ മാത്രം, ശരി മാത്രം. ഞങ്ങൾ അത് ക്ലയന്റിന് നൽകുന്നു.

തൽഫലമായി, ഇത് ഇതുപോലെ കാണപ്പെടും:

എന്നാൽ നമുക്ക് യഥാർത്ഥ ലോകത്തിലേക്ക് മടങ്ങാം. ആരും നിർമ്മാണത്തിനായി ഹലോ വേൾഡിനെ വിന്യസിക്കുന്നില്ല. ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ സാധാരണയായി ഡാറ്റാബേസിലേക്കോ മറ്റെവിടെയെങ്കിലുമോ പോകുന്നു, മിക്ക സമയത്തും പ്രതികരണത്തിനായി കാത്തിരിക്കുന്നു.

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

GET പാരാമീറ്ററുകൾ എടുക്കാൻ രണ്ട് വരികൾ നിങ്ങളെ അനുവദിക്കുന്നു, സങ്കീർണതകളൊന്നുമില്ല. അടുത്തതായി, ഒരു കീവേഡിനും വിപുലീകരണത്തിനുമുള്ള ഒരു അടയാളമുള്ള ഒരു ഡാറ്റാബേസിൽ നിന്ന്, ഒരു സാധാരണ SQL ചോദ്യം ഉപയോഗിച്ച് ഞങ്ങൾ ഈ വിവരങ്ങൾ നേടുന്നു. ഇത് ലളിതമാണ്. ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

ലൈബ്രറി ബന്ധിപ്പിക്കുന്നു resty.mysql, ഞങ്ങൾ ഇതിനകം കിറ്റിൽ ഉണ്ട്. ഞങ്ങൾ ഒന്നും ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതില്ല, എല്ലാം തയ്യാറാണ്. എങ്ങനെ കണക്റ്റുചെയ്യാമെന്നും ഒരു SQL അന്വേഷണം നടത്താമെന്നും ഞങ്ങൾ സൂചിപ്പിക്കുന്നു:

ഇവിടെ ഇത് അൽപ്പം ഭയാനകമാണ്, പക്ഷേ എല്ലാം പ്രവർത്തിക്കുന്നു. ഇവിടെ 10 ആണ് പരിധി. ഞങ്ങൾ 10 എൻട്രികൾ പുറത്തെടുത്തു, ഞങ്ങൾ മടിയന്മാരാണ്, കൂടുതൽ കാണിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല. SQL-ലെ പരിധിയെക്കുറിച്ച് ഞാൻ മറന്നു.

അടുത്തതായി എല്ലാ ചോദ്യങ്ങൾക്കുമുള്ള ചിത്രങ്ങൾ ഞങ്ങൾ കണ്ടെത്തും. ഞങ്ങൾ ഒരു കൂട്ടം അഭ്യർത്ഥനകൾ ശേഖരിക്കുകയും ഒരു Lua ടേബിൾ പൂരിപ്പിക്കുകയും ചെയ്യുന്നു reqs, ഞങ്ങൾ ചെയ്യുന്നു ngx.location.capture_multi.

ഈ അഭ്യർത്ഥനകളെല്ലാം സമാന്തരമായി അയയ്ക്കുകയും ഉത്തരങ്ങൾ ഞങ്ങൾക്ക് തിരികെ നൽകുകയും ചെയ്യുന്നു. പ്രവർത്തന സമയം മന്ദഗതിയിലുള്ള ഒന്നിന്റെ പ്രതികരണ സമയത്തിന് തുല്യമാണ്. നമ്മൾ എല്ലാവരും 50 മില്ലിസെക്കൻഡിൽ ഷൂട്ട് ചെയ്യുകയും നൂറ് അഭ്യർത്ഥനകൾ അയയ്ക്കുകയും ചെയ്താൽ, ഞങ്ങൾക്ക് 50 മില്ലിസെക്കൻഡിൽ ഉത്തരം ലഭിക്കും.

ഞങ്ങൾ അലസരായതിനാൽ HTTP, കാഷിംഗ് കൈകാര്യം ചെയ്യൽ എന്നിവ എഴുതാൻ താൽപ്പര്യമില്ലാത്തതിനാൽ, ഞങ്ങൾക്കായി NGINX-നെ എല്ലാം ചെയ്യും. നിങ്ങൾ കണ്ടതുപോലെ, ഒരു അഭ്യർത്ഥന ഉണ്ടായിരുന്നു url/fetch, ഇതാ അവൻ:

ഞങ്ങൾ അത് ലളിതമാക്കുന്നു proxy_pass, എവിടെയാണ് കാഷെ ചെയ്യേണ്ടത്, അത് എങ്ങനെ ചെയ്യണം, എല്ലാം ഞങ്ങൾക്കായി പ്രവർത്തിക്കുന്നു.

എന്നാൽ ഇത് പോരാ, ഞങ്ങൾ ഇപ്പോഴും ഉപയോക്താവിന് ഡാറ്റ നൽകേണ്ടതുണ്ട്. ഏറ്റവും ലളിതമായ ആശയം JSON-ൽ, എളുപ്പത്തിൽ, രണ്ട് വരികളായി സീരിയലൈസ് ചെയ്യുക എന്നതാണ്. ഞങ്ങൾ ഉള്ളടക്ക തരം നൽകുന്നു, ഞങ്ങൾ JSON നൽകുന്നു.

എന്നാൽ ഒരു ബുദ്ധിമുട്ട് ഉണ്ട്: ഉപയോക്താവിന് JSON വായിക്കാൻ താൽപ്പര്യമില്ല. നമുക്ക് ഫ്രണ്ട് എൻഡ് ഡെവലപ്പർമാരെ ആകർഷിക്കേണ്ടതുണ്ട്. ചിലപ്പോൾ ഞങ്ങൾ ആദ്യം ഇത് ചെയ്യാൻ ആഗ്രഹിക്കുന്നില്ല. ഞങ്ങൾ ചിത്രങ്ങൾക്കായി തിരയുകയാണെങ്കിൽ, അത് അവർക്ക് പ്രശ്നമല്ലെന്ന് SEO സ്പെഷ്യലിസ്റ്റുകൾ പറയും. ഞങ്ങൾ അവർക്ക് കുറച്ച് ഉള്ളടക്കം നൽകിയാൽ, ഞങ്ങളുടെ തിരയൽ എഞ്ചിനുകൾ ഒന്നും സൂചികയിലാക്കില്ലെന്ന് അവർ പറയും.

അതിന് എന്ത് ചെയ്യണം? തീർച്ചയായും, ഞങ്ങൾ ഉപയോക്താവിന് HTML നൽകും. കൈകൊണ്ട് നിർമ്മിക്കുന്നത് comme il faut അല്ല, അതിനാൽ ഞങ്ങൾ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നു. ഇതിനായി ഒരു ലൈബ്രറിയുണ്ട് lua-resty-template.

OPM എന്ന ഭയപ്പെടുത്തുന്ന മൂന്ന് അക്ഷരങ്ങൾ നിങ്ങൾ കണ്ടിട്ടുണ്ടാകും. ഓപ്പൺ റെസ്റ്റി അതിന്റേതായ പാക്കേജ് മാനേജറുമായാണ് വരുന്നത്, അതിലൂടെ നിങ്ങൾക്ക് ഒരു കൂട്ടം വ്യത്യസ്ത മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും, പ്രത്യേകിച്ചും, lua-resty-template. ജാംഗോ ടെംപ്ലേറ്റുകൾക്ക് സമാനമായ ഒരു ലളിതമായ ടെംപ്ലേറ്റ് എഞ്ചിനാണ് ഇത്. അവിടെ നിങ്ങൾക്ക് കോഡ് എഴുതാനും വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ നടത്താനും കഴിയും.

തൽഫലമായി, എല്ലാം ഇതുപോലെ കാണപ്പെടും:

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

എല്ലാം രസകരമാണ്, പക്ഷേ ഞങ്ങൾ വികസനത്തിലാണ്, ഇത് ഇതുവരെ ഉപയോക്താക്കളെ കാണിക്കാൻ ആഗ്രഹിക്കുന്നില്ല. നമുക്ക് അംഗീകാരം നൽകാം. ഇത് ചെയ്യുന്നതിന്, OpenResty നിബന്ധനകളിൽ NGINX എങ്ങനെയാണ് അഭ്യർത്ഥന കൈകാര്യം ചെയ്യുന്നത് എന്ന് നോക്കാം:

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

ഞങ്ങളുടെ അംഗീകാരം ഇതുപോലെയായിരിക്കും:

അതിലേക്ക് ഞങ്ങൾ ഇത് ചേർക്കും location, ഞങ്ങൾ മുമ്പ് വിവരിച്ച, ഇനിപ്പറയുന്ന കോഡ് അവിടെ ഇടുക:

ഞങ്ങൾക്ക് ഒരു കുക്കി ടോക്കൺ ഉണ്ടോ എന്ന് ഞങ്ങൾ നോക്കുന്നു. ഇല്ലെങ്കിൽ, ഞങ്ങൾ അനുമതി ചോദിക്കുന്നു. ഉപയോക്താക്കൾ തന്ത്രശാലികളാണ്, അവർക്ക് ഒരു കുക്കി ടോക്കൺ സജ്ജീകരിക്കേണ്ടതുണ്ടെന്ന് ഊഹിക്കാൻ കഴിയും. അതിനാൽ, ഞങ്ങൾ ഇത് Redis-ലും ഇടും:

റെഡിസിനൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള കോഡ് വളരെ ലളിതവും മറ്റ് ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തവുമല്ല. അതേ സമയം, എല്ലാ ഇൻപുട്ട്/ഔട്ട്പുട്ടും, ഇവിടെയും അവിടെയും, തടയുന്നില്ല. നിങ്ങൾ സിൻക്രണസ് കോഡ് എഴുതുകയാണെങ്കിൽ, അത് അസമന്വിതമായി പ്രവർത്തിക്കുന്നു. ഏതാണ്ട് ഗെവെന്റ് പോലെ, പക്ഷേ നന്നായി ചെയ്തു.

അംഗീകാരം സ്വയം ചെയ്യാം:

അഭ്യർത്ഥനയുടെ ബോഡി വായിക്കേണ്ടതുണ്ടെന്ന് ഞങ്ങൾ പറയുന്നു. ഞങ്ങൾക്ക് POST ആർഗ്യുമെന്റുകൾ ലഭിക്കുകയും ലോഗിനും പാസ്‌വേഡും ശരിയാണോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു. അവ തെറ്റാണെങ്കിൽ, അംഗീകാരത്തിനായി ഞങ്ങൾ നിങ്ങളെ വെല്ലുവിളിക്കുന്നു. ശരിയാണെങ്കിൽ, റെഡിസിൽ ടോക്കൺ എഴുതുക:

കുക്കി സജ്ജീകരിക്കാൻ മറക്കരുത്, ഇതും രണ്ട് വരികളിലായാണ് ചെയ്യുന്നത്:

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

• മിനിമലിസ്റ്റിക് ബാക്കെൻഡ്. ചിലപ്പോൾ നമുക്ക് ബാക്കെൻഡിലേക്ക് കുറച്ച് ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യേണ്ടതുണ്ട്: എവിടെയെങ്കിലും നമുക്ക് ഒരു തീയതി ചേർക്കേണ്ടതുണ്ട്, എവിടെയെങ്കിലും ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കേണ്ടതുണ്ട്, ഇപ്പോൾ സൈറ്റിൽ എത്ര ഉപയോക്താക്കളുണ്ടെന്ന് പറയുക, ഒരു കൗണ്ടറോ സ്ഥിതിവിവരക്കണക്കുകളോ അറ്റാച്ചുചെയ്യുക. വളരെ ചെറിയ എന്തോ ഒന്ന്. ചില ചെറിയ കഷണങ്ങൾ വളരെ എളുപ്പത്തിൽ ഉണ്ടാക്കാം. ഇത് വേഗത്തിലും എളുപ്പത്തിലും മികച്ചതാക്കും.
• ഡാറ്റ പ്രീപ്രോസസിംഗ്. ചിലപ്പോൾ ഞങ്ങളുടെ പേജിലേക്ക് പരസ്യം ഉൾപ്പെടുത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, കൂടാതെ API അഭ്യർത്ഥനകൾ ഉപയോഗിച്ച് ഞങ്ങൾക്ക് ഈ പരസ്യം ലഭിക്കും. ഇത് ഇവിടെ ചെയ്യാൻ വളരെ എളുപ്പമാണ്. ഞങ്ങൾ ഇതിനകം തന്നെ ഇരുന്നു കഠിനാധ്വാനം ചെയ്യുന്ന ഞങ്ങളുടെ ബാക്കെൻഡ് ലോഡ് ചെയ്യുന്നില്ല. നിങ്ങൾക്ക് അത് ഇവിടെ നിന്ന് എടുത്ത് ശേഖരിക്കാം. നമുക്ക് ചില JS സംയോജിപ്പിക്കാം അല്ലെങ്കിൽ, അത് വിച്ഛേദിച്ച് ഉപയോക്താവിന് നൽകുന്നതിന് മുമ്പ് എന്തെങ്കിലും പ്രീപ്രോസസ് ചെയ്യാം.
• മൈക്രോസർവീസിനുള്ള മുൻഭാഗം. ഇതും വളരെ നല്ല കേസാണ്, ഞാൻ അത് നടപ്പിലാക്കി. അതിനുമുമ്പ്, ഇലക്ട്രോണിക് റിപ്പോർട്ടിംഗുമായി ബന്ധപ്പെട്ട ടെൻസോർ എന്ന കമ്പനിയിൽ ഞാൻ ജോലി ചെയ്തിരുന്നു, രാജ്യത്തെ നിയമപരമായ സ്ഥാപനങ്ങളിൽ പകുതിയോളം പേർക്ക് റിപ്പോർട്ടിംഗ് നൽകുന്നു. ഞങ്ങൾ ഒരു സേവനം സൃഷ്ടിച്ചു, ഒരേ സംവിധാനം ഉപയോഗിച്ച് അവിടെ പലതും ചെയ്തു: റൂട്ടിംഗ്, അംഗീകാരം എന്നിവയും അതിലേറെയും.
  ഓപ്പൺ റെസ്റ്റി നിങ്ങളുടെ മൈക്രോസർവീസുകളുടെ ഗ്ലൂ ആയി ഉപയോഗിക്കാം, എല്ലാത്തിനും ഒരൊറ്റ ആക്സസും ഒരൊറ്റ ഇന്റർഫേസും നൽകുന്നു. നിങ്ങൾക്ക് ഇവിടെ Node.js, ഇവിടെ PHP, ഇവിടെ പൈത്തൺ, ഇവിടെ ചില Erlang കാര്യങ്ങൾ ഉള്ള വിധത്തിൽ microservices എഴുതാൻ കഴിയുമെന്നതിനാൽ, എല്ലായിടത്തും ഒരേ കോഡ് മാറ്റിയെഴുതാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെന്ന് ഞങ്ങൾ മനസ്സിലാക്കുന്നു. അതിനാൽ, ഓപ്പൺ റെസ്റ്റി മുൻവശത്ത് പ്ലഗ് ചെയ്യാൻ കഴിയും.

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

  ലുവാ ഡെവലപ്പർമാർ. ഇന്നലെ ഞാൻ ഹൈലോഡ്++ പരിശീലന ദിനത്തിൽ വന്ന ആൺകുട്ടികളുമായി സംസാരിച്ചു, ലുവായിൽ ടാരന്റൂൾ മാത്രമേ എഴുതിയിട്ടുള്ളൂ എന്ന് കേട്ടു. ഇത് ശരിയല്ല, ലുവായിൽ ധാരാളം കാര്യങ്ങൾ എഴുതിയിട്ടുണ്ട്. ഉദാഹരണങ്ങൾ: OpenResty, Prosody XMPP സെർവർ, Love2D ഗെയിം എഞ്ചിൻ, Warcraft-ലും മറ്റിടങ്ങളിലും സ്ക്രിപ്റ്റ് ചെയ്ത Lua. ധാരാളം ലുവാ ഡെവലപ്പർമാർ ഉണ്ട്, അവർക്ക് വലുതും പ്രതികരിക്കുന്നതുമായ ഒരു കമ്മ്യൂണിറ്റിയുണ്ട്. എന്റെ എല്ലാ Lua ചോദ്യങ്ങളും ഏതാനും മണിക്കൂറുകൾക്കുള്ളിൽ പരിഹരിച്ചു. നിങ്ങൾ മെയിലിംഗ് ലിസ്റ്റിലേക്ക് എഴുതുമ്പോൾ, അക്ഷരാർത്ഥത്തിൽ ഏതാനും മിനിറ്റുകൾക്കുള്ളിൽ ഇതിനകം ഒരു കൂട്ടം പ്രതികരണങ്ങൾ ഉണ്ട്, എന്താണ്, എങ്ങനെ, എന്താണ് എന്താണ് എന്ന് വിവരിക്കുന്നു. ഇത് മഹത്തരമാണ്. നിർഭാഗ്യവശാൽ, അത്തരമൊരു തരത്തിലുള്ള ആത്മീയ സമൂഹം എല്ലായിടത്തും ഇല്ല.
  ഓപ്പൺ റെസ്റ്റിക്ക് GitHub ഉണ്ട്, അവിടെ എന്തെങ്കിലും തകരാറുണ്ടെങ്കിൽ നിങ്ങൾക്ക് ഒരു പ്രശ്നം തുറക്കാനാകും. ഗൂഗിൾ ഗ്രൂപ്പുകളിൽ നിങ്ങൾക്ക് പൊതുവായ പ്രശ്നങ്ങൾ ചർച്ച ചെയ്യാൻ കഴിയുന്ന ഒരു മെയിലിംഗ് ലിസ്റ്റ് ഉണ്ട്, ചൈനീസ് ഭാഷയിൽ ഒരു മെയിലിംഗ് ലിസ്റ്റ് ഉണ്ട് - നിങ്ങൾക്കറിയില്ല, ഒരുപക്ഷേ നിങ്ങൾ ഇംഗ്ലീഷ് സംസാരിക്കില്ല, പക്ഷേ നിങ്ങൾക്ക് ചൈനീസ് അറിയാം.

ഫലങ്ങൾ

• ഓപ്പൺ റെസ്റ്റി വെബിന് അനുയോജ്യമായ വളരെ സൗകര്യപ്രദമായ ഒരു ചട്ടക്കൂടാണെന്ന് എനിക്ക് അറിയിക്കാൻ കഴിഞ്ഞുവെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.
• ഇതിന് പ്രവേശനത്തിന് കുറഞ്ഞ തടസ്സമുണ്ട്, കാരണം കോഡ് നമ്മൾ എഴുതുന്നതിന് സമാനമാണ്, ഭാഷ വളരെ ലളിതവും ചുരുങ്ങിയതുമാണ്.
• ഇത് കോൾബാക്കുകൾ ഇല്ലാതെ അസിൻക്രണസ് I/O നൽകുന്നു, ചിലപ്പോൾ NodeJS-ൽ എഴുതാൻ കഴിയുന്ന തരത്തിലുള്ള നൂഡിൽസ് ഞങ്ങളുടെ പക്കലില്ല.
• ഞങ്ങൾക്ക് ആവശ്യമായ മൊഡ്യൂളും ഞങ്ങളുടെ കോഡും ഉള്ള NGINX മാത്രമേ ആവശ്യമുള്ളൂ എന്നതിനാൽ ഇതിന് എളുപ്പത്തിൽ വിന്യാസമുണ്ട്, എല്ലാം ഉടനടി പ്രവർത്തിക്കുന്നു.
• വലുതും പ്രതികരിക്കുന്നതുമായ കമ്മ്യൂണിറ്റി.

റൂട്ടിംഗ് എങ്ങനെയാണെന്ന് ഞാൻ വിശദമായി പറഞ്ഞില്ല, ഇത് വളരെ നീണ്ട കഥയായി മാറി.

Спасибо!

Vladimir Protasov - OpenResty: NGINX ഒരു പൂർണ്ണമായ ആപ്ലിക്കേഷൻ സെർവറാക്കി മാറ്റുന്നു

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