分布式缓存——Redis

时间：2021-05-30 05:43:19

一、Redis介绍

Redis是一个开源的使用C语言编写、开源、支持网络、可基于内存亦可持久化的日志型、高性能的key-value数据库，并提供多种语言的API。它通常被称为数据结构服务器，因为值（value）可以是字符串（string）、哈希（Map）、列表（List）、集合（sets）和有序集合（sorted sets）等类型。

（1）Redis和其他key-value缓存产品的特点

  • Redis支持数据持久化，可以将内存中的数据写入磁盘中，重启之后可以再次加载进行使用。
  • Redis不仅仅支持简单的key-value类型的数据，同时还提供list、set、zset、hash等数据结构的存储。
  • Redis支持数据备份，即master-slave模式的数据备份。

（2）Redis的优势

  • 性能极高。Redis的读速度大约为110000次/秒，写速度大约是8100次/秒。
  • 丰富的数据类型。
  • 原子性。Redis的所有操作都是原子行的，同时Redis还支持对几个操作合并之后的原子性执行（原子性是指事物的不可分割性，一个事务的所有操作要么不间断的全部被执行，要么一个也没有执行）
  • 丰富的特性。Redis还支持发布/订阅通知，key过期等特性。

（3）Redis的一些介绍

互联网数据大多数是使用两种方式来存储的，关系数据库或key-value。但是关系数据库的存储对于互联网数据来说，都会产生一些冗余数据，会存储一些重复数据。key-value存储的修改和删除都比较麻烦，会导致所有的数据读出再写入。Redis在内存中设计了多种数据类型。让业务可以高速原子的访问这些数据结构。

Redis新版本增加了VM（虚拟内存）特性。VM特性就是暂时把不经常访问的数据（冷数据）从内存交换到磁盘中，从而将空间用于其他经常访问的数据（热数据）。通过VM实现冷热数据分离，使热数据保存到内存中，冷数据保存到磁盘中。这种方法使得Redis数据容量突破了物理内存的限制。

如果在没有实现VM特性的情况下，Redis的全部数据都要放置在内存中。如果一个key-value单元需要最小占用512个字节，即使只放入一个key-value也会占用512个字节；此时我们可以将key复用，几个key-value放入一个key中，value再作为一个数组放入，这样就会节省内存空间。

（4）Redis的存储方式

  1. RDB模式(默认方式) 【备份模式】

实现方式是定时将内存的快照持久化到磁盘，这种方式的缺点是持久化之后如果出现宕机则会丢失一段数据。原因：RDB是在某个时间点将数据写入一个临时文件，持久化结束后，用这个临时文件替换上次持久化的文件，达到数据恢复。

分布式缓存——Redis

优点：使用单独子进程来进行持久化，主进程不会进行任何IO操作，保证了Redis的高性能。

缺点：RDB是间隔一段时间进行持久化，如果持久化之间redis发生故障，会发生数据丢失。

适用：数据要求不严谨的时候。

2.  AOF模式【容灾模式】

AOF即append（追加） only file。该模式是在写入内存数据的同时将操作命令保存到日志文件，但在产生大型数据的系统中，命令日志会非常大，aof在这种系统中就失去了高可用的本意。

分布式缓存——Redis

优点：AOF模式保证了数据的可靠性和高可用性，可以保持更高的数据完整性。

缺点：AOF文件比RDB文件大，且恢复速度较慢。

另一种达到容灾的方式：Replication。由于Redis复制基本上没有延迟，这样可以防止单点故障并实现高可用。（主从）

分布式缓存——Redis

二、Redis的数据类型和Redis的应用场景

（1）Redis的数据类型

Redis支持五种数据类型：String(字符串)，hash（哈希），set（集合），zset（有序集合），list（列表）。

1、String(字符串)

字符串是Redis最基础的数据类型。一个key对应一个vaule。value可以包含任何数据，包含图片或序列化对象。一个键最大能存储512MB。

序列化对象：序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

#添加一个key
1 127.0.0.1:6379> set var "String abc"  #设置一个key（var）值（value）为（string abc）

2 OK

3 127.0.0.1:6379> get var  #获取var的vaule

4 "String abc"
#redis中大小写敏感


127.0.0.1:6379> set name "redis"
OK
127.0.0.1:6379> get NAME
(nil)
127.0.0.1:6379> set NAME "REDIS"
OK
127.0.0.1:6379> get name
"redis"
127.0.0.1:6379> get NAME
"REDIS"




  #设置自动过期时间




 1 TTL #查看key的剩余生命周期

 2 -1  #该选项代表key永不过期。重新对key赋值，之前有的生命周期会改变为永不过期

 3 -2  #该选项代表key不存在。

 4 num  #出现数字代表剩余的生命周期

 5

 6 127.0.0.1:6379> set face wang EX 100  #设置face的生命周期为100秒

 7 OK

 8 127.0.0.1:6379> TTL face  #查看face的生命周期

 9 (integer) 89

10 127.0.0.1:6379> TTL face

11 (integer) 85

12 127.0.0.1:6379> set face zhang  #修改face的值，生命周期改变为永不过期

13 OK

14 127.0.0.1:6379> TTL face

15 (integer) -1

16 127.0.0.1:6379> EXPIRE face 1000  #修改face的生命周期为1000秒

17 (integer) 1

18 127.0.0.1:6379> TTL face

19 (integer) 995

20 127.0.0.1:6379> PERSIST face  #删除生命周期，设置为永不过期

21 (integer) 1

22 127.0.0.1:6379> TTL face

23 (integer) -1




   #删除一个或多个key




 1 127.0.0.1:6379> DEL face  #删除一个key

 2 (integer) 1

 3 127.0.0.1:6379> get face

 4 (nil)

 5 127.0.0.1:6379> DEL face name   #删除多个key

 6 (integer) 2

 7 127.0.0.1:6379> get face

 8 (nil)

 9 127.0.0.1:6379> get name

10 (nil)




#批量设置与获取key




 1 127.0.0.1:6379> MSET key1 value1 key2 value2 key3 value3  #批量设置key

 2 OK

 3 127.0.0.1:6379> MGET key1 key2 key3  #批量获取key

 4 1) "value1"

 5 2) "value2"

 6 3) "value3"

 7 127.0.0.1:6379> KEYS n*  #获取所有以n开头的key

 8 1) "nc"

 9 2) "na"

10 3) "nb"

11 127.0.0.1:6379> KEYS k*   #获取所有以k开头的key

12 1) "key1"

13 2) "key3"

14 3) "key2"

15 127.0.0.1:6379> KEYS *   #获取所有key

16  1) "key1"

17  2) "nc"

18  3) "na"

19  4) "bcd"

20  5) "key3"

21  6) "key2"

22  7) "var"

23  8) "nb"

24  9) "abc"

25 10) "NAME"




#追加数据与返回字符串长度




 1 127.0.0.1:6379> get var

 2 "String abc"

 3 127.0.0.1:6379> APPEND var "append"  #给key的value追加数据

 4 (integer) 16

 5 127.0.0.1:6379> get var

 6 "String abcappend"

 7 127.0.0.1:6379> STRLEN var  #获取key的value的字符串长度

 8 (integer) 16

 9 127.0.0.1:6379> APPEND var "123456"

10 (integer) 22

11 127.0.0.1:6379> STRLEN var

12 (integer) 22

13 127.0.0.1:6379> get var

14 "String abcappend123456"




  #数值递增与递减




 1 127.0.0.1:6379> set num 10

 2 OK

 3 127.0.0.1:6379> INCR num  #数值递增

 4 (integer) 11

 5 127.0.0.1:6379> get num

 6 "11"

 7 127.0.0.1:6379> STRLEN num

 8 (integer) 2

 9 127.0.0.1:6379> DECR num  #数值递减

10 (integer) 10

11 127.0.0.1:6379> get num

12 "10"




 #判断key是否存在




 1 127.0.0.1:6379> keys *

 2  1) "key1"

 3  2) "nc"

 4  3) "na"

 5  4) "bcd"

 6  5) "key3"

 7  6) "key2"

 8  7) "var"

 9  8) "nb"

10  9) "abc"

11 10) "NAME"

12 11) "num"

13 127.0.0.1:6379> EXISTS NAME  #判断是否存在

14 (integer) 1  （存在）

15 127.0.0.1:6379> EXISTS name

16 (integer) 0




2、哈希


hash是一个string类型的field和value的映射表，Redis中的每一个hash可以存储2^32-1键值对，类似于字典，存放了多个键值对，hash特别适合用于存储对象场景。




 1 127.0.0.1:6379> HSET 9527 name zhouxingchi age 20 salary 5000000   #生成一个hash

 2 (integer) 3

 3 127.0.0.1:6379> HSET school teacher abc age 50 salary 5000  #生成一个hash

 4 (integer) 3

 5 127.0.0.1:6379> TYPE 9527 #查看这个key的类型

 6 hash

 7 127.0.0.1:6379> TYPE school

 8 hash

 9 127.0.0.1:6379> HGET 9527 age  #查看hash中的某个key的值

10 "20"

11 127.0.0.1:6379> HGET 9527 name

12 "zhouxingchi"

13 127.0.0.1:6379> HGET school teacher

14 "abc"

15 127.0.0.1:6379> HMGET school teacher age salary  #获取hash中多个值

16 1) "abc"

17 2) "50"

18 3) "5000"

19 127.0.0.1:6379> HDEL school teacher #删除hash中的某个key字段

20 (integer) 1

21 127.0.0.1:6379> HGET school teacher

22 (nil)

23 127.0.0.1:6379> HMSET school teacher zhangbs age 24  salary 90000  #重新设置一个hash中的值

24 OK

25 127.0.0.1:6379> HKEYS school  #获取某一个hash中的所有key

26 1) "age"

27 2) "salary"

28 3) "teacher"

29 127.0.0.1:6379> HGETALL school  #获取指定hash中的所有key和value

30 1) "age"

31 2) "24"

32 3) "salary"

33 4) "90000"

34 5) "teacher"

35 6) "zhangbs"

36 127.0.0.1:6379> DEL school  #删除一个hash

37 (integer) 1

38 127.0.0.1:6379> HMGET school name

39 1) (nil)

40 127.0.0.1:6379> EXISTS school  #hash以及不存在

41 (integer) 0




3、集合


set是string类型的无序集合，集合中的成员是唯一的，这就意味着集合中不能出现重复的数据，可以在两个不同的集合中对数据进行对比并取值，常用于取值判断，统计，交集等场景。




 1 127.0.0.1:6379> SADD set1 v1  #创建一个集合，里面元素有v1

 2 (integer) 1

 3 127.0.0.1:6379> SADD set2 v2 v4  #创建一个集合，里面元素有v2 v4

 4 (integer) 2

 5 127.0.0.1:6379> SADD set1 v2 v3 v4  #往集合set1中添加元素

 6 (integer) 3

 7 127.0.0.1:6379> SADD set2 v2 v6 #往集合set2中添加元素，但只添加成功一个，因为集合中元素不能重复

 8 (integer) 1

 9 #查询集合中的所有元素

10 127.0.0.1:6379> SMEMBERS set1

11 1) "v1"

12 2) "v2"

13 3) "v4"

14 4) "v3"

15 127.0.0.1:6379> SMEMBERS set2

16 1) "v2"

17 2) "v6"

18 3) "v4"

19 #求set1和set2的交集

20 127.0.0.1:6379> SINTER set1 set2

21 1) "v2"

22 2) "v4"

23 #求set1和set2的并集

24 127.0.0.1:6379> SUNION set1 set2

25 1) "v3"

26 2) "v4"

27 3) "v2"

28 4) "v6"

29 5) "v1"

30 ##求set1和set2的差集

31 127.0.0.1:6379> SDIFF set1 set2

32 1) "v1"

33 2) "v3"




4、有序集合


Redis有序集合和集合一样也是string类型的元素的集合，且不允许有重复的成员，不同的是每个元素都会关联一个double(双精度浮点型)类型的分数，Redis通过该分数来为集合中的成员进行从小到大的排序，有序集合的成员是唯一的，但是分数是可以重复的，集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)，集合中最大的成员数为2^32-1(大概四亿多)，经常用于排行榜的场景。




 1 #生成有序集合

 2 127.0.0.1:6379> ZADD zset01 1 chu  #分数为一

 3 (integer) 1

 4 127.0.0.1:6379> ZADD zset01 2 ye

 5 (integer) 1

 6 127.0.0.1:6379> ZADD zset01 3 zhang

 7 (integer) 1

 8 127.0.0.1:6379> ZADD zset01 2 wu

 9 (integer) 1

10 127.0.0.1:6379> ZADD zset01 3 wu  #分数可以重复，但是元素值不可以重复

11 (integer) 0

12 #创建一个例子

13 127.0.0.1:6379> ZADD paihangbang 90 neizha 100 anqila 110 change 120 diaochan 130 daji   #创建一个有序集合

14 (integer) 5

15 127.0.0.1:6379> ZRANGE paihangbang 0 -1  #正序排序后显示所有的key

16 1) "neizha"

17 2) "anqila"

18 3) "change"

19 4) "diaochan"

20 5) "daji"

21 127.0.0.1:6379> ZREVRANGE paihangbang 0 -1  #倒序排序后显示所有的key

22 1) "daji"

23 2) "diaochan"

24 3) "change"

25 4) "anqila"

26 5) "neizha"

27 127.0.0.1:6379> ZRANGE paihangbang 0 -1 WITHSCORES  #正序显示多有的key和分数

28 1) "neizha"

29 2) "90"

30 3) "anqila"

31 4) "100"

32 5) "change"

33 6) "110"

34 7) "diaochan"

35 8) "120"

36 9) "daji"

37 10) "130"

38 127.0.0.1:6379> ZREVRANGE paihangbang 0 -1 WITHSCORES  #倒序显示多有的key和分数

39 1) "daji"

40 2) "130"

41 3) "diaochan"

42 4) "120"

43 5) "change"

44 6) "110"

45 7) "anqila"

46 8) "100"

47 9) "neizha"

48 10) "90"

49

50 #获取该有序集合的长度

51 127.0.0.1:6379> ZCARD paihangbang

52 (integer) 5

53 127.0.0.1:6379> ZCARD zset01

54 (integer) 4

55

56

57 #根据索引获取key或根据key获取索引

58 127.0.0.1:6379> ZRANGE paihangbang 0 2  #获取索引为0~2的所有key

59 1) "neizha"

60 2) "anqila"

61 3) "change"

62 127.0.0.1:6379> ZRANGE paihangbang 0 10    #获取索引为0~10的所有key，超出范围不报错

63 1) "neizha"

64 2) "anqila"

65 3) "change"

66 4) "diaochan"

67 5) "daji"

68 127.0.0.1:6379> ZRANGE paihangbang 2 2

69 1) "change"

70 127.0.0.1:6379> ZRANK paihangbang change  #获取key为change的索引

71 (integer) 2

72 127.0.0.1:6379> ZRANK paihangbang neuzha #key不存在

73 (nil)




5、列表


列表是一个双向可读写管道，其头部是左侧，尾部为右侧，一个列表最多可含2^32-1个元素。下标1表示第一个元素，下标2表示第二个元素，依此类推；下标-1表示倒数第一个元素，下标-2表示倒数第二个元素。元素值可以重复，常用于存入日志等场景。




#一个例子

127.0.0.1:6379> LPUSH list01 jack tom jhon Lucille  #创建了一个列表

(integer) 4

127.0.0.1:6379> TYPE list01   #查看类型

list

127.0.0.1:6379> LRANGE list01 0 -1    #查看该列表的所有元素

1) "Lucille"

2) "jhon"

3) "tom"

4) "jack"




分布式缓存——Redis


#新添加一个元素




1 127.0.0.1:6379> LPUSH list01 sunce  #在原有列表中插入一个新元素

2 (integer) 5

3 127.0.0.1:6379> LRANGE list01 0 -1

4 1) "sunce"

5 2) "Lucille"

6 3) "jhon"

7 4) "tom"

8 5) "jack"




分布式缓存——Redis #获取列表长度




127.0.0.1:6379> LLen list01

(integer) 5

127.0.0.1:6379> LRANGE list01 0 -1

1) "sunce"

2) "Lucille"

3) "jhon"

4) "tom"

5) "jack"




#获取指定列表的某个值




127.0.0.1:6379> LINDEX list01 0

"sunce"

127.0.0.1:6379> LINDEX list01 -1

"jack"




#获取列表某个范围的值




127.0.0.1:6379> LRANGE list01 0 2

1) "sunce"

2) "Lucille"

3) "jhon"

127.0.0.1:6379> LRANGE list01 2 2

1) "jhon"




#移除列表与列表数据




 1 127.0.0.1:6379> LRANGE abcd 0 -1   #查询列表abcd中的所有值

 2 1) "d"

 3 2) "c"

 4 3) "b"

 5 4) "a"

 6 127.0.0.1:6379> LPOP abcd  #删除第一个元素，即最左边的元素 序号为0的元素

 7 "d"

 8 127.0.0.1:6379> LRANGE abcd 0 -1

 9 1) "c"

10 2) "b"

11 3) "a"

12 127.0.0.1:6379> RPOP abcd  #删除最后一个元素 即最右边的元素

13 "a"

14 127.0.0.1:6379> LRANGE abcd 0 -1

15 1) "c"

16 2) "b"

17 127.0.0.1:6379>

18 127.0.0.1:6379> LPUSH list a b c d e f

19 (integer) 6

20 127.0.0.1:6379> LRANGE list 0 -1

21 1) "f"

22 2) "e"

23 3) "d"

24 4) "c"

25 5) "b"

26 6) "a"

27 127.0.0.1:6379> LTRIM list 1 2   #对列表进行修剪，不在指定区间的元素都被删除

28 OK

29 127.0.0.1:6379> LRANGE list 0 -1

30 1) "e"

31 2) "d"

32 127.0.0.1:6379>

33 127.0.0.1:6379> DEL list   #删除列表

34 (integer) 1

35 127.0.0.1:6379> EXISTS list

36 (integer) 0




（2）Redis的应用场景


Redis最大的作用是增大原本的访问性能。Redis的典型使用场景：


    

  1. 缓存系统。Redis可以替代memcache，让缓存只能存储数据变得能够更新数据，因此我们不需要每次都重新生成数据。
    2. 

  2. 计数器和排行榜等相关问题。计数器使用原子递增，就可以实现各种计数；GETSET可以重置计数器，或者过期属性。排行榜使用有序集合根据分数进行排序。
    3. 

  3. 消息队列系统。简单的消息队列系统可以使用Redis，它支持模式匹配，能够实施订阅与取消频道。
    4. 

  4. 社交网络。Redis可以很好的和社交网络进行结合，例如Redis就可以实现一些交互，例如实时聊天。
    5. 

  5. 过期项目处理。通过UNIX时间作为关键字，用来保持列表能够按时间排序。
    6. 

  6. 实时系统。使用位图来做布隆过滤器，例如：垃圾邮件过滤系统。
    7. 



二、Redis持久化


Redis需要经常将内存中的数据同步到磁盘来保证持久化。Redis支持四种持久化方式。一种是RDB、另一种是AOF、还有一个是虚拟内存方式（该方式已被丢弃。）、最后一个是diskstore方式。


（1）RDB


RDB即快照是默认的持久化方式。这种方式就是将内存中的数据以快照的方式写入到二进制文件中，默认的文件名为dump.rdb。可以通过设置自动做快照持久化的方式。我们可以配置redis在n秒内如果超过m个key被修改就自动做快照，配置文件为redis.conf 。




#如下是默认的快照保存设置

save 900 1   #900秒之内如果有一个key被修改，就发起快照保存

save 300 10   #300秒内如果有10个key被修改，就发起快照保存

save 60 10000  #60秒内如果有10000个key被修改，就发起快照保存





　快照保存过程：


分布式缓存——Redis




client请求也可以使用save或者bgsave命令通知redis做一次快照持久化。save操作是在线程中保存快照的，由于redis是用一个主线程来处理所有的client请求的，这种方式会阻塞所有的client请求，一般情况下不推荐使用。


另一个，每次快照持久化都是讲内存数据完整的写入到磁盘一次，并不是增量的。所以，如果数据量较大且写操作比较多的话，会引起大量的I/O操作，可能会严重影响性能。




由于快照方式的持久化是间隔一段时间进行一次，所以在间隔时间内，Redis因为意外宕机的话，就会丢失一部分数据。


（2）AOF


AOF持久化是将每一个收到的写命令都通过write函数追加到文件中（默认是appendonly.aof）。当redis重启时会通过重新执行文件中保存的写命令来在内存中重建整个数据库的内存。


当然，由于OS会在内核中缓存write做的修改，所以可能不是立即写到磁盘上。这样AOF方式的持久化也可能会导致部分丢失。不过我们可以在配置文件中配置redis我们想要通过fsync函数强制os写入到磁盘的时机，如下：




appendonly no   #是否启动aof持久化方式

# appendfsync always   #每次收到写命令就立即强制写入磁盘，最慢的，但是可以保证完全的持久化，不推荐使用

appendfsync everysec   #每秒总强制写入磁盘一次，在性能和持久化方面做了很好的折中，推荐使用

# appendfsync no  #完全依赖os，性能最好，持久化没保证





　　AOF的方式也同时带来了另一个问题。持久化文件会变得越来越大。例如，如果我们调用了一个函数一百次，文件中就保存了100条命令，但其中99条就是多余的。因为要恢复数据库的状态其实文件中保存一条 “set 函数 100”就可以了。为了压缩aof的持久化文件，redis提供了bgrewriteaof命令，收到这个命令redis将使用与快照类似的方式将内存中的数据以命令的方式保存到临时文件中，最后替换原来的文件。


具体过程如下：


分布式缓存——Redis


以上的aof文件重写的操作中，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件。


（3）数据持久化对比





 


RDB持久化


AOF持久化




描述

默认的持久化方式。实现方法：每隔一段时间将内存的快照持久化到磁盘。
实现方式：在写入内存数据的同时将命令保存到一个临时文件。




优点
使用单独的子进程来进行持久化，主进程不会进行i/o操作，保证redis的性能。
保证了数据的可靠性和高可用性，保证更高的数据完整性。




缺点
间隔一段时间导致可能会导致数据丢失，在间隔时间中Redis宕机。
在并发较高的系统中，命令日志会很大，恢复时间较长；文件必RDB大很多。




适用场景
适合对数据要求不严谨的场景。
适合对数据完整性较高的场景。





（4）diskstore方式


diskstore方式是放弃了虚拟内存方式之后选择的一种新的实现方式。具体细节：




1、读操作。使用read through以及LRU方式。内存中不存在的数据从磁盘拉取并放入内存，内存中放不下的数据采用LRU（最近最少使用）淘汰。


2、写操作。采用另外的spawn一个线程单独处理，写线程通常是异步的（推荐）。当然也可以把cache-flush-delay配置为0，Redis尽量保证即使写入（这个方式可能会导致调用方卡住。以上选项设置为0，多个client需要排队等候，如果队列容量超过cache-max-memory，就会导致调用发卡住。）。




RDB可以和diskstore转换。通过BGSAVE可以随时将diskstore格式另存为rdb格式，而且rdb格式还用于Redis复制以及不同存储方式之间的中间格式。通过工具可以将rdb格式转化成diskstore格式。


三、Redis安装配置及运用


（1）安装


1、编译安装




#安装
[root@redis ~]# yum install gcc gcc-c++ make -y

[root@redis ~]# wget http://download.redis.io/releases/redis-5.0.4.tar.gz

[root@redis ~]# tar xf redis-5.0.4.tar.gz

[root@redis ~]# cd redis-5.0.4

[root@redis redis-5.0.4]# make

[root@redis redis-5.0.4]# echo $?

0

[root@redis redis-5.0.4]# mkdir -p /data/redis

[root@redis redis-5.0.4]# make PREFIX=/data/redis install

[root@redis redis-5.0.4]# echo $?

0

[root@redis redis-5.0.4]# mkdir /data/redis/conf

[root@redis redis-5.0.4]# cp redis.conf /data/redis/conf/


#启动redis

[root@redis redis-5.0.4]# /data/redis/bin/redis-server /data/redis/conf/redis.conf

12040:C 29 Dec 2021 21:45:31.021 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo

12040:C 29 Dec 2021 21:45:31.021 # Redis version=5.0.4, bits=64, commit=00000000, modified=0, pid=12040, just started

12040:C 29 Dec 2021 21:45:31.021 # Configuration loaded

12040:M 29 Dec 2021 21:45:31.022 * Increased maximum number of open files to 10032 (it was originally set to 1024).

                _._

           _.-``__ ''-._

      _.-``    `.  `_.  ''-._           Redis 5.0.4 (00000000/0) 64 bit

  .-`` .-```.  ```\/    _.,_ ''-._

 (    '      ,       .-`  | `,    )     Running in standalone mode

 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379

 |    `-._   `._    /     _.-'    |     PID: 12040

  `-._    `-._  `-./  _.-'    _.-'

 |`-._`-._    `-.__.-'    _.-'_.-'|

 |    `-._`-._        _.-'_.-'    |           http://redis.io

  `-._    `-._`-.__.-'_.-'    _.-'

 |`-._`-._    `-.__.-'    _.-'_.-'|

 |    `-._`-._        _.-'_.-'    |

  `-._    `-._`-.__.-'_.-'    _.-'

      `-._    `-.__.-'    _.-'

          `-._        _.-'

              `-.__.-'

#此时已启动，但如果需要在其上进行什么操作，可以重新启动一个终端。

#在后台启动

[root@redis redis-5.0.4]# /data/redis/bin/redis-server /data/redis/conf/redis.conf &

[1] 12044

12044:C 29 Dec 2021 21:47:00.969 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo

12044:C 29 Dec 2021 21:47:00.969 # Redis version=5.0.4, bits=64, commit=00000000, modified=0, pid=12044, just started

12044:C 29 Dec 2021 21:47:00.969 # Configuration loaded

12044:M 29 Dec 2021 21:47:00.970 * Increased maximum number of open files to 10032 (it was originally set to 1024).

                _._

           _.-``__ ''-._

      _.-``    `.  `_.  ''-._           Redis 5.0.4 (00000000/0) 64 bit

  .-`` .-```.  ```\/    _.,_ ''-._

 (    '      ,       .-`  | `,    )     Running in standalone mode

 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379

 |    `-._   `._    /     _.-'    |     PID: 12044

  `-._    `-._  `-./  _.-'    _.-'

 |`-._`-._    `-.__.-'    _.-'_.-'|

 |    `-._`-._        _.-'_.-'    |           http://redis.io

  `-._    `-._`-.__.-'_.-'    _.-'

 |`-._`-._    `-.__.-'    _.-'_.-'|

 |    `-._`-._        _.-'_.-'    |

  `-._    `-._`-.__.-'_.-'    _.-'

      `-._    `-.__.-'    _.-'

          `-._        _.-'

              `-.__.-'                                               

12044:M 29 Dec 2021 21:47:00.970 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.

12044:M 29 Dec 2021 21:47:00.970 # Server initialized

12044:M 29 Dec 2021 21:47:00.970 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.

12044:M 29 Dec 2021 21:47:00.971 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.

12044:M 29 Dec 2021 21:47:00.971 * DB loaded from disk: 0.000 seconds

12044:M 29 Dec 2021 21:47:00.971 * Ready to accept connections

[root@redis redis-5.0.4]# 

#关闭redis

[root@redis redis-5.0.4]# /data/redis/bin/redis-cli shutdown

12044:M 29 Dec 2021 21:47:37.787 # User requested shutdown...

12044:M 29 Dec 2021 21:47:37.787 * Saving the final RDB snapshot before exiting.

12044:M 29 Dec 2021 21:47:37.811 * DB saved on disk

12044:M 29 Dec 2021 21:47:37.811 * Removing the pid file.

12044:M 29 Dec 2021 21:47:37.812 # Redis is now ready to exit, bye bye...

[1]+  完成                  /data/redis/bin/redis-server /data/redis/conf/redis.conf




2、yum安装




#安装
yum install epel-release -y #下载fedora的epel

yum install redis  #下载redis

#启动等

#启动redis服务

systemctl start redis

#设置开启自启动

systemctl enable redis

#配置文件的地址

cat /etc/redis.conf




（2）调优


redis启动界面有几个警告：




12073:M 29 Dec 2021 21:59:03.066 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.


（backlog参数控制的是三次握手的时候server端收到client 确认号之后的队列值，即全连接队列）


修改方法：vim /etc/sysctl.conf  添加 net.core.somaxconn=1024


net.core.somaxconn 该选项表示socket监听的backlog上限，backlog就是socket的监听队列，当一个请求尚未被处理或者建立时，他会进入backlog。net.core.somaxconn该选项的默认值为128
12073:M 29 Dec 2021 21:59:03.066 # Server initialized
12073:M 29 Dec 2021 21:59:03.066 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.


0：表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则，内存申请失败，并把错误返回给应用进程。


1：表示内核允许分配所有的物理内存，而不管当前的内存状态如何


2：表示内核允许分配超过所有物理内存和交换空间总和的内存


解决：vim /etc/sysctl.conf  添加 vm.overcommit_memory = 1


vm.overcommit_memory 是一种内核堆内存分配的策略。
12073:M 29 Dec 2021 21:59:03.066 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.


警告：内核中启用了透明大页面（THP）支持。这将造成Redis的延迟和内存使用问题。要解决此问题，请以root用户身份运行命令'echo never>/sys/kernel/mm/transparent\u hugepage/enabled'，并将其添加到/etc/rc。本地，以便在重新启动后保留设置。禁用THP后，必须重新启动Redis。


解决方式：


[root@redis ~]# cat /sys/kernel/mm/transparent_hugepage/enabled 
[always] madvise never
[root@redis ~]# echo never > /sys/kernel/mm/transparent_hugepage/enabled
[root@redis ~]# cat /sys/kernel/mm/transparent_hugepage/enabled 
always madvise [never]


[root@redis ~]# cat /etc/rc.d/rc.local 
#!/bin/bash
# THIS FILE IS ADDED FOR COMPATIBILITY PURPOSES
#
# It is highly advisable to create own systemd services or udev rules
# to run scripts during boot instead of using this file.
#
# In contrast to previous versions due to parallel execution during boot
# this script will NOT be run after all other services.
#
# Please note that you must run 'chmod +x /etc/rc.d/rc.local' to ensure
# that this script will be executed during boot.


touch /var/lock/subsys/local
echo never > /sys/kernel/mm/transparent_hugepage/enabled
[root@redis ~]# chmod +x /etc/rc.d/rc.local


12073:M 29 Dec 2021 21:59:03.066 * Ready to accept connections




调优完成


分布式缓存——Redis


（3）连接到Redis


1、人员连接


本机非密码连接




redis-cli





　　跨主机非密码连接




redis-cli -h hostname/IP -p port




跨主机密码连接




redis-cli -h hostname/IP -p port -a PASWORD




2、程序连接


shell脚本写入数据到Redis




[root@redis ~]# cat redis.sh

#!bin/bash

NUM=10

for((i=1;i<=$NUM;i++));do

  echo $i;

  /data/redis/bin/redis-cli -h 127.0.0.1 -p 6379 set 这是第${i}条数据 这条数据的内容为${i}

done; 




python连接方式




#以LINUX系统 centos版本中使用python3连接为例

#准备工作（安装python3和redis-py）

[root@localhost ~]# yum install python3 -y

[root@localhost ~]# wget https://github.com/andymccurdy/redis-py/archive/master.zip

#安装redis-py

[root@localhost ~]# unzip master.zip

[root@localhost ~]# cd redis-py-master/

[root@localhost redis-py-master]# python3 setup.py install

#验证

[root@localhost redis-py-master]# python3

Python 3.6.8 (default, Nov 16 2020, 16:55:22)

[GCC 4.8.5 20150623 (Red Hat 4.8.5-44)] on linux

Type "help", "copyright", "credits" or "license" for more information.

>>> import redis

>>> r = redis.StrictRedis(host='127.0.0.1',port=6379,password='123456');

>>> r.set('name','Lucille');

True

>>> r.get('name');

b'Lucille' 

#普通连接

注：该方法的redis.py必须放置在redis-py-master文件夹下

[root@localhost redis-py-master]# cat redis.py

import redis

r = redis.Redis(host='192.168.10.12',port=6379,password='123456')

r.set('name01','zhnagbs')

print(r.get('name01'))

[root@localhost redis-py-master]# python3.6 redis.py

b'zhnagbs'

#连接池连接

[root@localhost redis-py-master]# cat redispool.py

import redis

pool = redis.ConnectionPool(host='192.168.10.12',port=6379,password='123456')

r = redis.Redis(connection_pool=pool)

r.set('salary','value0000')

date=r.get('salary')

print(date)

r.set('food','noodles',ex=3) #设置过期时间为秒

food=r.get('food')

print(food)

r.set('abc','123',px=300) #设置过期时间为毫秒

food=r.get('food')

print(food)

print((r.set('fruit','poor',nx=True))) #当name不存在时，当前set执行（新建）。 如果fruit不存在，输出True;如果fruit存在，输出None。

print((r.set('fruit','poor',xx=True))) #当name存在时，当前set执行（修改）。 如果fruit已经存在，输出True;如果fruit不存在，输出None。





（4）安全性设置


#修改Redis的登录密码




1 vim /etc/redis.conf

2 #bind 127.0.0.1 注释掉，否则只有本机可登录

3 protected-mode no #保护模式关闭

4 port 6379  #设置端口

5 requirepass 123456  #设置密码

6 重启

#连接


[root@localhost ~]# redis-cli 
127.0.0.1:6379> info
NOAUTH Authentication required.
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> info
# Server
redis_version:3.2.12
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:7897e7d0e13773f
redis_mode:standalone
os:Linux 3.10.0-957.el7.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll


…………




（5）Redis的常用命令详解


1、config


config命令用于查看当前的redis配置、以及在不重启Redis的情况下,动态更改Redis配置




#更改最大内存

127.0.0.1:6379> CONFIG GET maxmemory

1) "maxmemory"

2) "0"

127.0.0.1:6379> CONFIG SET maxmemory 8589934592

OK

127.0.0.1:6379> CONFIG GET maxmemory

1) "maxmemory"

2) "8589934592"

#设置连接密码

127.0.0.1:6379> CONFIG GET requirepass

1) "requirepass"

2) "654321"

127.0.0.1:6379> CONFIG SET requirepass 123456

OK

127.0.0.1:6379> CONFIG GET requirepass

1) "requirepass"

2) "123456"

#获取当前配置

127.0.0.1:6379> CONFIG GET *

  1) "dbfilename"

  2) "dump.rdb"

  3) "requirepass"

  4) "123456"

  5) "masterauth"

  6) ""

  7) "unixsocket"

  8) ""

  9) "logfile"

…………　　




2、INFO


info命令用来显示节点redis运行状态信息。




127.0.0.1:6379> INFO

# Server

redis_version:3.2.12

redis_git_sha1:00000000

redis_git_dirty:0

redis_build_id:7897e7d0e13773f

redis_mode:standalone

os:Linux 3.10.0-957.el7.x86_64 x86_64

arch_bits:64

multiplexing_api:epoll

gcc_version:4.8.5

process_id:8829

run_id:72db7986094df4763a54bd99a24fc6aa2048ab4f

tcp_port:6379

uptime_in_seconds:16123

uptime_in_days:0

hz:10

lru_clock:13411656

executable:/usr/bin/redis-server

config_file:/etc/redis.conf

…………




3、SELECT


切换数据库，等同于MYSQL的use databasename指令。




127.0.0.1:6379[1]> select 0

OK

127.0.0.1:6379> select 1

OK

127.0.0.1:6379[1]> select 16  #Redis的默认数据库为15个

(error) ERR invalid DB index




4、KEYS


keys命令用于查看当前库下的所有key，此命令在测试环境，以及key数量较少的环境下使用。如果在生产环境或数据量较大的环境中，该命令会导致redis锁住，CPU飙升。




127.0.0.1:6379> keys *

1) "name"

2) "salary"

3) "name01"




5、BGSAVE


bgsave该命令表示在后台执行RDB持久化操作。




[root@localhost ~]# ll /var/lib/redis/dump.rdb

-rw-r--r--. 1 redis redis 130 12月 29 22:53 /var/lib/redis/dump.rdb

[root@localhost ~]# redis-cli -h 127.0.0.1 -a '123456' BGSAVE

Background saving started

[root@localhost ~]# ll /var/lib/redis/dump.rdb

-rw-r--r--. 1 redis redis 130 1月  13 17:53 /var/lib/redis/dump.rdb





6、DBSIZE


该命令用于返回库中的所有key的数量




127.0.0.1:6379> DBSIZE

(integer) 3

127.0.0.1:6379> keys *

1) "name"

2) "salary"

3) "name01"

127.0.0.1:6379> SELECT 1

OK

127.0.0.1:6379[1]> DBSIZE

(integer) 0

127.0.0.1:6379[1]> keys *

(empty list or set)





7、FLUSHDB


该命令用于清除当前库的所有key




127.0.0.1:6379[1]> SELECT 2  #切换到一个辛苦

OK

127.0.0.1:6379[2]> mset key1 values key2 values2 key3 abc key4 567  #批量创建字符串

OK

127.0.0.1:6379[2]> DBSIZE  #查看该库有几个key

(integer) 4

127.0.0.1:6379[2]> KEYS *

1) "key3"

2) "key2"

3) "key4"

4) "key1"

127.0.0.1:6379[2]> FLUSHDB

OK

127.0.0.1:6379[2]> KEYS *

(empty list or set)





8、FLUSHALL


该命令用于强制删除整个redis服务器中所有数据库中的所有key，即删除所有数据。




127.0.0.1:6379> FLUSHALL

OK

127.0.0.1:6379> KEYS *

(empty list or set)　　




（6）配置详解


配置文件 使用yum安装是在/etc/redis.conf  使用其他安装方式可以使用“find / -name redis.conf”命令来查询




# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.

daemonize no

默认情况下，Redis不是作为守护进程运行的，如果需要放在后台运行，就可以把它改为yes

#bind 127.0.0.1（如果需要异地连接，这个选项需要注释掉）

监听地址，可以用空格隔开后多个监听

#protected-mode no

该选项时redis3.2版本之后的特性，设置为no，外部网络可以直接访问；设置为yes，需配置bind访问地址和访问密码。

#port 6379

该选项是设置监听端口

#tcp-backlog 511

该选项是三次握手的时候server端收到client的确认号之后的队列值，即全队列长度。

#timeout 0

客户端和Redis服务端的连接超时时间，默认为0，表示永不超时。

#tcp-keepalive 300

TCP会话保持时间。

pidfile /var/run/redis_6379.pid

pid文件路径

databases 16

#设置默认的数据库数量

stop-writes-on-bgsave-error yes

yes时因空间满等原因快照无法保存出错时，禁止redis写入操作。

rdbcompression yes
持久化到RDB文件时，是否压缩。

rdbchecksum yes
是否对备份文件开启RC64校验

dbfilename dump.rdb
持久化快照的文件名

dir /var/lib/redis 快照的保存路径

slave-serve-stale-data yes #当主库同从库失去连接或复制正在进行，从库的两种运行方式：
                             yes：从库会继续响应客户客户端的读请求。
                             no: 除去指定的命令之外都会返回错误“SYNC with master in progress”

slave-read-only yes  是否设置从库只读，设置为no,主从同步时从库可能会覆盖数据，造成数据丢失。

repl-diskless-sync no   #是否使用socket方式复制数据（无盘同步），新salve连接时需要做数据的全量同步，需要从内存dump出新的RDB文件，然后从master传到slave，传输方式：
                         no：master新建一个进程dump生成RDB磁盘文件，RDB完成之后由父进程（主进程）将RDB文件发送给SLAVE。
                         yes：master创建一个新进程直接dump RDB文件到slave的网络socket，不经过主进程和硬盘。

repl-diskless-sync-delay 5   diskless时复制的服务器等待的延迟时间，设置0为关闭。
                             在延迟时间内到达的客户端，会一起通过diskless方式同步数据，但是复制开始之后，master节点就不接受slave的复制请求，直到下一次同步开始才重新接受复制请求。




四、核心组件


（1）复制


（2）发布订阅


Redis发布订阅是一种消息通信模式，发送者（pub）发送信息，订阅者（sub）接受信息。


Redis客户端可以订阅任意数量的频道。


分布式缓存——Redis


例子：




一、创建订阅频道

[root@localhost ~]# redis-cli

127.0.0.1:6379> auth 123456

OK

127.0.0.1:6379> subscribe redisChat

Reading messages... (press Ctrl-C to quit)

1) "subscribe"

2) "redisChat"

3) (integer) 1

二、打开客户端，订阅频道

[root@localhost ~]# redis-cli -h 192.168.10.11 -p 6379 -a "123456"

192.168.10.11:6379> psubscribe redisChat

Reading messages... (press Ctrl-C to quit)

1) "psubscribe"

2) "redisChat"

3) (integer) 1

三、推送

127.0.0.1:6379> publish redisChat "hello"

(integer) 3

127.0.0.1:6379> publish redisChat "litter chu"

(integer) 3

四、结果

[root@localhost ~]# redis-cli -h 192.168.10.11 -p 6379 -a "123456"

192.168.10.11:6379> psubscribe redisChat

Reading messages... (press Ctrl-C to quit)

1) "psubscribe"

2) "redisChat"

3) (integer) 1

1) "pmessage"

2) "redisChat"

3) "redisChat"

4) "hello"

1) "pmessage"

2) "redisChat"

3) "redisChat"

4) "litter chu"




推送的原理：


当客户端向某个频道发送消息时，Redis首先在结构体redisServer中的pubsub_channels中找出键为该频道的结点，遍历该结点的值，找出所有的客户端，将消息发送给这些客户端。然后，遍历结构体Redis Client中的pubsub_patterns，找出包含该频道的模式的结点，将消息发送给订阅了该模式的客户端。


创建订阅频道的原理：


首先，在客户端结构体client中，有一个属性为pubsub_channels，该属性表明了该客户端订阅的所有频道，它是一个字典类型，通过哈希表实现，其中的每个元素都包含了一个键值对以及指向下一个元素的指针，每次订阅都要向其中插入一个结点，键表示订阅的频道，值为空。然后，在表示服务器端的结构体redisServer中，也有一个属性为pubsub_channels，但此处它表示的是该服务器端中的所有频道以及订阅了这个频道的客户端，它也是一个字典类型，插入结点时，键表示频道，值则是订阅了这个频道的所有客户端组成的链表。最后Redis通知客户端其订阅成功。


（3）事务


事务可以保证多个操作同时执行成功。




127.0.0.1:6379> MULTi  #标记事务开始

OK

127.0.0.1:6379> set name yang   #多条命令按照顺序入队

QUEUED

127.0.0.1:6379> set people 123

QUEUED

127.0.0.1:6379> set abc 678

QUEUED

127.0.0.1:6379> PING

QUEUED

127.0.0.1:6379> EXEC   #执行

1) OK

2) OK

3) OK

4) PONG

(0.71s)





在一个事务中，任何一个操作发生错误，所有操作都会回滚。




127.0.0.1:6379> Multi

OK

127.0.0.1:6379> set a 10

QUEUED

127.0.0.1:6379> INCR a

QUEUED

127.0.0.1:6379> INCR a 12

(error) ERR wrong number of arguments for 'incr' command

127.0.0.1:6379> EXEC

(error) EXECABORT Transaction discarded because of previous errors.

127.0.0.1:6379> get a

(nil)　　




五、主从复制


1、描述


Redis的复制功能是支持多个数据库之间的数据同步。一类的主数据库（master），另一种是从数据库（slave），主数据库可以进行读写操作，当发生写数据时自动将数据同步到从数据库；然而从数据库一般是只读的，并接收主数据库同步过来的数据。一个主数据库可以由多个从数据库；而一个从数据库只能有一个主数据库。


通过Redis的复制功能可以很好的实现数据库的读写分离，提高服务器的负载能力，主数据库主要进行写操作，从数据库负责读操作。


2、原理


Redis的主从同步支持全量同步和增量同步。第一次同步必为全量同步。


（1）全量同步


全量同步流程图：


分布式缓存——Redis


（2）增量同步


增量同步流程图：


分布式缓存——Redis


3、配置


方法一（该方法在任何一方重启之后就会不复存在）：


(1)主库操作


分布式缓存——Redis


（2）从库操作




[root@slave ~]# redis-cli -a "123456"

127.0.0.1:6379> INFO replication

# Replication

role:master   #依旧是master

connected_slaves:0

master_repl_offset:0

repl_backlog_active:0

repl_backlog_size:1048576

repl_backlog_first_byte_offset:0

repl_backlog_histlen:0

127.0.0.1:6379> set key1 v1-slave

OK

127.0.0.1:6379> get key1  #设置一个数据

"v1-slave"

127.0.0.1:6379> SLAVEOF 192.168.10.11 6379  #设置master服务器

OK

127.0.0.1:6379> CONFIG SET masterauth 123456  #设置master服务器的密码

OK

127.0.0.1:6379> INFO replication

# Replication

role:slave   #此时已是从服务器

master_host:192.168.10.11

master_port:6379

master_link_status:up   #且已启动

master_last_io_seconds_ago:10

master_sync_in_progress:0

slave_repl_offset:995

slave_priority:100

slave_read_only:1

connected_slaves:0

master_repl_offset:0

repl_backlog_active:0

repl_backlog_size:1048576

repl_backlog_first_byte_offset:0

repl_backlog_histlen:0

127.0.0.1:6379> get key1  #此时的相同数据显示的值是主服务器的值。

"v1-master"

127.0.0.1:6379>




方法二（永久保存）：


在slave的redis.conf中设置：


分布式缓存——Redis


（3）观察日志




#master的日志

[root@master ~]# tail /var/log/redis/redis.log

8115:M 14 Jan 00:03:10.387 * Background saving terminated with success

8115:M 14 Jan 00:03:10.387 * Synchronization with slave 192.168.10.12:6379 succeeded

8115:M 14 Jan 00:15:10.245 * Slave 192.168.10.10:6379 asks for synchronization

8115:M 14 Jan 00:15:10.246 * Full resync requested by slave 192.168.10.10:6379

8115:M 14 Jan 00:15:10.246 * Starting BGSAVE for SYNC with target: disk

8115:M 14 Jan 00:15:10.304 * Background saving started by pid 8283

8283:C 14 Jan 00:15:10.425 * DB saved on disk

8283:C 14 Jan 00:15:10.426 * RDB: 4 MB of memory used by copy-on-write

8115:M 14 Jan 00:15:10.469 * Background saving terminated with success

8115:M 14 Jan 00:15:10.470 * Synchronization with slave 192.168.10.10:6379 succeeded

#slave的日志

[root@slave ~]# tail /var/log/redis/redis.log

7257:S 14 Jan 00:15:10.187 * Connecting to MASTER 192.168.10.11:6379

7257:S 14 Jan 00:15:10.187 * MASTER <-> SLAVE sync started

7257:S 14 Jan 00:15:10.187 * Non blocking connect for SYNC fired the event.

7257:S 14 Jan 00:15:10.188 * Master replied to PING, replication can continue...

7257:S 14 Jan 00:15:10.189 * Partial resynchronization not possible (no cached master)

7257:S 14 Jan 00:15:10.254 * Full resync from master: 294e46b3ebccaf679b057d1c22fe2af3dd4ca4f3:981

7257:S 14 Jan 00:15:10.414 * MASTER <-> SLAVE sync: receiving 98 bytes from master

7257:S 14 Jan 00:15:10.414 * MASTER <-> SLAVE sync: Flushing old data

7257:S 14 Jan 00:15:10.414 * MASTER <-> SLAVE sync: Loading DB in memory

7257:S 14 Jan 00:15:10.415 * MASTER <-> SLAVE sync: Finished with success




六、哨兵模式


1、一个场景


一共有三台服务器，分别为192.168.10.10、192.168.10.11、192.168.10.12。在该场景中，192.168.10.10为主，其他两个机器为它的从。然后，192.168.10.10服务器宕掉了，将192.168.10.11提升为主，192.168.10.12指向新的主服务器。


分布式缓存——Redis                     分布式缓存——Redis


目前情况：


主服务器


分布式缓存——Redis


从服务器


分布式缓存——Redis               分布式缓存——Redis


修改过程：


①、停止192.168.10.10的redis服务。


②、192.168.10.11的操作　　　　　　　　　　　　　　　　　　　　　　　　　　　　③、192.168.10.12的操作


分布式缓存——Redis                                    分布式缓存——Redis


以上情况下，我们通过手动方式实现了一个故障的切换，但在日常使用中，我们没有办法在很短的时间内进行故障切换，可能会对业务造成损失。所以，需要一个方式自动进行切换，即哨兵模式。


2、哨兵模式


Sentinel进程适用于监控redis集群中Master主服务器工作的状态，在Master主服务器发生故障时，可以实现Master和Slave服务器的切换，保证系统的高可用。它被集成在Redis2.6+的版本中，稳定于2.8+之后的版本中。哨兵是一个分布式系统，可以在一个架构中运行多个哨兵进程。这些进程使用流言协议来接收关于Master主服务器是否下线的信息，并使用投票协议来决定是否执行自动故障迁移，以及选择哪个Slave作为新的Master。


（1）工作原理


每个哨兵进程会向其他哨兵、Master、Slave定时发送信息，以确定对方是否还“活”着。如果发现对方在指定配置时间（可配置）未给到回应，则认为对方已经下线，这个方法被称为”主观认为宕机“，简称SDOWN；当”哨兵群“中的多数哨兵（Sentinel）进程在对master主服务器做出SDOWN的判断，并且通过 SENTINEL is-master-down-by-addr命令互相交流之后，得出master server下线判断，这种办法叫做”客观宕机“，简称ODOWN。


通过一定的vote算法，从剩下的Slave服务器节点中，选一台提升未Master服务器节点，然后自动修改相关配置，并开启故障转移（failover）。Sentinel机制可以解决master和slave角色的自动切换问题。


（2）配置


初始设置：redis哨兵模式的前提是已经实现了一个master-slave的运行环境，从而实现一个一主两从基于哨兵的高可用redis架构。


分布式缓存——Redis      分布式缓存——Redis      分布式缓存——Redis


配置哨兵模式：




[root@master etc]# vim redis-sentinel.conf

port 26379

dir /tmp

sentinel monitor mymaster 192.168.10.10 6379 2

sentinel down-after-milliseconds mymaster 30000

sentinel parallel-syncs mymaster 1

sentinel failover-timeout mymaster 180000

logfile /var/log/redis/sentinel.log

配置完成后，将该文件复制到另两个服务器（slave）
[root@master etc]# scp /etc/redis-sentinel.conf root@192.168.10.11:/etc
[root@master etc]# scp /etc/redis-sentinel.conf root@192.168.10.12:/etc

复制完成后，分别在两台机器上启动哨兵进程
[root@master etc]# systemctl restart redis-sentinel.service
[root@slave1 etc]# systemctl restart redis-sentinel.service
[root@slave1 etc]# systemctl restart redis-sentinel.service

启动之后又，查看


[root@master etc]# ss -ntl
State       Recv-Q Send-Q                                        Local Address:Port                                                       Peer Address:Port              
LISTEN      0      128                                                       *:26379                                                                 *:*                  
LISTEN      0      128                                                       *:6379                                                                  *:*                  
LISTEN      0      128                                                       *:22                                                                    *:*                  
LISTEN      0      100                                               127.0.0.1:25                                                                    *:*                  
LISTEN      0      128                                                      :::26379                                                                :::*                  
LISTEN      0      128                                                      :::6379                                                                 :::*                  
LISTEN      0      128                                                      :::22                                                                   :::*                  
LISTEN      0      100                                                     ::1:25                                                                   :::*


[root@slave1 etc]# ps -ef | grep redis
redis      7845      1  0 12月29 ?      00:00:44 /usr/bin/redis-server *:6379
redis      7936      1  0 12月29 ?      00:00:45 /usr/bin/redis-sentinel *:26379 [sentinel]
root      17628   7677  4 00:13 pts/0    00:00:00 grep --color=auto redis


[root@slave2 etc]# ps -ef | grep redis
redis      7823      1  0 12月29 ?      00:00:44 /usr/bin/redis-server *:6379
redis      7902      1  0 12月29 ?      00:00:44 /usr/bin/redis-sentinel *:26379 [sentinel]
root      17594   7654  0 00:14 pts/0    00:00:00 grep --color=auto redis


至此配置完成！！




查看哨兵模式日志：




#查看哨兵日志：

[root@master etc]# tail -f /var/log/redis/sentinel.log   #master日志

          `-._        _.-'

              `-.__.-'                                               

7610:X 14 Jan 22:44:57.838 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.

7610:X 14 Jan 22:44:57.873 # Sentinel ID is 0e531e0dc2f12a696905287c5a66ca8c2fbc091a

7610:X 14 Jan 22:44:57.873 # +monitor master mymaster 192.168.10.10 6379 quorum 1

7610:X 14 Jan 22:44:57.884 * +slave slave 192.168.10.11:6379 192.168.10.11 6379 @ mymaster 192.168.10.10 6379

7610:X 14 Jan 22:44:57.923 * +slave slave 192.168.10.12:6379 192.168.10.12 6379 @ mymaster 192.168.10.10 6379

7610:X 14 Jan 22:44:58.291 * +sentinel sentinel ff71c9c1fe12b5d8a0f321982e25b71af1a06b9e 192.168.10.11 26379 @ mymaster 192.168.10.10 6379

7610:X 14 Jan 22:44:58.855 * +sentinel sentinel 03708ce901a87a120f69909a041c346a1340a655 192.168.10.12 26379 @ mymaster 192.168.10.10 6379

[root@slave1 etc]# tail -f /var/log/redis/sentinel.log   #slave1的日志

          `-._        _.-'

              `-.__.-'                                               

7936:X 29 Dec 21:51:18.081 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.

7936:X 29 Dec 21:51:18.205 # Sentinel ID is ff71c9c1fe12b5d8a0f321982e25b71af1a06b9e

7936:X 29 Dec 21:51:18.205 # +monitor master mymaster 192.168.10.10 6379 quorum 1

7936:X 29 Dec 21:51:18.234 * +slave slave 192.168.10.11:6379 192.168.10.11 6379 @ mymaster 192.168.10.10 6379

7936:X 29 Dec 21:51:18.235 * +slave slave 192.168.10.12:6379 192.168.10.12 6379 @ mymaster 192.168.10.10 6379

7936:X 29 Dec 21:51:18.405 * +sentinel sentinel 03708ce901a87a120f69909a041c346a1340a655 192.168.10.12 26379 @ mymaster 192.168.10.10 6379

7936:X 29 Dec 21:51:23.263 * +sentinel sentinel 0e531e0dc2f12a696905287c5a66ca8c2fbc091a 192.168.10.10 26379 @ mymaster 192.168.10.10 6379

[root@slave2 etc]# tail -f /var/log/redis/sentinel.log   #slave2的日志

          `-._        _.-'

              `-.__.-'                                               

7902:X 29 Dec 21:51:56.490 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.

7902:X 29 Dec 21:51:56.530 # Sentinel ID is 03708ce901a87a120f69909a041c346a1340a655

7902:X 29 Dec 21:51:56.530 # +monitor master mymaster 192.168.10.10 6379 quorum 1

7902:X 29 Dec 21:51:56.724 * +slave slave 192.168.10.11:6379 192.168.10.11 6379 @ mymaster 192.168.10.10 6379

7902:X 29 Dec 21:51:56.765 * +slave slave 192.168.10.12:6379 192.168.10.12 6379 @ mymaster 192.168.10.10 6379

7902:X 29 Dec 21:52:10.070 * +sentinel sentinel ff71c9c1fe12b5d8a0f321982e25b71af1a06b9e 192.168.10.11 26379 @ mymaster 192.168.10.10 6379

7902:X 29 Dec 21:52:13.898 * +sentinel sentinel 0e531e0dc2f12a696905287c5a66ca8c2fbc091a 192.168.10.10 26379 @ mymaster 192.168.10.10 6379




验证哨兵模式：




#关闭master的redis服务

[root@master etc]# systemctl stop redis

#查看slave1

[root@slave1 etc]# grep -vE "^$|^#" /etc/redis-sentinel.conf

protected-mode no

port 26379

dir "/tmp"

sentinel myid ff71c9c1fe12b5d8a0f321982e25b71af1a06b9e

sentinel monitor mymaster 192.168.10.11 6379 1

sentinel config-epoch mymaster 2

sentinel leader-epoch mymaster 2

logfile "/var/log/redis/sentinel.log"

supervised systemd

sentinel known-slave mymaster 192.168.10.10 6379

sentinel known-slave mymaster 192.168.10.12 6379

sentinel known-sentinel mymaster 192.168.10.12 26379 03708ce901a87a120f69909a041c346a1340a655

sentinel known-sentinel mymaster 192.168.10.10 26379 0e531e0dc2f12a696905287c5a66ca8c2fbc091a

sentinel current-epoch 2

#查看slave2

[root@slave2 etc]# grep -vE "^$|^#" /etc/redis-sentinel.conf

protected-mode no

port 26379

dir "/tmp"

sentinel myid 03708ce901a87a120f69909a041c346a1340a655

sentinel monitor mymaster 192.168.10.11 6379 1

sentinel config-epoch mymaster 2

sentinel leader-epoch mymaster 2

logfile "/var/log/redis/sentinel.log"

supervised systemd

sentinel known-slave mymaster 192.168.10.12 6379

sentinel known-slave mymaster 192.168.10.10 6379

sentinel known-sentinel mymaster 192.168.10.11 26379 ff71c9c1fe12b5d8a0f321982e25b71af1a06b9e

sentinel known-sentinel mymaster 192.168.10.10 26379 0e531e0dc2f12a696905287c5a66ca8c2fbc091a

sentinel current-epoch 2

哨兵模式配置成功！！




哨兵模式解决了redis的高可用问题，即当master故障后可以自动将slave提升为master，从而可以本宗衡redis服务的正常使用，但是无法解决redis的单机写入瓶颈问题，即单机redis写入性能受限于单机的内存大小、并发数量、网卡速率等因素。


七，集群


Redis3.0+的版本支持集群功能。用来解决master的写瓶颈等。


Redis集群是一个提供在多个Redis间节点的共享数据。它通过分区share来提供一定程度的可用性，在实际环境中当某个节点宕机或者不可达的情况下继续处理命令。


优势：自动分割数据到不同的节点上。整个集群的部分节点失败或者不可达的情况下能够继续处理命令。


特点：①、所有Redis节点使用（PING机制）互联。


②、集群中某个节点是否失效，是由整个集群中超过半数的节点监测都失效，才能算真正的失效。


③、客户端不需要proxy即可直接连接redis，应用程序需要写全部的redis服务器IP


④、redis集群把所有的redis node平均映射到0-16383个槽位上，读写需要到指定的redis node上进行操作，因此有多少个redis node相当于redis并发扩展了多少倍，每个redis node承担16284/N个槽位。


⑤、Redis集群预先分配16384个槽位，当需要在redis集群总写入一个key-value的时候，会使用CRC16（key） mod16384之后的值，决定将key写入值哪一个槽位而绝当写入哪个Redis节点上，从而解决单机瓶颈。


（1）Redis集群的数据分片


redis使用哈希槽，每个key通过CRC16校验后对16384去模来决定放置那个槽位，集群的每一个节点来负责一部分槽位。


例如当前集群有三个节点。


节点A：包含0-5500号hash槽。


节点B：包含5501-11000号hash槽。


节点A：包含11001-16384号hash槽。


数据到底放置在哪个槽上，数据hash运算除以16384取余。


（2）集群的主存服复制模型


redis并不能保证数据的强一致性，这意味着在实际中集群在特定条件下操作可能会对视一些数据，集群使用了异步复制的写操作过程。


（3）集群搭建


1、环境准备




三台机器，分别开启两个redis服务


192.168.10.10        端口：6379，6380


192.168.10.11        端口：6379，6380


192.168.10.12        端口：6379，6380




修改配置文件，配置文件如下（其他两个服务器的配置相同）：




#一些默认操作

[root@localhost ~]# mkdir /data/redis/6380

[root@localhost ~]# cp /data/redis/conf/redis.conf /data/redis/6380/redis6380.conf

#配置文件的操作

[root@localhost ~]# grep -vE "^$|^#" /data/redis/conf/redis.conf

protected-mode no

port 6379

tcp-backlog 511

timeout 0

tcp-keepalive 300

daemonize no

supervised no

pidfile /var/run/redis_6379.pid

loglevel notice

logfile "/data/redis/conf/redis.log"

databases 16

always-show-logo yes

save 900 1

save 300 10

save 60 10000

stop-writes-on-bgsave-error yes

rdbcompression yes

rdbchecksum yes

dbfilename dump.rdb

dir ./

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

lazyfree-lazy-eviction no

lazyfree-lazy-expire no

lazyfree-lazy-server-del no

slave-lazy-flush no

appendonly yes

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

aof-use-rdb-preamble no

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

cluster-enabled yes

cluster-config-file nodes-6379.conf

[root@localhost ~]# grep -vE "^$|^#" /data/redis/6380/redis6380.conf

protected-mode no

port 6380

tcp-backlog 511

timeout 0

tcp-keepalive 300

daemonize no

supervised no

pidfile /var/run/redis_6380.pid

loglevel notice

logfile "/data/redis/6380/redis6380.log"

databases 16

always-show-logo yes

save 900 1

save 300 10

save 60 10000

stop-writes-on-bgsave-error yes

rdbcompression yes

rdbchecksum yes

dbfilename dump.rdb

dir ./

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

lazyfree-lazy-eviction no

lazyfree-lazy-expire no

lazyfree-lazy-server-del no

slave-lazy-flush no

appendonly yes

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

aof-use-rdb-preamble no

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

cluster-enabled yes

cluster-config-file nodes-6380.conf




启动redis服务.




[root@localhost ~]# redis-server /data/redis/conf/redis.conf

[root@localhost ~]# redis-server /data/redis/6380/redis6380.conf

[root@localhost ~]# tail -f /data/redis/conf/redis.log==> /usr/local/redis/cluster/redis_7001.log <==

  `-._    `-._`-.__.-'_.-'    _.-'

      `-._    `-.__.-'    _.-'

          `-._        _.-'

              `-.__.-'                                               

17449:M 19 Jan 14:21:39.532 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.

17449:M 19 Jan 14:21:39.532 # Server started, Redis version 3.2.12

17449:M 19 Jan 14:21:39.532 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.

17449:M 19 Jan 14:21:39.548 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.

17449:M 19 Jan 14:21:39.549 * The server is now ready to accept connections on port 7001

[root@localhost ~]# tail -f  /data/redis/6380/redis6380.log

  `-._    `-._`-.__.-'_.-'    _.-'

      `-._    `-.__.-'    _.-'

          `-._        _.-'

              `-.__.-'                                               

17453:M 19 Jan 14:21:42.850 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.

17453:M 19 Jan 14:21:42.850 # Server started, Redis version 3.2.12

17453:M 19 Jan 14:21:42.850 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.

17453:M 19 Jan 14:21:42.851 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.

17453:M 19 Jan 14:21:42.851 * The server is now ready to accept connections on port 7002




集群管理工具安装（redis5以下的版本）


低版本（redis4和redis3版本）：需要安装集群管理工具redis-trib.rb。




[root@localhost ~]# find / -name redis-trib.rb

/opt/redis-4.0.9/src/redis-trib.rb

[root@localhost ~]# cp /opt/redis-4.0.9/src/redis-trib.rb /usr/bin/

[root@localhost ~]# redis-trib.rb   (缺少ruby环境)

/usr/bin/env: ruby: 没有那个文件或目录

问题解决：

[root@localhost ~]# yum install gcc openssl-devel zlib-devel -y

[root@localhost ~]# wget https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.9.tar.gz

[root@localhost ~]# tar xf ruby-2.5.9.tar.gz

[root@localhost ~]# cd ruby-2.5.9

[root@localhost ruby-2.5.9]# ./configure

[root@localhost ruby-2.5.9]# make -j 2

[root@localhost ruby-2.5.9]# make install

[root@localhost ruby-2.5.9]# ruby -v

ruby 2.5.9p229 (2021-04-05 revision 67939) [x86_64-linux]

[root@localhost ruby-2.5.9]# gem install redis

Fetching: redis-4.5.1.gem (100%)

Successfully installed redis-4.5.1

Parsing documentation for redis-4.5.1

Installing ri documentation for redis-4.5.1

Done installing documentation for redis after 46 seconds

1 gem installed

成功

[root@localhost ruby-2.5.9]# redis-trib.rb

Usage: redis-trib <command> <options> <arguments ...>

  create          host1:port1 ... hostN:portN

                  --replicas <arg>

  check           host:port

  info            host:port

  fix             host:port

                  --timeout <arg>

  reshard         host:port

                  --from <arg>

                  --to <arg>

                  --slots <arg>

                  --yes

                  --timeout <arg>

                  --pipeline <arg>

  rebalance       host:port

                  --weight <arg>

                  --auto-weights

                  --use-empty-masters

                  --timeout <arg>

                  --simulate

                  --pipeline <arg>

                  --threshold <arg>

  add-node        new_host:new_port existing_host:existing_port

                  --slave

                  --master-id <arg>

  del-node        host:port node_id

  set-timeout     host:port milliseconds

  call            host:port command arg arg .. arg

  import          host:port

                  --from <arg>

                  --copy

                  --replace

  help            (show this help)

For check, fix, reshard, del-node, set-timeout you can specify the host and port of any working node in the cluster.

[root@localhost ruby-2.5.9]# 　




修改redis的登录密码




[root@localhost ~]# find / -name client.rb

/root/ruby-2.5.9/gems/xmlrpc-0.3.0/lib/xmlrpc/client.rb

/usr/local/lib/ruby/gems/2.5.0/gems/xmlrpc-0.3.0/lib/xmlrpc/client.rb

/usr/local/lib/ruby/gems/2.5.0/gems/redis-4.5.1/lib/redis/client.rb

[root@localhost ~]# vim /root/ruby-2.5.9/gems/xmlrpc-0.3.0/lib/xmlrpc/client.rb

def initialize(host=nil, path=nil, port=nil, proxy_host=nil, proxy_port=nil,

                   user=nil, use_ssl=nil, timeout=nil)#删除其中的password




确保三台服务器的六个redis都在运行




[root@localhost ~]# netstat -nltp | grep redis

tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      7289/redis-server *

tcp        0      0 0.0.0.0:6380            0.0.0.0:*               LISTEN      7293/redis-server *

tcp        0      0 0.0.0.0:16379           0.0.0.0:*               LISTEN      7289/redis-server *

tcp        0      0 0.0.0.0:16380           0.0.0.0:*               LISTEN      7293/redis-server *

tcp6       0      0 :::6379                 :::*                    LISTEN      7289/redis-server *

tcp6       0      0 :::6380                 :::*                    LISTEN      7293/redis-server *

tcp6       0      0 :::16379                :::*                    LISTEN      7289/redis-server *

tcp6       0      0 :::16380                :::*                    LISTEN      7293/redis-server * 　




2、创建集群


redis4以及以下版本




[root@localhost ~]# redis-trib.rb create --replicas 1 192.168.10.10:6379 192.168.10.10:6380 192.168.10.11:6379 192.168.10.11:6380 192.168.10.12:6379 192.168.10.12:6380

>>> Creating cluster

>>> Performing hash slots allocation on 6 nodes...

Using 3 masters:

192.168.10.10:6379

192.168.10.11:6379

192.168.10.12:6379

Adding replica 192.168.10.11:6380 to 192.168.10.10:6379

Adding replica 192.168.10.12:6380 to 192.168.10.11:6379

Adding replica 192.168.10.10:6380 to 192.168.10.12:6379

M: 7bcdba4859d10eae99e17d7d93efc7973af0d50c 192.168.10.10:6379

   slots:0-5460 (5461 slots) master

S: 46dafd34daaa3f9c4092217098c0791331db96da 192.168.10.10:6380

   replicates 7756a52a33dd9e99b19109bf4eaa461c8d079936

M: 4e468829617e1e62e764b3ab3e477ba5f99bdf16 192.168.10.11:6379

   slots:5461-10922 (5462 slots) master

S: 39c3771e87184b5f27a596c23abc882dfa2bc02a 192.168.10.11:6380

   replicates 7bcdba4859d10eae99e17d7d93efc7973af0d50c

M: 7756a52a33dd9e99b19109bf4eaa461c8d079936 192.168.10.12:6379

   slots:10923-16383 (5461 slots) master

S: 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f 192.168.10.12:6380

   replicates 4e468829617e1e62e764b3ab3e477ba5f99bdf16

Can I set the above configuration? (type 'yes' to accept): 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.10.10:6379)

M: 7bcdba4859d10eae99e17d7d93efc7973af0d50c 192.168.10.10:6379

   slots:0-5460 (5461 slots) master

   1 additional replica(s)

M: 7756a52a33dd9e99b19109bf4eaa461c8d079936 192.168.10.12:6379

   slots:10923-16383 (5461 slots) master

   1 additional replica(s)

M: 4e468829617e1e62e764b3ab3e477ba5f99bdf16 192.168.10.11:6379

   slots:5461-10922 (5462 slots) master

   1 additional replica(s)

S: 39c3771e87184b5f27a596c23abc882dfa2bc02a 192.168.10.11:6380

   slots: (0 slots) slave

   replicates 7bcdba4859d10eae99e17d7d93efc7973af0d50c

S: 46dafd34daaa3f9c4092217098c0791331db96da 192.168.10.10:6380

   slots: (0 slots) slave

   replicates 7756a52a33dd9e99b19109bf4eaa461c8d079936

S: 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f 192.168.10.12:6380

   slots: (0 slots) slave

   replicates 4e468829617e1e62e764b3ab3e477ba5f99bdf16

[OK] All nodes agree about slots configuration.

>>> Check for open slots...

>>> Check slots coverage...

[OK] All 16384 slots covered.c




redis5及以上版本




redis-cli (-a 123456#如果有密码的话) --cluster create 192.168.10.10:6379 192.168.10.10:6380 192.168.10.11:6379 192.168.10.11:6380 192.168.10.12:6379 192.168.10.12:6380 --cluster-replicas 1




查看集群对应关系




[root@localhost ~]# cat /root/nodes-6379.conf

7756a52a33dd9e99b19109bf4eaa461c8d079936 192.168.10.12:6379@16379 master - 0 1643073510000 5 connected 10923-16383

4e468829617e1e62e764b3ab3e477ba5f99bdf16 192.168.10.11:6379@16379 master - 0 1643073510551 3 connected 5461-10922

39c3771e87184b5f27a596c23abc882dfa2bc02a 192.168.10.11:6380@16380 slave 7bcdba4859d10eae99e17d7d93efc7973af0d50c 0 1643073511566 4 connected

46dafd34daaa3f9c4092217098c0791331db96da 192.168.10.10:6380@16380 slave 7756a52a33dd9e99b19109bf4eaa461c8d079936 0 1643073511000 5 connected

3d0acde0db99b58ec0d1cfa0dfb5444a3056634f 192.168.10.12:6380@16380 slave 4e468829617e1e62e764b3ab3e477ba5f99bdf16 0 1643073509000 6 connected

7bcdba4859d10eae99e17d7d93efc7973af0d50c 192.168.10.10:6379@16379 myself,master - 0 1643073512000 1 connected 0-5460

vars currentEpoch 6 lastVoteEpoch 0




查看状态




[root@localhost ~]# redis-trib.rb info 192.168.10.10:6379

192.168.10.10:6379 (7bcdba48...) -> 0 keys | 5461 slots | 1 slaves.

192.168.10.12:6379 (7756a52a...) -> 0 keys | 5461 slots | 1 slaves.

192.168.10.11:6379 (4e468829...) -> 0 keys | 5462 slots | 1 slaves.

[OK] 0 keys in 3 masters.

0.00 keys per slot on average.

[root@localhost ~]# redis-trib.rb check 192.168.10.10:6379

>>> Performing Cluster Check (using node 192.168.10.10:6379)

M: 7bcdba4859d10eae99e17d7d93efc7973af0d50c 192.168.10.10:6379

   slots:0-5460 (5461 slots) master

   1 additional replica(s)

M: 7756a52a33dd9e99b19109bf4eaa461c8d079936 192.168.10.12:6379

   slots:10923-16383 (5461 slots) master

   1 additional replica(s)

M: 4e468829617e1e62e764b3ab3e477ba5f99bdf16 192.168.10.11:6379

   slots:5461-10922 (5462 slots) master

   1 additional replica(s)

S: 39c3771e87184b5f27a596c23abc882dfa2bc02a 192.168.10.11:6380

   slots: (0 slots) slave

   replicates 7bcdba4859d10eae99e17d7d93efc7973af0d50c

S: 46dafd34daaa3f9c4092217098c0791331db96da 192.168.10.10:6380

   slots: (0 slots) slave

   replicates 7756a52a33dd9e99b19109bf4eaa461c8d079936

S: 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f 192.168.10.12:6380

   slots: (0 slots) slave

   replicates 4e468829617e1e62e764b3ab3e477ba5f99bdf16

[OK] All nodes agree about slots configuration.

>>> Check for open slots...

>>> Check slots coverage...

[OK] All 16384 slots covered.

[root@localhost ~]#

[root@localhost ~]# redis-cli

127.0.0.1:6379> CLUSTER INFO

cluster_state:ok

cluster_slots_assigned:16384

cluster_slots_ok:16384

cluster_slots_pfail:0

cluster_slots_fail:0

cluster_known_nodes:6

cluster_size:3

cluster_current_epoch:6

cluster_my_epoch:1

cluster_stats_messages_ping_sent:3243

cluster_stats_messages_pong_sent:3060

cluster_stats_messages_sent:6303

cluster_stats_messages_ping_received:3055

cluster_stats_messages_pong_received:3243

cluster_stats_messages_meet_received:5

cluster_stats_messages_received:6303

127.0.0.1:6379>




模拟master故障，对应的slave节点自动提升为新master




[root@localhost ~]# redis-cli -h 192.168.10.11 -p 6379

192.168.10.11:6379> shutdown

not connected> exit

[1]-  完成                  redis-server /data/redis/conf/redis.conf

[root@localhost ~]# redis-trib.rb check 192.168.10.10:6379

>>> Performing Cluster Check (using node 192.168.10.10:6379)

M: 7bcdba4859d10eae99e17d7d93efc7973af0d50c 192.168.10.10:6379

   slots:0-5460 (5461 slots) master

   1 additional replica(s)

M: 7756a52a33dd9e99b19109bf4eaa461c8d079936 192.168.10.12:6379

   slots:10923-16383 (5461 slots) master

   1 additional replica(s)

S: 39c3771e87184b5f27a596c23abc882dfa2bc02a 192.168.10.11:6380

   slots: (0 slots) slave

   replicates 7bcdba4859d10eae99e17d7d93efc7973af0d50c

S: 46dafd34daaa3f9c4092217098c0791331db96da 192.168.10.10:6380

   slots: (0 slots) slave

   replicates 7756a52a33dd9e99b19109bf4eaa461c8d079936

M: 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f 192.168.10.12:6380

   slots:5461-10922 (5462 slots) master

   0 additional replica(s)

[OK] All nodes agree about slots configuration.

>>> Check for open slots...

>>> Check slots coverage...

[OK] All 16384 slots covered.





故障恢复后，该节点加入集群成为新的slave




[root@localhost ~]# redis-server /data/redis/conf/redis.conf &

[3] 7425

root@localhost ~]# redis-trib.rb check 192.168.10.10:6379

>>> Performing Cluster Check (using node 192.168.10.10:6379)

M: 7bcdba4859d10eae99e17d7d93efc7973af0d50c 192.168.10.10:6379

   slots:0-5460 (5461 slots) master

   1 additional replica(s)

M: 7756a52a33dd9e99b19109bf4eaa461c8d079936 192.168.10.12:6379

   slots:10923-16383 (5461 slots) master

   1 additional replica(s)

S: 4e468829617e1e62e764b3ab3e477ba5f99bdf16 192.168.10.11:6379

   slots: (0 slots) slave

   replicates 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f

S: 39c3771e87184b5f27a596c23abc882dfa2bc02a 192.168.10.11:6380

   slots: (0 slots) slave

   replicates 7bcdba4859d10eae99e17d7d93efc7973af0d50c

S: 46dafd34daaa3f9c4092217098c0791331db96da 192.168.10.10:6380

   slots: (0 slots) slave

   replicates 7756a52a33dd9e99b19109bf4eaa461c8d079936

M: 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f 192.168.10.12:6380

   slots:5461-10922 (5462 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.





（4）集群维护


1、添加节点到集群　


因为各种各样的业务增长，目前的架构可能会导致无法满足现有业务的并发，加入新的服务器，并将他们添加进集群中。


添加节点，需要与之前的redis node版本相同，配置相同，再分别启动，且为一主一从。


添加节点到集群




add-node new_host:new_port  existing_host:existing_port

说明：

new_host:new_port   #新添加的主机IP和端口

existing_host:existing_port   #已经存在于集群中任意节点的IP和端口。

redis4添加：

[root@localhost ~]# redis-trib.rb add-node 119.3.46.177:6379 192.168.10.10:6379

>>> Adding node 119.3.46.177:6379 to cluster 192.168.10.10:6379

>>> Performing Cluster Check (using node 192.168.10.10:6379)

M: 7bcdba4859d10eae99e17d7d93efc7973af0d50c 192.168.10.10:6379

   slots:0-5460 (5461 slots) master

   1 additional replica(s)

M: 7756a52a33dd9e99b19109bf4eaa461c8d079936 192.168.10.12:6379

   slots:10923-16383 (5461 slots) master

   1 additional replica(s)

S: 4e468829617e1e62e764b3ab3e477ba5f99bdf16 192.168.10.11:6379

   slots: (0 slots) slave

   replicates 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f

S: 39c3771e87184b5f27a596c23abc882dfa2bc02a 192.168.10.11:6380

   slots: (0 slots) slave

   replicates 7bcdba4859d10eae99e17d7d93efc7973af0d50c

S: 46dafd34daaa3f9c4092217098c0791331db96da 192.168.10.10:6380

   slots: (0 slots) slave

   replicates 7756a52a33dd9e99b19109bf4eaa461c8d079936

M: 3d0acde0db99b58ec0d1cfa0dfb5444a3056634f 192.168.10.12:6380

   slots:5461-10922 (5462 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.

>>> Send CLUSTER MEET to node 119.3.46.177:6379 to make it join the cluster.

[OK] New node added correctly.

redis5添加：

[root@localhost ~]# redis-cli --cluster add-node 119.3.46.177:6379 192.168.10.10:6379 -a 密码
#添加时至少添加两个节点（一主一从）




添加两个服务器时一主一从设置




方法一：在新加节点到集群时，直接将他设置为主从模式

例：

redis-cli -a 123456 --cluster add-node 192.168.10.13:7001 192.168.10.10:7001  #添加master节点

redis-cli -a 123456 --cluster add-node 192.168.10.13:7002 192.168.10.10:7001 --cluster-slave --cluster-master-id 086082f1e218640593aa9776c80845cf84c97a06 

方法二：先将新节点加入集群，再修改为slave

redis-cli -a 123456 --cluster add-node 192.168.10.13:7001 192.168.10.10:7001  #添加节点进入集群

手动修改

redis-cli -a 123456 -h 192.168.10.10 -p 7001

192.168.10.10:7001> CLUSTER NODES #查找master的ID

192.168.10.10:7001> CLUSTER REPLICATE master的ID  #设置为slave

192.168.10.10:7001> CLUSTER NODES




添加成功后重新分配槽位




[root@localhost ~]# redis-cli -a 123456 --cluster reshared 192.168.10.10:7001  (ip+port可为集群中任意节点)

出现第一个需要输入：输入数为（16384除以master的个数）

出现第二个需要输入：输入数为（新添加的节点的master节点的id）

出现第三个需要输入：输入数为 （all:表示将哪些源主机的槽位分配给新的节点）

出现第四个需要输入：表示确认分配

分配后查看：

[root@localhost ~]# redis-cli -a 123456 --cluster check 192.168.10.10:7001

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

192.168.10.10:7001 (2ca33c82...) -> 0 keys | 4096 slots | 1 slaves.

192.168.10.13:7001 (fd9d61eb...) -> 0 keys | 4096 slots | 1 slaves.

192.168.10.12:7001 (fce781a3...) -> 0 keys | 4096 slots | 1 slaves.

192.168.10.11:7001 (be7b9fef...) -> 0 keys | 4096 slots | 1 slaves.

[OK] 0 keys in 4 masters.

0.00 keys per slot on average.

>>> Performing Cluster Check (using node 192.168.10.10:7001)

M: 2ca33c822373a073cfe06f3bd65e832ff551a052 192.168.10.10:7001

   slots:[1365-5460] (4096 slots) master

   1 additional replica(s)

S: a901767a5f6bd51a13ee2b822f64ce4bbe1f435e 192.168.10.11:7002

   slots: (0 slots) slave

   replicates 2ca33c822373a073cfe06f3bd65e832ff551a052

S: aa84800441affebc4c10a3f43a6c8dcaa2548317 192.168.10.13:7002

   slots: (0 slots) slave

   replicates fd9d61eb447dc196b8c27e36a7976530ca5e02bc

S: 39cb8b3aca80388373252eb36598f9a58acf4175 192.168.10.10:7002

   slots: (0 slots) slave

   replicates fce781a33203003acaa8e4d6f2d4831f3c5a1eb7

S: 690ff3113371d470101c16046371de2a0bb87bcd 192.168.10.12:7002

   slots: (0 slots) slave

   replicates be7b9fefd8d78c8f310acc403d871866d5101074

M: fd9d61eb447dc196b8c27e36a7976530ca5e02bc 192.168.10.13:7001

   slots:[0-1364],[5461-6826],[10923-12287] (4096 slots) master

   1 additional replica(s)

M: fce781a33203003acaa8e4d6f2d4831f3c5a1eb7 192.168.10.12:7001

   slots:[12288-16383] (4096 slots) master

   1 additional replica(s)

M: be7b9fefd8d78c8f310acc403d871866d5101074 192.168.10.11:7001

   slots:[6827-10922] (4096 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.





2、减少节点　


可能会因为一些服务器老旧的问题，造成需要将某个节点移出集群。




删除节点的过程：


删除节点的操作与添加操作顺序相反，是先将被删除的redis上的槽位迁移到集群中的其他redis节点上，然后再将其删除。 且被删除的服务器必须保证没有数据。




过程：


迁移槽位




#查看目前状态

[root@localhost ~]# redis-cli -a 123456 --cluster check 192.168.10.10:7001

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

192.168.10.10:7001 (2ca33c82...) -> 0 keys | 4096 slots | 1 slaves.

192.168.10.13:7001 (fd9d61eb...) -> 0 keys | 4096 slots | 1 slaves.

192.168.10.12:7001 (fce781a3...) -> 0 keys | 4096 slots | 1 slaves.

192.168.10.11:7001 (be7b9fef...) -> 0 keys | 4096 slots | 1 slaves.

[OK] 0 keys in 4 masters.

0.00 keys per slot on average.

>>> Performing Cluster Check (using node 192.168.10.10:7001)

M: 2ca33c822373a073cfe06f3bd65e832ff551a052 192.168.10.10:7001

   slots:[1365-5460] (4096 slots) master

   1 additional replica(s)

S: a901767a5f6bd51a13ee2b822f64ce4bbe1f435e 192.168.10.11:7002

   slots: (0 slots) slave

   replicates 2ca33c822373a073cfe06f3bd65e832ff551a052

S: aa84800441affebc4c10a3f43a6c8dcaa2548317 192.168.10.13:7002

   slots: (0 slots) slave

   replicates fd9d61eb447dc196b8c27e36a7976530ca5e02bc

S: 39cb8b3aca80388373252eb36598f9a58acf4175 192.168.10.10:7002

   slots: (0 slots) slave

   replicates fce781a33203003acaa8e4d6f2d4831f3c5a1eb7

S: 690ff3113371d470101c16046371de2a0bb87bcd 192.168.10.12:7002

   slots: (0 slots) slave

   replicates be7b9fefd8d78c8f310acc403d871866d5101074

M: fd9d61eb447dc196b8c27e36a7976530ca5e02bc 192.168.10.13:7001

   slots:[0-1364],[5461-6826],[10923-12287] (4096 slots) master

   1 additional replica(s)

M: fce781a33203003acaa8e4d6f2d4831f3c5a1eb7 192.168.10.12:7001

   slots:[12288-16383] (4096 slots) master

   1 additional replica(s)

M: be7b9fefd8d78c8f310acc403d871866d5101074 192.168.10.11:7001

   slots:[6827-10922] (4096 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.

#连接到集群，并将192.168.10.13上的槽位移动到其他master节点上

[root@localhost ~]# redis-cli -a 123456 --cluster reshard 192.168.10.10:7001 --cluster-slots 10（将要删除的节点上的槽位平均分配给其他master节点） --cluster-from fd9d61eb447dc196b8c27e36a7976530ca5e02bc（要删除的节点） --cluster-to 2ca33c822373a073cfe06f3bd65e832ff551a052（承接槽位的节点） --cluster-yes

#结果

[root@localhost ~]# redis-cli -a 123456 --cluster check 192.168.10.10:7001

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

192.168.10.10:7001 (2ca33c82...) -> 0 keys | 5462 slots | 2 slaves.

192.168.10.13:7001 (fd9d61eb...) -> 0 keys | 0 slots | 0 slaves.

192.168.10.12:7001 (fce781a3...) -> 0 keys | 5461 slots | 1 slaves.

192.168.10.11:7001 (be7b9fef...) -> 0 keys | 5461 slots | 1 slaves.

[OK] 0 keys in 4 masters.

0.00 keys per slot on average.

>>> Performing Cluster Check (using node 192.168.10.10:7001)

M: 2ca33c822373a073cfe06f3bd65e832ff551a052 192.168.10.10:7001

   slots:[0-1355],[1365-5460],[12278-12287] (5462 slots) master

   2 additional replica(s)

S: a901767a5f6bd51a13ee2b822f64ce4bbe1f435e 192.168.10.11:7002

   slots: (0 slots) slave

   replicates 2ca33c822373a073cfe06f3bd65e832ff551a052

S: aa84800441affebc4c10a3f43a6c8dcaa2548317 192.168.10.13:7002

   slots: (0 slots) slave

   replicates 2ca33c822373a073cfe06f3bd65e832ff551a052

S: 39cb8b3aca80388373252eb36598f9a58acf4175 192.168.10.10:7002

   slots: (0 slots) slave

   replicates fce781a33203003acaa8e4d6f2d4831f3c5a1eb7

S: 690ff3113371d470101c16046371de2a0bb87bcd 192.168.10.12:7002

   slots: (0 slots) slave

   replicates be7b9fefd8d78c8f310acc403d871866d5101074

M: fd9d61eb447dc196b8c27e36a7976530ca5e02bc 192.168.10.13:7001

   slots: (0 slots) master

M: fce781a33203003acaa8e4d6f2d4831f3c5a1eb7 192.168.10.12:7001

   slots:[1356-1364],[5461-6816],[12288-16383] (5461 slots) master

   1 additional replica(s)

M: be7b9fefd8d78c8f310acc403d871866d5101074 192.168.10.11:7001

   slots:[6817-12277] (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.




删除服务器：




[root@localhost ~]# redis-cli -a 123456 --cluster del-node 192.168.10.13:7001 fd9d61eb447dc196b8c27e36a7976530ca5e02bc

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

>>> Removing node fd9d61eb447dc196b8c27e36a7976530ca5e02bc from cluster 192.168.10.13:7001

>>> Sending CLUSTER FORGET messages to the cluster...

>>> SHUTDOWN the node.




删除成功：




[root@localhost ~]# redis-cli -a 123456 --cluster check 192.168.10.10:7001

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

192.168.10.10:7001 (2ca33c82...) -> 0 keys | 5462 slots | 2 slaves.

192.168.10.12:7001 (fce781a3...) -> 0 keys | 5461 slots | 1 slaves.

192.168.10.11:7001 (be7b9fef...) -> 0 keys | 5461 slots | 1 slaves.

[OK] 0 keys in 3 masters.

0.00 keys per slot on average.

>>> Performing Cluster Check (using node 192.168.10.10:7001)

M: 2ca33c822373a073cfe06f3bd65e832ff551a052 192.168.10.10:7001

   slots:[0-1355],[1365-5460],[12278-12287] (5462 slots) master

   2 additional replica(s)

S: a901767a5f6bd51a13ee2b822f64ce4bbe1f435e 192.168.10.11:7002

   slots: (0 slots) slave

   replicates 2ca33c822373a073cfe06f3bd65e832ff551a052

S: aa84800441affebc4c10a3f43a6c8dcaa2548317 192.168.10.13:7002

   slots: (0 slots) slave

   replicates 2ca33c822373a073cfe06f3bd65e832ff551a052

S: 39cb8b3aca80388373252eb36598f9a58acf4175 192.168.10.10:7002

   slots: (0 slots) slave

   replicates fce781a33203003acaa8e4d6f2d4831f3c5a1eb7

S: 690ff3113371d470101c16046371de2a0bb87bcd 192.168.10.12:7002

   slots: (0 slots) slave

   replicates be7b9fefd8d78c8f310acc403d871866d5101074

M: fce781a33203003acaa8e4d6f2d4831f3c5a1eb7 192.168.10.12:7001

   slots:[1356-1364],[5461-6816],[12288-16383] (5461 slots) master

   1 additional replica(s)

M: be7b9fefd8d78c8f310acc403d871866d5101074 192.168.10.11:7001

   slots:[6817-12277] (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.




删除多余的从节点




[root@localhost ~]# redis-cli -a 123456 --cluster del-node 192.168.10.13:7002 aa84800441affebc4c10a3f43a6c8dcaa2548317

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

>>> Removing node aa84800441affebc4c10a3f43a6c8dcaa2548317 from cluster 192.168.10.13:7002

>>> Sending CLUSTER FORGET messages to the cluster...

>>> SHUTDOWN the node.




最终结果：




[root@localhost ~]# redis-cli -a 123456 --cluster check 192.168.10.10:7001

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

192.168.10.10:7001 (2ca33c82...) -> 0 keys | 5462 slots | 1 slaves.

192.168.10.12:7001 (fce781a3...) -> 0 keys | 5461 slots | 1 slaves.

192.168.10.11:7001 (be7b9fef...) -> 0 keys | 5461 slots | 1 slaves.

[OK] 0 keys in 3 masters.

0.00 keys per slot on average.

>>> Performing Cluster Check (using node 192.168.10.10:7001)

M: 2ca33c822373a073cfe06f3bd65e832ff551a052 192.168.10.10:7001

   slots:[0-1355],[1365-5460],[12278-12287] (5462 slots) master

   1 additional replica(s)

S: a901767a5f6bd51a13ee2b822f64ce4bbe1f435e 192.168.10.11:7002

   slots: (0 slots) slave

   replicates 2ca33c822373a073cfe06f3bd65e832ff551a052

S: 39cb8b3aca80388373252eb36598f9a58acf4175 192.168.10.10:7002

   slots: (0 slots) slave

   replicates fce781a33203003acaa8e4d6f2d4831f3c5a1eb7

S: 690ff3113371d470101c16046371de2a0bb87bcd 192.168.10.12:7002

   slots: (0 slots) slave

   replicates be7b9fefd8d78c8f310acc403d871866d5101074

M: fce781a33203003acaa8e4d6f2d4831f3c5a1eb7 192.168.10.12:7001

   slots:[1356-1364],[5461-6816],[12288-16383] (5461 slots) master

   1 additional replica(s)

M: be7b9fefd8d78c8f310acc403d871866d5101074 192.168.10.11:7001

   slots:[6817-12277] (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、导入现有数据


基础准备


导入数据与原有数据不能有重复的key名称。


导入数据之前需要关闭redis各服务器的密码，包括集群中的各node和源Redis




redis-cli -h 192.168.10.10 -p 7001 -a 123456 CONFIG SET requirepass ""




执行




redis-cli --cluster import 集群服务器IP:PORT  --CLUSTER-FROM  外部redis node-IP:port --cluster-copy --cluster-replace




Redis正式完结！！！！！
相关文章