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 吗？遇到过什么坑？欢迎评论区分享！

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

相关推荐
IMPYLH2 小时前
Linux 的 env 命令
linux·运维·服务器·数据库
fobwebs2 小时前
如何通过phpmyadmin指令来优化数据库表，给数据库“减肥”。
数据库·wordpress·数据库优化·phpmyadmin
syinfo2 小时前
oracle使用PLSQL导出表数据
数据库·oracle
客梦2 小时前
数据库基础
数据库·笔记
老苏畅谈运维2 小时前
Oracle AI Database 26ai 安装实战
数据库·oracle·oracle 26ai
Rick19932 小时前
SQL优化
数据库·sql
沪漂阿龙2 小时前
掌握MySQL这些函数，SQL水平直接起飞！
数据库·sql·mysql
无忧智库2 小时前
破局与重构：基于“智慧大脑”的企业全面数据化经营深度解构（PPT）
数据库·重构
大嘴皮猴儿2 小时前
零基础入门：跨境电商产品图片多语言翻译的完整流程与跨马翻译实操
大数据·数据库·人工智能·自动翻译·教育电商
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03围棋-html版本04纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！05班级宠物园部署指南06小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）07“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）08中国象棋-html版本09OpenClaw 使用和管理 MCP 完全指南10UV安装并设置国内源