如何实现数据库读写分离？-么罗博客

之前的教程《[如何处理高并发流量问题](https://blog.gaomeluo.com/archives/chulibingfa/ "如何处理高并发流量问题")》中提到需要对数据库进行优化。

数据库的优化总结为以下三点：
《[mysql数据库如何分表](https://blog.gaomeluo.com/archives/sjkfb/ "mysql数据库如何分表")》
《[如何实现数据库读写分离](https://blog.gaomeluo.com/archives/sjkdxfl/ "如何实现数据库读写分离")》
《[mysql建表并创建索引](https://blog.gaomeluo.com/archives/sjkcjsy/ "mysql建表并创建索引")》

数据库读写分离的基本原理是让主数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操作，这样可以提升数据库的并发负载能力。如下图：

![sjkdxfl01.jpg](https://image.gaomeluo.com/blog/2019/03/sjkdxfl01.jpg)

下面的内容来源网络整理，以供大家参考。

## 一、MySQL的安装与配置
具体的安装过程，自行搜索安装教程，这里不再赘述。

## 二、MySQL主从复制
**场景描述：**

主数据库服务器：192.168.10.130，MySQL已经安装，并且无应用数据。

从数据库服务器：192.168.10.131，MySQL已经安装，并且无应用数据。

### 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’;
```

记录下 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> 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读写分离的安装与配置。

## 三、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可以去下载。

### 1、设置说明

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

### 2、安装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 
```

3、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. 
```

### 4、数据库准备工作

#### （1）安装半同步补丁(建议)（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 |  
+-+ 
```

### 5、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 
```

### 6、客户端连接测试

#### （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;`

### 7、正式环境说明

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

2、Mysql Proxy的rw-splitting.lua脚本在网上有很多版本, 但是最准确无误的版本仍然是源码包中所附带的rw-splitting.lua脚本, 如果有lua脚本编程基础的话, 可以在这个脚本的基础上再进行优化；

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

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

## mysql的读写分离amoeba

原址如下：

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

### 一、关于读写分离

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

### 二、同类产品比较

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

### 三、关于Amoeba

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

### 四、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

###  五、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/"> 
 
                 
 
        <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>        __ ** ##后端数据库默认库**__ 
                         
                </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="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> 
 
                 
                         
                         
                         
                        <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> 
 
         
        <connectionManagerList> 
                         
                </connectionManager> 
 
                         
                </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>
```

### 六、启动Amoeba

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

### 七、日志排错

日志文件在/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的读写分离，起到缓解主数据库服务器的压力，下面是实现这一方案的架构图：

![sjkdxfl02.jpg](https://image.gaomeluo.com/blog/2019/03/sjkdxfl02.jpg)

### 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的读写分离主要涉及两个文件：**

1、/usr/local/amoeba/conf/dbServers.xml
此文件定义由Amoeba代理的数据库如何连接，比如最基础的：主机IP、端口、Amoeba使用的用户名和密码等等。

2、/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：
**1、无法正常连接？**
首先根据执行amoeba start输出的信息排除配置文件没有问题，之后确认mysql用户是否有远程连接的权限，然后检查网站的数据库配置文件是否设置正确。

**2、如何配置网站数据库连接文件?**
默认的端口应该为8066,用户及密码在amoeba.xml里设置。

如何实现数据库读写分离？

评论已关闭

最新文章

标签云

最近回复