1. Alta disponibilidad de
redis 1.1 El concepto de alta disponibilidad de redis
En los servidores web, la alta disponibilidad se refiere al tiempo en el que normalmente se puede acceder al servidor, etc).
La fórmula de cálculo para la alta disponibilidad es 1-(tiempo de inactividad)/(tiempo de inactividad+tiempo de ejecución), que es algo similar a la tasa de error de bits de los parámetros de transmisión de la red. Usamos el número 9 para representar la disponibilidad:
2 nueves: 99 %, tiempo de inactividad en un año: 1 % x 365 días = 3,6524 días = 87,6 h
4 nueves: 99,99 %, tiempo de inactividad en un año: 0,01 % × 365 días = 52,56 min
5 nueves: 99,999 %, tiempo de inactividad en un año: 0,001 %*365 días=5,265 min
Once nueves: casi un año de inactividad en segundos
Sin embargo, en el contexto de Redis, el significado de alta disponibilidad parece ser más amplio: además de garantizar la prestación de servicios normales (como separación maestro-esclavo, tecnología de recuperación rápida ante desastres), también es necesario considerar la expansión de capacidad de datos y seguridad de datos sin pérdida, etc.
1.2 Tecnología de alta disponibilidad de Redis
En Redis, las tecnologías para lograr una alta disponibilidad incluyen principalmente persistencia, replicación maestro-esclavo, centinela y clústeres de clúster, a continuación se describen sus funciones y qué problemas resuelven.
Persistencia: La persistencia es el método de alta disponibilidad más simple (a veces ni siquiera se clasifica como un método de alta disponibilidad). Su función principal es la copia de seguridad de datos, es decir, almacenar datos en el disco duro para garantizar que los datos no se perderán debido al proceso. salida.
Replicación maestro-esclavo: la replicación maestro-esclavo es la base de Redis de alta disponibilidad. Los centinelas y los clústeres se basan en la replicación maestro-esclavo para lograr una alta disponibilidad. La replicación maestro-esclavo realiza principalmente copias de seguridad (y sincronización) de datos en varias máquinas, así como equilibrio de carga y recuperación simple de fallas para operaciones de lectura.
Defectos: la recuperación de fallas no se puede automatizar; las operaciones de escritura no se pueden equilibrar en la carga; la capacidad de almacenamiento está limitada por una sola máquina.
Sentinel: basado en la replicación maestro-esclavo, Sentinel implementa la recuperación automática de fallas. (El maestro está inactivo, encuentre un esclavo para convertirse en el nuevo maestro y el nodo centinela lo monitoreará)
Defectos: las operaciones de escritura no se pueden equilibrar en la carga; la capacidad de almacenamiento está limitada por una sola máquina.
Clúster de 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 con la carga y la capacidad de almacenamiento está limitada por una sola máquina, y realiza una solución de alta disponibilidad relativamente completa. (6 juegos de inicio, en parejas, 3 maestros y 3 esclavos)
Clúster de 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 con la carga y la capacidad de almacenamiento está limitada por una sola máquina, y realiza una solución de alta disponibilidad relativamente completa. (6 juegos de inicio, en parejas, 3 maestros y 3 esclavos)
2. 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 (Master), y el segundo se denomina nodo esclavo (slave); la replicación de datos es unidireccional, solo del nodo maestro al nodo esclavo.
De forma predeterminada, cada servidor de Redis es un 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 implementa una copia de seguridad activa de los datos, que es un método de redundancia de datos distinto de la persistencia.
Recuperación de fallas: cuando el nodo maestro tiene un problema, el nodo esclavo puede proporcionar servicios para lograr una rápida recuperación de fallas; en realidad, es un tipo de redundancia de servicio.
Equilibrio de carga: sobre la base de la replicación maestro-esclavo, combinada con la separación de lectura y escritura, el nodo maestro puede proporcionar servicios de escritura y los nodos esclavos pueden proporcionar servicios 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 cuando lee datos de Redis), para compartir la carga del servidor; especialmente en el escenario de escribir menos y leer más, compartir la carga de lectura a través de múltiples nodos esclavos puede aumentar considerablemente la concurrencia del servidor Redis.
La 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.
1.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 la 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 la memoria caché. en el medio del archivo de datos.
(3) Después de que el proceso en segundo plano complete la operación de caché, la máquina maestra enviará el archivo de datos a la máquina esclava, la máquina esclava guardará el archivo de datos en el disco duro y luego lo cargará en la memoria, y luego la máquina maestra máquina modificará todos los archivos de datos La operación también se envía a la máquina esclava. Si el esclavo falla y provoca 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 esclava, envía su archivo de datos completo a la máquina esclava. Si la máquina maestra recibe solicitudes de sincronización de varios esclavos al mismo tiempo, la maestra iniciará un proceso en segundo plano para guarde el archivo de datos y luego envíelo a todas las máquinas esclavas, asegúrese de que todas las máquinas esclavas sean normales.
3. Implementación de redis maestro-esclavo (un maestro y dos esclavos)
pasos experimentales específicos
1 Instalar redis un maestro y dos servidores esclavos
// preparación del entorno
systemctl stop firewalld
systemctl disabled firewalld
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config
#Modificar los parámetros del kernel
vim /etc/sysctl.conf
vm.overcommit_memory = 1
net.core.somaxconn = 2048
sysctl-p
//Instalar redis
yum install -y gcc gcc-c++ make
tar zxvf /opt/redis-7.0.9.tar.gz -C /opt/
cd /opt/redis-7.0.9
make
make PREFIX=/usr/local/redis install
#Porque el Makefile se proporciona directamente en la fuente de Redis package, por lo que después de descomprimir el paquete de software, no necesita ejecutar ./configure primero para configurarlo, puede ejecutar directamente los comandos make y make install para instalarlo.
#Crear directorio de trabajo redis
mkdir /usr/local/redis/{conf,log,data}
cp /opt/redis-7.0.9/redis.conf /usr/local/redis/conf/
useradd -M -s /sbin/nologin redis
chown -R redis.redis /usr/local/redis/
#Variable de entorno
vim /etc/profile
PATH=$PATH:/usr/local/redis/bin #Agregar una línea
fuente /etc/perfil
//Definir secuencia de comandos de administración de servicios de systemd
vim /usr/lib/systemd/system/redis-server.service
[Unidad]
Descripción=Redis Server
After=network.target
[Servicio]
Usuario=redis
Grupo=redis
Tipo=bifurcación
TimeoutSec=0
PIDFile=/usr/local/redis/log/redis_6379.pid
ExecStart=/usr/local/redis/bin/redis-server /usr/local/redis/ conf/redis.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s SALIR $MAINPID
PrivateTmp=true
[Instalar]
WantedBy=multi-user.target
2 Modificar el archivo de configuración maestro-esclavo
----- modificar el archivo de configuración de Redis (Operación del nodo maestro) -----
vim /usr/local/redis/conf/redis.conf
bind 0.0.0.0
línea #87, modifique la dirección de escucha a 0.0.0.0
modo protegido sin
línea #111, configure el modo de protección de acceso local sin
puerto 6379
línea #138 , Redis escucha el puerto 6379 de manera predeterminada
daemonize yes
#309 line, configúrelo como un proceso daemon, inicie
pidfile /usr/local/redis/log/redis_6379.pid
#341 line, especifique el archivo
de registro del archivo PID "/usr/local/redis /log/ redis_6379.log"
línea #354, especifique el archivo de registro
dir /usr/local/redis/data
línea #504, especifique el directorio donde se encuentra el archivo persistente
#requirepass abc123
línea #1037, opcional, configure la contraseña de redis
appendonly sí
#1380 línea, abrir AOF
systemctl reiniciar redis-server.service
iniciar servicio redis
----- Modificar el archivo de configuración de Redis (operación de nodo esclavo) -----
vim /usr/local/redis/conf/redis.conf
enlazar
la línea 0.0.0.0 #87, modificar la dirección de escucha a 0.0.0.0
protected- mode no
#111 line, establezca el modo de protección de acceso local no
port 6379
#138 line, Redis escucha el puerto 6379 de manera predeterminada
daemonize sí
#309 line, configúrelo como un proceso daemon, inicie
pidfile /usr/local/redis/log/ redis_6379 en el fondo.línea pid
#341, especifique el archivo de
registro PID "/usr/local/redis/log/redis_6379.log"
línea #354, especifique el archivo de registro
dir /usr/local/redis/data
#504 línea, especifique el directorio donde se encuentra el archivo persistente
# requirepass abc123
#1037 línea, opcional, configure la contraseña redis
agregue solo sí #1380 línea, abra la réplica
AOF de 192.168.80.10 6379 #528 línea, especifique la IP del nodo maestro y el puerto que se sincronizará #masterauth abc123 #535 línea, opcional, especifique la contraseña del nodo maestro, solo configure requirepass systemctl en el El nodo maestro reinicia redis-server.service para iniciar el servicio
Maestro de prueba experimental
escribir datos
127.0.0.1:6379> teclas *
127.0.0.1:6379> establecer nombre zhangsan
127.0.0.1:6379> obtener nombre
dos de la biblioteca para ver la base de datos
4. Modo centinela de Redis
El método de tecnología de conmutación maestro-esclavo es: cuando el servidor está inactivo, un esclavo debe cambiarse manualmente al maestro. Esto requiere una intervención manual, que no solo requiere mucho tiempo y es laboriosa, sino que también provoca que el servicio no esté disponible durante un período de tiempo. Para resolver las deficiencias de la replicación maestro-esclavo, existe un mecanismo centinela.
Función principal de Sentinel: basado en la replicación maestro-esclavo, Sentinel introduce la conmutación por error automática del nodo maestro.
La composición del modo centinela:
Nodo centinela: el sistema centinela consta de uno o más nodos centinela, que son nodos redis especiales que no almacenan datos.
Nodos de datos: tanto los nodos maestros como los esclavos son nodos de datos.
4.1 El papel del modo centinela
Monitoreo: Sentry verifica constantemente que los nodos maestro y esclavo funcionen correctamente.
Conmutación por error automática: cuando el nodo maestro no funciona con normalidad, Sentinel iniciará una operación de conmutación por error automática. Actualizará uno de los nodos esclavos del nodo maestro fallido a un nuevo nodo maestro y permitirá que otros nodos esclavos copien el nuevo nodo maestro en su lugar. .
Notificaciones (recordatorios): Sentinels puede enviar resultados de conmutación por error a los clientes.
Además: el nodo centinela también puede ser independiente de otros hosts y no necesita instalarse en el servidor del nodo para la replicación maestro-esclavo de redis
4.2 Mecanismo de conmutación por error
1. El nodo centinela monitorea regularmente para averiguar si el nodo maestro ha fallado.Cada
nodo centinela le pedirá al nodo maestro, al nodo esclavo y a otros nodos centinela que envíen un comando ping cada segundo para una verificación del corazón. Si el nodo maestro no responde dentro de un cierto período de tiempo o responde con un mensaje de error, el centinela considerará que el nodo maestro está fuera de línea subjetivamente (unilateralmente). Cuando más de la mitad de los nodos centinela piensan que el nodo maestro está desconectado subjetivamente, objetivamente está desconectado.
2. Cuando el nodo maestro falle, el nodo centinela implementará el mecanismo de elección a través del algoritmo Raft (algoritmo de elección) para elegir conjuntamente un nodo centinela como líder que se encargará de manejar la conmutación por error y la notificación del nodo maestro. Por lo tanto, la cantidad de clústeres que ejecutan Sentinels no debe ser inferior a 3 nodos.
3. El nodo centinela líder realiza la conmutación por error, el proceso es el siguiente:
Actualice un nodo esclavo a un nuevo nodo maestro y deje que otros nodos esclavos apunten al nuevo nodo maestro;
si el nodo maestro original se recupera, también se convertirá en un nodo esclavo y apuntará al nuevo nodo maestro;
notifique al cliente que el nodo maestro el nodo ha sido reemplazado.
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 los desconecte subjetivamente, no habrá operaciones objetivas fuera de línea y de conmutación por error posteriores.
4.3 Selección de nodos maestros en modo centinela
1. Filtre los nodos esclavos en mal estado (fuera de línea) que no hayan respondido a la respuesta del ping centinela.
2. Seleccione el nodo esclavo con la configuración de mayor prioridad en el archivo de configuración. (prioridad de réplica, el valor predeterminado es 100)
3. Seleccione el nodo esclavo con el desplazamiento de replicación más grande, es decir, la replicación más completa.
El inicio de Sentinel depende del modo maestro-esclavo, por lo que el modo Sentinel debe instalarse después de instalar el modo maestro-esclavo.
5. Implementación del modo centinela redis
Implementación de componentes experimentales
Los pasos de operación específicos del experimento
son implementar el modo centinela sobre la base de la replicación redis maestro-esclavo (solo hágalo sobre la base de la replicación anterior de un maestro-dos-esclavo)
Paso 1: Modificar el archivo de configuración del nodo centinela (la misma operación para todos los nodos centinela)
El archivo de configuración del centinela es la configuración que viene con el software redis
cp /opt/redis-7.0.9/sentinel.conf /usr/local/redis/conf/
chown redis.redis /usr/local/redis/conf/sentinel.conf
vim /usr/local/redis/conf/sentinel. conf
protected-mode no
línea #6, cierre el puerto de modo de protección
26379
línea #10, el puerto de escucha predeterminado de Redis sentinel
daemonize yes
línea #15, especifique sentinel como fondo iniciar
pidfile /usr/local/redis/log/redis- sentinel.pid
línea #20, especifique el archivo de registro PID
"/usr/local/redis/log/sentinel.log"
línea #25, especifique la ruta de almacenamiento de registro
dir /usr/local/redis/data
línea #54, especifique el ruta de almacenamiento de la base de datos
monitor centinela mymaster 192.168.80.10 6379 2
Línea #73, modifique y especifique que el nodo centinela monitorea el nodo maestro 192.168.80.10:6379. El
nombre del nodo maestro es mymaster. El significado de los 2 últimos está relacionado con el juicio de falla del nodo maestro: al menos dos los nodos centinela deben estar de acuerdo con
el juicio Fallo del nodo maestro y conmutación por error
#sentinel auth-pass mymaster abc123
#76 línea, opcional, especifique la contraseña del nodo maestro, solo configure requirepass
sentinel down-after-milliseconds mymaster 3000
#114 line, the el servidor está inactivo El período de tiempo, el valor predeterminado es 30000 milisegundos (30 segundos)
sentinel failover-timeout mymaster 180000
#214 line, el intervalo entre dos failovers del mismo sentinel al mismo maestro (180 segundos)
Paso 2: Inicie el modo centinela
Inicie el maestro primero, luego inicie el esclavo
cd /usr/local/redis/conf/
redis-sentinel sentinel.conf &
-----查看哨兵信息-----
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.5023:6379,esclavos=2,centinelas=3
-----Simulación de fallas-----
#Ver el número de proceso del servidor redis:
ps -ef | grep redis
root 57031 1 0 15:20 ? 00:00:07 /usr/local/bin/redis-server 0.0 .0.0:6379
raíz 57742 1 1 16:05
?
#Elimine el número de proceso de redis-server en el nodo maestro
kill -9 57031 #El número de proceso de redis-server en el nodo maestro
Resultados experimentales
[root@localhost redis-5.0.7]# tail -f /var/log/sentinel.log
#Nuevo maestro crea pares clave-valor
[root@localhost redis-5.0.7]# redis-cli
127.0.0.1: 6379> establecer nuevo nombre lisi
OK
127.0.0.1:6379> obtener nuevo nombre
"lisi"
127.0.0.1:6379>
Resultados de la prueba:
6. Modo de clúster de Redis
El clúster, es decir, el clúster de Redis, es una solución de almacenamiento distribuido introducida por Redis3.0.
El clúster consta de varios nodos (nodos) y los datos de Redis se distribuyen entre estos nodos. Los nodos del 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 de 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 del clúster
(1) Particionamiento de datos: el particionamiento de datos (o fragmentación de datos) es la función principal del clúster.
El clúster distribuye datos a múltiples nodos. Por un lado, supera el límite del tamaño de la memoria de una sola máquina de Redis y la capacidad de almacenamiento aumenta considerablemente; por otro lado, cada nodo maestro puede proporcionar servicios externos de lectura y escritura, lo que mejora en gran medida la capacidad de respuesta del clúster.
El tamaño de la memoria independiente de Redis es limitado, lo cual se mencionó en la introducción de la persistencia y la replicación 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 el 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 principal (similar a Sentinel); cuando falla algún nodo, el clúster aún puede proporcionar servicios externos.
A través del clúster, Redis resuelve el problema de que la operación de escritura no puede equilibrarse con la carga y la capacidad de almacenamiento está limitada por una sola máquina, y realiza una solución de alta disponibilidad relativamente completa.
6.2 Fragmentación de datos del clúster de Redis
Redis Cluster presenta el concepto de ranuras hash.
Redis Cluster tiene 16384 ranuras hash (numeradas 0-16383).
Cada nodo del clúster es responsable de una parte de las ranuras hash.
Después de que cada clave pase la verificación CRC16, tome el resto de 16384 para determinar qué ranura hash colocar. A través de este valor, encuentre el nodo correspondiente a la ranura correspondiente y luego salte directa y automáticamente al nodo correspondiente para las operaciones de acceso.
Tome un clúster compuesto por 3 nodos como ejemplo:
El nodo A contiene ranuras hash de 0 a 5460.
El nodo B contiene ranuras hash de 5461 a 10922. El nodo
c contiene ranuras hash de 10923 a 16383.
7. Implementación del clúster de redis
En un entorno de producción real, el clúster clúster de redis requiere al menos seis servidores. se puede realizar, si es por problemas de rendimiento de la computadora
Puede probar la implementación de instancias múltiples de redis
Despliegue de componentes experimentales
Los pasos específicos del experimento
Paso 1
cd /usr/local/redis/
mkdir -p redis-cluster/redis600{1..6}
for i in {1..6}
do
cp /opt/redis-7.0.9/ redis.conf /usr/local/redis/redis-cluster/redis600$i
cp /opt/redis-7.0.9/src/redis-cli /opt/redis-7.0.9/src/redis-server
/usr/local /redis /redis-cluster/redis600$i
done
Paso 2 #Habilite la función de clúster:
#Los archivos de configuración de las otras 5 carpetas se modifican por analogía, y los 6 puertos deben ser diferentes.
cd /usr/local/redis/redis-cluster/redis6001
vim redis.conf
#bind 127.0.0.1
línea #87, comente el elemento de vinculación, controle todas las tarjetas de red de forma predeterminada en
modo protegido sin
línea #111, cierre el modo de protección
puerto 6001
# 138 OK, modifique el puerto de escucha redis
daemonize sí
#309 línea, establecer como proceso daemon, iniciar
pidfile /usr/local/redis/log/redis_6001.pid
#341 línea, especificar el archivo
de registro del archivo PID "/usr/local/redis/log/redis_6001.log"
#354 Línea , especifique el archivo de registro
dir ./
línea #504, especifique el directorio donde se adjunta el archivo persistente
solo sí
#1379 línea, habilite AOF
habilitado para clúster sí
#1576 línea, elimine el comentario, habilite la función de clúster
cluster-config-file nodes-6001 .conf
#1584 línea, descomentar, conjunto de archivos de nombre de clúster
cluster-node-timeout 15000
#1590 línea, descomentar configuración de tiempo de espera de clúster
Cuando se configura 6001, puede copiar directamente el archivo de configuración a 6002-6006 y luego modificarlo directamente con sed -i
Inicio: sed -i 's/6001/6002/g' usr/local/redis/redis-cluster/redis6002
sed -i 's/6001/6003/g' usr/local/redis/redis-cluster/redis6003
sed -i 's/6001/6004/g' usr/local/redis/redis-cluster/redis6004
sed -i 's/6001/6005/g' usr/local/redis/redis-cluster/redis6005
sed -i 's/6001/6006/g' usr/local/redis/redis-cluster/redis6006
Paso 3 Inicie el nodo de redis
Ingrese las seis carpetas respectivamente y ejecute el comando: redis-server redis.conf para iniciar el nodo de redis
cd /usr/local/redis/redis-cluster/redis-cluster/redis-cluster/redis6001
redis- server redis.conf
o
para d en {1..6}
haz
cd /usr/local/redis/redis-cluster/redis600$d
./redis-server redis.conf
done
ps -ef | grep redis
Paso 4#Iniciar 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, un maestro y un esclavo en cada grupo, el frente es el nodo maestro y el último es el nodo esclavo.
Al interactuar a continuación, debe ingresar sí para crear.
--replicas 1 significa que cada nodo maestro tiene 1 nodo esclavo.
Pruebe el clúster
redis-cli -p 6001 -c #Agregue el parámetro -c, los nodos pueden saltar entre sí
127.0.0.1:6001> ranuras de clúster #Ver el rango de número de ranura hash de los nodos
1) 1) (entero) 5461
2 ) ( entero) 10922 #Rango de número de ranura hash
3) 1) "127.0.0.1"
2) (entero) 6003 #IP de nodo principal y número de puerto
3) "fdca661922216dd69a63a7c9d3c4540cd6baef44"
4) 1) "127.0.0.1"
2) (entero) 6 004 #IP del nodo esclavo y número de puerto
3) "a2c0c32aff0f38980accd2b63d6d952812e44740"
2) 1) (entero) 0
2) (entero) 5460
3) 1) "127.0.0.1"
2) (entero) 6001
3) "0e5873747a2e26bdc935bc76c2bafb19d0a54b11"
4) 1) "127.0.0.1"
2) (entero) 6006
3) "8842ef5584a85005e135fd0ee59e5a0d67b0cf8e"
3) 1) (entero) 10923
2) (entero) 16383
3) 1) "127.0.0.1"
2 ) (entero) 6002
3 ) "816ddaa3d1469540b2ffbcaaf9aa867646846b30"
4) 1) "127.0.0.1"
2) (entero) 6005
3) "f847077bfe6722466e96178ae8cbb09dc8b4d5eb" 127.0.0.1
:6001> establecer nombre zhangsan
-> Redirigido a la ranura [5798] ubicada en 127.0.0.1:6003
OK
127.0 .0.1:6001> cluster keylot name
#Ver el número de ranura de la clave de nombre
redis-cli -p 6004 -c
127.0.0.1: 6004> teclas *
#El nodo esclavo correspondiente también tiene estos datos, pero otros nodos no
1) "nombre"
redis-cli -p 6001 -c nodos de clúster
Paso 5: agregar nodos al clúster clúster para expansión dinámica
El clúster redis 5 admite la expansión dinámica de nodos bajo carga.
El clúster existente tiene 6 nodos 127.0.0.1:6001 - 127.0.0.1:6006 y 3 grupos de nodos maestros y esclavos. Ahora agregue el cuarto grupo de nodos maestro-esclavo 127.0.0.1:6007, 127.0.0.1:6008
1) Primero cree un nodo de clúster, modifique el número de puerto a 6007, 6008 para agregarlo al clúster
2) Cree un nuevo nodo maestro 127.0.0.1:6007
redis-cli -p 6001 --cluster add-node 127.0.0.1 : 6007 127.0.0.1:6001
或
redis-cli -p 6001
reunión de clúster 127.0.0.1 6007
reunión de clúster 127.0.0.1 6008
3) Cree 127.0.0.1:6008 como nodo esclavo de 127.0.0.1:6007
redis-cli --cluster add-node 127.0.0.1:6008 127.0.0.1:6001 --cluster-slave (se puede omitir el siguiente maestro, en caso de que solo haya un maestro y ningún nodo esclavo)
redis-cli -p 6001 --cluster add-node 127.0.0.1:6008 127.0.0.1:6001 --cluster-slave --cluster-master-id e44678abed249e22482559136bf45280fd3ac281
Es necesario especificar un nodo existente en el comando para obtener información del clúster y el ID de nodo del nodo maestro.
4) El nodo maestro recién agregado no tiene número de ranura. Solo cuando se inicialice el clúster, se asignará de acuerdo con los datos del maestro. Por ejemplo, el nodo maestro recién agregado debe asignarse manualmente. Primero, use nodos de clúster para obtener el número de ID de nodo de cada nodo en el
clúster
reshard slots Debido a que redis 5 aún no admite el equilibrio automático de las ranuras, debe calcular la cantidad de ranuras que deben moverse y ejecutar manualmente el comando. En este ejemplo, es necesario mover 1365 ranuras de los tres grupos de nodos maestros existentes al nuevo nodo maestro 127.0.0.1:6007 para lograr el equilibrio
redis-cli -p 6007 --cluster reshard 127.0.0.1:6001 --cluster-from \ e1a033e07f0064e6400825b4ddbcd6680c032d10 --cluster-to \ e44678abed249e22482559136bf45280fd3ac281 --cluster -ranuras 1365 --cluster-sí
De manera similar, los nodos maestros 6002 y 6003 también necesitan mover 1365 ranuras al nodo maestro 6007
O puede transferir ranuras hash de forma interactiva
o
redis-cli -p 6007 --cluster reshard 127.0.0.1:6001
¿Cuántas ranuras desea mover (de 1 a 16384)? 1000
#Especifique la cantidad de ranuras de transferencia ¿
Cuál es la recepción? ¿ID de nodo? e44678abed249e22482559136bf45280fd3ac281
#Especifique el ID de nodo principal del número de ranuras de recepción
Ingrese todas las ID de nodo de origen.
Escriba "todos" para usar todos los nodos como nodos de origen para las ranuras hash.
Escriba "hecho" una vez que haya ingresado todos los ID de los nodos de origen
Nodo de origen n.º 1: e1a033e07f0064e6400825b4ddbcd6680c032d10
#Especifique el ID del nodo maestro asignado
Nodo de origen n.º 2: hecho
#Ingrese la entrada e inicie la transferencia