streamalism.org

1. Oversikt

I tidligere artikler har vi dekket det grunnleggende om JHipster og hvordan du bruker det til å generere et mikroservicebasert program.

I denne veiledningen, vi vil utforske JHipsters brukerkonto og autorisasjonstjeneste - UAA for kort - og hvordan du bruker den til å sikre en fullverdig JHispter-basert mikroserviceapplikasjon. Enda bedre, alt dette kan oppnås uten å skrive en eneste kodelinje!

2. UAA kjernefunksjoner

Et viktig trekk ved applikasjonene vi har bygd i våre tidligere artikler er at brukerkontoer var en integrert del av dem. Nå er dette greit når vi har et enkelt program, men hva om vi vil dele brukerkontoer mellom flere JHipster-genererte applikasjoner? Dette er hvor JHipsters UAA kommer inn.

JHipsters UAA er en mikroservice det er bygget, distribuert og kjørt uavhengig av andre tjenester i applikasjonen vår. Det fungerer som:

• En OAuth2 autorisasjonsserver, basert på Spring Boots implementering
• En Identity Management Server som avslører en brukerkonto CRUD API

JHipster UAA støtter også typiske påloggingsfunksjoner som selvregistrering og "husk meg". Og selvfølgelig integreres den fullt ut med andre JHipster-tjenester.

3. Oppsett av utviklingsmiljø

Før vi starter en utvikling, må vi først være sikre på at miljøet vårt har alle forutsetningene. I tillegg til alle verktøyene som er beskrevet i artikkelen Intro To JHipster, trenger vi et løpende JHipster Registry. Akkurat som et raskt sammendrag tillater registertjenesten de forskjellige tjenestene vi oppretter for å finne og snakke med hverandre.

Den fullstendige prosedyren for å generere og kjøre registret er beskrevet i avsnitt 4.1 i vår JHipster med en Microservice Architecture-artikkel, så vi vil ikke gjenta det her. Et Docker-bilde er også tilgjengelig og kan brukes som et alternativ.

4. Generere en ny JHipster UAA-tjeneste

La oss generere UAA-tjenesten vår ved hjelp av JHipster kommandolinjeprogram:

$ mkdir uaa $ cd uaa $ jhipster 

Det første spørsmålet vi må svare på er hvilken type applikasjon vi vil generere. Ved hjelp av piltastene velger vi alternativet "JHipster UAA (for mikroservice OAuth2-godkjenning)":

Deretter blir vi bedt om noen spørsmål angående spesifikke detaljer angående den genererte tjenesten, for eksempel applikasjonsnavn, serverport og serviceoppdagelse:

For det meste er standard svarene fine. Når det gjelder applikasjonens grunnnavn, som påvirker mange av de genererte gjenstandene, vi har valgt “Uaa” (små bokstaver) - et fornuftig navn. Vi kan leke med de andre verdiene hvis vi vil, men det vil ikke endre hovedfunksjonene i det genererte prosjektet.

Etter å ha svart på disse spørsmålene, vil JHipster opprette alle prosjektfiler og installere npm pakkeavhengigheter (som egentlig ikke brukes i dette tilfellet).

Vi kan nå bruke det lokale Maven-skriptet til å bygge og kjøre UAA-tjenesten vår:

$ ./mvnw ... bygg meldinger utelatt 2018-10-14 14: 07: 17.995 INFO 18052 --- [restartedMain] com.baeldung.jhipster.uaa.UaaApp: ------------ ---------------------------------------------- Søknad 'uaa' løper! Tilgangs-URLer: Lokal: // localhost: 9999 / Ekstern: //192.168.99.1:9999/ Profil (er): [dev, swagger] ------------------- --------------------------------------- 2018-10-14 14: 07: 18.000 INFO 18052 --- [restartedMain] com.baeldung.jhipster.uaa.UaaApp: --------------------------------- ------------------------- Config Server: Koblet til JHipster Registry konfigurasjonsserver! -------------------------------------------------- -------- 

Hovedbudskapet å være oppmerksom på her er den som sier at UAA er koblet til JHipster Registry. Denne meldingen indikerer at UAA var i stand til å registrere seg selv og vil være tilgjengelig for oppdagelse av andre mikrotjenester og gateways.

5. Testing av UAA-tjenesten

Siden den genererte UAA-tjenesten ikke har noe brukergrensesnitt i seg selv, må vi bruke direkte API-anrop for å teste om den fungerer som forventet.

Det er to funksjoner som vi må sørge for at de fungerer før vi bruker den med andre deler eller systemet vårt: OAuth2-tokengenerering og kontogjenfinning.

Først, la oss få et nytt token fra UAAs OAuth-endepunkt, ved hjelp av en enkel krølle kommando:

$ curl -X POST --data \ "brukernavn = bruker & passord = bruker & grant_type = passord & omfang = openid" \ // web_app: [e-postbeskyttet]: 9999 / oauth / token 

Her har vi brukt passordtilskudd flyt, ved hjelp av to par legitimasjon. I denne typen flyt sender vi klientlegitimasjon ved hjelp av grunnleggende HTTP-autentisering, som vi koder direkte i URL-en.

Sluttbrukerlegitimasjonen sendes som en del av kroppen, ved hjelp av standard brukernavn og passordparametere. Vi bruker også brukerkontoen som heter "bruker", som er tilgjengelig som standard i testprofilen.

Forutsatt at vi har oppgitt alle detaljene riktig, får vi et svar som inneholder et tilgangstoken og et oppdateringstoken:

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

Det kan vi nå bruk den returnerte tilgangstoken for å få informasjon for den tilknyttede kontoen ved hjelp av regnskap ressurs, som er tilgjengelig i UAA-tjenesten:

$ curl -H "Autorisasjon: Bearer eyJh ... (tilgangstoken utelatt)" \ // localhost: 9999 / api / account {"id": 4, "login": "user", "firstName": "User" , "lastName": "Bruker", "email": "[e-postbeskyttet]", "imageUrl": "", "aktivert": sant, "langKey": "no", "createdBy": "system", " createdDate ":" 2018-10-14T17: 07: 01.336Z "," lastModifiedBy ":" system "," lastModifiedDate ": null," autoriteter ": [" ROLE_USER "]} 

Vær oppmerksom på at vi må utstede denne kommandoen før tilgangstoken utløper. UAA-tjenesten utsteder som standard tokens som er gyldige i fem minutter, noe som er en fornuftig verdi for produksjonen.

Vi kan enkelt endre levetiden til gyldige tokens ved å redigere applikasjon-.yml filen som tilsvarer profilen vi kjører appen under og setter inn uaa.web-client-configuration.access-token-validity-in-seconds nøkkel. Innstillingsfilene ligger i src / main / resources / config katalog over UAA-prosjektet vårt.

6. Genererer UAA-aktivert gateway

Nå som vi er sikre på at UAA-tjenesten og tjenestregisteret fungerer, la oss lage et økosystem for disse å samhandle med. Til slutt har vi lagt til:

• En vinkelbasert frontend
• En mikroservice-back-end
• En API Gateway som fronter begge disse

La oss faktisk begynne med gatewayen, da det vil være tjenesten som vil forhandle med UAA for autentisering. Det kommer til å være vert for vår front-end-applikasjon og rute API-forespørsler til andre mikrotjenester.

Nok en gang bruker vi kommandolinjeverktøyet JHipster i en nyopprettet katalog:

$ mkdir gateway $ cd gateway $ jhipster

Som før må vi svare på noen spørsmål for å kunne generere prosjektet. De viktigste er følgende:

• Søknadstype: må være "Microservices gateway"
• Programnavn: Vi bruker “gateway” denne gangen
• Tjenesteoppdagelse: Velg “JHipster registry”
• Autentiseringstype:Vi må velge alternativet "Autentisering med JHipster UAA-server" her
• UI Framework: La oss velge “Angular 6”

Når JHipster genererer alle gjenstandene, kan vi bygge og kjøre gatewayen med det medfølgende Maven wrapper-skriptet:

$ ./mwnw ... mange meldinger utelatt ---------------------------------------- ------------------ Programmet 'gateway' kjører! Tilgangs-URLer: Lokal: // localhost: 8080 / Ekstern: //192.168.99.1:8080/ Profil (er): [dev, swagger] ------------------- --------------------------------------- 2018-10-15 23: 46: 43.011 INFO 21668 --- [restartedMain] c.baeldung.jhipster.gateway.GatewayApp: --------------------------------- ------------------------- Config Server: Koblet til JHipster Registry konfigurasjonsserver! -------------------------------------------------- -------- 

Med meldingen ovenfor kan vi få tilgang til applikasjonen vår ved å peke nettleseren vår mot // lokal vert: 8080, som skal vise den standardgenererte hjemmesiden:

La oss gå videre og logge på applikasjonen vår, ved å navigere til Konto> Pålogging menyelement. Vi bruker admin / admin som legitimasjon, som JHipster oppretter automatisk som standard. Alt går bra, velkomstsiden viser en melding som bekrefter en vellykket pålogging:

La oss oppsummere hva som skjedde med å få oss hit: Først sendte gatewayen vår legitimasjon til UAAs OAuth2-token-endepunkt, som validerte dem og genererte et svar som inneholder tilgang og et JWT-token på nytt. Gatewayen tok deretter disse tokens og sendte dem tilbake til nettleseren som informasjonskapsler.

Deretter kalte den kantede frontenden den / uaa / api / konto API, som igjen gatewayen videresendes til UAA. I denne prosessen tar gatewayen informasjonskapselen som inneholder tilgangstokenet, og bruker verdien til å legge til en autorisasjonshode i forespørselen.

Om nødvendig kan vi se all denne strømmen i detalj ved å sjekke både UAA og Gateway-loggene. Vi kan også få full data på ledningsnivå ved å stille inn org.apache.http.wire loggernivå til DEBUG.

7. Generere en UAA-aktivert mikroservice

Nå som applikasjonsmiljøet vårt er i gang, er det på tide å legge til en enkel mikroservice til det. Vi oppretter en "tilbud" mikrotjeneste, som vil avsløre en fullstendig REST API som lar oss lage, spørre, endre og slette et sett med aksjekurser. Hvert tilbud vil bare ha tre egenskaper:

• Sitatets handelssymbol
• Prisen, og
• Den siste handelens tidsstempel

La oss gå tilbake til terminalen vår og bruke JHipsters kommandolinjeverktøy for å generere prosjektet vårt:

$ mkdir sitater $ cd sitater $ jhipster 

Denne gangen ber vi JHipster om å generere en Microservice applikasjon, som vi vil kalle "sitater". Spørsmålene ligner på de vi har svart på før. Vi kan beholde standardene for de fleste av dem, bortsett fra disse tre:

• Service Discovery: Velg “JHipster Registry” siden vi allerede bruker det i vår arkitektur
• Sti til UAA-applikasjonen: Siden vi holder alle prosjektkataloger under samme mappe, vil dette være ../uaa (med mindre vi selv har endret det)
• Autentiseringstype: Velg “JHipster UAA server”

Slik ser en typisk sekvens av svar ut i vårt tilfelle:

Når JHipster er ferdig med å generere prosjektet, kan vi fortsette og bygge det:

$ mvnw ... mange, mange meldinger utelatt ---------------------------------------- ------------------ Søknad 'sitater' kjører! Tilgangs-URLer: Lokal: // localhost: 8081 / Ekstern: //192.168.99.1:8081/ Profil (er): [dev, swagger] ------------------- --------------------------------------- 2018-10-19 00: 16: 05.581 INFO 16092 --- [restartedMain] com.baeldung.jhipster.quotes.QuotesApp: --------------------------------- ------------------------- Config Server: Koblet til JHipster Registry konfigurasjonsserver! -------------------------------------------------- -------- ... flere meldinger utelatt 

Meldingen "Connected to the JHipster Registry config server!" er det vi leter etter her. Dens tilstedeværelse forteller oss at mikroservicen registrerte seg i registeret, og på grunn av dette vil gatewayen kunne rute forespørsler til vår "tilbud" -ressurs og vise den på et hyggelig brukergrensesnitt når vi har opprettet den. Siden vi bruker en mikroservicearkitektur, deler vi denne oppgaven i to deler:

• Lag "tilbud" ressurs back-end-tjenesten
• Opprett brukergrensesnittet "anførselstegn" i frontend (del av gateway-prosjektet)

7.1. Legge til sitatressursen

Først må vi sørg for at tilbudet mikroserviceapplikasjon er stoppet - vi kan trykke CTRL-C på det samme konsollvinduet som vi tidligere brukte til å kjøre det.

La oss nå legge til en enhet i prosjektet ved hjelp av JHipsters verktøy. Denne gangen bruker vi import-jdl kommando, som vil redde oss fra den kjedelige og feilutsatte prosessen med å levere alle detaljer individuelt. For ytterligere informasjon om JDL-formatet, se hele JDL-referansen.

Neste, vi lage en tekstfil som heter sitater.jh inneholder vår Sitat enhetsdefinisjon, sammen med noen kodegenereringsdirektiver:

enhet Sitat {symbol Streng kreves unik, pris BigDecimal kreves, lastTrade ZonedDateTime kreves} dto Sitat med mapstruct paginate Sitat med pagineringstjeneste Sitat med serviceImpl mikroservice Sitat med tilbud Filter filter Sitat clientRootFolder Sitat med tilbud 

Det kan vi nå importer denne enhetsdefinisjonen til prosjektet vårt:

$ jhipster import-jdl quotes.jh 

Merk: under importen vil JHipster klage på en konflikt mens endringene påføres master.xml fil. Vi kan trygt velge overskrive alternativ i dette tilfellet.

Vi kan nå bygge og kjøre vår mikroservice igjen ved hjelp av mvnw. Når det er oppe, kan vi bekrefte at gatewayen henter den nye ruten som går til Inngangsport visning, tilgjengelig fra Administrasjon Meny. Denne gangen kan vi se at det er en oppføring for “/ Sitater / **” rute, hvilkenviser at backend er klar til bruk av brukergrensesnittet.

7.2. Legge til sitatgrensesnittet

Til slutt, la oss generere CRUD UI i gateway-prosjektet som vi bruker for å få tilgang til tilbudene våre. Vi bruker den samme JDL-filen fra "sitater" mikroserviceprosjektet for å generere UI-komponentene, og vi importerer den ved hjelp av JHipsters import-jdl kommando:

$ jhipster import-jdl ../jhipster-quotes/quotes.jh ... meldinger utelatt? Overskrive webpack \ webpack.dev.js? y ... meldinger utelatt Gratulerer, JHipster-utførelsen er fullført! 

Under importen vil JHipster be noen ganger om handlingen den bør ta med hensyn til motstridende filer. I vårt tilfelle kan vi ganske enkelt overskrive eksisterende ressurser, siden vi ikke har gjort noen tilpasninger.

Nå kan vi starte gatewayen på nytt og se hva vi har oppnådd. La oss peke nettleseren vår mot porten på // lokal vert: 8080, og sørger for at vi oppdaterer innholdet. De Enheter menyen skal nå ha en ny oppføring for Sitater ressurs:

Ved å klikke på dette menyalternativet vises Sitater oppføringsskjerm:

Som forventet er oppføringen tom - vi har ikke lagt til noen tilbud ennå! La oss prøve å legge til en ved å klikke på "Opprett ny tilbudsknapp" øverst til høyre på dette skjermbildet, som bringer oss til opprett / rediger skjemaet:

Vi kan se at det genererte skjemaet har alle forventede funksjoner:

• Nødvendige felt er merket med en rød indikator som blir grønn når den er fylt
• Dato / klokkeslett og numeriske felt bruker innfødte komponenter for å hjelpe til med datainnføring
• Vi kan avbryte denne aktiviteten, som vil la data forbli uendret, eller lagre vår nye eller endrede enhet

Etter å ha fylt ut dette skjemaet og slå Lagre, vi får se resultatene på oppføringsskjermen. Vi kan nå se det nye Sitater forekomsti datarutenettet:

Som administrator har vi også tilgang til API-menyelementet, som tar oss med til standard Swagger API Developer Portal. I dette skjermbildet kan vi velge en av de tilgjengelige API-ene som skal utøves:

• misligholde: Gateway sin egen API som viser tilgjengelige ruter
• uaa: Konto- og bruker-API-er
• sitater: Quotes API

8. Neste trinn

Applikasjonen vi hittil har bygget fungerer som forventet og gir et solid grunnlag for videre utvikling. Vi må absolutt også skrive litt (eller mye) tilpasset kode, avhengig av kompleksiteten i våre krav. Noen områder som sannsynligvis trenger litt arbeid er:

• UI-tilpasning: Dette er vanligvis ganske enkelt på grunn av måten frontend-applikasjonen er strukturert - vi kan gå langt ganske enkelt ved å fikle med CSS og legge til noen bilder
• Endringer av brukerregister: Noen organisasjoner har allerede et slags internt brukerregister (f.eks. En LDAP-katalog) - dette vil kreve endringer på UAA, men det fine er at vi bare trenger å endre det en gang
• Finer kornet autorisasjon på enheter:Standardsikkerhetsmodellen som brukes av den genererte enhetens back-end, har ingen slags instansnivå og / eller feltnivåsikkerhet - det er opp til utvikleren å legge til disse begrensningene på riktig nivå (API eller tjeneste, avhengig av tilfelle)

Selv med disse kommentarene kan bruk av et verktøy som JHispter hjelpe mye når du utvikler en ny applikasjon. Det vil gi et solid fundament og kan holde et godt konsistensnivå i kodebasen vår når systemet - og utviklerne - utvikler seg.

9. Konklusjon

I denne artikkelen har vi vist hvordan du bruker JHispter til å lage en fungerende applikasjon basert på en mikrotjenestearkitektur og JHipsters UAA-server. Vi oppnådde det uten å skrive en eneste linje med Java-kode, som er ganske imponerende.

Som vanlig er den fullstendige koden for prosjektene som er presentert i denne artikkelen tilgjengelig i GitHub-depotet vårt.