Personalizzare il traffico del gateway GKE utilizzando Service Extensions

Questa pagina descrive come Google Kubernetes Engine (GKE) utilizza le estensioni di servizio per aggiungere logica personalizzata al bilanciamento del carico Cloud.

Questa pagina è rivolta agli amministratori di account e di identità GKE e agli sviluppatori che devono configurare la logica di gestione del traffico personalizzata utilizzando le Estensioni di servizio.

Prima di leggere questa pagina, assicurati di conoscere quanto segue:

Panoramica

GKE utilizza le estensioni di servizio per aggiungere logica personalizzata in Cloud Load Balancing. Un'estensione si attacca a un Gateway e fa riferimento a un Service o a un GoogleAPIServiceName. GoogleAPIServiceName è supportato solo per GCPTrafficExtensions.

Puoi modificare gli intestazioni e i payload HTTP per le richieste e le risposte oppure controllare il routing del traffico senza influire sulla selezione dei servizi di backend o sui criteri di sicurezza. Puoi utilizzare le estensioni di servizio per attività come la suddivisione avanzata del traffico, l'autenticazione personalizzata o la registrazione delle richieste.

Il controller GKE Gateway supporta le seguenti estensioni di servizio:

  • GCPRoutingExtension: questa estensione aggiunge logica personalizzata al bilanciamento del carico Cloud per controllare il routing del traffico. È supportato per il bilanciatore del carico delle applicazioni esterno regionale e il bilanciatore del carico delle applicazioni interno regionale.

    La risorsa "GCPRoutingExtension" è collegata a un gateway e fa riferimento a un servizio. L'estensione controlla il routing del traffico.
    Figura: come funziona "GCPRoutingExtension" con i gateway

  • GCPTrafficExtension: questa estensione inserisce logica personalizzata nel bilanciamento del carico di Cloud. Consente a un servizio di estensioni di modificare le intestazioni e i payload di richieste e risposte. GCPTrafficExtension non influisce sulla selezione dei servizi di backend o sui criteri di sicurezza dei servizi di backend.

    La risorsa "GCPTrafficExtension" è collegata a un gateway e fa riferimento a un servizio o a un "GoogleAPIServiceName". L'estensione modifica gli header e i payload delle richieste e delle risposte.
    Figura: come funziona "GCPTrafficExtension" con i gateway

Google Cloud Compatibilità di Service Extension con GatewayClasses

La tabella seguente descrive la compatibilità delle Google Cloud estensioni di servizio con diversi GatewayClass:

GatewayClass GCPRoutingExtension GCPTrafficExtension
gke-l7-rilb Supportato Supportato
gke-l7-regional-external-managed Supportato Supportato
gke-l7-global-external-managed Non supportata Supportato

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installa e poi inizializza gcloud CLI. Se hai già installato l'interfaccia a riga di comando gcloud, ottieni la versione più recente eseguendo gcloud components update.

Requisiti di GKE Gateway Controller

Restrizioni e limitazioni

La tabella seguente elenca le limitazioni associate alla configurazione delle estensioni di servizio gateway in GKE:

Categoria Restrizioni e limitazioni
Bilanciatore del carico GCPRoutingExtension è supportato solo per i bilanciatori del carico delle applicazioni esterni regionali e per i bilanciatori del carico delle applicazioni interni regionali (classi di gateway gke-l7-regional-external-managed e gke-l7-rilb) e non è supportato dalla classe di gateway gke-l7-global-external-managed.
Catena e specifica dell'estensione
  • Per un GCPTrafficExtension, ogni ExtensionChain può avere un massimo di 3 Extensions.
  • Per un GCPRoutingExtension, ogni ExtensionChain è limitato a 1 Extension.
  • Un GCPTrafficExtensionSpec e un GCPRoutingExtensionSpec possono avere ciascuno un massimo di 5 ExtensionChains.
Tempistiche e corrispondenza
  • Il timeout per ogni singolo messaggio nello stream all'interno di un'estensione deve essere compreso tra 10 e 1000 millisecondi. Questo limite di un secondo si applica alle estensioni Route e Traffic.
  • Ogni MatchCondition all'interno di un ExtensionChain è limitato a un massimo di 10 CELExpressions.
  • La stringa MatchCondition risultante inviata a GCE ha un limite di 512 caratteri.
  • La stringa CELMatcher all'interno di un CELExpression ha una lunghezza massima di 512 caratteri e deve rispettare uno schema specifico. Non supportiamo il campo BackendRefs di CELExpression.
Intestazione e metadati
  • L'elenco ForwardHeaders in un Extension può contenere un massimo di 50 nomi di intestazioni HTTP.
  • La mappa Metadata in un Extension può avere un massimo di 16 proprietà.
  • Le chiavi all'interno della mappa Metadata devono avere una lunghezza compresa tra 1 e 63 caratteri.
  • I valori all'interno della mappa Metadata devono avere una lunghezza compresa tra 1 e 1023 caratteri.
Evento
  • Per un GCPRoutingExtension, se requestBodySendMode non è impostato, l'elenco supportedEvents può contenere solo eventi RequestHeaders.
  • Per un GCPRoutingExtension, se requestBodySendMode è impostato su FullDuplexStreamed, l'elenco supportedEvents può contenere solo eventi RequestHeaders, RequestBody e RequestTrailers.
GCPTrafficExtension
  • Il campo responseBodySendMode è supportato solo per GCPTrafficExtension.
  • Il campo googleAPIServiceName è supportato solo per GCPTrafficExtension.
googleAPIServiceName e backendRef Quando fai riferimento a un servizio che utilizza backendRef in un'estensione, devi soddisfare le seguenti condizioni:
  • Deve utilizzare HTTP2 come appProtocol.
  • Deve trovarsi nello stesso spazio dei nomi dell'estensione e del gateway a cui fa riferimento l'estensione.
  • Non è possibile utilizzare IAP.
  • Non è possibile utilizzare i criteri di sicurezza di Google Cloud Armor (campo securityPolicy da GCPBackendPolicyConfig.
  • Non è possibile utilizzare Cloud CDN.
  • È necessario impostare esattamente uno tra backendRef o googleAPIServiceName per un Extension.
  • È necessario impostare authority se è impostato backendRef.
  • È necessario impostare authority se è impostato googleAPIServiceName.
  • Configura requestBodySendMode per le estensioni utilizzando solo backendRef.
  • Configura responseBodySendMode per le estensioni utilizzando solo backendRef.

Configurare le estensioni di servizio GKE

Puoi personalizzare il routing del traffico, modificare i payload di richiesta o risposta e integrarti con servizi esterni configurando le Estensioni di servizio GKE. I gateway non hanno Estensioni di servizio per impostazione predefinita.

Per configurare le estensioni di servizio GKE:

  1. Esegui il deployment di un gateway: per configurare un'estensione del servizio GKE, devi prima eseguire il deployment di un gateway che indirizzi il traffico esterno al tuo cluster. Può essere un bilanciatore del carico delle applicazioni esterno globale, un bilanciatore del carico delle applicazioni esterno regionale o un gateway bilanciatore del carico delle applicazioni interno regionale.

    Per ulteriori informazioni sul deployment dei gateway, consulta Eseguire il deployment dei gateway.

  2. Esegui il deployment di un servizio di callout di backend: crea un servizio Kubernetes che rappresenti il servizio di backend per l'esecuzione della logica personalizzata. Il bilanciatore del carico richiama questo servizio.

  3. Configura le estensioni di servizio: configura le estensioni di servizio appropriate in base al tipo e ai requisiti del bilanciatore del carico.

    1. GCPRoutingExtension per i gateway regionali: utilizza questa estensione per i bilanciatori del carico delle applicazioni esterni e interni regionali per implementare una logica di routing personalizzata all'interno della regione.

    2. GCPTrafficExtension per gateway esterni globali, esterni regionali e interni: utilizza questa estensione per i bilanciatori del carico delle applicazioni esterni globali, esterni regionali e interni regionali per eseguire la manipolazione del traffico, ad esempio la modifica dell'intestazione o l'ispezione del payload, su vari tipi di bilanciatori del carico.

Esegui il deployment di un servizio di callout di backend

Un servizio di callout implementa la logica personalizzata per le estensioni di servizio Gateway in GKE. Il gateway richiama queste applicazioni di backend, in base alle configurazioni GCPTrafficExtension o GCPRoutingExtension, per modificare o instradare il traffico.

Esegui il deployment di un servizio callout per aggiungere logica personalizzata al tuo gateway. Questo servizio indipendente gestisce l'elaborazione personalizzata, ad esempio la manipolazione dell'intestazione, le trasformazioni del payload o il routing del traffico.

Per eseguire il deployment di un servizio di backend che possa fungere da callout per il tuo gateway, segui questi passaggi:

  1. (Facoltativo) Crea un secret per TLS: questo comando crea un secret Kubernetes di tipo TLS contenente il certificato TLS e la chiave privata.

    Per creare il secret TLS per il servizio callout, sostituisci quanto segue:

    • SECRET_NAME: il nome del secret per il servizio di callout
    • path-to-cert: i percorsi dei file del certificato
    • path-to-key: i percorsi file della chiave

  2. Per verificare che il segreto sia stato aggiunto, esegui questo comando:

    kubectl get secrets SECRET_NAME

    Sostituisci SECRET_NAME con il nome della chiave segreta per il servizio di callout.

    L'output dovrebbe essere simile al seguente:

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

  3. Definisci le risorse di Deployment e Service.

    Devi definire quanto segue:

    • Deployment: per gestire i pod di applicazioni che contengono la logica personalizzata per le estensioni di servizio.
    • Servizio: per esporre i pod dell'applicazione gestiti dal deployment come servizio di rete.

    1. Crea un manifest di esempio extension-service-app.yaml con le definizioni di deployment e servizio:

      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. Applica il manifest extension-service-app.yaml:

      kubectl apply -f extension-service-app.yaml

  4. Verifica la configurazione:

    1. Verifica che l'applicazione sia stata dispiata:

      kubectl get pod --selector app=store

      Una volta avviata l'applicazione, l'output è simile al seguente:

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

    2. Verifica che il servizio sia stato disegnato:

      kubectl get service extension-service

      L'output è simile al seguente, che mostra un servizio per ogni deployment del negozio:

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

Configura le estensioni di servizio

Puoi configurare un GCPRoutingExtension o un GCPTrafficExtension per personalizzare il flusso di traffico.

Configurare GCPRoutingExtension per i gateway regionali

Puoi reindirizzare il traffico utilizzando un GCPRoutingExtension. Per configurare un GCPRoutingExtension, aggiorna HTTPRoute per specificare le richieste per l'service-extensions.comhost.

  1. Aggiorna HTTPRoute. Modifica HTTPRoute in modo da includere i nomi host o i percorsi che attiveranno l'estensione di routing.

    1. Salva il seguente manifest di esempio come file 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

      Sostituisci GATEWAY_NAME con il nome del gateway.

    2. Applica il manifest store-route.yaml:

      kubectl apply -f store-route.yaml

  2. Definisci il GCPRoutingExtension.

    1. Salva la configurazione GCPRoutingExtension nel file di esempiogcp-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

      Sostituisci GATEWAY_NAME con il nome del gateway.

    2. Applica il manifest di esempio al cluster:

      kubectl apply -f gcp-routing-extension.yaml

  3. Verifica la configurazione di GCPRoutingExtension e la relativa associazione al gateway.

    1. Controlla il deployment di GCPRoutingExtension:

      kubectl describe gcproutingextension my-gateway-extension

      L'output è simile al seguente:

      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>

      L'output mostra i dettagli del GCPRoutingExtension, denominato my-gateway-extension, nello spazio dei nomi predefinito. L'output mostra il campo Spec, che contiene la definizione del comportamento dell'estensione.

    2. Verifica l'associazione del gateway:

      1. Verifica che GCPRoutingExtension sia associato al gateway. L'operazione potrebbe richiedere alcuni minuti:

        kubectl describe gateway GATEWAY_NAME

        L'output è simile al seguente:

        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
...

        L'output mostra le annotazioni, che GKE utilizza per memorizzare i collegamenti tra il gateway e le risorseGoogle Cloud sottostanti. L'annotazione networking.gke.io/lb-route-extensions conferma il binding del gateway a GCPRoutingExtension.

      2. Controlla lo stato dell'estensione verificando che GCPRoutingExtension abbia uno stato Reconciled con il motivo ReconciliationSucceeded. L'esecuzione di questo comando potrebbe richiedere alcuni minuti.

        kubectl describe gcproutingextension my-gateway-extension

        L'output è simile al seguente:

        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

        Il campo Status.Conditions mostra una condizione Reconciled con Status: True e Reason: ReconciliationSucceeded.

        Vero e Motivo: ReconciliationSucceeded. Queste informazioni confermano che l'estensione è stata applicata correttamente.

  4. Invia traffico alla tua applicazione.

    Dopo aver eseguito il deployment di gateway, route e applicazione nel cluster, puoi trasmettere il traffico all'applicazione.

    1. Per accedere all'applicazione, devi trovare l'indirizzo IP del gateway.

      Nel terminale, utilizza il seguente comando:

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

      Sostituisci GATEWAY_NAME con il nome del gateway.

      Questo comando restituisce l'indirizzo IP del gateway. Nei comandi successivi, sostituisci GATEWAY_IP_ADDRESS con l'indirizzo IP dell'output.

    2. Testa l'aggiornamento del percorso passando alla versione serviceextensions del servizio dello store all'indirizzo store.example.com/serviceextensions:

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

      L'output è simile al seguente:

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

Configura GCPTrafficExtension

Puoi utilizzare un GCPTrafficExtension per usufruire delle funzionalità avanzate di gestione del traffico all'interno del tuo Google Cloud ambiente. Puoi configurare questa estensione su bilanciatori del carico delle applicazioni esterni globali, bilanciatori del carico delle applicazioni esterni regionali e bilanciatori del carico delle applicazioni interni regionali. Puoi utilizzare GCPTrafficExtension per implementare logica personalizzata per richieste e risposte, routing sofisticato, trasformazioni e criteri di sicurezza.

  1. Aggiorna HTTPRoute. Modifica HTTPRoute in modo da includere nomi host o percorsi che attiveranno l'estensione del traffico.

    1. Salva il seguente manifest di esempio come file 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

      Sostituisci GATEWAY_NAME con il nome del tuo gateway, ad esempio internal-http, external-http o global-external-http.

    2. Applica il manifest store-route.yaml al cluster:

      kubectl apply -f store-route.yaml

  2. Definisci il GCPTrafficExtension.

    1. Salva la configurazione GCPTrafficExtension nel file gcp-traffic-extension.yaml di esempio:

      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

      Sostituisci GATEWAY_NAME con il nome del gateway, come internal-http, external-http o global-external-http.

    2. Applica il manifest di esempio al cluster:

      kubectl apply -f gcp-traffic-extension.yaml

  3. Verifica la configurazione di GCPTrafficExtension e la relativa associazione al gateway.

    1. Controlla il deployment di GCPTrafficExtension:

      kubectl describe gcptrafficextension my-traffic-extension

      L'output è simile al seguente:

      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>

      L'output mostra i dettagli dell'GCPTrafficExtension my-traffic-extension nello spazio dei nomi predefinito. Mostra il campo Spec, che contiene la definizione del comportamento dell'estensione.

    2. Verifica l'associazione del gateway:

      Verifica che GCPTrafficExtension sia associato al gateway. Il completamento di questo comando potrebbe richiedere alcuni minuti:

      kubectl describe gateway GATEWAY_NAME

      L'output è simile al seguente:

      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
...

      L'output mostra le annotazioni, che GKE utilizza per memorizzare i link tra il gateway e le risorse Google Cloud sottostanti. L'annotazione networking.gke.io/lb-traffic-extensions conferma il binding.

    3. Controlla lo stato dell'estensione:

      Verifica che GCPTrafficExtension abbia uno stato Reconciled con il motivo ReconciliationSucceeded. Il completamento di questo comando potrebbe richiedere alcuni minuti.

      kubectl describe gcptrafficextension my-traffic-extension

      L'output è simile al seguente:

      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

      Il campo Status.Conditions mostra una condizione Reconciled con Status: True e Reason: ReconciliationSucceeded. Queste informazioni confermano che l'estensione è stata applicata correttamente.

  4. Invia traffico alla tua applicazione.

    Dopo aver eseguito il deployment di gateway, route e applicazione nel cluster, puoi trasmettere il traffico all'applicazione.

    1. Per accedere all'applicazione, devi trovare l'indirizzo IP del gateway.

      Nel terminale, utilizza il seguente comando:

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

      Sostituisci GATEWAY_NAME con il nome del gateway.

      Questo comando restituisce l'indirizzo IP del gateway. Nei comandi successivi, sostituisci GATEWAY_IP_ADDRESS con l'indirizzo IP dell'output.

    2. Testa l'aggiornamento del percorso passando alla versione serviceextensions del servizio dello store all'indirizzo store.example.com/serviceextensions:

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

      L'output è simile al seguente:

      {
*   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
}

Risolvere i problemi relativi alle estensioni di traffico nei gateway

Questa sezione fornisce suggerimenti per la risoluzione dei problemi relativi alla configurazione delle estensioni di traffico su Gateway.

Gateway non trovato

Il seguente errore indica che la risorsa Gateway specificata nel campo targetRefs della risorsa GCPTrafficExtension o GCPRoutingExtension non esiste:

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

Per risolvere il problema, assicurati che la risorsa Gateway specificata nel campo targetRefs della risorsa GCPTrafficExtension o GCPRoutingExtension esista nello spazio dei nomi specificato.

Servizio o porta del servizio non trovati

Il seguente errore indica che il servizio o la porta del servizio specificati nel backendRef campo della risorsa GCPTrafficExtension o GCPRoutingExtension non esiste:

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

Per risolvere il problema, assicurati che il servizio e la porta del servizio specificati nel campo backendRef della risorsa GCPTrafficExtension o GCPRoutingExtension esistano nello spazio dei nomi specificato.

Nessun endpoint di rete nel NEG

Il seguente errore indica che non sono presenti endpoint di rete nel gruppo NEG associati al servizio specificato nel campo backendRef della risorsa GCPTrafficExtension o 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"

Per risolvere il problema, assicurati che il servizio specificato nel campo backendRef della risorsa GCPTrafficExtension o GCPRoutingExtension abbia endpoint di rete.

Nessuna risposta o risposta con un errore durante l'invio della richiesta

Se non ricevi una risposta o se ricevi una risposta con un errore quando invii una richiesta, è possibile che il servizio di callout non funzioni correttamente.

Per risolvere il problema, controlla la presenza di errori nei log del servizio di callout.

Codice di errore 404 nel payload JSON

Il seguente errore indica che il servizio di callout non è stato trovato o non risponde alla richiesta:

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

Per risolvere il problema, assicurati che il servizio di callout sia in esecuzione, che ascolti sulla porta corretta e che sia configurato correttamente nella risorsa GCPTrafficExtension o GCPRoutingExtension.

Codice di errore 500 nel payload JSON

Il seguente errore indica che il servizio di callout sta riscontrando un errore interno del server:

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

Per risolvere il problema, controlla i log del servizio di callout per identificare la causa dell'errore interno del server.

Passaggi successivi