redis---高级

1. redis发布订阅

1.1 发布订阅的命令

PUBLISH channel msg
    将信息 message 发送到指定的频道 channel
    
SUBSCRIBE channel [channel ...]
    订阅频道，可以同时订阅多个频道
    
UNSUBSCRIBE [channel ...]
    取消订阅指定的频道, 如果不指定频道，则会取消订阅所有频道
    
PSUBSCRIBE pattern [pattern ...]
    订阅一个或多个符合给定模式的频道，每个模式以 * 作为匹配符，
    比如 it* 匹配所    有以 it 开头的频道( it.news 、 it.blog 、 it.tweets 等等)， news.* 匹配所有  
    以 news. 开头的频道( news.it 、 news.global.today 等等)，诸如此类
    
PUNSUBSCRIBE [pattern [pattern ...]]
    退订指定的规则, 如果没有参数则会退订所有规则
    
PUBSUB subcommand [argument [argument ...]]
    查看订阅与发布系统状态
    
注意：使用发布订阅模式实现的消息队列，当有客户端订阅channel后只能收到后续发布到该频道的消息，之前发送的不会缓存，必须Provider和Consumer同时在线。

2. 持久化

2.1 介绍

• Redis是一种内存型数据库，一旦服务器进程退出，数据库的数据就会丢失，
• 为了解决这个问题，Redis提供了两种持久化的方案，将内存中的数据保存到磁盘中，避免数据的丢失。

• rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于rdb持久化功能

• aof：以追加的方式记录redis操作日志的文件。可以最大程度的保证redis数据安全，类似于mysql的binlog

2.2 RDB持久化

2.2.1 介绍

• redis提供了RDB持久化的功能，这个功能可以将redis在内存中的的状态保存到硬盘中，它可以手动执行。
• 也可以再redis.conf中配置，定期执行。
• RDB持久化产生的RDB文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis可以通过这个文件还原数据库当时的状态。

2.2.2 RDB配置

RDB(持久化)
内存数据保存到磁盘
在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）
优点：速度快，适合做备份，主从复制就是基于RDB持久化功能实现
rdb通过再redis中使用save命令触发 rdb
rab 配置

dir /data/6379/  #
dbfilename  dbmp.rdb
每过900秒 # 有1个操作就进行持久化
save 900秒  # 1个修改类的操作
save 300秒  # 10个操作
save 60秒  # 10000个操作
save  900 1
save 300 10
save 60  10000

2.2.3 案例

1.启动redis服务端,准备配置文件,需要创建一个文件夹/data/6379 

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379              #定义持久化文件存储位置
dbfilename  dbmp.rdb        #rdb持久化文件
bind 10.0.0.10  127.0.0.1    #redis绑定地址
requirepass redhat            #redis登录密码
save 900 1                    #rdb机制 每900秒 有1个修改记录
save 300 10                    #每300秒        10个修改记录
save 60  10000                #每60秒内        10000修改记录

2.启动redis服务端
3.登录redis设置一个key
redis-cli -a redhat
4.此时检查目录，/data/6379底下没有dbmp.rdb文件
5.通过save触发持久化，将数据写入RDB文件
127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> save
OK
5.测试kill redis 在重新以配置文件启动，发现数不会丢 

2. 3 AOF

2.3.1 介绍

• rdb有缺点，可能会造成数据丢失，但是持久化速度最快
• AOF（append-only log file）
• 记录服务器执行的所有变更操作命令（例如set del等），并在服务器启动时，通过重新执行这些命令来还原数据集
• AOF 文件中的命令全部以redis协议的格式保存，新命令追加到文件末尾。
• 优点：最大程序保证数据不丢
• 缺点：日志记录非常大

2.3.2 配置

AOF持久化配置，两条参数
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379              #定义持久化文件存储位置
appendonly yes
appendfsync  always    总是修改类的操作(一般默认是它)
             everysec   每秒做一次持久化
             no     依赖于系统自带的缓存大小机制

2.3.3 案例

1.准备aof配置文件 redis.conf

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
requirepass redhat
appendonly yes
appendfsync everysec

2.启动redis服务
redis-server /etc/redis.conf

3.检查redis数据目录/data/6379/是否产生了aof文件
[root@web02 6379]# ls
appendonly.aof  dbmp.rdb  redis.log

4.登录redis-cli，写入数据，实时检查aof文件信息
[root@web02 6379]# tail -f appendonly.aof

5.设置新key，检查aof信息，然后关闭redis，检查数据是否持久化
redis-cli -a redhat shutdown
redis-server /etc/redis.conf
redis-cli -a redhat

3. RDB持久化切换AOF持久化

3.1 环境准备

确保redis版本在2.2以上
本文在redis4.0中，通过config set命令，达到不重启redis服务，从RDB持久化切换为AOF

3.2 实验环境准备

# 1.redis.conf服务端配置文件 
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename  dbmp.rdb
save 900 1                    #rdb机制 每900秒 有1个修改记录
save 300 10                    #每300秒        10个修改记录
save 60  10000                #每60秒内        10000修改记录
# 2.启动redis服务端
redis-server redis.conf
# 3.登录redis-cli插入数据，手动持久化
127.0.0.1:6379> set name chaoge
OK
127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> set addr shahe
OK
127.0.0.1:6379> save
OK
# 4.检查RDB文件
[root@pyyuc /data 22:34:16]#ls 6379/
dbmp.rdb  redis.log
# 5.备份这个rdb文件，保证数据安全
[root@pyyuc /data/6379 22:35:38]#cp dbmp.rdb /opt/
# 6.执行命令，开启AOF持久化
127.0.0.1:6379> CONFIG set appendonly yes   #开启AOF功能
OK
127.0.0.1:6379> CONFIG SET save ""  #关闭RDB功能
OK
# 7.确保数据库的key数量正确
127.0.0.1:6379> keys *
1) "addr"
2) "age"
3) "name"
# 8.确保插入新的key，AOF文件会记录
127.0.0.1:6379> set title golang
OK
# 9.此时RDB已经正确切换AOF，注意还得修改redis.conf添加AOF设置，不然重启后，通过config set的配置将丢失
appendonly yes
appendfsync  always    总是修改类的操作

4. 主从同步

4.2 案例

redis的主从同步功能
主从同步，读写分离的功能，redis.conf配置文件中定义的
1.redis支持多实例的功能，通过配置文件生效，多实例的概念Ⅰ写多个配置文件，指定文件启动，端口区分数据库，就是多实例了
2. 创建文件夹
存配置文件
mkdir /data/638{0..2}  #创建6380 6381 6382文件夹
存数据记录  dir /data/6380
mkdir /data/638{0..2}  
4.配置文件示例：
vim   /data/6380/redis.conf
# redis-6379.conf  主库
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no

# redis-6380. conf 从库1
port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
protected-mode no
slaveof 127.0.0.1 6380 # 指明主的地址

# redis-6381.conf  从库2
port 6382
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
protected-mode no
slaveof 127.0.0.1 6380 # 指明主的地址

# 5.启动redis
redis-server /data/6380/redis.conf
redis-server /data/6381/redis.conf
redis-server /data/6382/redis.conf
# 6.检查主从状态
从库：
127.0.0.1:6382> info replication
127.0.0.1:6381> info replication
主库：
127.0.0.1:6380> info replication

4.3 redis主从复制故障修复

#redis的主从复制故障修复(这个是临时生效，永久需要到配置文件中修改配置)
1.手动杀死主库
kill 主库pid
2.选择一个从库为新的主库，例如6380是主，6381是从 
127.o.o.1:6380>slaveof no one
oK
3.去登录6381从库
127.0.0.1:6381> slalveof 127.0.0.1 6380
OK

5. redis哨兵高可用

5.1 介绍redis-Sentinel

Redis-Sentinel是redis官方推荐的高可用性解决方案，
当用redis作master-slave的高可用时，如果master本身宕机，redis本身或者客户端都没有实现主从切换的功能。
而redis-sentinel就是一个独立运行的进程，用于监控多个master-slave集群，
自动发现master宕机，进行自动切换slave > master。

sentinel主要功能如下：
不时的监控redis是否良好运行，如果节点不可达就会对节点进行下线标识
如果被标识的是主节点，sentinel就会和其他的sentinel节点“协商”，如果其他节点也人为主节点不可达，就会选举一个sentinel节点来完成自动故障转义
在master-slave进行切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换

Redis-sentinel工作机制：
每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令
如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线。
如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。
当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线
在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令
当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次
若没有足够数量的 Sentinel 同意 Master 已经下线， Master 的客观下线状态就会被移除。
若 Master 重新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。
主观下线和客观下线
主观下线：Subjectively Down，简称 SDOWN，指的是当前 Sentinel 实例对某个redis服务器做出的下线判断。
客观下线：Objectively Down， 简称 ODOWN，指的是多个 Sentinel 实例在对Master Server做出 SDOWN 判断，并且通过 SENTINEL is-master-down-by-addr 命令互相交流之后，得出的Master Server下线判断，然后开启failover.
SDOWN适合于Master和Slave，只要一个 Sentinel 发现Master进入了ODOWN， 这个 Sentinel 就可能会被其他 Sentinel 推选出， 并对下线的主服务器执行自动故障迁移操作。
ODOWN只适用于Master，对于Slave的 Redis 实例，Sentinel 在将它们判断为下线前不需要进行协商， 所以Slave的 Sentinel 永远不会达到ODOWN。

5.2 环境准备

redis高可用之哨兵功能1.配置redis-sentinel环境准备

三个redis实例，准备一主两从的架构

# 主节点master的redis-6379.conf

port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/var/redis/data/"
# 从节点slave的redis-6380.conf

port 6380
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/var/redis/data/" 
slaveof 127.0.0.1 6379      // 从属主节点

# 从节点slave的redis-6381.conf

port 6381
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/var/redis/data/" 
slaveof 127.0.0.1 6379      // 从属主节点


# 根据需求创建文件夹
mkdir /...
# 启动redis主节点
redis-server /etc/redis-6379.conf
# 启动两slave节点
# 6379为master，6380和6381为slave
redis-server /etc/redis-6380.conf
redis-server /etc/redis-6381.conf
# 验证从节点的redis服务
[root@master  ~]$redis-cli   -p 6380 ping
PONG
[root@master  ~]$redis-cli   -p 6381 ping
PONG
# 检测主从关系
在主节点上查看主从通信关系
redis-cli  -p 6379 info replication
在从节点上查看主从关系（6380、6379）
redis-cli  -p 6380 info replication


# 三个redis-sentinel配置文件,运行三个哨兵进程

# 配置redis sentinel环境
redis-sentinel-26379.conf配置文件写入如下信息
# 介绍
redis-sentinel-26379.conf redis-sentinel-26380.conf redis-sentinel-26381.conf 的配置仅仅差异是port(端口)的不同。

// Sentinel节点的端口
port 26379  
dir /var/redis/data/
logfile "26379.log"
// 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
// 2代表判断主节点失败至少需要2个Sentinel节点节点同意 
// mymaster是主节点的别名  名称以及ip根据需求修改，如果是一台机器IP(127.0.0.1) 2--至少2台哨兵同意
sentinel monitor mymaster 192.168.119.10 6379 2
//每个Sentinel节点都要定期PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30000毫秒30s且没有回复，则判定不可达
sentinel down-after-milliseconds mymaster 30000
//当Sentinel节点集合对主节点故障判定达成一致时，Sentinel领导者节点会做故障转移操作，选出新的主节点，
原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为1
sentinel parallel-syncs mymaster 1
//故障转移超时时间为180000毫秒
sentinel failover-timeout mymaster 180000
# 后台运行
daemonize yes

# 根据需求创建数据文件夹
# 然后启动三个sentinel哨兵
redis-sentinel /etc/redis-sentinel-26379.conf
redis-sentinel /etc/redis-sentinel-26380.conf
redis-sentinel /etc/redis-sentinel-26381.conf
# 此时查看哨兵是否成功通信
redis-cli -p 26379  info sentinel

# Sentinel信息
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=mymaster,status=ok,address=192.168.119.10:6379,slaves=2,sentinels=3
#看到最后一条信息正确即成功了哨兵，哨兵主节点名字叫做mymaster，状态ok，监控地址是192.168.119.10:6379，有两个从节点，3个哨兵

5.3 redis高可用故障实验

大致思路

杀掉主节点的redis进程6379端口，观察从节点是否会进行新的master选举，进行切换
重新恢复旧的“master”节点，查看此时的redis身份

首先查看三个redis的进程状态
ps -ef|grep redis

检查三个节点的复制身份状态
 redis-cli -p 6381 info replication
 redis-cli -p 6380 info replication
 redis-cli -p 6379 info replication
此时，干掉master！！！然后等待其他两个节点是否能自动被哨兵sentienl，切换为master节点
ps -ef|grep 6380   #干掉master进程
稍等片刻之后，发现slave节点成为master节点！！
redis-cli -p 6379 info replication

5.4 redis集群

步骤一、通过配置，redis.conf开启redis-cluster

• redis支持多实例的功能，我们在单机演示集群搭建，需要6个实例，三个是主节点，三个是从节点，数量为6个节点才能保证高可用的集群。
• 每个节点仅仅是端口运行的不同！

• [root@yugo /opt/redis/config 17:12:30]#ls
  redis-7000.conf  redis-7002.conf  redis-7004.conf
  redis-7001.conf  redis-7003.conf  redis-7005.conf
  #确保每个配置文件中的端口修改！！

port 7000
daemonize yes
dir "/opt/redis/data"
logfile "7000.log"
dbfilename "dump-7000.rdb"
cluster-enabled yes   #开启集群模式
cluster-config-file nodes-7000.conf　　#集群内部的配置文件
cluster-require-full-coverage no　　#redis cluster需要16384个slot都正常的时候才能对外提供服务，换句话说，只要任何一个slot异常那么整个cluster不对外提供服务。 因此生产环境一般为no

步骤二、运行redis实例

• 创建6个节点的redis实例

1855  2018-10-24 15:46:01 redis-server redis-7000.conf
 1856  2018-10-24 15:46:13 redis-server redis-7001.conf
 1857  2018-10-24 15:46:16 redis-server redis-7002.conf
 1858  2018-10-24 15:46:18 redis-server redis-7003.conf
 1859  2018-10-24 15:46:20 redis-server redis-7004.conf
 1860  2018-10-24 15:46:23 redis-server redis-7005.conf



redis-server redis-7000.conf
redis-server redis-7001.conf
redis-server redis-7002.conf
redis-server redis-7003.conf
redis-server redis-7004.conf
redis-server redis-7005.conf

步骤3、开启redis-cluster

1. 下载、编译、安装Ruby
2. 安装rubygem redis
3. 安装redis-trib.rb命令

第一步、安装ruby

#下载ruby源码包
wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
#解压缩ruby源码包
tar -zxvf ruby-2.3.1.tar.gz
#编译且安装
./configure --prefix=/opt/ruby/
make && make install

第二步、配置ruby环境变量

vim /etc/profile
写入如下配置
PATH=$PATH:/opt/ruby/bin

第三步、安装ruby操作redis包

wget http://rubygems.org/downloads/redis-3.3.0.gem
gem install -l redis-3.3.0.gem

第四部、安装redis-trib.rb命令

[root@yugo /opt/redis/src 18:38:13]#cp /opt/redis/src/redis-trib.rb /usr/local/bin/

一键开启redis-cluster集群

#每个主节点，有一个从节点，代表--replicas 1
redis-trib.rb create --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
#集群自动分配主从关系  7000、7001、7002为 7003、7004、7005 主动关系

查看集群状态

redis-cli -p 7000 cluster info  
redis-cli -p 7000 cluster nodes  #等同于查看nodes-7000.conf文件节点信息
集群主节点状态
redis-cli -p 7000 cluster nodes | grep master
集群从节点状态
redis-cli -p 7000 cluster nodes | grep slave

写入redis-cluster集群数据

安装完毕后，检查集群状态

[root@yugo /opt/redis/src 18:42:14]#redis-cli -p 7000 cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:10468
cluster_stats_messages_pong_sent:10558
cluster_stats_messages_sent:21026
cluster_stats_messages_ping_received:10553
cluster_stats_messages_pong_received:10468
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:21026

测试写入集群数据，登录集群必须使用redis-cli -c -p 7000必须加上-c参数

127.0.0.1:7000> set name chao     
-> Redirected to slot [5798] located at 127.0.0.1:7001       
OK
127.0.0.1:7001> exit
[root@yugo /opt/redis/src 18:46:07]#redis-cli -c -p 7000
127.0.0.1:7000> ping
PONG
127.0.0.1:7000> keys *
(empty list or set)
127.0.0.1:7000> get name
-> Redirected to slot [5798] located at 127.0.0.1:7001
"chao"

redis-python api

1、对redis的单实例进行连接操作
python3
>>>import redis
>>>r = redis.StrictRedis(host='localhost', port=6379, db=0,password='root')
>>>r.set('lufei', 'guojialei')
True
>>>r.get('lufei')
'bar'
--------------------
2、sentinel集群连接并操作
[root@db01 ~]# redis-server /data/6380/redis.conf
[root@db01 ~]# redis-server /data/6381/redis.conf
[root@db01 ~]# redis-server /data/6382/redis.conf 
[root@db01 ~]# redis-sentinel /data/26380/sentinel.conf &
--------------------------------
## 导入redis sentinel包
>>> from redis.sentinel import Sentinel  
##指定sentinel的地址和端口号
>>> sentinel = Sentinel([('localhost', 26380)], socket_timeout=0.1)  
##测试，获取以下主库和从库的信息
>>> sentinel.discover_master('mymaster')  
>>> sentinel.discover_slaves('mymaster')  
##配置读写分离
#写节点
>>> master = sentinel.master_for('mymaster', socket_timeout=0.1)  
#读节点
>>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)  
###读写分离测试   key     
>>> master.set('oldboy', '123')  
>>> slave.get('oldboy')  
'123'
----------------------
redis cluster的连接并操作（python2.7.2以上版本才支持redis cluster，我们选择的是3.5）
https://github.com/Grokzen/redis-py-cluster
3、python连接rediscluster集群测试
使用
python3
>>> from rediscluster import StrictRedisCluster  
>>> startup_nodes = [{"host": "127.0.0.1", "port": "7000"}]  
### Note: decode_responses must be set to True when used with python3  
>>> rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)  
>>> rc.set("foo", "bar")  
True  
>>>   
'bar'