JHipster con un'architettura di microservizi

1. Introduzione

In questo articolo, esploreremo un esempio interessante con JHipster: la creazione di una semplice architettura di microservizi. Mostreremo come creare e distribuire tutti i componenti necessari e, alla fine, avremo un'applicazione di microservizi completa e funzionante.

Se sei nuovo su JHipster, controlla il nostro articolo introduttivo prima di procedere per avere una buona comprensione delle basi di questo strumento di generazione del progetto.

2. Monolitico vs. microservizio

Nel nostro articolo iniziale, abbiamo illustrato come creare e eseguire il bootstrap di un'applicazione monolitica relativamente facile da mantenere.

Il nostro sistema di microservizi, d'altra parte, separerà il front-end dal back-end che, a sua volta, può anche essere suddiviso in diverse piccole applicazioni, ognuna delle quali si occupa di un sottoinsieme dell'intero dominio dell'applicazione. Naturalmente, come con tutte le implementazioni di microservizi, questo risolve alcuni problemi ma introduce anche una certa complessità, come la gestione del registro dei componenti e della sicurezza.

JHipster si prenderà cura della maggior parte delle difficoltà di gestione delle applicazioni di microservizi, con l'aiuto di moderni strumenti open source come Eureka Server di Netflix e Console di Hashicorp.

Ci sono, ovviamente, alcune cose da considerare qui, come quanto sia grande o complicato il nostro dominio, quanto sia critica la nostra applicazione e quali livelli di disponibilità vogliamo avere, ospiteremo i nostri servizi su diversi server e posizioni , ecc. L'obiettivo di questi strumenti è ovviamente quello di rendere possibili e facili da gestire queste permutazioni.

2.1. Componenti di JHipster Microservice

Quando si lavora su un'architettura Microservice con JHipster, è necessario creare e distribuire almeno tre diversi progetti: un registro JHipster, un Microservice Gateway e almeno un'applicazione Microservice.

Il registro JHipster è una parte essenziale dell'architettura dei microservizi. Collega insieme tutti gli altri componenti e consente loro di comunicare tra loro.

L'applicazione Microservice contiene il codice back-end. Una volta eseguito, esporrà l'API per il dominio di cui è interessato. Un'architettura di microservizi può essere composta da molte applicazioni di microservizi, ciascuna contenente alcune entità correlate e regole di business.

E il Microservice Gateway ha tutto il codice front-end (angolare) e utilizzerà l'API creata dall'intero gruppo di applicazioni di micro servizi:

3. Installazione

Per tutti i dettagli sul processo di installazione, controlla il nostro articolo introduttivo su JHipster.

4. Creazione di un progetto di microservizi

Ora installiamo i tre componenti principali del nostro progetto di microservizi.

4.1. Installazione di JHipster Registry

Poiché JHipster Registry è un JHipster standard, dobbiamo solo scaricarlo ed eseguirlo. Non è necessario modificarlo:

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

Questo clonerà il progetto jhipster -registry da GitHub e avvierà l'applicazione. Una volta avviato correttamente, possiamo visitare // localhost: 8761 / e accedere con utente admin e password admin :

4.2. Installazione di un'applicazione per microservizi

Qui è dove iniziamo a costruire le caratteristiche reali del nostro progetto. In questo esempio, creeremo una semplice applicazione di microservizi che gestisce le auto. Quindi prima creeremo l'applicazione, quindi aggiungeremo un'entità ad essa:

# create a directory for the app and cd to it mkdir car-app && cd car-app # run the jhipster wizard yo jhipster

Una volta avviato il wizard, seguiamo le istruzioni per creare un'applicazione di tipo Microservice denominata carapp . Alcuni altri parametri rilevanti sono:

  • porta: 8081
  • pacchetto: com.car.app
  • autenticazione: JWT
  • rilevamento del servizio: JHipster Registry

Lo screenshot qui sotto mostra il set completo di opzioni:

Ora aggiungeremo un'entità auto alla nostra applicazione:

# runs entity creation wizard yo jhipster:entity car

Verrà avviata la procedura guidata di creazione dell'entità. Dovremmo seguire le istruzioni per creare un'entità chiamata auto con tre campi: marca , modello e prezzo.

Al termine, la nostra prima applicazione Microservice è completa. Se diamo uno sguardo al codice generato, noteremo che non c'è javascript, HTML, CSS o alcun codice front-end. Questi verranno tutti prodotti una volta creato il Microservice Gateway. Inoltre, controlla il file README per informazioni importanti sul progetto e comandi utili.

Per finire, eseguiamo il nostro componente appena creato:

./mvnw

Prima di eseguire il comando precedente, dobbiamo assicurarci che il componente jhipster-registry sia attivo e in esecuzione. Altrimenti, riceveremo un errore.

Se tutto andasse secondo i piani, la nostra app per auto si avvierebbe e il registro del registro jhipster ci dirà che l'app è stata registrata con successo:

Registered instance CARAPP/carapp:746e7525dffa737747dcdcee55ab43f8 with status UP (replication=true)

4.3. Installazione di un Microservice Gateway

Ora il bit di front-end. Creeremo un Microservice Gateway e gli indicheremo che abbiamo un'entità su un componente esistente per il quale vogliamo creare il codice front-end:

# Create a directory for our gateway app mkdir gateway-app && cd gateway-app # Runs the JHipster wizard yo jhipster

Seguiamo le istruzioni per creare un'applicazione di tipo gateway Microservice. Assegneremo un nome al gateway applicazione e selezioneremo le seguenti opzioni per gli altri parametri:

  • porta: 8080
  • pacchetto: com.gateway
  • auth: JWT
  • rilevamento del servizio: JHipster Registry

Ecco un riepilogo del set completo di parametri:

Passiamo alla creazione di entità:

# Runs entity creation wizard yo jhipster:entity car

Quando viene chiesto se si desidera generare da un microservizio esistente, scegliere , quindi digitare il percorso relativo alla directory principale dell'app per auto (es .: ../car-app). Infine, quando ci viene chiesto se vogliamo aggiornare l'entità, scegli Sì, rigenera l'entità .

JHipster troverà il file Car.json che fa parte dell'applicazione Microservice esistente che abbiamo creato in precedenza e utilizzerà i metadati contenuti in quel file per creare tutto il codice UI necessario per quell'entità:

Found the .jhipster/Car.json configuration file, entity can be automatically generated!

È ora di eseguire l' app gateway e verificare se tutto funziona:

# Starts up the gateway-app component ./mvnw

Andiamo ora a // localhost: 8080 / e accedi con l'utente admin e la password admin . Nel menu in alto, dovremmo vedere una voce Auto che ci porterà alla pagina dell'elenco delle auto. Tutto bene!

4.4. Creazione di una seconda applicazione di microservizio

Quindi, portiamo il nostro sistema un ulteriore passo avanti e creiamo un secondo componente di tipo Applicazione microservice . Questo nuovo componente gestirà i concessionari di auto, quindi aggiungeremo un'entità chiamata concessionario .

Creiamo una nuova directory, accediamola ed eseguiamo il comando yo jhipster :

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

Dopodiché, digitiamo dealerapp come nome dell'applicazione e scegliamo la porta 8082 per l'esecuzione (è fondamentale che questa sia una porta diversa da quelle che stiamo utilizzando per il registro jhipster e l' app per auto ).

Per gli altri parametri, possiamo scegliere qualsiasi opzione che vogliamo. Ricorda che questo è un microservizio separato in modo che possa usare diversi tipi di database, strategia di cache e test rispetto al componente car-app .

Aggiungiamo un paio di campi alla nostra entità rivenditore . Ad esempio nome e indirizzo:

# Runs the create entity wizard yo jhipster:entity dealer

Non dovremmo dimenticare di accedere all'app gateway e dirgli di generare il codice front-end per l' entità del rivenditore :

# Navigate to the gateway-app root directory cd ../gateway-app # Runs the create entity wizard yo jhipster:entity dealer

Infine, esegui ./mvnw nella directory principale dell'app del rivenditore per avviare quel componente.

Successivamente, possiamo visitare la nostra applicazione gateway su // localhost: 8080 e aggiornare la pagina per vedere la voce di menu appena creata per l'entità Dealer.

Prima di concludere, diamo di nuovo un'occhiata all'applicazione jhipster-registry su // localhost: 8761 /. Fare clic sulla voce di menu Applicazioni per verificare che tutti i nostri tre componenti siano stati identificati e registrati correttamente:

Questo è tutto! Abbiamo creato un'architettura sofisticata composta da un'app Gateway con tutto il codice front-end supportato da due microservizi in pochi minuti.

5. conclusione

Avviare un progetto di architettura di microservizi con JHipster è abbastanza semplice; abbiamo solo bisogno di creare tutte le applicazioni di microservice di cui abbiamo bisogno e un gateway di microservizi e siamo pronti per partire.

È possibile esplorare ulteriormente il framework sul sito Web ufficiale di JHipster.

Come sempre, la base di codice per la nostra app per auto, app per concessionari e app per gateway sono disponibili su GitHub.