0Pricing
API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) · Lección

Versionado de API con Nginx

Configure Nginx para admitir distintas versiones de una API y permitir actualizaciones fluidas con compatibilidad con versiones anteriores.

Versionado de API con Nginx es una lección gratuita de API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway), y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

What is API Versioning?

When you build APIs, they often change over time. New features are added, old ones removed, or logic is updated.

API versioning is a strategy to manage these changes without breaking existing applications that rely on your API.

It allows different versions of your API to coexist, supporting both older and newer clients simultaneously.

Why Versioning Matters

Imagine you update your API, and suddenly, all apps using the old API stop working. That's a bad experience!

  • Backward Compatibility: Ensures older clients continue to function.
  • Controlled Upgrades: Allows clients to migrate to new versions at their own pace.
  • Risk Management: Isolates changes, reducing the risk of widespread issues.

Common Versioning Approaches

There are several ways to indicate an API version:

  • URL Path: /api/v1/users
  • Custom Header: X-API-Version: 1
  • Query Parameter: /api/users?version=1

For Nginx, URL Path versioning is often the simplest and most common to implement using location blocks, which is what we'll focus on.

Nginx for URL-based Versioning

Nginx uses location blocks to match specific URL patterns. This is perfect for routing requests based on a version number in the path.

For example, requests to /api/v1/ can be sent to one backend, while requests to /api/v2/ go to another.

This allows you to deploy different versions of your API application, each serving its specific version.

Setting Up API Version 1

Let's configure Nginx to route requests for /api/v1/ to a backend server running our first API version.

We'll define an upstream block for our backend service and then a location block to proxy requests.

http {
  upstream api_v1_backend {
    server 192.168.1.10:8080;
  }

  server {
    listen 80;
    server_name example.com;

    location /api/v1/ {
      proxy_pass http://api_v1_backend/;
      proxy_set_header Host $host;
    }
  }
}

Adding API Version 2

Now, let's introduce a new version of our API. We'll set up a separate upstream and location block for /api/v2/, routing it to a different backend server.

This demonstrates how Nginx can direct traffic to completely separate application deployments based on the API version.

http {
  upstream api_v1_backend {
    server 192.168.1.10:8080;
  }

  upstream api_v2_backend {
    server 192.168.1.11:8081;
  }

  server {
    listen 80;
    server_name example.com;

    location /api/v1/ {
      proxy_pass http://api_v1_backend/;
      proxy_set_header Host $host;
    }

    location /api/v2/ {
      proxy_pass http://api_v2_backend/;
      proxy_set_header Host $host;
    }
  }
}

Handling Root/Default Version

What if a client doesn't specify a version? You can configure Nginx to redirect to the latest version or serve a default.

Using a rewrite rule, you can internally change the URI to point to /api/v2/ if the client requests /api/ without a version.

http {
  # ... upstream blocks ...

  server {
    listen 80;
    server_name example.com;

    # Redirect /api/ to /api/v2/ internally
    location = /api/ {
      rewrite ^ /api/v2/ permanent;
    }

    location /api/v1/ {
      proxy_pass http://api_v1_backend/;
      proxy_set_header Host $host;
    }

    location /api/v2/ {
      proxy_pass http://api_v2_backend/;
      proxy_set_header Host $host;
    }
  }
}

Prefix Matching & Trailing Slashes

Be careful with how location blocks match. A location /api/v1 will match /api/v1, /api/v1/, and /api/v1something.

Using location /api/v1/ (with a trailing slash) is generally safer as it matches /api/v1/ and its subpaths (e.g., /api/v1/users) but not /api/v10.

The proxy_pass directive also handles trailing slashes. If proxy_pass http://backend/; has a trailing slash, Nginx removes the matched part of the URI before passing it.

Best Practices for Versioning

To make your API versioning smooth and effective:

  • Document clearly: Inform clients about available versions and deprecation schedules.
  • Be consistent: Use the same versioning strategy across all your APIs.
  • Plan deprecation: Give ample notice before removing old versions.
  • Monitor usage: Track which versions are still in use to inform deprecation decisions.

Nginx Versioning Quiz

Consider the following Nginx configuration. Which proxy_pass destination would a request to http://example.com/api/v1/products be routed to?

server {
  listen 80;
  server_name example.com;

  location /api/v1/ {
    proxy_pass http://backend_old_api/;
  }

  location /api/v2/ {
    proxy_pass http://backend_new_api/;
  }

  location / {
    proxy_pass http://default_backend/;
  }
}

Recap: API Versioning with Nginx

You've learned how to implement API versioning using Nginx!

  • Versioning helps manage API changes and client compatibility.
  • Nginx's location blocks are ideal for URL-based versioning.
  • You can route different API versions to distinct backend services.
  • Using rewrite rules, you can handle default or unversioned requests.

This allows you to evolve your APIs smoothly while maintaining service for all your users.

Preguntas frecuentes

¿La lección «Versionado de API con Nginx» es gratis?

Sí — el texto completo de «Versionado de API con Nginx» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway), actualiza a CoddyKit PRO. El curso de API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) incluye 4 lecciones en total.

¿Qué aprenderé en «Versionado de API con Nginx»?

Configure Nginx para admitir distintas versiones de una API y permitir actualizaciones fluidas con compatibilidad con versiones anteriores. Practicas API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)?

No se requiere experiencia previa. API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Versionado de API con Nginx»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)?

Sí. Cada lección de API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Versionado de API con Nginx
  2. Intercambio de recursos de origen cruzado (CORS)
  3. Limitación de velocidad y control de tráfico con Nginx
  4. Enrutamiento basado en rutas hacia microservicios
← Volver a API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)