Im zweiten Teil dieses Tutorials werden wir die Mitarbeiter-Suche inklusive weiterer Services erstellen und dann die Microservices mit Docker bereitstellen. Teil 1 des Tutorials finden Sie hier.

Erstellen des Mitarbeiter-Suchdienstes

Zu Beginn erstellen wir einen winzigen Microservice, der Mitarbeiter-Informationen basierend auf einer übergebenen ID zurückgibt. Dazu werden wir eine REST-API bereitstellen und diesen Microservice beim Eureka-Server registrieren, so dass andere Microservices ihn entsprechend finden und nutzen können.

Ich nutze den Eureka-Client von start.spring.io.

Werfen wir einen Blick auf die pom.xml Datei:

Pom XML File - Teil 2

Sehen wir uns die Bootstrap-Eigenschaten an:

Bootstrap-Eigenschaften - Teil 2

Ich verwende einen logischen Namen des Dienstes EmployeeSearch, unter dem alle Instanzen dieses Dienstes gemeinsam im Eureka-Server registiert werden. Außerdem vergebe ich die URL des Konfigurationsservers. Bitte beachten Sie, dass Sie für die Bereitstellung in Docker die Container IP des Config-Servers ändern müssen, um den Konfigurationsserver zu finden. Gleiches gilt für den Standort des Eureka-Servers. 

Erstellen Sie nun die Service-Datei für die Mitarbeiter-Suche:

Service-File - Teil 2

Die Controller-Datei sollte wie folgt aussehen:

Controller-File - Teil 2

Nun erstelle ich einige wenige Mitarbeiter und ordne sie der Rest URL zu. Die Spring Boot-Datei sieht wie folgt aus:

Spring Boot-Datei - Teil 2

Ich verwende den @EnableDiscoveryClient, um diesen Dienst als Eureka-Client zu registrieren. Wenn ich nun http://localhost:8080/employee/find/1 aufrufe, erhalte ich folgende Ausgabe: 

Mitarbeiterausgabe

Erstellen des Mitarbeiter-Dashboard-Service

Jetzt werde ich einen anderen Dienst erstellen, der den Employee Search Service verwendet, um Mitarbeiter-Informationen abzurufen. Dazu nutze ich einen Feign-Client und Hystrix als Sicherung, so dass selbst bei einem nicht aktiven Mitarbeiter-Suchdienst Standardwerte zurückgegeben werden können.

Pom.xml:

Pom XML File - Teil 2

Bootstrap-Eigenschaften:

Bootstrap-Properties - Teil 2

Feign-Client:

Feign Client - Teil 2

Controller:

Controller - Teil 2

Spring Boot-Starter-Service:

Spring Boot Starter Service - Teil 2

Jetzt ist es soweit: wenn ich die URL http://localhost:8081/dashboard /feign/1 aufrufe, erhalte ich folgende Antwort:

Aufruf Feign Client - Teil 2

Erstellen des Gateway-Services

pom.xml:

Pom-XML-File-Gateway-Service - Teil 2

Bootstrap-Eigenschaften:

Bootstrap-Properties-Gateway-Service - Teil 2

Durch die Eigenschaft zuul.routes.employeeUI.serviceId = EmployeeDashBoard weisen wir Zuul an, dass jede URL, die mit managerUI versehen ist, auf den EmployeeDashboard-Dienst umgeleitet wird.

Spring Boot-Datei:

Sprint Boot Gateway Service - Teil 2

Wenn wir jetzt den Service ausführen und http://localhost:8084/employeeUI/dashboard/feign/1 aufrufen, erhalten wir folgende Antwort:

Aufruf Gateway Service - Teil 2

Die Bereitstellung in Docker Containern

So, jetzt ist erst einmal Schluss mit dem Codieren. Mal sehen, wie unsere Anwendung läuft. Derzeit stehen alle Dienste bereit und laufen auf dem lokalen Rechner. Wir möchten jedoch nicht, dass unser Code nur in der lokalen Konfiguration ausgeführt wird, sondern dass er in der Produktion mit Bravour läuft. Wir lieben unseren Code und betrachten ihn wie ein kleines Kind, dem wir nur das Beste wünschen. Wenn wir unsere Kinder zur Schule schicken und ihnen den richtigen Weg zum Erfolg zeigen wollen, müssen wir sie auch durch unsere Anwendung leiten. Lassen Sie uns also einen Ausflug in die DevOps-Welt machen und versuchen, unserem Quellcode den richtigen Weg zu zeigen.

Willkommen in der Docker World

Docker braucht eigentlich keine Einführung. Wenn Sie der Meinung sind, dass Sie noch einen Leitfaden benötigen, können Sie sich hier https://docs.docker.com/get-started/ ansehen.

Ich gehe davon aus, dass Docker CE auf Ihrem Computer installiert ist. Die Konzepte, die wir hier für die Bereitstellung verwenden, lauten wie folgt:

  1. Docker-File: Dies ist ein Textdokument, das alle Anweisungen zum Erstellen eines Docker-Images enthält. Mit dem Befehlssatz einer Docker-Datei können wir Schritte festlegen, die Dateien kopieren, Installationen durchführen usw. Weitere Referenzen finden Sie unter https://docs.docker.com/engine/reference/builder/.
  2. Docker-Compose: Dies ist ein Werkzeug, das mehrere Container erstellen kann. Es hilft, die erforderliche Umgebung mit einem einzigen Befehl zu erstellen.

Wie im Microservice-Architekturdiagramm gezeigt, erstellen wir für jeden Service einen eigenen Container. In unserem Beispiel ist dies die Liste der Container:

  1. Konfigurationsserver
  2. EmployeeService
  3. Mitarbeiter Board Service
  4. Mitarbeiter Dashboard Service
  5. Gateway-Service

Docker-Konfiguration für den Konfigurationsserver

Der Container sollte die JAR-Datei des Konfigurationsservers enthalten. Hier wählen wir die jar-Datei vom lokalen Rechner aus. In einem realen Szenario sollten wir die jar-Datei an ein Artifact-Repository-Manager-System wie Nexus oder Artifactory weiterleiten und der Container sollte die Datei vom Repo-Manager herunterladen.

Der Konfigurationsserver sollte am Port 8888 entsprechend der Bootstrap Eigenschaften verfügbar sein.

Wie oben bereits erwähnt, lassen wir den Konfigurationsserver die Konfiguration von einem Speicherort lesen, so dass wir sicherstellen, dass die Eigenschaftsdateien auch dann abgerufen werden können, wenn der Container ausfällt.

Erstellen Sie nun einen Ordner namens config-repo, der die erforderliche Eigenschaftsdatei enthält. Wir werden Folgendes für den Container Config-Server sicherstellen:

Config-Repo - Teil 2

Im übergeordneten Ordner erstellen wir eine Docker-Datei namens Dockerfile. Diese Dockerfile erstellt unser Image, welches Java enthält.

Dockerfile - Teil 2

Platzieren Sie folgenden Inhalt:

Content Dockerfile - Teil 2

FROM: Dieses Schlüsselwort weist Docker an, ein bestimmtes Bild mit seinem Tag als build-base zu verwenden.

MAINTAINER: Ein MAINTAINER ist der Autor eines Images.

RUN: Dieser Befehl installiert openjdk8 im System.

Führen Sie den folgenden Befehl aus, um das Basis-Docker-Image zu erstellen:

docker build --tag=alpine-jdk:base --rm=true .

Nachdem das Basisimage erfolgreich erstellt wurde, ist es an der Zeit, das Docker-Image für den Konfigurationsserver zu erstellen.

Erstellen Sie einen Ordner namens files und legen Sie die jar-Datei des Konfigurationsservers in das Verzeichnis. Erstellen Sie dann eine Datei namens Dockerfile-configserver mit dem folgenden Inhalt:

Dockerfile Configserver - Teil 2

Hier haben wir festgelegt, dass aus ein Image aus dem zuvor erstellten Alpine-Jdk-Image erstellt wird. Wir werden die jar-Datei mit dem Namen employeenconfigserver.jar in den Speicherort /opt/lib und das config-repo in das Verzeichnis /root kopieren. Sobald der Container gestartet wird, wollen wir auch deb Konfigurationsserver starten, daher sind ENTRYPOINT und CMD so eingestellt, dass sie den entsprechenden Java-Befehl ausführen. Da wir eine Möglichkeit benötigen, um die Konfigurationsdateien von außerhalb des Containers zu teilen, nutzen wir den Volume-Befehl. Und da der Konfigurationsserver für die Außenwelt über den Port 9090 erreichbar sein sollte, nutzen wir EXPOSE 9090.

Lassen Sie uns nun das Docker-Image erstellen und als config-server markieren:

Docker-Image-erstellen - Teil 2

Und das Docker-Volume:

Docker Volume - Teil 2

Puh! Sobald wir den obigen Befehl ausführen, sollten wir in der Lage sein, einen Docker-Container zu sehen und auszuführen. Durch den Aufruf http://localhost:9090/config/default / sollten wir auch auf die Eigenschaften zugreifen können.

Eureka-Server

In ähnlicher Weise müssen wir eine Docker-Datei für Eureka-Server erstellen, die auf Port 9091 läuft. Das Dockerfile für den Eureka-Server sollte wie folgt aussehen:

Dockerfile Eureka-Server - Teil 2

Verwenden Sie diesen Befehl, um das Image zu erstellen:

Image Dockerfile Eureka-Server - Teil 2

Microservices

Jetzt stellen Sie unsere aktuellen Microservices bereit. Die Schritte sollten ähnlich sein; das einzige, was wir uns merken müssen ist, dass unsere Microservices vom Config-Server und Eureka-Server abhängen. Daher müssen wir sicherstellen, dass die beide Server betriebsbereit sind, bevor wir mit unsere Microservices starten. Da es Abhängigkeiten zwischen Containern gibt, sollten wir uns Docker-Compose etwas genauer anschauen. So stellen wir sicher, dass die Container in einer bestimmten Reihenfolge erzeugt werden.

Um das zu tun, sollten wir eine Docker-File für den Rest der Container schreiben. So sieht das entsprechende Docker-File aus:

Dockerfile weitere Container - Teil 2

Ein kleiner Hinweis: Die beiden Shell-Skripts für den Mitarbeiter-Suchdienst und den Mitarbeiter-Dashboard-Dienst, die ich hier erstellt habe, weisen Docker-Compose an, die Dienste erst dann zu starten, nachdem der Konfigurationsserver und der Eureka-Server gestartet wurden.

Warten auf den Config-Server - Teil 2

Nun erstellen wir noch zügig eine Datei namens docker-compose.yml, die all diese Docker-Dateien verwendet, um unsere benötigten Umgebungen zu erstellen. Sie stellt auch sicher, dass die erforderlichen Container die korrekte Reihenfolge beibehalten und miteinander verknüpfen.

Docker Compose YML - Teil 2

In der Docker-Compose-Datei finden Sie einige wichtige Einträge:

Version: Ein Pflichtfeld, in dem wir die Version des Docker-Compose-Formats pflegen müssen.

Services: Jeder Eintrag definiert den Container, den wir erzeugen müssen.

Build: Wenn erwähnt, sollte Docker-Compose ein Image aus der angegebenen Docker-Datei erstellen.

Image: Der Name des Images, das erstellt wird.

Netzwerk: Der Name des zu verwendenden Netzwerks. Dieser Name sollte im Bereich Netzwerke vorhanden sein.

Links: Dadurch wird eine interne Verbindung zwischen dem Dienst und dem erwähnten Dienst hergestellt. Hier muss der EmployeeSearch-Dienst auf den Config- und Eureka-Server zugreifen.

Depends: Dies wird benötigt, um die Reihenfolge zu erhalten. Der EmployeeSearch-Container hängt vom Eureka- und Konfigurationsserver ab. Daher stellt Docker sicher, dass die Container Eureka- und Config-Server erzeugt werden, bevor der EmployeeSearch-Container erzeugt wird.

Nach dem Erstellen der Datei, sollten wir unsere Images und die erforderlichen Container erstellen. Dies können wir mit einem einzigen Befehl bewerkstelligen:

docker-compose up --build 

Die komplette Umgebung können wir mit folgendem Befehl stoppen:

docker-compose down 

Die vollständige Dokumentation zu Docker-Compose finden Sie unter https://docs.docker.com/compose/.

Festzuhalten bleibt, dass das Schreiben der Docker-Datei und der Docker-Compose-Datei einmalige Aktivitäten sind, die Sie aber in die Lage versetzt, jederzeit bei Bedarf eine vollständige Umgebung zu erstellen.

Fazit

Dies ist die vollständige Anleitung zum Erstellen verschiedener Komponenten in Microservices und zum Bereitstellen in Docker. In der Produktion sollte CI /CD beteiligt sein, so dass Sie nicht alle Docker-Befehle zum Erstellen von Images kennen müssen. Aus meiner Sicht macht es als Full Stack Entwickler aber durchaus Sinn zu wissen, wie Sie ein Image in Docker erzeugen und bereitstellen können.

 

Hinweise:
Der Beitrag von Shamik Mitra ist im Original unter https://dzone.com/articles/buiding-microservice-using-spring-boot-and-docker?fromrel=true erschienen. Dort finden Sie auch die verschiedenen Code-Schnipsel als Kopiervorlage.
Mit Zustimmung von Shamik Mitra übersetzen wir verschiedene Beiträge von ihm hier in unserem Blog vom Englischen ins Deutsche.

Gefällt Ihnen dieser Beitrag?

Gefällt Ihnen dieser Beitrag?

Melden Sie sich für unsere News-Updates an und erhalten Sie regelmäßig Tipps von bekannten Autoren direkt in Ihren Posteingang.

Sie haben sich für unsere News-Updates angemeldet. In kürze Erhalten Sie eine E-Mail mit einem Bestätigungslink. Erst wenn Sie darauf geklickt haben, werden wir Ihnen regelmäßig unsere Updates in Ihren Posteingang senden.

Share This