mysql （主从复制）（proxy , Amoeba）

时间 2019-11-24

标签 mysql 主从复制 proxy amoeba 栏目 MySQL 繁體版

原文原文链接

原址以下：

http://heylinux.com/archives/1004.htmlhtml

Mysql做为目前世界上使用最普遍的免费数据库，相信全部从事系统运维的工程师都必定接触过。但在实际的生产环境中，由单台Mysql做为独立的数据库是彻底不能知足实际需求的，不管是在安全性，高可用性以及高并发等各个方面。前端

所以，通常来讲都是经过主从复制（Master-Slave）的方式来同步数据，再经过读写分离（MySQL-Proxy）来提高数据库的并发负载能力这样的方案来进行部署与实施的。java

以下图所示：
mysql

下面是我在实际工做过程当中所整理的笔记，在此分享出来，以供你们参考。linux

1、MySQL的安装与配置
具体的安装过程，建议参考个人这一篇文章：http://heylinux.com/archives/993.html
值得一提的是，个人安装过程都是源码包编译安装的，而且全部的配置与数据等都统一规划到了/opt/mysql目录中，所以在一台服务器上安装完成之后，能够将整个mysql目录打包，而后传到其它服务器上解包，即可当即使用。c++

2、MySQL主从复制
场景描述：
主数据库服务器：192.168.10.130，MySQL已经安装，而且无应用数据。
从数据库服务器：192.168.10.131，MySQL已经安装，而且无应用数据。sql

2.1 主服务器上进行的操做
启动mysql服务
/opt/mysql/init.d/mysql start数据库

经过命令行登陆管理MySQL服务器
/opt/mysql/bin/mysql -uroot -p'new-password'编程

受权给从数据库服务器192.168.10.131
mysql> GRANT REPLICATION SLAVE ON *.* to 'rep1'@'192.168.10.131' identified by ‘password’;vim

记录下 FILE 及 Position 的值，在后面进行从服务器操做的时候须要用到。

2.2 配置从服务器
修改从服务器的配置文件/opt/mysql/etc/my.cnf
将 server-id = 1修改成 server-id = 10，并确保这个ID没有被别的MySQL服务所使用。

启动mysql服务
/opt/mysql/init.d/mysql start

经过命令行登陆管理MySQL服务器
/opt/mysql/bin/mysql -uroot -p'new-password'

执行同步SQL语句
mysql> change master to
master_host=’192.168.10.130’,
master_user=’rep1’,
master_password=’password’,
master_log_file=’mysql-bin.000005’,
master_log_pos=261;

正确执行后启动Slave同步进程
mysql> start slave;

主从同步检查
mysql> show slave status\G
==============================================
**************** 1. row *******************
Slave_IO_State:
Master_Host: 192.168.10.130
Master_User: rep1
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000005
Read_Master_Log_Pos: 415
Relay_Log_File: localhost-relay-bin.000008
Relay_Log_Pos: 561
Relay_Master_Log_File: mysql-bin.000005
Slave_IO_Running: YES
Slave_SQL_Running: YES
Replicate_Do_DB:
……………省略若干……………
Master_Server_Id: 1
1 row in set (0.01 sec)
==============================================

其中Slave_IO_Running 与 Slave_SQL_Running 的值都必须为YES，才代表状态正常。

若是主服务器已经存在应用数据，则在进行主从复制时，须要作如下处理：
(1)主数据库进行锁表操做，不让数据再进行写入动做
mysql> FLUSH TABLES WITH READ LOCK;

(2)查看主数据库状态
mysql> show master status;

(3)记录下 FILE 及 Position 的值。
将主服务器的数据文件（整个/opt/mysql/data目录）复制到从服务器，建议经过tar归档压缩后再传到从服务器解压。

(4)取消主数据库锁定
mysql> UNLOCK TABLES;

2.3 验证主从复制效果

主服务器上的操做
在主服务器上建立数据库first_db
mysql> create database first_db;
Query Ok, 1 row affected (0.01 sec)

在主服务器上建立表first_tb
mysql> create table first_tb(id int(3),name char(10));
Query Ok, 1 row affected (0.00 sec)

在主服务器上的表first_tb中插入记录
mysql> insert into first_tb values (001,’myself’);
Query Ok, 1 row affected (0.00 sec)

mysql> use first_db
Database chaged

mysql> show tables;
=============================
+--------------------+
| Tables_in_first_db |
+--------------------+
| first_tb |
+--------------------+
1 row in set (0.02 sec)
=============================
数据库表first_tb也已经自动建立

mysql> select * from first_tb;
=============================
+------+------+
| id | name |
+------+------+
| 1 | myself |
+------+------+
1 rows in set (0.00 sec)
=============================
记录也已经存在

由此，整个MySQL主从复制的过程就完成了，接下来，咱们进行MySQL读写分离的安装与配置。

3、MySQL读写分离
场景描述：
数据库Master主服务器：192.168.10.130
数据库Slave从服务器：192.168.10.131
MySQL-Proxy调度服务器：192.168.10.132

如下操做，均是在192.168.10.132即MySQL-Proxy调度服务器上进行的。

3.1 MySQL的安装与配置
具体的安装过程与上文相同。

3.2 检查系统所需软件包
经过 rpm -qa | grep name 的方式验证如下软件包是否已所有安装。
gcc* gcc-c++* autoconf* automake* zlib* libxml* ncurses-devel* libmcrypt* libtool* flex* pkgconfig*
libevent* glib*

若缺乏相关的软件包，可经过yum -y install方式在线安装，或直接从系统安装光盘中找到并经过rpm -ivh方式安装。

3.3 编译安装lua
MySQL-Proxy的读写分离主要是经过rw-splitting.lua脚本实现的，所以须要安装lua。

lua可经过如下方式得到
从http://www.lua.org/download.html下载源码包

从rpm.pbone.NET搜索相关的rpm包
download.fedora.redhat.com/pub/fedora/epel/5/i386/lua-5.1.4-4.el5.i386.rpm
download.fedora.redhat.com/pub/fedora/epel/5/x86_64/lua-5.1.4-4.el5.x86_64.rpm

这里咱们建议采用源码包进行安装
cd /opt/install
wget http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zvfx lua-5.1.4.tar.gz
cd lua-5.1.4

vi src/Makefile
在 CFLAGS= -O2 -Wall $(MYCFLAGS) 这一行记录里加上-fPIC，更改成 CFLAGS= -O2 -Wall -fPIC $(MYCFLAGS) 来避免编译过程当中出现错误。

make Linux
make install

cp etc/lua.pc /usr/lib/pkgconfig/
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/lib/pkgconfig

3.4 安装配置MySQL-Proxy
MySQL-Proxy可经过如下网址得到：
http://mysql.cdpa.nsysu.edu.tw/Downloads/MySQL-Proxy/

推荐采用已经编译好的二进制版本，由于采用源码包进行编译时，最新版的MySQL-Proxy对automake，glib以及libevent的版本都有很高的要求，而这些软件包都是系统的基础套件，不建议强行进行更新。
而且这些已经编译好的二进制版本在解压后都在统一的目录内，所以建议选择如下版本：
32位RHEL5平台：
http://mysql.cdpa.nsysu.edu.tw/Downloads/MySQL-Proxy/mysql-proxy-0.8.1-linux-rhel5-x86-32bit.tar.gz
64位RHEL5平台：
http://mysql.cdpa.nsysu.edu.tw/Downloads/MySQL-Proxy/mysql-proxy-0.8.1-linux-rhel5-x86-64bit.tar.gz

测试平台为RHEL5 32位，所以选择32位的软件包
wget http://mysql.cdpa.nsysu.edu.tw/Downloads/MySQL-Proxy/mysql-proxy-0.8.1-linux-rhel5-x86-32bit.tar.gz

tar xzvf mysql-proxy-0.8.1-linux-rhel5-x86-32bit.tar.gz
mv mysql-proxy-0.8.1-linux-rhel5-x86-32bit /opt/mysql-proxy

建立mysql-proxy服务管理脚本
mkdir /opt/mysql-proxy/init.d/

vim mysql-proxy

 
      01 
      #!/bin/sh 
     
      02 
      # 
     
      03 
      # mysql-proxy This script starts and stops the mysql-proxy daemon 
     
      04 
      # 
     
      05 
      # chkconfig: - 78 30 
     
      06 
      # processname: mysql-proxy 
     
      07 
      # description: mysql-proxy is a proxy daemon to mysql 
     
      08 
        
      09 
      # Source function library. 
     
      10 
      . /etc/rc.d/init.d/functions 
     
      11 
        
      12 
      #PROXY_PATH=/usr/local/bin 
     
      13 
      PROXY_PATH=/opt/mysql-proxy/bin 
     
      14 
        
      15 
      prog="mysql-proxy" 
     
      16 
        
      17 
      # Source networking configuration. 
     
      18 
      . /etc/sysconfig/network 
     
      19 
        
      20 
      # Check that networking is up. 
     
      21 
      [ ${NETWORKING} = "no" ] && exit 0 
     
      22 
        
      23 
      # Set default mysql-proxy configuration. 
     
      24 
      #PROXY_OPTIONS="--daemon" 
     
      25 
      PROXY_OPTIONS="--admin-username=root --admin-password=password --proxy-read-only-backend-addresses=192.168.10.131:3306 --proxy-backend-addresses=192.168.10.130:3306  --admin-lua-script=/opt/mysql-proxy/lib/mysql-proxy/lua/admin.lua --proxy-lua-script=/opt/mysql-proxy/scripts/rw-splitting.lua" 
     
      26 
      PROXY_PID=/opt/mysql-proxy/run/mysql-proxy.pid 
     
      27 
        
      28 
      # Source mysql-proxy configuration. 
     
      29 
      if [ -f /etc/sysconfig/mysql-proxy ]; then 
     
      30 
              . /etc/sysconfig/mysql-proxy 
     
      31 
      fi 
     
      32 
        
      33 
      PATH=$PATH:/usr/bin:/usr/local/bin:$PROXY_PATH 
     
      34 
        
      35 
      # By default it's all good 
     
      36 
      RETVAL=0 
     
      37 
        
      38 
      # See how we were called. 
     
      39 
      case "$1" in 
     
      40 
        start) 
     
      41 
              # Start daemon. 
     
      42 
              echo -n $"Starting $prog: " 
     
      43 
              $NICELEVEL $PROXY_PATH/mysql-proxy $PROXY_OPTIONS --daemon --pid-file=$PROXY_PID --user=mysql --log-level=warning --log-file=/opt/mysql-proxy/log/mysql-proxy.log 
     
      44 
              RETVAL=$? 
     
      45 
              echo 
     
      46 
              if [ $RETVAL = 0 ]; then 
     
      47 
                      touch /var/lock/subsys/mysql-proxy 
     
      48 
              fi 
     
      49 
             ;; 
     
      50 
        stop) 
     
      51 
              # Stop daemons. 
     
      52 
              echo -n $"Stopping $prog: " 
     
      53 
              killproc $prog 
     
      54 
              RETVAL=$? 
     
      55 
              echo 
     
      56 
              if [ $RETVAL = 0 ]; then 
     
      57 
                      rm -f /var/lock/subsys/mysql-proxy 
     
      58 
                      rm -f $PROXY_PID 
     
      59 
              fi 
     
      60 
             ;; 
     
      61 
        restart) 
     
      62 
              $0 stop 
     
      63 
              sleep 3 
     
      64 
              $0 start 
     
      65 
             ;; 
     
      66 
        condrestart) 
     
      67 
             [ -e /var/lock/subsys/mysql-proxy ] && $0 restart 
     
      68 
            ;; 
     
      69 
        status) 
     
      70 
              status mysql-proxy 
     
      71 
              RETVAL=$? 
     
      72 
             ;; 
     
      73 
        *) 
     
      74 
              echo "Usage: $0 {start|stop|restart|status|condrestart}" 
     
      75 
              RETVAL=1 
     
      76 
             ;; 
     
      77 
      esac 
     
      78 
        
      79 
      exit $RETVAL

脚本参数详解：
==============================================
PROXY_PATH=/opt/mysql-proxy/bin //定义mysql-proxy服务二进制文件路径

PROXY_OPTIONS="--admin-username=root \ //定义内部管理服务器帐号
--admin-password=password \ //定义内部管理服务器密码
--proxy-read-only-backend-addresses=192.168.10.131:3306 \ //定义后端只读从服务器地址
--proxy-backend-addresses=192.168.10.130:3306 \ //定义后端主服务器地址
--admin-lua-script=/opt/mysql-proxy/lib/mysql-proxy/lua/admin.lua \ //定义lua管理脚本路径
--proxy-lua-script=/opt/mysql-proxy/scripts/rw-splitting.lua" \ //定义lua读写分离脚本路径

PROXY_PID=/opt/mysql-proxy/run/mysql-proxy.pid //定义mysql-proxy PID文件路径

$NICELEVEL $PROXY_PATH/mysql-proxy $PROXY_OPTIONS \
--daemon \ //定义以守护进程模式启动
--keepalive \ //使进程在异常关闭后可以自动恢复
--pid-file=$PROXY_PID \ //定义mysql-proxy PID文件路径
--user=mysql \ //以mysql用户身份启动服务
--log-level=warning \ //定义log日志级别，由高到低分别有(error|warning|info|message|debug)
--log-file=/opt/mysql-proxy/log/mysql-proxy.log //定义log日志文件路径
==============================================

cp mysql-proxy /opt/mysql-proxy/init.d/
chmod +x /opt/mysql-proxy/init.d/mysql-proxy

mkdir /opt/mysql-proxy/run
mkdir /opt/mysql-proxy/log

mkdir /opt/mysql-proxy/scripts

配置并使用rw-splitting.lua读写分离脚本
最新的脚本咱们能够从最新的mysql-proxy源码包中获取
cd /opt/install

wget http://mysql.cdpa.nsysu.edu.tw/Downloads/MySQL-Proxy/mysql-proxy-0.8.1.tar.gz

tar xzvf mysql-proxy-0.8.1.tar.gz
cd mysql-proxy-0.8.1
cp lib/rw-splitting.lua /opt/mysql-proxy/scripts

修改读写分离脚本rw-splitting.lua
修改默认链接，进行快速测试，不修改的话要达到链接数为4时才启用读写分离
vim /opt/mysql-proxy/scripts/rw-splitting.lua
=============================
-- connection pool
if not proxy.global.config.rwsplit then
proxy.global.config.rwsplit = {
min_idle_connections = 1, //默认为4
max_idle_connections = 1, //默认为8
is_debug = false
}
end
=============================

修改完成后，启动mysql-proxy
/opt/mysql-proxy/init.d/mysql-proxy start

3.5 测试读写分离效果
建立用于读写分离的数据库链接用户
登录主数据库服务器192.168.10.130，经过命令行登陆管理MySQL服务器
/opt/mysql/bin/mysql -uroot -p'new-password'
mysql> GRANT ALL ON *.* TO 'proxy1'@'192.168.10.132' IDENTIFIED BY 'password';
因为咱们配置了主从复制功能，所以从数据库服务器192.168.10.131上已经同步了此操做。

为了清晰的看到读写分离的效果，须要暂时关闭MySQL主从复制功能
登录从数据库服务器192.168.10.131，经过命令行登陆管理MySQL服务器
/opt/mysql/bin/mysql -uroot -p'new-password'

关闭Slave同步进程
mysql> stop slave;
Query OK, 0 rows affected (0.00 sec)

链接MySQL-Proxy
/opt/mysql/bin/mysql -uproxy1 -p'password' -P4040 -h192.168.10.132

登录成功后，在first_db数据的first_tb表中插入两条记录
mysql> use first_db;
Database changed
mysql> insert into first_tb values (007,’first’);
Query Ok, 1 row affected (0.00 sec)
mysql> insert into first_tb values (110,’second’);
Query Ok, 1 row affected (0.00 sec)

查询记录
mysql> select * from first_tb;
=============================
+------+------+
| id | name |
+------+------+
| 1 | myself |
+------+------+
1 rows in set (0.00 sec)
=============================
经过读操做并无看到新记录

mysql> quit
退出MySQL-Proxy

下面，分别登录到主从数据库服务器，对比记录信息
首先，检查主数据库服务器
mysql> select * from first_tb;
=============================
+------+------+
| id | name |
+------+------+
| 1 | myself |
+------+------+
| 007 | first |
+------+------+
| 110 | second |
+------+------+
3 rows in set (0.00 sec)
=============================
两条新记录都已经存在

而后，检查从数据库服务器
mysql> select * from first_tb;
=============================
+------+------+
| id | name |
+------+------+
| 1 | myself |
+------+------+
1 rows in set (0.00 sec)
=============================
没有新记录存在

由此验证，咱们已经实现了MySQL读写分离，目前全部的写操做都所有在Master主服务器上，用来避免数据的不一样步；
另外，全部的读操做都分摊给了其它各个Slave从服务器上，用来分担数据库压力。

经验分享：
1.当MySQL主从复制在 show slave status\G 时出现Slave_IO_Running或Slave_SQL_Running 的值不为YES时，须要首先经过 stop slave 来中止从服务器，而后再执行一次本文 2.1与2.2 章节中的步骤便可恢复，但若是想尽量的同步更多的数据，能够在Slave上将master_log_pos节点的值在以前同步失效的值的基础上增大一些，而后反复测试，直到同步OK。由于MySQL主从复制的原理其实就是从服务器读取主服务器的binlog，而后根据binlog的记录来更新数据库。

2.MySQL-Proxy的rw-splitting.lua脚本在网上有不少版本，可是最准确无误的版本仍然是源码包中所附带的lib/rw-splitting.lua脚本，若是有lua脚本编程基础的话，能够在这个脚本的基础上再进行优化；

3.MySQL-Proxy实际上很是不稳定，在高并发或有错误链接的状况下，进程很容易自动关闭，所以打开--keepalive参数让进程自动恢复是个比较好的办法，但仍是不能从根本上解决问题，所以一般最稳妥的作法是在每一个从服务器上安装一个MySQL-Proxy供自身使用，虽然比较低效但却能保证稳定性；

4.一主多从的架构并非最好的架构，一般比较优的作法是经过程序代码和中间件等方面，来规划，好比设置对表数据的自增id值差别增加等方式来实现两个或多个主服务器，但必定要注意保证好这些主服务器数据的完整性，不然效果会比多个一主多从的架构还要差；

5.MySQL-Cluster 的稳定性也不是太好；

6.Amoeba for MySQL 是一款优秀的中间件软件，一样能够实现读写分离，负载均衡等功能，而且稳定性要大大超过MySQL-Proxy，建议你们用来替代MySQL-Proxy，甚至MySQL-Cluster。

详解Mysql Proxy Lua读写分离设置

原址以下：

http://mobile.51cto.com/iphone-287937.htm

Mysql Proxy Lua读写分离设置是本文要介绍的内容，主要是来了解Mysql Proxy的Mysql 分离设置，为了将来MySQL读写分离的须要, 先行对MySQL官方的Mysql Proxy产品进行了初步测试. 如下是测试过程，二进制版Mysql Proxy能够去下载。

一、设置说明

Master服务器: 192.168.41.196
Slave服务器: 192.168.41.197
Proxy服务器: 192.168.41.203

二、安装Mysql Proxy

在Proxy服务器上安装便可. 若是源码方式安装, 需提早安装pkg-config,libevent,glibc,lua等依赖包, 很是麻烦, 建议直接使用二进制版.

# cd /u01/software/mysql
# tar -zxvf Mysql Proxy-0.8.1-linux-rhel5-x86-32bit.tar.gz -C /usr/local
# cd /usr/local
# ln -s Mysql Proxy-0.8.1-linux-rhel5-x86-32bit Mysql Proxy
# vi + ~/.bash_profile
export PATH=$PATH:/usr/local/Mysql Proxy/bin/
# . ~/.bash_profile

三、Mysql Proxy选项说明

# Mysql Proxy help-all

管理功能选项:

admin-address=host:port 指定一个mysqo-proxy的管理端口, 缺省是4041;
admin-username=<string> username to allow to log in
admin-password=<string> password to allow to log in
admin-lua-script=<filename> script to execute by the admin plugin

代理功能选项:

-P, proxy-address=<host:port> 是Mysql Proxy 服务器端的监听端口, 缺省是4040;
-r, proxy-read-only-backend-addresses=<host:port> 只读Slave的地址和端口, 缺省为不设置;
-b, proxy-backend-addresses=<host:port> 远程Master地址和端口, 可设置多个作failover和load balance, 缺省是127.0.0.1:3306;
proxy-skip-profiling 关闭查询分析功能, 缺省是打开的;
proxy-fix-bug-25371 修正 mysql的libmysql版本大于5.1.12的一个#25371号bug;
-s, proxy-lua-script=<file> 指定一个Lua脚原本控制Mysql Proxy的运行和设置, 这个脚本在每次新建链接和脚本发生修改的的时候将从新调用;

其余选项:

defaults-file=<file>配置文件, 能够把Mysql Proxy的参数信息置入一个配置文件里;
daemon Mysql Proxy以守护进程方式运行
pid-file=file 设置Mysql Proxy的存储PID文件的路径
keepalive try to restart the proxy if it crashed, 保持链接启动进程会有2个, 一号进程用来监视二号进程, 若是二号进程死掉自动重启proxy.

四、数据库准备工做

（1）安装半同步补丁(建议)

读写分离不能回避的问题之一就是延迟, 能够考虑Google提供的SemiSyncReplication补丁.

（2）给用户受权

在Master/Slave创建一个测试用户, 由于之后客户端发送的SQL都是经过Mysql Proxy服务器来转发, 因此要确保能够从Mysql Proxy服务器上登陆MySQL主从库.

mysql> grant all privileges on *.* to 'u_test'@'192.168.41.203' identified by 'xxx' with grant option;

（3）在Master创建测试表

mysql> create table db_test.t_test (col varchar(10));
mysql> insert into db_test.t_test values ('testA');
mysql> select * from db_test.t_test;
+-+
| col |
+-+
| testA |
+-+

五、Mysql Proxy启动

（1）修改读写分离lua脚本

默认最小4个最大8个以上的客户端链接才会实现读写分离, 现改成最小1个最大2个:

# vi +40 /usr/local/Mysql Proxy/share/doc/Mysql Proxy/rw-splitting.lua
connection pool
if not proxy.global.config.rwsplit then
proxy.global.config.rwsplit = {
min_idle_connections = 1,
max_idle_connections = 2,
is_debug = true
}
end

这是由于Mysql Proxy会检测客户端链接, 当链接没有超过min_idle_connections预设值时, 不会进行读写分离, 即查询操做会发生到Master上.

（2）启动Mysql Proxy

建议使用配置文件的形式启动, 注意配置文件必须是660权限, 不然没法启动. 若是有多个Slave的话, proxy-read-only-backend-addresses参数能够配置多个以逗号分隔的IP:Port从库列表.

# killall Mysql Proxy
# vi /etc/Mysql Proxy.cnf
[Mysql Proxy]
admin-username=wangnc
admin-password=iamwangnc
admin-lua-script=/usr/local/Mysql Proxy/lib/Mysql Proxy/lua/admin.lua
proxy-backend-addresses=192.168.41.196:3351
proxy-read-only-backend-addresses=192.168.41.197:3351
proxy-lua-script=/usr/local/Mysql Proxy/share/doc/Mysql Proxy/rw-splitting.lua
log-file=/var/tmp/Mysql Proxy.log
log-level=debug
daemon=true
keepalive=true
# chmod 660 /etc/Mysql Proxy.cnf
# Mysql Proxy defaults-file=/etc/Mysql Proxy.cnf
# ps -ef | grep Mysql Proxy | grep -v grep
root 1869 1 0 18:16 ? 00:00:00 /usr/local/Mysql Proxy/libexec/Mysql Proxy defaults-file=/etc/Mysql Proxy.cnf
root 1870 1869 0 18:16 ? 00:00:00 /usr/local/Mysql Proxy/libexec/Mysql Proxy defaults-file=/etc/Mysql Proxy.cnf
# tail -50f /var/tmp/Mysql Proxy.log

六、客户端链接测试

（1）先中止Slave的复制进程

mysql> stop slave;

（2）链接Proxy端口, 插入数据

# mysql -uu_test -pxxx -h192.168.41.203 -P4040 -Ddb_test
mysql> insert into db_test.t_test values ('testB');
mysql> select * from db_test.t_test;
+-+
| col |
+-+
| testA |
| testB |
+-+

（3）多开几个客户端, 链接Proxy端口, 查询数据

# mysql -uu_test -pxxx -h192.168.41.203 -P4040 -Ddb_test
mysql> select * from db_test.t_test;
+-+
| col |
+-+
| testA |
+-+

若是查询不到上步新插入的数据, 说明链接到了Slave, 读写分离成功. 在同一线程再插入数据并验证:

mysql> insert into db_test.t_test values ('testC');
mysql> select * from db_test.t_test;
+-+
| col |
+-+
| testA |
+-+

发现insert操做成功, 可是select不出刚插入的数据, 说明同一线程也读写分离成功. 从日志中能够验证:

# tail -50f /var/tmp/Mysql Proxy.log
...
[read_query] 192.168.41.203:45481
current backend = 0
client default db = db_test
client username = u_test
query = select * from db_test.t_test
sending to backend : 192.168.41.197:3351
is_slave : true
server default db: db_test
server username : u_test
in_trans : false
in_calc_found : false
COM_QUERY : true
[read_query] 192.168.41.203:45481
current backend = 0
client default db = db_test
client username = u_test
query = insert into db_test.t_test values ('testC')
sending to backend : 192.168.41.196:3351
is_slave : false
server default db: db_test
server username : u_test
in_trans : false
in_calc_found : false
COM_QUERY : true

（4）测试完毕后, 启动Slave的复制进程

mysql> start slave;

七、正式环境说明

一、Mysql Proxy当前还只是个测试版, MySQL官方还不建议用到生产环境中;

二、Mysql Proxy的rw-splitting.lua脚本在网上有不少版本, 可是最准确无误的版本仍然是源码包中所附带的rw-splitting.lua脚本, 若是有lua脚本编程基础的话, 能够在这个脚本的基础上再进行优化；

三、Mysql Proxy实际上很是不稳定, 在高并发或有错误链接的状况下, 进程很容易自动关闭, 所以打开keepalive参数让进程自动恢复是个比较好的办法, 但仍是不能从根本上解决问题, 所以一般最稳妥的作法是在每一个从服务器上安装一个Mysql Proxy供自身使用, 虽然比较低效但却能保证稳定性；

四、Amoeba for MySQL是一款优秀的中间件软件, 一样能够实现读写分离, 负载均衡等功能, 而且稳定性要大大超过Mysql Proxy, 建议你们用来替代Mysql Proxy, 甚至MySQL-Cluster.

mysql的读写分离amoeba

原址以下：

http://freeze.blog.51cto.com/1846439/860111

此文凝聚笔者很多心血请尊重笔者劳动，转载请注明出处http://freeze.blog.51cto.com/

1、关于读写分离

读写分离（Read/Write Splitting），基本的原理是让主数据库处理事务性增、改、删操做（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操做。数据库复制被用来把事务性操做致使的变动同步到集群中的从数据库。

2、同类产品比较

虽然大多数都是从程序里直接实现读写分离的，但对于分布式的部署和水平和垂直分割，一些代理的相似中间件的软件仍是挺实用的，Amoeba for Mysql 与MySQL Proxy比较在MySQL proxy 6.0版本上面若是想要读写分离而且读集群、写集群机器比较多状况下，用mysql proxy 须要至关大的工做量，目前mysql proxy没有现成的 lua脚本。mysql proxy根本没有配置文件， lua脚本就是它的所有，固然lua是至关方便的。那么一样这种东西须要编写大量的脚本才能完成一个复杂的配置。而Amoeba for Mysql只须要进行相关的配置就能够知足需求。

3、关于Amoeba

Amoeba(变形虫)项目,该开源框架于2008年开始发布一款 Amoeba for Mysql软件。这个软件致力于MySQL的分布式数据库前端代理层，它主要在应用层访问MySQL的时候充当SQL路由功能，专一于分布式数据库代理层（Database Proxy）开发。座落与 Client、DB Server(s)之间,对客户端透明。具备负载均衡、高可用性、SQL 过滤、读写分离、可路由相关的到目标数据库、可并发请求多台数据库合并结果。经过Amoeba你可以完成多数据源的高可用、负载均衡、数据切片的功能，目前Amoeba已在不少企业的生产线上面使用。

4、Amoeba的安装

4.1下载

wget http://nchc.dl.sourceforge.net/project/amoeba/Amoeba%20for%20mysql/2.x/amoeba-mysql-binary-2.1.0-RC5.tar.gz

4.2安装amoeba

mkdir /usr/local/amoeba
#mv amoeba-mysql-binary-2.1.0-RC5.tar.gz /usr/local/amoeba
#tar xvf amoeba-mysql-binary-2.1.0-RC5.tar.gz

4.3安装JDK

由于Amoeba是java开发的，须要JDK支持。 Amoeba框架是基于Java SE1.5开发的，建议使用Java SE 1.5版本。
% java -version
java version "1.6.0_18"
Java(TM) SE Runtime Environment (build 1.6.0_18-b07)
Java HotSpot(TM) Client VM (build 16.0-b13, mixed mode, sharing)
目前Amoeba经验证在JavaTM SE 1.5和Java SE 1.6能正常运行，（可能包括其余未经验证的版本）。若是你的机器上没有安装JavaTM环境，能够访问http://www.oracle.com/technetwork/java/javase/downloads/index.html进行下载。能够根据你的操做系统等详情安装JavaTM环境。
去oracle官网下载jdk安装包后，安装jdk
# chmod 755 jdk-6u25-linux-i586.bin
# ./jdk-6u25-linux-i586.bin
# mv jdk1.6.0_25/ /usr/local/jdk
声明路径，修改/etc/profile，在末尾加上如下代码
export AMOEBA_HOME=/usr/local/amoeba
export JAVA_HOME=/usr/local/jdk
export PATH=$PATH:$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$AMOEBA_HOME/bin

5、Amoeba配置

cd /usr/local/amoeba/conf 主要配置如下2个配置文件：
dbServers.xml #定义链接数据库信息
amoeba.xml #定义读写分离节点管理信息

5.1 配置dbServers.xml

<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE amoeba:dbServers SYSTEM "dbserver.dtd">
<amoeba:dbServers xmlns:amoeba="http://amoeba.meidusa.com/">
<!--
Each dbServer needs to be configured into a Pool,
such as 'multiPool' dbServer
-->
<dbServer name="abstractServer" abstractive="true">
<factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
<property name="manager">${defaultManager}</property>
<property name="sendBufferSize">64</property>
<property name="receiveBufferSize">128</property>
<property name="port">3306</property> __ ** ##后端数据库端口**__
<property name="schema">test</property> __ ** ##后端数据库默认库**__
<!-- mysql password
<property name="password">password</property>
-->
</factoryConfig>
<poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
<property name="maxActive">500</property>
<property name="maxIdle">500</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" parent="abstractServer"> __ ** ##定义主的写的节点**__
<factoryConfig>
<property name="ipAddress">192.168.1.1</property> __ ** ##主masterIP**__
<property name="user">test1</property> __ ** ##与主mysql通讯，链接数据库的账号，如下是密码**__
<property name="password">test1</property>
</factoryConfig>
</dbServer>
<dbServer name="slave" parent="abstractServer">
<factoryConfig>
<property name="ipAddress">192.168.1.2</property>
<property name="user">test2</property> __ ** ##与从mysql通讯，链接数据库的账号，如下是密码**__
<property name="password">test2</property>
</factoryConfig>
</dbServer>
<dbServer name="server1" virtual="true">
<poolConfig class="com.meidusa.amoeba.server.MultipleServerPool"> __ ** ##定义写的池，把master节点加入**__
<property name="loadbalance">1</property>
<property name="poolNames">master</property>
</poolConfig>
</dbServer>
<dbServer name="server2" virtual="true">
<poolConfig class="com.meidusa.amoeba.server.MultipleServerPool"> __ ** ##定义读的池，把slave节点加入**__
<property name="loadbalance">1</property>
<property name="poolNames">slave</property>
</poolConfig>
</dbServer>
</amoeba:dbServers>

5.2 配置amoeba.xml

<?xml version="1.0" encoding="gbk"?>
<amoeba:configuration xmlns:amoeba="http://amoeba.meidusa.com/">
<proxy>
<property name="port">6666</property> __ ** ##定义amoeba读写分离proxy对外代理的端口**__
<!--
<property name="ipAddress">127.0.0.1</property>
-->
<property name="manager">${clientConnectioneManager}</property>
<property name="connectionFactory">
<property name="sendBufferSize">128</property>
<property name="receiveBufferSize">64</property>
</bean>
</property>
<property name="authenticator">
<property name="user">dbproxy</property> __ ** ##定义proxy的管理账号密码，客户端和程序只须要链接proxy的账号密码便可，至关于中间接封装**__
<property name="password">123456</property>
<property name="filter">
</bean>
</property>
</bean>
</property>
</service>
<!-- default value: random number
<property name="port">9066</property>
-->
<property name="ipAddress">127.0.0.1</property>
<property name="daemon">true</property>
<property name="manager">${clientConnectioneManager}</property>
<property name="connectionFactory">
<runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext">
<property name="readThreadPoolSize">20</property>
<property name="statementCacheSize">500</property>
<property name="queryTimeout">60</property>
</runtime>
</proxy>
<!--
Each ConnectionManager will start as thread
manager responsible for the Connection IO read , Death Detection
-->
<connectionManagerList>
<!--
default value is avaliable Processors
<property name="processors">5</property>
-->
</connectionManager>
<!--
default value is avaliable Processors
<property name="processors">5</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">server1</property> __ ** ##定义默认的池，一些除了SELECT\UPDATE\INSERT\DELETE的语句都会在defaultPool执行。**__
<property name="writePool">server1</property> __ ** ##定义写的池**__
<property name="readPool">server2</property> __ ** ##定义读的池**__
<property name="needParse">true</property>
</queryRouter>
</amoeba:configuration>

6、启动Amoeba

/usr/local/amoeba/bin/amoeba start &
开机自动启动可加入到 /etc/rc.local内
echo "/usr/local/amoeba/bin/amoeba start &" >> /etc/rc.local

7、日志排错

日志文件在/usr/local/amoeba/log下

PS：amoeba虽然是Java写的，看似效率不高，但功能异常强大，支持读写分离，表和库级别的读写分离，数据库水平分割，垂直分割，还有集群。是淘宝的得力做品。喜欢的童鞋能够尝试下。mysql-proxy 只是轻量级的读写分离程序，虽然C写的，可是驱动是须要lua的脚本跑，并且在高并发下常常挂掉。程序还忽略了一些字符设定，若是数据库不是同一编码还会出现乱码,amoeba就不存在。就简单介绍到这里吧。

使用Amoeba for mysql实现mysql读写分离

原址以下：

http://www.centos.bz/2012/05/amoeba-for-mysql/

Amoeba for MySQL致力于MySQL的分布式数据库前端代理层，它主要在应用层访问MySQL的时候充当query 路由功能，专一分布式数据库 proxy 开发。座落与Client、DB Server(s)之间。对客户端透明。具备负载均衡、高可用性、Query过滤、读写分离、可路由相关的query到目标数据库、可并发请求多台数据库合并结果。在Amoeba上面你可以完成多数据源的高可用、负载均衡、数据切片的功能。目前在不少企业的生产线上面使用。
www.centos.bz这里使用Amoeba for mysql来实现mysql的读写分离，起到缓解主数据库服务器的压力，下面是实现这一方案的架构图：

mysql主从复制配置

由于读写分离，因此一台负责mysql的写操做，另外一台负责mysql的读操做，因此咱们这里使用mysql的主从复制再合适不过了。关于这一配置，请移步：
http://www.centos.bz/2011/07/linux-mysql-replication-sync-configure/

java环境配置

Amoeba框架是基于Java SE1.5开发的，建议使用Java SE 1.5版本。目前Amoeba经验证在JavaTM SE 1.5和Java SE 1.6能正常运行，（可能包括其余未经验证的版本）。
Java SE 1.6下载地址：http://www.oracle.com/technetwork/java/javase/downloads/jdk-6u32-downloads-1594644.html
我这里下载jdk-6u32-linux-i586-rpm.bin。
下载完成后执行sh jdk-6u32-linux-i586-rpm.bin开始安装，将会安装到/usr/java/jdk1.6.0_32目录。

Amoeba的安装

Amoeba下载地址：http://sourceforge.net/projects/amoeba/
下面是安装步骤：

cd /tmp
mkdir /usr/local/amoeba
wget http://softlayer.dl.sourceforge.net/project/amoeba/Amoeba%20for%20mysql/2.x/amoeba-mysql-binary-2.1.0-RC5.tar.gz
tar xzf amoeba-mysql-binary-2.1.0-RC5.tar.gz -C /usr/local/amoeba

配置用户环境变量

vi ~/.bash_profile

设置为：

PATH=$PATH:$HOME/bin:/usr/local/amoeba/bin
JAVA_HOME=/usr/java/jdk1.6.0_32
export JAVA_HOME
export PATH

当即生效：

source ~/.bash_profile

Amoeba for mysql配置

配置Amoeba for mysql的读写分离主要涉及两个文件：
一、/usr/local/amoeba/conf/dbServers.xml
此文件定义由Amoeba代理的数据库如何链接，好比最基础的：主机IP、端口、Amoeba使用的用户名和密码等等。
二、/usr/local/amoeba/conf/amoeba.xml
此文件定义了Amoeba代理的相关配置。

dbServers.xml文件配置

abstractServer配置:

<dbServer name="abstractServer" abstractive="true">
<factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
<property name="manager">${defaultManager}</property>
<property name="sendBufferSize">64</property>
<property name="receiveBufferSize">128</property>
<property name="port">3306</property>
<property name="schema">dbname</property>
<property name="user">root</property>
<property name="password">root</property>
</factoryConfig>
<poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
<property name="maxActive">500</property>
<property name="maxIdle">500</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>

此部分定义真实mysql服务器的端口，数据库名称，mysql用户及密码。
主从数据库定义：

<dbServer name="Master" parent="abstractServer">
<factoryConfig>
<property name="ipAddress">192.168.0.1</property>
</factoryConfig>
</dbServer>
<dbServer name="Slave1" parent="abstractServer">
<factoryConfig>
<property name="ipAddress">192.168.0.2</property>
</factoryConfig>
</dbServer>
<dbServer name="Slave2" parent="abstractServer">
<factoryConfig>
<property name="ipAddress">192.168.0.3</property>
</factoryConfig>
</dbServer>
<dbServer name="virtualSlave" virtual="true">
<poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
<property name="loadbalance">1</property>
<property name="poolNames">Slave1,Slave2</property>
</poolConfig>
</dbServer>

此部分定义主服务器，从服务器，及从服务器链接池。这里只定义数据库地址，它们的用户及密码就是上面的abstractServer里的设置。注意用来链接真实mysql服务器的用户必须拥有远程链接权限。

amoeba.xml配置

amoeba链接验证配置：

<property name="authenticator">
<bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">
<property name="user">root</property>
<property name="password">root</property>
<property name="filter">
<bean class="com.meidusa.amoeba.server.IPAccessController">
<property name="ipFile">${amoeba.home}/conf/access_list.conf</property>
</bean>
</property>
</bean>
</property>

这里定义链接amoeba时用来验证的用户及密码。
读写分离配置：

<property name="defaultPool">Master</property>
<property name="writePool">Master</property>
<property name="readPool">virtualSlave</property>

defaultPool:配置了默认的数据库节点，一些除了SELECTUPDATEINSERTDELETE的语句都会在defaultPool执行。
writePool :配置了数据库写库，一般配为Master，如这里就配置为以前定义的Master数据库。
readPool :配置了数据库读库，一般配为Slave或者Slave组成的数据库池，如这里就配置以前的virtualSlave数据库池。

amoeba启动

启动命令：

amoeba start

此命令之前台的方式启动，会输出启动时的信息，检查没有错误信息后，中断，并后台运行：

amoeba start &

FAQ

一、没法正常链接？
首先根据执行amoeba start输出的信息排除配置文件没有问题，以后确认mysql用户是否有远程链接的权限，而后检查网站的数据库配置文件是否设置正确。
二、如何配置网站数据库链接文件?
默认的端口应该为8066,用户及密码在amoeba.xml里设置。
参考：http://docs.hexnova.com/amoeba/single-dbserver.html
http://docs.hexnova.com/amoeba/rw-splitting.html