读写分离之amoeba

Amoeba是什么
     Amoeba(变形虫)项目,该开源框架于2008年 开始发布一款 Amoeba for Mysql软件。这个软件致力于MySQL的分布式数据库前端代理层，它主要在应用层访问MySQL的 时候充当SQL路由功能，专注于分布式数据库代理层（Database Proxy）开发。座落与 Client、DB Server(s)之间,对客户端透明。具有负载均衡、高可用性、SQL 过滤、读写分离、可路由相关的到目标数据库、可并发请求多台数据库合并结果。 通过Amoeba你能够完成多数据源的高可用、负载均衡、数据切片的功能，目前Amoeba已在很多 企业的生产线上面使用。
 
为何要使用Amoeba?
     随着传统的数据库技术日趋成熟、计算机网络技术的飞速发展和应用范围的扩充，数据库应用 已经普遍建立于计算机网络之上。这时集中式数据库系统表现出它的不足：集中式处理，势必造成性 能瓶颈；应用程序集中在一台计算机上运行，一旦该计算机发生故障，则整个系统受到影响，可靠性 不高；集中式处理引起系统的规模和配置都不够灵活，系统的可扩充性差。在这种形势下，集中式数 据库将向分布式数据库发展。而Amoeba的透明、简易配置及多个优点使其成为分布式数据库代理产品中的优秀选择。
   

分布式数据库代理的相关概念

Amoeba在分布式数据库领域将致力解决数据切分，应付客户端“集中式”处理分布式数据。这 里集中式是一个相对概念，客户端不需要知道某种数据的物理存储地。避免这种逻辑出现在业务端， 大大简化了客户端操作分布式数据的复杂程度。

分布式数据库系统的优点：

  • 降低费用。分布式数据库在地理上可以式分布的。其系统的结构符合这种分布的要求。允许用 户在自己的本地录用、查询、维护等操作，实行局部控制，降低通信代价，避免集中式需要更高要求 的硬件设备。而且分布式数据库在单台机器上面数据量较少，其响应速度明显提升。

  • 提高系统整体可用性。避免了因为单台数据库的故障而造成全部瘫痪的后果。

  • 易于扩展处理能力和系统规模。分布式数据库系统的结构可以很容易地扩展系统，在分布式数 据库中增加一个新的节点，不影响现有系统的正常运行。这种方式比扩大集中式系统要灵活经济。在 集中式系统中扩大系统和系统升级，由于有硬件不兼容和软件改变困难等缺点，升级的代价常常是昂贵和不可行的。

  •  Amoeba相关产品及其介绍

    Amoeba for MySQL

    Amoeba for MySQL致力于MySQL的分布式数据库前端代理层，它主要在应用层访问MySQL的时候充当query 路由功能，专注 分布式数据库 proxy 开发。座落与Client、DB Server(s)之间。对客户端透明。具有负载均衡、高可用性、Query过滤、读写分离、可路由相关的query到目标数据库、可并发请求多台数据库合并结果。 在Amoeba上面你能够完成多数据源的高可用、负载均衡、数据切片的功能。目前在很多企业的生产线上面使用。

    那么Amoeba for mysql 对客户端程序来说是什么呢？ 我们就当它是mysql吧，它是一个虚拟的mysql，对外提供mysql协议。客户端连接amoeba就象连接mysql一样。在amoeba内部需要配置相关的认证属性。具体请参阅后面的章节。

  • Amoeba for Aladdin

    与Amoeba for MySQL 类似，客户端连接Aladdin必须用MySQL 协议，之所以用MySQL协议，主要是想借助mysql使用的广泛程度以及对各种开发语言的支持。Aladdin后端可以同时连接各种数据库。只要这些数据库提供jdbc驱动。aladdin的出现可以解决企业在数据库整合上面提供积极的帮助。使用者不需要知道后端到底使用了什么类型的数据库、数据库的物理地址什么，这些由aladdin来分析sql语句，并且获得相应的要查询的表跟条件，然后由这些规则结合这些条件进行路由到相关的物理数据库。

    Amoeba for MongoDB

    随着NoSQL的日益兴起，mongoDB作为一款nosql数据库以其优异的性能得到了广泛的关注。可以说，mongoDB填补了传统关系型数据库以及传统键值型数据库的空白，并且兼具两者优秀特质。Amoeba for MongoDB将提供与Amoeba for MySQL类似的，完全自主、可控的切分方式、并尝试完成同样的auto sharding的功能。 基于Amoeba框架，跟以往的产品一样具备心跳检测、负载均衡、故障转移、查询聚合等功能，保留了之前的配置方式，只要熟悉amoeba其中一款产品的配置，那么上手将非常容易的。 

  • 比较Amoeba及其类似产品

    Amoeba for Mysql 与MySQL Proxy比较

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

    Amoeba for mongoDB与mongos比较

    mongodb中的数据切分有一个chunk的概念，每个chunk代表一个数据段（range)，当一个chunk的大小到达了指定的数据大小，就会自动切分成两个。 Mongos是根据数据段（chunk）进行切分的，且切分依据的字段必须是一个key。而目前大多的应用中，id（尤其是用户ID）是无序化的，可能有些用户是手机号、有些是会员卡号等等。这使得proxy的range切分难以实施。 因此，虽然mongodb的mongos提供了automatic sharding的功能，但由于数据切分的不可控，常常不能满足我们的需要。 Amoeba for MongoDB提供完全自主、可控的切分方式。

  • Amoeba不能做什么？

    • 目前还不支持事务

    • 暂时不支持存储过程（近期会支持）

    • 不适合从amoeba导数据的场景或者对大数据量查询的query并不合适（比如一次请求返回10w以上甚至更多数据的场合）

    • 暂时不支持分库分表，amoeba目前只做到分数据库实例，每个被切分的节点需要保持库表结构一致            
    •     安装amoeba
    • 安装jdk
    •  java --version
    • 下载   http://sourceforge.net/projects/amoeba/files/
 

在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节点中，使他们组成一个数据库池。
 
 
 

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

 

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



 

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

 

Amoeba: Amoeba <192.168.14.129>

Master： Master <192.168.14.131> （可读写）

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

 

在 主从数据库 的复制的部分， 任然需要使用数据库自己的复制机制。 Amoeba 不提供复制功能。

 

1. 起动数据库的主从复制功能。

 

a. 修改配置文件

 

master.cnf

Cnf代码  收藏代码
  1. server-id = 1 #主数据库标志  
  2.   
  3. # 增加 日志文件， 用于验证读写分离  
  4. log = /home/mysql/mysql/log/mysql.log  

 

slave1.cnf

Cnf代码  收藏代码
  1. server-id = 2  
  2.   
  3. # 增加 日志文件， 用于验证读写分离  
  4. log = /home/mysql/mysql/log/mysql.log  

 

slave2.cnf

Cnf代码  收藏代码
  1. server-id = 3  
  2.   
  3. # 增加 日志文件， 用于验证读写分离  
  4. log = /home/mysql/mysql/log/mysql.log  

 

b. Master 中 创建两个 只读权限 的用户。 用户名均为：repl_user   密码均为：copy  分别开放给 slave1， slave2

 

Sql代码  收藏代码
  1. mysql> grant replication slave on *.* to repl_user@192.168.14.132 identified by 'copy';  
  2.   
  3. mysql> grant replication slave on *.* to repl_user@192.168.14.133 identified by 'copy';  

 

c. 查看 Master 信息

Sql代码  收藏代码
  1. mysql> show master status;  
  2. +------------------+----------+--------------+------------------+  
  3. | File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |  
  4. +------------------+----------+--------------+------------------+  
  5. | mysql-bin.000017 |     2009 |              |                  |  
  6. +------------------+----------+--------------+------------------+  
  7. 1 row in set (0.00 sec)  
 

 

d. Slave1 ，Slave2 中 启动 Master - Slave 复制功能。

 

分别执行以下命令

 

Sql代码  收藏代码
  1. mysql> slave stop;  
  2. Query OK, 0 rows affected (0.02 sec)  
  3.   
  4. mysql> change master to  
  5.     -> master_host='192.168.14.131',  
  6.     -> master_user='repl_user',  
  7.     -> master_password='copy',  
  8.     -> master_log_file='mysql-bin.000017',  
  9.     -> master_log_pos=2009;  
  10. Query OK, 0 rows affected (0.03 sec)  
  11.   
  12. mysql> start slave;  
  13. Query OK, 0 rows affected (0.00 sec)  

 

2. Amoeba 读写分离的配置

 

a. Master ， Slave1 ，Slave2 中开放权限给 Amoeba 访问。

 

在 Master ， Slave1 ， Slave2 中分别执行

 

Sql代码  收藏代码
  1. mysql> grant all on test.* to test_user@192.168.14.129 indentified by '1234';  

Amoeba 访问三个数据库的账号密码相同。

 

b. 修改 Amoeba 的配置文件

 

配置文件详细说明请查看 官方文档：http://docs.hexnova.com/amoeba/rw-splitting.html

 

dbServer.xml

Xml代码  收藏代码
  1. <?xml version="1.0" encoding="gbk"?>  
  2.   
  3. <!DOCTYPE amoeba:dbServers SYSTEM "dbserver.dtd">  
  4. <amoeba:dbServers xmlns:amoeba="http://amoeba.meidusa.com/">  
  5.   
  6.         <!--   
  7.             Each dbServer needs to be configured into a Pool,  
  8.             If you need to configure multiple dbServer with load balancing that can be simplified by the following configuration:  
  9.              add attribute with name virtual = "true" in dbServer, but the configuration does not allow the element with name factoryConfig  
  10.              such as 'multiPool' dbServer     
  11.         -->  
  12.   
  13.     <!-- 数据库连接配置的公共部分 -->   
  14.     <dbServer name="abstractServer" abstractive="true">  
  15.         <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">  
  16.             <property name="manager">${defaultManager}</property>  
  17.             <property name="sendBufferSize">64</property>  
  18.             <property name="receiveBufferSize">128</property>  
  19.                   
  20.             <!-- mysql port -->  
  21.             <property name="port">3306</property>  
  22.               
  23.             <!-- mysql schema -->  
  24.             <property name="schema">test</property>  
  25.               
  26.             <!-- mysql user -->  
  27.             <property name="user">test_user</property>  
  28.               
  29.             <!--  mysql password -->  
  30.             <property name="password">1234</property>  
  31.               
  32.         </factoryConfig>  
  33.   
  34.         <poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool">  
  35.             <property name="maxActive">500</property>  
  36.             <property name="maxIdle">500</property>  
  37.             <property name="minIdle">10</property>  
  38.             <property name="minEvictableIdleTimeMillis">600000</property>  
  39.             <property name="timeBetweenEvictionRunsMillis">600000</property>  
  40.             <property name="testOnBorrow">true</property>  
  41.             <property name="testWhileIdle">true</property>  
  42.         </poolConfig>  
  43.     </dbServer>  
  44.   
  45.     <!-- Master ，Slave1， Slave2 的独立部分，也就只有 IP 了 -->  
  46.     <dbServer name="master"  parent="abstractServer">  
  47.         <factoryConfig>  
  48.             <!-- mysql ip -->  
  49.             <property name="ipAddress">192.168.14.131</property>  
  50.         </factoryConfig>  
  51.     </dbServer>  
  52.   
  53.     <dbServer name="slave1"  parent="abstractServer">  
  54.         <factoryConfig>  
  55.             <!-- mysql ip -->  
  56.             <property name="ipAddress">192.168.14.132</property>  
  57.         </factoryConfig>  
  58.     </dbServer>  
  59.   
  60.     <dbServer name="slave2"  parent="abstractServer">  
  61.         <factoryConfig>  
  62.             <!-- mysql ip -->  
  63.             <property name="ipAddress">192.168.14.133</property>  
  64.         </factoryConfig>  
  65.     </dbServer>     
  66.       
  67.     <!-- 数据库池，虚拟服务器，实现读取的负载均衡 -->  
  68.     <dbServer name="slaves" virtual="true">  
  69.         <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">  
  70.             <!-- Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->  
  71.             <property name="loadbalance">1</property>  
  72.               
  73.             <!-- Separated by commas,such as: server1,server2,server1 -->  
  74.             <property name="poolNames">slave1,slave2</property>  
  75.         </poolConfig>  
  76.     </dbServer>  
  77.           
  78. </amoeba:dbServers>  

 

amoeba.xml

Xml代码  收藏代码
  1. <?xml version="1.0" encoding="gbk"?>  
  2.   
  3. <!DOCTYPE amoeba:configuration SYSTEM "amoeba.dtd">  
  4. <amoeba:configuration xmlns:amoeba="http://amoeba.meidusa.com/">  
  5.   
  6.     <proxy>  
  7.       
  8.         <!-- service class must implements com.meidusa.amoeba.service.Service -->  
  9.         <service name="Amoeba for Mysql" class="com.meidusa.amoeba.net.ServerableConnectionManager">  
  10.             <!-- Amoeba 端口号 -->  
  11.             <property name="port">8066</property>  
  12.               
  13.             <!-- bind ipAddress -->  
  14.             <!--  
  15.             <property name="ipAddress">127.0.0.1</property> 
  16.              -->  
  17.               
  18.             <property name="manager">${clientConnectioneManager}</property>  
  19.               
  20.             <property name="connectionFactory">  
  21.                 <bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory">  
  22.                     <property name="sendBufferSize">128</property>  
  23.                     <property name="receiveBufferSize">64</property>  
  24.                 </bean>  
  25.             </property>  
  26.               
  27.             <property name="authenticator">  
  28.                 <bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">  
  29.                     <!-- Amoeba 账号，密码 -->  
  30.                     <property name="user">root</property>  
  31.                       
  32.                     <property name="password">root</property>  
  33.                       
  34.                     <property name="filter">  
  35.                         <bean class="com.meidusa.amoeba.server.IPAccessController">  
  36.                             <property name="ipFile">${amoeba.home}/conf/access_list.conf</property>  
  37.                         </bean>  
  38.                     </property>  
  39.                 </bean>  
  40.             </property>  
  41.               
  42.         </service>  
  43.           
  44.         <!-- server class must implements com.meidusa.amoeba.service.Service -->  
  45.         <service name="Amoeba Monitor Server" class="com.meidusa.amoeba.monitor.MonitorServer">  
  46.             <!-- port -->  
  47.             <!--  default value: random number  
  48.             <property name="port">9066</property>  
  49.             -->  
  50.             <!-- bind ipAddress -->  
  51.             <property name="ipAddress">127.0.0.1</property>  
  52.             <property name="daemon">true</property>  
  53.             <property name="manager">${clientConnectioneManager}</property>  
  54.             <property name="connectionFactory">  
  55.                 <bean class="com.meidusa.amoeba.monitor.net.MonitorClientConnectionFactory"></bean>  
  56.             </property>  
  57.               
  58.         </service>  
  59.           
  60.         <runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext">  
  61.             <!-- proxy server net IO Read thread size -->  
  62.             <property name="readThreadPoolSize">20</property>  
  63.               
  64.             <!-- proxy server client process thread size -->  
  65.             <property name="clientSideThreadPoolSize">30</property>  
  66.               
  67.             <!-- mysql server data packet process thread size -->  
  68.             <property name="serverSideThreadPoolSize">30</property>  
  69.               
  70.             <!-- per connection cache prepared statement size  -->  
  71.             <property name="statementCacheSize">500</property>  
  72.               
  73.             <!-- query timeout( default: 60 second , TimeUnit:second) -->  
  74.             <property name="queryTimeout">60</property>  
  75.         </runtime>  
  76.           
  77.     </proxy>  
  78.       
  79.     <!--   
  80.         Each ConnectionManager will start as thread  
  81.         manager responsible for the Connection IO read , Death Detection  
  82.     -->  
  83.     <connectionManagerList>  
  84.         <connectionManager name="clientConnectioneManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper">  
  85.             <property name="subManagerClassName">com.meidusa.amoeba.net.ConnectionManager</property>  
  86.             <!--   
  87.               default value is avaliable Processors   
  88.             <property name="processors">5</property>  
  89.              -->  
  90.         </connectionManager>  
  91.         <connectionManager name="defaultManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper">  
  92.             <property name="subManagerClassName">com.meidusa.amoeba.net.AuthingableConnectionManager</property>  
  93.               
  94.             <!--   
  95.               default value is avaliable Processors   
  96.             <property name="processors">5</property>  
  97.              -->  
  98.         </connectionManager>  
  99.     </connectionManagerList>  
  100.       
  101.         <!-- default using file loader -->  
  102.     <dbServerLoader class="com.meidusa.amoeba.context.DBServerConfigFileLoader">  
  103.         <property name="configFile">${amoeba.home}/conf/dbServers.xml</property>  
  104.     </dbServerLoader>  
  105.       
  106.     <queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">  
  107.           
  108.         <property name="ruleLoader">  
  109.             <bean class="com.meidusa.amoeba.route.TableRuleFileLoader">  
  110.                 <property name="ruleFile">${amoeba.home}/conf/rule.xml</property>  
  111.                 <property name="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property>  
  112.             </bean>  
  113.         </property>  
  114.         <property name="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property>  
  115.           
  116.         <property name="LRUMapSize">1500</property>  
  117.         <!-- 默认数据库，主数据库 -->  
  118.         <property name="defaultPool">master</property>  
  119.           
  120.         <!-- 写数据库 -->  
  121.         <property name="writePool">master</property>  
  122.         <!-- 读数据库，dbServer.xml 中配置的 虚拟数据库，数据库池 -->  
  123.         <property name="readPool">slaves</property>  
  124.           
  125.         <property name="needParse">true</property>  
  126.     </queryRouter>  
  127. </amoeba:configuration>  

 

rule.xml

Java代码  收藏代码
  1. <?xml version="1.0" encoding="gbk"?>  
  2. <!DOCTYPE amoeba:rule SYSTEM "rule.dtd">  
  3.   
  4. <amoeba:rule xmlns:amoeba="http://amoeba.meidusa.com/">  
  5.     <tableRule name="message" schema="test" defaultPools="server1">  
  6.     </tableRule>  
  7. </amoeba:rule>  

 

不需要 数据库分片时，不用配置。 但是不能没有 tableRule 元素， 否则报错。 随便写个空规则就行了。

 

3. 测试读写分离

 

a. 在 Master ， Slave1 ， Slave2  中分别查看 日志文件： mysql.log

Shell代码  收藏代码
  1. tail -f ./log/mysql.log  

 

 

 
b. 启动 Amoeba， 使用 Mysql GUI Tools 连接 Amoeba
posted @ 2017-05-16 15:09  靠岸啊啊  阅读(281)  评论(0)  编辑  收藏  举报