Application orientée microservices avec Spring Cloud OpenFeign

Introduction

Nous mettons en place une application orientée microservices avec Spring Boot et Spring Cloud OpenFeign. Dans cette application nous simulons un scénario de gestion suivant:

Scénario nominal: Un employée est affecté à une adresse <> Scénario alternatif: Si l’adresse n’existe pas, erreur d’enregistrement de l’employé
Scénario nominal: Un projet est affecté à un employé pour une société <> Scénario alternatif: Si l’employé et / ou la société n’existent pas, erreur de création de projet.

L’application est consistituée de deux types microservices:

Quatre microservices métiers pour le fonctionnement de l’application
Deux microservices intermédiaires pour faire fonctionner les microservices métiers

Les répertoires des microservices métiers:

address-microservice
employee-microservice
company-microservice
project-microservice

Les répertoires des microservices qui font fonctionner les microservices métiers:

spring-cloud-gateway-service
eureka-discovery-service

Chaque microservice métier possède ses propres ressources

Sa base de données
Son propre code source
Son propre fichier de configuration

Les modèles de l’application

1) Une adresse (classe Address) est finie par:

   address ID          Long
   numero              int
   street name          String
   city                String 
   country             String

2) Un employée (classe Employee) est défini par:

    employee ID      Long
    firstname        String
    lastname         String
    email            String 
    created date     Date 
    birth country    String
    address          Address

3) Une société (classe Company) est définie par:

    company ID       Long 
    company ame      String 
    company type     Type (Enum: CLIENT/PROSPECT)

4) Un projet (classe Project) est defini par:

    project ID      Long,
    project name    String
    priority        Priority (Enum: P1/P2/P3/...)
    description     String
    starting date   Date,
    state           State (Enum: END/IN_PROGRESS)
    company         Company
    employee        Employee

La figure présente le diagramme de classe de l’application

Communication entre microservices

Pour le fonctionnement de l’applications, les microservices métiers interagissent entre eux. Par exemple:

Le microservice employee-microservice aura besoin du microservice address-microservice pour créer et persister un employée dans la base de données.
Le microservice project-microservice aura besoin des microservices employee-microservice et company-microservice pour périsiter un projet dans la base de données.

Pour faire échanger les données entre microservices nous utilisons le pattern Spring Cloud OpenFeign. openfeign.

Spring Boot RestTemplate vs Spring Cloud OpenFeign

Comparé à Spring Boot RestTemplate, Spring Cloud OpenFeign présente plusieurs avantages:

Avec RestTemplate, un microservice qui a besoin d’appeler un autre microservice doit écrire en dur l’url de ce dernier dans son code source <> Spring Cloud OpenFeign fournit l’autoconfiguration des microservices. Les microservices métiers s’enregistrent dans un service d’annuaire, un microservice qui a besoin d’appeler un autre microservice consulte juste le nom de ce dernier dans l’annuaire via une gateway.
Avec RestTemplate, l’évolutivité de l’application est remise en question parce que RestTemplate se base sur une classe dans laquelle on écrit en dur l’url du microservice qu’on appelle. Ainsi, s’il arrive que le microservice change d’URL, on est obligé de modifier le code source de la classe de l’autre microservice qui utilise le premier microservice <> Spring Cloud OpenFeign assure l’évolutivité de l’application grâce à l’autoconfiguration des microservices métiers. En effet, OpenFeign est basé sur une interface qu’il marque comme un service qui permet aux microservices de s’autoenregistrer.

Déploiement des microservices

Construction d’une image docker pour chaque microservice avec un simple fichier Dockerfile placé à la racine du dossier du microservice.
Lancement avec un fichier docke-compose de la stack des microservices composant toute l’application.

Lancement de l’application

Créer un répertoire que l’on nomme à son choix, projet-microservices par exemple
Cloner le git suivant de l’application dans ce répertoire:
- Dans le terminal, se placer dans ce répetoire
- Saisirgit clonehttps://gitea.natan.fr/placidenduwayo/microservices-with-spring-cloud-openfeign.git`

Tous les microservices métiers et les microservices intermédiaires sont téléchargés dans ce répertoire. Il faut avoir l’application Docker installée sur la machine pour créer les images docker des microservices et docker-compose pour agencer et lancer en une seule ligne de commandes les images de toute l’application. Pour en savoir sur docker et docker-compose, visiter les liens et docker-compose

Dans le terminal:
- se placer dans le répertoire des microservices
- le fichier docker-compose à la racine de ce répertoire contient les Dockerfile des images à créer
- saisir la ligne de commandes :docker-compose build:
  - docker-compose build va builder tout le code source de chaque microservice
  - Ensuite, à partir du Dockerfile de chaque microservice, il créera des images docker pour les microservices Après le build de l’application:
- Toujours dans le répertoire des microservices
- Saisir la ligne de commande: docker-compose up. Cette ligne de commande va lancer toutes les images agencer dans le fichier docker-compose

Microservices intermédiaires

Les microservices eureka-discovery-server et spring-cloud-gateway-service sont de simples applications qui n’exposent aucun Endpoint.

eureka-discovery-server

Ce service joue le rôle de serveur d’annuaire des microservices. eureka-discovery-server est lancé en premier. Lorsqu’ils sont lancés, les microservices métiers address-microservice, employee-microservice, company-microservice et project-microservice s’enregistrent dans l’annuaire. Ils s’enregistrent par leur nom qui a été indiqué dans leur fichier de configuration application.properties. Exemple: spring.application.name = address-service.

Le lien suivant présente la documentation de ce service d’annuaire eureka service registration.

spring-cloud-gateway

Le service gateway spring-cloud-gateway-service peut être lancé avant ou après les microservices métiers. Comme son nom l’indique, il sert de gateway entre le frontend et les microservices métiers en backend.
Dans la requête HTTP, le client a juste besoin de connaître l’adresse de la passerelle et le nom du microservice qu’il veut consommer. Sa requête est de la forme: http://adresse-gateway:port/NOM-MICROSERVICE/endpoint.
Le service gateway va cherche dans l’annuaire de eureka-discovery-server le nom du microservice que le client HTTP a spécifié dans sa requête.
Si la gateway trouve le service demandé, le client peut commencer à consommer le microservice.

La figure suivante présente l’architecture et le fonctionnement de l’application :.

Services offerts par l’application

Le serveur d’annuaire eureka-discover-server possède une page web pour consulter les différents microservices qui se sont enregistrés dans son annuaire.

Avec Postman, on teste l’application avec les services qu’elle met en disposition des clients.

Pour les test nn local, le service gateway demarre sur l’addresse http://localhost:8888/

address-microservice

Dans Postman:

La requête POST pour créer une adresse

[POST]/http://localhost:8888/ADDRESS-SERVICE/addresses

Le body de la requête:

{
    "numHouse": 44,
    "streetName":"Rue notre Dame des Victoires",
    "pb":75002,
    "city":"Paris",
    "country":"France"
}

[GET]/http://localhost:8888/ADDRESS-SERVICE/addresses
[GET]/http://localhost:8888/ADDRESS-SERVICE/addresses/{addressID}
[DELETE]/http://localhost:8888/ADDRESS-SERVICE/addresses/{addressID}
[DELETE]/http://localhost:8888/ADDRESS-SERVICE/addresses

La requête PUT pour modifier une adresse

[PUT]/http://localhost:8888/ADDRESS-SERVICE/addresses/{addressID}

Exemple du body de la requête:


{
    "addressID":1
    "numHouse": 44,
    "streetName":"Rue notre Dame des Victoires",
    "pb":75002,
    "city":"Paris",
    "country":"France"
}

employee-microservice

La requête POST pour créer une employée

[POST]/http://localhost:8888/EMPLOYEE-SERVICE/employees/addresses/{addressID}

Exemple du body de la requête:

{
    "firstname":"Placide",
    "lastname":"Nduwayo",
    "birthCountry":"Burundi"
}

Retour de la requête:

{
    "employeeID": 7,
    "firstname": "Placide",
    "lastname": "NDUWAYO",
    "email": "placide.nduwayo@natan.fr",
    "createdDate": "2022-09-13 : 10:07:52",
    "birthCountry": "Burundi",
    "addressID": 1,
    "address": {
        "addressID": 1,
        "numHouse": 44,
        "streetName": "Rue Notre Dame des Victoires",
        "pb": 75002,
        "city": "Paris",
        "country": "France"
    }
}

[GET]/http://localhost:8888/EMPLOYEES-SERVICE/employees
[GET]/http://localhost:8888/EMPLOYEES-SERVICE/employees
[GET]/http://localhost:8888/EMPLOYEES-SERVICE/employees/addresses/{addressID}
[DELETE]/http://localhost:8888/EMPLOYEES-SERVICE/employees/{employeeID}

La requête PUT pour modifier un employé

[PUT]/http://localhost:8888/EMPLOYEES-SERVICE/employees/{employeeID}

Exemple du body de la requête:

{
     "employeeID": 2,
      "firstname": "David",
      "lastname": "TOUITOU",
      "email": "david.touitou@natan.fr",
      "createdDate": "2022-09-12 : 18:05:41",
      "birthCountry": "Isreal",
      "addressID": 2
 }

company-microservice

Postman:

La requête POST pour créer une société

[POST]/http://localhost:8888/COMPANY-SERVICE/companies

Exemple du body de la requête:

{
    "companyName":"NATAN",
    "companyType":"CLIENT"
}

[GET]/http://localhost:8888/COMPANY-SERVICE/companies
[GET]/http://localhost:8888/COMPANY-SERVICE/companies/{companyID}
[DELETE]/http://localhost:8888/COMPANY-SERVICE/companies/{companyID}
[DELETE]/http://localhost:8888/COMPANY-SERVICE/companies

La requête PUT pour modifier une société

[PUT]/http://localhost:8888/COMPANY-SERVICE/companies/{companyID}

Exemple du body de la requête:

{
    "companyID":1
    "companyName":"NATAN-PARIS",
    "companyType":"CLIENT"
}

project-microservice

Postman:

La requête POST pour créer un projet

[POST]/http://localhost:8888/PROJECT-SERVICE/projects/employees/{employeeID}/companies/{companyID}

Exemple du body de la requête:

 {
    "projectName":"Gestion employees",
    "projectPriority":"P1",
    "description":"La formation des employees au développement backend avec le framework Angular",
    "projectProgress":"END"
}

Retour de la requête:

{
    "projectID": 2,
    "projectName": "TRAINING EMPLOYEES",
    "projectPriority": "P1",
    "createdDate": "2022-09-13 : 10:19:04",
    "description": "La formation des employees au développement backend avec le framework Angular",
    "projectProgress": "END",
    "employeeID": 2,
    "employee": {
        "employeeID": 2,
        "firstname": "David",
        "lastname": "TOUITOU",
        "email": "david.touitou@natan.fr",
        "createdDate": "2022-09-12 : 18:05:41",
        "addressID": 2
    },
    "companyID": 1,
    "company": {
        "companyID": 1,
        "companyName": "NATAN-PARIS",
        "companyType": "CLIENT",
        "createdDate": "2022-09-12: 18:08:48"
    }
}

[GET]/http://localhost:8888/PROJECT-SERVICE/projects
[GET]/http://localhost:8888/PROJECT-SERVICE/projects/{projectID}
[DELETE]/http://localhost:8888/PROJECT-SERVICE/projects/{projectID}
[GET]/http://localhost:8888/PROJECT-SERVICE/projects/employees/{employeeID}
[GET]/http://localhost:8888/PROJECT-SERVICE/projects/companies/{companyID}

La requête PUT pour modifier une un projet

[PUT]/http://localhost:8888/PROJECT-SERVICE/projects/{projectID}

Exemple du body de la requête:

{
    "projectID": 1,
    "projectName": "TRAINING EMPLOYEES",
    "projectPriority": "P1",
    "createdDate": "2022-09-12 : 18:11:20",
    "description": "La formation des employees au développement backend avec le framework Angular",
    "projectProgress": "END",
    "employeeID": 1,
    "companyID": 1
}