{"id":71572,"date":"2017-12-20T10:00:36","date_gmt":"2017-12-20T08:00:36","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=71572"},"modified":"2017-12-19T10:39:31","modified_gmt":"2017-12-19T08:39:31","slug":"intro-spring-cloud-config-server","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2017\/12\/intro-spring-cloud-config-server.html","title":{"rendered":"Intro to Spring Cloud Config Server"},"content":{"rendered":"

1. Overview<\/h2>\n

In this tutorial, we will review the basics of Spring Cloud Config Server<\/strong>. We will setup a Config Server<\/strong> and then build a client application<\/strong> that consumes the configuration<\/strong> on startup and then\u00a0refreshes\u00a0the configuration without restarting. The application we are building is the same \u201cHello World\u201d application discussed in the Centralized Configuration Getting Started Guide<\/a>, but we go into more depth about the concepts of Spring Cloud Config Server in this article.<\/p>\n

The full source code for the tutorial is on Github<\/a>.<\/p>\n

2. What is Spring Cloud Config Server?<\/h2>\n

As the documentation<\/a> succinctly states, \u201cSpring Cloud Config provides server and client-side support for externalized configuration in a distributed system.\u201d\u00a0The default implementation of the server storage backend uses git<\/strong>,\u00a0so it supports labelled versions of configuration environments with ease and is accessible to many tools for managing the content.<\/p>\n

Spring Cloud Config fits very well into Spring applications<\/strong> because its concepts of both client and server map precisely to the Spring Environment<\/em>\u00a0and PropertySource<\/em>\u00a0abstractions. However, Spring Cloud Config can be used with any application running in any language.<\/p>\n

3. Create a Multi Module Project<\/h2>\n

The application we are creating will have two modules: one for the Configuration Service and the other for the Configuration client. Because of this, we need to create a parent pom<\/em>.<\/p>\n

3.1 Parent<\/h3>\n

In our IDE, let\u2019s create a new project. I\u2019m using Spring Tool Suite, but that\u2019s just a personal preference.<\/p>\n

In our\u00a0pom.xml<\/em>, let\u2019s specify our two modules:<\/p>\n

<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\" xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\r\n\t<modelVersion>4.0.0<\/modelVersion>\r\n\r\n\t<groupId>com.michaelcgood<\/groupId>\r\n\t<artifactId>com.michaelcgood<\/artifactId>\r\n\t<version>0.0.1<\/version>\r\n\t<packaging>pom<\/packaging>\r\n\r\n\t<name>michaelcgood-spring-cloud-config-server<\/name>\r\n\t<description>Intro to Spring Cloud Config Server<\/description>\r\n\r\n\r\n    <modules>\r\n        <module>mcg-configuration-client<\/module>\r\n        <module>mcg-configuration-service<\/module>\r\n    <\/modules>\r\n\r\n<\/project><\/pre>\n
3.2 Configuration Service<\/h3>\n
In our IDE, let\u2019s create a new Maven module for our configuration service and insert this in our pom<\/em>:<\/p>\n
<?xml version=\"1.0\"?>\r\n<project xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\" xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\">\r\n  <modelVersion>4.0.0<\/modelVersion>\r\n  <groupId>com.michaelcgood<\/groupId>\r\n  <artifactId>mcg-configuration-service<\/artifactId>\r\n  <version>0.0.1<\/version>\r\n  <packaging>jar<\/packaging>\r\n  <name>mcg-configuration-service<\/name>\r\n \r\n    <parent>\r\n        <groupId>org.springframework.boot<\/groupId>\r\n        <artifactId>spring-boot-starter-parent<\/artifactId>\r\n        <version>1.5.9.RELEASE<\/version>\r\n        <relativePath \/> <!-- lookup parent from repository -->\r\n    <\/parent>\r\n\r\n    <properties>\r\n        <project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\r\n        <java.version>1.8<\/java.version>\r\n    <\/properties>\r\n\r\n    <dependencies>\r\n        <dependency>\r\n            <groupId>org.springframework.cloud<\/groupId>\r\n            <artifactId>spring-cloud-config-server<\/artifactId>\r\n        <\/dependency>\r\n\r\n        <dependency>\r\n            <groupId>org.springframework.boot<\/groupId>\r\n            <artifactId>spring-boot-starter-test<\/artifactId>\r\n            <scope>test<\/scope>\r\n        <\/dependency>\r\n    <\/dependencies>\r\n\r\n    <dependencyManagement>\r\n        <dependencies>\r\n            <dependency>\r\n                <groupId>org.springframework.cloud<\/groupId>\r\n                <artifactId>spring-cloud-dependencies<\/artifactId>\r\n                <version>Edgware.RELEASE<\/version>\r\n                <type>pom<\/type>\r\n                <scope>import<\/scope>\r\n            <\/dependency>\r\n        <\/dependencies>\r\n    <\/dependencyManagement>\r\n\r\n    <build>\r\n        <plugins>\r\n            <plugin>\r\n                <groupId>org.springframework.boot<\/groupId>\r\n                <artifactId>spring-boot-maven-plugin<\/artifactId>\r\n            <\/plugin>\r\n        <\/plugins>\r\n    <\/build>\r\n<\/project><\/pre>\n
3.3 Configuration Client<\/h3>\n
Now we just need to make a module for our configuration client. So, let\u2019s make another Maven module and insert this into our pom<\/em>:
 
<\/div> <\/div><\/p>\n
<?xml version=\"1.0\"?>\r\n<project xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\" xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\">\r\n  <modelVersion>4.0.0<\/modelVersion>\r\n  <groupId>com.michaelcgood<\/groupId>\r\n  <artifactId>mcg-configuration-client<\/artifactId>\r\n  <version>0.0.1<\/version>\r\n  <packaging>jar<\/packaging>\r\n  \t<parent>\r\n\t\t<groupId>org.springframework.boot<\/groupId>\r\n\t\t<artifactId>spring-boot-starter-parent<\/artifactId>\r\n\t\t<version>1.5.9.RELEASE<\/version>\r\n\t\t<relativePath\/> <!-- lookup parent from repository -->\r\n\t<\/parent>\r\n\r\n\t<properties>\r\n\t\t<project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\r\n\t\t<java.version>1.8<\/java.version>\r\n\t<\/properties>\r\n\r\n\t<dependencies>\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework.cloud<\/groupId>\r\n\t\t\t<artifactId>spring-cloud-starter-config<\/artifactId>\r\n\t\t<\/dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework.boot<\/groupId>\r\n\t\t\t<artifactId>spring-boot-starter-actuator<\/artifactId>\r\n\t\t<\/dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework.boot<\/groupId>\r\n\t\t\t<artifactId>spring-boot-starter-web<\/artifactId>\r\n\t\t<\/dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework.boot<\/groupId>\r\n\t\t\t<artifactId>spring-boot-starter-test<\/artifactId>\r\n\t\t\t<scope>test<\/scope>\r\n\t\t<\/dependency>\r\n\t<\/dependencies>\r\n\r\n\t<dependencyManagement>\r\n\t\t<dependencies>\r\n\t\t\t<dependency>\r\n\t\t\t\t<groupId>org.springframework.cloud<\/groupId>\r\n\t\t\t\t<artifactId>spring-cloud-dependencies<\/artifactId>\r\n\t\t\t\t<version>Edgware.RELEASE<\/version>\r\n\t\t\t\t<type>pom<\/type>\r\n\t\t\t\t<scope>import<\/scope>\r\n\t\t\t<\/dependency>\r\n\t\t<\/dependencies>\r\n\t<\/dependencyManagement>\r\n\r\n\t<build>\r\n\t\t<plugins>\r\n\t\t\t<plugin>\r\n\t\t\t\t<groupId>org.springframework.boot<\/groupId>\r\n\t\t\t\t<artifactId>spring-boot-maven-plugin<\/artifactId>\r\n\t\t\t<\/plugin>\r\n\t\t<\/plugins>\r\n\t<\/build>\r\n<\/project><\/pre>\n
Our project structure looks like this now:
\n\"\"<\/a><\/p>\n
4. Config Server<\/h2>\n
Now we will create a Config Servic<\/strong>e to act as an intermediary between our client and a git repository<\/strong>.<\/p>\n
4.1 Enable Config Server<\/h3>\n
We use Spring Cloud\u2019s @EnableConfigServer<\/em> to create a config server that can be communicated with. So, this is just a normal Spring Boot application with one annotation added to enable the Config Server<\/strong>.:<\/p>\n
@EnableConfigServer\r\n@SpringBootApplication\r\npublic class ConfigServiceApplication {\r\n    \r\n    public static void main(String[] args) {\r\n        SpringApplication.run(ConfigServiceApplication.class, args);\r\n    }\r\n}<\/pre>\n
4.2 application.properties<\/h3>\n
To ensure that there is no conflict between ports for our Config Service and client, we specify a different port for the Config Service:<\/p>\n
server.port=8888\r\n\r\nspring.cloud.config.server.git.uri=${HOME}\/Desktop\/mcg-config<\/pre>\n
The second line spring.cloud.config.server.git.uri=${HOME}\/Desktop\/mcg-config<\/em> points to a git repository, which we will create next.<\/p>\n
4.3 Git<\/h3>\n
On a *nix system, we can do everything on the command line.
\nWe make a folder on our desktop:<\/p>\n
mkdir mcg-config<\/pre>\n
We create a file named a-bootiful-client.properties<\/em> using vim<\/a>:<\/p>\n
vim a-bootiful-client.properties<\/pre>\n
We add the message, \u201cHello World\u201d but this could be whatever we would like. After we write (:w) we quit (:q) vim.<\/p>\n
Now let\u2019s create a new repo:<\/p>\n
git init<\/pre>\n
Now we add the file that contains our message:<\/p>\n
git add a-bootiful-client.properties<\/pre>\n
Let\u2019s commit:<\/p>\n
git commit<\/pre>\n
\u00a05. Configuration Client<\/h2>\n
Now let\u2019s create a new Spring Boot application that uses the Config Server to load its own configuration and that refreshes its configuration to reflect changes to the Config Server on-demand, without restarting the JVM.<\/p>\n
Spring will see the configuration property files just like it would any property file loaded from application.properties<\/em>, application.yml<\/em> or any other PropertySource<\/em>.<\/p>\n
5.1 Reflecting Changes<\/h3>\n
The client may access any value in the Config Server using the standard Spring ways, such as @ConfigurationProperties<\/em> or @Value(\u201c${\u2026\u200b}\u201d)<\/em>.<\/p>\n
With this in mind, we create a REST controller that returns the resolved message property\u2019s value:<\/p>\n
@SpringBootApplication\r\npublic class ConfigClientApplication {\r\n\r\n    public static void main(String[] args) {\r\n        SpringApplication.run(ConfigClientApplication.class, args);\r\n    }\r\n}\r\n\r\n@RefreshScope\r\n@RestController\r\nclass MessageRestController {\r\n\r\n    @Value(\"${message:Hello default}\")\r\n    private String message;\r\n\r\n    @RequestMapping(\"\/message\")\r\n    String getMessage() {\r\n        return this.message;\r\n    }\r\n}<\/pre>\n
The default configuration only allows the values to be read on the client\u2019s startup and not again. So, using @RefreshScope<\/em> we force the bean to refresh its configuration, which means it will pull updated values from the Config Server, and then trigger a refresh event.<\/p>\n
5.2 bootstrap.properties<\/h3>\n
The properties to configure the Config Client must be read in before the rest of the application\u2019s configuration is read from the Config Server, during the bootstrap phase.<\/p>\n
We specify the client\u2019s spring.application.name<\/em> and the location of the Config Server spring.cloud.config.uri<\/em>:<\/p>\n
spring.application.name=a-bootiful-client\r\nspring.cloud.config.uri=http:\/\/localhost:8888\r\nmanagement.security.enabled=false<\/pre>\n
Notice:<\/strong>
\nWe disabled security with our setting management.security.enabled=false<\/em> to make testing and tinkering easy for us.<\/p>\n
6. Demo<\/h2>\n
First we need to change directory to our configuration service and start it:<\/p>\n
mcg-configuration-service mike$  mvn spring-boot:run<\/pre>\n
And then do the same for our client:<\/p>\n
mcg-configuration-client mike$  mvn spring-boot:run<\/pre>\n
We can see in our terminal for configuration service when the a-bootiful-client.properties<\/em> is added:<\/p>\n
INFO 5921 --- [nio-8888-exec-1] o.s.c.c.s.e.NativeEnvironmentRepository  : Adding property source: file:\/var\/folders\/dk\/48l9cm2x3vnfl5ymh6dtxpwc0000gn\/T\/config-repo-7195892194658362240\/a-bootiful-client.properties<\/pre>\n
Let\u2019s open our browser and visit http:\/\/localhost:8080\/message<\/em>. We see \u201cHello World\u201d.<\/p>\n
Now let\u2019s change the message in a-bootiful-client.properties<\/em> again and this time put, \u201cHi! :-)\u201d.<\/p>\n
After saving and doing a commit, we visit http:\/\/localhost:8888\/a-bootiful-client\/default<\/em> to confirm our change.<\/p>\n
Now we invoke the Spring Boot Actuator refersh endpoint to refresh our client:<\/p>\n
curl -X POST http:\/\/localhost:8080\/refresh<\/pre>\n
We visit http:\/\/localhost:8080\/message <\/em>and see our message \u201cHi! :-)\u201d is displayed.<\/p>\n
For more information on Spring Boot Actuator, see the tutorial Building Spring Boot RESTful Service + Spring Boot Actuator<\/a>.<\/p>\n
7. Conclusion<\/h2>\n
We just completed centralizing configuration of our services in Spring. We accomplished this by standing up a Spring Cloud Config Server and creating a client to consume the configuration on startup and then refresh the configuration without restarting.<\/p>\n
Many other things can be done with Spring Cloud Config Server that we did not touch on, such as:<\/p>\n