# Architecture Microservices PHP : Implémentation Complète avec Symfony L'architecture microservices révolutionne le développement d'applications PHP. Après avoir implémenté cette approche sur 15+ projets majeurs, je partage mon guide complet pour migrer d'un monolithe vers des microservices robustes avec Symfony.
Principes fondamentaux des microservices ### Définition et avantages **Qu'est-ce qu'une architectur
e microservices ?** Les microservices décomposent une application monolithique en services indépendants, chacun responsable d'une fonctionnalité métier spécifique.
// Exemple : Service de gestion des commandes namespace App\OrderService; class OrderService { public function __construct( private OrderRepository $repository, private PaymentServiceInterface $paymentService, private InventoryServiceInterface $inventoryService, private NotificationServiceInterface $notificationService ) {} public function processOrder(CreateOrderDTO $orderDTO): Order { // Logique métier focalisée sur les commandes uniquement $order = Order::fromDTO($orderDTO); // Interactions avec autres services via APIs $payment = $this->paymentService->processPayment($order->getTotal()); $this->inventoryService->reserveItems($order->getItems()); $this->repository->save($order); $this->notificationService->sendOrderConfirmation($order); return $order; } }Avantages concrets observés Scalabilité granulaire - Montée en charge par service selon la de
mande - Resources allouées précisément - Performance optimisée par composant Équipes autonomes - Développement parallèle sans conflits - Technologies adaptées par contexte - Déploiements indépendants Résilience améliorée - Isolation des pannes - Dégradation gracieuse - Recovery rapide et ciblé ## Décomposition du monolithe PHP ### Stratégie de découpage 1. Identification des domaines métier
// Analyse du monolithe existant class MonolithicECommerceApp { // Domain 1: User Management public function registerUser() { } public function authenticateUser() { } public function updateProfile() { } // Domain 2: Product Catalog public function createProduct() { } public function searchProducts() { } public function manageInventory() { } // Domain 3: Order Processing public function createOrder() { } public function processPayment() { } public function shipOrder() { } // Domain 4: Customer Support public function createTicket() { } public function trackIssues() { } }# Services identifiés et leurs interactions services: user-service: responsibilities: - Authentication - User profiles - Permissions dependencies: [] catalog-service: responsibilities: - Product management - Search & filtering - Inventory tracking dependencies: - user-service (authentication) order-service: responsibilities: - Order lifecycle - Cart management dependencies: - user-service (user validation) - catalog-service (product validation) - payment-service (transactions) payment-service: responsibilities: - Payment processing - Transaction history dependencies: - user-service (user validation)Pattern Strangler Fig Migration progressive sans interruption
// Étape 1: Extraction du service User class LegacyUserController extends AbstractController { public function _construct( private UserService $legacyUserService, private UserServiceClient $newUserService // Client HTTP ) {} #[Route('/api/users/{id}', methods: ['GET'])] public function getUser(int $id): JsonResponse { // Feature flag pour migration progressive if ($this->isFeatureEnabled('newuser_service')) { return $this->newUserService->getUser($id); } // Fallback sur ancienne implémentation return $this->legacyUserService->getUser($id); } }// Client HTTP pour communication service-à-service class PaymentServiceClient { public function __construct( private HttpClientInterface $httpClient, private string $paymentServiceUrl ) {} public function processPayment(PaymentRequest $request): PaymentResponse { $response = $this->httpClient->request('POST', $this->paymentServiceUrl . '/api/payments', [ 'json' => $request->toArray(), 'headers' => [ 'Authorization' => 'Bearer ' . $this->getServiceToken(), 'Content-Type' => 'application/json', ], 'timeout' => 5, // Timeout court pour éviter cascading failures ] ); if ($response->getStatusCode() !== 200) { throw new PaymentServiceException('Payment failed'); } return PaymentResponse::fromArray($response->toArray()); } }// Publisher d'événements class OrderEventPublisher { public function construct( private MessageBusInterface $messageBus, private EventSerializer $serializer ) {} public function publishOrderCreated(Order $order): void { $event = new OrderCreatedEvent( orderId: $order->getId(), userId: $order->getUserId(), total: $order->getTotal(), items: $order->getItems()->toArray(), occurredAt: new \DateTimeImmutable() ); $this->messageBus->dispatch( new Envelope($event, [ new AmqpStamp('order.created') ]) ); } } // Consumer d'événements class InventoryEventHandler implements MessageHandlerInterface { public function construct( private InventoryService $inventoryService ) {} public function __invoke(OrderCreatedEvent $event): void { // Traitement asynchrone de la réservation stock foreach ($event->items as $item) { $this->inventoryService->reserveItem( $item['productId'], $item['quantity'] ); } } }Circuit Breaker Pattern
// Protection contre les cascading failures class CircuitBreakerServiceClient { private const FAILURETHRESHOLD = 5; private const TIMEOUTDURATION = 30; // seconds public function _construct( private HttpClientInterface $httpClient, private CacheInterface $cache ) {} public function callService(string $endpoint, array $data): ?array { $circuitKey = 'circuitbreaker' . md5($endpoint); $failures = $this->cache->get($circuitKey . 'failures', 0); $lastFailure = $this->cache->get($circuitKey . 'lastfailure'); // Circuit ouvert : rejeter immédiatement if ($failures >= self::FAILURETHRESHOLD) { if (time() - $lastFailure < self::TIMEOUTDURATION) { throw new ServiceUnavailableException('Circuit breaker open'); } // Tentative de récupération $this->cache->delete($circuitKey . 'failures'); } try { $response = $this->httpClient->request('POST', $endpoint, [ 'json' => $data, 'timeout' => 3 ]); // Succès : reset du compteur $this->cache->delete($circuitKey . 'failures'); return $response->toArray(); } catch (\Exception $e) { // Échec : incrémenter le compteur $this->cache->set($circuitKey . 'failures', $failures + 1, 300); $this->cache->set($circuitKey . 'last_failure', time(), 300); throw $e; } } }API Gateway et authentification ### Configuration API Gateway
# nginx.conf - API Gateway configuration upstream userservice { server user-service:8000; } upstream orderservice { server order-service:8000; } upstream catalogservice { server catalog-service:8000; } server { listen 80; servername api.monapp.com; # Rate limiting global limitreqzone $binaryremoteaddr zone=api:10m rate=100r/m; limitreq zone=api burst=20 nodelay; # Routes vers les services location /api/v1/users { proxypass http://userservice; include proxyparams; } location /api/v1/orders { authrequest /auth; # Vérification auth avant routage proxypass http://orderservice; include proxyparams; } location /api/v1/products { proxypass http://catalogservice; include proxyparams; } # Endpoint d'authentification interne location = /auth { internal; proxypass http://userservice/internal/auth; proxypassrequestbody off; proxysetheader Content-Length ""; proxysetheader X-Original-URI $request_uri; } }Service d'authentification centralisé
// JWT Token Service class JWTTokenService { public function construct( private string $secretKey, private int $ttl = 3600 ) {} public function generateToken(User $user): string { $payload = [ 'sub' => $user->getId(), 'email' => $user->getEmail(), 'roles' => $user->getRoles(), 'iat' => time(), 'exp' => time() + $this->ttl, 'iss' => 'user-service' ]; return JWT::encode($payload, $this->secretKey, 'HS256'); } public function validateToken(string $token): TokenPayload { try { $decoded = JWT::decode($token, new Key($this->secretKey, 'HS256')); return TokenPayload::fromArray((array) $decoded); } catch (\Exception $e) { throw new InvalidTokenException('Token validation failed'); } } } // Middleware d'authentification pour tous les services class AuthenticationMiddleware { public function construct( private JWTTokenService $tokenService ) {} public function process(Request $request, RequestHandler $handler): Response { $authHeader = $request->headers->get('Authorization'); if (!$authHeader || !strstartswith($authHeader, 'Bearer ')) { throw new UnauthorizedException('Missing or invalid authorization header'); } $token = substr($authHeader, 7); $payload = $this->tokenService->validateToken($token); // Injection des infos utilisateur dans la requête $request->attributes->set('userid', $payload->sub); $request->attributes->set('userroles', $payload->roles); return $handler->handle($request); } }Orchestration avec Docker ### Configuration multi-services
# docker-compose.yml version: '3.8' services: # API Gateway nginx: image: nginx:alpine ports: - "80:80" volumes: - ./nginx.conf:/etc/nginx/nginx.conf dependson: - user-service - order-service - catalog-service # Service utilisateur user-service: build: ./services/user environment: - DATABASEURL=postgresql://user:pass@user-db:5432/users - REDISURL=redis://redis:6379 dependson: - user-db - redis deploy: replicas: 2 user-db: image: postgres:15 environment: POSTGRESDB: users POSTGRESUSER: user POSTGRESPASSWORD: pass volumes: - userdata:/var/lib/postgresql/data # Service commandes order-service: build: ./services/order environment: - DATABASEURL=postgresql://order:pass@order-db:5432/orders - USERSERVICEURL=http://user-service:8000 - PAYMENTSERVICEURL=http://payment-service:8000 dependson: - order-db - rabbitmq order-db: image: postgres:15 environment: POSTGRESDB: orders POSTGRESUSER: order POSTGRESPASSWORD: pass volumes: - orderdata:/var/lib/postgresql/data # Message broker pour événements rabbitmq: image: rabbitmq:3-management environment: RABBITMQDEFAULTUSER: admin RABBITMQDEFAULTPASS: admin ports: - "15672:15672" # Management UI # Cache partagé redis: image: redis:7-alpine ports: - "6379:6379" volumes: userdata: orderdata:Dockerfile optimisé pour production
# Dockerfile multi-stage pour service PHP FROM php:8.3-fpm-alpine AS base # Installation extensions PHP nécessaires RUN apk add --no-cache \ postgresql-dev \ redis \ && docker-php-ext-install \ pdo_pgsql \ opcache # Configuration PHP production COPY php.ini /usr/local/etc/php/ FROM base AS dependencies # Installation Composer COPY --from=composer:2 /usr/bin/composer /usr/bin/composer # Installation dépendances PHP WORKDIR /app COPY composer.json composer.lock ./ RUN composer install --no-dev --optimize-autoloader --no-scripts FROM base AS production # Copie de l'application WORKDIR /app COPY --from=dependencies /app/vendor ./vendor COPY . . # Optimisations finales RUN composer dump-autoload --optimize --classmap-authoritative RUN php bin/console cache:warmup --env=prod # Configuration utilisateur non-root RUN addgroup -g 1000 appuser && adduser -u 1000 -G appuser -D appuser RUN chown -R appuser:appuser /app USER appuser EXPOSE 8000 CMD ["php-fpm"]Monitoring et observabilité ### Instrumentation distribuée
// Tracing distribué avec OpenTelemetry class TracingMiddleware { public function _construct( private TracerInterface $tracer, private string $serviceName ) {} public function process(Request $request, RequestHandler $handler): Response { $span = $this->tracer->spanBuilder('httprequest') ->setSpanKind(SpanKind::KINDSERVER) ->setAttribute('http.method', $request->getMethod()) ->setAttribute('http.route', $request->getPathInfo()) ->setAttribute('service.name', $this->serviceName) ->startSpan(); $scope = $span->activate(); try { $response = $handler->handle($request); $span->setStatus(StatusCode::STATUSOK); $span->setAttribute('http.statuscode', $response->getStatusCode()); return $response; } catch (\Throwable $e) { $span->setStatus(StatusCode::STATUSERROR, $e->getMessage()); $span->recordException($e); throw $e; } finally { $scope->detach(); $span->end(); } } }Métriques applicatives
// Collecte de métriques métier class BusinessMetricsCollector { public function _construct( private CounterInterface $orderCounter, private HistogramInterface $orderValueHistogram, private GaugeInterface $activeUsersGauge ) {} public function recordOrderCreated(Order $order): void { $this->orderCounter->increment([ 'status' => $order->getStatus(), 'paymentmethod' => $order->getPaymentMethod() ]); $this->orderValueHistogram->record( $order->getTotal(), ['currency' => $order->getCurrency()] ); } public function updateActiveUsers(int $count): void { $this->activeUsersGauge->set($count); } }Déploiement et CI/CD ### Pipeline de déploiement
# .github/workflows/microservices-deploy.yml name: Microservices Deployment on: push: branches: [main] paths: - 'services/' jobs: detect-changes: runs-on: ubuntu-latest outputs: services: ${{ steps.changes.outputs.services }} steps: - uses: actions/checkout@v4 - uses: dorny/paths-filter@v2 id: changes with: filters: | user: - 'services/user/' order: - 'services/order/' catalog: - 'services/catalog/' deploy-services: needs: detect-changes runs-on: ubuntu-latest strategy: matrix: service: ${{ fromJSON(needs.detect-changes.outputs.services) }} steps: - uses: actions/checkout@v4 - name: Run tests for ${{ matrix.service }} run: | cd services/${{ matrix.service }} composer install php bin/phpunit - name: Build Docker image run: | docker build -t myapp-${{ matrix.service }}:${{ github.sha }} \ ./services/${{ matrix.service }} - name: Deploy to Kubernetes run: | kubectl set image deployment/${{ matrix.service }} \ app=myapp-${{ matrix.service }}:${{ github.sha }} kubectl rollout status deployment/${{ matrix.service }}Configuration Kubernetes
# k8s/user-service-deployment.yml apiVersion: apps/v1 kind: Deployment metadata: name: user-service spec: replicas: 3 selector: matchLabels: app: user-service template: metadata: labels: app: user-service spec: containers: - name: app image: myapp-user-service:latest ports: - containerPort: 8000 env: - name: DATABASE_URL valueFrom: secretKeyRef: name: user-service-secrets key: database-url resources: requests: memory: "128Mi" cpu: "100m" limits: memory: "512Mi" cpu: "500m" livenessProbe: httpGet: path: /health port: 8000 initialDelaySeconds: 30 periodSeconds: 10 readinessProbe: httpGet: path: /ready port: 8000 initialDelaySeconds: 5 periodSeconds: 5 --- apiVersion: v1 kind: Service metadata: name: user-service spec: selector: app: user-service ports: - protocol: TCP port: 8000 targetPort: 8000