API versioning with routing in Nginx - Commands & Configuration

Introduction

When you update an API, old clients might still use the previous version. API versioning with routing helps direct requests to the correct version so everyone gets the right response without breaking.

When you want to support multiple versions of an API at the same time.

When you need to upgrade your API without forcing all users to update immediately.

When you want to test a new API version while keeping the old one live.

When different clients require different API versions based on their capabilities.

When you want to organize your API endpoints clearly by version.

Config File - nginx.conf

nginx.conf

events {}

http {
    upstream backend-v1 {
        server 127.0.0.1:8081;
    }

    upstream backend-v2 {
        server 127.0.0.1:8082;
    }

    server {
        listen 80;

        location /api/v1/ {
            proxy_pass http://backend-v1/;
        }

        location /api/v2/ {
            proxy_pass http://backend-v2/;
        }
    }
}

This configuration sets up an Nginx server listening on port 80.

Requests starting with /api/v1/ are routed to the backend server at 127.0.0.1:8081, which serves version 1 of the API.

Requests starting with /api/v2/ are routed to the backend server at 127.0.0.1:8082, which serves version 2 of the API.

The upstream blocks define the backend servers for each API version.

Commands

This command tests the Nginx configuration file for syntax errors before applying it.

Terminal

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.

Terminal

sudo systemctl reload nginx

Expected Output

No output (command runs silently)

This command sends a request to the version 1 API endpoint to verify routing works correctly.

Terminal

curl -i http://localhost/api/v1/users

Expected Output

HTTP/1.1 200 OK

Content-Type: application/json



{"version":"v1","users":[]}

This command sends a request to the version 2 API endpoint to verify routing works correctly.

Terminal

curl -i http://localhost/api/v2/users

Expected Output

HTTP/1.1 200 OK

Content-Type: application/json



{"version":"v2","users":[]}

Key Concept

If you remember nothing else from this pattern, remember: use URL paths to route requests to different API versions so clients get the right backend response.

Common Mistakes

Not testing the Nginx configuration before reloading.

This can cause Nginx to fail to reload and stop serving requests.

Always run 'nginx -t' to check for syntax errors before reloading.

Using the same backend server for all API versions without routing.

Clients will not get the correct API version responses, causing errors or confusion.

Define separate upstream servers and route requests based on the version in the URL.

Forgetting the trailing slash in location paths like '/api/v1/'.

This can cause incorrect routing or missing resources.

Include the trailing slash in location blocks to match the URL path correctly.

Summary

Define separate location blocks in Nginx for each API version using URL paths.

Use upstream blocks to point to different backend servers for each API version.

Test the Nginx configuration with 'nginx -t' before reloading to avoid downtime.

Reload Nginx to apply the new routing rules without stopping the server.

Verify routing by sending requests to each API version URL and checking responses.

Practice

1. What is the main purpose of using API versioning with routing in nginx?

easy

A. To block all API requests except the latest version

B. To combine all API versions into a single endpoint

C. To run multiple API versions side by side and route requests accordingly

D. To disable routing and serve static files only

Solution

1. Step 1: Understand API versioning concept

   API versioning allows different versions of an API to coexist, so clients using older versions still work.

2. Step 2: Role of nginx routing

   nginx uses location blocks to route requests to the correct API version based on the URL path.

3. Final Answer:

   To run multiple API versions side by side and route requests accordingly -> Option C

4. Quick Check:

   API versioning = multiple versions side by side [OK]

Hint: API versioning means routing requests to different versions [OK]

Common Mistakes:

• Thinking API versioning disables old versions
• Assuming all versions merge into one endpoint
• Confusing routing with blocking requests

2. Which nginx configuration snippet correctly routes requests to API version v1 at path /api/v1/?

easy

A. location /api/v1/ { proxy_pass http://backend_v1; }

B. location /api/v1 { proxy_pass http://backend_v1; }

C. location /api/v1/* { proxy_pass http://backend_v1; }

D. location /api/v1$ { proxy_pass http://backend_v1; }

Solution

1. Step 1: Understand nginx location matching

   Using location /api/v1/ matches all requests starting with /api/v1/, including subpaths.

2. Step 2: Check syntax correctness

   location /api/v1/ { proxy_pass http://backend_v1; } uses correct syntax without wildcards or regex, which nginx does not support in this form.

3. Final Answer:

   location /api/v1/ { proxy_pass http://backend_v1; } -> Option A

4. Quick Check:

   Trailing slash in location matches subpaths [OK]

Hint: Use trailing slash in location to match all subpaths [OK]

Common Mistakes:

• Using wildcards (*) in location which nginx does not support
• Missing trailing slash causing partial matches
• Using regex syntax without ~

3. Given this nginx config snippet, what backend will handle a request to /api/v2/users?

location /api/v1/ {
  proxy_pass http://backend_v1;
}
location /api/v2/ {
  proxy_pass http://backend_v2;
}

medium

A. http://backend_v2

B. No backend, 404 error

C. http://backend_v1

D. Both backends in round-robin

Solution

1. Step 1: Match request path to location blocks

   The request path /api/v2/users starts with /api/v2/, so it matches the second location block.

2. Step 2: Determine proxy backend

   The matching location proxies to http://backend_v2, so this backend handles the request.

3. Final Answer:

   http://backend_v2 -> Option A

4. Quick Check:

   Request path prefix matches location prefix [OK]

Hint: Match URL prefix to location prefix to find backend [OK]

Common Mistakes:

• Choosing backend_v1 for /api/v2/ path
• Assuming nginx load balances both backends automatically
• Thinking unmatched paths cause proxy to backend_v1

4. Identify the error in this nginx config for API versioning:

location /api/v1 {
  proxy_pass http://backend_v1;
}
location /api/v2/ {
  proxy_pass http://backend_v2;
}

medium

A. proxy_pass must use IP address, not hostname

B. proxy_pass URLs must include trailing slash

C. location blocks cannot be adjacent

D. Missing trailing slash in first location causes incorrect routing

Solution

1. Step 1: Check location path consistency

   The first location uses /api/v1 without trailing slash, which matches only exact path or prefix differently than /api/v1/.

2. Step 2: Understand routing impact

   Requests like /api/v1/users won't match the first location correctly, causing routing errors.

3. Final Answer:

   Missing trailing slash in first location causes incorrect routing -> Option D

4. Quick Check:

   Trailing slash in location matters for prefix matching [OK]

Hint: Always use trailing slash in location for API version prefixes [OK]

Common Mistakes:

• Ignoring trailing slash difference in location paths
• Thinking proxy_pass URL must have trailing slash
• Believing location blocks cannot be next to each other

5. You want to support API versions v1 and v2 in nginx, but also redirect any request to /api/ without version to v2 by default. Which config snippet achieves this correctly?

hard

A. location /api/ { proxy_pass http://backend_v2; }
location /api/v1/ { proxy_pass http://backend_v1; }

B. location /api/v1/ { proxy_pass http://backend_v1; }
location /api/v2/ { proxy_pass http://backend_v2; }
location /api/ { return 301 /api/v2/; }

C. location /api/ { proxy_pass http://backend_v1; }
location /api/v2/ { proxy_pass http://backend_v2; }

D. location /api/v1/ { proxy_pass http://backend_v1; }
location /api/v2/ { proxy_pass http://backend_v2; }
location /api/ { proxy_pass http://backend_v2; }

Solution

1. Step 1: Define explicit version locations

   Locations for /api/v1/ and /api/v2/ proxy requests to respective backends.

2. Step 2: Redirect base /api/ to default version

   Using return 301 /api/v2/; in /api/ location sends clients to v2 URL, ensuring default version usage.

3. Final Answer:

   location /api/v1/ { proxy_pass http://backend_v1; } location /api/v2/ { proxy_pass http://backend_v2; } location /api/ { return 301 /api/v2/; } -> Option B

4. Quick Check:

   Redirect base path to default version with return 301 [OK]

Hint: Use return 301 to redirect base API path to default version [OK]

Common Mistakes:

• Proxying /api/ directly instead of redirecting
• Overlapping location blocks causing conflicts
• Using proxy_pass in /api/ without redirect