Gestione delle applicazioni con Application Delivery


In questa pagina ti guideremo nella configurazione di un deployment di NGINX con Application Delivery. Il deployment viene eseguito in due ambienti: staging e prod. L'ambiente prod utilizza una configurazione normale, mentre staging ne utilizza una leggermente modificata.

Requisiti

Per completare questo tutorial, avrai bisogno di quanto segue:

  • Git 2.19.2 o versioni successive installato localmente.
  • Un account GitHub o GitLab con le autorizzazioni per creare un repository privato. Application Delivery supporta solo i repository GitHub e GitLab.
  • Un cluster che esegue GKE versione 1.15 o successiva.
  • Un utente con privilegi di clusterAdmin.
  • Kustomize installato localmente. Puoi seguire la guida all'installazione.
  • Se vuoi convalidare i file di configurazione di Kubernetes nel repository di deployment, devi installare Docker.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

  • Assicurati di aver abilitato l'API Google Kubernetes Engine.
  • Abilita l'API Google Kubernetes Engine
  • Assicurati di aver installato l'interfaccia a riga di comando di Google Cloud.
  • Configura le impostazioni dell'interfaccia a riga di comando di Google Cloud predefinite per il tuo progetto utilizzando uno dei seguenti metodi:
    • Utilizza gcloud init se vuoi avere istruzioni dettagliate sull'impostazione delle impostazioni predefinite del progetto.
    • Utilizza gcloud config per impostare singolarmente l'ID, la zona e l'area geografica del progetto.

    gcloud init

    1. Esegui gcloud init e segui le istruzioni:

      gcloud init

      Se utilizzi SSH su un server remoto, usa il flag --console-only per impedire l'avvio del comando da parte di un browser:

      gcloud init --console-only
    2. Segui le istruzioni per autorizzare l'interfaccia a riga di comando gcloud a utilizzare il tuo account Google Cloud.
    3. Crea una nuova configurazione o selezionane una esistente.
    4. Scegli un progetto Google Cloud.
    5. Scegli una zona Compute Engine predefinita.
    6. Scegli un'area geografica di Compute Engine predefinita.

    gcloud config

    1. Imposta l'ID progetto predefinito:
      gcloud config set project PROJECT_ID
    2. Imposta l'area geografica di Compute Engine predefinita (ad esempio us-central1):
      gcloud config set compute/region COMPUTE_REGION
    3. Imposta la zona Compute Engine predefinita (ad esempio us-central1-c):
      gcloud config set compute/zone COMPUTE_ZONE
    4. Aggiorna gcloud alla versione più recente:
      gcloud components update

    Impostando le posizioni predefinite puoi evitare errori nell'interfaccia a riga di comando gcloud come One of [--zone, --region] must be supplied: Please specify location:

  • Aggiungi le chiavi SSH al tuo account GitHub o GitLab.
  • Testa le tue chiavi con ssh:

    GitHub

    sh ssh -T git@github.com

    GitLab

    sh ssh -T git@gitlab.com

    È possibile che ti venga chiesto di confermare i dettagli della connessione o la passphrase della chiave. Se la connessione ha esito positivo, viene stampato un messaggio sul terminale.

Configurazione di Application Delivery

Per utilizzare Application Delivery, devi:

  1. Crea un nuovo cluster con Application Delivery abilitata o attivalo su un cluster GKE esistente con versione 1.15 o successiva.
  2. Installa appctl, lo strumento a riga di comando di Application Delivery.

Crea un nuovo cluster con Application Delivery

Puoi creare un nuovo cluster con Application Delivery abilitata utilizzando l'interfaccia a riga di comando gcloud o Cloud Console.

gcloud

Crea un cluster:

gcloud beta container clusters create CLUSTER_NAME \
      --cluster-version CLUSTER_VERSION\
      --addons ApplicationManager

Sostituisci quanto segue:

  • CLUSTER_NAME: il nome del nuovo cluster.
  • CLUSTER_VERSION: la versione del nuovo cluster. Deve essere GKE 1.15 o versioni successive.

Console

  1. Vai alla pagina Google Kubernetes Engine in Cloud Console.

    Vai a Google Kubernetes Engine

  2. Fai clic su Crea.

  3. Nella sezione Standard, fai clic su Configura.

  4. Specifica un nome per il cluster.

  5. Scegli una versione del piano di controllo successiva alla 1.15.x o successiva.

  6. Configura il cluster come preferisci.

  7. Nel riquadro di navigazione, in Cluster, fai clic su Funzioni.

  8. Seleziona la casella di controllo Enable Application Manager (Attiva Gestione applicazioni).

  9. Fai clic su Crea.

Abilitazione di Application Delivery su un cluster esistente

Puoi abilitare Application Delivery su un cluster esistente utilizzando l'interfaccia a riga di comando gcloud o Cloud Console.

gcloud

Per abilitare l'applicazione delle applicazioni su un cluster esistente, esegui questo comando:

gcloud beta container clusters update CLUSTER_NAME \
      --update-addons ApplicationManager=ENABLED

Sostituisci CLUSTER_NAME con il nome del cluster esistente.

Console

  1. Vai alla pagina Google Kubernetes Engine in Cloud Console.

    Vai a Google Kubernetes Engine

  2. Nell'elenco dei cluster, fai clic sul nome del cluster che vuoi modificare.

  3. In Funzionalità, accanto al campo Gestione applicazioni, fai clic su Modifica gestione applicazioni.

  4. Seleziona la casella di controllo Enable Application Manager (Attiva Gestione applicazioni).

  5. Fai clic su Salva modifiche.

Conferma installazione

Per controllare lo stato dell'installazione di Application Delivery, procedi come segue:

  1. Controlla lo stato del deployment:

    kubectl get deployment application-controller-manager -n application-system
    

    L'output è simile al seguente:

    NAME                             READY   UP-TO-DATE   AVAILABLE   AGE
    application-controller-manager   2/2     2            2           1h
    

    Dovrebbero essere disponibili due pod in questo deployment application-controller-manager.

  2. Controlla lo stato dell'oggetto StatefulSet:

    kubectl get statefulset kalm-controller-manager -n kalm-system
    

    L'output è simile al seguente:

    NAME                      READY   AGE
    kalm-controller-manager   1/1     1h
    

    Dovrebbe esserci un pod pronto in questo kalm-controller-manager StatefulSet.

Installa applicazione

Per installare lo strumento a riga di comando Application Delivery appctl, utilizza l'interfaccia a riga di comando gcloud per installare pkg.

gcloud components install pkg

Dopo aver abilitato Application Delivery su un cluster e installato pkg, puoi eseguire il deployment della tua prima applicazione.

Deployment di un'applicazione

Per eseguire il deployment di un'applicazione, procedi come segue:

  1. Crea nuovi repository Git o inizializza i repository esistenti.
  2. Crea una configurazione di base.
  3. Crea uno o più ambienti per il tuo deployment.
  4. Facoltativamente, applica gli overlay di configurazione agli ambienti nel repository di applicazioni.
  5. Crea un candidato per la release sotto forma di richiesta di pull o di unione.
  6. Eseguire il deployment della release.

Creazione di nuovi repository in corso...

Crea repository per Application Delivery su GitHub o GitLab con appctl.

  1. Passa alla directory in cui vuoi creare la directory delle applicazioni.
  2. Crea i tuoi repository di Delivery applicazioni con appctl.

    GitHub

    Esegui questo comando:

    appctl init APP_NAME \
        --app-config-repo=github.com/USERNAME/APP_NAME
    

    Sostituisci quanto segue:

    • APP_NAME: il nome dell'applicazione.
    • USERNAME: il tuo nome utente GitHub.

    Ad esempio, se il tuo nome utente GitHub è octocat e vuoi creare un'applicazione denominata myapp, esegui questo comando:

    appctl init myapp \
        --app-config-repo=github.com/octocat/myapp
    

    GitLab

    Esegui questo comando:

    appctl init APP_NAME \
        --app-config-repo=gitlab.com/USERNAME/APP_NAME
    

    Sostituisci quanto segue:

    • APP_NAME: il nome dell'applicazione.
    • USERNAME: il tuo nome utente GitLab.

    Ad esempio, se il tuo nome utente GitLab è alice e vuoi creare un'applicazione denominata myapp, esegui questo comando:

    appctl init myapp \
        --app-config-repo=gitlab.com/alice/myapp
    
  3. appctl ti chiede di confermare i nuovi repository privati.

appctl crea due repository Git privati remoti:

  • Il repository dell'applicazione github.com/USERNAME/APP_NAME. Questo repository viene clonato nella directory corrente.
  • Il repository di deployment github.com/USERNAME/APP_NAME-deployment. Il repository di deployment locale è archiviato in ./APP_NAME/.deployment.

Per ulteriori informazioni sui contenuti e sulla struttura di questi repository, consulta la guida alla distribuzione Applicazione delle applicazioni.

Inizializza repository esistenti

Se hai già dei repository, puoi inizializzarli per l'invio delle applicazioni su GitHub o GitLab con appctl.

  1. Passa alla directory in cui vuoi creare la directory dell'applicazione.

  2. Esegui il comando appctl init, che crea una directory denominata APP_NAME e clona il tuo repository.

    Il comando appctl init inizializza un livello base Kustomize nei file di configurazione archiviati nella directory ./config del repository. Puoi specificare un percorso di configurazione diverso con il flag --config-path.

    Per impostazione predefinita, appctl init utilizza github.com/USERNAME/APP_NAME-deployment come URL del repository di deployment. Puoi utilizzare il flag --deployment-repo per specificare un URL diverso. Se il repository di deployment non esiste, il comando appctl ne creerà uno.

    GitHub

    appctl init APP_NAME \
          --app-config-repo=github.com/USERNAME/APP_NAME \
          [--config-path=CONFIG_PATH]
    

    Sostituisci quanto segue:

    • APP_NAME: il nome dell'applicazione.
    • USERNAME: il tuo nome utente GitHub.
    • CONFIG_PATH: il percorso facoltativo della directory di configurazione del repository. Se omessa, il valore predefinito è ./config.

    Ad esempio, se il repository di configurazione dell'applicazione esistente è https://github.com/octocat/myapp e prevedi che il repository di deployment sia https://github.com/octocat/myapp-deploy, esegui il comando seguente:

    appctl init myapp \
        --app-config-repo=github.com/octocat/myapp
    

    GitLab

    appctl init APP_NAME \
        --app-config-repo=gitlab.com/USERNAME/APP_NAME \
        [--config-path=CONFIG_PATH]
    

    Sostituisci quanto segue:

    • APP_NAME: il nome dell'applicazione.
    • USERNAME: il tuo nome utente GitLab.
    • CONFIG_PATH: il percorso facoltativo della directory di configurazione del repository. Se omessa, il valore predefinito è ./config.

    Ad esempio, se il repository di configurazione dell'applicazione esistente è gitlab.com/alice/myapp, esegui il seguente comando:

    appctl init myapp --app-config-repo=gitlab.com/alice/myapp
    

Creare una configurazione di base

  1. Cambia la directory di lavoro nel repository di applicazioni.

  2. Crea la configurazione per il tuo carico di lavoro Kubernetes. Può essere qualsiasi deployment Kubernetes valido.

    La seguente configurazione definisce un'applicazione denominata nginx, che esegue il deployment di 3 repliche del container nginx. Copia la configurazione nel file config/base/myapp.yaml . Se vuoi abilitare un servizio LoadBalancer, annulla il commento della riga type: LoadBalancer.

    #myapp/config/base/myapp.yaml
    
    apiVersion: v1
    kind: Service
    metadata:
      name: nginx
      labels:
        app: nginx
    spec:
      # if your cluster supports it, uncomment the following to automatically create
      # an external load-balanced IP for the frontend service.
      # type: LoadBalancer
      ports:
        - port: 80
      selector:
        app: nginx
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.7.9
            ports:
            - containerPort: 80
    
  3. Configura Application Delivery per applicare questa configurazione alla base. Incolla il codice seguente in config/base/kustomization.yaml.

    #config/base/kustomization.yaml
    
    resources:
      - myapp.yaml
    

Test e push della configurazione

  1. Dalla directory del repository dell'applicazione, verifica la tua configurazione con kustomize build:

    kustomize build config/base/
    

    Se la tua configurazione è valida, kustomize stampa il YAML che sarà sottoposto a deployment nel tuo cluster quando sarà applicato.

  2. Dopo aver convalidato il YAML, crea ed esegui il push di un commit nel repository dell'applicazione:

    git add .
    git commit -m "Creating APP_NAME"
    git push origin master
    

Aggiunta di un ambiente di rilascio

Application Delivery esegue il deployment della tua applicazione in ambienti. Aggiungi ambienti per le tue release con l'elemento appctl.

  1. Passa alla directory radice del repository dell'applicazione.

  2. Crea il tuo ambiente con appctl:

    appctl env add ENVIRONMENT_NAME \
        --cluster=CLUSTER_NAME
    

    Sostituisci quanto segue:

    • ENVIRONMENT_NAME: il nome del nuovo ambiente.
    • CLUSTER_NAME: il nome del cluster.

    appctl crea un commit Git contenente una configurazione Kustomize strutturata.

    Puoi specificare il nome dello spazio dei nomi per un ambiente di rilascio di questa applicazione utilizzando --namespace. In caso contrario, il nome predefinito dello spazio dei nomi è APP_NAME-ENVIRONMENT_NAME.

    Ad esempio, per aggiungere gli ambienti staging e prod al cluster application-cluster utilizzando il nome dello spazio dei nomi predefinito, esegui il comando seguente:

    appctl env add staging --cluster=application-cluster
    appctl env add prod --cluster=application-cluster
    

    Per aggiungere l'ambiente test nello spazio dei nomi test al cluster application-cluster, esegui il comando seguente:

    appctl env add test --cluster=application-cluster --namespace=test
    

    Durante l'aggiunta di un ambiente, devi valutare se sono necessarie richieste di pull e revisioni del codice nel repository di deployment per questo ambiente. Per impostazione predefinita, vengono create richieste di pull. Se l'ambiente non è critico di produzione e la revisione del codice non è necessaria, puoi saltare la creazione di richieste di pull con --review-required=false.

    Ad esempio, per aggiungere l'ambiente test, che non richiede richieste di pull, esegui il comando seguente:

    appctl env add test \
        --cluster=application-cluster \
        --review-required=false
    
  3. Facoltativamente, visualizza le modifiche Application Delivery apportate nel tuo repository Git con git log:

    git log -p *
    
  4. Esegui il push della configurazione al repository dell'applicazione:

    git push origin master
    

Facoltativo: controllo del repository di deployment

Apri la pagina GitHub o GitLab per il tuo repository di deployment. Ad esempio, se il tuo nome utente GitHub è octocat e hai creato un'applicazione denominata myapp, l'URL è https://github.com/octocat/myapp-deployment. In questa pagina puoi vedere i rami creati per ciascun ambiente.

Deployment di un ambiente

Per eseguire il deployment di un ambiente con Application Delivery, procedi come segue:

  1. Crea una versione con git tag ed esegui il push del tag:

    git tag VERSION
    git push origin VERSION
    

    Sostituisci VERSION con il numero di versione della tua applicazione.

    Ad esempio, per eseguire il push della versione v0.1.0, esegui i comandi seguenti:

    git tag v0.1.0
    git push origin v0.1.0
    ```
    
  2. Usa appctl prepare per designare la versione attualmente codificata e generare una richiesta di pull nel repository di deployment per la revisione.

    appctl prepare ENVIRONMENT_NAME
    

    Ad esempio, per utilizzare l'ambiente staging, esegui il comando seguente:

    appctl prepare staging \
        --validate=true
    

    Questo comando attiva la funzione di convalida kpt gcr.io/kustomize-functions/example-validator per convalidare il push della modifica al repository di deployment.

    kpt è installato da gcloud components install pkg. Questa funzione di convalida esegue kubeval in background, che convalida i file di configurazione di Kubernetes utilizzando schemi della specifica OpenAPI di Kubernetes.

    Per eseguire kpt prepare staging --validate, devi installare Docker sulla tua macchina.

    Per impostazione predefinita, il flag --validate è disattivato.

    Se appctl ha completato il commit nel repository di deployment, stampa un URL per una richiesta di pull, come di seguito:

    Created a "Pull Request": "https://github.com/octocat/myapp-deployment/pull/[Pull_Request_ID]"
    
  3. Utilizza GitHub o GitLab per esaminare e approvare la richiesta di pull.

  4. Dopo aver approvato la richiesta di pull, utilizza appctl apply per completare il deployment:

    appctl apply ENVIRONMENT_NAME
    

    Sostituisci ENVIRONMENT_NAME con il nome dell'ambiente.

    Ad esempio, per eseguire il deployment delle modifiche nell'ambiente staging, esegui il comando seguente:

    appctl apply staging
    
  5. Verifica che l'applicazione sia in esecuzione con kubectl o da Cloud Console.

    kubectl

    Utilizza lo kubectl describe per visualizzare lo stato della tua domanda:

    kubectl get releasetracks.app.gke.io APP_NAME \
        --n NAMESPACE \
        -w
    

    Sostituisci quanto segue:

    • APP_NAME: il nome del repository della tua applicazione.
    • NAMESPACE: il nome dello spazio dei nomi specificato durante la creazione dell'ambiente. Se non hai specificato un nome dello spazio dei nomi, il valore predefinito è APP_NAME-ENVIRONMENT_NAME.

    Ad esempio, per controllare lo stato dell'ambiente staging dell'applicazione denominata myapp, esegui il comando seguente:

    kubectl get releasetracks.app.gke.io myapp -n myapp-staging
    

    Per controllare lo stato dell'ambiente test aggiunto in precedenza da env add --namespace test, esegui il comando seguente:

    kubectl get releasetracks.app.gke.io myapp -n test
    

    Console

    Per visualizzare le informazioni sullo stato e sulla versione delle applicazioni di cui hai eseguito il deployment con Application Delivery, consulta la pagina Applicazioni di GKE su Cloud Console.

Promozione di una release

  1. Per promuovere un candidato per la release da un ambiente a un altro, esegui questo comando:

    appctl prepare TARGET_ENVIRONMENT \
        --from-env=SOURCE_ENVIRONMENT
    

    Sostituisci quanto segue:

    • TARGET_ENVIRONMENT: il nome dell'ambiente in cui vuoi eseguire il deployment del candidato.
    • SOURCE_ENVIRONMENT: il nome dell'ambiente attuale.

    Ad esempio, per promuovere staging a prod esegui:

    appctl prepare prod --from-env=staging
    
  2. Utilizza GitHub o GitLab per esaminare e approvare la richiesta di pull.

  3. Per il deployment della candidatura del candidato nell'ambiente di destinazione, esegui il comando seguente:

    appctl apply TARGET_ENVIRONMENT
    

    Ad esempio, per eseguire il deployment nell'ambiente prod, esegui il comando seguente:

    appctl apply prod
    

Ambienti di visualizzazione in Cloud Console

Dopo aver eseguito il deployment dell'applicazione, puoi visualizzarla nella pagina Applicazioni GKE. Questa pagina contiene un elenco di applicazioni con i relativi ambienti contrassegnati tra parentesi. Di seguito è riportato uno screenshot di un'applicazione myapp con due ambienti staging e prod. Lo spazio dei nomi, il cluster e la versione di ogni ambiente sono visualizzati anche in questa pagina.

Uno screenshot della pagina dell'applicazione.

Per visualizzare i dettagli dell'applicazione, ad esempio il tag Git, i componenti e gli ambienti, fai clic sul nome dell'applicazione. Il seguente screenshot mostra i dettagli di myapp.

Uno screenshot della pagina dei dettagli dell'applicazione.

Modifica della configurazione di un ambiente

In questa sezione si suppone che l'ambiente staging sia configurato come descritto nei passaggi precedenti. Potrebbe essere necessario adattare queste istruzioni al tuo utilizzo.

In questa sezione, modificherai i parametri per l'ambiente staging utilizzando unoverlay kustomize. Dopo aver apportato la modifica, esegui il push e il tagging delle modifiche in Git. Application Delivery aggiornerà il tuo cluster.

  1. Crea un file denominato config/envs/staging/patch-replicas.yaml e copia il testo seguente. La configurazione nell'ambiente staging verrà aggiornata per eseguire una replica anziché tre repliche.

    #config/envs/staging/patch-replicas.yaml
    
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx
    spec:
      replicas: 1
    
  2. Modifica il file config/envs/staging/kustomization.yaml e aggiungi patch-replicas.yaml a una nuova raccolta denominata patchesStrategicMerge.

    #config/envs/staging/kustomization.yaml
    namespace: myapp-staging
    bases:
       - ../../base
    patchesStrategicMerge:
       - patch-replicas.yaml
    

    In questo overlay puoi anche aggiungere annotazioni specifiche per l'ambiente. L'esempio seguente aggiunge un'annotazione denominata oncall-team per aggiungere tutte le risorse di questo ambiente. Per ulteriori informazioni, consulta la pagina Campi di file Kustomize.

    #config/envs/staging/kustomization.yaml
    
    #Don't change the namespace field
    namespace: myapp-staging
    bases:
       - ../../base
    patchesStrategicMerge:
       - patch-replicas.yaml
    commonAnnotations:
      oncall-team: staging-oncall@foo.bar
    
  3. Testa la tua configurazione con kustomize build:

    kustomize build config/envs/staging/
    
  4. Aggiungi e conferma le modifiche.

    git add .
    git commit -m "<var>COMMIT_MESSAGE</var>"
    git push origin master
    

    Sostituisci COMMIT_MESSAGE con un messaggio che descrive le modifiche.

  5. Crea una versione con git tag ed eseguine il push.

    git tag VERSION
    git push origin VERSION
    

    Sostituisci VERSION con il numero di versione che preferisci.

  6. Usa appctl prepare per generare una richiesta di pull nel repository di deployment per la revisione:

    appctl prepare ENVIRONMENT_NAME
    
  7. Segui il link per creare una richiesta di pull GitHub o GitLab.

  8. Esamina i contenuti della tua richiesta di pull. Application Delivery apporta una modifica di una riga che imposta il valore replicas su 1.

  9. Approva la richiesta di pull con GitHub o GitLab.

  10. Utilizza appctl apply per applicare le modifiche:

    appctl apply staging
    

Rollback delle modifiche alla configurazione

Per eseguire il rollback a una release precedente, esegui il comando seguente:

appctl apply TARGET_ENVIRONMENT \
    --from-tag GIT_TAG

Sostituisci quanto segue:

  • TARGET_ENVIRONMENT: il nome dell'ambiente in cui vuoi eseguire il deployment della release.
  • GIT_TAG: il nome del tag per la release.

Utilizzo di appctl negli script

Lo strumento appctl è interattivo e prevede l'input dell'utente per impostazione predefinita. Se vuoi eseguire appctl in uno script, un container o delle pipeline, imposta la variabile di ambiente APPCTL_INTERACTIVE su false.

Ad esempio, nella shell bash, esegui il comando seguente:

export APPCTL_INTERACTIVE=false

Le informazioni su comandi appctl specifici sono disponibili con appctl help command. Ad esempio, per ricevere assistenza in merito a: appctl prepare, esegui appctl help prepare.

Disinstallazione di Gestione applicazioni

Per rimuovere l'applicazione in esecuzione nel cluster, elimini tutti gli spazi dei nomi creati con nuovi ambienti.

Per tutti gli ambienti e i cluster, ripeti i seguenti comandi:

  1. Passa al cluster per un determinato ambiente:

    kubectl config use-context ENVIRONMENT_CLUSTER_NAME
    

    Sostituisci ENVIRONMENT_CLUSTER_NAME con il nome del cluster nell'ambiente selezionato.

  2. Elimina lo spazio dei nomi in cui è in esecuzione l'applicazione per questo ambiente:

    kubectl delete ns NAMESPACE
    

    Sostituisci NAMESPACE con il nome dello spazio dei nomi che vuoi eliminare. Il valore predefinito è APP_NAME-ENVIRONMENT_NAME.

  3. Elimina da GitHub o da GitLab i due repository Git creati da appctl.

  4. Elimina la directory dell'applicazione locale:

    rm -rf myapp/
    
  5. Puoi disabilitare Application Delivery nel tuo cluster da gcloud o Cloud Console:

    gcloud

    gcloud beta container clusters update CLUSTER_NAME \
        --update-addons ApplicationManager=DISABLED
    

    Console

    1. Vai alla pagina Google Kubernetes Engine in Cloud Console.

      Vai a Google Kubernetes Engine

    2. Nell'elenco dei cluster, fai clic sul nome del cluster che vuoi modificare.

    3. In Funzionalità, accanto al campo Gestione applicazioni, fai clic su Modifica gestione applicazioni.

    4. Deseleziona la casella di controllo Abilita Gestione applicazioni.

    5. Fai clic su Salva modifiche.

Passaggi successivi

Scopri di più su Kustomize.