Introduction à Ribbon pour les appels de microservices

Ribbon est une bibliothèque d'équilibrage de charge publiée par Netflix, conçue pour contrôler le cmoportement des clients HTTP et TCP. Une fois l'adresse des fournisseurs de services configurée, Ribbon peut automatiquement distribuer les requêtes des consommateurs vers différents fournisseurs en appliquant un algorithme d'équilibrage de charge, tel que le round-robin ou la sélection aléatoire. Dans Spring Cloud, lorsqu'il est intégré avec Eureka, Ribbon peut récupérer dynamiquement la liste des instances de service depuis le serveur Eureka.

Configuration initiale

Ribbon fonctionne côté client, il doit donc être intégré dans le projet consommateur. On commence par ajouter les dépendances nécessaires dans le fichier pom.xml du module consommateur.

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>

Le fichier application.yml du consommateur est ensuite configuré pour désactiver l'enregistrement auprès d'Eureka et pointer vers le serveur de découverte.

server:
  port: 8080
spring:
  application:
    name: consommateur-etudiant
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka-server:8761/eureka/

La configuraton du contexte Spring doit inclure l'annotation @LoadBalanced sur le bean RestTemplate pour activer l'équilibrage de charge, et la classe d'application doit être annotée avec @EnableEurekaClient.

@Configuration
public class ConfigClient {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@SpringBootApplication
@EnableEurekaClient
public class ApplicationConsommateur {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationConsommateur.class, args);
    }
}

Équilibrage de charge avec Ribbon

Pour démontrer l'équilibrage de charge, il est nécessaire de déployer un cluster de fournisseurs de services. On crée plusieurs instances d'un même service, par exemple fournisseur-etudiant, avec des numéros de port différents (par ex. 9001, 9002, 9003).

Le fichier de configuration YAML pour chaque instance de fournisseur utilise un profil pour différencier les ports et identifiants d'instance.

spring:
  profiles:
    active: instance-9001
---
spring:
  profiles: instance-9001
server:
  port: 9001
eureka:
  instance:
    instance-id: fournisseur-etudiant:9001
---
spring:
  profiles: instance-9002
server:
  port: 9002
eureka:
  instance:
    instance-id: fournisseur-etudiant:9002
---
spring:
  profiles: instance-9003
server:
  port: 9003
eureka:
  instance:
    instance-id: fournisseur-etudiant:9003

Chaque instance de fournisseur expose un endpoint qui retourne son numéro de port, permettant de visualiser l'équilibrage. Le consommateur peut alors appeler ce service via l'URL du service (http://FOURNISSEUR-ETUDIANT/port).

Pour personnaliser la stratégie d'équilibrage, on peut définir un bean IRule dans la configuration du consommateur. Par exemple, pour utiliser une stratégie de réessai en cas d'échec (RetryRule).

@Bean
public IRule strategieEquilibrage() {
    return new RetryRule();
}

Introduction à Feign et intégration

Feign est un client web déclaratif qui simplifie l'écriture d'appels aux services. Il s'appuie sur des annotations sur des interfaces Java et intègre Ribbon et Eureka pour l'équilibrage de charge. Contrairement à l'approche avec RestTemplate de manière directe, Feign centralise la définition des appels dans une interface.

Création d'un client Feign dans le module commun

Dans un module partagé (commun), on ajoute la dépendance Feign et on définit une interface client pour le service cible.

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

@FeignClient(name = "FOURNISSEUR-ETUDIANT")
public interface ClientServiceEtudiant {
    @GetMapping("/etudiants/{id}")
    Etudiant recupererParId(@PathVariable("id") Long id);

    @GetMapping("/etudiants")
    List<Etudiant> listerTous();

    @PostMapping("/etudiants")
    boolean sauvegarder(@RequestBody Etudiant etudiant);
}

Développement d'un consommateur utilisant Feign

On crée un nouveau module consommateur (consommateur-etudiant-feign) qui référence le module commun. Le fichier pom.xml inclut les dépendances pour Feign, Eureka et Ribbon. Le contrôleur du consommateur injecte alors l'interface ClientServiceEtudiant pour efffectuer les appels.

@RestController
@RequestMapping("/api")
public class ControleurConsommateur {
    @Autowired
    private ClientServiceEtudiant clientServiceEtudiant;

    @GetMapping("/etudiants/{id}")
    public Etudiant obtenirEtudiant(@PathVariable Long id) {
        return clientServiceEtudiant.recupererParId(id);
    }

    @GetMapping("/etudiants")
    public List<Etudiant> listerEtudiants() {
        return clientServiceEtudiant.listerTous();
    }
}

La classe principale du consommateur doit être annotée avec @EnableFeignClients pour activer le scan des interfaces Feign.

@SpringBootApplication
@EnableFeignClients(basePackages = "com.exemple.commun.clients")
public class ApplicationConsommateurFeign {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationConsommateurFeign.class, args);
    }
}