Uno de los problemas más comunes cuando se desarrollan aplicaciones en cualquier lenguaje es utilizar un solo código que este se ejecute en múltiples entornos (dev, qa y prod). En todos los entornos se utilizarán las mismas configuraciones, lo que cambiará de uno a otro serán los valores asignados a las mismas.

Para soportar esto Spring boot provee perfiles que son diferentes a los perfiles normales de Maven, para saber más sobre ellos re recomendamos el post Perfiles Maven en Español !.

Primeros pasos

Antes de adentrarnos a cómo configurar los perfiles primero existen algunos conceptos que debemos entender:

  • Un perfil se asignará a un entorno de tal modo que si tenemos los entornos, Desarrollo, QA y Producción se deberán crear 3 perfiles.
  • A diferencia de los perfiles normales de Maven, en Spring boot los perfiles se utilizarán en tiempo de ejecución, de este modo no es necesario compilar los proyectos con la bandera -P.
  • Existen diferentes formas de definir un perfil en Maven, en este post se explicarán las 2 principales utilizando archivos properties y utilizando archivos yaml.
  • Para estos ejemplos se tomará como base el proyecto creado en el post Spring Boot + REST Jersey Parte 1.

Definiendo perfiles utilizando archivos properties

Para configurar los perfiles maven utilizando archivos properties es necesario hacer lo siguiente.

1. Agregar un archivo properties por cada perfil que se desea soportar

El primer paso será crear un archivo properties en el folder src/main/resources por cada uno de los entornos a soportar siguiendo la siguiente estructura:

application-${profile}.properties

${profile} Será el nombre de nuestro entorno. Para este ejemplo se crearán los siguientes 3 archivos:

  • application-dev.properties
 com.raidentrance.app.name=Spring boot dev
  • application-qa.properties
 com.raidentrance.app.name=Spring boot qa
  • application-prod.properties
 com.raidentrance.app.name=Spring boot prod

2. Crear un nuevo servicio para mostrar el valor de la propiedad

Una vez definida la nueva propiedad llamada com.raidentrance.app.name el siguiente paso será exponerla en un servicio. Para esto se creará el siguiente servicio:

/**
*
*/
package com.raidentrance.resource;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
* @author maagapi
*
*/
@Component
@Path("/configs")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class ProjectConfigurationResource {

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

private static final Logger log = LoggerFactory.getLogger(UserResource.class);

@GET
@Path("/appName")
public Response getAppName() {
log.info("Getting project configuration");
return Response.ok(appName).build();
}
}

El servicio anterior mostrará en la respuesta del endpoint GET /configs/appName el nombre definido en nuestro archivo de configuración.

3. Registrar el servicio en Jersey

Recordemos que siempre que se crea un servicio nuevo en Jersey lo debemos agregar en nuestra clase JerseyConfig como se muestra a continuación:

/**
*
*/
package com.raidentrance.config;

import org.glassfish.jersey.server.ResourceConfig;
import org.springframework.stereotype.Component;

import com.raidentrance.resource.ProjectConfigurationResource;
import com.raidentrance.resource.UserResource;

/**
* @author raidentrance
*
*/
@Component
public class JerseyConfig extends ResourceConfig {
public JerseyConfig() {
register(UserResource.class);
register(ProjectConfigurationResource.class);
}
}

Recordemos que el servicio UserResource fue el que ya existía en el ejemplo y no es necesario para la explicación de perfiles.

4. Probado todo junto

Una vez que ya se configuró todo lo anterior lo único que resta es probarlo, para esto solo es necesario compilar nuestra aplicación como siempre con un simple mvn clean install, lo único que será diferente será al momento de ejecutarlo, para esto se utilizará el siguiente comando:

mvn -Dspring.profiles.active=qa spring-boot:run

Como se puede ver en el comando se ejecutará la aplicación utilizando las configuraciones definidas en el perfil de qa.

Si ejecutamos el endpoint GET /configs/appName la salida será la siguiente:

Spring boot qa

Definiendo perfiles utilizando archivos yaml

Una vez que ya sabemos como definir los perfiles utilizando multiples archivos .properties, el siguiente paso será entender como hacerlo utilizando archivos yaml.

Paso 1 Definir las configuraciones

A diferencia de la configuración utilizando archivos properties, para definir multiples perfiles utilizando archivos yaml solo es necesario crear un solo archivo para todos los perfiles de la aplicación veamos el ejemplo mencionado anteriormente pero utilizando archivos yaml.

spring:
    profiles:
        active: dev
---
spring:
    profiles: dev
com:
    raidentrance:
      app:
        name: Spring boot dev
---
spring:
    profiles: qa
com:
    raidentrance:
      app:
        name: Spring boot qa
---
spring:
    profiles: prod
com:
    raidentrance:
      app:
        name: Spring boot prod

Como se puede observar a diferencia de la definición con archivos properties es posible definir en un solo archivo yaml el perfil por defecto a utilizar y las propiedades para los diferentes entornos.

Los demás componentes del código serán iguales para ambas formas.

Puedes encontrar el código completo en el siguiente enlace https://github.com/raidentrance/spring-boot-example/tree/part7-profiles .

Si te gusta el contenido o tienes preguntas síguenos en nuestras redes sociales: https://twitter.com/geeks_mx y https://www.facebook.com/geeksJavaMexico/.

 

Autor: Alejandro Agapito Bautista

Twitter: @raidentrance

Contacto:raidentrance@gmail.com