:::warning 容器集群化是未来的发展方向。需要对容器网络做规划，容器网络有五类：bridge，host，none，container和自定义网络。

容器监控以及可视化容器部署配置。

:::

1 Docker 复杂安装详说

👑1.1 安装 MySQL 主从复制

👑1.1.1 主从复制原理

mysql主从复制原理是什么-mysql教程-PHP中文网

• 为什么需要主从复制？

1、在业务复杂的系统中，有这么一个情景，有一句SQL语句需要缩表，导致暂时不能使用读的服务，那么就很影响运行中的业务，使用主从复制，让主库负责写，从库负责读，这样，即使主库出现了缩表的情景，通过读从库也可以保证业务的正常运行。

2、做数据的热备，主库宕机后能够及时替换主库，保证业务可用性。

3、架构的扩展。业务量越来越大，I/O 访问频率过高，单机无法满足，此时做多库的存储，降低磁盘I/O访问的频率，提高单个机器的I/O性能。

4、MySQL 主从经典的部署方式：一主一从；MySQL 主从中从服务器也不需要太多，MySQL 会出现主从的不同步情况，从服务器同步跟不上也会导致数据同步出错。

• 什么是 MySQL 的主从复制？

主从复制中分为【主服务器（master）】和【从服务器（slave）】，主服务器负责写，而从服务器负责读，MySQL 的主从复制的过程是一个【异步的过程】。
这样读写分离的过程能够是整体的服务性能提高，即时写操作时间比较长，也不影响读操作的进行。

MySQL 主从复制是指数据可以从一个MySQL数据库服务器主节点复制到一个或者多个从节点。
MySQL 默认采用异步复制方式，这样从节点不用一直访问主服务器来更新自己的数据，数据的更新可以在远程连接上进行，从节点可以复制主数据库中所有数据库或者特定的数据库，或者特定的表。

• MySQL 主从复制的流程

:::warning

1.主节点必须启用二进制日志，记录任何修改了数据库数据的事件

2.从节点开启了一个线程(I/O Thread)把自己扮演成MySQL的客户端，通过MySQL协议，请求主节点的二进制日志文件中的事件

3.主节点启动一个线程(Dump Thread)，检查自己二进制日志中的事件，跟对方请求的位置对比，如果不带请求位置参数，则主节点就会从第一个日志文件中的第一个事件一个一个发送给从节点

4.从节点接收到主节点发送过来的数据把它放置在中继日志(Relay Log)文件中。并记录该次请求到主节点的具体哪一个二进制日志文件内部的哪一个位置(主节点中的二进制文件会有很多个)

5.从节点启动另一个线程(SQL Thread)，把Relay Log中的事件读取出来，并在本地再执行一次

:::

:::warning

复制中线程的作用：

从节点

• I/O Thread：从Master节点请求二进制日志事件，并保存于中继日志中

• SQL Thread：从Reglay Log中读取日志事件并在本地完成重放

主节点

• Dump Thread：为每个 Slave 的I/O Thread启动一个Dump，用于向从节点发送二进制事件

:::

• MySQL 主从复制的原理

MySQL 的主从复制中主要有三个线程：master(binlog dump thread)、slave(I/O thread / SQL thread)，Master一条线程和Slave中的两条线程。

master(binlog dump thread)主要负责Master库中有数据更新的时候，会按照binlog格式，将更新的事件类型写入到主库的binlog文件中。

并且，master(binlog dump thread)线程通知Slave主库中存在数据更新，这就是为什么主库的binlog日志一定要开启的原因。

I/O thread线程在Slave中创建，该线程用于请求Master，Master会返回binlog的名称以及当前数据更新的位置，binlog文件位置的副本。

然后，将binlog保存在[Relay Log(中继日志)]中，中继日志也是记录数据更新的信息。

SQL thread也是在Slave创建的，当 Slave 检测到中继日志有更新，就会将更新的内容同步到Slave数据库中，这样就保证了主从的数据的同步。

:::warning 主库db的更新事件（update，insert，delete）被写到 binlog

主库创建一个 binlog dump thread，把 binlog 的内容发送到从库

从库启动并发起连接，连接到主库

从库启动之后，创建一个I/O线程，读取主库传过来的 binlog 内容并写入到 relay log

从库启动之后，创建一个 SQL 线程，从 relay log 里面读取内容，从 Exec_Master_Log_Pos 位置开始执行读取到的更新事件，将更新内容写入到 Slave 的 db中

:::

以上就是主从复制的过程，当然，主从复制的过程有不同的策略方式进行数据的同步，主要包含以下几种：

1. 「同步策略」：Master会等待所有的Slave都回应后才会提交，这个主从的同步的性能会严重的影响。
2. 「半同步策略」：Master至少会等待一个Slave回应后提交。
3. 「异步策略」：Master不用等待Slave回应就可以提交。
4. 「延迟策略」：Slave要落后于Master指定的时间。

对于不同的业务需求，有不同的策略方案，但是一般都会采用最终一致性，不会要求强一致性，毕竟强一致性会严重影响性能。

1.1.2 主从搭建步骤

新建主服务器容器实例 Port:3307

$ docker run -it -p 3307:3306 -d \
  --name mysql-master --privileged=true \
  -v /app/mysql-master/log:/var/log/mysql \
  -v /app/mysql-master/data:/var/lib/mysql \
  -v /app/mysql-master/conf:/etc/mysql \
  -e MYSQL_ROOT_PASSWORD=Admin@h3c \
  mysql:5.7.36
$ docker ps -l
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                                                                                     NAMES
43c1f8bc896c   mysql:5.7.36   "docker-entrypoint.s…"   7 seconds ago   Up 6 seconds   33060/tcp, 0.0.0.0:3307->3306/tcp, :::3307->3306/tcp   mysql-master

• 进入 /app/mysql-master/conf 目录下新建 my.cnf

$ cat > /app/mysql-master/conf/my.cnf <<EOF
[client]
## 设置客户端的默认字符集
default-character-set=utf8mb4
[mysql]
## 设置MySQL服务器的默认字符集
default-character-set=utf8mb4
[mysqld]
## 设置MySQL后台服务程序的默认字符集
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
## 设置server_id,同一局域网中需要唯一
server_id=101
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-bin
## 开启二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或者指定类型的错误，避免slave端复制终端
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
EOF

• 修改完配置后重启 master 实例

$ docker restart mysql-master

• 进入 mysql-master 容器

$ docker exec -it mysql-master /bin/bash
root@43c1f8bc896c:/# mysql -uroot -pAdmin@h3c
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

• master 容器实例内创建数据同步用户

mysql> CREATE USER 'slave'@'%' IDENTIFIED BY 'Admin@h3c';
mysql> GRANT REPLICATION SLAVE,REPLICATION CLIENT ON *.* TO 'slave'@'%';

新建从服务器容器实例 Port:3308

$ docker run -it -p 3308:3306 -d \
  --name mysql-slave --privileged=true\
  -v /app/mysql-slave/log:/var/log/mysql \
  -v /app/mysql-slave/data:/var/lib/mysql \
  -v /app/mysql-slave/conf:/etc/mysql \
  -e MYSQL_ROOT_PASSWORD=Admin@h3c \
  mysql:5.7.36
$ docker ps -l
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS        PORTS                                                                                                    NAMES
67ff2cc65475   mysql:5.7.36   "docker-entrypoint.s…"   2 seconds ago   Up 1 second   33060/tcp, 0.0.0.0:3308->3306/tcp, :::3308->3306/tcp   mysql-slave

• 进入 /app/mysql-slave/conf 目录下新建 my.cnf

$ cat > /app/mysql-slave/conf/my.cnf <<EOF
[client]
## 设置客户端的默认字符集
default-character-set=utf8mb4
[mysql]
## 设置MySQL服务器的默认字符集
default-character-set=utf8mb4
[mysqld]
## 设置MySQL后台服务程序的默认字符集
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
## 设置server_id,同一局域网中需要唯一
server_id=102
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能，以备Slave作为其他数据库实例的Master时使用
log-bin=mall-slave1-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或者指定类型的错误，避免slave端复制终端
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
## slave设置为只读（具有super权限的用户除外）
read_only=1
EOF

• 修改完配置后重启 slave 实例

$ docker restart mysql-slave

• 在 mysql-mater 主数据库中查看主从同步状态

$ docker exec -it mysql-master /bin/bash
root@43c1f8bc896c:/# mysql -uroot -pAdmin@h3c
mysql> show master status;
+-----------------------+----------+--------------+------------------+-------------------+
| File                  | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+-----------------------+----------+--------------+------------------+-------------------+
| mall-mysql-bin.000001 |      617 |              | mysql            |                   |
+-----------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)

• 进入 mysql-slave 从数据库容器

$ docker exec -it mysql-slave /bin/bash
root@67ff2cc65475:/# mysql -uroot -pAdmin@h3c

• 在 mysql-slave 从数据库中配置主从复制

### 主从复制命令参数说明
# master_host：主数据库的IP地址
# master_port：主数据库的运行断开
# master_user：在主数据库创建的用于同步数据的用户账号
# master_password：在主数据库创建的用于同步数据的用户密码
# master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数
# master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数
# master_connect_retry：连接失败重试的时间间隔，单位为秒
# 公式：change master to master_host='宿主机ip', master_user='slave', master_password='Admin@h3c', master_port=3307, master_log_file='mall-mysql-bin.000001', master_log_pos=617, master_connect_retry=30;
$ docker exec -it mysql-slave /bin/bash
root@67ff2cc65475:/# mysql -uroot -pAdmin@h3c
mysql> change master to master_host='139.198.105.99', master_user='slave', master_password='Admin@h3c', master_port=3307, master_log_file='mall-mysql-bin.000001', master_log_pos=617, master_connect_retry=30;

• 在 mysql-slave 从数据库中查看主从同步状态

$ docker exec -it mysql-slave /bin/bash
root@67ff2cc65475:/# mysql -uroot -pAdmin@h3c
mysql> show slave status\G;
*************************** 1. row ***************************
               Slave_IO_State:
                  Master_Host: 139.198.105.99
                  Master_User: slave
                  Master_Port: 3307
                Connect_Retry: 30
              Master_Log_File: mall-mysql-bin.000001
          Read_Master_Log_Pos: 617
               Relay_Log_File: mall-mysql-relay-bin.000001
                Relay_Log_Pos: 4
        Relay_Master_Log_File: mall-mysql-bin.000001
             Slave_IO_Running: No
            Slave_SQL_Running: No

• 在 mysql-slave 从数据库中开启主从同步

$ docker exec -it mysql-slave /bin/bash
root@67ff2cc65475:/# mysql -uroot -pAdmin@h3c
mysql> start slave;
Query OK, 0 rows affected (0.00 sec)

• 查看从数据库状态发现已经同步

mysql> show slave status\G;
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 139.198.105.99
                  Master_User: slave
                  Master_Port: 3307
                Connect_Retry: 30
              Master_Log_File: mall-mysql-bin.000001
          Read_Master_Log_Pos: 617
               Relay_Log_File: mall-mysql-relay-bin.000002
                Relay_Log_Pos: 325
        Relay_Master_Log_File: mall-mysql-bin.000001
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes

• 主从复制测试
  • 主机新建库 —> 使用库 —> 新建表 —> 插入数据，OK
  • 从机使用库 —> 查看记录，OK

# 在主数据库进行操作
$ docker exec -it mysql-master /bin/bash
root@43c1f8bc896c:/# mysql -uroot -pAdmin@h3c
mysql> create database if not exists db01;
mysql> use db01;
mysql> create table t1 (id INT,name VARCHAR(20));
mysql> insert into t1(id , name) values(1 , 'zhangsan');
mysql> select * from t1;
+------+----------+
| id   | name     |
+------+----------+
|    1 | zhangsan | 
+------+----------+
1 row in set (0.00 sec)
# 在从数据库进行操作
$ docker exec -it mysql-slave /bin/bash
root@67ff2cc65475:/# mysql -uroot -pAdmin@h3c
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| db01               |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.01 sec)
mysql> use db01;
mysql> show tables;
+----------------+
| Tables_in_db01 |
+----------------+
| t1             |
+----------------+
1 row in set (0.00 sec)
mysql> select * from t1;
+------+----------+
| id   | name     |
+------+----------+
|    1 | zhangsan |
+------+----------+
1 row in set (0.00 sec)

👑1.2 安装 Redis 集群（大厂面试题-分布式存储案例）

Cluster集群模式-Docker版本 ---> 哈希槽分区进行亿级数据存储

Redis 采用的算法就是为了区分不同的请求分配给哪台服务器处理

面试题：1~2亿条数据需要缓存，请问如何设计这个存储案例

回答：单机单台100%不可能实现，肯定是**<font style="color:#E8323C;">分布式存储</font>**，用Redis如何落地。

上述问题阿里 P6~P7 工程案例和场景设计类必考题目，一般业界有三种解决方案。

👑1.2.0 Redis 存储数据的算法

（1）哈希取余分区（Redis面试题Hash算法-嗨客网 (haicoder.net)）

• Hash 基本原理就是把任意长度的输入，通过 Hash 算法变成固定长度的输出。Hash 算法有很多种，常见的算法有 MD5，SHA，CRC等。

2 亿条记录就是2亿条 K/V，我们单机不行必须要分布式多机，假设有3台机器构成一个集群，用户每次读写操作都是根据公式；hash(key) % N 个机器台数，计算出哈希值，用来决定数据映射到哪一个节点上。

假设有一个Key，set k1=v1。读写操作需要根据 hash(key) % N = Number(hash) 值，利用该 Number(hash)值 来决定映射到哪个节点。怎么存储的就怎么取出数据。Redis 的 key 一般是不重复的，利用同一套的 hash 算法，例如：得到的[余数]存储的时候是 0号机器，取出数据的时也是0号机器。

哈希取余分区是最通用，最常用的。一般用于小型业务场景，中大型业务场景建议不要使用。

:::warning

优点：

• 简单粗暴，直接有效，只需要预估好数据规划好节点，例如3台，8台，10台，就能保证一段时间的数据支撑。使用 Hash 算法让固定的一部分请求（并维护这些请求的信息），起到负载均衡+分而治之的作用。

缺点：

• 原来规划好的节点，进行扩容或者缩容就比较麻烦了，不管扩容缩容，每次数据变动导致节点有变动，映射关系需要重新进行计算，在服务器个数固定不变时没有问题，如果需要弹性扩容或者故障停机的情况下，原来的取模公式就会发生变化，Hash(key) % 3会变成Hash(key) % ?，此时地址经过取余运算的结果将发生很大变化，根据公式获取的服务器也会变的不可控。

• 若集群规模台数为3，Hash(key) = 3，则Hash(key) % 3=0，当集群规模扩容之后，台数为7，Hash(key)值不变，Hash(key) % 7 = 1，存储数据的路径即会发生变化。

• 某个Redis机器宕机了，由于台数数量变化，会导致Hash取余全部数据重新洗牌。

缺点总结：节点映射，数据变动，容易出错。

:::

（2）一致性哈希算法分区

• 是什么?一致性 Hash 算法背景：→ 一致性Hash哈希算法在1997年由麻省理工学院中提出的，设计目标是为了解决分布式缓存数据变动和映射问题，某个机器宕机了，分母数量改变了，自然取余数不OK了。
• 能干嘛?→ 提出一致性Hash解决方案。目的是当服务器个数发生变动时，尽量减少影响客户端到服务器的映射关系。
• 3大步骤(Redis面试题一致性Hash-嗨客网 (haicoder.net))

：假设Node C宕机，可以看到此时对象A，B，D不会受到影响，只有C对象被重定位到Node D。一般的，在一致性Hash算法中，如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响。简单说，就是C挂了，受到影响的只是B、C之间的数据，并且这些数据会转移到D进行存储。 2.

：数据量增加了，需要增加一台节点Node X，此时对象 Object A、B、D 不受影响，只有对象 C 需要重定位到新的 Node X 。一般的，在一致性哈希算法中，如果增加一台服务器，则受影响的数据仅仅是新服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间数据，其它数据也不会受到影响。 若 Node X的位置在Node A 与 Node B 之间，那受到影响的也就是 A 到 X之间的数据，重新把 A 到 X 的数据录入到 X 上即可，不会导致 hash 取余全部数据重新洗牌。 所以会影响相邻结点之间的数据缓存，结点越多影响越小。 + 缺点 一致性哈希算法的数据倾斜问题：一致性 Hash 算法在服务节点太少时，容易因为节点分布不均匀而造成数据倾斜（被缓存的对象大部分集中缓存在某一台服务器上）问题，例如系统中只有两台服务器。 此时必然造成大量数据集中到 Node A 上，而只有极少量会定位到 Node B 上。 为了解决这种数据倾斜问题，一致性哈希算法引入了虚拟节点机制，即对每一个服务节点计算多个哈希，每个计算结果位置都放置一个此服务节点，称为虚拟节点。具体做法可以在服务器 ip 或主机名的后面增加编号来实现。例如上面的情况，可以为每台服务器计算三个虚拟节点，于是可以分别计算 “Node A#1”、“Node A#2”、“Node A#3”、“Node B#1”、“Node B#2”、“Node B#3” 的哈希值，于是形成六个虚拟节点： 同时数据定位算法不变，只是多了一步虚拟节点到实际节点的映射，例如定位到 “Node A#1”、“Node A#2”、“Node A#3” 三个虚拟节点的数据均定位到 Node A 上。这样就解决了服务节点少时数据倾斜的问题。在实际应用中，通常将虚拟节点数设置为 32 甚至更大，因此即使很少的服务节点也能做到相对均匀的数据分布。 + 小总结 为了在节点数目发生改变时尽可能少的迁移数据 将所有的存储节点排列在收尾相接的 Hash 环上，每个 key 在计算 Hash 后会顺时针找到临近的存储节点存放。而当有节点加入或 者退出时仅影响该节点在 Hash 环上顺时针相邻的后续节点。 优点：加入和删除节点只影响哈希环中顺时针方向的相邻的节点，对其他节点无影响。 缺点：数据的分布和节点的位置有关，因为这些节点不是均匀的分布在哈希环上的，所以数据在进行存储时达不到均匀分布的效果。

换句话说是分布在0-65535之间，那作者在做 mod 运算的时候，为什么不mod65536，而是选择mod16384？

https://github.com/redis/redis/issue/2576

<主要为了心跳方便，以及数据传输的最大化>

说明1：

• 正确的心跳数据包带有节点的完整配置，可以用幂等方式用新的节点替换旧节点，以便更新旧的配置。

这意味着他们包含原始节点的插槽配置，该节点使用 2K的空间和16K的插槽，但是会使用8K的空间(使用65K的插槽)。

同时，由于其他设计折衷，Redis不太可能扩展到1000个以上的主节点。

因此16k处于正确的范围内，以确保每个主机具有足够的插槽，最多可容纳100个矩阵，但是数据足够少，可以轻松的将插槽配置作为原始位图传播。请注意，在小型群集中，位图将难以压缩，因为当N较小时，位图将设置的 slot/N 占设置位的很大百分比。

说明2：

(1)如果槽位为65536，发送心跳信息的消息头达8K，发送的心跳包过于庞大。

在消息头中最占空间的是myslots[CLUSTER_SLOTS/8]。当槽位为65536时，这块的大小是：65536/8/1024=8KB

因为每秒钟，Redis节点需要发送一定数量的ping消息作为心跳包，如果槽位是65536，则这个ping消息的消息头太大了，浪费带宽。

(2)Redis 的集群主节点数量基本不可能超过1000个。

集群节点越多，心跳包的消息体内携带的数据越多。如果节点过1000个，也会导致为了拥堵。因此Redis作者不建议Redis Cluster节点数量超过1000个。那么，对于节点数在1000以内的Redis Cluster集群，16384个槽位足够了。没有必要扩展到 65536 个。

(3)槽位越小，节点少的情况下，压缩比高，容易传输

Redis 主节点的配置信息中它所负责的哈希槽是通过一张 bitmap 的形式来保存的，在传输过程中会对 bitmap 进行压缩，但是如果 bitmap 的填充率 slots / N 很高的话(N代表节点数)，bitmap 的压缩率就很低。如果节点数很少，而哈希槽数量很多的话，bitmap的压缩率就很低。

:::

（4）**哈希槽计算**

:::warning

Redis 哈希槽计算

Redis 集群中内置了 16384 个哈希槽，Redis 会根据节点数量大致均等的将哈希槽映射到不同的节点。当需要在 Redis 集群中放置一个 key-value 时，Redis 先对 key 使用 CRC16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，也就是映射到某个节点上。如下代码，key之A、B在Node2，key之C落在Node3上。

@Test

public void test3()

{

//import.io.lettuce.core.cluster.SlotHash;
System.out.println(SlotHash.getSlot(key:"A")); //6373
System.out.println(SlotHash.getSlot(key:"B")); //10374
System.out.println(SlotHash.getSlot(key:"C")); //14503
System.out.println(SlotHash.getSlot(key:"hello")); //866

}

:::

:::warning 哈希槽和一致性 Hash 的最大区别就是引入了 Hash 槽，可以理解为在一致性 Hash 的基础上，变成 16384 个虚拟节点，这也是 Hash 算法算出来的倾斜的概率会降低，但是极端情况还是数据倾斜。

:::

三主三从Redis集群扩缩容配置案例架构说明

👑1.2.1 Redis 三主三从实现步骤

### 1.关闭防火墙+启动Docker后台服务
$ systemctl stop firewalld && systemctl disable firewalld
$ systemctl start docker   && systemctl enable docker
### 2.新建6个Redis Docker容器实例
# docker run ---> 创建并运行 docker 容器实例
# --name redis-node-1 ---> 容器名字
# -d ---> 容器实例后台运行
# --net host ---> 使用宿主机的IP和端口，默认(host网络模式不需要端口映射，直接使用宿主机端口)
# --privileged=true ---> 获取宿主机 root 用户权限
# -v /data/redis/share/redis-note-1:/data ---> 容器卷，宿主机绝对路径目录:Docker容器内部绝对路径目录
# redis ---> Redis 镜像，默认版本号为 latest
# --cluster-enabled yes ---> 开启 Redis 集群
# --appendonly yes ---> 开启持久化
# --port 6381 ---> 容器实例 Redis 暴露的端口号
docker run -d --name redis-node-1 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-1:/data redis --cluster-enabled yes --appendonly yes --port 6381
docker run -d --name redis-node-2 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-2:/data redis --cluster-enabled yes --appendonly yes --port 6382
docker run -d --name redis-node-3 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-3:/data redis --cluster-enabled yes --appendonly yes --port 6383
docker run -d --name redis-node-4 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-4:/data redis --cluster-enabled yes --appendonly yes --port 6384
docker run -d --name redis-node-5 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-5:/data redis --cluster-enabled yes --appendonly yes --port 6385
docker run -d --name redis-node-6 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-6:/data redis --cluster-enabled yes --appendonly yes --port 6386
### 3.进入容器 redis-node-1 并为 6台机器构建集群关系
## 进入容器
$ docker exec -it redis-node-1 /bin/bash
## 构建主从关系
# 注意，进入Docker容器后才能执行一下命令，并且注意自己的真实IP地址
# --cluster-replicas 1 表示为每个 Master 创建一个 Slave 节点
root@docker:/data# redis-cli --cluster create 139.198.105.99:6381 139.198.105.99:6382 139.198.105.99:6383 139.198.105.99:6384 139.198.105.99:6385 139.198.105.99:6386 --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 139.198.105.99:6385 to 139.198.105.99:6381
Adding replica 139.198.105.99:6386 to 139.198.105.99:6382
Adding replica 139.198.105.99:6384 to 139.198.105.99:6383
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381
   slots:[0-5460] (5461 slots) master
M: a23364d45a6d2f56d94021815af2c8f3ef6cb499 139.198.105.99:6382
   slots:[5461-10922] (5462 slots) master
M: 15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383
   slots:[10923-16383] (5461 slots) master
S: 150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384
   replicates daa3085081481d5c893f100a4d742a7160a8616c
S: 48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385
   replicates a23364d45a6d2f56d94021815af2c8f3ef6cb499
S: 2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386
   replicates 15a33cc85697b68cc897137c863238f412ceff46
Can I set the above configuration? (type 'yes' to accept): yes
## 一切Ok的话，3主3从搞定
### 4.链接进入 6381 作为切入点，查看集群状态
## 链接进入 6381 作为切入点，查看节点状态
$ docker exec -it redis-node-1 /bin/bash
$ root@docker:/data# redis-cli -p 6381
## cluster info
127.0.0.1:6381> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:319
cluster_stats_messages_pong_sent:329
cluster_stats_messages_sent:648
cluster_stats_messages_ping_received:324
cluster_stats_messages_pong_received:319
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:648
## cluster nodes
127.0.0.1:6381> cluster nodes
2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386@16386 slave 15a33cc85697b68cc897137c863238f412ceff46 0 1642221710000 3 connected
48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385@16385 slave a23364d45a6d2f56d94021815af2c8f3ef6cb499 0 1642221711199 2 connected
daa3085081481d5c893f100a4d742a7160a8616c 10.150.22.47:6381@16381 myself,master - 0 1642221711000 1 connected 0-5460
150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384@16384 slave daa3085081481d5c893f100a4d742a7160a8616c 0 1642221710196 1 connected
a23364d45a6d2f56d94021815af2c8f3ef6cb499 139.198.105.99:6382@16382 master - 0 1642221712202 2 connected 5461-10922
15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383@16383 master - 0 1642221709193 3 connected 10923-16383
### 5.由于是Redis的Master-Slave之间的关系自动分配，所以需要具体问题具体分析
## 该Redis-Cluster的配置为：
# Master1:Port6381 --> Slave1:Port6384
# Master2:Port6382 --> Slave2:Port6385
# Master3:Port6383 --> Slave3:Port6386
## Redis-Cluster 内部两两随机匹配了以后，内部打散了以后，由Redis自行决定Master-Slave的顺序。

1.2.2 Redis 主从容错切换迁移案例

• 数据读写存储

### 1.启动6台容器构成的集群并通过 exec 进入
$ docker exec -it redis-node-1 /bin/bash
root@docker:/data# redis-cli -p 6381
127.0.0.1:6381> keys *
(empty array)
### 2.对 6381 新增两个 key
# 根据key Hash计算后与16384取模算出对应的槽点值，会有数据存储到其他Node节点上。所以会有key存储失败
127.0.0.1:6381> set k1 v1
(error) MOVED 12706 139.198.105.99:6383
127.0.0.1:6381> set k2 v2
OK
127.0.0.1:6381> set k3 v3
OK
127.0.0.1:6381> set k4 v4
(error) MOVED 8455 139.198.105.99:6382
### 防止路由失效加传输 -c 并新增两个 key
[
127.0.0.1:6381> set k1 v1
(error) MOVED 12706 139.198.105.99:6383
# 加入参数 -c，优化路由
root@docker:/data# redis-cli -c -p 6381
127.0.0.1:6381> set k1 v1
-> Redirected to slot [12706] located at 139.198.105.99:6383
OK
]
$ docker exec -it redis-node-1 /bin/bash
root@docker:/data# redis-cli -c -p 6381
# 清除Redis存储的KV
127.0.0.1:6381> FLUSHALL 
OK
127.0.0.1:6381> set k1 v1
-> Redirected to slot [12706] located at 139.198.105.99:6383
OK
# 会重定向到指定的槽位Node
139.198.105.99:6383> set k2 v2
-> Redirected to slot [449] located at 139.198.105.99:6381
OK
139.198.105.99:6381> set k3 v3
OK
139.198.105.99:6381> set k4 v4
-> Redirected to slot [8455] located at 139.198.105.99:6382
OK
### 查看集群信息
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (daa30850...) -> 2 keys | 5461 slots | 1 slaves.
139.198.105.99:6382 (a23364d4...) -> 1 keys | 5462 slots | 1 slaves.
139.198.105.99:6383 (15a33cc8...) -> 1 keys | 5461 slots | 1 slaves.
[OK] 4 keys in 3 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6381)
M: daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386
   slots: (0 slots) slave
   replicates 15a33cc85697b68cc897137c863238f412ceff46
S: 48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385
   slots: (0 slots) slave
   replicates a23364d45a6d2f56d94021815af2c8f3ef6cb499
S: 150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384
   slots: (0 slots) slave
   replicates daa3085081481d5c893f100a4d742a7160a8616c
M: a23364d45a6d2f56d94021815af2c8f3ef6cb499 139.198.105.99:6382
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383
   slots:[10923-16383] (5461 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.

• 容错切换迁移

Redis 集群主从切换（1号宕机4号上位）

### 主6381和从机切换，先停止主机6381
$ docker stop redis-node-1
### 再次查看集群信息
# 使用 redis-node-2 进入 Redis
$ docker exec -it redis-node-2 /bin/bash
root@docker:/data# redis-cli -c -p 6382
127.0.0.1:6382> cluster nodes
# 139.198.105.99:6381@16381 master,fail 主节点连接失败
daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381@16381 master,fail - 1642226063583 1642226056560 1 disconnected
15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383@16383 master - 0 1642226096000 3 connected 10923-16383
48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385@16385 slave a23364d45a6d2f56d94021815af2c8f3ef6cb499 0 1642226096834 2 connected
2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386@16386 slave 15a33cc85697b68cc897137c863238f412ceff46 0 1642226095826 3 connected
a23364d45a6d2f56d94021815af2c8f3ef6cb499 10.150.22.47:6382@16382 myself,master - 0 1642226094000 2 connected 5461-10922
# 139.198.105.99:6384@16384 master 从节点成主节点
150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384@16384 master - 0 1642226095000 7 connected 0-5460
# 6381 宕机了，6384上位成为了新的Master。6381的数据同样存储在6384
# 备注：每次案例下面挂的从机以实际情况为准，具体是几号机器就是几号
127.0.0.1:6382> get k1
-> Redirected to slot [12706] located at 139.198.105.99:6383
"v1"
139.198.105.99:6383> get k2
-> Redirected to slot [449] located at 139.198.105.99:6384
"v2"
139.198.105.99:6384> get k3
"v3"
139.198.105.99:6384> get k4
-> Redirected to slot [8455] located at 139.198.105.99:6382
"v4"
### 先还原之前的3主3从
# 先启 6381 --> docker start redis-node-1
# 再停 6384 --> docker stop redis-node-4
# 再启 6384 --> docker start redis-node-4
# 主从机器分配情况以实际情况为准
$ docker start redis-node-1
# 6381 主节点恢复后，角色会变成 Slave，不会自动切换到 Master
139.198.105.99:6382> cluster nodes
daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381@16381 slave 150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 0 1642226771967 7 connected
15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383@16383 master - 0 1642226771000 3 connected 10923-16383
48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385@16385 slave a23364d45a6d2f56d94021815af2c8f3ef6cb499 0 1642226771018 2 connected
2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386@16386 slave 15a33cc85697b68cc897137c863238f412ceff46 0 1642226771000 3 connected
a23364d45a6d2f56d94021815af2c8f3ef6cb499 10.150.22.47:6382@16382 myself,master - 0 1642226769000 2 connected 5461-10922
150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384@16384 master - 0 1642226770000 7 connected 0-5460
-------
$ docker stop redis-node-4
# 6381 主节点会因为 6384 宕机而将角色切换到 Master
139.198.105.99:6382> cluster nodes
daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381@16381 master - 0 1642227020000 8 connected 0-5460
15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383@16383 master - 0 1642227021206 3 connected 10923-16383
48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385@16385 slave a23364d45a6d2f56d94021815af2c8f3ef6cb499 0 1642227021894 2 connected
2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386@16386 slave 15a33cc85697b68cc897137c863238f412ceff46 0 1642227019000 3 connected
a23364d45a6d2f56d94021815af2c8f3ef6cb499 10.150.22.47:6382@16382 myself,master - 0 1642227018000 2 connected 5461-10922
# 6384 节点宕机
150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384@16384 master,fail - 1642227003710 1642226998715 7 disconnected
-------
$ docker start redis-node-4
# 6384 节点的角色恢复到 Slave
139.198.105.99:6382> cluster nodes
daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381@16381 master - 0 1642227143806 8 connected 0-5460
15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383@16383 master - 0 1642227144821 3 connected 10923-16383
48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385@16385 slave a23364d45a6d2f56d94021815af2c8f3ef6cb499 0 1642227142814 2 connected
2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386@16386 slave 15a33cc85697b68cc897137c863238f412ceff46 0 1642227143000 3 connected
a23364d45a6d2f56d94021815af2c8f3ef6cb499 10.150.22.47:6382@16382 myself,master - 0 1642227142000 2 connected 5461-10922
150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384@16384 slave daa3085081481d5c893f100a4d742a7160a8616c 0 1642227143000 8 connected
### 查看集群状态
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (daa30850...) -> 2 keys | 5461 slots | 1 slaves.
139.198.105.99:6382 (a23364d4...) -> 1 keys | 5462 slots | 1 slaves.
139.198.105.99:6383 (15a33cc8...) -> 1 keys | 5461 slots | 1 slaves.
[OK] 4 keys in 3 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6381)
M: daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386
   slots: (0 slots) slave
   replicates 15a33cc85697b68cc897137c863238f412ceff46
M: a23364d45a6d2f56d94021815af2c8f3ef6cb499 139.198.105.99:6382
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385
   slots: (0 slots) slave
   replicates a23364d45a6d2f56d94021815af2c8f3ef6cb499
S: 150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384
   slots: (0 slots) slave
   replicates daa3085081481d5c893f100a4d742a7160a8616c
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

1.2.3 Redis 主从扩容案例

先添加 Master4 分配槽位号，再添加 Slave4 于 Master4连接

### 1.新建6387、6388两个节点+新建后启动+查看是否8节点
docker run -d -it --name redis-node-7 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-7:/data redis --cluster-enabled yes --appendonly yes --port 6387
docker run -d -it --name redis-node-8 --net host --privileged=true --restart=always -v /myapp/redis/share/redis-node-8:/data redis --cluster-enabled yes --appendonly yes --port 6388
docker ps
### 2.进入6387容器实例内部
$ docker exec -it redis-node-7 /bin/bash
### 3.将新增的6387节点(空槽号)作为Master节点加入原集群
# 将新增的6387作为master节点加入集群
# redis-cli --cluster add-node 自己实际IP地址:6387 自己实际IP地址:6381
# 6387 就是将要作为 master 新增节点
# 6388 就是原来集群节点里面的领路人，相当于6387拜访6381的码头从而找到组织加入集群
$ docker exec -it redis-node-7 /bin/bash
root@docker:/data# redis-cli --cluster add-node 139.198.105.99:6387 139.198.105.99:6381
>>> Adding node 139.198.105.99:6387 to cluster 139.198.105.99:6381
>>> Performing Cluster Check (using node 139.198.105.99:6381)
......
>>> Send CLUSTER MEET to node 139.198.105.99:6387 to make it join the cluster.
[OK] New node added correctly.
### 4.检查集群情况
root@docker:/data# redis-cli --cluster check 139.198.105.99:6387
139.198.105.99:6387 (4cc6ed4c...) -> 0 keys | 0 slots | 0 slaves. "(暂时没有槽位号)"
139.198.105.99:6383 (15a33cc8...) -> 1 keys | 5461 slots | 1 slaves.
139.198.105.99:6381 (daa30850...) -> 2 keys | 5461 slots | 1 slaves.
139.198.105.99:6382 (a23364d4...) -> 1 keys | 5462 slots | 1 slaves.
[OK] 4 keys in 4 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6387)
M: 4cc6ed4c3b00d3c9f625f9f83d34420dc34d8033 139.198.105.99:6387
slots: (0 slots) master
M: 15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383
slots:[10923-16383] (5461 slots) master
1 additional replica(s)
S: 2075147d5c9e90275c1eb7e1b1ad32912129a13e 139.198.105.99:6386
slots: (0 slots) slave
replicates 15a33cc85697b68cc897137c863238f412ceff46
S: 48656f0b83bd65f31a4478fc17be8322efcd2ede 139.198.105.99:6385
slots: (0 slots) slave
replicates a23364d45a6d2f56d94021815af2c8f3ef6cb499
S: 150f6fdc57070f702fb8bb9cfe40a1bd94608a7b 139.198.105.99:6384
slots: (0 slots) slave
replicates daa3085081481d5c893f100a4d742a7160a8616c
M: daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381
slots:[0-5460] (5461 slots) master
1 additional replica(s)
M: a23364d45a6d2f56d94021815af2c8f3ef6cb499 139.198.105.99:6382
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.
### 5.重新分派槽号
# 重新分派槽号
# 命令:redis-cli --cluster reshard IP地址:端口号
# redis-cli --cluster reshard 139.198.105.99:6381
$ docker exec -it redis-node-1 /bin/bash
root@docker:/data# redis-cli --cluster reshard 139.198.105.99:6381
>>> Performing Cluster Check (using node 139.198.105.99:6387)
M: 4cc6ed4c3b00d3c9f625f9f83d34420dc34d8033 139.198.105.99:6387 # [--> 没有槽号]
slots: (0 slots) master
M: 15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383
slots:[10923-16383] (5461 slots) master
1 additional replica(s)
......
replicates daa3085081481d5c893f100a4d742a7160a8616c
M: daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381
slots:[0-5460] (5461 slots) master
1 additional replica(s)
M: a23364d45a6d2f56d94021815af2c8f3ef6cb499 139.198.105.99:6382
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)? 4096 
# [--> 16384/(Master数)->16384/4]
What is the receiving node ID? 4cc6ed4c3b00d3c9f625f9f83d34420dc34d8033 
# [--> 4cc6ed4c3b00d3c9f625f9f83d34420dc34d8033 (redis-node-7 ID号)]
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: all
...
Ready to move 4096 slots.
Source nodes:
 M: 15a33cc85697b68cc897137c863238f412ceff46 139.198.105.99:6383
    slots:[10923-16383] (5461 slots) master
    1 additional replica(s)
 M: daa3085081481d5c893f100a4d742a7160a8616c 139.198.105.99:6381
    slots:[0-5460] (5461 slots) master
    1 additional replica(s)
 M: a23364d45a6d2f56d94021815af2c8f3ef6cb499 139.198.105.99:6382
    slots:[5461-10922] (5462 slots) master
    1 additional replica(s)
Destination node:
 M: 4cc6ed4c3b00
......
Do you want to proceed with the proposed reshard plan (yes/no)? yes
......"(等待数据迁移，迁移速度与机器的性能有关)"
### 6.检查集群情况
# 迁移数据完毕后，之前的节点匀了一部分槽号给新的Master
# redis-cli --cluster check 真实IP地址:6381
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (58e4217a...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6383 (b67e4f11...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6382 (a93838a2...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6387 (fb19d789...) -> 1 keys | 4096 slots | 0 slaves.
[OK] 4 keys in 4 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6381)
M: 58e4217a0588e05a8806411f61fc54915b781e5a 139.198.105.99:6381
slots:[1365-5460] (4096 slots) master
1 additional replica(s)
M: b67e4f11be048b6a0796de83b2350e44419621ac 139.198.105.99:6383
slots:[12288-16383] (4096 slots) master
1 additional replica(s)
M: a93838a2a0df5f771443f2000a650ff49b1a3e7e 139.198.105.99:6382
slots:[6827-10922] (4096 slots) master
1 additional replica(s)
replicates b67e4f11be048b6a0796de83b2350e44419621ac
M: fb19d789d779dd48ff2d78016a112880f10a3caf 139.198.105.99:6387
slots:[0-1364],[5461-6826],[10923-12287] (4096 slots) master [3 Master匀了一部分槽号给新的Master使用]
......
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
### 7.为主节点6387分配从节点6388
# 数据存储在节点上，节点存储在槽上，所以重新分配槽点，原有数据不影响读取
# 命令：redis-cli --cluster add-node Slave-IP:Slave-Port Master-IP:Master-Port --cluster-slave --cluster-master-id 新主机节点ID
# redis-cli --cluster add-node 139.198.105.99:6388 139.198.105.99:6387 --cluster-slave --cluster-master-id fb19d789d779dd48ff2d78016a112880f10a3caf(是6387的ID编号，按照自己实际情况填写)
$ docker exec -it redis-node-7 /bin/bash
root@docker:/data# redis-cli --cluster add-node 139.198.105.99:6388 139.198.105.99:6387 --cluster-slave --cluster-master-id fb19d789d779dd48ff2d78016a112880f10a3caf
>>> Adding node 139.198.105.99:6388 to cluster 139.198.105.99:6387
>>> Performing Cluster Check (using node 139.198.105.99:6387)
M: fb19d789d779dd48ff2d78016a112880f10a3caf 139.198.105.99:6387
slots:[0-1364],[5461-6826],[10923-12287] (4096 slots) master
M: b67e4f11be048b6a0796de83b2350e44419621ac 139.198.105.99:6383
slots:[12288-16383] (4096 slots) master
1 additional replica(s)
S: bf66a51258fd046b3e3e741d3adc8bdef7b34ffc 139.198.105.99:6384
slots: (0 slots) slave
replicates a93838a2a0df5f771443f2000a650ff49b1a3e7e
S: 1dcd70196a57e2862463938aa776c2ef3555b01c 139.198.105.99:6386
slots: (0 slots) slave
replicates 58e4217a0588e05a8806411f61fc54915b781e5a
S: 264e4329f261c70b3001028334a2fe161f30113d 139.198.105.99:6385
slots: (0 slots) slave
replicates b67e4f11be048b6a0796de83b2350e44419621ac
M: 58e4217a0588e05a8806411f61fc54915b781e5a 139.198.105.99:6381
slots:[1365-5460] (4096 slots) master
1 additional replica(s)
M: a93838a2a0df5f771443f2000a650ff49b1a3e7e 139.198.105.99:6382
slots:[6827-10922] (4096 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 139.198.105.99:6388 to make it join the cluster.
Waiting for the cluster to join
>>> Configure node as replica of 139.198.105.99:6387.
[OK] New node added correctly.
### 8.检查集群情况
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (58e4217a...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6383 (b67e4f11...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6382 (a93838a2...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6387 (fb19d789...) -> 1 keys | 4096 slots | 1 slaves.
[OK] 4 keys in 4 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6381)
M: 58e4217a0588e05a8806411f61fc54915b781e5a 139.198.105.99:6381
slots:[1365-5460] (4096 slots) master
1 additional replica(s)
M: b67e4f11be048b6a0796de83b2350e44419621ac 139.198.105.99:6383
slots:[12288-16383] (4096 slots) master
1 additional replica(s)
M: a93838a2a0df5f771443f2000a650ff49b1a3e7e 139.198.105.99:6382
slots:[6827-10922] (4096 slots) master
1 additional replica(s)
S: 264e4329f261c70b3001028334a2fe161f30113d 139.198.105.99:6385
slots: (0 slots) slave
replicates b67e4f11be048b6a0796de83b2350e44419621ac
M: fb19d789d779dd48ff2d78016a112880f10a3caf 139.198.105.99:6387
slots:[0-1364],[5461-6826],[10923-12287] (4096 slots) master
1 additional replica(s)
S: 08fc0002346c3dcbc343982388aa78c1d57c7d68 139.198.105.99:6388
slots: (0 slots) slave
replicates fb19d789d779dd48ff2d78016a112880f10a3caf
S: bf66a51258fd046b3e3e741d3adc8bdef7b34ffc 139.198.105.99:6384
slots: (0 slots) slave
replicates a93838a2a0df5f771443f2000a650ff49b1a3e7e
S: 1dcd70196a57e2862463938aa776c2ef3555b01c 139.198.105.99:6386
slots: (0 slots) slave
replicates 58e4217a0588e05a8806411f61fc54915b781e5a
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
# 测试数据是否存在
root@docker:/data# redis-cli -c -p 6381
127.0.0.1:6381> get k1
-> Redirected to slot [12706] located at 139.198.105.99:6383
"v1"
139.198.105.99:6383> get k2
-> Redirected to slot [449] located at 139.198.105.99:6387
"v2"
139.198.105.99:6387> get k3
-> Redirected to slot [4576] located at 139.198.105.99:6381
"v3"
139.198.105.99:6381> get k4
-> Redirected to slot [8455] located at 139.198.105.99:6382
"v4"

:::warning

槽号分派说明

为什么6387是3个新的区间，以前的还是连续?

重新分配成本太高，所以前3Master各自匀出来一部分，从6381 / 6382 / 6383三个旧的Master节点分别匀出1364个槽位给新的节点6387

:::

1.2.4 Redis 主从缩容案例

:::warning

1. 先清除从节点6388
2. 清出来的槽号重新分配
3. 再删除6387
4. 恢复成3主3从

:::

### 1.目的：6387和6388下线
$ docker exec -it redis-node-1 /bin/bash
--------
### 2.检查集群情况1获得6388节点ID
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (58e4217a...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6383 (b67e4f11...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6382 (a93838a2...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6387 (fb19d789...) -> 1 keys | 4096 slots | 1 slaves.
[OK] 4 keys in 4 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6381)
M: 58e4217a0588e05a8806411f61fc54915b781e5a 139.198.105.99:6381
slots:[1365-5460] (4096 slots) master
1 additional replica(s)
M: b67e4f11be048b6a0796de83b2350e44419621ac 139.198.105.99:6383
slots:[12288-16383] (4096 slots) master
1 additional replica(s)
M: a93838a2a0df5f771443f2000a650ff49b1a3e7e 139.198.105.99:6382
slots:[6827-10922] (4096 slots) master
1 additional replica(s)
M: fb19d789d779dd48ff2d78016a112880f10a3caf 139.198.105.99:6387
slots:[0-1364],[5461-6826],[10923-12287] (4096 slots) master
1 additional replica(s)
S: 08fc0002346c3dcbc343982388aa78c1d57c7d68 139.198.105.99:6388
slots: (0 slots) slave
replicates fb19d789d779dd48ff2d78016a112880f10a3caf
......
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
--------
### 3.将6388删除，从集群中将4号从节点6388删除
# 命令：redis-cli --cluster del-node Slave-IP:Slave-Port 从机6388节点ID
# redis-cli --cluster del-node 139.198.105.99:6388 08fc0002346c3dcbc343982388aa78c1d57c7d68
root@docker:/data# redis-cli --cluster del-node 139.198.105.99:6388 08fc0002346c3dcbc343982388aa78c1d57c7d68
--------
# 检查集群情况1
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (58e4217a...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6383 (b67e4f11...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6382 (a93838a2...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6387 (fb19d789...) -> 1 keys | 4096 slots | 0 slaves.
# 检查一下发现，6388被删除了，只剩下7台机器了
--------
### 4.将6387的槽号清空，重新分配，本例将清出来的槽号都给6381
root@docker:/data# redis-cli --cluster reshard 139.198.105.99:6381
......
How many slots do you want to move (from 1 to 16384)? 4096 "[--> 6381的节点，由它来接手空出来的槽号(共4096个)]"
What is the receiving node ID? 58e4217a0588e05a8806411f61fc54915b781e5a "[--> 6381的节点ID]"
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: fb19d789d779dd48ff2d78016a112880f10a3caf "[--> 6387的节点ID，告知删除该节点]"
Source node #2: done
Do you want to proceed with the proposed reshard plan (yes/no)? yes
......(等待数据迁移，迁移速度与机器的性能有关)
--------
### 5.检查集群情况2
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (58e4217a...) -> 2 keys | 8192 slots | 2 slaves.
139.198.105.99:6383 (b67e4f11...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6382 (a93838a2...) -> 1 keys | 4096 slots | 1 slaves.
[OK] 4 keys in 3 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6381)
M: 58e4217a0588e05a8806411f61fc54915b781e5a 139.198.105.99:6381
slots:[0-6826],[10923-12287] (8192 slots) master
2 additional replica(s)
M: b67e4f11be048b6a0796de83b2350e44419621ac 139.198.105.99:6383
slots:[12288-16383] (4096 slots) master
1 additional replica(s)
M: a93838a2a0df5f771443f2000a650ff49b1a3e7e 139.198.105.99:6382
slots:[6827-10922] (4096 slots) master
1 additional replica(s)
S: 264e4329f261c70b3001028334a2fe161f30113d 139.198.105.99:6385
slots: (0 slots) slave
replicates b67e4f11be048b6a0796de83b2350e44419621ac
S: fb19d789d779dd48ff2d78016a112880f10a3caf 139.198.105.99:6387
slots: (0 slots) slave
replicates 58e4217a0588e05a8806411f61fc54915b781e5a
S: bf66a51258fd046b3e3e741d3adc8bdef7b34ffc 139.198.105.99:6384
slots: (0 slots) slave
replicates a93838a2a0df5f771443f2000a650ff49b1a3e7e
S: 1dcd70196a57e2862463938aa776c2ef3555b01c 139.198.105.99:6386
slots: (0 slots) slave
replicates 58e4217a0588e05a8806411f61fc54915b781e5a
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
## 4096个槽位都指给了6381，它变成了8192个槽位，相当于全部都给6381了，不让要输入3次，一锅端。
--------
### 6.将6387删除
# 命令：redis-cli --cluster del-node Master-IP:Master-Port 主Master-6387节点ID
# redis-cli --cluster del-node 139.198.105.99:6387 fb19d789d779dd48ff2d78016a112880f10a3caf
root@docker:/data# redis-cli --cluster del-node 139.198.105.99:6387 fb19d789d779dd48ff2d78016a112880f10a3caf
------------------------------------------------------------------------------------------------------------
### 7.检查集群情况3
root@docker:/data# redis-cli --cluster check 139.198.105.99:6381
139.198.105.99:6381 (58e4217a...) -> 2 keys | 8192 slots | 1 slaves.
139.198.105.99:6383 (b67e4f11...) -> 1 keys | 4096 slots | 1 slaves.
139.198.105.99:6382 (a93838a2...) -> 1 keys | 4096 slots | 1 slaves.
[OK] 4 keys in 3 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 139.198.105.99:6381)
M: 58e4217a0588e05a8806411f61fc54915b781e5a 139.198.105.99:6381
slots:[0-6826],[10923-12287] (8192 slots) master
1 additional replica(s)
M: b67e4f11be048b6a0796de83b2350e44419621ac 139.198.105.99:6383
slots:[12288-16383] (4096 slots) master
1 additional replica(s)
M: a93838a2a0df5f771443f2000a650ff49b1a3e7e 139.198.105.99:6382
slots:[6827-10922] (4096 slots) master
1 additional replica(s)
S: 264e4329f261c70b3001028334a2fe161f30113d 139.198.105.99:6385
slots: (0 slots) slave
replicates b67e4f11be048b6a0796de83b2350e44419621ac
S: bf66a51258fd046b3e3e741d3adc8bdef7b34ffc 139.198.105.99:6384
slots: (0 slots) slave
replicates a93838a2a0df5f771443f2000a650ff49b1a3e7e
S: 1dcd70196a57e2862463938aa776c2ef3555b01c 139.198.105.99:6386
slots: (0 slots) slave
replicates 58e4217a0588e05a8806411f61fc54915b781e5a
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.