Zum Inhalt springen
Deutsch

Cached-Snapshot-Store

CachedSnapshotStore ist ein Decorator — wickle jeden SnapshotStore ein, um einen TTL-basierten Read-Through-Cache für loadLatest hinzuzufügen, gestützt auf einen beliebigen Cache (In-Memory, Redis oder Memcached).

import {
ActorSystem,
ActorSystemOptions,
} from 'actor-ts';
import {
CachedSnapshotStore,
CachedSnapshotStoreOptions,
ObjectStorageSnapshotStore,
ObjectStorageSnapshotStoreOptions,
} from 'actor-ts/persistence';
const objectStorageSnapshotStoreOptions = ObjectStorageSnapshotStoreOptions.create().withBackend(backend);
const underlying = new ObjectStorageSnapshotStore(
objectStorageSnapshotStoreOptions, // S3- / Filesystem-Backend
);
const cachedSnapshotStoreOptions = CachedSnapshotStoreOptions.create()
.withCache(cache) // Backing-Cache (typischerweise Redis)
.withTtlMs(60_000);
const cached = new CachedSnapshotStore(
underlying,
cachedSnapshotStoreOptions, // optionale TTL
);
const actorSystemOptions = ActorSystemOptions.create().withPersistence({
journal: myJournal,
snapshotStore: cached,
});
const system = ActorSystem.create('app', actorSystemOptions);

Drei Muster:

  1. Langsamer zugrunde liegender Store — Object-Storage mit Multi-Hop-Netzwerklatenz, verschlüsselter State mit teurer Entschlüsselung. Für den verschlüsselten Fall lies zuerst Sicherheit — der Cache hält Klartext: das ist der stärkste Grund, zum Cache zu greifen, und der eine, der eine Entscheidung braucht.
  2. Häufige Actor-Churn — gesharde Entities, die ständig passivieren / neu spawnen und jeweils denselben Snapshot neu lesen.
  3. Recovery-Stürme — Full-Cluster-Restart, jeder Actor lädt seinen Snapshot auf einmal. Der Cache reduziert redundante Loads, wenn derselbe Snapshot während des Sturms abgefragt wird.

Für lokale SQLite-gestützte Snapshots (Sub-Millisekunden-Reads) fügt der Cache Overhead ohne Nutzen hinzu. Nutze ihn nur, wenn der zugrunde liegende Store messbare Read-Latenz hat.

type CachedSnapshotStoreOptionsType = {
cache: Cache; // Backing-Cache (erforderlich)
ttlMs?: number; // Cache-TTL in ms, Default 5 Minuten
keyPrefix?: string; // Key-Prefix, Default 'snap:'
allowPlaintextCache?: boolean; // verschlüsselten State trotzdem cachen, Default false
};
FeldWas
cacheBacking-Cache (erforderlich) — in Produktion typischerweise Redis. Jeder Cache: In-Memory, Redis oder Memcached.
ttlMsCache-TTL in Millisekunden. Default: 5 Minuten.
keyPrefixKey-Prefix (Default 'snap:') — verhindert Kollisionen in geteilten Caches.
allowPlaintextCacheBestätigt, dass der Cache den Klartext von State halten darf, den der eingewickelte Store at rest verschlüsselt — und cacht trotzdem. Default false — siehe unten.

Der zugrunde liegende Store ist das erste Argument des Konstruktors — new CachedSnapshotStore(underlying, options) — keine Option.

Gecacht wird, was loadLatest zurückgibt, und das ist der dekodierte Domain-State: dekomprimiert und bei den Object-Storage-Stores entschlüsselt. Kombinierst du diesen Decorator mit client-seitiger Snapshot-Verschlüsselung, hält das Deployment zwei Kopien des States — eine verschlüsselt im Bucket, eine im Klartext in einem Cache, der dir gehört, den du mit anderen Subsystemen teilst und der oft unauthentifiziert in einem “privaten” Netz läuft. Die zweite Kopie zu lesen braucht weder den Bucket noch den Master-Key, und ein Redis-RDB-Dump hält sie danach weiter lesbar.

Am Bucket selbst wird dadurch nichts schwächer; die zweite Kopie ist die ganze Exposition. Das macht es zu einer Kompositions-Gefahr statt zu einem Fehler in einem der beiden Teile — und es ist eine Komposition, die genau diese Seite empfiehlt, weshalb sie hier ausgeschrieben steht.

Ein loadLatest, dessen State der eingewickelte Store at rest verschlüsselt hält, wird deshalb direkt aus dem eingewickelten Store bedient, ohne Cache, und der Decorator warnt einmal. Er räumt außerdem, was der Cache unter dieser persistenceId bereits hält: Ein Eintrag, der gecacht wurde, bevor der Actor seinen encryption()-Hook bekam oder bevor der Store auf Verschlüsselung konfiguriert wurde, bliebe sonst bis zum nächsten save oder bis zum Ablauf von ttlMs im Klartext lesbar. Der Preis ist ein Cache-Round-Trip pro verweigertem Load — pro jedem, nicht nur dem, der warnt — auf einem Pfad, der ohnehin den vollen Read des eingewickelten Stores zahlt. Beide Wege zur Verweigerung zählen — eine Per-Call-encryption-Direktive mit einem anderen Modus als 'none' und das withEncryption(...) des Stores selbst, das in den Options keines Calls je auftaucht:

persistence: CachedSnapshotStore caches decoded snapshot state, and on
'ObjectStorageSnapshotStore' this loadLatest asked for encryption — …
persistence: CachedSnapshotStore caches decoded snapshot state, and on
'ObjectStorageSnapshotStore' the store's own configuration keeps this
persistenceId encrypted — …

withAllowPlaintextCache(true) ist deine Bestätigung, dass der Cache so geschützt ist wie der Bucket, und stellt das Caching wieder her:

const cachedSnapshotStoreOptions = CachedSnapshotStoreOptions.create()
.withCache(cache)
.withTtlMs(60_000)
.withAllowPlaintextCache(true);

Vernünftige Antworten auf die Frage, die das Flag stellt:

  • In-Process-InMemoryCache — der Klartext verlässt den Knoten nicht, der ohnehin entschlüsselt hat. Setze das Flag.
  • Redis oder Memcached innerhalb derselben Vertrauensgrenze, mit Authentifizierung, Transportverschlüsselung und ohne Persistenz auf Platte — setze das Flag und halte die Begründung dort fest, wo deine übrigen Key-Management-Entscheidungen leben.
  • Ein geteilter Cache, der auch HTTP-Middleware trägt, oder einer, dessen Betreiber nicht die Betreiber des Buckets sind — setze das Flag nicht. Gib dem verschlüsselten Store einen eigenen Cache oder nimm die Cold-Start-Kosten in Kauf.

Er sieht beide Wege, auf denen ein Deployment zu Vertraulichkeit kommt: die Per-Call-PersistenceOptions, die der encryption()-Hook deines Actors erzeugt, und die Store-eigene Konfiguration, die er über das optionale Member encryptsAtRest(persistenceId) von SnapshotStore liest. ObjectStorageSnapshotStore implementiert das aus derselben encryption-Konfiguration, die auch sein Codec benutzt, pro persistenceId — ein Resolver, der ein Präfix verschlüsselt und ein anderes nicht, wird also pro Entity entschieden statt einmal für den ganzen Store.

Eine Per-Call-Direktive gewinnt gegen die Store-Konfiguration, hier wie überall sonst; ein explizites Per-Call-{ mode: 'none' } ist deshalb ein Opt-out, auch über einem Store, der verschlüsselt.

Zwei Dinge sieht er weiterhin nicht:

  • Einen Store, der verschlüsselt und nichts deklariert. Das Member ist optional, Abwesenheit heißt unbekannt, und unbekannt verweigert nie — die Regel, der die ganze Capability-Familie folgt, damit ein Fremd-Store nicht beim Upgrade sein Verhalten ändert, nur weil er nichts deklariert hat. Ein eigener Store, der verschlüsselt, sollte encryptsAtRest implementieren.
  • Verschlüsselung unterhalb des Stores — ein Server-Side- Default des Buckets oder ein Backend, das auf dem Weg nach außen verschlüsselt. Kein Member dieses Contracts meldet das, der Decorator hat nichts zu warnen, und die Entscheidung liegt allein bei dir.
  • loadLatest(persistenceId) — Read-Through mit TTL. Cache prüfen; bei Treffer zurückgeben. Bei Miss aus dem zugrunde liegenden Store laden, das Ergebnis mit ttlMs cachen, zurückgeben. Ein Load, den der Sicherheitsabschnitt verweigert, überspringt die Abfrage, löscht stattdessen den Eintrag und wird aus dem zugrunde liegenden Store bedient.
  • save(persistenceId, seq, state) — Write-Through-with-Invalidate: an den zugrunde liegenden Store delegieren, dann den Cache-Eintrag löschen. Es schreibt den neuen Snapshot bewusst nicht zurück — im Cluster können zwei Knoten beim Save konkurrieren, und ein lokaler Write würde einen veralteten Eintrag hinterlassen. Der nächste Read füllt neu.
  • loadBefore(persistenceId, seq) — nicht gecacht (zu viele mögliche seq-Werte, und selten genutzt — nur bei Recovery).
  • delete(persistenceId, toSeq) — an den zugrunde liegenden Store delegieren, dann den Cache-Eintrag invalidieren.

Nach einem save ist der Cache-Eintrag invalidiert, sodass der nächste loadLatest aus dem zugrunde liegenden Store neu holt und den gerade gespeicherten Snapshot zurückgibt. Die TTL ist das Sicherheitsnetz: selbst wenn ein Knoten zwischen dem zugrunde-liegenden Write und der Cache-Invalidierung abstürzt, läuft der veraltete Eintrag innerhalb von ttlMs ab.

Für einen langsamen zugrunde liegenden Store (etwa 50 ms pro Load) macht der Cache nachfolgende Loads desselben Snapshots zu Sub-Mikrosekunden-Operationen. Ein typischer Sharded-Entity-Workload sieht nach dem Aufwärmen 80–95 % Trefferquote.

Der Cache kann über Knoten geteilt werden — stütze ihn auf Redis oder Memcached, und jeder Knoten liest aus demselben Cache, sodass ein auf einem Knoten geladener Snapshot auf allen anderen ein Treffer ist. Stütze ihn stattdessen auf einen In-Memory-Cache, behält jeder Knoten seine eigene Kopie; Misses auf einem frischen Knoten zahlen die vollen Load-Kosten.