Microservices en PHP : architecture et pratique avancée

Microservices en PHP : de la théorie à la production

Passer d'un monolithe à une architecture microservices en PHP n'est pas simplement une mise à niveau technologique, mais un changement fondamental dans la mentalité du développeur. Au niveau avancé, nous sommes confrontés à des défis réels : transactions distribuées, cohérence des données, latence réseau et complexité du débogage. Dans cet article, nous allons détailler les modèles clés et les techniques pratiques qui vous aideront à construire un système fiable et évolutif en PHP.

1. Communication entre services : synchrone vs asynchrone

Le choix du protocole de communication est la première chose à laquelle un architecte est confronté. Dans l'écosystème PHP, il existe deux approches principales.

Communication synchrone via REST/gRPC

Idéal pour les opérations nécessitant une réponse immédiate (par exemple, vérification du solde d'un utilisateur). Cependant, cela crée des dépendances fortes : si le service B tombe, le service A tombera aussi. Il est recommandé d'utiliser le modèle Circuit Breaker.

// Exemple de Circuit Breaker en PHP utilisant la bibliothèque Guzzleuse GuzzleHttp\\Client;use GuzzleHttp\\Exception\\ConnectException;

class CircuitBreaker {    private int $failureCount = 0;    private int $threshold = 3;    private int $timeout = 30; // secondes    private bool $open = false;    private int $lastFailureTime = 0;

    public function call(string $url): ?array {        if ($this->isOpen()) {            return null; // Court-circuit rapide        }

        try {            $client = new Client(['timeout' => 2.0]);            $response = $client->get($url);            $this->reset();            return json_decode($response->getBody(), true);        } catch (ConnectException $e) {            $this->recordFailure();            return null;        }    }

    private function isOpen(): bool {        if (!$this->open) return false;        if (time() - $this->lastFailureTime > $this->timeout) {            $this->open = false; // État semi-ouvert            return false;        }        return true;    }

    private function recordFailure(): void {        $this->failureCount++;        $this->lastFailureTime = time();        if ($this->failureCount >= $this->threshold) {            $this->open = true;        }    }

    private function reset(): void {        $this->failureCount = 0;        $this->open = false;    }}

Communication asynchrone via files d'attente (RabbitMQ, Kafka)

Pour les opérations qui ne nécessitent pas de réponse instantanée (envoi d'email, génération de rapports). Utilisez la bibliothèque php-amqplib.

// Publication d'un événement dans RabbitMQuse PhpAmqpLib\\Connection\\AMQPStreamConnection;use PhpAmqpLib\\Message\\AMQPMessage;

$connection = new AMQPStreamConnection('localhost', 5672, 'guest', 'guest');$channel = $connection->channel();

$channel->queue_declare('order_created', false, true, false, false);

$data = json_encode([    'order_id' => 12345,    'user_id' => 678,    'total' => 1500.00]);$msg = new AMQPMessage($data, ['delivery_mode' => AMQPMessage::DELIVERY_MODE_PERSISTENT]);$channel->basic_publish($msg, '', 'order_created');

$channel->close();$connection->close();

2. Gestion des données : CQRS et Event Sourcing

Dans les microservices, chaque service doit posséder ses propres données. Mais que faire si vous devez combiner des données de différents services pour un rapport ? Le modèle CQRS (Command Query Responsibility Segregation) vient à la rescousse.

Implémentation d'un CQRS simple en PHP

Séparons les commandes (écriture) et les requêtes (lecture). Pour l'écriture, utilisons Doctrine ORM, pour la lecture, des requêtes SQL directes vers le modèle de lecture.

// Commande : création d'une commandeclass CreateOrderCommand {    public function __construct(        public readonly int $userId,        public readonly array $items,        public readonly float $total    ) {}}

// Tra