Docker 安装 Redis 教程 – wiki基地

作者： /

容器化高性能缓存：Docker 安装 Redis 详细教程

在现代应用开发中，高性能、可扩展的数据存储和缓存机制是不可或缺的。Redis 作为一款流行的开源、内存中数据结构存储系统，常用于数据库、缓存和消息代理。它的高速读写能力和丰富的数据结构使其成为构建实时应用和微服务架构的理想选择。

与此同时，Docker 作为领先的容器化平台，彻底改变了我们构建、部署和运行应用程序的方式。它通过将应用程序及其所有依赖项打包到一个标准化的、可移植的单元中——即容器，解决了“在我的机器上可以运行”的问题。将 Redis 部署在 Docker 容器中，不仅可以享受到 Docker 带来的隔离性、一致性和可移植性，还能极大地简化 Redis 的安装、配置和管理过程。

本教程将带您从零开始，深入浅出地讲解如何在 Docker 环境中安装、配置和管理 Redis，涵盖从基本部署到数据持久化、高级配置、网络管理以及使用 Docker Compose 进行编排的方方面面。无论您是 Docker 新手还是经验丰富的开发者，都将从本教程中获益。

第一部分：Docker 与 Redis 概述

在深入实践之前，让我们先了解一下 Docker 和 Redis 的核心概念，以及为什么将它们结合起来是如此强大的组合。

1.1 什么是 Docker？

Docker 是一个开源平台，用于自动化应用程序的部署、扩展和管理。它使用容器技术，将应用程序及其运行所需的所有内容（代码、运行时、系统工具、系统库等）打包到一个独立的、轻量级的容器中。

Docker 的核心优势：
* 隔离性： 每个容器都是一个独立的运行环境，彼此之间互不干扰，即使它们运行在同一台主机上。
* 可移植性： 容器可以在任何支持 Docker 的环境中运行，无论是在开发者的笔记本电脑、测试服务器还是生产集群，都能保持一致的行为。
* 一致性： 解决了开发、测试和生产环境不一致导致的问题，保证了应用在不同环境中的行为一致。
* 效率： 容器启动速度快，资源占用少，因为它们共享宿主机的操作系统内核。
* 标准化： 提供标准化的打包和分发机制，简化了软件交付流程。

1.2 什么是 Redis？

Redis（Remote Dictionary Server）是一个开源的高性能键值对存储系统。它通常被称为数据结构服务器，因为它支持字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等多种数据结构。

Redis 的核心优势：
* 速度快： 数据存储在内存中，读写速度极快，常用于缓存和会话存储。
* 数据结构丰富： 支持多种高级数据结构，使得复杂的数据操作变得简单。
* 持久化： 虽然是内存数据库，但支持RDB（快照）和AOF（只追加文件）两种持久化方式，确保数据在服务器重启后不会丢失。
* 原子性： Redis 的所有操作都是原子性的，这意味着它们要么完全执行，要么完全不执行，不会出现中间状态。
* 高可用性： 支持主从复制和哨兵模式（Sentinel），提供高可用性和自动故障转移。

1.3 为什么要在 Docker 中运行 Redis？

将 Redis 部署在 Docker 容器中，可以充分利用两者的优势，带来诸多益处：

  • 环境隔离： 避免 Redis 与宿主机或其他应用程序之间的依赖冲突，确保 Redis 运行在一个干净、独立的环境中。
  • 快速部署： 几秒钟内即可启动一个 Redis 实例，无论是用于开发、测试还是生产环境。
  • 版本管理： 轻松切换不同版本的 Redis，例如同时运行 Redis 5.x 和 Redis 6.x 进行测试。
  • 资源控制： 可以为 Redis 容器分配特定的 CPU 和内存资源，防止它占用过多宿主机资源。
  • 可移植性： Redis 容器可以在任何 Docker 环境中无缝迁移，方便开发、测试和生产环境的统一。
  • 简化配置： 通过 Docker 卷（Volume）和环境变量，可以轻松管理 Redis 的配置文件和运行时参数。
  • 弹性扩展： 结合 Docker Swarm 或 Kubernetes 等容器编排工具，可以实现 Redis 的高可用和水平扩展。

第二部分：准备工作

在开始部署 Redis 之前，请确保您的系统已安装 Docker。

2.1 安装 Docker

如果您尚未安装 Docker，请根据您的操作系统（Windows、macOS、Linux）访问 Docker 官方文档进行安装：
* Docker Desktop (Windows/macOS): 访问 https://docs.docker.com/desktop/
* Docker Engine (Linux): 访问 https://docs.docker.com/engine/install/

安装完成后，打开终端或命令行工具，运行以下命令验证 Docker 是否安装成功：

bash
docker --version
docker compose version # 检查 Docker Compose (如果单独安装)
docker run hello-world

如果 hello-world 容器成功运行并显示欢迎信息，说明 Docker 已正确安装并可以正常工作。

2.2 基础 Docker 命令回顾

在后续教程中，我们将频繁使用以下 Docker 命令：
* docker pull <image_name>:<tag>：从 Docker Hub 下载镜像。
* docker images：列出本地所有镜像。
* docker run [OPTIONS] <image_name>:<tag> [COMMAND] [ARG...]：创建并启动一个新容器。
* docker ps：列出当前正在运行的容器。
* docker ps -a：列出所有容器（包括已停止的）。
* docker stop <container_name_or_id>：停止一个运行中的容器。
* docker start <container_name_or_id>：启动一个已停止的容器。
* docker rm <container_name_or_id>：删除一个容器。
* docker rmi <image_name_or_id>：删除一个镜像。
* docker exec -it <container_name_or_id> <command>：在运行中的容器内执行命令。
* docker logs <container_name_or_id>：查看容器的日志输出。

第三部分：部署一个基本的 Redis 容器

现在，我们开始部署第一个 Redis 容器。

3.1 拉取 Redis 镜像

首先，我们需要从 Docker Hub 下载 Redis 官方镜像。Redis 官方镜像由 Redis 维护，是最推荐的选择。您可以选择 latest 标签（始终指向最新稳定版），也可以选择特定的版本标签（例如 redis:6.2.7）以确保环境的稳定性。在生产环境中，强烈建议使用特定版本标签。

“`bash
docker pull redis:latest

或者指定版本，例如：

docker pull redis:6.2.7

“`

执行命令后，Docker 将从 Docker Hub 下载 Redis 镜像及其依赖层。您可以使用 docker images 命令查看已下载的镜像：

bash
docker images | grep redis

输出类似：
REPOSITORY TAG IMAGE ID CREATED SIZE
redis latest a0937c4d57c2 2 weeks ago 114MB

3.2 运行一个简单的 Redis 容器

现在，我们可以启动 Redis 容器了。我们将使用 docker run 命令。

bash
docker run -d --name my-redis-instance redis

让我们分解这个命令：
* -d：表示在后台“分离”（detached）模式运行容器。容器启动后，命令行会立即返回，而不会被容器的日志输出阻塞。
* --name my-redis-instance：为容器指定一个易于识别的名称，这里是 my-redis-instance。如果没有指定，Docker 会自动生成一个随机名称。
* redis：指定要运行的镜像名称，这里是 redis:latest（如果未指定标签，默认为 latest）。

运行此命令后，Docker 会创建一个新的容器并在后台启动 Redis 服务。您可以使用 docker ps 命令验证容器是否正在运行：

bash
docker ps

输出类似：
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a1b2c3d4e5f6 redis "docker-entrypoint.s…" 10 seconds ago Up 9 seconds 6379/tcp my-redis-instance

您可以看到 my-redis-instance 容器正在运行，并且 Redis 默认监听在容器内部的 6379/tcp 端口。

3.3 连接到 Redis 容器

有两种主要方式连接到 Redis 容器：从容器内部和从容器外部。

3.3.1 从容器内部连接 (使用 redis-cli)

Redis 镜像自带了 redis-cli 客户端工具。您可以使用 docker exec 命令进入容器内部或直接在容器内部执行 redis-cli。

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

  • docker exec：在运行中的容器内执行命令。
  • -it：
    • -i：保持 STDIN 打开，即使没有附加到它。
    • -t：分配一个伪 TTY。这两个标志结合使用，可以与容器进行交互式操作。
  • my-redis-instance：目标容器的名称。
  • redis-cli：要在容器内执行的命令。

执行此命令后，您会进入 Redis 命令行界面。您可以尝试一些基本的 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

这表明 Redis 容器已成功启动并可以正常工作。

3.3.2 从容器外部连接 (通过端口映射)

目前，您的 Redis 容器只在 Docker 内部网络中可见。如果想从宿主机或其他网络中的应用程序访问 Redis，您需要进行端口映射。

首先，停止并删除之前的容器：

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

现在，使用 -p 参数重新运行容器，将容器的 6379 端口映射到宿主机的 6379 端口：

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

  • -p 6379:6379：将宿主机的 6379 端口映射到容器的 6379 端口。格式是 HOST_PORT:CONTAINER_PORT。您也可以映射到宿主机的其他端口，例如 -p 6380:6379。

现在，您可以在宿主机上使用 redis-cli 连接到 Redis：

bash
redis-cli -h 127.0.0.1 -p 6379

如果您的宿主机上没有安装 redis-cli，您可以使用一个新的 Docker 容器来模拟客户端连接：

bash
docker run -it --rm --network host redis redis-cli -h 127.0.0.1 -p 6379

  • --network host：让新容器直接使用宿主机的网络栈，这样它就可以通过 127.0.0.1 访问宿主机上的映射端口。
  • --rm：容器停止后自动删除。

第四部分：数据持久化

运行 Redis 容器而不进行数据持久化，意味着一旦容器被删除或数据卷被销毁，所有数据都将丢失。这在生产环境中是不可接受的。Docker 提供了两种主要的数据持久化方式：Docker 卷（Volumes） 和 绑定挂载（Bind Mounts）。

Redis 默认将数据（RDB 快照文件和 AOF 文件）存储在容器内部的 /data 目录下。我们将利用这一点进行持久化。

4.1 方案一：使用 Docker 卷 (Volumes)

Docker 卷是 Docker 推荐的持久化数据的方式。它们由 Docker 管理，独立于容器的生命周期，通常存储在宿主机的文件系统中的特定位置（例如 /var/lib/docker/volumes）。

步骤：

  1. 创建 Docker 卷：
    bash
    docker volume create redis-data-volume
    您可以使用 docker volume ls 查看已创建的卷。

  2. 运行 Redis 容器并挂载卷：
    将 redis-data-volume 挂载到容器内部的 /data 目录。
    bash
    docker run -d \
    --name my-redis-persistent \
    -p 6379:6379 \
    -v redis-data-volume:/data \
    redis

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

  3. 测试数据持久化：
    连接到 Redis 容器，设置一些数据：
    bash
    docker exec -it my-redis-persistent redis-cli
    127.0.0.1:6379> SET mykey "This data should persist!"
    OK
    127.0.0.1:6379> SAVE # 手动触发RDB保存，确保数据写入磁盘
    OK
    127.0.0.1:6379> exit
    现在，停止并删除容器（但不要删除卷）：
    bash
    docker stop my-redis-persistent
    docker rm my-redis-persistent
    重新启动一个新的 Redis 容器，并再次挂载相同的卷：
    bash
    docker run -d \
    --name my-redis-restarted \
    -p 6379:6379 \
    -v redis-data-volume:/data \
    redis
    连接到新容器，检查数据是否存在：
    bash
    docker exec -it my-redis-restarted redis-cli
    127.0.0.1:6379> GET mykey
    "This data should persist!"
    127.0.0.1:6379> exit
    数据成功恢复，说明持久化配置生效。

4.2 方案二：使用绑定挂载 (Bind Mounts)

绑定挂载允许您将宿主机文件系统上的任意目录或文件直接挂载到容器中。这种方式的优点是您可以直接在宿主机上访问和管理 Redis 的数据文件。

步骤：

  1. 在宿主机上创建数据目录：
    选择一个合适的路径，例如 /opt/redis/data。
    bash
    mkdir -p /opt/redis/data
    # 确保 Docker 用户有权限写入此目录
    # 例如：sudo chown -R 1000:1000 /opt/redis/data (如果Redis容器以非root用户运行)

  2. 运行 Redis 容器并绑定挂载：
    bash
    docker run -d \
    --name my-redis-bindmount \
    -p 6379:6379 \
    -v /opt/redis/data:/data \
    redis

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

  3. 测试数据持久化：
    与 Docker 卷的测试方法相同。连接到 Redis 容器，设置数据，然后停止、删除容器，再重新启动。数据应能恢复。您还可以直接在宿主机的 /opt/redis/data 目录下看到 dump.rdb 或 appendonly.aof 等文件。

总结：
* Docker 卷（Volumes） 是更推荐的持久化方式，特别是在容器编排（如 Kubernetes）中。它们由 Docker 管理，具有更好的性能和移植性。
* 绑定挂载（Bind Mounts） 适用于需要直接访问宿主机文件系统的场景，例如在开发过程中查看或编辑配置文件。

第五部分：Redis 配置和自定义

Redis 提供了丰富的配置选项，通过 redis.conf 文件进行管理。在 Docker 中，我们可以通过绑定挂载自定义的 redis.conf 文件，或者通过环境变量传递部分配置。

5.1 使用自定义 redis.conf 文件

这是最灵活的配置方式，允许您完全控制 Redis 的所有参数。

步骤：

  1. 在宿主机创建配置文件目录：
    bash
    mkdir -p /opt/redis/conf

  2. 创建 redis.conf 文件：
    在 /opt/redis/conf 目录下创建一个名为 redis.conf 的文件。您可以从 Redis 官方 GitHub 仓库或已运行的 Redis 容器中获取默认配置文件的副本作为起点。
    “`bash
    # 示例 /opt/redis/conf/redis.conf 内容
    # 确保这是完整且有效的 Redis 配置文件

    绑定监听地址，只允许本地连接（更安全）

    bind 0.0.0.0 # 如果要从宿主机外部访问，需要监听所有接口，或者指定宿主机IP

    端口

    port 6379

    开启AOF持久化

    appendonly yes
    appendfilename “appendonly.aof”

    RDB持久化快照

    save 900 1 # 900秒（15分钟）内至少有1个key改变
    save 300 10 # 300秒（5分钟）内至少有10个key改变
    save 60 10000 # 60秒（1分钟）内至少有10000个key改变

    设置最大内存，例如 512MB

    maxmemory 512mb

    内存淘汰策略，例如 volatile-lru (对有过期时间的key使用LRU算法)

    maxmemory-policy allkeys-lru

    设置密码 (强烈建议在生产环境中使用)

    requirepass your_strong_password_here

    禁用保护模式（如果需要从外部连接且没有密码）

    protected-mode no

    注意：如果启用了密码且绑定0.0.0.0，protected-mode可以保持开启

    设置工作目录，Redis会将持久化文件写入此目录

    dir /data
    “`

  3. 运行 Redis 容器并挂载配置文件和数据卷：
    我们将挂载 redis.conf 文件到容器的 /etc/redis/redis.conf 路径，并告诉 Redis 服务器使用这个配置文件启动。
    bash
    docker run -d \
    --name my-redis-configured \
    -p 6379:6379 \
    -v /opt/redis/conf/redis.conf:/etc/redis/redis.conf \
    -v redis-data-volume:/data \
    redis redis-server /etc/redis/redis.conf

    • -v /opt/redis/conf/redis.conf:/etc/redis/redis.conf：将宿主机的 redis.conf 文件挂载到容器的 /etc/redis/redis.conf。
    • redis-server /etc/redis/redis.conf：这是关键！它覆盖了 Redis 镜像默认的启动命令，明确指示 Redis 服务器使用我们挂载的配置文件来启动。

  4. 验证配置：
    连接到 Redis 容器，并使用 AUTH 命令进行认证，然后检查配置。
    “`bash
    docker exec -it my-redis-configured redis-cli -a your_strong_password_here

    检查内存限制

    127.0.0.1:6379> CONFIG GET maxmemory
    1) “maxmemory”
    2) “536870912” # 512MB = 536870912 bytes

    检查AOF状态

    127.0.0.1:6379> CONFIG GET appendonly
    1) “appendonly”
    2) “yes”

    检查密码是否设置

    127.0.0.1:6379> INFO security

    Security

    …
    requirepass:your_strong_password_here
    …

    127.0.0.1:6379> exit
    “`
    如果配置都正确显示，说明自定义配置已成功加载。

5.2 通过环境变量进行部分配置

Redis 官方 Docker 镜像也支持通过环境变量进行一些基本配置，例如设置密码。这种方式在某些情况下比挂载完整配置文件更简洁，但不如前者灵活。

bash
docker run -d \
--name my-redis-env-password \
-p 6379:6379 \
-v redis-data-volume:/data \
-e REDIS_PASSWORD=another_strong_password \
redis
* -e REDIS_PASSWORD=another_strong_password：通过环境变量设置 Redis 的访问密码。

连接时需要使用密码：
bash
docker exec -it my-redis-env-password redis-cli -a another_strong_password

建议： 对于复杂的生产环境配置，强烈推荐使用自定义的 redis.conf 文件。环境变量适合简单的配置场景。

第六部分：Docker 网络配置

在 Docker 中，容器默认运行在 bridge 网络上，可以相互通信，但它们不直接暴露在宿主机网络上，除非您进行端口映射。对于更复杂的应用场景，例如多个服务需要相互发现和通信，Docker 提供了自定义网络。

6.1 宿主机与容器的通信（端口映射）

如前所述，使用 -p HOST_PORT:CONTAINER_PORT 参数可以将容器的端口暴露给宿主机。

bash
docker run -d --name my-redis-app \
-p 6379:6379 \
redis
应用程序现在可以在宿主机上通过 127.0.0.1:6379 访问 Redis。

安全性考虑： 生产环境中，如果 Redis 不需要从宿主机外部访问，最好将其绑定到 127.0.0.1，或者使用防火墙限制外部访问。在 redis.conf 中设置 bind 127.0.0.1 可以确保 Redis 只监听本地连接。如果同时需要通过容器 IP 访问，则需要考虑更复杂的网络配置，或者使用 Docker Compose 的服务发现。

6.2 容器与容器的通信（自定义网络）

当您有多个 Docker 容器（例如一个 Web 应用容器和一个 Redis 容器）需要相互通信时，自定义网络是最佳实践。它提供了服务发现（通过容器名称互相访问）和更好的隔离。

步骤：

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

  2. 运行 Redis 容器并加入网络：
    bash
    docker run -d \
    --name my-redis-networked \
    --network my-app-network \
    -v redis-data-volume:/data \
    redis

    • --network my-app-network：将 Redis 容器连接到 my-app-network 网络。

  3. 运行一个模拟应用容器并加入同一网络：
    我们将使用 busybox 镜像来模拟一个简单的应用程序，它将尝试连接到 Redis。
    bash
    docker run -it --rm \
    --name my-app-client \
    --network my-app-network \
    busybox sh
    进入 busybox 容器后，您可以尝试 ping Redis 容器：
    bash
    / # ping my-redis-networked
    PING my-redis-networked (172.18.0.2): 56 data bytes
    64 bytes from 172.18.0.2: seq=0 ttl=64 time=0.082 ms
    ...
    这表明 my-app-client 容器可以通过容器名称 my-redis-networked 解析到 Redis 容器的 IP 地址并进行通信。
    现在，您可以使用 redis-cli 连接到 Redis（如果 busybox 镜像包含 redis-cli，或者您使用一个包含 redis-cli 的镜像）：
    bash
    # 如果busybox没有redis-cli，我们可以用一个临时的redis客户端容器来测试
    docker run -it --rm --network my-app-network redis redis-cli -h my-redis-networked
    在 redis-cli 中：
    my-redis-networked:6379> PING
    PONG
    my-redis-networked:6379> exit
    这证明了在自定义网络中，容器可以通过其名称互相发现和通信。这对于微服务架构至关重要。

第七部分：使用 Docker Compose 编排 Redis

当您的应用程序包含多个服务（例如一个 Web 服务器、一个数据库、一个 Redis 缓存）时，使用 docker run 命令逐个启动和管理容器会变得复杂且容易出错。Docker Compose 是一个用于定义和运行多容器 Docker 应用程序的工具。它使用 YAML 文件来配置应用程序的服务，然后通过一个命令即可创建和启动所有服务。

7.1 为什么使用 Docker Compose？

  • 简化配置： 将所有服务配置（镜像、端口、卷、网络、环境变量等）集中在一个 docker-compose.yml 文件中。
  • 服务发现： 默认情况下，Compose 会为您的应用程序创建一个自定义网络，并允许服务通过其名称互相发现。
  • 单命令操作： 使用 docker-compose up 即可启动整个应用栈，docker-compose down 即可停止和移除。
  • 环境一致性： 确保开发、测试和生产环境的配置一致。

7.2 编写 docker-compose.yml 文件

在项目根目录下创建一个名为 docker-compose.yml 的文件。

“`yaml

docker-compose.yml

version: ‘3.8’ # 建议使用最新的 Compose 文件格式版本

services:
redis:
image: redis:6.2.7 # 明确指定Redis版本，避免不确定性
container_name: my-app-redis # 为容器指定一个易于识别的名称
restart: always # 容器退出时自动重启
ports:
– “6379:6379” # 将宿主机的6379端口映射到容器的6379端口
volumes:
– redis_data:/data # 挂载一个Docker卷用于数据持久化
– ./redis-conf/redis.conf:/etc/redis/redis.conf # 挂载自定义配置文件
command: redis-server /etc/redis/redis.conf # 使用自定义配置文件启动Redis
environment:
# 如果你的redis.conf中设置了requirepass，这里可以不设置
# 或者如果你想通过环境变量覆盖密码，可以在redis.conf中留空并在此设置
# REDIS_PASSWORD: “my_secure_compose_password”
networks:
– my-app-network # 将Redis容器连接到自定义网络

volumes:
redis_data: # 定义一个Docker卷，供redis服务使用

networks:
my-app-network: # 定义一个自定义网络，供应用内服务互相通信
driver: bridge

假设你还有一个web服务，它需要连接到redis

# web:
# image: your_web_app_image
# container_name: my-app-web
# ports:
# – “80:80”
# environment:
# REDIS_HOST: redis # 在自定义网络中，可以直接使用服务名称作为主机名
# REDIS_PORT: 6379
# # REDIS_PASSWORD: “my_secure_compose_password” # 如果Redis有密码
# depends_on:
# – redis # 确保redis服务在web服务之前启动
# networks:
# – my-app-network
“`

说明：
* version: 指定 Compose 文件格式版本。
* services: 定义应用程序包含的各个服务。
* redis: 这是我们的 Redis 服务。
* image: 使用 redis:6.2.7 镜像。
* container_name: 明确指定容器名称。
* restart: always: 保证容器在退出、重启 Docker 或系统重启后自动恢复运行。
* ports: 映射端口。
* volumes:
* redis_data:/data: 挂载一个名为 redis_data 的 Docker 卷到容器的 /data 目录。
* ./redis-conf/redis.conf:/etc/redis/redis.conf: 挂载宿主机当前目录下的 redis-conf/redis.conf 文件到容器的 /etc/redis/redis.conf。请确保您已在宿主机上创建 redis-conf 目录及 redis.conf 文件。
* command: 覆盖默认启动命令，使用我们自定义的 redis.conf。
* networks: 将服务连接到 my-app-network。
* volumes: 定义顶层卷，这里是 redis_data。Compose 会自动创建并管理这个卷。
* networks: 定义顶层网络，这里是 my-app-network。

准备配置文件：
在 docker-compose.yml 同级目录下创建 redis-conf 目录，并在其中创建 redis.conf 文件：

bash
mkdir redis-conf
redis-conf/redis.conf 示例内容：

“`

redis-conf/redis.conf

bind 0.0.0.0
port 6379
appendonly yes
dir /data
requirepass your_compose_password # 设置一个强密码
maxmemory 256mb
maxmemory-policy allkeys-lru
“`

7.3 启动和管理服务

进入 docker-compose.yml 文件所在的目录，然后执行：

bash
docker compose up -d
* up: 创建并启动 Compose 文件中定义的所有服务。
* -d: 在后台分离模式运行。

Compose 将会：
1. 下载 redis:6.2.7 镜像（如果本地没有）。
2. 创建 my-app-network 网络和 redis_data 卷（如果不存在）。
3. 启动 my-app-redis 容器。

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

bash
docker ps

连接到 Compose 部署的 Redis：

  1. 从宿主机连接：
    bash
    redis-cli -h 127.0.0.1 -p 6379 -a your_compose_password

  2. 从其他 Docker 容器（如果也在 my-app-network 中）连接：
    例如，您可以通过以下方式在一个临时容器中连接：
    bash
    docker run -it --rm --network my-app-network redis redis-cli -h redis -a your_compose_password
    注意：这里的 -h redis 是指 Compose 文件中服务的名称。

7.4 停止和移除服务

要停止并移除由 Compose 启动的所有服务、网络和卷（如果不是外部卷），请执行：

bash
docker compose down
如果您想保留数据卷，可以使用：

bash
docker compose down --volumes
这会移除容器和网络，但保留 redis_data 卷中的数据。

第八部分：安全和最佳实践

在生产环境中使用 Dockerized Redis 时，以下安全和最佳实践至关重要：

  1. 使用强密码： 始终为 Redis 设置 requirepass。在 redis.conf 中配置或通过环境变量设置。
  2. 网络隔离：
    • 如果 Redis 只需要内部服务访问，使用 Docker 自定义网络，不要暴露端口到宿主机外部。
    • 如果需要宿主机访问，将 Redis 绑定到 127.0.0.1 (bind 127.0.0.1 在 redis.conf 中)，并只映射到宿主机的本地端口，避免公网暴露。
    • 配置防火墙（如 ufw 或 firewalld）以限制对 Redis 端口的访问。
  3. 数据持久化： 始终使用 Docker 卷或绑定挂载进行数据持久化，以防止数据丢失。
  4. 资源限制： 为 Redis 容器设置 CPU 和内存限制，防止其占用过多宿主机资源，影响其他服务。
    • 例如：docker run --memory="512m" --cpus="0.5" ... 或在 Compose 文件中设置 resources。
  5. 监控和日志： 监控 Redis 容器的健康状况和性能指标，检查容器日志以排查问题。
    • docker logs <container_name>
    • docker stats <container_name>
    • 利用 Redis 的 INFO 命令获取运行时信息。
  6. 使用特定版本标签： 避免在生产环境中使用 redis:latest。锁定特定版本（如 redis:6.2.7）以确保环境的稳定性。
  7. 备份和恢复： 定期备份 Redis 的持久化数据（dump.rdb 或 appendonly.aof 文件）。
  8. 非 Root 用户运行： 默认情况下，Redis 容器以非 root 用户身份运行，这是一个好的安全实践。
  9. 禁用 protected-mode 要谨慎： 如果您从外部网络连接 Redis，并且没有设置密码，protected-mode 会阻止连接。如果您需要禁用它（protected-mode no），请务必同时设置强密码。
  10. AOF 和 RDB 配置： 根据您的数据敏感度和性能需求，合理配置 Redis 的 AOF 和 RDB 持久化策略。

第九部分：故障排除

部署过程中可能会遇到一些问题，以下是一些常见的故障及排查方法：

  1. 容器无法启动：

    • 检查容器日志： docker logs <container_name>。这通常会显示启动失败的原因，例如配置错误、端口冲突、文件权限问题。
    • 检查端口冲突： 如果宿主机端口已被占用，容器将无法启动。更改端口映射或停止占用端口的进程。
    • 配置文件错误： 如果是挂载了自定义 redis.conf，请检查文件内容是否有语法错误或不兼容的配置。

  2. redis-cli 无法连接：

    • 确认容器正在运行： docker ps。
    • 检查端口映射： 确保您使用的宿主机端口与容器内部 Redis 监听的端口正确映射。
    • 检查防火墙： 宿主机防火墙可能阻止了连接。
    • Redis 密码： 如果 Redis 设置了密码，请确保在 redis-cli 中使用 -a <password> 进行认证。
    • 网络问题： 如果在自定义网络中，确保客户端容器和 Redis 容器在同一个网络中，并且使用正确的服务名称或 IP 地址。

  3. 数据未持久化：

    • 检查卷挂载： 确保 -v 参数正确，并且卷已成功挂载到容器的 /data 目录。
    • 检查权限： 如果是绑定挂载，确保 Docker 用户对宿主机上的数据目录有读写权限。
    • 检查 Redis 配置： 确保 redis.conf 中没有禁用 RDB 或 AOF 持久化，并且 dir 参数设置为 /data。

  4. 容器意外退出：

    • 查看退出码： docker ps -a 查看 STATUS 列中的退出码。
    • 检查日志： docker logs <container_name>。容器意外退出通常会在日志中留下线索。

结语

通过本教程，您应该已经掌握了在 Docker 中部署和管理 Redis 的各种方法，包括：

  • 拉取 Redis 镜像并启动基本容器。
  • 通过端口映射从宿主机连接 Redis。
  • 使用 Docker 卷和绑定挂载实现数据持久化。
  • 通过自定义 redis.conf 文件进行高级配置。
  • 利用 Docker 自定义网络实现容器间通信。
  • 使用 Docker Compose 简化多服务应用的部署和管理。
  • 理解了 Dockerized Redis 的安全和最佳实践。
  • 掌握了常见的故障排除技巧。

将 Redis 容器化部署是现代应用架构的趋势，它不仅简化了部署和管理，还提升了应用程序的可移植性、可扩展性和韧性。随着您对 Docker 和 Redis 的熟练度不断提高，您将能够构建出更加健壮、高效的分布式系统。祝您在容器化的世界中玩得开心！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部