കുബർനെറ്റസ് വികസിപ്പിക്കുകയും പൂരകമാക്കുകയും ചെയ്യുക (അവലോകനവും വീഡിയോ റിപ്പോർട്ടും)

ഏപ്രിൽ 8 ന് സമ്മേളനത്തിൽ സെന്റ് ഹൈലോഡ്++ 2019, "DevOps ആൻഡ് ഓപ്പറേഷൻസ്" വിഭാഗത്തിന്റെ ഭാഗമായി, "Kubernetes വികസിപ്പിക്കുകയും പൂരകമാക്കുകയും ചെയ്യുക" എന്ന ഒരു റിപ്പോർട്ട് നൽകി, അതിൽ Flant കമ്പനിയിലെ മൂന്ന് ജീവനക്കാർ പങ്കെടുത്തു. അതിൽ, കുബെർനെറ്റസിന്റെ കഴിവുകൾ വികസിപ്പിക്കാനും പൂരകമാക്കാനും ഞങ്ങൾ ആഗ്രഹിക്കുന്ന നിരവധി സാഹചര്യങ്ങളെക്കുറിച്ച് ഞങ്ങൾ സംസാരിക്കുന്നു, എന്നാൽ അതിനായി ഞങ്ങൾ തയ്യാറാക്കിയതും ലളിതവുമായ ഒരു പരിഹാരം കണ്ടെത്തിയില്ല. ഓപ്പൺ സോഴ്സ് പ്രോജക്റ്റുകളുടെ രൂപത്തിൽ ആവശ്യമായ പരിഹാരങ്ങൾ ഞങ്ങളുടെ പക്കലുണ്ട്, ഈ പ്രസംഗവും അവർക്കായി സമർപ്പിക്കുന്നു.

പാരമ്പര്യമനുസരിച്ച്, അവതരിപ്പിക്കുന്നതിൽ ഞങ്ങൾക്ക് സന്തോഷമുണ്ട് റിപ്പോർട്ടിന്റെ വീഡിയോ (50 മിനിറ്റ്, ലേഖനത്തേക്കാൾ കൂടുതൽ വിവരദായകമാണ്) കൂടാതെ വാചക രൂപത്തിലുള്ള പ്രധാന സംഗ്രഹവും. പോകൂ!

K8s-ലെ കോറും കൂട്ടിച്ചേർക്കലുകളും

കുബെർനെറ്റസ് ദീർഘകാലമായി സ്ഥാപിതമായ വ്യവസായത്തെയും ഭരണത്തിലേക്കുള്ള സമീപനങ്ങളെയും മാറ്റുന്നു:

• അദ്ദേഹത്തിന് നന്ദി അമൂർത്തങ്ങൾ, ഞങ്ങൾ മേലിൽ ഒരു കോൺഫിഗറേഷൻ സജ്ജീകരിക്കുകയോ ഒരു കമാൻഡ് പ്രവർത്തിപ്പിക്കുകയോ (ഷെഫ്, അൻസിബിൾ...) പോലുള്ള ആശയങ്ങളുമായി പ്രവർത്തിക്കില്ല, എന്നാൽ കണ്ടെയ്‌നറുകൾ, സേവനങ്ങൾ മുതലായവ ഗ്രൂപ്പുചെയ്യൽ ഉപയോഗിക്കുക.
• യുടെ സൂക്ഷ്മതകളെക്കുറിച്ച് ചിന്തിക്കാതെ നമുക്ക് ആപ്ലിക്കേഷനുകൾ തയ്യാറാക്കാം നിർദ്ദിഷ്ട സൈറ്റ്, അത് സമാരംഭിക്കും: വെറും ലോഹം, ദാതാക്കളിൽ ഒരാളുടെ ക്ലൗഡ് മുതലായവ.
• K8s ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരിക്കലും കൂടുതൽ ആക്‌സസ് ചെയ്യാനായിട്ടില്ല മികച്ച സമ്പ്രദായങ്ങൾ അടിസ്ഥാന സൗകര്യങ്ങൾ സംഘടിപ്പിക്കുന്നതിൽ: സ്കെയിലിംഗ് ടെക്നിക്കുകൾ, സ്വയം-രോഗശാന്തി, തെറ്റ് സഹിഷ്ണുത മുതലായവ.

എന്നിരുന്നാലും, തീർച്ചയായും, എല്ലാം അത്ര സുഗമമല്ല: കുബർനെറ്റസും അതിന്റേതായ പുതിയ വെല്ലുവിളികൾ കൊണ്ടുവന്നു.

കുബേർനെറ്റ് അല്ല എല്ലാ ഉപയോക്താക്കളുടെയും എല്ലാ പ്രശ്നങ്ങളും പരിഹരിക്കുന്ന ഒരു സംയോജനമാണ്. കോർ ആവശ്യമായ ഏറ്റവും കുറഞ്ഞ ഫംഗ്‌ഷനുകളുടെ ഒരു കൂട്ടത്തിന് മാത്രമാണ് കുബർനെറ്റസ് ഉത്തരവാദി ഓരോന്നും ക്ലസ്റ്റർ:

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

മറുവശത്ത്, ലഭ്യമായ ഫംഗ്ഷനുകൾ വിപുലീകരിക്കാൻ K8s മികച്ച അവസരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, ഇത് മറ്റുള്ളവരെ അടയ്ക്കാൻ സഹായിക്കുന്നു - നിർദ്ദിഷ്ട - ഉപയോക്തൃ ആവശ്യങ്ങൾ. കുബർനെറ്റുകളിലേക്കുള്ള കൂട്ടിച്ചേർക്കലുകൾ ക്ലസ്റ്റർ അഡ്മിനിസ്ട്രേറ്റർമാരുടെ ഉത്തരവാദിത്തമാണ്, അവർ അവരുടെ ക്ലസ്റ്റർ "ശരിയായ രൂപത്തിൽ" [അവരുടെ നിർദ്ദിഷ്ട പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന്] ആവശ്യമായ എല്ലാം ഇൻസ്റ്റാൾ ചെയ്യുകയും കോൺഫിഗർ ചെയ്യുകയും വേണം. ഏത് തരത്തിലുള്ള കൂട്ടിച്ചേർക്കലുകളാണ് ഇവ? ചില ഉദാഹരണങ്ങൾ നോക്കാം.

ആഡ്-ഓണുകളുടെ ഉദാഹരണങ്ങൾ

Kubernetes ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, ഒരു നോഡിനുള്ളിലും നോഡുകൾക്കിടയിലും പോഡുകളുടെ പ്രതിപ്രവർത്തനത്തിന് ആവശ്യമായ നെറ്റ്‌വർക്കിംഗ് സ്വന്തമായി പ്രവർത്തിക്കാത്തതിൽ ഞങ്ങൾ ആശ്ചര്യപ്പെട്ടേക്കാം. Kubernetes കേർണൽ ആവശ്യമായ കണക്ഷനുകൾക്ക് ഉറപ്പുനൽകുന്നില്ല; പകരം, അത് നെറ്റ്‌വർക്ക് നിർണ്ണയിക്കുന്നു ഇന്റർഫേസ് (സിഎൻഐ) മൂന്നാം കക്ഷി ആഡ്-ഓണുകൾക്കായി. നെറ്റ്‌വർക്ക് കോൺഫിഗറേഷന് ഉത്തരവാദിത്തമുള്ള ഈ ആഡ്-ഓണുകളിൽ ഒന്ന് ഞങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യണം.

ഡാറ്റ സ്റ്റോറേജ് സൊല്യൂഷനുകൾ (ലോക്കൽ ഡിസ്ക്, നെറ്റ്‌വർക്ക് ബ്ലോക്ക് ഉപകരണം, സെഫ്...) ഒരു അടുത്ത ഉദാഹരണമാണ്. തുടക്കത്തിൽ അവർ കാമ്പിലായിരുന്നു, പക്ഷേ വരവോടെ സിഎസ്ഐ സ്ഥിതിഗതികൾ ഇതിനകം വിവരിച്ചതിന് സമാനമായ ഒന്നിലേക്ക് മാറുന്നു: ഇന്റർഫേസ് കുബെർനെറ്റസിലാണ്, അതിന്റെ നടപ്പാക്കൽ മൂന്നാം കക്ഷി മൊഡ്യൂളുകളിലുമാണ്.

മറ്റ് ഉദാഹരണങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:

• തുടരുക- കൺട്രോളറുകൾ (അവരുടെ അവലോകനം കാണുക ഞങ്ങളുടെ സമീപകാല ലേഖനം).
• സർട്ട് മാനേജർ:

  

• ഓപ്പറേറ്റർമാർ ആഡ്-ഓണുകളുടെ ഒരു മുഴുവൻ ക്ലാസ് ആണ് (അതിൽ സൂചിപ്പിച്ച സർട്ട് മാനേജർ ഉൾപ്പെടുന്നു), അവ പ്രാകൃത(കൾ), കൺട്രോളർ(കൾ) എന്നിവ നിർവ്വചിക്കുന്നു. അവരുടെ ജോലിയുടെ യുക്തി നമ്മുടെ ഭാവനയാൽ മാത്രം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു, കൂടാതെ റെഡിമെയ്ഡ് ഇൻഫ്രാസ്ട്രക്ചർ ഘടകങ്ങളെ (ഉദാഹരണത്തിന്, ഒരു ഡിബിഎംഎസ്) പ്രിമിറ്റീവുകളാക്കി മാറ്റാൻ ഞങ്ങളെ അനുവദിക്കുന്നു, അവ പ്രവർത്തിക്കാൻ വളരെ എളുപ്പമാണ് (ഒരു കൂട്ടം കണ്ടെയ്‌നറുകളും അവയുടെ ക്രമീകരണങ്ങളും ഉള്ളതിനേക്കാൾ). ധാരാളം ഓപ്പറേറ്റർമാർ എഴുതിയിട്ടുണ്ട് - അവരിൽ പലരും ഇതുവരെ നിർമ്മാണത്തിന് തയ്യാറായിട്ടില്ലെങ്കിലും, ഇത് സമയത്തിന്റെ കാര്യം മാത്രമാണ്:

  

• മെട്രിക്സ് - കുബെർനെറ്റസ് എങ്ങനെ ഇന്റർഫേസ് (മെട്രിക്സ് API) നടപ്പിലാക്കുന്നതിൽ നിന്ന് വേർപെടുത്തി എന്നതിന്റെ മറ്റൊരു ചിത്രം
• വേണ്ടി നിരീക്ഷണവും സ്ഥിതിവിവരക്കണക്കുകളും, പ്രായോഗികമായി മാത്രമല്ല ആവശ്യമുള്ളിടത്ത് പ്രൊമിത്യൂസും ഗ്രാഫാനയും, മാത്രമല്ല kube-state-metrics, node-exporter മുതലായവ.

കൂടാതെ ഇത് കൂട്ടിച്ചേർക്കലുകളുടെ പൂർണ്ണമായ ലിസ്റ്റ് അല്ല... ഉദാഹരണത്തിന്, ഞങ്ങൾ നിലവിൽ ഇൻസ്റ്റാൾ ചെയ്യുന്ന ഫ്ലാന്റ് കമ്പനിയിൽ 29 കൂട്ടിച്ചേർക്കലുകൾ (ഇവയെല്ലാം മൊത്തം 249 കുബർനെറ്റസ് ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കുന്നു). ലളിതമായി പറഞ്ഞാൽ, കൂട്ടിച്ചേർക്കലുകളില്ലാതെ നമുക്ക് ഒരു ക്ലസ്റ്ററിന്റെ ജീവിതം കാണാൻ കഴിയില്ല.

ഓട്ടോമേഷൻ

ഞങ്ങൾ ദിവസവും അഭിമുഖീകരിക്കുന്ന പതിവ് പ്രവർത്തനങ്ങൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനാണ് ഓപ്പറേറ്റർമാർ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഒരു ഓപ്പറേറ്റർ എഴുതുന്നത് ഒരു മികച്ച പരിഹാരമായ യഥാർത്ഥ ജീവിത ഉദാഹരണങ്ങൾ ഇതാ:

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

ഏത് ക്ലസ്റ്ററിലും, പതിവ് ജോലികൾ പരിഹരിക്കേണ്ടതുണ്ട്, കൂടാതെ ശരി ഓപ്പറേറ്റർമാരെ ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും.

വിവരിച്ച എല്ലാ കഥകളും സംഗ്രഹിച്ച്, ഞങ്ങൾ നിഗമനത്തിലെത്തി കുബർനെറ്റിലെ സുഖപ്രദമായ ജോലിക്ക് നിങ്ങൾക്ക് ആവശ്യമാണ്: എ) ആഡ്-ഓണുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക, b) ഓപ്പറേറ്റർമാരെ വികസിപ്പിക്കുക (ദൈനംദിന അഡ്‌മിൻ ടാസ്‌ക്കുകൾ പരിഹരിക്കുന്നതിന്).

കുബെർനെറ്റസിന് എങ്ങനെ ഒരു പ്രസ്താവന എഴുതാം?

പൊതുവേ, സ്കീം ലളിതമാണ്:

... എന്നാൽ പിന്നീട് അത് മാറുന്നു:

• കുബെർനെറ്റസ് API എന്നത് വളരെ നിസ്സാരമല്ലാത്ത കാര്യമാണ്, അത് മാസ്റ്റർ ചെയ്യാൻ വളരെയധികം സമയമെടുക്കും;
• പ്രോഗ്രാമിംഗ് എല്ലാവർക്കുമുള്ളതല്ല (ഗോ ഭാഷ തിരഞ്ഞെടുക്കപ്പെട്ട ഭാഷയായി തിരഞ്ഞെടുത്തത് അതിന് ഒരു പ്രത്യേക ചട്ടക്കൂട് ഉള്ളതിനാൽ - ഓപ്പറേറ്റർ എസ്.ഡി.കെ);
• ചട്ടക്കൂടിന്റെ കാര്യത്തിലും സ്ഥിതി സമാനമാണ്.

താഴത്തെ വരി: ഒരു കൺട്രോളർ എഴുതാൻ (ഓപ്പറേറ്റർ) ചെയ്യേണ്ടത് കാര്യമായ വിഭവങ്ങൾ ചെലവഴിക്കുക മെറ്റീരിയൽ പഠിക്കാൻ. "വലിയ" ഓപ്പറേറ്റർമാർക്ക് ഇത് ന്യായീകരിക്കപ്പെടും - MySQL DBMS-ന് വേണ്ടി. എന്നാൽ മുകളിൽ വിവരിച്ച ഉദാഹരണങ്ങൾ ഞങ്ങൾ ഓർക്കുന്നുവെങ്കിൽ (രഹസ്യങ്ങൾ തുറക്കുന്നു, ഇന്റർനെറ്റിലേക്ക് പോഡുകൾ ആക്‌സസ് ചെയ്യുന്നു...), അത് ഞങ്ങൾ ശരിയായി ചെയ്യാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ചെലവഴിച്ച പരിശ്രമം ഇപ്പോൾ ആവശ്യമുള്ള ഫലത്തേക്കാൾ കൂടുതലാണെന്ന് ഞങ്ങൾ മനസ്സിലാക്കും:

പൊതുവേ, ഒരു ആശയക്കുഴപ്പം ഉയർന്നുവരുന്നു: ധാരാളം വിഭവങ്ങൾ ചെലവഴിക്കുകയും പ്രസ്താവനകൾ എഴുതുന്നതിനുള്ള ശരിയായ ഉപകരണം കണ്ടെത്തുകയും ചെയ്യുക, അല്ലെങ്കിൽ അത് പഴയ രീതിയിൽ ചെയ്യുക (എന്നാൽ വേഗത്തിൽ). ഇത് പരിഹരിക്കുന്നതിന് - ഈ അതിരുകടന്നതുകൾക്കിടയിൽ ഒരു വിട്ടുവീഴ്ച കണ്ടെത്താൻ - ഞങ്ങൾ ഞങ്ങളുടെ സ്വന്തം പ്രോജക്റ്റ് സൃഷ്ടിച്ചു: ഷെൽ ഓപ്പറേറ്റർ (അവന്റെയും കാണുക സമീപകാല പ്രഖ്യാപനം ഹബ്ബിൽ).

ഷെൽ ഓപ്പറേറ്റർ

അവൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു? ക്ലസ്റ്ററിന് ഷെൽ-ഓപ്പറേറ്ററുള്ള ഒരു ഗോ ബൈനറി അടങ്ങിയ പോഡ് ഉണ്ട്. അവന്റെ അടുത്തായി ഒരു കൂട്ടം കൊളുത്തുകൾ (അവയെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ - താഴെ കാണുക). ഷെൽ ഓപ്പറേറ്റർ തന്നെ ചില കാര്യങ്ങൾ സബ്‌സ്‌ക്രൈബ് ചെയ്യുന്നു ഇവന്റുകൾ കുബെർനെറ്റസ് API-ൽ, അത് സംഭവിക്കുമ്പോൾ അനുബന്ധ കൊളുത്തുകൾ സമാരംഭിക്കുന്നു.

ഏതൊക്കെ ഇവന്റുകൾ വിളിക്കണമെന്ന് ഷെൽ ഓപ്പറേറ്റർക്ക് എങ്ങനെ അറിയാം? ഈ വിവരങ്ങൾ ഹുക്കുകൾ വഴി ഷെൽ-ഓപ്പറേറ്ററിലേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്നു, അവർ അത് വളരെ ലളിതമായി ചെയ്യുന്നു.

ഒരൊറ്റ ആർഗ്യുമെന്റ് അംഗീകരിക്കുന്ന ഒരു ബാഷ് സ്ക്രിപ്റ്റോ മറ്റേതെങ്കിലും എക്സിക്യൂട്ടബിൾ ഫയലോ ആണ് ഹുക്ക് --config കൂടാതെ JSON-മായി പ്രതികരിക്കുന്നു. രണ്ടാമത്തേത് ഏത് വസ്തുക്കളാണ് താൽപ്പര്യമുള്ളതെന്നും ഏത് സംഭവങ്ങളോട് (ഈ വസ്തുക്കൾക്ക്) പ്രതികരിക്കണമെന്നും നിർണ്ണയിക്കുന്നു:

ഞങ്ങളുടെ ഉദാഹരണങ്ങളിലൊന്നിന്റെ ഷെൽ-ഓപ്പറേറ്ററിൽ നടപ്പിലാക്കുന്നത് ഞാൻ ചിത്രീകരിക്കും - ആപ്ലിക്കേഷൻ ഇമേജുകൾക്കൊപ്പം ഒരു സ്വകാര്യ രജിസ്ട്രി ആക്സസ് ചെയ്യുന്നതിനുള്ള രഹസ്യങ്ങൾ വിഘടിപ്പിക്കുന്നു. ഇത് രണ്ട് ഘട്ടങ്ങൾ ഉൾക്കൊള്ളുന്നു.

പ്രാക്ടീസ്: 1. ഒരു ഹുക്ക് എഴുതുക

ഒന്നാമതായി, ഹുക്കിൽ ഞങ്ങൾ പ്രോസസ്സ് ചെയ്യും --config, നെയിംസ്‌പെയ്‌സുകളിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെന്ന് സൂചിപ്പിക്കുന്നു, പ്രത്യേകിച്ചും, അവ സൃഷ്ടിക്കപ്പെട്ട നിമിഷം:

[[ $1 == "--config" ]] ; then
  cat << EOF
{
  "onKubernetesEvent": [
    {
      "kind": "namespace",
      "event": ["add"]
    }
  ]
}
EOF
…

യുക്തി എങ്ങനെയായിരിക്കും? കൂടാതെ വളരെ ലളിതമാണ്:

…
else
  createdNamespace=$(jq -r '.[0].resourceName' $BINDING_CONTEXT_PATH)
  kubectl create -n ${createdNamespace} -f - << EOF
Kind: Secret
...
EOF
fi

ഏത് നെയിംസ്പേസ് സൃഷ്ടിച്ചുവെന്ന് കണ്ടെത്തുക എന്നതാണ് ആദ്യപടി, രണ്ടാമത്തേത് അത് ഉപയോഗിച്ച് സൃഷ്ടിക്കുക എന്നതാണ് kubectl ഈ നെയിംസ്പേസിന്റെ രഹസ്യം.

പ്രാക്ടീസ്: 2. ചിത്രം കൂട്ടിച്ചേർക്കുന്നു

സൃഷ്ടിച്ച ഹുക്ക് ഷെൽ ഓപ്പറേറ്ററിന് കൈമാറുക മാത്രമാണ് അവശേഷിക്കുന്നത് - ഇത് എങ്ങനെ ചെയ്യാം? ഷെൽ-ഓപ്പറേറ്റർ തന്നെ ഒരു ഡോക്കർ ഇമേജായി വരുന്നു, അതിനാൽ ഈ ചിത്രത്തിലെ ഒരു പ്രത്യേക ഡയറക്ടറിയിലേക്ക് ഹുക്ക് ചേർക്കുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല:

FROM flant/shell-operator:v1.0.0-beta.1
ADD my-handler.sh /hooks

അത് കൂട്ടിച്ചേർക്കുകയും തള്ളുകയും ചെയ്യുക എന്നതാണ് അവശേഷിക്കുന്നത്:

$ docker build -t registry.example.com/my-operator:v1 .
$ docker push registry.example.com/my-operator:v1

ക്ലസ്റ്ററിലേക്ക് ചിത്രം വിന്യസിക്കുക എന്നതാണ് അവസാന ടച്ച്. ഇത് ചെയ്യുന്നതിന്, നമുക്ക് എഴുതാം വിന്യാസ:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-operator
spec:
  template:
    spec:
      containers:
      - name: my-operator
        image: registry.example.com/my-operator:v1 # 1
      serviceAccountName: my-operator              # 2

ശ്രദ്ധിക്കേണ്ട രണ്ട് പോയിന്റുകളുണ്ട്:

1. പുതുതായി സൃഷ്ടിച്ച ചിത്രത്തിന്റെ സൂചന;
2. കുബെർനെറ്റസിലെ ഇവന്റുകൾ സബ്‌സ്‌ക്രൈബുചെയ്യുന്നതിനും നെയിംസ്‌പെയ്‌സുകളിലേക്ക് രഹസ്യങ്ങൾ അനുവദിക്കുന്നതിനും (കുറഞ്ഞത്) അവകാശങ്ങൾ ആവശ്യമുള്ള ഒരു സിസ്റ്റം ഘടകമാണിത്, അതിനാൽ ഞങ്ങൾ ഹുക്കിനായി ഒരു ServiceAccount (കൂടാതെ ഒരു കൂട്ടം നിയമങ്ങളും) സൃഷ്‌ടിക്കുന്നു.

ഫലം - ഞങ്ങൾ ഞങ്ങളുടെ പ്രശ്നം പരിഹരിച്ചു ബന്ധുക്കൾ രഹസ്യങ്ങൾ വിഘടിപ്പിക്കുന്നതിനുള്ള ഒരു ഓപ്പറേറ്ററെ സൃഷ്ടിക്കുന്ന വിധത്തിൽ കുബെർനെറ്റസിനായി.

മറ്റ് ഷെൽ ഓപ്പറേറ്റർ സവിശേഷതകൾ

ഹുക്ക് പ്രവർത്തിക്കുന്ന നിങ്ങൾ തിരഞ്ഞെടുത്ത തരത്തിലുള്ള ഒബ്ജക്റ്റുകൾ പരിമിതപ്പെടുത്താൻ, അവ ഫിൽട്ടർ ചെയ്യാം, ചില ലേബലുകൾ അനുസരിച്ച് തിരഞ്ഞെടുക്കുന്നു (അല്ലെങ്കിൽ ഉപയോഗിക്കുന്നത് matchExpressions):

"onKubernetesEvent": [
  {
    "selector": {
      "matchLabels": {
        "foo": "bar",
       },
       "matchExpressions": [
         {
           "key": "allow",
           "operation": "In",
           "values": ["wan", "warehouse"],
         },
       ],
     }
     …
  }
]

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

ഒരു ഹുക്ക് വിളിക്കുമ്പോൾ, ഷെൽ-ഓപ്പറേറ്റർ അത് കടന്നുപോകുന്നു ഒബ്ജക്റ്റ് ഡാറ്റ, ഏത് ആവശ്യത്തിനും ഉപയോഗിക്കാം.

ഹുക്കുകൾ ട്രിഗർ ചെയ്യുന്ന ഇവന്റുകൾ കുബർനെറ്റസ് ഇവന്റുകൾക്ക് മാത്രമായി പരിമിതപ്പെടുത്തിയിട്ടില്ല: ഷെൽ-ഓപ്പറേറ്റർ പിന്തുണ നൽകുന്നു സമയം കൊണ്ട് കൊളുത്തുകൾ വിളിക്കുന്നു (പരമ്പരാഗത ഷെഡ്യൂളറിലെ ക്രോണ്ടാബിന് സമാനമായത്), കൂടാതെ ഒരു പ്രത്യേക ഇവന്റും തുടക്കത്തിൽ. ഈ ഇവന്റുകളെല്ലാം സംയോജിപ്പിച്ച് ഒരേ ഹുക്കിലേക്ക് അസൈൻ ചെയ്യാം.

ഷെൽ-ഓപ്പറേറ്ററിന്റെ രണ്ട് സവിശേഷതകൾ കൂടി:

1. ഇത് പ്രവർത്തിക്കുന്നു അസമന്വിതമായി. ഒരു കുബെർനെറ്റസ് ഇവന്റ് (ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നത് പോലെയുള്ളത്) ലഭിച്ചതിനാൽ, മറ്റ് ഇവന്റുകൾ (അതേ ഒബ്‌ജക്റ്റ് ഇല്ലാതാക്കുന്നത് പോലുള്ളവ) ക്ലസ്റ്ററിൽ സംഭവിക്കാം, ഹുക്കുകൾ ഇത് കണക്കിലെടുക്കേണ്ടതുണ്ട്. ഒരു പിശക് ഉപയോഗിച്ചാണ് ഹുക്ക് എക്സിക്യൂട്ട് ചെയ്തതെങ്കിൽ, സ്ഥിരസ്ഥിതിയായി അത് ആയിരിക്കും വീണ്ടും വിളിക്കുക വിജയകരമായി പൂർത്തിയാകുന്നതുവരെ (ഈ സ്വഭാവം മാറ്റാവുന്നതാണ്).
2. അത് കയറ്റുമതി ചെയ്യുന്നു അളവുകൾ പ്രൊമിത്യൂസിനായി, ഷെൽ-ഓപ്പറേറ്റർ പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് നിങ്ങൾക്ക് മനസിലാക്കാൻ കഴിയും, ഓരോ ഹുക്കിനുമുള്ള പിശകുകളുടെ എണ്ണവും നിലവിലെ ക്യൂ വലുപ്പവും കണ്ടെത്തുക.

റിപ്പോർട്ടിന്റെ ഈ ഭാഗം സംഗ്രഹിക്കാൻ:

ആഡ്-ഓണുകൾ ഇൻസ്റ്റാളേഷൻ

Kubernetes-ന്റെ സുഖപ്രദമായ ജോലിക്ക്, ആഡ്-ഓണുകൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതിന്റെ ആവശ്യകതയും സൂചിപ്പിച്ചു. ഞങ്ങൾ ഇപ്പോൾ അത് എങ്ങനെ ചെയ്യുന്നു എന്നതിനുള്ള ഞങ്ങളുടെ കമ്പനിയുടെ പാതയുടെ ഉദാഹരണം ഉപയോഗിച്ച് ഞാൻ ഇതിനെക്കുറിച്ച് നിങ്ങളോട് പറയും.

നിരവധി ക്ലസ്റ്ററുകളുള്ള കുബർനെറ്റസുമായി ഞങ്ങൾ പ്രവർത്തിക്കാൻ തുടങ്ങി, അതിനുള്ള ഏക കൂട്ടിച്ചേർക്കൽ ഇൻഗ്രെസ്സ് ആയിരുന്നു. ഓരോ ക്ലസ്റ്ററിലും ഇത് വ്യത്യസ്തമായി ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്, കൂടാതെ വ്യത്യസ്ത പരിതസ്ഥിതികൾക്കായി ഞങ്ങൾ നിരവധി YAML കോൺഫിഗറേഷനുകൾ ഉണ്ടാക്കി: ബെയർ മെറ്റൽ, AWS...

കൂടുതൽ ക്ലസ്റ്ററുകൾ ഉള്ളതിനാൽ, കൂടുതൽ കോൺഫിഗറേഷനുകൾ ഉണ്ടായിരുന്നു. കൂടാതെ, ഞങ്ങൾ ഈ കോൺഫിഗറേഷനുകൾ സ്വയം മെച്ചപ്പെടുത്തി, അതിന്റെ ഫലമായി അവ തികച്ചും വൈവിധ്യപൂർണ്ണമായി:

എല്ലാം ക്രമീകരിക്കാൻ, ഞങ്ങൾ ഒരു സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ആരംഭിച്ചു (install-ingress.sh), ഞങ്ങൾ ഏത് തരം ക്ലസ്റ്ററിലേക്ക് വിന്യസിക്കും എന്നത് ഒരു വാദമായി എടുത്ത്, ആവശ്യമായ YAML കോൺഫിഗറേഷൻ സൃഷ്‌ടിക്കുകയും അത് കുബർനെറ്റസിലേക്ക് റോൾ ചെയ്യുകയും ചെയ്തു.

ചുരുക്കത്തിൽ, ഞങ്ങളുടെ തുടർന്നുള്ള പാതയും അതുമായി ബന്ധപ്പെട്ട ന്യായവാദവും ഇപ്രകാരമായിരുന്നു:

• YAML കോൺഫിഗറേഷനുകളിൽ പ്രവർത്തിക്കാൻ, ഒരു ടെംപ്ലേറ്റ് എഞ്ചിൻ ആവശ്യമാണ് (ആദ്യ ഘട്ടങ്ങളിൽ ഇത് ലളിതമായ സെഡ് ആണ്);
• ക്ലസ്റ്ററുകളുടെ എണ്ണം കൂടുന്നതിനനുസരിച്ച്, ഓട്ടോമാറ്റിക് അപ്‌ഡേറ്റിന്റെ ആവശ്യകത വന്നു (ആദ്യത്തെ പരിഹാരം Git-ൽ സ്ക്രിപ്റ്റ് ഇടുക, ക്രോൺ ഉപയോഗിച്ച് അപ്ഡേറ്റ് ചെയ്ത് പ്രവർത്തിപ്പിക്കുക);
• പ്രോമിത്യൂസിനും സമാനമായ ഒരു സ്ക്രിപ്റ്റ് ആവശ്യമായിരുന്നു (install-prometheus.sh), എന്നിരുന്നാലും, ഇതിന് കൂടുതൽ ഇൻപുട്ട് ഡാറ്റയും അവയുടെ സംഭരണവും (നല്ല രീതിയിൽ - കേന്ദ്രീകൃതവും ഒരു ക്ലസ്റ്ററിലും) ആവശ്യമാണ് എന്നതും ശ്രദ്ധേയമാണ്, കൂടാതെ ചില ഡാറ്റ (പാസ്‌വേഡുകൾ) സ്വയമേവ സൃഷ്ടിക്കാൻ കഴിയും:

  

• വർദ്ധിച്ചുവരുന്ന ക്ലസ്റ്ററുകളിലേക്ക് എന്തെങ്കിലും തെറ്റ് വരുത്താനുള്ള സാധ്യത നിരന്തരം വർദ്ധിച്ചുകൊണ്ടിരിക്കുകയാണ്, അതിനാൽ ഇൻസ്റ്റാളറുകൾ എന്ന് ഞങ്ങൾ മനസ്സിലാക്കി (അതായത് രണ്ട് സ്ക്രിപ്റ്റുകൾ: ഇൻഗ്രെസ്സിനും പ്രൊമിത്യൂസിനും) സ്റ്റേജിംഗ് ആവശ്യമായിരുന്നു (Git-ലെ നിരവധി ശാഖകൾ, അവയെ അനുബന്ധമായി അപ്ഡേറ്റ് ചെയ്യാൻ നിരവധി ക്രോണുകൾ: സ്ഥിരതയുള്ള അല്ലെങ്കിൽ ടെസ്റ്റ് ക്ലസ്റ്ററുകൾ);
• с kubectl apply അത് ഡിക്ലറേറ്റീവ് അല്ലാത്തതിനാലും ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാൻ മാത്രമേ കഴിയൂ എന്നതിനാലും പ്രവർത്തിക്കാൻ ബുദ്ധിമുട്ടാണ്, എന്നാൽ അവയുടെ സ്റ്റാറ്റസ്/ഇല്ലാതാക്കുന്നതിന് തീരുമാനങ്ങൾ എടുക്കാൻ കഴിയില്ല;
• ആ സമയത്ത് ഞങ്ങൾ നടപ്പിലാക്കിയിട്ടില്ലാത്ത ചില ഫംഗ്‌ഷനുകൾ ഞങ്ങൾക്ക് നഷ്‌ടമായി:
  • ക്ലസ്റ്റർ അപ്‌ഡേറ്റുകളുടെ ഫലത്തിന്റെ പൂർണ്ണ നിയന്ത്രണം,
  • ക്ലസ്റ്ററിൽ നിന്ന് ലഭിക്കുന്ന ഡാറ്റയെ അടിസ്ഥാനമാക്കി (കണ്ടെത്തൽ) ചില പരാമീറ്ററുകൾ (ഇൻസ്റ്റലേഷൻ സ്ക്രിപ്റ്റുകൾക്കുള്ള ഇൻപുട്ട്) യാന്ത്രികമായി നിർണ്ണയിക്കുക,
  • തുടർച്ചയായ കണ്ടെത്തലിന്റെ രൂപത്തിൽ അതിന്റെ ലോജിക്കൽ വികസനം.

ഞങ്ങളുടെ മറ്റ് പ്രോജക്റ്റിന്റെ ചട്ടക്കൂടിനുള്ളിൽ ഈ ശേഖരിച്ച അനുഭവങ്ങളെല്ലാം ഞങ്ങൾ നടപ്പിലാക്കി - addon-operator.

ആഡ്-ഓപ്പറേറ്റർ

ഇത് ഇതിനകം സൂചിപ്പിച്ച ഷെൽ ഓപ്പറേറ്ററെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. മുഴുവൻ സിസ്റ്റവും ഇതുപോലെ കാണപ്പെടുന്നു:

ഷെൽ-ഓപ്പറേറ്റർ ഹുക്കുകളിലേക്ക് ഇനിപ്പറയുന്നവ ചേർത്തിരിക്കുന്നു:

• മൂല്യങ്ങളുടെ സംഭരണം,
• ഹെൽം ചാർട്ട്,
• ഘടകം മൂല്യങ്ങളുടെ സ്റ്റോർ നിരീക്ഷിക്കുന്നു കൂടാതെ - എന്തെങ്കിലും മാറ്റങ്ങളുണ്ടെങ്കിൽ - ചാർട്ട് വീണ്ടും റോൾ ചെയ്യാൻ ഹെൽമിനോട് ആവശ്യപ്പെടുന്നു.

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

നിരവധി മൊഡ്യൂളുകൾ ഉണ്ടാകാം, അവയിലേക്ക് ഞങ്ങൾ ആഗോള കൊളുത്തുകൾ, ഒരു ആഗോള മൂല്യ സ്റ്റോർ, ഈ ആഗോള സ്റ്റോർ നിരീക്ഷിക്കുന്ന ഒരു ഘടകം എന്നിവ ചേർക്കുന്നു.

ഇപ്പോൾ, കുബർനെറ്റസിൽ എന്തെങ്കിലും സംഭവിക്കുമ്പോൾ, ഒരു ഗ്ലോബൽ ഹുക്ക് ഉപയോഗിച്ച് നമുക്ക് അതിനോട് പ്രതികരിക്കാനും ഗ്ലോബൽ സ്റ്റോറിൽ എന്തെങ്കിലും മാറ്റാനും കഴിയും. ഈ മാറ്റം ശ്രദ്ധിക്കപ്പെടുകയും ക്ലസ്റ്ററിലെ എല്ലാ മൊഡ്യൂളുകളും പുറത്തുവരാൻ ഇടയാക്കുകയും ചെയ്യും:

മുകളിൽ പറഞ്ഞിരിക്കുന്ന ആഡ്-ഓണുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുള്ള എല്ലാ ആവശ്യകതകളും ഈ സ്കീം നിറവേറ്റുന്നു:

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

ഈ മുഴുവൻ സിസ്റ്റവും Go-യിൽ ഒരൊറ്റ ബൈനറിയുടെ രൂപത്തിലാണ് നടപ്പിലാക്കുന്നത്, ഇതിനെ addon-operator എന്ന് വിളിക്കുന്നു. ഇത് ഡയഗ്രം ലളിതമാക്കുന്നു:

ഈ ഡയഗ്രാമിലെ പ്രധാന ഘടകം മൊഡ്യൂളുകളുടെ ഒരു കൂട്ടമാണ് (ചുവടെ ചാരനിറത്തിൽ ഹൈലൈറ്റ് ചെയ്തിരിക്കുന്നു). ഇപ്പോൾ നമുക്ക് ആവശ്യമായ ആഡ്-ഓണിനായി ഒരു മൊഡ്യൂൾ എഴുതാം, കൂടാതെ അത് ഓരോ ക്ലസ്റ്ററിലും ഇൻസ്റ്റാൾ ചെയ്യപ്പെടുകയും അപ്‌ഡേറ്റ് ചെയ്യുകയും ക്ലസ്റ്ററിൽ ആവശ്യമായ ഇവന്റുകളോട് പ്രതികരിക്കുകയും ചെയ്യുമെന്ന് ഉറപ്പാക്കുക.

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

addon-operator-നുള്ള മൊഡ്യൂളുകൾ എനിക്ക് എവിടെ നിന്ന് ലഭിക്കും? ഞങ്ങളുടെ ലൈബ്രറി പ്രസിദ്ധീകരിക്കുന്നത് ഞങ്ങൾക്ക് അടുത്ത ഘട്ടമാണ്; വേനൽക്കാലത്ത് ഇത് ചെയ്യാൻ ഞങ്ങൾ പദ്ധതിയിടുന്നു.

വീഡിയോകളും സ്ലൈഡുകളും

പ്രകടനത്തിൽ നിന്നുള്ള വീഡിയോ (~50 മിനിറ്റ്):

റിപ്പോർട്ടിന്റെ അവതരണം:

പി.എസ്

ഞങ്ങളുടെ ബ്ലോഗിലെ മറ്റ് റിപ്പോർട്ടുകൾ:

• «ഡാറ്റാബേസുകളും കുബർനെറ്റുകളും"; (Dmitry Stolyarov; നവംബർ 8, 2018 ഹൈലോഡ്++ ൽ);
• «നിരീക്ഷണവും കുബർനെറ്റസും"; (Dmitry Stolyarov; മെയ് 28, 2018 RootConf-ൽ);
• «കുബർനെറ്റസ്, GitLab എന്നിവയ്‌ക്കൊപ്പമുള്ള CI/CD മികച്ച രീതികൾ"; (Dmitry Stolyarov; നവംബർ 7, 2017 ഹൈലോഡ്++ ൽ);
• «ചെറിയ പ്രോജക്ടുകളിൽ കുബർനെറ്റുകളുമായുള്ള ഞങ്ങളുടെ അനുഭവം"; (Dmitry Stolyarov; ജൂൺ 6, 2017 RootConf-ൽ).

ഇനിപ്പറയുന്ന പ്രസിദ്ധീകരണങ്ങളിലും നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടാകാം:

• «ഷെൽ-ഓപ്പറേറ്റർ അവതരിപ്പിക്കുന്നു: കുബർനെറ്റസിനായി ഓപ്പറേറ്റർമാരെ സൃഷ്ടിക്കുന്നത് ഇപ്പോൾ എളുപ്പമായി".

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