redis数据库在linux上的学习

1.redis安装方式

        yum安装（提前配置好yum源）
    yum install  redis -y  
源代码编译安装

rpm包手动安装
    

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

        3.编译三部曲 
    指定安装路径 ，生成makefile 编译文件 
        ./configure --prefix=redis的安装路径
    开始编译
        make
    编译安装
        make install  
    编译完成后，默认生成可使用的redis命令
        /usr/local/bin/redis-server     
4.修改redis的配置文件，支持更安全的启动方式
    redis.conf 
    
#打开redis密码的参数
    requirepass aoligei
#开启安全模式
    protected-mode yes
#修改redis的默认启动端口，以及绑定地址
    bind 0.0.0.0
    port 6379
#守护进程方式
daemonize  yes
    

redis的基本配置

        #过滤出非空行，注释行的内容，重定向写入到一个文件中
 grep  -v "^$"  redis.conf |grep  -v "^#"  > s24redis.conf
#在配置文件结尾加上后台启动参数
daemonize  yes

5.启动redis服务端
 redis-server s24redis.conf 

6.验证redis是否启动
    netstat -tunlp |grep  redis
    ps -ef|grep redis 
    
7.指定密码登录redis
    [root@s24_linux ~]# redis-cli -p 6800
    127.0.0.1:6800> ping
    (error) NOAUTH Authentication required.
    127.0.0.1:6800> auth aoligei  #登录  输入密码
    OK
    127.0.0.1:6800> 
    127.0.0.1:6800> 
    127.0.0.1:6800> ping
    PONG
    127.0.0.1:6800> keys *
    1) "chaoge"
    127.0.0.1:6800> get chaoge
    "zhenshuai"
        
8.redis常用命令学习
    

redis的五大数据类型

字符串（string）
散列（hash）
列表（list）
集合（set）
有序集合（zset）

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的数量

9.redis的字符串string使用命令

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

10.list双向队列用法

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

11.set集合类型，天然去重

sadd/srem 添加/删除 元素
sismember 判断是否为set的一个元素
smembers 返回集合所有的成员
sdiff 返回一个集合和其他集合的差异
sinter 返回几个集合的交集
sunion 返回几个集合的并集

12.zset有序集合,去重排序

zset的每一个成员都有一个分数与之对应，并且分数是可以重复的。有序集合的增删改由于有啦排序，执行效率就是非常快速的，即便是访问集合中间的数据也是非常高效的。

用来保存需要排序的数据，例如排行榜，成绩，工资等。

实例

利用有序集合的排序，排序学生的成绩

        127.0.0.1:6379> ZADD mid_test 70 "alex"
(integer) 1
127.0.0.1:6379> ZADD mid_test 80 "wusir"
(integer) 1
127.0.0.1:6379> ZADD mid_test 99 "yuyu"
    

排行榜，zreverange 倒叙 zrange正序

        127.0.0.1:6379> ZREVRANGE mid_test 0 -1 withscores
1) "yuyu"
2) "99"
3) "wusir"
4) "80"
5) "xiaofneg"
6) "75"
7) "alex"
8) "70"
127.0.0.1:6379> ZRANGE mid_test 0 -1 withscores
1) "alex"
2) "70"
3) "xiaofneg"
4) "75"
5) "wusir"
6) "80"
7) "yuyu"
8) "99"
    

移除有序集合mid_test中的成员，xiaofeng给移除掉

        127.0.0.1:6379> ZREM mid_test xiaofneg
(integer) 1
127.0.0.1:6379> ZRANGE mid_test 0 -1 withscores
1) "alex"
2) "70"
3) "wusir"
4) "80"
5) "yuyu"
6) "99"
    

zcard返回有序集合mid_test的基数

        127.0.0.1:6379> ZCARD mid_test
(integer) 3
    

zscore 返回成员的score值

        127.0.0.1:6379> ZSCORE mid_test alex
"70"
    

zrank返回有序集合中，成员的排名。默认按score，从小到大排序,从0开始。

        127.0.0.1:6379> ZRANGE mid_test 0 -1 withscores
1) "alex"
2) "70"
3) "wusir"
4) "80"
5) "yuyu"
6) "99"
127.0.0.1:6379> ZRANK mid_test wusir
(integer) 1
127.0.0.1:6379> ZRANK mid_test yuyu
(integer) 2
    

12.redis哈希类型（字典类型）

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

key -field1 -value1
-field 2 - value2
-field 3 - value3

redis的key

stu1 name changxin
age 8
weight 300
height 180

redis的持久化存储

rdb机制

RDB持久化产生的RDB文件是一个经过压缩的二进制文件

redis持久化之rdb机制，创建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  #60秒之后有10000个修改就会存储


    

创建数据文件夹

mkdir -p /data/6379

指定rdb文件启动redis

redis-server s24rdbredis.conf

AOF方式

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

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

修改配置文件如下
touch s24aof.conf
写入如下内容

        daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
appendonly yes           #开启aof的俩参数
appendfsync everysec     #aof的持久化机制 
    

        #appendfsync 的参数
always    总是修改类的操作
everysec   每秒做一次持久化
no     依赖于系统自带的缓存大小机制
    

指定aof文件启动redis

redis-server s24aof.conf

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

1.准备一个rdb的redis数据库
2.通过命令，直接切换aof

        127.0.0.1:6379> CONFIG set appendonly yes   #开启AOF功能
OK
127.0.0.1:6379> CONFIG SET save ""  #关闭RDB功能
OK
    

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

4.还得修改配置文件，以上命令只是临时生效，改完以后，下次指定配置文件启动，就一直是aof了

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

redis的主从复制

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

redis的主从复制，做一个一主三从的实验

        mredis.conf   #主库的配置文件
port 6380
bind 0.0.0.0
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no

    

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

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

    

创建三个数据库的数据文件夹

mkdir -p /data/{6380,6381,6382}

分别启动三个数据库实例

        [root@s24_linux myredis]# redis-server mredis.conf 
[root@s24_linux myredis]# redis-server s1redis.conf 
[root@s24_linux myredis]# redis-server s2redis.conf 
[root@s24_linux 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

    

分别查看三个redis数据库的库信息

        [root@s24_linux myredis]# redis-cli -p 6380 info replication 
[root@s24_linux myredis]# redis-cli -p 6381 info replication 
[root@s24_linux myredis]# redis-cli -p 6382 info replication 

    

通过命令，临时给三个数据库添加主从复制信息

        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可读可写
6381 6382只读，不给写

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

杀死主库，必须得手动解决故障，把从库切换为新的主库，继续主从复制

只需要剔除当前自己的从的身份即可，剔除6381的从的身份
127.0.0.1:6381> slaveof no one
OK

再次启动一个新的从库，以6381为主库即可

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

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

        [root@s24_linux 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@s24_linux 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@s24_linux 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数据库节点

redis哨兵机制

2.准备三个哨兵sentinel(哨兵)的配置文件，三个哨兵配置文件，仅仅是端口的不同，默认是26379,26380,26381
s24shaobing.conf

        port 26379  
dir /var/redis/data/
logfile "26379.log"
// 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
// 2代表判断主节点失败至少需要2个Sentinel节点节点同意
// s24ms是主节点的别名
sentinel monitor s24ms 127.0.0.1  6380  2

//每个Sentinel节点都要定期PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30000毫秒30s且没有回复，则判定不可达
sentinel down-after-milliseconds s24ms 30000

//当Sentinel节点集合对主节点故障判定达成一致时，Sentinel领导者节点会做故障转移操作，选出新的主节点，
原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为1
sentinel parallel-syncs s24ms 1

//故障转移超时时间为180000毫秒
sentinel failover-timeout s24ms 180000
//后台运行哨兵 
daemonize yes 
    

s24shaobing1.conf
s24shaobing2.conf

快速生成2个配置文件

[root@s24_linux myredis]# sed ‘s/26379/26380/g‘ s24shaobing.conf > s24shaobing1.conf
[root@s24_linux myredis]# sed ‘s/26379/26381/g‘ s24shaobing.conf > s24shaobing2.conf

创建数据文件夹

mkdir -p /var/redis/data/

3.分别启动三个哨兵进程

redis-sentinel s24shaobing.conf

redis-sentinel s24shaobing1.conf

redis-sentinel s24shaobing2.conf

[root@s24_linux 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.将挂掉的主库，重新启动，查看复制信息

redis-cluster集群的搭建

1.准备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/7005/g‘ redis-7000.conf > redis-7005.conf

分别启动6个redis节点

2.配置ruby环境，一键创建redis机群slot槽位分配
yum直接安装ruby解释器
yum install ruby -y
下载ruby操作redis的模块
wget http://rubygems.org/downloads/redis-3.3.0.gem
gem install -l redis-3.3.0.gem
一键开启redis集群槽位分配，先找一下这个ruby工具在哪
find / -name redis-trib.rb

        /s24fuxi/redis-4.0.10/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-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
    

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

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

原文：https://www.cnblogs.com/ciquankun/p/12096989.html