自动配置Redis集群的脚本怎么写

wen 实用脚本 2026-07-11 220

本文目录导读：

自动配置Redis集群的脚本怎么写

基础版Redi集群配置脚本
Docker版Redis集群配置脚本
使用说明
验证集群

我来提供一个自动配置Redis集群的Shell脚本,这个脚本可以自动创建、配置和启动Redis集群。

基础版Redi集群配置脚本

#!/bin/bash
# Redis集群自动配置脚本
# 使用前请修改以下配置变量
# ============ 配置参数 ============
REDIS_VERSION="6.2.6"  # Redis版本
REDIS_PASSWORD=""      # Redis密码（可选）
BASE_PORT=6379         # 基础端口
NODE_COUNT=6           # 节点数量（必须为6，3主3从）
REDIS_DIR="/usr/local/redis"  # 安装目录
DATA_DIR="/data/redis"        # 数据目录
LOG_DIR="/var/log/redis"      # 日志目录
CLUSTER_REPLICAS=1     # 每个主节点的副本数
# 服务器节点IP列表（需要提前配置好免密登录）
# 如果是单机多实例，填localhost即可
NODE_IPS=(
    "127.0.0.1"
    "127.0.0.1"
    "127.0.0.1"
    "127.0.0.1"
    "127.0.0.1"
    "127.0.0.1"
)
# ============ 颜色输出 ============
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
# ============ 函数定义 ============
print_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}
print_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}
print_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}
# 检查命令是否存在
check_command() {
    if ! command -v $1 &> /dev/null; then
        print_error "$1 命令未找到，请先安装"
        exit 1
    fi
}
# 安装Redis
install_redis() {
    print_info "开始安装Redis..."
    # 检查是否已安装
    if [ -f "${REDIS_DIR}/bin/redis-server" ]; then
        print_warn "Redis已安装，跳过安装步骤"
        return 0
    fi
    # 安装依赖
    if command -v apt-get &> /dev/null; then
        apt-get update
        apt-get install -y build-essential tcl
    elif command -v yum &> /dev/null; then
        yum groupinstall -y "Development Tools"
        yum install -y tcl
    fi
    # 下载并编译Redis
    cd /tmp
    wget http://download.redis.io/releases/redis-${REDIS_VERSION}.tar.gz
    tar xzf redis-${REDIS_VERSION}.tar.gz
    cd redis-${REDIS_VERSION}
    make
    make install PREFIX=${REDIS_DIR}
    # 清理临时文件
    cd /tmp
    rm -rf redis-${REDIS_VERSION}.tar.gz redis-${REDIS_VERSION}
    print_info "Redis安装完成"
}
# 创建Redis配置文件
create_redis_config() {
    local node_id=$1
    local port=$((BASE_PORT + node_id))
    local config_file="${REDIS_DIR}/conf/redis_${port}.conf"
    print_info "创建Redis配置文件: ${config_file}"
    # 创建配置目录
    mkdir -p ${REDIS_DIR}/conf ${DATA_DIR}/${port} ${LOG_DIR}
    cat > ${config_file} << EOF
# Redis集群节点配置文件
port ${port}
daemonize yes
pidfile /var/run/redis_${port}.pid
loglevel notice
logfile "${LOG_DIR}/redis_${port}.log"
# 数据持久化
dir ${DATA_DIR}/${port}
appendonly yes
appendfsync everysec
save 900 1
save 300 10
save 60 10000
# 集群配置
cluster-enabled yes
cluster-config-file nodes_${port}.conf
cluster-node-timeout 5000
# 网络配置
bind 0.0.0.0
protected-mode no
# 性能优化
tcp-backlog 511
timeout 0
tcp-keepalive 300
maxclients 10000
EOF
    # 如果设置了密码，添加密码配置
    if [ -n "$REDIS_PASSWORD" ]; then
        echo "requirepass ${REDIS_PASSWORD}" >> ${config_file}
        echo "masterauth ${REDIS_PASSWORD}" >> ${config_file}
    fi
}
# 启动Redis实例
start_redis_instance() {
    local node_id=$1
    local port=$((BASE_PORT + node_id))
    local config_file="${REDIS_DIR}/conf/redis_${port}.conf"
    print_info "启动Redis实例: 端口 ${port}"
    # 检查是否已经在运行
    if ${REDIS_DIR}/bin/redis-cli -p ${port} ping 2>/dev/null | grep -q "PONG"; then
        print_warn "Redis实例 ${port} 已在运行"
        return 0
    fi
    # 启动Redis
    ${REDIS_DIR}/bin/redis-server ${config_file}
    # 等待启动完成
    sleep 2
    # 检查是否启动成功
    if ${REDIS_DIR}/bin/redis-cli -p ${port} ping 2>/dev/null | grep -q "PONG"; then
        print_info "Redis实例 ${port} 启动成功"
    else
        print_error "Redis实例 ${port} 启动失败"
        tail -5 ${LOG_DIR}/redis_${port}.log
        return 1
    fi
}
# 创建集群
create_cluster() {
    print_info "开始创建Redis集群..."
    # 构建集群节点列表
    local cluster_nodes=""
    for i in $(seq 0 $((NODE_COUNT - 1))); do
        local port=$((BASE_PORT + i))
        cluster_nodes="${cluster_nodes} ${NODE_IPS[$i]}:${port}"
    done
    # 使用redis-cli创建集群
    local create_cmd="${REDIS_DIR}/bin/redis-cli --cluster create ${cluster_nodes} --cluster-replicas ${CLUSTER_REPLICAS}"
    # 如果有密码，添加认证
    if [ -n "$REDIS_PASSWORD" ]; then
        create_cmd="${create_cmd} -a ${REDIS_PASSWORD}"
    fi
    print_info "执行命令: ${create_cmd}"
    # 自动确认集群创建
    echo yes | ${create_cmd}
    if [ $? -eq 0 ]; then
        print_info "Redis集群创建成功"
    else
        print_error "Redis集群创建失败"
        return 1
    fi
}
# 检查集群状态
check_cluster_status() {
    print_info "检查集群状态..."
    local first_port=$BASE_PORT
    local check_cmd="${REDIS_DIR}/bin/redis-cli -p ${first_port} cluster info"
    if [ -n "$REDIS_PASSWORD" ]; then
        check_cmd="${check_cmd} -a ${REDIS_PASSWORD}"
    fi
    local cluster_info=$(${check_cmd} 2>/dev/null)
    if echo "${cluster_info}" | grep -q "cluster_state:ok"; then
        print_info "集群状态正常"
        echo "${cluster_info}"
        # 显示节点信息
        echo -e "\n${GREEN}节点信息:${NC}"
        ${REDIS_DIR}/bin/redis-cli -p ${first_port} cluster nodes 2>/dev/null
    else
        print_error "集群状态异常"
        echo "${cluster_info}"
        return 1
    fi
}
# 停止所有Redis实例
stop_all_instances() {
    print_warn "停止所有Redis实例..."
    for port in $(seq ${BASE_PORT} $((BASE_PORT + NODE_COUNT - 1))); do
        ${REDIS_DIR}/bin/redis-cli -p ${port} shutdown 2>/dev/null
        print_info "已停止实例: 端口 ${port}"
    done
    # 等待所有实例停止
    sleep 2
}
# 清理集群数据
clean_cluster_data() {
    print_warn "清理集群数据..."
    # 停止实例
    for port in $(seq ${BASE_PORT} $((BASE_PORT + NODE_COUNT - 1))); do
        ${REDIS_DIR}/bin/redis-cli -p ${port} shutdown 2>/dev/null
        sleep 1
        # 删除数据文件
        rm -f ${DATA_DIR}/${port}/appendonly.aof
        rm -f ${DATA_DIR}/${port}/dump.rdb
        rm -f ${DATA_DIR}/${port}/nodes_*.conf
    done
    print_info "集群数据已清理"
}
# ============ 主程序 ============
main() {
    print_info "Redis集群自动配置脚本"
    echo "==================================="
    # 检查必要命令
    check_command "wget"
    check_command "make"
    # 检查节点数量
    if [ ${NODE_COUNT} -ne 6 ]; then
        print_warn "建议使用6个节点（3主3从）"
    fi
    case "$1" in
        install)
            install_redis
            ;;
        start)
            # 启动所有节点
            for i in $(seq 0 $((NODE_COUNT - 1))); do
                create_redis_config $i
                start_redis_instance $i
            done
            ;;
        create)
            create_cluster
            ;;
        stop)
            stop_all_instances
            ;;
        restart)
            stop_all_instances
            sleep 2
            for i in $(seq 0 $((NODE_COUNT - 1))); do
                create_redis_config $i
                start_redis_instance $i
            done
            sleep 3
            create_cluster
            ;;
        clean)
            clean_cluster_data
            ;;
        status)
            check_cluster_status
            ;;
        all)
            # 完整流程：安装、配置、启动、创建集群
            install_redis
            for i in $(seq 0 $((NODE_COUNT - 1))); do
                create_redis_config $i
                start_redis_instance $i
            done
            sleep 3
            create_cluster
            sleep 2
            check_cluster_status
            ;;
        *)
            echo "使用方法: $0 {install|start|create|stop|restart|clean|status|all}"
            echo ""
            echo "选项说明:"
            echo "  install  - 安装Redis"
            echo "  start    - 启动所有Redis实例"
            echo "  create   - 创建Redis集群"
            echo "  stop     - 停止所有Redis实例"
            echo "  restart  - 重启所有实例并重建集群"
            echo "  clean    - 清理集群数据"
            echo "  status   - 检查集群状态"
            echo "  all      - 完整配置流程"
            exit 1
            ;;
    esac
}
# 执行主程序
main "$@"

Docker版Redis集群配置脚本

如果需要使用Docker部署,这里还有一个更便捷的Docker版本：

#!/bin/bash
# Docker版Redis集群自动配置脚本
# ============ 配置参数 ============
NETWORK_NAME="redis-cluster"
BASE_PORT=6379
NODE_COUNT=6
REDIS_VERSION="6.2.6"
# ============ 颜色输出 ============
GREEN='\033[0;32m'
NC='\033[0m'
print_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}
# 创建Docker网络
create_network() {
    docker network create ${NETWORK_NAME} 2>/dev/null || true
    print_info "Docker网络已创建: ${NETWORK_NAME}"
}
# 创建Redis配置
create_redis_config_docker() {
    local node_id=$1
    local port=$((BASE_PORT + node_id))
    mkdir -p /tmp/redis-cluster/${port}
    cat > /tmp/redis-cluster/${port}/redis.conf << EOF
port ${port}
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
protected-mode no
bind 0.0.0.0
daemonize no
EOF
}
# 启动容器
start_containers() {
    for i in $(seq 0 $((NODE_COUNT - 1))); do
        local port=$((BASE_PORT + i))
        create_redis_config_docker $i
        docker run -d \
            --name redis-cluster-${i} \
            --net ${NETWORK_NAME} \
            -v /tmp/redis-cluster/${port}/redis.conf:/usr/local/etc/redis/redis.conf \
            redis:${REDIS_VERSION} \
            redis-server /usr/local/etc/redis/redis.conf
        print_info "启动容器 redis-cluster-${i} (端口: ${port})"
    done
}
# 获取容器IP
get_container_ips() {
    local ips=()
    for i in $(seq 0 $((NODE_COUNT - 1))); do
        local ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis-cluster-${i})
        ips+=("${ip}")
    done
    echo "${ips[@]}"
}
# 创建集群
create_cluster_docker() {
    local ips=($(get_container_ips))
    # 获取第一个容器的IP
    local first_ips="${ips[@]/%/:6379}"
    # 创建集群
    docker exec redis-cluster-0 redis-cli \
        --cluster create ${first_ips} \
        --cluster-replicas 1
    print_info "Docker Redis集群创建成功"
}
# 主函数
main() {
    print_info "Docker Redis集群自动配置脚本"
    case "$1" in
        start)
            create_network
            start_containers
            sleep 5
            create_cluster_docker
            ;;
        stop)
            for i in $(seq 0 $((NODE_COUNT - 1))); do
                docker stop redis-cluster-${i}
                docker rm redis-cluster-${i}
            done
            docker network rm ${NETWORK_NAME} 2>/dev/null
            rm -rf /tmp/redis-cluster
            print_info "Docker集群已清理"
            ;;
        status)
            docker ps --filter "name=redis-cluster"
            ;;
        *)
            echo "使用方法: $0 {start|stop|status}"
            exit 1
            ;;
    esac
}
main "$@"

使用说明

基础版使用：

# 1. 给脚本添加执行权限
chmod +x redis-cluster-setup.sh
# 2. 安装Redis
./redis-cluster-setup.sh install
# 3. 启动所有Redis实例
./redis-cluster-setup.sh start
# 4. 创建集群
./redis-cluster-setup.sh create
# 5. 完整流程（一键完成）
./redis-cluster-setup.sh all
# 6. 检查集群状态
./redis-cluster-setup.sh status
# 7. 停止所有实例
./redis-cluster-setup.sh stop
# 8. 清理数据
./redis-cluster-setup.sh clean

Docker版使用：

# 1. 启动集群
./redis-cluster-docker.sh start
# 2. 查看状态
./redis-cluster-docker.sh status
# 3. 停止并清理
./redis-cluster-docker.sh stop

验证集群

# 连接集群测试
redis-cli -c -p 6379
# 测试写入
set test_key "Hello Redis Cluster"
# 测试读取
get test_key
# 查看集群信息
cluster info
# 查看节点信息
cluster nodes

这个脚本提供了完整的Redis集群自动化配置功能,可以根据实际需求修改配置参数。

本文地址： https://www.bmjup.com/post/19055.html