Redis-Leistungsüberwachung

Einführung

In diesem Lab lernen Sie, wie Sie Redis-Leistungsprobleme überwachen und beheben. Der Schwerpunkt liegt auf der Identifizierung und Lösung von Latenzproblemen, der Analyse der Speicherauslastung und der Optimierung der Abfrageleistung.

Sie werden den Befehl LATENCY DOCTOR zur Diagnose von Latenzen, MEMORY STATS zur Überprüfung der Speicherauslastung, SLOWLOG GET zur Analyse langsamer Abfragen und MEMORY PURGE zur Speicheroptimierung verwenden. Durch die schrittweise Anleitung gewinnen Sie praktische Erfahrungen bei der Aufrechterhaltung einer reaktionsschnellen und effizienten Redis-Bereitstellung.

Vorkonfigurierte Umgebung

Um zuverlässige Demonstrationen zu gewährleisten, wurde diese Lab-Umgebung wie folgt vorkonfiguriert:

• 1000 String-Keys (user:1 bis user:1000) mit Benutzerdaten
• 50 Hash-Objekte (profile:1 bis profile:50) mit Benutzerprofilinformationen
• 20 Listen-Objekte (logs:app1 bis logs:app20) mit Log-Einträgen
• 10 Set-Objekte (tags:1 bis tags:10) mit Tag-Daten
• Optimierte Redis-Konfiguration für die Leistungsüberwachung
• Vorab generierte Latenz- und Slowlog-Daten für die sofortige Analyse

Latenzüberwachung mit LATENCY DOCTOR

In diesem Schritt untersuchen wir, wie der Befehl LATENCY DOCTOR in Redis zur Diagnose und Fehlerbehebung von Latenzproblemen eingesetzt wird. Das Verständnis und die Behebung von Latenzen sind entscheidend für den Betrieb einer reaktionsschnellen und effizienten Redis-Instanz.

Was ist Latenz?

Latenz bezeichnet die Verzögerung zwischen dem Senden einer Anfrage an einen Redis-Server und dem Empfang einer Antwort. Eine hohe Latenz kann die Anwendungsleistung negativ beeinflussen, was zu langsamen Antwortzeiten und einer schlechten Benutzererfahrung führt.

Einführung in LATENCY DOCTOR

Der Befehl LATENCY DOCTOR ist ein leistungsstarkes, in Redis integriertes Werkzeug, das dabei hilft, potenzielle Ursachen für Latenzen zu identifizieren. Er analysiert verschiedene Aspekte des Redis-Betriebs und liefert Erkenntnisse darüber, was Verzögerungen verursachen könnte.

Schritt-für-Schritt-Anleitung

Verbindung zu Redis herstellen:

Verbinden Sie sich zunächst mit Ihrem Redis-Server über den Befehl `redis-cli`. Öffnen Sie ein Terminal in Ihrer LabEx-VM und führen Sie Folgendes aus:

```bash
redis-cli
```

Dies öffnet die Redis-Befehlszeilenschnittstelle.

Aktuelle Konfiguration überprüfen:

Die Umgebung wurde vorkonfiguriert, wobei die Latenzüberwachung aktiviert ist. Sie können die aktuellen Einstellungen überprüfen:

```bash
CONFIG GET latency-monitor-threshold
```

Dies sollte zeigen, dass der Schwellenwert auf 10 Millisekunden eingestellt ist.

LATENCY DOCTOR ausführen:

Führen Sie nun den Befehl `LATENCY DOCTOR` aus, um das System zu analysieren:

```bash
LATENCY DOCTOR
```

Da es sich um eine fehlerfreie Redis-Instanz ohne nennenswerte Latenzprobleme handelt, werden Sie wahrscheinlich eine Ausgabe sehen, die der folgenden ähnelt:

```
Dave, no latency spike was observed during the lifetime of this Redis instance, not in the slightest bit. I honestly think you ought to sit down calmly, take a stress pill, and think things over.
```

Diese humorvolle Nachricht (eine Anspielung auf HAL 9000 aus "2001: Odyssee im Weltraum") zeigt an, dass Redis einwandfrei funktioniert und keine Latenzspitzen über dem konfigurierten Schwellenwert erkannt wurden.

Die Antwort von LATENCY DOCTOR verstehen:

Wenn `LATENCY DOCTOR` die "Dave"-Nachricht anzeigt, bedeutet dies:
- Kein Befehl hat den Latenzüberwachungsschwellenwert (in unserem Fall 10 ms) überschritten.
- Redis arbeitet effizient ohne Leistungsengpässe.
- Das System ist aus Latenzsicht gesund.

In Produktionsumgebungen mit tatsächlichen Latenzproblemen würden Sie eine detaillierte Analyse sehen, einschließlich:
- Spezifischer Latenzspitzen und deren Ursachen
- Empfehlungen zur Optimierung
- Detaillierter Aufschlüsselungen langsamer Operationen

Das Slowlog untersuchen (Alternative Analyse):

Selbst wenn `LATENCY DOCTOR` keine Probleme anzeigt, können wir das Slowlog untersuchen, um zu sehen, welche Operationen im Vergleich zu anderen die meiste Zeit in Anspruch nehmen:

```bash
SLOWLOG GET 10
```

Sie sehen eine Ausgabe mit den letzten Befehlen und deren Ausführungszeiten. Die Einträge zeigen:
- **Eindeutige ID:** Sequenzielle Kennung für jeden Eintrag
- **Zeitstempel:** Unix-Zeitstempel, zu dem der Befehl ausgeführt wurde
- **Ausführungszeit:** Zeit in Mikrosekunden (z. B. 1954 Mikrosekunden = 1,954 Millisekunden)
- **Befehl:** Der ausgeführte Befehl (zeigt oft "COMMAND" für interne Redis-Operationen)
- **Client-Info:** IP-Adresse und Port des Clients

Zum Beispiel:

```
1) 1) (integer) 10
   2) (integer) 1753255495
   3) (integer) 1954
   4) 1) "COMMAND"
   5) "127.0.0.1:42212"
   6) ""
```

Dies zeigt einen Befehl, dessen Ausführung 1.954 Mikrosekunden (etwa 2 Millisekunden) dauerte.

redis-cli beenden:

Um sicherzustellen, dass die Befehle protokolliert werden, beenden Sie die `redis-cli` durch Eingabe von:

```bash
exit
```

Die Bedeutung verstehen

Durch die Verwendung von LATENCY DOCTOR und die Analyse des Slowlogs gewinnen Sie wertvolle Einblicke in die Leistung Ihrer Redis-Bereitstellung. Auch wenn alles gesund erscheint (wie durch die "Dave"-Nachricht angezeigt), hilft eine regelmäßige Überwachung dabei, eine dauerhaft gute Leistung sicherzustellen und aufkommende Probleme frühzeitig zu erkennen.

Speicher mit MEMORY STATS überprüfen

In diesem Schritt lernen wir, wie der Befehl MEMORY STATS in Redis verwendet wird, um die Speicherauslastung zu überwachen und zu verstehen. Ein effizientes Speichermanagement ist entscheidend für die Stabilität und Leistung Ihres Redis-Servers.

Warum Speicher überwachen?

Redis ist ein In-Memory-Datenspeicher, was bedeutet, dass alle Daten im RAM gespeichert werden. Wenn Redis der Speicher ausgeht, kann dies zu Leistungseinbußen, Datenverlust oder sogar Abstürzen führen. Die Überwachung der Speicherauslastung ermöglicht es Ihnen, potenzielle speicherbezogene Probleme proaktiv zu identifizieren und zu beheben.

Einführung in MEMORY STATS

Der Befehl MEMORY STATS bietet einen detaillierten Überblick über den Speicherverbrauch von Redis. Er unterteilt die Speicherauslastung in verschiedene Kategorien und gibt Ihnen Einblicke, wo Ihr Speicher verwendet wird.

Schritt-für-Schritt-Anleitung

Verbindung zu Redis herstellen:

Verbinden Sie sich mit Ihrem Redis-Server über den Befehl `redis-cli`. Öffnen Sie ein Terminal in Ihrer LabEx-VM und führen Sie Folgendes aus:

```bash
redis-cli
```

Dies öffnet die Redis-Befehlszeilenschnittstelle.

MEMORY STATS ausführen:

Sobald Sie verbunden sind, führen Sie den Befehl `MEMORY STATS` aus:

```bash
MEMORY STATS
```

Redis sammelt daraufhin Speicherstatistiken und zeigt die Ergebnisse an.

Die Ausgabe interpretieren:

Die Ausgabe von `MEMORY STATS` ist ein Wörterbuch aus Schlüssel-Wert-Paaren, wobei jeder Schlüssel eine Speicherstatistik und der Wert den entsprechenden Wert darstellt. Betrachten wir eine Beispielausgabe und erläutern einige der wichtigsten Metriken:

```
127.0.0.1:6379> MEMORY STATS
 1) "peak.allocated"
 2) (integer) 1114480
 3) "total.allocated"
 4) (integer) 1114480
 5) "startup.allocated"
 6) (integer) 948480
 7) "replication.buffer"
 8) (integer) 0
 9) "clients.slaves"
10) (integer) 0
11) "clients.normal"
12) (integer) 6456
13) "aof.buffer"
14) (integer) 0
15) "lua.vm"
16) (integer) 0
17) "overhead.total"
18) (integer) 165992
19) "keys.count"
20) (integer) 0
21) "keys.bytes-per-key"
22) (integer) 0
23) "dataset.bytes"
24) (integer) 948488
25) "dataset.percentage"
26) "0.00%"
27) "bytes-per-replica.avg"
28) (integer) 0
29) "bytes-per-replica.min"
30) (integer) 0
31) "bytes-per-replica.max"
32) (integer) 0
33) "allocator.fragratio"
34) "1.00"
35) "allocator.fragbytes"
36) (integer) 0
37) "allocator.rss"
38) (integer) 835584
39) "allocator.peak"
40) (integer) 1114112
41) "total.system"
42) (integer) 4194304
43) "allocator.resident"
44) (integer) 835584
```

Hier ist eine Aufschlüsselung einiger wichtiger Metriken:
- **`peak.allocated`:** Die höchste Speichermenge, die Redis seit dem Start zugewiesen hat.
- **`total.allocated`:** Die gesamte aktuell von Redis zugewiesene Speichermenge.
- **`dataset.bytes`:** Die Gesamtgröße der in Redis gespeicherten Daten (ohne Overhead).
- **`overhead.total`:** Die gesamte Speichermenge, die für Redis-Overhead (z. B. Datenstrukturen, Metadaten) verwendet wird.
- **`keys.count`:** Die Anzahl der aktuell in Redis gespeicherten Keys.
- **`allocator.fragratio`:** Das Fragmentierungsverhältnis des Speicher-Allocators. Ein höherer Wert deutet auf eine stärkere Fragmentierung hin.
- **`allocator.rss`:** Die Speichermenge, die Redis laut Betriebssystem verwendet (Resident Set Size).
- **`total.system`:** Die gesamte auf dem System verfügbare Speichermenge.

redis-cli beenden:

Um sicherzustellen, dass die Befehle protokolliert werden, beenden Sie die `redis-cli` durch Eingabe von:

```bash
exit
```

Die Informationen nutzen

Die von MEMORY STATS bereitgestellten Informationen können verwendet werden, um:

• Speicherlecks zu identifizieren.
• Datenstrukturen zu optimieren, um den Speicherverbrauch zu reduzieren.
• Redis-Konfigurationsparameter anzupassen, um die Speichereffizienz zu verbessern.
• Festzustellen, ob Sie den verfügbaren RAM für Ihren Redis-Server erhöhen müssen.

Langsame Abfragen mit SLOWLOG GET analysieren

In diesem Schritt werden wir uns mit der Analyse langsamer Abfragen mithilfe des Befehls SLOWLOG GET in Redis befassen. Das Identifizieren und Optimieren langsamer Abfragen ist für den Betrieb einer reaktionsschnellen und effizienten Redis-Instanz unerlässlich. Wie von LATENCY DOCTOR im ersten Schritt vorgeschlagen, ist die Analyse des Slowlogs ein entscheidender Schritt zur Fehlersuche bei Latenzproblemen.

Was ist das Slowlog?

Das Slowlog ist ein System in Redis, das Abfragen protokolliert, die eine festgelegte Ausführungszeit überschreiten. Dies ermöglicht es Ihnen, Abfragen zu identifizieren, die länger als erwartet dauern und möglicherweise die Leistung beeinträchtigen.

Schritt-für-Schritt-Anleitung

Verbindung zu Redis herstellen:

Verbinden Sie sich mit Ihrem Redis-Server über den Befehl `redis-cli`. Öffnen Sie ein Terminal in Ihrer LabEx-VM und führen Sie Folgendes aus:

```bash
redis-cli
```

Dies öffnet die Redis-Befehlszeilenschnittstelle.

Slowlog-Konfiguration überprüfen:

Die Umgebung wurde mit geeigneten Slowlog-Einstellungen vorkonfiguriert. Sie können die aktuelle Konfiguration überprüfen:

```bash
CONFIG GET slowlog-log-slower-than
```

```bash
CONFIG GET slowlog-max-len
```

Dies sollte zeigen, dass Redis so konfiguriert ist, dass jeder Befehl während dieses Labs protokolliert wird (`slowlog-log-slower-than` ist `0`) und bis zu 128 Slowlog-Einträge gespeichert werden. In der Produktion würden Sie normalerweise einen höheren Schwellenwert verwenden, sodass nur Befehle protokolliert werden, die langsamer als Ihr Leistungsziel sind.

Slowlog-Einträge abrufen:

Verwenden Sie den Befehl `SLOWLOG GET`, um Slowlog-Einträge abzurufen. Um die 10 aktuellsten Slowlog-Einträge abzurufen, verwenden Sie den folgenden Befehl:

```bash
SLOWLOG GET 10
```

Sie sehen eine Ausgabe, die der folgenden ähnelt. Die genauen IDs, Zeitstempel, Ausführungszeiten und Portnummern werden in Ihrer Umgebung anders sein:

```
 1) 1) (integer) 10
    2) (integer) 1753255495
    3) (integer) 321
    4) 1) "EVAL"
       2) "local total = 0; for i=1,1000 do local value = redis.call('GET', 'user:' .. i); if value then total = total + string.len(value) end end; return total"
       3) "0"
   5) "127.0.0.1:42212"
   6) ""
 2) 1) (integer) 9
    2) (integer) 1753255494
    3) (integer) 225
    4) 1) "KEYS"
       2) "*"
    5) "127.0.0.1:41444"
    6) ""
 3) 1) (integer) 8
    2) (integer) 1753255494
    3) (integer) 5
    4) 1) "SLOWLOG"
       2) "RESET"
    5) "127.0.0.1:41004"
    6) ""
```

Die Ausgabe interpretieren:

Die Ausgabe von `SLOWLOG GET` ist ein Array von Slowlog-Einträgen. Jeder Eintrag enthält sechs Informationen:
- **Eindeutige ID:** Eine sequenzielle Kennung für den Slowlog-Eintrag (z. B. 10, 9, 8...)
- **Zeitstempel:** Der Unix-Zeitstempel, zu dem die Abfrage ausgeführt wurde
- **Ausführungszeit:** Die Ausführungszeit in Mikrosekunden (z. B. 1954 = 1,954 Millisekunden)
- **Befehls-Array:** Der ausgeführte Befehl und seine Argumente
- **Client-IP und Port:** Die IP-Adresse und der Port des Clients (z. B. "127.0.0.1:42212")
- **Client-Name:** Der Name des Clients (normalerweise leer, angezeigt als "")

**Die Zeiten verstehen:**
- 321 Mikrosekunden = 0,321 Millisekunden
- 225 Mikrosekunden = 0,225 Millisekunden
- 5 Mikrosekunden = 0,005 Millisekunden

Häufige Muster analysieren:

In der Umgebung sehen Sie typischerweise:
- **Befehls-Arrays:** Einträge wie `EVAL`, `KEYS`, `CONFIG` und `SLOWLOG`, gefolgt von ihren Argumenten
- **Mikrosekunden-Timing:** Die meisten Operationen sind sehr schnell, oft unter 1 Millisekunde
- **Lokale Verbindungen:** Alle Verbindungen von 127.0.0.1 (localhost)

Detailliertere langsame Abfragen generieren:

Um spezifischere langsame Abfragen mit den vorhandenen Daten zu sehen, führen wir Operationen aus, die den Datensatz durchsuchen:

```bash
KEYS user:*
```

Dieser Befehl durchsucht alle Benutzer-Keys (1000 Keys), was im Slowlog erscheinen sollte.

Überprüfen Sie nun das aktualisierte Slowlog:

```bash
SLOWLOG GET 3
```

Sie sollten nun den Befehl `KEYS user:*` im Slowlog sehen, mit einem Format wie:

```
1) 1) (integer) 11
   2) (integer) [timestamp]
   3) (integer) [execution_time]
   4) 1) "KEYS"
      2) "user:*"
   5) "127.0.0.1:[port]"
   6) ""
```

Speicheroptimierung mit MEMORY PURGE:

Lassen Sie uns auch die Speicheroptimierung demonstrieren. Überprüfen Sie zuerst die aktuelle Speicherauslastung:

```bash
MEMORY STATS
```

Suchen Sie in der Ausgabe nach dem Wert `total.allocated`. Lassen Sie uns nun Speicher freigeben, indem wir ungenutzten Speicher bereinigen:

```bash
MEMORY PURGE
```

Überprüfen Sie die Speicherauslastung erneut:

```bash
MEMORY STATS
```

Vergleichen Sie die `total.allocated`-Werte, um zu sehen, ob Speicher freigegeben wurde. Der Befehl `MEMORY PURGE` versucht, Speicher freizugeben, der nicht aktiv von Redis genutzt wird.

redis-cli beenden:

Um sicherzustellen, dass die Befehle protokolliert werden, beenden Sie die `redis-cli` durch Eingabe von:

```bash
exit
```

Die Informationen nutzen

Durch die Analyse des Slowlogs können Sie langsame Abfragen identifizieren und Schritte zu deren Optimierung unternehmen. Wichtige Erkenntnisse sind:

• Befehlshäufigkeit: Wie oft langsame Befehle auftreten
• Ausführungsmuster: Ob bestimmte Operationen konsistent im Slowlog erscheinen
• Leistungstrends: Änderungen der Ausführungszeiten im Zeitverlauf
• Ressourcennutzung: Befehle, die möglicherweise übermäßig viel CPU oder Speicher verbrauchen

Diese Informationen helfen Ihnen dabei:

• Anwendungsabfragen zu optimieren
• Problematische Muster zu identifizieren
• Skalierung und Kapazität zu planen
• Leistungsprobleme in der Produktion zu beheben

Zusammenfassung

In diesem Lab haben wir Techniken zur Redis-Leistungsüberwachung mithilfe einer vorkonfigurierten Umgebung erkundet, die echte Redis-Überwachungstools demonstriert.

Wir begannen mit der Verwendung des Befehls LATENCY DOCTOR, um zu verstehen, wie Redis Latenzprobleme diagnostiziert. In unserer gesunden Umgebung sahen wir die charakteristische "Dave"-Nachricht, die anzeigte, dass keine Latenzspitzen erkannt wurden. Dies lehrte uns, wie das Feedback der Redis-Latenzüberwachung bei gut funktionierenden Systemen zu interpretieren ist.

Als Nächstes untersuchten wir den Befehl MEMORY STATS, um Muster der Redis-Speicherauslastung zu analysieren. Mit dem vorkonfigurierten Datensatz aus 1000 String-Keys, 50 Hash-Objekten, 20 Listen und 10 Sets beobachteten wir eine realistische Speicherzuweisung und lernten, wichtige Speichermetriken wie total.allocated, dataset.bytes und overhead.total zu identifizieren.

Anschließend erkundeten wir den Befehl SLOWLOG GET, um die Abfrageleistung zu analysieren. Wir lernten, die sechsteiligen Slowlog-Einträge zu interpretieren, die Ausführungszeiten in Mikrosekunden zu verstehen und zu beobachten, wie interne Redis-"COMMAND"-Operationen im Slowlog erscheinen. Wir demonstrierten auch das Generieren benutzerdefinierter langsamer Abfragen mithilfe von Pattern-Matching-Befehlen wie KEYS user:*.

Schließlich demonstrierten wir die Speicheroptimierung mit dem Befehl MEMORY PURGE und verglichen die Speicherauslastung vor und nach der Bereinigung, um zu verstehen, wie Redis Speicher effizient verwaltet.

Während des gesamten Labs haben wir gelernt:

1. Die Ausgabe von LATENCY DOCTOR zu interpretieren, einschließlich der Nachricht für ein "gesundes System".
2. Speicherauslastungsmuster mit MEMORY STATS unter Verwendung realer Datensatzmetriken zu analysieren.
3. Slowlog-Einträge mit ihrer sechsteiligen Struktur zu lesen und zu verstehen.
4. Langsame Abfragen mithilfe von Pattern-Matching-Operationen zu generieren und zu analysieren.
5. Die Speicherauslastung mit MEMORY PURGE zu optimieren.
6. Zwischen internen Redis-Operationen und Benutzerbefehlen bei der Leistungsüberwachung zu unterscheiden.

Diese praktische Erfahrung mit den integrierten Leistungsüberwachungstools von Redis bildet die Grundlage für die Aufrechterhaltung reaktionsschneller und effizienter Redis-Bereitstellungen in Produktionsumgebungen.