Modo de alta disponibilidad de Redis, replicación maestro-esclavo, modo centinela, modo de clúster (importante y detallado)

1. Modo de alta disponibilidad de Redis

1. Replicación maestro-esclavo: la replicación maestro-esclavo es la base de Redis de alta disponibilidad. Sentinel y los clústeres se basan en la replicación maestro-esclavo para lograr una alta disponibilidad. La replicación maestro-esclavo implementa principalmente la copia de seguridad de datos de varias máquinas, así como el equilibrio de carga y la recuperación de fallas simple para operaciones de lectura.
Defectos:
● La recuperación de fallas no se puede automatizar;
● Las operaciones de escritura no se pueden equilibrar la carga;
● La capacidad de almacenamiento está limitada por una sola máquina.
2. Sentinel: sobre la base de la replicación maestro-esclavo, Sentinel realiza la recuperación automática de fallas.
Defectos:
● Las operaciones de escritura no se pueden equilibrar la carga;
● La capacidad de almacenamiento está limitada por una sola máquina;
● Sentinel no puede realizar una conmutación por error automática del nodo esclavo. En el escenario de separación de lectura y escritura, la falla del nodo esclavo hará que el servicio de lectura sea no disponible, y el nodo esclavo debe tener operaciones adicionales de monitoreo y conmutación.
3. Agrupación en clústeres: a través de la agrupación en clústeres, Redis resuelve el problema de que las operaciones de escritura no se pueden equilibrar la carga y la capacidad de almacenamiento está limitada por una sola máquina y realiza una solución de alta disponibilidad relativamente completa.

Dos, replicación maestro-esclavo de Redis

La replicación maestro-esclavo se refiere a copiar los datos de un servidor Redis a otros servidores Redis. El primero se denomina nodo maestro (maestro) y el último se denomina nodo esclavo (esclavo);
La replicación de datos es unidireccional, solo desde el nodo maestro al nodo esclavo
De forma predeterminada, cada servidor Redis es el nodo maestro; y un nodo maestro puede tener varios nodos esclavos (o ningún nodo esclavo), pero un nodo esclavo solo puede tener un nodo maestro.

2.1 El papel de la replicación maestro-esclavo

● Redundancia de datos: la replicación maestro-esclavo realiza una copia de seguridad en caliente de los datos, que es un método de redundancia de datos además de la persistencia.
● Recuperación de fallas: cuando el nodo maestro tiene un problema, el nodo esclavo puede proporcionar servicios para lograr una recuperación rápida de fallas; de hecho, es un tipo de redundancia de servicio.
● Equilibrio de carga: sobre la base de la replicación maestro-esclavo, con la separación de lectura y escritura, el nodo maestro puede proporcionar el servicio de escritura y el nodo esclavo puede proporcionar el servicio de lectura (es decir, la aplicación se conecta al nodo maestro al escribir datos de Redis, y la aplicación se conecta al nodo esclavo al leer datos de Redis), comparta la carga del servidor; especialmente en el escenario de escribir menos y leer más, compartir la carga de lectura entre varios nodos esclavos puede aumentar en gran medida la concurrencia de la Servidor Redis.
● Piedra angular de la alta disponibilidad: además de las funciones anteriores, la replicación maestro-esclavo también es la base para la implementación de centinelas y clústeres, por lo que la replicación maestro-esclavo es la base para la alta disponibilidad de Redis.

2.2 Proceso de replicación maestro-esclavo

(1) Si se inicia un proceso de máquina esclava, enviará un comando de "comando de sincronización" a la máquina maestra para solicitar una conexión sincrónica.
(2) Ya sea la primera conexión o reconexión, la máquina maestra iniciará un proceso en segundo plano para guardar la instantánea de datos en el archivo de datos (ejecutar la operación rdb), y la maestra también registrará todos los comandos para modificar los datos y almacenarlos en caché en el archivo de datos en formato.
(3) Una vez que el proceso en segundo plano completa la operación de caché, la máquina maestra enviará el archivo de datos a la máquina esclava, y la máquina esclava guardará el archivo de datos en el disco duro y luego lo cargará en la memoria , y luego el La máquina maestra modificará todos los datos, la operación se envía a la máquina esclava. Si el esclavo falla y causa un tiempo de inactividad, se volverá a conectar automáticamente después de volver a la normalidad.
(4) Después de que la máquina maestra recibe la conexión de la máquina del lado esclavo, envía su archivo de datos completo a la máquina del lado esclavo. Si Mater recibe solicitudes de sincronización de varios esclavos al mismo tiempo, el maestro iniciará un proceso en segundo plano. para guardar El archivo de datos se envía a todas las máquinas del lado esclavo para garantizar que todas las máquinas del lado esclavo sean normales.

Tres, compile la replicación maestro-esclavo de Redis

Master节点: 192. 168.238.10
Slave1节点: 192. 168.238.20
Slave2节点: 192. 168.238.30

#!/bin/bash

#yum源
echo -e "\033[31m =====正在验证当前为仅主机还是NAT模式===== \033[0m"
ping -c1 -W1 www.baidu.com &> /dev/null
if [ $? -eq 0 ];then echo -e "\033[31m 检测当前为NAT模式，为您配置在线yum源 \033[0m"
mkdir -p /etc/yum.repos.d/repo.bak

mv -f /etc/yum.repos.d/* /etc/yum.repos.d/repo.bak &> /dev/null

wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo &> /dev/null

yum clean all &> /dev/null
yum list &> /dev/null
echo -e "\033[31m 在线源已配置完成 \033[0m"

else
echo -e "\033[31m 检测当前为仅主机模式，为您配置本地yum源 \033[0m"
mount /dev/sr0 /mnt &> /dev/null
cd /etc/yum.repos.d/
mkdir -p /etc/yum.repos.d/repo.bak

mv -f /etc/yum.repos.d/* /etc/yum.repos.d/repo.bak &> /dev/null

echo '[local]
name=local
baseurl=file:///mnt
enabled=1
gpgcheck=0' > /etc/yum.repos.d/local.repo
yum clean all &> /dev/null
yum makecache &> /dev/null

df -h | grep "/mnt" 
if [ $? -ne 0 ];then
echo -e "\033[31m 检测当前为仅主机模式，但光盘未连接！ \033[0m"
else
echo -e "\033[31m 本地yum源已配置完成 \033[0m"
fi
fi

#关闭防火墙
systemctl stop firewalld
setenforce 0
yum install -y gcc gcc-c++ make
rpm -q expect
rpm -q tcl
yum -y install expect
cd /opt
tar zxvf redis-5.0.7.tar.gz -C /opt/
cd /opt/redis-5.0.7/
make
make PREFIX=/usr/local/redis install
#由于Redis源码包中直接提供了Makefile 文件，所以在解压完软件包后，不用先执行./configure进行配置，可直接执行make与make install 命令进行安装。

#在/utils里执行软件包提供的install_server.sh脚本文件设置Redis服务所需要的相关配置文件
cd /opt/redis-5.0.7/utils

#开始免交换执行
/usr/bin/expect <<EOF
#expect开始标志
spawn ./install_server.sh
#Please select the redis port for this instance: [6379]
expect "instance"
send "\r" 
#Please select the redis config file name [/etc/redis/6379.conf] 
expect "config"
send "\r"
#Please select the redis log file name [/var/log/redis_6379.log]
expect "log"
send "\r"
#Please select the data directory for this instance [/var/lib/redis/6379]
expect "data"
send "\r"
#Please select the redis executable path []
expect "executable"
send "/usr/local/redis/bin/redis-server\r"
#Is this ok? Then press ENTER to go on or Ctrl-C to abort.
expect "abort"
send "\r"
expect eof
EOF


ln -s /usr/local/redis/bin/* /usr/local/bin/
netstat -natp | grep redis

/etc/init.d/redis_6379 restart     
/etc/init.d/redis_6379 status   

sed -i '/bind 127.0.0.1/c bind 0.0.0.0' /etc/redis/6379.conf
sed -i 's/appendonly no/appendonly yes/' /etc/redis/6379.conf
/etc/redis/6379.conf
 
/etc/init.d/redis_6379 restart
/etc/init.d/redis_6379 status  

Ejecutar comandos desde el servidor

sed -i '/replicaof <masterip> <masterport>/c replicaof 192.168.238.10 6379' 

Modificar el archivo de configuración de Redis (operación del nodo maestro)

El script anterior operará este paso

vim /etc/redis/6379.conf
bind 0.0.0.0      			  #70行，修改监听地址为0.0.0.0
daemonize yes       		  #137行，开启守护进程
logfile /var/log/redis_6379.log    #172行，指定日志文件目录.
dir /var/lib/redis/6379            #264行，指定工作目录
appendonly yes           		   #700行，开启AOF持久化功能

/etc/init.d/redis_6379 restart

Modificar el archivo de configuración de Redis (operación del nodo esclavo)

El script anterior operará este paso

vim /etc/redis/6379.conf
bind 0.0.0.0		#70行，修改监听地址为0.0.0.0
daemonize yes		#137行，开启守护进程
logfile /var/log/redis_6379.log	#172行，指定日志文件目录
dir /var/lib/redis/6379			#264行，指定工作目录
replicaof 192.168.238.10 6379 		#288行，指定要同步的Master节点IP和端口
appendonly yes		#700行，开启AOF持久化功能

/etc/init.d/redis_6379 restart

Verificar el efecto maestro-esclavo

Mire el registro en el nodo maestro

tail -f /var/log/redis_6379.log
Replica 192.168.80.11:6379 asks for synchronization
Replica 192.168.80.12:6379 asks for synchronization

Verifique el nodo esclavo en el nodo maestro

redis-cli info replication
# Replication
role:master
connected slaves:2
slave0:ip=192.168.80.11, port=6379, state=online, offset=1246, lag=0
slave1:ip=192.168.80.12, port=6379, state=online, offset=1246, lag=1

Verifique el nodo esclavo en el nodo esclavo

Cuatro, modo centinela de Redis

La función principal de Sentinel: basada en la replicación maestro-esclavo, Sentinel introduce la conmutación por error automática del nodo maestro.

4.1 Principio del modo centinela

Sentinel: Es un sistema distribuido que se utiliza para monitorear cada servidor en la estructura maestro-esclavo, cuando ocurre una falla, se selecciona un nuevo maestro mediante un mecanismo de votación y todos los esclavos se conectan al nuevo maestro. Por lo tanto, el número de centinelas en ejecución del clúster completo no debe ser inferior a 3 nodos.

4.2 El papel del modo centinela

● Monitoreo: el centinela verificará constantemente si el nodo maestro y el nodo esclavo funcionan normalmente.
● Conmutación por error automática: cuando el nodo maestro no funciona normalmente, el centinela iniciará una operación de conmutación por error automática, que actualizará uno de los nodos esclavos del nodo maestro fallido al nuevo nodo maestro y hará que otros nodos esclavos copien el nuevo maestro. nodo.
● Notificación (recordatorio): el centinela puede enviar el resultado de la conmutación por error al cliente.

4.3 La estructura centinela consta de dos partes, nodo centinela y nodo de datos

1. Ganglio centinela: El sistema centinela consta de uno o más ganglios centinela El ganglio centinela es un nodo Redis especial y no almacena datos.
2. Nodo de datos: tanto el nodo maestro como el esclavo son nodos de datos.

El inicio del modo centinela depende del modo maestro-esclavo, por lo que debe instalar el modo maestro-esclavo antes de hacer el modo centinela. Todos los nodos deben implementar el modo centinela. El modo centinela controlará si todos los nodos de trabajo de Redis son normales. Cuando aparece el Maestro Cuando hay un problema, porque otros nodos han perdido contacto con el nodo maestro, votarán. Más de la mitad de los votos se considera que hay un problema con este Maestro, y luego se notificará a la sala de centinelas. , y luego uno de los esclavos será seleccionado como el nuevo maestro.
Es importante tener en cuenta que el objetivo fuera de línea es un concepto exclusivo del nodo maestro; si el nodo esclavo y el nodo centinela fallan, después de que el centinela esté subjetivamente fuera de línea, no habrá operaciones objetivas posteriores fuera de línea y de conmutación por error.

Cinco, configurar el modo centinela

Master节点: 192.168.238.10
Slave1节点: 192.168.238.20
Slave2节点: 192.168.238.30

systemctl stop firewalld
setenforce 0

Modificar el archivo de configuración del modo centinela de Redis (todas las operaciones de nodo)

vim /opt/redis-5.0.7/sentinel.conf
protected-mode no		#17行，关闭保护模式
port 26379			#21行，Redis哨 兵默认的监听端口
daemonize yes		#26行，指定sentine1为后台启动
logfile "/var/log/sentinel.log"		#36行，指定日志存放路径
dir "/var/lib/redis/6379"		#65行，指定数据库存放路径
sentinel monitor mymaster 192.168.80.10 6379 2 		#84行， 修改
#指定该哨兵节点监控192.168.80.10:6379这个主节点，该主节点的名称是mymaster,最后的2的含义与主节点的故障判定有关:至少需要2个哨兵节点同意，才能判定主节点故障并进行故障转移
sentinel down-after-milliseconds mymaster 3000 		#113行， 判定服务器down掉的时间周期，默认30000毫秒 (30秒 )
sentinel failover-timeout mymaster 180000		#146行，故障节点的最大超时时间为180000 (180秒)

Activar el modo centinela

Empezar maestro primero, luego esclavo

cd /opt/redis-5.0.7/
redis-sentinel sentinel.conf &

Ver información centinela

redis-cli -p 26379 info Sentinel
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=mymaster,status=ok,address=192.168.80.10: 6379,slaves=2,sentinels=3

Simulación de fallas

Ver número de proceso de redis-server

ps -ef | grep redis
root    57031    1    	 0 15:20 ?    		00:00:07 /usr/local/bin/redis-server 0.0.0.0:6379
root    57742    1   	 1 16:05 ?    		00:00:07 redis-sentinel *:26379 [sentinel]
root    57883    57462   0 16:17 pts/1      00:00:00 grep --color=auto redis

主：
root      46721   6605  0 20:30 pts/3    00:00:00 tail -f /var/log/redis_6379.log
root      46768   6605  0 20:34 pts/3    00:00:00 tail -f /var/log/redis_6379.log
root      46790   6605  0 20:36 pts/3    00:00:00 tail -f /var/log/redis_6379.log
root      46832      1  0 20:39 ?        00:00:16 /usr/local/redis/bin/redis-server 0.0.0.0:6379
root      46848   6605  0 20:40 pts/3    00:00:00 tail -f /var/log/redis_6379.log
root      48779      1  0 23:46 ?        00:00:00 redis-sentinel *:26379 [sentinel]
root      48801  48225  0 23:48 pts/2    00:00:00 grep --color=auto redis


从：
[root@localhost redis-5.0.7]#ps -ef | grep redis
root      47386      1  0 20:30 ?        00:00:19 /usr/local/redis/bin/redis-server 0.0.0.0:6379
root      49483      1  0 23:46 ?        00:00:00 redis-sentinel *:26379 [sentinel]
root      49519  48928  0 23:50 pts/1    00:00:00 grep --color=auto redis

#杀死Master 节点上redis- server的进程号
kill -9 57031    #Master节点上redis-server的进程号

Resultados de la validación

tail -f /var/log/sentinel.log
57742:X 07 Aug 2020 16:19:21.170 # +failover-state-select-slave master mymaster 192.168.80.11 6379
57742:x 07 Aug 2020 16:19:21.170 # -sdown slave 192.168.80.12:6379 192.168.80.12 6379 @ mymaster 192.168.80.11 6379
57742:X 07 Aug 2020 16:19:21.272 # +selected-slave slave 192.168.80.12:6379 192.168.80.12 6379 @ mymaster 192.168.80.11 6379
57742:X 07 Aug 2020 16:19:21.272 ★+failover-state-send-slaveof-noone slave 192.168.80.12:6379 192.168.80.12 6379 @ mymaster 192.168.80.11 6379
57742:X 07 Aug 2020 16:19:21.338 * +failover-state-wait-promotion slave 192.168.80.12:6379 192.168.80.12 6379 @ mymaster 192.168.80.11 6379
57742:X 07 Aug 2020 16:19:21.402 # -failover- abort-slave-timeout master mymaster 192.168.80.11 6379
57742:X 07 Aug 2020 16:19:21.799 # -sdown master mymaster 192.168.80.11 6379
57742:X 07 Aug 2020 16:19:21.826 # +new - epoch 41
57742:X 07 Aug 2020 16:19:21.827 # +vote- for-leader b12178afd9f862e0ead00763c2c7f1ae7f5de22e 41
57742:X 07 Aug 2020 16:19:31.137 * +convert- to- slave slave 192.168.80.12:6379 192.168.80.12 6379 @ mymaster 192.168.80.11 6379

[root@localhost redis-5.0.7]#tail -f /var/log/sentinel.log
48779:X 25 Feb 2021 23:46:57.327 * +sentinel sentinel 0d2634b6bba9148fd0dcc86b6f1b84e345a2c35e 192.168.238.20 26379 @ mymaster 192.168.238.10 6379
48779:X 25 Feb 2021 23:47:13.367 * +sentinel sentinel 4172c90a7e2f5c352bad5df746aa995a4ed8c229 192.168.238.30 26379 @ mymaster 192.168.238.10 6379
48779:X 25 Feb 2021 23:54:22.812 # +sdown master mymaster 192.168.238.10 6379
48779:X 25 Feb 2021 23:54:22.904 # +new-epoch 1
48779:X 25 Feb 2021 23:54:22.904 # +vote-for-leader 4172c90a7e2f5c352bad5df746aa995a4ed8c229 1
48779:X 25 Feb 2021 23:54:23.788 # +config-update-from sentinel 4172c90a7e2f5c352bad5df746aa995a4ed8c229 192.168.238.30 26379 @ mymaster 192.168.238.10 6379
48779:X 25 Feb 2021 23:54:23.788 # +switch-master mymaster 192.168.238.10 6379 192.168.238.30 6379
48779:X 25 Feb 2021 23:54:23.789 * +slave slave 192.168.238.20:6379 192.168.238.20 6379 @ mymaster 192.168.238.30 6379
48779:X 25 Feb 2021 23:54:23.789 * +slave slave 192.168.238.10:6379 192.168.238.10 6379 @ mymaster 192.168.238.30 6379
48779:X 25 Feb 2021 23:54:53.881 # +sdown slave 192.168.238.10:6379 192.168.238.10 6379 @ mymaster 192.168.238.30 6379

Seis, modo de clúster de Redis

Cluster, a saber, Redis Cluster, es una solución de almacenamiento distribuido introducida en Redis 3.0.
El clúster está compuesto por varios nodos (nodo) y los datos de Redis se distribuyen entre estos nodos. Los nodos en el clúster se dividen en nodos maestros y nodos esclavos: solo el nodo maestro es responsable del mantenimiento de las solicitudes de lectura y escritura y la información del clúster; los nodos esclavos solo replican los datos y la información de estado del nodo maestro.

6.1 El papel de los clústeres se puede resumir en dos puntos

(1) Partición de datos: la partición de datos (o fragmentación de datos) es la función principal del clúster.
El clúster dispersa los datos en varios nodos. Por un lado, supera el límite de tamaño de memoria de una sola máquina de Redis y la capacidad de almacenamiento aumenta considerablemente; por otro lado, cada nodo principal puede proporcionar servicios externos de lectura y escritura, que mejora en gran medida la capacidad de respuesta del clúster.
La limitación del tamaño de la memoria independiente de Redis se menciona en la introducción de la persistencia y la replicación maestro-esclavo; por ejemplo, si la memoria independiente es demasiado grande, la operación de bifurcación de bgsave y bgrewriteaof puede hacer que el proceso maestro se bloquee y puede ser posible cuando el host se cambia en el entorno maestro-esclavo. Como resultado, el nodo esclavo no puede proporcionar servicios durante mucho tiempo y el búfer de replicación del nodo maestro puede desbordarse durante la fase de replicación completa.
(2) Alta disponibilidad: el clúster admite la replicación maestro-esclavo y la conmutación por error automática del nodo maestro (similar a centinela); cuando falla cualquier nodo, el clúster aún puede proporcionar servicios externos.

6.2 Fragmentación de datos del clúster de Redis

El clúster de Redis introduce el concepto de ranuras de hash. El
clúster de Redis tiene 16384 ranuras de hash (No. 0-16383)
. Cada nodo del clúster es responsable de una parte de la ranura de hash. Después
de que CRC16 verifique cada clave , el resto de 16384 Se toma para determinar cuál colocar. Espere ranura, a través de este valor, para encontrar el nodo correspondiente a la ranura correspondiente, y luego saltar automáticamente al nodo correspondiente para las operaciones de acceso

6.3 Tome un clúster compuesto por 3 nodos como ejemplo

El nodo A contiene las ranuras hash 0 a
5460. El nodo B contiene las ranuras hash 5461 a 10922. El
nodo C contiene las ranuras hash 10923 a 16383.

6.4 Modelo de replicación maestro-esclavo del clúster de Redis

El clúster tiene tres nodos A, B y C. Si el nodo B falla, todo el clúster no estará disponible debido a la falta de ranuras en el rango de 5461-10922.
Agregue un nodo esclavo A1, B1 y C1 para cada nodo. El clúster completo consta de tres nodos maestros y tres nodos esclavos. Después de que el nodo B falla, el clúster elige el nodo maestro con B1 como el nodo principal para continuar sirviendo. Cuando tanto B como B1 fallan, el clúster no estará disponible.

Siete, compila el modo de clúster de Redis

Un clúster de redis generalmente requiere 6 nodos, 3 maestros y 3 esclavos. Para mayor comodidad, aquí todos los nodos se simulan en el mismo servidor: se
distinguen por números de puerto: 3 números de puerto de nodo maestro: 6001/6002/6003, y los números de puerto de nodo esclavo correspondientes: 6004/6005/6006.

cd /etc/redis/
mkdir -p redis-cluster/redis600{
    
    1..6}
for i in {
    
    1..6}
do
cp /opt/redis-5.0.7/redis.conf /etc/redis/redis-cluster/redis600$i
cp /opt/redis-5.0.7/src/redis-cli /opt/redis-5.0.7/src/redis-server /etc/redis/redis-cluster/redis600$i
done

Encienda la función de clúster

#Los archivos de configuración de las otras 5 carpetas se modifican de la misma manera, tenga en cuenta que los 6 puertos son todos diferentes.

cd /etc/redis/redis-cluster/redis 6001
vim redis.conf
bind 127.0.0.1
#69行，注释掉bind项，默认监听所有网卡
protected-mode no
#88行，修改，关闭保护模式
port 6001
#92行，修改，redis监听端口，
daemonize yes
#136行，开启守护进程，以独立进程启动
cluster-enabled yes
#832行，取消注释，开启群集功能
cluster-config-file nodes-6001.conf
#840行，取消注释，群集名称文件设置
cluster-node-timeout 15000
#846行，取消注释群集超时时间设置
appendonly yes
#700行，修改，开启AOF持久化

Inicie el nodo redis

Ingrese las seis carpetas y ejecute el comando: redis-server redis.conf para iniciar el nodo redis

cd /etc/redis/redis-cluster/redis6001
redis-server redis.conf
for d in {
    
    1..6}
do
cd /etc/redis/redis-cluster/redis600$d
redis-server redis.conf
done
ps -ef | grep redis

Iniciar el clúster

redis-cli --cluster create 127.0.0.1:6001 127.0.0.1:6002 127.0.0.1:6003 127.0.0.1:6004 127.0.0.1:6005 127.0.0.1:6006 --cluster-replicas 1

# Las seis instancias se dividen en tres grupos, cada grupo tiene un maestro y un esclavo, el frente es el nodo maestro y la parte posterior es el nodo esclavo. Debe ingresar sí para crear la siguiente interacción.
-Replicas 1 significa que cada nodo maestro tiene 1 nodo esclavo.

#Test cluster

redis-cli -p 6001 -c         #加-c参数，节点之，间就可以互相跳转
127.0.0.1:6001> cluster slots    #查看节点的哈希槽编号范围
1) 1) (integer) 5461
   2) (integer) 10922        #哈希槽编号范围
   3) 1) "127.0.0.1"
      2) (integer) 6003        #主节点IP和端口号
      3) " fdca661922216dd69a63a7c9d3c4540cd6baef44"
   4) 1) "127.0.0.1"
      2) (integer) 6004        #从节点IP和端口号
     3) " a2c0c32aff0f38980accd2b63d6d952812e44740"
2) 1) (integer) 0
   2) (integer) 5460
   3) 1) "127.0.0.1"
      2) (integer) 6001
      3) "0e5873747a2e26bdc935bc76c2bafb19d0a54b11"
      4) 1) "127.0.0.1"
         2) (integer) 6006
         3) "8842ef5584a85005e135fd0ee59e5a0d67b0cf8e"
3) 1) (integer) 10923
   2) (integer) 16383
   3) 1) "127.0.0.1"
      2) (integer) 6002
      3) "81 6ddaa3d1469540b2ffbcaaf9aa867646846b30"
   4) 1) "127.0.0.1"
      2) (integer) 6005
      3) " f847077bfe6722466e96178ae8cbb09dc8b4d5eb"
127.0.0.1:6001> set name zhangsan
-> Redi rected to slot [5798] located at 127.0.0.1:6003 
OK
127.0.0.1:6001> cluster keyslot name    #查看name键的槽编号

127.0.0.1:6001> cluster slots
1) 1) (integer) 10923
   2) (integer) 16383
   3) 1) "127.0.0.1"
      2) (integer) 6003
      3) "f466e92c2487cea57aeca1ac74065e976f23bf0e"
   4) 1) "127.0.0.1"
      2) (integer) 6004
      3) "451dda82fd262ad6f3eaca5d39a4847b7c2b635c"
2) 1) (integer) 5461
   2) (integer) 10922
   3) 1) "127.0.0.1"
      2) (integer) 6002
      3) "1cbb5bdda47f98adb4193da8cc7b801ef76ac08e"
   4) 1) "127.0.0.1"
      2) (integer) 6006
      3) "fb71c49ba37aa0e2495160b6979d8c79b56f123f"
3) 1) (integer) 0
   2) (integer) 5460
   3) 1) "127.0.0.1"
      2) (integer) 6001
      3) "7696a844322b9a2c8d23125228afd25097885546"
   4) 1) "127.0.0.1"
      2) (integer) 6005
      3) "87412db1a80e4f8064205efdb581d34e0af80c2e"
      127.0.0.1:6001> set name xyw
-> Redirected to slot [5798] located at 127.0.0.1:6002
OK
127.0.0.1:6002> cluster keyslot name
(integer) 5798