Lección 248: Integración de Eureka con API Gateway

Cuando trabajamos en una arquitectura de microservicios, podemos tener decenas o cientos de servicios, cada uno encargado de su parte de la lógica. La configuración estática de esos servicios en el API Gateway es como intentar organizar manualmente una fila de gatos: nadie garantiza que mañana un servicio no cambie de dirección o que aparezca uno nuevo.

La integración de API Gateway con Eureka permite:

1. Descubrir microservicios automáticamente: Eureka se encarga de registrar los servicios y monitorizarlos. El API Gateway pedirá esa información en tiempo real.
2. Enrutar las solicitudes de forma dinámica: los servicios nuevos o los cambios en los existentes se tienen en cuenta automáticamente en las rutas.
3. Simplificar la gestión de microservicios: menos trabajo rutinario manual — más automatización.

Preparación para la integración

Antes de empezar la integración, asegúrate de que tienes:

• Desplegado un Eureka Server (se configuró en la lección anterior "Práctica: configuración de Eureka para el descubrimiento de microservicios").
• Uno o varios microservicios cliente registrados en Eureka (por ejemplo, los servicios user-service y order-service).

Ahora vamos a crear un proyecto para el API Gateway y enlazarlo con el Eureka Server.

1. Creación del proyecto para API Gateway

1. Inicialización del proyecto Usamos Spring Initializr para crear una nueva aplicación Spring Boot:

• Dependencies:
  • Spring Cloud Gateway
  • Eureka Discovery Client
  • Spring Boot Actuator (para monitorización, es opcional pero útil)

Descargamos el proyecto y lo abrimos en nuestro entorno de desarrollo favorito (por ejemplo, IntelliJ IDEA).

2. Configuración de application.yml

Agregaremos la configuración básica en nuestro application.yml para conectar con el Eureka Server:

server:
  port: 8080 # Puerto del API Gateway

spring:
  application:
    name: api-gateway # Nombre del servicio en Eureka
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # Activamos la integración con Eureka
      routes:
        - id: default_route
          uri: lb://placeholder # Esto es un placeholder temporal hasta el enrutamiento automático.

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/ # Enlace a tu Eureka Server
    fetch-registry: true
    register-with-eureka: true

Fíjate en la parte clave de esta configuración:

• spring.cloud.gateway.discovery.locator.enabled: true — activa la integración del Gateway con Eureka.
• lb:// — indica a Spring usar Ribbon (Load Balancer) para enrutar las solicitudes.

3. Implementación del enrutamiento automático

Ahora, gracias a tener discovery.locator.enabled activado, el API Gateway leerá automáticamente la información de los servicios registrados en Eureka. Cada servicio en Eureka queda disponible "por nombre". Por ejemplo:

• lb://user-service enruta solicitudes al servicio user-service.
• lb://order-service — al order-service.

Pero para comprobar esto en la práctica, añadamos una ruta manualmente para pruebas:

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/orders/**

Estas rutas indican al Gateway dirigir:

• Todas las solicitudes que empiecen con /users/ al servicio user-service.
• Todas las solicitudes que empiecen con /orders/ al servicio order-service.

4. Arranque del API Gateway y pruebas

Arrancamos nuestro API Gateway y probamos las rutas. Asegúrate de que tus servicios user-service y order-service se han registrado en el Eureka Server y están funcionando.

Pruebas con *Postman o curl*

• Solicitud:

  curl -X GET http://localhost:8080/users/all
  

  Resultado esperado: la solicitud será redirigida al user-service y obtendrás la lista de todos los usuarios (o un error si el servicio no está configurado correctamente).
• Solicitud:

  curl -X GET http://localhost:8080/orders
  

  Resultado esperado: la solicitud será redirigida al order-service.

Si todo funciona, ¡la integración fue exitosa!

5. Depuración y monitorización

Para depurar la integración puedes usar Spring Boot Actuator. Añade en application.yml la siguiente configuración:

management:
  endpoints:
    web:
      exposure:
        include: "*"

Ahora puedes comprobar /actuator/gateway/routes para listar todas las rutas del API Gateway que se detectan a través de Eureka.

Ejemplo de comando para comprobarlo:

curl http://localhost:8080/actuator/gateway/routes

6. Configuración avanzada

También puedes configurar filtros para procesar las solicitudes. Por ejemplo, si quieres añadir un header a todas las solicitudes:

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**
          filters:
            - AddRequestHeader=X-Service, UserService

Ahora cualquier solicitud al user-service contendrá automáticamente el header X-Service: UserService.

Para proteger los servicios contra sobrecarga, puedes configurar limitación de tasa (rate-limiting):

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10 # Solicitudes por segundo
                redis-rate-limiter.burstCapacity: 20

Problemas comunes y sus soluciones

1. Eureka Server no disponible: si el API Gateway no puede conectarse a Eureka, asegúrate de que el Eureka Server esté en marcha y que su dirección esté correcta en application.yml.
2. El microservicio no se registra: asegúrate de que en el application.yml de tus microservicios la configuración para registrarse en Eureka sea correcta.
3. Errores de enrutamiento: revisa la configuración de rutas en /actuator/gateway/routes y asegúrate de que el uri indicado sea correcto.

¡Enhorabuena! Ahora tu API Gateway es más inteligente gracias a la integración con Eureka. No solo simplificaste el enrutamiento de solicitudes, sino que también hiciste el sistema más flexible frente a cambios en los microservicios. Seguiremos desarrollando tus habilidades en las siguientes lecciones, ¡hasta la próxima!