mysql数据业务垂直+水平分割+主从复制读写分离

友情提示:本人第一次写技术博客,会继续完善,尽量做到图文并茂,通俗易懂,如果有什么写的不好的地方,还请大家多多提意见,您的意见将是我宝贵的资源。如果有兴趣的话,还可以一起讨论相关技术哦,亲!一定要注意软件版本哦!

联系方式 QQ:794884160

指导老师:双星  冯德勇老师  曾勇老师

一、拓扑图:

垂直+水平分割+主从复制+读写分离完整原理图:

仅说明原理,详细拓扑及参数参考本次实验拓扑图

本次试验拓扑图:(上图左侧部分)

二、实验描述:

根据业务原型先进行数据库垂直切割,然后用户数据根据user_id取模360进行水平切割,DB1和DB2创建相同的表结构。0-179存储到DB1,179-359存储到DB2上,其他博客、空间的那个放在其它数据库上,本次只做用户数据。DB1、DB2都采用主从读写分离架构,实现数据冗余和性能优化,实现较大用户承载量。

DB1-master: 10.0.8.18/16        插入记录user_id % 360 <=179
   DB1-slave: 10.0.8.28/16
   DB1-amoeba: 10.0.8.38/16
   DB2-master: 10.0.8.48/16        插入记录user_id % 360 >170
   DB2-slave: 10.0.8.58/16
   DB2-amoeba: 10.0.8.68/16
   split-amoeba: 10.0.8.78/16
  注意:所有机器关闭selinux和iptables

三、实验过程:
1.环境搭建
1.1DB1和DB2的master、slave都安装mysql5.1.50
创建mysql目录并授权
#useradd -s /sbin/nologin -M mysql
#mkdir -p /data/dbdata
#mkdir -p /usr/local/mysql/tmp/
#chown -R mysql:mysql /usr/local/services/mysql
#chown -R mysql:mysql /data/dbdata
#chown -R mysql:mysql /usr/local/mysql

编译安装mysql源码包
#tar xvf mysql-5.1.50.tar.gz
#cd mysql-5.1.50
#./configure ‘--prefix=/usr/local/services/mysql‘‘--localstatedir=/data/dbdata‘‘--with-unix-socket-path=/usr/local/mysql/tmp/mysql.sock‘ ‘--with-charset=utf8‘‘--with-extra-charsets=complex‘ ‘--with-pthread‘ ‘--enable-thread-safe-client‘‘--with-ssl‘ ‘--with-client-ldflags=-all-static‘ ‘--with-mysqld-ldflags=-all-static‘‘--with-plugins=partition,federated,ndbcluster,innobase,csv,blackhole,myisam,innodb_plugin,heap,archive‘‘--enable-shared‘ ‘--enable-assembler‘
# make && make install

初始化mysql
#/usr/local/services/mysql/bin/mysql_install_db --user=mysql--basedir=/usr/local/services/mysql --datadir=/data/dbdata
# cp /usr/local/services/mysql/share/mysql/mysql.server /etc/init.d/mysqld
# chmod 755 /etc/init.d/mysqld
# vim /etc/init.d/mysqld 修改mysql启动脚本,设置数据库目录和安装目录
basedir=/usr/local/services/mysql
datadir=/data/dbdata

修改mysql配置文件
#vim /etc/my.cnf
配置文件在附件中给出,直接覆盖/etc/my.cnf

innodb_buffer_pool_size = 8G

根据服务器内存修改,否者起不来

设置环境变量和启动服务
#vim /etc/profile 修改profile文件,将mysql脚本路径添加到环境变量中去
MYSQL=/usr/local/services/mysql/bin
PATH=$PATH:$MYSQL
export PATH
#source /etc/profile 使环境变量设置生效
#/etc/init.d/mysqld start 启动服务

1.2三台amoeba服务器都安装jdk1.7.1_40和amoeba
解压jdk文件
# mkdir /java
# tar -xvf jdk-7u40-linux-x64.tar.gz -C /java

将jdk路径写到环境变量中去
# vim /etc/profile
JAVA_HOME=/java/jdk1.7.0_40
export JAVA_HOME

PATH=$JAVA_HOME/bin:$PATH
export PATH

CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:$CLASSPATH
export CLASSPATH
#source /etc/profile

测试是否已经有JAVA环境
# java -version
java version "1.7.0_40"
Java(TM) SE Runtime Environment (build 1.7.0_40-b43)
Java HotSpot(TM) 64-Bit Server VM (build 24.0-b56, mixed mode)

安装Amoeba
# unzip amoeba-mysql-1.3.1-BETA.zip -d /usr/local/amoeba/
# chmod -R +x /usr/local/amoeba/bin/

安装mysql客户端
#yum install mysql -y

2.配置主从复制读写分离架构
 2.1在两台master上操作:

修改配置文件my.cnf
#vim /etc/my.cnf
首先将bin-log日志打开
log-bin=mysql-bin
其次将server-id设置为1,默认为1
server-id=1
将log-slave-updates给关闭掉,默认为关闭

修改后重启服务
#/etc/init.d/mysqld restart

登陆数据库,创建主从复制读写分离用户并授权
#mysql
安装好后默认以root账户登录,没有密码,登陆之后用set password=password(‘密码‘)修改,也可以用mysqladmin -uroot-p password ‘密码‘修改
>create user ‘amoeba‘@‘%‘ identified by ‘amoeba‘; 创建amoeba用户,密码为amoeba
>grant all privileges on *.* to ‘amoeba‘@‘%‘ identified by ‘amoeba‘; 给amoeba用户授予整个数据库完整权限针对所有ip开放。
>grant replication slave on *.* to ‘amoeba‘@‘10.0.8.28‘ identified by‘amoeba‘; 给slave服务器授予整个数据库复制权限,IP为从服务器IP
>flush privileges; 刷新权限
>show master status \G; 查看master状态,二进制日志文件名和postion值用于slave服务器配置

2.2在两台slave服务器上操作

修改配置文件my.cnf
首先将bin-log日志打开
其次将server-id设置为2
去掉log-slave-updates前的#

修改好后重启服务
#/etc/init.d/mysqld restart

登陆数据库,创建主从复制读写分离用户并授权
#mysql
安装好后默认以root账户登录,没有密码,登陆之后用set password=password(‘密码‘)修改,也可以用mysqladmin -uroot-p password ‘密码‘修改
>create user ‘amoeba‘@‘%‘ identified by ‘amoeba‘; 创建amoeba用户,密码为amoeba
>grant all privileges on *.* to ‘amoeba‘@‘%‘ identified by ‘amoeba‘; 给amoeba用户授予整个数据库完整权限针对所有ip开放。
>flush privileges; 刷新权限
>stop slave;
>change master tomaster_host=‘10.0.8.18‘,master_user=‘amoeba‘,master_password=‘amoeba‘,master_log_file=‘mysql-bin.0000005‘,master_log_pos=4043;
>start slave;
>show slave status\G; 查看slave状态,IO线程和SQL线程状态都为yes则表示主从复制已经开启成功

主从复制测试
在master上创建一个库为amoeba
>create database amoeba;
在slave上会自动生成一个amoeba库

2.3在两台amoeba读写分离调度器上操作

修改amoeba配置文件amoeba.xml,从上至下
#vim /usr/local/amoeba/conf/amoeba.xml

①修改第一部分本机mysql登陆配置:
================================================
       <!-- proxy server绑定的端口 -->
       <property name="port">8066</property>

<!-- proxy server绑定的IP -->

<property name="ipAddress">10.0.8.38</property> #另一台为10.0.8.68

<!-- proxy server net IO Read thread size -->
       <property name="readThreadPoolSize">20</property>

<!-- proxy server client process thread size -->
       <property name="clientSideThreadPoolSize">30</property>

<!-- mysql server data packet process thread size -->
       <property name="serverSideThreadPoolSize">30</property>

<!-- socket Send and receive BufferSize(unit:K) -->
       <property name="netBufferSize">128</property>

<!-- Enable/disable TCP_NODELAY (disable/enable Nagle‘s algorithm). -->
       <property name="tcpNoDelay">true</property>

<!-- 对外验证的用户名 -->
       <property name="user">root</property>

<!-- 对外验证的密码 -->

<property name="password">aixocm</property> #这里的密码可以任意指定,用来进行读写分离登陆

==================================================
②修改第二部分:amoeba登陆主从服务器配置
==================================================
   <dbServer name="server1">

<!-- PoolableObjectFactory实现类 -->
       <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
           <property name="manager">defaultManager</property>

<!-- 真实mysql数据库端口 -->
           <property name="port">3306</property>

<!-- 真实mysql数据库IP -->
           <property name="ipAddress">10.0.8.18</property> #另一台amoeba上为10.0.8.48
           <!--这里的test依赖数据库中的test库-->
           <property name="schema">test</property>

<!-- 用于登陆mysql的用户名 -->
           <property name="user">amoeba</property>

<!-- 用于登陆mysql的密码 -->

<property name="password">amoeba</property>

</factoryConfig>

<!-- ObjectPool实现类 -->
       <poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
       <property name="maxActive">200</property>
       <property name="maxIdle">200</property>
       <property name="minIdle">10</property>
       <propertyname="minEvictableIdleTimeMillis">600000</property>
       <property name="timeBetweenEvictionRunsMillis">600000</property>
       <property name="testOnBorrow">true</property>
       <property name="testWhileIdle">true</property>
       </poolConfig>
   </dbServer>

<dbServer name="server2">

<!-- PoolableObjectFactory实现类 -->
       <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
           <property name="manager">defaultManager</property>

<!-- 真实mysql数据库端口 -->
           <property name="port">3306</property>

<!-- 真实mysql数据库IP -->
           <property name="ipAddress">10.0.8.28</property> #另一台amoeba上为10.0.8.58
           <!--这里的test依赖数据库中的test库-->
           <property name="schema">test</property>

<!-- 用于登陆mysql的用户名 -->
           <property name="user">amoeba</property>
           <!-- 用于登陆mysql的密码 -->
           <property name="password">amoeba</property>

</factoryConfig>

<!-- ObjectPool实现类 -->
       <poolConfig class="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
           <property name="maxActive">200</property>
           <property name="maxIdle">200</property>
           <property name="minIdle">10</property>
           <propertyname="minEvictableIdleTimeMillis">600000</property>
           <property name="timeBetweenEvictionRunsMillis">600000</property>
           <property name="testOnBorrow">true</property>
           <property name="testWhileIdle">true</property>
       </poolConfig>
   </dbServer>
=====================================================
③修改的第三部分:负载均衡池
=====================================================
<dbServer name="master" virtual="true">
       <poolConfigclass="com.meidusa.amoeba.server.MultipleServerPool">
           <!-- 负载均衡参数 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
           <property name="loadbalance">1</property>

<!-- 参与该pool负载均衡的poolName列表以逗号分割 -->
           <property name="poolNames">server1</property>
       </poolConfig>
   </dbServer>

<dbServer name="slave" virtual="true">
       <poolConfigclass="com.meidusa.amoeba.server.MultipleServerPool">
           <!-- 负载均衡参数 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
           <property name="loadbalance">1</property>

<!-- 参与该pool负载均衡的poolName列表以逗号分割 -->
<propertyname="poolNames">server1,server2</property>
       </poolConfig>
   </dbServer>

读主从的比例默认为1:1,可以进行读权重配置,如server1,server2,server2,server2,server2,这样读4次从服务器,
读一次主服务器,只写主服务器。读主从的比例为变为1:4。
=======================================================

④修改的第四部分: 配置master和slave的读写分离
=======================================================
   <queryRouterclass="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">
       <propertyname="ruleConfig">${amoeba.home}/conf/rule.xml</property>
       <propertyname="functionConfig">${amoeba.home}/conf/functionMap.xml</property>
   <propertyname="ruleFunctionConfig">${amoeba.home}/conf/ruleFunctionMap.xml</property>
       <property name="LRUMapSize">1500</property>
       <!-- 配置master和slave读写分离 Begin-->
       <property name="defaultPool">master</property>
       <property name="writePool">master</property>
       <property name="readPool">slave</property>
       <!-- 配置master和slave读写分离 End-->
       <property name="needParse">true</property>
       </queryRouter>
=======================================================

修改Amoeba启动脚本
# vim /usr/local/amoeba/bin/amoeba
#DEFAULT_OPTS="-server -Xms256m -Xmx256m -Xss128k" 将此行注释掉,增加一下行
DEFAULT_OPTS="-server -Xms256m -Xmx256m -Xss256k" 增加这一行

运行amoeba脚本
#cd /usr/local/amoeba/bin
#nohup bash -x amoeba & 后台运行amoeba并且记录日志到nohup.out

测试读写分离
在两台master上的amoeba库下创建一个amo表
>use amoeba;
>create table amo(
>user_id int not null unique,
>user_name varchar(45),
>user_address varchar(100),
>primary key(user_id)
>)engine=innodb;

在master和slave上分别插入一条不同记录
master端: >insert into amo(user_id,user_name,user_address)values(1,‘master‘,‘china‘);
slave端: >insert into amo(user_id,user_name,user_address)values(2,‘slave‘,‘china‘);

在amoeba上进行读写测试
select * from amo 会看到先后两次不同的记录
inset into amo(user_id,user_name,user_address) values(3,‘amoeba‘,‘china‘); 会写到master上然后同步到slave上

3.数据库切割
在amoeba切分器上操作

1.修改配置文件amoeba.xml,从上至下
#vim /usr/local/amoeba/conf/amoeba.xml

①修改的第一部分:本机mysql登陆配置
==============================================================
       <!-- proxy server绑定的端口 -->
       <property name="port">8066</property>

<!-- proxy server绑定的IP -->

<property name="ipAddress">10.0.8.78</property>

<!-- proxy server net IO Read thread size -->
       <property name="readThreadPoolSize">20</property>

<!-- proxy server client process thread size -->
       <property name="clientSideThreadPoolSize">30</property>

<!-- mysql server data packet process thread size -->
       <property name="serverSideThreadPoolSize">30</property>

<!-- socket Send and receive BufferSize(unit:K) -->
       <property name="netBufferSize">128</property>

<!-- Enable/disable TCP_NODELAY (disable/enable Nagle‘s algorithm). -->
       <property name="tcpNoDelay">true</property>

<!-- 对外验证的用户名 -->
       <property name="user">root</property>

<!-- 对外验证的密码 -->
       <property name="password">aixocm</property> #这里的密码可以任意指定,用来进行读写分离登陆最好统一

=============================================================
②修改的第二部分:amoeba读写分离调度器配置
=============================================================
   <dbServer name="server1">

<!-- PoolableObjectFactory实现类 -->
       <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
           <property name="manager">defaultManager</property>

<!-- 真实mysql数据库端口 -->
<property name="port">8066</property> #这里要填写amoeba1配置文件第一部分的端口号,因为ip不同,所以不冲突

<!-- 真实mysql数据库IP -->
           <property name="ipAddress">10.0.8.38</property>
           <!--这里的test依赖数据库中的test库-->
           <property name="schema">test</property>

<!-- 用于登陆mysql的用户名 -->
           <property name="user">root</property> #这里要填写amoeba1配置文件第一部分配置的用户和密码

<!-- 用于登陆mysql的密码 -->

<property name="password">aixocm</property>

</factoryConfig>

<!-- ObjectPool实现类 -->
           <poolConfigclass="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
               <property name="maxActive">200</property>
               <property name="maxIdle">200</property>
               <property name="minIdle">10</property>
               <property name="minEvictableIdleTimeMillis">600000</property>
               <propertyname="timeBetweenEvictionRunsMillis">600000</property>
               <property name="testOnBorrow">true</property>
               <property name="testWhileIdle">true</property>
           </poolConfig>
       </dbServer>

<dbServer name="server2">

<!-- PoolableObjectFactory实现类 -->
       <factoryConfigclass="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory">
       <property name="manager">defaultManager</property>

<!-- 真实mysql数据库端口 -->
<property name="port">8066</property>

<!-- 真实mysql数据库IP -->
       <property name="ipAddress">10.0.8.68</property>
       <!--这里的test依赖数据库中的test库-->
       <property name="schema">test</property>

<!-- 用于登陆mysql的用户名 -->
       <property name="user">amoeba</property>
       <!-- 用于登陆mysql的密码 -->
<property name="password">amoeba</property>

</factoryConfig>

<!-- ObjectPool实现类 -->
        <poolConfigclass="com.meidusa.amoeba.net.poolable.PoolableObjectPool">
           <property name="maxActive">200</property>
           <property name="maxIdle">200</property>
           <property name="minIdle">10</property>
           <property name="minEvictableIdleTimeMillis">600000</property>
           <propertyname="timeBetweenEvictionRunsMillis">600000</property>
           <property name="testOnBorrow">true</property>
           <property name="testWhileIdle">true</property>
       </poolConfig>
   </dbServer>
================================================================
③修改的第三部分:去掉负载均衡池,或者注释掉
================================================================
   <!-- <dbServer name="multipool" virtual="true">
   <poolConfigclass="com.meidusa.amoeba.server.MultipleServerPool">
   <!-- 负载均衡参数 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->
   <property name="loadbalance">1</property>

<!-- 参与该pool负载均衡的poolName列表以逗号分割 -->
   <property name="poolNames">server1</property>
   </poolConfig>
   </dbServer>
   -->
=================================================================

2.修改切割规则配置文件
#vim /usr/local/amoeba/conf/rule.xml
<tableRule name="amo" schema="amoeba"defaultPools="server1,server2">

name后为表名,schema后为库名

如上图user_id % 360 0到179的记录插入DB1-master,user_id % 360 在180到359的记录插入到DB2-master中

3.修改amoeba启动脚本
# vim /usr/local/amoeba/bin/amoeba
#DEFAULT_OPTS="-server -Xms256m -Xmx256m -Xss128k" 将此行注释掉,增加一下行
DEFAULT_OPTS="-server -Xms256m -Xmx256m -Xss256k" 增加这一行

4.启动amoeba
#nohup bash -x /usr/local/amoeba/bin/amoeba &

5.数据切割测试
amoeba切分器端操作
>use amoeba;
主语要采用标准插入语句
>insert into amo(user_id,uesr_name,user_address) values(177,‘user‘,‘china‘);
>insert into amo(user_id,uesr_name,user_address) values(178,‘user‘,‘china‘);
>insert into amo(user_id,uesr_name,user_address) values(179,‘user‘,‘china‘);
>insert into amo(user_id,uesr_name,user_address) values(180,‘user‘,‘china‘);
>insert into amo(user_id,uesr_name,user_address) values(181,‘user‘,‘china‘);
>insert into amo(user_id,uesr_name,user_address) values(182,‘user‘,‘china‘);
>insert into amo(user_id,uesr_name,user_address) values(359,‘user‘,‘china‘);
>insert into amo(user_id,uesr_name,user_address) values(360,‘user‘,‘china‘);
master、slave端查看效果,看是否切分成功

6.读写分离测试
在两台slave端分别插入一条记录
然后在amoeba切分器上用select语句查看效果,两次运行select语句结果分别是两台slave的记录和两台master的记录

amoeba切分器进行数据切割时,调用amoeba读写分离服务器进行读写分离,所以amoeba切分器中的server1和server2分别指定的是
amoeba1和amoeba2的ip和8066端口,而不是DB1和DB2的IP登录用户也是amoeba1和amoeba2配置文件第一部分配置的用户和密码

真实生产环境下,amoeba切割器可以用软件实现,利用软件进行切割

mysql数据业务垂直+水平分割+主从复制读写分离

时间: 05-14

mysql数据业务垂直+水平分割+主从复制读写分离的相关文章

mysql主从复制读写分离-Altas

mysql主从复制读写分离 本文读写分离使用的软件是Altas,altas是奇虎360公司开发的开源数据库代理软件.它是基于mysql-proxy开发而成的 它集中地响应应用的请求,依据用户事先设置的规则,将SQL请求发送到特定的数据库上执行.基于此可以实现负载均衡.读写分离.高可用性等需求. mysql读写分离原理: 数据库层在高并发的情况下,i/o会产生瓶颈.而实际上用户读的请求要远远大于写的请求. 使用代理服务作为数据库前端,将不同的请求根据规则分配到不同的后端数据上面去,比如将写的请求分

【实战】Amoeba 代理 MySQL 主从复制 + 读写分离 【提供源码包】

目录简介: 1· Amoeba 的介绍2· MySQL 主从复制原理3· MySQL 读写分离原理4· 实战案例5· 总结归纳 Amoeba 的介绍 1)Amoeba 是什么: 1·Amoeba 的中文名是:变形虫.它是一个以MySQL为底层数据存储,并对应用提供MySQL协议接口的proxy.它集中地响应应用的请求,依据用户事先设置的规则,将SQL请求发送到特定的数据库上执行.基于此可以实现负载均衡.读写分离.高可用性等需求. 2·Amoeba相当于一个SQL请求的路由器,目的是为负载均衡.读

Mysql的主从复制读写分离--简单篇

Mysql基础拓扑图: Mysql环境准备: 一台mysql主服务器(安装mysql) 两台mysql从服务器(安装mysql) 一台mysql代理(安装amoeba和java) 一台mysql客户端(mysql客户端) 部署前先关闭所有的iptables,selinux Mysql的主从复制读写分离所需安装包: cmake-2.8.6.tar.gz mysql-5.5.22.tar.gz amoeba-mysql-binary-2.2.0.tar.gz jdk-7u65-linux-x64.t

mysql主从复制读写分离之——proxysql应用

一.说明ProxySQL是一个开源的MySQL代理服务器,这意味着它充当MySQL服务器和访问其数据库的应用程序之间的中介.ProxySQL可以通过在多个数据库服务器池之间分配流量来提高性能,并且如果一个或多个数据库服务器发生故障,还可以通过自动故障切换到备用数据库来提高可用性. 系统环境:master1:ubuntu16.04 mysql5.6 192.168.1.10 3307 master2:ubuntu16.04 mysql5.6 192.168.1.20 3307slave1: ubu

mysql主从复制-读写分离

mysql5.6版本: mysql的主从复制环境构建故障恢复 基于GTID的mysql中从复制 使用atlas实现读写分离 文章下载包地址: 链接:https://pan.baidu.com/s/1ht1y9HnqcfrDdWuPHUq_gg 提取码:cxql 原文地址:https://www.cnblogs.com/myself-technology-summary/p/10859878.html

Mysql + keepalived 实现双主热备读写分离【转】

Mysql + keepalived 实现双主热备读写分离 2013年6月16日frankwong发表评论阅读评论 架构图 系统:CentOS6.4_X86_64软件版本:Mysql-5.6.12,Keepalived-1.2.7环境简介:1.Master-A 192.168.1.168 (Mysql+Keepalived)2.Master-B 192.168.1.169 (Mysql+Keepalived)3.写入VIP 192.168.100 (168主,169从)4.读取VIP 192.1

mysql主从复制读写分离

一.环境 1.主服务器操作系统:Mac OS MySQL版本:5.1.6 2.从服务器操作系统:Centos 6.5 MySQL版本:5.1.6 二.实战 2.1MySQL主从复制,读写分离示意图 MySQL 复制的工作方式很简单,一台服务器作为主机,一台或多台服务器作为从机.主机会把数据库的变化记录到日志.一旦这些变化被记录到日志,就会立刻(或者以设定的时间间隔)被送到从机. 2.2 主服务器IP:172.16.151.1 从服务器IP:172.16.151.130 在两台服务器分别安装好My

数据库---mysql主从复制读写分离

http://m.open-open.com/m/lib/view/1413274853450.html 原理及架构分析 部署前准备 下载好源码包存放位置要与脚本中对应 mysql-5.5.22.tar.gz,cmake-2.8.6.tar.gz,amoeba-mysql-binary-2.2.0.tar.gz,jdk-6u14-linux-x64.bin selinux和iptables不做设置,关闭 系统光盘镜像为本地yum源,配置好yum文件 环境介绍: 主服务器(master):192.

mysql主从复制+读写分离 菜鸟入门

MYsql主从复制 1.mysql主从复制原理: Master将数据变化记录到二进制日志中[binary log] Slave将master的二进制日志[binary log]拷贝到自己的中继日志[relay log]中. Slave将中继入日志[relay log]事件在做一次,将数据变化,反应到自身数据库. 简述:mysql主从复制其实就是完全备份,和二进制日志备份还原的过程.二进制日志的还原基本上是实时进行的.注意不是完全实时,而是异步实时,主从直接的执行有延迟.如果master压力过大,