Gateway API has emerged as the direction of travel for Kubernetes networking. The more consequential question now is implementation: does a controller treat Gateway API as its native model, or layer it onto years of Ingress-era behavior?
That distinction affects security, scalability, and day-two operations. F5 NGINX Gateway Fabric (NGF) was built around Gateway API from the start. It does not have to reconcile Gateway API with a legacy Ingress control model.
The Ingress annotation debt
Kubernetes Ingress was intentionally minimal: host and path routing, TLS termination, and basic load balancing. More advanced behavior had to be expressed elsewhere.
In practice, that meant annotations.
Header-based routing, traffic splitting, gRPC, rate limiting, custom rewrites—each controller added its own annotation vocabulary. The result was functional but brittle: unstructured strings, controller-specific semantics, weak validation, and Ingress manifests that accumulated operational debt over time.
The Kubernetes project has frozen Ingress development and directs users toward Gateway API. NGINX’s overview explains the broader transition.
This is not just a configuration hygiene issue. It has security implications.
In March 2025, Wiz Research disclosed IngressNightmare, a set of vulnerabilities in the community-maintained kubernetes/ingress-nginx controller. Its most serious issue, CVE-2025-1974, received a 9.8 CVSS score; under certain conditions, it allowed a workload with pod-network access to compromise a cluster without credentials. The underlying pattern involved annotation values being incorporated into generated NGINX configuration without sufficient sanitization. Kubernetes documented the vulnerability and required mitigations. A later issue, CVE-2026-3288, involved the rewrite-target annotation. SentinelOne’s advisory describes that issue.
An important distinction: these CVEs affected the community kubernetes/ingress-nginx project, not F5 NGINX Ingress Controller (NIC), which is separately developed and maintained.
The larger lesson is architectural. When unstructured annotations become a configuration-generation language, they create a class of input-validation and injection risk that must be defended continuously. Combining that model with legacy Ingress support, proprietary CRDs, and Gateway API in one controller increases both implementation complexity and the security surface.
Gateway API as the native model
NGF starts from a different premise: Gateway API is the configuration model.
Capabilities that previously lived in annotation strings—rewrites, redirects, header manipulation, weighted traffic distribution, and gRPC routing—are represented through typed, validated Gateway API resources and fields. This makes configuration more portable, reviewable, and predictable.
The difference is not that Gateway API eliminates the need for sound security practices. It reduces reliance on opaque, vendor-specific strings as a primary mechanism for expressing traffic policy.
NGF can use either NGINX Open Source or NGINX Plus as the data plane without changing the Gateway API configuration model. Teams can begin with open source and adopt NGINX Plus later while keeping their Gateway, Route, and Policy resources intact.
NGINX Plus adds enterprise capabilities such as:
- Dynamic upstream reconfiguration as Pods scale, without requiring an NGINX reload
- Additional Prometheus metrics and live activity monitoring
- Latency-aware load balancing
- Cookie-based session persistence
- F5 WAF for NGINX through WAFPolicy resources
The value is not merely a longer feature list. It is the ability to change the data-plane capability level without forcing application teams to relearn the configuration model. NGF’s NGINX Plus documentation covers the available capabilities.
Separate planes, clearer boundaries
NGF 2.0 introduced a distributed architecture in June 2025. Rather than running the configuration controller and NGINX traffic-processing container together, NGF provisions a dedicated NGINX data-plane deployment for each Gateway object. That lets teams scale the control plane and individual Gateway data planes independently. F5 DevCentral’s release announcement describes the model.
That separation also creates a meaningful security boundary.
The control plane holds the Kubernetes API and Secret access required to reconcile configuration. The data plane handles live traffic. Separating their responsibilities reduces the consequences of a compromise in either layer:
- A compromised data plane does not automatically inherit the control plane’s Kubernetes API and Secret access.
- A compromised control plane is not itself the live traffic-serving process.
- Each Gateway can have a separately managed and scaled data-plane deployment.
This is a more resilient default than a monolithic model in which one component both renders configuration and directly serves traffic.
The performance argument is similarly architectural. A controller dedicated to Gateway API reconciliation has one API model to interpret. It is not simultaneously translating legacy Ingress resources, proprietary controller CRDs, and Gateway API resources into a shared runtime configuration. As clusters grow and configuration churn rises, reducing that reconciliation complexity matters.
NIC is a bridge, not a dead end
For organizations already using F5 NGINX Ingress Controller, Gateway API adoption does not need to be a disruptive reset.
NIC’s VirtualServer and VirtualServerRoute resources provide a structured alternative to raw Ingress manifests. They support advanced routing patterns such as traffic splitting and content-based routing, while establishing a hierarchical delegation model. The NIC documentation details those resources.
A VirtualServer owns host-level concerns such as TLS, listeners, and top-level routing. It can delegate a path to a VirtualServerRoute, including across namespaces. That is not a literal implementation of Gateway API’s role model, but it prepares teams for the same separation of responsibility:
| Concern | NIC model | Gateway API model |
|---|---|---|
| Shared infrastructure | VirtualServer host, TLS, and listener configuration | Gateway and GatewayClass |
| Application routing | Delegated VirtualServerRoute | HTTPRoute, GRPCRoute, and other Route resources |
| Team boundaries | Delegation across namespaces | Attachment, namespace, and policy controls |
That familiarity is valuable during migration. Gateway API places certificates on the Gateway, rather than attaching them directly to individual application routes. Teams moving from annotation-heavy Ingress configurations may need to rethink certificate automation and ownership boundaries. This migration discussion highlights that operational shift.
Teams already using NIC’s delegated resources have typically done much of the organizational and conceptual work.
A practical migration path
The urgency is real for users of the community ingress-nginx project. In November 2025, SIG Network and the Kubernetes Security Response Committee announced its retirement and advised users to begin migrating. End of life and the end of security patches were targeted for March 2026. Kubernetes announced the retirement. Additional migration context is available here.
F5 NGINX Ingress Controller remains actively maintained. It can be the stable operating environment for teams that need to continue using Ingress while they plan a measured move to Gateway API.
The practical migration tooling is already available. Kubernetes SIG Network’s ingress2gateway project can convert Ingress resources to Gateway API resources, and its NGINX provider supports migration workflows for NGINX projects. NGF documentation covers the process.
ingress2gateway print \ --providers=nginx \ --input-file=<your-ingress-file> \ > gateway-api-resources.yaml
The provider translates supported annotation-based behavior into typed Gateway API constructs. Examples include:
- ssl-services to BackendTLSPolicy
- grpc-services to GRPCRoute
- Rewrite annotations to an HTTPRoute URLRewrite filter
- redirect-to-https to a RequestRedirect filter
NGINX’s migration guidance explains the mappings in more detail.
A low-risk sequence looks like this:
- Inventory current Ingress resources, annotations, TLS ownership, and nonstandard routing behavior.
- Deploy NGF alongside the existing controller.
- Convert and validate workloads in a non-production environment.
- Shift production traffic progressively, using canary or staged cutover patterns.
- Decommission the legacy controller only after functional and operational validation.
NIC and NGF are separate products that can run side by side, making a parallel migration possible.
Staying within the NGINX ecosystem also preserves familiar data-plane behavior. Existing knowledge of TLS handling, buffering, headers, timeouts, and NGINX operational practices transfers more directly than it would in a move to a fundamentally different proxy engine.
NGF is also where Gateway API-aligned capabilities continue to arrive. NGF 2.3.0, released in December 2025, added support for multiple InferencePool backends through the Gateway API Inference Extension, upstream mTLS using BackendTLSPolicy, and customizable access logging. NGINX’s release post covers those additions.
Choose the cleaner foundation
An all-in-one controller can look convenient: one install for Ingress, proprietary CRDs, and Gateway API. But supporting every generation of Kubernetes traffic management in one control plane carries a cost—more translation logic, more compatibility behavior, and a broader surface to operate and secure.
The better long-term model is straightforward:
- Use F5 NGINX Ingress Controller where Ingress remains the right operational choice today.
- Use its structured CRDs to establish clearer ownership and delegation.
- Move to NGINX Gateway Fabric when Gateway API is the target architecture.
- Use ingress2gateway and parallel deployment to make the transition controlled rather than disruptive.
A controller that supports everything is not necessarily a platform with the cleanest path forward. NGF’s value is not that it asks teams to give up capability. It gives them a way to stop carrying configuration and operational baggage that Gateway API was designed to replace.