---

Redis Docker 入门教程：从零开始，拥抱容器化魅力

欢迎来到 Redis 和 Docker 的世界！本文将带你从零开始，一步步掌握如何在 Docker 中运行和管理 Redis。无论你是后端开发者、系统管理员还是对容器技术感兴趣的新手，这篇详细教程都能帮助你轻松上手。我们将深入探讨为什么要在 Docker 中使用 Redis，如何进行基本操作，以及如何处理数据持久化、配置和网络等实际应用中的关键问题。

目录

1. 引言：为什么选择 Redis？为什么选择 Docker？Redis + Docker 的优势
2. 准备工作：安装 Docker
3. Redis Docker 基础：拉取镜像、运行容器
   • 拉取 Redis 官方镜像
   • 运行第一个 Redis 容器
   • 测试 Redis 连接 (使用 redis-cli)
   • 停止和移除容器
4. 进阶实践：让 Redis 容器更实用
   • 后台运行 (Detached Mode)
   • 端口映射：从主机访问 Redis
   • 为容器命名：管理更便捷
5. 数据持久化：确保数据不丢失
   • 理解容器的生命周期与数据
   • 使用 Docker Volumes (推荐方式)
     • 创建 Volume
     • 运行容器并挂载 Volume
     • 验证数据持久性
     • 移除 Volume
   • 使用 Bind Mounts (适用于配置或特殊场景)
6. 配置 Redis：定制你的 Redis 实例
   • 默认配置
   • 使用自定义配置文件
     • 准备自定义配置文件
     • 使用 Bind Mount 挂载配置
     • 指定 Redis 使用新的配置
7. 网络配置：让其他应用连接 Redis
   • 默认 Bridge 网络的问题
   • 创建和使用用户自定义网络
     • 创建网络
     • 在网络中运行 Redis 容器
     • 在网络中运行应用容器并连接 Redis
8. 连接应用：在另一个容器中访问 Redis
9. 最佳实践与注意事项
   • 安全性：认证与网络暴露
   • 资源限制
   • 健康检查
   • 使用 Docker Compose 简化部署
10. 常见问题与故障排除
11. 总结

---

1. 引言：为什么选择 Redis？为什么选择 Docker？Redis + Docker 的优势

在开始技术实操之前，让我们先理解背景。

为什么选择 Redis？

Redis（Remote Dictionary Server）是一个开源的、基于内存的数据结构存储系统，可用作数据库、缓存和消息代理。它支持多种数据结构，如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等等。由于数据存储在内存中，Redis 提供了非常高的数据读写速度，通常用于：

• 缓存层： 缓解数据库压力，提高应用响应速度。
• 会话存储： 分布式应用中存储用户会话信息。
• 队列： 实现任务队列或消息发布/订阅。
• 实时排行榜/计数器： 快速更新和查询数据。

Redis 的高性能和丰富功能使其成为现代应用架构中不可或缺的一部分。

为什么选择 Docker？

Docker 是一个容器化平台，它允许开发者将应用程序及其所有依赖项（库、配置文件等）打包到一个称为“容器”的标准化单元中。容器是轻量级、可移植且自包含的。

使用 Docker 的主要优势包括：

• 环境一致性： 在开发、测试和生产环境中都能获得相同的运行环境，解决“在我的机器上可以运行”的问题。
• 隔离性： 每个容器运行在独立的环境中，互不影响。
• 可移植性： 容器可以在任何安装了 Docker 的机器上运行，无论是你的笔记本、虚拟机还是云服务器。
• 效率： 容器启动快速，资源占用少于传统虚拟机。
• 标准化： 提供标准化的打包和部署方式。

Redis + Docker 的优势

将 Redis 运行在 Docker 容器中，结合了两者的优点：

• 快速部署： 几条 Docker 命令就能拉取最新的 Redis 镜像并运行一个 Redis 实例，无需在主机上安装和配置 Redis。
• 环境隔离： Redis 实例运行在独立的容器中，不会污染主机环境，也不会与其他应用产生依赖冲突。
• 版本管理： 轻松切换不同版本的 Redis，或者同时运行多个不同版本的 Redis 实例。
• 可移植性： 将 Redis 配置和数据通过 Docker Volumes 或 Bind Mounts 管理，整个 Redis 实例（配置+数据）可以方便地在不同环境间迁移。
• 资源控制： 可以方便地为 Redis 容器设置 CPU、内存等资源限制。
• 简化运维： 容器的启停、删除、备份、恢复等操作都变得标准化且简单。

综上所述，在 Docker 中运行 Redis 是一个高效、便捷且符合现代DevOps实践的方式。

2. 准备工作：安装 Docker

在开始之前，你需要在你的操作系统上安装 Docker。Docker 提供了适用于 Windows、macOS 和多种 Linux 发行版的安装包。

• 对于 Windows 和 macOS： 推荐安装 Docker Desktop。它包含 Docker Engine、Docker CLI、Docker Compose、Kubernetes（可选）等工具，并提供友好的图形界面。访问 Docker Desktop 下载页面 下载并按照指引安装。
• 对于 Linux： 可以直接安装 Docker Engine 和 Docker CLI。访问 Docker Engine 安装页面 选择你的发行版并按照指引安装。安装完成后，建议设置非 root 用户运行 Docker 的权限（通过创建 docker 用户组）。

安装完成后，打开终端（或命令提示符），运行以下命令验证 Docker 是否安装成功：

bash
docker --version
docker run hello-world

docker --version 会显示 Docker 的版本信息。docker run hello-world 会拉取一个很小的测试镜像并在容器中运行它，如果一切正常，你会看到 Docker 的欢迎信息，这说明 Docker Engine 正在正常工作。

现在，你已经准备好在 Docker 中运行 Redis 了！

3. Redis Docker 基础：拉取镜像、运行容器

Redis 官方在 Docker Hub 上维护了一个官方的 Redis 镜像，这是我们推荐使用的镜像。

3.1 拉取 Redis 官方镜像

在使用任何 Docker 镜像之前，你需要将它从 Docker Hub 或其他镜像仓库拉取到你的本地机器上。

打开终端，运行以下命令拉取最新的 Redis 官方镜像：

bash
docker pull redis

这条命令会拉取 redis:latest 镜像。latest 是默认标签，表示拉取最新稳定版本。如果你需要特定版本的 Redis，可以指定标签，例如：

bash
docker pull redis:6.2
docker pull redis:7.0

首次拉取需要从网络下载镜像文件，可能需要一些时间，取决于你的网络速度。如果本地已经存在该镜像，Docker 会检查更新并下载最新的层。

你可以通过以下命令查看本地已有的镜像：

bash
docker images

你会看到列表中包含 redis 镜像及其标签、ID、创建时间和大小。

3.2 运行第一个 Redis 容器

镜像只是一个模板，要使用 Redis，你需要从镜像创建一个并运行它，这就是“容器”。

运行一个最基本的 Redis 容器的命令如下：

bash
docker run redis

执行这条命令后：

1. Docker 会检查本地是否有 redis:latest 镜像，如果没有会自动拉取（如果之前没拉取过 docker pull 会在这里发生）。
2. Docker 会基于 redis:latest 镜像创建一个新的容器。
3. Docker 会启动这个容器，容器内的入口命令（Entrypoint）会启动 Redis 服务器进程。

你会看到 Redis 服务器启动时的日志信息直接打印在你的终端上。此时，你的终端被这个容器的日志占用，你无法输入其他命令。这是一个前台运行的容器。

Redis 默认监听 6379 端口。然而，仅仅运行 docker run redis，这个 Redis 实例只在容器内部的私有网络中监听 6379 端口，你的主机或其他外部机器是无法直接访问它的。我们将在后续章节介绍如何进行端口映射和网络配置。

3.3 测试 Redis 连接 (使用 redis-cli)

既然 Redis 已经在容器里运行了，我们怎么连接并操作它呢？最简单的方式是利用 redis-cli，它通常包含在 Redis 镜像中。我们可以通过 docker exec 命令在运行中的容器内部执行命令。

首先，你需要找到正在运行的 Redis 容器的 ID 或名称。打开一个新的终端窗口（不要关闭运行 Redis 容器的那个终端，因为它正在前台运行）。

运行以下命令查看正在运行的容器：

bash
docker ps

你会看到一个列表，其中有一行对应你的 Redis 容器。记下它的 CONTAINER ID（例如 a1b2c3d4e5f6）。

现在，使用 docker exec 命令在容器内部启动 redis-cli：

bash
docker exec -it <CONTAINER ID> redis-cli

将 <CONTAINER ID> 替换为你实际的容器 ID。

• -it 参数：-i 表示保持标准输入（stdin）打开，-t 表示分配一个伪终端（pseudo-TTY）。这两个参数通常一起使用，让你可以在容器内部进行交互式操作，就像登录到容器一样。

执行后，你会看到 127.0.0.1:6379> 的提示符，这说明你已经成功连接到容器内部的 Redis 服务器了！

现在你可以输入一些 Redis 命令来测试：

redis
PING

你应该会收到 PONG 的回复。

redis
SET mykey "Hello Docker Redis"

如果成功，你会收到 OK。

redis
GET mykey

你应该会收到 "Hello Docker Redis"。

redis
QUIT

输入 QUIT 退出 redis-cli 客户端。

回到第一个终端窗口，你会看到 Redis 服务器记录了这些连接和操作的日志。

3.4 停止和移除容器

在前台运行的终端窗口中，按下 Ctrl+C。这会向容器发送一个中断信号，Redis 进程会收到信号并优雅地关闭。容器停止运行。

再次运行 docker ps，你会发现 Redis 容器不再显示在运行列表中。

要查看所有容器（包括已停止的），运行：

bash
docker ps -a

你会看到你的 Redis 容器状态是 Exited。

停止的容器仍然占用磁盘空间和资源（虽然很少）。如果你不再需要它，可以移除它。

使用容器 ID 或名称（稍后会讲到如何命名）移除容器：

bash
docker rm <CONTAINER ID>

将 <CONTAINER ID> 替换为你的容器 ID。

如果你想强制停止并移除一个正在运行的容器（不推荐，可能导致数据丢失），可以使用 -f 标志：

bash
docker rm -f <CONTAINER ID>

注意： docker rm 只移除容器本身，不会移除与该容器关联的 Volume（稍后会讨论）。

通过 docker pull, docker run, docker exec, docker ps, docker stop, docker rm 这几个基本命令，你已经掌握了 Docker 中 Redis 容器的最基础生命周期管理。

4. 进阶实践：让 Redis 容器更实用

前面的例子让 Redis 在前台运行，且只能通过 docker exec 在容器内部访问，这在实际应用中很不方便。接下来我们学习如何让容器在后台运行，并从主机或其他地方访问它。

4.1 后台运行 (Detached Mode)

通常我们希望服务器进程在后台运行，不占用终端。这可以通过 -d 参数实现，也称为“分离模式”（Detached mode）。

bash
docker run -d redis

执行这条命令后，Docker 会在后台启动 Redis 容器，并立即打印出容器的完整 ID。你的终端会立即返回提示符，可以继续输入其他命令。

运行 docker ps，你会看到 Redis 容器正在后台运行。

要查看后台容器的日志，可以使用 docker logs 命令加上容器 ID 或名称：

bash
docker logs <CONTAINER ID or NAME>

4.2 端口映射：从主机访问 Redis

要在主机或其他网络中的机器上访问容器内部的 Redis 服务，你需要将容器内部的端口映射到主机上的端口。Redis 默认监听 6379 端口。

使用 -p 参数进行端口映射：host_port:container_port。

例如，将容器内部的 6379 端口映射到主机的 6379 端口：

bash
docker run -d -p 6379:6379 redis

• -d: 后台运行。
• -p 6379:6379: 将主机的 6379 端口映射到容器内部的 6379 端口。

现在，你可以在主机上安装 redis-cli 工具（如果还没有的话），然后像连接本地 Redis 服务一样连接它：

bash
redis-cli -h localhost -p 6379

或者简单地：

bash
redis-cli

因为 redis-cli 默认就尝试连接 localhost:6379。

你也可以将容器端口映射到主机上的 其他 端口，例如映射到主机的 6380 端口：

bash
docker run -d -p 6380:6379 redis

此时，你需要连接主机的 6380 端口：

bash
redis-cli -h localhost -p 6380

4.3 为容器命名：管理更便捷

使用容器 ID 来管理容器（停止、移除、查看日志等）非常麻烦，因为 ID 是一长串随机字符。通过 --name 参数可以为容器指定一个易于记忆的名称。

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

• -d: 后台运行。
• -p 6379:6379: 端口映射。
• --name my-redis: 将容器命名为 my-redis。容器名称必须是唯一的。

现在，你可以使用 my-redis 作为容器的标识符来执行各种 Docker 命令：

bash
docker ps -a # 查看所有容器，包括名称
docker stop my-redis # 停止容器
docker start my-redis # 启动容器
docker restart my-redis # 重启容器
docker logs my-redis # 查看日志
docker rm my-redis # 移除容器 (容器必须先停止)
docker exec -it my-redis redis-cli # 在容器内部执行命令

使用 --name 大大地提高了容器的可管理性。

5. 数据持久化：确保数据不丢失

默认情况下，Redis 容器中的数据存储在容器的可写层。当你停止并移除容器后，容器的可写层也会被删除，这意味着你的 Redis 数据将丢失。对于数据库或缓存服务来说，数据持久化至关重要。Docker 提供了 Volumes 和 Bind Mounts 两种主要方式来实现数据持久化。

5.1 理解容器的生命周期与数据

容器设计为是临时的。容器内部的文件系统更改（写入数据、创建文件等）发生在容器顶部的可写层。移除容器 (docker rm) 会删除这个可写层，从而丢失所有这些更改。

为了保存数据，你需要将数据存储在容器外部，并将其“挂载”到容器内部的特定路径上。这样，即使容器被删除，外部存储的数据仍然存在。

Redis 默认将数据（RDB 文件或 AOF 文件）存储在容器内部的 /data 目录中。官方 Redis 镜像也配置为使用 /data 作为其工作目录，如果启动时/data目录中存在持久化文件（dump.rdb或appendonly.aof），则会加载这些数据。因此，我们要做的就是将主机的某个位置（Volume 或 Bind Mount）挂载到容器内部的 /data 目录。

5.2 使用 Docker Volumes (推荐方式)

Docker Volumes 是 Docker 管理数据持久化的推荐方式。它们完全由 Docker 管理，创建、管理和存储位置都由 Docker 控制，通常位于主机上的 /var/lib/docker/volumes/ 目录下（具体位置可能因操作系统而异）。Docker Volumes 的优势在于：

• 易于备份和迁移： Volumes 是独立于容器的，可以方便地备份、恢复或迁移。
• 高性能： Volumes 不会受到存储驱动的性能影响，通常比 Bind Mounts 性能更好。
• 安全性： Volume 的内容默认只有 Docker 可以访问，相比 Bind Mounts 暴露主机文件系统更安全。
• 跨平台兼容性： 在不同操作系统上行为一致。

步骤 1: 创建一个 Docker Volume

首先，创建一个名为 my-redis-data 的 Volume：

bash
docker volume create my-redis-data

你可以使用 docker volume ls 查看所有 Volume，使用 docker volume inspect my-redis-data 查看 Volume 的详细信息，包括它在主机上的实际存储路径（Mountpoint 字段）。

步骤 2: 运行容器并挂载 Volume

使用 -v 参数将创建的 Volume 挂载到容器内部 Redis 存放数据的 /data 目录：volume_name:container_path。

bash
docker run -d \
--name my-redis-with-volume \
-p 6379:6379 \
-v my-redis-data:/data \
redis

• -d: 后台运行。
• --name my-redis-with-volume: 容器命名。
• -p 6379:6379: 端口映射。
• -v my-redis-data:/data: 关键步骤！ 将名为 my-redis-data 的 Volume 挂载到容器内部的 /data 目录。Redis 会将持久化文件（如 dump.rdb）写入这个目录，而这些文件实际上会存储在 my-redis-data Volume 中。

步骤 3: 验证数据持久性

连接到这个 Redis 实例，设置一些数据：

“`bash
redis-cli

或 redis-cli -h localhost -p 6379 如果映射了其他端口

“`

在 redis-cli 中执行：

redis
SET volume_test "Data should persist!"
SAVE # 强制Redis进行一次同步保存到RDB文件
GET volume_test

确认能够成功设置和获取数据。SAVE 命令强制 Redis 将内存中的数据保存到 /data/dump.rdb 文件中（假设你没有开启 AOF，或者默认配置是 RDB 持久化）。

现在，停止并移除当前的 Redis 容器：

bash
docker stop my-redis-with-volume
docker rm my-redis-with-volume

请注意，docker rm 命令不会删除与之关联的 Volume (my-redis-data)。Volume 仍然存在。

现在，使用同一个 Volume 名称启动一个新的 Redis 容器：

bash
docker run -d \
--name my-new-redis-with-volume \
-p 6379:6379 \
-v my-redis-data:/data \
redis

连接到新的 Redis 实例：

bash
redis-cli

尝试获取之前设置的数据：

redis
GET volume_test

你应该会看到 "Data should persist!" 的输出。这证明了尽管容器被移除了，但数据保存在 Volume 中，并在新的容器启动时被加载了。

步骤 4: 移除 Volume (当不再需要时)

如果确定不再需要这个 Volume 中的数据，可以手动移除它：

bash
docker volume rm my-redis-data

如果 Volume 当前正被某个容器使用，你将无法移除它，Docker 会提示错误。你需要先停止并移除使用该 Volume 的容器。

5.3 使用 Bind Mounts (适用于配置或特殊场景)

Bind Mounts 允许你将主机上的一个文件或目录直接挂载到容器内部的指定路径。与 Volumes 不同，Bind Mounts 需要你指定主机上的绝对路径，且 Docker 不管理 Bind Mount 的生命周期。

Bind Mounts 更常用于：

• 将主机上的配置文件挂载到容器中。
• 将主机上的源代码挂载到开发容器中。

我们将 Bind Mount 用于配置文件的场景（下一节）。对于 Redis 数据持久化，强烈推荐使用 Volumes 而不是 Bind Mounts，因为 Volumes 的管理更方便，也更符合 Docker 的设计理念。如果非要用 Bind Mount 进行数据持久化，命令会是这样：

“`bash

创建主机上的一个目录用于存放数据，例如 /path/to/your/redis/data

mkdir -p /path/to/your/redis/data

docker run -d \
–name my-redis-with-bind-mount \
-p 6379:6379 \
-v /path/to/your/redis/data:/data \
redis
“`

这里的 /path/to/your/redis/data 是主机上的一个目录的绝对路径。你需要确保 Docker 进程（或运行 Docker 的用户）有权限访问这个目录。这种方式的缺点是，如果你将容器迁移到另一台主机，你需要手动确保该路径下的数据也同步过去。

6. 配置 Redis：定制你的 Redis 实例

Redis 有丰富的配置选项，如设置密码、修改端口、配置持久化方式（RDB/AOF）、最大内存限制等。官方 Redis 镜像允许你通过多种方式提供自定义配置。

6.1 默认配置

如果你直接运行 docker run redis，Redis 会使用其默认配置启动。你可以通过查看容器日志或连接到容器内部查看配置文件来了解默认配置。

默认的 redis.conf 文件通常位于容器内部的 /usr/local/etc/redis/redis.conf。

6.2 使用自定义配置文件

最灵活的方式是准备一个自定义的 redis.conf 文件，然后使用 Bind Mount 将它挂载到容器内部 /usr/local/etc/redis/redis.conf 的位置，并告诉 Redis 使用这个文件启动。

步骤 1: 准备自定义配置文件

在你的主机上创建一个目录（例如 ~/redis-config），并在其中创建一个 redis.conf 文件。你可以从 Redis 官方仓库下载一个完整的 redis.conf 文件作为起点进行修改，或者从零开始只包含你需要修改的配置项。

例如，创建一个简单的 redis.conf 文件，设置一个连接密码：

“`conf

~/redis-config/redis.conf

requirepass your_secret_password

appendonly yes # 启用 AOF 持久化 (如果需要)

maxmemory 100mb # 设置最大内存

maxmemory-policy allkeys-lru # 设置内存淘汰策略

“`

请替换 your_secret_password 为一个安全的密码。

步骤 2: 使用 Bind Mount 挂载配置

使用 -v 参数将主机上的配置文件挂载到容器内部 Redis 配置文件所在的路径：host_path:container_path。

bash
docker run -d \
--name my-redis-config \
-p 6379:6379 \
-v my-redis-data:/data \
-v ~/redis-config/redis.conf:/usr/local/etc/redis/redis.conf \
redis

• -v my-redis-data:/data: 这是我们之前讲到的数据持久化，依然需要挂载。
• -v ~/redis-config/redis.conf:/usr/local/etc/redis/redis.conf: 关键步骤！ 将主机上的 ~/redis-config/redis.conf 文件挂载到容器内部的 /usr/local/etc/redis/redis.conf 位置。请确保使用主机上文件的绝对路径。

步骤 3: 指定 Redis 使用新的配置

默认情况下，官方 Redis 镜像的 Entrypoint 会启动 redis-server 进程，并且如果 /usr/local/etc/redis/redis.conf 文件存在，它会自动使用它。所以，上一步的命令通常已经足够。

但在某些情况下，或者为了明确指定，你可以在 docker run 命令的末尾添加 Redis 启动命令及其参数。官方镜像的默认启动命令是 redis-server /usr/local/etc/redis/redis.conf（如果文件存在的话）。如果你想覆盖这个行为，可以这样做：

bash
docker run -d \
--name my-redis-config-explicit \
-p 6379:6379 \
-v my-redis-data:/data \
-v ~/redis-config/redis.conf:/usr/local/etc/redis/redis.conf \
redis redis-server /usr/local/etc/redis/redis.conf

这里的 redis-server /usr/local/etc/redis/redis.conf 会覆盖镜像默认的启动命令，确保 Redis 使用你提供的配置文件启动。对于官方 Redis 镜像，这种明确指定通常不是必须的，但理解 Entrypoint 和 CMD 的工作方式有助于更灵活地使用镜像。

验证配置

连接到设置了密码的 Redis 实例，你会发现直接输入命令会提示错误（NOAUTH Authentication required.）。

“`bash
redis-cli

或 redis-cli -h localhost -p 6379

“`

在 redis-cli 中输入：

redis
PING

输出：(error) NOAUTH Authentication required.

需要先进行认证：

redis
AUTH your_secret_password

输出：OK

现在你可以正常使用 Redis 命令了：

redis
PING

输出：PONG

通过挂载自定义配置文件，你可以完全控制 Redis 的行为和性能参数。

7. 网络配置：让其他应用连接 Redis

在多容器应用中，你通常不希望通过端口映射 (-p) 让数据库或缓存服务直接暴露在主机网络上，而是希望应用容器和数据服务容器在同一个内部网络中进行通信。Docker 的用户自定义网络（User-defined networks）为此提供了解决方案。

7.1 默认 Bridge 网络的问题

当你运行 docker run 但不指定网络时，容器默认连接到 Docker 的 bridge 网络。这个网络允许容器通过 IP 地址互相通信，并且可以通过端口映射 (-p) 从主机访问容器。

然而，在默认 bridge 网络中，容器之间的通信依赖于 IP 地址，而容器的 IP 地址是动态分配的，重启容器后可能会改变。这使得应用容器难以可靠地找到 Redis 容器。虽然旧版本的 Docker 有 --link 机制，但它已被视为遗弃（legacy）并不推荐使用。

7.2 创建和使用用户自定义网络

用户自定义网络（通常是 bridge 类型的）提供更好的隔离性和服务发现。连接到同一个用户自定义网络的容器可以通过容器名称相互访问，Docker 会负责名称解析（内置 DNS 服务）。

步骤 1: 创建一个网络

创建一个名为 my-app-net 的自定义网络：

bash
docker network create my-app-net

你可以使用 docker network ls 查看所有网络。

步骤 2: 在网络中运行 Redis 容器

使用 --network 参数将 Redis 容器连接到新创建的网络：

bash
docker run -d \
--name my-redis-networked \
--network my-app-net \
-v my-redis-data:/data \
-v ~/redis-config/redis.conf:/usr/local/etc/redis/redis.conf \
redis redis-server /usr/local/etc/redis/redis.conf

• --network my-app-net: 将容器连接到 my-app-net 网络。
• 注意： 这里通常不需要 -p 参数进行端口映射了，因为我们希望其他容器通过网络访问 Redis，而不是从主机直接访问。当然，如果你同时需要从主机访问（例如使用 redis-cli），你也可以保留 -p 参数。

现在，my-redis-networked 容器运行在 my-app-net 网络中。

步骤 3: 在网络中运行应用容器并连接 Redis

假设你有一个应用程序容器（例如使用 Python 镜像模拟）：

bash
docker run -it --rm \
--name my-app \
--network my-app-net \
python:3.9-slim \
bash

• -it: 交互式终端。
• --rm: 容器停止后自动移除。
• --name my-app: 容器命名。
• --network my-app-net: 关键步骤！ 将应用容器也连接到 my-app-net 网络，使其能够发现并连接 Redis 容器。
• python:3.9-slim bash: 运行一个 Python 容器并在其中启动 bash 终端。

进入应用容器的 bash 终端后，你需要安装一个 Redis 客户端库（例如 redis-py）：

bash
pip install redis

然后，你可以尝试连接 Redis。在同一个网络中的容器，可以使用容器名称作为主机名进行连接。Redis 的默认端口是 6379。

在 bash 终端中启动 Python 交互式环境：

bash
python

在 Python 环境中：

“`python
import redis

使用 Redis 容器的名称作为 host

如果设置了密码，需要认证

r = redis.Redis(host=’my-redis-networked’, port=6379, db=0, password=’your_secret_password’)

测试连接

print(r.ping())

设置和获取数据

r.set(‘app_key’, ‘Data from application’)
print(r.get(‘app_key’))
“`

如果一切正常，你会看到 True 和 b'Data from application' 的输出。

这个例子演示了如何使用用户自定义网络让应用容器通过 Redis 容器的名称 (my-redis-networked) 稳定地连接到 Redis 服务，而无需知道其动态分配的 IP 地址或通过主机端口转发。这是多容器应用之间通信的标准和推荐方式。

8. 连接应用：在另一个容器中访问 Redis

上一节的网络配置已经详细演示了这一点。核心思想是：

1. 创建 一个用户自定义网络 (docker network create my-app-net)。
2. 将 Redis 容器 连接到该网络 (--network my-app-net --name my-redis)。
3. 将 应用程序容器 也连接到该网络 (--network my-app-net --name my-web-app)。
4. 在应用程序代码中，使用 Redis 容器的名称 (my-redis) 作为连接的主机名，端口使用 Redis 默认的 6379 端口。

例如，在 Node.js 应用中：

“`javascript
const redis = require(‘redis’);
const client = redis.createClient({
url: ‘redis://my-redis:6379’, // 使用容器名称作为hostname
password: ‘your_secret_password’ // 如果设置了密码
});

client.on(‘error’, (err) => console.log(‘Redis Client Error’, err));

async function connectRedis() {
await client.connect();
console.log(‘Connected to Redis!’);
await client.set(‘node_key’, ‘Hello from Node.js’);
const value = await client.get(‘node_key’);
console.log(‘Retrieved from Redis:’, value);
// await client.quit(); // 或在需要时关闭连接
}

connectRedis();
“`

在 Java Spring Boot 应用中（使用 Lettuce 客户端为例）：

“`java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.RedisURI;

@Configuration
public class RedisConfig {

@Bean
public StatefulRedisConnection<String, String> redisConnection() {
    // 构建 Redis 连接 URI
    // redis://[password@]host[:port][/database]
    RedisURI redisUri = RedisURI.create("redis://your_secret_password@my-redis:6379/0");

    RedisClient redisClient = RedisClient.create(redisUri);
    StatefulRedisConnection<String, String> connection = redisClient.connect();

    System.out.println("Connected to Redis!");
    // 测试连接
    connection.sync().set("java_key", "Hello from Java");
    System.out.println("Retrieved from Redis: " + connection.sync().get("java_key"));

    return connection;
}

// 应用停止时关闭连接的 Bean 或 Hook

}
“`

通过用户自定义网络和容器名称，容器间的服务发现变得简单而可靠。

9. 最佳实践与注意事项

在使用 Docker 运行生产环境的 Redis 时，还需要考虑以下几点：

• 安全性：
  • 认证： 始终为 Redis 设置密码 (requirepass)，尤其是在非隔离的网络环境中。通过挂载自定义配置文件实现。
  • 网络暴露： 除非必要，不要将 Redis 容器端口 (6379) 直接映射到主机公网 IP 上。优先使用用户自定义网络，只在服务网关或反向代理后面暴露应用端口。
• 资源限制： 使用 --cpus, --memory 参数为 Redis 容器设置合理的资源限制，防止 Redis 因内存不足（OOM）或 CPU 占用过高影响其他服务或主机稳定性。例如：--memory 512m --cpus 0.5。
• 健康检查： 在生产环境中，配置 Docker 或容器编排工具（如 Docker Compose, Kubernetes）的健康检查，定期探测 Redis 实例是否正常响应（例如使用 redis-cli ping），以便在 Redis 不健康时自动重启或替换容器。
• 生产环境的持久化： 确保使用 Docker Volumes 或挂载到可靠的存储位置。定期备份 Volume 数据。配置 Redis 内部的 RDB 或 AOF 持久化策略。
• 高可用与集群： 单个 Redis 实例存在单点故障风险。对于需要高可用的场景，考虑部署 Redis Sentinel（主从复制+自动故障转移）或 Redis Cluster（分片+高可用）。虽然这些部署比单个实例复杂，但同样可以在 Docker 中实现，通常需要多个 Redis 容器和 Sentinel 容器，并使用用户自定义网络连接它们。这超出了本入门教程的范围，但在规划生产环境时应予以考虑。
• 使用 Docker Compose： 当你的应用包含多个服务（如 Web 应用、API、数据库、缓存等）时，使用 Docker Compose 可以通过一个简单的 YAML 文件来定义、配置和管理整个应用栈的服务（包括网络、Volumes 等），极大地简化了部署和管理流程。

10. 常见问题与故障排除

• docker run 容器启动后立即退出： 运行 docker logs <容器名称或ID> 查看容器的日志输出。这通常会显示 Redis 启动失败的原因，比如配置文件错误、端口被占用、内存不足等。
• 端口已被占用： 如果使用 -p host_port:container_port 时提示 port is already allocated，说明主机上的 host_port 已经被其他进程使用了。你需要更改主机端口，或者停止占用该端口的进程。
• 无法连接到 Redis (即使做了端口映射)：
  • 检查容器是否正在运行 (docker ps)。
  • 检查端口映射是否正确 (docker ps 会显示端口映射信息)。
  • 检查防火墙设置，确保主机端口（如 6379）允许外部或本地连接。
  • 如果设置了 Redis 密码，确保客户端连接时提供了正确的密码。
  • 如果使用用户自定义网络，确保客户端和 Redis 容器都在同一个网络中，并且客户端使用了正确的容器名称作为主机名。
• Volume 挂载权限问题： 如果使用 Bind Mount 挂载主机目录，确保 Docker 进程或容器内的用户有权限读写该目录。对于 Linux，这可能涉及用户/组权限或 SELinux/AppArmor 配置。Docker Volumes 通常没有这个问题，因为它们由 Docker 管理。
• 数据未持久化： 检查是否正确使用了 -v 参数将 Volume 或 Bind Mount 挂载到了容器内部 Redis 默认的数据目录 (/data)。同时，检查 Redis 配置是否启用了持久化（RDB 或 AOF）。

11. 总结

恭喜你！通过这篇教程，你已经掌握了在 Docker 中运行 Redis 的基础和进阶技巧。我们学习了：

• 为什么 Redis 和 Docker 是强大的组合。
• 如何拉取官方 Redis 镜像并运行容器。
• 使用 docker exec 连接容器内部的 redis-cli。
• 让容器后台运行、进行端口映射和为容器命名，提高可用性。
• 最重要的数据持久化： 使用 Docker Volumes 将 Redis 数据存储在容器外部，确保数据不丢失。
• 通过 Bind Mount 挂载自定义 redis.conf 文件来配置 Redis。
• 利用用户自定义网络实现容器间的服务发现，让应用容器通过名称连接 Redis。
• 了解了在生产环境中运行 Redis Docker 实例的一些最佳实践和注意事项。

现在，你可以自信地在开发、测试甚至生产环境中使用 Docker 来管理你的 Redis 实例了。随着你对 Docker 和 Redis 的深入使用，你会发现更多它们结合带来的便利。

继续探索 Docker Compose，它会让你部署包含 Redis 的多服务应用变得更加轻松。同时，深入学习 Redis 的高级特性和持久化、复制、Sentinel、Cluster 等高可用方案，并研究如何在 Docker 环境中进行部署。

希望这篇详细的教程对你有所帮助！容器化你的 Redis 实例，享受带来的便捷和高效吧！