澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

MySQL读写抽离Amoeba简要介绍,6主从复制及读写抽

2019-12-01 作者:数据库网络   |   浏览(178)

MySQL读写分离是在主从复制的基础上进一步通过在master上执行写操作,在slave上执行读操作来实现的。通过主从复制,master上的数据改动能够同步到slave上,从而保持了数据的一致性。实现数据的读写分离能带来的好处有:

MySQL读写分离Amoeba简介

MySQL5.6主从复制及读写分离的实现

MySQL 5.6 基于GTID的主从复制及使用amoeba配置实现读写分离**

  • 增加物理服务器,提升机器处理能力,也就是拿硬件换性能。

  • 主从只负责各自的读和写,极大程度缓解X锁和S锁争用。

  • slave可以配置myIasm引擎,提升查询性能以及节约系统开销。

  • master直接写是并发的,slave通过主库发送来的binlog恢复数据是异步。

  • slave可以单独设置一些参数来提升其读的性能。

  • 增加冗余,提高可用性。

Amoeba介绍:

amoeba 简介

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

Amoeba优点:

1.降低费用,简单易用
2.提高系统整体可用性
3.易于扩展处理能力和系统规模
4.可以直接实现读写分离及负载均衡的效果,而不用修改代码

Amoeba 缺点:

1.不支持事务与存储过程
2.暂不支持分库分表,amoeba目前只做到分数据库实例
3.不适合从amoeba导入数据的场景或者对大数据量查询的query并不合适(比如一次请求返回10w以上的甚至更多的数据场合)

常见的实现数据库读写分离的方案大致有两种:应用层,代理层

阿里巴巴的Amoeba(变形虫)项目,专注 数据库proxy开发。座落与Client、DB Server(s)之间。对客户端透明。具有负载均衡、高可用性、sql过滤、读写分离、可路由相关的query到目标数据库、可并发请求多台数据库合并结果。

MySQL GTID

Mysql 5.6的新特性之一,加入了全局事务性ID(GTID:GlobalTransactions Identifier)来强化数据库的主备一致性,故障恢复,以及容错能力;也使得复制功能的配置、监控及管理变得更加易于实现,且更加健壮

在应用层也就是在代码中进行操作,通过对数据库操作类型的不同手动指定数据源,可以通过AOP的方式进行实现,不过对于一个已经搭建起来并正在运行的系统来说,这个方案应该比较复杂。

架构图:

MySQL主从配置

环境介绍:

[root@master~]# 192.168.17.15
[root@slave~]# 192.168.17.32

安装mysql服务器在俩台主机上

tar xfmysql-5.6.13-linux-glibc2.5-x86_64.tar.gz -C /usr/local
cd /usr/local/
ln -sv mysql-5.6.13-linux-glibc2.5-x86_64/mysql
cd mysql
chown –R root.msyql *
cp support-files/mysql.server/etc/init.d/mysqld
chmod  x /etc/init.d/mysqld
chkconfig --add mysqld
chkconfig mysqld on
echo"PATH=/usr/local/mysql/bin:$PATH" > /etc/profile
. /etc/profile
cat /etc/my.cnf | egrep -v "^#"> /root/my.cnf
cp /root/my.cnf /etc/

主/etc/my.cnf的配置文件总汇

[client]
port            = 3306
socket          = /tmp/mysql.sock
[mysqld]
port            = 3306
socket          = /tmp/mysql.sock
skip-external-locking
key_buffer_size = 256M
max_allowed_packet = 1M
table_open_cache = 256
sort_buffer_size = 1M
read_buffer_size = 1M
read_rnd_buffer_size = 4M
myisam_sort_buffer_size = 64M
thread_cache_size = 8
query_cache_size= 16M
thread_concurrency = 8
datadir=/mydata/data
innodb_file_per_table = 1
log-bin=/binlog/mysql-bin
binlog_format=row
log-slave-updates=true
gtid-mode=on
enforce-gtid-consistency=true
master-info-repository=TABLE
relay-log-info-repository=TABLE
sync-master-info=1
slave-parallel-workers=2
binlog-checksum=CRC32
master-verify-checksum=1
slave-sql-verify-checksum=1
binlog-rows-query-log_events=1
report-port=3306
report-host=192.168.17.32
server-id       = 20
[mysqldump]
quick
max_allowed_packet = 16M
[mysql]
no-auto-rehash
[myisamchk]
key_buffer_size = 128M
sort_buffer_size = 128M
read_buffer = 2M
write_buffer = 2M
[mysqlhotcopy]
interactive-timeout

初始化mysql并启动

chown -R mysql.mysql  /mydata/data/
chown -R mysql.mysql  /binlog/
./scripts/mysql_install_db --user=mysql--datadir=/mydata/data/
service mysqld start

slave服务器安装mysql与master一样 ,但在slave服务器的/etc/my.cnf配置文件中有俩个参数需要更改一下与master服务器不同

server-id  =  20 
report-host = 192.168.17.32 

在master服务器上创建slave复制用户并测试连接

mysql> grant replication client,replication slave on *.* to 'slave'@'192.168.%.%' identified by 'budongshu';
mysql> flush privileges;
[root@slave mysql]# mysql -uslave-pbudongshu -h 192.168.17.15                                  #成功连接

启动从节点的复制线程

[root@slave mysql]# mysql
mysql> change master tomaster_host='192.168.17.15',
   -> master_user='slave',
   -> master_password='budongshu',
   -> master_auto_position=1;
mysql> start slave;
mysql> show slave status G
        Slave_IO_Running: Yes
Slave_SQL_Running:Yes

yes代表启动成功,必须要俩个全部都是yes

MySQL读写抽离Amoeba简要介绍,6主从复制及读写抽离的兑现。在master服务器创建数据库查看slave服务器是否更新

[root@master ~]# mysql -e 'create databasebds1'
[root@slave mysql]# mysql -e 'showdatabases'
 -------------------- 
| Database           |
 -------------------- 
| information_schema |
| bds                |
| bds1               |                                                                        #slave服务器同步正常
| mysql              |
| performance_schema |
| test               |
 -------------------- 
mysql> show processlist;                                                                       #查看gtid进程
 ---- ------------- ----------- ------ --------- --------- ----------------------------------------------------------------------------- ------------------ 
| Id | User        | Host      | db  | Command | Time    | State                                                                      | Info             |
 ---- ------------- ----------- ------ --------- --------- ----------------------------------------------------------------------------- ------------------ 
|  4| system user |           | NULL |Connect |     395 | Waiting for master tosend event                                           | NULL             |
|  5| system user |           | NULL |Connect |     225 | Slave has read allrelay log; waiting for the slave I/O thread to update it | NULL             |
|  6| system user |           | NULL |Connect | -252924 | Waiting for an event from Coordinator                                       | NULL             |
|  7| system user |           | NULL |Connect | -253320 | Waiting for an event from Coordinator                                       | NULL             |
|  9| root        | localhost | NULL |Query   |       0 | init                                                                        |show processlist |
 ---- ------------- ----------- ------ --------- --------- ----------------------------------------------------------------------------- ------------------ 

另外一种实现方式是通过数据库代理层,代理对应用层呢个是透明的,所有的读写分离操作由代理层来完成,好处就是对于开发应用层来说是透明的,不需要管理数据源,缺点在于应用原来直接访问数据库现在变成了通过代理访问数据库,性能上肯定会有影响,不过如果代理层实现的很优秀的话这个影响应该不大。

Amoeba除了读写分离,还可以进行负载均衡、高可用性、sql过滤。

读写分离配置

基于前面做的mysql主从架构,然后在前端加一台服务器,用于实现mysql的读分离,

安装jdk (bin结尾的包,rpm包都可以,可以去oracle官网下载)

[root@amoeba ~]# chmod  x  jdk-6u31-linux-x64-rpm.bin
[root@amoeba ~]#. /jdk-6u31-linux-x64-rpm.bin
[root@amoeba ~]# vim /etc/profile.d/java.sh
export JAVA_HOME=/usr/java/latest
export PATH=$JAVA_HOME/bin:$PATH
[root@amoeba ~]#. /etc/profile.d/java.sh
[root@amoeba ~]# java -version
java version "1.6.0_31"
Java(TM) SE Runtime Environment (build1.6.0_31-b04)
Java HotSpot(TM) 64-Bit Server VM (build20.6-b01, mixed mode)

安装amoeba

[root@amoeba ~]# mkdir /usr/local/amoeba
[root@amoeba ~]# tar xf  amoeba-mysql-binary-2.2.0.tar.gz -C /usr/local/
[root@amoeba ~]# vi/etc/profile.d/amoeba.sh
export AMOEBA_HOME=/usr/local/amoeba
export PATH=$AMOEBA_HOME/bin:$PATH
[root@amoeba ~]# .  /etc/profile.d/amoeba.sh
[root@amoeba ~]# amoeba                                                                          #出现下边信息代表安装成功
amoeba start|stop

授权MySQL用户,用于实现前端amoeba连接

mysql> grant all on *.* to'amoeba'@'192.168.%.%' identified by 'amoebapass';
mysql> flush privileges;

配置amoeba

[root@amoeba ~]# cd /usr/local/amoeba/conf/
amoeba.xml                                                                                       #定义管理信息与读写分离
dbServers.xml                                                                                    #定义后端服务器的配置

配置文件dbServers.xml介绍

[root@amoeba conf]# vi dbServers.xml
<?xml version="1.0"encoding="gbk"?>
<!DOCTYPE amoeba:dbServers SYSTEM"dbserver.dtd">
<amoeba:dbServersxmlns:amoeba="http://amoeba.meidusa.com/">
                <!--
                        Each dbServer needs tobe configured into a Pool,
                        If you need toconfigure multiple dbServer with load balancing that can be simplified by thefollowing configuration:
                         add attribute with name virtual ="true" in dbServer, but the configuration does not allow the elementwith name factoryConfig
                         such as 'multiPool'dbServer
                -->
       <dbServer name="abstractServer" abstractive="true">
                <factoryConfigclass="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
                        <propertyname="manager">${defaultManager}</property>
                        <propertyname="sendBufferSize">64</property>
                        <propertyname="receiveBufferSize">128</property>
                        <!-- mysql port-->
                        <propertyname="port">3306</property>                    #连接后端mysql服务器的端口
                        <!-- mysql schema-->
                       <propertyname="schema">test</property>                   #连接后端mysql服务器的默认库
                        <!-- mysql user-->
                        <propertyname="user">amoeba</property>                  #连接后端mysql服务器的用户名
                        <!--  mysql password -->                                #把password最后的注释(-->)这个符号去掉跟上边一样
                        <propertyname="password">amoebapass</propert>           #连接后端mysql服务器的密码
                </factoryConfig>
                <poolConfigclass="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
                        <propertyname="maxActive">500</property>
                        <propertyname="maxIdle">500</property>
                        <propertyname="minIdle">10</property>
                        <propertyname="minEvictableIdleTimeMillis">600000</property>
                        <propertyname="timeBetweenEvictionRunsMillis">600000</property>
                        <propertyname="testOnBorrow">true</property>
                        <propertyname="testOnReturn">true</property>
                        <propertyname="testWhileIdle">true</property>
                </poolConfig>
       </dbServer>
       <dbServer name="master" parent="abstractServer">                     #定义master服务器的节点 name可以自定义
                <factoryConfig>
                        <!-- mysql ip -->
                        <propertyname="ipAddress">192.168.17.15</property>  #定义master服务器的IP地址
                </factoryConfig>
       </dbServer>
       <dbServer name="slave" parent="abstractServer">                      #定义slave服务器的节点
                <factoryConfig>
                        <!-- mysql ip -->
                        <propertyname="ipAddress">192.168.17.32</property>
                </factoryConfig>
        </dbServer>
       <dbServer name="multiPool" virtual="true">
                <poolConfigclass="com.meidusa.amoeba.server.MultipleServerPool">
                        <!-- Load balancingstrategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->    #负载均衡算法
                        <propertyname="loadbalance">1</property>                               #定义选择哪一种算法
                        <!-- Separated bycommas,such as: server1,server2,server1 -->           #定义数据库池,用于实现负载均衡,“slave“为自定义的数据库节点,可以写多个用”,”隔开
                        <property name="poolNames">slave</property
                </poolConfig>
       </dbServer>
</amoeba:dbServers>

配置文件amoeba.xml 介绍

[root@amoeba conf]# vi amoeba.xml
<?xml version="1.0"encoding="gbk"?>
<!DOCTYPE amoeba:configuration SYSTEM"amoeba.dtd">
<amoeba:configurationxmlns:amoeba="http://amoeba.meidusa.com/">
       <proxy>
                <!-- service class mustimplements com.meidusa.amoeba.service.Service -->
               <servicename="Amoeba for Mysql"class="com.meidusa.amoeba.net.ServerableConnectionManager">
                        <!-- port -->
                        <propertyname="port">3306</property>                        #定义amoeba代理服务器对外监听的端口
                        <!-- bind ipAddress-->
                        <!--
                        <propertyname="ipAddress">192.168.17.11</property>          #定义amoeba代理服务器对外连接的监听ip      
                         -->
                        <propertyname="manager">${clientConnectioneManager}</property>
                        <propertyname="connectionFactory">
                                <beanclass="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory">
                                       <property name="sendBufferSize">128</property>
                                       <property name="receiveBufferSize">64</property>
                                </bean>
                        </property>
                        <propertyname="authenticator">
                                <beanclass="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">   #定义客户端使用的用户名和密码
                                       <property name="user">admin</property>                               
                                       <property name="password">password</property>
                                       <property name="filter">
                                               <beanclass="com.meidusa.amoeba.server.IPAccessController">
                                                       <propertyname="ipFile">${amoeba.home}/conf/access_list.conf</property>
                                               </bean>
                                       </property>
                                </bean>
                        </property>
                </service>
                <!-- server class mustimplements com.meidusa.amoeba.service.Service -->
                <service name="AmoebaMonitor Server"class="com.meidusa.amoeba.monitor.MonitorServer">
                        <!-- port -->
                        <!--  default value: random number
                        <propertyname="port">9066</property>
                        -->
                        <!-- bind ipAddress-->
                        <propertyname="ipAddress">127.0.0.1</property>
                        <propertyname="daemon">true</property>
                        <propertyname="manager">${clientConnectioneManager}</property>
                        <propertyname="connectionFactory">
                                <beanclass="com.meidusa.amoeba.monitor.net.MonitorClientConnectionFactory"></bean>
                        </property>
                </service>
                <runtimeclass="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext">
                       <!-- proxy servernet IO Read thread size -->
                        <propertyname="readThreadPoolSize">20</property>
                        <!-- proxy serverclient process thread size -->
                        <propertyname="clientSideThreadPoolSize">30</property>
                        <!-- mysql serverdata packet process thread size -->
                        <propertyname="serverSideThreadPoolSize">30</property>
                        <!-- per connectioncache prepared statement size  -->
                        <propertyname="statementCacheSize">500</property>
                        <!-- query timeout(default: 60 second , TimeUnit:second) -->
                        <propertyname="queryTimeout">60</property>
                </runtime>
       </proxy>
       <!--
                Each ConnectionManager willstart as thread
                manager responsible for theConnection IO read , Death Detection
       -->
       <connectionManagerList>
                <connectionManagername="clientConnectioneManager"class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper">
                        <propertyname="subManagerClassName">com.meidusa.amoeba.net.ConnectionManager</property>
                        <!--
                          default value isavaliable Processors
                        <propertyname="processors">5</property>
                         -->
                </connectionManager>
                <connectionManagername="defaultManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper">
                        <propertyname="subManagerClassName">com.meidusa.amoeba.net.AuthingableConnectionManager</property>
                        <!--
                          default value is avaliableProcessors
                        <propertyname="processors">5</property>
                         -->
                </connectionManager>
       </connectionManagerList>
                <!-- default using fileloader -->
       <dbServerLoader class="com.meidusa.amoeba.context.DBServerConfigFileLoader">
                <propertyname="configFile">${amoeba.home}/conf/dbServers.xml</property>
       </dbServerLoader>
       <queryRouterclass="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">
                <propertyname="ruleLoader">
                        <beanclass="com.meidusa.amoeba.route.TableRuleFileLoader">
                                <propertyname="ruleFile">${amoeba.home}/conf/rule.xml</property>
                                <propertyname="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property>
                        </bean>
                </property>
                <propertyname="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property>
                <propertyname="LRUMapSize">1500</property>
                <propertyname="defaultPool">master</property>      #把 <!--   -->注释去掉使其配置生效, 定义默认池,默认会在此服务器上执行
                <property name="writePool">master</property>       #定义只写服务器    
                <propertyname="readPool">slave</property>          #定义只读服务器,也可以在dbServer.xml中定义数据池的名称,实现负载均衡                                      

                <propertyname="needParse">true</property>                            
       </queryRouter>
</amoeba:configuration>

启动amoeba服务并测试

[root@amoeba conf]# amoeba start &                                                #后台启动amoeba
[root@amoeba conf]# ss -tunlp | grep 3306                                         #启动正常
tcp   LISTEN     0      128                   :::3306                 :::*      users:(("java",1796,52))

连接amoeba代理服务器,执行插入和查询操作,分别在后端俩台服务器进行抓包,查看是否实现读写分离

mysql> create database bds2;
mysql> use bds2
mysql> create table tb2 (id int ) ;
mysql> select * from tb2;

通过代理层实现数据库读写分离又有两种方案可供选择,其一是使用MySQL-Proxy,另一种是使用Amoeba。最开始找到的实现方案是基于MySQL-Proxy的,由于它没有配置文件,所要完成的工作需要由Lua脚本来实现,这对于一个Lua门外汉来说压力不小。后来找到的Amoeba实现起来很简单,只需要简单地配置就能实现数据库的读写分离,所以这里记录我通过使用Amoeba来实现数据库读写分离的过程。

Amoeba的安装和配置

tcpdump抓包查看检测

[root@master ~]# tcpdump -i eth0 -s0 -nn -A tcp dst port 3306 and dst  host192.168.17.15

13:25:46.488469 IP 192.168.17.11.39787 >192.168.17.15.3306: Flags [P.], seq 171:202, ack 444, win 490, options[nop,nop,TS val 8050703 ecr 15047099], length 31
E..S4  @.@.c1.........k....z..y.............
.z...........create table tb2 (id int )                                     ###写请求在master服务器上执行
13:25:46.523028 IP 192.168.17.32.41112 >192.168.17.15.3306: Flags [.], ack 1661, win 1117, options [nop,nop,TS val41437531 ecr 15058573], length 0
E..4..@.@.y{... ........M.$....4...].   .....
.xI[....
13:25:46.523050 IP 192.168.17.11.39787 >192.168.17.15.3306: Flags [.], ack 455, win 490, options [nop,nop,TS val 8050737ecr 15058574], length 0
E..44
@.@.cO.........k....z..y......Q......
.z.1....

[root@slave ~]# tcpdump -i eth0 -s0 -nn -Atcp dst  port 3306 and dst  host 192.168.17.32

15:01:20.243577 IP 192.168.17.11.54071 >192.168.17.32.3306: Flags [.], ack 196, win 457, options [nop,nop,TS val8129871 ecr 41516665], length 0
E..4@.@.@.V}....... .7..}.      ....i...........
O.y~y
15:01:20.246139 IP 192.168.17.11.54071 >192.168.17.32.3306: Flags [P.], seq 133:155, ack 196, win 457, options[nop,nop,TS val 8129874 ecr 41516665], length 22
E..J@.@.@.Vf....... .7..}.      ....i...........
R.y~y.....select * from tb2                                                 ###读请求在slave服务器上执行
15:01:20.287625 IP 192.168.17.11.54071 >192.168.17.32.3306: Flags [.], ack 259, win 457, options [nop,nop,TS val8129915 ecr 41516669], length 0
E..4@.@.@.V{....... .7..}.      ..........}.....
{.y~}

由上图可知抓包实现了读写分离的效果

Amoeba简介:

Amoeba需要mysql-server支持,Amoeba服务器端需要安装Mysql-server,并且最好不与其他数据库服务器在一起

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

Amoeba是Java编写的,运行需要JDK环境,可以通过#echo $JAVA_HOME看是否安装配置了JDK,如果没有,则

Amoeba使用:

安装JKD

一、准备工作

MySQL读写抽离Amoeba简要介绍,6主从复制及读写抽离的兑现。①.安装依赖包

  1. amoeba使用java编写,所以运行amoeba的运行环境要安装好java环境,并配置好环境变量,jdk版本要在1.5以上,因为amoeba就是用jdk1.5编写的;我的服务器java版本为1.7。
  2. amoeba是在主从同步的基础上工作的,所以要先配置好MySQL的主从同步功能,我在另一篇日志中记录了我实现Mysql主从同步的过程,可以参考:MySQL主从复制(Master-Slave)实践
  3.   amoeba服务器 :虚拟机 ip:182.92.172.80   amoeba版本3.0.5-RC   mysql版本5. 5.32   Java环境1.7.0_60    操作系统linux

        master服务器    :虚拟机 ip:182.92.172.80  mysql版本5. 5.32   操作系统centos6.5 (和amoeba在同一个服务器上,因为我只用了两个服务器)

        slave服务器       :虚拟机 ip:123.57.44.85   mysql版本5.5.39   操作系统centos6.5 

yum -y install glibc*

二、下载安装amoeba

②.安装JDK

下载地址:

下载:jdk-6u35-linux-i586.bin 或 jdk-6u45-linux-x64.bin

安装:把zip安装包解压到自己指定的服务器路径上就可以了,我把它放在了/usr/local/amoeba/amoeba-mysql-3.0.5-RC里面,解压后的文件结构如下图:

chmod 700 jdk-6u35-linux-i586.bin

图片 1

 

chmod 700 jdk-6u45-linux-x64.bin

三、配置amoeba

./jdk-6u35-linux-i586.bin

Amoeba基础配置介绍:

mv jdk1.6.0_35 jdk

想象Amoeba作为数据库代理层,它一定会和很多数据库保持通信,因此它必须知道由它代理的数据库如何连接,比如最基础的:主机IP、端口、Amoeba使用的用户名和密码等等。这些信息存储在$AMOEBA_HOME/conf/dbServers.xml中。

mv jdk /usr/local/

Amoeba为了完成数据切分提供了完善的切分规则配置,为了了解如何分片数据、如何将数据库返回的数据整合,它必须知道切分规则。与切分规则相关的信息存储在$AMOEBA_HOME/conf/rule.xml中。

③.修改JDK的环境变量

当我们书写SQL来操作数据库的时候,常常会用到很多不同的数据库函数,比如:UNIX_TIMESTAMP()、SYSDATE()等等。这些函数如何被Amoeba解析呢?$AMOEBA_HOME/conf/functionMap.xml描述了函数名和函数处理的关系。

vi /etc/profile.d/java.sh

对$AMOEBA_HOME/conf/rule.xml进行配置时,会用到一些我们自己定义的函数,比如我们需要对用户ID求HASH值来切分数据,这些函数在$AMOEBA_HOME/conf/ruleFunctionMap.xml中定义。

JAVA_HOME="/usr/local/jdk"

Amoeba可以制定一些可访问以及拒绝访问的主机IP地址,这部分配置在$AMOEBA_HOME/conf/access_list.conf中

CLASS_PATH="$JAVA_HOME/lib:$JAVA_HOME/jre/lib"

Amoeba允许用户配置输出日志级别以及方式,配置方法使用log4j的文件格式,文件是$AMOEBA_HOME/conf/log4j.xml。

PATH="$PATH:$JAVA_HOME/bin"

在开始配置amoeba配置文件之前我们需要先了解为什么要做这些配置工作。

export JAVA_HOME

第一,如上第一条所述,Amoeba是通过代理MySQL服务来实现数据库的读写分离的,它必须要知道如何连接到需要被代理的数据库,因此需要被代理的数据库需要创建一个访问用户给amoeba,这样amoeba才能连接到数据库上。

source /etc/profile.d/java.sh

第二,amobea把对客户端也就是应用层是透明的,不管amoeba如何实现的读写分离,它既然把数据库全都给代理了,那它就要为客户端提供一个类似原来mysql那样的连接,客户端就把当它是mysql,它其实是一个虚拟的mysql,对外提供mysql协议,客户端连接amoeba就象连接mysql一样,因此amoeba要为客户端提供一个可供连接的用户账号。

#测试安装成功

第三,amoeba内部是实现了多数据库的负载均衡、读写分离、可切片的,所以这部分的配置是它功能上的核心配置。

java -version

下面就正式开始配置amoeba

安装Amoeba

  1. 所有数据库创建amoeba访问的用户:

    mysql>grant all on . to 'amoeba'@'182.92.172.80' identified by '123456' #创建用户并授权

    mysql>flush privileges; #刷新权限

下载:amoeba-mysql-binary-2.2.0.tar.gz

  为了方便统一管理就把所有数据库创建的用户名和密码保持一致了

①.安装Amoeba

  2.配置conf文件

mkdir /usr/local/amoeba

在amoeba安装目录的conf文件夹下找到dbServer.xml和amoeba.xml文件,这两个文件是需要我们配置的

tar -zxvf amoeba-mysql-binary-2.2.0.tar.gz -C /usr/local/amoeba

我的dbServer.xml文件配置如下:

cd /usr/local/amoeba/

 1 <?xml version="1.0" encoding="gbk"?>
 2 
 3 <!DOCTYPE amoeba:dbServers SYSTEM "dbserver.dtd">
 4 <amoeba:dbServers xmlns:amoeba="http://amoeba.meidusa.com/">
 5 
 6         <!-- 
 7             Each dbServer needs to be configured into a Pool,
 8             If you need to configure multiple dbServer with load balancing that can be simplified by the following configuration:
 9              add attribute with name virtual = "true" in dbServer, but the configuration does not allow the element with name factoryConfig
10              such as 'multiPool' dbServer   
11         -->
12         
13     <dbServer name="abstractServer" abstractive="true">
14         <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
15             <property name="connectionManager">${defaultManager}</property>
16             <property name="sendBufferSize">64</property>
17             <property name="receiveBufferSize">128</property>
18                 
19             <!-- mysql port -->
20             <!--<property name="port">3306</property>-->
21             
22             <!-- mysql schema -->
23             <property name="schema">yj_platform</property>
24             
25             <!-- mysql user -->
26             <property name="user">amoeba</property>
27             
28             <property name="password">123456</property>
29         </factoryConfig>
30 
31         <poolConfig class="com.meidusa.toolkit.common.poolable.PoolableObjectPool">
32             <property name="maxActive">500</property>
33             <property name="maxIdle">500</property>
34             <property name="minIdle">1</property>
35             <property name="minEvictableIdleTimeMillis">600000</property>
36             <property name="timeBetweenEvictionRunsMillis">600000</property>
37             <property name="testOnBorrow">true</property>
38             <property name="testOnReturn">true</property>
39             <property name="testWhileIdle">true</property>
40         </poolConfig>
41     </dbServer>
42 
43     <dbServer name="master"  parent="abstractServer">
44         <factoryConfig>
45             <!-- mysql ip -->
46             <property name="ipAddress">182.92.172.96</property>
47             <!-- mysql port -->
48             <property name="port">3306</property>
49         </factoryConfig>
50     </dbServer>
51     
52     <dbServer name="slave1"  parent="abstractServer">
53         <factoryConfig>
54             <!-- mysql ip -->
55             <property name="ipAddress">123.57.44.78</property>
56             <!-- mysql port -->
57             <property name="port">13306</property>
58         </factoryConfig>
59     </dbServer>
60     
61 <!--    <dbServer name="multiPool" virtual="true">
62         <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
63             #Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA
64             <property name="loadbalance">1</property>
65             
66             #Separated by commas,such as: server1,server2,server1
67             <property name="poolNames">slave1,slave2</property>
68         </poolConfig>
69     </dbServer>
70 -->        
71 </amoeba:dbServers>

②.配置amoeba.xml和dbServer.xml

 

vi conf/amoeba.xml

需要我们关注的元素用标红字体显示出来了,在这里是指几个dbServer元素,需要手动修改的部分用黄色背景表示出来。

8066

第一个dbServer元素其abstractive="true"属性表示这个一个抽象元素可以被其他dbServer元素扩展,类似于java里面的抽象类和类的继承之间的关系。这个dbServer里面配置amoeba连接它所代理的mysql数据库的连接信息,因为之前已经说过为了方便管理把每个数据库为amoeba访问创建的用户都统一了账号,在这里我把端口信息给注释掉了,因为我的slave数据库端口用的不是默认的3306,这种和ip,端口不一样的信息就没办法配置在通用的抽象dbServer里面了。

# 默认端口是8066

第二个dbServer取名为"maser",其parent="abstractServer"表示拓展了上面的抽象dbServer,在这里设置的是amoeba连接数据库具体的信息,因为每个数据库的ip肯定是不同的。

# 修改连接amoeba接口的认证信息

同样第三个dbServer取名为“slave”,连接信息是slave服务器。

172.18.109.213

在下面被我注释掉的第四个dbServer其name="multiPool" virtual="true"属性表示这是一个对多服务器池,这个配置使得amoeba可以把多个读数据库管理成一个读池,把多个写数据库管理成写池,在每个池中amoeba就能够实现负载均衡。由于我的主从同步只设置了一主一从,并不涉及到多个读数据库组成池的情况,所以我就把这个配置注释掉了。

#访问amoeba的ip地址,amoeba服务器的地址

接下来配置amoeba.xml文件,同样放上我的配置文件:

... ...

 1 <?xml version="1.0" encoding="gbk"?>
 2 
 3 <!DOCTYPE amoeba:configuration SYSTEM "amoeba.dtd">
 4 <amoeba:configuration xmlns:amoeba="http://amoeba.meidusa.com/">
 5 
 6     <proxy>
 7     
 8         <!-- service class must implements com.meidusa.amoeba.service.Service -->
 9         <service name="Amoeba for Mysql" class="com.meidusa.amoeba.mysql.server.MySQLService">
10             <!-- port -->
11             <property name="port">8066</property>
12             
13             <!-- bind ipAddress -->
14             
15             <!--<property name="ipAddress">127.0.0.1</property>-->
16             
17             
18             <property name="connectionFactory">
19                 <bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory">
20                     <property name="sendBufferSize">128</property>
21                     <property name="receiveBufferSize">64</property>
22                 </bean>
23             </property>
24             
25             <property name="authenticateProvider">
26                 <bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">
27                     
28                     <property name="user">amoeba</property>
29                     
30                     <property name="password">password</property>
31                     
32                     <property name="filter">
33                         <bean class="com.meidusa.toolkit.net.authenticate.server.IPAccessController">
34                             <property name="ipFile">${amoeba.home}/conf/access_list.conf</property>
35                         </bean>
36                     </property>
37                 </bean>
38             </property>
39             
40         </service>
41         
42         <runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext">
43             
44             <!-- proxy server client process thread size -->
45             <property name="executeThreadSize">128</property>
46             
47             <!-- per connection cache prepared statement size  -->
48             <property name="statementCacheSize">500</property>
49             
50             <!-- default charset -->
51             <property name="serverCharset">utf8</property>
52             
53             <!-- query timeout( default: 60 second , TimeUnit:second) -->
54             <property name="queryTimeout">60</property>
55         </runtime>
56         
57     </proxy>
58     
59     <!-- 
60         Each ConnectionManager will start as thread
61         manager responsible for the Connection IO read , Death Detection
62     -->
63     <connectionManagerList>
64         <connectionManager name="defaultManager" class="com.meidusa.toolkit.net.MultiConnectionManagerWrapper">
65             <property name="subManagerClassName">com.meidusa.toolkit.net.AuthingableConnectionManager</property>
66         </connectionManager>
67     </connectionManagerList>
68     
69         <!-- default using file loader -->
70     <dbServerLoader class="com.meidusa.amoeba.context.DBServerConfigFileLoader">
71         <property name="configFile">${amoeba.home}/conf/dbServers.xml</property>
72     </dbServerLoader>
73     
74     <queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">
75         <property name="ruleLoader">
76             <bean class="com.meidusa.amoeba.route.TableRuleFileLoader">
77                 <property name="ruleFile">${amoeba.home}/conf/rule.xml</property>
78                 <property name="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property>
79             </bean>
80         </property>
81         <property name="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property>
82         <property name="LRUMapSize">1500</property>
83         <property name="defaultPool">slave1</property>
84         <property name="writePool">master</property>
85         <property name="readPool">slave1</property>
86         <property name="needParse">true</property>
87     </queryRouter>
88 </amoeba:configuration>

amoeba

 

# 客户端连接amoeba的代理使用的用户

amoeba.xml文件中需要配置的地方也不多,首先要配置的是service标签,其中需要配置的地方有三个port,user,password。这里的端口,用户名和密码其实就是为了虚拟出一个mysql链接做准备的(非真实,amoeba服务器可以不安装真实的mysql数据库),端口默认的事8066,可以修改但是不要跟现有的端口冲突,用户名和密码是客户端连接amoeba虚拟出来的mysql连接的用户名密码,和之前mysql数据库创建给amoeba的用户账号不同。在这里有一个注释掉的ipAddress属性,如果Amoeba所在的服务器在多个网络环境内你可以定义该机器的其中一个IP来指定Amoeba所服务的网络环境,但是如果设置为127.0.0.1将导致其他机器无法访问Amoeba的服务。

mypasswd

之后配置queryRouter标签,这是amoeba真正实现读写分离所产生作用的地方,之前的配置都是为了该处做准备。

# 客户端连接amoeba的代理使用的密码

该处有三个地方需要我们配置,首先是defaultPool,一些除了SELECTUPDATEINSERTDELETE的语句都会在defaultPool执行。

... ...

之后是writePool,这里是配置写库也就是主数据库,在这里是前面dbServer.xml中配置的master。

${amoeba.home}/conf/rule.xml

resdPool配置的是读库,我这里是slave1,如果读库有多个这里可以填读池,也就是我在dbServer.xml中注释掉的那个dbServer配置的信息。在这里就完成了读写分离(主写从读)的配置。我的配置中是把写操作限制在了master中,把读限制在了slave中,如果我把defaultPool改成master的话那么读操作就会在master和slave之间做负载均衡了。

${amoeba.home}/conf/ruleFunctionMap.xml

 

${amoeba.home}/conf/functionMap.xml

四、配置jvm运行参数

1500

运行在jdk1.7环境中的amoeba要求xss参数必须大于228才能启动JVM

master# 设定默认节点

所以在amoeba安装目录下的jvm.properties文件中进行参数设置:

master # 设定可写节点,节点定义见dbServers.xml文件

 1 # app名字
 2 APP_NAME=Amoeba-MySQL
 3 
 4 # app版本号
 5 APP_VERSION=3.0.0-beta
 6 
 7 # 日志输出路径,log4j中可引用参数 ${project.output}
 8 
 9 APP_OUTPUT_PATH=$PROJECT_HOME/logs
10 
11 # 应用程序的PID文件存放路径,    默认存放在: ${project.home}/${APP_NAME}.pid
12 
13 #APP_PID_PATH=/temp/logs/$APP_NAME
14 
15 
16 # 控制台输出到日志文件
17 
18 APP_CONSOLE_LOG=$APP_OUTPUT_PATH/console.log
19 
20 
21 # 程序相关的配置参数
22 
23 #APP_OPTIONS="-DmyParam=value1 -DmyParam2=value2"
24 
25 # 启动参数  
26 
27 #APP_ARGS="args0 "
28 
29 
30 # JVM相关的参数,包括内存配置、垃圾回收策略
31 
32 JVM_OPTIONS="-server -Xms512m -Xmx1024m -Xss512k -XX:PermSize=16m -XX:MaxPermSize=96m"
33 
34 
35 # 应用程序忽略的信号列表,以逗号分割,程序shutdown的信号为15(可用 kill -15 pid 可让程序文明的shutdown,请不要在这儿填15)
36 
37 IGNORE_SIGNALS=1,2

slave1 # 设定只读池,可配置多个slave节点

 

#readPool或writePool可以是dbServers中的multiPool名称,用multiPool来设置负载均衡。

如上所有的配置工作就已经完成了,可以看出amoeba所需的全部配置工作还是比较少的。

true

启动amoeba:

vi conf/dbServers.xml

启动脚本在amoeba安装目录的bin目录下运行lancher:

# 读写分离配置,读池和写池和dbServer.xml中配置的节点相关

root@iZ25j1wvn7pZ:/usr/local/amoeba/amoeba-mysql-3.0.5-RC/bin# ./launcher
2016-12-12 21:38:05,748 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/amoeba-mysql-3.0.5-RC/conf/access_list.conf
2016-12-12 21:38:06,037 INFO  net.ServerableConnectionManager - Server listening on /127.0.0.1:8066.
 2016-12-12 22:14:44 [INFO] Project Name=Amoeba-MySQL, PID=2596 , System shutdown ....
 2016-12-12 22:14:48 [INFO] Project Name=Amoeba-MySQL, PID=3324 , starting...
log4j:WARN log4j config load completed from file:/usr/local/amoeba/amoeba-mysql-3.0.5-RC/conf/log4j.xml
2016-12-12 22:14:49,405 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/amoeba-mysql-3.0.5-RC/conf/access_list.conf
2016-12-12 22:14:49,664 INFO  net.ServerableConnectionManager - Server listening on 0.0.0.0/0.0.0.0:8066.
 2016-12-14 15:02:14 [INFO] Project Name=Amoeba-MySQL, PID=3324 , System shutdown ....
 2016-12-14 15:02:20 [INFO] Project Name=Amoeba-MySQL, PID=12246 , starting...
log4j:WARN log4j config load completed from file:/usr/local/amoeba/amoeba-mysql-3.0.5-RC/conf/log4j.xml
2016-12-14 15:02:20,955 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/amoeba-mysql-3.0.5-RC/conf/access_list.conf
2016-12-14 15:02:21,224 INFO  net.ServerableConnectionManager - Server listening on 0.0.0.0/0.0.0.0:8066.

${defaultManager}

 

64

 

128

运行结果如上所示表示启动成功。

3306

之后可以通过amoeba连接到数据库,连接信息如下:

chejecms

root@iZ25j1wvn7pZ:/usr/local/amoeba/amoeba-mysql-3.0.5-RC/bin# mysql -h182.92.172.80 -P8066 -uamoeba -ppassword
Welcome to the MySQL monitor.  Commands end with ; or g.
Your MySQL connection id is 2049945506
Server version: 5.1.45-mysql-amoeba-proxy-3.0.4-BETA (Ubuntu)

Copyright (c) 2000, 2014, 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> 

myroot

 

# 默认连接mysql server的用户

五、amoeba服务测试

my123

从连接的server version 可以看出连接数据可的实例是amoeba-proxy实例不是mysql实例,这样就表示可以通过amoeba的访问账户连接amoeba服务了。之后就可以进行测试了,首先向数据库中添加一条记录,可以看见数据同时更新到master和slave中,主从同步功能是可以用的。之后在slave上停止slave服务,再通过amoeba写入数据,这时amoeba重新读出的数据就没有新插入的数据了,因为主从同步功能已经关掉了,写入的数据在master中,没有同步到slave中,而amoeba读数据是从slave中读取的,因此没有新加入的数据。之后打开slave的同步服务,再在amoeba中读取就可以读到之前添加的数据了。整体测试下来就保证了amoeba实现了读写分离功能。

# 默认连接mysql server的密码,以上两项如不在下文中的dbserver中单独定义,则直接继承此处定义

 

# 定义连接mysql服务的用户amoeba和密码my123和数据库chejecms

参考资料:

# 定义后端MySQL的IP地址,一个master,一个slave

mysql基于amoeba的读写分离

172.19.200.204

MySQL基于amoeba的读写分离及负载均衡

172.18.109.213

CentOS系统 Amoeba MySql主从读写分离配置 适合新手傻

通过Amoeba对一个数据库实例进行操作

#服务组,轮询策略

1

master,slave1

#1为轮询策略,里面的master,slaver1按请求轮询调用

64位系统,修改:

vi /usr/local/amoeba/bin/amoeba

... ...

DEFAULT_OPTS="-server -Xms256m -Xmx256m -Xss256k"

#-Xss128k改为-Xss256k

③.开启amoeba

/usr/local/amoeba/bin/amoeba start &

开机自启动

echo "/usr/local/amoeba/bin/amoeba start &" >> /etc/rc.d/rc.local

④.验证amoeba

mysql -uamoeba -h 172.18.109.213 -pmypasswd -P8066

#注意,此时登录的用户密码为连接amoeba服务器的密码,不是连接数据库的密码!!因为连接进到的是amoeba,并没有进到mysql里面!!!

本文由澳门新萄京官方网站发布于数据库网络,转载请注明出处:MySQL读写抽离Amoeba简要介绍,6主从复制及读写抽

关键词: