谷粒商城集群篇 (七) --------- Redis 集群

ゝ一世哀愁。 2024-04-03 09:50 99阅读 0赞

#### 目录 ####

*  一、Redis 集群形式
 *   *  1. 数据分区方案
     *  2. 高可用方式
 *  二、Redis-Cluster
 *   *  1. 槽
     *  2. 一致性 hash
     *  3. 部署 Cluster

--------------------

## 一、Redis 集群形式 ##

### 1. 数据分区方案 ###

![在这里插入图片描述][94be9986fa194827a7fd63e5b5ae5e02.png]

**A、客户端分区**

客户端分区方案的代表为 Redis Sharding，Redis Sharding 是 Redis Cluster 出来之前，业界普遍使用的 Redis 多实例集群方法。

Java 的 Redis 客户端驱动库 Jedis，支持 Redis Sharding 功能，即 ShardedJedis 以及 结合缓存池 的 ShardedJedisPool。

优点：

> 不使用 第三方中间件，分区逻辑 可控，配置 简单，节点之间无关联，容易线性扩展，灵活性强。

缺点：

> 客户端 无法 动态增删 服务节点，客户端需要自行维护 分发逻辑，客户端之间无连接共享，会造成 连接浪费。

**B、代理分区**

![在这里插入图片描述][7d742317892b445b8694ee6db0e1b1b1.png]  
代理分区常用方案有 Twemproxy 和 Codis。

**C、redis-cluster**

![在这里插入图片描述][f4b21eda5574447ab6cf08f4bebdff6e.png]  
redis 从 3.0 开始支持集群功能。redis 集群采用无中心节点方式实现，无需 proxy 代理，客户端直接与redis 集群的每个节点连接，根据同样的 hash 算法计算出 key 对应的 slot，然后直接在 slot 对应的 redisj 节点上执行命令。在 redis 看来，响应时间是最苛刻的条件，增加一层带来的开销是 redis 不能接受的。因此，redis 实现了客户端对节点的直接访问，为了去中心化，节点之间通过 gossip 协议交换互相的状态，以及探测新加入的节点信息。redis 集群支持动态加入节点，动态迁移 slot，以及自动故障转移。

![在这里插入图片描述][c194fac846054b8080875d60ff9da202.png]

redis cluster 是一个去中心化的集群，每个节点都会跟其他节点保持连接，用来交换彼此的信息。节点组成集群的方式使用 cluster meet 命令，meet 命令可以让两个节点相互握手，然后通过 gossip 协议交换信息。如果一个节点 r1 在集群中，新节点 r4 加入的时候与 r1 节点握手，r1 节点会把集群内的其他节点信息通过 gossip 协议发送给 r4，r4 会一一与这些节点完成握手，从而加入到集群中。

### 2. 高可用方式 ###

**A、Sentinel (哨兵机制) 支持高可用**

前面介绍了主从机制，但是从运维角度来看，主节点出现了问题我们还需要通过人工干预的方式把从节点设为主节点，还要通知应用程序更新主节点地址，这种方式非常繁琐笨重，而且主节点的读写能力都十分有限，有没有较好的办法解决这两个问题，哨兵机制就是针对第一个问题的有效解决方案，第二个问题则有赖于集群！哨兵的作用就是监控Redis 系统的运行状况，其功能主要是包括以下三个：

*  监控(Monitoring)： 哨兵(sentinel) 会不断地检查你的 Master 和 Slave 是否运作正常。
 *  提醒(Notification)： 当被监控的某个 Redis 出现问题时, 哨兵(sentinel) 可以通过 API 向管理员或者其他应用程序发送通知。
 *  自动故障迁移(Automatic failover)： 当主数据库出现故障时自动将从数据库转换为主数据库。

![在这里插入图片描述][1c3ed0e083c4457eb560e7a097e3abb6.png]  
**哨兵的原理**

Redis 哨兵的三个定时任务，Redis 哨兵判定一个 Redis 节点故障不可达主要就是通过三个定时监控任务来完成的：

*  每隔 10 秒每个哨兵节点会向主节点和从节点发送"info replication" 命令来获取最新的拓扑结构

![在这里插入图片描述][ad39ed3e57984d0a9f0e6995c7ab8a51.png]

*  每隔 2 秒每个哨兵节点会向 Redis 节点的`_sentinel_:hello` 频道发送自己对主节点是否故障的判断以及自身的节点信息，并且其他的哨兵节点也会订阅这个频道来了解其他哨兵节点的信息以及对主节点的判断
 *  每隔 1 秒每个哨兵会向主节点、从节点、其他的哨兵节点发送一个 “ping” 命令来做心跳检测

![在这里插入图片描述][b972b3e0b4d74c75b82cd6aaf69dc286.png]

如果在定时 Job3 检测不到节点的心跳，会判断为“主观下线”。如果该节点还是主节点那么还会通知到其他的哨兵对该主节点进行心跳检测，这时主观下线的票数超过了`<quorum>`数时，那么这个主节点确实就可能是故障不可达了，这时就由原来的主观下线变为了“客观下线”。

**故障转移和 Leader 选举**

如果主节点被判定为客观下线之后，就要选取一个哨兵节点来完成后面的故障转移工作，选举出一个 leader，这里面采用的选举算法为 Raft。选举出来的哨兵 leader 就要来完成故障转移工作，也就是在从节点中选出一个节点来当新的主节点，这部分的具体流程可参考引用。

[https://blog.csdn.net/nuomizhende45/article/details/82831966][https_blog.csdn.net_nuomizhende45_article_details_82831966]

## 二、Redis-Cluster ##

[https://redis.io/topics/cluster-tutorial/][https_redis.io_topics_cluster-tutorial]

Redis 的官方多机部署方案，Redis Cluster。一组 Redis Cluster 是由多个Redis 实例组成，官方推荐我们使用 6 实例，其中 3 个为主节点，3 个为从结点。一旦有主节点发生故障的时候，Redis Cluster 可以选举出对应的从结点成为新的主节点，继续对外服务，从而保证服务的高可用性。那么对于客户端来说，知道知道对应的 key 是要路由到哪一个节点呢？

Redis Cluster 把所有的数据划分为 16384 个不同的槽位，可以根据机器的性能把不同的槽位分配给不同的 Redis 实例，对于 Redis 实例来说，他们只会存储部分的 Redis 数据，当然，槽的数据是可以迁移的，不同的实例之间，可以通过一定的协议，进行数据迁移。

![在这里插入图片描述][411e0797b9c34d5b84e0ea8e33fb006e.png]

### 1. 槽 ###

![在这里插入图片描述][c4dc25c7a3054b5c9b6ed28fe8937a11.png]  
Redis 集群的功能限制：

> Redis 集群相对单机在功能上存在一些限制，需要开发人员提前了解，在使用时做好规避。

**JAVA CRC16 校验算法**

> CRC即循环冗余校验码（Cyclic Redundancy Check\[1\] ）：是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。

具体实现：

/**
     * 基于Modbus CRC16的校验算法工具类
     */
    public class Crc16Util {
        
    
        /**
         * 获取源数据和验证码的组合byte数组
         * @param strings 可变长度的十六进制字符串
         * @return
         */
        public static byte[] getData(String...strings) {
        
            byte[] data = new byte[]{
        };
            for (int i = 0; i<strings.length;i++) {
        
                int x = Integer.parseInt(strings[i], 16);
                byte n = (byte)x;
                byte[] buffer = new byte[data.length+1];
                byte[] aa = {
        n};
                System.arraycopy( data,0,buffer,0,data.length);
                System.arraycopy( aa,0,buffer,data.length,aa.length);
                data = buffer;
            }
            return getData(data);
        }
        /**
         * 获取源数据和验证码的组合byte数组
         * @param aa 字节数组
         * @return
         */
        private static byte[] getData(byte[] aa) {
        
            byte[] bb = getCrc16(aa);
            byte[] cc = new byte[aa.length+bb.length];
            System.arraycopy(aa,0,cc,0,aa.length);
            System.arraycopy(bb,0,cc,aa.length,bb.length);
            return cc;
        }
        /**
         * 获取验证码byte数组，基于Modbus CRC16的校验算法
         */
        private static byte[] getCrc16(byte[] arr_buff) {
        
            int len = arr_buff.length;
    
            // 预置 1 个 16 位的寄存器为十六进制FFFF, 称此寄存器为 CRC寄存器。
            int crc = 0xFFFF;
            int i, j;
            for (i = 0; i < len; i++) {
        
                // 把第一个 8 位二进制数据 与 16 位的 CRC寄存器的低 8 位相异或, 把结果放于 CRC寄存器
                crc = ((crc & 0xFF00) | (crc & 0x00FF) ^ (arr_buff[i] & 0xFF));
                for (j = 0; j < 8; j++) {
        
                    // 把 CRC 寄存器的内容右移一位( 朝低位)用 0 填补最高位, 并检查右移后的移出位
                    if ((crc & 0x0001) > 0) {
        
                        // 如果移出位为 1, CRC寄存器与多项式A001进行异或
                        crc = crc >> 1;
                        crc = crc ^ 0xA001;
                    } else
                        // 如果移出位为 0,再次右移一位
                        crc = crc >> 1;
                }
            }
            return intToBytes(crc);
        }
        /**
         * 将int转换成byte数组，低位在前，高位在后
         * 改变高低位顺序只需调换数组序号
         */
        private static byte[] intToBytes(int value)  {
        
            byte[] src = new byte[2];
            src[1] =  (byte) ((value>>8) & 0xFF);
            src[0] =  (byte) (value & 0xFF);
            return src;
        }
        /**
         * 将字节数组转换成十六进制字符串
         */
        public static String byteTo16String(byte[] data) {
        
            StringBuffer buffer = new StringBuffer();
            for (byte b : data) {
        
                buffer.append(byteTo16String(b));
            }
            return buffer.toString();
        }
        /**
         * 将字节转换成十六进制字符串
         * int转byte对照表
         * [128,255],0,[1,128)
         * [-128,-1],0,[1,128)
         */
        public static String byteTo16String(byte b) {
        
            StringBuffer buffer = new StringBuffer();
            int aa = (int)b;
            if (aa<0) {
        
                buffer.append(Integer.toString(aa+256, 16)+" ");
            }else if (aa==0) {
        
                buffer.append("00 ");
            }else if (aa>0 && aa<=15) {
        
                buffer.append("0"+Integer.toString(aa, 16)+" ");
            }else if (aa>15) {
        
                buffer.append(Integer.toString(aa, 16)+" ");
            }
            return buffer.toString();
        }
    }

*  key 批量操作支持有限。
    
     *  类似 mset、mget 操作，目前只支持对具有相同 slot 值的 key 执行 批量操作。对于映射为不同 slot 值的 key 由于执行 mget、mget 等操作可能存在于多个节点上，因此不被支持。
 *  key 事务操作支持有限。
    
     *  只支持多 key 在同一节点上的事务操作，当多个 key 分布在 不同的节点上时无法使用事务功能。
 *  key 作为 数据分区 的最小粒度
 *  不能将一个大的键值对象如 hash、list 等映射到不同的节点。
 *  不支持 多数据库空间
    
     *  单机下的 Redis 可以支持 16 个数据库 (db0 ~ db15)，集群模式下只能使用 一个 数据库空间，即 db0。
 *  复制结构只支持一层
    
     *  从节点只能复制主节点，不支持嵌套树状复制结构。
 *  命令大多会重定向，耗时多。

![在这里插入图片描述][b827197cc96b45e2bc8f5d932de79831.png]

### 2. 一致性 hash ###

一致性哈希 可以很好的解决 稳定性问题，可以将所有的存储节点排列在 收尾接 的 Hash 环上，每个 key 在计算 Hash 后会 顺时针找到临接的存储节点 存放。而当有节点加入或退出时，仅影响该节点在 Hash 环上 顺时针相邻 的 后续节点 。

![在这里插入图片描述][6a99c8b74eed4925b5288d1fb95bf4d2.png]  
**Hash 倾斜**

如果节点很少，容易出现倾斜，负载不均衡问题。一致性哈希算法，引入了虚拟节点，在整个环上，均衡增加若干个节点。比如 a1，a2，b1，b2，c1，c2，a1 和 a2 都是属于 A 节点的。解决 hash 倾斜问题。

### 3. 部署 Cluster ###

**A、创建 6 个 redis 节点**

3 主 3 从方式，从为了同步备份，主进行 slot 数据分片

将以下内容复制粘贴至命令行。。

for port in $(seq 7001 7006); \
    do \
    mkdir -p /mydata/redis/node-${port}/conf
    touch /mydata/redis/node-${port}/conf/redis.conf
    cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
    port ${port}
    cluster-enabled yes
    cluster-config-file nodes.conf
    cluster-node-timeout 5000
    cluster-announce-ip 192.168.56.10
    cluster-announce-port ${port}
    cluster-announce-bus-port 1${port}
    appendonly yes
    EOF
    docker run -p ${port}:${port} -p 1${port}:1${port} --name redis-${port} \ 
      -v /mydata/redis/node-${port}/data:/data \ 
      -v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \ 
      -d redis:5.0.7 redis-server /etc/redis/redis.conf; \
    done

docker stop $(docker ps -a |grep redis-700 | awk '{ print $1}')
    docker rm $(docker ps -a |grep redis-700 | awk '{ print $1}')

**B、使用 redis 建立集群**

docker exec -it redis-7001 bash
    redis-cli --cluster create 192.168.56.10:7001 192.168.56.10:7002 192.168.56.10:7003192.168.56.10:7004 192.168.56.10:7005 192.168.56.10:7006 --cluster-replicas 1

**C、测试集群效果**

随便进入某个 redis 容器

docker exec -it redis-7002 /bin/bash

使用 redis-cli 的 cluster 方式进行连接

redis-cli -c -h 192.168.56.10 -p 7006

*  cluster info：获取集群信息
 *  cluster nodes：获取集群节点

Get/Set 命令测试，将会重定向

--------------------

节点宕机，slave 会自动提升为 master，master 开启后变为 slave

[94be9986fa194827a7fd63e5b5ae5e02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/6c1c6d7b9658488c84270dc2de956f73.png
[7d742317892b445b8694ee6db0e1b1b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/6ff0389934bd4adba2178b13ab369ef2.png
[f4b21eda5574447ab6cf08f4bebdff6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/eb8469c3bcb84f60b7250b01a7f2ed11.png
[c194fac846054b8080875d60ff9da202.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/d89a816a2cb2441b9799bd6a1af6ffa6.png
[1c3ed0e083c4457eb560e7a097e3abb6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/575b65e940b040d7983849dbd971dfea.png
[ad39ed3e57984d0a9f0e6995c7ab8a51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/290af6b13e454b85815f0703ab732a4e.png
[b972b3e0b4d74c75b82cd6aaf69dc286.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/de5a410d2c904cc6aaa2793594d139fa.png
[https_blog.csdn.net_nuomizhende45_article_details_82831966]: https://blog.csdn.net/nuomizhende45/article/details/82831966
[https_redis.io_topics_cluster-tutorial]: https://redis.io/topics/cluster-tutorial/
[411e0797b9c34d5b84e0ea8e33fb006e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4ba93f4800974cb5b389d41f41be9692.png
[c4dc25c7a3054b5c9b6ed28fe8937a11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/6c1e5059113b4ef3876c01c226854b1f.png
[b827197cc96b45e2bc8f5d932de79831.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/8ff7d99780cc43b992246b070fb871bb.png
[6a99c8b74eed4925b5288d1fb95bf4d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/6bf398123e764476a6a0089d05aeb352.png