mysql负载均衡+读写分离 - huzz

　　上一篇记录了mysql作主从复制，一个master带n个slave以后，当然需要利用这些从库实现读写分离和负载均衡，要不然还要这些个从干什么用啊？看了好些个读写分离的方案后，决定尝试采用阿里的amoeba-mysql来实现，因为它只需要做简单的配置即可达到我想要实现的效果。

　　最新版本的amoeba在codeproject可以找到，我把链接也一起提供上来，写文的时候最新版本是3.0.5，地址：https://sourceforge.net/projects/amoeba/files/Amoeba%20for%20mysql/，下载的进候直接下最新版本的就好了，这是个java程序，运行前要先把jdk配置妥当，我实验的时候用的是jdk1.8，文档要求是jdk1.6以上，各位看官自己选择jdk版本吧。

　　接下来，amoeba也有比较详尽的配置说明，链接也一并提供：http://docs.hexnova.com/amoeba/。根据我的用途，主要看“在Master/Slave结构下的读写分离”这个章节，参照配置文件进行配置就可以用了，我的环境如下：192.168.68.61为mysql-master，192.168.68.62为mysql-slave，之前已经配置好主从复制，而且主从复制工作正常，而192.168.68.60就是留给amoeba的代理访问端口，配置成功后，应用只看到192.168.68.60这个数据库服务器。

　　mysql-server:192.168.68.61

　　mysql-slave:192.168.68.62

　　amoeba:192.168.68.60

主要配置两个文件：dbServers.xml（数据库集群）、amoeba.xml（amoeba的主配置文件）

　　下面贴我现在配置成功的实际配置文件:

　　dbServers.xml:

<?xml version="1.0" encoding="gbk"?>

<!DOCTYPE amoeba:dbServers SYSTEM "dbserver.dtd">
<amoeba:dbServers xmlns:amoeba="http://amoeba.meidusa.com/">

<dbServer name="abstractServer" abstractive="true">
<factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
<property name="connectionManager">${defaultManager}</property>
<property name="sendBufferSize">64</property>
<property name="receiveBufferSize">128</property>


<property name="port">3306</property>


<property name="schema">dbtu</property>


<property name="user">tu</property>

<property name="password">tu</property>
</factoryConfig>

<dbServer name="vslave" virtual="true">
<poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
<property name="loadbalance">1</property>
<property name="poolNames">slave1</property>
</poolConfig>
</dbServer>








</amoeba:dbServers>

amoeba.xml:

<?xml version="1.0" encoding="gbk"?>

<!DOCTYPE amoeba:configuration SYSTEM "amoeba.dtd">
<amoeba:configuration xmlns:amoeba="http://amoeba.meidusa.com/">

<proxy>


<service name="Amoeba for Mysql" class="com.meidusa.amoeba.mysql.server.MySQLService">

<property name="port">8066</property>




<property name="connectionFactory">
<bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory">
<property name="sendBufferSize">128</property>
<property name="receiveBufferSize">64</property>
</bean>
</property>

<property name="authenticateProvider">
<bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">

<property name="user">tu</property>

<property name="password">tu</property>


</bean>
</property>

</service>

<runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext">


<property name="executeThreadSize">128</property>


<property name="statementCacheSize">500</property>


<property name="serverCharset">utf8</property>


<property name="queryTimeout">60</property>
</runtime>

</proxy>


<connectionManagerList>
<connectionManager name="defaultManager" class="com.meidusa.toolkit.net.MultiConnectionManagerWrapper">
<property name="subManagerClassName">com.meidusa.toolkit.net.AuthingableConnectionManager</property>
</connectionManager>
</connectionManagerList>


<dbServerLoader class="com.meidusa.amoeba.context.DBServerConfigFileLoader">
<property name="configFile">${amoeba.home}/conf/dbServers.xml</property>
</dbServerLoader>

<queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">
<property name="ruleLoader">
<bean class="com.meidusa.amoeba.route.TableRuleFileLoader">

<property name="ruleFile">${amoeba.home}/conf/rule.xml</property>

<property name="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property>
</bean>
</property>
<property name="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property>
<property name="LRUMapSize">1500</property>
<property name="defaultPool">vslave</property>

<property name="writePool">master</property>
<property name="readPool">vslave</property>

<property name="needParse">true</property>
</queryRouter>
</amoeba:configuration>

这两个配置文件配置完毕后，剩下的就是启动程序了，我这个版本的启动方式跟教程的不太一样，就是执行bin/launcher 这个脚本，如果没有显示"abort"，那就是正常了，附使用教程链接：http://docs.hexnova.com/amoeba/，附“在Master/Slave结构下的读写分离”配置章节：

首先说明一下amoeba 跟 MySQL proxy在读写分离的使用上面的区别：

在MySQL proxy 6.0版本上面如果想要读写分离并且读集群、写集群机器比较多情况下，用mysql proxy 需要相当大的工作量，目前mysql proxy没有现成的 lua脚本。mysql proxy根本没有配置文件， lua脚本就是它的全部，当然lua是相当方便的。那么同样这种东西需要编写大量的脚本才能完成一个复杂的配置。而Amoeba只需要进行相关的配置就可以满足需求。

假设有这样的使用场景，有三个数据库节点分别命名为Master、Slave1、Slave2如下：

Master： Master （可读写）

Slaves：Slave1、Slave2 （2个平等的数据库。只读/负载均衡）

针对这样的使用方式，首先在dbServers.xml中将Slave1和Slave2配置在一个虚拟的dbServer节点中，使他们组成一个数据库池。

Example 4.3. 数据库池在dbServers.xml的定义与配置

<?xml version="1.0" encoding="gbk"?>

<!DOCTYPE amoeba:dbServers SYSTEM "dbserver.dtd">
<amoeba:dbServers xmlns:amoeba="http://amoeba.meidusa.com/">
...
 <dbServer name="Master"  parent="abstractServer">

  <factoryConfig>
   <!-- mysql ip -->
   <property name="ipAddress">192.168.0.1</property>
  </factoryConfig>
 </dbServer>
 
 <dbServer name="Slave1"  parent="abstractServer">

  <factoryConfig>
   <!-- mysql ip -->
   <property name="ipAddress">192.168.0.2</property>
  </factoryConfig>
 </dbServer>

 <dbServer name="Slave2"  parent="abstractServer">

  <factoryConfig>
   <!-- mysql ip -->
   <property name="ipAddress">192.168.0.3</property>
  </factoryConfig>
 </dbServer>
  
 <dbServer name="virtualSlave" virtual="true">

  <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
   <!-- Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
   <property name="loadbalance">1</property>

   
   <!-- Separated by commas,such as: server1,server2,server1 -->
   <property name="poolNames">Slave1,Slave2</property>

  </poolConfig>
 </dbServer>
...
</amoeba:dbServers>

	定义了Master节点，parent为abstractServer，关于abstractServer的定义方式参照第三章。
	定义了Slave1和Slave2节点。
	定义了virtualSlave的虚拟节点，这是由Slave1和Slave2组成的一个数据库池。
	loadbalance元素设置了loadbalance策略的选项，这里选择第一个“ROUNDROBIN”轮询策略，该配置提供负载均衡、failOver、故障恢复功能。
	poolNames定义了其中的数据库节点配置（当然也可以是虚拟的节点）。此外对于轮询策略，poolNames还定义了其轮询规则，比如设置成“Slave1,Slave1,Slave2”那么Amoeba将会以两次Slave1，一次Slave2的顺序循环对这些数据库节点转发请求。

如果不需要配置规则那么可以不使用rule.xml而直接配置amoeba.xml中的queryRouter，配置如下：

Example 4.4. 配置amoeba.xml不使用切分功能直接配置queryRouter以读写分离

<?xml version="1.0" encoding="gbk"?>

<!DOCTYPE amoeba:configuration SYSTEM "amoeba.dtd">
<amoeba:configuration xmlns:amoeba="http://amoeba.meidusa.com/">
...
<queryRouter class=”com.meidusa.amoeba.mysql.parser.MysqlQueryRouter”>  
   <property name="LRUMapSize">1500</property>

   <property name="defaultPool">Master</property>

  
   <property name="writePool">Master</property>

   <property name="readPool">virtualSlave</property>

   <property name="needParse">true</property>  
</queryRouter>  
...
</amoeba:configuration>

	LRUMapSize属性定义了Amoeba缓存的SQL语句解析的条数。
	defaultPool配置了默认的数据库节点，一些除了SELECT\UPDATE\INSERT\DELETE的语句都会在defaultPool执行。
	writePool配置了数据库写库，通常配为Master，如这里就配置为之前定义的Master数据库。
	readPool配置了数据库读库，通常配为Slave或者Slave组成的数据库池，如这里就配置之前的virtualSlave数据库池。

当同时需要配置切分规则以及读写分离时，这里以本章节的“基于Amoeba的数据水平切分”小节的场景与本小节的场景合并可以使用这样的配置方法：

Example 4.5. 通过使用isReadStatement在rule.xml配置中指定读库和写库

<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE amoeba:rule SYSTEM "rule.dtd">

<amoeba:rule xmlns:amoeba="http://amoeba.meidusa.com/">
...
   <tableRule name="MESSAGE" schema="test" defaultPools="blogdb-1-write,blogdb-2-write">
      <rule name="rule1" ruleResult="POOLNAME">

         <parameters>ID</parameters>
         <expression><![CDATA[
           var hashid = abs(hash(id)) mod 2;
           case hashid when 0 then (isReadStatement?'blogdb-1-read':'blogdb-1-write');

                       when 1 then (isReadStatement?'blogdb-2-read':'blogdb-2-write');
         ]]></expression>
         <defaultPools>blogdb-1</defaultPools>
      </rule>
   </tableRule>
...
</amoeba:rule>

	这里的规则配置设置ruleResult为“POOLNAME”这意味着操作的数据库节点名称是由expression的返回结果得到的。
	这里使用了isReadStatement来确定操作语句是读语句还是写语句，在这个例子中，读语句会路由到blogdb-1-read数据库节点，而写语句会路由到blogdb-1-write数据库节点。这里blogdb-1-read等几个数据库节点都必须在dbServers.xml中配置。

posted on 2016-10-04 02:43 huzz 阅读(563) 评论(0) 收藏举报

刷新页面返回顶部


博客园 © 2004-2026 浙公网安备 33010602011771号浙ICP备2021040463号-3

导航