¿Cómo usar Configuración Centralizada de Plataforma en tu aplicación?

Onesait Platform posee una Configuración de Sistema Centralizada para diversos propósitos. Usuarios con rol Administrador pueden definir de manera visual configuraciones para sus necesidades, incluyendo Despliegues (configuraciones Rancher & OpenShift), redes sociales (Twitter), programación de procesos, registros Endpint, etc.

Mediante es módulo, los usuarios pueden definir de forma sencilla las distintas configuraciones; plataforma, usa YAML o JSON como base.

Panel de Control UI

Para crear y modificar las Configuraciones, el usuario puede dirigirse al menú DEV TOOLS > Gestión de Configuraciones.

Como se puede ver en la tabla la Configuración está relacionada con un entorno (típicamente default o docker), un Identificador y un tipo:

Al crear una nueva Configuración el usuario tiene que rellenar el siguiente formulario:

Hay que tener en cuenta que para usuarios no administradores (a partir de la versión 2.3.0 de Plataforma) sólo se podrán crear configuraciones del tipo EXTERNAL_CONFIG.

Por ejemplo, se puede modificar la Configuración para los servicios endpoints, los cuales se procesan cuando la plataforma se lanza:

API REST

Además, se pueden realizar operaciones a través de una API REST existente, cuyos endpoints comienzan con '/controlpanel/api/configurations'.

Nota: estas Configuraciones emplean Yaml, la respuesta de estos servicios REST es visualmente poco amigable.

Cómo configurar tu aplicación para utilizar la configuración centralizada

En primer lugar tendrás que añadir al pom.xml del proyecto que va a actuar como Config Server la siguiente dependencia.

<dependency>
	<groupId>com.minsait.onesait.platform</groupId>
	<artifactId>onesaitplatform-spring-config-client</artifactId>
	<version>5.0.0</version>
</dependency>

Y tendrás que añadir el repositorio de Plataforma al listado de repositorios dentro del pom:

<repositories>
	<repository>
		<id>onesait platform releases</id>
		<url>https://nexus.onesaitplatform.com/nexus/content/repositories/releases/</url>
	</repository>
</repositories>

Una vez añadida la dependencia tendrás que añadir las siguientes propiedades a tu application.yml

onesaitplatform:
  api.rest:
    token: <ONESAITPLATFORM_API_KEY> 
    endpoint: <ONESAITPLATFORM_BASE_URL>
  spring.cloud.config:
    enabled: false

Donde:

• ONESAITPLATFORM_API_KEY es el API Key de un usuario con rol administrador de la Plataforma. Esta key se utilizará para gestionar la seguridad a nivel de Pltaforma para poder obtener la configuración centralizada.

• ONESAITPLATFORM_BASE_URL es el endpoint del controlpanel de la Plataforma donde se encuentra la configuración centralizada que queremos utilizar.

Una vez configurado el proyecto, basta con inyectar el Bean ConfigurationManager y acceder a los métodos disponibles:

@Autowired
ConfigurationManager configManager;

Crear configuración

configManager.createConfiguration(configuration)

Dónde el objeto configuration está conpuesto por los siguientes campos:

private String id;
private String username;
@NonNull
private ConfigurationType type;
@NonNull
private String description;
@NonNull
private String identification;
@NonNull
private String environment;
private String yml;

Obtener configuración

Hay múltiples métodos para obtener una configuración dependiendo de los parámetros de los que se disponga:

# Obtener configuración a través del identificador, entorno y tipo
Configuration config = configManager.getConfiguration(identification, environament, type)
# Obtener configuración por ID
Configuration config = configManager.getConfigurationById(id)
# Obtener configuración por identificador
Configuration config = configManager.getConfigurationByIdentification(identification)
# Obtener todas las configuraciones del usuario
List<Configuration> configList = configManager.getConfigurations()

Actualizar configuración

configManager.updateConfiguration(configuration);

Borrar configuración

# Borrar configuración por identificador, entorno y tipo
configManager.deleteConfiguration(identification, environment, type);
# Borrar configuración por ID
configManager.deleteConfigurationById(id);

Uso del cliente Java para la gestión de configuración

Los clientes Java ofrecen una clase de Configuración Wrapper.

Configuración de la Dependencia

Para usar este API es necesario añadir el siguiente repositorio al proyecto pom.xml.

<repositories>
	<repository>
		<id>onesait platform releases</id>
		<url>https://nexus.onesaitplatform.com/nexus/content/repositories/releases/</url>
	</repository>
</repositories>

Después de esto hay que añadir la dependencia:

<dependency>
	  <groupId>com.minsait.onesait.platform</groupId>
	  <artifactId>onesaitplatform-java-client</artifactId>
	  <version>2.1.0-RELEASE</version>
</dependency>

Inicialización

El primer caso es crear un objeto ConfigurationManager, para poder utilizar el cliente debes introducir como argumentos el usuario, la contraseña y el servidor URL:

	private static ConfigurationManager manager;

	@PostConstruct
	public void init() throws ConfigurationManagerException, IOException {
		manager = new ConfigurationManager("developer", "changeIt2020!", "https://hyperblast.onesaitplatform.com");
	}

Una vez inicializado el objeto, ya se puede usar para operar con las Configuraciones de Plataforma.

Crear una Configuración

Para crear una configuración es necesario crear antes un Objeto de tipo Configuration:

Configuration configuration = Configuration.builder().description("Testing config sample")
				.environment("default").identification("testconfiguration").type(ConfigurationType.EXTERNAL_CONFIG).yml(YML_SAMPLE)
				.build();

Una vez que la configuración se haya creado hay que hacer una llamada al ClientManager, al método createConfiguration:

String id = manager.createConfiguration(configuration);

Este método, si tiene éxito, devolverá el id de la configuración que se acaba de crear. Con este identificador se puede recuperar la configuración en un futuro, eliminarla o actualizarla.

Obtener una configuración

Hay dos métodos para recuperar una configuración:

• getConfigurationById(id)

Este método permite recuperar una configuración a través de su id.

• getConfiguration(identification, type, environment)

En caso de no conocer la id se puede obtener la configuración mediante los parámetros en el argumento. En el caso de existir, estos métodos devuelven una instancia de la Configuración.

Obtener todas las Configuraciones

Es posible obtener una lista de Configuraciones según el usuario logado, llamando al método getConfigurations:

List<Configuration> configurations = manager.getConfigurations()

Editar una Configuración

Para editar una configuración es necesario conocer su id.

La mejor manera de editar dicha configuración es recuperándola, aplicar los cambios y finalmente llamar al método updateConfiguration:

Configuration retrievedConfig = manager.getConfiguration(IDENTIFICATION, ConfigurationType.EXTERNAL_CONFIG, ENVIRONMENT);
log.info("Retrieved config from the platform by parameters");
retrievedConfig.setDescription("This is a new description");
log.info("Updating configuration with new description and identification {}", IDENTIFICATION);
manager.updateConfiguration(configuration, retrievedConfig.getId());

Borrar una Configuración

Para eliminar una configuración hay que llamar al método deleteConfiguration pasando el id de la configuración.

log.info("Retrieved config from the platform by id");
Configuration retrievedConfig = manager.getConfiguration(IDENTIFICATION, ConfigurationType.EXTERNAL_CONFIG, ENVIRONMENT);
log.info("Retrieved config from the platform by parameters");
log.info("Deleting configuration with id {}", retrievedConfig .getId());
manager.deleteConfiguration(IDENTIFICATION, ConfigurationType.EXTERNAL_CONFIG, ENVIRONMENT);

Test

Hay un test dentro de la librería que sirve como ejemplo. Prueba las operaciones básicas descritas en este tutorial. En caso de tener dudas, puedes consultar el código aquí:

/**
 * Copyright Indra Soluciones Tecnologías de la Información, S.L.U.
 * 2013-2019 SPAIN
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *      http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.minsait.onesait.platform.client;

import java.io.IOException;
import java.util.List;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.experimental.categories.Category;

import com.minsait.onesait.platform.client.enums.ConfigurationType;
import com.minsait.onesait.platform.client.exception.ConfigurationManagerException;
import com.minsait.onesait.platform.client.model.Configuration;
import com.minsait.onesait.platform.testing.IntegrationTest;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Category(IntegrationTest.class)
public class TestConfigurationManager {

	private final static String USERNAME = "developer";
	private final static String PASSWORD = "Changed2019!";
	private final static String SERVER = "http://localhost:18000";
	private final static String IDENTIFICATION = "testing_01";
	private final static String ENVIRONMENT = "default";
	private final static String YML_SAMPLE = "rancher:\r\n  url: https://rancher.sofia4cities.com/\r\n  accessKey: 471D90A16431C2CE7158\r\n  secretKey: VSoq31eGBqaFsG4vUcuvdpkQL1T64FypVPVckaDx";
	private final static ConfigurationType TYPE = ConfigurationType.EXTERNAL_CONFIG;
	private static ConfigurationManager manager;

	@BeforeClass
	public static void startUp() throws ConfigurationManagerException {
		log.info("Initializing Manager");
		manager = new ConfigurationManager(USERNAME, PASSWORD, SERVER);
	}

	@Test
	public void getAllConfigurations() throws IOException, ConfigurationManagerException {
		log.info("Getting Configurations from open platform");
		final List<Configuration> configurations = manager.getConfigurations();
		Assert.assertTrue(configurations.size() > 0);
	}

	@Test
	public void configurationCRUD() throws IOException, ConfigurationManagerException {

		@SuppressWarnings("unchecked")
		final Configuration configuration = Configuration.builder().description("Rancher config sample")
				.environment(ENVIRONMENT).identification(IDENTIFICATION).username(USERNAME).type(TYPE).yml(YML_SAMPLE)
				.build();

		Configuration retrievedConfig = manager.getConfiguration(IDENTIFICATION, ConfigurationType.EXTERNAL_CONFIG,
				ENVIRONMENT);
		if (retrievedConfig != null) {
			log.info("Deleting configuration with id {}", retrievedConfig.getId());
			manager.deleteConfiguration(retrievedConfig.getId());
		}

		log.info("Creating configuration");
		final String id = manager.createConfiguration(configuration);
		Assert.assertNotNull(id);
		log.info("Created configuration, id is {}", id);
		retrievedConfig = manager.getConfigurationById(id);
		Assert.assertNotNull(retrievedConfig);
		log.info("Retrieved config from the platform by id");
		retrievedConfig = manager.getConfiguration(IDENTIFICATION, ConfigurationType.EXTERNAL_CONFIG, ENVIRONMENT);
		Assert.assertNotNull(retrievedConfig);
		log.info("Retrieved config from the platform by parameters");

		configuration.setDescription("This is a new description");
		log.info("Updating configuration with new description and identification {}", IDENTIFICATION);
		manager.updateConfiguration(configuration, id);

		log.info("Deleting configuration with id {}", id);
		manager.deleteConfiguration(IDENTIFICATION, ConfigurationType.EXTERNAL_CONFIG, ENVIRONMENT);

	}
}