Spring cloud config
Spring Cloud Config: Centralized Configuration Management
Spring Cloud Config provides server and client-side support for externalized configuration in a distributed system. With Spring Cloud Config, you can manage your application configurations centrally, eliminating the need to hardcode properties or rely on local configuration files. This article will explore the features of Spring Cloud Config, provide step-by-step examples of setting up a config server and client, and demonstrate how to manage configurations effectively.
Features of Spring Cloud Config
Centralized Configuration Management
Centralize your application configuration in one place, which simplifies management and ensures consistency across different environments.
Version Control Integration
Integrate with version control systems (e.g., Git, SVN) to version and track configuration changes.
JDBC, Vault
Other backends like JDBC databases, or HashiCorp Vault can be used.
Environment-Specific Configurations
Manage different configurations for different environments (development, testing, production).
Dynamic Configuration Updates
Automatically update configurations in running applications without restarting them.
Secure Configuration Management
Secure sensitive information using encryption and decryption mechanisms.
Setting Up Spring Cloud Config Server
Step 1: Create a Spring Boot Application
First create a new Spring Boot project using Spring Initializr ([https://start.spring.io/](https://start.spring.io/)) to act as the Config Server. Add the necessary dependencies in your `pom.xml` file:
```xml
org.springframework.cloud
spring-cloud-config-server
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-security
```
### Step 2: Enable Config Server
Enable the Config Server by adding the `@EnableConfigServer` annotation to your main application class:
```java
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
@SpringBootApplication
@EnableConfigServer
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigServerApplication.class, args);
}
}
```
### Step 3: Configure the Config Server
Configure the server to load config files from the local filesystem for this demo. Add the following properties to your `application.properties` or `application.yml` file. There are [many backends](https://docs.spring.io/spring-cloud-config/reference/server/environment-repository.html) available including git, jdbc
```ini
server.port=8888
# Enable spring cloud config native profile
spring.profiles.active=native
# Configure cloud config to lookup properties from a local folder
spring.cloud.config.server.native.searchLocations=file:./config
spring.security.user.name=root
spring.security.user.password=changeit
```
### Step 2: Configure the Config Client
Configure the client to connect to the Config Server. Add the following properties to your `application.properties` or `application.yml` file:
##language-ini
`# The application name is used in the cloud config server to allow
# the server to provide configs for multiple applications
spring.application.name=my-client-app
# Load the dev profile (config/my-client-app-dev.properties)
spring.profiles.active=dev
# Be sure to include http auth here if configured
# prefix with `optional:` if the app should be able
# to come up when the server is unavailable.
spring.config.import=configserver:http://root:changeit@localhost:8888
`
### Step 3: Create Configuration Files
Create configuration files in the folder specified in the Config Server. For example, create a file named `config/my-client-app.properties`:
```ini
message=Hello from Spring Cloud Config
```
Multiple property files are merged in a similar way that spring already loads property files, there is a specific ordering where each subsequent property file overwrites any existing keys.
## `application.properties`
- `application-{profile}.properties`
- `{application-name}.properties`
- `{application-name}-{profile}.properties`
Properties can also be stored inside folders representing the application name, eg
`/{application}/application-{profile}.yml
/{application}/application.yml
`
### Step 4: Access Configuration Properties
Access the configuration properties in your client application using the `@Value` annotation or `@ConfigurationProperties`:
```java
package com.example.demo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RefreshScope
public class MessageController {
@Value(${message})
private String message;
@GetMapping(/message)
public String getMessage() {
return this.message;
}
/** Run code when the context is refreshed */
@EventListener({ ContextRefreshedEvent.class })
public void onContextRefreshed() {
/** code to execute when context is refreshed */
System.out.println(Context refreshed, new message value: + message);
}
}
```
## Managing Environment-Specific Configurations
Spring Cloud Config supports environment-specific configurations. You can create different configuration files for different environments (e.g., `application-dev.properties`, `application-prod.properties`).
### Example
In the config folder, create three files.
`config/my-client-app.properties`:
```ini
message=Hello from Default Environment
```
`config/my-client-app-dev.properties`:
```ini
message=Hello from Development Environment
```
`config/my-client-app-prod.properties`:
```ini
message=Hello from Production Environment
```
Spring cloud config works by serving properties via get requests, the endpoint format is simple, `{spring.application.name}/{spring.profile}` with `default` being the default profile. Spring cloud client's simply make the get request and reload any components that have the `@RefreshScope` annotation with the new properties, optionally you can be notified when this happens via annotating a handler in the component with `@EventListener({ ContextRefreshedEvent.class })`
##language-shell
> curl http://root:changeit@localhost:8888/my-client-app/dev | json_pp
{
label : null,
name : my-client-app
Need Expert Help with Spring Cloud Config?
Configuration management at scale requires careful planning and expertise. Our Spring Cloud specialists can help you implement centralized configuration that’s secure, scalable, and easy to manage.
Get Spring Cloud Config Consulting →
