Weighted round-robin in Nginx - Deep Dive

Overview - Weighted round-robin

What is it?

Weighted round-robin is a method used in load balancing to distribute incoming network traffic across multiple servers. Each server is assigned a weight, which determines how much traffic it should receive relative to others. Servers with higher weights get more requests, helping balance load according to their capacity. This method ensures efficient use of resources and better performance.

Why it matters

Without weighted round-robin, all servers would get equal traffic regardless of their capacity, causing slower servers to become overloaded and faster servers underused. This can lead to poor user experience and wasted resources. Weighted round-robin solves this by matching traffic to server strength, improving reliability and speed of applications.

Where it fits

Learners should first understand basic load balancing concepts and simple round-robin distribution. After weighted round-robin, they can explore advanced load balancing methods like least connections or IP hash. This topic fits into the broader study of web server configuration and traffic management.

Mental Model

Core Idea

Weighted round-robin sends more requests to stronger servers by assigning them higher weights, balancing load according to capacity.

Think of it like...

Imagine a group of cashiers at a store where some are faster than others. Instead of giving each cashier the same number of customers, the faster cashiers get more customers to serve, so the line moves smoothly for everyone.

┌───────────────┐
│ Incoming      │
│ Requests      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Load Balancer │
│ (Weighted RR) │
└──────┬────────┘
       │
       ▼
┌───────────┬───────────┬───────────┐
│ Server A  │ Server B  │ Server C  │
│ Weight=5 │ Weight=3 │ Weight=2 │
└───────────┴───────────┴───────────┘

Build-Up - 7 Steps

1

Foundation

Basic round-robin load balancing

Concept: Round-robin distributes requests evenly across servers in order.

In a simple round-robin setup, the load balancer sends the first request to Server A, the second to Server B, the third to Server C, then repeats the cycle. This ensures equal distribution without considering server capacity.

Result

Each server receives the same number of requests in a repeating sequence.

Understanding simple round-robin is essential because weighted round-robin builds on this by adjusting distribution based on server weights.

2

Foundation

Why equal distribution can be inefficient

Concept: Servers often have different capacities, so equal traffic can overload some and underuse others.

If Server A is twice as powerful as Server B, sending them equal requests means Server B may slow down or fail under load, while Server A is idle part of the time.

Result

Unequal server performance leads to bottlenecks and wasted resources.

Recognizing this problem motivates the need for weighted distribution to match traffic with server strength.

3

Intermediate

Assigning weights to servers

🤔Before reading on: do you think higher weights mean fewer or more requests? Commit to your answer.

Concept: Weights are numbers assigned to servers to indicate their relative capacity or priority.

In nginx, weights are set in the upstream block like 'server 192.168.1.1 weight=5;'. A server with weight 5 will get more requests than one with weight 1. The load balancer uses these weights to decide how often to send requests to each server.

Result

Servers receive traffic proportional to their weights, improving load distribution.

Knowing how weights influence request distribution helps you tune performance by matching traffic to server capabilities.

4

Intermediate

Configuring weighted round-robin in nginx

Concept: nginx uses the 'weight' parameter in the upstream block to implement weighted round-robin.

Example nginx config: upstream backend { server 192.168.1.10 weight=5; server 192.168.1.11 weight=3; server 192.168.1.12 weight=2; } server { listen 80; location / { proxy_pass http://backend; } } This config sends more requests to 192.168.1.10 because of its higher weight.

Result

nginx distributes incoming requests according to the weights set, balancing load effectively.

Understanding nginx syntax for weights lets you control traffic flow precisely without extra tools.

5

Intermediate

How weighted round-robin cycles requests

🤔Before reading on: do you think nginx sends all requests to the highest weight server first or mixes them? Commit to your answer.

Concept: Weighted round-robin cycles through servers, sending requests proportionally but mixing them to avoid overload bursts.

nginx keeps counters for each server's weight and cycles through servers, sending requests in proportion to weights. For example, with weights 5,3,2, it sends 5 requests to Server A, then 3 to Server B, then 2 to Server C, then repeats.

Result

Requests are spread smoothly over time, preventing sudden overload on any server.

Knowing the cycling behavior helps predict traffic patterns and troubleshoot load issues.

6

Advanced

Dynamic weight adjustment and health checks

🤔Before reading on: do you think nginx changes weights automatically when servers fail? Commit to your answer.

Concept: nginx can adjust server weights dynamically based on health checks or external scripts to improve reliability.

By default, nginx does not change weights automatically, but with modules like nginx-plus or third-party scripts, weights can be adjusted if a server becomes slow or unhealthy. This prevents sending traffic to failing servers.

Result

Load balancing adapts to server health, improving uptime and user experience.

Understanding dynamic weight adjustment reveals how production systems maintain stability under changing conditions.

7

Expert

Weighted round-robin internals and edge cases

🤔Before reading on: do you think nginx's weighted round-robin perfectly balances load in all cases? Commit to your answer.

Concept: Weighted round-robin is simple but can cause uneven load if request sizes vary or weights are not tuned well.

nginx uses a simple algorithm that cycles requests based on weights, but it does not consider request processing time or size. If some requests are heavy, servers may still get overloaded despite weights. Also, weights must be integers and carefully chosen to avoid bias.

Result

Weighted round-robin improves load distribution but is not perfect for all workloads.

Knowing limitations helps experts decide when to combine weighted round-robin with other methods like least connections.

Under the Hood

nginx maintains a list of servers with assigned weights. For each incoming request, it cycles through servers, sending requests according to their weights by incrementing counters. This is done efficiently in memory without complex calculations. The algorithm ensures that over time, the number of requests matches the weight ratios.

Why designed this way?

Weighted round-robin was designed to be simple and fast, suitable for high-performance web servers. Complex load balancing algorithms can add latency or overhead. Using integer weights and cycling counters balances efficiency with improved load distribution over simple round-robin.

┌───────────────┐
│ Incoming      │
│ Request       │
└──────┬────────┘
       │
       ▼
┌─────────────────────────────┐
│ Weighted Round-Robin Logic   │
│ ┌───────────────┐           │
│ │ Server List   │           │
│ │ A (weight=5)  │           │
│ │ B (weight=3)  │  Counters │
│ │ C (weight=2)  │  track    │
│ └───────────────┘  requests │
└─────────┬───────────────────┘
          │
          ▼
┌───────────────┬───────────┬───────────┐
│ Server A      │ Server B  │ Server C  │
│ Receives 5   │ Receives 3│ Receives 2│
│ requests     │ requests  │ requests  │
└──────────────┴───────────┴───────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does weighted round-robin guarantee perfectly equal load on all servers? Commit yes or no.

Common Belief: Weighted round-robin perfectly balances load exactly according to weights at all times.

Reality: It balances requests proportionally but does not account for request size or processing time, so actual load can vary.

Why it matters: Assuming perfect balance can cause overlooked overloads and performance issues in production.

Quick: Do you think nginx automatically reduces weights when a server is slow? Commit yes or no.

Common Belief: nginx automatically adjusts weights based on server health or speed.

Reality: Standard nginx does not change weights dynamically; this requires extra modules or external tools.

Why it matters: Believing in automatic adjustment can lead to misconfigured systems that send traffic to failing servers.

Quick: Is it true that weights can be any decimal number in nginx? Commit yes or no.

Common Belief: Weights in nginx can be fractional or decimal numbers for fine tuning.

Reality: nginx weights must be positive integers; decimals are not supported.

Why it matters: Trying to use decimals causes config errors or ignored weights, leading to unexpected load distribution.

Quick: Does weighted round-robin always outperform simple round-robin? Commit yes or no.

Common Belief: Weighted round-robin is always better than simple round-robin.

Reality: Weighted round-robin is better when servers differ in capacity, but if all servers are equal, simple round-robin is sufficient and simpler.

Why it matters: Using weighted round-robin unnecessarily adds complexity without benefit.

Expert Zone

1

Weights are integers, so fine-grained tuning requires careful scaling to avoid rounding errors.

2

Weighted round-robin does not consider server response time, so combining it with health checks or least connections improves real-world performance.

3

In nginx, the order of servers in the upstream block can affect request distribution subtly when weights are equal.

When NOT to use

Avoid weighted round-robin when request sizes vary greatly or server response times fluctuate rapidly; use least connections or adaptive load balancing instead.

Production Patterns

In production, weighted round-robin is often combined with active health checks and failover to remove unhealthy servers dynamically. Weights are tuned based on server benchmarks and monitored continuously.

Connections

Least Connections Load Balancing

Alternative load balancing method that sends requests to the server with the fewest active connections.

Understanding weighted round-robin helps contrast it with least connections, which adapts better to varying request durations.

Weighted Voting Systems (Political Science)

Both assign weights to participants to influence outcomes proportionally.

Recognizing weighted round-robin as a form of weighted voting clarifies how proportional influence works in different fields.

Traffic Signal Timing (Civil Engineering)

Traffic lights allocate green time based on road traffic volume, similar to weights in load balancing.

Seeing weighted round-robin like traffic signal timing helps understand how resource allocation optimizes flow in complex systems.

Common Pitfalls

#1 Assigning zero or negative weights to servers.

Wrong approach:

upstream backend {
server 192.168.1.10 weight=0;
server 192.168.1.11 weight=-2;
}

Correct approach:

upstream backend {
server 192.168.1.10 weight=5;
server 192.168.1.11 weight=3;
}

Root cause:

Weights must be positive integers; zero or negative values are invalid and cause nginx to ignore or error.

#2 Using decimal weights in nginx configuration.

Wrong approach:

upstream backend {
server 192.168.1.10 weight=2.5;
server 192.168.1.11 weight=1.5;
}

Correct approach:

upstream backend {
server 192.168.1.10 weight=3;
server 192.168.1.11 weight=1;
}

Root cause:

nginx only accepts integer weights; decimals cause configuration errors or ignored weights.

#3 Expecting weighted round-robin to handle server failures automatically.

Wrong approach:

upstream backend {
server 192.168.1.10 weight=5;
server 192.168.1.11 weight=3;
server 192.168.1.12 weight=2;
}
# No health checks configured

Correct approach:

upstream backend {
server 192.168.1.10 weight=5 max_fails=3 fail_timeout=30s;
server 192.168.1.11 weight=3 max_fails=3 fail_timeout=30s;
server 192.168.1.12 weight=2 max_fails=3 fail_timeout=30s;
}

Root cause:

Without health checks, nginx sends traffic to failed servers, causing errors and downtime.

Key Takeaways

Weighted round-robin improves load balancing by sending more requests to stronger servers based on assigned weights.

nginx implements weighted round-robin using integer weights in the upstream configuration block.

This method cycles requests proportionally but does not consider request size or server response time, so it has limitations.

Proper weight tuning and health checks are essential for effective and reliable load balancing in production.

Understanding weighted round-robin helps choose the right load balancing strategy and optimize resource use.