Redis环境搭建指南：Windows/Linux/Docker多场景安装与配置

Redis环境搭建指南：Windows/Linux/Docker多场景安装与配置

1. Redis安装方式概览

1.1 安装方式对比

安装方式	适用场景	优点	缺点	难度
Windows直接安装	开发调试	安装简单，Windows兼容好	性能不如Linux，生产不推荐	⭐
Linux源码编译	生产环境	性能最佳，可定制编译参数	编译时间长，依赖管理复杂	⭐⭐⭐
Linux包管理器	快速部署	安装快速，依赖自动处理	版本可能不是最新	⭐⭐
Docker容器	开发/测试/生产	环境隔离，部署一致性好	需要Docker知识	⭐⭐

1.2 版本选择建议

Redis版本发布时间线：

• Redis 6.0 (2020年) - 引入多线程I/O、ACL安全
• Redis 6.2 (2021年) - 稳定版本，推荐生产使用
• Redis 7.0 (2022年) - 最新功能，Functions支持
• Redis 7.2 (2023年) - 当前最新稳定版

选择建议：

• 生产环境：Redis 6.2.x (稳定可靠)
• 新项目：Redis 7.0.x (新特性丰富)
• 学习测试：Redis 7.2.x (最新版本)

---

2. Windows环境安装Redis

2.1 MSI安装包安装

下载地址：

# GitHub下载地址
https://github.com/MicrosoftArchive/redis/releases
# 推荐版本：Redis 3.2.100 for Windows

安装步骤：

1. 下载redis-x64-3.2.100.msi文件
2. 双击运行安装程序
3. 选择安装路径（默认：C:\Program Files\Redis\）
4. 勾选环境变量和服务选项
5. 完成安装

验证安装：

# 检查版本
redis-server --version

# 启动服务
redis-server

# 新窗口连接测试
redis-cli
127.0.0.1:6379> ping
PONG

2.2 Windows服务管理

注册为Windows服务：

# 管理员身份运行
cd "C:\Program Files\Redis"

# 安装服务
redis-server --service-install redis.windows.conf

# 启动服务
redis-server --service-start

# 停止服务
redis-server --service-stop

2.3 Windows配置文件

关键配置：

# 网络配置
bind 127.0.0.1
port 6379

# 安全配置
requirepass yourpassword

# 内存配置
maxmemory 256mb
maxmemory-policy allkeys-lru

# 持久化配置
save 900 1
save 300 10
save 60 10000
appendonly yes

---

3. Linux环境安装Redis

3.1 包管理器安装

3.1.1 Ubuntu/Debian系统

# 更新包列表
sudo apt update

# 安装Redis
sudo apt install redis-server

# 启动并设置自启
sudo systemctl start redis-server
sudo systemctl enable redis-server

# 验证安装
redis-cli ping

3.1.2 CentOS/RHEL系统

# CentOS 7
sudo yum install epel-release
sudo yum install redis

# CentOS 8/Rocky Linux
sudo dnf install redis

# 启动服务
sudo systemctl start redis
sudo systemctl enable redis

3.2 源码编译安装

3.2.1 环境准备

# Ubuntu/Debian依赖
sudo apt update
sudo apt install build-essential tcl wget

# CentOS/RHEL依赖
sudo yum groupinstall "Development Tools"
sudo yum install tcl wget

3.2.2 编译安装

# 下载源码
cd /opt
sudo wget https://download.redis.io/redis-stable.tar.gz
sudo tar xzf redis-stable.tar.gz
cd redis-stable

# 编译安装
sudo make
sudo make install

# 创建目录和用户
sudo mkdir -p /etc/redis /var/lib/redis /var/log/redis
sudo useradd --system --home /var/lib/redis --shell /bin/false redis
sudo chown redis:redis /var/lib/redis /var/log/redis

# 复制配置文件
sudo cp redis.conf /etc/redis/redis.conf

3.2.3 系统服务配置

创建systemd服务文件/etc/systemd/system/redis.service：

[Unit]
Description=Redis In-Memory Data Store
After=network.target

[Service]
User=redis
Group=redis
ExecStart=/usr/local/bin/redis-server /etc/redis/redis.conf
ExecStop=/usr/local/bin/redis-cli shutdown
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

3.3 系统参数优化

# 内核参数优化
cat >> /etc/sysctl.conf << EOF
vm.overcommit_memory = 1
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
EOF

# 应用配置
sudo sysctl -p

# 禁用透明大页
echo never > /sys/kernel/mm/transparent_hugepage/enabled

---

4. Docker容器化部署Redis

4.1 单机Redis部署

4.1.1 基础部署

# 拉取镜像
docker pull redis:7.2-alpine

# 简单运行
docker run -d --name redis -p 6379:6379 redis:7.2-alpine

4.1.2 带配置文件部署

创建配置：

mkdir -p /opt/redis/{conf,data,logs}

cat > /opt/redis/conf/redis.conf << 'EOF'
bind 0.0.0.0
port 6379
protected-mode no
daemonize no
dir /data
save 900 1
save 300 10
save 60 10000
appendonly yes
maxmemory 1gb
maxmemory-policy allkeys-lru
requirepass redis123456
EOF

运行容器：

docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /opt/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  -v /opt/redis/data:/data \
  redis:7.2-alpine \
  redis-server /usr/local/etc/redis/redis.conf

4.1.3 Docker Compose部署

创建docker-compose.yml：

version: '3.8'

services:
  redis:
    image: redis:7.2-alpine
    container_name: redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - ./conf/redis.conf:/usr/local/etc/redis/redis.conf
      - redis_data:/data
    command: redis-server /usr/local/etc/redis/redis.conf
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  redis_data:

---

5. Redis配置文件详解

5.1 核心配置项

配置项	说明	推荐值	示例
bind	绑定IP地址	内网IP	bind 127.0.0.1
port	监听端口	6379	port 6379
requirepass	访问密码	强密码	requirepass Complex123!
maxmemory	最大内存	系统内存70%	maxmemory 2gb
maxmemory-policy	淘汰策略	allkeys-lru	maxmemory-policy allkeys-lru

5.2 持久化配置

5.2.1 RDB配置

# RDB快照触发条件
save 900 1      # 15分钟内至少1个键变化
save 300 10     # 5分钟内至少10个键变化  
save 60 10000   # 1分钟内至少10000个键变化

# RDB文件配置
dbfilename dump.rdb
dir /var/lib/redis
rdbcompression yes
rdbchecksum yes

5.2.2 AOF配置

# AOF基础配置
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec    # 推荐：每秒同步

# AOF重写配置
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 混合持久化（Redis 4.0+）
aof-use-rdb-preamble yes

5.3 安全配置

# 访问控制
requirepass "your_strong_password_123!"
protected-mode yes

# 命令重命名（禁用危险命令）
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command CONFIG "CONFIG_SECURE_2023"

# 连接限制
maxclients 10000
timeout 300

---

6. Java应用连接Redis

6.1 Spring Boot集成

6.1.1 Maven依赖

<dependencies>
    <!-- Spring Boot Redis Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- 连接池支持 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
</dependencies>

6.1.2 应用配置

application.yml：

spring:
  redis:
    host: localhost
    port: 6379
    password: redis123456
    database: 0
    timeout: 3000ms
    
    # 连接池配置
    lettuce:
      pool:
        max-active: 200
        max-wait: -1ms
        max-idle: 50
        min-idle: 10

6.1.3 配置类

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // JSON序列化配置
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = 
            new Jackson2JsonRedisSerializer<>(Object.class);
        
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 序列化配置
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        
        template.afterPropertiesSet();
        return template;
    }
}

6.2 Redis工具类

@Component
@Slf4j
public class RedisUtil {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 设置缓存
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                redisTemplate.opsForValue().set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error("Redis set error", e);
            return false;
        }
    }
    
    /**
     * 获取缓存
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    
    /**
     * 删除缓存
     */
    public boolean delete(String key) {
        try {
            return Boolean.TRUE.equals(redisTemplate.delete(key));
        } catch (Exception e) {
            log.error("Redis delete error", e);
            return false;
        }
    }
    
    /**
     * 设置过期时间
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                return Boolean.TRUE.equals(redisTemplate.expire(key, time, TimeUnit.SECONDS));
            }
            return false;
        } catch (Exception e) {
            log.error("Redis expire error", e);
            return false;
        }
    }
    
    /**
     * 判断key是否存在
     */
    public boolean hasKey(String key) {
        try {
            return Boolean.TRUE.equals(redisTemplate.hasKey(key));
        } catch (Exception e) {
            log.error("Redis hasKey error", e);
            return false;
        }
    }
    
    /**
     * 递增
     */
    public long increment(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        Long result = redisTemplate.opsForValue().increment(key, delta);
        return result != null ? result : 0;
    }
    
    /**
     * Hash获取
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }
    
    /**
     * Hash设置
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            log.error("Redis hset error", e);
            return false;
        }
    }
    
    /**
     * 获取List内容
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            log.error("Redis lGet error", e);
            return null;
        }
    }
    
    /**
     * List右侧插入
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            log.error("Redis lSet error", e);
            return false;
        }
    }
}

---

7. 生产环境部署建议

7.1 硬件配置建议

配置项	最低配置	推荐配置	高性能配置
CPU	2核心	4核心	8核心+
内存	4GB	16GB	64GB+
存储	普通SSD	高速SSD	NVMe SSD
网络	100Mbps	1Gbps	10Gbps

7.2 操作系统优化

# 关闭透明大页
echo never > /sys/kernel/mm/transparent_hugepage/enabled

# 调整内核参数
cat >> /etc/sysctl.conf << EOF
vm.overcommit_memory = 1
net.core.somaxconn = 65535
vm.swappiness = 1
EOF

# 应用配置
sysctl -p

# 调整文件描述符限制
echo "redis soft nofile 65535" >> /etc/security/limits.conf
echo "redis hard nofile 65535" >> /etc/security/limits.conf

7.3 部署架构建议

单机部署：

• 适用：开发环境、小型应用
• 配置：4核8G、SSD存储
• 注意：做好数据备份

主从部署：

• 适用：中小型应用
• 配置：主库4核8G，从库2核4G
• 注意：读写分离、故障切换

集群部署：

• 适用：大型应用、海量数据
• 配置：至少6个节点（3主3从）
• 注意：数据分片、扩容规划

---

8. 常见问题及解决方案

8.1 连接问题

问题1：连接被拒绝

# 解决方案
1. 检查Redis服务状态
   systemctl status redis
   
2. 检查端口监听
   netstat -tlnp | grep 6379
   
3. 检查bind配置
   bind 0.0.0.0  # 允许远程连接

问题2：认证失败

# 解决方案
1. 检查密码配置
   redis-cli -a password ping
   
2. Java代码设置密码
   spring.redis.password=your_password

8.2 性能问题

问题3：响应慢

# 排查步骤
1. 检查慢查询日志
   redis-cli slowlog get 10
   
2. 检查内存使用
   redis-cli info memory
   
3. 检查网络延迟
   redis-cli --latency

问题4：内存不足

# 解决方案
1. 增加内存限制
   config set maxmemory 4gb
   
2. 设置淘汰策略
   config set maxmemory-policy allkeys-lru
   
3. 清理无用数据
   redis-cli --scan --pattern "temp:*" | xargs redis-cli del

8.3 数据持久化问题

问题5：RDB备份失败

# 解决方案
1. 检查磁盘空间
   df -h
   
2. 检查权限
   chown redis:redis /var/lib/redis
   
3. 检查内存配置
   echo 1 > /proc/sys/vm/overcommit_memory

问题6：AOF文件损坏

# 解决方案
1. 修复AOF文件
   redis-check-aof --fix appendonly.aof
   
2. 重启Redis服务
   systemctl restart redis

---

总结

本文全面介绍了Redis在各种环境下的安装配置方法：

主要内容回顾

1. 多平台安装：Windows MSI安装、Linux包管理器和源码编译、Docker容器化部署
2. 配置优化：网络、持久化、内存、安全等核心配置项详解
3. Java集成：Spring Boot完整配置示例和实用工具类封装
4. 运维实践：硬件配置建议、系统优化、部署架构选择
5. 问题排查：常见问题的诊断步骤和解决方案

关键要点

• 开发环境：推荐Docker部署，快速启动，环境隔离
• 测试环境：使用包管理器安装，配置简单，易于管理
• 生产环境：源码编译安装，性能最优，安全可控
• 配置管理：版本控制，自动化部署，监控告警

最佳实践建议

1. 安全第一：设置强密码，禁用危险命令，限制网络访问
2. 性能优化：合理配置内存，选择适当的持久化策略
3. 监控告警：建立完善的监控体系，及时发现问题
4. 备份恢复：定期备份数据，测试恢复流程
5. 容量规划：根据业务增长预估资源需求

通过本文的学习，你应该能够在任何环境下成功部署Redis，并进行合理的配置优化。接下来我们将学习Redis的基础命令操作。

---

下一篇预告 ：《Redis基础命令速查：从连接到数据操作，新手也能上手》

---