Kubernetes kube-proxy IPVS Is Going Away: Plan the Migration to nftables

Kubernetes is retiring kube-proxy IPVS. Learn how to inventory your cluster, choose nftables or iptables, and validate the migration.

Cloud Infrastructure•~8 min read•November 17, 2026•By QZ-L Editorial
#Kubernetes#kube-proxy#Networking#DevOps
Looking for related guides? Start with the qz-l Learning Center and explore more tutorials in this topic cluster.

Many Kubernetes clusters still use the ipvs mode of kube-proxy because it solved real scaling problems in older versions of Kubernetes. That makes its deprecation easy to miss: Services continue to work, so there may be no urgent symptom to fix.

The Kubernetes project has now published a migration plan. IPVS was deprecated in Kubernetes 1.35, will be disabled by default in 1.40, and is scheduled to be fully removed in 1.43. The recommended destination for supported Linux nodes is usually the nftables mode, with iptables as the compatibility fallback.

This is not a request to change every cluster today. It is a request to discover which backend each cluster uses, test the replacement before an upgrade makes the decision for you, and check the networking behaviors that can change along with the backend.

What kube-proxy is changing

kube-proxy implements the virtual IP behavior behind most Kubernetes Services. It watches Services and EndpointSlices, then configures the node to redirect traffic for a Service address and port to one of its endpoints.

On Linux, the available modes are iptables, ipvs, and nftables. IPVS used kernel hash tables and avoided some of the data-plane and synchronization costs of older iptables implementations. It also had limitations: its API did not map cleanly to every Kubernetes Service behavior, and the kube-proxy implementation had to fall back to iptables for some features.

The project’s current plan is staged rather than an immediate break:

  • Kubernetes 1.35: IPVS is deprecated and kube-proxy warns when it is used.
  • Kubernetes 1.40: the KubeProxyIPVS feature gate is planned to become default-off. A cluster can still temporarily override the gate, but that is a migration bridge, not a long-term solution.
  • Kubernetes 1.43: the feature is planned to be locked off and the IPVS implementation removed.

The exact release dates and upgrade sequence depend on your distribution and provider. The important operational point is that waiting until the final removal leaves less time to find NodePort, firewall, monitoring, or CNI incompatibilities.

First, find the mode you actually run

Do not infer the mode from the Kubernetes version or from what a cluster used several years ago. Inspect the active kube-proxy configuration in each cluster. In a kubeadm-managed cluster, the configuration is commonly stored in the kube-proxy ConfigMap in kube-system; managed Kubernetes services may expose a provider-specific setting instead.

An illustrative inspection sequence is:

kubectl -n kube-system get configmap kube-proxy \
  -o jsonpath='{.data.config\.conf}' | grep -E '^[[:space:]]*mode:'

This example was not run against a cluster. The key is to confirm the source of truth used by your deployment, not to assume that a successful kubectl command proves the value is present. Also inspect the kube-proxy DaemonSet arguments and the rendered configuration if your platform supplies them separately.

If the mode is omitted, make the intended mode explicit before an upgrade. Kubernetes documentation warns that the recommended default will change in a future release; relying on an implicit default can therefore change the node dataplane during an otherwise routine upgrade.

Record the result per cluster and node pool, including:

  • Kubernetes and node operating-system versions.
  • Linux kernel version and the installed nft tool version.
  • CNI and NetworkPolicy components.
  • Any host firewall or other process that writes netfilter rules.
  • NodePort address settings and consumers of localhost NodePorts.
  • kube-proxy metrics and dashboards that assume iptables or IPVS-specific data.

Prefer nftables when the prerequisites fit

Kubernetes recommends moving to nftables on Kubernetes 1.36 or later when nodes run Linux kernel 5.13 or newer. The backend is designed to replace the scaling characteristics of both older modes: it uses map-based packet dispatch and can apply updates more incrementally.

That recommendation is not a promise that every cluster can switch without testing. The nftables backend changes some defaults intentionally. For example, NodePort Services default to the node’s primary addresses rather than being reachable on every local address. A host firewall must also allow the traffic that Kubernetes needs; kube-proxy does not configure that firewall for you.

The nftables path is a good candidate when:

  • Every relevant node meets the kernel and Kubernetes version requirements.
  • The CNI, NetworkPolicy, and observability tools do not depend on IPVS-specific behavior.
  • You can test Service, NodePort, external traffic policy, session affinity, and conntrack behavior.
  • Your team is prepared to inspect the host’s existing nftables rules.

The Kubernetes documentation also describes a metric, iptables_ct_state_invalid_dropped_packets_total, that can reveal dependence on a conntrack workaround. If that metric indicates a dependency, investigate it before switching rather than blindly copying the old behavior.

Keep iptables as a compatibility option

iptables is the safer destination when the node kernel is too old for nftables, a network component has an incompatibility, or the organization cannot yet validate the changed defaults. It is not the same as abandoning the migration: it removes the IPVS dependency while leaving a supported kube-proxy backend in place.

Modern iptables mode is not the same implementation that motivated IPVS in 2017. Kubernetes has reduced redundant rules, improved synchronization, and avoided unnecessary full-state work. The project still presents nftables as the preferred modern path where supported, but iptables may be the right interim choice for an older or constrained fleet.

Do not choose iptables solely because it is familiar. Check the scale and update behavior of the actual cluster, and measure synchronization delay if kube-proxy has historically been a bottleneck. Conversely, do not choose nftables solely because a benchmark chart looks better: compatibility with the rest of the node is part of the decision.

A staged kubeadm migration

For a kubeadm cluster, the Kubernetes migration guidance describes changing the kube-proxy ConfigMap from mode: ipvs to mode: nftables, then restarting the kube-proxy Pods. A representative shape is:

apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: nftables

This snippet is illustrative and was not applied. Preserve the rest of your existing configuration and remove or translate IPVS-specific settings according to the current kube-proxy configuration reference. Do not replace a production ConfigMap with a minimal example.

A safer rollout is:

  1. Capture a baseline. Save the current kube-proxy configuration, node kernel/tool versions, Service and EndpointSlice counts, NodePort exposure, and relevant error and latency metrics.
  2. Choose a representative node pool. Include nodes with the oldest supported kernel and the most unusual network policy or firewall rules.
  3. Change one controlled group. Apply the provider-supported configuration change and restart only the intended kube-proxy instances.
  4. Exercise real paths. Test ClusterIP, headless and external traffic as applicable, NodePort, load-balancer traffic, readiness transitions, session affinity, dual-stack paths, and connections that cross nodes.
  5. Watch the node, not only the API. Check kube-proxy logs and metrics, host nftables state, conntrack behavior, packet drops, and application error rates.
  6. Expand gradually. Continue only when the canary behaves like the baseline and the rollback procedure is known to work.

The exact restart command varies by installation. A kubectl rollout restart against the kube-proxy DaemonSet may be appropriate for one kubeadm setup, while a managed service may require a provider setting or node replacement. Treat the command as deployment-specific rather than copying it into an automation pipeline without review.

Details that can break an otherwise successful switch

NodePort reachability. If clients used a secondary node address or loopback, the nftables default may stop accepting that traffic. Review --nodeport-addresses. Kubernetes 1.37 provides a documented feature gate for localhost NodePorts, but enabling it is a deliberate compatibility choice, not a generic fix.

Host firewalls. nftables is also a host firewall API. Another component may own tables or chains on the node. Confirm ownership and ruleset expectations so that kube-proxy does not conflict with a firewall or so that a firewall does not block Service traffic.

CNI and monitoring. Verify that the CNI, NetworkPolicy implementation, packet-capture tooling, and dashboards support the selected backend. A dashboard that only counts iptables chains can look “quiet” after a successful migration while hiding useful evidence.

IPVS scheduler assumptions. IPVS scheduler names can look like an application-level load-balancing policy. Kubernetes explains that kube-proxy instances on different nodes do not share scheduler state, so those schedulers do not provide the global behavior some operators expect. Do not treat preserving an IPVS scheduler as a reason to postpone the migration without verifying its actual purpose.

Rollback. Keep the previous configuration and a tested way to restore it, but do not assume that changing the mode alone cleans every old kernel rule. Kubernetes notes that low-level rules may persist until cleanup or reboot in some circumstances. Follow the version- and distribution-specific cleanup guidance, and schedule rollback work with the same care as the forward change.

A practical decision checklist

Use this order rather than starting with a configuration edit:

  1. Identify every cluster and node pool using IPVS.
  2. Make the current proxy mode explicit and record the 1.40/1.43 upgrade implications.
  3. Prefer nftables when the Kubernetes, kernel, CNI, firewall, and tooling prerequisites are satisfied.
  4. Use iptables as a supported fallback when nftables cannot yet be validated.
  5. Canary the change and test traffic behaviors, not only Pod readiness.
  6. Monitor NodePort exposure, conntrack drops, kube-proxy synchronization, and application errors.
  7. Remove IPVS-specific settings and feature-gate overrides after the migration is stable.

IPVS is not disappearing because Service traffic no longer needs a node proxy. It is disappearing because a backend that once solved a scaling problem is now harder to maintain and less complete than the replacement. Treat the deprecation as an upgrade-planning task: inventory first, choose deliberately, and prove the node dataplane still matches the way your users reach your Services.

References

Related Posts

Kubernetes OCI Seccomp Profiles: Ship Syscall Policies with Your Workload

Kubernetes 1.38 adds an alpha path for digest-pinned OCI seccomp profiles. Learn the runtime flow, safeguards, and rollout limits.

Docker Engine 29.10: Check Your Local Registry Configuration Before Upgrading

Docker Engine 29.10 changes loopback registry defaults. Learn how to migrate local registries without weakening transport security.

Kubernetes HPA Scale-to-Zero: Stop Paying for Idle Workers

Use Kubernetes 1.37 HPA scale-to-zero for queue and batch workers, with an example manifest and the operational limits to plan for.