阿里云部署MySQL、Redis、RocketMQ、Nacos集群

文章目录

🔊博主介绍
🥤本文内容
MySQL集群配置
Redis集群配置
- redis.conf配置文件
- 配置过程
RocketMQ
配置Nacos
- 配置JDK
- Nginx高可用负载
📢文章总结
📥博主目标

🔊博主介绍

🌟我是廖志伟，一名Java开发工程师、Java领域优质创作者、CSDN博客专家、51CTO专家博主、阿里云专家博主、清华大学出版社签约作者、产品软文专业写手、技术文章评审老师、问卷调查设计师、个人社区创始人、开源项目贡献者。🌎跑过十五公里、🚀徒步爬过衡山、🔥有过三个月减肥20斤的经历、是个喜欢躺平的狠人。

📕拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、SpringBoot、Spring MVC、SpringCould、Mybatis、Dubbo、Zookeeper)，消息中间件底层架构原理(RabbitMQ、RockerMQ、Kafka)、Redis缓存、MySQL关系型数据库、 ElasticSearch全文搜索、MongoDB非关系型数据库、Apache ShardingSphere分库分表读写分离、设计模式、领域驱动DDD、Kubernetes容器编排等。

📙有过从0到1的项目高并发项目开发与管理经验，对JVM调优、MySQL调优、Redis调优、ElasticSearch调优、消息中间件调优、系统架构调优都有着比较全面的实战经验。

📘有过云端搭建服务器环境，自动化部署CI/CD，弹性伸缩扩容服务器（最高200台），了解过秒级部署（阿里云的ACK和华为云的云容器引擎CCE）流程，能独立开发和部署整个后端服务，有过分库分表的实战经验。

🎥经过多年在CSDN创作上千篇文章的经验积累，我已经拥有了不错的写作技巧，与清华大学出版社签下了四本书籍的合约，并将陆续在明年出版。这些书籍包括了基础篇、进阶篇、架构篇的📌《Java项目实战—深入理解大型互联网企业通用技术》📌，以及📚《解密程序员的思维密码–沟通、演讲、思考的实践》📚。具体出版计划会根据实际情况进行调整，希望各位读者朋友能够多多支持！

🌾阅读前，快速浏览目录和章节概览可帮助了解文章结构、内容和作者的重点。了解自己希望从中获得什么样的知识或经验是非常重要的。建议在阅读时做笔记、思考问题、自我提问，以加深理解和吸收知识。

💡在这个美好的时刻，本人不再啰嗦废话，现在毫不拖延地进入文章所要讨论的主题。接下来，我将为大家呈现正文内容。

🥤本文内容

CSDN

MySQL集群配置

云服务器选购

CPU选择

在这里插入图片描述可以看到除了IO线程的其他线程，都只占一个线程，io线程有四个，其中write和read需要相同的数量。

如果是master thread1条，IO thread(write1条，read1条，insert buffer thread1条，log io thread1条)，purge thread1条，page cleaner thread1条，给它凑个整，就是8核cpu。

如果是master thread1条，IO thread(write5条，read5条，insert buffer thread1条，log io thread1条)，purge thread1条，page cleaner thread1条，给它凑个整就是16核cpu。

这里为了部署集群，我选择八核，最大化利用cpu资源的同时也能节约成本。

内存选择

在这里插入图片描述
MySQL服务器的最佳内存配置实际上并没有一个固定的答案，因为它取决于多个因素，如服务器的物理内存大小、MySQL的配置文件、所处理的数据量、工作负载、查询的复杂性以及期望的性能等。

一般来说，根据MySQL官方文档的建议，一个典型的MySQL服务器至少需要2GB的物理内存。但在实际应用中，这个数字可能会更高，特别是当MySQL服务器需要处理大量的数据时。例如，如果MySQL需要处理1GB的数据，那么至少需要4GB的物理内存。

InnoDB存储引擎使用缓冲池（Buffer Pool）来缓存数据和索引，因此为InnoDB配置足够的内存是非常重要的。通常，一个好的起点是将总内存的50%到80%分配给MySQL的InnoDB缓冲池。你可以使用SHOW ENGINE INNODB STATUS命令来查看当前Buffer pool的使用情况，以便根据实际情况调整配置。

此外，除了InnoDB缓冲池外，MySQL还需要内存来存储其他信息，如线程堆栈、排序缓冲区、连接缓冲区等。因此，在配置内存时，需要确保为这些操作预留足够的内存。

请注意，内存配置只是MySQL性能调优的一部分。你还需要考虑其他因素，如磁盘I/O、CPU、网络等。在调整任何配置之前，最好先在测试环境中进行验证，以确保更改不会对生产环境造成负面影响。

前面我选择了八核的cpu，那么对应的云服务器选择就少很多了
在这里插入图片描述

由于需要部署集群，单台服务器肯定是不够的，所以考虑到成本，这里选择经济型，16GiB内存就够了。

云盘选择

ESSD AutoPL云盘

在这里插入图片描述
如果不开启预配置性能只有6800的IOPS，如果开启最高的预配置性能有56800，但是价格也会高出不少。云盘才0.21元一个小时，预配置性能则高达3.125元一小时。

在这里插入图片描述

块存储性能（ESSD）

在这里插入图片描述

ESSD Entry的IOPS要低很多，价格也便宜

在这里插入图片描述

在这里插入图片描述
ESSD云盘，上限的IOPS是五万，正常运行的IOPS是6800，综合而已，选择这宽经济实惠，也能满足一定的IOPS。

这里说一下IOPS:

IOPS，即Input/Output Operations Per Second，是一个用于计算机存储设备（如硬盘(HDD)、固态硬盘(SSD)或存储区域网络(SAN)）性能测试的量测方式，可以视为是每秒的读写次数。这是一个衡量随机存取性能的关键指标，常用于数据库和应用程序工作负载，因为这些应用通常需要快速的随机读写。
IOPS的数值会根据读写操作的大小和类型（随机或顺序）而变化。因此，当比较或评估IOPS时，应确保在相同的条件下进行。此外，IOPS和吞吐量都是描述存储性能的指标，但它们衡量的是不同的操作和应用场景。

镜像选择

首先我这里选择的是CentOS7.9版本，虽然CentOS官方不再进行新的维护了。具体来说，CentOS 7将在2024年6月30日停止维护（EOL, End Of Life），而CentOS 8在2021年底就已经停止了维护。尽管CentOS不再进行新的维护，但已经安装和运行的CentOS系统仍然可以继续使用。

同时CentOS的普及率也有一定程度了，加上大部分开发者对CentOS也是比较熟悉，网上也有很多前辈踩过坑，所以我依然选择这个镜像，就是为了保证稳定性以及遇到问题可以即时检索出答案。

带宽选择

首先，需要估计每个I/O操作平均需要传输多少数据。然后将这个数字乘以预期的IOPS来得到一个粗略的带宽需求估计。

例如，如果每个I/O操作平均传输1KB的数据，并且你预计在高并发时会有10000的IOPS，那么你需要的带宽大约是10MBps（10000 * 1KB/s）。

这里我按照顶额处理给到100MBps，因为是按量付费，选择10MBps和100MBps价格都不变，变的是使用的量。

密码配置

在这里插入图片描述
企业级通常使用密钥对保证安全性，我这里因为就是简单做个压测，就直接使用密码了。

这里提供一个生成密码的网站：https://suijimimashengcheng.bmcx.com/

9ND%8cnNyAr!##ptRz^n@tbRLf$dsau%

注意事项

购买阿里云服务器，账户最少100元才可以购买。
另外这二个配置一定加上
在这里插入图片描述
避免扣钱过度

搭建宝塔面板方便管理云服务器

这里按照宝塔面板主要是为了方便部署管理云服务器

访问宝塔面板：https://www.bt.cn/new/download.html

在这里插入图片描述

面板地址:http://8.134.108.60:8888/e8d94840
用户名:lsbjlsfj
密码:38500125

也可以使用脚本安装：

if [ -f /usr/bin/curl ];then curl -sSO https://download.bt.cn/install/install_panel.sh;else wget -O install_panel.sh https://download.bt.cn/install/install_panel.sh;fi;bash install_panel.sh ed8484bec

在这里插入图片描述
如果当前宝塔面板有漏洞的话，建议还是别安装了，毕竟也是外部安装的脚步文件。我这里主要是做压测，倒是没关系。

云服务器的安全组

我这里先将云服务器的安全组关闭了，后面宝塔面板开机自启动防火墙
在这里插入图片描述
企业通常会开启防火墙，修改默认端口，开放特定端口

安装docker和docker-compose

其他都别按照，只安装docker和docker-compose
在这里插入图片描述这是阿里云的服务器，所以选择阿里云的镜像

安装docker和docker-compose

在Linux服务器上安装Docker的命令主要包括以下步骤：

检查CentOS系统的内核版本是否高于3.10，因为Docker要求CentOS系统的内核版本高于3.10。可以使用uname -r命令来查看当前的内核版本。
更新yum包，使用命令sudo yum update。
安装必要的软件包，包括yum-utils（提供yum-config-manager功能）、device-mapper-persistent-data和lvm2。使用命令

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

设置yum源，以便可以从Docker的官方仓库中安装Docker。使用命令

sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

查看所有可用的Docker版本，以便可以选择要安装的特定版本。使用命令

yum list docker-ce --showduplicates | sort -r

安装Docker CE（社区版）。如果要安装特定版本，可以在安装命令中指定版本号。使用命令

sudo yum install docker-ce docker-ce-cli containerd.io

进行安装。
启动Docker服务，使用命令systemctl start docker。
查看Docker版本信息，使用命令docker version。如果看到版本号，表示安装成功。

请注意，安装Docker的过程中可能需要根据提示输入“y”以继续安装过程。此外，如果服务器开启了防火墙，需要在安装前关闭防火墙，并确保禁止开机启动防火墙，以避免影响Docker的正常运行。

这些步骤是Linux服务器上安装Docker的基本命令，具体步骤可能会因服务器环境和版本的不同而有所差异。在安装过程中，建议仔细阅读命令的输出信息，并根据需要进行适当的调整。

具体操作：https://blog.csdn.net/java_wxid/article/details/121317129

sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager   --add-repo   http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
sudo yum install docker-ce docker-ce-cli containerd.io
systemctl daemon-reload
systemctl start firewalld
systemctl enable firewalld
docker version
sudo curl -L "https://github.com/docker/compose/releases/download/1.28.6/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
docker-compose --version
sudo systemctl restart docker

部署MySQL三主六从半同步集群

一主二从同步集群规划

master节点：ip地址：8.134.108.60 mysql端口：33061
slave1节点：ip地址：8.134.108.60 mysql端口：33062
slave2节点：ip地址：8.134.108.60 mysql端口：33063
服务器登录的用户名密码都是root用户admin密码
master节点的mysql登录账户是root用户masterroot密码
slave1节点和slave2节点的mysql登录账户是root用户slaveroot密码

sudo useradd -r -s /sbin/nologin -d /var/lib/mysql mysql
sudo usermod -d /var/lib/mysql mysql
sudo chmod -R 755 /var/lib/mysql
grep mysql /etc/passwd
sudo usermod -d /var/lib/mysql mysql
sudo setenforce 0

部署node1节点的master1

docker-compose.yaml文件

编辑docker-compose.yaml文件，代码如下：

mkdir -p /var/lib/mysql
chmod 755 /var/lib/mysql
mkdir -p /opt/software/mysqlcluster/master1
cd /opt/software/mysqlcluster/master1
vi docker-compose.yaml

文件内容，代码如下：

version: '3'  # 使用docker-compose版本3
services:  # 定义服务
  mysql_master:  # 定义一个名为mysql_master的服务
    image: mysql:8.0.20  # 使用MySQL 8.0.20镜像
    container_name: mysql_node1_master1  # 指定容器名称为mysql_node1_master1
    restart: unless-stopped  # 在容器退出时自动重新启动
    ports:  # 定义容器和主机之间的端口映射
      - "33061:3306"  # 将容器的3306端口映射到主机的33061端口
    environment:  # 定义环境变量
      MYSQL_ROOT_PASSWORD: node1master1root  # 设置root用户的密码  
    volumes:  # 定义数据卷
      - /var/lib/mysql:/var/lib/mysql # 数据目录
    healthcheck:  
      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost", "-u", "root", "-pnode1master1root"]  # 设置容器健康检查命令
      interval: 20s  # 每隔20秒进行一次健康检查
      timeout: 10s  # 健康检查超时时间为10秒
      retries: 3  # 健康检查失败时重试次数为3次

授权文件

sudo chmod 777 docker-compose.yaml
mkdir /opt/software/mysqlcluster/master1/conf
vi /opt/software/mysqlcluster/master1/conf/my.cnf

my.cnf文件

[mysqld]
pid-file        = /var/run/mysqld/mysqld.pid
socket          = /var/run/mysqld/mysqld.sock
datadir         = /var/lib/mysql
secure-file-priv= NULL
symbolic-links=0
default-storage-engine = InnoDB # 默认存储引擎
server_id = 1010  # 服务器的唯一标识符
bind-address = 0.0.0.0  # 服务器监听的IP地址
port = 3306  # 服务器监听的端口号
character-set-server = utf8mb4  # 服务器使用的字符集
skip-external-locking  # 不使用外部锁定
skip-name-resolve  # 不进行域名解析
log-bin = mysql-bin # 启用二进制日志  
log-bin-trust-function-creators = 1  # 允许二进制日志中记录函数创建的事件
max_connections = 2000  # 最大连接数
max_user_connections = 1000  # 单个用户最大连接数
max_connect_errors = 4000  # 最大连接错误数
wait_timeout = 300  # 空闲连接的超时时间
interactive_timeout = 600  # 交互式连接的超时时间
table_open_cache = 512  # 表缓存大小
max_allowed_packet = 32M  # 最大允许的数据包大小
sort_buffer_size = 2M  # 排序缓冲区大小
join_buffer_size = 2M  # 连接缓冲区大小
thread_cache_size = 8  # 线程缓存大小
sync_binlog = 0  # 数据刷盘参数=0时，由文件系统控制写盘的频率，并发性能最好，但是意外丢失数据的风险最大
gtid_mode = ON # 开启GTID模式，用于自动处理复制中的事务  
enforce_gtid_consistency = ON # GTID_MODE 和 ENFORCE_GTID_CONSISTENCY 的设置是一致的,强制全局事务标识的一致性
# 日志设置
log-short-format = 1  # 使用短格式记录日志
slow_query_log  # 启用慢查询日志
long_query_time = 2  # 慢查询的时间阈值
# 二进制日志设置
log_bin_trust_function_creators=1  # 允许二进制日志中记录函数创建的事件
binlog_format = MIXED  # 二进制日志格式
binlog_expire_logs_seconds = 864000  # 二进制日志过期时间（单位：秒）
# InnoDB特定选项
innodb_buffer_pool_size = 4G  # InnoDB缓冲池大小
innodb_thread_concurrency = 8  # InnoDB线程并发数
innodb_flush_method = O_DIRECT  # InnoDB刷新日志的方法
innodb_flush_log_at_trx_commit = 1 # 控制事务日志的同步方式  
innodb_log_buffer_size = 128M  # InnoDB日志缓冲区大小
innodb_log_file_size = 256M  # InnoDB日志文件大小
innodb_log_files_in_group = 3  # InnoDB日志文件组中的文件数
innodb_max_dirty_pages_pct = 90  # InnoDB脏页的最大比例
innodb_lock_wait_timeout = 50  # InnoDB锁等待超时时间（单位：秒）
innodb_file_per_table = 1  # 每个表使用独立的表空间文件
plugin-load = rpl_semi_sync_master.so   # 配置半同步复制
# rpl_semi_sync_master_enabled = 1  # 开启半同步复制
# rpl_semi_sync_master_timeout = 5000 # 配置主从同步超时时间（毫秒）
[mysqldump]
quick  # 快速导出数据
max_allowed_packet = 16M  # 最大允许的数据包大小
[myisamchk]
key_buffer_size = 256M  # MyISAM键缓冲区大小
sort_buffer_size = 256M  # MyISAM排序缓冲区大小
read_buffer = 2M  # MyISAM读缓冲区大小
write_buffer = 2M  # MyISAM写缓冲区大小
[mysqlhotcopy]
interactive-timeout = 3600  # 交互式超时时间，超时时间设置为 1 小时

授权启动

sudo chmod 644 /opt/software/mysqlcluster/master1/conf/my.cnf
docker-compose up -d
docker-compose ps
sudo chown -R mysql:mysql /var/lib/mysql

复制配置文件my.cnf到容器中

docker cp /opt/software/mysqlcluster/master1/conf/my.cnf mysql_node1_master1:/etc/mysql/my.cnf

重启容器

docker restart mysql_node1_master1

进入主节点容器，命令如下：

docker exec -it mysql_node1_master1 bash

登录mysql，命令如下：

mysql -u root -pnode1master1root

参考server_id是否配置正确，判断my.cnf是否生效

SHOW VARIABLES LIKE 'server_id';

安装semisync_master模块，通过扩展库来安装半同步复制模块，需要指定扩展库的文件名，命令如下：

install plugin rpl_semi_sync_master soname 'semisync_master.so';

查看系统全局参数，命令如下：

show global variables like 'rpl_semi%';

输出结果如下：

mysql> show global variables like 'rpl_semi%';
+-------------------------------------------+------------+
| Variable_name                             | Value      |
+-------------------------------------------+------------+
| rpl_semi_sync_master_enabled              | OFF        |
| rpl_semi_sync_master_timeout              | 10000      |
| rpl_semi_sync_master_trace_level          | 32         |
| rpl_semi_sync_master_wait_for_slave_count | 1          |
| rpl_semi_sync_master_wait_no_slave        | ON         |
| rpl_semi_sync_master_wait_point           | AFTER_SYNC |
+-------------------------------------------+------------+
6 rows in set (0.00 sec)

rpl_semi_sync_master_timeout就是半同步复制时等待应答的最长等待时间，默认是10秒，可以根据情况自行调整。rpl_semi_sync_master_wait_point其实表示一种半同步复制的方式。半同步复制有两种方式，一种是我们现在看到的这种默认的AFTER_SYNC方式。这种方式下，主库把日志写入binlog，并且复制给从库，然后开始等待从库的响应。从库返回成功后，主库再提交事务，接着给客户端返回一个成功响应。而另一种方式是叫做AFTER_COMMIT方式。他不是默认的。这种方式，在主库写入binlog后，等待binlog复制到从库，主库就提交自己的本地事务，再等待从库返回给自己一个成功响应，然后主库再给客户端返回响应。

打开半同步复制的开关，命令如下：

set global rpl_semi_sync_master_enabled=ON;

授权，命令如下：

ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'node1master1root';
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'node1master1root';
FLUSH PRIVILEGES;

查看master节点状态

show master status;

输出结果：

mysql> show master status;
+------------------+----------+--------------+------------------+------------------------------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set                        |
+------------------+----------+--------------+------------------+------------------------------------------+
| mysql-bin.000003 |      196 |              |                  | 7410e8b2-e12b-11ee-9499-0242ac160002:1-3 |
+------------------+----------+--------------+------------------+------------------------------------------+
1 row in set (0.00 sec)

mysql>

退出容器将my.cnf文件中的：

# rpl_semi_sync_master_enabled = 1  # 开启半同步复制
# rpl_semi_sync_master_timeout = 5000 # 配置主从同步超时时间（毫秒）

打开：

rpl_semi_sync_master_enabled = 1  # 开启半同步复制
rpl_semi_sync_master_timeout = 5000 # 配置主从同步超时时间（毫秒）

重启master节点的mysql服务，命令如下：

docker restart mysql_node1_master1

部署node1节点的slave1

docker-compose.yaml文件

编辑docker-compose.yaml文件，代码如下：

mkdir -p /var/lib/mysqlslave1
ls -ld /var/lib/mysqlslave1/
chmod 755 /var/lib/mysqlslave1/
ls -ld /var/lib/mysqlslave1/
mkdir -p /opt/software/mysqlcluster/slave1
cd /opt/software/mysqlcluster/slave1
vi docker-compose.yaml

文件内容，代码如下：

version: '3'  # 使用docker-compose版本3
services:  # 定义服务
  mysql_master:  # 定义一个名为mysql_master的服务
    image: mysql:8.0.20  # 使用MySQL 8.0.20镜像
    container_name: mysql_node1_slave1  # 指定容器名称为mysql_node2_slave1
    restart: unless-stopped  # 在容器退出时自动重新启动
    ports:  # 定义容器和主机之间的端口映射
      - "33064:3309"  # 将容器的3306端口映射到主机的33061端口
    environment:  # 定义环境变量
      MYSQL_ROOT_PASSWORD: node1slave1root  # 设置root用户的密码  
    volumes:  # 定义数据卷
      - /var/lib/mysqlslave1:/var/lib/mysql # 数据目录
    healthcheck:  
      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost", "-u", "root", "-pnode1slave1root"]  # 设置容器健康检查命令
      interval: 20s  # 每隔20秒进行一次健康检查
      timeout: 10s  # 健康检查超时时间为10秒
      retries: 3  # 健康检查失败时重试次数为3次

授权文件

sudo chmod 777 docker-compose.yaml
mkdir -p /opt/software/mysqlcluster/slave1/conf
vi /opt/software/mysqlcluster/slave1/conf/my.cnf

my.cnf文件

[mysqld]
pid-file        = /var/run/mysqld/mysqld.pid
socket          = /var/run/mysqld/mysqld.sock
datadir         = /var/lib/mysql
secure-file-priv= NULL
symbolic-links=0
default-storage-engine = InnoDB # 默认存储引擎
server_id = 1011  # 服务器的唯一标识符
bind-address = 0.0.0.0  # 服务器监听的IP地址
port = 3309  # 服务器监听的端口号
character-set-server = utf8mb4  # 服务器使用的字符集
skip-external-locking  # 不使用外部锁定
skip-name-resolve  # 不进行域名解析
relay_log = relay-log  # 开启中继日志
relay_log_index = slave-relay-bin.index  # 设置中继日志索引的文件名
read_only = ON # 启用只读属性
relay_log_purge = 0 # 是否自动清空不再需要中继日志
log_slave_updates=1  # 开启从服务器记录二进制日志更新的功能
max_connections = 2000  # 最大连接数
max_user_connections = 1000  # 单个用户最大连接数
max_connect_errors = 4000  # 最大连接错误数
wait_timeout = 300  # 空闲连接的超时时间
interactive_timeout = 600  # 交互式连接的超时时间
table_open_cache = 512  # 表缓存大小
max_allowed_packet = 32M  # 最大允许的数据包大小
sort_buffer_size = 2M  # 排序缓冲区大小
join_buffer_size = 2M  # 连接缓冲区大小
thread_cache_size = 8  # 线程缓存大小
sync_binlog = 0  # 数据刷盘参数=0时，由文件系统控制写盘的频率，并发性能最好，但是意外丢失数据的风险最大
gtid_mode = ON # 开启GTID模式，用于自动处理复制中的事务  
enforce_gtid_consistency = ON # GTID_MODE 和 ENFORCE_GTID_CONSISTENCY 的设置是一致的,强制全局事务标识的一致性
# 日志设置
log-short-format = 1  # 使用短格式记录日志
slow_query_log  # 启用慢查询日志
long_query_time = 2  # 慢查询的时间阈值
# 二进制日志设置
binlog_format = MIXED  # 二进制日志格式
binlog_expire_logs_seconds = 864000  # 二进制日志过期时间（单位：秒）
# InnoDB特定选项
innodb_buffer_pool_size = 4G  # InnoDB缓冲池大小
innodb_thread_concurrency = 8  # InnoDB线程并发数
innodb_flush_method = O_DIRECT  # InnoDB刷新日志的方法
innodb_flush_log_at_trx_commit = 1 # 控制事务日志的同步方式  
innodb_log_buffer_size = 128M  # InnoDB日志缓冲区大小
innodb_log_file_size = 256M  # InnoDB日志文件大小
innodb_log_files_in_group = 3  # InnoDB日志文件组中的文件数
innodb_max_dirty_pages_pct = 90  # InnoDB脏页的最大比例
innodb_lock_wait_timeout = 50  # InnoDB锁等待超时时间（单位：秒）
innodb_file_per_table = 1  # 每个表使用独立的表空间文件
# plugin-load = semisync_slave.so  # 半同步复制
# rpl_semi_sync_slave_enabled = 1 # 开启半同步复制
[mysqldump]
quick  # 快速导出数据
max_allowed_packet = 16M  # 最大允许的数据包大小
[myisamchk]
key_buffer_size = 256M  # MyISAM键缓冲区大小
sort_buffer_size = 256M  # MyISAM排序缓冲区大小
read_buffer = 2M  # MyISAM读缓冲区大小
write_buffer = 2M  # MyISAM写缓冲区大小
[mysqlhotcopy]
interactive-timeout = 3600  # 交互式超时时间，超时时间设置为 1 小时

授权启动

sudo chmod 644 /opt/software/mysqlcluster/slave1/conf/my.cnf

启动运行，命令如下：

docker-compose up -d
docker-compose ps

复制配置文件my.cnf到容器中

docker cp /opt/software/mysqlcluster/slave1/conf/my.cnf mysql_node1_slave1:/etc/mysql/my.cnf

重启容器

docker restart mysql_node1_slave1

进入主节点容器，命令如下：

docker exec -it mysql_node1_slave1 bash

登录mysql，命令如下：

mysql -u root -pnode1slave1root

参考server_id是否配置正确，判断my.cnf是否生效

SHOW VARIABLES LIKE 'server_id';

安装smeisync_slave模块，命令如下：

install plugin rpl_semi_sync_slave soname 'semisync_slave.so';
set global rpl_semi_sync_slave_enabled = on;

查看效果，命令如下：

show global variables like 'rpl_semi%';

输出结果：

mysql> show global variables like 'rpl_semi%';
+---------------------------------+-------+
| Variable_name                   | Value |
+---------------------------------+-------+
| rpl_semi_sync_slave_enabled     | ON    |
| rpl_semi_sync_slave_trace_level | 32    |
+---------------------------------+-------+
2 rows in set (0.01 sec)

rpl_semi_sync_slave_enabled为ON表示设置成功。

授权，命令如下：

ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'node1slave1root';
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'node1slave1root';
FLUSH PRIVILEGES;

退出容器将my.cnf文件中的：

# plugin-load = semisync_slave.so  # 半同步复制
# rpl_semi_sync_slave_enabled = 1 # 开启半同步复制

打开：

plugin-load = semisync_slave.so  # 半同步复制
rpl_semi_sync_slave_enabled = 1 # 开启半同步复制

重启从节点1的mysql服务，命令如下：

docker cp /opt/software/mysqlcluster/slave1/conf/my.cnf mysql_node1_slave1:/etc/mysql/my.cnf
docker restart mysql_node1_slave1
docker exec -it mysql_node1_slave1 bash
mysql -u root -pnode1slave1root

部署node1节点的slave2

docker-compose.yaml文件

编辑docker-compose.yaml文件，代码如下：

mkdir -p /var/lib/mysqlslave2
ls -ld /var/lib/mysqlslave2/
chmod 755 /var/lib/mysqlslave2/
ls -ld /var/lib/mysqlslave2/
mkdir /opt/software/mysqlcluster/slave2
cd /opt/software/mysqlcluster/slave2
vi docker-compose.yaml

文件内容，代码如下：

version: '3'  # 使用docker-compose版本3
services:  # 定义服务
  mysql_master:  # 定义一个名为mysql_master的服务
    image: mysql:8.0.20  # 使用MySQL 8.0.20镜像
    container_name: mysql_node1_slave2  # 指定容器名称为mysql_node1_slave2
    restart: unless-stopped  # 在容器退出时自动重新启动
    ports:  # 定义容器和主机之间的端口映射
      - "33065:3310"  # 将容器的3306端口映射到主机的33061端口
    environment:  # 定义环境变量
      MYSQL_ROOT_PASSWORD: node2slave2root  # 设置root用户的密码  
    volumes:  # 定义数据卷
      - /var/lib/mysqlslave2:/var/lib/mysql # 数据目录
    healthcheck:  
      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost", "-u", "root", "-pnode2slave2root"]  # 设置容器健康检查命令
      interval: 20s  # 每隔20秒进行一次健康检查
      timeout: 10s  # 健康检查超时时间为10秒
      retries: 3  # 健康检查失败时重试次数为3次

授权文件

sudo chmod 777 docker-compose.yaml
mkdir -p /opt/software/mysqlcluster/slave2/conf
vi /opt/software/mysqlcluster/slave2/conf/my.cnf

my.cnf文件

[mysqld]
pid-file        = /var/run/mysqld/mysqld.pid
socket          = /var/run/mysqld/mysqld.sock
datadir         = /var/lib/mysql
secure-file-priv= NULL
symbolic-links=0
default-storage-engine = InnoDB # 默认存储引擎
server_id = 1021  # 服务器的唯一标识符
bind-address = 0.0.0.0  # 服务器监听的IP地址
port = 3310  # 服务器监听的端口号
character-set-server = utf8mb4  # 服务器使用的字符集
skip-external-locking  # 不使用外部锁定
skip-name-resolve  # 不进行域名解析
relay_log = relay-log  # 开启中继日志
relay_log_index = slave-relay-bin.index  # 设置中继日志索引的文件名
read_only = ON # 启用只读属性
relay_log_purge = 0 # 是否自动清空不再需要中继日志
log_slave_updates=1  # 开启从服务器记录二进制日志更新的功能
max_connections = 2000  # 最大连接数
max_user_connections = 1000  # 单个用户最大连接数
max_connect_errors = 4000  # 最大连接错误数
wait_timeout = 300  # 空闲连接的超时时间
interactive_timeout = 600  # 交互式连接的超时时间
table_open_cache = 512  # 表缓存大小
max_allowed_packet = 32M  # 最大允许的数据包大小
sort_buffer_size = 2M  # 排序缓冲区大小
join_buffer_size = 2M  # 连接缓冲区大小
thread_cache_size = 8  # 线程缓存大小
sync_binlog = 0  # 数据刷盘参数=0时，由文件系统控制写盘的频率，并发性能最好，但是意外丢失数据的风险最大
gtid_mode = ON # 开启GTID模式，用于自动处理复制中的事务  
enforce_gtid_consistency = ON # GTID_MODE 和 ENFORCE_GTID_CONSISTENCY 的设置是一致的,强制全局事务标识的一致性
# 日志设置
log-short-format = 1  # 使用短格式记录日志
slow_query_log  # 启用慢查询日志
long_query_time = 2  # 慢查询的时间阈值
# 二进制日志设置
binlog_format = MIXED  # 二进制日志格式
binlog_expire_logs_seconds = 864000  # 二进制日志过期时间（单位：秒）
# InnoDB特定选项
innodb_buffer_pool_size = 4G  # InnoDB缓冲池大小
innodb_thread_concurrency = 8  # InnoDB线程并发数
innodb_flush_method = O_DIRECT  # InnoDB刷新日志的方法
innodb_flush_log_at_trx_commit = 1 # 控制事务日志的同步方式  
innodb_log_buffer_size = 128M  # InnoDB日志缓冲区大小
innodb_log_file_size = 256M  # InnoDB日志文件大小
innodb_log_files_in_group = 3  # InnoDB日志文件组中的文件数
innodb_max_dirty_pages_pct = 90  # InnoDB脏页的最大比例
innodb_lock_wait_timeout = 50  # InnoDB锁等待超时时间（单位：秒）
innodb_file_per_table = 1  # 每个表使用独立的表空间文件
plugin-load = semisync_slave.so  # 半同步复制
rpl_semi_sync_slave_enabled = 1 # 开启半同步复制
[mysqldump]
quick  # 快速导出数据
max_allowed_packet = 16M  # 最大允许的数据包大小
[myisamchk]
key_buffer_size = 256M  # MyISAM键缓冲区大小
sort_buffer_size = 256M  # MyISAM排序缓冲区大小
read_buffer = 2M  # MyISAM读缓冲区大小
write_buffer = 2M  # MyISAM写缓冲区大小
[mysqlhotcopy]
interactive-timeout = 3600  # 交互式超时时间，超时时间设置为 1 小时

授权启动

sudo chmod 644 /opt/software/mysqlcluster/slave2/conf/my.cnf

启动运行，命令如下：

docker-compose up -d
docker-compose ps

复制配置文件my.cnf到容器中

docker cp /opt/software/mysqlcluster/slave2/conf/my.cnf mysql_node1_slave2:/etc/mysql/my.cnf

重启容器

docker restart mysql_node1_slave2

进入主节点容器，命令如下：

docker exec -it mysql_node1_slave2 bash

登录mysql，命令如下：

mysql -u root -pnode2slave2root

参考server_id是否配置正确，判断my.cnf是否生效

SHOW VARIABLES LIKE 'server_id';

安装smeisync_slave模块，命令如下：

install plugin rpl_semi_sync_slave soname 'semisync_slave.so';
set global rpl_semi_sync_slave_enabled = on;

查看效果，命令如下：

show global variables like 'rpl_semi%';

输出结果：

mysql> show global variables like 'rpl_semi%';
+---------------------------------+-------+
| Variable_name                   | Value |
+---------------------------------+-------+
| rpl_semi_sync_slave_enabled     | ON    |
| rpl_semi_sync_slave_trace_level | 32    |
+---------------------------------+-------+
2 rows in set (0.01 sec)

rpl_semi_sync_slave_enabled为ON表示设置成功。

授权，命令如下：

ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'node2slave2root';
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'node2slave2root';
FLUSH PRIVILEGES;

退出容器将my.cnf文件中的：

# plugin-load = semisync_slave.so  # 半同步复制
# rpl_semi_sync_slave_enabled = 1 # 开启半同步复制

打开：

plugin-load = semisync_slave.so  # 半同步复制
rpl_semi_sync_slave_enabled = 1 # 开启半同步复制

重启从节点2的mysql服务，命令如下：

docker cp /opt/software/mysqlcluster/slave2/conf/my.cnf mysql_node1_slave2:/etc/mysql/my.cnf
docker restart mysql_node1_slave2
docker exec -it mysql_node1_slave2 bash
mysql -u root -pnode2slave2root

查看master节点状态

show master status;

配置三个从节点的主从同步配置

配置规划

node1	node2	node3
master1	master2	master3
slave1	slave1	slave1
slave2	slave2	slave2

查看master节点状态：

show master status

mysql> show master status;
+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000001 |      156 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)

mysql>

在slave1和slave2上配置master1为主节点

CHANGE MASTER TO
MASTER_HOST='8.134.108.60',
MASTER_PORT=33061,
MASTER_USER='root',
MASTER_PASSWORD='node1master1root',
MASTER_LOG_FILE='mysql-bin.000001',
MASTER_LOG_POS=156;

开启主从配置，查看从节点状态，命令如下：

START SLAVE;
show slave status\G;

只要Slave_IO_Running: Yes和Slave_SQL_Running: Yes主从同步配置就好了。

校验三主六从集群同步是否正常

在所有master节点查看数据库，命令如下：

show databases;

输出结果如下：

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

在其中一个master节点上创建一个test数据库，命令如下：

create database test;

去其他所有节点上查看数据库是否同步过去，同步过去说明真个集群处于同步状态。

主从复制容易遇错中断

START SLAVE; 命令用于启动 MySQL 的主从复制功能。如果配置的时候主从，但是在同步过程中出现异常错误，则会打断主从同步，并且需要重新手动重新配置，而这个过程需要每隔一段时间监听，使用SHOW SLAVE STATUS\G; 命令来查看从服务器的复制状态，这可能就需要通过手写程序或者使用某云产品来实现。

Redis集群配置

执行编写脚本docker-redis-cluster.sh：

vim docker-redis-cluster.sh

#!/bin/bash  
# 循环执行6次  
for i in $(seq 6)  
do  
  # 设置端口号  
  PORT=637$i    
  # 获取当前主机的IP地址  
  REDIS_CLUSTER_IP=$(hostname -I | awk '{print $1}')    
  # 设置配置文件路径  
  CONFIG_FILE="/opt/software/rediscluster/conf/redis-$i.conf"  
  # 检查配置文件是否存在，如果存在并且是目录，则删除  
  if [ -d "$CONFIG_FILE" ]; then  
    echo "配置文件$CONFIG_FILE已经是一个目录，正在删除它..."  
    rm -rf "$CONFIG_FILE"  
  fi  
  
  # 检查模板文件是否存在  
  if [ ! -f /opt/software/rediscluster/conf/redis.conf ]; then  
    echo "模板文件/opt/software/rediscluster/conf/redis.conf不存在，请确保它存在并且包含正确的占位符。"  
    exit 1  
  fi  
  
  # 通过sed命令替换模板文件中的占位符，生成实际的配置文件  
  sed "s/PORT/${PORT}/g;s/REDIS_CLUSTER_IP/${REDIS_CLUSTER_IP}/g;" /opt/software/rediscluster/conf/redis.conf > "$CONFIG_FILE"    
  # 使用docker运行Redis容器，并挂载配置文件和数据目录  
  docker run -d --name redis-node-$i --restart=unless-stopped --net host --privileged=true -v /opt/software/rediscluster/node/redis-node-$i:/data -v "$CONFIG_FILE":/etc/redis/redis.conf redis:7.2.4 redis-server /etc/redis/redis.conf  
done

redis.conf配置文件

# Redis配置文件示例  
# 绑定到所有网络接口  
bind 0.0.0.0
# 保护模式设置为no，这样Redis就可以接受来自任何主机的连接  
protected-mode no
# Redis 集群节点监听的端口  
port PORT
# TCP backlog的数量，默认是1500，在高并发环境下你可能需要增加这个值。同时需要编辑sudo nano /etc/sysctl.conf文件，添加或者编辑net.core.somaxconn = 1500，在 nano 编辑器中，按 Ctrl + O（这是“O”字母，不是数字零）。这将会提示你保存文件。如果文件是第一次创建或之前没有被修改过，它会询问你文件名，此时你可以直接按 Enter 键确认使用当前的文件名。如果文件已经被修改过，它会直接保存更改。保存文件后，按 Ctrl + X。这将会退出 nano 编辑器并返回到终端。否则会出现提示 TCP 的 backlog 设置（1500）不能强制执行，因为 /proc/sys/net/core/somaxconn 的值被设置为更低的 128。/proc/sys/net/core/somaxconn 是一个内核参数，它定义了系统中每一个端口上排队的最大 TCP 连接数。sudo sysctl -p
tcp-backlog 1500
# 开启集群模式
cluster-enabled yes
# 超时时间，超时则认为master宕机，随后主备切换。单位是毫秒  
cluster-node-timeout 5000
# 集群配置文件的路径，Redis 集群节点会自动创建和更新这个文件  
cluster-config-file nodes-PORT.conf
#集群各节点IP地址，记得修改为你的ip地址
cluster-announce-ip REDIS_CLUSTER_IP
#集群节点映射端口 
cluster-announce-port PORT
#集群总线端口 
cluster-announce-bus-port 1PORT 
# TCP 后台线程和I/O线程：如果启用了 TCP 后台线程（io-threads-do-reads）或 I/O 线程（io-threads），确保为这些线程配置了正确的 CPU 内核列表（server_cpulist、bio_cpulist 等）。
io-threads-do-reads yes
io-threads 4
# Redis Server绑定到的CPU内核列表，这里绑定到CPU 0和1  
server_cpulist 0-1 
# 后台I/O线程绑定到的CPU内核列表，这里绑定到CPU 2和3  
bio_cpulist 2-3
# AOF重写进程绑定到的CPU内核列表，这里绑定到CPU 4  
aof_rewrite_cpulist 4 
# RDB持久化进程绑定到的CPU内核列表，这里绑定到CPU 5  
bgsave_cpulist 5
# 启用AOF持久化  
appendonly yes
# AOF文件名称  
appendfilename "appendonly.aof"
# appendonly 文件同步策略，always 表示每个写命令都立即同步，everysec 表示每秒同步一次，no 表示由操作系统决定何时同步  
appendfsync everysec
# 密码设置  
requirepass admin
# Redis集群启用了密码验证，那么除了在每个节点的配置文件中设置requirepass之外，还需要设置masterauth
masterauth admin
# 禁用 RDB 快照持久化，因为集群模式下有节点复制功能  
save ""
# 禁用 AOF 重写
auto-aof-rewrite-percentage 0
auto-aof-rewrite-min-size 0

配置过程

通常情况下内存overcommit（超额提交）未启用，这可能在内存不足的情况下导致后台保存或复制失败。即使在不出现内存不足的情况下，这也可能导致失败。在/etc/sysctl.conf文件中添加vm.overcommit_memory = 1，然后重启系统以启用内存overcommit。

[root@node3 rediscluster]# cat /etc/sysctl.conf
# sysctl settings are defined through files in
# /usr/lib/sysctl.d/, /run/sysctl.d/, and /etc/sysctl.d/.
#
# Vendors settings live in /usr/lib/sysctl.d/.
# To override a whole file, create a new file with the same in
# /etc/sysctl.d/ and put new settings there. To override
# only specific settings, add a file with a lexically later
# name in /etc/sysctl.d/ and put new settings there.
#
# For more information, see sysctl.conf(5) and sysctl.d(5).
net.core.somaxconn = 1500
sysctl vm.overcommit_memory = 1

或者执行以下命令并查看是否更改成功。

sysctl -w vm.overcommit_memory=1

然后重启服务器，执行以下命令运行脚本：

chmod 777 /opt/software/rediscluster/conf/redis.conf
chmod 777 /opt/software/rediscluster/docker-redis-cluster.sh
sh docker-redis-cluster.sh

docker exec -it redis-node-1 bash

用私网ip:
在这里插入图片描述

redis-cli  -a admin --cluster create 10.0.0.14:6371 10.0.0.14:6372 10.0.0.14:6373 10.0.0.14:6374 10.0.0.14:6375 10.0.0.14:6376 --cluster-replicas 1

在这里插入图片描述我的Redis实例是在Docker容器内部运行的，应该使用容器内部或宿主机的私有IP地址，而不是公网IP地址。使用的是宿主机公网IP，需要确保防火墙或安全组规则允许外部连接到这些端口。

redis-cli -p 6371 -a admin

cluster info

cluster nodes

在这里插入图片描述

RocketMQ

配置runserver.sh

mkdir -p /opt/software/rocketmqcluster/bin
vi /opt/software/rocketmqcluster/bin/runserver.sh

#!/bin/bash

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

#===========================================================================================
# Java Environment Setting
#===========================================================================================
error_exit ()
{
    echo "ERROR: $1 !!"
    exit 1
}

find_java_home()
{
    case "`uname`" in
        Darwin)
            JAVA_HOME=$(/usr/libexec/java_home)
        ;;
        *)
            JAVA_HOME=$(dirname $(dirname $(readlink -f $(which javac))))
        ;;
    esac
}

find_java_home

[ ! -e "$JAVA_HOME/bin/java" ] && JAVA_HOME=$HOME/jdk/java
[ ! -e "$JAVA_HOME/bin/java" ] && JAVA_HOME=/usr/java
[ ! -e "$JAVA_HOME/bin/java" ] && error_exit "Please set the JAVA_HOME variable in your environment, We need java(x64)!"

export JAVA_HOME
export JAVA="$JAVA_HOME/bin/java"
export BASE_DIR=$(dirname $0)/..
export CLASSPATH=.:${BASE_DIR}/conf:${CLASSPATH}

#===========================================================================================
# JVM Configuration
#===========================================================================================
calculate_heap_sizes()
{
    case "`uname`" in
        Linux)
            system_memory_in_mb=`free -m| sed -n '2p' | awk '{print $2}'`
            system_cpu_cores=`egrep -c 'processor([[:space:]]+):.*' /proc/cpuinfo`
        ;;
        FreeBSD)
            system_memory_in_bytes=`sysctl hw.physmem | awk '{print $2}'`
            system_memory_in_mb=`expr $system_memory_in_bytes / 1024 / 1024`
            system_cpu_cores=`sysctl hw.ncpu | awk '{print $2}'`
        ;;
        SunOS)
            system_memory_in_mb=`prtconf | awk '/Memory size:/ {print $3}'`
            system_cpu_cores=`psrinfo | wc -l`
        ;;
        Darwin)
            system_memory_in_bytes=`sysctl hw.memsize | awk '{print $2}'`
            system_memory_in_mb=`expr $system_memory_in_bytes / 1024 / 1024`
            system_cpu_cores=`sysctl hw.ncpu | awk '{print $2}'`
        ;;
        *)
            # assume reasonable defaults for e.g. a modern desktop or
            # cheap server
            system_memory_in_mb="2048"
            system_cpu_cores="2"
        ;;
    esac

    # some systems like the raspberry pi don't report cores, use at least 1
    if [ "$system_cpu_cores" -lt "1" ]
    then
        system_cpu_cores="1"
    fi

    # set max heap size based on the following
    # max(min(1/2 ram, 1024MB), min(1/4 ram, 8GB))
    # calculate 1/2 ram and cap to 1024MB
    # calculate 1/4 ram and cap to 8192MB
    # pick the max
    half_system_memory_in_mb=`expr $system_memory_in_mb / 2`
    quarter_system_memory_in_mb=`expr $half_system_memory_in_mb / 2`
    if [ "$half_system_memory_in_mb" -gt "1024" ]
    then
        half_system_memory_in_mb="1024"
    fi
    if [ "$quarter_system_memory_in_mb" -gt "8192" ]
    then
        quarter_system_memory_in_mb="8192"
    fi
    if [ "$half_system_memory_in_mb" -gt "$quarter_system_memory_in_mb" ]
    then
        max_heap_size_in_mb="$half_system_memory_in_mb"
    else
        max_heap_size_in_mb="$quarter_system_memory_in_mb"
    fi
    MAX_HEAP_SIZE="${max_heap_size_in_mb}M"

    # Young gen: min(max_sensible_per_modern_cpu_core * num_cores, 1/4 * heap size)
    max_sensible_yg_per_core_in_mb="100"
    max_sensible_yg_in_mb=`expr $max_sensible_yg_per_core_in_mb "*" $system_cpu_cores`

    desired_yg_in_mb=`expr $max_heap_size_in_mb / 4`

    if [ "$desired_yg_in_mb" -gt "$max_sensible_yg_in_mb" ]
    then
        HEAP_NEWSIZE="${max_sensible_yg_in_mb}M"
    else
        HEAP_NEWSIZE="${desired_yg_in_mb}M"
    fi
}
# calculate_heap_sizes 函数就是用来根据系统的总内存和其他一些因素，动态地计算出一个合适的堆内存大小。这里我想自定义，所以注释掉了
calculate_heap_sizes

# Dynamically calculate parameters, for reference.
Xms=$MAX_HEAP_SIZE
Xmx=$MAX_HEAP_SIZE
Xmn=$HEAP_NEWSIZE
# Set for `JAVA_OPT`.
JAVA_OPT="${JAVA_OPT} -server -Xms${Xms} -Xmx${Xmx} -Xmn${Xmn}"
JAVA_OPT="${JAVA_OPT} -XX:+UseConcMarkSweepGC -XX:+UseCMSCompactAtFullCollection -XX:CMSInitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+CMSClassUnloadingEnabled -XX:SurvivorRatio=8  -XX:-UseParNewGC"
JAVA_OPT="${JAVA_OPT} -verbose:gc -Xloggc:/dev/shm/rmq_srv_gc.log -XX:+PrintGCDetails"
JAVA_OPT="${JAVA_OPT} -XX:-OmitStackTraceInFastThrow"
JAVA_OPT="${JAVA_OPT}  -XX:-UseLargePages"
JAVA_OPT="${JAVA_OPT} -Djava.ext.dirs=${JAVA_HOME}/jre/lib/ext:${BASE_DIR}/lib"
#JAVA_OPT="${JAVA_OPT} -Xdebug -Xrunjdwp:transport=dt_socket,address=9555,server=y,suspend=n"
JAVA_OPT="${JAVA_OPT} ${JAVA_OPT_EXT}"
JAVA_OPT="${JAVA_OPT} -cp ${CLASSPATH}"

$JAVA ${JAVA_OPT} $@

runbroker.sh

vi /opt/software/rocketmqcluster/bin/runbroker.sh

#!/bin/bash

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

#===========================================================================================
# Java Environment Setting
#===========================================================================================
error_exit ()
{
    echo "ERROR: $1 !!"
    exit 1
}

find_java_home()
{
    case "`uname`" in
        Darwin)
            JAVA_HOME=$(/usr/libexec/java_home)
        ;;
        *)
            JAVA_HOME=$(dirname $(dirname $(readlink -f $(which javac))))
        ;;
    esac
}

find_java_home

[ ! -e "$JAVA_HOME/bin/java" ] && JAVA_HOME=$HOME/jdk/java
[ ! -e "$JAVA_HOME/bin/java" ] && JAVA_HOME=/usr/java
[ ! -e "$JAVA_HOME/bin/java" ] && error_exit "Please set the JAVA_HOME variable in your environment, We need java(x64)!"

export JAVA_HOME
export JAVA="$JAVA_HOME/bin/java"
export BASE_DIR=$(dirname $0)/..
export CLASSPATH=.:${BASE_DIR}/conf:${CLASSPATH}

#===========================================================================================
# JVM Configuration
#===========================================================================================
calculate_heap_sizes()
{
    case "`uname`" in
        Linux)
            system_memory_in_mb=`free -m| sed -n '2p' | awk '{print $2}'`
            system_cpu_cores=`egrep -c 'processor([[:space:]]+):.*' /proc/cpuinfo`
        ;;
        FreeBSD)
            system_memory_in_bytes=`sysctl hw.physmem | awk '{print $2}'`
            system_memory_in_mb=`expr $system_memory_in_bytes / 1024 / 1024`
            system_cpu_cores=`sysctl hw.ncpu | awk '{print $2}'`
        ;;
        SunOS)
            system_memory_in_mb=`prtconf | awk '/Memory size:/ {print $3}'`
            system_cpu_cores=`psrinfo | wc -l`
        ;;
        Darwin)
            system_memory_in_bytes=`sysctl hw.memsize | awk '{print $2}'`
            system_memory_in_mb=`expr $system_memory_in_bytes / 1024 / 1024`
            system_cpu_cores=`sysctl hw.ncpu | awk '{print $2}'`
        ;;
        *)
            # assume reasonable defaults for e.g. a modern desktop or
            # cheap server
            system_memory_in_mb="2048"
            system_cpu_cores="2"
        ;;
    esac

    # some systems like the raspberry pi don't report cores, use at least 1
    if [ "$system_cpu_cores" -lt "1" ]
    then
        system_cpu_cores="1"
    fi

    # set max heap size based on the following
    # max(min(1/2 ram, 1024MB), min(1/4 ram, 8GB))
    # calculate 1/2 ram and cap to 1024MB
    # calculate 1/4 ram and cap to 8192MB
    # pick the max
    half_system_memory_in_mb=`expr $system_memory_in_mb / 2`
    quarter_system_memory_in_mb=`expr $half_system_memory_in_mb / 2`
    if [ "$half_system_memory_in_mb" -gt "1024" ]
    then
        half_system_memory_in_mb="1024"
    fi
    if [ "$quarter_system_memory_in_mb" -gt "8192" ]
    then
        quarter_system_memory_in_mb="8192"
    fi
    if [ "$half_system_memory_in_mb" -gt "$quarter_system_memory_in_mb" ]
    then
        max_heap_size_in_mb="$half_system_memory_in_mb"
    else
        max_heap_size_in_mb="$quarter_system_memory_in_mb"
    fi
    MAX_HEAP_SIZE="${max_heap_size_in_mb}M"

    # Young gen: min(max_sensible_per_modern_cpu_core * num_cores, 1/4 * heap size)
    max_sensible_yg_per_core_in_mb="100"
    max_sensible_yg_in_mb=`expr $max_sensible_yg_per_core_in_mb "*" $system_cpu_cores`

    desired_yg_in_mb=`expr $max_heap_size_in_mb / 4`

    if [ "$desired_yg_in_mb" -gt "$max_sensible_yg_in_mb" ]
    then
        HEAP_NEWSIZE="${max_sensible_yg_in_mb}M"
    else
        HEAP_NEWSIZE="${desired_yg_in_mb}M"
    fi
}
# calculate_heap_sizes 函数就是用来根据系统的总内存和其他一些因素，动态地计算出一个合适的堆内存大小。这里我想自定义，所以注释掉了
# calculate_heap_sizes

# Dynamically calculate parameters, for reference.
Xms=$MAX_HEAP_SIZE
Xmx=$MAX_HEAP_SIZE
Xmn=$HEAP_NEWSIZE
MaxDirectMemorySize=$MAX_HEAP_SIZE
# Set for `JAVA_OPT`.
JAVA_OPT="${JAVA_OPT} -server -Xms${Xms} -Xmx${Xmx} -Xmn${Xmn}"
JAVA_OPT="${JAVA_OPT} -XX:+UseG1GC -XX:G1HeapRegionSize=16m -XX:G1ReservePercent=25 -XX:InitiatingHeapOccupancyPercent=30 -XX:SoftRefLRUPolicyMSPerMB=0 -XX:SurvivorRatio=8"
JAVA_OPT="${JAVA_OPT} -verbose:gc -Xloggc:/dev/shm/mq_gc_%p.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCApplicationStoppedTime -XX:+PrintAdaptiveSizePolicy"
JAVA_OPT="${JAVA_OPT} -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=30m"
JAVA_OPT="${JAVA_OPT} -XX:-OmitStackTraceInFastThrow"
JAVA_OPT="${JAVA_OPT} -XX:+AlwaysPreTouch"
JAVA_OPT="${JAVA_OPT} -XX:MaxDirectMemorySize=${MaxDirectMemorySize}"
JAVA_OPT="${JAVA_OPT} -XX:-UseLargePages -XX:-UseBiasedLocking"
JAVA_OPT="${JAVA_OPT} -Djava.ext.dirs=${JAVA_HOME}/jre/lib/ext:${BASE_DIR}/lib"
#JAVA_OPT="${JAVA_OPT} -Xdebug -Xrunjdwp:transport=dt_socket,address=9555,server=y,suspend=n"
JAVA_OPT="${JAVA_OPT} ${JAVA_OPT_EXT}"
JAVA_OPT="${JAVA_OPT} -cp ${CLASSPATH}"

numactl --interleave=all pwd > /dev/null 2>&1
if [ $? -eq 0 ]
then
	if [ -z "$RMQ_NUMA_NODE" ] ; then
		numactl --interleave=all $JAVA ${JAVA_OPT} $@
	else
		numactl --cpunodebind=$RMQ_NUMA_NODE --membind=$RMQ_NUMA_NODE $JAVA ${JAVA_OPT} $@
	fi
else
	$JAVA ${JAVA_OPT} $@
fi

配置分组

使用root用户创建rocketmq组，增加rocketmq用户并加入rocketmq组，设置用户密码

groupadd rocketmq
useradd -g rocketmq rocketmq
passwd rocketmq

输入密码，8位以上复杂密码

liaozhiwei12345678

更改组的 gid，更改用户的 uid，查看是否更改成功

groupmod -g 3000 rocketmq
usermod -u 3000 rocketmq
id rocketmq

递归地将/opt/software/rocketmqcluster目录及其所有子目录和文件的所有者和所属组都更改为rocketmq

chown -R rocketmq:rocketmq /opt/software/rocketmqcluster

配置JDK

安装配置JDK，根据实际情况选择版本，注意JDK的版本和RocketMQ的版本是否匹配。
运行RocketMQ需要先安装JDK。我们采用目前最稳定的JDK1.8版本。可以自行去Oracle官网上下载也可以使用我从官网拉下来的jdk版本。链接：https://pan.baidu.com/s/10YA9SBV7Y6TKJ9keBrNVWw?pwd=2022
提取码：2022
用FTP或者WSP上传到rocketmq用户的工作目录下。由rocketmq用户解压到/opt/jdk目录下

chmod 777 jdk-8u152-linux-x64.tar.gz
tar -zxvf jdk-8u152-linux-x64.tar.gz

vi /etc/profile

尾部添加：

export JAVA_HOME=/opt/jdk1.8.0_152
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=./:JAVA_HOME/lib:$JRE_HOME/lib
export ROCKETMQ_HOME=/opt/software/rocketmqcluster
export PATH=/bin:/user/bin:/sbin:$JAVA_HOME/bin:$ROCKETMQ_HOME/bin:$PATH

source /etc/profile
java -version

java version "1.8.0_152"
Java(TM) SE Runtime Environment (build 1.8.0_152-b16)
Java HotSpot(TM) 64-Bit Server VM (build 25.152-b16, mixed mode)
[root@iZ7xv7y4w2otz9udxctoa6Z jdk1.8.0_152]#

配置属性文件

进入到rocketmqcluster目录，代码如下：

cd /opt/software/rocketmqcluster

创建rocket存储、日志、配置目录，代码如下：

mkdir -p /opt/software/rocketmqcluster/conf/dledger

broker-n0.conf

编辑broker-n0的broker属性文件，代码如下：

vi /opt/software/rocketmqcluster/conf/dledger/broker-n0.conf

添加配置，代码如下：

# broker名，名称一样的节点就是一组主从节点。
brokerName=broker0
# broker对外服务的监听端口
listenPort=30911
# 所属集群名，名称一样的节点就在同一个集群内
brokerClusterName=CustomRocketMQCluster
# brokerid，0就表示是Master，>0的都是表示Slave
brokerId=0
# 删除文件时间点，默认凌晨4点
deleteWhen=04
# 文件保留时间，默认48 小时
fileReservedTime=48
# broker角色，ASYNC_MASTER异步复制Master，SYNC_MASTER同步双写Master，SLAVE从节点接收来自Master节点的复制消息。在高可用集群中，建议将所有的Broker节点都配置成ASYNC_MASTER角色，以便在主节点挂掉后进行主从切换
brokerRole=ASYNC_MASTER
# 刷盘方式，ASYNC_FLUSH异步刷盘，SYNC_FLUSH同步刷盘
flushDiskType=ASYNC_FLUSH
# broker ip多网卡配置，容器配置宿主机网卡ip
brokerIP1=8.138.134.212
# name-server地址，分号间隔
namesrvAddr=8.138.134.212:9876;8.138.134.212:9876;8.138.134.212:9876;
# 存储路径
storePathRootDir=/home/rocketmq/rocketmq-4.7.1/store-n0
# commitLog存储路径
storePathCommitLog=/home/rocketmq/rocketmq-4.7.1/store-n0/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/home/rocketmq/rocketmq-4.7.1/store-n0/consumequeue
#消息索引存储路径
storePathIndex=/home/rocketmq/rocketmq-4.7.1/store-n0/index
#checkpoint 文件存储路径
storeCheckpoint=/home/rocketmq/rocketmq-4.7.1/store-n0/checkpoint
#abort 文件存储路径
abortFile=/home/rocketmq/rocketmq-4.7.1/store-n0/abort
# 是否允许broker自动创建Topic
autoCreateTopicEnable=true
# autoCreateTopicKeyWord 定义了哪些主题名称会被自动创建。星号 * 表示所有主题名称都会被自动创建。
autoCreateTopicKeyWord=*
# 是否允许broker自动创建订阅组
autoCreateSubscriptionGroup=true
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#强制销毁映射文件的间隔时间（以毫秒为单位）。如果某个映射文件在指定的时间内没有被访问，它将被强制销毁以释放资源
#destroyMapedFileIntervalForcibly=120000
#重新删除悬挂文件的间隔时间。悬挂文件是指在某些情况下没有被正常关闭的文件。通过定期检查和删除这些文件，可以避免资源泄漏。
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#限制的消息大小
maxMessageSize=65536
#刷新CommitLog和ConsumeQueue到磁盘时的最小页面数
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#彻底刷新CommitLog和ConsumeQueue到磁盘的间隔时间（以毫秒为单位）
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
# 是否启动DLedger
enableDLegerCommitLog=true
# DLedger Raft Group的名字，建议和brokerName保持一致
dLegerGroup=broker0
# DLedger Group内各节点的端口信息，同一个Group内的各个节点配置必须要保证一致
dLegerPeers=n0-8.138.134.212:40911;n1-8.138.134.212:40911;n2-8.138.134.212:40911
# 节点id, 必须属于dLegerPeers中的一个；同Group内各个节点要唯一
dLegerSelfId=n0

broker-n1.conf

编辑broker-n1的broker属性文件，代码如下：

vi /opt/software/rocketmqcluster/conf/dledger/broker-n1.conf

添加配置，代码如下：

# broker名，名称一样的节点就是一组主从节点。
brokerName=broker1
# broker对外服务的监听端口
listenPort=30912
# 所属集群名，名称一样的节点就在同一个集群内
brokerClusterName=CustomRocketMQCluster
# brokerid，0就表示是Master，>0的都是表示Slave
brokerId=1
# 删除文件时间点，默认凌晨4点
deleteWhen=04
# 文件保留时间，默认48 小时
fileReservedTime=48
# broker角色，ASYNC_MASTER异步复制Master，SYNC_MASTER同步双写Master，SLAVE从节点接收来自Master节点的复制消息。在高可用集群中，建议将所有的Broker节点都配置成ASYNC_MASTER角色，以便在主节点挂掉后进行主从切换
brokerRole=ASYNC_MASTER
# 刷盘方式，ASYNC_FLUSH异步刷盘，SYNC_FLUSH同步刷盘
flushDiskType=ASYNC_FLUSH
# broker ip多网卡配置，容器配置宿主机网卡ip
brokerIP1=8.138.134.212
# name-server地址，分号间隔
namesrvAddr=8.138.134.212:9876;8.138.134.212:9876;8.138.134.212:9876;
# 存储路径
storePathRootDir=/home/rocketmq/rocketmq-4.7.1/store-n1
# commitLog存储路径
storePathCommitLog=/home/rocketmq/rocketmq-4.7.1/store-n1/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/home/rocketmq/rocketmq-4.7.1/store-n1/consumequeue
#消息索引存储路径
storePathIndex=/home/rocketmq/rocketmq-4.7.1/store-n1/index
#checkpoint 文件存储路径
storeCheckpoint=/home/rocketmq/rocketmq-4.7.1/store-n1/checkpoint
#abort 文件存储路径
abortFile=/home/rocketmq/rocketmq-4.7.1/store-n1/abort
# 是否允许broker自动创建Topic
autoCreateTopicEnable=true
# autoCreateTopicKeyWord 定义了哪些主题名称会被自动创建。星号 * 表示所有主题名称都会被自动创建。
autoCreateTopicKeyWord=*
# 是否允许broker自动创建订阅组
autoCreateSubscriptionGroup=true
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#强制销毁映射文件的间隔时间（以毫秒为单位）。如果某个映射文件在指定的时间内没有被访问，它将被强制销毁以释放资源
#destroyMapedFileIntervalForcibly=120000
#重新删除悬挂文件的间隔时间。悬挂文件是指在某些情况下没有被正常关闭的文件。通过定期检查和删除这些文件，可以避免资源泄漏。
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#限制的消息大小
maxMessageSize=65536
#刷新CommitLog和ConsumeQueue到磁盘时的最小页面数
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#彻底刷新CommitLog和ConsumeQueue到磁盘的间隔时间（以毫秒为单位）
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
# 是否启动DLedger
enableDLegerCommitLog=true
# DLedger Raft Group的名字，建议和brokerName保持一致
dLegerGroup=broker1
# DLedger Group内各节点的端口信息，同一个Group内的各个节点配置必须要保证一致
dLegerPeers=n0-8.138.134.212:40912;n1-8.138.134.212:40912;n2-8.138.134.212:40912
# 节点id, 必须属于dLegerPeers中的一个；同Group内各个节点要唯一
dLegerSelfId=n0

broker-n2.conf

编辑broker-n2的broker属性文件，代码如下：

vi /opt/software/rocketmqcluster/conf/dledger/broker-n2.conf

添加配置，代码如下：

# broker名，名称一样的节点就是一组主从节点。
brokerName=broker2
# broker对外服务的监听端口
listenPort=30913
# 所属集群名，名称一样的节点就在同一个集群内
brokerClusterName=CustomRocketMQCluster
# brokerid，0就表示是Master，>0的都是表示Slave
brokerId=2
# 删除文件时间点，默认凌晨4点
deleteWhen=04
# 文件保留时间，默认48 小时
fileReservedTime=48
# broker角色，ASYNC_MASTER异步复制Master，SYNC_MASTER同步双写Master，SLAVE从节点接收来自Master节点的复制消息。在高可用集群中，建议将所有的Broker节点都配置成ASYNC_MASTER角色，以便在主节点挂掉后进行主从切换
brokerRole=ASYNC_MASTER
# 刷盘方式，ASYNC_FLUSH异步刷盘，SYNC_FLUSH同步刷盘
flushDiskType=ASYNC_FLUSH
# broker ip多网卡配置，容器配置宿主机网卡ip
brokerIP1=8.138.134.212
# name-server地址，分号间隔
namesrvAddr=8.138.134.212:9876;8.138.134.212:9876;8.138.134.212:9876;
# 存储路径
storePathRootDir=/home/rocketmq/rocketmq-4.7.1/store-n2
# commitLog存储路径
storePathCommitLog=/home/rocketmq/rocketmq-4.7.1/store-n2/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/home/rocketmq/rocketmq-4.7.1/store-n2/consumequeue
#消息索引存储路径
storePathIndex=/home/rocketmq/rocketmq-4.7.1/store-n2/index
#checkpoint 文件存储路径
storeCheckpoint=/home/rocketmq/rocketmq-4.7.1/store-n2/checkpoint
#abort 文件存储路径
abortFile=/home/rocketmq/rocketmq-4.7.1/store-n2/abort
# 是否允许broker自动创建Topic
autoCreateTopicEnable=true
# autoCreateTopicKeyWord 定义了哪些主题名称会被自动创建。星号 * 表示所有主题名称都会被自动创建。
autoCreateTopicKeyWord=*
# 是否允许broker自动创建订阅组
autoCreateSubscriptionGroup=true
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#强制销毁映射文件的间隔时间（以毫秒为单位）。如果某个映射文件在指定的时间内没有被访问，它将被强制销毁以释放资源
#destroyMapedFileIntervalForcibly=120000
#重新删除悬挂文件的间隔时间。悬挂文件是指在某些情况下没有被正常关闭的文件。通过定期检查和删除这些文件，可以避免资源泄漏。
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#限制的消息大小
maxMessageSize=65536
#刷新CommitLog和ConsumeQueue到磁盘时的最小页面数
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#彻底刷新CommitLog和ConsumeQueue到磁盘的间隔时间（以毫秒为单位）
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
# 是否启动DLedger
enableDLegerCommitLog=true
# DLedger Raft Group的名字，建议和brokerName保持一致
dLegerGroup=broker2
# DLedger Group内各节点的端口信息，同一个Group内的各个节点配置必须要保证一致
dLegerPeers=n0-8.138.134.212:40913;n1-8.138.134.212:40913;n2-8.138.134.212:40913
# 节点id, 必须属于dLegerPeers中的一个；同Group内各个节点要唯一
dLegerSelfId=n0

docker-compose.yaml

创建docker-compose.yaml文件，代码如下：

vi /opt/software/rocketmqcluster/docker-compose.yaml

添加配置，代码如下：

version: '3.5'
services:
  namesrv:
    restart: always
    image: apache/rocketmq:4.7.1
    container_name: namesrv
    ports:
      - 9876:9876
    environment:
      # runbroker.sh文件中设置Java堆的最大内存限制为512兆字节（MB）
      - MAX_HEAP_SIZE=512m
      # runbroker.sh文件中设置新生代的大小为256MB
      - HEAP_NEWSIZE=256m
      # 通常情况下设置上述二个配置，JAVA_OPT_EXT中就不需要设置堆大小和新生代大小了，不过这里还是重复设置（有些可能不对runbroker.sh进行配置，使用下面进行jvm调优也不受影响）
      - JAVA_OPT_EXT=-Duser.home=/home/rocketmq/rocketmq-4.7.1 -Xms512m -Xmx512m -Xmn256m -XX:InitiatingHeapOccupancyPercent=30 -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCApplicationStoppedTime -XX:+PrintAdaptiveSizePolicy -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=30m -XX:SoftRefLRUPolicyMSPerMB=0 -verbose:gc 
      - TZ=Asia/Shanghai
    volumes:
      - /opt/software/rocketmqcluster/bin/runserver.sh:/home/rocketmq/rocketmq-4.7.1/bin/runserver.sh
    command: sh mqnamesrv
  broker-n0:
    restart: always
    image: apache/rocketmq:4.7.1
    container_name: broker-n0
    ports:
      - 30911:30911
      - 40911:40911
    environment:
      - NAMESRV_ADDR=8.138.134.212:9876;8.138.134.212:9876;8.138.134.212:9876;
      # runbroker.sh文件中设置Java堆的最大内存限制为512兆字节（MB）
      - MAX_HEAP_SIZE=512m
      # runbroker.sh文件中设置新生代的大小为256MB
      - HEAP_NEWSIZE=256m
      # 通常情况下设置上述二个配置，JAVA_OPT_EXT中就不需要设置堆大小和新生代大小了，不过这里还是重复设置（有些可能不对runbroker.sh进行配置，使用下面进行jvm调优也不受影响）
      - JAVA_OPT_EXT=-Duser.home=/home/rocketmq/rocketmq-4.7.1 -Xms512m -Xmx512m -Xmn256m -XX:InitiatingHeapOccupancyPercent=30 -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCApplicationStoppedTime -XX:+PrintAdaptiveSizePolicy -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=30m -XX:SoftRefLRUPolicyMSPerMB=0 -verbose:gc 
      - TZ=Asia/Shanghai
    volumes:
      - /opt/software/rocketmqcluster/conf/dledger/broker-n0.conf:/home/rocketmq/rocketmq-4.7.1/conf/dledger/broker-n0.conf
      - /opt/software/rocketmqcluster/bin/runbroker.sh:/home/rocketmq/rocketmq-4.7.1/bin/runbroker.sh
    command: sh mqbroker -c /home/rocketmq/rocketmq-4.7.1/conf/dledger/broker-n0.conf
  broker-n1:
    restart: always
    image: apache/rocketmq:4.7.1
    container_name: broker-n1
    ports:
      - 30912:30912
      - 40912:40912
    environment:
      - NAMESRV_ADDR=8.138.134.212:9876;8.138.134.212:9876;8.138.134.212:9876;
      # runbroker.sh文件中设置Java堆的最大内存限制为512兆字节（MB）
      - MAX_HEAP_SIZE=512m
      # runbroker.sh文件中设置新生代的大小为256MB
      - HEAP_NEWSIZE=256m
      # 通常情况下设置上述二个配置，JAVA_OPT_EXT中就不需要设置堆大小和新生代大小了，不过这里还是重复设置（有些可能不对runbroker.sh进行配置，使用下面进行jvm调优也不受影响）      
      - JAVA_OPT_EXT=-Duser.home=/home/rocketmq/rocketmq-4.7.1 -Xms512m -Xmx512m -Xmn256m -XX:InitiatingHeapOccupancyPercent=30 -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCApplicationStoppedTime -XX:+PrintAdaptiveSizePolicy -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=30m -XX:SoftRefLRUPolicyMSPerMB=0 -verbose:gc 
      - TZ=Asia/Shanghai
    volumes:
      - /opt/software/rocketmqcluster/conf/dledger/broker-n1.conf:/home/rocketmq/rocketmq-4.7.1/conf/dledger/broker-n1.conf
      - /opt/software/rocketmqcluster/bin/runbroker.sh:/home/rocketmq/rocketmq-4.7.1/bin/runbroker.sh
    command: sh mqbroker -c /home/rocketmq/rocketmq-4.7.1/conf/dledger/broker-n1.conf
  broker-n2:
    restart: always
    image: apache/rocketmq:4.7.1
    container_name: broker-n2
    ports:
      - 30913:30913
      - 40913:40913
    environment:
      - NAMESRV_ADDR=8.138.134.212:9876;8.138.134.212:9876;8.138.134.212:9876;
      # runbroker.sh文件中设置Java堆的最大内存限制为512兆字节（MB）
      - MAX_HEAP_SIZE=512m
      # runbroker.sh文件中设置新生代的大小为256MB
      - HEAP_NEWSIZE=256m
      # 通常情况下设置上述二个配置，JAVA_OPT_EXT中就不需要设置堆大小和新生代大小了，不过这里还是重复设置（有些可能不对runbroker.sh进行配置，使用下面进行jvm调优也不受影响）
      - JAVA_OPT_EXT=-Duser.home=/home/rocketmq/rocketmq-4.7.1 -Xms512m -Xmx512m -Xmn256m -XX:InitiatingHeapOccupancyPercent=30 -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCApplicationStoppedTime -XX:+PrintAdaptiveSizePolicy -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=30m -XX:SoftRefLRUPolicyMSPerMB=0 -verbose:gc 
      - TZ=Asia/Shanghai
    volumes:
      - /opt/software/rocketmqcluster/conf/dledger/broker-n2.conf:/home/rocketmq/rocketmq-4.7.1/conf/dledger/broker-n2.conf
      - /opt/software/rocketmqcluster/bin/runbroker.sh:/home/rocketmq/rocketmq-4.7.1/bin/runbroker.sh
    command: sh mqbroker -c /home/rocketmq/rocketmq-4.7.1/conf/dledger/broker-n2.conf
  console:
    restart: always
    image: apacherocketmq/rocketmq-dashboard
    container_name: console
    ports:
      - 19081:8080
    environment:
        TZ: "Asia/Shanghai"
        JAVA_OPTS: "-Drocketmq.namesrv.addr=8.138.134.212:9876;8.138.134.212:9876;8.138.134.212:9876 -Dcom.rocketmq.sendMessageWithVIPChannel=false"
    depends_on:
      - namesrv
# 网络声明
networks:
  rmq:
    name: rmq # 指定网络名称
    driver: bridge # 指定网络驱动程序
# 通用日志设置
x-logging:
    &default-logging
    # 日志大小和数量
    options:
        max-size: "100m"
        max-file: "3"
    # 文件存储类型
    driver: json-file

访问控制台：http://8.138.134.212:19081/#/
在这里插入图片描述

配置Nacos

配置JDK

chmod 777 jdk-8u152-linux-x64.tar.gz
tar -zxvf jdk-8u152-linux-x64.tar.gz

vi /etc/profile

尾部添加：

export JAVA_HOME=/opt/jdk1.8.0_152
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=./:JAVA_HOME/lib:$JRE_HOME/lib
export ROCKETMQ_HOME=/opt/software/rocketmqcluster
export PATH=/bin:/user/bin:/sbin:$JAVA_HOME/bin:$ROCKETMQ_HOME/bin:$PATH

source /etc/profile
java -version

java version "1.8.0_152"
Java(TM) SE Runtime Environment (build 1.8.0_152-b16)
Java HotSpot(TM) 64-Bit Server VM (build 25.152-b16, mixed mode)
[root@iZ7xv7y4w2otz9udxctoa6Z jdk1.8.0_152]#

创建脚本：
在/opt/software/nacoscluster/config目录下创建cluster.conf属性文件：

mkdir -p /opt/software/nacoscluster/config
vim /opt/software/nacoscluster/config/cluster.conf

8.138.100.27:8848
8.138.100.27:8850
8.138.100.27:8852
8.138.100.27:8854
8.138.100.27:8856
8.138.100.27:8858

vim /opt/software/nacoscluster/config/application.properties

# 设置spring的servlet上下文路径，默认为/nacos，可以通过环境变量SERVER_SERVLET_CONTEXTPATH来指定  
server.servlet.contextPath=/nacos    
# 设置服务的上下文路径，默认为/nacos  
server.contextPath=/nacos    
# 设置服务端口，默认为8848  
server.port=8848    
# 设置数据源平台，默认为空，可以通过环境变量SPRING_DATASOURCE_PLATFORM来指定  
spring.datasource.platform=
# 设置CMDB dump任务的执行间隔，单位为秒，默认为3600秒（1小时）  
nacos.cmdb.dumpTaskInterval=3600    
# 设置CMDB event任务的执行间隔，单位为秒，默认为10秒  
nacos.cmdb.eventTaskInterval=10  
# 设置CMDB label任务的执行间隔，单位为秒，默认为300秒（5分钟）  
nacos.cmdb.labelTaskInterval=300  
# 设置是否在启动时加载数据，默认为false  
nacos.cmdb.loadDataAtStart=false  
# 设置数据库数量，默认为1，可以通过环境变量MYSQL_DATABASE_NUM来指定  
db.num=1  
# 设置第一个数据库的连接URL，使用JDBC格式，并可以通过环境变量MYSQL_SERVICE_DB_PARAM来指定连接参数  
db.url.0=jdbc:mysql://8.134.108.60:33061/user?characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8
# 设置数据库用户名，这里为root  
db.user=root  
# 设置数据库密码，这里为node1master1root  
db.password=node1master1root  
# 设置认证系统的类型，目前仅支持'nacos'  
nacos.core.auth.system.type=nacos
# 设置token的过期时间，单位为秒，默认为18000秒（5小时）  
nacos.core.auth.default.token.expire.seconds=18000 
# 设置默认的token密钥  
### The default token:  
nacos.core.auth.default.token.secret.key=SecretKey012345678901234567890123456789012345678901234567890123456789
# 是否开启认证信息的缓存，开启后认证信息的更新会有15秒的延迟  
nacos.core.auth.caching.enabled=false
# 是否启用userAgent白名单认证  
nacos.core.auth.enable.userAgentAuthWhite=false  
# 设置认证服务器的标识键  
nacos.core.auth.server.identity.key=serverIdentity   
# 设置认证服务器的标识值  
nacos.core.auth.server.identity.value=security    
# 是否启用Tomcat的访问日志  
server.tomcat.accesslog.enabled=false
# 设置Tomcat访问日志的格式  
# %h: 远程主机名（IP地址）  
# %l: 请求者身份验证名（通常为'-'）  
# %u: 远程用户（通常为'-'）  
# %t: 请求的时间戳  
# "%r": 请求的第一行（例如GET /index.html HTTP/1.1）  
# %s: HTTP状态码  
# %b: 发送的字节数，不包括HTTP头，如果为0则显示'-'  
# %D: 处理请求的时间（以毫秒为单位）  
server.tomcat.accesslog.pattern=%h %l %u %t "%r" %s %b %D    
# 设置Tomcat的默认工作目录，这里未指定具体路径，可按需配置  
server.tomcat.basedir=    
# 设置Nacos需要忽略安全校验的URL路径，这里通过环境变量NACOS_SECURITY_IGNORE_URLS指定了一系列路径  
# 包括根路径'/'，错误页面'/error'，以及所有CSS、JS、HTML、MAP、SVG、PNG、ICO文件的路径，以及console-fe的公共目录、v1/auth目录等  
nacos.security.ignore.urls=${NACOS_SECURITY_IGNORE_URLS:/,/error,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-fe/public/**,/v1/auth/**,/v1/console/health/**,/actuator/**,/v1/console/server/**}    
# 关闭向Elastic导出指标的功能  
management.metrics.export.elastic.enabled=false    
# 关闭向InfluxDB导出指标的功能  
management.metrics.export.influx.enabled=false    
# 设置Nacos命名服务分发任务的线程数，默认为10  
nacos.naming.distro.taskDispatchThreadCount=10    
# 设置Nacos命名服务分发任务的调度周期，单位为毫秒，默认为200毫秒  
nacos.naming.distro.taskDispatchPeriod=200    
# 设置Nacos命名服务分发任务时，批量同步的键的数量，默认为1000  
nacos.naming.distro.batchSyncKeyCount=1000    
# 设置Nacos命名服务数据初始化时，同步的数据占全部数据的比例，默认为0.9（即90%）  
nacos.naming.distro.initDataRatio=0.9    
# 设置Nacos命名服务在同步失败时重试的延迟时间，单位为毫秒，默认为5000毫秒（即5秒）  
nacos.naming.distro.syncRetryDelay=5000    
# 设置Nacos命名服务在启动时是否预热数据，默认为true  
nacos.naming.data.warmup=true

使用脚本运行：

vim docker-nacos-cluster.sh

docker-nacos-cluster.sh文件：

#!/bin/bash  
# 初始化端口号为8848  
port=8848  
# 循环执行6次  
for i in $(seq 6)  
do  
  instance_name="nacos$i"  
  # 每个实例使用不同的宿主机端口  
  host_port=$((port + i - 1))  
  # 容器内部仍然监听8848端口，但映射到不同的宿主机端口  
  container_port=8848      
  # 构建 docker run 命令字符串  
  docker_command="docker run -d -p $host_port:$container_port --name $instance_name --restart=unless-stopped --hostname $instance_name nacos/nacos-server:1.4.1"      
  # 打印命令日志  
  echo "Executing: $docker_command"  
  # 执行 docker run 命令  
  eval $docker_command      
  # 更新端口号以供下一个实例使用  
  let "port+=1"  
done

docker cp /opt/software/nacoscluster/config/application.properties nacos1:/home/nacos/conf/application.properties
docker cp /opt/software/nacoscluster/config/cluster.conf nacos1:/home/nacos/conf/cluster.conf
docker cp /opt/software/nacoscluster/config/application.properties nacos2:/home/nacos/conf/application.properties
docker cp /opt/software/nacoscluster/config/cluster.conf nacos2:/home/nacos/conf/cluster.conf
docker cp /opt/software/nacoscluster/config/application.properties nacos3:/home/nacos/conf/application.properties
docker cp /opt/software/nacoscluster/config/cluster.conf nacos3:/home/nacos/conf/cluster.conf
docker cp /opt/software/nacoscluster/config/application.properties nacos4:/home/nacos/conf/application.properties
docker cp /opt/software/nacoscluster/config/cluster.conf nacos4:/home/nacos/conf/cluster.conf
docker cp /opt/software/nacoscluster/config/application.properties nacos5:/home/nacos/conf/application.properties
docker cp /opt/software/nacoscluster/config/cluster.conf nacos5:/home/nacos/conf/cluster.conf
docker cp /opt/software/nacoscluster/config/application.properties nacos6:/home/nacos/conf/application.properties
docker cp /opt/software/nacoscluster/config/cluster.conf nacos6:/home/nacos/conf/cluster.conf
docker restart nacos1
docker restart nacos2
docker restart nacos3
docker restart nacos4
docker restart nacos5
docker restart nacos6

nacos访问地址：
http://8.138.100.27:8848/nacos
http://8.138.100.27:8850/nacos
http://8.138.100.27:8852/nacos
http://8.138.100.27:8854/nacos
http://8.138.100.27:8856/nacos
http://8.138.100.27:8858/nacos

默认用户密码：nacos/nacos

Nginx高可用负载

拷贝nginx配置文件出来：

mkdir /opt/software/nginx
mkdir /opt/software/nginx/log
cd /opt/software/nginx/
docker pull nginx
docker run --name nginx-test -p 80:80 -d nginx
docker cp nginx-test:/etc/nginx/nginx.conf /opt/software/nginx/nginx.conf
chmod 777 nginx.conf
docker stop nginx-test && docker rm nginx-test

拷贝出来的文件如下：

user  nginx;
worker_processes  auto;
error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;
events {
    worker_connections  1024;
}
http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile        on;
    #tcp_nopush     on;
    keepalive_timeout  65;
    #gzip  on;
    include /etc/nginx/conf.d/*.conf;
}

在最后一行（和http同级）添加以下代码：

user  nginx;
worker_processes  auto;
error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;
events {
    worker_connections  1024;
}
http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile        on;
    #tcp_nopush     on;
    keepalive_timeout  65;
    #gzip  on;
    include /etc/nginx/conf.d/*.conf;
}
stream {
    upstream nacos {
        server 8.138.100.27:8848 weight=1 max_fails=2 fail_timeout=10s;
        server 8.138.100.27:8850 weight=1 max_fails=2 fail_timeout=10s;
        server 8.138.100.27:8852 weight=1 max_fails=2 fail_timeout=10s;
        server 8.138.100.27:8854 weight=1 max_fails=2 fail_timeout=10s;		
        server 8.138.100.27:8856 weight=1 max_fails=2 fail_timeout=10s;
        server 8.138.100.27:8858 weight=1 max_fails=2 fail_timeout=10s;	
    }
    server {
        listen 8048;
        proxy_pass nacos;
    }
}

docker运行nginx：

docker run -p 8048:8048  --name nginx --restart=unless-stopped -v /opt/software/nginx/log/:/var/log/nginx -v /opt/software/nginx/nginx.conf:/etc/nginx/nginx.conf -d nginx

开放防火墙端口8048端口，访问地址：http://8.138.100.27:8048/nacos
默认的用户名和密码：nacos

在这里插入图片描述

CSDN

📢文章总结

对本篇文章进行总结：

🔔以上就是今天要讲的内容，阅读结束后，反思和总结所学内容，并尝试应用到现实中，有助于深化理解和应用知识。与朋友或同事分享所读内容，讨论细节并获得反馈，也有助于加深对知识的理解和吸收。

🔔如果您需要转载或者搬运这篇文章的话，非常欢迎您私信我哦~

🚀🎉希望各位读者大大多多支持用心写文章的博主，现在时代变了，🚀🎉 信息爆炸，酒香也怕巷子深🔥，博主真的需要大家的帮助才能在这片海洋中继续发光发热🎨，所以，🏃💨赶紧动动你的小手，点波关注❤️，点波赞👍，点波收藏⭐，甚至点波评论✍️，都是对博主最好的支持和鼓励！

💂 博客主页：我是廖志伟
👉开源项目：java_wxid
🌥 哔哩哔哩：我是廖志伟
🎏个人社区：幕后大佬
🔖个人微信号： SeniorRD
🎉微信号二维码：

📥博主目标

🍋程序开发这条路不能停，停下来容易被淘汰掉，吃不了自律的苦，就要受平庸的罪，持续的能力才能带来持续的自信。我本是一个很普通的程序员，放在人堆里，除了与生俱来的盛世美颜，就剩180的大高个了，就是我这样的一个人，默默写博文也有好多年了。
📺有句老话说的好，牛逼之前都是傻逼式的坚持，希望自己可以通过大量的作品、时间的积累、个人魅力、运气、时机，可以打造属于自己的技术影响力。
💥内心起伏不定，我时而激动，时而沉思。我希望自己能成为一个综合性人才，具备技术、业务和管理方面的精湛技能。我想成为产品架构路线的总设计师，团队的指挥者，技术团队的中流砥柱，企业战略和资本规划的实战专家。
🎉这个目标的实现需要不懈的努力和持续的成长，但我必须努力追求。因为我知道，只有成为这样的人才，我才能在职业生涯中不断前进并为企业的发展带来真正的价值。在这个不断变化的时代，我们必须随时准备好迎接挑战，不断学习和探索新的领域，才能不断地向前推进。我坚信，只要我不断努力，我一定会达到自己的目标。