Memcached-Cache
MemcachedCache ist die Memcached-gestützte Cache-
Implementierung. Verteilter Cache über Pods, geteilt über
Prozesse hinweg.
import { MemcachedCache, MemcachedCacheOptions } from 'actor-ts/cache';
const memcachedCacheOptions = MemcachedCacheOptions.create().withServers('memcached-1:11211,memcached-2:11211');const cache = new MemcachedCache( memcachedCacheOptions,);Wann Memcached
Abschnitt betitelt „Wann Memcached“Zwei Hauptgründe:
- Bestehende Memcached-Infrastruktur — dein Team betreibt es bereits.
- Reiner Cache-Anwendungsfall — du brauchst Redis’ Extra- Features nicht (Persistenz, Pub/Sub, Scripting, Sorted Sets).
Memcached ist einfacher als Redis — weniger Features, geringerer operativer Footprint, geringerer Speicher-Overhead. Für pures Key-Value-Caching mit TTLs reicht das voll.
Konfiguration
Abschnitt betitelt „Konfiguration“type MemcachedCacheOptionsType = { servers?: string; // kommagetrennt, Default 'localhost:11211' username?: string; password?: string; keyPrefix?: string; // serverseitig, auf jede Operation angewendet client?: MemcachedClientLike; // vorgefertigter memjs-Client};memjs (der zugrunde liegende Client) unterstützt SASL-Auth
über username/password. Mehrere Server werden über Hashing
verteilt.
Allein aus der Config
Abschnitt betitelt „Allein aus der Config“Das Framework registriert die Memcached-Factory selbst; ein Cache kommt
also auf Memcached hoch, ohne registerCache-Aufruf und ohne irgendein
new MemcachedCache(...) in deinem Code — es braucht nur eine Plugin-Id
und einen Block:
actor-ts.cache { sessions.plugin = "actor-ts.cache.memcached" # cache('sessions') is Memcached
memcached { servers = "memcache-a:11211,memcache-b:11211" username = ${?MEMCACHED_USERNAME} password = ${?MEMCACHED_PASSWORD} key-prefix = "my-app:" }}Die Blätter sind die Felder aus MemcachedCacheOptionsType oben in
kebab-case. servers ist ein kommagetrennter String und keine
Liste, weil memjs’ Client.create genau das nimmt.
Ein leerer String bedeutet „nicht gesetzt”. username, password
und key-prefix werden als "" ausgeliefert, damit du die Form des Keys
siehst; der Reader verwirft sie, statt sie weiterzureichen, und ein leeres
servers fällt auf das eingebaute localhost:11211 durch, statt
abgelehnt zu werden.
Jeder benannte Cache kann eigene Verbindungs-Settings haben, Blatt für Blatt über den globalen Block gelegt:
actor-ts.cache { memcached.servers = "memcache-a:11211"
sessions { plugin = "actor-ts.cache.memcached", memcached.key-prefix = "sess:" }}memjs ist ein lazy geladener optionaler Peer, der Block kostet also
nichts, solange kein Cache tatsächlich darauf auflöst: Der Treiber wird
bei der ersten Cache-Operation importiert, nicht beim Start.
Peer-Dependency
Abschnitt betitelt „Peer-Dependency“npm install memjs# oder: bun add memjsWas funktioniert
Abschnitt betitelt „Was funktioniert“| Cache-Methode | Memcached-Implementierung |
|---|---|
get/set/delete | Direkte Memcached-Befehle. |
incr | Kombination aus Memcached INCR/ADD. |
setIfAbsent | Memcached ADD (atomar). |
mget/mset | Parallele Single-Key-Operationen. |
mget/mset sind auf Memcached nicht Single-Round-Trip (keine
Multi-Key-Befehle). Das Framework parallelisiert die einzelnen
Operationen.
Memcached vs. Redis
Abschnitt betitelt „Memcached vs. Redis“| Aspekt | Memcached | Redis |
|---|---|---|
| Speicher-Overhead pro Eintrag | Niedriger | Höher |
| Multi-Key-Operationen | Langsamer (parallele Single-Key) | Schneller (MGET, MSET) |
| Persistenz | Keine | RDB / AOF verfügbar |
| Pub/Sub | Nein | Ja |
| Datentypen | Nur Strings | Strings, Listen, Sets, Hashes, Sorted Sets |
| Cluster-Support | Clientseitiges Hashing | Eingebautes Clustering |
| Replikation | Keine (oder über Sidecars) | Eingebaute Replikation |
Für puren Cache: beides funktioniert. Redis gewinnt bei fast allem anderen, was das Framework wollen könnte. Memcached gewinnt bei minimalem operativen Footprint, wenn Caching der einzige Bedarf ist.
Eviction
Abschnitt betitelt „Eviction“// Memcached konfiguriert mit --memory-limit=2048 (MB)// → LRU-Eviction, sobald vollMemcacheds Eviction ist LRU, konfiguriert auf der Memcached- Serverebene (nicht vom Cache-Client). Keine clientseitige Eviction-Policy.
Für einen Cache fester Größe ist das okay — Memcached wirft alte Einträge raus, um Platz zu schaffen.
Für alles, was eine Garantie trägt, ist es das nicht.
InMemoryCache evictet Einträge ohne Garantie, bevor er ein Lock,
einen Rate-Limit-Zähler oder einen Idempotency-Record anfasst; hier
gibt es dazu kein Gegenstück, denn die Entscheidung fällt im Server
und der Client wird nicht gefragt. Ein von setIfAbsent
geschriebener Eintrag kann also mit dem größten Teil seiner TTL
verschwinden — ein zweimal vergebenes Lock, ein zurückgesetztes
Limit, ein Retry, der seinen Handler erneut ausführt — und nichts in
der API meldet es. Dimensioniere die Memcached-Instanz für die
Garantien, die sie hält, halte sie von einem Key-Raum fern, den
Aufrufer aufzählen können, und siehe
was Eviction schützt und was nicht
für die Grundlage der Garantie. Das ist unabhängig von der
Topologie-Gefahr weiter unten: die braucht einen Server, der dazu-
oder wegkommt, diese hier nur Speicherdruck.
Connection-Pooling
Abschnitt betitelt „Connection-Pooling“memjs hält seinen eigenen Connection-Pool; das Framework
verwaltet ihn nicht direkt. Tune über memjs-Optionen, falls
nötig (meist sind die Defaults okay).
Wohin als Nächstes
Abschnitt betitelt „Wohin als Nächstes“- Cache-Übersicht — das große Bild.
- In-Memory-Cache — für Single-Pod.
- Redis-Cache — mehr Features.
