What an Ingress actually does
An Ingress is an API object that manages external access to services in a cluster, typically HTTP. It maps traffic to backends based on rules you define through the Kubernetes API, and it may provide load balancing, SSL termination, and name-based virtual hosting. That is the whole job, and the critical fact about it is in the first line of the Kubernetes documentation: an Ingress resource on its own does nothing. You must have an Ingress controller to satisfy it — only creating the resource has no effect. The controller is the software that watches the Ingress objects and configures a load balancer, a proxy, or an edge router to implement them.
The Ingress API has one more property that decides every new deployment: it is frozen. The Kubernetes project recommends using the Gateway API instead of Ingress, and states plainly that the Ingress API is generally available and will not be removed, but is no longer being developed. A controller that only speaks Ingress is a controller on a frozen API. Every controller in this comparison now speaks the Gateway API as well, and the migration question is when, not whether.
The three controllers in one paragraph each
Ingress NGINX Controller is F5's NGINX-based controller, and it is not the same software as the community ingress-nginx project despite the shared name — F5's documentation ships a migration guide between the two, which is the first thing to check if you inherited a cluster and do not know which one you run. The open-source edition is free under Apache 2.0; NGINX Plus is the commercial edition with support and additional features, priced on application rather than published. Configuration runs through Ingress resources plus F5's own VirtualServer and VirtualServerRoute custom resources, with annotations, snippets, and Policy resources for the behaviour that does not fit in the standard API.
Traefik Proxy is a single Go binary from Traefik Labs, MIT-licensed, that configures itself by watching providers: Docker labels, Kubernetes Ingress and Gateway API resources, its own IngressRoute custom resources, Consul, ECS, and others. Pointing Traefik at the orchestrator is the only configuration step it asks for. It ships as the default ingress controller in k3s. Middlewares — rate limiting, circuit breaking, basic and forward authentication, compression, redirects — attach to routes as composable units, and built-in ACME support requests and renews TLS certificates from Let's Encrypt automatically. Traefik Hub is the separate commercial product for API management; the proxy itself costs nothing.
Istio is a service mesh first and a gateway second. A control plane, istiod, configures Envoy proxies that run as sidecars beside every workload pod, and the gateway is one of those proxies placed at the edge. Its scope is both north-south gateway traffic and east-west service-to-service traffic, with mutual TLS, authorisation policy, and observability across the mesh. Istio supports the Gateway API and is moving toward making it the default, while keeping its own CRDs — VirtualService, DestinationRule — for advanced behaviour the spec does not yet cover. It is open source under Apache 2.0 and a CNCF graduated project. Ambient mode removes the per-pod sidecar in favour of waypoint proxies, which changes the cost math below.
| Attribute | Ingress NGINX Controller | Traefik Proxy | Istio Gateway | Authority |
|---|---|---|---|---|
| Vendor / licence | F5; OSS free under Apache 2.0, NGINX Plus commercial | Traefik Labs; MIT, free; Hub commercial | CNCF graduated; Apache 2.0, free | NGINX docs; Traefik docs; Istio docs |
| Architecture | NGINX data plane, controller configures it | Single Go binary, control and data plane in one | istiod control plane + Envoy sidecars (or ambient waypoint proxies) | Vendor docs |
| Route definition | Ingress + VirtualServer / VirtualServerRoute CRDs | Ingress, Gateway API, IngressRoute CRD, Docker labels | Gateway API + VirtualService / DestinationRule CRDs | Kubernetes docs; vendor docs |
| TLS certificates | cert-manager or NGINX Plus features | Built-in ACME, automatic Let's Encrypt | cert-manager or Istio's own issuance | Traefik docs; Istio docs |
| Beyond ingress | No — gateway only | No — gateway only | Full mesh: mTLS, policy, observability | Istio docs |
| Gateway API | Supported | Supported | Supported, moving to default | Kubernetes docs; vendor docs |
The cost math: one workload, three bills
The workload is a public API behind a single load balancer: 100 million requests a month, 1 KB average response, 50 new connections a second, 3,000 active connections a minute, 10 routing rules per request. AWS prices an Application Load Balancer at $0.0225 per hour plus $0.008 per Load Balancer Capacity Unit-hour, and charges only on the dimension with the highest usage. One LCU contains 25 new connections a second, 3,000 active connections a minute, 1 GB of processed bytes an hour, and 1,000 rule evaluations a second.
The four dimensions for this workload: new connections, 50 / 25 = 2.00 LCUs; active connections, 3,000 / 3,000 = 1.00 LCU; processed bytes, 100 million × 1 KB = 100 GB a month, or 0.14 GB an hour = 0.14 LCU; rule evaluations, 0.00 LCU — AWS allows 10 free rules per request, and this workload configures exactly 10. The highest dimension is new connections at 2 LCUs:
At ten times the volume — 1 billion requests a month, 10 KB average response, 500 new connections a second, 30,000 active connections a minute — the dimensions become 20.00, 10.00, 13.70, and 0.00 LCUs, the rule evaluations still inside the 10 free rules. The highest is again new connections, at 20 LCUs:
The load balancer's bill grows with the busiest dimension, not with the request count alone. Long-lived connections pay on active connections; heavy responses pay on processed bytes; connection churn pays on new connections. Price the dimension you actually stress, and run the website cost estimator with your own traffic shape before you commit to a number.
NGINX Ingress Controller and Traefik Proxy have no per-request meter at all. The open-source editions are free, so their marginal cost on nodes you already run is $0 — the bill is the node capacity they consume, which on a cluster that already runs the workloads is a rounding error. The honest comparison is not $28.11 against $0; it is $28.11 against the engineering time to operate a controller yourself, plus the cloud load balancer you still need in front of it in most managed clusters, because the controller needs a public IP.
Istio's cost is a resource tax, not a bill. Each sidecar reserves 100 millicores of CPU and 128 MiB of memory by default. Fifty pods carry fifty sidecars: 5 vCPU and 6.4 GiB reserved before any application code runs. On a three-node cluster of 4 vCPU and 16 GiB nodes — 12 vCPU and 48 GiB in total — the sidecars consume 42% of the cluster's CPU capacity and 13% of its memory. That is the price of the mesh, paid in node capacity rather than dollars, and it is why ambient mode matters: waypoint proxies replace the per-pod sidecar. Size the mesh on the sidecar count, not on the request count.
The limits that decide for you
The Ingress resource only routes HTTP and HTTPS. Exposing anything else — a raw TCP database, a UDP game server — requires a Service of type NodePort or LoadBalancer, or a controller-specific TCP/UDP feature. Traefik and Istio handle TCP and UDP natively; Ingress NGINX Controller handles them through ConfigMap-based passthrough. If the workload is not HTTP, the Ingress API was never the tool.
Path matching is the second limit, and it is where migrations break. Ingress paths have three types: Exact, Prefix, and ImplementationSpecific. Prefix matching is element-wise, not string matching — /foo matches /foo/bar but not /foo/barbaz — and when several paths match, the longest wins, with Exact beating Prefix on a tie. Host wildcards cover a single DNS label: *.foo.com matches bar.foo.com but not baz.bar.foo.com and not foo.com. Every controller implements these rules, but ImplementationSpecific means whatever the controller decides, so a migration must re-test every path.
The third limit is annotation drift. Ingress controllers configure behaviour the standard API does not cover through annotations, and each controller's annotations are its own dialect. An NGINX rewrite-target annotation means nothing to Traefik; a Traefik middleware annotation means nothing to Istio. The Gateway API exists to end this: it standardises the route, the filter, and the attachment point, so the same configuration works across controllers. That is the concrete reason the Kubernetes project froze Ingress — the annotation dialects had become the API.
The migration sequence that actually works
Step 1 — Identify what you actually run. Check whether the cluster runs the community ingress-nginx or F5's NGINX Ingress Controller, Traefik, or Istio — the names overlap and the migration path depends on the answer. List every annotation in use.
Step 2 — Stand up the Gateway API alongside Ingress. Install the Gateway API CRDs and the new controller in the same cluster, behind a separate hostname. Do not touch the existing Ingress routes.
Step 3 — Translate one route, then test it. Convert a single low-traffic route to a Gateway API HTTPRoute, including its TLS, path rules, and middleware equivalent. Test the path matching — /foo must not match /foo/barbaz — and confirm the wildcard host behaves as a single label.
Step 4 — Move traffic by DNS weight. Shift a fraction of traffic to the new gateway by DNS, watch error rates and latency for a full business cycle, then move the rest. Keep the old Ingress routes until the new gateway has served 100% of traffic for a week.
Step 5 — Price the new steady state. Recompute the load balancer bill on the highest LCU dimension at the new traffic level, and the sidecar reservations if the move involved Istio. The migration is not done until the bill is measured, not estimated.
Step 6 — Retire the old controller. Delete the Ingress resources and the old controller only after the new gateway has run clean for a week. Leave the Gateway API CRDs and the controller's own CRDs — the new source of truth.
Founder & CEO Insight — Enow A. Jovial
The ingress migration checklist
- [x] Controller identified: community ingress-nginx, F5 NGINX Ingress Controller, Traefik, or Istio — confirmed from the running deployment, not from memory.
- [x] Annotations inventoried: every controller-specific annotation listed, with its Gateway API equivalent or its documented gap.
- [x] Gateway API installed: CRDs present, new controller running behind a separate hostname, old routes untouched.
- [x] One route translated and tested: path matching verified element-wise, wildcard host verified as a single label, TLS verified end to end.
- [x] Traffic moved by DNS weight: fraction first, full business cycle observed, 100% for a week before the old controller is touched.
- [x] Bill measured: load balancer cost recomputed on the highest LCU dimension, sidecar reservations recomputed if Istio is involved.
- [x] Old controller retired: Ingress resources and old controller deleted only after a clean week on the new gateway.
For the cluster underneath the gateway, the EKS vs GKE vs AKS managed Kubernetes pricing playbook prices the control planes and node pools the controller runs on. For the edge caching in front of the gateway, the Cloudflare vs Fastly vs AWS CloudFront CDN pricing playbook prices the delivery layer. The gateway is one hop in a chain — price the chain, not the hop.

