Scalabilty, Composability und Resilience sind wesentliche Anforderungen an verteilte Systeme (Distribution Systems) und damit auch an eine Microservices Architecture.
Die Scalability und damit die Skalierung erfolgen horizontal (in Cloud-Umgebungen, in denen Microservices leben, haben wir es ausschließlich mit horizontaler Skalierung zu tun). Mit zunehmender Last werden zusätzliche Server und Container hochgefahren und neue Microservices-Instanzen bereitgestellt. Bei Lastabfall werden sie wieder heruntergefahren. Die Microservices-Instanzen haben somit keinen festen Ort, wie das bei der vertikalen Skalierung der Fall wäre. Der Ort, also die Adresse der Microservices, ist somit nicht bekannt. Es besteht die Forderung nach Ortstransparenz für den Client, der auf den Microservice zugreifen möchte.
Um der Anforderung der Composability, also der Kombinierbarkeit von Microservices zu einer Anwendung, gerecht zu werden, müssen Microservices in verteilten Systemen eindeutig identifizierbar sein. Weitere Services müssen die benötigten Microservices finden und anschließend verwenden können.
Eine weitere, wichtige Anforderung ist die Resilience, also die Fehlertoleranz in verteilten Systemen. Fallen Microservices aus oder können sie die geforderte Performance nicht mehr bereitstellen, darf nicht das gesamte verteilte System zusammenbrechen. Der Microservices-Client darf nicht wesentlich von den Fehlern beeinträchtigt werden.
Bei der Umsetzung der genannten Anforderungen helfen uns die Distribution-Patterns, die im Folgenden beschrieben werden.
5.1 Service Registry
Problem
Microservices-Architekturen stellen verteilte Systeme dar. Eine zentrale Anforderung in verteilten Systemen ist die Ortstransparenz. Ortstransparenz bedeutet, dass ein Microservices-Client nichts über den physikalischen Ort (Host, Adresse, Port) des Microservice wissen muss, den er verwenden möchte. Wie können wir den physikalischen Ort eines Microservice ermitteln und dem Microservices-Client bereitstellen?
Lösung
Die Lösung ist das Service-Registry-Pattern. Es stellt eine zentrale Instanz, die Service Registry bereit, die alle Microservices kennt und einem Microservices-Client auf Anfrage eine Microservices-Instanz bereitstellen kann (dies ist die Instanziierung eines Microservice). Die Service Registry ist ein Single Point of Failure, das heißt, fällt die Service Registry aus, dann können keine Microservices mehr bereitgestellt werden. Es ist daher darauf zu achten, dass die Service Registry ausfallsicher aufgesetzt wird. In aller Regel werden mehrere Instanzen einer Service Registry betrieben, um die Verfügbarkeit zu erhöhen. Dazu müssen die Service-Registry-Instanzen untereinander kommunizieren.
Beispiel
Eine Implementierung des Service-Registry-Patterns stellt Netflix mit Eureka [1] bereit. Eureka wird über das Projekt Spring Cloud Netflix [2] in Spring Cloud integriert. Durch das Einbinden der Dependency spring-cloud-starter-eureka-server kann Eureka in einer Spring-Boot-Anwendung verwendet werden.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>Listing 5.1 Dependency für Eureka in der „pom.xml“
Dazu ist lediglich die Spring-Boot-Anwendung mit der Annotation @EnableEurekaServer zu deklarieren. Das Autoconfiguration-Feature von Spring Boot sorgt dafür, dass die für die Service Registry benötigten Spring Beans im Hintergrund automatisch erzeugt werden.
@SpringBootApplication
@EnableEurekaServer
public class RegistryServiceApplication {
public static void main(String[] args) {
SpringApplication.run(RegistryService.class, args);
}}Listing 5.2: Eureka-Annotationen in der Spring-Boot-Anwendung
Die Konfiguration von Eureka erfolgt wie gewohnt über die Property Files von Spring Boot. Dazu stellt Spring Cloud Netflix eine Menge von Properties bereit. Die Konfiguration kann in drei Bereiche unterteilt werden (Tabelle 5.1).
|
Bereich |
Property-Präfix |
Configuration Bean |
|
Eureka-Instanz |
eureka.instance.* |
EurekaInstanceConfigBean |
|
Eureka-Client |
eureka.client.* |
EurekaClientConfigBean |
|
Eureka-Server |
eureka.server.* |
EurekaServerConfigBean |
Tabelle 5.1: Überblick über Eureka Properties für die Konfiguration
Es existiert keine Dokumentation der Properties. Daher empfehlen wir den Blick in die Configuration Beans, in denen alle Properties deklariert und definiert sind. Die Namen der Properties sind zum Teil selbstsprechend, gegebenenfalls kann weiter recherchiert werden. Die Configuration Beans sind im Spring-Cloud-Netflix-Projekt [3] zu finden.
Die Konfiguration application.yml zeigt zwei einfache Einträge (Konfigurationen können im Property oder YAML-Format vorliegen; die Beispiele zeigen die Konfigurationen im YAML-Format): Über das uns bereits bekannte Spring Boot Property port legen wir fest, unter welchem Port die Service Registry erreichbar ist. Durch den Eintrag waitTimeInMsWhenSyncEmpty wird die Synchronisationszeit zwischen Service Registry und den registrierten Microservices auf 0s gestellt, damit direkt nach dem Starten die Tests durchgeführt werden können.
# application.yml
server:
port: 8761
eureka:
client:
registerWithEureka: false
fetchRegistry: false
server:
waitTimeInMsWhenSyncEmpty: 0 Listing 5.3: Service-Registry-Eureka-Konfiguration
Grundsätzlich sollten mehrere Service Registries betrieben werden. Das erfordert, dass sich jede Service Registry selbst wieder bei einer entfernten Service Registry registriert. In unserem Beispiel wird die Service Registry standalone betrieben. Dies erreichen wir über die Konfigurationseinträge registerWithEureka, fetchRegistry. Im Produktivbetrieb kann die Konfiguration umfangreicher ausfallen und muss auf den Anwendungsfall optimal abgestimmt werden.
5.2 Self Registration
Problem
In Kapitel 5.1 haben wir die Ortstransparenz in verteilten Systemen und die damit verbundene Notwendigkeit einer Service Registry beschrieben. In diesem Zusammenhang stellt sich nun die Frage: Wie kann sich ein Microservice, der von einem Microservices-Client gefunden werden möchte, bei einer Service Registry anmelden?
Lösung
Die Lösung ist das Self-Registration-Pattern. Der Microservice meldet sich beim Start an einer ihm bekannten Service Registry an. Bei einem Shutdown oder Crash meldet sich die Microservices-Instanz wieder ab. Während die Microservices-Instanz existiert, sendet sie regelmäßig Lebenszeichen (Heartbeats). Sendet der Microservice keine Lebenszeichen mehr, wird er automatisch abgemeldet.
Beispiel
Wie in Kapitel 5.1 beschrieben, wird auch für das Self-Registration-Pattern eine Implementierung von Netflix Eureka über Spring Cloud Netflix bereitgestellt, die durch das einfache Einbinden der Starter-POM zur Verfügung steht.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>Listing 5.4: Dependency für Eureka in der „pom.xml“
Durch die Annotation @EnableEurekaClient wird die Spring-Boot-Anwendung, die unseren Microservice repräsentiert, automatisch an der Service Registry angemeldet.
@SpringBootApplication
@EnableEurekaClient
public class CarRepairApplication {
public static void main(String[] args) {
SpringApplication.run(CarRepairApplication.class, args);
}
}Listing 5.5: Eureka-Client-Annotationen in der Spring-Boot-Anwendung
Jeder Microservice benötigt einen eindeutigen Namen, mit dem er sich bei der Service Registry anmeldet und unter dem er von anderen Microservices-Clients in der Service Registry gefunden werden kann. Dieser Name wird über das Spring Boot Property, das den Anwendungsnamen festlegt, konfiguriert. In unserem Fall ist es der Name car-repair-service.
# bootstrap.yml
spring:
application:
name: car-repair-serviceListing 5.6: Eureka-Client-Bootstrap-Konfiguration
Die Konfiguration erfolgt dabei nicht wie gewohnt in der application.yml, sondern in der bootstrap.yml. Auf die Konfigurationsdatei wird in Kapitel 5.7 noch einmal genauer eingegangen.
Die weitere Konfiguration des Microservices erfolgt wie gewohnt in der Konfigurationsdatei application.yml. Entscheidend sind dabei die Properties unter dem Präfix eureka.client.* (Tabelle 5.1).
# application.xml
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka/Listing 5.7: Eureka-Client-Application-Konfiguration
Über das Property serviceUrl wird definiert, welche Service Registries vorhanden und unter welcher Adresse sie zu erreichen sind. Im Fall eines Service Registry Clusterings können das durchaus mehrere sein. Die möglichen Cluster können über die Konfiguration availabilityZones definiert werden.
In dem gezeigten Beispiel wird kein Service Registry Clustering verwendet. In diesem Fall sucht der Microservice nach einem festen Clusternamen defaultZone und verwendet diesen URI für den Zugriff auf die Service Registry.
Während über die Properties...

