JHipster mit einer Microservice-Architektur

1. Einleitung

In diesem Artikel werden wir ein interessantes Beispiel mit JHipster untersuchen - den Aufbau einer einfachen Microservices-Architektur. Wir werden zeigen, wie alle erforderlichen Teile erstellt und bereitgestellt werden, und am Ende wird eine vollständige Microservice-Anwendung zum Laufen gebracht.

Wenn Sie JHipster noch nicht kennen, lesen Sie bitte unseren Einführungsartikel, bevor Sie mit den Grundlagen dieses Tools zur Projekterstellung fortfahren.

2. Monolithic vs. Microservice

In unserem ersten Artikel haben wir gezeigt, wie eine monolithische Anwendung erstellt und gebootet wird, die relativ einfach zu warten ist.

Unser Microservice-System hingegen trennt das Front-End vom Back-End, das wiederum auch in mehrere kleine Anwendungen aufgeteilt werden kann, die jeweils eine Teilmenge der gesamten Anwendungsdomäne behandeln. Wie bei allen Microservice-Implementierungen löst dies natürlich einige Probleme, führt jedoch auch zu einer gewissen Komplexität, z. B. bei der Registrierung und Sicherheit von Komponenten.

JHipster wird sich mit Hilfe moderner Open-Source-Tools wie Eureka Server von Netflix und Consul von Hashicorp um die meisten Schwierigkeiten bei der Verwaltung der Microservice-Anwendungen kümmern.

Natürlich sind hier einige Dinge zu beachten, z. B. wie groß oder kompliziert unsere Domain ist, wie kritisch unsere Anwendung ist und welche Verfügbarkeitsstufen wir benötigen, um unsere Dienste auf verschiedenen Servern und Standorten zu hosten usw. Das Ziel dieser Tools ist natürlich, dass diese Permutationen möglich und einfach zu verwalten sind.

2.1. JHipster Microservice-Komponenten

Wenn Sie mit JHipster an einer Microservice-Architektur arbeiten, müssen Sie mindestens drei verschiedene Projekte erstellen und bereitstellen: eine JHipster-Registrierung, ein Microservice-Gateway und mindestens eine Microservice-Anwendung.

Die JHipster-Registrierung ist ein wesentlicher Bestandteil der Microservice-Architektur. Es verbindet alle anderen Komponenten miteinander und ermöglicht ihnen die Kommunikation miteinander.

Die Microservice-Anwendung enthält den Back-End-Code. Nach dem Ausführen wird die API für die betreffende Domäne verfügbar gemacht. Eine Microservice-Architektur kann aus vielen Microservice-Anwendungen bestehen, die jeweils einige verwandte Entitäten und Geschäftsregeln enthalten.

Das Microservice Gateway verfügt über den gesamten Front-End-Code (Angular) und verwendet die API, die von der gesamten Gruppe von Micro-Service-Anwendungen erstellt wurde:

3. Installation

Alle Details zum Installationsprozess finden Sie in unserem Einführungsartikel zu JHipster.

4. Erstellen eines Microservice-Projekts

Lassen Sie uns nun die drei Kernkomponenten unseres Microservice-Projekts installieren.

4.1. Installieren der JHipster-Registrierung

Da die JHipster-Registrierung ein Standard-JHipster ist, müssen wir sie nur herunterladen und ausführen. Es ist nicht erforderlich, es zu ändern:

git clone //github.com/jhipster/jhipster-registry cd jhipster-registry && ./mvnw

Dadurch wird das Jhipster- Registrierungsprojekt von GitHub geklont und die Anwendung gestartet. Nach dem erfolgreichen Start können wir // localhost: 8761 / besuchen und uns mit dem Benutzer admin und dem Passwort admin anmelden :

4.2. Installieren einer Microservice-Anwendung

Hier beginnen wir mit dem Aufbau der eigentlichen Funktionen unseres Projekts. In diesem Beispiel erstellen wir eine einfache Microservice-Anwendung, die Autos verwaltet. Zuerst erstellen wir die Anwendung und fügen dann eine Entität hinzu:

# create a directory for the app and cd to it mkdir car-app && cd car-app # run the jhipster wizard yo jhipster

Befolgen Sie nach dem Start des Assistenten die Anweisungen zum Erstellen einer Microservice-Anwendung mit dem Namen carapp . Einige andere relevante Parameter sind:

  • Port: 8081
  • Paket: com.car.app
  • Authentifizierung: JWT
  • Serviceerkennung: JHipster Registry

Der folgende Screenshot zeigt die vollständigen Optionen:

Jetzt werden wir eine hinzufügen Auto Einheit unserer Anwendung:

# runs entity creation wizard yo jhipster:entity car

Der Assistent zum Erstellen von Entitäten wird gestartet. Wir sollten den Anweisungen folgen, um eine Entität mit dem Namen Auto mit drei Feldern zu erstellen : Marke , Modell und Preis.

Sobald dies abgeschlossen ist, ist unsere erste Microservice-Anwendung abgeschlossen. Wenn wir uns den generierten Code ansehen, werden wir feststellen, dass es kein Javascript, HTML, CSS oder Front-End-Code gibt. Diese werden alle erstellt, sobald das Microservice Gateway erstellt wurde. Überprüfen Sie auch die README-Datei auf wichtige Informationen zum Projekt und nützliche Befehle.

Lassen Sie uns zum Abschluss unsere neu erstellte Komponente ausführen:

./mvnw

Bevor Sie den obigen Befehl ausführen , sollten Sie sicherstellen, dass die Jhipster-Registrierungskomponente aktiv ist. Andernfalls erhalten wir eine Fehlermeldung.

Wenn alles nach Plan lief, würde unsere Auto-App starten und das Jhipster-Registrierungsprotokoll zeigt an, dass die App erfolgreich registriert wurde:

Registered instance CARAPP/carapp:746e7525dffa737747dcdcee55ab43f8 with status UP (replication=true)

4.3. Installieren eines Microservice-Gateways

Nun das Frontend-Bit. Wir erstellen ein Microservice Gateway und geben ihm an, dass wir eine Entität für eine vorhandene Komponente haben, für die wir den Front-End-Code erstellen möchten:

# Create a directory for our gateway app mkdir gateway-app && cd gateway-app # Runs the JHipster wizard yo jhipster

Befolgen Sie die Anweisungen zum Erstellen einer Anwendung vom Typ Microservice Gateway. Wir werden den Namen der Anwendung Gateway , und wählen Sie die folgenden Optionen für die anderen Parameter:

  • Port: 8080
  • Paket: com.gateway
  • auth: JWT
  • Serviceerkennung: JHipster Registry

Hier ist eine Zusammenfassung des gesamten Parametersatzes:

Fahren wir mit der Erstellung von Entitäten fort:

# Runs entity creation wizard yo jhipster:entity car

Wenn Sie gefragt werden, ob wir aus einem vorhandenen Microservice generieren möchten, wählen Sie Ja und geben Sie den relativen Pfad zum Stammverzeichnis der car-app ein (Beispiel: ../car-app). Wenn Sie gefragt werden, ob die Entität aktualisiert werden soll, wählen Sie " Ja" und "Entität neu generieren" .

JHipster findet die Car.json- Datei, die Teil der vorhandenen Microservice-Anwendung ist, die wir zuvor erstellt haben, und verwendet die in dieser Datei enthaltenen Metadaten, um den gesamten erforderlichen UI-Code für diese Entität zu erstellen:

Found the .jhipster/Car.json configuration file, entity can be automatically generated!

Zeit, die Gateway-App auszuführen und zu testen, ob alles funktioniert:

# Starts up the gateway-app component ./mvnw

Navigieren wir nun zu // localhost: 8080 / und melden uns mit dem Benutzer admin und dem Passwort admin an . Im oberen Menü sollte ein Element Auto angezeigt werden, das uns zur Seite mit der Fahrzeugliste führt. Alles gut!

4.4. Erstellen einer zweiten Microservice-Anwendung

Als nächstes gehen wir noch einen Schritt weiter und erstellen eine zweite Komponente vom Typ Microservice Application . Diese neue Komponente wird Autohändler verwalten, daher werden wir eine Entität hinzufügen, die als Händler bezeichnet wird.

Lassen Sie uns ein neues Verzeichnis erstellen, dorthin navigieren und den Befehl yo jhipster ausführen :

mkdir dealer-app && cd dealer-app yo jhipster

Danach geben wir Dealerapp als Anwendungsnamen ein und wählen Port 8082 für die Ausführung aus (es ist wichtig, dass dies ein anderer Port ist als der, den wir für die Jhipster- Registrierung und die Auto-App verwenden ).

Für die anderen Parameter können wir eine beliebige Option auswählen. Denken Sie daran, dass dies ein separater Microservice ist, damit andere Datenbanktypen, Cache-Strategien und Tests als die Car-App- Komponente verwendet werden können.

Fügen wir unserer Händlerentität einige Felder hinzu . Zum Beispiel Name und Adresse:

# Runs the create entity wizard yo jhipster:entity dealer

Wir sollten nicht vergessen, zur Gateway-App zu navigieren und sie anzuweisen, den Front-End-Code für die Händlerentität zu generieren :

# Navigate to the gateway-app root directory cd ../gateway-app # Runs the create entity wizard yo jhipster:entity dealer

Führen Sie abschließend ./mvnw im Stammverzeichnis der Händler-App aus, um diese Komponente zu starten.

Als Nächstes können wir unsere Gateway-Anwendung unter // localhost: 8080 besuchen und die Seite aktualisieren, um den neu erstellten Menüpunkt für die Dealer-Entität anzuzeigen.

Bevor wir fertig sind, werfen wir noch einmal einen Blick auf die Jhipster-Registrierungsanwendung unter // localhost: 8761 /. Klicken Sie auf den Menüpunkt Anwendungen, um zu überprüfen, ob alle drei Komponenten erfolgreich identifiziert und registriert wurden:

Das ist es! Wir haben eine ausgefeilte Architektur erstellt, die aus einer Gateway-App besteht, bei der der gesamte Front-End-Code in wenigen Minuten von zwei Microservices unterstützt wird.

5. Schlussfolgerung

Das Starten eines Microservice Architecture-Projekts mit JHipster ist recht einfach. Wir müssen nur so viele Microservice-Anwendungen wie nötig und ein Microservice-Gateway erstellen und können loslegen.

Sie können das Framework weiter unten auf der offiziellen JHipster-Website erkunden.

Wie immer ist die Codebasis für unsere Auto-App, Händler-App und Gateway-App über GitHub verfügbar.