DISCOVERY SERVICE : EUREKA

Définition

Eureka est un service de découverte de services développé par Netflix et intégré à Spring Cloud. Il permet aux micro-services de s'enregistrer automatiquement et de découvrir dynamiquement les autres services dans une architecture distribuée.

Eureka fonctionne sur le principe de "serveur-client" où le serveur Eureka maintient un registre des services disponibles et les clients Eureka s'enregistrent périodiquement auprès du serveur.

Architecture d'Eureka

  • Eureka Server : Serveur central qui maintient le registre des services
  • Eureka Client : Services qui s'enregistrent auprès du serveur
  • Heartbeat : Mécanisme de vérification de disponibilité des services
  • Ribbon : Client de load balancing intégré
  • Zone Awareness : Support pour la répartition géographique
  • Self Preservation : Mode de préservation en cas de défaillance réseau
🖥️
EUREKA SERVER

Serveur central qui maintient un registre des instances de services disponibles. Il reçoit les enregistrements des services et permet leur découverte dynamique.

Fonction: Registre central des services

Configuration Eureka Server

// pom.xml - Dépendances Eureka Server
<dependency>
  <groupId>org.springframework.cloudgroupId>
  <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
dependency>

// EurekaServerApplication.java
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
  public static void main(String[] args) {
    SpringApplication.run(EurekaServerApplication.class, args);
  }
}

// application.yml - Configuration Eureka Server
server:
  port: 8761
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  server:
    enable-self-preservation: true
    eviction-interval-timer-in-ms: 5000
    response-cache-update-interval-ms: 3000
    use-read-only-response-cache: true
spring:
  application:
    name: eureka-server
🔌
EUREKA CLIENT

Services qui s'enregistrent auprès du serveur Eureka et peuvent découvrir d'autres services. Chaque client envoie périodiquement des "heartbeats" pour signaler sa disponibilité.

Fonction: Enregistrement et découverte de services

Configuration Eureka Client

// pom.xml - Dépendances Eureka Client
<dependency>
  <groupId>org.springframework.cloudgroupId>
  <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
dependency>

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

// application.yml - Configuration Eureka Client
server:
  port: 8080
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
    register-with-eureka: true
    fetch-registry: true
    registry-fetch-interval-seconds: 30
    instance-info-replication-interval-seconds: 30
    initial-instance-info-replication-interval-seconds: 40
  instance:
    prefer-ip-address: true
    ip-address: 192.168.1.100
    instance-id: ${spring.application.name}:${server.port}
    lease-renewal-interval-in-seconds: 30
    lease-expiration-duration-in-seconds: 90
spring:
  application:
    name: user-service
💓
HEARTBEAT & RENEWAL

Mécanisme de vérification de disponibilité des services. Chaque client envoie périodiquement des "heartbeats" au serveur pour signaler qu'il est toujours actif.

Fonction: Surveillance de la disponibilité

Configuration Heartbeat

// Paramètres de configuration du heartbeat
eureka:
  instance:
    # Intervalle d'envoi du heartbeat (en secondes)
    lease-renewal-interval-in-seconds: 30
    # Durée avant expiration de l'instance (en secondes)
    lease-expiration-duration-in-seconds: 90
    # Délai initial avant le premier heartbeat
    initial-registration-replication-delay-seconds: 40
  client:
    # Intervalle de mise à jour du registre local
    registry-fetch-interval-seconds: 30
    # Intervalle de réplication des informations d'instance
    instance-info-replication-interval-seconds: 30
    # Délai initial avant la première réplication
    initial-instance-info-replication-interval-seconds: 40

// Surveillance des heartbeats dans les logs
/*
INFO [user-service] Renewing Leases
INFO [user-service] DiscoveryClient_USER-SERVICE:localhost:user-service:8080 - Heartbeat success
INFO [eureka-server] DS: Registry: 3 instances
*/
🛡️
SELF PRESERVATION MODE

Mode de protection qui empêche la suppression des services en cas de défaillance réseau. Eureka préfère conserver les services potentiellement disponibles plutôt que de les supprimer prématurément.

Fonction: Protection contre les faux positifs

Configuration Self Preservation

// Configuration du mode Self Preservation
eureka:
  server:
    # Activer/désactiver le mode Self Preservation
    enable-self-preservation: true
    # Pourcentage minimum de renouvellements requis
    renewal-percent-threshold: 0.85
    # Intervalle d'éviction des instances mortes
    eviction-interval-timer-in-ms: 60000
    # Durée de conservation des données de réponse
    response-cache-auto-expiration-in-seconds: 180
    # Intervalle de mise à jour du cache de réponse
    response-cache-update-interval-ms: 30000

// Indicateurs du mode Self Preservation
/*
WARN [eureka-server] The self preservation mode is turned ON.
WARN [eureka-server] 15% of renewals are unimplemented.
INFO [eureka-server] Entered self preservation mode.
*/
⚖️
LOAD BALANCING

Intégration avec Ribbon pour la distribution des requêtes entre plusieurs instances d'un même service. Eureka fournit la liste des instances disponibles à Ribbon.

Fonction: Distribution équilibrée des charges

Configuration Load Balancing

// Utilisation avec RestTemplate
@Configuration
public class RestTemplateConfig {
  @LoadBalanced
  @Bean
  public RestTemplate restTemplate() {
    return new RestTemplate();
  }
}

// Service utilisant RestTemplate avec load balancing
@Service
public class UserService {
  @Autowired
  private RestTemplate restTemplate;

  public String callOrderService() {
    // Utilisation du nom de service au lieu de l'URL directe
    return restTemplate.getForObject(
      "http://order-service/api/orders",
      String.class
    );
  }
}

// Configuration Ribbon
order-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule
    ConnectTimeout: 3000
    ReadTimeout: 5000
    MaxAutoRetries: 1
    MaxAutoRetriesNextServer: 2
    OkToRetryOnAllOperations: true
🔍
DÉCOUVERTE DE SERVICES

Mécanisme permettant aux services de découvrir dynamiquement les autres services disponibles dans le registre Eureka.

Fonction: Découverte dynamique des services

Implémentation Discovery Client

// Injection du Discovery Client
@RestController
public class DiscoveryController {
  @Autowired
  private DiscoveryClient discoveryClient;

  @Autowired
  private EurekaClient eurekaClient;

  @GetMapping("/services")
  public List getServices() {
    return new ArrayList<>(discoveryClient.getServices());
  }

  @GetMapping("/instances/{serviceId}")
  public List getInstances(
    @PathVariable String serviceId) {
    return discoveryClient.getInstances(serviceId);
  }

  @GetMapping("/eureka-instances/{serviceId}")
  public List getEurekaInstances(
    @PathVariable String serviceId) {
    Application application = eurekaClient.getApplication(serviceId);
    return application != null ? application.getInstances() : new ArrayList<>();
  }
}

// Utilisation avec Feign Client
@FeignClient(name = "order-service")
public interface OrderServiceClient {
  @GetMapping("/api/orders")
  List getOrders();

  @GetMapping("/api/orders/user/{userId}")
  List getOrdersByUserId(@PathVariable Long userId);
}
📋
REGISTRE DES SERVICES

Interface web permettant de visualiser l'état des services enregistrés dans Eureka. Fournit des informations en temps réel sur la disponibilité des services.

Fonction: Interface de monitoring

Configuration Interface Web

// application.yml - Configuration de l'interface web
eureka:
  dashboard:
    path: /
    enabled: true
  server:
    enable-self-preservation: true
    eviction-interval-timer-in-ms: 60000
    response-cache-update-interval-ms: 30000
    use-read-only-response-cache: true
    wait-time-in-ms-when-sync-empty: 5000

// Sécurisation de l'interface web
spring:
  security:
    user:
      name: admin
      password: ${EUREKA_PASSWORD:password}

// WebSecurityConfig.java
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
      .authorizeRequests()
      .antMatchers("/eureka/**")
      .hasRole("ADMIN")
      .anyRequest().authenticated()
      .and()
      .httpBasic();
  }
}

Exemple Complet d'Architecture Eureka

project-root/
├── eureka-server/
│ ├── src/main/java/
│ │ └── com/example/eureka/
│ │ └── EurekaServerApplication.java
│ ├── src/main/resources/
│ │ └── application.yml
│ └── pom.xml
├── user-service/
│ ├── src/main/java/
│ │ └── com/example/user/
│ │ ├── UserServiceApplication.java
│ │ ├── controller/UserController.java
│ │ └── service/UserService.java
│ │ └── client/OrderServiceClient.java
│ ├── src/main/resources/
│ │ └── application.yml
│ └── pom.xml
├── order-service/
│ ├── src/main/java/
│ │ └── com/example/order/
│ │ ├── OrderServiceApplication.java
│ │ ├── controller/OrderController.java
│ │ └── service/OrderService.java
│ ├── src/main/resources/
│ │ └── application.yml
│ └── pom.xml
└── gateway-service/
├── src/main/java/
│ └── com/example/gateway/
│ └── GatewayApplication.java
├── src/main/resources/
│ └── application.yml
└── pom.xml

AVANTAGES

  • Simplicité: Intégration facile avec Spring Boot
  • Auto-enregistrement: Services s'enregistrent automatiquement
  • Résilience: Mode Self Preservation
  • Load balancing: Intégration native avec Ribbon
  • Monitoring: Interface web de supervision
  • Scalabilité: Support de milliers de services
  • Flexibilité: Configuration personnalisable

INCONVÉNIENTS

  • Single point of failure: Serveur central critique
  • Latence: Délai de découverte des services
  • Ressources: Consommation mémoire importante
  • Complexité: Configuration avancée nécessaire
  • Maintenance: Nécessite une surveillance constante
  • Dépendance: Lié à l'écosystème Netflix
  • Obsolescence: Projets Netflix en maintenance

Bonnes Pratiques

Pour une utilisation optimale d'Eureka, suivez ces bonnes pratiques :

  • Utilisez des noms de services significatifs et cohérents
  • Configurez correctement les intervalles de heartbeat
  • Activez le mode Self Preservation en production
  • Sécurisez l'interface web d'Eureka
  • Utilisez des environnements séparés pour dev/test/prod
  • Surveillez les logs pour détecter les problèmes
  • Implémentez des mécanismes de retry et circuit breaker
  • Utilisez des adresses IP plutôt que des noms d'hôtes si possible

CONTRÔLES D'ANIMATION

Afficher/Masquer Labels:
Accélérer:
Ralentir:
Réinitialiser Animation:
Simuler Enregistrement:
Mode Tutoriel:
Pause/Lecture:
Étape Suivante:
Étape Précédente:
Fullscreen:
Réinitialiser Disposition:
EUREKA - DISCOVERY SERVICE

FLUX DE TRAVAIL

1. Service → Eureka Server (Enregistrement)
2. Heartbeat périodique
3. Découverte par autres services
4. Load Balancing
5. Communication inter-services
6. Surveillance du registre
7. Éviction des services morts
8. Mode Self Preservation

LÉGENDE DES COMPOSANTS

Eureka Server
Eureka Client
Heartbeat
Self Preservation
Load Balancing
Découverte Services
Enregistrement
Heartbeat
Vitesse: 1.0x | Labels: ACTIFS | FPS: 60 | Mode: AUTO