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 de GKE Gateway Controller :
- 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 détenus et gérés par des équipes distinctes, et sont déployés sur un parc de clusters GKE partagés. 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 :
Déployez des clusters GKE
Enregistrez vos clusters dans un parc.
Activez les contrôleurs de service et de passerelle multiclusters.
Enfin, consultez la section Limites et problèmes connus de GKE Gateway Controller 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 :
- déployer l'exemple d'application
store
sur les clustersgke-west-1
etgke-east-1
; - Configurer les services sur chaque cluster à exporter dans votre parc (services multiclusters).
- 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 podsstore
dans le clustergke-west-1
. - Les requêtes adressées à
/east
sont acheminées vers des podsstore
dans le clustergke-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
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
etgke-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 ServiceExports 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.
Appliquez le fichier manifeste suivant au cluster
gke-west-1
pour créer vos ressourcesstore
etstore-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
Appliquez le fichier manifeste suivant au cluster
gke-east-1
pour créer vos ressourcesstore
etstore-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
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
etgke-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 podsstore
sur les deux clusters, tandis que les servicesstore-west-1
etstore-east-1
ne contiennent que des podsstore
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.Après quelques minutes, vérifiez que les ressources
ServiceImports
associées ont bien été créées automatiquement par le contrôleur de services multicluster sur l'ensemble des clusters du parc.kubectl get serviceimports --context CLUSTER_NAME --namespace store
Remplacez CLUSTER_NAME par
gke-west-1
etgke-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.
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.
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
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
- Service de backend 404 par défaut :
- 1 vérification d'état :
- Vérification d'état 404 par défaut :
gkemcg1-store-gw-serve404-HASH
- Vérification d'état 404 par défaut :
- 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
.- 1 équilibreur de charge :
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 podsstore
dans le clustergke-west-1
, car les pods sélectionnés par le ServiceExportstore-west-1
n'existent que dans le clustergke-west-1
. - Les requêtes adressées à
/east
sont acheminées vers des podsstore
dans le clustergke-east-1
, car les pods sélectionnés par le ServiceExportstore-east-1
n'existent que dans le clustergke-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 podsstore
. 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 podsstore
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
- Le service de backend
- 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
- La vérification d'état
- 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
- La règle de routage
- Les requêtes adressées à
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 qui sert de 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.
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
Vous devriez obtenir un résultat semblable à celui-ci :
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
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.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 clustergke-west-1
etgke-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" }
Envoyez ensuite du trafic vers le chemin
/west
. Cela a pour effet d'acheminer le trafic vers la ressource ServiceImportstore-west-1
qui n'a des pods en cours d'exécution que sur le clustergke-west-1
. Une ressource ServiceImport spécifique au cluster telle questore-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", }
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 ressources GatewayClass 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 allez apprendre à utiliser la répartition du trafic basée sur une pondération pour contrôler explicitement la proportion de trafic envoyée à 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 :
- 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.
- 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.
- 90 %-10 % : répartition du trafic Canary de 10 % pour exposer progressivement le nouveau cluster vers le trafic en temps réel.
- 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.
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 :
Déployer une application de démonstration
Cet exemple utilise les clusters
gke-west-1
etgke-west-2
que vous avez déjà configurés. Ces clusters se trouvent dans la même région, car la ressource GatewayClassgke-l7-rilb-mc
est régionale et n'accepte que les backends de cluster situés dans la même région.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.
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
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.
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 HTTPenv: canary
sont acheminées vers les podsstore
sur le clustergke-west-1
. - Les requêtes internes envoyées à
store.example.internal
avec l'en-tête HTTPenv: canary
sont acheminées vers les podsstore
sur le clustergke-west-2
.
Vérifiez que l'objet HTTPRoute fonctionne correctement en envoyant du trafic vers l'adresse IP de la passerelle.
- Les requêtes internes envoyées à
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.
Envoyez une requête à la passerelle en utilisant l'en-tête HTTP
env: canary
. Cela confirme que le trafic est acheminé versgke-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.
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
À 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
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.
Vérifiez les journaux d'application d'un pod
store
sur le clustergke-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
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.
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
À 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é.
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
À 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
Pour préparer votre environnement, suivez les instructions de la section Activer les passerelles multiclusters.
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
Appliquez le fichier manifeste
Service
suivant aux clustersgke-west-1
etgke-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.
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.
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 servicestore
sur les deux clusters et permet à l'équilibreur de charge de les traiter comme un service unique.Au bout de quelques minutes, vous pouvez vérifier les événements de la passerelle, afin de 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 versgke-east-1
. - 60 RPS, ce qui correspond à la surcapacité des services dans les deux clusters.
Configurer le tableau de bord
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
Dans Google Cloud Console, accédez à la page Explorateur de métriques.
Sous Sélectionner une métrique, cliquez sur CODE: MQL.
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.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
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.
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 queus-east1-b
ne reçoit aucun trafic. Comme le générateur de trafic s'exécute dans la régionus-west1
, tout le trafic est envoyé au service dans le clustergke-west-1
.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
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.
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 degke-west-1
est pleinement utilisé et qu'il fait déborder 10 RPS du trafic vers le service dansgke-east-1
.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
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'
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.
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 :
Annulez l'enregistrement de vos clusters dans le parc s'ils n'ont pas besoin d'être enregistrés à d'autres fins.
Désactivez la fonctionnalité
multiclusterservicediscovery
:gcloud container fleet multi-cluster-services disable
Désactiver un objet Ingess multicluster
gcloud container fleet ingress disable
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) |
Pour créer des passerelles multiclusters dans un environnement VPC partagé, procédez comme suit :
Suivez la procédure pour configurer vos services multiclusters avec un VPC partagé.
Créez vos services et exportez-les vers le cluster de configuration.
Si vous prévoyez d'utiliser une passerelle interne multicluster, créez un sous-réseau proxy réservé.
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.
Aucun élément opérationnel en amont
Symptôme :
Le problème suivant peut se produire lorsque vous créez une passerelle, mais que vous ne pouvez pas accéder aux services de backend (code de réponse 503) :
no healthy upstream
Explication :
Ce message d'erreur indique que le vérificateur d'état ne parvient pas à trouver des services de backend opérationnels. Il est possible que vos services de backend soient opérationnels, mais que vous deviez personnaliser les vérifications d'état.
Solution :
Pour résoudre ce problème, personnalisez votre vérification d'état en fonction des exigences de votre application (par exemple, /health
), à l'aide d'une ressource HealthCheckPolicy
.
Étapes suivantes
- En savoir plus sur le contrôleur Gateway