linux项目部署学习(4)

6.redis

五大数据类型

具体参考 https://www.cnblogs.com/hanfe1/p/12759299.html

• string 字符串类型 set name zy
• hash 哈希类型 hset key field value
• set 无序集合
• zset 有序集合
• list 双向队列，向左插入数据，向右插入数据

redis安全启动与配置文件

1.redis如何安装？
	rpm包
	yum自动化安装装，在阿里云的仓库中，redis包可能旧一点	
	源代码编译安装

redis是内存性数据库，断电，数据丢失，进程重启，数据丢失

得配置redis的数据持久化，防止数据丢失。

reids支持数据备份，也就是master-slave模式,读写分离，防止单点故障，数据丢失。

1.yunm install redis -y 
2.修改redis.conf配置文件，用yum安装的redis，默认配置文件在/etc/redis.conf 打开如下参数即可

bind 127.0.0.1 ::1  #绑定reids的启动地址
port 6500  #默认6379
requirepass zzy  #redis密码 
protected-mode yes #默认打开安全模式
daemonize yes  #后台运行redis服务端的参数

3.启动redis服务端
[root@VM-0-6-centos ~]# redis-server /etc/redis.conf  #指定配置文件启动
[root@VM-0-6-centos ~]# ps -ef | grep redis
root     10410     1  0 11:55 ?        00:00:00 redis-server 127.0.0.1:6500
4.链接redis服务端，指定ip，port 密码
-p 指定端口
-h 指定ip地址
-a auth，密码验证
[root@VM-0-6-centos ~]# redis-cli -p 6500 
127.0.0.1:6500> auth zzy
OK
127.0.0.1:6500> 
127.0.0.1:6500> set name hai
OK
127.0.0.1:6500> keys *
1) "name"
127.0.0.1:6500> get name
"hai"
#或者这样进入redis客户端
[root@VM-0-6-centos ~]# redis-cli -p 6500 -a zzy

#清空reids
127.0.0.1:6500> FLUSHDB
OK
127.0.0.1:6500> FLUSHALL
OK

redis的功能解析

(venv1) [root@VM-0-6-centos data]# redis-
redis-benchmark #压测
redis-check-aof #检查aof文件
redis-check-rdb #检查rdb文件
redis-cli  #客户端
redis-sentinel #哨兵
redis-server #服务端

redis的数据持久化之RDB机制

redis提供了RDB持久化的功能，这个功能可以将redis在内存中的的状态保存到硬盘中，它可以手动执行。

也可以再redis.conf中配置，定期执行。

RDB持久化产生的RDB文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis可以通过这个文件还原数据库当时的状态。

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

rdb配置参数：
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

redis持久化之RDB实践

1.启动redis服务端,准备配置文件

daemonize yes
port 6500
logfile /data/6500/redis.log
dir /data/6500              #定义持久化文件存储位置
dbfilename  dbmp.rdb        #rdb持久化文件
bind 0.0.0.0    #redis绑定地址
requirepass zzy            #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 zzy

4.通过save触发持久化，将数据写入RDB文件

127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> save
OK

5.此时检查目录，/data/6379底下没有dbmp.rdb文件

数据持久化之AOF机制

AOF（append-only log file）
记录服务器执行的所有变更操作命令（例如set del等），并在服务器启动时，通过重新执行这些命令来还原数据集(如果这个文件被删除，数据也就丢失了。)
AOF 文件中的命令全部以redis协议的格式保存，新命令追加到文件末尾。
优点：最大程序保证数据不丢
缺点：日志记录非常大

配置参数

AOF持久化配置，两条参数

appendonly yes
appendfsync  always    总是修改类的操作
             everysec   每秒做一次持久化  #企业中一般用这个每秒
             no     依赖于系统自带的缓存大小机制

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

daemonize yes
port 6500
logfile /data/6500/redis.log
dir /data/6500
dbfilename  dbmp.rdb
requirepass zzy
save 900 1
save 300 10
save 60  10000
appendonly yes
appendfsync everysec

2.启动redis服务

[root@VM-0-6-centos etc]# redis-server /etc/redis_aof.conf 

3.检查redis数据目录/data/6500/是否产生了aof文件

[root@VM-0-6-centos 6500]# ls -rlt 
total 12
-rw-r--r-- 1 root root   93 Jun 30 12:30 dbmp.rdb
-rw-r--r-- 1 root root    0 Jun 30 12:32 appendonly.aof
-rw-r--r-- 1 root root 4723 Jun 30 12:32 redis.log

4.登录redis-cli，写入数据，实时检查aof文件信息

[root@VM-0-6-centos 6500]# tailf appendonly.aof 
*2
$6
SELECT
$1
0
*3
$3
set
$4
name
$2
zz

5.设置新key，检查aof信息，然后关闭redis，检查数据是否持久化

[root@VM-0-6-centos etc]# pkill redis
[root@VM-0-6-centos etc]# redis-server /etc/redis_aof.conf 
[root@VM-0-6-centos etc]# redis-cli -p 6500                
127.0.0.1:6500> keys *
(error) NOAUTH Authentication required.
127.0.0.1:6500> AUTH zzy
OK
127.0.0.1:6500> keys *
1) "name"
127.0.0.1:6500> get name
"zz"

redis 持久化方式有哪些？有什么区别？

 rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于rdb持久化功能
 aof：以追加的方式记录redis操作日志的文件。可以最大程度的保证redis数据安全，类似于mysql的binlog

redis不重启，切换RDB备份到AOF备份方法：

参考：https://www.cnblogs.com/pyyu/p/10061526.html

redis的db0-db15的概念

redis有没有什么方法使不同的应用程序数据彼此分开同时又存储在相同的实例上呢？就相当于mysql数据库，不同的应用程序数据存储在不同的数据库下。

redis下，数据库是由一个整数索引标识，而不是由一个数据库名称。默认情况下，一个客户端连接到数据库0。redis配置文件中下面的参数来控制数据库总数：

/etc/redis.conf 配置中默认是16个库
databases 16

可以通过下面的命令来切换到不同的数据库下

127.0.0.1:6500[1]> select 0
OK
127.0.0.1:6500> select 1
OK
127.0.0.1:6500[1]> select 15
OK
127.0.0.1:6500[15]> 

随后，所有的命令将使用数据库15，知道你明确的切换到另一个数据库下。

每个数据库都有属于自己的空间，不必担心之间的key冲突。

不同的数据库下，相同的key取到各自的值。

flushdb命令清除数据，只会清除当前的数据库下的数据，不会影响到其他数据库。

flushall命令会清除这个实例的数据。在执行这个命令前要格外小心。

redis数据主从同步复制

原理：

1. 从服务器向主服务器发送 SYNC 命令。
2. 接到 SYNC 命令的主服务器会调用BGSAVE 命令，创建一个 RDB 文件，并使用缓冲区记录接下来执行的所有写命令。
3. 当主服务器执行完 BGSAVE 命令时，它会向从服务器发送 RDB 文件，而从服务器则会接收并载入这个文件。
4. 主服务器将缓冲区储存的所有写命令发送给从服务器执行。

1、在开启主从复制的时候，使用的是RDB方式的，同步主从数据的
2、同步开始之后，通过主库命令传播的方式，主动的复制方式实现
3、2.8以后实现PSYNC的机制，实现断线重连

在一台机器上运行2个以上的redis，是redis支持多实例功能，基于端口号的不同，就能够运行多个相互独立的redis数据库。

基于配置文件区别，在机器上运行多个独立的redis进程，互不干扰

如图是redis的多实例功能，且配置主从同步的图（主：可读可写，从：可读）

可以配置程序的读写分离，读从库，写的时候写主库，减轻主库压力

测试环境准备：

6380.conf

1、环境：
准备两个或两个以上redis实例

mkdir /data/638{0..2}  #创建6380 6381 6382文件夹

配置文件示例：
vim   /data/6380/redis.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

6381.conf

vim   /data/6381/redis.conf
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  #配置文件中配置主从复制关系 永久生效

6382.conf

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

启动三个redis实例

redis-server /data/6380/redis.conf
redis-server /data/6381/redis.conf
redis-server /data/6382/redis.conf

主从规划

主节点：6380
从节点：6381、6382

配置主从同步

6381/6382命令行 这里只是暂时生效，想永久生效在配置文件中配置即可

redis-cli -p 6381 SLAVEOF 127.0.0.1 6380 #指明主的地址

redis-cli -p 6382 SLAVEOF 127.0.0.1 6380 #指明主的地址

检查主从状态

从库：

[root@VM-0-6-centos data]# redis-cli -p 6381 info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up  #链接上了
master_last_io_seconds_ago:3
master_sync_in_progress:0
slave_repl_offset:29
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

主库：显示有两个从库

[root@VM-0-6-centos data]# redis-cli -p 6380 info replication       
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=155,lag=0
slave1:ip=127.0.0.1,port=6382,state=online,offset=155,lag=0
master_repl_offset:155
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:154

redis一主多从，主从复制故障切换

懒的画图了，摘的图

一、主库挂了，选择一个备库当master，当之前的主库修复后，让他当从库即可。

#关闭主库6380
redis-cli -p 6380 shutdown
或者ps -ef 找到进程 kill -9 

检查从库主从信息，此时master_link_status:down

redis-cli -p 6381 info replication
redis-cli -p 6382 info replication

既然主库挂了，我想要在6381 6382之间选一个新的主库

1.关闭6381的从库身份

redis-cli -p 6381 slaveof no one

2.将6382设为6381的从库

6382连接到6381：
[root@db03 ~]# redis-cli -p 6382
127.0.0.1:6382> SLAVEOF no one
127.0.0.1:6382> SLAVEOF 127.0.0.1 6381

3.检查6382，6381的主从信息

二、主库不挂，从库挂掉的场景

从库挂掉，无所谓，从新找个从库即可。

redis命令整理

#查看redis的数据库信息
redis-cli -p 6382 info  #查看所有的数据库信息
redis-cli -p 6382 info server  #查看server
redis-cli -p 6382 info replication #查看redis的复制授权信息
redis-cli -p 6382 info sentinel   #查看redis的哨兵信息

redis高可用哨兵 - 应用在主从故障处理

参考：https://www.cnblogs.com/pyyu/p/9718679.html

哨兵的工作原理（Redis-Sentinel） 只是监控着主库挂没挂

配置好redis的哨兵进程，一般都是使用3个哨兵
哨兵的作用是盯着redis主库，不断的询问他是否存活，如果超过30s(设定的阈值)都没有回应，3个哨兵会判断主库宕机，谈话进行投票机制，因为3个哨兵要自动去选择从库成为新的主库，每个哨兵意见不一样，因此引出投票机制，少数服从多数。
当多个哨兵达成一致，选择某一个从库，自动的修改他们的配置文件，切换为新的主库
此时如果宕机的主库恢复后，哨兵也会自动加入集群，分配为从库。
这些都是自动化，无需任务干预的！

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的监控目标会随之调换

安装与配置

本实验是在测试环境下，考虑到学生机器较弱，因此只准备一台linux服务器用作环境！！

redis复用上面的6380/6381/6382

主 6380 
从 6381 6382
kill上面的redis进程，重启3个redis实例

(venv1) [root@VM-0-6-centos /]# redis-server /data/6380/redis.conf
(venv1) [root@VM-0-6-centos /]# redis-server /data/6381/redis.conf
(venv1) [root@VM-0-6-centos /]# redis-server /data/6382/redis.conf
(venv1) [root@VM-0-6-centos /]# 
(venv1) [root@VM-0-6-centos /]# 
(venv1) [root@VM-0-6-centos /]# ps -ef |grep redis
root     14047     1  0 11:15 ?        00:00:00 redis-server *:6380
root     14051     1  0 11:15 ?        00:00:00 redis-server *:6381
root     14058     1  0 11:15 ?        00:00:00 redis-server *:6382

主从信息

(venv1) [root@VM-0-6-centos /]# redis-cli -p 6380 info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=99,lag=0
slave1:ip=127.0.0.1,port=6382,state=online,offset=99,lag=1
master_repl_offset:99
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:98
(venv1) [root@VM-0-6-centos /]# redis-cli -p 6381 info replication 
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up
master_last_io_seconds_ago:4
master_sync_in_progress:0
slave_repl_offset:113
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
(venv1) [root@VM-0-6-centos /]# redis-cli -p 6382 info replication 
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up
master_last_io_seconds_ago:8
master_sync_in_progress:0
slave_repl_offset:113
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
(venv1) [root@VM-0-6-centos /]# 
#此时可以在master上写入数据，在slave上查看数据，此时主从复制配置完成

开始配置Redis Sentinel 哨兵

vi redis-sentinel-26380.conf
// Sentinel节点的端口
port 26380
dir /var/redis/data/
logfile "26380.log"

// 当前Sentinel节点监控 :6380 这个主节点              
// 2代表判断主节点失败至少需要2个Sentinel节点节点同意
// mymaster是主节点的别名
sentinel monitor mymaster 127.0.0.1 6380 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

###简洁版    只有port 26381/26382不一样，其他参数不用改！！！！！！！！只监控主库
port 26380
dir /var/redis/data/
logfile "26380.log"
sentinel monitor mymaster 127.0.0.1 6380 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1	
sentinel failover-timeout mymaster 180000
daemonize yes

redis-sentinel-26381.conf和redis-sentinel-26382.conf的配置仅仅差异是port(端口)的不同。然后启动三个sentinel哨兵

启动哨兵

mkdir -p /var/redis/data/
redis-sentinel /data/s_sentinel/redis-sentinel-26380.conf
redis-sentinel /data/s_sentinel/redis-sentinel-26381.conf
redis-sentinel /data/s_sentinel/redis-sentinel-26382.conf

此时查看哨兵是否成功通信

(venv1) [root@VM-0-6-centos data]# redis-cli -p 26380  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=127.0.0.1:6380,slaves=2,sentinels=3
        
#看到最后一条信息正确即成功了哨兵，哨兵主节点名字叫做mymaster，状态ok，监控地址是127.0.0.1:6380，有两个从节点，3个哨兵

此时模拟6380挂了

kill -9 6380进程号

看结果 6382是主库了，6381是从库

(venv1) [root@VM-0-6-centos data]# redis-cli -p 6382  info replication 
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=5519,lag=0
master_repl_offset:5519
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:5518
(venv1) [root@VM-0-6-centos data]# redis-cli -p 6381  info replication  
# Replication
role:slave
master_host:127.0.0.1
master_port:6382
master_link_status:up
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_repl_offset:7528
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

在把旧的主库起来（宕机恢复） ：看这是6380成为从库

redis-server /data/6380/redis.conf

(venv1) [root@VM-0-6-centos data]# redis-cli -p 6380  info replication 
# Replication
role:master
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
(venv1) [root@VM-0-6-centos data]# redis-cli -p 6380  info replication 
# Replication
role:slave
master_host:127.0.0.1
master_port:6382
master_link_status:up
master_last_io_seconds_ago:0
master_sync_in_progress:0
slave_repl_offset:25366
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

redis集群 （cluster）

参考：https://www.cnblogs.com/pyyu/p/9844093.html