TL;DR
- kube-proxy is the Kubernetes component that runs on every node and turns a Service object into the packet-routing rules that make a cluster IP reachable, and the ipvs mode of kube-proxy is one of the three engines it can use to do that.
- SIG Network plans to remove the ipvs mode in Kubernetes 1.40, after deprecating it in 1.35, because the kernel IPVS API never matched the Kubernetes Services API closely enough.
- The ipvs mode existed to fix two iptables scaling problems: rule matching that grew linearly with the number of services, and a full ruleset rewrite every time a service or endpoint changed.
- The IPVS interface has no batch update, so large bursts of changes could take longer to apply; the mode also fell back to iptables for Service features beyond basic load balancing.
- The recommended migration is nftables mode on Kubernetes 1.36 or later with kernel 5.13 or later, and iptables mode for older nodes, with a reboot of each node after the configuration change.
- The project's own latency chart shows nftables mode performing very slightly better than ipvs mode in its first-packet test at 5k, 10k and 30k services; these measurements cover only that benchmark profile.
- Before the 1.40 upgrade, check the proxy mode your control plane actually deploys, the kernel version on each node group, and whether a managed cluster sets that mode for you.
Page capture of the post "Scheduling the removal of the kube-proxy IPVS backend", published 16 November 2026 by Dan Winship for SIG Network. Source: kubernetes.io/blog/2026/11/16/ipvs-removal, captured 17 November 2026.
A cluster IP address is the most ordinary thing in Kubernetes and the least obvious. It belongs to no process, exists on no single machine, and resolves to whatever a kube-proxy process wrote into the packet-filtering rules of the node that happens to receive the connection. Those rules are what the proxy mode selects, and Kubernetes has now set a date for retiring one of the three implementations.
Why kube-proxy had three backends
The iptables backend of 2017 had two separate scaling problems, and the project's own account separates them carefully. Data-plane latency grew because every new connection had to be matched against a chain of rules whose length was O(n) in the number of services in the cluster. Control-plane latency was even larger because kube-proxy rewrote the entire iptables ruleset whenever any service or endpoint changed. The cost of processing that updated ruleset grew faster than the number of endpoints, and in very large clusters kube-proxy could burn a full core continuously just to process updates.
Netics visual, 17 November 2026: the proxy mode is the engine kube-proxy runs on each node to turn a Service into routing rules, and Kubernetes ships three of them.
The ipvs mode addressed both. The kernel IPVS subsystem looks up service addresses in hash tables, which removed the linear scan from the data path, and it does not rewrite the whole ruleset on every change, largely because its API offers no batch operation to rewrite with. That constraint came back later as a design cost.
The architectural limits of IPVS mode
Compatibility came first. The first version of the backend did not match the iptables behaviour completely, and the assumption was that the gaps would close over time. The original authors moved on to work outside the Kubernetes ecosystem, and finding maintainers took a while, which the post states plainly as one reason the gaps stayed open.
The deeper limit was architectural. Since the IPVS interface is narrow, the backend had to fall back to iptables for Service features beyond basic load balancing, and although it used ipset for some of those rules, ipset shares the same missing batch-update API. So the backend inherited part of the scaling problem it was written to escape. Red Hat's plan to remove the iptables API from Red Hat Enterprise Linux reaches the same code from a second direction: a backend that depends on iptables will not be available on RHEL at all.
Page capture of the Kubernetes documentation page that defines virtual IPs, Service implementations and proxy modes. Source: kubernetes.io/docs/reference/networking/virtual-ips, captured 17 November 2026.
One more expectation had to be corrected publicly. Teams valued the policy-based endpoint selection offered by the IPVS schedulers. iptables and nftables use random selection. kube-proxy is a distributed service spread across every node, and its processes do not share scheduler state, so each node picks endpoints blind to what the other nodes are doing. The post uses the mh scheduler, built on Maglev hashing, as the example: it is efficient inside a specific two-layer load-balancer design, and kube-proxy cannot act as either of those layers.
What changes in 1.40 and what stays
The nftables backend landed in Kubernetes 1.29, graduated to general availability in 1.33, and is feature complete. The ipvs backend was formally deprecated as of 1.35, where kube-proxy still runs it and prints a deprecation warning. Removal is planned for 1.40.
The migration changes the node-level engine that renders Service objects into rules and preserves the Services API behaviour for objects, endpoints, cluster IPs, session affinity and the rest of the object model. That distinction matters for planning: application teams keep the same Services API behaviour. Platform teams own the configuration that determines whether an upgrade breaks traffic.
Netics visual, 17 November 2026: what ipvs mode carried until 1.39 and what the two maintained backends offer from 1.40.
How a migration to nftables runs
The project gives two paths, and the choice depends on the node platform. On Kubernetes 1.36 or later with a Linux distribution running kernel 5.13 or later, nftables mode is the recommendation. In a kubeadm cluster the change is a ConfigMap edit: set mode: nftables in the kube-proxy configuration and restart the kube-proxy pods. Any ipvs-specific settings that were overridden have to be translated to their nftables equivalents at the same time, which is where an inherited cluster usually needs a real review.
Older nodes take the second path. The iptables backend has been reworked since 2017 in four specific ways: redundant rules removed, rule generation made cheaper, resyncing changed so kube-proxy assumes the current state is correct and only reads the ruleset when an update fails, and updates limited to the services and endpoints that changed. Even reading an iptables ruleset is slow on a large cluster, so that last change is the one that recovered the most time. For this path the post recommends a reboot of each node after the configuration change.
Netics visual, 17 November 2026: the deprecation in 1.35, the nftables target on 1.36 with kernel 5.13, and the removal in 1.40.
What the latency chart shows and hides
The post publishes one chart, first-packet round-trip latency by percentile, with p01, p50, p90 and p99 groups at 5k, 10k and 30k services. The author presents the chart as evidence that nftables has very slightly better performance than ipvs in this first-packet test. The bars support that reading, and the p50 group, which measures average connection-establishment latency, sits in the same range across both backends.
The limits of that evidence belong in the same paragraph as the finding. The chart covers three cluster sizes, one profile per backend and variation in connections. Memory use, endpoint churn and distributions with kernels below 5.13 remain outside its scope. Teams operating beyond the chart's 30k-service range have to measure their own clusters.
What to check before the 1.40 upgrade
Start with the mode each cluster actually deploys; the repository can specify a different mode. A kube-proxy ConfigMap, a --proxy-mode flag in a systemd unit, and a managed control plane's own default can disagree, and managed services configure this layer themselves, so the vendor's release notes are the source for those clusters.
Then the node platform. Kernel 5.13 is the floor for the nftables backend, which rules out some older long-term-support distributions still in production, and the iptables path carries its own deadline through Red Hat's removal plan. Replace every node group that lacks a migration path before 1.40 ships.
The post's own chart: first-packet round-trip latency by percentile for ipvs and nftables at 5k, 10k and 30k services. Source: kubernetes.io/blog/2026/11/16/ipvs-removal, retrieved 17 November 2026.
Finally, the rollback question. Changing a proxy mode redirects every new connection on a node, so validate it on a canary node group with real traffic and a known connection-error rate before a fleet-wide rollout. Teams that own their own sovereign infrastructure and cloud exit path should include the node inventory, kernel versions and upgrade window in the migration plan before the proxy mode changes.
The 1.40 release is a deadline for a backend, and the work it forces is an inventory: which nodes run which kernel, which proxy mode the cluster actually gets, and who owns the configuration that decides it.
Originally published on the Netics blog.






Top comments (1)
Good heads-up. The removal in 1.40 after the 1.35 deprecation gives teams a clear window, and the first step is simply finding which clusters still run ipvs mode before an upgrade surprises anyone.