Redis从零到cluster集群实践详解

博文结构介绍

1、博文概要
Redis简介
Redis安装及基本配置
Redis持久化
Redis多数据类型开发（了解）
Redis复制及高可用
Redis 集群分片
Redis API支持（Python篇）

---

2、软件获取和帮助获取
Redis.io
Download/redis.io
Redisdoc.com
redis.cn

3、redis的核心特性
高速读写
数据类型丰富
支持持久化
多种内存分配及回收策略
支持事务
消息队列、消息订阅
支持高可用
支持分布式分片集群

与memeched区别：
支持事务
数据类型丰富
支持持久化
支持高可用
支持分布式分片集群

4、Redis安装部署

下载：
wget http://download.redis.io/releases/redis-3.2.12.tar.gz
解压：
上传至 /data
tar xzf redis-3.2.12.tar.gz
mv redis-3.2.12 redis
安装：
cd redis
make

修改环境变量

vim /etc/profile
export PATH=/application/mysql/bin/:/data/redis/src:$PATH

source /etc/profile

启动和简易连接：

redis-server &
redis-cli

5、Redis基本管理操作

5.1基础配置文件介绍：

mkdir /data/6379

vim /data/6379/redis.conf

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename dump.rdb

127.0.0.1:6379> shutdown 
not connected> exit

[root@db01 6379]# redis-server /data/6379/redis.conf 
[root@db03 ~]# netstat -lnp|grep 63

redis-cli shutdown

+++++++++++配置文件说明++++++++++++++

redis.conf
是否后台运行：
daemonize yes
默认端口：
port 6379
日志文件位置
logfile /var/log/redis.log
持久化文件存储位置
dir /data/6379
RDB持久化数据文件:
dbfilename dump.rdb

+++++++++++++++++++++++++

5.2 redis安全配置

（1）redis没有用户概念，redis只有密码
（2）redis默认在工作在保护模式下。不允许远程任何用户登录的（protected-mode）

protected-mode yes/no （保护模式，是否只允许本地访问）

DENIED Redis is running in protected mode because protected mode is enabled, 
no bind address was specified, no authentication password is requested to clients. 
In this mode connections are only accepted from the loopback interface. 
If you want to connect from external computers to Redis you may adopt one of the following solutions: 
1)Just disable protected mode sending the command 'CONFIG SET protected-mode no' 
 from the loopback interface by connecting to Redis from the same host the server is running, 
 however MAKE SURE Redis is not publicly accessible from internet if you do so.
 Use CONFIG REWRITE to make this change permanent. 
2) Alternatively you can just disable the protected mode by editing the Redis configuration file, 
 and setting the protected mode option to 'no', and then restarting the server.
3) If you started the server manually just for testing, restart it with the '--protected-mode no' option. 
4) Setup a bind address or an authentication password. 
 NOTE: You only need to do one of the above things in order for the server to start accepting connections from the outside.

(1)Bind :指定IP进行监听

vim /data/6379/redis.conf
bind 10.0.0.52 127.0.0.1

(2)增加requirepass {password}

vim /data/6379/redis.conf
requirepass root

重启生效：

redis-cli shutdown 

redis-server /data/6379/redis.conf

----------验证-----

方法一：
[root@db03 ~]# redis-cli -a root
127.0.0.1:6379> set name zhangsan 
OK
127.0.0.1:6379> exit
方法二：
[root@db03 ~]# redis-cli
127.0.0.1:6379> auth root
OK
127.0.0.1:6379> set a b

5.3 在线查看和修改配置

CONFIG GET *

CONFIG GET requirepass
CONFIG SET requirepass 123456

5.4 redis持久化（内存数据保存到磁盘）
RDB 持久化
可以在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）。
优点：速度快，适合于用做备份，主从复制也是基于RDB持久化功能实现的。
缺点：会有数据丢失

rdb持久化核心配置参数：

vim /data/6379/redis.conf

dir /data/6379
dbfilename dump.rdb
save 900 1
save 300 10
save 60 10000

配置分别表示：
900秒（15分钟）内有1个更改
300秒（5分钟）内有10个更改
60秒内有10000个更改

AOF 持久化(append-only log file)
记录服务器执行的所有写操作命令，并在服务器启动时，通过重新执行这些命令来还原数据集。
AOF 文件中的命令全部以 Redis 协议的格式来保存，新命令会被追加到文件的末尾。
优点：可以最大程度保证数据不丢
缺点：日志记录量级比较大

AOF持久化配置

appendonly yes
appendfsync always

appendfsync everysec
appendfsync no

是否打开aof日志功能
每1个命令,都立即同步到aof
每秒写1次
写入工作交给操作系统,由操作系统判断缓冲区大小,统一写入到aof.

vim /data/6379/redis.conf

appendonly yes
appendfsync everysec 

redis 持久化方式有哪些？有什么区别？
rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于rdb持久化功能
aof：以追加的方式记录redis操作日志的文件。可以最大程度的保证redis数据安全，类似于mysql的binlog

Redis的数据类型

1、介绍：

                    key                                 value
                    键                                   值
                    自主定制的名字                     多数据类型的存储模式

string类型                name                                "zhangsan"
hash类型（字典类型）    stu                                 {id:101,name:zhangsan}
LIST类型                wechat                              (v1,v2,v3)
                                                         0   1  2
SET(集合类型)           set1                                [m1,m2,m3]
                                                         0   1  2
Sorted SET(有序)      zset1                               [socre m1,score m2,score m3]
                                                                0        1       2

2、数据类型应用场景及基本操作

2.1 String类型
应用场景：
（1）非常基本的键值对存储
（2）计数器
互联网当中，点击量，访问量，关注量等
网页游戏应用当中的，血量、蓝量等

基本操作：

127.0.0.1:6379> set name zhangsan 
OK
127.0.0.1:6379> get name
"zhangsan"
127.0.0.1:6379> mset id 101 name zhangsan age 20 gender male 
OK
127.0.0.1:6379> mget id name age gender

计数器应用

127.0.0.1:6379> incr fensi
127.0.0.1:6379> DECR fensi
127.0.0.1:6379> INCRBY fensi 10000
127.0.0.1:6379> DECRBY fensi 10003

127.0.0.1:6379> get fensi

2.2 HASH类型（字典类型）
应用场景：最接近于MySQL表结构的数据类型
存储部分变更的数据，如用户信息等。

基本操作：

127.0.0.1:6379> hset zhangsan name zs
(integer) 1
127.0.0.1:6379> hmset student id 101 name zs age 20 gender male
OK
127.0.0.1:6379> hmset stu id 102 name lisi age 21 gender male
OK
127.0.0.1:6379> hmget stu id name age gender
1) "102"
2) "lisi"
3) "21"
4) "male"
127.0.0.1:6379> hgetall stu
1) "id"
2) "102"
3) "name"
4) "lisi"
5) "age"
6) "21"
7) "gender"
8) "male"

小扩展：
MySQL 中 city表中前10行数据，灌入到redis中

MySQL:
        id        name      age    gender 
        101       zhangsan  20      male

hmset zhangsan_stu  id 101 name zhangsan  age 20 gender male

思路：

mysql> desc t1;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(20) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

mysql> 
mysql> 
mysql> 
mysql> 
mysql> select concat("hmset stu_",name," id ",id," name ",name) from t1;
+---------------------------------------------------+
| concat("hmset stu_",name," id ",id," name ",name) |
+---------------------------------------------------+
| hmset stu_zhang3 id 1 name zhang3                 |
| hmset stu_li4 id 2 name li4                       |
| hmset stu_wang5 id 3 name wang5                   |
+---------------------------------------------------+

2.3 List列表类型
应用场景：朋友圈应用
在Redis中我们的最新微博ID使用了常驻缓存，这是一直更新的。
但是做了限制不能超过5000个ID，因此获取ID的函数会一直询问Redis。
只有在start/count参数超出了这个范围的时候，才需要去访问数据库。 
系统不会像传统方式那样“刷新”缓存，Redis实例中的信息永远是一致的。
SQL数据库（或是硬盘上的其他类型数据库）只是在用户需要获取“很远”的数据时才会被触发，而主页或第一个评论页是不会麻烦到硬盘上的数据库了。

例子：微信朋友圈应用

127.0.0.1:6379> LPUSH wechat "today is 1"
(integer) 1
127.0.0.1:6379> LPUSH wechat "today is 2"
(integer) 2
127.0.0.1:6379> LPUSH wechat "today is 3"
(integer) 3
127.0.0.1:6379> LPUSH wechat "today is 4"
(integer) 4
127.0.0.1:6379> LPUSH wechat "today is 5"

127.0.0.1:6379> LRANGE wechat 0 -1
1) "today is 5"
2) "today is 4"
3) "today is 3"
4) "today is 2"
5) "today is 1"
127.0.0.1:6379> 

2.4 SET 集合类型
应用场景：
案例： 在微博应用中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。
Redis还为集合提供了求交集、并集、差集等操作，可以非常方便的实现如共同关注、共同喜好、二度好友等功能，
对上面的所有集合操作，你还可以使用不同的命令选择将结果返回给客户端还是存集到一个新的集合中。

127.0.0.1:6379> sadd lxl pg1 pg2 baoqiang masu marong 
(integer) 5
127.0.0.1:6379> sadd jnl baoqiang yufan baobeier zhouxingchi 
(integer) 4
127.0.0.1:6379> SUNION lxl jnl 
1) "zhouxingchi"
2) "baobeier"
3) "pg2"
4) "yufan"
5) "masu"
6) "baoqiang"
7) "pg1"
8) "marong"
127.0.0.1:6379> 
127.0.0.1:6379> SINTER lxl jnl
1) "baoqiang"
127.0.0.1:6379> SDIFF lxl jnl
1) "masu"
2) "pg1"
3) "marong"
4) "pg2"
127.0.0.1:6379> SDIFF jnl lxl
1) "yufan"
2) "zhouxingchi"
3) "baobeier"

2.5 Sorted Set

排行榜应用，取TOP N操作 
这个需求与上面需求的不同之处在于，前面操作以时间为权重，这个是以某个条件为权重，
比如按顶的次数排序，这时候就需要我们的sorted set出马了，将你要排序的值设置成sorted set的score
，将具体的数据设置成相应的value，每次只需要执行一条ZADD命令即可。

例子： 歌曲排行榜

127.0.0.1:6379> zadd music 0 fskl 0 fshkl 0 lzlsfs 0 tm 0 ass 
(integer) 5
127.0.0.1:6379> 
127.0.0.1:6379> ZINCRBY music 1000 fskl
"1000"
127.0.0.1:6379> ZINCRBY music 10000  fshkl
"10000"
127.0.0.1:6379> ZINCRBY music 100000 lzlsfs
"100000"
127.0.0.1:6379> ZINCRBY music 1000000 tm
"1000000"
127.0.0.1:6379> ZINCRBY music 100 ass
"100"
127.0.0.1:6379> ZREVRANGE music 0 -1 withscores 
 1) "tm"

发布订阅

PUBLISH channel msg
    将信息 message 发送到指定的频道 channel
SUBSCRIBE channel [channel ...]
    订阅频道，可以同时订阅多个频道
UNSUBSCRIBE [channel ...]
    取消订阅指定的频道, 如果不指定频道，则会取消订阅所有频道
PSUBSCRIBE pattern [pattern ...]
    订阅一个或多个符合给定模式的频道，每个模式以 * 作为匹配符，比如 it* 匹配所   有以 it 开头的频道( it.news 、 it.blog 、 it.tweets 等等)， news.* 匹配所有 以 news. 开头的频道( news.it 、 news.global.today 等等)，诸如此类
PUNSUBSCRIBE [pattern [pattern ...]]
    退订指定的规则, 如果没有参数则会退订所有规则
PUBSUB subcommand [argument [argument ...]]
    查看订阅与发布系统状态
注意：使用发布订阅模式实现的消息队列，当有客户端订阅channel后只能收到后续发布到该频道的消息，之前发送的不会缓存，必须Provider和Consumer同时在线。

发布订阅例子：

窗口1：

127.0.0.1:6379> SUBSCRIBE baodi 

窗口2：

127.0.0.1:6379> PUBLISH baodi "jin tian zhen kaixin!"

订阅多频道：
窗口1：
127.0.0.1:6379> PSUBSCRIBE wang*
窗口2：
127.0.0.1:6379> PUBLISH wangbaoqiang "jintian zhennanshou "

7、Rediis事务

开启事务功能时（multi）
multi
command1
command2
command3
command4

4条语句作为一个组，并没有真正执行，而是被放入同一队列中。
如果，这是执行discard，会直接丢弃队列中所有的命令，而不是做回滚。

exec
当执行exec时，对列中所有操作，要么全成功要么全失败

127.0.0.1:6379> set a b
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set a b
QUEUED
127.0.0.1:6379> set c d
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK

8、redis乐观锁实现（模拟买票）

发布一张票
set ticket 1

窗口1：
watch ticket
multi
set ticket 0       1---->0

窗口2：
multi 
set ticket 0 
exec 

窗口1：
exec

9、 服务器管理命令

Info
Clinet list
Client kill ip:port
config get *
CONFIG RESETSTAT 重置统计
CONFIG GET/SET 动态修改
Dbsize
FLUSHALL 清空所有数据 
select 1
FLUSHDB 清空当前库

MONITOR 监控实时指令
SHUTDOWN 关闭服务器

关闭数据库：
redis-cli -a root shutdown

10、redis主从复制

原理：

1. 从服务器向主服务器发送 SYNC 命令。
2. 接到 SYNC 命令的主服务器会调用BGSAVE 命令，创建一个 RDB 文件，并使用缓冲区记录接下来执行的所有写命令。
3. 当主服务器执行完 BGSAVE 命令时，它会向从服务器发送 RDB 文件，而从服务器则会接收并载入这个文件。
4. 主服务器将缓冲区储存的所有写命令发送给从服务器执行。

1、在开启主从复制的时候，使用的是RDB方式的，同步主从数据的
2、同步开始之后，通过主库命令传播的方式，主动的复制方式实现
3、2.8以后实现PSYNC的机制，实现断线重连

主从数据一致性保证：
min-slaves-to-write 1
min-slaves-max-lag

这个特性的运作原理：

从服务器以每秒一次的频率 PING 主服务器一次， 并报告复制流的处理情况。
主服务器会记录各个从服务器最后一次向它发送 PING 的时间。

用户可以通过配置， 指定网络延迟的最大值 min-slaves-max-lag ，
以及执行写操作所需的至少从服务器数量 min-slaves-to-write 。

如果至少有 min-slaves-to-write 个从服务器， 并且这些服务器的延迟值都少于 min-slaves-max-lag秒，
那么主服务器就会执行客户端请求的写操作。

你可以将这个特性看作 CAP 理论中的 C 的条件放宽版本： 尽管不能保证写操作的持久性， 
但起码丢失数据的窗口会被严格限制在指定的秒数中。

另一方面， 如果条件达不到 min-slaves-to-write 和 min-slaves-max-lag 所指定的条件， 那么写操作就不会被执行
主服务器会向请求执行写操作的客户端返回一个错误。

主库是否要开启持久化？
如果不开,有可能主库重启操作,造成所有主从数据丢失！

主从复制实现：

1、环境：
准备两个或两个以上redis实例

mkdir /data/638{0..2}

配置文件示例：
vim /data/6380/redis.conf

port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no

vim /data/6381/redis.conf

port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
protected-mode no

vim /data/6382/redis.conf

port 6382
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
protected-mode no

启动：

redis-server /data/6380/redis.conf
redis-server /data/6381/redis.conf
redis-server /data/6382/redis.conf

主节点：6380
从节点：6381、6382

2、开启主从：
6381/6382命令行:

redis-cli -p 6381
SLAVEOF 127.0.0.1 6380

redis-cli -p 6382
SLAVEOF 127.0.0.1 6380

3、查询主从状态

从库：
127.0.0.1:6382> info replication

主库：
127.0.0.1:6380> info replication

主库故障模拟及切换（failover过程）：

4、从库切为主库

模拟主库故障

redis-cli -p 6380
shutdown

redis-cli -p 6381
info replication
slaveof no one

6382连接到6381：
[root@db03 ~]# redis-cli -p 6382
127.0.0.1:6382> SLAVEOF no one
127.0.0.1:6382> SLAVEOF 127.0.0.1 6381

---

redis-sentinel（哨兵）

sentinel的作用：

1、监控(不断检查主、从服务器是否正常)，提醒（通过api发送通知信息）
2、自动选主，切换（6381 slaveof no one）
3、2号从库（6382）指向新主库（6381）

工作原理:

通过用户给定的配置文件来发现主服务器，sentinel本身可以有多个管理节点，用于Redis节点故障后 判断是否真实故障，通过Raf协议选举判断，半数以上投票主节点失败则确认主节点故障，选举一个新主库。如果节点恢复了，会把它作为一个从节点的角色加入集群。

sentinel搭建过程

sentinel集群开始下面的操作，需要保证已经实现了redis的主从复制环境。

mkdir /data/26380
cd /data/26380

vim sentinel.conf
port 26380
dir "/data/26380"

#127.0.0.1 6380是集群里面主从复制的主节点，由于是单机，所以sentinel 为1就可以判断为故障发生了
sentinel monitor mymaster 127.0.0.1 6380 1

#sentinel如果5s还联系不上主节点，则表示故障
sentinel down-after-milliseconds mymaster 5000

启动：
redis-sentinel /data/26380/sentinel.conf &

停主库测试：

[root@db01 ~]# redis-cli -p 6380
shutdown

[root@db01 ~]# redis-cli -p 6381
info replication

启动源主库（6380），看状态。

---

redis cluster （redis集群）

redis cluster 功能之 高性能：

基于KEY进行数据拆分

1、在多分片节点中，将16384个槽位，均匀分布到多个分片节点中
2、存数据时，将key做crc16(key),然后和16384进行取模，得出槽位值（0-16383之间）
3、根据计算得出的槽位值，找到相对应的分片节点的主节点，存储到相应槽位上
4、如果客户端当时连接的节点不是将来要存储的分片节点，分片集群会将客户端连接切换至真正存储节点进行数据存储

redis cluster 功能之 高可用：
在搭建集群时，会为每一个分片的主节点，对应一个从节点，实现slaveof的功能，同时当主节点down，实现类似于sentinel的自动failover的功能。

规划、搭建过程

6个redis实例，一般会放到3台硬件服务器
注：在企业规划中，一个分片的两个节点，分到不同的物理机，防止硬件主机宕机造成的整个分片数据丢失。

端口号：7000-7005

1、安装集群插件

EPEL源安装ruby支持
yum install ruby rubygems -y

使用国内源
gem sources -l
gem sources -a http://mirrors.aliyun.com/rubygems/ 
gem sources  --remove http://rubygems.org/
gem install redis -v 3.3.3
gem sources -l

或者：
gem sources -a http://mirrors.aliyun.com/rubygems/  --remove http://rubygems.org/ 

2、集群节点准备

mkdir /data/700{0..5}

vim /data/7000/redis.conf
port 7000
daemonize yes
pidfile /data/7000/redis.pid
loglevel notice
logfile "/data/7000/redis.log"
dbfilename dump.rdb
dir /data/7000
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

vim /data/7001/redis.conf
port 7001
daemonize yes
pidfile /data/7001/redis.pid
loglevel notice
logfile "/data/7001/redis.log"
dbfilename dump.rdb
dir /data/7001
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

vim /data/7002/redis.conf
port 7002
daemonize yes
pidfile /data/7002/redis.pid
loglevel notice
logfile "/data/7002/redis.log"
dbfilename dump.rdb
dir /data/7002
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

vim /data/7003/redis.conf
port 7003
daemonize yes
pidfile /data/7003/redis.pid
loglevel notice
logfile "/data/7003/redis.log"
dbfilename dump.rdb
dir /data/7003
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

vim /data/7004/redis.conf
port 7004
daemonize yes
pidfile /data/7004/redis.pid
loglevel notice
logfile "/data/7004/redis.log"
dbfilename dump.rdb
dir /data/7004
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

vim /data/7005/redis.conf
port 7005
daemonize yes
pidfile /data/7005/redis.pid
loglevel notice
logfile "/data/7005/redis.log"
dbfilename dump.rdb
dir /data/7005
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

启动节点：

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

[root@db01 ~]# ps -ef |grep redis
root       8854      1  0 03:56 ?        00:00:00 redis-server *:7000 [cluster]     
root       8858      1  0 03:56 ?        00:00:00 redis-server *:7001 [cluster]     
root       8860      1  0 03:56 ?        00:00:00 redis-server *:7002 [cluster]     
root       8864      1  0 03:56 ?        00:00:00 redis-server *:7003 [cluster]     
root       8866      1  0 03:56 ?        00:00:00 redis-server *:7004 [cluster]     
root       8874      1  0 03:56 ?        00:00:00 redis-server *:7005 [cluster]  

3、将节点加入集群管理

通过redis-trib.rb 命令创建集群，每个分片主节点保留一份副本（一个副本就够了，多了也浪费，集群没有自带读写分离机制），自动选择前三个为主节点，后三个为按照顺序对应从节点。主从节点不要放到一个机器上面，以免宕机导致数据丢失。

redis-trib.rb create --replicas 1 127.0.0.1:7000 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

4、集群状态查看

集群主节点状态
redis-cli -p 7000 cluster nodes | grep master

集群从节点状态
redis-cli -p 7000 cluster nodes | grep slave

---

5、集群节点管理

5.1 增加新的节点（新的分片也需要有主从节点）

需要做的操作：让集群认识这个新节点，再把已有的槽位重新划分，划拨一些槽位分配给新节点。

mkdir /data/7006
mkdir /data/7007

vim /data/7006/redis.conf
port 7006
daemonize yes
pidfile /data/7006/redis.pid
loglevel notice
logfile "/data/7006/redis.log"
dbfilename dump.rdb
dir /data/7006
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

vim /data/7007/redis.conf
port 7007
daemonize yes
pidfile /data/7007/redis.pid
loglevel notice
logfile "/data/7007/redis.log"
dbfilename dump.rdb
dir /data/7007
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

redis-server /data/7006/redis.conf 
redis-server /data/7007/redis.conf 

5.2 添加主节点：（把7006添加到7000所在的集群里面）

redis-trib.rb add-node 127.0.0.1:7006 127.0.0.1:7000

5.3 转移slot（重新分片）

redis-trib.rb reshard 127.0.0.1:7000

会进入交互式的输入窗口，大概意思是你想要移动多少槽位给哪个节点，从哪里划拨资源（一般填入all）
然后就会开始均一部分slot给新节点，需要花费一些时间。

5.4 添加从节点

# 7007代表了master-id这个的从节点，7000代表在这个集群中
redis-trib.rb add-node --slave --master-id bff7d6e603578033f53865de3e55fb2b8c526b60 127.0.0.1:7007 127.0.0.1:7000

6.删除节点

6.1 将需要删除节点slot移动走，但是只能移动其余的一个分片上，导致数据分布不均衡

redis-trib.rb reshard 127.0.0.1:7000
交互式输入时done表示完成，没其他的了

删除一个节点
删除master节点之前首先要使用reshard移除master的全部slot,然后再删除当前节点

主节点删除：
redis-trib.rb del-node 127.0.0.1:7006 bff7d6e603578033f53865de3e55fb2b8c526b60

从节点删除：
redis-trib.rb del-node 127.0.0.1:7007 2af3da4252ad1a7334d476e1b56498b85a1b488c

redis redis-trib.rb工具的使用

1、create：创建集群
2、check：检查集群
3、info：查看集群信息
4、fix：修复集群
5、reshard：在线迁移slot
6、rebalance：平衡集群节点slot数量
7、add-node：将新节点加入集群
8、del-node：从集群中删除节点
9、set-timeout：设置集群节点间心跳连接的超时时间
10、call：在集群全部节点上执行命令
11、import：将外部redis数据导入集群

---

redis的多API支持----python为例

 tar xf Python-3.5.2.tar.xz 
cd  Python-3.5.2
./configure
make && make install

https://redis.io/clients 下载 redis-py-master.zip

unzip redis-py-master.zip
cd redis-py-master
python3 setup.py install

安装redis-cluser的客户端程序

cd redis-py-cluster-unstable
python3 setup.py install

1、对redis的单实例进行连接操作

python3
>>>import redis
>>>r = redis.StrictRedis(host='localhost', port=6379, db=0,password='root')
>>>r.set('lufei', 'guojialei')
True
>>>r.get('lufei')
'bar'

2、sentinel集群连接并操作

[root@db01 ~]# redis-server /data/6380/redis.conf
[root@db01 ~]# redis-server /data/6381/redis.conf
[root@db01 ~]# redis-server /data/6382/redis.conf 
[root@db01 ~]# redis-sentinel /data/26380/sentinel.conf &

导入redis sentinel包

>>> from redis.sentinel import Sentinel  
##指定sentinel的地址和端口号
>>> sentinel = Sentinel([('localhost', 26380)], socket_timeout=0.1)  
##测试，获取以下主库和从库的信息
>>> sentinel.discover_master('mymaster')  
>>> sentinel.discover_slaves('mymaster')  
##配置读写分离
#写节点
>>> master = sentinel.master_for('mymaster', socket_timeout=0.1)  
#读节点
>>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)  
###读写分离测试   key     
>>> master.set('oldboy', '123')  
>>> slave.get('oldboy')  
'123'

读写分离需要在代码里面操作，官方没有提供读写分离方案。

redis cluster的连接并操作（python2.7.2以上版本才支持redis cluster，我们选择的是3.5）
https://github.com/Grokzen/redis-py-cluster

3、python连接rediscluster集群测试
使用

python3
>>> from rediscluster import StrictRedisCluster  
>>> startup_nodes = [{"host": "127.0.0.1", "port": "7000"}]  
### Note: decode_responses must be set to True when used with python3  
>>> rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)  
>>> rc.set("foo", "bar")  
True  
>>>   
'bar'

在集群里面执行命令的两种情况

命令发送到了正确的节点：
命令要处理的键所在的槽正好是由接收命令的节点负责，那么该节点执行命令，就像单机 Redis 服务器一样。

命令发送到了错误的节点：
接收到命令的节点并非处理键所在槽的节点，那么节点将向客户端返回一个转向（redirection）错误，告知客户端应该到哪个节点去执行这个命令，客户端会根据错误提示的信息，重新向正确的节点发送命令。

转载于:https://blog.51cto.com/12083623/2360243