MyCat入门

最新推荐文章于 2023-07-08 15:05:22 发布

xiaoHui_1126

最新推荐文章于 2023-07-08 15:05:22 发布

阅读量292

点赞数 1

分类专栏： MyCAT 文章标签：分布式数据库中间件

本文链接：https://blog.csdn.net/xiaohui_1126/article/details/105363775

版权

MyCAT 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

MyCat入门

mysql集群

一个庞大的分布式系统的性能瓶颈中，最脆弱的是两个连接，一个是客户端与后端的连接，一个是后端与数据库的连接。说白了就是发送端请求太多，接收端能够的接收和处理的请求并不多。客户端与后端可以利用类似nginx的负载均衡解决，后端与数据库中可以利用类似mycat的负载均衡实现mysql集群，提高mysql的总体性能。

什么是MyCAT

MyCAT是

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

MyCAT的目标

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

也就是：MyCAT的目的是能满足数据库数据大量存储和提高了查询性能。

MyCAT的关键特性

支持 SQL 92标准
支持Mysql集群，可以作为Proxy使用

Proxy是基于 MySQL 的一款开源的中间件的产品，是一个灵活的 MySQL 代理层，可以实现读写分离，支持 Query 路由功能，支持动态指定某个 SQL 进行缓存，支持动态加载（无需重启 ProxySQL 服务），故障切换和一些 SQL 的过滤功能。

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

MyCAT架构

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

常见高可用集群方式

在生产环境中，MyCAT节点最好使用双节点，即双机热备环境，防止MyCAT出现单点故障。

Keepalived+MyCAT+Mysql
Keepalived+LVS+MyCAT+Mysql
Keepalived+Haproxy+MyCAT+Mysql

MyCAT典型应用场景

单纯的读写分离，此时配置最为简单，支持读写分离，主从切换；
分表分库，对于超过1000万的表进行分片，最大支持1000亿的单表分片；
多租户应用，每个应用一个库，但应用程序只连接MyCAT，从而不改造程序本身，实现多租户化；
报表系统，借助于MyCAT的分表能力，处理大规模报表的统计；
替代Hbase，分析大数据；
作为海量数据实时查询的一种简单有效方案，比如100亿条频繁查询的记录需要在3秒内查询出来结果，除了基于主键的查询，还可能存在范围查询或其他属性查询，此时MyCAT可能是最简单有效的选择；
强化分布式数据库中间件的方面的功能，使之具备丰富的插件、强大的数据库智能优化功能、全面的系统监控能力、以及方便的数据运维工具，实现在线数据扩容、迁移等高级功能；
进一步挺进大数据计算领域，深度结合Spark Stream和Storm等分布式实时流引擎，能够完成快速的巨表关联、排序、分组聚合等 OLAP方向的能力，并集成一些热门常用的实时分析算法，让工程师以及DBA们更容易用MyCAT实现一些高级数据分析处理功能。

MyCAT不适合的应用场景

设计使用MyCAT时有非分片字段查询
设计使用MyCAT时有分页排序
设计使用MyCAT时如果要进行表JOIN操作，要确保两个表的关联字段具有相同的数据分布
设计使用MyCAT时如果有分布式事务，得先看是否得保证事务得强一致性

分库分表

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

主要有两种分片形式：

垂直切片：将不同的表切分到不同的数据库中
水平切片：将同一种表按照条件切分到不同的数据库中

Schema：逻辑库，与MySQL中的Database（数据库）对应，一个逻辑库中定义了所包括的Table。

Table：逻辑表，即物理数据库中存储的某一张表，与传统数据库不同，这里的表格需要声明其所存储的逻辑数据节点DataNode。在此可以指定表的分片规则。

DataNode：MyCAT的逻辑数据节点，是存放table的具体物理节点，也称之为分片节点，通过DataSource来关联到后端某个具体数据库上。

DataSource：定义某个物理库的访问地址，用于捆绑到Datanode上。

配置文件说明

schema.xml

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

	<!--
	name：为mycat逻辑库的名字，对应server<property name="schemas">mydatabase</property>，
	建议设置跟数据库一样的名称
	checkSQLschema：自动检查逻辑库名称并拼接，true会在sql语句中的表名前拼接逻辑库名，
	例如select * from mydatabase.t_user;
	sqlMaxLimit：查询保护、如果没有写limit条件，会自动拼接。只查询100条。
	-->
	<schema name="mydatabase" checkSQLschema="true" sqlMaxLimit="100">
		<!--
		name:为物理数据库的表名，命名与物理数据库的一致 
		dataNode:为dataNode标签(<dataNode name="dn1" dataHost="dtHost1" database="db1" />)里面的name值
		dataNode里面填写的节点数量必须和rule里面的规则数量一致
		例如rule里面只定义了两个0-1M=0  1M-2M=1那么此处只可以指定两个节点,1M=10000，M为单位万
		primaryKey:为表的ID字段，建议和rule.xml里面指定的ID和物理库的ID一致
		rule：分片规则，对应rule.xml中<tableRule name="student_id">的name
		type：表格类型，默认非global，用于全局表定义
		-->
		<table name="t_user" dataNode="dn1,dn2,dn3" primaryKey="id" rule="auto-sharding-long">
			<!--ER分片注意childTable 标签需要放到table标签内，是主外键关联关系，
				name:为物理数据库的表名，命名与物理数据库的一致 
				primaryKey:为表t_loginlog的ID字段，建议和rule.xml里面指定的ID和物理库的ID一致.
				joinKey：从表t_loginlog的外键字段，需要和物理库的字段名称一致
				parentKey：为主表t_user的字段名，依据此字段做关联，进行ER分片
			-->		
			<childTable name="t_loginlog" primaryKey="id" joinKey="user_id" parentKey="id"></childTable>
		</table>
		<table name="t_student" dataNode="dn1,dn3" primaryKey="id" rule="auto-sharding-long" />
		<table name="t_dictionaries" dataNode="dn1,dn2,dn3" type="global" />
		<table name="t_teacher" dataNode="dn1" />
    </schema>
		
		<!-- name：节点名称，用于在table标签里面调用
		dataHost:dataHost标签name值(<dataHost name="dtHost1">)
		database:物理数据库名，需要提前创建好实际存在的,是真实数据库服务上的数据库名-->
		<dataNode name="dn1" dataHost="dtHost1" database="db1" />
		<dataNode name="dn2" dataHost="dtHost1" database="db2" />
		<dataNode name="dn3" dataHost="dtHost2" database="db3" />
		
	<!--
	name：节点名称，在上方dataNode标签中调用
	maxCon:底层数据库的链接最大数
	minCon:底层数据库的链接最小数

	balance:值可以为0,1,2,3,分别表示对当前datahost中维护的数据库们的读操作逻辑
	0:不开启读写分离，所有的读写操作都在最小的索引号的writeHost(第一个writeHost标签)
	1：全部的readHost和备用writeHost都参与读数据的平衡，如果读的请求过多，负责写的第一个writeHost也分担一部分。简单的说，当双主双从模式(M1->S1，M2->S2，并且M1与M2互为主备)，正常情况下，M1，M2,S1,S2都参与 select语句的负载均衡。
	2 ：所有的读操作，都随机的在所有的writeHost和readHost中进行
	3 ：所有的读操作，都到writeHost对应的readHost上进行（备用writeHost不参加了）,在集群中没有配置ReadHost的情况下,读都到第一个writeHost完成

	writeType:控制当前datahost维护的数据库集群的写操作
	0：所有的写操作都在第一个writeHost标签的数据库进行，第一个挂了切到还生存的第二个writeHost，重新启动后已切换后的为准，切换记录在配置文件中:dnindex.properties。
	1：所有的写操作，都随机分配到所有的writeHost
	dbtype：数据库类型（不同数据库配置不同名称，mysql）
	dbDriver:数据库驱动，native,动态获取

	switchType：切换的逻辑
	-1：故障不切换，不启用主从切换
	1：默认值，故障自动切换，当前写操作的writeHost故障，进行切换，切换到下一个writeHost；心跳检测语句，一般为select user();
	2：基于主从同步的状态，决定是否切换，与show slave status心跳对应；
	3：基于多住galary集群切换，与show status like 'wsrep%'对应；

	slaveThreshold：标签中的<heartbeat>用来检测后端数据库的心跳sql语句;本属性检查从节点与主节点的同步情况(延迟时间数),配合心跳语句show slave status; 读写分离时,所有的readHost的数据都可靠
	-->
	<dataHost name="dtHost1" maxCon="1000" minCon="10" balance="1"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<!--用于验证心跳，这个是mysql主库的配置-->
		<heartbeat>select user()</heartbeat>
		
		<writeHost host="127.0.0.1" url="192.168.199.11:3306" user="root" password="123456">
			<readHost host="127.0.0.1" url="192.168.199.12:3306" user="root" password="123456" />
		</writeHost>
	
	</dataHost>
	<dataHost name="dtHost2" maxCon="1000" minCon="10" balance="1"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<!--用于验证心跳，这个是mysql主库的配置-->
		<heartbeat>select user()</heartbeat>
		
		<writeHost host="127.0.0.1" url="192.168.199.13:3306" user="root" password="123456">
			<readHost host="127.0.0.1" url="192.168.199.13:3306" user="root" password="123456" />
		</writeHost>
	
	</dataHost>
</mycat:schema>

建议组合值balance=“1” writeType=“0” switchType="2"

server.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
	<system>
	<!--配置的端口号-->
    <property name="serverPort">8066</property>
	<property name="nonePasswordLogin">0</property> <!-- 0为需要密码登陆、1为不需要密码登陆 ,默认为0，设置为1则需要指定默认账户-->
	<property name="useHandshakeV10">1</property>
	<property name="useSqlStat">0</property>  <!-- 1为开启实时统计、0为关闭 -->
	<property name="useGlobleTableCheck">0</property>  <!-- 1为开启全加班一致性检测、0为关闭 -->

		<property name="sequnceHandlerType">2</property>
	<property name="subqueryRelationshipCheck">false</property> <!-- 子查询中存在关联查询的情况下,检查关联字段中是否有分片字段 .默认 false -->
      <!--  <property name="useCompression">1</property>--> <!--1为开启mysql压缩协议-->
        <!--  <property name="fakeMySQLVersion">5.6.20</property>--> <!--设置模拟的MySQL版本号-->
	<!-- <property name="processorBufferChunk">40960</property> -->
	<!-- 
	<property name="processors">1</property> 
	<property name="processorExecutor">32</property> 
	 -->
        <!--默认为type 0: DirectByteBufferPool | type 1 ByteBufferArena | type 2 NettyBufferPool -->
		<property name="processorBufferPoolType">0</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="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> -->
		<!--分布式事务开关，0为不过滤分布式事务，1为过滤分布式事务（如果分布式事务内只涉及全局表，则不过滤），2为不过滤分布式事务,但是记录分布式事务日志-->
		<property name="handleDistributedTransactions">0</property>
		
			<!--
			off heap for merge/order/group/limit      1开启   0关闭
		-->
		<property name="useOffHeapForMerge">1</property>

		<!--
			单位为m
		-->
        <property name="memoryPageSize">64k</property>

		<!--
			单位为k
		-->
		<property name="spillsFileBufferSize">1k</property>

		<property name="useStreamOutput">0</property>

		<!--
			单位为m
		-->
		<property name="systemReserveMemorySize">384m</property>


		<!--是否采用zookeeper协调切换  -->
		<property name="useZKSwitch">false</property>

		<!-- XA Recovery Log日志路径 -->
		<!--<property name="XARecoveryLogBaseDir">./</property>-->

		<!-- XA Recovery Log日志名称 -->
		<!--<property name="XARecoveryLogBaseName">tmlog</property>-->
		<!--如果为 true的话 严格遵守隔离级别,不会在仅仅只有select语句的时候在事务中切换连接-->
		<property name="strictTxIsolation">false</property>
		
		<property name="useZKSwitch">true</property>
		
	</system>
	
	<!-- 全局SQL防火墙设置 -->
	<!--白名单可以使用通配符%或着*-->
	<!--例如<host host="127.0.0.*" user="root"/>-->
	<!--例如<host host="127.0.*" user="root"/>-->
	<!--例如<host host="127.*" user="root"/>-->
	<!--例如<host host="1*7.*" user="root"/>-->
	<!--这些配置情况下对于127.0.0.1都能以root账户登录-->
	<!-- 此处是开放了本机和外网的请求链接，因为我的mycat安装在虚拟机上，所以本机是通过ip链接
	192.*是为了让navicat可以连接使用(配置完整的虚拟机IP也可以)
	127.*是为了让虚拟机本身可以通过命令连接-->
	<firewall>
	   <whitehost>
	      <host host="192.*" user="root"/>
		  <host host="127.*" user="root"/>
	   </whitehost>
       <blacklist check="false">
       </blacklist>
	</firewall>
	
	<!-- 此处定义了一个root用户，可以管理的逻辑库为mydatabase，对应schema.xml中的<schema name="mydatabase" > -->
	<user name="root" defaultAccount="true">
		<property name="password">123456</property>
		<property name="schemas">mydatabase</property>
		
		<!-- 表级 DML 权限设置 -->
		<!-- 		
		<privileges check="false">
			<schema name="TESTDB" dml="0110" >
				<table name="tb01" dml="0000"></table>
				<table name="tb02" dml="1111"></table>
			</schema>
		</privileges>		
		 -->
	</user>

	<!--<user name="user">
		<property name="password">123456</property>
		<property name="schemas">mycat1,test3</property>
		<property name="readOnly">true</property>
	</user>-->

</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://io.mycat/">
<!--schema.xml中配置的rule="student_id" 所对应的规则，规则对应主键，
列名为id需要与数据库的列名对应algorithm对应下方function-->
	<tableRule name="student_id">
        <rule>
            <columns>id</columns>
            <algorithm>student_text</algorithm>
        </rule>
    </tableRule>

	<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>
			<algorithm>hash-int</algorithm>
		</rule>
	</tableRule>
	<tableRule name="auto-sharding-long">
		<rule>
			<columns>id</columns>
			<algorithm>rang-long</algorithm>
		</rule>
	</tableRule>
	<tableRule name="mod-long">
		<rule>
			<columns>id</columns>
			<algorithm>mod-long</algorithm>
		</rule>
	</tableRule>
	<tableRule name="sharding-by-murmur">
		<rule>
			<columns>id</columns>
			<algorithm>murmur</algorithm>
		</rule>
	</tableRule>
	<tableRule name="crc32slot">
		<rule>
			<columns>id</columns>
			<algorithm>crc32slot</algorithm>
		</rule>
	</tableRule>
	<tableRule name="sharding-by-month">
		<rule>
			<columns>create_time</columns>
			<algorithm>partbymonth</algorithm>
		</rule>
	</tableRule>
	<tableRule name="latest-month-calldate">
		<rule>
			<columns>calldate</columns>
			<algorithm>latestMonth</algorithm>
		</rule>
	</tableRule>
	
	<tableRule name="auto-sharding-rang-mod">
		<rule>
			<columns>id</columns>
			<algorithm>rang-mod</algorithm>
		</rule>
	</tableRule>
	
	<tableRule name="jch">
		<rule>
			<columns>id</columns>
			<algorithm>jump-consistent-hash</algorithm>
		</rule>
	</tableRule>

<!--在conf中需要添加student_text.txt规则文件-->
 <function name="student_text"
        class="io.mycat.route.function.AutoPartitionByLong">
        <property name="mapFile">student_text.txt</property>
    </function>

	<function name="murmur"
		class="io.mycat.route.function.PartitionByMurmurHash">
		<property name="seed">0</property><!-- 默认是0 -->
		<property name="count">2</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="crc32slot"
			  class="io.mycat.route.function.PartitionByCRC32PreSlot">
	</function>
	<function name="hash-int"
		class="io.mycat.route.function.PartitionByFileMap">
		<property name="mapFile">partition-hash-int.txt</property>
	</function>
	<function name="rang-long"
		class="io.mycat.route.function.AutoPartitionByLong">
		<property name="mapFile">autopartition-long.txt</property>
	</function>
	<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
		<!-- how many data nodes -->
		<property name="count">3</property>
	</function>

	<function name="func1" class="io.mycat.route.function.PartitionByLong">
		<property name="partitionCount">8</property>
		<property name="partitionLength">128</property>
	</function>
	<function name="latestMonth"
		class="io.mycat.route.function.LatestMonthPartion">
		<property name="splitOneDay">24</property>
	</function>
	<function name="partbymonth"
		class="io.mycat.route.function.PartitionByMonth">
		<property name="dateFormat">yyyy-MM-dd</property>
		<property name="sBeginDate">2015-01-01</property>
	</function>
	
	<function name="rang-mod" class="io.mycat.route.function.PartitionByRangeMod">
        	<property name="mapFile">partition-range-mod.txt</property>
	</function>
	
	<function name="jump-consistent-hash" class="io.mycat.route.function.PartitionByJumpConsistentHash">
		<property name="totalBuckets">3</property>
	</function>
</mycat:rule>

例子解释

在上面的例子中使用到auto-sharding-long分片规则

<tableRule name="auto-sharding-long">
    <rule>
        <columns>id</columns>
        <algorithm>rang-long</algorithm>
    </rule>
</tableRule>

通过id 来进行分片的，分片的算法是rang-long下面在算法中使用到了autopartition-long.txt(mycat/conf下)

# range start-end ,data node index``# K=1000,M=10000.``0-500M=0``500M-1000M=1``1000M-1500M=2

这个的意思是K=1000条记录，M=10000条记录，那么下面三个配置就是0_{500万的记录会存在数据库db1的表中，500万}1000万会存在db2的表中，1000万~1500万会存在db3的表中。

注意

记得给你的防火墙开端口默认的mycat端口是8066
错误1：Host is blocked because of many connection errors; unblock with ‘mysqladmin flush-hosts’ 原因：估计是数据库的账号和密码错误，使IP被锁，首先需要去数据库执行flush hosts；命令清除被锁死的IP。
错误2：java.lang.IllegalArgumentException: Invalid DataSource:0 原因：MySQL配置有问题，首先去MySQL修改ROOT用户公网可访问update user set host = '%' where user = 'root';，并flush hosts重启；然后去schema.xml文件检查数据库名，密码等是否正确（匹配）。
错误3：在mycat.log中: Unknown charsetIndex:224 原因：字符集问题引起的数据库不能连接成功。vim index_to_charset.properties编辑配置文件中设置224的字符集，比如224=utf8mb4，之后重启。
关于id自增报错问题：在实现分库分表的情况下，数据库自增主键已无法保证自增主键的唯一性。所以，对于自增主键的情况，MyCAT中提供全局sequence来实现自增主键。在server.xml配置中配置<property name="sequnceHandlerType">1</property>；sequnceHandlerType参数0代表本地文件，1数据库表方式，2时间戳方式。

读写分离

配置MyCat读写分类前需要先配置MySQL的主从复制。

MySQL主从复制

MySQL内建的复制功能是构建大型，高性能应用程序的基础。将 MySQL的数亿分布到到多个系统上去，这种分布的机制，是通过将 MySQL 的某一台主机的数据复制到其它主机( Slave )上，并重新执行一遍来实现的。

复制过程中一个服务器充当服务器，而一个或多个其它服务器充当从服务器。主服务器将更新写入二进制日志，并维护文件的一个索引以跟踪日志循环。这些日志可以记录发送到从服务器的更新。当一个从服务器连接主服务器时，它通知主服务器从服务器在日志中读取的最后一次成功更新的位置，从服务器接收从那时起发生的任何更新，然后封锁等等主服务器通知新的更新。

注意，进行复制时，所有对复制中的表的更新必须在主服务器上进行。否则，会出现对主服务器上的表进行的更新与对服务器上的表所进行的更新之间的冲突。

主从复制实现原理

涉及到三个线程，一个运行在主节点(log dump thread)，其余两个(I/O thread, SQL thread)运行在从节点。

当从节点连接主节点时，主节点会创建一个log dump线程，用于发送bin-log的内容。在读取bin-log中的操作时，此线程会对主节点上的bin-log加锁。一旦该事件被线程读取完之后，该锁会被释放，即使在该事件完全发送到从库之前，该锁也会被释放。

当从节点上执行start slave;命令之后，从节点会创建一个I/O线程用来连接主节点，请求主库中更新的bin-log。I/O线程接收到主节点log dump进程发来的更新之后，保存在本地relay-log中。

SQL线程负责读取relay log中的内容，解析成具体的操作并执行，最终保证主从数据的一致性。

对于每一个主从连接，都需要三个进程来完成。当主节点有多个从节点时，主节点会为每一个当前连接的从节点建一个binary log dump 进程，而每个从节点都有自己的I/O进程和SQL进程。

常用主从策略

一主一从
一主多从：提高读性能
多主一从：将多个mysql数据库备份到一台存储性能比较好的服务器上
双主复制：互做主从复制，每个服务器既是master，又是另外一台服务器的slave。任何一方所做的变更，都会通过复制应用到另外一方的数据库中。
级联复制：部分slave的数据同步不连接主节点，而是连接从节点。不仅可以缓解主节点的压力，并且对数据一致性没有负面影响。

配置主服务器Master

修改my.conf文件，加入

server_id=252 #指定MySQL的id，通常是服务器IP的最后一段
log-bin=mysql-bin #开启二进制日志文件

重启

service mysqld restart

在MySQL中建立帐户并授权slave

grant replication slave on *.* to NAME@IP identified by 'PASSWORD';

NAME是授权的用户名，IP是授权的IP地址（%表示对从服务器IP不做限制），PASSWORD是密码。例如：

grant replication slave on *.* to test_user@% identified by '12345678';

查看master的状态

show master status\G;

±-----------------±---------±-------------±-----------------±------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
±-----------------±---------±-------------±-----------------±------------------+
| mysql-bin.000001 | 2579 | | | |
±-----------------±---------±-------------±-----------------±------------------+

配置从服务器slave

修改my.conf文件，加入

server_id=73
log-bin=mysql-bin
binlog_do_db=db_test#表示要同步的数据库
# binlog-ignore-db=test 表示不同步 test 数据库
# binlog_do_db=db_test#表示要同步的数据库

重启

service mysqld restart

在MySQL中连接主服务器

change master to master_host=IP, master_user=NAME, master_password=PASSWORD, master_log_file='mysql-bin.000001', master_log_pos=647;

IP指需要连接的主服务器IP，NAME和PASSWORD是获得授权的用户名和密码，master_log_file对应上文查看查看master的状态得到的File，master_log_pos对应上文查看查看master的状态得到的Position。

开始复制

start slave;

停止复制的命令是

stop slave;

查看从服务器的状态

show slave status\G;

必须看到这两个是YES，才算配置完成。

Slave_IO_Running: Yes

Slave_SQL_Running: Yes

配置schema.xml

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
 <!-- 数据库配置，与server.xml中的数据库对应 -->
	<schema name="db_test" checkSQLschema="false" sqlMaxLimit="100" dataNode="db_node" />
     <!-- 分片配置 -->
     <dataNode name="db_node" dataHost="db_host" database="db_test" />
     <!-- 物理数据库配置 -->
     <dataHost name="db_host" maxCon="1000" minCon="10" balance="3"
     writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
     	<heartbeat>select user()</heartbeat>
     	<!-- can have multi write hosts -->
     	<writeHost host="hostM1" url="mysql_master:3306" user="root" password="apple">
     	<!-- can have multi read hosts -->
     	  <readHost host="hostS2" url="mysql_slaver:3306" user="root" password="apple" />
     	</writeHost>
     </dataHost>
</mycat:schema>

配置说明：

sqlMaxLimit配置默认查询数量
database为真实数据库名

balance="3":所有读请求随机的分发到 wiriterHost 对应的 readhost 执行,writerHost 不负担读压力

writeType="0":所有写操作发送到配置的第一个writeHost，第一个挂了切到还生存的第二个writeHost，重新启动后已切换后的为准，切换记录在配置文件中:dnindex.properties .

switchType="1":默认值，故障自动切换，当前写操作的writeHost故障，进行切换，切换到下一个writeHost；心跳检测语句，一般为select user();

配置server.xml

<!-- 全局SQL防火墙设置 -->
<firewall>
     <whitehost>
         <host host="***.***.***.***" user="root"/>
         <host host="127.0.0.1" user="root"/>
     </whitehost>
    
     <blacklist check="false" />
</firewall>

配置***.***.***.***为可访问的外网IP

xiaoHui_1126

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyCat入门

MyCat入门mysql集群一个庞大的分布式系统的性能瓶颈中，最脆弱的是两个连接，一个是客户端与后端的连接，一个是后端与数据库的连接。说白了就是发送端请求太多，接收端能够的接收和处理的请求并不多。客户端与后端可以利用类似nginx的负载均衡解决，后端与数据库中可以利用类似mycat的负载均衡实现mysql集群，提高mysql的总体性能。什么是MyCATMyCAT是一个彻底开源的，面向企...
复制链接

扫一扫