Eine Kurzanleitung zum Spring Cloud Consul

1. Übersicht

Das Spring Cloud Consul-Projekt bietet eine einfache Integration mit Consul für Spring Boot-Anwendungen.

Consul ist ein Tool, das Komponenten zur Lösung einiger der häufigsten Herausforderungen in einer Mikrodienstarchitektur bereitstellt:

  • Service Discovery - Zum automatischen Registrieren und Aufheben der Registrierung der Netzwerkspeicherorte von Service-Instanzen
  • Integritätsprüfung - um festzustellen, wann eine Dienstinstanz aktiv ist
  • Verteilte Konfiguration - um sicherzustellen, dass alle Dienstinstanzen dieselbe Konfiguration verwenden

In diesem Artikel erfahren Sie, wie Sie eine Spring Boot-Anwendung für die Verwendung dieser Funktionen konfigurieren können.

2. Voraussetzungen

Zunächst wird empfohlen, einen kurzen Blick auf Consul und alle seine Funktionen zu werfen.

In diesem Artikel verwenden wir einen Consul-Agenten, der auf localhost ausgeführt wird: 8500 . Weitere Informationen zum Installieren von Consul und zum Ausführen eines Agenten finden Sie unter diesem Link.

Zuerst müssen wir die Abhängigkeit von Spring-Cloud-Starter-Consul-All zu unserer pom.xml hinzufügen :

 org.springframework.cloud spring-cloud-starter-consul-all 1.3.0.RELEASE 

3. Serviceerkennung

Schreiben wir unsere erste Spring Boot-Anwendung und verbinden uns mit dem laufenden Consul-Agenten:

@SpringBootApplication public class ServiceDiscoveryApplication { public static void main(String[] args) { new SpringApplicationBuilder(ServiceDiscoveryApplication.class) .web(true).run(args); } }

Standardmäßig versucht Spring Boot, eine Verbindung zum Consul-Agenten unter localhost: 8500 herzustellen . Um andere Einstellungen zu verwenden, müssen wir die Datei application.yml aktualisieren :

spring: cloud: consul: host: localhost port: 8500

Wenn wir dann die Website des Konsulagenten im Browser unter // localhost: 8500 besuchen , sehen wir, dass unsere Anwendung ordnungsgemäß in Konsul mit der Kennung von "$ {spring.application.name}: $ {Profile getrennt durch" registriert wurde Komma}: $ {server.port} ” .

Um diesen Bezeichner anzupassen, müssen wir die Eigenschaft spring.cloud.discovery.instanceId mit einem anderen Ausdruck aktualisieren :

spring: application: name: myApp cloud: consul: discovery: instanceId: ${spring.application.name}:${random.value}

Wenn wir die Anwendung erneut ausführen, sehen wir, dass sie mit der Kennung "MyApp" plus einem zufälligen Wert registriert wurde . Wir benötigen dies, um mehrere Instanzen unserer Anwendung auf unserem lokalen Computer auszuführen.

Um die Serviceerkennung zu deaktivieren, müssen Sie die Eigenschaft spring.cloud.consul.discovery.enabled auf false setzen .

3.1. Nachschlagen von Diensten

Wir haben unsere Anwendung bereits bei Consul registriert, aber wie können Kunden die Service-Endpunkte finden? Wir benötigen einen Discovery-Client-Service, um einen laufenden und verfügbaren Service von Consul zu erhalten.

Spring bietet hierfür eine DiscoveryClient-API an , die wir mit der Annotation @EnableDiscoveryClient aktivieren können :

@SpringBootApplication @EnableDiscoveryClient public class DiscoveryClientApplication { // ... }

Anschließend können wir die DiscoveryClient- Bean in unseren Controller einfügen und auf die Instanzen zugreifen:

@RestController public class DiscoveryClientController { @Autowired private DiscoveryClient discoveryClient; public Optional serviceUrl() { return discoveryClient.getInstances("myApp") .stream() .findFirst() .map(si -> si.getUri()); } }

Schließlich definieren wir unsere Anwendungsendpunkte:

@GetMapping("/discoveryClient") public String discoveryPing() throws RestClientException, ServiceUnavailableException { URI service = serviceUrl() .map(s -> s.resolve("/ping")) .orElseThrow(ServiceUnavailableException::new); return restTemplate.getForEntity(service, String.class) .getBody(); } @GetMapping("/ping") public String ping() { return "pong"; }

Der Pfad "myApp / ping" ist der Name der Spring-Anwendung mit dem Service-Endpunkt. Consul stellt alle verfügbaren Anwendungen mit dem Namen "myApp" zur Verfügung.

4. Gesundheitsprüfung

Consul überprüft regelmäßig den Zustand der Service-Endpunkte.

Standardmäßig implementiert Spring den Integritätsendpunkt so, dass 200 OK zurückgegeben wird, wenn die App aktiv ist . Wenn wir den Endpunkt anpassen möchten, müssen wir die application.yml aktualisieren :

spring: cloud: consul: discovery: healthCheckPath: /my-health-check healthCheckInterval: 20s

Infolgedessen fragt Consul alle 20 Sekunden den Endpunkt "/ my-health-check" ab .

Definieren wir unseren benutzerdefinierten Integritätsprüfungsdienst, um den Status VERBOTEN zurückzugeben :

@GetMapping("/my-health-check") public ResponseEntity myCustomCheck() { String message = "Testing my healh check function"; return new ResponseEntity(message, HttpStatus.FORBIDDEN); }

Wenn wir zur Website des Konsulagenten gehen, werden wir feststellen, dass unsere Anwendung fehlschlägt. Um dies zu beheben, sollte der Dienst "/ my-health-check" den Statuscode " HTTP 200 OK" zurückgeben .

5. Verteilte Konfiguration

Diese Funktion ermöglicht die Synchronisierung der Konfiguration zwischen allen Diensten . Der Konsul sucht nach Konfigurationsänderungen und löst dann die Aktualisierung aller Dienste aus.

Zuerst müssen wir die Abhängigkeit von Spring-Cloud-Starter-Consul-Config zu unserer pom.xml hinzufügen :

 org.springframework.cloud spring-cloud-starter-consul-config 1.3.0.RELEASE 

Wir müssen auch die Einstellungen des Anwendungsnamens von Consul und Spring aus der Datei application.yml in die Datei bootstrap.yml verschieben , die Spring zuerst lädt.

Dann müssen wir Spring Cloud Consul Config aktivieren:

spring: application: name: myApp cloud: consul: host: localhost port: 8500 config: enabled: true

Spring Cloud Consul Config will look for the properties in Consul at “/config/myApp”. So if we have a property called “my.prop”, we would need to create this property in the Consul agent site.

We can create the property by going to the “KEY/VALUE” section, then entering “/config/myApp/my/prop” in the “Create Key” form and “Hello World” as value. Finally, click the “Create” button.

Bear in mind that if we are using Spring profiles, we need to append the profiles next to the Spring application name. For example, if we are using the dev profile, the final path in Consul will be “/config/myApp,dev”.

Now, let's see what our controller with the injected properties looks like:

@RestController public class DistributedPropertiesController { @Value("${my.prop}") String value; @Autowired private MyProperties properties; @GetMapping("/getConfigFromValue") public String getConfigFromValue() { return value; } @GetMapping("/getConfigFromProperty") public String getConfigFromProperty() { return properties.getProp(); } }

And the MyProperties class:

@RefreshScope @Configuration @ConfigurationProperties("my") public class MyProperties { private String prop; // standard getter, setter }

If we run the application, the field value and properties have the same “Hello World” value from Consul.

5.1. Updating the Configuration

What about updating the configuration without restarting the Spring Boot application?

If we go back to the Consul agent site and we update the property “/config/myApp/my/prop” with another value like “New Hello World”, then the field value will not change and the field properties will have been updated to “New Hello World” as expected.

Dies liegt daran, dass die Feldeigenschaften eine MyProperties- Klasse mit der Annotation @RefreshScope sind . Alle mit der Annotation @RefreshScope kommentierten Beans werden nach Konfigurationsänderungen aktualisiert.

Im wirklichen Leben sollten wir die Eigenschaften nicht direkt in Consul haben, sondern sie irgendwo dauerhaft aufbewahren. Wir können dies mit einem Konfigurationsserver tun.

6. Fazit

In diesem Artikel erfahren Sie, wie Sie unsere Spring Boot-Anwendungen so einrichten, dass sie mit Consul für Service Discovery-Zwecke zusammenarbeiten, die Regeln für die Integritätsprüfung anpassen und eine verteilte Konfiguration freigeben.

Wir haben auch eine Reihe von Ansätzen für die Kunden eingeführt, um diese registrierten Dienste aufzurufen.

Wie üblich finden Sie Quellen auf GitHub.