redis的

redis的

关注
发信
关注(28)粉丝(399)

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 "^#"  > 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的持久化

  • 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

4. 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为主库即可

5. 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.将挂掉的主库，重新启动，查看复制信息

6. 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

# 会自动分配不同应该在的不同的槽位
12-21 18:35
Powered by LMLPHP ©2024 redis的 0.070082