Docker 部署 Redis：小白一键安装、配置与迁移教程

无名-CODING2026-03-30 9:39

🎯 本文适合人群 ：Docker 初学者、运维工程师、后端开发

⏱️ 阅读时长 ：30分钟

📌 你将收获：掌握 Docker 部署 Redis 单机、主从、哨兵、集群的完整流程

📖 目录

一、为什么用 Docker 部署 Redis

1.1 传统部署 vs Docker 部署

复制代码 
┌──────────────────────────────────────────────────┐
│              传统部署 vs Docker 部署               │
├──────────────────────────────────────────────────┤
│                                                  │
│  传统部署：                                       │
│    1. 下载源码 → 编译 → 安装 → 配置 → 启动        │
│    2. 依赖管理复杂（gcc、make、系统库）           │
│    3. 不同环境配置不一致                          │
│    4. 升级/回滚困难                               │
│    5. 多实例部署繁琐                              │
│                                                  │
│  Docker 部署：                                    │
│    1. docker run 一条命令启动 ✅                  │
│    2. 无依赖问题（镜像自带）                      │
│    3. 环境一致（开发=测试=生产）                  │
│    4. 秒级升级/回滚                               │
│    5. 轻松部署多实例                              │
│                                                  │
└──────────────────────────────────────────────────┘

1.2 Docker 部署的优势

优势 说明 示例
环境隔离 每个容器独立运行 同一台服务器运行多个 Redis 版本
快速部署 拉取镜像即可运行 docker run -d redis
资源限制 限制 CPU/内存 --memory=2g --cpus=2
易于迁移 镜像可在任何环境运行 开发 → 测试 → 生产
版本管理 随时切换版本 redis:7.0 ↔ redis:6.2
一键清理 删除容器即可 docker rm -f redis

二、Docker 环境准备

2.1 安装 Docker（CentOS 7）

bash 复制代码 
# 1. 卸载旧版本
sudo yum remove -y docker docker-common docker-selinux docker-engine

# 2. 安装依赖
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# 3. 添加 Docker 官方仓库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 国内用户推荐使用阿里云镜像
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 4. 安装 Docker
sudo yum install -y docker-ce docker-ce-cli containerd.io

# 5. 启动 Docker
sudo systemctl start docker
sudo systemctl enable docker

# 6. 验证安装
docker --version
# Docker version 24.0.7, build afdd53b

docker run hello-world
# Hello from Docker! ✅

2.2 配置 Docker 镜像加速

bash 复制代码 
# 创建配置文件
sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://mirror.ccs.tencentyun.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  }
}
EOF

# 重启 Docker
sudo systemctl daemon-reload
sudo systemctl restart docker

# 验证配置
docker info | grep -A 5 "Registry Mirrors"

2.3 安装 Docker Compose

bash 复制代码 
# 方式 1：官方脚本（推荐）
sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 国内镜像
sudo curl -L "https://get.daocloud.io/docker/compose/releases/download/v2.24.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 添加执行权限
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker-compose --version
# Docker Compose version v2.24.0 ✅

三、单机 Redis 部署

3.1 快速启动（最简单）

bash 复制代码 
# 1. 拉取 Redis 镜像（最新版本）
docker pull redis

# 2. 启动 Redis 容器
docker run -d \
  --name redis \
  -p 6379:6379 \
  redis

# 3. 验证运行
docker ps
# CONTAINER ID   IMAGE   COMMAND                  STATUS
# a1b2c3d4e5f6   redis   "docker-entrypoint.s..."   Up 10 seconds

# 4. 连接 Redis
docker exec -it redis redis-cli
127.0.0.1:6379> PING
PONG  # ✅ 成功

参数说明：

  • -d：后台运行
  • --name redis：容器名称
  • -p 6379:6379：端口映射（宿主机:容器）

3.2 持久化部署（推荐）

bash 复制代码 
# 1. 创建数据目录
mkdir -p /data/redis/{data,conf,logs}

# 2. 下载 Redis 配置文件
wget https://raw.githubusercontent.com/redis/redis/7.0/redis.conf -O /data/redis/conf/redis.conf

# 3. 修改配置文件
vim /data/redis/conf/redis.conf

关键配置修改：

bash 复制代码 
# ========== 网络配置 ==========
bind 0.0.0.0                  # 允许所有 IP 访问
protected-mode no             # 关闭保护模式（或设置密码）

# ========== 密码配置 ==========
requirepass your_password_123  # 设置密码

# ========== 持久化配置 ==========
appendonly yes                # 开启 AOF
appendfsync everysec          # 每秒同步

save 900 1                    # RDB 快照
save 300 10
save 60 10000

# ========== 日志配置 ==========
logfile "/data/redis/logs/redis.log"

# ========== 数据目录 ==========
dir /data/redis
bash 复制代码 
# 4. 启动容器（挂载数据卷）
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /data/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  -v /data/redis/data:/data \
  -v /data/redis/logs:/data/redis/logs \
  --restart=always \
  redis redis-server /usr/local/etc/redis/redis.conf

# 5. 验证持久化
docker exec -it redis redis-cli -a your_password_123
127.0.0.1:6379> SET test "hello"
OK

# 6. 检查数据文件
ls -lh /data/redis/data/
# appendonly.aof  dump.rdb  ✅

参数说明：

  • -v：挂载数据卷（宿主机:容器）
  • --restart=always：自动重启
  • redis-server /usr/local/etc/redis/redis.conf：使用自定义配置

3.3 资源限制（生产环境推荐）

bash 复制代码 
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /data/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  -v /data/redis/data:/data \
  --memory=2g \
  --memory-swap=2g \
  --cpus=2 \
  --restart=always \
  redis redis-server /usr/local/etc/redis/redis.conf

参数说明：

  • --memory=2g：限制内存 2GB
  • --memory-swap=2g：禁用 swap
  • --cpus=2：限制 CPU 核心数

四、Docker Compose 部署

4.1 单机部署

目录结构：

复制代码 
/data/redis/
├── docker-compose.yml
├── conf/
│   └── redis.conf
├── data/
└── logs/

docker-compose.yml：

yaml 复制代码 
version: '3.8'

services:
  redis:
    image: redis:7.0
    container_name: redis
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "6379:6379"
    volumes:
      - ./conf/redis.conf:/usr/local/etc/redis/redis.conf
      - ./data:/data
      - ./logs:/data/redis/logs
    environment:
      - TZ=Asia/Shanghai
    networks:
      - redis-network
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
        reservations:
          cpus: '1'
          memory: 1G

networks:
  redis-network:
    driver: bridge

启动服务：

bash 复制代码 
# 进入目录
cd /data/redis

# 启动
docker-compose up -d

# 查看日志
docker-compose logs -f redis

# 停止
docker-compose down

# 重启
docker-compose restart

4.2 多实例部署

docker-compose.yml（三个 Redis 实例）：

yaml 复制代码 
version: '3.8'

services:
  redis-6379:
    image: redis:7.0
    container_name: redis-6379
    restart: always
    command: redis-server --port 6379 --requirepass pass123
    ports:
      - "6379:6379"
    volumes:
      - ./data/redis-6379:/data
    networks:
      - redis-network

  redis-6380:
    image: redis:7.0
    container_name: redis-6380
    restart: always
    command: redis-server --port 6380 --requirepass pass123
    ports:
      - "6380:6380"
    volumes:
      - ./data/redis-6380:/data
    networks:
      - redis-network

  redis-6381:
    image: redis:7.0
    container_name: redis-6381
    restart: always
    command: redis-server --port 6381 --requirepass pass123
    ports:
      - "6381:6381"
    volumes:
      - ./data/redis-6381:/data
    networks:
      - redis-network

networks:
  redis-network:
    driver: bridge
bash 复制代码 
# 启动
docker-compose up -d

# 查看
docker ps | grep redis
# redis-6379  ✅
# redis-6380  ✅
# redis-6381  ✅

五、主从复制部署

5.1 架构图

复制代码 
┌──────────────────────────────────────┐
│         Redis 主从复制架构            │
├──────────────────────────────────────┤
│                                      │
│         Master（主）6379              │
│            ↓ 数据同步                 │
│       ┌────┴────┐                    │
│       ↓         ↓                    │
│  Slave1 6380  Slave2 6381            │
│   （从）       （从）                 │
│                                      │
│  写入：只能写 Master                  │
│  读取：Master + Slave（读写分离）      │
│                                      │
└──────────────────────────────────────┘

5.2 Docker Compose 配置

目录结构：

复制代码 
/data/redis-replication/
├── docker-compose.yml
├── master/
│   ├── redis.conf
│   └── data/
├── slave1/
│   ├── redis.conf
│   └── data/
└── slave2/
    ├── redis.conf
    └── data/

master/redis.conf：

bash 复制代码 
bind 0.0.0.0
port 6379
requirepass master_password_123
masterauth master_password_123  # 从节点连接主节点的密码

appendonly yes
appendfsync everysec

slave1/redis.conf：

bash 复制代码 
bind 0.0.0.0
port 6380
requirepass slave_password_123
masterauth master_password_123  # 连接主节点的密码

# 指定主节点
replicaof redis-master 6379

# 从节点只读
replica-read-only yes

appendonly yes
appendfsync everysec

slave2/redis.conf（同 slave1，端口改为 6381）

docker-compose.yml：

yaml 复制代码 
version: '3.8'

services:
  redis-master:
    image: redis:7.0
    container_name: redis-master
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "6379:6379"
    volumes:
      - ./master/redis.conf:/usr/local/etc/redis/redis.conf
      - ./master/data:/data
    networks:
      - redis-replication

  redis-slave1:
    image: redis:7.0
    container_name: redis-slave1
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "6380:6380"
    volumes:
      - ./slave1/redis.conf:/usr/local/etc/redis/redis.conf
      - ./slave1/data:/data
    depends_on:
      - redis-master
    networks:
      - redis-replication

  redis-slave2:
    image: redis:7.0
    container_name: redis-slave2
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "6381:6381"
    volumes:
      - ./slave2/redis.conf:/usr/local/etc/redis/redis.conf
      - ./slave2/data:/data
    depends_on:
      - redis-master
    networks:
      - redis-replication

networks:
  redis-replication:
    driver: bridge

5.3 启动与验证

bash 复制代码 
# 启动
docker-compose up -d

# 查看主节点信息
docker exec -it redis-master redis-cli -a master_password_123
127.0.0.1:6379> INFO replication
# Replication
role:master
connected_slaves:2
slave0:ip=172.18.0.3,port=6380,state=online
slave1:ip=172.18.0.4,port=6381,state=online

# 测试主从同步
127.0.0.1:6379> SET name "张三"
OK

# 在从节点验证
docker exec -it redis-slave1 redis-cli -p 6380 -a slave_password_123
127.0.0.1:6380> GET name
"张三"  # ✅ 同步成功

# 从节点无法写入
127.0.0.1:6380> SET age 25
(error) READONLY You can't write against a read only replica.

六、哨兵模式部署

6.1 架构图

复制代码 
┌──────────────────────────────────────────────┐
│           Redis 哨兵模式架构                  │
├──────────────────────────────────────────────┤
│                                              │
│  Sentinel1   Sentinel2   Sentinel3           │
│     ↓           ↓           ↓                │
│  监控 Master 和 Slave                         │
│     ↓                                        │
│  Master 宕机 → 自动故障转移                   │
│     ↓                                        │
│  选举一个 Slave 成为新 Master                 │
│                                              │
└──────────────────────────────────────────────┘

6.2 Docker Compose 配置

目录结构：

复制代码 
/data/redis-sentinel/
├── docker-compose.yml
├── master/
│   └── redis.conf
├── slave1/
│   └── redis.conf
├── slave2/
│   └── redis.conf
├── sentinel1/
│   └── sentinel.conf
├── sentinel2/
│   └── sentinel.conf
└── sentinel3/
    └── sentinel.conf

sentinel1/sentinel.conf：

bash 复制代码 
port 26379

# 监控主节点
# sentinel monitor <master-name> <ip> <port> <quorum>
sentinel monitor mymaster redis-master 6379 2
sentinel auth-pass mymaster master_password_123

# 主节点无响应超时时间（毫秒）
sentinel down-after-milliseconds mymaster 5000

# 故障转移超时时间
sentinel failover-timeout mymaster 10000

# 同时进行同步的从节点数量
sentinel parallel-syncs mymaster 1

sentinel2/sentinel.conf （端口改为 26380）
sentinel3/sentinel.conf（端口改为 26381）

docker-compose.yml：

yaml 复制代码 
version: '3.8'

services:
  redis-master:
    image: redis:7.0
    container_name: redis-master
    restart: always
    command: redis-server --requirepass master_password_123 --masterauth master_password_123
    ports:
      - "6379:6379"
    networks:
      - redis-sentinel

  redis-slave1:
    image: redis:7.0
    container_name: redis-slave1
    restart: always
    command: redis-server --replicaof redis-master 6379 --requirepass slave_password_123 --masterauth master_password_123
    ports:
      - "6380:6379"
    depends_on:
      - redis-master
    networks:
      - redis-sentinel

  redis-slave2:
    image: redis:7.0
    container_name: redis-slave2
    restart: always
    command: redis-server --replicaof redis-master 6379 --requirepass slave_password_123 --masterauth master_password_123
    ports:
      - "6381:6379"
    depends_on:
      - redis-master
    networks:
      - redis-sentinel

  sentinel1:
    image: redis:7.0
    container_name: sentinel1
    restart: always
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    ports:
      - "26379:26379"
    volumes:
      - ./sentinel1/sentinel.conf:/usr/local/etc/redis/sentinel.conf
    depends_on:
      - redis-master
    networks:
      - redis-sentinel

  sentinel2:
    image: redis:7.0
    container_name: sentinel2
    restart: always
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    ports:
      - "26380:26380"
    volumes:
      - ./sentinel2/sentinel.conf:/usr/local/etc/redis/sentinel.conf
    depends_on:
      - redis-master
    networks:
      - redis-sentinel

  sentinel3:
    image: redis:7.0
    container_name: sentinel3
    restart: always
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    ports:
      - "26381:26381"
    volumes:
      - ./sentinel3/sentinel.conf:/usr/local/etc/redis/sentinel.conf
    depends_on:
      - redis-master
    networks:
      - redis-sentinel

networks:
  redis-sentinel:
    driver: bridge

6.3 验证与故障测试

bash 复制代码 
# 启动
docker-compose up -d

# 查看哨兵信息
docker exec -it sentinel1 redis-cli -p 26379
127.0.0.1:26379> SENTINEL masters
# name=mymaster,status=ok

127.0.0.1:26379> SENTINEL slaves mymaster
# 显示 2 个从节点

# 模拟主节点故障
docker stop redis-master

# 查看哨兵日志（自动故障转移）
docker logs -f sentinel1
# +sdown master mymaster 6379
# +odown master mymaster 6379
# +failover-end master mymaster
# +switch-master mymaster 172.18.0.2 6379 172.18.0.3 6379

# 验证新主节点
docker exec -it sentinel1 redis-cli -p 26379
127.0.0.1:26379> SENTINEL get-master-addr-by-name mymaster
1) "172.18.0.3"  # slave1 成为新主节点
2) "6379"

七、集群模式部署

7.1 架构图

复制代码 
┌────────────────────────────────────────────────┐
│           Redis Cluster 集群架构                │
├────────────────────────────────────────────────┤
│                                                │
│  节点1(M)  ←→  节点2(M)  ←→  节点3(M)           │
│    ↓             ↓             ↓               │
│  节点4(S)      节点5(S)      节点6(S)           │
│                                                │
│  M = Master（主节点，负责读写）                  │
│  S = Slave（从节点，备份和读）                   │
│                                                │
│  数据分片：16384 个槽位分配到 3 个主节点          │
│  高可用：每个主节点有一个从节点备份               │
│                                                │
└────────────────────────────────────────────────┘

7.2 Docker Compose 配置

目录结构：

复制代码 
/data/redis-cluster/
├── docker-compose.yml
├── redis-7001/
│   ├── redis.conf
│   └── data/
├── redis-7002/
│   ├── redis.conf
│   └── data/
├── redis-7003/
│   ├── redis.conf
│   └── data/
├── redis-7004/
│   ├── redis.conf
│   └── data/
├── redis-7005/
│   ├── redis.conf
│   └── data/
└── redis-7006/
    ├── redis.conf
    └── data/

redis-7001/redis.conf：

bash 复制代码 
port 7001
bind 0.0.0.0
protected-mode no

# 集群配置
cluster-enabled yes
cluster-config-file nodes-7001.conf
cluster-node-timeout 5000

appendonly yes
appendfsync everysec

其他节点配置（端口改为对应的 7002-7006）

docker-compose.yml：

yaml 复制代码 
version: '3.8'

services:
  redis-7001:
    image: redis:7.0
    container_name: redis-7001
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "7001:7001"
      - "17001:17001"
    volumes:
      - ./redis-7001/redis.conf:/usr/local/etc/redis/redis.conf
      - ./redis-7001/data:/data
    networks:
      redis-cluster:
        ipv4_address: 172.20.0.2

  redis-7002:
    image: redis:7.0
    container_name: redis-7002
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "7002:7002"
      - "17002:17002"
    volumes:
      - ./redis-7002/redis.conf:/usr/local/etc/redis/redis.conf
      - ./redis-7002/data:/data
    networks:
      redis-cluster:
        ipv4_address: 172.20.0.3

  redis-7003:
    image: redis:7.0
    container_name: redis-7003
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "7003:7003"
      - "17003:17003"
    volumes:
      - ./redis-7003/redis.conf:/usr/local/etc/redis/redis.conf
      - ./redis-7003/data:/data
    networks:
      redis-cluster:
        ipv4_address: 172.20.0.4

  redis-7004:
    image: redis:7.0
    container_name: redis-7004
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "7004:7004"
      - "17004:17004"
    volumes:
      - ./redis-7004/redis.conf:/usr/local/etc/redis/redis.conf
      - ./redis-7004/data:/data
    networks:
      redis-cluster:
        ipv4_address: 172.20.0.5

  redis-7005:
    image: redis:7.0
    container_name: redis-7005
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "7005:7005"
      - "17005:17005"
    volumes:
      - ./redis-7005/redis.conf:/usr/local/etc/redis/redis.conf
      - ./redis-7005/data:/data
    networks:
      redis-cluster:
        ipv4_address: 172.20.0.6

  redis-7006:
    image: redis:7.0
    container_name: redis-7006
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "7006:7006"
      - "17006:17006"
    volumes:
      - ./redis-7006/redis.conf:/usr/local/etc/redis/redis.conf
      - ./redis-7006/data:/data
    networks:
      redis-cluster:
        ipv4_address: 172.20.0.7

networks:
  redis-cluster:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

7.3 创建集群

bash 复制代码 
# 1. 启动所有节点
docker-compose up -d

# 2. 创建集群（进入任意容器）
docker exec -it redis-7001 redis-cli --cluster create \
  172.20.0.2:7001 \
  172.20.0.3:7002 \
  172.20.0.4:7003 \
  172.20.0.5:7004 \
  172.20.0.6:7005 \
  172.20.0.7:7006 \
  --cluster-replicas 1

# 输出：
# >>> Performing hash slots allocation on 6 nodes...
# Master[0] -> Slots 0 - 5460
# Master[1] -> Slots 5461 - 10922
# Master[2] -> Slots 10923 - 16383
# Can I set the above configuration? (type 'yes' to accept): yes

# 输入 yes 确认

# 3. 验证集群
docker exec -it redis-7001 redis-cli -c -p 7001
127.0.0.1:7001> CLUSTER INFO
cluster_state:ok
cluster_slots_assigned:16384
cluster_size:3
cluster_known_nodes:6

127.0.0.1:7001> CLUSTER NODES
# 显示 6 个节点信息

# 4. 测试数据分片
127.0.0.1:7001> SET name "张三"
-> Redirected to slot [5798] located at 172.20.0.3:7002
OK  # 自动重定向到对应节点

八、数据迁移方案

8.1 从传统 Redis 迁移到 Docker

方案 1：RDB 文件迁移

bash 复制代码 
# 1. 在旧 Redis 生成 RDB 快照
redis-cli BGSAVE

# 2. 复制 RDB 文件到 Docker 数据目录
cp /var/lib/redis/dump.rdb /data/redis/data/

# 3. 启动 Docker Redis
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /data/redis/data:/data \
  redis

# 4. 验证数据
docker exec -it redis redis-cli
127.0.0.1:6379> DBSIZE
(integer) 1000000  # ✅ 数据已迁移

方案 2：AOF 文件迁移

bash 复制代码 
# 1. 在旧 Redis 开启 AOF
redis-cli CONFIG SET appendonly yes
redis-cli BGREWRITEAOF

# 2. 复制 AOF 文件
cp /var/lib/redis/appendonly.aof /data/redis/data/

# 3. 修改配置文件
vim /data/redis/conf/redis.conf
appendonly yes

# 4. 启动 Docker Redis
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /data/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  -v /data/redis/data:/data \
  redis redis-server /usr/local/etc/redis/redis.conf

8.2 在线迁移（主从同步）

bash 复制代码 
# 1. Docker Redis 作为从节点
docker run -d \
  --name redis-slave \
  -p 6380:6379 \
  redis redis-server \
    --replicaof <旧Redis IP> 6379 \
    --masterauth <旧Redis密码>

# 2. 等待同步完成
docker exec -it redis-slave redis-cli
127.0.0.1:6379> INFO replication
master_link_status:up  # ✅ 同步完成

# 3. 提升为主节点
127.0.0.1:6379> REPLICAOF NO ONE
OK

# 4. 切换应用连接到新 Redis
# 修改应用配置：127.0.0.1:6380

# 5. 停止旧 Redis

8.3 跨版本迁移

bash 复制代码 
# 从 Redis 5.0 迁移到 7.0

# 1. 使用 redis-cli --rdb 导出
redis-cli --rdb dump.rdb

# 2. 启动 Redis 7.0
docker run -d \
  --name redis7 \
  -p 6379:6379 \
  -v /data/redis7/data:/data \
  redis:7.0

# 3. 导入数据
docker cp dump.rdb redis7:/data/
docker restart redis7

九、生产环境优化

9.1 性能优化配置

yaml 复制代码 
version: '3.8'

services:
  redis:
    image: redis:7.0
    container_name: redis-prod
    restart: always
    command: redis-server /usr/local/etc/redis/redis.conf
    ports:
      - "6379:6379"
    volumes:
      - ./conf/redis.conf:/usr/local/etc/redis/redis.conf
      - ./data:/data
    
    # 资源限制
    deploy:
      resources:
        limits:
          cpus: '4'
          memory: 8G
        reservations:
          cpus: '2'
          memory: 4G
    
    # 安全配置
    security_opt:
      - no-new-privileges:true
    
    # 网络优化
    sysctls:
      net.core.somaxconn: 1024
      vm.overcommit_memory: 1
    
    # 健康检查
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    
    # 日志配置
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"
    
    networks:
      - redis-prod

networks:
  redis-prod:
    driver: bridge

9.2 监控与告警

docker-compose.yml（Redis + Redis Exporter + Prometheus + Grafana）：

yaml 复制代码 
version: '3.8'

services:
  redis:
    image: redis:7.0
    container_name: redis
    restart: always
    command: redis-server --requirepass redis_password_123
    ports:
      - "6379:6379"
    networks:
      - monitoring

  redis-exporter:
    image: oliver006/redis_exporter:latest
    container_name: redis-exporter
    restart: always
    environment:
      - REDIS_ADDR=redis:6379
      - REDIS_PASSWORD=redis_password_123
    ports:
      - "9121:9121"
    depends_on:
      - redis
    networks:
      - monitoring

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: always
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    networks:
      - monitoring

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: always
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    networks:
      - monitoring

networks:
  monitoring:
    driver: bridge

prometheus.yml：

yaml 复制代码 
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'redis'
    static_configs:
      - targets: ['redis-exporter:9121']

9.3 备份脚本

bash 复制代码 
#!/bin/bash
# docker-redis-backup.sh

CONTAINER_NAME="redis"
BACKUP_DIR="/backup/redis/$(date +%Y%m%d)"
RETENTION_DAYS=7

mkdir -p $BACKUP_DIR

# 触发 RDB 快照
docker exec $CONTAINER_NAME redis-cli BGSAVE

# 等待完成
sleep 10

# 复制文件
docker cp $CONTAINER_NAME:/data/dump.rdb $BACKUP_DIR/
docker cp $CONTAINER_NAME:/data/appendonly.aof $BACKUP_DIR/

# 压缩
cd $BACKUP_DIR
tar -czf redis_backup_$(date +%Y%m%d_%H%M%S).tar.gz *.rdb *.aof
rm -f *.rdb *.aof

# 删除旧备份
find /backup/redis/ -mtime +$RETENTION_DAYS -type d -exec rm -rf {} \;

echo "Docker Redis backup completed: $BACKUP_DIR"

十、常见面试题

10.1 基础题

Q1：Docker 部署 Redis 有什么优势？

答案：

  1. 环境一致性：开发、测试、生产环境完全一致
  2. 快速部署：一条命令启动，无需编译安装
  3. 资源隔离：限制 CPU/内存，避免资源竞争
  4. 易于扩展：快速部署多实例、集群
  5. 版本管理：随时切换 Redis 版本
  6. 简化运维：统一管理、备份、监控
Q2：如何持久化 Docker Redis 的数据？

答案 ：

使用 数据卷（Volume） 挂载：

bash 复制代码 
docker run -d \
  --name redis \
  -v /data/redis:/data \
  redis

关键点：

  • 数据存储在宿主机 /data/redis
  • 容器删除后数据仍保留
  • 便于备份和迁移
Q3：Docker Redis 如何设置密码？

答案：

方式 1：命令行参数

bash 复制代码 
docker run -d \
  --name redis \
  redis redis-server --requirepass your_password

方式 2：配置文件

bash 复制代码 
# redis.conf
requirepass your_password

docker run -d \
  --name redis \
  -v /path/to/redis.conf:/usr/local/etc/redis/redis.conf \
  redis redis-server /usr/local/etc/redis/redis.conf

10.2 进阶题

Q4：如何用 Docker 部署 Redis 主从复制？

答案：

yaml 复制代码 
version: '3.8'

services:
  master:
    image: redis:7.0
    command: redis-server --requirepass master_pass
    ports:
      - "6379:6379"

  slave:
    image: redis:7.0
    command: redis-server --replicaof master 6379 --masterauth master_pass
    ports:
      - "6380:6379"
    depends_on:
      - master

关键配置：

  • --replicaof <主机> <端口>：指定主节点
  • --masterauth <密码>：连接主节点的密码
Q5：Docker Redis 集群如何实现高可用？

答案：

方案 1：哨兵模式（Sentinel）

  • 部署 3 个哨兵节点监控主从
  • 主节点故障自动故障转移
  • 适合中小规模（单主多从）

方案 2：集群模式（Cluster）

  • 部署 6+ 节点（3主3从）
  • 数据分片到多个主节点
  • 主节点故障自动切换
  • 适合大规模（PB 级数据）

选型：

  • 数据量 < 10GB → 主从 + 哨兵
  • 数据量 > 10GB → 集群模式
Q6：如何限制 Docker Redis 的内存和 CPU？

答案：

bash 复制代码 
docker run -d \
  --name redis \
  --memory=2g \
  --memory-swap=2g \
  --cpus=2 \
  redis

参数说明：

  • --memory=2g：限制内存 2GB
  • --memory-swap=2g：禁用 swap（等于 memory）
  • --cpus=2：限制 2 个 CPU 核心

配合 Redis 配置：

bash 复制代码 
maxmemory 2gb
maxmemory-policy allkeys-lru

10.3 实战题

Q7：生产环境 Docker Redis 如何备份？

答案：

1. 定时备份脚本：

bash 复制代码 
#!/bin/bash
docker exec redis redis-cli BGSAVE
sleep 10
docker cp redis:/data/dump.rdb /backup/

2. 定时任务：

bash 复制代码 
crontab -e
0 2 * * * /usr/local/bin/docker-redis-backup.sh

3. 远程备份：

bash 复制代码 
tar -czf redis_backup.tar.gz /backup/dump.rdb
scp redis_backup.tar.gz user@remote:/backup/
Q8：如何从传统 Redis 迁移到 Docker？

答案：

方案 1：停机迁移（RDB）

  1. 旧 Redis 生成 RDB：redis-cli BGSAVE
  2. 复制到 Docker 数据目录：cp dump.rdb /data/redis/
  3. 启动 Docker Redis
  4. 验证数据

方案 2：在线迁移（主从同步）

  1. Docker Redis 作为从节点连接旧 Redis
  2. 等待数据同步完成
  3. 提升 Docker Redis 为主节点
  4. 切换应用连接

方案 3：双写迁移

  1. 应用同时写入旧 Redis 和 Docker Redis
  2. 使用 Redis SCAN 增量迁移旧数据
  3. 验证数据一致性
  4. 切换读流量
Q9：Docker Redis 性能优化建议？

答案：

1. 使用宿主机网络：

bash 复制代码 
docker run -d --network host redis
# 避免 Docker 网络转发开销

2. 使用 SSD 存储数据卷：

bash 复制代码 
docker run -d -v /ssd/redis:/data redis

3. 调整内核参数：

bash 复制代码 
sysctl -w vm.overcommit_memory=1
echo never > /sys/kernel/mm/transparent_hugepage/enabled

4. 限制日志大小：

yaml 复制代码 
logging:
  driver: "json-file"
  options:
    max-size: "100m"
    max-file: "3"

5. 禁用 swap：

bash 复制代码 
--memory-swap=<memory值>
Q10：如何监控 Docker Redis？

答案：

1. Docker 命令监控：

bash 复制代码 
# CPU/内存使用率
docker stats redis

# 日志监控
docker logs -f redis

2. Redis 自带监控：

bash 复制代码 
docker exec -it redis redis-cli INFO
docker exec -it redis redis-cli MONITOR

3. Prometheus + Grafana：

  • 部署 redis_exporter 采集指标
  • Prometheus 存储时序数据
  • Grafana 可视化展示

关键指标：

  • used_memory：内存使用
  • connected_clients：客户端连接数
  • instantaneous_ops_per_sec：QPS
  • keyspace_hits/misses：缓存命中率

🎉 总结

本文全面讲解了 Docker 部署 Redis：

✅ 单机部署 ：快速启动、持久化、资源限制

✅ Docker Compose ：优雅编排、多实例管理

✅ 主从复制 ：读写分离、数据冗余

✅ 哨兵模式 ：自动故障转移、高可用

✅ 集群模式 ：数据分片、水平扩展

✅ 数据迁移 ：RDB/AOF/主从同步迁移

✅ 生产优化 ：性能调优、监控告警、备份策略

✅ 面试宝典：10 道高频 Docker Redis 面试题

📚 Redis 系列完结

恭喜你完成 Redis 系列全部五篇博客！

  1. ✅ Redis 入门与 CentOS 安装
  2. ✅ Redis 基础命令速通
  3. ✅ Redis 五大核心数据类型
  4. ✅ Redis 持久化机制
  5. ✅ Docker 部署 Redis

💬 互动时间 ：

你在生产环境使用 Docker 部署 Redis 吗？遇到过什么坑？欢迎评论区分享！

👍 觉得有帮助，点个赞+收藏+关注三连吧~ 🎉

相关推荐
2301_7775993724 分钟前
mysql如何进行数据库容量规划_评估磁盘空间增长趋势
jvm·数据库·python
NineData1 小时前
NineData 亮相香港国际创科展 InnoEX 2026，以 AI 加速布局全球市场
运维·数据库·人工智能·ninedata·新闻资讯·玖章算术
m0_377618231 小时前
Redis怎样应对大规模集群的重启风暴_分批次重启节点并等待集群状态恢复绿灯后再继续操作
jvm·数据库·python
imuliuliang1 小时前
存储过程（SQL）
android·数据库·sql
考虑考虑1 小时前
SQL语句中的order by可能造成时间重复
数据库·后端·mysql
2401_835956812 小时前
Golang怎么写基准测试benchmark_Golang基准测试教程【完整】
jvm·数据库·python
阿杰学AI2 小时前
AI核心知识129—大语言模型之 向量数据库（简洁且通俗易懂版）
数据库·人工智能·ai·语言模型·自然语言处理·向量数据库·vector database
SPC的存折2 小时前
D在 Alpine 容器中手动搭建 Discuz 全攻略（包含镜像一键部署脚本，可直接用）
linux·数据库·mysql·缓存
李兆龙的博客3 小时前
从一到无穷大 #67 大查询根因分析 - 从 PinSQL 到 RCRank
数据库·时序数据库
AgCl233 小时前
MYSQL-6-函数与约束-3/17
android·数据库·mysql
热门推荐
012026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元02GitHub 镜像站点032026 年 AI 编程助手全面对比评测：Cursor vs Copilot vs Claude Code vs GitHub Copilot Free042026年4月AI大事件深度解读：大模型竞争进入“深水区“05Claude Code Windows 兼容性问题：指定版本 2.1.112 可解决06AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析07UBUNTU Claude Code 报错 claude native binary not installed08近期有什么ai的新消息，新动态？ 2026.4月09从限购到畅通：GLM-5.1 Coding Plan接入攻略10从零部署 Hermes Agent：一只"会成长的 AI 马"保姆级安装教程