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);Wann du ihn brauchst
Abschnitt betitelt „Wann du ihn brauchst“Drei Muster:
- 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.
- Häufige Actor-Churn — gesharde Entities, die ständig passivieren / neu spawnen und jeweils denselben Snapshot neu lesen.
- 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.
Konfiguration
Abschnitt betitelt „Konfiguration“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};| Feld | Was |
|---|---|
cache | Backing-Cache (erforderlich) — in Produktion typischerweise Redis. Jeder Cache: In-Memory, Redis oder Memcached. |
ttlMs | Cache-TTL in Millisekunden. Default: 5 Minuten. |
keyPrefix | Key-Prefix (Default 'snap:') — verhindert Kollisionen in geteilten Caches. |
allowPlaintextCache | Bestä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.
Sicherheit — der Cache hält Klartext
Abschnitt betitelt „Sicherheit — der Cache hält Klartext“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 thispersistenceId 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.
Was der Check sieht — und was nicht
Abschnitt betitelt „Was der Check sieht — und was nicht“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
encryptsAtRestimplementieren. - 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.
Cache-Semantik
Abschnitt betitelt „Cache-Semantik“loadLatest(persistenceId)— Read-Through mit TTL. Cache prüfen; bei Treffer zurückgeben. Bei Miss aus dem zugrunde liegenden Store laden, das Ergebnis mitttlMscachen, 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öglicheseq-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.
Performance
Abschnitt betitelt „Performance“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.
Fallstricke
Abschnitt betitelt „Fallstricke“Wie geht es weiter
Abschnitt betitelt „Wie geht es weiter“- Snapshots — die Policy, der dies dient.
- Object-Storage-Snapshot-Store — der übliche langsame zugrunde liegende Store.
- In-Memory-Snapshot-Store — für Tests.
- SQLite-Snapshot-Store — der Single-Node-Default.
