mysql主从复制、双主双从、读写分离以及分库分表

偏执的太偏执、 2022-10-22 04:12 187阅读 0赞

这边已安装好mysql版本为5.7、jdk等

一、环境准备  
1.1 准备2台服务器，一台为主一台为从  
二、一主一丛  
2.1 在主服务器节点上修改/etc/my.cnf的文件增加如下命令  
\*\*注意：\*\*在我的环境中必须把增加的命令放在mysqld下方、否则会报异常、原因不详！！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70]

#mysql服务唯一id，不同的mysql服务必须拥有全局唯一的id
    server-id=1   //这里有个小插曲！后面描述
    #启动二进制日志
    log-bin=mysql-bin
    #设置不要复制的数据库
    binlog-ignore-db=mysql
    binlog-ignore-db=information-schema
    #设置需要复制的数据库
    binlog-do-db=msb
    #设置binlog的格式
    binlog_format=statement

2.2 在从服务器节点上修改/etc/my.cnf文件

#服务器唯一id
    server-id=2
    #启动中继日志
    relay-log=mysql-relay

2.3 重新启动mysql服务 service mysql restart;

2.4 在主服务器上创建账户并授权slave(从服务器)

grant replication slave on *.* to 'root'@'%' identified by '666666';
    --在进行授权的时候，如果提示密码的问题，把密码验证取消
    set global validate_password_policy=0;
    set global validate_password_length=1;

2.5 查看master的状态

show master status

![在这里插入图片描述][20210403165910911.png]

2.6 在从服务器上配置需要复制的主机

CHANGE MASTER TO MASTER_HOST='10.0.0.130',master_port=33306,MASTER_USER='root',
    MASTER_PASSWORD='666666',MASTER_LOG_FILE='mysql-bin.000006',MASTER_LOG_POS=522;
    参数介绍
    master_host：主数据库ip
    master_port：主数据库端口
    master_user：连接主数据的用户
    master_password：连接主数据的密码
    master_log_file：主数据的日志文件
    master_log_pos：主数据的日志文件，当前记录的位置

2.7 启动从服务器复制功能

start slave;

2.8 查看从服务器状态

show slave status\G

![在这里插入图片描述][20210403171933392.png]  
果然一切注定不会那么顺利、出问题了。。。。我这完全是照着文档的步骤走的怎么会出问题呢、心里狠狠地说了句 **卧槽**。。  
这个Slave\_IO\_Running: No是怎么回事，在mysql安装目录下

show variables like 'datadir';   登陆mysql输入这个命令可以获取到安装目录

查看到错误日志是这样的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 1]  
英文不太好、不过大概可以猜到是id重复了、可是这怎么会重复呢？当时主服务器server-id=1、从服务器server-id=2明明是这样配置的咋会重复呢？马上在百度上搜了下找到了[这篇文章][Link 1]  
**排查错误**  
1、分别在主从数据库中执行如下sql, 并必读两边的server\_id 是否一样，一样则修改my.cnf设置成不一样：

show variables like '%server_id%';

2、分别在主从数据库中执行如下sql, 并必读两边的server\_uuid 是否一样，如果一样则删除从数据库的数据目录下的auto.cnf：

show variables like '%uuid%';

3、确认主从数据库的数据host是否一样，如果主从数据库的host一样也会报这个错误.

经过排查果然主服务器和从服务器的server-id竟然是一样、原因my.cnf本身就有了server-id=1这个配置了、然后我在配置主服务器和从服务器时又给它加了一个所以导致重复，修改完毕后再次查看主服务器mysql状态

show master status 
    如果状态发生改变从服务器配置时需要同步更改！

登陆从服务器mysql输入命令

reset slave;  //重置从服务器的mysql
    
    CHANGE MASTER TO MASTER_HOST='10.0.0.130',master_port=33306,MASTER_USER='root',
    MASTER_PASSWORD='666666',MASTER_LOG_FILE='mysql-bin.000006',MASTER_LOG_POS=522;  
    
    start slave;  //启动从节点
    show slave status\G   //查看状态

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 2]  
当执行完成之后，会看到两个关键的属性Slave\_IO\_Running，Slave\_SQL\_Running，当这两个属性都是yes的时候，表示主从复制已经准备好了，可以进行具体的操作了

三、一主一从验证  
3.1下面我们通过实际的操作来验证主从复制是否完成

--在主服务器mysql创建数据库
    create database msb;
    --在msb上创建具体的表
    create table mytbl(id int,name varchar(20));
    --在主服务器mysql上插入数据
    insert into mytbl values(1,'zhangsan');
    --在从服务器mysql上验证发现数据已经同步成功，表示主从复制完成

注意如果从服务器存在相同的id且是主键则会插入失败并报错、此时需要重置从服务器进行全量更新！

··**读写分离**  
安装mycat 进入conf目录配置server.xml  
vi server.xml进行如下配置

<?xml version="1.0" encoding="UTF-8"?>
    
    <!DOCTYPE mycat:server SYSTEM "server.dtd">
    <mycat:server xmlns:mycat="http://io.mycat/">
    
            <user name="root">  //mysql用户名
                    <property name="password">666666</property> //mysql密码
                    <property name="schemas">TESTDB</property>  //mycat逻辑库
                    <property name="defaultSchema">TESTDB</property> //默认逻辑库
            </user>
    
    </mycat:server>

配置schema.xml

<?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
            <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
    <table name="test" dataNode="dn1" />
            </schema>
    
            <dataNode name="dn1" dataHost="localhost1" database="msb" />
            <dataHost name="localhost1" maxCon="1000" minCon="10" balance="2"  
                              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                    <heartbeat>select user()</heartbeat>
                    
                    <writeHost host="hostM1" url="10.0.0.130:33306" user="root"
                                       password="666666">
    <readHost host="hostS1" url="10.0.0.131:33306" user="root" password="666666"></readHost>
                    </writeHost>
             </dataHost>
    </mycat:schema>

配置完成后进入bin目录启动mycat

./mycat console            //表示启动mycat并在控制台打印日志

连接mycat

mysql -uroot -p666666 -P 9066 -h 10.0.0.130

插入一条数据测试读写分离

insert into testvalues(2,@@hostname);

进行读测试  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 3]  
发现每次读出来的数据都可能不一样、这说明数据是从不同的服务器均衡的读出来，因为上面在schema.xml中配置了 balance=“2”，这个参数表明：所有读操作都随机的在writehost，readhost上分发。

1、balance=0 :不开启读写分离机制，所有读操作都发送到当前可用的writehost上
    
    		2、balance=1:全部的readhost和stand by writehost参与select 语句的负载均衡，简单的说，当双主双从模式下，其他的节点都参与select语句的负载均衡
    
    		3、balance=2:所有读操作都随机的在writehost，readhost上分发
    
    		4、balance=3:所有读请求随机的分发到readhost执行，writehost不负担读压力

## 双主双从 ##

在此架构中，可以让一台主机用来处理所有写请求，此时，它的从机和备机，以及备机的从机复制所有读请求，当主机宕机之后，另一台主机负责写请求，两台主机互为备机。

准备四台服务器，分别命名为node1(主)、node2(从)、node3(主)、node4(从)

1.  下面开始搭建双主双从  
    修改node1上的/etc/my.cnf文件

#主服务器唯一ID
    server-id=1
    #启用二进制日志
    log-bin=mysql-bin
    # 设置不要复制的数据库(可设置多个)
    binlog-ignore-db=mysql
    binlog-ignore-db=information_schema
    #设置需要复制的数据库
    binlog-do-db=msb
    #设置logbin格式
    binlog_format=STATEMENT
    # 在作为从数据库的时候， 有写入操作也要更新二进制日志文件
    log-slave-updates
    #表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1， 取值范围是1 .. 65535
    auto-increment-increment=2   //不是必须的
    # 表示自增长字段从哪个数开始，指字段一次递增多少，他的取值范围是1 .. 65535
    auto-increment-offset=1   //不是必须的

2、修改node3上的/etc/my.cnf文件

#主服务器唯一ID
    server-id=3
    #启用二进制日志
    log-bin=mysql-bin
    # 设置不要复制的数据库(可设置多个)
    binlog-ignore-db=mysql
    binlog-ignore-db=information_schema
    #设置需要复制的数据库
    binlog-do-db=msb
    #设置logbin格式
    binlog_format=STATEMENT
    # 在作为从数据库的时候，有写入操作也要更新二进制日志文件
    log-slave-updates
    #表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535
    auto-increment-increment=2
    # 表示自增长字段从哪个数开始，指字段一次递增多少，他的取值范围是1 .. 65535
    auto-increment-offset=2

3、修改node2上的/etc/my.cnf文件

#从服务器唯一ID
    server-id=2
    #启用中继日志
    relay-log=mysql-relay

4、修改node4上的/etc/my.cnf文件

#从服务器唯一ID
    server-id=4
    #启用中继日志
    relay-log=mysql-relay

5、所有主机重新启动mysql服务

6、在两台主机node1,node3上授权同步命令

GRANT REPLICATION SLAVE ON *.* TO 'root'@'%' IDENTIFIED BY '666666';
    //这个地方*.* 在生产环境中应为实际的主机ip

7、查看两台主机的状态

show master status;

8、在node2上执行要复制的主机

CHANGE MASTER TO MASTER_HOST='10.0.0.130',MASTER_USER='root',MASTER_PASSWORD='666666',MASTER_PORT=33306,MASTER_LOG_FILE='mysql-bin.000001',MASTER_LOG_POS=522;

9、在node4上执行要复制的主机

CHANGE MASTER TO MASTER_HOST='10.0.0.132',MASTER_USER='root',MASTER_PASSWORD='666666',MASTER_PORT=33306,MASTER_LOG_FILE='mysql-bin.000006',MASTER_LOG_POS=522;

10、启动两个从机的slave并且查看状态，当看到两个参数都是yes的时候表示成功

start slave;
    show slave status;

11、完成node1跟node3的相互复制

--在node1上执行
    CHANGE MASTER TO MASTER_HOST='192.168.85.113',MASTER_USER='root',MASTER_PASSWORD='123456',MASTER_LOG_FILE='mysql-bin.000001',MASTER_LOG_POS=442;
    --开启slave
    start slave
    --查看状态
    show slave status\G
    --在node3上执行
    CHANGE MASTER TO MASTER_HOST='192.168.85.111',MASTER_USER='root',MASTER_PASSWORD='123456',MASTER_LOG_FILE='mysql-bin.000002',MASTER_LOG_POS=442;
    --开启slave
    start slave
    --查看状态
    show slave status\G

双主双从验证  
在node1上执行如下sql语句：

create database msb;
    create table mytb2(id int,name varchar(20));
    insert into mytb values(1,'zhangsan');

发现在node2、node3、node4都同步了数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 4]

当上述操作完成之后，我们可以验证mycat的读写分离，此时我们需要进行重新的配置，修改schema.xml文件。

在当前mysql架构中，我们使用的是双主双从的架构，因此可以将balance设置为1
    
    	除此之外我们需要注意，还需要了解一些参数：
    
    	参数writeType，表示写操作发送到哪台机器，此参数有两个值可以进行设置：
    
    	writeType=0:所有写操作都发送到配置的第一个writeHost，第一个挂了切换到还生存的第二个
    
    	writeType=1:所有写操作都随机的发送到配置的writehost中，1.5之后废弃，
    
    	需要注意的是：writehost重新启动之后以切换后的为准，切换记录在配置文件dnindex.properties中
    
    	参数switchType:表示如何进行切换：
    
    	switchType=1:默认值，自动切换
    
    	switchType=-1:表示不自动切换
    
    	switchType=2：基于mysql主从同步的状态决定是否切换

<?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
    
            <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
    
            </schema>
    
            <dataNode name="dn1" dataHost="localhost1" database="msb" />
            <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
                              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                    <heartbeat>select user()</heartbeat>
                    
                    <writeHost host="hostM1" url="10.0.0.130:33306" user="root"
                                       password="666666">
    <readHost host="hostS1" url="10.0.0.131:33306" user="root" password="666666"></readHost>
                    </writeHost>
    <writeHost host="hostM2" url="10.0.0.132:33306" user="root"
                                       password="666666">
                            <readHost host="hostS2" url="10.0.0.133:33306" user="root" password="666666"></readHost>
                    </writeHost>
             </dataHost>
    </mycat:schema>

下面开始进行读写分离的验证

--插入以下语句，使数据不一致
    insert into mytb2 values(4,@@hostname);
    --通过查询mycat表中的数据，发现查询到的结果在node2,node3,node4之间切换，符合正常情况
    select * from mytb2;
    --停止node1的mysql服务
    service mysql stop
    --重新插入语句
    insert into mytb2 values(5,@@hostname);
    --开启node1的mysql服务
    service mysql start
    --执行相同的查询语句，此时发现在noede1，node2,node4之间切换，符合情况

通过上述的验证，我们可以得到一个结论，node1,node3互做备机，负责写的宕机切换，其他机器充作读请求的响应。

## 分库分表(数据切分)有时间再更新 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70]: /images/20221022/8df520b28a5042c58bb043bc30dae39f.png
[20210403165910911.png]: /images/20221022/912efc6a21db4e63a98cb8da089566ea.png
[20210403171933392.png]: /images/20221022/e4ae24fe0b5b4b01ab3c4522a7e06e08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 1]: /images/20221022/a7e0bec72e44471486c7cd0104325a8d.png
[Link 1]: https://blog.csdn.net/daobageg/article/details/95100118
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 2]: /images/20221022/9dfc5f34ee314184aaf59db809e54d25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 3]: /images/20221022/d6c3e488955a41e38396c188c8feb4a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R6eHNjOA_size_16_color_FFFFFF_t_70 4]: /images/20221022/aba0e83d5f0741f2b63a9f52bbd3109b.png