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.

By 0xScorPionSon

8 min read

Scheduling the Removal of Kubernetes kube-proxy IPVS: Migrating Clusters to nftables Before v1.40

Kubernetes kube-proxy IPVS removal and nftables migration infographic

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:

  1. No batch update API: Unlike nftables, the kernel IPVS interface lacks atomic batch update operations. When thousands of endpoints churn simultaneously, kube-proxy in ipvs mode can actually sync slower than modern iptables implementations.
  2. Incomplete feature parity and iptables fallback: IPVS never implemented every Kubernetes Service edge case natively, forcing kube-proxy to invoke the iptables API alongside IPVS. Because Red Hat plans to remove the iptables userspace/kernel compatibility layer from RHEL, ipvs mode inherits an unsustainable dependency.
  3. 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.
  4. No out-of-tree repo: Under KEP-5495, SIG Network explicitly rejected moving ipvs to a separate kubernetes-sigs/kube-proxy-ipvs repository 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 iptables rewrote the full ruleset via iptables-restore (growing to hundreds of thousands of rules at tens of thousands of Services), nftables applies incremental updates proportional only to the Services and endpoints that changed since the last sync.
  • No global lock contention: The nftables API allows each networking component (kube-proxy, CNI plugins, host firewall) to own its own private table, eliminating global xtables lock contention.
  • Kernel requirement: nftables mode 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:

  1. Switching to nftables: Updating mode: nftables in KubeProxyConfiguration and restarting the kube-proxy DaemonSet automatically cleans up leftover ipvs and iptables rules without requiring a node reboot.
  2. Switching to iptables (legacy kernels): If you must fall back to iptables on an older distribution without kernel 5.13+, the November 16, 2026 Kubernetes blog explicitly recommends rebooting each node after updating the kube-proxy configuration rather than merely restarting kube-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

  1. Kubernetes Blog — Scheduling the removal of the kube-proxy IPVS backend (Published November 16–17, 2026)
  2. Kubernetes Documentation — Virtual IPs and Service Proxies (Updated August 6, 2026)
  3. Kubernetes Enhancements (GitHub) — KEP-5495: Deprecate IPVS mode in kube-proxy (SIG Network Specification)
  4. Kubernetes Blog — NFTables mode for kube-proxy (Published February 28, 2025)
  5. daily.dev — Scheduling the removal of the kube-proxy IPVS backend (Published November 17, 2026)

More on Technology

Technology

.NET 11 Launches With C# 15 Union Types and CoreCLR for MAUI as .NET 8 and .NET 9 Reach End of Support

Released November 10, 2026 alongside .NET Conf 2026, .NET 11 (STS, supported through November 14, 2028) introduces C# 15 union types and closed hierarchies, a Native AOT CLI host, OpenAPI 3.2 defaults, and CoreCLR on .NET MAUI—on the exact day .NET 8 and .NET 9 reached end of support. Here is the technical breakdown, .NET 10 LTS vs .NET 11 comparison, and upgrade checklist.

8 min read

Technology

DocumentDB 1.0 Reaches General Availability: MIT-Licensed MongoDB Compatibility on PostgreSQL—With Telemetry and Latency Caveats

Open-source DocumentDB 1.0 is now generally available under the permissive MIT license, pairing a native BSON PostgreSQL extension with a MongoDB wire-protocol gateway and Kubernetes Operator 1.0.0. Here is how the architecture works across PostgreSQL 15–18, what early YCSB benchmarks against FerretDB and MongoDB 9.0.4 show, and how to harden deployments—including disabling default Scarf container telemetry.

8 min read

Tell us what is not working

A thirty-minute call, no deck and no obligation. You will leave with a straight answer about whether this is worth building - including if that answer is no.

Start a project

Direct line

hello@codebumble.net
Dhaka, Bangladesh  :   local timeCalls in English or Bangla