Kubernetes Kustomize માં નેમસ્પેસ

Lina Fontaine

ગુરુવાર, 2 જાન્યુઆરી, 2025 એ 02:01:04 AM વાગ્યે

નિપુણતા Kustomize: નેમસ્પેસ ફેરફારો પછી પેચિંગ

Kubernetes Kustomize એ એક શક્તિશાળી સાધન છે જે વિકાસકર્તાઓને રૂપરેખાંકનોને અસરકારક રીતે સંચાલિત કરવામાં મદદ કરે છે. જો કે, એવા દૃશ્યો છે જ્યાં પરિવર્તન લાગુ કરવું, જેમ કે નેમસ્પેસ બદલવાથી, જ્યારે પછી વધારાના પેચોની જરૂર હોય ત્યારે પડકારો સર્જી શકે છે.

કલ્પના કરો કે તમારી પાસે `kustomization.yaml` છે જે નેમસ્પેસ સેટ કરે છે, અને પછીથી, તમારે સમાન સંસાધન પર પેચ લાગુ કરવાની જરૂર છે. આ પરિસ્થિતિ એક વ્યવહારુ પ્રશ્ન ઉભો કરે છે: નેમસ્પેસ ટ્રાન્સફોર્મેશન પછી પેચ એક્ઝિક્યુટ થાય તેની ખાતરી કેવી રીતે કરશો? વાસ્તવિક-વિશ્વ કુબરનેટ્સ જમાવટમાં આ એક સામાન્ય પડકારનો સામનો કરવો પડે છે. 🔧

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

આ લેખમાં, અમે Kustomize માં નેમસ્પેસ ટ્રાન્સફોર્મેશન પછી પેચને કેવી રીતે કૉલ કરવો તે શોધીશું. અમે નેમસ્પેસ લાગુ કરતી વખતે પસંદગીયુક્ત રીતે સંસાધનોને કેવી રીતે બાકાત રાખવું તેની પણ ચર્ચા કરીશું. સ્પષ્ટ ઉદાહરણો અને નિષ્ણાત ટિપ્સ દ્વારા, તમે તમારા કુબરનેટ્સ વર્કલોડ માટે Kustomize ની સંભવિતતાને અનલૉક કરશો. 🚀

આદેશ	ઉપયોગનું ઉદાહરણ
config.load_kube_config()	ડિફૉલ્ટ સ્થાન (~/.kube/config) પરથી કુબરનેટ્સ રૂપરેખાંકન લોડ કરે છે. Python Kubernetes ક્લાયન્ટનો ઉપયોગ કરીને ક્લસ્ટર સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે આ જરૂરી છે.
yaml.safe_load()	YAML ફાઇલોને પાયથોન શબ્દકોશમાં કન્વર્ટ કરવા માટે સુરક્ષિત રીતે પાર્સ કરે છે. તે મનસ્વી કોડના અમલને અટકાવે છે, તેને રૂપરેખાંકન ફાઇલો લોડ કરવા માટે સુરક્ષિત બનાવે છે.
api.create_namespaced_custom_object()	કુબરનેટ્સ ક્લસ્ટરમાં ચોક્કસ નેમસ્પેસમાં કસ્ટમ રિસોર્સ બનાવે છે અથવા અપડેટ કરે છે. પરિવર્તનોને ગતિશીલ રીતે લાગુ કરવાની આ ચાવી છે.
resource['metadata']['namespace']	સંસાધનના મેટાડેટા વિભાગમાં નેમસ્પેસ ફીલ્ડને એક્સેસ કરે છે અને અપડેટ કરે છે, ચોક્કસ નેમસ્પેસ પર રૂપાંતરણ યોગ્ય રીતે લાગુ થાય છે તેની ખાતરી કરે છે.
json.MarshalIndent()	ઇન્ડેન્ટેડ JSON સ્ટ્રિંગમાં Go સ્ટ્રક્ચરને ક્રમાંકિત કરે છે. રૂપાંતરિત સંસાધનોને ડીબગીંગ અથવા લોગીંગ કરતી વખતે વાંચી શકાય તેવું આઉટપુટ ઉત્પન્ન કરવા માટે ઉપયોગી.
map[string]interface{}	લવચીક કી-મૂલ્ય માળખું રજૂ કરવા માટે Go માં વપરાય છે, સંસાધન ક્ષેત્રોને અપડેટ કરીને ગતિશીલ રીતે પેચો લાગુ કરવાની મંજૂરી આપે છે.
applyNamespace()	કસ્ટમ ફંક્શન કે જે રિસોર્સના નેમસ્પેસ ફીલ્ડને અપડેટ કરે છે. તે રૂપાંતરણ તર્કમાં મોડ્યુલરિટી અને પુનઃઉપયોગિતાની ખાતરી કરે છે.
applyPatch()	એક કસ્ટમ ફંક્શન કે જે પેચ ડેટાને હાલના સંસાધનમાં મર્જ કરે છે. ગતિશીલ અપડેટ્સને હેન્ડલ કરે છે, તેને લવચીક કસ્ટમાઇઝ ઑપરેશન માટે યોગ્ય બનાવે છે.
CustomObjectsApi()	કુબરનેટ્સ કસ્ટમ સંસાધનો સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે પાયથોનમાં ચોક્કસ API ક્લાયંટ. બિન-માનક કુબરનેટ્સ ઑબ્જેક્ટ્સનું સંચાલન કરવા માટે આ કેન્દ્રિય છે.
os package in Go	પર્યાવરણ ચલો અને સિસ્ટમ માહિતીની ઍક્સેસ પ્રદાન કરે છે. ઘણીવાર સ્ક્રિપ્ટ્સમાં ગતિશીલ રીતે ફાઇલ પાથ અથવા રૂપરેખાંકનો પુનઃપ્રાપ્ત કરવા માટે વપરાય છે.

Kustomize માં નેમસ્પેસ ફેરફારો પછી પેચો કામ કરે છે

ઉપર આપેલી સ્ક્રિપ્ટો કુબરનેટ્સમાં ચોક્કસ પડકારને સંબોધિત કરે છે: a પછી પેચ લાગુ કરવી નેમસ્પેસ ટ્રાન્સફોર્મેશન કસ્ટમાઇઝનો ઉપયોગ કરીને. પાયથોન સ્ક્રિપ્ટ `config.load_kube_config()` આદેશ સાથે કુબરનેટ્સ કન્ફિગરેશન લોડ કરીને શરૂ થાય છે. આ સ્ક્રિપ્ટને ક્લસ્ટર સાથે જોડે છે, તેને ગતિશીલ રીતે સંસાધનોનું સંચાલન કરવાની મંજૂરી આપે છે. એકવાર કનેક્ટ થઈ ગયા પછી, YAML રૂપરેખાંકન ફાઇલો વાંચવામાં આવે છે અને `yaml.safe_load()` નો ઉપયોગ કરીને વિશ્લેષિત થાય છે, જે સંભવિત જટિલ YAML સ્ટ્રક્ચર્સને હેન્ડલ કરવાની એક સુરક્ષિત રીત છે. આ સુનિશ્ચિત કરે છે કે નેમસ્પેસ ફીલ્ડ સહિત તમામ મેટાડેટા વધુ હેરફેર માટે સુરક્ષિત રીતે લોડ થયેલ છે. 📜

Python સ્ક્રિપ્ટમાં પ્રથમ કી કાર્ય, `apply_namespace_transformation()`, આપેલ સંસાધનની નેમસ્પેસમાં ફેરફાર કરે છે. તે સંસાધનના મેટાડેટા ફીલ્ડને અપડેટ કરે છે અને ક્લસ્ટરમાં આ ફેરફારોને લાગુ કરવા માટે Kubernetes ક્લાયન્ટ લાઇબ્રેરીમાંથી `create_namespaced_custom_object()` ફંક્શનનો ઉપયોગ કરે છે. આ પગલું મહત્વપૂર્ણ છે કારણ કે તે ખાતરી કરે છે કે વધુ ફેરફારો કરવામાં આવે તે પહેલાં નેમસ્પેસ યોગ્ય રીતે સોંપવામાં આવી છે. તેને આગામી પેચિંગ પ્રક્રિયા માટે સ્ટેજ સેટ કરવા તરીકે વિચારો. આ વિના, ક્લસ્ટર જાણશે નહીં કે સંસાધન ક્યાંનું છે. 🚀

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

ગો સ્ક્રિપ્ટ, બીજી તરફ, ગોની ટાઇપ સિસ્ટમ અને JSON હેન્ડલિંગ ક્ષમતાઓની લવચીકતાનો લાભ લઈને એક અલગ અભિગમને હાઇલાઇટ કરે છે. `applyNamespace()` અને `applyPatch()` જેવા કાર્યો ગો સ્ટ્રક્ટ પર કામ કરવા માટે બનાવવામાં આવ્યા છે, જે પ્રકારની સલામતી અને ચોકસાઈની ખાતરી કરે છે. દાખલા તરીકે, `json.MarshalIndent()` કમાન્ડ સારી રીતે ફોર્મેટ કરેલ JSON આઉટપુટ જનરેટ કરે છે, જેનાથી રિસોર્સ કન્ફિગરેશનને ડિબગ કરવું અને માન્ય કરવું સરળ બને છે. ભલે તમે Python અથવા Go નો ઉપયોગ કરી રહ્યાં હોવ, બંને સ્ક્રિપ્ટ મોડ્યુલારિટી અને વાંચી શકાય તેવા મહત્વ પર ભાર મૂકે છે, એ સુનિશ્ચિત કરે છે કે તમારા Kustomize પેચો નેમસ્પેસ ટ્રાન્સફોર્મેશન સાથે એકીકૃત રીતે કાર્ય કરે છે. 🛠️

કુબરનેટ્સ કુસ્ટમાઇઝમાં નેમસ્પેસ ટ્રાન્સફોર્મેશન પછી પેચોને હેન્ડલ કરવું

કુબરનેટ્સ ક્લાયંટ લાઇબ્રેરી સાથે પાયથોન સ્ક્રિપ્ટનો ઉપયોગ કરીને બેકએન્ડ સોલ્યુશન

# Import necessary libraries
from kubernetes import client, config
import yaml
import os
# Load Kubernetes configuration
config.load_kube_config()
# Define a function to apply the namespace transformation
def apply_namespace_transformation(resource_path, namespace):
    with open(resource_path, 'r') as file:
        resource = yaml.safe_load(file)
    resource['metadata']['namespace'] = namespace
    api = client.CustomObjectsApi()
    group = resource['apiVersion'].split('/')[0]
    version = resource['apiVersion'].split('/')[1]
    kind = resource['kind'].lower() + 's'
    api.create_namespaced_custom_object(group, version, namespace, kind, resource)
# Define a function to apply a patch
def apply_patch(resource_path, patch_path, namespace):
    with open(resource_path, 'r') as file:
        resource = yaml.safe_load(file)
    with open(patch_path, 'r') as file:
        patch = yaml.safe_load(file)
    resource['metadata']['namespace'] = namespace
    for key, value in patch.items():
        resource[key] = value
    print(f"Patched resource: {resource}")
# Usage example
apply_namespace_transformation("extensionconfig.yaml", "foooo")
apply_patch("extensionconfig.yaml", "patch.yaml", "foooo")

નેમસ્પેસ અને પેચોને ગતિશીલ રીતે સંચાલિત કરવા Kustomize નો ઉપયોગ કરવો

Go માં લખેલા Kustomize ટ્રાન્સફોર્મર પ્લગઇનનો ઉપયોગ કરીને ડાયનેમિક સોલ્યુશન

package main
import (
    "encoding/json"
    "fmt"
    "os"
)
type Resource struct {
    APIVersion string `json:"apiVersion"`
    Kind       string `json:"kind"`
    Metadata   Metadata `json:"metadata"`
}
type Metadata struct {
    Name      string `json:"name"`
    Namespace string `json:"namespace"`
}
func applyNamespace(resource *Resource, namespace string) {
    resource.Metadata.Namespace = namespace
}
func applyPatch(resource *Resource, patch map[string]interface{}) {
    for key, value := range patch {
        switch key {
        case "metadata":
            meta := value.(map[string]interface{})
            for mk, mv := range meta {
                if mk == "namespace" {
                    resource.Metadata.Namespace = mv.(string)
                }
            }
        }
    }
}
func main() {
    resource := Resource{
        APIVersion: "runtime.cluster.x-k8s.io/v1alpha1",
        Kind:       "ExtensionConfig",
        Metadata:   Metadata{Name: "my-extensionconfig"},
    }
    applyNamespace(&resource, "foooo")
    patch := map[string]interface{}{
        "metadata": map[string]interface{}{
            "namespace": "foooo",
        },
    }
    applyPatch(&resource, patch)
    result, _ := json.MarshalIndent(resource, "", "  ")
    fmt.Println(string(result))
}

રિસોર્સ એક્સક્લુઝન અને એડવાન્સ નેમસ્પેસ મેનેજમેન્ટને સમજવું

Kubernetes Kustomize સાથે કામ કરવાનું એક અગત્યનું પાસું એ સમજવું છે કે નેમસ્પેસ ટ્રાન્સફોર્મેશનમાંથી અમુક સંસાધનોને કેવી રીતે બાકાત રાખવું. ડિફૉલ્ટ રૂપે, `kustomization.yaml` ફાઇલમાં નેમસ્પેસ લાગુ કરવાથી તમામ સૂચિબદ્ધ સંસાધનોને અસર થાય છે, પરંતુ એવા સંજોગો છે કે જ્યાં અમુક સંસાધનો નેમસ્પેસ-સ્વતંત્ર રહેવા જોઈએ. ઉદાહરણ તરીકે, ક્લસ્ટર-વ્યાપી સંસાધનો જેમ કે `ClusterRole` અથવા `ClusterRoleBinding` ચોક્કસ નેમસ્પેસ સાથે જોડાયેલા નથી અને જો અયોગ્ય રીતે ફેરફાર કરવામાં આવ્યો હોય તો તે તૂટી શકે છે. 'નેમસ્પેસ: કંઈ નહીં' રૂપરેખાંકનનો ઉપયોગ કરીને અથવા તમારી Kustomize ફાઇલમાં વ્યૂહાત્મક રીતે બાકાત રાખવાથી આ સમસ્યાને ઉકેલવામાં મદદ મળી શકે છે. 🛡️

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

છેલ્લે, પર્યાવરણ-વિશિષ્ટ રૂપરેખાંકનોનું સંચાલન એ Kustomize માટે મુખ્ય ઉપયોગનો કેસ છે. ઉદાહરણ તરીકે, બહુ-પર્યાવરણ સેટઅપમાં (dev, staging, prod), તમે નેમસ્પેસ ટ્રાન્સફોર્મેશન અને પેચ પર્યાવરણના આધારે બદલાય તેવું ઈચ્છી શકો છો. `kustomization.yaml` ફાઇલોને અલગ પર્યાવરણ ફોલ્ડર્સમાં ગોઠવીને, તમે ડુપ્લિકેશન વિના અનન્ય રૂપરેખાંકનો એકીકૃત રીતે લાગુ કરી શકો છો. સ્પષ્ટ અને સ્કેલેબલ જમાવટ વ્યૂહરચના જાળવી રાખીને આ અભિગમ Kustomize ની લવચીકતાનો સૌથી વધુ ઉપયોગ કરે છે. તમારા કસ્ટમાઇઝેશન મેનિફેસ્ટમાં ટિપ્પણીઓ અને વિગતવાર દસ્તાવેજીકરણ શામેલ કરવાથી મોટી ટીમો માટે જાળવણીક્ષમતા વધુ સુનિશ્ચિત થાય છે. 📜

Kustomize નેમસ્પેસ અને પેચો વિશે વારંવાર પૂછાતા પ્રશ્નો

હું નેમસ્પેસ ટ્રાન્સફોર્મેશનમાંથી સંસાધનને કેવી રીતે બાકાત રાખી શકું?
તમે ઉપયોગ કરી શકો છો namespace: none નેમસ્પેસ ફેરફારોથી સંસાધનોને પ્રભાવિત થવાથી બાકાત રાખવા માટે તમારા `kustomization.yaml` માં વિકલ્પ.
શું હું ક્લસ્ટર-વ્યાપી સંસાધનોમાં પેચો લાગુ કરી શકું?
હા, તમે કરી શકો છો, પરંતુ ખાતરી કરો કે સંસાધન નેમસ્પેસ ટ્રાન્સફોર્મેશનમાંથી બાકાત રાખવામાં આવ્યું છે namespace: none અથવા સંસાધનને એક અલગ `kustomization.yaml` ફાઇલમાં મૂકીને.
હું કેવી રીતે ખાતરી કરી શકું કે પેચ ક્રમમાં લાગુ થયા છે?
નો ઉપયોગ કરો patchesStrategicMerge તમારા `kustomization.yaml` ની અંદર જરૂરી ક્રમમાં ફીલ્ડ અને પેચોની યાદી બનાવો.
શું હું બંને વ્યૂહાત્મક મર્જ પેચ અને JSON પેચો એકસાથે વાપરી શકું?
હા, Kustomize બંને અભિગમોને સમર્થન આપે છે. તમે તેમને `patchesStrategicMerge` માં સ્પષ્ટ કરી શકો છો અને patchesJson6902 અનુક્રમે ક્ષેત્રો.
મારા રૂપરેખાંકનો લાગુ કરતાં પહેલાં હું તેને કેવી રીતે માન્ય કરી શકું?
ચલાવો kubectl kustomize ક્લસ્ટરમાં લાગુ કરતાં પહેલાં આઉટપુટનું પૂર્વાવલોકન કરવા અને YAML માળખું માન્ય કરવા માટે.
જો બે પેચ સંઘર્ષ થાય તો શું થાય?
Kustomize પેચોને તેઓ સૂચિબદ્ધ કરેલા ક્રમમાં લાગુ કરે છે. જો કોઈ તકરાર હોય, તો પછીનો પેચ પહેલાના પેચને ઓવરરાઈટ કરે છે.
હું મારા `kustomization.yaml` સાથે સમસ્યાઓને કેવી રીતે ડિબગ કરી શકું?
નો ઉપયોગ કરો --log-level `kubectl` સાથે ફ્લેગ કરો અથવા સમસ્યા વિસ્તારને ઓળખવા માટે તમારી સ્ક્રિપ્ટમાં વર્બોઝ લોગિંગ ઉમેરો.
શું હું હેલ્મ સાથે Kustomize નો ઉપયોગ કરી શકું?
હા, હેલ્મ આઉટપુટને રિસોર્સ ફાઇલ તરીકે ગણીને હેલ્મ ચાર્ટ પર કુસ્ટમાઇઝ ફેરફારોને ઓવરલે કરી શકે છે.
હું બહુ-પર્યાવરણ રૂપરેખાંકનો કેવી રીતે મેનેજ કરી શકું?
તમારી `kustomization.yaml` ફાઇલોને પર્યાવરણ-વિશિષ્ટ ફોલ્ડર્સમાં ગોઠવો અને અલગ ઓવરલે સાથે તેનો સંદર્ભ આપો.
લાગુ કરેલ નેમસ્પેસને માન્ય કરવા માટે હું કયા સાધનોનો ઉપયોગ કરી શકું?
ઉપયોગ કરો kubectl get નેમસ્પેસ યોગ્ય રીતે લાગુ કરવામાં આવી છે તે ચકાસવા માટે સંસાધન નામ સાથે.
શું પેચોમાંથી ચોક્કસ સંસાધનોને બાકાત રાખવું શક્ય છે?
હા, સંસાધન-વિશિષ્ટ `kustomization.yaml` ફાઇલો બનાવીને અથવા તમારી સ્ક્રિપ્ટ્સમાં શરતી તર્કનો ઉપયોગ કરીને.

કસ્ટમાઇઝ પેચિંગને સુવ્યવસ્થિત કરવા પર અંતિમ વિચારો

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

વ્યૂહાત્મક રીતે બાકાતને લાગુ કરીને અને પેચિંગ સુવિધાઓનો લાભ લઈને, વપરાશકર્તાઓ તેમની ડિપ્લોયમેન્ટ પાઇપલાઇન્સને વધારી શકે છે. આ વિકસતા વાતાવરણ માટે સુગમતા સુનિશ્ચિત કરે છે અને મજબૂત કુબરનેટ્સ ક્લસ્ટર મેનેજમેન્ટને પ્રોત્સાહન આપે છે. 🌟

કુબરનેટ્સ કસ્ટમાઇઝ માટે સંદર્ભો અને સંસાધનો

Kustomize અને તેની વિશેષતાઓ વિશેની વિગતો સત્તાવાર Kubernetes દસ્તાવેજીકરણમાં મળી શકે છે: Kubernetes Kustomize દસ્તાવેજીકરણ .
નેમસ્પેસ ટ્રાન્સફોર્મેશન અને એક્સક્લુઝનને હેન્ડલ કરવા માટેની આંતરદૃષ્ટિ માટે, આ સમુદાય માર્ગદર્શિકાનો સંદર્ભ લો: GitHub રિપોઝીટરીને કસ્ટમાઇઝ કરો .
આ વિગતવાર માર્ગદર્શિકામાંથી કુબરનેટ્સમાં વ્યૂહાત્મક મર્જ અને JSON પેચો વિશે વધુ જાણો: કુબરનેટ્સ પેચ દસ્તાવેજીકરણ .
અદ્યતન ઉપયોગના કેસ અને વાસ્તવિક દુનિયાના ઉદાહરણોનું અન્વેષણ કરવા માટે, આ સંસાધન તપાસો: Kustomize.io .

Kubernetes Kustomize માં નેમસ્પેસ ટ્રાન્સફોર્મેશન પછી પેચો લાગુ કરવું