Déployer des passerelles multiclusters

Autopilot Standard

---

Cette page explique comment déployer des ressources Kubernetes Gateway pour l'équilibrage de charge du trafic entrant sur plusieurs clusters Google Kubernetes Engine (GKE) (ou un parc). Avant de déployer des passerelles multiclusters, consultez la page Activer les passerelles multiclusters pour préparer votre environnement.

Pour déployer des passerelles destinées à équilibrer la charge du trafic entrant sur un seul cluster GKE, consultez la page Déployer des passerelles.

Ressources Gateway multiclusters

Une passerelle multicluster est une ressource de passerelle (Gateway) qui équilibre la charge de trafic entre plusieurs clusters Kubernetes. Dans GKE, les ressources GatewayClass gke-l7-global-external-managed-mc, gke-l7-regional-external-managed-mc, gke-l7-rilb-mc et gke-l7-gxlb-mc déploient des passerelles multiclusters qui fournissent un routage HTTP, une répartition du trafic, une mise en miroir du trafic, un basculement basé sur l'état, etc. sur différents clusters GKE et espaces de noms Kubernetes, ainsi que dans différentes régions. Les passerelles multiclusters facilitent la gestion, la sécurisation et la mise l'échelle de la mise en réseau des applications pour de nombreux clusters et équipes par les administrateurs d'infrastructure.

Cette page présente trois exemples afin de vous apprendre à déployer des passerelles multiclusters à l'aide du contrôleur GKE Gateway :

• Exemple 1 : passerelle multicluster externe offrant un équilibrage de charge sur deux clusters GKE pour le trafic Internet.
• Exemple 2 : répartition du trafic bleu-vert en fonction du poids et mise en miroir du trafic sur deux clusters GKE pour le trafic VPC interne.
• Exemple 3 : une passerelle basée sur la capacité permettant d'équilibrer la charge de requêtes vers différents backends en fonction de leur capacité maximale.

Chaque exemple utilise les mêmes applications store et site pour modéliser un scénario réel dans lequel un service d'achats en ligne et un service de site Web sont gérés et exploités par des équipes distinctes, et sont déployés sur un parc de clusters GKE partagé. Chaque exemple met en évidence différentes topologies et différents cas d'utilisation rendus possibles par les passerelles multiclusters.

Les passerelles multiclusters nécessitent une préparation environnementale avant de pouvoir être déployées. Avant de continuer, suivez les étapes décrites dans la section Activer les passerelles multiclusters :

1. Déployez des clusters GKE

2. Enregistrez vos clusters dans un parc.

3. Activez les contrôleurs de service et de passerelle multiclusters.

Consultez la section Limites et problèmes connus du contrôleur GKE Gateway avant de l'utiliser dans votre environnement.

Passerelle externe multicluster et multirégionale

Dans ce tutoriel, vous allez créer une passerelle multicluster externe qui diffuse du trafic externe vers une application exécutée dans deux clusters GKE.

Au cours des étapes suivantes, vous allez :

1. Déployer l'exemple d'application store sur les clusters gke-west-1 et gke-east-1.
2. Configurer les services sur chaque cluster à exporter dans votre parc (services multiclusters).
3. Déployer une passerelle multicluster externe et une ressource HTTPRoute sur votre cluster de configuration (gke-west-1).

Une fois les ressources d'application et de passerelle déployées, vous pouvez contrôler le trafic entre les deux clusters GKE à l'aide du routage basé sur le chemin d'accès :

• Les requêtes adressées à /west sont acheminées vers des pods store dans le cluster gke-west-1.
• Les requêtes adressées à /east sont acheminées vers des pods store dans le cluster gke-east-1.
• Les requêtes vers les autres chemins sont acheminées vers l'un des clusters, en fonction de leur état, de leur capacité et de leur proximité avec le client demandeur.

Déployer l'application de démonstration

1. Créez le déploiement et l'espace de noms store dans les trois clusters déployés dans la section Activer les passerelles multiclusters :

   kubectl apply --context gke-west-1 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store.yaml
   kubectl apply --context gke-west-2 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store.yaml
   kubectl apply --context gke-east-1 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store.yaml
   

   Cela a pour effet de déployer les ressources suivantes sur chaque cluster :

   namespace/store created
   deployment.apps/store created
   

   Tous les exemples de cette page utilisent l'application déployée lors de la présente étape. Assurez-vous que l'application est déployée sur les trois clusters avant d'essayer l'une des étapes restantes. Cet exemple n'utilise que les clusters gke-west-1 et gke-east-1. gke-west-2 est utilisé dans un autre exemple.

Services multiclusters

Les services sont la manière dont les pods sont exposés aux clients. Étant donné que le contrôleur GKE Gateway utilise l'équilibrage de charge natif en conteneurs, il n'utilise pas l'équilibrage de charge ClusterIP ou Kubernetes pour atteindre les pods. Le trafic est envoyé directement de l'équilibreur de charge aux adresses IP des pods. Toutefois, les services jouent toujours un rôle essentiel d'identifiant logique pour le regroupement de pods.

Les services multiclusters (MCS) sont une norme d'API pour les services couvrant plusieurs clusters et leur contrôleur GKE qui permettent la détection de services sur les clusters GKE. Le contrôleur de passerelle multicluster utilise des ressources d'API MCS pour regrouper les pods dans un service adressable sur plusieurs clusters ou couvrant plusieurs clusters.

L'API des services multiclusters définit les ressources personnalisées suivantes :

• Les ressources ServiceExport sont mappées à un service Kubernetes en exportant les points de terminaison de ce service vers tous les clusters enregistrés dans la Fleet. Lorsqu'un service possède une ressource serviceExport correspondante, cela signifie qu'il peut être traité par une passerelle multicluster.
• Les ressources ServiceImports sont générées automatiquement par le contrôleur de service multicluster. Les ressources ServiceExport et ServiceImport sont disponibles par paires. Si une ressource de type ServiceExport existe dans le parc, une ressource ServiceImport correspondante est créée pour permettre l'accès au service mappé à l'exportation depuis les clusters.

L'exportation de services fonctionne de la manière suivante : Un service de magasin existe dans gke-west-1 et permet de sélectionner un groupe de pods dans ce cluster. Une ressource ServiceExport est créée dans le cluster, ce qui permet aux pods de gke-west-1 d'être accessibles à partir des autres clusters du parc. La ressource ServiceExport mappe et expose les services ayant le même nom et le même espace de noms que la ressource ServiceExport.

apiVersion: v1
kind: Service
metadata:
  name: store
  namespace: store
spec:
  selector:
    app: store
  ports:
  - port: 8080
    targetPort: 8080
---
kind: ServiceExport
apiVersion: net.gke.io/v1
metadata:
  name: store
  namespace: store

Le schéma suivant illustre ce qui se passe après un déploiement de ServiceExport. Si une paire ServiceExport et Service existe, le contrôleur de service multicluster déploie une ressource ServiceImport correspondante sur chaque cluster GKE du parc. La ressource ServiceImport est la représentation locale du service store dans chaque cluster. Cela permet au pod client de client dans gke-east-1 d'utiliser ClusterIP ou des services sans adresse IP de cluster pour atteindre les pods store dans gke-west-1. Lorsqu'ils sont utilisés de cette manière, les services multiclusters fournissent un équilibrage de charge est-ouest entre les clusters sans nécessiter de service LoadBalancer interne. Pour utiliser les services multiclusters pour l'équilibrage de charge cluster à cluster, consultez la page Configurer des services multicluster.

Les passerelles multiclusters utilisent également les importations de services, mais pas pour l'équilibrage de charge de cluster à cluster. Au lieu de cela, les passerelles utilisent les ressources ServiceImport comme identifiants logiques pour un service existant dans un autre cluster ou s'étendant sur plusieurs clusters. Le fichier HTTPRoute suivant fait référence à une ressource ServiceImport plutôt qu'à une ressource Service. Faire référence à une ressource ServiceImport indique que le trafic est transféré vers un groupe de pods backend qui s'exécutent sur un ou plusieurs clusters.

kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: store-route
  namespace: store
  labels:
    gateway: multi-cluster-gateway
spec:
  parentRefs:
  - kind: Gateway
    namespace: store
    name: external-http
  hostnames:
  - "store.example.com"
  rules:
  - backendRefs:
    - group: net.gke.io
      kind: ServiceImport
      name: store
      port: 8080

Le schéma suivant montre comment HTTPRoute achemine le trafic store.example.com vers les pods store sur gke-west-1 et gke-east-1. L'équilibreur de charge les traite comme un seul pool de backends. Si les pods de l'un des clusters deviennent non opérationnels, inaccessibles ou sans trafic, la charge de trafic est répartie entre les pods restants de l'autre cluster. De nouveaux clusters peuvent être ajoutés ou supprimés à l'aide du service store et de ServiceExport. Cette opération ajoute et supprime de manière transparente les pods de backend sans aucune modification explicite de la configuration de routage.

Exporter des services

À ce stade, l'application s'exécute sur les deux clusters. Ensuite, vous exposerez et exporterez les applications en déployant des ressources Service et ServiceExport sur chaque cluster.

1. Appliquez le fichier manifeste suivant au cluster gke-west-1 pour créer vos ressources store et store-west-1 Services et ServiceExport :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   apiVersion: v1
   kind: Service
   metadata:
     name: store
     namespace: store
   spec:
     selector:
       app: store
     ports:
     - port: 8080
       targetPort: 8080
   ---
   kind: ServiceExport
   apiVersion: net.gke.io/v1
   metadata:
     name: store
     namespace: store
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-west-1
     namespace: store
   spec:
     selector:
       app: store
     ports:
     - port: 8080
       targetPort: 8080
   ---
   kind: ServiceExport
   apiVersion: net.gke.io/v1
   metadata:
     name: store-west-1
     namespace: store
   EOF
   

2. Appliquez le fichier manifeste suivant au cluster gke-east-1 pour créer vos ressources store et store-east-1 Services et ServiceExport :

   cat << EOF | kubectl apply --context gke-east-1 -f -
   apiVersion: v1
   kind: Service
   metadata:
     name: store
     namespace: store
   spec:
     selector:
       app: store
     ports:
     - port: 8080
       targetPort: 8080
   ---
   kind: ServiceExport
   apiVersion: net.gke.io/v1
   metadata:
     name: store
     namespace: store
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-east-1
     namespace: store
   spec:
     selector:
       app: store
     ports:
     - port: 8080
       targetPort: 8080
   ---
   kind: ServiceExport
   apiVersion: net.gke.io/v1
   metadata:
     name: store-east-1
     namespace: store
   EOF
   

3. Vérifiez que les ressources ServiceExport appropriées ont été créées dans le cluster.

   kubectl get serviceexports --context CLUSTER_NAME --namespace store
   

   Remplacez CLUSTER_NAME par gke-west-1 et gke-east-1. La sortie doit ressembler à ceci :

   # gke-west-1
   NAME           AGE
   store          2m40s
   store-west-1   2m40s
   
   # gke-east-1
   NAME           AGE
   store          2m25s
   store-east-1   2m25s
   

   Cela montre que le service store contient des pods store sur les deux clusters, tandis que les services store-west-1 et store-east-1 ne contiennent que des pods store sur leurs clusters respectifs. Ces services qui se chevauchent permettent de cibler les pods de plusieurs clusters ou un sous-ensemble de pods sur un seul cluster.

4. Après quelques minutes, vérifiez que le ServiceImports associé a bien été créé automatiquement par le contrôleur de services multicluster sur l'ensemble des clusters du parc.

   Remarque : La mise en place du premier MCS que vous créez dans votre parc peut prendre jusqu'à 20 minutes. L'exportation de nouveaux services après la création du premier ou l'ajout de points de terminaison à des services multiclusters existants est plus rapide (de quelques minutes dans certains cas).

   kubectl get serviceimports --context CLUSTER_NAME --namespace store
   

   Remplacez CLUSTER_NAME par gke-west-1 et gke-east-1. La sortie doit ressembler à ceci :

   # gke-west-1
   NAME           TYPE           IP                  AGE
   store          ClusterSetIP   ["10.112.31.15"]    6m54s
   store-east-1   ClusterSetIP   ["10.112.26.235"]   5m49s
   store-west-1   ClusterSetIP   ["10.112.16.112"]   6m54s
   
   # gke-east-1
   NAME           TYPE           IP                  AGE
   store          ClusterSetIP   ["10.72.28.226"]    5d10h
   store-east-1   ClusterSetIP   ["10.72.19.177"]    5d10h
   store-west-1   ClusterSetIP   ["10.72.28.68"]     4h32m
   

   Cela montre que les trois services sont bien accessibles à partir des deux clusters du parc. Toutefois, comme il n'existe qu'un seul cluster de configuration actif par parc, vous ne pouvez déployer dans gke-west-1 que des passerelles et des routes HTTP qui font référence à ces ressources ServiceImport. Lorsqu'une ressource HTTPRoute dans le cluster de configuration fait référence à ces objets ServiceImport en tant que backends, la passerelle peut transférer le trafic vers ces services, quel que soit le cluster à partir duquel elles sont exportées.

Remarque : Le contrôleur de passerelle n'utilise pas les ressources ServiceImport ou ClusterClusterIP pour effectuer le routage, même si ClusterSetIP peut être utilisé pour équilibrer le trafic directement entre les clusters pour les cas d'utilisation est-ouest. Les ressources ServiceImport ne sont utilisées par les passerelles que pour leurs informations de découverte de services. L'ensemble du trafic de la passerelle passe directement de l'équilibreur de charge aux adresses IP des pods sans aucun équilibrage de charge kube-proxy.

Déployer des ressources Gateway et HTTPRoute

Une fois les applications déployées, vous pouvez configurer une passerelle à l'aide de la GatewayClass gke-l7-global-external-managed-mc. Cette passerelle crée un équilibreur de charge d'application externe configuré pour répartir le trafic entre vos clusters cibles.

1. Appliquez le fichier manifeste Gateway suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: Gateway
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: external-http
     namespace: store
   spec:
     gatewayClassName: gke-l7-global-external-managed-mc
     listeners:
     - name: http
       protocol: HTTP
       port: 80
       allowedRoutes:
         kinds:
         - kind: HTTPRoute
   EOF
   

   Remarque : Le déploiement et la diffusion du trafic de la passerelle peuvent prendre plusieurs minutes (jusqu'à 10).

   Cette configuration de passerelle déploie des ressources d'équilibreur de charge d'application externe avec la convention d'attribution de noms gkemcg1-NAMESPACE-GATEWAY_NAME-HASH.

   Les ressources par défaut créées avec cette configuration sont les suivantes :

   • 1 équilibreur de charge : gkemcg1-store-external-http-HASH
   • 1 adresse IP publique : gkemcg1-store-external-http-HASH
   • 1 règle de transfert : gkemcg1-store-external-http-HASH
   • 2 services de backend :
     • Service de backend 404 par défaut : gkemcg1-store-gw-serve404-HASH
     • Service de backend 500 par défaut : gkemcg1-store-gw-serve500-HASH
   • 1 vérification d'état :
     • Vérification d'état 404 par défaut : gkemcg1-store-gw-serve404-HASH
   • 0 règle de routage (le mappage d'URL est vide)

   À ce stade, toute requête envoyée à GATEWAY_IP:80 génère une page par défaut affichant le message suivant : fault filter abort.

   Avertissement : Dans cet exemple, nous déployons une passerelle multicluster externe qui écoute sur le port 80. Si vous déployez une passerelle multicluster externe pour un environnement de production, vous devez configurer un ensemble de fonctionnalités pour la sécuriser correctement en fonction de votre contexte et de votre environnement. Pour en savoir plus sur la sécurisation d'une passerelle multicluster, consultez la page Sécuriser une passerelle. Pour appliquer des règles à une passerelle multicluster, consultez la page Configurer des ressources de passerelle à l'aide de règles.

2. Appliquez le fichier manifeste HTTPRoute suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: public-store-route
     namespace: store
     labels:
       gateway: external-http
   spec:
     hostnames:
     - "store.example.com"
     parentRefs:
     - name: external-http
     rules:
     - matches:
       - path:
           type: PathPrefix
           value: /west
       backendRefs:
       - group: net.gke.io
         kind: ServiceImport
         name: store-west-1
         port: 8080
     - matches:
       - path:
           type: PathPrefix
           value: /east
       backendRefs:
         - group: net.gke.io
           kind: ServiceImport
           name: store-east-1
           port: 8080
     - backendRefs:
       - group: net.gke.io
         kind: ServiceImport
         name: store
         port: 8080
   EOF
   

   À ce stade, toute requête envoyée à GATEWAY_IP:80 génère une page par défaut affichant le message suivant : fault filter abort.

   Une fois déployé, cet objet HTTPRoute configure le comportement de routage suivant :

   • Les requêtes adressées à /west sont acheminées vers des pods store dans le cluster gke-west-1, car les pods sélectionnés par le ServiceExport store-west-1 n'existent que dans le cluster gke-west-1.
   • Les requêtes adressées à /east sont acheminées vers des pods store dans le cluster gke-east-1, car les pods sélectionnés par le ServiceExport store-east-1 n'existent que dans le cluster gke-east-1.
   • Les requêtes vers les autres chemins sont acheminées vers des pods store dans l'un des clusters, en fonction de leur état, de leur capacité et de leur proximité avec le client demandeur.
   • Les requêtes adressées à GATEWAY_IP:80 génèrent une page par défaut affichant le message suivant : fault filter abort.

   

   Notez que si tous les pods d'un cluster donné ne sont pas opérationnels (ou n'existent pas), le trafic vers le service store n'est envoyé qu'aux clusters comportant effectivement des pods store. L'existence d'une ressource ServiceExport et d'un service sur un cluster donné ne garantit pas que le trafic sera envoyé vers ce cluster. Les pods doivent exister et répondre de manière positive à la vérification d'état de l'équilibreur de charge, sans quoi l'équilibreur de charge enverra simplement le trafic vers les pods store opérationnels dans d'autres clusters.

   Des ressources sont créées avec cette configuration :

   • 3 services de backend :
     • Le service de backend store : gkemcg1-store-store-8080-HASH
     • Le service de backend store-east-1 : gkemcg1-store-store-east-1-8080-HASH
     • Le service de backend store-west-1 : gkemcg1-store-store-west-1-8080-HASH
   • 3 vérifications d'état :
     • La vérification d'état store : gkemcg1-store-store-8080-HASH
     • La vérification d'état store-east-1 : gkemcg1-store-store-east-1-8080-HASH
     • La vérification d'état store-west-1 : gkemcg1-store-store-west-1-8080-HASH
   • 1 règle de routage dans le mappage d'URL :
     • La règle de routage store.example.com :
     • 1 hôte : store.example.com
     • Plusieurs matchRules pour le routage vers les nouveaux services de backend

Le schéma suivant illustre les ressources que vous avez déployées sur les deux clusters. Étant donné que gke-west-1 est le cluster de configuration de passerelle, il s'agit du cluster dans lequel notre passerelle ainsi que nos objets HTTPRoute et nos ressources ServiceImport sont surveillés par le contrôleur de passerelle. Chaque cluster possède une ressource ServiceImport store et une autre ressource ServiceImport spécifique à ce cluster. Les deux pointent vers les mêmes pods. Cela permet au protocole HTTPRoute de spécifier exactement où le trafic doit être acheminé, vers les pods store d'un cluster spécifique ou vers les pods store de tous les clusters.

Notez qu'il s'agit d'un modèle de ressource logique, et non d'une représentation du flux de trafic. Le trafic passe directement de l'équilibreur de charge aux pods de backend et n'a pas de relation directe avec le cluster de configuration.

Valider le déploiement

Vous pouvez désormais envoyer des requêtes à notre passerelle multicluster et répartir le trafic sur les deux clusters GKE.

1. Vérifiez que les ressources Gateway et HTTPRoute ont bien été déployées en inspectant l'état et les événements de la passerelle.

   kubectl describe gateways.gateway.networking.k8s.io external-http --context gke-west-1 --namespace store
   

   La sortie obtenue devrait ressembler à ceci :

   Name:         external-http
   Namespace:    store
   Labels:       <none>
   Annotations:  networking.gke.io/addresses: /projects/PROJECT_NUMBER/global/addresses/gkemcg1-store-external-http-laup24msshu4
                 networking.gke.io/backend-services:
                   /projects/PROJECT_NUMBER/global/backendServices/gkemcg1-store-gw-serve404-80-n65xmts4xvw2, /projects/PROJECT_NUMBER/global/backendServices/gke...
                 networking.gke.io/firewalls: /projects/PROJECT_NUMBER/global/firewalls/gkemcg1-l7-default-global
                 networking.gke.io/forwarding-rules: /projects/PROJECT_NUMBER/global/forwardingRules/gkemcg1-store-external-http-a5et3e3itxsv
                 networking.gke.io/health-checks:
                   /projects/PROJECT_NUMBER/global/healthChecks/gkemcg1-store-gw-serve404-80-n65xmts4xvw2, /projects/PROJECT_NUMBER/global/healthChecks/gkemcg1-s...
                 networking.gke.io/last-reconcile-time: 2023-10-12T17:54:24Z
                 networking.gke.io/ssl-certificates:
                 networking.gke.io/target-http-proxies: /projects/PROJECT_NUMBER/global/targetHttpProxies/gkemcg1-store-external-http-94oqhkftu5yz
                 networking.gke.io/target-https-proxies:
                 networking.gke.io/url-maps: /projects/PROJECT_NUMBER/global/urlMaps/gkemcg1-store-external-http-94oqhkftu5yz
   API Version:  gateway.networking.k8s.io/v1beta1
   Kind:         Gateway
   Metadata:
     Creation Timestamp:  2023-10-12T06:59:32Z
     Finalizers:
       gateway.finalizer.networking.gke.io
     Generation:        1
     Resource Version:  467057
     UID:               1dcb188e-2917-404f-9945-5f3c2e907b4c
   Spec:
     Gateway Class Name:  gke-l7-global-external-managed-mc
     Listeners:
       Allowed Routes:
         Kinds:
           Group:  gateway.networking.k8s.io
           Kind:   HTTPRoute
         Namespaces:
           From:  Same
       Name:      http
       Port:      80
       Protocol:  HTTP
   Status:
     Addresses:
       Type:   IPAddress
       Value:  34.36.127.249
     Conditions:
       Last Transition Time:  2023-10-12T07:00:41Z
       Message:               The OSS Gateway API has deprecated this condition, do not depend on it.
       Observed Generation:   1
       Reason:                Scheduled
       Status:                True
       Type:                  Scheduled
       Last Transition Time:  2023-10-12T07:00:41Z
       Message:
       Observed Generation:   1
       Reason:                Accepted
       Status:                True
       Type:                  Accepted
       Last Transition Time:  2023-10-12T07:00:41Z
       Message:
       Observed Generation:   1
       Reason:                Programmed
       Status:                True
       Type:                  Programmed
       Last Transition Time:  2023-10-12T07:00:41Z
       Message:               The OSS Gateway API has altered the "Ready" condition semantics and reservedit for future use.  GKE Gateway will stop emitting it in a future update, use "Programmed" instead.
       Observed Generation:   1
       Reason:                Ready
       Status:                True
       Type:                  Ready
     Listeners:
       Attached Routes:  1
       Conditions:
         Last Transition Time:  2023-10-12T07:00:41Z
         Message:
         Observed Generation:   1
         Reason:                Programmed
         Status:                True
         Type:                  Programmed
         Last Transition Time:  2023-10-12T07:00:41Z
         Message:               The OSS Gateway API has altered the "Ready" condition semantics and reservedit for future use.  GKE Gateway will stop emitting it in a future update, use "Programmed" instead.
         Observed Generation:   1
         Reason:                Ready
         Status:                True
         Type:                  Ready
       Name:                    http
       Supported Kinds:
         Group:  gateway.networking.k8s.io
         Kind:   HTTPRoute
   Events:
     Type    Reason  Age                    From                   Message
     ----    ------  ----                   ----                   -------
     Normal  UPDATE  35m (x4 over 10h)      mc-gateway-controller  store/external-http
     Normal  SYNC    4m22s (x216 over 10h)  mc-gateway-controller  SYNC on store/external-http was a success
   

2. Une fois la passerelle déployée, récupérez l'adresse IP externe à partir de la passerelle external-http.

   kubectl get gateways.gateway.networking.k8s.io external-http -o=jsonpath="{.status.addresses[0].value}" --context gke-west-1 --namespace store
   

   Dans les étapes suivantes, remplacez VIP par l'adresse IP que vous recevez en sortie.

3. Envoyer le trafic vers le chemin racine du domaine. Cela a pour effet d'envoyer le trafic vers la ressource ServiceImport store, qui se trouve sur le cluster gke-west-1 et gke-east-1. L'équilibreur de charge envoie votre trafic vers la région la plus proche de vous et vous risquez de ne pas voir les réponses de l'autre région.

   curl -H "host: store.example.com" http://VIP
   

   Le résultat confirme que la requête a été diffusée par le pod à partir du cluster gke-east-1 :

   {
     "cluster_name": "gke-east-1",
     "zone": "us-east1-b",
     "host_header": "store.example.com",
     "node_name": "gke-gke-east-1-default-pool-7aa30992-t2lp.c.agmsb-k8s.internal",
     "pod_name": "store-5f5b954888-dg22z",
     "pod_name_emoji": "⏭",
     "project_id": "agmsb-k8s",
     "timestamp": "2021-06-01T17:32:51"
   }
   

4. Envoyez ensuite du trafic vers le chemin /west. Cela a pour effet d'acheminer le trafic vers la ressource ServiceImport store-west-1 qui n'a des pods en cours d'exécution que sur le cluster gke-west-1. Une ressource ServiceImport spécifique au cluster telle que store-west-1 permet à un propriétaire d'application d'envoyer explicitement du trafic vers un cluster spécifique, plutôt que de laisser l'équilibreur de charge prendre la décision.

   curl -H "host: store.example.com" http://VIP/west
   

   Le résultat confirme que la requête a été diffusée par le pod à partir du cluster gke-west-1 :

   {
     "cluster_name": "gke-west-1", 
     "zone": "us-west1-a", 
     "host_header": "store.example.com",
     "node_name": "gke-gke-west-1-default-pool-65059399-2f41.c.agmsb-k8s.internal",
     "pod_name": "store-5f5b954888-d25m5",
     "pod_name_emoji": "🍾",
     "project_id": "agmsb-k8s",
     "timestamp": "2021-06-01T17:39:15",
   }
   

5. Enfin, envoyez le trafic vers le chemin d'accès /east.

   curl -H "host: store.example.com" http://VIP/east
   

   Le résultat confirme que la requête a été diffusée par le pod à partir du cluster gke-east-1 :

   {
     "cluster_name": "gke-east-1",
     "zone": "us-east1-b",
     "host_header": "store.example.com",
     "node_name": "gke-gke-east-1-default-pool-7aa30992-7j7z.c.agmsb-k8s.internal",
     "pod_name": "store-5f5b954888-hz6mw",
     "pod_name_emoji": "🧜🏾",
     "project_id": "agmsb-k8s",
     "timestamp": "2021-06-01T17:40:48"
   }
   

Routage multicluster bleu-vert avec une passerelle

Les passerelles gke-l7-global-external-managed-*, gke-l7-regional-external-managed-* et gke-l7-rilb-* disposent de nombreuses fonctionnalités avancées de routage du trafic comme la répartition du trafic, la mise en correspondance des en-têtes, la manipulation des en-têtes, la mise en miroir du trafic, etc… Dans cet exemple, vous apprendrez à utiliser la répartition du trafic basée sur une pondération pour contrôler explicitement la proportion de trafic envoyée aux deux clusters GKE.

Cet exemple décrit certaines des étapes réelles qu'un propriétaire de service doit effectuer pour déplacer ou étendre son application vers un nouveau cluster GKE. L'objectif des déploiements bleu-vert est de réduire les risques grâce à plusieurs étapes de validation qui confirment que le nouveau cluster fonctionne correctement. Cet exemple décrit quatre étapes de déploiement :

1. 100% – Canary basé sur l'en-tête : utilisez le routage d'en-tête HTTP pour envoyer uniquement le trafic de test ou de synthèse vers le nouveau cluster.
2. 100% - Mise en miroir du trafic : mettez en miroir le trafic utilisateur vers le cluster Canary. Cela permet de tester la capacité du cluster Canary en copiant 100 % du trafic utilisateur vers ce cluster.
3. 90 %-10 %  : répartition du trafic Canary de 10 % pour exposer progressivement le nouveau cluster vers le trafic en temps réel.
4. 0 % - 100 % : basculer complète vers le nouveau cluster avec la possibilité de revenir en arrière si des erreurs sont observées.

Cet exemple est semblable au précédent mais il utilise une passerelle multicluster interne. Il consiste à déployer un équilibreur de charge d'application interne qui n'est accessible que de manière privée depuis le VPC. Vous allez utilisez les clusters et l'application déployés lors des étapes précédentes mais les déployer via une autre passerelle.

Remarque : Les mêmes configurations peuvent être appliquées aux passerelles à l'aide de ressources GatewayClass externes (gke-l7-global-external-managed-,gke-l7-regional- external-managed-, à l'exception de la ressource GatewayClass gke-l7-gxlb qui n'est pas compatible avec les fonctionnalités de gestion avancée du trafic. Pour en savoir plus sur les différentes fonctionnalités compatibles avec chaque ressource GatewayClass, consultez la page Fonctionnalités GatewayClass.

Prérequis

L'exemple suivant s'appuie sur certaines des étapes de la section Déployer une passerelle multicluster externe. Assurez-vous d'avoir suivi les étapes suivantes avant de continuer avec cet exemple :

1. Activer des passerelles multiclusters

2. Déployer une application de démonstration

   Cet exemple utilise les clusters gke-west-1 et gke-west-2 que vous avez déjà configurés. Ces clusters se trouvent dans la même région, car la ressource GatewayClass gke-l7-rilb-mc est régionale et n'accepte que les backends de cluster situés dans la même région.

3. Déployez les ressources Service et ServiceExport nécessaires sur chaque cluster. Si vous avez déployé des ressources Service et ServiceExport pour l'exemple précédent, vous avez déjà déployé certaines des ressources nécessaires.

   kubectl apply --context gke-west-1 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store-west-1-service.yaml
   kubectl apply --context gke-west-2 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store-west-2-service.yaml
   

   Cela déploie un ensemble de ressources similaire sur chaque cluster :

   service/store created
   serviceexport.net.gke.io/store created
   service/store-west-2 created
   serviceexport.net.gke.io/store-west-2 created
   

Configurer un sous-réseau proxy réservé

Si vous ne l'avez pas déjà fait, configurez un sous-réseau proxy réservé pour chaque région dans laquelle vous déployez des passerelles internes. Ce sous-réseau permet de fournir des adresses IP internes aux proxys des équilibreurs de charge et doit être configuré avec un --purpose défini sur REGIONAL_MANAGED_PROXY uniquement.

Vous devez créer un sous-réseau proxy réservé avant de créer des passerelles gérant des équilibreurs de charge d'application internes. Chaque région d'un réseau cloud privé virtuel (VPC) dans lequel vous utilisez des équilibreurs de charge d'application internes doit comporter un sous-réseau proxy réservé.

La commande gcloud compute networks subnets create crée un sous-réseau proxy réservé.

gcloud compute networks subnets create SUBNET_NAME \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=REGION \
    --network=VPC_NETWORK_NAME \
    --range=CIDR_RANGE

Remplacez les éléments suivants :

• SUBNET_NAME : nom du sous-réseau proxy réservé.
• REGION : région du sous-réseau proxy réservé.
• VPC_NETWORK_NAME : nom du réseau VPC contenant le sous-réseau.
• CIDR_RANGE : plage d'adresses IP principale du sous-réseau. Vous devez utiliser un masque de sous-réseau ne dépassant pas /26 afin qu'au moins 64 adresses IP soient disponibles pour les proxys de la région. Le masque de sous-réseau recommandé est /23.

Déployer la passerelle

La passerelle suivante est créée à partir de la GatewayClass gke-l7-rilb-mc. Il s'agit d'une passerelle interne régionale qui ne peut cibler que des clusters GKE dans la même région.

1. Appliquez le fichier manifeste Gateway suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: Gateway
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: internal-http
     namespace: store
   spec:
     gatewayClassName: gke-l7-rilb-mc
     listeners:
     - name: http
       protocol: HTTP
       port: 80
       allowedRoutes:
         kinds:
         - kind: HTTPRoute
   EOF
   

   Remarque : Le déploiement et la diffusion du trafic de la passerelle peuvent prendre plusieurs minutes (jusqu'à 10).

2. Vérifiez que la passerelle est bien opérationnelle. Vous pouvez filtrer uniquement les événements de cette passerelle en utilisant la commande suivante :

   kubectl get events --field-selector involvedObject.kind=Gateway,involvedObject.name=internal-http --context=gke-west-1 --namespace store
   

   Le déploiement de la passerelle a réussi si le résultat ressemble à ce qui suit :

   LAST SEEN   TYPE     REASON   OBJECT                  MESSAGE
   5m18s       Normal   ADD      gateway/internal-http   store/internal-http
   3m44s       Normal   UPDATE   gateway/internal-http   store/internal-http
   3m9s        Normal   SYNC     gateway/internal-http   SYNC on store/internal-http was a success
   

Canary basé sur l'en-tête

La version Canary basée sur l'en-tête permet au propriétaire du service de mettre en correspondance le trafic de test synthétique qui ne provient pas d'utilisateurs réels. Cela vous permet de vérifier facilement que le réseau de base de l'application fonctionne sans exposer directement les utilisateurs.

1. Appliquez le fichier manifeste HTTPRoute suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: internal-store-route
     namespace: store
     labels:
       gateway: internal-http
   spec:
     parentRefs:
     - kind: Gateway
       namespace: store
       name: internal-http
     hostnames:
     - "store.example.internal"
     rules:
     # Matches for env=canary and sends it to store-west-2 ServiceImport
     - matches:
       - headers:
         - name: env
           value: canary
       backendRefs:
         - group: net.gke.io
           kind: ServiceImport
           name: store-west-2
           port: 8080
     # All other traffic goes to store-west-1 ServiceImport
     - backendRefs:
       - group: net.gke.io
         kind: ServiceImport
         name: store-west-1
         port: 8080
   EOF
   

   Une fois déployé, cet objet HTTPRoute configure le comportement de routage suivant :

   • Les requêtes internes envoyées à store.example.internal sans l'en-tête HTTP env: canary sont acheminées vers les pods store sur le cluster gke-west-1.
   • Les requêtes internes envoyées à store.example.internal avec l'en-tête HTTP env: canary sont acheminées vers les pods store sur le cluster gke-west-2.

   

   Vérifiez que l'objet HTTPRoute fonctionne correctement en envoyant du trafic vers l'adresse IP de la passerelle.

2. Récupérez l'adresse IP interne de internal-http.

   kubectl get gateways.gateway.networking.k8s.io internal-http -o=jsonpath="{.status.addresses[0].value}" --context gke-west-1 --namespace store
   

   Dans les étapes suivantes, remplacez VIP par l'adresse IP que vous recevez en sortie.

   Remarque : Dans les étapes suivantes, vous allez envoyer toutes les requêtes à VIP à partir d'un client disposant d'une connectivité VPC interne et appartenant à la même région que le cluster GKE (sauf si vous avez configuré l'accès mondial sur votre passerelle). Vous pouvez créer une VM dans us-west1 et vous y connecter en SSH à cette fin. Cela est nécessaire, car la passerelle internal-http est un équilibreur de charge interne régional. Définissez également store.example.internal dans l'en-tête d'hôte afin que le DNS n'ait pas besoin d'être configuré pour que cet exemple fonctionne.

3. Envoyez une requête à la passerelle en utilisant l'en-tête HTTP env: canary. Cela confirme que le trafic est acheminé vers gke-west-2. Utilisez un client privé dans le même VPC que les clusters GKE afin de vérifier que les requêtes sont correctement acheminées. La commande suivante doit être exécutée sur une machine disposant d'un accès privé à l'adresse IP de la passerelle, sans quoi elle ne fonctionnera pas.

   curl -H "host: store.example.internal" -H "env: canary" http://VIP
   

   Le résultat confirme que la requête a été diffusée par un pod à partir du cluster gke-west-2 :

   {
       "cluster_name": "gke-west-2", 
       "host_header": "store.example.internal",
       "node_name": "gke-gke-west-2-default-pool-4cde1f72-m82p.c.agmsb-k8s.internal",
       "pod_name": "store-5f5b954888-9kdb5",
       "pod_name_emoji": "😂",
       "project_id": "agmsb-k8s",
       "timestamp": "2021-05-31T01:21:55",
       "zone": "us-west1-a"
   }
   

Mise en miroir du trafic

Cette étape envoie le trafic vers le cluster prévu, mais met également en miroir ce trafic vers le cluster Canary.

La mise en miroir permet de déterminer l'impact de la charge de trafic sur les performances de l'application, sans aucun impact sur les réponses fournies à vos clients. Elle n'est pas nécessaire pour tous les types de déploiements, mais elle peut être utile lors du déploiement de modifications importantes susceptibles d'affecter les performances ou la charge.

1. Appliquez le fichier manifeste HTTPRoute suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: internal-store-route
     namespace: store
     labels:
       gateway: internal-http
   spec:
     parentRefs:
     - kind: Gateway
       namespace: store
       name: internal-http
     hostnames:
     - "store.example.internal"
     rules:
     # Sends all traffic to store-west-1 ServiceImport
     - backendRefs:
       - name: store-west-1
         group: net.gke.io
         kind: ServiceImport
         port: 8080
       # Also mirrors all traffic to store-west-2 ServiceImport
       filters:
       - type: RequestMirror
         requestMirror:
           backendRef:
             group: net.gke.io
             kind: ServiceImport
             name: store-west-2
             port: 8080
   EOF
   

2. À l'aide de votre client privé, envoyez une requête à la passerelle internal-http. Utilisez le chemin /mirror pour identifier de manière unique cette requête dans les journaux d'application lors d'une prochaine étape.

   curl -H "host: store.example.internal" http://VIP/mirror
   

3. Le résultat confirme que le client a reçu une réponse d'un pod du cluster gke-west-1 :

   {
       "cluster_name": "gke-west-1", 
       "host_header": "store.example.internal",
       "node_name": "gke-gke-west-1-default-pool-65059399-ssfq.c.agmsb-k8s.internal",
       "pod_name": "store-5f5b954888-brg5w",
       "pod_name_emoji": "🎖",
       "project_id": "agmsb-k8s",
       "timestamp": "2021-05-31T01:24:51",
       "zone": "us-west1-a"
   }
   

   Cela confirme que le cluster principal répond bien au trafic. Vous devez toujours vérifier que le cluster vers lequel vous effectuez la migration reçoit le trafic mis en miroir.

4. Vérifiez les journaux d'application d'un pod store sur le cluster gke-west-2. Les journaux doivent confirmer que le pod a bien reçu le trafic mis en miroir de l'équilibreur de charge.

   kubectl logs deployment/store --context gke-west-2 -n store | grep /mirror
   

5. Ce résultat confirme que les pods du cluster gke-west-2 reçoivent également les mêmes requêtes, mais que leurs réponses à ces requêtes ne sont pas renvoyées au client. Les adresses IP affichées dans les journaux sont les adresses IP internes de l'équilibreur de charge interne qui communique avec vos pods.

   Found 2 pods, using pod/store-5c65bdf74f-vpqbs
   [2023-10-12 21:05:20,805] INFO in _internal: 192.168.21.3 - - [12/Oct/2023 21:05:20] "GET /mirror HTTP/1.1" 200 -
   [2023-10-12 21:05:27,158] INFO in _internal: 192.168.21.3 - - [12/Oct/2023 21:05:27] "GET /mirror HTTP/1.1" 200 -
   [2023-10-12 21:05:27,805] INFO in _internal: 192.168.21.3 - - [12/Oct/2023 21:05:27] "GET /mirror HTTP/1.1" 200 -
   

Traffic split

La répartition du trafic est l'une des méthodes les plus courantes pour déployer du nouveau code ou effectuer des déploiements en toute sécurité dans de nouveaux environnements. Le propriétaire du service définit un pourcentage explicite de trafic envoyé aux backends Canary, généralement une petite partie du trafic global, afin de déterminer la réussite du déploiement avec une quantité acceptable de risque pour les requêtes réelles des utilisateurs.

Une répartition du trafic avec une petite partie du trafic permet au propriétaire du service d'inspecter l'état de l'application et des réponses. Si tous les signaux semblent opérationnels, il est possible de passer au basculement complet.

1. Appliquez le fichier manifeste HTTPRoute suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: internal-store-route
     namespace: store
     labels:
       gateway: internal-http
   spec:
     parentRefs:
     - kind: Gateway
       namespace: store
       name: internal-http
     hostnames:
     - "store.example.internal"
     rules:
     - backendRefs:
       # 90% of traffic to store-west-1 ServiceImport
       - name: store-west-1
         group: net.gke.io
         kind: ServiceImport
         port: 8080
         weight: 90
       # 10% of traffic to store-west-2 ServiceImport
       - name: store-west-2
         group: net.gke.io
         kind: ServiceImport
         port: 8080
         weight: 10
   EOF
   

2. À l'aide de votre client privé, envoyez une requête curl continue à la passerelle internal- http.

   while true; do curl -H "host: store.example.internal" -s VIP | grep "cluster_name"; sleep 1; done
   

   Le résultat sera semblable à ceci, indiquant qu'une répartition du trafic de 90/10 est appliquée.

   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-2",
   "cluster_name": "gke-west-1",
   "cluster_name": "gke-west-1",
   ...
   

Basculement du trafic

La dernière étape de la migration bleu-vert consiste à basculer entièrement vers le nouveau cluster et à supprimer l'ancien cluster. Si le propriétaire du service était en train d'intégrer un deuxième cluster à un cluster existant, cette dernière étape serait différente, car elle consisterait à répartir le trafic entre les deux clusters. Dans ce scénario, il est recommandé d'utiliser une seule ressource ServiceImport store comportant des pods provenant des clusters gke-west-1 et gke-west-2. Cela permet à l'équilibreur de charge de prendre la décision d'acheminement du trafic pour une application en mode actif/actif, en se basant sur la proximité, l'état et la capacité.

1. Appliquez le fichier manifeste HTTPRoute suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: internal-store-route
     namespace: store
     labels:
       gateway: internal-http
   spec:
     parentRefs:
     - kind: Gateway
       namespace: store
       name: internal-http
     hostnames:
     - "store.example.internal"
     rules:
       - backendRefs:
         # No traffic to the store-west-1 ServiceImport
         - name: store-west-1
           group: net.gke.io
           kind: ServiceImport
           port: 8080
           weight: 0
         # All traffic to the store-west-2 ServiceImport
         - name: store-west-2
           group: net.gke.io
           kind: ServiceImport
           port: 8080
           weight: 100
   EOF
   

2. À l'aide de votre client privé, envoyez une requête curl continue à la passerelle internal- http.

   while true; do curl -H "host: store.example.internal" -s VIP | grep "cluster_name"; sleep 1; done
   

   Le résultat sera semblable à ceci, indiquant que tout le trafic est maintenant dirigé vers gke-west-2.

   "cluster_name": "gke-west-2",
   "cluster_name": "gke-west-2",
   "cluster_name": "gke-west-2",
   "cluster_name": "gke-west-2",
   ...
   

Cette dernière étape vient clôturer le processus de migration bleu-vert complet d'une application, d'un cluster GKE vers un autre cluster GKE.

Déployer un équilibrage de charge basé sur la capacité

L'exercice de cette section illustre les concepts mondiaux d'équilibrage de charge et de capacité de service, en déployant une application sur deux clusters GKE dans différentes régions. Le trafic généré est envoyé à différents niveaux de requête par seconde (RPS) pour montrer comment le trafic est équilibré entre les clusters et les régions.

Le schéma suivant illustre la topologie que vous allez déployer et la manière dont le trafic déborde entre les clusters et les régions lorsque le trafic a dépassé la capacité de service :

Pour en savoir plus sur la gestion du trafic, consultez la page Gestion du trafic GKE.

Préparer votre environnement

1. Pour préparer votre environnement, suivez les instructions de la section Activer les passerelles multiclusters.

2. Vérifiez que les ressources GatewayClass sont installées sur le cluster de configuration :

   kubectl get gatewayclasses --context=gke-west-1
   

   Le résultat ressemble à ce qui suit :

   NAME                                  CONTROLLER                  ACCEPTED   AGE
   gke-l7-global-external-managed        networking.gke.io/gateway   True       16h
   gke-l7-global-external-managed-mc     networking.gke.io/gateway   True       14h
   gke-l7-gxlb                           networking.gke.io/gateway   True       16h
   gke-l7-gxlb-mc                        networking.gke.io/gateway   True       14h
   gke-l7-regional-external-managed      networking.gke.io/gateway   True       16h
   gke-l7-regional-external-managed-mc   networking.gke.io/gateway   True       14h
   gke-l7-rilb                           networking.gke.io/gateway   True       16h
   gke-l7-rilb-mc                        networking.gke.io/gateway   True       14h
   

Déployer une application

Déployez l'exemple de serveur d'applications Web sur les deux clusters :

kubectl apply --context gke-west-1 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/master/gateway/docs/store-traffic-deploy.yaml
kubectl apply --context gke-east-1 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/master/gateway/docs/store-traffic-deploy.yaml

Le résultat ressemble à ce qui suit :

namespace/store created
deployment.apps/store created

Déployer un service, une passerelle et une route HTTP

1. Appliquez le fichier manifeste Service suivant aux clusters gke-west-1 et gke-east-1 :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   apiVersion: v1
   kind: Service
   metadata:
     name: store
     namespace: traffic-test
     annotations:
       networking.gke.io/max-rate-per-endpoint: "10"
   spec:
     ports:
     - port: 8080
       targetPort: 8080
       name: http
     selector:
       app: store
     type: ClusterIP
   ---
   kind: ServiceExport
   apiVersion: net.gke.io/v1
   metadata:
     name: store
     namespace: traffic-test
   EOF
   

   cat << EOF | kubectl apply --context gke-east-1 -f -
   apiVersion: v1
   kind: Service
   metadata:
     name: store
     namespace: traffic-test
     annotations:
       networking.gke.io/max-rate-per-endpoint: "10"
   spec:
     ports:
     - port: 8080
       targetPort: 8080
       name: http
     selector:
       app: store
     type: ClusterIP
   ---
   kind: ServiceExport
   apiVersion: net.gke.io/v1
   metadata:
     name: store
     namespace: traffic-test
   EOF
   

   Le service est annoté avec max-rate-per-endpoint défini sur 10 requêtes par seconde. Avec deux instances dupliquées par cluster, chaque service dispose d'une capacité de 20 RPS par cluster.

   Pour plus d'informations sur le choix d'un niveau de capacité de service pour votre service, consultez la section Déterminer la capacité de votre service.

2. Appliquez le fichier manifeste Gateway suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: Gateway
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: store
     namespace: traffic-test
   spec:
     gatewayClassName: gke-l7-global-external-managed-mc
     listeners:
     - name: http
       protocol: HTTP
       port: 80
       allowedRoutes:
         kinds:
         - kind: HTTPRoute
   EOF
   

   Le fichier manifeste décrit une passerelle multicluster globale externe, qui déploie un équilibreur de charge d'application externe avec une adresse IP accessible publiquement.

3. Appliquez le fichier manifeste HTTPRoute suivant au cluster de configuration, gke-west-1 dans cet exemple :

   cat << EOF | kubectl apply --context gke-west-1 -f -
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: store
     namespace: traffic-test
     labels:
       gateway: store
   spec:
     parentRefs:
     - kind: Gateway
       namespace: traffic-test
       name: store
     rules:
     - backendRefs:
       - name: store
         group: net.gke.io
         kind: ServiceImport
         port: 8080
   EOF
   

   Le fichier manifeste décrit une HTTPRoute qui configure la passerelle avec une règle de routage qui dirige tout le trafic vers la ressource ServiceImport du magasin. La ressource ServiceImport store regroupe les pods de service store sur les deux clusters et permet à l'équilibreur de charge de les traiter comme un service unique.

   Remarque : Le déploiement et la diffusion du trafic de la passerelle peuvent prendre plusieurs minutes (jusqu'à 10).

   Vous pouvez vérifier les événements de la passerelle après quelques minutes pour voir si le déploiement est terminé :

   kubectl describe gateway store -n traffic-test --context gke-west-1
   

   Le résultat ressemble à ce qui suit :

   ...
   Status:
     Addresses:
       Type:   IPAddress
       Value:  34.102.159.147
     Conditions:
       Last Transition Time:  2023-10-12T21:40:59Z
       Message:               The OSS Gateway API has deprecated this condition, do not depend on it.
       Observed Generation:   1
       Reason:                Scheduled
       Status:                True
       Type:                  Scheduled
       Last Transition Time:  2023-10-12T21:40:59Z
       Message:
       Observed Generation:   1
       Reason:                Accepted
       Status:                True
       Type:                  Accepted
       Last Transition Time:  2023-10-12T21:40:59Z
       Message:
       Observed Generation:   1
       Reason:                Programmed
       Status:                True
       Type:                  Programmed
       Last Transition Time:  2023-10-12T21:40:59Z
       Message:               The OSS Gateway API has altered the "Ready" condition semantics and reservedit for future use.  GKE Gateway will stop emitting it in a future update, use "Programmed" instead.
       Observed Generation:   1
       Reason:                Ready
       Status:                True
       Type:                  Ready
     Listeners:
       Attached Routes:  1
       Conditions:
         Last Transition Time:  2023-10-12T21:40:59Z
         Message:
         Observed Generation:   1
         Reason:                Programmed
         Status:                True
         Type:                  Programmed
         Last Transition Time:  2023-10-12T21:40:59Z
         Message:               The OSS Gateway API has altered the "Ready" condition semantics and reservedit for future use.  GKE Gateway will stop emitting it in a future update, use "Programmed" instead.
         Observed Generation:   1
         Reason:                Ready
         Status:                True
         Type:                  Ready
       Name:                    http
       Supported Kinds:
         Group:  gateway.networking.k8s.io
         Kind:   HTTPRoute
   Events:
     Type    Reason  Age                  From                   Message
     ----    ------  ----                 ----                   -------
     Normal  ADD     12m                  mc-gateway-controller  traffic-test/store
     Normal  SYNC    6m43s                mc-gateway-controller  traffic-test/store
     Normal  UPDATE  5m40s (x4 over 12m)  mc-gateway-controller  traffic-test/store
     Normal  SYNC    118s (x6 over 10m)   mc-gateway-controller  SYNC on traffic-test/store was a success
   

   Ce résultat indique que la passerelle a été déployée avec succès. Le déploiement du trafic peut prendre quelques minutes après le déploiement de la passerelle. Notez l'adresse IP dans ce résultat, car elle est utilisée dans une étape suivante.

Confirmer le trafic

Vérifiez que le trafic est transmis à l'application en testant l'adresse IP de la passerelle à l'aide d'une commande curl :

curl GATEWAY_IP_ADDRESS

Le résultat ressemble à ce qui suit :

{
  "cluster_name": "gke-west-1",
  "host_header": "34.117.182.69",
  "pod_name": "store-54785664b5-mxstv",
  "pod_name_emoji": "👳🏿",
  "project_id": "project",
  "timestamp": "2021-11-01T14:06:38",
  "zone": "us-west1-a"
}

Ce résultat affiche les métadonnées du pod, qui indiquent la région depuis laquelle la requête a été diffusée.

Vérifier le trafic à l'aide de tests de charge

Pour vérifier que l'équilibreur de charge fonctionne, vous pouvez déployer un générateur de trafic dans votre cluster gke-west-1. Le générateur de trafic génère du trafic à différents niveaux de charge pour illustrer la capacité et le débordement de l'équilibreur de charge. Les trois niveaux de charge suivants sont présentés :

• 10 RPS, ce qui est inférieur à la capacité du service de magasin dans gke-west-1
• 30 RPS, ce qui est une surcapacité pour le service de magasin gke-west-1 et entraîne un débordement du trafic vers gke-east-1.
• 60 RPS, ce qui correspond à la surcapacité des services dans les deux clusters.

Configurer le tableau de bord

1. Récupérez le nom du mappage d'URL sous-jacent de votre passerelle :

   kubectl get gateway store -n traffic-test --context=gke-west-1 -o=jsonpath="{.metadata.annotations.networking\.gke\.io/url-maps}"
   

   Le résultat ressemble à ce qui suit :

   /projects/PROJECT_NUMBER/global/urlMaps/gkemcg1-traffic-test-store-armvfyupay1t
   

2. Dans Google Cloud Console, accédez à la page Explorateur de métriques.

   Accéder à l'explorateur de métriques

3. Sous Sélectionner une métrique, cliquez sur CODE: MQL.

4. Saisissez la requête suivante pour observer les métriques de trafic du service de magasin sur vos deux clusters :

   fetch https_lb_rule
   | metric 'loadbalancing.googleapis.com/https/backend_request_count'
   | filter (resource.url_map_name == 'GATEWAY_URL_MAP')
   | align rate(1m)
   | every 1m
   | group_by [resource.backend_scope],
       [value_backend_request_count_aggregate:
           aggregate(value.backend_request_count)]
   

   Remplacez GATEWAY_URL_MAP par le nom de mappage d'URL de l'étape précédente.

5. Cliquez sur Run query. Attendez au moins cinq minutes après le déploiement du générateur de charge dans la section suivante pour que les métriques s'affichent dans le graphique.

Test avec 10 RPS

1. Déployez un pod sur votre cluster gke-west-1 :

   kubectl run --context gke-west-1 -i --tty --rm loadgen  \
       --image=cyrilbkr/httperf  \
       --restart=Never  \
       -- /bin/sh -c 'httperf  \
       --server=GATEWAY_IP_ADDRESS  \
       --hog --uri="/zone" --port 80  --wsess=100000,1,1 --rate 10'
   

   Remplacez GATEWAY_IP_ADDRESS par l'adresse IP de la passerelle de l'étape précédente.

   Le résultat ressemble à ce qui suit, indiquant que le générateur de trafic envoie du trafic :

   If you don't see a command prompt, try pressing enter.
   

   Le générateur de charge envoie en continu 10 RPS à la passerelle. Même si le trafic provient de la région Google Cloud, il est considéré comme du trafic client provenant de la côte ouest des États-Unis par l'équilibreur de charge. Pour simuler une diversité de client réaliste, le générateur de charge envoie chaque requête HTTP en tant que nouvelle connexion TCP, ce qui signifie que le trafic est réparti plus uniformément entre les pods de backend.

   Le générateur prend jusqu'à 5 minutes pour générer du trafic pour le tableau de bord.

2. Afficher le tableau de bord de l'explorateur de métriques Deux lignes apparaissent, indiquant la quantité de charge de trafic équilibrée pour chacun des clusters :

   

   Vous devriez constater que us-west1-a reçoit environ 10 RPS de trafic, tandis que us-east1-b ne reçoit aucun trafic. Comme le générateur de trafic s'exécute dans la région us-west1, tout le trafic est envoyé au service dans le cluster gke-west-1.

3. Arrêtez le générateur de charge à l'aide du raccourci Ctrl+C, puis supprimez le pod :

   kubectl delete pod loadgen --context gke-west-1
   

Test avec 30 RPS

1. Déployez à nouveau le générateur de charge, mais configuré pour envoyer 30 RPS :

   kubectl run --context gke-west-1 -i --tty --rm loadgen  \
       --image=cyrilbkr/httperf  \
       --restart=Never  \
       -- /bin/sh -c 'httperf  \
       --server=GATEWAY_IP_ADDRESS  \
       --hog --uri="/zone" --port 80  --wsess=100000,1,1 --rate 30'
   

   Le générateur prend jusqu'à 5 minutes pour générer du trafic pour le tableau de bord.

2. Affichez votre tableau de bord Cloud Ops.

   

   Vous devriez constater qu'environ 20 RPS sont envoyées à us-west1-a et 10 RPS à us-east1-b. Cela indique que le service de gke-west-1 est pleinement utilisé et qu'il fait déborder 10 RPS du trafic vers le service dans gke-east-1.

3. Arrêtez le générateur de charge à l'aide du raccourci Ctrl+C, puis supprimez le pod :

   kubectl delete pod loadgen --context gke-west-1
   

Test avec 60 RPS

1. Déployez le générateur de charge configuré pour envoyer 60 RPS :

   kubectl run --context gke-west-1 -i --tty --rm loadgen  \
       --image=cyrilbkr/httperf  \
       --restart=Never  \
       -- /bin/sh -c 'httperf  \
       --server=GATEWAY_IP_ADDRESS  \
       --hog --uri="/zone" --port 80  --wsess=100000,1,1 --rate 60'
   

2. Attendez cinq minutes, puis affichez votre tableau de bord Cloud Ops. Vous devriez maintenant voir que les deux clusters reçoivent environ 30 RPS. Étant donné que tous les services sont surexploités à l'échelle mondiale, le trafic n'est pas en débordement et les services absorbent tout le trafic possible.

   

3. Arrêtez le générateur de charge à l'aide du raccourci Ctrl+C, puis supprimez le pod :

   kubectl delete pod loadgen --context gke-west-1
   

Effectuer un nettoyage

Après avoir terminé les exercices de cette page, procédez comme suit pour supprimer les ressources afin d'éviter que des frais inutiles ne vous soient facturés sur votre compte :

1. Supprimer les clusters

2. Annulez l'enregistrement de vos clusters dans le parc s'ils n'ont pas besoin d'être enregistrés à d'autres fins.

3. Désactivez la fonctionnalité multiclusterservicediscovery :

   gcloud container fleet multi-cluster-services disable
   

4. Désactiver un objet Ingess multicluster

   gcloud container fleet ingress disable
   

5. Désactivez les API :

   gcloud services disable \
       multiclusterservicediscovery.googleapis.com \
       multiclusteringress.googleapis.com \
       trafficdirector.googleapis.com \
       --project=PROJECT_ID
   

Utiliser une passerelle multicluster avec un VPC partagé

Une passerelle multicluster peut également être déployée dans un environnement VPC partagé, avec différentes topologies, en fonction du cas d'utilisation.

Le tableau suivant décrit les topologies de passerelles multiclusters compatibles avec un environnement VPC partagé :

Scénario	Projet hôte du parc	Cluster de configuration	Clusters de charge de travail
1	Projet hôte de VPC partagé	Projet hôte de VPC partagé	Projet hôte de VPC partagé
2	Projet de service VPC partagé	Projet de service de VPC partagé (identique à celui de service de parc)	Projet de service de VPC partagé (identique à celui de service de parc)

Remarque : Les services multiclusters peuvent être déployés dans différents scénarios avec une combinaison de projets hôtes de VPC partagé et de projets de service. La passerelle multicluster n'est pas compatible avec toutes les topologies et exige que tous les clusters soient créés dans le même projet hôte de VPC partagé ou projet de service.

Pour créer des passerelles multiclusters dans un environnement VPC partagé, procédez comme suit :

1. Suivez la procédure pour configurer vos services multiclusters avec un VPC partagé.

2. Créez vos services et exportez-les vers le cluster de configuration.

3. Si vous prévoyez d'utiliser une passerelle interne multicluster, créez un sous-réseau proxy réservé.

4. Créez vos ressources Gateway multiclusters et HTTPRoute externes ou internes

Une fois ces étapes terminées, vous pouvez valider votre déploiement en fonction de votre topologie.

Dépannage

Le sous-réseau proxy réservé destiné à la passerelle interne n'existe pas

Si l'événement suivant apparaît sur votre passerelle interne, il n'existe pas de sous-réseau proxy réservé pour cette région. Pour résoudre ce problème, déployez un sous-réseau proxy réservé.

generic::invalid_argument: error ensuring load balancer: Insert: Invalid value for field 'resource.target': 'regions/us-west1/targetHttpProxies/gkegw-x5vt-default-internal-http-2jzr7e3xclhj'. A reserved and active subnetwork is required in the same region and VPC as the forwarding rule.

Étapes suivantes

• En savoir plus sur le contrôleur Gateway