Bewährte Methoden für die Verwendung von Redis EXPIRE- und TTL-Befehlen

Redis ist ein leistungsstarker In-Memory-Datenspeicher, der häufig als Cache, Nachrichtenbroker und Datenbank verwendet wird. Die effektive Verwaltung der Datenlebensdauer in Redis ist entscheidend für die Optimierung der Leistung, die Vermeidung von Speichererschöpfung und die Implementierung robuster Caching-Strategien. Die Befehle EXPIRE und TTL (sowie ihre millisekundengenauen Gegenstücke PEXPIRE und PTTL) sind grundlegende Werkzeuge zur Steuerung des Datenablaufs.

Wenn Sie bei temporären Daten die Ablaufzeiten vergessen, kann Redis den Speicher leise mit veralteten Cache-Einträgen, alten Sitzungen und verlassenen Sperrschlüsseln füllen. Verwenden Sie Ablaufzeiten bewusst und setzen Sie sie atomar, sobald der Schlüssel erstellt wird.

Grundlegendes zu Redis-Ablaufbefehlen

Redis bietet Befehle zum Festlegen einer Time To Live (TTL) für Schlüssel, nach deren Ablauf der Schlüssel automatisch gelöscht wird. Diese automatische Löschung ist für die Speicherverwaltung und die Sicherstellung der Datenaktualität, insbesondere in Caching-Szenarien, unerlässlich.

EXPIRE- und PEXPIRE-Befehle

Diese Befehle legen ein Timeout für einen Schlüssel fest. Sobald das Timeout erreicht ist, wird der Schlüssel automatisch gelöscht. Der Hauptunterschied liegt in der Zeiteinheit:

• EXPIRE key seconds: Legt den Ablauf in Sekunden fest.
• PEXPIRE key milliseconds: Legt den Ablauf in Millisekunden fest.

Die Verwendung von PEXPIRE bietet eine feinere Kontrolle, was für zeitkritisches Caching oder wenn Daten in sehr kurzen Intervallen ablaufen sollen, von Vorteil sein kann.

Beispiel:

# Setzt den Schlüssel 'mykey' so, dass er in 60 Sekunden abläuft
redis-cli> EXPIRE mykey 60
(integer) 1

# Setzt den Schlüssel 'anotherkey' so, dass er in 500 Millisekunden abläuft
redis-cli> PEXPIRE anotherkey 500
(integer) 1

Rückgabewert:

• 1: Das Timeout wurde erfolgreich gesetzt.
• 0: Der Schlüssel existiert nicht.

EXPIREAT- und PEXPIREAT-Befehle

Diese Befehle ähneln EXPIRE und PEXPIRE, legen jedoch anstelle einer Dauer eine bestimmte absolute Zeit fest, zu der der Schlüssel ablaufen soll.

• EXPIREAT key timestamp: Legt den Ablauf auf einen bestimmten Unix-Zeitstempel (Sekunden seit der Epoche) fest.
• PEXPIREAT key millitimestamp: Legt den Ablauf auf einen bestimmten Unix-Zeitstempel in Millisekunden fest.

Diese sind nützlich, wenn ein Element zu einer bestimmten Wanduhrzeit ablaufen soll, unabhängig davon, wann es gesetzt wurde.

Beispiel:

# Setzt den Schlüssel 'session:123' so, dass er zum Unix-Zeitstempel 1678886400 (15. März 2023, 12:00:00 UTC) abläuft
redis-cli> EXPIREAT session:123 1678886400
(integer) 1

TTL- und PTTL-Befehle

Diese Befehle geben die verbleibende Lebensdauer eines Schlüssels zurück. Dies ist entscheidend für die Überwachung des Ablaufs von Schlüsseln und für die Implementierung von Logik, die von der verbleibenden Zeit abhängt.

• TTL key: Gibt die verbleibende Lebensdauer eines Schlüssels in Sekunden zurück.
• PTTL key: Gibt die verbleibende Lebensdauer eines Schlüssels in Millisekunden zurück.

Rückgabewerte:

• Positive Ganzzahl: Die verbleibende Lebensdauer in Sekunden (für TTL) oder Millisekunden (für PTTL).
• -1: Der Schlüssel existiert, hat aber keinen zugehörigen Ablauf.
• -2: Der Schlüssel existiert nicht.

Beispiel:

redis-cli> TTL mykey
(integer) 55

redis-cli> PTTL anotherkey
(integer) 480

redis-cli> TTL non_existent_key
(integer) -2

redis-cli> SET permanent_key "some value"
OK
redis-cli> TTL permanent_key
(integer) -1

Bewährte Methoden für die Verwendung von EXPIRE und TTL

Die effektive Nutzung dieser Befehle erfordert einen strategischen Ansatz für Caching und Datenverwaltung. Hier sind die wichtigsten bewährten Methoden:

1. Setzen Sie Ablaufzeiten aggressiv für Caches

Für Daten, die als Cache dienen, ist es fast immer besser, eine Ablaufzeit zu setzen. Dies stellt sicher, dass veraltete Daten nicht unbegrenzt bestehen bleiben. Der Schlüssel liegt darin, eine Ablaufzeit zu wählen, die die Cache-Trefferquote mit der Datenaktualität in Einklang bringt.

• Cache-Invalidierung: Der Ablauf fungiert als eine Form der automatischen Cache-Invalidierung. Wenn ein Cache-Eintrag abläuft, kann die Anwendung die aktuellen Daten aus der primären Quelle erneut abrufen und den Cache aktualisieren.
• Speicherverwaltung: Verhindert, dass der Cache unbegrenzt wächst, was zu Speichererschöpfung und Leistungseinbußen führen kann.

Beispiel: Caching von Benutzerprofilen für 5 Minuten.

import redis
import time

r = redis.Redis(decode_responses=True)

def get_user_profile(user_id):
    cache_key = f"user_profile:{user_id}"
    profile_data = r.get(cache_key)

    if profile_data:
        print(f"Cache-Treffer für Benutzer {user_id}")
        return profile_data
    else:
        print(f"Cache-Fehlzugriff für Benutzer {user_id}. Daten aus DB abrufen...")
        # Simuliert das Abrufen aus einer Datenbank
        user_profile = {"name": "Alice", "email": "[email protected]"}
        # In Redis mit einer 5-minütigen Ablaufzeit speichern (300 Sekunden)
        r.set(cache_key, str(user_profile), ex=300)
        return user_profile

# Erster Aufruf (Cache-Fehlzugriff)
print(get_user_profile(123))

# Zweiter Aufruf (Cache-Treffer)
print(get_user_profile(123))

# Kurze Zeit warten, aber weniger als die Ablaufzeit
r.sleep(10)
print(f"TTL für Cache-Schlüssel: {r.ttl(cache_key)} Sekunden")

# Auf Ablauf warten
r.sleep(300) # Simuliert den Rest der 5 Minuten
print(f"TTL nach Ablauf: {r.ttl(cache_key)} Sekunden")

2. Verwenden Sie PEXPIRE für hochfrequente/kurzlebige Daten

Für Szenarien wie Ratenbegrenzung, Sitzungstoken mit sehr kurzer Gültigkeit oder temporäre Sperren kann Millisekundengenauigkeit entscheidend sein. PEXPIRE ermöglicht eine viel feinere Kontrolle.

Beispiel: Implementierung eines einfachen Ratenbegrenzers.

import redis
import time

r = redis.Redis(decode_responses=True)

def check_rate_limit(user_id, limit=5, period_ms=60000): # 5 Anfragen pro Minute
    key = f"rate_limit:{user_id}"
    current_requests = r.get(key)

    if current_requests is None:
        # Erste Anfrage in diesem Zeitraum
        r.set(key, 1, px=period_ms)
        return True
    else:
        current_requests = int(current_requests)
        if current_requests < limit:
            # INCR behält die vorhandene TTL bei.
            r.incr(key)
            return True
        else:
            # Limit überschritten
            return False

# Simuliert Anfragen für einen Benutzer
user = "user:abc"
for i in range(7):
    if check_rate_limit(user):
        print(f"Anfrage {i+1}: Erlaubt. Verbleibende TTL: {r.pttl(f'rate_limit:{user}')}ms")
    else:
        print(f"Anfrage {i+1}: Ratenlimit überschritten.")
    time.sleep(0.1) # Simuliert etwas Zeit zwischen den Anfragen

3. EXPIREAT für zeitbasierte Ereignisse

Wenn Daten zu einer bestimmten Kalenderzeit ablaufen sollen (z. B. Ende einer Aktion, Sitzungsablauf basierend auf der Anmeldezeit plus einer festen Dauer), ist EXPIREAT besser geeignet als die Berechnung von Dauern.

Beispiel: Ablauf eines Sonderangebots zu einem festgelegten Zeitpunkt.

import redis
import datetime

r = redis.Redis(decode_responses=True)

offer_id = "SUMMER2026"
end_time = datetime.datetime(2023, 8, 31, 23, 59, 59)

# In Unix-Zeitstempel umwandeln
end_timestamp = int(end_time.timestamp())

# Angebotsdetails in Redis speichern und Ablaufzeit setzen
r.set(f"offer:{offer_id}", "20% Rabatt auf alle Artikel!")
r.expireat(f"offer:{offer_id}", end_timestamp)

print(f"Angebot '{offer_id}' läuft ab um {end_time} (Zeitstempel: {end_timestamp})")
print(f"Aktuelle TTL für das Angebot: {r.ttl(f'offer:{offer_id}')} Sekunden")

4. Achten Sie auf Schlüssel ohne Ablaufzeiten

Schlüssel, die ohne expliziten EXPIRE-, PEXPIRE-, EXPIREAT- oder PEXPIREAT-Befehl gesetzt wurden, bleiben unbegrenzt bestehen, bis sie explizit gelöscht werden oder der Redis-Server neu startet (sofern keine Persistenz konfiguriert ist). Dies kann zu Speicherproblemen führen.

• Permanente Daten: Wenn Daten dauerhaft sein sollen, stellen Sie sicher, dass ihnen nicht versehentlich eine Ablaufzeit zugewiesen wird. Wenn Daten hingegen ablaufen sollen, Sie aber vergessen, die Ablaufzeit zu setzen, bleiben sie erhalten.
• Überwachung: Überwachen Sie regelmäßig Ihre Redis-Speichernutzung und Schlüsselanzahlen. Verwenden Sie Befehle wie INFO memory und redis-cli --stat oder Tools wie die Redis Enterprise-Benutzeroberfläche, um Schlüssel zu identifizieren, die möglicherweise übermäßig viel Speicher ohne Ablaufzeit verbrauchen.

5. Verwenden Sie PERSIST, um die Ablaufzeit zu entfernen

Wenn Sie eine Ablaufzeit für einen Schlüssel festgelegt haben, sich aber später entscheiden, dass er dauerhaft sein soll, verwenden Sie den Befehl PERSIST.

Beispiel:

redis-cli> SET temp_key "data"
OK
redis-cli> EXPIRE temp_key 300
(integer) 1
redis-cli> TTL temp_key
(integer) 295
redis-cli> PERSIST temp_key
(integer) 1
redis-cli> TTL temp_key
(integer) -1

6. Atomarität: Kombinieren Sie SET mit Ablaufzeit

Wenn Sie einen neuen Schlüssel setzen, der eine Ablaufzeit haben soll, ist es oft effizienter und atomarer, den Befehl SET mit der Option EX oder PX zu verwenden, anstatt ein SET gefolgt von einem EXPIRE auszugeben.

• SET key value EX seconds: Setzt den Wert des Schlüssels und seine Ablaufzeit in Sekunden.
• SET key value PX milliseconds: Setzt den Wert des Schlüssels und seine Ablaufzeit in Millisekunden.

Dies ist atomar, was bedeutet, dass die Operation entweder vollständig erfolgreich ist oder vollständig fehlschlägt, wodurch Wettlaufsituationen vermieden werden, bei denen der EXPIRE-Befehl zwischen den Befehlen SET und EXPIRE fehlschlagen oder übersehen werden könnte.

Beispiel:

# Anstatt:
# redis-cli> SET mycache "some value"
# redis-cli> EXPIRE mycache 3600

# Verwenden Sie:
redis-cli> SET mycache "some value" EX 3600
OK

# Oder für Millisekunden:
redis-cli> SET anothercache "other value" PX 500
OK

7. Ziehen Sie SETNX mit Ablaufzeit in Betracht

Wenn Sie SETNX (Set if Not Exists) für verteilte Sperren oder zum Setzen eines Werts nur dann, wenn er nicht bereits vorhanden ist, verwenden, sollten Sie es mit einer Ablaufzeit kombinieren, um Deadlocks zu verhindern.

• SET key value NX EX seconds: Setzt key auf value nur, wenn key nicht existiert, und setzt die angegebene Ablaufzeit in Sekunden.
• SET key value NX PX milliseconds: Ähnlich, aber mit Millisekunden.

Dies ist ein gängiges Muster für die Implementierung verteilter Sperren.

Beispiel: Erwerb einer verteilten Sperre.

# Versucht, eine Sperre für die Ressource 'resource_X' für 10 Sekunden zu erwerben
redis-cli> SET lock:resource_X "process_abc" NX EX 10
OK
# Wenn das obige 'OK' zurückgibt, haben Sie die Sperre.
# Wenn es 'nil' (oder eine leere Zeichenfolge in einigen Clients) zurückgibt, wird die Sperre bereits gehalten.

# Um die Sperre freizugeben (vorsichtig, normalerweise mit einem Lua-Skript, um den Wert vor dem Löschen zu überprüfen)
# redis-cli> DEL lock:resource_X

8. Überwachen Sie Ablaufereignisse

Redis verfügt über einen Mechanismus zum Bereinigen abgelaufener Schlüssel: faule Ablaufzeit und aktive Ablaufzeit.

• Faule Ablaufzeit: Schlüssel werden nur dann auf Ablauf überprüft, wenn sie von einem Befehl (z. B. GET, TTL) aufgerufen werden. Dies ist die gebräuchlichste und ressourcenschonendste Methode.
• Aktive Ablaufzeit: Redis durchsucht regelmäßig Schlüssel mit TTLs und löscht abgelaufene, auch wenn sie nicht aufgerufen werden. Dies hilft, Speicher proaktiver freizugeben.

Obwohl Sie die Häufigkeit der aktiven Ablaufzeit ohne Serverkonfiguration nicht direkt steuern können, können Sie TTL und PTTL verwenden, um den Status von Schlüsseln zu überprüfen und sicherzustellen, dass Ihre Anwendungslogik abgelaufene Daten korrekt verarbeitet.

Fazit

Verwenden Sie SET ... EX oder SET ... PX beim Erstellen temporärer Schlüssel, überprüfen Sie TTL beim Debuggen und behandeln Sie Schlüssel mit TTL = -1 als Bereinigungsrisiko, es sei denn, sie sind absichtlich dauerhaft.