redis主从架构(4)

绝地灬酷狼 2022-06-01 07:18 196阅读 0赞

# 1、redis高并发跟整个系统的高并发之间的关系 #

redis，你要搞高并发的话，不可避免，要把底层的缓存搞得很好

mysql，高并发，做到了，那么也是通过一系列复杂的分库分表，订单系统，事务要求的，QPS到几万，比较高了

要做一些电商的商品详情页，真正的超高并发，QPS上十万，甚至是百万，一秒钟百万的请求量

光是redis是不够的，但是redis是整个大型的缓存架构中，支撑高并发的架构里面，非常重要的一个环节

首先，你的底层的缓存中间件，缓存系统，必须能够支撑的起我们说的那种高并发，其次，再经过良好的整体的缓存架构的设计（多级缓存架构、热点缓存），支撑真正的上十万，甚至上百万的高并发

# 2、redis不能支撑高并发的瓶颈在哪里？ #

单机  
![这里写图片描述][SouthEast]

# 3、如果redis要支撑超过10万+的并发，那应该怎么做？ #

单机的redis几乎不太可能说QPS超过10万+，除非一些特殊情况，比如你的机器性能特别好，配置特别高，物理机，维护做的特别好，而且你的整体的操作不是太复杂

单机在几万

读写分离，一般来说，对缓存，一般都是用来支撑读高并发的，写的请求是比较少的，可能写请求也就一秒钟几千，一两千

大量的请求都是读，一秒钟二十万次读

读写分离

主从架构 -> 读写分离 -> 支撑10万+读QPS的架构  
![这里写图片描述][SouthEast 1]

# 4、redis replication的核心机制 #

（1）redis采用异步方式复制数据到slave节点，不过redis 2.8开始，slave node会周期性地确认自己每次复制的数据量  
（2）一个master node是可以配置多个slave node的  
（3）slave node也可以连接其他的slave node  
（4）slave node做复制的时候，是不会block master node的正常工作的  
（5）slave node在做复制的时候，也不会block对自己的查询操作，它会用旧的数据集来提供服务; 但是复制完成的时候，需要删除旧数据集，加载新数据集，这个时候就会暂停对外服务了  
（6）slave node主要用来进行横向扩容，做读写分离，扩容的slave node可以提高读的吞吐量

slave，高可用性，有很大的关系

--------------------

# 5、master持久化对于主从架构的安全保障的意义 #

如果采用了主从架构，那么建议必须开启master node的持久化！

不建议用slave node作为master node的数据热备，因为那样的话，如果你关掉master的持久化，可能在master宕机重启的时候数据是空的，然后可能一经过复制，salve node数据也丢了

master -> RDB和AOF都关闭了 -> 全部在内存中

master宕机，重启，是没有本地数据可以恢复的，然后就会直接认为自己IDE数据是空的

master就会将空的数据集同步到slave上去，所有slave的数据全部清空

100%的数据丢失

master节点，必须要使用持久化机制

第二个，master的各种备份方案，要不要做，万一说本地的所有文件丢失了; 从备份中挑选一份rdb去恢复master; 这样才能确保master启动的时候，是有数据的

即使采用了后续讲解的高可用机制，slave node可以自动接管master node，但是也可能sentinal还没有检测到master failure，master node就自动重启了，还是可能导致上面的所有slave node数据清空故障

# 6、主从架构的核心原理 #

当启动一个slave node的时候，它会发送一个PSYNC命令给master node

如果这是slave node重新连接master node，那么master node仅仅会复制给slave部分缺少的数据; 否则如果是slave node第一次连接master node，那么会触发一次full resynchronization

开始full resynchronization的时候，master会启动一个后台线程，开始生成一份RDB快照文件，同时还会将从客户端收到的所有写命令缓存在内存中。RDB文件生成完毕之后，master会将这个RDB发送给slave，slave会先写入本地磁盘，然后再从本地磁盘加载到内存中。然后master会将内存中缓存的写命令发送给slave，slave也会同步这些数据。

slave node如果跟master node有网络故障，断开了连接，会自动重连。master如果发现有多个slave node都来重新连接，仅仅会启动一个rdb save操作，用一份数据服务所有slave node。  
![这里写图片描述][SouthEast 2]

# 7、主从复制的断点续传 #

从redis 2.8开始，就支持主从复制的断点续传，如果主从复制过程中，网络连接断掉了，那么可以接着上次复制的地方，继续复制下去，而不是从头开始复制一份

master node会在内存中常见一个backlog，master和slave都会保存一个replica offset还有一个master id，offset就是保存在backlog中的。如果master和slave网络连接断掉了，slave会让master从上次的replica offset开始继续复制

但是如果没有找到对应的offset，那么就会执行一次resynchronization

**redis主从复制的原理**  
![这里写图片描述][SouthEast 3]

# 8、无磁盘化复制 #

master在内存中直接创建rdb，然后发送给slave，不会在自己本地落地磁盘了

repl-diskless-sync  
repl-diskless-sync-delay，等待一定时长再开始复制，因为要等更多slave重新连接过来

# 9、过期key处理 #

slave不会过期key，只会等待master过期key。如果master过期了一个key，或者通过LRU淘汰了一个key，那么会模拟一条del命令发送给slave。

# 10、复制的完整流程 #

（1）slave node启动，仅仅保存master node的信息，包括master node的host和ip，但是复制流程没开始

master host和ip是从哪儿来的，redis.conf里面的slaveof配置的

（2）slave node内部有个定时任务，每秒检查是否有新的master node要连接和复制，如果发现，就跟master node建立socket网络连接  
（3）slave node发送ping命令给master node  
（4）口令认证，如果master设置了requirepass，那么salve node必须发送masterauth的口令过去进行认证  
（5）master node第一次执行全量复制，将所有数据发给slave node  
（6）master node后续持续将写命令，异步复制给slave node

# 11、数据同步相关的核心机制 #

指的就是第一次slave连接msater的时候，执行的全量复制，那个过程里面你的一些细节的机制

（1）master和slave都会维护一个offset

master会在自身不断累加offset，slave也会在自身不断累加offset  
slave每秒都会上报自己的offset给master，同时master也会保存每个slave的offset

这个倒不是说特定就用在全量复制的，主要是master和slave都要知道各自的数据的offset，才能知道互相之间的数据不一致的情况

（2）backlog

master node有一个backlog，默认是1MB大小  
master node给slave node复制数据时，也会将数据在backlog中同步写一份  
backlog主要是用来做全量复制中断候的增量复制的

（3）master run id

info server，可以看到master run id  
如果根据host+ip定位master node，是不靠谱的，如果master node重启或者数据出现了变化，那么slave node应该根据不同的run id区分，run id不同就做全量复制  
如果需要不更改run id重启redis，可以使用redis-cli debug reload命令

**maste run id的作用**  
![这里写图片描述][SouthEast 4]

（4）psync

从节点使用psync从master node进行复制，psync runid offset  
master node会根据自身的情况返回响应信息，可能是FULLRESYNC runid offset触发全量复制，可能是CONTINUE触发增量复制

# 12、全量复制 #

（1）master执行bgsave，在本地生成一份rdb快照文件  
（2）master node将rdb快照文件发送给salve node，如果rdb复制时间超过60秒（repl-timeout），那么slave node就会认为复制失败，可以适当调节大这个参数  
（3）对于千兆网卡的机器，一般每秒传输100MB，6G文件，很可能超过60s  
（4）master node在生成rdb时，会将所有新的写命令缓存在内存中，在salve node保存了rdb之后，再将新的写命令复制给salve node  
（5）client-output-buffer-limit slave 256MB 64MB 60，如果在复制期间，内存缓冲区持续消耗超过64MB，或者一次性超过256MB，那么停止复制，复制失败  
（6）slave node接收到rdb之后，清空自己的旧数据，然后重新加载rdb到自己的内存中，同时基于旧的数据版本对外提供服务  
（7）如果slave node开启了AOF，那么会立即执行BGREWRITEAOF，重写AOF

rdb生成、rdb通过网络拷贝、slave旧数据的清理、slave aof rewrite，很耗费时间

如果复制的数据量在4G~6G之间，那么很可能全量复制时间消耗到1分半到2分钟

# 13、增量复制 #

（1）如果全量复制过程中，master-slave网络连接断掉，那么salve重新连接master时，会触发增量复制  
（2）master直接从自己的backlog中获取部分丢失的数据，发送给slave node，默认backlog就是1MB  
（3）msater就是根据slave发送的psync中的offset来从backlog中获取数据的

**复制的完整的基本流程**  
![这里写图片描述][SouthEast 5]

# 14、heartbeat #

主从节点互相都会发送heartbeat信息

master默认每隔10秒发送一次heartbeat，salve node每隔1秒发送一个heartbeat

# 15、异步复制 #

master每次接收到写命令之后，现在内部写入数据，然后异步发送给slave node

# 16、启用复制，部署slave node #

wget [http://downloads.sourceforge.net/tcl/tcl8.6.1-src.tar.gz][http_downloads.sourceforge.net_tcl_tcl8.6.1-src.tar.gz]  
tar -xzvf tcl8.6.1-src.tar.gz  
cd /usr/local/tcl8.6.1/unix/  
./configure  
make && make install

使用redis-3.2.8.tar.gz（截止2017年4月的最新稳定版）  
tar -zxvf redis-3.2.8.tar.gz  
cd redis-3.2.8  
make && make test && make install

（1）redis utils目录下，有个redis\_init\_script脚本  
（2）将redis\_init\_script脚本拷贝到linux的/etc/init.d目录中，将redis\_init\_script重命名为redis\_6379，6379是我们希望这个redis实例监听的端口号  
（3）修改redis\_6379脚本的第6行的REDISPORT，设置为相同的端口号（默认就是6379）  
（4）创建两个目录：/etc/redis（存放redis的配置文件），/var/redis/6379（存放redis的持久化文件）  
（5）修改redis配置文件（默认在根目录下，redis.conf），拷贝到/etc/redis目录中，修改名称为6379.conf

（6）修改redis.conf中的部分配置为生产环境

daemonize yes 让redis以daemon进程运行  
pidfile /var/run/redis\_6379.pid 设置redis的pid文件位置  
port 6379 设置redis的监听端口号  
dir /var/redis/6379 设置持久化文件的存储位置

（7）让redis跟随系统启动自动启动

在redis\_6379脚本中，最上面，加入两行注释

# chkconfig: 2345 90 10
    
    # description: Redis is a persistent key-value database
    
    chkconfig redis_6379 on

在slave node上配置：slaveof 192.168.1.1 6379，即可

也可以使用slaveof命令

主节点安装路径（redis安装详情）：[http://blog.csdn.net/qq1137623160/article/details/79121959][http_blog.csdn.net_qq1137623160_article_details_79121959]

# 17、强制读写分离 #

基于主从复制架构，实现读写分离

redis slave node只读，默认开启，slave-read-only

开启了只读的redis slave node，会拒绝所有的写操作，这样可以强制搭建成读写分离的架构

# 18、集群安全认证 #

master上启用安全认证，requirepass  
master连接口令，masterauth

## 19、读写分离架构的测试 ##

先启动主节点，eshop-cache01上的redis实例  
再启动从节点，eshop-cache02上的redis实例

刚才我调试了一下，redis slave node一直说没法连接到主节点的6379的端口

在搭建生产环境的集群的时候，不要忘记修改一个配置，bind

bind 127.0.0.1 -> 本地的开发调试的模式，就只能127.0.0.1本地才能访问到6379的端口

每个redis.conf中的bind 127.0.0.1 -> bind自己的ip地址  
在每个节点上都: iptables -A INPUT -ptcp –dport 6379 -j ACCEPT

redis-cli -h ipaddr  
info replication

在主上写，在从上读

**你如果要对自己刚刚搭建好的redis做一个基准的压测，测一下你的redis的性能和QPS（query per second）**

**redis自己提供的redis-benchmark压测工具，是最快捷最方便的，当然啦，这个工具比较简单，用一些简单的操作和场景去压测**

# 20、对redis读写分离架构进行压测，单实例写QPS+单实例读QPS #

redis-3.2.8/src

./redis-benchmark -h 192.168.31.187

\-c Number of parallel connections (default 50)  
\-n Total number of requests (default 100000)  
\-d Data size of SET/GET value in bytes (default 2)

根据你自己的高峰期的访问量，在高峰期，瞬时最大用户量会达到10万+，-c 100000，-n 10000000，-d 50

各种基准测试，直接出来

1核1G，虚拟机

====== PING\_INLINE ======  
100000 requests completed in 1.28 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

99.78% <= 1 milliseconds  
99.93% <= 2 milliseconds  
99.97% <= 3 milliseconds  
100.00% <= 3 milliseconds  
78308.54 requests per second

====== PING\_BULK ======  
100000 requests completed in 1.30 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

99.87% <= 1 milliseconds  
100.00% <= 1 milliseconds  
76804.91 requests per second

====== SET ======  
100000 requests completed in 2.50 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

5.95% <= 1 milliseconds  
99.63% <= 2 milliseconds  
99.93% <= 3 milliseconds  
99.99% <= 4 milliseconds  
100.00% <= 4 milliseconds  
40032.03 requests per second

====== GET ======  
100000 requests completed in 1.30 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

99.73% <= 1 milliseconds  
100.00% <= 2 milliseconds  
100.00% <= 2 milliseconds  
76628.35 requests per second

====== INCR ======  
100000 requests completed in 1.90 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

80.92% <= 1 milliseconds  
99.81% <= 2 milliseconds  
99.95% <= 3 milliseconds  
99.96% <= 4 milliseconds  
99.97% <= 5 milliseconds  
100.00% <= 6 milliseconds  
52548.61 requests per second

====== LPUSH ======  
100000 requests completed in 2.58 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

3.76% <= 1 milliseconds  
99.61% <= 2 milliseconds  
99.93% <= 3 milliseconds  
100.00% <= 3 milliseconds  
38684.72 requests per second

====== RPUSH ======  
100000 requests completed in 2.47 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

6.87% <= 1 milliseconds  
99.69% <= 2 milliseconds  
99.87% <= 3 milliseconds  
99.99% <= 4 milliseconds  
100.00% <= 4 milliseconds  
40469.45 requests per second

====== LPOP ======  
100000 requests completed in 2.26 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

28.39% <= 1 milliseconds  
99.83% <= 2 milliseconds  
100.00% <= 2 milliseconds  
44306.60 requests per second

====== RPOP ======  
100000 requests completed in 2.18 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

36.08% <= 1 milliseconds  
99.75% <= 2 milliseconds  
100.00% <= 2 milliseconds  
45871.56 requests per second

====== SADD ======  
100000 requests completed in 1.23 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

99.94% <= 1 milliseconds  
100.00% <= 2 milliseconds  
100.00% <= 2 milliseconds  
81168.83 requests per second

====== SPOP ======  
100000 requests completed in 1.28 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

99.80% <= 1 milliseconds  
99.96% <= 2 milliseconds  
99.96% <= 3 milliseconds  
99.97% <= 5 milliseconds  
100.00% <= 5 milliseconds  
78369.91 requests per second

====== LPUSH (needed to benchmark LRANGE) ======  
100000 requests completed in 2.47 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

15.29% <= 1 milliseconds  
99.64% <= 2 milliseconds  
99.94% <= 3 milliseconds  
100.00% <= 3 milliseconds  
40420.37 requests per second

====== LRANGE\_100 (first 100 elements) ======  
100000 requests completed in 3.69 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

30.86% <= 1 milliseconds  
96.99% <= 2 milliseconds  
99.94% <= 3 milliseconds  
99.99% <= 4 milliseconds  
100.00% <= 4 milliseconds  
27085.59 requests per second

====== LRANGE\_300 (first 300 elements) ======  
100000 requests completed in 10.22 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

0.03% <= 1 milliseconds  
5.90% <= 2 milliseconds  
90.68% <= 3 milliseconds  
95.46% <= 4 milliseconds  
97.67% <= 5 milliseconds  
99.12% <= 6 milliseconds  
99.98% <= 7 milliseconds  
100.00% <= 7 milliseconds  
9784.74 requests per second

====== LRANGE\_500 (first 450 elements) ======  
100000 requests completed in 14.71 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

0.00% <= 1 milliseconds  
0.07% <= 2 milliseconds  
1.59% <= 3 milliseconds  
89.26% <= 4 milliseconds  
97.90% <= 5 milliseconds  
99.24% <= 6 milliseconds  
99.73% <= 7 milliseconds  
99.89% <= 8 milliseconds  
99.96% <= 9 milliseconds  
99.99% <= 10 milliseconds  
100.00% <= 10 milliseconds  
6799.48 requests per second

====== LRANGE\_600 (first 600 elements) ======  
100000 requests completed in 18.56 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

0.00% <= 2 milliseconds  
0.23% <= 3 milliseconds  
1.75% <= 4 milliseconds  
91.17% <= 5 milliseconds  
98.16% <= 6 milliseconds  
99.04% <= 7 milliseconds  
99.83% <= 8 milliseconds  
99.95% <= 9 milliseconds  
99.98% <= 10 milliseconds  
100.00% <= 10 milliseconds  
5387.35 requests per second

====== MSET (10 keys) ======  
100000 requests completed in 4.02 seconds  
50 parallel clients  
3 bytes payload  
keep alive: 1

0.01% <= 1 milliseconds  
53.22% <= 2 milliseconds  
99.12% <= 3 milliseconds  
99.55% <= 4 milliseconds  
99.70% <= 5 milliseconds  
99.90% <= 6 milliseconds  
99.95% <= 7 milliseconds  
100.00% <= 8 milliseconds  
24869.44 requests per second

我们这个读写分离这一块

大部分情况下来说，看你的服务器的机器性能和配置，机器越牛逼，配置越高

单机上十几万，单机上二十万

很多公司里，给一些低配置的服务器，操作复杂度

大公司里，都是公司会提供统一的云平台，比如京东、腾讯、BAT、其他的一些、小米、美团

虚拟机，低配

搭建一些集群，专门为某个项目，搭建的专用集群，4核4G内存，比较复杂的操作，数据比较大

几万，单机做到，差不多了

redis提供的高并发，至少到上万，没问题

几万~十几万/二十万不等

QPS，自己不同公司，不同服务器，自己去测试，跟生产环境还有区别

生产环境，大量的网络请求的调用，网络本身就有开销，你的redis的吞吐量就不一定那么高了

QPS的两个杀手：一个是复杂操作，lrange，挺多的; value很大，2 byte，我之前用redis做大规模的缓存

做商品详情页的cache，可能是需要把大串数据，拼接在一起，作为一个json串，大小可能都几k，几个byte

2、水平扩容redis读节点，提升度吞吐量

来自龙果学院讲师：中华石杉

[SouthEast]: /images/20220601/87510fd6f8094beba005f24d736e32ee.png
[SouthEast 1]: /images/20220601/3203cdd8909d44618125c912c9db773d.png
[SouthEast 2]: /images/20220601/ad2432eec01a4276bed12051ba40ee6f.png
[SouthEast 3]: /images/20220601/0e3fcfc4a4614e2a88971add5c35f7b6.png
[SouthEast 4]: /images/20220601/dd01f64536b34667a26b3c7b26bd733e.png
[SouthEast 5]: /images/20220601/389d97343cda40d49de3a86d205878de.png
[http_downloads.sourceforge.net_tcl_tcl8.6.1-src.tar.gz]: http://downloads.sourceforge.net/tcl/tcl8.6.1-src.tar.gz
[http_blog.csdn.net_qq1137623160_article_details_79121959]: http://blog.csdn.net/qq1137623160/article/details/79121959