Redis auf STACKIT – Managed In-Memory Key-Value Store

Wenn deine Anwendung unter hoher Latenz bei Datenbankabfragen leidet oder du Echtzeit-Kommunikation zwischen Services brauchst, ist Redis die Lösung. STACKIT bietet einen vollständig verwalteten Redis-Service, der dir Betrieb, Patching und Backups abnimmt.

Was ist Redis?

Redis ist ein In-Memory-Datenstore, der Daten im Arbeitsspeicher hält und dadurch extrem schnelle Lese- und Schreiboperationen ermöglicht:

• Key-Value Store – Speichert Daten als Schlüssel-Wert-Paare mit Sub-Millisekunden-Latenz
• Caching-Layer – Entlastet deine primäre Datenbank durch Zwischenspeicherung häufiger Abfragen
• Pub/Sub Messaging – Ermöglicht Echtzeit-Kommunikation zwischen Microservices
• Datenstrukturen – Unterstützt Strings, Hashes, Listen, Sets und Sorted Sets
• Persistenz – Optionale Snapshots und Append-Only-Files für Datensicherheit

:::info Managed Redis auf STACKIT übernimmt automatische Backups, Failover und Skalierung – du konzentrierst dich auf deine Anwendung. :::

Tutorial: Redis auf STACKIT einrichten und nutzen

1. Redis-Instanz erstellen

stackit redis instance create \
  --name my-cache \
  --project-id your-project-id \
  --plan-name single-small

2. Credentials anlegen

stackit redis credentials create \
  --instance-name my-cache \
  --project-id your-project-id

Notiere dir Host, Port und Passwort aus der Ausgabe.

3. Verbindung testen

redis-cli -h your-redis-host -p 6379 -a your-redis-password
> PING
PONG

4. Caching-Pattern implementieren (Cache-Aside)

import redis
import json

r = redis.Redis(
    host="your-redis-host",
    port=6379,
    password="your-redis-password",
    ssl=True
)

def get_user(user_id):
    cached = r.get(f"user:{user_id}")
    if cached:
        return json.loads(cached)

    user = db.query(f"SELECT * FROM users WHERE id = %s", (user_id,))
    r.setex(f"user:{user_id}", 300, json.dumps(user))
    return user

5. Pub/Sub für Echtzeit-Events

Publisher:

r.publish("orders", json.dumps({
    "event": "order_created",
    "order_id": "12345"
}))

Subscriber:

pubsub = r.pubsub()
pubsub.subscribe("orders")

for message in pubsub.listen():
    if message["type"] == "message":
        event = json.loads(message["data"])
        print(f"Neues Event: {event['event']}")

6. Session-Speicher mit Node.js

const Redis = require("ioredis");
const session = require("express-session");
const RedisStore = require("connect-redis").default;

const redisClient = new Redis({
  host: "your-redis-host",
  port: 6379,
  password: "your-redis-password",
  tls: {}
});

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: "your-session-secret",
  resave: false,
  saveUninitialized: false,
  cookie: { maxAge: 3600000 }
}));

:::tip Setze immer eine TTL (Time-to-Live) auf Cache-Einträge, um veraltete Daten und Speicherüberlauf zu vermeiden. :::

Nächste Schritte

• Richte Redis-Monitoring über STACKIT Observability ein, um Speicherverbrauch und Hit-Rate zu überwachen
• Implementiere Cache-Invalidierung bei Datenänderungen in deiner primären Datenbank
• Evaluiere Redis Cluster für Hochverfügbarkeit und horizontale Skalierung
• Nutze Redis Sorted Sets für Leaderboards oder Rate-Limiting