amoeba for mysql实现 mysql负载均衡，读写分离；

http://onlyoulinux.blog.51cto.com/7941460/1570472

以上blog己经实现了mysql的主从，本文在主从的基础上用amoeba-mysql实现负载均衡，读写分离 .

amoeba：采用java NTO框架无阻塞模式；

amoeba for mysql是amoeba项目的子项目；

1、amoeba要有java环境支持：安装jdk

[email protected] src]# rpm -ivh jdk-7u67-linux-i586.rpm 
Preparing...                ########################################### [100%]
   1:jdk                    ########################################### [100%]
Unpacking JAR files...
 rt.jar...
 jsse.jar...
 charsets.jar...
 tools.jar...
 localedata.jar...
 jfxrt.jar...
 plugin.jar...
 javaws.jar...
 deploy.jar...
[[email protected] src]# cat /etc/profile.d/jdk.sh 
export JAVA_HOME=/usr/java/jdk1.7.0_67
export PATH=$PATH:$JAVA_HOME/bin:$JAVA_HOME/jre

[[email protected] src]# source /etc/profile

2、下载amoeba包：

[[email protected] src]#wget http://jaist.dl.sourceforge.net/project/amoeba/Amoeba%20for%20mysql/amoeba-mysql-1.3.1-BETA.zip
[[email protected] amoeba]# unzip amoeba-mysql-1.3.1-BETA.zip 
[[email protected] amoeba]# ls
amoeba-mysql-1.3.1-BETA.zip  bin  build.properties  build.xml  conf  doc  lib  
LICENSE.txt  logs  README.html  src

3、以下是我的配置文件（标红的是 需要注意或改动的地方）

[[email protected] amoeba]# cat conf/amoeba.xml  |grep -v "^$"
<?xml version="1.0" encoding="gbk"?>

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

<server>
  <!-- proxy server绑定的端口 -->
  <property name="port">8066</property>
  <!-- proxy server绑定的IP -->
  <property name="ipAddress">192.168.0.120</property>
  <!-- proxy server net IO Read thread size -->
  <property name="readThreadPoolSize">20</property>
  <!-- proxy server client process thread size -->
  <property name="clientSideThreadPoolSize">30</property>
  <!-- mysql server data packet process thread size -->
  <property name="serverSideThreadPoolSize">30</property>
  <!-- socket Send and receive BufferSize(unit:K)  -->
  <property name="netBufferSize">128</property>
  <!-- Enable/disable TCP_NODELAY (disable/enable Nagle‘s algorithm). -->
  <property name="tcpNoDelay">true</property>
  <!-- 对外验证的用户名 -->
  <property name="user">root</property>
  <!-- 对外验证的密码 -->
  <property name="password">password</property>
  <!-- query timeout( default: 60 second , TimeUnit:second) -->
  <property name="queryTimeout">60</property>
 </server>
 <!--
  每个ConnectionManager都将作为一个线程启动。
  manager负责Connection IO读写/死亡检测
 -->
 <connectionManagerList>
  <connectionManager name="defaultManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper">
   <property name="subManagerClassName">com.meidusa.amoeba.net.AuthingableConnectionManager</property>
   
   <!--
     default value is avaliable Processors
   <property name="processors">5</property>
    -->
  </connectionManager>
 </connectionManagerList>
 
 <dbServerList>
  <!--
   一台mysqlServer 需要配置一个pool，
   如果多台 平等的mysql需要进行loadBalance，
   平台已经提供一个具有负载均衡能力的objectPool：com.meidusa.amoeba.mysql.server.MultipleServerPool
   简单的配置是属性加上 virtual="true",该Pool 不允许配置factoryConfig
   或者自己写一个ObjectPool。
  -->
  <dbServer name="server1">
   <!-- PoolableObjectFactory实现类 -->
   <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
    <property name="manager">defaultManager</property>
    <!-- 真实mysql数据库端口 -->
    <property name="port">3306</property>
    <!-- 真实mysql数据库IP -->
    <property name="ipAddress">192.168.0.117</property>
    <property name="schema">test</property>
    <!-- 用于登陆mysql的用户名和密码 -->
    <property name="user">proxy</property>
    <!-- 用于登陆mysql的密码 -->
    <property name="password">proxy</property>
   </factoryConfig>
   <!-- ObjectPool实现类 -->
   <poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
    <property name="maxActive">200</property>
    <property name="maxIdle">200</property>
    <property name="minIdle">10</property>
    <property name="minEvictableIdleTimeMillis">600000</property>
    <property name="timeBetweenEvictionRunsMillis">600000</property>
    <property name="testOnBorrow">true</property>
    <property name="testWhileIdle">true</property>
   </poolConfig>
  </dbServer>
  
  <dbServer name="server2">
   
   <!-- PoolableObjectFactory实现类 -->
   <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
    <property name="manager">defaultManager</property> 
    <!-- 真实mysql数据库端口 -->
    <property name="port">3306</property>
    <!-- 真实mysql数据库IP -->
    <property name="ipAddress">192.168.0.118</property>
    <property name="schema">test</property>
    <!-- 用于登陆mysql的用户名 -->
    <property name="user">proxy</property>
    <!-- 用于登陆mysql的密码 -->
    <property name="password">proxy</property>
   </factoryConfig>
   
   <!-- ObjectPool实现类 -->
   <poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
    <property name="maxActive">200</property>
    <property name="maxIdle">200</property>
    <property name="minIdle">10</property>
    <property name="minEvictableIdleTimeMillis">600000</property>
    <property name="timeBetweenEvictionRunsMillis">600000</property>
    <property name="testOnBorrow">true</property>
    <property name="testWhileIdle">true</property>
   </poolConfig>
  </dbServer>
  
  <dbServer name="master" virtual="true">
   <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
    <!-- 负载均衡参数 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
    <property name="loadbalance">1</property>
    <!-- 参与该pool负载均衡的poolName列表以逗号分割 -->
    <property name="poolNames">server1</property>
   </poolConfig>
  </dbServer>

<dbServer name="slave" virtual="true">
   <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
    <!-- 负载均衡参数 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
    <property name="loadbalance">1</property>    
    <!-- 参与该pool负载均衡的poolName列表以逗号分割 -->
    <property name="poolNames">server1,server2</property>
   </poolConfig>
  </dbServer>
  
 </dbServerList>

<queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">
  <property name="ruleConfig">${amoeba.home}/conf/rule.xml</property>
  <property name="functionConfig">${amoeba.home}/conf/functionMap.xml</property>
  <property name="ruleFunctionConfig">${amoeba.home}/conf/ruleFunctionMap.xml</property>
  <property name="LRUMapSize">1500</property>
  <property name="defaultPool">master</property>  
  <property name="writePool">master</property>
  <property name="readPool">slave</property>
  <property name="needParse">true</property>
 </queryRouter>
</amoeba:configuration>

4、在主库上对amoeba代理进行授权（只授权主库就可以，从库会自动 同步的）

mysql>GRANT ALL PRIVILEGES ON *.* TO ‘proxy‘@‘192.168.0.120‘ IDENTIFIED BY PASSWORD ‘proxy‘ WITH GRANT OPTION1;

row in set (0.00 sec)

mysql>flush privileges;

5、启动amoeba

[[email protected] amoeba]# /usr/local/amoeba/bin/amoeba &   先要给amoeba加可执行权限

[[email protected] amoeba]# ps -ef |grep amoeba
root      7686  1604  0 06:26 pts/1    00:00:22 /usr/java/jdk1.7.0_67/bin/java -server -Xms256m -Xmx256m -Xss128k -Damoeba.home=/usr/local/amoeba -Dclassworlds.conf=/usr/local/amoeba/bin/amoeba.classworlds -classpath /usr/local/amoeba/lib/classworlds-1.0.jar org.codehaus.classworlds.Launcher
root      7977  7949  0 07:25 tty1     00:00:00 vim /usr/local/amoeba/conf/amoeba.xml
root      8004  1456  0 07:38 pts/0    00:00:00 grep amoeba
[[email protected] amoeba]# netstat -tunlp |grep java
tcp        0      0 ::ffff:192.168.0.120:8066   :::*                        LISTEN      7686/java

6、测试

测试方法：单独建一个test库，在库中建一个表jaychou，表中加一行数据，然后 mysql>slave stop;让数据不再同步，然后在主库中再加入一行数据；在amoeba上反复查询看不同；这是实现了读的测试，写的测试只要在amoeba上插入一行数据就可以了；

# mysql -uroot -ppassword -h192.168.0.120 -P8066 注意分清哪个用户名哪个密码；

mysql> select * from jaychou;
+------+
| id   |
+------+
|    1 |
|    2 |
+------+
2 rows in set (0.00 sec)

mysql> select * from jaychou;
+------+
| id   |
+------+
|    1 |
+------+
1 row in set (0.01 sec)

mysql> select * from jaychou;
+------+
| id   |
+------+
|    1 |
|    2 |
+------+
2 rows in set (0.01 sec)

mysql> select * from jaychou;
+------+
| id   |
+------+
|    1 |
+------+
1 row in set (0.00 sec)

mysql> insert into jaychou value(3);
Query OK, 1 row affected (0.01 sec)

mysql> select * from jaychou;
+------+
| id   |
+------+
|    1 |
+------+
1 row in set (0.00 sec)

mysql> select * from jaychou;
+------+
| id   |
+------+
|    1 |
|    2 |
|    3 |
+------+
3 rows in set (0.01 sec)

mysql>

貌似达到这个效果就可以了，

amoeba还可以做负载均衡，不过对于主从两个节点的mysql cluster来说，使用roundrobin机制就可以了 ；对于多节点的mysql集群来说可以用轮循、权重、甚至可以做HA， 各人感觉amoeba for mysql比 mysql-proxy简单好用 多了，

；

时间： 2024-07-31 01:14:24

amoeba for mysql实现 mysql负载均衡，读写分离；的相关文章

数据库双重负载均衡读写分离及双活集群

双重负载均衡读写分离及双活集群 ---数据库性能和容灾一体化解决方案 说明: 1. 第一重负载均衡读写分离:节点DB-A和DB-B之间负载均衡和读写分离,数据同步方式为同步模式. 2. 第二重负载均衡读写分离:节点DB-C执行报表.OLAP查询等,数据同步方式为异步模式. 3. 双活集群:两节点DB-A和DB-B构成双活集群(故障时数据零丢失.服务不停止). 4. 兼容性:客户端代码零修改,和原本单机数据库访问保持二进制兼容.

变形虫mysql的负载均衡 读写分离

变形虫概述 图片来自   http://docs.hexnova.com/amoeba/amoeba-products.html  文档上说也可以做mongdb的分布式. 应用: 具有负载均衡.高可用性.Query过滤.读写分离.可路由相关的query到目标数据库.可并发请求多台数据库合并结果. 在Amoeba上面你能够完成多数据源的高可用.负载均衡.数据切片的功能.目前在很多企业的生产线上面使用. 缺点: 目前还不支持事务 暂时不支持存储过程(近期会支持) 不适合从amoeba导数据的场景或者

搭建MySQL高可用负载均衡集群

1.简介 使用MySQL时随着时间的增长,用户量以及数据量的逐渐增加,访问量更是剧增,最终将会使MySQL达到某个瓶颈,那么MySQL的性能将会大大降低.这一结果也不利于软件的推广. 那么如何跨过这个瓶颈,提高MySQL的并发量呢?方法有很多,分布式数据库.读写分离.高可用负载均衡.增加缓存服务器等等.之前的文章里已经介绍了读写分离的方案了,接下来我将讲解MySQL高可用负载均衡这一方法. 其中实现高可用负载均衡的方法有很多,例如LVS+keepalived组合实现.haproxy+keepal

MySQL高可用负载均衡

1.简介 使用MySQL时随着时间的增长,用户量以及数据量的逐渐增加,访问量更是剧增,最终将会使MySQL达到某个瓶颈,那么MySQL的性能将会大大降低.这一结果也不利于软件的推广. 那么如何跨过这个瓶颈,提高MySQL的并发量呢?方法有很多,分布式数据库.读写分离.高可用负载均衡.增加缓存服务器等等.之前的文章里已经介绍了读写分离的方案了,接下来我将讲解MySQL高可用负载均衡这一方法. 其中实现高可用负载均衡的方法有很多,例如LVS+keepalived组合实现.haproxy+keepal

Linux CentOS搭建JDK+Mysql+Tomcat+Nginx负载均衡环境 &nbsp; &nbsp; &nbsp;

本文使用了Tomcat+Nginx环境,主要起到负载均衡的作用,使用Tomcat处理jsp后台程序,使用Nginx处理静态页面. 准备工作(下载软件版本,请自行百度下载) 安装包放至:/usr/local/src 安装地址:/usr/local/软件名 1.apache-tomcat-6.0.48 2.mysql-5.5.54 3.nginx-1.6.3 4.cmake-2.8.8 5.pcre-8.40 6.jdk-8u11-linux-x64 7.openssl-1.1.0d(https使用

MySQL 高可用：mysql+Lvs+Keepalived 负载均衡及故障转移

转自 MySQL 高可用:mysql+Lvs+Keepalived 负载均衡及故障转移 - KK ——专注数据 - 博客频道 - CSDN.NEThttp://blog.csdn.net/kk185800961/article/details/51115264# 系统信息: mysql主库 192.168.1.152 CentOS 5.6 mysql 5.6.22 mysql从库 192.168.1.153 CentOS 5.6 mysql 5.6.22 VIP 192.168.1.150 my

MySQL 数据库的主从复制与读写分离

在实际生产环境中,如果对数据库的读和写都在同一个数据库服务器中操作,无论是安全性.高可用性,还是高并发等各个方面都是完全不能满足实际需求的,因此,一般来说都是通过主从复制(Master-Slave)的方式来同步数据,再通过读写分离来提升数据库的并发负载能力这样的方案来进行部署与实施. MySQL 的主从复制和读写分离两者有着紧密关联,首先要部署主从复制,才能在此基础上进行数据的读写分离. MySQL 主从复制的复制类型1) 基于语句的数据.在主服务器上执行的 SQL 语句,在从服务器上执行同样的

Mysql主从配置，实现读写分离

大型网站为了软解大量的并发访问,除了在网站实现分布式负载均衡,远远不够.到了数据业务层.数据访问层,如果还是传统的数据结构,或者只是单单靠一台服务器扛,如此多的数据库连接操作,数据库必然会崩溃,数据丢失的话,后果更是 不堪设想.这时候,我们会考虑如何减少数据库的联接,一方面采用优秀的代码框架,进行代码的优化,采用优秀的数据缓存技术如:memcached,如果资金丰厚的话,必然会想到假设服务器群,来分担主数据库的压力.Ok切入今天微博主题,利用MySQL主从配置,实现读写分离,减轻数据库压力.这种

MySQL/MariaDB基于MMM实现读写分离及高可用

前言 MMM(Master-Master replication managerfor Mysql,Mysql主主复制管理器)是一套灵活的脚本程序,基于perl实现,用来对mysql replication进行监控和故障迁移,并能管理mysql Master-Master复制的配置(同一时间只有一个节点是可写的). MMM 优缺点 优点:高可用性,扩展性好,出现故障自动切换,对于主主同步,在同一时间只提供一台数据库写操作,保证的数据的一致性. 缺点:Monitor节点是单点,可以结合Keepal

高可用架构篇--MyCat在MySQL主从复制基础上实现读写分离

点击链接加入群[Dubbo技术交流2群]:https://jq.qq.com/?_wv=1027&k=46DcDFI 一.环境 操作系统:CentOS-6.6-x86_64-bin-DVD1.iso JDK版本:jdk1.7.0_45 MyCat版本:Mycat-server-1.4-release-20151019230038-linux.tar.gz MyCat节点IP:192.168.1.203      主机名:edu-mycat-01  主机配置:4核CPU.4G内存 MySQL版本: