Kubernetes-ൽ HA മോഡിൽ കീക്ലോക്ക് റൺ ചെയ്യുന്നു

അച്ചു ഡി.ആർ.: കീക്ലോക്കിന്റെ ഒരു വിവരണം, ഒരു ഓപ്പൺ സോഴ്സ് ആക്സസ് കൺട്രോൾ സിസ്റ്റം, ആന്തരിക ഘടനയുടെ വിശകലനം, കോൺഫിഗറേഷൻ വിശദാംശങ്ങൾ എന്നിവ ഉണ്ടാകും.

ആമുഖവും പ്രധാന ആശയങ്ങളും

ഈ ലേഖനത്തിൽ, കുബർനെറ്റസിന്റെ മുകളിൽ ഒരു കീക്ലോക്ക് ക്ലസ്റ്റർ വിന്യസിക്കുമ്പോൾ മനസ്സിൽ സൂക്ഷിക്കേണ്ട അടിസ്ഥാന ആശയങ്ങൾ ഞങ്ങൾ കാണും.

നിങ്ങൾക്ക് കീക്ലോക്കിനെക്കുറിച്ച് കൂടുതലറിയണമെങ്കിൽ, ലേഖനത്തിന്റെ അവസാനത്തെ ലിങ്കുകൾ പരിശോധിക്കുക. പരിശീലനത്തിൽ കൂടുതൽ മുഴുകാൻ, നിങ്ങൾക്ക് പഠിക്കാം ഞങ്ങളുടെ ശേഖരം ഈ ലേഖനത്തിന്റെ പ്രധാന ആശയങ്ങൾ നടപ്പിലാക്കുന്ന ഒരു മൊഡ്യൂളിനൊപ്പം (ലോഞ്ച് ഗൈഡ് അവിടെയുണ്ട്, ഈ ലേഖനം ഉപകരണത്തിന്റെയും ക്രമീകരണങ്ങളുടെയും ഒരു അവലോകനം നൽകും, ഏകദേശം. വിവർത്തകൻ).

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

ഒഫീഷ്യൽ വായിക്കാൻ ഞങ്ങൾ നിങ്ങളെ ക്ഷണിക്കുന്നു വെബ്സൈറ്റ് അഥവാ വിക്കിപീഡിയ വിശദമായ ധാരണയ്ക്കായി.

കീക്ലോക്ക് ലോഞ്ച് ചെയ്യുന്നു

കീക്ലോക്കിന് പ്രവർത്തിക്കാൻ രണ്ട് സ്ഥിരമായ ഡാറ്റ ഉറവിടങ്ങൾ ആവശ്യമാണ്:

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

കീക്ലോക്ക് നാല് വ്യത്യസ്ത മോഡുകളിൽ പ്രവർത്തിക്കുന്നു:

• സാധാരണമായ - ഒരേയൊരു പ്രക്രിയ, ഒരു ഫയൽ വഴി ക്രമീകരിച്ചിരിക്കുന്നു standalone.xml
• റെഗുലർ ക്ലസ്റ്റർ (ഉയർന്ന ലഭ്യത ഓപ്ഷൻ) - എല്ലാ പ്രക്രിയകളും ഒരേ കോൺഫിഗറേഷൻ ഉപയോഗിക്കണം, അത് സ്വമേധയാ സമന്വയിപ്പിക്കണം. ക്രമീകരണങ്ങൾ ഒരു ഫയലിൽ സംഭരിച്ചിരിക്കുന്നു ഒറ്റത്തവണ-ha.xml, കൂടാതെ നിങ്ങൾ ഡാറ്റാബേസിലേക്കും ഒരു ലോഡ് ബാലൻസറിലേക്കും പങ്കിട്ട ആക്സസ് ഉണ്ടാക്കേണ്ടതുണ്ട്.
• ഡൊമെയ്ൻ ക്ലസ്റ്റർ — സാധാരണ മോഡിൽ ഒരു ക്ലസ്റ്റർ ആരംഭിക്കുന്നത് ക്ലസ്റ്റർ വളരുന്തോറും ഒരു പതിവുള്ളതും വിരസമായതുമായ ഒരു ജോലിയായി മാറുന്നു, ഓരോ തവണയും കോൺഫിഗറേഷൻ മാറുന്നതിനാൽ, ഓരോ ക്ലസ്റ്റർ നോഡിലും എല്ലാ മാറ്റങ്ങളും വരുത്തേണ്ടതുണ്ട്. ചില പങ്കിട്ട സ്റ്റോറേജ് ലൊക്കേഷൻ സജ്ജീകരിച്ച് കോൺഫിഗറേഷൻ പ്രസിദ്ധീകരിക്കുന്നതിലൂടെ ഡൊമെയ്ൻ പ്രവർത്തന രീതി ഈ പ്രശ്നം പരിഹരിക്കുന്നു. ഈ ക്രമീകരണങ്ങൾ ഫയലിൽ സംഭരിച്ചിരിക്കുന്നു domain.xml
• ഡാറ്റാ സെന്ററുകൾ തമ്മിലുള്ള അനുകരണം - നിങ്ങൾക്ക് നിരവധി ഡാറ്റാ സെന്ററുകളുടെ ഒരു ക്ലസ്റ്ററിൽ കീക്ലോക്ക് പ്രവർത്തിപ്പിക്കണമെങ്കിൽ, മിക്കപ്പോഴും വ്യത്യസ്ത ഭൂമിശാസ്ത്രപരമായ സ്ഥലങ്ങളിൽ. ഈ ഓപ്ഷനിൽ, ഓരോ ഡാറ്റാ സെന്ററിനും അതിന്റേതായ കീക്ലോക്ക് സെർവറുകളുടെ ക്ലസ്റ്റർ ഉണ്ടായിരിക്കും.

ഈ ലേഖനത്തിൽ ഞങ്ങൾ രണ്ടാമത്തെ ഓപ്ഷൻ വിശദമായി പരിഗണിക്കും, അതായത് സാധാരണ ക്ലസ്റ്റർ, കൂടാതെ ഡാറ്റാ സെന്ററുകൾ തമ്മിലുള്ള പകർപ്പെടുക്കൽ എന്ന വിഷയത്തിലും ഞങ്ങൾ അൽപ്പം സ്പർശിക്കും, കാരണം ഈ രണ്ട് ഓപ്ഷനുകൾ കുബർനെറ്റസിൽ പ്രവർത്തിപ്പിക്കുന്നതിൽ അർത്ഥമുണ്ട്. ഭാഗ്യവശാൽ, കുബർനെറ്റസിൽ നിരവധി പോഡുകളുടെ (കീക്ലോക്ക് നോഡുകൾ) ക്രമീകരണങ്ങൾ സമന്വയിപ്പിക്കുന്നതിൽ ഒരു പ്രശ്നവുമില്ല. ഡൊമെയ്ൻ ക്ലസ്റ്റർ അത് ചെയ്യാൻ വലിയ ബുദ്ധിമുട്ടുണ്ടാകില്ല.

എന്ന വാക്ക് കൂടി ദയവായി ശ്രദ്ധിക്കുക ക്ലസ്റ്റർ ലേഖനത്തിന്റെ ബാക്കി ഭാഗങ്ങൾ ഒരുമിച്ച് പ്രവർത്തിക്കുന്ന ഒരു കൂട്ടം കീക്ലോക്ക് നോഡുകൾക്ക് മാത്രമേ ബാധകമാകൂ, ഒരു കുബർനെറ്റസ് ക്ലസ്റ്ററിനെ പരാമർശിക്കേണ്ട ആവശ്യമില്ല.

സാധാരണ കീക്ലോക്ക് ക്ലസ്റ്റർ

ഈ മോഡിൽ കീക്ലോക്ക് പ്രവർത്തിപ്പിക്കുന്നതിന് നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

• ബാഹ്യ പങ്കിട്ട ഡാറ്റാബേസ് ക്രമീകരിക്കുക
• ലോഡ് ബാലൻസർ ഇൻസ്റ്റാൾ ചെയ്യുക
• IP മൾട്ടികാസ്റ്റ് പിന്തുണയുള്ള ഒരു ആന്തരിക നെറ്റ്‌വർക്ക് ഉണ്ട്

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

ഒരു ഫെയ്‌ലോവർ (എച്ച്‌എ) ക്ലസ്റ്ററിൽ കീക്ലോക്ക് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നന്നായി മനസിലാക്കാൻ, വൈൽഡ്‌ഫ്ലൈയുടെ ക്ലസ്റ്ററിംഗ് കഴിവുകളെ അതെല്ലാം എത്രമാത്രം ആശ്രയിച്ചിരിക്കുന്നു എന്ന് അറിയേണ്ടത് പ്രധാനമാണ്.

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

• mod_cluster: ഒരു HTTP ലോഡ് ബാലൻസറായി അപ്പാച്ചെയുമായി സംയോജിച്ച് പ്രവർത്തിക്കുന്നു, സ്ഥിരസ്ഥിതിയായി ഹോസ്റ്റുകൾ കണ്ടെത്തുന്നതിന് TCP മൾട്ടികാസ്റ്റിനെ ആശ്രയിച്ചിരിക്കുന്നു. ഒരു ബാഹ്യ ബാലൻസർ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം.

• infinispan: ഒരു ട്രാൻസ്പോർട്ട് ലെയറായി JGroups ചാനലുകൾ ഉപയോഗിക്കുന്ന ഒരു വിതരണം ചെയ്ത കാഷെ. കൂടാതെ, കാഷെ ഉള്ളടക്കങ്ങൾ സമന്വയിപ്പിക്കുന്നതിന് ഒരു ബാഹ്യ ഇൻഫിനിസ്പാൻ ക്ലസ്റ്ററുമായി ആശയവിനിമയം നടത്താൻ ഇതിന് HotRod പ്രോട്ടോക്കോൾ ഉപയോഗിക്കാം.

• jgroups: JGroups ചാനലുകളെ അടിസ്ഥാനമാക്കി ഉയർന്ന ലഭ്യമായ സേവനങ്ങൾക്ക് ഗ്രൂപ്പ് ആശയവിനിമയ പിന്തുണ നൽകുന്നു. പേരുനൽകിയ പൈപ്പുകൾ ഒരു ക്ലസ്റ്ററിലെ ആപ്ലിക്കേഷൻ സംഭവങ്ങളെ ഗ്രൂപ്പുകളായി ബന്ധിപ്പിക്കാൻ അനുവദിക്കുന്നു, അതുവഴി ആശയവിനിമയത്തിന് വിശ്വാസ്യത, ക്രമം, പരാജയങ്ങളോടുള്ള സംവേദനക്ഷമത തുടങ്ങിയ ഗുണങ്ങളുണ്ട്.

ബാലൻസർ ലോഡ് ചെയ്യുക

ഒരു കുബർനെറ്റസ് ക്ലസ്റ്ററിൽ ഒരു ഇൻഗ്രെസ്സ് കൺട്രോളറായി ഒരു ബാലൻസർ ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ, ഇനിപ്പറയുന്ന കാര്യങ്ങൾ മനസ്സിൽ സൂക്ഷിക്കേണ്ടത് പ്രധാനമാണ്:

എച്ച്ടിടിപി വഴി പ്രാമാണീകരണ സെർവറിലേക്ക് കണക്റ്റുചെയ്യുന്ന ക്ലയന്റിന്റെ റിമോട്ട് വിലാസം ക്ലയന്റ് കമ്പ്യൂട്ടറിന്റെ യഥാർത്ഥ ഐപി വിലാസമാണെന്ന് കീക്ലോക്ക് അനുമാനിക്കുന്നു. ബാലൻസറും പ്രവേശന ക്രമീകരണങ്ങളും HTTP തലക്കെട്ടുകൾ ശരിയായി സജ്ജീകരിക്കണം X-Forwarded-For и X-Forwarded-Proto, കൂടാതെ യഥാർത്ഥ ശീർഷകം സംരക്ഷിക്കുക HOST. പുതിയ പതിപ്പ് ingress-nginx (>0.22.0) സ്ഥിരസ്ഥിതിയായി ഇത് പ്രവർത്തനരഹിതമാക്കുന്നു

പതാക സജീവമാക്കുന്നു proxy-address-forwarding ഒരു പരിസ്ഥിതി വേരിയബിൾ സജ്ജീകരിക്കുന്നതിലൂടെ PROXY_ADDRESS_FORWARDING в true കീക്ലോക്ക് ഒരു പ്രോക്സിക്ക് പിന്നിൽ പ്രവർത്തിക്കുന്നുവെന്ന് മനസ്സിലാക്കുന്നു.

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

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

ആദ്യം പ്രതികരിച്ച നോഡിന്റെ പേരും കീക്ലോക്ക് അറ്റാച്ചുചെയ്യുന്നു AUTH_SESSION_ID, കൂടാതെ വളരെ ലഭ്യമായ പതിപ്പിലെ ഓരോ നോഡും ഒരേ ഡാറ്റാബേസ് ഉപയോഗിക്കുന്നതിനാൽ, അവ ഓരോന്നും ഉണ്ടായിരിക്കണം ഇടപാടുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു പ്രത്യേക നോഡ് ഐഡന്റിഫയർ. ഇടാൻ ശുപാർശ ചെയ്യുന്നു JAVA_OPTS പാരാമീറ്ററുകൾ jboss.node.name и jboss.tx.node.id ഓരോ നോഡിനും അദ്വിതീയമാണ് - ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് പോഡിന്റെ പേര് നൽകാം. നിങ്ങൾ ഒരു പോഡ് നാമം ഇടുകയാണെങ്കിൽ, jboss വേരിയബിളുകൾക്കുള്ള 23 പ്രതീക പരിധിയെക്കുറിച്ച് മറക്കരുത്, അതിനാൽ ഒരു വിന്യാസത്തിന് പകരം സ്റ്റേറ്റ്ഫുൾസെറ്റ് ഉപയോഗിക്കുന്നതാണ് നല്ലത്.

മറ്റൊരു റേക്ക് - പോഡ് ഇല്ലാതാക്കുകയോ പുനരാരംഭിക്കുകയോ ചെയ്താൽ, അതിന്റെ കാഷെ നഷ്ടപ്പെടും. ഇത് കണക്കിലെടുക്കുമ്പോൾ, എല്ലാ കാഷെകൾക്കും കാഷെ ഉടമകളുടെ എണ്ണം കുറഞ്ഞത് രണ്ടായി സജ്ജീകരിക്കുന്നത് മൂല്യവത്താണ്, അങ്ങനെ കാഷെയുടെ ഒരു പകർപ്പ് നിലനിൽക്കും. ഓടുക എന്നതാണ് പരിഹാരം വൈൽഡ്‌ഫ്ലൈയ്‌ക്കുള്ള സ്‌ക്രിപ്റ്റ് പോഡ് ആരംഭിക്കുമ്പോൾ, അത് ഡയറക്ടറിയിൽ സ്ഥാപിക്കുക /opt/jboss/startup-scripts കണ്ടെയ്നറിൽ:

സ്ക്രിപ്റ്റ് ഉള്ളടക്കം

embed-server --server-config=standalone-ha.xml --std-out=echo
batch

echo * Setting CACHE_OWNERS to "${env.CACHE_OWNERS}" in all cache-containers

/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=authenticationSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})

run-batch
stop-embedded-server

തുടർന്ന് പരിസ്ഥിതി വേരിയബിളിന്റെ മൂല്യം സജ്ജമാക്കുക CACHE_OWNERS ആവശ്യമുള്ളവയിലേക്ക്.

IP മൾട്ടികാസ്റ്റ് പിന്തുണയുള്ള സ്വകാര്യ നെറ്റ്‌വർക്ക്

നിങ്ങൾ ഒരു CNI ആയി Weavenet ഉപയോഗിക്കുകയാണെങ്കിൽ, മൾട്ടികാസ്റ്റ് ഉടനടി പ്രവർത്തിക്കും - നിങ്ങളുടെ കീക്ലോക്ക് നോഡുകൾ സമാരംഭിച്ച ഉടൻ തന്നെ അവ പരസ്പരം കാണും.

നിങ്ങളുടെ കുബർനെറ്റസ് ക്ലസ്റ്ററിൽ ip മൾട്ടികാസ്റ്റ് പിന്തുണ ഇല്ലെങ്കിൽ, നോഡുകൾ കണ്ടെത്തുന്നതിന് മറ്റ് പ്രോട്ടോക്കോളുകളുമായി പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് JGroups കോൺഫിഗർ ചെയ്യാം.

ആദ്യ ഓപ്ഷൻ ഉപയോഗിക്കുക എന്നതാണ് KUBE_DNSഏത് ഉപയോഗിക്കുന്നു headless service കീക്ലോക്ക് നോഡുകൾ കണ്ടെത്തുന്നതിന്, നോഡുകൾ കണ്ടെത്താൻ ഉപയോഗിക്കുന്ന സേവനത്തിന്റെ പേര് നിങ്ങൾ JGroup-ന് നൽകുക.

മറ്റൊരു ഓപ്ഷൻ രീതി ഉപയോഗിക്കുക എന്നതാണ് KUBE_PING, നോഡുകൾക്കായി തിരയാൻ API-യിൽ പ്രവർത്തിക്കുന്നു (നിങ്ങൾ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട് serviceAccount അവകാശങ്ങളുമായി list и get, തുടർന്ന് ഇതിനൊപ്പം പ്രവർത്തിക്കാൻ പോഡുകൾ കോൺഫിഗർ ചെയ്യുക serviceAccount).

എൻവയോൺമെന്റ് വേരിയബിളുകൾ സജ്ജീകരിച്ച് JGroups നോഡുകൾ കണ്ടെത്തുന്ന രീതി ക്രമീകരിച്ചിരിക്കുന്നു JGROUPS_DISCOVERY_PROTOCOL и JGROUPS_DISCOVERY_PROPERTIES. വേണ്ടി KUBE_PING ചോദിച്ച് നിങ്ങൾ പോഡുകൾ തിരഞ്ഞെടുക്കേണ്ടതുണ്ട് namespace и labels.

നിങ്ങൾ മൾട്ടികാസ്റ്റ് ഉപയോഗിക്കുകയും ഒരു കുബർനെറ്റസ് ക്ലസ്റ്ററിൽ രണ്ടോ അതിലധികമോ കീക്ലോക്ക് ക്ലസ്റ്ററുകൾ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നുവെങ്കിൽ (നമുക്ക് നെയിംസ്പേസിൽ ഒന്ന് പറയാം production, രണ്ടാമത് - staging) - ഒരു കീക്ലോക്ക് ക്ലസ്റ്ററിന്റെ നോഡുകൾക്ക് മറ്റൊരു ക്ലസ്റ്ററിൽ ചേരാനാകും. വേരിയബിളുകൾ സജ്ജീകരിക്കുന്നതിലൂടെ ഓരോ ക്ലസ്റ്ററിനും തനതായ മൾട്ടികാസ്റ്റ് വിലാസം ഉപയോഗിക്കുന്നത് ഉറപ്പാക്കുകjboss.default.multicast.address и jboss.modcluster.multicast.address в JAVA_OPTS.

ഡാറ്റാ സെന്ററുകൾ തമ്മിലുള്ള അനുകരണം

കണക്ഷൻ

കീക്ലോക്ക് നോഡുകളാൽ നിർമ്മിച്ച കീക്ലോക്ക് ക്ലസ്റ്ററുകൾ സ്ഥിതി ചെയ്യുന്ന ഓരോ ഡാറ്റാ സെന്ററിനും കീക്ലോക്ക് ഒന്നിലധികം പ്രത്യേക ഇൻഫിനിസ്പാൻ കാഷെ ക്ലസ്റ്ററുകൾ ഉപയോഗിക്കുന്നു. എന്നാൽ വ്യത്യസ്ത ഡാറ്റാ സെന്ററുകളിലെ കീക്ലോക്ക് നോഡുകൾ തമ്മിൽ വ്യത്യാസമില്ല.

ഡാറ്റാ സെന്ററുകൾ തമ്മിലുള്ള ആശയവിനിമയത്തിനായി കീക്ലോക്ക് നോഡുകൾ ഒരു ബാഹ്യ ജാവ ഡാറ്റ ഗ്രിഡ് (ഇൻഫിനിസ്പാൻ സെർവറുകൾ) ഉപയോഗിക്കുന്നു. പ്രോട്ടോക്കോൾ അനുസരിച്ച് ആശയവിനിമയം പ്രവർത്തിക്കുന്നു ഇൻഫിനിസ്പാൻ ഹോട്ട്റോഡ്.

Infinispan കാഷെകൾ ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് കോൺഫിഗർ ചെയ്യണം remoteStore, അതുവഴി ഡാറ്റ വിദൂരമായി സംഭരിക്കാൻ കഴിയും (മറ്റൊരു ഡാറ്റാ സെന്ററിൽ, ഏകദേശം. വിവർത്തകൻ) കാഷെകൾ. JDG സെർവറുകൾക്കിടയിൽ പ്രത്യേക ഇൻഫിനിസ്പാൻ ക്ലസ്റ്ററുകൾ ഉണ്ട്, അതിനാൽ സൈറ്റിലെ JDG1-ൽ ഡാറ്റ സംഭരിച്ചിരിക്കുന്നു. site1 സൈറ്റിലെ JDG2 ലേക്ക് പകർത്തും site2.

അവസാനമായി, സ്വീകരിക്കുന്ന ജെഡിജി സെർവർ ക്ലയന്റ് കണക്ഷനുകൾ വഴി അതിന്റെ ക്ലസ്റ്ററിന്റെ കീക്ലോക്ക് സെർവറുകളെ അറിയിക്കുന്നു, ഇത് HotRod പ്രോട്ടോക്കോളിന്റെ സവിശേഷതയാണ്. കീക്ലോക്ക് നോഡുകൾ ഓണാണ് site2 അവരുടെ Infinispan കാഷെകൾ അപ്ഡേറ്റ് ചെയ്യുക, കൂടാതെ നിർദ്ദിഷ്ട ഉപയോക്തൃ സെഷൻ കീക്ലോക്ക് നോഡുകളിലും ലഭ്യമാകും site2.

ചില കാഷെകൾക്കായി, ബാക്കപ്പുകൾ ഉണ്ടാക്കാതിരിക്കാനും ഇൻഫിനിസ്പാൻ സെർവറിലൂടെ ഡാറ്റ എഴുതുന്നത് ഒഴിവാക്കാനും സാധിക്കും. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ക്രമീകരണം നീക്കംചെയ്യേണ്ടതുണ്ട് remote-store നിർദ്ദിഷ്ട ഇൻഫിനിസ്പാൻ കാഷെ (ഫയലിൽ ഒറ്റത്തവണ-ha.xml), അതിനുശേഷം ചില പ്രത്യേകം replicated-cache ഇൻഫിനിസ്പാൻ സെർവർ ഭാഗത്തും ഇനി ആവശ്യമില്ല.

കാഷെകൾ സജ്ജീകരിക്കുന്നു

കീക്ലോക്കിൽ രണ്ട് തരം കാഷെകളുണ്ട്:

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

• പകർത്തിയത്. ഉപയോക്തൃ സെഷനുകൾ, ഓഫ്‌ലൈൻ ടോക്കണുകൾ എന്നിവ പ്രോസസ്സ് ചെയ്യുന്നു, കൂടാതെ പാസ്‌വേഡ് ഫിഷിംഗ് ശ്രമങ്ങളും മറ്റ് ആക്രമണങ്ങളും കണ്ടെത്തുന്നതിന് ലോഗിൻ പിശകുകളും നിരീക്ഷിക്കുന്നു. ഈ കാഷെകളിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റ താൽക്കാലികമാണ്, റാമിൽ മാത്രം സംഭരിച്ചിരിക്കുന്നു, എന്നാൽ ക്ലസ്റ്ററിലുടനീളം പകർത്താനാകും.

ഇൻഫിനിസ്പാൻ കാഷെകൾ

സെഷനുകൾ - കീക്ലോക്കിലെ ഒരു ആശയം, പ്രത്യേക കാഷെകൾ എന്ന് വിളിക്കുന്നു authenticationSessions, നിർദ്ദിഷ്ട ഉപയോക്താക്കളുടെ ഡാറ്റ സംഭരിക്കുന്നതിന് ഉപയോഗിക്കുന്നു. ഈ കാഷെകളിൽ നിന്നുള്ള അഭ്യർത്ഥനകൾ സാധാരണയായി ബ്രൗസറിനും കീക്ലോക്ക് സെർവറുകൾക്കും ആവശ്യമാണ്, ആപ്ലിക്കേഷനുകൾക്കല്ല. ഇവിടെയാണ് സ്റ്റിക്കി സെഷനുകളെ ആശ്രയിക്കുന്നത്, ആക്റ്റീവ്-ആക്ടീവ് മോഡിന്റെ കാര്യത്തിൽ പോലും അത്തരം കാഷെകൾ തന്നെ ആവർത്തിക്കേണ്ടതില്ല.

ആക്ഷൻ ടോക്കണുകൾ. മറ്റൊരു ആശയം, സാധാരണയായി വിവിധ സാഹചര്യങ്ങൾക്കായി ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന്, ഉപയോക്താവ് മെയിൽ വഴി അസമന്വിതമായി എന്തെങ്കിലും ചെയ്യണം. ഉദാഹരണത്തിന്, നടപടിക്രമത്തിനിടയിൽ forget password കാഷെ actionTokens ബന്ധപ്പെട്ട ടോക്കണുകളുടെ മെറ്റാഡാറ്റ ട്രാക്ക് ചെയ്യാൻ ഉപയോഗിക്കുന്നു - ഉദാഹരണത്തിന്, ഒരു ടോക്കൺ ഇതിനകം ഉപയോഗിച്ചു, അത് വീണ്ടും സജീവമാക്കാൻ കഴിയില്ല. ഇത്തരത്തിലുള്ള കാഷെ സാധാരണയായി ഡാറ്റാ സെന്ററുകൾക്കിടയിൽ ആവർത്തിക്കേണ്ടതുണ്ട്.

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

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

ഉപയോക്തൃ സെഷനുകൾ. പേരുകളുള്ള കാഷെകൾ sessions, clientSessions, offlineSessions и offlineClientSessions, സാധാരണയായി ഡാറ്റാ സെന്ററുകൾക്കിടയിൽ ആവർത്തിക്കുകയും ഉപയോക്താവ് ബ്രൗസറിൽ സജീവമായിരിക്കുമ്പോൾ സജീവമായ ഉപയോക്തൃ സെഷനുകളെക്കുറിച്ചുള്ള ഡാറ്റ സംഭരിക്കുന്നതിന് സേവിക്കുകയും ചെയ്യുന്നു. അന്തിമ ഉപയോക്താക്കളിൽ നിന്നുള്ള എച്ച്ടിടിപി അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്ന ആപ്ലിക്കേഷൻ ഉപയോഗിച്ച് ഈ കാഷെകൾ പ്രവർത്തിക്കുന്നു, അതിനാൽ അവ സ്റ്റിക്കി സെഷനുകളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു കൂടാതെ ഡാറ്റാ സെന്ററുകൾക്കിടയിൽ ആവർത്തിക്കുകയും വേണം.

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

ഒരു ഇൻഫിനിസ്പാൻ ക്ലസ്റ്റർ പുറത്തിറക്കുമ്പോൾ, നിങ്ങൾ ക്രമീകരണ ഫയലിലേക്ക് കാഷെ നിർവചനങ്ങൾ ചേർക്കേണ്ടതുണ്ട്:

<replicated-cache-configuration name="keycloak-sessions" mode="ASYNC" start="EAGER" batching="false">
</replicated-cache-configuration>

<replicated-cache name="work" configuration="keycloak-sessions" />
<replicated-cache name="sessions" configuration="keycloak-sessions" />
<replicated-cache name="offlineSessions" configuration="keycloak-sessions" />
<replicated-cache name="actionTokens" configuration="keycloak-sessions" />
<replicated-cache name="loginFailures" configuration="keycloak-sessions" />
<replicated-cache name="clientSessions" configuration="keycloak-sessions" />
<replicated-cache name="offlineClientSessions" configuration="keycloak-sessions" />

കീക്ലോക്ക് ക്ലസ്റ്റർ ആരംഭിക്കുന്നതിന് മുമ്പ് നിങ്ങൾ ഇൻഫിനിസ്പാൻ ക്ലസ്റ്റർ കോൺഫിഗർ ചെയ്യുകയും ആരംഭിക്കുകയും വേണം

അപ്പോൾ നിങ്ങൾ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട് remoteStore കീക്ലോക്ക് കാഷെകൾക്കായി. ഇത് ചെയ്യുന്നതിന്, ഒരു സ്ക്രിപ്റ്റ് മതി, വേരിയബിൾ സജ്ജമാക്കാൻ ഉപയോഗിക്കുന്ന മുമ്പത്തേതിന് സമാനമായി ഇത് ചെയ്യുന്നു CACHE_OWNERS, നിങ്ങൾ അത് ഒരു ഫയലിൽ സേവ് ചെയ്ത് ഒരു ഡയറക്ടറിയിൽ ഇടേണ്ടതുണ്ട് /opt/jboss/startup-scripts:

സ്ക്രിപ്റ്റ് ഉള്ളടക്കം

embed-server --server-config=standalone-ha.xml --std-out=echo
batch

echo *** Update infinispan subsystem ***
/subsystem=infinispan/cache-container=keycloak:write-attribute(name=module, value=org.keycloak.keycloak-model-infinispan)

echo ** Add remote socket binding to infinispan server **
/socket-binding-group=standard-sockets/remote-destination-outbound-socket-binding=remote-cache:add(host=${remote.cache.host:localhost}, port=${remote.cache.port:11222})

echo ** Update replicated-cache work element **
/subsystem=infinispan/cache-container=keycloak/replicated-cache=work/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=work, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)

/subsystem=infinispan/cache-container=keycloak/replicated-cache=work:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache sessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=sessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache offlineSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=offlineSessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache clientSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=clientSessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache offlineClientSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=offlineClientSessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache loginFailures element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=loginFailures, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache actionTokens element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    cache=actionTokens, 
    remote-servers=["remote-cache"], 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache authenticationSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=authenticationSessions:write-attribute(name=statistics-enabled,value=true)

echo *** Update undertow subsystem ***
/subsystem=undertow/server=default-server/http-listener=default:write-attribute(name=proxy-address-forwarding,value=true)

run-batch
stop-embedded-server

ഇൻസ്റ്റാൾ ചെയ്യാൻ മറക്കരുത് JAVA_OPTS HotRod പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള കീക്ലോക്ക് നോഡുകൾക്കായി: remote.cache.host, remote.cache.port സേവനത്തിന്റെ പേരും jboss.site.name.

ലിങ്കുകളും അധിക ഡോക്യുമെന്റേഷനും

• https://www.keycloak.org/docs/latest/server_installation/index.html
• https://docs.wildfly.org/17/High_Availability_Guide.html#cluster-configuration
• https://infinispan.org/docs/9.4.x/user_guide/user_guide.html
• https://hub.docker.com/r/jboss/keycloak
• https://hub.docker.com/r/jboss/infinispan

ലേഖനം വിവർത്തനം ചെയ്ത് ഹബ്റിന് വേണ്ടി തയ്യാറാക്കിയത് ജീവനക്കാരാണ് ചേരി പരിശീലന കേന്ദ്രം - പ്രാക്ടീസ് ചെയ്യുന്ന സ്പെഷ്യലിസ്റ്റുകളിൽ നിന്നുള്ള തീവ്രമായ കോഴ്‌സുകൾ, വീഡിയോ കോഴ്‌സുകൾ, കോർപ്പറേറ്റ് പരിശീലനം (കുബർനെറ്റസ്, ഡെവോപ്‌സ്, ഡോക്കർ, അൻസിബിൾ, സെഫ്, എസ്ആർഇ)

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