Request body handling in Nginx - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the effect of the directive 'client_max_body_size 1m;' in nginx?

Consider the nginx configuration snippet below:

client_max_body_size 1m;

What happens when a client sends a request body larger than 1 megabyte?

A nginx returns a 413 Request Entity Too Large error to the client.

B nginx silently truncates the request body to 1 megabyte and processes it.

C nginx accepts the full request body but logs a warning.

D nginx closes the connection without any response.

💡 Hint

Think about how nginx enforces limits on client request sizes.

The client_max_body_size directive sets the maximum allowed size of the client request body. If the client sends a body larger than this limit, nginx responds with a 413 error.

❓ Configuration

intermediate

How to configure nginx to save client request bodies to a specific directory?

You want nginx to save the full client request body to files in /var/tmp/nginx_body for later inspection. Which configuration snippet correctly enables this?

A client_body_save /var/tmp/nginx_body;

B client_body_directory /var/tmp/nginx_body;

C client_body_path /var/tmp/nginx_body;

D client_body_temp_path /var/tmp/nginx_body 1 2;

💡 Hint

Look for the directive that controls the temporary storage path for client request bodies.

The client_body_temp_path directive sets the directory where nginx stores temporary files for client request bodies. The numbers specify subdirectory levels for better file distribution.

❓ Troubleshoot

advanced

Why does nginx return a 400 Bad Request when client_body_buffer_size is too small?

Given this nginx configuration:

client_body_buffer_size 1k;

A client sends a POST request with a 2 KB body. nginx returns a 400 Bad Request error. Why?

A The buffer size is too small to hold the entire request body in memory, and nginx fails to buffer it properly.

B nginx does not support buffering request bodies larger than 1 KB.

C The client request body is corrupted, causing nginx to reject it.

D The 400 error is unrelated to buffer size and caused by a syntax error in the configuration.

💡 Hint

Consider how nginx buffers client request bodies before processing.

The client_body_buffer_size sets the size of the buffer used to read the client request body. If the body is larger than this buffer and nginx cannot write to disk (due to permissions or other issues), it may reject the request with a 400 error.

🔀 Workflow

advanced

Order the steps nginx follows to handle a client request body

Arrange the following steps in the correct order nginx processes a client request body:

A 2,1,4,3

B 1,2,3,4

C 1,4,2,3

D 1,2,4,3

💡 Hint

Think about how nginx validates size before reading the body.

nginx first checks if the body size exceeds the limit (1). If yes, it returns an error (4). Otherwise, it reads the body (2) and then passes it to the backend (3).

✅ Best Practice

expert

Which nginx configuration best prevents denial-of-service attacks via large request bodies?

You want to protect your nginx server from clients sending very large request bodies that could exhaust resources. Which configuration snippet is the best practice?

A client_max_body_size 10m; client_body_buffer_size 128k;

B client_max_body_size 1m; client_body_buffer_size 512k;

C client_max_body_size 100m; client_body_buffer_size 1m;

D client_max_body_size 0; client_body_buffer_size 64k;

💡 Hint

Consider reasonable limits to block very large bodies but allow normal usage.

Setting client_max_body_size to 1m limits request bodies to 1 megabyte, preventing very large uploads. A buffer size of 512k balances memory use and performance. Setting max size to 0 disables body reading, which breaks many applications.

Practice

1. What does the client_max_body_size directive control in nginx?

easy

A. The maximum number of requests per second

B. The maximum size of the client request body that nginx will accept

C. The timeout duration for client requests

D. The maximum number of client connections allowed

Solution

1. Step 1: Understand the purpose of client_max_body_size

   This directive sets a limit on how large the data sent by a client in the request body can be.

2. Step 2: Compare with other options

   Other options relate to connections, timeouts, or request rates, which are unrelated to request body size.

3. Final Answer:

   The maximum size of the client request body that nginx will accept -> Option B

4. Quick Check:

   Request body size limit = D [OK]

Hint: Remember: max_body_size limits upload size [OK]

Common Mistakes:

• Confusing body size with connection limits
• Mixing up timeout settings with body size
• Thinking it controls request rate

2. Which of the following is the correct syntax to set the maximum client request body size to 10 megabytes in nginx?

easy

A. client_max_body_size 10MB;

B. client_max_body_size 10M

C. client_max_body_size 10mb;

D. client_max_body_size 10m;

Solution

1. Step 1: Recall nginx size suffixes

   nginx uses lowercase 'm' for megabytes, so '10m' is correct syntax.

2. Step 2: Check other options

   Uppercase 'MB' or 'M' and lowercase 'mb' are invalid or not recognized by nginx.

3. Final Answer:

   client_max_body_size 10m; -> Option D

4. Quick Check:

   Size suffix 'm' lowercase = B [OK]

Hint: Use lowercase 'm' for megabytes in nginx sizes [OK]

Common Mistakes:

• Using uppercase 'MB' or 'M' suffix
• Using 'mb' instead of 'm'
• Omitting the semicolon

3. Given this nginx config snippet inside a location block:

proxy_set_body $request_body;
proxy_pass http://backend;

What will be forwarded to the backend server?

medium

A. The original client request body content

B. An empty body regardless of client data

C. The request headers only, no body

D. The request URI instead of the body

Solution

1. Step 1: Understand proxy_set_body $request_body;

   This directive sets the body sent to the backend to the original client request body.

2. Step 2: Effect on proxy_pass

   With this setting, the backend receives the exact data the client sent in the request body.

3. Final Answer:

   The original client request body content -> Option A

4. Quick Check:

   proxy_set_body $request_body forwards client body = A [OK]

Hint: proxy_set_body $request_body forwards client data [OK]

Common Mistakes:

• Assuming body is empty by default
• Confusing headers with body content
• Thinking URI is sent as body

4. You set client_max_body_size 5m; but clients still upload files larger than 5MB without errors. What is the most likely cause?

medium

A. The server has no disk space left

B. The client is ignoring nginx limits

C. The directive is set in the wrong context and not applied

D. The proxy_set_body directive is missing

Solution

1. Step 1: Check directive context

   client_max_body_size must be set in http, server, or location context to apply properly.

2. Step 2: Understand client behavior and other options

   Clients cannot bypass nginx limits; disk space or proxy_set_body do not affect this limit.

3. Final Answer:

   The directive is set in the wrong context and not applied -> Option C

4. Quick Check:

   Wrong context means limit ignored = C [OK]

Hint: Set client_max_body_size in correct context (http/server/location) [OK]

Common Mistakes:

• Blaming clients for ignoring limits
• Confusing proxy_set_body with size limits
• Ignoring directive placement

5. You want nginx to reject client requests with bodies larger than 2MB and forward the exact request body to a backend server. Which configuration snippet achieves this?

hard

A. client_max_body_size 2m;
proxy_set_body $request_body;
proxy_pass http://backend;

B. client_max_body_size 2m;
proxy_pass http://backend;
proxy_set_body $request_body

C. proxy_set_body $request_body;
client_max_body_size 2m;
proxy_pass http://backend

D. proxy_pass http://backend;
client_max_body_size 2m;
proxy_set_body $request_body

Solution

1. Step 1: Set size limit before proxying

   client_max_body_size 2m; must be declared to reject large bodies before proxying.

2. Step 2: Forward original body to backend

   proxy_set_body $request_body; ensures the backend receives the client data exactly.

3. Step 3: Correct order and syntax

   client_max_body_size 2m; proxy_set_body $request_body; proxy_pass http://backend; lists directives in proper order and syntax inside the location block.

4. Final Answer:

   client_max_body_size 2m; proxy_set_body $request_body; proxy_pass http://backend; -> Option A

5. Quick Check:

   Limit then forward body then proxy = A [OK]

Hint: Set size limit first, then proxy_set_body, then proxy_pass [OK]

Common Mistakes:

• Wrong directive order causing ignored limits
• Missing semicolons
• Not forwarding the request body properly