基于Keepalived+GTID的MySQL集群
文章目录
- 项目
-
- 步骤
-
- master
-
- 和ansible建立双向通道
- 读写创两个账户
- slave、slave2
- slave2 创建用户给slave b
- slave3 delay
- ansible
- router1、2
-
- 测试读写分离效果
- HA
-
- vip切换的时候实现报警
- 双vip
- 压力测试工具
- sysbench
-
- **安装**
- **准备测试数据**
- **使用yum安装的路径进行测试**
- **测试结果**
- tpcc
-
- 下载源码包，解压安装
- tcpp测试准备，初始化数据库
- 进行测试
- 问题
项目
读写分离
读写分离： 将对数据库的增删改查等操作进行分离，读操作往slave上进行，读写操作都可以在master上进行
本质上起到了负载均衡的作用。–》读写分离器、负载均衡器
目的： 是解决大并发的场景下，将流量分散到所有的MySQL服务器上，提升整个MySQL集群的处理能力，避免资源的闲置，提高数据库的响应能力，提高用户使用的满意度。
让整个数据库的访问过程非常顺畅，不卡顿。
准8台机器，4台mysq服务器，搭建主从复制的集群，一个master服务器，2个slave服务器，一个延迟备份服务器，同时延迟备份服务器也可以充当异地备份服务器。数据从，master或者slave上导出，然后rsync到备份服务器
2台mysqlrouter服务器，安装好 keepalived 实现高可用的读写分离服务
1台ansible中控服务器（中台）,实现对mysql整个集群里的服务器进行批量管理
1台压力测试服务器
步骤
基于GTID的半同步主从复制搭建过程
1.安装好4台MySQL服务器系统和MySQL软件，安装好半同步相关的插件
2.选中一台做master，其他的做slave，一台做延迟backup服务器
3.配置好ansible服务器，定义好主机清单
4.在master上导出基础数据，到ansible上，然后ansible下发到所有的slave服务器上
5.在所有的slave机器上导入基础数据
6.开启gtid功能，启动主从复制服务
7.配置延迟备份服务器，从slave1上拿二进制日志
8.在Master和ansible服务器之间建立双向免密通道，方便同步数据
9.在master上创建一个计划任务每天2:30进行数据库的备份，编写备份脚本每天备份数据，备份文件包含当前的日期，使用scp或者rsync+sersync远程同步到ansible服务器（相当于一台异地备份服务器）
10.在一台服务器安装部署了mysqlrouter中间件软件，实现读写分离
11.安装keepalived实现高可用，配置2个vrrp实例实现双vip的高可用功能
12.在dns域名里添加同一个名字对应2个vip，实现dns的负载均衡
13.进程压力测试，使用sysbench进行测试
master
导出基础数据
mysqldump -u root -p --all-databases --triggers --routines --events --set-gtid-purged=OFF > all_db.sql
导出mysql安装包和安装脚本到slave服务器
[root@master-mysql ~]# scp mysql-5.7.41-linux-glibc2.12-x86_64.tar.gz onekey_mysql.sh root@*.*.*.*:/root
和ansible建立双向通道
这是master和ansible建立免密通道
ssh-copy-id -i /root/.ssh/id_rsa.pub [email protected]
在ansible建立备份脚本
#!/bin/bash
mkdir -p /backup
mysqldump -u root -p'123456' --all-databases --triggers --routines --events --set-gtid-purged=OFF > all_db.sql >/backup/$(date +%Y%m%d%H%M%S)_all_db.SQL
scp /backup/$(date +%Y%m%d%H%M%S)_all_db.SQL 192.168.2.22:/backup
建立任务
[root@master-mysql backup]# crontab -l
30 2 * * * bash /backup/mysql_backup.sh
30 2 * * * bash /backup/backup_db.sh
读写创两个账户
在master上创建2个测试账号，一个是读的，一个是写的
这是需要咋开启半同步之后设置的，因为这些用户也会同步到slave。
grant all on *.* to 'write'@'%' identified by '123456';
grant select on *.* to 'read'@'%' identified by '123456';
slave、slave2
导入基础数据
安装半同步
root@(none) 11:05 mysql>INSTALL PLUGIN rpl_semi_sync_slave SONAME 'semisync_slave.so';
root@(none) 11:05 mysql>SET GLOBAL rpl_semi_sync_slave_enabled = 1;
修改my.cnf
[root@mysql ~]# cat /etc/my.cnf
[mysqld_safe]
[client]
socket=/data/mysql/mysql.sock
[mysqld]
socket=/data/mysql/mysql.sock
port = 3306
open_files_limit = 8192
innodb_buffer_pool_size = 512M
character-set-server=utf8
log_bin
server_id=2 #id号需要不同
rpl_semi_sync_slave_enabled=1
#gtid-mode=ON #在导入数据的时候需要先关闭数据，数据导入同步后，然后开启gtid功能
#enforce-gtid-consistency=ON
[mysql]
auto-rehash
prompt=\u@\d \R:\m mysql>
slave2的
[root@mysql ~]# cat /etc/my.cnf
[mysqld_safe]
[client]
socket=/data/mysql/mysql.sock
[mysqld]
socket=/data/mysql/mysql.sock
port = 3306
open_files_limit = 8192
innodb_buffer_pool_size = 512M
character-set-server=utf8
log_bin
server_id=2
rpl_semi_sync_slave_enabled=1
gtid-mode=ON
enforce-gtid-consistency=ON
log_slave_updates=ON
[mysql]
auto-rehash
prompt=\u@\d \R:\m mysql>
导入数据
mysql -uroot -p123456 < all_db.sql
配置半同步
CHANGE MASTER TO MASTER_HOST='192.168.2.3' ,
MASTER_USER='slave',
MASTER_PASSWORD='123456',
MASTER_PORT=3306,
master_auto_position=1;
root@(none) 16:09 mysql>show variables like '%semi_sync%'
-> ;
+-------------------------------------------+------------+
| 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 |
| rpl_semi_sync_slave_enabled | ON |
| rpl_semi_sync_slave_trace_level | 32 |
+-------------------------------------------+------------+
slave2 创建用户给slave b
这是给slave3 delay服务器用的账户
grant replication slave on *.* to 'slavede'@'192.168.2.%' identified by '123456';
slave3 delay
导入基础数据
导入数据
mysql -uroot -p123456 < all_db.sql
slave3 delay的master为slave2，从slave2服务器从数据做延迟备份，可以有效防止master错删数据。
stop slave;
reset master;
reset slave all;
start slave;
show slave status\G;
CHANGE MASTER TO MASTER_HOST='192.168.2.4' ,
MASTER_USER='slavede',
MASTER_PASSWORD='123456',
MASTER_PORT=3306,
master_auto_position=1;
ansible
ansible详细介绍
安装ansible
[root@prometheus ~]# yum install epel-release -y
[root@prometheus ~]# yum install ansible -y
建立免密通道
[root@prometheus ~]# ssh-keygen -t rsa
[root@prometheus ~]# ssh-copy-id -i /root/.ssh/id_rsa.pub [email protected]
[root@prometheus ~]# ssh '[email protected]'
Last login: Mon Jul 17 15:16:59 2023
[root@slave-d ~]#
免密通道建立成功
从master拿数据
[root@slave-d ~]# scp [email protected]:/backup/all2_db.sql .
[email protected]'s password:
all_db.sql 100% 203 124.7KB/s 00:00
[root@slave-d ~]#
转数据到slave
ansible -m copy -a "src=/backup/20230717174205_all_db.SQL dest=/root" dbs
配置半同步（从slave2从拿数据，作为备份服务器）
CHANGE MASTER TO MASTER_HOST='192.168.2.4' ,
MASTER_USER='slavede',
MASTER_PASSWORD='12345',
MASTER_PORT=3306,
master_auto_position=1;
配置延迟
CHANGE MASTER TO MASTER_DELAY = 10;
router1、2
MySQL Router（MySQL路由器）是MySQL官方提供的一个开源工具，用于实现MySQL数据库的读写分离和负载均衡。它允许应用程序连接到MySQL集群而不需要直接连接到后端MySQL服务器。MySQL Router通过拦截客户端的连接请求，并根据配置规则将请求转发到合适的MySQL服务器上，从而实现了负载均衡和读写分离。
以下是MySQL Router的一些关键特点和功能：
-
负载均衡：MySQL Router可以将客户端的连接请求分发到后端MySQL服务器上，从而实现负载均衡。这有助于避免某些服务器过载，提高整个集群的性能和可扩展性。
-
读写分离：通过配置不同的路由规则，MySQL Router可以将读请求（SELECT）和写请求（INSERT、UPDATE、DELETE等）分别转发到不同的MySQL服务器上，实现读写分离的目标。这样可以减轻主数据库的负担，提高读取操作的性能。
-
高可用性：MySQL Router支持多个实例部署，可以配置为高可用模式。如果一个Router实例故障，客户端可以自动连接到另一个可用的Router实例。
-
动态路由更新：MySQL Router可以监视MySQL服务器的状态，并动态地更新路由规则，以便在服务器故障或新服务器加入时重新平衡负载。
-
连接池：MySQL Router具有连接池功能，可以有效地管理与后端MySQL服务器的连接，从而减少连接的开销并提高性能。
-
SSL支持：MySQL Router支持通过SSL加密进行安全的数据库连接。
-
透明性：对于应用程序来说，连接到MySQL Router和直接连接到MySQL服务器没有明显区别，因为Router在中间工作，对于应用程序来说是透明的。
-
轻量级：MySQL Router是一个轻量级的工具，易于部署和配置。
MySQL Router通常与MySQL InnoDB集群或MySQL复制集群（主-从复制）一起使用。它为应用程序提供了简单、高效且可靠的数据库连接管理，使得横向扩展和高可用性的MySQL架构更加容易实现。
客户端接入mysql router的不同端口，因此客户端有不同的功能，有读写的功能和仅读的功能。这需要master服务器创建两个不同的账户来实现这个功能。
下载mysql-router安装包
https://dev.mysql.com/get/Downloads/MySQL-Router/mysql-router-community-8.0.21-1.el7.x86_64.rpm
安装
[root@web1 ~]# rpm -ivh mysql-router-community-8.0.23-1.el7.x86_64.rpm
修改配置文件
[root@web1 ~]# cd /etc/mysqlrouter/
[root@web1 mysqlrouter]# ls
mysqlrouter.conf
[DEFAULT]
logging_folder = /var/log/mysqlrouter
runtime_folder = /var/run/mysqlrouter
config_folder = /etc/mysqlrouter
[logger]
level = INFO
[keepalive]
interval = 60
#read-only
[routing:slaves]
bind_address = 0.0.0.0:7001
destinations = 192.168.2.4:3306,192.168.2.5:3306
mode = read-only
connect_timeout = 1
#write and read
[routing:masters]
bind_address = 0.0.0.0:7002
destinations = 192.168.2.3:3306
mode = read-write
connect_timeout = 1
启动MySQL router服务
[root@web1 mysqlrouter]# service mysqlrouter start
Redirecting to /bin/systemctl start mysqlrouter.service
[root@web1 mysqlrouter]# netstat -anplut|grep mysql
tcp 0 0 0.0.0.0:3306 0.0.0.0:* LISTEN 1211/mysqld
tcp 0 0 192.168.2.25:7001 0.0.0.0:* LISTEN 2264/mysqlrouter
tcp 0 0 192.168.2.25:7002 0.0.0.0:* LISTEN 2264/mysqlrouter
测试读写分离效果
mysql -h 192.168.2.25 -P 7002 -uwrite -p'123456'
mysql -h 192.168.2.25 -P 7001 -uread -p'123456'
读写分离的关键点：其实是用户的权限，让不同的用户连接不同的端口，最后任然要到后端的mysql服务器里去验证是否有读写的权限
mysqlrouter:只是做了读写的分流，让应用程序去连接不同的端口(mysqlrouter只是一个分流的工具)主要是用户权限的控制，有写权限的用户走读的通道也可以写，读的用户走写的通道只能读
HA
HA-keepalive详细介绍
安装keepalived
yum install keepalived -y
修改配置文件
cd /etc/keepalived/
! Configuration File for keepalived
global_defs {
notification_email {
[email protected]
[email protected]
[email protected]
}
notification_email_from [email protected]
smtp_server 192.168.200.1
smtp_connect_timeout 30
router_id LVS_DEVEL
vrrp_skip_check_adv_addr
# vrrp_strict
vrrp_garp_interval 0
vrrp_gna_interval 0
}
vrrp_instance VI_1 {
state MASTER
interface ens33
virtual_router_id 88
priority 180
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
virtual_ipaddress {
192.168.2.66
}
}
vip切换的时候实现报警
[root@mysql-router-1 keepalived]# cat keepalived.conf
! Configuration File for keepalived
global_defs {
notification_email {
[email protected]
[email protected]
[email protected]
}
notification_email_from [email protected]
smtp_server 192.168.200.1
smtp_connect_timeout 30
router_id LVS_DEVEL
vrrp_skip_check_adv_addr
#vrrp_strict
vrrp_garp_interval 0
vrrp_gna_interval 0
}
#keepalived进程去封装vrrp报文
#当keepalived进程发送vrrp报文，执行的脚本，每隔3秒钟执行一次，配置名字叫send_mail
#在vrrp实例里的配置，只要启动keepalived进程就会每隔3秒执行一次，不管你是master还是backup
#/mail/sendmail.sh 需要自己去创建，编写
vrrp_script send_mail {
script "/mail/sendmail.sh"
interval 3 #每隔3秒钟就执行一次这个脚本
}
vrrp_script send_mail {
script "/mail/sendmail.sh"
interval 3
}
vrrp_instance VI_1 {
state MASTER
interface ens33
virtual_router_id 88
priority 200
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
#追踪执行脚本，只要成为master，发送vrrp宣告消息就执行脚本
track_script {
send_mail
}
#notify_master 状态改变为MASTER后执行的脚本
notify_master /mail/master.sh
#notify_backup 状态改变为BACKUP后执行的脚本
notify_backup /mail/backup.sh
#notify_stop VRRP停止后后执行的脚本
notify_stop /mail/stop.sh
virtual_ipaddress {
192.168.2.66
}
}
notify_master | # 状态改变为MASTER后执行的脚本
notify_backup | # 状态改变为BACKUP后执行的脚本
notify_fault | # 状态改变为FAULT后执行的脚本
notify_stop | # VRRP停止后后执行的脚本
notify | # (1)任意状态改变后执行的脚本
双vip
搞2个vrrp实例，2个vip，2个实例互为主备
在dns域名里添加同一个名字对应2个vip，实现dns的负载均衡
[root@web1 mail]# cat /etc/keepalived/keepalived.conf
! Configuration File for keepalived
global_defs {
notification_email {
[email protected]
[email protected]
[email protected]
}
notification_email_from [email protected]
smtp_server 192.168.200.1
smtp_connect_timeout 30
router_id LVS_DEVEL
vrrp_skip_check_adv_addr
# vrrp_strict
vrrp_garp_interval 0
vrrp_gna_interval 0
}
vrrp_script send_mail {
script "/mail/sendmail.sh"
interval 30000
}
vrrp_instance VI_1 {
state MASTER
interface ens33
virtual_router_id 88
priority 180
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
#追踪执行脚本，只要成为master，发送vrrp宣告消息就执行脚本
track_script {
send_mail
}
#notify_master 状态改变为MASTER后执行的脚本
notify_master /mail/master.sh
#notify_backup 状态改变为BACKUP后执行的脚本
notify_backup /mail/backup.sh
#notify_stop VRRP停止后后执行的脚本
virtual_ipaddress {
192.168.2.66
}
}
vrrp_instance VI_2 {
state backup
interface ens33
virtual_router_id 87
priority 100
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
virtual_ipaddress {
192.168.2.67
}
}
压力测试工具
TPCC
- OLTP（on-line transaction processing）为联机事务处理。
- OLAP（On-Line Analytical Processing）为联机分析处理。
两者简单的区别为OLTP是做事务处理，OLAP是做分析处理。
站在数据库的操作层面来看，OLTP主要是对数据的增删改，侧重实时性，OLAP是对数据的查询，侧重大数据量查询。
SYSBENCH
Sysbench 是一个常用的多线程性能测试工具，可用于评估数据库系统和硬件的性能。它支持多种基准测试，包括 OLTP (Online Transaction Processing)、CPU、文件 I/O、内存等
sysbench
Sysbench 是一个常用的多线程性能测试工具，可用于评估数据库系统和硬件的性能。它支持多种基准测试，包括 OLTP (Online Transaction Processing)、CPU、文件 I/O、内存等。
安装
去官方网站下mysql的repo文件
https://dev.mysql.com/downloads/repo/yum/
[root@localhost ~]# rpm -ivh mysql80-community-release-el7-8.noarch.rpm
[root@localhost ~]# cd /etc/yum.repos.d/
[root@localhost yum.repos.d]# ls
CentOS-Base.repo CentOS-Media.repo mysql-community-debuginfo.repo
CentOS-CR.repo CentOS-Sources.repo mysql-community.repo
CentOS-Debuginfo.repo CentOS-Vault.repo mysql-community-source.repo
CentOS-fasttrack.repo CentOS-x86_64-kernel.repo
出现问题：
即使下载了官网的repo源，也不行
again or use --enablerepo for temporary usage:
yum-config-manager --disable
or
subscription-manager repos --disable=
5. Configure the failing repository to be skipped, if it is unavailable.
Note that yum will try to contact the repo. when it runs most commands,
so will have to try and fail each time (and thus. yum will be be much
slower). If it is a very temporary problem though, this is often a nice
compromise:
yum-config-manager --save --setopt=.skip_if_unavailable=true
Cannot find a valid baseurl for repo: base/7/x86_64
解决方法：
- 尝试其他镜像源：如果DNS配置正确，但
mirrorlist.centos.org仍然无法解析，可以尝试使用其他镜像源。在/etc/yum.repos.d/目录下，有一个名为CentOS-Base.repo的文件，尝试编辑这个文件，将mirrorlist相关的行注释掉，然后启用baseurl行，并使用一个可用的镜像URL，例如：rubyCopy code baseurl=http://mirror.centos.org/centos/7/os/x86_64/注意：这只是一个示例URL，您可以根据需要使用其他可用的镜像源。
- 清除YUM缓存：运行以下命令可以尝试清除YUM缓存并重新生成：
cssCopy code yum clean all
编译安装下载
yum -y install mysql-community-devel
yum -y install automake libtool
wget https://github.com/akopytov/sysbench/archive/1.0.15.tar.gz
tar xf 1.0.15.tar.gz
cd sysbench-1.0.15
./autogen.sh
./configure
make -j
make install
建议实验epel下载sysbench（yum安装）
yum install epel-release -y
yum install sysbench -y
准备测试数据
首先创建sysbench所需数据库sbtest(这是sysbench默认使用的库名，必须创建测试库)。
mysqladmin -h127.0.0.1 -uroot -p123456 -P3306 create sbtest;
这是yum安装对应的
sysbench --mysql-host=192.168.2.25 --mysql-port=7002 --mysql-user=write --mysql-password='123456' /usr/share/sysbench/oltp_common.lua --tables=10 --table_size=10000 prepare
这是编译安装对应的
sysbench --mysql-host=192.168.2.25 --mysql-port=7002 --mysql-user=write --mysql-password='123456' /root/sysbench-1.0.15/src/lua
/oltp_common.lua --tables=10 --table_size=10000 prepare
使用yum安装的路径进行测试
[root@localhost bin]# sysbench --mysql-host=192.168.2.25 --mysql-port=7002 --mysql-user=write --mysql-password='123456' /usr/share/sysbench/oltp_common.lua --tables=10 --table_size=10000 prepare
sysbench 1.0.17 (using system LuaJIT 2.0.4)
Creating table 'sbtest1'...
Inserting 10000 records into 'sbtest1'
Creating a secondary index on 'sbtest1'...
Creating table 'sbtest2'...
Inserting 10000 records into 'sbtest2'
Creating a secondary index on 'sbtest2'...
Creating table 'sbtest3'...
Inserting 10000 records into 'sbtest3'
Creating a secondary index on 'sbtest3'...
Creating table 'sbtest4'...
Inserting 10000 records into 'sbtest4'
Creating a secondary index on 'sbtest4'...
Creating table 'sbtest5'...
Inserting 10000 records into 'sbtest5'
Creating a secondary index on 'sbtest5'...
Creating table 'sbtest6'...
Inserting 10000 records into 'sbtest6'
Creating a secondary index on 'sbtest6'...
Creating table 'sbtest7'...
Inserting 10000 records into 'sbtest7'
Creating a secondary index on 'sbtest7'...
Creating table 'sbtest8'...
Inserting 10000 records into 'sbtest8'
Creating a secondary index on 'sbtest8'...
Creating table 'sbtest9'...
Inserting 10000 records into 'sbtest9'
Creating a secondary index on 'sbtest9'...
Creating table 'sbtest10'...
Inserting 10000 records into 'sbtest10'
Creating a secondary index on 'sbtest10'...
root@sbtest 11:32 mysql>show tables;
+------------------+
| Tables_in_sbtest |
+------------------+
| sbtest1 |
| sbtest10 |
| sbtest2 |
| sbtest3 |
| sbtest4 |
| sbtest5 |
| sbtest6 |
| sbtest7 |
| sbtest8 |
| sbtest9 |
+------------------+
10 rows in set (0.00 sec)
测试结果
基准测试命令： 使用 Sysbench 运行 MySQL 基准测试时，常见的命令格式如下：
cssCopy code sysbench [options] --threads=[num_threads] --mysql-host=[mysql_host] --mysql-port=[mysql_port] --mysql-user=[mysql_user] --mysql-password=[mysql_password] --mysql-db=[mysql_database] [test_name]
[options]：可选的 Sysbench 选项，用于配置测试的参数，例如运行时间、请求率等。--threads=[num_threads]：指定并发线程数，即同时运行的线程数。--mysql-host=[mysql_host]：指定 MySQL 服务器的主机名或 IP 地址。--mysql-port=[mysql_port]：指定 MySQL 服务器的端口号。--mysql-user=[mysql_user]：指定连接 MySQL 服务器所使用的用户名。--mysql-password=[mysql_password]：指定连接 MySQL 服务器所使用的密码。--mysql-db=[mysql_database]：指定要进行测试的数据库名称。[test_name]：指定要运行的具体测试，例如 OLTP、CPU、文件 I/O 等。
sysbench --threads=4 --time=20 --report-interval=5 --mysql-host=192.168.2.25 --mysql-port=7001 --mysql-user=write --mysql-password=123456 /usr/share/sysbench/oltp_read_write.lua --tables=10 --table-size=100000 run
[root@localhost sysbench]# sysbench --threads=4 --time=20 --report-interval=5 --mysql-host=192.168.2.25 --mysql-port=7001 --mysql-user=write --mysql-password=123456 /usr/share/sysbench/oltp_read_write.lua --tables=10 --table-size=100000 run
sysbench 1.0.17 (using system LuaJIT 2.0.4)
Running the test with following options:
Number of threads: 4
Report intermediate results every 5 second(s)
Initializing random number generator from current time
Initializing worker threads...
Threads started!
[ 5s ] thds: 4 tps: 191.49 qps: 3850.57 (r/w/o: 2698.03/201.67/950.86) lat (ms,95%): 31.37 err/s: 0.60 reconn/s: 0.00
[ 10s ] thds: 4 tps: 209.08 qps: 4181.87 (r/w/o: 2927.17/242.93/1011.77) lat (ms,95%): 26.68 err/s: 0.00 reconn/s: 0.00
[ 15s ] thds: 4 tps: 198.05 qps: 3960.59 (r/w/o: 2772.09/254.12/934.37) lat (ms,95%): 30.81 err/s: 0.00 reconn/s: 0.00
[ 20s ] thds: 4 tps: 192.85 qps: 3858.26 (r/w/o: 2701.95/262.43/893.88) lat (ms,95%): 33.72 err/s: 0.00 reconn/s: 0.00
SQL statistics:
queries performed:
read: 55510
write: 4812
other: 18972
total: 79294
transactions: 3962 (197.75 per sec.)
queries: 79294 (3957.64 per sec.)
ignored errors: 3 (0.15 per sec.)
reconnects: 0 (0.00 per sec.)
General statistics:
total time: 20.0346s
total number of events: 3962
Latency (ms):
min: 9.20
avg: 20.20
max: 1010.51
95th percentile: 30.81
sum: 80041.23
Threads fairness:
events (avg/stddev): 990.5000/34.51
execution time (avg/stddev): 20.0103/0.01
根据sysbench的输出，这是一次OLTP读写测试的结果。让我对输出进行解析，以便您更好地了解测试的性能表现：
- 系统信息：
- sysbench版本：1.0.17
- 使用的LuaJIT版本：2.0.4
- 测试参数：
- 线程数：4
- 报告中间结果的间隔：每5秒报告一次
- 使用的MySQL主机：192.168.2.25
- 使用的MySQL端口：7001
- 使用的MySQL用户：write
- 使用的MySQL密码：123456
- 测试脚本路径：/usr/share/sysbench/oltp_read_write.lua
- 使用的表数：10
- 每个表的大小：100,000行
- 测试过程：
- 初始化随机数生成器。
- 初始化工作线程。
- 启动4个线程进行测试。
- 测试结果：
在测试进行了20秒后，以下是测试的结果统计：
- 在第5秒时，每秒处理事务数(tps)约为191.49，每秒查询数(qps)约为3850.57。
- 在第10秒时，tps约为209.08，qps约为4181.87。
- 在第15秒时，tps约为198.05，qps约为3960.59。
- 在第20秒时，tps约为192.85，qps约为3858.26。
- SQL统计：
- 读取查询数量：55510
- 写入查询数量：4812
- 其他查询数量：18972
- 总查询数量：79294
- 完成的事务数量：3962 (平均每秒197.75个事务)
- 总查询数：79294 (平均每秒3957.64个查询)
- 忽略的错误数：3 (平均每秒0.15个错误)
- 重新连接数：0 (平均每秒0.00个重新连接)
- 总体统计：
- 总耗时：20.0346秒
- 总事件数：3962
- 延迟（以毫秒为单位）：
- 最小延迟：9.20ms
- 平均延迟：20.20ms
- 最大延迟：1010.51ms
- 第95百分位延迟：30.81ms
- 总延迟：80041.23ms
- 线程公平性：
- 事件数量（平均/标准差）：990.5000/34.51
- 执行时间（平均/标准差）：20.0103/0.01
解析结果表明，测试运行了20秒，使用4个线程，在给定的配置下，每秒处理的事务数在190到210之间浮动。请注意，性能结果还受到MySQL服务器和系统硬件等因素的影响，因此，如果要获得更精确的性能指标，可能需要在多个不同配置下运行测试，并进行更详细的分析。
清除建立的测试表
sysbench --mysql-host=192.168.2.25 \
--mysql-port=7002 \
--mysql-user=write \
--mysql-password='123456' \
/usr/share/sysbench/oltp_common.lua \
--tables=10 \
cleanup
效果
| 59741 | 50095 | 94054036382-30666175964-93983866440-82198879802-79178088086-626860264174919 |
| 60074 | 50328 | 71234724885-22289811426-29663594026-43624298282-65444509716-502104939320899 |
| 63215 | 49852 | 69814563728-47986046934-75862954779-06559782038-51838414177-222236416566077 |
| 65881 | 49778 | 74995573852-31949172824-75320100772-28469702486-62705248269-933810682682159 |
+-------+-------+-----------------------------------------------------------------------------+
10177 rows in set (0.13 sec)
root@sbtest 11:42 mysql>select * from sbtest1;
ERROR 1146 (42S02): Table 'sbtest.sbtest1' doesn't exist
删除成功了
当然也可以在master服务器上手动删除
出现问题，删除后如果我新建再次会出现数据库存在的问题
[root@localhost sysbench]# mysqladmin -h127.0.0.1 -uroot -p123456 -P3306 create sbtest;
mysqladmin: [Warning] Using a password on the command line interface can be insecure.
mysqladmin: CREATE DATABASE failed; error: 'Can't create database 'sbtest'; database exists'
原因:
有其他MySQL连接正在使用sbtest数据库,导致你无法删除。可以用
show processlist;命令查看是否有进程在占用sbtest数据库。
*************************** 4. row ***************************
Id: 12
User: write
Host: 192.168.2.25:35132
db: sbtest
Command: Sleep
Time: 1704
State:
Info: NULL
4 rows in set (0.00 sec)
ERROR:
No query specified
root@(none) 11:57 mysql>
解决：
最简单的方法是：在master服务器上重新创建一个sbtest数据库
- 识别占用连接的线程id,然后使用kill命令终止该连接线程:
kill [线程id];
- 如果不确定是哪个连接占用了sbtest数据库,可以直接杀死所有连接线程:
kill connection for database sbtest;
- 使用disconnect命令 disconnect指定的线程:
disconnect [线程id];
- 修改该连接的用户权限,禁用其访问sbtest数据库的权限:
revoke all privileges on sbtest.* from [用户名]@[主机名];
- 设置sbtest数据库为只读模式,禁止写入操作:
flush tables with read lock;
- 直接重启MySQL服务,关闭所有连接线程。
tpcc
TPCC-MYSQL 是一个用于执行 TPCC（Transaction Processing Performance Council）基准测试的工具集合。TPCC 是一个广泛使用的数据库基准测试，用于衡量数据库系统在高并发负载下的性能。TPCC-MYSQL 专门针对 MySQL 数据库进行性能测试，它使用标准的 TPCC 基准测试规范，并提供一系列工具和脚本来准备测试数据、运行测试和分析测试结果。
tpcc-mysql业务逻辑
下面是 TPCC-MYSQL 的业务逻辑详细介绍：
数据库模式（Schema）：
TPCC-MYSQL 使用一组相关的数据库表来表示不同的业务实体，例如仓库、客户、订单、商品等。这些表之间建立了适当的关系，以模拟真实的业务场景。在运行 TPCC-MYSQL 之前，需要创建这些数据库表，并根据 TPCC 的要求填充测试数据。仓库（Warehouse）：
一个仓库代表了一个具有存储功能的实体，用于存放商品。TPCC-MYSQL 可以模拟多个仓库的情况。商品（Item）：
商品是指可以在仓库中存放和销售的产品。每个仓库都有一定数量的商品，这些商品可以随机分配给不同的仓库。客户（Customer）：
客户代表购买商品的个人或组织。每个客户可以有一些基本信息，例如姓名、地址等。订单（Order）：
订单是客户购买商品的记录。每个订单包含了购买的商品、数量、价格等信息。支付（Payment）：
支付是客户支付订单的记录。每个支付包含了支付的金额、日期等信息。交货（Delivery）：
交货是将商品交付给客户的记录。每个交货包含了交货的日期、数量等信息。填充测试数据：
在执行 TPCC-MYSQL 之前，需要使用tpcc_load工具来填充测试数据。该工具会根据指定的仓库数量、客户数量和商品数量生成适量的测试数据。事务处理：
TPCC-MYSQL 使用一系列事务来模拟不同的业务操作，例如客户下单、付款、交货等。这些事务包含了多个数据库操作，涉及多个表之间的数据交互。并发测试：
TPCC-MYSQL 可以在多个并发用户之间执行事务处理，以模拟高并发负载下的数据库性能。并发测试是衡量数据库系统处理并发事务的能力的重要指标。测量性能：
在执行 TPCC-MYSQL 测试后，可以使用tpcc_start和tpcc_report工具来测量和分析数据库系统的性能表现。报告中可能包含吞吐量、响应时间、事务成功率等指标，这些指标可以帮助评估数据库系统的性能和可伸缩性。
下载源码包，解压安装
wget http://imysql.com/wp-content/uploads/2014/09/tpcc-mysql-src.tgz
[root@localhost tcpp]# tar xf tpcc-mysql-src.tgz
cd tpcc-mysql/src
[root@localhost src]# make
make后会生成两个二进制工具tpcc_load（提供初始化数据的功能）和tpcc_start(进行压力测试)
[root@localhost tpcc-mysql]# ls
add_fkey_idx.sql drop_cons.sql schema2 tpcc_load
count.sql load.sh scripts tpcc_start
根据您提供的文件列表，以下是关于 TPCC-MYSQL 文件夹中的每个文件的详细信息：
add_fkey_idx.sql: 这个文件可能包含用于添加外键索引的 SQL 语句。外键索引用于维护表之间的关联性，并能加速数据检索和连接。
drop_cons.sql: 这个文件可能包含用于删除外键约束的 SQL 语句。在进行 TPCC 测试之前，可能需要清除外键约束，以便更轻松地加载数据。
schema2: 这是一个文件夹，通常包含与数据库模式（Schema）相关的文件。可能包含创建表、视图、存储过程等的 SQL 语句。
tpcc_load: 这是一个用于加载测试数据的工具或脚本。在进行 TPCC 基准测试之前，需要加载适当的测试数据，以模拟真实的数据库工作负载。
count.sql: 这个文件可能包含一些用于统计数据量或验证数据完整性的 SQL 查询语句。
load.sh: 这是一个 Shell 脚本，可能用于执行数据加载操作的脚本。它可能调用了tpcc_load工具，并指定了一些加载的参数。
scripts: 这是一个文件夹，可能包含其他执行 TPCC 测试所需的脚本文件。
tpcc_start: 这可能是一个用于启动 TPCC 测试的脚本。它可能设置了测试的参数，并调用其他必要的脚本来开始基准测试过程。
tcpp测试准备，初始化数据库
创建数据库
mysqladmin -uwrite -p'123456' -h 192.168.2.25 -P 7002 create tpcc
导入数据
如果远程导入不行，可以直接将数据转送到master主机上，将数据导入就可了
mysql -h 192.168.2.25 -P 7002 -uwrite -p'123546' tpcc scp create_table.sql add_fkey_idx.sql [email protected]:/root
[root@master-mysql ~]# mysql -uroot -p'123456' tpcc root@tpcc 15:27 mysql>show tables;
+----------------+
| Tables_in_tpcc |
+----------------+
| customer |
| district |
| history |
| item |
| new_orders |
| order_line |
| orders |
| stock |
| warehouse |
+----------------+
9 rows in set (0.00 sec)
加载数据
./tpcc_load 192.168.2.25:7002 tpcc write 123456 2
数据量大小：参数
2指定了要加载的仓库数量。加载的数据量越大，执行时间可能越长。
想尽快看到效果的伙伴，可以把这个数据调小些。
出现问题：
[root@localhost tpcc-mysql]# ./tpcc_load 192.168.2.25:7002 tpcc write 123456 2
./tpcc_load: error while loading shared libraries: libmysqlclient.so.20: cannot open shared object file: No such file or directory
解决
确认库文件位置：如果已经安装了 MySQL 客户端库，但是找不到
libmysqlclient.so.20文件，您需要确定它的位置。通常，MySQL 客户端库的位置是在/usr/lib或/usr/lib64目录下
[root@localhost tpcc-mysql]# find / -name 'libmysqlclient.so.20'
/usr/local/mysql/lib/libmysqlclient.so.20
echo "/usr/local/mysql/lib" | sudo tee -a /etc/ld.so.conf
sudo ldconfig
进行测试
注意：server等信息与步骤4中保持一致
TPCC-MYSQL 是一个用于测试数据库性能的基准测试工具，下面是
tpcc_start命令的详细参数说明和用法：./tpcc_start -h [server_host] -P [port] -d [database_name] -u [mysql_user] -p [mysql_password] -w [warehouses] -c [connections] -r [warmup_time] -l [running_time] -i [report_interval] -f [report_file] -t [trx] > out1各个参数的用法如下：
-h server_host: 指定数据库服务器的主机名或IP地址。
-P port: 指定数据库服务器的端口号，默认为3306。
-d database_name: 指定用于测试的数据库名称。
-u mysql_user: 指定连接数据库所使用的用户名。
-p mysql_password: 指定连接数据库所使用的密码。
-w warehouses: 指定要创建的仓库数量。仓库用于存储商品和处理订单。
-c connections: 指定并发连接数，即同时运行的线程数。默认为1，可以根据测试需求调整该值。
-r warmup_time: 指定热身时间，即在正式测试之前预先运行一段时间以将数据加载到内存中。热身是为了使缓存预热，提高测试结果的准确性。默认为10秒。
-l running_time: 指定测试时间，即执行正式测试的时间长度。默认为20秒。
-i report_interval: 指定生成测试报告的时间间隔。在测试期间，TPCC-MYSQL 会定期生成报告，以便观察测试过程中的性能指标。建议生成报告的间隔时间不低于30分钟，以确保获得足够的数据。
-f report_file: 指定测试结果输出文件的名称。一般将测试结果输出到一个日志文件，以便后续分析和查看。
-t trx: 指定输出文件的名称。该文件记录了执行测试期间的所有事务操作，包括成功和失败的事务。执行
tpcc_start命令后，它将启动测试并运行指定时间。在测试结束后，您可以查看输出文件out1，以及报告文件report_file，来了解测试期间数据库的性能表现。
./tpcc_start -h 192.168.2.25 -P 7002 -d tpcc -u write -p '123456' -w 2 -c 12 -r 300 -l 360 -f test0.log -t test1.log - >test0.out
[root@localhost tpcc-mysql]# cat test0.out
***************************************
*** ###easy### TPC-C Load Generator ***
***************************************
option h with value '192.168.2.25'
option P with value '7002'
option d with value 'tpcc'
option u with value 'write'
option p with value '123456'
option w with value '2'
option c with value '12'
option r with value '300'
option l with value '360'
option f with value 'test0.log'
option t with value 'test1.log'
non-option ARGV-elements: -
[server]: 192.168.2.25
[port]: 7002
[DBname]: tpcc
[user]: write
[pass]: 123456
[warehouse]: 2
[connection]: 12
[rampup]: 300 (sec.)
[measure]: 360 (sec.)
RAMP-UP TIME.(300 sec.)
MEASURING START.
10, 677(190):9.609|283.788, 678(0):2.243|203.337, 69(0):1.168|5.442, 68(0):14.206|40.242, 68(2):19.999|59.394
20, 765(231):7.100|8.084, 764(0):1.552|1.866, 75(0):0.698|0.750, 77(0):8.885|8.978, 76(5):19.999|21.524
30, 761(236):7.015|7.196, 759(0):1.603|2.238, 77(0):0.845|0.866, 76(0):8.885|9.294, 77(9):19.999|21.956
40, 680(203):7.233|80.320, 685(0):1.715|2.160, 69(0):0.798|0.804, 68(0):9.011|9.381, 67(10):19.999|34.428
50, 647(212):8.568|39.590, 644(1):1.821|16.209, 63(0):1.151|1.383, 65(0):9.928|11.700, 65(15):19.999|24.729
60, 658(192):9.849|12.151, 656(0):2.417|3.684, 66(0):0.836|1.166, 66(0):10.870|11.271, 65(8):19.999|29.011
70, 712(233):9.885|62.567, 717(1):2.234|5.236, 72(0):0.927|1.120, 70(0):19.382|67.972, 72(14):19.999|32.404
80, 645(217):8.361|34.979, 645(0):2.618|3.911, 64(0):0.815|1.236, 65(0):11.297|12.007, 65(13):19.999|34.617
90, 616(227):10.123|24.151, 614(2):2.788|6.256, 62(0):1.082|1.552, 62(0):13.038|13.162, 61(14):19.999|34.818
100, 661(243):8.853|12.499, 657(1):2.111|6.116, 65(0):0.868|0.951, 65(0):12.572|13.628, 65(17):19.999|25.945
110, 710(267):8.887|13.115, 714(0):2.035|3.214, 72(0):1.031|1.164, 72(0):11.494|11.545, 72(24):19.999|30.804
120, 717(246):9.264|12.371, 713(0):1.908|2.807, 71(0):0.855|1.004, 71(0):19.999|24.060, 72(18):19.999|30.451
130, 708(239):8.596|10.882, 707(0):2.030|3.013, 71(0):0.857|0.959, 71(0):10.861|11.188, 70(21):19.999|27.728
140, 588(275):14.900|20.400, 591(1):3.257|5.346, 59(0):1.471|1.503, 58(0):16.165|18.864, 59(26):19.999|40.590
150, 657(157):7.862|38.557, 663(0):1.692|3.636, 66(0):0.978|1.223, 67(0):9.459|10.673, 66(13):19.999|62.886
160, 589(168):7.498|14.794, 586(0):1.813|2.117, 59(0):0.787|1.700, 59(0):9.913|10.766, 59(10):19.999|23.412
170, 752(194):7.096|7.933, 748(0):1.481|1.808, 75(0):0.788|0.834, 75(0):8.384|8.727, 76(9):19.999|22.745
180, 785(241):6.907|7.807, 784(0):1.583|2.197, 78(0):0.686|0.924, 78(0):8.651|9.104, 77(5):19.999|22.638
190, 771(227):7.447|10.232, 770(0):1.613|2.382, 77(0):0.782|1.041, 77(0):9.203|9.313, 78(15):19.999|23.728
200, 686(253):10.316|17.892, 684(0):2.141|3.064, 69(0):1.054|1.715, 69(0):10.166|17.150, 69(19):19.999|36.686
210, 593(186):9.524|17.592, 597(0):2.494|4.665, 60(0):1.591|1.775, 59(0):14.900|17.007, 59(17):19.999|35.502
220, 617(177):9.079|16.471, 615(1):2.039|13.194, 61(0):0.711|1.426, 62(0):11.674|11.768, 62(14):19.999|27.944
230, 738(252):7.925|11.160, 741(0):1.793|2.965, 74(0):0.767|0.881, 74(0):10.863|11.546, 73(11):19.999|25.909
240, 725(253):7.808|12.047, 728(0):2.179|2.994, 73(0):0.730|1.008, 72(0):9.999|11.472, 72(21):19.999|27.928
250, 525(333):13.687|16.571, 521(1):3.305|5.677, 51(0):1.767|2.185, 53(0):14.808|16.540, 52(44):19.999|42.772
260, 613(329):12.063|24.300, 609(1):2.546|6.719, 62(0):1.491|2.242, 61(0):14.331|23.131, 62(44):19.999|38.645
270, 515(243):12.594|17.291, 521(3):3.319|7.934, 52(0):1.751|2.218, 51(0):15.489|17.018, 52(29):19.999|39.224
280, 599(209):9.682|16.133, 597(0):2.326|3.089, 59(0):0.838|0.888, 61(0):14.361|14.406, 60(16):19.999|32.602
290, 695(183):7.802|9.971, 695(0):1.673|3.705, 70(0):0.753|0.969, 69(0):10.170|10.787, 69(9):19.999|23.973
300, 756(213):7.334|9.825, 752(0):1.620|3.822, 76(0):0.704|0.710, 75(0):9.623|11.539, 76(9):19.999|21.460
310, 727(254):7.609|9.025, 729(0):1.908|2.261, 72(0):0.980|1.791, 73(0):10.384|11.064, 72(14):19.999|26.970
根据输出的内容，
./tpcc_start命令执行了 TPC-C 测试的加载和性能测量过程。test0.out文件中记录了tpcc_start命令执行过程中的输出信息，包括测试参数、测试进度、性能指标等。以下是输出内容的解析：
首部显示了 TPC-C 测试的相关信息，包括测试名称 “TPC-C Load Generator”，以及使用的选项和参数。
部分列出了使用的测试参数，包括服务器地址、端口、数据库名称、用户名、密码、仓库数量、并发连接数、热身时间和测试时间。接下来是测试的执行过程，每行表示一个时间点的测试结果。例如，第一行 “RAMP-UP TIME.(300 sec.)” 表示热身时间为 300 秒，即系统在这段时间内预热。之后，每行显示了一系列的性能指标，例如各个仓库的交易成功率、平均响应时间等。具体的指标含义可能需要查阅 TPCC-MYSQL 的文档或者相关资料。
最后，测试执行完成，可能会显示测试的总体结果或者总结性信息。
根据输出内容，您可以了解到测试的进度和性能指标。如果需要更详细的测试结果，建议查阅生成的日志文件和报告文件，它们通常包含更全面的测试结果和详细的性能指标分析。
问题
-
slave导入数据的时候GTID问题，先不开启gtid功能，数据导入同步后，再开启gtid功能
-
Slave_IO_Running:no
原因是:slave上的GTIDs编号bimaster上的还大（意味着slave上的数据比，master还新），导致IO线程启动不成功
**解决的方法：**在所有slave上清除master信息和slave的信息
stop slave; reset master; reset slave all; start slave; show slave status\G;CHANGE MASTER TO MASTER_HOST='192.168.2.4' , MASTER_USER='slavede', MASTER_PASSWORD='123456', MASTER_PORT=3306, master_auto_position=1;CHANGE MASTER TO MASTER_HOST='192.168.2.3' , MASTER_USER='slave', MASTER_PASSWORD='123456', MASTER_PORT=3306, master_auto_position=1; -
配置延迟备份服务器，从slave1上来
可能出现操作上的不一致，需要看
show slave status进行操作.