Upgrade di un ambiente GKE multi-cluster con Ingress multi-cluster

Last reviewed 2022-12-15 UTC

Autopilot Standard

Questo tutorial mostra come eseguire l'upgrade di un ambiente Google Kubernetes Engine (GKE) multi-cluster utilizzando Multi Cluster Ingress. Questo tutorial è la continuazione del documento sugli upgrade GKE multi-cluster con Ingress multi-cluster, che spiega in modo più dettagliato il processo, l'architettura e i termini. Ti consigliamo di leggere il documento sui concetti prima di questo tutorial.

Per un confronto dettagliato tra Ingress multi-cluster (MCI), Multi-cluster Gateway (MCG) e bilanciatore del carico con gruppi di endpoint di rete autonomi (bilanciatore del carico e NEG autonomi), consulta Scegliere l'API di bilanciamento del carico multicluster per GKE.

Questo documento è rivolto agli amministratori responsabili della gestione delle flotte per i cluster GKE. Google Cloud

Ti consigliamo di eseguire l'upgrade automatico dei cluster GKE. L'upgrade automatico è un modo completamente gestito per aggiornare automaticamente i cluster (control plane e nodi) in base a una pianificazione delle release determinata daGoogle Cloud. Ciò non richiede alcun intervento da parte dell'operatore. Tuttavia, se vuoi un maggiore controllo su come e quando vengono eseguiti gli upgrade dei cluster, questo tutorial illustra un metodo per eseguire l'upgrade di più cluster in cui le tue app vengono eseguite su tutti i cluster. Poi utilizza Ingress multi-cluster per svuotare un cluster alla volta prima di eseguire l'upgrade.

Architettura

Questo tutorial utilizza la seguente architettura. Esistono tre cluster in totale: due cluster (blue e green) fungono da cluster identici con la stessa app di cui è stato eseguito il deployment e un cluster (ingress-config) funge da cluster del control plane che configura Ingress multi-cluster. In questo tutorial, esegui il deployment di un'app di esempio in due cluster di app (cluster blue e green).

Obiettivi

• Crea tre cluster GKE e registrali come parco risorse.
• Configura un cluster GKE (ingress-config) come cluster di configurazione centrale.
• Esegui il deployment di un'app di esempio negli altri cluster GKE.
• Configura Ingress multi-cluster per inviare il traffico client all'app in esecuzione su entrambi i cluster di app.
• Configura un generatore di carico per l'app e configura il monitoraggio.
• Rimuovi (svuota) un cluster di app da Ingress multicluster ed esegui l'upgrade del cluster svuotato.
• Riversa il traffico nel cluster di cui è stato eseguito l'upgrade utilizzando Ingress multi-cluster.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• GKE
• Networking
• Cloud Load Balancing

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

1. Questo tutorial richiede di configurare Ingress multi-cluster in modo che sia configurato quanto segue:
   • Due o più cluster con le stesse app, come spazi dei nomi, deployment e servizi, in esecuzione su tutti i cluster.
   • L'upgrade automatico è disattivato per tutti i cluster.
   • I cluster sono cluster VPC nativi che utilizzano intervalli di indirizzi IP alias
   • Avere il bilanciamento del carico HTTP abilitato (abilitato per impostazione predefinita).
   • gcloud --version deve essere pari a 369 o superiore. I passaggi di registrazione del cluster GKE dipendono da questa versione o successive.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Verify that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

5. Imposta il progetto predefinito:

   export PROJECT=$(gcloud info --format='value(config.project)')
   gcloud config set project ${PROJECT}
   

6. Abilita le API GKE, Hub e multiclusteringress:

   gcloud services enable container.googleapis.com \
                          gkehub.googleapis.com \
                          multiclusteringress.googleapis.com \
                          multiclusterservicediscovery.googleapis.com
   

Configura l'ambiente

1. In Cloud Shell, clona il repository per ottenere i file per questo tutorial:

   cd ${HOME}
   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

2. Crea una directory WORKDIR:

   cd kubernetes-engine-samples/networking/gke-multicluster-upgrade-mci/
   export WORKDIR=`pwd`
   

Crea e registra i cluster GKE nell'hub

In questa sezione crei tre cluster GKE e li registri in GKE Hub.

Crea cluster GKE

1. In Cloud Shell, crea tre cluster GKE:

   gcloud container clusters create ingress-config --location us-west1-a \
   --release-channel=None --no-enable-autoupgrade --num-nodes=4 \
   --enable-ip-alias --workload-pool=${PROJECT}.svc.id.goog --quiet --async
   gcloud container clusters create blue --location us-west1-b --num-nodes=3 \
   --release-channel=None --no-enable-autoupgrade --enable-ip-alias \
   --workload-pool=${PROJECT}.svc.id.goog --quiet --async
   gcloud container clusters create green --location us-west1-c --num-nodes=3 \
   --release-channel=None --no-enable-autoupgrade --enable-ip-alias \
   --workload-pool=${PROJECT}.svc.id.goog --quiet
   

   Ai fini di questo tutorial, crea i cluster in una singola regione, in tre zone diverse: us-west1-a, us-west1-b e us-west1-c. Per saperne di più su regioni e zone, consulta Area geografica e regioni.

2. Attendi qualche minuto finché tutti i cluster non vengono creati correttamente. Assicurati che i cluster siano in esecuzione:

   gcloud container clusters list
   

   L'output è simile al seguente:

   NAME: ingress-config
   LOCATION: us-west1-a
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 35.233.186.135
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 4
   STATUS: RUNNING
   
   NAME: blue
   LOCATION: us-west1-b
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 34.82.35.222
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 3
   STATUS: RUNNING
   
   NAME: green
   LOCATION: us-west1-c
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 35.185.204.26
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 3
   STATUS: RUNNING
   

3. Crea un file kubeconfig e connettiti a tutti i cluster per generare voci nel file kubeconfig:

   touch gke-upgrade-kubeconfig
   export KUBECONFIG=gke-upgrade-kubeconfig
   gcloud container clusters get-credentials ingress-config \
       --location us-west1-a --project ${PROJECT}
   gcloud container clusters get-credentials blue --location us-west1-b \
       --project ${PROJECT}
   gcloud container clusters get-credentials green --location us-west1-c \
       --project ${PROJECT}
   

   Utilizzi il file kubeconfig per creare l'autenticazione ai cluster creando un utente e un contesto per ogni cluster. Dopo aver creato il file kubeconfig, puoi passare rapidamente da un contesto all'altro tra i cluster.

4. Verifica di avere tre cluster nel file kubeconfig:

   kubectl config view -ojson | jq -r '.clusters[].name'
   

   L'output è il seguente:

   gke_gke-multicluster-upgrades_us-west1-a_ingress-config
   gke_gke-multicluster-upgrades_us-west1-b_blue
   gke_gke-multicluster-upgrades_us-west1-c_green
   

5. Recupera il contesto dei tre cluster per utilizzarli in un secondo momento:

   export INGRESS_CONFIG_CLUSTER=$(kubectl config view -ojson | jq \
       -r '.clusters[].name' | grep ingress-config)
   export BLUE_CLUSTER=$(kubectl config view -ojson | jq \
       -r '.clusters[].name' | grep blue)
   export GREEN_CLUSTER=$(kubectl config view -ojson | jq \
       -r '.clusters[].name' | grep green)
   echo -e "${INGRESS_CONFIG_CLUSTER}\n${BLUE_CLUSTER}\n${GREEN_CLUSTER}"
   

   L'output è il seguente:

   gke_gke-multicluster-upgrades_us-west1-a_ingress-config
   gke_gke-multicluster-upgrades_us-west1-b_blue
   gke_gke-multicluster-upgrades_us-west1-c_green
   

Registra i cluster GKE in un parco risorse

La registrazione dei cluster in un parco risorse ti consente di gestire i cluster Kubernetes in ambienti ibridi. I cluster registrati nei parchi risorse possono utilizzare funzionalità GKE avanzate come Ingress multi-cluster. Per registrare un cluster GKE a un parco risorse, puoi utilizzare direttamente un account di servizio account Google Cloudoppure utilizzare l'approccio consigliato Workload Identity Federation for GKE, che consente a un account di servizio Kubernetes nel tuo cluster GKE di fungere da account di servizio Identity and Access Management.

1. Registra i tre cluster come parco risorse:

   gcloud container fleet memberships register ingress-config \
       --gke-cluster=us-west1-a/ingress-config \
       --enable-workload-identity
   
   gcloud container fleet memberships register blue \
       --gke-cluster=us-west1-b/blue \
       --enable-workload-identity
   
   gcloud container fleet memberships register green \
       --gke-cluster=us-west1-c/green \
       --enable-workload-identity
   

2. Verifica che i cluster siano registrati:

   gcloud container fleet memberships list
   

   L'output è simile al seguente:

   NAME: blue
   EXTERNAL_ID: 401b4f08-8246-4f97-a6d8-cf1b78c2a91d
   
   NAME: green
   EXTERNAL_ID: 8041c36a-9d42-40c8-a67f-54fcfd84956e
   
   NAME: ingress-config
   EXTERNAL_ID: 65ac48fe-5043-42db-8b1e-944754a0d725
   

3. Configura il cluster ingress-config come cluster di configurazione per Ingress multi-clusters attivando la funzionalità multiclusteringress tramite l'hub:

   gcloud container fleet ingress enable --config-membership=ingress-config
   

   Il comando precedente aggiunge le CRD (Custom Resource Definitions) MulticlusterIngress e MulticlusterService al cluster ingress-config. Il completamento di questo comando richiede alcuni minuti. Attendi prima di procedere con il passaggio successivo.

4. Verifica che il cluster ingress-cluster sia stato configurato correttamente per Ingress multi-clusters:

   watch gcloud container fleet ingress describe
   

   Attendi che l'output sia simile al seguente:

   createTime: '2022-07-05T10:21:40.383536315Z'
   membershipStates:
     projects/662189189487/locations/global/memberships/blue:
       state:
         code: OK
         updateTime: '2022-07-08T10:59:44.230329189Z'
     projects/662189189487/locations/global/memberships/green:
       state:
         code: OK
         updateTime: '2022-07-08T10:59:44.230329950Z'
     projects/662189189487/locations/global/memberships/ingress-config:
       state:
         code: OK
         updateTime: '2022-07-08T10:59:44.230328520Z'
   name: projects/gke-multicluster-upgrades/locations/global/features/multiclusteringress
   resourceState:
     state: ACTIVE
   spec:
     multiclusteringress:
       configMembership: projects/gke-multicluster-upgrades/locations/global/memberships/ingress-config
   state:
     state:
       code: OK
       description: Ready to use
       updateTime: '2022-07-08T10:57:33.303543609Z'
   updateTime: '2022-07-08T10:59:45.247576318Z'
   

   Nota: questa funzionalità non è pronta per l'uso finché il cluster di configurazione non ha lo stato OK. Se dopo qualche minuto non vedi code: OK, vai alla sezione per la risoluzione dei problemi.

   Per uscire dal comando watch, premi Ctrl+C.

Esegui il deployment di un'applicazione di esempio nei cluster blu e verde

1. In Cloud Shell, esegui il deployment dell'app whereami di esempio nei cluster blue e green:

   kubectl --context ${BLUE_CLUSTER} apply -f ${WORKDIR}/application-manifests
   kubectl --context ${GREEN_CLUSTER} apply -f ${WORKDIR}/application-manifests
   

2. Attendi qualche minuto e assicurati che tutti i pod nei cluster blue e green abbiano lo stato Running:

   kubectl --context ${BLUE_CLUSTER} get pods
   kubectl --context ${GREEN_CLUSTER} get pods
   

   L'output è simile al seguente:

   NAME                                   READY   STATUS    RESTARTS   AGE
   whereami-deployment-756c7dc74c-zsmr6   1/1     Running   0          74s
   NAME                                   READY   STATUS    RESTARTS   AGE
   whereami-deployment-756c7dc74c-sndz7   1/1     Running   0          68s.
   

Configura Ingress multi-cluster

In questa sezione, creerai un Ingress multi-cluster che invia il traffico all'applicazione in esecuzione sui cluster blue e green. Utilizzi Cloud Load Balancing per creare un bilanciatore del carico che utilizza l'app whereami nei cluster blue e green come backend. Per creare il bilanciatore del carico, hai bisogno di due risorse: un MultiClusterIngress e uno o più MultiClusterServices. Gli oggetti MultiClusterIngress e MultiClusterService sono analoghi multi-cluster per le risorse Kubernetes Ingress e Service esistenti utilizzate nel contesto di un singolo cluster.

1. In Cloud Shell, esegui il deployment della risorsa MulticlusterIngress nel cluster ingress-config:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f ${WORKDIR}/multicluster-manifests/mci.yaml
   

   L'output è il seguente:

   multiclusteringress.networking.gke.io/whereami-mci created
   

2. Esegui il deployment della risorsa MulticlusterService nel cluster ingress-config:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f ${WORKDIR}/multicluster-manifests/mcs-blue-green.yaml
   

   L'output è il seguente:

   multiclusterservice.networking.gke.io/whereami-mcs created
   

3. Per confrontare le due risorse:

   • Controlla la risorsa MulticlusterIngress:

     kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusteringress -o yaml
     

     L'output contiene quanto segue:

     spec:
       template:
         spec:
           backend:
             serviceName: whereami-mcs
             servicePort: 8080
     

     La risorsa MulticlusterIngress è simile alla risorsa Kubernetes Ingress, tranne per il fatto che la specifica serviceName punta a una risorsa MulticlusterService.

   • Controlla la risorsa MulticlusterService:

     kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusterservice -o yaml
     

     L'output contiene quanto segue:

     spec:
       clusters:
       - link: us-west1-b/blue
       - link: us-west1-c/green
       template:
         spec:
           ports:
           - name: web
             port: 8080
             protocol: TCP
             targetPort: 8080
           selector:
             app: whereami
     

     La risorsa MulticlusterService è simile a una risorsa di servizio Kubernetes, tranne per il fatto che ha una specifica clusters. Il valore clusters è l'elenco dei cluster registrati in cui viene creata la risorsa MulticlusterService.

   • Verifica che la risorsa MulticlusterIngress abbia creato un bilanciatore del carico con un servizio di backend che punta alla risorsa MulticlusterService:

     watch kubectl --context ${INGRESS_CONFIG_CLUSTER} \
           get multiclusteringress -o jsonpath="{.items[].status.VIP}"
     

     L'operazione potrebbe richiedere fino a 10 minuti Attendi che l'output sia simile al seguente:

     34.107.246.9
     

     Per uscire dal comando watch, premi Control+C.

4. In Cloud Shell, recupera il VIP di Cloud Load Balancing:

   export GCLB_VIP=$(kubectl --context ${INGRESS_CONFIG_CLUSTER} \
          get multiclusteringress -o json | jq -r '.items[].status.VIP') \
          && echo ${GCLB_VIP}
   

   L'output è simile al seguente:

   34.107.246.9
   

5. Utilizza curl per accedere al bilanciatore del carico e all'applicazione di cui è stato eseguito il deployment:

   curl ${GCLB_VIP}
   

   L'output è simile al seguente:

   {
     "cluster_name": "green",
     "host_header": "34.107.246.9",
     "pod_name": "whereami-deployment-756c7dc74c-sndz7",
     "pod_name_emoji": "😇",
     "project_id": "gke-multicluster-upgrades",
     "timestamp": "2022-07-08T14:26:07",
     "zone": "us-west1-c"
   }
   

6. Esegui ripetutamente il comando curl. Tieni presente che le richieste vengono bilanciate tra l'applicazione whereami di cui è stato eseguito il deployment in due cluster, blue e green.

Configura il generatore di carico

In questa sezione, configuri un servizio loadgenerator che genera traffico client verso il VIP di Cloud Load Balancing. Innanzitutto, il traffico viene inviato ai cluster blue e green perché la risorsa MulticlusterService è configurata per inviare il traffico a entrambi i cluster. In un secondo momento, configurerai la risorsa MulticlusterService per inviare il traffico a un singolo cluster.

1. Configura il manifest loadgenerator per inviare il traffico client a Cloud Load Balancing:

   TEMPLATE=loadgen-manifests/loadgenerator.yaml.templ && envsubst < ${TEMPLATE} > ${TEMPLATE%.*}
   

2. Esegui il deployment di loadgenerator nel cluster ingress-config:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f ${WORKDIR}/loadgen-manifests
   

3. Verifica che tutti i pod loadgenerator nel cluster ingress-config abbiano lo stato Running:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} get pods
   

   L'output è simile al seguente:

   NAME                             READY   STATUS    RESTARTS   AGE
   loadgenerator-5498cbcb86-hqscp   1/1     Running   0          53s
   loadgenerator-5498cbcb86-m2z2z   1/1     Running   0          53s
   loadgenerator-5498cbcb86-p56qb   1/1     Running   0          53s
   

   Se uno dei pod non ha lo stato Running, attendi qualche minuto e poi esegui di nuovo il comando.

Monitora il traffico

In questa sezione, monitorerai il traffico verso l'app whereami utilizzando la consoleGoogle Cloud .

Nella sezione precedente hai configurato un deployment loadgenerator che simula il traffico client accedendo all'app whereami tramite il VIP di Cloud Load Balancing. Puoi monitorare queste metriche tramite la consoleGoogle Cloud . Configura prima il monitoraggio in modo da poter monitorare i cluster man mano che li svuoti per gli upgrade (descritti nella sezione successiva).

1. Crea un dashboard per mostrare il traffico che raggiunge Ingress multi-cluster:

   export DASH_ID=$(gcloud monitoring dashboards create \
       --config-from-file=dashboards/cloud-ops-dashboard.json \
       --format=json | jq  -r ".name" | awk -F '/' '{print $4}')
   

   L'output è simile al seguente:

   Created [721b6c83-8f9b-409b-a009-9fdf3afb82f8]
   

2. Le metriche di Cloud Load Balancing sono disponibili nella consoleGoogle Cloud . Genera l'URL:

   echo "https://console.cloud.google.com/monitoring/dashboards/builder/${DASH_ID}/?project=${PROJECT}&timeDomain=1h"
   

   L'output è simile al seguente:

   https://console.cloud.google.com/monitoring/dashboards/builder/721b6c83-8f9b-409b-a009-9fdf3afb82f8/?project=gke-multicluster-upgrades&timeDomain=1h"
   

3. In un browser, vai all'URL generato dal comando precedente.

   Il traffico verso l'applicazione di esempio va dal generatore di carico a entrambi i cluster blue e green (indicati dalle due zone in cui si trovano i cluster). Il grafico delle metriche della cronologia mostra il traffico diretto a entrambi i backend.I valori k8s1- al passaggio del mouse indicano che i gruppi di endpoint di rete (NEG) per i due frontend MulticlusterServices vengono eseguiti nei cluster blue e green.

   Nota: i colori del grafico potrebbero non corrispondere ai cluster blue e green. Potrebbero essere necessari diversi minuti prima che il traffico diventi visibile nel grafico.

   

Esegui lo svuotamento e l'upgrade del cluster blue

In questa sezione, svuota il cluster blue. Il svuotamento di un cluster significa che lo rimuovi dal pool di bilanciamento del carico. Dopo aver svuotato il cluster blue, tutto il traffico client destinato all'applicazione viene indirizzato al cluster green. Puoi monitorare questo processo come descritto nella sezione precedente. Dopo lo svuotamento del cluster, puoi eseguire l'upgrade. Dopo l'upgrade, puoi inserirlo di nuovo nel pool di bilanciamento del carico. Ripeti questi passaggi per eseguire l'upgrade dell'altro cluster (non mostrato in questo tutorial).

Per svuotare il cluster blue, aggiorna la risorsa MulticlusterService nel cluster ingress-cluster e rimuovi il cluster blue dalla specifica clusters.

Svuota il cluster blu

1. In Cloud Shell, aggiorna la risorsa MulticlusterService nel cluster ingress-config:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} \
             apply -f ${WORKDIR}/multicluster-manifests/mcs-green.yaml
   

2. Verifica di avere solo il cluster green nella specifica clusters:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusterservice \
           -o json | jq '.items[].spec.clusters'
   

   L'output è il seguente:

   [
     {
       "link": "us-west1-c/green"
     }
   ]
   

   Solo il cluster green è elencato nella specifica clusters, quindi solo il cluster green si trova nel pool di bilanciamento del carico.

3. Puoi visualizzare le metriche di Cloud Load Balancing nella console Google Cloud . Genera l'URL:

   echo "https://console.cloud.google.com/monitoring/dashboards/builder/${DASH_ID}/?project=${PROJECT}&timeDomain=1h"
   

4. In un browser, vai all'URL generato dal comando precedente.

   Il grafico mostra che solo il cluster green riceve traffico.

   

Esegui l'upgrade del cluster blue

Ora che il cluster blue non riceve più traffico client, puoi eseguire l'upgrade del cluster (control plane e nodi).

1. In Cloud Shell, recupera la versione attuale dei cluster:

   gcloud container clusters list
   

   L'output è simile al seguente:

   NAME: ingress-config
   LOCATION: us-west1-a
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 35.233.186.135
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 4
   STATUS: RUNNING
   
   NAME: blue
   LOCATION: us-west1-b
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 34.82.35.222
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 3
   STATUS: RUNNING
   
   NAME: green
   LOCATION: us-west1-c
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 35.185.204.26
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 3
   STATUS: RUNNING
   

   Le versioni del cluster potrebbero essere diverse a seconda di quando completi questo tutorial.

2. Visualizza l'elenco delle versioni di MasterVersions disponibili nella zona:

   gcloud container get-server-config --location us-west1-b --format=json | jq \
   '.validMasterVersions[0:20]'
   

   L'output è simile al seguente:

   [
     "1.24.1-gke.1400",
     "1.23.7-gke.1400",
     "1.23.6-gke.2200",
     "1.23.6-gke.1700",
     "1.23.6-gke.1501",
     "1.23.6-gke.1500",
     "1.23.5-gke.2400",
     "1.23.5-gke.1503",
     "1.23.5-gke.1501",
     "1.22.10-gke.600",
     "1.22.9-gke.2000",
     "1.22.9-gke.1500",
     "1.22.9-gke.1300",
     "1.22.8-gke.2200",
     "1.22.8-gke.202",
     "1.22.8-gke.201",
     "1.22.8-gke.200",
     "1.21.13-gke.900",
     "1.21.12-gke.2200",
     "1.21.12-gke.1700"
   ]
   

3. Visualizza un elenco delle versioni di NodeVersions disponibili nella zona:

   gcloud container get-server-config --location us-west1-b --format=json | jq \
   '.validNodeVersions[0:20]'
   

   L'output è simile al seguente:

   [
     "1.24.1-gke.1400",
     "1.23.7-gke.1400",
     "1.23.6-gke.2200",
     "1.23.6-gke.1700",
     "1.23.6-gke.1501",
     "1.23.6-gke.1500",
     "1.23.5-gke.2400",
     "1.23.5-gke.1503",
     "1.23.5-gke.1501",
     "1.22.10-gke.600",
     "1.22.9-gke.2000",
     "1.22.9-gke.1500",
     "1.22.9-gke.1300",
     "1.22.8-gke.2200",
     "1.22.8-gke.202",
     "1.22.8-gke.201",
     "1.22.8-gke.200",
     "1.22.7-gke.1500",
     "1.22.7-gke.1300",
     "1.22.7-gke.900"
   ]
   

4. Imposta una variabile di ambiente per una versione di MasterVersion e NodeVersion presente negli elenchi MasterVersions e NodeVersions e superiore alla versione attuale per il cluster blue, ad esempio:

   export UPGRADE_VERSION="1.22.10-gke.600"
   

   Questo tutorial utilizza la versione 1.22.10-gke.600. Le versioni del cluster potrebbero essere diverse a seconda delle versioni disponibili quando completi questo tutorial. Per ulteriori informazioni sull'upgrade, consulta Upgrade di cluster e node pool.

   Nota :ti consigliamo di non saltare le versioni secondarie del cluster per evitare potenziali problemi di incompatibilità del control plane o dei nodi. Per maggiori informazioni, consulta Posso saltare più versioni di GKE durante l'upgrade di un cluster?.

5. Esegui l'upgrade del nodo control plane per il cluster blue:

   gcloud container clusters upgrade blue \
       --location us-west1-b --master --cluster-version ${UPGRADE_VERSION}
   

   Per confermare l'upgrade, premi Y.

   Il completamento della procedura richiede alcuni minuti. Attendi il completamento dell'upgrade prima di procedere.

   Al termine dell'aggiornamento, l'output è il seguente:

   Updated
   [https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-b/clusters/blue].
   

6. Esegui l'upgrade dei nodi nel cluster blue:

   gcloud container clusters upgrade blue \
       --location=us-west1-b --node-pool=default-pool \
       --cluster-version ${UPGRADE_VERSION}
   

   Per confermare l'aggiornamento, premi Y.

   Il completamento della procedura richiede alcuni minuti. Attendi il completamento dell'upgrade del nodo prima di procedere.

   Al termine dell'upgrade, l'output è il seguente:

   Upgrading blue... Done with 3 out of 3 nodes (100.0%): 3 succeeded...done.
   Updated [https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-b/clusters/blue].
   

7. Verifica che il cluster blue sia stato eseguito l'upgrade:

   gcloud container clusters list
   

   L'output è simile al seguente:

   NAME: ingress-config
   LOCATION: us-west1-a
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 35.233.186.135
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 4
   STATUS: RUNNING
   
   NAME: blue
   LOCATION: us-west1-b
   MASTER_VERSION: 1.22.10-gke.600
   MASTER_IP: 34.82.35.222
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.10-gke.600
   NUM_NODES: 3
   STATUS: RUNNING
   
   NAME: green
   LOCATION: us-west1-c
   MASTER_VERSION: 1.22.8-gke.202
   MASTER_IP: 35.185.204.26
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.22.8-gke.202
   NUM_NODES: 3
   STATUS: RUNNING
   

Aggiungi di nuovo il cluster blue al pool di bilanciamento del carico

In questa sezione, aggiungi di nuovo il cluster blue al pool di bilanciamento del carico.

1. In Cloud Shell, verifica che il deployment dell'applicazione sia in esecuzione sul cluster blue prima di aggiungerlo di nuovo al pool di bilanciamento del carico:

   kubectl --context ${BLUE_CLUSTER} get pods
   

   L'output è simile al seguente:

   NAME                                   READY   STATUS    RESTARTS   AGE
   whereami-deployment-756c7dc74c-xdnb6   1/1     Running   0          17m
   

2. Aggiorna la risorsa MutliclusterService per aggiungere di nuovo il cluster blue al pool di bilanciamento del carico:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} apply \
           -f ${WORKDIR}/multicluster-manifests/mcs-blue-green.yaml
   

3. Verifica di avere cluster blue e green nella specifica dei cluster:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusterservice \
           -o json | jq '.items[].spec.clusters'
   

   L'output è il seguente:

   [
     {
       "link": "us-west1-b/blue"
     },
     {
       "link": "us-west1-c/green"
     }
   ]
   

   I cluster blue e green sono ora inclusi nella specifica clusters.

4. Le metriche di Cloud Load Balancing sono disponibili nella console Google Cloud . Genera l'URL:

   echo "https://console.cloud.google.com/monitoring/dashboards/builder/${DASH_ID}/?project=${PROJECT}&timeDomain=1h"
   

5. In un browser, vai all'URL generato dal comando precedente.

   Il grafico mostra che sia i cluster blu che quelli verdi ricevono traffico dal generatore di carico utilizzando il bilanciatore del carico.

   Nota: potrebbero essere necessari diversi minuti prima che il traffico venga ribilanciato.

   

   Complimenti. Hai eseguito correttamente l'upgrade di un cluster GKE in un'architettura multi-cluster utilizzando Ingress multi-cluster.

6. Per eseguire l'upgrade del cluster green, ripeti la procedura per svuotare ed eseguire l'upgrade del cluster blu, sostituendo blue con green.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Il modo più semplice per eliminare la fatturazione è eliminare il progetto Google Cloud che hai creato per il tutorial. In alternativa, puoi eliminare le singole risorse.

Elimina i cluster

1. In Cloud Shell, annulla la registrazione ed elimina i cluster blue e green:

   gcloud container fleet memberships unregister blue --gke-cluster=us-west1-b/blue
   gcloud container clusters delete blue --location us-west1-b --quiet
   
   gcloud container fleet memberships unregister green --gke-cluster=us-west1-c/green
   gcloud container clusters delete green --location us-west1-c --quiet
   

2. Elimina la risorsa MuticlusterIngress dal cluster ingress-config:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} delete -f ${WORKDIR}/multicluster-manifests/mci.yaml
   

   Questo comando elimina le risorse Cloud Load Balancing dal progetto.

3. Annulla la registrazione ed elimina il cluster ingress-config:

   gcloud container fleet memberships unregister ingress-config --gke-cluster=us-west1-a/ingress-config
   gcloud container clusters delete ingress-config --location us-west1-a --quiet
   

4. Verifica che tutti i cluster siano stati eliminati:

   gcloud container clusters list
   

   L'output è il seguente:

   *<null>*
   

5. Reimposta il file kubeconfig:

   unset KUBECONFIG
   

6. Rimuovi la cartella WORKDIR:

   cd ${HOME}
   rm -rf ${WORKDIR}
   

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:
• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi

• Scopri di più su Ingress multi-cluster.
• Scopri come eseguire il deployment di Ingress multi-cluster nei cluster.
• Esplora architetture, diagrammi e best practice di riferimento su Google Cloud. Consulta il nostro Cloud Architecture Center.