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:

  1. Install Groovy Environment Manager
  2. $ gvm install springboot
  3. $ spring --version
  4. Spring Boot v1.2.5.RELEASE

A simple sample for Spring boot as below:

  1. package hello;
  3. import org.springframework.boot.*;
  4. import org.springframework.boot.autoconfigure.*;
  5. import org.springframework.stereotype.*;
  6. import org.springframework.web.bind.annotation.*;
  8. @Controller
  9. @EnableAutoConfiguration
  10. public class SampleController {
  12.     @RequestMapping("/")
  13.     @ResponseBody
  14.     String home() {
  15.         return "Hello World!";
  16.     }
  18.     public static void main(String[] args) throws Exception {
  19.         SpringApplication.run(SampleController.class, args);
  20.     }
  21. }

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

  1. Start Config Server first
  2. Then start client app.
  3. After Config Server is down, Cient still works.
  4. Restarting Config Server will re-clone git properties
  5. use POST method instead of GET for curl command above

Setup Config Server

1. Start and visit config server

  1. $ cd spring-cloud-config-server
  2. $ mvn spring-boot:run
  3. $ curl localhost:8888/foo/default
  4. $ curl localhost:8888/foo/development
  5. {"name":"development","label":"master","propertySources":[
  6.   {"name":"https://github.com/scratches/config-repo/foo-development.properties","source":{"bar":"spam"}}, # The priority of foo-development.properties is higher than foo.properties
  7.   {"name":"https://github.com/scratches/config-repo/foo.properties","source":{"foo":"bar"}}
  8. ]}

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

  1. /spring-cloud-config-server$ tree
  2. .
  3. ├── pom.xml
  4. ├── src
  5. │   ├── main
  6. │   │   ├── java
  7. │   │   └── resources
  8. │   │       ├── configserver.yml

The content of the configserver.yml

  1. info:
  2.   component: Config Server
  3. spring:
  4.   application:
  5.     name: configserver
  6.   jmx:
  7.     default_domain: cloud.config.server
  8.   cloud:
  9.     config:
  10.       server:
  11.         git:
  12.           uri: https://github.com/spring-cloud-samples/config-repo
  13.           repos:
  14.             - patterns: multi-repo-demo-*
  15.               uri: https://github.com/spring-cloud-samples/config-repo
  17. server:
  18.   port: 8888
  19. management:
  20.   context_path: /admin

The content of the git repository https://github.com/spring-cloud-samples/config-repo:

  1. .
  2. ├── application.yml
  3. ├── bar.properties
  4. ├── configserver.yml
  5. ├── eureka.yml
  6. ├── foo-development.properties
  7. ├── foo.properties
  8. ├── processor.yml
  9. ├── samplebackendservice-development.properties
  10. ├── samplebackendservice.properties
  11. ├── samplefrontendservice.properties
  12. ├── stores.yml
  13. └── 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.

  1. ├── pom.xml
  2. ├── src
  3. │   ├── main
  4. │   │   ├── java
  5. │   │   │   └── sample
  6. │   │   │       └── Application.java
  7. │   │   └── resources
  8. │   │       ├── application.yml
  9. │   │       └── bootstrap.yml
  1. $ cd spring-cloud-config-sample
  2. $ mvn spring-boot:run

spring-cloud-config-sample/pom.xml

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>1.2.3.RELEASE</version>
  5.     <relativePath /> <!-- lookup parent from repository -->
  6. </parent>
  8. <dependencyManagement>
  9.     <dependencies>
  10.         <dependency>
  11.             <groupId>org.springframework.cloud</groupId>
  12.             <artifactId>spring-cloud-starter-parent</artifactId>
  13.             <version>1.0.1.RELEASE</version>
  14.             <type>pom</type>
  15.             <scope>import</scope>
  16.         </dependency>
  17.     </dependencies>
  18. </dependencyManagement>
  20. <dependencies>
  21.     <dependency>
  22.         <groupId>org.springframework.cloud</groupId>
  23.         <artifactId>spring-cloud-starter-config</artifactId>
  24.     </dependency>
  25.     <dependency>
  26.         <groupId>org.springframework.boot</groupId>
  27.         <artifactId>spring-boot-starter-test</artifactId>
  28.         <scope>test</scope>
  29.     </dependency>
  30. </dependencies>
  32. <build>
  33.     <plugins>
  34.         <plugin>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-maven-plugin</artifactId>
  37.         </plugin>
  38.     </plugins>
  39. </build>
  41. <!-- repositories also needed for snapshots and milestones -->

Main Client class:

spring-cloud-config-sample/src/main/java/sample/Application.java

  1. @Configuration
  2. @EnableAutoConfiguration
  3. public class Application {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(Application.class, args);
  6.     }
  7. }

spring-cloud-config-sample/src/main/resources/bootstrap.yml

  1. spring:
  2.   application:
  3.     name: bar
  4.   cloud:
  5.     config:
  6.       env: default # optional
  7.       label: master # optional
  8.       uri: http://localhost:${config.port:8888}

where it specifies application name bar and the uri of spring cloud config server.

  1. $ curl localhost:8080/env
  2. {
  3.   "profiles":[],
  4.   "configService:https://github.com/scratches/config-repo/bar.properties":{"foo":"bar"},
  5.   "servletContextInitParams":{},
  6.   "systemProperties":{...},
  7.   ...
  8. }

Usage:

1. Get/Refresh properties (Fetch value on request API call)

  1. $ curl localhost:8080/env/foo
  2. bar
  3. $ vi /tmp/config-repo-{id}/bar.properties
  4. .. change value of "bars"
  5. $ curl -X POST localhost:8080/refresh
  6. ["foo"]
  7. $ curl localhost:8080/env/foo
  8. bars

2. Usage of ClientAppClass

  1. package demo;
  3. import org.springframework.beans.factory.annotation.Value;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  6. import org.springframework.context.annotation.ComponentScan;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  10. @EnableAutoConfiguration
  11. @ComponentScan
  12. @RestController
  13. public class ClientApp {
  14.     @Value("${bar:World!}")
  15.     String bar;
  17.     @RequestMapping("/")
  18.     String hello() {
  19.         return "Hello " + bar + "!";
  20.     }
  22.     public static void main(String[] args) {
  23.         SpringApplication.run(ClientApp.class, args);
  24.     }
  25. }

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

posted @ 2015-12-20 01:07  雄狮_杜  阅读(262)  评论(0)  编辑  收藏  举报