Linux之redis

目录：
 

 

在linux通过源码编译安装redis
    
1.下载源码包
    wget http://download.redis.io/releases/redis-4.0.10.tar.gz
2.解压缩redis
    tar -zxf redis-4.0.10.tar.gz 
3.进入redis源码，直接可以编译且安装
    make && make install 
    
4.可以指定配置文件启动redis
    vim /opt/redis-4.0.10/redis.conf 
    
    1.更改该文件中的bind参数，让redis可以远程访问
        bind 0.0.0.0
    2.更改该文件中的redis的默认端口
        port 6380
    3.设置该文件中的redis的密码，登录时则需要该密码
        requirepass 登录redis的密码
    4.指定配置文件启动
        redis-server redis.conf 
        
5.通过新的端口和密码登录redis
    redis-cli -p 6380
    登录后
    auth 密码

    补充：redis还支持交互式的参数，登录数据库
        redis-cli -p 6380  -a  redis的密码  （这个不太安全）

6.通过登录redis，用命令查看redis的密码
    config set  requirepass  新的密码         #设置新密码
    config get  requirepass          #获取当前的密码


过滤掉文件的空白行和注释行
grep -v "^#"  redis.conf |   grep  -v "^$"
redis的下载安装配置
redis发布订阅

三个角色，提供的redis命令
1.发布者
    PUBLISH  频道  消息         给频道发消息
        例：PUBLISH music xxx            在music频道上发布xxx消息
2.订阅者
    SUBSCRIBE  频道                  订阅频道 
        例：SUBSCRIBE music              订阅music频道，会收到music频道发布的xxx消息
    PSUBSCRIBE 频道*           支持模糊匹配的订阅
        例：PSUBSCRIBE mus*              订阅所有以mus开头的频道，这里会收到music频道发布的xxx消息
3.频道
    channel  频道名 自定义
redis发布订阅
redis持久化之RDB
1.在配置文件中添加参数，开启rdb功能
  在redis.conf（最好备份一份） 中写入
    port 6379
    daemonize yes
    logfile /data/6379/redis.log
    dir /data/6379
    dbfilename   s15.rdb
    save 900 1                    #rdb机制 每900秒 有1个修改记录
    save 300 10                    #每300秒        10个修改
    记录
    save 60  10000                #每60秒内        10000修改记录
2.开启redis服务端，测试rdb功能
    redis-server redis.conf 


redis持久化之aof
1.开启aof功能，在redis.conf中添加参数
    port 6379
    daemonize yes
    logfile /data/6379/redis.log
    dir /data/6379
    appendonly yes
    appendfsync everysec
2.启动redis服务端，指定aof功能，测试持久化数据
redis持久化RDB与AOF的使用
redis不重启之rdb数据切换到aof数据
1.准备rdb的redis服务端
    redis-server   s15-redis.conf (注明这是在rdb持久化模式下)

2.切换rdb到aof
    redis-cli  登录redis，然后通过命令，激活aof持久化
    CONFIG set appendonly yes        #用命令激活aof持久化(临时生效，注意写入到配置文件)
    CONFIG SET save ""             #关闭rdb持久化

2.5 将aof操作，写入到配置文件，永久生效，下次重启后生效
    port 6379
    daemonize yes 
    logfile /data/6379/redis.log
    dir /data/6379   

    #dbfilename   s15.rdb
    #save 900 1  
    #save 300 10 
    #save 60  10000 
    appendonly yes
    appendfsync everysec

3.测试aof数据持久化 ,杀掉redis，重新启动
    kill 
    redis-server s15-redis.conf 

4.写入数据，检查aof文件appendonly.aof
redis不重启之rdb数据备份切换到aof数据备份
redis的主从同步

注：检查redis数据库信息，主从状态的命令
    redis-cli  -p 6379  info              检查数据库信息
    redis-cli  -p 6379  info  replication          检查数据库主从信息

1.准备三个redis配置文件，通过端口的区分，启动三个redis数据库实例，然后配置主从复制
redis-6379.conf 
    port 6379
    daemonize yes
    pidfile /data/6379/redis.pid
    loglevel notice
    logfile "/data/6379/redis.log"
    dbfilename dump.rdb
    dir /data/6379
    
redis-6380.conf 
    #通过命令快速生成配置文件（s是替换，g是全局）
    sed "s/6379/6380/g" redis-6379.conf > redis-6380.conf 
    slaveof  127.0.0.1  6379   #指明主库的身份ip 和端口

redis-6381.conf 
    #通过命令快速生成配置文件
    sed "s/6379/6381/g" redis-6379.conf > redis-6381.conf 
    slaveof  127.0.0.1  6379

2.启动三个数据库实例，检测redis主从同步方案
    redis-server redis-6379.conf
    redis-server redis-6380.conf
    redis-server redis-6381.conf


3.redis主从复制，假如主库6379停止工作，手动从从库中选择一个从库作为新的主库
    (1).杀死6379的主库实例
        kill 主库
    
    (2).手动切换主从身份
        1.登录redis-6380 ，通过命令，去掉自己的从库身份，等待连接
            slaveof no one  
        2.登录redis-6381 ,通过命令，生成新的主人
            slaveof 127.0.0.1 6380  
    
    (3).测试新的主从数据同步
redis的主从同步
redis哨兵
1.什么是哨兵呢？保护redis主从集群，正常运转，当主库挂掉之后，自动的再从库中挑选新的主库，进行同步

2.redis哨兵的安装配置
    (1).准备三个redis数据库实例（三个配置文件，通过端口区分）
        [root@localhost redis-4.0.10]# redis-server redis-6379.conf 
        [root@localhost redis-4.0.10]# redis-server redis-6380.conf 
        [root@localhost redis-4.0.10]# redis-server redis-6381.conf 
    (2).准备三个哨兵，准备三个哨兵的配置文件(仅仅是端口的不同26379,26380,26381)
      redis-sentinel-26379.conf，文件内容如下：
        port 26379  
        dir /var/redis/data/
        logfile "26379.log"

        sentinel monitor s15master 127.0.0.1 6379 2

        sentinel down-after-milliseconds s15master 30000

        sentinel parallel-syncs s15master 1

        sentinel failover-timeout s15master 180000
        daemonize yes

      redis-sentinel-26380.conf
        快速生成配置文件
        sed "s/26379/26380/g" redis-sentinel-26379.conf >  redis-sentinel-26380.conf 
      redis-sentinel-26381.conf
        sed "s/26379/26381/g" redis-sentinel-26379.conf >  redis-sentinel-26381.conf 

    (3).启动三个哨兵
        redis-sentinel redis-sentinel-26379.conf 
        redis-sentinel redis-sentinel-26380.conf 
        redis-sentinel redis-sentinel-26381.conf 
        
    (4).检查哨兵的通信状态
        redis-cli -p 26379  info sentinel 
        查看结果如下之后，表示哨兵正常
        [root@localhost redis-4.0.10]# 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=s15master,status=ok,address=127.0.0.1:6381,slaves=2,sentinels=3

    (5).杀死一个redis主库6379节点，等待30s以内，检查6380和6381的节点状态
        kill 6379主节点
        redis-cli -p 6380 info replication 
        redis-cli -p 6381 info replication 
        切换了主从身份，（原理就是更改redis的配置文件，切换主从身份）
    
    (6).恢复6379节点的数据库，查看是否将6379添加为新的slave身份
redis哨兵
redis-cluster集群安装配置
1.准备6个redis数据库实例，准备6个配置文件redis-{7000....7005}配置文件
    -rw-r--r-- 1 root root 151 Jan  2 19:26 redis-7000.conf
    -rw-r--r-- 1 root root 151 Jan  2 19:27 redis-7001.conf
    -rw-r--r-- 1 root root 151 Jan  2 19:27 redis-7002.conf
    -rw-r--r-- 1 root root 151 Jan  2 19:27 redis-7003.conf
    -rw-r--r-- 1 root root 151 Jan  2 19:27 redis-7004.conf
    -rw-r--r-- 1 root root 151 Jan  2 19:27 redis-7005.conf

2.启动6个redis数据库实例
    [root@localhost s15rediscluster]# redis-server redis-7000.conf 
    [root@localhost s15rediscluster]# redis-server redis-7001.conf 
    [root@localhost s15rediscluster]# redis-server redis-7002.conf 
    [root@localhost s15rediscluster]# redis-server redis-7003.conf 
    [root@localhost s15rediscluster]# redis-server redis-7004.conf 
    [root@localhost s15rediscluster]# redis-server redis-7005.conf 

3.配置ruby语言环境，脚本一键启动redis-cluster 
    1.下载ruby语言的源码包，编译安装
        wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
    2.解压缩
        ./configure --prefix=/opt/ruby/       释放makefile
        make && make install     编译且安装
    3.下载安装ruby操作redis的模块包
        wget http://rubygems.org/downloads/redis-3.3.0.gem
        
    4.配置ruby的环境变量
        echo $PATH
    
        vim /etc/profile
        写入最底行
            PATH=$PATH:/opt/ruby/bin/
        读取文件
            source /etc/profile 
    
    5.通过ruby的包管理工具去安装redis包，安装后会生成一个redis-trib.rb这个命令
        一键创建redis-cluster 其实就是分配主从关系 以及 槽位分配 slot槽位分配
        /opt/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
    
    6.检查节点主从状态
        redis-cli -p 7000  info replication 
    
    7.向redis集群写入数据，查看数据流向
        redis-cli -p 7000    #这里会将key自动的重定向，放到某一个节点的slot槽位中
        set  name  s15 
        set  addr shahe  

注：如果ruby一键启动redis-cluster集群不管用了，试一试下面这条命令启动集群
      redis-cli --cluster create 127.0.0.1:7006 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 --cluster-replicas 1
redis-cluster集群安装配置

 

 

杀死redis服务的方法
　　1.kill pid
　　2.pkill redis-server           根据服务名 杀死进程，可以杀死所有有关redis-server

 

一、redis下载安装配置及基本使用

NoSQL

学名（not only sql）

特点：

存储结构与mysql这一种关系型数据库完全不同，nosql存储的是KV形式

nosql有很多产品，都有自己的api和语法，以及业务场景

产品种类：

Mongodb

redis

Hbase hadoop
NoSQL

Nosql和sql的区别

应用场景不同，sql支持关系复杂的数据查询，nosql反之
sql支持事务性，nosql不支持

redis特性

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件
redis是c语言编写的，支持数据持久化，是key-value类型数据库。
应用在缓存，队列系统中
redis支持数据备份，也就是master-slave模式

redis优势

性能高，读取速度10万次每秒
写入速度8万次每秒
所有操作支持原子性

用作缓存数据库，数据放在内存中
替代某些场景下的mysql，如社交类app
大型系统中，可以存储session信息，购物车订单

 

yum安装redis

1.yum安装

#前提得配置好阿里云yum源，epel源
#查看是否有redis包
yum list redis
#安装redis
yum install redis -y
#安装好，启动redis
systemctl start redis

2.检测redis是否工作

redis-cli    #redis 客户端工具
#进入交互式环境后，执行ping，返回pong表示安装成功
127.0.0.1:6379> ping
PONG

源码安装redis，编译安装

大家用过yum，是相当省事好用吧，为什么还要学习源码安装？

有人说编译安装性能好？错

编译安装的优势是：

  • 编译安装时可以指定扩展的module（模块），php、apache、nginx都是一样有很多第三方扩展模块，如mysql，编译安装时候，如果需要就定制存储引擎（innodb，还是MyIASM）
  • 编译安装可以统一安装路径，linux软件约定安装目录在/opt/下面
  • 软件仓库版本一般比较低，编译源码安装可以根据需求，安装最新的版本
1.下载redis源码
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
2.解压缩
tar -zxf redis-4.0.10.tar.gz
3.切换redis源码目录
cd redis-4.0.10.tar.gz
4.编译源文件
make 
5.编译好后，src/目录下有编译好的redis指令
6.make install 安装到指定目录，默认在/usr/local/bin

redis可执行文件

./redis-benchmark //用于进行redis性能测试的工具
./redis-check-dump //用于修复出问题的dump.rdb文件
./redis-cli //redis的客户端
./redis-server //redis的服务端
./redis-check-aof //用于修复出问题的AOF文件
./redis-sentinel //用于集群管理

redis配置文件

redis配置文件名为
redis.conf 
这个文件可以自定义

redis.conf核心配置项

绑定ip，如需要远程访问，需要填写服务器ip
bind 127.0.0.1  

端口，redis启动端口
port 

守护进程方式运行
daemonize yes

rdb数据文件
dbfilename dump.rdb

数据文件存放路径
dir /var/lib/redis/

日志文件
logfile /var/log/redis/redis-server.log

主从复制
slaveof

启动redis服务端

启动redis非常简单，直接./redis-server就可以启动服务端了，还可以用下面的方法指定要加载的配置文件：
./redis-server ../redis.conf
默认情况下，redis-server会以非daemon的方式来运行，且默认服务端口为6379。

使用redis客户端

#执行客户端命令即可进入
./redis-cli  
#测试是否连接上redis
127.0.0.1:6379 > ping
返回pong代表连接上了

//用set来设置key、value
127.0.0.1:6379 > set name "chaoge"
OK
//get获取name的值
127.0.0.1:6379 > get name
"chaoge"

redis数据结构

redis是一种高级的key：value存储系统，其中value支持五种数据类型
字符串（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的数量

 

数据结构示例

1.strings类型

  • set 　设置key
  • get   获取key
  • append  追加string
  • mset   设置多个键值对
  • mget   获取多个键值对
  • del  删除key
  • incr  递增+1
  • decr  递减-1
127.0.0.1:6379> set name 'yu'   #设置key
OK
127.0.0.1:6379> get name　　　　#获取value
"yu"
127.0.0.1:6379> set name 'yuchao'　　#覆盖key
OK
127.0.0.1:6379> get name　　　　#获取value
"yuchao"
127.0.0.1:6379> append name ' dsb' 　　#追加key的string
(integer) 10
127.0.0.1:6379> get name　　#获取value
"yuchao dsb"


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

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

127.0.0.1:6379> decr num　　　　　　#递减1  
(integer) 10
127.0.0.1:6379> decr num　　　　#递减1
(integer) 9
127.0.0.1:6379> get num
"9"
使用示例

2.list类型

  • lpush         从列表左边插
  • rpush         从列表右边插
  • lrange          获取一定长度的元素  lrange key  start stop
  • ltrim               截取一定长度列表
  • lpop                 删除最左边一个元素
  • rpop                     删除最右边一个元素
  • lpushx/rpushx                key存在则添加值，不存在不处理
lpush duilie 'alex' 'peiqi' 'ritian'  #新建一个duilie，从左边放入三个元素

llen duilie  #查看duilie长度

lrange duilie 0 -1  #查看duilie所有元素

rpush duilie 'chaoge'   #从右边插入chaoge

lpushx duilie2  'dsb'  #key存在则添加 dsb元素，key不存在则不作处理

ltrim duilie 0 2  #截取队列的值，从索引0取到2，删除其余的元素

lpop #删除左边的第一个
rpop #删除右边的第一个

3.sets集合类型

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

集合相关的操作也很丰富，如添加新元素、删除已有元素、取交集、取并集、取差集等。我们来看例子：

  • sadd/srem   添加/删除 元素
  • sismember   判断是否为set的一个元素
  • smembers    返回集合所有的成员
  • sdiff             返回一个集合和其他集合的差异
  • sinter           返回几个集合的交集
  • sunion          返回几个集合的并集
sadd zoo  wupeiqi yuanhao  #添加集合，有三个元素，不加引号就当做字符串处理

smembers zoo  #查看集合zoo成员

srem zoo  wupeiqi #删除zoo里面的alex

sismember zoo wupeiqi  #返回改是否是zoo的成员信息，不存在返回0，存在返回1

sadd zoo wupeiqi   #再把wupeiqi加入zoo

smembers zoo  #查看zoo成员

sadd zoo2 wupeiqi mjj #添加新集合zoo2

sdiff zoo zoo2 #找出集合zoo中有的，而zoo2中没有的元素

sdiff zoo2  zoo  #找出zoo2中有，而zoo没有的元素

sinter zoo zoo1   #找出zoo和zoo1的交集，都有的元素

sunion  zoo zoo1  #找出zoo和zoo1的并集，所有的不重复的元素

4.有序集合

都是以z开头的命令

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"

返回有序集合mid_test的基数

127.0.0.1:6379> ZCARD mid_test
(integer) 3

返回成员的score值

127.0.0.1:6379> ZSCORE mid_test alex
"70"

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

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>
127.0.0.1:6379>
127.0.0.1:6379> ZRANK mid_test wusir
(integer) 1
127.0.0.1:6379> ZRANK mid_test yuyu
(integer) 2

5.哈希数据结构

哈希结构就是  k1   ->  k1 : v1     如同字典 套字典  { k1 : { k2: v2 }  }   ，取出v2 必须  k1，取出k2

hashes即哈希。哈希是从redis-2.0.0版本之后才有的数据结构。

hashes存的是字符串和字符串值之间的映射，比如一个用户要存储其全名、姓氏、年龄等等，就很适合使用哈希。

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

语法  hset key field value  

hset news1   title "first news title" #设置第一条新闻 news的id为1，添加数据title的值是"first news title"

hset news1 content "news content"    #添加一个conntent内容

hget news1 title   #获取news:1的标题

hget news1  content  #获取news的内容

hmget news1  title content   #获取多对news:1的 值

hmset news2 title "second news title" content "second Contents2"   #设置第二条新闻news:2 多个field

hmget news2 title  content #获取news:2的多个值

hkeys news1   #获取新闻news:1的所有key

hvals news1   #获取新闻news:1的所有值

hlen news1    #获取新闻news:1的长度

hdel news1 title   #删除新闻news:1的title

hlen news1     #看下新闻news:1的长度

hexists news1 title    #判断新闻1中是否有title，不存在返回0，存在返回1

 

二、Python操作redis

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

1、安装redis

yum install redis -y

或者
wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make
2、启动redis
这里注意对配置文件修改
打开注释，不然py客户端连不上　　

守护模式不开就no　　

指定配置文件进行启动　　

然后准备设置redis验证密码（不然py连接报错）

 

退出，重新登录redis　　

3、python操作redis

#!/usr/bin/env python 
# -*- coding:utf8 -*-

import redis

r = redis.Redis(host='192.168.11.122',password='123123',port=6379)

r.set('foo', 'Bar')
print (r.get('foo'))

4、线程池操作redis

'''
redis-py 使用connection pool 来管理对一个redis server的所有连接，避免每次建立，释放连接的开销
默认 每个redis实例都会维护一个自己的链接池,然后作为参数redis,这样就可以实现多个redis 实例共享一个连接池
'''
import redis

pool = redis.ConnectionPool(host='192.168.11.122',password='123123',port=6379)

r = redis.Redis(connection_pool=pool)
r.set('name','Yu chao')
print(r.get('name'))

参考博客：https://www.cnblogs.com/pyyu/p/6964593.html

 

三、redis安全

centos下redis安全相关

　　由于发现众多同学，在使用云服务器时，安装的redis3.0+版本都关闭了protected-mode，因而都遭遇了挖矿病毒的攻击，使得服务器99%的占用率！！

　　因此我们在使用redis时候，最好更改默认端口，并且使用redis密码登录。

（1）redis没有用户概念，redis只有密码
（2）redis默认在工作在保护模式下。不允许远程任何用户登录的（protected-mode）

redis.conf设置

protected-mode yes   #打开保护模式
port 6380  #更改默认启动端口
requirepass xxxxxx   #设置redis启动密码，xxxx是自定义的密码

启动redis服务端

redis-server /opt/redis-4.0.10/redis.conf &     #指定配置文件启动redis，且后台启动

使用密码登录redis，使用6380端口

方法1，使用这个

[root@oldboy_python ~ 09:48:41]#redis-cli -p 6380
127.0.0.1:6380> auth xxxx
OK

方法2，此方案不安全，容易暴露密码

[root@oldboy_python ~ 09:49:46]#redis-cli -p 6380 -a xxxx
Warning: Using a password with '-a' option on the command line interface may not be safe.
127.0.0.1:6380> ping
PONG

补充

检查redis是否设置了密码

127.0.0.1:6380> CONFIG get requirepass
1) "requirepass"
2) "xxxxxx"

如果没有，也可以给redis设置密码（命令方式）

CONFIG set requirepass "xxxxxx"

因此你的redis就不容易被黑客入侵了。

参考博客：https://www.cnblogs.com/pyyu/p/9515937.html

 

四、redis 发布订阅

发布publish

订阅subscribe

Redis 通过 PUBLISH 、 SUBSCRIBE 等命令实现了订阅与发布模式。

 

 

 

 

举例1：

qq群的公告，单个发布者，多个收听者

发布/订阅 实验

发布订阅的命令

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同时在线。

发布订阅：

窗口1，启动两个redis-cli窗口，均订阅diantai 频道（channel）

窗口2，启动发布者向频道 diantai发送消息

[root@web02 ~]# redis-cli
127.0.0.1:6379> PUBLISH diantai 'jinyewugenglaiwojia'
(integer) 2

窗口3，查看订阅者的消息状态

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

窗口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 "

窗口3，发布者消息

[root@web02 ~]# redis-cli
127.0.0.1:6379> PUBLISH wangbaoqiang "jintian zhennanshou "
(integer) 2

 

五、redis持久化RDB与AOF

redis持久化

Redis是一种内存型数据库，一旦服务器进程退出，数据库的数据就会丢失，为了解决这个问题，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 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

redis持久化之AOF

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

redis-client   写入数据  >  redis-server   同步命令   >  AOF文件

配置参数

AOF持久化配置，两条参数

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

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

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename  dbmp.rdb
requirepass redhat
save 900 1
save 300 10
save 60  10000
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

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

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

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

 

六、redis不重启，切换RDB备份到AOF备份

确保redis版本在2.2以上

[root@pyyuc /data 22:23:30]#redis-server -v
Redis server v=4.0.10 sha=00000000:0 malloc=jemalloc-4.0.3 bits=64 build=64cb6afcf41664c

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

实验环境准备

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修改记录

启动redis服务端

redis-server redis.conf

登录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

检查RDB文件

[root@pyyuc /data 22:34:16]#ls 6379/
dbmp.rdb  redis.log

备份这个rdb文件，保证数据安全

[root@pyyuc /data/6379 22:35:38]#cp dbmp.rdb /opt/

执行命令，开启AOF持久化

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

确保数据库的key数量正确

127.0.0.1:6379> keys *
1) "addr"
2) "age"
3) "name"

确保插入新的key，AOF文件会记录

127.0.0.1:6379> set title golang
OK

此时RDB已经正确切换AOF，注意还得修改redis.conf添加AOF设置，不然重启后，通过config set的配置将丢失

 

七、redis主从同步

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


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

环境准备

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

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

启动三个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  #指明主的地址

检查主从状态

从库：

127.0.0.1:6382> info replication
127.0.0.1:6381> info replication

主库：

127.0.0.1:6380> info replication

测试写入数据，主库写入数据，检查从库数据

主
127.0.0.1:6380> set name chaoge


从
127.0.0.1:6381>get name

手动进行主从复制故障切换

#关闭主库6380
redis-cli -p 6380
shutdown

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

redis-cli -p 6381
info replication

redis-cli -p 6382
info replication

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

1.关闭6381的从库身份

redis-cli -p 6381
info replication
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-sentinel哨兵实战

redis-sentinel主从复制高可用

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

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。
sentinel公作方式

redis主从复制背景问题

Redis主从复制可将主节点数据同步给从节点，从节点此时有两个作用：

  • 一旦主节点宕机，从节点作为主节点的备份可以随时顶上来。
  • 扩展主节点的读能力，分担主节点读压力。

但是问题是：

  • 一旦主节点宕机，从节点上位，那么需要人为修改所有应用方的主节点地址（改为新的master地址），还需要命令所有从节点复制新的主节点

那么这个问题，redis-sentinel就可以解决了

主从复制架构

Redis Sentinel架构

redis的一个进程，但是不存储数据，只是监控redis

 

redis命令整理

官网地址：http://redisdoc.com/

redis-cli info #查看redis数据库信息

redis-cli info replication #查看redis的复制授权信息
redis-cli info sentinel   #查看redis的哨兵信息

安装与配置

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

服务器环境，一台即可完成操作

master 192.168.119.10

所有配置文件如下

主节点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      // 从属主节点

启动redis主节点

redis-server /etc/redis-6379.conf

测试redis主节点是否通信

redis-cli  ping

启动两slave节点

还记得上面超哥的截图吗？总体redis配置文件如下，6379为master，6380和6381为slave

-rw-r--r-- 1 root root 145 Nov  7 17:44 /etc/redis-6379.conf      #这个为主，port是6379
-rw-r--r-- 1 root root  93 Nov  7 17:42 /etc/redis-6380.conf　　　 # 这个是从，port6380，并且得加上新的参数slaveof
-rw-r--r-- 1 root root 115 Nov  7 17:42 /etc/redis-6381.conf      # 这个是从，port6381，并且得加上新的参数slaveof

redis-6380.conf  slave配置文件详解，6381端口的配置文件，仅仅和6380端口不一样

port 6380
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/var/redis/data"
# Generated by CONFIG REWRITE
slaveof 127.0.0.1 6379
# Redis 配置文件

# 当配置中需要配置内存大小时，可以使用 1k, 5GB, 4M 等类似的格式，其转换方式如下(不区分大小写)
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# 内存配置大小写是一样的.比如 1gb 1Gb 1GB 1gB

# daemonize no 默认情况下，redis不是在后台运行的，如果需要在后台运行，把该项的值更改为yes
daemonize yes

# 当redis在后台运行的时候，Redis默认会把pid文件放在/var/run/redis.pid，你可以配置到其他地址。
# 当运行多个redis服务时，需要指定不同的pid文件和端口
pidfile /var/run/redis.pid

# 指定redis运行的端口，默认是6379
port 6379

# 指定redis只接收来自于该IP地址的请求，如果不进行设置，那么将处理所有请求，
# 在生产环境中最好设置该项
# bind 127.0.0.1

# Specify the path for the unix socket that will be used to listen for
# incoming connections. There is no default, so Redis will not listen
# on a unix socket when not specified.
#
# unixsocket /tmp/redis.sock
# unixsocketperm 755

# 设置客户端连接时的超时时间，单位为秒。当客户端在这段时间内没有发出任何指令，那么关闭该连接
# 0是关闭此设置
timeout 0

# 指定日志记录级别
# Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose
# debug    记录很多信息，用于开发和测试
# varbose    有用的信息，不像debug会记录那么多
# notice    普通的verbose，常用于生产环境
# warning    只有非常重要或者严重的信息会记录到日志
loglevel debug

# 配置log文件地址
# 默认值为stdout，标准输出，若后台模式会输出到/dev/null
#logfile stdout
logfile /var/log/redis/redis.log

# To enable logging to the system logger, just set 'syslog-enabled' to yes,
# and optionally update the other syslog parameters to suit your needs.
# syslog-enabled no

# Specify the syslog identity.
# syslog-ident redis

# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
# syslog-facility local0

# 可用数据库数
# 默认值为16，默认数据库为0，数据库范围在0-（database-1）之间
databases 16

################################ 快照 #################################
#
# 保存数据到磁盘，格式如下:
#
# save <seconds> <changes>
#
# 指出在多长时间内，有多少次更新操作，就将数据同步到数据文件rdb。
# 相当于条件触发抓取快照，这个可以多个条件配合
# 
# 比如默认配置文件中的设置，就设置了三个条件
#
# save 900 1 900秒内至少有1个key被改变
# save 300 10 300秒内至少有300个key被改变
# save 60 10000 60秒内至少有10000个key被改变

save 900 1
save 300 10
save 60 10000

# 存储至本地数据库时（持久化到rdb文件）是否压缩数据，默认为yes
rdbcompression yes

# 本地持久化数据库文件名，默认值为dump.rdb
dbfilename dump.rdb

# 工作目录
#
# 数据库镜像备份的文件放置的路径。
# 这里的路径跟文件名要分开配置是因为redis在进行备份时，先会将当前数据库的状态写入到一个临时文件中，等备份完成时，
# 再把该该临时文件替换为上面所指定的文件，而这里的临时文件和上面所配置的备份文件都会放在这个指定的路径当中。
# 
# AOF文件也会存放在这个目录下面
# 
# 注意这里必须制定一个目录而不是文件
dir ./

################################# 复制 #################################

# 主从复制. 设置该数据库为其他数据库的从数据库. 
# 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步
#
# slaveof <masterip> <masterport>

# 当master服务设置了密码保护时(用requirepass制定的密码)
# slav服务连接master的密码
# 
# masterauth <master-password>


# 当从库同主机失去连接或者复制正在进行，从机库有两种运行方式：
#
# 1) 如果slave-serve-stale-data设置为yes(默认设置)，从库会继续相应客户端的请求
# 
# 2) 如果slave-serve-stale-data是指为no，出去INFO和SLAVOF命令之外的任何请求都会返回一个
# 错误"SYNC with master in progress"
#
slave-serve-stale-data yes

# 从库会按照一个时间间隔向主库发送PINGs.可以通过repl-ping-slave-period设置这个时间间隔，默认是10秒
#
# repl-ping-slave-period 10

# repl-timeout 设置主库批量数据传输时间或者ping回复时间间隔，默认值是60秒
# 一定要确保repl-timeout大于repl-ping-slave-period
# repl-timeout 60

################################## 安全 ###################################

# 设置客户端连接后进行任何其他指定前需要使用的密码。
# 警告：因为redis速度相当快，所以在一台比较好的服务器下，一个外部的用户可以在一秒钟进行150K次的密码尝试，这意味着你需要指定非常非常强大的密码来防止暴力破解
#
# requirepass foobared

# 命令重命名.
#
# 在一个共享环境下可以重命名相对危险的命令。比如把CONFIG重名为一个不容易猜测的字符。
#
# 举例:
#
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
#
# 如果想删除一个命令，直接把它重命名为一个空字符""即可，如下：
#
# rename-command CONFIG ""

################################### 约束 ####################################

# 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，
# 如果设置 maxclients 0，表示不作限制。
# 当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息
#
# maxclients 128

# 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key
# Redis同时也会移除空的list对象
#
# 当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作
# 
# 注意：Redis新的vm机制，会把Key存放内存，Value会存放在swap区
#
# maxmemory的设置比较适合于把redis当作于类似memcached的缓存来使用，而不适合当做一个真实的DB。
# 当把Redis当做一个真实的数据库使用的时候，内存使用将是一个很大的开销
# maxmemory <bytes>

# 当内存达到最大值的时候Redis会选择删除哪些数据？有五种方式可供选择
# 
# volatile-lru -> 利用LRU算法移除设置过过期时间的key (LRU:最近使用 Least Recently Used )
# allkeys-lru -> 利用LRU算法移除任何key
# volatile-random -> 移除设置过过期时间的随机key
# allkeys->random -> remove a random key, any key 
# volatile-ttl -> 移除即将过期的key(minor TTL)
# noeviction -> 不移除任何可以，只是返回一个写错误
# 
# 注意：对于上面的策略，如果没有合适的key可以移除，当写的时候Redis会返回一个错误
#
# 写命令包括: set setnx setex append
# incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
# sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
# zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
# getset mset msetnx exec sort
#
# 默认是:
#
# maxmemory-policy volatile-lru

# LRU 和 minimal TTL 算法都不是精准的算法，但是相对精确的算法(为了节省内存)，随意你可以选择样本大小进行检测。
# Redis默认的灰选择3个样本进行检测，你可以通过maxmemory-samples进行设置
#
# maxmemory-samples 3

############################## AOF ###############################


# 默认情况下，redis会在后台异步的把数据库镜像备份到磁盘，但是该备份是非常耗时的，而且备份也不能很频繁，如果发生诸如拉闸限电、拔插头等状况，那么将造成比较大范围的数据丢失。
# 所以redis提供了另外一种更加高效的数据库备份及灾难恢复方式。
# 开启append only模式之后，redis会把所接收到的每一次写操作请求都追加到appendonly.aof文件中，当redis重新启动时，会从该文件恢复出之前的状态。
# 但是这样会造成appendonly.aof文件过大，所以redis还支持了BGREWRITEAOF指令，对appendonly.aof 进行重新整理。
# 你可以同时开启asynchronous dumps 和 AOF

appendonly no

# AOF文件名称 (默认: "appendonly.aof")
# appendfilename appendonly.aof

# Redis支持三种同步AOF文件的策略:
#
# no: 不进行同步，系统去操作 . Faster.
# always: always表示每次有写操作都进行同步. Slow, Safest.
# everysec: 表示对写操作进行累积，每秒同步一次. Compromise.
#
# 默认是"everysec"，按照速度和安全折中这是最好的。
# 如果想让Redis能更高效的运行，你也可以设置为"no"，让操作系统决定什么时候去执行
# 或者相反想让数据更安全你也可以设置为"always"
#
# 如果不确定就用 "everysec".

# appendfsync always
appendfsync everysec
# appendfsync no

# AOF策略设置为always或者everysec时，后台处理进程(后台保存或者AOF日志重写)会执行大量的I/O操作
# 在某些Linux配置中会阻止过长的fsync()请求。注意现在没有任何修复，即使fsync在另外一个线程进行处理
#
# 为了减缓这个问题，可以设置下面这个参数no-appendfsync-on-rewrite
#
# This means that while another child is saving the durability of Redis is
# the same as "appendfsync none", that in pratical terms means that it is
# possible to lost up to 30 seconds of log in the worst scenario (with the
# default Linux settings).
# 
# If you have latency problems turn this to "yes". Otherwise leave it as
# "no" that is the safest pick from the point of view of durability.
no-appendfsync-on-rewrite no

# Automatic rewrite of the append only file.
# AOF 自动重写
# 当AOF文件增长到一定大小的时候Redis能够调用 BGREWRITEAOF 对日志文件进行重写 
# 
# 它是这样工作的：Redis会记住上次进行些日志后文件的大小(如果从开机以来还没进行过重写，那日子大小在开机的时候确定)
#
# 基础大小会同现在的大小进行比较。如果现在的大小比基础大小大制定的百分比，重写功能将启动
# 同时需要指定一个最小大小用于AOF重写，这个用于阻止即使文件很小但是增长幅度很大也去重写AOF文件的情况
# 设置 percentage 为0就关闭这个特性

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

################################## SLOW LOG ###################################

# Redis Slow Log 记录超过特定执行时间的命令。执行时间不包括I/O计算比如连接客户端，返回结果等，只是命令执行时间
# 
# 可以通过两个参数设置slow log：一个是告诉Redis执行超过多少时间被记录的参数slowlog-log-slower-than(微妙)，
# 另一个是slow log 的长度。当一个新命令被记录的时候最早的命令将被从队列中移除

# 下面的时间以微妙微单位，因此1000000代表一分钟。
# 注意制定一个负数将关闭慢日志，而设置为0将强制每个命令都会记录
slowlog-log-slower-than 10000

# 对日志长度没有限制，只是要注意它会消耗内存
# 可以通过 SLOWLOG RESET 回收被慢日志消耗的内存
slowlog-max-len 1024

################################ VM ###############################

### WARNING! Virtual Memory is deprecated in Redis 2.4
### The use of Virtual Memory is strongly discouraged.

# Virtual Memory allows Redis to work with datasets bigger than the actual
# amount of RAM needed to hold the whole dataset in memory.
# In order to do so very used keys are taken in memory while the other keys
# are swapped into a swap file, similarly to what operating systems do
# with memory pages.
#
# To enable VM just set 'vm-enabled' to yes, and set the following three
# VM parameters accordingly to your needs.

vm-enabled no
# vm-enabled yes

# This is the path of the Redis swap file. As you can guess, swap files
# can't be shared by different Redis instances, so make sure to use a swap
# file for every redis process you are running. Redis will complain if the
# swap file is already in use.
#
# The best kind of storage for the Redis swap file (that's accessed at random) 
# is a Solid State Disk (SSD).
#
# *** WARNING *** if you are using a shared hosting the default of putting
# the swap file under /tmp is not secure. Create a dir with access granted
# only to Redis user and configure Redis to create the swap file there.
vm-swap-file /tmp/redis.swap

# vm-max-memory configures the VM to use at max the specified amount of
# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
# is, if there is still enough contiguous space in the swap file.
#
# With vm-max-memory 0 the system will swap everything it can. Not a good
# default, just specify the max amount of RAM you can in bytes, but it's
# better to leave some margin. For instance specify an amount of RAM
# that's more or less between 60 and 80% of your free RAM.
vm-max-memory 0

# Redis swap files is split into pages. An object can be saved using multiple
# contiguous pages, but pages can't be shared between different objects.
# So if your page is too big, small objects swapped out on disk will waste
# a lot of space. If you page is too small, there is less space in the swap
# file (assuming you configured the same number of total swap file pages).
#
# If you use a lot of small objects, use a page size of 64 or 32 bytes.
# If you use a lot of big objects, use a bigger page size.
# If unsure, use the default :)
vm-page-size 32

# Number of total memory pages in the swap file.
# Given that the page table (a bitmap of free/used pages) is taken in memory,
# every 8 pages on disk will consume 1 byte of RAM.
#
# The total swap size is vm-page-size * vm-pages
#
# With the default of 32-bytes memory pages and 134217728 pages Redis will
# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
#
# It's better to use the smallest acceptable value for your application,
# but the default is large in order to work in most conditions.
vm-pages 134217728

# Max number of VM I/O threads running at the same time.
# This threads are used to read/write data from/to swap file, since they
# also encode and decode objects from disk to memory or the reverse, a bigger
# number of threads can help with big objects even if they can't help with
# I/O itself as the physical device may not be able to couple with many
# reads/writes operations at the same time.
#
# The special value of 0 turn off threaded I/O and enables the blocking
# Virtual Memory implementation.
vm-max-threads 4

############################### ADVANCED CONFIG ###############################

# 当hash中包含超过指定元素个数并且最大的元素没有超过临界时，
# hash将以一种特殊的编码方式（大大减少内存使用）来存储，这里可以设置这两个临界值
# Redis Hash对应Value内部实际就是一个HashMap，实际这里会有2种不同实现，
# 这个Hash的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会采用真正的HashMap结构，对应的value redisObject的encoding为zipmap,
# 当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。
hash-max-zipmap-entries 512
hash-max-zipmap-value 64

# list数据类型多少节点以下会采用去指针的紧凑存储格式。
# list数据类型节点值大小小于多少字节会采用紧凑存储格式。
list-max-ziplist-entries 512
list-max-ziplist-value 64

# set数据类型内部数据如果全部是数值型，且包含多少节点以下会采用紧凑格式存储。
set-max-intset-entries 512

# zsort数据类型多少节点以下会采用去指针的紧凑存储格式。
# zsort数据类型节点值大小小于多少字节会采用紧凑存储格式。
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# Redis将在每100毫秒时使用1毫秒的CPU时间来对redis的hash表进行重新hash，可以降低内存的使用
# 
# 当你的使用场景中，有非常严格的实时性需要，不能够接受Redis时不时的对请求有2毫秒的延迟的话，把这项配置为no。
#
# 如果没有这么严格的实时性要求，可以设置为yes，以便能够尽可能快的释放内存
activerehashing yes

################################## INCLUDES ###################################

# 指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件

# include /path/to/local.conf
# include /path/to/other.conf
redis.conf详解--补充--

启动slave从节点的redis服务

[root@master 192.168.119.10 ~]$redis-server /etc/redis-6380.conf
[root@master 192.168.119.10 ~]$redis-server /etc/redis-6381.conf

验证从节点的redis服务

[root@master  ~]$redis-cli   -p 6380 ping
PONG
[root@master  ~]$redis-cli   -p 6381 ping
PONG

确定主从关系

在主节点上查看主从通信关系

[root@master ~]# redis-cli  -p 6379 info replication
# Replication
role:master
connected_slaves:2
slave0:ip=192.168.119.10,port=6380,state=online,offset=407,lag=0
slave1:ip=192.168.119.10,port=6381,state=online,offset=407,lag=0
master_repl_offset:407
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:406

在从节点上查看主从关系（6380、6379）

[root@slave 192.168.119.11 ~]$redis-cli  -p 6380 info replication
# Replication
role:slave
master_host:192.168.119.10
master_port:6379
master_link_status:up
master_last_io_seconds_ago:3
master_sync_in_progress:0
slave_repl_offset:505
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

此时可以在master上写入数据，在slave上查看数据，此时主从复制配置完成

开始配置Redis Sentinel

超哥实验的环境是单独一台linux，192.168.119.10

[root@master tmp]# ll /etc/redis-*
-rw-r--r-- 1 root root 145 Nov  7 17:44 /etc/redis-6379.conf
-rw-r--r-- 1 root root  93 Nov  7 17:42 /etc/redis-6380.conf
-rw-r--r-- 1 root root 115 Nov  7 17:42 /etc/redis-6381.conf
-rw-r--r-- 1 root root 556 Nov  7 17:42 /etc/redis-sentinel-26379.conf
-rw-r--r-- 1 root root 556 Nov  7 17:42 /etc/redis-sentinel-26380.conf
-rw-r--r-- 1 root root 556 Nov  7 17:42 /etc/redis-sentinel-26381.conf

redis-sentinel-26379.conf配置文件写入如下信息

// Sentinel节点的端口
port 26379  
dir /var/redis/data/
logfile "26379.log"

// 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
// 2代表判断主节点失败至少需要2个Sentinel节点节点同意
// mymaster是主节点的别名
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
redis-sentinel-26380.conf和redis-sentinel-26381.conf的配置仅仅差异是port(端口)的不同。
然后启动三个sentinel哨兵
redis-sentinel /etc/redis-sentinel-26379.conf
redis-sentinel /etc/redis-sentinel-26380.conf
redis-sentinel /etc/redis-sentinel-26381.conf

监控拓扑图

 

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

[root@master ~]# 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个哨兵

redis高可用故障实验

大致思路

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

 首先查看三个redis的进程状态

ps -ef|grep redis

检查三个节点的复制身份状态

第一个

[root@master tmp]# redis-cli -p 6381 info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6380

第二个

[root@master tmp]# redis-cli -p 6380 info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=54386,lag=0
slave1:ip=127.0.0.1,port=6379,state=online,offset=54253,lag=0

第三个

[root@master tmp]# redis-cli -p 6379 info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6380

此时，干掉master！！！然后等待其他两个节点是否能自动被哨兵sentienl，切换为master节点

ps -ef|grep 6380   #干掉master进程

此时查看两个slave的状态

精髓就是查看一个参数

master_link_down_since_seconds:13

稍等片刻之后，发现slave节点成为master节点！！

[root@master tmp]# redis-cli -p 6379 info replication
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=41814,lag=1

大功告成！

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

 

九、redis-cluster集群 配置

 为什么要用redis-cluster

1.并发问题

redis官方生成可以达到 10万/每秒,每秒执行10万条命令
假如业务需要每秒100万的命令执行呢？

2.数据量太大

一台服务器内存正常是16~256G，假如你的业务需要500G内存，

新浪微博作为世界上最大的redis存储，就超过1TB的数据，去哪买这么大的内存条？各大公司有自己的解决方案，推出各自的集群功能，核心思想都是将数据分片（sharding）存储在多个redis实例中，每一片就是一个redis实例。

各大企业集群方案：
twemproxy由Twitter开源
Codis由豌豆荚开发，基于GO和C开发
redis-cluster官方3.0版本后的集群方案

解决方案如下

  1. 配置一个超级牛逼的计算机，超大内存，超强cpu，但是问题是。。。。

2.正确的应该是考虑分布式，加机器，把数据分到不同的位置，分摊集中式的压力，一堆机器做一件事

客户端分片

redis3.0集群采用P2P模式，完全去中心化，将redis所有的key分成了16384个槽位，每个redis实例负责一部分slot，集群中的所有信息通过节点数据交换而更新。

redis实例集群主要思想是将redis数据的key进行散列，通过hash函数特定的key会映射到指定的redis节点上

数据分布原理图

 

数据分布理论

分布式数据库首要解决把整个数据集按照分区规则映射到多个节点的问题，即把数据集划分到多个节点上，每个节点负责整个数据的一个子集。

常见的分区规则有哈希分区和顺序分区。Redis Cluster采用哈希分区规则，因此接下来会讨论哈希分区规则。

  • 节点取余分区
  • 一致性哈希分区
  • 虚拟槽分区(redis-cluster采用的方式)

顺序分区

哈希分区

节点取余

例如按照节点取余的方式，分三个节点

1~100的数据对3取余，可以分为三类

  • 余数为0
  • 余数为1
  • 余数为2

 

那么同样的分4个节点就是hash(key)%4

节点取余的优点是简单，客户端分片直接是哈希+取余

一致性哈希

客户端进行分片，哈希+顺时针取余

虚拟槽分区 

Redis Cluster采用虚拟槽分区

虚拟槽分区巧妙地使用了哈希空间，使用分散度良好的哈希函数把所有的数据映射到一个固定范围内的整数集合，整数定义为槽（slot）。

Redis Cluster槽的范围是0 ～ 16383。

槽是集群内数据管理和迁移的基本单位。采用大范围的槽的主要目的是为了方便数据的拆分和集群的扩展，

每个节点负责一定数量的槽。

 

 

搭建redis cluster

搭建集群分为几部

  •  准备节点（几匹马儿）
  • 节点通信（几匹马儿分配主从）
  • 分配槽位给节点（slot分配给马儿）

redis-cluster集群架构

多个服务端，负责读写，彼此通信，redis指定了16384个槽。

多匹马儿，负责运输数据，马儿分配16384个槽位，管理数据。

ruby的脚本自动就把分配槽位这事做了

 

安装方式

官方提供通过ruby语言的脚本一键安装

1.环境准备

通过配置，开启redis-cluster

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个实例，三个是主节点，三个是从节点，数量为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

#确保每个配置文件中的端口修改！！

2.运行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

检查日志文件

cat 7000.log

检查redis服务的端口、进程

netstat -tunlp|grep redis


ps -ef|grep redis

此时集群还不可用，可以通过登录redis查看

redis-cli -p 7000
set hello world

(error)CLUSTERDOWN The cluster is down

3.创建开启redis-cluster

准备ruby环境

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

第一步，安装ruby(这些命令可以放入一个sh脚本文件里)

#下载ruby
wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz

#安装ruby
tar -xvf ruby-2.3.1.tar.gz
./configure --prefix=/opt/ruby/
make && make install

#准备一个ruby命令
#准备一个gem软件包管理命令
#拷贝ruby命令到path下/usr/local/ruby
cp /opt/ruby/bin/ruby /usr/local/
cp bin/gem /usr/local/bin

安装ruby gem 包管理工具

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

gem install -l redis-3.3.0.gem

#查看gem有哪些包
gem list -- check redis 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

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

[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"

集群ok

工作原理：

redis客户端任意访问一个redis实例，如果数据不在该实例中，通过重定向引导客户端访问所需要的redis实例

返回顶部
posted on 2019-11-30 08:34  始终不够啊  阅读(460)  评论(0)  编辑  收藏  举报