Mycat2分库分表

一：Mycat介绍

1.1.什么是mycat

Mycat 是数据库中间件。数据库中间件：连接java应用程序和数据库
1、数据库中间件
中间件：是一类连接软件组件和应用的计算机软件，以便于软件各部件之间的沟通。
例子：Tomcat，web中间件。
2、为什么要用Mycat？
① Java与数据库紧耦合。
② 高访问量高并发对数据库的压力。
③ 读写请求数据不一致

1.2.能干什么

1.读写分离
2、数据分片
垂直拆分（分库）、水平拆分（分表）、垂直+水平拆分（分库分表）
3.多数据源整合

1.3.原理

Mycat 的原理中最重要的一个动词是“拦截”，它拦截了用户发送过来的 SQL 语句，首先对 SQL
语句做了一些特定的分析：如分片分析、路由分析、读写分离分析、缓存分析等，然后将此 SQL 发
往后端的真实数据库，并将返回的结果做适当的处理，最终再返回给用户。

二：安装使用mycat

1、解压后即可使用
解压缩文件拷贝到 linux 下 /usr/local/
2、三个配置文件
①schema.xml：定义逻辑库，表、分片节点等内容
②rule.xml：定义分片规则
③server.xml：定义用户以及系统相关变量，如端口等
3.启动
修改配置文件server.xml
修改用户信息，与MySQL区分，如下：

<user name="mycat">
 <property name="password">123456</property>
 <property name="schemas">TESTDB</property>
</user>
1
2
3
4

修改配置文件 schema.xml

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
 <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
 </schema>
 <dataNode name="dn1" dataHost="host1" database="testdb" />
 <dataHost name="host1" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1" 
slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!-- can have multi write hosts -->
 <writeHost host="hostM1" url="192.168.140.128:3306" user="root"
 password="123123">
 <!-- can have multi read hosts -->
 <readHost host="hostS1" url="192.168.140.127:3306" user="root" 
password="123123" />
 </writeHost>
 </dataHost>
</mycat:schema>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

验证数据库访问情况

mysql -uroot -p123123 -h 192.168.140.128 -P 3306
mysql -uroot -p123123 -h 192.168.140.127 -P 3306
#如远程访问报错，请建对应用户
grant all privileges on *.* to root@'缺少的host' identified by '123123';
1
2
3
4

4、启动程序
①控制台启动 ：去 mycat/bin 目录下执行 ./mycat console
②后台启动 ：去 mycat/bin 目录下 ./mycat start
为了能第一时间看到启动日志，方便定位问题，我们选择①控制台启动。
5.登录
mysql -umycat -p123456 -P 9066 -h 192.168.140.128
#常用命令如下：
show database

三：搭建读写分离

3.1mysql搭建一主一从

什么是一主一从：一个主机用于处理所有写请求，一台从机负责所有读请求
①Mysql主从复制
②.主机配置:

修改配置文件：vim /etc/my.cnf
#主服务器唯一ID
server-id=1
#启用二进制日志
log-bin=mysql-bin
# 设置不要复制的数据库(可设置多个)
binlog-ignore-db=mysql
binlog-ignore-db=information_schema
#设置需要复制的数据库
binlog-do-db=需要复制的主数据库名字
#设置logbin格式
binlog_format=STATEMENT
1
2
3
4
5
6
7
8
9
10
11
12

③ .从机配置

修改配置文件：vim /etc/my.cnf
#从服务器唯一ID
server-id=2
#启用中继日志
relay-log=mysql-relay
1
2
3
4
5

④ 主机、从机重启 MySQL 服务
⑤ 主机从机都关闭防火墙
⑥ 在主机上建立帐户并授权 slave
#在主机MySQL里执行授权命令
GRANT REPLICATION SLAVE ON . TO ‘slave’@‘%’ IDENTIFIED BY ‘123123’;
⑦ 在从机上配置需要复制的主机

主机使用查询master的状态
show master status;```

#复制主机的命令
CHANGE MASTER TO MASTER_HOST='主机的IP地址',
MASTER_USER='slave',
MASTER_PASSWORD='123123',
MASTER_LOG_FILE='mysql-bin.具体数字',MASTER_LOG_POS=具体值;
启动从服务器复制功能
start slave;
#查看从服务器状态
show slave status\G;


1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 修改 Mycat 的配置文件 schema.xml

//验证读写分离
（1）在写主机插入：insert into mytbl values (1,@@hostname);
主从主机数据不一致了
（2）在Mycat里查询：select * from mytbl
//修改<dataHost>的balance属性，通过此属性配置读写分离的类型
负载均衡类型，目前的取值有4 种：
（1）balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。
（2）balance="1"，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡，简单的说，当双主双从
模式(M1->S1，M2->S2，并且 M1 与 M2 互为主备)，正常情况下，M2,S1,S2 都参与 select 语句的负载均衡。
（3）balance="2"，所有读操作都随机的在 writeHost、readhost 上分发。
（4）balance="3"，所有读请求随机的分发到 readhost 执行，writerHost 不负担读压力
//为了能看到读写分离的效果，把balance设置成2，会在两个主机间切换查询
<dataHost name="host1" maxCon="1000" minCon="10" balance="2"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1" 
slaveThreshold="100">
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.2搭建双主双从

双主双从：一个主机 m1 用于处理所有写请求，它的从机 s1 和另一台主机 m2 还有它的从机 s2 负责所有读请
求。当 m1 主机宕机后，m2 主机负责写请求，m1、m2 互为备机。
1.搭建mysql数据库主从复制（双主双从）
① 双主机配置
Master1配置

修改配置文件：vim /etc/my.cnf
#主服务器唯一ID
server-id=1
#启用二进制日志
log-bin=mysql-bin
# 设置不要复制的数据库(可设置多个)
binlog-ignore-db=mysql
binlog-ignore-db=information_schema
#设置需要复制的数据库
binlog-do-db=需要复制的主数据库名字
#设置logbin格式
binlog_format=STATEMENT
# 在作为从数据库的时候，有写入操作也要更新二进制日志文件
log-slave-updates 
#表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535
auto-increment-increment=2 
# 表示自增长字段从哪个数开始，指字段一次递增多少，他的取值范围是1 .. 65535
auto-increment-offset=1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Master2配置

修改配置文件：vim /etc/my.cnf
#主服务器唯一ID
server-id=3
#启用二进制日志
log-bin=mysql-bin
# 设置不要复制的数据库(可设置多个)
binlog-ignore-db=mysql
binlog-ignore-db=information_schema
#设置需要复制的数据库
binlog-do-db=需要复制的主数据库名字
#设置logbin格式
binlog_format=STATEMENT
# 在作为从数据库的时候，有写入操作也要更新二进制日志文件
log-slave-updates 
#表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535
auto-increment-increment=2 
# 表示自增长字段从哪个数开始，指字段一次递增多少，他的取值范围是1 .. 65535
auto-increment-offset=2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

② 双从机配置
Slave1配置

修改配置文件：vim /etc/my.cnf
#从服务器唯一ID
server-id=2
#启用中继日志
relay-log=mysql-relay
1
2
3
4
5

Slave2配置

修改配置文件：vim /etc/my.cnf
#从服务器唯一ID
server-id=4
#启用中继日志
relay-log=mysql-relay
1
2
3
4
5

③ 双主机、双从机重启 mysql 服务
④ 主机从机都关闭防火墙
⑤ 在两台主机上建立帐户并授权 slave

#在主机MySQL里执行授权命令
GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' IDENTIFIED BY '123123';
#查询Master1的状态
show master status;
#查询Master2的状态
show master status;
#分别记录下File和Position的值
#执行完此步骤后不要再操作主服务器MYSQL，防止主服务器状态值变化
1
2
3
4
5
6
7
8

⑥ 在从机上配置需要复制的主机
Slava1 复制 Master1，Slava2 复制 Master2

#复制主机的命令
CHANGE MASTER TO MASTER_HOST='主机的IP地址',
MASTER_USER='slave',
MASTER_PASSWORD='123123',
MASTER_LOG_FILE='mysql-bin.具体数字',MASTER_LOG_POS=具体值;
启动两台从服务器复制功能
start slave;
#查看从服务器状态
show slave status\G;
1
2
3
4
5
6
7
8
9

Master2 复制 Master1，Master1 复制 Master2

启动两台主服务器复制功能
start slave;
#查看从服务器状态
show slave status\G;
1
2
3
4

2.修改 Mycat 的配置文件 schema.xml
修改的balance属性，通过此属性配置读写分离的类型

负载均衡类型，目前的取值有4 种：
（1）balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。
（2）balance="1"，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡，简单的说，当双主双从
模式(M1->S1，M2->S2，并且 M1 与 M2 互为主备)，正常情况下，M2,S1,S2 都参与 select 语句的负载均衡。
（3）balance="2"，所有读操作都随机的在 writeHost、readhost 上分发。
（4）balance="3"，所有读请求随机的分发到 readhost 执行，writerHost 不负担读压力
1
2
3
4
5
6

为了双主双从读写分离balance设置为1

<dataNode name="dn1" dataHost="host1" database="testdb" />
 <dataHost name="host1" maxCon="1000" minCon="10" balance="1"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1" 
slaveThreshold="100" >
 <heartbeat>select user()</heartbeat>
 <!-- can have multi write hosts -->
 <writeHost host="hostM1" url="192.168.140.128:3306" user="root"
 password="123123">
 <!-- can have multi read hosts -->
 <readHost host="hostS1" url="192.168.140.127:3306" user="root" 
password="123123" />
 </writeHost>
 <writeHost host="hostM2" url="192.168.140.126:3306" user="root"
 password="123123">
 <!-- can have multi read hosts -->
 <readHost host="hostS2" url="192.168.140.125:3306" user="root" 
password="123123" />
 </writeHost>
 </dataHost>
…
#balance="1": 全部的readHost与stand by writeHost参与select语句的负载均衡。
#writeType="0": 所有写操作发送到配置的第一个writeHost，第一个挂了切到还生存的第二个
#writeType="1"，所有写操作都随机的发送到配置的 writeHost，1.5 以后废弃不推荐
#writeHost，重新启动后以切换后的为准，切换记录在配置文件中:dnindex.properties 。
#switchType="1": 1 默认值，自动切换。
# -1 表示不自动切换
# 2 基于 MySQL 主从同步的状态决定是否切换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3、 启动 Mycat

四：垂直拆分——分库

垂直拆分：一个数据库由很多表的构成，每个表对应着不同的业务，垂直切分是指按照业务将表进行分类，
分布到不同 的数据库上面，这样也就将数据或者说压力分担到不同的库上面，
1.如何划分表
一个问题：在两台主机上的两个数据库中的表，能否关联查询？
答案：不可以关联查询。
分库的原则：有紧密关联关系的表应该在一个库里，相互没有关联关系的表可以分到不同的库里。

#客户表 rows:20万
CREATE TABLE customer(
 id INT AUTO_INCREMENT,
 NAME VARCHAR(200),
 PRIMARY KEY(id)
);
#订单表 rows:600万
CREATE TABLE orders(
 id INT AUTO_INCREMENT,
 order_type INT,
 customer_id INT,
 amount DECIMAL(10,2),
 PRIMARY KEY(id) 
); 
#订单详细表 rows:600万
CREATE TABLE orders_detail(
 id INT AUTO_INCREMENT,
 detail VARCHAR(2000),
 order_id INT,
 PRIMARY KEY(id)
);
#订单状态字典表 rows:20
CREATE TABLE dict_order_type(
 id INT AUTO_INCREMENT,
 order_type VARCHAR(200),
 PRIMARY KEY(id)
)
客户表分在一个数据库，另外三张都需要关联查询，分在另外一个数据库。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.实现分库
1.修改 schema 配置文件

<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
 <table name="customer" dataNode="dn2" ></table>
 </schema>
<dataNode name="dn1" dataHost="host1" database="orders" />
 <dataNode name="dn2" dataHost="host2" database="orders" />
 <dataHost name="host1" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1" 
slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!-- can have multi write hosts -->
 <writeHost host="hostM1" url="192.168.140.128:3306" user="root"
 password="123123">
 </writeHost>
 </dataHost>
 <dataHost name="host2" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1" 
slaveThreshold="100">
<heartbeat>select user()</heartbeat>
 <!-- can have multi write hosts -->
 <writeHost host="hostM2" url="192.168.140.127:3306" user="root"
 password="123123">
 </writeHost>
 </dataHost>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.新增两个空白库
分库操作不是在原来的老数据库上进行操作，需要准备两台机器分别安装新的数据库

#在数据节点 dn1、dn2 上分别创建数据库 orders
CREATE DATABASE orders;
1
2

4.启动 Mycat

./mycat console
1

5.访问 Mycat 进行分库

#访问 Mycat
mysql -umycat -p123456 -h 192.168.140.128 -P 8066
#切换到 TESTDB
#创建 4 张表
#查看表信息，可以看到成功分库
1
2
3
4
5

五：水平拆分——分表

水平拆分：水平拆分不是将表做分类，而是按照某个字段的某种规则来分散到多个库之中，
每个表中 包含一部分数据。简单来说，我们可以将数据的水平切分理解为是按照数据行的切分，就
是将表中的某些行切分 到一个数据库，而另外的某些行又切分到其他的数据库中
1. 实现分表
1.1 选择要拆分的表
MySQL 单表存储数据条数是有瓶颈的，单表达到 1000 万条数据就达到了瓶颈，会影响查询效率，
需要进行水平拆分（分表）进行优化。
例如：例子中的 orders、orders_detail 都已经达到 600 万行数据，需要进行分表优化。
2.分表字段

以 orders 表为例，可以根据不同自字段进行分表
编号 分表字段 效果
1 id（主键、或创建时间） 查询订单注重时效，历史订单被查询的次数少，如此
分片会造成一个节点访问多，一个访问少，不平均。
2 customer_id（客户 id） 根据客户 id 去分，两个节点访问平均，一个客户的所
有订单都在同一个节点
1
2
3
4
5
6

3、 修改配置文件 schema.xml

#为 orders 表设置数据节点为 dn1、dn2，并指定分片规则为 mod_rule（自定义的名字）
<table name="orders" dataNode="dn1,dn2" rule="mod_rule" ></table>
1
2

4、 修改配置文件 rule.xml

#在 rule 配置文件里新增分片规则 mod_rule，并指定规则适用字段为 customer_id，
#还有选择分片算法 mod-long（对字段求模运算），customer_id 对两个节点求模，根据结果分片
#配置算法 mod-long 参数 count 为 2，两个节点
<tableRule name="mod_rule">
 <rule>
 <columns>customer_id</columns>
 <algorithm>mod-long</algorithm>
 </rule>
 </tableRule>
…
<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
 <!-- how many data nodes -->
 <property name="count">2</property>
 </function>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5、 在数据节点 dn2 上建 orders 表
6、 重启 Mycat，让配置生效
7、 访问 Mycat 实现分片

#在 mycat 里向 orders 表插入数据，INSERT 字段不能省略
INSERT INTO orders(id,order_type,customer_id,amount) VALUES (1,101,100,100100);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(2,101,100,100300);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(3,101,101,120000);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(4,101,101,103000);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(5,102,101,100400);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(6,102,100,100020);
#在mycat、dn1、dn2中查看orders表数据，分表成功
1
2
3
4
5
6
7
8

六： 基于 HA 机制的 Mycat 高可用

1.高可用方案
我们可以使用 HAProxy + Keepalived 配合两台 Mycat 搭起 Mycat 集群，实现高可用性。HAProxy
实现了 MyCat 多节点的集群高可用和负载均衡，而 HAProxy 自身的高可用则可以通过 Keepalived 来
实现。

编号 角色 IP 地址 机器名
1 Mycat1 192.168.140.128 host79
2 Mycat2 192.168.140.127 host80
3 HAProxy（master） 192.168.140.126 host81
4 Keepalived（master） 192.168.140.126 host81
5 HAProxy（backup） 192.168.140.125 host82
6 Keepalived（backup） 192.168.140.125 host82
1
2
3
4
5
6
7

2.安装配置 HAProxy

#1准备好HAProxy安装包，传到/opt目录下
#2解压到/usr/local/src
tar -zxvf haproxy-1.5.18.tar.gz -C /usr/local/src
#3进入解压后的目录，查看内核版本，进行编译
cd /usr/local/src/haproxy-1.5.18
uname -r
make TARGET=linux310 PREFIX=/usr/local/haproxy ARCH=x86_64
# ARGET=linux310，内核版本，使用uname -r查看内核，如：3.10.0-514.el7，此时该参数就为linux310；
#ARCH=x86_64，系统位数；
#PREFIX=/usr/local/haprpxy #/usr/local/haprpxy，为haprpxy安装路径。
#4编译完成后，进行安装
make install PREFIX=/usr/local/haproxy
#5安装完成后，创建目录、创建HAProxy配置文件
mkdir -p /usr/data/haproxy/
vim /usr/local/haproxy/haproxy.conf
#6向配置文件中插入以下配置信息,并保存
global
 log 127.0.0.1 local0
 #log 127.0.0.1 local1 notice
 #log loghost local0 info
 maxconn 4096
 chroot /usr/local/haproxy
 pidfile /usr/data/haproxy/haproxy.pid
 uid 99
 gid 99
 daemon
 #debug
 #quiet
defaults
 log global
 mode tcp
 option abortonclose
 option redispatch
 retries 3
 maxconn 2000
 timeout connect 5000
 timeout client 50000
 timeout server 50000
listen proxy_status 
bind :48066
 mode tcp
 balance roundrobin
 server mycat_1 192.168.140.128:8066 check inter 10s
 server mycat_2 192.168.140.127:8066 check inter 10s
frontend admin_stats 
bind :7777
 mode http
 stats enable
 option httplog
 maxconn 10
 stats refresh 30s
 stats uri /admin
 stats auth admin:123123
 stats hide-version
 stats admin if TRU
//2、 启动验证
#1启动HAProxy
/usr/local/haproxy/sbin/haproxy -f /usr/local/haproxy/haproxy.conf
#2查看HAProxy进程
ps -ef|grep haproxy
#3打开浏览器访问
http://192.168.140.125:7777/admin

#在弹出框输入用户名：admin密码：123123
#如果Mycat主备机均已启动，则可以看到如下图
#4验证负载均衡，通过HAProxy访问Mycat
mysql -umycat -p123456 -h 192.168.140.126 -P 48066

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

3 配置 Keepalived

#1准备好Keepalived安装包，传到/opt目录下
#2解压到/usr/local/src
tar -zxvf keepalived-1.4.2.tar.gz -C /usr/local/src
#3安装依赖插件
yum install -y gcc openssl-devel popt-devel
#3进入解压后的目录，进行配置，进行编译
cd /usr/local/src/keepalived-1.4.2
./configure --prefix=/usr/local/keepalived
#4进行编译，完成后进行安装
make && make install
#5运行前配置
cp /usr/local/src/keepalived-1.4.2/keepalived/etc/init.d/keepalived /etc/init.d/
mkdir /etc/keepalived
cp /usr/local/keepalived/etc/keepalived/keepalived.conf /etc/keepalived/
cp /usr/local/src/keepalived-1.4.2/keepalived/etc/sysconfig/keepalived /etc/sysconfig/
cp /usr/local/keepalived/sbin/keepalived /usr/sbin/
#6修改配置文件
vim /etc/keepalived/keepalived.conf
#修改内容如下
! Configuration File for keepalived
global_defs {
 notification_email {
 xlcocoon@foxmail.com
 }
 notification_email_from keepalived@showjoy.com
 smtp_server 127.0.0.1
 smtp_connect_timeout 30
 router_id LVS_DEVEL
 vrrp_skip_check_adv_addr
 vrrp_garp_interval 0
 vrrp_gna_interval 0
}
vrrp_instance VI_1 {
 #主机配MASTER，备机配BACKUP
state MASTER
#所在机器网卡
 interface ens33
virtual_router_id 51
#数值越大优先级越高
 priority 100
 advert_int 1
 authentication {
 auth_type PASS
 auth_pass 1111
 }
virtual_ipaddress {
#虚拟IP
 192.168.140.200
 }
}
virtual_server 192.168.140.200 48066 {
 delay_loop 6
 lb_algo rr
 lb_kind NAT
 persistence_timeout 50
 protocol TCP
 real_server 192.168.140.125 48066 {
 weight 1
 TCP_CHECK {
 connect_timeout 3
 retry 3
 delay_before_retry 3
 }
}
real_server 192.168.140.126 48600 {
 weight 1
 TCP_CHECK {
 connect_timeout 3
 nb_get_retry 3
 delay_before_retry 3
 }
 }
}
2、 启动验证
#1启动Keepalived
service keepalived start
#2登录验证
mysql -umycat -p123456 -h 192.168.140.200 -P 48066

// 测试高可用
#1关闭mycat
#2通过虚拟ip查询数据
mysql -umycat -p123456 -h 192.168.140.200 -P 48066

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

七：Mycat 安全设置
user 标签权限控制
目前 Mycat 对于中间件的连接控制并没有做太复杂的控制，目前只做了中间件逻辑库级别的读
写权限控制。是通过 server.xml 的 user 标签进行配置。

#server.xml配置文件user部分
<user name="mycat">
 <property name="password">123456</property>
 <property name="schemas">TESTDB</property>
</user>
<user name="user">
 <property name="password">user</property>
 <property name="schemas">TESTDB</property>
 <property name="readOnly">true</property>
</user>

标签属性 说明
name 应用连接中间件逻辑库的用户名
password 该用户对应的密码
TESTDB 应用当前连接的逻辑库中所对应的逻辑表。schemas 中可以配置一个或多个
readOnly 应用连接中间件逻辑库所具有的权限。true 为只读，false 为读写都有，默认为 false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

八：Mycat 监控工具
1.Mycat-web 配置使用

#1下载安装包http://zookeeper.apache.org/
#2 安装包拷贝到Linux系统/opt目录下，并解压
tar -zxvf zookeeper-3.4.11.tar.gz```
#3 进入ZooKeeper解压后的配置目录（conf），复制配置文件并改名
cp zoo_sample.cfg zoo.cfg
#4 进入ZooKeeper的命令目录（bin），运行启动命令
./zkServer.sh start
#5 ZooKeeper服务端口为2181，查看服务已经启动
netstat -ant | grep 2181
1
2
3
4
5
6
7
8
9

2.Mycat-web 安装

#1下载安装包http://www.mycat.io/
#2 安装包拷贝到Linux系统/opt目录下，并解压
tar -zxvf Mycat-web-1.0-SNAPSHOT-20170102153329-linux.tar.gz
#3 拷贝mycat-web文件夹到/usr/local目录下
cp -r mycat-web /usr/local
#4 进入mycat-web的目录下运行启动命令
cd /usr/local/mycat-web/
./start.sh &
5 Mycat-web服务端口为8082，查看服务已经启动
netstat -ant | grep 8082
#6 通过地址访问服务
http://192.168.140.127:8082/mycat/
1
2
3
4
5
6
7
8
9
10
11
12

3、 Mycat-web 配置

#1 先在注册中心配置ZooKeeper地址
#2 新增Mycat监控实例
1
2