Cómo parametrizar rutas en Spring Cloud Gateway correctamente

Spring Cloud Gateway es el enrutador API oficial del ecosistema Spring. Su función es actuar como punto de entrada unificado para todas las peticiones hacia nuestros microservicios. Nos permite aplicar filtros, modificar rutas, validar tokens o incluso enrutar dinámicamente a través de balanceadores de carga. Y lo mejor: todo esto puede configurarse fácilmente mediante ficheros "application.yml" o "application.properties".

En este post vamos a centrarnos en la parametrización de rutas: cómo definirlas, qué atributos tienen y cómo aprovechar filtros personalizados para enriquecer las peticiones entrantes.

¿Qué es la parametrización de rutas?

Cuando hablamos de parametrizar rutas en Spring Cloud Gateway, nos referimos a configurar de forma declarativa las reglas que definen cómo enrutar cada petición entrante. Esta parametrización puede hacerse en el fichero "application.yml" (con estructura más legible) o en el fichero "application.properties" (con estructura más granular). Dicha configuración se apoya en los atributos siguientes:

Atributo id : identificador único de la ruta.
Atributo uri : destino de la ruta (puede ser un microservicio).
Atributo predicate : condiciones que deben cumplirse para activar la ruta.
Atributo filter : lógica adicional a aplicar antes o después del reenvío.

Atributos clave en la configuración de rutas

A continuación, vamos a explicar un poco más en detalle en qué consisten cada uno de los atributos que podemos utilizar para configurar la parametrización de las rutas en nuestro Spring Gateway.

Atributo id

Este atributo sirve para identificar la ruta, tanto para fines de trazabilidad como para debug o auditoría. Dicho parámetro se establece así:

spring.cloud.gateway.routes[0].id=users-ws-get-update-delete

Atributo uri

Define el destino al que se debe redirigir la petición si se cumplen los predicados definidos. Este valor destino puede ser una URL completa o un identificador de servicio registrado en Eureka (cuando se usa con el tag de balanceador lb://). Se establece del siguiente modo:

spring.cloud.gateway.routes[0].uri=lb://users-ws

Atributo predicate

Los predicados actúan como condiciones de activación. De esa manera, la ruta será procesada únicamente si se cumplen todas las condiciones.

🔎 Algunos ejemplos comunes:

Path: define el patrón de la URL.
spring.cloud.gateway.routes[0].predicates[0]=Path=/users-ws/users/**

Method: valida por tipo de método HTTP.
spring.cloud.gateway.routes[0].predicates[1]=Method=GET,PUT,DELETE

Header: activa la ruta solo si existe una cabecera específica.
spring.cloud.gateway.routes[0].predicates[2]=Header=Authorization, Bearer (.*)

Atributo filter

Los filtros permiten realizar acciones antes o después de reenviar la petición al microservicio de destino, añdiendo una gran flexibilidad al tratamiento de rutas dentro del Gateway.

🔎 Ejemplos útiles:

RemoveRequestHeader: elimina cabeceras antes de reenviar.
spring.cloud.gateway.routes[0].filters[0]=RemoveRequestHeader=Cookie

RewritePath: reescribe dinámicamente la URL.
gateway.routes[0].filters[1]=RewritePath=/users-ws/(?<segment>.*), /$\{segment}

AddRequestHeader y AddRequestParameter: añaden cabeceras o parámetros al request.
spring.cloud.gateway.routes[0].filters[2]=AddRequestHeader=MyHeader,MyURI
spring.cloud.gateway.routes[0].filters[3]=AddRequestParameter=Param,MyValue

Predicates más utilizados en Spring Cloud Gateway

A continuación te voy a dejar una lista de los predicados especialmente útiles, aquellos que suelen ser más relevantes y utilizados en los proyectos de microservicios:

Path: filtra según el patrón de la URL.
Method: filtra según el método HTTP (GET, POST, etc.).
Header: permite actuar según la existencia o valor de una cabecera.
Query: activa rutas si hay un parámetro específico en la URL.
Host: permite enrutar por dominio (útil en multi-tenant).
RemoteAddr: restringe según la IP de origen.

Filtros útiles en rutas de Spring Gateway

Además de los filtros estándar de Spring Cloud, también puedes combinar múltiples filtros para enriquecer el request. Te dejo aquí los filtros más relevantes:

RemoveRequestHeader
AddRequestHeader
AddRequestParameter
RewritePath
SetPath
PrefixPath
StripPrefix

Cada uno de ellos puede ayudarte a modificar el comportamiento de la petición del Spring Gateway sin tocar código del microservicio final.

Filtros personalizados

Spring Cloud Gateway permite extender su comportamiento mediante la utilización de los denominados Filtros Personalizados (Filter Custom Authorization). Básicamente, estos filtros habilitan la ejecución de funcionalidad adicional mediante clases Java que implementan interfaces como "GatewayFilter" o "GlobalFilter". A este respecto, uno de los casos más comunes de empleo de este tipo de filtros personalizados es la validación de tokens JWT.

🔎 Te dejo aquí, en relación con la validación de tokens, un ejemplo típico con la utilización de un clase "AuthorizationHeaderFilter.java", que intercepta la petición antes de redirigirla. El proceso de ejecución sería el siguiente.

Flujo de ejecución:

Spring ejecuta automáticamente el método apply() de la clase Java.
Este método recibe los objetos ServerWebExchange y GatewayFilterChain.
Se aplica la lógica de validación.
Se continúa con la cadena de filtros chain.filter().

👉 Código simplificado:


 
@Component
public class AuthorizationHeaderFilter implements GatewayFilter {
     /**
     * Este metodo se ejecuta automaticamente al procesar los filtros
     */
    @Override
    public GatewayFilter apply(Config config) {
        // TODO Auto-generated method stub
        
        // Definimos funcion Lambda para procesar las validaciones
        // exchange --> contenedor del HTTP request
        // chain --> contenedor de los filtros de la cadena GatewayFilterChain
        GatewayFilter pLambda = (ServerWebExchange exchange, GatewayFilterChain chain) -> {
            
            // Recuperamos la peticion HTTP
            ServerHttpRequest request = exchange.getRequest();
            
            // Devolvemos error si la peticion no contiene un Header "Authorization"
            if (!request.getHeaders().containsKey(HttpHeaders.AUTHORIZATION)) {
                return onError(exchange, "No Authorization header", HttpStatus.UNAUTHORIZED);
            }
            
            // Extraemos el JWT Token almacenado en el header Authorization
            String authHeader = request.getHeaders().get(HttpHeaders.AUTHORIZATION).get(0);
            String jwtToken = authHeader.replace("Bearer ", "").trim();
            
            // Se valida el token JWT
            if (!isJwtValid(jwtToken)) {
                return onError(exchange, "JWT token is not valid", HttpStatus.UNAUTHORIZED);
            }
            
            // Si todo es correcto, se continua y se invoca al siguiente filtro de la cadena
            return chain.filter(exchange);
        };
        
        return pLambda;
        
    }
 
}

Luego, únicamente tendrías que incluir este filtro en tu configuración de rutas dentro del fichero de parametrización application.properties:

# Ejecutar filtro de validacion de token antes de reenrutar peticion al microservicio 
spring.cloud.gateway.routes[0].filters[2]=AuthorizationHeaderFilter

🔎 Ejemplo completo en "application.yml"

Para que veas cómo funciona en conjunción todo lo anteriormente comentado, ahora te voy a dejar aquí un ejemplo realista de una ruta configurada con predicados y filtros, incluyendo un filtro de autorización personalizado:

 
spring:
  cloud:
    gateway:
      routes:
        - id: users-ws-get-update-delete
          uri: lb://users-ws
          predicates:
            - Path=/users-ws/users/**
            - Method=GET,PUT,DELETE
            - Header=Authorization, Bearer (.*)
          filters:
            - RemoveRequestHeader=Cookie
            - RewritePath=/users-ws/(?<segment>.*), /${segment}
            - AuthorizationHeaderFilter

Este bloque define lo siguiente:

✅ Enruta todas las peticiones que vayan a "/users-ws/users/**"
✅ Acepta solo los métodos GET, PUT y DELETE
✅ Requiere un header Authorization válido
✅ Elimina la cabecera "Cookie"
✅ Reescribe el path antes de reenviar
✅ Ejecuta un filtro de autorización propio, llamando a la clase "AuthorizationHeaderFilter"

Conclusión

Spring Cloud Gateway ofrece una forma robusta, elegante y altamente parametrizable de gestionar el enrutamiento en aplicaciones basadas en microservicios. Gracias a su capacidad de configurar rutas con predicados y filtros, tanto estándar como personalizados, es una herramienta imprescindible para construir gateways seguros, flexibles y escalables.

Dominar estas configuraciones te permitirá tener control absoluto sobre cómo se enrutan, filtran y transforman las peticiones dentro de tu arquitectura de microservicios en Spring.

¡Nos vemos en el siguiente post!

Saludos.

Buscar este blog

Universo Java