IPVS vs. IPTables for kube-proxy in Kubernetes

I’ve had the unique opportunity to work extensively with Kubernetes and its various components. One critical element in Kubernetes networking is kube-proxy, which can use either IPTables or IPVS for routing traffic. While IPTables has been the default for many, IPVS offers significant advantages in terms of scalability, performance, and security. I’ll share my experiences and insights on why IPVS is a superior choice for modern Kubernetes deployments.

Why kube-proxy Matters

Kube-proxy plays a crucial role in the Kubernetes networking model by managing the network rules on nodes. It ensures that traffic destined for services gets routed correctly to the appropriate pods. The choice between IPTables and IPVS as the underlying mechanism can greatly impact your cluster’s efficiency and reliability.

The Technical Background: Understanding IPTables and IPVS


IPTables is a user-space utility program that allows a system administrator to configure the IP packet filter rules of the Linux kernel firewall, implemented as different Netfilter modules. It uses a table-based structure for managing and organizing rules.

  • Chains and Tables: IPTables uses chains of rules, each of which is checked in order for each packet. The main tables used are filter (default), nat (network address translation), and mangle (for specialized packet alteration).
  • Rule Processing: Each packet traverses these chains, which can have a considerable number of rules, leading to sequential processing. This sequential checking becomes inefficient as the number of rules grows, especially in large Kubernetes clusters with thousands of services and network policies


IPVS (IP Virtual Server) is a transport layer load balancing technology built on the Linux kernel’s Netfilter framework. It was designed to provide better performance and scalability than IPTables.

  • Load Balancing Methods: IPVS supports multiple load balancing algorithms, such as round-robin, least connections, and destination hashing, allowing more flexible and efficient traffic distribution.
  • Connection Handling: IPVS manages connections more efficiently by maintaining a hash table of active connections, allowing for constant-time lookups and faster packet processing.

The Challenge with IPTables

When I first started working with Kubernetes, IPTables was the go-to solution for Kube-proxy. It works by setting up IP packet filter rules in the Linux kernel. For small clusters, it’s sufficient. However, as the number of services and pods scales up, IPTables can become a bottleneck. Each new service adds more rules, which means the system has to process a growing list of rules sequentially for every packet. This sequential processing can slow down network traffic, leading to latency issues that aren't acceptable in large-scale deployments.

In practice, I've seen clusters where the sheer number of IPTables rules resulted in significantly degraded performance. The complexity of managing and troubleshooting these rules also increased, leading to operational challenges and increased risk of misconfigurations.

How IPVS Solves Scalability

I recommend switching to IPVS when there's a need for a more scalable solution. Unlike IPTables, IPVS handles traffic with a hash table that allows for constant-time lookups, which significantly improves performance as the number of services increases. This ability to manage large numbers of services efficiently makes IPVS a game-changer for large clusters.

IPVS's hash table approach means that regardless of how many services and rules you have, the time it takes to process a packet remains constant. This scalability is particularly crucial for large-scale Kubernetes deployments where the number of services and endpoints can grow rapidly. In one of my deployments, switching to IPVS reduced the average packet processing time by over 50%, demonstrating its efficiency and scalability.

Performance: Keeping Latency Low

Performance with IPTables is acceptable for smaller deployments. However, in a busy cluster with hundreds or thousands of services, the linear processing of rules becomes a major drawback. I've seen scenarios where the CPU usage spikes, and packet processing times increase, leading to overall system sluggishness.

In a typical Kubernetes cluster, IPTables must handle a large number of rules. Each packet needs to be checked against these rules, and as the rule set grows, so does the processing time. This not only increases latency but can also lead to higher CPU utilization, affecting the overall performance of the nodes.

IPVS, on the other hand, uses a more efficient data structure for managing rules. In my experience, switching to IPVS resulted in a noticeable drop in CPU usage and latency. The constant-time algorithm for packet processing ensures that performance remains stable regardless of the cluster size. This improvement is critical for maintaining the responsiveness and reliability of services in large-scale Kubernetes deployments.

IPVS's efficient connection handling and load balancing capabilities contribute significantly to improved performance. For example, in a scenario with high traffic loads, IPVS can distribute the traffic more evenly across backend pods, reducing the risk of any single node becoming a bottleneck. This balanced distribution not only enhances performance but also ensures better resource utilization and service stability.

Practical Considerations and Real-World Experience

Deployment and Migration

Migrating from IPTables to IPVS is a relatively straightforward process, but it requires careful planning and testing. In my experience, the key steps include:

  1. Assessing Cluster Readiness: Ensure that all nodes in the cluster support IPVS. This typically involves verifying kernel versions and enabling the necessary kernel modules.
  2. Configuration Changes: Modify the Kube-proxy configuration to switch to IPVS mode. This change depends upon the CNI you are using. Major managed kubernetes offerings already provide this capability and its generally a configuration change away.
  3. Testing and Validation: Conduct thorough testing to ensure that IPVS is functioning correctly and that there are no disruptions to service traffic. This includes monitoring performance, latency, and resource usage.


Reflecting on my experience with Kubernetes, the switch from IPTables to IPVS for Kube-proxy has been transformative. IPVS offers unparalleled scalability, superior performance, and simplified security management, making it the best choice for modern, large-scale Kubernetes deployments. If you’re managing a growing cluster and struggling with the limitations of IPTables, I highly recommend exploring IPVS. The benefits are clear, and it could be the key to optimizing your Kubernetes environment.

Subscribe to Kubernetes Logs

Sign up now to get access to the library of members-only issues.
Jamie Larson