Linux07 /redis

标签：time   logfile   rev   安装   messages   rubygems   成绩   sed   value   

7、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 "^#"  > s24redis.conf

• 启动redis服务端

  # 启动服务端
  redis-server s24redis.conf
  
  # 验证redis是否启动
  netstat -tunlp |grep  redis
  ps -ef|grep redis 

• 指定密码登录redis

  [root@s24_linux ~]# 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
  
  # 会自动分配不同应该在的不同的槽位

Linux07 /redis

标签：time   logfile   rev   安装   messages   rubygems   成绩   sed   value   

原文地址：https://www.cnblogs.com/liubing8/p/12088653.html