redis，python操作哨兵，python操作集群，缓存优化，缓存击穿，穿透，雪崩

python操作哨兵

高可用架构后》不能直接连接某一个主库》主库可能会挂掉，后来他就不是主库了

之前的连接redis操作就不能用了

import redis
conn=redis.Redis(host='',port=6379)
conn.set()
conn.close()

新的连接哨兵的操作

连接哨兵服务器（主机名也可以用做域名）

配置文件

# redis-server配置文件
port 6379
daemonize yes
bind 0.0.0.0
logfile "redis_sentinel.log"

port 6380
daemonize yes
bind 0.0.0.0
logfile "redis_sentinel.log"
replicaof 10.0.0.200 6379
replica-read-only yes


port 6381
daemonize yes
bind 0.0.0.0
logfile "redis_sentinel.log"
replicaof 10.0.0.200 6379
replica-read-only yes

# 哨兵配置文件

port 26379
daemonize yes
dir "/root/redis-6.2.9/data"
bind 0.0.0.0
logfile "redis_sentinel.log"
sentinel monitor mymaster 10.0.0.200 6379 2


port 26380
daemonize yes
dir "/root/redis-6.2.9/data1"
bind 0.0.0.0
logfile "redis_sentinel.log"
sentinel monitor mymaster 10.0.0.200 6379 2


port 26381
daemonize yes
dir "/root/redis-6.2.9/data2"
bind 0.0.0.0
logfile "redis_sentinel.log"
sentinel monitor mymaster 10.0.0.200 6379 2

#开启redis主从
./src/redis-server ./conf/redis_6379.conf 
./src/redis-server ./conf/redis_6380.conf 
./src/redis-server ./conf/redis_6381.conf 

# 开启哨兵
./src/redis-sentinel ./conf/redis_26379.conf 
./src/redis-sentinel ./conf/redis_26381.conf 
./src/redis-sentinel ./conf/redis_26380.conf 

python操作哨兵

import redis
from redis import Sentinel

sentine = Sentinel([
    ('10.0.0.200', 26379),
    ('10.0.0.200', 26380),
    ('10.0.0.200', 26381)
], socket_timeout=5)

print(sentine)
master = sentine.discover_master('mymaster')
print(master)

"""
('10.0.0.200', 6379)
[('10.0.0.200', 6381), ('10.0.0.200', 6380)]
"""

读写分离

获取主服务器进行写入

# 获取主库
master = sentine.master_for('mymaster')
# 获取一个从库
slave = sentine.slave_for('mymaster')
master.set('name','lqz')
print(slave.get('name'))

注意：要写机器的ip地址，不要写127.0.0.1，想在公网用，python要是再内网中使用，要写内网的ip

python操作集群

redis集群搭建

节点（某一台机器），meet（节点跟节点之间通过meet通信），指派操（16384个槽分给几个节点），复制（主从复制），高可用（主节点挂掉，从节点顶上）

第一步准备6台机器，写6个配置文件

port 7000
daemonize yes
bind 0.0.0.0
dir "/root/redis/data/"
logfile "7000.log"
protected-mode no

cluster-enabled yes
cluster-node-timeout 15000
cluster-config-file nodes-7000.conf
cluster-require-full-coverage yes

第二步：快速复制6个配置问题，并修改配置文件

快速生成其他配置

sed 's/7000/7001/g' redis_7000.conf > redis_7001.conf
sed 's/7000/7002/g' redis_7000.conf > redis_7002.conf
sed 's/7000/7003/g' redis_7000.conf > redis_7003.conf
sed 's/7000/7004/g' redis_7000.conf > redis_7004.conf
sed 's/7000/7005/g' redis_7000.conf > redis_7005.conf

第三步：启动6个redis服务

./src/redis-server ./conf/redis_7000.conf
./src/redis-server ./conf/redis_7001.conf
./src/redis-server ./conf/redis_7002.conf
./src/redis-server ./conf/redis_7003.conf
./src/redis-server ./conf/redis_7004.conf
./src/redis-server ./conf/redis_7005.conf


# 查看运行状态
ps -ef|grep redis

第四步：

./src/redis-cli --cluster create --cluster-replicas 1 10.0.0.200:7000 10.0.0.200:7001 10.0.0.200:7002 10.0.0.200:7003 10.0.0.200:7004 10.0.0.200:7005

第五步：

redis-cli -p 7000 cluster info
redis-cli -p 7000 cluster nodes
redis-cli -p 7000 cluster slots # 查看槽的信息

第六步：测试，存数据

./src/redis-cli -p 7000 -c

一旦搭建了集群，python操作也变了

集群扩容，缩容

1.2 集群扩容

#1 准备两台机器
sed 's/7000/7006/g' redis-7000.conf > redis-7006.conf
sed 's/7000/7007/g' redis-7000.conf > redis-7007.conf
#2 启动两台机器
./src/redis-server ./redis-7006.conf
./src/redis-server ./redis-7007.conf

# 3 两台机器加入到集群中去
./src/redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000
./src/redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7000
        
# 4 让7007复制7006
./src/redis-cli -p 7007 cluster replicate baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a
        
# 5 迁移槽
./src/redis-cli --cluster reshard 127.0.0.1:7000 
    -迁移4096个槽
    -7006的机器接收槽
    -all

1.3 集群缩容

# 第一步：下线迁槽（把7006的1366个槽迁移到7000上）
redis-cli --cluster reshard --cluster-from baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a --cluster-to 050bfd3608514d4db5d2ce5411ef5989bbe50867 --cluster-slots 1365 127.0.0.1:7000
yes

redis-cli --cluster reshard --cluster-from baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a --cluster-to 9cb2a9b8c2e7b63347a9787896803c0954e65b40 --cluster-slots 1366 127.0.0.1:7001
yes

redis-cli --cluster reshard --cluster-from baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a --cluster-to d3aea3d0b4cf90f58252cf3bcd89530943f52d36 --cluster-slots 1366 127.0.0.1:7002
yes


#第二步：下线节点 忘记节点，关闭节点
./src/redis-cli --cluster del-node 127.0.0.1:7000 9c2abbfaa4d1fb94b74df04ce2b481512e6edbf3 # 先下从，再下主，因为先下主会触发故障转移
./src/redis-cli --cluster del-node 127.0.0.1:7000 baf261f2e6cb2b0359d25420b3ddc3d1b8d3bb5a

# 第三步：关掉其中一个主，另一个从立马变成主顶上， 重启停止的主，发现变成了从

安装模块rediscluster

pip3 install redis-py-cluster

操作代码

from rediscluster import RedisCluster
startup_nodes = [{"host":"10.0.0.200", "port": "7000"},{"host":"10.0.0.200", "port": "7001"},{"host":"10.0.0.200", "port": "7002"}]
# rc = RedisCluster(startup_nodes=startup_nodes,decode_responses=True)
rc = RedisCluster(startup_nodes=startup_nodes)
# rc.set("xxx", "bar")
print(rc.get("xxx"))

缓存优化

redis缓存更新策略

redis本身，内存存储，会出现内存不够用，放数据放不进去，有些策略，删除一部分数据，在放新的

LRU/LFU/FIFO算法剔除：例如maxmemory-policy(到了最大内存，对应的应对策略)

LRU -Least Recently Used,没有被使用时间最长的

LFU -Least Frequenty Used,一定时间段内使用次数最少的

FIFO -First In FIrst OUt 先进先出（队列）

缓存击穿，雪崩，穿透

缓存穿透

缓存穿透式指缓存和数据库中都没有的数据，而用户不断发起请求，这时的用户很可能是攻击者，攻击者会导致数据库压力过大

解决方案：

1.接口层增加校验

2.从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null,缓存时间可以设置短点。

3.布隆过滤器实现

缓存击穿

缓存击穿是指缓存中没有但数据有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读取缓存没读取到数据，又同时去数据库取数据，引起数据库压力瞬间增大，造成过大压力

解决方案：

设置热点数据永远不过期

缓存雪崩

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机，和缓存击穿不同的是缓存击穿指并发查询同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

解决方案：

1.缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。

2.如果缓存数据库是分布式部署，将热点数据均匀分布再不同的缓存数据库中

3.设置热点数据永远不过期