ഓപ്പൺഷിഫ്റ്റിലെ ആധുനിക ആപ്ലിക്കേഷനുകൾ, ഭാഗം 3: ഓപ്പൺഷിഫ്റ്റ് ഒരു വികസന അന്തരീക്ഷമായും ഓപ്പൺഷിഫ്റ്റ് പൈപ്പ്ലൈനുകളായും

ഈ ബ്ലോഗിലെ എല്ലാവർക്കും ഹലോ! Red Hat OpenShift-ൽ ആധുനിക വെബ് ആപ്ലിക്കേഷനുകൾ എങ്ങനെ വിന്യസിക്കാമെന്ന് കാണിക്കുന്ന ഒരു പരമ്പരയിലെ മൂന്നാമത്തെ പോസ്റ്റാണിത്.

മുമ്പത്തെ രണ്ട് പോസ്റ്റുകളിൽ, ഏതാനും ഘട്ടങ്ങളിലൂടെ ആധുനിക വെബ് ആപ്ലിക്കേഷനുകൾ എങ്ങനെ വിന്യസിക്കാമെന്നും പ്രൊഡക്ഷൻ വിന്യാസങ്ങൾ ക്രമീകരിക്കുന്നതിന് ചെയിൻഡ് ബിൽഡുകൾ ഉപയോഗിച്ച് NGINX പോലെയുള്ള ഓഫ്-ദി-ഷെൽഫ് HTTP സെർവർ ഇമേജിനൊപ്പം ഒരു പുതിയ S2I ഇമേജ് എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഞങ്ങൾ കാണിച്ചുതന്നു. .

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

ഒരു വികസന പരിതസ്ഥിതിയായി OpenShift

വികസന വർക്ക്ഫ്ലോ

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

മിക്ക ആധുനിക ചട്ടക്കൂടുകളിലും, അത്തരം ഒരു "വികസന സെർവർ" അനുബന്ധ കമാൻഡ് ലൈൻ ടൂളുകളിൽ നിർമ്മിച്ചിരിക്കുന്നു.

പ്രാദേശിക ഉദാഹരണം

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

$ npm run start

അപ്പോൾ ടെർമിനൽ വിൻഡോയിൽ നമ്മൾ ഇതുപോലൊന്ന് കാണും:

ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ സ്ഥിരസ്ഥിതി ബ്രൗസറിൽ തുറക്കും:

ഇപ്പോൾ, നമ്മൾ ഫയലിൽ മാറ്റങ്ങൾ വരുത്തുകയാണെങ്കിൽ, ആപ്ലിക്കേഷൻ ബ്രൗസറിൽ അപ്ഡേറ്റ് ചെയ്യണം.

ശരി, പ്രാദേശിക മോഡിലെ വികസനത്തിൽ എല്ലാം വ്യക്തമാണ്, എന്നാൽ OpenShift-ൽ അത് എങ്ങനെ നേടാം?

OpenShift-ലെ വികസന സെർവർ

നിങ്ങൾ ഓർക്കുന്നുവെങ്കിൽ, ഇൻ മുൻ പോസ്റ്റ്, S2I ഇമേജിന്റെ റൺ ഘട്ടം എന്ന് വിളിക്കപ്പെടുന്ന ഘട്ടം ഞങ്ങൾ പരിശോധിച്ചു, സ്ഥിരസ്ഥിതിയായി, സെർവ് മൊഡ്യൂൾ ഞങ്ങളുടെ വെബ് ആപ്ലിക്കേഷന്റെ സേവനത്തിന് ഉത്തരവാദിയാണെന്ന് കണ്ടു.

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

ഉദാഹരണത്തിന്, ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ വിന്യസിക്കാൻ നോഡ്ഷിഫ്റ്റ് മൊഡ്യൂൾ ഉപയോഗിക്കാം:

$ npx nodeshift --deploy.env NPM_RUN="yarn start" --dockerImage=nodeshift/ubi8-s2i-web-app

ശ്രദ്ധിക്കുക: പൊതുവായ ആശയം വ്യക്തമാക്കുന്നതിന് മുകളിലുള്ള ഉദാഹരണം ചുരുക്കിയിരിക്കുന്നു.

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

നിങ്ങൾ പ്രവർത്തിക്കുന്ന പോഡിന്റെ ലോഗ് നോക്കുകയാണെങ്കിൽ, അത് ഇതുപോലെ കാണപ്പെടും:

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

റിമോട്ട്, ലോക്കൽ കോഡ് സമന്വയിപ്പിക്കുന്നു

ഭാഗ്യവശാൽ, നോഡ്ഷിഫ്റ്റിന് സിൻക്രൊണൈസേഷനെ എളുപ്പത്തിൽ സഹായിക്കാനാകും, കൂടാതെ മാറ്റങ്ങൾ ട്രാക്കുചെയ്യുന്നതിന് നിങ്ങൾക്ക് വാച്ച് കമാൻഡ് ഉപയോഗിക്കാം.

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

$ npx nodeshift watch

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

അതിനാൽ, ഞങ്ങൾ ഇപ്പോൾ src/App.js ഫയൽ അപ്‌ഡേറ്റ് ചെയ്യുകയാണെങ്കിൽ, സിസ്റ്റം ഈ മാറ്റങ്ങളോട് പ്രതികരിക്കും, അവ റിമോട്ട് ക്ലസ്റ്ററിലേക്ക് പകർത്തി ഡെവലപ്‌മെന്റ് സെർവർ ആരംഭിക്കും, അത് ബ്രൗസറിൽ ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ അപ്‌ഡേറ്റ് ചെയ്യും.

ചിത്രം പൂർത്തിയാക്കാൻ, ഈ മുഴുവൻ കമാൻഡുകളും എങ്ങനെയിരിക്കുമെന്ന് നമുക്ക് കാണിക്കാം:

$ npx nodeshift --strictSSL=false --dockerImage=nodeshift/ubi8-s2i-web-app --build.env YARN_ENABLED=true --expose --deploy.env NPM_RUN="yarn start" --deploy.port 3000

$ npx nodeshift watch --strictSSL=false

വാച്ച് കമാൻഡ് oc rsync കമാൻഡിന് മുകളിലുള്ള ഒരു സംഗ്രഹമാണ്, ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് കൂടുതലറിയാൻ കഴിയും ഇവിടെ.

ഇത് റിയാക്റ്റിന് ഒരു ഉദാഹരണമായിരുന്നു, എന്നാൽ മറ്റ് ചട്ടക്കൂടുകൾക്കും ഇതേ രീതി തന്നെ ഉപയോഗിക്കാം, ആവശ്യാനുസരണം NPM_RUN എൻവയോൺമെന്റ് വേരിയബിൾ സജ്ജമാക്കുക.
 

ഓപ്പൺഷിഫ്റ്റ് പൈപ്പ്ലൈനുകൾ

അടുത്തതായി നമ്മൾ ഓപ്പൺഷിഫ്റ്റ് പൈപ്പ്ലൈനുകൾ പോലെയുള്ള ഒരു ഉപകരണത്തെക്കുറിച്ചും ചങ്ങലയുള്ള ബിൽഡുകൾക്ക് ബദലായി എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചും സംസാരിക്കും.

എന്താണ് ഓപ്പൺഷിഫ്റ്റ് പൈപ്പ് ലൈനുകൾ

ഓപ്പൺഷിഫ്റ്റ് പൈപ്പ്‌ലൈനുകൾ ടെക്‌ടൺ ഉപയോഗിച്ച് പൈപ്പ്‌ലൈനുകൾ സംഘടിപ്പിക്കുന്നതിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന ക്ലൗഡ്-നേറ്റീവ് സിഐ/സിഡി തുടർച്ചയായ സംയോജനവും ഡെലിവറി സംവിധാനവുമാണ്. ടെക്‌ടൺ ഒരു ഫ്ലെക്‌സിബിൾ ഓപ്പൺ സോഴ്‌സ് കുബർനെറ്റസ്-നേറ്റീവ് സിഐ/സിഡി ചട്ടക്കൂടാണ്, അത് അന്തർലീനമായ ലെയറിൽ നിന്ന് സംഗ്രഹിച്ച് വിവിധ പ്ലാറ്റ്‌ഫോമുകളിൽ (കുബർനെറ്റസ്, സെർവർലെസ്, വെർച്വൽ മെഷീനുകൾ മുതലായവ) വിന്യാസം ഓട്ടോമേറ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഈ ലേഖനം മനസ്സിലാക്കുന്നതിന് പൈപ്പ് ലൈനുകളെ കുറിച്ച് കുറച്ച് അറിവ് ആവശ്യമാണ്, അതിനാൽ നിങ്ങൾ ആദ്യം വായിക്കാൻ ഞങ്ങൾ ശക്തമായി ശുപാർശ ചെയ്യുന്നു ഔദ്യോഗിക പാഠപുസ്തകം.

നിങ്ങളുടെ തൊഴിൽ അന്തരീക്ഷം സജ്ജീകരിക്കുന്നു

ഈ ലേഖനത്തിലെ ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് കളിക്കാൻ, നിങ്ങൾ ആദ്യം നിങ്ങളുടെ പ്രവർത്തന അന്തരീക്ഷം തയ്യാറാക്കേണ്ടതുണ്ട്:

1. ഒരു OpenShift 4 ക്ലസ്റ്റർ ഇൻസ്റ്റാൾ ചെയ്ത് കോൺഫിഗർ ചെയ്യുക. ഞങ്ങളുടെ ഉദാഹരണങ്ങൾ ഇതിനായി CodeReady Containers (CRD) ഉപയോഗിക്കുന്നു, അതിനുള്ള ഇൻസ്റ്റലേഷൻ നിർദ്ദേശങ്ങൾ കണ്ടെത്താനാകും ഇവിടെ.
2. ക്ലസ്റ്റർ തയ്യാറായ ശേഷം, നിങ്ങൾ അതിൽ പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ ഇൻസ്റ്റാൾ ചെയ്യണം. ഭയപ്പെടേണ്ട, ഇത് എളുപ്പമാണ്, ഇൻസ്റ്റാളേഷൻ നിർദ്ദേശങ്ങൾ ഇവിടെ.
3. ഡൗൺലോഡ് ടെക്ടൺ CLI (ടികെഎൻ) ഇവിടെ.
4. നിങ്ങൾ വിന്യസിക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കാൻ create-react-app കമാൻഡ് ലൈൻ ടൂൾ പ്രവർത്തിപ്പിക്കുക (ഇതൊരു ലളിതമായ ആപ്ലിക്കേഷനാണ് തിരിച്ചടി നടത്തുക).
5. (ഓപ്ഷണൽ) npm ഇൻസ്റ്റാളും തുടർന്ന് npm സ്റ്റാർട്ടും ഉപയോഗിച്ച് പ്രാദേശികമായി ഉദാഹരണ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന് റിപ്പോസിറ്ററി ക്ലോൺ ചെയ്യുക.

ആപ്ലിക്കേഷൻ റിപ്പോസിറ്ററിയിൽ ഒരു k8s ഫോൾഡറും ഉണ്ടാകും, അതിൽ ആപ്ലിക്കേഷൻ വിന്യസിക്കാൻ ഉപയോഗിക്കുന്ന Kubernetes/OpenShift YAML-കൾ അടങ്ങിയിരിക്കും. ഇതിൽ ഞങ്ങൾ സൃഷ്ടിക്കുന്ന ടാസ്‌ക്കുകൾ, ക്ലസ്റ്റർ ടാസ്‌ക്കുകൾ, ഉറവിടങ്ങൾ, പൈപ്പ്‌ലൈനുകൾ എന്നിവ ഉണ്ടാകും ശേഖരങ്ങൾ.

നമുക്ക് തുടങ്ങാം

ഓപ്പൺഷിഫ്റ്റ് ക്ലസ്റ്ററിൽ ഒരു പുതിയ പ്രോജക്റ്റ് സൃഷ്ടിക്കുക എന്നതാണ് ഞങ്ങളുടെ ഉദാഹരണത്തിനുള്ള ആദ്യപടി. നമുക്ക് ഈ പ്രോജക്ടിനെ webapp-pipeline എന്ന് വിളിക്കാം, താഴെ പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് ഇത് സൃഷ്ടിക്കാം:

$ oc new-project webapp-pipeline

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

അതിനാൽ, ഒന്നാമതായി ...

ചുമതലകൾ

നമുക്ക് കുറച്ച് ടാസ്‌ക്കുകൾ സൃഷ്‌ടിക്കാം, അത് ഞങ്ങളുടെ പൈപ്പ്‌ലൈനിനുള്ളിൽ ആപ്ലിക്കേഷൻ വിന്യസിക്കാൻ സഹായിക്കും. ഞങ്ങളുടെ ആപ്ലിക്കേഷന്റെ k8s ഫോൾഡറിൽ സ്ഥിതി ചെയ്യുന്ന Kubernetes ഉറവിടങ്ങളുടെ (സേവനം, വിന്യാസം, റൂട്ട്) YAML പ്രയോഗിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തമാണ് ആദ്യ ടാസ്‌ക് - apply_manifests_task. രണ്ടാമത്തെ ടാസ്‌ക് - update_deployment_task - ഇതിനകം വിന്യസിച്ചിരിക്കുന്ന ചിത്രം ഞങ്ങളുടെ പൈപ്പ്‌ലൈൻ സൃഷ്‌ടിച്ച ചിത്രത്തിലേക്ക് അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുള്ള ഉത്തരവാദിത്തമാണ്.

ഇത് ഇതുവരെ വ്യക്തമായിട്ടില്ലെങ്കിൽ വിഷമിക്കേണ്ട. വാസ്തവത്തിൽ, ഈ ടാസ്ക്കുകൾ യൂട്ടിലിറ്റികൾ പോലെയാണ്, ഞങ്ങൾ അവയെ കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കും. ഇപ്പോൾ, നമുക്ക് അവ സൃഷ്ടിക്കാം:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/update_deployment_task.yaml
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/apply_manifests_task.yaml

തുടർന്ന്, tkn CLI കമാൻഡ് ഉപയോഗിച്ച്, ടാസ്‌ക്കുകൾ സൃഷ്‌ടിച്ചിട്ടുണ്ടോയെന്ന് ഞങ്ങൾ പരിശോധിക്കും:

$ tkn task ls

NAME                AGE
apply-manifests     1 minute ago
update-deployment   1 minute ago

ശ്രദ്ധിക്കുക: ഇവ നിങ്ങളുടെ നിലവിലെ പ്രോജക്റ്റിനുള്ള പ്രാദേശിക ടാസ്ക്കുകളാണ്.

ക്ലസ്റ്റർ ജോലികൾ

ക്ലസ്റ്റർ ടാസ്‌ക്കുകൾ അടിസ്ഥാനപരമായി ലളിതമായ ജോലികൾക്ക് സമാനമാണ്. അതായത്, ഒരു നിർദ്ദിഷ്ട ടാസ്ക് പ്രവർത്തിപ്പിക്കുമ്പോൾ ഒരു തരത്തിൽ അല്ലെങ്കിൽ മറ്റൊന്നിൽ കൂടിച്ചേർന്ന ഘട്ടങ്ങളുടെ പുനരുപയോഗിക്കാവുന്ന ശേഖരമാണിത്. ക്ലസ്റ്ററിനുള്ളിൽ എല്ലായിടത്തും ഒരു ക്ലസ്റ്റർ ടാസ്‌ക് ലഭ്യമാണ് എന്നതാണ് വ്യത്യാസം. പൈപ്പ്ലൈൻ ഓപ്പറേറ്റർ ചേർക്കുമ്പോൾ സ്വയമേവ സൃഷ്ടിക്കപ്പെടുന്ന ക്ലസ്റ്റർ ടാസ്ക്കുകളുടെ ലിസ്റ്റ് കാണുന്നതിന്, ഞങ്ങൾ വീണ്ടും tkn CLI കമാൻഡ് ഉപയോഗിക്കും:

$ tkn clustertask ls

NAME                       AGE
buildah                    1 day ago
buildah-v0-10-0            1 day ago
jib-maven                  1 day ago
kn                         1 day ago
maven                      1 day ago
openshift-client           1 day ago
openshift-client-v0-10-0   1 day ago
s2i                        1 day ago
s2i-go                     1 day ago
s2i-go-v0-10-0             1 day ago
s2i-java-11                1 day ago
s2i-java-11-v0-10-0        1 day ago
s2i-java-8                 1 day ago
s2i-java-8-v0-10-0         1 day ago
s2i-nodejs                 1 day ago
s2i-nodejs-v0-10-0         1 day ago
s2i-perl                   1 day ago
s2i-perl-v0-10-0           1 day ago
s2i-php                    1 day ago
s2i-php-v0-10-0            1 day ago
s2i-python-3               1 day ago
s2i-python-3-v0-10-0       1 day ago
s2i-ruby                   1 day ago
s2i-ruby-v0-10-0           1 day ago
s2i-v0-10-0                1 day ago

ഇനി നമുക്ക് രണ്ട് ക്ലസ്റ്റർ ടാസ്‌ക്കുകൾ ഉണ്ടാക്കാം. ആദ്യത്തേത് S2I ഇമേജ് സൃഷ്ടിക്കുകയും ആന്തരിക OpenShift രജിസ്ട്രിയിലേക്ക് അയയ്ക്കുകയും ചെയ്യും; രണ്ടാമത്തേത്, ഞങ്ങൾ ഇതിനകം ഉള്ളടക്കമായി നിർമ്മിച്ച ആപ്ലിക്കേഷൻ ഉപയോഗിച്ച് NGINX അടിസ്ഥാനമാക്കി ഞങ്ങളുടെ ചിത്രം നിർമ്മിക്കുക എന്നതാണ്.

ചിത്രം സൃഷ്ടിച്ച് അയയ്ക്കുക

ആദ്യ ടാസ്ക് സൃഷ്ടിക്കുമ്പോൾ, ലിങ്കുചെയ്ത അസംബ്ലികളെക്കുറിച്ച് മുമ്പത്തെ ലേഖനത്തിൽ ഞങ്ങൾ ഇതിനകം ചെയ്തത് ആവർത്തിക്കും. ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ "ബിൽഡ്" ചെയ്യാൻ ഞങ്ങൾ S2I ഇമേജ് (ubi8-s2i-web-app) ഉപയോഗിച്ചുവെന്നും ഓപ്പൺഷിഫ്റ്റ് ഇന്റേണൽ രജിസ്ട്രിയിൽ സംഭരിച്ചിരിക്കുന്ന ഒരു ചിത്രത്തിലാണ് അവസാനിച്ചതെന്നും ഓർക്കുക. ഇപ്പോൾ ഞങ്ങൾ ഈ S2I വെബ് ആപ്പ് ഇമേജ് ഉപയോഗിച്ച് ഞങ്ങളുടെ ആപ്പിനായി ഒരു DockerFile സൃഷ്‌ടിക്കും, തുടർന്ന് യഥാർത്ഥ ബിൽഡ് ചെയ്യാൻ Buildah ഉപയോഗിക്കുകയും തത്ഫലമായുണ്ടാകുന്ന ചിത്രം OpenShift ആന്തരിക രജിസ്ട്രിയിലേക്ക് തള്ളുകയും ചെയ്യും, കാരണം നിങ്ങൾ NodeShift ഉപയോഗിച്ച് നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ വിന്യസിക്കുമ്പോൾ OpenShift ചെയ്യുന്നത് അതാണ്. .

ഇതെല്ലാം ഞങ്ങൾ എങ്ങനെ അറിഞ്ഞു, നിങ്ങൾ ചോദിക്കുന്നു? നിന്ന് ഔദ്യോഗിക Node.js-ന്റെ ഔദ്യോഗിക പതിപ്പ്, ഞങ്ങൾ അത് പകർത്തി സ്വയം പരിഷ്ക്കരിച്ചു.

അതിനാൽ, ഇപ്പോൾ നമുക്ക് s2i-web-app ക്ലസ്റ്റർ ടാസ്ക് സൃഷ്ടിക്കാം:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/s2i-web-app-task.yaml

ഞങ്ങൾ ഇത് വിശദമായി വിശകലനം ചെയ്യില്ല, പക്ഷേ OUTPUT_DIR പാരാമീറ്ററിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിക്കും:

params:
      - name: OUTPUT_DIR
        description: The location of the build output directory
        default: build

സ്ഥിരസ്ഥിതിയായി, ഈ പരാമീറ്റർ നിർമ്മിക്കുന്നതിന് തുല്യമാണ്, അവിടെയാണ് റിയാക്റ്റ് അസംബിൾ ചെയ്ത ഉള്ളടക്കം ഇടുന്നത്. മറ്റ് ചട്ടക്കൂടുകൾ വ്യത്യസ്ത പാതകൾ ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന്, എംബറിൽ ഇത് വിദൂരമാണ്. ഞങ്ങൾ ശേഖരിച്ച HTML, JavaScript, CSS എന്നിവ അടങ്ങിയ ഒരു ചിത്രമായിരിക്കും ഞങ്ങളുടെ ആദ്യ ക്ലസ്റ്റർ ടാസ്‌ക്കിന്റെ ഔട്ട്‌പുട്ട്.

NGINX അടിസ്ഥാനമാക്കി ഒരു ചിത്രം നിർമ്മിക്കുക

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

ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ - മുകളിൽ പറഞ്ഞതുപോലെ തന്നെ - ഒരു ക്ലസ്റ്റർ ടാസ്‌ക് webapp-build-runtime സൃഷ്‌ടിക്കും:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/webapp-build-runtime-task.yaml

നിങ്ങൾ ഈ ക്ലസ്റ്റർ ടാസ്‌ക്കുകളുടെ കോഡ് നോക്കുകയാണെങ്കിൽ, ഞങ്ങൾ പ്രവർത്തിക്കുന്ന Git റിപ്പോസിറ്ററിയോ ഞങ്ങൾ സൃഷ്‌ടിക്കുന്ന ചിത്രങ്ങളുടെ പേരുകളോ അതിൽ വ്യക്തമാക്കിയിട്ടില്ലെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും. Git-ലേക്ക് കൃത്യമായി എന്താണ് കൈമാറുന്നതെന്ന് അല്ലെങ്കിൽ അന്തിമ ചിത്രം ഔട്ട്‌പുട്ട് ചെയ്യേണ്ട ഒരു പ്രത്യേക ചിത്രം മാത്രമേ ഞങ്ങൾ വ്യക്തമാക്കൂ. അതുകൊണ്ടാണ് മറ്റ് ആപ്ലിക്കേഷനുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ ഈ ക്ലസ്റ്റർ ടാസ്‌ക്കുകൾ വീണ്ടും ഉപയോഗിക്കാൻ കഴിയുന്നത്.

ഇവിടെ ഞങ്ങൾ മനോഹരമായി അടുത്ത പോയിന്റിലേക്ക് നീങ്ങുന്നു ...

വിഭവങ്ങൾ

അതിനാൽ, ഞങ്ങൾ ഇപ്പോൾ പറഞ്ഞതുപോലെ, ക്ലസ്റ്റർ ടാസ്‌ക്കുകൾ കഴിയുന്നത്ര പൊതുവായതായിരിക്കണം, ഇൻപുട്ടായും (Git റിപ്പോസിറ്ററി) ഔട്ട്‌പുട്ടായും (അവസാന ചിത്രങ്ങൾ) ഉപയോഗിക്കുന്ന ഉറവിടങ്ങൾ ഞങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. ഞങ്ങൾക്ക് ആവശ്യമായ ആദ്യത്തെ ഉറവിടം Git ആണ്, ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ താമസിക്കുന്നത് ഇതുപോലുള്ള ഒന്ന്:

# This resource is the location of the git repo with the web application source
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: web-application-repo
spec:
  type: git
  params:
    - name: url
      value: https://github.com/nodeshift-starters/react-pipeline-example
    - name: revision
      value: master

ഇവിടെ പൈപ്പ്‌ലൈൻ റിസോഴ്‌സ് ജിറ്റ് ടൈപ്പാണ്. params വിഭാഗത്തിലെ url കീ ഒരു നിർദ്ദിഷ്‌ട ശേഖരത്തിലേക്ക് പോയിന്റ് ചെയ്യുകയും മാസ്റ്റർ ബ്രാഞ്ച് വ്യക്തമാക്കുകയും ചെയ്യുന്നു (ഇത് ഓപ്‌ഷണലാണ്, പക്ഷേ ഞങ്ങൾ ഇത് പൂർണ്ണതയ്ക്കായി എഴുതുന്നു).

s2i-web-app ടാസ്‌ക്കിന്റെ ഫലങ്ങൾ സംരക്ഷിക്കപ്പെടുന്ന ചിത്രത്തിനായി ഇപ്പോൾ ഞങ്ങൾ ഒരു ഉറവിടം സൃഷ്ടിക്കേണ്ടതുണ്ട്, ഇത് ഇതുപോലെയാണ് ചെയ്യുന്നത്:

# This resource is the result of running "npm run build",  the resulting built files will be located in /opt/app-root/output
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: built-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-application:latest

ഇവിടെ പൈപ്പ്ലൈൻ റിസോഴ്സ് ടൈപ്പ് ഇമേജാണ്, കൂടാതെ url പാരാമീറ്ററിന്റെ മൂല്യം ആന്തരിക OpenShift ഇമേജ് രജിസ്ട്രിയിലേക്ക് പോയിന്റ് ചെയ്യുന്നു, പ്രത്യേകിച്ച് webapp-pipeline നെയിംസ്പേസിൽ സ്ഥിതി ചെയ്യുന്ന ഒന്ന്. നിങ്ങൾ മറ്റൊരു നെയിംസ്‌പെയ്‌സാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ ഈ ക്രമീകരണം മാറ്റാൻ മറക്കരുത്.

അവസാനമായി, ഞങ്ങൾക്ക് ആവശ്യമായ അവസാന ഉറവിടവും ടൈപ്പ് ഇമേജ് ആയിരിക്കും, ഇത് വിന്യാസ സമയത്ത് ഉപയോഗിക്കപ്പെടുന്ന അവസാന NGINX ഇമേജായിരിക്കും:

# This resource is the image that will be just the static html, css, js files being run with nginx
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: runtime-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtime-web-application:latest

വീണ്ടും, വെബ്‌ആപ്പ്-പൈപ്പ്‌ലൈൻ നെയിംസ്‌പെയ്‌സിലെ ആന്തരിക ഓപ്പൺഷിഫ്റ്റ് രജിസ്‌ട്രിയിൽ ഈ ഉറവിടം ഇമേജ് സംഭരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക.

ഈ ഉറവിടങ്ങളെല്ലാം ഒരേസമയം സൃഷ്ടിക്കുന്നതിന്, ഞങ്ങൾ സൃഷ്ടിക്കുക കമാൻഡ് ഉപയോഗിക്കുന്നു:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/resources/resource.yaml

ഉറവിടങ്ങൾ ഇതുപോലെയാണ് സൃഷ്ടിച്ചതെന്ന് നിങ്ങൾക്ക് ഉറപ്പാക്കാം:

$ tkn resource ls

കൺവെയർ പൈപ്പ്ലൈൻ

ഇപ്പോൾ നമുക്ക് ആവശ്യമായ എല്ലാ ഘടകങ്ങളും ഉണ്ട്, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് അവയിൽ നിന്ന് ഒരു പൈപ്പ്ലൈൻ ഉണ്ടാക്കാം:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/pipelines/build-and-deploy-react.yaml

എന്നാൽ ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, നമുക്ക് ഈ ഘടകങ്ങൾ നോക്കാം. ആദ്യത്തേത് പേര്:

apiVersion: tekton.dev/v1alpha1
kind: Pipeline
metadata:
  name: build-and-deploy-react

തുടർന്ന് സ്പെക് വിഭാഗത്തിൽ ഞങ്ങൾ നേരത്തെ സൃഷ്ടിച്ച വിഭവങ്ങളുടെ ഒരു സൂചന കാണുന്നു:

spec:
  resources:
    - name: web-application-repo
      type: git
    - name: built-web-application-image
      type: image
    - name: runtime-web-application-image
      type: image

തുടർന്ന് ഞങ്ങളുടെ പൈപ്പ്ലൈൻ പൂർത്തിയാക്കേണ്ട ജോലികൾ ഞങ്ങൾ സൃഷ്ടിക്കുന്നു. ഒന്നാമതായി, ഞങ്ങൾ ഇതിനകം സൃഷ്‌ടിച്ച s2i-web-app ടാസ്‌ക് ഇത് എക്‌സിക്യൂട്ട് ചെയ്യണം:

tasks:
    - name: build-web-application
      taskRef:
        name: s2i-web-app
        kind: ClusterTask

ഈ ടാസ്ക്ക് ഇൻപുട്ടും (ഗിർ റിസോഴ്സ്) ഔട്ട്പുട്ടും (ബിൽറ്റ്-വെബ്-ആപ്ലിക്കേഷൻ-ഇമേജ് റിസോഴ്സ്) പാരാമീറ്ററുകൾ എടുക്കുന്നു. ഞങ്ങൾ സ്വയം ഒപ്പിട്ട സർട്ടിഫിക്കറ്റുകൾ ഉപയോഗിക്കുന്നതിനാൽ ഇത് TLS പരിശോധിക്കാതിരിക്കാൻ ഞങ്ങൾ ഒരു പ്രത്യേക പാരാമീറ്ററും കൈമാറുന്നു:

resources:
        inputs:
          - name: source
            resource: web-application-repo
        outputs:
          - name: image
            resource: built-web-application-image
      params:
        - name: TLSVERIFY
          value: "false"

അടുത്ത ടാസ്‌ക് ഏതാണ്ട് സമാനമാണ്, ഞങ്ങൾ ഇതിനകം സൃഷ്‌ടിച്ച വെബ്‌ആപ്പ്-ബിൽഡ്-റൺടൈം ക്ലസ്റ്റർ ടാസ്‌ക്കിനെ ഇവിടെ മാത്രമേ വിളിക്കൂ:

name: build-runtime-image
    taskRef:
      name: webapp-build-runtime
      kind: ClusterTask

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

resources:
        inputs:
          - name: image
            resource: built-web-application-image
        outputs:
          - name: image
            resource: runtime-web-application-image
        params:
        - name: TLSVERIFY
          value: "false"
      runAfter:
        - build-web-application

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

കൺവെയർ ആരംഭിക്കുന്നു

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

$ tkn pipeline start build-and-deploy-react

ഈ ഘട്ടത്തിൽ, കമാൻഡ് ലൈൻ ഇന്ററാക്ടീവ് ആയി ഉപയോഗിക്കുകയും അതിന്റെ ഓരോ അഭ്യർത്ഥനകൾക്കും മറുപടിയായി ഉചിതമായ ഉറവിടങ്ങൾ നിങ്ങൾ തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്: git റിസോഴ്സിനായി, web-application-repo തിരഞ്ഞെടുക്കുക, തുടർന്ന് ആദ്യത്തെ ഇമേജ് റിസോഴ്സിനായി, ബിൽറ്റ്-വെബ്-ആപ്ലിക്കേഷനായി -ചിത്രം, ഒടുവിൽ, രണ്ടാമത്തെ ഇമേജ് റിസോഴ്സിനായി -റൺടൈം-വെബ്-ആപ്ലിക്കേഷൻ-ഇമേജ്:

? Choose the git resource to use for web-application-repo: web-application-repo (https://github.com/nodeshift-starters/react-pipeline-example)
? Choose the image resource to use for built-web-application-image: built-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-
application:latest)
? Choose the image resource to use for runtime-web-application-image: runtime-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtim
e-web-application:latest)
Pipelinerun started: build-and-deploy-react-run-4xwsr

ഇനി താഴെ പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് പൈപ്പ്ലൈനിന്റെ നില പരിശോധിക്കാം:

$ tkn pipeline logs -f

പൈപ്പ്‌ലൈൻ ആരംഭിച്ച് ആപ്ലിക്കേഷൻ വിന്യസിച്ചുകഴിഞ്ഞാൽ, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് ഞങ്ങൾക്ക് പ്രസിദ്ധീകരിച്ച റൂട്ട് അഭ്യർത്ഥിക്കാം:

$ oc get route react-pipeline-example --template='http://{{.spec.host}}'

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

ചിത്രം.1. പ്രവർത്തിക്കുന്ന പൈപ്പ്ലൈനുകളുടെ അവലോകനം.

പ്രവർത്തിക്കുന്ന പൈപ്പ്ലൈനിൽ ക്ലിക്ക് ചെയ്യുമ്പോൾ, ചിത്രം 2-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ അധിക വിശദാംശങ്ങൾ കാണിക്കുന്നു.

അരി. 2. പൈപ്പ്ലൈനിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ.

കൂടുതൽ വിവരങ്ങൾക്ക് ശേഷം, വ്യൂവിൽ റൺ ചെയ്യുന്ന ആപ്ലിക്കേഷനുകൾ നിങ്ങൾക്ക് കാണാം ടോപ്പോളജി, Fig.3 ൽ കാണിച്ചിരിക്കുന്നത് പോലെ.

ചിത്രം 3. വിക്ഷേപിച്ച പോഡ്.

ഐക്കണിന്റെ മുകളിൽ വലത് കോണിലുള്ള സർക്കിളിൽ ക്ലിക്കുചെയ്യുന്നത് ചിത്രം 4-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ തുറക്കുന്നു.

അരി. 4. റിയാക്റ്റ് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നു.

തീരുമാനം

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

അധിക ഉറവിടങ്ങൾ (EN)

• സൗജന്യ ഇ-ബുക്ക് "ഓപ്പൺഷിഫ്റ്റിലെ വികസനം: അക്ഷമർക്ക് ഒരു വഴികാട്ടി"
• കണ്ടെയ്നർ കേന്ദ്രീകൃതമായ Node.js ആപ്ലിക്കേഷനുകൾ Red Hat OpenShift ആപ്ലിക്കേഷൻ റൺടൈമുകളും Istio ഉപയോഗിച്ച് നിർമ്മിക്കുന്നു
• Chrome DevTools ഉപയോഗിച്ച് OpenShift-ലെ Node.js ആപ്ലിക്കേഷനുകൾ ഡീബഗ്ഗിംഗ് ചെയ്യുന്നു
• ആദ്യം മുതൽ OpenShift-ൽ Express മാസ്റ്റർ ചെയ്യാനുള്ള മൂന്ന് കമാൻഡുകൾ
• Red Hat OpenShift ആപ്ലിക്കേഷൻ റൺടൈമിന്റെ ഭാഗമായി Node.js-ന്റെ പൊതുവായി ലഭ്യമായ പതിപ്പിന്റെ അറിയിപ്പ്
• Prometheus നൊപ്പം OpenShift-ലെ Node.js ആപ്ലിക്കേഷനുകൾ നിരീക്ഷിക്കുന്നു
• എന്നതിലെ മറ്റ് ലേഖനങ്ങൾ ഓപ്പൺഷിഫ്റ്റും കുബർനെറ്റസും Red Hat വെബ്സൈറ്റിൽ

വരാനിരിക്കുന്ന വെബിനാറുകളുടെ പ്രഖ്യാപനങ്ങൾ

Red Hat OpenShift കണ്ടെയ്‌നർ പ്ലാറ്റ്‌ഫോമും കുബർനെറ്റുകളും ഉപയോഗിച്ച് നേറ്റീവ് അനുഭവത്തെക്കുറിച്ചുള്ള വെള്ളിയാഴ്ച വെബ്‌നാറുകളുടെ ഒരു പരമ്പര ഞങ്ങൾ ആരംഭിക്കുന്നു:

• ഓഗസ്റ്റ് 28, വെബിനാർ എംപറർ "ഓപ്പറേറ്റർ": ഓപ്പൺഷിഫ്റ്റിലെയും കുബർനെറ്റിലെയും ഓപ്പറേറ്റർമാർ
• സെപ്തംബർ 11, DeploymentConfig vs Deployment - ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനും വിന്യസിക്കുന്നതിനുമുള്ള ഓപ്പൺഷിഫ്റ്റ്-നിർദ്ദിഷ്ട മാജിക്
• സെപ്റ്റംബർ 25, Red Hat OpenShift, Machine API
• ഒക്‌ടോബർ 9, പെട്ടെന്നുള്ള ജോലിഭാരം എങ്ങനെ നേരിടാം
• ഒക്‌ടോബർ 23, എംബഡഡ് ജെങ്കിൻസ്, പൈപ്പ്‌ലൈൻ-ബിൽഡ്‌സ്, ടെക്‌ടൺ ഇൻ റെഡ് ഹാറ്റ് ഓപ്പൺഷിഫ്റ്റ് കണ്ടെയ്‌നർ പ്ലാറ്റ്‌ഫോമിൽ

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