Percona on F嘉阳

PXC系列学习笔记（七）——大数据归档——冷热数据分离

Mon, 30 Dec 2019 08:50:00 +0800

一、介绍

1. InnoDB写入慢的原因

采用BTREE索引，IO占用高

2. TokuDB优点

高压缩比（1:12，是InnoDB的14倍）,高写入性能（是InnoDB的10-20倍）
在线创建索引和字段
支持事物（写入性能是InnoDB的9-20倍）
支持主从同步

3. 归档规划

使用TokuDB引擎保存归档数据，拥有高速写入特性
使用双机热备方案搭建归档库，具备高可用性
使用pt-archiver执行数据归档，简便易行

二、安装TokuDB

安装jemlloc
```
yum install -y jemalloc 
```

编辑配置文件

vi /etc/my.cnf

……
[mysqld_safe]
malloc-lib=/usr/lib64/libjemalloc.so.1
……

重启MySQL
```
systemctl restart mysqld
```
开启Linux大页内存，同时开启内存碎片整理

linux系统默认在系统启动时进行内存分配，后续将不再管理内存
```
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag
```

安装TokuDB

yum install -y Percona-Server-tokudb-57.x86_64
ps-admin --enable -uroot -p

重启数据库再次执行安装

service mysqld restart
ps-admin --enable -uroot -p

提示引擎已经成功安装

查看安装结果
```
show engines ;
```

三、配置Replication集群

集群设计——双向同步Replication集群

原因：默认情况下Replication模式单向同步，若主库宕机，则向从库写入数据。若主库重新上线，则不会自动同步数据，导致数据不一致

架构图

replication集群同步原理

配置互为主从的replication集群

在两个TokuDB数据库上创建用户

CREATE USER 'tokubackup'@'%' IDENTIFIED BY 'Abc_123456' ;

GRANT super, reload, replication slave ON *.* TO 'tokubackup'@'%' ;

FLUSH PRIVILEGES ;

修改两个TokuDB的配置文件/etc/my.cnf，如下：

[mysqld]
server_id = 101
log_bin = mysql_bin
relay_log = relay_bin
……

[mysqld]
server_id = 102
log_bin = mysql_bin
relay_log = relay_bin

重新启动两个TokuDB节点
```
service mysqld restart
```

分别在两个TokuDB上执行下面4句SQL

当前数据库架构，首先让B节点向A节点同步数据

graph LR
 A节点-->B节点;
 subgraph Master
 A节点
 end
 subgraph Slave
 B节点
 end

在B节点执行语句

#关闭同步服务
stop slave;
#设置同步的Master节点
change master to master_host="pxc1",master_port=3306,master_user="backup",
master_password="Abc_123456";
#启动同步服务
start slave;
#查看同步状态
show slave status;

执行结果

当如下两个字段为yes，则说明主从同步已经开启

在A节点启动主从同步

#关闭同步服务
stop slave;
#设置同步的Master节点
change master to master_host="pxc8",master_port=3306,master_user="backup",
master_password="Abc_123456";
#启动同步服务
start slave;
#查看同步状态
show slave status;


 执行结果

 ![image-20191230111537571](https://gitea.fjy8018.top/fjy8018/images/raw/branch/blog/img/image-20191230111537571.png)

## 四、创建归档表

通常按年份定义归档表分表名称，选择任意一个节点执行即可，此处选择在PXC1节点上执行

```mysql
CREATE DATABASE test;
USE test;
CREATE TABLE t_purchase_20191230 (
	id INT UNSIGNED PRIMARY KEY,
	purchase_price DECIMAL(10,2) NOT NULL,
	purchase_num INT UNSIGNED NOT NULL,
	purchase_sum DECIMAL (10,2) NOT NULL,
	purchase_buyer INT UNSIGNED NOT NULL,
	purchase_date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
	company_id INT UNSIGNED NOT NULL,
	goods_id INT UNSIGNED NOT NULL,
	KEY idx_company_id(company_id),
	KEY idx_goods_id(goods_id)
)engine=TokuDB;

在PXC8节点上也看到了新增的数据表

五、配置Haproxy+Keepalived双机热备

在两个节点上安装Haproxy，此处使用之前搭建的两个节点Haproxy
```
yum install -y haproxy
```

修改配置文件

vi /etc/haproxy/haproxy.cfg

global
 log 127.0.0.1 local2

 chroot /var/lib/haproxy
 pidfile /var/run/haproxy.pid
 maxconn 4000
 user haproxy
 group haproxy
 daemon

 stats socket /var/lib/haproxy/stats

defaults
 mode http
 log global
 option httplog
 option dontlognull
 option http-server-close
 option forwardfor except 127.0.0.0/8
 option redispatch
 retries 3
 timeout http-request 10s
 timeout queue 1m
 timeout connect 10s
 timeout client 1m
 timeout server 1m
 timeout http-keep-alive 10s
 timeout check 10s
 maxconn 3000

listen admin_stats 
 bind 0.0.0.0:4001
 mode http
 stats uri /dbs
 stats realm Global\ statistics
 stats auth admin:Abc%6870

listen proxy_mysql
 bind 0.0.0.0:13306 
 mode tcp 
 balance roundrobin
 option tcplog
 server mycat_1 192.168.1.33:8066 check port 8066 weight 1 maxconn 2000 
 server mycat_2 192.168.1.36:8066 check port 8066 weight 1 maxconn 2000 
 option tcpka
# 新增配置 
listen proxy_mysql_backup
 bind 0.0.0.0:13307 
 mode tcp 
 balance roundrobin
 option tcplog #日志格式
 server backup_1 pxc1:3306 check port 3306 maxconn 2000 
 server backup_2 pxc8:3306 check port 3306 maxconn 2000 
 option tcpka #使用keepalive检测死链

重启Haproxy

开启防火墙的VRRP协议

firewall-cmd --direct --permanent --add-rule ipv4 filter INPUT 0 --protocol vrrp -j ACCEPT

firewall-cmd --reload

查看配置结果

在两个节点上安装Keepalived，此处复用之前的Keepalived

六、准备归档数据

在两个PXC分片上创建进货表，默认是InnoDB引擎

CREATE TABLE t_purchase (
	id INT UNSIGNED PRIMARY KEY,
	purchase_price DECIMAL(10,2) NOT NULL,
	purchase_num INT UNSIGNED NOT NULL,
	purchase_sum DECIMAL (10,2) NOT NULL,
	purchase_buyer INT UNSIGNED NOT NULL,
	purchase_date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
	company_id INT UNSIGNED NOT NULL,
	goods_id INT UNSIGNED NOT NULL,
	KEY idx_company_id(company_id),
	KEY idx_goods_id(goods_id)
)

配置MyCat的schema.xml文件，并重启MyCat
```
<table name="t_purchase" dataNode="dn1,dn2" rule="mod-long" />
```
使用Java程序导入10万条测试数据，由mycat路由到两个分片中

测试数据的时间为2019年11月21日

七、执行数据归档

pt-archiver用途：

导出线上数据,到线下数据作处理
清理过期数据,并把数据归档到本地归档表中,或者远端归档服务器

安装pt-archiver
```
yum install -y percona-toolkit
```

查看版本

$ pt-archiver --version
pt-archiver 3.1.0

执行数据归档

--bulk-delete --bulk-insert表示对源库批量删除，对归档库批量导入，该归档过程包含事务，故不会导致数据丢失

pt-archiver --source h=192.168.1.9,P=13306,u=admin,p='password',D=test,t=t_purchase --dest h=192.168.1.9,P=13307,u=admin,p='password',D=test,t=t_purchase_20191230 --no-check-charset --where 'purchase_date<"2019-11-30 00:00:00"' --progress 5000 --bulk-delete --bulk-insert --limit=10000 --statistics

迁移结果

查询源库，记录已全部迁移

查询归档库

PXC系列学习笔记（六）——Java千万数据量导入和查询优化

Mon, 30 Dec 2019 08:49:04 +0800

一、介绍

通用导入方法：数据量大应当使用load data方式导入，而不是使用source sql文件的方式

此处为了验证PXC集群性能，需要创造一千万条数据进行SQL语句性能测试

二、数据生成

若对数据内容无要求，则可使用通用工具生成随机数据，此处面向具体业务场景，故使用Java应用程序生成数据

1. 创建SpringBoot工程

使用SpringBoot快速创建数据导入工程，引入jdbc和jpa依赖

...
<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.2.2.RELEASE</version>
 <relativePath/> <!-- lookup parent from repository -->
</parent>
...
<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 <exclusions>
 <exclusion>
 <groupId>org.junit.vintage</groupId>
 <artifactId>junit-vintage-engine</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
</dependencies>

2. 编写实体类

package top.fjy8018.jdbcbench;

/**
 * @author F嘉阳
 * @date 2019-12-28 13:08
 */
@Entity(name = "tb_test")
@Data
public class DBTest {

 @Id
 private Integer id;

 private String name;
}

实现JPA接口

package top.fjy8018.jdbcbench;

/**
 * @author F嘉阳
 * @date 2019-12-28 13:09
 */
public interface DBTestRepository extends JpaRepository<DBTest,Integer> {}

3. 配置JDBC连接

此处有个重要配置，就是rewriteBatchedStatements=true，加上该配置，批量写入数据的性能能提升数百倍。

参考资料：jdbcTemplate.batchUpdate在批量执行的时候，性能差没有效果，看看怎么解决的。

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: admin
 password: password
 url: jdbc:mysql://192.168.1.9:13306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&rewriteBatchedStatements=true&serverTimezone=Asia/Shanghai
 jpa:
 properties:
 hibernate:
 jdbc:
 batch_size: 10000
 order_inserts: true
 generate_statistics: true

4.准备数据库

每个PXC分片只开启一个节点，导入一个节点中则不会产生限流，导入完成后拷贝数据文件到其他节点再启动即可

修改PXC节点文件，然后重启PXC服务

## 不等待事务提交先写入硬盘
innodb_flush_log_at_trx_commit = 0
## 日志数据直接写入磁盘，不进入日志缓冲区
innodb_flush_method = O_DIRECT
## 缓存越大越好
innodb_buffer_pool_size = 200M

创建t_test数据表

CREATE TABLE tb_test(
	id INT UNSIGNED PRIMARY KEY,
 name VARCHAR(200) NOT NULL
);

配置MyCat

<table name="t_test" dataNode="dn1,dn2" rule="mod-long" />

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
 <!--配置虚拟逻辑数据表-->
 <schema name="test" checkSQLschema="false" sqlMaxLimit="100">
 <table name="t_user" dataNode="dn1,dn2" rule="mod-long" />
 <table name="tb_test" dataNode="dn1,dn2" rule="mod-long" />
 <table name="t_customer" dataNode="dn1,dn2" rule="sharding-customer">
 <childTable name="t_orders" primaryKey="ID" joinKey="customer_id" parentKey="id"/>
 </table>
 </schema>
 <!--配置分片关系-->
 <dataNode name="dn1" dataHost="cluster1" database="test" />
 <dataNode name="dn2" dataHost="cluster2" database="test" />
 <!--配置连接信息-->
 <dataHost name="cluster1" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1"
 slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!--多数情况 读多写少-->
 <writeHost host="W1" url="pxc4:3306" user="admin"
 password="admin">
 </writeHost>
 </dataHost>
 <dataHost name="cluster2" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1"
 slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!--多数情况 读多写少-->
 <writeHost host="W1" url="pxc7:3306" user="admin"
 password="admin">
 </writeHost>
 </dataHost>
</mycat:schema>

5.编写单元测试

package top.fjy8018.jdbcbench;

@Slf4j
@Component
class JdbcBenchTest extends JdbcBenchApplicationTests{

 @Autowired
 private DBTestRepository repository;

 @Autowired
 private JdbcTemplate jdbcTemplate;

 @Test
 public void insertTest(){
 DBTest t = new DBTest();
 t.setId(1);
 t.setName(1+"，测试实体");
 DBTest save = repository.save(t);
 Assert.notNull(save,"保存测试失败");
 }

 @Test
 public void insertData() throws Exception {
 for (int i = 1; i <= 10000000;) {
 List<DBTest> tests = new LinkedList<>();
 for (int j = 1; j <= 50000; j++) {
 DBTest t = new DBTest();
 t.setId(j+i);
 t.setName(j+i+"，测试实体");
 tests.add(t);
 }
 i = i+50000;
 log.info("插入{}条数据",i);
 batchInsert(tests);
 tests.clear();
 }
 }

 @Transactional
 public void batchInsert(List<DBTest> dbTestList) {
 String sql = "insert into tb_test(id,name) values(?,?)";
 log.info("批次大小：{}",dbTestList.size());
 jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
 public void setValues(PreparedStatement ps, int i) throws SQLException {
 String name = dbTestList.get(i).getName();
 int id = dbTestList.get(i).getId();
 ps.setInt(1, id);
 ps.setString(2, name);
 }
 public int getBatchSize() {
 return dbTestList.size();
 }
 });
 }
}

执行单元测试，大约1小时写入完成，不同服务器配置写入性能差距明显，应当以实际为准

三、数据导入后的操作

关闭PXC节点(还原配置文件)
拷贝数据文件到其他PXC节点
关闭 MyCat(还原配置文件)
启动PC和 MyCat

四、大数据性能测试——limit关键字

SELECT id, name FROM tb_test LIMIT 100, 100;
SELECT id, name FROM tb_test LIMIT 10000, 100;
SELECT id, name FROM tb_test LIMIT 1000000, 100;
SELECT id, name From tb_test LIMIT 5000000, 100;

现象：执行最后一条sql语句时速度慢，且cpu和内存占用率极大，主要对mycat节点内存占用一直居高不下

分析索引使用情况，rows字段显示其操作了4746302条数据，走全表扫描

id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
1	SIMPLE	tb_test		ALL					4746302	100

原因：

全表扫描,速度极慢
limit语句的查询时间与起始记录的位置成正比
mysql limit的语句是很方便,但是对记录很多的表并不适合直接使用

PXC系列学习笔记（五）——Sysbench基准测试

Mon, 30 Dec 2019 08:48:05 +0800

一、介绍

为了检测当前搭建的PXC集群性能，需要执行基准测试，看是否符合性能指标，并对sql进行针对性优化

二、安装Sysbench

选择集群以外的节点安装测试工具，保证测试的准确性，并且能与集群在网络上互通。

本次选择的机器配置如下，且位于同一内网网段，网络影响因素几乎忽略不计

名称	IP	CPU	内存	磁盘
Sysbench	192.168.1.24	2	12G	20G

在线安装

curl -s https://packagecloud.io/install/repositories/akopytov/sysbench/script.rpm.sh | sudo bash

 yum -y install sysbench

本地安装

下载压缩文件

https://codeload.github.com/akopytov/sysbench/zip/1.0

安装依赖包

yum install -y automake libtool
yum install -y mysql-devel

执行安装

#cd sysbench
./autogen.sh 
./configure 
make
make install
sysbench --version

执行测试

参数介绍

参数名称	功能意义
-oltp-test-mode	执行模式(simple只测试查询、nontrx无事务、complex有事务)
-oltp-tables-count	测试表的数量
-oltp-table-size	测试表的记录数
-threads	并发连接数
-time	测试执行时间（秒）
-report-interval	生成报告单的间隔时间（秒）

COMMAND 命令

参数名称	功能意义
prepare	准备测试数据
run	执行测试
cleanUD	清除测试数据

准备测试库，手动连接到pxc集群，创建名为sbtest的测试库

sysbench /usr/share/sysbench/tests/include/oltp_legacy/oltp.lua --mysql-host=192.168.1.9 --mysql-port=3306 --mysql-user=admin --mysql-password=Abc_123456 --oltp-tables-count=10 --oltp-table-size=100000 prepare

执行测试

sysbench /usr/share/sysbench/tests/include/oltp_legacy/oltp.lua --mysql-host=192.168.1.9 --mysql-port=3306 --mysql-user=admin --mysql-password=Abc_123456 --oltp-test-mode=complex --threads=10 --time=300 --report-interval=10 run >> /home/mysysbench.log

5分钟压测结果

SQL statistics:
 queries performed:
 read: 1122604
 write: 307573
 other: 160792
 total: 1590969
 transactions: 72545 (241.79 per sec.)
 queries: 1590969 (5302.59 per sec.)
 ignored errors: 7641 (25.47 per sec.)
 reconnects: 0 (0.00 per sec.)

General statistics:
 total time: 300.0339s
 total number of events: 72545

Latency (ms):
 min: 10.26
 avg: 41.35
 max: 2246.45
 95th percentile: 78.60
 sum: 2999916.73

Threads fairness:
 events (avg/stddev): 7254.5000/602.52
 execution time (avg/stddev): 299.9917/0.01

清理数据

sysbench /usr/share/sysbench/tests/include/oltp_legacy/oltp.lua --mysql-host=192.168.1.9 --mysql-port=3306 --mysql-user=admin --mysql-password=Abc_123456 --oltp-tables-count=10 cleanup

修改haproxy，跳过mycat，直接对pxc集群进行测试

listen proxy_mysql
 bind 0.0.0.0:13306
 mode tcp
 balance roundrobin
 option tcplog
 server pxc_1 192.168.1.32:3306 check port 3306 weight 1 maxconn 2000
 server pxc_2 192.168.1.33:3306 check port 3306 weight 1 maxconn 2000
 server pxc_3 192.168.1.35:3306 check port 3306 weight 1 maxconn 2000
 option tcpka

结果

推荐测试配置：

数据表建议不低于10个,单表数据量不低于500万行。如果是配备了SSD或者 PCIE SSD的话,则建议单表数据量最少不低于1亿行，测试时间应当在24小时以上

PXC系列学习笔记（四）——搭建双机热备的MyCat集群

Mon, 30 Dec 2019 08:46:37 +0800

一、介绍

目前已经搭建好了2套PXC集群，使用了单台mycat进行数据路由，在数据库层实现了高可用，但若mycat宕机，后端数据库依然无法使用，故还需要搭建多一台mycat，结合HAProxy和Keepalived实现负载均衡、双机热备。

二、集群架构

三、搭建

服务器资源规划如下

名称	IP	CPU	内存	磁盘	服务
pxc3	192.168.1.33	1	2G	40G	mycat
pxc4	192.168.1.35	1	2G	40G	haproxy、Keepalived
pxc5	192.168.1.36	1	2G	40G	mycat
pxc6	192.168.1.37	1	2G	40G	haproxy、Keepalived

1. 安装mycat集群

用两个虚拟机实例，各自部署MyCat，采用相同配置

2. 安装Haproxy集群

用一个虚拟机实例部署Haproxy

安装Haproxy，需要开放两个端口，3306（TCP转发），4001（监控界面）
```
$ yum install -y haproxy
```

编辑配置文件

$ vi /etc/haproxy/haproxy.cfg

由于该节点同时也运行了PXC数据库，3306端口已经占用，故使用13306端口

global
 log 127.0.0.1 local2

 chroot /var/lib/haproxy
 pidfile /var/run/haproxy.pid
 maxconn 4000
 user haproxy
 group haproxy
 daemon

 stats socket /var/lib/haproxy/stats

defaults
 mode http
 log global
 option httplog
 option dontlognull
 option http-server-close
 option forwardfor except 127.0.0.0/8
 option redispatch
 retries 3
 timeout http-request 10s
 timeout queue 1m
 timeout connect 10s
 timeout client 1m
 timeout server 1m
 timeout http-keep-alive 10s
 timeout check 10s
 maxconn 3000

listen admin_stats 
 bind 0.0.0.0:4001
 mode http
 stats uri /dbs
 stats realm Global\ statistics
 stats auth admin:Abc%6870

listen proxy_mysql
 bind 0.0.0.0:13306 
 mode tcp 
 balance roundrobin
 option tcplog
 server mycat_1 192.168.1.33:8066 check port 8066 weight 1 maxconn 2000 
 server mycat_2 192.168.1.36:8066 check port 8066 weight 1 maxconn 2000 
 option tcpka

启动Haproxy
```
$ service haproxy start
```
访问Haproxy监控画面

http://192.168.1.35:4001/dbs

用另外一个虚拟机同样按照上述操作安装Haproxy

3. 安装Keepalived集群

在某个Haproxy虚拟机实例上部署Keepalived

开启防火墙的VRRP协议

#开启VRRP
firewall-cmd --direct --permanent --add-rule ipv4 filter INPUT 0 --protocol vrrp -j ACCEPT
# iptable配置
iptables -I INPUT -p vrrp -j ACCEPT

#应用设置
firewall-cmd --reload

安装Keepalived
```
yum install -y keepalived
```

编辑配置文件

vi /etc/keepalived/keepalived.conf

vrrp_instance VI_1 {
 state MASTER # 争抢虚拟IP，若不争抢，则设置为slave
 interface ens192
 virtual_router_id 51 # 唯一ID，范围0-255
 priority 100 # 抢占权重
 advert_int 1 # 心跳检测间隔时间
 authentication { # 心跳检测账户和密码
 auth_type PASS
 auth_pass 123456
 }
 virtual_ipaddress {
 192.168.1.9 # 新虚拟IP
 }
}

启动Keepalived
```
$ systemctl start keepalived
```
在两台Keepalived节点上ping虚拟IP，看是否已经创建并可以访问
```
$ ping 192.168.1.9
```

在另外一个Haproxy虚拟机上，按照上述方法部署Keepalived
使用MySQL客户端连接192.168.1.9，执行增删改查数据

PXC系列学习笔记（三）——MyCat安装和读写分离配置

Mon, 30 Dec 2019 08:45:00 +0800

一. 介绍

由于每个PXC集群有3个节点，故需要使用mycat进行读写分离，分摊单个节点的读写压力。

同时由于有两套PXC集群，故需要针对不同表采用不同分片算法进行数据路由。

因为mycat不支持跨分片表连接，还需要配置父子表等，让需要表连接操作的数据路由到同一个分片中。

二. JDK安装与配置

安装JDK

#搜索JDK版本
yum search jdk 
#安装JDK1.8开发版
yum install java-1.8.0-openjdk-devel.x86_64

配置环境变量

#查看JDK安装路径
ls -lrt /etc/alternatives/java
vi /etc/profile
#在文件结尾加上JDK路径
JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.232.b09-0.el7_7.x86_64/
PATH=$JAVA_HOME/bin:$PATH
export PATH JAVA_HOME

source /etc/profile

三. 创建数据表

创建两套PXC集群，每套3台机器

在两组PXC集群中分别创建t_user数据表

CREATE TABLE t_user
(
 id INT(10) UNSIGNED NOT NULL,
 username VARCHAR(200) NOT NULL,
 password VARCHAR(200) NOT NULL,
 tel CHAR(11) NOT NULL,
 locked TINYINT(1) UNSIGNED NULL,
 PRIMARY KEY (ID) USING BTREE,
 INDEX `idx_username` (`username`) USING BTREE,
 UNIQUE INDEX `unq_username` (`username`) USING BTREE
) COMMENT 'pxc测试表';

四、MyCat安装与配置

下载MyCat

http://dl.mycat.io/1.6.5/Mycat-server-1.6.5-release-20180122220033-linux.tar.gz
上传MyCat压缩包到虚拟机

安装unzip程序包，解压缩MyCat

yum install unzip
unzip MyCAT压缩包名称

开放防火墙8066和9066端口，关闭SELINUX
修改MyCat的bin目录中所有.sh文件的权限
```
chmod -R 777 ./*.sh
```

MyCat启动与关闭

#cd MyCat的bin目录
./startup_nowrap.sh #启动MyCat
ps -aux #查看系统进程
kill -9 MyCat进程编号

mycat配置文件解析

文件	作用	修改内容
rule.xml	切分算法	修改mod-long分片数量为2
server.xml	虚拟MySQL	修改用户名、密码和逻辑库
scnema．Xml	数据库连接、读写分离、负载均衡、数据表映射	定义连接、读写分离、负载均衡、数据表映射

修改server.xml文件，设置MyCat帐户和虚拟逻辑库

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
 	<system>
 		<property name="nonePasswordLogin">0</property>
 		<property name="useHandshakeV10">1</property>
 		<property name="useSqlStat">0</property>
 		<property name="useGlobleTableCheck">0</property>
 		<property name="sequnceHandlerType">2</property>
 		<property name="subqueryRelationshipCheck">false</property>
 		<property name="processorBufferPoolType">0</property>
 		<property name="handleDistributedTransactions">0</property>
 		<property name="useOffHeapForMerge">1</property>
 	<property name="memoryPageSize">64k</property>
 		<property name="spillsFileBufferSize">1k</property>
 		<property name="useStreamOutput">0</property>
 		<property name="systemReserveMemorySize">384m</property>
 		<property name="useZKSwitch">false</property>
 	</system>
 <!--这里是设置的admin用户和虚拟逻辑库-->
 	<user name="admin" defaultAccount="true">
 		<property name="password">Abc_123456</property>
 		<property name="schemas">test</property>
 	</user>
</mycat:server>

修改schema.xml文件，设置数据库连接和虚拟数据表

此处有两个分片，则配置两个dataHost

重点配置介绍

1. balance 属性

负载均衡类型，目前的取值有 3 种：

balance=“0”, 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。
balance=“1”，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡，简单的说，当双主双从模式(M1->S1，M2->S2，并且 M1 与 M2 互为主备)，正常情况下，M2,S1,S2 都参与 select 语句的负载均衡。
balance=“2”，所有读操作都随机的在 writeHost、readhost 上分发。防止写节点浪费
balance=“3”，所有读请求随机的分发到 wiriterHost 对应的 readhost 执行，writerHost 不负担读压力，注意 balance=3 只在 1.4 及其以后版本有，1.3 没有。

2. writeType 属性

负载均衡类型，目前的取值有 3 种：

writeType=“0”, 所有写操作发送到配置的第一个 writeHost，第一个挂了切到还生存的第二个 writeHost，重新启动后已切换后的为准，切换记录在配置文件中:dnindex.properties .
writeType=“1”，所有写操作都随机的发送到配置的 writeHost，1.5 以后废弃不推荐。

3. switchType 属性

-1 表示不自动切换。
1 默认值，自动切换。
2 基于 MySQL 主从同步的状态决定是否切换。

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
 	<!--配置虚拟逻辑数据表-->
 	<schema name="test" checkSQLschema="false" sqlMaxLimit="100">
 		<table name="t_user" dataNode="dn1,dn2" rule="mod-long" />
 	</schema>
 	<!--配置分片关系-->
 	<dataNode name="dn1" dataHost="cluster1" database="test" />
 	<dataNode name="dn2" dataHost="cluster2" database="test" />
 	<!--配置连接信息-->
 	<dataHost name="cluster1" maxCon="1000" minCon="10" balance="2" 
 writeType="0" dbType="mysql" dbDriver="native" switchType="1" 
 slaveThreshold="100">
 		<heartbeat>select user()</heartbeat>
 		<!--多数情况 读多写少-->
 		<writeHost host="W1" url="pxc2:3306" user="admin" 
 password="password">
 			<readHost host="W1R1" url="pxc3:3306" user="admin" 
 password="password" />
 			<readHost host="W1R2" url="pxc4:3306" user="admin" 
 password="password" />
 		</writeHost>
 		<!--写节点冗余-->
 		<writeHost host="W2" url="pxc3:3306" user="admin" 
 password="password">
 			<readHost host="W2R1" url="pxc2:3306" user="admin" 
 password="password" />
 			<readHost host="W2R2" url="pxc4:3306" user="admin" 
 password="password" />
 		</writeHost>
 	</dataHost>
 	<dataHost name="cluster2" maxCon="1000" minCon="10" balance="2" 
 writeType="0" dbType="mysql" dbDriver="native" switchType="1" 
 slaveThreshold="100">
 		<heartbeat>select user()</heartbeat>
 		<!--多数情况 读多写少-->
 		<writeHost host="W1" url="pxc5:3306" user="admin" 
 password="password">
 			<readHost host="W1R1" url="pxc6:3306" user="admin" 
 password="password" />
 			<readHost host="W1R2" url="pxc7:3306" user="admin" 
 password="password" />
 		</writeHost>
 		<!--写节点冗余-->
 		<writeHost host="W2" url="pxc6:3306" user="admin" 
 password="password">
 			<readHost host="W2R1" url="pxc5:3306" user="admin" 
 password="password" />
 			<readHost host="W2R2" url="pxc7:3306" user="admin" 
 password="password" />
 		</writeHost>
 	</dataHost>
</mycat:schema>

修改rule.xml文件，把mod-long的count值修改成2

<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
	<property name="count">2</property>
</function>

放行端口

8066：数据服务

9066：管理端口

重启MyCat

$ ./startup_nowrap.sh

关闭命令：

$ ps -aux | grep mycat
$ kill $PID

向t_user表写入数据，感受数据的切分

USE test;
select * from t_user;
#第一条记录被切分到第二个分片
INSERT INTO t_user(id,username,password,tel,locked) VALUES(1,"A",HEX(AES_ENCRYPT('123456','HelloWorld')),"12345678901",false);
#第二条记录被切分到第一个分片
INSERT INTO t_user(id,username,password,tel,locked) VALUES(2,"B",HEX(AES_ENCRYPT('123456','HelloWorld')),"12345678912",false);

五、配置数据分片和父子表

1. 数据切分算法

切分算法	适用场合	备注
主键求模切分	数据增长速度慢,难于增加分片	有明确主键值
枚举值切分	归类存储数据,适合大多数业务
主键范围切分	数据快速增长,容易增加分片	有明确主键值
日期切分	数据快速增长,容易增加分片

（1）主键求模切分

求模切分适合用在初始数据很大,但是数据增长不快的场景
求模切分的弊病在于扩展新分片难度大,迁移的数据太多
建议扩张后的分片数是原有分片的2n倍

（2）枚举值切分

按照某个字段的值（数字）来切分数据

2. 数据分片

在conf目录下创建customer-hash-int文件，内容如下：
```
101=0
102=0
103=0
104=1
105=1
106=1
```

在rule.xml文件中加入自定义和

<function name="customer-hash-int"
		class="io.mycat.route.function.PartitionByFileMap">
	<property name="mapFile">customer-hash-int.txt</property>
</function>

<tableRule name="sharding-customer">
	<rule>
		<columns>sharding_id</columns>
		<algorithm>customer-hash-int</algorithm>
	</rule>
</tableRule>

修改schema.xml文件，配置数据分片算法

<!--配置虚拟逻辑数据表-->
<schema name="test" checkSQLschema="false" sqlMaxLimit="100">
 <table name="t_user" dataNode="dn1,dn2" rule="mod-long" />
 <table name="t_customer" dataNode="dn1,dn2" rule="sharding-customer"/>
</schema>

重载mycat配置

使用navicat打开命令行界面，执行语句

reload @@config_all;

USE test;
CREATE TABLE t_customer(
	id INT UNSIGNED PRIMARY KEY,
 username VARCHAR(200) NOT NULL,
 sharding_id INT NOT NULL
);
select * from t_customer;
insert into t_customer(id, username, sharding_id) VALUES (1,'tom',101);
insert into t_customer(id, username, sharding_id) VALUES (2,'jetty',102);
insert into t_customer(id, username, sharding_id) VALUES (3,'tomcat',105);

第一个分片

第二个分片

查询mycat数据

3. 父子表

出现原因：在 MyCat中是不允许跨分片做表连接查询的

解决原理：部分业务总会可以抽象出父子关系的表。这类表适用于 ER 分片表，子表的记录与所关联的父表记录存放在同一个数据分片上，避免数据 Join 跨库操作

修改schema.xml文件，添加父子表定义。此处定义成父表t_customer允许分在不同分片，子表t_orders不允许跨分片。一个父表可以包含多个子表，子表也可嵌套多个子表。

<table name="t_customer" dataNode="dn1,dn2" rule="sharding-customer">
 <childTable name="t_orders" primaryKey="ID" joinKey="customer_id" parentKey="id"/>
</table>

重载mycat配置

使用navicat打开命令行界面，执行语句
```
reload @@config_all;
```

在MyCat上执行如下SQL：

USE test;
CREATE TABLE t_orders(
	id INT PRIMARY KEY,
 customer_id INT NOT NULL,
 datetime TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

向t_customer表和t_orders表写入数据，查看字表数据跟随父表切分到同一个分片

-- 预期写入第一个分片
insert into t_orders(id, customer_id) VALUES (1,1);
insert into t_orders(id, customer_id) VALUES (2,1);
insert into t_orders(id, customer_id) VALUES (3,1);
-- 预期写入第二个分片
insert into t_orders(id, customer_id) VALUES (4,2);
insert into t_orders(id, customer_id) VALUES (5,3);

分片一t_customer查询结果

分片一t_orders查询结果

分片二t_customer查询结果

分片二t_orders查询结果

同一个客户订单和客户信息都存在相同分片中，结果符合预期

连接查询测试

select c.username,t.id,t.datetime from t_customer c join t_orders t on c.id = t.customer_id

PXC系列学习笔记（二）——PXC集群安装配置

Mon, 30 Dec 2019 08:42:07 +0800

1. 介绍

PXC集群具有强一致性特点，用于需要多节点一致性的业务，例如金融系统、交易、支付系统、库存系统等

本次计划搭建PXC集群使用两个分片，每个分片3个节点组成一个PXC集群

名称	IP	CPU	内存	磁盘
pxc2	192.168.1.32	1	2G	40G
pxc3	192.168.1.33	1	2G	40G
pxc4	192.168.1.35	1	2G	40G
pxc5	192.168.1.36	1	2G	40G
pxc6	192.168.1.37	1	2G	40G
pxc7	192.168.1.38	1	2G	40G

2. 删除MariaDB程序包

$ yum -y remove mari*

3. 开放防火墙端口

$ firewall-cmd --zone=public --add-port=3306/tcp --permanent
$ firewall-cmd --zone=public --add-port=4444/tcp --permanent
$ firewall-cmd --zone=public --add-port=4567/tcp --permanent
$ firewall-cmd --zone=public --add-port=4568/tcp --permanent

4. 关闭SELINUX

vi /etc/selinux/config

把SELINUX属性值设置成disabled

reboot

5. 离线安装PXC（推荐）

进入官网下载5.7版本的Percona，注意，此处下载的是集群版本，下载后分发到所有集群节点执行相同的安装和配置操作

进入RPM文件目录，执行安装命令
```
$ yum localinstall *.rpm
```
参考前一篇内容，修改MySQL配置文件、创建账户等操作

6. 创建PXC集群

停止MySQL服务

修改每个PXC节点的/etc/my.cnf文件（在不同节点上，注意调整文件内容）

server-id=1 #PXC集群中MySQL实例的唯一ID，不能重复，必须是数字
wsrep_provider=/usr/lib64/galera3/libgalera_smm.so
wsrep_cluster_name=pxc-cluster #PXC集群的名称
wsrep_cluster_address=gcomm://pxc2,pxc3,pxc4
wsrep_node_name=pxc2 #当前节点的名称
wsrep_node_address=pxc2 #当前节点的IP
wsrep_sst_method=xtrabackup-v2 #同步方法（mysqldump、rsync、xtrabackup）
wsrep_sst_auth= admin:password #同步使用的帐户
pxc_strict_mode=ENFORCING #同步严厉模式
binlog_format=ROW #基于ROW复制（安全可靠）
default_storage_engine=InnoDB #默认引擎
innodb_autoinc_lock_mode=2 #主键自增长不锁表

主节点的管理命令（第一个启动的PXC节点）

$ systemctl start mysql@bootstrap.service
$ systemctl stop mysql@bootstrap.service
$ systemctl restart mysql@bootstrap.service

非主节点的管理命令（非第一个启动的PXC节点）

$ systemctl start mysql
$ systemctl stop mysql
$ systemctl restart mysql

查看PXC集群状态信息
```
show status like 'wsrep_cluster%' ;
```
按照上述配置方法，创建两组PXC集群

7. PXC节点启动与关闭

如果最后关闭的PXC节点是安全退出的，那么下次启动要最先启动这个节点，而且要以主节点启动
如果最后关闭的PXC节点不是安全退出的，那么要先修改/var/lib/mysql/grastate.dat 文件，把其中的safe_to_bootstrap属性值设置为1，再安装主节点启动

PXC系列学习笔记（一）——PXC单节点安装配置

Sun, 29 Dec 2019 20:03:00 +0800

本系列笔记是对慕课网课程的学习与总结MySQL数据库集群-PXC方案

Percona数据库介绍

官网 Percona官网

Percona数据库提供MySQL、MongoDB等衍生版本，在大数据、同步性能上做了大量优化

安装

Percona官方也有提供docker镜像，但为了方便学习，全使用云服务器安装Percona数据库，本次使用的机器配置为

CPU：1C
RAM：1G
DISK：40G

1. 离线安装Percona

安装前置环境

$ yum install https://repo.percona.com/yum/percona-release-latest.noarch.rpm -y
$ yum install qpress

进入官网下载5.7版本的Percona，注意，此处下载的是单机版本

进入RPM安装文件目录，执行下面的脚本
```
$ yum localinstall *.rpm
```

管理MySQL服务

$ systemctl enable mysqld
$ systemctl start mysqld
$ systemctl stop mysqld
$ systemctl restart mysqld

2. 在线安装Percona（不推荐）

在线安装不便于统一版本和多节点分发

使用yum命令安装

$ yum install https://repo.percona.com/yum/percona-release-latest.noarch.rpm
$ yum install Percona-Server-server-57

管理MySQL服务

$ service mysql start
$ service mysql stop
$ service mysql restart

3. 开放防火墙端口

$ firewall-cmd --zone=public --add-port=3306/tcp --permanent
$ firewall-cmd --reload

4. 修改MySQL配置文件

vi /etc/my.cnf

[mysqld]
character_set_server = utf8
bind-address = 0.0.0.0
#跳过DNS解析
skip-name-resolve

$ service mysql restart

5. 禁止开机启动MySQL

若某一节点宕机，其自动启动后会开始自动同步，若宕机时间过长，PXC集群会限制其他节点的写入操作，直到所有数据同步成功

宕机后科学做法：手动从其他节点中拷贝数据库文件，再启动，减少同步数据

$ chkconfig mysqld off

注意，关闭了开机启动后无法使用service mysql restart 命令启动数据库，需要使用下面的命令启动

$ service mysqld restart

6. 初始化MySQL数据库

查看MySQL初始密码

cat /var/log/mysqld.log | grep "A temporary password"

修改MySQL密码
```
mysql_secure_installation
```
修改过程全输入y，并录入密码

创建远程管理员账户

mysql -u root -p

CREATE USER 'admin'@'%' IDENTIFIED BY 'password';
GRANT all privileges ON *.* TO 'admin'@'%';
FLUSH PRIVILEGES;

Percona on F嘉阳

PXC系列学习笔记（七）——大数据归档——冷热数据分离

一、介绍

1. InnoDB写入慢的原因

2. TokuDB优点

3. 归档规划

二、 安装TokuDB

三、配置Replication集群

五、配置Haproxy+Keepalived双机热备

六、准备归档数据

七、执行数据归档

PXC系列学习笔记（六）——Java千万数据量导入和查询优化

一、介绍

二、数据生成

1. 创建SpringBoot工程

2. 编写实体类

3. 配置JDBC连接

4.准备数据库

5.编写单元测试

三、数据导入后的操作

四、大数据性能测试——limit关键字

PXC系列学习笔记（五）——Sysbench基准测试

一、介绍

二、安装Sysbench

执行测试

PXC系列学习笔记（四）——搭建双机热备的MyCat集群

一、介绍

二、集群架构

三、搭建

1. 安装mycat集群

2. 安装Haproxy集群

3. 安装Keepalived集群

PXC系列学习笔记（三）——MyCat安装和读写分离配置

一. 介绍

二. JDK安装与配置

三. 创建数据表

四、MyCat安装与配置

mycat配置文件解析

重点配置介绍

1. balance 属性

2. writeType 属性

3. switchType 属性

五、配置数据分片和父子表

1. 数据切分算法

（1）主键求模切分

（2）枚举值切分

2. 数据分片

3. 父子表

PXC系列学习笔记（二）——PXC集群安装配置

1. 介绍

2. 删除MariaDB程序包

3. 开放防火墙端口

4. 关闭SELINUX

5. 离线安装PXC（推荐）

6. 创建PXC集群

7. PXC节点启动与关闭

PXC系列学习笔记（一）——PXC单节点安装配置

Percona数据库介绍

安装

1. 离线安装Percona

2. 在线安装Percona（不推荐）

3. 开放防火墙端口

4. 修改MySQL配置文件

5. 禁止开机启动MySQL

6. 初始化MySQL数据库

二、安装TokuDB