---

Docker 部署 Redis 详细教程：从入门到实践

前言

在现代软件开发中，效率、可移植性和可伸缩性是核心要素。Docker 作为容器化技术的翘楚，极大地简化了应用程序的部署和管理。而 Redis，作为一款高性能的键值存储系统，广泛应用于缓存、消息队列、实时分析等场景。将 Redis 部署在 Docker 容器中，不仅能享受到 Docker 带来的诸多便利，还能确保 Redis 服务的隔离性、一致性和快速部署能力。

本教程将带领您从零开始，详细了解如何使用 Docker 部署 Redis，涵盖从最基础的运行，到数据持久化、配置管理、网络设置、多服务编排，直至生产环境下的高可用与性能优化等高级实践。无论您是 Docker 或 Redis 的初学者，还是希望在生产环境中优化部署的老手，都能从中获益。

目录

1. 引言：Docker 与 Redis 的完美结合
   • 为什么选择 Docker 部署 Redis？
   • 本教程将涵盖什么？
2. 准备工作
   • 安装 Docker
   • 基础 Docker 命令回顾
3. 入门篇：快速部署一个无状态 Redis 容器
   • 拉取 Redis 镜像
   • 运行第一个 Redis 容器
   • 连接并测试 Redis 服务
   • 停止与移除容器
   • 重要提示：无状态容器的风险
4. 进阶篇：确保数据持久化
   • 理解数据持久化的重要性
   • 方法一：使用主机目录挂载 (Bind Mounts)
     • 原理与操作
     • 优点与局限性
   • 方法二：使用 Docker 卷 (Docker Volumes)
     • 创建 Docker 卷
     • 将卷挂载到 Redis 容器
     • 优点与推荐
5. 配置篇：定制化 Redis 服务
   • 获取默认 Redis 配置文件
   • 编写自定义 redis.conf
   • 将自定义配置挂载到容器
   • 常用配置项详解：requirepass (密码)、bind、maxmemory 等
6. 网络篇：容器间通信与端口管理
   • 端口映射 (-p)
   • Docker 默认 Bridge 网络
   • 自定义 Bridge 网络
     • 创建自定义网络
     • 将 Redis 容器连接到自定义网络
     • 实现应用容器与 Redis 容器的通信
     • 优点与实践建议
7. 实践篇：使用 Docker Compose 管理 Redis 服务
   • 为什么需要 Docker Compose？
   • 安装 Docker Compose
   • 编写 docker-compose.yml 文件
     • 定义 Redis 服务
     • 整合数据持久化、自定义配置、网络和密码
   • 启动、停止与管理服务
   • 一个简单的 Web 应用连接 Redis 的示例
8. 高级篇：生产环境考量与高可用
   • 资源限制：CPU、内存限制
   • 日志管理：查看与导出日志
   • 备份与恢复策略
     • Redis RDB 与 AOF 持久化
     • 通过 Docker 卷进行备份
   • 高可用性 (HA) 概览
     • Redis Sentinel：原理与 Docker 部署思路
     • Redis Cluster：原理与 Docker 部署思路
     • 结合 Docker Swarm 或 Kubernetes
   • 监控与管理
     • 使用 docker stats
     • Dockerized RedisInsight 部署
9. 故障排除与常见问题
   • 容器无法启动
   • 无法连接 Redis
   • 数据未持久化
   • 性能问题
10. 总结与展望

---

1. 引言：Docker 与 Redis 的完美结合

为什么选择 Docker 部署 Redis？

在传统的部署模式中，我们可能需要手动安装 Redis、配置环境变量、管理依赖库，这些过程繁琐且容易出错。而 Docker 带来了革命性的变化：

• 环境隔离：Redis 服务运行在独立的容器中，与宿主机环境和其他应用隔离，避免了版本冲突和依赖问题。
• 快速部署：通过 Docker 镜像，可以在任何支持 Docker 的环境中快速拉取和启动 Redis 服务，大大缩短部署时间。
• 可移植性：构建好的 Redis 容器可以在开发、测试、生产环境之间无缝迁移，保证环境一致性。
• 资源管理：Docker 提供了强大的资源限制能力，可以为 Redis 容器分配特定的 CPU、内存等资源，避免资源争抢。
• 版本控制：Docker 镜像本身就是版本化的，可以轻松回滚到旧版本或升级到新版本。
• 易于管理：通过 Docker 命令或 Docker Compose，可以方便地启动、停止、重启、监控 Redis 容器。

将 Redis 容器化，能够让开发者专注于业务逻辑，而非繁琐的基础设施管理。

本教程将涵盖什么？

本教程旨在提供一个全面的 Docker 部署 Redis 指南，从基础命令到高级实践，包括：

• Redis 镜像的拉取与运行。
• 两种主要的数据持久化方案：Bind Mounts 和 Docker Volumes。
• 自定义 Redis 配置文件的应用。
• Docker 网络的创建与管理，实现容器间通信。
• 使用 Docker Compose 简化多服务编排。
• 生产环境下的资源限制、备份、高可用性策略探讨。
• 常见的故障排除方法。

2. 准备工作

在开始之前，您需要在您的操作系统上安装 Docker。

安装 Docker

• Linux: 遵循 Docker 官方文档的指引，通常使用 apt 或 yum 包管理器进行安装。
  • 例如 (Ubuntu): sudo apt update && sudo apt install docker.io && sudo systemctl start docker && sudo systemctl enable docker
• macOS: 下载并安装 Docker Desktop for Mac。
• Windows: 下载并安装 Docker Desktop for Windows。

安装完成后，您可以通过运行以下命令验证 Docker 是否安装成功并正常运行：

bash
docker --version
docker run hello-world

如果看到 “Hello from Docker!” 的信息，则说明 Docker 已准备就绪。

基础 Docker 命令回顾

在后续教程中，我们将频繁使用以下 Docker 命令：

• docker pull <image_name>:<tag>: 从 Docker Hub 拉取镜像。
• docker images: 列出本地所有镜像。
• docker run [OPTIONS] <image_name>:<tag> [COMMAND] [ARG...]: 运行一个新容器。
  • -p <host_port>:<container_port>: 端口映射。
  • -v <host_path>:<container_path>: 卷挂载（Bind Mount）。
  • -v <volume_name>:<container_path>: 卷挂载（Docker Volume）。
  • --name <container_name>: 为容器指定一个名称。
  • -d: 后台运行容器。
  • --rm: 容器停止后自动删除。
  • --network <network_name>: 连接到指定网络。
  • -e <ENV_VAR>=<VALUE>: 设置环境变量。
• docker ps [-a]: 列出正在运行的容器（-a 包含已停止的）。
• docker logs <container_name_or_id>: 查看容器日志。
• docker stop <container_name_or_id>: 停止一个运行中的容器。
• docker rm <container_name_or_id>: 删除一个容器。
• docker exec -it <container_name_or_id> <command>: 在运行中的容器内执行命令。
• docker network create <network_name>: 创建一个自定义网络。
• docker volume create <volume_name>: 创建一个 Docker 卷。

3. 入门篇：快速部署一个无状态 Redis 容器

这是最简单、最快速的 Redis 部署方式，非常适合临时测试或学习。

3.1 拉取 Redis 镜像

首先，我们需要从 Docker Hub 拉取 Redis 官方镜像。通常我们会拉取 latest 标签，但生产环境建议指定具体的版本号，例如 redis:6.2.7。

bash
docker pull redis

您也可以拉取带有 Alpine Linux 基础的轻量级镜像，例如 redis:alpine，这在资源受限的环境下会更受欢迎。

3.2 运行第一个 Redis 容器

现在，我们将运行一个最基础的 Redis 容器。

bash
docker run -d -p 6379:6379 --name my-redis-instance redis

这条命令的含义是：
* -d: 让容器在后台（detached）运行。
* -p 6379:6379: 将宿主机的 6379 端口映射到容器内部的 6379 端口。Redis 默认监听 6379 端口。这样，您就可以从宿主机访问容器内的 Redis 服务。
* --name my-redis-instance: 为这个容器指定一个易于识别的名称 my-redis-instance。
* redis: 指定要运行的镜像名称。

运行后，您可以使用 docker ps 命令查看正在运行的容器：

bash
docker ps

您应该能看到 my-redis-instance 容器正在运行。

3.3 连接并测试 Redis 服务

有两种方式可以连接到容器内的 Redis 服务：

方式一：从宿主机连接

如果您的宿主机上安装了 redis-cli 工具，可以直接连接：

bash
redis-cli -h 127.0.0.1 -p 6379

进入 redis-cli 后，可以执行一些 Redis 命令：

127.0.0.1:6379> PING
PONG
127.0.0.1:6379> SET mykey "Hello Docker Redis"
OK
127.0.0.1:6379> GET mykey
"Hello Docker Redis"
127.0.0.1:6379> exit

方式二：进入容器内部连接

您也可以通过 docker exec 命令进入容器内部，使用容器自带的 redis-cli：

bash
docker exec -it my-redis-instance redis-cli

然后执行相同的 Redis 命令：

127.0.0.1:6379> PING
PONG
127.0.0.1:6379> GET mykey
"Hello Docker Redis"

3.4 停止与移除容器

测试完成后，您可以停止并删除这个容器：

bash
docker stop my-redis-instance
docker rm my-redis-instance

重要提示：无状态容器的风险

您会发现，在执行 docker rm 后，之前存储在 Redis 中的数据（例如 mykey）会丢失。这是因为我们没有为 Redis 配置任何数据持久化机制。对于生产环境或需要保存数据的场景，这是绝对不可接受的。接下来的章节将解决这个问题。

4. 进阶篇：确保数据持久化

数据持久化是部署 Redis 的核心考量之一。Redis 默认会将数据存储在容器的临时文件系统上。一旦容器被删除，所有数据都会丢失。为了避免这种情况，我们需要将 Redis 的数据目录映射到宿主机文件系统上。Docker 提供了两种主要的数据持久化方式：主机目录挂载 (Bind Mounts) 和 Docker 卷 (Docker Volumes)。

4.1 理解数据持久化的重要性

无论是缓存还是作为主存储，Redis 中的数据都可能非常重要。如果没有持久化，一旦容器意外停止、升级或删除，所有数据都将丢失，这对于任何生产应用来说都是灾难性的。

4.2 方法一：使用主机目录挂载 (Bind Mounts)

Bind Mounts 允许您将宿主机文件系统上的一个目录或文件直接挂载到容器内部的指定路径。

原理与操作

1. 在宿主机上创建一个目录，用于存储 Redis 数据。
   bash
mkdir -p /opt/docker/redis/data

2. 运行 Redis 容器时，使用 -v 参数进行挂载。Redis 默认将其数据存储在容器内的 /data 目录。
   bash
docker run -d \
-p 6379:6379 \
--name my-redis-persistent-bind \
-v /opt/docker/redis/data:/data \
redis

   • -v /opt/docker/redis/data:/data: 将宿主机的 /opt/docker/redis/data 目录挂载到容器内的 /data 目录。

3. 连接并测试：
   bash
redis-cli -h 127.0.0.1 -p 6379
SET mykey "Data persisted with Bind Mount!"
GET mykey

4. 停止并删除容器，然后重新运行一个新容器，但使用相同的挂载路径：
   “`bash
   docker stop my-redis-persistent-bind
   docker rm my-redis-persistent-bind

   再次运行，注意这里直接用相同目录，数据会恢复

   docker run -d \
   -p 6379:6379 \
   –name my-redis-persistent-bind-new \
   -v /opt/docker/redis/data:/data \
   redis
   5. 连接新容器并验证数据是否恢复：bash
   redis-cli -h 127.0.0.1 -p 6379
   GET mykey

   应该会显示 “Data persisted with Bind Mount!”

   “`

优点与局限性

• 优点:
  • 简单直观，直接访问宿主机文件系统。
  • 方便宿主机应用（如备份脚本）直接操作数据。
• 局限性:
  • 宿主机目录路径依赖性强，降低可移植性。
  • 权限管理可能比较复杂，容器内 Redis 进程需要对挂载目录有写入权限。
  • 与 Docker 的存储机制结合不紧密，可能会绕过 Docker 的一些存储管理功能。

4.3 方法二：使用 Docker 卷 (Docker Volumes)

Docker 卷是 Docker 管理数据持久化的首选方式。它们由 Docker 自身管理，通常位于宿主机文件系统的 /var/lib/docker/volumes 目录下（具体位置可能因操作系统而异），但您无需关心其内部结构。

原理与操作

1. 创建 Docker 卷：
   bash
docker volume create redis_data
   您可以使用 docker volume ls 查看所有 Docker 卷，docker volume inspect redis_data 查看卷的详细信息。

2. 将卷挂载到 Redis 容器：
   bash
docker run -d \
-p 6379:6379 \
--name my-redis-persistent-volume \
-v redis_data:/data \
redis

   • -v redis_data:/data: 将名为 redis_data 的 Docker 卷挂载到容器内的 /data 目录。

3. 连接并测试（与 Bind Mounts 相同）：
   bash
redis-cli -h 127.0.0.1 -p 6379
SET anotherkey "Data persisted with Docker Volume!"
GET anotherkey

4. 停止并删除容器，然后重新运行一个新容器，并挂载相同的 Docker 卷：
   “`bash
   docker stop my-redis-persistent-volume
   docker rm my-redis-persistent-volume

   再次运行，数据会恢复

   docker run -d \
   -p 6379:6379 \
   –name my-redis-persistent-volume-new \
   -v redis_data:/data \
   redis
   “`
   5. 连接新容器并验证数据恢复。

优点与推荐

• 优点:
  • 由 Docker 管理: 更符合 Docker 的理念，易于备份、迁移和与其他 Docker 服务集成。
  • 平台无关性: 不依赖于特定的宿主机目录结构，提高了可移植性。
  • 性能优化: Docker 卷通常针对容器化应用进行了性能优化。
  • 数据隔离: 避免了宿主机文件系统权限和管理上的复杂性。
• 推荐: 在大多数生产环境中，Docker Volumes 是比 Bind Mounts 更推荐的数据持久化方式。

5. 配置篇：定制化 Redis 服务

Redis 有丰富的配置选项，我们可以通过挂载自定义的 redis.conf 文件来定制化 Redis 服务。

5.1 获取默认 Redis 配置文件

您可以从 Redis 官方 GitHub 仓库下载 redis.conf 文件，或者从正在运行的 Redis 容器中复制出来：

1. 临时运行一个 Redis 容器（如果不希望干扰现有容器）：
   bash
docker run --rm --name temp-redis-config redis cat /usr/local/etc/redis/redis.conf > ./redis.conf
   这条命令会启动一个 Redis 容器，执行 cat /usr/local/etc/redis/redis.conf 命令，然后将输出重定向到宿主机的 redis.conf 文件，容器运行完毕后会自动删除 (--rm)。

2. 现在，您的当前目录下就有了 redis.conf 文件。

5.2 编写自定义 redis.conf

打开 redis.conf 文件进行编辑。我们将进行以下常见配置：

• requirepass：设置 Redis 连接密码。
• bind：限制 Redis 监听的 IP 地址。在容器中，通常设置为 0.0.0.0 (监听所有网络接口) 或 127.0.0.1 (仅限容器内部访问)。
• dir：指定 Redis 持久化文件（RDB/AOF）的存储目录。对于 Docker 容器，通常将其指向 /data，以便与卷挂载结合。
• maxmemory：设置最大内存使用量及内存淘汰策略。

示例 redis.conf 片段：

“`conf

开启后台持久化（如果需要）

daemonize no # 必须为 no，否则容器会认为 Redis 已经退出

绑定监听地址，0.0.0.0 允许所有 IP 访问，但请注意安全

如果在 Docker 网络内部，也可以考虑更安全的只允许容器内部 IP 访问

bind 0.0.0.0

端口

port 6379

持久化文件目录，必须与 Docker 卷挂载点一致

dir /data

设置密码

requirepass your_strong_password_here

最大内存限制 (例如 2GB)

maxmemory 2gb

内存淘汰策略 (例如 allkeys-lru，LRU算法淘汰所有键)

maxmemory-policy allkeys-lru

AOF 持久化 (根据需求开启或关闭)

appendonly yes
appendfsync everysec

RDB 持久化 (默认开启)

save 900 1
save 300 10
save 60 10000
``
**注意**: 在 Docker 容器中，daemonize选项必须设置为no`。因为容器期望前台进程持续运行，如果 Redis 进程后台化，容器会认为服务已停止并退出。

5.3 将自定义配置挂载到容器

有了自定义的 redis.conf 文件后，我们可以将其挂载到 Redis 容器中。

1. 将 redis.conf 文件放置在一个合适的宿主机目录下，例如 /opt/docker/redis/config/redis.conf。
   bash
mkdir -p /opt/docker/redis/config
# 假设你已经将自定义的 redis.conf 放在了当前目录
mv ./redis.conf /opt/docker/redis/config/redis.conf

2. 运行 Redis 容器，同时挂载数据卷和配置文件：
   bash
docker run -d \
-p 6379:6379 \
--name my-redis-custom \
-v redis_data:/data \
-v /opt/docker/redis/config/redis.conf:/usr/local/etc/redis/redis.conf \
redis redis-server /usr/local/etc/redis/redis.conf

   • -v /opt/docker/redis/config/redis.conf:/usr/local/etc/redis/redis.conf: 将宿主机的 redis.conf 文件挂载到容器内的 /usr/local/etc/redis/redis.conf 路径。这是 Redis 官方镜像默认寻找配置文件的位置。
   • redis-server /usr/local/etc/redis/redis.conf: 明确告诉 Redis 容器使用我们挂载的配置文件启动。

3. 连接并测试密码：
   bash
redis-cli -h 127.0.0.1 -p 6379
# 此时直接 PING 会被拒绝
(error) NOAUTH Authentication required.
AUTH your_strong_password_here
PING
# 应该会显示 PONG

6. 网络篇：容器间通信与端口管理

在实际应用中，Redis 往往不是独立运行的，它需要与其他应用（如 Web 服务器、消息队列）进行通信。Docker 提供了强大的网络功能来管理容器间的连接。

6.1 端口映射 (-p)

前面我们已经用过 -p 参数进行端口映射：docker run -p <host_port>:<container_port>。这使得宿主机可以通过 <host_port> 访问容器内的服务。对于单机部署或少量服务暴露，这很方便。

6.2 Docker 默认 Bridge 网络

当您不指定网络时，Docker 容器会连接到默认的 bridge 网络。这个网络允许容器通过 IP 地址互相访问，但需要知道对方的 IP。对于服务发现和管理来说，这并不理想。

6.3 自定义 Bridge 网络

推荐的做法是为您的应用创建一个自定义的 Bridge 网络。自定义网络有以下优点：

• 服务发现: 同一网络内的容器可以通过容器名称互相解析 IP 地址，无需硬编码 IP。
• 隔离性: 将不同应用的服务分隔在不同的网络中，提高安全性。
• DNS 解析: Docker 内置的 DNS 服务会自动处理容器名称到 IP 的解析。

操作步骤

1. 创建自定义网络：
   bash
docker network create my-app-network
   您可以使用 docker network ls 查看。

2. 将 Redis 容器连接到自定义网络：
   首先停止并删除之前的 Redis 容器（如果还在运行）：
   bash
docker stop my-redis-custom
docker rm my-redis-custom
   然后重新运行 Redis 容器，并将其连接到 my-app-network：
   bash
docker run -d \
--network my-app-network \
--network-alias redis \
--name my-redis-network \
-v redis_data:/data \
-v /opt/docker/redis/config/redis.conf:/usr/local/etc/redis/redis.conf \
redis redis-server /usr/local/etc/redis/redis.conf

   • --network my-app-network: 将容器连接到 my-app-network。
   • --network-alias redis: 为 Redis 容器在 my-app-network 中创建一个网络别名 redis。其他连接到此网络的容器可以通过 redis 这个主机名访问它。
     注意: 我们没有使用 -p 6379:6379 端口映射。这意味着 Redis 服务只在 my-app-network 内部暴露，无法从宿主机直接通过 6379 端口访问。如果仍需宿主机访问，可以加上 -p。

3. 实现应用容器与 Redis 容器的通信：
   现在，假设我们有一个简单的 Python Web 应用需要连接 Redis。我们可以将它也连接到 my-app-network。

   创建一个简单的 Python Web 应用 app.py：
   “`python

   app.py

   import redis
   from flask import Flask

   app = Flask(name)
   r = redis.Redis(host=’redis’, port=6379, password=’your_strong_password_here’, db=0)

   @app.route(‘/’)
   def hello_world():
   try:
   r.ping()
   count = r.incr(‘visits’)
   return f”Hello from Flask! Visits: {count}. Redis is connected!”
   except Exception as e:
   return f”Error connecting to Redis: {e}”, 500

   if name == ‘main‘:
   app.run(host=’0.0.0.0’, port=5000)
   创建一个 `Dockerfile` for Flask App：dockerfile

   Dockerfile for Flask App

   FROM python:3.9-slim-buster
   WORKDIR /app
   COPY requirements.txt .
   RUN pip install -r requirements.txt
   COPY app.py .
   EXPOSE 5000
   CMD [“python”, “app.py”]
   创建一个 `requirements.txt`:
   flask
   redis
   构建 Flask 镜像：bash
   docker build -t my-flask-app .
   运行 Flask 容器，并连接到 `my-app-network`：bash
   docker run -d \
   -p 5000:5000 \
   –network my-app-network \
   –name my-flask-app-instance \
   my-flask-app
   ``
现在，通过浏览器访问http://localhost:5000`，您应该能看到 Flask 应用成功连接到 Redis，并且计数器在增加。

   关键点: Flask 应用在连接 Redis 时，host='redis' 就能正确解析到 Redis 容器的 IP，因为它们都在 my-app-network 中，并且 Redis 容器设置了 redis 的网络别名。

7. 实践篇：使用 Docker Compose 管理 Redis 服务

当您的应用包含多个服务（如 Web 应用、数据库、缓存、消息队列等）时，手动使用 docker run 命令来管理它们会变得非常繁琐。Docker Compose 应运而生，它允许您使用一个 YAML 文件来定义和管理多容器 Docker 应用程序。

7.1 为什么需要 Docker Compose？

• 声明式配置: 所有服务、网络、卷的配置都集中在一个 docker-compose.yml 文件中，清晰明了。
• 一键式操作: 仅需一个命令 (docker compose up) 即可启动整个应用程序栈。
• 服务发现: Docker Compose 会自动为服务创建网络，并实现服务间的 DNS 解析。
• 版本控制: docker-compose.yml 文件可以轻松地进行版本控制。

7.2 安装 Docker Compose

对于 Docker Desktop 用户，Docker Compose 通常已内置。对于 Linux 用户，可能需要单独安装（或使用 docker compose 命令代替 docker-compose）。

• 旧版本: sudo curl -L "https://github.com/docker/compose/releases/download/v2.10.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose && sudo chmod +x /usr/local/bin/docker-compose
• 新版本 (推荐): Docker Compose V2 已集成到 Docker CLI 中，直接使用 docker compose 命令即可。如果没有，请更新您的 Docker Desktop 或 Docker Engine。

验证安装：
bash
docker compose version

7.3 编写 docker-compose.yml 文件

我们将使用 Docker Compose 来编排 Flask 应用和 Redis 服务。

创建一个新的目录，并在其中创建 docker-compose.yml 文件、app.py、requirements.txt 和 Dockerfile。

docker-compose.yml 示例：

“`yaml
version: ‘3.8’ # Docker Compose 文件格式版本

services:
web:
build: . # 使用当前目录的 Dockerfile 构建 web 服务镜像
ports:
– “5000:5000” # 映射宿主机 5000 端口到容器 5000 端口
volumes:
– ./app.py:/app/app.py # 将宿主机 app.py 挂载到容器，方便开发调试
environment:
REDIS_HOST: redis # Redis 服务的主机名，与下方 services 定义的服务名一致
REDIS_PASSWORD: your_strong_password_here # Redis 密码
depends_on:
– redis # 确保 redis 服务在 web 服务之前启动
networks:
– my-app-network # 连接到自定义网络

redis:
image: redis:6.2.7-alpine # 使用指定版本的 Redis Alpine 镜像
container_name: my-redis-compose # 为容器指定名称
command: redis-server /usr/local/etc/redis/redis.conf # 使用挂载的配置文件启动
ports:
– “6379:6379” # 映射 Redis 端口，方便宿主机直接访问，生产环境可省略
volumes:
– redis_data:/data # 挂载 Docker 卷用于数据持久化
– ./config/redis.conf:/usr/local/etc/redis/redis.conf # 挂载自定义配置文件
networks:
– my-app-network # 连接到自定义网络

volumes:
redis_data: # 定义一个名为 redis_data 的 Docker 卷

networks:
my-app-network: # 定义一个自定义网络
driver: bridge
“`

确保 app.py 适配了环境变量：
“`python

app.py

import redis
import os
from flask import Flask

app = Flask(name)

REDIS_HOST = os.getenv(‘REDIS_HOST’, ‘localhost’)
REDIS_PORT = int(os.getenv(‘REDIS_PORT’, 6379))
REDIS_PASSWORD = os.getenv(‘REDIS_PASSWORD’, None)

r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=0)

@app.route(‘/’)
def hello_world():
try:
r.ping()
count = r.incr(‘visits’)
return f”Hello from Flask! Visits: {count}. Redis is connected!”
except Exception as e:
return f”Error connecting to Redis: {e}”, 500

if name == ‘main‘:
app.run(host=’0.0.0.0’, port=5000)
创建 `config/redis.conf` 目录及文件，并放入自定义配置：bash
mkdir -p config

编辑 config/redis.conf 文件

`config/redis.conf` 内容（与前面一致，确保 `requirepass` 与 `app.py` 中的 `REDIS_PASSWORD` 匹配）：conf
bind 0.0.0.0
port 6379
dir /data
requirepass your_strong_password_here
appendonly yes
maxmemory 2gb
maxmemory-policy allkeys-lru
“`

7.4 启动、停止与管理服务

在 docker-compose.yml 所在的目录下，执行以下命令：

• 启动所有服务 (第一次会构建镜像):
  bash
docker compose up -d

  • -d: 后台运行。

• 查看服务状态:
  bash
docker compose ps

• 查看服务日志:
  bash
docker compose logs -f

  • -f: 跟踪日志输出。

• 停止所有服务:
  bash
docker compose stop

• 停止并删除所有服务、网络和卷:
  bash
docker compose down

  • --volumes: 如果要删除 Docker Compose 创建的卷，可以添加此参数。
    bash
docker compose down --volumes
    注意: 这会删除 redis_data 卷，您的 Redis 数据将会丢失！请谨慎使用。

通过访问 http://localhost:5000，您可以看到整个应用栈已成功启动并运行。

8. 高级篇：生产环境考量与高可用

在生产环境中部署 Redis，除了上述基本配置，还需要考虑资源管理、监控、备份、高可用性等因素。

8.1 资源限制

为避免 Redis 容器占用过多宿主机资源，您可以通过 Docker 或 Docker Compose 设置 CPU 和内存限制。

在 docker run 中:
* --memory <limit>: 内存限制 (例如 2g 表示 2GB)。
* --cpus <number>: CPU 核心数限制 (例如 1.5 表示 1.5 个 CPU 核心)。

bash
docker run -d \
--name my-redis-prod \
--memory 2g \
--cpus 1.5 \
# ... 其他参数
redis

在 docker-compose.yml 中:

yaml
services:
redis:
image: redis:6.2.7-alpine
# ...
deploy:
resources:
limits:
memory: 2G
cpus: '1.5'
reservations: # 预留资源，确保至少这些资源可用
memory: 1G
cpus: '0.5'
注意: deploy 部分通常用于 Docker Swarm 或 Kubernetes，但 Docker Compose 在本地也可以对 resources 进行一定程度的模拟。

8.2 日志管理

Redis 容器的日志可以通过 docker logs 命令查看。在生产环境中，通常会结合日志收集系统（如 ELK Stack, Grafana Loki）来集中管理和分析日志。

• 查看实时日志: docker logs -f my-redis-compose
• 导出日志: docker logs my-redis-compose > redis_logs.txt

8.3 备份与恢复策略

尽管 Docker 卷提供了数据持久化，但仍然需要定期备份以防数据损坏或意外删除。

• Redis RDB 与 AOF 持久化:

  • RDB (Redis Database): Redis 会定期将内存中的数据快照写入磁盘，形成一个 dump.rdb 文件。它是二进制格式，适合备份。
  • AOF (Append Only File): Redis 会将所有写操作追加到 AOF 文件中。AOF 文件是文本格式，更适合数据恢复的完整性，但通常比 RDB 大。
    在 redis.conf 中合理配置 save (RDB) 和 appendonly (AOF) 选项。通常建议两者都开启，或者只开启 AOF，因为它提供了更好的数据完整性保证。

• 通过 Docker 卷进行备份:
  由于数据存储在 Docker 卷中，您可以利用 Docker 卷的特性进行备份。

  1. 临时容器备份: 启动一个临时容器，挂载相同的 Redis 数据卷和另一个用于备份的宿主机目录，然后从 /data 目录复制数据。
     bash
docker run --rm -v redis_data:/data -v /path/to/backup:/backup alpine sh -c "cp -R /data/* /backup/"
     在执行此操作时，最好先停止 Redis 容器，或者在 Redis 内部执行 BGSAVE 命令确保数据已写入 RDB 文件。
  2. 卷管理工具: 使用 docker volume cp (如果您的 Docker 版本支持) 或第三方工具进行卷备份。

8.4 高可用性 (HA) 概览

单个 Redis 实例存在单点故障风险。为了实现高可用性，Redis 提供了 Sentinel 和 Cluster 两种方案。

• Redis Sentinel：

  • 作用: 监控 Redis Master/Slave 实例的健康状态，在 Master 故障时自动进行故障转移，选举新的 Master，并通知应用新的 Master 地址。
  • Docker 部署思路: 通常需要部署至少 3 个 Sentinel 实例和至少 1 个 Master、2 个 Slave 实例。可以通过 Docker Compose 编排多个 Redis 和 Sentinel 容器，并使用自定义网络进行通信。应用连接到 Sentinel 实例，由 Sentinel 提供 Master 的地址。
  • 复杂性: 配置 Sentinel 需要理解其选举机制和 Quorum (仲裁) 概念。

• Redis Cluster：

  • 作用: 将数据分片 (Sharding) 存储在多个 Master 节点上，每个 Master 可以有多个 Slave。提供横向扩展和高可用性。
  • Docker 部署思路: 部署至少 3 个 Master 节点，每个 Master 至少一个 Slave，共 6 个节点是推荐的最小生产集群。通过 Docker Compose 编排多个 Redis 容器，并使用 Redis Cluster 的 redis-trib.rb 或 redis-cli --cluster 工具进行集群初始化。
  • 复杂性: 配置集群比 Sentinel 更复杂，需要处理数据分片、槽位分配等问题。

• 结合 Docker Swarm 或 Kubernetes:
  对于真正生产级的、高度自动化的 Redis 高可用部署，通常会结合更强大的容器编排工具：

  • Docker Swarm: 适用于较小的集群，可以在 Docker Swarm Mode 下部署 Redis Sentinel 或 Cluster。
  • Kubernetes (K8s): 行业标准的容器编排平台。有成熟的 Redis Operator (例如 KubeDB, Bitnami Redis Operator) 可以帮助您轻松部署和管理生产级的 Redis Sentinel 或 Cluster。Kubernetes 提供了 StatefulSets 来管理有状态服务，Persistent Volumes 来管理持久化存储，Service 来实现服务发现和负载均衡。

8.5 监控与管理

• docker stats: 实时查看容器的 CPU、内存、网络 I/O 等资源使用情况。
  bash
docker stats my-redis-compose
• RedisInsight 部署: RedisInsight 是一个功能强大的 Redis 可视化管理工具。它也可以部署在 Docker 中。
  bash
docker run -d \
-p 8001:8001 \
--name redis-insight \
redislabs/redisinsight:latest
  然后访问 http://localhost:8001，您可以添加 Redis 连接信息（host: my-redis-compose (如果启用了端口映射则为 127.0.0.1), port: 6379, password: your_strong_password_here）。
• Prometheus + Grafana: 结合 Redis Exporter (Docker 容器) 和 Prometheus、Grafana 可以构建专业的 Redis 监控仪表盘。

9. 故障排除与常见问题

• 容器无法启动:
  • 检查日志: docker logs <container_name>，通常能找到启动失败的原因，如配置文件错误、端口冲突、权限问题。
  • 端口冲突: 确保 -p 映射的宿主机端口没有被其他进程占用。
  • 配置文件错误: 仔细检查 redis.conf 语法，尤其是 daemonize no。
  • 权限问题: 如果使用 Bind Mounts，确保宿主机挂载目录对于容器内的 Redis 进程（通常是 redis 用户）有读写权限。
• 无法连接 Redis:
  • 检查端口映射: 确保 -p 参数正确，并且您连接的端口是宿主机端口。
  • 检查网络: 如果使用自定义网络，确保客户端容器与 Redis 容器在同一网络中，并且客户端使用正确的服务名称/别名连接。
  • 检查密码: 确保连接时提供了正确的密码 (AUTH 命令或客户端配置)。
  • 检查 bind 配置: 确保 redis.conf 中的 bind 地址允许客户端连接。对于容器内，通常是 bind 0.0.0.0。
  • 防火墙: 检查宿主机防火墙是否阻挡了 Redis 端口（6379）。
• 数据未持久化:
  • 检查卷挂载: 确保 -v 参数正确，且 Docker 卷或 Bind Mount 确实挂载到了容器的 /data 目录。
  • 检查 redis.conf: 确保 dir /data 配置正确，并且 RDB/AOF 持久化策略（save 和 appendonly）已启用。
  • 检查权限: 确保 Redis 进程对 /data 目录有写入权限。
• 性能问题:
  • 资源限制: 检查 Docker Compose 或 docker run 命令是否给 Redis 分配了足够的 CPU 和内存。
  • Swap: 在 Linux 上，Redis 开启持久化时应避免使用 Swap，可以通过 vm.overcommit_memory = 1 和禁用 Swap 来优化。
  • 网络 I/O: 检查宿主机网络是否存在瓶颈。
  • Redis 命令优化: 分析客户端应用使用的 Redis 命令，是否存在耗时操作（如 KEYS 命令）。
  • 监控: 使用 redis-cli MONITOR 或 RedisInsight 查看实时操作。

10. 总结与展望

通过本教程，您已经详细学习了如何使用 Docker 部署 Redis，从最基本的运行到实现数据持久化、自定义配置、网络管理，再到使用 Docker Compose 进行多服务编排。我们也探讨了生产环境下的资源限制、备份策略以及高可用性方案的概览。

Docker 为 Redis 的部署带来了前所未有的便利性和效率，使其成为现代云原生应用栈中不可或缺的一部分。掌握这些技能，您将能够更自信、更高效地管理和扩展您的 Redis 服务。

下一步您可以探索：

• 更深入地学习 Redis 的数据结构和使用场景。
• 研究 Redis Sentinel 和 Redis Cluster 的具体部署实践。
• 将 Docker Compose 部署扩展到更复杂的微服务架构。
• 学习 Docker Swarm 或 Kubernetes，以应对更高级的容器编排和大规模部署需求。

希望这篇详细的教程对您有所帮助！