IBRAVRA Media Network
Comparisons • 12 min read

Kubernetes Ingress: NGINX vs Traefik vs Istio Gateway Playbook

Three controllers answer the same question — how traffic reaches a service inside a Kubernetes cluster — with different architectures and different bills. This playbook prices one workload three ways, runs the limits that decide, and gives the Gateway API migration sequence that works.

By Enow A. Jovial • Published 2026-11-17
Three controllers answer the same question — how does traffic from the internet reach a service inside a Kubernetes cluster — and they answer it with different architectures, different licences, and different bills. Ingress NGINX Controller is the F5-built NGINX controller with VirtualServer custom resources and a commercial Plus edition. Traefik Proxy is a single MIT-licensed Go binary that discovers routes from the orchestrator and issues its own TLS certificates. Istio is a full service mesh whose gateway is one feature of a platform that also encrypts, observes, and polices east-west traffic. The worked cost math below prices the same workload three ways: 100 million requests a month costs $28.11 on an AWS Application Load Balancer, $0 in licence fees on NGINX or Traefik running on nodes you already pay for, and 5 vCPU plus 6.4 GiB of sidecar reservations on Istio. And the Kubernetes project itself has already made one decision for you: the Ingress API is frozen, and new work belongs on the Gateway API.

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.

Kubernetes Ingress documentation: the project recommends the Gateway API instead of Ingress, and the Ingress API has been frozen
Kubernetes Ingress documentation: the project recommends the Gateway API instead of Ingress, and the Ingress API has been frozen

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.

AttributeIngress NGINX ControllerTraefik ProxyIstio GatewayAuthority
Vendor / licenceF5; OSS free under Apache 2.0, NGINX Plus commercialTraefik Labs; MIT, free; Hub commercialCNCF graduated; Apache 2.0, freeNGINX docs; Traefik docs; Istio docs
ArchitectureNGINX data plane, controller configures itSingle Go binary, control and data plane in oneistiod control plane + Envoy sidecars (or ambient waypoint proxies)Vendor docs
Route definitionIngress + VirtualServer / VirtualServerRoute CRDsIngress, Gateway API, IngressRoute CRD, Docker labelsGateway API + VirtualService / DestinationRule CRDsKubernetes docs; vendor docs
TLS certificatescert-manager or NGINX Plus featuresBuilt-in ACME, automatic Let's Encryptcert-manager or Istio's own issuanceTraefik docs; Istio docs
Beyond ingressNo — gateway onlyNo — gateway onlyFull mesh: mTLS, policy, observabilityIstio docs
Gateway APISupportedSupportedSupported, moving to defaultKubernetes 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:

ALB=($0.0225×730)+(2×730×$0.008)=$16.43+$11.68=$28.11/month\text{ALB} = (\$0.0225 \times 730) + (2 \times 730 \times \$0.008) = \$16.43 + \$11.68 = \$28.11\text{/month}

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:

ALB at 10x=$16.43+(20×730×$0.008)=$16.43+$116.80=$133.23/month\text{ALB at 10x} = \$16.43 + (20 \times 730 \times \$0.008) = \$16.43 + \$116.80 = \$133.23\text{/month}
AWS Application Load Balancer pricing example: the hourly bill is the highest of the four LCU dimensions, at $0.0225 per hour plus $0.008 per LCU-hour
AWS Application Load Balancer pricing example: the hourly bill is the highest of the four LCU dimensions, at $0.0225 per hour plus $0.008 per LCU-hour

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.

Two mistakes in this comparison are expensive and silent. The first is deploying a new cluster on the Ingress API in 2026 and discovering a year later that the feature you need — header-based routing, request mirroring, weighted canary splits — exists only in the Gateway API, and your controller's Ingress annotations cannot express it. The second is adopting Istio for the gateway alone: you pay the full sidecar tax, the control-plane operations, and the upgrade cycle of a service mesh for a feature that NGINX or Traefik delivers as a single binary. Adopt Istio when you need the mesh — mutual TLS between services, authorisation policy, traffic observability — and adopt a gateway when you need a gateway.

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

"Every cluster I have inherited had the same story: somebody picked an ingress controller because it was the default in the distribution, and three years later the team was maintaining annotation folklore nobody could explain. The controller is not a default. It is the front door of everything you run, and the front door decides what your TLS looks like, what your canary deploys look like, and what your bill looks like. Pick it the way you would pick a front door: on the traffic you actually have, the routes you actually need, and the team that has to operate it at 2 a.m. — not on which one shipped with the installer."
— Enow A. Jovial, Founder & Chief Executive Officer

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.

If the cluster is small and the team is smaller, start with Traefik. A single binary, automatic TLS, and configuration that lives next to the workload is the lowest operational load of the three, and it speaks the Gateway API when the team is ready to standardise. Move to NGINX when you need its configuration depth and commercial support, and to Istio when you need the mesh.