Redis Cluster Verwaltung - Skalierbare Datenspeicherung

Einführung

In diesem Lab lernen Sie, wie Sie einen Redis-Cluster verwalten. Der Schwerpunkt des Labs liegt auf wesentlichen Aufgaben der Clusterverwaltung, einschließlich der Initialisierung eines Clusters, dem Hinzufügen von Knoten, der Überprüfung des Clusterzustands und dem Resharding (Neuverteilung) von Slots.

Wir beginnen mit der Initialisierung eines Redis-Clusters mithilfe des Befehls redis-cli --cluster, der die anfängliche Konfiguration automatisiert. Anschließend lernen Sie, wie Sie einen neuen Knoten mit CLUSTER MEET hinzufügen. Als Nächstes überprüfen Sie den Zustand des Clusters mit CLUSTER INFO. Abschließend werden Sie Slots zwischen Knoten mit CLUSTER SETSLOT neu verteilen, um den Cluster auszugleichen.

Initialisieren des Redis Clusters

In diesem Schritt initialisieren Sie einen Redis-Cluster mit dem Befehl redis-cli --cluster create. Dieser Befehl vereinfacht den Prozess der Einrichtung eines funktionsfähigen Redis-Clusters.

Was ist ein Redis-Cluster?

Ein Redis-Cluster ist eine verteilte Einrichtung, die Daten automatisch auf mehrere Redis-Knoten verteilt. Dies ermöglicht es Ihnen, Ihre Redis-Bereitstellung horizontal zu skalieren und größere Datensätze zu verwalten, als eine einzelne Redis-Instanz verarbeiten kann.

Warum redis-cli --cluster create verwenden?

Der Befehl redis-cli --cluster create bietet eine einfache Möglichkeit, einen Redis-Cluster zu erstellen, zu verwalten und mit ihm zu interagieren. Er automatisiert die anfängliche Konfiguration und Knotenerkennung und erleichtert so die Clustererstellung.

Schritte:

Redis-Instanzen starten:

Zuerst müssen Sie mehrere Redis-Instanzen konfigurieren und starten. Für dieses Lab verwenden wir sechs Instanzen, die auf den Ports 7000 bis 7005 laufen. Jede Instanz muss mit cluster-enabled yes konfiguriert werden.

Dazu können Sie die folgenden Befehle verwenden, um Konfigurationsdateien zu erstellen und die Redis-Instanzen zu starten. Beachten Sie, dass diese Befehle zu Demonstrationszwecken dienen. Das Setup-Skript hat diese Instanzen bereits für Sie konfiguriert und gestartet.

REDIS_CONF="/etc/redis/redis.conf"
for port in 7000 7001 7002 7003 7004 7005; do
  CONF_FILE="/etc/redis/redis-${port}.conf"
  sudo cp "$REDIS_CONF" "$CONF_FILE"
  sudo sed -i "s/^port 6379/port ${port}/g" "$CONF_FILE"
  sudo sed -i "s/^#cluster-enabled yes/cluster-enabled yes/g" "$CONF_FILE"
  sudo sed -i "s/^#cluster-config-file nodes.conf/cluster-config-file nodes-${port}.conf/g" "$CONF_FILE"
  sudo sed -i "s/^#cluster-node-timeout 15000/cluster-node-timeout 15000/g" "$CONF_FILE"
  sudo sed -i "s/^#appendonly no/appendonly yes/g" "$CONF_FILE"
  sudo redis-server "$CONF_FILE" &
done
sleep 5

Cluster erstellen:

Verwenden Sie nun den Befehl redis-cli --cluster create, um den Cluster zu erstellen. Dieser Befehl erfordert die IP-Adressen und Ports der anfänglichen Knoten.

Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:
```
redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 --cluster-replicas 1
```
- redis-cli --cluster create: Startet den Clustererstellungsprozess.
- 127.0.0.1:7000 127.0.0.1:7001 ... 127.0.0.1:7005: Die Adressen und Ports der Redis-Instanzen.
- --cluster-replicas 1: Gibt an, dass jeder Master-Knoten eine Replika (Nachbildung) haben soll.

Clustererstellung bestätigen:

Das redis-cli-Tool fordert Sie auf, die Clustererstellung zu bestätigen. Geben Sie yes ein und drücken Sie die Eingabetaste.

>>> Creating cluster
>>> Performing hash slots allocation on 6 nodes...
>>> Master[0] -> Slots 0 - 5460
>>> Master[1] -> Slots 5461 - 10922
>>> Master[2] -> Slots 10923 - 16383
>>> Adding replica node to Master[0]
>>> Adding replica node to Master[1]
>>> Adding replica node to Master[2]
>>> M: 49a4928719291928192819281928192819281928 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
>>> M: 9281928192819281928192819281928192819281 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
>>> M: 19281928192819281928192819281928192819281 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
>>> S: 81928192819281928192819281928192819281928 127.0.0.1:7003
   replicates 49a4928719291928192819281928192819281928
>>> S: 28192819281928192819281928192819281928192 127.0.0.1:7004
   replicates 9281928192819281928192819281928192819281
>>> S: 928192819281928192819281928192819281928192 127.0.0.1:7005
   replicates 19281928192819281928192819281928192819281
>>> Can I set the above configuration? (type 'yes' to accept): yes
>>> Slots 0-5460 assigned to node 49a4928719291928192819281928192819281928
>>> Slots 5461-10922 assigned to node 9281928192819281928192819281928192819281
>>> Slots 10923-16383 assigned to node 19281928192819281928192819281928192819281
>>> Adding replica 81928192819281928192819281928192819281928 to 49a4928719291928192819281928192819281928
>>> Adding replica 28192819281928192819281928192819281928192 to 9281928192819281928192819281928192819281
>>> Adding replica 928192819281928192819281928192819281928192 to 19281928192819281928192819281928192819281
>>> [OK] All nodes agree about the cluster configuration.
>>> >>> Check cluster info
>>> >>> Nodes
>>> M: 49a4928719291928192819281928192819281928 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
>>> M: 9281928192819281928192819281928192819281 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
>>> M: 19281928192819281928192819281928192819281 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
>>> S: 81928192819281928192819281928192819281928 127.0.0.1:7003
   replicates 49a4928719291928192819281928192819281928
>>> S: 28192819281928192819281928192819281928192 127.0.0.1:7004
   replicates 9281928192819281928192819281928192819281
>>> S: 928192819281928192819281928192819281928192 127.0.0.1:7005
   replicates 19281928192819281928192819281928192819281
>>> [OK] All nodes agree about the cluster configuration.
>>> All 16384 slots covered.

Diese Ausgabe zeigt die Zuordnung von Slots zu jedem Master-Knoten und die Zuweisung von Repliken.

Mit dem Cluster verbinden:

Verbinden Sie sich mit dem Redis-Cluster mit redis-cli. Dies ermöglicht es Ihnen, Befehle gegen den Cluster auszuführen.
```
redis-cli -h 127.0.0.1 -p 7000
```
redis-cli beenden:

Beenden Sie die redis-cli-Sitzung, um sicherzustellen, dass der Befehl protokolliert wird.
```
exit
```

Sie haben nun erfolgreich einen Redis-Cluster initialisiert. In den nächsten Schritten werden wir untersuchen, wie man Knoten hinzufügt, den Clusterzustand überprüft und Slots neu verteilt (reshard).

Einen neuen Knoten zum Cluster hinzufügen

In diesem Schritt lernen Sie, wie Sie einen neuen Knoten zu einem bestehenden Redis-Cluster mit dem Befehl CLUSTER MEET hinzufügen. Dieser Befehl ist wichtig, um die Kapazität Ihres Clusters zu erweitern und eine hohe Verfügbarkeit (High Availability) sicherzustellen.

CLUSTER MEET verstehen

Der Befehl CLUSTER MEET führt einen neuen Redis-Knoten in den Cluster ein. Wenn ein Knoten diesen Befehl empfängt, versucht er, sich mit dem angegebenen Knoten zu verbinden und den Handshake-Prozess zu starten, um Teil des Clusters zu werden.

Voraussetzungen:

Ein Redis-Cluster, der wie im vorherigen Schritt beschrieben initialisiert wurde.
Eine neue Redis-Instanz, die läuft und so konfiguriert ist, dass sie Teil des Clusters ist, aber noch nicht verbunden ist. Für dieses Lab gehen wir davon aus, dass Sie eine neue Instanz haben, die auf Port 7006 läuft. Diese Instanz sollte mit der Konfigurationsoption cluster-enabled yes gestartet werden. Das Setup-Skript hat diese Instanz bereits für Sie konfiguriert und gestartet.

Schritte:

Mit einem bestehenden Knoten verbinden:

Verbinden Sie sich mit einem der bestehenden Knoten im Cluster mit redis-cli. Es spielt keine Rolle, mit welchem Knoten Sie sich verbinden, da der Befehl CLUSTER MEET die Informationen im gesamten Cluster verbreitet.
```
redis-cli -h 127.0.0.1 -p 7000
```
Den Befehl CLUSTER MEET verwenden:

Nachdem Sie sich mit einem Knoten im Cluster verbunden haben, verwenden Sie den Befehl CLUSTER MEET, um den neuen Knoten (Port 7006) einzuführen.
```
CLUSTER MEET 127.0.0.1 7006
```
- CLUSTER MEET: Der Befehl zum Hinzufügen eines neuen Knotens.
- 127.0.0.1: Die IP-Adresse des neuen Knotens.
- 7006: Die Portnummer des neuen Knotens.
Sie sollten die folgende Ausgabe sehen:
```
OK
```
Dies zeigt an, dass der Befehl erfolgreich gesendet wurde.
redis-cli beenden:

Beenden Sie die redis-cli-Sitzung, um sicherzustellen, dass der Befehl protokolliert wird.
```
exit
```

Sie haben erfolgreich einen neuen Knoten zum Redis-Cluster hinzugefügt. Im nächsten Schritt werden wir den Zustand des Clusters überprüfen.

Überprüfen des Cluster-Zustands

In diesem Schritt lernen Sie, wie Sie den Zustand und Status Ihres Redis-Clusters mit dem Befehl CLUSTER INFO überprüfen. Dieser Befehl liefert wertvolle Einblicke in den Gesamtzustand des Clusters.

CLUSTER INFO verstehen

Der Befehl CLUSTER INFO gibt Informationen über den Redis-Cluster zurück, die zur Überwachung seines Zustands und zur Diagnose von Problemen verwendet werden können.

Voraussetzungen:

Ein Redis-Cluster, der initialisiert wurde und dem ein neuer Knoten hinzugefügt wurde, wie in den vorherigen Schritten beschrieben.

Schritte:

Mit einem Cluster-Knoten verbinden:

Verbinden Sie sich mit einem beliebigen Knoten im Cluster mit redis-cli.
```
redis-cli -h 127.0.0.1 -p 7000
```

Den Befehl CLUSTER INFO ausführen:

Verwenden Sie den Befehl CLUSTER INFO, um Clusterinformationen abzurufen.

CLUSTER INFO

Sie sollten eine ähnliche Ausgabe wie die folgende sehen:

cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:7
cluster_size:3
cluster_current_epoch:7
cluster_my_epoch:7
...

Die Ausgabe interpretieren:

Hier ist eine Aufschlüsselung einiger wichtiger Metriken:
- cluster_state:ok: Der Cluster befindet sich in einem gesunden Zustand.
- cluster_slots_assigned:16384: Die Anzahl der Slots, die Knoten zugewiesen sind.
- cluster_slots_ok:16384: Die Anzahl der Slots, die korrekt funktionieren.
- cluster_slots_pfail:0: Die Anzahl der Slots in einem "potenziell fehlerhaften" Zustand (potentially failing state).
- cluster_slots_fail:0: Die Anzahl der Slots in einem "fehlerhaften" Zustand (failing state).
- cluster_known_nodes:7: Die Gesamtzahl der Knoten, die der aktuelle Knoten kennt.
- cluster_size:3: Die Anzahl der Master-Knoten im Cluster.
redis-cli beenden:

Beenden Sie die redis-cli-Sitzung, um sicherzustellen, dass der Befehl protokolliert wird.
```
exit
```

Sie haben den Zustand Ihres Redis-Clusters erfolgreich mit dem Befehl CLUSTER INFO überprüft.

Slots zum neuen Knoten re-sharden

In diesem Schritt lernen Sie, wie Sie Slots in einem Redis-Cluster mit dem Befehl redis-cli --cluster reshard re-sharden (neu verteilen). Dies ist wichtig, um Daten gleichmäßig zu verteilen, insbesondere nach dem Hinzufügen neuer Knoten.

Redis Slots und Resharding verstehen

Ein Redis-Cluster unterteilt den Keyspace in 16384 Slots. Jeder Master-Knoten ist für eine Teilmenge dieser Slots verantwortlich. Wenn Sie einen neuen Knoten hinzufügen, besitzt dieser anfänglich keine Slots. Resharding verschiebt Slots von bestehenden Knoten zum neuen Knoten, wodurch die Daten und die Arbeitslast ausgeglichen werden.

Schritte:

Mit dem Cluster über redis-cli --cluster verbinden:

Um die Resharding-Operation durchzuführen, verwenden Sie den Befehl redis-cli --cluster reshard. Dieser Befehl bietet eine interaktive Möglichkeit, Slots im Cluster neu zu verteilen.

Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:
```
redis-cli --cluster reshard 127.0.0.1:7000
```
Dieser Befehl verbindet sich mit dem Redis-Cluster über den Knoten unter 127.0.0.1:7000 und startet den Resharding-Prozess.
Die Anzahl der zu verschiebenden Slots angeben:

Das redis-cli-Tool fordert Sie auf, die Anzahl der Slots einzugeben, die Sie verschieben möchten. Für dieses Beispiel verschieben wir 101 Slots zum neuen Knoten.
```
How many slots do you want to move? (default: all)
```
Geben Sie 101 ein und drücken Sie die Eingabetaste.
Die Zielknoten-ID eingeben:

Als Nächstes fordert das Tool Sie auf, die Knoten-ID (Node ID) des Zielknotens einzugeben. Dies ist der neue Knoten, den Sie im vorherigen Schritt hinzugefügt haben (Port 7006). Um die Knoten-ID zu finden, können Sie den Befehl CLUSTER NODES verwenden, wie in den vorherigen Schritten gezeigt, oder Sie können den folgenden Befehl verwenden, um die Knoten-ID direkt abzurufen:
```
redis-cli -h 127.0.0.1 -p 7006 cluster nodes | grep myself | awk '{print $1}'
```
Kopieren Sie die Knoten-ID aus der Ausgabe. Das redis-cli-Tool fordert Sie auf:
```
What is the receiving node ID?
```
Fügen Sie die Knoten-ID ein und drücken Sie die Eingabetaste.
Die Quellknoten angeben:

Das Tool fordert Sie auf, die Quellknoten anzugeben, von denen die Slots übernommen werden sollen. Sie können all eingeben, um Slots von allen vorhandenen Master-Knoten neu zu verteilen.
```
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' to stop entering IDs.
```
Geben Sie all ein und drücken Sie die Eingabetaste.
Den Resharding-Plan bestätigen:

Das redis-cli-Tool zeigt den Resharding-Plan an und fordert Sie auf, ihn zu bestätigen.
```
Do you want to proceed with the reshard plan? (type 'yes' to accept):
```
Geben Sie yes ein und drücken Sie die Eingabetaste, um den Resharding-Prozess zu starten.
Warten, bis das Resharding abgeschlossen ist:

Das redis-cli-Tool verschiebt nun die Slots von den Quellknoten zum Zielknoten. Dieser Vorgang kann einige Zeit dauern, abhängig von der Datenmenge im Cluster. Sie sehen Fortschrittsmeldungen, während die Slots verschoben werden.
redis-cli beenden:

Sobald das Resharding abgeschlossen ist, beenden Sie die redis-cli-Sitzung.

```redis
exit
```

Sie haben nun erfolgreich Slots in Ihrem Redis-Cluster mit dem Befehl redis-cli --cluster reshard re-shardet. Dies stellt sicher, dass die Daten gleichmäßiger im Cluster verteilt sind, einschließlich des neuen Knotens.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man einen Redis-Cluster verwaltet. Sie begannen mit der Initialisierung eines Clusters mit redis-cli --cluster create, fügten dann einen neuen Knoten mit CLUSTER MEET hinzu. Sie überprüften den Zustand des Clusters mit CLUSTER INFO und re-shardeten schließlich Slots mit redis-cli --cluster reshard, um den Cluster auszugleichen. Dies sind wesentliche Aufgaben für die Verwaltung eines Redis-Clusters und die Gewährleistung seiner Skalierbarkeit und hohen Verfügbarkeit (high availability).