Personnaliser le trafic GKE Gateway à l'aide des extensions de service

Cette page explique comment Google Kubernetes Engine (GKE) utilise les extensions de service pour ajouter une logique personnalisée à l'Cloud Load Balancing.

Cette page est destinée aux administrateurs de comptes et d'identité GKE, ainsi qu'aux développeurs qui doivent configurer une logique de gestion du trafic personnalisée à l'aide d'extensions de service.

Avant de lire cette page, assurez-vous de connaître les éléments suivants:

Présentation

GKE utilise les extensions de service pour ajouter une logique personnalisée à Cloud Load Balancing. Une extension se joint à un Gateway et fait référence à un Service ou à un GoogleAPIServiceName. GoogleAPIServiceName n'est compatible qu'avec GCPTrafficExtensions.

Vous pouvez modifier les en-têtes et les charges utiles HTTP pour les requêtes et les réponses, ou contrôler le routage du trafic, sans affecter la sélection des service de backend ni les règles de sécurité. Vous pouvez utiliser les extensions de service pour des tâches telles que la répartition du trafic avancée, l'authentification personnalisée ou la journalisation des requêtes.

GKE Gateway Controller est compatible avec les extensions de service suivantes:

  • GCPRoutingExtension: cette extension ajoute une logique personnalisée à Cloud Load Balancing pour contrôler le routage du trafic. Il est compatible avec les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux.

    La ressource "GCPRoutingExtension" est associée à une passerelle et fait référence à un service. L'extension contrôle le routage du trafic.
    Figure: Fonctionnement de GCPRoutingExtension avec les passerelles

  • GCPTrafficExtension: cette extension insère une logique personnalisée dans Cloud Load Balancing. Il permet à un service d'extension de modifier les en-têtes et les charges utiles des requêtes et des réponses. GCPTrafficExtension n'a aucune incidence sur la sélection du service de backend ni sur les stratégies de sécurité du service de backend.

    La ressource "GCPTrafficExtension" est associée à une passerelle et fait référence à un service ou à un "GoogleAPIServiceName". L'extension modifie les en-têtes et les charges utiles des requêtes et des réponses.
    Figure: Fonctionnement de GCPTrafficExtension avec les passerelles

Google Cloud Compatibilité des extensions de service avec GatewayClasses

Le tableau suivant décrit la compatibilité des extensions de service Google Cloud avec différentes GatewayClasses:

GatewayClass GCPRoutingExtension GCPTrafficExtension
gke-l7-rilb Compatible Compatible
gke-l7-regional-external-managed Compatible Compatible
gke-l7-global-external-managed Non compatible Compatible

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Kubernetes Engine.
    • Activer l'API Google Kubernetes Engine
  • Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.

Conditions requises pour le contrôleur GKE Gateway

Restrictions et limitations

Le tableau suivant répertorie les restrictions associées à la configuration des extensions de service de passerelle dans GKE:

Catégorie Restrictions et limitations
Équilibreur de charge GCPRoutingExtension n'est compatible qu'avec les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux (classes de passerelles gke-l7-regional-external-managed et gke-l7-rilb) et n'est pas compatible avec la classe de passerelle gke-l7-global-external-managed.
Chaîne et spécification d'extension
  • Pour une GCPTrafficExtension, chaque ExtensionChain peut comporter un maximum de trois Extensions.
  • Pour un GCPRoutingExtension, chaque ExtensionChain est limité à un seul Extension.
  • Un GCPTrafficExtensionSpec et un GCPRoutingExtensionSpec peuvent chacun comporter jusqu'à cinq ExtensionChains.
Timing et mise en correspondance
  • Le délai avant expiration de chaque message individuel du flux dans une extension doit être compris entre 10 et 1 000 millisecondes. Cette limite d'une seconde s'applique aux extensions de route et de trafic.
  • Chaque MatchCondition d'un ExtensionChain est limité à 10 CELExpressions maximum.
  • La chaîne MatchCondition générée et envoyée à la GCE est limitée à 512 caractères.
  • La chaîne CELMatcher d'un CELExpression peut comporter jusqu'à 512 caractères et doit respecter un format spécifique. Le champ BackendRefs à partir de CELExpression n'est pas compatible.
En-tête et métadonnées
  • La liste ForwardHeaders d'un Extension peut contenir jusqu'à 50 noms d'en-tête HTTP.
  • La carte Metadata d'une Extension peut contenir au maximum 16 propriétés.
  • Les clés de la carte Metadata doivent comporter entre 1 et 63 caractères.
  • Les valeurs de la mappe Metadata doivent comporter entre 1 et 1 023 caractères.
Événement
  • Pour un GCPRoutingExtension, si requestBodySendMode n'est pas défini, la liste supportedEvents ne peut contenir que des événements RequestHeaders.
  • Pour un GCPRoutingExtension, si requestBodySendMode est défini sur FullDuplexStreamed, la liste supportedEvents ne peut contenir que des événements RequestHeaders, RequestBody et RequestTrailers.
GCPTrafficExtension
  • Le champ responseBodySendMode n'est compatible qu'avec GCPTrafficExtension.
  • Le champ googleAPIServiceName n'est compatible qu'avec GCPTrafficExtension.
googleAPIServiceName et backendRef Lorsque vous référencez un service qui utilise backendRef dans une extension, vous devez remplir les conditions suivantes :
  • Doit utiliser HTTP2 comme appProtocol.
  • Doit se trouver dans le même espace de noms que l'extension et la passerelle référencée par l'extension.
  • Impossible d'utiliser IAP.
  • Impossible d'utiliser les règles de sécurité Google Cloud Armor (champ securityPolicy de GCPBackendPolicyConfig.
  • Vous ne pouvez pas utiliser Cloud CDN.
  • Vous devez définir exactement un seul élément backendRef ou googleAPIServiceName pour un Extension.
  • Vous devez définir authority si backendRef est défini.
  • Vous devez définir authority si googleAPIServiceName est défini.
  • Configurez requestBodySendMode pour les extensions à l'aide de backendRef uniquement.
  • Configurez responseBodySendMode pour les extensions à l'aide de backendRef uniquement.

Configurer les extensions de service GKE

Vous pouvez personnaliser le routage du trafic, modifier les charges utiles de requête ou de réponse, et intégrer des services externes en configurant des extensions de service GKE. Les passerelles ne disposent pas d'extensions de service par défaut.

Pour configurer les extensions de service GKE:

  1. Déployer une passerelle: pour configurer une extension de service GKE, vous devez d'abord déployer une passerelle, qui dirige le trafic externe vers votre cluster. Il peut s'agir d'un équilibreur de charge d'application externe global, d'un équilibreur de charge d'application externe régional ou d'une passerelle d'équilibreur de charge d'application interne régional.

    Pour en savoir plus sur le déploiement de passerelles, consultez la section Déployer des passerelles.

  2. Déployez un service de rappel de backend : créez un service Kubernetes qui représente le service de backend pour l'exécution de la logique personnalisée. L'équilibreur de charge appelle ce service.

  3. Configurer les extensions de service: configurez les extensions de service appropriées en fonction du type et des exigences de votre équilibreur de charge.

    1. GCPRoutingExtension pour les passerelles régionales: utilisez cette extension pour l'équilibreur de charge d'application externe régional et l'équilibreur de charge d'application interne régional afin d'implémenter une logique de routage personnalisée dans la région.

    2. GCPTrafficExtension pour les passerelles externes globales, externes régionales et internes: utilisez cette extension pour les équilibreurs de charge d'application externes globaux, les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux afin d'effectuer une manipulation du trafic, telle que la modification de l'en-tête ou l'inspection de la charge utile, sur différents types d'équilibreurs de charge.

Déployer un service de rappel backend

Un service d'appel implémente une logique personnalisée pour les extensions de service de passerelle dans GKE. La passerelle appelle ces applications backend, en fonction des configurations GCPTrafficExtension ou GCPRoutingExtension, pour modifier ou acheminer le trafic.

Vous déployez un service d'appel pour ajouter une logique personnalisée à votre passerelle. Ce service distinct gère le traitement personnalisé, comme la manipulation des en-têtes, les transformations de la charge utile ou le routage du trafic.

Pour déployer un service de backend pouvant servir d'appel pour votre passerelle, procédez comme suit:

  1. (Facultatif) Créer un secret pour TLS : cette commande crée un secret Kubernetes de type TLS contenant votre certificat TLS et votre clé privée.

    Pour créer le secret TLS de votre service de callout, remplacez les éléments suivants:

    • SECRET_NAME: nom secret de votre service d'appel
    • path-to-cert: chemins d'accès de votre certificat
    • path-to-key: chemins d'accès aux fichiers de votre clé

  2. Pour vérifier que le secret a été ajouté, exécutez la commande suivante:

    kubectl get secrets SECRET_NAME

    Remplacez SECRET_NAME par le nom secret de votre service d'appel.

    La sortie devrait ressembler à ce qui suit :

    NAME            TYPE                DATA   AGE
SECRET_NAME     kubernetes.io/tls   2      12s

  3. Définissez les ressources de déploiement et de service.

    Vous devez définir les éléments suivants:

    • Déploiement: pour gérer les pods d'application contenant la logique personnalisée de vos extensions de service.
    • Service: permet d'exposer les pods d'application gérés par le déploiement en tant que service réseau.

    1. Créez un exemple de fichier manifeste extension-service-app.yaml contenant des définitions de déploiement et de service:

      apiVersion: apps/v1
kind: Deployment
metadata:
name: extension-service-app
spec:
selector:
    matchLabels:
      app: store
  replicas: 1
  template:
    metadata:
      labels:
        app: store
    spec:
      containers:
      - name: serviceextensions
        image: us-docker.pkg.dev/service-extensions-samples/callouts/python-example-basic:main
        ports:
        - containerPort: 8080
        - containerPort: 443
        volumeMounts:
        - name: certs
          mountPath: "/etc/certs/"
          readOnly: true
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: TLS_SERVER_CERT
          value: "/etc/certs/path-to-cert"
        - name: TLS_SERVER_PRIVKEY
          value: "/etc/certs/path-to-key"
          resources:
          requests:
            cpu: 10m
      volumes:
      - name: certs
        secret:
          secretName: SECRET_NAME
          optional: false
---
apiVersion: v1
kind: Service
metadata:
  name: extension-service
spec:
  ports:
  - port: 443
    targetPort: 443
    appProtocol: HTTP2
  selector:
    app: store

    2. Appliquez le fichier manifeste extension-service-app.yaml :

      kubectl apply -f extension-service-app.yaml

  4. Vérifiez votre configuration :

    1. Vérifiez que l'application a été déployée:

      kubectl get pod --selector app=store

      Une fois l'application lancée, le résultat ressemble à ce qui suit:

      NAME                                     READY   STATUS    RESTARTS   AGE
extension-service-app-85f466bc9b-b5mf4   1/1     Running   0          7s

    2. Vérifiez que le service a été déployé:

      kubectl get service extension-service

      Le résultat ressemble à ce qui suit, qui affiche un service pour chaque déploiement de magasin:

      NAME                TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
extension-service   ClusterIP   34.118.225.9   <none>        443/TCP   2m40s

Configurer les extensions de service

Vous pouvez configurer un GCPRoutingExtension ou un GCPTrafficExtension pour personnaliser votre flux de trafic.

Configurer GCPRoutingExtension pour les passerelles régionales

Vous pouvez rediriger le trafic à l'aide d'un GCPRoutingExtension. Pour configurer un GCPRoutingExtension, mettez à jour HTTPRoute pour spécifier les requêtes de l'hôte service-extensions.com.

  1. Mettez à jour HTTPRoute. Modifiez votre HTTPRoute pour inclure des noms d'hôte ou des chemins d'accès qui déclencheront l'extension de routage.

    1. Enregistrez l'exemple de fichier manifeste suivant en tant que fichier store-route.yaml:

      kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1
metadata:
  name: store
spec:
  parentRefs:
  - kind: Gateway
    name:GATEWAY_NAME
  hostnames:
  - "store.example.com"
  - "service-extensions.example.com"
  rules:
  - backendRefs:
    - name: store-v1
      port: 8080
  - matches:
    - headers:
      - name: env
        value: canary
    backendRefs:
    - name: store-v2
      port: 8080
  - matches:
    - path:
        value: /de
    backendRefs:
    - name: store-german
      port: 8080

      Remplacez GATEWAY_NAME par le nom de votre passerelle.

    2. Appliquez le fichier manifeste store-route.yaml :

      kubectl apply -f store-route.yaml

  2. Définissez GCPRoutingExtension.

    1. Enregistrez la configuration GCPRoutingExtension dans l'exemple de fichier gcp-routing-extension.yaml:

      kind: GCPRoutingExtension
apiVersion: networking.gke.io/v1
metadata:
  name: my-gateway-extension
  namespace: default
spec:
  targetRefs:
  - group: "gateway.networking.k8s.io"
    kind: Gateway
    name: GATEWAY_NAME
  extensionChains:
  - name: chain1
    matchCondition:
      celExpressions:
      - celMatcher: request.path.contains("serviceextensions")
    extensions:
    - name: ext1
      authority: "myext.com"
      timeout: 1s
        backendRef:
          group: ""
        kind: Service
        name: extension-service
        port: 443

      Remplacez GATEWAY_NAME par le nom de votre passerelle.

    2. Appliquez l'exemple de fichier manifeste à votre cluster:

      kubectl apply -f gcp-routing-extension.yaml

  3. Vérifiez la configuration de GCPRoutingExtension et son association à la passerelle.

    1. Vérifiez le déploiement GCPRoutingExtension:

      kubectl describe gcproutingextension my-gateway-extension

      Le résultat ressemble à ce qui suit :

      Name:         my-gateway-extension
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         GCPRoutingExtension
Metadata:
  Creation Timestamp:  2025-03-02T17:12:30Z
  Generation:        1
  Resource Version:  31283253
  UID:               ec8efaa0-d8e7-4e1b-9fd4-0ae0ef3c74d0
Spec:
  Extension Chains:
    Extensions:
      Authority:    myext.com
      Backend Ref:
        Group:
        Kind: Service
        Name: extension-service
        Port: 443
      Name:       ext1
      Timeout:    1s
    Match Condition:
      Cel Expressions:
        Cel Matcher: request.path.contains("serviceextensions")
    Name:  chain1
  Target Refs:
    Group: gateway.networking.k8s.io
    Kind: Gateway
    Name: GATEWAY_NAME
Events:  <none>

      La sortie affiche les détails de la GCPRoutingExtension, qui est nommée my-gateway-extension, dans l'espace de noms par défaut. La sortie affiche le champ Spec, qui contient la définition du comportement de l'extension.

    2. Vérifiez la liaison de la passerelle:

      1. Vérifiez que GCPRoutingExtension est associé à la passerelle. Cela peut prendre quelques minutes:

        kubectl describe gateway GATEWAY_NAME

        Le résultat ressemble à ce qui suit :

        Name:         GATEWAY_NAME
Namespace:    default
Labels:       none
Annotations:  networking.gke.io/addresses: /projects/1234567890/regions/us-central1/addresses/test-hgbk-default-internal-http-5ypwen3x2gcr
              networking.gke.io/backend-services:
                /projects/1234567890/regions/us-central1/backendServices/test-hgbk-default-extension-service-443-rduk21fwhoj0, /projects/1234567890/re...
              networking.gke.io/firewalls: /projects/1234567890/global/firewalls/test-hgbk-l7-default-us-central1
              networking.gke.io/forwarding-rules: /projects/1234567890/regions/us-central1/forwardingRules/test-hgbk-default-internal-http-qn7dk9i9zm73
              networking.gke.io/health-checks:
                /projects/1234567890/regions/us-central1/healthChecks/test-hgbk-default-extension-service-443-rduk21fwhoj0, /projects/1234567890/regio...
              networking.gke.io/last-reconcile-time: 2025-03-02T17:15:02Z
              networking.gke.io/lb-route-extensions:
                /projects/1234567890/locations/us-central1/lbRouteExtensions/test-hgbk-default-internal-http-lwh0op4qorb0
              networking.gke.io/lb-traffic-extensions:
              networking.gke.io/ssl-certificates:
              networking.gke.io/target-http-proxies:
                /projects/1234567890/regions/us-central1/targetHttpProxies/test-hgbk-default-internal-http-2jzr7e3xclhj
              networking.gke.io/target-https-proxies:
              networking.gke.io/url-maps: /projects/1234567890/regions/us-central1/urlMaps/test-hgbk-default-internal-http-2jzr7e3xclhj
API Version:  gateway.networking.k8s.io/v1
Kind:         Gateway
Metadata:
  Creation Timestamp:  2025-03-02T16:37:50Z
  Finalizers:
  gateway.finalizer.networking.gke.io
  Generation:        1
  Resource Version:  31284863
  UID:               fd512611-bad2-438e-abfd-5619474fbf31
...

        La sortie affiche les annotations, que GKE utilise pour stocker les liens entre la passerelle et les ressourcesGoogle Cloud sous-jacentes. L'annotation networking.gke.io/lb-route-extensions confirme l'association de la passerelle au GCPRoutingExtension.

      2. Vérifiez l'état de l'extension en confirmant que GCPRoutingExtension est à l'état Reconciled avec le motif ReconciliationSucceeded. L'exécution de cette commande peut prendre quelques minutes.

        kubectl describe gcproutingextension my-gateway-extension

        Le résultat ressemble à ce qui suit :

        Name:         my-gateway-extension
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         GCPRoutingExtension
Metadata:
  Creation Timestamp:  2025-03-02T17:12:30Z
  Generation:          1
  Resource Version:    31284378
  UID:                 ec8efaa0-d8e7-4e1b-9fd4-0ae0ef3c74d0
Spec:
  Extension Chains:
    Extensions:
      Authority:  myext.com
      Backend Ref:
        Group:
        Kind:   Service
        Name:   extension-service
        Port:   443
      Name:     ext1
      Timeout:  1s
    Match Condition:
      Cel Expressions:
        Cel Matcher:  request.path.contains("serviceextensions")
    Name:             chain1
  Target Refs:
    Group:  gateway.networking.k8s.io
    Kind:   Gateway
    Name:   GATEWAY_NAME
Status:
  Ancestors:
    Ancestor Ref:
      Group:      gateway.networking.k8s.io
      Kind:       Gateway
      Name:       GATEWAY_NAME
      Namespace:  default
    Conditions:
      Last Transition Time:  2025-03-02T17:14:15Z
      Message:
      Reason:                Accepted
      Status:                True
      Type:                  Accepted
      Last Transition Time:  2025-03-02T17:14:15Z
      Message:
      Reason:                ReconciliationSucceeded
      Status:                True
      Type:                  Reconciled
    Controller Name:         networking.gke.io/gateway
Events:
  Type    Reason  Age                From                   Message
  ----    ------  ----               ----                   -------
  Normal  ADD     2m31s              sc-gateway-controller  default/my-gateway-extension
Normal  SYNC    51s (x2 over 98s)  sc-gateway-controller  Attachment of GCPRoutingExtension "default/my-gateway-extension" to AncestorRef {Group:       "gateway.networking.k8s.io",
Kind:        "Gateway",
Namespace:   "default",
Name:        "GATEWAY_NAME",
SectionName: nil,
Port:        nil} was a success
  Normal  SYNC    23s           sc-gateway-controller  Reconciliation of GCPRoutingExtension "default/my-gateway-extension" to AncestorRef {Group:       "gateway.networking.k8s.io",
Kind:        "Gateway",
Namespace:   "default",
Name:        "GATEWAY_NAME",
SectionName: nil,
Port:        nil} was a success

        Le champ Status.Conditions affiche une condition Reconciled avec Status: True et Reason: ReconciliationSucceeded.

        Vrai et motif: ReconciliationSucceeded. Ces informations confirment que l'extension a bien été appliquée.

  4. Envoyez du trafic vers votre application.

    Une fois votre ressource Gateway, votre route et votre application déployées dans votre cluster, vous pouvez transmettre du trafic à votre application.

    1. Pour accéder à votre application, vous devez trouver l'adresse IP de votre passerelle.

      Dans votre terminal, utilisez la commande suivante:

      kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"

      Remplacez GATEWAY_NAME par le nom de votre passerelle.

      Cette commande affiche l'adresse IP de la passerelle. Dans les commandes de suivi, remplacez GATEWAY_IP_ADDRESS par l'adresse IP de la sortie.

    2. Testez la mise à jour du chemin en accédant à la version serviceextensions du service de magasin à l'adresse store.example.com/serviceextensions:

      curl http://store.example.com/serviceextensions --resolve store.example.com:80:GATEWAY_IP_ADDRESS -v

      Le résultat ressemble à ce qui suit :

      {
"cluster_name": "gke1",
"host_header": "service-extensions.com",
"metadata": "store-v1",
"pod_name": "store-v1-5d9554f847-cvxpd",
"pod_name_emoji": "💇🏼‍♀️",
"project_id": "gateway-demo",
"timestamp": "2025-03-15T12:00:00",
"zone": "us-central1-c"
}

Configurer le GCPTrafficExtension

Vous pouvez utiliser un GCPTrafficExtension pour utiliser des fonctionnalités avancées de gestion du trafic dans votre environnement Google Cloud . Vous pouvez configurer cette extension pour les équilibreurs de charge d'application externes globaux, les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux. Vous pouvez utiliser GCPTrafficExtension pour implémenter une logique de requête et de réponse personnalisée, un routage sophistiqué, des transformations et des règles de sécurité.

  1. Mettez à jour HTTPRoute. Modifiez votre HTTPRoute pour inclure les noms d'hôte ou les chemins qui déclencheront l'extension du trafic.

    1. Enregistrez l'exemple de fichier manifeste suivant en tant que fichier store-route.yaml:

      kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1
metadata:
  name: store
spec:
  parentRefs:
  - kind: Gateway
    name: GATEWAY_NAME
  hostnames:
  - "store.example.com"
  - "service-extensions.example.com"
  rules:
  - backendRefs:
    - name: store-v1
      port: 8080
  - matches:
    - headers:
      - name: env
        value: canary
    backendRefs:
    - name: store-v2
      port: 8080
  - matches:
    - path:
        value: /de
    backendRefs:
    - name: store-german
      port: 8080

      Remplacez GATEWAY_NAME par le nom de votre passerelle, par exemple internal-http, external-http ou global-external-http.

    2. Appliquez le fichier manifeste store-route.yaml à votre cluster:

      kubectl apply -f store-route.yaml

  2. Définissez GCPTrafficExtension.

    1. Enregistrez la configuration GCPTrafficExtension dans l'exemple de fichier gcp-traffic-extension.yaml:

      kind: GCPTrafficExtension
apiVersion: networking.gke.io/v1
metadata:
  name: my-traffic-extension
  namespace: default
spec:
  targetRefs:
  - group: "gateway.networking.k8s.io"
    kind: Gateway
    name: GATEWAY_NAME
  extensionChains:
  - name: chain1
    matchCondition:
      celExpressions:
      - celMatcher: request.path.contains("serviceextensions")
    extensions:
    - name: ext1
      authority: "myext.com"
      timeout: 1s
      backendRef:
        group: ""
        kind: Service
        name: extension-service
        port: 443

      Remplacez GATEWAY_NAME par le nom de votre passerelle, par exemple internal-http, external-http ou global-external-http.

    2. Appliquez l'exemple de fichier manifeste à votre cluster:

      kubectl apply -f gcp-traffic-extension.yaml

  3. Vérifiez la configuration de GCPTrafficExtension et son association à la passerelle.

    1. Vérifiez le déploiement GCPTrafficExtension:

      kubectl describe gcptrafficextension my-traffic-extension

      Le résultat ressemble à ce qui suit :

      Name:         my-traffic-extension
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         GCPTrafficExtension
Metadata:
  Creation Timestamp:  2025-03-02T17:12:30Z
  Generation:        1
  Resource Version:  31283253
  UID:               ec8efaa0-d8e7-4e1b-9fd4-0ae0ef3c74d0
Spec:
  Extension Chains:
    Extensions:
      Authority:    myext.com
      Backend Ref:
        Group:
        Kind: Service
        Name: extension-service
        Port: 443
      Name:       ext1
      Timeout:    1s
    Match Condition:
      Cel Expressions:
        Cel Matcher: request.path.contains("serviceextensions")
    Name:  chain1
  Target Refs:
    Group: gateway.networking.k8s.io
    Kind: Gateway
    Name: GATEWAY_NAME
Events:  <none>

      La sortie affiche les détails de l'GCPTrafficExtension nommé my-traffic-extension dans l'espace de noms par défaut. Il affiche le champ Spec, qui contient la définition du comportement de l'extension.

    2. Vérifiez la liaison de la passerelle:

      Vérifiez que GCPTrafficExtension est associé à la passerelle. L'exécution de cette commande peut prendre quelques minutes:

      kubectl describe gateway GATEWAY_NAME

      Le résultat ressemble à ce qui suit :

      Name:         GATEWAY_NAME
Namespace:    default
Labels:       <none>
Annotations:  networking.gke.io/addresses: /projects/1234567890/regions/us-central1/addresses/test-hgbk-default-internal-http-5ypwen3x2gcr
              networking.gke.io/backend-services:
                /projects/1234567890/regions/us-central1/backendServices/test-hgbk-default-extension-service-443-rduk21fwhoj0, /projects/1234567890/re...
              networking.gke.io/firewalls: /projects/1234567890/global/firewalls/test-hgbk-l7-default-us-central1
              networking.gke.io/forwarding-rules: /projects/1234567890/regions/us-central1/forwardingRules/test-hgbk-default-internal-http-qn7dk9i9zm73
              networking.gke.io/health-checks:
                /projects/1234567890/regions/us-central1/healthChecks/test-hgbk-default-extension-service-443-rduk21fwhoj0, /projects/1234567890/regio...
              networking.gke.io/last-reconcile-time: 2025-03-02T17:15:02Z
              networking.gke.io/lb-traffic-extensions:
                /projects/1234567890/locations/us-central1/lbTrafficExtensions/test-hgbk-default-internal-http-lwh0op4qorb0
              networking.gke.io/ssl-certificates:
              networking.gke.io/target-http-proxies:
                /projects/1234567890/regions/us-central1/targetHttpProxies/test-hgbk-default-internal-http-2jzr7e3xclhj
              networking.gke.io/target-https-proxies:
              networking.gke.io/url-maps: /projects/1234567890/regions/us-central1/urlMaps/test-hgbk-default-internal-http-2jzr7e3xclhj
API Version:  gateway.networking.k8s.io/v1
Kind:         Gateway
Metadata:
  Creation Timestamp:  2025-03-02T16:37:50Z
  Finalizers:
    gateway.finalizer.networking.gke.io
  Generation:        1
  Resource Version:  31284863
  UID:               fd512611-bad2-438e-abfd-5619474fbf31
...

      La sortie affiche les annotations, que GKE utilise pour stocker les liens entre la passerelle et les ressources Google Cloud sous-jacentes. L'annotation networking.gke.io/lb-traffic-extensions confirme la liaison.

    3. Vérifiez l'état de l'extension:

      Vérifiez que l'GCPTrafficExtension a un état Reconciled avec le motif ReconciliationSucceeded. L'exécution de cette commande peut prendre quelques minutes.

      kubectl describe gcptrafficextension my-traffic-extension

      Le résultat ressemble à ce qui suit :

      Name:         my-traffic-extension
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         GCPTrafficExtension
Metadata:
  Creation Timestamp:  2025-03-02T17:12:30Z
  Generation:          1
  Resource Version:    31284378
  UID:                 ec8efaa0-d8e7-4e1b-9fd4-0ae0ef3c74d0
Spec:
  Extension Chains:
    Extensions:
      Authority:  myext.com
      Backend Ref:
        Group:
        Kind:   Service
        Name:   extension-service
        Port:   443
      Name:     ext1
      Timeout:  1s
    Match Condition:
      Cel Expressions:
        Cel Matcher:  request.path.contains("serviceextensions")
    Name:             chain1
  Target Refs:
    Group:  gateway.networking.k8s.io
    Kind:   Gateway
    Name:   GATEWAY_NAME
Status:
  Ancestors:
    Ancestor Ref:
      Group:      gateway.networking.k8s.io
      Kind:       Gateway
      Name:       GATEWAY_NAME
      Namespace:  default
    Conditions:
      Last Transition Time:  2025-03-02T17:14:15Z
      Message:
      Reason:                Accepted
      Status:                True
      Type:                  Accepted
      Last Transition Time:  2025-03-02T17:14:15Z
      Message:
      Reason:                ReconciliationSucceeded
      Status:                True
      Type:                  Reconciled
    Controller Name:         networking.gke.io/gateway
Events:
  Type    Reason  Age                From                   Message
  ----    ------  ----               ----                   -------
  Normal  ADD     2m31s              sc-gateway-controller  default/my-traffic-extension
  Normal  SYNC    51s (x2 over 98s)  sc-gateway-controller  Attachment of GCPTrafficExtension "default/my-gateway-extension" to AncestorRef {Group:       "gateway.networking.k8s.io",
  Kind:        "Gateway",
  Namespace:   "default",
  Name:        "GATEWAY_NAME",
  SectionName: nil,
  Port:        nil} was a success
  Normal  SYNC    23s           sc-gateway-controller  Reconciliation of GCPTrafficExtension "default/my-traffic-extension" to AncestorRef {Group:       "gateway.networking.k8s.io",
  Kind:        "Gateway",
  Namespace:   "default",
  Name:        "GATEWAY_NAME",
  SectionName: nil,
  Port:        nil} was a success

      Le champ Status.Conditions affiche une condition Reconciled avec Status: True et Reason: ReconciliationSucceeded. Ces informations confirment que l'extension a bien été appliquée.

  4. Envoyez du trafic vers votre application.

    Une fois votre ressource Gateway, votre route et votre application déployées dans votre cluster, vous pouvez transmettre du trafic à votre application.

    1. Pour accéder à votre application, vous devez trouver l'adresse IP de votre passerelle.

      Dans votre terminal, utilisez la commande suivante:

      kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"

      Remplacez GATEWAY_NAME par le nom de votre passerelle.

      Cette commande affiche l'adresse IP de la passerelle. Dans les commandes de suivi, remplacez GATEWAY_IP_ADDRESS par l'adresse IP de la sortie.

    2. Testez la mise à jour du chemin en accédant à la version serviceextensions du service de magasin à l'adresse store.example.com/serviceextensions:

      curl http://store.example.com/serviceextensions --resolve store.example.com:80:GATEWAY_IP_ADDRESS -v

      Le résultat ressemble à ce qui suit :

      {
*   Request completely sent off
< HTTP/1.1 200 OK
< server: Werkzeug/2.3.7 Python/3.11.3
< date: Sun, 02 Mar 2025 16:58:10 GMT
< content-type: application/json
< access-control-allow-origin: *
< hello: service-extensions
< via: 1.1 google
< transfer-encoding: chunked
}

Résoudre les problèmes d'extensions de trafic sur les passerelles

Cette section fournit des conseils de dépannage pour la configuration des extensions de trafic sur les passerelles.

Passerelle introuvable

L'erreur suivante indique que la ressource de passerelle spécifiée dans le champ targetRefs de la ressource GCPTrafficExtension ou GCPRoutingExtension n'existe pas:

error: failed to create resource: GCPTrafficExtension.networking.gke.io "my-traffic-extension" is invalid: spec.gatewayRef: gateway "my-gateway" not found in namespace "default"

Pour résoudre ce problème, assurez-vous que la ressource de passerelle spécifiée dans le champ targetRefs de la ressource GCPTrafficExtension ou GCPRoutingExtension existe dans l'espace de noms spécifié.

Service ou port de service introuvable

L'erreur suivante indique que le service ou le port de service spécifié dans le champ backendRef de la ressource GCPTrafficExtension ou GCPRoutingExtension n'existe pas:

error: failed to create resource: GCPTrafficExtension.networking.gke.io "my-traffic-extension" is invalid: spec.service: service "callout-service" not found in namespace "default"

Pour résoudre ce problème, assurez-vous que le service et le port de service spécifiés dans le champ backendRef de la ressource GCPTrafficExtension ou GCPRoutingExtension existent dans l'espace de noms spécifié.

Aucun point de terminaison du réseau dans le NEG

L'erreur suivante indique qu'aucun point de terminaison réseau du NEG n'est associé au service spécifié dans le champ backendRef de la ressource GCPTrafficExtension ou GCPRoutingExtension:

error: failed to create resource: GCPTrafficExtension.networking.gke.io "my-traffic-extension" is invalid: spec.service: no network endpoints found for service "callout-service"

Pour résoudre ce problème, assurez-vous que le service spécifié dans le champ backendRef de la ressource GCPTrafficExtension ou GCPRoutingExtension comporte des points de terminaison réseau.

Aucune réponse ou réponse avec une erreur lors de l'envoi de la requête

Si vous ne recevez pas de réponse ou si vous recevez une réponse avec une erreur lorsque vous envoyez une requête, cela peut indiquer que le service de callout ne fonctionne pas correctement.

Pour résoudre ce problème, recherchez d'éventuelles erreurs dans les journaux du service d'appel.

Code d'erreur 404 dans la charge utile JSON

L'erreur suivante indique que le service d'appel n'a pas été trouvé ou qu'il ne répond pas à la requête:

{
  "error": {
    "code": 404,
    "message": "Requested entity was not found.",
    "status": "NOT_FOUND"
  }
}

Pour résoudre ce problème, assurez-vous que le service de rappel est en cours d'exécution, qu'il écoute sur le bon port et qu'il est correctement configuré dans la ressource GCPTrafficExtension ou GCPRoutingExtension.

Code d'erreur 500 dans la charge utile JSON

L'erreur suivante indique qu'une erreur interne du serveur s'est produite dans le service d'appel:

{
  "error": {
    "code": 500,
    "message": "Internal server error.",
    "status": "INTERNAL"
  }
}

Pour résoudre ce problème, vérifiez les journaux du service d'appel pour identifier la cause de l'erreur de serveur interne.

Étapes suivantes