Linux07 /redis的配置、五大数据类型、发布订阅、持久化、主从复制、哨兵配置、集群搭建

Linux07 /redis的配置、五大数据类型、发布订阅、持久化、主从复制、哨兵配置、集群搭建

1. redis的安装/启动

redis的安装方式：

1.yum安装（提前配置好yum源）
2.源代码编译安装
3.rpm包手动安装

编译安装redis

1.下载redis源代码包
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
    
2.解压缩redis源码包
tar -zxvf redis-4.0.10.tar.gz

3.编译三部曲 
    第一步：指定安装路径 ，生成makefile 编译文件 
    ./configure --prefix=redis的安装路径
    第二步：开始编译
    make
    第三步：编译安装
    make install  
    编译完成后，默认生成可使用的redis命令
    /usr/local/bin/redis-server
    
# 安装包会有所不同，有的只需要执行后面两步或者最后一步

修改redis的配置文件，支持更安全的启动方式

文件名：redis.conf 
		
# 打开redis密码的参数
requirepass abc
# 开启安全模式
protected-mode yes
# 修改redis的默认启动端口，以及绑定地址
bind 0.0.0.0
port 6800
# 在配置文件结尾加上后台启动参数
daemonize  yes

# 过滤出非空行，注释行的内容，重定向写入到一个文件中
grep  -v "^$"  redis.conf |grep  -v "^#"  > redis.conf

启动redis服务端

# 启动服务端
redis-server redis.conf

# 验证redis是否启动
netstat -tunlp |grep  redis
ps -ef|grep redis

指定密码登录redis

[root@localhost ~]# redis-cli -p 6800 
127.0.0.1:6800> ping
(error) NOAUTH Authentication required. 
127.0.0.1:6800> auth abc
OK
127.0.0.1:6800> ping
PONG
127.0.0.1:6800> keys *
1) "name"
127.0.0.1:6800> get name
"zhangsan"

2. redis的五大数据类型、常用命令

redis的五大数据类型

字符串（strings）
散列（hashes）
列表（lists）
集合（sets）
有序集合（sorted sets）

常用命令（整体操作，不限制数据类型）

keys *               # 查看所有key
type key             # 查看key类型
expire key seconds   # 过期时间
ttl key              # 查看key过期剩余时间，-2表示key已经不存在了
persist              # 取消key的过期时间，-1表示key存在，没有过期时间
exists key           # 判断key存在，存在返回1、否则0
del keys             # 删除key，可以删除多个
dbsize               # 计算key的数量

字符串(strings)常用命令

set 　　   # 设置key
get       # 获取key
append    # 追加string
mset      # 设置多个键值对
mget      # 获取多个键值对
del       # 删除key
incr      # 递增+1
decr      # 递减-1

示例：

# 设置key
127.0.0.1:6379> set name 'zhangsan'   
OK
# 获取value
127.0.0.1:6379> get name　　　　
"zhangsan"
# 覆盖key
127.0.0.1:6379> set name 'lisi'　　
OK
# 获取value
127.0.0.1:6379> get name　　　　
"lisi"
# 追加key的string
127.0.0.1:6379> append name 'heihei' 　　
(integer) 10
# 获取value
127.0.0.1:6379> get name　　
"heihei"

# 设置多个键值对
127.0.0.1:6379> mset user1 'zhangsan' user2 'lisi'   
OK
# 获取value
127.0.0.1:6379> get user1　　　　
"zhangsan"
# 获取value
127.0.0.1:6379> get user2　　　　
"lisi"
# 找到所有key
127.0.0.1:6379> keys *　　　　　　
1) "user2"
2) "name"
3) "user1"

# 获取多个value
127.0.0.1:6379> mget user1 user2 name   
1) "zhangsan"
2) "lisi"
3) "lisiheihei"
# 删除key
127.0.0.1:6379> del name　  
(integer) 1
# 获取不存在的value，为nil
127.0.0.1:6379> get name　　
(nil)
# string类型实际上不仅仅包括字符串类型，还包括整型，浮点型。redis可对整个字符串或字符串一部分进行操作，而对于整型/浮点型可进行自增、自减操作。
127.0.0.1:6379> set num 10　　　　
OK　　　　
127.0.0.1:6379> get num
"10"
# 给num string 加一 INCR 命令将字符串值解析成整型，将其加一，最后将结果保存为新的字符串值，可以用作计数器
127.0.0.1:6379> incr num　　　
(integer) 11
127.0.0.1:6379> get num　　
"11"
# 递减1  
127.0.0.1:6379> decr num　　　　
(integer) 10
# 递减1
127.0.0.1:6379> decr num　　　　
(integer) 9
127.0.0.1:6379> get num
"9"

列表(list)常用命令

lpush           # 从列表左边插
rpush           # 从列表右边插
lrange          # 获取一定长度的元素：lrange key  start stop
ltrim           # 截取一定长度列表
lpop            # 删除最左边一个元素
rpop            # 删除最右边一个元素
lpushx/rpushx   # key存在则添加值，不存在不处理

示例：

# 新建一个duilie，从左边放入三个元素
lpush duilie 'zhangsan' 'lisi' 'wangwu' 
# 查看duilie长度
llen duilie  
# 查看duilie所有元素
lrange duilie 0 -1  
# 从右边插入zhaoliu
rpush duilie 'zhaoliu'   
# key存在则添加heihei元素，key不存在则不作处理
lpushx duilie2  'heihei'  
# 截取队列的值，从索引0取到2，删除其余的元素
ltrim duilie 0 2 
# 删除左边的第一个
lpop 
# 删除右边的第一个
rpop

集合(set)常用命令，天然去重

# redis的集合，是一种无序的集合，集合中的元素没有先后顺序

sadd/srem     # 添加/删除元素
sismember     # 判断是否为set的一个元素
smembers      # 返回集合所有的成员
sdiff         # 返回几个集合的差集，显示第一个有的，后几个没有的
sinter        # 返回几个集合的交集
sunion        # 返回几个集合的并集

示例：

# 添加集合，有三个元素，不加引号就当做字符串处理
sadd zoo  zhangsan lisi  
# 查看集合zoo成员
smembers zoo  
# 删除zoo里面的lisi
srem zoo  lisi
# 返回改是否是zoo的成员信息，不存在返回0，存在返回1
sismember zoo zhangsan  
# 再把zhangsan加入zoo
sadd zoo zhangsan
# 查看zoo成员
smembers zoo  
# 添加新集合zoo2
sadd zoo2 zhangsan wangwu 
# 找出集合zoo中有的，而zoo2中没有的元素
sdiff zoo zoo2 
# 找出zoo2中有，而zoo没有的元素
sdiff zoo2  zoo  
# 找出zoo和zoo1的交集，都有的元素
sinter zoo zoo1   
# 找出zoo和zoo1的并集，所有的不重复的元素
sunion  zoo zoo1

有序集合

# 1.都是以z开头的命令
# 2.zset的每一个成员都有一个分数与之对应，并且分数是可以重复的。有序集合的增删改由于有啦排序，执行效率就是非常快速的，即便是访问集合中间的数据也是非常高效的。
# 3.用来保存需要排序的数据，例如排行榜，成绩，工资等。

zadd   # 添加元素
ZREVRANGE mid_test 0 -1 withscores   # 倒叙查看
ZRANGE mid_test 0 -1 withscores      # 正序查看
mid_test     # 移除有序集合中的成员
ZCARD mid_test    # 返回有序集合mid_test的基数
ZSCORE mid_test zhangsan   # 返回成员的score值
ZRANK mid_test zhangsan    # 返回有序集合中，成员的排名

示例：

# 添加元素
ZADD mid_test 70 "alex"
(integer) 1

# 排行榜，zreverange 倒叙   zrange正序
ZREVRANGE mid_test 0 -1 withscores
1) "zhangsan"
2) "99"
3) "lisi"
4) "80"
5) "wangwu"
6) "70"


ZRANGE mid_test 0 -1 withscores
1) "wangwu"
2) "70"
3) "lisi"
4) "80"
5) "zhangsan"
6) "99"

# 移除有序集合mid_test中的成员，zhangsan给移除掉
ZREM mid_test zhangsan
(integer) 1
ZRANGE mid_test 0 -1 withscores
1) "wangwu"
2) "70"
3) "lisi"
4) "80"

# 返回有序集合mid_test的基数
ZCARD mid_test
(integer) 3

# 返回成员的score值
ZSCORE mid_test wangwu
"70"

# zrank返回有序集合中，成员的排名。默认按score，从小到大排序。
ZRANGE mid_test 0 -1 withscores
1) "wangwu"
2) "70"
3) "lisi"
4) "80"

ZRANK mid_test wangwu
(integer) 0
ZRANK mid_test lisi
(integer) 1

哈希类型（字典类型）常用命令

# redis hash是一个string类型的field和value的映射表
# 语法  hset key field value 


hset      # 设置散列值
hget      # 获取散列值
hmset     # 设置多对散列值
hmget     # 获取多对散列值
hsetnx    # 如果散列已经存在，则不设置（防止覆盖key）
hkeys     # 返回所有keys
hvals     # 返回所有values
hlen      # 返回散列包含域（field）的数量
hdel      # 删除散列指定的域（field）
hexists   # 判断是否存在

示例：

# 设置第一条新闻 news的id为1，添加数据title的值是"first news title"
hset news1 title "first news title" 
# 添加一个conntent内容
hset news1 content "news content"    
# 获取news1的标题
hget news1 title   
# 获取news的内容
hget news1  content  
# 获取多对news1的值
hmget news1  title content   
# 设置第二条新闻news2 多个field
hmset news2 title "second news title" content "second Contents2" # 获取news2的多个值 
hmget news2 title  content 
# 获取新闻news1的所有key
hkeys news1   
# 获取新闻news1的所有值
hvals news1   
# 获取新闻news1的长度
hlen news1    
# 删除新闻news1的title
hdel news1 title   
# 看下新闻news1的长度
hlen news1     
# 判断news1中是否有title，不存在返回0，存在返回1
hexists news1 title

3. redis的发布订阅

简单实现

# 1.启动发布者向频道diantai发送消息
[root@localhost ~]# redis-cli
127.0.0.1:6379> PUBLISH diantai
(integer) 2

# 2.启动两个redis-cli窗口、均订阅diantai频道（channel）
[root@localhost ~]# redis-cli
127.0.0.1:6379> SUBSCRIBE diantai 'kaishile'
1) "subscribe"
2) "diantai"
3) (integer) 1

1) "message"
2) "diantai"
3) "kaishile"

[root@localhost ~]# redis-cli
127.0.0.1:6379> SUBSCRIBE diantai 'kaishile'
1) "subscribe"
2) "diantai"
3) (integer) 1

1) "message"
2) "diantai"
3) "kaishile"

订阅一个或者多个符合模式的频道

# 窗口1，发布者消息
[root@localhost ~]# redis-cli
127.0.0.1:6379> PUBLISH wangbaoqiang "jintian zhennanshou "
(integer) 2

# 窗口1，启动两个redis-cli窗口，均订阅 wang*频道（channel）
127.0.0.1:6379> PSUBSCRIBE wang*
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "wang*"
3) (integer) 1


1) "pmessage"
2) "wang*"
3) "wangbaoqiang"
4) "jintian zhennanshou "

# 窗口2，启动redis-cli窗口，均订阅wang*频道
127.0.0.1:6379> PSUBSCRIBE wang*
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "wang*"
3) (integer) 1



1) "pmessage"
2) "wang*"
3) "wangbaoqiang"
4) "jintian zhennanshou "

4. redis的持久化

redis持久化之rdb机制

# 1.创建rdb的配置文件
touch rdbredis.conf
# 写入如下内容：
daemonize yes # 后台运行 
port 6379 	  # 指定端口 
logfile /data/6379/redis.log   # 指定日志路径
dir /data/6379	  # redis的数据文件，会存放在这里
dbfilename  s24dbmp.rdb  # 开启rdb持久化，且指定持久化文件的名字
bind 0.0.0.0
save 900 1 	  #定义触发rdb持久化的时间机制 
save 300 10
save 60  10000 

# 2.创建数据文件夹
mkdir -p /data/6379
 
# 3.指定rdb文件启动redis
redis-server rdbredis.conf

redis持久化之aof方式，以日志形式，把修改类的操作，记录下来

# 1.修改配置文件如下
touch  aofredis.conf 
# 写入如下内容：
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
appendonly yes  		 # 开启aof的俩参数
appendfsync everysec     # aof的持久化机制 

# 2.指定aof文件启动redis
redis-server aofredis.conf 

# 注意：测试时，需要将上面的进程杀掉、删除6379下面的文件

问题：不重启，切换rdb持久化为aof持久化

# 1.准备一个rdb的redis数据库

# 2.通过命令，直接切换aof
CONFIG set appendonly yes  # 开启AOF功能
CONFIG SET save ""         # 关闭RDB功能


# 3.正确情况下，会生成aof日志文件了，此时命令操作都是在aof里面了

# 4.还得修改配置文件，以上命令只是临时生效，改完以后，下次指定配置文件启动，就一直是aof了
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename  dbmp.rdb
save 900 1
save 300 10
save 60  10000
daemonize yes
appendonly yes  
appendfsync everysec

5. redis的主从复制

概念：

redis的主可以读、可以写，redist的从只可以读，不可以写

redis的主从复制，可以基于redis的多实例完成，基于不同的端口，就能运行各个独立的redis数据库

redis主从复制测试：一主三从的测试

# 1.主库的配置文件
mredis.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

# 2.准备一个从库s1redis.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  # 也可以在配置文件中，直接定义，直接启动，默认就是主从复制了


# 3.准备第二个从库s2redis.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  # 也可以在配置文件中，直接定义，直接启动，默认就是主从复制了

# 4.创建三个数据库的数据文件夹
mkdir -p  /data/{6380,6381,6382}

# 5.分别启动三个数据库实例
[root@localhost myredis]# redis-server mredis.conf 
[root@localhost myredis]# redis-server s1redis.conf 
[root@localhost myredis]# redis-server s2redis.conf 
[root@localhost myredis]# ps -ef|grep redis
root      78545      1  0 10:54 ?        00:00:00 redis-server *:6380
root      78550      1  0 10:54 ?        00:00:00 redis-server *:6381
root      78555      1  0 10:54 ?        00:00:00 redis-server *:6382

# 6.分别查看三个redis数据库的库信息
[root@localhost myredis]# redis-cli -p 6380 info replication 
[root@localhost myredis]# redis-cli -p 6381 info replication 
[root@localhost myredis]# redis-cli -p 6382 info replication 


# 7.通过命令，临时给三个数据库添加主从复制信息，也可以在配置文件中，直接定义，直接启动，默认就是主从复制了
redis-cli -p 6381  slaveof 127.0.0.1 6380   #给6381指定为6380的从库
redis-cli -p 6381 info replication 			#查看6381的复制信息
redis-cli -p 6380 info replication			#查看6380的复制信息
redis-cli -p 6382  slaveof 127.0.0.1 6380	#给6382设置为6380的从库
redis-cli -p 6380 info replication

进行主从复制读写演示

# 6380 可以读可以写
127.0.0.1:6380> set name zhangsan
OK
127.0.0.1:6380> get name
"zhangsan"

# 6381 6382  只可以读，不可以写
127.0.0.1:6381> get name
"zhangsan"
127.0.0.1:6381> set age 18
(error) READONLY You can't write against a read only slave.



# 1.杀死从库，无所谓，再把从库重新启动，或者再创建一个新的就行 

# 2.杀死主库，必须得手动解决故障，把从库切换为新的主库，继续主从复制
#   只需要剔除当前自己的从的身份即可，剔除6381的从的身份
#   127.0.0.1:6381> slaveof no one
#   再次启动一个新的从库，以6381为主库即可

6. redis的哨兵配置

概念：redis的哨兵配置，能够自动的解决主从切换故障

哨兵配置实现：

# 1.准备三个redis数据库实例，配置好，主从关系

[root@localhost myredis]# cat mredis.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

[root@localhost myredis]# cat s1redis.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


[root@localhost myredis]# cat s2redis.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数据库节点


# 2.准备三个哨兵sentinel(哨兵)的配置文件，三个哨兵配置文件，仅仅是端口的不同，默认是26379,26380,26381 
文件名:shaobing.conf 
	port 26379  
	dir /var/redis/data/
	logfile "26379.log"

	# 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
	# 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 

shaobing1.conf 
shaobing2.conf 
# 快速生成2个配置文件
[root@localhost myredis]# sed 's/26379/26380/g'   shaobing.conf  > shaobing1.conf
[root@localhost myredis]# sed 's/26379/26381/g'   shaobing.conf  > shaobing2.conf
# 创建数据文件夹
 mkdir -p /var/redis/data/


# 3.分别启动三个哨兵进程
[root@localhost myredis]# redis-sentinel shaobing.conf 
[root@localhost myredis]# redis-sentinel shaobing1.conf 
[root@localhost myredis]# redis-sentinel shaobing2.conf 

[root@localhost myredis]# ps -ef|grep redis
root      78952      1  0 11:42 ?        00:00:00 redis-server *:6380
root      78957      1  0 11:42 ?        00:00:00 redis-server *:6381
root      78963      1  0 11:42 ?        00:00:00 redis-server *:6382
root      79051      1  0 11:51 ?        00:00:00 redis-sentinel *:26379 [sentinel]
root      79056      1  0 11:51 ?        00:00:00 redis-sentinel *:26380 [sentinel]
root      79061      1  0 11:51 ?        00:00:00 redis-sentinel *:26381 [sentinel]


# 4.干掉master主库，哨兵会自动的选举一个从库为新的主库

# 5.将挂掉的主库，重新启动，查看复制信息

7. redis-cluster集群的搭建

测试集群准备

# 准备6个数据库节点，搭建三主三从的数据库主从机群，6个节点，仅仅是端口的不同 
指定7000~7005 6个节点
touch redis-7000.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　　# 集群内部的配置文件

touch redis-7001.conf 
touch redis-7002.conf 
touch redis-7003.conf 
touch redis-7004.conf 
touch redis-7005.conf 

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 

# 创建文件夹
mkdir -p /opt/redis/data

# 分别启动6个redis节点

配置ruby环境，一键创建redis机群slot槽位分配

# 1.yum直接安装ruby解释器
yum install ruby -y  

# 2.下载ruby操作redis的模块
wget http://rubygems.org/downloads/redis-3.3.0.gem      
gem install -l redis-3.3.0.gem

# 3.一键开启redis集群槽位分配，先找一下这个ruby工具在哪
find / -name  redis-trib.rb   

# 4.创建集群
# redis5.0以前版本创建集群方式如下：
/opt/redis-5.0.7/src/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

开启redis集群功能，向集群中写入数据，查看数据重定向

以集群模式登陆redis-cluster ，写入数据

redis-cli -p 7000 -c

# 会自动分配不同应该在的不同的槽位