Mikroservices in PHP: Architektur und fortgeschrittene Praxis

Mikroservices in PHP: Von der Theorie zur Produktion

Der Übergang vom Monolithen zur Mikroservice-Architektur in PHP ist nicht nur ein technologisches Upgrade, sondern eine grundlegende Änderung der Denkweise des Entwicklers. Auf fortgeschrittenem Niveau stehen wir vor echten Herausforderungen: verteilte Transaktionen, Datenkonsistenz, Netzwerklatenz und Debugging-Komplexität. In diesem Artikel analysieren wir die wichtigsten Muster und praktischen Techniken, die helfen, ein zuverlässiges und skalierbares System in PHP aufzubauen.

1. Kommunikation zwischen Diensten: synchron vs. asynchron

Die Wahl des Kommunikationsprotokolls ist das Erste, dem ein Architekt begegnet. Im PHP-Ökosystem gibt es zwei Hauptansätze.

Synchroner Austausch über REST/gRPC

Ideal für Operationen, die eine sofortige Antwort erfordern (z. B. Überprüfung des Benutzerguthabens). Erzeugt jedoch starre Abhängigkeiten: Wenn Dienst B ausfällt, fällt auch Dienst A aus. Es wird empfohlen, das Circuit-Breaker-Muster zu verwenden.

// Beispiel für einen Circuit Breaker in PHP mit der Bibliothek Guzzleuse GuzzleHttp\\Client;use GuzzleHttp\\Exception\\ConnectException;

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

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

        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; // Halboffener Zustand            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;    }}

Asynchroner Austausch über Warteschlangen (RabbitMQ, Kafka)

Für Operationen, die keine sofortige Antwort erfordern (E-Mail-Versand, Berichtserstellung). Verwenden Sie die Bibliothek php-amqplib.

// Veröffentlichung eines Ereignisses in 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. Datenverwaltung: CQRS und Event Sourcing

In Mikroservices sollte jeder Dienst seine eigenen Daten besitzen. Aber was tun, wenn Daten aus verschiedenen Diensten für einen Bericht zusammengeführt werden müssen? Hier hilft das CQRS-Muster (Command Query Responsibility Segregation).

Implementierung eines einfachen CQRS in PHP

Wir trennen Befehle (Schreiben) und Abfragen (Lesen). Für das Schreiben verwenden wir Doctrine ORM, für das Lesen direkte SQL-Abfragen an das Read-Modell.

// Befehl: Erstellung einer Bestellungclass CreateOrderCommand {    public function __construct(        public readonly int $userId,        public readonly array $items,        public readonly float $total    ) {}}

// Ver