Seite 2: Schritt für Schritt

Inhaltsverzeichnis

Schritt 1: den Config-Server aufsetzen

Der Config-Server ist ein um spezielle Annotationen angereicherter Spring-Boot-Service. Zuerst bekommt er die notwendigen Bibliotheken als Abhängigkeiten hinzugefügt. Zusätzlich zur Referenz auf das Parent-POM spring-boot-starter-parent werden die Artefakte spring-cloud-config-server und spring-core eingebunden. Als start-class definiert man ConfigServerApplication; damit weiß Spring Boot, welche Klasse zum Start des Services verwendet werden soll.

pom.xml 

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.1.5.RELEASE</version>
    <relativePath/> </parent>  
<dependencyManagement>     <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
            <version>1.0.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>         <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.1.RELEASE</version>
        </dependency>         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
            <version>1.0.0.RELEASE</version>
        </dependency>     </dependencies>
</dependencyManagement> <dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <scope>compile</scope>
        <exclusions>             <exclusion>
                <artifactId>commons-logging</artifactId>
                <groupId>commons-logging</groupId>
            </exclusion>         </exclusions>
    </dependency>     <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency> </dependencies> <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <start-class>ConfigServerApplication</start-class>
</properties> 

Als Nächstes wird der Config-Server konfiguriert. Dafür müssen drei Informationen in der Datei application.yml enthalten sein: der Port des Service, der Applikationsname und die Verbindungsparameter für das Git-Repository:

application.yml

server:
  port: 8888
 
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: <git-repository-url>

Zum Starten braucht der Service eine Main-Methode. Sie findet sich in der Klasse ConfigServerApplication.java. Durch die Annotation @EnableConfigServer erkennt Spring Cloud, dass es sich um einen Config-Server handelt. Spring Cloud stellt die Management-Schnittstellen zur Verfügung.

ConfigServerApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
 
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

Damit ist die Programmierung des Config-Servers komplett.

Schritt 2: den Config-Client aufsetzen

Auch der Config-Client ist ein normaler Spring-Boot-Service, der um spezielle Annotationen angereichert wird. Neben der Referenz auf das Parent-POM spring-boot-starter-parent werden die Artefakte spring-cloud-starter-config und spring-core eingebunden.

Für die REST-Schnittstelle, die der Test-Client zur Ausgabe des Konfigurationswerts anbietet, benötigt man das Paket spring-boot-starter-web. Als Startklasse definiert man com.maibornwolff.Application.

pom.xml

<parent>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-parent</artifactId>
    <version>1.0.1.RELEASE</version>
    <relativePath/>
</parent>
 
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.1.6.RELEASE</version>
        <scope>compile</scope>
        <exclusions>
            <exclusion>
                <artifactId>commons-logging</artifactId>
                <groupId>commons-logging</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
 
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <start-class>com.maibornwolff.Application</start-class>
</prpoperties>

Der Config-Client verbindet sich mit dem Config-Server anhand der konfigurierten URL. Sie steht in der Datei bootstrap.yml:

spring:
  application:
    name: config-client
  cloud:
    config:
      uri: http://localhost:8888

Um auf Konfigurationswerte im Client zuzugreifen, ist ein weiterer Spring-Boot-Service einzurichten, der unter der URL http://localhost:8080/project-name den im Beispiel konfigurierten Projektnamen zurückgibt. Das geschieht in der Klasse Application.java. Dafür ist die Annotation @EnableAutoConfiguration hinzuzufügen. Der Zugriff auf Konfigurationswerte erfolgt über die Spring-Core-Annotation @Value(${<property-key>}). Die REST-Schnittstelle wird anhand der Annotation @RequestMapping("/project-name") definiert.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@EnableAutoConfiguration
@RestController
public class Application {
 
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
 
    @Value("${configuration.projectName}")
    private String projectName;
 
    @RequestMapping("/project-name")
    String projectName() {
        return this.projectName;
    }
 
}

Config-Server und Config-Client sind damit fertig eingerichtet. Die Konfiguration müssen Entwickler im Git-Repository ablegen. Dazu pushen sie eine Datei namens config-client.properties mit folgendem Inhalt in das Repository:

configuration.projectName=my_first_cloud_project
 

Erster Test

Nach dem Start von Config-Server und -Clients folgt der Test der Services mit CURL:

? curl http://localhost:8080/project-name
my_first_cloud_project

Um die Auslieferung umgebungsspezifischer Konfigurationen zu testen, pushen Entwickler eine zweite Konfiguration mit der Endung "dev" und einem veränderten Inhalt ins Git.

configuration.projectName=my_first_cloud_project_on_dev

Die Client-Konfiguration gibt an, welches profile der Client nutzen soll. Das geschieht entweder über einen Startparameter (-Dspring.profiles.active=dev) oder einen Eintrag in der Datei bootstrap.yml.

spring:
  application:
    name: config-client
  cloud:
    config:
      uri: http://localhost:8888
  profiles:
    active: dev

Nach einem Neustart können Entwickler die Konfiguration aus config-client-dev.properties auslesen:

$curl http://localhost:8080/project-name
my_first_cloud_project_on_dev