குபெர்னெட்டஸின் சரியான ஒப்பீடு விண்ணப்பிக்கவும், மாற்றவும் மற்றும் ஒட்டவும்

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

என்றால் கூகுளில் தேடவும் "kubernetes apply vs replace" என்ற சொற்றொடர் அமைந்துள்ளது StackOverflowக்கு பதில், இது சரியல்ல. தேடும் போது "kubernetes apply vs patch" என்பதற்கான ஆவணம் முதல் இணைப்பு kubectl patch, இதில் ஒப்பீடு இல்லை apply и patch. இந்த கட்டுரை வெவ்வேறு விருப்பங்களையும், ஒவ்வொன்றின் சரியான பயன்பாட்டையும் பார்க்கலாம்.

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

குபெர்னெட்டஸ் CLI

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

அனைவருக்கும் கட்டளைகள் தெரியாது patch и replace. குழு patch கட்டளை வரியில் மாற்றப்பட்ட பகுதியை மட்டும் வழங்கும், வள விவரக்குறிப்பின் பகுதியை மாற்ற உங்களை அனுமதிக்கிறது. குழு replace போலவே செயல்படுகிறது edit, ஆனால் எல்லாவற்றையும் கைமுறையாக செய்ய வேண்டும்: ஆதார விவரக்குறிப்பின் தற்போதைய பதிப்பை நீங்கள் பதிவிறக்க வேண்டும், எடுத்துக்காட்டாக, பயன்படுத்தி kubectl get -o yaml, அதை திருத்தி, பிறகு பயன்படுத்தவும் replace மாற்றப்பட்ட விவரக்குறிப்பின்படி ஒரு வளத்தைப் புதுப்பிக்க. குழு replace ஆதாரத்தை வாசிப்பதற்கும் மாற்றுவதற்கும் இடையில் ஏதேனும் மாற்றங்கள் ஏற்பட்டால் வேலை செய்யாது.

குபெர்னெட்ஸ் ஏபிஐ

முறைகளை நீங்கள் அறிந்திருக்கலாம் CoreV1().Pods().Update(), replaceNamespacedService அல்லது patch_namespaced_deployment, நீங்கள் கிளஸ்டர்களுடன் வேலை செய்தால் Kubernetes API க்கான கிளையன்ட் லைப்ரரி சில நிரலாக்க மொழியைப் பயன்படுத்துதல். முறைகளைப் பயன்படுத்தி HTTP கோரிக்கைகள் வழியாக இந்த முறைகளை நூலகம் கையாளுகிறது PUT и PATCH... இதில் update и replace பயன்பாடு PUTமற்றும் patch, அது எவ்வளவு அற்பமானதாக இருந்தாலும், பயன்படுத்துகிறது PATCH.

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

இயல்பாக பேட்ச்

சிறப்பாக பயன்படுத்தப்பட்டது patch, நீங்கள் வளத்தைப் புதுப்பிக்க விரும்பினால். இரண்டு கிளையன்ட் லைப்ரரிகளும் குபெர்னெட்ஸ் ஏபிஐக்கு மேல் இப்படித்தான் வேலை செய்கின்றன kubectl (ஆச்சரியப்படுவதற்கில்லை, ஏனெனில் இது கிளையன்ட் லைப்ரரிக்கான ரேப்பர், தோராயமாக மொழிபெயர்ப்பாளர்).

மூலோபாயமாக வேலை செய்யுங்கள்

அனைத்து அணிகளும் kubectl apply, edit и patch முறையைப் பயன்படுத்தவும் PATCH HTTP கோரிக்கைகளில் ஏற்கனவே உள்ள வளத்தைப் புதுப்பிக்க வேண்டும். கட்டளைகளை செயல்படுத்துவதை நீங்கள் இன்னும் விரிவாக ஆராய்ந்தால், அவை அனைத்தும் அணுகுமுறையைப் பயன்படுத்துகின்றன மூலோபாய-இணைப்பு இணைப்பு கட்டளை என்றாலும், வளங்களை புதுப்பிக்க patch மற்ற அணுகுமுறைகளைப் பயன்படுத்தலாம் (இதைப் பற்றி மேலும் கீழே). மூலோபாய-சேர்க்கை இணைப்பு அணுகுமுறையானது, வழங்கப்பட்ட விவரக்குறிப்பை ஏற்கனவே உள்ள விவரக்குறிப்புடன் இணைப்பதன் மூலம் "சரியாகப் பெற" முயற்சிக்கிறது. மேலும் குறிப்பாக, இது பொருள்கள் மற்றும் வரிசைகள் இரண்டையும் இணைக்க முயற்சிக்கிறது, அதாவது மாற்றங்கள் சேர்க்கையாக இருக்கும். எடுத்துக்காட்டாக, கட்டளையை இயக்கவும் patch பாட் கொள்கலன் விவரக்குறிப்பில் ஒரு புதிய சூழல் மாறி, அந்த சூழல் மாறியை மேலெழுதுவதற்கு பதிலாக இருக்கும் சூழல் மாறிகளில் சேர்க்கிறது. இந்த அணுகுமுறையைப் பயன்படுத்தி அகற்ற, வழங்கப்பட்ட விவரக்குறிப்பில் அளவுரு மதிப்பை பூஜ்யமாக்க கட்டாயப்படுத்த வேண்டும். எந்த அணிகள் kubectl புதுப்பிக்கப் பயன்படுத்துவது சிறந்ததா?

பயன்படுத்தி உங்கள் வளங்களை உருவாக்கி நிர்வகித்தால் kubectl apply, புதுப்பிக்கும் போது எப்போதும் பயன்படுத்துவது நல்லது kubectl applyஅதனால் kubectl உள்ளமைவை நிர்வகிக்கலாம் மற்றும் பயன்பாட்டிலிருந்து பயன்பாட்டிற்கு கோரப்பட்ட மாற்றங்களைச் சரியாகக் கண்காணிக்கலாம். நன்மை எப்போதும் பயன்படுத்தவும் apply இது முன்னர் பயன்படுத்தப்பட்ட விவரக்குறிப்பைக் கண்காணித்து, விவரக்குறிப்பு பண்புகள் மற்றும் வரிசை கூறுகள் வெளிப்படையாக அகற்றப்படும்போது அதை அறிய அனுமதிக்கிறது. இது நீங்கள் பயன்படுத்த அனுமதிக்கிறது apply பண்புகள் மற்றும் வரிசை உறுப்புகளை அகற்ற, ஒரு சாதாரண மூலோபாய இணைப்பு வேலை செய்யாது. அணிகள் edit и patch குறிப்புகளை புதுப்பிக்க வேண்டாம் kubectl apply அதன் மாற்றங்களைக் கண்காணிக்கப் பயன்படுத்துகிறது, எனவே குபெர்னெட்ஸ் ஏபிஐ மூலம் கண்காணிக்கப்படும் மற்றும் செய்யப்படும் மாற்றங்கள், ஆனால் கட்டளைகள் மூலம் செய்யப்படும் edit и patch, அடுத்தடுத்த கட்டளைகளுக்கு கண்ணுக்கு தெரியாதது applyஅதாவது apply உள்ளீட்டு விவரக்குறிப்பில் அவை தோன்றாவிட்டாலும் அவற்றை அகற்றாது apply (ஆவணம் கூறுகிறது edit и patch பயன்படுத்திய குறிப்புகளுக்கு புதுப்பிப்புகளை உருவாக்கவும் apply, ஆனால் நடைமுறையில் - இல்லை).

நீங்கள் கட்டளையைப் பயன்படுத்தவில்லை என்றால் apply, என பயன்படுத்தலாம் edit, மற்றும் patch, செய்யப்படும் மாற்றத்திற்கு மிகவும் பொருத்தமான கட்டளையைத் தேர்ந்தெடுக்கவும். BOM பண்புகளைச் சேர்க்கும்போது மற்றும் மாற்றும்போது, ​​இரண்டு அணுகுமுறைகளும் தோராயமாக ஒரே மாதிரியாக இருக்கும். விவரக்குறிப்பு பண்புகள் அல்லது வரிசை உறுப்புகளை நீக்கும் போது edit ஒரு முறை ஏவுவது போல் செயல்படுகிறது apply, விவரக்குறிப்பு எடிட் செய்யப்படுவதற்கு முன்னும் பின்னும் எப்படி இருந்தது என்பதைக் கண்காணிப்பது உட்பட, எனவே நீங்கள் ஆதாரத்திலிருந்து பண்புகளையும் வரிசை கூறுகளையும் வெளிப்படையாக அகற்றலாம். விவரக்குறிப்பில் சொத்து மதிப்பை பூஜ்யமாக அமைக்க வேண்டும் patchஅதை வளத்திலிருந்து அகற்ற வேண்டும். மூலோபாய-ஒன்றிணைப்பு இணைப்புகளைப் பயன்படுத்தி ஒரு வரிசை உறுப்பை அகற்றுவது மிகவும் சிக்கலானது, ஏனெனில் அது ஒன்றிணைக்கும் வழிமுறைகளைப் பயன்படுத்த வேண்டும். மேலும் சாத்தியமான மாற்றுகளுக்கு கீழே உள்ள பிற மேம்படுத்தல் அணுகுமுறைகளைப் பார்க்கவும்.

மேலே உள்ள கட்டளைகளைப் போலவே செயல்படும் கிளையன்ட் லைப்ரரியில் மேம்படுத்தல் முறைகளைச் செயல்படுத்த kubectl, கோரிக்கைகளில் அமைக்கப்பட வேண்டும் content-type в application/strategic-merge-patch+json. விவரக்குறிப்பில் உள்ள பண்புகளை நீங்கள் அகற்ற விரும்பினால், அவற்றின் மதிப்புகளை அதே வழியில் பூஜ்யமாக அமைக்க வேண்டும். kubectl patch. நீங்கள் வரிசை உறுப்புகளை அகற்ற வேண்டும் என்றால், புதுப்பிப்பு விவரக்குறிப்பில் ஒன்றிணைக்கும் வழிமுறைகளைச் சேர்க்க வேண்டும் அல்லது புதுப்பிப்புகளுக்கு வேறு அணுகுமுறையைப் பயன்படுத்த வேண்டும்.

புதுப்பிப்புகளுக்கான பிற அணுகுமுறைகள்

Kubernetes இரண்டு மேம்படுத்தல் அணுகுமுறைகளை ஆதரிக்கிறது: JSON இணைப்பு இணைப்பு и JSON இணைப்பு. JSON மெர்ஜ் பேட்ச் அணுகுமுறை ஒரு பகுதி குபெர்னெட்ஸ் விவரக்குறிப்பை உள்ளீடாக எடுத்துக்கொள்கிறது மற்றும் மூலோபாய-இணைப்பு இணைப்பு அணுகுமுறையைப் போன்ற பொருட்களை ஒன்றிணைப்பதை ஆதரிக்கிறது. இரண்டுக்கும் இடையே உள்ள வித்தியாசம் என்னவென்றால், இது பாட் விவரக்குறிப்பில் உள்ள கொள்கலன் வரிசை உட்பட வரிசை மாற்றத்தை மட்டுமே ஆதரிக்கிறது. அதாவது JSON மெர்ஜ் பேட்சைப் பயன்படுத்தும் போது, ​​ஏதேனும் கண்டெய்னரின் எந்தப் பண்பும் மாறினால், அனைத்து கொள்கலன்களுக்கும் முழுமையான விவரக்குறிப்புகளை நீங்கள் வழங்க வேண்டும். எனவே இந்த அணுகுமுறை BOM இல் உள்ள அணிவரிசையிலிருந்து உறுப்புகளை அகற்ற பயனுள்ளதாக இருக்கும். கட்டளை வரியில் நீங்கள் JSON merge patch ஐப் பயன்படுத்தி தேர்ந்தெடுக்கலாம் kubectl patch --type=merge. Kubernetes API உடன் பணிபுரியும் போது, ​​நீங்கள் கோரிக்கை முறையைப் பயன்படுத்த வேண்டும் PATCH மற்றும் நிறுவல் content-type в application/merge-patch+json.

JSON பேட்ச் அணுகுமுறை, ஒரு வளத்தின் பகுதி விவரக்குறிப்பை வழங்குவதற்குப் பதிலாக, வளத்தில் நீங்கள் செய்ய விரும்பும் மாற்றங்களை ஒரு வரிசையாகப் பயன்படுத்துகிறது, இதில் வரிசையின் ஒவ்வொரு உறுப்பும் வளத்தில் செய்யப்படும் மாற்றத்தின் விளக்கத்தைக் குறிக்கிறது. இந்த அணுகுமுறை மாற்றங்களை வெளிப்படுத்த மிகவும் நெகிழ்வான மற்றும் சக்திவாய்ந்த வழியாகும், ஆனால் ஒரு பகுதி வள விவரக்குறிப்பை அனுப்புவதற்குப் பதிலாக, தனியான, குபெர்னெட்ஸ் அல்லாத வடிவத்தில் செய்யப்படும் மாற்றங்களை பட்டியலிடுவதற்கான செலவில். IN kubectl நீங்கள் JSON பேட்சைப் பயன்படுத்தி தேர்ந்தெடுக்கலாம் kubectl patch --type=json. Kubernetes API ஐப் பயன்படுத்தும் போது, ​​இந்த அணுகுமுறை கோரிக்கை முறையைப் பயன்படுத்தி செயல்படுகிறது PATCH மற்றும் நிறுவல் content-type в application/json-patch+json.

எங்களுக்கு நம்பிக்கை தேவை - மாற்றீட்டைப் பயன்படுத்தவும்

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

• A மற்றும் B ஆனது API இலிருந்து வளத்தின் தற்போதைய நிலையைப் பெறுகின்றன
• ஒவ்வொன்றும் உள்நாட்டில் கவுண்டரை ஒன்று அதிகரிப்பதன் மூலம் விவரக்குறிப்பைப் புதுப்பிக்கிறது மற்றும் "புதுப்பிக்கப்பட்ட" குறிப்பில் முறையே "A" அல்லது "B" ஐச் சேர்ப்பது
• மேலும் இது வளத்தை சற்று வேகமாக புதுப்பிக்கிறது
• B வளத்தைப் புதுப்பிக்கிறது

இதன் விளைவாக, புதுப்பிப்பு A இழக்கப்பட்டது. கடைசி ஆபரேஷன் patch வெற்றிகள், கவுண்டர் இரண்டிற்கு பதிலாக ஒன்றால் அதிகரிக்கப்பட்டது, மேலும் "புதுப்பிக்கப்பட்ட" குறிப்பின் மதிப்பு "B" உடன் முடிவடைகிறது மற்றும் "A" இல்லை. அணுகுமுறையைப் பயன்படுத்தி மேம்படுத்தல்கள் செய்யப்படும்போது என்ன நடக்கும் என்பதை மேலே உள்ளதை ஒப்பிடுவோம் replace:

• A மற்றும் B ஆனது API இலிருந்து வளத்தின் தற்போதைய நிலையைப் பெறுகின்றன
• ஒவ்வொன்றும் உள்நாட்டில் கவுண்டரை ஒன்று அதிகரிப்பதன் மூலம் விவரக்குறிப்பைப் புதுப்பிக்கிறது மற்றும் "புதுப்பிக்கப்பட்ட" குறிப்பில் முறையே "A" அல்லது "B" ஐச் சேர்ப்பது
• மேலும் இது வளத்தை சற்று வேகமாக புதுப்பிக்கிறது
• B வளத்தைப் புதுப்பிக்க முயற்சிக்கிறது, ஆனால் வள பதிப்பு விவரக்குறிப்பில் இருப்பதால் புதுப்பிப்பு API ஆல் நிராகரிக்கப்பட்டது replace குபெர்னெட்டஸில் உள்ள வளத்தின் தற்போதைய பதிப்போடு பொருந்தவில்லை, ஏனெனில் வளத்தின் பதிப்பு A இன் மாற்றுச் செயல்பாட்டால் அதிகரிக்கப்பட்டது.

மேலே உள்ள வழக்கில், B ஆதாரத்தை மீண்டும் பெற வேண்டும், புதிய நிலைக்கு மாற்றங்களைச் செய்து மீண்டும் முயற்சிக்க வேண்டும் replace. இது கவுண்டரை இரண்டாக அதிகரிக்கச் செய்யும் மற்றும் "புதுப்பிக்கப்பட்ட-மூலம்" குறிப்பில் இறுதியில் "AB" சேர்க்கப்படும்.

மேலே உள்ள உதாரணம் செயல்படுத்தும் போது குறிக்கிறது replace முழு வளமும் முற்றிலும் மாற்றப்பட்டது. பயன்படுத்தப்படும் விவரக்குறிப்பு replace, பகுதி அல்லது பகுதிகளாக இருக்கக்கூடாது apply, ஆனால் சேர்த்தல் உட்பட முழுமையானது resourceVersion விவரக்குறிப்பு மெட்டாடேட்டாவில். நீங்கள் இயக்கவில்லை என்றால் resourceVersion அல்லது நீங்கள் வழங்கும் பதிப்பு தற்போது இல்லை, மாற்றீடு நிராகரிக்கப்படும். எனவே பயன்படுத்த சிறந்த அணுகுமுறை replace - ஆதாரத்தைப் படித்து, அதைப் புதுப்பித்து உடனடியாக மாற்றவும். பயன்படுத்தி kubectl, இது இப்படி இருக்கலாம்:

$ kubectl get deployment my-deployment -o json 
    | jq '.spec.template.spec.containers[0].env[1].value = "new value"' 
    | kubectl replace -f -

பின்வரும் இரண்டு கட்டளைகள், தொடர்ச்சியாக செயல்படுத்தப்பட்டு, வெற்றிகரமாகச் செயல்படும் என்பது குறிப்பிடத்தக்கது. deployment.yaml சொத்து இல்லை .metadata.resourceVersion

$ kubectl create -f deployment.yaml
$ kubectl replace -f deployment.yaml

இது மேலே கூறப்பட்டதற்கு முரணாகத் தோன்றும், அதாவது. "சேர்த்து resourceVersion விவரக்குறிப்பு மெட்டாடேட்டாவில்." அப்படிச் சொல்வது தவறா? இல்லை, அது இல்லை, ஏனெனில் என்றால் kubectl நீங்கள் குறிப்பிடாததை கவனிக்கிறது resourceVersion, அது ஆதாரத்திலிருந்து அதைப் படித்து நீங்கள் குறிப்பிட்ட விவரக்குறிப்பில் சேர்க்கும், பின்னர் அதை இயக்கவும் replace. நீங்கள் அணுவை நம்பியிருந்தால் இது ஆபத்தானது என்பதால், மந்திரம் முற்றிலும் பக்கத்தில் வேலை செய்கிறது kubectl, API உடன் வேலை செய்யும் கிளையன்ட் லைப்ரரிகளைப் பயன்படுத்தும் போது நீங்கள் அதை நம்பக்கூடாது. இந்த வழக்கில், நீங்கள் தற்போதைய ஆதார விவரக்குறிப்பைப் படித்து, அதைப் புதுப்பித்து பின்னர் இயக்க வேண்டும் PUT கோரிக்கை.

நீங்கள் ஒரு பேட்ச் செய்ய முடியாது - நாங்கள் மாற்றுவோம்

சில நேரங்களில் நீங்கள் API ஆல் கையாள முடியாத சில மாற்றங்களைச் செய்ய வேண்டும். இதுபோன்ற சந்தர்ப்பங்களில், வளத்தை நீக்கி மீண்டும் உருவாக்குவதன் மூலம் அதை மாற்றுவதற்கு நீங்கள் கட்டாயப்படுத்தலாம். இதை பயன்படுத்தி செய்யப்படுகிறது kubectl replace --force. கட்டளையை இயக்குவது உடனடியாக ஆதாரங்களை நீக்கி, பின்னர் வழங்கப்பட்ட விவரக்குறிப்பிலிருந்து மீண்டும் உருவாக்குகிறது. ஏபிஐயில் "ஃபோர்ஸ் ரிப்ளேஸ்" ஹேண்ட்லர் இல்லை, ஏபிஐ மூலம் அவ்வாறு செய்ய, நீங்கள் இரண்டு செயல்பாடுகளைச் செய்ய வேண்டும். முதலில் நீங்கள் அதை அமைப்பதன் மூலம் ஆதாரத்தை நீக்க வேண்டும் gracePeriodSeconds பூஜ்ஜியத்திற்கு (0) மற்றும் propagationPolicy "பின்னணியில்" பின்னர் விரும்பிய விவரக்குறிப்புடன் இந்த ஆதாரத்தை மீண்டும் உருவாக்கவும்.

எச்சரிக்கை: இந்த அணுகுமுறை ஆபத்தானது மற்றும் வரையறுக்கப்படாத நிலைக்கு வழிவகுக்கும்.

சர்வர் பக்கத்தில் விண்ணப்பிக்கவும்

மேலே குறிப்பிட்டுள்ளபடி, குபெர்னெட்ஸ் டெவலப்பர்கள் தர்க்கத்தை செயல்படுத்துவதில் பணியாற்றி வருகின்றனர் apply из kubectl Kubernetes API இல். தர்க்கங்கள் apply குபெர்னெட்ஸ் 1.18 இல் கிடைக்கிறது kubectl apply --server-side அல்லது முறையைப் பயன்படுத்தி API வழியாக PATCH с content-type application/apply-patch+YAML.

குறிப்பு: JSON செல்லுபடியாகும் YAML ஆகும், எனவே விவரக்குறிப்பை JSON ஆக அனுப்பலாம் content-type இருக்கும் application/apply-patch+yaml.

அந்த தர்க்கம் தவிர kubectl API மூலம் அனைவருக்கும் கிடைக்கும், apply சர்வர் பக்கத்தில், விவரக்குறிப்பில் உள்ள புலங்களுக்கு யார் பொறுப்பு என்பதை கண்காணிக்கும், இதனால் அதன் முரண்பாடு இல்லாத எடிட்டிங்கிற்கான பாதுகாப்பான பல அணுகலை அனுமதிக்கிறது. வேறு வார்த்தைகளில் கூறுவதானால், என்றால் apply சர்வர் பக்கத்தில் மிகவும் பரவலாக மாறும், ஒரு உலகளாவிய பாதுகாப்பான வள மேலாண்மை இடைமுகம் வெவ்வேறு வாடிக்கையாளர்களுக்கு தோன்றும், எடுத்துக்காட்டாக, kubectl, Pulumi அல்லது Terraform, GitOps, அத்துடன் கிளையன்ட் லைப்ரரிகளைப் பயன்படுத்தி சுயமாக எழுதப்பட்ட ஸ்கிரிப்டுகள்.

முடிவுகளை

க்ளஸ்டர்களில் உள்ள வளங்களைப் புதுப்பிப்பதற்கான பல்வேறு வழிகளைப் பற்றிய இந்தக் குறுகிய கண்ணோட்டம் உங்களுக்கு உதவியாக இருக்கும் என்று நம்புகிறேன். மாற்றுவதற்கு எதிராக இது பொருந்தும் என்பதை அறிவது நல்லது; விண்ணப்பிக்க, திருத்த, பேட்ச் அல்லது மாற்றீட்டைப் பயன்படுத்தி வளத்தைப் புதுப்பிக்க முடியும். எல்லாவற்றிற்கும் மேலாக, கொள்கையளவில், ஒவ்வொரு அணுகுமுறைக்கும் அதன் சொந்த பயன்பாட்டின் பகுதி உள்ளது. அணு மாற்றங்களுக்கு, மாற்றுவது விரும்பத்தக்கது; இல்லையெனில், நீங்கள் பயன்படுத்துவதன் மூலம் மூலோபாய-இணைப்பு இணைப்புகளைப் பயன்படுத்த வேண்டும். குறைந்தபட்சம், "kubernetes apply vs replace" என்று தேடும் போது Google அல்லது StackOerflow ஐ நீங்கள் நம்ப முடியாது என்பதை நீங்கள் புரிந்துகொள்வீர்கள் என்று எதிர்பார்க்கிறேன். குறைந்தபட்சம் இந்தக் கட்டுரை தற்போதைய பதிலை மாற்றும் வரை.

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