`

Redis集群

Redis 
阅读更多
1. Redis集群概述 

Redis Cluster与Redis3.0.0同时发布，以此结束了Redis无官方集群方案的时代。
redis cluster是去中心化，去中间件的，也就是说，集群中的每个节点都是平等的关系，都是对等的，每个节点都保存各自的数据和整个集群的状态。每个节点都和其他所有节点连接，而且这些连接保持活跃，这样就保证了我们只需要连接集群中的任意一个节点，就可以获取到其他节点的数据。
那么redis是如何合理分配这些节点和数据的呢？
Redis集群没有并使用传统的一致性哈希来分配数据，而是采用另外一种叫做哈希槽(hash slot)的方式来分配的。redis cluster默认分配了16384个slot，当我们set一个key 时，会用CRC16算法来取模得到所属的slot，然后将这个key分到哈希槽区间的节点上，具体算法就是：CRC16(key) % 16384。
注意的是：必须要3个以后的主节点，否则在创建集群时会失败，我们在后续会实践到。
所以，我们假设现在有3个节点已经组成了集群，分别是：A, B, C 三个节点，它们可以是一台机器上的三个端口，也可以是三台不同的服务器。那么，采用哈希槽 (hash slot)的方式来分配16384个slot 的话，它们三个节点分别承担的slot 区间是：
节点A覆盖0－5460;
节点B覆盖5461－10922;
节点C覆盖10923－16383.
那么，现在我想设置一个key ,比如叫my_name:set my_name wind
按照redis cluster的哈希槽算法：CRC16(‘my_name’)%16384 = 2412。 那么就会把这个key的存储分配到A上了。
同样，当我连接(A,B,C)任何一个节点想获取my_name这个key时，也会这样的算法，然后内部跳转到B节点上获取数据。
这种哈希槽的分配方式有好也有坏，好处就是很清晰，比如我想新增一个节点D，redis cluster的这种做法是从各个节点的前面各拿取一部分slot到D上，我会在接下来的实践中实验。大致就会变成这样：
节点A覆盖1365-5460
节点B覆盖6827-10922
节点C覆盖12288-16383
节点D覆盖0-1364,5461-6826,10923-12287
同样删除一个节点也是类似，移动完成后就可以删除这个节点了。
Redis Cluster主从模式
redis cluster 为了保证数据的高可用性，加入了主从模式，一个主节点对应一个或多个从节点，主节点提供数据存取，从节点则是从主节点拉取数据备份，当这个主节点挂掉后，就会有这个从节点选取一个来充当主节点，从而保证集群不会挂掉。
上面那个例子里, 集群有ABC三个主节点, 如果这3个节点都没有加入从节点，如果B挂掉了，我们就无法访问整个集群了。A和C的slot也无法访问。
所以我们在集群建立的时候，一定要为每个主节点都添加了从节点, 比如像这样, 集群包含主节点A、B、C, 以及从节点A1、B1、C1, 那么即使B挂掉系统也可以继续正确工作。
B1节点替代了B节点，所以Redis集群将会选择B1节点作为新的主节点，集群将会继续正确地提供服务。 当B重新开启后，它就会变成B1的从节点。
不过需要注意，如果节点B和B1同时挂了，Redis集群就无法继续正确地提供服务了。
集群的时候，我们可以单机集群也可以多机集群。


2. Redis单机多节点集群

2.1 安装Redis 

Reids安装包里有个集群工具，要复制到/usr/local/bin里去
    [root@#localhost ~]# cp redis-3.2.9/src/redis-trib.rb /usr/local/bin


2.2 修改配置，创建节点 

我们现在要搞六个节点，三主三从，端口规定分别是7001，7002，7003，7004，7005，7006
我们先在root目录下新建一个redis_cluster目录，然后该目录下再创建6个目录，分别是7001，7002，7003，7004，7005，7006，用来存在redis配置文件；
这里我们要使用redis集群，要先修改redis的配置文件redis.conf
新建目录redis_cluster
    [root@#localhost ~]# mkdir redis_cluster
    [root@#localhost ~]# cd redis_cluster/
    [root@#localhost redis_cluster]# mkdir 7001 7002 7003 7004 7005 7006
    [root@#localhost redis_cluster]# ll
    总用量 0
    drwxr-xr-x. 2 root root 6 2月  28 04:23 7001
    drwxr-xr-x. 2 root root 6 2月  28 04:23 7002
    drwxr-xr-x. 2 root root 6 2月  28 04:23 7003
    drwxr-xr-x. 2 root root 6 2月  28 04:23 7004
    drwxr-xr-x. 2 root root 6 2月  28 04:23 7005
    drwxr-xr-x. 2 root root 6 2月  28 04:23 7006
先复制一份配置文件到7001目录下
    [root@#localhost redis_cluster]# cd
    [root@#localhost ~]# cp redis-3.2.9/redis.conf redis_cluster/7001/
修改下这个配置文件
    [root@#localhost ~]# vi redis_cluster/7001/redis.conf
    修改一下几个
        port 7001  // 六个节点配置文件分别是7001-7006
        daemonize yes  // redis后台运行
        pidfile /var/run/redis_7001.pid  // pidfile文件对应7001-7006
        cluster-enabled yes  // 开启集群
        cluster-config-file nodes_7001.conf  // 保存节点配置，自动创建，自动更新对应7001-7006
        cluster-node-timeout 5000  // 集群超时时间，节点超过这个时间没反应就断定是宕机
        appendonly yes  // 存储方式，aof，将写操作记录保存到日志中
7001下的修改完后，我们把7001下的配置分别复制到7002-7006 然后对应的再修改下配置即可；
    [root@#localhost ~]# cp redis_cluster/7001/redis.conf redis_cluster/7002/
    [root@#localhost ~]# cp redis_cluster/7001/redis.conf redis_cluster/7003/
    [root@#localhost ~]# cp redis_cluster/7001/redis.conf redis_cluster/7004/
    [root@#localhost ~]# cp redis_cluster/7001/redis.conf redis_cluster/7005/
    [root@#localhost ~]# cp redis_cluster/7001/redis.conf redis_cluster/7006/
编辑后面5个配置文件，把 port ，pidfile，cluster-config-file 分别修改下即可；
    [root@#localhost ~]# vi redis_cluster/7002/redis.conf
        port 7001  // 六个节点配置文件分别是7001-7006
        pidfile /var/run/redis_7001.pid  // pidfile文件对应7001-7006
        cluster-config-file nodes_7001.conf  // 保存节点配置，自动创建，自动更新对应7001-7006
    [root@#localhost ~]# vi redis_cluster/7003/redis.conf
    [root@#localhost ~]# vi redis_cluster/7004/redis.conf
    [root@#localhost ~]# vi redis_cluster/7005/redis.conf
    [root@#localhost ~]# vi redis_cluster/7006/redis.conf


2.3 启动六个节点的redis 

启动六个节点
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7001/redis.conf 
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7002/redis.conf 
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7003/redis.conf 
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7004/redis.conf 
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7005/redis.conf 
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7006/redis.conf 
查找下redis进程
    [root@#localhost ~]# ps -ef | grep redis
    root       7607      1  0 04:36 ?        00:00:00 /usr/local/redis/bin/redis-server 127.0.0.1:7001 [cluster]
    root       7613      1  0 04:36 ?        00:00:00 /usr/local/redis/bin/redis-server 127.0.0.1:7002 [cluster]
    root       7617      1  0 04:36 ?        00:00:00 /usr/local/redis/bin/redis-server 127.0.0.1:7003 [cluster]
    root       7621      1  0 04:36 ?        00:00:00 /usr/local/redis/bin/redis-server 127.0.0.1:7004 [cluster]
    root       7625      1  0 04:36 ?        00:00:00 /usr/local/redis/bin/redis-server 127.0.0.1:7005 [cluster]
    root       7630      1  0 04:36 ?        00:00:00 /usr/local/redis/bin/redis-server 127.0.0.1:7006 [cluster]
    root       7634   7281  0 04:37 pts/0    00:00:00 grep --color=auto redis
    说明都启动成功了！


2.4 创建集群 

redis官方提供了redis-trib.rb工具，第一步里已经房到里bin下；
但是在使用之前需要安装ruby，以及redis和ruby连接
    [root@#localhost ~]# yum -y install ruby ruby-devel rubygems rpm-build
    [root@#localhost ~]# gem install redis


这里会应该版本不匹配报错
    Fetching: redis-4.1.0.gem (100%)
    ERROR:  Error installing redis:
        redis requires Ruby version >= 2.2.2.

解决方案：
    [root@#localhost ~]# yum install centos-release-scl-rh
    [root@#localhost ~]# yum install rh-ruby23  -y
    [root@#localhost ~]# scl  enable  rh-ruby23 bash
    [root@#localhost ~]# ruby -v
    [root@#localhost ~]# gem install redis


创建集群
    [root@#localhost ~]# redis-trib.rb create --replicas 1 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006
    >>> Creating cluster
    >>> Performing hash slots allocation on 6 nodes...
    Using 3 masters:
    127.0.0.1:7001
    127.0.0.1:7002
    127.0.0.1:7003
    Adding replica 127.0.0.1:7004 to 127.0.0.1:7001
    Adding replica 127.0.0.1:7005 to 127.0.0.1:7002
    Adding replica 127.0.0.1:7006 to 127.0.0.1:7003
    M: d00cac026f8cfa21733df7ec23e5fb1cf9335785 127.0.0.1:7001
       slots:0-5460 (5461 slots) master
    M: 019a7ff44dca53bc08f9c62628ad6a067dfa32a3 127.0.0.1:7002
       slots:5461-10922 (5462 slots) master
    M: 3c31f267a21125c71bca05f44cd10361b14bc2e0 127.0.0.1:7003
       slots:10923-16383 (5461 slots) master
    S: 74c2dc28292335563185fd617bbe12e7366fe958 127.0.0.1:7004
       replicates d00cac026f8cfa21733df7ec23e5fb1cf9335785
    S: 0b0a7238542085dc1900ccfa7532062423cd9e3c 127.0.0.1:7005
       replicates 019a7ff44dca53bc08f9c62628ad6a067dfa32a3
    S: 08771230d07dd4ff2205de8c1042dd711a98c62d 127.0.0.1:7006
       replicates 3c31f267a21125c71bca05f44cd10361b14bc2e0
    Can I set the above configuration? (type 'yes' to accept): yes

    从运行结果看，主节点就是7001 7002 7003从节点分别是7004 7005 7006 
    7001分配到的哈希槽是 0-5460
    7002分配到的哈希槽是 5461-10922
    7003分配到的哈希槽是 10923-16383
    最后问我们是否接受上面的设置，输入yes就表示接受，我们输入yes然后显示：
    
    >>> Nodes configuration updated
    >>> Assign a different config epoch to each node
    >>> Sending CLUSTER MEET messages to join the cluster
    Waiting for the cluster to join...
    >>> Performing Cluster Check (using node 127.0.0.1:7001)
    M: d00cac026f8cfa21733df7ec23e5fb1cf9335785 127.0.0.1:7001
       slots:0-5460 (5461 slots) master
       1 additional replica(s)
    M: 3c31f267a21125c71bca05f44cd10361b14bc2e0 127.0.0.1:7003
       slots:10923-16383 (5461 slots) master
       1 additional replica(s)
    S: 0b0a7238542085dc1900ccfa7532062423cd9e3c 127.0.0.1:7005
       slots: (0 slots) slave
       replicates 019a7ff44dca53bc08f9c62628ad6a067dfa32a3
    M: 019a7ff44dca53bc08f9c62628ad6a067dfa32a3 127.0.0.1:7002
       slots:5461-10922 (5462 slots) master
       1 additional replica(s)
    S: 74c2dc28292335563185fd617bbe12e7366fe958 127.0.0.1:7004
       slots: (0 slots) slave
       replicates d00cac026f8cfa21733df7ec23e5fb1cf9335785
    S: 08771230d07dd4ff2205de8c1042dd711a98c62d 127.0.0.1:7006
       slots: (0 slots) slave
       replicates 3c31f267a21125c71bca05f44cd10361b14bc2e0
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.
显示配置哈希槽，以及集群创建成功，可以用了。


2.5 集群数据测试 

我们先连接任意一个节点，然后添加一个key：
redis-cli是redis默认的客户端工具，启动时加上'-c'参数，'-p'指定端口，就可以连接到集群。 
连接任意一个节点端口：
    [root@#localhost ~]# /usr/local/redis/bin/redis-cli -c -p 7002
    127.0.0.1:7002>
正确连接到7002端口
    127.0.0.1:7002> set xxx 'test7002port'
    -> Redirected to slot [4038] located at 127.0.0.1:7001
    OK

前面说过Redis Cluster值分配规则，所以分配key的时候，它会使用CRC16('my_name')%16384算法来计算，将这个key放到哪个节点，这里分配到了4038slot 就分配到了7001(0-5460)这个节点上。所以有：Redirected to slot [4038] located at 127.0.0.1:7001
我们从其他集群节点，都可以获取到数据
    127.0.0.1:7001> exit
    [root@localhost ~]# /usr/local/redis/bin/redis-cli -c -p 7005
    127.0.0.1:7005> get xxx
    -> Redirected to slot [4038] located at 127.0.0.1:7001
    "test7002port"
    127.0.0.1:7001>


2.6 集群宕机测试 

假如干掉一个节点，比如7002这个主节点
    [root@#localhost ~]# ps -ef | grep redis
    root       7607      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7001 [cluster]
    root       7613      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7002 [cluster]
    root       7617      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7003 [cluster]
    root       7621      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7004 [cluster]
    root       7625      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7005 [cluster]
    root       7630      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7006 [cluster]
    root       7909   7875  0 05:37 pts/0    00:00:00 grep --color=auto redis
    [root@#localhost ~]# kill -9 7613
    [root@#localhost ~]# ps -ef | grep redis
    root       7607      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7001 [cluster]
    root       7617      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7003 [cluster]
    root       7621      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7004 [cluster]
    root       7625      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7005 [cluster]
    root       7630      1  0 04:36 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7006 [cluster]
    root       7913   7875  0 05:42 pts/0    00:00:00 grep --color=auto redis
    [root@#localhost ~]# 

然后再来看下集群的情况
    [root@#localhost ~]# redis-trib.rb check 127.0.0.1:7001
    >>> Performing Cluster Check (using node 127.0.0.1:7001)
    M: d00cac026f8cfa21733df7ec23e5fb1cf9335785 127.0.0.1:7001
       slots:0-5460 (5461 slots) master
       1 additional replica(s)
    M: 3c31f267a21125c71bca05f44cd10361b14bc2e0 127.0.0.1:7003
       slots:10923-16383 (5461 slots) master
       1 additional replica(s)
    M: 0b0a7238542085dc1900ccfa7532062423cd9e3c 127.0.0.1:7005
       slots:5461-10922 (5462 slots) master
       0 additional replica(s)
    S: 74c2dc28292335563185fd617bbe12e7366fe958 127.0.0.1:7004
       slots: (0 slots) slave
       replicates d00cac026f8cfa21733df7ec23e5fb1cf9335785
    S: 08771230d07dd4ff2205de8c1042dd711a98c62d 127.0.0.1:7006
       slots: (0 slots) slave
       replicates 3c31f267a21125c71bca05f44cd10361b14bc2e0
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.
我们发现7005本来是从节点，由于他对应的主节点挂了，就自动变成主节点master。
有最后一个说明All 16384 slots covered. 所有哈希槽都可覆盖了，集群可以正常使用。

假如我们把7005也干掉，试试看
    [root@#localhost ~]# kill -9 7625
    [root@#localhost ~]# ps -ef | grep redis
    root       9501      1  0 17:38 ?        00:00:03 /usr/local/redis/bin/redis-server 127.0.0.1:7001 [cluster]
    root       9516      1  0 17:45 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7003 [cluster]
    root       9520      1  0 17:45 ?        00:00:03 /usr/local/redis/bin/redis-server 127.0.0.1:7004 [cluster]
    root       9528      1  0 17:45 ?        00:00:02 /usr/local/redis/bin/redis-server 127.0.0.1:7006 [cluster]
    root       9610   2186  0 18:16 pts/0    00:00:00 grep --color=auto redis
    [root@localhost ~]# 

查看下集群情况
    [root@#localhost ~]# redis-trib.rb check 127.0.0.1:7001
    >>> Performing Cluster Check (using node 127.0.0.1:7001)
    M: d00cac026f8cfa21733df7ec23e5fb1cf9335785 127.0.0.1:7001
       slots:0-5460 (5461 slots) master
       1 additional replica(s)
    M: 3c31f267a21125c71bca05f44cd10361b14bc2e0 127.0.0.1:7003
       slots:10923-16383 (5461 slots) master
       1 additional replica(s)
    S: 74c2dc28292335563185fd617bbe12e7366fe958 127.0.0.1:7004
       slots: (0 slots) slave
       replicates d00cac026f8cfa21733df7ec23e5fb1cf9335785
    S: 08771230d07dd4ff2205de8c1042dd711a98c62d 127.0.0.1:7006
       slots: (0 slots) slave
       replicates 3c31f267a21125c71bca05f44cd10361b14bc2e0
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [ERR] Not all 16384 slots are covered by nodes.
这里我们发现报错了，因为主从节点都挂了所以有一部分哈希槽没得分配。
最后一句[ERR] Not all 16384 slots are covered by nodes.没有安全覆盖；所以不能正常使用集群。


3. Redis多机多节点集群

3.1 环境准备 

搞两台虚拟机
    虚拟机 --> 管理 --> 克隆 --> 完整克隆

ip addr查询两个不同的ip是192.168.18.4和192.168.18.8

使用Xshell连接两个不同的虚拟机。


3.2 安装Redis 

------------------已经操作过了，可以忽略------------------
安装Redis
192.168.18.4虚拟机里，Reids安装包里有个集群工具，要复制到/usr/local/bin里去
    [root@#localhost ~]# cp redis-3.2.9/src/redis-trib.rb /usr/local/bin
----------------------------------------------------------


3.3 修改配置，创建节点 

------------------已经操作过了，可以忽略------------------
首先我们在192.168.18.4虚拟机里创建三个节点，端口分别是7001，7002，7003
我们先在root目录下新建一个redis_cluster目录，然后该目录下再创建3个目录，
分别是7001，7002，7003，用来存redis配置文件；
这里我们要使用redis集群，要先修改redis的配置文件redis.conf
mkdir redis_cluster 新建目录
    [root@#localhost ~]# cd redis_cluster/
    [root@#localhost redis_cluster]# mkdir 7001 7002 7003
    [root@#localhost redis_cluster]# ll
    总用量 0
    drwxr-xr-x. 2 root root 6 7月  27 19:49 7001
    drwxr-xr-x. 2 root root 6 7月  27 19:49 7002
    drwxr-xr-x. 2 root root 6 7月  27 19:49 7003
    [root@localhost redis_cluster]# 
先复制一份配置文件到7001目录下
    [root@#localhost redis_cluster]# cd
    [root@#localhost ~]# cp redis-3.2.9/redis.conf redis_cluster/7001/
----------------------------------------------------------

(1)首先清理没有用的文件
    [root@#localhost ~]# ll
    总用量 1552
    -rw-------. 1 root root    1259 2月  21 06:31 anaconda-ks.cfg
    -rw-r--r--. 1 root root      64 2月  28 05:35 appendonly.aof
    -rw-r--r--. 1 root root      76 2月  28 05:48 dump.rdb
    -rw-r--r--. 1 root root     735 2月  28 05:45 nodes-7001.conf
    -rw-r--r--. 1 root root     733 2月  28 05:33 nodes-7002.conf
    -rw-r--r--. 1 root root     735 2月  28 05:45 nodes-7003.conf
    -rw-r--r--. 1 root root     729 2月  28 05:45 nodes-7004.conf
    -rw-r--r--. 1 root root     715 2月  28 05:42 nodes-7005.conf
    -rw-r--r--. 1 root root     735 2月  28 05:45 nodes-7006.conf
    drwxrwxr-x. 6 root root    4096 5月  17 2017 redis-3.2.9
    -rw-r--r--. 1 root root 1547695 5月  17 2017 redis-3.2.9.tar.gz
    drwxr-xr-x. 8 root root      78 2月  28 04:23 redis_cluster
    [root@#localhost ~]# rm -rf dump.rdb
    [root@#localhost ~]# rm -rf appendonly.aof
    [root@#localhost ~]# rm -rf nodes-7001.conf
    [root@#localhost ~]# rm -rf nodes-7002.conf
    [root@#localhost ~]# rm -rf nodes-7003.conf
    [root@#localhost ~]# rm -rf nodes-7004.conf
    [root@#localhost ~]# rm -rf nodes-7005.conf
    [root@#localhost ~]# rm -rf nodes-7006.conf
    [root@#localhost ~]# cd redis_cluster/
    [root@#localhost redis_cluster]# ll
    总用量 0
    drwxr-xr-x. 2 root root 24 2月  28 04:29 7001
    drwxr-xr-x. 2 root root 24 2月  28 04:31 7002
    drwxr-xr-x. 2 root root 24 2月  28 04:32 7003
    drwxr-xr-x. 2 root root 24 2月  28 04:33 7004
    drwxr-xr-x. 2 root root 24 2月  28 04:34 7005
    drwxr-xr-x. 2 root root 24 2月  28 04:34 7006
    [root@#localhost redis_cluster]# rm -rf 7004
    [root@#localhost redis_cluster]# rm -rf 7005
    [root@#localhost redis_cluster]# rm -rf 7006
修改文件
    [root@#localhost redis_cluster]# cd
    [root@#localhost ~]# vi redis_cluster/7001/redis.conf
        修改以下几个
        port 7001  // 三个节点配置文件分别是7001-7003
        bind 192.168.18.4  // 默认ip为127.0.0.1 需要改为其他节点机器可访问的ip 否则创建集群时无法访，和单机集群有区别
        daemonize yes  // redis后台运行
        pidfile /var/run/redis_7001.pid  // pidfile文件对应7001-7003
        cluster-enabled yes  // 开启集群
        cluster-config-file nodes_7001.conf  // 保存节点配置，自动创建，自动更新对应7001-7003
        cluster-node-timeout 5000  // 集群超时时间，节点超过这个时间没反应就断定是宕机
        appendonly yes  / 存储方式，aof，将写操作记录保存到日志中
同理修改另外两个文件
    [root@#localhost ~]# vi redis_cluster/7002/redis.conf
    [root@#localhost ~]# vi redis_cluster/7003/redis.conf

------------------已经操作过了，可以忽略------------------
7001下的修改完后，我们把7001下的配置分别复制到7002-7003 然后对应的再修改下配置即可；
[root@#localhost ~]# cp redis_cluster/7001/redis.conf redis_cluster/7002/
[root@#localhost ~]# cp redis_cluster/7001/redis.conf redis_cluster/7003/
----------------------------------------------------------

(2) 在clone虚拟机上执行相同的操作，首先清理没有用的文件
    [root@#localhost ~]# ll
    总用量 1552
    -rw-------. 1 root root    1259 2月  21 06:31 anaconda-ks.cfg
    -rw-r--r--. 1 root root      64 2月  28 05:35 appendonly.aof
    -rw-r--r--. 1 root root      76 2月  28 05:48 dump.rdb
    -rw-r--r--. 1 root root     735 2月  28 05:45 nodes-7001.conf
    -rw-r--r--. 1 root root     733 2月  28 05:33 nodes-7002.conf
    -rw-r--r--. 1 root root     735 2月  28 05:45 nodes-7003.conf
    -rw-r--r--. 1 root root     729 2月  28 05:45 nodes-7004.conf
    -rw-r--r--. 1 root root     715 2月  28 05:42 nodes-7005.conf
    -rw-r--r--. 1 root root     735 2月  28 05:45 nodes-7006.conf
    drwxrwxr-x. 6 root root    4096 5月  17 2017 redis-3.2.9
    -rw-r--r--. 1 root root 1547695 5月  17 2017 redis-3.2.9.tar.gz
    drwxr-xr-x. 8 root root      78 2月  28 04:23 redis_cluster
    [root@#localhost ~]# rm -rf dump.rdb
    [root@#localhost ~]# rm -rf appendonly.aof
    [root@#localhost ~]# rm -rf nodes-7001.conf
    [root@#localhost ~]# rm -rf nodes-7002.conf
    [root@#localhost ~]# rm -rf nodes-7003.conf
    [root@#localhost ~]# rm -rf nodes-7004.conf
    [root@#localhost ~]# rm -rf nodes-7005.conf
    [root@#localhost ~]# rm -rf nodes-7006.conf
    [root@#localhost ~]# cd redis_cluster/
    [root@#localhost redis_cluster]# ll
    总用量 0
    drwxr-xr-x. 2 root root 24 2月  28 04:29 7001
    drwxr-xr-x. 2 root root 24 2月  28 04:31 7002
    drwxr-xr-x. 2 root root 24 2月  28 04:32 7003
    drwxr-xr-x. 2 root root 24 2月  28 04:33 7004
    drwxr-xr-x. 2 root root 24 2月  28 04:34 7005
    drwxr-xr-x. 2 root root 24 2月  28 04:34 7006
    [root@#localhost redis_cluster]# rm -rf 7001
    [root@#localhost redis_cluster]# rm -rf 7002
    [root@#localhost redis_cluster]# rm -rf 7003
修改文件
    [root@#localhost redis_cluster]# cd
    [root@#localhost ~]# vi redis_cluster/7004/redis.conf
        修改以下内容
            port 7004  // 三个节点配置文件分别是7004-7006
            bind 192.168.18.8  // 默认ip为127.0.0.1 需要改为其他节点机器可访问的ip 否则创建集群时无法访，和单机集群有区别
            daemonize yes  // redis后台运行
            pidfile /var/run/redis_7004.pid  // pidfile文件对应7004-7006
            cluster-enabled yes  // 开启集群
            cluster-config-file nodes_7004.conf  // 保存节点配置，自动创建，自动更新对应7004-7006
            cluster-node-timeout 5000  // 集群超时时间，节点超过这个时间没反应就断定是宕机
            appendonly yes  // 存储方式，aof，将写操作记录保存到日志中
同理修改另外两个文件
    [root@#localhost ~]# vi redis_cluster/7005/redis.conf
    [root@#localhost ~]# vi redis_cluster/7006/redis.conf
------------------已经操作过了，可以忽略------------------
7004下的修改完后，我们把7001下的配置分别复制到7005-7006 然后对应的再修改下配置即可；
    [root@#localhost ~]# cp redis_cluster/7004/redis.conf redis_cluster/7005/
    [root@#localhost ~]# cp redis_cluster/7004/redis.conf redis_cluster/7006/
----------------------------------------------------------


3.4 启动两台机器的六个节点 

192.168.18.4机器
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7001/redis.conf
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7002/redis.conf
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7003/redis.conf
    [root@#localhost ~]# ps -ef | grep redis
    root       7372      1  0 06:23 ?        00:00:00 /usr/local/redis/bin/redis-server 192.168.18.4:7001 [cluster]
    root       7376      1  0 06:23 ?        00:00:00 /usr/local/redis/bin/redis-server 192.168.18.4:7002 [cluster]
    root       7380      1  0 06:24 ?        00:00:00 /usr/local/redis/bin/redis-server 192.168.18.4:7003 [cluster]
    root       7384   7315  0 06:24 pts/0    00:00:00 grep --color=auto redis
192.168.18.8机器
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7004/redis.conf
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7005/redis.conf
    [root@#localhost ~]# /usr/local/redis/bin/redis-server redis_cluster/7006/redis.conf
    [root@#localhost ~]# ps -ef | grep redis
    root       7343      1  0 06:24 ?        00:00:00 /usr/local/redis/bin/redis-server 192.168.18.8:7004 [cluster]
    root       7347      1  0 06:24 ?        00:00:00 /usr/local/redis/bin/redis-server 192.168.18.8:7005 [cluster]
    root       7351      1  0 06:24 ?        00:00:00 /usr/local/redis/bin/redis-server 192.168.18.8:7006 [cluster]
    root       7355   7290  0 06:24 pts/0    00:00:00 grep --color=auto redis
说明都启动OK


3.5 设置防火墙，开放集群端口 

两台机器的防火墙我们直接关掉
    [root@#localhost ~]# systemctl stop firewalld.service


3.6 创建集群 
192.168.18.4机器作为集群控制端

------------------已经操作过了，可以忽略------------------
redis官方提供了redis-trib.rb工具，第一步里已经放到里bin下；
但是在使用之前需要安装ruby，以及redis和ruby连接
    [root@#localhost ~]# yum -y install ruby ruby-devel rubygems rpm-build
----------------------------------------------------------

需要安装redis和ruby连接
    [root@#localhost ~]# gem install redis
    这里会应该版本不匹配报错
        Fetching: redis-4.1.0.gem (100%)
        ERROR:  Error installing redis:
            redis requires Ruby version >= 2.2.2.

    解决方案：
        [root@#localhost ~]# yum install centos-release-scl-rh
        [root@#localhost ~]# yum install rh-ruby23  -y
        [root@#localhost ~]# scl  enable  rh-ruby23 bash
        [root@#localhost ~]# ruby -v
        [root@#localhost ~]# gem install redis

创建集群
    [root@#localhost ~]# redis-trib.rb create --replicas 1  192.168.18.4:7001 192.168.18.4:7002 192.168.18.4:7003 192.168.18.8:7004 192.168.18.8:7005 192.168.18.8:7006
    >>> Creating cluster
    >>> Performing hash slots allocation on 6 nodes...
    Using 3 masters:
    192.168.18.4:7001
    192.168.18.8:7004
    192.168.18.4:7002
    Adding replica 192.168.18.8:7005 to 192.168.18.4:7001
    Adding replica 192.168.18.4:7003 to 192.168.18.8:7004
    Adding replica 192.168.18.8:7006 to 192.168.18.4:7002
    M: b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8 192.168.18.4:7001
       slots:0-5460 (5461 slots) master
    M: b1750afac16a2f3912c6ac68b2421864cb958bb8 192.168.18.4:7002
       slots:10923-16383 (5461 slots) master
    S: a63d95745d7937153bb446c40296df89eab54abf 192.168.18.4:7003
       replicates 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084
    M: 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084 192.168.18.8:7004
       slots:5461-10922 (5462 slots) master
    S: 42813846e4bac77d3d3f958ebc550a8d80767844 192.168.18.8:7005
       replicates b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8
    S: e183d0e666776f42e32c08df52a00782a0e2d69a 192.168.18.8:7006
       replicates b1750afac16a2f3912c6ac68b2421864cb958bb8
    Can I set the above configuration? (type 'yes' to accept): yes
    
    从运行结果看 主节点就是7001 7004 7002 从节点分别是7005 7003 7006 
    7001分配到的哈希槽是 0-5460
    7004分配到的哈希槽是 5461-10922
    7002分配到的哈希槽是 10923-16383
    最后问我们是否接受上面的设置，输入yes 就表示接受，我们输入yes
    然后显示：

    >>> Nodes configuration updated
    >>> Assign a different config epoch to each node
    >>> Sending CLUSTER MEET messages to join the cluster
    Waiting for the cluster to join...
    >>> Performing Cluster Check (using node 192.168.18.4:7001)
    M: b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8 192.168.18.4:7001
       slots:0-5460 (5461 slots) master
       1 additional replica(s)
    S: e183d0e666776f42e32c08df52a00782a0e2d69a 192.168.18.8:7006
       slots: (0 slots) slave
       replicates b1750afac16a2f3912c6ac68b2421864cb958bb8
    M: 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084 192.168.18.8:7004
       slots:5461-10922 (5462 slots) master
       1 additional replica(s)
    S: 42813846e4bac77d3d3f958ebc550a8d80767844 192.168.18.8:7005
       slots: (0 slots) slave
       replicates b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8
    S: a63d95745d7937153bb446c40296df89eab54abf 192.168.18.4:7003
       slots: (0 slots) slave
       replicates 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084
    M: b1750afac16a2f3912c6ac68b2421864cb958bb8 192.168.18.4:7002
       slots:10923-16383 (5461 slots) master
       1 additional replica(s)
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.
显示配置哈希槽，以及集群创建成功，可以用了。


3.7 集群数据测试 

先连接任意一个节点，然后添加一个key：
redis-cli是redis默认的客户端工具，启动时加上’-c'参数，'-p'指定端口，就可以连接到集群。
这里还得加-h指定机器IP 
连接任意一个节点端口：
    [root@#localhost ~]# /usr/local/redis/bin/redis-cli -h 192.168.18.4 -c -p 7002
    192.168.18.4:7002> 
连接到7002节点
    192.168.1.109:7002> set xxx '18.4port7002'
    -> Redirected to slot [4038] located at 192.168.18.4:7001
    OK
根据Redis Cluster值分配规则，所以分配key的时候，它会使用CRC16('my_name')%16384算法，来计算，将这个key放到哪个节点，这里分配到了4038slot 就分配到了7001(0-5460)这个节点上。所以有：
Redirected to slot [4038] located at 192.168.18.4:7001
从其他集群节点，都可以获取到数据
    192.168.18.4:7001> exit
    [root@#localhost ~]# /usr/local/redis/bin/redis-cli -h 192.168.18.8 -c -p 7005
    192.168.18.8:7005> get xxx
    -> Redirected to slot [4038] located at 192.168.18.4:7001
    "18.4port7002"
    192.168.18.4:7001>


3.8 集群宕机测试 

假如我们干掉一个节点，比如7002这个主节点
    [root@#localhost ~]# ps -ef | grep redis
    root       7372      1  0 06:23 ?        00:00:01 /usr/local/redis/bin/redis-server 192.168.18.4:7001 [cluster]
    root       7376      1  0 06:23 ?        00:00:01 /usr/local/redis/bin/redis-server 192.168.18.4:7002 [cluster]
    root       7380      1  0 06:24 ?        00:00:01 /usr/local/redis/bin/redis-server 192.168.18.4:7003 [cluster]
    root       7480   7455  0 06:46 pts/0    00:00:00 grep --color=auto redis
    [root@#localhost ~]# kill -9 7376
    [root@#localhost ~]# ps -ef | grep redis
    root       7372      1  0 06:23 ?        00:00:01 /usr/local/redis/bin/redis-server 192.168.18.4:7001 [cluster]
    root       7380      1  0 06:24 ?        00:00:01 /usr/local/redis/bin/redis-server 192.168.18.4:7003 [cluster]
    root       7482   7455  0 06:46 pts/0    00:00:00 grep --color=auto redis

然后我们查看下集群情况
    [root@#localhost ~]# redis-trib.rb check 192.168.18.4:7001
    >>> Performing Cluster Check (using node 192.168.18.4:7001)
    M: b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8 192.168.18.4:7001
       slots:0-5460 (5461 slots) master
       1 additional replica(s)
    M: e183d0e666776f42e32c08df52a00782a0e2d69a 192.168.18.8:7006
       slots:10923-16383 (5461 slots) master
       0 additional replica(s)
    M: 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084 192.168.18.8:7004
       slots:5461-10922 (5462 slots) master
       1 additional replica(s)
    S: 42813846e4bac77d3d3f958ebc550a8d80767844 192.168.18.8:7005
       slots: (0 slots) slave
       replicates b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8
    S: a63d95745d7937153bb446c40296df89eab54abf 192.168.18.4:7003
       slots: (0 slots) slave
       replicates 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.

我们发现7006本来是从节点，由于他对应的主节点挂了，就自动变成主节点master。
所以会有最后一个说明All 16384 slots covered. 所有哈希槽都可覆盖了，集群可以正常使用。

假如我们把7006也干掉，试试看
    [root@#localhost ~]# ps -ef | grep redis
    root       7343      1  0 06:24 ?        00:00:02 /usr/local/redis/bin/redis-server 192.168.18.8:7004 [cluster]
    root       7347      1  0 06:24 ?        00:00:02 /usr/local/redis/bin/redis-server 192.168.18.8:7005 [cluster]
    root       7351      1  0 06:24 ?        00:00:02 /usr/local/redis/bin/redis-server 192.168.18.8:7006 [cluster]
    root       7415   7290  0 06:48 pts/0    00:00:00 grep --color=auto redis
    [root@#localhost ~]# kill -9 7351
    [root@#localhost ~]# ps -ef | grep redis
    root       7343      1  0 06:24 ?        00:00:02 /usr/local/redis/bin/redis-server 192.168.18.8:7004 [cluster]
    root       7347      1  0 06:24 ?        00:00:02 /usr/local/redis/bin/redis-server 192.168.18.8:7005 [cluster]
    root       7417   7290  0 06:49 pts/0    00:00:00 grep --color=auto redis

再次查看当前集群状态
    [root@#localhost ~]# redis-trib.rb check 192.168.18.4:7001
    >>> Performing Cluster Check (using node 192.168.18.4:7001)
    M: b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8 192.168.18.4:7001
       slots:0-5460 (5461 slots) master
       1 additional replica(s)
    M: 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084 192.168.18.8:7004
       slots:5461-10922 (5462 slots) master
       1 additional replica(s)
    S: 42813846e4bac77d3d3f958ebc550a8d80767844 192.168.18.8:7005
       slots: (0 slots) slave
       replicates b3edeb0157192fd3c46d6b67e05fc7fc73fc3db8
    S: a63d95745d7937153bb446c40296df89eab54abf 192.168.18.4:7003
       slots: (0 slots) slave
       replicates 5d302ca6dc6ede24557e7042bb0d0ee5a0f0e084
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [ERR] Not all 16384 slots are covered by nodes.

这里我们发现出事了，因为主从节点都挂了所以有一部分哈希槽没得分配，最后一句
[ERR] Not all 16384 slots are covered by nodes. 没有安全覆盖；
所以不能正常使用集群。
分享到：
| Redis持久化rdb和aof
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    springcloud部署redis集群

    在SpringCloud框架中，部署Redis集群是实现高可用、数据持久化和分布式缓存的关键步骤。Redis是一款高性能的键值数据库，广泛应用于缓存、消息队列等多种场景。SpringCloud通过集成Spring Data Redis模块，使得在...

    阿里云公网redis集群搭建以及java访问redis集群

    阿里云公网Redis集群搭建及Java访问教程 在云计算日益普及的今天，阿里云提供了便捷的公共服务，如Redis缓存服务，帮助企业或个人快速构建高效、可靠的分布式应用。本教程将详细讲解如何在阿里云上搭建公网Redis...

    Redis集群弱/空密码问题整改

    使用redis安装用户，在命令行连接上redis集群后，执行命令：config set requirepass 【自定义的强密码】，如： config set requirepass mypassword@#75@~ 然后执行 config rewrite 将配置密码持久化到redis配置文件...

    redis集群连接及工具类DEMO

    【Redis集群连接及工具类DEMO】是一个Spring工程，它提供了与Redis集群交互的实例，同时也包含了一些实用的工具类，使得开发者能够更方便地在Java应用中使用Redis作为数据存储。这个DEMO的主要目标是展示如何配置和...

    springboot整合redis集群零配置

    本篇文章将深入探讨如何在Spring Boot中实现对Redis集群的零配置整合，并介绍使用AOP实现的自定义缓存注解。 首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-...

    k8s集群搭建redis集群

    k8s集群搭建redis集群 k8s集群搭建redis集群 k8s集群搭建redis集群 k8s集群搭建redis集群 k8s集群搭建redis集群

    Redis集群下过期key监听的实现代码

    在使用redis集群时，发现过期key始终监听不到。网上也没有现成的解决方案。于是想，既然不能监听集群，那我可以建立多个redis连接，分别对每个redis的key过期进行监听。以上做法可能不尽人意，目前也没找到好的解决...

    SpringBoot集成Redis集群

    SpringBoot集成Redis集群 在本文档中，我们将指导您如何在SpringBoot 2.X中集成Redis集群。下面是相关的知识点： 集成Redis集群的必要性 在实际应用中，使用Redis集群可以提高系统的可扩展性和可靠性。Redis集群...

    Redis集群数据迁移操作文档

    《Redis集群数据迁移实战指南》 在IT领域，数据迁移是一项关键任务，特别是在使用Redis这样的高性能内存数据库时。本文将详细介绍如何进行Redis集群的数据迁移，包括全量和增量数据迁移，以及离线迁移的方法，主要...

    rancher2.3.6部署redis集群配置教程.pdf

    标题中的“rancher2.3.6部署redis集群配置教程.pdf”暗示了这份文档是针对特定版本的Rancher软件（版本号2.3.6）的使用教程，旨在指导用户如何部署Redis集群。Rancher是一款开源的容器管理平台，可以用来部署、管理...

    spring + redis集群

    本文将深入探讨如何使用Spring Data Redis构建一个Redis集群，以及如何通过Spring框架来操作Redis集群，存储对象集合，并提供一个基于Maven的可运行项目示例。 首先，Spring Data Redis是Spring框架的一个模块，它...

    redis集群批量插入

    本文将详细讨论如何在Java环境下连接Redis集群并实现批量插入String类型的数据。 首先，我们需要理解Redis集群的基本概念。Redis集群是通过分片（Sharding）技术来分散数据到多个节点，每个节点存储一部分数据。在...

    redis集群一键自动部署脚本.rar

    "redis集群一键自动部署脚本.rar" 提供了一种便捷的方式来在 CentOS 7.X 操作系统上搭建 Redis 集群。以下是关于Redis集群、shell脚本以及CentOS的相关知识点： 1. **Redis集群**： - **主从复制（Replication）**...

    springboot集成redis集群,redis安装包配置

    在本文中，我们将深入探讨如何在SpringBoot应用中集成Redis集群以及如何配置Redis服务器。首先，Redis是一个开源的、基于键值对的数据存储系统，常用于数据库、缓存和消息中间件。它以其高性能和易用性而备受青睐。...

    Redis集群搭建工具及教程

    在本资源包中，提供了搭建Redis集群所需的各种工具和教程，帮助你在Windows环境下进行操作。 首先，让我们来了解Redis集群的基础知识。Redis集群通过分片（Sharding）技术将数据分散到多个节点上，实现数据的冗余和...

    nginx+lua+redis 集群 连接插件和脚本

    本资源包“nginx+lua+redis集群 连接插件和脚本”正是为了解决这三者之间的协同工作，特别是针对原插件没有密码功能的问题进行了改进，使得安全性得到了提升。 首先，Nginx是一款轻量级的Web服务器/反向代理服务器...

    redis集群windows启动脚本

    在Windows环境下，设置和管理Redis集群可能相对复杂，但通过编写启动脚本可以实现一键启动，简化操作流程。以下将详细介绍如何创建并使用“redis集群windows启动脚本”。 1. **Redis集群概念** Redis集群是Redis...

    Redis集群测试

    Redis集群是一种分布式数据库解决方案，它允许用户将数据分散存储在多台服务器上，以提高系统的可扩展性和可用性。在“Redis集群测试”中，我们通常会关注以下几个关键知识点： 1. **集群架构**：Redis集群采用无...

    redis集群批处理一键搭建

    Redis集群批处理一键搭建是指通过一个简单的批处理脚本来快速构建和配置四个节点的Redis集群。这种方式极大地简化了安装和部署过程，使得在64位操作系统上启用Redis集群变得更加便捷。Redis是一个开源的、高性能的...

    shiro连接redis集群 根据org.crazycake.shiro包改造源码

    在分布式系统中，尤其是在使用Redis作为缓存或session存储时，Shiro的原生支持可能无法直接与Redis集群配合工作。这里提到的"shiro-redis-cluster"项目，显然是针对这个问题进行的一个定制化改造，它使得Shiro能够...

Magicbox
Global site tag (gtag.js) - Google Analytics