如何在K8s上部署Redis集群

共计 16572 个字符，预计需要花费 42 分钟才能阅读完成。

自动写代码机器人，免费开通

这篇文章将为大家详细讲解有关如何在 K8s 上部署 Redis 集群，丸趣 TV 小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。

一、前言
架构原理：每个 Master 都可以拥有多个 Slave。当 Master 下线后，Redis 集群会从多个 Slave 中选举出一个新的 Master 作为替代，而旧 Master 重新上线后变成新 Master 的 Slave。

二、准备操作
本次部署主要基于该项目：

https://github.com/zuxqoj/kubernetes-redis-cluster

其包含了两种部署 Redis 集群的方式：

StatefulSet
Service Deployment

两种方式各有优劣，对于像 Redis、Mongodb、Zookeeper 等有状态的服务，使用 StatefulSet 是首选方式。本文将主要介绍如何使用 StatefulSet 进行 Redis 集群的部署。

三、StatefulSet 简介
RC、Deployment、DaemonSet 都是面向无状态的服务，它们所管理的 Pod 的 IP、名字，启停顺序等都是随机的，而 StatefulSet 是什么？顾名思义，有状态的集合，管理所有有状态的服务，比如 MySQL、MongoDB 集群等。
StatefulSet 本质上是 Deployment 的一种变体，在 v1.9 版本中已成为 GA 版本，它为了解决有状态服务的问题，它所管理的 Pod 拥有固定的 Pod 名称，启停顺序，在 StatefulSet 中，Pod 名字称为网络标识(hostname)，还必须要用到共享存储。
在 Deployment 中，与之对应的服务是 service，而在 StatefulSet 中与之对应的 headless service，headless service，即无头服务，与 service 的区别就是它没有 Cluster IP，解析它的名称时将返回该 Headless Service 对应的全部 Pod 的 Endpoint 列表。
除此之外，StatefulSet 在 Headless Service 的基础上又为 StatefulSet 控制的每个 Pod 副本创建了一个 DNS 域名，这个域名的格式为：

$(podname).(headless server name) 
FQDN： $(podname).(headless server name).namespace.svc.cluster.local

也即是说，对于有状态服务，我们最好使用固定的网络标识（如域名信息）来标记节点，当然这也需要应用程序的支持（如 Zookeeper 就支持在配置文件中写入主机域名）。
StatefulSet 基于 Headless Service（即没有 Cluster IP 的 Service）为 Pod 实现了稳定的网络标志（包括 Pod 的 hostname 和 DNS Records），在 Pod 重新调度后也保持不变。同时，结合 PV/PVC，StatefulSet 可以实现稳定的持久化存储，就算 Pod 重新调度后，还是能访问到原先的持久化数据。
以下为使用 StatefulSet 部署 Redis 的架构，无论是 Master 还是 Slave，都作为 StatefulSet 的一个副本，并且数据通过 PV 进行持久化，对外暴露为一个 Service，接受客户端请求。

四、部署过程
本文参考项目的 README 中，简要介绍了基于 StatefulSet 的 Redis 创建步骤：

1. 创建 NFS 存储
2. 创建 PV
3. 创建 PVC
4. 创建 Configmap
5. 创建 headless 服务
6. 创建 Redis StatefulSet
7. 初始化 Redis 集群

这里，我将参考如上步骤，实践操作并详细介绍 Redis 集群的部署过程。文中会涉及到很多 K8S 的概念，希望大家能提前了解学习

1. 创建 NFS 存储
创建 NFS 存储主要是为了给 Redis 提供稳定的后端存储，当 Redis 的 Pod 重启或迁移后，依然能获得原先的数据。这里，我们先要创建 NFS，然后通过使用 PV 为 Redis 挂载一个远程的 NFS 路径。

安装 NFS

yum -y install nfs-utils（主包提供文件系统）yum -y install rpcbind（提供 rpc 协议）

然后，新增 /etc/exports 文件，用于设置需要共享的路径：

[root@ftp pv3]# cat /etc/exports
/usr/local/k8s/redis/pv1 192.168.0.0/24(rw,sync,no_root_squash)
/usr/local/k8s/redis/pv2 192.168.0.0/24(rw,sync,no_root_squash)
/usr/local/k8s/redis/pv3 192.168.0.0/24(rw,sync,no_root_squash)
/usr/local/k8s/redis/pv4 192.168.0.0/24(rw,sync,no_root_squash)
/usr/local/k8s/redis/pv5 192.168.0.0/24(rw,sync,no_root_squash)
/usr/local/k8s/redis/pv6 192.168.0.0/24(rw,sync,no_root_squash)

创建相应目录

[root@ftp quizii]# mkdir -p /usr/local/k8s/redis/pv{1..6}

接着，启动 NFS 和 rpcbind 服务：

systemctl restart rpcbind
systemctl restart nfs
systemctl enable nfs

[root@ftp pv3]# exportfs -v
/usr/local/k8s/redis/pv1
 192.168.0.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,no_root_squash,no_all_squash)
/usr/local/k8s/redis/pv2
 192.168.0.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,no_root_squash,no_all_squash)
/usr/local/k8s/redis/pv3
 192.168.0.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,no_root_squash,no_all_squash)
/usr/local/k8s/redis/pv4
 192.168.0.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,no_root_squash,no_all_squash)
/usr/local/k8s/redis/pv5
 192.168.0.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,no_root_squash,no_all_squash)
/usr/local/k8s/redis/pv6
 192.168.0.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,no_root_squash,no_all_squash)

客户端

yum -y install nfs-utils

查看存储端共享

[root@node2 ~]# showmount -e 192.168.0.222
Export list for 192.168.0.222:
/usr/local/k8s/redis/pv6 192.168.0.0/24
/usr/local/k8s/redis/pv5 192.168.0.0/24
/usr/local/k8s/redis/pv4 192.168.0.0/24
/usr/local/k8s/redis/pv3 192.168.0.0/24
/usr/local/k8s/redis/pv2 192.168.0.0/24
/usr/local/k8s/redis/pv1 192.168.0.0/24

创建 PV
每一个 Redis Pod 都需要一个独立的 PV 来存储自己的数据，因此可以创建一个 pv.yaml 文件，包含 6 个 PV：

[root@master redis]# cat pv.yaml 
apiVersion: v1
kind: PersistentVolume
metadata:
 name: nfs-pv1
spec:
 capacity:
 storage: 200M
 accessModes:
 - ReadWriteMany
 nfs:
 server: 192.168.0.222
 path:  /usr/local/k8s/redis/pv1 
apiVersion: v1
kind: PersistentVolume
metadata:
 name: nfs-vp2
spec:
 capacity:
 storage: 200M
 accessModes:
 - ReadWriteMany
 nfs:
 server: 192.168.0.222
 path:  /usr/local/k8s/redis/pv2 
apiVersion: v1
kind: PersistentVolume
metadata:
 name: nfs-pv3
spec:
 capacity:
 storage: 200M
 accessModes:
 - ReadWriteMany
 nfs:
 server: 192.168.0.222
 path:  /usr/local/k8s/redis/pv3 
apiVersion: v1
kind: PersistentVolume
metadata:
 name: nfs-pv4
spec:
 capacity:
 storage: 200M
 accessModes:
 - ReadWriteMany
 nfs:
 server: 192.168.0.222
 path:  /usr/local/k8s/redis/pv4 
apiVersion: v1
kind: PersistentVolume
metadata:
 name: nfs-pv5
spec:
 capacity:
 storage: 200M
 accessModes:
 - ReadWriteMany
 nfs:
 server: 192.168.0.222
 path:  /usr/local/k8s/redis/pv5 
apiVersion: v1
kind: PersistentVolume
metadata:
 name: nfs-pv6
spec:
 capacity:
 storage: 200M
 accessModes:
 - ReadWriteMany
 nfs:
 server: 192.168.0.222
 path:  /usr/local/k8s/redis/pv6

如上，可以看到所有 PV 除了名称和挂载的路径外都基本一致。执行创建即可：

[root@master redis]#kubectl create -f pv.yaml 
persistentvolume  nfs-pv1  created
persistentvolume  nfs-pv2  created
persistentvolume  nfs-pv3  created
persistentvolume  nfs-pv4  created
persistentvolume  nfs-pv5  created
persistentvolume  nfs-pv6  created

2. 创建 Configmap
这里，我们可以直接将 Redis 的配置文件转化为 Configmap，这是一种更方便的配置读取方式。配置文件 redis.conf 如下

[root@master redis]# cat redis.conf 
appendonly yes
cluster-enabled yes
cluster-config-file /var/lib/redis/nodes.conf
cluster-node-timeout 5000
dir /var/lib/redis
port 6379

创建名为 redis-conf 的 Configmap：

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

查看创建的 configmap:

[root@master redis]# kubectl describe cm redis-conf
Name: redis-conf
Namespace: default
Labels:  none 
Annotations:  none 
redis.conf:
appendonly yes
cluster-enabled yes
cluster-config-file /var/lib/redis/nodes.conf
cluster-node-timeout 5000
dir /var/lib/redis
port 6379
Events:  none

如上，redis.conf 中的所有配置项都保存到 redis-conf 这个 Configmap 中。

3. 创建 Headless service
Headless service 是 StatefulSet 实现稳定网络标识的基础，我们需要提前创建。准备文件 headless-service.yml 如下：

[root@master redis]# cat headless-service.yaml 
apiVersion: v1
kind: Service
metadata:
 name: redis-service
 labels:
 app: redis
spec:
 ports:
 - name: redis-port
 port: 6379
 clusterIP: None
 selector:
 app: redis
 appCluster: redis-cluster

创建：

kubectl create -f headless-service.yml

查看：

可以看到，服务名称为 redis-service，其 CLUSTER-IP 为 None，表示这是一个“无头”服务。

4. 创建 Redis 集群节点
创建好 Headless service 后，就可以利用 StatefulSet 创建 Redis 集群节点，这也是本文的核心内容。我们先创建 redis.yml 文件：

[root@master redis]# cat redis.yaml 
apiVersion: apps/v1beta1
kind: StatefulSet
metadata:
 name: redis-app
spec:
 serviceName:  redis-service 
 replicas: 6
 template:
 metadata:
 labels:
 app: redis
 appCluster: redis-cluster
 spec:
 terminationGracePeriodSeconds: 20
 affinity:
 podAntiAffinity:
 preferredDuringSchedulingIgnoredDuringExecution:
 - weight: 100
 podAffinityTerm:
 labelSelector:
 matchExpressions:
 - key: app
 operator: In
 values:
 - redis
 topologyKey: kubernetes.io/hostname
 containers:
 - name: redis
 image: redis
 command:
 -  redis-server 
 args:
 -  /etc/redis/redis.conf 
 -  --protected-mode 
 -  no 
 resources:
 requests:
 cpu:  100m 
 memory:  100Mi 
 ports:
 - name: redis
 containerPort: 6379
 protocol:  TCP 
 - name: cluster
 containerPort: 16379
 protocol:  TCP 
 volumeMounts:
 - name:  redis-conf 
 mountPath:  /etc/redis 
 - name:  redis-data 
 mountPath:  /var/lib/redis 
 volumes:
 - name:  redis-conf 
 configMap:
 name:  redis-conf 
 items:
 - key:  redis.conf 
 path:  redis.conf 
 volumeClaimTemplates:
 - metadata:
 name: redis-data
 spec:
 accessModes: [  ReadWriteMany  ]
 resources:
 requests:
 storage: 200M

如上，总共创建了 6 个 Redis 节点(Pod)，其中 3 个将用于 master，另外 3 个分别作为 master 的 slave；Redis 的配置通过 volume 将之前生成的 redis-conf 这个 Configmap，挂载到了容器的 /etc/redis/redis.conf；Redis 的数据存储路径使用 volumeClaimTemplates 声明（也就是 PVC），其会绑定到我们先前创建的 PV 上。
这里有一个关键概念——Affinity，请参考官方文档详细了解。其中，podAntiAffinity 表示反亲和性，其决定了某个 pod 不可以和哪些 Pod 部署在同一拓扑域，可以用于将一个服务的 POD 分散在不同的主机或者拓扑域中，提高服务本身的稳定性。
而 PreferredDuringSchedulingIgnoredDuringExecution 则表示，在调度期间尽量满足亲和性或者反亲和性规则，如果不能满足规则，POD 也有可能被调度到对应的主机上。在之后的运行过程中，系统不会再检查这些规则是否满足。
在这里，matchExpressions 规定了 Redis Pod 要尽量不要调度到包含 app 为 redis 的 Node 上，也即是说已经存在 Redis 的 Node 上尽量不要再分配 Redis Pod 了。但是，由于我们只有三个 Node，而副本有 6 个，因此根据 PreferredDuringSchedulingIgnoredDuringExecution，这些豌豆不得不得挤一挤，挤挤更健康~
另外，根据 StatefulSet 的规则，我们生成的 Redis 的 6 个 Pod 的 hostname 会被依次命名为 $(statefulset 名称)-$(序号) 如下图所示：

[root@master redis]# kubectl get pods -o wide 
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE
redis-app-0 1/1 Running 0 2h 172.17.24.3 192.168.0.144  none 
redis-app-1 1/1 Running 0 2h 172.17.63.8 192.168.0.148  none 
redis-app-2 1/1 Running 0 2h 172.17.24.8 192.168.0.144  none 
redis-app-3 1/1 Running 0 2h 172.17.63.9 192.168.0.148  none 
redis-app-4 1/1 Running 0 2h 172.17.24.9 192.168.0.144  none 
redis-app-5 1/1 Running 0 2h 172.17.63.10 192.168.0.148  none

如上，可以看到这些 Pods 在部署时是以 {0…N-1} 的顺序依次创建的。注意，直到 redis-app- 0 状态启动后达到 Running 状态之后，redis-app-1 才开始启动。
同时，每个 Pod 都会得到集群内的一个 DNS 域名，格式为 $(podname).$(service name).$(namespace).svc.cluster.local，也即是：

redis-app-0.redis-service.default.svc.cluster.local
redis-app-1.redis-service.default.svc.cluster.local
... 以此类推...

在 K8S 集群内部，这些 Pod 就可以利用该域名互相通信。我们可以使用 busybox 镜像的 nslookup 检验这些域名：

[root@master redis]# kubectl exec -ti busybox -- nslookup redis-app-0.redis-service
Server: 10.0.0.2
Address 1: 10.0.0.2 kube-dns.kube-system.svc.cluster.local
Name: redis-app-0.redis-service
Address 1: 172.17.24.3

可以看到，redis-app- 0 的 IP 为 172.17.24.3。当然，若 Redis Pod 迁移或是重启（我们可以手动删除掉一个 Redis Pod 来测试），IP 是会改变的，但是 Pod 的域名、SRV records、A record 都不会改变。

另外可以发现，我们之前创建的 pv 都被成功绑定了：

[root@master redis]# kubectl get pv
NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE
nfs-pv1 200M RWX Retain Bound default/redis-data-redis-app-2 3h
nfs-pv3 200M RWX Retain Bound default/redis-data-redis-app-4 3h
nfs-pv4 200M RWX Retain Bound default/redis-data-redis-app-5 3h
nfs-pv5 200M RWX Retain Bound default/redis-data-redis-app-1 3h
nfs-pv6 200M RWX Retain Bound default/redis-data-redis-app-0 3h
nfs-vp2 200M RWX Retain Bound default/redis-data-redis-app-3 3h

5. 初始化 Redis 集群

创建好 6 个 Redis Pod 后，我们还需要利用常用的 Redis-tribe 工具进行集群的初始化

创建 Ubuntu 容器
由于 Redis 集群必须在所有节点启动后才能进行初始化，而如果将初始化逻辑写入 Statefulset 中，则是一件非常复杂而且低效的行为。这里，本人不得不称赞一下原项目作者的思路，值得学习。也就是说，我们可以在 K8S 上创建一个额外的容器，专门用于进行 K8S 集群内部某些服务的管理控制。
这里，我们专门启动一个 Ubuntu 的容器，可以在该容器中安装 Redis-tribe，进而初始化 Redis 集群，执行：

kubectl run -it ubuntu --image=ubuntu --restart=Never /bin/bash

我们使用阿里云的 Ubuntu 源，执行：

root@ubuntu:/# cat   /etc/apt/sources.list   EOF
deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
 
deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
  EOF

成功后，原项目要求执行如下命令安装基本的软件环境：

apt-get update
apt-get install -y vim wget python2.7 python-pip redis-tools dnsutils

初始化集群
首先，我们需要安装 redis-trib：

pip install redis-trib==0.5.1

然后，创建只有 Master 节点的集群：

redis-trib.py create \
 `dig +short redis-app-0.redis-service.default.svc.cluster.local`:6379 \
 `dig +short redis-app-1.redis-service.default.svc.cluster.local`:6379 \
 `dig +short redis-app-2.redis-service.default.svc.cluster.local`:6379

其次，为每个 Master 添加 Slave

redis-trib.py replicate \
 --master-addr `dig +short redis-app-0.redis-service.default.svc.cluster.local`:6379 \
 --slave-addr `dig +short redis-app-3.redis-service.default.svc.cluster.local`:6379
redis-trib.py replicate \
 --master-addr `dig +short redis-app-1.redis-service.default.svc.cluster.local`:6379 \
 --slave-addr `dig +short redis-app-4.redis-service.default.svc.cluster.local`:6379
redis-trib.py replicate \
 --master-addr `dig +short redis-app-2.redis-service.default.svc.cluster.local`:6379 \
 --slave-addr `dig +short redis-app-5.redis-service.default.svc.cluster.local`:6379

至此，我们的 Redis 集群就真正创建完毕了，连到任意一个 Redis Pod 中检验一下：

[root@master redis]# kubectl exec -it redis-app-2 /bin/bash
root@redis-app-2:/data# /usr/local/bin/redis-cli -c
127.0.0.1:6379  cluster nodes
5d3e77f6131c6f272576530b23d1cd7592942eec 172.17.24.3:6379@16379 master - 0 1559628533000 1 connected 0-5461
a4b529c40a920da314c6c93d17dc603625d6412c 172.17.63.10:6379@16379 master - 0 1559628531670 6 connected 10923-16383
368971dc8916611a86577a8726e4f1f3a69c5eb7 172.17.24.9:6379@16379 slave 0025e6140f85cb243c60c214467b7e77bf819ae3 0 1559628533672 4 connected
0025e6140f85cb243c60c214467b7e77bf819ae3 172.17.63.8:6379@16379 master - 0 1559628533000 2 connected 5462-10922
6d5ee94b78b279e7d3c77a55437695662e8c039e 172.17.24.8:6379@16379 myself,slave a4b529c40a920da314c6c93d17dc603625d6412c 0 1559628532000 5 connected
2eb3e06ce914e0e285d6284c4df32573e318bc01 172.17.63.9:6379@16379 slave 5d3e77f6131c6f272576530b23d1cd7592942eec 0 1559628533000 3 connected
127.0.0.1:6379  cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:6
cluster_stats_messages_ping_sent:14910
cluster_stats_messages_pong_sent:15139
cluster_stats_messages_sent:30049
cluster_stats_messages_ping_received:15139
cluster_stats_messages_pong_received:14910
cluster_stats_messages_received:30049
127.0.0.1:6379

另外，还可以在 NFS 上查看 Redis 挂载的数据：

[root@ftp pv3]# ll /usr/local/k8s/redis/pv3
total 12
-rw-r--r-- 1 root root 92 Jun 4 11:36 appendonly.aof
-rw-r--r-- 1 root root 175 Jun 4 11:36 dump.rdb
-rw-r--r-- 1 root root 794 Jun 4 11:49 nodes.conf

6. 创建用于访问 Service
前面我们创建了用于实现 StatefulSet 的 Headless Service，但该 Service 没有 Cluster Ip，因此不能用于外界访问。所以，我们还需要创建一个 Service，专用于为 Redis 集群提供访问和负载均衡：

[root@master redis]# cat redis-access-service.yaml 
apiVersion: v1
kind: Service
metadata:
 name: redis-access-service
 labels:
 app: redis
spec:
 ports:
 - name: redis-port
 protocol:  TCP 
 port: 6379
 targetPort: 6379
 selector:
 app: redis
 appCluster: redis-cluster

如上，该 Service 名称为 redis-access-service，在 K8S 集群中暴露 6379 端口，并且会对 labels name 为 app: redis 或 appCluster: redis-cluster 的 pod 进行负载均衡。

创建后查看：

[root@master redis]# kubectl get svc redis-access-service -o wide
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE SELECTOR
redis-access-service ClusterIP 10.0.0.64  none  6379/TCP 2h app=redis,appCluster=redis-cluster

如上，在 K8S 集群中，所有应用都可以通过 10.0.0.64 :6379 来访问 Redis 集群。当然，为了方便测试，我们也可以为 Service 添加一个 NodePort 映射到物理机上，这里不再详细介绍。

五、测试主从切换
在 K8S 上搭建完好 Redis 集群后，我们最关心的就是其原有的高可用机制是否正常。这里，我们可以任意挑选一个 Master 的 Pod 来测试集群的主从切换机制，如 redis-app-0：

[root@master redis]# kubectl get pods redis-app-0 -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE
redis-app-1 1/1 Running 0 3h 172.17.24.3 192.168.0.144  none

进入 redis-app- 0 查看：

[root@master redis]# kubectl exec -it redis-app-0 /bin/bash
root@redis-app-0:/data# /usr/local/bin/redis-cli -c
127.0.0.1:6379  role
1)  master 
2) (integer) 13370
3) 1) 1)  172.17.63.9 
 2)  6379 
 3)  13370 
127.0.0.1:6379

如上可以看到，app- 0 为 master，slave 为 172.17.63.9 即 redis-app-3。

接着，我们手动删除 redis-app-0：

[root@master redis]# kubectl delete pod redis-app-0
pod  redis-app-0  deleted
[root@master redis]# kubectl get pod redis-app-0 -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE
redis-app-0 1/1 Running 0 4m 172.17.24.3 192.168.0.144  none

我们再进入 redis-app- 0 内部查看：

[root@master redis]# kubectl exec -it redis-app-0 /bin/bash
root@redis-app-0:/data# /usr/local/bin/redis-cli -c
127.0.0.1:6379  role
1)  slave 
2)  172.17.63.9 
3) (integer) 6379
4)  connected 
5) (integer) 13958

如上，redis-app- 0 变成了 slave，从属于它之前的从节点 172.17.63.9 即 redis-app-3。

六、疑问
至此，大家可能会疑惑，那为什么没有使用稳定的标志，Redis Pod 也能正常进行故障转移呢？这涉及了 Redis 本身的机制。因为，Redis 集群中每个节点都有自己的 NodeId（保存在自动生成的 nodes.conf 中），并且该 NodeId 不会随着 IP 的变化和变化，这其实也是一种固定的网络标志。也就是说，就算某个 Redis Pod 重启了，该 Pod 依然会加载保存的 NodeId 来维持自己的身份。我们可以在 NFS 上查看 redis-app- 1 的 nodes.conf 文件：

[root@k8s-node2 ~]# cat /usr/local/k8s/redis/pv1/nodes.conf 96689f2018089173e528d3a71c4ef10af68ee462 192.168.169.209:6379@16379 slave d884c4971de9748f99b10d14678d864187a9e5d3 0 1526460952651 4 connected237d46046d9b75a6822f02523ab894928e2300e6 192.168.169.200:6379@16379 slave c15f378a604ee5b200f06cc23e9371cbc04f4559 0 1526460952651 1 connected
c15f378a604ee5b200f06cc23e9371cbc04f4559 192.168.169.197:6379@16379 master – 0 1526460952651 1 connected 10923-16383d884c4971de9748f99b10d14678d864187a9e5d3 192.168.169.205:6379@16379 master – 0 1526460952651 4 connected 5462-10922c3b4ae23c80ffe31b7b34ef29dd6f8d73beaf85f 192.168.169.198:6379@16379 myself,slave c8a8f70b4c29333de6039c47b2f3453ed11fb5c2 0 1526460952565 3 connected
c8a8f70b4c29333de6039c47b2f3453ed11fb5c2 192.168.169.201:6379@16379 master – 0 1526460952651 6 connected 0-5461vars currentEpoch 6 lastVoteEpoch 4
如上，第一列为 NodeId，稳定不变；第二列为 IP 和端口信息，可能会改变。

这里，我们介绍 NodeId 的两种使用场景：

当某个 Slave Pod 断线重连后 IP 改变，但是 Master 发现其 NodeId 依旧，就认为该 Slave 还是之前的 Slave。

当某个 Master Pod 下线后，集群在其 Slave 中选举重新的 Master。待旧 Master 上线后，集群发现其 NodeId 依旧，会让旧 Master 变成新 Master 的 slave。

对于这两种场景，大家有兴趣的话还可以自行测试，注意要观察 Redis 的日志。

关于“如何在 K8s 上部署 Redis 集群”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。

向 AI 问一下细节