Spring Cloud Gateway

    <!-- Dépendances du projet -->
    <dependencies>
        <!-- Dépendance principale pour Spring Cloud Gateway -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
            <!-- Pas de version = héritée de spring-cloud-dependencies -->
        </dependency>
        
        <!-- Client Eureka pour discovery -->
        <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>
    </dependencies>
    

############################################
# 🌐 CONFIGURATION DE BASE DU SERVEUR
############################################

# Port du Gateway - c’est sur ce port que les clients externes enverront leurs requêtes.
server.port=8080

# Nom de l’application - utilisé pour l’enregistrement auprès d’Eureka.
# Chaque service doit avoir un nom unique pour être distingué dans le registre.
spring.application.name=api-gateway


############################################
# 🧭 CONFIGURATION DU CLIENT EUREKA
############################################

# URL du serveur Eureka - indique où se trouve le service de découverte.
# Le format standard est : http://:/eureka/
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Enregistrement du Gateway dans le serveur Eureka
# true : le Gateway s’inscrit lui-même dans le registre.
eureka.client.register-with-eureka=true

# Récupération du registre des services
# true : permet au Gateway de connaître tous les services enregistrés (pour le routage dynamique).
eureka.client.fetch-registry=true

# Utilisation de l’adresse IP plutôt que du nom d’hôte.
# Recommandé dans les environnements Docker ou Cloud.
eureka.instance.prefer-ip-address=true


############################################
# 🚦 CONFIGURATION DU ROUTAGE AUTOMATIQUE
############################################

# Active la découverte automatique des routes depuis Eureka.
# Si activé, chaque service enregistré dans Eureka devient accessible via une route.
spring.cloud.gateway.discovery.locator.enabled=true

# Convertit automatiquement les noms de services en minuscules.
# Exemple : SERVICE-A → service-a (plus cohérent pour les URLs).
spring.cloud.gateway.discovery.locator.lower-case-service-id=true


############################################
# 🧩 CONFIGURATION DES ROUTES MANUELLES
############################################

# === Route personnalisée vers le microservice Service A ===
spring.cloud.gateway.routes[0].id=service-a
spring.cloud.gateway.routes[0].uri=lb://service-a
spring.cloud.gateway.routes[0].predicates[0]=Path=/api/service-a/**
spring.cloud.gateway.routes[0].filters[0]=StripPrefix=2
# 🔹 "lb://" active le load-balancing basé sur Eureka.
# 🔹 "Path" définit le motif d’URL correspondant à cette route.
# 🔹 "StripPrefix=2" supprime les deux premiers segments du chemin (/api/service-a/ → /).

# === Route personnalisée vers le microservice Service B ===
spring.cloud.gateway.routes[1].id=service-b
spring.cloud.gateway.routes[1].uri=lb://service-b
spring.cloud.gateway.routes[1].predicates[0]=Path=/api/service-b/**
spring.cloud.gateway.routes[1].filters[0]=StripPrefix=2

# === Route personnalisée vers le microservice Service C ===
spring.cloud.gateway.routes[2].id=service-c
spring.cloud.gateway.routes[2].uri=lb://service-c
spring.cloud.gateway.routes[2].predicates[0]=Path=/api/service-c/**
spring.cloud.gateway.routes[2].filters[0]=StripPrefix=2


############################################
# 🧱 CONFIGURATION DES FILTRES GLOBAUX
############################################

# Évite les doublons dans les en-têtes de réponse (CORS notamment).
# DedupeResponseHeader fusionne les en-têtes dupliqués pour plus de propreté.
spring.cloud.gateway.default-filters[0]=DedupeResponseHeader=Access-Control-Allow-Credentials Access-Control-Allow-Origin


############################################
# 📊 CONFIGURATION ACTUATOR (MONITORING)
############################################

# Expose les endpoints pour la supervision et le diagnostic.
# - gateway : affiche les routes configurées
# - health : état de santé du Gateway
# - info : informations générales de l’application
# - metrics : indicateurs de performance
management.endpoints.web.exposure.include=gateway,health,info,metrics


############################################
# 🪵 CONFIGURATION DE LOGGING
############################################

# Niveau de logs pour le moteur Spring Cloud Gateway.
# DEBUG : niveau verbeux utile pour le développement et le débogage.
logging.level.org.springframework.cloud.gateway=DEBUG

# Logs détaillés pour le client HTTP réactif (basé sur Reactor Netty).
logging.level.reactor.netty.http.client=DEBUG


############################################
# ⏱️ CONFIGURATION DES TIMEOUTS
############################################

# Temps maximal d’attente lors de la connexion à un service cible (en millisecondes).
spring.cloud.gateway.httpclient.connect-timeout=5000

# Temps maximal d’attente pour la réponse complète d’un service (en secondes).
spring.cloud.gateway.httpclient.response-timeout=10s


############################################
# 🧩 CONFIGURATION DE L’INSTANCE EUREKA
############################################

# Identifiant unique de cette instance - utile pour le suivi et le débogage.
# Exemple : api-gateway:8080
eureka.instance.instance-id=${spring.application.name}:${server.port}

# Fréquence à laquelle le Gateway renouvelle son "bail" auprès d’Eureka (en secondes).
# Un renouvellement est une sorte de "ping" qui indique que le service est toujours actif.
eureka.instance.lease-renewal-interval-in-seconds=30

# Délai maximal avant qu’un service soit marqué comme inactif si aucun renouvellement n’est reçu.
eureka.instance.lease-expiration-duration-in-seconds=90

// Annotation pour dire que c'est une classe de configuration Spring
@Configuration
public class GatewayConfig {
    
    // Annotation @Bean pour créer un composant Spring géré
    @Bean
    // RouteLocator = objet qui définit toutes les routes du Gateway
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        // builder.routes() = commence à construire les routes
        return builder.routes()
            
            // === ROUTE POUR SERVICE A ===
            // .route("service-a", r -> r...) = crée une route nommée "service-a"
            .route("service-a", r -> r
                // .path("/api/service-a/**") = condition : chemin commence par /api/service-a/
                .path("/api/service-a/**")
                
                // .filters(f -> f...) = applique des filtres à cette route
                .filters(f -> f
                    // .stripPrefix(2) = retire les 2 premiers segments du chemin
                    .stripPrefix(2)
                    // .addResponseHeader("X-Response-Service", "Service-A") = ajoute un header à la réponse
                    .addResponseHeader("X-Response-Service", "Service-A")
                    // .retry(3) = réessaie 3 fois en cas d'erreur
                    .retry(3)
                )
                // .uri("lb://service-a") = destination avec load balancing vers service-a
                .uri("lb://service-a"))
            
            // === ROUTE POUR SERVICE B ===
            .route("service-b", r -> r
                .path("/api/service-b/**")
                .filters(f -> f
                    .stripPrefix(2)
                    .addResponseHeader("X-Response-Service", "Service-B")
                    .retry(3)
                )
                .uri("lb://service-b"))
            
            // === ROUTE POUR SERVICE C ===
            .route("service-c", r -> r
                .path("/api/service-c/**")
                .filters(f -> f
                    .stripPrefix(2)
                    .addResponseHeader("X-Response-Service", "Service-C")
                    .retry(3)
                )
                .uri("lb://service-c"))
            
            // .build() = construit et retourne l'objet RouteLocator
            .build();
    }
}

// Annotation Spring Boot qui combine plusieurs fonctionnalités :
// @Configuration + @EnableAutoConfiguration + @ComponentScan
@SpringBootApplication

// Active le client Eureka pour la découverte de services
// Permet à ce service de s'enregistrer et de trouver les autres services
@EnableDiscoveryClient

// Classe principale de l'application
public class ApiGatewayApplication {
    
    // Méthode principale - point d'entrée de l'application
    public static void main(String[] args) {
        // SpringApplication.run() :
        // 1. Crée le contexte Spring (conteneur d'inversion de contrôle)
        // 2. Scanne les composants (@Component, @Service, @Repository, etc.)
        // 3. Configure automatiquement les beans selon les dépendances
        // 4. Démarre le serveur web embarqué (Tomcat par défaut)
        // 5. Lance l'application
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
}

# === ROUTE AVANCÉE POUR SERVICE A AVEC FILTRES COMPLEXES ===
# ID unique de la route
spring.cloud.gateway.routes[0].id=service-a-advanced

# URI de destination avec load balancing
spring.cloud.gateway.routes[0].uri=lb://service-a

# === PRÉDICATS (CONDITIONS DE ROUTAGE) ===
# Predicate 0 : Chemin de l'URL
# /api/v1/service-a/** = tous les chemins commençant par /api/v1/service-a/
spring.cloud.gateway.routes[0].predicates[0]=Path=/api/v1/service-a/**

# Predicate 1 : Méthode HTTP autorisée
# Seules les requêtes GET et POST seront routées
spring.cloud.gateway.routes[0].predicates[1]=Method=GET,POST

# Predicate 2 : Header requis
# La requête doit avoir un header X-API-Version avec la valeur 1.0
spring.cloud.gateway.routes[0].predicates[2]=Header=X-API-Version, 1.0

# === FILTRES À APPLIQUER ===
# Filtre 0 : StripPrefix
# Retire les 3 premiers segments du chemin (/api/v1/service-a/health → /health)
spring.cloud.gateway.routes[0].filters[0]=StripPrefix=3

# Filtre 1 : AddRequestHeader
# Ajoute un header à la requête envoyée au service
spring.cloud.gateway.routes[0].filters[1]=AddRequestHeader=X-Forwarded-By, API-Gateway

# Filtre 2 : AddResponseHeader avec expression SpEL
# Ajoute un header à la réponse avec la date courante
# #{new java.util.Date()} = expression Spring Expression Language
spring.cloud.gateway.routes[0].filters[2]=AddResponseHeader=X-Response-Time, #{new java.util.Date()}

# Filtre 3 : Retry
# Réessaie la requête en cas d'erreurs spécifiques
# 3 = nombre de tentatives
# INTERNAL_SERVER_ERROR, SERVICE_UNAVAILABLE = codes d'erreur qui déclenchent le retry
spring.cloud.gateway.routes[0].filters[3]=Retry=3,INTERNAL_SERVER_ERROR,SERVICE_UNAVAILABLE


# === ROUTE POUR SERVICE B AVEC RATE LIMITING ===
spring.cloud.gateway.routes[1].id=service-b-limited
spring.cloud.gateway.routes[1].uri=lb://service-b
spring.cloud.gateway.routes[1].predicates[0]=Path=/api/v1/service-b/**
# Rate limiting : 10 requêtes par seconde, rafale de 20
spring.cloud.gateway.routes[1].filters[0]=StripPrefix=3
spring.cloud.gateway.routes[1].filters[1]=RequestRateLimiter=10,20


# === ROUTE POUR SERVICE C AVEC FALLBACK ===
spring.cloud.gateway.routes[2].id=service-c-fallback
spring.cloud.gateway.routes[2].uri=lb://service-c
spring.cloud.gateway.routes[2].predicates[0]=Path=/api/v1/service-c/**
spring.cloud.gateway.routes[2].filters[0]=StripPrefix=3
# FallbackHeaders : ajoute des headers en cas d'erreur pour le fallback
spring.cloud.gateway.routes[2].filters[1]=FallbackHeaders=ExecutionException

// Annotation pour dire que c'est une classe de configuration Spring
@Configuration
public class GlobalFiltersConfig {
    
    // @Bean pour créer un bean Spring
    // @Order(-1) pour que ce filtre s'exécute en premier (-1 = avant les autres)
    @Bean
    @Order(-1)
    public GlobalFilter preGlobalFilter() {
        // Retourne un filtre global
        return (exchange, chain) -> {
            // exchange = contient toutes les informations de la requête/réponse
            // chain = chaîne des filtres suivants
            
            // === LOGIQUE DU FILTRE PRE-PROCESSING ===
            System.out.println("=== FILTRE PRÉ-TRAITEMENT EXÉCUTÉ ===");
            
            // Affiche le chemin de la requête
            System.out.println("Chemin de la requête: " + exchange.getRequest().getPath());
            
            // Affiche la méthode HTTP
            System.out.println("Méthode HTTP: " + exchange.getRequest().getMethod());
            
            // === MODIFICATION DE LA REQUÊTE ===
            // .mutate() = permet de modifier la requête de manière immutable
            ServerHttpRequest request = exchange.getRequest()
                .mutate()
                // Ajoute un header personnalisé avec un UUID unique
                .header("X-Global-Request-ID", java.util.UUID.randomUUID().toString())
                // Ajoute un header avec le timestamp
                .header("X-Request-Time", String.valueOf(System.currentTimeMillis()))
                // .build() = construit la nouvelle requête modifiée
                .build();
            
            // === CONTINUER LA CHAÎNE DE FILTRES ===
            // exchange.mutate().request(request).build() = met à jour l'échange avec la requête modifiée
            // chain.filter() = continue vers le filtre suivant
            return chain.filter(exchange.mutate().request(request).build());
        };
    }
    
    // Deuxième filtre global, exécuté après le premier (@Order(0))
    @Bean
    @Order(0)
    public GlobalFilter postGlobalFilter() {
        return (exchange, chain) -> {
            // === EXÉCUTION ASYNCHRONE AVEC MONO ===
            // chain.filter(exchange) = exécute les filtres suivants
            // .then() = exécute du code après que tous les filtres suivants ont terminé
            return chain.filter(exchange).then(
                // Mono.fromRunnable() = crée un Mono (programmation réactive) à partir d'un Runnable
                Mono.fromRunnable(() -> {
                    // === LOGIQUE DU FILTRE POST-TRAITEMENT ===
                    System.out.println("=== FILTRE POST-TRAITEMENT EXÉCUTÉ ===");
                    
                    // Affiche le statut de la réponse
                    System.out.println("Statut de la réponse: " + exchange.getResponse().getStatusCode());
                    
                    // Ajoute un header à la réponse
                    exchange.getResponse().getHeaders().add("X-Global-Response", "Processed by Gateway");
                })
            );
        };
    }
}

1. preGlobalFilter() (@Order(-1)) - PRÉ-TRAITEMENT
   ↓
2. Filtres de route configurés
   ↓
3. Appel au service cible
   ↓
4. Réponse du service
   ↓
5. Filtres de route configurés (sens inverse)
   ↓
6. postGlobalFilter() (@Order(0)) - POST-TRAITEMENT

<!-- Ajouter cette dépendance dans la section <dependencies> -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

// Annotation pour dire que c'est une configuration
@Configuration

// Active la sécurité Web réactive (nécessaire pour Spring Cloud Gateway)
@EnableWebFluxSecurity
public class SecurityConfig {
    
    // @Bean pour créer un bean Spring géré
    // SecurityWebFilterChain = chaîne de filtres de sécurité
    @Bean
    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
        // Configuration de la sécurité HTTP
        http
            // .authorizeExchange() = configure l'autorisation des échanges
            .authorizeExchange(exchanges -> exchanges
                // .pathMatchers() = définit des motifs de chemins
                // .permitAll() = autorise tout le monde (pas d'authentification requise)
                
                // Autoriser l'accès aux endpoints Actuator (monitoring)
                .pathMatchers("/actuator/**").permitAll()
                
                // Autoriser l'accès aux APIs publiques
                .pathMatchers("/api/public/**").permitAll()
                
                // Pour toutes les autres requêtes, authentification requise
                .anyExchange().authenticated()
            )
            // .httpBasic() = active l'authentification HTTP Basic
            // Affiche une popup de login dans le navigateur
            .httpBasic()
            
            // .and() = permet d'enchaîner les configurations
            // .csrf().disable() = désactive la protection CSRF
            // (souvent désactivé pour les APIs REST stateless)
            .and()
            .csrf().disable();
        
        // Retourne la chaîne de filtres de sécurité configurée
        return http.build();
    }
}

# Accès sans authentification - devrait être refusé
curl http://localhost:8080/api/service-a/health

# Accès avec authentification - devrait fonctionner
curl -u user:password http://localhost:8080/api/service-a/health

# Accès aux endpoints publics - devrait fonctionner
curl http://localhost:8080/api/public/info

# Accès aux endpoints Actuator - devrait fonctionner
curl http://localhost:8080/actuator/health

// Annotation pour que Spring gère ce composant
@Component

// Hérite d'AbstractGatewayFilterFactory pour créer un filtre configurable
// <CustomRequestFilterFactory.Config> = type de configuration du filtre
public class CustomRequestFilterFactory extends AbstractGatewayFilterFactory<CustomRequestFilterFactory.Config> {
    
    // Constructeur qui définit le type de configuration
    public CustomRequestFilterFactory() {
        // super(Config.class) = indique que la configuration est de type Config
        super(Config.class);
    }
    
    // Méthode principale qui applique le filtre
    @Override
    public GatewayFilter apply(Config config) {
        // Retourne un GatewayFilter (filtre de Gateway)
        return (exchange, chain) -> {
            // === TRANSFORMATION DE LA REQUÊTE ===
            
            // exchange.getRequest() = obtient la requête actuelle
            // .mutate() = permet de la modifier de manière immutable
            ServerHttpRequest request = exchange.getRequest()
                .mutate()
                // Ajoute un header personnalisé avec la valeur configurée
                .header("X-Custom-Header", config.getHeaderValue())
                // Ajoute un header avec le timestamp de la requête
                .header("X-Request-Time", String.valueOf(System.currentTimeMillis()))
                // .build() = construit la nouvelle requête modifiée
                .build();
            
            // === CONTINUER LA CHAÎNE DE TRAITEMENT ===
            // exchange.mutate().request(request).build() = met à jour l'échange
            // chain.filter() = continue vers le filtre suivant
            return chain.filter(exchange.mutate().request(request).build());
        };
    }
    
    // Classe de configuration interne pour ce filtre
    // Permet de configurer le filtre via application.properties
    public static class Config {
        // Propriété configurable
        private String headerValue;
        
        // Getter
        public String getHeaderValue() {
            return headerValue;
        }
        
        // Setter
        public void setHeaderValue(String headerValue) {
            this.headerValue = headerValue;
        }
    }
}

# Utilisation du filtre personnalisé dans application.properties

# Créer une route qui utilise le filtre personnalisé
spring.cloud.gateway.routes[0].id=service-a-custom
spring.cloud.gateway.routes[0].uri=lb://service-a

# Prédicat : quand le chemin commence par /api/custom/
spring.cloud.gateway.routes[0].predicates[0]=Path=/api/custom/**

# Filtres à appliquer :
# 1. StripPrefix=2 : retire /api/custom/ du chemin
spring.cloud.gateway.routes[0].filters[0]=StripPrefix=2

# 2. CustomRequest=CustomValue : utilise notre filtre personnalisé
# CustomRequest = nom du filtre (déduit du nom de la classe)
# CustomValue = valeur passée à setHeaderValue()
spring.cloud.gateway.routes[0].filters[1]=CustomRequest=CustomValue

<!-- Ajouter cette dépendance pour Redis réactif -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

# === CONFIGURATION REDIS POUR RATE LIMITING ===
# Adresse du serveur Redis
spring.redis.host=localhost

# Port Redis (par défaut 6379)
spring.redis.port=6379

# === CONFIGURATION DU RATE LIMITING SUR UNE ROUTE ===
# ID de la route
spring.cloud.gateway.routes[0].id=service-a-rate-limited

# URI de destination
spring.cloud.gateway.routes[0].uri=lb://service-a

# Prédicat : chemin
spring.cloud.gateway.routes[0].predicates[0]=Path=/api/rate-limited/**

# Filtres :
# 1. StripPrefix=2
spring.cloud.gateway.routes[0].filters[0]=StripPrefix=2

# 2. RequestRateLimiter=10,20
# 10 = nombre de requêtes par seconde autorisées
# 20 = rafale maximale (burst capacity)
spring.cloud.gateway.routes[0].filters[1]=RequestRateLimiter=10,20,#@redisRateLimiter

@Configuration
public class RateLimiterConfig {
    
    // @Bean pour créer un bean Spring
    // @Primary pour indiquer que c'est le KeyResolver par défaut
    @Bean
    @Primary
    // KeyResolver = détermine comment identifier un client unique
    KeyResolver userKeyResolver() {
        // Retourne un KeyResolver qui utilise le paramètre "user" de la requête
        return exchange -> {
            // exchange = contient les informations de la requête
            
            // Récupère le paramètre "user" de la requête
            String user = exchange.getRequest().getQueryParams().getFirst("user");
            
            // Mono.just() = crée un Mono qui émet immédiatement une valeur
            // Si user est null, utilise "anonymous"
            return Mono.just(user != null ? user : "anonymous");
        };
    }
    
    // KeyResolver basé sur l'IP du client
    @Bean
    KeyResolver ipKeyResolver() {
        return exchange -> {
            // Récupère l'adresse IP du client
            String ip = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
            return Mono.just(ip);
        };
    }
    
    // Configuration du RedisRateLimiter
    @Bean
    RedisRateLimiter redisRateLimiter() {
        // 10 requêtes par seconde, rafale de 20
        return new RedisRateLimiter(10, 20);
    }
}

# Installer Redis (sur Ubuntu/Debian)
sudo apt-get install redis-server

# Démarrer Redis
redis-server

# Tester le rate limiting
# Ces 10 requêtes devraient réussir
for i in {1..10}; do 
    curl "http://localhost:8080/api/rate-limited/health?user=testuser"
done

# Ces requêtes supplémentaires devraient échouer avec 429 Too Many Requests
for i in {1..5}; do 
    curl "http://localhost:8080/api/rate-limited/health?user=testuser"
done

# Ouvrir un terminal
cd chemin/vers/eureka-server

# Démarrer avec Maven
mvn spring-boot:run

# OU si vous avez le JAR
java -jar target/eureka-server-0.0.1-SNAPSHOT.jar

# Vérifier : http://localhost:8761

# Terminal 2 : Service A
cd chemin/vers/service-a
mvn spring-boot:run

# Terminal 3 : Service B  
cd chemin/vers/service-b
mvn spring-boot:run

# Terminal 4 : Service C
cd chemin/vers/service-c
mvn spring-boot:run

# Vérifier dans Eureka : http://localhost:8761
# Vous devriez voir les 3 services enregistrés

# Terminal 5 : API Gateway
cd chemin/vers/api-gateway
mvn spring-boot:run

# OU avec le JAR
java -jar target/api-gateway-0.0.1-SNAPSHOT.jar

# Vérifier : http://localhost:8080/actuator/health

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

=== SYSTEM STATUS ===
Environment: development
Data center: default

=== INSTANCES CURRENTLY REGISTERED WITH EUREKA ===
Application    AMIs    Availability Zones    Status
─────────────────────────────────────────────────────────────
API-GATEWAY    n/a     (1)                  UP (1) - hostname:api-gateway:8080
SERVICE-A      n/a     (1)                  UP (1) - hostname:service-a:8081
SERVICE-B      n/a     (1)                  UP (1) - hostname:service-b:8082
SERVICE-C      n/a     (1)                  UP (1) - hostname:service-c:8083

=== GENERAL INFO ===
Total number of instances: 4
Renews threshold: 6
Renews (last min): 6

# Liste de tous les services enregistrés
curl http://localhost:8761/eureka/apps

# Détails d'un service spécifique
curl http://localhost:8761/eureka/apps/SERVICE-A

# Informations sur cette instance
curl http://localhost:8761/eureka/apps/SERVICE-A/service-a:8081

# === ROUTES AUTOMATIQUES (NOMS EN MAJUSCULES) ===

# Accéder à Service A via le Gateway
# Format : http://gateway:port/NOM-SERVICE/endpoint
curl http://localhost:8080/SERVICE-A/health
curl http://localhost:8080/SERVICE-A/info

# Accéder à Service B via le Gateway
curl http://localhost:8080/SERVICE-B/health
curl http://localhost:8080/SERVICE-B/users

# Accéder à Service C via le Gateway
curl http://localhost:8080/SERVICE-C/health
curl http://localhost:8080/SERVICE-C/data

# === ROUTES MANUELLES (CONFIGURÉES) ===

# Accéder à Service A via route personnalisée
# Format : http://gateway:port/api/service-name/endpoint
curl http://localhost:8080/api/service-a/health
curl http://localhost:8080/api/service-a/info

# Accéder à Service B via route personnalisée
curl http://localhost:8080/api/service-b/health
curl http://localhost:8080/api/service-b/users

# Accéder à Service C via route personnalisée
curl http://localhost:8080/api/service-c/health
curl http://localhost:8080/api/service-c/data

# Tester route avec filtre personnalisé
curl http://localhost:8080/api/custom/health

# Vérifier les headers ajoutés
curl -v http://localhost:8080/api/custom/health

# Dans la réponse, vous devriez voir :
# < X-Custom-Header: CustomValue
# < X-Request-Time: 1234567890123

# Démarrer Redis (nécessaire pour rate limiting)
redis-server

# Tester rate limiting
# Ces 10 requêtes devraient réussir (200 OK)
for i in {1..10}; do 
    echo "Requête $i:"
    curl -w "%{http_code}\n" "http://localhost:8080/api/rate-limited/health?user=testuser"
    sleep 0.1
done

# Ces requêtes supplémentaires devraient échouer (429 Too Many Requests)
for i in {1..5}; do 
    echo "Requête supplémentaire $i:"
    curl -w "%{http_code}\n" "http://localhost:8080/api/rate-limited/health?user=testuser"
    sleep 0.1
done

# Tester routes protégées (devrait demander authentification)
curl http://localhost:8080/api/protected/endpoint
# Résultat : 401 Unauthorized

# Tester avec authentification correcte
curl -u user:password http://localhost:8080/api/service-a/health
# Résultat : 200 OK + réponse du service

# Tester routes publiques (devrait fonctionner sans auth)
curl http://localhost:8080/api/public/info
# Résultat : 200 OK

# === SIMULATION DE PANNE ===

# 1. Dans un terminal, arrêter Service B (Ctrl+C)

# 2. Attendre 30-90 secondes (temps d'expiration Eureka)

# 3. Vérifier dans Eureka : http://localhost:8761
# Service B devrait disparaître de la liste

# 4. Essayer d'accéder à Service B via Gateway
curl http://localhost:8080/SERVICE-B/health
# Résultat attendu : 503 Service Unavailable

# 5. Essayer d'accéder aux autres services (devraient fonctionner)
curl http://localhost:8080/SERVICE-A/health
# Résultat attendu : 200 OK

# Tester route avec retry configuré
curl http://localhost:8080/api/service-a/health

# Pour tester le retry, vous pouvez :
# 1. Temporairement arrêter un service
# 2. Faire une requête pendant l'arrêt
# 3. Redémarrer rapidement le service
# 4. Observer que le Gateway réessaie automatiquement

# Exemple avec 2 instances de Service A :
# Instance 1 : port 8081
# Instance 2 : port 8084 (même service, port différent)

# Gateway alterne automatiquement entre les instances
curl http://localhost:8080/SERVICE-A/health  # → Instance 1
curl http://localhost:8080/SERVICE-A/health  # → Instance 2
curl http://localhost:8080/SERVICE-A/health  # → Instance 1

# === CONFIGURATION DES ENDPOINTS ACTUATOR ===

# Exposition des endpoints
# gateway = routes et configuration du Gateway
# health = état de santé
# info = informations générales
# metrics = métriques de performance
# env = variables d'environnement
# configprops = propriétés de configuration
# loggers = configuration des logs
management.endpoints.web.exposure.include=gateway,health,info,metrics,env,configprops,loggers

# Afficher les détails de santé même pour les endpoints non sensibles
management.endpoint.health.show-details=always

# Activer l'endpoint gateway (pour voir les routes)
management.endpoint.gateway.enabled=true

# === CONFIGURATION DES MÉTRIQUES ===
# Activer l'export vers Prometheus
management.metrics.export.prometheus.enabled=true

# Activer le timing automatique pour les requêtes web
management.metrics.web.server.request.autotime.enabled=true

# === CONFIGURATION DES LOGS ===
# Niveau de log pour le Gateway
logging.level.org.springframework.cloud.gateway=INFO

# Niveau de log pour le client HTTP réactif
logging.level.reactor.netty=INFO

# Pattern de log personnalisé
logging.pattern.console=%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n

# === ENDPOINTS ACTUATOR UTILES ===

# 1. Informations générales
curl http://localhost:8080/actuator/info
# Résultat : Informations sur l'application, version, etc.

# 2. Santé de l'application
curl http://localhost:8080/actuator/health
# Résultat : {"status":"UP"} si tout va bien

# 3. Routes configurées
curl http://localhost:8080/actuator/gateway/routes
# Résultat : Liste de toutes les routes configurées

# 4. Refresh des routes (recharge la configuration)
curl -X POST http://localhost:8080/actuator/gateway/refresh
# Résultat : 200 OK, routes rechargées

# 5. Métriques
curl http://localhost:8080/actuator/metrics
# Résultat : Liste de toutes les métriques disponibles

# 6. Métrique spécifique
curl http://localhost:8080/actuator/metrics/gateway.requests
# Résultat : Statistiques sur les requêtes du Gateway

# 7. Configuration actuelle
curl http://localhost:8080/actuator/configprops
# Résultat : Toutes les propriétés de configuration chargées

# 8. Variables d'environnement
curl http://localhost:8080/actuator/env
# Résultat : Variables d'environnement et propriétés

[
  {
    "predicate": "Paths: [/api/service-a/**], match trailing slash: true",
    "metadata": {
      "id": "service-a"
    },
    "route_id": "service-a",
    "filters": [
      "[[StripPrefix parts = 2], order = 0]"
    ],
    "uri": "lb://service-a",
    "order": 0
  },
  {
    "predicate": "Paths: [/api/service-b/**], match trailing slash: true",
    "metadata": {
      "id": "service-b"
    },
    "route_id": "service-b",
    "filters": [
      "[[StripPrefix parts = 2], order = 0]"
    ],
    "uri": "lb://service-b",
    "order": 0
  }
]

# Dans application.properties

# Activer les métriques Prometheus
management.endpoints.web.exposure.include=prometheus
management.metrics.export.prometheus.enabled=true

# Endpoint Prometheus
management.endpoint.prometheus.enabled=true

# Configuration des métriques
management.metrics.web.server.request.autotime.enabled=true
management.metrics.distribution.percentiles-histogram.http.server.requests=true

# Endpoint Prometheus
curl http://localhost:8080/actuator/prometheus

# Exemple de métriques retournées :
# gateway_requests_seconds_count{routeId="service-a",outcome="SUCCESSFUL",status="200",} 5.0
# gateway_requests_seconds_sum{routeId="service-a",outcome="SUCCESSFUL",status="200",} 0.123
# jvm_memory_used_bytes{area="heap",id="G1 Eden Space",} 1.23456789E8

# === CONFIGURATION SÉCURITÉ AVANCÉE ===

# Configuration CORS (Cross-Origin Resource Sharing)
# Autoriser toutes les origines (à restreindre en production)
spring.cloud.gateway.globalcors.cors-configurations.[/**].allowed-origins=*
# Méthodes HTTP autorisées
spring.cloud.gateway.globalcors.cors-configurations.[/**].allowed-methods=GET,POST,PUT,DELETE,OPTIONS
# Headers autorisés
spring.cloud.gateway.globalcors.cors-configurations.[/**].allowed-headers=*
# Autoriser les credentials
spring.cloud.gateway.globalcors.cors-configurations.[/**].allow-credentials=true

# Configuration HTTPS
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=password
server.ssl.keyStoreType=PKCS12
server.ssl.keyAlias=tomcat

# Redirection HTTP vers HTTPS
server.http.port=8080
server.port=8443

@Configuration
@EnableWebFluxSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
        http
            .authorizeExchange(exchanges -> exchanges
                .pathMatchers("/actuator/**").permitAll()
                .pathMatchers("/api/public/**").permitAll()
                .pathMatchers("/api/v1/auth/**").permitAll()
                .anyExchange().authenticated()
            )
            // Désactiver HTTP Basic
            .httpBasic().disable()
            // Activer JWT
            .oauth2ResourceServer(ServerHttpSecurity.OAuth2ResourceServerSpec::jwt)
            .csrf().disable();
        return http.build();
    }
}

# === CONFIGURATION PERFORMANCE ===

# Compression HTTP
server.compression.enabled=true
server.compression.mime-types=application/json,application/xml,text/html,text/xml,text/plain
server.compression.min-response-size=1024

# Configuration du client HTTP
# Timeout de connexion (5 secondes)
spring.cloud.gateway.httpclient.connect-timeout=5000
# Timeout de réponse (10 secondes)
spring.cloud.gateway.httpclient.response-timeout=10s
# Configuration du pool de connexions
spring.cloud.gateway.httpclient.pool.max-idle-time=60000
spring.cloud.gateway.httpclient.pool.max-life-time=60000
spring.cloud.gateway.httpclient.pool.max-connections=1000

# Configuration du cache
spring.cloud.gateway.routes[0].filters[2]=CacheRequestBody=10MB

# Configuration des threads
server.tomcat.max-threads=200
server.tomcat.min-spare-threads=10

# === CONFIGURATION DES ERREURS ===

# Configuration des fallbacks
spring.cloud.gateway.routes[0].filters[3]=FallbackHeaders=ExecutionException

# Configuration des statuts d'erreur personnalisés
spring.cloud.gateway.routes[0].filters[4]=SetStatus=BAD_GATEWAY

# Configuration des retries avancés
# 3 tentatives, avec codes d'erreur spécifiques
spring.cloud.gateway.routes[0].filters[5]=Retry=3,INTERNAL_SERVER_ERROR,SERVICE_UNAVAILABLE,GATEWAY_TIMEOUT,IOException

# Timeout global pour les routes
spring.cloud.gateway.routes[0].metadata.timeout=15000

# Configuration du circuit breaker (nécessite Resilience4j)
spring.cloud.gateway.routes[0].filters[6]=CircuitBreaker=myCircuitBreaker

@Configuration
// @Order(-2) pour qu'il s'exécute avant les autres gestionnaires
@Order(-2)
public class GlobalErrorWebExceptionHandler implements ErrorWebExceptionHandler {
    
    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
        // Log l'erreur
        ex.printStackTrace();
        
        // Définit le statut HTTP
        exchange.getResponse().setStatusCode(HttpStatus.BAD_GATEWAY);
        
        // Optionnel : ajoute un message d'erreur personnalisé
        String errorMessage = "{\"error\":\"Gateway Error\",\"message\":\"" + ex.getMessage() + "\"}";
        exchange.getResponse().getHeaders().add("Content-Type", "application/json");
        
        // Écrit le message d'erreur dans le corps de la réponse
        DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(errorMessage.getBytes());
        return exchange.getResponse().writeWith(Mono.just(buffer));
    }
}

# Vérifier les routes actuelles
curl http://localhost:8080/actuator/gateway/routes

# Résultat attendu : Liste des routes configurées
# Si la liste est vide, les routes ne sont pas chargées

# Vérifier Eureka
curl http://localhost:8761/eureka/apps

# Vérifier un service spécifique
curl http://localhost:8761/eureka/apps/SERVICE-A

# Dans application.properties, vérifier :
spring.cloud.gateway.routes[0].id=service-a
spring.cloud.gateway.routes[0].uri=lb://service-a  # Bon nom de service ?
spring.cloud.gateway.routes[0].predicates[0]=Path=/api/service-a/**  # Bon chemin ?

# Dans les logs, chercher :
# "RoutePredicateHandlerMapping" - pour le routage
# "LoadBalancerClientFilter" - pour le load balancing
# "NotFoundException" - pour les routes non trouvées

# Vérifier que le service est dans Eureka
curl http://localhost:8761/eureka/apps/SERVICE-A

# Si réponse vide : le service n'est pas enregistré
# Vérifier les logs du service : doit afficher "Registering application SERVICE-A"

# ERREUR :
spring.cloud.gateway.routes[0].uri=lb://ServiceA  # Mauvais casse

# CORRECT :
spring.cloud.gateway.routes[0].uri=lb://service-a  # Minuscules, tirets

# Vérifier le statut dans Eureka
curl http://localhost:8761/eureka/apps/SERVICE-A

# Dans la réponse, chercher : "status":"DOWN"
# Si DOWN : vérifier les logs du service pour les erreurs

# Vérifier dans application.properties du Gateway :
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/  # Bonne URL ?
eureka.client.fetch-registry=true  # true = récupère le registre
eureka.client.register-with-eureka=true  # true = s'enregistre

# ERREUR :
spring.cloud.gateway.routes[0].filters[0]=StripPrefix:2  # Mauvais séparateur

# CORRECT :
spring.cloud.gateway.routes[0].filters[0]=StripPrefix=2  # Égalité =

// ERREUR : Classe sans @Component
public class MyFilterFactory extends AbstractGatewayFilterFactory { ... }

// CORRECT : Ajouter @Component
@Component  // ← Très important !
public class MyFilterFactory extends AbstractGatewayFilterFactory { ... }

# Les filtres s'appliquent dans l'ordre des index
spring.cloud.gateway.routes[0].filters[0]=AddRequestHeader=X-First,first
spring.cloud.gateway.routes[0].filters[1]=AddRequestHeader=X-Second,second
# X-First sera ajouté avant X-Second

# Activer les logs détaillés
logging.level.org.springframework.cloud.gateway=DEBUG
logging.level.org.springframework.cloud.gateway.filter=TRACE

# Vérifier si Redis tourne
redis-cli ping
# Résultat attendu : PONG

# Démarrer Redis (si arrêté)
redis-server

# Vérifier le port
netstat -an | grep 6379

# Vérifier dans application.properties :
spring.redis.host=localhost  # Bon hôte ?
spring.redis.port=6379       # Bon port ?

# Test de connexion
telnet localhost 6379
# Doit se connecter sans erreur

<!-- Vérifier dans pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

# Vérifier la syntaxe
# ERREUR :
spring.cloud.gateway.routes[0].filters[1]=RequestRateLimiter 10 20

# CORRECT :
spring.cloud.gateway.routes[0].filters[1]=RequestRateLimiter=10,20