Mysql数据库的读写分离
读写分离应用
在大量的数据请求下，单台数据库将无法承担所有读写操作。
解决方法是配置多台数据库服务器以实现主从复制+读写分离。
读写分离的优点
增加冗余
增加了机器的处理能力
对于读操作为主的应用，使用读写分离是最好的场景，因为可以确保写的服务器压力更小，而读又可以接受点时间上的延迟。
读写分离提高性能的原因
物理服务器增加，负荷增加
主从只负责各自的写和读，极大程度的缓解X锁和S锁争用
从库可配置myisam引擎，提升查询性能以及节约系统开销
从库同步主库的数据和主库直接写还是有区别的，通过主库发送来的binlog恢复数据，但是，最重要区别在于主库向从库发送binlog是异步的，从库恢复数据也是异步的
读写分离适用与读远大于写的场景，如果只有一台服务器，当select很多时，update和delete会被这些select访问中的数据堵塞，等待select结束，并发性能不高。
对于写和读比例相近的应用，应该部署双主相互复制
可以在从库启动是增加一些参数来提高其读的性能，例如--skip-innodb、--skip-bdb、--low-priority-updates以及--delay-key-write=ALL。当然这些设置也是需要根据具体业务需求来定得，不一定能用上。
分摊读取。假如我们有1主3从，不考虑上述1中提到的从库单方面设置，假设现在1分钟内有10条写入，150条读取。那么，1主3从相当于共计40条写入，而读取总数没变，因此平均下来每台服务器承担了10条写入和50条读取（主库不承担读取操作）。因此，虽然写入没变，但是读取大大分摊了，提高了系统性能。另外，当读取被分摊后，又间接提高了写入的性能。所以，总体性能提高了，说白了就是拿机器和带宽换性能。MySQL官方文档中有相关演算公式：官方文档 见6.9FAQ之“MySQL复制能够何时和多大程度提高系统性能”
MySQL复制另外一大功能是增加冗余，提高可用性，当一台数据库服务器宕机后能通过调整另外一台从库来以最快的速度恢复服务，因此不能光看性能，也就是说1主1从也是可以的。
读写分离实现方法
双主或多主模型是无须实现读写分离，仅需要负载均衡：haproxy, nginx, lvs, ...
1）基于程序代码内部实现
在代码中根据select、insert进行路由分类，这种方法目前生产环境中应用最广泛。
优点是性能较好，因为在程序代码中实现，不需要增加额外的设备作为硬件开支。
缺点是需要开发人员才能实现，运维人员不能。
2）基于中间代理层实现
代理一般位于客户端和服务器之间，代理服务器接到客户端请求后通过判断后转发到后端数据库
常见的代理服务器：
proxysql、mysqlproxysql、Amoeba
基于ProxySQL的读写分离的实现
参考：
http://seanlook.com/2017/04/10/mysql-proxysql-install-config/
http://seanlook.com/2017/04/17/mysql-proxysql-route-rw_split/
proxysql
http://www.proxysql.com/,
proxysql is a high performance, high availability, protocol aware proxy for mysql and forks (like percona server and maiadb).
https://github.com/sysown/proxysql/releases
master ：192.168.213.251
slave ：192.168.213.252
proxysql：192.168.213.253，是个前端调度器
1.搭建主从复制
2.在主服务器上创建两个账号，一个用于前端调度器连接后端数据库用，一个用于前端调度器监控后端服务器的健康状态用
MariaDB [(none)]> grant all on *.* to dbadmin@‘192.168.%.%‘ identified by ‘centos‘; ##此用户也可以用于客户端访问用
MariaDB [(none)]> grant all on *.* to monitor@‘192.168.%.%‘ identified by ‘monitor‘; ##注意这个账号也要创建，不然调度器连接不到后端主从服务器
3.下载ProxySQL并安装
http://www.proxysql.com/
yum install proxysql-*
4.配置前端调度器proxysql
vim /etc/proxysql.cnf
datadir="/var/lib/proxysql"
admin_variables=
{
admin_credentials="admin:admin"
mysql_ifaces="127.0.0.1:6032;/tmp/proxysql_admin.sock" ##proxysql的一个管理接口，可以连接到这个管理接口上管理proxysql
}
mysql_variables=
{
threads=4
max_connections=2048
default_query_delay=0
default_query_timeout=36000000
have_compress=true
poll_timeout=2000
interfaces="0.0.0.0:3306;/tmp/mysql.sock" ##将端口改为3306，这样客户端就可以用mysql直接连接而不必指定端口号
default_schema="information_schema"
stacksize=1048576
server_version="5.5.30"
connect_timeout_server=3000
monitor_username="monitor" ##设置一个监测后端主机的用户，设置了这个用户就可以连接到后端主机来监控其状态
monitor_password=“monitor” ##设置的密码
monitor_history=600000
monitor_connect_interval=60000
monitor_ping_interval=10000
monitor_read_only_interval=1500
monitor_read_only_timeout=500
ping_interval_server=120000
ping_timeout_server=500
commands_stats=true
sessions_sort=true
connect_retries_on_failure=10
}
mysql_servers =
(
{
address = "192.168.213.251" # no default, required . if port is 0 , address is interpred as a unix socket domain
port = 3306 # no default, required . if port is 0 , address is interpred as a unix socket domain
hostgroup = 0 # no default, required
status = "online" # default: online
weight = 1 # default: 1
compression = 0 # default: 0
},
{
address = "192.168.213.252"
port = 3306
hostgroup = 1
status = "online" # default: online
weight = 1 # default: 1
compression = 0 # default: 0
},
{
address = "xxxxx"
port = 3306
hostgroup = 1
status = "online" # default: online
weight = 1 # default: 1
compression = 0 # default: 0
}
)
mysql_users: ##设置一个用户，用于客户端和proxysql连接后端主机获取数据，客户端连接前端调度器时使用这个用户，调度器连接后端主机时也使用这个用户。
(
{
username = "dbadmin" # no default , required
password = "centos" # default: ‘‘
default_hostgroup = 0 # default: 0
active = 1 # default: 1
}
)
mysql_query_rules: ##设置路由规则
(
｛
rule_id=2
active=1
match_pattern="^SELECT" ##以SELECT为开头的就调度1组
destination_hostgroup=1
apply=1
｝
)
mysql_replication_hostgroups=
(
{
writer_hostgroup=0 ##写调度到0组
reader_hostgroup=1 ##读调度到1组
}
)
service proxysql start
ss -ntl
5.查看
mysql -S /tmp/proxysql_admin.sock -uadmin -padmin ##登录到管理端口上
MySQL [(none)]> show databases；
MySQL [(none)]> show tables;
MySQL [(none)]> select * from mysql_servers; ##查看后端服务器的一些信息
mysql -udbadmin -pcentos -h192.168.213.253 ---客户端访问此调度器
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MySQL connection id is 5
Server version: 5.5.30 (ProxySQL) ##可以看到访问的是proxysql
Copyright (c) 2000, 2017, Oracle, MariaDB Corporation Ab and others.
Type ‘help;‘ or ‘\h‘ for help. Type ‘\c‘ to clear the current input statement.
MySQL [(none)]>SELECT * from hellodb.tbl1; ##发现调度至从服务器上，因为从服务器上不复制hellodb数据库,在这里一定要注意，SELECT要用大写，不然只会往主上调度，识别不了，前面做实验一直失败就是这个原因。
ERROR 1146 (42S02): Table ‘hellodb.tbl1‘ doesn‘t exist
MySQL [(none)]> insert intohellodb.tbl1values(2,‘li‘); #发现可以插入数据，因为写操作调度至主服务器上了
Amoeba实现mysql的读写分离
一、Amoeba 是什么
Amoeba(变形虫)项目，专注分布式数据库 proxy 开发，座落与Client、DB Server(s)之间。
对客户端透明，具有负载均衡、高可用性、sql过滤、读写分离、可路由相关的query到目标数据库、可并发请求多台数据库合并结果。
主要解决：
降低数据切分带来的复杂多数据库结构
提供切分规则并降低 数据切分规则 给应用带来的影响
降低db 与客户端的连接数
读写分离
二、为什么要用Amoeba
目前要实现mysql的主从读写分离，主要有以下几种方案：
1、 通过程序实现，网上很多现成的代码，比较复杂，如果添加从服务器要更改多台服务器的代码。
2、 通过mysql-proxy来实现，由于mysql-proxy的主从读写分离是通过lua脚本来实现，目前lua的脚本的开发跟不上节奏，而写没有完美的现成的脚本，因此导致用于生产环境的话风险比较大，据网上很多人说mysql-proxy的性能不高。
3、 自己开发接口实现，这种方案门槛高，开发成本高，不是一般的小公司能承担得起。
4、 利用阿里巴巴的开源项目Amoeba来实现，具有负载均衡、高可用性、sql过滤、读写分离、可路由相关的query到目标数据库，并且安装配置非常简单
三、Amoeba的安装
先介绍下部署环境：
amoeba:192.168.2.203
masterDB：192.168.2.204
slaveDB：192.168.2.205
以上系统全为centos6.8
Amoeba框架是居于JDK1.5开发的，采用了JDK1.5的特性，所以还需要安装java环境，建议使用javaSE1.5以上的JDK版本
1、安装java环境
先去官网下载：http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
安装
[root@bogon src]# rpm -ivh jdk-8u111-linux-x64.rpm
Preparing... ########################################### [100%]
1:jdk1.8.0_111 ########################################### [100%]
Unpacking JAR files...
tools.jar...
plugin.jar...
javaws.jar...
deploy.jar...
rt.jar...
jsse.jar...
charsets.jar...
localedata.jar...
然后设置java环境变量
[root@bogon src]# vim /etc/profile
#set java environment
JAVA_HOME=/usr/java/jdk1.8.0_111
JRE_HOME=/usr/java/jdk1.8.0_111/jre
CLASS_PATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
export JAVA_HOME JRE_HOME CLASS_PATH PATH
[root@bogon amoeba]# source /etc/profile
测试是否安装成功
[root@bogon src]# java -version
java version "1.8.0_111"
Java(TM) SE Runtime Environment (build 1.8.0_111-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.111-b14, mixed mode)
2、安装Amoeba
可以从https://sourceforge.net/projects/amoeba/下载最新版本的Amoeba，我这里下载的是amoeba-mysql-3.0.5-RC-distribution.zip。
Amoeba安装非常简单，直接解压即可使用，这里将Amoeba解压到/usr/local/amoeba目录下，这样就安装完成了
[root@bogon amoeba]# pwd
/usr/local/amoeba
[root@bogon amoeba]# ll
drwxrwxrwx. 2 root root 4096 7月 5 2013 benchmark
drwxrwxrwx. 2 root root 4096 7月 5 2013 bin
drwxrwxrwx. 2 root root 4096 7月 5 2013 conf
-rwxrwxrwx. 1 root root 728 7月 5 2013 jvm.properties
drwxrwxrwx. 2 root root 4096 7月 5 2013 lib
3、配置Amoeba
Amoeba的配置文件在本环境下位于/usr/local/amoeba/conf目录下。
配置文件比较多，但是仅仅使用读写分离功能，只需配置两个文件即可，分别是dbServers.xml和amoeba.xml，如果需要配置ip访问控制，还需要修改access_list.conf文件，下面首先介绍dbServers.xml
[root@bogon amoeba]# cat conf/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,
If you need to configure multiple dbServer with load balancing that can be simplified by the following configuration:
add attribute with name virtual = "true" in dbServer, but the configuration does not allow the element with name factoryConfig
such as ‘multiPool‘ dbServer
-->
<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>
<!-- mysql port -->
<property name="port">3306</property> #设置Amoeba要连接的mysql数据库的端口，默认是3306
<!-- mysql schema -->
<property name="schema">testdb</property> #设置缺省的数据库，当连接amoeba时，操作表必须显式的指定数据库名，即采用dbname.tablename的方式，不支持 use dbname指定缺省库，因为操作会调度到各个后端dbserver
<!-- mysql user -->
<property name="user">test1</property> #设置amoeba连接后端数据库服务器的账号和密码，因此需要在所有后端数据库上创建该用户，并授权amoeba服务器可连接
<property name="password">111111</property>
</factoryConfig>
<poolConfig class="com.meidusa.toolkit.common.poolable.PoolableObjectPool">
<property name="maxActive">500</property> #最大连接数，默认500
<property name="maxIdle">500</property> #最大空闲连接数
<property name="minIdle">1</property> #最新空闲连接数
<property name="minEvictableIdleTimeMillis">600000</property>
<property name="timeBetweenEvictionRunsMillis">600000</property>
<property name="testOnBorrow">true</property>
<property name="testOnReturn">true</property>
<property name="testWhileIdle">true</property>
</poolConfig>
</dbServer>
<dbServer name="writedb" parent="abstractServer"> #设置一个后端可写的dbServer，这里定义为writedb，这个名字可以任意命名，后面还会用到
<factoryConfig>
<!-- mysql ip -->
<property name="ipAddress">192.168.2.204</property> #设置后端可写dbserver
</factoryConfig>
</dbServer>
<dbServer name="slave" parent="abstractServer"> #设置后端可读dbserver
<factoryConfig>
<!-- mysql ip -->
<property name="ipAddress">192.168.2.205</property>
</factoryConfig>
</dbServer>
<dbServer name="myslave" virtual="true"> #设置定义一个虚拟的dbserver，实际上相当于一个dbserver组，这里将可读的数据库ip统一放到一个组中，将这个组的名字命名为myslave
<poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
<!-- Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
<property name="loadbalance">1</property> #选择调度算法，1表示复制均衡，2表示权重，3表示HA， 这里选择1
<!-- Separated by commas,such as: server1,server2,server1 -->
<property name="poolNames">slave</property> #myslave组成员
</poolConfig>
</dbServer>
</amoeba:dbServers>
另一个配置文件amoeba.xml
[root@bogon amoeba]# cat conf/amoeba.xml
<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE amoeba:configuration SYSTEM "amoeba.dtd">
<amoeba:configuration xmlns:amoeba="http://amoeba.meidusa.com/">
<proxy>
<!-- service class must implements com.meidusa.amoeba.service.Service -->
<service name="Amoeba for Mysql" class="com.meidusa.amoeba.mysql.server.MySQLService">
<!-- port -->
<property name="port">8066</property> #设置amoeba监听的端口，默认是8066
<!-- bind ipAddress --> #下面配置监听的接口，如果不设置，默认监听所以的IP
<!--
<property name="ipAddress">127.0.0.1</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">
# 提供客户端连接amoeba时需要使用这里设定的账号 (这里的账号密码和amoeba连接后端数据库服务器的密码无关)
<property name="user">root</property>
<property name="password">123456</property>
<property name="filter">
<bean class="com.meidusa.toolkit.net.authenticate.server.IPAccessController">
<property name="ipFile">${amoeba.home}/conf/access_list.conf</property>
</bean>
</property>
</bean>
</property>
</service>
<runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext">
<!-- proxy server client process thread size -->
<property name="executeThreadSize">128</property>
<!-- per connection cache prepared statement size -->
<property name="statementCacheSize">500</property>
<!-- default charset -->
<property name="serverCharset">utf8</property>
<!-- query timeout( default: 60 second , TimeUnit:second) -->
<property name="queryTimeout">60</property>
</runtime>
</proxy>
<!--
Each ConnectionManager will start as thread
manager responsible for the Connection IO read , Death Detection
-->
<connectionManagerList>
<connectionManager name="defaultManager" class="com.meidusa.toolkit.net.MultiConnectionManagerWrapper">
<property name="subManagerClassName">com.meidusa.toolkit.net.AuthingableConnectionManager</property>
</connectionManager>
</connectionManagerList>
<!-- default using file loader -->
<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">writedb</property> #设置amoeba默认的池，这里设置为writedb
<property name="writePool">writedb</property> #这两个选项默认是注销掉的，需要取消注释，这里用来指定前面定义好的俩个读写池
<property name="readPool">myslave</property> #
<property name="needParse">true</property>
</queryRouter>
</amoeba:configuration>
4、在masterdb上创建数据库testdb
mysql> create database testdb;
Query OK, 1 row affected (0.08 sec)
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mydb |
| mysql |
| performance_schema |
| test |
| testdb |
+--------------------+
6 rows in set (0.00 sec)
查看slavedb是否复制成功
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mydb |
| mysql |
| performance_schema |
| test |
| testdb |
+--------------------+
6 rows in set (0.00 sec)
分别在masterdb和slavedb上为amoedb授权
mysql> GRANT ALL ON testdb.* TO ‘test1‘@‘192.168.2.203‘ IDENTIFIED BY ‘111111‘;
Query OK, 0 rows affected (0.05 sec)
mysql> flush privileges;
Query OK, 0 rows affected (0.02 sec)
启动amoeba
[root@bogon amoeba]# /usr/local/amoeba/bin/launcher
Error: JAVA_HOME environment variable is not set.
[root@bogon amoeba]# vim /etc/profile^C
[root@bogon amoeba]# source /etc/profile
[root@bogon amoeba]# /usr/local/amoeba/bin/launcher
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=16m; support was removed in 8.0
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=96m; support was removed in 8.0
The stack size specified is too small, Specify at least 228k
Error: Could not create the Java Virtual Machine.
Error: A fatal exception has occurred. Program will exit.
报错:
Error: Could not create the Java Virtual Machine.
Error: A fatal exception has occurred. Program will exit.
从错误文字上看，应该是由于stack size太小，导致JVM启动失败，要如何修改呢？
其实Amoeba已经考虑到这个问题，并将JVM参数配置写在属性文件里。现在，让我们通过该属性文件修改JVM参数。
修改jvm.properties文件JVM_OPTIONS参数。
[root@bogon amoeba]# vim /usr/local/amoeba/jvm.properties
改成：JVM_OPTIONS="-server -Xms1024m -Xmx1024m -Xss256k -XX:PermSize=16m -XX:MaxPermSize=96m"
原为：JVM_OPTIONS="-server -Xms256m -Xmx1024m -Xss196k -XX:PermSize=16m -XX:MaxPermSize=96m"
再次启动
[root@bogon ~]# /usr/local/amoeba/bin/launcher
at org.codehaus.plexus.classworlds.launcher.Launcher.launchStandard(Launcher.java:329)
at org.codehaus.plexus.classworlds.launcher.Launcher.launch(Launcher.java:239)
at org.codehaus.plexus.classworlds.launcher.Launcher.mainWithExitCode(Launcher.java:409)
at org.codehaus.classworlds.Launcher.mainWithExitCode(Launcher.java:127)
at org.codehaus.classworlds.Launcher.main(Launcher.java:110)
Caused by: com.meidusa.toolkit.common.bean.util.InitialisationException: default pool required!,defaultPool=writedb invalid
at com.meidusa.amoeba.route.AbstractQueryRouter.init(AbstractQueryRouter.java:469)
at com.meidusa.amoeba.context.ProxyRuntimeContext.initAllInitialisableBeans(ProxyRuntimeContext.java:337)
... 11 more
2016-10-24 18:46:37 [INFO] Project Name=Amoeba-MySQL, PID=1577 , System shutdown ....
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=16m; support was removed in 8.0
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=96m; support was removed in 8.0
2016-10-24 18:50:19 [INFO] Project Name=Amoeba-MySQL, PID=1602 , starting...
log4j:WARN log4j config load completed from file:/usr/local/amoeba/conf/log4j.xml
2016-10-24 18:50:21,668 INFO context.MysqlRuntimeContext - Amoeba for Mysql current versoin=5.1.45-mysql-amoeba-proxy-3.0.4-BETA
log4j:WARN ip access config load completed from file:/usr/local/amoeba/conf/access_list.conf
2016-10-24 18:50:22,852 INFO net.ServerableConnectionManager - Server listening on 0.0.0.0/0.0.0.0:8066.
查看端口
[root@bogon ~]# netstat -unlpt | grep java
tcp 0 0 :::8066 :::* LISTEN 1602/java
由此可知Amoeba启动正常
5、测试
远程登陆mysql客户端通过指定amoeba配置文件中指定的用户名、密码、和端口以及amoeba服务器ip地址链接mysql数据库
[root@lys2 ~]# mysql -h192.168.2.203 -uroot -p -P8066
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 1364055863
Server version: 5.1.45-mysql-amoeba-proxy-3.0.4-BETA Source distribution
Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type ‘help;‘ or ‘\h‘ for help. Type ‘\c‘ to clear the current input statement.
mysql>
在testdb中创建表test并插入数据
mysql> use testdb;
Database changed
mysql> create table test_table(id int,password varchar(40) not null);
Query OK, 0 rows affected (0.19 sec)
mysql> show tables;
+------------------+
| Tables_in_testdb |
+------------------+
| test_table |
+------------------+
1 row in set (0.02 sec)
mysql> insert into test_table(id,password) values(‘1‘,‘test1‘);
Query OK, 1 row affected (0.04 sec)
mysql> select * from test_table;
+------+----------+
| id | password |
+------+----------+
| 1 | test1 |
+------+----------+
1 row in set (0.02 sec)
分别登陆masterdb和slavedb查看数据
masterdb：
mysql> use testdb;
Database changed
mysql> show tables;
+------------------+
| Tables_in_testdb |
+------------------+
| test_table |
+------------------+
1 row in set (0.00 sec)
mysql> select * from test_table;
+------+----------+
| id | password |
+------+----------+
| 1 | test1 |
+------+----------+
1 row in set (0.03 sec)
slavedb：
mysql> use testdb;
Database changed
mysql> show tables;
+------------------+
| Tables_in_testdb |
+------------------+
| test_table |
+------------------+
1 row in set (0.00 sec)
mysql> select * from test_table;
+------+----------+
| id | password |
+------+----------+
| 1 | test1 |
+------+----------+
1 row in set (0.00 sec)
停掉masterdb，然后在客户端分别执行插入和查询功能
masterdb：
[root@bogon ~]# service mysqld stop
Shutting down MySQL. SUCCESS!
客户端：
mysql> insert into test_table(id,password) values(‘2‘,‘test2‘);
ERROR 1044 (42000): Amoeba could not connect to MySQL server[192.168.2.204:3306],拒绝连接
mysql> select * from test_table;
+------+----------+
| id | password |
+------+----------+
| 1 | test1 |
+------+----------+
1 row in set (0.01 sec)
可以看到，关掉masterdb和写入报错，读正常
开启masterdb上的msyql 关闭slave上的mysql
masterdb：
[root@bogon ~]# service mysqld start
Starting MySQL.. SUCCESS!
slavedb：
[root@localhost ~]# service mysqld stop
Shutting down MySQL. SUCCESS!
客户端再次尝试
mysql> insert into test_table(id,password) values(‘2‘,‘test2‘);
Query OK, 1 row affected (0.19 sec)
mysql> select * from test_table;
ERROR 1044 (42000): poolName=myslave, no valid pools
可以看到插入成功，读取失败
开启slavedb上的mysql，查看数据是否自动同步
slavedb:
[root@localhost ~]# service mysqld start
Starting MySQL... SUCCESS!
客户端：
mysql> select * from test_table;
+------+----------+
| id | password |
+------+----------+
| 1 | test1 |
| 2 | test2 |
+------+----------+
2 rows in set (0.01 sec)
接着客户端：
mysql> insert into test_table(id,password) values(‘3‘,‘test3‘);
Query OK, 1 row affected (0.03 sec)
mysql> select * from test_table;
+------+----------+
| id | password |
+------+----------+
| 1 | test1 |
| 2 | test2 |
| 3 | test3 |
+------+----------+
3 rows in set (0.02 sec)
OK 一切正常，到此全部结束
Amoeba主配置文件($AMOEBA_HOME/conf/amoeba.xml)，用来配置Amoeba服务的基本参数，如Amoeba主机地址、端口、认证方式、用于连接的用户名、密码、线程数、超时时间、其他配置文件的位置等。
数据库服务器配置文件($AMOEBA_HOME/conf/dbServers.xml)，用来存储和配置Amoeba所代理的数据库服务器的信息，如:主机IP、端口、用户名、密码等。
切分规则配置文件($AMOEBA_HOME/conf/rule.xml)，用来配置切分规则。
数据库函数配置文件($AMOEBA_HOME/conf/functionMap.xml)，用来配置数据库函数的处理方法，Amoeba将使用该配置文件中的方法解析数据库函数。
切分规则函数配置文件($AMOEBA_HOME/conf/ruleFunctionMap.xml)，用来配置切分规则中使用的用户自定义函数的处理方法。
访问规则配置文件($AMOEBA_HOME/conf/access_list.conf)，用来授权或禁止某些服务器IP访问Amoeba。
日志规格配置文件($AMOEBA_HOME/conf/log4j.xml)，用来配置Amoeba输出日志的级别和方式。
mysql-proxy实现读写分离
MySQL Proxy最强大的一项功能是实现“读写分离(Read/Write Splitting)”。
基本的原理是让主数据库处理事务性查询，而从数据库处理SELECT查询。
数据库复制被用来把事务性查询导致的变更同步到集群中的从数据库。
当然，主服务器也可以提供查询服务。
使用读写分离最大的作用无非是环境服务器压力。
下面使用MySQL官方提供的数据库代理层产品MySQLProxy搭建读写分离。
MySQLProxy实际上是在客户端请求与MySQLServer之间建立了一个连接池。
所有客户端请求都是发向MySQLProxy，然后经由MySQLProxy进行相应的分析，判断出是读操作还是写操作，分发至对应的MySQLServer上。
对于多节点Slave集群，也可以起做到负载均衡的效果。
MySQL读写分离配置
MySQL环境准备
master 192.168.1.5
slave 192.168.1.6
proxy 192.168.1.2
MySQL：5.5.37
MySQL-proxy：mysql-proxy-0.8.4-linux-rhel5-x86-64bit.tar.gz
创建用户并分配权限
mysql> create user libai identified by ‘libai‘;
mysql> grant all on *.* to libai@‘192.168.1.%‘ identified by ‘libai‘;
在配置了MySQL复制，以上操作在master执行会同步到slave节点。
启用MySQL复制
先关闭并清除之前的复制。
mysql> stop slave;
mysql> reset slave all;
启用新的复制同步。启用之前需要清除日志
mysql> change master to master_host=‘192.168.1.5‘,master_user=‘libai‘,master_password=‘libai‘,master_port=3306,master_log_file=‘mysql-bin.000001‘,master_log_pos=0;
主库
# mysql -h localhost -ulibai -plibai
mysql> create database d;
mysql> use d;
mysql> create table t(i int);
mysql> insert into t values(1);
从库
mysql> select * from t;
+------+
| i |
+------+
| 1 |
启用MySQLProxy代理服务器
代理服务器上创建mysql用户
# groupadd mysql
# useradd -g mysql mysql
解压启动mysql-proxy
# ./mysql-proxy --daemon --log-level=debug --user=mysql --keepalive --log-file=/var/log/mysql-proxy.log --plugins="proxy" --proxy-backend-addresses="192.168.1.5:3306" --proxy-read-only-backend-addresses="192.168.1.6:3306" --proxy-lua-script="/root/soft/mysql-proxy/rw-splitting.lua" --plugins=admin --admin-username="admin" --admin-password="admin" --admin-lua-script="/root/soft/mysql-proxy/lib/mysql-proxy/lua/admin.lua"
其中proxy-backend-addresses是master服务器，proxy-read-only-backend-addresses是slave服务器。可以通过./mysql-proxy --help 查看详细说明。
查看启动后进程
# ps -ef | grep mysql
root 25721 1 0 11:33 ? 00:00:00 /root/soft/mysql-proxy/libexec/mysql-proxy --daemon --log-level=debug --user=mysql --keepalive --log-file=/var/log/mysql-proxy.log --plugins=proxy --proxy-backend-addresses=192.168.1.5:3306 --proxy-read-only-backend-addresses=192.168.1.6:3306 --proxy-lua-script=/root/soft/mysql-proxy/rw-splitting.lua --plugins=admin --admin-username=admin --admin-password=admin --admin-lua-script=/root/soft/mysql-proxy/lib/mysql-proxy/lua/admin.lua
mysql 25722 25721 0 11:33 ? 00:00:00 /root/soft/mysql-proxy/libexec/mysql-proxy --daemon --log-level=debug --user=mysql --keepalive --log-file=/var/log/mysql-proxy.log --plugins=proxy --proxy-backend-addresses=192.168.1.5:3306 --proxy-read-only-backend-addresses=192.168.1.6:3306 --proxy-lua-script=/root/soft/mysql-proxy/rw-splitting.lua --plugins=admin --admin-username=admin --admin-password=admin --admin-lua-script=/root/soft/mysql-proxy/lib/mysql-proxy/lua/admin.lua
4040是proxy端口，4041是admin管理端口
# lsof -i:4040
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
mysql-pro 25722 mysql 10u IPv4 762429 0t0 TCP *:yo-main (LISTEN)
# lsof -i:4041
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
mysql-pro 25722 mysql 11u IPv4 762432 0t0 TCP *:houston (LISTEN)
测试
保证mysqlproxy节点上可执行mysql 。通过复制同步帐号连接proxy
# mysql -h 192.168.1.2 -ulibai -p --port=4040
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| d |
| mysql |
| performance_schema |
| test |
+--------------------+
登录admin查看状态
# mysql -h 192.168.1.2 -u admin -p --port=4041
mysql> select * from backends;
+-------------+------------------+-------+------+------+-------------------+
| backend_ndx | address | state | type | uuid | connected_clients |
+-------------+------------------+-------+------+------+-------------------+
| 1 | 192.168.1.5:3306 | up | rw | NULL | 0 |
| 2 | 192.168.1.6:3306 | up | ro | NULL | 0 |
+-------------+------------------+-------+------+------+-------------------+
2 rows in set (0.00 sec)
可以从以上查询中看到master和slave状态均为up。
1）登录proxy节点，创建数据库dufu，并创建一张表t
mysql> create database dufu;
mysql> show databases;
mysql> use dufu;
mysql> create table t(id int(10),name varchar(20));
mysql> show tables;
创建完数据库及表后，主从节点上应该都可以看到
2）关闭同步，分别在master和slave上插入数据
mysql> slave stop;
master
mysql> insert into t values(1,‘this_is_master‘);
slave
mysql> insert into t values(2,‘this_is_slave‘);
3）proxy上查看结果
mysql> use dufu;
mysql> select * from t;
+------+---------------+
| id | name |
+------+---------------+
| 2 | this_is_slave |
+------+---------------+
1 row in set (0.00 sec)
从结果可以看到数据是从slave上读取的，并没考虑master节点上的数据。
直接从proxy上插入数据
mysql> insert into t values(3,‘this_is_proxy‘);
再次查询
mysql> select * from t;
+------+---------------+
| id | name |
+------+---------------+
| 2 | this_is_slave |
+------+---------------+
结果显示查询数据没有变化，因为proxy上执行insert相当于写入到了master上，而查询的数据是从slave上读取的。
master上查询
mysql> select * from t;
+------+----------------+
| id | name |
+------+----------------+
| 1 | this_is_master |
| 3 | this_is_proxy |
+------+----------------+
启用复制，proxy查询
mysql> select * from t;
+------+----------------+
| id | name |
+------+----------------+
| 2 | this_is_slave |
| 1 | this_is_master |
| 3 | this_is_proxy |
+------+----------------+
说明此时master上的数据同步到了slave，并且在proxy查询到数据是slave数据库的数据。此时，可以看到MySQLProxy实现了分离。
