Actualizar un entorno de GKE con varios clústeres mediante la entrada de varios clústeres

Last reviewed 2022-12-15 UTC

Autopilot Standard

En este tutorial se muestra cómo actualizar un entorno de Google Kubernetes Engine (GKE) con varios clústeres mediante Multi Cluster Ingress. Este tutorial es una continuación del documento sobre las actualizaciones de GKE multiclúster con Multi Cluster Ingress, que explica el proceso, la arquitectura y los términos con más detalle. Te recomendamos que leas el documento de conceptos antes de este tutorial.

Para ver una comparación detallada entre Multi Cluster Ingress (MCI), Multi-cluster Gateway (MCG) y el balanceador de carga con grupos de endpoints de red independientes (LB y Standalone NEGs), consulta Elegir la API de balanceo de carga multiclúster para GKE.

Este documento está dirigido a los administradores que se encargan de mantener las flotas de clústeres de GKE. Google Cloud

Te recomendamos que actualices automáticamente tus clústeres de GKE. La actualización automática es una forma totalmente gestionada de actualizar automáticamente los clústeres (plano de control y nodos) según una programación de lanzamientos determinada porGoogle Cloud. No requiere ninguna intervención por parte del operador. Sin embargo, si quieres tener más control sobre cómo y cuándo se actualizan los clústeres, en este tutorial se explica un método para actualizar varios clústeres en los que tus aplicaciones se ejecutan en todos los clústeres. A continuación, usa Ingress de varios clústeres para vaciar un clúster a la vez antes de actualizarlo.

Arquitectura

En este tutorial se usa la siguiente arquitectura. Hay un total de tres clústeres: dos clústeres (blue y green) actúan como clústeres idénticos con la misma aplicación desplegada y un clúster (ingress-config) actúa como clúster de plano de control que configura Multi Cluster Ingress. En este tutorial, desplegarás una aplicación de ejemplo en dos clústeres de aplicaciones (clústeres blue y green).

Objetivos

• Crea tres clústeres de GKE y regístralos como una flota.
• Configura un clúster de GKE (ingress-config) como clúster de configuración central.
• Despliega una aplicación de ejemplo en los otros clústeres de GKE.
• Configura Ingress con varios clústeres para enviar el tráfico de clientes a la aplicación que se ejecuta en ambos clústeres de aplicaciones.
• Configura un generador de carga en la aplicación y configura la monitorización.
• Quita (drena) un clúster de aplicaciones de la entrada de varios clústeres y actualiza el clúster drenado.
• Redirige el tráfico al clúster actualizado mediante Ingress de varios clústeres.

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

• GKE
• Networking
• Cloud Load Balancing

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos pueden disfrutar de una prueba gratuita. Google Cloud

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que hayas creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

1. Para seguir este tutorial, debes configurar Ingress con varios clústeres para que se cumplan los siguientes requisitos:
   • Dos o más clústeres con las mismas aplicaciones, como espacios de nombres, implementaciones y servicios, que se ejecutan en todos los clústeres.
   • La actualización automática está desactivada en todos los clústeres.
   • Los clústeres son clústeres nativos de VPC que usan intervalos de direcciones IP con alias.
   • Tener habilitado el balanceo de carga de HTTP (habilitado de forma predeterminada).
   • gcloud --version debe ser 369 o superior. Los pasos para registrar un clúster de GKE dependen de esta versión o de una posterior.

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. Configura tu proyecto predeterminado:

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

6. Habilita las APIs de GKE, Hub y multiclusteringress:

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

Configurar el entorno

1. En Cloud Shell, clona el repositorio para obtener los archivos de este tutorial:

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

2. Crea un directorio WORKDIR:

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

Crear y registrar clústeres de GKE en Hub

En esta sección, crearás tres clústeres de GKE y los registrarás en GKE Hub.

Crear clústeres de GKE

1. En Cloud Shell, crea tres clústeres de 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
   

   En este tutorial, crearás los clústeres en una sola región, en tres zonas diferentes: us-west1-a, us-west1-b y us-west1-c. Para obtener más información sobre las regiones y las zonas, consulta el artículo sobre geografía y regiones.

2. Espera unos minutos hasta que se hayan creado todos los clústeres correctamente. Asegúrate de que los clústeres se estén ejecutando:

   gcloud container clusters list
   

   El resultado debería ser similar al siguiente:

   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 archivo kubeconfig y conéctalo a todos los clústeres para generar entradas en el archivo 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}
   

   El archivo kubeconfig se usa para crear la autenticación en los clústeres. Para ello, se crea un usuario y un contexto para cada clúster. Después de crear el archivo kubeconfig, puedes cambiar rápidamente de contexto entre clústeres.

4. Comprueba que haya tres clústeres en el archivo kubeconfig:

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

   El resultado es el siguiente:

   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. Obtén el contexto de los tres clústeres para usarlos más adelante:

   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}"
   

   El resultado es el siguiente:

   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
   

Registrar clústeres de GKE en una flota

Registrar tus clústeres en una flota te permite operar tus clústeres de Kubernetes en entornos híbridos. Los clústeres registrados en flotas pueden usar funciones avanzadas de GKE, como la entrada multi-clúster. Para registrar un clúster de GKE en una flota, puedes usar una Google Cloud cuenta de servicio directamente o usar el enfoque recomendado de federación de Workload Identity para GKE , que permite que una cuenta de servicio de Kubernetes de tu clúster de GKE actúe como cuenta de servicio de gestión de identidades y accesos.

1. Registra los tres clústeres como una flota:

   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 que los clústeres estén registrados:

   gcloud container fleet memberships list
   

   El resultado debería ser similar al siguiente:

   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 el clúster ingress-config como clúster de configuración de Ingress de varios clústeres habilitando la función multiclusteringress a través del Hub:

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

   El comando anterior añade los MulticlusterIngress y MulticlusterService CRDs (Custom Resource Definitions) al clúster ingress-config. Este comando tarda unos minutos en completarse. Espera antes de continuar con el siguiente paso.

4. Verifica que el clúster ingress-cluster se ha configurado correctamente para Ingress con varios clústeres:

   watch gcloud container fleet ingress describe
   

   Espera hasta que el resultado sea similar al siguiente:

   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: Esta función no estará lista para usarse hasta que tu clúster de configuración tenga el estado OK. Si no ves code: OK al cabo de unos minutos, ve a la sección de solución de problemas.

   Para salir del comando watch, pulsa Control+C.

Desplegar una aplicación de ejemplo en los clústeres azul y verde

1. En Cloud Shell, despliega la aplicación de ejemplo whereami en los clústeres blue y green:

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

2. Espera unos minutos y comprueba que todos los pods de los clústeres blue y green tengan el estado Running:

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

   El resultado debería ser similar al siguiente:

   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.
   

Configurar Ingress de varios clústeres

En esta sección, crearás un recurso Ingress multiclúster que envíe tráfico a la aplicación que se ejecuta en los clústeres blue y green. Usas Cloud Load Balancing para crear un balanceador de carga que utilice la aplicación whereami en los clústeres blue y green como back-ends. Para crear el balanceador de carga, necesitas dos recursos: un MultiClusterIngress y uno o varios MultiClusterServices. Los objetos MultiClusterIngress y MultiClusterService son análogos multiclúster de los recursos Ingress y Service de Kubernetes que se usan en el contexto de un solo clúster.

1. En Cloud Shell, despliega el recurso MulticlusterIngress en el clúster ingress-config:

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

   El resultado es el siguiente:

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

2. Despliega el recurso MulticlusterService en el clúster ingress-config:

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

   El resultado es el siguiente:

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

3. Para comparar los dos recursos, sigue estos pasos:

   • Inspecciona el recurso MulticlusterIngress:

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

     La salida contiene lo siguiente:

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

     El recurso MulticlusterIngress es similar al recurso Ingress de Kubernetes, excepto que la especificación serviceName apunta a un recurso MulticlusterService.

   • Inspecciona el recurso MulticlusterService:

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

     La salida contiene lo siguiente:

     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
     

     El recurso MulticlusterService es similar a un recurso de servicio de Kubernetes, pero tiene una especificación clusters. El valor de clusters es la lista de clústeres registrados en los que se crea el recurso MulticlusterService.

   • Verifica que el recurso MulticlusterIngress haya creado un balanceador de carga con un servicio de backend que apunte al recurso MulticlusterService:

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

     Esta operación puede tardar hasta 10 minutos. Espera hasta que el resultado sea similar al siguiente:

     34.107.246.9
     

     Para salir del comando watch, pulsa Control+C.

4. En Cloud Shell, obtén la dirección IP virtual de Cloud Load Balancing:

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

   El resultado debería ser similar al siguiente:

   34.107.246.9
   

5. Usa curl para acceder al balanceador de carga y a la aplicación implementada:

   curl ${GCLB_VIP}
   

   El resultado debería ser similar al siguiente:

   {
     "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. Ejecuta el comando curl repetidamente. Observa que las solicitudes se están equilibrando entre la aplicación whereami, que se ha implementado en dos clústeres, blue y green.

Configurar el generador de carga

En esta sección, configurarás un loadgenerator servicio que genere tráfico de cliente a la dirección IP virtual de Cloud Load Balancing. En primer lugar, el tráfico se envía a los clústeres blue y green, ya que el recurso MulticlusterService está configurado para enviar tráfico a ambos clústeres. Más adelante, configurará el MulticlusterService recurso para que envíe tráfico a un solo clúster.

1. Configura el manifiesto loadgenerator para enviar el tráfico de clientes a Cloud Load Balancing:

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

2. Despliega el loadgenerator en el clúster ingress-config:

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

3. Verifica que todos los pods loadgenerator del clúster ingress-config tengan el estado Running:

   kubectl --context ${INGRESS_CONFIG_CLUSTER} get pods
   

   El resultado debería ser similar al siguiente:

   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
   

   Si alguno de los pods no tiene el estado Running, espera unos minutos y vuelve a ejecutar el comando.

Supervisar el tráfico

En esta sección, monitorizarás el tráfico de la aplicación whereami mediante la consolaGoogle Cloud .

En la sección anterior, has configurado una implementación de loadgenerator que simula el tráfico de clientes accediendo a la aplicación whereami a través de la dirección IP virtual de Cloud Load Balancing. Puedes monitorizar estas métricas a través de la consolaGoogle Cloud . Primero debes configurar la monitorización para poder monitorizar los clústeres mientras los vacías para realizar las actualizaciones (se describe en la siguiente sección).

1. Crea un panel de control para mostrar el tráfico que llega a Ingress con varios clústeres:

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

   El resultado debería ser similar al siguiente:

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

2. Las métricas de Cloud Load Balancing están disponibles en la consola deGoogle Cloud . Genera la URL:

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

   El resultado debería ser similar al siguiente:

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

3. En un navegador, ve a la URL generada por el comando anterior.

   El tráfico a la aplicación de ejemplo va del generador de carga a los clústeres blue y green (indicados por las dos zonas en las que se encuentran los clústeres). El gráfico de métricas de la cronología muestra el tráfico que va a ambos backends.Los valores al colocar el cursor sobre k8s1- indican que el grupo de puntos finales de red (NEG) de los dos frontend MulticlusterServices se está ejecutando en los clústeres blue y green.

   Nota: Es posible que los colores del gráfico no se correspondan con los clústeres blue y green. El tráfico puede tardar varios minutos en aparecer en el gráfico.

   

Drenar y actualizar el clúster blue

En esta sección, vaciarás el clúster blue. Drenar un clúster significa eliminarlo del grupo de balanceo de carga. Una vez que hayas vaciado el clúster blue, todo el tráfico de clientes destinado a la aplicación se dirigirá al clúster green. Puedes monitorizar este proceso como se describe en la sección anterior. Una vez que se haya vaciado el clúster, puedes actualizarlo. Después de la actualización, puedes volver a añadirlo al grupo de balanceo de carga. Repite estos pasos para actualizar el otro clúster (no se muestra en este tutorial).

Para vaciar el clúster blue, actualiza el recurso MulticlusterService en el clúster ingress-cluster y elimina el clúster blue de la especificación clusters.

Vacía el clúster azul

1. En Cloud Shell, actualiza el recurso MulticlusterService en el clúster ingress-config:

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

2. Verifica que solo tengas el clúster green en la especificación clusters:

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

   El resultado es el siguiente:

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

   Solo el clúster green se incluye en la especificación clusters, por lo que solo el clúster green está en el grupo de balanceo de carga.

3. Puedes ver las métricas de Cloud Load Balancing en laGoogle Cloud consola. Genera la URL:

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

4. En un navegador, ve a la URL generada a partir del comando anterior.

   El gráfico muestra que solo el clúster green está recibiendo tráfico.

   

Actualizar el clúster blue

Ahora que el clúster blue ya no recibe tráfico de clientes, puedes actualizarlo (plano de control y nodos).

1. En Cloud Shell, obtén la versión actual de los clústeres:

   gcloud container clusters list
   

   El resultado debería ser similar al siguiente:

   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
   

   Las versiones de tu clúster pueden ser diferentes en función de cuándo completes este tutorial.

2. Obtén la lista de versiones de MasterVersions disponibles en la zona:

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

   El resultado debería ser similar al siguiente:

   [
     "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. Obtén una lista de las versiones de NodeVersions disponibles en la zona:

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

   El resultado debería ser similar al siguiente:

   [
     "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. Define una variable de entorno para una versión MasterVersion y NodeVersion que esté en las listas MasterVersions y NodeVersions, y que sea superior a la versión actual del clúster blue. Por ejemplo:

   export UPGRADE_VERSION="1.22.10-gke.600"
   

   En este tutorial se usa la versión 1.22.10-gke.600. Las versiones de tu clúster pueden ser diferentes en función de las versiones que estén disponibles cuando completes este tutorial. Para obtener más información sobre cómo actualizar, consulta Actualizar clústeres y grupos de nodos.

   Nota: Te recomendamos que no te saltes versiones secundarias del clúster para evitar posibles problemas de incompatibilidad del plano de control o de los nodos. Para obtener más información, consulta ¿Puedo saltarme varias versiones de GKE durante una actualización de clúster?

5. Actualiza el nodo control plane del clúster blue:

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

   Para confirmar la actualización, pulsa Y.

   Este proceso tarda unos minutos en completarse. Espera a que se complete la actualización antes de continuar.

   Una vez completada la actualización, el resultado es el siguiente:

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

6. Actualiza los nodos del clúster blue:

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

   Para confirmar la actualización, pulsa Y.

   Este proceso tarda unos minutos en completarse. Espera a que se complete la actualización del nodo antes de continuar.

   Una vez completada la actualización, el resultado es el siguiente:

   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 que el clúster blue se haya actualizado:

   gcloud container clusters list
   

   El resultado debería ser similar al siguiente:

   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
   

Vuelve a añadir el clúster blue al pool de balanceo de carga

En esta sección, volverá a añadir el clúster blue al pool de balanceo de carga.

1. En Cloud Shell, comprueba que el despliegue de la aplicación se esté ejecutando en el clúster blue antes de volver a añadirlo al pool de balanceo de carga:

   kubectl --context ${BLUE_CLUSTER} get pods
   

   El resultado debería ser similar al siguiente:

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

2. Actualiza el recurso MutliclusterService para volver a añadir el clúster blue al grupo de balanceo de carga:

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

3. Verifica que tienes los clústeres blue y green en la especificación de clústeres:

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

   El resultado es el siguiente:

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

   Los clústeres blue y green ahora están en la especificación clusters.

4. Las métricas de Cloud Load Balancing están disponibles en laGoogle Cloud consola. Genera la URL:

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

5. En un navegador, ve a la URL generada por el comando anterior.

   El gráfico muestra que tanto los clústeres azules como los verdes reciben tráfico del generador de carga mediante el balanceador de carga.

   Nota: El tráfico puede tardar varios minutos en reequilibrarse.

   

   Enhorabuena. Has actualizado correctamente un clúster de GKE en una arquitectura de varios clústeres mediante Multi Cluster Ingress.

6. Para actualizar el clúster green, repite el proceso para vaciar y actualizar el clúster azul, sustituyendo blue por green.

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

La forma más fácil de evitar que te cobren es eliminar el Google Cloud proyecto que has creado para el tutorial. También puedes eliminar los recursos de forma individual.

Eliminar los clústeres

1. En Cloud Shell, da de baja y elimina los clústeres blue y 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 el recurso MuticlusterIngress del clúster ingress-config:

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

   Este comando elimina los recursos de Cloud Load Balancing del proyecto.

3. Da de baja y elimina el clúster 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 que se hayan eliminado todos los clústeres:

   gcloud container clusters list
   

   El resultado es el siguiente:

   *<null>*
   

5. Restablece el archivo kubeconfig:

   unset KUBECONFIG
   

6. Elimina la carpeta WORKDIR:

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

Eliminar el proyecto

Precaución: Eliminar un proyecto tiene los siguientes efectos:
• Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
• Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.
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.

Siguientes pasos

• Consulta más información sobre Multi Cluster Ingress.
• Consulta cómo desplegar Ingress de varios clústeres en clústeres.
• Consulta arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Centro de arquitectura de Cloud.