• Redis持久化RDB与AOF


    一、Redis基础

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

    NoSQL

    学名(not only sql)
    
    特点:
    
    存储结构与mysql这一种关系型数据库完全不同,nosql存储的是KV形式
    
    nosql有很多产品,都有自己的api和语法,以及业务场景
    
    产品种类:
    
    Mongodb
    
    redis
    
    Hbase hadoop

    Nosql和sql的区别

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

    redis特性

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

    redis优势

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

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

    基本命令

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

    redis数据结构

    redis是一种高级的key:value存储系统,其中value支持五种数据类型
    字符串(strings)
    散列(hashes)
    列表(lists)
    集合(sets)
    有序集合(sorted sets)

    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开头的命令

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

    实例

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

    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

    二、redis发布订阅

    Redis 通过 PUBLISH 、 SUBSCRIBE 等命令实现了订阅与发布模式。发布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

    三、python操作redis

    注意配置文件

    打开注释,不然py客户端连不上  

    守护模式不开就no  

    指定配置文件进行启动  

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

    退出,重新登录redis  

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

    链接池操作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持久化RDB与AOF

    redis持久化之RDB:
    1.rdb持久化,可以手动触发持久化,通过redis放入save命令触发
    2.rdb文件是一个经过压缩的二进制文件,redis可以通过这个文件还原数据
    3.rdb持久化还有时间策略
    save  900 1          #900秒  1个修改类的操作
    save 300 10          #300秒  10个操作
    save 60  10000       #60秒  10000个操作
    
    4.使用rdb持久化的方式
    --配置文件:
        [root@localhost redis-4.0.10]# vim redis-6380.conf 
        写入以下内容:
        port 6380    #redis端口
        daemonize yes  #后台运行redis
        pidfile /data/6380/redis.pid  #pid号码
        loglevel notice   #日志等级
        logfile "/data/6380/redis.log"  #日志文件存放路径
        requirepass bubu666  #redis的密码    
        dir /data/6380  #redis数据目录/#定义持久化文件存储位置【记得去创建一下目录】    
        
        dbfilename  redis.dump        #rdb持久化文件(此文件在/data/6380目录下)
        save 900 1                    #rdb机制 每900秒 有1个修改记录
        save 300 10                   #每300秒        10个修改记录
        save 60  10000                #每60秒内        10000修改记录
    
    
    
    
    5.关闭redis服务端,准备重启或者使用kill
    redis-cli -p 6380 -a bubu666 shutdown
    
    6.使用新的支持rdb持久化的配置文件启动redis
    redis-server redis-6380.conf
    
    7.手动触发rdb持久化
    127.0.0.1:6380> set name dsb
    OK
    127.0.0.1:6380> save
    OK
    
    8.让配置文件支持定期持久化
    save 900 1                    #rdb机制 每900秒 有1个修改记录
    save 300 10                   #每300秒        10个修改记录
    save 60  10000                #每60秒内        10000修改记录
    
    
    redis持久化之AOF(企业一般多用这个):
    1.配置文件:
        [root@localhost redis-4.0.10]# vim redis-6380.conf 
        写入以下内容:
        port 6380    #redis端口
        daemonize yes  #后台运行redis
        pidfile /data/6380/redis.pid  #pid号码
        loglevel notice   #日志等级
        logfile "/data/6380/redis.log"  #日志文件存放路径
        requirepass bubu666  #redis的密码    
        dir /data/6380  #redis数据目录/#定义持久化文件存储位置【记得去创建一下目录】
        
        appendonly yes
        appendfsync everysec
    
    2.启动
    redis-server redis-6380.conf
    3.写入数据
    [root@localhost redis-4.0.10]# redis-cli -p 6380 -a bubu666
    Warning: Using a password with '-a' option on the command line interface may not be safe.
    127.0.0.1:6380> set name dsb
    OK
    127.0.0.1:6380> keys *
    1) "name"
    
    4.新终端中检查
    [root@localhost redis-4.0.10]# cd /data/6380
    [root@localhost 6380]# tail -f appendonly.aof 
    
    
    ##############################################
    
    AOF持久化配置,两条参数
    appendonly yes
    appendfsync  always    总是修改类的操作
                 everysec   每秒做一次持久化
                 no     依赖于系统自带的缓存大小机制
    
    #bind 10.0.0.10  127.0.0.1    #redis绑定地址
    
    [root@localhost ~]# redis-server -v
    Redis server v=4.0.10 sha=00000000:0 malloc=jemalloc-4.0.3 bits=64 build=b632d68350d21f18
    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,切换rdb数据到aof数据中
    1.准备一个rdb的redis数据库
        --配置文件redis-6380.conf:
        [root@localhost redis-4.0.10]# vim redis-6380.conf 
        写入以下内容:
        port 6380    #redis端口
        daemonize yes  #后台运行redis
        pidfile /data/6380/redis.pid  #pid号码
        loglevel notice   #日志等级
        logfile "/data/6380/redis.log"  #日志文件存放路径
        requirepass bubu666  #redis的密码    
        dir /data/6380  #redis数据目录/#定义持久化文件存储位置【记得去创建一下目录】    
        
        dbfilename  redis.dump        #rdb持久化文件(此文件在/data/6380目录下)
        save 900 1                    #rdb机制 每900秒 有1个修改记录
        save 300 10                   #每300秒        10个修改记录
        save 60  10000                #每60秒内        10000修改记录
        
    2.启动redis支持rdb的数据库
    redis-server redis-6380.conf
    3.设置redis的数据库,手动save触发持久化,生成持久化数据文件
    127.0.0.1:6380> save
    4.备份这个rdb文件,保证数据安全
    [root@localhost 6380]# cp redis.dump /opt/
    5.通过命令,切换持久化模式
    127.0.0.1:6380> CONFIG set appendonly yes
    127.0.0.1:6380> CONFIG SET save ""
    6.【注意】修改redis的配置文件,改为aof,以后重启完全切换到aof模式
        --配置文件redis-6380.conf:
        [root@localhost redis-4.0.10]# vim redis-6380.conf 
        写入以下内容:
        port 6380    #redis端口
        daemonize yes  #后台运行redis
        pidfile /data/6380/redis.pid  #pid号码
        loglevel notice   #日志等级
        logfile "/data/6380/redis.log"  #日志文件存放路径
        requirepass bubu666  #redis的密码    
        dir /data/6380  #redis数据目录/#定义持久化文件存储位置【记得去创建一下目录】
        
        appendonly yes
        appendfsync everysec
    不重启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的配置将丢失

    六、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"
  • 相关阅读:
    [转载]Linux 线程实现机制分析
    Linux命令学习总结:cp命令
    ORA-01012: not logged on
    TNS-12540: TNS:internal limit restriction exceeded
    ORACLE临时表空间总结
    ORACLE回收站机制介绍
    SQL Server 2008 R2 Service Pack 3 已经发布
    python中的单下划线和双下划线意义和作用
    redis基本命令的演示:
    redis百度百科和维基百科知识总结:
  • 原文地址:https://www.cnblogs.com/bubu99/p/11582163.html
Copyright © 2020-2023  润新知