JHipster avec une architecture de microservices

1. Introduction

Dans cet article, nous explorerons un exemple intéressant avec JHipster - la construction d'une architecture de microservices simple. Nous montrerons comment créer et déployer toutes les pièces requises, et à la fin, nous aurons une application de microservice à part entière opérationnelle.

Si vous êtes nouveau sur JHipster, veuillez consulter notre article d'introduction avant de continuer pour avoir une bonne compréhension des bases de cet outil de génération de projet.

2. Monolithique ou microservice

Dans notre article initial, nous avons illustré comment créer et amorcer une application monolithique relativement facile à maintenir.

Notre système de microservices, en revanche, séparera le front-end du back-end qui, à son tour, peut également être divisé en plusieurs petites applications, chacune traitant un sous-ensemble du domaine d'application complet. Naturellement, comme pour toutes les implémentations de microservices, cela résout certains problèmes mais introduit également une certaine complexité, comme la gestion du registre des composants et de la sécurité.

JHipster s'occupera de la plupart des difficultés de gestion des applications de microservices, à l'aide d'outils open-source modernes comme Eureka Server de Netflix et Consul de Hashicorp.

Il y a, bien sûr, certains éléments à prendre en compte ici, comme la taille ou la complexité de notre domaine, la gravité de notre application et les niveaux de disponibilité que nous voulons avoir, allons-nous héberger nos services sur différents serveurs et emplacements , etc. Le but de ces outils est bien entendu de rendre ces permutations possibles et faciles à gérer.

2.1. Composants JHipster Microservice

Lorsque vous travaillez sur une architecture Microservice avec JHipster, nous devons créer et déployer au moins trois projets différents: un registre JHipster, une passerelle Microservice et au moins une application Microservice.

Le registre JHipster est un élément essentiel de l'architecture des microservices. Il relie tous les autres composants ensemble et leur permet de communiquer entre eux.

L'application Microservice contient le code back-end. Une fois en cours d'exécution, il exposera l'API du domaine concerné. Une architecture de microservices peut être composée de nombreuses applications de microservices, chacune contenant quelques entités et règles métier associées.

Et la passerelle Microservice a tout le code frontal (angulaire) et consommera l'API créée par l'ensemble du groupe d'applications de micro-service:

3. Installation

Pour tous les détails sur le processus d'installation, consultez notre article d'introduction sur JHipster.

4. Création d'un projet de microservice

Maintenant, installons les trois composants principaux de notre projet de microservice.

4.1. Installation du registre JHipster

Étant donné que le registre JHipster est un JHipster standard, il nous suffit de le télécharger et de l'exécuter. Il n'est pas nécessaire de le modifier:

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

Cela clonera le projet jhipster -registry à partir de GitHub et démarrera l'application. Une fois le démarrage réussi, nous pouvons visiter // localhost: 8761 / et nous connecter avec l'utilisateur admin et le mot de passe admin :

4.2. Installation d'une application de microservice

C'est ici que nous commençons à construire les fonctionnalités réelles de notre projet. Dans cet exemple, nous allons créer une application Microservice simple qui gère les voitures. Nous allons donc d'abord créer l'application, puis nous y ajouterons une entité:

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

Une fois l'assistant lancé, suivons les instructions pour créer une application de type Microservice nommée carapp . Certains autres paramètres pertinents sont:

  • port: 8081
  • paquet: com.car.app
  • authentification: JWT
  • découverte de service: Registre JHipster

La capture d'écran ci-dessous montre l'ensemble complet des options:

Nous allons maintenant ajouter une entité voiture à notre application:

# runs entity creation wizard yo jhipster:entity car

L'assistant de création d'entité démarre. Nous devons suivre les instructions pour créer une entité nommée la voiture avec trois champs: marque , modèle et prix.

Une fois que c'est terminé, notre première application Microservice est terminée. Si nous regardons le code généré, nous remarquerons qu'il n'y a pas de javascript, HTML, CSS ou tout autre code frontal. Ceux-ci seront tous produits une fois la passerelle de microservice créée. Consultez également le fichier README pour obtenir des informations importantes sur le projet et des commandes utiles.

Pour finir, exécutons notre composant nouvellement créé:

./mvnw

Avant d'exécuter la commande ci-dessus, nous devons nous assurer que le composant jhipster-registry est opérationnel. Sinon, nous aurons une erreur.

Si tout se passait comme prévu, notre application de voiture démarrerait et le journal jhipster-registry nous indiquera que l'application a été enregistrée avec succès:

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

4.3. Installation d'une passerelle de microservice

Maintenant, le bit frontal. Nous allons créer une passerelle Microservice et lui indiquer que nous avons une entité sur un composant existant pour lequel nous voulons créer le code frontal:

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

Suivons les instructions pour créer une application de type passerelle Microservice. Nous nommerons la passerelle d' application et sélectionnerons les options suivantes pour les autres paramètres:

  • port: 8080
  • paquet: com.gateway
  • auth: JWT
  • découverte de service: Registre JHipster

Voici un résumé de l'ensemble complet de paramètres:

Passons à la création d'entités:

# Runs entity creation wizard yo jhipster:entity car

Lorsqu'on vous demande si nous voulons générer à partir d'un microservice existant, choisissez Oui , puis saisissez le chemin relatif vers le répertoire racine car-app (ex .: ../car-app). Enfin, lorsqu'on vous demande si nous voulons mettre à jour l'entité, choisissez Oui, régénérer l'entité .

JHipster trouvera le fichier Car.json qui fait partie de l'application Microservice existante que nous avons créée précédemment et utilisera les métadonnées contenues dans ce fichier pour créer tout le code d'interface utilisateur nécessaire pour cette entité:

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

Il est temps d'exécuter l' application de passerelle et de tester si tout fonctionne:

# Starts up the gateway-app component ./mvnw

Naviguons maintenant vers // localhost: 8080 / et connectez-vous avec l'utilisateur admin et le mot de passe admin . Dans le menu supérieur, nous devrions voir un élément Voiture qui nous mènera à la page de la liste des voitures. Tout bon!

4.4. Création d'une deuxième application de microservice

Ensuite, poussons notre système un peu plus loin et créons un deuxième composant de type Microservice Application . Ce nouveau composant gérera les concessionnaires automobiles, nous y ajouterons donc une entité appelée concessionnaire .

Créons un nouveau répertoire, accédez-y et exécutez la commande yo jhipster :

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

Après cela, nous tapons dealerapp comme nom de l'application et choisissons le port 8082 pour qu'elle s'exécute (il est essentiel que ce soit un port différent de ceux que nous utilisons pour le registre jhipster et l' application voiture ).

Pour les autres paramètres, nous pouvons choisir n'importe quelle option que nous voulons. N'oubliez pas qu'il s'agit d'un microservice distinct afin qu'il puisse utiliser différents types de base de données, stratégie de cache et tests que le composant car-app .

Ajoutons quelques champs à notre entité concessionnaire . Par exemple nom et adresse:

# Runs the create entity wizard yo jhipster:entity dealer

Nous ne devons pas oublier de naviguer vers gateway-app et lui dire de générer le code frontal pour l' entité concessionnaire :

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

Enfin, exécutez ./mvnw sur le répertoire racine de l' application dealer pour démarrer ce composant.

Ensuite, nous pouvons visiter notre application de passerelle à // localhost: 8080 et actualiser la page pour voir l'élément de menu nouvellement créé pour l'entité Dealer.

Avant de terminer, jetons à nouveau un coup d'œil à l' application jhipster-registry à // localhost: 8761 /. Cliquez sur l'élément de menu Applications pour vérifier que tous nos trois composants ont été correctement identifiés et enregistrés:

C'est ça! Nous avons créé une architecture sophistiquée composée d'une application Gateway avec tout le code frontal soutenu par deux microservices en quelques minutes.

5. Conclusion

Démarrer un projet d'architecture de microservice avec JHipster est assez simple; il nous suffit de créer autant d'applications microservices que nécessaire et une passerelle microservice et nous sommes prêts à partir.

Vous pouvez explorer le cadre plus loin sur le site officiel de JHipster.

Comme toujours, la base de code pour notre application de voiture, notre application de concessionnaire et notre application de passerelle sont disponibles sur GitHub.