Skip to content
audiotale.net
Sign in
NewsNews

Kubernetes kube-proxy IPVS mode removal: 1.40 off by default, gone in 1.43

Kubernetes SIG Network has scheduled the end of kube-proxy's IPVS backend and tells users to move to nftables or iptables. Here is the timeline, how to check your cluster and how to switch.

audiotale.net team

· 8 min read

Written by AI from the sources linked below. How we use AI

On this page
  1. Key points
  2. What to do
  3. What happened
  4. Background
  5. How it works
  6. What it means
  7. What we don't know yet
  8. What to watch next
  9. Sources

If your Kubernetes cluster runs kube-proxy in ipvs mode, the clock is now running. On 16 November 2026 the Kubernetes project (in a post by Dan Winship of Red Hat for SIG Network) announced that it is scheduling the removal of the kube-proxy IPVS backend, and told every IPVS user to plan a move to the nftables or iptables backends. Nothing breaks today: the backend still works and prints a deprecation warning. But the project's own documentation says IPVS support is switched off by default from Kubernetes 1.40 and deleted from the code in 1.43, so any cluster that wants to keep upgrading will have to change its proxy mode first.

Key points

  • The kube-proxy ipvs mode has been deprecated since Kubernetes 1.35 and the SIG Network post of 16 November 2026 says the project now plans to remove it.
  • The Kubernetes networking documentation says IPVS support is disabled by default from v1.40 (re-enable with the KubeProxyIPVS feature gate) and fully removed in v1.43. The announcement post itself says "1.40" for removal, so the exact end date is worth watching.
  • Kubernetes recommends nftables mode, which needs Linux kernel 5.13 or later and, for best results, Kubernetes 1.36 or later; clusters on older kernels can use iptables mode instead.
  • Switching is a configuration change plus a restart of kube-proxy, but nftables behaves differently from iptables for NodePort addresses, local firewalls and one connection-tracking workaround.
  • The IPVS-only scheduling algorithms (round robin, least connection, source hashing and others) have no direct replacement; the project says they were rarely useful inside kube-proxy anyway.

What to do

Who is affected: anyone running kube-proxy with mode: ipvs. That includes self-managed and kubeadm clusters, and any managed offering that exposes the setting. If you run a managed service, check your provider's documentation, because we found no provider statements in the sources below.

Check your mode. In a kubeadm-style cluster the setting lives in the kube-proxy ConfigMap:

kubectl -n kube-system get configmap kube-proxy -o yaml | grep -E '^\s*mode:'

On a node, ipvsadm -Ln listing virtual servers is another sign that IPVS is in use. If the mode line is empty, kube-proxy uses its default, which in Kubernetes 1.37 is iptables; the docs say a future version will change the default to nftables, and recommend setting the mode explicitly so an upgrade never changes your backend silently.

Choose a target.

  • Kubernetes 1.36 or later, nodes on kernel 5.13 or later: move to nftables. The announcement says there were performance and scaling fixes after the 1.33 GA that were not backported to releases earlier than 1.36.
  • Older Kubernetes or older kernels: move to iptables. The project says it has improved greatly since IPVS was created in 2017 and that many people who found it unusable in the past would not have problems with it now.

Make the change. For kubeadm clusters the post says to change mode: ipvs to mode: nftables in the kube-proxy ConfigMap and restart the kube-proxy pods. If you override IPVS-specific options in the config, change them to the matching nftables ones. For iptables, the project recommends rebooting each node after changing the configuration rather than only restarting kube-proxy. Test on a non-production cluster first.

What happened

The Kubernetes blog post, dated Monday 16 November 2026 and titled "Scheduling the removal of the kube-proxy IPVS backend", sets out the plan in plain terms. The IPVS backend "was an experiment" in giving Kubernetes Services a faster implementation than the iptables backend. It succeeded on speed, the post says, but the kernel IPVS API turned out to be a bad match for the Kubernetes Services API, and the backend was never able to implement all of the edge cases of Service behaviour correctly.

SIG Network, the group that owns kube-proxy, had already deprecated the backend as of Kubernetes 1.35. It still ships, with a warning when kube-proxy starts in IPVS mode. The new post adds the intention to remove it, and the project's Services documentation fills in the dates: disabled by default from 1.40, fully removed in 1.43.

Background

Understanding why this matters means understanding what IPVS was for. kube-proxy is the component on every node that turns a Service's virtual IP into traffic to real pod endpoints. The original iptables backend wrote one rule per Service IP, so a new connection had to be matched against a list that grew with the number of Services, and it rewrote the entire ruleset whenever any Service or endpoint changed. The post says that in very large clusters kube-proxy would use 100% of one CPU just to process iptables updates.

IPVS, a load-balancing subsystem already in the Linux kernel, fixed both problems: it uses hash tables rather than linear lookup, and it does not rewrite everything on each update. The Kubernetes post says that is why people adopted it in big clusters.

The problems arrived later. The first version was not fully compatible with the iptables backend, and the original authors moved on, so for a while nobody maintained it. The IPVS kernel API has no batch updates, so changing many things at once could be slower than with iptables. And because IPVS can only do basic load balancing, kube-proxy still had to fall back to iptables (and ipset) for other Service features, so it inherited some of the same scaling issues.

The post also names an outside pressure: Red Hat plans to remove the iptables API from Red Hat Enterprise Linux, which means the IPVS backend, which depends on iptables for part of its work, would no longer be available to Kubernetes users on RHEL.

The replacement was introduced in Kubernetes 1.29 as an alpha nftables backend and became generally available in 1.33. From the start it was designed to replace both older backends eventually.

How it works

The timeline in KEP-5495, the Kubernetes enhancement proposal for the deprecation, lays out stages by release (the KEP's status page lists it as deprecated):

Release What changes
1.35 Deprecation notices on the website; kube-proxy warns when started in IPVS mode; nftables bug fixes backported to 1.34 and 1.33
1.37 KubeProxyIPVS feature gate added (on by default); docs and warnings state the plan
1.40 Gate flips to off by default; starting IPVS mode without overriding it makes kube-proxy exit with an error listing the valid modes
1.43 The gate stops being locked and the IPVS code is deleted
1.46 Feature gate removed

The KEP says the IPVS code will not move to a separate repository, because nobody plans to maintain it, security fixes included. So after removal there is no community-maintained copy to fall back on.

What about the schedulers? Some users chose IPVS for its choice of scheduling algorithms. The Kubernetes post argues this advantage was mostly illusory: kube-proxy runs separately on every node and the instances do not share IPVS scheduler state, so each node picks endpoints without knowing what the others see. Even Maglev hashing (the mh scheduler), the post says, only pays off in a specific two-layer load balancer design that kube-proxy cannot take part in. iptables and nftables modes select endpoints at random by default.

Where nftables differs. The Services documentation lists behaviour changes for people moving from iptables to nftables, which matter if you are leaving IPVS too:

  • NodePort addresses. In iptables mode NodePort Services answer on all local IP addresses. In nftables mode the default is --nodeport-addresses primary, so only the node's primary IPv4 and IPv6 addresses answer. You can set an explicit value, for example 0.0.0.0/0, to listen on all local IPv4 addresses.
  • Local firewalls. The iptables mode adds rules to accept inbound traffic on each NodePort in case a firewall would block it. That does not work with nftables-based firewalls, so the nftables mode does nothing here: you must allow the NodePort range yourself.
  • Connection tracking. Linux kernels before 6.1 have a bug that can close long-lived TCP connections to Service IPs with "Connection reset by peer". The iptables mode installs a workaround that later caused other problems; nftables mode installs none by default. The docs say to check the iptables_ct_state_invalid_dropped_packets_total metric to see whether you depend on it, and if so to run kube-proxy with --conntrack-tcp-be-liberal.

On speed, the Kubernetes post says nftables has very slightly better connection latency than IPVS, and stresses that the point is that, unlike iptables, it is not slower. It shows the result as a chart but gives no figures in text, so we do not quote numbers. The Services documentation adds that the nftables data-plane advantage only becomes noticeable in clusters with tens of thousands of Services.

What it means

For platform teams, this is a scheduled migration rather than an emergency, but it has a long lead time in practice because kube-proxy sits under all in-cluster traffic. A test on a staging cluster, a rollout node pool by node pool, and a check of firewall and NodePort assumptions are all sensible before 1.40 lands in your upgrade path.

Teams on old distributions have the hardest choice. nftables needs kernel 5.13, so enterprise images with older kernels will have to use iptables, which is the slower option at very large scale. The KEP names kernel age as its main drawback and expects kernels too old for nftables to leave long-term support by the end of 2026.

Teams that chose IPVS for a specific scheduler lose that option. The project's view is that those schedulers did not work well in kube-proxy's distributed design; if you truly depend on one, the realistic alternatives live outside kube-proxy, such as an external load balancer or a service mesh, and you should test them rather than assume parity.

For the wider project, it is another case of a feature being retired when it is not maintained: the KEP says SIG Network had few maintainers who knew the IPVS backend and had been steering bug reports toward nftables.

What we don't know yet

  • The exact removal release. The announcement post says the plan is to remove IPVS in 1.40, while the Services documentation and the KEP say it is disabled by default in 1.40 and the code goes in 1.43. We have taken the documentation and KEP as the detailed schedule, but plans like this can change.
  • Managed services. We found no statements from cloud providers about when their managed Kubernetes offerings will stop supporting IPVS mode or how they will migrate customers.
  • Real-world cost. The sources give no data on how many clusters still run IPVS.

What to watch next

  • The release notes of Kubernetes 1.38 and 1.39 for any change to the schedule.
  • The KubeProxyIPVS gate flipping off in 1.40, and the change of the default proxy mode to nftables planned for a future release.
  • Your distribution's or cloud provider's guidance on proxy modes and kernel versions.
  • Red Hat's progress on removing the iptables API from RHEL.

Sources

Written by

audiotale.net team

The official account of the people who run audiotale.net: announcements, conversation starters and the newsroom's drafts. Posts written with AI say so. Every other account here is a real person.