一、Redis 简介

① 什么是 Redis ？

• REmote DIctionary Server（Redis）是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库。
• Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存、分布式、可选持久性的键值对（Key-Value）存储数据库，并提供多种语言的 API。
• Redis 通常被称为数据结构服务器，因为值（value）可以是字符串（String）、哈希（Hash）、列表（list）、集合（sets）、有序集合（Sorted Set:）。
• Redis 持久化方式：全量数据（RDB：Redis DataBase）和增量请求（AOF：Append Only File），全量数据在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）；增量请求则是把内存中的数据序列转化为操作请求，用于读取文件进行 replay 得到数据，这种类似于 mysql 的 binlog，Redis 的存储分为内存存储、磁盘存储和 log 文件三部分。
• Redis 有三种集群模式：主从模式，Sentinel（哨兵）模式，Cluster 模式。

② Redis 的持久化机制

• RDB 持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是 fork 一个子进程，先将数据集写入临时文件，写入成功后，再替换之前的文件，用二进制压缩存储：

• RDB 优势：
• • 利于备份：一旦采用该方式，那么整个 Redis 数据库将只包含一个文件，这对于文件备份而言是非常完美的；
• • 数据恢复便捷：对于灾难恢复而言，RDB 是非常不错的选择，因为可以非常轻松的将一个单独的文件压缩后再转移到其它存储介质上；
• • 性能最大化：对于 Redis 的服务进程而言，在开始持久化时，它唯一需要做的只是 fork 出子进程，之后再由子进程完成这些持久化的工作，这样就可以极大的避免服务进程执行 IO 操作；
• • 相比 AOF 数据量小：相比于 AOF 机制，如果数据集很大，RDB 的启动效率会更高。
• RDB 劣势：
• • 数据的完整性和一致性不高：系统一旦在定时持久化之前出现宕机现象，此前没有来得及写入磁盘的数据都将丢失；
• • 备份时占用内存：因为 Redis 在备份时会独立创建一个子进程，将数据写入到一个临时文件（此时内存中的数据是原来的两倍），最后再将临时文件替换之前的备份文件，因此 Redis 的持久化和数据的恢复要选择在夜深人静的时候执行是比较合理的；
• RDB 持久化配置：
• • Redis 会将数据集的快照 dump 到 dump.rdb 文件中，此外也可以通过配置文件来修改 Redis 服务器 dump 快照的频率，在打开 6379.conf 文件之后，搜索 save，可以看到下面的配置信息：

save 900 1           #在900秒(15分钟)之后，如果至少有1个key发生变化，则dump内存快照
save 300 10          #在300秒(5分钟)之后，如果至少有10个key发生变化，则dump内存快照
save 60 10000        #在60秒(1分钟)之后，如果至少有10000个key发生变化，则dump内存快照

• 除了上面配置的会触发 RDB 持久化，还有以下几种默认方式：
• • 执行 save（阻塞， 只管保存快照，其他的等待） 或者是 bgsave （异步）命令；
• • 执行 flushall 命令，清空数据库所有数据，意义不大；
• • 执行 shutdown 命令，保证服务器正常关闭且不丢失任何数据。
• AOF 持久化以日志的形式记录服务器所处理的每一个写、删除操作，查询操作不会记录，以文本的方式记录，可以打开文件看到详细的操作记录：

• Redis AOF 默认关闭，开启需要手动把 no 改为 yes：

# 开启
appendonly yes
# 指定文件名
appendfilename "appendonly.aof"

• AOF 的优势：
• • 数据的完整性和一致性更高：Redis 中提供了 3 中同步策略，即每秒同步、每修改同步和不同步；
• • 事实上每秒同步也是异步完成的，其效率也是非常高的，所差的是一旦系统出现宕机现象，那么这一秒钟之内修改的数据将会丢失；
• • 而每修改同步，可以将其视为同步持久化，即每次发生的数据变化都会被立即记录到磁盘中。
• AOF 的劣势：
• • 占用磁盘空间大，数据恢复速度慢：对于相同数量的数据集而言，AOF 文件通常要大于 RDB 文件，RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快；
• • 运行效率低，频繁同步：根据同步策略的不同，AOF 在运行效率上往往会慢于 RDB，总之每秒同步策略的效率是比较高的，同步禁用策略的效率和 RDB 一样高效。
• 在 Redis 的配置文件中存在三种同步方式，它们分别是：

appendfsync always       #每次有数据修改发生时都会写入AOF文件
appendfsync everysec     #每秒钟同步一次，该策略为AOF的缺省策略
appendfsync no           #从不同步，高效但是数据不会被持久化

• RDB 与 AOF 如何选择：
• • 一般来说，如果想达到足以媲美 PostgreSQL 的数据安全性，应该同时使用两种持久化方式；
• • 有很多用户都只使用 AOF 持久化， 但并不推荐这种方式： 因为定时生成 RDB 快照（snapshot）非常便于进行数据库备份， 并且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快。

二、“主从模式”部署

① “主从模式”架构

• 主从模式特点：
• • 主数据库可以进行读写操作，当读写操作导致数据变化时会自动将数据同步给从数据库；
• • 从数据库一般都是只读的，并且接收主数据库同步过来的数据；
• • 一个 master 可以拥有多个 slave，但是一个 slave 只能对应一个 master；
• • slave 挂了不影响其他 slave 的读和 master 的读和写，重新启动后会将数据从 master 同步过来；
• • master 挂了以后，不影响 slave 的读，但 redis 不再提供写服务，master 重启后 redis 将重新对外提供写服务；
• • master 挂了以后，不会在 slave 节点中重新选一个 master。
• 工作机制：
• • 当 slave 启动后，主动向 master 发送 SYNC 命令，master 接收到 SYNC 命令后在后台保存快照（RDB持久化）和缓存保存快照这段时间的命令，然后将保存的快照文件和缓存的命令发送给 slave，slave 接收到快照文件和命令后加载快照文件和缓存的执行命令；
• • 复制初始化后，master 每次接收到的写命令都会同步发送给 slave，保证主从数据一致性。
• 主从复制模式中包含一个主数据库实例（master）与一个或多个从数据库实例（slave），数据的复制是单向的，只能由主节点到从节点，从节点一般只读，如下所示：

• 优点：
• • 架构简单，部署方便；
• • 高可靠性：一方面，采用双机主备架构，能够在主库出现故障时自动进行主备切换，从库提升为主库提供服务，保证服务平稳运行;另一方面，开启数据持久化功能和配置合理的备份策略，能有效的解决数据误操作和数据异常丢失的问题；
• • 读写分离策略：从节点可以扩展主库节点的读能力，有效应对大并发量的读操作。
• 缺点：
• • master 单节点风险：从上面可以看出，master 节点在主从模式中唯一，若 master 挂掉，则 redis 无法对外提供写服务；
• • 不保证数据的可靠性：在缓存使用，进程重启后，数据丢失，即使有备用的节点解决高可用性，但是仍然不能解决缓存预热问题，因此不适用于数据可靠性要求高的业务；
• • 主节点的写能力受到单机的限制。

② 主从同步原理

• Redis 全量复制一般发生在 Slave 初始化阶段，这时 Slave 需要将 Master 上的所有数据都复制一份。具体步骤如下：
• • 从服务器连接主服务器，发送 SYNC 命令；
• • 主服务器接收到 SYNC 命名后，开始执行 BGSAVE 命令生成 RDB 文件并使用缓冲区记录此后执行的所有写命令；
• • 主服务器 BGSAVE 执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令；
• • 从服务器收到快照文件后丢弃所有旧数据，载入收到的快照；
• • 主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令；
• • 从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；

• 增量同步：
• • Redis 增量复制是指 Slave 初始化后开始正常工作时主服务器发生的写操作同步到从服务器的过程；
• • 增量复制的过程主要是主服务器每执行一个写命令就会向从服务器发送相同的写命令，从服务器接收并执行收到的写命令。
• Redis 主从同步策略：主从刚刚连接的时候，进行全量同步；全同步结束后，进行增量同步；当然，如果有需要，slave 在任何时候都可以发起全量同步，redis 策略是，无论如何，首先会尝试进行增量同步，如不成功，要求从机进行全量同步。

③ 环境准备

IP	主机名	角色
local-168-182-110	192.168.182.110	master
local-168-182-111	192.168.182.111	slave1
local-168-182-112	192.168.182.112	slave2

④ 下载解压 Redis 安装包（所有节点）

cd /opt/software
wget http://download.redis.io/releases/redis-7.0.3.tar.gz
# 解压
tar -xf redis-7.0.3.tar.gz
cd redis-7.0.3
# 设置环境变量
echo "export REDIS_HOME=/opt/software/redis-7.0.3">> /etc/profile
source /etc/profile

⑤ 编译安装（所有节点）

cd $REDIS_HOME
yum -y install gcc gcc++
make && make install
# 默认安装目录 /usr/local/bin

⑥ 配置成服务（所有节点）

cat << EOF > /usr/lib/systemd/system/redis.service
[Unit]
Description=Redis persistent key-value database
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/usr/local/bin/redis-server /usr/local/redis/redis.conf --supervised systemd
ExecStop=/usr/libexec/redis-shutdown
Type=forking
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
LimitNOFILE=65536
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

• 配置说明：

Description: # 描述服务 
After: # 描述服务类别 
[Service] # 服务运行参数的设置 
Type=forking # 是后台运行的形式 
ExecStart # 为服务的具体运行命令 
ExecReload # 为重启命令 
ExecStop # 为停止命令 
LimitNOFILE=65536 # 打开文件数和进程数有限制，默认限制为1024，如果不设置，或者设置为LimitNOFILE=unlimited(不识别)，则得到了1024
PrivateTmp=True # 表示给服务分配独立的临时空间 
#【注意】[Service]的启动、重启、停止命令全部要求使用绝对路径 
[Install] #运行级别下服务安装的相关设置，可设置为多用户，即系统运行级别为3

重载系统服务：systemctl daemon-reload

• /usr/libexec/redis-shutdown：

#!/bin/bash
#
# Wrapper to close properly redis and sentinel
test x"$REDIS_DEBUG" != x && set -x

REDIS_CLI=/usr/local/bin/redis-cli

# Retrieve service name
SERVICE_NAME="$1"
if [ -z "$SERVICE_NAME" ]; then
   SERVICE_NAME=redis
fi

# Get the proper config file based on service name
CONFIG_FILE="/usr/local/redis/$SERVICE_NAME.conf"

# Use awk to retrieve host, port from config file
HOST=`awk '/^[[:blank:]]*bind/ { print $2 }' $CONFIG_FILE | tail -n1`
PORT=`awk '/^[[:blank:]]*port/ { print $2 }' $CONFIG_FILE | tail -n1`
PASS=`awk '/^[[:blank:]]*requirepass/ { print $2 }' $CONFIG_FILE | tail -n1`
SOCK=`awk '/^[[:blank:]]*unixsocket\s/ { print $2 }' $CONFIG_FILE | tail -n1`

# Just in case, use default host, port
HOST=${HOST:-127.0.0.1}
if [ "$SERVICE_NAME" = redis ]; then
    PORT=${PORT:-6379}
else
    PORT=${PORT:-26739}
fi

# Setup additional parameters
# e.g password-protected redis instances
[ -z "$PASS"  ] || ADDITIONAL_PARAMS="-a $PASS"

# shutdown the service properly
if [ -e "$SOCK" ] ; then
        $REDIS_CLI -s $SOCK $ADDITIONAL_PARAMS shutdown
else
        $REDIS_CLI -h $HOST -p $PORT $ADDITIONAL_PARAMS shutdown
fi

• 配置完就可以通过 systemctl 启停 redis。

⑦ 授权启动服务（所有节点）

chmod +x /usr/libexec/redis-shutdown
useradd -s /sbin/nologin redis
mkdir /usr/local/redis ; cp $REDIS_HOME/redis.conf /usr/local/redis/ && chown -R redis:redis /usr/local/redis
mkdir -p /opt/software/redis-7.0.3/data && chown -R redis:redis /opt/software/redis-7.0.3/data
yum install -y bash-completion && source /etc/profile                 # 命令补全
systemctl daemon-reload
systemctl enable redis

⑧ 配置（redis.conf）

• 修改 linux 内核参数：

# 临时生效
sysctl  -w  vm.overcommit_memory=1
# 永久生效
echo 'vm.overcommit_memory=1' >> /etc/sysctl.conf && sysctl -p
### 可选值：0，1，2
# 0：表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则，内存申请失败，并把错误返回给应用进程
# 1：表示内核允许分配所有的物理内存，而不管当前的内存状态如何
# 2：表示内核允许分配超过所有物理内存和交换空间总和的内存

• master 节点配置，修改配置如下：vi /usr/local/redis/redis.conf：

bind 192.168.182.110                 # 监听ip，多个ip用空格分隔
daemonize yes                        # 允许后台启动
logfile "/usr/local/redis/redis.log" # 日志路径
dir /opt/software/redis-7.0.3/data   # 数据库备份文件存放目录
masterauth 123456                    # slave连接master密码，master可省略
requirepass 123456                   # 设置master连接密码，slave可省略

appendonly yes                       # 在/opt/software/redis-7.0.3/data目录生成appendonly.aof文件，将每一次写操作请求都追加到appendonly.aof 文件中

• slave1 节点配置，修改配置如下：vi /usr/local/redis/redis.conf：

bind 192.168.182.111                  # 监听ip，多个ip用空格分隔
daemonize yes               		  # 允许后台启动
logfile "/usr/local/redis/redis.log"  # 日志路径
dir /opt/software/redis-7.0.3/data    # 数据库备份文件存放目录
#  replicaof用于追随某个节点的redis，被追随的节点为主节点，追随的为从节点。就是设置master节点
replicaof 192.168.182.110 6379
masterauth 123456                     # slave连接master密码，master可省略
requirepass 123456              	  # 设置master连接密码，slave可省略
appendonly yes                  	  # 在/opt/software/redis-7.0.3/data目录生成appendonly.aof文件，将每一次写操作请求都追加到appendonly.aof 文件中

• slave2 节点配置，修改配置如下：vi /usr/local/redis/redis.conf：

bind 192.168.182.112                 # 监听ip，多个ip用空格分隔
daemonize yes                        # 允许后台启动
logfile "/usr/local/redis/redis.log" # 日志路径
dir /opt/software/redis-7.0.3/data   # 数据库备份文件存放目录
#  replicaof用于追随某个节点的redis，被追随的节点为主节点，追随的为从节点。就是设置master节点
replicaof 192.168.182.110 6379
masterauth 123456               	 # slave连接master密码，master可省略
requirepass 123456              	 # 设置master连接密码，slave可省略
appendonly yes                  	 # 在/opt/software/redis-7.0.3/data目录生成appendonly.aof文件，将每一次写操作请求都追加到appendonly.aof 文件中

⑨ 启动 Redis 服务

systemctl start redis
systemctl status redis

⑩ 查看集群状态

# 交互式
redis-cli -h 192.168.182.110 -a 123456
192.168.182.110:6379> info replication

# 交互式
redis-cli -h 192.168.182.110
192.168.182.110:6379> auth 123456
192.168.182.110:6379> info replication

# 非交互式
redis-cli -h 192.168.182.110 -a 123456 info replication

三、“Sentinel（哨兵）模式”部署

① Sentinel 模式的架构

• 主从模式的弊端就是不具备高可用性，当 master 挂掉以后，Redis 将不能再对外提供写入操作，因此 sentinel 应运而生。
• sentinel 中文含义为哨兵，顾名思义，它的作用就是监控 redis 集群的运行状况，特点如下：
• • sentinel 模式是建立在主从模式的基础上，如果只有一个 Redis 节点，sentinel 就没有任何意义；
• • 当 master 挂了以后，sentinel 会在 slave 中选择一个做为 master，并修改它们的配置文件，其他 slave 的配置文件也会被修改，比如 slaveof 属性会指向新的 master；
• • 当 master 重新启动后，它将不再是 master 而是做为 slave 接收新的 master 的同步数据；
• • sentinel 因为也是一个进程有挂掉的可能，因此 sentinel 也会启动多个形成一个 sentinel 集群；
• • 多 sentinel 配置的时候，sentinel 之间也会自动监控；
• • 当主从模式配置密码时，sentinel 也会同步将配置信息修改到配置文件中，不需要担心；
• • 一个 sentinel 或 sentinel 集群可以管理多个主从 Redis，多个 sentinel 也可以监控同一个 redis；
• • sentinel 最好不要和 Redis 部署在同一台机器，不然 Redis 的服务器挂了以后，sentinel 也挂了。

• 工作机制：
• • 每个 sentinel 以每秒钟一次的频率向它所知的 master，slave 以及其他 sentinel 实例发送一个 PING 命令；
• • 如果一个实例距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 sentinel 标记为主观下线；
• • 如果一个 master 被标记为主观下线，则正在监视这个 master 的所有 sentinel 要以每秒一次的频率确认 master 的确进入了主观下线状态；
• • 当有足够数量的 sentinel（大于等于配置文件指定的值）在指定的时间范围内确认 master 的确进入了主观下线状态， 则 master 会被标记为客观下线；
• • 在一般情况下， 每个 sentinel 会以每 10 秒一次的频率向它已知的所有 master，slave 发送 INFO 命令；
• • 当 master 被 sentinel 标记为客观下线时，sentinel 向下线的 master 的所有 slave 发送 INFO 命令的频率会从 10 秒一次改为 1 秒一次；
• • 若没有足够数量的 sentinel 同意 master 已经下线，master 的客观下线状态就会被移除；若 master 重新向 sentinel 的 PING 命令返回有效回复，master 的主观下线状态就会被移除。
• 优点：
• • 高可用：主从可以自动切换，系统更健壮，可用性更高；
• • 实现监控多组节点：可以实现一套 Sentinel 监控一组 Redis 数据节点或多组数据节点。
• 缺点：
• • 部署复杂：部署相对 Redis 主从模式要复杂一些，原理理解更繁琐；
• • 资源浪费：Redis 数据节点中 slave 节点作为备份节点不提供服务；
• • 默认不支持读写分离：不能解决读写分离问题，实现起来相对复杂；
• • 维护成本大：需要多维护一套监控节点；
• • Redis 较难支持在线扩容：对于集群，容量达到上限时在线扩容会变得很复杂。

② 环境准备

IP	主机名	角色
local-168-182-110	192.168.182.110	master，sentinel
local-168-182-111	192.168.182.111	slave1，sentinel
local-168-182-112	192.168.182.112	slave2，sentinel

③ 配置 sentinel（所有节点）

• 由于前面已经安装过 redis 主从模式，因为哨兵模式是基于主从模式的，因此 redis 的配置这里省略，直接修改 sentinel 配置文件，配置 3 个哨兵，每个哨兵的配置都是一样的。

# 三个节点创建存储目录
mkdir /opt/software/redis-7.0.3/sentinel
mkdir /opt/software/redis-7.0.3/sentinel ; chown -R redis:redis /opt/software/redis-7.0.3/

cat >/usr/local/redis/sentinel.conf<<EOF
daemonize yes
logfile "/usr/local/redis/sentinel.log"
# sentinel工作目录
dir "/opt/software/redis-7.0.3/sentinel"
# 判断master失效至少需要2个sentinel同意，建议设置为n/2+1，n为sentinel个数
# sentinel monitor <master-name> <ip> <port> <count>
sentinel monitor mymaster 192.168.182.110 6379 2
sentinel auth-pass mymaster 123456
# 判断master主观下线时间，默认30s
sentinel down-after-milliseconds mymaster 30000
EOF

④ 启动 sentinel（所有节点）

/usr/local/bin/redis-sentinel /usr/local/redis/sentinel.conf
netstat -tnlp|grep 26379

⑤ 模拟故障测试

# 停掉master
systemctl stop redis
redis-cli -h 192.168.182.111 -a 123456 info replication

• 发现 master 节点已经切换到其它节点，再测试一下读写：

[root@local-168-182-110 redis-7.0.3]# redis-cli -h 192.168.182.112 -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
192.168.182.112:6379> set k2 v2
OK

• 新的 master 节点写能力也正常，接下来就是恢复故障：

redis-cli -h 192.168.182.112 -a 123456 info replication

• 发现就算原先的 master 节点恢复，也不会切换到 master 角色，而是作为 slave 角色。

四、“Cluster 模式”部署

① Cluster 模式的架构

• 前面的两种模式数据都是在一个节点上的，单个节点存储是存在上限的，集群模式就是把数据进行分片存储，当一个分片数据达到上限的时候，就分成多个分片。Redis3.0 加入了 Redis 的集群模式，对数据进行分片，将不同的数据存储在不同的 master 节点上面，从而实现了海量数据的分布式存储和在线扩容的问题：
• • Redis Cluster 集群模式通常具有 高可用、可扩展性、分布式、容错 等特性；
• • Redis Cluster 集群节点最小配置 6 个节点以上(3 主 3 从)，其中主节点提供读写操作，从节点作为备用节点，不提供请求，只作为故障转移使用；
• • Redis Cluster 采用虚拟槽分区，所有的键根据哈希函数映射到 0～16383 个整数槽内，每个节点负责维护一部分槽以及槽所印映射的键值数据。
• 如下所示，Redis 集群可以看成多个主从架构组合起来的，每一个主从架构可以看成一个节点（其中，只有 master 节点具有处理请求的能力，slave 节点主要是用于节点的高可用）：

• Cluster 模式的特点：
• • 多个 redis 节点网络互联，数据共享；
• • 所有的节点都是一主一从（也可以是一主多从），其中从不提供服务，仅作为备用；
• • 不支持同时处理多个 key（如 MSET/MGET），因为 redis 需要把 key 均匀分布在各个节点上，并发量很高的情况下同时创建 key-value 会降低性能并导致不可预测的行为；
• • 支持在线增加、删除节点；
• • 客户端可以连接任何一个主节点进行读写。
• Cluster 模式的工作机制：
• • 选举：集群启动后，主从已分配完成，经过了 N 轮的选举，当某一个主节点宕机，那么从节点需要经过选举成为主节点。简单介绍选举过程：所有子节点向其他节点发送请求，请求自身成为主节点，其他节点收到请求后，返回投票信息，只有主节点 master 有权投票，且只能投一次，当获取到的票数大于一半人数时（master 个数），就当选 master；期间，所有子节点发送请求的时机有所有不同，因此基本都有先后顺序，很少会出现票数相同情况，如果相同，则重新选举，直到选出 master 为止。故需要至少 3 主 3 从，否则节点出现问题，将选举失败。
• • 槽位：在 Redis 集群中，定义了 16384 个逻辑上的槽位，将这些槽位均匀分配给 N 个节点（一主一从为一个节点），此文 3 个节点，自动均匀分配，意思为，0-5460 个槽位分配给第一个节点；当用户 set 一个值时，除了计算 key 本身的 hashCode 之外，还会调用 C 语言的一个 CRC16 算法，将 key 当 hash 值再计算出一个数字，然后与 16384 取模，得到的数字落在哪个槽位，则会将数据放在对应的节点。比如，计算出的数字为 16387，则取模 16384 后，得到 3，在 0-5460 之间，则放入对于的第一个节点。其他以此类推。
• • 跳转：主从模式中，只有主节点可以写入数据，而从节点只能读取数据。在 Cluster 集群中，设置值时，如果计算出的槽位在另一台服务器上，则集群连接会自动跳转至相应服务器。
• 优点：
• • 无中心架构；
• • 数据共享：数据按照 slot 存储分布在多个节点，节点间数据共享，可动态调整数据分布；
• • 可扩展性：可线性扩展到 1000 多个节点，节点可动态添加或删除；
• • 高可用性：部分节点不可用时，集群仍可用，通过增加 Slave 做 standby 数据副本，能够实现故障自动 failover，节点之间通过 gossip 协议交换状态信息，用投票机制完成 Slave 到 Master 的角色提升；
• • 任意节点读写：客户端可以连接任何一个主节点进行读写。
• 缺点：
• • 实现复杂，开发成本高；
• • 需要建立配套的周边设施，如监控，域名服务，存储元数据信息的数据库等；
• • 维护成本高。

② 环境准备

• 三台机器，分别开启三个 redis 服务，也就是每个节点就是一主两从模式：

IP	主机名	端口	节点
local-168-182-110	192.168.182.110	7001,7002,7003	node1
local-168-182-111	192.168.182.111	7001,7002,7003	node2
local-168-182-112	192.168.182.112	7001,7002,7003	node3

③ 修改配置（所有节点）

• 基于主从模式的配置修改，不是基于主从模式部署，哨兵模式是基于主从模式部署。

# 创建存储目录
mkdir -p /opt/software/redis-7.0.3/cluster/redis_{7001..7003}
cp /usr/local/redis/redis.conf /usr/local/redis/cluster_redis_7001.conf
cp /usr/local/redis/redis.conf /usr/local/redis/cluster_redis_7002.conf
cp /usr/local/redis/redis.conf /usr/local/redis/cluster_redis_7003.conf

chown -R redis:redis /usr/local/redis ;chown -R redis:redis /opt/software/redis-7.0.3/cluster

• 修改配置文件 /usr/local/redis/cluster_redis_7001.conf：

# 【注意】节点不一样，IP不一样，记得修改这个bind配置
bind 192.168.182.110
port 7001
daemonize yes
pidfile "/var/run/cluster_redis_7001.pid"
logfile "/usr/local/redis/cluster_redis_7001.log"
dir "/opt/software/redis-7.0.3/cluster/redis_7001"
#replicaof 192.168.182.110 6379
masterauth "123456"
requirepass "123456"
appendonly yes
# 开启集群模式
cluster-enabled yes
# 虽然此配置的名字叫"集群配置文件"，但是此配置文件不能人工编辑，它是集群节点自动维护的文件，主要用于记录集群中有哪些节点、他们的状态以及一些持久化参数等，方便在重启时恢复这些状态。通常是在收到请求之后这个文件就会被更新。
cluster-config-file nodes_7001.conf
cluster-node-timeout 15000

• 修改配置文件 /usr/local/redis/cluster_redis_7002.conf：

# 【注意】节点不一样，IP不一样，记得修改这个bind配置
bind 192.168.182.110
port 7002
daemonize yes
pidfile "/var/run/cluster_redis_7002.pid"
logfile "/usr/local/redis/cluster_redis_7002.log"
dir "/opt/software/redis-7.0.3/cluster/redis_7002"
#replicaof 192.168.182.110 6379
masterauth "123456"
requirepass "123456"
appendonly yes
# 配置yes则开启集群功能，此redis实例作为集群的一个节点，否则，它是一个普通的单一的redis实例。
cluster-enabled yes
# 虽然此配置的名字叫"集群配置文件"，但是此配置文件不能人工编辑，它是集群节点自动维护的文件，主要用于记录集群中有哪些节点、他们的状态以及一些持久化参数等，方便在重启时恢复这些状态。通常是在收到请求之后这个文件就会被更新。
cluster-config-file nodes_7002.conf
cluster-node-timeout 15000

• 修改配置文件 /usr/local/redis/cluster_redis_7002.conf：

# 【注意】节点不一样，IP不一样，记得修改这个bind配置
bind 192.168.182.110
port 7003
daemonize yes
pidfile "/var/run/cluster_redis_7003.pid"
logfile "/usr/local/redis/cluster_redis_7003.log"
dir "/opt/software/redis-7.0.3/cluster/redis_7003"
#replicaof 192.168.182.110 6379
masterauth "123456"
requirepass "123456"
appendonly yes
# 配置yes则开启集群功能，此redis实例作为集群的一个节点，否则，它是一个普通的单一的redis实例。
cluster-enabled yes
# 虽然此配置的名字叫"集群配置文件"，但是此配置文件不能人工编辑，它是集群节点自动维护的文件，主要用于记录集群中有哪些节点、他们的状态以及一些持久化参数等，方便在重启时恢复这些状态。通常是在收到请求之后这个文件就会被更新。
cluster-config-file nodes_7003.conf
cluster-node-timeout 15000

• 其它两台机器配置与 192.168.182.110 一致，只是 ip 不同，此处省略：

# 将配置copy到另外两个节点
scp -r /usr/local/redis/cluster_redis_{7001..7003}.conf local-168-182-111:/usr/local/redis/
scp -r /usr/local/redis/cluster_redis_{7001..7003}.conf local-168-182-112:/usr/local/redis/

# 在node2上执行
sed -i 's/192.168.182.110/192.168.182.111/g' /usr/local/redis/cluster_redis_{7001..7003}.conf

# 在node3上执行
sed -i 's/192.168.182.110/192.168.182.112/g' /usr/local/redis/cluster_redis_{7001..7003}.conf

④ 启动 Redis 服务（所有节点）

redis-server /usr/local/redis/cluster_redis_7001.conf
netstat -tnlp|grep 7001
redis-server /usr/local/redis/cluster_redis_7002.conf
netstat -tnlp|grep 7002
redis-server /usr/local/redis/cluster_redis_7003.conf
netstat -tnlp|grep 7003
tail -f /usr/local/redis/cluster_redis_7001.log
tail -f /usr/local/redis/cluster_redis_7002.log
tail -f /usr/local/redis/cluster_redis_7003.log

⑤ 创建集群

# –cluster-replicas 2 : 表示集群的一个主节点有2个从节点，就是一主两从模式
redis-cli -a 123456 --cluster create \
192.168.182.110:7001 192.168.182.110:7002 192.168.182.110:7003 \
192.168.182.111:7001 192.168.182.111:7002 192.168.182.111:7003 \
192.168.182.112:7001 192.168.182.112:7002 192.168.182.112:7003 \
--cluster-replicas 2

• 会自动生成 nodes.conf 文件：

ll /opt/software/redis-7.0.3/cluster/redis_{7001..7003}

⑥ 集群操作

• 登录集群：

redis-cli -c -h 192.168.182.110 -p 7001
192.168.182.110:7001> auth 123456

• 查看集群信息：

redis-cli -c -h 192.168.182.129 -p 7001
192.168.182.110:7001> auth 123456
192.168.182.110:7001> CLUSTER INFO

• 列出节点信息：

redis-cli -c -h 192.168.182.129 -p 7001
192.168.182.110:7001> auth 123456
192.168.182.110:7001> CLUSTER INFO
192.168.182.110:7001> CLUSTER NODES

• 在 node1 上增加一节点：

# copy配置
cp /usr/local/redis/cluster_redis_7003.conf /usr/local/redis/cluster_redis_7004.conf
# 创建存储目录
mkdir /opt/software/redis-7.0.3/cluster/redis_7004

# 修改配置
vi /usr/local/redis/cluster_redis_7004.conf

bind 192.168.182.110
port 7004
daemonize yes
pidfile "/var/run/redis_7004.pid"
logfile "/usr/local/redis/cluster_redis_7004.log"
dir "/opt/software/redis-7.0.3/cluster/redis_7004"
#replicaof 192.168.182.110 6379
masterauth "123456"
requirepass "123456"
appendonly yes
cluster-enabled yes
cluster-config-file nodes_7004.conf
cluster-node-timeout 15000

# 授权
chown -R redis:redis /usr/local/redis && chown -R redis:redis /opt/software/redis-7.0.3/cluster/redis_7004

• 启动服务：

redis-server /usr/local/redis/cluster_redis_7004.conf
netstat -tnlp|grep :7004

• 集群中增加节点：

[root@local-168-182-110 ~]# redis-cli -c -h 192.168.182.110 -p 7001
192.168.182.110:7001> auth 123456
# 添加节点
192.168.182.110:7001> CLUSTER MEET 192.168.182.110 7004
# 查看节点信息
192.168.182.110:7001> CLUSTER NODES

• 可以看到，新增的节点都是以 master 身份加入集群的。将新增的 192.168.182.110:7004 节点身份改为 192.168.182.130:7001 的 slave：

redis-cli -c -h 192.168.182.110 -p 7004
192.168.182.110:7004> auth 123456
# 改变节点类型
192.168.182.110:7004> cluster replicate 0a9d68b75d529b611b4bae5753be602006fcef74
192.168.182.110:7004> CLUSTER NODES

• 删除节点：

redis-cli -c -h 192.168.182.110 -p 7001
192.168.182.110:7001> auth 123456
# 查看节点
192.168.182.110:7001> CLUSTER NODES
# 删除节点
192.168.182.110:7001> CLUSTER FORGET 378ef2a24fb4138496b8da85bb66143800b53686
# 检查节点信息
192.168.182.110:7001> CLUSTER NODES

• 保存配置：

redis-cli -c -h 192.168.182.110 -p 7001
192.168.182.110:7001> auth 123456
# 将节点的配置文件保存到硬盘里面
192.168.182.110:7001> CLUSTER SAVECONFIG

• 可以看到，之前删除的节点又恢复了，这是因为对应的配置文件没有删除，执行 CLUSTER SAVECONFIG 恢复：

• 模拟 master 节点挂掉：

netstat -lntp |grep :7001|awk '{print $NF}'|cut -d '/' -f 1|xargs kill -9
redis-cli -c -h 192.168.182.111 -p 7001 -a 123456 CLUSTER NODES

• 对应 192.168.182.110:7001 的一行可以看到，master fail，状态为 disconnected；而对应 192.168.182.110:7004 的一行，slave 已经变成 master。重新启动 192.168.182.110:7001 节点：

redis-server /usr/local/redis/cluster_redis_7001.conf
redis-cli -c -h 192.168.182.111 -p 7001 -a 123456 CLUSTER NODES

• 可以看到，192.168.182.110:7001 节点启动后为 slave 节点，并且是 192.168.182.110:7004 的 slave 节点，即 master 节点如果挂掉，它的 slave 节点变为新 master 节点继续对外提供服务，而原来的 master 节点如果重启，则变为新 master 节点的 slave 节点。
• 注意：cluster 不能选择 db，只能默认 db 为 0，因此 select 切库相当于是不能使用的。

五、简单使用

① 集群常用操作

• 查看集群信息：

cluster info ：打印集群的信息
cluster nodes ：列出集群当前已知的所有节点（node），以及这些节点的相关信息

• 节点操作：

cluster meet <ip> <port> ：将 ip 和 port 所指定的节点添加到集群当中，让它成为集群的一份子
cluster forget <node_id> ：从集群中移除 node_id 指定的节点
cluster replicate <node_id> ：将当前节点设置为 node_id 指定的节点的从节点
cluster saveconfig ：将节点的配置文件保存到硬盘里面

• 槽（slot）：

cluster addslots <slot> [slot ...] ：将一个或多个槽（slot）指派（assign）给当前节点
cluster delslots <slot> [slot ...] ：移除一个或多个槽对当前节点的指派
cluster flushslots ：移除指派给当前节点的所有槽，让当前节点变成一个没有指派任何槽的节点
cluster setslot <slot> node <node_id> ：将槽 slot 指派给 node_id 指定的节点，如果槽已经指派给
另一个节点，那么先让另一个节点删除该槽>，然后再进行指派
cluster setslot <slot> migrating <node_id> ：将本节点的槽 slot 迁移到 node_id 指定的节点中
cluster setslot <slot> importing <node_id> ：从 node_id 指定的节点中导入槽 slot 到本节点
cluster setslot <slot> stable ：取消对槽 slot 的导入（import）或者迁移（migrate）

• 键：

cluster keyslot <key> ：计算键 key 应该被放置在哪个槽上
cluster countkeysinslot <slot> ：返回槽 slot 目前包含的键值对数量
cluster getkeysinslot <slot> <count> ：返回 count 个 slot 槽中的键

② redis 常用操作

• 字符串（String）：

# 登录master节点，slave节点是只读的
redis-cli -c -h 192.168.182.112 -p 7001
192.168.182.112:7001> auth 123456
OK
192.168.182.112:7001> set k1 v1
OK
192.168.182.112:7001> get k1
"v1"
# 获取多个值
192.168.182.112:7001> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"

• 哈希（Hash）：Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象：

# 登录master节点，slave节点是只读的
redis-cli -c -h 192.168.182.112 -p 7001
192.168.182.112:7001> auth 123456
# 设置
192.168.182.112:7001> HSET myhash field1 "foo"
(integer) 1
# 获取
192.168.182.112:7001> hget myhash field1
"foo"

• 列表（List）：Redis 列表是简单的字符串列表，按照插入顺序排序，可以添加一个元素到列表的头部（左边）或者尾部（右边）：

# 登录master节点，slave节点是只读的
redis-cli -c -h 192.168.182.112 -p 7001
192.168.182.112:7001> auth 123456
192.168.182.112:7001> LPUSH larr v1
(integer) 1
192.168.182.112:7001> LPUSH larr v2
(integer) 2
192.168.182.112:7001> LPUSH larr v3
(integer) 3
# 获取0到10个元素
192.168.182.112:7001> LRANGE larr  0 10
1) "v3"
2) "v2"
3) "v1"

• 集合（Set）：Redis 的 Set 是 String 类型的无序集合，集合成员是唯一的，这就意味着集合中不能出现重复的数据：

# 登录master节点，slave节点是只读的
redis-cli -c -h 192.168.182.112 -p 7001
192.168.182.112:7001> auth 123456
192.168.182.112:7001> SADD myset "hello"
(integer) 1
192.168.182.112:7001> SADD myset "foo"
(integer) 1
# 已经存在，则不能添加该元素
192.168.182.112:7001> SADD myset "hello"
(integer) 0
# 获取
192.168.182.112:7001> SMEMBERS myset
1) "foo"
2) "hello"
192.168.182.112:6379>

• 有序集合（sorted set)）：Redis 有序集合和集合一样也是 string 类型元素的集合，且不允许重复的成员，不同的是每个元素都会关联一个 double 类型的分数，redis 正是通过分数来为集合中的成员进行从小到大的排序，有序集合的成员是唯一的,但分数（score）却可以重复：

# 登录master节点，slave节点是只读的
redis-cli -c -h 192.168.182.112 -p 7001
192.168.182.112:7001> auth 123456
192.168.182.112:7001> ZADD key1 1 redis
(integer) 1
192.168.182.112:7001> ZADD key1 2 mongodb
(integer) 1
192.168.182.112:7001> ZADD key1 3 mysql
(integer) 1
# 已经存在，不能添加
192.168.182.112:7001> ZADD key1  3 mysql
(integer) 0
# 已经存在，不能添加
192.168.182.112:7001> ZADD key1  4 mysql
(integer) 0
# 获取数据
192.168.182.112:7001> ZRANGE key1  0 10 WITHSCORES
1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "mysql"
6) "4"