Redis（五）、Redis数据库集群相关

Redis数据库集群

第1章 集群简介

Redis 集群是一个分布式（distributed）、容错（fault-tolerant）的 Redis 实现， 集群可使用的功能是普通单机 Redis 所能使用的功能的一个子集（subset），是一个能够在多个 Redis 节点之间进行数据共享的设施（installation）。

Redis 集群中不存在中心（central）节点或者代理（proxy）节点， 集群的其中一个主要设计目标是达到线性可扩展性（linear scalability）。

Redis 集群不支持那些须要同时处理多个键的 Redis 命令， 由于执行这些命令须要在多个 Redis 节点之间移动数据， 而且在高负载的状况下， 这些命令将下降 Redis 集群的性能， 并致使不可预测的行为。

Redis 集群经过分区（partition）来提供必定程度的可用性（availability）： 即便集群中有一部分节点失效或者没法进行通信， 集群也能够继续处理命令请求。

Redis 集群提供了如下两个好处：

q  将数据自动切分（split）到多个节点的能力。

q  当集群中的一部分节点失效或者没法进行通信时， 仍然能够继续处理命令请求的能力。

第2章 集群数据共享

Redis 集群使用数据分片（sharding）而非一致性哈希（consistency hashing）来实现： 一个 Redis 集群包含 16384 个哈希槽（hash slot）， 数据库中的每一个键都属于这 16384 个哈希槽的其中一个， 集群使用公式 CRC16(key) % 16384 来计算键 key 属于哪一个槽， 其中 CRC16(key) 语句用于计算键 key 的 CRC16 校验和 。

集群中的每一个节点负责处理一部分哈希槽。 举个例子， 一个集群能够有三个哈希槽， 其中：

节点 A 负责处理 0 号至 5500 号哈希槽。

节点 B 负责处理 5501 号至 11000 号哈希槽。

节点 C 负责处理 11001 号至 16384 号哈希槽。

这种将哈希槽分布到不一样节点的作法使得用户能够很容易地向集群中添加或者删除节点。 好比说，若是用户将新节点 D 添加到集群中， 那么集群只须要将节点 A 、B 、 C 中的某些槽移动到节点 D 就能够了。与此相似， 若是用户要从集群中移除节点 A ， 那么集群只须要将节点 A 中的全部哈希槽移动到节点 B 和节点 C ， 而后再移除空白（不包含任何哈希槽）的节点 A 就能够了。

由于将一个哈希槽从一个节点移动到另外一个节点不会形成节点阻塞， 因此不管是添加新节点仍是移除已存在节点， 又或者改变某个节点包含的哈希槽数量， 都不会形成集群下线。

第3章 集群中的主从复制

为了使得集群在一部分节点下线或者没法与集群的大多数（majority）节点进行通信的状况下， 仍然能够正常运做， Redis 集群对节点使用了主从复制功能： 集群中的每一个节点都有 1 个至 N 个复制品（replica）， 其中一个复制品为主节点（master）， 而其他的 N-1 个复制品为从节点（slave）。

在以前列举的节点 A 、B 、C 的例子中， 若是节点 B 下线了， 那么集群将没法正常运行， 由于集群找不到节点来处理 5501 号至 11000号的哈希槽。

另外一方面， 假如在建立集群的时候（或者至少在节点 B 下线以前）， 咱们为主节点 B 添加了从节点 B1 ， 那么当主节点 B 下线的时候， 集群就会将 B1 设置为新的主节点， 并让它代替下线的主节点 B ， 继续处理 5501 号至 11000 号的哈希槽， 这样集群就不会由于主节点 B 的下线而没法正常运做了。不过若是节点 B 和 B1 都下线的话， Redis 集群仍是会中止运做。

第4章 集群的一致性保证

Redis 集群不保证数据的强一致性（strong consistency）： 在特定条件下， Redis 集群可能会丢失已经被执行过的写命令。

使用异步复制（asynchronous replication）是 Redis 集群可能会丢失写命令的其中一个缘由。 考虑如下这个写命令的例子：

1、客户端向主节点 B 发送一条写命令。

2、主节点 B 执行写命令，并向客户端返回命令回复。

3、主节点 B 将刚刚执行的写命令复制给它的从节点 B1 、 B2 和 B3 。

可见， 主节点对命令的复制工做发生在返回命令回复以后， 由于若是每次处理命令请求都须要等待复制操做完成的话，那么主节点处理命令请求的速度将极大地下降 —— 咱们必须在性能和一致性之间作出权衡。

Redis 集群另一种可能会丢失命令的状况是， 集群出现网络分裂（network partition）， 而且一个客户端与至少包括一个主节点在内的少数（minority）实例被孤立。举个例子：

1、假设集群包含 A 、 B 、 C 、 A1 、 B1 、 C1 六个节点，其中 A 、B 、C 为主节点，而 A1 、B1 、C1 分别为三个主节点的从节点， 另外还有一个客户端 Z1 。

2、假设集群中发生网络分裂， 那么集群可能会分裂为两方， 大多数（majority）的一方包含节点 A 、C 、A1 、B1 和 C1 ， 而少数（minority）的一方则包含节点 B 和客户端 Z1 。

3、在网络分裂期间， 主节点 B 仍然会接受 Z1 发送的写命令：

4、若是网络分裂出现的时间很短， 那么集群会继续正常运行；

5、可是， 若是网络分裂出现的时间足够长， 使得大多数一方将从节点 B1 设置为新的主节点， 并使用 B1 来代替原来的主节点 B ， 那么 Z1 发送给主节点 B 的写命令将丢失。

注意， 在网络分裂出现期间， 客户端 Z1 能够向主节点 B 发送写命令的最大时间是有限制的， 这一时间限制称为节点超时时间（node timeout）， 是 Redis 集群的一个重要的配置选项。

q  对于大多数一方来讲， 若是一个主节点未能在节点超时时间所设定的时限内从新联系上集群， 那么集群会将这个主节点视为下线， 并使用从节点来代替这个主节点继续工做。

q  对于少数一方， 若是一个主节点未能在节点超时时间所设定的时限内从新联系上集群， 那么它将中止处理写命令， 并向客户端报告错误。

第5章 建立并使用Redis集群

5.1 集群模式配置

Redis 集群由多个运行在集群模式（cluster mode）下的 Redis 实例组成， 实例的集群模式须要经过配置来开启， 开启集群模式的实例将可使用集群特有的功能和命令。

如下是一个包含了最少选项的集群配置文件示例：

port 7000
cluster-enabled yes                     #<==打开实例的集群模式
cluster-config-file nodes.conf          #<==设定保存节点的配置文件，无需人为修改
cluster-node-timeout 5000               #<==集群节点超时时间
appendonly yes

5.2 安装Redis

普通安装过程与单节点一致，可用yum或者编译的方式安装，这里再也不叙述。可是Redis集群模式会使用到redis-trib工具，这是一个ruby语言的工具，所以须要事先安装好ruby语言的执行环境。

yum -y  install ruby ruby-devel rubygems rpm-build

再用 gem 这个命令来安装 redis接口,gem是ruby的一个工具包.

gem install redis -v 3.2.1
1 gem installed
Installing ri documentation for redis-3.2.1...
Installing RDoc documentation for redis-3.2.1...

若是下载失败的话，能够去这个网址手动下载，再经过命令gem install命令手动安装

https://rubygems.org/gems/redis/versions/3.2.1

5.3 建立实例目录

本此实验环境为在单台主机上启动六个不一样端口的实例，若是是分布在不一样的机器上，则不须要。

mkdir /opt/redis/cluster/{7000..7005} -p

5.4 集群配置文件

将如下配置文件放入7000-7005六个目录中，注意修改每一个目录下面对应的端口号。

#<==在原默认配置上进行修改
bind 10.0.0.16
port 7000
pidfile /var/run/redis_7000.pid
logfile "/opt/redis/cluster/7000/redis.log"
daemonize yes
appendonly yes
dir /opt/redis/cluster/7000
 
#新增集群的配置 
cluster-enabled yes
cluster-config-file /opt/redis/cluster/7000/nodes-7000.conf
cluster-node-timeout 15000
 
protected-mode yes
tcp-backlog 511
timeout 0
tcp-keepalive 300
supervised no
loglevel notice
databases 16
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
slave-serve-stale-data yes
slave-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
slave-priority 100
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes

5.5 分别启动实例

分别启动六个不一样的实例：

./../../src/redis-server ../7000/redis.conf
./../../src/redis-server ../7001/redis.conf
./../../src/redis-server ../7002/redis.conf
./../../src/redis-server ../7003/redis.conf
./../../src/redis-server ../7004/redis.conf
./../../src/redis-server ../7005/redis.conf

查看实例运行状况：

[root@test3 7000]# ps -ef |grep redis
root     108314      1  0 20:53 ?        00:00:00 ./../../src/redis-server 10.0.0.16:7000 [cluster]
root     108322      1  0 20:54 ?        00:00:00 ./../../src/redis-server 10.0.0.16:7001 [cluster]
root     108324      1  0 20:54 ?        00:00:00 ./../../src/redis-server 10.0.0.16:7002 [cluster]
root     108328      1  0 20:54 ?        00:00:00 ./../../src/redis-server 10.0.0.16:7003 [cluster]
root     108330      1  0 20:54 ?        00:00:00 ./../../src/redis-server 10.0.0.16:7004 [cluster]
root     108332      1  0 20:54 ?        00:00:00 ./../../src/redis-server 10.0.0.16:7005 [cluster]

5.6 建立Redis集群

如今咱们已经有了六个正在运行中的 Redis 实例， 接下来咱们须要使用这些实例来建立集群， 并为每一个节点编写配置文件。

经过使用 Redis 集群命令行工具 redis-trib ， 编写节点配置文件的工做能够很是容易地完成： redis-trib 位于 Redis 源码的 src 文件夹中， 它是一个 Ruby 程序， 这个程序经过向实例发送特殊命令来完成建立新集群， 检查集群， 或者对集群进行从新分片（reshared）等工做。

集群建立命令：

./../../src/redis-trib.rb create --replicas 1 10.0.0.16:7000 10.0.0.16:7001 10.0.0.16:7002 10.0.0.16:7003 10.0.0.16:7004 10.0.0.16:7005

q  命令的意义以下：

create ：                 这表示咱们但愿建立一个新的集群。

 --replicas 1 ：   表示咱们但愿为集群中的每一个主节点建立一个从节点。

以后跟着的其余参数则是实例的地址列表， 咱们但愿程序使用这些地址所指示的实例来建立新集群。简单来讲， 以上命令的意思就是让 redis-trib 程序建立一个包含三个主节点和三个从节点的集群。接着， redis-trib 会打印出一份预想中的配置给你看， 若是你以为没问题的话， 就能够输入 yes ， redis-trib 就会将这份配置应用到集群当中：

>>> Creating cluster
>>> Performing hash slots allocation on 6 nodes...
Using 3 masters:
10.0.0.16:7000
10.0.0.16:7001
10.0.0.16:7002
Adding replica 10.0.0.16:7003 to 10.0.0.16:7000
Adding replica 10.0.0.16:7004 to 10.0.0.16:7001
Adding replica 10.0.0.16:7005 to 10.0.0.16:7002
M: 62d87bd83fd636e6ba1fe031777178cce8f9f776 10.0.0.16:7000
   slots:0-5460 (5461 slots) master
M: ccc65af4a214689b15d0cfd9dea584d214a0c2ad 10.0.0.16:7001
   slots:5461-10922 (5462 slots) master
M: 2366c6765ecf21ee86b064376693ce59047478a5 10.0.0.16:7002
   slots:10923-16383 (5461 slots) master
S: 19920c1ccf4be5849a1fca5d5f41643a3598cfcc 10.0.0.16:7003
   replicates 62d87bd83fd636e6ba1fe031777178cce8f9f776
S: 60c3b5d3c1a53328046b627bd015da99e30436c0 10.0.0.16:7004
   replicates ccc65af4a214689b15d0cfd9dea584d214a0c2ad
S: 287a24936fa3c0c29ce33d768921769cf1969115 10.0.0.16:7005
   replicates 2366c6765ecf21ee86b064376693ce59047478a5
Can I set the above configuration? (type 'yes' to accept):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 10.0.0.16:7000)
M: 62d87bd83fd636e6ba1fe031777178cce8f9f776 10.0.0.16:7000
   slots:0-5460 (5461 slots) master
   1 additional replica(s)
S: 287a24936fa3c0c29ce33d768921769cf1969115 10.0.0.16:7005
   slots: (0 slots) slave
   replicates 2366c6765ecf21ee86b064376693ce59047478a5
M: ccc65af4a214689b15d0cfd9dea584d214a0c2ad 10.0.0.16:7001
   slots:5461-10922 (5462 slots) master
   1 additional replica(s)
M: 2366c6765ecf21ee86b064376693ce59047478a5 10.0.0.16:7002
   slots:10923-16383 (5461 slots) master
   1 additional replica(s)
S: 60c3b5d3c1a53328046b627bd015da99e30436c0 10.0.0.16:7004
   slots: (0 slots) slave
   replicates ccc65af4a214689b15d0cfd9dea584d214a0c2ad
S: 19920c1ccf4be5849a1fca5d5f41643a3598cfcc 10.0.0.16:7003
   slots: (0 slots) slave
   replicates 62d87bd83fd636e6ba1fe031777178cce8f9f776
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered. #<==这表示集群中的 16384个槽都有至少一个主节点在处理， 集群运做正常。

新集群建立完毕！！！

5.7 集群客户端实现

q  redis-rb-cluster

是antirez编写的 Ruby 实现， 用于做为其余实现的参考。 该实现是对 redis-rb 的一个简单包装， 高效地实现了与集群进行通信所需的最少语义（semantic）。

q  redis-py-cluster

看上去是 redis-rb-cluster 的一个 Python 版本， 这个项目有一段时间没有更新了， 不过能够将这个项目用做学习集群的起点。

q  Predis

流行的 Predis 曾经对早期的 Redis 集群有过必定的支持， 但不肯定它对如今集群的支持是否完整， 也不清楚它是否和最新版本的 Redis 集群兼容 （由于新版的 Redis 集群将槽的数量从 4k 改成 16k 了）。

q  redis-cli

Redis unstable 分支中的 redis-cli 程序实现了很是基本的集群支持，因此它老是依靠 Redis 集群节点来将它转向（redirect）至正确的节点。

使用 redis-cli 为例来进行演示：

10.0.0.16:7000> set foo bar
-> Redirected to slot [12182] located at 10.0.0.16:7002
OK
10.0.0.16:7002> set hello world
-> Redirected to slot [866] located at 10.0.0.16:7000
OK
10.0.0.16:7000> get foo
-> Redirected to slot [12182] located at 10.0.0.16:7002
"bar"
10.0.0.16:7002> get hello
-> Redirected to slot [866] located at 10.0.0.16:7000
"world"
10.0.0.16:7000>

第6章 集群从新分片

从新分片操做基本上就是将某些节点上的哈希槽移动到另一些节点上面， 和建立集群同样， 从新分片也可使用 redis-trib 程序来执行。

原hash槽分配：

10.0.0.16:7000---- 0-5460

10.0.0.16:7001---- 5461-10922

10.0.0.16:7002---- 10923-16383

q  执行如下命令能够开始一次从新分片操做：

./redis-trib.rb reshard 10.0.0.16:7000

你只须要指定集群中其中一个节点的地址， redis-trib 就会自动找到集群中的其余节点。目前 redis-trib 只能在管理员的协助下完成从新分片的工做， 要让 redis-trib 自动将哈希槽从一个节点移动到另外一个节点， 目前来讲还作不到。

q  设定打算移动哈希槽的数量

执行 redis-trib 的第一步就是设定你打算移动的哈希槽的数量：

>>> Performing Cluster Check (using node 10.0.0.16:7000)
M: 62d87bd83fd636e6ba1fe031777178cce8f9f776 10.0.0.16:7000
   slots:0-5460 (5461 slots) master
   1 additional replica(s)
S: 287a24936fa3c0c29ce33d768921769cf1969115 10.0.0.16:7005
   slots: (0 slots) slave
   replicates 2366c6765ecf21ee86b064376693ce59047478a5
M: ccc65af4a214689b15d0cfd9dea584d214a0c2ad 10.0.0.16:7001
   slots:5461-10922 (5462 slots) master
   1 additional replica(s)
M: 2366c6765ecf21ee86b064376693ce59047478a5 10.0.0.16:7002
   slots:10923-16383 (5461 slots) master
   1 additional replica(s)
S: 60c3b5d3c1a53328046b627bd015da99e30436c0 10.0.0.16:7004
   slots: (0 slots) slave
   replicates ccc65af4a214689b15d0cfd9dea584d214a0c2ad
S: 19920c1ccf4be5849a1fca5d5f41643a3598cfcc 10.0.0.16:7003
   slots: (0 slots) slave
   replicates 62d87bd83fd636e6ba1fe031777178cce8f9f776
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 1000      #<==移动1000个hash槽

q  设置目标ID

除了移动的哈希槽数量以外， redis-trib 还须要知道从新分片的目标（target node）， 也就是负责接收这 1000 个哈希槽的节点。

指定目标须要使用节点的 ID ， 而不是 IP 地址和端口。 好比说， 咱们打算使用集群的第一个主节点来做为目标， 它的 IP 地址和端口是 10.0.0.16:7001 ， 而节点 ID 则是62d87bd83fd636e6ba1fe031777178cce8f9f776 ， 那么咱们应该向 redis-trib 提供节点的 ID ：

How many slots do you want to move (from 1 to 16384)? 1000
What is the receiving node ID? 62d87bd83fd636e6ba1fe031777178cce8f9f776

q  设置源节点

接下来， redis-trib 会向你询问从新分片的源节点（source node），也就是要从哪一个节点中取出 1000 个哈希槽， 并将这些槽移动到目标节点上面。若是咱们不打算从特定的节点上取出指定数量的哈希槽，那么能够向 redis-trib 输入 all ，这样的话，集群中的全部主节点都会成为源节点， redis-trib 将从各个源节点中各取出一部分哈希槽， 凑够 1000 个， 而后移动到目标节点上面：

What is the receiving node ID? 62d87bd83fd636e6ba1fe031777178cce8f9f776
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' once you entered all the source nodes IDs.
Source node #1:all      #<==这里能够选择all或者具体节点ID回车再输入done来指定具体节点，能够用来清除主节点的solt。

输入 all 并按下回车以后， redis-trib 将打印出哈希槽的移动计划， 若是你以为没问题的话， 就能够输入 yes 并再次按下回车：

......
    Moving slot 11420 from 2366c6765ecf21ee86b064376693ce59047478a5
    Moving slot 11421 from 2366c6765ecf21ee86b064376693ce59047478a5
Do you want to proceed with the proposed reshard plan (yes/no)? yes

输入 yes 并使用按下回车以后， redis-trib 就会正式开始执行从新分片操做， 将指定的哈希槽从源节点一个个地移动到目标节点上面。

q  从新检查集群状态

[root@test3 src]# ./redis-trib.rb check 10.0.0.16:7000
>>> Performing Cluster Check (using node 10.0.0.16:7000)
M: 62d87bd83fd636e6ba1fe031777178cce8f9f776 10.0.0.16:7000
   slots:0-5961,10923-11421 (6461 slots) master
   1 additional replica(s)
S: 287a24936fa3c0c29ce33d768921769cf1969115 10.0.0.16:7005
   slots: (0 slots) slave
   replicates 2366c6765ecf21ee86b064376693ce59047478a5
M: ccc65af4a214689b15d0cfd9dea584d214a0c2ad 10.0.0.16:7001
   slots:5962-10922 (4961 slots) master
   1 additional replica(s)
M: 2366c6765ecf21ee86b064376693ce59047478a5 10.0.0.16:7002
   slots:11422-16383 (4962 slots) master
   1 additional replica(s)
S: 60c3b5d3c1a53328046b627bd015da99e30436c0 10.0.0.16:7004
   slots: (0 slots) slave
   replicates ccc65af4a214689b15d0cfd9dea584d214a0c2ad
S: 19920c1ccf4be5849a1fca5d5f41643a3598cfcc 10.0.0.16:7003
   slots: (0 slots) slave
   replicates 62d87bd83fd636e6ba1fe031777178cce8f9f776
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

须要注意的就是， 在三个主节点中， 节点 127.0.0.1:7000 包含了 6461 个哈希槽， 而节点 127.0.0.1:7001 和节点 127.0.0.1:7002 都只包含了 4961 个哈希槽， 由于后二者都将本身的 500 个哈希槽移动到了节点 127.0.0.1:7000 。

第7章 集群节点管理

 

7.1 添加节点

根据新添加节点的种类， 咱们须要用两种方法来将新节点添加到集群里面：

q  若是要添加的新节点是一个主节点， 那么咱们须要建立一个空节点（empty node）， 而后将某些哈希槽移动到这个空节点里面。

q  若是要添加的新节点是一个从节点， 那么咱们须要将这个新节点设置为集群中某个节点的复制品（replica）。

7.1.1 新增一个空的节点

同理，再启动一个新的7006端口的Redis节点，过程见redis（一）、入门。

7.1.2 新增节点加入集群

执行如下命令， 将这个新节点添加到集群里面：

./redis-trib.rb add-node 10.0.0.16:7006 10.0.0.16:7000

命令中的 add-node 表示咱们要让 redis-trib 将一个节点添加到集群里面， add-node 以后跟着的是新节点的 IP 地址和端口号， 再以后跟着的是集群中任意一个已存在节点的 IP 地址和端口号， 这里咱们使用的是 10.0.0.16:7000 。

经过 cluster nodes 命令， 咱们能够确认新节点 10.0.0.16:7006 已经被添加到集群里面了：

[root@test3 cluster]# redis-cli -c -h 10.0.0.16 -p 7000 cluster nodes
287a24936fa3c0c29ce33d768921769cf1969115 10.0.0.16:7005 slave 2366c6765ecf21ee86b064376693ce59047478a5 0 1523112658032 6 connected
ccc65af4a214689b15d0cfd9dea584d214a0c2ad 10.0.0.16:7001 master - 0 1523112656012 8 connected 0-565 5962-10922 11422-11855
2366c6765ecf21ee86b064376693ce59047478a5 10.0.0.16:7002 master - 0 1523112651972 3 connected 11856-16383
62d87bd83fd636e6ba1fe031777178cce8f9f776 10.0.0.16:7000 myself,master - 0 0 7 connected 566-5961 10923-11421
60c3b5d3c1a53328046b627bd015da99e30436c0 10.0.0.16:7004 slave ccc65af4a214689b15d0cfd9dea584d214a0c2ad 0 1523112655003 8 connected
96fdc35b69c4f0929ba9ba5550a5fca8f3b0b514 10.0.0.16:7006 master - 0 1523112657022 0 connected
19920c1ccf4be5849a1fca5d5f41643a3598cfcc 10.0.0.16:7003 slave 62d87bd83fd636e6ba1fe031777178cce8f9f776 0 1523112652982 7 connected

新节点如今已经链接上了集群， 成为集群的一份子， 而且能够对客户端的命令请求进行转向了， 可是和其余主节点相比， 新节点还有两点区别：

1、新节点没有包含任何数据， 由于它没有包含任何哈希槽。

2、尽管新节点没有包含任何哈希槽， 但它仍然是一个主节点， 因此在集群须要将某个从节点升级为新的主节点时， 这个新节点不会被选中。

7.1.3 添加为主节点

当把节点添加进集群的时候，已经默认设置为主节点了，只是该节点没有数据而已。这时只须要咱们将哈希槽移动到新的节点里面，新节点就会成为真正的主节点了。

详细过程见第六章。

7.1.4 添加为slave节点

使用客户端链接上新节点，并运行以下命令：

[root@test3 cluster]# redis-cli -c -h 10.0.0.16 -p 7006
10.0.0.16:7006> cluster replicate 62d87bd83fd636e6ba1fe031777178cce8f9f776
OK
10.0.0.16:7006>

注：以上这条命令也适合于随时修改从节点的master。

q  一步到位法：

redis-trib.rb add-node --slave --master-id 62d87bd83fd636e6ba1fe031777178cce8f9f77 10.0.0.16:7006 10.0.0.16:7000
--slave:表示添加的是从节点
--master-id 62d87bd83fd636e6ba1fe031777178cce8f9f77:主节点的node id
10.0.0.16:7006：新的节点
10.0.0.16:7000：任何一个集群中的旧节点

查看是否设置成功：

[root@test3 cluster]# redis-cli -c -h 10.0.0.16 -p 7000 cluster nodes | grep slave
287a24936fa3c0c29ce33d768921769cf1969115 10.0.0.16:7005 slave 2366c6765ecf21ee86b064376693ce59047478a5 0 1523113268561 6 connected
60c3b5d3c1a53328046b627bd015da99e30436c0 10.0.0.16:7004 slave ccc65af4a214689b15d0cfd9dea584d214a0c2ad 0 1523113270579 8 connected
96fdc35b69c4f0929ba9ba5550a5fca8f3b0b514 10.0.0.16:7006 slave 62d87bd83fd636e6ba1fe031777178cce8f9f776 0 1523113269569 9 connected
19920c1ccf4be5849a1fca5d5f41643a3598cfcc 10.0.0.16:7003 slave 62d87bd83fd636e6ba1fe031777178cce8f9f776 0 1523113267550 7 connected
#<==能够看出新节点已经成为slave了

7.2 移除节点

7.2.1 移除从节点

执行以下命令，将节点移出集群：

/opt/redis/src/redis-trib.rb del-node 10.0.0.16:7006 '96fdc35b69c4f0929ba9ba5550a5fca8f3b0b514'

7.2.2 移除主节点

q  若是主节点有从节点，先将从节点移到其余主节点

10.0.0.16:7006> cluster replicate 62d87bd83fd636e6ba1fe031777178cce8f9f776

q  若是主节点有solt，去掉分配的solt

详细过程见第6章，只须要把all替换为需删除的主节点便可。 

q  删除主节点

/opt/redis/src/redis-trib.rb del-node 10.0.0.16:7006 '96fdc35b69c4f0929ba9ba5550a5fca8f3b0b514'

第8章 Redis Cluster相关命令

//集群(cluster)  
CLUSTER INFO #<==打印集群的信息  
CLUSTER NODES #<==列出集群当前已知的全部节点（node），以及这些节点的相关信息。   
  
//节点(node)  
CLUSTER MEET <ip> <port>     #<==将ip和port所指定的节点添加到集群当中，让它成为集群的一份子。  
CLUSTER FORGET <node_id>     #<==从集群中移除node_id指定的节点。  
CLUSTER REPLICATE <node_id>  #<==将当前节点设置为node_id指定的节点的从节点。  
CLUSTER SAVECONFIG            #<==将节点的配置文件保存到硬盘里面。   
  
//槽(slot)  
CLUSTER ADDSLOTS <slot> [slot ...]         #<==将一个或多个槽（slot）指派（assign）给当前节点。  
CLUSTER DELSLOTS <slot> [slot ...]         #<==移除一个或多个槽对当前节点的指派。  
CLUSTER FLUSHSLOTS                            #<==移除指派给当前节点的全部槽，让当前节点变成一个没有指派任何槽的节点。  
CLUSTER SETSLOT <slot> NODE <node_id>      #<==将槽slot指派给node_id指定的节点，若是槽已经指派给另外一个节点，那么先让另外一个节点删除该槽，而后再进行指派。  
CLUSTER SETSLOT <slot> MIGRATING <node_id> #<==将本节点的槽 slot 迁移到 node_id 指定的节点中。  
CLUSTER SETSLOT <slot> IMPORTING <node_id> #<==从 node_id 指定的节点中导入槽 slot 到本节点。  
CLUSTER SETSLOT <slot> STABLE               #<==取消对槽 slot 的导入（import）或者迁移（migrate）。   
  
//键 (key)  
CLUSTER KEYSLOT <key>                    #<==计算键 key 应该被放置在哪一个槽上。  
CLUSTER COUNTKEYSINSLOT <slot>           #<==回槽slot目前包含的键值对数量。  
CLUSTER GETKEYSINSLOT <slot> <count>     #<==返回count个slot槽中的键。