zoukankan      html  css  js  c++  java
  • 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
      
      # 会自动分配不同应该在的不同的槽位
      
  • 相关阅读:
    LintCode 17.子集
    JS时间操作
    Ajax总结
    Ajax请求文件下载操作失败的原因和解决办法
    遍历Map的几种方式
    java获取文件大小的方法
    Ajax详细介绍
    第31课
    30-React JSX IN DEPTH
    28-React state提升、组件组合或继承
  • 原文地址:https://www.cnblogs.com/liubing8/p/12088653.html
Copyright © 2011-2022 走看看