ക്ഷമിക്കണം OpenShift, ഞങ്ങൾ നിങ്ങളെ വേണ്ടത്ര അഭിനന്ദിച്ചില്ല, മാത്രമല്ല നിങ്ങളെ നിസ്സാരമായി കാണുകയും ചെയ്തു

Kubernetes-ലെ ആപ്ലിക്കേഷൻ വികസനത്തെക്കുറിച്ചും OpenShift-ലെ അത്തരം വികസനത്തിന്റെ പ്രത്യേകതകളെക്കുറിച്ചും ഞങ്ങളുടെ ജീവനക്കാർ ക്ലയന്റുകളുമായി ധാരാളം സംഭാഷണങ്ങൾ നടത്തിയതിനാലാണ് ഈ പോസ്റ്റ് എഴുതിയത്.

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

പൊതുവേ, ഞങ്ങൾ ഈ കുറിപ്പ് എഴുതുന്നത് പോലെയുള്ള ഒരു ഉപസംഹാരത്തോടെയാണ് “കേൾക്കുക, OpenShift അല്ലെങ്കിൽ AKS, EKS, ചില ഇഷ്‌ടാനുസൃത കുബർനെറ്റുകൾ, അല്ലെങ്കിൽ ഏത് കുബർനെറ്റുകളിലും കോഡ് എവിടെ പ്രവർത്തിപ്പിക്കണമെന്നത് പ്രശ്നമല്ല. (സംക്ഷിപ്തതയ്ക്ക് ഇതിനെ KUK എന്ന് വിളിക്കാം) "ഇത് വളരെ ലളിതമാണ്, അവിടെയും അവിടെയും."

തുടർന്ന് ഞങ്ങൾ ഏറ്റവും ലളിതമായ "ഹലോ വേൾഡ്" എടുത്ത് അതിന്റെ ഉദാഹരണം ഉപയോഗിച്ച് KUC-യും Red Hat OpenShift കണ്ടെയ്‌നർ പ്ലാറ്റ്‌ഫോമും (ഇനിമുതൽ, OCP അല്ലെങ്കിൽ ലളിതമായി OpenShift) തമ്മിലുള്ള വ്യത്യാസം എന്താണെന്നും കാണിക്കാൻ പദ്ധതിയിട്ടു.

എന്നിരുന്നാലും, ഞങ്ങൾ ഈ കുറിപ്പ് എഴുതിയപ്പോൾ, ഞങ്ങൾ ഓപ്പൺഷിഫ്റ്റ് ഉപയോഗിക്കുന്നത് വളരെക്കാലമായി ഉപയോഗിച്ചിരുന്നുവെന്ന് ഞങ്ങൾ മനസ്സിലാക്കി, അത് എങ്ങനെ വളർന്നുവെന്നും ഒരു കുബർനെറ്റസ് വിതരണത്തേക്കാൾ വളരെ കൂടുതലായി മാറിയ ഒരു അത്ഭുതകരമായ പ്ലാറ്റ്‌ഫോമായി മാറിയെന്നും ഞങ്ങൾക്ക് മനസ്സിലായില്ല. ഓപ്പൺഷിഫ്റ്റിന്റെ പക്വതയും ലാളിത്യവും ഞങ്ങൾ നിസ്സാരമായി കാണുകയും അതിന്റെ തിളക്കം കാണാതിരിക്കുകയും ചെയ്യുന്നു.

പൊതുവേ, സജീവമായ മാനസാന്തരത്തിനുള്ള സമയം വന്നിരിക്കുന്നു, ഇപ്പോൾ ഞങ്ങൾ KUK ലും OpenShift ലും ഞങ്ങളുടെ "ഹലോ വേൾഡ്" കമ്മീഷൻ ചെയ്യുന്നത് ഘട്ടം ഘട്ടമായി താരതമ്യം ചെയ്യും, ഞങ്ങൾ ഇത് കഴിയുന്നത്ര വസ്തുനിഷ്ഠമായി ചെയ്യും (നന്നായി, ചിലപ്പോൾ കാണിക്കുന്നത് ഒഴികെ. വിഷയത്തോടുള്ള വ്യക്തിപരമായ മനോഭാവം). ഈ വിഷയത്തിൽ തികച്ചും ആത്മനിഷ്ഠമായ അഭിപ്രായത്തിൽ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് അത് വായിക്കാം ഇവിടെ (EN). ഈ പോസ്റ്റിൽ ഞങ്ങൾ വസ്തുതകളിൽ ഉറച്ചുനിൽക്കും, വസ്തുതകൾ മാത്രം.

ക്ലസ്റ്ററുകൾ

അതിനാൽ, ഞങ്ങളുടെ "ഹലോ വേൾഡിന്" ക്ലസ്റ്ററുകൾ ആവശ്യമാണ്. സെർവറുകൾ, രജിസ്‌ട്രികൾ, നെറ്റ്‌വർക്കുകൾ, ഡാറ്റാ കൈമാറ്റം മുതലായവയ്‌ക്ക് പണം നൽകാതിരിക്കാൻ ഞങ്ങൾ ഏതെങ്കിലും പൊതു ക്ലൗഡുകളോട് “ഇല്ല” എന്ന് ഉടൻ പറയും. അതനുസരിച്ച്, ഞങ്ങൾ ഒരു ലളിതമായ സിംഗിൾ-നോഡ് ക്ലസ്റ്റർ തിരഞ്ഞെടുക്കുന്നു മിനിക്യൂബ് (KUK-യ്ക്ക്) ഒപ്പം കോഡ് റെഡി കണ്ടെയ്‌നറുകൾ (ഓപ്പൺഷിഫ്റ്റ് ക്ലസ്റ്ററിനായി). ഈ രണ്ട് ഓപ്ഷനുകളും ഇൻസ്റ്റാൾ ചെയ്യാൻ വളരെ എളുപ്പമാണ്, എന്നാൽ നിങ്ങളുടെ ലാപ്ടോപ്പിൽ ധാരാളം വിഭവങ്ങൾ ആവശ്യമാണ്.

KUK-e-ലെ അസംബ്ലി

അതുകൊണ്ട് നമുക്ക് പോകാം.

ഘട്ടം 1 - ഞങ്ങളുടെ കണ്ടെയ്‌നർ ഇമേജ് നിർമ്മിക്കുന്നു

നമ്മുടെ “ഹലോ വേൾഡ്” മിനിക്യൂബിലേക്ക് വിന്യസിച്ചുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം. ഇത് ചെയ്യുന്നതിന് നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

1. 1. ഇൻസ്റ്റാൾ ചെയ്ത ഡോക്കർ.
2. 2. Git ഇൻസ്റ്റാൾ ചെയ്തു.
3. 3. Maven ഇൻസ്റ്റാൾ ചെയ്തു (യഥാർത്ഥത്തിൽ, ഈ പ്രോജക്റ്റ് mvnw ബൈനറി ഉപയോഗിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് ഇത് കൂടാതെ ചെയ്യാൻ കഴിയും).
4. 4. യഥാർത്ഥത്തിൽ, ഉറവിടം തന്നെ, അതായത്. റിപ്പോസിറ്ററി ക്ലോൺ github.com/gcolman/quarkus-hello-world.git

ഒരു ക്വാർക്കസ് പ്രോജക്റ്റ് സൃഷ്ടിക്കുക എന്നതാണ് ആദ്യപടി. നിങ്ങൾ ഒരിക്കലും Quarkus.io ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ ഭയപ്പെടേണ്ട - ഇത് എളുപ്പമാണ്. നിങ്ങൾ പ്രോജക്റ്റിൽ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ഘടകങ്ങൾ തിരഞ്ഞെടുക്കുക (RestEasy, Hibernate, Amazon SQS, Camel, മുതലായവ), തുടർന്ന് Quarkus തന്നെ, നിങ്ങളുടെ പങ്കാളിത്തം ഒന്നുമില്ലാതെ, maven ആർക്കിടൈപ്പ് കോൺഫിഗർ ചെയ്യുകയും എല്ലാം github-ൽ ഇടുകയും ചെയ്യുന്നു. അതായത്, അക്ഷരാർത്ഥത്തിൽ മൗസിന്റെ ഒരു ക്ലിക്ക് - നിങ്ങൾ പൂർത്തിയാക്കി. അതുകൊണ്ടാണ് നമ്മൾ ക്വാർക്കസിനെ സ്നേഹിക്കുന്നത്.

ഞങ്ങളുടെ "ഹലോ വേൾഡ്" ഒരു കണ്ടെയ്‌നർ ഇമേജായി നിർമ്മിക്കാനുള്ള ഏറ്റവും എളുപ്പ മാർഗം ഡോക്കറിനായി ക്വാർക്കസ്-മേവൻ എക്സ്റ്റൻഷനുകൾ ഉപയോഗിക്കുക എന്നതാണ്, അത് ആവശ്യമായ എല്ലാ ജോലികളും ചെയ്യും. ക്വാർക്കസിന്റെ വരവോടെ, ഇത് വളരെ എളുപ്പവും ലളിതവുമാണ്: കണ്ടെയ്നർ-ഇമേജ്-ഡോക്കർ എക്സ്റ്റൻഷൻ ചേർക്കുക, നിങ്ങൾക്ക് മാവൻ കമാൻഡുകൾ ഉപയോഗിച്ച് ചിത്രങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയും.

./mvnw quarkus:add-extension -Dextensions=”container-image-docker”

അവസാനമായി, ഞങ്ങൾ മാവൻ ഉപയോഗിച്ച് ഞങ്ങളുടെ ചിത്രം നിർമ്മിക്കുന്നു. തൽഫലമായി, ഞങ്ങളുടെ സോഴ്‌സ് കോഡ് ഒരു റെഡിമെയ്ഡ് കണ്ടെയ്‌നർ ഇമേജായി മാറുന്നു, അത് ഇതിനകം കണ്ടെയ്‌നർ റൺടൈമിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

./mvnw -X clean package -Dquarkus.container-image.build=true

വാസ്തവത്തിൽ, അത്രയേയുള്ളൂ, ഇപ്പോൾ നിങ്ങൾക്ക് ഡോക്കർ റൺ കമാൻഡ് ഉപയോഗിച്ച് കണ്ടെയ്‌നർ പ്രവർത്തിപ്പിക്കാൻ കഴിയും, ഞങ്ങളുടെ സേവനം പോർട്ട് 8080-ലേക്ക് മാപ്പ് ചെയ്‌ത് അത് ആക്‌സസ് ചെയ്യാൻ കഴിയും.

docker run -i — rm -p 8080:8080 gcolman/quarkus-hello-world

കണ്ടെയ്നർ ഇൻസ്‌റ്റൻസ് ആരംഭിച്ചതിന് ശേഷം, ഞങ്ങളുടെ സേവനം പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് curl കമാൻഡ് ഉപയോഗിച്ച് പരിശോധിക്കുന്നത് മാത്രമാണ് അവശേഷിക്കുന്നത്:

അതിനാൽ എല്ലാം പ്രവർത്തിക്കുന്നു, അത് വളരെ എളുപ്പവും ലളിതവുമായിരുന്നു.

ഘട്ടം 2 - ഞങ്ങളുടെ കണ്ടെയ്നർ കണ്ടെയ്നർ ഇമേജ് ശേഖരത്തിലേക്ക് അയയ്ക്കുക

ഇപ്പോൾ, ഞങ്ങൾ സൃഷ്ടിച്ച ചിത്രം പ്രാദേശികമായി, ഞങ്ങളുടെ പ്രാദേശിക കണ്ടെയ്‌നർ സ്റ്റോറേജിൽ സംഭരിച്ചിരിക്കുന്നു. ഞങ്ങളുടെ COOK പരിതസ്ഥിതിയിൽ ഈ ചിത്രം ഉപയോഗിക്കണമെങ്കിൽ, അത് മറ്റേതെങ്കിലും ശേഖരത്തിൽ സ്ഥാപിക്കണം. Kubernetes-ന് ഈ സവിശേഷതകൾ ഇല്ല, അതിനാൽ ഞങ്ങൾ dockerhub ഉപയോഗിക്കും. കാരണം, ഒന്നാമതായി, ഇത് സൗജന്യമാണ്, രണ്ടാമതായി, (ഏതാണ്ട്) എല്ലാവരും അത് ചെയ്യുന്നു.

ഇതും വളരെ ലളിതമാണ്, ഇവിടെ ഒരു ഡോക്കർഹബ് അക്കൗണ്ട് മാത്രമേ ആവശ്യമുള്ളൂ.

അതിനാൽ, ഞങ്ങൾ ഡോക്കർഹബ് ഇൻസ്റ്റാൾ ചെയ്യുകയും അവിടെ ഞങ്ങളുടെ ചിത്രം അയയ്ക്കുകയും ചെയ്യുന്നു.

ഘട്ടം 3 - കുബർനെറ്റസ് സമാരംഭിക്കുക

ഞങ്ങളുടെ "ഹലോ വേൾഡ്" പ്രവർത്തിപ്പിക്കുന്നതിന് kubernetes കോൺഫിഗറേഷൻ കൂട്ടിച്ചേർക്കാൻ നിരവധി മാർഗങ്ങളുണ്ട്, എന്നാൽ അവയിൽ ഏറ്റവും ലളിതമായത് ഞങ്ങൾ ഉപയോഗിക്കും, അതാണ് ഞങ്ങൾ...

ആദ്യം, നമുക്ക് മിനിക്യൂബ് ക്ലസ്റ്റർ സമാരംഭിക്കാം:

minikube start

ഘട്ടം 4 - ഞങ്ങളുടെ കണ്ടെയ്നർ ചിത്രം വിന്യസിക്കുക

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

kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT

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

ഘട്ടം 5 - ഞങ്ങളുടെ സേവനത്തിലേക്കുള്ള പ്രവേശനം തുറക്കുക

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

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

kubectl expose deployment hello-quarkus — type=NodePort — port=8080

എക്സ്പോസ് കമാൻഡിന്റെ "-ടൈപ്പ്" ഓപ്ഷനിൽ ഒരു നിമിഷം നമുക്ക് താമസിക്കാം.

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

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

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ തരം=നോഡ്‌പോർട്ട്, അതായത്, ഞങ്ങളുടെ സേവനത്തിലേക്കുള്ള കോൾ നോഡിന്റെ IP വിലാസവും പോർട്ട് നമ്പറും വഴി പോകുന്നു. പൊതു ക്ലൗഡുകളൊന്നും ഉപയോഗിക്കാതിരിക്കാൻ ഈ ഓപ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു, എന്നാൽ നിരവധി അധിക ഘട്ടങ്ങൾ ആവശ്യമാണ്. ഒന്നാമതായി, നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം ലോഡ് ബാലൻസർ ആവശ്യമാണ്, അതിനാൽ ഞങ്ങൾ NGINX ലോഡ് ബാലൻസർ ഞങ്ങളുടെ ക്ലസ്റ്ററിൽ വിന്യസിക്കും.

ഘട്ടം 6 - ഒരു ലോഡ് ബാലൻസർ ഇൻസ്റ്റാൾ ചെയ്യുക

minikube-ന് ഇൻഗ്രെസ്സ് കൺട്രോളറുകൾ പോലുള്ള ബാഹ്യമായി ആക്സസ് ചെയ്യാവുന്ന ഘടകങ്ങൾ സൃഷ്ടിക്കുന്നത് എളുപ്പമാക്കുന്ന നിരവധി പ്ലാറ്റ്ഫോം ഫംഗ്ഷനുകൾ ഉണ്ട്. Minikube Nginx ഇൻഗ്രെസ്സ് കൺട്രോളറുമായി വരുന്നു, ഞങ്ങൾ ചെയ്യേണ്ടത് അത് പ്രവർത്തനക്ഷമമാക്കുകയും കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുക എന്നതാണ്.

minikube addons enable ingress

ഇപ്പോൾ ഞങ്ങൾ ഒരു കമാൻഡ് ഉപയോഗിച്ച് ഒരു Nginx ഇൻഗ്രെസ്സ് കൺട്രോളർ സൃഷ്ടിക്കും, അത് ഞങ്ങളുടെ മിനിക്യൂബ് ക്ലസ്റ്ററിനുള്ളിൽ പ്രവർത്തിക്കും:

ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m

ഘട്ടം 7 - പ്രവേശനം സജ്ജീകരിക്കുന്നു

ഇപ്പോൾ നമ്മൾ Nginx ഇൻഗ്രെസ്സ് കൺട്രോളർ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്, അങ്ങനെ അത് hello-quarkus അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നു.

അവസാനമായി, ഞങ്ങൾ ഈ കോൺഫിഗറേഷൻ പ്രയോഗിക്കേണ്ടതുണ്ട്.

kubectl apply -f ingress.yml

ഞങ്ങൾ ഇതെല്ലാം ചെയ്യുന്നത് ഞങ്ങളുടെ സ്വന്തം കമ്പ്യൂട്ടറിൽ ആയതിനാൽ, ഞങ്ങളുടെ മിനിക്യൂബിലേക്കുള്ള http അഭ്യർത്ഥനകൾ NGINX ലോഡ് ബാലൻസറിലേക്ക് റൂട്ട് ചെയ്യുന്നതിന് ഞങ്ങൾ /etc/ ഹോസ്റ്റ് ഫയലിലേക്ക് ഞങ്ങളുടെ നോഡിന്റെ IP വിലാസം ചേർക്കുക.

192.168.99.100 hello-quarkus.info

അത്രയേയുള്ളൂ, ഇപ്പോൾ ഞങ്ങളുടെ minikube സേവനം Nginx ഇൻഗ്രെസ്സ് കൺട്രോളർ വഴി പുറത്ത് നിന്ന് ലഭ്യമാണ്.

ശരി, അത് എളുപ്പമായിരുന്നു, അല്ലേ? അതോ അത്രയല്ലേ?

ഓപ്പൺഷിഫ്റ്റിൽ പ്രവർത്തിക്കുന്നു (കോഡ് റെഡി കണ്ടെയ്നറുകൾ)

Red Hat OpenShift കണ്ടെയ്‌നർ പ്ലാറ്റ്‌ഫോമിൽ (OCP) ഇതെല്ലാം എങ്ങനെ ചെയ്യുന്നുവെന്ന് ഇപ്പോൾ നോക്കാം.

minikube പോലെ, ഞങ്ങൾ കോഡ് റെഡി കണ്ടെയ്‌നറുകളുടെ (CRC) രൂപത്തിൽ ഒരു സിംഗിൾ-നോഡ് OpenShift ക്ലസ്റ്റർ ഡിസൈൻ തിരഞ്ഞെടുക്കുന്നു. മുമ്പ്, ഇത് മിനിഷിഫ്റ്റ് എന്ന് വിളിച്ചിരുന്നു, ഇത് ഓപ്പൺഷിഫ്റ്റ് ഒറിജിൻ പ്രോജക്റ്റിനെ അടിസ്ഥാനമാക്കിയുള്ളതായിരുന്നു, എന്നാൽ ഇപ്പോൾ ഇത് CRC ആണ്, ഇത് Red Hat-ന്റെ OpenShift കണ്ടെയ്നർ പ്ലാറ്റ്ഫോമിൽ നിർമ്മിച്ചതാണ്.

ഇവിടെ, ക്ഷമിക്കണം, ഞങ്ങൾക്ക് പറയാതിരിക്കാൻ കഴിയില്ല: "ഓപ്പൺഷിഫ്റ്റ് മികച്ചതാണ്!"

തുടക്കത്തിൽ, ഓപ്പൺഷിഫ്റ്റിലെ വികസനം കുബർനെറ്റിലെ വികസനത്തിൽ നിന്ന് വ്യത്യസ്തമല്ലെന്ന് എഴുതാൻ ഞങ്ങൾ കരുതി. സത്യത്തിൽ അത് അങ്ങനെയാണ്. എന്നാൽ ഈ കുറിപ്പ് എഴുതുന്ന പ്രക്രിയയിൽ, നിങ്ങൾക്ക് ഓപ്പൺഷിഫ്റ്റ് ഇല്ലാത്തപ്പോൾ എത്ര അധിക ചലനങ്ങൾ നടത്തണമെന്ന് ഞങ്ങൾ ഓർത്തു, അതുകൊണ്ടാണ്, വീണ്ടും, ഇത് അതിശയിപ്പിക്കുന്നത്. എല്ലാം എളുപ്പത്തിൽ ചെയ്യപ്പെടുമ്പോൾ ഞങ്ങൾ അത് ഇഷ്ടപ്പെടുന്നു, കൂടാതെ minikube നെ അപേക്ഷിച്ച് OpenShift-ൽ വിന്യസിക്കാനും പ്രവർത്തിപ്പിക്കാനും ഞങ്ങളുടെ ഉദാഹരണം എത്ര എളുപ്പമാണ് എന്നതാണ് ഈ പോസ്റ്റ് എഴുതാൻ ഞങ്ങളെ പ്രേരിപ്പിച്ചത്.

നമുക്ക് പ്രക്രിയയിലൂടെ കടന്നുപോകാം, എന്താണ് ചെയ്യേണ്ടതെന്ന് നോക്കാം.

അതിനാൽ, മിനിക്യൂബ് ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഡോക്കറിൽ ആരംഭിച്ചു... കാത്തിരിക്കൂ, ഇനി നമുക്ക് മെഷീനിൽ ഡോക്കർ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതില്ല.

പിന്നെ ഞങ്ങൾക്ക് ഒരു ലോക്കൽ ജിറ്റ് ആവശ്യമില്ല.
പിന്നെ മാവൻ ആവശ്യമില്ല.
കൂടാതെ നിങ്ങൾ കൈകൊണ്ട് ഒരു കണ്ടെയ്നർ ഇമേജ് സൃഷ്ടിക്കേണ്ടതില്ല.
കണ്ടെയ്നർ ചിത്രങ്ങളുടെ ഒരു ശേഖരവും നിങ്ങൾ അന്വേഷിക്കേണ്ടതില്ല.
കൂടാതെ നിങ്ങൾ ഒരു ഇൻഗ്രെസ്സ് കൺട്രോളർ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതില്ല.
കൂടാതെ നിങ്ങൾ പ്രവേശനം കോൺഫിഗർ ചെയ്യേണ്ടതില്ല.

നിങ്ങൾക്ക് മനസ്സിലായി, അല്ലേ? OpenShift-ൽ ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ വിന്യസിക്കാനും പ്രവർത്തിപ്പിക്കാനും, നിങ്ങൾക്ക് മുകളിൽ പറഞ്ഞതൊന്നും ആവശ്യമില്ല. കൂടാതെ പ്രക്രിയ തന്നെ ഇതുപോലെ കാണപ്പെടുന്നു.

ഘട്ടം 1 - നിങ്ങളുടെ ഓപ്പൺഷിഫ്റ്റ് ക്ലസ്റ്റർ സമാരംഭിക്കുക

ഞങ്ങൾ Red Hat-ൽ നിന്നുള്ള കോഡ് റെഡി കണ്ടെയ്‌നറുകൾ ഉപയോഗിക്കുന്നു, അത് പ്രധാനമായും ഒരേ Minikube ആണ്, എന്നാൽ ഒരു പൂർണ്ണമായ ഒറ്റ-നോഡ് Openshift ക്ലസ്റ്ററിനൊപ്പം മാത്രം.

crc start

ഘട്ടം 2 - ഓപ്പൺഷിഫ്റ്റ് ക്ലസ്റ്ററിലേക്ക് ആപ്ലിക്കേഷൻ നിർമ്മിക്കുകയും വിന്യസിക്കുകയും ചെയ്യുക

ഈ ഘട്ടത്തിലാണ് ഓപ്പൺഷിഫ്റ്റിന്റെ ലാളിത്യവും സൗകര്യവും അതിന്റെ എല്ലാ മഹത്വത്തിലും വെളിപ്പെടുന്നത്. എല്ലാ കുബർനെറ്റസ് വിതരണങ്ങളേയും പോലെ, ഒരു ക്ലസ്റ്ററിൽ ഒരു ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന് ഞങ്ങൾക്ക് നിരവധി മാർഗങ്ങളുണ്ട്. കൂടാതെ, KUK യുടെ കാര്യത്തിലെന്നപോലെ, ഞങ്ങൾ ഏറ്റവും ലളിതമായ ഒന്ന് തിരഞ്ഞെടുക്കുന്നു.

കണ്ടെയ്‌നറൈസ്ഡ് ആപ്ലിക്കേഷനുകൾ സൃഷ്‌ടിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള ഒരു പ്ലാറ്റ്‌ഫോമായി ഓപ്പൺഷിഫ്റ്റ് എല്ലായ്പ്പോഴും നിർമ്മിച്ചിട്ടുണ്ട്. കണ്ടെയ്‌നർ ബിൽഡിംഗ് എല്ലായ്പ്പോഴും ഈ പ്ലാറ്റ്‌ഫോമിന്റെ അവിഭാജ്യ ഘടകമാണ്, അതിനാൽ അനുബന്ധ ജോലികൾക്കായി ഒരു ടൺ അധിക കുബർനെറ്റസ് ഉറവിടങ്ങളുണ്ട്.

ഞങ്ങൾ ഓപ്പൺഷിഫ്റ്റിന്റെ സോഴ്സ് 2 ഇമേജ് (എസ് 2 ഐ) പ്രോസസ്സ് ഉപയോഗിക്കും, അതിൽ ഞങ്ങളുടെ ഉറവിടം (കോഡ് അല്ലെങ്കിൽ ബൈനറികൾ) എടുത്ത് ഒരു ഓപ്പൺഷിഫ്റ്റ് ക്ലസ്റ്ററിൽ പ്രവർത്തിക്കുന്ന ഒരു കണ്ടെയ്നറൈസ്ഡ് ഇമേജാക്കി മാറ്റുന്നതിന് വ്യത്യസ്ത മാർഗങ്ങളുണ്ട്.

ഇതിനായി നമുക്ക് രണ്ട് കാര്യങ്ങൾ ആവശ്യമാണ്:

• ഞങ്ങളുടെ സോഴ്സ് കോഡ് git റിപ്പോസിറ്ററിയിലാണ്
• ബിൽഡർ-ഇമേജ്, അതിന്റെ അടിസ്ഥാനത്തിൽ അസംബ്ലി നിർവഹിക്കും.

Red Hat-ലും കമ്മ്യൂണിറ്റി തലത്തിലും അത്തരം നിരവധി ഇമേജുകൾ പരിപാലിക്കുന്നു, ഞാൻ ഒരു ജാവ ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനാൽ ഞങ്ങൾ OpenJDK ഇമേജ് ഉപയോഗിക്കും.

നിങ്ങൾക്ക് ഓപ്പൺഷിഫ്റ്റ് ഡെവലപ്പർ ഗ്രാഫിക്കൽ കൺസോളിൽ നിന്നും കമാൻഡ് ലൈനിൽ നിന്നും S2I ബിൽഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും. ബിൽഡർ ഇമേജും ഞങ്ങളുടെ സോഴ്‌സ് കോഡും എവിടെ നിന്ന് ലഭിക്കുമെന്ന് പറഞ്ഞ് ഞങ്ങൾ new-app കമാൻഡ് ഉപയോഗിക്കും.

oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git

അത്രയേയുള്ളൂ, ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ സൃഷ്ടിച്ചു. അങ്ങനെ ചെയ്യുമ്പോൾ, S2I പ്രക്രിയ ഇനിപ്പറയുന്ന കാര്യങ്ങൾ ചെയ്തു:

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

ഈ ലിസ്റ്റിൽ ധാരാളം ഉണ്ട്, എന്നാൽ പ്രധാന കാര്യം, മുഴുവൻ ബിൽഡും ഓപ്പൺഷിഫ്റ്റിനുള്ളിൽ മാത്രമായി നടക്കുന്നു എന്നതാണ്, ആന്തരിക ഡോക്കർ രജിസ്ട്രി ഓപ്പൺഷിഫ്റ്റിനുള്ളിലാണ്, കൂടാതെ ബിൽഡ് പ്രോസസ്സ് എല്ലാ കുബർനെറ്റസ് ഘടകങ്ങളും സൃഷ്ടിക്കുകയും ക്ലസ്റ്ററിൽ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു.

നിങ്ങൾ കൺസോളിൽ S2I യുടെ ലോഞ്ച് ദൃശ്യപരമായി നിരീക്ഷിക്കുകയാണെങ്കിൽ, ബിൽഡ് പൂർത്തിയാകുമ്പോൾ ബിൽഡ് പോഡ് എങ്ങനെ സമാരംഭിക്കുന്നുവെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും.

ഇപ്പോൾ നമുക്ക് ബിൽഡർ പോഡിന്റെ ലോഗുകൾ നോക്കാം: ഒന്നാമതായി, മാവൻ അതിന്റെ ജോലി ചെയ്യുന്നതെങ്ങനെയെന്നും ഞങ്ങളുടെ ജാവ ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനുള്ള ഡിപൻഡൻസികൾ ഡൗൺലോഡ് ചെയ്യുന്നതെങ്ങനെയെന്നും അവിടെ നിങ്ങൾക്ക് കാണാൻ കഴിയും.

മാവൻ ബിൽഡ് പൂർത്തിയാക്കിയ ശേഷം, കണ്ടെയ്നർ ഇമേജിന്റെ നിർമ്മാണം ആരംഭിക്കുന്നു, തുടർന്ന് ഈ ബിൽറ്റ് ഇമേജ് ആന്തരിക ശേഖരത്തിലേക്ക് അയയ്ക്കുന്നു.

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

oc get service

അത്രയേയുള്ളൂ. പിന്നെ ഒരു ടീം മാത്രം. പുറത്തുനിന്നുള്ള ആക്‌സസ്സിനായി ഈ സേവനം തുറന്നുകാട്ടുക മാത്രമാണ് ഞങ്ങൾ ചെയ്യേണ്ടത്.

ഘട്ടം 3 - പുറത്ത് നിന്ന് ആക്‌സസ് ചെയ്യുന്നതിനുള്ള സേവനം തുറന്നുകാട്ടുക

KUC-യുടെ കാര്യത്തിലെന്നപോലെ, ഓപ്പൺഷിഫ്റ്റ് പ്ലാറ്റ്‌ഫോമിൽ ഞങ്ങളുടെ "ഹലോ വേൾഡിന്" ക്ലസ്റ്ററിനുള്ളിലെ സേവനത്തിലേക്ക് ബാഹ്യ ട്രാഫിക്കിലേക്ക് നയിക്കുന്നതിന് ഒരു റൂട്ടറും ആവശ്യമാണ്. OpenShift ഇത് വളരെ എളുപ്പമാക്കുന്നു. ഒന്നാമതായി, HAProxy റൂട്ടിംഗ് ഘടകം ക്ലസ്റ്ററിൽ സ്ഥിരസ്ഥിതിയായി ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട് (ഇത് അതേ NGINX ആയി മാറ്റാവുന്നതാണ്). രണ്ടാമതായി, റൂട്ടുകൾ എന്ന് വിളിക്കപ്പെടുന്ന സവിശേഷവും ഉയർന്ന ഇഷ്‌ടാനുസൃതമാക്കാവുന്നതുമായ ഉറവിടങ്ങളുണ്ട്, അവ നല്ല പഴയ കുബർനെറ്റുകളിലെ ഇൻഗ്രെസ്സ് ഒബ്‌ജക്റ്റുകളോട് സാമ്യമുള്ളതാണ് (വാസ്തവത്തിൽ, ഓപ്പൺഷിഫ്റ്റിന്റെ റൂട്ടുകൾ ഇൻഗ്രെസ് ഒബ്‌ജക്റ്റുകളുടെ രൂപകൽപ്പനയെ വളരെയധികം സ്വാധീനിച്ചു, അത് ഇപ്പോൾ ഓപ്പൺഷിഫ്റ്റിൽ ഉപയോഗിക്കാം) , എന്നാൽ ഞങ്ങളുടെ “ഹലോ വേൾഡിന്” , കൂടാതെ മറ്റെല്ലാ സാഹചര്യങ്ങളിലും, അധിക കോൺഫിഗറേഷൻ കൂടാതെ ഞങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് റൂട്ട് മതിയാകും.

"ഹലോ വേൾഡ്" എന്നതിനായി ഒരു റൂട്ടബിൾ എഫ്‌ക്യുഡിഎൻ സൃഷ്‌ടിക്കാൻ (അതെ, സേവന നാമങ്ങൾ ഉപയോഗിച്ച് റൂട്ടിംഗിനായി ഓപ്പൺഷിഫ്റ്റിന് അതിന്റേതായ ഡിഎൻഎസ് ഉണ്ട്), ഞങ്ങൾ ഞങ്ങളുടെ സേവനം തുറന്നുകാട്ടും:

oc expose service quarkus-hello-world

നിങ്ങൾ പുതുതായി സൃഷ്ടിച്ച റൂട്ട് നോക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് FQDN ഉം മറ്റ് റൂട്ടിംഗ് വിവരങ്ങളും അവിടെ കണ്ടെത്താനാകും:

oc get route

അവസാനമായി, ഞങ്ങൾ ബ്രൗസറിൽ നിന്ന് ഞങ്ങളുടെ സേവനം ആക്സസ് ചെയ്യുന്നു:

എന്നാൽ ഇപ്പോൾ അത് വളരെ എളുപ്പമായിരുന്നു!

ഞങ്ങൾ കുബർനെറ്റസിനെയും ഈ സാങ്കേതികവിദ്യ ഞങ്ങളെ ചെയ്യാൻ അനുവദിക്കുന്ന എല്ലാറ്റിനെയും സ്നേഹിക്കുന്നു, ഒപ്പം ലാളിത്യവും എളുപ്പവും ഞങ്ങൾ ഇഷ്ടപ്പെടുന്നു. വിതരണം ചെയ്‌തതും അളക്കാവുന്നതുമായ കണ്ടെയ്‌നറുകൾ പ്രവർത്തിപ്പിക്കാൻ അവിശ്വസനീയമാംവിധം എളുപ്പമാക്കുന്നതിനാണ് Kubernetes രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത്, എന്നാൽ അതിന്റെ ലാളിത്യം ഇന്ന് ആപ്ലിക്കേഷനുകൾ ഉൽപ്പാദനത്തിലേക്ക് കൊണ്ടുവരാൻ പര്യാപ്തമല്ല. ഇവിടെയാണ് ഓപ്പൺഷിഫ്റ്റ് പ്രവർത്തിക്കുന്നത്, സമയത്തിന് അനുസൃതമായി ഡവലപ്പർ കേന്ദ്രീകൃത കുബർനെറ്റുകൾ വാഗ്ദാനം ചെയ്യുന്നു. S2I, ODI, ഡെവലപ്പർ പോർട്ടൽ, ഓപ്പൺഷിഫ്റ്റ് ഓപ്പറേറ്റർ ഫ്രെയിംവർക്ക്, IDE ഇന്റഗ്രേഷൻ, ഡെവലപ്പർ കാറ്റലോഗുകൾ, ഹെൽം ഇന്റഗ്രേഷൻ, നിരീക്ഷണം തുടങ്ങി നിരവധി ടൂളുകളുടെ നിർമ്മാണം ഉൾപ്പെടെ, ഡെവലപ്പർക്കായി പ്രത്യേകമായി ഓപ്പൺഷിഫ്റ്റ് പ്ലാറ്റ്ഫോം ക്രമീകരിക്കുന്നതിന് ധാരാളം പരിശ്രമങ്ങൾ നടത്തിയിട്ടുണ്ട്.

ഈ ലേഖനം നിങ്ങൾക്ക് രസകരവും ഉപയോഗപ്രദവുമാണെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു. പോർട്ടലിലെ ഓപ്പൺഷിഫ്റ്റ് പ്ലാറ്റ്‌ഫോമിൽ വികസനത്തിന് ഉപയോഗപ്രദമായ അധിക ഉറവിടങ്ങളും മെറ്റീരിയലുകളും മറ്റ് കാര്യങ്ങളും നിങ്ങൾക്ക് കണ്ടെത്താനാകും Red Hat ഡെവലപ്പർമാർ.

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