Why Nginx handles API routing - Why It Works

Introduction

When you build web applications, you often need to send requests to different parts of your system. Nginx can help by directing these requests to the right place, especially for APIs. This makes your app faster and easier to manage.

When you want to send API requests to different backend servers based on the URL path.

When you need to serve both a website and API from the same domain without conflicts.

When you want to improve performance by letting Nginx handle routing before requests reach your app.

When you want to add security rules or caching specifically for API routes.

When you want to simplify your backend by letting Nginx manage which service handles which API call.

Config File - nginx.conf

nginx.conf

events {}
http {
    server {
        listen 80;
        server_name example.com;

        location /api/ {
            proxy_pass http://localhost:5000/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        location / {
            root /var/www/html;
            index index.html;
        }
    }
}

This configuration tells Nginx to listen on port 80 for requests to example.com.

Requests starting with /api/ are sent to a backend server running on localhost port 5000.

Other requests serve static files from /var/www/html.

The proxy_set_header lines pass important client information to the backend.

Commands

Check if the Nginx configuration file syntax is correct before applying changes.

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

Reload Nginx to apply the new configuration without stopping the server.

Terminal

sudo systemctl reload nginx

Expected Output

No output (command runs silently)

Send a test request to the API route to verify Nginx routes it to the backend server.

Terminal

curl -i http://example.com/api/test

Expected Output

HTTP/1.1 200 OK

Server: nginx

Date: Wed, 01 Jan 2025 12:00:00 GMT

Content-Type: application/json

Content-Length: 15



{"message":"ok"}

→

-i - Show HTTP response headers along with the body

Send a request to the root URL to verify Nginx serves static files correctly.

Terminal

curl -i http://example.com/

Expected Output

HTTP/1.1 200 OK

Server: nginx

Date: Wed, 01 Jan 2025 12:00:00 GMT

Content-Type: text/html

Content-Length: 1256



<!DOCTYPE html><html>...</html>

→

-i - Show HTTP response headers along with the body

Key Concept

If you remember nothing else from this pattern, remember: Nginx routes API requests by matching URL paths and forwarding them to the right backend server.

Common Mistakes

Not reloading Nginx after changing the configuration file.

Nginx keeps running the old configuration, so routing changes do not take effect.

Always run 'sudo nginx -t' to check syntax, then 'sudo systemctl reload nginx' to apply changes.

Forgetting to include proxy headers like Host and X-Real-IP.

Backend servers may not receive correct client information, causing issues with logging or security.

Add proxy_set_header lines to pass client info to the backend.

Using incorrect proxy_pass URL without trailing slash.

Nginx may append the original URI incorrectly, causing wrong backend paths.

Use a trailing slash in proxy_pass like 'http://localhost:5000/' to correctly map paths.

Summary

Nginx uses location blocks to match API routes and forward them to backend servers.

Always test Nginx configuration syntax before reloading to avoid downtime.

Use curl commands to verify that API routing and static file serving work as expected.

Practice

1. Why is Nginx commonly used to handle API routing in web applications?

easy

A. Because it replaces the need for backend servers

B. Because it efficiently directs API requests to the correct backend services

C. Because it stores API data permanently

D. Because it automatically writes API documentation

Solution

1. Step 1: Understand Nginx's role in routing

   Nginx acts as a traffic controller, sending API requests to the right backend service based on rules.

2. Step 2: Identify what Nginx does not do

   Nginx does not store data, replace backend servers, or write documentation; it only routes requests.

3. Final Answer:

   Because it efficiently directs API requests to the correct backend services -> Option B

4. Quick Check:

   Routing = directing requests [OK]

Hint: Nginx routes requests, it doesn't store or create data [OK]

Common Mistakes:

• Thinking Nginx stores API data
• Believing Nginx replaces backend servers
• Assuming Nginx writes API docs

2. Which Nginx directive is used to forward API requests to a backend server?

easy

A. proxy_pass

B. listen

C. server_name

D. root

Solution

1. Step 1: Identify the directive for forwarding requests

   The proxy_pass directive tells Nginx where to send the incoming API requests.

2. Step 2: Differentiate from other directives

   listen sets the port, server_name sets the domain, and root sets the file path, none forward requests.

3. Final Answer:

   proxy_pass -> Option A

4. Quick Check:

   Forwarding = proxy_pass [OK]

Hint: proxy_pass sends requests to backend servers [OK]

Common Mistakes:

• Confusing listen with proxy_pass
• Using root to forward requests
• Mixing server_name with routing

3. Given this Nginx config snippet, what backend URL will a request to /api/users be forwarded to?

location /api/ {
    proxy_pass http://backend-service:8080/;
}

medium

A. http://backend-service:8080/api/users

B. http://backend-service:8080/

C. http://backend-service:8080/api/

D. http://backend-service:8080/users

Solution

1. Step 1: Understand proxy_pass with trailing slash

   Since proxy_pass ends with a slash, Nginx replaces the matching /api/ part in the request URL with the backend URL.

2. Step 2: Apply URL rewrite logic

   Request /api/users becomes /users appended to http://backend-service:8080/, resulting in http://backend-service:8080/users.

3. Final Answer:

   http://backend-service:8080/users -> Option D

4. Quick Check:

   Trailing slash rewrites path [OK]

Hint: Trailing slash in proxy_pass rewrites matched path [OK]

Common Mistakes:

• Appending full original path without rewrite
• Ignoring trailing slash effect
• Assuming no path change

4. Identify the error in this Nginx config that prevents API routing:

location /api {
    proxy_pass http://backend-service:8080;
}

medium

A. Missing trailing slash in location path

B. proxy_pass must use HTTPS instead of HTTP

C. proxy_pass URL missing trailing slash causing path issues

D. location directive should be inside server block

Solution

1. Step 1: Check proxy_pass URL format

   The proxy_pass URL lacks a trailing slash, so Nginx appends the full original request URI, causing incorrect backend paths.

2. Step 2: Understand impact on routing

   Without the trailing slash, requests like /api/users become http://backend-service:8080/api/users which may not be expected by backend.

3. Final Answer:

   proxy_pass URL missing trailing slash causing path issues -> Option C

4. Quick Check:

   Trailing slash in proxy_pass fixes path [OK]

Hint: Always add trailing slash in proxy_pass for correct routing [OK]

Common Mistakes:

• Ignoring trailing slash importance
• Thinking location path needs trailing slash
• Assuming HTTPS is mandatory

5. You want Nginx to route requests starting with /api/v1/ to http://v1-backend:9000/ and requests starting with /api/v2/ to http://v2-backend:9000/. Which configuration correctly achieves this?

hard

A. location /api/v1/ { proxy_pass http://v1-backend:9000/; }\nlocation /api/v2/ { proxy_pass http://v2-backend:9000/; }

B. location /api/ { proxy_pass http://v1-backend:9000/; }\nlocation /api/ { proxy_pass http://v2-backend:9000/; }

C. location /api/v1 { proxy_pass http://v1-backend:9000; }\nlocation /api/v2 { proxy_pass http://v2-backend:9000; }

D. location /api/v1/ { proxy_pass http://v2-backend:9000/; }\nlocation /api/v2/ { proxy_pass http://v1-backend:9000/; }

Solution

1. Step 1: Match location blocks to API versions

   Separate location blocks for /api/v1/ and /api/v2/ ensure requests route to correct backend.

2. Step 2: Use trailing slashes in proxy_pass URLs

   Trailing slashes in proxy_pass ensure correct path rewriting for backend services.

3. Step 3: Verify options

   location /api/v1/ { proxy_pass http://v1-backend:9000/; }\nlocation /api/v2/ { proxy_pass http://v2-backend:9000/; } correctly matches paths and proxies to correct backends. location /api/ { proxy_pass http://v1-backend:9000/; }\nlocation /api/ { proxy_pass http://v2-backend:9000/; } duplicates location blocks, location /api/v1 { proxy_pass http://v1-backend:9000; }\nlocation /api/v2 { proxy_pass http://v2-backend:9000; } misses trailing slashes, location /api/v1/ { proxy_pass http://v2-backend:9000/; }\nlocation /api/v2/ { proxy_pass http://v1-backend:9000/; } swaps backends incorrectly.

4. Final Answer:

   location /api/v1/ { proxy_pass http://v1-backend:9000/; }\nlocation /api/v2/ { proxy_pass http://v2-backend:9000/; } -> Option A

5. Quick Check:

   Separate locations + trailing slash = correct routing [OK]

Hint: Use distinct location blocks with trailing slashes for each API version [OK]

Common Mistakes:

• Using same location for different APIs
• Missing trailing slashes causing path errors
• Swapping backend URLs by mistake