Eureka Server avec 3 Microservices

    <dependencies>
        <!-- Dépendance principale pour Eureka Server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        
        <!-- Pour exposer les endpoints web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
  

# =====================================================
# 🧭 Port du serveur Eureka
# =====================================================
# Le port sur lequel le serveur Eureka va écouter les requêtes HTTP.
# Par défaut, Eureka utilise le port 8761, mais vous pouvez le modifier
# si un autre service utilise déjà ce port.
server.port=8761


# =====================================================
# 🏷️ Nom de l'application
# =====================================================
# Ce nom est utilisé par Spring Boot pour identifier l’application.
# Il est aussi visible dans les logs et les outils de monitoring.
spring.application.name=eureka-server


# =====================================================
# ⚙️ Configuration Eureka Server
# =====================================================

# Le serveur Eureka ne doit PAS s’enregistrer lui-même.
# Cette option désactive l’inscription automatique du serveur auprès de lui-même.
# En effet, dans une architecture typique, ce sont les clients qui s’enregistrent.
eureka.client.register-with-eureka=false

# Le serveur Eureka ne doit PAS non plus chercher d’autres serveurs pour récupérer un registre.
# Cela est utile uniquement dans un cluster de plusieurs serveurs Eureka.
# Ici, comme il s’agit d’un serveur unique, on le désactive.
eureka.client.fetch-registry=false

# L’URL par défaut du registre Eureka. 
# Même si le serveur ne s’enregistre pas, cette propriété est requise
# pour certaines opérations internes (comme la gestion des endpoints).
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/


# =====================================================
# 🛑 Désactiver la protection contre les suppressions
# =====================================================
# La "self-preservation" est un mécanisme de sécurité d’Eureka
# qui empêche la suppression des instances si le serveur détecte
# une perte massive de communication avec les clients.
# Dans un environnement de développement, on peut la désactiver
# pour forcer la suppression immédiate des services inactifs.
eureka.server.enable-self-preservation=false


# =====================================================
# 🧹 Intervalle de nettoyage des services morts (en ms)
# =====================================================
# Détermine la fréquence à laquelle le serveur Eureka vérifie et
# supprime les instances non renouvelées du registre.
# Ici, toutes les 30 secondes (30000 millisecondes).
eureka.server.eviction-interval-timer-in-ms=30000


# =====================================================
# ⏱️ Durée avant qu’un service soit considéré comme mort
# =====================================================
# Si un service ne renouvelle pas son bail (heartbeat) dans ce délai,
# il est considéré comme inactif et sera supprimé du registre.
# Valeur par défaut : 90 secondes. Ici, réduite à 30 secondes pour le test.
eureka.instance.lease-expiration-duration-in-seconds=30


# =====================================================
# 🔁 Intervalle de renouvellement du bail (heartbeat)
# =====================================================
# Chaque client envoie un signal (heartbeat) pour indiquer qu’il est toujours vivant.
# Cet intervalle détermine la fréquence d’envoi de ce signal.
# Ici, toutes les 10 secondes.
eureka.instance.lease-renewal-interval-in-seconds=10


# =====================================================
# 🪵 Niveau de logging pour le débogage
# =====================================================
# Ces paramètres réduisent la verbosité des logs générés par Eureka.
# Ils peuvent être réglés à DEBUG ou TRACE pour le développement.
# Ici, désactivés pour éviter les logs inutiles.
logging.level.com.netflix.eureka=OFF
logging.level.com.netflix.discovery=OFF


# =====================================================
# 📊 Exposition des endpoints Actuator
# =====================================================
# Les endpoints Actuator permettent de surveiller et de gérer
# l’état de l’application (santé, info, env, etc.).
# Ici, on expose tous les endpoints à des fins de test.
management.endpoints.web.exposure.include=*


# =====================================================
# 🖥️ Configuration de l’instance locale
# =====================================================
# Nom d’hôte de l’instance Eureka. Généralement "localhost"
# pour un serveur local, mais peut être remplacé par une IP ou un DNS.
eureka.instance.hostname=localhost

# Si cette option est vraie, l’adresse IP de l’instance est utilisée
# au lieu du nom d’hôte pour les communications entre services.
# Cela peut éviter des erreurs de résolution DNS en environnement local.
eureka.instance.prefer-ip-address=true

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * Classe principale du Eureka Server
 * 
 * @EnableEurekaServer : Active les fonctionnalités de Eureka Server
 * Cette annotation transforme l'application en serveur de découverte
 */
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

# Ouvrir dans un navigateur
http://localhost:8761

    <dependencies>
        <!-- Pour créer des APIs REST -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Client Eureka pour s'enregistrer -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        
        <!-- Pour le monitoring et la santé de l'application -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

# =====================================================
# 🌐 Port du microservice
# =====================================================
# Le port HTTP sur lequel le microservice sera lancé.
# Chaque microservice d’un système distribué doit utiliser un port différent
# pour éviter les conflits de communication.
# Exemple : service-a = 8081, service-b = 8082, etc.
server.port=8081


# =====================================================
# 🏷️ Nom de l'application
# =====================================================
# Ce nom identifie le microservice dans le registre Eureka.
# C’est ce nom (spring.application.name) que les autres services utiliseront
# pour communiquer via le mécanisme de découverte de services.
spring.application.name=service-a


# =====================================================
# 🔗 Configuration du Eureka Server
# =====================================================
# URL du serveur Eureka auprès duquel le microservice va s’enregistrer.
# Le chemin /eureka/ est obligatoire car c’est l’endpoint d’inscription.
# Le "defaultZone" indique l’adresse du serveur de découverte.
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/


# =====================================================
# 🧾 Enregistrement du microservice
# =====================================================
# Indique si ce service doit s’enregistrer auprès du serveur Eureka.
# Doit être "true" pour que le serveur puisse le rendre visible aux autres.
eureka.client.register-with-eureka=true

# Indique si ce microservice doit télécharger la liste (registre)
# de tous les autres services enregistrés auprès d’Eureka.
# Cela permet de communiquer avec d'autres services sans connaître leurs IP/ports.
eureka.client.fetch-registry=true


# =====================================================
# ⚙️ Configuration de l’instance
# =====================================================
# Utiliser l’adresse IP au lieu du nom d’hôte (utile en local ou en Docker).
# Cela évite des problèmes de résolution DNS entre conteneurs.
eureka.instance.prefer-ip-address=true

# Identifiant unique de l’instance dans Eureka.
# Combine le nom du service et le port pour différencier plusieurs instances.
eureka.instance.instance-id=${spring.application.name}:${server.port}

# Intervalle entre deux "heartbeats" (signaux de vie envoyés à Eureka).
# Ici, le microservice enverra un signal toutes les 10 secondes
# pour indiquer qu’il est encore actif.
eureka.instance.lease-renewal-interval-in-seconds=10

# Durée avant qu’Eureka considère le service comme inactif
# s’il ne reçoit plus de signaux.
# Après 30 secondes sans "heartbeat", Eureka supprime cette instance du registre.
eureka.instance.lease-expiration-duration-in-seconds=30


# =====================================================
# 💓 Statut et surveillance de l’instance
# =====================================================
# URL exposée pour consulter les informations de base de l’application.
# Utilisée par Eureka pour fournir des métadonnées sur le service.
eureka.instance.status-page-url-path=/actuator/info

# URL utilisée par Eureka pour vérifier la santé du service.
# Si cette URL retourne un statut DOWN, Eureka peut retirer temporairement
# l’instance du registre.
eureka.instance.health-check-url-path=/actuator/health


# =====================================================
# 🧩 Exposition des endpoints Actuator
# =====================================================
# Permet d’exposer les endpoints de monitoring Spring Boot Actuator.
# L’astérisque (*) indique que tous les endpoints sont accessibles
# (par exemple /health, /info, /metrics, /env, etc.).
# ⚠️ En production, il est conseillé de restreindre les endpoints exposés.
management.endpoints.web.exposure.include=*


# =====================================================
# 🧠 Configuration spécifique du microservice
# =====================================================
# Ces propriétés sont purement personnalisées.
# Elles peuvent être utilisées pour afficher des informations dans les logs
# ou pour configurer d’autres composants du service.
app.service.name=Service A
app.service.description=Premier microservice de l'application
app.service.version=1.0.0


# =====================================================
# 🪵 Niveau de Logging
# =====================================================
# Définit la verbosité des logs pour les packages Spring Cloud et Netflix (Eureka).
# Utile pour le débogage des interactions entre le client et le serveur Eureka.
# En production, il est recommandé de passer en niveau INFO ou WARN.
logging.level.org.springframework.cloud=DEBUG
logging.level.com.netflix=DEBUG

package com.example.servicea;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

/**
 * =====================================================
 * 🧠 ServiceAApplication.java
 * =====================================================
 * Description :
 *   - Microservice A faisant partie d'une architecture microservices Spring Cloud.
 *   - Ce service est enregistré dans le serveur Eureka (service discovery).
 *   - Il communique avec d'autres microservices (ex : Service B, Service C)
 *     en utilisant RestTemplate + Load Balancing.
 *
 * Principales annotations :
 *   @SpringBootApplication → Active Spring Boot (auto-configuration, scanning, etc.)
 *   @EnableDiscoveryClient → Active le client Eureka (inscription et découverte)
 *   @RestController → Expose les endpoints REST directement depuis cette classe
 */
@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class ServiceAApplication {

    // =====================================================
    // ⚙️ Dépendances et Beans
    // =====================================================

    /**
     * RestTemplate est utilisé pour effectuer des appels HTTP
     * entre microservices (ex : Service A → Service B).
     * L’annotation @LoadBalanced permet d’utiliser le nom logique
     * du service enregistré dans Eureka (ex : "http://service-b").
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    // Injection automatique du RestTemplate
    @Autowired
    private RestTemplate restTemplate;


    // =====================================================
    // 🚀 Point d'entrée principal de l'application
    // =====================================================
    public static void main(String[] args) {
        SpringApplication.run(ServiceAApplication.class, args);
    }


    // =====================================================
    // 🌐 Endpoints REST exposés par Service A
    // =====================================================

    /**
     * Endpoint d'information sur le service.
     * Accessible via : GET http://localhost:8081/info
     */
    @GetMapping("/info")
    public Map getServiceInfo() {
        return Map.of(
            "serviceName", "Service A",
            "description", "Premier microservice de l'application",
            "port", "8081",
            "status", "UP"
        );
    }

    /**
     * Endpoint de vérification de santé.
     * Accessible via : GET http://localhost:8081/health
     * Utilisé par Eureka pour vérifier la disponibilité du service.
     */
    @GetMapping("/health")
    public String health() {
        return "Service A is running!";
    }

    /**
     * Endpoint de démonstration d'appel à un autre microservice via Eureka.
     * Utilise le RestTemplate LoadBalanced pour appeler le service-b.
     * Accessible via : GET http://localhost:8081/call-service-b
     */
    @GetMapping("/call-service-b")
    public String callServiceB() {
        try {
            // Utilisation du nom logique du service "service-b"
            // défini dans le fichier application.properties
            String response = restTemplate.getForObject("http://service-b/health", String.class);
            return "✅ Response from Service B: " + response;
        } catch (Exception e) {
            return "❌ Error calling Service B: " + e.getMessage();
        }
    }

    /**
     * Endpoint de démonstration d’appel à Service C.
     * Accessible via : GET http://localhost:8081/call-service-c
     */
    @GetMapping("/call-service-c")
    public String callServiceC() {
        try {
            String response = restTemplate.getForObject("http://service-c/health", String.class);
            return "✅ Response from Service C: " + response;
        } catch (Exception e) {
            return "❌ Error calling Service C: " + e.getMessage();
        }
    }
}

package com.example.serviceb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class ServiceBApplication {
    
    @Autowired
    private RestTemplate restTemplate;

    public static void main(String[] args) {
        SpringApplication.run(ServiceBApplication.class, args);
    }
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @GetMapping("/info")
    public Map<String, Object> getServiceInfo() {
        return Map.of(
            "serviceName", "Service B",
            "description", "Service d'authentification et de gestion des utilisateurs",
            "port", "${server.port}",
            "status", "UP"
        );
    }
    
    @GetMapping("/health")
    public String health() {
        return "Service B is running!";
    }
    
    @GetMapping("/users")
    public Map<String, Object> getUsers() {
        return Map.of(
            "users", Arrays.asList("user1", "user2", "user3"),
            "count", 3
        );
    }
    
    @GetMapping("/call-service-a")
    public String callServiceA() {
        try {
            String response = restTemplate.getForObject("http://service-a/health", String.class);
            return "Response from Service A: " + response;
        } catch (Exception e) {
            return "Error calling Service A: " + e.getMessage();
        }
    }
}

package com.example.servicec;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class ServiceCApplication {
    
    @Autowired
    private RestTemplate restTemplate;

    public static void main(String[] args) {
        SpringApplication.run(ServiceCApplication.class, args);
    }
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @GetMapping("/info")
    public Map<String, Object> getServiceInfo() {
        return Map.of(
            "serviceName", "Service C",
            "description", "Service de traitement de données et d'analyse",
            "port", "${server.port}",
            "status", "UP"
        );
    }
    
    @GetMapping("/health")
    public String health() {
        return "Service C is running!";
    }
    
    @GetMapping("/data")
    public Map<String, Object> getData() {
        return Map.of(
            "data", Arrays.asList("data1", "data2", "data3"),
            "processed", true
        );
    }
    
    @GetMapping("/call-service-a")
    public String callServiceA() {
        try {
            String response = restTemplate.getForObject("http://service-a/health", String.class);
            return "Response from Service A: " + response;
        } catch (Exception e) {
            return "Error calling Service A: " + e.getMessage();
        }
    }
    
    @GetMapping("/call-service-b")
    public String callServiceB() {
        try {
            String response = restTemplate.getForObject("http://service-b/users", String.class);
            return "Response from Service B: " + response;
        } catch (Exception e) {
            return "Error calling Service B: " + e.getMessage();
        }
    }
}

server.port=8761
spring.application.name=eureka-server

# Configuration peer-to-peer
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true
eureka.client.service-url.defaultZone=http://peer2:8762/eureka/

eureka.instance.hostname=peer1
eureka.server.enable-self-preservation=false

server.port=8762
spring.application.name=eureka-server

# Configuration peer-to-peer
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true
eureka.client.service-url.defaultZone=http://peer1:8761/eureka/

eureka.instance.hostname=peer2
eureka.server.enable-self-preservation=false

# Terminal 1
java -jar eureka-server.jar --spring.profiles.active=peer1

# Terminal 2
java -jar eureka-server.jar --spring.profiles.active=peer2

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

# Configuration de sécurité
spring.security.user.name=admin
spring.security.user.password=secure-password

# Configuration Eureka avec authentification
eureka.client.service-url.defaultZone=http://admin:secure-password@localhost:8761/eureka/

package com.example.eurekaserver.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/eureka/**").authenticated()
                .anyRequest().permitAll()
            )
            .httpBasic();
        return http.build();
    }
}

# =====================================================
# ⚙️ Configuration Eureka Client avancée
# =====================================================

# URL du serveur Eureka auprès duquel le microservice va s’enregistrer.
# L’endpoint /eureka/ est obligatoire. C’est ici que les clients
# s’inscrivent et récupèrent les autres services.
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Permet à ce service de s’enregistrer automatiquement auprès du serveur Eureka.
# Doit être "true" pour que le serveur découvre ce client.
eureka.client.register-with-eureka=true

# Permet à ce client de récupérer la liste des autres services enregistrés.
# Nécessaire pour permettre la découverte dynamique et les appels interservices.
eureka.client.fetch-registry=true


# =====================================================
# ⏱️ Configuration de la fréquence d'actualisation
# =====================================================

# Définit la fréquence (en secondes) à laquelle le client rafraîchit
# la liste des services enregistrés dans Eureka.
# Ici, toutes les 30 secondes, le client mettra à jour son cache local.
# Cela permet de détecter rapidement les nouveaux services ou les arrêts.
eureka.client.registry-fetch-interval-seconds=30


# =====================================================
# 🧩 Configuration de l'instance
# =====================================================

# Utiliser l’adresse IP au lieu du nom d’hôte pour éviter
# les problèmes de résolution DNS, notamment en environnement Docker.
eureka.instance.prefer-ip-address=true

# Identifiant unique de cette instance du microservice.
# Combine le nom de l’application et le port pour assurer l’unicité.
eureka.instance.instance-id=${spring.application.name}:${server.port}

# Intervalle (en secondes) d’envoi du "heartbeat" à Eureka.
# Cela indique que l’instance est toujours active.
# Ici, toutes les 30 secondes.
eureka.instance.lease-renewal-interval-in-seconds=30

# Durée (en secondes) avant qu’Eureka considère le service comme inactif
# s’il ne reçoit plus de signaux (heartbeats).
# Ici, 90 secondes → plus tolérant aux pertes de connexion temporaires.
eureka.instance.lease-expiration-duration-in-seconds=90


# =====================================================
# 💓 URLs de statut et de santé (Spring Boot Actuator)
# =====================================================

# Page d’information (actuator/info) utilisée par Eureka pour consulter
# des métadonnées sur le service (nom, version, description, etc.)
eureka.instance.status-page-url-path=/actuator/info

# Page de santé (actuator/health) utilisée par Eureka pour vérifier
# si le service est opérationnel. Si elle renvoie "DOWN", Eureka
# peut retirer le service temporairement du registre.
eureka.instance.health-check-url-path=/actuator/health

# Page d’accueil (souvent utilisée pour renvoyer vers la documentation ou l’API principale)
eureka.instance.home-page-url-path=/


# =====================================================
# 🧭 Métadonnées personnalisées (Metadata Map)
# =====================================================

# Ces métadonnées supplémentaires sont stockées dans Eureka
# et peuvent être utilisées par d’autres services pour filtrer
# ou sélectionner des instances selon certains critères.

# Zone de déploiement logique (ex : primary, secondary, backup, etc.)
# Utile pour le routage régional ou la redondance multi-zone.
eureka.instance.metadata-map.zone=primary

# Environnement de déploiement (production, staging, test, etc.)
# Cela permet d’éviter qu’un service en développement se connecte
# accidentellement à un service de production.
eureka.instance.metadata-map.environment=production


# =====================================================
# ⏳ Timeout et gestion réseau Eureka
# =====================================================

# Délai maximal (en secondes) pour établir une connexion
# entre le client et le serveur Eureka.
# Si le serveur ne répond pas dans ce délai, la tentative échoue.
eureka.client.eureka-server-connect-timeout-seconds=5

# Délai maximal (en secondes) pour lire la réponse du serveur Eureka
# après l’établissement de la connexion.
# Ici, fixé à 8 secondes pour tolérer de légères latences réseau.
eureka.client.eureka-server-read-timeout-seconds=8

@Service
public class CustomLoadBalancer {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    public String getNextAvailableInstance(String serviceName) {
        List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
        
        if (instances.isEmpty()) {
            throw new RuntimeException("No instances available for " + serviceName);
        }
        
        // Implémentation personnalisée de load balancing (round-robin, random, etc.)
        ServiceInstance instance = instances.get(0); // Simplifié
        return instance.getUri().toString();
    }
}

############################################
# 🔧 CONFIGURATION DU SERVEUR EUREKA
############################################

# Port du serveur Eureka
server.port=8761

# Nom de l'application Eureka
spring.application.name=eureka-server

# Désactiver l'enregistrement et la récupération (car c'est un serveur)
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

# URL locale du serveur Eureka
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Désactivation de la protection automatique contre les suppressions accidentelles
# (utile pour le développement et les tests)
eureka.server.enable-self-preservation=false

# Intervalle de nettoyage des instances inactives (en millisecondes)
eureka.server.eviction-interval-timer-in-ms=30000

# Délai avant qu’un service soit considéré comme mort (en secondes)
eureka.instance.lease-expiration-duration-in-seconds=30

# Intervalle de renouvellement du bail (en secondes)
eureka.instance.lease-renewal-interval-in-seconds=10

# Exposition de tous les endpoints Actuator
management.endpoints.web.exposure.include=*

# Configuration de l’instance du serveur
eureka.instance.hostname=localhost
eureka.instance.prefer-ip-address=true

# Niveau de logs pour le serveur Eureka
logging.level.com.netflix.eureka=OFF
logging.level.com.netflix.discovery=OFF

############################################
# ⚙️ CONFIGURATION DU MICRO SERVICE (CLIENT)
############################################

# Port du microservice
server.port=8081

# Nom du microservice (utilisé pour l'enregistrement Eureka)
spring.application.name=service-a

# URL du serveur Eureka
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Enregistrement du microservice dans Eureka
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

# Identifiant unique de l’instance
eureka.instance.instance-id=${spring.application.name}:${server.port}

# Préférence pour utiliser l’adresse IP au lieu du nom d’hôte
eureka.instance.prefer-ip-address=true

# Intervalle de renouvellement et d’expiration du bail
eureka.instance.lease-renewal-interval-in-seconds=10
eureka.instance.lease-expiration-duration-in-seconds=30

# URLs de statut et de santé du microservice
eureka.instance.status-page-url-path=/actuator/info
eureka.instance.health-check-url-path=/actuator/health

# Exposition de tous les endpoints Actuator
management.endpoints.web.exposure.include=*

# Informations supplémentaires sur le service
app.service.name=Service A
app.service.description=Premier microservice de l'application
app.service.version=1.0.0

# Niveau de logs du client Eureka
logging.level.org.springframework.cloud=DEBUG
logging.level.com.netflix=DEBUG

############################################
# 🚀 CONFIGURATION EUREKA CLIENT AVANCÉE
############################################

# URL du serveur Eureka (répétée pour compatibilité avancée)
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Activation de l'enregistrement et de la récupération
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

# Fréquence d’actualisation du registre (en secondes)
eureka.client.registry-fetch-interval-seconds=30

# Métadonnées pour classification (utile dans des environnements multi-zones)
eureka.instance.metadata-map.zone=primary
eureka.instance.metadata-map.environment=production

# Timeout pour la connexion au serveur Eureka
eureka.client.eureka-server-connect-timeout-seconds=5
eureka.client.eureka-server-read-timeout-seconds=8

############################################
# 🔒 CONFIGURATION HTTPS DU MICRO SERVICE
############################################

# Définition du keystore (certificat SSL)
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=password
server.ssl.keyStoreType=PKCS12
server.ssl.keyAlias=tomcat

# Activation du port sécurisé pour Eureka
eureka.instance.secure-port-enabled=true
eureka.instance.non-secure-port-enabled=false
eureka.instance.secure-port=${server.port}
eureka.instance.secure-virtual-host-name=${spring.application.name}

# Configuration de performance Eureka
eureka.server.response-cache-update-interval-ms=30000
eureka.server.response-cache-auto-expiration-in-seconds=180
eureka.server.use-read-only-response-cache=true

# Compression
server.compression.enabled=true
server.compression.mime-types=application/json,application/xml,text/html,text/xml,text/plain

# Monitoring avec Actuator
management.endpoints.web.exposure.include=health,info,metrics,eureka
management.endpoint.health.show-details=always
management.metrics.export.prometheus.enabled=true

# Configuration resilience
eureka.client.initial-instance-info-replication-interval-seconds=40
eureka.client.instance-info-replication-interval-seconds=30
eureka.client.eureka-service-url-poll-interval-seconds=300

# Fallback configuration
spring.cloud.loadbalancer.retry.enabled=true
spring.cloud.loadbalancer.retry.max-attempts=3
spring.cloud.loadbalancer.retry.backoff.initial-interval=1000
spring.cloud.loadbalancer.retry.backoff.multiplier=2.0
spring.cloud.loadbalancer.retry.backoff.max-interval=10000