Capítulo 3: Configuración Centralizada con Spring Cloud Config

🎯 Objetivos del Capítulo

Comprender la necesidad de configuración centralizada
Configurar un Spring Cloud Config Server
Conectar los servicios como Config Clients
Utilizar Git como backend de configuración
Implementar el refresh de configuración en caliente
Gestionar la encryption de secretos

1. ¿Por qué la Configuración Centralizada?

1.1 El Problema Sin Config Server

microservices/
├── user-service/
│   └── application.yml          # Configuración específica
├── product-service/
│   └── application.yml          # Configuración específica
├── order-service/
│   └── application.yml          # Configuración específica
├── payment-service/
│   └── application.yml          # Configuración específica
└── inventory-service/
    └── application.yml          # Configuración específica

Problemas:

Cambiar la contraseña de la BD = modificar 5 archivos
Redplegar 5 servicios
Sin versionado centralizado
Secretos en texto plano en cada servicio
Sin refresh sin reinicio

1.2 La Solución: Config Server

Ventajas:

Una sola fuente de verdad
Versionado con Git (histórico, ramas)
Refresh sin redeploy
Encriptación de secretos
Configuración por entorno (dev, prod)

2. Arquitectura Spring Cloud Config

2.1 Componentes

2.2 Flujo de Configuración

3. Configuración del Config Server

3.1 Estructura del Proyecto

config-server/
├── pom.xml
└── src/main/
    ├── java/com/example/configserver/
    │   └── ConfigServerApplication.java
    └── resources/
        └── application.yml

3.2 Dependencias Maven

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>config-server</artifactId>
    <version>1.0.0</version>
    
    <properties>
        <java.version>17</java.version>
        <spring-cloud.version>2023.0.0</spring-cloud.version>
    </properties>
    
    <dependencies>
        <!-- Config Server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
        
        <!-- Eureka Client (para registrarse) -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        
        <!-- Security -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        
        <!-- Actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3.3 Aplicación Principal

package com.example.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer  // Activa el Config Server
public class ConfigServerApplication {

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

3.4 Configuración con Git

# application.yml
server:
  port: 8888

spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          # Repositorio Git (GitHub, GitLab, Bitbucket, local)
          uri: https://github.com/votre-org/config-repo
          # Rama por defecto
          default-label: main
          # Carpeta en el repo (opcional)
          search-paths: config
          # Clonar al inicio
          clone-on-start: true
          # Credenciales si el repo es privado
          username: ${GIT_USERNAME:}
          password: ${GIT_PASSWORD:}
          # Timeout
          timeout: 10

# Eureka Client
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

# Security
spring:
  security:
    user:
      name: config
      password: config123

3.5 Configuración Local (para dev)

spring:
  cloud:
    config:
      server:
        native:
          search-locations: 
            - file:///C:/config-repo
            - classpath:/config
  profiles:
    active: native  # Usar el filesystem en lugar de Git

4. Estructura del Repositorio de Configuración

4.1 Convención de Nombres

config-repo/
├── application.yml              # Config común a TODOS los servicios
├── application-dev.yml          # Config dev para TODOS los servicios
├── application-prod.yml         # Config prod para TODOS los servicios
├── user-service.yml             # Config específica user-service
├── user-service-dev.yml         # user-service en dev
├── user-service-prod.yml        # user-service en prod
├── product-service.yml
├── product-service-dev.yml
├── product-service-prod.yml
├── order-service.yml
├── order-service-dev.yml
└── order-service-prod.yml

4.2 Prioridad de Configuración

La configuración se fusiona en este orden (de menor a mayor prioridad):

application.yml (base común)
application-\{profile\}.yml (perfil común)
{service-name}.yml (servicio específico)
{service-name}-\{profile\}.yml (servicio + perfil)

4.3 Ejemplo: application.yml (común)

# config-repo/application.yml
# Configuración compartida por TODOS los servicios

# Eureka común
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

# Actuator común
management:
  endpoints:
    web:
      exposure:
        include: health,info,refresh
  endpoint:
    health:
      show-details: always

# Logging común
logging:
  level:
    root: INFO
    com.example: DEBUG

4.4 Ejemplo: user-service.yml

# config-repo/user-service.yml
# Configuración específica para User Service

server:
  port: 8081

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/users_db
    username: ${DB_USERNAME:postgres}
    password: ${DB_PASSWORD:postgres}
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

# Configuración de negocio
user:
  default-role: USER
  password-min-length: 8
  token-expiration-hours: 24

4.5 Ejemplo: user-service-dev.yml

# config-repo/user-service-dev.yml
# Sobrescritura para el entorno de desarrollo

spring:
  datasource:
    url: jdbc:h2:mem:users_dev
    driver-class-name: org.h2.Driver
  h2:
    console:
      enabled: true
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true

logging:
  level:
    com.example.userservice: TRACE
    org.hibernate.SQL: DEBUG

4.6 Ejemplo: user-service-prod.yml

# config-repo/user-service-prod.yml
# Configuración producción

spring:
  datasource:
    url: jdbc:postgresql://prod-db.example.com:5432/users_db
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
  jpa:
    hibernate:
      ddl-auto: none
    show-sql: false

logging:
  level:
    root: WARN
    com.example: INFO

# Desactivar los endpoints sensibles
management:
  endpoints:
    web:
      exposure:
        include: health,info

5. Configuración del Config Client

5.1 Dependencias Maven (Servicio)

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Config Client -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    
    <!-- Bootstrap (para cargar config antes de la app) -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-bootstrap</artifactId>
    </dependency>
    
    <!-- Eureka Client -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    
    <!-- Actuator (para /refresh) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

5.2 Configuración Cliente (Método 1: bootstrap.yml)

# src/main/resources/bootstrap.yml
# Cargado ANTES de application.yml

spring:
  application:
    name: user-service  # Debe coincidir con el nombre de los archivos de config
  profiles:
    active: dev
  cloud:
    config:
      # URL directa del Config Server
      uri: http://localhost:8888
      # Credenciales si el Config Server está protegido
      username: config
      password: config123
      # Retry si el Config Server no está disponible
      fail-fast: true
      retry:
        initial-interval: 1000
        max-attempts: 6
        max-interval: 2000
        multiplier: 1.1

5.3 Configuración Cliente (Método 2: application.yml con import)

# src/main/resources/application.yml
# Spring Boot 2.4+ - no necesita bootstrap.yml

spring:
  application:
    name: user-service
  profiles:
    active: dev
  config:
    import: "optional:configserver:http://localhost:8888"
  cloud:
    config:
      username: config
      password: config123

5.4 Descubrimiento vía Eureka

# En lugar de una URL fija, descubrir vía Eureka
spring:
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config-server  # Nombre en Eureka
      fail-fast: true

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

6. Acceso a las Propiedades en el Código

6.1 Inyección con @Value

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Value("${user.default-role}")
    private String defaultRole;
    
    @Value("${user.password-min-length}")
    private int passwordMinLength;
    
    @Value("${user.token-expiration-hours}")
    private int tokenExpirationHours;
    
    @GetMapping("/config")
    public Map<String, Object> getConfig() {
        return Map.of(
            "defaultRole", defaultRole,
            "passwordMinLength", passwordMinLength,
            "tokenExpirationHours", tokenExpirationHours
        );
    }
}

6.2 Inyección con @ConfigurationProperties

package com.example.userservice.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "user")
public class UserProperties {
    
    private String defaultRole;
    private int passwordMinLength;
    private int tokenExpirationHours;
    
    // Getters y Setters
    public String getDefaultRole() { return defaultRole; }
    public void setDefaultRole(String defaultRole) { 
        this.defaultRole = defaultRole; 
    }
    
    public int getPasswordMinLength() { return passwordMinLength; }
    public void setPasswordMinLength(int passwordMinLength) { 
        this.passwordMinLength = passwordMinLength; 
    }
    
    public int getTokenExpirationHours() { return tokenExpirationHours; }
    public void setTokenExpirationHours(int tokenExpirationHours) { 
        this.tokenExpirationHours = tokenExpirationHours; 
    }
}

@Service
public class UserService {
    
    private final UserProperties userProperties;
    
    public UserService(UserProperties userProperties) {
        this.userProperties = userProperties;
    }
    
    public User createUser(UserRequest request) {
        User user = new User();
        user.setRole(userProperties.getDefaultRole());
        // ...
        return user;
    }
}

7. Refresh de Configuración en Caliente

7.1 El Problema

Modificar user-service-dev.yml en Git
Commit & Push
Config Server detecta el cambio
PERO: user-service sigue con la configuración antigua!
   (La cargó al iniciar)

7.2 Solución 1: Endpoint /actuator/refresh

# Exponer el endpoint refresh
management:
  endpoints:
    web:
      exposure:
        include: health,info,refresh

# Disparar el refresh manualmente
curl -X POST http://localhost:8081/actuator/refresh

7.3 Beans @RefreshScope

@RestController
@RequestMapping("/api/config")
@RefreshScope  // Este bean será recreado al hacer refresh
public class ConfigController {
    
    @Value("${user.token-expiration-hours}")
    private int tokenExpirationHours;
    
    @GetMapping("/token-expiration")
    public int getTokenExpiration() {
        return tokenExpirationHours;
    }
}

7.4 Solución 2: Spring Cloud Bus (Propagación automática)

Dependencia:

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

Disparar refresh global:

curl -X POST http://config-server:8888/actuator/busrefresh

8. Encriptación de Secretos

8.1 ¿Por qué Encriptar?

# ❌ PELIGRO: Contraseña en texto plano en Git!
spring:
  datasource:
    password: SuperSecret123!

8.2 Configuración de Encriptación

# Config Server - application.yml
encrypt:
  key: ${ENCRYPT_KEY:my-secret-encryption-key-32chars!}

O con un keystore:

encrypt:
  key-store:
    location: classpath:/server.jks
    password: keystorepassword
    alias: configserver
    secret: keypassword

8.3 Encriptar un Valor

# Encriptar
curl -X POST http://localhost:8888/encrypt -d "SuperSecret123!"
# Resultado: AQB...encodedValue...

# Desencriptar (para verificar)
curl -X POST http://localhost:8888/decrypt -d "AQB...encodedValue..."
# Resultado: SuperSecret123!

8.4 Usar el Valor Encriptado

# config-repo/user-service-prod.yml
spring:
  datasource:
    password: '{cipher}AQB...encodedValue...'

El Config Server desencripta automáticamente antes de enviar al cliente.

8.5 Encriptación Asimétrica (RSA)

# Generar un keystore
keytool -genkeypair -alias configserver -keyalg RSA \
  -dname "CN=Config Server,OU=Unit,O=Organization,L=City,S=State,C=US" \
  -keypass changeme -keystore server.jks -storepass changeme

encrypt:
  key-store:
    location: file:/etc/config-server/server.jks
    password: ${KEYSTORE_PASSWORD}
    alias: configserver
    secret: ${KEY_PASSWORD}

9. Endpoints del Config Server

9.1 Patrones de URL

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

9.2 Ejemplos

# Configuración user-service con perfil dev
curl http://localhost:8888/user-service/dev
curl http://localhost:8888/user-service-dev.yml

# Configuración con rama específica
curl http://localhost:8888/user-service/dev/feature-branch

# Configuración en formato properties
curl http://localhost:8888/user-service-dev.properties

9.3 Respuesta JSON

curl http://localhost:8888/user-service/dev

{
  "name": "user-service",
  "profiles": ["dev"],
  "label": "main",
  "version": "abc123def456",
  "propertySources": [
    {
      "name": "https://github.com/org/config-repo/user-service-dev.yml",
      "source": {
        "spring.datasource.url": "jdbc:h2:mem:users_dev",
        "user.default-role": "USER"
      }
    },
    {
      "name": "https://github.com/org/config-repo/user-service.yml",
      "source": {
        "server.port": 8081
      }
    },
    {
      "name": "https://github.com/org/config-repo/application.yml",
      "source": {
        "eureka.client.service-url.defaultZone": "http://localhost:8761/eureka/"
      }
    }
  ]
}

10. Buenas Prácticas

10.1 Separación de Entornos

config-repo/
├── application.yml           # NUNCA secretos aquí
├── application-dev.yml       # Config dev (puede tener valores por defecto)
├── application-staging.yml   # Config staging
├── application-prod.yml      # SOLO referencias a variables de entorno

10.2 Secretos en Producción

# ❌ Malo
spring:
  datasource:
    password: '{cipher}AQB...'  # Aunque esté encriptado, está en Git

# ✅ Bueno
spring:
  datasource:
    password: ${DB_PASSWORD}  # Variable de entorno

10.3 Fail-Fast

spring:
  cloud:
    config:
      fail-fast: true  # El servicio no inicia si el Config Server no está disponible
      retry:
        max-attempts: 6
        initial-interval: 1000

10.4 Timeouts Apropiados

spring:
  cloud:
    config:
      request-connect-timeout: 5000
      request-read-timeout: 10000

10.5 Health Check

// El health check incluye automáticamente el Config Server
// GET /actuator/health
{
  "status": "UP",
  "components": {
    "configServer": {
      "status": "UP",
      "details": {
        "propertySources": [...]
      }
    }
  }
}

11. Resumen

Puntos Clave

✅ Config Server = Fuente única de configuración
✅ Git Backend = Versionado, histórico, ramas
✅ Convención de nombres = {service}-\{profile\}.yml
✅ @RefreshScope = Beans que se recargan
✅ Encryption = Secretos seguros
✅ Spring Cloud Bus = Refresh automático distribuido

Orden de Arranque

Eureka Server (8761) - Descubrimiento de servicios
Config Server (8888) - Configuración
Otros servicios - Recuperan su configuración y luego se registran

Checklist

Config Server configurado con Git
Repositorio de configuración estructurado
Clientes configurados con bootstrap.yml o spring.config.import
Endpoint /refresh expuesto
Secretos encriptados o vía variables de entorno
fail-fast activado

Capítulo Siguiente: API Gateway →

Volver al Módulo 13

🎯 Objetivos del Capítulo​

1. ¿Por qué la Configuración Centralizada?​

1.1 El Problema Sin Config Server​

1.2 La Solución: Config Server​

2. Arquitectura Spring Cloud Config​

2.1 Componentes​

2.2 Flujo de Configuración​

3. Configuración del Config Server​

3.1 Estructura del Proyecto​

3.2 Dependencias Maven​

3.3 Aplicación Principal​

3.4 Configuración con Git​

3.5 Configuración Local (para dev)​

4. Estructura del Repositorio de Configuración​

4.1 Convención de Nombres​

4.2 Prioridad de Configuración​

4.3 Ejemplo: application.yml (común)​

4.4 Ejemplo: user-service.yml​

4.5 Ejemplo: user-service-dev.yml​

4.6 Ejemplo: user-service-prod.yml​

5. Configuración del Config Client​

5.1 Dependencias Maven (Servicio)​

5.2 Configuración Cliente (Método 1: bootstrap.yml)​

5.3 Configuración Cliente (Método 2: application.yml con import)​

5.4 Descubrimiento vía Eureka​

6. Acceso a las Propiedades en el Código​

6.1 Inyección con @Value​

6.2 Inyección con @ConfigurationProperties​

7. Refresh de Configuración en Caliente​

7.1 El Problema​

7.2 Solución 1: Endpoint /actuator/refresh​

7.3 Beans @RefreshScope​

7.4 Solución 2: Spring Cloud Bus (Propagación automática)​

8. Encriptación de Secretos​

8.1 ¿Por qué Encriptar?​

8.2 Configuración de Encriptación​

8.3 Encriptar un Valor​

8.4 Usar el Valor Encriptado​

8.5 Encriptación Asimétrica (RSA)​

9. Endpoints del Config Server​

9.1 Patrones de URL​

9.2 Ejemplos​

9.3 Respuesta JSON​

10. Buenas Prácticas​

10.1 Separación de Entornos​

10.2 Secretos en Producción​

10.3 Fail-Fast​

10.4 Timeouts Apropiados​

10.5 Health Check​

11. Resumen​

Puntos Clave​

Orden de Arranque​

Checklist​