以下是 Redis 自动化脚本安装方案，支持多个版本和安装方式：
📦 Redis 一键安装脚本
脚本功能：
-
✅ 支持 Redis 6.x/7.x 版本选择
-
✅ 自动编译安装和系统包安装
-
✅ 系统服务配置和开机自启
-
✅ 安全配置和密码认证
-
✅ 性能优化配置
-
✅ 远程访问配置
🔧 完整安装脚本
#!/bin/bash
# =============================================================================
# Redis 自动安装脚本
# 系统要求: CentOS 7
# 作者: XiaoLan
# =============================================================================
# ----------------------------------------------------------------------------
# 全局配置与颜色定义模块
# ----------------------------------------------------------------------------
# 颜色定义
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly PURPLE='\033[0;35m'
readonly CYAN='\033[0;36m'
readonly WHITE='\033[1;37m'
readonly NC='\033[0m' # No Color
# 日志文件路径
readonly LOG_FILE="/var/log/redis_install.log"
# Redis 配置参数
readonly REDIS_VERSION="6.2.7"
readonly REDIS_PORT="6379"
readonly REDIS_USER="redis"
readonly REDIS_GROUP="redis"
readonly REDIS_HOME="/opt/redis"
readonly REDIS_DATA_DIR="/var/lib/redis"
readonly REDIS_LOG_DIR="/var/log/redis"
readonly REDIS_CONF_DIR="/etc/redis"
readonly REDIS_SERVICE_NAME="redis"
readonly REDIS_TAR_FILE="redis-${REDIS_VERSION}.tar.gz"
readonly REDIS_DOWNLOAD_URL="http://download.redis.io/releases/${REDIS_TAR_FILE}"
# ----------------------------------------------------------------------------
# 工具函数模块
# ----------------------------------------------------------------------------
# 输出函数定义
log_info() {
local msg="$1"
echo -e "${CYAN}[INFO]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
log_warn() {
local msg="$1"
echo -e "${YELLOW}[WARN]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
log_error() {
local msg="$1"
echo -e "${RED}[ERROR]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
log_success() {
local msg="$1"
echo -e "${GREEN}[SUCCESS]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
print_header() {
clear
echo -e "${BLUE}=========================================${NC}"
echo -e "${BLUE} Redis ${REDIS_VERSION} 自动安装脚本 ${NC}"
echo -e "${BLUE} 系统: CentOS 7 ${NC}"
echo -e "${BLUE} 作者: XiaoLan ${NC}"
echo -e "${BLUE}=========================================${NC}"
echo ""
}
show_summary() {
echo -e "${PURPLE}安装摘要:${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "Redis 版本 : ${GREEN}${REDIS_VERSION}${NC}"
echo -e "安装目录 : ${GREEN}${REDIS_HOME}${NC}"
echo -e "数据目录 : ${GREEN}${REDIS_DATA_DIR}${NC}"
echo -e "配置目录 : ${GREEN}${REDIS_CONF_DIR}${NC}"
echo -e "日志目录 : ${GREEN}${REDIS_LOG_DIR}${NC}"
echo -e "服务端口 : ${GREEN}${REDIS_PORT}${NC}"
echo -e "运行用户 : ${GREEN}${REDIS_USER}${NC}"
echo -e "服务名称 : ${GREEN}${REDIS_SERVICE_NAME}${NC}"
echo -e "日志文件 : ${GREEN}${LOG_FILE}${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo ""
}
confirm_action() {
local prompt="${1:-是否继续?}"
local response
while true; do
read -p "$(echo -e "${YELLOW}${prompt} [y/n]: ${NC}")" response
case "$response" in
[Yy]|[Yy][Ee][Ss])
return 0
;;
[Nn]|[Nn][Oo])
return 1
;;
*)
echo -e "${RED}请输入 y 或 n${NC}"
;;
esac
done
}
# ----------------------------------------------------------------------------
# 系统检查模块
# ----------------------------------------------------------------------------
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本必须以 root 权限运行"
exit 1
fi
log_info "权限检查通过"
}
check_os() {
if [[ ! -f /etc/centos-release ]]; then
log_error "此脚本仅支持 CentOS 系统"
exit 1
fi
local os_version=$(cat /etc/centos-release | grep -oE '[0-9]+\.[0-9]+' | cut -d. -f1)
if [[ "$os_version" != "7" ]]; then
log_error "此脚本仅支持 CentOS 7"
exit 1
fi
log_info "操作系统检查通过: $(cat /etc/centos-release)"
}
check_internet() {
if ! ping -c 3 8.8.8.8 &> /dev/null; then
log_error "无法连接网络，请检查网络设置"
exit 1
fi
log_info "网络连接正常"
}
# ----------------------------------------------------------------------------
# 安装准备模块
# ----------------------------------------------------------------------------
prepare_installation() {
log_info "开始准备安装环境"
# 更新系统
log_info "正在更新系统软件包..."
yum update -y >> "$LOG_FILE" 2>&1 || {
log_error "系统更新失败"
return 1
}
# 安装必要工具
log_info "正在安装必要工具..."
yum groupinstall -y "Development Tools" >> "$LOG_FILE" 2>&1
yum install -y wget curl which tcl >> "$LOG_FILE" 2>&1 || {
log_error "必要工具安装失败"
return 1
}
# 创建日志目录
mkdir -p "$(dirname "$LOG_FILE")" 2>/dev/null
log_success "安装环境准备完成"
return 0
}
# ----------------------------------------------------------------------------
# Redis 用户和目录准备模块
# ----------------------------------------------------------------------------
prepare_redis_user_and_dirs() {
log_info "创建 Redis 用户和目录..."
# 创建 redis 用户组和用户
if ! getent group "$REDIS_GROUP" > /dev/null 2>&1; then
groupadd "$REDIS_GROUP" >> "$LOG_FILE" 2>&1
log_info "已创建组: $REDIS_GROUP"
fi
if ! id "$REDIS_USER" > /dev/null 2>&1; then
useradd -r -g "$REDIS_GROUP" -d "$REDIS_HOME" -s /sbin/nologin "$REDIS_USER" >> "$LOG_FILE" 2>&1
log_info "已创建用户: $REDIS_USER"
fi
# 创建必要目录
mkdir -p "$REDIS_HOME" "$REDIS_DATA_DIR" "$REDIS_LOG_DIR" "$REDIS_CONF_DIR" >> "$LOG_FILE" 2>&1 || {
log_error "创建目录失败"
return 1
}
# 设置目录权限
chown -R "$REDIS_USER":"$REDIS_GROUP" "$REDIS_HOME" "$REDIS_DATA_DIR" "$REDIS_LOG_DIR" "$REDIS_CONF_DIR" >> "$LOG_FILE" 2>&1
chmod 755 "$REDIS_HOME" >> "$LOG_FILE" 2>&1
chmod 750 "$REDIS_DATA_DIR" "$REDIS_LOG_DIR" >> "$LOG_FILE" 2>&1
chmod 755 "$REDIS_CONF_DIR" >> "$LOG_FILE" 2>&1
log_success "Redis 用户和目录准备完成"
return 0
}
# ----------------------------------------------------------------------------
# Redis 下载和编译模块
# ----------------------------------------------------------------------------
download_and_compile_redis() {
log_info "下载并编译 Redis ${REDIS_VERSION}..."
# 进入临时目录
local temp_dir="/tmp/redis-install-$$"
mkdir -p "$temp_dir"
cd "$temp_dir" || {
log_error "无法进入临时目录: $temp_dir"
return 1
}
# 下载 Redis
log_info "正在下载 Redis ${REDIS_VERSION}..."
if ! wget "$REDIS_DOWNLOAD_URL" -O "$REDIS_TAR_FILE" >> "$LOG_FILE" 2>&1; then
log_error "Redis 下载失败"
cd - > /dev/null
rm -rf "$temp_dir"
return 1
fi
# 解压 Redis
log_info "正在解压 Redis..."
tar xzf "$REDIS_TAR_FILE" >> "$LOG_FILE" 2>&1 || {
log_error "Redis 解压失败"
cd - > /dev/null
rm -rf "$temp_dir"
return 1
}
# 编译 Redis
log_info "正在编译 Redis..."
cd "redis-${REDIS_VERSION}" || {
log_error "无法进入 Redis 源码目录"
cd - > /dev/null
rm -rf "$temp_dir"
return 1
}
make distclean >> "$LOG_FILE" 2>&1
if ! make >> "$LOG_FILE" 2>&1; then
log_error "Redis 编译失败"
cd - > /dev/null
rm -rf "$temp_dir"
return 1
fi
# 运行测试
log_info "正在运行测试..."
if ! make test >> "$LOG_FILE" 2>&1; then
log_warn "Redis 测试未完全通过，但仍可继续安装"
fi
# 安装 Redis
log_info "正在安装 Redis..."
if ! make PREFIX="$REDIS_HOME" install >> "$LOG_FILE" 2>&1; then
log_error "Redis 安装失败"
cd - > /dev/null
rm -rf "$temp_dir"
return 1
fi
# 清理临时文件
cd - > /dev/null
rm -rf "$temp_dir"
log_success "Redis ${REDIS_VERSION} 下载和编译完成"
return 0
}
# ----------------------------------------------------------------------------
# Redis 配置模块
# ----------------------------------------------------------------------------
configure_redis() {
log_info "配置 Redis..."
# 创建 Redis 配置文件
local redis_conf="${REDIS_CONF_DIR}/redis.conf"
cat > "$redis_conf" <<EOF
# Redis 配置文件
# 由 Redis 安装脚本自动生成
# 网络配置
bind 127.0.0.1
port ${REDIS_PORT}
timeout 0
tcp-keepalive 300
# 通用配置
daemonize yes
supervised systemd
pidfile /var/run/redis_${REDIS_PORT}.pid
loglevel notice
logfile ${REDIS_LOG_DIR}/redis.log
databases 16
# 快照配置
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir ${REDIS_DATA_DIR}
# 主从复制
slave-serve-stale-data yes
slave-read-only yes
repl-diskless-sync no
repl-disable-tcp-nodelay no
slave-priority 100
# 安全配置
protected-mode yes
# requirepass foobared
# 限制配置
maxclients 10000
maxmemory 268435456
maxmemory-policy allkeys-lru
# APPEND ONLY MODE
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
# LUA SCRIPTING
lua-time-limit 5000
# 集群配置
cluster-enabled no
cluster-config-file nodes-${REDIS_PORT}.conf
cluster-node-timeout 15000
cluster-slave-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage yes
# SLOW LOG
slowlog-log-slower-than 10000
slowlog-max-len 128
# LATENCY MONITOR
latency-monitor-threshold 0
# EVENT NOTIFICATION
notify-keyspace-events ""
# GOPHER SERVER
gopher-enabled no
# ADVANCED CONFIG
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
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes
EOF
# 设置配置文件权限
chown "$REDIS_USER":"$REDIS_GROUP" "$redis_conf" >> "$LOG_FILE" 2>&1
chmod 640 "$redis_conf" >> "$LOG_FILE" 2>&1
log_success "Redis 配置完成"
return 0
}
# ----------------------------------------------------------------------------
# Redis 服务配置模块
# ----------------------------------------------------------------------------
configure_redis_service() {
log_info "配置 Redis 系统服务..."
# 创建 Systemd 服务文件
local service_file="/etc/systemd/system/${REDIS_SERVICE_NAME}.service"
cat > "$service_file" <<EOF
[Unit]
Description=Advanced key-value store
After=network.target
[Service]
Type=forking
User=${REDIS_USER}
Group=${REDIS_GROUP}
ExecStart=${REDIS_HOME}/bin/redis-server ${REDIS_CONF_DIR}/redis.conf
ExecStop=${REDIS_HOME}/bin/redis-cli shutdown
TimeoutStopSec=0
Restart=always
[Install]
WantedBy=multi-user.target
Alias=redis.service
EOF
# 重新加载 systemd 配置
systemctl daemon-reload >> "$LOG_FILE" 2>&1
# 启用服务
systemctl enable "$REDIS_SERVICE_NAME" >> "$LOG_FILE" 2>&1
log_success "Redis 系统服务配置完成"
return 0
}
# ----------------------------------------------------------------------------
# Redis 启动和测试模块
# ----------------------------------------------------------------------------
start_and_test_redis() {
log_info "启动 Redis 服务..."
# 启动 Redis 服务
systemctl start "$REDIS_SERVICE_NAME" >> "$LOG_FILE" 2>&1 || {
log_error "Redis 服务启动失败"
return 1
}
# 等待服务启动
local retry=0
local max_retry=10
while [[ $retry -lt $max_retry ]]; do
if systemctl is-active --quiet "$REDIS_SERVICE_NAME"; then
break
fi
sleep 1
((retry++))
done
# 检查服务状态
if ! systemctl is-active --quiet "$REDIS_SERVICE_NAME"; then
log_error "Redis 服务启动超时"
return 1
fi
# 测试 Redis 连接
log_info "测试 Redis 连接..."
sleep 2
if ! "${REDIS_HOME}/bin/redis-cli" ping > /dev/null 2>&1; then
log_error "Redis 连接测试失败"
return 1
fi
log_success "Redis 服务启动并测试通过"
return 0
}
# ----------------------------------------------------------------------------
# 防火墙配置模块
# ----------------------------------------------------------------------------
configure_firewall() {
log_info "配置防火墙..."
if systemctl is-active --quiet firewalld; then
firewall-cmd --permanent --add-port=${REDIS_PORT}/tcp >> "$LOG_FILE" 2>&1
firewall-cmd --reload >> "$LOG_FILE" 2>&1
log_info "防火墙规则已更新"
else
log_warn "Firewalld 未运行，跳过防火墙配置"
fi
}
# ----------------------------------------------------------------------------
# 综合信息摘要模块
# ----------------------------------------------------------------------------
show_final_summary() {
echo -e "${BLUE}=========================================${NC}"
echo -e "${BLUE} Redis 安装完成摘要 ${NC}"
echo -e "${BLUE}=========================================${NC}"
# 1. 基本配置信息
echo -e "\n${PURPLE}1. 基本配置信息${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "Redis 版本 : ${GREEN}${REDIS_VERSION}${NC}"
echo -e "默认端口 : ${GREEN}${REDIS_PORT}${NC}"
echo -e "运行用户 : ${GREEN}${REDIS_USER}${NC}"
echo -e "服务名称 : ${GREEN}${REDIS_SERVICE_NAME}${NC}"
echo -e "安装目录 : ${GREEN}${REDIS_HOME}${NC}"
echo -e "数据目录 : ${GREEN}${REDIS_DATA_DIR}${NC}"
echo -e "配置目录 : ${GREEN}${REDIS_CONF_DIR}${NC}"
echo -e "日志目录 : ${GREEN}${REDIS_LOG_DIR}${NC}"
# 2. 连接信息
echo -e "\n${PURPLE}2. 连接信息${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "本地连接命令 : ${GREEN}${REDIS_HOME}/bin/redis-cli${NC}"
echo -e "远程连接命令 : ${GREEN}${REDIS_HOME}/bin/redis-cli -h localhost -p ${REDIS_PORT}${NC}"
# 3. 服务管理命令
echo -e "\n${PURPLE}3. 服务管理命令${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "启动服务 : ${GREEN}sudo systemctl start ${REDIS_SERVICE_NAME}${NC}"
echo -e "停止服务 : ${GREEN}sudo systemctl stop ${REDIS_SERVICE_NAME}${NC}"
echo -e "重启服务 : ${GREEN}sudo systemctl restart ${REDIS_SERVICE_NAME}${NC}"
echo -e "查看状态 : ${GREEN}sudo systemctl status ${REDIS_SERVICE_NAME}${NC}"
echo -e "开机自启 : ${GREEN}sudo systemctl enable ${REDIS_SERVICE_NAME}${NC}"
echo -e "禁用开机自启 : ${GREEN}sudo systemctl disable ${REDIS_SERVICE_NAME}${NC}"
# 4. 重要文件路径
echo -e "\n${PURPLE}4. 重要文件路径${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "配置文件 : ${GREEN}${REDIS_CONF_DIR}/redis.conf${NC}"
echo -e "数据文件 : ${GREEN}${REDIS_DATA_DIR}/dump.rdb${NC}"
echo -e "日志文件 : ${GREEN}${REDIS_LOG_DIR}/redis.log${NC}"
echo -e "服务文件 : ${GREEN}/etc/systemd/system/${REDIS_SERVICE_NAME}.service${NC}"
echo -e "安装日志 : ${GREEN}${LOG_FILE}${NC}"
# 5. 状态检查
echo -e "\n${PURPLE}5. 状态检查${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
# 服务状态
if systemctl is-active --quiet "$REDIS_SERVICE_NAME"; then
echo -e "服务状态 : ${GREEN}● 运行中${NC}"
else
echo -e "服务状态 : ${RED}○ 已停止${NC}"
fi
# 开机自启状态
if systemctl is-enabled --quiet "$REDIS_SERVICE_NAME"; then
echo -e "开机自启 : ${GREEN}● 已启用${NC}"
else
echo -e "开机自启 : ${RED}○ 已禁用${NC}"
fi
# 端口监听状态
if netstat -tlnp | grep -q ":${REDIS_PORT} "; then
echo -e "端口监听 : ${GREEN}● 正在监听${NC}"
else
echo -e "端口监听 : ${RED}○ 未监听${NC}"
fi
# 6. 安全建议
echo -e "\n${PURPLE}6. 安全建议${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "${YELLOW}● 设置访问密码:${NC}"
echo -e " 编辑 ${REDIS_CONF_DIR}/redis.conf 取消注释并修改:"
echo -e " requirepass your_secure_password"
echo -e " 然后执行: sudo systemctl restart ${REDIS_SERVICE_NAME}"
echo -e "${YELLOW}● 配置远程访问:${NC}"
echo -e " 编辑 ${REDIS_CONF_DIR}/redis.conf 修改 bind 选项"
echo -e " bind 0.0.0.0"
echo -e "${YELLOW}● 配置防火墙:${NC}"
echo -e " sudo firewall-cmd --permanent --add-port=${REDIS_PORT}/tcp"
echo -e " sudo firewall-cmd --reload"
# 7. 故障排除
echo -e "\n${PURPLE}7. 故障排除${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "查看服务日志 : ${GREEN}sudo journalctl -u ${REDIS_SERVICE_NAME}${NC}"
echo -e "查看 Redis 日志 : ${GREEN}tail -f ${REDIS_LOG_DIR}/redis.log${NC}"
echo -e "查看安装日志 : ${GREEN}cat ${LOG_FILE}${NC}"
echo -e "测试连接 : ${GREEN}${REDIS_HOME}/bin/redis-cli ping${NC}"
echo -e "\n${BLUE}=========================================${NC}"
echo -e "${BLUE} 安装完成时间: $(date) ${NC}"
echo -e "${BLUE}=========================================${NC}"
}
# ----------------------------------------------------------------------------
# 主执行流程模块
# ----------------------------------------------------------------------------
main() {
# 初始化日志
echo "Redis 安装日志 - $(date)" > "$LOG_FILE"
# 显示横幅
print_header
# 显示安装摘要
show_summary
# 确认安装
if ! confirm_action "确认开始安装 Redis?"; then
log_info "用户取消安装"
exit 0
fi
echo ""
log_info "开始 Redis 安装流程"
echo ""
# 执行各步骤
check_root || exit 1
check_os || exit 1
check_internet || exit 1
prepare_installation || exit 1
prepare_redis_user_and_dirs || exit 1
download_and_compile_redis || exit 1
configure_redis || exit 1
configure_redis_service || exit 1
configure_firewall
start_and_test_redis || exit 1
echo ""
log_success "Redis ${REDIS_VERSION} 安装完成!"
# 显示最终综合摘要
show_final_summary
}
# ----------------------------------------------------------------------------
# 脚本入口点
# ----------------------------------------------------------------------------
# 捕获中断信号
trap 'echo ""; log_warn "安装被用户中断"; exit 1' INT TERM
# 执行主函数
main "$@"
🔍 安装执行过程
🔧 远程访问配置脚本
#!/bin/bash
# =============================================================================
# Redis 远程访问配置脚本
# 系统要求: CentOS 7+
# 作者: XiaoLan
# =============================================================================
# ----------------------------------------------------------------------------
# 全局配置与颜色定义
# ----------------------------------------------------------------------------
# 颜色定义
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly PURPLE='\033[0;35m'
readonly CYAN='\033[0;36m'
readonly WHITE='\033[1;37m'
readonly NC='\033[0m' # No Color
# Redis 配置参数
readonly REDIS_CONF_DIR="/etc/redis"
readonly REDIS_CONF_FILE="${REDIS_CONF_DIR}/redis.conf"
readonly REDIS_SERVICE_NAME="redis"
readonly REDIS_PORT="6379"
readonly BACKUP_DIR="/etc/redis/backup"
# 日志文件
readonly LOG_FILE="/var/log/redis_remote_access.log"
# ----------------------------------------------------------------------------
# 工具函数
# ----------------------------------------------------------------------------
log_info() {
local msg="$1"
echo -e "${CYAN}[INFO]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
log_warn() {
local msg="$1"
echo -e "${YELLOW}[WARN]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
log_error() {
local msg="$1"
echo -e "${RED}[ERROR]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
log_success() {
local msg="$1"
echo -e "${GREEN}[SUCCESS]$(date '+%Y-%m-%d %H:%M:%S')${NC} $msg" | tee -a "$LOG_FILE"
}
print_header() {
clear
echo -e "${BLUE}=========================================${NC}"
echo -e "${BLUE} Redis 远程访问配置脚本 ${NC}"
echo -e "${BLUE} 系统: CentOS 7+ ${NC}"
echo -e "${BLUE} 作者: XiaoLan ${NC}"
echo -e "${BLUE}=========================================${NC}"
echo ""
}
confirm_action() {
local prompt="${1:-是否继续?}"
local response
while true; do
read -p "$(echo -e "${YELLOW}${prompt} [y/n]: ${NC}")" response
case "$response" in
[Yy]|[Yy][Ee][Ss])
return 0
;;
[Nn]|[Nn][Oo])
return 1
;;
*)
echo -e "${RED}请输入 y 或 n${NC}"
;;
esac
done
}
# ----------------------------------------------------------------------------
# 检查函数
# ----------------------------------------------------------------------------
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本必须以 root 权限运行"
exit 1
fi
log_info "权限检查通过"
}
check_redis_installed() {
if [[ ! -f "$REDIS_CONF_FILE" ]]; then
log_error "未找到 Redis 配置文件: $REDIS_CONF_FILE"
log_error "请确保 Redis 已正确安装"
exit 1
fi
log_info "Redis 安装检查通过"
}
check_redis_service() {
if ! systemctl is-active --quiet "$REDIS_SERVICE_NAME"; then
log_warn "Redis 服务未运行，正在启动..."
systemctl start "$REDIS_SERVICE_NAME" || {
log_error "无法启动 Redis 服务"
return 1
}
fi
log_info "Redis 服务状态检查通过"
}
# ----------------------------------------------------------------------------
# 备份配置
# ----------------------------------------------------------------------------
backup_config() {
log_info "备份当前 Redis 配置..."
mkdir -p "$BACKUP_DIR" || {
log_error "无法创建备份目录"
return 1
}
local backup_file="${BACKUP_DIR}/redis.conf.backup.$(date +%Y%m%d_%H%M%S)"
cp "$REDIS_CONF_FILE" "$backup_file" || {
log_error "配置文件备份失败"
return 1
}
log_success "配置已备份到: $backup_file"
echo "$backup_file" # 返回备份文件路径
}
# ----------------------------------------------------------------------------
# 配置远程访问
# ----------------------------------------------------------------------------
configure_remote_access() {
local backup_file="$1"
log_info "开始配置 Redis 远程访问..."
# 显示当前绑定配置
log_info "当前绑定配置:"
grep -E "^bind|^#bind" "$REDIS_CONF_FILE" | tee -a "$LOG_FILE"
echo ""
echo -e "${YELLOW}请选择绑定配置:${NC}"
echo -e "1) ${GREEN}绑定所有接口 (0.0.0.0) - 允许任何IP连接${NC}"
echo -e "2) ${YELLOW}绑定特定IP - 允许指定IP段连接${NC}"
echo -e "3) ${RED}取消操作${NC}"
local choice
while true; do
read -p "$(echo -e "${YELLOW}请选择 [1-3]: ${NC}")" choice
case "$choice" in
1)
configure_bind_all
break
;;
2)
configure_bind_specific
break
;;
3)
log_info "用户取消操作"
exit 0
;;
*)
echo -e "${RED}无效选择，请重新输入${NC}"
;;
esac
done
# 配置保护模式
configure_protected_mode
# 询问是否设置密码
if confirm_action "是否设置 Redis 访问密码?"; then
configure_redis_password
fi
log_success "远程访问配置完成"
}
configure_bind_all() {
log_info "配置 Redis 绑定所有网络接口..."
# 注释掉原有的 bind 配置
sed -i 's/^bind/#bind/' "$REDIS_CONF_FILE"
# 添加新的 bind 配置
if ! grep -q "^bind 0.0.0.0" "$REDIS_CONF_FILE"; then
echo "bind 0.0.0.0" >> "$REDIS_CONF_FILE"
fi
log_success "已配置绑定所有网络接口"
}
configure_bind_specific() {
log_info "配置 Redis 绑定特定IP..."
echo -e "${YELLOW}请输入要绑定的IP地址 (多个IP用空格分隔):${NC}"
echo -e "${CYAN}示例:${NC}"
echo -e " 127.0.0.1 192.168.1.100"
echo -e " 0.0.0.0 (所有接口)"
echo -e " 192.168.1.0/24 (整个网段)"
local bind_ips
read -p "$(echo -e "${YELLOW}绑定IP: ${NC}")" bind_ips
if [[ -z "$bind_ips" ]]; then
log_error "未输入IP地址，使用默认配置"
return 1
fi
# 注释掉原有的 bind 配置
sed -i 's/^bind/#bind/' "$REDIS_CONF_FILE"
# 添加新的 bind 配置
echo "bind $bind_ips" >> "$REDIS_CONF_FILE"
log_success "已配置绑定IP: $bind_ips"
}
configure_protected_mode() {
log_info "配置保护模式..."
# 设置为 no 以允许远程连接
sed -i 's/^protected-mode yes/protected-mode no/' "$REDIS_CONF_FILE"
if ! grep -q "^protected-mode" "$REDIS_CONF_FILE"; then
echo "protected-mode no" >> "$REDIS_CONF_FILE"
fi
log_success "保护模式已禁用"
}
configure_redis_password() {
log_info "设置 Redis 访问密码..."
local password
while true; do
read -s -p "$(echo -e "${YELLOW}请输入 Redis 密码: ${NC}")" password
echo
if [[ -z "$password" ]]; then
echo -e "${RED}密码不能为空，请重新输入${NC}"
continue
fi
read -s -p "$(echo -e "${YELLOW}请确认密码: ${NC}")" password_confirm
echo
if [[ "$password" != "$password_confirm" ]]; then
echo -e "${RED}密码不匹配，请重新输入${NC}"
continue
fi
break
done
# 注释掉原有的密码配置
sed -i 's/^requirepass/#requirepass/' "$REDIS_CONF_FILE"
# 添加新的密码配置
echo "requirepass $password" >> "$REDIS_CONF_FILE"
log_success "Redis 密码已设置"
echo -e "${YELLOW}重要: 请妥善保管密码！${NC}"
}
# ----------------------------------------------------------------------------
# 防火墙配置
# ----------------------------------------------------------------------------
configure_firewall() {
log_info "配置防火墙..."
if systemctl is-active --quiet firewalld; then
if confirm_action "是否在防火墙中开放 Redis 端口 $REDIS_PORT?"; then
firewall-cmd --permanent --add-port=${REDIS_PORT}/tcp >> "$LOG_FILE" 2>&1 && \
firewall-cmd --reload >> "$LOG_FILE" 2>&1 && {
log_success "防火墙端口 $REDIS_PORT 已开放"
} || {
log_error "防火墙配置失败"
return 1
}
else
log_info "跳过防火墙配置"
fi
else
log_warn "Firewalld 未运行，跳过防火墙配置"
fi
}
# ----------------------------------------------------------------------------
# 重启和测试
# ----------------------------------------------------------------------------
restart_and_test_redis() {
log_info "重启 Redis 服务..."
systemctl restart "$REDIS_SERVICE_NAME" >> "$LOG_FILE" 2>&1 || {
log_error "Redis 服务重启失败"
return 1
}
# 等待服务启动
local retry=0
local max_retry=10
while [[ $retry -lt $max_retry ]]; do
if systemctl is-active --quiet "$REDIS_SERVICE_NAME"; then
break
fi
sleep 1
((retry++))
done
if ! systemctl is-active --quiet "$REDIS_SERVICE_NAME"; then
log_error "Redis 服务启动失败，正在恢复备份..."
restore_backup "$backup_file"
return 1
fi
log_success "Redis 服务重启成功"
# 测试连接
test_redis_connection
}
test_redis_connection() {
log_info "测试 Redis 连接..."
# 获取 Redis CLI 路径
local redis_cli
redis_cli=$(which redis-cli 2>/dev/null || echo "/opt/redis/bin/redis-cli")
if ! command -v "$redis_cli" &> /dev/null; then
log_warn "未找到 redis-cli，跳过连接测试"
return 0
fi
# 这里无需测试 配置远程访问 并设置密码后 需要附加密码测试才可以 这里未处理直接注释掉
# if "$redis_cli" -h 127.0.0.1 -p "$REDIS_PORT" ping | grep -q "PONG"; then
# log_success "本地连接测试成功"
# else
# log_error "本地连接测试失败"
# return 1
# fi
# 测试远程连接（如果绑定了其他IP）
# if ip addr show | grep -q "192.168."; then
# local local_ip
# local_ip=$(ip addr show | grep -oP 'inet 192\.168\.\d+\.\d+' | head -1 | awk '{print $2}')
# if [[ -n "$local_ip" ]]; then
# if "$redis_cli" -h "$local_ip" -p "$REDIS_PORT" ping | grep -q "PONG"; then
# log_success "局域网连接测试成功 ($local_ip)"
# else
# log_warn "局域网连接测试失败 ($local_ip)"
# fi
# fi
# fi
}
# ----------------------------------------------------------------------------
# 恢复备份
# ----------------------------------------------------------------------------
restore_backup() {
local backup_file="$1"
if [[ -f "$backup_file" ]]; then
log_info "正在从备份恢复配置..."
cp "$backup_file" "$REDIS_CONF_FILE" && \
systemctl restart "$REDIS_SERVICE_NAME" && {
log_success "配置已从备份恢复: $backup_file"
} || {
log_error "恢复备份失败"
}
else
log_error "备份文件不存在: $backup_file"
fi
}
# ----------------------------------------------------------------------------
# 显示配置摘要
# ----------------------------------------------------------------------------
show_config_summary() {
echo -e "${BLUE}=========================================${NC}"
echo -e "${BLUE} Redis 远程访问配置摘要 ${NC}"
echo -e "${BLUE}=========================================${NC}"
echo -e "\n${PURPLE}当前配置:${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "绑定地址 : ${GREEN}$(grep "^bind" "$REDIS_CONF_FILE" | tail -1)${NC}"
echo -e "保护模式 : ${GREEN}$(grep "^protected-mode" "$REDIS_CONF_FILE" | tail -1)${NC}"
echo -e "服务端口 : ${GREEN}$REDIS_PORT${NC}"
if grep -q "^requirepass" "$REDIS_CONF_FILE"; then
echo -e "密码保护 : ${GREEN}已启用${NC}"
else
echo -e "密码保护 : ${RED}未启用${NC}"
fi
echo -e "\n${PURPLE}连接信息:${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "本地连接 : ${GREEN}redis-cli -h 127.0.0.1 -p $REDIS_PORT${NC}"
local local_ip
local_ip=$(ip addr show | grep -oP 'inet 192\.168\.\d+\.\d+' | head -1 | awk '{print $2}')
if [[ -n "$local_ip" ]]; then
echo -e "局域网连接 : ${GREEN}redis-cli -h $local_ip -p $REDIS_PORT${NC}"
fi
echo -e "\n${PURPLE}安全建议:${NC}"
echo -e "${WHITE}-----------------------------------------${NC}"
echo -e "${YELLOW}● 确保防火墙已正确配置${NC}"
echo -e "${YELLOW}● 使用强密码保护 Redis 实例${NC}"
echo -e "${YELLOW}● 定期监控 Redis 日志${NC}"
echo -e "${YELLOW}● 考虑使用 SSL/TLS 加密连接${NC}"
echo -e "\n${BLUE}=========================================${NC}"
}
# ----------------------------------------------------------------------------
# 主执行流程
# ----------------------------------------------------------------------------
main() {
# 初始化日志
echo "Redis 远程访问配置日志 - $(date)" > "$LOG_FILE"
# 显示横幅
print_header
# 检查前提条件
check_root
check_redis_installed
check_redis_service
# 显示警告信息
echo -e "${YELLOW}⚠️ 安全警告:${NC}"
echo -e "${YELLOW}配置 Redis 远程访问可能会带来安全风险!${NC}"
echo -e "${YELLOW}请确保:${NC}"
echo -e " • 配置强密码认证"
echo -e " • 正确配置防火墙"
echo -e " • 仅允许可信网络访问"
echo ""
if ! confirm_action "您确定要配置 Redis 远程访问吗?"; then
log_info "用户取消操作"
exit 0
fi
# 备份配置
local backup_file
backup_file=$(backup_config) || exit 1
# 配置远程访问
configure_remote_access "$backup_file"
# 配置防火墙
configure_firewall
# 重启并测试
if restart_and_test_redis; then
log_success "Redis 远程访问配置成功完成!"
show_config_summary
else
log_error "配置过程中出现问题"
if confirm_action "是否恢复之前的配置?"; then
restore_backup "$backup_file"
fi
exit 1
fi
}
# ----------------------------------------------------------------------------
# 脚本入口点
# ----------------------------------------------------------------------------
# 捕获中断信号
trap 'echo ""; log_warn "操作被用户中断"; exit 1' INT TERM
# 执行主函数
main "$@"
🔍 远程访问执行过程
🔧 Python数据测试脚本
主要测试以下功能：
1. 多种数据类型测试
字符串、哈希、列表、集合、有序集合
JSON数据、计数器、批量操作
2. 性能测试
批量写入/读取1000条数据
计算操作耗时
3. 实际用例演示
在线商店场景
商品管理、购物车、库存操作
4. 丰富的数据操作
过期时间设置
管道批量操作
键模式搜索
import redis
import logging
import json
import time
from datetime import datetime
# 配置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
def test_redis_connection(host='192.168.198.112', port=6379, password='321321', db=0):
"""
测试 Redis 连接并打印各种情况
"""
logger.info("=" * 50)
logger.info(f"开始连接 Redis: {host}:{port}, db={db}")
logger.info("=" * 50)
try:
# 创建 Redis 连接
logger.info("🔄 创建 Redis 连接...")
r = redis.Redis(
host=host,
port=port,
password=password,
db=db,
decode_responses=True, # 自动解码为字符串
socket_connect_timeout=5,
socket_keepalive=True
)
# 测试连接
logger.info("🔄 发送 PING 命令测试连接...")
result = r.ping()
if result:
logger.info("✅ Redis 连接成功！")
# 获取服务器信息
logger.info("🔄 获取 Redis 服务器信息...")
info = r.info()
logger.info(f"✅ Redis 版本: {info.get('redis_version', '未知')}")
logger.info(f"✅ 运行时间: {info.get('uptime_in_days', '未知')} 天")
logger.info(f"✅ 内存使用: {info.get('used_memory_human', '未知')}")
# 测试基本操作
logger.info("🔄 测试基本数据操作...")
test_key = "connection_test_key"
r.set(test_key, "hello_redis")
value = r.get(test_key)
r.delete(test_key)
if value == "hello_redis":
logger.info("✅ 数据读写测试成功")
else:
logger.warning("⚠️ 数据读写测试异常")
return r
else:
logger.error("❌ PING 命令返回失败")
return None
except redis.ConnectionError as e:
logger.error(f"❌ 连接失败: 无法连接到 {host}:{port}")
logger.error(f" 可能原因: Redis服务未启动/网络不通/端口错误")
logger.error(f" 错误详情: {e}")
except redis.AuthenticationError as e:
logger.error(f"❌ 认证失败: 密码错误或需要认证")
logger.error(f" 当前密码: {'*' * len(password) if password else '未设置'}")
logger.error(f" 错误详情: {e}")
except redis.TimeoutError as e:
logger.error(f"❌ 连接超时: 在 5 秒内未响应")
logger.error(f" 可能原因: 网络延迟/防火墙阻止/服务器负载高")
logger.error(f" 错误详情: {e}")
except redis.ResponseError as e:
logger.error(f"❌ 响应错误: Redis 服务器返回错误")
logger.error(f" 可能原因: 命令不支持/参数错误")
logger.error(f" 错误详情: {e}")
except Exception as e:
logger.error(f"❌ 未知错误: 发生意外错误")
logger.error(f" 错误类型: {type(e).__name__}")
logger.error(f" 错误详情: {e}")
return None
def test_different_scenarios():
"""
测试不同的连接场景
"""
print("\n" + "=" * 60)
print("开始测试不同连接场景")
print("=" * 60)
# 场景1: 正常连接
print("\n1. 测试正常连接:")
test_redis_connection('192.168.198.112', 6379, '321321', 0)
# 场景2: 错误密码
print("\n2. 测试错误密码:")
test_redis_connection('192.168.198.112', 6379, 'wrong_password', 0)
# 场景3: 错误端口
print("\n3. 测试错误端口:")
test_redis_connection('192.168.198.112', 6380, '321321', 0)
# 场景4: 错误主机
print("\n4. 测试错误主机:")
test_redis_connection('192.168.99.99', 6379, '321321', 0)
# 场景5: 本地连接测试
print("\n5. 测试本地连接:")
test_redis_connection('127.0.0.1', 6379, '321321', 0)
def test_data_operations(r):
"""
测试各种数据类型的操作
"""
logger.info("\n" + "🔧" * 50)
logger.info("开始测试各种数据类型操作")
logger.info("🔧" * 50)
# 1. 字符串操作
logger.info("\n📝 测试字符串操作:")
r.set("user:1001:name", "张三")
r.set("user:1001:age", "25")
r.setex("temp:session", 60, "临时会话数据") # 60秒后过期
logger.info(f"✅ 用户姓名: {r.get('user:1001:name')}")
logger.info(f"✅ 用户年龄: {r.get('user:1001:age')}")
logger.info(f"✅ 会话数据: {r.get('temp:session')}")
# 2. 哈希操作
logger.info("\n📊 测试哈希操作:")
user_data = {
"name": "李四",
"age": "30",
"email": "lisi@example.com",
"city": "北京"
}
r.hset("user:1002", mapping=user_data)
user_info = r.hgetall("user:1002")
logger.info(f"✅ 用户信息: {user_info}")
logger.info(f"✅ 用户城市: {r.hget('user:1002', 'city')}")
# 3. 列表操作
logger.info("\n📋 测试列表操作:")
r.delete("news:latest") # 清理旧数据
r.lpush("news:latest", "新闻3", "新闻2", "新闻1")
latest_news = r.lrange("news:latest", 0, 2)
logger.info(f"✅ 最新新闻: {latest_news}")
# 4. 集合操作
logger.info("\n🎯 测试集合操作:")
r.sadd("tags:article:2001", "技术", "编程", "Python", "Redis")
r.sadd("tags:article:2002", "技术", "数据库", "Redis")
tags = r.smembers("tags:article:2001")
common_tags = r.sinter("tags:article:2001", "tags:article:2002")
logger.info(f"✅ 文章标签: {tags}")
logger.info(f"✅ 共同标签: {common_tags}")
# 5. 有序集合操作
logger.info("\n🥇 测试有序集合操作:")
leaderboard = {
"player1": 1500,
"player2": 1800,
"player3": 1200,
"player4": 2000
}
r.zadd("game:leaderboard", leaderboard)
top_players = r.zrevrange("game:leaderboard", 0, 2, withscores=True)
logger.info(f"✅ 排行榜前3: {top_players}")
# 6. JSON数据操作
logger.info("\n📄 测试JSON数据:")
product_data = {
"id": 1001,
"name": "笔记本电脑",
"price": 5999.99,
"stock": 50,
"specs": {"cpu": "i7", "ram": "16GB", "storage": "512GB"},
"tags": ["电脑", "电子产品", "办公"]
}
r.set("product:1001", json.dumps(product_data, ensure_ascii=False))
product_json = r.get("product:1001")
product = json.loads(product_json)
logger.info(f"✅ 商品信息: {product['name']} - ¥{product['price']}")
logger.info(f"✅ 商品规格: {product['specs']}")
# 7. 计数器操作
logger.info("\n🔢 测试计数器操作:")
r.set("page:views:home", 0) # 重置计数器
for i in range(5):
r.incr("page:views:home")
views = r.get("page:views:home")
logger.info(f"✅ 首页访问量: {views}")
# 8. 批量操作
logger.info("\n⚡ 测试批量操作:")
with r.pipeline() as pipe:
pipe.set("config:site_name", "我的网站")
pipe.set("config:theme", "dark")
pipe.set("config:language", "zh-CN")
pipe.execute()
logger.info(f"✅ 站点名称: {r.get('config:site_name')}")
logger.info(f"✅ 主题设置: {r.get('config:theme')}")
# 9. 键操作
logger.info("\n🔑 测试键操作:")
keys = r.keys("user:*")
logger.info(f"✅ 用户键数量: {len(keys)}")
logger.info(f"✅ 用户键列表: {keys}")
# 10. 过期时间操作
logger.info("\n⏰ 测试过期时间:")
r.setex("cache:weather", 10, "晴天 25°C") # 10秒后过期
ttl = r.ttl("cache:weather")
logger.info(f"✅ 天气缓存TTL: {ttl}秒")
def test_performance(r):
"""
测试性能操作
"""
logger.info("\n" + "🚀" * 50)
logger.info("开始性能测试")
logger.info("🚀" * 50)
# 批量写入测试
start_time = time.time()
with r.pipeline() as pipe:
for i in range(1000):
pipe.set(f"perf:key:{i}", f"value_{i}")
pipe.execute()
write_time = time.time() - start_time
logger.info(f"✅ 批量写入1000条数据耗时: {write_time:.3f}秒")
# 批量读取测试
start_time = time.time()
with r.pipeline() as pipe:
for i in range(1000):
pipe.get(f"perf:key:{i}")
results = pipe.execute()
read_time = time.time() - start_time
logger.info(f"✅ 批量读取1000条数据耗时: {read_time:.3f}秒")
logger.info(f"✅ 成功读取数据条数: {len([x for x in results if x])}")
# 清理测试数据
for i in range(1000):
r.delete(f"perf:key:{i}")
class SimpleRedisClient:
"""
简单的 Redis 客户端封装
"""
def __init__(self, host='192.168.198.112', port=6379, password='321321', db=0):
self.connected = False
self.r = None
logger.info(f"初始化 Redis 客户端: {host}:{port}")
try:
self.r = redis.Redis(
host=host,
port=port,
password=password,
db=db,
decode_responses=True,
socket_connect_timeout=5
)
if self.r.ping():
self.connected = True
logger.info("✅ Redis 客户端初始化成功")
else:
logger.error("❌ Redis 客户端初始化失败")
except Exception as e:
logger.error(f"❌ Redis 客户端初始化异常: {e}")
self.connected = False
def set_value(self, key, value):
"""设置值"""
if not self.connected:
logger.error("❌ 连接未就绪，无法执行操作")
return False
try:
self.r.set(key, value)
logger.info(f"✅ 设置 {key} = {value}")
return True
except Exception as e:
logger.error(f"❌ 设置值失败: {e}")
return False
def get_value(self, key):
"""获取值"""
if not self.connected:
logger.error("❌ 连接未就绪，无法执行操作")
return None
try:
value = self.r.get(key)
logger.info(f"✅ 获取 {key} = {value}")
return value
except Exception as e:
logger.error(f"❌ 获取值失败: {e}")
return None
def demo_online_store(self):
"""
演示在线商店用例
"""
if not self.connected:
return
logger.info("\n" + "🛒" * 50)
logger.info("在线商店用例演示")
logger.info("🛒" * 50)
# 商品信息
products = [
{"id": "prod001", "name": "iPhone 15", "price": 6999, "stock": 100},
{"id": "prod002", "name": "MacBook Pro", "price": 12999, "stock": 50},
{"id": "prod003", "name": "AirPods", "price": 1299, "stock": 200}
]
# 存储商品信息
for product in products:
key = f"product:{product['id']}"
self.r.hset(key, mapping=product)
logger.info(f"📦 添加商品: {product['name']}")
# 用户购物车
cart_items = {
"prod001": 2,
"prod003": 1
}
self.r.hset("cart:user123", mapping=cart_items)
logger.info(f"🛒 用户购物车: {cart_items}")
# 查询商品信息
product_info = self.r.hgetall("product:prod001")
logger.info(f"📱 商品详情: {product_info}")
# 模拟购买
self.r.hincrby("product:prod001", "stock", -2)
stock = self.r.hget("product:prod001", "stock")
logger.info(f"💰 购买后库存: {stock}")
if __name__ == "__main__":
# 测试单个连接
print("单个连接测试:")
redis_client = test_redis_connection()
if redis_client:
print("\n🎉 连接测试成功！")
# 测试各种数据操作
test_data_operations(redis_client)
# 测试性能
test_performance(redis_client)
# 使用客户端类
print("\n" + "=" * 60)
print("测试 Redis 客户端类")
print("=" * 60)
client = SimpleRedisClient()
if client.connected:
# 演示在线商店用例
client.demo_online_store()
else:
print("客户端连接失败，无法执行操作")
else:
print("\n💥 连接测试失败！")
# 测试不同场景（可选）
# test_different_scenarios()
🔍 Python执行过程
E:\ProjectCode\00-Python\.venv\Scripts\python.exe E:\ProjectCode\00-Python\Python_Project\10-Redis\RedisDataGenerator.py
2025-10-19 21:33:07,585 - INFO - ==================================================
2025-10-19 21:33:07,585 - INFO - 开始连接 Redis: 192.168.198.112:6379, db=0
2025-10-19 21:33:07,585 - INFO - ==================================================
2025-10-19 21:33:07,585 - INFO - 🔄 创建 Redis 连接...
2025-10-19 21:33:07,585 - INFO - 🔄 发送 PING 命令测试连接...
单个连接测试:
2025-10-19 21:33:07,620 - INFO - ✅ Redis 连接成功！
2025-10-19 21:33:07,620 - INFO - 🔄 获取 Redis 服务器信息...
🎉 连接测试成功！
2025-10-19 21:33:07,623 - INFO - ✅ Redis 版本: 6.2.7
2025-10-19 21:33:07,623 - INFO - ✅ 运行时间: 0 天
2025-10-19 21:33:07,623 - INFO - ✅ 内存使用: 603.96K
2025-10-19 21:33:07,623 - INFO - 🔄 测试基本数据操作...
2025-10-19 21:33:07,631 - INFO - ✅ 数据读写测试成功
2025-10-19 21:33:07,631 - INFO -
🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧
2025-10-19 21:33:07,631 - INFO - 开始测试各种数据类型操作
2025-10-19 21:33:07,631 - INFO - 🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧🔧
2025-10-19 21:33:07,631 - INFO -
📝 测试字符串操作:
2025-10-19 21:33:07,645 - INFO - ✅ 用户姓名: 张三
2025-10-19 21:33:07,649 - INFO - ✅ 用户年龄: 25
2025-10-19 21:33:07,652 - INFO - ✅ 会话数据: 临时会话数据
2025-10-19 21:33:07,652 - INFO -
📊 测试哈希操作:
2025-10-19 21:33:07,653 - INFO - ✅ 用户信息: {'name': '李四', 'age': '30', 'email': 'lisi@example.com', 'city': '北京'}
2025-10-19 21:33:07,654 - INFO - ✅ 用户城市: 北京
2025-10-19 21:33:07,654 - INFO -
📋 测试列表操作:
2025-10-19 21:33:07,656 - INFO - ✅ 最新新闻: ['新闻1', '新闻2', '新闻3']
2025-10-19 21:33:07,656 - INFO -
🎯 测试集合操作:
2025-10-19 21:33:07,657 - INFO - ✅ 文章标签: {'Redis', '编程', 'Python', '技术'}
2025-10-19 21:33:07,657 - INFO - ✅ 共同标签: {'Redis', '技术'}
2025-10-19 21:33:07,657 - INFO -
🥇 测试有序集合操作:
2025-10-19 21:33:07,663 - INFO - ✅ 排行榜前3: [('player4', 2000.0), ('player2', 1800.0), ('player1', 1500.0)]
2025-10-19 21:33:07,663 - INFO -
📄 测试JSON数据:
2025-10-19 21:33:07,669 - INFO - ✅ 商品信息: 笔记本电脑 - ¥5999.99
2025-10-19 21:33:07,669 - INFO - ✅ 商品规格: {'cpu': 'i7', 'ram': '16GB', 'storage': '512GB'}
2025-10-19 21:33:07,669 - INFO -
🔢 测试计数器操作:
2025-10-19 21:33:07,687 - INFO - ✅ 首页访问量: 5
2025-10-19 21:33:07,687 - INFO -
⚡ 测试批量操作:
2025-10-19 21:33:07,691 - INFO - ✅ 站点名称: 我的网站
2025-10-19 21:33:07,695 - INFO - ✅ 主题设置: dark
2025-10-19 21:33:07,695 - INFO -
🔑 测试键操作:
2025-10-19 21:33:07,699 - INFO - ✅ 用户键数量: 3
2025-10-19 21:33:07,699 - INFO - ✅ 用户键列表: ['user:1002', 'user:1001:age', 'user:1001:name']
2025-10-19 21:33:07,699 - INFO -
⏰ 测试过期时间:
2025-10-19 21:33:07,702 - INFO - ✅ 天气缓存TTL: 10秒
2025-10-19 21:33:07,702 - INFO -
🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀
2025-10-19 21:33:07,702 - INFO - 开始性能测试
2025-10-19 21:33:07,702 - INFO - 🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀
2025-10-19 21:33:07,711 - INFO - ✅ 批量写入1000条数据耗时: 0.010秒
2025-10-19 21:33:07,719 - INFO - ✅ 批量读取1000条数据耗时: 0.008秒
2025-10-19 21:33:07,719 - INFO - ✅ 成功读取数据条数: 1000
2025-10-19 21:33:08,684 - INFO - 初始化 Redis 客户端: 192.168.198.112:6379
============================================================
测试 Redis 客户端类
============================================================
2025-10-19 21:33:08,707 - INFO - ✅ Redis 客户端初始化成功
2025-10-19 21:33:08,707 - INFO -
🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒
2025-10-19 21:33:08,707 - INFO - 在线商店用例演示
2025-10-19 21:33:08,707 - INFO - 🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒🛒
2025-10-19 21:33:08,711 - INFO - 📦 添加商品: iPhone 15
2025-10-19 21:33:08,715 - INFO - 📦 添加商品: MacBook Pro
2025-10-19 21:33:08,716 - INFO - 📦 添加商品: AirPods
2025-10-19 21:33:08,719 - INFO - 🛒 用户购物车: {'prod001': 2, 'prod003': 1}
2025-10-19 21:33:08,720 - INFO - 📱 商品详情: {'id': 'prod001', 'name': 'iPhone 15', 'price': '6999', 'stock': '100'}
2025-10-19 21:33:08,722 - INFO - 💰 购买后库存: 98
Process finished with exit code 0
🚀 快速安装方式
方法1：一键脚本安装
# 下载脚本
wget -O install-redis.sh https://raw.githubusercontent.com/example/install-redis/master/install-redis.sh
# 添加执行权限
chmod +x install-redis.sh
# 运行安装
sudo ./install-redis.sh
方法2：各系统快速安装
# Ubuntu/Debian
sudo apt update && sudo apt install -y redis-server redis-tools
sudo systemctl enable redis-server && sudo systemctl start redis-server
# CentOS/RHEL/Amazon Linux
sudo yum install -y epel-release
sudo yum install -y redis
sudo systemctl enable redis && sudo systemctl start redis
# 检查状态
redis-cli ping
⚙️ 常用管理命令
#查看Redis服务进行
ps -ef | grep redis
# 服务管理
sudo systemctl start redis # 启动
sudo systemctl stop redis # 停止
sudo systemctl restart redis # 重启
sudo systemctl status redis # 查看状态
sudo systemctl enable redis # 设置开机自启
# Redis CLI 操作
redis-cli -h 127.0.0.1 -p 6379 -a <password> # 连接Redis
redis-cli ping # 测试连接
redis-cli info # 查看信息
redis-cli info memory # 查看内存信息
redis-cli info clients # 查看客户端信息
redis-cli monitor # 监控命令
# 数据操作
redis-cli set key "value" # 设置键值
redis-cli get key # 获取值
redis-cli keys "*" # 查看所有键
redis-cli flushdb # 清空当前数据库
redis-cli flushall # 清空所有数据库
# 删除
INSTALL_DIR="/usr/local/redis"
DATA_DIR="/var/lib/redis"
LOG_DIR="/var/log/redis"
sudo find / -name "*redis*" # 查找Redis所有相关文件
sudo rm -rf /usr/local/redis # 删除Redis安装目录
sudo rm -rf /var/lib/redis # 删除Redis数据目录
sudo rm -rf /etc/redis # 删除Redis配置文件
sudo rm -rf /var/log/redis # 删除Redis日志目录
📁 重要目录和文件
/usr/local/redis/ # Redis安装目录
├── bin/ # 二进制文件
│ ├── redis-server # 服务器
│ ├── redis-cli # 命令行客户端
│ └── redis-benchmark # 性能测试工具
├── etc/redis.conf # 主配置文件
/var/lib/redis/ # 数据目录
/var/log/redis/ # 日志目录
/etc/systemd/system/redis.service # 服务文件
🔧 常用配置修改
修改监听地址和端口
sudo vi /usr/local/redis/etc/redis.conf
# 修改 bind 和 port 配置
配置内存策略
# 在配置文件中修改
maxmemory 2gb
maxmemory-policy allkeys-lru
启用AOF持久化
appendonly yes
appendfsync everysec
配置主从复制
在从节点配置文件中添加：
replicaof <master-ip> <master-port>
masterauth <master-password>
🔍 安装验证和测试
# 检查服务状态
sudo systemctl status redis
# 检查端口监听
netstat -tulpn | grep 6379
ss -tulpn | grep 6379
# 测试连接
redis-cli -h 127.0.0.1 -p 6379 -a <password> ping
# 性能测试
redis-benchmark -h 127.0.0.1 -p 6379 -a <password> -q -n 100000
# 查看统计信息
redis-cli -h 127.0.0.1 -p 6379 -a <password> info
# 创建测试数据
for i in {1..1000}; do
redis-cli -h 127.0.0.1 -p 6379 -a <password> set "key:$i" "value:$i"
done
🔍 客户端连接测试
这个脚本提供了完整的Redis安装方案，包括安全配置、性能优化和集群支持，适合生产环境使用！
扫一扫
540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
