AOF

Append Only File追加文件

将我们的所有命令都记录下来，恢复的时候就重新执行这些命令（读操作不记录）

AOF是什么

配置

默认是不开启的，我们需要手动配置

一般我们只需要开启AOF即可，其他的配置不需要动

重启我们的redis服务器

[root@iz2zebfusfdfm99altnk8lz bin]# ls
appendonly.aof  redis-benchmark  redis-check-rdb  redis-sentinel  wconfig
dump.rdb        redis-check-aof  redis-cli        redis-server


#当我们执行以下命令后
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> set k2 v2
OK
127.0.0.1:6379> set k3 v3
OK
127.0.0.1:6379> set k4 v4
OK
127.0.0.1:6379> set k5 v5
OK
#########打开查看我们的aof文件
vim appendonly.aof 

把我们的set命令都记录下来了，要是这个文件被破坏了怎么办呢

这个文件出错怎么办呢？

在我们的工具中还有一个叫做redis-check-aof的工具

他可以进行修复

我们退出Redis服务，然后用vim修改aof文件中的内容，故意加一行数据

再去尝试连接Redis服务

[root@iz2zebfusfdfm99altnk8lz bin]# vim appendonly.aof 
[root@iz2zebfusfdfm99altnk8lz bin]# redis-server wconfig/redis.conf 
2237:C 30 Nov 2020 15:41:21.026 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
2237:C 30 Nov 2020 15:41:21.026 # Redis version=5.0.7, bits=64, commit=00000000, modified=0, pid=2237, just started
2237:C 30 Nov 2020 15:41:21.026 # Configuration loaded
[root@iz2zebfusfdfm99altnk8lz bin]# redis-cli -p 6379
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected> 
######我们发现，不能连接到了，因为aof刷新出问题了
##########	我们必须使用aof-check-aof修复这个aof文件

aof-check-aof

命令修复文件

[root@iz2zebfusfdfm99altnk8lz bin]# redis-check-aof --fix appendonly.aof 
0x              a8: Expected prefix '*', got: 's'
AOF analyzed: size=181, ok_up_to=168, diff=13
This will shrink the AOF from 181 bytes, with 13 bytes, to 168 bytes
Continue? [y/N]: y
Successfully truncated AOF

我们现在去看看

我们现在再去连接Reids服务器，可以直接连接了,数据也在，有时候有误差，可能会丢一两个

127.0.0.1:6379> keys *
1) "k2"
2) "k4"
3) "k3"
4) "k1"
5) "k5"

重写规则

aof默认的是文件的无线追加，文件越来越大

如果aof文件大于64M，太大了！！就会fork一个新的进程来将我们的文件重写

优缺点

优点：

• 每一次修改都同步

• 每秒同步一次，有可能丢失一秒的数据

• 从不同步，效率最高

缺点：

• 现对于数据文件来说，aof远大于rdf，修复速度比rdb慢

• 运行效率比rdb慢

扩展

1. RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储
2. AOF持久化方式记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据, AOF命令以Redis协议追加保存每次写的操作到文件末尾, Redis还能对AOF文件进行后台重写,使得AOF文件的体积不至于过大。
3. 只做缓存,如果你只希望你的数据在服务器运行的时候存在,你也可以不使用任何持久化
4. 同时开启两种持久化方式
   ●在这种情况下,当redis重启的时候会优先载入AOF文件来恢复原始的数据,因为在通常情况下AOF文件保存的数据集要比RDB
   文件保存的数据集要完整。
   ●RDB的数据不实时,同时使用两者时服务器重启也只会找AOF文件,那要不要只使用AOF呢?作者建议不要，因为RDB更适合
   用于备份数据库( AOF在不断变化不好备份) , 快速重启,而且不会有AOF可能潜在的Bug ,留着作为- -个万- -的手段。
5. 性能建议
   ●因为RDB文件只用作后备用途,建议只在Slave.上持久化RDB文件,而且只要15分钟备份-次就够了,只保留save 9001这条
   规则。
   ●如果Enable AOF ,好处是在最恶劣情况下也只会丢失不超过两秒数据,启动脚本较简单只load自己的AOF文件就可以了,代价
   一是带来了持续的I0 ,二是AOF rewrite的最后将rewrite 过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要
   硬盘许可,应该尽量减少AOF rewrite的频率, AOF重写的基础大小默认值64M太了,可以设到5G以上,默认超过原大小
   100%大小重写可以改到适当的数值。
   ●如果不Enable AOF ,仅靠Master Slave Repllcation实现高可用性也可以,能省掉一大笔I0 ,也减少了rewrite时带来的系统波动。代价是如果Master/Slave 同时倒掉,**(突然断电)**会丢失十几分钟的数据,启动脚本也要比较两个Master/Slave中的RDB文件,载入较新的那个,微博就是这种架构。

Redis发布订阅

通信 队列 发送者 ============ 订阅者

Redis发布订阅(pub/sub)是一种I消息通信模式== :发送者(pub)发送消息,订阅者(sub)接收消息。
Redis客户端可以订阅任意数量的频道。

订阅发布模式图

消息发送者：UP主，博主

频道：平台

接受者：粉丝

命令

序号	命令及描述
1	PSUBSCRIBE pattern [pattern …]订阅一个或多个符合给定模式的频道。
2	PUBSUB subcommand [argument [argument …]] 查看订阅与发布系统状态。
3	PUBLISH channel message将信息发送到指定的频道。
4	PUNSUBSCRIBE [pattern [pattern …]] 退订所有给定模式的频道。
5	SUBSCRIBE channel [channel …] 订阅给定的一个或多个频道的信息。
6	UNSUBSCRIBE [channel [channel …]] 指退订给定的频道。

测试

订阅端开启，她在等待读取我们的messages信息，我订阅了狂神说

他就在等这个狂神说推送的信息

127.0.0.1:6379> SUBSCRIBE kuangshenshuo
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "kuangshenshuo"
3) (integer) 1

我们在开一个连接，模拟发送消息，我发消息到这个频道

[root@iz2zebfusfdfm99altnk8lz bin]# cd /usr/local/bin
[root@iz2zebfusfdfm99altnk8lz bin]# redis-cli -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> PUBLISH kuangshenshuo "hello wangshen"
(integer) 1
127.0.0.1:6379> PUBLISH kuangshenshuo "redis"
(integer) 1

这个时候我们就能监听到了，我接收到了up主的帖子

127.0.0.1:6379> SUBSCRIBE kuangshenshuo
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "kuangshenshuo"
3) (integer) 1
1) "message"
2) "kuangshenshuo"
3) "hello wangshen"
1) "message"
2) "kuangshenshuo"
3) "redis"

原理

Redis是使用C实现的,通过分析Redis源码里的pubsgb.c文件，了解发布和订阅机制的底层实现,籍此加深对Redis的理解。
Redis通过PUBLISH、SUBSCRIBE 和PSUBSCRIBE等命令实现发布和订阅功能。
通过SUBSCRIBE命令订阅某频道后, redis-server 里维护了一个字典,字典的键就是一个个channel , 而字典的值则是一个链表,链表中保存了所有订阅这个channel的客户端。SUBSCRIBE 命令的关键,就是将客户端添加到给定channel的订阅链表中。

通过PUBLISH命令向订阅者发送消息, redis-server 会使用给定的频道作为键,在它所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表,遍历这个链表,将消息发布给所有订阅者。
Pub/Sub从字面上理解就是发布( Publish )与订阅( Subscribe ) , 在Redis中,你可以设定对某一个key值进行消息发 布及消息订阅，当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息。这-功能最明显的用法就是用作实时消息系统,比如普通的即时聊天,群聊等功能。

场景

实时消息系统

实时聊天系统(频道当做聊天室，在将信息回显给所有人)

订阅，关注系统

Redis主从复制

概念

主从复制,是指将-台Redis服务器的数据 ,复制到其他的Redis服务器。前者称为主节点(master/leader) ,后者称为从节点(slave/follower) ;数据的复制是单向的,只能由主节点到从节点。Master以写为主 , Slave以读为主。(主从分离，读写分离！一主二从！！！最低配，后面的哨兵模式会选举，至少2个从机)
默认情况下,每台Redis服务器都是主节点;且一个主节点可以有多个从节点(或没有从节点),但一个从节点只能有一个主节点。

**主从复制的作用主要包括: **
1、**数据冗余:**主从复制实现了数据的热备份,是持久化之外的一种数据冗余方式。
2.**故障恢复:**当主节点出现问题时,可以由从节点提供服务,实现快速的故障恢复;实际上是一一种服务的冗余。
3、**负载均衡:**在主从复制的基础上,配合读写分离,可以由主节点提供写服务,由从节点提供读服务(即写Redis数据时应用连接主节点,读Redis数据时应用连接从节点) , 分担服务器负载;尤其是在写少读多的场景下,通过多个从节点分担读负载,可以以大提高Redis服务器的并发量。
4、**高可用基石:**除了上述作用以外,主从复制还是哨兵和集群能够实施的基础,因此说主从复制是Redis高可用的基础。

一般来说,要将Redis运用于工程项目中.只使用一台Redis是万万不能的,原因如下:
1、从结构上,单个Redis服务器会发生单点故障,并且-台服务器需要处理所有的请求负载,压力较大;
2、从容量上,单个Redis服务器内存容量有限,就算一台Redis服务器内存容量为256G ,也不能将所有内存用作Redis存储内存,
一般来说， 单台Redis最大使用内存不应该超过20G。
电商网站上的商品,一般都是一 次上传,无数次浏览的,说专业点也就是”多读少写"。
对于这种场景,我们可以使如下这种架构:

一主三从

环境配置

只配置从库，不用配置主库！！

info replication	#查看当前库的信息
# Replication
role:master		#角色
connected_slaves:0		#从机个数
master_replid:9585c086af13283e932bb79e27bae579c7e09c23
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

复制3个对应文件修改对应的信息

1.端口

2pid名字

3.log文件名字

4.durm.rdb名字

[root@iz2zebfusfdfm99altnk8lz bin]# redis-server wconfig/redis79.conf 
[root@iz2zebfusfdfm99altnk8lz bin]# ls
6379.log        dump.rdb         redis-check-aof  redis-cli       redis-server
appendonly.aof  redis-benchmark  redis-check-rdb  redis-sentinel  wconfig
[root@iz2zebfusfdfm99altnk8lz bin]# ps -ef|grep redis
root      2378     1  0 16:47 ?        00:00:00 redis-server *:6379
root      2384     1  0 16:48 ?        00:00:00 redis-server *:6380
root      2389     1  0 16:48 ?        00:00:00 redis-server *:6381
root      2394  2119  0 16:48 pts/1    00:00:00 grep --color=auto redis

一主二从

默认情况下，每台服务器都是主节点

我们命令查询3台都是主机，我们一般只用配置从机就好了

命令配置从机

命令配置的主从机只是临时的

79做主机，80,81做从机

80配置

127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:up
master_last_io_seconds_ago:5
#####81也是如此
#####79配置就变成了如下
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6380,state=online,offset=126,lag=1
slave1:ip=127.0.0.1,port=6381,state=online,offset=126,lag=1
master_replid:fbd16c58d8a1dc9bc87c361057f1f4a52d816ccc

真实的从主配置应该在配置文件中配置，那样才是永久的配置

配置文件配置

细节

主机可以写，从机只能读

主机中的所有的信息和数据，都会自动被从机保存

###79主机写操作
127.0.0.1:6379> set k1 v1
OK
#两个从机读操作
127.0.0.1:6380> keys *
1) "k1"
127.0.0.1:6381> keys *
1) "k1"
####从机写操作   报错
127.0.0.1:6381> set k2 v2
(error) READONLY You can't write against a read only replica.
###################
###主节点崩了，但是从机存储的信息和数据还在

主机宕机

127.0.0.1:6379> SHUTDOWN
not connected> exit

#####		只剩下了两个从机80,81
[root@iz2zebfusfdfm99altnk8lz wconfig]# ps -ef|grep redis
root      2384     1  0 16:48 ?        00:00:01 redis-server *:6380
root      2389     1  0 16:48 ?        00:00:01 redis-server *:6381
root      2401  2293  0 16:51 pts/2    00:00:00 redis-cli -p 6380
root      2403  2340  0 16:51 pts/3    00:00:00 redis-cli -p 6381
root      2432  2119  0 17:04 pts/1    00:00:00 grep --color=auto redis
#######################################################
#######			再次查看主从关系
####		从机依然是从机
127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0

现在我们主机活过来，会怎样呢

#####	主机写操作
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> set k2 v2
OK
####		从机读操作
127.0.0.1:6380> get k2
"v2"

测试:主机断开连接,从机依旧连接到主机的,但是没有写操作,这个时候,主机如果回来了,从机依旧可以直接获取到主机写的信息!

从机宕机

我们关闭81从机

127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6380,state=online,offset=290,lag=1
master_replid:4555410e900c0be6c1cee3ee2507d496c9f5db82
########		从机变成一个
#####		这个时候我们主机做set写操作
127.0.0.1:6379> set k3 v3
OK
#########		当然我们的80从机还是能拿到的因为他没有宕机
############################################################
####	再次启动81从机
[root@iz2zebfusfdfm99altnk8lz bin]# redis-server wconfig/redis81.conf 
[root@iz2zebfusfdfm99altnk8lz bin]# redis-cli -p 6381
########	我们发现这个从机断开的时候，主机写的操作他拿不到了
127.0.0.1:6381> get k3
(nil)

#######			为什么呢
127.0.0.1:6381> info replication
# Replication
role:master
connected_slaves:0
master_replid:733d3bd5ded64f06b7fc79bcc853505aba6f89f9
##########  因为我们使用命令行让他成为79的从机，再次启动就变成了主机
##				那我们再次用命令让他变成从机，能拿到么
127.0.0.1:6381> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:up
#########	我们发现一旦成为从机  数据立马就回来了
127.0.0.1:6381> get k3
"v3"

从机复制原理

Slave启动成功连接到master后会发送一个sync命令

Master接到命令,启动后台的存盘进程,同时收集所有接收到的用于修改数据集命令,在后台进程执行完毕之后, master将传送整个数据文件到slave ,并完成一次完全同步。

**全量复制:**而slave服务在接收到数据库文件数据后,将其存盘并加载到内存中。
增量复制: Master继续将新的所有收集到的修改命令依次传给slave ,完成同步
但是只要是重新连接master , 一次完全同步(全量复制)将被自动执行，我们的数据一定可以再从机中看到

进阶

我们可不可以这样设置主从关系，80这个机子即当主机又当从机，81作为80的从机，而不直接是79的从机，那如果79主机宕机，80这个机子能进行主机才能进行的写操作么

### 		81变成80的从机 
127.0.0.1:6381> SLAVEOF 127.0.0.1 6380
127.0.0.1:6381> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up
############################################################
##		79以前的两个从机变成了一个从机
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6380,state=online,offset=1509,lag=1
master_replid:4555410e900c0be6c1cee3ee2507d496c9f5db82
############################################################
##		此时的80依旧是一个从节点，不能进行写操作
127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:up
master_last_io_seconds_ago:6
master_sync_in_progress:0
slave_repl_offset:1593
slave_priority:100
############################################################
############################################################
###	那我们现在在79端口写操作，81从机还能获取到么
127.0.0.1:6379> set k4 v4
OK
###	81拿数据		依旧能拿到
127.0.0.1:6381> get k4
"v4"

这个时候也可以完成主从复制

那我们能不能在79断开服务之后，能不能选出来一个做主机呢？

手动命令配置

如果主机宕机

81从机野心勃勃，想要篡位，只需要执行

#####		篡位命令
127.0.0.1:6381> SLAVEOF no one 
OK
######		登基称帝
127.0.0.1:6381> info replication
# Replication
role:master
connected_slaves:0
master_replid:8730bf7197a01429d102e41ddd73d6025c4c10c6
master_replid2:4555410e900c0be6c1cee3ee2507d496c9f5db82

那么现在其他的节点就可以手动去连接到这个最新的主机上,如果以前的主机恢复了，只能手动重新连接

为了方便测试，我们还是老老实实让81节点去做太监，，80,81全部认79做主机

哨兵模式

概述

主从切换技术的方法是:当主服务器宕机后,需要手动把一台从服务器切换为主服务器,这就需要人工干预,费事费力,还会造成一段时间内服务不可用。 这不是一种推荐的方式,更多时候,我们优先考虑哨兵模式。Redis从2.8开始正式提供 了Sentinel (哨兵)架构来解决这个问题。

谋朝篡位的自动版,能够后台监控主机是否故障,如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式,首先Redis提供了哨兵的命令,哨兵是一个独立的进程,作为进程,它会独立运行。其原理是哨兵通过发送命令,等待Redis服务器响应.从而监控运行的多个Redis实例。

这里的哨兵有两个作用
●通过发送命令,让Redis服务器返回监控其运行状态,包括主服务器和从服务器。
●当哨兵监测到master宕机,会自动将slave切换成master ,然后通过发布订阅模式通知其他的从服务器,修改配置文件,让它们切换主机。

那如果我们的哨兵也挂了呢？

多哨兵监控

假设主服务器宕机,哨兵1先检测到这个结果,系统并不会马上进行failover过程,仅仅是哨兵1主观的认为主服务器不可用,这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用,并且数量达到一定值时,那么哨兵之间就会进行一次投票 ,投票的结果由一个哨兵发起,进行failover[故障转移]操作。切换成功后,就会通过发布订阅模式,让各个哨兵把自己监控的从服务器实现切换主机,这个过程称为客观下线。

测试

还是上面的一主二从状态

1.配置哨兵配置文件

在我们的wconfig文件夹下创建我们的哨兵配置

#			被监控的名称		主机地址  端口	1
sentinel monitor myredis 127.0.0.1 6379 1

这个数字1代表主机挂了，slave投票看让谁接替为主机，票数最多的，就会成为主机

2.启动哨兵

[root@iz2zebfusfdfm99altnk8lz bin]# redis-sentinel wconfig/sentinel.conf 
2511:X 30 Nov 2020 17:49:18.081 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
2511:X 30 Nov 2020 17:49:18.082 # Redis version=5.0.7, bits=64, commit=00000000, modified=0, pid=2511, just started
2511:X 30 Nov 2020 17:49:18.082 # Configuration loaded
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 5.0.7 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26379
 |    `-._   `._    /     _.-'    |     PID: 2511
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

####		监控127.0.0.1 6379	后面有1  说明他是1票是主机
2511:X 30 Nov 2020 17:49:18.085 # +monitor master myredis 127.0.0.1 6379 quorum 1
####		发现两个从机127.0.0.1:6380 127.0.0.1:6381
2511:X 30 Nov 2020 17:49:18.086 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:49:18.088 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379

现在我们将主机关掉

#####  80还是从机
127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_repl_offset:12060
#####	81还是从机
127.0.0.1:6381> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up
master_last_io_seconds_ago:2
############################################################
2511:X 30 Nov 2020 17:52:33.934 * +failover-state-send-slaveof-noone slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:34.006 * +failover-state-wait-promotion slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:34.861 # +promoted-slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:34.861 # +failover-state-reconf-slaves master myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:34.929 * +slave-reconf-sent slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:35.877 * +slave-reconf-inprog slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:35.877 * +slave-reconf-done slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:35.959 # +failover-end master myredis 127.0.0.1 6379
2511:X 30 Nov 2020 17:52:35.959 # +switch-master myredis 127.0.0.1 6379 127.0.0.1 6380
2511:X 30 Nov 2020 17:52:35.959 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6380
2511:X 30 Nov 2020 17:52:35.959 * +slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6380
2511:X 30 Nov 2020 17:53:05.983 # +sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6380
######  我们发现他开始发送选举6379崩了，故障转移
##############################################################	我们去看看哪两个从机怎么养了
###			我们发现80自动成为了主机
####	在我们的哨兵最后一行我们亦可以看到# +sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6380
##########					6380选举成为了新主机
127.0.0.1:6380> info replication
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=28127,lag=1
master_replid:7a0938c6540d38d1f9e285832f1f1e9dd7e51758
master_replid2:a1cf0c30e0351d92f5d990bc4768957fd3eff962
master_repl_offset:28259
second_repl_offset:12061
repl_backlog_active:1
repl_backlog_size:1048576

哨兵日志

投票算法

现在以前的主机在连接回来呢？光杆司令，想要称帝，还得我们手动配置

不然的话，自动给80节点当从机，已经是80的天下了

优缺点

优点：

1.哨兵集群，基于主从复制模式，所有的主从配置优点，它全有

2.主从可以切换，故障可以转移，系统的可用性会更好

3.哨兵模式就是主从模式的升级，手动到自动，更加健壮

缺点：

1.Redis不好在线扩容，集群数量一旦达到上限，在线扩容就会十分麻烦！！(横向扩展)
2.实现哨兵模式的配置其实是很麻烦的，我们例子是最基础的

哨兵模式的全部配置

# Example sentine1. conf

#哨兵sentine1实例运行的端口默认26379
#如果有哨兵集群，我们还需要配置每个哨兵的端口
port 26379

#哨兵sentine1的工作目录
dir /tmp

#哨兵sentine]监控的redis主节点的ip port
# master-name可以自己命名的主节点名字 只能由字母A-z、 数字0-9、这三个字符".-- "组成。
# quorum配置多少个sentine1哨兵统- -认为master主节点失联 那么这时客观上认为主节点失联了
# sentinel monitor <master-name> 、 cip> <redis-port> <quorum>
sentine1 monitor mymaster 127.0.0.1 6379 2

#当在Redis实例中开启 了requirepass foobared 授权密码这样所有连接Redis实例的客户端都要提供密码
#设置哨兵sentinel连接主从的密码注意必须为主从设置- -一样的验证密码
# sentine1 auth-pass <master-name> <password>
sentine1 auth-pass mymaster MySUPER--secret -0123passwOrd

#指定多少毫秒之后主节点没有应答哨兵sentine1此时哨兵主观上认为主节点下线默认30秒
# sentine1 down-after-milliseconds <master-name> <mi 11iseconds>
sentine1 down-after-mi1li seconds mymaster 30000

#这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步，
这个数字越小，完成failover所需的时间就越长，
但是如果这个数字越大，就意味着越多的slave因为replication而不可用。
可以通过将这个值设为1来保证每次只有一-个slave处于不能处理命令请求的状态。
# sentine1 parallel-syncs <master-name> <nums laves>
sentine1 paralle1-syncs mymaster 1

#故障转移的超时时间failover-timeout 可以用在以下这些方面:
#1.同一个sentine1对同一 个master两次failover之间的间隔时间。
#2.当一个slave从一个错 误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的fai lover所需要的时间。
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves 依然会被正确配置为指向
master,但是就不按para1le1-syncs所配置的规则来了
#默认三分钟
# sentine1 fai lover-timeout <master-name> <mi 11iseconds>
sentine1 failover-timeout mymaster 180000


# SCRIPTS EXECUTION
#配置当某一事 件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
并对于脚本的运行结果有以下规则:
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信 号终止，之后重新执行。
#通知型脚本:当sentine1有任何警告级别的事件发生时(比如说redis实例的主观失效和客观失效等等)，将会去调用这个脚本，这时这个
脚本应该通过邮件，SMS 等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，- - 个是事件的类型，一
个是事件的描述。如果sentinel. conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则
sentine1无法正常启动成功。
#通知脚本
#shell编程
# sentine1 notification-script <master-name> <script-path>
sentine1 notification-script mymaster /var/redis/notify. sh


#客户端重新配置主节点参数脚本
#当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
#以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
#目前<state> 总是“failover",
# <role> 是“Teader"或者“observer"中的-一个。
#参数from-ip，from-port, to-ip, to-port是用来和旧的master和新的master (即旧的slave)通信的
#这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentine1 client-reconfig-script <master-name> <script-path>
sentine1 client-reconfig-script mymaster /var/redis/reconfig. sh
#一般运维来配置

Redis缓存穿透和雪崩

Redis缓存的使用,极大的提升了应用程序的性能和效率,特别是数据查询方面。但同时,它也带来了一-些问题。其中,最要害的问题,就是数据的一致性问题,从严格意义上讲,这个问题无解。如果对数据的一致性要求很高,那么就不能使用缓存。
另外的一些典型问题就是,缓存穿透、缓存雪崩和缓存击穿。目前,业界也都有比较流行的解决方案。

user2谁都没有，他就不停的像Mysql中查询，容易洪水攻击导致崩溃，这就是典型的缓存穿透

缓存穿透

查不到导致的

概念

缓存穿透的概念很简单,用户想要查询一个数据,发现redis内存数据库没有,也就是缓存没有命中,于是向持久层数据库查询。发现也没有,于是本次查询失败。当用户很多的时候,缓存都没有命中,于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透。

解决方案

布隆过滤器

布隆过滤器是一种数据结构 ,对所有可能查询的参数以hash形式存储,在控制层先进行校验,不符合则丢弃,从而避免了对底层存储系统的查询压力;

缓存空对象

当存储层不命中后,即使返回的空对象也将其缓存起来,同时会设置一个过期时间,之后再访问这个数据将会从缓存中获取,保护了后端数据源;

但是这种方法会存在两个问题:
1、如果空值能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键;
2、即使对空值设置了过期时间,还是会存在缓存层和存储层的数据会有一-段时间窗口的不-致,这对于需要保持一致性的业务会有影响。

缓存击穿

量太大 缓存过期

微博服务器宕机(热点词频 60s时宕机，60.1s恢复，0.1s大量请求直接访问mysql，mysql会被击穿)

概述

这里需要注意和缓存击穿的区别,缓存击穿,是指一个key非常热点 ,在不停的扛着大并发,大并发集中对这一个点进行访问 ,当这个key在失效的瞬间,(这个key对应的数据过期了)持续的大并发就穿破缓存,直接请求数据库,就像在一个屏障 上凿开了一个洞。
当某个key在过期的瞬间,有大量的请求并发访问，这类数据一-般是热点数据 ,由于缓存过期,会同时访问数据库来查询最新数据,并且回写缓存,会导使数据库瞬间压力过大。

解决方案

设置热点数据永不过期

从缓存层面来看,没有设置过期时间,所以不会出现热点key过期后产生的问题。

加互斥锁

**分布式锁:**使用分布式锁,保证对于每个key同时只有一个线程去查询后端服务,其他线程没有获得分布式锁的权限,因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁,因此对分布式锁的考验很大。

缓存雪崩

概念

缓存雪崩，是指在某-个时间段,缓存集中过期失效。Redis 宕机!
产生雪崩的原因之一 ,比如马上就要到双十二零点,很快就会迎来一波抢购,这波商品时间比较集中的放入了缓存,假设缓存一个小时。那么到了凌晨一-点钟的时候 ,这批商品的缓存就都过期了。而对这批商品的访问查询,都落到了数据库
上,对于数据库而言,就会产生周期性的压力波峰。于是所有的请求都会达到存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况。

**缓存集中过期,倒不是非常致命,**比较致命的缓存雪崩,是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩,一定是在某个时间段集中创建缓存, 这个时候,数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机,对数据库服务器造成的压力是不可预知的,很有可能瞬间就把数据库压垮。

解决方案

Redis高可用

这个思想的含义是,既然redis有可能挂掉,那我多增设几台redis ,这样一台挂掉之后其他的还可以继续工作 ,其实就是搭建的集群。(异地多活)

限流降级

这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。

数据预热

数据加热的含义就是在正式部署之前,我先把可能的数据先预先访问- -遍 ,这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key ,设置不同的过期时间,让缓存失效的时间点尽量均匀。

上面有些内容没有涉及到，至于选举算法，布隆过滤等等还有解决方案我会在另一个Redis的博客中写