കുബെർനെറ്റസ് ട്യൂട്ടോറിയൽ ഭാഗം 1: ആപ്ലിക്കേഷനുകൾ, മൈക്രോസർവീസുകൾ, കണ്ടെയ്നറുകൾ

ഞങ്ങളുടെ അഭ്യർത്ഥന പ്രകാരം, ഹബ്ർ ഒരു ഹബ് സൃഷ്ടിച്ചു കുബേർനെറ്റ് ആദ്യത്തെ പ്രസിദ്ധീകരണം അതിൽ ഇടുന്നതിൽ ഞങ്ങൾക്ക് സന്തോഷമുണ്ട്. സബ്സ്ക്രൈബ് ചെയ്യുക!

കുബർനെറ്റസ് എളുപ്പമാണ്. ഈ മേഖലയിൽ പ്രവർത്തിക്കാൻ ബാങ്കുകൾ എനിക്ക് ധാരാളം പണം നൽകുന്നത് എന്തിനാണ്, എന്നാൽ ഏതാനും മണിക്കൂറുകൾക്കുള്ളിൽ ആർക്കും ഈ സാങ്കേതികവിദ്യയിൽ പ്രാവീണ്യം നേടാനാകും?

കുബെർനെറ്റസ് ഇത്ര വേഗത്തിൽ പഠിക്കാൻ കഴിയുമെന്ന് നിങ്ങൾക്ക് സംശയമുണ്ടെങ്കിൽ, അത് സ്വയം പരീക്ഷിക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു. അതായത്, ഈ മെറ്റീരിയലിൽ വൈദഗ്ദ്ധ്യം നേടിയ ശേഷം, നിങ്ങൾക്ക് ഒരു കുബർനെറ്റസ് ക്ലസ്റ്ററിലെ മൈക്രോസർവീസുകളെ അടിസ്ഥാനമാക്കി ഒരു ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കാൻ കഴിയും. കുബെർനെറ്റസിനൊപ്പം പ്രവർത്തിക്കാൻ ഞങ്ങളുടെ ക്ലയന്റുകളെ ഞാൻ പഠിപ്പിക്കുന്നത് ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്ന അതേ രീതിശാസ്ത്രമായതിനാൽ എനിക്ക് ഇത് ഉറപ്പ് നൽകാൻ കഴിയും. ഈ ഗൈഡിനെ മറ്റുള്ളവരിൽ നിന്ന് വ്യത്യസ്തമാക്കുന്നത് എന്താണ്? വാസ്തവത്തിൽ, ഒരുപാട് കാര്യങ്ങളുണ്ട്. അതിനാൽ, ഈ മെറ്റീരിയലുകളിൽ ഭൂരിഭാഗവും ആരംഭിക്കുന്നത് ലളിതമായ കാര്യങ്ങളുടെ വിശദീകരണത്തോടെയാണ് - കുബെർനെറ്റസിന്റെ ആശയങ്ങളും kubectl കമാൻഡിന്റെ സവിശേഷതകളും. ഈ മെറ്റീരിയലുകളുടെ രചയിതാക്കൾ അവരുടെ വായനക്കാർക്ക് ആപ്ലിക്കേഷൻ വികസനം, മൈക്രോസർവീസുകൾ, ഡോക്കർ കണ്ടെയ്നറുകൾ എന്നിവയെക്കുറിച്ച് പരിചിതമാണെന്ന് അനുമാനിക്കുന്നു. ഞങ്ങൾ മറ്റൊരു വഴിക്ക് പോകും. ആദ്യം, ഒരു കമ്പ്യൂട്ടറിലെ മൈക്രോസർവീസുകളെ അടിസ്ഥാനമാക്കി ഒരു ആപ്ലിക്കേഷൻ എങ്ങനെ പ്രവർത്തിപ്പിക്കാം എന്നതിനെക്കുറിച്ച് നമ്മൾ സംസാരിക്കും. അപ്പോൾ നമ്മൾ ഓരോ മൈക്രോസർവീസിനും കണ്ടെയ്‌നർ ഇമേജുകൾ നിർമ്മിക്കുന്നത് നോക്കാം. അതിനുശേഷം, ഞങ്ങൾ Kubernetes-നെ പരിചയപ്പെടുകയും Kubernetes നിയന്ത്രിക്കുന്ന ഒരു ക്ലസ്റ്ററിൽ microservices അടിസ്ഥാനമാക്കിയുള്ള ഒരു ആപ്ലിക്കേഷൻ വിന്യസിക്കുന്നത് നോക്കുകയും ചെയ്യും.

കുബെർനെറ്റസിനോട് ക്രമാനുഗതമായ സമീപനത്തോടെയുള്ള ഈ സമീപനം, കുബർനെറ്റസിൽ എല്ലാം എത്ര ലളിതമായി പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കാൻ ശരാശരി വ്യക്തിക്ക് എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസ്സിലാക്കാനുള്ള ആഴം നൽകും. കുബെർനെറ്റസ് തീർച്ചയായും ഒരു ലളിതമായ സാങ്കേതികവിദ്യയാണ്, അത് പഠിക്കാൻ ആഗ്രഹിക്കുന്നവർക്ക് അത് എവിടെ, എങ്ങനെ ഉപയോഗിക്കാമെന്ന് അറിയാമെങ്കിൽ.

ഇപ്പോൾ, കൂടുതൽ ചർച്ച ചെയ്യാതെ, നമുക്ക് ആരംഭിക്കാം, ഞങ്ങൾ പ്രവർത്തിക്കാൻ പോകുന്ന ആപ്ലിക്കേഷനെക്കുറിച്ച് സംസാരിക്കാം.

പരീക്ഷണാത്മക ആപ്ലിക്കേഷൻ

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

ഈ ആപ്ലിക്കേഷന്റെ പ്രധാന വിൻഡോ ഇങ്ങനെയാണ്.

ടെക്സ്റ്റുകളുടെ വികാര വിശകലനത്തിനുള്ള വെബ് ആപ്ലിക്കേഷൻ

ഒരു സാങ്കേതിക വീക്ഷണകോണിൽ നിന്ന്, ആപ്ലിക്കേഷനിൽ മൂന്ന് മൈക്രോസർവീസുകൾ അടങ്ങിയിരിക്കുന്നു, അവയിൽ ഓരോന്നും ഒരു നിർദ്ദിഷ്ട ജോലികൾ പരിഹരിക്കുന്നു:

• സ്റ്റാറ്റിക് റിയാക്റ്റ് ഫയലുകൾ നൽകുന്ന ഒരു Nginx വെബ് സെർവറാണ് SA-Frontend.
• മുൻവശത്ത് നിന്നുള്ള അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്ന ജാവയിൽ എഴുതിയ ഒരു വെബ് ആപ്ലിക്കേഷനാണ് SA-WebApp.
• ടെക്സ്റ്റിൽ വികാര വിശകലനം നടത്തുന്ന ഒരു പൈത്തൺ ആപ്ലിക്കേഷനാണ് SA-Logic.

മൈക്രോസർവീസുകൾ ഒറ്റപ്പെട്ട നിലയിലല്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. അവർ "ഉത്തരവാദിത്തങ്ങൾ വേർപെടുത്തുക" എന്ന ആശയം നടപ്പിലാക്കുന്നു, എന്നാൽ അതേ സമയം അവർ പരസ്പരം ഇടപഴകേണ്ടതുണ്ട്.

ആപ്ലിക്കേഷനിൽ ഡാറ്റ ഒഴുകുന്നു

മുകളിലുള്ള ഡയഗ്രാമിൽ, ആപ്ലിക്കേഷനിലെ ഡാറ്റാ ഫ്ലോകൾ ചിത്രീകരിക്കുന്ന സിസ്റ്റത്തിന്റെ അക്കമിട്ട ഘട്ടങ്ങൾ നിങ്ങൾക്ക് കാണാൻ കഴിയും. നമുക്ക് അവ നോക്കാം:

1. ബ്രൗസർ സെർവറിൽ നിന്ന് ഒരു ഫയൽ അഭ്യർത്ഥിക്കുന്നു index.html (ഇത്, റിയാക്റ്റ് ആപ്ലിക്കേഷൻ പാക്കേജ് ഡൗൺലോഡ് ചെയ്യുന്നു).
2. ഉപയോക്താവ് ആപ്ലിക്കേഷനുമായി സംവദിക്കുന്നു, ഇത് സ്പ്രിംഗ് അടിസ്ഥാനമാക്കിയുള്ള വെബ് ആപ്ലിക്കേഷനിലേക്ക് ഒരു കോളിന് കാരണമാകുന്നു.
3. ടെക്സ്റ്റ് വിശകലനം നടത്താനുള്ള അഭ്യർത്ഥന പൈത്തൺ ആപ്ലിക്കേഷനിലേക്ക് വെബ് ആപ്ലിക്കേഷൻ കൈമാറുന്നു.
4. പൈത്തൺ ആപ്ലിക്കേഷൻ ടെക്സ്റ്റിന്റെ വികാര വിശകലനം നടത്തുകയും അഭ്യർത്ഥനയ്ക്കുള്ള പ്രതികരണമായി ഫലം നൽകുകയും ചെയ്യുന്നു.
5. സ്പ്രിംഗ് ആപ്ലിക്കേഷൻ റിയാക്റ്റ് ആപ്ലിക്കേഷനിലേക്ക് ഒരു പ്രതികരണം അയയ്ക്കുന്നു (അത്, ഉപയോക്താവിന് ടെക്സ്റ്റ് വിശകലനത്തിന്റെ ഫലം കാണിക്കുന്നു).

ഈ ആപ്ലിക്കേഷനുകൾക്കെല്ലാം കോഡ് കണ്ടെത്താനാകും ഇവിടെ. ഈ ശേഖരം ഇപ്പോൾ നിങ്ങൾക്കായി പകർത്താൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു, കാരണം രസകരമായ നിരവധി പരീക്ഷണങ്ങൾ ഞങ്ങൾക്ക് മുന്നിലുണ്ട്.

നിങ്ങളുടെ പ്രാദേശിക മെഷീനിൽ ഒരു മൈക്രോസർവീസ് അടിസ്ഥാനമാക്കിയുള്ള ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നു

ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുന്നതിന്, ഞങ്ങൾ മൂന്ന് മൈക്രോസർവീസുകളും ആരംഭിക്കേണ്ടതുണ്ട്. അവയിൽ ഏറ്റവും ഭംഗിയുള്ളതിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം - ഫ്രണ്ട്-എൻഡ് ആപ്ലിക്കേഷൻ.

▍പ്രാദേശിക വികസനത്തിനായി റിയാക്റ്റ് സജ്ജീകരിക്കുക

ഒരു റിയാക്റ്റ് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ Node.js പ്ലാറ്റ്‌ഫോമും NPM-ഉം ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. നിങ്ങൾ ഇതെല്ലാം ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങളുടെ പ്രോജക്റ്റ് ഫോൾഡറിലേക്ക് നാവിഗേറ്റ് ചെയ്യാൻ ടെർമിനൽ ഉപയോഗിക്കുക sa-frontend താഴെ പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

npm install

ഫോൾഡറിൽ ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ node_modules റിയാക്റ്റ് ആപ്ലിക്കേഷന്റെ ഡിപൻഡൻസികൾ ലോഡ് ചെയ്യപ്പെടും, അതിന്റെ രേഖകൾ ഫയലിലുണ്ട് package.json. ഡിപൻഡൻസികൾ ഒരേ ഫോൾഡറിൽ ഡൗൺലോഡ് ചെയ്‌തുകഴിഞ്ഞാൽ, ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

npm start

അത്രയേയുള്ളൂ. ഇപ്പോൾ റിയാക്റ്റ് ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുന്നു, നിങ്ങളുടെ ബ്രൗസറിലെ ഇനിപ്പറയുന്ന വിലാസത്തിലേക്ക് പോയി നിങ്ങൾക്ക് അത് ആക്‌സസ് ചെയ്യാൻ കഴിയും: localhost:3000. നിങ്ങൾക്ക് അതിന്റെ കോഡിൽ എന്തെങ്കിലും മാറ്റാൻ കഴിയും. ബ്രൗസറിൽ ഈ മാറ്റങ്ങളുടെ ഫലം ഉടനടി നിങ്ങൾ കാണും. മൊഡ്യൂളുകളുടെ "ചൂട്" മാറ്റിസ്ഥാപിക്കുന്നതിന് ഇത് സാധ്യമാണ്. ഇത് ഫ്രണ്ട് എൻഡ് വികസനം ലളിതവും ആസ്വാദ്യകരവുമായ അനുഭവമാക്കി മാറ്റുന്നു.

▍ഉത്പാദനത്തിനായി ഒരു റിയാക്റ്റ് ആപ്ലിക്കേഷൻ തയ്യാറാക്കുന്നു

യഥാർത്ഥത്തിൽ ഒരു റിയാക്റ്റ് ആപ്ലിക്കേഷൻ ഉപയോഗിക്കുന്നതിന്, ഞങ്ങൾ അതിനെ ഒരു കൂട്ടം സ്റ്റാറ്റിക് ഫയലുകളായി പരിവർത്തനം ചെയ്യുകയും ഒരു വെബ് സെർവർ ഉപയോഗിച്ച് ക്ലയന്റുകൾക്ക് നൽകുകയും ചെയ്യേണ്ടതുണ്ട്.

റിയാക്റ്റ് ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിന്, ടെർമിനൽ ഉപയോഗിച്ച് വീണ്ടും ഫോൾഡറിലേക്ക് നാവിഗേറ്റ് ചെയ്യുക sa-frontend താഴെ പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

npm run build

ഇത് പ്രോജക്റ്റ് ഫോൾഡറിൽ ഒരു ഡയറക്ടറി സൃഷ്ടിക്കും build. റിയാക്റ്റ് ആപ്ലിക്കേഷന് പ്രവർത്തിക്കാൻ ആവശ്യമായ എല്ലാ സ്റ്റാറ്റിക് ഫയലുകളും ഇതിൽ അടങ്ങിയിരിക്കും.

▍Nginx ഉപയോഗിച്ച് സ്റ്റാറ്റിക് ഫയലുകൾ നൽകുന്നു

ആദ്യം നിങ്ങൾ Nginx വെബ് സെർവർ ഇൻസ്റ്റാൾ ചെയ്ത് പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്. ഇത് നിങ്ങൾക്ക് ഇത് ഡൌൺലോഡ് ചെയ്യാനും അത് എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനുമുള്ള നിർദ്ദേശങ്ങൾ കണ്ടെത്താനാകും. അപ്പോൾ നിങ്ങൾ ഫോൾഡറിലെ ഉള്ളടക്കങ്ങൾ പകർത്തേണ്ടതുണ്ട് sa-frontend/build ഫോൾഡറിലേക്ക് [your_nginx_installation_dir]/html.

ഈ സമീപനത്തിലൂടെ, റിയാക്റ്റ് ആപ്ലിക്കേഷന്റെ ബിൽഡ് പ്രോസസ്സിനിടെ സൃഷ്ടിച്ച ഫയൽ index.html എന്ന വിലാസത്തിൽ ലഭ്യമാകും [your_nginx_installation_dir]/html/index.html. ഇത് ആക്‌സസ് ചെയ്യുമ്പോൾ Nginx സെർവർ സ്ഥിരസ്ഥിതിയായി നിർമ്മിക്കുന്ന ഫയലാണ്. പോർട്ടിൽ കേൾക്കാൻ സെർവർ ക്രമീകരിച്ചിരിക്കുന്നു 80, എന്നാൽ ഫയൽ എഡിറ്റ് ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് ആവശ്യമുള്ള രീതിയിൽ ഇത് ഇഷ്ടാനുസൃതമാക്കാവുന്നതാണ് [your_nginx_installation_dir]/conf/nginx.conf.

ഇപ്പോൾ നിങ്ങളുടെ ബ്രൗസർ തുറന്ന് പോകുക localhost:80. നിങ്ങൾ റിയാക്റ്റ് ആപ്ലിക്കേഷൻ പേജ് കാണും.

Nginx സെർവർ നൽകുന്ന റിയാക്റ്റ് ആപ്ലിക്കേഷൻ

നിങ്ങൾ ഇപ്പോൾ ഫീൽഡിൽ എന്തെങ്കിലും പ്രവേശിക്കുകയാണെങ്കിൽ Type your sentence ബട്ടൺ അമർത്തുക Send - ഒന്നും സംഭവിക്കില്ല. പക്ഷേ, നിങ്ങൾ കൺസോൾ നോക്കിയാൽ, നിങ്ങൾക്ക് അവിടെ പിശക് സന്ദേശങ്ങൾ കാണാൻ കഴിയും. ഈ പിശകുകൾ കൃത്യമായി എവിടെയാണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ, നമുക്ക് ആപ്ലിക്കേഷൻ കോഡ് വിശകലനം ചെയ്യാം.

▍ഫ്രണ്ട് എൻഡ് ആപ്ലിക്കേഷൻ കോഡ് വിശകലനം

ഫയൽ കോഡ് നോക്കുന്നു App.js, ബട്ടൺ അമർത്തുന്നത് നമുക്ക് കാണാം Send ഒരു രീതി വിളിക്കുന്നു analyzeSentence(). ഈ രീതിയുടെ കോഡ് ചുവടെ നൽകിയിരിക്കുന്നു. ഫോമിന്റെ അഭിപ്രായമുള്ള ഓരോ വരിയിലും ദയവായി ശ്രദ്ധിക്കുക # Номер, കോഡിന് താഴെ നൽകിയിരിക്കുന്ന ഒരു വിശദീകരണമുണ്ട്. മറ്റ് കോഡ് ശകലങ്ങളും ഞങ്ങൾ അതേ രീതിയിൽ വിശകലനം ചെയ്യും.

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. POST അഭ്യർത്ഥന നടത്തിയ URL. അത്തരം അഭ്യർത്ഥനകൾ പ്രതീക്ഷിക്കുന്ന ഒരു അപേക്ഷ ഈ വിലാസത്തിൽ ഉണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്നു.

2.അപേക്ഷയിലേക്ക് അയച്ച അഭ്യർത്ഥന ബോഡി. ഒരു ഉദാഹരണ അഭ്യർത്ഥന ബോഡി ഇതാ:

{
    sentence: "I like yogobella!"
}

3.ഒരു അഭ്യർത്ഥനയ്ക്കുള്ള പ്രതികരണം ലഭിക്കുമ്പോൾ, ഘടകത്തിന്റെ അവസ്ഥ അപ്ഡേറ്റ് ചെയ്യുന്നു. ഇത് ഘടകം വീണ്ടും റെൻഡർ ചെയ്യുന്നതിന് കാരണമാകുന്നു. ഞങ്ങൾക്ക് ഡാറ്റ ലഭിക്കുകയാണെങ്കിൽ (അതായത്, ഇൻപുട്ട് ഡാറ്റയും കണക്കാക്കിയ ടെക്‌സ്‌റ്റ് സ്‌കോറും അടങ്ങിയ ഒരു JSON ഒബ്‌ജക്റ്റ്), ഞങ്ങൾ ഘടകം ഔട്ട്‌പുട്ട് ചെയ്യും Polarity, കാരണം ഉചിതമായ വ്യവസ്ഥകൾ പാലിക്കപ്പെടും. ഘടകത്തെ ഞങ്ങൾ വിവരിക്കുന്നത് ഇങ്ങനെയാണ്:

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

കോഡ് നന്നായി പ്രവർത്തിക്കുന്നതായി തോന്നുന്നു. എന്തായാലും ഇതിൽ എന്താണ് തെറ്റ്? അപേക്ഷ ഒരു POST അഭ്യർത്ഥന അയയ്‌ക്കാൻ ശ്രമിക്കുന്ന വിലാസത്തിൽ, ഈ അഭ്യർത്ഥന സ്വീകരിക്കാനും പ്രോസസ്സ് ചെയ്യാനും കഴിയുന്ന യാതൊന്നും ഇതുവരെ ഇല്ലെന്ന് നിങ്ങൾ അനുമാനിക്കുകയാണെങ്കിൽ, നിങ്ങൾ തികച്ചും ശരിയാകും. അതായത്, ലഭിച്ച അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് http://localhost:8080/sentiment, ഞങ്ങൾ സ്പ്രിംഗ് അടിസ്ഥാനമാക്കി ഒരു വെബ് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്.

ഞങ്ങൾക്ക് ഒരു POST അഭ്യർത്ഥന സ്വീകരിക്കാൻ കഴിയുന്ന ഒരു സ്പ്രിംഗ് ആപ്ലിക്കേഷൻ ആവശ്യമാണ്

▍ഒരു സ്പ്രിംഗ് അടിസ്ഥാനമാക്കിയുള്ള വെബ് ആപ്ലിക്കേഷൻ സജ്ജീകരിക്കുന്നു

ഒരു സ്പ്രിംഗ് ആപ്ലിക്കേഷൻ വിന്യസിക്കുന്നതിന്, നിങ്ങൾക്ക് JDK8, Maven എന്നിവയും ശരിയായി കോൺഫിഗർ ചെയ്ത എൻവയോൺമെന്റ് വേരിയബിളുകളും ആവശ്യമാണ്. നിങ്ങൾ ഇതെല്ലാം ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് ഞങ്ങളുടെ പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുന്നത് തുടരാം.

▍ഒരു ജാർ ഫയലിലേക്ക് ഒരു ആപ്ലിക്കേഷൻ പാക്കേജിംഗ്

ഒരു ടെർമിനൽ ഉപയോഗിച്ച് ഫോൾഡറിലേക്ക് നാവിഗേറ്റ് ചെയ്യുക sa-webapp തുടർന്ന് ഇനിപ്പറയുന്ന കമാൻഡ് നൽകുക:

mvn install

ഫോൾഡറിൽ ഈ കമാൻഡ് പ്രവർത്തിപ്പിച്ചതിന് ശേഷം sa-webapp ഒരു ഡയറക്ടറി സൃഷ്ടിക്കപ്പെടും target. ഇവിടെയാണ് ജാവ ആപ്ലിക്കേഷൻ സ്ഥിതി ചെയ്യുന്നത്, ഒരു ജാർ ഫയലിൽ പാക്കേജുചെയ്‌ത്, ഫയൽ പ്രതിനിധീകരിക്കുന്നു sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ഒരു ജാവ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നു

ഫോൾഡറിലേക്ക് പോകുക target ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുക:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

ഈ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ഒരു പിശക് സംഭവിക്കും. ഇത് പരിഹരിക്കാൻ ആരംഭിക്കുന്നതിന്, സ്റ്റാക്ക് ട്രേസ് ഡാറ്റയിലെ ഒഴിവാക്കൽ വിശദാംശങ്ങൾ നമുക്ക് വിശകലനം ചെയ്യാം:

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

ഞങ്ങളെ സംബന്ധിച്ചിടത്തോളം, ഇവിടെ ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യം അർത്ഥം വ്യക്തമാക്കാനുള്ള അസാധ്യതയെക്കുറിച്ചുള്ള പരാമർശമാണ് sa.logic.api.url. പിശക് സംഭവിക്കുന്ന കോഡ് വിശകലനം ചെയ്യാം.

▍ജാവ ആപ്ലിക്കേഷൻ കോഡ് വിശകലനം

പിശക് സംഭവിക്കുന്ന കോഡ് സ്നിപ്പറ്റ് ഇതാ.

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

1. എസ് ൽentimentController അവിടെ ഒരു വയലുണ്ട് saLogicApiUrl. അതിന്റെ മൂല്യം സ്വത്ത് വ്യക്തമാക്കുന്നു sa.logic.api.url.
2. സ്ട്രിംഗ് saLogicApiUrl മൂല്യവുമായി സംയോജിപ്പിക്കുന്നു /analyse/sentiment. ടെക്സ്റ്റ് വിശകലനം നടത്തുന്ന മൈക്രോസർവീസിലേക്ക് കോൾ ചെയ്യുന്നതിനുള്ള വിലാസം അവർ ഒരുമിച്ച് രൂപപ്പെടുത്തുന്നു.

▍ഒരു പ്രോപ്പർട്ടി മൂല്യം സജ്ജമാക്കുക

വസന്തകാലത്ത്, പ്രോപ്പർട്ടി മൂല്യങ്ങളുടെ അടിസ്ഥാന ഉറവിടം ഒരു ഫയലാണ് application.properties, എന്നതിൽ കണ്ടെത്താനാകും sa-webapp/src/main/resources. എന്നാൽ അതിന്റെ ഉപയോഗം മാത്രമല്ല പ്രോപ്പർട്ടി മൂല്യങ്ങൾ സജ്ജീകരിക്കുന്നതിനുള്ള ഏക മാർഗം. ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ചും ഇത് ചെയ്യാൻ കഴിയും:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

ഈ വസ്തുവിന്റെ മൂല്യം ഞങ്ങളുടെ പൈത്തൺ ആപ്ലിക്കേഷന്റെ വിലാസത്തിലേക്ക് ചൂണ്ടിക്കാണിച്ചിരിക്കണം.

ഇത് കോൺഫിഗർ ചെയ്യുന്നതിലൂടെ, ടെക്സ്റ്റ് വിശകലന അഭ്യർത്ഥനകൾ നടത്താൻ അത് എവിടെ പോകണമെന്ന് ഞങ്ങൾ സ്പ്രിംഗ് വെബ് ആപ്ലിക്കേഷനോട് പറയുന്നു.

ഞങ്ങളുടെ ജീവിതം സങ്കീർണ്ണമാക്കാതിരിക്കാൻ, പൈത്തൺ ആപ്ലിക്കേഷൻ ഇവിടെ ലഭ്യമാകുമെന്ന് ഞങ്ങൾ തീരുമാനിക്കും localhost:5000 അതിനെക്കുറിച്ച് മറക്കാതിരിക്കാൻ ശ്രമിക്കാം. തൽഫലമായി, സ്പ്രിംഗ് ആപ്ലിക്കേഷൻ സമാരംഭിക്കുന്നതിനുള്ള കമാൻഡ് ഇതുപോലെ കാണപ്പെടും:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

ഞങ്ങളുടെ സിസ്റ്റത്തിൽ ഒരു പൈത്തൺ ആപ്ലിക്കേഷൻ നഷ്‌ടമായി

ഇപ്പോൾ നമ്മൾ ചെയ്യേണ്ടത് പൈത്തൺ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുക, സിസ്റ്റം പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കും.

▍ഒരു പൈത്തൺ ആപ്ലിക്കേഷൻ സജ്ജീകരിക്കുന്നു

ഒരു പൈത്തൺ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾ പൈത്തൺ 3, പിപ്പ് എന്നിവ ഇൻസ്റ്റാൾ ചെയ്തിരിക്കണം, കൂടാതെ ഉചിതമായ എൻവയോൺമെന്റ് വേരിയബിളുകൾ ശരിയായി സജ്ജീകരിച്ചിരിക്കണം.

▍ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു

നിങ്ങളുടെ പ്രോജക്റ്റ് ഫോൾഡറിലേക്ക് പോകുക sa-logic/sa കൂടാതെ ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

▍ആപ്ലിക്കേഷൻ സമാരംഭിക്കുക

ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കാൻ ഞങ്ങൾ തയ്യാറാണ്:

python sentiment_analysis.py

ഈ കമാൻഡ് പ്രവർത്തിപ്പിച്ചതിന് ശേഷം ഞങ്ങളോട് ഇനിപ്പറയുന്നവ പറയും:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

ഇതിനർത്ഥം ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുകയും അഭ്യർത്ഥനകൾക്കായി കാത്തിരിക്കുകയും ചെയ്യുന്നു എന്നാണ് localhost:5000/

▍കോഡ് ഗവേഷണം

അഭ്യർത്ഥനകളോട് എങ്ങനെ പ്രതികരിക്കുന്നുവെന്ന് മനസിലാക്കാൻ പൈത്തൺ ആപ്ലിക്കേഷൻ കോഡ് നോക്കാം:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

1. ഒരു വസ്തുവിനെ ആരംഭിക്കുന്നു Flask.
2. അതിലേക്ക് POST അഭ്യർത്ഥനകൾ നടത്തുന്നതിനുള്ള ഒരു വിലാസം വ്യക്തമാക്കുന്നു.
3. ഒരു സ്വത്ത് വീണ്ടെടുക്കുന്നു sentence അഭ്യർത്ഥന ബോഡിയിൽ നിന്ന്.
4. ഒരു അജ്ഞാത വസ്തുവിനെ ആരംഭിക്കുന്നു TextBlob മൂല്യം നേടുകയും ചെയ്യുന്നു polarity അഭ്യർത്ഥനയുടെ ബോഡിയിൽ ലഭിച്ച ആദ്യ വാചകത്തിന് (ഞങ്ങളുടെ കാര്യത്തിൽ, വിശകലനത്തിനായി അയച്ച ഒരേയൊരു വാക്യമാണിത്).
5. വാക്യത്തിന്റെ വാചകവും അതിനായി കണക്കാക്കിയ സൂചകവും അടങ്ങിയിരിക്കുന്ന പ്രതികരണം നൽകുന്നു polarity.
6. ഒരു ഫ്ലാസ്ക് ആപ്ലിക്കേഷൻ സമാരംഭിക്കുക, അത് ഇവിടെ ലഭ്യമാകും 0.0.0.0:5000 (ഫോറത്തിന്റെ ഒരു നിർമ്മാണം ഉപയോഗിച്ച് നിങ്ങൾക്കത് ആക്സസ് ചെയ്യാനും കഴിയും localhost:5000).

ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്ന മൈക്രോസർവീസുകൾ ഇപ്പോൾ പ്രവർത്തിക്കുന്നു. അവർ പരസ്പരം ഇടപഴകാൻ ട്യൂൺ ചെയ്തിരിക്കുന്നു. ജോലിയുടെ ഈ ഘട്ടത്തിൽ ആപ്ലിക്കേഷൻ ഡയഗ്രം ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്.

ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്ന എല്ലാ മൈക്രോസർവീസുകളും പ്രവർത്തന ക്രമത്തിലേക്ക് കൊണ്ടുവരുന്നു

ഇപ്പോൾ, നിങ്ങൾ തുടരുന്നതിന് മുമ്പ്, ഒരു ബ്രൗസറിൽ നിങ്ങളുടെ റിയാക്റ്റ് ആപ്ലിക്കേഷൻ തുറന്ന് കുറച്ച് വാചകം പാഴ്‌സ് ചെയ്യാൻ ശ്രമിക്കുക. എല്ലാം ശരിയായി ചെയ്തുവെങ്കിൽ - ബട്ടൺ അമർത്തിയാൽ Send ടെക്സ്റ്റ് ഫീൽഡിന് താഴെയുള്ള വിശകലന ഫലങ്ങൾ നിങ്ങൾ കാണും.

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

ഡോക്കർ കണ്ടെയ്നറുകൾ

കുബേർനെറ്റ് കണ്ടെയ്നറൈസ്ഡ് ആപ്ലിക്കേഷനുകളുടെ വിന്യാസം, സ്കെയിലിംഗ്, മാനേജ്മെന്റ് എന്നിവ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനമാണ്. ഇതിനെ "കണ്ടെയ്നർ ഓർക്കസ്ട്രേറ്റർ" എന്നും വിളിക്കുന്നു. Kubernetes കണ്ടെയ്‌നറുകളിൽ പ്രവർത്തിക്കുന്നുവെങ്കിൽ, ഈ സിസ്റ്റം ഉപയോഗിക്കുന്നതിന് മുമ്പ് നമ്മൾ ആദ്യം ഈ കണ്ടെയ്നറുകൾ സ്വന്തമാക്കണം. എന്നാൽ ആദ്യം, കണ്ടെയ്നറുകൾ എന്താണെന്നതിനെക്കുറിച്ച് സംസാരിക്കാം. അത് എന്താണെന്ന ചോദ്യത്തിനുള്ള ഏറ്റവും നല്ല ഉത്തരം ഒരുപക്ഷേ കണ്ടെത്താനാകും പ്രമാണീകരണം ഡോക്കറിലേക്ക്:

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

പ്രൊഡക്ഷൻ സെർവറുകൾ ഉൾപ്പെടെ ഏത് കമ്പ്യൂട്ടറിലും കണ്ടെയ്‌നറുകൾ പ്രവർത്തിപ്പിക്കാമെന്നാണ് ഇതിനർത്ഥം, അവയിൽ അടങ്ങിയിരിക്കുന്ന ആപ്ലിക്കേഷനുകൾ ഏത് പരിതസ്ഥിതിയിലും ഒരേപോലെ പ്രവർത്തിക്കും.

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

▍ഒരു വെർച്വൽ മെഷീൻ ഉപയോഗിച്ച് ഒരു റിയാക്റ്റ് ആപ്ലിക്കേഷന്റെ സ്റ്റാറ്റിക് ഫയലുകൾ നൽകുന്നു

വെർച്വൽ മെഷീനുകൾ ഉപയോഗിച്ച് സ്റ്റാറ്റിക് ഫയലുകളുടെ സേവനം ഓർഗനൈസുചെയ്യാൻ ശ്രമിക്കുമ്പോൾ, ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന ദോഷങ്ങൾ നേരിടേണ്ടിവരും:

1. ഓരോ വെർച്വൽ മെഷീനും ഒരു പൂർണ്ണമായ ഓപ്പറേറ്റിംഗ് സിസ്റ്റമായതിനാൽ വിഭവങ്ങളുടെ കാര്യക്ഷമമല്ലാത്ത ഉപയോഗം.
2. പ്ലാറ്റ്ഫോം ആശ്രിതത്വം. ഒരു പ്രാദേശിക കമ്പ്യൂട്ടറിൽ പ്രവർത്തിക്കുന്നവ ഒരു പ്രൊഡക്ഷൻ സെർവറിൽ പ്രവർത്തിച്ചേക്കില്ല.
3. ഒരു വെർച്വൽ മെഷീൻ അധിഷ്‌ഠിത സൊല്യൂഷന്റെ സ്ലോ, റിസോഴ്‌സ്-ഇന്റൻസീവ് സ്കെയിലിംഗ്.

ഒരു വെർച്വൽ മെഷീനിൽ പ്രവർത്തിക്കുന്ന സ്റ്റാറ്റിക് ഫയലുകൾ നൽകുന്ന Nginx വെബ് സെർവർ

സമാനമായ ഒരു പ്രശ്നം പരിഹരിക്കാൻ കണ്ടെയ്നറുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, വെർച്വൽ മെഷീനുകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, ഇനിപ്പറയുന്ന ശക്തികൾ ശ്രദ്ധിക്കാവുന്നതാണ്:

1. വിഭവങ്ങളുടെ കാര്യക്ഷമമായ ഉപയോഗം: ഡോക്കർ ഉപയോഗിച്ച് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുക.
2. സ്വതന്ത്ര പ്ലാറ്റ്ഫോം. ഒരു ഡെവലപ്പർക്ക് തന്റെ കമ്പ്യൂട്ടറിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു കണ്ടെയ്‌നർ എവിടെയും പ്രവർത്തിക്കും.
3. ഇമേജ് ലെയറുകളുടെ ഉപയോഗത്തിലൂടെ ഭാരം കുറഞ്ഞ വിന്യാസം.

ഒരു കണ്ടെയ്‌നറിൽ പ്രവർത്തിക്കുന്ന സ്റ്റാറ്റിക് ഫയലുകൾ നൽകുന്ന Nginx വെബ് സെർവർ

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

▍ഒരു റിയാക്റ്റ് ആപ്ലിക്കേഷനായി ഒരു കണ്ടെയ്‌നർ ഇമേജ് നിർമ്മിക്കുന്നു

ഒരു ഡോക്കർ കണ്ടെയ്‌നറിന്റെ അടിസ്ഥാന നിർമ്മാണ ബ്ലോക്ക് ഫയലാണ് Dockerfile. ഈ ഫയലിന്റെ തുടക്കത്തിൽ, കണ്ടെയ്‌നറിന്റെ അടിസ്ഥാന ഇമേജ് ഉപയോഗിച്ച് ഒരു റെക്കോർഡ് നിർമ്മിക്കുന്നു, തുടർന്ന് ഒരു പ്രത്യേക ആപ്ലിക്കേഷന്റെ ആവശ്യങ്ങൾ നിറവേറ്റുന്ന ഒരു കണ്ടെയ്നർ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് സൂചിപ്പിക്കുന്ന നിർദ്ദേശങ്ങളുടെ ഒരു ശ്രേണി ഉണ്ട്.

ഞങ്ങൾ ഫയലുമായി പ്രവർത്തിക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ് Dockerfile, Nginx സെർവറിലേക്ക് അപ്‌ലോഡ് ചെയ്യുന്നതിനായി റിയാക്റ്റ് ആപ്ലിക്കേഷൻ ഫയലുകൾ തയ്യാറാക്കാൻ ഞങ്ങൾ എന്താണ് ചെയ്തതെന്ന് ഓർക്കുക:

1. ഒരു റിയാക്റ്റ് ആപ്ലിക്കേഷൻ പാക്കേജ് നിർമ്മിക്കുന്നു (npm run build).
2. Nginx സെർവർ ആരംഭിക്കുന്നു.
3. ഡയറക്ടറി ഉള്ളടക്കങ്ങൾ പകർത്തുന്നു build പ്രോജക്റ്റ് ഫോൾഡറിൽ നിന്ന് sa-frontend സെർവർ ഫോൾഡറിലേക്ക് nginx/html.

ഒരു കണ്ടെയ്‌നർ സൃഷ്‌ടിക്കുന്നതും നിങ്ങളുടെ ലോക്കൽ കമ്പ്യൂട്ടറിൽ നടപ്പിലാക്കുന്ന മുകളിലെ ഘട്ടങ്ങളും തമ്മിലുള്ള സമാന്തരങ്ങൾ നിങ്ങൾക്ക് ചുവടെ കാണാൻ കഴിയും.

▍SA-Frontend ആപ്ലിക്കേഷനായി ഡോക്കർഫയൽ തയ്യാറാക്കുന്നു

അതിൽ അടങ്ങിയിരിക്കുന്ന നിർദ്ദേശങ്ങൾ Dockerfile അപേക്ഷയ്ക്കായി SA-Frontend, രണ്ട് ടീമുകൾ മാത്രം ഉൾക്കൊള്ളുന്നു. Nginx ഡെവലപ്‌മെന്റ് ടീം ഒരു അടിസ്ഥാനം തയ്യാറാക്കിയിട്ടുണ്ട് എന്നതാണ് വസ്തുത ഒരു ചിത്രം Nginx-നായി, അത് ഞങ്ങളുടെ ഇമേജ് സൃഷ്ടിക്കാൻ ഞങ്ങൾ ഉപയോഗിക്കും. ഞങ്ങൾ വിവരിക്കേണ്ട രണ്ട് ഘട്ടങ്ങൾ ഇവയാണ്:

1. ചിത്രത്തിന്റെ അടിസ്ഥാനം Nginx ഇമേജ് ആയിരിക്കണം.
2. ഫോൾഡർ ഉള്ളടക്കം sa-frontend/build ഇമേജ് ഫോൾഡറിലേക്ക് പകർത്തേണ്ടതുണ്ട് nginx/html.

നിങ്ങൾ ഈ വിവരണത്തിൽ നിന്ന് ഫയലിലേക്ക് പോയാൽ Dockerfile, അപ്പോൾ ഇത് ഇതുപോലെ കാണപ്പെടും:

FROM nginx
COPY build /usr/share/nginx/html

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഇവിടെ എല്ലാം വളരെ ലളിതമാണ്, കൂടാതെ ഫയലിലെ ഉള്ളടക്കങ്ങൾ പോലും വായിക്കാവുന്നതും മനസ്സിലാക്കാവുന്നതുമായി മാറുന്നു. ചിത്രമെടുക്കാൻ ഈ ഫയൽ സിസ്റ്റത്തോട് പറയുന്നു nginx അതിൽ ഇതിനകം ഉള്ളതെല്ലാം ഉപയോഗിച്ച്, ഡയറക്ടറിയുടെ ഉള്ളടക്കങ്ങൾ പകർത്തുക build ഡയറക്ടറിയിലേക്ക് nginx/html.

ഫോൾഡറിൽ നിന്ന് ഫയലുകൾ എവിടെയാണ് പകർത്തേണ്ടതെന്ന് എനിക്കറിയുന്നത് എങ്ങനെ എന്നതിനെക്കുറിച്ച് ഇവിടെ നിങ്ങൾക്ക് ഒരു ചോദ്യം ഉണ്ടായേക്കാം build, അതായത്, പാത എവിടെ നിന്നാണ് വന്നത് /usr/share/nginx/html. വാസ്തവത്തിൽ, ഇവിടെയും സങ്കീർണ്ണമായ ഒന്നും തന്നെയില്ല. പ്രസക്തമായ വിവരങ്ങൾ ഇതിൽ കണ്ടെത്താനാകും എന്നതാണ് വസ്തുത വിവരണം ചിത്രം.

▍ചിത്രം നിർമ്മിക്കുകയും ശേഖരത്തിലേക്ക് അപ്‌ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു

പൂർത്തിയായ ചിത്രവുമായി പ്രവർത്തിക്കുന്നതിന് മുമ്പ്, അത് ഇമേജ് റിപ്പോസിറ്ററിയിലേക്ക് തള്ളേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ സൗജന്യ ക്ലൗഡ് ഇമേജ് ഹോസ്റ്റിംഗ് പ്ലാറ്റ്ഫോം ഡോക്കർ ഹബ് ഉപയോഗിക്കും. ജോലിയുടെ ഈ ഘട്ടത്തിൽ നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യേണ്ടതുണ്ട്:

1. ഇൻസ്റ്റാൾ ചെയ്യുക ഡോക്കർ.
2. ഡോക്കർ ഹബ് വെബ്സൈറ്റിൽ രജിസ്റ്റർ ചെയ്യുക.
3. ടെർമിനലിൽ ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിച്ച് നിങ്ങളുടെ അക്കൗണ്ടിലേക്ക് ലോഗിൻ ചെയ്യുക:

   docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"

ഇപ്പോൾ നിങ്ങൾ ഡയറക്ടറിയിലേക്ക് പോകാൻ ടെർമിനൽ ഉപയോഗിക്കേണ്ടതുണ്ട് sa-frontend താഴെ പറയുന്ന കമാൻഡ് അവിടെ പ്രവർത്തിപ്പിക്കുക:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

സമാനമായ കമാൻഡുകളിൽ ഇവിടെയും കൂടുതലും $DOCKER_USER_ID നിങ്ങളുടെ ഡോക്കർ ഹബ് ഉപയോക്തൃനാമം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കേണ്ടതാണ്. ഉദാഹരണത്തിന്, കമാൻഡിന്റെ ഈ ഭാഗം ഇതുപോലെയാകാം: rinormaloku/sentiment-analysis-frontend.

ഈ സാഹചര്യത്തിൽ, അതിൽ നിന്ന് നീക്കം ചെയ്തുകൊണ്ട് ഈ കമാൻഡ് ചെറുതാക്കാം -f Dockerfile, ഞങ്ങൾ ഈ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്ന ഫോൾഡറിൽ ഈ ഫയൽ ഇതിനകം തന്നെ ഉള്ളതിനാൽ.

പൂർത്തിയായ ചിത്രം റിപ്പോസിറ്ററിയിലേക്ക് അയയ്ക്കുന്നതിന്, നമുക്ക് ഇനിപ്പറയുന്ന കമാൻഡ് ആവശ്യമാണ്:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

ഇത് പൂർത്തിയാക്കിയ ശേഷം, ക്ലൗഡ് സ്റ്റോറേജിലേക്ക് ചിത്രം അപ്‌ലോഡ് ചെയ്യുന്നത് വിജയകരമാണോ എന്ന് മനസിലാക്കാൻ ഡോക്കർ ഹബിലെ നിങ്ങളുടെ റിപ്പോസിറ്ററികളുടെ ലിസ്റ്റ് പരിശോധിക്കുക.

▍ഒരു കണ്ടെയ്നർ പ്രവർത്തിപ്പിക്കുന്നു

എന്നറിയപ്പെടുന്ന ചിത്രം ഇപ്പോൾ ആർക്കും ഡൗൺലോഡ് ചെയ്ത് പ്രവർത്തിപ്പിക്കാം $DOCKER_USER_ID/sentiment-analysis-frontend. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്ന കമാൻഡുകളുടെ ക്രമം പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

ഇപ്പോൾ കണ്ടെയ്‌നർ പ്രവർത്തിക്കുന്നു, നമുക്ക് ആവശ്യമായ മറ്റ് ചിത്രങ്ങൾ സൃഷ്‌ടിച്ച് നമുക്ക് ജോലി തുടരാം. എന്നാൽ തുടരുന്നതിന് മുമ്പ്, നമുക്ക് ഡിസൈൻ മനസ്സിലാക്കാം 80:80, ഇത് ഇമേജ് ലോഞ്ച് കമാൻഡിൽ ദൃശ്യമാകുകയും ആശയക്കുഴപ്പമുണ്ടാക്കുന്നതായി തോന്നുകയും ചെയ്യും.

• ആദ്യ നമ്പർ 80 — ഇതാണ് ഹോസ്റ്റ് പോർട്ട് നമ്പർ (അതായത്, ലോക്കൽ കമ്പ്യൂട്ടർ).
• രണ്ടാം നമ്പർ 80 അഭ്യർത്ഥന കൈമാറേണ്ട കണ്ടെയ്‌നറിന്റെ പോർട്ട് ആണ്.

ഇനിപ്പറയുന്ന ദൃഷ്ടാന്തം പരിഗണിക്കുക.

പോർട്ട് ഫോർവേഡിംഗ്

പോർട്ടിൽ നിന്നുള്ള അഭ്യർത്ഥനകൾ സിസ്റ്റം റീഡയറക്‌ട് ചെയ്യുന്നു <hostPort> തുറമുഖത്തേക്ക് <containerPort>. അതായത്, തുറമുഖത്തിലേക്കുള്ള പ്രവേശനം 80 കമ്പ്യൂട്ടർ പോർട്ടിലേക്ക് റീഡയറക്‌ട് ചെയ്‌തു 80 കണ്ടെയ്നർ.

തുറമുഖം മുതൽ 80 ലോക്കൽ കമ്പ്യൂട്ടറിൽ തുറന്നു, തുടർന്ന് നിങ്ങൾക്ക് ഈ കമ്പ്യൂട്ടറിൽ നിന്ന് ആപ്ലിക്കേഷൻ ആക്സസ് ചെയ്യാൻ കഴിയും localhost:80. നിങ്ങളുടെ സിസ്റ്റം ഡോക്കറിനെ പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ, ആപ്ലിക്കേഷൻ ഒരു ഡോക്കർ വെർച്വൽ മെഷീനിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയും, അതിന്റെ വിലാസം ഇങ്ങനെയായിരിക്കും <docker-machine ip>:80. ഡോക്കർ വെർച്വൽ മെഷീന്റെ IP വിലാസം കണ്ടെത്താൻ, നിങ്ങൾക്ക് കമാൻഡ് ഉപയോഗിക്കാം docker-machine ip.

ഈ ഘട്ടത്തിൽ, ഫ്രണ്ട്-എൻഡ് ആപ്ലിക്കേഷൻ കണ്ടെയ്നർ വിജയകരമായി സമാരംഭിച്ചതിന് ശേഷം, നിങ്ങൾക്ക് ബ്രൗസറിൽ അതിന്റെ പേജ് തുറക്കാൻ കഴിയും.

▍The .dockerignore ഫയൽ

ഒരു ആപ്ലിക്കേഷൻ ഇമേജ് ശേഖരിക്കുന്നു SA-Frontend, ഈ പ്രക്രിയ വളരെ മന്ദഗതിയിലാകുന്നത് നമുക്ക് ശ്രദ്ധിക്കാം. ഇമേജ് ബിൽഡ് സന്ദർഭം ഡോക്കർ ഡെമണിലേക്ക് അയയ്‌ക്കേണ്ടതിനാലാണ് ഇത് സംഭവിക്കുന്നത്. ബിൽഡ് സന്ദർഭത്തെ പ്രതിനിധീകരിക്കുന്ന ഡയറക്ടറി കമാൻഡിന്റെ അവസാന ആർഗ്യുമെന്റായി വ്യക്തമാക്കിയിരിക്കുന്നു docker build. ഞങ്ങളുടെ കാര്യത്തിൽ, ഈ കമാൻഡിന്റെ അവസാനം ഒരു ഡോട്ട് ഉണ്ട്. നിർമ്മാണ സന്ദർഭത്തിൽ ഇനിപ്പറയുന്ന ഘടന ഉൾപ്പെടുത്തുന്നതിന് ഇത് കാരണമാകുന്നു:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

എന്നാൽ ഇവിടെയുള്ള എല്ലാ ഫോൾഡറുകളിലും നമുക്ക് ഫോൾഡർ മാത്രമേ ആവശ്യമുള്ളൂ build. മറ്റെന്തെങ്കിലും ലോഡ് ചെയ്യുന്നത് സമയം പാഴാക്കലാണ്. ഏതൊക്കെ ഡയറക്ടറികൾ അവഗണിക്കണമെന്ന് ഡോക്കറിനോട് പറഞ്ഞുകൊണ്ട് നിങ്ങൾക്ക് ബിൽഡ് വേഗത്തിലാക്കാം. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾക്ക് ഫയൽ ആവശ്യമാണ് .dockerignore. നിങ്ങൾ, നിങ്ങൾക്ക് ഫയലുമായി പരിചയമുണ്ടെങ്കിൽ .gitignore, ഈ ഫയലിന്റെ ഘടന ഒരുപക്ഷേ പരിചിതമാണെന്ന് തോന്നും. ഇമേജ് ബിൽഡ് സിസ്റ്റത്തിന് അവഗണിക്കാൻ കഴിയുന്ന ഡയറക്ടറികൾ ഇത് പട്ടികപ്പെടുത്തുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, ഈ ഫയലിന്റെ ഉള്ളടക്കം ഇതുപോലെ കാണപ്പെടുന്നു:

node_modules
src
public

ഫയല് .dockerignore ഫയലിന്റെ അതേ ഫോൾഡറിൽ ആയിരിക്കണം Dockerfile. ഇപ്പോൾ ചിത്രം നിർമ്മിക്കുന്നത് നിമിഷങ്ങൾ എടുക്കും.

നമുക്ക് ഇപ്പോൾ ജാവ ആപ്ലിക്കേഷനായി ഇമേജിൽ പ്രവർത്തിക്കാം.

▍ഒരു ജാവ ആപ്ലിക്കേഷനായി ഒരു കണ്ടെയ്‌നർ ഇമേജ് നിർമ്മിക്കുന്നു

നിങ്ങൾക്കറിയാമോ, കണ്ടെയ്‌നർ ഇമേജുകൾ സൃഷ്‌ടിക്കാൻ നിങ്ങൾ അറിയേണ്ടതെല്ലാം നിങ്ങൾ ഇതിനകം പഠിച്ചുകഴിഞ്ഞു. അതുകൊണ്ടാണ് ഈ വിഭാഗം വളരെ ചെറുതായിരിക്കും.

ഫയൽ തുറക്കുക Dockerfileപ്രൊജക്റ്റ് ഫോൾഡറിലുള്ളത് sa-webapp. ഈ ഫയലിന്റെ ടെക്‌സ്‌റ്റ് നിങ്ങൾ വായിച്ചാൽ, കീവേഡുകളിൽ തുടങ്ങി രണ്ട് പുതിയ നിർമ്മാണങ്ങൾ മാത്രമേ നിങ്ങൾ അതിൽ കാണൂ ENV и EXPOSE:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

കീവേഡ് ENV ഡോക്കർ കണ്ടെയ്‌നറുകളിൽ പരിസ്ഥിതി വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. പ്രത്യേകിച്ചും, ഞങ്ങളുടെ കാര്യത്തിൽ, ടെക്സ്റ്റ് വിശകലനം നടത്തുന്ന ആപ്ലിക്കേഷന്റെ API ആക്സസ് ചെയ്യുന്നതിന് ഒരു URL വ്യക്തമാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

കീവേഡ് EXPOSE ഒരു പോർട്ട് തുറക്കാൻ ഡോക്കറിനോട് പറയാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുമ്പോൾ ഞങ്ങൾ ഈ പോർട്ട് ഉപയോഗിക്കാൻ പോകുന്നു. ഇവിടെ നിങ്ങൾക്ക് അത് ശ്രദ്ധിക്കാം Dockerfile അപേക്ഷയ്ക്കായി SA-Frontend അങ്ങനെയൊരു കൽപ്പന ഇല്ല. ഇത് ഡോക്യുമെന്റേഷൻ ആവശ്യങ്ങൾക്ക് മാത്രമുള്ളതാണ്, മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഈ നിർമ്മാണം വായിക്കുന്നവരെ ഉദ്ദേശിച്ചുള്ളതാണ് Dockerfile.

ഇമേജ് നിർമ്മിക്കുന്നതും റിപ്പോസിറ്ററിയിലേക്ക് തള്ളുന്നതും മുമ്പത്തെ ഉദാഹരണത്തിലെ പോലെ തന്നെ കാണപ്പെടുന്നു. നിങ്ങളുടെ കഴിവുകളിൽ നിങ്ങൾക്ക് ഇതുവരെ വിശ്വാസമില്ലെങ്കിൽ, അനുബന്ധ കമാൻഡുകൾ ഫയലിൽ കണ്ടെത്താനാകും README.md ഫോൾഡറിൽ sa-webapp.

▍പൈത്തൺ ആപ്ലിക്കേഷനായി ഒരു കണ്ടെയ്‌നർ ഇമേജ് നിർമ്മിക്കുന്നു

ഫയലിന്റെ ഉള്ളടക്കം നോക്കിയാൽ Dockerfile ഫോൾഡറിൽ sa-logic, അപ്പോൾ നിങ്ങൾക്കായി പുതിയതൊന്നും അവിടെ കണ്ടെത്തുകയില്ല. ഇമേജ് നിർമ്മിക്കുന്നതിനും ശേഖരത്തിലേക്ക് അയയ്ക്കുന്നതിനുമുള്ള കമാൻഡുകൾ നിങ്ങൾക്ക് ഇതിനകം പരിചിതമായിരിക്കണം, പക്ഷേ, ഞങ്ങളുടെ മറ്റ് ആപ്ലിക്കേഷനുകൾ പോലെ, അവ ഫയലിൽ കണ്ടെത്താനാകും README.md ഫോൾഡറിൽ sa-logic.

▍കണ്ടെയ്നറൈസ്ഡ് ആപ്ലിക്കേഷനുകൾ പരിശോധിക്കുന്നു

നിങ്ങൾ പരീക്ഷിച്ചിട്ടില്ലാത്ത എന്തെങ്കിലും വിശ്വസിക്കാമോ? എനിക്കും വയ്യ. നമുക്ക് നമ്മുടെ കണ്ടെയ്നറുകൾ പരിശോധിക്കാം.

1. നമുക്ക് ആപ്ലിക്കേഷൻ കണ്ടെയ്നർ സമാരംഭിക്കാം sa-logic പോർട്ടിൽ കേൾക്കാൻ അത് കോൺഫിഗർ ചെയ്യുക 5050:

   docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic

2. നമുക്ക് ആപ്ലിക്കേഷൻ കണ്ടെയ്നർ സമാരംഭിക്കാം sa-webapp പോർട്ടിൽ കേൾക്കാൻ അത് കോൺഫിഗർ ചെയ്യുക 8080. കൂടാതെ, എൻവയോൺമെന്റ് വേരിയബിൾ വീണ്ടും അസൈൻ ചെയ്‌ത് ജാവ ആപ്ലിക്കേഷനിൽ നിന്നുള്ള അഭ്യർത്ഥനകൾക്കായി പൈത്തൺ ആപ്ലിക്കേഷൻ ശ്രദ്ധിക്കുന്ന പോർട്ട് ഞങ്ങൾ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്. SA_LOGIC_API_URL:

   $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app

ഒരു ഡോക്കർ കണ്ടെയ്‌നറിന്റെയോ വെർച്വൽ മെഷീന്റെയോ ഐപി വിലാസം എങ്ങനെ കണ്ടെത്താം എന്നറിയാൻ, ഫയൽ കാണുക വായിക്കുക.

നമുക്ക് ആപ്ലിക്കേഷൻ കണ്ടെയ്നർ സമാരംഭിക്കാം sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

ഇപ്പോൾ ബ്രൗസറിലെ വിലാസത്തിലേക്ക് പോകാൻ എല്ലാം തയ്യാറാണ് localhost:80 കൂടാതെ ആപ്ലിക്കേഷൻ പരീക്ഷിക്കുക.

നിങ്ങൾ പോർട്ട് മാറ്റിയെങ്കിൽ എന്നത് ശ്രദ്ധിക്കുക sa-webapp, അല്ലെങ്കിൽ നിങ്ങൾ ഒരു ഡോക്കർ വെർച്വൽ മെഷീൻ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഫയൽ എഡിറ്റ് ചെയ്യേണ്ടതുണ്ട് App.js ഒരു ഫോൾഡറിൽ നിന്ന് sa-frontendരീതിയിലുള്ള IP വിലാസമോ പോർട്ട് നമ്പറോ മാറ്റുന്നതിലൂടെ analyzeSentence(), കാലഹരണപ്പെട്ട ഡാറ്റയ്ക്ക് പകരം നിലവിലെ വിവരങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നു. ഇതിനുശേഷം, നിങ്ങൾ ചിത്രം വീണ്ടും കൂട്ടിച്ചേർക്കുകയും അത് ഉപയോഗിക്കുകയും വേണം.

ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ ഡയഗ്രം ഇപ്പോൾ ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്.

മൈക്രോ സർവീസുകൾ കണ്ടെയ്‌നറുകളിൽ പ്രവർത്തിക്കുന്നു

സംഗ്രഹം: എന്തുകൊണ്ടാണ് ഞങ്ങൾക്ക് ഒരു കുബർനെറ്റസ് ക്ലസ്റ്റർ വേണ്ടത്?

ഞങ്ങൾ ഫയലുകൾ പരിശോധിച്ചു Dockerfile, ചിത്രങ്ങൾ എങ്ങനെ നിർമ്മിക്കാമെന്നും അവയെ ഒരു ഡോക്കർ ശേഖരത്തിലേക്ക് തള്ളാമെന്നും സംസാരിച്ചു. കൂടാതെ, ഫയൽ ഉപയോഗിച്ച് ഇമേജ് അസംബ്ലി എങ്ങനെ വേഗത്തിലാക്കാമെന്ന് ഞങ്ങൾ പഠിച്ചു .dockerignore. തൽഫലമായി, ഞങ്ങളുടെ മൈക്രോസർവീസുകൾ ഇപ്പോൾ ഡോക്കർ കണ്ടെയ്‌നറുകളിൽ പ്രവർത്തിക്കുന്നു. എന്തുകൊണ്ടാണ് ഞങ്ങൾക്ക് കുബർനെറ്റസ് ആവശ്യമായി വരുന്നത് എന്നതിനെക്കുറിച്ചുള്ള തികച്ചും ന്യായമായ ഒരു ചോദ്യം ഇവിടെ നിങ്ങൾക്ക് ഉണ്ടായേക്കാം. ഈ മെറ്റീരിയലിന്റെ രണ്ടാം ഭാഗം ഈ ചോദ്യത്തിന് ഉത്തരം നൽകും. അതിനിടയിൽ, ഇനിപ്പറയുന്ന ചോദ്യം പരിഗണിക്കുക:
ടെക്സ്റ്റ് വിശകലനത്തിനായുള്ള ഞങ്ങളുടെ വെബ് ആപ്ലിക്കേഷൻ ലോകമെമ്പാടും ജനപ്രിയമായിത്തീർന്നുവെന്ന് നമുക്ക് അനുമാനിക്കാം. ഓരോ മിനിറ്റിലും ദശലക്ഷക്കണക്കിന് അഭ്യർത്ഥനകൾ അവനിലേക്ക് വരുന്നു. ഇതിനർത്ഥം മൈക്രോസർവീസുകൾ എന്നാണ് sa-webapp и sa-logic വലിയ ലോഡിന് കീഴിലായിരിക്കും. മൈക്രോസർവീസുകൾ പ്രവർത്തിപ്പിക്കുന്ന കണ്ടെയ്‌നറുകൾ എങ്ങനെ സ്കെയിൽ ചെയ്യാം?

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