Lección 221: Introducción a la gestión centralizada de configuraciones

En esta lección daremos un paso hacia sistemas mejor organizados, escalables y mantenibles: estudiaremos la gestión centralizada de configuraciones.

Imagina que tu aplicación basada en microservicios está formada por decenas o incluso cientos de servicios. Ahora imagina que cada uno de esos servicios depende de montones de parámetros de configuración. Esos parámetros pueden incluir:

• Ajustes de bases de datos (por ejemplo, URL, usuario/contraseña)
• Claves API para servicios externos
• Credenciales para brokers de mensajes
• Parámetros dependientes del entorno (desarrollo, testing, producción)

Si guardas todos esos parámetros localmente en cada microservicio (por ejemplo, en application.properties o application.yml), te enfrentas a varios problemas:

1. Duplicación de configuraciones. Cambiar un parámetro exige editarlo en muchos sitios.
2. Necesidad de actualizaciones manuales. Actualizar configuraciones "en caliente" se vuelve prácticamente imposible.
3. Vulnerabilidad de seguridad. Transportar secretos (contraseñas, tokens) en texto plano dentro de archivos de configuración puede causar filtraciones.

Ventajas del enfoque centralizado

La gestión centralizada de configuraciones soluciona estos problemas. Veamos por qué mola:

1. Un único almacén para todas las configuraciones. Ahora todos los parámetros se pueden guardar de forma centralizada y usar mecanismos concretos para distribuirlos a los microservicios.
2. Actualización "en caliente". Los cambios en las configuraciones se pueden aplicar sin reiniciar los servicios (sí, ¡eso es magia!).
3. Gestión simplificada. Los servicios cargan automáticamente los parámetros que les correspondan según su entorno (por ejemplo, dev, test, prod).
4. Seguridad. Posibilidad de proteger datos sensibles usando cifrado, políticas de acceso y herramientas como HashiCorp Vault.

Ejemplos de uso de la gestión centralizada de configuraciones

Empresas reales ya usan activamente la gestión centralizada de configuraciones. Algunos de los ejemplos más conocidos:

• Netflix. En su arquitectura de microservicios Netflix usa Spring Cloud Config para gestionar configuraciones. Guardan las configuraciones en repositorios Git y aplican cambios en tiempo real.
• Uber. Para manejar cientos de microservicios Uber implantó un sistema de gestión centralizada de parámetros que facilita cambiar ajustes al mover cargas entre regiones.

Resumen de herramientas populares para gestión de configuraciones

En el mercado hay varias herramientas para trabajar con configuraciones centralizadas. Aquí las más populares:

¿Por qué Spring Cloud Config?

Nos centramos en Spring Cloud Config, porque se integra perfectamente con aplicaciones desarrolladas en Spring. Esto es lo que más les gusta a los desarrolladores:

1. Permite guardar configuraciones en distintas fuentes, incluyendo:
   • Repositorios Git. Es una forma popular y fiable, ya que las configuraciones se pueden versionar.
   • Sistema de archivos. Una opción sencilla para fases iniciales.
2. Soporta la gestión centralizada de parámetros para todos los microservicios a la vez.
3. Permite la carga dinámica de cambios en las configuraciones usando Spring Cloud Bus.
4. Se configura fácilmente con anotaciones y properties conocidos.

Ejemplo: problemas sin gestión centralizada

Tomemos una aplicación de microservicios compuesta por tres servicios: A, B y C. Los tres servicios usan una base de datos con los mismos ajustes:

# application.properties para el servicio A
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=1234

# application.properties para el servicio B
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=1234

# application.properties para el servicio C
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=1234

Ahora imagina que decides cambiar la contraseña. Eso requiere editar application.properties en los tres servicios. ¿Y si no son tres, sino treinta? ¿O 100?

Además, esos archivos en cada servicio se convierten en una posible fuente de fuga de datos, ya que usuarios y contraseñas están almacenados en texto plano.

Gestión centralizada de configuraciones con Spring Cloud Config

Así se resuelve la misma tarea usando Spring Cloud Config. Todas las configuraciones (incluida la de la base de datos) se guardan ahora en un único lugar, por ejemplo, en un repositorio Git. Los servicios las reciben del Config Server automáticamente.

Ejemplo de archivo en un repositorio Git:

# myapp-dev.yml (archivo para el entorno dev)
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: 1234

Los servicios A, B y C ya no contienen ajustes locales de base de datos; simplemente los "piden" al Config Server. Si hace falta cambiar la contraseña, el desarrollador actualiza el archivo en Git y... ¡listo! Los cambios se aplican para todos los servicios.

¿Cómo se ve esto en la práctica?

Spring Cloud Config consta de dos componentes clave:

1. Config Server. Es el servidor central que guarda y provee las configuraciones.
2. Config Client. Es la aplicación microservicio que solicita las configuraciones al servidor.

Aquí tienes un esquema simplificado:

+--------------------+         +--------------------+
| Config Client A    |         | Config Client B    |
| (obtiene configuración)  |         | (obtiene configuración)  |
+--------------------+         +--------------------+
        |                           |
        +-----------+   +-----------+
                    |   |
          +-------------------------+
          |        Config Server    |
          +-------------------------+
                    |
                    v
          +-------------------------+
          |      Git Repository     |
          +-------------------------+

Principales pasos para implementar Spring Cloud Config

En las próximas lecciones te guiaremos por cada uno de estos pasos:

1. Crear Config Server y conectarlo al almacenamiento (por ejemplo, Git).
2. Configurar el Config Client para que los microservicios puedan solicitar sus configuraciones.
3. Implementar la carga dinámica de actualizaciones (para que los cambios se apliquen "en caliente").
4. Integrar con herramientas de seguridad (por ejemplo, HashiCorp Vault) para proteger datos confidenciales.

Es hora de pasar de la teoría a la práctica. Prepárate para crear tu primer Config Server usando Spring.