【微服务/淘淘商城实践/SSM框架】12 Mysql 集群 Mycat (读写分离，双主多从，一主多从、全局表、E-R分片策略、水平拆分和路由算法) 逻辑数据节点与物理主机配置

最新推荐文章于 2022-10-11 15:32:10 发布

alwarse

最新推荐文章于 2022-10-11 15:32:10 发布

阅读量1.1k

点赞数

分类专栏：【微服务/淘淘商城实践/SSM框架】文章标签： mysql 微服务 mycat haproxy java

本文链接：https://blog.csdn.net/alwarse/article/details/122002755

版权

【微服务/淘淘商城实践/SSM框架】专栏收录该内容

14 篇文章 1 订阅

订阅专栏

Mysql 集群 Mycat

在这里插入图片描述

mysql 安装

mycat介绍

一个可以用于MySQL读写分离和高可用的中间件
一个模拟为MySQL Server的超级数据库
一个能平滑扩展支持1000亿大表的分布式数据库系统
一个可管控多种关系数据库的数据库路由器
一个平滑从关系数据升级到大数据的应用中间件
在这里插入图片描述

为什么选择Mycat

性能问题

在这里插入图片描述

数据库连接过多

在这里插入图片描述
Mycat引入连接复用解决多应用竞争问题

E-R分片难处理

存在关联关系的父子表在数据插入的过程中，子表会被Mycat路由到其相关父表记录的节点上，从而父子表的Join查询可以下推到各个数据库节点上完成，这是最高效的跨节点Join处理技术，也是Mycat首创
在这里插入图片描述

可用性问题

全局表技术
每个节点同时并发插入和更新数据，每个节点都可以读取数据，提升读性能的同时解决跨节点Join的效率
在这里插入图片描述

独创的ER关系分片
基于Catlet的两表自动Join模块(Catlet是Java编写的一段程序，类似数据库中的存储过程，可以实现任意复杂SQL的Join、Group、Order等功能
)
复杂SQL可通过用户自定义的Catlet进行处理

未来引入Sorm/Spark Stream等技术来处理海量数据计算

Standby切换故障

Mycat 支持基于MySQL主从复制状态的高级读写分离控制机制，比如 Slave_behind_master <100则开启，而一旦检测到主从同步出错或者延时超过发展，则自动排除readHost，防止程序读到很久的旧数据

在这里插入图片描述

成本和伸缩性问题

依赖高成本的硬件设备

Mycat的高可靠性方案

在这里插入图片描述

Mycat部署方案

高可靠性
Mycat本身是无状态的，可以用HAProxy或四层交换机等设备组成Mycat的高可用集群，后端MySQL则配置为主从同步，此时整个系统就是高可用的。

在这里插入图片描述
注意，当我们配置MySQL主从的时候，除了Galera Cluster是多主模式，其他标准是一主一从，此时，Mycat里面要将MySQL Slave配置为WriteHost，而不是readHost，这样当第一个WriteHost宕机，Mycat就会自动切断到第二个WriteHost，即MySQL Slave
上，完成自动的故障切换。

Mycat的原理

分表分库
在这里插入图片描述

Mycat架构图第三代

在这里插入图片描述

Mycat性能测试报告

16核心的服务器上，测试达到12万每秒的插入性能，1个Mycat，3个MySQL服务器
8核心8G的高端笔记本上，单机测试插入性能超过1万每秒
当带宽和IO不会成为瓶颈的情况下，Mycat一拖N个MSQL服务器的性能，可以达到N×80%×MySQL单机性能

mycat特性

在这里插入图片描述

mycat配置

schema.xml
table 对外统一表名 tb_item
mysql数据节点 dataNode 3个 dn1 dn2 dn3 d对应的数据库域(localhost1）以及数据库
dataHost localhost1配置数据库实例是mysql 读写分离，指定读服务器 writeHost

<schema name="taotao" checkSQLschema="false" sqlMaxLimit="100">
  <!-- auto sharding by id (long) -->
  <table name="tb_item" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />
 </schema>

 <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="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.175:3306" user="root"
   password="root">
   <!-- can have multi read hosts -->

  </writeHost>
  
 </dataHost>

在这里插入图片描述

读写分离

mysql 读写分离
–heartbeat
SELECT USER()

SHOW SLAVE STATUS

SHOW MASTER STATUS

change master 127.0.0.1 33.6 back localhost bin-log-004 .bin 606

分片枚举策略 E-R 分片规则（orders表格根据外键的值也就是customer的主键值切分）

在这里插入图片描述
根据E-R分片规则，orders表格根据外键的值也就是customer的主键值切分，

也就是orders.customer_id=customer.id的数据分在一个区。

分别在db1,db2检索数据，看看是否达到E-R分片的设计要求。

在这里插入图片描述

拆分数据表

水平拆分

在这里插入图片描述

路由算法

在这里插入图片描述

路由算法——扩容

在这里插入图片描述

路由算法——非均匀分布

在这里插入图片描述

拆分表的数据访问——SQL转发

在这里插入图片描述

拆分表的数据访问——结果返回

在这里插入图片描述

SQL执行策略总结

WHERE - 基于SQL转发
JOIN - 迭代分布式索引
ORDER BY/LIMIT - 多次查询减小数据量
GROUP BY - 增加ORDER BY

MyCat 事务支持

在这里插入图片描述

MyCAT使用经验分享

通过对mycat一个月左右的研究和使用，目前已经正式应用于我公司正式项目中，为了感谢群里各位朋友的帮助，现对mycat做一下使用经验分享。

1.环境准备

mycat是使用java语言开发的，需要先安装java运行环境，由于mycat中使用了JDK7中的一些特性，所以要求JDK7以上的版本才能运行。

JDK下载：

http://www.java.com/zh_CN/

MyCAT最新开源版本下载，项目主页：
https://github.com/MyCATApache/

MyCAT 二进制包下载：

https://github.com/MyCATApache/Mycat-download

MyCAT 文档下载：

https://github.com/MyCATApache/Mycat-doc

MySQL 下载：

http://dev.mysql.com/downloads/mysql/5.5.html#downloads
(注：MyCAT支持多种数据库接入，如：MySQL、SQL Server、Oracle、MongoDB等. 推荐使用MySQL做集群.)
在这里插入图片描述

2.环境安装与配置

如果是第一次刚接触MyCat建议下载源码在本地通过eclipse等工具进行配置和运行，便于深入了解和调试程序运行逻辑。

1）源代码方式调试与配置
由于MyCat源代码目前主要托管在github上，大家需要在本地安装和配置好相关环境，具体参考群共享中 “github-eclipse开发指南.docx”说的很详细，按照文档中的步骤把源代码下载到本地即可。
MyCAT目前通过配置文件的方式来定义逻辑库和相关配置：
MYCAT_HOME/conf/schema.xml中定义逻辑库，表、分片节点等内容
MYCAT_HOME/conf/rule.xml中定义分片规则
MYCAT_HOME/conf/server.xml中定义用户以及系统相关变量，如端口等。

运行：
入口程序是org.opencloudb.MycatStartup.java，右键run as 出现下面的界面，需要设置MYCAT_HOME目录，为你工程当前所在目录(src/main):
在这里插入图片描述

设置完MYCAT主目录后即可正常运行MyCAT服务。

注：若启动报错，DirectBuffer内存不够，则可以再加JVM系统参数：
XX:MaxDirectMemorySize=128M

使用MyCAT 服务安装包方式运行与配置
MyCAT 有提供编译好的安装包，支持windows、Linux、Mac、Solaris等系统上安装与运行。
windows下可以下载Mycat-server-xxxxxxx-win.tar.gz
linux下可以下载Mycat-server-xxxxxxx.linux.tar.gz 解压在某个目录下，注意目录不能有空格，在Linux(Unix)下，建议放在usr/local/MyCAT目录下，如下:

下面是修改MyCAT用户密码的方式(仅供参考)：
在这里插入图片描述

在这里插入图片描述

目录解释如下：
bin 程序目录，存放了window版本和linux版本，除了提供封装成服务的版本之外，也提供了nowrap的shell脚本命令，方便大家选择和修改，进入到bin目录：
Windows 下运行: mycat.bat console 在控制台启动程序，也可以装载成服务，若此程序运行有问题，也可以运行startup_nowrap.bat，确保java命令可以在命令执行。
Linux下运行：mycat console,首先要chmod +x *
Warp方式的命令，可以安装成服务并启动或停止(做成服务的方式)。
mycat install (可选)
mycat start
注意，wrap方式的程序，其JVM配置参数在conf/wrap.conf中，可以修改为合适的参数，参数调整参照http://wrapper.tanukisoftware.com/doc/english/properties.html

conf目录下存放配置文件，server.xml是Mycat服务器参数调整和用户授权的配置文件，schema.xml是逻辑库定义和表以及分片定义的配置文件，rule.xml是分片规则的配置文件，分片规则的具体一些参数信息单独存放为文件，也在这个目录下，配置文件修改，需要重启Mycat或者通过9066端口reload。

lib目录下主要存放mycat依赖的一些jar文件；

日志存放在logs/mycat.log中，每天一个文件，日志的配置是在conf/log4j.xml中，根据自己的需要，可以调整输出级别为debug，debug级别下，会输出更多的信息，方便排查问题。

3.数据库映射与配置

MyCAT逻辑库相关概念：
schema:逻辑库，与MySQL中的Database（数据库）对应，一个逻辑库中定义了所包括的Table。
table：表，即物理数据库中存储的某一张表，与传统数据库不同，这里的表格需要声明其所存储的逻辑数据节点DataNode，这是通过表格的分片规则定义来实现的，table可以定义其所属的“子表(childTable)”，子表的分片依赖于与“父表”的具体分片地址，简单的说，就是属于父表里某一条记录A的子表的所有记录都与A存储在同一个分片上。
分片规则：是一个字段与函数的捆绑定义，根据这个字段的取值来返回所在存储的分片（DataNode）的序号，每个表格可以定义一个分片规则，分片规则可以灵活扩展，默认提供了基于数字的分片规则，字符串的分片规则等。
DataNode：MyCAT的逻辑数据节点，是存放table的具体物理节点，也称之为分片节点，通过DataSource来关联到后端某个具体数据库上，一般来说，为了高可用性，每个DataNode都设置两个DataSource，一主一丛，当主节点宕机，系统自动切换到从节点。
DataSource：定义某个物理库的访问地址，用于捆绑到Datanode上。

编辑MYCAT_HOME/conf/schema.xml文件，增加对物理数据表映射信息：
在这里插入图片描述

table节点中各属性说明：
name：指定物理表名称；
primaryKey：指定物理表主键名称；
autoIncrement：指定主键是否采用自增长策略，如果不需要自增长可不用配置；
dataNode：指定表所在的逻辑数据节点，如果有多个节点可使用逗号分隔，也可使用表达式dn$0-99 指定在0-99这100个节点上都使用(如果是一个节点上有多个库可使用db1$0-99)；
rule：指定路由规则；

逻辑数据节点与物理主机配置：
在这里插入图片描述

dataNode节点中各属性说明：
name：指定逻辑数据节点名称；
dataHost：指定逻辑数据节点物理主机节点名称；
database：指定物理主机节点上。如果一个节点上有多个库，可使用表达式db$0-99，表示指定0-99这100个数据库；

dataHost 节点中各属性说明：
name：物理主机节点名称；
maxCon：指定物理主机服务最大支持1000个连接；
minCon：指定物理主机服务最小保持10个连接；
writeType：指定写入类型；
0，只在writeHost节点写入；
1，在所有节点都写入。慎重开启，多节点写入顺序为默认写入根据配置顺序，第一个挂掉切换另一个；
dbType：指定数据库类型；
dbDriver：指定数据库驱动；
balance：指定物理主机服务的负载模式。
0，不开启读写分离机制；
1，全部的readHost与stand by writeHost参与select语句的负载均衡，简单的说，当双主双从模式(M1->S1，M2->S2，并且M1与 M2互为主备)，正常情况下，M2,S1,S2都参与select语句的负载均衡；
2，所有的readHost与writeHost都参与select语句的负载均衡，也就是说，当系统的写操作压力不大的情况下，所有主机都可以承担负载均衡；

一个dataHost元素，表明进行了数据同步的一组数据库，DBA需要保证这一组数据库服务器是进行了数据同步复制的。writeHost相当于Master DB Server，而其下的readHost则是与从数据库同步的Slave DB Server。当dataHost配置了多个writeHost的时候，任何一个writeHost宕机，Mycat 都会自动检测出来，并尝试切换到下一个可用的writeHost；

MyCAT支持高可用性的企业级特性，根据您的应用特性，可以配置如下几种策略：
后端数据库配置为一主多从，并开启读写分离机制；
后端数据库配置为双主双从（多从），并开启读写分离机制；
后端数据库配置为多主多从，并开启读写分离机制；
后面两种配置，具有更高的系统可用性，当其中一个写节点（主节点）失败后，Mycat会侦测出来（心跳机制）并自动切换到下一个写节点，MyCAT在任何时候，只会往一个写节点写数据;

下面是典型的双主双从的Mysql集群配置：
在这里插入图片描述

4.sequence设置与使用

在实现分库分表的情况下，MySql自增主键已无法保证自增主键的全局唯一，为此，MyCat 提供了全局sequence，并使用两种机制实现这种全局sequence，分别是文件形式和数据库形式。

1）sequence使用方式
Sequence名称：TEST_SEQ；
使用方式：select next value for MYCATSEQ_TEST_SEQ；
注意，使用时sequence名称前一定要加大写的“MYCATSEQ_”；

2）文件形式
原理：此种方式MyCat将sequence配置到文件中，当使用到配置中的sequence后，MyCat会更新classpath中的sequence_conf.properties文件中的sequence当前值；

配置方式：
在sequence_conf.properties文件中做如下配置：
# self define sequence
TEST_SEQ.HISIDS=
TEST_SEQ.MINID=1001
TEST_SEQ.MAXID=2000
TEST_SEQ.CURID=1000
其中MINID：最小值； MAXID：最大值；CURID：当前值；

server.xml配置

0 sequnceHandlerType配置为0，表示使用文件形式；

缺点：
当MyCat重新发布后，sequence会恢复到初始值；

3）数据库形式
原理：此种方式是在数据库中建立一张表，存放sequence名称(name)，sequence当前值(current_value)，步长（increment int类型每次读取多少个sequence，假设为K）等信息；

Sequence获取步骤：
❶、当初次使用该sequence时，根据传入的sequence名称，从数据库这张表中读取 current_value，和increment到MyCat中，并将数据库中的current_value设置为原 current_value值+increment值；
❷、MyCat将读取到current_value+increment作为本次要使用的sequence值，下次使用时，自动加1，当使用increment次后，执行步骤❶相同的操作；
MyCat负责维护这张表，用到哪些sequence，只需要在这张表中插入一条记录即可。若某次读取的sequence没有用完，系统就停掉了，则这次读取的sequence剩余值不会在使用；
配置方式：
server.xml配置

1

sequnceHandlerType配置为1，表示使用数据库形式；

数据库配置:
	建立sequence相关表和函数，具体如附件:
	 ![在这里插入图片描述](https://img-blog.csdnimg.cn/5febeb455aea4f338ec31dcf7a57a587.png)

sequence_db_conf.properties文件配置：

指定sequence相关表和函数在哪个节点上：
Test_SEQ=dn1

4）sequence使用
目前mycat中支持配置全局sequence和自定义sequence两种方式。

使用默认的全局sequence :

insert into tb1(id,name) values(next value for MYCATSEQ_GLOBAL,‘micmiu.com’);

使用自定义的 sequence :

insert into tb2(id,name) values(next value for MYCATSEQ_MY1,‘micmiu.com’);

注：在没有特殊需求的情况下，建议每个表都使用自定义的sequence，每个表配置一个，这样比较方便管理和维护；

5）autoIncrement开启
在mycat中使用主键自增长需要在schema.xml的table节点中的autoIncrement设置为true表示开启主键自增长策略；

5.catlet支持

通过catlet支持跨分片复杂SQL实现以及存储过程支持等。使用方式主要通过mycat注释的方式来执行，如下：

跨分片联合查询注解支持：
/!mycat:catlet=demo.catlets.ShareJoin / select bu.,sg. from base_user bu,sam_glucose sg where bu.id_=sg.user_id；
注：sam_glucose 是跨分片表；
存储过程注解支持：
/!mycat: sql=select * from base_user where id_=1;/CALL proc_test();
注：目前执行存储过程通过mycat注解的方式执行，注意需要把存储过程中的sql写到注解中；

6.MySQL主从配置

在这里插入图片描述

在使用mycat管理一个mysql集群的时候经常需要使用主从数据复制的功能，以下是基于mysql5.5以上版本最新的主从配置：

开启mysql主从数据复制，主要在mysql的my.ini文件中设置：
windows系统一般在c:\ProgrameData\MySQL中；
Linux系统一般在 /etc/my.cnf中；

1、主数据库服务器配置：
server-id=1
log-bin=mysql-bin
binlog-do-db=sam_test //只同步sam_test数据库
binlog-ignore-db=mysql //避免同步mysql用户配置，以免不必要的麻烦

2、创建一个允许从服务器来访问的用户(主服务器)：
grant replication slave on . to ‘p1test’@‘192.168.18.74’ identified by ‘123456’;

3、从数据库服务器配置：
server-id=101
log-bin=mysql-bin
replicate-do-db=sam_test //指定只同步的数据库
replicate-ignore-db=mysql //屏蔽对mysql用户配置的同步，以免不必要的麻烦

4、在从数据库服务器上给主服务器授权：
注意：mysql5.1版本以上，从服务器上my.ini中不支持配置master-host= … 此类配置；
需要采用：
mysql> stop slave;
mysql> change master to master_host=‘192.168.18.78’,master_user=‘p1test’,master_password=‘123456’;
mysql> slave start;

查看主服务数据同步状态：
show master status;
或 show master status\G;

查看从服务数据同步状态：
show slave status;
或 show slave status\G;

在学习和使用mycat过程中主要参考的文档有：
MyCat_In_Action_中文版.doc
Mycat_Develope_Guide.docx
Mycat最权威Mysql主从配置手册.docx
mycat路由解析开发指南.docx
MyCat Sequence机制.docx
MyCat Sequence配置.sql
github-eclipse开发指南.docx
github个人使用笔记.doc
MyCat不支持的Sql语句.docx
MyCat生产部署经验分享.docx
分布式数据库选型.pptx

基于案例配置

我有一张线上日志表数据海量
CREATE TABLE zuolog (
id bigint(15) NOT NULL AUTO_INCREMENT COMMENT ‘主键自增日志id’,
accountcode varchar(30) NOT NULL COMMENT ‘账户码’,
consumetype decimal(2,0) NOT NULL COMMENT ‘0：计费 1：充值(消费类型)’,
consumevalue decimal(11,1) NOT NULL COMMENT ‘消费为负数，充值为正数（特殊情况下可为负），以元为单位，最小值为0.1’,
moneytype tinyint(2) NOT NULL COMMENT ‘0：普通 1：优惠券’,
chargedtype tinyint(2) NOT NULL COMMENT '0：放件 1揽件 2广告，3 市民卡充值 ',
targetid decimal(11,0) NOT NULL COMMENT ‘快件id,揽件id,广告id等(消费实体id)’,
consumetime datetime NOT NULL DEFAULT ‘1753-01-01 12:00:00’ COMMENT ‘yyyy-dd-MM hh:mm:ss(消费时间)’,
opuserid bigint(20) NOT NULL COMMENT ‘user_base.id 关联(操作人id)’,
content varchar(300) DEFAULT NULL,
note1 varchar(2) DEFAULT NULL,
note2 varchar(2) DEFAULT NULL,
isbackmoney tinyint(1) NOT NULL DEFAULT ‘1’ COMMENT ‘0：否，1是默认 1(是否参与返帐)’,
consumestauts tinyint(1) NOT NULL DEFAULT ‘0’ COMMENT ‘0：完成 1：预消费(消费状态)’,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=1564262 DEFAULT CHARSET=utf8 COMMENT=‘消费日志’;

现在数据以及好几千了所以需要mycat 负载也高所以架构图这里划一下手绘本事不大还望见谅啊

在这里插入图片描述

配置文件schema.xml配置

[root@node24 conf]#cat schema.xml 
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://org.opencloudb/">

        <schema name="yungui" checkSQLschema="false" sqlMaxLimit="100">
<!--            <table name="travelrecord" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />   -->
<!--            <table name="company" primaryKey="ID" type="global" dataNode="dn1,dn2,dn3" /> -->
<!--            <table name="goods" primaryKey="ID" type="global" dataNode="dn1,dn2" /> -->
                <!-- random sharding using mod sharind rule -->
<!--            <table name="hotnews" primaryKey="ID" dataNode="dn1,dn2,dn3"
                        rule="mod-long" />  -->
                <!-- <table name="dual" primaryKey="ID" dataNode="dnx,dnoracle2" type="global" 
                        needAddLimit="false"/> <table name="worker" primaryKey="ID" dataNode="jdbc_dn1,jdbc_dn2,jdbc_dn3" 
                        rule="mod-long" /> -->
                <table name="employee" primaryKey="ID" autoIncrement="true"  dataNode="dn1,dn2"
                        rule="sharding-by-intfile" />

        <table name="zuolog" primaryKey="id" autoIncrement="true"  dataNode="dn1,dn2,dn3,dn4,dn5"
        rule="mod-long" /> 
        <table name="tt2" primaryKey="id" autoIncrement="true" dataNode="dn1,dn2,dn3,dn4,dn5" rule="mod-long" />
        <table name="MYCAT_SEQUENCE" primaryKey="name"   dataNode="dn1" />


<!--            <table name="customer" primaryKey="ID" dataNode="dn1,dn2"
                        rule="sharding-by-intfile"> -->
<!--                    <childTable name="orders" primaryKey="ID" joinKey="customer_id"
                                parentKey="id">   -->
<!--                            <childTable name="order_items" joinKey="order_id"
                                        parentKey="id" />  
                        </childTable> -->
<!--                    <childTable name="customer_addr" primaryKey="ID" joinKey="customer_id"
                                parentKey="id" />
                </table>   -->
                <!-- <table name="oc_call" primaryKey="ID" dataNode="dn1$0-743" rule="latest-month-calldate" 
                        /> -->
        </schema>
        <!-- <dataNode name="dn1$0-743" dataHost="localhost1" database="db$0-743" 
                /> -->
        <dataNode name="dn1" dataHost="10.1.166.22" database="db1" />
        <dataNode name="dn2" dataHost="10.1.166.23" database="db2" />
        <dataNode name="dn3" dataHost="10.1.166.24" database="db3" />
        <dataNode name="dn4" dataHost="10.1.166.25" database="db4" />
        <dataNode name="dn5" dataHost="10.1.166.26" database="db5" />
        <!--<dataNode name="dn4" dataHost="sequoiadb1" database="SAMPLE" />
         <dataNode name="jdbc_dn1" dataHost="jdbchost" database="db1" /> 
        <dataNode       name="jdbc_dn2" dataHost="jdbchost" database="db2" /> 
        <dataNode name="jdbc_dn3"       dataHost="jdbchost" database="db3" /> -->
        <dataHost name="10.1.166.22" 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="10.1.166.22:3306" user="root"
                        password="123456">
                        <!-- can have multi read hosts -->

                </writeHost>
                <writeHost host="hostS1" url="10.1.166.22:3306" user="root"
                        password="123456" />
                <!-- <writeHost host="hostM2" url="localhost:3306" user="root" password="123456"/> -->
        </dataHost>




        <dataHost name="10.1.166.23" 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="10.1.166.23:3306" user="root"
                        password="123456">
                        <!-- can have multi read hosts -->

                </writeHost>
                <writeHost host="hostS1" url="10.1.166.23:3306" user="root"
                        password="123456" />
                <!-- <writeHost host="hostM2" url="localhost:3306" user="root" password="123456"/> -->
        </dataHost>

        <dataHost name="10.1.166.24" 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="10.1.166.24:3306" user="root"
                        password="123456">
                        <!-- can have multi read hosts -->

                </writeHost>
                <writeHost host="hostS1" url="10.1.166.24:3306" user="root"
                        password="123456" />
                <!-- <writeHost host="hostM2" url="localhost:3306" user="root" password="123456"/> -->
        </dataHost>


        <dataHost name="10.1.166.25" 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="10.1.166.25:3306" user="root"
                        password="123456">
                        <!-- can have multi read hosts -->

                </writeHost>
                <writeHost host="hostS1" url="10.1.166.25:3306" user="root"
                        password="123456" />
                <!-- <writeHost host="hostM2" url="localhost:3306" user="root" password="123456"/> -->
        </dataHost>


        <dataHost name="10.1.166.26" 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="10.1.166.26:3306" user="root"
                        password="123456">
                        <!-- can have multi read hosts -->

                </writeHost>
                <writeHost host="hostS1" url="10.1.166.26:3306" user="root"
                        password="123456" />
                <!-- <writeHost host="hostM2" url="localhost:3306" user="root" password="123456"/> -->
        </dataHost>

        <!--
                <dataHost name="sequoiadb1" maxCon="1000" minCon="1" balance="0" dbType="sequoiadb" dbDriver="jdbc"> 
                artbeat>                </heartbeat>
                 <writeHost host="hostM1" url="sequoiadb://1426587161.dbaas.sequoialab.net:11920/SAMPLE" user="jifeng"        password="jifeng"></writeHost> 
                 </dataHost>             
                 
          <dataHost name="oracle1" maxCon="1000" minCon="1" balance="0" writeType="0"   dbType="oracle" dbDriver="jdbc"> <heartbeat>select 1 from dual</heartbeat> 
                <connectionInitSql>alter session set nls_date_format='yyyy-mm-dd hh24:mi:ss'</connectionInitSql> 
                <writeHost host="hostM1" url="jdbc:oracle:thin:@127.0.0.1:1521:nange" user="base"       password="123456" > </writeHost> </dataHost> 

                <dataHost name="jdbchost" maxCon="1000"         minCon="1" balance="0" writeType="0" dbType="mongodb" dbDriver="jdbc"> 
                <heartbeat>select       user()</heartbeat> 
                <writeHost host="hostM" url="mongodb://192.168.0.99/test" user="admin" password="123456" ></writeHost> </dataHost> 

                <dataHost name="sparksql" maxCon="1000" minCon="1" balance="0" dbType="spark" dbDriver="jdbc"> 
                <heartbeat> </heartbeat>
                 <writeHost host="hostM1" url="jdbc:hive2://feng01:10000" user="jifeng"         password="jifeng"></writeHost> </dataHost> -->

        <!-- <dataHost name="jdbchost" maxCon="1000" minCon="10" balance="0" dbType="mysql" 
                dbDriver="jdbc"> <heartbeat>select user()</heartbeat> <writeHost host="hostM1" 
                url="jdbc:mysql://localhost:3306" user="root" password="123456"> </writeHost> 
                </dataHost> -->
</mycat:schema>

该配置文件是出错容易最多的地方需特别注意

配置数据名密码 server.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- - - Licensed under the Apache License, Version 2.0 (the "License");
        - you may not use this file except in compliance with the License. - You
        distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT
        WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the
        License for the specific language governing permissions and - limitations
        under the License. -->
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://org.opencloudb/">
        <system>
        <property name="defaultSqlParser">druidparser</property>
      <!--  <property name="useCompression">1</property>--> <!--1为开启mysql压缩协议-->
        <!-- <property name="processorBufferChunk">40960</property> -->
        <!--
        <property name="processors">1</property>
        <property name="processorExecutor">32</property>
         -->
                <!--默认是65535 64K 用于sql解析时最大文本长度 -->
                <!--<property name="maxStringLiteralLength">65535</property>-->
                <!--<property name="sequnceHandlerType">0</property>-->
                <!--<property name="backSocketNoDelay">1</property>-->
                <!--<property name="frontSocketNoDelay">1</property>-->
                <!--<property name="processorExecutor">16</property>-->
                <!--
                        <property name="mutiNodeLimitType">1</property> 0：开启小数量级（默认） ；1：开启亿级数据排序
                <property name="mutiNodePatchSize">100</property> 亿级数量排序批量
                        <property name="processors">32</property> <property name="processorExecutor">32</property>
                        <property name="serverPort">8066</property> <property name="managerPort">9066</property>
                        <property name="idleTimeout">300000</property> <property name="bindIp">0.0.0.0</property>
                        <property name="frontWriteQueueSize">4096</property> <property name="processors">32</property>
 -->
        </system>
        <user name="adminz">
                <property name="password">xinchengyungui</property>
                <property name="schemas">yungui</property>
        </user>

        <user name="adminz">
                <property name="password">xinchengyungui</property>
                <property name="schemas">yungui</property>
                <property name="readOnly">true</property>
        </user>
        <!-- <cluster> <node name="cobar1"> <property name="host">127.0.0.1</property>
                <property name="weight">1</property> </node> </cluster> -->
        <!-- <quarantine> <host name="1.2.3.4"> <property name="user">test</property>
                </host> </quarantine> -->

</mycat:server>

配置节点数 rule.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- - - Licensed under the Apache License, Version 2.0 (the "License");
        - you may not use this file except in compliance with the License. - You
        may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0
        - - Unless required by applicable law or agreed to in writing, software -
        distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT
        WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the
        License for the specific language governing permissions and - limitations
        under the License. -->
<!DOCTYPE mycat:rule SYSTEM "rule.dtd">
<mycat:rule xmlns:mycat="http://org.opencloudb/">
        <tableRule name="rule1">
                <rule>
                        <columns>id</columns>
                        <algorithm>func1</algorithm>
                </rule>
        </tableRule>

        <tableRule name="rule2">
                <rule>
                        <columns>user_id</columns>
                        <algorithm>func1</algorithm>
                </rule>
        </tableRule>

        <tableRule name="sharding-by-intfile">
                <rule>
                        <columns>sharding_id</columns>
/5
                </rule>
        </tableRule>

        <tableRule name="jch">
                <rule>
                        <columns>id</columns>
                        <algorithm>jump-consistent-hash</algorithm>
                </rule>
        </tableRule>

        <function name="murmur"
                class="org.opencloudb.route.function.PartitionByMurmurHash">
                <property name="seed">0</property><!-- 默认是0 -->
                <property name="count">5</property><!-- 要分片的数据库节点数量，必须指定，否则没法分片 -->
                <property name="virtualBucketTimes">160</property><!-- 一个实际的数据库节点被映射为这么多虚拟节点，默>
认是160倍，也就是虚拟节点数是物理节点数的160倍 -->
                <!-- <property name="weightMapFile">weightMapFile</property> 节点的权重，没有指定权重的节点默认是1。以
properties文件的格式填写，以从0开始到count-1的整数值也就是节点索引为key，以节点权重值为值。所有权重值必须是正整数，否>
则以1代替 -->
                <!-- <property name="bucketMapPath">/etc/mycat/bucketMapPath</property>
                        用于测试时观察各物理节点与虚拟节点的分布情况，如果指定了这个属性，会把虚拟节点的murmur hash值>
与物理节点的映射按行输出到这个文件，没有默认值，如果不指定，就不会输出任何东西 -->
        </function>
        <function name="hash-int"
                class="org.opencloudb.route.function.PartitionByFileMap">
                <property name="mapFile">partition-hash-int.txt</property>
        </function>
        <function name="rang-long"

自增主键

配置server.xml 开启数据库层面设计的自增主键还有基于本地的和catle的但是我这里用基于数据库的也是mycat作者推荐的方式
1
配置sequence_db_conf.properties
[root@node24 conf]#vi sequence_db_conf.properties
#sequence stored in datanode
GLOBAL=dn1
COMPANY=dn1
CUSTOMER=dn1
ORDERS=dn1
tt2=dn1
TT2=dn1
zuolog=dn1
ZUOLOG=dn1

haproxy+mycat

再安装一个mycat配置的一样一样的

环境描述

mysql5
OS: Oracle Linux Server release 6.3
Mycat server1:10.0.30.134:8806
Mycat server2:10.0.30.139:8806
Haproxy server:10.0.30.139: 8098
前期未启用VIP，所以先用Mycat server2的8098端口作为haproxy的对外接口

Mycat 安装

在Mycat server1及Mycat server2上进行安装Mycat

Linux(Unix)下，建议放在/usr/local/MyCAT目录下，如下面类似的：

useradd mycat
chown –R mycat.mycat /usr/local/mycat

启动mycat
/usr/local/mycat/bin/mycat start

Haproxy 的安装

useradd haproxy
#wget http://haproxy.1wt.eu/download/1.4/src/haproxy-1.4.25.tar.gz
#tar zcvf haproxy-1.3.20.tar.gz
#cd haproxy-1.3.20
#make TARGET=linux26 PREFIX=/usr/local/haprpxy ARCH=x86_64
#make install
安装完毕后，进入安装目录创建配置文件
#cd /usr/local/haproxy
#chown –R haproxy.haproxy *
#vi haproxy.cfg
global
log 127.0.0.1 local0 ##记日志的功能
maxconn 4096
chroot /usr/local/haproxy
user haproxy
group haproxy
daemon
defaults
log global
option dontlognull
retries 3
option redispatch
maxconn 2000
contimeout 5000
clitimeout 50000
srvtimeout 50000
listen admin_stats 10.0.30.139:48800 ##由于没有启用VIP，暂时用其中一台的IP和新端口
stats uri /admin-status ##统计页面
stats auth admin:admin
mode http
option httplog
listen allmycat 10.0.30.139:8098
mode tcp
option tcplog
option httpchk OPTIONS * HTTP/1.1\r\nHost:\ www
balance roundrobin
server mycat_134 10.0.30.134:8066 check port 48700 inter 5s rise 2 fall 3
server mycat_139 10.0.30.139:8066 check port 48700 inter 5s rise 2 fall 3
srvtimeout 20000
默认haproxy是不记录日志的，为了记录日志还需要配置syslog模块，在oracle linux下是rsyslogd服务，yum –y install rsyslog 先安装rsyslog，然后
#vi /etc/rsyslog.d/haproxy.conf
加入以下内容
$ModLoad imudp
$UDPServerRun 514
local0.* /var/log/haproxy.log ##对应haproxy.cfg 的日志记录选项
保存，重启
service rsyslog restart
现在你就可以看到日志了

在Mycat server1 Mycat server2上都需要添加检测端口48700的脚本，为此需要用到xinetd
首先在xinetd目录下面增加脚本与端口的映射配置文件
#vim /etc/xinetd.d/mycat_status
service mycat_status
{
flags = REUSE
socket_type = stream
port = 48700
wait = no
user = nobody
server = /usr/local/bin/mycat_status
log_on_failure += USERID
disable = no
}
再增加/usr/local/bin/mycat_status用于检测mycat是否运行的脚本
#vim /usr/local/bin/mycat_status
#!/bin/bash
#/usr/local/bin/mycat_status.sh
#This script checks if a mycat server is healthy running on localhost. It will
#return:
#“HTTP/1.x 200 OK\r” (if mycat is running smoothly)
#“HTTP/1.x 503 Internal Server Error\r” (else)
mycat=/usr/local/mycat/bin/mycat status | grep 'not running' | wc -l
if [ “$mycat” = “0” ];
then
/bin/echo -e “HTTP/1.1 200 OK\r\n”
else
/bin/echo -e “HTTP/1.1 503 Service Unavailable\r\n”
fi
我是根据mycat status 返回的状态来判定mycat是否在运行的，也可以直接通过mysql –P8806 –e”select user()” 等直接执行sql的形式来检测
重启xinetd服务
#service xinetd restart
查看48700端口是否监听了
#netstat -antup|grep 48700
在这里插入图片描述

如上图则端口的配置正确了

启动haproxy

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

为了使用方便可以增加一个启动，停止haproxy的脚本
启动脚本starthap内容如下
#!/bin/sh
/usr/local/haproxy/sbin/haproxy -f /usr/local/haproxy/haproxy.cfg &

停止脚本stophap内容如下
#!/bin/sh
ps -ef | grep sbin/haproxy | grep -v grep |awk ‘{print $2}’|xargs kill -s 9

分别赋予启动权限
chmod +x starthap
chmod +x stophap

启动后可以通过http://10.0.30.139:48800/admin-status (用户名密码都是admin haproxy.cnfg配置的)

percona集群+mycat+haproxy+keepalived

在这里插入图片描述

看我的集群比对然后加进来就行了

使用需谨慎报错无人理只能靠自己

alwarse

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【微服务/淘淘商城实践/SSM框架】12 Mysql 集群 Mycat (读写分离，双主多从，一主多从、全局表、E-R分片策略、水平拆分和路由算法) 逻辑数据节点与物理主机配置

Mysql 集群 Mycat读写分离，双主多从，一主多从、全局表、E-R分片策略、水平拆分和路由算法逻辑数据节点与物理主机配置HA架构
复制链接

扫一扫