【python操作哨兵】

 1  1 redis的主从，一主多从
 2  2 高可用：sentinal:哨兵
 3     多个哨兵：配置文件---》监控我们主从状态--》当发现主库--》故障转移
 4  3 python如何操作哨兵
 5 
 6 
 7 ---------------------------------------------------------------------------------------
 8 import redis
 9 from redis.sentinel import Sentinel
10 
11 # 连接哨兵服务器(主机名也可以用域名)
12 # 10.0.0.101:26379
13 sentinel = Sentinel([('10.0.0.101', 26379),
14                      ('10.0.0.101', 26380),
15                      ('10.0.0.101', 26381)],socket_timeout=5)
16 
17 # print(sentinel)
18 # 获取主服务器地址
19  master = sentinel.discover_master('mymaster')
20  print(master)
21 
22 # 获取从
23  slave = sentinel.discover_slaves('mymaster')
24  print(slave)
25 
26 # 往主库中写入
27  master = sentinel.master_for('mymaster', socket_timeout=0.5,password='654321')
28  w_ret = master.set('foo', 'bar')
29 
30 
31 # 从从库读
32 slave = sentinel.slave_for('mymaster', socket_timeout=0.5,password='654321')
33 print(slave.client().connection_pool)
34 # from redis.client import Redis
35 r_ret = slave.get('foo')
36 print(r_ret)

。

。

【集群】

（集群原理）

 1 # 1 存在问题 
 2     1 并发量：单机redis qps为10w/s,但是我们可能需要百万级别的并发量
 3     2 数据量：机器内存16g--256g，如果存500g数据呢？
 4 
 5 # 2 使用集群解决上述问题
 6 
 7 # 3 数据分布（分布式数据库）---》集群方案
 8     -分区方式
 9         -哈希分布 数据分散度高，建值分布与业务无关，无法顺序访问，支持批量操作    一致性哈希memcache，redis cluster，其他缓存产品
10         -顺序分布    数据分散度易倾斜，建值业务相关，可顺序访问，支持批量操作    BigTable，HBase
11 
12 # 问题：mysql 集群分区方案是什么？
13     mysql 官方早期是不支持集群的---》出了很多第三方方案--》官方有集群方案
14     -可以顺序
15     -可以hash
16 # 4 顺序分区
17     原理：100个数据分到3个节点上 1--33第一个节点；34--66第二个节点；67--100第三个节点（很多关系型数据库使用此种方式）
18   
19 # 5 hash分区
20     - 节点取余分区：
21         -把key通过hash运算后，对节点个数取余--》决定数据存在哪个节点
22         -扩容--》需要迁移数据量很大
23         -推荐翻倍扩容
24         
25     - 一致性哈希分区
26         -客户端分片：哈希+顺时针（优化取余）
27         节点伸缩：只影响临近节点，但是还有数据迁移的情况
28         伸缩：保证最小迁移数据和无法保证负载均衡（这样总共5个节点，数据就不均匀了），翻倍扩容可以实现负载均衡
29     
30     - 虚拟槽分区 ：redis使用此种方式
31         预设虚拟槽：每个槽映射一个数据子集，一般比节点数大
32         良好的哈希函数：如CRC16
33         服务端管理节点、槽、数据：如redis cluster（槽的范围0–16383）
34         5个节点，把16384个槽平均分配到每个节点，客户端会把数据发送给任意一个节点，通过CRC16对key进行哈希对16383进行取余，算出当前key属于哪部分槽，属于哪个节点，每个节点都会记录是不是负责这部分槽，如果是负责的，进行保存，如果槽不在自己范围内，redis cluster是共享消息的模式，它知道哪个节点负责哪些槽，返回结果，让客户端找对应的节点去存
35 服务端管理节点，槽，关系

（搭建redis集群）

1 # 为什么redis的虚拟槽是16384个？
2     在 Redis 集群中，Redis 根据公式 HASH_SLOT=CRC16(key) mod 16384 ，来确定客户端的 key 映射到哪个分片上，然后 Redis 会去相应节点进行操作。然而，CRC16 算法最多可产生 65535 个槽位，但是 Redis 的取模 是16384 ，主要基于如下两个原因：
3 
4 Redis 节点在发送心跳数据包时需要将所有槽都放入到这个心跳包里，如果采用 16384 个插槽，占用空间为 2KB（16384/8）;如果采用 65536 个插槽，占空间 8KB （65536/8）。8KB 的心跳数据有点儿大。
5 Redis Cluster 不太可能扩展到超过 1000 个节点，太多会导致网络拥堵。选择 16384 ，照样可以确保每个主节点都有足够的槽。
6 所以，选择 16384 既可以保证集群中每个节点都有足够的槽，又能保证心跳数据包不会过

方式：

  1 3个节点搭建步骤
  2 
  3 # 第一步：写6个redis配置文件
  4 # vi redis-7000.conf
  5 port 7000
  6 daemonize yes
  7 dir "/root/redis/data/"
  8 logfile "7000.log"
  9 dbfilename "dump-7000.rdb"
 10 
 11 cluster-enabled yes
 12 cluster-config-file nodes-7000.conf
 13 cluster-require-full-coverage yes 
 14 
 15 # 第二步：快速生成剩余5个配置文件
 16 sed 's/7000/7001/g' redis-7000.conf > redis-7001.conf
 17 sed 's/7000/7002/g' redis-7000.conf > redis-7002.conf
 18 sed 's/7000/7003/g' redis-7000.conf > redis-7003.conf
 19 sed 's/7000/7004/g' redis-7000.conf > redis-7004.conf
 20 sed 's/7000/7005/g' redis-7000.conf > redis-7005.conf
 21 
 22 # 第三步；启动6个节点
 23 redis-server ./redis-7000.conf
 24 redis-server ./redis-7001.conf
 25 redis-server ./redis-7002.conf
 26 redis-server ./redis-7003.conf
 27 redis-server ./redis-7004.conf
 28 redis-server ./redis-7005.conf
 29 
 30 # 查看集群信息
 31 cluster info
 32 cluster nodes
 33 
 34 # 第四步：搭建集群  
 35 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
 36 # yes  同意
 37 
 38 # 第五步：测试
 39     往 7000 上写 set name lqz 这个数据，写不进去
 40     原因是：name被hash后，得到的槽不归 7000管[0--5460槽]
 41     返回给我们错误，让我们去7001上写，顺利写进去
 42     
 43 # 第六步：查看机器信息
 44     cluster nodes
 45     cluster info
 46     
 47 # 第六步：集群模式连接--->自动切换到不同节点
 48      redis-cli -p 7000 -c 
 49 
 50 # 第七：停掉一个主---》原来的从会升级为主
 51 
 52 # 第八步：python操作redis集群
 53 # pip3 install redis-py-cluster
 54 
 55 from rediscluster import RedisCluster
 56 startup_nodes = [{"host":"127.0.0.1", "port": "7005"},{"host":"127.0.0.1", "port": "7001"},{"host":"127.0.0.1", "port": "7002"}]
 57 rc = RedisCluster(startup_nodes=startup_nodes)
 58 rc.set("foo", "bar")
 59 print(rc.get("foo"))
 60 
 61 
 62 ===============================================
 63 扩容
 64 
 65 #1 准备两台机器
 66 sed 's/7000/7006/g' redis-7000.conf > redis-7006.conf
 67 sed 's/7000/7007/g' redis-7000.conf > redis-7007.conf
 68 #2 启动两台机器
 69 redis-server ./redis-7006.conf
 70 redis-server ./redis-7007.conf
 71 
 72 # 3 两台机器加入到集群中去
 73 redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000
 74 redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7000
 75         
 76 # 4 让7007复制7006
 77 redis-cli -p 7007 cluster replicate 2bab67072c1b1f95cf6e3cb79e8cd29cd5b147f9
 78         
 79 # 5 迁移槽
 80 redis-cli --cluster reshard 127.0.0.1:7000
 81     -迁移4096个槽   16384/4
 82     -7006的机器接收槽
 83     -all
 84 
 85 ================================================
 86 缩容
 87 
 88 # 第一步：下线迁槽（把7006的1366个槽迁移到7000上）
 89 redis-cli --cluster reshard --cluster-from 2bab67072c1b1f95cf6e3cb79e8cd29cd5b147f9 --cluster-to 65cc604cdcb4ecf1566dc1182e6f25b276589d20 --cluster-slots 1365 127.0.0.1:7000
 90 yes
 91 
 92 redis-cli --cluster reshard --cluster-from 2bab67072c1b1f95cf6e3cb79e8cd29cd5b147f9 --cluster-to 25652d07d3da463255f6f794b61f156e8015f6cb --cluster-slots 1366 127.0.0.1:7001
 93 yes
 94 
 95 redis-cli --cluster reshard --cluster-from 2bab67072c1b1f95cf6e3cb79e8cd29cd5b147f9 --cluster-to de4ad907904bda3c12ddadbf69533d34a0ff31f2 --cluster-slots 1365 127.0.0.1:7002
 96 yes
 97 
 98 
 99 #第二步：下线节点 忘记节点，关闭节点
100 redis-cli --cluster del-node 127.0.0.1:7000 2bab67072c1b1f95cf6e3cb79e8cd29cd5b147f9 # 先下从，再下主，因为先下主会触发故障转移
101 redis-cli --cluster del-node 127.0.0.1:7000 842d379b428100880ed5414cd9816df2cda02d3a
102 
103 # 第三步：关掉其中一个主，另一个从立马变成主顶上， 重启停止的主，发现变成了从

 。

。

【缓存优化】

缓存更新策略

1 # LRU/LFU/FIFO算法剔除：例如maxmemory-policy(到了最大内存，对应的应对策略)
2 
3 LRU -Least Recently Used,没有被使用时间最长的
4 
5 LFU -Least Frequenty Use,一定时间段内使用次数最少的
6 
7 FIFO -First In First Out,先进先出

缓存穿透，缓存击穿，缓存雪崩

 1 ###  缓存穿透
 2 #描述：
 3 缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。
 4 #解决方案：
 5 1 接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
 6 2 从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击
 7 3 通过布隆过滤器实现
 8 
 9 
10 ### 缓存击穿
11 #描述：
12 缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力
13 #解决方案：
14 设置热点数据永远不过期。
15 
16  
17 ### 缓存雪崩
18 #描述：
19 缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，        缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。
20 # 解决方案：
21 1 缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
22 2 如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
23 3 设置热点数据永远不过期。
24 
25 
26 
27 # 跳跃表
28     有序集合 内部存储的数据结构