Worker processes and connections in Nginx - Commands & Configuration

Introduction

When a web server handles many visitors, it needs to manage how many tasks it can do at once. Worker processes and connections in nginx control how many users can be served at the same time without slowing down.

When your website gets slow because too many people visit at once

When you want to make sure your server uses all CPU cores efficiently

When you need to handle many connections without crashing

When tuning nginx for better performance on busy servers

When setting up nginx on a new server and want it to handle traffic well

Config File - nginx.conf

nginx.conf

worker_processes auto;
events {
    worker_connections 1024;
}
http {
    server {
        listen 80;
        server_name example.com;
        location / {
            root /usr/share/nginx/html;
            index index.html;
        }
    }
}

worker_processes auto; tells nginx to use as many worker processes as CPU cores available, making full use of the server's power.

worker_connections 1024; inside events sets how many connections each worker can handle at once.

This setup helps nginx serve many users efficiently by balancing work across CPU cores and limiting connections per worker.

Commands

This command checks the nginx configuration file for errors before applying changes. It helps avoid server crashes due to bad config.

Terminal

sudo nginx -t

Expected Output

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok

nginx: configuration file /etc/nginx/nginx.conf test is successful

This command reloads nginx to apply the new configuration without stopping the server, so users don't experience downtime.

Terminal

sudo systemctl reload nginx

Expected Output

No output (command runs silently)

This command shows running nginx processes, so you can verify the number of worker processes running.

Terminal

ps aux | grep nginx

Expected Output

root       1234  0.0  0.1  123456  2345 ?        Ss   10:00   0:00 nginx: master process /usr/sbin/nginx

www-data   1235  0.0  0.1  123456  2345 ?        S    10:00   0:00 nginx: worker process

www-data   1236  0.0  0.1  123456  2345 ?        S    10:00   0:00 nginx: worker process

This command counts how many connections are open on port 80, helping you see how many users nginx is currently serving.

Terminal

sudo lsof -i :80 | wc -l

Expected Output

15

Key Concept

If you remember nothing else from this pattern, remember: worker_processes sets how many CPU cores nginx uses, and worker_connections sets how many users each worker can handle at once.

Common Mistakes

Setting worker_processes to a fixed low number like 1 on a multi-core server

This wastes CPU resources and limits how many users nginx can serve at the same time.

Use 'worker_processes auto;' to let nginx use all CPU cores automatically.

Setting worker_connections too low, like 512, on a busy server

Limits the number of simultaneous connections per worker, causing slowdowns or dropped connections.

Increase worker_connections to a higher number like 1024 or more based on expected traffic.

Not testing nginx config with 'nginx -t' before reloading

Bad config changes can cause nginx to fail to reload, leading to downtime.

Always run 'sudo nginx -t' to check config syntax before reloading.

Summary

Set worker_processes to 'auto' to use all CPU cores for better performance.

Set worker_connections to control how many connections each worker can handle.

Test nginx configuration with 'nginx -t' before reloading to avoid errors.

Reload nginx with 'systemctl reload nginx' to apply changes without downtime.

Check running worker processes and active connections to monitor server load.

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