Cette page a été traduite par l'API Cloud Translation.

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

Autopilot Standard

Cette page explique comment Google Kubernetes Engine (GKE) utilise les extensions de service pour ajouter une logique personnalisée à 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 des extensions de service.

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

Présentation

GKE utilise des extensions de service pour ajouter une logique personnalisée à Cloud Load Balancing. Une extension est associée à 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 avancée du trafic, 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.

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. Le GCPTrafficExtension n'a aucune incidence sur la sélection des service de backend ni sur les règles de sécurité des service de backend.

Figure : Fonctionnement de GCPTrafficExtension avec les passerelles

Trusted Cloud by S3NS Compatibilité des extensions de service avec les GatewayClasses

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

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.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Activez les API Compute Engine, Network Services et Model Armor si nécessaire.

Accédez à Activer l'accès aux API et suivez les instructions.
Pour en savoir plus sur les tarifs des extensions de service Trusted Cloud , consultez Tarifs.
Consultez les rôles et autorisations requis dans Contrôle des accès aux extensions de service.
Familiarisez-vous avec les quotas et les limites dans Quotas des extensions de service.
Si vous prévoyez d'utiliser des comparateurs CEL (Common Expression Language), consultez les attributs et opérateurs compatibles dans la documentation de référence sur le langage des comparateurs CEL.

Remarque : Les attributs de requête request.backend_service_name et request.backend_service_project_number ne sont pas acceptés.
Consultez les restrictions et limites applicables aux extensions de service.

Conditions requises pour le contrôleur GKE Gateway

Votre cluster doit utiliser GKE version 1.33 ou ultérieure.
L'API Gateway doit être activée sur votre cluster.
Vous devez disposer d'une ressource Gateway configurée.
Vous devez disposer d'une ressource HTTPRoute configurée.

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 Gateway `gke-l7-regional-external-managed` et `gke-l7-rilb`), et n'est pas compatible avec la classe Gateway `gke-l7-global-external-managed`.
Chaîne et spécification des extensions	Pour un `GCPTrafficExtension`, chaque `ExtensionChain` peut comporter au maximum trois `Extensions`. Pour un `GCPRoutingExtension`, chaque `ExtensionChain` est limité à un `Extension`. Un `GCPTrafficExtensionSpec` et un `GCPRoutingExtensionSpec` peuvent chacun comporter jusqu'à cinq `ExtensionChains`.
Timing et 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 Route et Trafic. Chaque `MatchCondition` dans un `ExtensionChain` est limité à un maximum de 10 `CELExpressions`. La chaîne `MatchCondition` résultante envoyée à GCE est limitée à 512 caractères. La chaîne `CELMatcher` dans un `CELExpression` ne doit pas comporter plus de 512 caractères et doit respecter un format spécifique. Nous ne prenons pas en charge le champ `BackendRefs` de `CELExpression`.
En-tête et métadonnées	La liste `ForwardHeaders` d'un `Extension` peut contenir jusqu'à 50 noms d'en-tête HTTP. Une carte `Metadata` dans un `Extension` peut contenir jusqu'à 16 propriétés. Les clés du mappage `Metadata` doivent comporter entre 1 et 63 caractères. Les valeurs de la carte `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 les é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 faites référence à un Service qui utilise `backendRef` dans une Extension, vous devez respecter 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. Vous ne pouvez pas 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 l'un des éléments `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 en utilisant uniquement `backendRef`. Configurez `responseBodySendMode` pour les extensions en utilisant uniquement `backendRef`.

Configurer les extensions de service GKE

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

Pour configurer les extensions de service GKE :

Déployez 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 Déployer des passerelles.
Déployer un service d'appel 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.
Configurer les extensions de service : configurez les extensions de service appropriées en fonction de votre type d'équilibreur de charge et de vos exigences.
1. GCPRoutingExtension pour les passerelles régionales : utilisez cette extension pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux 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 de manipuler le trafic (par exemple, en modifiant les en-têtes ou en inspectant la charge utile) sur différents types d'équilibreurs de charge.

Déployer un service d'appel de 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 de 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 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 :

(Facultatif) Créez 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 pour votre service d'appel, remplacez les éléments suivants :
- SECRET_NAME : nom secret de votre service d'appel
- path-to-cert : chemins d'accès à votre certificat
- path-to-key : chemins d'accès à votre clé
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
```

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 qui contiennent la logique personnalisée de vos extensions de service.
Service : pour exposer les pods d'application gérés par le déploiement en tant que service réseau.

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

Appliquez le fichier manifeste extension-service-app.yaml :
```
kubectl apply -f extension-service-app.yaml
```

Vérifiez votre configuration :

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

kubectl get pod --selector app=store

Une fois l'application en cours d'exécution, le résultat ressemble à ce qui suit :

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

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

kubectl get service extension-service

Le résultat ressemble à ce qui suit, qui montre 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 l'HTTPRoute afin de spécifier les requêtes pour l'hôte service-extensions.com.

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

Enregistrez l'exemple de fichier manifeste suivant sous le nom 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.

Appliquez le fichier manifeste store-route.yaml :
```
kubectl apply -f store-route.yaml
```

Définissez le GCPRoutingExtension.

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.

Appliquez l'exemple de fichier manifeste à votre cluster :
```
kubectl apply -f gcp-routing-extension.yaml
```

Vérifiez la configuration de GCPRoutingExtension et sa liaison à la passerelle.

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>

Le résultat affiche les détails de GCPRoutingExtension, qui est nommé 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.

Vérifiez la liaison de la passerelle :

Vérifiez que GCPRoutingExtension est lié à 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
...

Le résultat affiche les annotations que GKE utilise pour stocker les liens entre la passerelle et les ressourcesTrusted Cloud sous-jacentes. L'annotation networking.gke.io/lb-route-extensions confirme l'association de la passerelle à GCPRoutingExtension.

Vérifiez l'état de l'extension en vous assurant que GCPRoutingExtension est à l'état Reconciled avec la raison 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 raison : ReconciliationSucceeded. Ces informations confirment que l'extension a bien été appliquée.

Envoyez du trafic vers votre application.

Une fois votre passerelle, 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 génère l'adresse IP de la passerelle. Dans les commandes suivantes, 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 Trusted 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é.

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

Enregistrez l'exemple de fichier manifeste suivant sous le nom 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.

Appliquez le fichier manifeste store-route.yaml à votre cluster :
```
kubectl apply -f store-route.yaml
```

Définissez le GCPTrafficExtension.

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, à savoir internal-http, external-http ou global-external-http.

Appliquez l'exemple de fichier manifeste à votre cluster :
```
kubectl apply -f gcp-traffic-extension.yaml
```

Vérifiez la configuration de GCPTrafficExtension et sa liaison à la passerelle.

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>

Le résultat 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.

Vérifiez la liaison de la passerelle :

Vérifiez que GCPTrafficExtension est lié à 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 Trusted Cloud sous-jacentes. L'annotation networking.gke.io/lb-traffic-extensions confirme l'association.

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

Vérifiez que l'GCPTrafficExtension est à l'état Reconciled pour la raison 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.

Envoyez du trafic vers votre application.

Une fois votre passerelle, 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 génère l'adresse IP de la passerelle. Dans les commandes suivantes, 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 liés aux extensions de trafic sur les passerelles

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

Passerelle introuvable

L'erreur suivante indique que la ressource Gateway 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 Gateway 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és dans le champ backendRef de la ressource GCPTrafficExtension ou GCPRoutingExtension n'existent 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 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 dispose de points de terminaison réseau.

Aucune réponse ou réponse avec une erreur lors de l'envoi de la demande

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

Pour résoudre ce problème, vérifiez si des erreurs sont présentes 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 est introuvable ou 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 d'appel 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 que le service d'accroche rencontre une erreur interne du serveur :

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

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

Étapes suivantes

En savoir plus sur la passerelle d'inférence GKE
Découvrez comment diffuser un LLM avec GKE Inference Gateway.
Découvrez comment afficher les métriques d'observabilité.

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

Présentation

Avant de commencer

Conditions requises pour le contrôleur GKE Gateway

Restrictions et limitations

Configurer les extensions de service GKE

Déployer un service d'appel de backend

Configurer les extensions de service

Configurer GCPRoutingExtension pour les passerelles régionales

Configurer le GCPTrafficExtension

Résoudre les problèmes liés aux extensions de trafic sur les passerelles

Passerelle introuvable

Service ou port de service introuvable

Aucun point de terminaison réseau dans le NEG

Aucune réponse ou réponse avec une erreur lors de l'envoi de la demande

Code d'erreur 404 dans la charge utile JSON

Code d'erreur 500 dans la charge utile JSON

Étapes suivantes

Configurer `GCPRoutingExtension` pour les passerelles régionales

Configurer le `GCPTrafficExtension`