Lección 249: Balanceo de carga en microservicios a través de API Gateway

Imagínate que tu microservicio procesa peticiones a la velocidad de una máquina de vapor del siglo XIX. Mientras tanto, la carga de tu aplicación crece y la cantidad de usuarios se dispara — ese es el camino directo al desastre. El balanceo de carga ayuda a repartir las peticiones entrantes entre varias instancias del microservicio para que ninguna se quede sobrecargada. Eso significa:

• Aumento de la tolerancia a fallos. Si una de las instancias del servicio falla, las demás siguen funcionando.
• Escalabilidad. Puedes añadir nuevas instancias del servicio fácilmente para manejar la carga creciente.
• Mejora del rendimiento. Las peticiones se procesan más rápido porque la carga está distribuida de forma equilibrada.

El balanceo de carga es un salvavidas que evita que tus microservicios se ahoguen en un mar de peticiones.

¿Cómo hace API Gateway el balanceo de carga?

API Gateway, como Spring Cloud Gateway, puede hacer el balanceo de carga de varias maneras, incluyendo mecanismos:

1. Round Robin (algoritmo circular): las peticiones se envían por turno a cada endpoint disponible (instancia del servicio). Por ejemplo, la primera petición va a Instance A, la segunda a Instance B, y así sucesivamente, volviendo al principio de la lista.
2. Random (selección aleatoria): la petición se dirige a una instancia del servicio elegida aleatoriamente.
3. Weighted (con ponderación): reparte las peticiones proporcionalmente al peso asignado a cada instancia.

Además, API Gateway puede tener en cuenta parámetros como la latencia de red o el estado de la instancia del servicio.

Implementación práctica del balanceo de carga

Vamos a la práctica. Vamos a implementar un ejemplo de configuración de balanceo de carga con Spring Cloud Gateway.

Preparar el proyecto

1. Asegúrate de que tienes instalado Spring Boot y añadidas las dependencias necesarias para Spring Cloud Gateway. En pom.xml añade las siguientes dependencias:

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

2. Supongamos que ya tienes configurado el Eureka Server y tus microservicios están registrados en él.

Configurar el Gateway para el balanceo

Ahora vamos a configurar Spring Cloud Gateway para el balanceo de peticiones. Imagina que tenemos dos instancias del microservicio payment-service, registradas en Eureka en puertos diferentes: 8081 y 8082.

Paso 1: Configurar las rutas en application.yml

Añadimos reglas de enrutamiento al archivo de configuración application.yml para el Gateway:

spring:
  cloud:
    gateway:
      routes:
        - id: payment-service-route
          uri: lb://payment-service # lb:// indica que se usa balanceo de carga
          predicates:
            - Path=/payments/** # Todas las peticiones que empiecen por /payments se envían a payment-service

Fíjate en el uso de lb:// en uri, que indica a Spring Cloud Gateway que use el sistema de balanceo de carga.

Paso 2: Registro de los microservicios

Asegúrate de que ambas instancias de tu servicio payment-service estén registradas en Eureka. Por ejemplo:

• Primera instancia: http://localhost:8081
• Segunda instancia: http://localhost:8082

Comprobación

Arranca el Gateway y ambas instancias del servicio payment-service. Luego prueba a enviar varias peticiones:

curl http://localhost:8080/payments

API Gateway distribuirá automáticamente las peticiones entre las instancias usando el algoritmo Round Robin (por defecto).

Configurar una estrategia de balanceo personalizada

Si necesitas usar otra estrategia, también es posible. Spring Cloud Gateway usa la librería Spring Cloud LoadBalancer, que soporta varios algoritmos. Vamos a cambiar la estrategia a Random Load Balancing.

Paso 1: Añadir un Bean LoadBalancer personalizado

En la clase de configuración CustomLoadBalancerConfiguration creamos un bean personalizado que define la estrategia de balanceo:

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
import org.springframework.cloud.loadbalancer.config.LoadBalancerConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

@Configuration
@LoadBalancerClient(value = "payment-service", configuration = CustomLoadBalancerConfiguration.class)
public class CustomLoadBalancerConfiguration {

    @Bean
    public ReactorServiceInstanceLoadBalancer loadBalancer(Environment environment,
                                                           LoadBalancerClient loadBalancerClient) {
        String serviceId = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(loadBalancerClient, serviceId);
    }
}

Aquí cambiamos el algoritmo a Random, usando RandomLoadBalancer. Ahora las peticiones irán a una instancia aleatoria del servicio.

Monitorización y análisis de la carga

Tras configurar el balanceo es importante vigilar cómo se distribuye la carga. Para eso puedes usar:

1. Spring Boot Actuator: métricas como gateway.requests muestran estadísticas de las peticiones que pasan por el Gateway.
2. Consola de Eureka: el Dashboard de Eureka permite ver el estado de las instancias.
3. Herramientas externas de monitorización: por ejemplo, Prometheus y Grafana para analizar métricas y crear gráficos de carga.

Errores y particularidades

Al usar balanceo de carga pueden surgir los siguientes problemas:

• Si una de las instancias falla pero sigue apareciendo en Eureka, las peticiones a esa instancia darán error. Esto se soluciona configurando un Health Check en Eureka y excluyendo las instancias no disponibles.
• Una mala configuración de filtros o predicados en el Gateway puede provocar un enrutado incorrecto.
• Servidores no preparados pueden sufrir una carga desigual, especialmente si usas la política Random.

Mira la documentación de Spring Cloud Gateway para configuración detallada: Spring Cloud Gateway Documentation.

Conclusión

El balanceo de carga es una herramienta clave para asegurar la tolerancia a fallos y mejorar el rendimiento de un sistema basado en microservicios. Con Spring Cloud Gateway puedes implementar fácilmente la distribución de peticiones entre las instancias de tus servicios, usando mecanismos integrados como Round Robin o Random Load Balancing. No olvides mirar las métricas y tener en cuenta el estado de los servicios para evitar errores y sobrecargas.