Redis的使用实例分析

共计 6895 个字符，预计需要花费 18 分钟才能阅读完成。

这篇文章主要介绍“Redis 的使用实例分析”，在日常操作中，相信很多人在 Redis 的使用实例分析问题上存在疑惑，丸趣 TV 小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Redis 的使用实例分析”的疑惑有所帮助！接下来，请跟着丸趣 TV 小编一起来学习吧！

Redis1. 基础知识

redis 是内存性数据库，断电，数据丢失，进程重启，数据丢失

需要配置 redis 的数据持久化，防止数据丢失

redis 支持 ms 复制，读写分离，防止单点故障，数据丢失

1.1. 安装

rpm 包安装

yum 自动化安装，在阿里的 yum 仓库中，有 redis 的软件包

yum install redis -y

源代码编译安装

# 1. 下载 redis 源码
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
# 2. 解压缩
tar -zxf redis-4.0.10.tar.gz
# 3. 切换 redis 源码目录
cd redis-4.0.10.tar.gz
# 4. 编译源文件
make 
# 5. 编译好后，src/ 目录下有编译好的 redis 指令
# 6.make install  安装到指定目录，默认在 /usr/local/bin
make install DESTDIR=/your/dir

1.2. 配置文件

修改 redis.conf，更改默认端口，设置密码，开启安全模式等操作
用 yum 安装的 redis，默认配置文件在 /etc/redis.conf

配置文件参数解释

# vim /etc/redis.conf # 打开如下参数即可 #  这里是绑定 redis 的启动地址，如果你支持远程连接，就改为 0.0.0.0bind 0.0.0.0 #更改端口 port 6500#设置 redis 的密码 requirepass haohaio# 默认打开了安全模式 protected-mode yes 
#打开一个 redis 后台运行的参数 daemonize yes

1.3. 启动 Redis

#  为什么使用 systemctl start redis 无法连接呢？#  是因为这个命令默认连接的是 6379 端口，我们更改了 redis 端口，因此无法连接了
#  请使用如下的命令，指定配置文件启动
[root@s25linux opt]# redis-server /etc/redis.conf

检查进程状态

# 检查 redis 的进程
[root@s25linux opt]# ps -ef|grep redis
root 6498 1 0 11:42 ? 00:00:00 redis-server 0.0.0.0:6500

1.4. 启动 Redis 客户端连接服务端

#  连接 redis 服务端，指定 ip 地址和端口，以及密码连接 redis
# -p  指定端口
# -h  指定 ip 地址
# auth 指令，用于密码验证
[root@s25linux opt]# redis-cli -p 6500 -h 192.168.178.143
192.168.178.143:6500  ping
(error) NOAUTH Authentication required.
192.168.178.143:6500  auth haohaio
192.168.178.143:6500  ping
PONG

1.5. 常用命令

1.keys *  列出 redis 所有的 key
2.type key  查看 key 类型
3.expire key seconds  过期时间
4.ttl key  查看 key 过期剩余时间  - 2 表示 key 已经不存在了
5.persist  取消 key 的过期时间  - 1 表示 key 存在，没有过期时间
6.exists key  判断 key 存在   存在返回 1   否则 0
7.del keys  删除 key  可以删除多个
8.dbsize  计算 key 的数量

2.RDB 持久化

redis 提供了 RDB 持久化的功能，这个功能可以将 redis 在内存中的的状态保存到硬盘中，它可以手动执行。

也可以再 redis.conf 中配置，定期执行。

RDB 持久化产生的 RDB 文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis 可以通过这个文件还原数据库当时的状态。

配置 rdb 机制的数据持久化，数据文件是一个看不懂的二进制文件，且配置触发的时间机制

vim s25_rdb_redis.conf，写入如下内容

daemonize yes #后台运行
port 6379 #端口  
logfile /data/6379/redis.log # 指定 redis 的运行日志，存储位置
dir /data/6379 #指定 redis 的数据文件，存放路径  
dbfilename s25_dump.rdb #指定数据持久化的文件名字  
bind 127.0.0.1 #指定 redis 的运行 ip 地址
#redis 触发 save 指令，用于数据持久化的时间机制  
# 900 秒之内有 1 个修改的命令操作，如 set .mset,del
save 900 1 
#  在 300 秒内有 10 个修改类的操作
save 300 10
# 60 秒内有 10000 个修改类的操作
save 60 10000

创建 redis 的数据文件夹，

mkdir -p /data/6379

杀死之前所有的 redis，防止扰乱实验

[root@s25linux s25redis]# pkill -9 redis

指定配置了 rdb 的 redis 配置文件，启动

redis-server s25_rdb_redis.conf

如果没有触发 redis 的持久化时间机制，数据文件是不会生成的，数据重启进程也会丢

可以通过编写脚本，让 redis 手动执行 save 命令，触发持久化，在 redis 命令行中，直接输入 save 即可触发持久化

127.0.0.1:6379  set addr shahe
127.0.0.1:6379 
127.0.0.1:6379  set age 18
127.0.0.1:6379 
127.0.0.1:6379 
127.0.0.1:6379  keys *
1)  age 
2)  addr 
3)  name 
127.0.0.1:6379  save
OK

存在了 rdb 持久化的文件之后，重启 redis 进程，数据也不会丢了，redis 在重启之后，会读取 dump.rdb 文件中的数据

rdb 的弊端在于什么，如果没有触发持久化机制，就发生了机器宕机，数据就会丢失了，因此 redis 有一个更好的 aof 机制

3.AOF 持久化

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

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

新建配置文件，配置以下参数。

vim s25_aof_redis.conf 
AOF 持久化配置，两条参数
appendonly yes
appendfsync always  总是修改类的操作
 everysec  每秒做一次持久化
 no  依赖于系统自带的缓存大小机制

例如参数配置为

daemonize yes
port 6379logfile /data/6379aof/redis.logdir /data/6379dbfilename dbmp.rdb
requirepass redhat
save 900 1save 300 10save 60 10000appendonly yes
appendfsync everysec

创建 aof 的数据文件夹

mkdir -p /data/6379aof

启动 aof 的 Redis 数据库

redis-server s25_aof_redis.conf

aof 机制的数据库，在首次启动的时候，就会生成 aof 数据文件了，如下

[root@s25linux 6379aof]# lsappendonly.aof redis.log

到此已经配置结束，以下为实验步骤

登录 redis, 写入数据

[root@s25linux s25redis]# redis-cli127.0.0.1:6379 127.0.0.1:6379 127.0.0.1:6379  keys *(empty list or set)127.0.0.1:6379  set name zhunbeixiakechifan
OK127.0.0.1:6379  set name2 xinkudajiale
OK127.0.0.1:6379  keys *1)  name2 2)  name

写入的操作，会被记录到 aof 文件日志中

杀死所有的 redis 进程，且重启

[root@s25linux s25redis]# pkill -9 redis[root@s25linux s25redis]# redis-server s25_aof_redis.conf

redis 的 aof 持久化机制，是在重启的时候，redis 重新执行一遍 aof 文件中的命令，实现数据复现

如果该 aof 日志文件被删除，数据也就无法恢复了

4. 一主一从数据同步复制 4.1. 说明

上午的最后一步，演示的是，当我们删除 aof 文件，或者是 rdb，aof 文件异常损坏，丢失，数据不也没了吗？

在一台机器上运行 2 个及以上的 redis，是 redis 支持多实例的功能，基于端口号的不同，就能够运行多个相互独立的 redis 数据库

什么是多实例
就是机器上运行了多个 redis 相互独立的进程
互不干扰的独立的数据库
叫做多个 redis 数据库的实例，基于配置文件区分即可

如图是 redis 的多实例功能，且配置主从同步的图

4.2. 配置步骤

准备好 2 个 redis 的配置文件，分别写入如下内容

vim s25-master-redis.conf

port 6379 #  端口
daemonize yes #  后台运行
pidfile /s25/6379/redis.pid # 
loglevel notice
logfile  /s25/6379/redis.log  #  日志存放目录
dbfilename dump.rdb #  持久化文件名
dir /s25/6379 #  数据文件保存的路径
protected-mode no #  打开安全模式

vim s25-slave-redis.conf

port 6389
daemonize yes
pidfile /s25/6389/redis.pid
loglevel notice
logfile  /s25/6389/redis.log 
dbfilename dump.rdb
dir /s25/6389
protected-mode no
#  可以直接在配置文件中，定义好复制关系，启动后，立即就会建立复制
slaveof 127.0.0.1 6379

分别生成 2 个 redis 的数据文件夹

mkdir -p /s25/{6379,6389}

分别启动 2 个 redis 数据库。

[root@s25linux s25redis]# redis-server s25-master-redis.conf
[root@s25linux s25redis]#
[root@s25linux s25redis]#
[root@s25linux s25redis]# redis-server s25-slave-redis.conf

分别检查他们的进程，以及复制关系

[root@s25linux s25redis]# redis-cli -p 6379 info replication
[root@s25linux s25redis]# redis-cli -p 6389 info replication
#  通过一条命令，配置他们的复制关系，注意，这个命令只是临时配置 redis 的复制关系，#  想要永久修改，还得修改配置文件
redis-cli -p 6389 slaveof 127.0.0.1 6379

配置完毕说明

此时
6379 ====  主库
6389 ====  从库
此时可以向 6379 中写入数据，能够同步到 6389 中
6389 是一个只读的数据库，无法写入数据

5. 一主多从及主从复制故障切换 5.1. 一主多从配置

再创建一个配置文件，port 是 6399，且加入到一主一从的复制关系中去

# vim s25-salve2-redis.conf port 6399daemonize yes
pidfile /s25/6399/redis.pid
loglevel notice
logfile  /s25/6399/redis.log dbfilename dump.rdbdir /s25/6399protected-mode no
slaveof 127.0.0.1 6379

创建数据文件夹

mkdir -p /s25/6399

此时可以启动 6399 的数据库，查看他的身份复制关系

[root@s25linux s25redis]# redis-cli -p 6399 info replication

5.2. 故障切换

故障模拟

环境准备，准备 3 个 redis 的数据库实例，分别是 6379（主）、6389（从 1）、6399（从 2），配置好一主两从的关系

[root@s25linux s25redis]# ps -ef|grep redis
root 11294 1 0 15:19 ? 00:00:01 redis-server *:6379
root 11310 1 0 15:19 ? 00:00:01 redis-server *:6389
root 11620 1 0 15:33 ? 00:00:00 redis-server *:6399

分别查看复制关系

[root@s25linux s25redis]# redis-cli -p 6379 info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6389,state=online,offset=1883,lag=1
slave1:ip=127.0.0.1,port=6399,state=online,offset=1883,lag=1

此时模拟故障，直接 kill 掉主库

kill -9 11294

此时留下 2 个孤零零的从库，没有了主人，还没发写入数据，很难受

此时一位从库(6399)，不乐意了，翻身农奴做主人，去掉自己的从库身份，

没有这个从库的枷锁，我就是我自己的主人

[root@s25linux s25redis]# redis-cli -p 6399 slaveof no one

此时 6399 已然是主库了，修改 6389 的复制信息，改为 6399 即可

[root@s25linux s25redis]# redis-cli -p 6389 slaveof 127.0.0.1 6399

此时检查他们的复制关系

[root@s25linux s25redis]# redis-cli -p 6389 info replication[root@s25linux s25redis]# redis-cli -p 6399 info replication

此时可以向主库 6399 写入数据，6389 查看数据即可

主库不挂，从库挂掉的场景

从库挂掉，无所谓，重新再建立一个从库，加入主从复制即可，。，。

你会发现，如此的手动切换复制关系，其实是很难受的，如果在夜里凌晨四点，redis 主库突然挂了，你该怎么办？你媳妇愿意让你起来干活吗？

因此你该咋办？是不是得学点别的技术？你希望有什么东西能帮你不？

有钱，你搞一个贾维斯

希望有一个人，能 24h 帮你盯着这个主从复制，发现主库宕机之后，自动的帮你进行主从切换

6. 高可用哨兵 sentinel6.1. 工作原理

配置好 redis 的哨兵进程，一般都是使用 3 个哨兵（保安）哨兵的作用是盯着 redis 主库，不断询问它是否存活，如果超过 30s（设置的时间阈值）都没有回应，3 个哨兵会判断主库宕机，谈话进行投票机制，因为 3 个哨兵，要自动的去选择从库为新的主库，每个哨兵的意见可能不一样，因此引出投票机制，少数服从多数。当多个哨兵达成一致，选择某一个从库阶段，自动的修改他们的配置文件，切换新的主库
此时如果宕机的主库，恢复后，哨兵也会自动将其加入集群，且自动分配为新的从库
这一些都是自动化，无需人为干预，贼牛屁

6.2. 架构

6.3.Redis 配置

准备 3 个 redis 节点，1 主 2 从的 redis 集群

# redis 支持多实例 ------- 基于多个配置文件，运行处多个 redis 相互独立的进程

s25-redis-6379.conf ----- 主

port 6379

daemonize yes

logfile  6379.log

dbfilename  dump-6379.rdb

dir  /var/redis/data/