以前寫過了一篇Mysql的主從复制,但沒有實現Mysql的主從复制的讀寫分離。

關於讀寫分離:

  讀寫分離(Read/Write Splitting),基本的原理是讓主數據庫處理事務性增、改、刪、操作(INSERT、UPDATE、DELETE),而從數據庫處理SELECT查詢操作。數據庫复制被用來把事務性操作導致的變更同步到集群中的從數據庫。

關於Mysql的讀寫分離實現大致有三種:

1、 程序修改Mysql操作類

   就以程序來完成Mysql的讀寫操作,如以PHP程序、java程序等解决此需求。

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

缺點:自己維護更新,增減服務器上的代碼處理。

2、 mysql-proxy

  MySQL-Proxy是處在你的MySQL數據庫客戶和服務端之間的程序,它還支持嵌入性腳本語言Lua。這個代理可以用來分析、監控和變換(transform)通信數據,它支持非常廣泛的使用場景:

 

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

優點:直接實現讀寫分離和負載均衡,不用修改代碼,master和slave用同一個账號

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

3、 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://go.rritw.com/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://go.rritw.com/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數據庫的主從复制以及讀寫分離的整個過程。文中可能還存在不完整或者出錯的地方,還請大家指出來,謝謝了。

 

 

 

 

 

本文出自 “linux學習” 博客,請務必保留此出處http://go.rritw.com/zhou123.blog.51cto.com/4355617/983592


From:51CTO        

 




創作者介紹
創作者 shadow 的頭像
shadow

資訊園

shadow 發表在 痞客邦 留言(0) 人氣()