Zum Inhalt springen
actor-ts
Deutsch

Redis-Cache

RedisCache ist die Redis-gestützte Cache-Implementierung. Produktionsreif, Multi-Pod-sicher, mit Single-Round-Trip-Bulk- Operationen.

import { RedisCache } from 'actor-ts';


const cache = new RedisCache({
  url: 'redis://redis.example.com:6379',
});

Wann Redis

Abschnitt betitelt „Wann Redis“

Die meisten Multi-Pod-Produktionsfälle:

  • Cache-Sharing über Pods — Pods sehen denselben Cache-State.
  • Bulk-Operationen zählen — MGET / MSET in einem Round-Trip.
  • Persistenz gewünscht — AOF / RDB überleben Redis-Neustarts.
  • Du betreibst schon Redis — bestehende Infrastruktur wiederverwenden.

Für Single-Pod ist In-Memory einfacher.

Konfiguration

Abschnitt betitelt „Konfiguration“
interface RedisCacheSettings {
  url?:       string;                // 'redis://host:port'
  host?:      string;
  port?:      number;
  password?:  string;
  username?:  string;
  db?:        number;
  keyPrefix?: string;
  tls?:       boolean;               // true für `rediss://`
  cluster?:   ClusterNodes;          // für Redis Cluster
}

URL-Form:

new RedisCache({ url: 'redis://localhost:6379/0' });
new RedisCache({ url: 'rediss://redis.example.com:6380' });  // TLS
new RedisCache({ url: 'redis://user:pass@host:6379' });

Feld-Form:

new RedisCache({
  host:    'redis.example.com',
  port:    6379,
  password: process.env.REDIS_PASS,
  db:      1,
  keyPrefix: 'my-app:',
});

keyPrefix wird auf jeden Key angewendet — nützlich, wenn du eine Redis-Instanz über mehrere Apps teilst:

keyPrefix: 'my-app:cache:'
// → 'my-app:cache:user:42', 'my-app:cache:session:abc', ...

Cluster-Modus

Abschnitt betitelt „Cluster-Modus“
new RedisCache({
  cluster: {
    nodes: [
      { host: 'redis-1', port: 6379 },
      { host: 'redis-2', port: 6379 },
      { host: 'redis-3', port: 6379 },
    ],
  },
});

ioredis übernimmt das Cluster-Protokoll (MOVED-/ASK-Redirects, Slot-Tracking). Nimm Redis Cluster für horizontale Skalierung über den Speicher eines einzelnen Redis-Servers hinaus.

TLS

Abschnitt betitelt „TLS“
new RedisCache({ url: 'rediss://redis.example.com:6380' });
// oder:
new RedisCache({ host: '...', port: 6380, tls: true });

URL-Präfix rediss:// oder explizit tls: true. Cert- Verifizierung läuft über Nodes TLS-Defaults; für selbstsignierte Zertifikate im Dev brauchst du explizite ioredis-TLS-Optionen.

Bulk-Operationen sind echtes Bulk

Abschnitt betitelt „Bulk-Operationen sind echtes Bulk“
const users = await cache.mget<User>(['user:1', 'user:2', 'user:3']);
//                                              ↑
//                                       ein MGET-Round-Trip

mget auf RedisCache → ein einzelner Redis-MGET-Befehl → ein Netzwerk-Round-Trip. Entscheidend für das Muster der Hydratation gesharder Entitäten (State für viele Entitäten beim Node-Start wieder aufbauen).

Atomare incr + setIfAbsent

Abschnitt betitelt „Atomare incr + setIfAbsent“

Beide mappen auf Redis-Primitive:

  • incr → Redis INCR (atomar, kein Race).
  • setIfAbsent → Redis SET NX (atomares CAS).

Wird von der Rate-Limit- + Idempotency-Key-Middleware des Frameworks genutzt. Sicher über Pods hinweg.

Pipelining

Abschnitt betitelt „Pipelining“
// Nicht direkt im Cache exponiert; ioredis-Pipelining ist automatisch
// für gebatcheten Aufrufe innerhalb desselben Ticks.

ioredis pipelined Befehle, die im selben JS-Tick abgesetzt werden, und sendet sie in einem einzigen TCP-Write. Das Cache- Interface exponiert Pipelining nicht explizit; die Implementierung des Frameworks nutzt Pipelining, wo hilfreich.

Peer-Dependency

Abschnitt betitelt „Peer-Dependency“
Terminal-Fenster
npm install ioredis
# oder: bun add ioredis

ioredis ist der zugrunde liegende Client. Versionen 5+ sind getestet.

Redis-Persistenz-Settings

Abschnitt betitelt „Redis-Persistenz-Settings“

Redis unterstützt zwei Persistenz-Modi:

  • RDB — periodische Snapshots. Default in vielen Configs.
  • AOF — Append-only-Log. Durabler, langsamer.

Der Cache des Frameworks kümmert sich nicht um Redis-seitige Persistenz-Config — Caches sind opportunistisch. Aber für Cache-Überleben über Redis-Neustarts aktiviere mindestens RDB.

TLS zu Managed-Redis

Abschnitt betitelt „TLS zu Managed-Redis“
new RedisCache({
  url: 'rediss://default:password@my-cluster.cache.amazonaws.com:6380',
});

AWS ElastiCache, GCP Memorystore, Azure Cache for Redis — alle unterstützen rediss://-URLs. Nutze sie.

Cluster-Verbindungsverwaltung

Abschnitt betitelt „Cluster-Verbindungsverwaltung“
new RedisCache({
  cluster: { nodes: [...] },
  options: {
    enableReadyCheck:    true,
    maxRetriesPerRequest: 3,
  },
});

Defaultet auf vernünftige ioredis-Defaults. Für sehr enge Latenz oder spezifische Connection-Pool-Größen gib ioredis-artige Optionen explizit mit.

Wohin als Nächstes

Abschnitt betitelt „Wohin als Nächstes“