Redis(无中心化集群搭建)

文章目录

    • 1.无中心化集群
        • 1.基本介绍
        • 2.集群说明
        • 2.基本环境搭建
            • 1.部署规划(6台服务器)
            • 2.首先删除上次的rdb和aof文件(对之前的三台服务器都操作)
              • 1.首先分别登录命令行,关闭redis
              • 2.清除/root/下的rdb和aof文件
              • 3.把上次的哨兵也关闭
              • 3.对新增的三台机器Redis进行初始化
                • 1.安装Redis
                  • 1.yum安装gcc
                  • 2.查看gcc版本
                  • 3.将redis6.2.6上传到/opt目录下
                  • 4.进入/opt目录下然后解压
                  • 5.进入 redis-6.2.6目录
                  • 6.编译并安装
                  • 7.进入 /usr/local/bin 查看是否有redis的命令
                  • 2.启动并使用Redis
                    • 1.进入 /opt/redis-6.2.6/
                    • 2.将里面的redis.conf复制一份到/etc下
                    • 3.编辑 /etc/redis.conf,将daemonize no修改成daemonize yes即以守护进程的方式启动(后台启动)
                    • 4.启动redis,指定刚才的配置文件
                    • 5.查看redis进程
                    • 3.Redis基本配置
                    • 编辑配置文件
                      • 1.修改端口为7489 port 6379
                      • 2.设置redis密码 requirepass foobared
                      • 3.设置redis节点连接其他redis的密码 masterauth(与requirepass 一致即可)
                      • 4.使redis支持远程访问 bind 127.0.0.1 -::1 和 protected-mode
                      • 5.登录redis的命令行,关闭redis(此时配置文件未生效,所以端口还是6379)
                      • 6.重新启动redis,使配置生效
                      • 4.开启7489端口
                        • 1.宝塔开启端口
                        • 2.腾讯云开启端口(只允许本机ip访问,为了方便允许所有ipv4也行,因为配置了密码)
                        • 5.Redis持久化配置
                          • 1.进入redis配置文件
                          • 2.dbfilename为redis持久化的文件名(一般不用改)
                          • 3.dir ./ 修改为/root/则每次持久化的dump.rdb都会在/root/下,恢复时无论在哪里启动,都会读取这个文件进行恢复
                          • 4.开启AOF持久化配置,编辑配置文件找到appendonly,设置成yes
                          • 5.进入命令行关闭redis,需要指定端口,密码,命令
                          • 6.重新启动redis,使配置生效
                          • 7.发现/root/下面有个配置文件,如果没有dump.rdb是因为redis库中还没东西
                          • 6.测试Java连接redis
                            • 1.引入jedis的jar包
                            • 2.编写测试程序
                            • 3.Redis无中心化集群搭建
                                • 1.前提条件
                                  • 1.确保六台服务器都按照前面的要求初始化了
                                  • 2.Redis集群单个节点配置(六个服务器都进行这个操作)
                                    • 1.都进入redis配置文件
                                    • 2.配置下面的三个东西,搜索 REDIS CLUSTER
                                    • 3.配置解释
                                    • 4.进行配置
                                    • 5.重启redis(在解决了下面的问题再重启)
                                    • 6.报错了(只有之前配置过了主从模式才会报错)
                                      • 1.原因是之前的主从模式导致了这行在配置文件中持久化了,而集群模式会与这个冲突,删除即可
                                      • 2.编辑配置文件,找到这行,删除即可
                                      • 3.再次启动redis,发现以集群模式启动了
                                      • 7.查看dir下是否生成对应节点文件
                                      • 3.将六个节点合成一个集群
                                        • 1.基本介绍
                                        • 2.合成指令
                                        • 3.执行报错 [ERR] Node NOAUTH Authentication required.
                                        • 4.添加一个--askpass参数,要求输入密码即可
                                        • 5.输入密码之后再输入yes
                                        • 6.一直在连接,原因是还需要开放总线端口就是redis的端口 + 10000
                                        • 7.六个服务器都要开放redis总线端口
                                          • 1.在宝塔开启redis总线端口7489 + 10000 = 17489
                                          • 2.在腾讯云开放17489端口
                                          • 8.重新执行命令创建集群,连接成功!如果想要查找是谁的从,就看replicates后面的字符跟Master对应
                                            • 1.示意图
                                            • 2.找出对应关系
                                            • 9.所以小结一下,创建集群的方式
                                              • 1.开放Redis的总线端口为 redis端口 + 10000
                                              • 2.创建集群指令
                                              • 4.集群方式登录
                                                • 1.登录并验证
                                                • 2.查看节点关系
                                                • 3.注意事项
                                                • 5.Redis插槽机制
                                                  • 1.一个Redis集群中包含16384个插槽,编号为0-16383,
                                                  • 2.集群使用公式CRC16(key)% 16384来计算键key属于哪个插槽,从而将其存放到不同的主机上,其中CRC16(key)计算的是key的校验和
                                                  • 3.示意图
                                                  • 6.在集群录入值
                                                    • 1.首先确保登录时带的 -c参数实现自动重定向
                                                      • 1.关于密码,第一种方式是直接在连接时指定
                                                      • 2.第二种方式是连接后让他询问(推荐)
                                                      • 3.如果不对密码进行设置,则每次切换到其他服务时都要重新输入密码
                                                      • 2.录入数据则会触发插槽机制
                                                      • 3.不在同一个slot下,是不能使用mget,mset等操作的
                                                        • 1.演示
                                                        • 2.解决方式:通过 {} 来定义组,从而使key中{}内相同内容的放到同一个slot中
                                                        • 7.查询集群中的值
                                                          • 1.返回key对应的插槽值
                                                          • 2.返回插槽中有多少个key,注意,只能在该节点管理的slot范围内查找,否则为0
                                                          • 3.返回count个slot槽中的键
                                                          • 8.集群的故障恢复(注意15s超时,再观察)
                                                            • 1.如果主节点down掉了,从节点自动升级为主节点
                                                              • 1.关闭主节点
                                                              • 2.查看节点状态,父节点down了,子节点自动升级
                                                              • 2.如果主节点恢复了,就会降级为子节点
                                                                • 1.启动 主节点
                                                                • 2.再次查看节点状态,已经被降级
                                                                • 3.如果主从节点都挂掉了(概率很低),可以配置服务是否继续
                                                                • 9.集群的Jedis开发
                                                                  • 1.基本说明
                                                                  • 2.引入依赖
                                                                  • 3.代码演示
                                                                  • 4.结果展示(没有做日志配置,所以会爆红)
                                                                  • 10.Redis集群的优缺点
                                                                    • 1.优点
                                                                    • 2.缺点

                                                                      1.无中心化集群

                                                                      1.基本介绍
                                                                      2.集群说明

                                                                      2.基本环境搭建

                                                                      1.部署规划(6台服务器)
                                                                      2.首先删除上次的rdb和aof文件(对之前的三台服务器都操作)
                                                                      1.首先分别登录命令行,关闭redis
                                                                      /usr/local/bin/redis-cli -p 7489 -a **** shutdown
                                                                      
                                                                      2.清除/root/下的rdb和aof文件
                                                                      cd && rm -rf appendonly.aof && rm -rf dump.rdb
                                                                      
                                                                      3.把上次的哨兵也关闭
                                                                      3.对新增的三台机器Redis进行初始化
                                                                      1.安装Redis
                                                                      1.yum安装gcc
                                                                      yum install gcc
                                                                      
                                                                      2.查看gcc版本
                                                                      gcc --version
                                                                      
                                                                      3.将redis6.2.6上传到/opt目录下
                                                                      4.进入/opt目录下然后解压
                                                                      cd /opt && tar -zxvf redis-6.2.6.tar.gz
                                                                      
                                                                      5.进入 redis-6.2.6目录
                                                                      cd redis-6.2.6
                                                                      
                                                                      6.编译并安装
                                                                      make && make install
                                                                      
                                                                      7.进入 /usr/local/bin 查看是否有redis的命令
                                                                      cd /usr/local/bin && ll
                                                                      
                                                                      2.启动并使用Redis
                                                                      1.进入 /opt/redis-6.2.6/
                                                                      cd /opt/redis-6.2.6/
                                                                      
                                                                      2.将里面的redis.conf复制一份到/etc下
                                                                      cp redis.conf /etc/redis.conf
                                                                      
                                                                      3.编辑 /etc/redis.conf,将daemonize no修改成daemonize yes即以守护进程的方式启动(后台启动)
                                                                      vim /etc/redis.conf
                                                                      
                                                                      4.启动redis,指定刚才的配置文件
                                                                      /usr/local/bin/redis-server /etc/redis.conf
                                                                      
                                                                      5.查看redis进程
                                                                      ps -aux | grep redis
                                                                      
                                                                      3.Redis基本配置
                                                                      编辑配置文件
                                                                      vim /etc/redis.conf
                                                                      
                                                                      1.修改端口为7489 port 6379
                                                                      2.设置redis密码 requirepass foobared
                                                                      3.设置redis节点连接其他redis的密码 masterauth(与requirepass 一致即可)
                                                                      4.使redis支持远程访问 bind 127.0.0.1 -::1 和 protected-mode
                                                                      5.登录redis的命令行,关闭redis(此时配置文件未生效,所以端口还是6379)
                                                                      /usr/local/bin/redis-cli shutdown
                                                                      
                                                                      6.重新启动redis,使配置生效
                                                                      /usr/local/bin/redis-server /etc/redis.conf && ps -aux | grep redis
                                                                      
                                                                      4.开启7489端口
                                                                      1.宝塔开启端口
                                                                      systemctl start firewalld && firewall-cmd --permanent --add-port=7489/tcp && firewall-cmd --reload && firewall-cmd --query-port=7489/tcp
                                                                      
                                                                      2.腾讯云开启端口(只允许本机ip访问,为了方便允许所有ipv4也行,因为配置了密码)
                                                                      5.Redis持久化配置
                                                                      1.进入redis配置文件
                                                                      vim /etc/redis.conf
                                                                      
                                                                      2.dbfilename为redis持久化的文件名(一般不用改)
                                                                      3.dir ./ 修改为/root/则每次持久化的dump.rdb都会在/root/下,恢复时无论在哪里启动,都会读取这个文件进行恢复
                                                                      4.开启AOF持久化配置,编辑配置文件找到appendonly,设置成yes
                                                                      5.进入命令行关闭redis,需要指定端口,密码,命令
                                                                      /usr/local/bin/redis-cli -p 7489 -a **** shutdown
                                                                      
                                                                      6.重新启动redis,使配置生效
                                                                      /usr/local/bin/redis-server /etc/redis.conf && ps -aux | grep redis
                                                                      
                                                                      7.发现/root/下面有个配置文件,如果没有dump.rdb是因为redis库中还没东西
                                                                      6.测试Java连接redis
                                                                      1.引入jedis的jar包
                                                                      2.编写测试程序
                                                                       public static void main(String[] args) { // 连接服务器的redis命令行
                                                                              Jedis jedis = new Jedis("你的redisip", 7489);
                                                                              // 如果redis设置了密码要先进行验证
                                                                              jedis.auth("******");
                                                                              String ping = jedis.ping();
                                                                              System.out.println(ping);
                                                                          }
                                                                      

                                                                      3.Redis无中心化集群搭建

                                                                      1.前提条件
                                                                      1.确保六台服务器都按照前面的要求初始化了
                                                                      2.Redis集群单个节点配置(六个服务器都进行这个操作)
                                                                      1.都进入redis配置文件
                                                                      vim /etc/redis.conf
                                                                      
                                                                      2.配置下面的三个东西,搜索 REDIS CLUSTER
                                                                      3.配置解释
                                                                      4.进行配置
                                                                      5.重启redis(在解决了下面的问题再重启)
                                                                      /usr/local/bin/redis-cli -p 7489 -a **** shutdown && /usr/local/bin/redis-server /etc/redis.conf && ps -aux | grep redis
                                                                      
                                                                      6.报错了(只有之前配置过了主从模式才会报错)
                                                                      1.原因是之前的主从模式导致了这行在配置文件中持久化了,而集群模式会与这个冲突,删除即可
                                                                      2.编辑配置文件,找到这行,删除即可
                                                                      3.再次启动redis,发现以集群模式启动了
                                                                      /usr/local/bin/redis-server /etc/redis.conf && ps -aux | grep redis
                                                                      
                                                                      7.查看dir下是否生成对应节点文件
                                                                      cd && ll
                                                                      
                                                                      3.将六个节点合成一个集群
                                                                      1.基本介绍
                                                                      2.合成指令
                                                                      /usr/local/bin/redis-cli --cluster create --cluster-replicas 1 *******
                                                                      
                                                                      3.执行报错 [ERR] Node NOAUTH Authentication required.
                                                                      4.添加一个–askpass参数,要求输入密码即可
                                                                      /usr/local/bin/redis-cli --cluster create --cluster-replicas 1 --askpass **********
                                                                      
                                                                      5.输入密码之后再输入yes
                                                                      6.一直在连接,原因是还需要开放总线端口就是redis的端口 + 10000
                                                                      7.六个服务器都要开放redis总线端口
                                                                      1.在宝塔开启redis总线端口7489 + 10000 = 17489
                                                                      firewall-cmd --permanent --add-port=17489/tcp && firewall-cmd --reload && firewall-cmd --query-port=17489/tcp
                                                                      
                                                                      2.在腾讯云开放17489端口
                                                                      8.重新执行命令创建集群,连接成功!如果想要查找是谁的从,就看replicates后面的字符跟Master对应
                                                                      1.示意图
                                                                      2.找出对应关系
                                                                      9.所以小结一下,创建集群的方式
                                                                      1.开放Redis的总线端口为 redis端口 + 10000
                                                                      2.创建集群指令
                                                                      /usr/local/bin/redis-cli --cluster create --cluster-replicas 1 --askpass *****************
                                                                      
                                                                      4.集群方式登录
                                                                      1.登录并验证
                                                                      redis-cli -c -p 7489
                                                                      
                                                                      2.查看节点关系
                                                                      cluster nodes
                                                                      
                                                                      3.注意事项
                                                                      5.Redis插槽机制
                                                                      1.一个Redis集群中包含16384个插槽,编号为0-16383,
                                                                      2.集群使用公式CRC16(key)% 16384来计算键key属于哪个插槽,从而将其存放到不同的主机上,其中CRC16(key)计算的是key的校验和
                                                                      3.示意图
                                                                      6.在集群录入值
                                                                      1.首先确保登录时带的 -c参数实现自动重定向
                                                                      1.关于密码,第一种方式是直接在连接时指定
                                                                      redis-cli -c -p 7489 -a ****
                                                                      
                                                                      2.第二种方式是连接后让他询问(推荐)
                                                                      redis-cli -c -p 7489 --askpass
                                                                      
                                                                      3.如果不对密码进行设置,则每次切换到其他服务时都要重新输入密码
                                                                      2.录入数据则会触发插槽机制
                                                                      3.不在同一个slot下,是不能使用mget,mset等操作的
                                                                      1.演示
                                                                      2.解决方式:通过 {} 来定义组,从而使key中{}内相同内容的放到同一个slot中
                                                                      7.查询集群中的值
                                                                      1.返回key对应的插槽值
                                                                      cluster keyslot 
                                                                      2.返回插槽中有多少个key,注意,只能在该节点管理的slot范围内查找,否则为0
                                                                      cluster countkeysinslot 
                                                                      3.返回count个slot槽中的键
                                                                      cluster getkeysinslot  
                                                                      8.集群的故障恢复(注意15s超时,再观察)
                                                                      1.如果主节点down掉了,从节点自动升级为主节点
                                                                      1.关闭主节点
                                                                      /usr/local/bin/redis-cli -p 7489 -a ***  shutdown
                                                                      
                                                                      2.查看节点状态,父节点down了,子节点自动升级
                                                                      cluster nodes
                                                                      
                                                                      2.如果主节点恢复了,就会降级为子节点
                                                                      1.启动 主节点
                                                                      /usr/local/bin/redis-server /etc/redis.conf && ps -aux | grep redis
                                                                      
                                                                      2.再次查看节点状态,已经被降级
                                                                      cluster nodes
                                                                      
                                                                      3.如果主从节点都挂掉了(概率很低),可以配置服务是否继续
                                                                      9.集群的Jedis开发
                                                                      1.基本说明
                                                                      2.引入依赖
                                                                        redis.clients jedis 3.2.0 
                                                                      3.代码演示
                                                                       public static void main(String[] args) { Set hostAndPorts = new HashSet();
                                                                              // 添加集群节点,可以是多个,保证容错性
                                                                              hostAndPorts.add(new HostAndPort("", 7489));
                                                                              // 创建 JedisPoolConfig 并设置密码
                                                                              JedisPoolConfig poolConfig = new JedisPoolConfig();
                                                                              String password = ""; // 将 "你的密码" 替换为你的 Redis 密码
                                                                              // 创建 JedisCluster 对象时传入密码
                                                                              redis.clients.jedis.JedisCluster jedisCluster = new redis.clients.jedis.JedisCluster(hostAndPorts, 2000, 2000, 5, password, poolConfig);
                                                                              try { // 设置和获取值
                                                                                  jedisCluster.set("k1", "v1");
                                                                                  String k1 = jedisCluster.get("k1");
                                                                                  System.out.println("k1=" + k1);
                                                                              } finally { // 确保在最后关闭 JedisCluster 来释放资源
                                                                                      jedisCluster.close();
                                                                              }
                                                                          }
                                                                      
                                                                      4.结果展示(没有做日志配置,所以会爆红)
                                                                      10.Redis集群的优缺点
                                                                      1.优点
                                                                      2.缺点