Lección 243: Funciones principales de API Gateway: enrutamiento, autenticación, autorización

API Gateway — es como el conserje de un hotel: recibe todas las peticiones de usuarios externos, verifica quiénes son, decide a dónde enviarlas y se encarga de la gestión general. Esto convierte a API Gateway en el punto central de control entre los clientes y los microservicios. En esta lección vamos a ver las funciones principales de API Gateway.

Capacidades avanzadas de enrutamiento

El enrutamiento en API Gateway es el corazón de su trabajo. Se encarga de que las peticiones lleguen a los microservicios que pueden procesarlas.

Ejemplo:

Imagínate que tienes dos microservicios:

1. Servicio de gestión de usuarios (UserService) en http://localhost:8081.
2. Servicio de pedidos (OrderService) en http://localhost:8082.

Queremos que:

• Las peticiones a /users/** se enruten a UserService.
• Las peticiones a /orders/** — a OrderService.

Lo configuramos en Spring Cloud Gateway:

@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user_service_route", r -> r.path("/users/**")
                .uri("http://localhost:8081")) // Enrutamiento a UserService
            .route("order_service_route", r -> r.path("/orders/**")
                .uri("http://localhost:8082")) // Enrutamiento a OrderService
            .build();
    }
}

Ahora el API Gateway reenvía las peticiones según la ruta. Eso ya está guay, pero podemos hacer más.

Gestión de autenticación y autorización

Autenticación — es verificar quién eres (por ejemplo, login con usuario y contraseña). Autorización — es comprobar qué te está permitido hacer (por ejemplo, acceso solo a ciertos datos).

API Gateway puede realizar autenticación y autorización de varias formas:

1. Verificación de tokens (por ejemplo, JWT).
2. Integración con sistemas OAuth2/SSO.
3. Ahorrar trabajo a tu backend rechazando peticiones no autorizadas ya en el nivel del API Gateway.

Funciones avanzadas de enrutamiento

Para escenarios complejos de enrutamiento, API Gateway soporta predicates y filtros.

Los predicados (Predicates) se usan para definir las reglas de enrutamiento. Por ejemplo:

• Por ruta (Path): enrutar peticiones si su ruta coincide con /users/**.
• Por método HTTP (Method): solo peticiones GET.
• Por host (Host): por ejemplo, peticiones dirigidas a api.example.com.

Ejemplo de uso de predicados:

@Bean
public RouteLocator advancedRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("user_service", r -> r
            .path("/users/**")
            .and()
            .method("GET") // Solo peticiones GET
            .uri("http://localhost:8081"))
        .build();
}

Los filtros (Filters) permiten procesar peticiones y respuestas: modificarlas, añadir headers, validar parámetros, etc.

Ejemplo: añadimos un header a todas las peticiones:

@Bean
public RouteLocator routeWithFilters(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("order_service", r -> r
            .path("/orders/**")
            .filters(f -> f.addRequestHeader("X-Request-ID", "12345")) // Añadimos header
            .uri("http://localhost:8082"))
        .build();
}

Autenticación en API Gateway

Trabajar con la autenticación es una función clave del API Gateway para construir aplicaciones seguras.

JWT (JSON Web Token) — es un token que el cliente envía con las peticiones y que el servidor (o el API Gateway) verifica usando una clave secreta. Es cómodo porque no hace falta consultar la base de datos cada vez: el token ya contiene la información.

Ejemplo de configuración para validar JWT: Añadimos la dependencia en pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>

Configuramos la seguridad:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.oauth2ResourceServer()
            .jwt(); // Activamos soporte para JWT
    }
}

Ahora todas las peticiones con tokens serán validadas.

Autorización en API Gateway

Autorización — es nuestro "¿y a ti te dejan pasar ahí?". Se encarga de que los usuarios solo puedan hacer lo que les esté permitido.

Roles y permisos

En un entorno de microservicios, los roles (por ejemplo, ADMIN, USER) se usan para limitar funcionalidades.

Configuramos autorización por roles:

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
        .antMatchers("/admin/**").hasRole("ADMIN") // Solo para admins
        .antMatchers("/user/**").hasRole("USER")   // Solo para usuarios
        .anyRequest().authenticated();            // Resto de peticiones: solo autenticados
}

Gestión de seguridad

Además de autenticación y autorización, el API Gateway debe proteger contra ataques como SQL-injection, XSS y CSRF.

Protección contra CSRF

CSRF (Cross-Site Request Forgery) — es un ataque en el que un atacante hace que un usuario realice una petición en su nombre. Spring Security incluye por defecto protección contra CSRF para formularios.

Para APIs REST se puede desactivar (¡con cuidado!):

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable(); // Desactivamos si usamos tokens
}

El API Gateway puede limitar el número de peticiones para prevenir ataques DoS. Por ejemplo, se puede configurar un límite usando filtros.

Ejercicio práctico

1. Configura el enrutamiento para dos microservicios: /users/** y /orders/**.
2. Implementa autenticación JWT, de modo que los usuarios con token puedan enviar peticiones.
3. Añade autorización para limitar el acceso:
   • Los admins pueden hacer POST en /orders.
   • Los usuarios solo pueden hacer GET en /users.

Hemos dado un gran paso — desde el enrutamiento básico hasta escenarios avanzados con autenticación y autorización. API Gateway ahora no solo distribuye peticiones, sino que también protege tus datos y microservicios. ¡Vamos adelante!