How to Create Config Server in Microservices Architecture with Spring Cloud Config Server

The ability of microservices architecture to deconstruct big monolithic programmes into smaller, independent, and controllable services has led to its enormous growth in popularity in recent years. It can be difficult to manage configuration across numerous microservices, though, as each service may call for a separate set of configurations. To solve this problem, configurations for microservices are centralised and managed by a separate Config Server. In this post, we'll examine what a Config Server is, why it's crucial for microservices, and how to use Spring Cloud Config Server to construct it.

What is a Config Server in Microservices?

A Config Server in microservices is a central component that stores and manages configurations for various services within the architecture. Its primary purpose is to decouple the configuration from individual services, promoting a more dynamic and flexible approach to managing application properties.

Importance of Config Server in Microservices

Centralized Configuration Management: With a Config Server, all configurations are stored in one central place, which simplifies the management of properties for all microservices. Changes to configurations can be done in one location, and services can fetch updated configurations without requiring a redeployment.

Dynamic Configurations: Configurations can be altered at runtime without restarting the microservices. This dynamic behavior allows you to adapt to changing requirements and fine-tune service behaviors without service interruptions.

Versioned Configurations: The Config Server can support versioning of configurations, enabling you to roll back to previous configurations easily or track configuration changes over time.

Security and Access Control: Config Servers can be equipped with security mechanisms to control access to sensitive configuration properties, ensuring that only authorized services can access specific configurations.

Scalability and High Availability: Config Servers can be designed to be highly available and scalable, reducing the risk of a single point of failure for configuration management.

Implementing Config Server with Spring Cloud Config Server

Spring Cloud provides a powerful solution for implementing a Config Server in a microservices environment. The Spring Cloud Config Server allows you to externalize configurations from microservices into a centralized configuration server.

Step 1: Create a Spring Boot Config Server Project

To get started, you need to create a new Spring Boot project and include the Spring Cloud Config Server dependency in your `pom.xml` or `build.gradle` file.

For Maven, add the following dependency:

<dependency>

    <groupId>org.springframework.cloud</groupId>

    <artifactId>spring-cloud-config-server</artifactId>

</dependency>

Step 2: Configuration

In your Spring Boot application, you need to enable the Config Server and specify the location of the configuration files. You can do this by adding the `@EnableConfigServer` annotation to your main application class:

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication

@EnableConfigServer

public class ConfigServerApplication {

    public static void main(String[] args) {

        SpringApplication.run(ConfigServerApplication.class, args);

    }

}

Step 3: Configuration Files

Create a Git repository to store the configuration files. The Spring Cloud Config Server uses Git as its default backend, but you can also use other version control systems or file systems.

Create configuration files in the following format:

users-service.properties

users-service-dev.properties

users-service-prod.properties

The file naming convention above follows the pattern `[service-name]-[profile].properties`. Here, `service-name` represents the name of the microservice, and `profile` denotes the environment or configuration profile (e.g., dev, prod, test, etc.).

Step 4: Configuration Repository

In your Config Server's `application.properties` file, specify the Git repository where the configuration files are stored:

spring.cloud.config.server.git.uri=URL_TO_YOUR_GIT_REPO

Step 5: Running the Config Server

Now, you can run the Config Server application, which will connect to the Git repository and expose the configurations over HTTP.

Step 6: Microservice Configuration

In your microservices, you need to enable the Spring Cloud Config client to fetch configurations from the Config Server. Add the following dependency to your microservice project:

<dependency>

    <groupId>org.springframework.cloud</groupId>

    <artifactId>spring-cloud-starter-config</artifactId>

</dependency>

Step 7: Microservice Bootstrap Configuration

In your microservice's `bootstrap.properties` or `bootstrap.yml`, configure the location of the Config Server:

spring.cloud.config.uri=URL_TO_YOUR_CONFIG_SERVER

Step 8: Fetching Configurations

Now, your microservice will fetch its configurations from the Config Server at startup. You can use the configurations in your code just like regular Spring properties.

Let's take an example of a simple microservice named "Product Service" that needs configuration properties for its database connection and some other settings.

• Set up a Git repository with the following configuration files:

# product-service.properties

db.url=jdbc:mysql://localhost:3306/productdb

db.username=admin

db.password=secretpassword

• Implement the Spring Cloud Config Server as described in the previous steps.

• Create a "Product Service" with the following bootstrap configuration:

# bootstrap.properties

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

In the "Product Service" code, use the configurations as regular Spring properties:

@RestController

public class ProductController {

    @Value("${db.url}")

    private String dbUrl;

    @Value("${db.username}")

    private String dbUsername;

    @Value("${db.password}")

    private String dbPassword;

    // Rest of the code...

}

With this setup, the "Product Service" will fetch its configuration from the Config Server during startup, and the `dbUrl`, `dbUsername`, and `dbPassword` properties will be injected with the appropriate values from the Git repository.

Conclusion

In conclusion, a Config Server plays a crucial role in microservices architecture by centralizing and managing configurations for various services. With the Spring Cloud Config Server, you can easily implement a robust and scalable configuration management solution for your microservices. 

This promotes better separation of concerns and allows you to adapt your services dynamically to changing requirements without the need for redeployment.

By following the step-by-step guide and example provided in this article, you can set up your own Spring Cloud Config Server and enhance the management of configurations in your microservices architecture.