ARCHITECTURES MICRO-SERVICES

Définition

L'architecture micro-services est un style architectural qui structure une application comme un ensemble de petits services indépendants, chacun exécutant un processus métier spécifique et communiquant via des API bien définies.

Chaque micro-service est développé, déployé et mis à l'échelle indépendamment, ce qui permet une plus grande flexibilité et résilience par rapport aux architectures monolithiques.

Caractéristiques Principales

Services indépendants : Chaque service peut être développé, déployé et mis à l'échelle séparément
Communication via API : Les services communiquent via des interfaces bien définies (REST, gRPC, messages)
Technologies hétérogènes : Chaque service peut utiliser la technologie la plus adaptée
Déploiement indépendant : Possibilité de déployer un seul service sans affecter les autres
Données décentralisées : Chaque service possède sa propre base de données
Organisation par domaine : Services organisés autour des domaines métiers

🔒

API GATEWAY

Point d'entrée unique pour toutes les requêtes clientes. Route les requêtes vers les micro-services appropriés et fournit des fonctionnalités transversales comme la sécurité, la surveillance et la résilience.

Fonction: Routage API, Sécurité, Surveillance

Exemple de Configuration Spring Cloud Gateway

@Configuration

public class GatewayConfig {

  @Bean

  public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {

    return builder.routes()

      .route("user-service", r -> r

        .path("/api/users/**")

        .uri("lb://user-service"))

      .route("order-service", r -> r

        .path("/api/orders/**")

        .uri("lb://order-service"))

      .build();

  }

}

📋

SERVICE REGISTRY

Maintient un registre des instances de services disponibles. Les services s'enregistrent eux-mêmes et découvrent dynamiquement les autres services.

Fonction: Découverte de services

Exemple de Service Registry avec Eureka

@SpringBootApplication

@EnableEurekaServer

public class ServiceRegistryApplication {

  public static void main(String[] args) {

    SpringApplication.run(ServiceRegistryApplication.class, args);

  }

}

// Configuration application.yml

server:

  port: 8761

eureka:

  client:

    register-with-eureka: false

    fetch-registry: false

⚙️

CONFIG SERVER

Gestion centralisée de la configuration. Fournit une configuration externe pour les applications depuis des sources comme les dépôts Git.

Fonction: Gestion de configuration

Exemple de Config Server

@SpringBootApplication

@EnableConfigServer

public class ConfigServerApplication {

  public static void main(String[] args) {

    SpringApplication.run(ConfigServerApplication.class, args);

  }

}

// Configuration application.yml

server:

  port: 8888

spring:

  cloud:

    config:

      server:

        git:

          uri: https://github.com/company/config-repo

          clone-on-start: true

💻

MICRO-SERVICES

Services indépendants qui exécutent une logique métier spécifique. Chaque service gère un domaine fonctionnel particulier et communique avec les autres via des API.

Fonction: Exécution de la logique métier

Exemple de Micro-Service Utilisateur

@SpringBootApplication

@EnableEurekaClient

public class UserServiceApplication {

  public static void main(String[] args) {

    SpringApplication.run(UserServiceApplication.class, args);

  }

}

@RestController

@RequestMapping("/api/users")

public class UserController {

  @Autowired

  private UserService userService;

  @GetMapping("/{id}")

  public ResponseEntity<User> getUser(@PathVariable Long id) {

    return ResponseEntity.ok(userService.findById(id));

  }

}

🛡️

CIRCUIT BREAKER

Fournit la tolérance aux pannes et aux latences. Prévient les échecs en cascade en échouant rapidement et en fournissant des mécanismes de secours.

Fonction: Tolérance aux pannes

Exemple de Circuit Breaker avec Resilience4j

@Service

public class OrderService {

  @Autowired

  private PaymentServiceClient paymentService;

  @CircuitBreaker(name = "payment-service", fallbackMethod = "paymentFallback")

  @Retry(name = "payment-service")

  @TimeLimiter(name = "payment-service")

  public PaymentResponse processPayment(PaymentRequest request) {

    return paymentService.process(request);

  }

  public PaymentResponse paymentFallback(PaymentRequest request, Exception ex) {

    // Logique de fallback

    return new PaymentResponse("FALLBACK", "Service temporairement indisponible");

  }

}

⚖️

LOAD BALANCER

Fournit l'équilibrage de charge côté client. Distribue les requêtes entre plusieurs instances d'un service pour de meilleures performances et disponibilité.

Fonction: Distribution de charge

Exemple de Load Balancing avec Spring Cloud LoadBalancer

@Configuration

public class LoadBalancerConfig {

  @Bean

  ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerFactory() {

    return new DefaultReactiveLoadBalancerFactory(

      Map.of(

        "user-service", new RoundRobinLoadBalancer(null, "user-service"),

        "order-service", new RoundRobinLoadBalancer(null, "order-service")

      )

    );

  }

}

Structure d'un Projet Micro-Services

project-root/

├── service-registry/          # Eureka Server

├── api-gateway/               # Spring Cloud Gateway

├── config-server/             # Configuration centralisée

├── user-service/              # Service Utilisateur

│   ├── src/main/java/

│   │   └── com/example/users/

│   │       ├── UserApplication.java

│   │       ├── controller/UserController.java

│   │       ├── service/UserService.java

│   │       ├── repository/UserRepository.java

│   │       └── model/User.java

│   └── pom.xml

├── order-service/             # Service Commande

│   ├── src/main/java/

│   │   └── com/example/orders/

│   │       ├── OrderApplication.java

│   │       ├── controller/OrderController.java

│   │       ├── service/OrderService.java

│   │       ├── repository/OrderRepository.java

│   │       └── model/Order.java

│   └── pom.xml

├── payment-service/           # Service Paiement

└── notification-service/      # Service Notification

AVANTAGES

Scalabilité indépendante: Chaque service peut être scalé selon ses besoins
Technologies variées: Chaque service peut utiliser la meilleure technologie
Déploiement flexible: Déploiement indépendant des services
Résilience: Échec d'un service n'affecte pas les autres
Équipes autonomes: Équipes spécialisées par service
Maintenance facilitée: Services plus petits et plus simples
Performance optimale: Services optimisés pour leurs fonctions

INCONVÉNIENTS

Complexité accrue: Gestion de la communication inter-services
Latence réseau: Communication via réseau entre services
Consistance des données: Difficile à maintenir entre services
Surcharge opérationnelle: Plus de services à surveiller
Problèmes de débogage: Traces distribuées complexes
Coût initial élevé: Infrastructure et outillage nécessaires
Gestion des transactions: Transactions distribuées complexes

Cas d'Utilisation

L'architecture micro-services est particulièrement adaptée aux applications complexes, aux grandes organisations et aux projets nécessitant une grande scalabilité.

Applications à grande échelle avec de nombreux utilisateurs
Organisations avec plusieurs équipes de développement
Projets nécessitant une scalabilité dynamique
Applications avec des exigences de disponibilité élevées
Projets où différentes parties de l'application évoluent à des rythmes différents
Entreprises adoptant une approche DevOps mature

CONTRÔLES D'ANIMATION

Afficher/Masquer Labels:

Accélérer:

Ralentir:

Réinitialiser Animation:

Simuler Requête:

Réinitialiser Disposition: