Créez un nouveau projet Spring Boot et ajoutez l'annotation @EnableEurekaServer sur la classe principale pour activer le registre.

serveur:
  port: 8761

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8761/eureka
    register-with-eureka: false
    fetch-registry: false

Après avoir lancé l'application, l'interface web du registre Eureka sera accessible via le navigateur à l'adresse http://localhost:8761.

Création du microservice fournisseur (Provider)

Générez un second module Spring Boot qui agira en tant que service exposant des API. Configurez son fichier application.yml pour qu'il s'enregistre auprès du serveur Eureka.

serveur:
  port: 8090

spring:
  application:
    name: ms-provider

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8761/eureka
    register-with-eureka: true
    fetch-registry: true
  instance:
    prefer-ip-address: true
    instance-id: ${spring.cloud.client.ip-address}:${server.port}

Implémantez un contrôleur REST dans ce service pour simuler la fourniture de données :

package com.example.msprovider.controller;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class FournisseurController {

    @GetMapping("/data")
    public String obtenirDonnees() {
        return "Données du fournisseur";
    }

    @GetMapping("/data/{identifiant}")
    public String obtenirDonneesParId(@PathVariable("identifiant") String id) {
        return "Données fournies : " + id;
    }

    @PostMapping("/data")
    public String creerDonnees(@RequestParam("titre") String titre, @RequestParam("taille") Integer taille) {
        return "Création réussie : " + titre + ", Taille : " + taille;
    }
}

Création du microservice consommateur (Consumer) avec Feign

Créez un troisième module Spring Boot. Ce service devra appeler le microservice fournisseur. Pour cela, nous utilisons Feign, un client HTTP déclaratif. Ajoutez les annotaitons @EnableEurekaClient et @EnableFeignClients sur la classe principale.

Configurez le application.yml de ce consommateur. Il est important de noter que Feign utilise Ribbon par défaut, avec un délai d'attente de 1 seconde. Pour éviter des erreurs de timeout lors de traitements longs, augmentez ces valeurs :

serveur:
  port: 8091

spring:
  application:
    name: ms-consumer

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8761/eureka
    register-with-eureka: true
    fetch-registry: true
  instance:
    prefer-ip-address: true
    instance-id: ${spring.cloud.client.ip-address}:${server.port}

ribbon:
  ReadTimeout: 5000
  ConnectTimeout: 5000

Déclarez une interface Feign qui mapppera les méthodes du microservice fournisseur. Le nom spécifié dans @FeignClient doit correspondre exactement au spring.application.name du service cible (ici ms-provider).

package com.example.msconsumer.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

@FeignClient("MS-PROVIDER")
public interface FournisseurProxy {

    @GetMapping("/api/data")
    String obtenirDonnees();

    @GetMapping("/api/data/{identifiant}")
    String obtenirDonneesParId(@PathVariable("identifiant") String id);

    @PostMapping("/api/data")
    String creerDonnees(@RequestParam("titre") String titre, @RequestParam("taille") Integer taille);
}

Injectez ce proxy dans le contrôleur du consommateur pour effectuer les appels distants :

package com.example.msconsumer.controller;

import com.example.msconsumer.client.FournisseurProxy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/proxy")
public class ConsommateurController {

    @Autowired
    private FournisseurProxy proxy;

    @GetMapping("/lancer")
    public String lancerAppel() {
        return "Proxy -> " + proxy.obtenirDonnees();
    }

    @GetMapping("/lancer/{id}")
    public String lancerAppelParam(@PathVariable("id") String id) {
        return "Proxy -> " + proxy.obtenirDonneesParId(id);
    }

    @PostMapping("/lancer")
    public String lancerAppelPost(@RequestParam("titre") String titre, @RequestParam("taille") Integer taille) {
        return "Proxy -> " + proxy.creerDonnees(titre, taille);
    }
}

Lors du démarrage de plusieurs modules dans IntelliJ IDEA, il est possible d'activer le tableau de bord d'exécution (Run Dashboard) pour gérer facilement les instances. Pour cela, modifiez le fichier workspace.xml situé dans le dossier .idea du projet en y insérant la configuration suivante :

<component name="RunDashboard">
  <option name="configurationTypes">
    <set>
      <option value="SpringBootApplicationConfigurationType" />
    </set>
  </option>
</component>

Une fois le serveur Eureka, le fournisseur et le consommateur démarrés, testez les endpoints du consommateur. L'adresse http://localhost:8091/proxy/lancer renverra le résultat de l'appel au service distant. Les passages de paramètres en GET et POST fonctionnent de la même manière, via les interfaces mappées par Feign.