Spring Cloud Config
Spring Cloud Config provides server and client-side support for externalized configuration in a distributed system.
Spring Cloud Config Quick Start Page
1. Preparation
Install Spring boot by following Spring boot getting started
Linux for example:
Install Groovy Environment Manager
$ gvm install springboot
$ spring --version
Spring Boot v1.2.5.RELEASE
A simple sample for Spring boot as below:
package hello;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@Controller
@EnableAutoConfiguration
public class SampleController {
@RequestMapping("/")
@ResponseBody
String home() {
return "Hello World!";
}
public static void main(String[] args) throws Exception {
SpringApplication.run(SampleController.class, args);
}
}
Git Clone the Sample Code of Srping Cloud Config
https://github.com/spring-cloud/spring-cloud-config/tree/1.0.2.RELEASE
.
├── docs
├── Guardfile
├── pom.xml
├── README.adoc
├── sample.groovy
├── spring-cloud-config-client
├── spring-cloud-config-sample
└── spring-cloud-config-server
2. The basic architecture of Spring Cloud Config
Setup Tips
- Start Config Server first
- Then start client app.
- After Config Server is down, Cient still works.
- Restarting Config Server will re-clone git properties
- use POST method instead of GET for curl command above
Setup Config Server
1. Start and visit config server
$ cd spring-cloud-config-server
$ mvn spring-boot:run
$ curl localhost:8888/foo/default
$ curl localhost:8888/foo/development
{"name":"development","label":"master","propertySources":[
{"name":"https://github.com/scratches/config-repo/foo-development.properties","source":{"bar":"spam"}}, # The priority of foo-development.properties is higher than foo.properties
{"name":"https://github.com/scratches/config-repo/foo.properties","source":{"foo":"bar"}}
]}
localhost:8888/foo/development is following this convention:
/{application}/{profile}[/{label}]
application: foo
profile: development (environment like develop/qa/release/production)
label: "master" (master branch by default)
Explain more below.
2. Configurations in config server
/spring-cloud-config-server$ tree
.
├── pom.xml
├── src
│ ├── main
│ │ ├── java
│ │ └── resources
│ │ ├── configserver.yml
The content of the configserver.yml
info:
component: Config Server
spring:
application:
name: configserver
jmx:
default_domain: cloud.config.server
cloud:
config:
server:
git:
uri: https://github.com/spring-cloud-samples/config-repo
repos:
- patterns: multi-repo-demo-*
uri: https://github.com/spring-cloud-samples/config-repo
server:
port: 8888
management:
context_path: /admin
The content of the git repository https://github.com/spring-cloud-samples/config-repo:
.
├── application.yml
├── bar.properties
├── configserver.yml
├── eureka.yml
├── foo-development.properties
├── foo.properties
├── processor.yml
├── samplebackendservice-development.properties
├── samplebackendservice.properties
├── samplefrontendservice.properties
├── stores.yml
└── zuul.properties
Will be cloned to /tmp/config-repo-{id} in Linux
localhost:8888/foo/development refer to foo-development.properties
localhost:8888/foo/default refer to foo.properties
Updating git repostiory will reflect to localhost:8888 like /tmp/config-repo-{id}
3. Client Side Usage
Simple structure for client side.
├── pom.xml
├── src
│ ├── main
│ │ ├── java
│ │ │ └── sample
│ │ │ └── Application.java
│ │ └── resources
│ │ ├── application.yml
│ │ └── bootstrap.yml
$ cd spring-cloud-config-sample
$ mvn spring-boot:run
spring-cloud-config-sample/pom.xml
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.3.RELEASE</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-parent</artifactId>
<version>1.0.1.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<!-- repositories also needed for snapshots and milestones -->
Main Client class:
spring-cloud-config-sample/src/main/java/sample/Application.java
@Configuration
@EnableAutoConfiguration
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
spring-cloud-config-sample/src/main/resources/bootstrap.yml
spring:
application:
name: bar
cloud:
config:
env: default # optional
label: master # optional
uri: http://localhost:${config.port:8888}
where it specifies application name bar and the uri of spring cloud config server.
$ curl localhost:8080/env
{
"profiles":[],
"configService:https://github.com/scratches/config-repo/bar.properties":{"foo":"bar"},
"servletContextInitParams":{},
"systemProperties":{...},
...
}
Usage:
1. Get/Refresh properties (Fetch value on request API call)
$ curl localhost:8080/env/foo
bar
$ vi /tmp/config-repo-{id}/bar.properties
.. change value of "bars"
$ curl -X POST localhost:8080/refresh
["foo"]
$ curl localhost:8080/env/foo
bars
2. Usage of ClientAppClass
package demo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@EnableAutoConfiguration
@ComponentScan
@RestController
public class ClientApp {
@Value("${bar:World!}")
String bar;
@RequestMapping("/")
String hello() {
return "Hello " + bar + "!";
}
public static void main(String[] args) {
SpringApplication.run(ClientApp.class, args);
}
}
You can also see a single property.
$ curl http://localhost:8080/env/bar
123456
When you access to the controller,
$ curl http://localhost:8080
Hello 123456!
you can find the property on Config Server is injected.
See more usage samples here: http://qiita.com/making@github/items/704d8e254e03c5cce546