JHipster met een microservice-architectuur

1. Inleiding

In dit artikel zullen we een interessant voorbeeld met JHipster onderzoeken: het bouwen van een eenvoudige microservices-architectuur. We laten zien hoe u alle vereiste onderdelen bouwt en implementeert, en uiteindelijk hebben we een volledige microservicetoepassing in gebruik.

Als u nieuw bent bij JHipster, bekijk dan ons inleidende artikel voordat u verder gaat om een ​​goed begrip te hebben van de basisprincipes van deze tool voor het genereren van projecten.

2. Monolithisch vs. microservice

In ons eerste artikel hebben we geïllustreerd hoe u een monolithische applicatie kunt maken en opstarten die relatief eenvoudig te onderhouden is.

Ons microservicesysteem zal daarentegen de front-end en de back-end scheiden, die op hun beurt ook kunnen worden opgesplitst in verschillende kleine applicaties, die elk een subset van het volledige applicatiedomein behandelen. Dit lost natuurlijk, zoals bij alle microservice-implementaties, enkele problemen op, maar brengt ook enige complexiteit met zich mee, zoals het omgaan met componentenregistratie en beveiliging.

JHipster zorgt voor de meeste problemen bij het beheer van de microservicetoepassingen, met behulp van moderne open-sourcehulpmiddelen zoals Netflix's Eureka Server en Hashicorp's Consul.

Er zijn hier natuurlijk een aantal dingen die u moet overwegen, zoals hoe groot of gecompliceerd ons domein is, hoe kritisch onze applicatie is en welke beschikbaarheidsniveaus we willen hebben, gaan we onze services hosten op verschillende servers en locaties , etc. Het doel van deze tools is natuurlijk om deze permutaties mogelijk en gemakkelijk te beheren.

2.1. JHipster Microservice-componenten

Wanneer we met JHipster aan een Microservice-architectuur werken, moeten we ten minste drie verschillende projecten bouwen en implementeren: een JHipster-register, een Microservice-gateway en ten minste één Microservice-applicatie.

Het JHipster-register is een essentieel onderdeel van de microservice-architectuur. Het verbindt alle andere componenten met elkaar en stelt ze in staat met elkaar te communiceren.

De Microservice-applicatie bevat de back-endcode. Als het eenmaal is uitgevoerd, wordt de API weergegeven voor het domein waar het om gaat. Een microservice-architectuur kan bestaan ​​uit een groot aantal microservicetoepassingen, die elk een paar gerelateerde entiteiten en bedrijfsregels bevatten.

En de Microservice Gateway heeft alle front-end (Angular) code en gebruikt de API die is gemaakt door de hele groep microservicetoepassingen:

3. Installatie

Bekijk ons ​​inleidende artikel over JHipster voor alle details over het installatieproces.

4. Een microserviceproject maken

Laten we nu de drie kerncomponenten van ons microserviceproject installeren.

4.1. JHipster Registry installeren

Omdat het JHipster-register een standaard JHipster is, hoeven we het alleen maar te downloaden en uit te voeren. Het is niet nodig om het te wijzigen:

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

Hiermee wordt het jhipster-registratie project van GitHub en start de applicatie. Zodra het succesvol is opgestart, kunnen we // localhost: 8761 / bezoeken en inloggen met de gebruiker beheerder en wachtwoord beheerder:

4.2. Een microservice-applicatie installeren

Hier beginnen we met het bouwen van de feitelijke kenmerken van ons project. In dit voorbeeld maken we een eenvoudige Microservice-applicatie die auto's beheert. Dus eerst maken we de applicatie, en dan voegen we er een entiteit aan toe:

# maak een map voor de app en cd ernaar mkdir auto-app && cd auto-app # voer de jhipster-wizard uit yo jhipster

Nadat de wizard is gestart, volgen we de instructies om een ​​toepassing van het type Microservice te maken met de naam carapp. Enkele andere relevante parameters zijn:

  • poort: 8081
  • pakket: com.car.app
  • authenticatie: JWT
  • service discovery: JHipster Registry

De onderstaande schermafbeelding toont de volledige reeks opties:

Nu gaan we een auto entiteit aan onze applicatie:

# voert de wizard voor het maken van entiteiten uit yo jhipster: entity car

De wizard voor het maken van entiteiten wordt gestart. We moeten de instructies volgen om een ​​entiteit met de naam auto met drie velden: maken, model-, en prijs.

Als dat klaar is, is onze eerste Microservice-applicatie klaar. Als we de gegenereerde code bekijken, zullen we zien dat er geen javascript, HTML, CSS of enige front-end code is. Deze zullen allemaal worden geproduceerd zodra de Microservice Gateway is gemaakt. Bekijk ook het README-bestand voor belangrijke informatie over het project en handige opdrachten.

Laten we om af te sluiten onze nieuw gemaakte component uitvoeren:

./mvnw

Voordat u de bovenstaande opdracht uitvoert, moeten we ervoor zorgen dat het jhipster-registry component is actief. Anders krijgen we een foutmelding.

Als alles volgens plan is verlopen, onze auto-app zou beginnen, en de jhipster-registry log zal ons vertellen dat de app met succes is geregistreerd:

Geregistreerd exemplaar CARAPP / carapp: 746e7525dffa737747dcdcee55ab43f8 met status UP (replicatie = true)

4.3. Een Microservice Gateway installeren

Nu het front-end bit. We maken een Microservice Gateway en geven aan dat we een entiteit hebben op een bestaande component waarvoor we de front-end code willen maken:

# Maak een map voor onze gateway-app mkdir gateway-app && cd gateway-app # Start de JHipster-wizard yo jhipster

Laten we de instructies volgen om een ​​toepassing van het type Microservice-gateway te maken. We noemen de applicatie poorten selecteer de volgende opties voor de andere parameters:

  • poort: 8080
  • pakket: com.gateway
  • auth: JWT
  • service discovery: JHipster Registry

Hier is een samenvatting van de volledige set parameters:

Laten we verder gaan met het maken van entiteiten:

# Voert wizard voor het maken van entiteiten uit yo jhipster: entity car

Als u wordt gevraagd of we willen genereren vanuit een bestaande microservice, kiest u Ja, typ vervolgens het relatieve pad naar het auto-app root-directory (bijv .: ../car-app). Als u ten slotte wordt gevraagd of we de entiteit willen bijwerken, kiest u Ja, genereer de entiteit opnieuw.

JHipster zal het Car.json bestand dat deel uitmaakt van de bestaande Microservice-applicatie die we eerder hebben gemaakt en de metadata in dat bestand zal gebruiken om alle benodigde UI-code voor die entiteit te maken:

Het .jhipster / Car.json-configuratiebestand gevonden, entiteit kan automatisch worden gegenereerd!

Tijd om het gateway-app en test of alles werkt:

# Start de gateway-app-component ./mvnw

Laten we nu navigeren naar // localhost: 8080 / en inloggen met de gebruiker beheerder en wachtwoord beheerder. In het bovenste menu zouden we een item moeten zien Auto dat brengt ons naar de autolijstpagina. Alles goed!

4.4. Een tweede microservicetoepassing maken

Laten we vervolgens ons systeem een ​​stap verder brengen en maak een tweede component van het type Microservice-applicatie. Dit nieuwe onderdeel beheert autodealers, dus we voegen een entiteit toe met de naam dealer eraan.

Laten we een nieuwe map maken, ernaar navigeren en het yo jhipster opdracht:

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

Daarna typen we in dealerapp als de naam van de toepassing en kies poort 8082 om het te laten draaien (het is van cruciaal belang dat dit een andere poort is dan degene die we gebruiken voor de jhipster-register en auto-app).

Voor de andere parameters kunnen we elke gewenste optie kiezen. Onthoud dat dit een aparte microservice is, zodat deze andere databasetypen, cachestrategie en tests kan gebruiken dan de auto-app component.

Laten we een paar velden aan ons toevoegen dealer entiteit. Bijvoorbeeld naam en adres:

# Start de wizard voor het maken van een entiteit yo jhipster: entiteit dealer

We moeten niet vergeten te navigeren naar gateway-app en vertel het om de front-end code voor het dealer entiteit:

# Navigeer naar de gateway-app root directory cd ../gateway-app # Start de create entity wizard yo jhipster: entity dealer

Ten slotte rennen ./mvnw op de dealer-app root directory om die component op te starten.

Vervolgens kunnen we onze gateway-applicatie bezoeken op // localhost: 8080 en de pagina vernieuwen om het nieuw gemaakte menu-item voor de entiteit Dealer te zien.

Laten we, voordat we afronden, eens kijken naar het jhipster-registry applicatie opnieuw op // localhost: 8761 /. Klik op het menu-item Toepassingen om te controleren of al onze drie componenten met succes zijn geïdentificeerd en geregistreerd:

Dat is het! We hebben een geavanceerde architectuur gemaakt die bestaat uit één Gateway-app met alle front-end-code in slechts enkele minuten ondersteund door twee microservices.

5. Conclusie

Het starten van een Microservice Architecture-project met JHipster is vrij eenvoudig; we hoeven maar zoveel Microservice-applicaties te maken als we nodig hebben en één Microservice Gateway, en we zijn klaar om te gaan.

U kunt het raamwerk verder verkennen op de officiële JHipster-website.

Zoals altijd is de codebase voor onze auto-app, dealer-app en gateway-app beschikbaar op GitHub.