Worker processes and connections in Nginx - Step-by-Step Execution

Process Flow - Worker processes and connections

Start nginx master process

↓

Spawn worker processes

↓

Each worker listens on ports

↓

Accept client connections

↓

Handle requests concurrently

↓

Close connections when done

↓

Wait for new connections

↩Loop back to Accept client connections

nginx master starts worker processes, each worker handles many client connections concurrently in a loop.

Execution Sample

Nginx

worker_processes 2;
worker_connections 1024;

# Each worker can handle 1024 connections
# Total max connections = 2 * 1024 = 2048

Configures nginx to run 2 worker processes, each able to handle 1024 simultaneous connections.

Process Table

Step	Worker Process	Connections Opened	Action	Total Connections
1	Worker 1	0	Start listening	0
2	Worker 2	0	Start listening	0
3	Worker 1	512	Accept connections	512
4	Worker 2	512	Accept connections	1024
5	Worker 1	1024	Max connections reached	1536
6	Worker 2	1024	Max connections reached	2048
7	Worker 1	1024	Close some connections	1924
8	Worker 2	900	Close some connections	1824
9	Worker 1	1024	Wait for new connections	1824
10	Worker 2	900	Wait for new connections	1824
11	All	-	No more connections to accept	1824

💡 No more incoming connections; workers wait idle.

Status Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 6	After Step 8	Final
Worker 1 Connections	0	512	512	1024	1024	1024	1024
Worker 2 Connections	0	0	512	512	1024	900	900
Total Connections	0	512	1024	1536	2048	1824	1824

Key Moments - 3 Insights

Why does each worker process have its own connections instead of sharing one pool?

Each worker process runs independently to avoid locking and improve performance. See steps 3 and 4 where each worker accepts connections separately.

What happens when a worker reaches its max connections?

It stops accepting new connections until some close. See steps 5 and 6 where workers reach 1024 connections and stop accepting more.

Why do total connections sometimes decrease in the table?

Because some connections close after handling requests, freeing slots for new ones. See steps 7 and 8 where connections close and totals drop.

Visual Quiz - 3 Questions

Look at the execution table, how many connections does Worker 1 have after step 5?

A 900

B 512

C 1024

D 0

💡 Hint

Check the 'Worker 1 Connections' column at step 5 in the execution_table.

At which step do both workers reach their max connections?

A Step 4

B Step 6

C Step 5

D Step 7

💡 Hint

Look for when both workers have 1024 connections in the execution_table.

If worker_processes is set to 4 instead of 2, how does total max connections change?

A It doubles

B It stays the same

C It halves

D It quadruples

💡 Hint

Total max connections = worker_processes * worker_connections, see execution_sample.

Concept Snapshot

nginx uses worker_processes to run multiple workers.
Each worker handles up to worker_connections clients.
Total max connections = worker_processes * worker_connections.
Workers accept and close connections independently.
This improves performance and concurrency.

Full Transcript

In nginx, the master process starts multiple worker processes. Each worker listens for client connections independently. The number of worker processes is set by the 'worker_processes' directive. Each worker can handle a number of simultaneous connections defined by 'worker_connections'. Together, total max connections equal worker_processes times worker_connections. Workers accept connections, handle requests, then close connections and wait for new ones. This design avoids locking and improves performance by distributing load across workers.

Practice

1. What does the worker_processes directive control in an nginx configuration?

easy

A. The timeout for client connections

B. The maximum size of client request body

C. The number of server blocks defined

D. The number of worker processes handling client requests

Solution

1. Step 1: Understand the role of worker_processes

   This directive sets how many worker processes nginx will start to handle incoming requests.

2. Step 2: Compare with other options

   Other options relate to different settings like request size, server blocks, or timeouts, not worker count.

3. Final Answer:

   The number of worker processes handling client requests -> Option D

4. Quick Check:

   worker_processes = number of workers [OK]

Hint: worker_processes = how many workers run [OK]

Common Mistakes:

• Confusing worker_processes with worker_connections
• Thinking it controls timeout or request size
• Mixing it with server block count

2. Which of the following is the correct syntax to set worker connections to 1024 in nginx?

easy

A. worker_connections = 1024

B. worker_connections 1024;

C. worker_connections: 1024

D. worker_connections(1024);

Solution

1. Step 1: Recall nginx directive syntax

   nginx directives use the format: directive_name value; without equals or parentheses.

2. Step 2: Identify correct syntax

   worker_connections 1024; matches this format exactly with a semicolon ending.

3. Final Answer:

   worker_connections 1024; -> Option B

4. Quick Check:

   nginx directives end with semicolon [OK]

Hint: nginx directives end with semicolon, no equals [OK]

Common Mistakes:

• Using equals sign (=) in directive
• Using colon (:) instead of space
• Adding parentheses around values

3. Given the following nginx config snippet:

worker_processes 2;
worker_connections 512;

What is the maximum number of simultaneous connections nginx can handle?

medium

A. 512

B. 256

C. 1024

D. 2

Solution

1. Step 1: Understand the meaning of directives

   worker_processes = 2 means 2 workers; worker_connections = 512 means each worker can handle 512 connections.

2. Step 2: Calculate total connections

   Total connections = worker_processes * worker_connections = 2 * 512 = 1024.

3. Final Answer:

   1024 -> Option C

4. Quick Check:

   2 workers x 512 connections = 1024 [OK]

Hint: Multiply workers by connections per worker [OK]

Common Mistakes:

• Using only worker_connections value
• Using only worker_processes value
• Adding instead of multiplying

4. You set worker_processes 4; and worker_connections 1024; but nginx only handles about 1024 connections total. What is the likely cause?

medium

A. The OS limit on open files is too low

B. worker_processes must be set to 1

C. worker_connections must be less than 512

D. nginx does not support multiple workers

Solution

1. Step 1: Understand expected max connections

   With 4 workers and 1024 connections each, max should be 4096 connections.

2. Step 2: Identify system limits

   OS limits on open files (ulimit) can restrict max connections nginx can open, causing lower actual limits.

3. Final Answer:

   The OS limit on open files is too low -> Option A

4. Quick Check:

   OS file descriptor limit affects max connections [OK]

Hint: Check OS file limits if max connections too low [OK]

Common Mistakes:

• Assuming nginx ignores worker_processes
• Reducing worker_connections unnecessarily
• Believing nginx can't use multiple workers

5. You want nginx to handle at least 10,000 simultaneous connections. Your server has 4 CPU cores. Which configuration is best to achieve this?

hard

A. worker_processes 4; worker_connections 2500;

B. worker_processes 1; worker_connections 10000;

C. worker_processes auto; worker_connections 2000;

D. worker_processes 10; worker_connections 1000;

Solution

1. Step 1: Understand requirements

   To handle at least 10,000 connections on 4 CPU cores, set worker_processes to 4 (matching cores) and calculate worker_connections accordingly.

2. Step 2: Calculate for worker_processes 4; worker_connections 2500;

   worker_processes 4; worker_connections 2500; gives 4 * 2500 = 10,000 connections.

3. Step 3: Compare other options

   B uses 1 worker (poor performance); C with auto (4 workers) * 2000 = 8,000 (insufficient); D uses 10 workers (overhead).

4. Final Answer:

   worker_processes 4; worker_connections 2500; -> Option A

5. Quick Check:

   workers (cores) * connections >= 10,000 [OK]

Hint: Match CPU cores for workers, tune connections to meet target [OK]

Common Mistakes:

• Using single worker (poor performance)
• Setting insufficient connections per worker
• Oversubscribing workers beyond cores