从单机到集群：Docker、Kubernetes 与 Helm 部署 Redis 全攻略

一、使用 Docker 部署 Redis 单机版

在本文中，我们将通过 Docker 部署一个 Redis 单机版实例，并使用自定义的 redis.conf 配置文件。以下是详细的部署步骤。

步骤 1：获取 redis.conf 配置文件

要开始部署 Redis，我们需要一个配置文件 redis.conf。你可以通过以下方式获取该配置文件：

1. 从 Redis 官方获取 ：

   使用以下命令从 Redis 官方 GitHub 仓库下载最新的 redis.conf 配置文件：

   curl -O https://raw.githubusercontent.com/redis/redis/6.0/redis.conf

   下载完成后，你可以将文件移动到 /data/redis/conf/redis.conf 目录：

   mkdir -p /data/redis/conf
   mv redis.conf /data/redis/conf/redis.conf

2. 从 Docker 镜像获取 ：

   如果你已经在本地运行了 Redis Docker 容器，可以从容器中提取配置文件：

   docker run --rm redis:6.0 cat /etc/redis/redis.conf > /data/redis/conf/redis.conf

   这样可以直接从 Redis 官方镜像获取配置文件，并保存到本地路径。

配置文件示例：redis.conf

以下是一个示例的 redis.conf 配置文件内容。你可以根据需求进行修改：

# Redis configuration file example

# 绑定地址
bind 0.0.0.0

# 保护模式（如果设置为 yes，Redis 会阻止外部网络连接）
protected-mode no

# Redis 持久化设置
appendonly yes          # 启用 AOF 持久化
appendfsync everysec    # 每秒同步一次 AOF 文件

# 数据库选项
databases 16            # 默认支持 16 个数据库

# 日志设置
loglevel notice         # 日志级别 (debug, verbose, notice, warning)
logfile /var/log/redis.log

# 最大客户端连接数
maxclients 10000        # 设置最大连接数

# 最大内存设置
maxmemory 2gb           # 设置最大内存为 2GB
maxmemory-policy allkeys-lru  # 设置内存满时的淘汰策略

# 设置 Redis 的端口
port 6379               # 默认 Redis 端口

# 主从复制配置
# replicaof <masterip> <masterport>

# Redis 数据文件设置
dir /data               # 数据文件存放路径

配置文件中的常见选项解释

• bind ：指定 Redis 监听的 IP 地址。0.0.0.0 表示监听所有可用的网络接口。
• protected-mode ：如果设置为 yes，Redis 会限制外部访问，只允许通过本地连接进行访问。通常生产环境中将其设置为 no，以便可以通过外部 IP 访问 Redis。
• appendonly：启用 AOF（Append-Only File）持久化，可以保证 Redis 数据在重启后不会丢失。
• databases：设置 Redis 的数据库数量，默认有 16 个数据库。
• loglevel ：设置日志的详细程度。可以选择 debug（调试）、verbose（详细）、notice（普通）和 warning（警告）。
• maxmemory：设置 Redis 最大内存使用量。超出此值时 Redis 会根据内存淘汰策略（例如 LRU）释放部分内存。
• maxclients：设置最大连接数，以防止 Redis 受到连接洪水攻击。

步骤 2：创建必要的目录

在运行 Docker 容器之前，需要确保数据存储和配置文件的目录已经创建，并且具有适当的权限。执行以下命令来创建目录并设置权限：

mkdir -p /data/redis/data /data/redis/conf
chmod 777 /data/redis

步骤 3：运行 Docker 命令

执行以下 Docker 命令来启动 Redis 容器：

docker run --restart=always --name redis \
-p 16379:6379 \
-v /data/redis/data:/data \
-v /data/redis/conf/redis.conf:/etc/redis/redis.conf \
-d --privileged redis:6.0

命令解释：

• --restart=always：容器退出后自动重启。
• --name redis：为容器指定名称为 redis。
• -p 16379:6379：将容器内的 Redis 端口（6379）映射到主机的 16379 端口，以便外部可以访问 Redis。
• -v /data/redis/data:/data：将主机上的数据目录挂载到容器中的 /data，以便 Redis 数据持久化。
• -v /data/redis/conf/redis.conf:/etc/redis/redis.conf：将自定义的 Redis 配置文件挂载到容器中的 /etc/redis/redis.conf。
• -d：让容器在后台运行。
• --privileged：使容器具有特权模式，允许执行某些受限操作。
• redis:6.0：使用 Redis 6.0 版本的官方镜像。

步骤 4：验证容器是否成功启动

执行以下命令检查 Redis 容器的状态：

docker ps

如果 Redis 容器正在运行，输出应该显示类似以下信息：

CONTAINER ID   IMAGE         COMMAND                  CREATED        STATUS        PORTS                  NAMES
xxxxxxx        redis:6.0     "docker-entrypoint.s..."   2 minutes ago  Up 2 minutes  0.0.0.0:16379->6379/tcp redis

步骤 5：访问 Redis

通过命令行连接到 Redis 容器：

docker exec -it redis redis-cli -p 16379

或者通过 redis-cli 客户端连接到 Redis 实例：

redis-cli -h 127.0.0.1 -p 16379

此时，你可以使用 Redis 命令与容器内的 Redis 进行交互。

补充说明

1. 数据持久化：

   • 使用 -v /data/redis/data:/data 选项将 Redis 数据目录挂载到主机上的 /data/redis/data，确保 Redis 数据在容器重启时不会丢失。
   • 在 Redis 配置文件中，确保启用了数据持久化选项（例如 appendonly yes），以便在关闭或重启容器时保存数据。

2. 配置文件：

   • redis.conf 文件用于自定义 Redis 的行为（例如设置持久化、连接限制、缓存大小等）。如果需要修改 Redis 的配置，可以直接编辑该文件。

3. 容器端口映射：

   • 如果你需要在多个机器之间部署 Redis，可以根据需要修改端口映射部分，例如映射到不同的主机端口。

通过这些步骤，你就可以成功地在 Docker 容器中部署 Redis 单机版，并根据需求进行定制和扩展。

二、Kubernetes部署Redis集群指南

在本节中，我们将介绍如何在Kubernetes集群中部署Redis集群。Redis集群是一个分布式系统，允许数据自动分片并处理分布式存储和请求负载。我们将详细说明Redis集群的配置、存储和集群的自动化创建过程。

1. 创建 Redis 配置文件 (redis.conf)

首先，我们需要为Redis创建一个配置文件。该配置文件包含了集群模式的启用、密码保护、数据持久化设置等参数。以下是一个示例配置：

root@ecs-205205:~/k8s-test/redis# cat redis.conf
bind 0.0.0.0
protected-mode yes
port 6360
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize no
supervised no
pidfile /data/redis.pid
loglevel notice
logfile /data/redis_log
databases 16
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir /data
masterauth iloveyou
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
requirepass iloveyou
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 15000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes

2. 创建 ConfigMap

在Kubernetes中，我们将Redis配置文件作为ConfigMap存储，这样可以方便地将配置应用到Redis Pod。

kubectl create configmap redis-conf --from-file=redis.conf=redis.conf

3. 创建存储类 StorageClass - NFS 服务

如果没有现有的StorageClass，可以创建一个用于持久化存储的NFS存储类。以下是NFS配置的参考文档：创建NFS存储。

4. 创建 StatefulSet 和服务

接下来，我们创建一个StatefulSet来部署Redis集群。StatefulSet适用于需要持久化存储和稳定标识的应用程序。以下是创建Redis集群的YAML配置：

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: redis-svc
  name: redis-svc
spec:
  ports:
    - port: 6360
      protocol: TCP
      targetPort: 6360
  selector:
    app: redis-sts
  type: ClusterIP
  clusterIP: None

---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  labels:
    app: redis-sts
  name: redis-sts
  namespace: default
spec:
  selector:
    matchLabels:
      app: redis-sts
  replicas: 6
  serviceName: redis-svc
  template:
    metadata:
      labels:
        app: redis-sts
    spec:
      containers:
        - name: redis
          image: redis:latest
          imagePullPolicy: IfNotPresent
          command:
            - redis-server
          args:
            - /etc/redis/redis.conf
            - --cluster-announce-ip
            - $(POD_IP)
          env:
            - name: POD_IP
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
          ports:
            - name: redis-6360
              containerPort: 6360
          volumeMounts:
            - name: redis-conf
              mountPath: /etc/redis
            - name: redis-data
              mountPath: /data
            - name: localtime
              mountPath: /etc/localtime
              readOnly: true
      restartPolicy: Always
      volumes:
        - name: redis-conf
          configMap:
            name: redis-conf
            items:
              - key: redis.conf
                path: redis.conf
        - name: localtime
          hostPath:
            path: /usr/share/zoneinfo/Asia/Shanghai
            type: File
  volumeClaimTemplates:
    - metadata:
        name: redis-data
      spec:
        resources:
          requests:
            storage: 100M
        accessModes:
          - ReadWriteOnce
        storageClassName: managed-nfs-storage

5. 自动创建 Redis 集群

在所有Pod启动后，我们可以通过Redis的集群创建命令来自动配置Redis集群。执行以下命令来自动创建集群：

kubectl exec -it redis-sts-0 -- redis-cli -a iloveyou --cluster create --cluster-replicas 1 $(kubectl get pods -l app=redis-sts -o jsonpath='{range.items[*]}{.status.podIP}:6360 {end}')

此命令将自动为Redis分配主从节点并创建集群。

6. 验证集群状态

验证集群的健康状态。你可以通过以下命令检查Redis集群的状态：

kubectl exec -it redis-sts-0 -- redis-cli -a iloveyou --cluster check $(kubectl get pods -l app=redis-sts -o jsonpath='{range.items[0]}{.status.podIP}:6360 {end}')

或者进入任意一个Pod并运行以下命令：

kubectl exec -it redis-sts-0 -- bash
redis-cli -a iloveyou --cluster check 10.244.1.20:6360

7. 验证服务的域名解析

通过创建一个busybox Pod，验证Redis服务的域名解析是否正常：

kubectl exec -it busybox -- nslookup redis-svc.default.svc.cluster.local

该命令将返回Redis集群的所有Pod IP。

8. 暴露服务集群外访问

如果需要让外部访问Redis集群，可以将Service类型修改为NodePort，并指定一个端口：

apiVersion: v1
kind: Service
metadata:
  labels:
    app: redis-svc
  name: redis-svc
spec:
  ports:
  - port: 6360
    targetPort: 6360
    nodePort: 31567
    protocol: TCP
  selector:
    app: redis-sts
  type: NodePort

应用更改后，使用以下命令重新部署：

kubectl delete -f redis-cluster-sts.yaml
kubectl apply -f redis-cluster-sts.yaml

总结

在Kubernetes集群中部署Redis集群可以有效地处理大规模的分布式数据存储。本节通过创建配置文件、ConfigMap、StatefulSet、服务以及自动集群创建等步骤，详细讲解了Redis集群的部署过程。根据需求，我们还可以暴露Redis集群供外部访问，并通过各种工具验证集群的健康状态。

三、使用 Helm 部署 Redis 集群

参考文档：

• Redis集群部署教程

步骤：

1. 安装 Helm

   首先，我们需要安装 Helm。根据 Kubernetes 版本选择合适的 Helm 版本。可以从 Helm 官网或者 GitHub 下载。

   # 下载并解压 Helm
   wget https://get.helm.sh/helm-v3.9.4-linux-amd64.tar.gz
   tar xf helm-v3.9.4-linux-amd64.tar.gz
   mv linux-amd64/helm /usr/local/bin/
   helm version

2. 添加 Helm 仓库

   为了拉取 Redis 集群的 Helm chart，我们需要先添加几个常见的 Helm 仓库。

   # 添加 Helm 仓库
   helm repo add bitnami https://charts.bitnami.com/bitnami
   helm repo add stable http://mirror.azure.cn/kubernetes/charts
   helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
   helm repo add incubator https://charts.helm.sh/incubator
   
   # 更新 Helm 仓库
   helm repo update

3. 拉取 Redis 集群 Chart

   使用以下命令搜索 Redis，然后拉取相应的 Chart 包。

   # 搜索 Redis
   helm search repo redis
   
   # 拉取 Redis 集群 Chart
   helm pull bitnami/redis-cluster
   # 如果失败，可以手动下载
   wget https://charts.bitnami.com/bitnami/redis-cluster-11.4.0.tgz

4. 解压并配置 Chart

   解压 Chart 包并修改 values.yaml 配置文件，指定存储类和密码。

   # 解压 Chart 包
   tar xf redis-cluster-11.4.0.tgz
   cd redis-cluster
   
   # 修改 values.yaml 配置文件
   vim values.yaml
   
   # 在文件中进行以下修改：
   global:
     imageRegistry: ""
     imagePullSecrets: []
     storageClass: "nfs-storage"  # 使用的存储类是 nfs
     redis:
       password: "123456"
   usePassword: true
   password: "123456"
   persistence:
     storageClass: "nfs-storage"
     accessModes:
       - ReadWriteMany
     size: 8Gi
   updateJob:
     resources:
       requests:
         cpu: 2
         memory: 512Mi
       limits:
         cpu: 3
         memory: 1024Mi
   service:
     type: NodePort  # 可以修改为 ClusterIP 或 NodePort

5. 安装 Redis 集群

   配置完成后，可以安装 Redis 集群。

   # 安装 Redis 集群
   helm install redis-cluster ./redis-cluster

6. 查看 Pods 状态

   通过以下命令查看 Redis Pods 是否成功启动。

   kubectl get pod -n default

7. 常见错误及解决方法

   • 问题 1：PVC 无法绑定 PV

     如果 PVC 无法绑定到 PV，可以手动创建 PV，示例配置如下：

     apiVersion: v1
     kind: PersistentVolume
     metadata:
       name: redis-cluster-pv-0
     spec:
       capacity:
         storage: 8Gi
       accessModes:
         - ReadWriteMany
       persistentVolumeReclaimPolicy: Retain
       storageClassName: nfs-storage
       nfs:
         server: 192.168.80.130
         path: /data/nfs-demo/redis-data-redis-cluster-0  # 这里是 NFS 服务器指定的路径

     确保 PV 和 PVC 之间的绑定关系符合要求：storageClassName 和 accessModes 必须一致，PVC 请求的存储量不应超过 PV 的容量。

   • 问题 2：NFS 服务器目录权限问题

     在 NFS 服务器上创建必要的目录，并为其提供写权限。

     # 创建 NFS 共享目录并赋予写权限
     mkdir -p /data/nfs-demo/redis-data-redis-cluster-0
     chmod 777 /data/nfs-demo/redis-data-redis-cluster-0

   • 问题 3：Redis 集群未自动创建

     如果 Redis Pods 已经处于 Running 状态，但集群没有自动创建，可以通过以下命令手动创建集群：

     kubectl exec -it redis-cluster-0 -- redis-cli --cluster create \
       10.0.1.247:6379 \
       10.0.1.61:6379 \
       10.0.1.190:6379 \
       10.0.1.91:6379 \
       10.0.1.35:6379 \
       10.0.1.2:6379 \
       --cluster-replicas 1

     之后可以使用以下命令验证集群状态：

     kubectl exec -it redis-cluster-0 -- redis-cli -c -h 10.0.1.247 -p 6379 cluster info
     kubectl exec -it redis-cluster-0 -- redis-cli -c -h 10.0.1.247 -p 6379 cluster nodes

8. DNS 问题

   如果出现 CoreDNS 无法解析 Redis 集群节点的错误，可能是因为 /etc/resolv.conf 配置问题。可以通过以下步骤解决：

   # 修改 CoreDNS 配置
   kubectl -n kube-system get configmap coredns -o yaml
   # 修改 resolv.conf 文件，添加 DNS 服务器
   sudo vi /etc/systemd/resolved.conf
   [Resolve]
   DNS=8.8.8.8 1.1.1.1
   sudo systemctl restart systemd-resolved
   sudo vi /etc/resolv.conf
   nameserver 8.8.8.8
   nameserver 1.1.1.1
   # 更新 CoreDNS 配置
   kubectl -n kube-system edit configmap coredns
   # 修改 forward 配置
   forward . 8.8.8.8 1.1.1.1
   kubectl -n kube-system rollout restart deployment coredns

   完成后，可以通过 ping 和 nslookup 命令验证 DNS 是否正常工作。

---

注意事项：

1. 存储类（StorageClass）选择 ：除了 NFS，还可以选择使用 local-path-provisioner。这种方式会自动创建 PV 和 PVC，方便本地存储的管理。
2. 资源限制配置 ：在 values.yaml 中可以配置 Redis 集群的资源请求与限制，例如 CPU 和内存。

总结来说，Docker、Kubernetes 和 Helm 各有特点，适用于不同的场景。Docker 部署 Redis 适合快速搭建和单机环境，操作简单但缺乏扩展性；Kubernetes 部署则更适合生产环境，提供高可用性和灵活扩展，但配置相对复杂；Helm 作为 Kubernetes 的包管理工具，简化了部署和管理过程，适合大规模、自动化的集群部署。选择哪种方式取决于实际需求，如环境规模、管理要求和自动化水平。