🥇kubectl-ஐ மிகவும் திறமையாக எவ்வாறு பயன்படுத்துவது: ஒரு விரிவான வழிகாட்டி

நீங்கள் Kubernetes உடன் பணிபுரிந்தால், kubectl என்பது நீங்கள் அதிகம் பயன்படுத்தும் பயன்பாடுகளில் ஒன்றாகும். மேலும் ஒரு குறிப்பிட்ட கருவியில் நீங்கள் அதிக நேரம் செலவழிக்கும் போதெல்லாம், அதை நன்றாகப் படித்து, அதை எவ்வாறு திறம்பட பயன்படுத்துவது என்பதைக் கற்றுக்கொள்வது பயனளிக்கும்.

அணி Mail.ru இலிருந்து Kubernetes aaS டேனியல் வெய்பலின் ஒரு கட்டுரையை மொழிபெயர்த்தார், அதில் நீங்கள் kubectl உடன் திறம்பட வேலை செய்வதற்கான உதவிக்குறிப்புகள் மற்றும் தந்திரங்களைக் காணலாம். குபெர்னெட்டஸைப் பற்றிய ஆழமான புரிதலைப் பெறவும் இது உதவும்.

ஆசிரியரின் கூற்றுப்படி, கட்டுரையின் குறிக்கோள், குபெர்னெட்ஸுடன் உங்கள் அன்றாட வேலையை மிகவும் திறமையாக மட்டுமல்லாமல், மிகவும் சுவாரஸ்யமாகவும் மாற்றுவதாகும்!

அறிமுகம்: kubectl என்றால் என்ன

நீங்கள் kubectl ஐ மிகவும் திறம்பட பயன்படுத்த கற்றுக்கொள்வதற்கு முன், அது என்ன, அது எவ்வாறு செயல்படுகிறது என்பது பற்றிய அடிப்படை புரிதலை நீங்கள் பெற வேண்டும்.

பயனரின் பார்வையில், kubectl என்பது குபெர்னெட்ஸ் செயல்பாடுகளைச் செய்ய உங்களை அனுமதிக்கும் ஒரு கட்டுப்பாட்டுப் பலகமாகும்.

தொழில்நுட்ப ரீதியாக, kubectl ஒரு குபெர்னெட்டஸ் API கிளையன்ட் ஆகும்.

Kubernetes API என்பது HTTP REST API ஆகும். இந்த API என்பது உண்மையான Kubernetes பயனர் இடைமுகமாகும், இதன் மூலம் இது முழுமையாகக் கட்டுப்படுத்தப்படுகிறது. இதன் பொருள், ஒவ்வொரு குபெர்னெட்டஸ் செயல்பாடும் ஒரு API இறுதிப்புள்ளியாக வெளிப்படும் மற்றும் அந்த இறுதிப்புள்ளிக்கு HTTP கோரிக்கையுடன் செய்யப்படலாம்.

எனவே, kubectl இன் முக்கிய வேலை, Kubernetes API க்கு HTTP கோரிக்கைகளைச் செய்வது:

குபெர்னெட்ஸ் என்பது முற்றிலும் வளம் சார்ந்த அமைப்பாகும். இதன் பொருள் இது வளங்களின் உள் நிலையை பராமரிக்கிறது மற்றும் அனைத்து குபெர்னெட்ஸ் செயல்பாடுகளும் CRUD செயல்பாடுகளாகும்.

இந்த ஆதாரங்களை நிர்வகிப்பதன் மூலம் நீங்கள் குபெர்னெட்ஸின் முழுமையான கட்டுப்பாட்டில் இருக்கிறீர்கள், மேலும் தற்போதைய வளங்களின் நிலையின் அடிப்படையில் என்ன செய்ய வேண்டும் என்பதை குபெர்னெட்ஸ் கண்டுபிடிப்பார். இந்த காரணத்திற்காக, Kubernetes API குறிப்பு, அவற்றின் தொடர்புடைய செயல்பாடுகளுடன் வள வகைகளின் பட்டியலாக ஒழுங்கமைக்கப்பட்டுள்ளது.

ஒரு உதாரணத்தைப் பார்ப்போம்.

நீங்கள் ReplicaSet ஆதாரத்தை உருவாக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். இதைச் செய்ய, ஒரு கோப்பில் உள்ள பிரதிசெட்டை பெயரால் விவரிக்கிறீர்கள் replicaset.yaml, பின்னர் கட்டளையை இயக்கவும்:

$ kubectl create -f replicaset.yaml

இது ReplicaSet ஆதாரத்தை உருவாக்கும். ஆனால் திரைக்குப் பின்னால் என்ன நடக்கிறது?

குபெர்னெட்டஸ் ரெப்லிகாசெட் உருவாக்கும் செயல்பாட்டைக் கொண்டுள்ளது. மற்ற செயல்பாடுகளைப் போலவே, இது ஒரு API இறுதிப் புள்ளியாக வெளிப்படும். இந்தச் செயல்பாட்டிற்கான குறிப்பிட்ட API முடிவுப் புள்ளி இதுபோல் தெரிகிறது:

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

அனைத்து குபெர்னெட்ஸ் செயல்பாடுகளுக்கான API இறுதிப்புள்ளிகளை இங்கே காணலாம் API குறிப்பு (உட்பட மேலே உள்ள இறுதிப்புள்ளி) இறுதிப் புள்ளிக்கு உண்மையான கோரிக்கையைச் செய்ய, API குறிப்பில் பட்டியலிடப்பட்டுள்ள இறுதிப்புள்ளி பாதைகளில் API சேவையக URL ஐ முதலில் சேர்க்க வேண்டும்.

எனவே, நீங்கள் மேலே உள்ள கட்டளையை இயக்கும் போது, மேலே உள்ள API இறுதிப் புள்ளிக்கு kubectl ஒரு HTTP POST கோரிக்கையை அனுப்புகிறது. கோப்பில் நீங்கள் வழங்கிய ReplicaSet வரையறை replicaset.yaml, கோரிக்கையின் உடலில் அனுப்பப்படுகிறது.

குபெர்னெட்ஸ் கிளஸ்டருடன் தொடர்பு கொள்ளும் அனைத்து கட்டளைகளுக்கும் kubectl இப்படித்தான் செயல்படுகிறது. இந்த எல்லா நிகழ்வுகளிலும், kubectl வெறுமனே HTTP கோரிக்கைகளை பொருத்தமான Kubernetes API இறுதிப்புள்ளிகளுக்கு செய்கிறது.

நீங்கள் குபெர்னெட்ஸை முழுமையாக நிர்வகிக்க முடியும் என்பதை கவனத்தில் கொள்ளவும் curlகைமுறையாக HTTP கோரிக்கைகளை Kubernetes API க்கு அனுப்புவதன் மூலம். குபெக்ட்ல் குபெர்னெட்ஸ் ஏபிஐ பயன்படுத்துவதை எளிதாக்குகிறது.

kubectl என்றால் என்ன, அது எவ்வாறு செயல்படுகிறது என்பதற்கான அடிப்படை இதுதான். ஆனால் ஒவ்வொரு kubectl பயனரும் தெரிந்து கொள்ள வேண்டிய Kubernetes API பற்றி வேறு ஏதாவது உள்ளது. குபெர்னெட்டஸின் உள் உலகத்தை விரைவாகப் பார்ப்போம்.

குபெர்னெட்டஸின் உள் உலகம்

குபெர்னெட்டஸ் என்பது கிளஸ்டர் முனைகளில் தனித்தனி செயல்முறைகளாக இயங்கும் சுயாதீன கூறுகளின் தொகுப்பைக் கொண்டுள்ளது. சில கூறுகள் முதன்மை முனைகளில் இயங்குகின்றன, மற்றவை பணியாளர் முனைகளில் இயங்குகின்றன, ஒவ்வொரு கூறுகளும் அதன் சொந்த குறிப்பிட்ட பணியைச் செய்கின்றன.

முக்கிய முனைகளில் மிக முக்கியமான கூறுகள் இங்கே:

களஞ்சியம் - வள வரையறைகளை சேமிக்கிறது (பொதுவாக இது போன்றவை).
API சேவையகம் — API ஐ வழங்குகிறது மற்றும் சேமிப்பகத்தை நிர்வகிக்கிறது.
கட்டுப்பாட்டு மேலாளர் - வள நிலைகள் விவரக்குறிப்புகளுடன் இணங்குவதை உறுதி செய்கிறது.
திட்டமிடுபவர் - பணியாளர் முனைகளில் காய்களை திட்டமிடுகிறது.

தொழிலாளர் முனைகளில் ஒரு மிக முக்கியமான கூறு இங்கே:

குபேலேட் - வேலை செய்யும் முனையில் கொள்கலன்களின் துவக்கத்தை நிர்வகிக்கிறது.

இந்த கூறுகள் எவ்வாறு ஒன்றாக வேலை செய்கின்றன என்பதைப் புரிந்து கொள்ள, ஒரு உதாரணத்தைப் பார்ப்போம்.

நீங்கள் முடித்துவிட்டீர்கள் என்று வைத்துக்கொள்வோம் kubectl create -f replicaset.yaml, அதன் பிறகு kubectl ஒரு HTTP POST கோரிக்கையை செய்தது பிரதிசெட் API இறுதிப்புள்ளி (ReplicaSet வள வரையறையை கடந்து).

கிளஸ்டரில் என்ன நடக்கிறது?

செய்த பிறகு kubectl create -f replicaset.yaml API சேவையகம் உங்கள் ReplicaSet ஆதார வரையறையை சேமிப்பகத்தில் சேமிக்கிறது:
அடுத்து, ரெப்லிகாசெட் கன்ட்ரோலர் கன்ட்ரோலர் மேனேஜரில் தொடங்கப்படுகிறது, இது ரெப்லிகாசெட் ஆதாரங்களை உருவாக்குதல், மாற்றுதல் மற்றும் நீக்குதல் ஆகியவற்றைக் கையாளுகிறது:
ReplicaSet கட்டுப்படுத்தி ஒவ்வொரு ReplicaSet பிரதிக்கும் ஒரு பாட் வரையறையை உருவாக்குகிறது (ReplicaSet வரையறையில் உள்ள பாட் டெம்ப்ளேட்டின் படி) மற்றும் அவற்றை சேமிப்பகத்தில் சேமிக்கிறது:
திட்டமிடல் தொடங்கப்பட்டது, இதுவரை எந்த ஒரு பணியாளருக்கும் ஒதுக்கப்படாத காய்களைக் கண்காணிக்கிறது:
திட்டமிடுபவர் ஒவ்வொரு காய்க்கும் பொருத்தமான பணியாளரைத் தேர்ந்தெடுத்து, கடையில் உள்ள பாட் வரையறையில் இந்தத் தகவலைச் சேர்க்கிறார்:
பாட் ஒதுக்கப்பட்ட பணியாளரின் முனையில், குபெலெட் தொடங்கப்பட்டது, இது இந்த முனைக்கு ஒதுக்கப்பட்ட காய்களைக் கண்காணிக்கிறது:
குபெலெட் சேமிப்பகத்திலிருந்து பாட் வரையறையைப் படிக்கிறது மற்றும் முனையில் கொள்கலன்களைத் தொடங்க டோக்கர் போன்ற கொள்கலன் இயக்க நேரத்தை அறிவுறுத்துகிறது:

இந்த விளக்கத்தின் உரைப் பதிப்பு கீழே உள்ளது.

ReplicaSet உருவாக்கும் இறுதிப்புள்ளிக்கான API கோரிக்கை API சேவையகத்தால் செயலாக்கப்படுகிறது. API சேவையகம் கோரிக்கையை அங்கீகரிக்கிறது மற்றும் சேமிப்பகத்தில் ReplicaSet ஆதார வரையறையை சேமிக்கிறது.

இந்த நிகழ்வு ரெப்லிகாசெட் கன்ட்ரோலரைத் தொடங்குகிறது, இது கட்டுப்படுத்தி மேலாளரின் துணைச் செயலாகும். ReplicaSet கன்ட்ரோலர் ஸ்டோரில் உள்ள ReplicaSet ஆதாரங்களை உருவாக்குதல், புதுப்பித்தல் மற்றும் நீக்குதல் ஆகியவற்றைக் கண்காணித்து, இது நிகழும்போது நிகழ்வு அறிவிப்பைப் பெறுகிறது.

ReplicaSet கன்ட்ரோலரின் வேலை, தேவையான எண்ணிக்கையிலான ReplicaSet காய்கள் இருப்பதை உறுதி செய்வதாகும். எங்கள் எடுத்துக்காட்டில், இதுவரை காய்கள் எதுவும் இல்லை, எனவே ReplicaSet கட்டுப்படுத்தி இந்த பாட் வரையறைகளை உருவாக்குகிறது (ReplicaSet வரையறையில் உள்ள பாட் டெம்ப்ளேட்டின் படி) அவற்றை சேமிப்பகத்தில் சேமிக்கிறது.

புதிய காய்களின் உருவாக்கம், பணியாளர் முனைகளுக்கு இன்னும் திட்டமிடப்படாத பாட் வரையறைகளைக் கண்காணிக்கும் ஒரு திட்டமிடுபவர் மூலம் தூண்டப்படுகிறது. திட்டமிடுபவர் ஒவ்வொரு காய்க்கும் பொருத்தமான தொழிலாளி முனையைத் தேர்ந்தெடுத்து, களஞ்சியத்தில் உள்ள பாட் வரையறைகளைப் புதுப்பிக்கிறார்.

இது வரை, கிளஸ்டரில் எங்கும் பணிச்சுமை குறியீடு இயங்கவில்லை என்பதை நினைவில் கொள்ளவும். இதுவரை செய்தவை அனைத்தும் - இது முதன்மை முனையில் உள்ள களஞ்சியத்தில் உள்ள வளங்களை உருவாக்குதல் மற்றும் புதுப்பித்தல் ஆகும்.

கடைசி நிகழ்வு குபெலெட்ஸைத் தூண்டுகிறது, இது அவர்களின் தொழிலாளர் முனைகளுக்குத் திட்டமிடப்பட்ட காய்களைக் கண்காணிக்கிறது. உங்கள் ReplicaSet காய்கள் நிறுவப்பட்டிருக்கும் பணியாளர் முனையின் Kubelet, தேவையான கண்டெய்னர் படங்களைப் பதிவிறக்கி அவற்றை இயக்க, Docker போன்ற கொள்கலன் இயக்க நேரத்தை அறிவுறுத்த வேண்டும்.

இந்த கட்டத்தில், உங்கள் ReplicaSet பயன்பாடு இறுதியாக இயங்குகிறது!

குபெர்னெட்ஸ் API இன் பங்கு

முந்தைய எடுத்துக்காட்டில் நீங்கள் பார்த்தது போல், குபெர்னெட்டஸ் கூறுகள் (API சேவையகம் மற்றும் சேமிப்பகத்தைத் தவிர) சேமிப்பகத்தில் உள்ள வளங்களில் ஏற்படும் மாற்றங்களைக் கவனிக்கின்றன மற்றும் சேமிப்பகத்தில் உள்ள வளங்களைப் பற்றிய தகவலை மாற்றுகின்றன.

நிச்சயமாக, இந்த கூறுகள் சேமிப்பகத்துடன் நேரடியாக தொடர்பு கொள்ளாது, ஆனால் குபெர்னெட்ஸ் API மூலம் மட்டுமே.

பின்வரும் உதாரணங்களைக் கவனியுங்கள்:

ReplicaSet கட்டுப்படுத்தி API இறுதிப் புள்ளியைப் பயன்படுத்துகிறது பட்டியல் பிரதிகள் அளவுருவுடன் watch ReplicaSet ஆதாரங்களில் ஏற்படும் மாற்றங்களைக் கண்காணிக்க.
ReplicaSet கட்டுப்படுத்தி API இறுதிப் புள்ளியைப் பயன்படுத்துகிறது பாட் உருவாக்க (உருவாக்கு) காய்களை உருவாக்க.
திட்டமிடுபவர் API இறுதிப் புள்ளியைப் பயன்படுத்துகிறார் இணைப்பு நெற்று தேர்ந்தெடுக்கப்பட்ட பணியாளரின் முனையைப் பற்றிய தகவலுடன் காய்களைப் புதுப்பிக்க.

நீங்கள் பார்க்க முடியும் என, இது kubectl அணுகும் அதே API ஆகும். உள் கூறுகள் மற்றும் வெளிப்புற பயனர்களுக்கு ஒரே API ஐப் பயன்படுத்துவது Kubernetes வடிவமைப்பில் ஒரு அடிப்படைக் கருத்தாகும்.

குபெர்னெட்டஸ் எவ்வாறு செயல்படுகிறது என்பதை இப்போது சுருக்கமாகக் கூறலாம்:

சேமிப்பக அங்காடிகள் கூறுகின்றன, அதாவது குபெர்னெட்ஸ் வளங்கள்.
API சேவையகம் குபெர்னெட்ஸ் API வடிவத்தில் சேமிப்பகத்திற்கு ஒரு இடைமுகத்தை வழங்குகிறது.
மற்ற அனைத்து குபெர்னெட்ஸ் கூறுகளும் பயனர்களும் ஏபிஐ மூலம் குபெர்னெட்ஸ் நிலையை (வளங்கள்) படிக்கிறார்கள், கவனிக்கிறார்கள் மற்றும் கையாளுகிறார்கள்.

இந்தக் கருத்துகளை அறிந்துகொள்வது, kubectl ஐ நன்றாகப் புரிந்துகொள்ளவும், அதிலிருந்து அதிகமானவற்றைப் பெறவும் உதவும்.

இப்போது kubectl மூலம் உங்கள் உற்பத்தித்திறனை மேம்படுத்த உதவும் சில குறிப்பிட்ட குறிப்புகள் மற்றும் தந்திரங்களைப் பார்ப்போம்.

1. கட்டளையை நிறைவு செய்வதைப் பயன்படுத்தி உள்ளீட்டை விரைவுபடுத்துங்கள்

மிகவும் பயனுள்ள, ஆனால் பெரும்பாலும் கவனிக்கப்படாத, kubectl உடன் செயல்திறனை மேம்படுத்துவதற்கான நுட்பங்களில் ஒன்று கட்டளை நிறைவு ஆகும்.

Tab விசையைப் பயன்படுத்தி kubectl கட்டளைகளின் பகுதிகளை தானாக முடிக்க கட்டளை நிறைவு உங்களை அனுமதிக்கிறது. இது துணைக் கட்டளைகள், விருப்பங்கள் மற்றும் வாதங்களுக்குச் செயல்படுகிறது, இதில் வளப் பெயர்கள் போன்ற சிக்கலான ஒன்று அடங்கும்.

kubectl கட்டளை நிறைவு எவ்வாறு செயல்படுகிறது என்பதைப் பார்க்கவும்:

Bash மற்றும் 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

இது ஷெல் செயல்பாட்டுக் குறியீட்டை வெளியிட்டால், bash-completion சரியாக நிறுவப்படும். கட்டளை "கண்டுபிடிக்கப்படவில்லை" பிழையைக் கொடுத்தால், உங்கள் கோப்பில் பின்வரும் வரியைச் சேர்க்க வேண்டும் ~ / .bashrc:

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

இந்த வரியை கோப்பில் சேர்க்க வேண்டியது அவசியமா ~ / .bashrc அல்லது நீங்கள் bash-completion ஐ நிறுவப் பயன்படுத்திய தொகுப்பு மேலாளரைப் பொறுத்தது அல்ல. இது APTக்கு அவசியம், ஆனால் YUMக்கு அல்ல.

bash-completion ஐ நிறுவிய பின், அனைத்து ஷெல் அமர்வுகளிலும் kubectl completion ஸ்கிரிப்ட் இயக்கப்படும்படி நீங்கள் அனைத்தையும் உள்ளமைக்க வேண்டும்.

இதைச் செய்வதற்கான ஒரு வழி, கோப்பில் பின்வரும் வரியைச் சேர்ப்பது ~ / .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 ஆனது Bash பதிப்பு 3.2 ஐப் பயன்படுத்துகிறது, மேலும் kubectl தன்னியக்க ஸ்கிரிப்ட்டிற்கு குறைந்தபட்சம் 4.1 இன் Bash பதிப்பு தேவைப்படுகிறது மற்றும் அது Bash 3.2 இல் வேலை செய்யாது.

MacOS இல் பாஷின் காலாவதியான பதிப்பைப் பயன்படுத்துவதில் உரிமச் சிக்கல்கள் உள்ளன. பாஷ் பதிப்பு 4 GPLv3 இன் கீழ் உரிமம் பெற்றது, இது Apple ஆல் ஆதரிக்கப்படவில்லை.

MacOS இல் kubectl தன்னியக்கத்தை உள்ளமைக்க, நீங்கள் Bash இன் சமீபத்திய பதிப்பை நிறுவ வேண்டும். புதுப்பிக்கப்பட்ட பாஷை உங்கள் இயல்புநிலை ஷெல்லாகவும் அமைக்கலாம், இது எதிர்காலத்தில் உங்களுக்கு நிறைய சிக்கல்களைச் சேமிக்கும். இது கடினம் அல்ல, விவரங்கள் கட்டுரையில் கொடுக்கப்பட்டுள்ளன "MacOS இல் பாஷைப் புதுப்பிக்கிறது".

தொடர்வதற்கு முன், நீங்கள் பாஷின் சமீபத்திய பதிப்பைப் பயன்படுத்துகிறீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள் (வெளியீட்டைச் சரிபார்க்கவும் bash --version).

பாஷ் நிறைவு ஸ்கிரிப்ட் திட்டப்படி மாறுபடும் பாஷ்-நிறைவு, எனவே நீங்கள் முதலில் அதை நிறுவ வேண்டும்.

நீங்கள் பயன்படுத்தி bash-completion ஐ நிறுவலாம் homebrew:

$ brew install bash-completion@2

இது @2 bash-completion version 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

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பாத்.

JSONPath என்பது JSON ஆவணங்களிலிருந்து தரவை மீட்டெடுப்பதற்கான ஒரு மொழியாகும். 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'

[] ஆபரேட்டர் குறிப்பாக முக்கியமானது. பல குபெர்னெட்ஸ் ஆதார புலங்கள் பட்டியல்களாகும், மேலும் இந்த ஆபரேட்டர் அந்த பட்டியல்களின் உறுப்பினர்களைத் தேர்ந்தெடுக்க உங்களை அனுமதிக்கிறது. பட்டியலின் அனைத்து கூறுகளையும் தேர்ந்தெடுக்க இது பெரும்பாலும் [*] போன்ற வைல்டு கார்டுடன் பயன்படுத்தப்படுகிறது.

பயன்பாட்டு எடுத்துக்காட்டுகள்

தனிப்பயன் நெடுவரிசை வெளியீட்டு வடிவமைப்பைப் பயன்படுத்துவதற்கான சாத்தியக்கூறுகள் முடிவற்றவை, ஏனெனில் வெளியீட்டில் நீங்கள் எந்த புலத்தையும் அல்லது வளப் புலங்களின் கலவையையும் காட்டலாம். இங்கே சில மாதிரி பயன்பாடுகள் உள்ளன, ஆனால் அவற்றை நீங்களே ஆராய்ந்து உங்களுக்காக வேலை செய்யும் பயன்பாடுகளைக் கண்டறிய தயங்க வேண்டாம்.

காய்களுக்கான கொள்கலன் படங்களைக் காட்டுகிறது:
```
$ 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
```
இந்த கட்டளை ஒவ்வொரு பாட்க்கான கொள்கலன் பட பெயர்களைக் காட்டுகிறது.
ஒரு பாட் பல கொள்கலன்களைக் கொண்டிருக்கலாம் என்பதை நினைவில் கொள்ளுங்கள், பின்னர் படத்தின் பெயர்கள் காற்புள்ளிகளால் பிரிக்கப்பட்ட ஒரு வரியில் காட்டப்படும்.
முனை கிடைக்கும் மண்டலங்களைக் காட்டுகிறது:
```
$ 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 ஹரே கிளஸ்டருடன் இணைக்கப்படும்.

அதன்படி, மற்றொரு கிளஸ்டருக்கு மாற, நீங்கள் kubeconfig கோப்பில் தற்போதைய சூழலை மாற்ற வேண்டும்:

இப்போது kubectl ஃபாக்ஸ் கிளஸ்டருடன் இணைக்கப்படும்.

ஒரே கிளஸ்டரில் வேறு பெயர்வெளிக்கு மாற, தற்போதைய சூழலுக்கான பெயர்வெளி உறுப்பின் மதிப்பை மாற்ற வேண்டும்:

மேலே உள்ள எடுத்துக்காட்டில், kubectl Fox cluster's Prod namespace ஐப் பயன்படுத்தும் (முன்பு டெஸ்ட் பெயர்வெளி அமைக்கப்பட்டது).

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 போன்ற செயல்பாட்டை வழங்கும் இந்த கட்டளைகளின் அடிப்படையில் மாற்றுப்பெயர்களின் தொகுப்பை உருவாக்கினேன். இங்கே நீங்கள் அவற்றை செயலில் காணலாம்:

மாற்றுப்பெயர்கள் ஒரு ஊடாடத்தக்க இலவச தேடல் இடைமுகத்தை வழங்க 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 பெயர்வெளியை மாற்ற வேண்டும்.

இதைச் செய்யும் இரண்டு செருகுநிரல்களை நான் எழுதியுள்ளேன்:

செருகுநிரல்களின் வேலை முந்தைய பிரிவின் மாற்றுப்பெயர்களை அடிப்படையாகக் கொண்டது.

அவை எவ்வாறு செயல்படுகின்றன என்பது இங்கே:

ஊடாடத்தக்க இலவச தேடல் இடைமுகத்தை வழங்க செருகுநிரல்கள் fzf ஐப் பயன்படுத்துகின்றன என்பதை நினைவில் கொள்ளவும் (kubectx இன் ஊடாடும் முறை போன்றவை). இதன் பொருள் உங்களுக்குத் தேவை fzf ஐ நிறுவவும்இந்த மாற்றுப்பெயர்களைப் பயன்படுத்த.

செருகுநிரல்களை நிறுவ, பெயரிடப்பட்ட ஷெல் ஸ்கிரிப்ட்களைப் பதிவிறக்க வேண்டும் kubectl-ctx и kubectl-ns உங்கள் PATH மாறியில் உள்ள எந்த கோப்பகத்திற்கும், எ.கா. chmod +x. இதற்குப் பிறகு உடனடியாக நீங்கள் பயன்படுத்த முடியும் kubectl ctx и kubectl ns.

5. ஆட்டோஅலியாஸ்கள் மூலம் உள்ளீட்டைக் குறைக்கவும்

உள்ளீட்டை விரைவுபடுத்த ஷெல் மாற்றுப்பெயர்கள் ஒரு சிறந்த வழியாகும். திட்டம் kubectl - மாற்றுப்பெயர்கள் அடிப்படை kubectl கட்டளைகளுக்கு சுமார் 800 குறுக்குவழிகள் உள்ளன.

நீங்கள் ஆச்சரியப்படலாம் - 800 மாற்றுப்பெயர்களை நீங்கள் எப்படி நினைவில் கொள்கிறீர்கள்? ஆனால் நீங்கள் அனைத்தையும் நினைவில் வைத்திருக்க வேண்டிய அவசியமில்லை, ஏனென்றால் அவை ஒரு எளிய திட்டத்தின் படி கட்டப்பட்டுள்ளன, இது கீழே கொடுக்கப்பட்டுள்ளது:

உதாரணமாக:

kgpooyaml - kubectl காய்கள் ஓயமல் கிடைக்கும்
ksysgsvcw — kubectl -n kube-system get svc w
ksysrmcm -kubectl -n kube-system rm செ.மீ
kgdepallsl - kubectl வரிசைப்படுத்தல் அனைத்து sl

நீங்கள் பார்க்க முடியும் என, மாற்றுப்பெயர்கள் கூறுகளால் ஆனவை, அவை ஒவ்வொன்றும் kubectl கட்டளையின் ஒரு குறிப்பிட்ட உறுப்பைக் குறிக்கின்றன. ஒவ்வொரு மாற்றுப்பெயரும் அடிப்படை கட்டளை, செயல்பாடு மற்றும் வளத்திற்கான ஒரு கூறு மற்றும் அளவுருக்களுக்கான பல கூறுகளைக் கொண்டிருக்கலாம். மேலே உள்ள வரைபடத்தின்படி இந்த கூறுகளை இடமிருந்து வலமாக "பிரதிப்படுத்துங்கள்".

தற்போதைய விரிவான வரைபடம் உள்ளது மகிழ்ச்சியா. அங்கேயும் காணலாம் மாற்றுப்பெயர்களின் முழு பட்டியல்.

எடுத்துக்காட்டாக, kgpooyamlall என்ற மாற்றுப்பெயர் கட்டளைக்கு சமமானது kubectl get pods -o yaml --all-namespaces.

விருப்பங்களின் ஒப்பீட்டு வரிசை முக்கியமல்ல: கட்டளை kgpooyamlall கட்டளைக்கு சமமானது kgpoalloyaml.

நீங்கள் அனைத்து கூறுகளையும் மாற்றுப்பெயர்களாகப் பயன்படுத்த வேண்டியதில்லை. உதாரணத்திற்கு k, kg, klo, ksys, kgpo பயன்படுத்தவும் முடியும். மேலும், நீங்கள் மாற்றுப்பெயர்கள் மற்றும் வழக்கமான கட்டளைகள் அல்லது விருப்பங்களை கட்டளை வரியில் இணைக்கலாம்:

உதாரணமாக:

அதற்கு பதிலாக kubectl proxy நீங்கள் எழுதலாம் k proxy.
அதற்கு பதிலாக kubectl get roles நீங்கள் எழுதலாம் kg roles (பாத்திரங்கள் வளத்திற்கு தற்போது மாற்றுப்பெயர் எதுவும் இல்லை).
ஒரு குறிப்பிட்ட பாட்க்கான தரவைப் பெற, நீங்கள் கட்டளையைப் பயன்படுத்தலாம் 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 கட்டளையை நிறைவு செய்வதைப் பயன்படுத்தினால், ஆதாரப் பெயர்கள் போன்றவற்றிற்கு தானாக நிரப்புதலைப் பயன்படுத்தியிருக்கலாம். ஆனால் மாற்றுப்பெயர்களைப் பயன்படுத்தும்போது இதைச் செய்ய முடியுமா?

இது ஒரு மிக முக்கியமான கேள்வி, ஏனெனில் தன்னியக்க நிறைவு வேலை செய்யவில்லை என்றால், மாற்றுப்பெயர்களின் சில நன்மைகளை நீங்கள் இழப்பீர்கள்.

பதில் நீங்கள் எந்த ஷெல் பயன்படுத்துகிறீர்கள் என்பதைப் பொறுத்தது:

Zsh க்கு, மாற்று நிறைவு என்பது பெட்டிக்கு வெளியே வேலை செய்கிறது.
பாஷுக்கு, துரதிர்ஷ்டவசமாக, வேலை செய்யத் தானாக நிறைவு பெற சில வேலைகள் தேவை.

பாஷில் மாற்றுப்பெயர்களுக்குத் தானாக நிரப்புதலை இயக்குகிறது

பாஷில் உள்ள சிக்கல் என்னவென்றால், அது மாற்றுப்பெயரை (உதாரணமாக, Zsh செய்வது போல) குறிப்பிடும் கட்டளையை அல்ல, (உதாரணமாக, Tab ஐ அழுத்தும் ஒவ்வொரு முறையும்) மாற்றுப்பெயரை முடிக்க முயற்சிக்கிறது. 800 மாற்றுப்பெயர்களுக்கான நிறைவு ஸ்கிரிப்ட்கள் உங்களிடம் இல்லாததால், தன்னியக்க நிறைவு வேலை செய்யாது.

திட்டம் முழுமையான மாற்றுப்பெயர் இந்த பிரச்சனைக்கு பொதுவான தீர்வை வழங்குகிறது. இது மாற்றுப்பெயர்களுக்கான நிறைவு பொறிமுறையுடன் இணைகிறது, உள்நாட்டில் மாற்றுப்பெயரை ஒரு கட்டளையாக விரிவுபடுத்துகிறது மற்றும் முடிக்கப்பட்ட கட்டளைக்கான நிறைவு விருப்பங்களை வழங்குகிறது. இதன் பொருள் மாற்றுப்பெயருக்கான திணிப்பு ஒரு முழு கட்டளையைப் போலவே செயல்படுகிறது.

பின்வருவனவற்றில், நான் முதலில் முழுமையான மாற்றுப்பெயரை எவ்வாறு நிறுவுவது என்பதை விளக்குகிறேன், பின்னர் அனைத்து kubectl மாற்றுப்பெயர்களையும் நிறைவு செய்ய அதை எவ்வாறு கட்டமைப்பது என்பதை விளக்குகிறேன்.

முழுமையான மாற்றுப்பெயரை நிறுவுதல்

முதலில், முழுமையான மாற்றுப்பெயர் சார்ந்தது பாஷ்-நிறைவு. எனவே, முழுமையான மாற்றுப்பெயரை நிறுவும் முன், bash-completion நிறுவப்பட்டுள்ளதா என்பதை உறுதி செய்ய வேண்டும். Linux மற்றும் MacOS க்கு முன்பு நிறுவல் வழிமுறைகள் வழங்கப்பட்டுள்ளன.

MacOS பயனர்களுக்கான முக்கிய குறிப்பு: kubectl தன்னியக்க ஸ்கிரிப்டைப் போலவே, MacOS இல் இயல்புநிலையாக இருக்கும் Bash 3.2 உடன் முழுமையான மாற்றுப்பெயர் இயங்காது. குறிப்பாக, முழுமையான மாற்றுப்பெயர் பாஷ்-நிறைவு v2 (brew install bash-completion@2), இதற்கு குறைந்தபட்சம் பாஷ் 4.1 தேவைப்படுகிறது. MacOS இல் முழுமையான மாற்றுப்பெயரைப் பயன்படுத்த, நீங்கள் Bash இன் புதிய பதிப்பை நிறுவ வேண்டும்.

நீங்கள் ஸ்கிரிப்டை பதிவிறக்கம் செய்ய வேண்டும் bash_completion.sh из கிட்ஹப் களஞ்சியம் மற்றும் அதை உங்கள் கோப்பில் சேர்க்கவும் ~/.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

உங்களிடம் ஒரே பெயரில் பல செருகுநிரல்கள் இருந்தால் அல்லது செயல்படுத்த முடியாத செருகுநிரல் கோப்பு இருந்தால் இந்த கட்டளை எச்சரிக்கைகளையும் காண்பிக்கும்.

க்ரூவைப் பயன்படுத்தி செருகுநிரல்களைக் கண்டுபிடித்து நிறுவுதல்

Kubectl செருகுநிரல்களை மென்பொருள் தொகுப்புகள் போன்று பகிரலாம் அல்லது மீண்டும் பயன்படுத்தலாம். ஆனால் மற்றவர்கள் பகிர்ந்த செருகுநிரல்களை எங்கே காணலாம்?

திட்ட க்ரூ kubectl செருகுநிரல்களைப் பகிர்வதற்கும், தேடுவதற்கும், நிறுவுவதற்கும் மற்றும் நிர்வகிப்பதற்கும் ஒரு ஒருங்கிணைந்த தீர்வை வழங்குவதை நோக்கமாகக் கொண்டுள்ளது. திட்டமானது தன்னை "குபெக்ட்ல் செருகுநிரல்களுக்கான தொகுப்பு மேலாளர்" என்று அழைக்கிறது (க்ரூ இதைப் போன்றது கஷாயம்).

Krew என்பது நீங்கள் தேர்ந்தெடுத்து நிறுவக்கூடிய kubectl செருகுநிரல்களின் பட்டியல். அதே நேரத்தில், க்ரூவும் kubectl க்கான செருகுநிரலாகும்.

இதன் பொருள் Krew ஐ நிறுவுவது வேறு எந்த kubectl செருகுநிரலை நிறுவுவது போல வேலை செய்கிறது. நீங்கள் விரிவான வழிமுறைகளைக் காணலாம் கிட்ஹப் பக்கம்.

மிக முக்கியமான க்ரூ கட்டளைகள்:

# Поиск в списке плагинов
$ 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 க்ரூவைப் பயன்படுத்தி நிறுவப்பட்ட செருகுநிரல்களை மட்டுமே காட்டுகிறது, அதேசமயம் கட்டளை 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 ஐப் பயன்படுத்தினால், நீங்களும் பயன்படுத்தலாம் cli-இயக்க நேர நூலகம், இது குறிப்பாக kubectl செருகுநிரல்களை எழுதுவதற்கு உள்ளது.

உங்கள் செருகுநிரல்களை எவ்வாறு பகிர்வது

உங்கள் செருகுநிரல்கள் மற்றவர்களுக்கு பயனுள்ளதாக இருக்கும் என நீங்கள் நினைத்தால், அதை GitHub இல் பகிரலாம். அவற்றை தலைப்பில் சேர்க்க மறக்காதீர்கள் kubectl-plugins.

உங்கள் செருகுநிரலைச் சேர்க்குமாறும் நீங்கள் கோரலாம் க்ரூ பட்டியல். இதை எப்படி செய்வது என்பதற்கான வழிமுறைகள் உள்ளன கிட்ஹப் களஞ்சியங்கள்.

கட்டளை நிறைவு

செருகுநிரல்கள் தற்போது தானாக நிறைவு செய்வதை ஆதரிக்கவில்லை. அதாவது, நீங்கள் செருகுநிரலின் முழுப் பெயரையும் வாதங்களின் முழுப் பெயர்களையும் உள்ளிட வேண்டும்.

இந்தச் செயல்பாட்டிற்கான GitHub kubectl களஞ்சியத்தில் உள்ளது திறந்த கோரிக்கை. எனவே, இந்த அம்சம் எதிர்காலத்தில் செயல்படுத்தப்படும்.

நல்ல அதிர்ஷ்டம்!!!

தலைப்பில் வேறு என்ன படிக்க வேண்டும்:

ஆதாரம்: www.habr.com

kubectl ஐ மிகவும் திறம்பட பயன்படுத்துவது எப்படி: ஒரு விரிவான வழிகாட்டி