പോകണോ? ബാഷ്! ഷെൽ-ഓപ്പറേറ്ററെ കണ്ടുമുട്ടുക (KubeCon EU'2020-ൽ നിന്നുള്ള അവലോകനവും വീഡിയോ റിപ്പോർട്ടും)

ഈ വർഷത്തെ പ്രധാന യൂറോപ്യൻ കുബർനെറ്റസ് കോൺഫറൻസ് - KubeCon + CloudNativeCon Europe 2020 - വെർച്വൽ ആയിരുന്നു. എന്നിരുന്നാലും, ഫോർമാറ്റിലെ അത്തരമൊരു മാറ്റം ഞങ്ങളുടെ ദീർഘകാലമായി ആസൂത്രണം ചെയ്ത റിപ്പോർട്ട് നൽകുന്നതിൽ നിന്ന് ഞങ്ങളെ തടഞ്ഞില്ല “പോകണോ? ബാഷ്! ഞങ്ങളുടെ ഓപ്പൺ സോഴ്‌സ് പ്രോജക്റ്റിനായി സമർപ്പിക്കപ്പെട്ട ഷെൽ ഓപ്പറേറ്ററെ കണ്ടുമുട്ടുക ഷെൽ ഓപ്പറേറ്റർ.

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

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

ഫ്ലാന്റിൽ ഞങ്ങൾ എല്ലാം നിരന്തരം ഒപ്റ്റിമൈസ് ചെയ്യുകയും ഓട്ടോമേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു. ഇന്ന് നമ്മൾ മറ്റൊരു ആവേശകരമായ ആശയത്തെക്കുറിച്ച് സംസാരിക്കും. കണ്ടുമുട്ടുക: ക്ലൗഡ്-നേറ്റീവ് ഷെൽ സ്ക്രിപ്റ്റിംഗ്!

എന്നിരുന്നാലും, ഇതെല്ലാം സംഭവിക്കുന്ന സന്ദർഭത്തിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം: കുബർനെറ്റസ്.

Kubernetes API, കൺട്രോളറുകൾ

ഓരോ തരം ഒബ്‌ജക്‌റ്റിനും ഡയറക്‌ടറികളുള്ള ഒരു തരം ഫയൽ സെർവറായി കുബർനെറ്റസിലെ API പ്രതിനിധീകരിക്കാം. ഈ സെർവറിലെ ഒബ്ജക്റ്റുകളെ (വിഭവങ്ങൾ) പ്രതിനിധീകരിക്കുന്നത് YAML ഫയലുകളാണ്. കൂടാതെ, സെർവറിന് മൂന്ന് കാര്യങ്ങൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു അടിസ്ഥാന API ഉണ്ട്:

• സ്വീകരിക്കാൻ വിഭവം അതിന്റെ തരത്തിലും പേരിലും;
• മാറ്റം റിസോഴ്സ് (ഈ സാഹചര്യത്തിൽ, സെർവർ "ശരിയായ" ഒബ്‌ജക്റ്റുകൾ മാത്രമേ സംഭരിക്കുന്നുള്ളൂ - എല്ലാം തെറ്റായി രൂപപ്പെടുത്തിയവ അല്ലെങ്കിൽ മറ്റ് ഡയറക്‌ടറികൾക്കായി ഉദ്ദേശിച്ചവ നിരസിച്ചു);
• ട്രാക്ക് റിസോഴ്സിനായി (ഈ സാഹചര്യത്തിൽ, ഉപയോക്താവിന് അതിന്റെ നിലവിലെ/അപ്ഡേറ്റ് ചെയ്ത പതിപ്പ് ഉടനടി ലഭിക്കും).

അതിനാൽ, മൂന്ന് അടിസ്ഥാന രീതികൾ (അതെ, യഥാർത്ഥത്തിൽ മറ്റുള്ളവയുണ്ട്, പക്ഷേ ഞങ്ങൾ ഇപ്പോൾ അവ ഒഴിവാക്കും) ഒരു തരം ഫയൽ സെർവറായി (YAML മാനിഫെസ്റ്റുകൾക്ക്) കുബർനെറ്റസ് പ്രവർത്തിക്കുന്നു.

സെർവറിന് വിവരങ്ങൾ സംഭരിക്കാൻ മാത്രമേ കഴിയൂ എന്നതാണ് പ്രശ്നം. ഇത് പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് ആവശ്യമാണ് കണ്ട്രോളർ - കുബർനെറ്റസിന്റെ ലോകത്തിലെ രണ്ടാമത്തെ ഏറ്റവും പ്രധാനപ്പെട്ടതും അടിസ്ഥാനപരവുമായ ആശയം.

രണ്ട് പ്രധാന തരം കൺട്രോളറുകൾ ഉണ്ട്. ആദ്യത്തേത് കുബെർനെറ്റസിൽ നിന്ന് വിവരങ്ങൾ എടുക്കുകയും നെസ്റ്റഡ് ലോജിക്ക് അനുസരിച്ച് പ്രോസസ്സ് ചെയ്യുകയും K8- ലേക്ക് തിരികെ നൽകുകയും ചെയ്യുന്നു. രണ്ടാമത്തേത് കുബർനെറ്റസിൽ നിന്ന് വിവരങ്ങൾ എടുക്കുന്നു, പക്ഷേ, ആദ്യ തരത്തിൽ നിന്ന് വ്യത്യസ്തമായി, ചില ബാഹ്യ വിഭവങ്ങളുടെ അവസ്ഥ മാറ്റുന്നു.

Kubernetes-ൽ ഒരു വിന്യാസം സൃഷ്ടിക്കുന്ന പ്രക്രിയയെക്കുറിച്ച് നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം:

• വിന്യാസ കൺട്രോളർ (ഉൾപ്പെടുത്തിയിരിക്കുന്നു kube-controller-manager) വിന്യാസത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ സ്വീകരിക്കുകയും ഒരു റെപ്ലിക്കസെറ്റ് സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.
• ഈ വിവരങ്ങളെ അടിസ്ഥാനമാക്കി ReplicaSet രണ്ട് പകർപ്പുകൾ (രണ്ട് പോഡുകൾ) സൃഷ്ടിക്കുന്നു, എന്നാൽ ഈ പോഡുകൾ ഇതുവരെ ഷെഡ്യൂൾ ചെയ്തിട്ടില്ല.
• ഷെഡ്യൂളർ പോഡുകൾ ഷെഡ്യൂൾ ചെയ്യുകയും അവരുടെ YAML-കളിലേക്ക് നോഡ് വിവരങ്ങൾ ചേർക്കുകയും ചെയ്യുന്നു.
• കുബെലെറ്റുകൾ ഒരു ബാഹ്യ ഉറവിടത്തിൽ മാറ്റങ്ങൾ വരുത്തുന്നു (ഡോക്കർ എന്ന് പറയുക).

തുടർന്ന് ഈ മുഴുവൻ ക്രമവും വിപരീത ക്രമത്തിൽ ആവർത്തിക്കുന്നു: കുബെലെറ്റ് കണ്ടെയ്നറുകൾ പരിശോധിക്കുകയും പോഡിന്റെ നില കണക്കാക്കുകയും തിരികെ അയയ്ക്കുകയും ചെയ്യുന്നു. ReplicaSet കൺട്രോളർ സ്റ്റാറ്റസ് സ്വീകരിക്കുകയും റെപ്ലിക്ക സെറ്റിന്റെ അവസ്ഥ അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു. ഡിപ്ലോയ്‌മെന്റ് കൺട്രോളറിലും ഇതുതന്നെ സംഭവിക്കുന്നു, ഉപയോക്താവിന് ഒടുവിൽ അപ്‌ഡേറ്റ് ചെയ്ത (നിലവിലെ) നില ലഭിക്കും.

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

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

ലളിതമായ ഉദാഹരണം: രഹസ്യങ്ങൾ പകർത്തൽ

ഒരു ലളിതമായ ഉദാഹരണം നോക്കാം.

നമുക്ക് ഒരു കുബർനെറ്റസ് ക്ലസ്റ്റർ ഉണ്ടെന്ന് പറയാം. അതിന് ഒരു നെയിംസ്പേസ് ഉണ്ട് default ചില രഹസ്യങ്ങളോടൊപ്പം mysecret. കൂടാതെ, ക്ലസ്റ്ററിൽ മറ്റ് നെയിംസ്പേസുകളും ഉണ്ട്. അവയിൽ ചിലതിൽ ഒരു പ്രത്യേക ലേബൽ ഘടിപ്പിച്ചിരിക്കുന്നു. ഒരു ലേബൽ ഉപയോഗിച്ച് നെയിംസ്പേസുകളിലേക്ക് രഹസ്യം പകർത്തുക എന്നതാണ് ഞങ്ങളുടെ ലക്ഷ്യം.

ക്ലസ്റ്ററിൽ പുതിയ നെയിംസ്‌പെയ്‌സുകൾ ദൃശ്യമാകാമെന്നതും അവയിൽ ചിലത് ഈ ലേബൽ ഉള്ളതിനാലും ചുമതല സങ്കീർണ്ണമാണ്. മറുവശത്ത്, ലേബൽ ഇല്ലാതാക്കുമ്പോൾ, രഹസ്യവും ഇല്ലാതാക്കണം. ഇതുകൂടാതെ, രഹസ്യം തന്നെ മാറ്റാനും കഴിയും: ഈ സാഹചര്യത്തിൽ, പുതിയ രഹസ്യം ലേബലുകളുള്ള എല്ലാ നെയിംസ്പേസുകളിലേക്കും പകർത്തിയിരിക്കണം. ഏതെങ്കിലും നെയിംസ്‌പെയ്‌സിൽ അബദ്ധവശാൽ രഹസ്യം ഇല്ലാതാക്കിയാൽ, ഞങ്ങളുടെ ഓപ്പറേറ്റർ അത് ഉടനടി പുനഃസ്ഥാപിക്കേണ്ടതാണ്.

ഇപ്പോൾ ടാസ്‌ക് രൂപീകരിച്ചു, ഷെൽ-ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഇത് നടപ്പിലാക്കാൻ ആരംഭിക്കേണ്ട സമയമാണിത്. എന്നാൽ ആദ്യം ഷെൽ-ഓപ്പറേറ്ററിനെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ പറയേണ്ടതാണ്.

ഷെൽ ഓപ്പറേറ്റർ എങ്ങനെ പ്രവർത്തിക്കുന്നു

കുബർനെറ്റസിലെ മറ്റ് ജോലിഭാരങ്ങൾ പോലെ, ഷെൽ-ഓപ്പറേറ്റർ സ്വന്തം പോഡിൽ പ്രവർത്തിക്കുന്നു. ഡയറക്ടറിയിലെ ഈ പോഡിൽ /hooks എക്സിക്യൂട്ടബിൾ ഫയലുകൾ സംഭരിച്ചിരിക്കുന്നു. ഇവ ബാഷ്, പൈത്തൺ, റൂബി മുതലായവയിലെ സ്ക്രിപ്റ്റുകളാകാം. അത്തരം എക്സിക്യൂട്ടബിൾ ഫയലുകളെ ഞങ്ങൾ ഹുക്കുകൾ എന്ന് വിളിക്കുന്നു (കൊളുത്തും).

ഷെൽ-ഓപ്പറേറ്റർ കുബർനെറ്റസ് ഇവന്റുകൾ സബ്‌സ്‌ക്രൈബുചെയ്യുകയും ഞങ്ങൾക്ക് ആവശ്യമുള്ള ഇവന്റുകളോട് പ്രതികരിക്കുകയും ഈ ഹുക്കുകൾ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു.

ഏത് ഹുക്ക് എപ്പോൾ പ്രവർത്തിപ്പിക്കണമെന്ന് ഷെൽ ഓപ്പറേറ്റർക്ക് എങ്ങനെ അറിയാം? ഓരോ ഹുക്കിനും രണ്ട് ഘട്ടങ്ങളുണ്ട് എന്നതാണ് കാര്യം. സ്റ്റാർട്ടപ്പ് സമയത്ത്, ഷെൽ-ഓപ്പറേറ്റർ ഒരു ആർഗ്യുമെന്റുമായി എല്ലാ ഹുക്കുകളും പ്രവർത്തിപ്പിക്കുന്നു --config ഇതാണ് കോൺഫിഗറേഷൻ ഘട്ടം. അതിനുശേഷം, കൊളുത്തുകൾ സാധാരണ രീതിയിൽ സമാരംഭിക്കുന്നു - അവ ഘടിപ്പിച്ചിരിക്കുന്ന ഇവന്റുകളോടുള്ള പ്രതികരണമായി. പിന്നീടുള്ള സന്ദർഭത്തിൽ, ഹുക്ക് ബൈൻഡിംഗ് സന്ദർഭം സ്വീകരിക്കുന്നു (ബൈൻഡിംഗ് സന്ദർഭം) - JSON ഫോർമാറ്റിലുള്ള ഡാറ്റ, ഞങ്ങൾ താഴെ കൂടുതൽ വിശദമായി സംസാരിക്കും.

ബാഷിൽ ഒരു ഓപ്പറേറ്റർ ഉണ്ടാക്കുന്നു

ഇപ്പോൾ ഞങ്ങൾ നടപ്പിലാക്കാൻ തയ്യാറാണ്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ രണ്ട് ഫംഗ്ഷനുകൾ എഴുതേണ്ടതുണ്ട് (വഴി, ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു പുസ്തകശാല ഷെൽ_ലിബ്, ഇത് ബാഷിൽ ഹുക്കുകൾ എഴുതുന്നത് വളരെ ലളിതമാക്കുന്നു):

• ആദ്യത്തേത് കോൺഫിഗറേഷൻ ഘട്ടത്തിന് ആവശ്യമാണ് - ഇത് ബൈൻഡിംഗ് സന്ദർഭം പ്രദർശിപ്പിക്കുന്നു;
• രണ്ടാമത്തേതിൽ ഹുക്കിന്റെ പ്രധാന യുക്തി അടങ്ങിയിരിക്കുന്നു.

#!/bin/bash

source /shell_lib.sh

function __config__() {
  cat << EOF
    configVersion: v1
    # BINDING CONFIGURATION
EOF
}

function __main__() {
  # THE LOGIC
}

hook::run "$@"

നമുക്ക് എന്ത് വസ്തുക്കൾ വേണമെന്ന് തീരുമാനിക്കുക എന്നതാണ് അടുത്ത ഘട്ടം. ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങൾ ട്രാക്ക് ചെയ്യേണ്ടതുണ്ട്:

• മാറ്റങ്ങളുടെ ഉറവിട രഹസ്യം;
• ക്ലസ്റ്ററിലെ എല്ലാ നെയിംസ്‌പെയ്‌സുകളും, അതിലൂടെ ഏതൊക്കെ ലേബൽ ഘടിപ്പിച്ചിട്ടുണ്ടെന്ന് നിങ്ങൾക്കറിയാം;
• അവയെല്ലാം ഉറവിട രഹസ്യവുമായി സമന്വയിപ്പിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കാൻ ടാർഗെറ്റ് രഹസ്യങ്ങൾ.

രഹസ്യ ഉറവിടത്തിലേക്ക് സബ്‌സ്‌ക്രൈബ് ചെയ്യുക

അതിനുള്ള ബൈൻഡിംഗ് കോൺഫിഗറേഷൻ വളരെ ലളിതമാണ്. പേരിനൊപ്പം രഹസ്യത്തിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെന്ന് ഞങ്ങൾ സൂചിപ്പിക്കുന്നു mysecret നെയിംസ്പേസിൽ default:

function __config__() {
  cat << EOF
    configVersion: v1
    kubernetes:
    - name: src_secret
      apiVersion: v1
      kind: Secret
      nameSelector:
        matchNames:
        - mysecret
      namespace:
        nameSelector:
          matchNames: ["default"]
      group: main
EOF

തൽഫലമായി, ഉറവിട രഹസ്യം മാറുമ്പോൾ ഹുക്ക് പ്രവർത്തനക്ഷമമാകും (src_secret) കൂടാതെ ഇനിപ്പറയുന്ന ബൈൻഡിംഗ് സന്ദർഭം സ്വീകരിക്കുക:

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, അതിൽ പേരും മുഴുവൻ വസ്തുവും അടങ്ങിയിരിക്കുന്നു.

നെയിംസ്പേസുകളുടെ ട്രാക്ക് സൂക്ഷിക്കുന്നു

ഇപ്പോൾ നിങ്ങൾ നെയിംസ്പേസുകൾ സബ്സ്ക്രൈബ് ചെയ്യേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഇനിപ്പറയുന്ന ബൈൻഡിംഗ് കോൺഫിഗറേഷൻ വ്യക്തമാക്കുന്നു:

- name: namespaces
  group: main
  apiVersion: v1
  kind: Namespace
  jqFilter: |
    {
      namespace: .metadata.name,
      hasLabel: (
       .metadata.labels // {} |  
         contains({"secret": "yes"})
      )
    }
  group: main
  keepFullObjectsInMemory: false

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

അതിൽ ഒരു അറേ അടങ്ങിയിരിക്കുന്നു filterResults ക്ലസ്റ്ററിലെ ഓരോ നെയിംസ്പേസിനും. ബൂളിയൻ വേരിയബിൾ hasLabel തന്നിരിക്കുന്ന നെയിംസ്‌പെയ്‌സിൽ ഒരു ലേബൽ ഘടിപ്പിച്ചിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്നു. സെലക്ടർ keepFullObjectsInMemory: false പൂർണ്ണമായ വസ്തുക്കളെ മെമ്മറിയിൽ സൂക്ഷിക്കേണ്ട ആവശ്യമില്ലെന്ന് സൂചിപ്പിക്കുന്നു.

ലക്ഷ്യ രഹസ്യങ്ങൾ ട്രാക്കുചെയ്യുന്നു

വ്യാഖ്യാനം വ്യക്തമാക്കിയിട്ടുള്ള എല്ലാ രഹസ്യങ്ങളിലേക്കും ഞങ്ങൾ സബ്‌സ്‌ക്രൈബുചെയ്യുന്നു managed-secret: "yes" (ഇവരാണ് ഞങ്ങളുടെ ലക്ഷ്യം dst_secrets):

- name: dst_secrets
  apiVersion: v1
  kind: Secret
  labelSelector:
    matchLabels:
      managed-secret: "yes"
  jqFilter: |
    {
      "namespace":
        .metadata.namespace,
      "resourceVersion":
        .metadata.annotations.resourceVersion
    }
  group: main
  keepFullObjectsInMemory: false

ഈ സാഹചര്യത്തിൽ jqFilter നെയിംസ്‌പെയ്‌സും പാരാമീറ്ററും ഒഴികെയുള്ള എല്ലാ വിവരങ്ങളും ഫിൽട്ടർ ചെയ്യുന്നു resourceVersion. രഹസ്യം സൃഷ്ടിക്കുമ്പോൾ അവസാന പാരാമീറ്റർ വ്യാഖ്യാനത്തിലേക്ക് കടന്നു: രഹസ്യങ്ങളുടെ പതിപ്പുകൾ താരതമ്യം ചെയ്യാനും അവ കാലികമായി നിലനിർത്താനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

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

ഈ വിവരങ്ങളെല്ലാം അടിസ്ഥാനമാക്കി, ഒരു അടിസ്ഥാന അൽഗോരിതം വികസിപ്പിക്കാൻ കഴിയും. ഇത് എല്ലാ നെയിംസ്‌പെയ്‌സുകളിലും ആവർത്തിക്കുന്നു:

• എങ്കിൽ hasLabel കാര്യങ്ങൾ true നിലവിലെ നെയിംസ്പേസിനായി:
  • ആഗോള രഹസ്യം പ്രാദേശിക രഹസ്യവുമായി താരതമ്യം ചെയ്യുന്നു:
    • അവ ഒന്നുതന്നെയാണെങ്കിൽ, ഒന്നും ചെയ്യുന്നില്ല;
    • അവ വ്യത്യാസപ്പെട്ടാൽ - നിർവ്വഹിക്കുന്നു kubectl replace അഥവാ create;
• എങ്കിൽ hasLabel കാര്യങ്ങൾ false നിലവിലെ നെയിംസ്പേസിനായി:
  • നൽകിയിരിക്കുന്ന നെയിംസ്‌പെയ്‌സിൽ രഹസ്യം ഇല്ലെന്ന് ഉറപ്പാക്കുന്നു:
    • പ്രാദേശിക രഹസ്യം ഉണ്ടെങ്കിൽ, അത് ഉപയോഗിച്ച് ഇല്ലാതാക്കുക kubectl delete;
    • പ്രാദേശിക രഹസ്യം കണ്ടെത്തിയില്ലെങ്കിൽ, അത് ഒന്നും ചെയ്യുന്നില്ല.

ബാഷിൽ അൽഗോരിതം നടപ്പിലാക്കൽ നിങ്ങൾക്ക് ഞങ്ങളുടെ ഡൗൺലോഡ് ചെയ്യാം ഉദാഹരണങ്ങളുള്ള ശേഖരങ്ങൾ.

YAML കോൺഫിഗറിൻറെ 35 വരികളും അതേ അളവിലുള്ള ബാഷ് കോഡും ഉപയോഗിച്ച് ഒരു ലളിതമായ കുബർനെറ്റസ് കൺട്രോളർ സൃഷ്ടിക്കാൻ ഞങ്ങൾക്ക് കഴിഞ്ഞത് അങ്ങനെയാണ്! ഷെൽ-ഓപ്പറേറ്ററുടെ ജോലി അവയെ പരസ്പരം ബന്ധിപ്പിക്കുക എന്നതാണ്.

എന്നിരുന്നാലും, രഹസ്യങ്ങൾ പകർത്തുന്നത് യൂട്ടിലിറ്റിയുടെ പ്രയോഗത്തിന്റെ ഒരേയൊരു മേഖലയല്ല. അവന്റെ കഴിവ് എന്താണെന്ന് കാണിക്കാൻ കുറച്ച് ഉദാഹരണങ്ങൾ കൂടി ഇതാ.

ഉദാഹരണം 1: കോൺഫിഗ്മാപ്പിൽ മാറ്റങ്ങൾ വരുത്തുന്നു

മൂന്ന് പോഡുകൾ അടങ്ങുന്ന ഒരു വിന്യാസം നോക്കാം. ചില കോൺഫിഗറേഷൻ സംഭരിക്കാൻ പോഡുകൾ കോൺഫിഗറേഷൻ മാപ്പ് ഉപയോഗിക്കുന്നു. പോഡുകൾ സമാരംഭിച്ചപ്പോൾ, കോൺഫിഗ്മാപ്പ് ഒരു നിശ്ചിത നിലയിലായിരുന്നു (നമുക്ക് അതിനെ v.1 എന്ന് വിളിക്കാം). അതനുസരിച്ച്, എല്ലാ പോഡുകളും കോൺഫിഗ്മാപ്പിന്റെ ഈ പ്രത്യേക പതിപ്പ് ഉപയോഗിക്കുന്നു.

ഇപ്പോൾ കോൺഫിഗ്മാപ്പ് മാറിയെന്ന് നമുക്ക് അനുമാനിക്കാം (v.2). എന്നിരുന്നാലും, പോഡുകൾ കോൺഫിഗ്മാപ്പിന്റെ മുൻ പതിപ്പ് ഉപയോഗിക്കും (v.1):

പുതിയ കോൺഫിഗറേഷൻ മാപ്പിലേക്ക് (v.2) മാറാൻ എനിക്ക് അവരെ എങ്ങനെ ലഭിക്കും? ഉത്തരം ലളിതമാണ്: ഒരു ടെംപ്ലേറ്റ് ഉപയോഗിക്കുക. വിഭാഗത്തിലേക്ക് ഒരു ചെക്ക്സം വ്യാഖ്യാനം ചേർക്കാം template വിന്യാസ കോൺഫിഗറേഷനുകൾ:

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

ഉപയോക്താവ് കോൺഫിഗ്മാപ്പിൽ മാറ്റങ്ങൾ വരുത്തുകയാണെങ്കിൽ, ഷെൽ-ഓപ്പറേറ്റർ അത് ശ്രദ്ധിക്കുകയും ചെക്ക്സം വീണ്ടും കണക്കാക്കുകയും ചെയ്യും. അതിനുശേഷം കുബെർനെറ്റസിന്റെ മാന്ത്രികത പ്രവർത്തിക്കും: ഓർക്കസ്ട്രേറ്റർ പോഡിനെ കൊല്ലും, പുതിയൊരെണ്ണം സൃഷ്ടിക്കും, അത് ആകുന്നതുവരെ കാത്തിരിക്കുക Ready, അടുത്തതിലേക്ക് നീങ്ങുന്നു. തൽഫലമായി, വിന്യാസം സമന്വയിപ്പിക്കുകയും കോൺഫിഗ്മാപ്പിന്റെ പുതിയ പതിപ്പിലേക്ക് മാറുകയും ചെയ്യും.

ഉദാഹരണം 2: കസ്റ്റം റിസോഴ്സ് നിർവചനങ്ങൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

നിങ്ങൾക്കറിയാവുന്നതുപോലെ, ഇഷ്‌ടാനുസൃത തരം ഒബ്‌ജക്റ്റുകൾ സൃഷ്‌ടിക്കാൻ Kubernetes നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് തരം സൃഷ്ടിക്കാൻ കഴിയും MysqlDatabase. ഈ തരത്തിന് രണ്ട് മെറ്റാഡാറ്റ പാരാമീറ്ററുകൾ ഉണ്ടെന്ന് പറയാം: name и namespace.

apiVersion: example.com/v1alpha1
kind: MysqlDatabase
metadata:
  name: foo
  namespace: bar

ഞങ്ങൾക്ക് MySQL ഡാറ്റാബേസുകൾ സൃഷ്ടിക്കാൻ കഴിയുന്ന വ്യത്യസ്ത നെയിംസ്‌പേസുകളുള്ള ഒരു കുബർനെറ്റസ് ക്ലസ്റ്റർ ഉണ്ട്. ഈ സാഹചര്യത്തിൽ ഉറവിടങ്ങൾ ട്രാക്ക് ചെയ്യാൻ ഷെൽ-ഓപ്പറേറ്റർ ഉപയോഗിക്കാം MysqlDatabase, അവയെ MySQL സെർവറുമായി ബന്ധിപ്പിച്ച് ക്ലസ്റ്ററിന്റെ ആവശ്യമുള്ളതും നിരീക്ഷിച്ചതുമായ അവസ്ഥകൾ സമന്വയിപ്പിക്കുന്നു.

ഉദാഹരണം 3: ക്ലസ്റ്റർ നെറ്റ്‌വർക്ക് മോണിറ്ററിംഗ്

നിങ്ങൾക്കറിയാവുന്നതുപോലെ, ഒരു നെറ്റ്‌വർക്ക് നിരീക്ഷിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗമാണ് പിംഗ് ഉപയോഗിക്കുന്നത്. ഷെൽ-ഓപ്പറേറ്റർ ഉപയോഗിച്ച് അത്തരം നിരീക്ഷണം എങ്ങനെ നടപ്പിലാക്കാമെന്ന് ഈ ഉദാഹരണത്തിൽ ഞങ്ങൾ കാണിക്കും.

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

configVersion: v1
kubernetes:
- name: nodes
  apiVersion: v1
  kind: Node
  jqFilter: |
    {
      name: .metadata.name,
      ip: (
       .status.addresses[] |  
        select(.type == "InternalIP") |
        .address
      )
    }
  group: main
  keepFullObjectsInMemory: false
  executeHookOnEvent: []
schedule:
- name: every_minute
  group: main
  crontab: "* * * * *"

പാരാമീറ്റർ executeHookOnEvent: [] ഏതെങ്കിലും ഇവന്റിനോടുള്ള പ്രതികരണമായി ഹുക്ക് പ്രവർത്തിക്കുന്നത് തടയുന്നു (അതായത്, നോഡുകൾ മാറ്റുന്നതിനും ചേർക്കുന്നതിനും ഇല്ലാതാക്കുന്നതിനുമുള്ള പ്രതികരണമായി). എന്നിരുന്നാലും, അവൻ ഓടും (നോഡുകളുടെ ലിസ്റ്റ് അപ്ഡേറ്റ് ചെയ്യുക) ഷെഡ്യൂൾ ചെയ്തു - ഓരോ മിനിറ്റിലും, ഫീൽഡ് നിർദ്ദേശിച്ച പ്രകാരം schedule.

ഇപ്പോൾ ചോദ്യം ഉയർന്നുവരുന്നു, പാക്കറ്റ് നഷ്ടം പോലുള്ള പ്രശ്‌നങ്ങളെക്കുറിച്ച് നമുക്ക് എങ്ങനെ കൃത്യമായി അറിയാം? നമുക്ക് കോഡ് നോക്കാം:

function __main__() {
  for i in $(seq 0 "$(context::jq -r '(.snapshots.nodes | length) - 1')"); do
    node_name="$(context::jq -r '.snapshots.nodes['"$i"'].filterResult.name')"
    node_ip="$(context::jq -r '.snapshots.nodes['"$i"'].filterResult.ip')"
    packets_lost=0
    if ! ping -c 1 "$node_ip" -t 1 ; then
      packets_lost=1
    fi
    cat >> "$METRICS_PATH" <<END
      {
        "name": "node_packets_lost",
        "add": $packets_lost,
        "labels": {
          "node": "$node_name"
        }
      }
END
  done
}

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

ഇതുപോലെ ഒരു ക്ലസ്റ്ററിൽ ലളിതമായ നെറ്റ്‌വർക്ക് നിരീക്ഷണത്തിനായി നിങ്ങൾക്ക് ഒരു ഓപ്പറേറ്ററെ ഉണ്ടാക്കാം.

ക്യൂയിംഗ് സംവിധാനം

ഷെൽ-ഓപ്പറേറ്ററിൽ നിർമ്മിച്ച മറ്റൊരു പ്രധാന സംവിധാനം വിവരിക്കാതെ ഈ ലേഖനം അപൂർണ്ണമായിരിക്കും. ക്ലസ്റ്ററിലെ ഒരു സംഭവത്തിന് പ്രതികരണമായി ഇത് ഏതെങ്കിലും തരത്തിലുള്ള ഹുക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നുവെന്ന് സങ്കൽപ്പിക്കുക.

• അതേ സമയം, ക്ലസ്റ്ററിൽ എന്തെങ്കിലും സംഭവിച്ചാൽ എന്ത് സംഭവിക്കും? ഒന്ന് കൂടി സംഭവം?
• ഷെൽ-ഓപ്പറേറ്റർ ഹുക്കിന്റെ മറ്റൊരു ഉദാഹരണം പ്രവർത്തിപ്പിക്കുമോ?
• ഒരേസമയം അഞ്ച് സംഭവങ്ങൾ ക്ലസ്റ്ററിൽ സംഭവിച്ചാലോ?
• ഷെൽ-ഓപ്പറേറ്റർ അവയെ സമാന്തരമായി പ്രോസസ്സ് ചെയ്യുമോ?
• മെമ്മറിയും സിപിയുവും പോലെ ഉപഭോഗം ചെയ്ത വിഭവങ്ങളെ സംബന്ധിച്ചെന്ത്?

ഭാഗ്യവശാൽ, ഷെൽ-ഓപ്പറേറ്ററിന് ഒരു ബിൽറ്റ്-ഇൻ ക്യൂയിംഗ് മെക്കാനിസം ഉണ്ട്. എല്ലാ ഇവന്റുകളും ക്യൂവിൽ നിർത്തുകയും ക്രമാനുഗതമായി പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു.

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

കൂടാതെ ഇവയും ഇവന്റുകൾ ഒരു വലിയ ഒന്നായി കൂട്ടിച്ചേർക്കാം. പരാമീറ്റർ ഇതിന് ഉത്തരവാദിയാണ് group ബൈൻഡിംഗ് കോൺഫിഗറേഷനിൽ.

നിങ്ങൾക്ക് എത്ര ക്യൂകളും/ഹുക്കുകളും അവയുടെ വിവിധ കോമ്പിനേഷനുകളും സൃഷ്ടിക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, ഒരു ക്യൂവിന് രണ്ട് കൊളുത്തുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയും, അല്ലെങ്കിൽ തിരിച്ചും.

അതിനനുസരിച്ച് ഫീൽഡ് കോൺഫിഗർ ചെയ്താൽ മതി queue ബൈൻഡിംഗ് കോൺഫിഗറേഷനിൽ. ഒരു ക്യൂ നാമം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഹുക്ക് ഡിഫോൾട്ട് ക്യൂവിൽ പ്രവർത്തിക്കുന്നു (default). കൊളുത്തുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ എല്ലാ റിസോഴ്സ് മാനേജ്മെന്റ് പ്രശ്നങ്ങളും പൂർണ്ണമായും പരിഹരിക്കാൻ ഈ ക്യൂയിംഗ് സംവിധാനം നിങ്ങളെ അനുവദിക്കുന്നു.

തീരുമാനം

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

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

നിങ്ങൾക്കിത് ഇഷ്‌ടപ്പെട്ടെങ്കിൽ, GitHub-ൽ പുതിയ ലക്കങ്ങൾ/PR/നക്ഷത്രങ്ങൾ കാണുന്നതിൽ ഞങ്ങൾ എപ്പോഴും സന്തുഷ്ടരാണ്, അവിടെ നിങ്ങൾക്ക് മറ്റുള്ളവരെ കണ്ടെത്താനാകും. രസകരമായ പദ്ധതികൾ. അവയിൽ ഹൈലൈറ്റ് ചെയ്യുന്നത് മൂല്യവത്താണ് addon-operator, ഷെൽ ഓപ്പറേറ്ററുടെ മൂത്ത സഹോദരൻ. ആഡ്-ഓണുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും അപ്‌ഡേറ്റുകൾ നൽകുന്നതിനും വിവിധ ചാർട്ട് പാരാമീറ്ററുകൾ/മൂല്യങ്ങൾ നിരീക്ഷിക്കുന്നതിനും ചാർട്ടുകളുടെ ഇൻസ്റ്റാളേഷൻ പ്രക്രിയ നിയന്ത്രിക്കുന്നതിനും ക്ലസ്റ്ററിലെ ഇവന്റുകൾക്ക് പ്രതികരണമായി അവ പരിഷ്‌ക്കരിക്കുന്നതിനും ഈ യൂട്ടിലിറ്റി ഹെൽം ചാർട്ടുകൾ ഉപയോഗിക്കുന്നു.

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

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

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

പി.എസ്

ഞങ്ങളുടെ ബ്ലോഗിലും വായിക്കുക:

• «ഷെൽ-ഓപ്പറേറ്റർ ഉപയോഗിച്ച് കുബർനെറ്റസ് ഓപ്പറേറ്റർമാരുടെ എളുപ്പത്തിൽ സൃഷ്ടിക്കൽ: വർഷത്തിൽ പ്രോജക്റ്റ് പുരോഗതി";
• «ഷെൽ-ഓപ്പറേറ്റർ അവതരിപ്പിക്കുന്നു: കുബർനെറ്റസിനായി ഓപ്പറേറ്റർമാരെ സൃഷ്ടിക്കുന്നത് ഇപ്പോൾ എളുപ്പമായി";
• «ഒരു കുബർനെറ്റസ് ക്ലസ്റ്റർ തയ്യാറാക്കുന്നത് എളുപ്പവും സൗകര്യപ്രദവുമാണോ? ആഡ്-ഓപ്പറേറ്റർ പ്രഖ്യാപിക്കുന്നു";
• «കുബർനെറ്റസ് വികസിപ്പിക്കുകയും പൂർത്തീകരിക്കുകയും ചെയ്യുക" (അവലോകനവും വീഡിയോ റിപ്പോർട്ടും).

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