Redis Cluster (Cluster) Demo-Súper pasos detallados de demostración + Tutorial Spring Boot

El Redis utilizado en este artículo es 5.0.8, por lo que la diferencia con la versión anterior 4.0.X radica en el cambio de la forma de crear un clúster

Sistema utilizado: Centos7.7 de 64 bits

La contraseña unificada establecida en este artículo es: shunleite

Spring Boot 2.0+

Primero, el principio del cluster

En un clúster de Redis, todos los nodos de Redis están interconectados entre sí, y el protocolo binario utilizado dentro de los nodos optimiza la velocidad de transmisión y el ancho de banda.

Después de que un nodo cuelga, solo cuando más de la mitad de los nodos en el clúster persisten en fallar, se considera que el nodo ha fallado. Cualquiera en el clúster de Redis

Los nodos están conectados al cliente Java. La ranura hash se usa para la distribución de datos en el clúster Redis, integrado en el clúster Redis

Hay 16384 ranuras de hash. Cuando haya datos para almacenar, Redis usará primero el algoritmo CRC16 para calcular la clave y obtener el cálculo.

El resultado es el resto de 16384, de modo que cada clave corresponde a una ranura hash con un valor entre 0 y 16383. Redis se basa en esto

El resto almacena estos datos en el nodo Redis correspondiente, y los programadores pueden ajustar cada Redis de acuerdo con el rendimiento de cada instancia de Redis

Rango de distribución de ranuras hash en la instancia

Segundo, planificación distribuida de clústeres

Es necesario comprender algunos conceptos:
un maestro (maestro) puede tener varios esclavos (esclavo), y un esclavo (esclavo) solo puede tener un maestro (maestro)
Además, cada funcionario requiere al menos tres maestros en cada grupo para ejecutar
este El caso toma cada puerto correspondiente a cada servidor para distinguir cada servidor Redis diferente

主节点：111.67.194.61:6661，111.67.194.60:6662，111.67.194.63:6663

从节点：111.67.194.64:6664，111.67.194.65:6665，111.67.202.207:6666

两个用来测试添加主从数据库的节点： 111.67.194.70:6667（主），111.67.194.108:6668（从）

3. Configuración del clúster de Redis

1. Instale la herramienta de administración de clúster (el servidor de clúster big brother 111.67.194.61 se usa para configurar el entorno Ruby, que solo está en este)

Debido a que la herramienta de clúster Redis depende del entorno Ruby, primero debe instalar el entorno Ruby, y debido a que
la versión predeterminada de Ruby en la biblioteca centos7 yum es demasiado baja, por lo que es una herramienta RVM conveniente (los siguientes pasos son para descargar y configurar la clave pública rvm)

gpg2 --keyserver hkp://keys.gnupg.net --recv-keys D39DC0E3
#上面个木有成功就下面那个
gpg2 --keyserver hkp://pool.sks-keyservers.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
curl -L get.rvm.io | bash -s stable
source /usr/local/rvm/scripts/rvm

Vea si RVM se instaló con éxito

rvm list known

Si el verde aparece como se muestra en la imagen, tendrá éxito.

Elija una versión más estable (el tiempo del tutorial es 2020/4/5)

rvm install 2.6.5

Finalmente instale las dependencias de Redia

gem install redis

2. Instalar Redis:

①Descargar Redis

wget http://download.redis.io/releases/redis-5.0.8.tar.gz

Si no hay un comando wget, debe instalarlo y luego ejecutar el comando anterior

yum install wget

② Para instalar Redis,
primero cree una carpeta redisCluster, mueva el archivo descargado y luego instale

mkdir redisCluster
cp -f ./redis-5.0.8.tar.gz ./redisCluster
cd redisCluster
tar -zxvf redis-5.0.8.tar.gz
cd redis-5.0.8
make MALLOC=libc
make install

③Cada uno de los otros dispositivos debe realizar el segundo paso (esta operación se requiere para cada servidor)

RedisCluster continuación, creado bajo cada servidor (incluyendo el servidor de Gran Hermano 111.67.194.61) de una carpeta (para añadir en una sola etapa en la producción de la parte de atrás)
fueron carpeta 6661 6662 6,663,666,466,656,666 (en consonancia con la parte de la planificación anterior)
Más Debajo de cada carpeta, debe copiar el archivo redis.conf en el directorio redis-5.0.8 en el directorio superior a este directorio

cp -f ../redis-5.0.8/redis.conf ./

A continuación, modifique la configuración de redis.conf en la carpeta 666x de cada servidor. La configuración modificada es la siguiente (modificada o no agregada)

port 6661
#bind 127.0.0.1
cluster-enabled yes
cluster-config-file nodes-6661.conf
protected no
daemonize yes
requirepass shunleite
masterrauth shunleite

Mención: Si usa vi, entonces necesita encontrar / modificar lentamente el modo de cadena

    第一为该节点端口与文件夹名一一对应

    第二行是将bind部分注释掉，因为默认是本地乱接，注释掉就可以外网连接Redis了

    第三行表示开启集群

    第四行表示该集群节点的配置文件(注意nodes-666x.conf格式配置方便管理)

    第五行就是关闭保护毕竟你第七行用了密码

    第六行表示允许Redis后台运行

    第七行就是设置密码了

    第八行因为第七行设置了密码所以他就需要个密码认证

④ Abrir instancia de Redis

redis-server /root/redisCluster/6661/redis.conf
redis-server /root/redisCluster/6662/redis.conf
redis-server /root/redisCluster/6663/redis.conf
redis-server /root/redisCluster/6664/redis.conf
redis-server /root/redisCluster/6665/redis.conf
redis-server /root/redisCluster/6666/redis.conf

⑤ Para poder conectarse a Redis de forma remota, también debe cerrar el firewall (o abrir el puerto correspondiente)

systemctl stop firewalld.service
systemctl disable firewalld.service

Regrese al servidor hermano mayor (111.67.194.61) y cambie al directorio redisCluster

3. Cree un clúster (este paso se ejecuta en el servidor hermano mayor)

    提一下：因为设置了密码，一般来说，Redis5.0.x以下的版本是需要将redis-trib.rb文件复制到redisCluster目录下的

    然而我们用的不是（嘻嘻）如果是就需要移

    而且还需修改复制后的redis-trib.rb文件，将@r = Redis.new(:host => @info[:host], :port => @info[:port], :timeout => 60)这行

    修改成@r = Redis.new(:host => @info[:host], :port => @info[:port], :timeout => 60, :password=>"shunleite")

    然后操作就把后面的redis-cli -a shunleite --cluster的部分改成./redis-trib.rb（在你redisCluster目录下）即可（虽然有些细微的不一样比如删除啥

    子，但大多一样，毕竟官方只是进行移植集成操作）

Crea un clúster

redis-cli -a shunleite --cluster create 111.67.194.61:6661 111.67.194.60:6662 111.67.194.63:6663 111.67.194.64:6664 111.67.194.65:6665 111.67.202.207:6666 --cluster-replicas 1

réplicas representa el número de ungüentos para cada nodo maestro. Durante la creación del clúster, se asignará una identificación única y se asignará una ranura.Los
resultados exitosos son los siguientes: nodo maestro de código M, nodo esclavo de código S, las ranuras son los segmentos de ranura asignados, y la identificación detrás de las réplicas representa la identificación del nodo maestro correspondiente

-h 表示实例主机地址 -p表示登陆的集群的端口,-a表示要登陆的集群的密码，-c则便是以集群的方式登陆，登陆成功后随便登陆一个节点

使用cluster nodes命令查询集群节点的信息,cluster info命令查询集群状态信息，此时你会发现已经自动配置好了slot

redis-cli -h 111.67.194.61 -p 6661 -a shunleite -c
cluster info
cluster nodes

4. Adición y eliminación de nodos maestros y esclavos en el clúster Redis

1. El nodo maestro aumenta

En el caso del crecimiento del negocio, no podemos evitar agregar el nodo maestro. Agregar el nodo maestro es construir una instancia del nodo maestro.
① Presione el segundo paso ② y ③, ④, ⑤ del segundo paso en el enlace de configuración del clúster de Redis. Cree una carpeta 6667 en el nodo (configuración

Al igual que los pasos anteriores, no lo demostraré aquí)
② El mismo modelo que Redis: redis-server /root/redisCluster/6667/redis.conf ③Luego
inicie sesión en el servidor hermano mayor (111.67.194.61) para realizar la operación de agregar nodo, agregue- nodo es la operación de agregar un nodo, el parámetro en el medio es el Redis que se agregará

Dirección de instancia, el último parámetro es la dirección de instancia en el clúster

redis-cli -a shunleite --cluster add-node  111.67.194.70:6667 111.67.194.61:6661

Inicie sesión en una instancia en cualquier clúster y ejecute los nodos del clúster para descubrir que la dirección de la instancia se ha agregado correctamente, pero la ranura no está asignada. Preste atención al ID de nodo 6667 del nodo.

    此新节点的ID为：d35877f5646c96fdfce71bdf66f588e8c90fd520

④Vuelva a asignar la siguiente ranura (en este caso, asigne 1,000 ranuras al nuevo nodo maestro)

Debido a que la operación anterior ha asignado el espacio, no hay espacio asignado para el nuevo nodo, es decir, el nuevo nodo de libro no tiene la oportunidad de almacenar datos, por lo que podemos
tomar parte de los otros tres nodos maestros y asignarlos a la nueva instancia del nodo. Se asignan un total de 1000 espacios a nuevos nodos

Si está asignando n ranuras a quién, ingrese la ID de la instancia de Redis que recibe las n ranuras. Puede ver esta ID cuando la agregue, o también puede verla
utilizando el comando de nodos del clúster después de iniciar sesión en el controlador del clúster. . Por ejemplo, tome n ranuras de la instancia con el puerto 6661 y asígnela a la instancia con 6667, luego ingrese la identificación de 6661, presione
Entrar y escriba done para presionar la tecla de retorno.

Inicie sesión en el servidor de big brother (111.67.194.61) y ejecute la siguiente redistribución de código, todos los medios para compartir la instancia original

redis-cli -a shunleite --cluster reshard 111.67.194.61:6661
#接着填入1000
#在填写节点的ID
#填入all

Después del piso:

2. Incremento desde el nodo

Es mucho más fácil aumentar el número de nodos.

① Siga el segundo paso ② y ③, ④, ⑤ del segundo paso en el enlace de configuración del clúster Redis para crear una carpeta 6668 en el nodo 111.67.194.108

Iniciarlo

② Inicie sesión en el servidor hermano mayor (111.67.194.61) y agregue el nodo esclavo. Debe especificar el ID maestro de la respuesta. Los parámetros detrás de –cluster-master-id indican en orden:

La identificación del maestro del nodo esclavo (aquí es 6667 como ejemplo), la dirección del nodo esclavo y la dirección de cualquier instancia en el clúster. El código es el siguiente:

redis-cli -a shunleite --cluster add-node --cluster-slave --cluster-master-id d35877f5646c96fdfce71bdf66f588e8c90fd520 111.67.194.108:6668 111.67.194.61:6661

Después de iniciar sesión en el controlador del clúster e ingresar los nodos del clúster, puede ver que la

nueva versión de Redis por debajo de 5.0.x agrega nuevos nodos esclavos. Debe usar el siguiente comando para agregar nodos secundarios en el directorio redisCluster (el significado del comando es básicamente el mismo que el anterior):

./redis-trib.rb add-node --slave --master-id d35877f5646c96fdfce71bdf66f588e8c90fd520 111.67.194.108:6668 111.67.194.61:6661

3. Eliminación de nodos

Elimine el nodo e inicie sesión en el servidor de Big Brother (111.67.194.61). Utilice el siguiente comando para eliminar el modelo:

del-node significa eliminar nodo. El siguiente parámetro es el nodo que se va a eliminar. Si el nodo eliminado ocupa el espacio, la eliminación fallará, entonces sigue el cuarto paso

Agregue y elimine el nodo maestro y el nodo esclavo del clúster Redis. En el paso 1, paso ④, asigne todas las ranuras del nodo que se va a eliminar y luego ejecute este comando.

Eliminar este comando directamente

redis-cli -a shunleite --cluster del-node 111.67.194.61:6661

Cinco, demostración del caso Spring Boot

A diferencia de Redis de instancia única, la integración de clúster de Redis Spring Boot requiere una configuración manual por parte de los programadores

1. Dependencias de configuración

El grupo de conexiones jedis se implementa en base a apache.commons-pool2. Cuando se construye el objeto del grupo de conexiones, el objeto de configuración del objeto del grupo de conexiones, es decir, JedisPoolConfig

JedisPoolConfig hereda de GenericObjectPoolConfig, podemos usar este objeto de configuración para configurar los parámetros relacionados del grupo de conexiones (como el número máximo de conexiones,

Número máximo de inactividad, etc.)

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
</dependency>

2. Configure la información del clúster (application.yml)

En este momento, es mucho más conveniente usar application.yml, así que simplemente elimine application.properties original y créelo.

Debido a que se utilizan muchos hosts, es suficiente crear dos matrices uno a uno correspondientes, lo que también es conveniente para las operaciones posteriores de agregar y eliminar nodos en producción

max-total representa el número máximo de conexiones en el grupo de conexiones, max-idle representa el número máximo de conexiones inactivas en el grupo de conexiones, max-wait-millis representa el tiempo máximo de espera de bloqueo, el valor predeterminado es -1

Indica que no hay límite, min-idle indica el número mínimo de conexiones en el grupo de conexiones

spring:
  redis:
    cluster:
      ports:
        - 6661
        - 6662
        - 6663
        - 6664
        - 6665
        - 6666
        - 6667
        - 6668
      hosts:
        - 111.67.194.61
        - 111.67.194.60
        - 111.67.194.63
        - 111.67.194.64
        - 111.67.194.65
        - 111.67.202.207
        - 111.67.194.70
        - 111.67.194.108
      poolConfig:
        max-total: 8
        max-idle: 8
        max-wait-millis: -1
        min-idle: 0

3. Configure Redis para crear RedisConfig

Vamos a analizar

RedisAutoConfiguration se proporciona en la clase de configuración automática de SpringBoot para la configuración de Redis. El código fuente es el siguiente:

este código fuente se puede ver, la información de configuración en la aplicación predeterminada. Las propiedades se inyectarán en RedisProperties, si no hay RedisTemplate o

StringRedisTemplate instancia, entonces Spring Boot proporcionará estos dos ejemplos de forma predeterminada, RedisTemplate y StringRedisTemplate proporcionan Redis

Operación básica

Como este caso usa Jedis, más JedisConnectionFactory hereda de RedisConnection

Por lo tanto, debemos configurar y proporcionar manualmente la configuración del clúster Redis, JedisConnectionFactory, RedisTemplate, StringRedisTemplate.

@Configuration
//通过ConfigurationProperties注解声明配置文件前缀，配置文件中定义的ports，hosts数组及连接配置信息都将被注入port、host、poolConfig三个属性中
@ConfigurationProperties("spring.redis.cluster")
public class RedisConfig {
    List<Integer> ports;
    List<String> hosts;
    JedisPoolConfig poolConfig;
    //配置RedisClusterConfiguration实例，设置Redis登陆密码以及Redis节点信息
    @Bean
    RedisClusterConfiguration redisClusterConfiguration(){
        RedisClusterConfiguration configuration = new RedisClusterConfiguration();
        List<RedisNode> nodes = new ArrayList<>();
        for(int i = 0;i<ports.size();i++){
            nodes.add(new RedisNode(hosts.get(i),ports.get(i)));
        }
        //配置RedisClusterConfiguration实例，摄制Redis登陆密码以及Redis节点信息
        configuration.setPassword(RedisPassword.of("shunleite"));
        configuration.setClusterNodes(nodes);
        return configuration;
    }
    //根据RedisClusterConfiguration实例以及连接池配置信息Jedis连接工厂JedisConnectionFactory
    @Bean
    JedisConnectionFactory jedisConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory(redisClusterConfiguration(),poolConfig);
        return factory;
    }
    //根据RedisConnectionFactory创建RedisTemplate和StringRedisTemplate，同时配置key和value的系列化方式。
    // 有了RedisTemplate和StringRedisTemplate，剩下的用法就和单一使用Redis用法一致
    @Bean
    RedisTemplate redisTemplate(){
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(jedisConnectionFactory());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        return redisTemplate;
    }
    @Bean
    StringRedisTemplate stringRedisTemplate(){
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(jedisConnectionFactory());
        stringRedisTemplate.setKeySerializer(new StringRedisSerializer());
        stringRedisTemplate.setValueSerializer(new StringRedisSerializer());
        return stringRedisTemplate;
    }
 
    @Override
    public String toString() {
        return "RedisConfig{" +
                "ports=" + ports +
                ", hosts=" + hosts +
                ", poolConfig=" + poolConfig +
                '}';
    }
 
    public List<Integer> getPorts() {
        return ports;
    }
 
    public void setPorts(List<Integer> ports) {
        this.ports = ports;
    }
 
    public List<String> getHosts() {
        return hosts;
    }
 
    public void setHosts(List<String> hosts) {
        this.hosts = hosts;
    }
 
    public JedisPoolConfig getPoolConfig() {
        return poolConfig;
    }
 
    public void setPoolConfig(JedisPoolConfig poolConfig) {
        this.poolConfig = poolConfig;
    }
}

4. Crear una clase de entidad

public class Customer implements Serializable {
    private String name;
    private String email;
 
    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(String email) {
        this.email = email;
    }
}

5. Crear controlador (prueba directa, solo demostrar cómo usar)

StringRedisTemplate es una subclase de RedisTemplate. La clave y el valor en StringRedisTemplate son cadenas que se utilizan

El esquema de serialización es StringRedisSerializer, y RedisTemplate se puede utilizar para manipular objetos. La serialización adoptada por RedisTemplate

La solución es JdkSerializationRedisSerializer. Ya sea StringRedisTemplate o RedisTemplater, el método de operación de Redis es el mismo.

StringRedisTemplate y RedisTemplate obtienen primero un objeto de operación a través de métodos como opsForValue, opsForZSet u opsForSet,

Luego use el objeto de operación para completar la lectura y escritura de datos

@RestController
public class CustomerController {
    @Autowired
    RedisTemplate redisTemplate;
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    @GetMapping("/test1")
    public void test1(){
        ValueOperations ops = redisTemplate.opsForValue();
        Customer customer = new Customer();
        customer.setName("shunzi");
        customer.setEmail("[email protected]");
        ops.set("customer",customer);
        System.out.println("customer = " + ops.get("customer"));
        ValueOperations<String,String> ops2 = stringRedisTemplate.opsForValue();
        ops2.set("ceshi","数据正确");
        System.out.println("ceshi = " + ops2.get("ceshi"));
    }
}

6. Ingrese 127.0.0.1:8080/test1 para probar

7. Inicie sesión en cualquier instancia del servidor Redis y consulte los datos para ver los resultados de la consulta.

get customer
get ceshi

RedisCluster será responsable de redirigir la solicitud de consulta a la instancia correspondiente.

El tutorial es muy largo y tiene muchos detalles, así que practícalo nuevamente después de leerlo pacientemente. ☺

Casi olvidado, el código fuente del caso se proporciona a continuación

Baidu SkyDrive: https://pan.baidu.com/s/17pNKWjfu_Fb70_x12m5ckQ (snet)

Descarga ordinaria: http://t.cn/A6Z1r6tG

Lan Zuoyun: https://lanzous.com/ib1ip9e