--- title: "¿Cómo usar Configuración Centralizada de Plataforma en tu aplicación?" canonical: "https://onesaitplatform-es.refined.site/space/DOC/2216832401/%C2%BFC%C3%B3mo%20usar%20Configuraci%C3%B3n%20Centralizada%20de%20Plataforma%20en%20tu%20aplicaci%C3%B3n%3F" format: markdown --- > Macro (toc) > ℹ️ En versiones anteriores a la 2.3.0 esta funcionalidad está disponible en el menú **Administración > Gestión de Configuraciones** y sólo está disponible para roles **Administradores**. 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**. ![image](media://8c1618be-5c48-4137-8bd4-24bb67ad9f32) 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**: > ℹ️ En versiones anteriores a la 2.3.0 el campo **identification** no existe, en su lugar estará el campo **suffix** ![image](media://ad709261-de00-4367-a7d9-f9a095f54005) Al crear una nueva Configuración el usuario tiene que rellenar el siguiente formulario: ![image](media://bb7677e8-eeba-49c5-b010-df195dc4287e) 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: ![image](media://3036bfb9-e7f7-4f50-ab8b-a4066530c1d4) API REST Además, se pueden realizar operaciones a través de una API REST existente, cuyos endpoints comienzan con '**/controlpanel/api/configurations**'. ![image](media://c9810642-725d-4492-aa37-d14ffd0e58ee) **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 > ⚠️ Sólo para versiones a partir de la 5.0.0 (RECOMENDADO) En primer lugar tendrás que añadir al *pom.xml* del proyecto que va a actuar como Config Server la siguiente dependencia. ``` com.minsait.onesait.platform onesaitplatform-spring-config-client 5.0.0 ``` Y tendrás que añadir el repositorio de Plataforma al listado de repositorios dentro del pom: ``` onesait platform releases https://nexus.onesaitplatform.com/nexus/content/repositories/releases/ ``` Una vez añadida la dependencia tendrás que añadir las siguientes propiedades a tu *application.yml* ``` onesaitplatform: api.rest: token: endpoint: 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: ```java @Autowired ConfigurationManager configManager; ``` ### Crear configuración ```java configManager.createConfiguration(configuration) ``` Dónde el objeto **configuration** está conpuesto por los siguientes campos: ```java 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: ```java # 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 configList = configManager.getConfigurations() ``` ### Actualizar configuración ```java configManager.updateConfiguration(configuration); ``` ### Borrar configuración ```java # 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 > ⚠️ Seguir este apartado solo para versiones inferiores a la 3.3.2 del cliente Java. Se recomienda utilizar la versión 5.0.0 (explicado en el apartado anterior) 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. ```xml onesait platform releases https://nexus.onesaitplatform.com/nexus/content/repositories/releases/ ``` Después de esto hay que añadir la dependencia: ```xml com.minsait.onesait.platform onesaitplatform-java-client 2.1.0-RELEASE ``` ### 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:** ```java 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**: ```java 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**: ```java 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**: ```java List 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**: ```java 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í:
Clase Test ```java /** * 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 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); } } ```