Lección 229: Uso de diferentes perfiles de configuración en Spring Boot

Imagina que tienes que gestionar distintos parámetros de tu sistema para diferentes entornos —por ejemplo, desarrollo (development), test (test) y producción (production). En el mundo de Spring esto se consigue fácilmente con los perfiles de configuración.

¿Para qué sirve esto?

• Ajustes distintos por entorno. Por ejemplo, en desarrollo se usa una base de datos local, y en producción una en la nube.
• Cambiar configuraciones al vuelo. Modificas ajustes sin tocar el código.
• Mejorar la seguridad. Los parámetros sensibles de producción se pueden guardar por separado.

Si no existieran los perfiles, probablemente tendrías varios archivos de configuración y copiarías manualmente el que toca antes de arrancar. Suena poco divertido, pero Spring nos libra de esa rutina.

¿Cómo funcionan los perfiles en Spring Boot?

En Spring Boot cada perfil es un conjunto de configuraciones que se aplican solo cuando ese perfil está activo. La idea clave es que puedes definir ajustes distintos para cada perfil, y Spring seleccionará automáticamente las configuraciones según el perfil activo.

Por ejemplo, si tienes los perfiles dev y prod, Spring puede usar las configuraciones de uno u otro según cuál esté activo.

¿Cómo se definen los perfiles?

En Spring Boot los perfiles se pueden definir:

1. En archivos de configuración.
2. Mediante parámetros en la línea de comandos.
3. A través de variables de entorno.

Configuración de perfiles en Spring Boot

1. Uso de application.properties y application.yml

Spring Boot utiliza archivos de configuración para gestionar los ajustes de la aplicación. Por defecto son:

• application.properties
• application.yml

Además puedes crear archivos específicos por perfil. Por ejemplo:

• application-dev.properties (o .yml) — configuraciones para el perfil dev.
• application-prod.properties (o .yml) — configuraciones para el perfil prod.

Al arrancar la aplicación Spring elegirá automáticamente el archivo de configuración correspondiente al perfil activo.

Ejemplo: application.yml

spring:
  profiles:
    active: dev

application-dev.yml

app:
  name: "MyApp (Development)"
datasource:
  url: "jdbc:h2:mem:devdb"
  username: "dev_user"
  password: "dev_password"

application-prod.yml

app:
  name: "MyApp (Production)"
datasource:
  url: "jdbc:mysql://prod.server:3306/proddb"
  username: "prod_user"
  password: "prod_password"

Cuando el perfil dev está activo, Spring cargará las configuraciones de application-dev.yml. Si está activo prod, usará application-prod.yml.

2. Cambio de perfiles

Mediante application.properties

Si quieres establecer un perfil por defecto, añade en application.properties:

spring.profiles.active=dev

Mediante la línea de comandos

Puedes activar un perfil al arrancar la app:

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

Mediante variables de entorno

Puedes fijar el perfil con una variable de entorno:

export SPRING_PROFILES_ACTIVE=prod

3. Uso de la anotación @Profile

Spring también permite controlar perfiles a nivel de componentes. Con la anotación @Profile puedes indicar en qué perfil debe crearse un bean concreto.

Ejemplo:

Código de configuración:

@Configuration
public class DataSourceConfig {

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        // Configuración para el perfil dev
        return new HikariDataSource();
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        // Configuración para el perfil prod
        return new HikariDataSource();
    }
}

Ahora Spring creará el bean DataSource según el perfil activo.

Práctica: implementación de perfiles en una aplicación Spring Boot

1. Configurar el proyecto

Crea un proyecto nuevo en Spring Initializr. Añade las dependencias necesarias, como:

• Spring Boot Starter Web
• Spring Boot Starter Data JPA
• H2 Database

2. Añadir archivos de configuración

Crea tres archivos:

1. application.yml — archivo principal de configuración.
2. application-dev.yml — configuraciones para desarrollo.
3. application-prod.yml — configuraciones para producción.

application.yml

spring:
  profiles:
    active: dev

application-dev.yml

app:
  name: MyApp (Dev)
server:
  port: 8080
datasource:
  url: jdbc:h2:mem:devdb
  username: dev_user
  password: password

application-prod.yml

app:
  name: MyApp (Prod)
server:
  port: 8081
datasource:
  url: jdbc:mysql://prod.server:3306/proddb
  username: prod_user
  password: prod_password

3. Uso de perfiles en el código

Vamos a crear un controlador que devuelva el nombre actual de la aplicación.

AppController.java

@RestController
@RequestMapping("/api")
public class AppController {

    @Value("${app.name}")
    private String appName;

    @GetMapping("/name")
    public String getAppName() {
        return appName; // Devolvemos el nombre de la aplicación indicado en la configuración
    }
}

4. Ejecutar la aplicación

5. Arranca la aplicación con el perfil dev:

java -jar myapp.jar --spring.profiles.active=dev

Ve a http://localhost:8080/api/name. Verás:

MyApp (Dev)

6. Arranca la aplicación con el perfil prod:

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

Ve a http://localhost:8081/api/name. Resultado:

MyApp (Prod)

Mejores prácticas: trabajar con perfiles en un proyecto grande

1. Define ajustes por defecto mínimos. Por ejemplo, guarda parámetros comunes en application.yml y los específicos en archivos por perfil.
2. No pongas contraseñas de producción en el código. Para eso existen secretos (por ejemplo HashiCorp Vault).
3. Añade un perfil de test. Facilitará las pruebas de tu aplicación.

Ejemplo: application.yml

logging:
level: INFO

application-test.yml

logging:
  level: DEBUG
datasource:
  url: jdbc:h2:mem:testdb

¿Qué hacer si algo sale mal?

A menudo la gente que empieza olvida activar el perfil. Eso provoca que Spring use la configuración por defecto (application.yml). Para evitarlo:

• Siempre establece el perfil explícitamente, usando el parámetro spring.profiles.active.
• Revisa los logs en la consola — Spring siempre indica qué perfil está activo.

Otro problema común es la superposición de ajustes. Si pones los mismos parámetros en varios archivos, Spring dará prioridad al perfil activo. Es fácil olvidarlo, pero como sabes, el logging es tu mejor amigo.

La documentación oficial de Spring sobre perfiles te ayudará a profundizar en el tema.