Technology
Scheduling the Removal of Kubernetes kube-proxy IPVS: Migrating Clusters to nftables Before v1.40
Kubernetes SIG Network has scheduled the removal of the kube-proxy IPVS backend for Kubernetes 1.40, closing the chapter on a mode deprecated since v1.35. Learn why IPVS lacks kernel batch updates, how nftables (kernel 5.13+) eliminates global lock contention, and how to audit and migrate your clusters safely.
8 min read
Scheduling the Removal of Kubernetes kube-proxy IPVS: Migrating Clusters to nftables Before v1.40
Executive Summary
On November 16–17, 2026, the Kubernetes project published Scheduling the removal of the kube-proxy IPVS backend, confirming that Kubernetes SIG Network plans to remove the ipvs proxy mode from kube-proxy in Kubernetes 1.40. Originally deprecated in Kubernetes 1.35 under KEP-5495 with an earlier multi-release runway extending toward v1.43 in older documentation, the updated announcement sets v1.40 as the removal target and directs Linux cluster operators to migrate to nftables (or the modernized iptables backend on legacy kernels).
With Kubernetes v1.37 ("Garhwal," released August 26, 2026) already logging startup deprecation warnings for mode: ipvs and v1.38 scheduled for December 16, 2026, platform teams running self-managed or managed clusters on IPVS face a concrete migration deadline. As daily.dev's November 17 technical summary notes, the kernel IPVS API lacks batch update operations, never achieved full feature parity with iptables, and faces long-term distribution headwinds because Red Hat plans to remove the iptables API from RHEL entirely. Meanwhile, Linux kernels too old to support kube-proxy nftables mode (pre-5.13) reach end of LTS by the end of 2026.
Confidence level: High for the Kubernetes v1.40 removal schedule, KEP-5495 rationale, kernel 5.13+ requirements, and migration mechanics, all verified against official kubernetes.io blog posts, kubernetes/enhancements KEP-5495, and Virtual IPs and Service Proxies documentation. Specific wall-clock latency benchmarks comparing ipvs vs. nftables at 10,000+ services are referenced qualitatively from upstream SIG Network documentation; exact cluster-specific throughput numbers depend on CNI plugin and kernel version.
Technical Mechanics and Architecture
Why IPVS Failed as a Kubernetes Service Backend
kube-proxy originally introduced ipvs mode (experimental in v1.11) to solve iptables O(n) rule-rewriting bottlenecks in large clusters. Instead of traversing linear iptables chains, IPVS uses an in-kernel hash table inside the netfilter subsystem and supports alternative load-balancing schedulers (rr, wrr, lc). However, in practice, the kernel IPVS API proved misaligned with the Kubernetes Service API:
- No batch update API: Unlike
nftables, the kernel IPVS interface lacks atomic batch update operations. When thousands of endpoints churn simultaneously,kube-proxyinipvsmode can actually sync slower than moderniptablesimplementations. - Incomplete feature parity and
iptablesfallback: IPVS never implemented every Kubernetes Service edge case natively, forcingkube-proxyto invoke theiptablesAPI alongside IPVS. Because Red Hat plans to remove theiptablesuserspace/kernel compatibility layer from RHEL,ipvsmode inherits an unsustainable dependency. - Node-local scheduler isolation: Alternative IPVS schedulers like least-connection (
lc) operate independently per node without sharing state across the cluster, limiting their real-world advantage over random endpoint selection. - No out-of-tree repo: Under KEP-5495, SIG Network explicitly rejected moving
ipvsto a separatekubernetes-sigs/kube-proxy-ipvsrepository to avoid maintaining unstaffed security fixes.
+-----------------------------------------------------------------------+
| KUBE-PROXY LINUX BACKEND ARCHITECTURE (2026) |
+-----------------------------------------------------------------------+
| |
| [Kubernetes API Server: Services & EndpointSlices] |
| | |
| v |
| [kube-proxy DaemonSet (per Linux Node)] |
| | |
| +--- mode: ipvs (DEPRECATED v1.35 -> REMOVED v1.40) |
| | |-- Kernel IPVS hash table + legacy iptables fallback |
| | |-- Lacks batch updates; incompatible with nftables-only OS |
| | |
| +--- mode: nftables (RECOMMENDED, GA v1.33+, Kernel >= 5.13) |
| | |-- Incremental updates: O(delta) instead of O(total rules) |
| | |-- Private nftables table (no global lock contention) |
| | |
| +--- mode: iptables (LEGACY FALLBACK, Kernel < 5.13) |
| |-- Improved since v1.26, but requires node reboot on switch |
| |
+-----------------------------------------------------------------------+
How nftables Solves Both Data-Plane and Control-Plane Latency
As documented in Kubernetes Virtual IPs and Service Proxies and the NFTables mode for kube-proxy engineering post:
- Incremental control-plane updates: Whereas legacy
iptablesrewrote the full ruleset viaiptables-restore(growing to hundreds of thousands of rules at tens of thousands of Services),nftablesapplies incremental updates proportional only to the Services and endpoints that changed since the last sync. - No global lock contention: The
nftablesAPI allows each networking component (kube-proxy, CNI plugins, host firewall) to own its own private table, eliminating globalxtableslock contention. - Kernel requirement:
nftablesmode requires Linux kernel 5.13 or later (and Kubernetes v1.36+ is recommended for full maturity, having reached GA in v1.33).
Safe Audit Script: Checking kube-proxy Mode and Kernel Readiness
Before modifying any cluster configuration, run a read-only audit across your nodes and kube-proxy ConfigMap to verify current proxy mode, Linux kernel version (>= 5.13), and whether any nodes still run cgroup v1 (which also faces strict enforcement in v1.37/v1.38):
#!/usr/bin/env bash
# Safe, read-only audit for kube-proxy mode and node kernel readiness
set -euo pipefail
echo "=== 1. Inspect kube-proxy ConfigMap mode ==="
kubectl -n kube-system get configmap kube-proxy \
-o jsonpath='{.data.config\.conf}' | grep -E '^(mode:|featureGates:)' || true
echo "=== 2. Check node OS and Linux kernel versions (need >= 5.13 for nftables) ==="
kubectl get nodes -o custom-columns=\
"NAME:.metadata.name,KERNEL:.status.nodeInfo.kernelVersion,OS:.status.nodeInfo.osImage,KUBELET:.status.nodeInfo.kubeletVersion"
echo "=== 3. Check kube-proxy logs for IPVS deprecation warnings ==="
kubectl -n kube-system logs -l k8s-app=kube-proxy --tail=50 | grep -iE 'ipvs|deprecat|nftables' || true
Evidence and Migration Matrix
The table below summarizes the official Kubernetes lifecycle milestones and backend comparison based on KEP-5495, Kubernetes Virtual IPs, and the November 16, 2026 IPVS removal announcement.
| Attribute / Milestone | ipvs Mode |
nftables Mode |
iptables Mode |
|---|---|---|---|
| Lifecycle Status (Nov 2026) | Deprecated (v1.35); Removed in v1.40 | GA & Recommended (since v1.33) | Supported fallback |
| Min Linux Kernel | Kernel IPVS + iptables modules |
Linux Kernel 5.13+ | Older Linux kernels supported |
| Rule Update Complexity | Lacks kernel batch update API | Incremental O(changed endpoints) | Full/partial iptables-restore |
| Table / Lock Isolation | Shares iptables fallback hooks |
Private nftables table |
Shared xtables lock |
| Node Reboot on Switch | N/A (source mode) | No reboot needed (cleans old rules) | Reboot recommended (per Nov 16 blog) |
| RHEL Future Compatibility | Breaks when iptables API removed |
Fully compatible | Legacy only |
Two operational details from the November 16 Kubernetes blog and NFTables mode documentation are critical during migration:
- Switching to
nftables: Updatingmode: nftablesinKubeProxyConfigurationand restarting thekube-proxyDaemonSet automatically cleans up leftoveripvsandiptablesrules without requiring a node reboot. - Switching to
iptables(legacy kernels): If you must fall back toiptableson an older distribution without kernel 5.13+, the November 16, 2026 Kubernetes blog explicitly recommends rebooting each node after updating thekube-proxyconfiguration rather than merely restartingkube-proxy.
Hardening and Migration Playbook
Execute this six-step playbook in a staging cluster before touching production workloads.
1. Audit CNI and Host Firewall Compatibility
If you run Calico, Cilium, or NodeLocal DNSCache alongside kube-proxy, verify their nftables compatibility first. For example, Calico operators must also switch the Felix dataplane to NFTables (or bypass kube-proxy entirely with eBPF) rather than leaving Calico in ipvs mode while kube-proxy runs nftables.
2. Verify Linux Kernel >= 5.13 and nft Userspace Support
Confirm every worker node runs Linux kernel 5.13 or newer and has nf_tables kernel modules loaded:
# Safe read-only check on a Linux worker node
uname -r && lsmod | grep -E 'nf_tables|ip_vs' || true
3. Pin mode: nftables Explicitly in KubeProxyConfiguration
Never leave mode: blank in your kube-proxy ConfigMap. An explicit mode: nftables prevents unexpected backend flips during future Kubernetes minor upgrades when the default switches away from iptables:
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: "nftables"
4. Roll Out kube-proxy DaemonSet in Staging and Verify Active Mode
Apply the updated ConfigMap and perform a controlled rolling restart of kube-proxy:
kubectl -n kube-system rollout restart daemonset/kube-proxy
kubectl -n kube-system rollout status daemonset/kube-proxy
kubectl -n kube-system logs daemonset/kube-proxy --tail=30 | grep -i nftables
5. Validate Service Connectivity, NodePort, and ExternalIPs
Test ClusterIP, NodePort, LoadBalancer, and SessionAffinity services across nodes—and confirm no workloads rely on Service.spec.externalIPs (which was also deprecated in Kubernetes v1.36).
6. Rollback Note
If nftables mode triggers an unexpected packet-drop or CNI interaction in staging, you can revert mode: ipvs (on Kubernetes < 1.40) in the kube-proxy ConfigMap and restart daemonset/kube-proxy; kube-proxy will automatically remove the nftables rules it created. If you rolled back to iptables instead, follow the Kubernetes SIG Network guidance and drain/reboot each affected node cleanly.
Frequently Asked Questions (FAQ)
1. When will Kubernetes actually remove kube-proxy IPVS mode?
According to the November 16, 2026 Kubernetes blog, SIG Network has scheduled the removal of the ipvs backend for Kubernetes 1.40. It has been deprecated with startup warnings since v1.35.
2. What should I migrate to: nftables or iptables?
Migrate to nftables if you are running Kubernetes 1.36+ on Linux kernel 5.13 or later—it delivers incremental rule updates, private table isolation, and better performance than ipvs. Only fall back to iptables on older Linux distributions that lack kernel 5.13+ support.
3. Do I need to reboot nodes when migrating from ipvs to nftables?
No. Per the Kubernetes nftables guide, restarting kube-proxy in nftables mode automatically deletes existing ipvs and iptables rules. However, if you switch from ipvs to iptables, Kubernetes recommends rebooting each node.
4. Why didn't Kubernetes move ipvs to an external kubernetes-sigs repo?
In KEP-5495, SIG Network explained that they had no intention of maintaining an external repo or shipping security patches for it, and all kernels too old for nftables reach end of LTS by the end of 2026.
5. What happens if I leave mode: unset in kube-proxy?
The Kubernetes Virtual IPs documentation warns that leaving mode unspecified causes kube-proxy to use the release default (currently iptables, changing to nftables in a future release), which can trigger an unintended backend switch during cluster upgrades.
Sources
- Kubernetes Blog — Scheduling the removal of the kube-proxy IPVS backend (Published November 16–17, 2026)
- Kubernetes Documentation — Virtual IPs and Service Proxies (Updated August 6, 2026)
- Kubernetes Enhancements (GitHub) — KEP-5495: Deprecate IPVS mode in kube-proxy (SIG Network Specification)
- Kubernetes Blog — NFTables mode for kube-proxy (Published February 28, 2025)
- daily.dev — Scheduling the removal of the kube-proxy IPVS backend (Published November 17, 2026)