Actualiza un entorno de GKE de varios clústeres con Ingress for Anthos

En este instructivo, se muestra cómo actualizar un entorno de varios clústeres de Google Kubernetes Engine (GKE) con Ingress. Este instructivo es una continuación del documento acerca de la actualización de GKE de varios clústeres con Ingress, en el que se explican el proceso, la arquitectura y los términos con más detalle. Te recomendamos que leas el documento de concepto antes de este instructivo. Este documento está dirigido a los administradores de Google Cloud que son responsables de mantener flotas para los clústeres de GKE.

Te recomendamos actualizar automáticamente tus clústeres de GKE. La actualización automática es una forma completamente administrada de actualizar tus clústeres (nodos y plano de control) automáticamente en un programa de actualización determinado por Google Cloud. No se requiere intervención del operador. Sin embargo, si quieres tener más control sobre cómo y cuándo se actualizan los clústeres, en este instructivo se explica un método para actualizar varios clústeres en los que tus apps se ejecutan en todos los clústeres. Luego, se usa Ingress para desviar un clúster a la vez antes de la actualización.

Arquitectura

En este instructivo, se usa la siguiente arquitectura. Hay un total de tres clústeres: dos (blue y green) actúan como clústeres idénticos con la misma app implementada y el tercero (ingress-config) actúa como el clúster de plano de control que configura Ingress. Implementarás una app de muestra llamada Online Boutique en dos clústeres de app (blue y green).

Online Boutique es una app de microservicios de muestra que consta de 10 microservicios que simulan una aplicación de comercio electrónico. Cuenta con un frontend web (al que los clientes pueden acceder) y varios servicios de backend, como un carrito de compras, un catálogo de productos y servicios de recomendación que simulan un minorista electrónico.

Arquitectura de dos clústeres idénticos y uno de plano de control.

Objetivos

  • Crear tres clústeres de GKE y registrarlos en Hub.
  • Configurar un clúster de GKE (ingress-config) como el clúster de configuración central.
  • Implementar Online Boutique como una app de muestra en los otros clústeres de GKE.
  • Configurar Ingress para enviar el tráfico del cliente a la app Online Boutique que se ejecuta en ambos clústeres de aplicación.
  • Establecer un generador de cargas para la app Online Boutique y configurar la supervisión.
  • Quitar (desviar) un clúster de aplicación del Ingress de varios clústeres y actualizar el clúster que se desvió.
  • Devolver el tráfico al clúster actualizado con Ingress.

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud sean aptos para obtener una prueba gratuita.

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta cómo hacer una limpieza.

Antes de comenzar

  1. En este instructivo, se requiere que configures Ingress para que se configure lo siguiente:
    • Dos o más clústeres con las mismas apps, como espacios de nombres, implementaciones y servicios, que se ejecutan en todos los clústeres
    • La actualización automática está desactivada para todos los clústeres
    • Versiones estáticas de GKE 1.14.10-gke.17 o superior, o clústeres de GKE en los canales de versiones rápidos o periódicos
    • Los clústeres son clústeres nativos de la VPC que usan rangos de direcciones IP de alias
    • Habilitar el balanceo de cargas HTTP (habilitado de forma predeterminada)
    • gcloud --version debe ser 281 o superior. Los pasos del registro de clústeres de GKE dependen de esta versión o una superior
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. En Cloud Console, activa Cloud Shell.

    Activar Cloud Shell

  5. Configura el proyecto predeterminado:

    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud config set project ${PROJECT}
    
  6. Habilita las API de GKE, Hub y multiclusteringress:

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

Configura el entorno

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

    cd ${HOME}
    git clone https://github.com/ameer00/gke-multicluster-upgrades.git
    
  2. Crea un directorio de WORKDIR:

    cd gke-multicluster-upgrades
    export WORKDIR=`pwd`
    

Crea y registra clústeres de GKE en Hub

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

Crea clústeres de GKE

  1. En Cloud Shell, crea tres clústeres de GKE:

    gcloud container clusters create ingress-config --zone us-west1-a \
        --num-nodes=3 --enable-ip-alias --async
    gcloud container clusters create blue --zone us-west1-b --num-nodes=4 \
        --enable-ip-alias --async
    gcloud container clusters create green --zone us-west1-c --num-nodes=4 \
        --enable-ip-alias
    

    Para los fines de este instructivo, puedes crear los clústeres en tres regiones diferentes: us-west1-a, us-west1-b y us-west1-c. Para obtener más información acerca de las regiones, consulta Geografía y regiones.

  2. Espera unos minutos hasta que todos los clústeres se creen de manera correcta. Asegúrate de que los clústeres estén en ejecución:

    gcloud container clusters list
    

    El resultado es similar al siguiente:

    NAME            LOCATION    MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION    NUM_NODES  STATUS
    ingress-config  us-west1-a  1.14.10-gke.24  35.203.165.186  n1-standard-1  1.14.10-gke.24  3          RUNNING
    blue            us-west1-b  1.14.10-gke.24  34.82.76.141    n1-standard-1  1.14.10-gke.24  4          RUNNING
    green           us-west1-c  1.14.10-gke.17  35.197.46.200   n1-standard-1  1.14.10-gke.17  4          RUNNING
    
  3. Crea un archivo kubeconfig y conéctate a todos los clústeres para generar entradas en el archivo kubeconfig, de la siguiente manera:

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

    Crea un usuario y un contexto para cada clúster a fin de usar el archivo kubeconfig para crear la autenticación a los clústeres. Después de crear el archivo kubeconfig, puedes cambiar el contexto entre clústeres con rapidez.

  4. Verifica que tengas tres clústeres en el archivo kubeconfig:

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

    Este es el resultado:

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

    Este es el resultado:

    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 clústeres de GKE en Hub

Hub te permite operar los clústeres de Kubernetes en entornos híbridos. Hub también permite que los clústeres registrados usen funciones avanzadas de GKE, como Ingress. Para registrar un clúster de GKE en Hub, usa una cuenta de servicio de Google Cloud y otórgale permiso de administración de identidades y accesos (IAM).

  1. En Cloud Shell, crea una cuenta de servicio y descarga sus credenciales:

    gcloud iam service-accounts create ingress-svc-acct
    gcloud projects add-iam-policy-binding ${PROJECT} \
        --member="serviceAccount:ingress-svc-acct@${PROJECT}.iam.gserviceaccount.com" \
        --role="roles/gkehub.connect"
    gcloud iam service-accounts keys \
        create ${WORKDIR}/ingress-svc-acct.json \
        --iam-account=ingress-svc-acct@${PROJECT}.iam.gserviceaccount.com
    
  2. Obtén los URI de los clústeres de GKE:

    export INGRESS_CONFIG_URI=$(gcloud container clusters list --uri | grep ingress-config)
    export BLUE_URI=$(gcloud container clusters list --uri | grep blue)
    export GREEN_URI=$(gcloud container clusters list --uri | grep green)
    echo -e "${INGRESS_CONFIG_URI}\n${BLUE_URI}\n${GREEN_URI}"
    

    Este es el resultado:

    https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-a/clusters/ingress-config
    https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-b/clusters/blue
    https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-c/clusters/green
    
  3. Registra los tres clústeres en Hub:

    gcloud container hub memberships register ingress-config \
        --project=${PROJECT} \
        --gke-uri=${INGRESS_CONFIG_URI} \
        --service-account-key-file=${WORKDIR}/ingress-svc-acct.json
    
    gcloud container hub memberships register blue \
        --project=${PROJECT} \
        --gke-uri=${BLUE_URI} \
        --service-account-key-file=${WORKDIR}/ingress-svc-acct.json
    
    gcloud container hub memberships register green \
        --project=${PROJECT} \
        --gke-uri=${GREEN_URI} \
        --service-account-key-file=${WORKDIR}/ingress-svc-acct.json
    
  4. Verifica que los clústeres estén registrados:

    gcloud container hub memberships list
    

    El resultado es similar al siguiente:

    NAME            EXTERNAL_ID
    blue            d40521d9-693f-11ea-a26c-42010a8a0010
    green           d3027ecd-693f-11ea-ad5f-42010a8a00a9
    ingress-config  bb778338-693f-11ea-a053-42010a8a016a
    
  5. Para configurar el clúster ingress-config como el clúster de configuración de Ingress, habilita la función multiclusteringress a través de Hub:

    gcloud alpha container hub ingress enable \
        --config-membership=projects/${PROJECT}/locations/global/memberships/ingress-config
    

    El comando anterior agrega los CDR (definiciones de recursos personalizados) MulticlusterIngress y MulticlusterService al clúster config. Este comando tardará unos minutos en completarse. Espera antes de continuar con el siguiente paso.

  6. Verifica que el clúster ingress-cluster se haya configurado correctamente para Ingress:

    watch gcloud alpha container hub ingress describe
    

    Espera hasta que el resultado sea similar al siguiente:

    createTime: '2020-03-18T18:13:46.530713607Z'
    
    featureState:
      details:
        code: OK
        description: Multicluster Ingress requires Anthos license enablement. Unlicensed
          usage is unrestricted for the MCI Beta API. Note that licensing will be enforced
          for use of the Generally Available MCI API.
      detailsByMembership:
        projects/960583074711/locations/global/memberships/blue:
          code: OK
        projects/960583074711/locations/global/memberships/green:
          code: OK
        projects/960583074711/locations/global/memberships/ingress-config:
          code: OK
      lifecycleState: ENABLED
    multiclusteringressFeatureSpec:
      configMembership: projects/gke-multicluster-upgrades/locations/global/memberships/ingress-config
    name:
    projects/gke-multicluster-upgrades/locations/global/features/multiclusteringress
    

    Para salir del comando watch, presiona Control + C.

Implementa la app Online Boutique en los clústeres azul y verde

  1. En Cloud Shell, implementa Online Boutique en los clústeres blue y green:

    kubectl --context ${BLUE_CLUSTER} apply -f ${WORKDIR}/hipster-shop
    kubectl --context ${GREEN_CLUSTER} apply -f ${WORKDIR}/hipster-shop
    
  2. Espera unos minutos y asegúrate de que todos los pods en los clústeres blue y green tengan el estado Running:

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

    El resultado es similar al siguiente:

    NAME                                     READY   STATUS    RESTARTS   AGE
    adservice-86f5dfb995-nlm5w               1/1     Running   0          10m
    cartservice-76cf9686b6-rxf7b             1/1     Running   0          10m
    checkoutservice-7766b946f5-qszvc         1/1     Running   0          10m
    currencyservice-76975c7847-vmwn7         1/1     Running   0          10m
    emailservice-c55cd96f-74rxs              1/1     Running   0          10m
    frontend-f4b7cd95-lk4k8                  1/1     Running   0          10m
    loadgenerator-6784bc5f77-bkx4c           1/1     Running   0          10m
    paymentservice-696f796545-8sjp5          1/1     Running   0          10m
    productcatalogservice-7975f8588c-blrbq   1/1     Running   0          10m
    recommendationservice-6d44459d79-xxb8w   1/1     Running   0          10m
    redis-cart-6448dcbdcc-8qcb4              1/1     Running   0          10m
    shippingservice-767f84b88c-8f26h         1/1     Running   0          10m
    

Configura Ingress de varios clústeres

En esta sección, crearás un Ingress de varios clústeres que envía el tráfico hacia el frontend de Online Boutique a los clústeres blue y green. Debes usar Cloud Load Balancing para crear un balanceador de cargas que use los servicios de frontend en los clústeres blue y green como backends. Para crear el balanceador de cargas, necesitarás dos recursos: MultiClusterIngress y uno o más MultiClusterServices. Los objetos MultiClusterIngress y MultiClusterService son análogos de varios clústeres para los recursos de Ingress y servicio de Kubernetes existentes que se usan en el contexto de clúster único.

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

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mci.yaml
    

    Este es el resultado:

    multiclusteringress.networking.gke.io/frontend-multicluster-ingress created
    
  2. Implementa el recurso MulticlusterService en el clúster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue-green.yaml
    

    Este es el resultado:

    multiclusterservice.networking.gke.io/frontend-multicluster-svc created
    
  3. Para comparar los dos recursos, haz lo siguiente:

    • Inspecciona el recurso MulticlusterIngress:

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

      Este es el resultado:

      spec:
          template:
            spec:
              backend:
                serviceName: frontend-multicluster-svc
                servicePort: 80
      

      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
      

      Este es el resultado:

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

      El recurso MulticlusterService es similar a un recurso de servicio de Kubernetes, excepto que tiene una especificación clusters. El valor 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 cargas con un servicio de backend que apunta al recurso MulticlusterService:

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

      Espera hasta que el resultado sea similar al siguiente:

      34.107.246.9
      

      Anota la dirección IP virtual (VIP).

      Para salir del comando watch, presiona Control+C.

  4. Para acceder a la app Online Boutique, ve a la dirección IP virtual en el navegador.

    Si ves un mensaje de error 404, espera un poco más y actualiza la página hasta que veas el frontend de la aplicación.

    Navega por la aplicación y realiza algunas compras de prueba. En este punto, la app de Online Boutique se implementó en los clústeres blue y green, y el recurso MulticlusterIngress está configurado para enviar tráfico a ambos clústeres.

Configura el generador de cargas

En esta sección, configurarás un servicio loadgenerator que genera tráfico de cliente a la VIP de Cloud Load Balancing. Primero, el tráfico se envía a los clústeres blue y green porque el recurso MulticlusterService está configurado para enviar tráfico a ambos clústeres. Más adelante, deberás configurar el recurso MulticlusterService para enviar tráfico a un solo clúster.

  1. En Cloud Shell, obtén la VIP 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 es similar al siguiente:

    34.107.246.9
    
  2. Configura el servicio loadgenerator para enviar tráfico de cliente a Cloud Load Balancing:

    sed -i 's/GCLB_VIP/'${GCLB_VIP}'/g' ${WORKDIR}/load-generator/loadgenerator.yaml
    
  3. Implementa loadgenerator en el clúster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f ${WORKDIR}/load-generator
    
  4. Verifica que los pods loadgenerator en el clúster ingress-config tengan el estado Running:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} get pods
    

    El resultado es 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 un estado Running, espera unos minutos y vuelve a ejecutar el comando.

Supervisa el tráfico

En esta sección, supervisarás el tráfico a la app Online Boutique mediante Cloud Console.

En la sección anterior, configuraste una implementación loadgenerator que simula el tráfico de clientes de Online Boutique accediendo a ella a través de Cloud Load Balancing. Puedes supervisar estas métricas en Cloud Console. Primero debes configurar la supervisión para que puedas realizarla mientras desvías los clústeres para las actualizaciones (se describe en la siguiente sección).

  1. En Cloud Shell, obtén el nombre de la regla de reenvío del recurso frontend-multicluster-ingress MulticlusterIngress:

    export INGRESS_LB_RULE=$(gcloud compute forwarding-rules list | grep frontend-multicluster-ingress | awk '{print $4}')
    echo ${INGRESS_LB_RULE}
    

    El resultado es similar al siguiente:

    mci-h8zu63-default-frontend-multicluster-ingress
    
  2. Genera la URL para la aplicación:

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    

    El resultado es similar al siguiente:

    https://console.cloud.google.com/net-services/loadbalancing/details/http/mci-h8zu63-default-frontend-multicluster-ingress?project=gke-multicluster-upgrades&tab=monitoring&duration=PT1H`
    
  3. En un navegador, ve a la URL generada por el comando anterior. En la lista desplegable Backend, selecciona el backend que comienza con mci.

    Selecciona el backend.

    El tráfico a la app Online Boutique se orientará a los clústeres blue y green (aquellos de las dos zonas en las que se encuentran los clústeres). En el gráfico de cronograma de las métricas, se muestra el tráfico que va a los dos backends. En la columna Backend, los valores k8s1- indican que los grupos de extremos de red (NEG) de los dos frontend MulticlusterServices se ejecutan en los clústeres blue y green.

    Gráfico de cronograma de métricas que muestra el tráfico que fluye a ambos backends.

Desvía y actualiza el clúster green

En esta sección, desviarás el clúster green. Desviar un clúster significa que lo quitas del grupo de balanceo de cargas. Después de desviar el clúster green, todo el tráfico del cliente destinado a la app Online Boutique irá al clúster blue. Puedes supervisar este proceso como se describe en la sección anterior. Una vez que el clúster se desvía, puedes actualizarlo. Después de la actualización, puedes volver a colocarlo en el grupo de balanceo de cargas. Repite estos pasos para actualizar el otro clúster (no se muestra en este instructivo).

Para desviar el clúster green, debes actualizar el recurso MulticlusterService en el clúster ingress-cluster y quitar el clúster green de la especificación clusters.

Desvía el clúster verde

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

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue.yaml
    
  2. Verifica que solo tengas el clúster blue en la especificación clusters:

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

    Este es el resultado:

    {
    
    ```
        "link": "us-west1-b/blue"
    }
    ```
    

    Solo el clúster blue aparece en la especificación clusters, por lo que únicamente el clúster blue está en el grupo de balanceo de cargas.

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

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    
  4. En un navegador, ve a la URL generada a partir del comando anterior.

    En el gráfico, se muestra que solo el clúster blue recibe tráfico de Online Boutique.

    El tráfico que fluye solo al clúster “azul”.

Actualiza el clúster green:

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

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

    gcloud container clusters list
    

    El resultado es similar al siguiente:

    NAME            LOCATION    MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION    NUM_NODES  STATUS
    ingress-config  us-west1-a  1.14.10-gke.24  35.203.165.186  n1-standard-1  1.14.10-gke.24  3          RUNNING
    blue            us-west1-b  1.14.10-gke.24  34.82.76.141    n1-standard-1  1.14.10-gke.24  4          RUNNING
    green           us-west1-c  1.14.10-gke.24  35.197.46.200   n1-standard-1  1.14.10-gke.24  4          RUNNING
    
    

    Tus versiones de clúster pueden ser diferentes según cuándo completes este instructivo.

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

    gcloud container get-server-config --zone us-west1-c --format=json | jq
    '.validMasterVersions'
    

    El resultado es similar al siguiente:

    [
      "1.15.9-gke.22",
      "1.15.9-gke.12",
      "1.15.9-gke.9",
      "1.15.9-gke.8",
      "1.15.8-gke.3",
      "1.14.10-gke.27",
      "1.14.10-gke.24",
      "1.14.10-gke.22",
      "1.14.10-gke.21",
      "1.14.10-gke.17",
      "1.13.12-gke.30"
    ]
    
  3. Obtén una lista de las versiones NodeVersions disponibles en la zona:

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

    El resultado es similar al siguiente:

    [
      "1.15.9-gke.22",
      "1.15.9-gke.12",
      "1.15.9-gke.9",
      "1.15.9-gke.8",
      "1.15.8-gke.3",
      "1.15.8-gke.2",
      "1.15.7-gke.23",
      "1.15.7-gke.2",
      "1.15.4-gke.22",
      "1.14.10-gke.27",
      "1.14.10-gke.24",
      "1.14.10-gke.22",
      "1.14.10-gke.21",
      "1.14.10-gke.17",
      "1.14.10-gke.0",
      "1.14.9-gke.23",
      "1.14.9-gke.2",
      "1.14.9-gke.0",
      "1.14.8-gke.33",
      "1.14.8-gke.21"
    ]
    
  4. Configura una variable de entorno para una versión MasterVersion y NodeVersion que sea posterior a la versión actual del clúster green:

    export UPGRADE_VERSION="1.16.13-gke.401"
    

    En este instructivo, se usa la versión 1.16.13-gke.401. Las versiones de tu clúster pueden ser diferentes según las versiones que estén disponibles cuando completes este instructivo. Para obtener más información sobre la actualización, consulta la página Actualiza de forma manual un clúster o un grupo de nodos. Recomendamos elegir la misma versión para todos los nodos. Elige una de las versiones disponibles de tu lista.

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

    gcloud container clusters upgrade green \
        --zone us-west1-c --master --cluster-version ${UPGRADE_VERSION}
    

    Para confirmar la actualización, presiona Y.

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

    Una vez que se completa la actualización, el resultado es el siguiente:

    Updated
    [https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-c/clusters/green].
    
  6. Actualiza los nodos en el clúster green:

    gcloud container clusters upgrade green \
        --zone=us-west1-c --node-pool=default-pool \
        --cluster-version ${UPGRADE_VERSION}
    

    Para confirmar la actualización, presiona Y.

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

    Una vez que se completa la actualización, el resultado es el siguiente:

    Upgrading green... Done with 4 out of 4 nodes (100.0%): 4 succeeded...done.
    Updated [https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-c/clusters/green].
    
  7. Verifica que el clúster green esté actualizado:

    gcloud container clusters list
    

    El resultado es similar al siguiente:

    NAME            LOCATION    MASTER_VERSION   MASTER_IP       MACHINE_TYPE   NODE_VERSION     NUM_NODES  STATUS
    ingress-config  us-west1-a  1.14.10-gke.24   35.203.165.186  n1-standard-1  1.14.10-gke.24   3          RUNNING
    blue            us-west1-b  1.14.10-gke.24   34.82.76.141    n1-standard-1  1.14.10-gke.24   4          RUNNING
    green           us-west1-c  1.16.13-gke.401  35.197.46.200   n1-standard-1  1.16.13-gke.401  4          RUNNING
    

Agrega el clúster green al grupo de balanceo de cargas

En esta sección, volverás a agregar el clúster green al grupo de balanceo de cargas.

  1. En Cloud Shell, verifica que todas las implementaciones de la app Online Boutique se ejecuten en el clúster green antes de agregarla al grupo de balanceo de cargas:

    kubectl --context ${GREEN_CLUSTER} get pods
    

    El resultado es similar al siguiente:

    NAME                                     READY   STATUS    RESTARTS   AGE
    adservice-86f5dfb995-2b25h               1/1     Running   0          16m
    cartservice-76cf9686b6-ws7b7             1/1     Running   1          13m
    checkoutservice-7766b946f5-6fhjh         1/1     Running   0          9m50s
    currencyservice-76975c7847-rf8r7         1/1     Running   0          13m
    emailservice-c55cd96f-pht8h              1/1     Running   0          13m
    frontend-f4b7cd95-wxdsh                  1/1     Running   0          13m
    loadgenerator-6784bc5f77-6b4cd           1/1     Running   6          6m34s
    paymentservice-696f796545-9wrl7          1/1     Running   0          9m49s
    productcatalogservice-7975f8588c-kbm5k   1/1     Running   0          6m33s
    recommendationservice-6d44459d79-km8vm   1/1     Running   0          9m49s
    redis-cart-6448dcbdcc-sjg69              1/1     Running   0          13m
    shippingservice-767f84b88c-gh9m4         1/1     Running   0          9m49s
    
  2. Actualiza el recurso MutliclusterService para volver a agregar el clúster green al grupo de balanceo de cargas:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue-green.yaml
    
  3. Verifica que tengas 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'
    

    Este es el resultado:

    {
        "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 Cloud Console. Genera la URL:

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    
  5. En un navegador, ve a la URL generada por el comando anterior.

    En el gráfico, se muestra que los clústeres azules y verdes reciben tráfico de la app Online Boutique.

    Ambos clústeres reciben tráfico.

    Felicitaciones. Actualizaste con éxito un clúster de GKE en una arquitectura de varios clústeres con Ingress.

  6. A fin de actualizar el clúster blue, repite el proceso para desviar y actualizar el clúster verde y reemplaza green por blue.

Realiza una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en el instructivo:

La manera más fácil de eliminar la facturación es borrar el proyecto de Cloud que creaste para el instructivo. Como alternativa, puedes borrar los recursos individuales.

Borra los clústeres

  1. En Cloud Shell, anula el registro y borra los clústeres blue y green:

    gcloud container hub memberships unregister green \
        --project=${PROJECT} \
        --gke-uri=${GREEN_URI}
    
    gcloud container clusters delete green --zone us-west1-c --quiet
    
    gcloud container hub memberships unregister blue \
        --project=${PROJECT} \
        --gke-uri=${BLUE_URI}
    
    gcloud container clusters delete blue --zone us-west1-b --quiet
    
  2. Borra el recurso MuticlusterIngress del clúster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} delete -f mci.yaml
    

    Con este comando, se borran los recursos de Cloud Load Balancing del proyecto.

  3. Cancela el registro del clúster ingress-config y bórralo:

    gcloud container hub memberships unregister ingress-config \
        --project=${PROJECT} \
        --gke-uri=${INGRESS_CONFIG_URI}
    gcloud container clusters delete ingress-config --zone us-west1-a --quiet
    
  4. Verifica que se borren todos los clústeres:

    gcloud container clusters list
    

    Este es el resultado:

    *<null>*
    
  5. Restablece el archivo kubeconfig:

    unset KUBECONFIG
    
  6. Quita la carpeta WORKDIR:

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

Borra el proyecto

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?