mycat主从复制，读写分离，双主双从，分库分表，高可用，安全监控

1.MyCAT介绍

1.1什么是MyCAT？

简单的说，MyCAT就是：
一个彻底开源的，面向企业应用开发的“大数据库集群”
支持事务、ACID、可以替代Mysql的加强版数据库
一个可以视为“Mysql”集群的企业级数据库，用来替代昂贵的Oracle集群
一个融合内存缓存技术、Nosql技术、HDFS大数据的新型SQL Server
结合传统数据库和新型分布式数据仓库的新一代企业级数据库产品
一个新颖的数据库中间件产品

MyCAT的目标是：低成本的将现有的单机数据库和应用平滑迁移到“云”端，解决数据存储和业务规模迅速增长情况下的数据瓶颈问题。

1.2.MyCAT的关键特性

支持 SQL 92标准
支持Mysql集群，可以作为Proxy使用
支持JDBC连接ORACLE、DB2、SQL Server，将其模拟为MySQL Server使用
支持galera for mysql集群，percona-cluster或者mariadb cluster，提供高可用性数据分片集群
自动故障切换，高可用性
支持读写分离，支持Mysql双主多从，以及一主多从的模式
支持全局表，数据自动分片到多个节点，用于高效表关联查询
支持独有的基于E-R 关系的分片策略，实现了高效的表关联查询
多平台支持，部署和实施简单

参考的博客

1.3MyCAT架构

如图所示：MyCAT使用Mysql的通讯协议模拟成了一个Mysql服务器，并建立了完整的Schema（数据库）、Table （数据表）、User(用户)的逻辑模型，并将这套逻辑模型映射到后端的存储节点DataNode（MySQL Instance）上的真实物理库中，这样一来，所有能使用Mysql的客户端以及编程语言都能将MyCAT当成是Mysql Server来使用，不必开发新的客户端协议。

2.Mycat解决的问题

性能问题
数据库连接过多
E-R分片难处理
可用性问题
成本和伸缩性问题

2.1.Mycat对多数据库的支持

3.分片策略

MyCAT支持水平分片与垂直分片：
水平分片：一个表格的数据分割到多个节点上，按照行分隔。
垂直分片：一个数据库中多个表格A，B，C，A存储到节点1上，B存储到节点2上，C存储到节点3上。

MyCAT通过定义表的分片规则来实现分片，每个表格可以捆绑一个分片规则，每个分片规则指定一个分片字段并绑定一个函数，来实现动态分片算法。

1、Schema：逻辑库，与MySQL中的Database（数据库）对应，一个逻辑库中定义了所包括的Table。
2、Table：表，即物理数据库中存储的某一张表，与传统数据库不同，这里的表格需要声明其所存储的逻辑数据节点DataNode。在此可以指定表的分片规则。
3、DataNode：MyCAT的逻辑数据节点，是存放table的具体物理节点，也称之为分片节点，通过DataSource来关联到后端某个具体数据库上
4、DataSource：定义某个物理库的访问地址，用于捆绑到Datanode上

4.Mycat的下载及安装

4.1.下载mycat

官方网站：
http://www.mycat.org.cn/

github地址
https://github.com/MyCATApache

4.2.Mycat安装

第一步：把MyCat的压缩包上传到linux服务器
第二步：解压缩，得到mycat目录
第三步：进入mycat/bin，启动MyCat
启动命令：./mycat start
停止命令：./mycat stop
重启命令：./mycat restart

注意：可以使用mysql的客户端直接连接mycat服务。默认服务端口为8066

5.Mycat分片

5.1.需求

把商品表分片存储到三个数据节点上。

5.2.安装环境

mysql节点1环境
操作系统版本 : centos6.4
数据库版本 : mysql-5.6
mycat版本 ：1.4 release
数据库名 : db1、db3
ip:192.168.25.134

mysql节点2环境
操作系统版本 : centos6.4
数据库版本 : mysql-5.6
mycat版本 ：1.4 release
数据库名 : db2
ip:192.168.25.166

MyCat安装到节点1上（需要安装jdk）

5.3.配置schema.xml

5.3.1.Schema.xml介绍

Schema.xml作为MyCat中重要的配置文件之一，管理着MyCat的逻辑库、表、分片规则、DataNode以及DataSource。弄懂这些配置，是正确使用MyCat的前提。这里就一层层对该文件进行解析.

schema 标签用于定义MyCat实例中的逻辑库
Table 标签定义了MyCat中的逻辑表
dataNode 标签定义了MyCat中的数据节点，也就是我们通常说所的数据分片。
dataHost标签在mycat逻辑库中也是作为最底层的标签存在，直接定义了具体的数据库实例、读写分离配置和心跳语句。

注意：若是LINUX版本的MYSQL，则需要设置为Mysql大小写不敏感，否则可能会发生表找不到的问题。
在MySQL的配置文件中my.ini [mysqld] 中增加一行
　　lower_case_table_names =1

5.4.配置server.xml

server.xml几乎保存了所有mycat需要的系统配置信息。最常用的是在此配置用户名、密码及权限。

5.5.配置rule.xml

rule.xml里面就定义了我们对表进行拆分所涉及到的规则定义。我们可以灵活的对表使用不同的分片算法，或者对表使用相同的算法但具体的参数不同。这个文件里面主要有tableRule和function这两个标签。在具体使用过程中可以按照需求添加tableRule
和function。
此配置文件可以不用修改，使用默认即可。

6.Mycat读写分离

数据库读写分离对于大型系统或者访问量很高的互联网应用来说，是必不可少的一个重要功能。对于MySQL来说，标准的读写分离是主从模式，一个写节点Master后面跟着多个读节点，读节点的数量取决于系统的压力，通常是1-3个读节点的配置

Mycat读写分离和自动切换机制，需要mysql的主从复制机制配合。

6.1.Mysql的主从复制(一主一从)

主从配置需要注意的地方
1、主DB server和从DB server数据库的版本一致
2、主DB server和从DB server数据库数据一致[ 这里就会可以把主的备份在从上还原，也可以直接将主的数据目录拷贝到从的相应数据目录]
3、主DB server开启二进制日志,主DB server和从DB server的server_id都必须唯一

6.2.Mysql主服务器配置

第一步：修改my.conf文件：
在[mysqld]段下添加：
binlog-do-db=db1
binlog-ignore-db=mysql
#启用二进制日志
log-bin=mysql-bin
#服务器唯一ID，一般取IP最后一段
server-id=134
第二步：重启mysql服务
service mysqld restart
第三步：建立帐户并授权slave
mysql>GRANT FILE ON . TO ‘backup’@’%’ IDENTIFIED BY ‘123456’;
mysql>GRANT REPLICATION SLAVE, REPLICATION CLIENT ON . to ‘backup’@’%’ identified by ‘123456’;
#一般不用root帐号，“%”表示所有客户端都可能连，只要帐号，密码正确，此处可用具体客户端IP代替，如192.168.145.226，加强安全。

刷新权限
mysql> FLUSH PRIVILEGES;

查看mysql现在有哪些用户
mysql>select user,host from mysql.user;

第四步：查询master的状态
mysql> show master status;
±-----------------±---------±-------------±-----------------±------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
±-----------------±---------±-------------±-----------------±------------------+
| mysql-bin.000001 | 120 | db1 | mysql | |
±-----------------±---------±-------------±-----------------±------------------+
1 row in set

6.3.Mysql从服务器配置

第一步：修改my.conf文件
[mysqld]
server-id=166

第二步：配置从服务器
mysql>change master to master_host=‘192.168.25.134’,master_port=3306,master_user=‘backup’,master_password=‘123456’,master_log_file=‘mysql-bin.000001’,master_log_pos=120

注意语句中间不要断开，master_port为mysql服务器端口号(无引号)，master_user为执行同步操作的数据库账户，“120”无单引号(此处的120就是show master status 中看到的position的值，这里的mysql-bin.000001就是file对应的值)。

第二步：启动从服务器复制功能
Mysql>start slave;

第三步：检查从服务器复制功能状态：
mysql> show slave status\G;

……………………(省略部分)
Slave_IO_Running: Yes //此状态必须YES
Slave_SQL_Running: Yes //此状态必须YES
……………………(省略部分)

注：Slave_IO及Slave_SQL进程必须正常运行，即YES状态，否则都是错误的状态(如：其中一个NO均属错误)。

错误处理：
如果出现此错误：
Fatal error: The slave I/O thread stops because master and slave have equal MySQL server UUIDs; these UUIDs must be different for replication to work.
因为是mysql是克隆的系统所以mysql的uuid是一样的，所以需要修改。
解决方法：
删除/var/lib/mysql/auto.cnf文件，重新启动服务。

以上操作过程，从服务器配置完成。

6.4.Mycat配置

Mycat 1.4 支持MySQL主从复制状态绑定的读写分离机制，让读更加安全可靠，配置如下：

<dataNode name="dn1" dataHost="localhost1" database="db1" />
	<dataNode name="dn2" dataHost="localhost1" database="db2" />
	<dataNode name="dn3" dataHost="localhost1" database="db3" />
	<dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
		writeType="0" dbType="mysql" dbDriver="native" switchType="2"  slaveThreshold="100">
		<heartbeat>show slave status</heartbeat>
		<writeHost host="hostM" url="192.168.25.134:3306" user="root"
			password="root">
			<readHost host="hostS" url="192.168.25.166:3306" user="root"
			password="root" />
		</writeHost>
	</dataHost>

(1)设置 balance="1"与writeType=“0”
Balance参数设置：

1. balance=“0”, 所有读操作都发送到当前可用的writeHost上。
2. balance=“1”，所有读操作都随机的发送到readHost。
3. balance=“2”，所有读操作都随机的在writeHost、readhost上分发
4. balance=”3” 所有的读平均分配到readhost执行，writehost不承担读请求
   WriteType参数设置：
5. writeType=“0”, 所有写操作都发送到可用的writeHost上。
6. writeType=“1”，所有写操作都随机的发送到readHost。
7. writeType=“2”，所有写操作都随机的在writeHost、readhost分上发。
   “readHost是从属于writeHost的，即意味着它从那个writeHost获取同步数据，因此，当它所属的writeHost宕机了，则它也不会再参与到读写分离中来，即“不工作了”，这是因为此时，它的数据已经“不可靠”了。基于这个考虑，目前mycat 1.3和1.4版本中，若想支持MySQL一主一从的标准配置，并且在主节点宕机的情况下，从节点还能读取数据，则需要在Mycat里配置为两个writeHost并设置banlance=1。”
   (2)设置 switchType=“2” 与slaveThreshold=“100”
   switchType 目前有三种选择：
   -1：表示不自动切换
   1 ：默认值，自动切换
   2 ：基于MySQL主从同步的状态决定是否切换
   “Mycat心跳检查语句配置为 show slave status ，dataHost 上定义两个新属性： switchType=“2” 与slaveThreshold=“100”，此时意味着开启MySQL主从复制状态绑定的读写分离与切换机制。Mycat心跳机制通过检测 show slave status 中的 “Seconds_Behind_Master”, “Slave_IO_Running”, “Slave_SQL_Running” 三个字段来确定当前主从同步的状态以及Seconds_Behind_Master主从复制时延。“

6.5双主双从

背景：
需要搭建Mycat商用环境，使用4台虚拟机操练一下，最终的目标是：
服务器情况：

机器ip	机器名	安装组件
192.168.239.144	douzi9	Master1 mycat1
192.168.239.145	douzi10	Slave1
192.168.239.146	douzi11	Master2 mycat2
192.168.239.147	douzi12	Slave1

6.5.1M1服务器douzi9 的mysql配置, douzi add config start 和douzi add config end之间替换为下方配置

[mysqld]
			# douzi add config start

			## 启用二进制日志

			log-bin=mysql-bin

			## 主服务器唯一id

			server-id=1

			## 设置不要复制的数据库(可配多个)

			binlog-ignore-db=mysql

			## 设置需要复制的数据库(可配多个)

			binlog-do-db=testdb

			## 设置logbin格式 （STATEMENT、ROW、MIXED）

			binlog_format=STATEMENT

			 

			## 在作为从数据库时，也要更新二进制文件

			log-slave-updates

			## 表示自增长时每次递增的量，指自增字段的起始值，默认为1，范围是 1-65535

			auto-increment-increment =2

			## 表示自增长字段从哪个值开始，范围1-65535

			auto-increment-offset =1

			# douzi add config end

6.5.2.M2服务器douzi11 的mysql配置, douzi add config start 和douzi add config end之间替换为下方配置

[mysqld]
			# douzi add config start

			## 启用二进制日志

			log-bin=mysql-bin

			## 主服务器唯一id

			server-id=3

			## 设置不要复制的数据库(可配多个)

			binlog-ignore-db=mysql

			## 设置需要复制的数据库(可配多个，多行配置)

			binlog-do-db=testdb

			## 设置logbin格式 （STATEMENT、ROW、MIXED）

			binlog_format=STATEMENT

			 

			## 在作为从数据库时，也要更新二进制文件

			log-slave-updates

			## 表示自增长时每次递增的量，指自增字段的起始值，默认为1，范围是 1-65535

			auto-increment-increment =2

			## 表示自增长字段从哪个值开始，范围1-65535

			auto-increment-offset =1

			# douzi add config end

6.5.3S1服务器douzi10 的mysql配置

[mysqld]

# douzi add config start

## 主服务器唯一id

server-id=2

## 启动中继日志

relay-log=mysql-relay

# douzi add config end

6.5.4 S2服务器douzi12 的mysql配置

[mysqld]

# douzi add config start

## 主服务器唯一id

server-id=4

## 启动中继日志

relay-log=mysql-relay

# douzi add config end

6.5.5重启所有mysql服务器，并查看状态:

systemctl restart mysqld

systemctl status mysqld

6.5.6M1、M2主机上建立账户并授权从机：

访问主机mysql服务器：mysql -uroot -p123456

执行授权sql：grant replication slave on *.* to 'slave'@'%' identified by '123456';

注：ERROR 1819 (HY000): Your password does not satisfy the current policy requirements

   执行 

    set global validate_password_policy=0;

    set global validate_password_length=1; 即可

6.5.7停止从机S1、S2复制服务：stop slave;

6.5.8重置主机M1、M2：reset master;

6.5.9搭建双主从复制M1->S1 M2->S2,与单个主从相同；

•S1命令：

change master to master_host=‘192.168.239.144’, master_port=3306,master_user=‘slave’, master_password=‘123456’,master_log_file=‘mysql-bin.000001’,master_log_pos=154;

•S2命令：
change master to master_host=‘192.168.239.146’, master_port=3306,master_user=‘slave’, master_password=‘123456’,master_log_file=‘mysql-bin.000001’,master_log_pos=154;

6.5.10 启动从机S1、S2复制服务：start slave; 查看从机状态（列展现）：show slave status\G;

6.5.11同时M1也要复制M2，M2也要复制M1，互相作为对方的从机：

•M1命令：
change master to master_host=‘192.168.239.146’, master_port=3306,master_user=‘slave’, master_password=‘123456’,master_log_file=‘mysql-bin.000001’,master_log_pos=154;
•M2命令：
change master to master_host=‘192.168.239.144’, master_port=3306,master_user=‘slave’, master_password=‘123456’,master_log_file=‘mysql-bin.000001’,master_log_pos=154;

6.5.12启动从机M1、M2复制服务：start slave; 查看从机状态（列展现）：show slave status\G;

7.垂直分库

• 一个节点多个库
• 多个节点多个库

• 这里只写多了节点多个库
  一个节点多个库

  7.1修改scheme.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'  >
             <!-- customer这个表在db2 库上面，其他的表在db1这个库上面-->
             <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.25.130:3306" user="root"
                                   password="root">
                        <!-- can have multi read hosts -->
              <!--              <readHost host="hostS1" url="192.168.25.132:3306" user="root" password="root" />-->
                </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="hostM1" url="192.168.25.132:3306" user="root"
                                     password="root">
                          <!-- can have multi read hosts -->
                <!--              <readHost host="hostS1" url="192.168.25.132:3306" user="root" password="root" />-->
                  </writeHost>

         </dataHost>
         </mycat:schema>

7.2在两个节点上面建好对应的数据库orders，

7.3开启mycat 进入mycat,然后建立表

mycat会自动对建表语句进行分析，然后把表建立在db2或者db1上面

create table customer(id int auto_increment,
                                        name varchar(200),
                                      primary key(id));

create table orders(id int auto_increment,
                                        order_type int,
                                     customer_id int,
                                   amount decimal(10.2),
                                      primary key(id));
create table orders_detail(id int auto_increment,
                                        detail varchar(2000),
                                     order_id int,
                                        primary key(id));
create table dict_order_type(id int auto_increment,
                                        order_type varchar(200),
                                        primary key(id));

8.水平分表

8.1修改scheme.xml

为orders表设置数据节点为db1,db2,并且知道分片规则为mod_rule (名字自定义)

8.2修改rule.xml 定义分片规则

定义分片字段columns。分片算法algorithm，分片规则name=“mod_rule”，与scheme.xml中的rule对应

<tableRule name="mod_rule">
                <rule>
                      
                        <columns>customer_id</columns>
                        <algorithm>mod-long</algorithm>
                </rule>
        </tableRule>

8.3修改节点数

 <function name="mod-long" class="io.mycat.route.function.PartitionByMod">
                <!-- how many data nodes -->
                <property name="count">2</property>
        </function>

8.4插入数据

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,120100);
insert into orders (id,order_type,customer_id,amount)values(3,101,100,103100);
insert into orders (id,order_type,customer_id,amount)values(4,101,101,140100);
insert into orders (id,order_type,customer_id,amount)values(5,102,101,150100);
insert into orders (id,order_type,customer_id,amount)values(6,102,101,160100);

8.5查询验证，发现在不同的表里面有不同的数据，根据对应的算法进行了分表存储，mycat做了对应的分片分析和结果聚合（合并）

8.6 orders 与orders_details 的join查询

8.6.1将orders_detail作为orders的字表(E-R表)

配置scheme.xml

 <childTable name='orders_detail' primaryKey='id' joinKey='order_id' parentKey='id'/>

8.6.2在两个库都建立order_detail表

8.6.3重新启动mycat，然后访问mycat，插入数据

insert into orders_detail (id,detail,order_id)values(1,'detail1',1);
insert into orders_detail (id,detail,order_id)values(2,'detail1',2);
insert into orders_detail (id,detail,order_id)values(3,'detail1',3);
insert into orders_detail (id,detail,order_id)values(4,'detail1',4);
insert into orders_detail (id,detail,order_id)values(5,'detail1',5);
insert into orders_detail (id,detail,order_id)values(6,'detail1',6);

8.6.4测试inner join查询

mysql> select a.*,b.detail from orders a inner join orders_detail b on  a.id =b.id
    -> ;
+----+------------+-------------+--------+---------+
| id | order_type | customer_id | amount | detail  |
+----+------------+-------------+--------+---------+
|  4 |        101 |         101 | 140100 | detail1 |
|  5 |        102 |         101 | 150100 | detail1 |
|  6 |        102 |         101 | 160100 | detail1 |
|  1 |        101 |         100 | 100100 | detail1 |
|  2 |        101 |         100 | 120100 | detail1 |
|  3 |        101 |         100 | 103100 | detail1 |
+----+------------+-------------+--------+---------+
6 rows in set (0.16 sec)

8.7全局表

8.7.1修改配置schem.xml

 <table name='dict_order_type' dataNode='db1,db2' type='global'></table>

8.7.2创建表

CREATE TABLE `dict_order_type` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `order_type` varchar(200) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

8.7.3重启mycat，插入数据

insert into dict_order_type (id,order_type)values(101,'type1');
insert into dict_order_type (id,order_type)values(102,'type2');

8.7.4 查询验证，两个节点都有数据

mysql> select * from dict_order_type;
+-----+------------+
| id  | order_type |
+-----+------------+
| 101 | type1      |
| 102 | type2      |
+-----+------------+
2 rows in set (0.15 sec)

8.8分片枚举

通过在配置文件中配置可能的id,自己配置分片，本规则适用于特殊场景，比如有业务需要按照省份或者区县来保存，而全国的省份区县是固定的，所以适合于此规则

8.8.1配置schema.xml

    <table name='orders_ware_info' dataNode='dn1,dn2' rule='sharding_by_intfile'></table>

8.8.2 配置rule.xml

  <tableRule name="sharding_by_intfile">
                <rule>
                        <columns>areacode</columns>
                        <algorithm>hash-int</algorithm>
                </rule>
        </tableRule>



 <function name="hash-int"
                class="io.mycat.route.function.PartitionByFileMap">
                <property name="mapFile">partition-hash-int.txt</property>
               <property name='type' >1</property>
              <property name='defaultNode'>0</property>
        </function>

type为0，表示int型，非0表示非int型

8.8.3配置partition-hash-int.txt

110=0
120=1

8.8.4重启mycat,登录mycat,创建表，插入数据

create table orders_ware_info(id int auto_increment,
                                        order_id int,
                                     address varchar(200),
                                  areacode varchar(20),
                                      primary key(id));

如果插入数据报错：mysql> INSERT INTO orders.orders_ware_info
-> (order_id, address, areacode)
-> VALUES(1, ‘深圳’, ‘110’);
ERROR 1366 (HY000): Incorrect string value: ‘\xE6\xB7\xB1\xE5\x9C\xB3’ for column ‘address’ at row 1
需要重新设置字符集。
show variables like ‘character%’;
alter table orders_ware_info character set utf8

8.8.5查询验证结果，每个节点按照枚举分片规则插入数据

8.9范围约定

8.9.1修改scheme.xml文件

 <table name='payment_info' dataNode='dn1,dn2' rule='auto_sharding_long'></table>

8.9.2 修改rule.xml

 <tableRule name="auto_sharding_long">
                <rule>
                        <columns>order_id</columns>
                        <algorithm>rang-long</algorithm>
                </rule>
        </tableRule>

 <function name="rang-long"
                class="io.mycat.route.function.AutoPartitionByLong">
                <property name="mapFile">autopartition-long.txt</property>
              <property name='defaultNode'>0</property>
        </function>

8.9.3 编辑配置文件autopartition-long.txt

# range start-end ,data node index
# K=1000,M=10000.
0-102=0
103-200=1

8.9.4 重新启动mycat,创建表，插入数据

create table payment_info(
id int auto_increment,
 order_id int,
payment_status int,
  primary key(id));
insert into payment_info(id,order_id,payment_status)values(1,101,0);
insert into payment_info(id,order_id,payment_status)values(2,102,1);
insert into payment_info(id,order_id,payment_status)values(3,103,0);
insert into payment_info(id,order_id,payment_status)values(4,104,1);

8.9.5 查询数据，验证结果，大于102的在节点2。

8.10按照日期来分片（和分表一个意思）

8.10.1修改scheme.xml

<table name='login_info' dataNode='dn1,dn2' rule='sharding_by_date'></table>

8.10.2修改rule.xml

 <tableRule name="sharding_by_date">
                <rule>
                        <columns>login_date</columns>
                        <algorithm>shardingByDate</algorithm>
                </rule>
        </tableRule>



<function name='shardingByDate' class='io.mycat.route.function.PartitionByDate'>
  <property name='dateFormat'>yyyy-MM-dd</property>
<property name='sBeginDate'>2019-01-01</property>
<property name='sEndDate'>2019-01-04</property>
<property name='sPartionDay'>2</property>
</function>
sBeginDate 开始日期
sEndDate 结束日期，到了结束日期以后会自动从第一个分片开始插入
sPartionDay  分割两天一个分区

8.10.3 重启mycat,创建表，插入数据

create table login_info (id int,user_id int,login_date date,primary key(id));

insert into login_info(id,user_id,login_date)values(1,101,'2019-01-01');
insert into login_info(id,user_id,login_date)values(2,102,'2019-01-02');
insert into login_info(id,user_id,login_date)values(3,103,'2019-01-03');
insert into login_info(id,user_id,login_date)values(4,104,'2019-01-04');
insert into login_info(id,user_id,login_date)values(5,105,'2019-01-05');
insert into login_info(id,user_id,login_date)values(6,106,'2019-01-06');

8.10.4查询数据，验证结果

mysql> select * from login_info;
+----+---------+------------+
| id | user_id | login_date |
+----+---------+------------+
|  1 |     101 | 2019-01-01 |
|  2 |     102 | 2019-01-02 |
|  5 |     105 | 2019-01-05 |
|  6 |     106 | 2019-01-06 |
|  3 |     103 | 2019-01-03 |
|  4 |     104 | 2019-01-04 |
+----+---------+------------+
6 rows in set (0.12 sec)

8.11全局序列

介绍了MyCat全局序列的本地文件方式，由于 MyCat 重新发布后，配置文件中的 sequence 会恢复到初始值（当这台机器宕机时会出现，序列文件丢失，造成序列冲突问题）,所以在实际项目中并不会采用本地文件生成序列，更多是采用数据库的方式，本文就将对如何在MyCat中使用数据库实现全局序列主键唯一。

8.11.1在dn1上面创建全局序列表

DROP TABLE IF EXISTS MYCAT_SEQUENCE;CREATE TABLE `MYCAT_SEQUENCE`
 (  `NAME` varchar(50) NOT NULL comment  "名称",  `current_value` int(11) NOT NULL comment "当
 前值",  `increment` int(11) NOT NULL DEFAULT '100' comment "步长",  PRIMARY KEY (`NAME`)) 
 ENGINE=InnoDB DEFAULT CHARSET=utf8;

8.11.2 创建全局序列所需要的函数

创建生成序列的函数
•返回当前的sequence的值

DROP FUNCTION IF EXISTS mycat_seq_currval;
DELIMITER $$
CREATE FUNCTION mycat_seq_currval(seq_name VARCHAR(50))RETURNS VARCHAR(64) CHARSET 'utf8'
DETERMINISTIC
begin
DECLARE retval VARCHAR(64);
SET retval='-999999999,NULL';
SELECT CONCAT(CAST(current_value AS CHAR),',',CAST(increment AS CHAR)) INTO retval from 
MYCAT_SEQUENCE WHERE NAME = seq_name;
RETURN retval;
END$$
DELIMITER ;

•设置sequence的值

DROP FUNCTION IF EXISTS mycat_seq_setval;
DELIMITER $$
CREATE FUNCTION mycat_seq_setval(seq_name VARCHAR(50),VALUE INTEGER) RETURNS 
VARCHAR(64) 
DETERMINISTIC
BEGIN  
 UPDATE MYCAT_SEQUENCE SET current_value = VALUE  
WHERE NAME = seq_name;
RETURN mycat_seq_currval(seq_name);END$$
DELIMITER ;

•获取下一个sequence的值

DROP FUNCTION IF EXISTS mycat_seq_nextval;
DELIMITER $$
CREATE FUNCTION mycat_seq_nextval(seq_name VARCHAR(50)) RETURNS VARCHAR(64)
DETERMINISTIC
begin
	
UPDATE MYCAT_SEQUENCE SET current_value = current_value + increment WHERE NAME = seq_name;
RETURN mycat_seq_currval(seq_name);END$$
DELIMITER ;

8.11.3 插入数据

insert into MYCAT_SEQUENCE(name, current_value, increment) values ('ORDERS', 400000, 100);

8.11.4 修改配置文件 sequence_db_conf.properties

#sequence stored in datanode
GLOBAL=dn1
COMPANY=dn1
CUSTOMER=dn1
ORDERS=dn1

修改server.xml

 <property name="sequnceHandlerType">1</property>
sequnceHandlerType=1  代表是使用数据库的方式实现全局序列

8.11.5 重启mycat ,验证全局序列

mysql> insert into orders(id,amount,customer_id,order_type) values(next value for MYCATSEQ_ORDERS,100,101,102);
Query OK, 1 row affected (0.13 sec)

mysql> select * from orders;
+--------+------------+-------------+--------+
| id     | order_type | customer_id | amount |
+--------+------------+-------------+--------+
|      1 |        101 |         100 | 100100 |
|      2 |        101 |         100 | 120100 |
|      3 |        101 |         100 | 103100 |
|      4 |        101 |         101 | 140100 |
|      5 |        102 |         101 | 150100 |
|      6 |        102 |         101 | 160100 |
| 400100 |        102 |         101 |    100 |
| 400101 |        102 |         101 |    100 |
+--------+------------+-------------+--------+
8 rows in set (0.00 sec)

参考博客

9.mycat 高可用

9.1 下载haproxy 与keepalived

安装参考链接
haproxy 下载链接
keepalived 下载链接

Mycat HAProxy 整合高可用

我们可以使用 HAProxy + Keepalived 配合两台 Mycat 搭起 Mycat 集群，实现高可用性。

HAProxy 保证了 MyCat 多节点的负载均衡和集群高可用性。

Keepalived 用来保证 HAProxy 自身的高可用性。

1、整体规划

编号	角色	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.128	host82
6	Keepalived（backup）	192.168.140.128	host82

9.2、HAProxy 安装

2.1、HAProxy 安装

1、准备好 HAProxy 安装包，传到/opt目录下
haproxy-1.8.13.tar.gz

2、解压到 /usr/local/src
tar -zxvf haproxy-1.8.13.tar.gz -C /usr/local/src
cd /usr/local/src/haproxy-1.8.13/

3、查询系统内核版本
[root@localhost haproxy-1.8.13]# uname -r
3.10.0-862.el7.x86_64

4、编译时，centos6.X需要使用 TARGET=linux26 ，centos7.x 使用 linux31
[root@localhost haproxy-1.8.13]# make TARGET=linux31 PREFIX=/usr/local/haproxy ARCH=x86_64

5、安装到 /usr/local/haproxy 目录下
[root@localhost haproxy-1.8.13]# make install PREFIX=/usr/local/haproxy

6、创建目录、创建HAProxy配置文件
[root@localhost haproxy-1.8.13]# mkdir -p /usr/data/haproxy/
[root@localhost haproxy-1.8.13]# vi /usr/local/haproxy/haproxy.conf

2.2、haproxy.conf 配置文件

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 TRUE

9.3、HAProxy 启动

1、启动HAProxy

/usr/local/haproxy/sbin/haproxy -f /usr/local/haproxy/haproxy.conf

2、查看HAProxy进程

ps -ef|grep haproxy

2.4、登录 HAProxy、查看

打开浏览器访问

http://192.168.140.125:7777/admin

在弹出框输入用户名： admin ，密码： 123123

4、验证负载均衡，通过HAProxy访问Mycat
mysql -umycat -p123456 -h 192.168.140.126 -P 48066

3、配置 Keepalived

9.4、 安装 Keepalived

1、准备好Keepalived安装包，传到/opt目录下

keepalived-1.4.2.tar.gz

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

4、进入解压后的目录， 进行配置， 进行编译
cd /usr/local/src/keepalived-1.4.2
./configure --prefix=/usr/local/keepalived

5、进行编译， 完成后进行安装
make && make install

6、运行前配置

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/

3.2、keepalived.conf 配置文件

9.5、修改配置文件

vim /etc/keepalived/keepalived.conf

修改内容如下：（MASTER，BACKUP 略有不同）

! 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
        }
    }
}

interface 是什么？

配置文件中 interface ens33 到底是什么？，如图所示：

在这里插入图片描述

virtual_ipaddress 虚拟IP的作用？

通过虚拟IP，隐藏真实服务的IP地址，从而保护的服务的安全性。

3.3、 启动验证

9.6、启动Keepalived

service keepalived start

2、登录验证
mysql -umycat -p123456 -h 192.168.140.200 -P 48066

4、测试

1、关闭mycat

2、通过虚拟ip查询数据
mysql -umycat -proot -h 192.168.140.200 -P 48066

10.安全监控

10.1 权限配置user

设置user用户只有只读权限

<user name='user'>
    <property name='password'>root</property>
   <property name='schemas'>TESTDB</property>
   <property name='readOnly'>true</property>
</user>

10.2 权限配置privilege

privileges标签可以对逻辑库，表进行更加精细化的dml管理，privileges标签默认为false，设置为true表示开启校验

配置orders表没有crud的权限

<user name='mycat'>
    <property name='password'>root</property>
   <property name='schemas'>TESTDB</property>
   <privaliges check='true'>
           <schema name='TESTDB' dml='1111'>
                  <table name='orders' dml ='0000'></table>
           </schema>
   </privileges>
   
</user>

DML权限	新增（insert）	更新（update）	查询（select）	删除（delete）
0000	禁止	禁止	禁止	禁止
0010	禁止	禁止	可以	禁止
1110	可以	可以	可以	禁止
1111	可以	可以	可以	可以

10.3 安全SQL拦截

filrwall标签用来定义防火墙功能，firewall下面的whitehost设置IP白名单,blackhost用来定义SQL黑名单

1. 白名单定义某些主机可以访问mycat,其他主机无法访问

<firewall>
    <whitehost>
      <host host='192.168.25.130' user='mycat'/>
    </whitehost>
</firewall>

2. ，如果白名单那一关过了，来到第二关，黑名单定义SQL的权限,是否能够crud

<firewall>
   <whitehost>
     <host host='192.168.25.130' user='mycat'/>
   </whitehost>
   <blackhost check='true'>
      <property name='deleteAllow'>true</property>
   </blackhost>
</firewall>

10.4 mycat-web 监控

10.4.1 zookeeper与mycat-web的安装

mycat-web下载

[root@ess130 opt]# ll
总用量 69984
drwxrwxrwx.  5 root   root         96 10月 20 2015 mycat-web
-rw-r--r--.  1 root   root   53956391 3月  24 16:24 Mycat-web-1.0-SNAPSHOT-20170102153329-linux.tar.gz
drwxr-xr-x.  2 root   root          6 10月 31 2018 rh
drwxr-xr-x. 10 itcast itcast     4096 2月  20 2014 zookeeper-3.4.6
-rw-r--r--.  1 root   root   17699306 3月  24 16:21 zookeeper-3.4.6.tar.gz
[root@ess130 opt]# 

直接解压使用，zookeeper,修改一下zoo.cfg文件名
mycat 拷贝到 、user/local下面

[root@ess130 local]# cd mycat-web/
[root@ess130 mycat-web]# ll
总用量 28
drwxr-xr-x. 2 root root    45 3月  24 16:45 etc
drwxr-xr-x. 3 root root   135 3月  24 16:45 lib
drwxr-xr-x. 7 root root   168 3月  24 16:45 mycat-web
-rwxr-xr-x. 1 root root   116 3月  24 16:45 readme.txt
-rwxr-xr-x. 1 root root 17125 3月  24 16:45 start.jar
-rwxr-xr-x. 1 root root   381 3月  24 16:45 start.sh
[root@ess130 mycat-web]# ./start.sh &

直接进入mycat-web ./start.sh & 后台启动

[root@ess130 mycat-web]# nohup: 忽略输入并把输出追加到"nohup.out"
^C
[root@ess130 mycat-web]# ll
总用量 48
drwxr-xr-x. 2 root root    45 3月  24 16:45 etc
drwxr-xr-x. 3 root root   135 3月  24 16:45 lib
drwxr-xr-x. 7 root root   168 3月  24 16:45 mycat-web
-rw-------. 1 root root 16349 3月  24 16:48 nohup.out
-rw-r--r--. 1 root root  1412 3月  24 16:48 rainbow.log
-rwxr-xr-x. 1 root root   116 3月  24 16:45 readme.txt
-rwxr-xr-x. 1 root root 17125 3月  24 16:45 start.jar
-rwxr-xr-x. 1 root root   381 3月  24 16:45 start.sh
[root@ess130 mycat-web]# 

多了一个启动日志文件nohup.out

验证默认端口8082

[root@ess130 mycat-web]# netstat -ant |grep 8082
tcp6       0      0 :::8082                 :::*                    LISTEN     
[root@ess130 mycat-web]# 

浏览器输入http://192.168.25.30/8082/mycat

10.4.2监控平台的配置指标

监控平台配置

未完待续…