Kubernetes is retiring IPVS: What operators should prepare now

Kubernetes is retiring kube-proxy's IPVS mode. What operators should know about nftables, the timeline, migration, testing, and rollback planning.

A Kubernetes cluster can run reliably for years while the foundations of its operation change. Configurations remain in place because they work. Earlier architectural decisions become part of automation and installation templates. Eventually, they feel so natural that hardly anyone questions their assumptions.

The announced retirement of kube-proxy's IPVS mode is a reason to take a closer look.

Platform teams now have a concrete task: identify the service proxy in use, choose a suitable migration path, and test the transition before the affected Kubernetes upgrade.

What Kubernetes is actually deprecating

The change affects the IPVS backend of kube-proxy. The announcement concerns neither the retirement of kube-proxy as a whole nor the removal of IPVS from the Linux kernel. The proposal addresses Kubernetes' implementation of this proxy mode. (Source: KEP-5495)

The documented roadmap has several stages:

Kubernetes version Planned change
1.35 IPVS mode is deprecated; kube-proxy emits a warning.
1.37 Introduction of the KubeProxyIPVS feature gate, initially enabled by default.
1.40 IPVS is disabled by default; temporary reactivation remains possible through the feature gate.
1.43 Complete removal of IPVS mode.

The linked announcement describes removal in 1.40. The KEP and reference documentation describe the staged process above. Operators should therefore also check the release notes for their specific target version when planning an upgrade. (Announcement, KEP-5495, reference documentation)

Our recommendation: complete the migration before the default changes. A transitional switch should remain a safeguard rather than replace a regular migration plan.

Why IPVS could originally be a good decision

IPVS was intended to address scaling problems in the iptables backend of its time. These included searching long rule chains for new connections and the cost of updating rules. IPVS brought improvements in both areas.

The limitations lie in the architecture: the IPVS kernel API is only a partial fit for the Kubernetes Service API. The backend still needs iptables for additional functionality. Missing batch operations complicate large changes; meanwhile, the implementation remained complex and did not correctly cover every Service edge case. (Source: Kubernetes blog)

For existing platforms, this does not retroactively make the original choice a mistake. A solution can have been appropriate for the requirements at the time and need a successor today.

The relevant question is therefore: which assumptions behind the original decision still hold for the current cluster?

Why nftables is a relevant target

The nftables mode uses maps to look up Service addresses. Packet processing therefore does not need the same linear search through Service rules as iptables. The API also allows more targeted updates when Services and endpoints change. These properties address two distinct tasks: processing connections and keeping forwarding state up to date. (Source: NFTables mode for kube-proxy)

The current announcement recommends that IPVS users switch to nftables on Kubernetes 1.36 or later and Linux kernel 5.13 or later. nftables has been generally available since Kubernetes 1.33; the recommendation for 1.36 accounts for subsequent performance and scaling fixes. Where nftables cannot yet be used, Kubernetes names iptables as an alternative. (Source: Kubernetes blog)

For your own platform, the target decision should still consider more than two version numbers. The operating system, network plugin, installation method, and any platform provider approvals also need to be checked.

The first step is a reliable inventory

Before setting a migration date, establish which service proxy is actually active in each cluster and who manages its configuration.

We recommend a short overview containing:

  • Kubernetes version and node images in use
  • Active proxy mode and the source of its configuration
  • Network plugin and its operating mode
  • Custom IPVS settings
  • Responsible team or platform provider
  • Planned Kubernetes and operating system upgrades

Teams should compare the running environment with its declarative configuration. An entry in an old installation repository does not prove that every node operates accordingly today.

The result should support a simple statement: this cluster uses IPVS, this component manages the setting, and this supported procedure leads to the target configuration.

A configuration change needs operational acceptance

The technical change can look straightforward. That makes checking its effects all the more important.

For a migration test, we recommend documenting the actual access paths used by applications. Which applications communicate internally? Which are reached through external load balancers? Where are NodePorts used? Which connections remain open for extended periods?

The Kubernetes documentation identifies differences involving NodePort addresses and local firewalls in nftables mode. By default, NodePorts use the nodes' primary addresses. Local firewalls must also allow the required traffic; nftables mode does not add the same allow rules as iptables mode. (Source: reference documentation)

These differences belong in concrete test cases. “The application is reachable” is too vague as an acceptance criterion if only one access path was tested.

A possible test matrix:

Area Recommended check
Internal communication Service access between applications on different nodes
External access Connections through the load balancers and node addresses actually used
Operational changes Behavior during deployment rollouts and scaling
Persistent connections Behavior of representative long-lived TCP connections
Failure scenarios Availability during backend failure or node maintenance
Network rules Expected allowed and blocked connections

The selection should reflect your platform. A small cluster with a few internal Services needs different checks from a platform with numerous external access paths.

Divide the transition into manageable steps

We recommend treating the migration as a separate change. If the Kubernetes version, operating system, network plugin, and proxy mode all change at once, the cause of a problem becomes harder to identify.

A sensible process starts with a representative test environment. Use it to test the target configuration, the transition, and the rollback procedure. Then run a limited production pilot using the procedure supported by your distribution or provider.

Establish three things before each stage:

What will be checked? This includes complete application workflows and the relevant network paths.

When will the change be stopped? For example, when connection errors exceed an agreed threshold or a business-critical access path fails.

Who decides? Responsibility for continuing or rolling back should be clear before the maintenance window.

Proceed to the next step only after acceptance. This turns a one-off intervention into a repeatable procedure for additional clusters.

Plan the rollback just as concretely

A saved configuration file is one part of a rollback plan. The plan must also describe how the previous operating mode will actually be restored and verified.

When switching from IPVS to iptables, Kubernetes recommends rebooting the nodes after changing the configuration rather than only restarting kube-proxy. This step belongs in capacity planning and the maintenance procedure. (Source: Kubernetes blog)

For your rollback procedure, we recommend a rehearsal using the same acceptance criteria as the migration. Include the time needed for recovery and access to the nodes if regular application access is disrupted.

A reliable plan describes an executable procedure with responsible people and expected results.

Automation must also be correct after the migration

Successfully switching a cluster does not finish the work.

We recommend subsequently checking everything that creates new nodes or clusters: installation templates, configuration management, recovery procedures, and internal operating instructions.

The decisive test is: will the next rebuild automatically produce the intended configuration?

Teams should also document why the target was chosen, which prerequisites apply, and which tests justified approval. This information helps with the next upgrade and reduces the time needed to understand the system during an incident.

What organizations should plan now

The IPVS deprecation translates into a manageable sequence of concrete tasks: identify affected clusters, determine a supported target configuration, test representative applications, and carry out the migration in time.

This needs an owner and a place on the platform roadmap. Without both, a known technical change can easily remain unresolved until the next upgrade.

For us, this is an essential part of Kubernetes operations: regularly checking decisions from earlier installations against today's platform and validating changes through reproducible tests.

If you use IPVS, start with this inventory now. That lets you choose a maintenance window around the requirements of your own operations.