Day16-非关系型数据库服务-redis

1、非关系型数据库服务Redis
- [1.1 Redis服务概述介绍](#1.1 Redis服务概述介绍)
- - [1.1.1 缓存服务介绍](#1.1.1 缓存服务介绍)
  - [1.1.2 缓存服务产品介绍](#1.1.2 缓存服务产品介绍)
  - [1.1.3 缓存服务应用场景](#1.1.3 缓存服务应用场景)
- [1.2 Redis服务安装部署](#1.2 Redis服务安装部署)
- - [1.2.1 缓存服务安装部署](#1.2.1 缓存服务安装部署)
- [1.3 Redis服务基础管理操作](#1.3 Redis服务基础管理操作)
- - [1.3.1 缓存服务配置文件介绍](#1.3.1 缓存服务配置文件介绍)
  - [1.3.2 缓存服务安全配置应用](#1.3.2 缓存服务安全配置应用)
  - [1.3.3 缓存服务查看修改配置](#1.3.3 缓存服务查看修改配置)
  - [1.3.4 缓存服务实现数据存储](#1.3.4 缓存服务实现数据存储)
- [1.4 Redis服务数据类型介绍](#1.4 Redis服务数据类型介绍)
- - [1.4.1 常用数据类型介绍说明](#1.4.1 常用数据类型介绍说明)
  - [1.4.2 数据类型通用操作说明](#1.4.2 数据类型通用操作说明)
  - [1.4.3 数据类型应用常见说明](#1.4.3 数据类型应用常见说明)
- [1.5 Redis服务事务操作应用](#1.5 Redis服务事务操作应用)
- - [1.5.1 缓存服务事务功能应用实践](#1.5.1 缓存服务事务功能应用实践)
- [1.6 Redis服务主从复制功能](#1.6 Redis服务主从复制功能)
- - [1.6.1 缓存服务主从复制原理](#1.6.1 缓存服务主从复制原理)
  - [1.6.2 缓存服务主从数据保证](#1.6.2 缓存服务主从数据保证)
  - [1.6.3 缓存服务主从复制实践](#1.6.3 缓存服务主从复制实践)
- [1.7 Redis服务哨兵架构功能实现](#1.7 Redis服务哨兵架构功能实现)
- - [1.7.1 缓存服务哨兵架构组成介绍](#1.7.1 缓存服务哨兵架构组成介绍)
- [1.8 Redis服务集群架构功能实现](#1.8 Redis服务集群架构功能实现)
- - [1.8.1 缓存服务集群架构介绍说明](#1.8.1 缓存服务集群架构介绍说明)
  - [1.8.2 缓存服务集群架构构建过程](#1.8.2 缓存服务集群架构构建过程)
  - [1.8.3 缓存服务集群架构节点添加](#1.8.3 缓存服务集群架构节点添加)
  - [1.8.4 缓存服务集群架构节点删除](#1.8.4 缓存服务集群架构节点删除)

Day-16-数据库NoSQL服务讲解

01 非关系型数据库服务 --redis

02 文档型数据库服务 --mongodb

1、非关系型数据库服务Redis

1.1 Redis服务概述介绍

1.1.1 缓存服务介绍

Redis是数百万开发人员使用的开源内存数据存储服务，经常被用于数据库、缓存、数据流引擎、以及消息中间件；

简单理解：Redis 是完全开源的，遵守BSD协议，是一个高性能的key-value数据库；

Redis服务属于NoSQL数据库产品系列，早期出现在网站架构中，主要是配合关系型数据库（RDBMS）完成某些工作任务的：

对于关系型数据库主要负责核心业务数据的存储和查询；
对于非关系性数据库主要作为配合数据库存储和查询的缓存业务；

对于非关系性数据库也是存在很多种类的：Redis（缓存型）、MogoDB（文档型）、ES（日志型）...

1.1.2 缓存服务产品介绍

缓存服务产品-Redis

Redis具有丰富的数据类型可以进行应用，其中包括：key-value、list、set、zset、hash等数据结构类型；
Redis具有持久化存储能力，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用；
Redis具有多种内存分配和回收的解决方案；
Redis具有原有关系型数据库的事务处理能力（弱事务）；
Reids具有消息队列相关功能，支持消息订阅能力，但是不支持消息回溯和消息堆积；
Redis具有原生态的高可用架构构建技术；
Redis具有数据的备份能力，即master-slave模式的数据备份；
Redis具有原生态的分布式架构和分片集群；

缓存服务产品-Memcache

Memcache具有高性能读写能；
Memcache具有客户端式的分布式集群，以及一致性hash功能；
Memcache具有多核结构，多线程读写能力；

Memcache能力与Redis能力对比：

比对项	Memcache	Redis
持久化存储	不具有持久化存储能力	具有持久化存储能力
缓存穿透问题	节点故障可能出现缓存穿透	具有原生态高可用和主从复制能力
分布式能力	分布式需要客户端实现	具有原生态分布式集群
数据迁移能力	跨机房数据同步困难	具有跨机房数据迁移能力
架构扩容能力	架构扩容复杂度高	具有架构扩容解决方案
性能读写能力	支持多线程读写能力，读写能力快	支持单线程读写能力，读写能力较低
数据类型支持	单一数据类型 key-value-结构	支持多种数据类型
虚拟内存定义	不支持自定义虚拟内存	具有自定义虚拟内存能力

总结：Memcahe和Redis读写性能对比

memcache：比较适合多用户访问场景，每个用户少量的读写操作；

Redis：比较适合少用户访问场景，每个用户大量的读写操作；

缓存服务产品-Tair

Tair具有高性能读写能力
Tair具有多种存储引擎应用，支持三种引擎(ddb、rdb、ldb)
Tair具有高可用架构构建能力
Tair具有分布式架构和分片集群(支持了几平所有淘宝业务的缓存
Tair在单机情况下，读写性能较其他两种产品较慢

1.1.3 缓存服务应用场景

多种缓存服务产品的应用场景：

缓存服务	应用场景
Memcached	多核的缓存服务，更加适合于多用户并发访问次数较少的应用场景
Redis	单核的缓存服务，单节点情况次下，更加适合于少量用户，多次访问的应用场景

说明：Redis在500并发量的处理能力是比较强的，一般采用单机多实例架构，并且配合构建集群应用；

1.2 Redis服务安装部署

1.2.1 缓存服务安装部署

第一步：上传解压软件程序

bash 复制代码

cd /usr/local/
wget https://download.redis.io/releases/redis-6.2.10.tar.gz
ll redis-6.2.10.tar.gz
tar xf redis-6.2.10.tar.gz
ln -s redis-6.2.10 redis
ll -d redis

第二步：安装软件程序

bash 复制代码

yum install -y gcc automake autoconf libtool make
cd redis
make

vim /etc/profile
export PATH=/usr/local/redis/src:$PATH
source /etc/profile

redis-server &
netstat -lntup|grep redis

第三步：测试登录

bash 复制代码

[root@db01 redis 09:00]# redis-cli 
127.0.0.1:6379> set a 1
OK
127.0.0.1:6379> get a
"1"
127.0.0.1:6379>
-- 测试是否正常登录缓存服务，进行简单缓存服务key-values数据类型设置

1.3 Redis服务基础管理操作

1.3.1 缓存服务配置文件介绍

编写基础配置文件信息：

bash 复制代码

[root@master redis]# mkdir -p /data/6379
[root@master redis]# cat >/data/6379/redis.conf<<EOF
daemonize yes
--表示定义服务程序在后台以守护进程方式运行
port 6379
--表示定义服务的默认端口
logfile /data/6379/redis.log
--表示服务运行日志存放路径
dir /data/6379
--表示定义数据目录路径，用于持久化应用时存储数据
dbfilename dump.rdb
--表示持久化存储的数据文件名称
EOF

cat >/data/6379/redis.conf<<EOF
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename dump.rdb
EOF

缓存服务应用配置文件：

bash 复制代码

[root@db01 redis 09:15]# redis-cli shutdown
5678:M 15 Oct 2024 09:19:26.307 # User requested shutdown...
5678:M 15 Oct 2024 09:19:26.307 * Saving the final RDB snapshot before exiting.
5678:M 15 Oct 2024 09:19:26.312 * DB saved on disk
5678:M 15 Oct 2024 09:19:26.312 # Redis is now ready to exit, bye bye...
[1]+  完成                  redis-server
-- 关闭原有启动的Redis服务程序

[root@db01 redis 09:15]# redis-server /data/6379/redis.conf
-- 加载指定配置文件启动Redis
[root@db01 redis 09:20]# netstat -lntup|grep redis
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      5730/redis-server * 
tcp6       0      0 :::6379                 :::*                    LISTEN      5730/redis-server * 

[root@db01 redis 09:22]# redis-cli 
127.0.0.1:6379> set name xiaoQ
OK
127.0.0.1:6379> get name
"xiaoQ"
127.0.0.1:6379>

1.3.2 缓存服务安全配置应用

Redis默认开启了安全保护模式，只允许本地环回地址登录并访问缓存服务数据库，无法实现远程连接缓存服务数据库；

需要禁用protected-mode模式，才能实现redis服务的远程连接

bash 复制代码

[root@db01 redis 09:25]# redis-cli -h 10.0.0.51 -p 6379
10.0.0.51:6379> set a 1
Error: Connection reset by peer
10.0.0.51:6379> get a
(error) DENIED Redis is running in protected mode because protected mode is enabled, no bind address was specified, no authentication password is requested to clients. In this mode connections are only accepted from the loopback interface. If you want to connect from external computers to Redis you may adopt one of the following solutions: 1) Just disable protected mode sending the command 'CONFIG SET protected-mode no' from the loopback interface by connecting to Redis from the same host the server is running, however MAKE SURE Redis is not publicly accessible from internet if you do so. Use CONFIG REWRITE to make this change permanent. 
-- 可以执行命令关闭protected-mode，执行的命令为CONFIG SET protected-mode no

2) Alternatively you can just disable the protected mode by editing the Redis configuration file, and setting the protected mode option to 'no', and then restarting the server.
-- 可以编写配置文件关闭保护模式，并设置protected mode option to 'no'

3) If you started the server manually just for testing, restart it with the '--protected-mode no' option. 
'--protected-mode no' option.
-- 可以在启动服务时，添加protected-mode no参数，实现关闭protected-mode

4) Setup a bind address or an authentication password. NOTE: You only need to do one of the above things in order for the server to start accepting connections from the outside.
10.0.0.51:6379> 
-- 可以设置地址绑定或认证密码方式，在不关闭保护模式情况下，实现外网远程连接redis服务
-- 进行key-values设置失败，显示redis已经运行了protected-mode，并且处于启用状态

10.0.0.51:6379> get name
Error: Connection reset by peer
-- 查看key-values设置失败，由于redis已经运行了protected-mode，并且处于启用状态

# Redis处于protected-mode手动关闭状态
# 关闭Redis保护模式（）
[root@db01 redis 10:17]# vim /data/6379/redis.conf
bind 10.0.0.51 127.0.0.1
-- 设置监听本地远程连接地址和本地环回地址，实现地址bind绑定

requirepass 123456
-- 设置远程连接认证密码信息

[root@db01 redis 10:21]# redis-cli shutdown
[root@db01 redis 10:21]# redis-server /data/6379/redis.conf
-- 进行监听地址和密码信息设置后，需要重启Redis服务程序

# 在开启Redis保护模式下，正常使用Redis服务
[root@db01 redis 10:21]# redis-cli
127.0.0.1:6379> set a 123
(error) NOAUTH Authentication required.
-- 此时本地登录缓存服务器也需要密码验证才可以

[root@db01 redis 10:22]# redis-cli -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
127.0.0.1:6379> set a 123
OK
127.0.0.1:6379> quit
[root@db01 redis 10:22]# redis-cli -h 10.0.0.51 -p 6379 -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
10.0.0.51:6379> set b 123
OK
10.0.0.51:6379> get b
"123"
10.0.0.51:6379> 
[root@db01 redis 10:27]# redis-cli 
127.0.0.1:6379> auth 123456
OK
-- 此时本地登录缓存服务器输入密码后，既可以进行缓存服务管理操作

[root@db01 redis 10:42]# redis-cli -h 10.0.0.51 -p 6379
10.0.0.51:6379> set c 123
(error) NOAUTH Authentication required.
10.0.0.51:6379> auth 123456
OK
10.0.0.51:6379> set c 123
OK
10.0.0.51:6379> get c
"123"

1.3.3 缓存服务查看修改配置

对于Redis缓存服务可以进行在线的查看配置和修改配置信息，无需对缓存服务进行重启操作：

bash 复制代码

config get key/*
config set key 值

# 在线查看缓存服务所有配置信息
10.0.0.51:6379> CONFIG GET *
  1) "rdbchecksum"
  2) "yes"
  3) "daemonize"
  4) "yes"
  5) "io-threads-do-reads"
  6) "no"
  7) "lua-replicate-commands"
  8) "yes"
  9) "always-show-logo"
 10) "no"
 11) "protected-mode"
 12) "yes"
...
288) "0"
289) "slaveof"
290) ""
291) "notify-keyspace-events"
292) ""
293) "bind"
294) "10.0.0.51 127.0.0.1"
295) "oom-score-adj-values"
296) "0 200 800"
-- 默认Redis服务总共有148个配置（6.2.10版本）

10.0.0.51:6379> CONFIG GET requirepass
1) "requirepass"
2) "123456"
10.0.0.51:6379> CONFIG GET require*
1) "requirepass"
2) "123456"
-- 单独指定某个配置信息进行查询，针对缓存服务登录密码信息查询

# 在线修改密码信息，避免重启服务
10.0.0.51:6379> CONFIG SET requirepass 123
OK
10.0.0.51:6379> CONFIG GET require*
1) "requirepass"
2) "123"
[root@db01 redis 10:51]# redis-cli -h 10.0.0.51 -p 6379
10.0.0.51:6379> auth 123456
(error) WRONGPASS invalid username-password pair or user is disabled.
10.0.0.51:6379> auth 123
OK
10.0.0.51:6379> set d 1234
OK
10.0.0.51:6379> get d
"1234"
10.0.0.51:6379> 
-- 在线修改缓存服务配置信息后，最好还要在配置文件中实现永久生效

1.3.4 缓存服务实现数据存储

Redis缓存服务可以实现将内存中的数据信息，持久化保存到磁盘中，实现缓存数据信息的永久保存，便于缓存数据信息的快速调取生成

Redis实现持久化存储：（具有两种持久化方式）

方式一：RDB

RDB持久化存储缓存数据：

Reids利用RDB持久化，可以在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）

优点：存储速度快，适合于用作备份，缓存主从复制也是基于RDB持久化功能实现的；

缺点：由于全部缓存都做持久化，可能出现持久化不及时情况，并且持久化快照会覆盖上一次的，会存在数据丢失情况；

RDB持久化存储手工实现方式：

bash 复制代码

[root@db01 redis 11:08]# redis-cli -h 10.0.0.51 -p 6379 -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
10.0.0.51:6379> get d
(nil)
10.0.0.51:6379> set d 123456
OK
10.0.0.51:6379> save
OK
-- 实现手动保存缓存数据信息，进行数据持久化存储（立即同步更新到磁盘）

10.0.0.51:6379> set a 123
OK
10.0.0.51:6379> BGSAVE
Background saving started
-- 实现手动保存缓存数据信息，进行数据持久化存储（等待键值对没有被修改时再更新到磁盘）

[root@db01 6379 11:10]# ll /data/6379/
总用量 16
-rw-r--r-- 1 root root  111 2024-10-15 11:09 dump.rdb
-rw-r--r-- 1 root root  132 2024-10-15 10:21 redis.conf
-rw-r--r-- 1 root root 4545 2024-10-15 11:09 redis.log

RDB持久化存储核心配置参数：（自动持久化）

bash 复制代码

[root@db01 redis 11:15]# vim /data/6379/redis.conf
dir /data/6379
-- 表示定义数据目录路径，用于持久化应用时存储数据
dbfilename dump.rdb
-- 表示持久化存储的数据文件名称
save 900 1
-- 表示900秒（15分钟）内有1个更改
save 300 10
-- 表示300秒（5分钟）内有10个更改
save 60 10000
-- 表示60s内有10000个更改
-- 根据时间和操作改动频次进行保存

[root@db01 redis 11:16]# redis-cli -h 10.0.0.51 -p 6379 -a 123456 shutdown
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
[root@db01 redis 11:16]# redis-server /data/6379/redis.conf 
[root@db01 redis 11:16]# redis-cli -h 10.0.0.51 -p 6379 -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
10.0.0.51:6379> CONFIG GET save
1) "save"
2) "900 1 300 10 60 10000"
10.0.0.51:6379>

方法二：

AOF持久化存储缓存数据：

Reids利用AOF持久化，会记录服务器执行的所有写操作命令，并在服务器启动时，通过重新执行这些命令来还原数据集；

AOF文件中的命令全部以redis协议的格式来保存，新命令会被追加到文件的末尾；

优点：可以最大程度保证数据不丢；

缺点：日志记录量级比较大；

AOF持久化存储核心配置参数：

bash 复制代码

[root@db01 redis 11:15]# vim /data/6379/redis.conf
dir /data/6379
-- 表示定义数据目录路径，用于持久化应用时存储数据
dbfilename dump.rdb
-- 表示持久化存储的数据文件名称
appendonly yes
-- 是否打开aof日志功能
appendfsync always
-- 表示每个命令，都立即同步到AOF
appendfsync everysec
-- 表示每秒写1次
appendfsync no
-- 写入工作交给操作系统，由操作系统判断缓冲区大小，统一写入到AOF;

root@db01 redis 11:29]# redis-cli -h 10.0.0.51 -p 6379 -a 123456 shutdown
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
[root@db01 redis 11:29]# redis-server /data/6379/redis.conf 
[root@db01 redis 11:29]# redis-cli -h 10.0.0.51 -p 6379 -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
10.0.0.51:6379> CONFIG GET appendonly
1) "appendonly"
2) "yes"
10.0.0.51:6379> CONFIG GET appendfsync
1) "appendfsync"
2) "always"
10.0.0.51:6379>

企业面试题目：Redis持久化方式有哪些？有什么区别？

RDB：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于RDB持久化功能；

AOF：以追加的方式记录redis操作日志的文件，可以最大程度的保证redis数据安全，类似于mysql的binlog；

1.4 Redis服务数据类型介绍

对于Redis缓存服务的数据类型知识，也是一个非常重要的内容，经常会在面试过程中被问到；

1.4.1 常用数据类型介绍说明

在Redis缓存服务中，常用的数据类型有：（数据类型主要是用于区分不同的数据存储方式）

序号	数据类型	解释说明
01	String	字符数据类型
02	Hash	字典数据类型
03	List	列表数据类型
04	Set	集合数据类型
05	Sorted Set	有序集合类型
	...

1.4.2 数据类型通用操作说明

在Redis缓存服务中，默认进行数据信息存储和读取时，都是采用Key-values方式进行的，其中values可以对应不同的数据类型：

在进行key-values操作时常用命令为：

bash 复制代码

redis 基础操作
set key values -- 设置添加键值对信息
get key        -- 获取键值对的值信息
del key        -- 删除键值对信息

expire key 秒  -- 设置键的过期时间
ttl key        -- 查看过期时间剩余多少
persist key    -- 终止键的过期时间

exists key     -- 判断键的信息是否存在
rename old_key_name new_key_name  -- 修改key名称信息


# 查看已经存在的所有key名称信息：
10.0.0.51:6379> keys *
1) "b"
2) "a"
3) "c"
-- 表示显示redis缓存服务中的所有key信息；（当keys数量较多时，此命令不建议使用）

10.0.0.51:6379> keys a*
1) "a"
10.0.0.51:6379> keys a
1) "a"
-- 表示显示redis缓存服务中的指定key信息，尽量精细化查找所需的key信息;

# 返回键所存储数据的类型
10.0.0.51:6379> type a
string
-- 表示显示redis缓存服务中的指定key信息所存储的数据类型;

# 以秒/毫秒为单位设定生存时间，以及返回生存时间（EXPIRE/PEXPIRE TTL/PTTL）
10.0.0.51:6379> EXPIRE a 60
(integer) 1
10.0.0.51:6379> ttl a
(integer) 55
10.0.0.51:6379> ttl a
(integer) 49
-- 设定键值对的生存时间为60秒，并且可以可以查看剩余时间；
10.0.0.51:6379> persist a
(integer) 1
-- 表示取消键值对过期时间的设定
10.0.0.51:6379> ttl a
(integer) -1
10.0.0.51:6379> get a
"1"

# 删除指定键值对信息
10.0.0.51:6379> get a
"123"
10.0.0.51:6379> del a
(integer) 1
10.0.0.51:6379> get a
(nil)
-- 已经对指定的键值对信息进行了删除操作

# 判断键值对信息是否存在
10.0.0.51:6379> get b
"456"
10.0.0.51:6379> exists b
(integer) 1
10.0.0.51:6379> get a
(nil)
10.0.0.51:6379> exists a
(integer) 0
-- 判断指定的键值对信息是否存在，如果存在返回1，如果不存在返回0

# 变更键值对信息的key名称
10.0.0.51:6379> rename a xiaoQ
OK
10.0.0.51:6379> get xiaoQ
"123"
10.0.0.51:6379> get a
(nil)

1.4.3 数据类型应用常见说明

01 数据类型应用场景-string

主要应用场景：

session（会话共享），常规计数（微博数、粉丝数、订阅数、礼物数）

Redis缓存功能实现方式：

bash 复制代码

# 进行Key-values信息的创建
10.0.0.51:6379> set name xiaoQ
-- 设置键值对用户信息
mset id 101 name xiaoQ age 20 gender m  -- z注册个人信息
-- 设置多个键值对对应的属性信息
等价于
10.0.0.51:6379> set id 101
10.0.0.51:6379> set name xiaoQ
10.0.0.51:6379> set age 20
10.0.0.51:6379> set name gender m

# 实现缓存计数器功能(可以实时关注数据信息变化)
10.0.0.51:6379> incr num_101   -- 将指定数值信息进行累加
(integer) 1
10.0.0.51:6379> incr num_101
(integer) 2
10.0.0.51:6379> incr num_101
(integer) 3
10.0.0.51:6379> get num_101
"3"
-- 实现计数器递增功能(模拟每点一次关注，都执行一次以上命令)

10.0.0.51:6379> decr num_101  -- 将指定数值信息进行递减
(integer) 2
10.0.0.51:6379> get num_101
"2"
10.0.0.51:6379> decr num_101
(integer) 1
10.0.0.51:6379> get num_101
"1"
-- 实现计数器递减功能

10.0.0.51:6379> incrby num_101 10000  -- 直接刷高数值信息
(integer) 10001
10.0.0.51:6379> get num_101
"10001"
-- 进行暗箱操作增加更多的数量

10.0.0.51:6379> decrby num_101 5000  -- 直接刷低数值信息
(integer) 5001
10.0.0.51:6379> get num_101
"5001"
-- 进行暗箱操作减去更多的数量

02 数据类型应用场景-Hash

主要应用场景：

存储部分变更的数据，如用户信息等；是最接近mysgl表结构的一种数据类型，因此可以作为数据库业务数据的缓存；

实现将数据库中数据调取缓存到Redis中

Redis缓存功能实现方式：

bash 复制代码

# 进行缓存数据存储操作
> hmset stu01 id 101 name xiaoQ age 20 gender m
> hmset stu02 id 102 name xiaoA age 21 gender f

# 进行缓存数据读取操作
> hmget stu01 id name age gender
> hmget stu02 id name age gender

# 实现将MySQL中热点数据行数据存储到缓存服务中
[root@master ~]# systemctl start mysqld3308
[root@master ~]# mysql-S /data/3308/mysql.sock
mysql> use world;
mysql> show tables;
+-----------------+
| Tables_in_world |
+-----------------+
| city            |
| country         |
| countrylanguage |
+-----------------+
3 rows in set (0.00 sec)
mysql> select concat("hmset city_",id," id ",id," name ",name) from world.city limit 10 into outfile '/tmp/hmset.txt'; 
-- 从数据库中调取数据，并追加到一个文件中

[root@db01 6379 14:03]# cat /tmp/hmset.txt 
hmset city_1 id 1 name Kabul
hmset city_2 id 2 name Qandahar
hmset city_3 id 3 name Herat
hmset city_4 id 4 name Mazar-e-Sharif
hmset city_5 id 5 name Amsterdam
hmset city_6 id 6 name Rotterdam
hmset city_7 id 7 name Haag
hmset city_8 id 8 name Utrecht
hmset city_9 id 9 name Eindhoven
hmset city_10 id 10 name Tilburg

[root@db01 6379 14:04]# cat /tmp/hmset.txt |redis-cli -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
-- 表示将数据库中的提取的数据缓存到Redis中

10.0.0.51:6379> keys city*
 1) "city_9"
 2) "city_2"
 3) "city_4"
 4) "city_8"
 5) "city_6"
 6) "city_10"
 7) "city_3"
 8) "city_7"
 9) "city_1"
10) "city_5"

10.0.0.51:6379> hgetall city_1
1) "id"
2) "1"
3) "name"
4) "Kabul"
-- 调取数据库中一行的所有信息

10.0.0.51:6379> hmget city_1 name
1) "Kabul"
-- 调取一行中的某列信息

10.0.0.51:6379> type city_1
hash

03 数据类型应用场景-List

主要应用场景：

可以用于构建消息队列系统，比如新浪微博，在Redis中缓存了最新微博ID使用了常驻缓存，这是一直更新的；

但是做了限制，不能超过5000个ID，因此获取ID的函数会一直询问redis，只有在start/count参数超过了这个范围的时候；

才会需要去访问数据库，系统不会像传统方式那样刷新缓存，redis实例中的信息永远是一致的；

SQL数据库(或是硬盘上的其他类型数据库)只是在用户需要获取很远的数据时才会被触发；

微博主页或第一个评论页是不会麻烦到硬盘上的数据库服务的；

可以快速加载留言或评论信息

Redis缓存功能实现方式：

bash 复制代码

# 创建生成数据列表信息
10.0.0.51:6379> LPUSH wechat "today is nice day ~"
(integer) 1
10.0.0.51:6379> LPUSH wechat "today is bad day ~"
(integer) 2
10.0.0.51:6379> LPUSH wechat "today is good day ~"
(integer) 3
10.0.0.51:6379> LPUSH wechat "today is rainy day ~"
(integer) 4
10.0.0.51:6379> LPUSH wechat "today is friday ~"
(integer) 5
-- 生成每天的微信朋友圈记录信息
-- 调取数据的下标信息[5,4,3,2,1]-01234 缓存中越新产生的数据，越容易被先调取
-- 多个不同的值信息指定给一个键，就可以构造成列表

# 查看调取数据列表信息
10.0.0.51:6379> LRANGE wechat 0 -1  -- 调取列表信息
1) "today is friday ~"
2) "today is rainy day ~"
3) "today is good day ~"
4) "today is bad day ~"
5) "today is nice day ~"
-- 所有朋友圈缓存数据信息都调取(顺序插入数据，倒叙查看数据)
10.0.0.51:6379> LRANGE wechat 0 0
1) "today is friday ~"
-- 查看第一条朋友圈数据信息(最新的第一个缓存数据)

10.0.0.51:6379> type wechat
list

04 数据类型应用场景-Set

主要应用场景：

在微博应用之中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合中；

Redis还为集合提供了求交集、并集、差集等操作，可以非常方便的实现和共同关注，共同喜欢，二度好友等功能；

对上面的所有集合操作，还可以使用不同的命令选择将结果返回给客户端，还是存集到一个新的集合中；

Redis缓存功能实现方式：

bash 复制代码

# 设置缓存集合信息:
10.0.0.51:6379> sadd xiaoQ xiaoA xiaoB oldgirl oldbaby tom
(integer) 5
10.0.0.51:6379> sadd oldboy oldgirl oldbaby oldli Lucy tom
(integer) 5

# 查看缓存集合信息:
10.0.0.51:6379> sunion xiaoQ oldboy
1) "oldli"
2) "oldbaby"
3) "Lucy"
4) "oldgirl"
5) "tom"
6) "xiaoB"
7) "xiaoA"
-- 获取两个集合的并集信息

10.0.0.51:6379> sinter xiaoQ oldboy
1) "oldbaby"
2) "oldgirl"
3) "tom"
-- 获取两个集合的交集信息

10.0.0.51:6379> sdiff xiaoQ oldboy
1) "xiaoA"
2) "xiaoB"
10.0.0.51:6379> sdiff oldboy xiaoQ
1) "Lucy"
2) "oldli"
-- 获取两个集合的差集信息

05 数据类型应用场景-SortedSet

主要应用场景：

有序集合数据类型可以应用于排行榜，进行取TOP N的操作需求；

这个需求与上面需求的不同之处在于，前面操作以事件为权重，这个是以某个条件为权重，比如按项的次数排序；

这个时候就需要sorted set出马了，将要排序的值设置为sorted set的score，将具体的数据设置成相应的value；

每次只需要执行一条ZADD命令即可；

Redis缓存功能实现方式：

bash 复制代码

# 进行排序集合创建
10.0.0.51:6379> zadd topN 0 smlt 0 fskl 0 fshkl 0 lzlsfs 0 wdhbx 0 wxg
(integer) 6
10.0.0.51:6379> ZINCRBY topN 100000 smlt
"100000"
10.0.0.51:6379> ZINCRBY topN 10000 fskl
"10000"
10.0.0.51:6379> ZINCRBY topN 1000000 fshkl
"1000000"
10.0.0.51:6379> ZINCRBY topN 100 lzlsfs
"100"
10.0.0.51:6379> ZINCRBY topN 10 wdhbx
"10"
10.0.0.51:6379> ZINCRBY topN 100000000 wxg
"100000000"
-- 模拟歌曲排行榜创建

# 进行排序集合查看
10.0.0.51:6379> ZREVRANGE topN 0 2
1) "wxg"
2) "fshkl"
3) "smlt"
10.0.0.51:6379> type topN
zset

1.5 Redis服务事务操作应用

Redis的事务是基于队列机制实现的弱事务（只是支持A原子特性），而对于MySQL的事务是基于事务日志和锁机制实现的；

Redis是乐观锁机制；

1.5.1 缓存服务事务功能应用实践

进行缓存服务事务功能开启：

bash 复制代码

# 事务创建格式
127.0.0.1:6379> multi    -- 开始事务
127.0.0.1:6379> command1
127.0.0.1:6379> command2
127.0.0.1:6379> command3
127.0.0.1:6379> command4
-- 四条语句作为一个组，并没有真正执行，而是被放入同一个队列中
127.0.0.1:6379> exec
-- 当执行exec时，表示队列中所有操作，要么全成功要么全失败
127.0.0.1:6379> discard
-- 如果上面操作语句执行完，直接执行了discard语句，会直接丢弃队列中所有的命令，而不是做回滚操作:

1.6 Redis服务主从复制功能

1.6.1 缓存服务主从复制原理

Redis缓存的服务主从复制功能又称为主副本集（Master-Replicaset），具体实现原理如下：

副本库通过slaveof 192.168.30.101 6379命令，连接到主库缓存服务，并发送SYNC给主库；
主库收到SYNC数据后，会立即触发BGSAVE，在后台保存RDB信息，并发送给副本库；
副本库接收后会应用RDB快照信息；
主库会陆续将中间产生的新操作数据，保存并发送给副本库，至此主复制集就正常工作了；
后面应用过程中，主库只要发生新的操作，都会以命令传输的形式自动发送给副本库；
所有复制相关的信息，从info信息中都可以查到，即使重启任何节点，它的主从关系依然都在；
如果发生主从关系断开时，从库数据没有任何损坏，在下一次重连之后，从库发送PSYNC给主库；
主库只会将从库缺失部分的数据同步给从库应用，达到快速恢复主从的目的；

1.6.2 缓存服务主从数据保证

在进行缓存服务主从复制时，可以应用以下参数配置信息，实现主从数据一致性；

bash 复制代码

min-slaves-to-write 1
min-slaves-max-lag 3

当缓存服务构建主从环境后，是否还需要开启缓存服务的持久化存储功能？

bash 复制代码

# 假设如果不需要持久化了
主缓存服务一旦出现宕机，内存中数据都会出现丢失，并且主库恢复上线后，会将空的内存状态同步给从库；所以，如果不开启持久化功能，一旦主库宕机，就不要让主库再次恢复主从同步关系；

1.6.3 缓存服务主从复制实践

进行缓存服务环境准备：（准备两个或两个以上Redis实例）

主机地址	端口信息	角色身份
10.0.0.51	6380	缓存服务主库(多实例)
10.0.0.51	6381	缓存服务从库(多实例)
10.0.0.51	6382	缓存服务从库(多实例)

进行主从复制实例配置：

bash 复制代码

# 编写生成主从缓存服务配置文件
mkdir -p /data/638{0..2}
cat >>/data/6380/redis.conf <<EOF
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
requirepass 123
masterauth 123
EOF
-- 缓存服务主库配置文件编写

cat >>/data/6381/redis.conf<<EOF
port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
requirepass 123
masterauth 123
EOF

cat >>/data/6382/redis.conf<<EOF
port 6382
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
requirepass 123
masterauth 123
EOF
-- 缓存服务从库配置文件编写

运行启动多实例缓存服务：

bash 复制代码

[root@db01 redis 15:35]# redis-server /data/6380/redis.conf 
[root@db01 redis 15:37]# redis-server /data/6381/redis.conf 
[root@db01 redis 15:37]# redis-server /data/6382/redis.conf 
[root@db01 redis 15:37]# netstat -lntup|grep redis
tcp        0      0 127.0.0.1:6379          0.0.0.0:*               LISTEN      6048/redis-server 1 
tcp        0      0 10.0.0.51:6379          0.0.0.0:*               LISTEN      6048/redis-server 1 
tcp        0      0 0.0.0.0:6380            0.0.0.0:*               LISTEN      6653/redis-server * 
tcp        0      0 0.0.0.0:6381            0.0.0.0:*               LISTEN      6659/redis-server * 
tcp        0      0 0.0.0.0:6382            0.0.0.0:*               LISTEN      6665/redis-server * 
tcp6       0      0 :::6380                 :::*                    LISTEN      6653/redis-server * 
tcp6       0      0 :::6381                 :::*                    LISTEN      6659/redis-server * 
tcp6       0      0 :::6382                 :::*                    LISTEN      6665/redis-server * 
-- 显示的端口信息中:6380为主节点缓存服务，6381/6382位从节点缓存服务;

在从库服务上开启主从同步：

bash 复制代码

# 从库服务开启主从同步
redis-cli -p 6381 -a 123 slaveof 127.0.0.1 6380
redis-cli -p 6382 -a 123 slaveof 127.0.0.1 6380

# 进行主从同步状态查看
redis-cli -p 6380 -a 123 info replication
-- 在主库上检查主从同步的情况

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=154,lag=1
slave1:ip=127.0.0.1,port=6382,state=online,offset=140,lag=1
master_failover_state:no-failover
master_replid:78b919247161870208e793e5c214dbf76ed52f06
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:154
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:154

redis-cli -p 6381 -a 123 info replication
-- 在从库上检查主从同步的情况
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
master_link_status:up
master_last_io_seconds_ago:8
master_sync_in_progress:0
slave_read_repl_offset:210
slave_repl_offset:210
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:78b919247161870208e793e5c214dbf76ed52f06
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:210
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:210

# 测试主从状态
[root@db01 redis 15:44]# redis-cli -p 6380 -a 123
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
127.0.0.1:6380> set a 123
OK
127.0.0.1:6380> keys *
1) "a"
127.0.0.1:6380> get a
"123"
127.0.0.1:6380> quit
[root@db01 redis 15:47]# redis-cli -p 6381 -a 123
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
127.0.0.1:6381> keys *
1) "a"
127.0.0.1:6381> get a
"123"
127.0.0.1:6381> 


# 解除主从同步关系状态
redis-cli -p 6382 -a 123 slaveof no one

1.7 Redis服务哨兵架构功能实现

1.7.1 缓存服务哨兵架构组成介绍

对于Redis主从复制功能，仅仅只是实现了数据的同步保存功能，但是并没有实现架构环境的高可用功能；

所以，对于Redis缓存服务，也需要设计一个合理的架构环境，保证主库业务的状态监控，和出现异常的切换操作；

可以利用sentinel（哨兵）功能组件，对集群架构进行管理，实现主库监控，故障切换，以及新节点加入集群等操作；

redis-sentinel功能组件作用说明：

可以实现架构监控功能；
可以实现自动选主切换；（6381 slaveof no one）
采用的是raft分布式一致性协议进行选主，数据接近主，可以和大部分节点联系，少数服从多数；
可以实现重构主从关系；
可以保证应用切换透明；
可以实现自研处理故障节点；

Redis实现高可用（哨兵组件）

第一步：安装部署哨兵服务

bash 复制代码

# 编写哨兵实例服务配置信息：
mkdir /data/26380
cd /data/26380/
vim sentinel.conf
port 26380
dir "/data/26380"
sentinel monitor mymaster 127.0.0.1 6380 1
-- 监控集群架构中主库服务状态（数值1表示发现主库异常的票数，当发现有1票提出主库宕机，就立刻切换)
sentinel down-after-milliseconds mymaster 5000
-- 当主库进行监控心跳检测时，如果5s内没有反馈，就认为主库服务已经宕机
sentinel auth-pass mymaster 123
-- 设置连接主库服务的认证密码信息

# 启动哨兵缓存实例服务程序:
redis-sentinel /data/26380/sentinel.conf &>/tmp/sentinel.log &
-- 可以利用sentinel日志文件信息输出，获取sentinel整个服务工作过程
netstat -lntup

第二步：进行高可用切换验证：

bash 复制代码

# 进行主库服务宕机状态查看
redis-cli -p 6380 -a 123 shutdown
-- 模拟主库故障
redis-cli -p 6381 -a 123 info replication
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6382,state=online,offset=18261,lag=1
-- 已经选举6381称为新的主库，其他从库也直接改为从6381进行数据同步
......

# 进行主库服务恢复状态查看
[root@db01 26380 16:18]# redis-server /data/6380/redis.conf 
[root@db01 26380 16:21]# redis-cli -p 6381 -a 123 info replication
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6382,state=online,offset=30070,lag=1
slave1:ip=127.0.0.1,port=6380,state=online,offset=30070,lag=0
-- 主库恢复后，会作为从库从新主同步数据
......

进行哨兵服务实例日常管理操作：

bash 复制代码

[root@db01 26380 16:21]# redis-cli -p 26380
127.0.0.1:26380>
-- 连接进入哨兵服务实例中
SENTINEL masters
-- 查看获取主库节点的详细状态信息
SENTINEL slaves mymaster
-- 查看指定架构集群从库节点状态信息
SENTINEL get-master-addr-by-name mymaster
-- 查看获取主库节点的地址和端口信息
SENTINEL reset <pattern>
-- 重置所有名字和给定模式pattern相匹配的主服务器
SENTINEL failover <master name>
SENTINEL failover mymaster

SENTINEL get-master-addr-by-name mymaster
--当主服务器失效时，在不询问其他sentinel意见的情况下，强制开始一次自动故障迁移;

说明：除了sentinel哨兵模式进行集群架构构建以外，还可以使用很多其他方式进行缓存服务架构搭建，比如consul+redis；

如何保证业务正常访问，在实现高可用之后？

哨兵模式无法实现高可用业务自动切换功能地址或端口需要变化，需要前端程序手动或自动识别变化的信息

1.8 Redis服务集群架构功能实现

1.8.1 缓存服务集群架构介绍说明

为了满足并发数据写入的高效性，会创建生成多缓存服务主节点，并将需要存储的数据分布存储到不同节点上；

具体实现高性能存储机制如下：

在多分片节点中，将16384个槽位，均匀分布到多个分片节点中；
存储数据时，将key信息做crc16（key）运算，然后和16384进行取模，得出槽位值（0~16384间）；
根据计算得出的槽位值，找到相对应的分片节点的主节点，存储到相应槽位上；
如果客户端当时连接的节点不是将来要存储分片节点，分片集群会将客户端连接切换至真正存储节点进行数据存储；

具体实现高可用存储机制如下：

在搭建集群时，会为每一个分片的主节点，对应一个从节点，实现slaveof的功能，当主节点宕机，实现类似于sentinel的自动切换功能

Redis缓存服务会有多组分片构成（3组）；
Redis cluster使用固定个数的slot存储数据（总共16384slot）；
Redis cluster中每组分片分得1/3 slot个数（0~5500 5501~11000 11001~16383）
基于CRC16(KEY)的加密数值/16384数值进行取模运算，得到数值就是存储数据的槽位位置；

1.8.2 缓存服务集群架构构建过程

集群架构环境规划准备：

6个redis实例，一般会放在3台硬件服务器上；

在企业规划中，一个分片的两个分到不同的物理机，防止硬件主机宕机造成的整个分片数据丢失；

主机地址	端口信息	角色身份
10.0.0.51	7000	缓存服务主库（多实例）
10.0.0.51	7001	缓存服务主库（多实例）
10.0.0.51	7002	缓存服务主库（多实例）
10.0.0.51	7003	缓存服务从库（多实例）
10.0.0.51	7004	缓存服务从库（多实例）
10.0.0.51	7005	缓存服务从库（多实例）

第一步：创建多个实例信息

集群架构环境插件安装：

bash 复制代码

# epel源安装ruby支持，并使用国内源下载插件
[root@master ~l# yum install ruby rubygems -y
[root@master ~l# gem sources -l
[root@master ~]# gem sources -a http://mirrors.aliyun.com/rubygems/
[root@master ~]# gem sources --remove http://rubygems.org/
[root@master ~]# gem enurces -l
[root@master ~]# gem install redis -v 3.3.3
-- 在redis 5.0.6.0之后，默认在redis软件中已经自带了集群构建的插件；

集群架构环境节点配置：

bash 复制代码

mkdir -p /data/700{0..5}

cat >/data/7000/redis.conf <<EOF
port 7000
daemonize yes
pidfile /data/7000/redis.pid
loglevel notice
logfile "/data/7000/redis.log"
dbfilename dump.rdb
dir /data/7000
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例01节点配置信息（主库）

cat >/data/7001/redis.conf <<EOF
port 7001
daemonize yes
pidfile /data/7001/redis.pid
loglevel notice
logfile "/data/7001/redis.log"
dbfilename dump.rdb
dir /data/7001
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例02节点配置信息（主库）

cat >/data/7002/redis.conf <<EOF
port 7002
daemonize yes
pidfile /data/7002/redis.pid
loglevel notice
logfile "/data/7002/redis.log"
dbfilename dump.rdb
dir /data/7002
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例03节点配置信息（主库）

cat >/data/7003/redis.conf <<EOF
port 7003
daemonize yes
pidfile /data/7003/redis.pid
loglevel notice
logfile "/data/7003/redis.log"
dbfilename dump.rdb
dir /data/7003
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例04节点配置信息（从库）

cat >/data/7004/redis.conf <<EOF
port 7004
daemonize yes
pidfile /data/7004/redis.pid
loglevel notice
logfile "/data/7004/redis.log"
dbfilename dump.rdb
dir /data/7004
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例05节点配置信息（从库）

cat >/data/7005/redis.conf <<EOF
port 7005
daemonize yes
pidfile /data/7005/redis.pid
loglevel notice
logfile "/data/7005/redis.log"
dbfilename dump.rdb
dir /data/7005
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例06节点配置信息（从库）

集群架构节点启动运行：

bash 复制代码

redis-server /data/7000/redis.conf
redis-server /data/7001/redis.conf
redis-server /data/7002/redis.conf
redis-server /data/7003/redis.conf
redis-server /data/7004/redis.conf
redis-server /data/7005/redis.conf

ps -ef|grep redis

第二步：创建集群成员

集群架构节点添加管理

bash 复制代码

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-cli --cluster create 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 --cluster-replicas 1
-- 自动创建集群
[root@db01 redis 17:12]# redis-cli --cluster create 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 --cluster-replicas 1
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 127.0.0.1:7004 to 127.0.0.1:7000
Adding replica 127.0.0.1:7005 to 127.0.0.1:7001
Adding replica 127.0.0.1:7003 to 127.0.0.1:7002
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
Can I set the above configuration? (type 'yes' to accept):yes
-- 确认是否同意进行集群架构环境自动构建

>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
.
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
-- 至此集群构建过程完成

集群架构状态信息查看：

bash 复制代码

# 集群主节点状态情况
[root@master ~]# redis-cli -p 7000 cluster nodes|grep master
50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002@17002 master - 0 1728983920000 3 connected 10923-16383
e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000@17000 myself,master - 0 1728983919000 1 connected 0-5460
e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001@17001 master - 0 1728983920084 2 connected 5461-10922

# 集群从节点状态情况
[root@master ~]# redis-cli -p 7000 cluster nodes|grep slave
50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003@17003 slave e2f1b84c67e6e77d9648ce07f357e16eea226bc0 0 1728983936242 2 connected
6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005@17005 slave e51d4b20b4cc6100a9e726575a7843df059740a4 0 1728983935233 1 connected
65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004@17004 slave 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 0 1728983935536 3 connected

1.8.3 缓存服务集群架构节点添加

在原有缓存服务集群节点中添加新的节点：

集群新的节点信息创建：

bash 复制代码

# 创建新的集群节点实例
mkdir /data/7006
mkdir /data/7007

# 编写新的节点配置文件
cat >/data/7006/redis.conf <<EOF
port 7006
daemonize yes
pidfile /data/7006/redis.pid
loglevel notice
logfile "/data/7006/redis.log"
dbfilename dump.rdb
dir /data/7006
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例07节点配置信息（主库）

cat >/data/7007/redis.conf <<EOF
port 7007
daemonize yes
pidfile /data/7007/redis.pid
loglevel notice
logfile "/data/7007/redis.log"
dbfilename dump.rdb
dir /data/7007
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF
-- 实例08节点配置信息（从库）

启动运行新的节点服务程序：

bash 复制代码

redis-server /data/7006/redis.conf 
redis-server /data/7007/redis.conf 
ps -ef|grep redis

进行新的节点架构集群添加

bash 复制代码

# 添加新的主节点信息
redis-trib.rb add-node 127.0.0.1:7006 127.0.0.1:7000
-- 已经是过时方式了，可以参考了解

redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000

>>> Adding node 127.0.0.1:7006 to cluster 127.0.0.1:7000
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
>>> Send CLUSTER MEET to node 127.0.0.1:7006 to make it join the cluster.
[OK] New node added correctly.

[root@db01 redis 08:01]# redis-cli -p 7000 cluster nodes|grep master
50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002@17002 master - 0 1729037807567 3 connected 10923-16383
046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006@17006 master - 0 1729037809089 0 connected
e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000@17000 myself,master - 0 1729037808000 1 connected 0-5460
e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001@17001 master - 0 1729037807567 2 connected 5461-10922
-- 此时新添加的节点，还没有分配槽位信息

# 转移slot槽位信息（进行槽位重新分配）
[root@db01 redis 08:40]# redis-trib.rb reshard 127.0.0.1:7000
-- 已经是过时方式了，可以参考了解

[root@db01 redis 08:40]# redis-cli --cluster reshard 127.0.0.1:7000
0-1364 
-- 槽位重新进行分配时，需要注意的是不能有数据的存储和读取操作（建议在业务不繁忙情况下进行）
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
M: 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006
   slots: (0 slots) master
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 1364  # 可以按照主节点比例均匀分配
What is the receiving node ID? 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' once you entered all the source nodes IDs.
Source node #1: e51d4b20b4cc6100a9e726575a7843df059740a4
Source node #2: e2f1b84c67e6e77d9648ce07f357e16eea226bc0
Source node #3: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
Source node #4: done
....
    Moving slot 11375 from 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
    Moving slot 11376 from 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
Do you want to proceed with the proposed reshard plan (yes/no)? yes
[root@db01 redis 08:16]# redis-cli -p 7000 cluster nodes|grep master
50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002@17002 master - 0 1729038694000 3 connected 11377-16383
046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006@17006 master - 0 1729038694000 7 connected 0-453 5461-5915 10923-11376
e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000@17000 myself,master - 0 1729038694000 1 connected 454-5460
e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001@17001 master - 0 1729038694877 2 connected 5916-10922

# 添加新的从节点信息
[root@db01 redis 08:40]# redis-trib.rb add-node --slave -master-id 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7007 127.0.0.1:7000
-- 已经是过时方式了，可以参考了解

[root@db01 redis 08:40]# redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7000 --cluster-slave --cluster-master-id 046f2d032d8e471c96c09220a8f05907c5dd4fbc

>>> Adding node 127.0.0.1:7007 to cluster 127.0.0.1:7000
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[454-5460] (5007 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[11377-16383] (5007 slots) master
   1 additional replica(s)
M: 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006
   slots:[0-453],[5461-5915],[10923-11376] (1363 slots) master
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5916-10922] (5007 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
>>> Send CLUSTER MEET to node 127.0.0.1:7007 to make it join the cluster.
Waiting for the cluster to join

>>> Configure node as replica of 127.0.0.1:7006.
[OK] New node added correctly.
[root@db01 redis 08:40]# redis-cli -p 7000 cluster nodes|grep slave
50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003@17003 slave e2f1b84c67e6e77d9648ce07f357e16eea226bc0 0 1729039315555 2 connected
6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005@17005 slave e51d4b20b4cc6100a9e726575a7843df059740a4 0 1729039315659 1 connected
743e1b1b0d88db79b78f8da061b653fc476149f4 127.0.0.1:7007@17007 slave 046f2d032d8e471c96c09220a8f05907c5dd4fbc 0 1729039315555 7 connected
65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004@17004 slave 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 0 1729039314000 3 connected

1.8.4 缓存服务集群架构节点删除

在进行节点删除时，可以先将节点中槽位移走

bash 复制代码

[root@db01 redis 08:40]# redis-trib.rb reshard 127.0.0.1:7000
-- 已经是过时方式了，可以参考了解

# 分片槽位第一次移动
[root@db01 redis 08:40]# redis-cli --cluster reshard 127.0.0.1:7000
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[454-5460] (5007 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[11377-16383] (5007 slots) master
   1 additional replica(s)
M: 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006
   slots:[0-453],[5461-5915],[10923-11376] (1363 slots) master
   1 additional replica(s)
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 743e1b1b0d88db79b78f8da061b653fc476149f4 127.0.0.1:7007
   slots: (0 slots) slave
   replicates 046f2d032d8e471c96c09220a8f05907c5dd4fbc
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5916-10922] (5007 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 454
What is the receiving node ID? e51d4b20b4cc6100a9e726575a7843df059740a4
-- 将部分槽位挪动还给7000主节点
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' once you entered all the source nodes IDs.
Source node #1: 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Source node #2: done
...
    Moving slot 453 from 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Do you want to proceed with the proposed reshard plan (yes/no)? yes
Moving slot 0 from 127.0.0.1:7006 to 127.0.0.1:7000: 
...
[root@db01 redis 08:50]# redis-cli -p 7000 cluster nodes|grep master
50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002@17002 master - 0 1729040122861 3 connected 11377-16383
046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006@17006 master - 0 1729040123874 7 connected 5461-5915 10923-11376
e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000@17000 myself,master - 0 1729040120000 8 connected 0-5460
-- 槽位已经移动回去到7000主节点
e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001@17001 master - 0 1729040123565 2 connected 5916-10922

# 分片槽位第二次移动
[root@db01 26380 08:55]# redis-cli --cluster reshard 127.0.0.1:7000
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[11377-16383] (5007 slots) master
   1 additional replica(s)
M: 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006
   slots:[5461-5915],[10923-11376] (909 slots) master
   1 additional replica(s)
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 743e1b1b0d88db79b78f8da061b653fc476149f4 127.0.0.1:7007
   slots: (0 slots) slave
   replicates 046f2d032d8e471c96c09220a8f05907c5dd4fbc
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5916-10922] (5007 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 455
What is the receiving node ID? e2f1b84c67e6e77d9648ce07f357e16eea226bc0
-- 将部分槽位挪动还给7001主节点
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' once you entered all the source nodes IDs.
Source node #1: 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Source node #2: done
...
  Moving slot 5915 from 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Do you want to proceed with the proposed reshard plan (yes/no)? yes
Moving slot 5461 from 127.0.0.1:7006 to 127.0.0.1:7001: 
...
[root@db01 redis 08:55]# redis-cli -p 7000 cluster nodes|grep master
50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002@17002 master - 0 1729040377000 3 connected 11377-16383
046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006@17006 master - 0 1729040377729 7 connected 10923-11376
e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000@17000 myself,master - 0 1729040377000 8 connected 0-5460
e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001@17001 master - 0 1729040378133 9 connected 5461-10922
-- 槽位已经移动回去到7001主节点

# 分片槽位第三次移动
[root@db01 26380 08:58]# redis-cli --cluster reshard 127.0.0.1:7000
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[11377-16383] (5007 slots) master
   1 additional replica(s)
M: 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006
   slots:[10923-11376] (454 slots) master
   1 additional replica(s)
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 743e1b1b0d88db79b78f8da061b653fc476149f4 127.0.0.1:7007
   slots: (0 slots) slave
   replicates 046f2d032d8e471c96c09220a8f05907c5dd4fbc
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 453
What is the receiving node ID? 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
-- 将部分槽位挪动还给7002主节点
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' once you entered all the source nodes IDs.
Source node #1: 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Source node #2: done   
...
Moving slot 11375 from 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Do you want to proceed with the proposed reshard plan (yes/no)? yes
Moving slot 10923 from 127.0.0.1:7006 to 127.0.0.1:7002:
...
[root@db01 redis 08:59]# redis-cli -p 7000 cluster nodes|grep master
50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002@17002 master - 0 1729040551000 10 connected 10923-11375 11377-16383
046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006@17006 master - 0 1729040551000 7 connected 11376
e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000@17000 myself,master - 0 1729040551000 8 connected 0-5460
e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001@17001 master - 0 1729040552065 9 connected 5461-10922
-- 槽位已经移动回去到7000主节点，少移动了一个

# 补剩下的一个槽位
[root@db01 26380 09:01]# redis-cli --cluster reshard 127.0.0.1:7000
>>> Performing Cluster Check (using node 127.0.0.1:7000)
M: e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
   slots:[10923-11375],[11377-16383] (5460 slots) master
   1 additional replica(s)
M: 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006
   slots:[11376] (1 slots) master
   1 additional replica(s)
S: 50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003
   slots: (0 slots) slave
   replicates e2f1b84c67e6e77d9648ce07f357e16eea226bc0
S: 6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005
   slots: (0 slots) slave
   replicates e51d4b20b4cc6100a9e726575a7843df059740a4
S: 743e1b1b0d88db79b78f8da061b653fc476149f4 127.0.0.1:7007
   slots: (0 slots) slave
   replicates 046f2d032d8e471c96c09220a8f05907c5dd4fbc
S: 65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004
   slots: (0 slots) slave
   replicates 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
M: e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 1   # 1个槽位
What is the receiving node ID? 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' once you entered all the source nodes IDs.
Source node #1: 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Source node #2: done

Ready to move 1 slots.
  Source nodes:
    M: 046f2d032d8e471c96c09220a8f05907c5dd4fbc 127.0.0.1:7006
       slots:[11376] (1 slots) master
       1 additional replica(s)
  Destination node:
    M: 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002
       slots:[10923-11375],[11377-16383] (5460 slots) master
       1 additional replica(s)
  Resharding plan:
    Moving slot 11376 from 046f2d032d8e471c96c09220a8f05907c5dd4fbc
Do you want to proceed with the proposed reshard plan (yes/no)? yes
Moving slot 11376 from 127.0.0.1:7006 to 127.0.0.1:7002: 
Node 127.0.0.1:7006 replied with error:
ERR Please use SETSLOT only with masters.
-- 此报错没有关系

[root@db01 redis 09:04]# redis-cli -p 7000 cluster nodes|grep master
50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 127.0.0.1:7002@17002 master - 0 1729040705000 10 connected 10923-16383
e51d4b20b4cc6100a9e726575a7843df059740a4 127.0.0.1:7000@17000 myself,master - 0 1729040705000 8 connected 0-5460
e2f1b84c67e6e77d9648ce07f357e16eea226bc0 127.0.0.1:7001@17001 master - 0 1729040706582 9 connected 5461-10922
-- 槽位挪动还给7002主节点



0-453 5461-5915 10923-11376
453   454    453
454   455    454

# 删除主节点信息
redis-cli --cluster del-node 127.0.0.1:7006 046f2d032d8e471c96c09220a8f05907c5dd4fbc
[root@db01 26380 09:03]# redis-cli --cluster del-node 127.0.0.1:7006 046f2d032d8e471c96c09220a8f05907c5dd4fbc
>>> Removing node 046f2d032d8e471c96c09220a8f05907c5dd4fbc from cluster 127.0.0.1:7006
>>> Sending CLUSTER FORGET messages to the cluster...
>>> Sending CLUSTER RESET SOFT to the deleted node.

# 删除从节点信息
redis-cli --cluster del-node 127.0.0.1:7007 743e1b1b0d88db79b78f8da061b653fc476149f4
[root@db01 26380 09:16]# redis-cli --cluster del-node 127.0.0.1:7007 743e1b1b0d88db79b78f8da061b653fc476149f4
>>> Removing node 743e1b1b0d88db79b78f8da061b653fc476149f4 from cluster 127.0.0.1:7007
>>> Sending CLUSTER FORGET messages to the cluster...
>>> Sending CLUSTER RESET SOFT to the deleted node.
[root@db01 redis 09:20]# redis-cli -p 7000 cluster nodes|grep slave
50dccf4c76d7eedd7a556e84ad6e18dc51cac0bf 127.0.0.1:7003@17003 slave e2f1b84c67e6e77d9648ce07f357e16eea226bc0 0 1729041691374 9 connected
6aee1776a1c219617a94d914097a2014239299b7 127.0.0.1:7005@17005 slave e51d4b20b4cc6100a9e726575a7843df059740a4 0 1729041691000 8 connected
65840e72797ec98359716da3275fffb6968448f0 127.0.0.1:7004@17004 slave 50dfc3a44b44a08dd22c8d5ce69be4f5def3cb4b 0 1729041690562 10 connected

建议设置redis最大内存容量为：

bash 复制代码

config set maxmemory 10240000