streamalism.org

1. Introduksjon

I denne oppskriften vil vi utforske et interessant eksempel med JHipster - å bygge en enkel mikrotjenestearkitektur. Vi viser hvordan du bygger og distribuerer alle nødvendige brikker, og til slutt har vi et fullverdig mikroserviceapplikasjon i gang.

Hvis du er ny i JHipster, kan du sjekke vår innledende artikkel før du fortsetter for å ha en god forståelse av det grunnleggende i dette verktøyet for prosjektgenerering.

2. Monolitisk vs. mikroservice

I vår første artikkel illustrerte vi hvordan du oppretter og starter en monolitisk applikasjon som er relativt enkel å vedlikeholde.

Vårt mikroservicesystem vil derimot skille frontend-back-enden, som i sin tur også kan deles i flere små applikasjoner, som hver har et undergruppe av hele applikasjonsdomenet. Naturligvis, som med alle implementeringer av mikroservice, løser dette noen problemer, men introduserer også noe kompleksitet, for eksempel å håndtere komponentregister og sikkerhet.

JHipster vil ta seg av de fleste vanskeligheter med å administrere mikroserviceapplikasjonene, ved hjelp av moderne open source-verktøy som Netflix Eureka Server og Hashicorps konsul.

Det er selvfølgelig noen ting å vurdere her, som hvor stort eller komplisert domenet vårt er, hvor kritisk er applikasjonen vår og hvilke nivåer av tilgjengelighet vi ønsker å ha, skal vi være vert for tjenestene våre på forskjellige servere og steder osv. Målet med disse verktøyene er selvfølgelig at disse permutasjonene er mulige og enkle å administrere.

2.1. JHipster Microservice-komponenter

Når vi jobber med en Microservice-arkitektur med JHipster, må vi bygge og distribuere minst tre forskjellige prosjekter: et JHipster-register, en Microservice Gateway og minst en Microservice-applikasjon.

JHipster-registeret er en viktig del av mikroservicearkitekturen. Den binder alle de andre komponentene sammen og gjør det mulig for dem å kommunisere med hverandre.

Microservice-applikasjonen inneholder back-end-koden. Når den er kjørt, vil den avsløre API-et for domenet det er opptatt av. En mikroservicearkitektur kan være sammensatt av mange mikroserviceapplikasjoner, som hver inneholder noen relaterte enheter og forretningsregler.

Og Microservice Gateway har all front-end (Angular) -koden og vil konsumere API-en som er opprettet av hele gruppen av mikrotjenesteapplikasjoner:

3. Installasjon

For alle detaljer om installasjonsprosessen, se vår innledende artikkel om JHipster.

4. Opprette et mikroserviceprosjekt

La oss nå installere de tre kjernekomponentene i mikroserviceprosjektet vårt.

4.1. Installere JHipster Registry

Siden JHipster Registry er en standard JHipster, så vi trenger bare å laste ned og kjøre den. Det er ikke nødvendig å endre det:

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

Dette vil klone jhipster-registrering prosjekt fra GitHub og start applikasjonen. Når den har startet, kan vi besøke // localhost: 8761 / og logge på med brukeren admin og passord admin:

4.2. Installere et Microservice-program

Her begynner vi å bygge de faktiske funksjonene i prosjektet vårt. I dette eksemplet lager vi et enkelt Microservice-program som administrerer biler. Så først lager vi applikasjonen, og deretter legger vi til en enhet i den:

# opprett en katalog for appen og cd til den mkdir bil-app && cd bil-app # kjør jhipster-veiviseren yo jhipster

Når veiviseren starter, la oss følge instruksjonene for å opprette et Microservice-program som heter carapp. Noen andre relevante parametere er:

• port: 8081
• pakke: com.car.app
• autentisering: JWT
• tjenesteoppdagelse: JHipster Registry

Skjermbildet nedenfor viser det komplette settet med alternativer:

Nå legger vi til en bil enhet til søknaden vår:

# kjører veiviser for opprettelse av enheter yo jhipster: enhetsbil

Veiviseren for opprettelse av enheter starter. Vi bør følge instruksjonene for å opprette en enhet som heter bil med tre felt: gjøre, modell, og pris.

Når det er ferdig, er vår første Microservice-applikasjon fullført. Hvis vi ser på den genererte koden, vil vi merke at det ikke er noe javascript, HTML, CSS eller noen front-end-kode. Disse vil alle bli produsert når Microservice Gateway er opprettet. Sjekk også ut README-filen for viktig informasjon om prosjektet og nyttige kommandoer.

For å fullføre, la oss kjøre den nyopprettede komponenten:

./mvnw

Før du kjører kommandoen ovenfor, bør vi sørge for at jhipster-register komponenten er i gang. Ellers får vi en feil.

Hvis alt gikk etter planen, vår bil-app ville starte, og jhipster-register loggen vil fortelle oss at appen ble registrert:

Registrert forekomst CARAPP / carapp: 746e7525dffa737747dcdcee55ab43f8 med status UP (replikering = sann)

4.3. Installere en Microservice Gateway

Nå frontend-biten. Vi oppretter en Microservice Gateway og indikerer for den at vi har en enhet på en eksisterende komponent som vi vil lage front-end-koden for:

# Opprett en katalog for vår gateway-app mkdir gateway-app && cd gateway-app # Kjører JHipster-veiviseren yo jhipster

La oss følge instruksjonene for å lage en applikasjon av typen Microservice gateway. Vi gir navnet på søknaden inngangsport, og velg følgende alternativer for de andre parametrene:

• port: 8080
• pakke: com. gateway
• auth: JWT
• tjenesteoppdagelse: JHipster Registry

Her er et sammendrag av det komplette settet med parametere:

La oss gå videre til opprettelse av enheter:

# Kjører veiviser for opprettelse av enheter yo jhipster: enhetsbil

Når du blir spurt om vi vil generere fra en eksisterende mikrotjeneste, velger du Ja, skriv deretter inn den relative banen til bil-app rotkatalog (eks .: ../bilapp). Til slutt, når du blir spurt om vi vil oppdatere enheten, velg Ja, regenerer enheten.

JHipster vil finne Bil.json filen som er en del av det eksisterende Microservice-programmet vi har opprettet tidligere, og vil bruke metadataene i filen til å opprette all nødvendig UI-kode for den enheten:

Fant konfigurasjonsfilen .jhipster / Car.json, enheten kan genereres automatisk!

På tide å kjøre gateway-app og test om alt fungerer:

# Starter gateway-app-komponenten ./mvnw

La oss nå navigere til // localhost: 8080 / og logge på med brukeren admin og passord admin. På toppmenyen skal vi se et element Bil som tar oss til siden med bilisten. Helt fint!

4.4. Opprette et annet Microservice-program

Neste, la oss ta systemet vårt et skritt videre og lage en andre komponent av typen Microservice Application. Denne nye komponenten vil administrere bilforhandlere, så vi legger til en enhet som heter forhandler til det.

La oss opprette en ny katalog, navigere til den og kjøre yo jhipster kommando:

mkdir forhandler-app && cd forhandler-app yo jhipster

Etter det skriver vi inn dealerapp som applikasjonens navn og velg port 8082 for at den skal kjøre (det er viktig at dette er en annen port enn den vi bruker til jhipster-register og bil-app).

For de andre parametrene kan vi velge hvilket som helst alternativ vi ønsker. Husk at dette er en egen mikrotjeneste slik at den kan bruke forskjellige databasetyper, cache-strategi og tester enn bil-app komponent.

La oss legge til et par felt i vårt forhandler enhet. For eksempel Navn og adresse:

# Kjører veiviseren for oppretting av enhet yo jhipster: enhetsforhandler

Vi bør ikke glemme å navigere til gateway-app og be den generere frontend-koden for forhandler enhet:

# Naviger til gateway-appens rotkatalog cd ../gateway-app # Kjører veiviseren for oppretting av enhet yo jhipster: enhetsforhandler

Til slutt, løp ./mvnw på forhandler-app rotkatalog for å starte den komponenten.

Deretter kan vi besøke gateway-applikasjonen vår på // localhost: 8080 og oppdatere siden for å se det nylig opprettede menyelementet for forhandlerenheten.

La oss ta en titt på før vi avslutter jhipster-register søknad igjen på // localhost: 8761 /. Klikk på menyelementet Programmer for å kontrollere at alle våre tre komponenter ble identifisert og registrert:

Det er det! Vi har laget en sofistikert arkitektur som består av en Gateway-app med all front-end-koden støttet av to mikrotjenester på bare noen få minutter.

5. Konklusjon

Å starte et Microservice Architecture-prosjekt med JHipster er ganske enkelt; vi trenger bare å lage så mange Microservice-applikasjoner som vi trenger, og en Microservice Gateway, og vi er klare til å gå.

Du kan utforske rammeverket videre på det offisielle JHipster-nettstedet.

Som alltid er kodebasen for vår bil-app, forhandler-app og gateway-app tilgjengelig på GitHub.