• MySQL数据库之主从复制及读写分离

    目录

    前言

    一、主从复制原理

    1、MySQL 支持的复制类型

    2、主从复制的工作过程

    3、MySQL四种同步方式

    ①异步复制（Async Replication）

    ②同步复制（sync Replication）

    ③半同步复制（Async Replication）

    ④增强半同步复制（lossless Semi-Sync Replication）

    4、MySQL主从复制延迟

    二、主从复制实验

    1、前期准备

    2、主从服务器时间同步

    3、主服务器Master配置（192.168.226.150）

    4、从服务器Slave的配置（192.168.226.151，192.168.226.152）

    5、验证主从复制效果

    6、从服务器的故障问题解决

    三、读写分离原理

    1、什么是读写分离

    2、为什么要读写分离

    3、什么时候要读写分离

    4、主从复制与读写分离

    四、读写分离实验部署

    1、读写分离拓扑图

    2、实验思路

    3、环境准备

    4、jdk环境安装

    5、安装Amoeba软件

    6、配置Amoeba读写分离，两个slave读负载均衡 

    7、配置Ammoeba 

    8、客户端测试读写分离功能

    出现的报错

    测试一：主从数据库是否可以同步

    测试二：读写分离

    测试三：是否为轮询查询

    前言

    在企业应用中，成熟的业务通常数据量都比较大。
    单台MySQL在安全性、高可用性和高并发方面都无法满足实际的需求。
    配置多台主从数据服务器以实现读写分离。

    一、主从复制原理

    MySQL的主从复制和MySQL的读写分离两者有着紧密联系，首先要部署主从复制，只有主从复制完成可=了，才能在此基础上进行数据的读写分离

    1、MySQL 支持的复制类型

    ①基于语句的复制（STATEMENT）
    在主服务器上执行的SQL语句，在从服务器上执行同样的语句。MySQL默认采用基于语句的复制，效率比较高

    ②基于行的复制（ROW）
    把改变的内容复制过去，而不是把命令在服务器上执行一遍

    ③混合类型的复制（MIXED）
    默认采用基于语句的复制，一旦发现基于语句无法精确复制时，就会采用基于行的复制

    2、主从复制的工作过程

    核心：两个日志，三个线程

    ①两个日志
    二进制日志：master
    中继日志：slaves
    二进制日志–>复制到 中继日志

    ②三个线程
    master上：dump线程
    slave上：I/O线程、SQL线程

    dump线程：
    监听本地二进制日志
    记录I/O线程对应的slave位置
    同步二进制日志更新内容给I/O线程

    I/O线程：
    监听master的dump线程
    将slave信息发送给master：从服务器位置、日志的position（记录位置）、超时时间
    接收master的dump线程传递过来的更新信息
    写入relay-log中

    SQL线程：
    监听中继日志
    将中继日志中的更新内容执行到自己的数据库中（保证从库与主库执行相同操作）

    MySQL主从复制的过程
    （1）在每个事务更新数据完成之前，Master在二进制日志（Binary log）记录这些改变。写入二进制日志完成后，Master通知存储引擎提交事务
    （2）Slave将Master的二进制日志（Binary log）复制到其中继日志（Relay log），首先slave开始一个工作线程（I/O），I/O线程在Master上打开一个普通的连接，然后开始Binlog dump process。Binlog dump process 从Master的二进制日志中读取事件，如果已经跟上Master，它会睡眠并等待Master产生新的事件，I/O线程将这些事件写入中继日志
    （3）SQL slave thread（SQL从线程）处理该过程的最后一步，SQL线程从中继日志读取事件，并重放其中的事件而更新salve数据，使其与Master中的数据一致，只要该线程与I/O保持一致，中继日志通常会位于OS缓存中，所以中继日志的开销很小

    复制过程有一个很重要的限制，即复制在Salve上是串行化的，也就是说Master上的并行更新操作不能在Salve上并行操作

    3、MySQL四种同步方式

    MySQL有四种同步方式
    ①异步复制（Async Replication）
    ②同步复制（sync Replication）
    ③半同步复制（Async Replication）
    ④增强半同步复制（lossless Semi-Sync Replication）、无损复制

    ①异步复制（Async Replication）

    主库将更新写入binlog日志文件后，不需要等待数据更新是否已经复制到从库中，就可以继续处理更多的请求。Master将事件写入binlog，但并不知道Slave是否或何时已经接收且已处理。在异步复制的机制的情况下，如果Master宕机，事务在Master上已提交，但很可能这些事务没有传到任何的Slave上。假设有Master->Slave故障转移的机制，此时Slave也可能会丢失事务。MySQL复制默认是异步复制，异步复制提供了最佳性能

    ②同步复制（sync Replication）

    主库将更新写入binlog日志文件后，需要等待数据更新已经复制到从库中，并且已经在从库执行成功，然后返回继续处理其他的请求。同步复制提供了最佳安全性，保证数据安全，数据不会丢失，但对性能有一定的影响。

    ③半同步复制（Async Replication）

    写入一条数据请求到Master，从服务器只要有一台接收到写入自己的中继日志，会给客户端返回一条接收成功的信息。
    主库提交更新写入二进制日志文件后，等待数据更新写入了从服务器中继日志中，然后才能再继续处理其它请求。该更能确保至少有一个从库接收完主库传递过来的binlog内容已经写入到自己的relaylog里面了，才会通知主库上面的等待线程，改操作完毕
    半同步复制，是最佳安全性与最佳性能之间的一个折中
    MySQL5.5版本之后引入了半同步复制功能，主从服务器必须安装半同步复制插件，才能开启该复制功能。如果等待超时，超过rpl_semi_master_timeout参数设置时间（默认值为10000，表示10秒），则关闭半同步复制，并自动转换为异步复制模式。当master dumo线程发送完一个事务的所有事件之后，如果在rpl_semi_master_timeout内，收到了从库的响应，则主从又重新恢复为增强半同步复制
    ACK即是确认符

    ④增强半同步复制（lossless Semi-Sync Replication）

    增强半同步是在MySQL5.7引入，其实半同步可以看成是一个过渡功能，因为默认的配置就是增强半同步，所以，大家一般说的半同步复制就是增强的半同步复制，也就是无损复制
    增强半同步和半同步不同的是，等待ACK时间不同
    rpl_semi_sync_master_wait_point = AFTER_SYNC（默认）
    半同步的问题是因为等待ACK的点是Commit之后，此时Master已经完成数据变更，用户已经可以看到最新数据，当binlog还未同步到Slave时，发生主从切换，那么此时从库是没有这个最新数据的，用户看到的是老数据
    增强半同步将等待ACK的点放在提交Commit之前，此时数据还未被提交，外界看不到数据变更，此时如果发送主从切换，新库依然还是老数据，不存在数据不一致的问题

    4、MySQL主从复制延迟

    Master服务器肝病发，形成大量事务

    网络延迟

    主从硬件设备导致（cpu主频、内存I/O、硬盘I/O）

    MySQL默认使用异步复制。可以优化MySQL参数。比如innodb_buffer_pool_size，让更多操作在MySQL内存中完成。主库还可以使用高性能主句，包括cpu强悍、内存加大，避免使用虚拟云主机，使用物理主机，这样升级了I/O方面。还可以将从库使用SSD磁盘。网络优化，避免跨机房使用

    二、主从复制实验

    1、前期准备

    服务器IP地址
    主服务器192.168.226.150
    从服务器1192.168.226.151
    从服务器2192.168.226.152

    关闭防火墙及核心防护

    1. systemctl stop firewalld    #关闭防火墙
    2. systemctl disable firewalld
    3. setenforce 0           #关闭核心防护

    2、主从服务器时间同步

    1. yum -y install ntpdate ntp    #下载软件
    2. ntpdate ntp.aliyun.com    #时间同步
    3. 26 Sep 05:16:50 ntpdate[12930]: adjust time server 203.107.6.88 offset 0.008096 sec

    3、主服务器Master配置（192.168.226.150）

    1. vim /etc/my.cnf
    2. server-id = 1    #server-id与从服务器server-id不能重复
    3. log-bin=master-bin    #添加，主服务器开启二进制文件
    4. log_slave-updates=true   #添加，允许从服务器更新二进制文件
    5.  
    6. systemctl restart mysqld    #重启mysql服务

    修改配置文件

    重启MySQL服务

    配置规则

    1. mysql -uroot -pngs123.    #进入到数据库
    2. grant replication slave on *.* to 'myslave'@'192.168.226.%' identified by '123456';
    3. #允许192.168.226.0网段的所有主机使用myslave账号和123456密码登录并使用库和表
    4. flush privileges;
    5. #将用户和权限配置保存在内存中
    6. show master status;
    7. #查看master服务器当前正在执行的二进制日志位置，和列偏移量

    4、从服务器Slave的配置（192.168.226.151，192.168.226.152）

    1. #从服务器1：192.168.226.151
    2. vim /etc/my.cnf
    3. server-id = 2    #id不能与master相同，两个从服务器slave也不能相同
    4. relay-log=relay-log-bin   #添加，开启中继日志，从服务器上同步master服务器日志文件到本地
    5. relay-log-index=slave-relay-bin.index   #添加，定义中继日志文件的位置和名称
    6.  
    7. systemctl restart mysqld    #重启MySQL
    8.  
    9. #从服务器2：192.168.226.152
    10. vim /etc/my.cnf
    11. server-id = 3
    12. relay-log=relay-log-bin
    13. relay-log-index=slave-relay-bin.index
    14.  
    15. systemctl restart mysqld    #重启MySQL

    修改配置文件

    开启从服务器功能

    1. mysql -uroot -pngs123.    #登录数据库
    2. change master to master_host='192.168.226.150',master_user='myslave',master_password='123456',master_log_file='master-bin.000001',master_log_pos=154;
    3. #配置同步，注意master_log_file和master_log_pos的值要与master查询的一致
    4.  
    5. start slave;   #开启同步
    6.  
    7. show slave status\G    #查看slave状态（查看I/O和SQL都为YES）
    8.  
    9. #确保I/O和SQL线程都是YES，代表同步正常
    10. Slave_IO_Running: Yes				#负责与主机的io通信
    11. Slave_SQL_Running: Yes				#负责自己的slave mysql进程

    5、验证主从复制效果

    在master服务器上创建sen库

    6、从服务器的故障问题解决

    如果在查看服务器上slave状态时，出现NO的问题。就是执行: show slave status\G，查看的结果，可以往下看，或查看到各个对应的报错的信息。

    ①遇到Slave_IO_Running:NO的情况

    分析：可以向下查看对应的报错的信息。

    • 先总览看 ： last_Error（报错数量） Last_Error（报错原因） 。
    • 再看IO的报错： Last_IO_Errno: 、Last_IO_Error: 他们之间的信息

    ②遇到Slave_SQL_Running：NO的情况

    分析：可以向下查看对应的报错的信息。

    • 先总览看 ： last_Error（报错数量） Last_Error（报错原因） 。
    • 再看IO的报错： Last_SQL_Errno: 、Last_SQL_Error: 他们之间的信息
    1. #问题:slave_IO_Running:NO
    2. 1、网络不通
    3. 2、my.cnf配置文件有问题
    4. 3、change中配置出错，密码、file文件名、pos偏移量与master不相符
    5. 4、防火墙没有关闭
    6.  
    7. #问题:slave_SQL_Running:NO
    8. 1、程序可能在slave上进行了写操作
    9. 2、也可能是slave机器重起后，事务回滚造成的.
    10. 执行这个：set GLOBAL SQL_SLAVE_SKIP_COUNTER=1;

    三、读写分离原理

    读写分离就是只在主服务器上写，只在从服务器上读
    基本的原理是让主数据库处理事务操作，而从数据库处理select查询，数据库复制被用来把主数据库上事务性操作导致的变更同步到集群中的从数据库

    1、什么是读写分离

    读写分离，基本的原理就是让主数据库处理事务性增、删、改操作，而从数据库处理select查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库

    2、为什么要读写分离

    因为数据库的“写”（写10000条数据可能要3分钟）操作是比较耗时的。
    但是数据库的“读”（读10000条数据可能只要5秒钟）。
    所以读写分离，解决的是，数据库的写入，影响了查询的效率。

    3、什么时候要读写分离

    数据库不一定要读写分离，如果程序使用数据库较多时，而更新少，查询多的情况下会考虑使用。利用数据库主从同步，再通过读写分离可以分担数据库压力，提高性能

    4、主从复制与读写分离

    在实际的生产环境中，对数据库的读和写都在同一个数据库服务器中，是不能满足实际需求。无论是在安全性、高可用还是高并发等各个方面都是完全不能满足实际需求的。因此，通过主从复制的方式来同步数据，再通过读写分离来提升数据库的并发负载能力。有点类似于rsync，但是不同的是rsync是对磁盘文件做备份，而mysql主从复制是对数据库中的数据、语句做备份

    四、读写分离实验部署

    在做读写分离时，要将上面的主从复制配置完成后再配置读写分离

    1、读写分离拓扑图

    2、实验思路

    客户端访问代理服务器

    代理服务器写入主服务器

    主服务器将增删改改写入自己二进制日志

    从服务器将主服务器的二进制日志同步至自己中继日志

    从服务器重放中继日志到数据库中

    客户端读，则代理服务器直接访问从服务器

    降低负载，起到负载均衡的作用

    3、环境准备

    主机IP地址
    Master192.168.130.15
    Slave1192.168.130.200
    Slave2192.168.130.201
    Amoeba192.168.130.10

    实验前需要将四台服务器防火墙关闭

    1. systemctl stop firewalld
    2. systemctl disable firewalld
    3. setenforce 0

    4、jdk环境安装

    做读写分离实验卡按必须有一主两从环境

    Ameoba服务是基于jdk1.5开发的，所以要使用jdk1.5或1.6版本，不建议使用高版本

    1. cp jdk-6u14-linux-x64.bin /usr/local
    2. cd /usr/local
    3. chmod +x jdk-6u14-linux-x64.bin
    4. ./jdk-6u14-linux-x64.bin #安装jdk

     这样就表示安装完成了

    mv jdk1.6.0_14  jdk1.6  #为jdk文件改名

     配置jdk环境变量 

    1. vim /etc/profile
    2.  
    3. export JAVA_HOME=/usr/local/jdk1.6
    4. export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
    5. export PATH=:$JAVA_HOME/lib:$JAVA_HOME/jre/bin:$PATH:$HOME/bin
    6.  
    7. ##下面两条是配置amoeba服务的，一起写入
    8. export AMOEBA_HOME=/usr/local/amoeba
    9. export PATH=$PATH:$AMOEBA_HOME/bin

    1. source /etc/profile  #刷新环境变量
    2. java -version  #查看刷新后的版本

    5、安装Amoeba软件

    这里提前准备好了amoeba的tar包

    1. mkdir /usr/local/amoeba
    2. tar -zxvf amoeba-mysql-binary-2.2.0.tar.gz -C /usr/local/amoeba
    3. chmod -R 755 /usr/local/amoeba/  #为amoeba目录赋权，让其他主机文件也能访问
    4.  
    5. #测试
    6. /usr/local/amoeba/bin/amoeba
    7. #如果显示amoeba start|stop则成功安装

     6、配置Amoeba读写分离，两个slave读负载均衡 

    配置前需要给Master、Slave1和Slave2的MySQL上开放权限给Amoeba访问

    1. grant all on *.* to 'amoeba'@'192.168.130.%' identified by '123456';
    2. flush privileges;  #刷新

     7、配置Ammoeba 

    修改全局配置文件

    1. #备份配置文件
    2. cd /usr/local/amoeba/conf
    3. cp amoeba.xml amoeba.xml.bak
    4. cp dbServers.xml dbServers.xml.bak

    1. vim amoeba.xml   #修改配置文件
    2.  
    3. #这里只要修改30行和115行那块的内容，下图有标

    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.  
    13.                         <!-- bind ipAddress -->
    14.                         <!-- 
    15.                         <property name="ipAddress">127.0.0.1</property>
    16.                          -->
    17.  
    18.                         <property name="manager">${clientConnectioneManager}</property>
    19.  
    20.                         <property name="connectionFactory">
    21.                                 <bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory">
    22.                                         <property name="sendBufferSize">128</property>
    23.                                         <property name="receiveBufferSize">64</property>
    24.                                 </bean>
    25.                         </property>
    26.  
    27.                         <property name="authenticator">
    28.                                 <bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">
    29.  
    30.                                         <property name="user">amoeba</property>
    31.  
    32.                                         <property name="password">123456</property>
    33.  
    34.                                         <property name="filter">
    35.                                                 <bean class="com.meidusa.amoeba.server.IPAccessController">
    36.                                                         <property name="ipFile">${amoeba.home}/conf/access_list.conf</property>
    37.                                                 </bean>
    38.                                         </property>
    39.                                 </bean>
    40.                         </property>
    41.  
    42.                 </service>
    43.  
    44.                 <!-- server class must implements com.meidusa.amoeba.service.Service -->
    45.                 <service name="Amoeba Monitor Server" class="com.meidusa.amoeba.monitor.MonitorServer">
    46.                         <!-- port -->
    47.                         <!--  default value: random number
    48.                         <property name="port">9066</property>
    49.                         -->
    50.                         <!-- bind ipAddress -->
    51.                         <property name="ipAddress">127.0.0.1</property>
    52.                         <property name="daemon">true</property>
    53.                         <property name="manager">${clientConnectioneManager}</property>
    54.                         <property name="connectionFactory">
    55.                                 <bean class="com.meidusa.amoeba.monitor.net.MonitorClientConnectionFactory"></bean>
    56.                         </property>
    57.  
    58.                 </service>
    59.  
    60.                 <runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext">
    61.                         <!-- proxy server net IO Read thread size -->
    62.                         <property name="readThreadPoolSize">20</property>
    63.  
    64.                         <!-- proxy server client process thread size -->
    65.                         <property name="clientSideThreadPoolSize">30</property>
    66.  
    67.                         <!-- mysql server data packet process thread size -->
    68.                         <property name="serverSideThreadPoolSize">30</property>
    69.  
    70.                         <!-- per connection cache prepared statement size  -->
    71.                         <property name="statementCacheSize">500</property>
    72.  
    73.                         <!-- query timeout( default: 60 second , TimeUnit:second) -->
    74.                         <property name="queryTimeout">60</property>
    75.                 </runtime>
    76.  
    77.         </proxy>
    78.  
    79.         <!-- 
    80.                 Each ConnectionManager will start as thread
    81.                 manager responsible for the Connection IO read , Death Detection
    82.         -->
    83.         <connectionManagerList>
    84.                 <connectionManager name="clientConnectioneManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper">
    85.                         <property name="subManagerClassName">com.meidusa.amoeba.net.ConnectionManager</property>
    86.                         <!-- 
    87.                           default value is avaliable Processors 
    88.                         <property name="processors">5</property>
    89.                          -->
    90.                 </connectionManager>
    91.                 <connectionManager name="defaultManager" class="com.meidusa.amoeba.net.MultiConnectionManagerWrapper">
    92.                         <property name="subManagerClassName">com.meidusa.amoeba.net.AuthingableConnectionManager</property>
    93.  
    94.                         <!-- 
    95.                           default value is avaliable Processors 
    96.                         <property name="processors">5</property>
    97.                          -->
    98.                 </connectionManager>
    99.         </connectionManagerList>
    100.  
    101.                 <!-- default using file loader -->
    102.         <dbServerLoader class="com.meidusa.amoeba.context.DBServerConfigFileLoader">
    103.                 <property name="configFile">${amoeba.home}/conf/dbServers.xml</property>
    104.         </dbServerLoader>
    105.  
    106.         <queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">
    107.                 <property name="ruleLoader">
    108.                         <bean class="com.meidusa.amoeba.route.TableRuleFileLoader">
    109.                                 <property name="ruleFile">${amoeba.home}/conf/rule.xml</property>
    110.                                 <property name="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property>
    111.                         </bean>
    112.                 </property>
    113.                 <property name="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property>
    114.                 <property name="LRUMapSize">1500</property>
    115.                 <property name="defaultPool">master</property>
    116.  
    117.  
    118.                 <property name="writePool">master</property>
    119.                 <property name="readPool">slaves</property>
    120.  
    121.                 <property name="needParse">true</property>
    122.         </queryRouter>
    123. </amoeba:configuration>

     修改另一个数据库配置文件 

    vim dbServers.xml

     

    1. #完整配置文件
    2.  
    3. <?xml version="1.0" encoding="gbk"?>
    4.  
    5. <!DOCTYPE amoeba:dbServers SYSTEM "dbserver.dtd">
    6. <amoeba:dbServers xmlns:amoeba="http://amoeba.meidusa.com/">
    7.  
    8.                 <!-- 
    9.                         Each dbServer needs to be configured into a Pool,
    10.                         If you need to configure multiple dbServer with load balancing that can be simplified by the following configuration:
    11.                          add attribute with name virtual = "true" in dbServer, but the configuration does not allow the element with name factoryConfig
    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">amoeba</property>
    29.  
    30.                         <!--  mysql password -->
    31.                         <property name="password">123456</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="testOnReturn">true</property>
    43.                         <property name="testWhileIdle">true</property>
    44.                 </poolConfig>
    45.         </dbServer>
    46.  
    47.         <dbServer name="master"  parent="abstractServer">
    48.                 <factoryConfig>
    49.                         <!-- mysql ip -->
    50.                         <property name="ipAddress">192.168.130.15</property>
    51.                 </factoryConfig>
    52.         </dbServer>
    53.  
    54.         <dbServer name="slave1"  parent="abstractServer">
    55.                 <factoryConfig>
    56.                         <!-- mysql ip -->
    57.                         <property name="ipAddress">192.168.130.200</property>
    58.                 </factoryConfig>
    59.         </dbServer>
    60.  
    61.         <dbServer name="slave2"  parent="abstractServer">
    62.                 <factoryConfig>
    63.                         <!-- mysql ip -->
    64.                         <property name="ipAddress">192.168.130.201</property>
    65.                 </factoryConfig>
    66.         </dbServer>
    67.  
    68.         <dbServer name="slaves" virtual="true">
    69.                 <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">
    70.                         <!-- Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
    71.                         <property name="loadbalance">1</property>
    72.  
    73.                         <!-- Separated by commas,such as: server1,server2,server1 -->
    74.                         <property name="poolNames">slave1,slave2</property>
    75.                 </poolConfig>
    76.         </dbServer>
    77.  
    78. </amoeba:dbServers>

    启动amoeba服务 

    /usr/local/amoeba/bin/amoeba start & #后台启动

    netstat -napt | grep java  #查看端口

    代表amoeba服务成功启动了

    8、客户端测试读写分离功能

    这里的测试端我们另起了一台服务器192.168.130.102

    1. #安装mariadb
    2. yum install mariadb  -y
    3.  
    4.  
    5. #远程登陆amoeba服务器
    6. mysql -uamoeba -p123456 -h 192.1168.130.10 -P8066

    出现的报错

    amoeba服务端的报错

    1. java.lang.Exception: poolName=slaves, no valid pools
    2. 	at com.meidusa.amoeba.net.poolable.MultipleLoadBalanceObjectPool.borrowObject(MultipleLoadBalanceObjectPool.java:183)
    3. 	at com.meidusa.amoeba.mysql.handler.CommandMessageHandler.startSession(CommandMessageHandler.java:633)
    4. 	at com.meidusa.amoeba.mysql.handler.MySqlCommandDispatcher.handleMessage(MySqlCommandDispatcher.java:123)
    5. ......

    原因：

    amoeba的数据库文件第23行，这里默认对应的MySQL库为text，我这里使用的MySQL版本为5.7版本，默认的库为mysql，所以找不到默认的库，我之前搭建的MySQL版本是5.5是不需要修改的，没注意到这一点

    所以我们去修改一下就行

    vim /usr/local/amoeba/conf/dbServers.xml

    重启一下就行

     

    测试一：主从数据库是否可以同步

    在客户端中新建表然后去主数据库查看是否同步

    1. MySQL [(none)]> show databases;
    2. +--------------------+
    3. | Database           |
    4. +--------------------+
    5. | information_schema |
    6. | mysql              |
    7. | performance_schema |
    8. | sys                |
    9. | yy                 |
    10. +--------------------+
    11. 5 rows in set (0.00 sec)
    12.  
    13. MySQL [(none)]> use yy
    14. No connection. Trying to reconnect...
    15. Connection id:    2010296347
    16. Current database: *** NONE ***
    17.  
    18. Database changed
    19. MySQL [yy]> show tables;   #这时的yy库中没有任何东西
    20. Empty set (0.01 sec)
    21.  
    22. MySQL [yy]> create table info(id int(3));   #我们给它创建一个info表
    23. Query OK, 0 rows affected (0.01 sec)
    24.  
    25. MySQL [yy]> show tables;    #查看一下
    26. +--------------+
    27. | Tables_in_yy |
    28. +--------------+
    29. | info         |
    30. +--------------+
    31. 1 row in set (0.00 sec)

    再去主服务器查看

     

    创建成功了 ，这里证明通过代理可以连入数据库

    测试二：读写分离

    我们先将两台从服务器的同步关掉

    1. #进入数据库
    2. stop slave;

    两台同步全关了

    1. #客户端
    2. show tables;
    3. insert into info values(5); #插入一条数据
    4. select * from info;

     

    当我们将从服务器同步打开

    start slave;

     

    然后再看客户端

    因为我们读的话只会读取从服务器，主服务器只作为写，这里真正展示了读写的区别 

    测试三：是否为轮询查询

    我们关闭slave2的同步

     

    在客户端添加一条数据，然后查看 

  • 相关阅读:
    吐血整理，Jmeter服务端性能测试-线程阻塞问题案例分析（超细）
    8 张图 | 剖析 Eureka 的首次同步注册表
    dot product【点积】
    Go 语言高级网络编程
    Python复习知识点（一）
    K8S基础笔记
    Jupyter部署和使用教程
    【leetcode】【初级算法】【链表3】反转链表
    猿创征文 | 组件的定义及复用性，局部组件和全局组件（1）
    XSAN数据恢复-存储空间架构迁移时误格式化存储系统的XSAN数据恢复案例
  • 原文地址：https://blog.csdn.net/liji133122/article/details/127061893