Configure Redis 7 Cluster Sharding & Failover

Set up Redis 7 cluster with automatic sharding across multiple nodes for horizontal scaling. Configure hash slots, master-slave replication, and automated failover with comprehensive monitoring.

Prerequisites

At least 4GB RAM
Multiple CPU cores
Root or sudo access
Network connectivity between nodes

What this solves

Redis cluster sharding distributes your data across multiple Redis nodes, allowing you to scale beyond the memory limits of a single server. This tutorial sets up a production-ready Redis 7 cluster with automated failover, hash slot management, and monitoring to handle high-traffic applications that need horizontal scaling.

Step-by-step configuration

Update system packages

Start by updating your package manager to ensure you get the latest versions.

sudo apt update && sudo apt upgrade -y

sudo dnf update -y

Install Redis 7

Install Redis 7 from the official repositories. This provides the cluster functionality we need.

sudo apt install -y redis-server redis-tools

sudo dnf install -y redis redis-tools

Configure Redis cluster nodes

Create Redis configuration files for each cluster node. We'll set up 6 nodes (3 masters, 3 slaves) across different ports.

sudo mkdir -p /etc/redis/cluster
sudo mkdir -p /var/lib/redis/cluster
sudo mkdir -p /var/log/redis

Create configuration for first master node

Configure the first master node on port 7000. This enables cluster mode and sets up data persistence.

port 7000
cluster-enabled yes
cluster-config-file nodes-7000.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly-7000.aof"
dir /var/lib/redis/cluster/7000
bind 0.0.0.0
protected-mode no
logfile /var/log/redis/redis-7000.log
loglevel notice
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump-7000.rdb
maxmemory 2gb
maxmemory-policy allkeys-lru
tcp-keepalive 60
timeout 0

Create configuration for second master node

Configure the second master node on port 7001 with similar settings but different paths.

port 7001
cluster-enabled yes
cluster-config-file nodes-7001.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly-7001.aof"
dir /var/lib/redis/cluster/7001
bind 0.0.0.0
protected-mode no
logfile /var/log/redis/redis-7001.log
loglevel notice
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump-7001.rdb
maxmemory 2gb
maxmemory-policy allkeys-lru
tcp-keepalive 60
timeout 0

Create configuration for third master node

Configure the third master node on port 7002 to complete our master node setup.

port 7002
cluster-enabled yes
cluster-config-file nodes-7002.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly-7002.aof"
dir /var/lib/redis/cluster/7002
bind 0.0.0.0
protected-mode no
logfile /var/log/redis/redis-7002.log
loglevel notice
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump-7002.rdb
maxmemory 2gb
maxmemory-policy allkeys-lru
tcp-keepalive 60
timeout 0

Create configuration for slave nodes

Configure three slave nodes on ports 7003, 7004, and 7005. These will provide automatic failover capability.

port 7003
cluster-enabled yes
cluster-config-file nodes-7003.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly-7003.aof"
dir /var/lib/redis/cluster/7003
bind 0.0.0.0
protected-mode no
logfile /var/log/redis/redis-7003.log
loglevel notice
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump-7003.rdb
maxmemory 2gb
maxmemory-policy allkeys-lru
tcp-keepalive 60
timeout 0

port 7004
cluster-enabled yes
cluster-config-file nodes-7004.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly-7004.aof"
dir /var/lib/redis/cluster/7004
bind 0.0.0.0
protected-mode no
logfile /var/log/redis/redis-7004.log
loglevel notice
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump-7004.rdb
maxmemory 2gb
maxmemory-policy allkeys-lru
tcp-keepalive 60
timeout 0

port 7005
cluster-enabled yes
cluster-config-file nodes-7005.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly-7005.aof"
dir /var/lib/redis/cluster/7005
bind 0.0.0.0
protected-mode no
logfile /var/log/redis/redis-7005.log
loglevel notice
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump-7005.rdb
maxmemory 2gb
maxmemory-policy allkeys-lru
tcp-keepalive 60
timeout 0

Create data directories

Create the data directories for each Redis node and set proper ownership.

sudo mkdir -p /var/lib/redis/cluster/{7000,7001,7002,7003,7004,7005}
sudo chown -R redis:redis /var/lib/redis/cluster
sudo chown -R redis:redis /var/log/redis
sudo chmod 755 /var/lib/redis/cluster/*

Create systemd service files

Create systemd service files for each Redis cluster node to manage them as system services.

[Unit]
Description=Redis Cluster Node 7000
After=network.target

[Service]
Type=notify
ExecStart=/usr/bin/redis-server /etc/redis/cluster/redis-7000.conf
ExecReload=/bin/kill -USR2 $MAINPID
TimeoutStopSec=0
Restart=always
User=redis
Group=redis
RuntimeDirectory=redis-7000
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target

sudo cp /etc/systemd/system/redis-cluster-7000.service /etc/systemd/system/redis-cluster-7001.service
sudo cp /etc/systemd/system/redis-cluster-7000.service /etc/systemd/system/redis-cluster-7002.service
sudo cp /etc/systemd/system/redis-cluster-7000.service /etc/systemd/system/redis-cluster-7003.service
sudo cp /etc/systemd/system/redis-cluster-7000.service /etc/systemd/system/redis-cluster-7004.service
sudo cp /etc/systemd/system/redis-cluster-7000.service /etc/systemd/system/redis-cluster-7005.service

Update service files for different ports

Modify each service file to reference the correct configuration file and port.

sudo sed -i 's/7000/7001/g' /etc/systemd/system/redis-cluster-7001.service
sudo sed -i 's/7000/7002/g' /etc/systemd/system/redis-cluster-7002.service
sudo sed -i 's/7000/7003/g' /etc/systemd/system/redis-cluster-7003.service
sudo sed -i 's/7000/7004/g' /etc/systemd/system/redis-cluster-7004.service
sudo sed -i 's/7000/7005/g' /etc/systemd/system/redis-cluster-7005.service

Start all Redis cluster nodes

Enable and start all six Redis cluster nodes.

sudo systemctl daemon-reload
sudo systemctl enable redis-cluster-7000 redis-cluster-7001 redis-cluster-7002 redis-cluster-7003 redis-cluster-7004 redis-cluster-7005
sudo systemctl start redis-cluster-7000 redis-cluster-7001 redis-cluster-7002 redis-cluster-7003 redis-cluster-7004 redis-cluster-7005

Initialize the Redis cluster

Create the cluster and assign hash slots automatically. This command distributes the 16384 hash slots across the three master nodes.

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

Type yes when prompted to accept the cluster configuration.

Warning: The bind 0.0.0.0 and protected-mode no settings allow connections from any IP address. In production, use specific IP addresses and enable authentication with the requirepass directive.

Configure firewall rules

Open the necessary ports for Redis cluster communication. Each node needs its data port and cluster bus port (data port + 10000).

sudo ufw allow 7000:7005/tcp
sudo ufw allow 17000:17005/tcp
sudo ufw reload

sudo firewall-cmd --permanent --add-port=7000-7005/tcp
sudo firewall-cmd --permanent --add-port=17000-17005/tcp
sudo firewall-cmd --reload

Set up Redis cluster monitoring script

Create a monitoring script to check cluster health and node status.

#!/bin/bash

Redis Cluster Health Monitor
echo "=== Redis Cluster Status ==="
echo "Timestamp: $(date)"
echo

Check cluster info
echo "--- Cluster Info ---"
redis-cli -p 7000 cluster info
echo

Check cluster nodes
echo "--- Cluster Nodes ---"
redis-cli -p 7000 cluster nodes
echo

Check individual node status
echo "--- Individual Node Status ---"
for port in 7000 7001 7002 7003 7004 7005; do
    echo "Node $port:"
    timeout 3 redis-cli -p $port ping 2>/dev/null || echo "  FAILED"
done
echo

Check memory usage
echo "--- Memory Usage ---"
for port in 7000 7001 7002 7003 7004 7005; do
    memory=$(redis-cli -p $port info memory | grep used_memory_human | cut -d: -f2 | tr -d '\r')
    role=$(redis-cli -p $port info replication | grep role | cut -d: -f2 | tr -d '\r')
    echo "Node $port ($role): $memory"
done
echo

Check hash slot distribution
echo "--- Hash Slot Distribution ---"
redis-cli -p 7000 cluster slots

sudo chmod +x /usr/local/bin/redis-cluster-monitor.sh

Configure automated monitoring with systemd timer

Set up a systemd timer to run cluster health checks every 5 minutes.

[Unit]
Description=Redis Cluster Health Monitor
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/redis-cluster-monitor.sh
User=redis
StandardOutput=journal
StandardError=journal

[Unit]
Description=Run Redis Cluster Monitor every 5 minutes
Requires=redis-cluster-monitor.service

[Timer]
OnCalendar=*:0/5
Persistent=true

[Install]
WantedBy=timers.target

sudo systemctl daemon-reload
sudo systemctl enable redis-cluster-monitor.timer
sudo systemctl start redis-cluster-monitor.timer

Configure Prometheus metrics exporter

Install and configure redis_exporter for Prometheus monitoring integration.

wget https://github.com/oliver006/redis_exporter/releases/download/v1.55.0/redis_exporter-v1.55.0.linux-amd64.tar.gz
tar xzf redis_exporter-v1.55.0.linux-amd64.tar.gz
sudo mv redis_exporter-v1.55.0.linux-amd64/redis_exporter /usr/local/bin/
sudo chmod +x /usr/local/bin/redis_exporter

wget https://github.com/oliver006/redis_exporter/releases/download/v1.55.0/redis_exporter-v1.55.0.linux-amd64.tar.gz
tar xzf redis_exporter-v1.55.0.linux-amd64.tar.gz
sudo mv redis_exporter-v1.55.0.linux-amd64/redis_exporter /usr/local/bin/
sudo chmod +x /usr/local/bin/redis_exporter

Create Redis exporter service

Configure the Redis exporter as a systemd service to expose cluster metrics on port 9121.

[Unit]
Description=Redis Cluster Metrics Exporter
After=network.target

[Service]
Type=simple
User=redis
Group=redis
ExecStart=/usr/local/bin/redis_exporter \
  -redis.addr=redis://127.0.0.1:7000 \
  -redis.addr=redis://127.0.0.1:7001 \
  -redis.addr=redis://127.0.0.1:7002 \
  -redis.addr=redis://127.0.0.1:7003 \
  -redis.addr=redis://127.0.0.1:7004 \
  -redis.addr=redis://127.0.0.1:7005 \
  -web.listen-address=:9121
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable redis-exporter
sudo systemctl start redis-exporter

Set up automatic failover testing

Create a script to test automatic failover by simulating node failures.

#!/bin/bash

Redis Cluster Failover Test
echo "=== Redis Cluster Failover Test ==="
echo "Starting failover test at $(date)"
echo

Get current master nodes
echo "--- Current Masters ---"
masters=$(redis-cli -p 7000 cluster nodes | grep master | awk '{print $1 ":" $2}')
echo "$masters"
echo

Pick first master for failover test
first_master_port=$(echo "$masters" | head -n1 | cut -d: -f2)
echo "Testing failover on port $first_master_port"
echo

Simulate failure by stopping the node
echo "Stopping node $first_master_port..."
sudo systemctl stop redis-cluster-$first_master_port
echo

Wait for failover
echo "Waiting 10 seconds for automatic failover..."
sleep 10
echo

Check cluster status
echo "--- Post-Failover Status ---"
redis-cli -p 7001 cluster nodes | grep -E "master|fail"
echo

Restart the failed node
echo "Restarting node $first_master_port..."
sudo systemctl start redis-cluster-$first_master_port
sleep 5
echo

Final status
echo "--- Final Status ---"
redis-cli -p 7000 cluster info | grep cluster_state
echo "Failover test completed at $(date)"

sudo chmod +x /usr/local/bin/redis-failover-test.sh

Verify your setup

Check that all Redis cluster nodes are running and the cluster is healthy.

# Check all services are running
sudo systemctl status redis-cluster-7000 redis-cluster-7001 redis-cluster-7002

Check cluster status
redis-cli -p 7000 cluster info

Check cluster nodes
redis-cli -p 7000 cluster nodes

Test cluster operations
redis-cli -c -p 7000 set test-key "Hello Redis Cluster"
redis-cli -c -p 7001 get test-key

Check metrics endpoint
curl localhost:9121/metrics | grep redis

Run monitoring script
/usr/local/bin/redis-cluster-monitor.sh

For additional monitoring integration, you can set up Redis monitoring with Prometheus and Grafana to create comprehensive dashboards for your cluster.

Hash slot management

Redis cluster automatically distributes data across nodes using hash slots. Each key is hashed and mapped to one of 16384 slots, which are distributed among master nodes.

View hash slot distribution

Check how hash slots are distributed across your cluster nodes.

# View detailed slot assignment
redis-cli -p 7000 cluster slots

Check which node serves a specific key
redis-cli -p 7000 cluster keyslot mykey

Find which node handles a slot
redis-cli -p 7000 cluster nodes | grep 0-5460

Manual hash slot rebalancing

If needed, you can manually rebalance hash slots across nodes.

# Rebalance cluster (use with caution)
redis-cli --cluster rebalance 127.0.0.1:7000 --cluster-use-empty-masters

Check cluster after rebalancing
redis-cli --cluster check 127.0.0.1:7000

Note: Hash slot rebalancing can impact performance during the operation. Always test in a staging environment first and perform during maintenance windows.

Adding and removing nodes

Redis cluster supports dynamic scaling by adding or removing nodes without downtime.

Add a new master node

Add a new master node to increase cluster capacity.

# Create new node configuration (port 7006)
sudo cp /etc/redis/cluster/redis-7000.conf /etc/redis/cluster/redis-7006.conf
sudo sed -i 's/7000/7006/g' /etc/redis/cluster/redis-7006.conf

Create data directory
sudo mkdir -p /var/lib/redis/cluster/7006
sudo chown redis:redis /var/lib/redis/cluster/7006

Create and start service
sudo cp /etc/systemd/system/redis-cluster-7000.service /etc/systemd/system/redis-cluster-7006.service
sudo sed -i 's/7000/7006/g' /etc/systemd/system/redis-cluster-7006.service
sudo systemctl daemon-reload
sudo systemctl enable redis-cluster-7006
sudo systemctl start redis-cluster-7006

Add node to cluster
redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000

Rebalance slots to new node
redis-cli --cluster rebalance 127.0.0.1:7000

Remove a node from cluster

Safely remove a node from the cluster by first moving its slots to other nodes.

# Get node ID to remove
node_id=$(redis-cli -p 7006 cluster myid)

Remove all keys from node (move slots)
redis-cli --cluster reshard 127.0.0.1:7000 --cluster-from $node_id --cluster-to-all --cluster-slots 1365

Remove empty node from cluster
redis-cli --cluster del-node 127.0.0.1:7000 $node_id

Stop and disable service
sudo systemctl stop redis-cluster-7006
sudo systemctl disable redis-cluster-7006

Performance optimization

Optimize your Redis cluster for maximum performance based on your workload characteristics.

Configure memory optimization

Tune memory settings for better performance and memory efficiency.

# Add these settings to all node configs
maxmemory-policy allkeys-lru
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100

Enable advanced persistence options

Configure hybrid persistence for better durability and performance.

# Add to all node configurations
echo "aof-use-rdb-preamble yes" | sudo tee -a /etc/redis/cluster/redis-7000.conf
echo "aof-rewrite-incremental-fsync yes" | sudo tee -a /etc/redis/cluster/redis-7000.conf

Restart nodes to apply changes
sudo systemctl restart redis-cluster-7000

You can also integrate this setup with PostgreSQL streaming replication if you're building a multi-database architecture requiring both SQL and NoSQL capabilities.

Common issues

Symptom	Cause	Fix
Cluster shows CLUSTER_STATE fail	Not all hash slots assigned	`redis-cli --cluster fix 127.0.0.1:7000`
Node won't join cluster	Node already has data	`redis-cli -p PORT flushall` then retry
High memory usage on one node	Uneven hash slot distribution	`redis-cli --cluster rebalance 127.0.0.1:7000`
Slow cluster operations	Network latency between nodes	Reduce cluster-node-timeout and optimize network
Frequent failovers	cluster-node-timeout too low	Increase timeout to 15000ms in config
Can't connect to cluster	Firewall blocking cluster bus ports	Open ports 17000-17005 for cluster communication
Split brain scenario	Network partition	Check network connectivity and restart affected nodes
Data loss after failover	AOF disabled or corrupted	Enable AOF with `appendonly yes` in config

Next steps

Implement Redis backup automation for data protection
Integrate Redis with microservices architecture for caching and session management
Configure Redis Sentinel with SSL encryption for enhanced security
Set up Redis cluster monitoring with Grafana dashboards
Implement Redis cluster backup encryption and rotation

Running this in production?

Want this handled for you? Running Redis cluster at scale adds a second layer of work: capacity planning, failover drills, security hardening, and 24/7 monitoring. Our managed platform covers monitoring, backups and response by default.

Automated install script

Run this to automate the entire setup

install.sh

#!/usr/bin/env bash

set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Default configuration
REDIS_USER="redis"
REDIS_GROUP="redis"
CLUSTER_NODES=6
MASTER_NODES=3
BASE_PORT=7000
MEMORY_LIMIT="2gb"

# Usage message
usage() {
    echo "Usage: $0 [--memory-limit <size>] [--base-port <port>]"
    echo "  --memory-limit: Redis memory limit per node (default: 2gb)"
    echo "  --base-port: Starting port number (default: 7000)"
    exit 1
}

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --memory-limit)
            MEMORY_LIMIT="$2"
            shift 2
            ;;
        --base-port)
            BASE_PORT="$2"
            shift 2
            ;;
        -h|--help)
            usage
            ;;
        *)
            echo -e "${RED}Unknown option: $1${NC}"
            usage
            ;;
    esac
done

# Cleanup function for rollback
cleanup() {
    echo -e "${RED}Installation failed. Cleaning up...${NC}"
    systemctl stop redis-cluster-* 2>/dev/null || true
    rm -rf /etc/redis/cluster /var/lib/redis/cluster /var/log/redis/redis-*.log
    rm -f /etc/systemd/system/redis-cluster-*.service
    systemctl daemon-reload
}

trap cleanup ERR

log_step() {
    echo -e "${GREEN}[$1] $2${NC}"
}

log_warning() {
    echo -e "${YELLOW}WARNING: $1${NC}"
}

log_error() {
    echo -e "${RED}ERROR: $1${NC}"
}

# Check if running as root or with sudo
if [[ $EUID -ne 0 ]]; then
    log_error "This script must be run as root or with sudo"
    exit 1
fi

# Auto-detect distribution
if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_INSTALL="apt install -y"
            PKG_UPDATE="apt update && apt upgrade -y"
            REDIS_PACKAGES="redis-server redis-tools"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_INSTALL="dnf install -y"
            PKG_UPDATE="dnf update -y"
            REDIS_PACKAGES="redis redis-tools"
            # Enable EPEL for older RHEL-based distros
            if command -v dnf >/dev/null 2>&1; then
                dnf install -y epel-release 2>/dev/null || true
            fi
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_INSTALL="yum install -y"
            PKG_UPDATE="yum update -y"
            REDIS_PACKAGES="redis redis-tools"
            ;;
        *)
            log_error "Unsupported distribution: $ID"
            exit 1
            ;;
    esac
else
    log_error "Cannot detect distribution. /etc/os-release not found."
    exit 1
fi

log_step "1/8" "Updating system packages"
$PKG_UPDATE

log_step "2/8" "Installing Redis 7 and required tools"
$PKG_INSTALL $REDIS_PACKAGES

# Stop default Redis service
systemctl stop redis 2>/dev/null || systemctl stop redis-server 2>/dev/null || true
systemctl disable redis 2>/dev/null || systemctl disable redis-server 2>/dev/null || true

log_step "3/8" "Creating Redis cluster directories"
mkdir -p /etc/redis/cluster
mkdir -p /var/lib/redis/cluster
mkdir -p /var/log/redis

# Create directories for each node
for ((i=0; i<CLUSTER_NODES; i++)); do
    port=$((BASE_PORT + i))
    mkdir -p "/var/lib/redis/cluster/$port"
done

# Set proper ownership
chown -R $REDIS_USER:$REDIS_GROUP /var/lib/redis/cluster
chown -R $REDIS_USER:$REDIS_GROUP /var/log/redis
chmod -R 750 /var/lib/redis/cluster
chmod -R 755 /var/log/redis

log_step "4/8" "Creating Redis cluster node configurations"
for ((i=0; i<CLUSTER_NODES; i++)); do
    port=$((BASE_PORT + i))
    
    cat > "/etc/redis/cluster/redis-$port.conf" << EOF
port $port
cluster-enabled yes
cluster-config-file nodes-$port.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly-$port.aof"
dir /var/lib/redis/cluster/$port
bind 0.0.0.0
protected-mode no
logfile /var/log/redis/redis-$port.log
loglevel notice
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump-$port.rdb
maxmemory $MEMORY_LIMIT
maxmemory-policy allkeys-lru
tcp-keepalive 60
timeout 0
daemonize no
supervised systemd
user $REDIS_USER
EOF
    
    chmod 644 "/etc/redis/cluster/redis-$port.conf"
done

log_step "5/8" "Creating systemd service files"
for ((i=0; i<CLUSTER_NODES; i++)); do
    port=$((BASE_PORT + i))
    
    cat > "/etc/systemd/system/redis-cluster-$port.service" << EOF
[Unit]
Description=Redis Cluster Node $port
After=network.target

[Service]
Type=notify
User=$REDIS_USER
Group=$REDIS_GROUP
ExecStart=/usr/bin/redis-server /etc/redis/cluster/redis-$port.conf
ExecStop=/bin/kill -s QUIT \$MAINPID
TimeoutStopSec=0
Restart=always
NotifyAccess=main
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
done

systemctl daemon-reload

log_step "6/8" "Starting Redis cluster nodes"
for ((i=0; i<CLUSTER_NODES; i++)); do
    port=$((BASE_PORT + i))
    systemctl enable "redis-cluster-$port"
    systemctl start "redis-cluster-$port"
    sleep 1
done

# Wait for all nodes to start
sleep 5

log_step "7/8" "Creating Redis cluster"
node_list=""
for ((i=0; i<CLUSTER_NODES; i++)); do
    port=$((BASE_PORT + i))
    node_list="$node_list 127.0.0.1:$port"
done

# Create cluster with replicas
redis-cli --cluster create $node_list --cluster-replicas 1 --cluster-yes

log_step "8/8" "Configuring firewall"
if command -v firewall-cmd >/dev/null 2>&1 && systemctl is-active --quiet firewalld; then
    for ((i=0; i<CLUSTER_NODES; i++)); do
        port=$((BASE_PORT + i))
        firewall-cmd --permanent --add-port="$port/tcp" >/dev/null
        # Cluster bus port (node port + 10000)
        cluster_port=$((port + 10000))
        firewall-cmd --permanent --add-port="$cluster_port/tcp" >/dev/null
    done
    firewall-cmd --reload >/dev/null
    log_warning "Firewall configured. Consider restricting access to trusted IPs only."
elif command -v ufw >/dev/null 2>&1; then
    for ((i=0; i<CLUSTER_NODES; i++)); do
        port=$((BASE_PORT + i))
        ufw allow "$port/tcp" >/dev/null 2>&1
        # Cluster bus port
        cluster_port=$((port + 10000))
        ufw allow "$cluster_port/tcp" >/dev/null 2>&1
    done
    log_warning "UFW configured. Consider restricting access to trusted IPs only."
fi

# Final verification
echo -e "${GREEN}Verifying Redis cluster installation...${NC}"
sleep 2

cluster_info=$(redis-cli -p $BASE_PORT cluster info | grep cluster_state | cut -d: -f2 | tr -d '\r')
if [[ "$cluster_info" == "ok" ]]; then
    echo -e "${GREEN}✓ Redis cluster is running successfully!${NC}"
    echo -e "${GREEN}✓ Cluster nodes: $CLUSTER_NODES ($MASTER_NODES masters, $((CLUSTER_NODES - MASTER_NODES)) replicas)${NC}"
    echo -e "${GREEN}✓ Port range: $BASE_PORT-$((BASE_PORT + CLUSTER_NODES - 1))${NC}"
    echo -e "${GREEN}✓ Memory limit per node: $MEMORY_LIMIT${NC}"
    
    echo -e "\n${YELLOW}Quick test commands:${NC}"
    echo "redis-cli -p $BASE_PORT cluster info"
    echo "redis-cli -p $BASE_PORT cluster nodes"
    echo "redis-cli -c -p $BASE_PORT"
    
    echo -e "\n${YELLOW}Service management:${NC}"
    echo "systemctl status redis-cluster-{$BASE_PORT..$((BASE_PORT + CLUSTER_NODES - 1))}"
else
    log_error "Cluster verification failed. Check logs: /var/log/redis/"
    exit 1
fi

Review the script before running. Execute with: bash install.sh

#redis #cluster #sharding #horizontal-scaling #failover

Configure Redis 7 cluster sharding for horizontal scaling with automated failover and monitoring

Prerequisites

What this solves

Step-by-step configuration

Update system packages

Install Redis 7

Configure Redis cluster nodes

Create configuration for first master node

Create configuration for second master node

Create configuration for third master node

Create configuration for slave nodes

Create data directories

Create systemd service files

Update service files for different ports

Start all Redis cluster nodes

Initialize the Redis cluster

Configure firewall rules

Set up Redis cluster monitoring script

Redis Cluster Health Monitor

Check cluster info

Check cluster nodes

Check individual node status

Check memory usage

Check hash slot distribution

Configure automated monitoring with systemd timer

Configure Prometheus metrics exporter

Create Redis exporter service

Set up automatic failover testing

Redis Cluster Failover Test

Get current master nodes

Pick first master for failover test

Simulate failure by stopping the node

Wait for failover

Check cluster status

Restart the failed node

Final status

Verify your setup

Check cluster status

Check cluster nodes

Test cluster operations

Check metrics endpoint

Run monitoring script

Hash slot management

View hash slot distribution

Check which node serves a specific key

Find which node handles a slot

Manual hash slot rebalancing

Check cluster after rebalancing

Adding and removing nodes

Add a new master node

Create data directory

Create and start service

Add node to cluster

Rebalance slots to new node

Remove a node from cluster

Remove all keys from node (move slots)

Remove empty node from cluster

Stop and disable service

Performance optimization

Configure memory optimization

Enable advanced persistence options

Restart nodes to apply changes

Common issues

Next steps

Running this in production?

Related tutorials

Implement ClickHouse backup automation with compression and S3 integration

Benchmark database performance with sysbench and fio integration

Configure MySQL binary log backup and point-in-time recovery

Don't want to manage this yourself?