Linux：redis 安装 + 应用

Redis安装

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

一、linux下安装redis 

方式一：yum 直接安装

yum install redis -y     # 安装

yum uninstall redis -y   # 卸载

方式二：通过源码编译安装

　　（这里是采用源码方式安装的）

1、下载源码包到目录 /opt/ 中

cd /opt
wget http://download.redis.io/releases/redis-4.0.10.tar.gz

2、解压压缩包redis

　　由于压缩包的格式是 *.tar.gz，因此需要用 -x 解压 .tar， -z 解压 .gz

tar -zxf redis-4.0.10.tar.gz     # -zxvf  v是显示解压的过程

3、进入redis源码中，直接可以编译且安装

　　由于解压后，直接含有Makefile文件，因此不需要执行 .configure....命令，直接 make 和 make install 即可

cd redis-4.0.10.tar.gz   # 进入源码
make && make install     # && 执行完make，直接再次执行 make install

二、修改配置文件

1、打开配置文件 redis.conf

vim /opt/redis-4.0.10/redis.conf    # 路径在下载的源码包里

　# 过滤出文件的空白行和注释行
  grep -v "^#" redis.conf | grep -v "^$"

2、修改项（4个）

　　a、更改bind参数，让redis可以远程访问

bind 0.0.0.0     # 原来是：bind 127.0.0.1

　　b、更改 redis 的默认端口

port 6380      # 原来 redis 默认端口是6379

　　c、设置 redis 密码

requirepass ******(登录redis的密码)   # 该行在文件中原本是注释掉的，现在打开注释，写上密码

　　d、设置 daemonize 为 yes，这样开启 redis 服务端就不会占用窗口，可以输入其他的命令，

daemonize yes   

三、redis启动服务

1、指定配置文件启动（启动服务端）

[root@localhost redis-4.0.10]# redis-server redis.conf     # 开启服务端

redis-server /opt/redis-4.0.10/reids.conf   # 采用绝对路径方式，开启服务

2、通过新设置的的端口和密码登录 redis（启动客户端）

redis-cli -p 6380    # 如果不写端口，则是默认 6379

auth ******    # 登录后必须 auth 验证一下密码

keys *        # 验证成功后，可以查看redis中所有的key

　　redis还支持交互式的参数，登录数据库

redis-cli -p 6380  -a  redis的密码    #（这个不太安全）

3、通过登录redis，用命令查看redis的密码

config set requirepass 新的密码         #   设置新密码
config get requirepass                        #  获取当前的密码

4、杀死 redis 服务的方法

kill pid(进程号)       # 只杀死启动的对应的redis 进程
pkill redis-server    # 根据服务名 杀死进程，可以杀死所有有关redis-server

5、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'))

6、线程池操作 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'))

redis 基础

redis基础

redis 发布订阅

1、订阅发布

　　就类似于qq，一个进程想某一个频道发送消息，收听该频道的redis进程就能够，接收到消息

　　

　　

2、常用的发布订阅的命令

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

三个角色，提供的redis命令：
1.发布者
    PUBLISH  频道  消息        # 给频道发消息
2.订阅者
    SUBSCRIBE  频道           # 订阅频道 
    PSUBSCRIBE 频道*          # 支持模糊匹配的订阅
3.频道
    channel  频道名  # 自定义

 　　其他的命令：

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

3、发布订阅示例

（1）简单的发布订阅

　　redis开启一个后端服务，支持开好几个客户端。

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

左窗口2：启动一个redis-cli窗口，想频道 music 发送消息，

　　publish  subscribe 可以大写也可以小写

 

 

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

窗口3，发布者消息

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

redis 持久化（RDB / AOF）

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

一、RDB

1、介绍

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    # dbmp.rdb 可以自己命名，在文件夹 6379中

每过900秒 有1个操作就进行持久化

save 900秒  1个修改类的操作
save 300秒  10个操作
save 60秒  10000个操作

save  900 1
save 300 10
save 60  10000

 

2、RDB的具体使用

（1）准备配置文件，在源码中创建 .conf 文件，并打开编辑配置

[root@localhost redis-4.0.10]# touch redis_s15.conf
[root@localhost redis-4.0.10]# vim redis_s15.conf 

　　在文件中添加以下内容

port 6379
daemonize yes
logfile /data/6379/redis.log
dir /data/6379 

dbfilename   s15.rdb
save 900 1                   
save 300 10               
save 60  10000    

（2）测试 rdb 功能

　　　　1）开启redis服务端，测试rdb功能

[root@localhost redis-4.0.10]# reids-server redis_s15.conf   # 这里是相对路径

　　　　2）登录redis设置一个key

[root@localhost redis-4.0.10]# redis-cli    # 因为.conf中没有设置密码，所以不输入密码就能进入
127.0.0.1:6379> 
127.0.0.1:6379> 
127.0.0.1:6379> 
127.0.0.1:6379> set name chen
OK

　　　　3）此时检查目录，/data/6379底下没有 s15.rdb文件

　　　　4）通过save触发持久化，将数据写入RDB文件,此时才有s15.rdb文件

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

二、AOF

1、介绍

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

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

 配置参数

AOF持久化配置，两条参数：

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

2、AOF的具体使用

（1）准备配置文件，在源码中创建 .conf 文件，并打开编辑配置

[root@localhost redis-4.0.10]# touch redis_s15.conf
[root@localhost redis-4.0.10]# vim redis_s15.conf 

　　在文件中添加以下内容

port 6379
daemonize yes
logfile /data/6379/redis.log
dir /data/6379

appendonly yes
appendfsync everysec

（2）启动redis服务端，指定aof功能，测试持久化数据 

　　　　1）启动 redis-server  redis_s15.conf 服务

　　　　2）检查redis数据目录/data/6379/是否产生了aof文件（产生了.aof文件）

[root@web02 6379]# ls
appendonly.aof  dbmp.rdb  redis.log

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

[root@web02 6379]# tail -f appendonly.aof

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

（3）两者的区别？

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

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

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

三、reids不重启，切换RDB备份到AOF备份

该方法，要求Redis的版本在2.2以上

# 查看版本
[root@localhost redis-4.0.10]# redis-server -v
Redis server v=4.0.10 sha=00000000:0 malloc=jemalloc-4.0.3 bits=64 build=27b865acb563d1c

 1、准备 rdb 的redis服务端

redis-server   s15-redis.conf (注明这是在rdb持久化模式下)

2、切换rdb到aof （通过命令切换）

127.0.0.1:6379>  CONFIG set appendonly yes                #用命令激活aof持久化(临时生效，注意写入到配置文件)
OK
127.0.0.1:6379> 
127.0.0.1:6379> 
127.0.0.1:6379>  CONFIG SET save ""             #关闭rdb持久化

3、将aof操作，写入到配置文件 redis_s15.conf ，永久生效，下次重启后生效

　　重写配置文件

port 6379
daemonize yes 
logfile /data/6379/redis.log
dir /data/6379   

#dbfilename   s15.rdb    rdb
#save 900 1  
#save 300 10 
#save 60  10000 

appendonly yes      # aof
appendfsync everysec

4、测试aof数据持久化 ,杀掉redis，重新启动

kill pid(进程号)
redis-server s15-redis.conf

5、写入数据，检查aof文件

redis 的主从同步

 

查看redis数据库信息，主从状态的命令

redis-cli  -p 6379  info   # 检查数据库信息 info 后可以跟参数，
redis-cli  -p 6379  info  replication   #检查数据库主从信息

一、主从配置的步骤

1、准备三个 redis 配置文件，通过端口的区分，启动三个redis数据库实例，然后配置主从复制

　　在redis的源码包中配置文件， /opt/redis-4.0.10/

　　（1）redis-6379.conf 文件  

#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

　　（2）redis-6380.conf 文件

　　三个配置文件中，除了端口，其他内容是一样的，因此这里采用命令来快速创建文件

sed "s/6379/6380/g" redis-6379.conf > redis-6380.conf    #通过命令快速生成配置文件  "s/6379/6380/g" 将6379修改成6380

slaveof 127.0.0.1 6379     #指明主库的身份ip 和端口

　　（3）redis-6381.conf 文件

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

2、启动这三个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

3、配置主从关系

 　　主从规划（主节点：6379；从节点：6380  6381）

# 设置 6380 从节点
[root@localhost redis-4.0.10]# redis-cli -p 6380
127.0.0.1:6380> slaveof 127.0.0.1 6379
127.0.0.1:6380> info replication               # 查看主从关系，因为在redis命令中，直接 info 即可


# 设置 6381 从节点
[root@localhost redis-4.0.10]# redis-cli -p 6381 
127.0.0.1:6381> slaveof 127.0.0.1 6379
127.0.0.1:6381> info replication 

# 查看主库的信息
127.0.0.1:6379> info replication

4、启动三个数据库实例，检测redis主从同步方案

主
127.0.0.1:6380> set name chaoge


从
127.0.0.1:6380>get name     # "chaoge"
127.0.0.1:6381>get name     # "chaoge"

二、redis主从复制，故障时手动切换

 　　情景：如果主库被挂掉之后，需要更改其中一个从库为主库，其他从库以该库为主库

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

1、这里先手动将主库进程杀掉

# 方式一：
kill pid(主库进程)

# 方式二：
redis-cli -p 6379
127.0.0.1:6379>shutdown


# 此时检查(info replication)从库主从信息，此时master_link_status:down 

 

2、手动切换主从身份

# 1、登录 redis-6380 ，通过命令，去掉自己的从库身份，等待连接
redis-cli -p 6380
127.0.0.1:6380> slaoveof no one    #去掉从库身份


# 2、登录redis-6381 ,通过命令，生成新的主任
redis-cli -p 6381 
127.0.0.1:6381> slaveof 127.0.0.1 6380   # 更改主库为6380

3、再次测试主从数据同步

　　同前面所讲的

redis 哨兵

哨兵就是保护redis主从集群，正常运转，当主库挂掉之后，自动的在从库中挑选新的主库，进行同步

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)
    -rw-r--r--  1 root root    227 Jan  2 18:44 redis-sentinel-26379.conf
        port 26379  
        dir /var/redis/data/
        logfile "26379.log"

        sentinel monitor s15master 127.0.0.1 6379 2  # 表示有2个哨兵同意才修改，如果是1，只要有一个哨兵发现了就更改

        sentinel down-after-milliseconds s15master 30000

        sentinel parallel-syncs s15master 1

        sentinel failover-timeout s15master 180000
        daemonize yes


    -rw-r--r--  1 root root    227 Jan  2 18:45 redis-sentinel-26380.conf
        快速生成配置文件
        sed "s/26379/26380/g" redis-sentinel-26379.conf >  redis-sentinel-26380.conf 
    -rw-r--r--  1 root root    227 Jan  2 18:46 redis-sentinel-26381.conf
        sed "s/26379/26381/g" redis-sentinel-26379.conf >  redis-sentinel-26381.conf 

    3.添加后台运行参数，使得三个哨兵进程，后台运行
[root@localhost redis-4.0.10]# echo "daemonize yes" >> redis-sentinel-26379.conf 
[root@localhost redis-4.0.10]# echo "daemonize yes" >> redis-sentinel-26380.conf 
[root@localhost redis-4.0.10]# echo "daemonize yes" >> redis-sentinel-26381.conf 

    4.启动三个哨兵
[root@localhost redis-4.0.10]#redis-sentinel redis-sentinel-26379.conf 
[root@localhost redis-4.0.10]#redis-sentinel redis-sentinel-26380.conf 
[root@localhost redis-4.0.10]#redis-sentinel redis-sentinel-26381.conf 
        
    5.检查哨兵的通信状态
    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

    6.杀死一个redis主库，6379节点，等待30s以内，检查6380和6381的节点状态
    kill 6379主节点
    redis-cli -p 6380 info replication 
    redis-cli -p 6381 info replication 
    如果切换的主从身份之后，（原理就是更改redis的配置文件，切换主从身份）
    
    7.恢复6379节点的数据库，查看是否将6379添加为新的slave身份

redis-cluster配置

 有错误，不对：

　　超哥连接

# redis-cluster安装配置
1.准备6个redis数据库实例，准备6个配置文件redis-{7000....7005}配置文件
    -rw-r--r-- 1 root root 151 Jan  2 19:26 redis-7000.conf
        port 7000
        daemonize yes
        dir "/data"            # 文件夹和下面两个文件可以自己定义名称
        logfile "7000.log"
        dbfilename "dump-7000.rdb"
        cluster-enabled yes   #开启集群模式
        cluster-config-file nodes-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.解压缩
        tar -zxvf ruby-2.3.1.tar.gz
        ./configure --prefix=/opt/ruby/       释放makefile
        make && make install     编译且安装
    3.下载安装ruby操作redis的模块包
        wget http://rubygems.org/downloads/redis-3.3.0.gem
        
        找绝对路径。。。
        
        gem install -l redis-3.3.0.gem  # 如果没有添加到环境变量，就用绝对路径  /opt/ruby/bin/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 
    
    redis-cli -c -p 7000