Lección 224: Actualización dinámica de configuraciones en microservicios

Hoy responderemos a esa pregunta y aprenderemos a aplicar la actualización dinámica de configuraciones en tiempo real. ¡Preparad los teclados!

El problema de las configuraciones estáticas en microservicios

Imagina que eres el administrador de un gran zoo de microservicios (sí-sí, nuestra metáfora favorita). Por ejemplo, decenas de microservicios dependen del mismo parámetro, digamos, un límite máximo para la ejecución de operaciones. Ese límite se guarda en una configuración centralizada, ¿pero qué pasa si hay que actualizarlo?

1. Cambias el valor en el repositorio (por ejemplo, en Git).
2. Luego reinicias cada microservicio para que recoja el nuevo valor.

Suena a una molestia. Especialmente si hay decenas o cientos de microservicios. Reiniciar no solo es incómodo, sino que puede provocar downtime del sistema. ¿Y si el parámetro cambia con frecuencia? Entonces deja de ser una molestia y se convierte en una catástrofe.

Para evitar estas situaciones necesitamos la actualización dinámica de configuraciones. Esto permite aplicar cambios "sobre la marcha", sin reiniciar los microservicios. Y aquí entra la magia de Spring Cloud Bus.

Spring Cloud Bus: fundamentos

Spring Cloud Bus es una herramienta para el envío de mensajes entre microservicios usando un broker de mensajería como RabbitMQ o Apache Kafka. Permite:

• Propagar cambios de configuración entre microservicios.
• Notificar a los componentes del sistema sobre cambios.
• Implementar enfoques orientados a eventos para gestionar settings.

Ejemplo de escenario de trabajo

1. El administrador cambia la configuración en Git (u otro repositorio).
2. Spring Cloud Config Server detecta el cambio y publica un evento en el broker de mensajes.
3. Todos los microservicios suscritos reciben el evento y actualizan automáticamente sus configuraciones.

Enfoques para la actualización dinámica de configuraciones

La actualización dinámica de configuraciones en Spring se logra con varios elementos clave:

1. Spring Cloud Bus para entregar eventos de cambio de configuración.
2. La anotación @RefreshScope para refrescar beans que dependen de la configuración.
3. Llamada a un método REST para actualizar beans — si quieres hacerlo manualmente.

Hablemos de cada uno.

Spring Cloud Bus en acción

Spring Cloud Bus usa brokers de mensajes (RabbitMQ, Kafka) para propagar eventos. En nuestro ejemplo usaremos RabbitMQ (porque se integra fácil y es muy usado).

En pasos sería así:

1. Spring Cloud Config Server publica el evento de cambio de configuración.
2. Spring Cloud Bus reenvía ese evento a los suscriptores (tus microservicios).
3. Los suscriptores reciben el evento y actualizan sus settings en tiempo real.

Instalar RabbitMQ es otra tarea, pero si aún no lo tienes puedes desplegarlo rápido con Docker:

docker run -d --hostname rabbitmq --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:management

Uso de la anotación @RefreshScope

La anotación @RefreshScope es tu herramienta principal para actualizar dependencias. Si tienes un bean que toma valores de la configuración, añadir @RefreshScope a ese bean garantizará que se refresque cuando cambien esos valores.

Aquí va un ejemplo:

@RestController
@RefreshScope
public class ConfigController {

    @Value("${example.config.value}")
    private String exampleConfig;

    @GetMapping("/config")
    public String getConfigValue() {
        return this.exampleConfig;
    }
}

Si el parámetro example.config.value cambia, el bean recogerá automáticamente el valor actualizado tras el evento de refresh de configuración.

Ten en cuenta que @RefreshScope funciona solo con beans gestionados por Spring. Si creas el bean manualmente (por ejemplo, con new), no pasará nada mágico.

Llamada a un método REST para actualizar configuraciones

Para que un microservicio se entere de que la configuración cambió, puedes esperar al evento de Spring Cloud Bus o invocar manualmente el endpoint /actuator/refresh. Hay que habilitar ese endpoint en la configuración:

management.endpoints.web.exposure.include=refresh

Para probar puedes usar curl:

curl -X POST http://localhost:8080/actuator/refresh

Después de llamar a /refresh todos los beans con la anotación @RefreshScope se actualizarán y, con ellos, los parámetros revisados.

Práctica: configuración de Spring Cloud Bus

Vamos a montar esto en condiciones. Crearemos dos microservicios (Config Server y Service) que se integrarán con Spring Cloud Bus mediante RabbitMQ.

Paso 1: Configuración de Spring Cloud Config Server

Crea un nuevo proyecto Spring Boot (por ejemplo, vía Spring Initializr) y añade las dependencias:

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-bus-amqp</artifactId>
    </dependency>
</dependencies>

Habilita el Config Server en el código:

@EnableConfigServer
@SpringBootApplication
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

Configura application.yml:

spring:
  cloud:
    config:
      server:
        git:
          uri: https://your-repo-url
  rabbitmq:
    host: localhost
    port: 5672

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

Arranca el servidor y comprueba que funciona.

Paso 2: Configuración del microservicio (cliente)

Crea un segundo proyecto y añade las dependencias:

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-bus-amqp</artifactId>
    </dependency>
</dependencies>

Configura bootstrap.yml para conectarte al servidor:

spring:
  application:
    name: client-service
  cloud:
    config:
      uri: http://localhost:8888
  rabbitmq:
    host: localhost
    port: 5672

Añade un controlador con configuración dinámica:

@RestController
@RefreshScope
public class TestController {

    @Value("${example.config.value:default}")
    private String configValue;

    @GetMapping("/current-config")
    public String getConfigValue() {
        return configValue;
    }
}

Paso 3: Verificación de actualizaciones dinámicas

1. Cambia la configuración en Git.
2. Ejecuta el comando en el Config Server:

curl -X POST http://localhost:8888/actuator/bus-refresh

Gracias a Spring Cloud Bus, los valores actualizados llegarán automáticamente a los microservicios.

Ahora tienes un sistema operativo que actualiza configuraciones en tiempo real. Usar Spring Cloud Bus simplifica mucho la gestión de settings en sistemas distribuidos, y además te permite dormir tranquilo sabiendo que reiniciar microservicios es cosa del pasado.