Cache-Invalidierung in Microservices mit PHP 8.2
Mit wachsender Anzahl von Services lässt sich die PHP-Cache-Invalidierung über schlüsselbasiertes Löschen kaum noch beherrschen. Anhand von Codebeispielen zeige ich, wie Sie dieses Problem mit Tag-basiertem Caching, Event-Queues und definierten Konsistenzfenstern lösen.
Das Problem: Schlüsselbasiertes Löschen skaliert nicht
Ändert sich der Preis eines Produkts, veralten nicht nur die Produktdetails, sondern auch Kategorielisten, Suchergebnisse und Aktionsblöcke. Jeden Schlüssel einzeln zu kennen, schafft versteckte Abhängigkeiten zwischen den Services: Der Preis-Service müsste die Cache-Schlüssel des Katalog-Services kennen. Wird beim Hinzufügen einer neuen Liste der Löschcode nicht aktualisiert, sehen Nutzer weiterhin den alten Preis.
Ein Überblick über die gängigen Ansätze zur PHP-Cache-Invalidierung erleichtert die Auswahl:
| Ansatz | Funktionsweise | Stärke | Schwäche |
|---|---|---|---|
| Schlüsselbasiertes Löschen | Von der Datenänderung betroffene Schlüssel werden einzeln gelöscht | Einfach und nachvollziehbar | Services müssen die Schlüssel anderer Services kennen |
| Nur TTL | Wert wird nach Ablauf der Zeit automatisch erneuert | Kein zusätzlicher Code nötig | Bis zum Ablauf werden veraltete Daten angezeigt |
| Tag-basiert | Werte werden mit Tags gespeichert; beim Leeren des Tags werden alle gelöscht | Services bleiben lose gekoppelt | Tag-Sets müssen gepflegt werden |
| Versionsschlüssel | Dem Schlüsselnamen wird ein Versionszähler hinzugefügt; erhöht er sich, werden alte Schlüssel ignoriert | Kein Löschvorgang erforderlich | Alte Werte belegen bis zum Ablauf der TTL weiterhin Speicher |
Die Lösung: Tags für jeden Eintrag
Jeder im Cache abgelegte Wert wird zusammen mit den Tags der zugehörigen Entitäten gespeichert (z. B. product:48213, category:112). In Redis genügt dafür pro Tag ein Set, das die Schlüsselnamen enthält. Trifft ein Änderungs-Event ein, wird lediglich das Tag geleert – alle damit verknüpften Schlüssel werden in einem Vorgang gelöscht.
<?php
final class TaggedCache
{
public function __construct(private Redis $redis) {}
public function remember(string $key, array $tags, int $ttl, callable $fn): mixed
{
$hit = $this->redis->get($key);
if ($hit !== false) {
return unserialize($hit);
}
$value = $fn();
$this->redis->setex($key, $ttl, serialize($value));
foreach ($tags as $tag) {
$this->redis->sAdd("tag:$tag", $key);
}
return $value;
}
public function invalidate(string ...$tags): void
{
foreach ($tags as $tag) {
$keys = $this->redis->sMembers("tag:$tag");
if ($keys) { $this->redis->del(...$keys); }
$this->redis->del("tag:$tag");
}
}
}Services über eine Event-Queue entkoppeln
Der Preis-Service legt die Änderung als Event in die Queue; der Consumer kennt ausschließlich die Tags:
{
"event": "price.updated",
"product_id": 48213,
"tags": ["product:48213", "category:112", "campaign:autumn"]
}In dieser Struktur muss der Preis-Service nicht wissen, welche Seiten gecacht werden. Kommt eine neue Liste hinzu, muss sie beim Schreiben lediglich mit den passenden Tags versehen werden.
Setzen Sie für Tag-Sets eine Ablaufzeit in Höhe der längsten darin enthaltenen TTL; andernfalls sammeln sich abgelaufene Schlüsselnamen im Speicher an.
Alternative: Invalidierung über Versionsschlüssel
In manchen Fällen ist es einfacher, einen Teil des Schlüsselnamens zu ändern, statt Schlüssel aktiv zu löschen. Für jede Kategorie wird ein Versionszähler geführt; erhöht sich der Zähler, werden alte Schlüssel nicht mehr gelesen und nach Ablauf der TTL automatisch bereinigt.
<?php
// Kategori listesi anahtarı: sürüm değişince yeni anahtar üretilir
$version = (int) $redis->get('ver:category:112');
$key = "category:112:v{$version}:page:1";
// Kategoride bir ürün değiştiğinde
$redis->incr('ver:category:112');Diese Methode erzeugt keinen Lösch-Traffic, lässt jedoch alte Werte noch eine Weile im Speicher. Bei begrenztem Arbeitsspeicher sollten Sie die Eviction-Policy von Redis (z. B. allkeys-lru) und die TTL-Werte gemeinsam planen.
Gleichzeitige Anfragen bei leerem Cache
Wird ein stark frequentierter Schlüssel gelöscht, können viele gleichzeitige Anfragen parallel auf die Datenquelle zugreifen (Cache Stampede). Mit einem einfachen Lock lässt sich sicherstellen, dass nur die erste Anfrage den Wert neu berechnet, während die übrigen kurz warten und anschließend aus dem Cache lesen.
<?php
// Yalnızca kilidi alan istek değeri yeniden üretir (10 saniyelik kilit)
if ($redis->set("lock:$key", 1, ['nx', 'ex' => 10])) {
$value = $fn();
$redis->setex($key, $ttl, serialize($value));
$redis->del("lock:$key");
}Das Konsistenzfenster einplanen
- Bis das Event aus der Queue verarbeitet ist, können kurzzeitig veraltete Daten sichtbar sein; messen Sie dieses Zeitfenster und stimmen Sie es mit der Fachseite ab.
- Umgehen Sie bei kritischen Abläufen wie Zahlung und Lagerbestand den Cache und lesen Sie direkt aus der Primärquelle.
- Verhindern Sie Datenverlust bei einem Consumer-Ausfall: Nutzen Sie Bestätigungen (ack) und Wiederholungsversuche in der Queue.
- Fassen Sie bei Massenaktualisierungen Tags zusammen und löschen Sie diese in einem Schritt.
Eine ähnliche Entkopplung nutze ich auch bei strukturierten AI-Ausgaben; siehe Zuverlässige JSON-Ausgaben von lokalen LLMs. Ein Beispiel für die Steuerung von Batch-Jobs über eine Queue finden Sie im Projekt Lokale AI-Produktbildgenerierung.
Der Cache ist eine Performance-Schicht, keine Single Source of Truth. Kritische Entscheidungen müssen immer auf der Primärquelle basieren.
Fazit
Tag-basierte PHP-Cache-Invalidierung hebt den Zwang auf, dass Services die Schlüssel anderer Services kennen müssen, und sorgt dafür, dass Änderungen konsistent in allen Listen ankommen. Wenn Sie Ihre PHP-Infrastruktur skalieren möchten, werfen Sie gerne einen Blick auf meine Leistung für AI-gestützte Webentwicklung.
