Request body handling in Nginx - Mini Project: Build & Apply

Request Body Handling in Nginx

📖 Scenario: You are setting up an Nginx server to handle HTTP POST requests with JSON data. You want to configure Nginx to read the request body and store it in a variable for further processing or logging.

🎯 Goal: Configure Nginx to read the request body into a variable and then log the content of the request body.

📋 What You'll Learn

Create a server block with a location to accept POST requests

Add a directive to read the request body into a variable

Use the variable to log the request body content

Print the request body content in the access log

💡 Why This Matters

🌍 Real World

Many web applications need to inspect or log the content of POST requests for debugging, auditing, or routing decisions. Nginx can be configured to read and handle request bodies efficiently.

💼 Career

Understanding how to handle request bodies in Nginx is useful for DevOps engineers and site reliability engineers who manage web servers and need to troubleshoot or customize request processing.

1

Create a basic server block

Create an Nginx server block listening on port 8080 with a /post location that accepts POST requests.

Nginx

server {
    listen 8080;
    # Your code here
}

Hint

Use server {} block with listen 8080; and a location /post {} inside.

2

Add directive to read request body

Inside the location /post, add the directive client_body_buffer_size 10k; and set client_body_in_file_only off; to enable reading the request body into memory.

Nginx

server {
    listen 8080;
    location /post {
        # Add client_body_buffer_size and client_body_in_file_only directives here
    }
}

Hint

Use client_body_buffer_size 10k; to set buffer size and client_body_in_file_only off; to keep body in memory.

3

Capture request body into a variable

Inside the location /post, add the directive set $req_body ""; to initialize a variable, then use access_by_lua_block to read the request body into $req_body variable using Lua scripting.

Nginx

server {
    listen 8080;
    location /post {
        client_body_buffer_size 10k;
        client_body_in_file_only off;
        # Initialize $req_body variable
        # Use access_by_lua_block to read request body
    }
}

Hint

Use set $req_body ""; to declare the variable and Lua code inside access_by_lua_block to read the body.

4

Log the request body content

Add a log_format named with_body that logs the $req_body variable, then set access_log to use this format inside the server block. Finally, add return 200 'OK'; inside the location /post to respond.

Nginx

log_format with_body '$remote_addr - $remote_user [$time_local] "$request" $status $body_bytes_sent "$http_referer" "$http_user_agent" "$req_body";  

server {
    listen 8080;
    access_log /var/log/nginx/access.log with_body;
    location /post {
        client_body_buffer_size 10k;
        client_body_in_file_only off;
        set $req_body "";
        access_by_lua_block {
            ngx.req.read_body()
            local data = ngx.req.get_body_data()
            if data then
                ngx.var.req_body = data
            end
        }
        # Add return statement here
    }
}

Hint

Define log_format with $req_body, set access_log to use it, and add return 200 'OK'; in location.

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