Een basis UAA-beveiligde JHipster Microservice bouwen

1. Overzicht

In eerdere artikelen hebben we de basisprincipes van JHipster besproken en hoe je deze kunt gebruiken om een ​​op microservices gebaseerde applicatie te genereren.

In deze tutorial we zullen de gebruikersaccount- en autorisatieservice van JHipster verkennen - UAA in het kort - en hoe u deze kunt gebruiken om een ​​volwaardige JHispter-gebaseerde microservicetoepassing te beveiligen. Nog beter, dit alles kan worden bereikt zonder een enkele regel code te schrijven!

2. UAA-kernfuncties

Een belangrijk kenmerk van de applicaties die we in onze vorige artikelen hebben gebouwd, is dat gebruikersaccounts er een integraal onderdeel van waren. Dit is prima als we een enkele applicatie hebben, maar wat als we gebruikersaccounts willen delen tussen meerdere door JHipster gegenereerde applicaties? Dit is waar de UAA van JHipster om de hoek komt kijken.

De UAA van JHipster is dus een microservice gebouwd, geïmplementeerd en onafhankelijk van andere services in onze applicatie uitgevoerd. Het dient als:

  • Een OAuth2-autorisatieserver, gebaseerd op de implementatie van Spring Boot
  • Een identiteitsbeheerserver, die de CRUD API van een gebruikersaccount blootlegt

JHipster UAA ondersteunt ook typische inlogfuncties zoals zelfregistratie en "onthoud mij". En natuurlijk integreert het volledig met andere JHipster-services.

3. Ontwikkelomgeving instellen

Voordat we met een ontwikkeling beginnen, moeten we er eerst zeker van zijn dat onze omgeving aan alle voorwaarden voldoet. Naast alle tools die worden beschreven in ons artikel Inleiding tot JHipster, hebben we een actief JHipster-register nodig. Even een korte samenvatting: de registerservice staat de verschillende services die we zullen maken toe om elkaar te vinden en met elkaar te praten.

De volledige procedure voor het genereren en uitvoeren van het register wordt beschreven in sectie 4.1 van onze JHipster met een Microservice Architecture-artikel, dus we zullen het hier niet herhalen. Een Docker-image is ook beschikbaar en kan als alternatief worden gebruikt.

4. Een nieuwe JHipster UAA-service genereren

Laten we onze UAA-service genereren met behulp van het JHipster-opdrachtregelprogramma:

$ mkdir uaa $ cd uaa $ jhipster 

De eerste vraag die we moeten beantwoorden, is welk type applicatie we willen genereren. Met de pijltjestoetsen selecteren we de optie "JHipster UAA (voor microservice OAuth2-authenticatie)":

Vervolgens worden we gevraagd om een ​​paar vragen over specifieke details met betrekking tot de gegenereerde service, zoals de naam van de applicatie, de serverpoort en het zoeken naar services:

Voor het grootste deel zijn de standaardantwoorden prima. Wat betreft de basisnaam van de applicatie, die veel van de gegenereerde artefacten beïnvloedt, we hebben gekozen "Uaa" (kleine letters) - een verstandige naam. We kunnen spelen met de andere waarden als we dat willen, maar het zal de belangrijkste kenmerken van het gegenereerde project niet veranderen.

Na het beantwoorden van deze vragen, zal JHipster alle projectbestanden aanmaken en installeren npm pakketafhankelijkheden (die in dit geval niet echt worden gebruikt).

We kunnen nu het lokale Maven-script gebruiken om onze UAA-service te bouwen en uit te voeren:

$ ./mvnw ... build-berichten weggelaten 2018-10-14 14: 07: 17.995 INFO 18052 --- [restartedMain] com.baeldung.jhipster.uaa.UaaApp: ------------ ---------------------------------------------- Toepassing 'uaa' is aan het rennen! Toegangs-URL's: Local: // localhost: 9999 / External: //192.168.99.1:9999/ Profiel (en): [dev, swagger] ------------------- --------------------------------------- 2018-10-14 14: 07: 18.000 INFO 18052 --- [herstartMain] com.baeldung.jhipster.uaa.UaaApp: --------------------------------- ------------------------- Config Server: Verbonden met de JHipster Registry configuratieserver! -------------------------------------------------- -------- 

De belangrijkste boodschap om hier op te letten, is die waarin staat dat UAA is verbonden met het JHipster-register. Dit bericht geeft aan dat UAA zichzelf heeft kunnen registreren en beschikbaar zal zijn voor detectie door andere microservices en gateways.

5. Testen van de UAA-dienst

Omdat de gegenereerde UAA-service zelf geen gebruikersinterface heeft, moeten we directe API-aanroepen gebruiken om te testen of deze naar verwachting werkt.

Er zijn twee functionaliteiten waarvan we zeker moeten zijn dat ze werken voordat we het met andere onderdelen of ons systeem gebruiken: OAuth2-token genereren en account ophalen.

Laten we eerst haal een nieuw token op van het OAuth-eindpunt van onze UAA, met behulp van een eenvoudig krullen opdracht:

$ curl -X POST --data \ "gebruikersnaam = gebruiker & wachtwoord = gebruiker & grant_type = wachtwoord & bereik = openid" \ // web_app: [e-mail beveiligd]: 9999 / oauth / token 

Hier hebben we de wachtwoord toekennen flow, met behulp van twee paar referenties. In dit soort stroom verzenden we klantreferenties met behulp van standaard HTTP-authenticatie, die we rechtstreeks in de URL coderen.

De inloggegevens van de eindgebruiker worden verzonden als onderdeel van de hoofdtekst, met behulp van de standaard gebruikersnaam en wachtwoordparameters. We gebruiken ook het genoemde gebruikersaccount "gebruiker", die standaard beschikbaar is in het testprofiel.

Ervan uitgaande dat we alle details correct hebben verstrekt, krijgen we een antwoord met een toegangstoken en een vernieuwingstoken:

{"access_token": "eyJh ... (token weggelaten)", "token_type": "bearer", "refresh_token": "eyJ ... (token weggelaten)", "expires_in": 299, "scope": " openid "," iat ": 1539650162," jti ":" 8066ab12-6e5e-4330-82d5-f51df16cd70f "}

Nu kunnen we gebruik de geretourneerde toegangstoken om informatie voor het gekoppelde account op te halen met behulp van de account bron, die beschikbaar is in de UAA-service:

$ curl -H "Autorisatie: Bearer eyJh ... (toegangstoken weggelaten)" \ // localhost: 9999 / api / account {"id": 4, "login": "user", "firstName": "Gebruiker" , "lastName": "Gebruiker", "email": "[email protected]", "imageUrl": "", "activated": true, "langKey": "en", "createdBy": "system", " createdDate ":" 2018-10-14T17: 07: 01.336Z "," lastModifiedBy ":" system "," lastModifiedDate ": null," autoriteiten ": [" ROLE_USER "]} 

Houd er rekening mee dat we deze opdracht moeten geven voordat het toegangstoken verloopt. Standaard geeft de UAA-service tokens uit die vijf minuten geldig zijn, wat een verstandige waarde is voor productie.

We kunnen de levensduur van geldige tokens eenvoudig wijzigen door de applicatie-.yml bestand dat overeenkomt met het profiel waaronder we de app uitvoeren en het uaa.web-client-configuration.access-token-validity-in-seconds sleutel. De instellingenbestanden bevinden zich in het src / main / resources / config directory van ons UAA-project.

6. Genereren van de UAA-geactiveerde gateway

Nu we er zeker van zijn dat onze UAA-service en serviceregistratie werken, gaan we een ecosysteem creëren waarmee ze kunnen communiceren. Aan het einde hebben we toegevoegd:

  • Een Angular-based front-end
  • Een microservice-back-end
  • Een API-gateway die voor beide zorgt

Laten we eigenlijk beginnen met de gateway, aangezien dit de service zal zijn die met UAA zal onderhandelen over authenticatie. Het gaat onze front-end-applicatie hosten en API-verzoeken doorsturen naar andere microservices.

Nogmaals, we zullen het JHipster-opdrachtregelprogramma gebruiken in een nieuw gemaakte map:

$ mkdir gateway $ cd gateway $ jhipster

Net als voorheen moeten we een paar vragen beantwoorden om het project te genereren. De belangrijkste zijn de volgende:

  • Applicatie type: moet 'Microservices gateway' zijn
  • Naam van de toepassing: We zullen deze keer "gateway" gebruiken
  • Service-detectie: Selecteer "JHipster registry"
  • Verificatietype:We moeten de optie "Authenticatie met JHipster UAA-server" selecteren hier
  • UI-raamwerk: Laten we "Angular 6" kiezen

Zodra JHipster al zijn artefacten heeft gegenereerd, kunnen we de gateway bouwen en uitvoeren met het meegeleverde Maven-wrapper-script:

$ ./mwnw ... veel berichten weggelaten ---------------------------------------- ------------------ Applicatie 'gateway' wordt uitgevoerd! Toegangs-URL's: Local: // localhost: 8080 / External: //192.168.99.1:8080/ Profiel (en): [dev, swagger] ------------------- --------------------------------------- 2018-10-15 23:46: 43.011 INFO 21668 --- [herstartMain] c.baeldung.jhipster.gateway.GatewayApp: --------------------------------- ------------------------- Config Server: Verbonden met de JHipster Registry configuratieserver! -------------------------------------------------- -------- 

Met het bovenstaande bericht hebben we toegang tot onze applicatie door onze browser naar te wijzen // localhost: 8080, die de standaard gegenereerde startpagina zou moeten weergeven:

Laten we doorgaan en inloggen op onze applicatie door naar het Account> Inloggen menu onderdeel. We zullen gebruiken admin / admin als inloggegevens, die JHipster standaard automatisch aanmaakt. Alles gaat goed, de welkomstpagina geeft een bericht weer dat een succesvolle aanmelding bevestigt:

Laten we samenvatten wat er is gebeurd om ons hier te krijgen: eerst stuurde de gateway onze inloggegevens naar het OAuth2-token-eindpunt van de UAA, dat ze valideerde en een antwoord genereerde met een toegangs- en een vernieuwd JWT-token. De gateway nam vervolgens die tokens en stuurde ze als cookies terug naar de browser.

Vervolgens noemde de Angular front-end de / uaa / api / account API, die opnieuw de gateway doorstuurde naar UAA. In dit proces neemt de gateway de cookie met het toegangstoken en gebruikt zijn waarde om een ​​autorisatieheader aan het verzoek toe te voegen.

Indien nodig kunnen we al deze stroom tot in detail bekijken door zowel de UAA- als de Gateway-logboeken te controleren. We kunnen ook volledige gegevens op draadniveau krijgen door de org.apache.http.wire logger niveau naar DEBUG.

7. Genereren van een UAA-enabled microservice

Nu onze applicatieomgeving draait, is het tijd om er een eenvoudige microservice aan toe te voegen. We maken een microservice voor “koersen”, die een volledige REST API beschikbaar stelt waarmee we een reeks aandelenkoersen kunnen maken, opvragen, wijzigen en verwijderen. Elk citaat heeft slechts drie eigenschappen:

  • Het handelssymbool van het citaat
  • Zijn prijs, en
  • Tijdstempel van de laatste transactie

Laten we teruggaan naar onze terminal en de opdrachtregeltool van JHipster gebruiken om ons project te genereren:

$ mkdir citeert $ cd citeert $ jhipster 

Deze keer vragen we JHipster om een Microservice-applicatie, die we "aanhalingstekens" zullen noemen. De vragen zijn vergelijkbaar met degene die we eerder hebben beantwoord. Voor de meeste kunnen we de standaardinstellingen behouden, behalve voor deze drie:

  • Dienstopsporing: Selecteer "JHipster Registry" aangezien we het al in onze architectuur gebruiken
  • Pad naar de UAA-applicatie: Omdat we alle projectmappen in dezelfde map houden, is dit ../uaa (tenzij we het natuurlijk hebben veranderd)
  • Verificatietype: Selecteer "JHipster UAA-server"

Hier is hoe een typische reeks antwoorden eruit zal zien in ons geval:

Zodra JHipster klaar is met het genereren van het project, kunnen we doorgaan en het bouwen:

$ mvnw ... veel, veel berichten weggelaten ---------------------------------------- ------------------ Applicatie 'quotes' wordt uitgevoerd! Toegangs-URL's: Local: // localhost: 8081 / External: //192.168.99.1:8081/ Profiel (en): [dev, swagger] ------------------- --------------------------------------- 2018-10-19 00: 16: 05.581 INFO 16092 --- [herstartMain] com.baeldung.jhipster.quotes.QuotesApp: --------------------------------- ------------------------- Config Server: Verbonden met de JHipster Registry configuratieserver! -------------------------------------------------- -------- ... meer berichten weggelaten 

Het bericht "Verbonden met de JHipster Registry-configuratieserver!" is wat we hier zoeken. Zijn aanwezigheid vertelt ons dat de microservice zichzelf heeft geregistreerd bij het register en dat de gateway daarom verzoeken naar onze bron voor "quotes" kan routeren en deze op een mooie gebruikersinterface kan weergeven zodra we deze hebben gemaakt. Omdat we een microservice-architectuur gebruiken, hebben we deze taak in twee delen opgesplitst:

  • Maak de back-endservice van de bron "quotes"
  • Maak de gebruikersinterface 'aanhalingstekens' in de front-end (onderdeel van het gatewayproject)

7.1. De bron voor offertes toevoegen

Ten eerste moeten we zorg ervoor dat de microservicetoepassing aanhalingstekens is gestopt - we kunnen CTRL-C raken in hetzelfde consolevenster dat we eerder gebruikten om het uit te voeren.

Laten we nu voeg een entiteit toe aan het project met behulp van de tool van JHipster. Deze keer gebruiken we de import-jdl commando, wat ons zal redden van het vervelende en foutgevoelige proces om alle details afzonderlijk aan te leveren. Raadpleeg de volledige JDL-referentie voor meer informatie over het JDL-formaat.

Vervolgens we maak een tekstbestand met de naam quotes.jh met onze Citaat entiteit definitie, samen met enkele richtlijnen voor het genereren van codes:

entiteit Citaat {symbool Tekenreeks vereist uniek, prijs BigDecimal vereist, lastTrade ZonedDateTime vereist} dto Offerte met mapstruct paginate Offerte met paginering-service Offerte met serviceImpl microservice Offerte met offertefilter Offerte clientRootFolder Offerte met aanhalingstekens 

Nu kunnen we importeer deze entiteitsdefinitie naar ons project:

$ jhipster import-jdl quotes.jh 

Opmerking: tijdens het importeren zal JHipster klagen over een conflict bij het toepassen van wijzigingen in het master.xml het dossier. We kunnen veilig kiezen voor de overschrijven optie in dit geval.

We kunnen nu onze microservice bouwen en weer gebruiken met mvnw. Zodra het voorbij is, kunnen we controleren of de gateway de nieuwe route oppikt die toegang geeft tot het poort weergave, verkrijgbaar bij de Administratie menu. Deze keer kunnen we zien dat er een vermelding is voor de "/citaten/**" route, dielaat zien dat de backend klaar is voor gebruik door de gebruikersinterface.

7.2. De gebruikersinterface voor offertes toevoegen

Laten we tot slot de CRUD-gebruikersinterface genereren in het gatewayproject dat we zullen gebruiken om toegang te krijgen tot onze offertes. We gebruiken hetzelfde JDL-bestand van het microserviceproject "quotes" om de UI-componenten te genereren, en we importeren het met behulp van JHipster's import-jdl opdracht:

$ jhipster import-jdl ../jhipster-quotes/quotes.jh ... berichten weggelaten? Webpack \ webpack.dev.js overschrijven? y ... berichten weggelaten Gefeliciteerd, de uitvoering van JHipster is voltooid! 

Tijdens het importeren zal JHipster een paar keer vragen wat het moet doen met betrekking tot conflicterende bestanden. In ons geval kunnen we eenvoudig bestaande bronnen overschrijven, aangezien we geen aanpassingen hebben gedaan.

Nu kunnen we de gateway opnieuw opstarten en kijken wat we hebben bereikt. Laten we onze browser naar de gateway richten op // localhost: 8080, en zorg ervoor dat we de inhoud vernieuwen. De Entiteiten menu zou nu een nieuw item moeten hebben voor de Citaten bron:

Als u op deze menuoptie klikt, wordt het Citaten lijstscherm:

Zoals verwacht is de aanbieding leeg - we hebben nog geen offertes toegevoegd! Laten we proberen er een toe te voegen door op de knop "Nieuwe offerte maken" rechtsboven in dit scherm te klikken, wat ons naar het formulier voor aanmaken / bewerken brengt:

We kunnen zien dat het gegenereerde formulier alle verwachte kenmerken heeft:

  • Verplichte velden zijn gemarkeerd met een rode indicator, die groen wordt zodra deze is ingevuld
  • Datum / tijd en numerieke velden gebruiken native componenten om te helpen bij het invoeren van gegevens
  • We kunnen deze activiteit annuleren, waardoor de gegevens ongewijzigd blijven, of onze nieuwe of gewijzigde entiteit opslaan

Na het invullen van dit formulier en op Sparen, we zien de resultaten op het lijstscherm. We kunnen nu het nieuwe zien Citaten voorbeeldin het dataraster:

Als admin hebben we ook toegang tot het API-menu-item, waarmee we naar de standaard Swagger API Developer Portal gaan. In dit scherm kunnen we een van de beschikbare API's selecteren om uit te oefenen:

  • standaard: Gateway's eigen API die beschikbare routes weergeeft
  • uaa: Account- en gebruikers-API's
  • citaten: Offertes API

8. Volgende stappen

De applicatie die we tot nu toe hebben gebouwd, werkt zoals verwacht en biedt een solide basis voor verdere ontwikkeling. We zullen zeker ook wat (of veel) aangepaste code moeten schrijven, afhankelijk van de complexiteit van onze vereisten. Enkele gebieden die waarschijnlijk wat werk nodig hebben, zijn:

  • UI-look en feel-aanpassing: Dit is meestal vrij eenvoudig vanwege de manier waarop de front-end-applicatie is gestructureerd - we kunnen een heel eind komen door simpelweg met CSS te spelen en wat afbeeldingen toe te voegen
  • Wijzigingen in de gebruikersrepository: Sommige organisaties hebben al een soort interne gebruikersrepository (bijvoorbeeld een LDAP-directory) - dit vereist wijzigingen op de UAA, maar het leuke is dat we het maar één keer hoeven te wijzigen
  • Fijnere autorisatie voor entiteiten:Het standaardbeveiligingsmodel dat wordt gebruikt door de gegenereerde entiteitsback-end heeft geen enkele vorm van beveiliging op instantieniveau en / of veldniveau - het is aan de ontwikkelaar om die beperkingen op het juiste niveau toe te voegen (API of service, afhankelijk van het geval)

Zelfs met die opmerkingen kan het gebruik van een tool als JHispter veel helpen bij het ontwikkelen van een nieuwe applicatie. Het zal een solide basis met zich meebrengen en kan een goed niveau van consistentie in onze codebasis behouden naarmate het systeem - en de ontwikkelaars - evolueren.

9. Conclusie

In dit artikel hebben we laten zien hoe je JHispter kunt gebruiken om een ​​werkende applicatie te maken op basis van een microservices-architectuur en de UAA-server van JHipster. We hebben dat bereikt zonder een enkele regel Java-code te schrijven, wat best indrukwekkend is.

Zoals gewoonlijk is de volledige code voor de projecten die in dit artikel worden gepresenteerd, beschikbaar in onze GitHub-repository.