kubectl കൂടുതൽ ഫലപ്രദമായി എങ്ങനെ ഉപയോഗിക്കാം: വിശദമായ ഒരു ഗൈഡ്

നിങ്ങൾ കുബെർനെറ്റസിനൊപ്പം പ്രവർത്തിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്ന യൂട്ടിലിറ്റികളിൽ ഒന്നാണ് kubectl. ഒരു പ്രത്യേക ഉപകരണം ഉപയോഗിച്ച് നിങ്ങൾ വളരെയധികം സമയം ചെലവഴിക്കുമ്പോഴെല്ലാം, അത് നന്നായി പഠിക്കുകയും അത് എങ്ങനെ ഫലപ്രദമായി ഉപയോഗിക്കാമെന്ന് മനസിലാക്കുകയും ചെയ്യുന്നു.

ടീം Mail.ru-ൽ നിന്ന് Kubernetes aaS ഡാനിയൽ വെയ്ബെലിന്റെ ഒരു ലേഖനം വിവർത്തനം ചെയ്തു, അതിൽ kubectl-ൽ ഫലപ്രദമായി പ്രവർത്തിക്കുന്നതിനുള്ള നുറുങ്ങുകളും തന്ത്രങ്ങളും നിങ്ങൾ കണ്ടെത്തും. കുബർനെറ്റുകളെ കുറിച്ച് ആഴത്തിലുള്ള ധാരണ നേടാനും ഇത് നിങ്ങളെ സഹായിക്കും.

രചയിതാവ് പറയുന്നതനുസരിച്ച്, കുബെർനെറ്റസുമായുള്ള നിങ്ങളുടെ ദൈനംദിന ജോലി കൂടുതൽ കാര്യക്ഷമമാക്കുക മാത്രമല്ല, കൂടുതൽ ആസ്വാദ്യകരമാക്കുകയും ചെയ്യുക എന്നതാണ് ലേഖനത്തിന്റെ ലക്ഷ്യം!

ആമുഖം: എന്താണ് kubectl

kubectl കൂടുതൽ ഫലപ്രദമായി ഉപയോഗിക്കാൻ പഠിക്കുന്നതിന് മുമ്പ്, അത് എന്താണെന്നും അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും നിങ്ങൾ ഒരു അടിസ്ഥാന ധാരണ നേടേണ്ടതുണ്ട്.

ഒരു ഉപയോക്താവിന്റെ വീക്ഷണകോണിൽ, Kubernetes പ്രവർത്തനങ്ങൾ നടത്താൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു നിയന്ത്രണ പാനലാണ് kubectl.

സാങ്കേതികമായി പറഞ്ഞാൽ, kubectl ഒരു Kubernetes API ക്ലയന്റാണ്.

Kubernetes API ഒരു HTTP REST API ആണ്. ഈ API യഥാർത്ഥ Kubernetes ഉപയോക്തൃ ഇന്റർഫേസ് ആണ്, അതിലൂടെ ഇത് പൂർണ്ണമായും നിയന്ത്രിക്കപ്പെടുന്നു. ഇതിനർത്ഥം, എല്ലാ കുബർനെറ്റസ് പ്രവർത്തനങ്ങളും ഒരു API എൻഡ്‌പോയിന്റായി തുറന്നുകാട്ടപ്പെടുന്നുവെന്നും ആ എൻഡ്‌പോയിന്റിലേക്ക് ഒരു HTTP അഭ്യർത്ഥന ഉപയോഗിച്ച് നടത്താമെന്നുമാണ്.

അതിനാൽ, Kubectl-ന്റെ പ്രധാന ജോലി Kubernetes API-ലേക്ക് HTTP അഭ്യർത്ഥനകൾ നടത്തുക എന്നതാണ്:

പൂർണ്ണമായും വിഭവാധിഷ്ഠിത സംവിധാനമാണ് കുബർനെറ്റസ്. ഇതിനർത്ഥം ഇത് വിഭവങ്ങളുടെ ആന്തരിക അവസ്ഥ നിലനിർത്തുന്നുവെന്നും എല്ലാ കുബർനെറ്റസ് പ്രവർത്തനങ്ങളും CRUD പ്രവർത്തനങ്ങളാണെന്നും ആണ്.

ഈ ഉറവിടങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിലൂടെ നിങ്ങൾ കുബർനെറ്റുകളുടെ പൂർണ്ണ നിയന്ത്രണത്തിലാണ്, കൂടാതെ വിഭവങ്ങളുടെ നിലവിലെ അവസ്ഥയെ അടിസ്ഥാനമാക്കി എന്താണ് ചെയ്യേണ്ടതെന്ന് കുബർനെറ്റ്സ് കണക്കാക്കുന്നു. ഇക്കാരണത്താൽ, Kubernetes API റഫറൻസ് അവയുടെ അനുബന്ധ പ്രവർത്തനങ്ങളുള്ള റിസോഴ്സ് തരങ്ങളുടെ ഒരു പട്ടികയായി ക്രമീകരിച്ചിരിക്കുന്നു.

നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം.

നിങ്ങൾ ഒരു ReplicaSet റിസോഴ്സ് സൃഷ്ടിക്കാൻ ആഗ്രഹിക്കുന്നുവെന്ന് പറയാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഒരു ഫയലിലെ ReplicaSet നെ പേര് പ്രകാരം വിവരിക്കുന്നു replicaset.yaml, തുടർന്ന് കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

$ kubectl create -f replicaset.yaml

ഇത് ഒരു ReplicaSet റിസോഴ്സ് സൃഷ്ടിക്കും. എന്നാൽ തിരശ്ശീലയ്ക്ക് പിന്നിൽ എന്താണ് സംഭവിക്കുന്നത്?

കുബെർനെറ്റസിന് റെപ്ലിക്കസെറ്റ് സൃഷ്‌ടിക്കൽ പ്രവർത്തനമുണ്ട്. മറ്റേതൊരു പ്രവർത്തനത്തെയും പോലെ, ഇത് ഒരു API എൻഡ്‌പോയിന്റായി തുറന്നുകാട്ടപ്പെടുന്നു. ഈ പ്രവർത്തനത്തിനായുള്ള നിർദ്ദിഷ്ട API എൻഡ്‌പോയിന്റ് ഇതുപോലെ കാണപ്പെടുന്നു:

POST /apis/apps/v1/namespaces/{namespace}/replicasets

എല്ലാ Kubernetes പ്രവർത്തനങ്ങൾക്കുമുള്ള API എൻഡ് പോയിന്റുകൾ ഇവിടെ കണ്ടെത്താനാകും API റഫറൻസ് (ഉൾപ്പെടെ മുകളിലുള്ള അവസാന പോയിന്റ്). ഒരു എൻഡ് പോയിന്റിലേക്ക് ഒരു യഥാർത്ഥ അഭ്യർത്ഥന നടത്താൻ, നിങ്ങൾ ആദ്യം API റഫറൻസിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്ന എൻഡ് പോയിന്റ് പാതകളിലേക്ക് API സെർവർ URL ചേർക്കണം.

അതിനാൽ, നിങ്ങൾ മുകളിലുള്ള കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, മുകളിലുള്ള API എൻഡ് പോയിന്റിലേക്ക് kubectl ഒരു HTTP POST അഭ്യർത്ഥന അയയ്ക്കുന്നു. നിങ്ങൾ ഫയലിൽ നൽകിയ ReplicaSet നിർവചനം replicaset.yaml, അഭ്യർത്ഥനയുടെ ബോഡിയിൽ അയച്ചു.

Kubernetes ക്ലസ്റ്ററുമായി സംവദിക്കുന്ന എല്ലാ കമാൻഡുകൾക്കും kubectl പ്രവർത്തിക്കുന്നത് ഇങ്ങനെയാണ്. ഈ സാഹചര്യങ്ങളിലെല്ലാം, kubectl ഉചിതമായ Kubernetes API എൻഡ്‌പോയിന്റുകളിലേക്ക് HTTP അഭ്യർത്ഥനകൾ നടത്തുന്നു.

ഇതുപോലുള്ള ഒരു യൂട്ടിലിറ്റി ഉപയോഗിച്ച് നിങ്ങൾക്ക് കുബർനെറ്റ്സ് പൂർണ്ണമായും നിയന്ത്രിക്കാനാകുമെന്നത് ശ്രദ്ധിക്കുക curlKubernetes API-ലേക്ക് സ്വമേധയാ HTTP അഭ്യർത്ഥനകൾ അയച്ചുകൊണ്ട്. Kubectl ലളിതമായി Kubernetes API ഉപയോഗിക്കുന്നത് എളുപ്പമാക്കുന്നു.

ഇതാണ് kubectl എന്താണെന്നും അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ഉള്ള അടിസ്ഥാനകാര്യങ്ങൾ. എന്നാൽ Kubernetes API-യെ കുറിച്ച് ഓരോ kubectl ഉപയോക്താവും അറിഞ്ഞിരിക്കേണ്ട മറ്റൊന്നുണ്ട്. കുബർനെറ്റസിന്റെ ആന്തരിക ലോകത്തിലേക്ക് നമുക്ക് പെട്ടെന്ന് നോക്കാം.

കുബർനെറ്റസിന്റെ ആന്തരിക ലോകം

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

പ്രധാന നോഡുകളിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ഘടകങ്ങൾ ഇതാ:

1. നിലവറ - റിസോഴ്സ് നിർവചനങ്ങൾ സംഭരിക്കുന്നു (സാധാരണയായി ഇത് etcd ആണ്).
2. API സെർവർ — ഒരു API നൽകുകയും സംഭരണം നിയന്ത്രിക്കുകയും ചെയ്യുന്നു.
3. കൺട്രോളർ മാനേജർ - റിസോഴ്സ് സ്റ്റാറ്റസുകൾ സ്പെസിഫിക്കേഷനുകൾക്ക് അനുസൃതമാണെന്ന് ഉറപ്പാക്കുന്നു.
4. ഷെഡ്യൂളർ - തൊഴിലാളി നോഡുകളിൽ പോഡുകൾ ഷെഡ്യൂൾ ചെയ്യുന്നു.

തൊഴിലാളി നോഡുകളിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ഒരു ഘടകം ഇതാ:

1. കുബേലേത് - വർക്കിംഗ് നോഡിലെ കണ്ടെയ്‌നറുകളുടെ വിക്ഷേപണം നിയന്ത്രിക്കുന്നു.

ഈ ഘടകങ്ങൾ എങ്ങനെ ഒരുമിച്ച് പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കാൻ, നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം.

നിങ്ങൾ ഇപ്പോൾ പൂർത്തിയാക്കി എന്ന് കരുതുക kubectl create -f replicaset.yaml, അതിന് ശേഷം kubectl ഒരു HTTP POST അഭ്യർത്ഥന നടത്തി ReplicaSet API എൻഡ്‌പോയിന്റ് (ReplicaSet റിസോഴ്സ് നിർവചനം കടന്നുപോകുന്നു).

ക്ലസ്റ്ററിൽ എന്താണ് നടക്കുന്നത്?

1. ചെയ്ത ശേഷം kubectl create -f replicaset.yaml API സെർവർ നിങ്ങളുടെ ReplicaSet റിസോഴ്സ് നിർവചനം സ്റ്റോറേജിൽ സംഭരിക്കുന്നു:

   

2. അടുത്തതായി, റെപ്ലിക്കസെറ്റ് റിസോഴ്‌സുകളുടെ സൃഷ്ടി, പരിഷ്‌ക്കരണം, ഇല്ലാതാക്കൽ എന്നിവ കൈകാര്യം ചെയ്യുന്ന കൺട്രോളർ മാനേജറിൽ ReplicaSet കൺട്രോളർ സമാരംഭിക്കുന്നു:

   

3. ReplicaSet കൺട്രോളർ ഓരോ ReplicaSet പകർപ്പിനും ഒരു പോഡ് ഡെഫനിഷൻ സൃഷ്ടിക്കുന്നു (ReplicaSet നിർവചനത്തിലെ പോഡ് ടെംപ്ലേറ്റ് അനുസരിച്ച്) അവ സ്റ്റോറേജിൽ സൂക്ഷിക്കുന്നു:

   

4. ഷെഡ്യൂളർ സമാരംഭിച്ചു, ഇതുവരെ ഒരു വർക്കർ നോഡുകളിലേക്കും അസൈൻ ചെയ്തിട്ടില്ലാത്ത പോഡുകൾ ട്രാക്കുചെയ്യുന്നു:

   

5. ഷെഡ്യൂളർ ഓരോ പോഡിനും അനുയോജ്യമായ ഒരു വർക്കർ നോഡ് തിരഞ്ഞെടുക്കുകയും സ്റ്റോറിലെ പോഡ് നിർവചനത്തിലേക്ക് ഈ വിവരങ്ങൾ ചേർക്കുകയും ചെയ്യുന്നു:

   

6. പോഡ് അസൈൻ ചെയ്‌തിരിക്കുന്ന വർക്കർ നോഡിൽ, കുബെലെറ്റ് സമാരംഭിച്ചു, ഇത് ഈ നോഡിലേക്ക് അസൈൻ ചെയ്‌ത പോഡുകൾ ട്രാക്ക് ചെയ്യുന്നു:

   

7. കുബെലെറ്റ് സംഭരണത്തിൽ നിന്ന് പോഡ് നിർവചനം വായിക്കുകയും നോഡിൽ കണ്ടെയ്‌നറുകൾ ലോഞ്ച് ചെയ്യാൻ ഡോക്കർ പോലുള്ള ഒരു കണ്ടെയ്‌നർ റൺടൈമിനോട് നിർദ്ദേശിക്കുകയും ചെയ്യുന്നു:

   

ഈ വിവരണത്തിന്റെ ഒരു വാചക പതിപ്പ് ചുവടെയുണ്ട്.

ReplicaSet ക്രിയേഷൻ എൻഡ്‌പോയിന്റിലേക്കുള്ള API അഭ്യർത്ഥന API സെർവർ പ്രോസസ്സ് ചെയ്യുന്നു. API സെർവർ അഭ്യർത്ഥന പ്രാമാണീകരിക്കുകയും സംഭരണത്തിൽ ReplicaSet റിസോഴ്സ് നിർവചനം സംഭരിക്കുകയും ചെയ്യുന്നു.

ഈ ഇവന്റ് റെപ്ലിക്കസെറ്റ് കൺട്രോളർ ആരംഭിക്കുന്നു, ഇത് കൺട്രോളർ മാനേജരുടെ ഉപപ്രോസസ് ആണ്. ReplicaSet കൺട്രോളർ സ്റ്റോറിലെ ReplicaSet ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നതും അപ്‌ഡേറ്റുചെയ്യുന്നതും ഇല്ലാതാക്കുന്നതും നിരീക്ഷിക്കുകയും ഇത് സംഭവിക്കുമ്പോൾ ഒരു ഇവന്റ് അറിയിപ്പ് സ്വീകരിക്കുകയും ചെയ്യുന്നു.

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

വർക്കർ നോഡുകൾക്കായി ഇതുവരെ ഷെഡ്യൂൾ ചെയ്തിട്ടില്ലാത്ത പോഡ് നിർവചനങ്ങളുടെ ട്രാക്ക് സൂക്ഷിക്കുന്ന ഒരു ഷെഡ്യൂളറാണ് പുതിയ പോഡുകൾ സൃഷ്ടിക്കുന്നത്. ഷെഡ്യൂളർ ഓരോ പോഡിനും അനുയോജ്യമായ ഒരു വർക്കർ നോഡ് തിരഞ്ഞെടുക്കുകയും റിപ്പോസിറ്ററിയിലെ പോഡ് നിർവചനങ്ങൾ അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു.

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

അവസാന ഇവന്റ് കുബെലെറ്റുകളെ പ്രവർത്തനക്ഷമമാക്കുന്നു, അത് അവരുടെ വർക്കർ നോഡുകൾക്കായി ഷെഡ്യൂൾ ചെയ്തിരിക്കുന്ന പോഡുകൾ നിരീക്ഷിക്കുന്നു. നിങ്ങളുടെ ReplicaSet പോഡുകൾ ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്ന വർക്കർ നോഡിന്റെ കുബെലെറ്റ്, ആവശ്യമായ കണ്ടെയ്‌നർ ഇമേജുകൾ ഡൗൺലോഡ് ചെയ്യാനും അവ പ്രവർത്തിപ്പിക്കാനും ഡോക്കർ പോലുള്ള കണ്ടെയ്‌നർ റൺടൈമിന് നിർദ്ദേശം നൽകണം.

ഈ സമയത്ത്, നിങ്ങളുടെ ReplicaSet ആപ്ലിക്കേഷൻ ഒടുവിൽ പ്രവർത്തിക്കുന്നു!

കുബർനെറ്റസ് API-യുടെ പങ്ക്

നിങ്ങൾ മുമ്പത്തെ ഉദാഹരണത്തിൽ കണ്ടതുപോലെ, സംഭരണത്തിലെ ഉറവിടങ്ങളിലെ മാറ്റങ്ങൾക്കായി Kubernetes ഘടകങ്ങൾ (API സെർവറും സ്റ്റോറേജും ഒഴികെ) നിരീക്ഷിക്കുകയും സംഭരണത്തിലെ ഉറവിടങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ മാറ്റുകയും ചെയ്യുന്നു.

തീർച്ചയായും, ഈ ഘടകങ്ങൾ സ്റ്റോറേജുമായി നേരിട്ട് സംവദിക്കുന്നില്ല, കുബർനെറ്റസ് API വഴി മാത്രം.

ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങൾ പരിഗണിക്കുക:

1. ReplicaSet കൺട്രോളർ API എൻഡ്‌പോയിന്റ് ഉപയോഗിക്കുന്നു ലിസ്റ്റ് റെപ്ലിക്കസെറ്റുകൾ പരാമീറ്റർ ഉപയോഗിച്ച് watch RepicaSet ഉറവിടങ്ങളിലെ മാറ്റങ്ങൾ നിരീക്ഷിക്കാൻ.
2. ReplicaSet കൺട്രോളർ API എൻഡ്‌പോയിന്റ് ഉപയോഗിക്കുന്നു പോഡ് സൃഷ്ടിക്കുക (പാഡ് സൃഷ്‌ടിക്കുക) പോഡുകൾ സൃഷ്ടിക്കാൻ.
3. ഷെഡ്യൂളർ API എൻഡ്‌പോയിന്റ് ഉപയോഗിക്കുന്നു പാച്ച് പോഡ് (എഡിറ്റ് പോഡ്) തിരഞ്ഞെടുത്ത വർക്കർ നോഡിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഉപയോഗിച്ച് പോഡുകൾ അപ്‌ഡേറ്റ് ചെയ്യാൻ.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, kubectl ആക്സസ് ചെയ്യുന്ന അതേ API ഇതാണ്. ആന്തരിക ഘടകങ്ങൾക്കും ബാഹ്യ ഉപയോക്താക്കൾക്കും ഒരേ API ഉപയോഗിക്കുന്നത് കുബർനെറ്റസ് ഡിസൈനിലെ ഒരു അടിസ്ഥാന ആശയമാണ്.

കുബെർനെറ്റസ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഇപ്പോൾ നമുക്ക് സംഗ്രഹിക്കാം:

1. സ്റ്റോറേജ് സ്റ്റോറുകൾ പ്രസ്താവിക്കുന്നു, അതായത്, കുബർനെറ്റസ് വിഭവങ്ങൾ.
2. API സെർവർ, Kubernetes API-യുടെ രൂപത്തിൽ സംഭരണത്തിന് ഒരു ഇന്റർഫേസ് നൽകുന്നു.
3. മറ്റെല്ലാ Kubernetes ഘടകങ്ങളും ഉപയോക്താക്കളും API വഴി Kubernetes അവസ്ഥ (വിഭവങ്ങൾ) വായിക്കുകയും നിരീക്ഷിക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു.

ഈ ആശയങ്ങൾ അറിയുന്നത് kubectl നന്നായി മനസ്സിലാക്കാനും അത് പരമാവധി പ്രയോജനപ്പെടുത്താനും നിങ്ങളെ സഹായിക്കും.

ഇപ്പോൾ kubectl ഉപയോഗിച്ച് നിങ്ങളുടെ ഉൽപ്പാദനക്ഷമത മെച്ചപ്പെടുത്താൻ സഹായിക്കുന്ന ചില പ്രത്യേക നുറുങ്ങുകളും തന്ത്രങ്ങളും നോക്കാം.

1. കമാൻഡ് പൂർത്തീകരണം ഉപയോഗിച്ച് ഇൻപുട്ട് വേഗത്തിലാക്കുക

kubectl ഉപയോഗിച്ച് പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനുള്ള ഏറ്റവും ഉപയോഗപ്രദവും എന്നാൽ പലപ്പോഴും അവഗണിക്കപ്പെടുന്നതുമായ ഒരു സാങ്കേതികതയാണ് കമാൻഡ് പൂർത്തീകരണം.

ടാബ് കീ ഉപയോഗിച്ച് kubectl കമാൻഡുകളുടെ ഭാഗങ്ങൾ സ്വയമേവ പൂർത്തിയാക്കാൻ കമാൻഡ് പൂർത്തീകരണം നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ഉപകമാൻഡുകൾക്കും ഓപ്ഷനുകൾക്കും ആർഗ്യുമെന്റുകൾക്കും വേണ്ടി പ്രവർത്തിക്കുന്നു, ഉറവിട നാമങ്ങൾ പോലെ സങ്കീർണ്ണമായ ഒന്ന് ഉൾപ്പെടെ.

kubectl കമാൻഡ് പൂർത്തീകരണം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണുക:

ബാഷ്, Zsh ഷെല്ലുകൾക്കായി കമാൻഡ് പൂർത്തിയാക്കൽ പ്രവർത്തിക്കുന്നു.

ഔദ്യോഗിക ഗൈഡ് സ്വയം പൂർത്തീകരണം സജ്ജീകരിക്കുന്നതിനുള്ള വിശദമായ നിർദ്ദേശങ്ങൾ അടങ്ങിയിരിക്കുന്നു, എന്നാൽ ചുവടെ ഞങ്ങൾ ഒരു ചെറിയ ഉദ്ധരണി നൽകും.

കമാൻഡ് പൂർത്തീകരണം എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഒരു പൂർത്തീകരണ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന ഒരു ഷെൽ സവിശേഷതയാണ് കമാൻഡ് പൂർത്തീകരണം. ഒരു നിർദ്ദിഷ്‌ട കമാൻഡിനായി ഒരു വിപുലീകരണത്തിന്റെ സ്വഭാവം നിർവചിക്കുന്ന ഒരു ഷെൽ സ്‌ക്രിപ്റ്റാണ് എക്‌സ്‌റ്റൻഷൻ സ്‌ക്രിപ്റ്റ്.

ഇനിപ്പറയുന്ന കമാൻഡുകൾ ഉപയോഗിച്ച് Kubectl സ്വപ്രേരിതമായി Bash, Zsh എന്നിവയ്‌ക്കായി വിപുലീകരണ സ്‌ക്രിപ്റ്റുകൾ സൃഷ്‌ടിക്കുകയും ഔട്ട്‌പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു:

$ kubectl completion bash

അല്ലെങ്കിൽ:

$ kubectl completion zsh

സിദ്ധാന്തത്തിൽ, ഈ കമാൻഡുകളുടെ ഔട്ട്പുട്ട് ഉചിതമായ കമാൻഡ് ഷെല്ലുമായി ബന്ധിപ്പിച്ചാൽ മതിയാകും, അതുവഴി kubectl-ന് കമാൻഡുകൾ പൂർത്തീകരിക്കാൻ കഴിയും.

പ്രായോഗികമായി, കണക്ഷൻ രീതി Bash-നും (Linux ഉം MacOS ഉം തമ്മിലുള്ള വ്യത്യാസങ്ങൾ ഉൾപ്പെടെ) Zsh-നും വ്യത്യസ്തമാണ്. ഈ എല്ലാ ഓപ്ഷനുകളും ഞങ്ങൾ ചുവടെ നോക്കും.

ലിനക്സിൽ ബാഷ് ചെയ്യുക

ബാഷ് പൂർത്തീകരണ സ്ക്രിപ്റ്റ് ബാഷ് പൂർത്തിയാക്കൽ പാക്കേജിനെ ആശ്രയിച്ചിരിക്കുന്നു, അതിനാൽ നിങ്ങൾ ആദ്യം ഇത് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്:

$ sudo apt-get install bash-completion

അല്ലെങ്കിൽ:

$ yum install bash-completion

ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് പാക്കേജ് വിജയകരമായി ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടോയെന്ന് നിങ്ങൾക്ക് പരിശോധിക്കാം:

$ type _init_completion

ഇത് ഷെൽ ഫംഗ്‌ഷൻ കോഡ് ഔട്ട്‌പുട്ട് ചെയ്യുന്നുവെങ്കിൽ, ബാഷ്-കംപ്ലീഷൻ ശരിയായി ഇൻസ്റ്റാൾ ചെയ്യപ്പെടും. കമാൻഡ് "കണ്ടെത്തിയില്ല" എന്ന പിശക് നൽകിയാൽ, നിങ്ങളുടെ ഫയലിലേക്ക് ഇനിപ്പറയുന്ന വരി ചേർക്കേണ്ടതുണ്ട് ~ / .bashrc:

$ source /usr/share/bash-completion/bash_completion

ഫയലിൽ ഈ വരി ചേർക്കേണ്ടതുണ്ടോ? ~ / .bashrc അല്ലെങ്കിൽ ബാഷ്-കംപ്ലീഷൻ ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങൾ ഉപയോഗിച്ച പാക്കേജ് മാനേജരെ ആശ്രയിച്ചിരിക്കില്ല. ഇത് APT-ന് ആവശ്യമാണ്, എന്നാൽ YUM-ന് അല്ല.

bash-completion ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, എല്ലാ ഷെൽ സെഷനുകളിലും kubectl കംപ്ലീഷൻ സ്ക്രിപ്റ്റ് പ്രവർത്തനക്ഷമമാക്കുന്നതിന് നിങ്ങൾ എല്ലാം കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്.

ഇതിനുള്ള ഒരു മാർഗ്ഗം ഫയലിലേക്ക് ഇനിപ്പറയുന്ന വരി ചേർക്കുക എന്നതാണ് ~ / .bashrc:

source <(kubectl completion bash)

മറ്റൊരു മാർഗം kubectl എക്സ്റ്റൻഷൻ സ്ക്രിപ്റ്റ് ഡയറക്ടറിയിലേക്ക് ചേർക്കുക എന്നതാണ് /etc/bash_completion.d (അത് നിലവിലില്ലെങ്കിൽ അത് സൃഷ്ടിക്കുക):

$ kubectl completion bash >/etc/bash_completion.d/kubectl

കാറ്റലോഗിലെ എല്ലാ ആഡ്-ഓൺ സ്ക്രിപ്റ്റുകളും /etc/bash_completion.d ബാഷ് പൂർത്തീകരണത്തിൽ സ്വയമേവ ഉൾപ്പെടുത്തിയിരിക്കുന്നു.

രണ്ട് ഓപ്ഷനുകളും ഒരുപോലെ ബാധകമാണ്.

ഷെൽ പുനരാരംഭിച്ച ശേഷം, kubectl കമാൻഡ് പൂർത്തീകരണം പ്രവർത്തിക്കും.

MacOS-ൽ ബാഷ് ചെയ്യുക

MacOS-ൽ സജ്ജീകരണം കുറച്ചുകൂടി സങ്കീർണ്ണമാണ്. സ്ഥിരസ്ഥിതിയായി, MacOS ബാഷ് പതിപ്പ് 3.2 ഉപയോഗിക്കുന്നു, കൂടാതെ kubectl ഓട്ടോകംപ്ലീഷൻ സ്ക്രിപ്റ്റിന് കുറഞ്ഞത് 4.1 ന്റെ ഒരു ബാഷ് പതിപ്പ് ആവശ്യമാണ്, അത് ബാഷ് 3.2-ൽ പ്രവർത്തിക്കില്ല.

MacOS-ൽ Bash-ന്റെ കാലഹരണപ്പെട്ട പതിപ്പ് ഉപയോഗിക്കുന്നതുമായി ബന്ധപ്പെട്ട ലൈസൻസിംഗ് പ്രശ്‌നങ്ങളുണ്ട്. Bash പതിപ്പ് 4, Apple പിന്തുണയ്‌ക്കാത്ത GPLv3-ന് കീഴിൽ ലൈസൻസ് ചെയ്‌തിരിക്കുന്നു.

MacOS-ൽ kubectl autocompletion കോൺഫിഗർ ചെയ്യുന്നതിന്, നിങ്ങൾ Bash-ന്റെ ഏറ്റവും പുതിയ പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. നിങ്ങൾക്ക് അപ്‌ഡേറ്റ് ചെയ്‌ത ബാഷ് നിങ്ങളുടെ ഡിഫോൾട്ട് ഷെല്ലായി സജ്ജീകരിക്കാനും കഴിയും, ഇത് ഭാവിയിൽ നിങ്ങൾക്ക് ഒരുപാട് പ്രശ്‌നങ്ങൾ ഒഴിവാക്കും. ഇത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, വിശദാംശങ്ങൾ ലേഖനത്തിൽ നൽകിയിരിക്കുന്നു "MacOS-ൽ ബാഷ് അപ്ഡേറ്റ് ചെയ്യുന്നു".

തുടരുന്നതിന് മുമ്പ്, നിങ്ങൾ ബാഷിന്റെ സമീപകാല പതിപ്പാണ് ഉപയോഗിക്കുന്നതെന്ന് ഉറപ്പാക്കുക (ഔട്ട്പുട്ട് പരിശോധിക്കുക bash --version).

ബാഷ് പൂർത്തീകരണ സ്ക്രിപ്റ്റ് പ്രോജക്റ്റ് അനുസരിച്ച് വ്യത്യാസപ്പെടുന്നു ബാഷ്-പൂർത്തിയാക്കൽ, അതിനാൽ നിങ്ങൾ ആദ്യം ഇത് ഇൻസ്റ്റാൾ ചെയ്യണം.

ഉപയോഗിച്ച് നിങ്ങൾക്ക് bash-completion ഇൻസ്റ്റാൾ ചെയ്യാം Homebrew:

$ brew install bash-completion@2

ഇത് @2 ബാഷ്-പൂർത്തിയാക്കൽ പതിപ്പ് 2. kubectl സ്വയം പൂർത്തീകരണത്തിന് bash-completion v2 ആവശ്യമാണ്, കൂടാതെ bash-completion v2-ന് കുറഞ്ഞത് Bash പതിപ്പ് 4.1 ആവശ്യമാണ്.

കമാൻഡ് ഔട്ട്പുട്ട് brew-install ഫയലിലേക്ക് എന്താണ് ചേർക്കേണ്ടതെന്ന് വ്യക്തമാക്കുന്ന ഒരു മുന്നറിയിപ്പ് വിഭാഗം അടങ്ങിയിരിക്കുന്നു ~/.bash_profile:

export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . 
"/usr/local/etc/profile.d/bash_completion.sh"

എന്നിരുന്നാലും, ഈ വരികൾ ചേർക്കരുതെന്ന് ഞാൻ ശുപാർശ ചെയ്യുന്നു ~/.bash_profile, ഒപ്പം ~/.bashrc. ഈ സാഹചര്യത്തിൽ, യാന്ത്രിക പൂർത്തീകരണം പ്രധാനത്തിൽ മാത്രമല്ല, ചൈൽഡ് കമാൻഡ് ഷെല്ലുകളിലും ലഭ്യമാകും.

കമാൻഡ് ഷെൽ പുനരാരംഭിച്ച ശേഷം, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇൻസ്റ്റാളേഷൻ ശരിയാണോ എന്ന് പരിശോധിക്കാൻ കഴിയും:

$ type _init_completion

ഔട്ട്പുട്ടിൽ നിങ്ങൾ ഒരു ഷെൽ ഫംഗ്ഷൻ കാണുകയാണെങ്കിൽ, എല്ലാം ശരിയായി ക്രമീകരിച്ചിരിക്കുന്നു.

ഇപ്പോൾ എല്ലാ സെഷനുകളിലും kubectl autocompletion പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട്.

ഇനിപ്പറയുന്ന വരി നിങ്ങളിലേക്ക് ചേർക്കുക എന്നതാണ് ഒരു മാർഗം ~/.bashrc:

source <(kubectl completion bash)

രണ്ടാമത്തെ മാർഗം ഫോൾഡറിലേക്ക് ഒരു സ്വയം പൂർത്തീകരണ സ്ക്രിപ്റ്റ് ചേർക്കുക എന്നതാണ് /usr/local/etc/bash_completion.d:

$ kubectl completion bash
>/usr/local/etc/bash_completion.d/kubectl

നിങ്ങൾ Homebrew ഉപയോഗിച്ച് bash-completion ഇൻസ്റ്റാൾ ചെയ്താൽ മാത്രമേ ഈ രീതി പ്രവർത്തിക്കൂ. ഈ സാഹചര്യത്തിൽ, bash-completion ഈ ഡയറക്ടറിയിൽ നിന്ന് എല്ലാ സ്ക്രിപ്റ്റുകളും ലോഡ് ചെയ്യുന്നു.

നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്താൽ ഹോംബ്രൂ ഉപയോഗിച്ച് kubectl, അപ്പോൾ മുമ്പത്തെ ഘട്ടം ചെയ്യേണ്ടതില്ല, കാരണം സ്വയം പൂർത്തീകരണ സ്ക്രിപ്റ്റ് സ്വയമേവ ഫോൾഡറിൽ സ്ഥാപിക്കും /usr/local/etc/bash_completion.d ഇൻസ്റ്റലേഷൻ സമയത്ത്. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ bash-completion ഇൻസ്റ്റാൾ ചെയ്താലുടൻ kubectl autocompletion പ്രവർത്തിക്കാൻ തുടങ്ങും.

തൽഫലമായി, ഈ ഓപ്ഷനുകളെല്ലാം തുല്യമാണ്.

Zsh

Zsh-നുള്ള യാന്ത്രിക പൂർത്തീകരണ സ്ക്രിപ്റ്റുകൾക്ക് ഡിപൻഡൻസികളൊന്നും ആവശ്യമില്ല. കമാൻഡ് ഷെൽ ലോഡ് ചെയ്യുമ്പോൾ അവ പ്രവർത്തനക്ഷമമാക്കുക മാത്രമാണ് നിങ്ങൾ ചെയ്യേണ്ടത്.

നിങ്ങളിലേക്ക് ഒരു വരി ചേർത്തുകൊണ്ട് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും ~/.zshrc ഫയൽ:

source <(kubectl completion zsh)

നിങ്ങൾക്ക് ഒരു പിശക് ലഭിക്കുകയാണെങ്കിൽ not found: compdef നിങ്ങളുടെ ഷെൽ പുനരാരംഭിച്ച ശേഷം, നിങ്ങൾ ബിൽറ്റ്ഇൻ ഫംഗ്ഷൻ പ്രവർത്തനക്ഷമമാക്കേണ്ടതുണ്ട് compdef. നിങ്ങളുടെ ഫയലിന്റെ തുടക്കത്തിൽ ചേർത്തുകൊണ്ട് നിങ്ങൾക്ക് ഇത് പ്രവർത്തനക്ഷമമാക്കാം ~/.zshrc ഇനിപ്പറയുന്നവ:

autoload -Uz compinit
compinit

2. റിസോഴ്സ് സ്പെസിഫിക്കേഷനുകൾ വേഗത്തിൽ കാണുക

നിങ്ങൾ YAML റിസോഴ്സ് നിർവചനങ്ങൾ സൃഷ്ടിക്കുമ്പോൾ, ആ ഉറവിടങ്ങൾക്കായുള്ള ഫീൽഡുകളും അവയുടെ അർത്ഥവും നിങ്ങൾ അറിയേണ്ടതുണ്ട്. ഈ വിവരങ്ങൾക്കായി തിരയാനുള്ള ഒരിടം API റഫറൻസിലാണ്, അതിൽ എല്ലാ വിഭവങ്ങൾക്കും പൂർണ്ണമായ സ്പെസിഫിക്കേഷനുകൾ അടങ്ങിയിരിക്കുന്നു.

എന്നിരുന്നാലും, നിങ്ങൾക്ക് എന്തെങ്കിലും തിരയേണ്ടിവരുമ്പോഴെല്ലാം വെബ് ബ്രൗസറിലേക്ക് മാറുന്നത് അസൗകര്യമാണ്. അതിനാൽ kubectl കമാൻഡ് നൽകുന്നു kubectl explain, ഇത് നിങ്ങളുടെ ടെർമിനലിൽ തന്നെയുള്ള എല്ലാ വിഭവങ്ങളുടെയും സ്പെസിഫിക്കേഷനുകൾ കാണിക്കുന്നു.

കമാൻഡ് ഫോർമാറ്റ് ഇപ്രകാരമാണ്:

$ kubectl explain resource[.field]...

അഭ്യർത്ഥിച്ച ഉറവിടത്തിന്റെ അല്ലെങ്കിൽ ഫീൽഡിന്റെ സ്പെസിഫിക്കേഷൻ കമാൻഡ് ഔട്ട്പുട്ട് ചെയ്യും. പ്രദർശിപ്പിച്ചിരിക്കുന്ന വിവരങ്ങൾ API മാനുവലിൽ അടങ്ങിയിരിക്കുന്ന വിവരങ്ങൾക്ക് സമാനമാണ്.

സ്ഥിരമായി kubectl explain വയലുകളുടെ നെസ്റ്റിംഗിന്റെ ആദ്യ തലം മാത്രം കാണിക്കുന്നു.

അത് എങ്ങനെയുണ്ടെന്ന് കാണുക ഇവിടെ ആകാം.

നിങ്ങൾ ഓപ്ഷൻ ചേർത്താൽ മുഴുവൻ ട്രീയും പ്രദർശിപ്പിക്കാൻ കഴിയും --recursive:

$ kubectl explain deployment.spec --recursive

ഏത് ഉറവിടങ്ങളാണ് ആവശ്യമെന്ന് നിങ്ങൾക്ക് കൃത്യമായി അറിയില്ലെങ്കിൽ, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അവയെല്ലാം പ്രദർശിപ്പിക്കാൻ കഴിയും:

$ kubectl api-resources

ഈ കമാൻഡ് റിസോഴ്സ് പേരുകൾ ബഹുവചന രൂപത്തിൽ പ്രദർശിപ്പിക്കുന്നു, ഉദാ. deployments പകരം deployment. ഇത് ഹ്രസ്വ നാമവും പ്രദർശിപ്പിക്കുന്നു, ഉദാഹരണത്തിന് deploy, അത് ഉള്ള വിഭവങ്ങൾക്ക്. ഈ വ്യത്യാസങ്ങളെക്കുറിച്ച് വിഷമിക്കേണ്ട. ഈ പേരിടൽ ഓപ്ഷനുകളെല്ലാം kubectl-ന് തുല്യമാണ്. അതായത്, നിങ്ങൾക്ക് അവയിലേതെങ്കിലും ഉപയോഗിക്കാം kubectl explain.

ഇനിപ്പറയുന്ന എല്ലാ കമാൻഡുകളും തുല്യമാണ്:

$ kubectl explain deployments.spec
# или
$ kubectl explain deployment.spec
# или        
$ kubectl explain deploy.spec

3. ഒരു ഇഷ്‌ടാനുസൃത കോളം ഔട്ട്പുട്ട് ഫോർമാറ്റ് ഉപയോഗിക്കുക

ഡിഫോൾട്ട് കമാൻഡ് ഔട്ട്പുട്ട് ഫോർമാറ്റ് kubectl get:

$ kubectl get pods
NAME                     READY    STATUS    RESTARTS  AGE
engine-544b6b6467-22qr6   1/1     Running     0       78d
engine-544b6b6467-lw5t8   1/1     Running     0       78d
engine-544b6b6467-tvgmg   1/1     Running     0       78d
web-ui-6db964458-8pdw4    1/1     Running     0       78d

ഈ ഫോർമാറ്റ് സൗകര്യപ്രദമാണ്, എന്നാൽ അതിൽ പരിമിതമായ വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. പൂർണ്ണമായ റിസോഴ്സ് ഡെഫനിഷൻ ഫോർമാറ്റുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, കുറച്ച് ഫീൽഡുകൾ മാത്രമേ ഇവിടെ പ്രദർശിപ്പിക്കൂ.

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

ഒരു ഇഷ്‌ടാനുസൃത ഫോർമാറ്റിന്റെ ഉപയോഗം ഓപ്ഷനുകൾ ഉപയോഗിച്ച് നിർണ്ണയിക്കപ്പെടുന്നു:

-o custom-columns=<header>:<jsonpath>[,<header>:<jsonpath>]...

നിങ്ങൾക്ക് ഓരോ ഔട്ട്പുട്ട് കോളവും ഒരു ജോഡിയായി നിർവചിക്കാം <header>:<jsonpath>എവിടെ <header> കോളത്തിന്റെ പേര്, ഒപ്പം <jsonpath> - ഒരു റിസോഴ്സ് ഫീൽഡ് നിർവചിക്കുന്ന ഒരു പദപ്രയോഗം.

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

$ kubectl get pods -o custom-columns='NAME:metadata.name'

NAME
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4

ഔട്ട്‌പുട്ടിൽ പോഡുകളുടെ പേരുകളുള്ള ഒരു കോളം അടങ്ങിയിരിക്കുന്നു.

ഓപ്ഷൻ എക്സ്പ്രഷൻ ഫീൽഡിൽ നിന്ന് പോഡ് പേരുകൾ തിരഞ്ഞെടുക്കുന്നു metadata.name. ചൈൽഡ് നെയിം ഫീൽഡിൽ പോഡിന്റെ പേര് നിർവചിച്ചിരിക്കുന്നതിനാലാണിത് metadata പോഡിന്റെ വിഭവ വിവരണത്തിൽ. കൂടുതൽ വിശദാംശങ്ങൾ കണ്ടെത്താനാകും API ഗൈഡ് അല്ലെങ്കിൽ കമാൻഡ് ടൈപ്പ് ചെയ്യുക kubectl explain pod.metadata.name.

ഇപ്പോൾ നിങ്ങൾക്ക് ഔട്ട്‌പുട്ടിലേക്ക് ഒരു അധിക കോളം ചേർക്കണമെന്ന് പറയാം, ഉദാഹരണത്തിന് ഓരോ പോഡും പ്രവർത്തിക്കുന്ന നോഡ് കാണിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് ഇഷ്‌ടാനുസൃത നിരകളുടെ ഓപ്‌ഷനിലേക്ക് ഉചിതമായ കോളം സ്പെസിഫിക്കേഷൻ ചേർക്കാം:

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,NODE:spec.nodeName'

NAME                       NODE
engine-544b6b6467-22qr6    ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8    ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg    ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4     ip-10-0-118-34.ec2.internal

എക്സ്പ്രഷൻ നോഡിന്റെ പേര് തിരഞ്ഞെടുക്കുന്നു spec.nodeName - ഒരു നോഡിലേക്ക് ഒരു പോഡ് നൽകുമ്പോൾ, അതിന്റെ പേര് ഫീൽഡിൽ എഴുതപ്പെടും spec.nodeName പോഡ് റിസോഴ്സ് സ്പെസിഫിക്കേഷൻ. കൂടുതൽ വിശദമായ വിവരങ്ങൾ ഔട്ട്പുട്ടിൽ കാണാം kubectl explain pod.spec.nodeName.

Kubernetes റിസോഴ്സ് ഫീൽഡുകൾ കേസ് സെൻസിറ്റീവ് ആണെന്ന കാര്യം ശ്രദ്ധിക്കുക.

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

എന്നാൽ ആദ്യം, നമുക്ക് ഫീൽഡ് തിരഞ്ഞെടുക്കൽ എക്സ്പ്രഷനുകൾ സൂക്ഷ്മമായി പരിശോധിക്കാം.

JSONPath എക്സ്പ്രഷനുകൾ

റിസോഴ്സ് ഫീൽഡുകൾ തിരഞ്ഞെടുക്കുന്നതിനുള്ള എക്സ്പ്രഷനുകൾ അടിസ്ഥാനമാക്കിയുള്ളതാണ് JSONപാത്ത്.

JSON പ്രമാണങ്ങളിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കുന്നതിനുള്ള ഒരു ഭാഷയാണ് JSONPath. ഒരൊറ്റ ഫീൽഡ് തിരഞ്ഞെടുക്കുന്നത് JSONPath-ന്റെ ഏറ്റവും ലളിതമായ ഉപയോഗമാണ്. അദ്ദേഹത്തിന് ധാരാളം ഉണ്ട് കൂടുതൽ സാധ്യതകൾ, സെലക്ടറുകൾ, ഫിൽട്ടറുകൾ തുടങ്ങിയവ ഉൾപ്പെടെ.

പരിമിതമായ എണ്ണം JSONPath സവിശേഷതകളെ Kubectl വിശദീകരിക്കുന്നു. അവയുടെ ഉപയോഗത്തിന്റെ സാധ്യതകളും ഉദാഹരണങ്ങളും ചുവടെ വിവരിച്ചിരിക്കുന്നു:

# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'

[] ഓപ്പറേറ്റർ പ്രത്യേകിച്ചും പ്രധാനമാണ്. പല കുബെർനെറ്റസ് റിസോഴ്‌സ് ഫീൽഡുകളും ലിസ്റ്റുകളാണ്, ആ ലിസ്റ്റുകളിലെ അംഗങ്ങളെ തിരഞ്ഞെടുക്കാൻ ഈ ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു ലിസ്റ്റിലെ എല്ലാ ഘടകങ്ങളും തിരഞ്ഞെടുക്കുന്നതിന് [*] പോലുള്ള ഒരു വൈൽഡ്കാർഡിനൊപ്പം ഇത് പലപ്പോഴും ഉപയോഗിക്കാറുണ്ട്.

ആപ്ലിക്കേഷൻ ഉദാഹരണങ്ങൾ

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

1. പോഡുകൾക്കുള്ള കണ്ടെയ്നർ ചിത്രങ്ങൾ പ്രദർശിപ്പിക്കുന്നു:

   $ kubectl get pods 
     -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'
   
   NAME                        IMAGES
   engine-544b6b6467-22qr6     rabbitmq:3.7.8-management,nginx
   engine-544b6b6467-lw5t8     rabbitmq:3.7.8-management,nginx
   engine-544b6b6467-tvgmg     rabbitmq:3.7.8-management,nginx
   web-ui-6db964458-8pdw4      wordpress

   ഈ കമാൻഡ് ഓരോ പോഡിനും കണ്ടെയ്നർ ഇമേജ് പേരുകൾ പ്രദർശിപ്പിക്കുന്നു.

   ഒരു പോഡിൽ നിരവധി കണ്ടെയ്‌നറുകൾ അടങ്ങിയിരിക്കാമെന്ന് ഓർമ്മിക്കുക, തുടർന്ന് ചിത്രത്തിന്റെ പേരുകൾ കോമകളാൽ വേർതിരിച്ച് ഒരു വരിയിൽ പ്രദർശിപ്പിക്കും.

2. നോഡ് ലഭ്യത സോണുകൾ പ്രദർശിപ്പിക്കുന്നു:

   $ kubectl get nodes 
     -o 
   custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain.beta.kubernetes.io/zone'
   
   NAME                          ZONE
   ip-10-0-118-34.ec2.internal   us-east-1b
   ip-10-0-36-80.ec2.internal    us-east-1a
   ip-10-0-80-67.ec2.internal    us-east-1b

   നിങ്ങളുടെ ക്ലസ്റ്റർ ഒരു പൊതു ക്ലൗഡിൽ ഹോസ്റ്റ് ചെയ്തിട്ടുണ്ടെങ്കിൽ ഈ കമാൻഡ് ഉപയോഗപ്രദമാണ്. ഇത് ഓരോ നോഡിനും ലഭ്യത മേഖല പ്രദർശിപ്പിക്കുന്നു.

   ലഭ്യത മേഖല എന്നത് ഒരു ഭൂമിശാസ്ത്ര മേഖലയിലേക്ക് പകർപ്പെടുക്കൽ മേഖലയെ പരിമിതപ്പെടുത്തുന്ന ഒരു ക്ലൗഡ് ആശയമാണ്.

   ഓരോ നോഡിനും ലഭ്യത സോണുകൾ ഒരു പ്രത്യേക ലേബൽ വഴി ലഭിക്കും - failure-domain.beta.kubernetes.io/zone. ഒരു പൊതു ക്ലൗഡിലാണ് ക്ലസ്റ്റർ പ്രവർത്തിക്കുന്നതെങ്കിൽ, ഈ ലേബൽ സ്വയമേവ സൃഷ്‌ടിക്കുകയും ഓരോ നോഡിനുമുള്ള ലഭ്യത സോണുകളുടെ പേരുകൾ കൊണ്ട് നിറയ്ക്കുകയും ചെയ്യും.

   ലേബലുകൾ കുബെർനെറ്റസ് റിസോഴ്സ് സ്പെസിഫിക്കേഷന്റെ ഭാഗമല്ല, അതിനാൽ അവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ നിങ്ങൾക്ക് കണ്ടെത്താനാകില്ല API ഗൈഡ്. എന്നിരുന്നാലും, YAML അല്ലെങ്കിൽ JSON ഫോർമാറ്റിലുള്ള നോഡുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ നിങ്ങൾ അഭ്യർത്ഥിക്കുകയാണെങ്കിൽ അവ (മറ്റേതൊരു ലേബലുകളും പോലെ) കാണാൻ കഴിയും:

   $ kubectl get nodes -o yaml
   # или
   $ kubectl get nodes -o json

   റിസോഴ്‌സ് സ്പെസിഫിക്കേഷനുകൾ പഠിക്കുന്നതിനു പുറമേ, വിഭവങ്ങളെ കുറിച്ച് കൂടുതലറിയാനുള്ള മികച്ച മാർഗമാണിത്.

4. ക്ലസ്റ്ററുകൾക്കും നെയിംസ്‌പെയ്‌സുകൾക്കുമിടയിൽ എളുപ്പത്തിൽ മാറുക

Kubectl, Kubernetes API-ലേക്ക് ഒരു അഭ്യർത്ഥന നടത്തുമ്പോൾ, കണക്ഷന് ആവശ്യമായ എല്ലാ പാരാമീറ്ററുകളും ലഭിക്കുന്നതിന് അത് ആദ്യം kubeconfig ഫയൽ വായിക്കുന്നു.

സ്ഥിരസ്ഥിതിയായി kubeconfig ഫയൽ ആണ് ~/.kube/config. സാധാരണയായി ഈ ഫയൽ ഒരു പ്രത്യേക കമാൻഡ് ഉപയോഗിച്ച് സൃഷ്ടിക്കുകയോ അപ്ഡേറ്റ് ചെയ്യുകയോ ചെയ്യുന്നു.

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

ഒരു ക്ലസ്റ്ററിനുള്ളിൽ, നിങ്ങൾക്ക് ഒന്നിലധികം നെയിംസ്പേസുകൾ സൃഷ്ടിക്കാൻ കഴിയും-ഒരു ഫിസിക്കൽ ക്ലസ്റ്ററിനുള്ളിൽ ഒരു തരം വെർച്വൽ ക്ലസ്റ്റർ. kubeconfig ഫയലിനെ അടിസ്ഥാനമാക്കി ഏത് നെയിംസ്പേസ് ഉപയോഗിക്കണമെന്ന് Kubectl നിർണ്ണയിക്കുന്നു. ഇതിനർത്ഥം kubectl കമാൻഡിനോട് എന്ത് നെയിംസ്പേസിൽ പ്രവർത്തിക്കണമെന്ന് പറയുന്നതിനുള്ള ഒരു മാർഗവും നിങ്ങൾക്കാവശ്യമാണ്.

ഈ അധ്യായത്തിൽ ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും അത് എങ്ങനെ ഫലപ്രദമായി പ്രവർത്തിക്കാമെന്നും ഞങ്ങൾ വിശദീകരിക്കും.

KUBECONFIG എൻവയോൺമെന്റ് വേരിയബിളിൽ നിങ്ങൾക്ക് ഒന്നിലധികം kubeconfig ഫയലുകൾ ലിസ്റ്റ് ചെയ്‌തിരിക്കാമെന്നത് ശ്രദ്ധിക്കുക. ഈ സാഹചര്യത്തിൽ, ഈ ഫയലുകളെല്ലാം റൺടൈമിൽ ഒരു പൊതു കോൺഫിഗറേഷനായി സംയോജിപ്പിക്കും. പാരാമീറ്റർ ഉപയോഗിച്ച് kubectl പ്രവർത്തിപ്പിച്ച് നിങ്ങൾക്ക് സ്ഥിരസ്ഥിതി kubeconfig ഫയൽ മാറ്റാനും കഴിയും --kubeconfig. നോക്കൂ ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ.

kubeconfig ഫയലുകൾ

kubeconfig ഫയലിൽ കൃത്യമായി എന്താണ് അടങ്ങിയിരിക്കുന്നതെന്ന് നോക്കാം:

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, kubeconfig ഫയലിൽ ഒരു കൂട്ടം സന്ദർഭങ്ങൾ അടങ്ങിയിരിക്കുന്നു. സന്ദർഭം മൂന്ന് ഘടകങ്ങൾ ഉൾക്കൊള്ളുന്നു:

• ക്ലസ്റ്റർ - ക്ലസ്റ്റർ സെർവറിന്റെ API URL.
• ക്ലസ്റ്ററിലെ ഉപയോക്താവ് - ഉപയോക്തൃ പ്രാമാണീകരണ ക്രെഡൻഷ്യലുകൾ.
• നെയിംസ്പേസ് - ക്ലസ്റ്ററിൽ ചേരുമ്പോൾ ഉപയോഗിക്കുന്ന നെയിംസ്പേസ്.

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

ഏത് സമയത്തും, സന്ദർഭങ്ങളിൽ ഒന്ന് നിലവിലുള്ളതാണ്:

kubectl ഒരു കോൺഫിഗറേഷൻ ഫയൽ വായിക്കുമ്പോൾ, അത് എല്ലായ്പ്പോഴും നിലവിലെ സന്ദർഭത്തിൽ നിന്ന് വിവരങ്ങൾ എടുക്കുന്നു. മുകളിലെ ഉദാഹരണത്തിൽ, kubectl Hare ക്ലസ്റ്ററുമായി ബന്ധിപ്പിക്കും.

അതനുസരിച്ച്, മറ്റൊരു ക്ലസ്റ്ററിലേക്ക് മാറുന്നതിന്, നിങ്ങൾ kubeconfig ഫയലിലെ നിലവിലെ സന്ദർഭം മാറ്റേണ്ടതുണ്ട്:

ഇപ്പോൾ kubectl ഫോക്സ് ക്ലസ്റ്ററുമായി ബന്ധിപ്പിക്കും.

ഒരേ ക്ലസ്റ്ററിലെ മറ്റൊരു നെയിംസ്‌പെയ്‌സിലേക്ക് മാറുന്നതിന്, നിലവിലെ സന്ദർഭത്തിനായി നെയിംസ്‌പെയ്‌സ് എലമെന്റിന്റെ മൂല്യം നിങ്ങൾ മാറ്റേണ്ടതുണ്ട്:

മുകളിലെ ഉദാഹരണത്തിൽ, kubectl ഫോക്സ് ക്ലസ്റ്ററിന്റെ പ്രോഡ് നെയിംസ്പേസ് ഉപയോഗിക്കും (മുമ്പ് ടെസ്റ്റ് നെയിംസ്പേസ് സജ്ജീകരിച്ചിരുന്നു).

kubectl ഓപ്‌ഷനുകളും നൽകുന്നു എന്നത് ശ്രദ്ധിക്കുക --cluster, --user, --namespace и --context, kubeconfig-ൽ സജ്ജീകരിച്ചിരിക്കുന്നത് പരിഗണിക്കാതെ തന്നെ വ്യക്തിഗത ഘടകങ്ങളും നിലവിലെ സന്ദർഭവും തിരുത്തിയെഴുതാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. നോക്കൂ kubectl options.

സിദ്ധാന്തത്തിൽ, നിങ്ങൾക്ക് kubeconfig-ലെ ക്രമീകരണങ്ങൾ സ്വമേധയാ മാറ്റാൻ കഴിയും. എന്നാൽ അത് അസൗകര്യമാണ്. ഈ പ്രവർത്തനങ്ങൾ ലളിതമാക്കുന്നതിന്, പാരാമീറ്ററുകൾ സ്വയമേവ മാറ്റാൻ നിങ്ങളെ അനുവദിക്കുന്ന വിവിധ യൂട്ടിലിറ്റികൾ ഉണ്ട്.

kubectx ഉപയോഗിക്കുക

ക്ലസ്റ്ററുകൾക്കും നെയിംസ്‌പെയ്‌സുകൾക്കുമിടയിൽ മാറുന്നതിനുള്ള വളരെ ജനപ്രിയമായ ഒരു യൂട്ടിലിറ്റി.

യൂട്ടിലിറ്റി കമാൻഡുകൾ നൽകുന്നു kubectx и kubens നിലവിലെ സന്ദർഭവും നെയിംസ്പേസും യഥാക്രമം മാറ്റാൻ.

സൂചിപ്പിച്ചതുപോലെ, നിലവിലെ സന്ദർഭം മാറ്റുന്നത് അർത്ഥമാക്കുന്നത് നിങ്ങൾക്ക് ഒരു ക്ലസ്റ്ററിന് ഒരു സന്ദർഭം മാത്രമേ ഉള്ളൂവെങ്കിൽ ക്ലസ്റ്റർ മാറ്റുക എന്നാണ്.

ഈ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

അടിസ്ഥാനപരമായി, ഈ കമാൻഡുകൾ മുകളിൽ വിവരിച്ചതുപോലെ kubeconfig ഫയൽ എഡിറ്റുചെയ്യുന്നു.

ഇൻസ്റ്റാൾ ചെയ്യാൻ kubectx, എന്നതിലെ നിർദ്ദേശങ്ങൾ പാലിക്കുക ഗിത്തബ്.

രണ്ട് കമാൻഡുകളും സന്ദർഭത്തിന്റെയും നെയിംസ്‌പെയ്‌സിന്റെയും പേരുകളുടെ സ്വയമേവ പൂർത്തീകരണത്തെ പിന്തുണയ്ക്കുന്നു, ഇത് അവ പൂർണ്ണമായും ടൈപ്പുചെയ്യേണ്ടതിന്റെ ആവശ്യകത ഇല്ലാതാക്കുന്നു. യാന്ത്രിക പൂർത്തീകരണം സജ്ജീകരിക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ ഇവിടെ.

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

ഷെൽ അപരനാമങ്ങൾ ഉപയോഗിക്കുന്നു

നിലവിലെ സന്ദർഭവും നെയിംസ്പേസും മാറ്റാൻ നിങ്ങൾക്ക് പ്രത്യേക ഉപകരണങ്ങൾ ആവശ്യമില്ല, കാരണം kubectl ഇതിനുള്ള കമാൻഡുകളും നൽകുന്നു. അതെ, ടീം kubectl config kubeconfig ഫയലുകൾ എഡിറ്റ് ചെയ്യുന്നതിനുള്ള ഉപകമാൻഡുകൾ നൽകുന്നു.

അവയിൽ ചിലത് ഇതാ:

• kubectl config get-contexts: എല്ലാ സന്ദർഭങ്ങളും പ്രദർശിപ്പിക്കുക;
• kubectl config current-context: നിലവിലെ സന്ദർഭം നേടുക;
• kubectl config use-context: നിലവിലെ സന്ദർഭം മാറ്റുക;
• kubectl config set-context: സന്ദർഭ ഘടകം മാറ്റുക.

എന്നിരുന്നാലും, ഈ കമാൻഡുകൾ നേരിട്ട് ഉപയോഗിക്കുന്നത് വളരെ സൗകര്യപ്രദമല്ല, കാരണം അവ ദൈർഘ്യമേറിയതാണ്. നിർവ്വഹിക്കാൻ എളുപ്പമുള്ള ഷെൽ അപരനാമങ്ങൾ നിങ്ങൾക്ക് ഉണ്ടാക്കാം.

kubectx-ന് സമാനമായ പ്രവർത്തനക്ഷമത നൽകുന്ന ഈ കമാൻഡുകളെ അടിസ്ഥാനമാക്കി ഞാൻ ഒരു കൂട്ടം അപരനാമങ്ങൾ സൃഷ്ടിച്ചു. ഇവിടെ നിങ്ങൾക്ക് അവ പ്രവർത്തനത്തിൽ കാണാൻ കഴിയും:

ഒരു ഇന്ററാക്ടീവ് ഫ്രീ ലുക്ക്അപ്പ് ഇന്റർഫേസ് (kubectx-ന്റെ ഇന്ററാക്ടീവ് മോഡ് പോലെ) നൽകാൻ അപരനാമങ്ങൾ fzf ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. ഇതിനർത്ഥം നിങ്ങൾക്ക് ആവശ്യമുണ്ട് എന്നാണ് fzf ഇൻസ്റ്റാൾ ചെയ്യുകഈ അപരനാമങ്ങൾ ഉപയോഗിക്കാൻ.

അപരനാമങ്ങളുടെ നിർവചനങ്ങൾ ഇതാ:

# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/  /;|^  $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'

# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print $5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/|  |;|^  $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'

ഈ അപരനാമങ്ങൾ സജ്ജീകരിക്കുന്നതിന് നിങ്ങളുടെ ഫയലിലേക്ക് മുകളിലുള്ള നിർവചനങ്ങൾ ചേർക്കേണ്ടതുണ്ട് ~/.bashrc അഥവാ ~/.zshrc നിങ്ങളുടെ ഷെൽ റീബൂട്ട് ചെയ്യുക.

പ്ലഗിനുകൾ ഉപയോഗിക്കുന്നു

അടിസ്ഥാന കമാൻഡുകൾ പോലെ തന്നെ എക്സിക്യൂട്ട് ചെയ്യുന്ന പ്ലഗിനുകൾ ലോഡ് ചെയ്യാൻ Kubectl നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് kubectl-foo പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്ത് കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്തുകൊണ്ട് പ്രവർത്തിപ്പിക്കാം. kubectl foo.

ഈ രീതിയിൽ സന്ദർഭവും നെയിംസ്പേസും മാറ്റുന്നത് സൗകര്യപ്രദമായിരിക്കും, ഉദാഹരണത്തിന് പ്രവർത്തിപ്പിക്കുക kubectl ctx സന്ദർഭം മാറ്റാൻ ഒപ്പം kubectl ns നെയിംസ്പേസ് മാറ്റാൻ.

ഇത് ചെയ്യുന്ന രണ്ട് പ്ലഗിനുകൾ ഞാൻ എഴുതിയിട്ടുണ്ട്:

• kubectl-ctx
• kubectl-ns

പ്ലഗിന്നുകളുടെ പ്രവർത്തനം മുമ്പത്തെ വിഭാഗത്തിൽ നിന്നുള്ള അപരനാമങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.

അവ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നത് ഇതാ:

ഒരു ഇന്ററാക്ടീവ് ഫ്രീ സെർച്ച് ഇന്റർഫേസ് (kubectx ന്റെ ഇന്ററാക്ടീവ് മോഡ് പോലെ) നൽകുന്നതിന് പ്ലഗിനുകൾ fzf ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. ഇതിനർത്ഥം നിങ്ങൾക്ക് ആവശ്യമുണ്ട് എന്നാണ് fzf ഇൻസ്റ്റാൾ ചെയ്യുകഈ അപരനാമങ്ങൾ ഉപയോഗിക്കാൻ.

പ്ലഗിനുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ, പേരുള്ള ഷെൽ സ്ക്രിപ്റ്റുകൾ നിങ്ങൾ ഡൗൺലോഡ് ചെയ്യേണ്ടതുണ്ട് kubectl-ctx и kubectl-ns നിങ്ങളുടെ PATH വേരിയബിളിലെ ഏതെങ്കിലും ഡയറക്‌ടറിയിലേക്ക് അവ എക്‌സിക്യൂട്ടബിൾ ആക്കുക ഉദാ. chmod +x. ഇതിനുശേഷം ഉടൻ തന്നെ നിങ്ങൾക്ക് ഉപയോഗിക്കാൻ കഴിയും kubectl ctx и kubectl ns.

5. സ്വയമേവയുള്ള ഇൻപുട്ട് കുറയ്ക്കുക

ഇൻപുട്ട് വേഗത്തിലാക്കാനുള്ള നല്ലൊരു മാർഗമാണ് ഷെൽ അപരനാമങ്ങൾ. പദ്ധതി kubectl-അപരനാമം അടിസ്ഥാന kubectl കമാൻഡുകൾക്കായി ഏകദേശം 800 കുറുക്കുവഴികൾ അടങ്ങിയിരിക്കുന്നു.

നിങ്ങൾ ആശ്ചര്യപ്പെട്ടേക്കാം - 800 അപരനാമങ്ങൾ നിങ്ങൾ എങ്ങനെ ഓർക്കും? എന്നാൽ നിങ്ങൾ അവയെല്ലാം ഓർമ്മിക്കേണ്ടതില്ല, കാരണം അവ ഒരു ലളിതമായ സ്കീം അനുസരിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത്, അത് ചുവടെ നൽകിയിരിക്കുന്നു:

ഉദാഹരണത്തിന്:

1. kgpooyaml - kubectl കായ്കൾ ഒയാമൽ ലഭിക്കും
2. ksysgsvcw — kubectl -n kube-system get svc w
3. ksysrmcm -kubectl -n kube-സിസ്റ്റം rm സെ.മീ
4. kgdepallsl - kubectl എല്ലാ sl വിന്യാസവും നേടുക

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, അപരനാമങ്ങൾ ഘടകങ്ങൾ കൊണ്ടാണ് നിർമ്മിച്ചിരിക്കുന്നത്, അവ ഓരോന്നും kubectl കമാൻഡിന്റെ ഒരു പ്രത്യേക ഘടകത്തെ പ്രതിനിധീകരിക്കുന്നു. ഓരോ അപരനാമത്തിനും അടിസ്ഥാന കമാൻഡ്, ഓപ്പറേഷൻ, റിസോഴ്സ് എന്നിവയ്ക്കായി ഒരു ഘടകവും പരാമീറ്ററുകൾക്കായി ഒന്നിലധികം ഘടകങ്ങളും ഉണ്ടായിരിക്കാം. മുകളിലുള്ള ഡയഗ്രം അനുസരിച്ച് നിങ്ങൾ ഈ ഘടകങ്ങൾ ഇടത്തുനിന്ന് വലത്തോട്ട് "പോപ്പുലേറ്റ്" ചെയ്യുക.

നിലവിലെ വിശദമായ ഡയഗ്രം ഇവിടെയാണ് സാമൂഹികം. അവിടെയും കണ്ടെത്താം അപരനാമങ്ങളുടെ മുഴുവൻ പട്ടിക.

ഉദാഹരണത്തിന്, kgpooyamlall എന്ന അപരനാമം ആജ്ഞയ്ക്ക് തുല്യമാണ് kubectl get pods -o yaml --all-namespaces.

ഓപ്ഷനുകളുടെ ആപേക്ഷിക ക്രമം പ്രധാനമല്ല: കമാൻഡ് kgpooyamlall കമാൻഡിന് തുല്യമാണ് kgpoalloyaml.

നിങ്ങൾ എല്ലാ ഘടകങ്ങളും അപരനാമങ്ങളായി ഉപയോഗിക്കേണ്ടതില്ല. ഉദാഹരണത്തിന് k, kg, klo, ksys, kgpo ഉപയോഗിക്കാനും കഴിയും. മാത്രമല്ല, കമാൻഡ് ലൈനിൽ നിങ്ങൾക്ക് അപരനാമങ്ങളും സാധാരണ കമാൻഡുകളും ഓപ്ഷനുകളും സംയോജിപ്പിക്കാൻ കഴിയും:

ഉദാഹരണത്തിന്:

1. പകരം kubectl proxy നിങ്ങൾക്ക് എഴുതാം k proxy.
2. പകരം kubectl get roles നിങ്ങൾക്ക് എഴുതാം kg roles (റോൾസ് റിസോഴ്സിന് നിലവിൽ അപരനാമമില്ല).
3. ഒരു നിർദ്ദിഷ്ട പോഡിനായി ഡാറ്റ ലഭിക്കുന്നതിന്, നിങ്ങൾക്ക് കമാൻഡ് ഉപയോഗിക്കാം kgpo my-pod — kubectl get pod my-pod.

ചില അപരനാമങ്ങൾക്ക് ഒരു കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് ആവശ്യമാണെന്ന് ദയവായി ശ്രദ്ധിക്കുക. ഉദാഹരണത്തിന്, അപരനാമം kgpol അർത്ഥം kubectl get pods -l. ഓപ്ഷൻ -l ഒരു വാദം ആവശ്യമാണ് - ഒരു ലേബൽ സ്പെസിഫിക്കേഷൻ. നിങ്ങൾ ഒരു അപരനാമം ഉപയോഗിച്ചാൽ അത് ഇതുപോലെ കാണപ്പെടും kgpol app=ui.

ചില അപരനാമങ്ങൾക്ക് ആർഗ്യുമെന്റുകൾ ആവശ്യമുള്ളതിനാൽ, a, f, l എന്നിവ അവസാനമായി ഉപയോഗിക്കേണ്ടതാണ്.

പൊതുവേ, നിങ്ങൾ ഈ സ്കീമിന്റെ ഹാംഗ് ലഭിച്ചുകഴിഞ്ഞാൽ, നിങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കമാൻഡുകളിൽ നിന്ന് നിങ്ങൾക്ക് അവബോധപൂർവ്വം അപരനാമങ്ങൾ ലഭിക്കുകയും ധാരാളം ടൈപ്പിംഗ് സമയം ലാഭിക്കുകയും ചെയ്യാം.

ഇൻസ്റ്റലേഷൻ

kubectl-aliases ഇൻസ്റ്റാൾ ചെയ്യാൻ, നിങ്ങൾ ഫയൽ ഡൗൺലോഡ് ചെയ്യേണ്ടതുണ്ട് .kubectl_aliases GitHub-ൽ നിന്ന് ഫയലിൽ ഉൾപ്പെടുത്തുക ~/.bashrc അഥവാ ~/.zshrc:

source ~/.kubectl_aliases

സ്വയം പൂർത്തീകരണം

ഞങ്ങൾ മുമ്പ് പറഞ്ഞതുപോലെ, കമാൻഡ് ലൈനിലെ അപരനാമത്തിലേക്ക് നിങ്ങൾ പലപ്പോഴും അധിക വാക്കുകൾ ചേർക്കുന്നു. ഉദാഹരണത്തിന്:

$ kgpooyaml test-pod-d4b77b989

നിങ്ങൾ kubectl കമാൻഡ് പൂർത്തീകരണം ഉപയോഗിക്കുകയാണെങ്കിൽ, റിസോഴ്സ് പേരുകൾ പോലെയുള്ള കാര്യങ്ങൾക്കായി നിങ്ങൾ സ്വയം പൂർത്തീകരണം ഉപയോഗിച്ചിരിക്കാം. എന്നാൽ അപരനാമങ്ങൾ ഉപയോഗിക്കുമ്പോൾ ഇത് ചെയ്യാൻ കഴിയുമോ?

ഇത് വളരെ പ്രധാനപ്പെട്ട ഒരു ചോദ്യമാണ്, കാരണം യാന്ത്രിക പൂർത്തീകരണം പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, അപരനാമങ്ങളുടെ ചില നേട്ടങ്ങൾ നിങ്ങൾക്ക് നഷ്‌ടമാകും.

ഉത്തരം നിങ്ങൾ ഉപയോഗിക്കുന്ന ഷെല്ലിനെ ആശ്രയിച്ചിരിക്കുന്നു:

1. Zsh-ന്, അപരനാമം പൂർത്തീകരണം ബോക്‌സിന് പുറത്ത് പ്രവർത്തിക്കുന്നു.
2. ബാഷിനെ സംബന്ധിച്ചിടത്തോളം, നിർഭാഗ്യവശാൽ, പ്രവർത്തിക്കാൻ സ്വയം പൂർത്തീകരണം ലഭിക്കുന്നതിന് കുറച്ച് ജോലികൾ ആവശ്യമാണ്.

ബാഷിലെ അപരനാമങ്ങൾക്കായി സ്വയം പൂർത്തീകരണം പ്രവർത്തനക്ഷമമാക്കുന്നു

ബാഷിന്റെ പ്രശ്നം അത് അപരനാമം പൂർത്തിയാക്കാൻ ശ്രമിക്കുന്നു എന്നതാണ് (നിങ്ങൾ ടാബ് അമർത്തുമ്പോഴെല്ലാം) അപരനാമം സൂചിപ്പിക്കുന്ന കമാൻഡല്ല (ഉദാഹരണത്തിന് Zsh ചെയ്യുന്നത് പോലെ). എല്ലാ 800 അപരനാമങ്ങൾക്കും നിങ്ങൾക്ക് പൂർത്തീകരണ സ്ക്രിപ്റ്റുകൾ ഇല്ലാത്തതിനാൽ, സ്വയമേവ പൂർത്തീകരണം പ്രവർത്തിക്കുന്നില്ല.

പദ്ധതി പൂർണ്ണ-അപരനാമം ഈ പ്രശ്നത്തിന് ഒരു പൊതു പരിഹാരം നൽകുന്നു. ഇത് അപരനാമങ്ങൾക്കുള്ള പൂർത്തീകരണ സംവിധാനവുമായി ബന്ധിപ്പിക്കുന്നു, അപരനാമം ഒരു കമാൻഡിലേക്ക് ആന്തരികമായി വികസിപ്പിക്കുന്നു, കൂടാതെ പൂർത്തിയാക്കിയ കമാൻഡിനായി പൂർത്തീകരണ ഓപ്ഷനുകൾ നൽകുന്നു. ഒരു അപരനാമത്തിനായുള്ള പാഡിംഗ് ഒരു പൂർണ്ണ കമാൻഡിന് സമാനമായി പ്രവർത്തിക്കുന്നു എന്നാണ് ഇതിനർത്ഥം.

താഴെപ്പറയുന്നവയിൽ, പൂർണ്ണമായ അപരനാമം എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാമെന്നും പിന്നീട് എല്ലാ kubectl അപരനാമങ്ങൾക്കും പൂർത്തീകരണം പ്രാപ്തമാക്കുന്നതിന് അത് എങ്ങനെ ക്രമീകരിക്കാമെന്നും ഞാൻ ആദ്യം വിശദീകരിക്കും.

സമ്പൂർണ്ണ അപരനാമം ഇൻസ്റ്റാൾ ചെയ്യുന്നു

ഒന്നാമതായി, സമ്പൂർണ്ണ-അപരനാമം ആശ്രയിച്ചിരിക്കുന്നു ബാഷ്-പൂർത്തിയാക്കൽ. അതിനാൽ, പൂർണ്ണമായ അപരനാമം ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുമുമ്പ്, ബാഷ്-പൂർത്തിയാക്കൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് നിങ്ങൾ ഉറപ്പാക്കേണ്ടതുണ്ട്. Linux, MacOS എന്നിവയ്ക്കായി ഇൻസ്റ്റലേഷൻ നിർദ്ദേശങ്ങൾ മുമ്പ് നൽകിയിട്ടുണ്ട്.

MacOS ഉപയോക്താക്കൾക്കുള്ള പ്രധാന കുറിപ്പ്: kubectl autocompletion സ്ക്രിപ്റ്റ് പോലെ, MacOS-ൽ സ്ഥിരസ്ഥിതിയായ Bash 3.2-ൽ പൂർണ്ണമായ അപരനാമം പ്രവർത്തിക്കില്ല. പ്രത്യേകിച്ചും, പൂർണ്ണമായ അപരനാമം ബാഷ്-പൂർത്തിയാക്കൽ v2 (brew install bash-completion@2), ഇതിന് കുറഞ്ഞത് ബാഷ് 4.1 ആവശ്യമാണ്. MacOS-ൽ പൂർണ്ണമായ അപരനാമം ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ Bash-ന്റെ ഒരു പുതിയ പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട് എന്നാണ് ഇതിനർത്ഥം.

നിങ്ങൾ സ്ക്രിപ്റ്റ് ഡൗൺലോഡ് ചെയ്യേണ്ടതുണ്ട് bash_completion.sh നിന്ന് GitHub ശേഖരം അത് നിങ്ങളുടെ ഫയലിൽ ഉൾപ്പെടുത്തുക ~/.bashrc:

source ~/bash_completion.sh

ഷെൽ റീബൂട്ട് ചെയ്ത ശേഷം, പൂർണ്ണമായ അപരനാമം പൂർണ്ണമായി ഇൻസ്റ്റാൾ ചെയ്യപ്പെടും.

kubectl അപരനാമങ്ങൾക്കായി സ്വയം പൂർത്തീകരണം പ്രവർത്തനക്ഷമമാക്കുന്നു

സാങ്കേതികമായി പൂർണ്ണമായ അപരനാമം ഒരു റാപ്പർ പ്രവർത്തനം നൽകുന്നു _complete_alias. ഈ ഫംഗ്‌ഷൻ അപരനാമം പരിശോധിക്കുകയും അപരനാമ കമാൻഡിനായുള്ള പൂർത്തീകരണ സൂചനകൾ നൽകുകയും ചെയ്യുന്നു.

ഒരു പ്രത്യേക അപരനാമവുമായി ഒരു ഫംഗ്ഷൻ ബന്ധപ്പെടുത്തുന്നതിന്, നിങ്ങൾ ബിൽറ്റ്-ഇൻ ബാഷ് മെക്കാനിസം ഉപയോഗിക്കേണ്ടതുണ്ട് പൂർണ്ണമായ, ഇൻസ്റ്റാൾ ചെയ്യാൻ _complete_alias ഒരു അപരനാമ പൂർത്തീകരണ പ്രവർത്തനമായി.

ഒരു ഉദാഹരണമായി, kubectl കമാൻഡിനെ സൂചിപ്പിക്കുന്ന അപരനാമം എടുക്കാം. ഇൻസ്റ്റാൾ ചെയ്യാൻ _complete_alias ഈ അപരനാമത്തിനായുള്ള ഒരു പൂരക ഫംഗ്‌ഷൻ എന്ന നിലയിൽ, നിങ്ങൾ ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കണം:

$ complete -F _complete_alias k

ഇതിന്റെ ഫലം, നിങ്ങൾ ഒരു അപരനാമം സ്വയം പൂർത്തീകരിക്കുമ്പോഴെല്ലാം, ഫംഗ്‌ഷനെ വിളിക്കുന്നു _complete_alias, ഇത് അപരനാമം പരിശോധിക്കുകയും കമാൻഡിനായി പൂർത്തീകരണ സൂചനകൾ നൽകുകയും ചെയ്യുന്നു kubectl.

രണ്ടാമത്തെ ഉദാഹരണമായി, നമുക്ക് അപരനാമം എടുക്കാം kg, ഇത് സൂചിപ്പിക്കുന്നു kubectl get:

$ complete -F _complete_alias kg

മുമ്പത്തെ ഉദാഹരണത്തിലെന്നപോലെ, നിങ്ങൾ കിലോഗ്രാം സ്വയമേവ പൂർത്തിയാക്കുമ്പോൾ, നിങ്ങൾക്ക് ലഭിക്കുന്ന അതേ പൂർത്തീകരണ സൂചനകൾ ലഭിക്കും. kubectl get.

നിങ്ങളുടെ സിസ്റ്റത്തിലെ ഏത് അപരനാമത്തിനും നിങ്ങൾക്ക് പൂർണ്ണമായ അപരനാമം ഉപയോഗിക്കാനാകുമെന്ന കാര്യം ശ്രദ്ധിക്കുക.

അതിനാൽ, എല്ലാ kubectl അപരനാമങ്ങൾക്കും സ്വയം പൂർത്തീകരണം പ്രവർത്തനക്ഷമമാക്കുന്നതിന്, അവയിൽ ഓരോന്നിനും മുകളിലുള്ള കമാൻഡ് പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്. നിങ്ങൾ kubectl-aliases സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഇനിപ്പറയുന്ന സ്‌നിപ്പെറ്റ് ഇത് കൃത്യമായി ചെയ്യുന്നു ~/.kubectl-aliases:

for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$//' ~/.kubectl_aliases); 
do
  complete -F _complete_alias "$_a"
done

ഈ കോഡ് നിങ്ങളുടേതിൽ സ്ഥാപിക്കേണ്ടതുണ്ട് ~/.bashrc, കമാൻഡ് ഷെൽ പുനരാരംഭിക്കുക, എല്ലാ 800 kubectl അപരനാമങ്ങൾക്കും സ്വയം പൂർത്തീകരണം ലഭ്യമാകും.

6. പ്ലഗിനുകൾ ഉപയോഗിച്ച് kubectl വിപുലീകരിക്കുന്നു

മുതൽ ആരംഭിക്കുന്നു പതിപ്പ് 1.12, kubectl പിന്തുണയ്ക്കുന്നു പ്ലഗിൻ മെക്കാനിസം, അധിക കമാൻഡുകൾ ഉപയോഗിച്ച് അതിന്റെ പ്രവർത്തനങ്ങൾ വികസിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

നിങ്ങൾക്ക് പരിചയമുണ്ടെങ്കിൽ Git പ്ലഗിൻ മെക്കാനിസങ്ങൾ, തുടർന്ന് kubectl പ്ലഗിനുകൾ ഒരേ തത്വത്തിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്.

ഈ അധ്യായത്തിൽ, പ്ലഗിനുകൾ എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം, അവ എവിടെ കണ്ടെത്താം, നിങ്ങളുടെ സ്വന്തം പ്ലഗിനുകൾ എങ്ങനെ സൃഷ്ടിക്കാം എന്നിവ ഞങ്ങൾ ചർച്ച ചെയ്യും.

പ്ലഗിനുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു

Kubectl പ്ലഗിനുകൾ എന്ന പേരിൽ ലളിതമായ എക്സിക്യൂട്ടബിൾ ഫയലുകളായി വിതരണം ചെയ്യപ്പെടുന്നു kubectl-x. ഉപസർഗ്ഗം kubectl- ആവശ്യമാണ്, തുടർന്ന് പ്ലഗിനിലേക്ക് വിളിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പുതിയ kubectl ഉപകമാൻഡ്.

ഉദാഹരണത്തിന്, ഹലോ പ്ലഗിൻ ഒരു ഫയലായി വിതരണം ചെയ്യും kubectl-hello.

പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്യാൻ, നിങ്ങൾ ഫയൽ പകർത്തേണ്ടതുണ്ട് kubectl-x നിങ്ങളുടെ PATH-ലെ ഏതെങ്കിലും ഡയറക്‌ടറിയിലേക്ക് അത് എക്‌സിക്യൂട്ടബിൾ ആക്കുക, ഉദാഹരണത്തിന് chmod +x. ഇതിന് ശേഷം ഉടൻ തന്നെ നിങ്ങൾക്ക് പ്ലഗിൻ ഉപയോഗിച്ച് വിളിക്കാം kubectl x.

നിങ്ങളുടെ സിസ്റ്റത്തിൽ നിലവിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള എല്ലാ പ്ലഗിന്നുകളും ലിസ്റ്റുചെയ്യുന്നതിന് നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കാം:

$ kubectl plugin list

നിങ്ങൾക്ക് ഒരേ പേരിൽ ഒന്നിലധികം പ്ലഗിനുകൾ ഉണ്ടെങ്കിൽ, അല്ലെങ്കിൽ എക്സിക്യൂട്ടബിൾ അല്ലാത്ത ഒരു പ്ലഗിൻസ് ഫയൽ ഉണ്ടെങ്കിൽ ഈ കമാൻഡ് മുന്നറിയിപ്പുകളും പ്രദർശിപ്പിക്കും.

Krew ഉപയോഗിച്ച് പ്ലഗിനുകൾ കണ്ടെത്തുകയും ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യുന്നു

Kubectl പ്ലഗിനുകൾ സോഫ്റ്റ്‌വെയർ പാക്കേജുകൾ പോലെ പങ്കിടാനോ വീണ്ടും ഉപയോഗിക്കാനോ കഴിയും. എന്നാൽ മറ്റുള്ളവർ പങ്കിട്ട പ്ലഗിനുകൾ നിങ്ങൾക്ക് എവിടെ കണ്ടെത്താനാകും?

പ്രോജക്റ്റ് ക്രൂ kubectl പ്ലഗിനുകൾ പങ്കിടുന്നതിനും തിരയുന്നതിനും ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും നിയന്ത്രിക്കുന്നതിനും ഒരു ഏകീകൃത പരിഹാരം നൽകാൻ ലക്ഷ്യമിടുന്നു. പ്രോജക്റ്റ് സ്വയം "kubectl പ്ലഗിനുകൾക്കുള്ള പാക്കേജ് മാനേജർ" എന്ന് വിളിക്കുന്നു (Krew ഇതിന് സമാനമാണ് ബ്രൂവ്).

നിങ്ങൾക്ക് തിരഞ്ഞെടുത്ത് ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയുന്ന kubectl പ്ലഗിന്നുകളുടെ ഒരു ലിസ്റ്റ് ആണ് Krew. അതേ സമയം, kubectl-നുള്ള ഒരു പ്ലഗിൻ കൂടിയാണ് ക്രൂ.

ഇതിനർത്ഥം Krew ഇൻസ്റ്റാൾ ചെയ്യുന്നത് മറ്റേതെങ്കിലും kubectl പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്യുന്നതുപോലെ പ്രവർത്തിക്കുന്നു എന്നാണ്. എന്നതിൽ നിങ്ങൾക്ക് വിശദമായ നിർദ്ദേശങ്ങൾ കണ്ടെത്താം GitHub പേജ്.

ഏറ്റവും പ്രധാനപ്പെട്ട ക്രൂ കമാൻഡുകൾ ഇവയാണ്:

# Поиск в списке плагинов
$ kubectl krew search [<query>]
# Посмотреть информацию о плагине
$ kubectl krew info <plugin>
# Установить плагин
$ kubectl krew install <plugin>
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove <plugin>

Krew ഉപയോഗിച്ച് പ്ലഗിനുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നത് മുകളിൽ വിവരിച്ച സ്റ്റാൻഡേർഡ് രീതി ഉപയോഗിച്ച് പ്ലഗിനുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിൽ ഇടപെടുന്നില്ലെന്ന് ദയവായി ശ്രദ്ധിക്കുക.

കമാൻഡ് എന്നത് ദയവായി ശ്രദ്ധിക്കുക kubectl krew list Krew ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്ത പ്ലഗിനുകൾ മാത്രം പ്രദർശിപ്പിക്കുന്നു, അതേസമയം കമാൻഡ് kubectl plugin list എല്ലാ പ്ലഗിന്നുകളും ലിസ്റ്റുചെയ്യുന്നു, അതായത്, ക്രൂ ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്തവയും മറ്റ് രീതികൾ ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്തവയും.

മറ്റെവിടെയെങ്കിലും പ്ലഗിനുകൾ കണ്ടെത്തുന്നു

ക്രൂ ഒരു യുവ പ്രോജക്‌റ്റാണ്, നിലവിൽ അതിന്റെ പ്രവർത്തനത്തിലാണ് പട്ടിക ഏകദേശം 30 പ്ലഗിനുകൾ മാത്രം. നിങ്ങൾക്ക് ആവശ്യമുള്ളത് കണ്ടെത്താൻ കഴിയുന്നില്ലെങ്കിൽ, GitHub പോലുള്ള മറ്റെവിടെയെങ്കിലും പ്ലഗിനുകൾ നിങ്ങൾക്ക് കണ്ടെത്താനാകും.

GitHub വിഭാഗം നോക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു kubectl-plugins. പരിശോധിക്കേണ്ട ലഭ്യമായ ഡസൻ കണക്കിന് പ്ലഗിനുകൾ അവിടെ നിങ്ങൾ കണ്ടെത്തും.

നിങ്ങളുടെ സ്വന്തം പ്ലഗിനുകൾ എഴുതുന്നു

നിങ്ങൾക്ക് സ്വയം കഴിയും പ്ലഗിനുകൾ സൃഷ്ടിക്കുക - ഇത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല. നിങ്ങൾക്ക് ആവശ്യമുള്ളത് ചെയ്യുന്ന ഒരു എക്സിക്യൂട്ടബിൾ നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്, അതിന് ഇതുപോലെ പേര് നൽകുക kubectl-x മുകളിൽ വിവരിച്ചതുപോലെ ഇൻസ്റ്റാൾ ചെയ്യുക.

ഫയൽ ഒരു ബാഷ് സ്‌ക്രിപ്‌റ്റോ, പൈത്തൺ സ്‌ക്രിപ്‌റ്റോ അല്ലെങ്കിൽ കംപൈൽ ചെയ്‌ത GO ആപ്ലിക്കേഷനോ ആകാം - അത് പ്രശ്‌നമല്ല. ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ നേരിട്ട് എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും എന്നതാണ് ഏക വ്യവസ്ഥ.

നമുക്ക് ഇപ്പോൾ ഒരു ഉദാഹരണ പ്ലഗിൻ സൃഷ്ടിക്കാം. മുമ്പത്തെ വിഭാഗത്തിൽ, ഓരോ പോഡിനുമുള്ള കണ്ടെയ്‌നറുകൾ ലിസ്റ്റ് ചെയ്യാൻ നിങ്ങൾ kubectl കമാൻഡ് ഉപയോഗിച്ചു. ഈ കമാൻഡ് നിങ്ങൾക്ക് വിളിക്കാൻ കഴിയുന്ന ഒരു പ്ലഗിനാക്കി മാറ്റുന്നത് എളുപ്പമാണ് ഉദാ. kubectl img.

ഒരു ഫയൽ സൃഷ്ടിക്കുക kubectl-img ഇനിപ്പറയുന്ന ഉള്ളടക്കം:

#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

ഇപ്പോൾ ഫയൽ എക്സിക്യൂട്ടബിൾ ആക്കുക chmod +x kubectl-img നിങ്ങളുടെ PATH-ലെ ഏതെങ്കിലും ഡയറക്ടറിയിലേക്ക് അത് നീക്കുക. ഇതിന് ശേഷം ഉടൻ തന്നെ നിങ്ങൾക്ക് പ്ലഗിൻ ഉപയോഗിക്കാം kubectl img.

സൂചിപ്പിച്ചതുപോലെ, kubectl പ്ലഗിനുകൾ ഏത് പ്രോഗ്രാമിംഗിലും സ്ക്രിപ്റ്റിംഗ് ഭാഷയിലും എഴുതാം. നിങ്ങൾ ഷെൽ സ്ക്രിപ്റ്റുകളാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, പ്ലഗിനിനുള്ളിൽ നിന്ന് kubectl-ലേക്ക് എളുപ്പത്തിൽ വിളിക്കാൻ കഴിയുന്നതിന്റെ പ്രയോജനം. എന്നിരുന്നാലും, നിങ്ങൾക്ക് യഥാർത്ഥ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ കൂടുതൽ സങ്കീർണ്ണമായ പ്ലഗിനുകൾ എഴുതാൻ കഴിയും കുബെർനെറ്റസ് ക്ലയന്റ് ലൈബ്രറി. നിങ്ങൾ Go ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്കും ഉപയോഗിക്കാം ക്ലി-റൺടൈം ലൈബ്രറി, ഇത് kubectl പ്ലഗിനുകൾ എഴുതുന്നതിന് പ്രത്യേകമായി നിലവിലുണ്ട്.

നിങ്ങളുടെ പ്ലഗിനുകൾ എങ്ങനെ പങ്കിടാം

നിങ്ങളുടെ പ്ലഗിനുകൾ മറ്റുള്ളവർക്ക് ഉപയോഗപ്രദമാകുമെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ, അത് GitHub-ൽ പങ്കിടാൻ മടിക്കേണ്ടതില്ല. അവരെ വിഷയത്തിലേക്ക് ചേർക്കുന്നത് ഉറപ്പാക്കുക kubectl-plugins.

നിങ്ങളുടെ പ്ലഗിൻ ചേർക്കാൻ നിങ്ങൾക്ക് അഭ്യർത്ഥിക്കാം ക്രൂ ലിസ്റ്റ്. ഇത് എങ്ങനെ ചെയ്യണമെന്നതിനുള്ള നിർദ്ദേശങ്ങൾ ഇവിടെയുണ്ട് GitHub ശേഖരണങ്ങൾ.

കമാൻഡ് പൂർത്തീകരണം

പ്ലഗിന്നുകൾ നിലവിൽ സ്വയമേവ പൂർത്തീകരണത്തെ പിന്തുണയ്ക്കുന്നില്ല. അതായത്, നിങ്ങൾ പ്ലഗിന്റെ മുഴുവൻ പേരും ആർഗ്യുമെന്റുകളുടെ മുഴുവൻ പേരുകളും നൽകണം.

ഈ ഫംഗ്‌ഷനുള്ള GitHub kubectl ശേഖരണമുണ്ട് തുറന്ന അഭ്യർത്ഥന. അതിനാൽ ഈ സവിശേഷത ഭാവിയിൽ എപ്പോഴെങ്കിലും നടപ്പിലാക്കാൻ സാധ്യതയുണ്ട്.

നല്ലതുവരട്ടെ!!!

വിഷയത്തിൽ മറ്റെന്താണ് വായിക്കേണ്ടത്:

1. കുബർനെറ്റസിലെ ഓട്ടോസ്‌കേലിംഗിന്റെ മൂന്ന് തലങ്ങളും അവ എങ്ങനെ ഫലപ്രദമായി ഉപയോഗിക്കാമെന്നും.
2. നടപ്പാക്കൽ ടെംപ്ലേറ്റിനൊപ്പം പൈറസിയുടെ ആവേശത്തിൽ കുബർനെറ്റസ്.
3. ടെലിഗ്രാമിലെ ഞങ്ങളുടെ ചാനൽ കുബെർനെറ്റസിന് ചുറ്റും.

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