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

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 gruppi di endpoint di rete autonomi), consulta Scegliere l'API di bilanciamento del carico multi-cluster 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 dell'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).

Architettura di due cluster identici e un cluster del piano di controllo.

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, creerai tre cluster GKE e li registrerai 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'

    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, configurerai 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, configuri 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, monitora 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 durante lo svuotamento per gli upgrade (descritto 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 il gruppo di endpoint di rete (NEG) per i due frontend MulticlusterServices viene eseguito nei cluster blue e green.

    Grafico delle metriche Timeline che mostra il traffico che fluisce verso entrambi i backend.

Esegui lo svuotamento e l'upgrade del cluster blue

In questa sezione, svuota il cluster blue. L'eliminazione 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 consoleGoogle 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.

    Traffico che fluisce solo al cluster &quot;verde&quot;.

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 al termine di questo tutorial. Per ulteriori informazioni sull'upgrade, consulta la pagina relativa all'upgrade di cluster e node pool.

  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 di questa 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 di questa 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 i 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 consoleGoogle 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 entrambi i cluster blu e verdi ricevono traffico dal generatore di carico utilizzando il bilanciatore del carico.

    Entrambi i cluster ricevono traffico.

    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.