Richteg Verglach vu Kubernetes Uwendung, Ersatz a Patch

Kubernetes huet verschidde Méiglechkeeten fir Ressourcen ze aktualiséieren: uwenden, änneren, patchen an ersetzen. Et gëtt Duercherneen iwwer wat jidderee mécht a wéini se ze benotzen. Loosst eis et erausfannen.

wann Sich op Google den Ausdrock "kubernetes gëllen vs ersetzen" ass lokaliséiert Äntwert op StackOverflow, wat net richteg ass. Wann Dir sicht "kubernetes applizéiert vs Patch" den éischte Link ass d'Dokumentatioun fir kubectl patch, déi net de Verglach enthält apply и patch. Dësen Artikel wäert déi verschidden Optiounen kucken, wéi och déi richteg Notzung vun all eenzel.

Wärend dem Liewenszyklus vun enger Kubernetes Ressource (Service, Deployment, Ingress, etc.), heiansdo musst Dir e puer Eegeschafte vun dëser Ressource änneren, derbäisetzen oder ewechhuelen. Zum Beispill eng Notiz derbäi, d'Zuel vun de Repliken erhéijen oder erofsetzen.

Kubernetes CLI

Wann Dir scho mat Kubernetes Cluster iwwer de CLI schafft, sidd Dir scho vertraut mat apply и edit. Equipe apply liest d'Ressource Spezifizéierung aus der Datei a mécht en "upsert" op de Kubernetes Cluster, d.h. erstellt d'Ressource wann et net existéiert an aktualiséiert se wann et existéiert. Equipe edit liest eng Ressource iwwer d'API, schreift dann d'Ressource Spezifizéierung op eng lokal Datei, déi dann an engem Texteditor opgemaach gëtt. Nodeems Dir d'Datei geännert an gespäichert hutt, kubectl schéckt d'Ännerungen zréck duerch d'API, déi dës Ännerungen virsiichteg op d'Ressource gëllen.

Net jiddereen weess d'Befehle patch и replace. Equipe patch erlaabt Iech en Deel vun enger Ressource Spezifizéierung z'änneren, déi nëmmen de geännerten Deel op der Kommandozeil ubitt. Equipe replace Wierker déi selwecht wéi edit, awer alles muss manuell gemaach ginn: Dir musst déi aktuell Versioun vun der Ressource Spezifizéierung eroflueden, zum Beispill mat kubectl get -o yaml, editéiert et, benotzt dann replace fir eng Ressource ze aktualiséieren no enger geännerter Spezifizéierung. Equipe replace wäert net funktionnéieren wann Ännerungen tëscht dem Liesen an dem Ersatz vun der Ressource geschitt sinn.

Kubernetes API

Dir sidd wahrscheinlech kennt mat de Methoden CoreV1().Pods().Update(), replaceNamespacedService oder patch_namespaced_deployment, Wann Dir schafft mat Stärekéip via Client Bibliothéik fir Kubernetes API eng programméiere Sprooch benotzt. D'Bibliothéik handhabt dës Methoden iwwer HTTP-Ufroe mat de Methoden PUT и PATCH... Woubäi update и replace benotzen PUTan patch, Egal wéi trivial et ass, benotzt PATCH.

Et ass derwäert ze wëssen datt kubectl Wierker och mat Stärekéip via API. An anere Wierder, kubectlass e Wrapper uewen op der Clientbibliothéik fir d'Go Sprooch, déi gréisstendeels d'Fäegkeet bitt Ënnerbefehle an enger méi kompakter a liesbarer Form zousätzlech zu de Standard API Fäegkeeten ze bidden. Zum Beispill, wéi Dir scho gemierkt hutt, d'Method apply war net uewen am virege Paragraph ernimmt. Aktuell (Mee 2020, ca. Iwwersetzer) all Logik kubectl apply, d.h. net existéierend Ressourcen erstellen an existéierend aktualiséieren, funktionnéiert ganz op der Code Säit kubectl. Efforte ginn gemaach op Logik Transfert apply op der API Säit, awer et ass nach ëmmer an der Beta. Ech wäert méi am Detail ënnert schreiwen.

Par défaut Patch

Am beschten benotzt patch, wann Dir d'Ressource update wëllt. Dëst ass wéi béid Clientbibliothéike schaffen uewen op der Kubernetes API an kubectl (net iwwerraschend, well et ass e Wrapper fir d'Clientbibliothéik, ca. Iwwersetzer).

Aarbecht strategesch

All Équipë kubectl apply, edit и patch benotzen d'Method PATCH an HTTP-Ufroe fir eng existent Ressource ze aktualiséieren. Wann Dir méi detailléiert an d'Ëmsetzung vun Kommandoen verdéiwen, da benotze se all d'Approche strategesch-fusionéieren Patching Ressourcen ze aktualiséieren, obwuel de Kommando patch kann aner Approche benotzen (méi iwwer dëst hei ënnen). D'strategesch-fusionéieren Patching Approche probéiert et "richteg ze kréien" andeems déi geliwwert Spezifizéierung mat der existéierender Spezifizéierung fusionéiert. Méi spezifesch probéiert et souwuel Objeten wéi Arrays ze kombinéieren, wat heescht datt d'Ännerunge tendéieren additiv ze sinn. Zum Beispill, de Kommando lafen patch mat enger neier Ëmfeldvariabel an der Pod Container Spezifizéierung, verursaacht datt dës Ëmfeldvariabel un déi existent Ëmfeldvariablen bäigefüügt gëtt anstatt se ze iwwerschreiwe. Fir dës Approche ze läschen, musst Dir de Parameterwäert op null an der spezifizéierter Spezifizéierung forcéieren. Wéi eng vun den Équipen kubectl Ass et am beschten fir d'Aktualiséierung ze benotzen?

Wann Dir Är Ressourcen erstellt a verwalten benotzt kubectl apply, beim Update ass et besser ëmmer ze benotzen kubectl applyze kubectl konnt d'Konfiguratioun verwalten a richteg ugefrote Ännerunge vun der Applikatioun op d'Applikatioun verfollegen. Virdeel ëmmer benotzen apply ass datt et eng virdru applizéiert Spezifizéierung hält, wat et erlaabt ze wëssen wéini Spezifizéierungseigenschaften an Arrayelementer explizit geläscht ginn. Dëst erlaabt Iech ze benotzen apply Eegeschaften an Arrayelementer ze läschen, während eng normal strategesch Fusioun net funktionnéiert. Équipë edit и patch net Update Noten datt kubectl apply benotzt fir seng Ännerungen ze verfolgen, sou datt all Ännerungen déi duerch d'Kubernetes API verfollegt a gemaach ginn, awer duerch Kommandoen gemaach ginn edit и patch, onsichtbar fir spéider Kommandoen apply, dat ass apply net ewechzehuelen hinnen och wann se net am Input Spezifizéierung schéngen fir apply (D'Dokumentatioun seet dat edit и patch maachen Aktualiséierungen op d'Noten benotzt apply, awer an der Praxis - nee).

Wann Dir de Kommando net benotzt apply, kann als benotzt ginn editan patch, wielt de Kommando deen am Beschten entsprécht der Ännerung déi gemaach gëtt. Wann Dir BOM Eegeschaften addéiert an ännert, sinn béid Approche ongeféier d'selwecht. Wann Dir Spezifizéierungseigenschaften oder Arrayelementer läschen edit behält sech wéi eng eemoleg Start apply, inklusiv verfollegen wat d'Spezifikatioun war wéi virun an no se geännert gouf, sou kënnt Dir explizit Eegeschaften an Array Elementer vun enger Ressource ewechhuelen. Dir musst explizit den Eegeschafte Wäert op null an der Spezifizéierung fir patchfir et aus der Ressource ze läschen. En Array-Element ewechzehuelen mat strategesche Merge Patching ass méi komplex well et d'Benotzung vu Fusiounsdirektive erfuerdert. Kuckt aner Upgrade Approche hei ënnen fir méi liewensfäeg Alternativen.

Fir Update Methoden an der Clientbibliothéik ëmzesetzen, déi sech ähnlech wéi d'Befehle hei uewen behuelen kubectl, soll an Ufroe gesat ginn content-type в application/strategic-merge-patch+json. Wann Dir Properties an enger Spezifizéierung wëllt läschen, musst Dir hir Wäerter explizit op null op eng ähnlech Manéier setzen kubectl patch. Wann Dir Array-Elementer ewechhuele musst, sollt Dir Fusiounsdirektiven an der Update-Spezifikatioun enthalen oder eng aner Approche fir Updates benotzen.

Aner Approche fir Updates

Kubernetes ënnerstëtzt zwee aner Update Approche: JSON Merge Patch и JSON Patch. D'JSON Merge Patch Approche hëlt eng partiell Kubernetes Spezifizéierung als Input an ënnerstëtzt Fusiounsobjekter ähnlech wéi déi strategesch Fusioun Patching Approche. Den Ënnerscheed tëscht deenen zwee ass datt et nëmmen Array Ersatz ënnerstëtzt, dorënner de Container Array an der Pod Spezifizéierung. Dëst bedeit datt wann Dir e JSON Merge Patch benotzt, musst Dir komplett Spezifikatioune fir all Container ubidden am Fall wou all Eegeschafte vun engem Container ännert. Also ass dës Approche nëtzlech fir Elementer aus enger Array an enger BOM ze läschen. Op der Kommandozeil kënnt Dir JSON Merge Patch benotzen kubectl patch --type=merge. Wann Dir mat der Kubernetes API schafft, sollt Dir d'Ufromethod benotzen PATCH an Installatioun content-type в application/merge-patch+json.

D'JSON Patch Approche, anstatt eng partiell Spezifizéierung vun enger Ressource ze liwweren, benotzt d'Ännerungen, déi Dir un d'Ressource maache wëllt als Array, an deem all Element vun der Array eng Beschreiwung vun der Ännerung duerstellt, déi op d'Ressource gemaach gëtt. Dës Approche ass e méi flexibelen a mächtege Wee fir d'Ännerungen auszedrécken, déi gemaach ginn, awer op d'Käschte fir d'Ännerungen opzemaachen, déi an engem separaten, net-Kubernetes-Format gemaach ginn, anstatt eng partiell Ressourcespezifizéierung ze schécken. IN kubectl Dir kënnt JSON Patch wielen benotzen kubectl patch --type=json. Wann Dir de Kubernetes API benotzt, funktionnéiert dës Approche mat der Ufromethod PATCH an Installatioun content-type в application/json-patch+json.

Mir brauchen Vertrauen - benotzen ersetzen

An e puer Fäll musst Dir sécher sinn datt keng Ännerunge fir eng Ressource gemaach ginn tëscht der Zäit wou d'Ressource gelies gëtt a wann se aktualiséiert gëtt. An anere Wierder, Dir sollt sécher sinn datt all Ännerungen sinn atomarer. An dësem Fall, fir Ressourcen ze aktualiséieren, sollt Dir benotzen replace. Zum Beispill, wann Dir e ConfigMap mat engem Comptoir hutt, dee vu multiple Quellen aktualiséiert gëtt, sollt Dir sécher sinn datt zwou Quellen de Konter net zur selwechter Zäit aktualiséieren, sou datt den Update verluer geet. Fir ze demonstréieren, stellt Iech eng Sequenz vun Eventer mat der Approche vir patch:

• A a B kréien den aktuellen Zoustand vun der Ressource vun der API
• Jiddereen aktualiséiert lokal d'Spezifikatioun andeems de Konter ëm een ​​eropgeet an och "A" respektiv "B" op d'"aktualiséiert-vun" Notiz bäigefüügt
• An et aktualiséiert d'Ressource e bësse méi séier
• B aktualiséiert d'Ressource

Als Resultat ass den Update A verluer. Déi lescht Operatioun patch gewënnt, de Konter gëtt vun eent amplaz vun zwee erhéicht, an de Wäert vun der "aktualiséiert-vun" Notiz endet mat "B" an enthält net "A". Loosst eis dat hei uewe vergläichen mat deem wat geschitt wann Updates mat der Approche gemaach ginn replace:

• A a B kréien den aktuellen Zoustand vun der Ressource vun der API
• Jiddereen aktualiséiert lokal d'Spezifikatioun andeems de Konter ëm een ​​eropgeet an och "A" respektiv "B" op d'"aktualiséiert-vun" Notiz bäigefüügt
• An et aktualiséiert d'Ressource e bësse méi séier
• B probéiert d'Ressource ze aktualiséieren, awer den Update gëtt vun der API verworf well d'Ressource Versioun an der Spezifizéierung ass replace entsprécht net déi aktuell Versioun vun der Ressource zu Kubernetes, well d'Versioun vun der Ressource duerch d'Ersatzoperatioun vun A erhéicht gouf.

Am uewe genannte Fall muss B d'Ressource erëmfannen, Ännerunge fir den neie Staat maachen an nach eng Kéier probéieren replace. Dëst wäert dozou féieren datt de Konter ëm zwee eropgeet an d'Notiz "Aktualiséiert duerch" fir "AB" um Enn.

Dat uewe genannte Beispill implizéiert datt beim Ausféierung replace Déi ganz Ressource gëtt komplett ersat. Spezifizéierung benotzt fir replace, däerf net deelweis sinn, oder an Deeler wéi an apply, awer komplett, och d'Zousätzlech resourceVersion an d'Spezifikatioun Metadaten. Wann Dir net aktivéiert hutt resourceVersion oder d'Versioun déi Dir ugitt ass net aktuell, den Ersatz gëtt refuséiert. Also déi bescht Approche fir ze benotzen ass replace - liest d'Ressource, update se an ersetzt se direkt. Benotzt kubectl, et kéint esou ausgesinn:

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

Et ass derwäert ze notéieren datt déi folgend zwee Kommandoen, sequentiell ausgefouert, erfollegräich ausféieren, well deployment.yaml enthält keng Propriétéit .metadata.resourceVersion

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

Dëst géif schéngen widderspréchlech wat uewen gesot gouf, d.h. " dobäizemaachen resourceVersion an d'Spezifikatioun Metadaten." Ass et falsch dat ze soen? Nee, et ass net, well wann kubectl Notifikatiounen déi Dir net uginn hutt resourceVersion, liest et aus der Ressource an füügt se un d'Spezifikatioun un déi Dir uginn hutt, an nëmmen dann auszeféieren replace. Well dëst potenziell geféierlech ass wann Dir op Atomitéit vertrauen, funktionnéiert d'Magie ganz op der Säit kubectl, Dir sollt net drop vertrauen wann Dir Clientbibliothéiken benotzt déi mat der API funktionnéieren. An dësem Fall musst Dir déi aktuell Ressource Spezifizéierung liesen, aktualiséieren an dann ausféieren PUT viraus.

Dir kënnt net e Patch maachen - mir maachen en Ersatz

Heiansdo musst Dir e puer Ännerungen maachen, déi net vun der API gehandhabt kënne ginn. An dëse Fäll kënnt Dir d'Ersatz vun der Ressource forcéieren andeems Dir se läschen an nei erstellt. Dëst gëtt gemaach mat kubectl replace --force. De Kommando auszeféieren läscht direkt d'Ressourcen an erstallt se dann aus der geliwwerter Spezifizéierung. Et gëtt keen "force replace" Handler an der API, a fir dat duerch d'API ze maachen, musst Dir zwou Operatiounen ausféieren. Als éischt musst Dir d'Ressource läschen andeems Dir et setzt gracePeriodSeconds op null (0) an propagationPolicy am "Background" an dann nees dës Ressource mat der gewënschter Spezifizéierung.

Opgepasst: Dës Approche ass potenziell geféierlech a kann zu engem ondefinéierte Staat féieren.

Gëlle op der Server Säit

Wéi uewen ernimmt, schaffen Kubernetes Entwéckler un der Ëmsetzung vun der Logik apply aus kubectl an der Kubernetes API. Logik apply verfügbar an Kubernetes 1.18 via kubectl apply --server-side oder iwwer d'API mat der Method PATCH с content-type application/apply-patch+YAML.

Notiz: JSON ass och valabel YAML, also kënnt Dir d'Spezifikatioun als JSON schécken och wann content-type wäert application/apply-patch+yaml.

Nieft där Logik kubectl gëtt fir jiddereen iwwer API verfügbar, apply op der Server Säit, hält Streck vun wien fir d'Felder an der Spezifizéierung verantwortlech ass, sou datt sécher Multiple Zougang fir seng Konflikt-gratis Redaktioun erlaabt. An anere Wierder, wann apply op der Server Säit wäert méi verbreet ginn, wäert eng universell sécher Ressource Gestioun Interface fir verschidde Clienten schéngen, zum Beispill, kubectl, Pulumi oder Terraform, GitOps, souwéi Self-schrëftlech Scripten Client Bibliothéiken benotzt.

Resultater

Ech hoffen dëse kuerzen Iwwerbléck iwwer verschidde Weeër fir Ressourcen a Cluster ze aktualiséieren war Iech hëllefräich. Et ass gutt ze wëssen datt et net nëmmen applizéiert versus ersat ass et méiglech eng Ressource ze aktualiséieren andeems se applizéieren, änneren, patchen oder ersetzen. No allem, am Prinzip, huet all Approche säin eegent Applikatiounsberäich. Fir atomarer Ännerungen, ersetzen ass léiwer soss, Dir sollt strategesch-fusionéieren Patch benotzen. Op d'mannst erwaarden ech datt Dir verstitt datt Dir Google oder StackOerflow net vertraue kënnt wann Dir no "kubernetes applizéiert vs ersetzen" sicht. Op d'mannst bis dësen Artikel déi aktuell Äntwert ersetzt.

Source: will.com