kubectl નો વધુ અસરકારક રીતે ઉપયોગ કેવી રીતે કરવો: વિગતવાર માર્ગદર્શિકા

જો તમે Kubernetes સાથે કામ કરો છો, તો પછી kubectl કદાચ તમે સૌથી વધુ ઉપયોગ કરો છો તે ઉપયોગિતાઓમાંની એક છે. અને જ્યારે પણ તમે કોઈ ચોક્કસ સાધન સાથે કામ કરવા માટે ઘણો સમય પસાર કરો છો, ત્યારે તે તેનો સારી રીતે અભ્યાસ કરવા અને તેનો અસરકારક રીતે ઉપયોગ કેવી રીતે કરવો તે શીખવા માટે ચૂકવણી કરે છે.

ટીમ Mail.ru માંથી કુબરનેટ્સ એએએસ ડેનિયલ વેઇબેલ દ્વારા એક લેખનો અનુવાદ કર્યો જેમાં તમને kubectl સાથે અસરકારક રીતે કામ કરવા માટેની ટીપ્સ અને યુક્તિઓ મળશે. તે તમને કુબરનેટ્સની ઊંડી સમજ મેળવવામાં પણ મદદ કરશે.

લેખકના મતે, લેખનો ધ્યેય કુબરનેટ્સ સાથેના તમારા દૈનિક કાર્યને માત્ર વધુ કાર્યક્ષમ જ નહીં, પણ વધુ આનંદપ્રદ બનાવવાનો છે!

પરિચય: kubectl શું છે

તમે kubectl નો વધુ અસરકારક રીતે ઉપયોગ કરવાનું શીખો તે પહેલાં, તમારે તે શું છે અને તે કેવી રીતે કાર્ય કરે છે તેની મૂળભૂત સમજ મેળવવાની જરૂર છે.

વપરાશકર્તાના પરિપ્રેક્ષ્યમાં, kubectl એ કંટ્રોલ પેનલ છે જે તમને Kubernetes ઑપરેશન કરવા દે છે.

તકનીકી રીતે કહીએ તો, kubectl એ Kubernetes API ક્લાયંટ છે.

Kubernetes API એ HTTP REST API છે. આ API એ સાચું Kubernetes વપરાશકર્તા ઇન્ટરફેસ છે, જેના દ્વારા તે સંપૂર્ણપણે નિયંત્રિત થાય છે. આનો અર્થ એ છે કે દરેક Kubernetes ઑપરેશન API એન્ડપોઇન્ટ તરીકે ખુલ્લું છે અને તે એન્ડપોઇન્ટ પર HTTP વિનંતી સાથે કરી શકાય છે.

તેથી, kubectl નું મુખ્ય કામ Kubernetes API ને HTTP વિનંતીઓ કરવાનું છે:

કુબરનેટ્સ એ સંપૂર્ણપણે સંસાધન-લક્ષી સિસ્ટમ છે. આનો અર્થ એ છે કે તે સંસાધનોની આંતરિક સ્થિતિ જાળવી રાખે છે અને તમામ કુબરનેટ્સ ઓપરેશન્સ CRUD ઓપરેશન્સ છે.

તમે આ સંસાધનોનું સંચાલન કરીને કુબરનેટ્સના સંપૂર્ણ નિયંત્રણમાં છો, અને કુબરનેટ્સ સંસાધનોની વર્તમાન સ્થિતિના આધારે શું કરવું તે નક્કી કરે છે. આ કારણોસર, કુબરનેટ્સ API સંદર્ભ તેમની સંકળાયેલ કામગીરી સાથે સંસાધન પ્રકારોની સૂચિ તરીકે ગોઠવવામાં આવે છે.

ચાલો એક ઉદાહરણ જોઈએ.

ધારો કે તમે ReplicaSet રિસોર્સ બનાવવા માંગો છો. આ કરવા માટે, તમે નામ દ્વારા ફાઇલમાં પ્રતિકૃતિ સેટનું વર્ણન કરો replicaset.yaml, પછી આદેશ ચલાવો:

$ kubectl create -f replicaset.yaml

આ એક ReplicaSet સ્ત્રોત બનાવશે. પરંતુ પડદા પાછળ શું થાય છે?

Kubernetes પાસે ReplicaSet બનાવવાની કામગીરી છે. અન્ય કોઈપણ ઓપરેશનની જેમ, તે API એન્ડપોઇન્ટ તરીકે ખુલ્લું છે. આ ઓપરેશન માટે વિશિષ્ટ API એન્ડપોઇન્ટ આના જેવો દેખાય છે:

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

બધા Kubernetes ઓપરેશન્સ માટે API એન્ડપોઇન્ટ્સ અહીં મળી શકે છે API સંદર્ભ (સહિત ઉપરોક્ત અંતિમ બિંદુ). એન્ડપોઇન્ટ પર વાસ્તવિક વિનંતી કરવા માટે, તમારે પહેલા API સંદર્ભમાં સૂચિબદ્ધ એન્ડપોઇન્ટ પાથમાં API સર્વર URL ઉમેરવું આવશ્યક છે.

તેથી, જ્યારે તમે ઉપરોક્ત આદેશ ચલાવો છો, ત્યારે kubectl ઉપરોક્ત API એન્ડપોઇન્ટને HTTP POST વિનંતી મોકલે છે. તમે ફાઇલમાં આપેલી ReplicaSet વ્યાખ્યા replicaset.yaml, વિનંતીના મુખ્ય ભાગમાં મોકલવામાં આવે છે.

આ રીતે kubectl બધા આદેશો માટે કામ કરે છે જે કુબરનેટ્સ ક્લસ્ટર સાથે ક્રિયાપ્રતિક્રિયા કરે છે. આ તમામ કેસોમાં, kubectl માત્ર યોગ્ય Kubernetes API એન્ડપોઇન્ટને HTTP વિનંતીઓ કરે છે.

મહેરબાની કરીને નોંધ કરો કે તમે ઉપયોગિતાનો ઉપયોગ કરીને કુબરનેટ્સનું સંપૂર્ણ સંચાલન કરી શકો છો જેમ કે curlકુબરનેટ્સ API ને મેન્યુઅલી HTTP વિનંતીઓ મોકલીને. Kubectl ફક્ત Kubernetes API નો ઉપયોગ કરવાનું સરળ બનાવે છે.

kubectl શું છે અને તે કેવી રીતે કાર્ય કરે છે તેની આ મૂળભૂત બાબતો છે. પરંતુ Kubernetes API વિશે કંઈક બીજું છે જે દરેક kubectl વપરાશકર્તાને જાણવું જોઈએ. ચાલો કુબરનેટીસની આંતરિક દુનિયામાં એક ઝડપી નજર કરીએ.

કુબરનેટીસની આંતરિક દુનિયા

કુબરનેટ્સમાં સ્વતંત્ર ઘટકોના સમૂહનો સમાવેશ થાય છે જે ક્લસ્ટર નોડ્સ પર અલગ પ્રક્રિયાઓ તરીકે ચાલે છે. કેટલાક ઘટકો માસ્ટર નોડ્સ પર ચાલે છે, અન્ય વર્કર નોડ્સ પર, દરેક ઘટક તેનું પોતાનું ચોક્કસ કાર્ય કરે છે.

અહીં મુખ્ય ગાંઠો પરના સૌથી મહત્વપૂર્ણ ઘટકો છે:

1. તિજોરી - સંસાધન વ્યાખ્યાઓ સંગ્રહિત કરે છે (સામાન્ય રીતે તે વગેરે).
2. API સર્વર — API પ્રદાન કરે છે અને સ્ટોરેજનું સંચાલન કરે છે.
3. કંટ્રોલર મેનેજર - ખાતરી કરે છે કે સંસાધન સ્થિતિ સ્પષ્ટીકરણોનું પાલન કરે છે.
4. શેડ્યૂલર — વર્કર ગાંઠો પર શીંગો સુનિશ્ચિત કરે છે.

અને વર્કર નોડ્સ પર અહીં એક સૌથી મહત્વપૂર્ણ ઘટક છે:

1. કુબેલેટ — વર્કિંગ નોડ પર કન્ટેનરના લોન્ચનું સંચાલન કરે છે.

આ ઘટકો એકસાથે કેવી રીતે કાર્ય કરે છે તે સમજવા માટે, ચાલો એક ઉદાહરણ જોઈએ.

ચાલો ધારીએ કે તમે હમણાં જ પૂર્ણ કર્યું છે kubectl create -f replicaset.yaml, જે પછી kubectl એ HTTP POST વિનંતી કરી ReplicaSet API એન્ડપોઇન્ટ (રેપ્લિકાસેટ સંસાધન વ્યાખ્યા પસાર કરવી).

ક્લસ્ટરમાં શું ચાલી રહ્યું છે?

1. કર્યા પછી kubectl create -f replicaset.yaml API સર્વર સ્ટોરેજમાં તમારી ReplicaSet સંસાધન વ્યાખ્યાને સંગ્રહિત કરે છે:

   

2. આગળ, ReplicaSet નિયંત્રક નિયંત્રક મેનેજરમાં લોંચ કરવામાં આવે છે, જે ReplicaSet સંસાધનોની રચના, ફેરફાર અને કાઢી નાખવાનું સંચાલન કરે છે:

   

3. ReplicaSet નિયંત્રક દરેક ReplicaSet પ્રતિકૃતિ માટે પોડ વ્યાખ્યા બનાવે છે (ReplicaSet વ્યાખ્યામાં પોડ ટેમ્પ્લેટ મુજબ) અને તેને સ્ટોરેજમાં સંગ્રહિત કરે છે:

   

4. શેડ્યૂલર લોન્ચ કરવામાં આવ્યું છે, ટ્રેકિંગ પોડ્સ કે જે હજુ સુધી કોઈપણ વર્કર નોડ્સને સોંપવામાં આવ્યા નથી:

   

5. શેડ્યૂલર દરેક પોડ માટે યોગ્ય વર્કર નોડ પસંદ કરે છે અને સ્ટોરમાં પોડની વ્યાખ્યામાં આ માહિતી ઉમેરે છે:

   

6. વર્કર નોડ પર કે જેને પોડ અસાઇન કરવામાં આવે છે, કુબેલેટ લોન્ચ થાય છે, તે આ નોડને સોંપેલ પોડ્સને ટ્રૅક કરે છે:

   

7. કુબેલેટ સ્ટોરેજમાંથી પોડની વ્યાખ્યા વાંચે છે અને કન્ટેનર રનટાઇમ, જેમ કે ડોકર, નોડ પર કન્ટેનર શરૂ કરવા માટે સૂચના આપે છે:

   

નીચે આ વર્ણનનું ટેક્સ્ટ સંસ્કરણ છે.

ReplicaSet સર્જન એન્ડપોઇન્ટ માટે API વિનંતી API સર્વર દ્વારા પ્રક્રિયા કરવામાં આવે છે. API સર્વર વિનંતીને પ્રમાણિત કરે છે અને ReplicaSet રિસોર્સ ડેફિનેશનને સ્ટોરેજમાં સ્ટોર કરે છે.

આ ઇવેન્ટ ReplicaSet કંટ્રોલર શરૂ કરે છે, જે કંટ્રોલર મેનેજરની સબપ્રોસેસ છે. ReplicaSet નિયંત્રક સ્ટોરમાં ReplicaSet સંસાધનોની રચના, અપડેટ અને કાઢી નાખવાનું મોનિટર કરે છે અને જ્યારે આવું થાય ત્યારે ઇવેન્ટ સૂચના પ્રાપ્ત કરે છે.

ReplicaSet નિયંત્રકનું કામ એ સુનિશ્ચિત કરવાનું છે કે જરૂરી સંખ્યામાં ReplicaSet પોડ્સ અસ્તિત્વમાં છે. અમારા ઉદાહરણમાં, હજી સુધી કોઈ પોડ્સ અસ્તિત્વમાં નથી, તેથી રેપ્લિકાસેટ નિયંત્રક આ પોડ વ્યાખ્યાઓ બનાવે છે (રેપ્લિકાસેટ વ્યાખ્યામાં પોડ નમૂના અનુસાર) અને તેને સ્ટોરેજમાં સંગ્રહિત કરે છે.

નવા પોડ્સનું નિર્માણ એક શેડ્યૂલર દ્વારા ટ્રિગર થાય છે જે પોડ વ્યાખ્યાઓનો ટ્રૅક રાખે છે જે હજી સુધી વર્કર નોડ્સ માટે સુનિશ્ચિત નથી. શેડ્યૂલર દરેક પોડ માટે યોગ્ય વર્કર નોડ પસંદ કરે છે અને રિપોઝીટરીમાં પોડ વ્યાખ્યાઓને અપડેટ કરે છે.

નોંધ કરો કે આ બિંદુ સુધી, ક્લસ્ટરમાં ક્યાંય પણ વર્કલોડ કોડ ચાલી રહ્યો ન હતો. અત્યાર સુધી જે બધું કરવામાં આવ્યું છે - આ માસ્ટર નોડ પર રીપોઝીટરીમાં સંસાધનોની રચના અને અપડેટ છે.

છેલ્લી ઘટના કુબેલેટ્સને ટ્રિગર કરે છે, જે તેમના વર્કર નોડ્સ માટે શેડ્યૂલ કરેલ પોડ્સનું નિરીક્ષણ કરે છે. વર્કર નોડના કુબેલેટ કે જેના પર તમારી રેપ્લિકાસેટ પોડ્સ ઇન્સ્ટોલ કરેલ છે તે કન્ટેનર રનટાઈમને સૂચના આપવી જોઈએ, જેમ કે ડોકર, જરૂરી કન્ટેનર ઈમેજો ડાઉનલોડ કરવા અને તેને ચલાવવા માટે.

આ બિંદુએ, તમારી ReplicaSet એપ્લિકેશન આખરે ચાલી રહી છે!

કુબરનેટ્સ API ની ભૂમિકા

તમે અગાઉના ઉદાહરણમાં જોયું તેમ, કુબરનેટ્સ ઘટકો (એપીઆઈ સર્વર અને સ્ટોરેજ સિવાય) સ્ટોરેજમાં સંસાધનોમાં થતા ફેરફારો અને સ્ટોરેજમાં સંસાધનો વિશેની માહિતીમાં ફેરફાર માટે જુએ છે.

અલબત્ત, આ ઘટકો સ્ટોરેજ સાથે સીધો સંપર્ક કરતા નથી, પરંતુ માત્ર કુબરનેટ્સ API દ્વારા.

નીચેના ઉદાહરણોનો વિચાર કરો:

1. ReplicaSet નિયંત્રક API એન્ડપોઇન્ટનો ઉપયોગ કરે છે સૂચિ પ્રતિકૃતિસેટ્સ પરિમાણ સાથે watch ReplicaSet સંસાધનોમાં ફેરફારોનું નિરીક્ષણ કરવા માટે.
2. ReplicaSet નિયંત્રક API એન્ડપોઇન્ટનો ઉપયોગ કરે છે પોડ બનાવો શીંગો બનાવવા માટે (પોડ બનાવો).
3. શેડ્યૂલર API એન્ડપોઇન્ટનો ઉપયોગ કરે છે પેચ પોડ (પોડ સંપાદિત કરો) પસંદ કરેલ કાર્યકર નોડ વિશે માહિતી સાથે પોડ્સ અપડેટ કરવા માટે.

જેમ તમે જોઈ શકો છો, આ એ જ API છે જે kubectl ઍક્સેસ કરે છે. આંતરિક ઘટકો અને બાહ્ય વપરાશકર્તાઓ માટે સમાન API નો ઉપયોગ કરવો એ કુબરનેટ્સ ડિઝાઇનમાં મૂળભૂત ખ્યાલ છે.

હવે આપણે સારાંશ આપી શકીએ છીએ કે કુબરનેટ્સ કેવી રીતે કાર્ય કરે છે:

1. સ્ટોરેજ સ્ટોર્સ જણાવે છે, એટલે કે, કુબરનેટ્સ સંસાધનો.
2. API સર્વર કુબરનેટ્સ API ના રૂપમાં સ્ટોરેજને ઇન્ટરફેસ પૂરું પાડે છે.
3. અન્ય તમામ કુબરનેટ્સ ઘટકો અને વપરાશકર્તાઓ API દ્વારા કુબરનેટ્સ સ્ટેટ (સંસાધનો) વાંચે છે, અવલોકન કરે છે અને તેની હેરફેર કરે છે.

આ વિભાવનાઓને જાણવાથી તમને kubectl ને વધુ સારી રીતે સમજવામાં અને તેમાંથી સૌથી વધુ મેળવવામાં મદદ મળશે.

હવે ચાલો કેટલીક વિશિષ્ટ ટીપ્સ અને યુક્તિઓ જોઈએ જે kubectl સાથે તમારી ઉત્પાદકતા સુધારવામાં મદદ કરશે.

1. આદેશ પૂર્ણતાનો ઉપયોગ કરીને ઇનપુટને ઝડપી બનાવો

સૌથી વધુ ઉપયોગી, પરંતુ ઘણીવાર અવગણવામાં આવતી, કુબેક્ટલ સાથે કામગીરી સુધારવા માટેની તકનીકો આદેશ પૂર્ણતા છે.

આદેશ પૂર્ણતા તમને ટેબ કીનો ઉપયોગ કરીને kubectl આદેશોના ભાગોને આપમેળે પૂર્ણ કરવાની મંજૂરી આપે છે. આ સબકમાન્ડ્સ, વિકલ્પો અને દલીલો માટે કામ કરે છે, જેમાં સંસાધન નામો જેટલું જટિલ કંઈક સામેલ છે.

kubectl આદેશ પૂર્ણતા કેવી રીતે કાર્ય કરે છે તે જુઓ:

Bash અને Zsh શેલો માટે કમાન્ડ પૂર્ણતા કામ કરે છે.

સત્તાવાર માર્ગદર્શિકા સ્વતઃપૂર્ણતા સુયોજિત કરવા માટે વિગતવાર સૂચનો સમાવે છે, પરંતુ નીચે અમે એક ટૂંકો અવતરણ પ્રદાન કરીશું.

કમાન્ડ કમ્પ્લીશન કેવી રીતે કામ કરે છે

કમાન્ડ કમ્પ્લીશન એ શેલ ફીચર છે જે કમ્પલીશન સ્ક્રિપ્ટનો ઉપયોગ કરીને કામ કરે છે. એક્સ્ટેંશન સ્ક્રિપ્ટ એ શેલ સ્ક્રિપ્ટ છે જે ચોક્કસ આદેશ માટે એક્સ્ટેંશનના વર્તનને વ્યાખ્યાયિત કરે છે.

Kubectl નીચે આપેલા આદેશોનો ઉપયોગ કરીને Bash અને Zsh માટે એક્સ્ટેંશન સ્ક્રિપ્ટ્સ આપમેળે જનરેટ અને આઉટપુટ કરે છે:

$ kubectl completion bash

અથવા:

$ kubectl completion zsh

સિદ્ધાંતમાં, આ આદેશોના આઉટપુટને યોગ્ય આદેશ શેલ સાથે જોડવા માટે તે પૂરતું છે જેથી kubectl આદેશોને પૂરક બનાવી શકે.

વ્યવહારમાં, Bash (Linux અને MacOS વચ્ચેના તફાવતો સહિત) અને Zsh માટે કનેક્શન પદ્ધતિ અલગ છે. નીચે આપણે આ બધા વિકલ્પો જોઈશું.

Linux પર બેશ

Bash પૂર્ણતા સ્ક્રિપ્ટ bash-completion પેકેજ પર આધાર રાખે છે, તેથી તમારે તેને પહેલા ઇન્સ્ટોલ કરવાની જરૂર છે:

$ sudo apt-get install bash-completion

અથવા:

$ yum install bash-completion

તમે નીચેના આદેશનો ઉપયોગ કરીને પેકેજ સફળતાપૂર્વક ઇન્સ્ટોલ કરેલું છે તે ચકાસી શકો છો:

$ type _init_completion

જો આ શેલ ફંક્શન કોડ આઉટપુટ કરે છે, તો પછી bash-completion યોગ્ય રીતે ઇન્સ્ટોલ કરેલું છે. જો આદેશ "નોટ ફાઉન્ડ" ભૂલ આપે છે, તો તમારે તમારી ફાઇલમાં નીચેની લીટી ઉમેરવાની જરૂર છે ~ / .bashrc:

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

શું ફાઇલમાં આ લાઇન ઉમેરવી જરૂરી છે ~ / .bashrc અથવા નહીં તે પેકેજ મેનેજર પર આધાર રાખે છે જેનો તમે bash-completion ઇન્સ્ટોલ કરવા માટે ઉપયોગ કર્યો હતો. આ 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 bash-completion માં આપમેળે સમાવવામાં આવેલ છે.

બંને વિકલ્પો સમાન રીતે લાગુ પડે છે.

શેલ પુનઃપ્રારંભ કર્યા પછી, kubectl આદેશ પૂર્ણતા કામ કરશે.

MacOS પર બેશ

MacOS પર સેટઅપ થોડું વધુ જટિલ છે. હકીકત એ છે કે મૂળભૂત રીતે, MacOS Bash સંસ્કરણ 3.2 નો ઉપયોગ કરે છે, અને kubectl સ્વતઃપૂર્ણ સ્ક્રિપ્ટને ઓછામાં ઓછા 4.1 ના Bash સંસ્કરણની જરૂર છે અને તે Bash 3.2 માં કામ કરતું નથી.

MacOS પર Bash ના જૂના સંસ્કરણનો ઉપયોગ કરવા સાથે સંકળાયેલ લાઇસેંસિંગ સમસ્યાઓ છે. Bash સંસ્કરણ 4 GPLv3 હેઠળ લાઇસન્સ પ્રાપ્ત છે, જે Apple દ્વારા સમર્થિત નથી.

MacOS પર kubectl સ્વતઃપૂર્ણતાને ગોઠવવા માટે, તમારે Bash નું વધુ તાજેતરનું સંસ્કરણ ઇન્સ્ટોલ કરવું પડશે. તમે અપડેટ કરેલ બેશને તમારા ડિફોલ્ટ શેલ તરીકે પણ સેટ કરી શકો છો, જે તમને ભવિષ્યમાં ઘણી બધી સમસ્યાઓ બચાવશે. તે મુશ્કેલ નથી, વિગતો લેખમાં આપવામાં આવી છે "MacOS પર Bash અપડેટ કરી રહ્યું છે».

ચાલુ રાખતા પહેલા, ખાતરી કરો કે તમે Bash ના તાજેતરના સંસ્કરણનો ઉપયોગ કરી રહ્યાં છો (આઉટપુટ તપાસો bash --version).

બેશ પૂર્ણતા સ્ક્રિપ્ટ પ્રોજેક્ટ દ્વારા બદલાય છે bash-પૂર્ણતા, તેથી તમારે પહેલા તેને ઇન્સ્ટોલ કરવાની જરૂર છે.

તમે ઉપયોગ કરીને bash-completion ઇન્સ્ટોલ કરી શકો છો હોમબ્રે:

$ 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 સ્વતઃપૂર્ણતા સક્ષમ છે.

એક રીત એ છે કે તમારામાં નીચેની લીટી ઉમેરો ~/.bashrc:

source <(kubectl completion bash)

બીજી રીત ફોલ્ડરમાં સ્વતઃપૂર્ણ સ્ક્રિપ્ટ ઉમેરવાની છે /usr/local/etc/bash_completion.d:

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

આ પદ્ધતિ ફક્ત ત્યારે જ કાર્ય કરશે જો તમે હોમબ્રુનો ઉપયોગ કરીને bash-completion ઇન્સ્ટોલ કરો. આ કિસ્સામાં, bash-completion આ ડિરેક્ટરીમાંથી બધી સ્ક્રિપ્ટો લોડ કરે છે.

જો તમે ઇન્સ્ટોલ કર્યું છે હોમબ્રુનો ઉપયોગ કરીને kubectl, પછી પાછલું પગલું ભરવાની જરૂર નથી, કારણ કે સ્વતઃપૂર્ણ સ્ક્રિપ્ટ ફોલ્ડરમાં આપમેળે મૂકવામાં આવશે. /usr/local/etc/bash_completion.d સ્થાપન દરમ્યાન. આ કિસ્સામાં, kubectl autocompletion તમે bash-completion ઇન્સ્ટોલ કરો કે તરત જ કામ કરવાનું શરૂ કરશે.

પરિણામે, આ બધા વિકલ્પો સમાન છે.

ઝેચ

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]...

આદેશ વિનંતી કરેલ સંસાધન અથવા ક્ષેત્રના સ્પષ્ટીકરણને આઉટપુટ કરશે. પ્રદર્શિત માહિતી એપીઆઈ મેન્યુઅલમાં સમાવિષ્ટ માહિતી જેવી જ છે.

મૂળભૂત રીતે 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.

મહેરબાની કરીને નોંધ કરો કે કુબરનેટ્સ રિસોર્સ ફીલ્ડ કેસ સેન્સિટિવ છે.

તમે કોઈપણ સંસાધન ક્ષેત્રને કૉલમ તરીકે જોઈ શકો છો. ફક્ત સંસાધન સ્પષ્ટીકરણની સમીક્ષા કરો અને તમને ગમે તે ફીલ્ડ સાથે અજમાવી જુઓ.

પરંતુ પ્રથમ, ચાલો ક્ષેત્ર પસંદગીના અભિવ્યક્તિઓ પર નજીકથી નજર કરીએ.

JSONPath અભિવ્યક્તિઓ

સંસાધન ક્ષેત્રો પસંદ કરવા માટેના અભિવ્યક્તિઓ પર આધારિત છે JSONPath.

JSONPath એ JSON દસ્તાવેજોમાંથી ડેટા પુનઃપ્રાપ્ત કરવા માટેની ભાષા છે. JSONPath માટે એક ફીલ્ડ પસંદ કરવું એ સૌથી સરળ ઉપયોગનો કેસ છે. તેની પાસે ઘણું છે વધુ શક્યતાઓ, પસંદગીકારો, ફિલ્ટર્સ અને તેથી વધુ સહિત.

Kubectl explain JSONPath સુવિધાઓની મર્યાદિત સંખ્યાને સમર્થન આપે છે. તેમના ઉપયોગની શક્યતાઓ અને ઉદાહરણો નીચે વર્ણવેલ છે:

# Выбрать все элементы списка
$ 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 આદેશને જણાવવા માટે તમારે એક માર્ગની જરૂર છે.

ક્લસ્ટરની અંદર, તમે બહુવિધ નેમસ્પેસ બનાવી શકો છો - ભૌતિક ક્લસ્ટરની અંદર વર્ચ્યુઅલ ક્લસ્ટરનો એક પ્રકાર. Kubectl એ પણ નક્કી કરે છે કે kubeconfig ફાઇલના આધારે કઈ નેમસ્પેસનો ઉપયોગ કરવો. આનો અર્થ એ છે કે તમારે kubectl આદેશને કઈ નેમસ્પેસ સાથે કામ કરવું તે જણાવવાની રીતની પણ જરૂર છે.

આ પ્રકરણમાં અમે સમજાવીશું કે તે કેવી રીતે કાર્ય કરે છે અને તેને અસરકારક રીતે કેવી રીતે કાર્ય કરવું.

નોંધ કરો કે તમારી પાસે KUBECONFIG પર્યાવરણ ચલમાં સૂચિબદ્ધ બહુવિધ kubeconfig ફાઈલો હોઈ શકે છે. આ કિસ્સામાં, આ બધી ફાઇલો રનટાઇમ પર એક સામાન્ય ગોઠવણીમાં જોડવામાં આવશે. તમે પેરામીટર સાથે kubectl ચલાવીને ડિફોલ્ટ kubeconfig ફાઇલને પણ બદલી શકો છો --kubeconfig. જુઓ સત્તાવાર દસ્તાવેજીકરણ.

kubeconfig ફાઇલો

ચાલો જોઈએ કે kubeconfig ફાઇલમાં બરાબર શું છે:

જેમ તમે જોઈ શકો છો, kubeconfig ફાઇલમાં સંદર્ભોનો સમૂહ છે. સંદર્ભમાં ત્રણ ઘટકોનો સમાવેશ થાય છે:

• ક્લસ્ટર — ક્લસ્ટર સર્વરનું API URL.
• વપરાશકર્તા - ક્લસ્ટરમાં વપરાશકર્તા પ્રમાણીકરણ ઓળખપત્રો.
• નેમસ્પેસ - ક્લસ્ટરમાં જોડતી વખતે વપરાતી નેમસ્પેસ.

વ્યવહારમાં, તેઓ ઘણી વખત તેમના ક્યુબેકોન્ફિગમાં ક્લસ્ટર દીઠ એક સંદર્ભનો ઉપયોગ કરે છે. જો કે, તમારી પાસે ક્લસ્ટર દીઠ બહુવિધ સંદર્ભો હોઈ શકે છે, જે વપરાશકર્તા અથવા નેમસ્પેસ દ્વારા અલગ પડે છે. જો કે, આ બહુ-સંદર્ભ રૂપરેખાંકન અસામાન્ય છે, તેથી સામાન્ય રીતે ક્લસ્ટરો અને સંદર્ભો વચ્ચે એક-થી-એક મેપિંગ હોય છે.

કોઈપણ સમયે, સંદર્ભોમાંથી એક વર્તમાન છે:

જ્યારે kubectl રૂપરેખાંકન ફાઇલ વાંચે છે, ત્યારે તે હંમેશા વર્તમાન સંદર્ભમાંથી માહિતી લે છે. ઉપરના ઉદાહરણમાં, kubectl Hare ક્લસ્ટર સાથે જોડાશે.

તદનુસાર, બીજા ક્લસ્ટર પર સ્વિચ કરવા માટે, તમારે kubeconfig ફાઇલમાં વર્તમાન સંદર્ભ બદલવાની જરૂર છે:

હવે kubectl ફોક્સ ક્લસ્ટર સાથે જોડાશે.

સમાન ક્લસ્ટરમાં અલગ નેમસ્પેસ પર સ્વિચ કરવા માટે, તમારે વર્તમાન સંદર્ભ માટે નેમસ્પેસ ઘટકની કિંમત બદલવાની જરૂર છે:

ઉપરના ઉદાહરણમાં, kubectl ફોક્સ ક્લસ્ટરની પ્રોડ નેમસ્પેસનો ઉપયોગ કરશે (અગાઉ ટેસ્ટ નેમસ્પેસ સેટ કરવામાં આવી હતી).

નોંધ કરો કે kubectl વિકલ્પો પણ પ્રદાન કરે છે --cluster, --user, --namespace и --context, જે તમને વ્યક્તિગત ઘટકો અને વર્તમાન સંદર્ભને ફરીથી લખવાની મંજૂરી આપે છે, kubeconfig માં શું સુયોજિત છે તે ધ્યાનમાં લીધા વગર. જુઓ kubectl options.

સૈદ્ધાંતિક રીતે, તમે kubeconfig માં સેટિંગ્સને મેન્યુઅલી બદલી શકો છો. પરંતુ તે અસુવિધાજનક છે. આ કામગીરીને સરળ બનાવવા માટે, ત્યાં વિવિધ ઉપયોગિતાઓ છે જે તમને આપમેળે પરિમાણો બદલવાની મંજૂરી આપે છે.

kubectx નો ઉપયોગ કરો

ક્લસ્ટરો અને નેમસ્પેસ વચ્ચે સ્વિચ કરવા માટે ખૂબ જ લોકપ્રિય ઉપયોગિતા.

ઉપયોગિતા આદેશો પ્રદાન કરે છે kubectx и kubens અનુક્રમે વર્તમાન સંદર્ભ અને નામ સ્થાન બદલવા માટે.

ઉલ્લેખ કર્યો છે તેમ, વર્તમાન સંદર્ભ બદલવાનો અર્થ એ છે કે જો તમારી પાસે ક્લસ્ટર દીઠ માત્ર એક જ સંદર્ભ હોય તો ક્લસ્ટર બદલવું.

અહીં આ આદેશો ચલાવવાનું ઉદાહરણ છે:

આવશ્યકપણે, આ આદેશો ઉપર વર્ણવ્યા મુજબ kubeconfig ફાઇલને સંપાદિત કરે છે.

સ્થાપિત કરવા માટે kubectx, પરની સૂચનાઓને અનુસરો ગિથબ.

બંને આદેશો સંદર્ભ અને નેમસ્પેસ નામોની સ્વતઃપૂર્ણતાને સમર્થન આપે છે, જે તેમને સંપૂર્ણપણે ટાઇપ કરવાની જરૂરિયાતને દૂર કરે છે. સ્વતઃપૂર્ણતા સેટ કરવા માટેની સૂચનાઓ અહીં.

અન્ય ઉપયોગી લક્ષણ kubectx તે ઇન્ટરેક્ટિવ મોડ. તે ઉપયોગિતા સાથે જોડાણમાં કામ કરે છે એફજેએફ, જે અલગથી ઇન્સ્ટોલ કરવું આવશ્યક છે. 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

પ્લગઈન્સનું કામ પાછલા વિભાગના ઉપનામો પર આધારિત છે.

તેઓ કેવી રીતે કાર્ય કરે છે તે અહીં છે:

નોંધ કરો કે પ્લગઇન્સ ઇન્ટરેક્ટિવ ફ્રી સર્ચ ઇન્ટરફેસ પ્રદાન કરવા માટે fzf નો ઉપયોગ કરે છે (જેમ કે kubectx ના ઇન્ટરેક્ટિવ મોડ). આનો અર્થ એ કે તમને જરૂર છે fzf ઇન્સ્ટોલ કરોઆ ઉપનામોનો ઉપયોગ કરવા માટે.

પ્લગઇન્સ ઇન્સ્ટોલ કરવા માટે, તમારે નામવાળી શેલ સ્ક્રિપ્ટ્સ ડાઉનલોડ કરવાની જરૂર છે kubectl-ctx и kubectl-ns તમારા PATH ચલની કોઈપણ ડિરેક્ટરીમાં અને તેને એક્ઝેક્યુટેબલ બનાવો દા.ત. chmod +x. આ પછી તરત જ તમે ઉપયોગ કરી શકશો kubectl ctx и kubectl ns.

5. ઓટોઅલીસીસ સાથે ઇનપુટ ઘટાડો

ઇનપુટને ઝડપી બનાવવા માટે શેલ ઉપનામો એ સારી રીત છે. પ્રોજેક્ટ kubectl-ઉપનામો મૂળભૂત kubectl આદેશો માટે લગભગ 800 શૉર્ટકટ્સ સમાવે છે.

તમે વિચારી રહ્યા હશો - તમને 800 ઉપનામો કેવી રીતે યાદ છે? પરંતુ તમારે તે બધાને યાદ રાખવાની જરૂર નથી, કારણ કે તે એક સરળ યોજના અનુસાર બનાવવામાં આવ્યા છે, જે નીચે આપેલ છે:

ઉદાહરણ તરીકે:

1. kgpooyaml - kubectl get pods oyaml
2. ksysgsvcw — kubectl -n kube-સિસ્ટમ svc w મેળવો
3. ksysrmcm -kubectl -n kube-સિસ્ટમ rm cm
4. kgdepalsl - kubectl મેળવો જમાવટ બધા sl

જેમ તમે જોઈ શકો છો, ઉપનામો ઘટકોથી બનેલા છે, જેમાંથી દરેક kubectl આદેશના ચોક્કસ ઘટકને રજૂ કરે છે. દરેક ઉપનામમાં બેઝ કમાન્ડ, ઓપરેશન અને રિસોર્સ માટે એક ઘટક અને પરિમાણો માટે બહુવિધ ઘટકો હોઈ શકે છે. તમે ઉપરના આકૃતિ અનુસાર આ ઘટકોને ડાબેથી જમણે ખાલી "વસ્તી" કરો.

વર્તમાન વિગતવાર આકૃતિ અહીં છે GitHub. ત્યાં પણ તમે શોધી શકો છો ઉપનામોની સંપૂર્ણ સૂચિ.

ઉદાહરણ તરીકે, ઉપનામ 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. Bash માટે, કમનસીબે, કામ કરવા માટે સ્વતઃપૂર્ણતા મેળવવા માટે અમુક કાર્ય જરૂરી છે.

Bash માં ઉપનામો માટે સ્વતઃપૂર્ણતાને સક્ષમ કરી રહ્યું છે

બૅશની સમસ્યા એ છે કે તે ઉપનામ (જેમ કે Zsh કરે છે, ઉદાહરણ તરીકે) નો ઉલ્લેખ કરે છે તે આદેશને નહીં (દર વખતે તમે ટેબ દબાવો) પૂર્ણ કરવાનો પ્રયાસ કરે છે. તમારી પાસે તમામ 800 ઉપનામો માટે પૂર્ણ સ્ક્રિપ્ટ્સ ન હોવાથી, સ્વતઃપૂર્ણતા કામ કરતું નથી.

આ પ્રોજેક્ટ સંપૂર્ણ ઉપનામ આ સમસ્યાનો સામાન્ય ઉકેલ પૂરો પાડે છે. તે ઉપનામો માટે પૂર્ણ કરવાની પદ્ધતિ સાથે જોડાય છે, આંતરિક રીતે ઉપનામને આદેશમાં વિસ્તૃત કરે છે, અને પૂર્ણ થયેલ આદેશ માટે પૂર્ણતા વિકલ્પો પરત કરે છે. આનો અર્થ એ છે કે ઉપનામ માટે પેડિંગ સંપૂર્ણ આદેશની જેમ જ વર્તે છે.

નીચેનામાં, હું પહેલા સમજાવીશ કે પૂર્ણ-ઉનામ કેવી રીતે ઇન્સ્ટોલ કરવું અને પછી બધા kubectl ઉપનામો માટે પૂર્ણતાને સક્ષમ કરવા માટે તેને કેવી રીતે ગોઠવવું.

પૂર્ણ ઉપનામ ઇન્સ્ટોલ કરી રહ્યું છે

સૌ પ્રથમ, સંપૂર્ણ ઉપનામ પર આધાર રાખે છે bash-પૂર્ણતા. તેથી, સંપૂર્ણ ઉપનામ ઇન્સ્ટોલ કરતા પહેલા, તમારે ખાતરી કરવાની જરૂર છે કે bash-completion ઇન્સ્ટોલ કરેલ છે. Linux અને MacOS માટે ઇન્સ્ટોલેશન સૂચનાઓ અગાઉ પ્રદાન કરવામાં આવી છે.

MacOS વપરાશકર્તાઓ માટે મહત્વપૂર્ણ નોંધ: kubectl autocompletion સ્ક્રિપ્ટની જેમ, પૂર્ણ-ઉનામ Bash 3.2 સાથે કામ કરતું નથી, જે MacOS પર ડિફોલ્ટ છે. ખાસ કરીને, સંપૂર્ણ ઉપનામ bash-completion v2 પર આધાર રાખે છે (brew install bash-completion@2), જેને ઓછામાં ઓછું Bash 4.1 જરૂરી છે. આનો અર્થ એ છે કે MacOS પર સંપૂર્ણ ઉપનામનો ઉપયોગ કરવા માટે તમારે Bash નું નવું સંસ્કરણ ઇન્સ્ટોલ કરવું પડશે.

તમારે સ્ક્રિપ્ટ ડાઉનલોડ કરવાની જરૂર છે bash_completion.sh થી GitHub રીપોઝીટરી અને તેને તમારી ફાઈલમાં સામેલ કરો ~/.bashrc:

source ~/bash_completion.sh

શેલ રીબૂટ કર્યા પછી, પૂર્ણ-ઉનામ સંપૂર્ણપણે ઇન્સ્ટોલ થઈ જશે.

kubectl ઉપનામો માટે સ્વતઃપૂર્ણતાને સક્ષમ કરી રહ્યું છે

તકનીકી રીતે પૂર્ણ-ઉર્ફે રેપર કાર્ય પ્રદાન કરે છે _complete_alias. આ ફંક્શન ઉપનામને તપાસે છે અને ઉપનામ આદેશ માટે પૂર્ણતા સંકેતો આપે છે.

ફંક્શનને ચોક્કસ ઉપનામ સાથે સાંકળવા માટે, તમારે બિલ્ટ-ઇન બાશ મિકેનિઝમનો ઉપયોગ કરવાની જરૂર છે પૂર્ણ, સ્થાપિત કરવા માટે _complete_alias ઉપનામ પૂર્ણ કાર્ય તરીકે.

ઉદાહરણ તરીકે, ચાલો ઉપનામ k લઈએ, જે kubectl આદેશ માટે વપરાય છે. સ્થાપિત કરવા માટે _complete_alias આ ઉપનામ માટે પૂરક કાર્ય તરીકે, તમારે નીચેનો આદેશ ચલાવવો જોઈએ:

$ complete -F _complete_alias k

આનું પરિણામ એ છે કે જ્યારે પણ તમે ઉપનામ 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 પ્લગિન્સને શેર કરવા, શોધવા, ઇન્સ્ટોલ કરવા અને મેનેજ કરવા માટે એકીકૃત ઉકેલ પ્રદાન કરવાનો હેતુ છે. આ પ્રોજેક્ટ પોતાને "ક્યુબેક્ટલ પ્લગિન્સ માટે પેકેજ મેનેજર" કહે છે (ક્રુ તેના જેવું જ છે યોજવું).

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-પ્લગઇન્સ. ત્યાં તમને ડઝનેક ઉપલબ્ધ પ્લગઈનો મળશે જે તપાસવા યોગ્ય છે.

તમારા પોતાના પ્લગઈનો લખી રહ્યા છીએ

તમે તમારી જાતને કરી શકો છો પ્લગઈનો બનાવો - તે મુશ્કેલ નથી. તમારે એક એક્ઝેક્યુટેબલ બનાવવાની જરૂર છે જે તમને જે જોઈએ છે તે કરે છે, તેને નામ આપો 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 નો ઉપયોગ કરી રહ્યા છો, તો તમે પણ ઉપયોગ કરી શકો છો cli-રનટાઇમ લાઇબ્રેરી, જે ખાસ કરીને kubectl પ્લગઈન્સ લખવા માટે અસ્તિત્વમાં છે.

તમારા પ્લગઈન્સ કેવી રીતે શેર કરવા

જો તમને લાગે કે તમારા પ્લગિન્સ અન્ય લોકો માટે ઉપયોગી થઈ શકે છે, તો તેને GitHub પર શેર કરવા માટે નિઃસંકોચ. તેમને વિષયમાં ઉમેરવાની ખાતરી કરો kubectl-પ્લગઇન્સ.

તમે તમારા પ્લગઇનને ઉમેરવાની વિનંતી પણ કરી શકો છો ક્રુ યાદી. આ કેવી રીતે કરવું તેની સૂચનાઓ આમાં છે GitHub રીપોઝીટરીઝ.

આદેશ પૂર્ણતા

પ્લગઇન્સ હાલમાં સ્વતઃપૂર્ણતાને સમર્થન આપતા નથી. એટલે કે, તમારે પ્લગઇનનું સંપૂર્ણ નામ અને દલીલોના સંપૂર્ણ નામ દાખલ કરવા આવશ્યક છે.

આ કાર્ય માટે GitHub kubectl રીપોઝીટરી ધરાવે છે ખુલ્લી વિનંતી. તેથી શક્ય છે કે આ સુવિધા ભવિષ્યમાં ક્યારેક લાગુ કરવામાં આવશે.

સારા નસીબ!!!

વિષય પર બીજું શું વાંચવું:

1. કુબરનેટ્સમાં ઓટોસ્કેલિંગના ત્રણ સ્તરો અને તેનો અસરકારક રીતે ઉપયોગ કેવી રીતે કરવો.
2. અમલીકરણ માટેના નમૂના સાથે ચાંચિયાગીરીની ભાવનામાં કુબરનેટ્સ.
3. ટેલિગ્રામમાં કુબરનેટ્સની આસપાસ અમારી ચેનલ.

સોર્સ: www.habr.com