Microservices en Java : architecture et pratique de A à Z

Microservices en Java : architecture et pratique de A à Z

L'architecture microservices (MSA) est devenue le standard de facto pour la construction d'applications modernes et évolutives. Contrairement au monolithe, où tout le code est un seul grand processus, les microservices divisent le système en petits services déployables indépendamment. Dans cet article, nous allons voir comment concevoir et implémenter des microservices en Java en utilisant des technologies populaires : Spring Boot, Docker, Kafka et Spring Cloud. Vous obtiendrez des recettes prêtes à l'emploi et des exemples de code.

1. Fondamentaux de l'architecture des microservices en Java

Avant d'écrire du code, il est important de comprendre les principes clés de la MSA :

\n
• Responsabilité unique (Single Responsibility) — chaque service est responsable d'une fonction métier (par exemple, Service de commandes, Service d'utilisateurs).
\n
• Déploiement indépendant — vous pouvez mettre à jour un service sans redémarrer tout le système.
\n
• Gestion décentralisée des données — chaque service possède sa propre base de données (Database per Service).
\n
• Faible couplage — les services communiquent via des protocoles légers (REST, gRPC, files de messages).
\n

Pour Java, le framework principal est Spring Boot associé à Spring Cloud (pour la découverte de services, la configuration, les passerelles API). Examinons un exemple minimal de microservice.

Exemple : un service REST simple avec Spring Boot

// pom.xml (extrait des dépendances)\n<dependency>\n    <groupId>org.springframework.boot</groupId>\n    <artifactId>spring-boot-starter-web</artifactId>\n</dependency>\n\n// UserServiceApplication.java\n@SpringBootApplication\npublic class UserServiceApplication {\n    public static void main(String[] args) {\n        SpringApplication.run(UserServiceApplication.class, args);\n    }\n}\n\n// UserController.java\n@RestController\n@RequestMapping("/api/users")\npublic class UserController {\n\n    @GetMapping("/{id}")\n    public ResponseEntity<String> getUser(@PathVariable Long id) {\n        // Dans un projet réel, ici un appel au repository\n        return ResponseEntity.ok("Utilisateur avec l'id : " + id);\n    }\n}

Ce microservice écoute sur le port 8080 et répond aux requêtes GET. Pour lancer un deuxième service (par exemple, le Service de commandes), créez simplement un autre projet Spring Boot avec un port différent (server.port=8081).

2. Pratique : Docker, Kafka et interaction entre services

Dans un système réel, les microservices ne peuvent pas communiquer directement via HTTP sans orchestration. Deux approches sont utilisées : synchrone (REST/Feign) et asynchrone (Message Broker).

2.1. Conteneurisation avec Docker

Chaque microservice est empaqueté dans une image Docker. Exemple de Dockerfile pour un service Java :

FROM openjdk:17-jdk-slim\nCOPY target/user-service-0.0.1-SNAPSHOT.jar app.jar\nEXPOSE 8080\nENTRYPOINT ["java", "-jar", "/app.jar"]

Ensuite, utilisez docker-compose.yml pour lancer tous les services en même temps :

version: '3.8'\nservices:\n  user-service:\n    build: ./user-service\n    ports:\n      - "8080:8080"\n  order-service:\n    build: ./order-service\n    ports:\n      - "8081:8081"\n  postgres:\n    image: postgres:15\n    environment:\n      POSTGRES_DB: mydb\n      POSTGRES_USER: user\n      POSTGRES_PASSWORD: pass

2.2. Interaction asynchrone via Apache Kafka

Lorsqu'un service doit notifier d'autres services d'un événement (par exemple, "commande créée"), il est préférable d'utiliser Kafka. Cela découple les services et améliore la tolérance aux pannes.

Exemple de producteur (Order Service envoie un événement) :

// KafkaProducerConfig.java\n@Configuration\npublic class KafkaProducerConfig {\n    @Bean\n    public ProducerFactory<String, String> producerFactory() {\n        Map<String, Object> props = new Ha