Mettre à niveau un environnement GKE multicluster avec Ingress pour Anthos

Ce tutoriel explique comment mettre à niveau un environnement Google Kubernetes Engine (GKE) multicluster à l'aide d'Ingress. Ce tutoriel s'inscrit dans la continuité des mises à niveau GKE multiclusters à l'aide d'un document Ingress, qui expliquent en détail le processus, l'architecture et les termes. Nous vous recommandons de lire le document conceptuel avant ce tutoriel. Ce document est destiné aux administrateurs Google Cloud chargés de gérer les parcs de clusters GKE.

Nous vous recommandons de mettre à niveau automatiquement vos clusters GKE. La mise à niveau automatique est une façon entièrement gérée de mettre à niveau automatiquement vos clusters (plan de contrôle et nœuds) selon un calendrier de lancement déterminé par Google Cloud. Cela ne requiert aucune intervention de l'opérateur. Toutefois, si vous souhaitez mieux contrôler comment et quand les clusters sont mis à niveau, ce tutoriel décrit une méthode de mise à niveau de plusieurs clusters pour lesquels vos applications s'exécutent sur tous les clusters. Il utilise ensuite Ingress pour drainer un cluster à la fois avant la mise à niveau.

Architecture

Ce tutoriel utilise l'architecture suivante. Trois clusters au total sont utilisés : deux clusters (blue et green) agissent comme des clusters identiques avec la même application déployée, et un cluster (ingress-config) sert de cluster de plan de contrôle qui configure Ingress. Dans ce tutoriel, vous allez déployer un exemple d'application appelée "Online Boutique" sur deux clusters d'application (clusters blue et green).

L'application Online Boutique est un exemple d'application de microservices composée de 10 microservices simulant une application d'e-commerce. L'application se compose d'une interface Web (à laquelle les clients peuvent accéder) et de plusieurs services de backend, par exemple un panier, un catalogue de produits et des services de recommandation qui simulent un e-vendeur.

Architecture de deux clusters identiques et d'un cluster de plan de contrôle.

Objectifs

  • Créer trois clusters GKE et les enregistrer dans Hub
  • Configurer un cluster GKE (ingress-config) en tant que cluster de configuration central.
  • Déployer Online Boutique en tant qu'exemple d'application sur les autres clusters GKE.
  • Configurer Ingress de manière à envoyer le trafic client vers l'application Online Boutique qui s'exécute sur les deux clusters d'application.
  • Configurer un générateur de charge dans l'application Online Boutique et configurer la surveillance.
  • Supprimer (drainer) un cluster d'application de l'objet Ingress multicluster et mettre à niveau le cluster drainé.
  • Rediriger le trafic vers le cluster mis à niveau à l'aide de Ingress.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Avant de commencer

  1. Pour suivre ce tutoriel, vous devez configurer l'objet Ingress de façon à obtenir la configuration suivante :
    • Deux clusters ou plus avec les mêmes applications, tels que les espaces de noms, les Déploiements et les Services, exécutées sur tous les clusters.
    • La mise à niveau automatique est désactivée pour tous les clusters.
    • GKE versions statiques 1.14.10-gke.17 ou ultérieures, ou clusters GKE dans les versions disponibles Rapide ou Standard.
    • Les clusters sont des clusters de VPC natif qui utilisent des plages d'adresses IP d'alias.
    • L'équilibrage de charge HTTP doit être activé (activé par défaut).
    • gcloud --version doit être au minimum en version 281. Les étapes d'enregistrement du cluster GKE s'appuient sur cette version ou une version ultérieure.
  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Dans Cloud Console, activez Cloud Shell.

    Activer Cloud Shell

  5. Définissez le projet par défaut :

    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud config set project ${PROJECT}
    
  6. Activez les API GKE, Hub et multiclusteringress :

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

Configurer l'environnement

  1. Dans Cloud Shell, clonez le dépôt pour obtenir les fichiers de ce tutoriel :

    cd ${HOME}
    git clone https://github.com/ameer00/gke-multicluster-upgrades.git
    
  2. Créez un répertoire WORKDIR :

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

Créer et enregistrer des clusters GKE dans Hub

Dans cette section, vous allez créer trois clusters GKE et les enregistrer dans Anthos Hub.

Créer des clusters GKE

  1. Dans Cloud Shell, créez trois clusters 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
    

    Pour les besoins de ce tutoriel, vous allez créer les clusters dans trois régions différentes : us-west1-a, us-west1-b et us-west1-c. Pour en savoir plus sur les régions, consultez la page Zones géographiques et régions.

  2. Attendez quelques minutes jusqu'à ce que tous les clusters soient créés. Assurez-vous que les clusters sont en cours d'exécution :

    gcloud container clusters list
    

    Le résultat ressemble à ce qui suit :

    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. Créez un fichier kubeconfig et connectez-vous à tous les clusters pour générer des entrées dans le fichier kubeconfig :

    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}
    

    Le fichier kubeconfig vous permet de créer une authentification pour les clusters en créant un utilisateur et un contexte pour chaque cluster. Une fois que vous avez créé le fichier kubeconfig, vous pouvez rapidement basculer entre différents contextes pour les clusters.

  4. Vérifiez que le fichier kubeconfig comporte trois clusters :

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

    Le résultat est le suivant :

    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. Obtenez le contexte des trois clusters pour une utilisation ultérieure :

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

    Le résultat est le suivant :

    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
    

Enregistrer des clusters GKE dans Hub

Hub vous permet d'exploiter vos clusters Kubernetes dans des environnements hybrides. Hub permet également aux clusters enregistrés d'utiliser des fonctionnalités GKE avancées, telles que Ingress. Pour enregistrer un cluster GKE dans Hub, utilisez un compte de service Google Cloud, puis attribuez à ce compte l'autorisation IAM (Identity and Access Management).

  1. Dans Cloud Shell, créez un compte de service et téléchargez ses identifiants :

    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. Obtenez les URI des clusters 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}"
    

    Le résultat est le suivant :

    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. Enregistrez les trois clusters dans le 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. Vérifiez que les clusters sont enregistrés :

    gcloud container hub memberships list
    

    Le résultat ressemble à ce qui suit :

    NAME            EXTERNAL_ID
    blue            d40521d9-693f-11ea-a26c-42010a8a0010
    green           d3027ecd-693f-11ea-ad5f-42010a8a00a9
    ingress-config  bb778338-693f-11ea-a053-42010a8a016a
    
  5. Configurez le cluster ingress-config en tant que cluster de configuration pour Ingress en activant la fonctionnalité multiclusteringress via le Hub :

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

    La commande précédente ajoute les CRD (Définitions de ressources personnalisées) MulticlusterIngress et MulticlusterService au cluster config. Cette opération prend quelques minutes. Attendez la fin de l'opération avant de passer à l'étape suivante.

  6. Vérifiez que le cluster ingress-cluster a bien été configuré pour Ingress :

    watch gcloud alpha container hub ingress describe
    

    Attendez jusqu'à obtenir un résultat semblable à ce qui suit :

    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
    

    Pour quitter la commande watch, appuyez sur les touches Ctrl+C.

Déployer l'application Online Boutique sur les clusters bleus et verts

  1. Dans Cloud Shell, déployez l'application Online Boutique sur les clusters blue et green :

    kubectl --context ${BLUE_CLUSTER} apply -f ${WORKDIR}/hipster-shop
    kubectl --context ${GREEN_CLUSTER} apply -f ${WORKDIR}/hipster-shop
    
  2. Attendez quelques minutes et assurez-vous que tous les Pods des clusters blue et green ont l'état Running :

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

    Le résultat ressemble à ce qui suit :

    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
    

Configurer un objet Ingress multicluster

Dans cette section, vous allez créer un objet Ingress multicluster qui envoie le trafic à l'interface de Online Boutique à la fois aux clusters blue et green. Vous utilisez Cloud Load Balancing pour créer un équilibreur de charge qui utilise les services frontend dans les clusters blue et green en tant que backends. Pour créer l'équilibreur de charge, vous avez besoin de deux types de ressources : une ressource MultiClusterIngress et une ou plusieurs ressources MultiClusterServices. Les objets MultiClusterIngress et MultiClusterService sont des ressources multicluster correspondant aux ressources Kubernetes "Ingress" et "Service" utilisées dans le cadre d'un cluster unique.

  1. Dans Cloud Shell, déployez la ressource MulticlusterIngress sur le cluster ingress-config :

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

    Le résultat est le suivant :

    multiclusteringress.networking.gke.io/frontend-multicluster-ingress created
    
  2. Déployez la ressource MulticlusterServicesur le cluster ingress-config :

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

    Le résultat est le suivant :

    multiclusterservice.networking.gke.io/frontend-multicluster-svc created
    
  3. Pour comparer les deux ressources, procédez comme suit :

    • Inspectez la ressource MulticlusterIngress :

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

      Le résultat est le suivant :

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

      La ressource MulticlusterIngress est semblable à la ressource Ingress Kubernetes, à la différence que la spécification serviceName pointe vers une ressource MulticlusterService.

    • Inspectez la ressource MulticlusterService :

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

      Le résultat est le suivant :

      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
      

      La ressource MulticlusterService est semblable à une ressource de Service Kubernetes, à la différence qu'elle comporte une spécification clusters. La valeur clusters correspond à la liste des clusters enregistrés où la ressource MulticlusterService est créée.

    • Vérifiez que la ressource MulticlusterIngress a créé un équilibreur de charge avec un service de backend pointant vers la ressource MulticlusterService :

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

      Attendez jusqu'à obtenir un résultat semblable à ce qui suit :

      34.107.246.9
      

      Notez l'adresse IP virtuelle (VIP).

      Pour quitter la commande watch, appuyez sur Control+C.

  4. Pour accéder à l'application Online Boutique, accédez à l'adresse IP virtuelle dans votre navigateur.

    Si un message d'erreur 404 s'affiche, patientez encore un peu et actualisez la page jusqu'à ce que l'interface de Online Boutique s'affiche.

    Parcourez l'application et effectuez quelques achats tests. À ce stade, l'application Online Boutique est déployée à la fois sur les clusters blue et green, et la ressource MulticlusterIngress est configurée pour envoyer du trafic vers les deux clusters.

Configurer le générateur de charge

Dans cette section, vous allez configurer un Service loadgenerator qui génère du trafic client vers l'adresse IP virtuelle de Cloud Load Balancing. Tout d'abord, le trafic est envoyé vers les clusters blue et green, car la ressource MulticlusterService est configurée pour envoyer du trafic vers les deux clusters. Par la suite, vous allez configurer la ressource MulticlusterService pour envoyer du trafic vers un seul cluster.

  1. Dans Cloud Shell, obtenez l'adresse IP virtuelle de Cloud Load Balancing :

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

    Le résultat ressemble à ce qui suit :

    34.107.246.9
    
  2. Configurez le service loadgenerator pour envoyer du trafic client vers Cloud Load Balancing :

    sed -i 's/GCLB_VIP/'${GCLB_VIP}'/g' ${WORKDIR}/load-generator/loadgenerator.yaml
    
  3. Déployez loadgenerator dans le cluster ingress-config :

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f ${WORKDIR}/load-generator
    
  4. Vérifiez que les pods loadgenerator du cluster ingress-config présentent tous l'état Running :

    kubectl --context ${INGRESS_CONFIG_CLUSTER} get pods
    

    Le résultat ressemble à ce qui suit :

    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 l'un des Pods n'est pas à l'état Running, attendez quelques minutes, puis exécutez à nouveau la commande.

Surveiller le trafic

Dans cette section, vous allez surveiller le trafic vers l'application Online Boutique à l'aide de Cloud Console.

Dans la section précédente, vous avez configuré un déploiement loadgenerator qui simule le trafic de Online Boutique en y accédant via l'adresse IP virtuelle de Cloud Load Balancing. Vous pouvez surveiller ces métriques via Cloud Console. Configurez d'abord la surveillance afin de pouvoir surveiller lorsque vous drainez des clusters pour les mises à niveau (comme décrit dans la section suivante).

  1. Dans Cloud Shell, obtenez le nom de la règle de transfert pour la ressource frontend-multicluster-ingress MulticlusterIngress :

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

    Le résultat ressemble à ce qui suit :

    mci-h8zu63-default-frontend-multicluster-ingress
    
  2. Générez l'URL de l'application :

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

    Le résultat ressemble à ce qui suit :

    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. Dans un navigateur, accédez à l'URL générée par la commande précédente. Dans la liste déroulante de Backend, sélectionnez le backend commençant par mci.

    Sélection du backend.

    Le trafic vers l'application Online Boutique est acheminé à la fois vers les clusters blue et green (notés par les deux zones dans lesquelles les clusters se trouvent). Le graphique des métriques chronologiques montre le trafic allant aux deux backends. Dans la colonne Backend, les valeurs k8s1- indiquent que le groupe de points de terminaison du réseau (NEG) pour les deux MulticlusterServices de l'interface s'exécute dans les clusters blue et green.

    Graphique des métriques chronologiques montrant le trafic circulant vers les deux backends.

Drainer et mettre à niveau le cluster green

Dans cette section, vous drainez le cluster green. Le drainage d'un cluster signifie que vous le supprimez du pool d'équilibrage de charge. Après avoir drainé le cluster green, tout le trafic client destiné à l'application Online Boutique est dirigé vers le cluster blue. Vous pouvez surveiller ce processus comme décrit dans la section précédente. Une fois le cluster drainé, vous pouvez mettre à jour le cluster drainé. Après la mise à niveau, vous pouvez le réinstaller dans le pool d'équilibrage de charge. Répétez ces étapes pour mettre à niveau l'autre cluster (non illustré dans ce tutoriel).

Pour drainer le cluster green, mettez à jour la ressource MulticlusterService dans le cluster ingress-cluster et supprimez le cluster green de la spécification clusters.

Drainer le cluster vert

  1. Dans Cloud Shell, mettez à jour la ressource MulticlusterService dans le cluster ingress-config :

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue.yaml
    
  2. Vérifiez que vous ne disposez que du cluster blue dans la spécification clusters :

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

    Le résultat est le suivant :

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

    Seul le cluster blue est répertorié dans la spécification clusters, de sorte que seul le cluster blue se trouve dans le pool d'équilibrage de charge.

  3. Vous pouvez consulter les métriques à partir des métriques Cloud Load Balancing dans Cloud Console. Générez l'URL :

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    
  4. Dans un navigateur, accédez à l'URL générée à partir de la commande précédente.

    Le graphique montre que seul le cluster blue reçoit du trafic en provenance de l'application Online Boutique.

    Trafic acheminé vers le cluster

Mettre à niveau le cluster green :

Maintenant que le cluster green ne reçoit plus de trafic client, vous pouvez le mettre à niveau (plan de contrôle et nœuds).

  1. Dans Cloud Shell, obtenez la version actuelle des clusters :

    gcloud container clusters list
    

    Le résultat ressemble à ce qui suit :

    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
    
    

    Vos versions de cluster peuvent varier selon la date à laquelle vous suivez ce tutoriel.

  2. Obtenez la liste des versions MasterVersions disponibles dans la zone :

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

    Le résultat ressemble à ce qui suit :

    [
      "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. Obtenez une liste des versions NodeVersions disponibles dans la zone :

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

    Le résultat ressemble à ce qui suit :

    [
      "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. Définissez une variable d'environnement pour une version MasterVersion et NodeVersion supérieure à la version actuelle du cluster green :

    export UPGRADE_VERSION="1.16.13-gke.401"
    

    Ce tutoriel utilise la version 1.16.13-gke.401. Vos versions de cluster peuvent varier en fonction des versions disponibles au moment où vous suivez ce tutoriel. Pour en savoir plus sur la mise à niveau, consultez la section Mettre à niveau des clusters et des pools de nœuds. Nous vous recommandons de choisir la même version pour tous les nœuds. Sélectionnez l'une des versions disponibles dans votre liste.

  5. Mettez à jour le nœud control plane du cluster green :

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

    Pour confirmer la mise à niveau, appuyez sur Y.

    Cela prend quelques minutes. Attendez la fin de la mise à niveau avant de continuer.

    Une fois la mise à jour terminée, le résultat est le suivant :

    Updated
    [https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-c/clusters/green].
    
  6. Mettez à niveau les nœuds du cluster green :

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

    Pour confirmer la mise à jour, appuyez sur Y.

    Cela prend quelques minutes. Attendez la fin de la mise à niveau des nœuds avant de continuer.

    Une fois la mise à niveau terminée, le résultat est le suivant :

    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. Vérifiez que le cluster green est mis à niveau :

    gcloud container clusters list
    

    Le résultat ressemble à ce qui suit :

    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
    

Ajouter le cluster green au pool d'équilibrage de charge

Dans cette section, vous ajoutez le cluster green au pool d'équilibrage de charge.

  1. Dans Cloud Shell, vérifiez que tous les déploiements d'applications de Online Boutique s'exécutent sur le cluster green avant de l'ajouter à nouveau au pool d'équilibrage de charge :

    kubectl --context ${GREEN_CLUSTER} get pods
    

    Le résultat ressemble à ce qui suit :

    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. Mettez à jour la ressource MutliclusterService pour ajouter de nouveau le cluster green au pool d'équilibrage de charge :

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue-green.yaml
    
  3. Vérifiez que la spécification des clusters contient à la fois les clusters blue et green :

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

    Le résultat est le suivant :

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

    Les clusters blue et green figurent maintenant dans la spécification clusters.

  4. Les métriques issues de Cloud Load Balancing sont disponibles dans Cloud Console. Générez l'URL :

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    
  5. Dans un navigateur, accédez à l'URL générée par la commande précédente.

    Le graphique montre que les clusters bleus et verts reçoivent le trafic de la part de l'application Online Boutique.

    Les deux clusters reçoivent du trafic.

    Félicitations ! Vous avez correctement mis à niveau un cluster GKE dans une architecture multicluster à l'aide d'Ingress.

  6. Pour mettre à niveau le cluster blue, répétez la procédure pour drainer et mettre à niveau le cluster vert, en remplaçant green par blue.

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet Cloud que vous avez créé pour le tutoriel. Vous pouvez également supprimer les différentes ressources.

Supprimer les clusters

  1. Dans Cloud Shell, annulez l'enregistrement et supprimez les clusters blue et 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. Supprimez la ressource MuticlusterIngress du cluster ingress-config :

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

    Cette commande supprime les ressources Cloud Load Balancing du projet.

  3. Annuler l'enregistrement et supprimer le cluster ingress-config :

    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. Vérifiez que tous les clusters sont supprimés :

    gcloud container clusters list
    

    Le résultat est le suivant :

    *<null>*
    
  5. Réinitialisez le fichier kubeconfig :

    unset KUBECONFIG
    
  6. Supprimez le dossier WORKDIR :

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

Supprimer le projet

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante