Amoeba For MySQL入門：實現數據庫水平切分

時間  2019-11-19
標籤 amoeba mysql 入門 實現 數據庫 水平 切分 欄目 MySQL 简体版
原文   原文鏈接

http://docs.hexnova.com/amoeba/rw-splitting.html (在Master/Slave結構下的讀寫分離,負載均衡)html

 

當系統數據量發展到必定程度後，每每須要進行數據庫的垂直切分和水平切分，以實現負載均衡和性能提高，而數據切分後隨之會帶來多數據源整合等等問題。若是僅僅從應用程序的角度去解決這類問題，無疑會加劇應用程度的複雜度，所以須要一個成熟的第三方解決方案。前端

Amoeba正是解決此類問題的一個開源方案，Amoeba位於應用程序和數據庫服務器之間，至關於提供了一個代理，使得應用程序只要鏈接一個Amoeba，至關於只是在操做一個單獨的數據庫服務器，而實際上倒是在操做多個數據庫服務器，這中間的工做所有交由Amoeba去完成。java

本文針對基於MySQL的水平切分的實現機制，講解Amoeba For MySQL的簡單應用。mysql

 

1、背景介紹

使用數據庫：MySQLlinux

數據庫節點1：127.0.0.1sql

數據庫節點2：10.167.157.176shell

 

數據庫名：yunzhu數據庫

切分的表：用戶表（user_info）express

切分的參數：用戶ID（USERID）編程

 

切分規則：

用戶ID小於等於100的數據存到數據庫節點1，

用戶ID大於100的數據存到數據庫節點2

 

user_info表結構以下：

Sql代碼   收藏代碼
  1. CREATE TABLE `user_info` (  
  2.     `USERID` INT(10) NOT NULL DEFAULT '0',  
  3.     `USERNAME` VARCHAR(50) NULL DEFAULT NULL,  
  4.     PRIMARY KEY (`USERID`)  
  5. )  

數據庫節點1中user_info表中的數據：

+--------+-----------+
| USERID | USERNAME  |
+--------+-----------+
|     73 | Chen Feng |
|     88 | China     |
+--------+-----------+

數據庫節點1中user_info表中的數據：

+--------+----------+
| USERID | USERNAME |
+--------+----------+
|    108 | Jiang Su |
|    200 | NanJing  |
+--------+----------+

 

Amoeba版本：

amoeba-mysql-binary-2.2.0

 

下載地址：

http://nchc.dl.sourceforge.net/project/amoeba/Amoeba%20for%20mysql/2.2.x/amoeba-mysql-binary-2.2.0.tar.gz

下載後直接解壓便可使用

 

2、配置Amoeba

配置文件所有位於conf目錄下

一、amoeba.xml

配置鏈接Amoeba程序的用戶名和密碼：

Xml代碼   收藏代碼
  1. <property name="user">root</property>  
  2. <property name="password">chenfeng123</property>  

二、dbServers.xml

先配置一個抽象的父節點，定義多個數據庫節點的共通的信息，包括數據庫節點的端口、schema、用戶名和密碼：

Xml代碼   收藏代碼
  1. <dbServer name="abstractServer" abstractive="true">  
  2.     <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">  
  3.         ......  
  4.               
  5.         <!-- mysql port -->  
  6.         <property name="port">3306</property>  
  7.           
  8.         <!-- mysql schema -->  
  9.         <property name="schema">yunzhu</property>  
  10.           
  11.         <!-- mysql user -->  
  12.         <property name="user">root</property>  
  13.           
  14.         <!--  mysql password -->  
  15.         <property name="password">chenfeng</property>  
  16.     </factoryConfig>  
  17.       ......  
  18. </dbServer>  

  再配置兩個數據庫節點，繼承上面的父節點，而後配置各自的IP地址便可：

Xml代碼   收藏代碼
  1. <dbServer name="server1"  parent="abstractServer">  
  2.     <factoryConfig>  
  3.         <!-- mysql ip -->  
  4.         <property name="ipAddress">127.0.0.1</property>  
  5.     </factoryConfig>  
  6. </dbServer>  
  7.   
  8. <dbServer name="server2"  parent="abstractServer">  
  9.     <factoryConfig>  
  10.         <!-- mysql ip -->  
  11.         <property name="ipAddress">10.167.157.176</property>  
  12.     </factoryConfig>  
  13. </dbServer>  

三、rule.xml

  配置切分規則：

     一、schema指定數據庫名，name指定表名，defaultPools指定關聯的數據庫節點（指定哪幾個節點就從哪幾個節點裏面查數據）

     二、切分規則：

         1）用戶ID小於100的數據存到數據庫節點1

         2）用戶ID大於100的數據存到數據庫節點2

Xml代碼   收藏代碼
  1. <amoeba:rule xmlns:amoeba="http://amoeba.meidusa.com/">  
  2.     <tableRule name="user_info" schema="yunzhu" defaultPools="server1,server2">  
  3.         <rule name="rule1">  
  4.             <parameters>USERID</parameters>  
  5.             <expression><![CDATA[ USERID <= 100]]></expression>  
  6.             <defaultPools>server1</defaultPools>  
  7.             <readPools>server1</readPools>  
  8.             <writePools>server1</writePools>  
  9.         </rule>  
  10.         <rule name="rule2">  
  11.             <parameters>USERID</parameters>  
  12.             <expression><![CDATA[ USERID > 100 ]]></expression>  
  13.             <defaultPools>server2</defaultPools>  
  14.             <writePools>server2</writePools>  
  15.             <readPools>server2</readPools>  
  16.         </rule>  
  17.     </tableRule>        
  18. </amoeba:rule>  

 

3、運行及驗證

一、啓動Amoeba

經過bin目錄下的amoeba.bat啓動：

 

Dos代碼   收藏代碼
  1. amoeba start  

 

啓動後控制檯打印以下信息，能夠看到：

Dos代碼   收藏代碼
  1. log4j:WARN log4j config load completed from file:D:\JavaTools\amoeba-mysql-binar  
  2. y-2.2.0\bin\..\conf\log4j.xml  
  3. 2013-01-08 09:32:27,765 INFO  context.MysqlRuntimeContext - Amoeba for Mysql cur  
  4. rent versoin=5.1.45-mysql-amoeba-proxy-2.2.0  
  5. log4j:WARN ip access config load completed from file:D:\JavaTools\amoeba-mysql-b  
  6. inary-2.2.0\bin\../conf/access_list.conf  
  7. 2013-01-08 09:32:27,921 INFO  net.ServerableConnectionManager - Amoeba for Mysql  
  8.  listening on 0.0.0.0/0.0.0.0:8066.  
  9. 2013-01-08 09:32:27,921 INFO  net.ServerableConnectionManager - Amoeba Monitor S  
  10. erver listening on /127.0.0.1:40170.  

二、鏈接Amoeba

經過mysql客戶端鏈接Amoeba，端口指定爲8066，而後還像之前操做MySQL同樣進行操做：

Dos代碼   收藏代碼
  1. D:\>mysql -P8066 -uroot -pchenfeng123  
  2. Welcome to the MySQL monitor.  Commands end with ; or \g.  
  3. Your MySQL connection id is 21616774 to server version: 5.1.45-mysql-amoeba-prox  
  4. y-2.2.0  
  5.   
  6. Type 'help;' or '\h' for help. Type '\c' to clear the buffer.  
  7.   
  8. mysql>  

三、驗證數據的查詢

查詢yunzhu庫下的user_info表的數據，以下：

Sql代碼   收藏代碼
  1. mysql> select * from yunzhu.user_info;  
  2. +--------+-----------+  
  3. | USERID | USERNAME  |  
  4. +--------+-----------+  
  5. |    108 | Jiang Su  |  
  6. |    200 | NanJing   |  
  7. |     73 | Chen Feng |  
  8. |     88 | China     |  
  9. +--------+-----------+  
  10. 4 rows in set (0.02 sec)  

能夠看到，如今查到了兩個數據庫節點中的user_info表中的全部記錄。

 

四、驗證數據的插入

這裏插入兩條數據，一條USERID爲55，另外一條USERID爲155，以下：

Dos代碼   收藏代碼
  1. mysql> insert into yunzhu.user_info(USERID,USERNAME) values(55,'test55');  
  2. Query OK, 1 row affected (0.13 sec)  
  3.   
  4. mysql> insert into yunzhu.user_info(USERID,USERNAME) values(155,'test155');  
  5. Query OK, 1 row affected (0.05 sec)  

 

查詢數據庫節點1：

Dos代碼   收藏代碼
  1. D:\>mysql -uroot -pchenfeng  
  2. Welcome to the MySQL monitor.  Commands end with ; or \g.  
  3. Your MySQL connection id is 33 to server version: 5.0.18-nt  
  4.   
  5. Type 'help;' or '\h' for help. Type '\c' to clear the buffer.  
  6.   
  7. mysql> select * from yunzhu.user_info;  
  8. +--------+-----------+  
  9. | USERID | USERNAME  |  
  10. +--------+-----------+  
  11. |     55 | test55    |  
  12. |     73 | Chen Feng |  
  13. |     88 | China     |  
  14. +--------+-----------+  
  15. 3 rows in set (0.00 sec)  

 

查詢數據庫節點2：

Dos代碼   收藏代碼
  1. D:\>mysql -uroot -pchenfeng -h10.167.157.176  
  2. Welcome to the MySQL monitor.  Commands end with ; or \g.  
  3. Your MySQL connection id is 34 to server version: 5.0.18-nt  
  4.   
  5. Type 'help;' or '\h' for help. Type '\c' to clear the buffer.  
  6.   
  7. mysql> select * from yunzhu.user_info;  
  8. +--------+----------+  
  9. | USERID | USERNAME |  
  10. +--------+----------+  
  11. |    108 | Jiang Su |  
  12. |    155 | test155  |  
  13. |    200 | NanJing  |  
  14. +--------+----------+  
  15. 3 rows in set (0.00 sec)  

能夠發現USERID爲55的記錄插入到了數據庫節點1中，USERID爲155的記錄插入到了數據庫節點2中。

由於根據rule.xml中的切分規則，USERID小於等於100的的記錄存在數據庫節點1中，而大於100的則存在數據庫節點2中。

 

4、注意一些限制

這是我在實踐中發現的，剛開始不知道存在這樣的限制，以至於浪費了不少時間，覺得配置有問題，搞了好久才發現原來是由於這些限制才致使沒有出現預期的結果，因此必需要注意：

一、不論是查詢和插入，每條都必須顯式地指定數據庫名（yunzhu），不然只會從一個數據庫節點中查詢數據，或者全部數據所有會插入一個數據庫節點中。

二、插入數據時，必須顯式地指定列名，如「insert into yunzhu.user_info(USERID,USERNAME)」，不然切分規則不會生效，全部記錄都會插入到一個數據庫節點中。

--------------------------------------------------------------------------------

 

Mysql的主從複製的讀寫分離之Amoeba實現

之前寫過了一篇Mysql的主從複製，但沒有實現Mysql的主從複製的讀寫分離。

關於讀寫分離：

  讀寫分離（Read/Write Splitting),基本的原理是讓主數據庫處理事務性增、改、刪、操做（INSERT、UPDATE、DELETE)，而從數據庫處理SELECT查詢操做。數據庫複製被用來把事務性操做致使的變動同步到集羣中的從數據庫。

關於Mysql的讀寫分離實現大體有三種：

一、 程序修改Mysql操做類

   就以程序來完成Mysql的讀寫操做，如以PHP程序、java程序等解決此需求。

優勢：直接和數據庫通訊，簡單快捷的讀寫分離和隨機的方式實現的負載均衡，權限獨立分配

缺點：本身維護更新，增減服務器上的代碼處理。

二、 mysql-proxy

  MySQL-Proxy是處在你的MySQL數據庫客戶和服務端之間的程序，它還支持嵌入性腳本語言Lua。這個代理能夠用來分析、監控和變換（transform）通訊數據，它支持很是普遍的使用場景：

 

  • 負載平衡和故障轉移處理
  • 查詢分析和日誌
  • SQL宏（SQL macros）
  • 查詢重寫（quer rewriting）
  • 執行shell命令

優勢：直接實現讀寫分離和負載均衡，不用修改代碼，master和slave用同一個帳號

缺點：字符集問題，lua語言編程，還只是alpha版本，時間消耗有點高

三、 Amoeba

參考官網：http://amoeba,meidusa.com/ 
優勢：直接實現讀寫分離和負載均衡，不用修改代碼，有很靈活的數據解決方案
缺點：本身分配帳戶，和後端數據庫權限管理獨立，權限處理不夠靈活

以上是三種常見的Mysql的讀寫分離方法。在這建議用第三種也就是amoeba來實現 

關於Amoeba

Amoeba（變形蟲）項目，該開源框架於2008年開始發佈一款Amoeba for Mysql軟件。這個軟件致力於Mysql的分佈式數據庫前端代理層，它主要在應用層訪問Mysql的時候充當SQL路由功能，專一於分佈式數據庫代理層（Database Proxy)開發。位於Client、DB Server(s)之間，對客戶透明。具備負載均衡、高可用性、SQL過濾、讀寫分離、可路由相關的到目標數據庫、可併發請求多臺數據庫合併結果。經過Amoeba你可以完成多數據源的高可用、負載均衡、數據切片的功能，目前Amoeba已在不少企業的生產線上使用。

下面就來把 Mysql的主從複製和讀寫分離完整的實現一下。

先來作Mysql的主從複製。

我實現的環境以下：

System：Centos 5.4 32bit

主：192.168.1.107

從：192.168.1.139

讀寫分離：192.168.1.183

拓撲圖以下：

 

MySql的主從複製：

對主MysqL服務器,主要是開啓二進制日誌，這個默認是開啓的，在配置文件中：

# vim /etc/my.cnf

server-id = 1 (默認爲1）

log-bin = mysql-bin (這個也是默認開啓的）

下面鏈接到mysql數據庫中建立一個用戶並賦予複製權限。

mysql> GRANT REPLICATION CLIENT,REPLICATION SLAVE ON *.* TO 'repl'@'192.168.1.139' IDENTIFIED BY "123456";

這樣在主服務器上操做暫時完成了。

下面來在從服務器上操做：

修改主配置文件：my.cnf

  1. # vim /etc/my.cnf 
  2. 定位到 server-id = 1 
  3. 修改成：server-id = 2 
  4. 添加以下內容： 
  5. relayrelay-log = relay-bin 
  6. relayrelay-log-index = relay-bin.index 
  7. 修改完成後，保存退出； 
  8. # service mysqld restart 

由於在主mysql中已經有數據了，因此要把主服務器的數據導入到從服務器中，因此在主服務器上的操做：

 

  1. # mysqldump --all-databases --lock-all-tables --master-data=2 > /tmp/slave.sql  
  2. 導出後複製到從服務器上： 
  3. # scp /tmp/slave.sql 192.168.1.139:/tmp/ 
  4. 進入到從服務器上,導入數據。 
  5. # mysql < /tmp/slave.sql 

以上操做完成後就能夠作把主從鏈接在一塊兒了。

在從服務器上進入數據庫中

  1. mysql> CHANGE MASTER TO MASTER_HOST='192.168.1.107',MASTER_USER='repl',MASTER_PASSWORD='123456'; 

 

下面就能夠在從服務器上開啓複製了

mysql> start slave;

 

查看是否鏈接成功：

  1. mysql> show slave status\G 
  2. 以下兩行出現則代表主從複製成功： 
  3.  
  4. Slave_IO_Running: Yes 
  5. Slave_SQL_Running: Yes 

可在主服務器上建立一個數據庫或表來在從服務器上來驗證一下。

下面來進行最爲核心的內容——讀寫分離

下面的操做要在讀寫分離的服務器上操做也就是：192.168.1.183

Amoeba的安裝：

安裝Amoeba前要先安裝JDK，由於Amoeba是用java開發的所要有JDK支持。

  1. # java -version 
  2. java version "1.6.0_33" 
  3. Java(TM) SE Runtime Environment (build 1.6.0_33-b04) 
  4. Java HotSpot(TM) Server VM (build 20.8-b03, mixed mode) 

若是沒有安裝JDK，要先安裝，方法以下 ：

  1. 去oracle官網下載jdk安裝包後，安裝jdk  
  2. # chmod 755 jdk-6u33-linux-i586.bin  
  3. # ./jdk-6u33-linux-i586.bin  
  4. 默認安裝到/usr/java/jdk1.6.0_33 
  5. 下面來修改環境變量： 
  6. # vim /etc/profile 
  7. 添加以下行： 
  8. export JAVA_HOME=/usr/java/jdk1.6.0_33 
  9. export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar 
  10. export PATH=$PATH:$JAVA_HOME/bin 
  11. 保存退出！ 
  12. # source /etc/profile \\使之生效 
  13. 查看： 
  14. # java -version 
  15. java version "1.6.0_33" 
  16. Java(TM) SE Runtime Environment (build 1.6.0_33-b04) 
  17. Java HotSpot(TM) Server VM (build 20.8-b03, mixed mode) 

安裝完成後就能夠安裝Amoeba了

下載：

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

安裝：

  1. # mkdir /usr/local/amoeba 
  2. # mv amoeba-mysql-binary-2.1.0-RC5.tar.gz /usr/local/amoeba  
  3. # cd /usr/local/amoeba 
  4. # tar zxvf amoeba-mysql-binary-2.1.0-RC5.tar.gz 

解壓後就完成了。下面要作的就是配置。

  1. # cd /usr/local/amoeba  \\主要是配置下面兩個文件 
  2. dbServer.xml  \\ 定義鏈接數據庫的信息
  3. amoeba.xml  \\ 定義讀寫分離的節點管理信息

下面就來配置一下。

# cd /usr/local/amoeba

# vim dbServer.xml

  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. 每一個dbServer須要配置一個pool,若是多臺平等的mysql須要進行loadBalance,
  9. 平臺已經提供一個具備負載均衡能力的objectPool:
  10. 簡單的配置是屬性加上virtual="true",該Pool不容許配置factoryConfig
  11. 或者本身寫一個ObjectPool
     
  12.                          such as 'multiPool' dbServer    
  13.                 --> 
  14.  
  15.         <dbServer name="abstractServer" abstractive="true"> 
  16.                 <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory"> 
  17.                         <property name="manager">${defaultManager}</property> 
  18.                         <property name="sendBufferSize">64</property> 
  19.                         <property name="receiveBufferSize">128</property> 
  20.  
  21.                         <!-- mysql port --> 
  22.                         <property name="port">3306</property> 
  23.   \\這個是後端數據的端口
  24.                         <!-- mysql schema --> 
  25.                         <property name="schema">test</property> 
  26.   \\這個是後端默認的數據庫
  27.                         <!-- mysql user --> 
  28.                         <property name="user">root</property> 
  29.  
  30.                         <!--  mysql password 
  31.                         <property name="password">password</property> 
  32.                         --> 
  33.                 </factoryConfig> 
  34.  
  35.                 <poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool"> 
  36.                         <property name="maxActive">500</property> 
  37.                         <property name="maxIdle">500</property> 
  38.                         <property name="minIdle">10</property> 
  39.                         <property name="minEvictableIdleTimeMillis">600000</property> 
  40.                         <property name="timeBetweenEvictionRunsMillis">600000</property> 
  41.                         <property name="testOnBorrow">true</property> 
  42.                         <property name="testWhileIdle">true</property> 
  43.                 </poolConfig> 
  44.         </dbServer> 
  45.  \\下面的配置是定義一個主節點和一個從節點。
  46.         <dbServer name="master"  parent="abstractServer">  \\定義一個主節點
  47.                 <factoryConfig> 
  48.                         <!-- mysql ip --> 
  49.                         <property name="ipAddress">192.168.1.107</property> 
  50.                         <property name="user">root</property>  \\鏈接數據庫的用戶名
  51.                         <property name="password">123456</property>  \\鏈接數據庫的密碼
  52.                 </factoryConfig> 
  53.         </dbServer> 
  54.         <dbServer name="slave"  parent="abstractServer">  \\定義一個從節點
  55.                 <factoryConfig> 
  56.                         <!-- mysql ip --> 
  57.                         <property name="ipAddress">192.168.1.139</property> 
  58.                         <property name="user">root</property> 
  59.                         <property name="password">123456</property> 
  60.                 </factoryConfig> 
  61.         </dbServer> 
  62.   \\定義池，把master和slave加入
  63.         <dbServer name="server1" virtual="true">  \\server1是要把master節點加入
  64.                 <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool"> 
  65.                         <!-- Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->   < !  -- 負載均衡參數1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
  66.                         <property name="loadbalance">1</property> 
  67.  
  68.                         <!-- Separated by commas,such as: server1,server2,server1 --> 
  69.                         <property name="poolNames">master</property>  <!--
  70. 參與該pool負載均衡的poolName列表以逗號分割 這裏只一個主節點因此就一個
  71.  -->
  72.                 </poolConfig> 
  73.         </dbServer> 
  74.         <dbServer name="server2" virtual="true">  \\server2是要把slave節點加入
  75.                 <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool"> 
  76.                         <!-- Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA--> 
  77.                         <property name="loadbalance">1</property> 
  78.  
  79.                         <!-- Separated by commas,such as: server1,server2,server1 --> 
  80.                         <property name="poolNames">slave</property> 
  81.                 </poolConfig> 
  82.         </dbServer> 
  83.  
  84. </amoeba:dbServers> 

下面來配置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.net.ServerableConnectionManager"> 
  10.                         <!-- port --> 
  11.                         <property name="port">8066</property> 
  12.   \\定義amoeba讀寫分離proxy對外代理的端口
  13.                         <!-- bind ipAddress --> 
  14.                         <!--  
  15.                         <property name="ipAddress">127.0.0.1</property> \\這個是綁定端口的ip
  16. 如新註釋掉了，說明8066端口綁定在0.0.0.0/0.0.0.0 上面
  17.                          --> 
  18.  
  19.                         <property name="manager">${clientConnectioneManager}</property> 
  20.  
  21.                         <property name="connectionFactory"> 
  22.                                 <bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory"> 
  23.                                         <property name="sendBufferSize">128</property> 
  24.                                         <property name="receiveBufferSize">64</property> 
  25.                                 </bean> 
  26.                         </property> 
  27.  
  28.                         <property name="authenticator"> 
  29.                                 <bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator"> 
  30.  
  31.                                         <property name="user">root</property> 
  32.   \\定義經過amoeba登陸的用戶名
  33.                                         <property name="password">123456</property> 
  34.   \\相應的這個就是密碼了。 定義proxy的管理賬號密碼，客戶端和程序只須要鏈接proxy的賬號密碼便可，至關於中間接封裝
  35.                                         <property name="filter"> 
  36.                                                 <bean class="com.meidusa.amoeba.server.IPAccessController"> 
  37.                                                         <property name="ipFile">${amoeba.home}/conf/access_list.conf</property> 
  38.                                                 </bean> 
  39.                                         </property> 
  40.                                 </bean> 
  41.                         </property> 
  42.  
  43.                 </service> 
  44.  
  45.                 <!-- server class must implements com.meidusa.amoeba.service.Service --> 
  46.                 <service name="Amoeba Monitor Server" class="com.meidusa.amoeba.monitor.MonitorServer"> 
  47.                         <!-- port --> 
  48.                         <!--  default value: random number 
  49.                         <property name="port">9066</property> 
  50.                         --> 
  51.                         <!-- bind ipAddress --> 
  52.                         <property name="ipAddress">127.0.0.1</property> 
  53.                         <property name="daemon">true</property> 
  54.                         <property name="manager">${clientConnectioneManager}</property> 
  55.                         <property name="connectionFactory"> 
  56.                                 <bean class="com.meidusa.amoeba.monitor.net.MonitorClientConnectionFactory"></bean> 
  57.                         </property> 
  58.  
  59.                 </service> 
  60.  
  61.                 <runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext"> 
  62.                         <!-- proxy server net IO Read thread size --> 
  63.                         <property name="readThreadPoolSize">20</property> 
  64.  
  65.                         <!-- proxy server client process thread size --> 
  66.                         <property name="clientSideThreadPoolSize">30</property> 
  67.  
  68.                         <!-- mysql server data packet process thread size --> 
  69.                         <property name="serverSideThreadPoolSize">30</property> 
  70.  
  71.                         <!-- per connection cache prepared statement size  --> 
  72.                         <property name="statementCacheSize">500</property> 
  73.  
  74.                         <!-- query timeout( default: 60 second , TimeUnit:second) --> 
  75.                         <property name="queryTimeout">60</property> 
  76.                 </runtime> 
  77.  
  78.         </proxy> 
  79.  
  80.         <!--  
  81.                 Each ConnectionManager will start as thread 
  82.                 manager responsible for the Connection IO read , Death Detection 
  83. \\每一個ConnectionManager 都作爲一個線程啓動
  84. \\manager 負責Connection IO讀寫/死亡檢測
  85.         --> 
  86.         <connectionManagerList> 
  87.                 <connectionManager name="clientConnectioneManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper"> 
  88.                         <property name="subManagerClassName">com.meidusa.amoeba.net.ConnectionManager</property> 
  89.                         <!--  
  90.                           default value is avaliable Processors  
  91.                         <property name="processors">5</property> 
  92.                          --> 
  93.                 </connectionManager> 
  94.                 <connectionManager name="defaultManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper"> 
  95.                         <property name="subManagerClassName">com.meidusa.amoeba.net.AuthingableConnectionManager</property> 
  96.  
  97.                         <!--  
  98.                           default value is avaliable Processors  
  99.                         <property name="processors">5</property> 
  100.                          --> 
  101.                 </connectionManager> 
  102.         </connectionManagerList> 
  103.  
  104.                 <!-- default using file loader --> 
  105.         <dbServerLoader class="com.meidusa.amoeba.context.DBServerConfigFileLoader"> 
  106.                 <property name="configFile">${amoeba.home}/conf/dbServers.xml</property> 
  107.         </dbServerLoader> 
  108.  
  109.         <queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter"> 
  110.                 <property name="ruleLoader"> 
  111.                         <bean class="com.meidusa.amoeba.route.TableRuleFileLoader"> 
  112.                                 <property name="ruleFile">${amoeba.home}/conf/rule.xml</property> 
  113.                                 <property name="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property> 
  114.                         </bean> 
  115.                 </property> 
  116.                 <property name="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property> 
  117.                 <property name="LRUMapSize">1500</property> 
  118.                 <property name="defaultPool">server1</property> 
  119.  \\定義默認的池，一些除了SELECT\UPDATE\INSERT\DELETE的語句都會在defaultPool執行
  120.  
  121.                 <property name="writePool">server1</property>
  122. \\定義寫的池，這裏的server1就是在dbServer.xml中的server1
  123.                 <property name="readPool">server2</property> 
  124.   \\定義讀的池，這裏的server2就是在dbserver.xml中的server2
  125.                 <property name="needParse">true</property> 
  126.         </queryRouter> 
  127. </amoeba:configuration> 

配置完成後就能夠啓動amoeba了。

  1. # cd /usr/local/amoeba/bin 
  2. # ./amoeba  
  3. amoeba start|stop 
  4. # ./amoeba start &  \\會輸出下面的信息 
  5. [1] 6789 
  6. log4j:WARN log4j config load completed from file:/usr/local/amoeba/conf/log4j.xml 
  7. 2012-09-06 17:56:01,619 INFO  context.MysqlRuntimeContext - Amoeba for Mysql current versoin=5.1.45-mysql-amoeba-proxy-2.1.0-RC5 
  8. log4j:WARN ip access config load completed from file:/usr/local/amoeba/conf/access_list.conf 
  9. 2012-09-06 17:56:01,987 INFO  net.ServerableConnectionManager - Amoeba for Mysql listening on 0.0.0.0/0.0.0.0:8066.  
  10. 2012-09-06 17:56:01,992 INFO  net.ServerableConnectionManager - Amoeba Monitor Server listening on /127.0.0.1:6376. 
  11. 從上面的信息中能夠看到8066端口打開了。可查看進程： 
  12. # ps aux | grep amoeba 
  13. root   6789  4.1  1.5 408940 31908 pts/1    Sl   17:56   0:00 /usr/java/jdk1.6.0_33/bin/java -server -Xms256m -Xmx256m -Xss12sworlds.conf=/usr/local/amoeba/bin/amoeba.classworlds -classpath /usr/local/amoeba/lib/classworlds-1.0.jar org.co 
  14. root   6820  0.0  0.0   5112   680 pts/1    S+   17:56   0:00 grep amoeba 
  15. # netstat -tlnp 
  16. Proto Recv-Q Send-Q Local Address               Foreign Address             State       PID/Program name    
  17. tcp        0      0 0.0.0.0:111                 0.0.0.0:*                   LISTEN      -                    
  18. tcp        0      0 0.0.0.0:688                 0.0.0.0:*                   LISTEN      -                    
  19. tcp        0      0 127.0.0.1:631               0.0.0.0:*                   LISTEN      -                    
  20. tcp        0      0 127.0.0.1:25                0.0.0.0:*                   LISTEN      -                    
  21. tcp        0      0 :::8066                     :::*                        LISTEN      6789/java            
  22. tcp        0      0 ::ffff:127.0.0.1:6376       :::*                        LISTEN      6789/java            
  23. tcp        0      0 :::22                       :::*                        LISTEN      -              

從上面的一些信息能夠看到amoeba已經啓動，下面就能夠測試一下了。

下面來作一測試：

爲了更好的看到測試結果，要作如下這些步驟：

測試以前要先保證amoeba-server有訪問兩個主從服務器test庫的權限，在主mysql上執行:

  1. mysql> grant all privileges on *.* to 'root'@'192.168.1.183' identified by "123456"; 
  2. mysql> flush privileges; 
  3. 用戶建立完成後就能夠登陸了 
  4. # mysql -uroot -p123456 -h192.168.1.183 -P8066 

下面開始測試：

先讓主從開始複製，即在從服務器上執行：

mysql> slave start;

再從讀寫分離的服務器上登陸：

# mysql -uroot -p123456 -h192.168.1.183 -P8066

進入以後，先來建立一個數據庫zhou,而後在這個數據庫中建立一個表test 

mysql> create database zhou;

mysql> use zhou;

mysql> create table test (id int(10), name varchar(20),adress varchar(30));

作完這些，回到從服務器上執行：

mysql> slave stop;

接着在主從服務器上各加入一條不一樣的數據。

在主上：

mysql> use zhou;

mysql> insert into test ('1','zhou','this_is_master');

在從上：

mysql> use zhou;

mysql> insert into test ('2','zhou','this_is_slave');

完成後就能夠在讀寫分離服務器上測試讀寫了

在讀寫分離服務器上：

mysql> use zhou;

 

mysql> select * from test;

+------+------+---------------+

| id   | name | address       |

+------+------+---------------+

|    2 | zhou | this_is_slave | 

+------+------+---------------+

1 row in set (0.01 sec)

從結果能夠看出數據是讀的從服務器上的數據，而後咱們直接插入數據，再來測試

 

mysql> insert into test values('3','hhh','test_write');

Query OK, 1 row affected (0.01 sec)

mysql> select * from test;

+------+------+---------------+

| id   | name | address       |

+------+------+---------------+

|    2 | zhou | this_is_slave | 

+------+------+---------------+

1 row in set (0.00 sec)

 

結果顯示出的數據沒有改變，由於咱們把主從複製停了，因此數據沒有同步，從查詢的結果能夠看到，數據仍是來自從服務器。

而後們再在主服務器上查詢能夠看到：

 

mysql> select * from test;

+------+------+--------------- +

| id   | name | address        |

+------+------+--------------- +

|    1 | zhou | this_is_master | 

+------+------+--------------- +

|    3 | hhh  |  test_write    | 

+------+------+--------------- +

 

 

從上面的結果能夠看出，數據的讀寫分離成功了。

以上就是mysql數據庫的主從複製以及讀寫分離的整個過程。文中可能還存在不完整或者出錯的地方，還請你們指出來，謝謝了。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程