Linux云计算 |【第四阶段】RDBMS2-DAY2

主要内容：

数据读写分离概述、Maxscale实现数据读写分离、多实例配置、中间件概述

一、数据读写分离概述

数据读写分离（Read/Write Splitting）是一种数据库架构设计模式，旨在提高数据库系统的性能、可扩展性和可用性。通过将读操作和写操作分离到不同的数据库实例上，可以有效减轻主数据库的负载，提高系统的整体性能。

使用读写分离的原因：

• ① 数据库写入效率要低于读取效率
• ② 一般来说，数据读取频率高于写入频率
• ③ 单个数据库实例在写入的时候，可能因写入效率慢，从而影响读取性能

基本概念：

将数据库的读操作（SELECT）和写操作（INSERT、UPDATE、DELETE）分离到不同的数据库实例上。通常有一个主数据库（Master）负责处理所有的写操作，而多个从数据库（Slaves）负责处理读操作。可由程序员通过代码实现，也可通过中间件服务器实现，如mysql-proxy、mycat、maxscale。

工作原理：

主数据库（Master）：

• 负责处理所有的写操作（INSERT、UPDATE、DELETE）
• 将写操作记录到二进制日志（Binary Log）中

从数据库（Slaves）：

• 通过复制主数据库的二进制日志，同步主数据库的数据
• 负责处理所有的读操作（SELECT）

负载均衡：

• 通过负载均衡器（Load Balancer）将读操作分发到多个从数据库上，以均衡负载

优点：

提高性能：

• 通过将读操作分发到多个从数据库上，减轻主数据库的负载，提高系统的整体性能。

• 适用于读操作远多于写操作的场景。
  提高可扩展性：

• 通过增加从数据库的数量，可以水平扩展系统的读能力。

• 主数据库和从数据库可以部署在不同的物理服务器上，提高系统的可扩展性。
  提高可用性：

• 从数据库可以作为主数据库的备份，提供数据的安全性和可靠性。

• 当主数据库发生故障时，可以从从数据库中选择一个作为新的主数据库，实现故障转移。

缺点：

数据一致性问题：

• 由于主数据库和从数据库之间的数据同步存在延迟，可能会导致数据一致性问题。

• 适用于对数据一致性要求不严格的场景。
  配置复杂：

• 需要配置和管理主数据库和从数据库之间的复制关系。

• 需要配置负载均衡器，以实现读操作的分发。
  单点写入：

• 主数据库仍然是单点写入，存在单点故障风险。

• 可以通过主主复制（Master-Master Replication）或多主复制（Multi-Master Replication）来解决单点写入问题，但配置和管理更加复杂。

二、Maxscale概述

MaxScale 是 MariaDB 公司开发的一款开源数据库中间件，旨在提供高性能、高可用性和可扩展性的数据库服务。MaxScale 支持多种数据库系统，包括 MySQL、MariaDB、PostgreSQL 等，并提供了丰富的功能，如读写分离、负载均衡、连接池、查询路由、数据分片等。

当主库故障后，Maxscale还可实现数据库自动故障转移，通过识别数据库语句，并将这些语句转发到一个或多个数据库服务器，扩展了MariaDB服务器的高可用性、可伸缩性和安全性（自动选取其中一个从库作为主库，其它从库自动指向新主库进行复制）。

下载地址：https://downloads.mariadb.com/MaxScale/

• 主配置文件：/etc/maxscale.cnf
• 服务日志文件：/var/log/maxscale/maxscale.log

1、主要功能

读写分离（Read/Write Splitting）

• MaxScale 支持自动将读操作和写操作分发到不同的数据库实例上，从而提高系统的性能和可扩展性。主数据库（Master）负责处理所有的写操作，而从数据库（Slaves）负责处理读操作。

负载均衡（Load Balancing）

• MaxScale 可以将客户端的请求分发到多个数据库实例上，以均衡负载。负载均衡策略可以根据请求类型（读或写）、数据库实例的负载情况等进行动态调整。

连接池（Connection Pooling）

• MaxScale 提供了连接池功能，可以有效管理数据库连接，减少连接建立和断开的开销，提高系统的性能和稳定性。

查询路由（Query Routing）

• MaxScale 可以根据查询的类型和内容，将查询路由到合适的数据库实例上。例如，可以将复杂的查询路由到性能较高的数据库实例上，将简单的查询路由到性能较低的数据库实例上。

数据分片（Data Sharding）

• MaxScale 支持数据分片功能，可以将数据分布到多个数据库实例上，以提高系统的可扩展性和性能。数据分片可以根据表、列或查询条件进行。

高可用性（High Availability）

• MaxScale 支持主从复制和多主复制，可以实现数据库的高可用性。当主数据库发生故障时，MaxScale 可以自动将从数据库提升为主数据库，实现故障转移。

2、架构和工作原理

1）监听器（Listener）

监听器负责监听客户端的连接请求，并将请求转发给合适的服务模块。监听器可以配置多个，以支持不同的协议和端口。

2）服务模块（Service）

服务模块是 MaxScale 的核心组件，负责处理客户端的请求。服务模块可以配置多个，每个服务模块可以对应一个或多个数据库实例。

3）路由模块（Router）

路由模块负责将客户端的请求路由到合适的数据库实例上。MaxScale 提供了多种路由模块，如读写分离路由模块（Read/Write Splitter）、负载均衡路由模块（Load Balancer）、查询路由模块（Query Router）等。

4）过滤器（Filter）

过滤器可以在请求到达数据库实例之前或之后对请求进行处理。MaxScale 提供了多种过滤器，如日志过滤器、查询重写过滤器、数据分片过滤器等。

5）监控模块（Monitor）

监控模块负责监控数据库实例的状态，如主从复制状态、数据库连接状态等。监控模块可以配置多个，以支持不同的数据库实例。

3、配置和管理

1）配置文件示例

MaxScale 的配置文件是一个文本文件，通常命名为 maxscale.cnf。配置文件中定义了监听器、服务模块、路由模块、过滤器、监控模块等的配置信息。以下是一个简单的配置文件示例：

[maxscale]
threads=auto

[server1]
type=server
address=192.168.1.101
port=3306
protocol=MySQLBackend

[server2]
type=server
address=192.168.1.102
port=3306
protocol=MySQLBackend

[Read-Write-Service]
type=service
router=readwritesplit
servers=server1,server2
user=maxscale
passwd=maxscale_password

[Read-Write-Listener]
type=listener
service=Read-Write-Service
protocol=MySQLClient
port=4006

2）管理工具

MaxScale 提供了命令行工具 maxctrl 和 Web 管理界面，用于管理和监控 MaxScale 的运行状态

• **maxctrl：**命令行工具，用于查看和修改 MaxScale 的配置，监控数据库实例的状态等
• **Web 管理界面：**通过 Web 界面可以直观地查看 MaxScale 的运行状态，配置和管理 MaxScale 的各个组件

---

读写分离实施示例：

实验拓扑图：

• 服务器角色：node10为主(Master），node11为从(Slave)，node17为中间件(Maxscale)；
• node10配置：ip地址192.168.2.10，启动mysqld，检查主从同步；
• node11配置：ip地址192.168.2.11，启动mysqld，检查主从同步；
• node17配置：ip地址192.168.2.17，安装Maxscale，不启用mysqld服务；
• client配置：ip地址192.168.2.5，启动mysqld，验证连接maxscale服务；

提示：提前关闭防火墙和SELinux；

步骤1：环境准备

① 准备YUM源（参考/linux-soft/4/mysql/maxscale-2.1.2-1.rhel.7.x86_64.rpm）

[root@localhost ~]# cp maxscale-2.1.2-1.rhel.7.x86_64.rpm /var/www/html/mysql/
[root@localhost ~]# cd /var/www/html/mysql/
[root@localhost mysql]# createrepo -v .

② 检查node17是否安装mysqld服务。如果已安装则停止服务；

[root@node17 ~]# systemctl stop mysqld
[root@node17 ~]# systemctl disable mysqld

③ 安装Maxscale

[root@node17 ~]# yum clean all
[root@node17 ~]# yum -y install maxscale.x86_64
[root@node17 ~]# id maxscale
uid=997(maxscale) gid=995(maxscale) 组=995(maxscale)

步骤2：Maxscale服务器配置

① 修改配置文件（建议修改前备份）

[root@node17 ~]# vim /etc/maxscale.cnf
# MaxScale documentation on GitHub:
# https://github.com/mariadb-corporation/MaxScale/blob/2.1/Documentation/Documentation-Contents.md
 
# Global parameters      //【全局配置】
#
# Complete list of configuration options:
# https://github.com/mariadb-corporation/MaxScale/blob/2.1/Documentation/Getting-Started/Configuration-Guide.md
 
[maxscale]
threads=auto    //线程数默认为1，需设置为auto，CPU有几个核心就产生几个线程（lscpu）
 
# Server definitions    //【服务器定义】
#
# Set the address of the server to the network
# address of a MySQL server.
#
 
[server1]      //定义要连接的后端mysql服务器(server1)
type=server
address=192.168.2.10
port=3306
protocol=MySQLBackend     //Mysql后端协议
 
[server2]      //定义要连接的后端mysql服务器(server2)
type=server
address=192.168.2.11
port=3306
protocol=MySQLBackend
 
# Monitor for the servers   //【定义监控服务器】
#
# This will keep MaxScale aware of the state of the servers.
# MySQL Monitor documentation:
# https://github.com/mariadb-corporation/MaxScale/blob/2.1/Documentation/Monitors/MySQL-Monitor.md
 
[MySQL Monitor]             //定义要监视的数据库节点
type=monitor                //类型为monitor
module=mysqlmon             //自带的监控模块
servers=server1,server2     //添加定义的服务器
user=maxscalemon            //定义监控用户
passwd=NSD2021@tedu.cn      //用户密码
monitor_interval=10000      //监控间隔默认10秒（单位为ms）
 
# Service definitions   //【服务定义】
#
# Service Definition for a read-only service and
# a read/write splitting service.
#
 
# ReadConnRoute documentation:
# https://github.com/mariadb-corporation/MaxScale/blob/2.1/Documentation/Routers/ReadConnRoute.md
 
# [Read-Only Service]       //注释只读连接路由服务
# type=service
# router=readconnroute
# servers=server1
# user=myuser
# passwd=mypwd
# router_options=slave
 
# ReadWriteSplit documentation:
# https://github.com/mariadb-corporation/MaxScale/blob/2.1/Documentation/Routers/ReadWriteSplit.md
 
[Read-Write Service]        //定义读写分离的数据库节点
type=service                //类型为service
router=readwritesplit       //读写分离路由
servers=server1,server2     //添加定义的服务器
user=maxscalerouter         //定义路由用户
passwd=NSD2021@tedu.cn      //用户密码
max_slave_connections=100%
 
# This service enables the use of the MaxAdmin interface   //【管理服务接口】
# MaxScale administration guide:
# https://github.com/mariadb-corporation/MaxScale/blob/2.1/Documentation/Reference/MaxAdmin.md
 
[MaxAdmin Service]
type=service      //类型为service
router=cli        //管理使用命令行接口界面
 
# Listener definitions for the services    //【监听服务端口及协议定义】
#
# These listeners represent the ports the
# services will listen on.
#
 
# [Read-Only Listener]      //注释只读监听信息
# type=listener
# service=Read-Only Service
# protocol=MySQLClient
# port=4008
 
[Read-Write Listener]         //定义读写分离服务配置
type=listener                 //类型为listener
service=Read-Write Service    //读写分离服务
protocol=MySQLClient          //协议
port=4006         //读写分离服务访问端口（默认）
 
[MaxAdmin Listener]           //定义管理服务配置
type=listener                //类型为listener
service=MaxAdmin Service      //管理服务
protocol=maxscaled           //协议 
socket=default
port=4016         //添加管理服务访问端口

步骤3：在主服务器上创建maxscale需要的监控、读写用户（node10操作）

① 创建监控用户（授予权限：replication slave、replication client，所有库所有表）

[root@node10 ~]# mysql -uroot -pNSD2021@tedu.cn
mysql> grant replication slave,replication client on *.* to maxscalemon@'%' identified by 'NSD2021@tedu.cn';
Query OK, 0 rows affected, 1 warning (0.01 sec)

② 创建路由用户（授予权限：select，Mysql库的所有表）

mysql> grant select on mysql.* to maxscalerouter@'%' identified by 'NSD2021@tedu.cn';
Query OK, 0 rows affected, 1 warning (0.00 sec)

补充：通过该授权用户maxscalerouter去select查看授权库mysql.{mysql,db等}，查看访问数据库的用户是否有权限操作数据库；

③ 从服务器上查看用户是否已同步（node11操作）

mysql> select user,host from mysql.user where user like 'maxscale%';
+----------------+------+
| user           | host |
+----------------+------+
| maxscalemon    | %    |
| maxscalerouter | %    |
+----------------+------+
2 rows in set (0.00 sec)

步骤4：启动maxscale服务

[root@node17 ~]# systemctl start maxscale.service

补充：如果服务无法启动，可查看/var/log/maxscale/maxscale.log日志

步骤5：验证登录Maxscale服务管理，并查看监控信息

maxadmin默认用户为admin，密码是mariadb；（端口：4016）

[root@node17 ~]# maxadmin -uadmin -pmariadb -P4016   //管理服务端口4016

① 查看后端主从同步服务器的连接状态信息

MaxScale> list servers
Servers.
-------------------+-----------------+-------+-------------+--------------------
Server             | Address         | Port  | Connections | Status
-------------------+-----------------+-------+-------------+--------------------
server1            | 192.168.2.10    |  3306 |           0 | Master, Running
server2            | 192.168.2.11    |  3306 |           0 | Slave, Running
-------------------+-----------------+-------+-------------+--------------------

② 查看服务状态信息

MaxScale> list services
Services.
--------------------------+-------------------+--------+----------------+-------------------
Service Name              | Router Module     | #Users | Total Sessions | Backend databases
--------------------------+-------------------+--------+----------------+-------------------
Read-Write Service        | readwritesplit    |      1 |              1 | server1, server2
MaxAdmin Service          | cli               |      3 |              3 |
--------------------------+-------------------+--------+----------------+-------------------

③ 查看所有服务的监听状态信息

MaxScale> list listeners
Listeners.
---------------------+---------------------+--------------------+-----------------+-------+--------
Name                 | Service Name        | Protocol Module    | Address         | Port  | State
---------------------+---------------------+--------------------+-----------------+-------+--------
Read-Write Listener  | Read-Write Service  | MySQLClient        | *               |  4006 | Running
MaxAdmin Listener    | MaxAdmin Service    | maxscaled          | *               |  4016 | Running
MaxAdmin Listener    | MaxAdmin Service    | maxscaled          | default         |     0 | Running
---------------------+---------------------+--------------------+-----------------+-------+--------

步骤6：验证读写分离测试

在mysql主服务器上创建用于连接数据库的用户

mysql> grant all on nsd2021.* to tom@'%' identified by 'NSD2021@tedu.cn';
Query OK, 0 rows affected, 1 warning (0.00 sec)

使用客户端192.168.2.5访问Maxscale服务器对主从数据库进行读写操作测试（端口4006）

[root@localhost ~]# mysql -utom -pNSD2021@tedu.cn -h192.168.2.17 -P4006

① 查询测试

mysql> select @@hostname;    //查询主机名
+------------+
| @@hostname |
+------------+
| node11     |
+------------+
1 row in set (0.00 sec)

解释：查询语句只转发到从服务器，所以得到的是从服务器主机名；

② 写入测试

mysql> insert into nsd2021.departments(dept_name) values('test');
Query OK, 1 row affected (0.09 sec)

解释：写入语句是转发到主服务器，数据会自动同步到从服务器，在从服务器上可查到新增内容；

登录从服务器node11查看是否同步内容（node11操作）

mysql> select * from nsd2021.departments where dept_name='test';
+---------+-----------+
| dept_id | dept_name |
+---------+-----------+
|      11 | test      |
+---------+-----------+
1 row in set (0.00 sec)

三、多实例配置

在数据库管理和部署中，多实例配置（Multi-Instance Configuration）是指在同一台物理服务器或虚拟机上运行多个独立的数据库实例。每个实例都有自己的配置文件、数据目录、进程和端口，彼此之间相互隔离。多实例配置可以提高资源利用率，实现资源共享，同时满足不同应用的需求。

许多数据库系统（如 MySQL、PostgreSQL、MariaDB）都提供了多实例功能，允许在同一台服务器上运行多个独立的数据库实例。

多实例配置的优势：

资源共享：

• 多个实例可以共享同一台服务器的硬件资源（如CPU、内存、磁盘），提高资源利用率。
  隔离性：

• 每个实例独立运行，互不干扰，可以避免不同应用之间的资源争用和冲突。
  灵活性：

• 可以根据不同应用的需求，为每个实例配置不同的参数和资源限制，满足多样化的需求。
  高可用性：

• 可以在同一台服务器上运行多个实例，实现负载均衡和高可用性。

注意事项：

• **资源限制：**为每个实例配置合理的资源限制（如内存、CPU），避免资源争用和性能瓶颈
• **端口冲突：**确保每个实例使用不同的端口，避免端口冲突
• **数据隔离：**确保每个实例的数据目录独立，避免数据混淆和冲突
• **安全性：**为每个实例配置独立的安全策略（如用户权限、防火墙规则），确保数据安全

1、多实例配置的实现方式

1）在 MySQL 中，可以通过以下步骤配置多实例：

① 创建数据目录：为每个实例创建独立的数据目录，例如：

mkdir -p /var/lib/mysql1
mkdir -p /var/lib/mysql2

② 创建配置文件：为每个实例创建独立的配置文件，例如：

cp /etc/my.cnf /etc/my1.cnf
cp /etc/my.cnf /etc/my2.cnf

修改每个配置文件中的 datadir、socket、port 等参数，确保它们不冲突。

③ 初始化数据库 ：使用 mysqld --initialize 命令初始化每个实例的数据目录，例如：

mysqld --initialize --user=mysql --datadir=/var/lib/mysql1
mysqld --initialize --user=mysql --datadir=/var/lib/mysql2

④ 启动实例 ：使用 mysqld_multi 或手动启动每个实例，例如：

mysqld_multi start 1
mysqld_multi start 2

2）在 PostgreSQL 中，可以通过以下步骤配置多实例：

① 创建数据目录：为每个实例创建独立的数据目录，例如：

mkdir -p /var/lib/pgsql/9.6/data1
mkdir -p /var/lib/pgsql/9.6/data2

② 初始化数据库 ：使用 initdb 命令初始化每个实例的数据目录，例如：

initdb -D /var/lib/pgsql/9.6/data1
initdb -D /var/lib/pgsql/9.6/data2

③ 创建启动脚本：为每个实例创建独立的启动脚本，例如：

cp /etc/init.d/postgresql /etc/init.d/postgresql1
cp /etc/init.d/postgresql /etc/init.d/postgresql2

修改每个启动脚本中的 PGDATA、PGPORT 等参数，确保它们不冲突。

④ 启动实例：使用启动脚本启动每个实例，例如：

service postgresql1 start
service postgresql2 start

---

多实例部署示例：

步骤1：环境准备

① 配置192.168.2.10为多实例数据库服务器，如已安装MySQL，则停止服务或将其卸载

[root@node10 ~]# yum list installed | grep mysql   //列出已安装的软件包
mysql-community-client.x86_64           5.7.17-1.el7                   @mysql
mysql-community-server.x86_64           5.7.17-1.el7                   @mysql
...
[root@node10 ~]# yum -y remove mysql-community-server.x86_64   //卸载MySQL服务

② 检查是否有/etc/my.cnf文件，若卸载成功则该文件不存在，如果有此文件则移走它

[root@node10 ~]# ls /etc/my.cnf
ls: 无法访问/etc/my.cnf: 没有那个文件或目录

③ 拷贝软件包（mysql-5.7.20-linux-glibc2.12-x86_64.tar.gz）

[root@localhost ~]# scp mysql-5.7.20-linux-glibc2.12-x86_64.tar.gz root@192.168.2.10:/root

④ 解压多实例Mysql软件包

[root@node10 ~]# tar -xf mysql-5.7.20-linux-glibc2.12-x86_64.tar.gz
[root@node10 ~]# mv mysql-5.7.20-linux-glibc2.12-x86_64 /usr/local/mysql
[root@node10 ~]# ls /usr/local/mysql/

步骤2：编写配置文件

[root@node10 ~]# vim /etc/my.cnf
[mysqld_multi]      //多实例基本配置（运行服务命令）
mysqld = /usr/local/mysql/bin/mysqld_safe        //启动服务程序路径
mysqladmin = /usr/local/mysql/bin/mysqladmin    //服务修改密码命令
user = root         //服务用户为root
 
[mysqld1]   //多实例1
datadir = /mysqlmul/mysqld1      //指定数据库工作目录（需要手动创建）
port = 3306      //端口号为3306
log-error = /mysqlmul/mysqld1/mysqld1.err     //指定错误日志（启动服务自动生成）
pid-file = /mysqlmul/mysqld1/mysqld1.pid      //指定进程文件
socket = /mysqlmul/mysqld1/mysqld1.sock       //指定套接字文件
 
[mysqld2]   //多实例2
datadir = /mysqlmul/mysqld2      //指定数据库工作目录
port = 3307     //端口号为3307（注意：端口不能冲突）
log-error = /mysqlmul/mysqld2/mysqld2.err     //指定错误日志（启动服务自动生成）
pid-file = /mysqlmul/mysqld2/mysqld2.pid      //指定进程文件
socket = /mysqlmul/mysqld2/mysqld2.sock       //指定套接字文件

步骤3：创建数据库工作目录

[root@node10 ~]# mkdir -p /mysqlmul/mysqld{1,2}    //【-p】父目录一同创建
[root@node10 ~]# ls /mysqlmul/
mysqld1  mysqld2      //子目录不创建，运行服务也可生成

步骤4：加入MySQL命令路径到PATH变量

① 方法1：临时增加环境变量

[root@node10 ~]# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/bin
[root@node10 ~]# export PATH=$PATH:/usr/local/mysql/bin
[root@node10 ~]# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/bin:/usr/local/mysql/bin

② 方法2：永久修改PATH环境变量

[root@node10 ~]# vim .bash_profile
PATH=$PATH:$HOME/bin:/usr/local/mysql/bin   //PATH路径
export PATH
[root@node10 ~]# source .bash_profile
[root@node10 ~]# echo $PATH    //查看环境变量
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/bin:/usr/local/mysql/bin

补充：若未有加入$PATH环境变量，则需要绝对路径：/usr/local/mysql/bin/mysqld_multi

步骤5：启动MySQL服务

① 启动第一个实例（mysqld1）

[root@node10 ~]# mysqld_multi start 1
2021-06-13T14:39:57.915320Z 1 [Note] A temporary password is generated for root@localhost: 8#a=+C20ja=i   //启动完成，会生成临时密码

[root@node10 ~]# ss -nlptu | grep :3306    //查看服务
tcp    LISTEN     0      80       :::3306                 :::*                   users:(("mysqld",pid=2252,fd=16))
[root@node10 ~]# ls /mysqlmul/mysqld1/

② 通过本机socket连接数据库并修改密码（/mysqlmul/mysqld1/mysqld1.sock）

[root@node10 ~]# mysqladmin -uroot -p'8#a=+C20ja=i' password '123456' -S /mysqlmul/mysqld1/mysqld1.sock

补充：Socket套接字文件需要启动服务后才能生成

测试本地Socket连接访问数据库

[root@node10 ~]# mysql -uroot -p123456 -S /mysqlmul/mysqld1/mysqld1.sock
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

③ 启动第二个实例（mysqld2）

[root@node10 ~]# mysqld_multi start 2
2021-06-13T15:20:35.200117Z 1 [Note] A temporary password is generated for root@localhost: jf8wBz5c(o4-

[root@node10 ~]# ss -nlptu | grep :3307    //查看服务
tcp    LISTEN     0      80       :::3307                 :::*                   users:(("mysqld",pid=2573,fd=16))
[root@node10 ~]# ls /mysqlmul/mysqld2/

④ 通过本机socket连接数据库并修改密码

[root@node10 ~]# mysql -uroot -p'jf8wBz5c(o4-' -S /mysqlmul/mysqld2/mysqld2.sock
mysql> alter user root@'localhost' identified by '123456';
Query OK, 0 rows affected (0.00 sec)

⑤ 测试通过网络连接数据库

[root@node10 ~]# mysql -uroot -p123456 -h127.0.0.1 -P3307
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

步骤6：停止服务

[root@node10 ~]# mysqld_multi --user root --password 123456 stop 1
[root@node10 ~]# ss -nlptu | grep :3306

补充：什么是读写分离？为什么要实现读写分离？

答：读写分离，基本的原理是让主数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。数据库的写操作是非常耗时的，写10000条数据可能需要几分钟，而读取10000条数据只要几秒钟。所以读写分离，解决的是数据库写入影响到了查询的速率。这样，主服务器处理增删改请求，从服务器处理读请求，可以极大地提高性能。

---

扩展知识：中间件

中间件（Middleware）是一种位于操作系统和应用程序之间的软件层，用于协调和管理不同应用程序之间的通信和数据交换。中间件提供了一系列服务和功能，简化了应用程序的开发和部署，提高了系统的可扩展性、可靠性和安全性。

1、中间件的主要功能：

1）通信管理

中间件提供了通信管理功能，包括消息传递、远程过程调用（RPC）、分布式对象请求代理（CORBA）等，使得不同应用程序之间可以方便地进行通信和数据交换。

2）数据管理

中间件提供了数据管理功能，包括数据缓存、数据复制、数据同步、数据分片等，确保数据的一致性和可靠性。

3）事务管理

中间件提供了事务管理功能，确保分布式事务的原子性、一致性、隔离性和持久性（ACID），避免数据不一致和事务失败。

4）安全性

中间件提供了安全性功能，包括身份验证、授权、加密、审计等，确保系统的安全性和数据的保密性。

5）负载均衡

中间件提供了负载均衡功能，将客户端的请求分发到多个服务器上，均衡负载，提高系统的性能和可扩展性。

6）高可用性

中间件提供了高可用性功能，包括故障检测、故障转移、容错机制等，确保系统的高可用性和可靠性。

7）监控和管理

中间件提供了监控和管理功能，包括性能监控、日志管理、配置管理等，帮助管理员监控和管理系统的运行状态。

可理解为是一类能够为一种或多种应用程序合作互通、资源共享，同时还能够为该应用程序提供相关的服务的软件。中间件是一类软件统称，而非一种软件，中间件不仅仅实现互连，还要实现应用之间的互操作。

2、中间件的类型：

消息中间件（Message-Oriented Middleware, MOM）

消息中间件用于在不同应用程序之间传递消息，支持异步通信和消息队列。常见的消息中间件包括：

• RabbitMQ：一个开源的消息代理，支持多种消息协议。
• Apache Kafka：一个分布式流处理平台，用于高吞吐量的消息传递。
• ActiveMQ：一个开源的消息代理，支持多种消息协议。

数据库中间件（Database Middleware）

数据库中间件用于管理和优化数据库访问，提供连接池、负载均衡、读写分离、数据分片等功能。常见的数据库中间件包括：

• MaxScale：MariaDB 公司开发的数据库中间件，支持 MySQL 和 MariaDB。
• ProxySQL：一个高性能的数据库代理，支持 MySQL 和 PostgreSQL。
• pgpool-II：一个 PostgreSQL 数据库中间件，提供连接池、负载均衡、复制等功能。

应用服务器中间件（Application Server Middleware）

应用服务器中间件用于管理和部署企业级应用程序，提供事务管理、安全性、负载均衡等功能。常见的应用服务器中间件包括：

• Apache Tomcat：一个开源的 Java Servlet 容器，用于部署 Java Web 应用程序。
• JBoss/WildFly：一个开源的应用服务器，支持 Java EE 标准。
• WebLogic：Oracle 公司开发的应用服务器，支持 Java EE 标准。

事务处理中间件（Transaction Processing Middleware）

事务处理中间件用于管理和协调分布式事务，确保事务的原子性、一致性、隔离性和持久性。常见的事务处理中间件包括：

• Tuxedo：Oracle 公司开发的事务处理中间件，支持 C/C++ 和 Java 应用程序。
• WebSphere：IBM 公司开发的应用服务器，支持事务处理和 Java EE 标准。

对象请求代理中间件（Object Request Broker, ORB）

对象请求代理中间件用于在分布式系统中调用远程对象的方法，支持分布式对象请求代理（CORBA）标准。常见的对象请求代理中间件包括：

• CORBA：一个分布式对象计算的标准，支持多种编程语言和平台。
• DCOM：微软公司开发的分布式对象计算技术，支持 Windows 平台。

Web 服务中间件（Web Services Middleware）

Web 服务中间件用于管理和调用 Web 服务，支持 SOAP、REST 等 Web 服务标准。常见的 Web 服务中间件包括：

• Apache Axis：一个开源的 Web 服务框架，支持 SOAP 和 WSDL。
• Apache CXF：一个开源的 Web 服务框架，支持 SOAP、REST 和 WSDL。
• Spring Web Services：一个开源的 Web 服务框架，支持 SOAP 和 REST。

思维导图：

小结：

本篇章节为**【第四阶段】RDBMS2-DAY2 的学习笔记**，这篇笔记可以初步了解到 数据读写分离概述、Maxscale实现数据读写分离、多实例配置、中间件概述，除此之外推荐参考相关学习网址：

• 参考：https://blog.csdn.net/weixin_40210977/article/details/109729464

---

Tip：毕竟两个人的智慧大于一个人的智慧，如果你不理解本章节的内容或需要相关笔记、视频，可私信小安，请不要害羞和回避，可以向他人请教，花点时间直到你真正的理解。