DAY 104 redis高级02

es
rabbitmq，python中实现rpc
mongodb
mysql主从
django读写分离
cmdb
分库分表（mycat）
redis分布式锁
分布式id生成
​
​
1 redis持久化

1.1 rdb方案

快照：某时某刻数据的一个完成备份
    -mysql的Dump
    -redis的RDB
写日志：任何操作记录日志，要恢复数据，只要把日志重新走一遍即可
    -mysql的 Binlog
    -Redis的 AOF
    
    
# rdb:快照方案
    -save   # 在客户端输入（同步）
    -bgsave # 异步（后台持久化）
    -配置文件
    save   900        1
    save   300        10
    save   60         10000
    # 解释
    如果60s中改变了1w条数据，自动生成rdb
    如果300s中改变了10条数据，自动生成rdb
    如果900s中改变了1条数据，自动生成rdb
    以上三条符合任意一条，就自动生成rdb，内部使用bgsave

1.2 aof方案

# 1 客户端每写入一条命令，都记录一条日志，放到日志文件中，如果出现宕机，可以将数据完全恢复
​
# 2 aof的三种策略
日志不是直接写到硬盘上，而是先放在缓冲区，缓冲区根据一些策略，写到硬盘上
always：redis–》写命令刷新的缓冲区—》每条命令fsync到硬盘—》AOF文件
everysec（默认值）：redis——》写命令刷新的缓冲区—》每秒把缓冲区fsync到硬盘–》AOF文件
no:redis——》写命令刷新的缓冲区—》操作系统决定，缓冲区fsync到硬盘–》AOF文件
    
    
# 3 AOF重写
本质就是把过期的，无用的，重复的，可以优化的命令，来优化
这样可以减少磁盘占用量，加速恢复速度
​
# aof持久化+aof重写策略开启的配置
appendonly yes #将该选项设置为yes，打开
appendfilename "appendonly.aof" #文件保存的名字
appendfsync everysec #采用第二种策略
dir /bigdiskpath #存放的路径
no-appendfsync-on-rewrite yes #在aof重写的时候，是否要做aof的append操作，因为aof重写消耗性能，磁盘消耗，正常aof写磁盘有一定的冲突，这段期间的数据，允许丢失
    
    
    
#####  rdb和aof都开启了，以aof为准，rdb就不加载了
    

 

2 主从复制

​
### 原理
1. 副本库通过slaveof 127.0.0.1 6379命令,连接主库,并发送SYNC给主库 
2. 主库收到SYNC,会立即触发BGSAVE,后台保存RDB,发送给副本库
3. 副本库接收后会应用RDB快照
4. 主库会陆续将中间产生的新的操作,保存并发送给副本库
5. 到此,我们主复制集就正常工作了
6. 再此以后,主库只要发生新的操作,都会以命令传播的形式自动发送给副本库.
7. 所有复制相关信息,从info信息中都可以查到.即使重启任何节点,他的主从关系依然都在.
8. 如果发生主从关系断开时,从库数据没有任何损坏,在下次重连之后,从库发送PSYNC给主库
9. 主库只会将从库缺失部分的数据同步给从库应用,达到快速恢复主从的目的
​
​
## 主库是否要开启持久化
如果不开有可能，主库重启操作，造成所有主从数据丢失！
​
​
## 配置方案有两种
第一通过命令：（启动两个redis实例），临时的，重启失效
在从库上敲： 
slaveof 127.0.0.1 6379  # 建立主从关系
​
slaveof no one # 取消主从关系
​
​
第二通过配置文件
slaveof 127.0.0.1 6379
slave-read-only yes
# 如果主库开启了密码认证，从库需要加
# 主库
requirepass 123456
# 从库
masterauth 123456

 

2.3 django使用多redis

from django.core.cache import cache
from django.core.cache import caches
import random
def muti_cache(request):
    #res_key=cache.get('res_key')
    res_key=caches['redis'].get('res_key')
    #res_key=caches['default'].get('res_key')
    if not res_key:
        res_key = random.randint(0,100)
        cache.set('res_key','cache_key', 300)

 

3 哨兵高可用

# 原理
1 多个sentinel发现并确认master有问题
2 选举触一个sentinel作为领导
3 选取一个slave作为新的master
4 通知其余slave成为新的master的slave
5 通知客户端主从变化
6 等待老的master复活成为新master的slave
​
​
# sentinel是一个特殊的服务端，启动也需要配置文件
​
# 配置（三个哨兵配置文件）
​
port 26379
daemonize yes
dir /opt/soft/redis/data
logfile "redis_sentinel_26379.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
​
port 26380
daemonize yes
dir /opt/soft/redis/data
logfile "redis_sentinel_26380.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
​
port 26381
daemonize yes
dir /opt/soft/redis/data
logfile "redis_sentinel_26381.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 redis_sentinel_26379.conf
./src/redis-sentinel redis_sentinel_26380.conf
./src/redis-sentinel redis_sentinel_26381.conf
​
## 提前搭好一主两从

 

python操作redis哨兵

import redis
from redis.sentinel import Sentinel
​
# 连接哨兵服务器(主机名也可以用域名)
# 10.0.0.101:26379
sentinel = Sentinel([('101.133.225.166', 26379),
                     ('101.133.225.166', 26380),
                     ('101.133.225.166', 26381)
             ],
                    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=5)
#
# print(type(master))
# # print(master)
# w_ret = master.set('foo', 'bar')
​
slave = sentinel.slave_for('mymaster', socket_timeout=0.5)
print(slave)
r_ret = slave.get('foo')
# print(r_ret)