Lección 244: Práctica: enrutamiento de solicitudes a través de API Gateway

Hemos visto Spring Cloud Gateway como una herramienta potente para implementar un API Gateway. Luego lo instalamos, añadimos las dependencias básicas y configuramos la primera ruta sencilla.

En esta lección crearemos la configuración de rutas en Spring Cloud Gateway para redirigir solicitudes a distintos microservicios. Añadiremos filtros para procesar peticiones y respuestas, implementaremos limitación de peticiones y configuraremos el soporte de CORS (solitudes cross-origin). También probaremos la configuración para asegurarnos de que todo funciona correctamente.

1. Configuración de rutas complejas

Las rutas (routes) son la base del Gateway. Cada ruta define:

• Predicados (predicates), que determinan qué solicitudes enrutar (por ejemplo, filtrado por path o método HTTP).
• Filtros (filters), que modifican o complementan las solicitudes y respuestas.
• URI, hacia donde redirigir las solicitudes.

Vamos a añadir varias rutas para nuestro sistema de microservicios.

Paso 1: Preparar el proyecto

Asegúrate de que tu proyecto ya tenga las dependencias de Spring Cloud Gateway. Si no, añádelas en el archivo pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

Y no olvides actualizar las dependencias (por ejemplo, con mvn clean install).

Paso 2: Configurar las rutas en application.yml

Ejemplo de application.yml con varias rutas:

spring:
  cloud:
    gateway:
      routes:
        - id: user-service-route
          uri: http://localhost:8081
          predicates:
            - Path=/users/**
          filters:
            - StripPrefix=1
        - id: order-service-route
          uri: http://localhost:8082
          predicates:
            - Path=/orders/**
          filters:
            - AddResponseHeader=X-Custom-Header, OrderService
        - id: product-service-route
          uri: lb://product-service
          predicates:
            - Path=/products/**

Aquí:

1. id: Identificador único de la ruta.
2. uri: Dirección del servicio a la que se enrutarán las solicitudes.
   • Por ejemplo, http://localhost:8081 significa que las solicitudes a /users/** se redirigirán al servicio User Service, que escucha en el puerto 8081.
   • lb://product-service significa el uso del balanceador de carga (funcionalidad de Eureka, si está integrada).
3. predicates: Condición de enrutamiento.
   • Por ejemplo, Path=/users/** significa que las solicitudes con esa ruta irán al servicio de usuarios.
4. filters: Transformaciones adicionales de solicitudes y respuestas.
   • StripPrefix=1 elimina el primer segmento de la ruta (/users) antes de enviar la petición al backend.
   • AddResponseHeader añade un header HTTP personalizado a la respuesta.

Paso 3: Ejecutar y probar

Después de configurar las rutas, inicia la aplicación y prueba cómo funciona:

• Para User Service: Envía una petición a http://localhost:8080/users/1 y comprueba que se redirige a http://localhost:8081/1.
• Para Order Service: Comprueba que la respuesta contiene el header X-Custom-Header: OrderService.

Usa Postman o el comando curl para probar:

curl -v http://localhost:8080/users/1
curl -v http://localhost:8080/orders/123

2. Añadir filtros

Los filtros permiten modificar peticiones y respuestas. Puedes añadir headers, cambiar el contenido de las peticiones, y también hacer autenticación.

Ejemplo: registro de peticiones

Añade un filtro para registrar las peticiones:

spring:
  cloud:
    gateway:
      routes:
        - id: logging-route
          uri: http://localhost:8081
          predicates:
            - Path=/logging/**
          filters:
            - name: RequestLoggingFilter

Crea el filtro:

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component
public class RequestLoggingFilter extends AbstractGatewayFilterFactory<RequestLoggingFilter.Config> {

    private static final Logger logger = LoggerFactory.getLogger(RequestLoggingFilter.class);

    public RequestLoggingFilter() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            logger.info("Request Path: " + exchange.getRequest().getPath());
            return chain.filter(exchange);
        };
    }

    public static class Config {
        // Configuración del filtro (si se requiere)
    }
}

3. Limitación de peticiones (Rate Limiting)

La limitación de tasa ayuda a evitar la sobrecarga de los servicios. Para esto se usa el filtro RedisRateLimiter.

Paso 1: Añadir la dependencia de Redis

Añade la dependencia:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

Paso 2: Configurar el filtro Rate Limiter

Modifica application.yml:

spring:
  cloud:
    gateway:
      routes:
        - id: rate-limited-route
          uri: http://localhost:8081
          predicates:
            - Path=/rate-limited/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20

Aquí:

• replenishRate: Número de peticiones que se pueden procesar por segundo.
• burstCapacity: Número máximo de peticiones en ráfaga.

4. Soporte de CORS (Cross-Origin Resource Sharing)

Si tu frontend y backend están en dominios diferentes, activa el soporte de CORS.

Paso 1: Configurar CORS en la configuración

Añade en application.yml:

spring:
  cloud:
    gateway:
      globalcors:
        corsConfigurations:
          '[/**]':
            allowedOrigins: "http://localhost:3000"
            allowedMethods:
              - GET
              - POST
              - PUT
              - DELETE

Ahora las solicitudes desde http://localhost:3000 hacia tu Gateway estarán permitidas.

5. Pruebas y validación

• Comprueba el funcionamiento de cada ruta con Postman.
• Asegúrate de que los headers se añaden correctamente.
• Prueba la limitación de peticiones enviando muchas solicitudes seguidas y verifica que las excedentes se bloquean.

6. Errores típicos y cómo evitarlos

1. Error 404: la ruta no está configurada correctamente. Revisa las condiciones de los predicates.
2. Falta de filtros: asegura que los filtros se aplican a la ruta.
3. Problemas con CORS: revisa que allowedOrigins y allowedMethods estén correctos en la configuración.

Consejo: primero revisa los logs para ver cómo el API Gateway maneja las peticiones.

Ahora sabes cómo configurar rutas complejas con Spring Cloud Gateway, añadir filtros y controlar las peticiones. Con estos conocimientos podrás enrutar solicitudes en una aplicación de microservicios teniendo en cuenta los requisitos de seguridad y rendimiento.