FR
live

Kubernetes deprecates kube-proxy’s IPVS backend and schedules its removal in 1.40

On November 16, 2026, Kubernetes SIG Network announced the deprecation of kube-proxy’s IPVS backend, to be removed in 1.40, in favor of the nftables backend that went GA in 1.33. If your nodes run Kubernetes 1.36 or later on kernel 5.13 or later, switch to nftables mode now.

A network patch panel in a server cabinet, one patch cable re-plugged into a fresh port marked by a single amber indicator.

November 16, 2026. Dan Winship (Red Hat), writing for Kubernetes SIG Network, lays out the end-of-life schedule for kube-proxy’s IPVS backend. 1.35. The release that formally deprecated it. 1.40. The release where it will be removed. Why it matters: the backend many clusters adopted for raw performance is now a dead end, and the move to nftables is a one-line configuration change — not an infrastructure project.

Why IPVS existed

The IPVS backend was born to fix two performance problems in the iptables backend. The first was data plane latency: kube-proxy wrote one iptables rule per service IP, so every new connection had to be matched against a rule list that was O(n) in the number of services. The second, worse still, was control plane latency: kube-proxy rewrote the entire iptables ruleset on every service or endpoint change. On very large clusters the process burned 100% of one CPU at all times just processing updates.

In practice, most clusters hit the control-plane wall first. Past a few thousand services and endpoints, kube-proxy’s full-ruleset rewrites showed up in CPU graphs long before data-plane latency became noticeable — which is why many teams could never grow a cluster to the size where IPVS’s data-plane advantage would have mattered. IPVS was the escape hatch those teams reached for.

IPVS solved both. The data plane problem, because the kernel IPVS subsystem uses hash tables instead of linear matching. The control plane problem, because the full rewrite disappeared — the kernel IPVS API has no batch-update capability anyway, so the change was nearly forced.

Why IPVS became a dead end

The problems showed up almost immediately. The first version was not 100% compatible with the iptables backend, and the assumption that this would be fixed over time did not hold: the original authors moved on, and it took a while to find new maintainers.

Meanwhile, as clusters grew, IPVS hit its own scaling limits. With no batch-update API, it was fast for a few small changes but potentially slower than iptables during a burst of many changes at once. And because the IPVS API is limited, kube-proxy had to fall back to iptables for anything beyond basic load balancing — reintroducing the very scaling problems it was meant to solve. Using ipset for some rules only moved the problem, still without batch updates.

There is a more structural issue too: Red Hat plans to remove the iptables API from RHEL entirely, which would leave the IPVS backend — which depends on it — unavailable to Kubernetes users on that distribution.

As for the IPVS schedulers, the other selling point, they do not deliver. kube-proxy is a distributed service running on every node with no shared state, so each node picks endpoints without knowing what the others are doing. Even the mh scheduler (Maglev Hashing), built for distributed load balancing, is only efficient inside a two-layer LB architecture that kube-proxy does not have.

The takeaway is not that IPVS was a mistake — it bought real time for clusters that outgrew iptables. It is that a backend with an incompatible API and a shrinking maintainer base cannot be the long-term answer, especially when its fallback dependency, iptables, is itself being retired by the major enterprise distribution. The nftables backend was designed from the start to replace both.

How to tell whether you are affected

First, check which backend your nodes actually run. The mode field of the kube-proxy ConfigMap is enough:

bash
kubectl -n kube-system get configmap kube-proxy -o jsonpath='{.data.config\.conf}'

The three possible values are iptables, ipvs, and nftables. If you read ipvs, you are inside the deprecation scope. The mode was often set years ago — by a kubeadm or a playbook that forced it explicitly, back when it was the recommended choice for performance — and many clusters run ipvs without anyone remembering. Since 1.35, kube-proxy also logs a deprecation warning: now is the time to read it. On a managed cluster (EKS, GKE, AKS), kube-proxy may be configured or replaced by the provider: check its documentation instead of assuming.

The migration is one line

The replacement path is already written: the nftables backend was introduced in 1.29 and has been GA since 1.33. It is fully supported, feature-complete.

Switching is a configuration change plus a restart. On a kubeadm cluster, change mode: ipvs to mode: nftables in the kube-proxy ConfigMap, then restart the pods:

yaml
# kubectl -n kube-system edit configmap kube-proxy
apiVersion: v1
kind: ConfigMap
metadata:
  name: kube-proxy
  namespace: kube-system
data:
  config.conf: |
    mode: nftables
bash
kubectl -n kube-system rollout restart daemonset kube-proxy

Two conditions must hold before you switch: run Kubernetes 1.36 or later, on a kernel 5.13 or later. Although nftables has been GA since 1.33, the performance and scaling fixes that make it a true peer were not backported before 1.36. If you override other IPVS-specific settings, reconsider each one individually.

The gain is not dramatic, and that is the good news. The numbers SIG Network published show nftables establishing connections with very slightly lower latency than IPVS — the point being that it does not regress where iptables regressed. A switch that costs nothing in performance can be made without urgency, but it leaves no excuse to wait.

nftables: one migration that sets up the next

Do not treat this as a simple swap for IPVS. The nftables backend is the designated successor to both older backends: the community’s plan is for it to eventually replace iptables too. Migrating to nftables today is not just fleeing a deprecation — it is taking the longest maintenance path.

Two things deserve an explicit check after the switch. First, the source IP of connections reaching your pods: depending on cluster topology and CNI, nftables mode may behave differently on externalTrafficPolicy or client-IP preservation. Second, your metrics and probes: a data-plane change is the moment to confirm that readiness and liveness probes behave as before, especially behind heavily populated ClusterIP Services. Roll the change out node by node on a staging cluster before going wide.

And if you are still on a release older than 1.36, the correct next step is not a big-bang upgrade — it is to put 1.36 on the roadmap with a clear owner, because every interim release leaves you closer to a removal you already know is coming.

The verdict

If you run ipvs mode and are already on Kubernetes 1.36+ with kernel 5.13+, schedule the switch to nftables now. It is a low-risk configuration change, not a project: change the mode, restart, observe. Before doing it in production, re-verify features that relied on the iptables fallback — service source IP, advanced policies — and re-test any IPVS-specific tuning. The window is comfortable, since removal only lands in 1.40, but every release that passes compounds the debt.

If you are stuck on an older release, stay on ipvs or iptables knowingly, and put the migration on the plan. The real cost of IPVS is not the future removal: it is a backend that was never fully compatible, maintained by a thin community, and dependent on an iptables API that Red Hat is phasing out. It is the kind of silent change that recalls the BestEffort downgrade on empty resources: you often only discover it at the next upgrade.

References

The cyber brief, every Tuesday

The flaws that matter and the patches to apply, in a ten-minute read.

No spam. One-click unsubscribe.
read next

On the same topic

Docker Engine 29.10 stops trusting loopback and breaks local registries without TLS

On 16 November 2026, Docker Engine 29.10 stops automatically treating loopback addresses as insecure registries whenever an insecure-registries list is configured: pulls and pushes to a local HTTP registry fail after the upgrade. Before upgrading, list your local registries and add them explicitly — or move them to TLS.

Meta cuts Kubernetes deployments from four hours to minutes by splitting app delivery from infrastructure

At KubeCon NA 2026, Meta revealed that its fifteen-engineer Cloud Foundation team ships to around a hundred Kubernetes clusters through a GitOps platform built on Argo CD and Kargo, separating application delivery from Terraform provisioning. The result, four hours down to minutes, is a lesson any team can copy the moment Terraform sits on its deployment critical path.

← Back to the feed

Type at least two characters.

↑ ↓ navigate ↵ open esc dismiss