Cluster architecture in Redis - Step-by-Step Execution

Concept Flow - Cluster architecture

Client calculates key slot

↓

Client sends command to correct node

↓

Node processes command

↓

Return result to client

The client calculates the slot for the key, determines the correct node, sends the command directly there, and receives the result.

Execution Sample

Redis

SET user:1 "Alice"
GET user:1
DEL user:1

Commands to set, get, and delete a key in a Redis cluster, showing routing and execution.

Execution Table

Step	Action	Key	Slot Calculation	Node Chosen	Result
1	Client sends SET command	user:1	Calculate slot for 'user:1' (e.g. slot 1234)	Node A (owns slot 1234)	Sent to Node A
2	Node A executes SET	user:1	Slot 1234	Node A	OK
3	Client sends GET command	user:1	Calculate slot for 'user:1' (slot 1234)	Node A	Sent to Node A
4	Node A executes GET	user:1	Slot 1234	Node A	"Alice"
5	Client sends DEL command	user:1	Calculate slot for 'user:1' (slot 1234)	Node A	Sent to Node A
6	Node A executes DEL	user:1	Slot 1234	Node A	1 (deleted)
7	Client sends GET command	user:1	Calculate slot for 'user:1' (slot 1234)	Node A	Sent to Node A
8	Node A executes GET	user:1	Slot 1234	Node A	(nil)
9	End of commands				No more commands to process

💡 All commands processed; cluster routes commands based on key slots to correct nodes.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	After Step 8
user:1	does not exist	"Alice"	"Alice"	deleted	does not exist

Key Moments - 2 Insights

Why does the client need to calculate the slot before sending the command?

The client must calculate the slot to send the command directly to the right node (see execution_table steps 1, 3, 5).

What happens if the key does not exist on the node?

The node returns nil or 0 depending on the command, as shown in step 8 where GET returns (nil) after the key was deleted in step 6.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the result of the GET command?

A OK

B "Alice"

C 1 (deleted)

D (nil)

💡 Hint

Check the 'Result' column at step 4 in the execution_table.

At which step does the key 'user:1' get deleted from the cluster?

A Step 6

B Step 4

C Step 2

D Step 8

💡 Hint

Look at the 'Action' and 'Result' columns in the execution_table to find when DEL is executed.

If the client did not calculate the slot, what would happen?

A The command would be ignored

B The cluster would automatically find the correct node without issue

C The client would receive an error immediately

D The command would be routed to the wrong node and fail

💡 Hint

Refer to the concept_flow showing the importance of slot calculation before sending to the node.

Concept Snapshot

Redis Cluster distributes data by key slots.
Client calculates slot from key.
Slot determines which node handles the command.
Commands are sent directly to the correct node.
Nodes execute commands and return results.
This ensures data is distributed and accessible.

Full Transcript

In Redis Cluster architecture, when a client sends a command involving a key, it first calculates the key's slot. This slot number determines which node in the cluster owns the data for that key. The client then sends the command directly to that node. The node executes the command and returns the result to the client. For example, setting a key 'user:1' involves calculating its slot, routing the SET command to the correct node, storing the value, and confirming success. Later GET and DEL commands follow the same routing process. If the key is deleted, subsequent GET commands return nil. This process ensures efficient data distribution and retrieval across the cluster.

Practice

1.

What is the main purpose of Redis Cluster architecture?

easy

A. To backup data to external storage every minute

B. To store data only on a single server for simplicity

C. To encrypt data automatically on all nodes

D. To split data across multiple servers for better performance and fault tolerance

Solution

1. Step 1: Understand Redis Cluster design

   Redis Cluster splits data across multiple servers using hash slots to distribute load.

2. Step 2: Identify the main benefit

   This splitting improves speed, storage capacity, and fault tolerance by avoiding a single point of failure.

3. Final Answer:

   To split data across multiple servers for better performance and fault tolerance -> Option D

4. Quick Check:

   Redis Cluster = Data distribution + fault tolerance [OK]

Hint: Redis Cluster splits data for speed and safety [OK]

Common Mistakes:

• Thinking Redis Cluster stores data on one server
• Confusing cluster with encryption feature
• Assuming cluster only handles backups

2.

Which command line option is required to start a Redis node with cluster enabled?

redis-server --port 7000 --cluster-enabled ???

easy

A. yes

B. true

C. on

D. enable

Solution

1. Step 1: Recall Redis cluster start syntax

   To enable cluster mode, the option is --cluster-enabled yes.

2. Step 2: Confirm correct boolean value

   Redis expects 'yes' or 'no' for this flag, not 'true', 'on', or 'enable'.

3. Final Answer:

   yes -> Option A

4. Quick Check:

   Cluster enabled flag = yes [OK]

Hint: Use 'yes' to enable cluster mode in Redis [OK]

Common Mistakes:

• Using 'true' or 'on' instead of 'yes'
• Typing 'enable' which is invalid
• Omitting the cluster-enabled option

3.

Given a Redis Cluster with 3 nodes, each handling 5461 hash slots, what happens if one node fails?

Choose the correct behavior:

medium

A. All data on the failed node is lost permanently

B. The cluster stops working until the failed node is back

C. The cluster continues working if replicas exist for the failed node's slots

D. The cluster automatically merges all slots to remaining nodes

Solution

1. Step 1: Understand Redis Cluster fault tolerance

   Redis Cluster uses replicas to provide fault tolerance. If a node fails, replicas can take over its hash slots.

2. Step 2: Analyze failure impact

   If replicas exist, the cluster continues working by promoting replicas. Without replicas, cluster availability is affected.

3. Final Answer:

   The cluster continues working if replicas exist for the failed node's slots -> Option C

4. Quick Check:

   Node failure + replicas = cluster stays up [OK]

Hint: Replicas keep cluster alive if a node fails [OK]

Common Mistakes:

• Assuming cluster stops immediately on node failure
• Thinking data is lost without replicas
• Believing cluster merges slots automatically

4.

Identify the error in this Redis cluster node start command:

redis-server --port 7001 --cluster-enabled yes --cluster-config-file nodes-7001.conf --cluster-node-timeout 5000 --cluster-announce-ip 192.168.1.10 --cluster-announce-port 7001 --cluster-announce-bus-port 17001 --cluster-enabled no

medium

A. The command has conflicting cluster-enabled flags

B. The port number is invalid

C. The cluster-config-file name is incorrect

D. The cluster-node-timeout value is too low

Solution

1. Step 1: Review cluster-enabled flags

   The command has two --cluster-enabled flags: one set to 'yes' and another to 'no'. This is conflicting.

2. Step 2: Understand impact of conflicting flags

   Redis will use the last flag, disabling cluster mode, which contradicts other cluster options.

3. Final Answer:

   The command has conflicting cluster-enabled flags -> Option A

4. Quick Check:

   Conflicting flags cause cluster mode error [OK]

Hint: Avoid multiple cluster-enabled flags in one command [OK]

Common Mistakes:

• Ignoring repeated flags causing conflicts
• Assuming port 7001 is invalid
• Thinking config file name causes error

5.

You want to create a Redis Cluster with 6 nodes: 3 masters and 3 replicas. Which of the following is the correct approach to assign hash slots and replicas?

hard

A. Assign all hash slots to replicas only; masters hold no slots

B. Assign all 16384 hash slots evenly to 3 masters; assign each replica to a different master node

C. Assign hash slots randomly to all 6 nodes without replicas

D. Assign hash slots only to one master; others act as replicas

Solution

1. Step 1: Understand hash slot distribution

   Redis Cluster has 16384 hash slots. These should be evenly split among master nodes for balanced load.

2. Step 2: Assign replicas properly

   Each replica should be linked to a different master to provide fault tolerance and avoid single points of failure.

3. Final Answer:

   Assign all 16384 hash slots evenly to 3 masters; assign each replica to a different master node -> Option B

4. Quick Check:

   Slots evenly on masters + replicas assigned = correct cluster setup [OK]

Hint: Distribute slots evenly on masters; assign replicas per master [OK]

Common Mistakes:

• Assigning slots to replicas instead of masters
• Not linking replicas to masters
• Putting all slots on one master only