redis 高级2

1 redis持久化

# 快照：某时某刻数据的一个完成备份，
	-mysql的Dump
    -redis的RDB
# 写日志：任何操作记录日志，要恢复数据，只要把日志重新走一遍即可
	-mysql的 Binlog
    -Redis的 AOF
   

1.1 RDB

# 触发机制-主要三种方式
	-save：客户端执行save命令----》redis服务端----》同步创建RDB二进制文件，如果老的RDB存在，会替换老的
    -bgsave：客户端执行save命令----》redis服务端----》异步创建RDB二进制文件，如果老的RDB存在，会替换老的
    -配置文件
    	save   900        1
        save   300        10
        save   60         10000
        如果60s中改变了1w条数据，自动生成rdb
		如果300s中改变了10条数据，自动生成rdb
		如果900s中改变了1条数据，自动生成rdb
        
	

1.2 aof

# 客户端每写入一条命令，都记录一条日志，放到日志文件中，如果出现宕机，可以将数据完全恢复

#  AOF的三种策略
	always：redis–》写命令刷新的缓冲区—》每条命令fsync到硬盘—》AOF文件
    everysec（默认值）：redis——》写命令刷新的缓冲区—》每秒把缓冲区fsync到硬盘–》AOF文件
    no:redis——》写命令刷新的缓冲区—》操作系统决定，缓冲区fsync到硬盘–》AOF文件

# AOF重写
	-本质：本质就是把过期的，无用的，重复的，可以优化的命令，来优化
    -使用：
    	-在客户端主动输入：bgrewriteaof
        -配置文件：
# AOF持久化配置最优方案
appendonly yes #将该选项设置为yes，打开
appendfilename "appendonly.aof" #文件保存的名字
appendfsync everysec #采用第二种策略
dir ./data #存放的路径
no-appendfsync-on-rewrite yes #在aof重写的时候，是否要做aof的append操作，因为aof重写消耗性能，磁盘消耗，正常aof写磁盘有一定的冲突，这段期间的数据，允许丢失

2 主从复制（一主一从一主多从）

# 原理：

# 如何配置：
	方式一：
    	-在从库执行 SLAVEOF 127.0.0.1 6379，
    	-断开关系 slaveof no one
    方式二：配置文件（配在从库的配置文件中）
    	slaveof 127.0.0.1 6379
		slave-read-only yes

3 哨兵

# 让redis的主从复制高可用
1 搭一个一主两从
#创建三个配置文件：
#第一个是主配置文件
daemonize yes
pidfile /var/run/redis.pid
port 6379
dir "/opt/soft/redis/data"
logfile “6379.log”

#第二个是从配置文件
daemonize yes
pidfile /var/run/redis2.pid
port 6378
dir "/opt/soft/redis/data2"
logfile “6378.log”
slaveof 127.0.0.1 6379
slave-read-only yes
#第三个是从配置文件
daemonize yes
pidfile /var/run/redis3.pid
port 6377
dir "/opt/soft/redis/data3"
logfile “6377.log”
slaveof 127.0.0.1 6379
slave-read-only yes


#把三个redis服务都启动起来
./src/redis-server redis_6379.conf
./src/redis-server redis_6378.conf
./src/redis-server redis_6377.conf


2 搭建哨兵
# sentinel.conf这个文件
# 把哨兵也当成一个redis服务器
创建三个配置文件分别叫sentinel_26379.conf sentinel_26378.conf  sentinel_26377.conf

# 当前路径下创建 data1 data2 data3 个文件夹
#内容如下(需要修改端口，文件地址日志文件名字)
port 26379
daemonize yes
dir ./data3
protected-mode no
bind 0.0.0.0
logfile "redis_sentinel3.log"
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000


#启动三个哨兵
./src/redis-sentinel sentinel_26379.conf
./src/redis-sentinel sentinel_26378.conf
./src/redis-sentinel sentinel_26377.conf



# 登陆哨兵
./src/redis-cli -p 26377
# 输入 info
 
# 查看哨兵的配置文件被修改了，自动生成的

# 主动停掉主redis 6379，哨兵会自动选择一个从库作为主库
redis-cli -p 6379
shutdown
#等待原来的主库启动，该主库会变成从库

客户端连接

import redis
from redis.sentinel import Sentinel

# 连接哨兵服务器(主机名也可以用域名)
# 10.0.0.101:26379
sentinel = Sentinel([('10.0.0.101', 26379),
                     ('10.0.0.101', 26378),
                     ('10.0.0.101', 26377)
		     ],
                    socket_timeout=5)

print(sentinel)
# 获取主服务器地址
master = sentinel.discover_master('mymaster')
print(master)

# 获取从服务器地址
slave = sentinel.discover_slaves('mymaster')
print(slave)



##### 读写分离
# 获取主服务器进行写入
# master = sentinel.master_for('mymaster', socket_timeout=0.5)
# w_ret = master.set('foo', 'bar')

# slave = sentinel.slave_for('mymaster', socket_timeout=0.5)
# r_ret = slave.get('foo')
# print(r_ret)

4 集群

# 集群是3.0以后加的，3.0----5.0之间，ruby脚本，5.0以后，内置了
## 详见博客

redis-cli --cluster create --cluster-replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005


CLUSTER NODES  # 集群节点信息
cluster slots  # 查看槽的信息

redis-cli -p 7007 cluster replicate 16c49dd91001529792f0425b46c6757080125732



redis-cli --cluster reshard --cluster-from 16c49dd91001529792f0425b46c6757080125732 --cluster-to 4ee63c79b7ab594414068099c12668ffc6698dbc --cluster-slots 1366 127.0.0.1:7000

redis-cli --cluster reshard --cluster-from 16c49dd91001529792f0425b46c6757080125732 --cluster-to 4ee63c79b7ab594414068099c12668ffc6698dbc --cluster-slots 1366 127.0.0.1:7000

redis其他

# 1 双写一致性，redis和mysql数据同步，方案
	1 先更新数据库，再更新缓存（一般不用）
	2 先删缓存，再更新数据库（在存数据的时候，请求来了，缓存不是最新的）
	3 先更新数据库，再删缓存（推荐用）
# 2 缓存更新策略
	- LRU/LFU/FIFO算法剔除
    -maxmemory-policy，超过最大内存，新的放不进去了，淘汰策略
    	​ LRU -Least Recently Used,没有被使用时间最长的（保证热点数据）
        ​ LFU -Least Frequenty User,一定时间段内使用次数最少的
        ​ FIFO -First In First Out，先进先出
# 3 如何保证redis中数据是最热的，配置lru的剔除算法
	-配置文件中：maxmemory-policy:volatile-lru
# 4 LFU配置 Redis4.0之后为maxmemory_policy淘汰策略添加了两个LFU模式
	-配置
    	maxmemory-policy:volatile-lfu
    	lfu-log-factor 10
		lfu-decay-time 1
        ># lfu-log-factor可以调整计数器counter的增长速度，lfu-log-factor越大，counter增长的越慢。
        ># lfu-decay-time是一个以分钟为单位的数值，可以调整counter的减少速度
        
        
# 5 缓存粒度控制
	-自由发挥
    
# 6 缓存穿透，缓存击穿，缓存雪崩
    ### 缓存穿透（恶意的）
    #描述：
    缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。
    #解决方案：
    1 接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
    2 从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击
    3 通过布隆过滤器实现，mysql中所有数据都放到布隆过滤器，请求来了，先去布隆过滤器查，如果没有，表示非法，直接返回

    ### 缓存击穿
    #描述：
    缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力
    #解决方案：
    设置热点数据永远不过期。

    ### 缓存雪崩
    #描述：
    缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，        缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。
    # 解决方案：
    1 缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
    2 如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
    3 设置热点数据永远不过期。
    
    
# 8 redis实现布孔过滤器
# 9 python实现布隆过滤器