1. Überblick
In vorherigen Artikeln haben wir die -Grundlagen von JHipster behandelt und erfahren, wie Sie eine https://www.baeldung.com/jhipster-microservices-basierte Datenbank generieren Anwendung].
In diesem Tutorial werden wir den Benutzerkonto- und Autorisierungsdienst von JHipster - kurz UAA - und die Verwendung dieses Dienstes zum Sichern einer umfassenden JHispter-basierten Mikroservice-Anwendung kennenlernen. Besser noch, all dies kann erreicht werden , ohne eine einzige Codezeile zu schreiben !
2. UAA-Kernfunktionen
Ein wichtiges Merkmal der Anwendungen, die wir in unseren vorherigen Artikeln eingebaut haben, ist, dass Benutzerkonten ein wesentlicher Bestandteil davon waren. Das ist in Ordnung, wenn wir eine einzige Anwendung haben, aber was ist, wenn wir Benutzerkonten für mehrere von JHipster generierte Anwendungen freigeben möchten? Hier kommt die UAA von JHipster ins Spiel.
Die UAA von JHipster ist ein Microservice, der unabhängig von anderen Diensten in unserer Anwendung erstellt, bereitgestellt und ausgeführt wird. Es dient als:
-
Ein OAuth2-Autorisierungsserver, der auf der Implementierung von Spring Boot basiert
-
Ein Identity Management Server, der eine Benutzerkonto-CRUD-API verfügbar macht
JHipster UAA unterstützt auch typische Anmeldefunktionen wie Selbstregistrierung und "Remember me". Und natürlich ist es vollständig in andere JHipster-Services integriert.
3. Einrichtung der Entwicklungsumgebung
Bevor wir mit der Entwicklung beginnen, müssen wir uns zunächst vergewissern, dass unsere Umgebung alle Voraussetzungen erfüllt. Neben allen in unserem Intro To JHipster-Artikel beschriebenen Tools benötigen wir eine laufende JHipster-Registrierung. Der Registrierungsdienst ermöglicht es, die verschiedenen Dienste, die wir erstellen, zu finden und miteinander zu kommunizieren.
Das vollständige Verfahren zum Erstellen und Ausführen der Registrierung wird in Abschnitt 4.1 unseres JHipster mit einem Microservice Architecture-Artikel beschrieben. Ein https://hub.docker.com/r/jhipster/jhipster-registry[Docker-Image ist ebenfalls verfügbar und kann alternativ verwendet werden.
4. Generieren eines neuen JHipster UAA Service
Lassen Sie uns unseren UAA-Dienst mit dem Befehlszeilenprogramm JHipster generieren
$ mkdir uaa
$ cd uaa
$ jhipsterDie erste Frage, die wir beantworten müssen, ist, welche Art von Anwendung wir generieren möchten. Mit den Pfeiltasten wählen wir die Option "JHipster UAA (für Microservice OAuth2 Authentication)"
Als Nächstes werden einige Fragen zu bestimmten Details des generierten Diensts gestellt, z. B. Name der Anwendung, Serverport und Diensterkennung.
In den meisten Fällen sind die Standardantworten in Ordnung. In Bezug auf den Basisnamen der Anwendung , der viele der erzeugten Artefakte beeinflusst , haben wir "uaa" (Kleinbuchstaben) gewählt - einen sinnvollen Namen. Wir können mit den anderen Werten herumspielen, wenn wir möchten, aber die Hauptmerkmale des generierten Projekts werden dadurch nicht geändert.
Nachdem Sie diese Fragen beantwortet haben, erstellt JHipster alle Projektdateien und installiert die Abhängigkeiten des npm -Pakets (die in diesem Fall nicht wirklich verwendet werden).
Wir können jetzt das lokale Maven-Skript verwenden, um unseren UAA-Dienst zu erstellen und auszuführen:
$ ./mvnw
... build messages omitted
2018-10-14 14:07:17.995 INFO 18052 ---[ restartedMain]com.baeldung.jhipster.uaa.UaaApp :
----------------------------------------------------------
Application 'uaa' is running! Access URLs:
Local: http://localhost:9999/ External: http://192.168.99.1:9999/ Profile(s): [dev, swagger]----------------------------------------------------------
2018-10-14 14:07:18.000 INFO 18052 ---[ restartedMain]com.baeldung.jhipster.uaa.UaaApp :
----------------------------------------------------------
Config Server: Connected to the JHipster Registry config server!
-----------------------------------------------------------
Die wichtigste Nachricht, die hier zu beachten ist, besagt, dass die UAA mit der JHipster-Registry verbunden ist. ** Diese Nachricht zeigt an, dass sich die UAA selbst registrieren konnte und für andere Microservices und Gateways für die Erkennung verfügbar ist.
5. Testen des UAA-Dienstes
Da der generierte UAA-Dienst selbst keine Benutzeroberfläche hat, müssen wir direkte API-Aufrufe verwenden, um zu testen, ob er wie erwartet funktioniert.
-
Es gibt zwei Funktionen, die vor dem Einsatz mit anderen Teilen oder unserem System sichergestellt werden müssen: ** OAuth2-Token-Generierung und Kontenabfrage
Lassen Sie uns zunächst ein neues Token vom OAuth-Endpunkt unserer UAA abrufen.
$ curl -X POST --data \
"username=user&password=user&grant__type=password&scope=openid" \
http://web__app:[email protected]:9999/oauth/tokenHier haben wir den __password grant __flow verwendet, wobei zwei Paare von Anmeldeinformationen verwendet wurden. In dieser Art von Fluss senden wir Client-Anmeldeinformationen mithilfe der grundlegenden HTTP-Authentifizierung, die wir direkt in der URL kodieren.
Die Endbenutzer-Anmeldeinformationen werden als Teil des Hauptteils unter Verwendung der Standardbenutzername- und Kennwortparameter gesendet. Wir verwenden auch das Benutzerkonto mit dem Namen "Benutzer" , das standardmäßig im Testprofil verfügbar ist.
Vorausgesetzt, wir haben alle Details korrekt angegeben, erhalten wir eine Antwort mit einem Zugriffstoken und einem Aktualisierungstoken:
{
"access__token" : "eyJh...(token omitted)",
"token__type" : "bearer",
"refresh__token" : "eyJ...(token omitted)",
"expires__in" : 299,
"scope" : "openid",
"iat" : 1539650162,
"jti" : "8066ab12-6e5e-4330-82d5-f51df16cd70f"
}Wir können jetzt ** das zurückgegebene access token verwenden, um mithilfe der Ressource account__, die im UAA-Dienst verfügbar ist, Informationen für das zugehörige Konto abzurufen:
$ curl -H "Authorization: Bearer eyJh...(access token omitted)" \
http://localhost:9999/api/account
{
"id" : 4,
"login" : "user",
"firstName" : "User",
"lastName" : "User",
"email" : "[email protected]",
"imageUrl" : "",
"activated" : true,
"langKey" : "en",
"createdBy" : "system",
"createdDate" : "2018-10-14T17:07:01.336Z",
"lastModifiedBy" : "system",
"lastModifiedDate" : null,
"authorities" :["ROLE__USER"]}-
Bitte beachten Sie, dass wir diesen Befehl ausgeben müssen, bevor das Zugriffstoken abläuft ** . Standardmäßig gibt der UAA-Dienst Token aus, die fünf Minuten gültig sind. Dies ist ein sinnvoller Wert für die Produktion.
Wir können die Lebensdauer gültiger Token leicht ändern, indem Sie die Datei application- <profile> .yml entsprechend dem Profil bearbeiten, unter dem die App ausgeführt wird, und das uaa.web-client-configuration.access-token-val- Sekunden Taste.
Die Einstellungsdateien befinden sich im Verzeichnis src/main/resources/config unseres UAA-Projekts.
6. Generieren des UAA-fähigen Gateways
Nun, da wir uns sicher sind, dass unser UAA-Service und unsere Service-Registry funktionieren, erstellen wir ein Ökosystem, mit dem diese interagieren können. Am Ende haben wir hinzugefügt:
-
Ein Angular-basiertes Frontend
-
Ein Microservice-Backend
-
Ein API-Gateway, das vor beiden steht
Beginnen wir eigentlich mit dem Gateway, da es der Dienst ist, der mit der UAA über die Authentifizierung verhandelt. Wir werden unsere Front-End-Anwendung hosten und API-Anforderungen an andere Microservices weiterleiten.
Wieder verwenden wir das JHipster-Befehlszeilenprogramm in einem neu erstellten Verzeichnis:
$ mkdir gateway
$ cd gateway
$ jhipsterNach wie vor müssen wir einige Fragen beantworten, um das Projekt zu generieren. Die wichtigsten sind die folgenden:
-
Application Type : muss "Microservices Gateway" sein
-
Anwendungsname: Dieses Mal verwenden wir "Gateway"
-
Service Discovery : Wählen Sie "JHipster-Registrierung" aus.
-
Authentication-Typ: ** Wir müssen "Authentication with" auswählen
Option JHipster UAA-Server ** UI Framework: Wählen wir "Angular 6"
Sobald JHipster alle Artefakte generiert hat, können wir das Gateway mit dem bereitgestellten Maven-Wrapper-Skript erstellen und ausführen:
$ ./mwnw
... many messages omitted
----------------------------------------------------------
Application 'gateway' is running! Access URLs:
Local: http://localhost:8080/ External: http://192.168.99.1:8080/ Profile(s): [dev, swagger]----------------------------------------------------------
2018-10-15 23:46:43.011 INFO 21668 ---[ restartedMain]c.baeldung.jhipster.gateway.GatewayApp :
----------------------------------------------------------
Config Server: Connected to the JHipster Registry config server!
----------------------------------------------------------Mit der obigen Nachricht können wir auf unsere Anwendung zugreifen, indem Sie in unserem Browser auf http://localhost : 8080, verweisen, der die standardmäßig generierte Startseite anzeigen soll:
Gehen Sie weiter und melden Sie sich in unserer Anwendung an, indem Sie zum Menüpunkt Account> Login navigieren. Wir verwenden __admin/admin __as als Anmeldeinformationen, die JHipster standardmäßig automatisch erstellt. Wenn alles gut geht, wird auf der Willkommensseite eine Nachricht angezeigt, die eine erfolgreiche Anmeldung bestätigt:
Lassen Sie uns zusammenfassen, was uns passiert ist: Zuerst hat das Gateway unsere Anmeldeinformationen an den Endpunkt OAuth2-Token der UAA gesendet, der sie validiert und eine Antwort generiert hat, die ein Zugriffs- und ein Aktualisierungs-JWT-Token enthält. Das Gateway nahm diese Token und sandte sie als Cookies an den Browser zurück.
Als Nächstes rief das Angular-Frontend die API /uaa/api/account auf, die das Gateway erneut an die UAA weiterleitete. In diesem Prozess nimmt das Gateway das Cookie mit dem Zugriffstoken und verwendet seinen Wert, um der Anforderung einen Berechtigungsheader hinzuzufügen.
Bei Bedarf können wir den gesamten Fluss detailliert anzeigen, indem Sie die Protokolle der UAA und des Gateways überprüfen. Wir können auch vollständige Daten auf Kabelebene abrufen, indem Sie die Protokollstufe org.apache.http.wire auf DEBUG setzen.
7. Generieren eines UAA-aktivierten Microservice
Nun, da unsere Anwendungsumgebung betriebsbereit ist, ist es an der Zeit, einen einfachen Microservice hinzuzufügen. Wir erstellen einen Mikroservice für Anführungszeichen, der eine vollständige REST-API verfügbar macht, mit der wir eine Reihe von Aktiennotierungen erstellen, abfragen, ändern und löschen können Jedes Angebot hat nur drei Eigenschaften:
-
Das Handelssymbol des Zitats
-
Sein Preis und
-
Der Zeitstempel des letzten Handels
Gehen wir zu unserem Terminal zurück und verwenden Sie das Befehlszeilentool von JHipster, um unser Projekt zu generieren:
$ mkdir quotes
$ cd quotes
$ jhipsterDiesmal bitten wir JHipster, eine Microservice-Anwendung zu generieren, die wir "Anführungszeichen" nennen. Die Fragen ähneln denen, die wir zuvor beantwortet haben. Wir können die Standardeinstellungen für die meisten beibehalten, außer für diese drei:
-
Service Discovery: Wählen Sie "JHipster Registry" aus, da wir bereits
Verwenden Sie es in unserer Architektur ** Pfad zur UAA-Anwendung: Da wir alle Projekte behalten
Verzeichnisse im selben Ordner sind dies ../uaa (es sei denn, wir haben hat es natürlich geändert) ** Authentication Type: Wählen Sie "JHipster UAA Server" aus.
So sieht eine typische Abfolge von Antworten in unserem Fall aus:
Sobald JHipster das Projekt erstellt hat, können wir es weiterentwickeln:
$ mvnw
... many, many messages omitted
----------------------------------------------------------
Application 'quotes' is running! Access URLs:
Local: http://localhost:8081/ External: http://192.168.99.1:8081/ Profile(s): [dev, swagger]----------------------------------------------------------
2018-10-19 00:16:05.581 INFO 16092 ---[ restartedMain]com.baeldung.jhipster.quotes.QuotesApp :
----------------------------------------------------------
Config Server: Connected to the JHipster Registry config server!
----------------------------------------------------------
... more messages omittedDie Nachricht "Verbunden mit dem JHipster Registry-Konfigurationsserver!" Suchen wir hier. Ihre Präsenz sagt uns, dass sich der Microservice bei der Registry registriert hat und das Gateway daher Anfragen an unsere Quotes-Ressource weiterleiten und sie auf einer schönen Benutzeroberfläche anzeigen kann, sobald wir sie erstellt haben. Da wir eine Microservice-Architektur verwenden, teilen wir diese Aufgabe in zwei Teile auf:
-
Erstellen Sie den Back-End-Service "Quotes"
-
Erstellen Sie im Frontend (Teil des Gateway-Projekts) die Benutzeroberfläche "Quotes"
7.1. Quotes-Ressource hinzufügen
Zuerst müssen wir sicherstellen, dass die Anwendung "microservice" für Anführungszeichen gestoppt wird - Wir können STRG-C in demselben Konsolenfenster drücken, in dem wir es zuvor ausgeführt haben.
Lassen Sie uns nun ** eine Entität mit JHipster-Tool zum Projekt hinzufügen. Diesmal verwenden wir den import-jdl -Befehl, der uns vor dem langwierigen und fehleranfälligen Prozess der individuellen Bereitstellung aller Details erspart.
Weitere Informationen zum JDL-Format finden Sie in der full JDL reference .
Als Nächstes erstellen wir eine Textdatei mit dem Namen quotes.jh , die unsere __Quote __entity-Definition sowie einige Anweisungen zur Codegenerierung enthält:
entity Quote {
symbol String required unique,
price BigDecimal required,
lastTrade ZonedDateTime required
}
dto Quote with mapstruct
paginate Quote with pagination
service Quote with serviceImpl
microservice Quote with quotes
filter Quote
clientRootFolder Quote with quotesWir können diese Entitätsdefinition jetzt in unser Projekt importieren:
$ jhipster import-jdl quotes.jh-
Hinweis: Während des Imports wird JHipster sich über einen Konflikt beschweren, während Änderungen an der Datei master.xml vorgenommen werden. In diesem Fall können wir die Option overwrite sicher wählen. **
Jetzt können wir unseren Microservice mit _mvnw erneut erstellen und ausführen. Nachdem können wir überprüfen, ob das Gateway die neue Route abruft und auf die Ansicht Gateway zugreift, die über das Menü Administration verfügbar ist. Diesmal sehen wir, dass es einen Eintrag für die _ /quotes/ -Route gibt, die zeigt, dass das Backend für die Verwendung durch die Benutzeroberfläche bereit ist.
7.2. Hinzufügen der Quotes-Benutzeroberfläche
Schließlich generieren wir die CRUD-Benutzeroberfläche im Gateway-Projekt, mit der wir auf unsere Angebote zugreifen können. Wir verwenden dieselbe JDL-Datei aus dem Microsofts-Projekt "quot", um die UI-Komponenten zu generieren, und importieren sie mit dem Befehl import-jdl von JHipster:
$ jhipster import-jdl ../jhipster-quotes/quotes.jh
...messages omitted
? Overwrite webpack\webpack.dev.js? <b>y</b>
... messages omitted
Congratulations, JHipster execution is complete!Während des Imports fordert JHipster einige Male auf, welche Aktion er in Bezug auf in Konflikt stehende Dateien ergreifen sollte. In unserem Fall können wir vorhandene Ressourcen einfach überschreiben, da wir keine Anpassungen vorgenommen haben.
Jetzt können wir das Gateway neu starten und sehen, was wir erreicht haben. Lassen Sie uns unseren Browser auf das Gateway unter http://localhost : 8080[ http://localhost : 8080 ]zeigen, um sicherzustellen, dass der Inhalt aktualisiert wird. Das Entities -Menü sollte jetzt einen neuen Eintrag für die Quotes -Ressource haben:
Durch Klicken auf diese Menüoption wird der Bildschirm mit den Quotes -Listen angezeigt:
Wie erwartet ist das Listing leer - wir haben noch keine Angebote hinzugefügt.
Versuchen Sie, eine hinzuzufügen, indem Sie auf die Schaltfläche "Neues Angebot erstellen" oben rechts in diesem Bildschirm klicken. Dadurch gelangen Sie zum Formular zum Erstellen/Bearbeiten:
Wir können sehen, dass das generierte Formular alle erwarteten Funktionen aufweist:
-
Pflichtfelder sind mit einer roten Markierung markiert, die grün wird
einmal gefüllt ** Datum/Uhrzeit und numerische Felder verwenden zur Unterstützung der Daten native Komponenten
Eintrag ** Wir können diese Aktivität abbrechen, wodurch die Daten unverändert bleiben oder gespeichert werden
unser neues oder modifiziertes Unternehmen
Nachdem Sie dieses Formular ausgefüllt haben und _Save drücken, sehen wir die Ergebnisse auf dem Listenbildschirm. Wir können jetzt die neue Quotes -Instanz _ im Datenraster sehen:
-
Als Administrator haben wir auch Zugriff auf den API-Menüpunkt ** , der uns zum Standard-Entwicklerportal von Swagger API führt. In diesem Bildschirm können wir eine der verfügbaren APIs für die Übung auswählen:
-
__default: __Gateway-eigene API, die verfügbare Routen anzeigt
-
uaa : Konto- und Benutzer-APIs
-
__quotes: __Quotes API
-
Nächste Schritte
-
Die Anwendung, die wir bisher entwickelt haben, funktioniert wie erwartet und bietet eine solide Basis für die weitere Entwicklung. Wir müssen auf jeden Fall auch (oder viele) benutzerdefinierten Code schreiben, je nach Komplexität unserer Anforderungen. Einige Bereiche, die wahrscheinlich etwas Arbeit benötigen, sind:
-
UI Look and Feel Anpassung: Dies ist in der Regel recht einfach
So wie die Front-End-Anwendung strukturiert ist, können wir einen langen Weg gehen einfach durch Fummeln mit CSS und Hinzufügen einiger Bilder ** User-Repository-Änderungen: Einige Organisationen haben bereits eine Sortierung
des internen Benutzer-Repositorys (z. B. ein LDAP-Verzeichnis) - dies ist erforderlich Änderungen an der UAA, aber das Schöne daran ist, dass wir sie nur ändern müssen Einmal Feinere Berechtigung für Entitäten: __ ** Die Standardsicherheit
Das vom generierten Entity-Backend verwendete Modell verfügt über keinerlei Sicherheit auf Instanzebene und/oder Feldebene ** - Es ist Sache des Entwicklers, diese Einschränkungen auf der entsprechenden Ebene hinzuzufügen (je nach Fall API oder Service).
Trotz dieser Anmerkungen kann die Verwendung eines Tools wie JHispter bei der Entwicklung einer neuen Anwendung sehr hilfreich sein. Es wird ein solides Fundament mitbringen und kann bei der Weiterentwicklung des Systems - und der Entwickler - ein gutes Maß an Konsistenz in unserer Codebasis beibehalten.
9. Schlussfolgerung
In diesem Artikel haben wir gezeigt, wie Sie mit JHispter eine funktionierende Anwendung erstellen, die auf einer Microservices-Architektur und dem UAA-Server von JHipster basiert. Wir haben das erreicht, ohne eine einzige Zeile Java-Code zu schreiben , was ziemlich beeindruckend ist.
Wie üblich ist der vollständige Code für die in diesem Artikel vorgestellten Projekte in unserem Repository https://github.com/eugenp/tutorials/tree/master/jhipster/jhipster-uaa [GitHub verfügbar.