Lección 174: Configurar microservicios Spring Boot con configuraciones mediante application.yml

Es hora de profundizar en la configuración de aplicaciones Spring Boot. Hoy aprenderemos a organizar configuraciones a través de application.yml, veremos las ventajas de YAML frente a .properties, dominaremos las configuraciones multi-perfil y entenderemos cómo aplicar distintos ajustes para diferentes entornos (por ejemplo, dev, test, prod).

¿Qué es application.yml?

Cuando estudiamos Docker Compose ya nos encontramos con YAML (YAML Ain't Markup Language). Recordemos, es un formato cómodo para escribir archivos de configuración. Sus principales ventajas:

• Legibilidad: menos "ruido" que en .properties (no hay claves repetidas para grupos de ajustes).
• Estructura jerárquica: la configuración se agrupa fácilmente en forma de árbol.
• Soporte para objetos complejos: listas y estructuras de datos anidadas.

Para comparar, configuración en .properties:

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret

Y la misma configuración en application.yml:

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret

Coincidirás en que application.yml se ve menos desordenado. Spring Boot soporta ambos formatos, pero YAML se usa más en proyectos modernos.

Cómo trabaja Spring Boot con las configuraciones

Spring Boot carga automáticamente los archivos de configuración desde el directorio src/main/resources. El archivo más común para configuración es application.yml. Permite definir ajustes de la aplicación, como:

• Puerto del servidor
• Ajustes de conexión a la base de datos
• Ajustes de caché y seguridad

Spring Boot detecta los parámetros del archivo y los aplica automáticamente a los componentes correspondientes.

Ventajas de usar application.yml

Usar application.yml ofrece varias ventajas clave:

1. Estructura jerárquica
   • Los parámetros relacionados se agrupan fácilmente en una sección única (por ejemplo, ajustes de la base de datos).
   • Formato fácil de leer para configuraciones complejas.
2. Soporte de perfiles
   • Gestión cómoda de ajustes para diferentes entornos — dev, test, prod.
3. Soporte de listas
   • Por ejemplo, puedes indicar una lista de URLs en la configuración.

Ejemplo de lista:

my-service:
  servers:
    - http://localhost:8081
    - http://localhost:8082
    - http://localhost:8083

Estructuración y agrupación de ajustes

La jerarquía en YAML permite ordenar lógicamente los parámetros de configuración.

Ajustes del servidor

Configuramos el puerto para nuestro microservicio:

server:
port: 8080

También se pueden establecer propiedades relacionadas con la codificación:

server:
  port: 8080
  spring:
    messages:
      encoding: UTF-8

Ajustes de la base de datos

Conectar con la base de datos es una de las tareas más habituales en Spring Boot. Veamos la configuración:

  spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

• url — la dirección de la base de datos.
• ddl-auto — estrategia para gestionar el esquema de la base de datos (por ejemplo, update, create-drop).
• show-sql — permite volcar las consultas SQL en los logs.

Perfiles de configuración

En proyectos reales normalmente tenemos distintas configuraciones para desarrollo (dev), testing (test) y producción (prod). Por ejemplo:

• En el entorno dev se usa la base de datos H2 (in-memory).
• En prod se usa MySQL.

Spring Boot permite definir esos ajustes mediante perfiles.

El perfil activo se indica en application.yml:

spring:
  profiles:
    active: dev

O puedes pasar el perfil en los argumentos de la línea de comandos:

java -Dspring.profiles.active=prod -jar myapp.jar

Separación de la configuración por perfiles

Cada perfil puede tener su propio archivo de configuración, por ejemplo:

• application-dev.yml
• application-prod.yml

Ejemplo de application-dev.yml:

  spring:
  datasource:
    url: jdbc:h2:mem:devdb
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: create

Ejemplo de application-prod.yml:

spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/mydb
    username: admin
    password: securepassword
  jpa:
    hibernate:
      ddl-auto: validate

Configuración por defecto

El archivo principal application.yml puede contener ajustes comunes:

  server:
  port: 8080
spring:
  jpa:
    show-sql: true

Spring Boot primero carga application.yml, y después las configuraciones específicas del perfil (application-dev.yml o application-prod.yml), sobrescribiendo propiedades según corresponda.

Práctica: Configurar un microservicio con application.yml

Paso 1: Creamos un nuevo proyecto

Usa Spring Initializr para generar el proyecto:
Dependencies: Spring Web, Spring Data JPA, MySQL Driver.

Recuerda el chiste: "Si no usas Spring Initializr, te gusta demasiado el dolor. Existe para que pulses el botón 'Generate'".

Paso 2: Configuramos application.yml

Añade el archivo application.yml en el directorio src/main/resources:

server:
  port: 8081

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Paso 3: Añadimos perfiles

Crea los archivos application-dev.yml y application-prod.yml.

Ejemplo: application-dev.yml:

spring:
  datasource:
    url: jdbc:h2:mem:devdb
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: create

Ejemplo: application-prod.yml:

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/mydb
    username: admin
    password: securepassword

Establece el perfil activo:

  spring:
  profiles:
    active: dev

Paso 4: Implementamos un REST API simple

Crea un controlador:

@RestController
@RequestMapping("/api/customers")
public class CustomerController {

    @GetMapping
    public String getAllCustomers() {
        return "List of all customers!";
    }
}

Paso 5: Ejecutamos la aplicación

Arranca la aplicación y ve a la dirección:
http://localhost:8081/api/customers.

Errores típicos

Algunos puntos que suelen causar problemas:

1. Configuraciones contradictorias: si application.yml y el archivo específico de perfil contienen ajustes contradictorios, el perfil activo sobrescribe la configuración principal.
2. Falta de perfil activo: no olvides indicar el perfil activo vía spring.profiles.active.
3. Errores de formato YAML: el más mínimo error de indentación puede romper la aplicación.

Para desplegar en servidores reales normalmente se pasa el perfil mediante argumentos JVM (-Dspring.profiles.active=prod).

Ahora sabes cómo configurar application.yml, dividir eficazmente la configuración por perfiles y aplicarlos en microservicios. ¡YAML se ha convertido en tu amigo en este viaje!