重要参考步骤---ProxySQL实现读写分离
MySQL配置主从同步文章地址：https://www.cnblogs.com/sanduzxcvbnm/p/16295369.html
ProxySQL实现读写分离与读负载均衡参考文档：https://www.cnblogs.com/gered/p/12856263.html
ROXYSQL 是多线程的在操作的 ，粗略的大致架构图
架构
| IP | server-id | 数据库版本 | 备注 |
|---|---|---|---|
| 192.168.20.200 | 200 | MySQL 8.0.29 | Master（主库） |
| 192.168.20.201 | 201 | MySQL 8.0.18 | Slave(从库) |
| 192.168.20.202 | 2.4.1 | ProxySQL |
下载并安装
# wget https://github.com/sysown/proxysql/releases/download/v2.4.1/proxysql-2.4.1-1-centos7.x86_64.rpm
# rpm -ivh proxysql-2.4.1-1-centos7.x86_64.rpm
警告：proxysql-2.4.1-1-centos7.x86_64.rpm: 头V4 RSA/SHA512 Signature, 密钥 ID 8217c97e: NOKEY
错误：依赖检测失败：
gnutls 被 proxysql-2.4.1-1.x86_64 需要
libgnutls.so.28()(64bit) 被 proxysql-2.4.1-1.x86_64 需要
libgnutls.so.28(GNUTLS_1_4)(64bit) 被 proxysql-2.4.1-1.x86_64 需要
libgnutls.so.28(GNUTLS_3_0_0)(64bit) 被 proxysql-2.4.1-1.x86_64 需要
libgnutls.so.28(GNUTLS_3_1_0)(64bit) 被 proxysql-2.4.1-1.x86_64 需要
perl(DBD::mysql) 被 proxysql-2.4.1-1.x86_64 需要
perl(DBI) 被 proxysql-2.4.1-1.x86_64 需要
rpm包安装会报一堆依赖包错误，具体的依赖关系看下面这个：
依赖关系解决
==================================================================================================================
Package 架构 版本 源 大小
==================================================================================================================
正在安装:
proxysql x86_64 2.4.1-1 proxysql_repo 15 M
为依赖而安装:
gnutls x86_64 3.3.29-9.el7_6 base 680 k
nettle x86_64 2.7.1-9.el7_9 updates 328 k
perl-Compress-Raw-Bzip2 x86_64 2.061-3.el7 base 32 k
perl-Compress-Raw-Zlib x86_64 1:2.061-4.el7 base 57 k
perl-DBD-MySQL x86_64 4.023-6.el7 base 140 k
perl-DBI x86_64 1.627-4.el7 base 802 k
perl-Data-Dumper x86_64 2.145-3.el7 base 47 k
perl-IO-Compress noarch 2.061-2.el7 base 260 k
perl-Net-Daemon noarch 0.48-5.el7 base 51 k
perl-PlRPC noarch 0.2020-14.el7 base 36 k
trousers x86_64 0.3.14-2.el7 base 289 k
建议采用yum方式安装，解决依赖包问题
yum方式安装
# cat <<EOF | tee /etc/yum.repos.d/proxysql.repo
[proxysql_repo]
name= ProxySQL YUM repository
baseurl=https://repo.proxysql.com/ProxySQL/proxysql-2.4.x/centos/\$releasever
gpgcheck=0
gpgkey=https://repo.proxysql.com/ProxySQL/repo_pub_key
EOF
# yum -y install proxysql
查看相应安装文件路径，有哪些文件
# rpm -ql proxysql
/etc/logrotate.d/proxysql
/etc/proxysql.cnf
/etc/systemd/system/proxysql.service
/usr/bin/proxysql
/usr/share/proxysql/tools/proxysql_galera_checker.sh
/usr/share/proxysql/tools/proxysql_galera_writer.pl
/etc/proxysql.cnf 是 ProxySQL 的配置文件
ProxySQL常用命令
systemctl start proxysql.service
systemctl stop proxysql.service
systemctl enable proxysql.service
# 查看是否启动
# netstat -anlp | grep proxysql
tcp 0 0 0.0.0.0:6032 0.0.0.0:* LISTEN 2989/proxysql
tcp 0 0 0.0.0.0:6033 0.0.0.0:* LISTEN 2989/proxysql
6032 是 ProxySQL 的管理端口号，6033是对外服务的端口号
查看 ProxySQL 的版本: proxysql --version
管理员登录 ProxySQL
需要安装 MYSQL 客户端，不需要安装 MYSQL 服务器程序，不安装 MYSQL 客户端则不能在 SHELL 下进行 PROXYSQL 配置
wget https://repo.mysql.com//mysql80-community-release-el7-5.noarch.rpm
yum localinstall -y mysql80-community-release-el7-5.noarch.rpm
yum -y install mysql-community-client # 8.0.29版本
配置PROXYSQL 中有两种方法，1 通过管理接口进行管理， 2 用过配置文件进行配置 ，这里建议使用管理端口进行配置，因为使用配置文件只能进行基础配置，并且PROXYSQL 本身携带SQLLITE 数据库，配置文件在初次配置后就被抛弃，所有的配置数据会写入到 SQLLITE 数据库。虽然使用的是MYSQL 的客户端，部分命令是可以使用来控制 SQLLITE ，但是在上层打包，下层还是使用 SQLLITE的部分命令，所以有些MYSQL命令在键入后并不能执行.
ProxySQL 的用户名和密码都是默认的 admin
# /usr/bin/mysql -uadmin -padmin -h 127.0.0.1 -P 6032
mysql> show databases;
+-----+---------------+-------------------------------------+
| seq | name | file |
+-----+---------------+-------------------------------------+
| 0 | main | |
| 2 | disk | /var/lib/proxysql/proxysql.db |
| 3 | stats | |
| 4 | monitor | |
| 5 | stats_history | /var/lib/proxysql/proxysql_stats.db |
+-----+---------------+-------------------------------------+
5 rows in set (0.00 sec)
可见有五个库： main、disk、stats 、monitor 和 stats_history
main: 内存配置数据库，即 MEMORY，表里存放后端 db 实例、用户验证、路由规则等信息。main 库中有如下信息：
mysql> use main;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
mysql> show tables;
+----------------------------------------------------+
| tables |
+----------------------------------------------------+
| global_variables |
| mysql_aws_aurora_hostgroups |
| mysql_collations |
| mysql_firewall_whitelist_rules |
| mysql_firewall_whitelist_sqli_fingerprints |
| mysql_firewall_whitelist_users |
| mysql_galera_hostgroups |
| mysql_group_replication_hostgroups |
| mysql_query_rules |
| mysql_query_rules_fast_routing |
| mysql_replication_hostgroups |
| mysql_servers |
| mysql_users |
| proxysql_servers |
| restapi_routes |
| runtime_checksums_values |
| runtime_global_variables |
| runtime_mysql_aws_aurora_hostgroups |
| runtime_mysql_firewall_whitelist_rules |
| runtime_mysql_firewall_whitelist_sqli_fingerprints |
| runtime_mysql_firewall_whitelist_users |
| runtime_mysql_galera_hostgroups |
| runtime_mysql_group_replication_hostgroups |
| runtime_mysql_query_rules |
| runtime_mysql_query_rules_fast_routing |
| runtime_mysql_replication_hostgroups |
| runtime_mysql_servers |
| runtime_mysql_users |
| runtime_proxysql_servers |
| runtime_restapi_routes |
| runtime_scheduler |
| scheduler |
+----------------------------------------------------+
32 rows in set (0.00 sec)
库下的主要表：
mysql_servers: 后端可以连接 MySQL 服务器的列表
mysql_users: 配置后端数据库的账号和监控的账号。
mysql_query_rules: 指定 Query 路由到后端不同服务器的规则列表。
注： 表名以 runtime_开头的表示 ProxySQL 当前运行的配置内容，不能通过 DML 语句修改。
只能修改对应的不以 runtime 开头的表，然后 “LOAD” 使其生效，“SAVE” 使其存到硬盘以供下次重启加载。
disk ：持久化的磁盘的配置
stats： 统计信息的汇总
monitor：一些监控的收集信息，比如数据库的健康状态等
stats_history: 这个库是 ProxySQL 收集的有关其内部功能的历史指标
配置 ProxySQL 所需账户
这里为了演示方便，用户密码都是一样的
在 master (192.168.20.200) 的 MySQL 上创建 ProxySQL 的监控账户和对外访问账户, 8.0.x 用户认证的方式需要修改为 mysql_native_password
# 若是主从库中自带的mysql库没有同步，则主从库的账号表不会进行同步，如下的账号操作还需要在从库里操作一遍
#proxysql 的监控账户
mysql> create user 'monitor'@'192.168.20.%' identified with mysql_native_password by 'vxRDX$v%XXuz^1v!m';
mysql> grant all privileges on *.* to 'monitor'@'192.168.20.%' with grant option;
#proxysql 的对外访问账户
mysql> create user 'proxysql'@'192.168.20.%' identified with mysql_native_password by 'vxRDX$v%XXuz^1v!m';
mysql> grant all privileges on *.* to 'proxysql'@'192.168.20.%' with grant option;
mysql> flush privileges;
或者先在配置文件中添加如下内容，并重启MySQL,然后在创建有关用户
# cat /etc/my.cnf
[mysqld]
default_authentication_plugin=mysql_native_password
#proxysql 的监控账户
mysql> create user 'monitor'@'192.168.20.%' identified by 'vxRDX$v%XXuz^1v!m'; # 此时不用再加 with mysql_native_password
mysql> grant all privileges on *.* to 'monitor'@'192.168.20.%' with grant option;
#proxysql 的对外访问账户
mysql> create user 'proxysql'@'192.168.20.%' identified by 'vxRDX$v%XXuz^1v!m';
mysql> grant all privileges on *.* to 'proxysql'@'192.168.20.%' with grant option;
mysql> flush privileges;
ProxySQL 的多层配置系统
配置结构如下：
https://github.com/sysown/proxysql/wiki/Configuring-ProxySQL
整套配置系统分为三层：顶层为 RUNTIME ,中间层为 MEMORY , 底层也就是持久层 DISK 和 CONFIG FILE 。
RUNTIME ： 代表 ProxySQL 当前生效的正在使用的配置，无法直接修改这里的配置，必须要从下一层 “load” 进来。
MEMORY： MEMORY 层上面连接 RUNTIME 层，下面连接持久层。这层可以正常操作 ProxySQL 配置，随便修改，不会影响生产环境。修改一个配置一般都是现在 MEMORY 层完成的，确认正常之后在加载达到 RUNTIME 和 持久化的磁盘上。
DISK 和 CONFIG FILE：持久化配置信息，重启后内存中的配置信息会丢失，所需要将配置信息保留在磁盘中。重启时，可以从磁盘快速加载回来。
在不同层次间移动配置
为了将配置持久化到磁盘或者应用到 runtime，在管理接口下有一系列管理命令来实现它们。
1.要重新配置 MySQL 用户，可执行下面的其中一个命令：
1、LOAD MYSQL USERS FROM MEMORY / LOAD MYSQL USERS TO RUNTIME
将内存数据库中的配置加载到 runtime 数据结构，反之亦然。
2、SAVE MYSQL USERS TO MEMORY / SAVE MYSQL USERS FROM RUNTIME
将 MySQL 用户从 runtime 持久化到内存数据库。
3、LOAD MYSQL USERS TO MEMORY / LOAD MYSQL USERS FROM DISK
从磁盘数据库中加载 MySQL 用户到内存数据库中。
4、SAVE MYSQL USERS FROM MEMORY / SAVE MYSQL USERS TO DISK
将内存数据库中的 MySQL 用户持久化到磁盘数据库中。
5、LOAD MYSQL USERS FROM CONFIG
从配置文件中加载 MySQL 用户到内存数据库中。
2.要处理 MySQL server：
1、LOAD MYSQL SERVERS FROM MEMORY / LOAD MYSQL SERVERS TO RUNTIME
将 MySQL server 从内存数据库中加载到 runtime。
2、SAVE MYSQL SERVERS TO MEMORY / SAVE MYSQL SERVERS FROM RUNTIME
将 MySQL server 从 runtime 持久化到内存数据库中。
3、LOAD MYSQL SERVERS TO MEMORY / LOAD MYSQL SERVERS FROM DISK
从磁盘数据库中加载 MySQL server 到内存数据库。
4、SAVE MYSQL SERVERS FROM MEMORY / SAVE MYSQL SERVERS TO DISK
从内存数据库中将 MySQL server 持久化到磁盘数据库中。
5、LOAD MYSQL SERVERS FROM CONFIG
从配置文件中加载 MySQL server 到内存数据库中
3.要处理 MySQL 的查询规则(mysql query rules)：
1、 LOAD MYSQL QUERY RULES FROM MEMORY / LOAD MYSQL QUERY RULES TO RUNTIME
将 MySQL query rules 从内存数据库加载到 runtime 数据结构。
2、 SAVE MYSQL QUERY RULES TO MEMORY / SAVE MYSQL QUERY RULES FROM RUNTIME
将 MySQL query rules 从 runtime 数据结构中持久化到内存数据库。
3、 LOAD MYSQL QUERY RULES TO MEMORY / LOAD MYSQL QUERY RULES FROM DISK
从磁盘数据库中加载 MySQL query rules 到内存数据库中。
4、 SAVE MYSQL QUERY RULES FROM MEMORY / SAVE MYSQL QUERY RULES TO DISK
将 MySQL query rules 从内存数据库中持久化到磁盘数据库中。
5、 LOAD MYSQL QUERY RULES FROM CONFIG
从配置文件中加载 MySQL query rules 到内存数据库中。
4.要处理 MySQL 变量(MySQL variables)：
1、 LOAD MYSQL VARIABLES FROM MEMORY / LOAD MYSQL VARIABLES TO RUNTIME
将 MySQL variables 从内存数据库加载到 runtime 数据结构。
2、 SAVE MYSQL VARIABLES TO MEMORY / SAVE MYSQL VARIABLES FROM RUNTIME
将 MySQL variables 从 runtime 数据结构中持久化到内存数据中。
3、 LOAD MYSQL VARIABLES TO MEMORY / LOAD MYSQL VARIABLES FROM DISK
从磁盘数据库中加载 MySQL variables 到内存数据库中。
4、 SAVE MYSQL VARIABLES FROM MEMORY / SAVE MYSQL VARIABLES TO DISK
将 MySQL variables 从内存数据库中持久化到磁盘数据库中。
5、 LOAD MYSQL VARIABLES FROM CONFIG
从配置文件中加载 MySQL variables 到内存数据库中。
5.要处理管理变量(admin variables)：
1、 LOAD ADMIN VARIABLES FROM MEMORY / LOAD ADMIN VARIABLES TO RUNTIME
将 admin variables 从内存数据库加载到 runtime 数据结构。
2、 SAVE ADMIN VARIABLES TO MEMORY / SAVE ADMIN VARIABLES FROM RUNTIME
将 admin variables 从 runtime 持久化到内存数据库中。
3、 LOAD ADMIN VARIABLES TO MEMORY / LOAD ADMIN VARIABLES FROM DISK
从磁盘数据库中加载 admin variables 到内存数据库中。
4、 SAVE ADMIN VARIABLES FROM MEMORY / SAVE ADMIN VARIABLES TO DISK
将 admin variables 从内存数据库中持久化到磁盘数据库。
5、 LOAD ADMIN VARIABLES FROM CONFIG
从配置文件中加载 admin variables 到内存数据库中。
一般在内存那层修改 ,然后保存到运行系统，保存到磁盘数据库系统
load xxx to runtime;
save xxx to disk;
管理配置
- disk and config file 持久化配置文件
disk -> 是sqlite3 数据库 ，默认位置是$DATADIR/proxysql.db( /var/lib/proxysql/proxysql.db)
config file 是一个传统配置文件：一般不更改
- 在内存中动态更改配置，如果重启，没进行持久化(save) 则会丢失。
三则之间关系：
- proxysql 启动时，首先去找/etc/proxysql.cnf 找到它的datadir,如果datadir下有proxysql.db 就加载proxysql.db的配置
- 如果启动proxysql时带有
--init标志，会用/etc/proxsql.cnf的配置，把Runtime，disk全部初始化一下 - 在调用是调用
--reload会把/etc/proxysql.cnf 和disk 中配置进行合并。如果冲突需要用户干预。disk会覆盖config file。
关于传统的配置文件
传统配置文件默认路径为/etc/proxysql.cnf，也可以在二进制程序proxysql上使用-c或–config来手动指定配置文件。
默认情况下：几乎不需要手动去配置proxysql.cnf。端口号，管理proxysql用户密码，可以在这里修改
小结
这里有几个最常用的命令：如何让修改的配置生效(runtime)，以及如何持久化到磁盘上(disk)。记住，只要不是加载到 runtime，修改的配置就不会生效。
LOAD MYSQL USERS TO RUNTIME; 将内存数据库中的配置加载到 runtime 数据结构
SAVE MYSQL USERS TO DISK; 将内存数据库中的 MySQL 用户持久化到磁盘数据库中。
LOAD MYSQL SERVERS TO RUNTIME; 将 MySQL server 从内存数据库中加载到 runtime。
SAVE MYSQL SERVERS TO DISK; 从内存数据库中将 MySQL server 持久化到磁盘数据库中。
LOAD MYSQL QUERY RULES TO RUNTIME; 将 MySQL query rules 从内存数据库加载到 runtime 数据结构。
SAVE MYSQL QUERY RULES TO DISK; 将 MySQL query rules 从内存数据库中持久化到磁盘数据库中。
LOAD MYSQL VARIABLES TO RUNTIME; 将 MySQL variables 从内存数据库加载到 runtime 数据结构。
SAVE MYSQL VARIABLES TO DISK; 将 MySQL variables 从内存数据库中持久化到磁盘数据库中。
LOAD ADMIN VARIABLES TO RUNTIME; 将 admin variables 从内存数据库加载到 runtime 数据结构。
SAVE ADMIN VARIABLES TO DISK; 将 admin variables 从内存数据库中持久化到磁盘数据库。
注意：只有加载到 runtime 状态时才会去做最后的有效性验证。在保存到内存数据库或持久化到磁盘上时，都不会发生任何警告或错误。当加载到 runtime 时，如果出现错误，将恢复为之前保存得状态，这时可以去检查错误日志。
配置 ProxySQL 主从分组信息
用到 这个表 mysql_replication_hostgroup,表结构信息如下:
mysql >show create table mysql_replication_hostgroups\G;
*************************** 1. row ***************************
table: mysql_replication_hostgroups
Create Table: CREATE TABLE mysql_replication_hostgroups (
writer_hostgroup INT CHECK (writer_hostgroup>=0) NOT NULL PRIMARY KEY,
reader_hostgroup INT NOT NULL CHECK (reader_hostgroup<>writer_hostgroup AND reader_hostgroup>=0),
check_type VARCHAR CHECK (LOWER(check_type) IN ('read_only','innodb_read_only','super_read_only','read_only|innodb_read_only','read_only&innodb_read_only')) NOT NULL DEFAULT 'read_only',
comment VARCHAR NOT NULL DEFAULT '', UNIQUE (reader_hostgroup))
1 row in set (0.00 sec)
writer_hostgroup 和reader_hostgroup 写组和读组都要大于0且不能相同，我的环境下，写组定义为10，读组定义为20
check_type 检查类型，默认只检查 read_only，依据这个检查来判断后端MySQL分配到哪个组里，其他选项：'read_only','innodb_read_only','super_read_only','read_only|innodb_read_only','read_only&innodb_read_only'
对于后端是主从复制的环境来说，这是必须的，因为ProxySQL需要通过每个节点的read_only值来自动调整它们是属于读组还是写组。
创建组
insert into mysql_replication_hostgroups ( writer_hostgroup, reader_hostgroup, comment) values (10,20,'proxy');
load mysql servers to runtime;
save mysql servers to disk;
注：上面语句中没有先切换到main库也执行成功了，因为ProxySQL内部使用的SQLite3数据库引擎，和MySQL的解析方式是不一样的。即使执行了USE main语句也是无任何效果的，但不会报错。
确定三种配置系统是否都已经写入了数据
mysql> select * from main.mysql_replication_hostgroups;
+------------------+------------------+------------+---------+
| writer_hostgroup | reader_hostgroup | check_type | comment |
+------------------+------------------+------------+---------+
| 10 | 20 | read_only | proxy |
+------------------+------------------+------------+---------+
1 row in set (0.00 sec)
mysql> select * from main.runtime_mysql_replication_hostgroups;
+------------------+------------------+------------+---------+
| writer_hostgroup | reader_hostgroup | check_type | comment |
+------------------+------------------+------------+---------+
| 10 | 20 | read_only | proxy |
+------------------+------------------+------------+---------+
1 row in set (0.00 sec)
mysql> select * from mysql_replication_hostgroups;
+------------------+------------------+------------+---------+
| writer_hostgroup | reader_hostgroup | check_type | comment |
+------------------+------------------+------------+---------+
| 10 | 20 | read_only | proxy |
+------------------+------------------+------------+---------+
1 row in set (0.00 sec)
ProxySQL 会根据server 的 read _only 的取值将服务器进行分组。 read_only=0 的server，master被分到编号为10的写组，read_only=1 的server，slave则被分到编号20的读组
添加主从服务器节点
用到mysql_servers 这个表
mysql> show create table main.mysql_servers\G
*************************** 1. row ***************************
table: mysql_servers
Create Table: CREATE TABLE mysql_servers (
hostgroup_id INT CHECK (hostgroup_id>=0) NOT NULL DEFAULT 0,
hostname VARCHAR NOT NULL,
port INT CHECK (port >= 0 AND port <= 65535) NOT NULL DEFAULT 3306,
gtid_port INT CHECK ((gtid_port <> port OR gtid_port=0) AND gtid_port >= 0 AND gtid_port <= 65535) NOT NULL DEFAULT 0,
status VARCHAR CHECK (UPPER(status) IN ('ONLINE','SHUNNED','OFFLINE_SOFT', 'OFFLINE_HARD')) NOT NULL DEFAULT 'ONLINE',
weight INT CHECK (weight >= 0 AND weight <=10000000) NOT NULL DEFAULT 1,
compression INT CHECK (compression IN(0,1)) NOT NULL DEFAULT 0,
max_connections INT CHECK (max_connections >=0) NOT NULL DEFAULT 1000,
max_replication_lag INT CHECK (max_replication_lag >= 0 AND max_replication_lag <= 126144000) NOT NULL DEFAULT 0,
use_ssl INT CHECK (use_ssl IN(0,1)) NOT NULL DEFAULT 0,
max_latency_ms INT UNSIGNED CHECK (max_latency_ms>=0) NOT NULL DEFAULT 0,
comment VARCHAR NOT NULL DEFAULT '',
PRIMARY KEY (hostgroup_id, hostname, port) )
1 row in set (0.00 sec)
insert into mysql_servers(hostgroup_id,hostname,port) values (10,'192.168.20.200',3306);
insert into mysql_servers(hostgroup_id,hostname,port) values (20,'192.168.20.201',3306);
注：严格需要写明comment
load mysql servers to runtime;
save mysql servers to disk;
添加了节点，二台机器都是online 状态
mysql> select * from main.mysql_servers;
+--------------+----------------+------+-----------+--------+--------+-------------+-----------------+---------------------+---------+----------------+---------+
| hostgroup_id | hostname | port | gtid_port | status | weight | compression | max_connections | max_replication_lag | use_ssl | max_latency_ms | comment |
+--------------+----------------+------+-----------+--------+--------+-------------+-----------------+---------------------+---------+----------------+---------+
| 20 | 192.168.20.200 | 3306 | 0 | ONLINE | 1 | 0 | 1000 | 0 | 0 | 0 | |
| 20 | 192.168.20.201 | 3306 | 0 | ONLINE | 1 | 0 | 1000 | 0 | 0 | 0 | |
+--------------+----------------+------+-----------+--------+--------+-------------+-----------------+---------------------+---------+----------------+---------+
2 rows in set (0.00 sec)
ProxySQL监控 MySQL 后端节点
为 ProxySQL 配置监控账号
mysql> set mysql-monitor_username='monitor';
Query OK, 1 row affected (0.00 sec)
mysql> set mysql-monitor_password='vxRDX$v%XXuz^1v!m';
Query OK, 1 row affected (0.00 sec)
上面这两句是修改变量的方式还可以在main库下面用sql语句方式修改
UPDATE global_variables SET variable_value='monitor'
WHERE variable_name='mysql-monitor_username';
UPDATE global_variables SET variable_value='vxRDX$v%XXuz^1v!m'
WHERE variable_name='mysql-monitor_password';
修改后，保存到runtime和disk
mysql> load mysql variables to runtime;
Query OK, 0 rows affected (0.01 sec)
mysql> save mysql variables to disk;
Query OK, 139 rows affected (0.00 sec)
mysql> select * from monitor.mysql_server_connect_log;
验证监控信息，ProxySQL 监控模块的指标都保存在monitor库的log表中
以下是连接是否正常的监控，对connect指标的监控 ，在前面可能会有很多connect_error，这是因为没有配置监控信息时的错误，配置后如果connect_error的结果为NULL则表示正常
mysql> select * from monitor.mysql_server_connect_log;
+----------------+------+------------------+-------------------------+-------------------------------------------------------------------------+
| hostname | port | time_start_us | connect_success_time_us | connect_error |
+----------------+------+------------------+-------------------------+-------------------------------------------------------------------------+
| 192.168.20.201 | 3306 | 1653297283529580 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.200 | 3306 | 1653297284622747 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.201 | 3306 | 1653297343530130 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.200 | 3306 | 1653297344357860 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.200 | 3306 | 1653297403530572 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.201 | 3306 | 1653297404303803 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.200 | 3306 | 1653297416099033 | 971 | NULL |
| 192.168.20.201 | 3306 | 1653297416962911 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.201 | 3306 | 1653297476099707 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.200 | 3306 | 1653297476809972 | 8633 | NULL |
| 192.168.20.201 | 3306 | 1653297536101657 | 0 | Access denied for user 'monitor'@'192.168.20.202' (using password: YES) |
| 192.168.20.200 | 3306 | 1653297536935790 | 1120 | NULL |
| 192.168.20.200 | 3306 | 1653297596101600 | 970 | NULL |
| 192.168.20.201 | 3306 | 1653297596820805 | 2608 | NULL |
| 192.168.20.200 | 3306 | 1653297656102679 | 784 | NULL |
| 192.168.20.201 | 3306 | 1653297657298135 | 996 | NULL |
| 192.168.20.200 | 3306 | 1653297716103248 | 1220 | NULL |
| 192.168.20.201 | 3306 | 1653297717271634 | 2917 | NULL |
+----------------+------+------------------+-------------------------+-------------------------------------------------------------------------+
18 rows in set (0.00 sec)
对心跳信息的监控(对ping 指标的监控)
mysql> select * from mysql_server_ping_log;
看read_only的日志监控
mysql> select * from mysql_server_read_only_log;
Monitor 模块就会开始监控后端的read_only值，当监控到read_only值，就会按照read_only的值将某些节点自动移到读写组
一些监控的状态日志都与log相关，都在monitor库下面的 global_variables 变量。
为 ProxySQL 配置对外访问账号
SQL 请求所使用的用户配置，都需要在 MySQL 节点创建上。
配置ProxySQL 账户，我创建的对外访问账户是：用户：proxysql，密码：vxRDX$v%XXuz^1v!m
配置mysql_users 这个表,表结构信息如下：
mysql> show create table mysql_users\G;
*************************** 1. row ***************************
table: mysql_users
Create Table: CREATE TABLE mysql_users (
username VARCHAR NOT NULL,
password VARCHAR,
active INT CHECK (active IN (0,1)) NOT NULL DEFAULT 1,
use_ssl INT CHECK (use_ssl IN (0,1)) NOT NULL DEFAULT 0,
default_hostgroup INT NOT NULL DEFAULT 0,
default_schema VARCHAR,
schema_locked INT CHECK (schema_locked IN (0,1)) NOT NULL DEFAULT 0,
transaction_persistent INT CHECK (transaction_persistent IN (0,1)) NOT NULL DEFAULT 1,
fast_forward INT CHECK (fast_forward IN (0,1)) NOT NULL DEFAULT 0,
backend INT CHECK (backend IN (0,1)) NOT NULL DEFAULT 1,
frontend INT CHECK (frontend IN (0,1)) NOT NULL DEFAULT 1,
max_connections INT CHECK (max_connections >=0) NOT NULL DEFAULT 10000,
comment VARCHAR NOT NULL DEFAULT '',
PRIMARY KEY (username, backend),
UNIQUE (username, frontend))
1 row in set (0.00 sec)
配置mysql_users 表，将proxysql用户添加到该表中。
insert into mysql_users (username,password,default_hostgroup) values ('proxysql','vxRDX$v%XXuz^1v!m',10);
load mysql users to runtime;
save mysql users to disk;
mysql> select * from mysql_users\G
*************************** 1. row ***************************
username: proxysql
password: vxRDX$v%XXuz^1v!m
active: 1 #是否启用该账户，为0表示禁用
use_ssl: 0
default_hostgroup: 10
default_schema: NULL
schema_locked: 0
transaction_persistent: 1 #事务透明化
fast_forward: 0
backend: 1
frontend: 1
max_connections: 10000 #用户链接10000，可以修改
comment:
1 row in set (0.00 sec)
mysql_users 表有不少字段，最主要的三个字段username,password,default_hostgroup
username: 前端链接ProxySQL ，以及ProxySQL 将SQL 语句路由给MySQL所使用的的用户名
password：用户名对应的密码，。可以是明文密码，也可以是hash密码。如果想使用hash密码，可以先在某个MySQL节点上执行select password(PASSWORD)，然后将加密结果复制到该字段。
default_hostgroup：该用户名默认的路由目标。例如，指定root用户的该字段值为10时，则使用 proxysql 用户发送的SQL语句默认情况下将路由到hostgroup_id=10 组中的某个节点。
我这里 hostgroup_id = 10的组中只有一个节点就是 master : 192.168.20.200
在192.168.20.201 (从库)端，用 proxysql 用户 测试是否sql路由能默认到 hostgroup_id=10，它是一个写组（读写数据）。
这句话的意思是说，在192.168.20.201（从库）上使用MySQL客户端，用proxysql 用户登录proxysql,默认是连接到 192.168.20.200(主库)上，创建一个数据库，看是否会同步过去
/usr/bin/mysql -h192.168.20.202 -P 6033 -uproxysql -pvxRDX$v%XXuz^1v!m # 提示有错误的话把密码先去掉，等提示输入密码的时候再输入
# 192.168.20.202 为软件proxysql安装所在主机
# proxysql为上一步创建的用户
# vxRDX$v%XXuz^1v!m 为用户proxysql的密码
# 6033 是对外提供服务的端口号，不是6032端口号
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
4 rows in set (0.00 sec)
mysql> select @@server_id;
+-------------+
| @@server_id |
+-------------+
| 200 |
+-------------+
1 row in set (0.00 sec)
# server_id是200，正好是192.168.20.200(主库)上的server_id
#通过proxysql用户，创建一个test库,因为192.168.20.200(主库)配置文件中写明只同步test库
mysql> create database test;
Query OK, 1 row affected (0.01 sec)
在slave：192.168.20.201 上去验证一下，是否同步过去test这个库, 经验证确实 同步过去test这个库了。
到这里主从分组信息都配置完了.
配置读写分离策略：路由规则
配置读写分离，就是配置ProxySQL 路由规则，ProxySQL 的路由规则非常灵活，可以基于用户，基于schema，以及单个sql语句实现路由规则定制。
注意：我这只是试验，只是配置了几个简单的路由规则，实际情况配置路由规则，不应该是就根据所谓的读、写操作来进行读写分离，而是从收集（慢日志）的各项指标找出压力大，执行频繁的语句单独写规则，做缓存等等。比如 先在测试几个核心sql语句，分析性能提升的百分比，在逐渐慢慢完善路由规则。
生产中使用读写分离 ：建议基于hash code 值做读写分离，不要建太多的规则
和查询规则有关的表有两个：mysql_query_rules和mysql_query_rules_fast_routing
表mysql_query_rules_fast_routing是mysql_query_rules的扩展，并在以后评估快速路由策略和属性（仅在ProxySQL 1.4.7+中可用）。
介绍一下改表mysql_query_rules的几个字段：
active：是否启用这个规则，1表示启用，0表示禁用
match_pattern 字段就是代表设置规则
destination_hostgroup 字段代表默认指定的分组，
apply 代表真正执行应用规则。
创建规则
创建两个规则：
1.把所有以select 开头的语句全部分配到读组中，读组编号是20
2.把 select .. for update 语句，这是一个特殊的select语句，会产生一个写锁(排他锁)，把他分到编号为10 的写组中，其他所有操作都会默认路由到写组中
insert into mysql_query_rules(rule_id,active,match_pattern,destination_hostgroup,apply) values (1,1,'^select.*for update$',10,1);
insert into mysql_query_rules(rule_id,active,match_pattern,destination_hostgroup,apply) values (2,1,'^select',20,1);
load mysql query rules to runtime;
save mysql query rules to disk;
select … for update规则的rule_id必须要小于普通的select规则的rule_id，因为ProxySQL是根据rule_id的顺序进行规则匹配的。
测试读写分离
# 测试读操作
密码是vxRDX$v%XXuz^1v!m
# mysql -uproxysql -p -P6033 -h192.168.20.202 -e 'select @@server_id'
Enter password:
+-------------+
| @@server_id |
+-------------+
| 201 |
+-------------+
# 测试写操作，以事务持久化进行测试
# mysql -uproxysql -p -P6033 -h192.168.20.202 -e '\
start transaction;\
select @@server_id;\
commit;\
select @@server_id;'
Enter password:
+-------------+
| @@server_id |
+-------------+
| 200 |
+-------------+
+-------------+
| @@server_id |
+-------------+
| 201 |
+-------------+
在192.168.20.201（从库）上使用MySQL客户端，用proxysql 用户登录proxysql,默认是连接到 192.168.20.200(主库)上
/usr/bin/mysql -h192.168.20.202 -P 6033 -uproxysql -pvxRDX$v%XXuz^1v!m # 提示有错误的话把密码先去掉，等提示输入密码的时候再输入
1.先创建数据表，然后查询数据表
mysql> CREATE TABLE `user_info1` (
-> `id` int NOT NULL,
-> `username` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
-> PRIMARY KEY (`id`)
-> ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from user_info1;
Empty set (0.01 sec)
2.登录prosysql管理端口，查看SQL请求路由信息
# 在 ProxySQL 中查看SQL请求路由信息stats_mysql_query_digest
# /usr/bin/mysql -uadmin -padmin -h 127.0.0.1 -P 6032
mysql> select hostgroup,schemaname,username,digest_text,count_star from stats_mysql_query_digest;
count_start 统计sql 语句次数，可以分析哪些 sql ，频繁执行
读写分离设置成功后，还可以调权重，比如让某台机器承受更多的读操作
列：
update mysql_servers set weight=10 hostname='192.168.20.201'；
load mysql servers to runtime;
save mysql servers to disk;
文章参考
https://www.cnblogs.com/f-ck-need-u/p/9278839.html
https://github.com/sysown/proxysql/wiki
https://www.cnblogs.com/keme/p/10972415.html#auto_id_17
重要参考步骤---ProxySQL实现读写分离的更多相关文章
- MHA+ProxySQL实现读写分离高可用
最近在研究ProxySQL,觉得还挺不错的,所以就简单的折腾了一下,ProxySQL目前也是Percona在推荐的一个读写分离的中间件.关于详细的介绍可以参考官方文档.https://github.c ...
- 如何利用MHA+ProxySQL实现读写分离和负载均衡
摘要:本文分享一下"MHA+中间件ProxySQL"如何来实现读写分离+负载均衡的相关知识. 本文分享自华为云社区<MySQL高可用架构MHA+ProxySQL实现读写分离和 ...
- MySQL架构之 主从+ProxySQL实现读写分离
准备服务器: docker run -d --privileged -v `pwd`/mysql_data:/data -p 3001:3306 --name mysql5-master --host ...
- Linux学习-基于CentOS7的ProxySQL实现读写分离
一.实验环境 主机:3台,一台ProxySQL(192.168.214.37),两台主从复制,master(192.168.214.17),slave(192.168.214.27) 系统:CentO ...
- MySQL使用ProxySQL实现读写分离
1 ProxySQL简介: ProxySQL是一个高性能的MySQL中间件,拥有强大的规则引擎.官方文档:https://github.com/sysown/proxysql/wiki/下载地址:ht ...
- 【DB宝42】MySQL高可用架构MHA+ProxySQL实现读写分离和负载均衡
目录 一.MHA+ProxySQL架构 二.快速搭建MHA环境 2.1 下载MHA镜像 2.2 编辑yml文件,创建MHA相关容器 2.3 安装docker-compose软件(若已安装,可忽略) 2 ...
- 重要参考步骤---ProxySQL Cluster 集群搭建步骤
环境 proxysql-1:192.168.20.202 proxysql-2:192.168.20.203 均采用yum方式安装 # cat <<EOF | tee /etc/yum.r ...
- ProxySQL（读写分离）部署
proxySQL是MySQL的中间件产品,是灵活强大的代理层,实现读写分离,支持Query路由功能,支持动态指定某个SQL进行缓存,支持动态加载配置,故障切换和一些SQL 过滤功能 环境: 192.1 ...
- proxysql 系列 ~ 读写分离核心功能
一 相关表介绍 1 mysql_user 列表配置 1 username && password 账号密码 2 default_hostgroup 默认的组ID2 mysq ...
随机推荐
- mvc Ensure that HttpConfiguration.EnsureInitialized()
The object has not yet been initialized. Ensure that HttpConfiguration.EnsureInitialized() is called ...
- docker容器数据管理
Docker容器数据卷 Docker中的数据可以存储在类似于虚拟机磁盘的介质中,在Docker中称为数据卷(Data Volume). 数据卷可以用来存储Docker应用的数据,也可以用来在Docke ...
- Trie树模板2
Trie数模板2 problem 这道题然后我们求最大异或对,我们很容易想出来 \(O(n^2)\) 的做法,两层循环遍历搞定 然后我们知道这样是肯定是肯定过不了的,我们考虑用字典树解决,然后我们来看 ...
- CSS面试总结
文章首次发表:_时雨_CSDN 1. BFC:块级格式化上下文(重点关注) BFC基本概念:BFC是 CSS布局的一个概念,是一块独立的渲染区域(环境),里面的元素不会影响到外部的元素. BFC原理( ...
- raspberrypi系统在加入k8s作为node节点时遇到的问题
新买的树莓派4b到货后就迫不及待的烧录上raspberrypi系统,将新派加入我的k8s集群,期间遇到了点小挫折,好歹也一个一个解决了: 一.kubelet版本不对导致无法加入k8s集群 在执行kub ...
- centos 8及以上安装mysql 8.0
本文适用于centos 8及以上安装mysql 8.0,整体耗时20分钟内,不需要FQ 1.环境先搞好 systemctl stop firewalld //关闭防火墙 systemctl disab ...
- Redis系列4：高可用之Sentinel(哨兵模式）
Redis系列1:深刻理解高性能Redis的本质 Redis系列2:数据持久化提高可用性 Redis系列3:高可用之主从架构 1 背景 从第三篇 Redis系列3:高可用之主从架构 ,我们知道,为Re ...
- 项目开发中Maven的单向依赖-2022新项目
一.业务场景 工作多年,在真实的项目开发中经常会遇到将一个项目拆分成多个工程的情况,比如将一个真实的项目拆分成controller层,service层, dao层,common公共服务层等等.这样拆分 ...
- 丽泽普及2022交流赛day19 半社论
目录 No Problem Str Not TSP 题面 题解 代码 Game 题面 题解 代码 No Problem 暴力 Str 存在循环节,大力找出来即可,长度显然不超过 \(10^3\) . ...
- 跟我学Python图像处理丨基于灰度三维图的图像顶帽运算和黑帽运算
摘要:本篇文章结合灰度三维图像讲解图像顶帽运算和图像黑猫运算,通过Python调用OpenCV函数实现. 本文分享自华为云社区<[Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽 ...