© DrHitch/Shutterstock.com
Microservices-Architektur

3 Deployment-Patterns


Microservices werden in Cloud-Umgebungen deployt. Clouds erfüllen mit ihren Eigenschaften Time-to-Market, Pay-as-you-use und Scalability, um nur einige zu nennen, die Anforderungen, die an Microservices Architectures gestellt werden. Daher sind Clouds die optimale Laufzeitumgebung für Microservices. Wie erreichen wir die in Tabelle 1.2 genannten Vorteile wie Easy to deploy, Replaceability und Scalability in der Cloud?

Dazu müssen Entwicklung und Betrieb in der Cloud optimal aufeinander abgestimmt werden. Genau das ist das Ziel von DevOps. DevOps ist nur mit den Methoden aus Continuous Delivery (CD) möglich, die Anforderungen stellen, die bei der Entwicklung von Microservices berücksichtigt werden müssen.

In Kapitel 1.1 werden Regeln beschrieben, die bei der Entwicklung von Microservices in der Cloud unter DevOps einzuhalten sind, um ein optimales Ergebnis zu erreichen. Kapitel 3 greift nun genau die Twelve Factors auf und stellt sie als Patterns vor.

Wir werden sehen, dass einige Patterns auch bei monolithischen Applikationen angewendet werden können (z. B. Config in Environment) oder dort bereits weit verbreitet sind (z. B. One Codebase, Dependency Declaration). Trotzdem müssen sie bei der Entwicklung von Microservices in der Cloud explizit erwähnt werden, da sie dort absolut essenziell sind.

3.1 One Codebase

Problem

Bei der Entwicklung monolithischer Applikationen entsteht oft sehr viel Sourcecode. Dementsprechend komplex werden die Wartung und Erweiterung des bestehenden Codes. Änderungen können zu unerwünschten Seiteneffekten führen, sodass schlimmstenfalls die gesamte Applikation nicht mehr lauffähig ist. Deshalb muss es jederzeit möglich sein, einen historischen Stand der Applikation wiederherzustellen.

Gleichzeitig muss der Microservice in verschiedene Umgebungen deployt werden. Jede Umgebung unterscheidet sich in ihrer Konfiguration. Daher müssen die entsprechenden applikationsspezifischen Konfigurationseinstellungen irgendwo gespeichert werden.

Schließlich müssen mehrere Stände parallel verwaltet werden können, da in verschiedenen Umgebungen verschiedene Versionen der Applikation existieren können. Diese Problematik gilt für alle Arten von Architekturen.

Lösung

Durch die Ablage in einem Sourcecode Repository wie Git ist es möglich, verschiedene Versionsstände eines Microservice zu rekonstruieren. Damit kann das Deployment unterschiedlicher Versionen im Rahmen einer Continuous Delivery Pipeline auch in viele Umgebungen automatisiert werden.

Hierbei ist es wichtig, dass applikationsspezifische Konfigurationen nicht mit dem Microservice im gleichen Repository abgelegt werden. Für das Deployment in eine neue Umgebung darf es nicht erforderlich sein, dass neue Konfigurationen in der Codebase des Microservice einzutragen sind. Die gleiche Codebase muss in alle Umgebungen deploybar sein.

Zusätzlich ist es empfehlenswert, dass mehrere Microservices, die die Funktionalität einer Applikation abbilden, auch komplett getrennt im Repository abgelegt werden. Änderungen, die in der Implementierung eines Microservice vorgenommen werden, können so nicht auf andere Applikationsteile durchschlagen.

Sollte es erforderlich sein, dass sich mehrere Microservices den gleichen Code teilen, so ist dieser als ein eigenständiges Projekt herauszulösen, das separat versioniert werden kann. Dadurch wird der Grad der Abhängigkeit minimiert.

Siehe auch: Kapitel 3.3 „Config in Environment“

Beispiel

Auf unser Beispiel angewendet bedeutet dies, dass jeder Microservice in einem separaten Repository abgelegt wird. Alle Microservices werden als eigenständige Applikationen betrachtet und entwickelt:

  • appointment-service
  • car-repair-service
  • data-collection-service
  • maintenance-service
  • master-data-service

Um das Beispiel besser nachvollziehen zu können, liegen alle Microservices in einem Repository, werden aber separat gebaut. In einem echten Projekt sollten die Microservices auch in getrennten Repositories verwaltet werden.

3.2 Dependency Declaration

Problem

Jede Applikation hat eine Vielzahl von Abhängigkeiten. Diese Abhängigkeiten ergeben sich einerseits direkt auf Codeebene durch eingesetzte Third-Party-Bibliotheken. Das Rad soll nicht jedes Mal neu erfunden werden, wenn es schon ein anderer getan hat. Andererseits kommt die Abhängigkeit auf der Ebene der Laufzeitumgebung hinzu. Dies kann durch die eingesetzte Programmiersprache, zum Beispiel Java, bedingt sein oder durch die Software der benötigten Infrastruktur wie Webserver oder Datenbank.

Bereits für monolithische Applikationen ist es wichtig, die Abhängigkeiten auf Codeebene automatisiert zu verwalten, um so jederzeit einen bestimmten Stand der Anwendung herstellen zu können. In hohem Maße gilt dies auch für das Deployment von Microservices in Cloud-Umgebungen. Hier kommen aber außerdem die Abhängigkeiten der Anwendung zur Laufzeitumgebung hinzu. Auch diese müssen automatisiert auflösbar sein. Warum?

Möchte man einen Microservice aufgrund besonderer Lastanforderungen auf vielen Knoten deployen, wäre es sehr aufwändig, wenn man zum Beispiel auf jedem Knoten manuell eine neue Laufzeitumgebung mit Application Server in einer bestimmten Konfiguration installieren müsste.

Lösung

Maven oder Gradle sind bereits Standard beim Schreiben von Spring-Applikationen und sollten auch bei der Entwicklung von Microservices zum Einsatz kommen. Spring bietet hier durch das Konzept der Starter POMs sehr gute Unterstützung: Durch die Angabe eines <parent> in der pom.xml eines Microservice sagen wir, welche Spring-Version wir verwenden wollen. Im Abschnitt <dependencies> geben wir an, welche Spring-Features wir benötigen.

Für einen Microservice werden wir in den allermeisten Fällen auf die spring-boot-starter-web Dependency zurückgreifen. Diese bietet uns alles für eine Full-Stack-Webentwicklung mit einem integrierten Tomcat. Das heißt, unser Microservice bringt bereits einen Webserver mit und kann direkt mit der Java Runtime gestartet werden. Ein Deployment in einen vorhandenen Server ist nicht erforderlich.

Ist trotzdem eine bestimmte Systemkonfiguration in der Zielumgebung erforderlich, können uns hier Tools wie Chef [1], Puppet [2] und Ansible [3] unterstützen.

Beispiel

Unter dem URL http://start.spring.io können wir uns interaktiv eine entsprechende Maven- oder Gradle-Projektkonfiguration erstellen lassen. Die pom.xml enthält dann die gewünschte Spring-Version im <parent>-Element und die gewünschten Starter-POMs unter <dependencies>.

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.1.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

Listing 3.1: Auszug aus der Maven „pom.xml“ des Microservice

Beim Deployen auf Cloud Foundry kommt noch eine weitere Datei hinzu, in der wir Abhängigkeiten deklarieren müssen, die manifest.yml. Hier wird unter anderem eingetragen, welches Buildpack, das heißt, welche Laufzeitumgebung der Programmiersprache, und welche Backing Services (Kapitel 3.4) wir benötigen. Die Deklaration des Java-Buildpacks ist optional.

--- 
applications:
- name: maintenance-service
memory: 256M
instances: 1
host: msgxt_spring
domain: cfapps.io
path: target/maintenance-service-1.0.0.jar
buildpack: https://github.com/cloudfoundry/java-buildpack
services:
- springmvc-hibernate-db
- springmvc-hibernate-redis

Listing 3.2: „manifest.yml“ des Microservice für Deployment in Cloud Foundry

3.3 Config in Environment

Problem

Jede Anwendung benötigt diverse Einstellungen, die von außen konfigurierbar sein müssen, weil sie sich in den verschiedenen Umgebungen (Entwicklung, Abnahmetest, Produktion etc.) unterscheiden. Zu diesen Einstellungen gehören unter anderem:

  • Deklarationen für Datenbank, Speichersysteme oder andere Ressourcen inklusive Credentials
  • Anbindung an Drittsysteme wie Mainframe, SAP etc.
  • Deploy-Einstellungen wie der aktuelle Hostname oder Port

In einer Microservices-Architektur, in der eine Anwendung aus vielen separat deploybaren Einheiten besteht, die auf vielen Knoten verteilt werden können, entsteht ein nicht zu unterschätzender Konfigurationsaufwand. Einerseits durch die bloße Menge der Microservices und die Anzahl der Umgebungen. Andererseits ist hier eine besonders hohe Flexibilität gefragt, da neue Umgebungen dynamisch hinzukommen können oder Backend-Ressourcen zur Laufzeit dynamisch ausgetauscht werden müssen – ein Beispiel könnte der Austausch eines vorhandenen Datenbanksystems durch ein leistungsstärkeres sein.

Die Verwaltung der Konfigurationseinstellungen im Applikationscode ist problematisch, da sie zu unflexibel und fehleranfällig ist.

Lösung

Die Konfiguration erfolgt vollständig über das Environment. Die Microservices sollten selbst keine Konfigurationseinstellungen im Code oder im Repository für die Umgebungen verwalten. Ebenso sollte eine Gruppierung von Environments vermieden werden. So mag zu Beginn eines Projekts die Unterteilung in Entwicklung, Test und Produktion ausreichen. Später wird es wahrscheinlich noch weitere Testumgebungen wie Qualitätssicherung, Lasttest oder für einen bestimmten Feature Branch geben. Für das Aufsetzen weiterer Umgebungen sollten keine Codeänderungen erforderlich sein.

Beispiel

Spring bietet reichlich Unterstützung für die flexible Konfiguration eines Microservice aus dem Environment, die sehr gut in der Spring-Boot-Dokumentation unter Externalized Configuration [4]> beschrieben wird. Hier einige Beispiele:

@Value: Mit der @Value-Annotation ist es möglich, sich einzelne Werte aus dem Environment direkt in eine Bean injizieren zu lassen. Hier ein Beispiel:

@Value("#{systemProperties.databaseName}")
public void setDatabaseName(String dbName) { ... }

Listing 3.3: „@Value“-Annotation zum Injizieren von Werten aus dem Evironment

Interface EnvironmentAware: Implementiert eine Bean das Interface Environment Aware, so kann es sich in der Methode setEnvironment, die automatisch zur Laufzeit aufgerufen wird, aktuelle Einstellungen aus dem Environment geben lassen.

@Component
class MyBean implements EnvironmentAware {
private String instanceId;
@Override
public void setEnvironmen...

headline from sands settings