Dynamic Configuration Updates with Spring Cloud Config

In a microservices architecture, managing configuration properties across multiple services can become challenging, especially when these configurations need to be updated frequently. Spring Cloud Config provides a centralized configuration management solution, allowing you to manage external properties for applications across all environments. One of the key features of Spring Cloud Config is its ability to dynamically update configurations without the need to restart services.

This article will guide you through the process of setting up dynamic configuration updates with Spring Cloud Config. We will explore how to create a Spring Cloud Config Server, connect it with a client application, and demonstrate how configuration changes can be dynamically applied to a Spring Boot application.

Spring Cloud Config Server

Spring Cloud Config Server provides a centralized configuration service that is distributed and versioned, with support for dynamic updates. It typically fetches configurations from a Git repository and serves them to client applications.

Dynamic Configuration Updates

To enable dynamic updates, Spring Cloud integrates with Spring Cloud Bus, which provides a simple way to refresh configurations across multiple instances of microservices. When a configuration is updated in the Git repository, the Config Server detects the changes, and Spring Cloud Bus triggers a refresh event across all connected clients.

Key Features:

• Centralized Configuration Management: Allows you to manage configuration properties for all microservices from a single location, simplifying configuration management in complex environments.
• Dynamic Configuration Updates: Spring Cloud Config can dynamically update configuration properties without requiring client applications to restart, achieved through integration with Spring Cloud Bus.
• Versioned and Distributed Configuration: Configurations managed by Spring Cloud Config are stored in a version control system like Git, providing versioning and rollback capabilities to track changes and revert to previous configurations if necessary.
• Environment-Specific Configurations: Spring Cloud Config supports environment-specific configurations, allowing you to define configurations for development, staging, and production environments. The appropriate configuration is automatically selected based on the active profile.
• Secure Configuration: Sensitive data, such as passwords and API keys, can be encrypted and stored securely in configuration files, with built-in support for encryption and decryption of configuration properties.
• Scalability: Spring Cloud Config is designed to work in large, distributed environments, ensuring that configuration updates scale to many microservices across multiple environments and data centers.

Implementation of Dynamic Configuration Updates with Spring Cloud Config in a Spring Boot Project

Step 1: Create the Git Repository

Create a Git repository to store configuration files. For example, create an application.yml file with the following configuration:

Message: Default Message

Step 2: Setup the Config Server

2.1: Create a New Spring Boot Project

Create a new Spring Boot project using IntelliJ IDEA with the following options:

• Name: config-server
• Language: Java
• Type: Maven
• Packaging: Jar

Click on the Next button.

2.2: Add Dependencies

Add the following dependencies into the Spring Boot project.

Project Structure

Once the project creation done, the file structure will look like the below image.

2.3: Configure Application Properties

Rename application.properties to application.yml and add the following configuration:

spring:
 cloud:
 config:
 server:
 git:
 uri: https://github.com/iammahesh123/config-repo
 clone-on-start: true
server:
 port: 8888

• The uri specifies the location of the Git repository containing the configuration files.
• clone-on-start ensures that the repository is cloned every time the server starts, ensuring the latest configurations are loaded.

2.4: Main Class

This is the entry point of the application. Add the @EnableConfigServer annotation to enable the Config Server functionality.

• The @EnableConfigServer annotation activates the Config Server in the Spring Boot application.
• SpringApplication.run starts the application.

pom.xml file:

2.5: Run the Application

Run the application. It will start and listen on port 8888.

Step 3: Setup the Client Application

3.1: Create a New Spring Boot Project

Create a new Spring Boot project using IntelliJ IDEA with the following options:

• Name: client-application
• Language: Java
• Type: Maven
• Packaging: Jar

Click on the Next button.

3.2: Add Dependencies

Add the following dependencies into the Spring Boot project.

Project Structure

Once the project is created, then the file structure will look like the below image.

• spring-boot-starter-actuator is included to monitor and manage the application.
• spring-boot-starter-web sets up a web application, while lombok and spring-boot-starter-test provide code reduction and testing support.

3.3: Configure Application Properties

Rename application.properties to application.yml and add the following configuration:

spring:
 cloud:
 config:
 uri: http://localhost:8888

The uri specifies the location of the Config Server.

3.4: Create the MessageController Class

Create a new class MessageController.java in the com.gfg.clientapplication package to handle incoming HTTP requests.

• @RestController marks the class as a REST controller.
• The @Value annotation injects the message property from the configuration, and @GetMapping maps the /message endpoint to the getMessage method.

3.5: Main Class

No changes are required in the main class, but for reference:

pom.xml file:

3.6: Run the Application

Now run the application, and it will start at port 8080.

Step 4: Testing the Endpoint

test the /message endpoint by sending a GET request to http://localhost:8080/message. It will return the default message from the configuration.

GET http://localhost:8080/message

Output:

Updating the Application Properties in GitHub

To see dynamic updates in action, update the message property in your GitHub repository to something like:

Message: Hello from Spring Cloud Config!

Then, you can trigger the refresh event and verify that the client application reflects the updated configuration without a restart.

Again, run the endpoint,

GET http://localhost:8080/message

Output:

This example project demonstrates the dynamic configuration with Spring Cloud Config of Spring Boot Project.