MySQL主从（MySQL proxy Lua读写分离设置，一主多从同步配置，分库分表方案）

Mysql Proxy Lua读写分离设置

一.读写分离说明

  1. 读写分离（Read/Write Splitting），基本的原理是让主数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。

1、设置说明

  1. Master服务器: 192.168.41.196
  2. Slave服务器: 192.168.41.197
  3. Proxy服务器: 192.168.41.203

2、安装Mysql Proxy

在Proxy服务器上安装即可. 如果源码方式安装, 需提前安装pkg-config,libevent,glibc,lua等依赖包, 非常麻烦, 建议直接使用二进制版.

  1. # cd /u01/software/mysql
  2. # tar -zxvf Mysql Proxy-0.8.1-linux-rhel5-x86-32bit.tar.gz -C /usr/local
  3. # cd /usr/local
  4. # ln -s Mysql Proxy-0.8.1-linux-rhel5-x86-32bit Mysql Proxy
  5. # vi + ~/.bash_profile
  6. export PATH=$PATH:/usr/local/Mysql Proxy/bin/
  7. # . ~/.bash_profile

3、Mysql Proxy选项说明

  1. # Mysql Proxy help-all

管理功能选项:

  1. admin-address=host:port 指定一个mysqo-proxy的管理端口, 缺省是4041;
  2. admin-username=<string> username to allow to log in
  3. admin-password=<string> password to allow to log in
  4. admin-lua-script=<filename> script to execute by the admin plugin

代理功能选项:

  1. -P, proxy-address=<host:port> 是Mysql Proxy 服务器端的监听端口, 缺省是4040;
  2. -r, proxy-read-only-backend-addresses=<host:port> 只读Slave的地址和端口, 缺省为不设置;
  3. -b, proxy-backend-addresses=<host:port> 远程Master地址和端口, 可设置多个做failover和load balance, 缺省是127.0.0.1:3306;
  4. proxy-skip-profiling 关闭查询分析功能, 缺省是打开的;
  5. proxy-fix-bug-25371 修正 mysql的libmysql版本大于5.1.12的一个#25371号bug;
  6. -s, proxy-lua-script=<file> 指定一个Lua脚本来控制Mysql Proxy的运行和设置, 这个脚本在每次新建连接和脚本发生修改的的时候将重新调用;

其他选项:

  1. defaults-file=<file>配置文件, 可以把Mysql Proxy的参数信息置入一个配置文件里;
  2. daemon Mysql Proxy以守护进程方式运行
  3. pid-file=file 设置Mysql Proxy的存储PID文件的路径
  4. keepalive try to restart the proxy if it crashed, 保持连接启动进程会有2个, 一号进程用来监视二号进程, 如果二号进程死掉自动重启proxy.

4、数据库准备工作

（1）安装半同步补丁(建议)

读写分离不能回避的问题之一就是延迟, 可以考虑Google提供的SemiSyncReplication补丁.

（2）给用户授权

在Master/Slave建立一个测试用户, 因为以后客户端发送的SQL都是通过Mysql Proxy服务器来转发, 所以要确保可以从Mysql Proxy服务器上登录MySQL主从库.

  1. mysql> grant all privileges on *.* to ‘u_test‘@‘192.168.41.203‘ identified by ‘xxx‘ with grant option;

（3）在Master建立测试表

  1. mysql> create table db_test.t_test (col varchar(10));
  2. mysql> insert into db_test.t_test values (‘testA‘);
  3. mysql> select * from db_test.t_test;
  4. +-+
  5. | col   |
  6. +-+
  7. | testA |
  8. +-+

5、Mysql Proxy启动

（1）修改读写分离lua脚本

默认最小4个最大8个以上的客户端连接才会实现读写分离, 现改为最小1个最大2个:

  1. # vi +40 /usr/local/Mysql Proxy/share/doc/Mysql Proxy/rw-splitting.lua
  2. connection pool
  3. if not proxy.global.config.rwsplit then
  4. proxy.global.config.rwsplit = {
  5. min_idle_connections = 1,
  6. max_idle_connections = 2,
  7. is_debug = true
  8. }
  9. end

这是因为Mysql Proxy会检测客户端连接, 当连接没有超过min_idle_connections预设值时, 不会进行读写分离, 即查询操作会发生到Master上.

（2）启动Mysql Proxy

建议使用配置文件的形式启动, 注意配置文件必须是660权限, 否则无法启动. 如果有多个Slave的话, proxy-read-only-backend-addresses参数可以配置多个以逗号分隔的IP:Port从库列表.

  1. # killall Mysql Proxy
  2. # vi /etc/Mysql Proxy.cnf
  3. [Mysql Proxy]
  4. admin-username=wangnc
  5. admin-password=iamwangnc
  6. admin-lua-script=/usr/local/Mysql Proxy/lib/Mysql Proxy/lua/admin.lua
  7. proxy-backend-addresses=192.168.41.196:3351
  8. proxy-read-only-backend-addresses=192.168.41.197:3351
  9. proxy-lua-script=/usr/local/Mysql Proxy/share/doc/Mysql Proxy/rw-splitting.lua
  10. log-file=/var/tmp/Mysql Proxy.log
  11. log-level=debug
  12. daemon=true
  13. keepalive=true
  14. # chmod 660 /etc/Mysql Proxy.cnf
  15. # Mysql Proxy defaults-file=/etc/Mysql Proxy.cnf
  16. # ps -ef | grep Mysql Proxy | grep -v grep
  17. root      1869     1  0 18:16 ?        00:00:00 /usr/local/Mysql Proxy/libexec/Mysql Proxy defaults-file=/etc/Mysql Proxy.cnf
  18. root      1870  1869  0 18:16 ?        00:00:00 /usr/local/Mysql Proxy/libexec/Mysql Proxy defaults-file=/etc/Mysql Proxy.cnf
  19. # tail -50f /var/tmp/Mysql Proxy.log

6、客户端连接测试

（1）先停止Slave的复制进程

  1. mysql> stop slave;

（2）连接Proxy端口, 插入数据

  1. # mysql -uu_test -pxxx -h192.168.41.203 -P4040 -Ddb_test
  2. mysql> insert into db_test.t_test values (‘testB‘);
  3. mysql> select * from db_test.t_test;
  4. +-+
  5. | col   |
  6. +-+
  7. | testA |
  8. | testB |
  9. +-+

（3）多开几个客户端, 连接Proxy端口, 查询数据

  1. # mysql -uu_test -pxxx -h192.168.41.203 -P4040 -Ddb_test
  2. mysql> select * from db_test.t_test;
  3. +-+
  4. | col   |
  5. +-+
  6. | testA |
  7. +-+

如果查询不到上步新插入的数据, 说明连接到了Slave, 读写分离成功. 在同一线程再插入数据并验证:

  1. mysql> insert into db_test.t_test values (‘testC‘);
  2. mysql> select * from db_test.t_test;
  3. +-+
  4. | col   |
  5. +-+
  6. | testA |
  7. +-+

发现insert操作成功, 但是select不出刚插入的数据, 说明同一线程也读写分离成功. 从日志中可以验证:

  1. # tail -50f /var/tmp/Mysql Proxy.log
  2. ...
  3. [read_query] 192.168.41.203:45481
  4. current backend   = 0
  5. client default db = db_test
  6. client username   = u_test
  7. query             = select * from db_test.t_test
  8. sending to backend : 192.168.41.197:3351
  9. is_slave         : true
  10. server default db: db_test
  11. server username  : u_test
  12. in_trans        : false
  13. in_calc_found   : false
  14. COM_QUERY       : true
  15. [read_query] 192.168.41.203:45481
  16. current backend   = 0
  17. client default db = db_test
  18. client username   = u_test
  19. query             = insert into db_test.t_test values (‘testC‘)
  20. sending to backend : 192.168.41.196:3351
  21. is_slave         : false
  22. server default db: db_test
  23. server username  : u_test
  24. in_trans        : false
  25. in_calc_found   : false
  26. COM_QUERY       : true

（4）测试完毕后, 启动Slave的复制进程

  1. mysql> start slave;

7、正式环境说明

1、Mysql Proxy当前还只是个测试版, MySQL官方还不建议用到生产环境中;

2、Mysql Proxy的rw-splitting.lua脚本在网上有很多版本, 但是最准确无误的版本仍然是源码包中所附带的rw-splitting.lua脚本, 如果有lua脚本编程基础的话, 可以在这个脚本的基础上再进行优化；

3、Mysql Proxy实际上非常不稳定, 在高并发或有错误连接的情况下, 进程很容易自动关闭, 因此打开keepalive参数让进程自动恢复是个比较好的办法, 但还是不能从根本上解决问题, 因此通常最稳妥的做法是在每个从服务器上安装一个Mysql Proxy供自身使用, 虽然比较低效但却能保证稳定性；

4、Amoeba for MySQL是一款优秀的中间件软件, 同样可以实现读写分离, 负载均衡等功能, 并且稳定性要大大超过Mysql Proxy, 建议大家用来替代Mysql Proxy, 甚至MySQL-Cluster.

二、MySQL一主多从同步配置

1.配置（3台上都一样）

在/etc目录下可能无my.cnf文件，从/user/share/mysql目录中拷贝my-medium.cnf 到/etc并修改成my.cnf

[[email protected] etc]# cp /usr/share/mysql/my-medium.cnf my.cnf

[[email protected] etc]# ll |grep my

-rwxr-xr-x 1 root root 5204 Feb 13 22:52 my_bak

-rwxr-xr-x 1 root root 4765 Jul 10 23:07 my.cnf

master 上;

[[email protected] ~]# vi /etc/my.cnf

1.修改master上的配置文件my.cnf。

在[mysqld]下添加如下字段：

server-id = 1

log-bin=mysql-bin

binlog-do-db=YYY //需要同步的数据库

binlog-ignore-db=mysql //被忽略的数据库

binlog-ignore-db=information-schema //被忽略的数据库

在master上为slave添加一个同步账号

mysql> grant replication slave on *.* to ‘affairlog‘@‘192.168.2.182‘ identified by ‘pwd123‘;

//在slave1上登陆成功

mysql> grant replication slave on *.* to ‘affairlog‘@‘192.168.2.111‘ identified by ‘pwd123‘;

//在slave2上登陆成功

保存后，重启master的mysql服务：

service mysql restart;

用show master status命令查看日志情况

mysql> show master status\G;

*************************** 1. row ***************************

File: mysql-bin.000087

Position: 106

Binlog_Do_DB: YYY

Binlog_Ignore_DB: mysql,information-schema

1 row in set (0.00 sec)

2.修改slave1上的配置文件my.cnf。

在[mysqld]下添加如下字段

[[email protected] ~]# vi /etc/my.cnf

server-id=182

master-host=192.168.3.101

master-user= affairlog

master-password=pwd123

master-port=3306

master-connect-retry=60

replicate-do-db=YYY //同步的数据库

replicate-ignore-db=mysql //被忽略的数据库

replicate-ignore-db=information-schema //被忽略的数据库

查看Master上 master_log_file的文件名 和master_log_pos 。

mysql>change master to master_host=‘192.168.3.101‘ master_user=‘affairlog‘ master_password=‘pwd123‘ master_log_file=‘mysql-bin.000087‘ master_log_pos=1845;

保存后，重启slave的mysql服务：

service mysql restart;

修改slave2上的配置文件my.cnf，和上面类似，只是把server-id改下，为了方便，我都用了相应的ip某位，

so，slave2上我设置的server-id是111。

在进入两个slave机中的mysql。

mysql>start slave;

mysql>show slave status\G;

*************************** 1. row ***************************

Slave_IO_State: Waiting for master to send event

Master_Host: 192.168.3.101

Master_User: affairlog

Master_Port: 3306

Connect_Retry: 60

Master_Log_File: mysql-bin.000087

Read_Master_Log_Pos: 106

Relay_Log_File: vm111-relay-bin.000002

Relay_Log_Pos: 251

Relay_Master_Log_File: mysql-bin.000087

Slave_IO_Running: Yes

Slave_SQL_Running: Yes

Replicate_Do_DB: YYY

Replicate_Ignore_DB: mysql,information-schema

Replicate_Do_Table:

Replicate_Ignore_Table:

Replicate_Wild_Do_Table:

Replicate_Wild_Ignore_Table:

Last_Errno: 0

Last_Error:

Skip_Counter: 0

Exec_Master_Log_Pos: 106

Relay_Log_Space: 406

Until_Condition: None

Until_Log_File:

Until_Log_Pos: 0

Master_SSL_Allowed: No

Master_SSL_CA_File:

Master_SSL_CA_Path:

Master_SSL_Cert:

Master_SSL_Cipher:

Master_SSL_Key:

Seconds_Behind_Master: 0

Master_SSL_Verify_Server_Cert: No

Last_IO_Errno: 0

Last_IO_Error:

Last_SQL_Errno: 0

Last_SQL_Error:

1 row in set (0.00 sec)

如果两个slave中的Slave_IO_Running、Slave_SQL_Running状态均为Yes则表明设置成功。

Slave_IO_Running：连接到主库，并读取主库的日志到本地，生成本地日志文件

Slave_SQL_Running:读取本地日志文件，并执行日志里的SQL命令。

三、MySQL分库分表方案：https://my.oschina.net/ydsakyclguozi/blog/199498

原文地址：https://www.cnblogs.com/sunyujun/p/8494669.html

时间： 2024-10-14 20:46:44

MySQL主从（MySQL proxy Lua读写分离设置，一主多从同步配置，分库分表方案）的相关文章

mysql主从利用proxy实现读写分离

编译安装代理服务 安装依赖yum update -y nss curl libcurlyum group install "Development tools" yum install gcc make libcurl-devel openssl-devel gmp-devel tar libffi-devel gettext-devel -yyum install -y tcpdump net-tools jemalloc-devel libevent-devel glib2-dev

【分库、分表】MySQL分库分表方案

一.Mysql分库分表方案 1.为什么要分表: 当一张表的数据达到几千万时,你查询一次所花的时间会变多,如果有联合查询的话,我想有可能会死在那儿了.分表的目的就在于此,减小数据库的负担,缩短查询时间. mysql中有一种机制是表锁定和行锁定,是为了保证数据的完整性.表锁定表示你们都不能对这张表进行操作,必须等我对表操作完才行.行锁定也一样,别的sql必须等我对这条数据操作完了,才能对这条数据进行操作. 2. mysql proxy:amoeba 做mysql集群,利用amoeba. 从上层的ja

MySQL 分库分表方案，总结的非常好！

前言 公司最近在搞服务分离,数据切分方面的东西,因为单张包裹表的数据量实在是太大,并且还在以每天60W的量增长. 之前了解过数据库的分库分表,读过几篇博文,但就只知道个模糊概念, 而且现在回想起来什么都是模模糊糊的. 今天看了一下午的数据库分库分表,看了很多文章,现在做个总结,"摘抄"下来.(但更期待后期的实操) 会从以下几个方面说起: 第一部分:实际网站发展过程中面临的问题. 第二部分:有哪几种切分方式,垂直和水平的区别和适用面. 第三部分:目前市面有的一些开源产品,技术,它们的优缺

MySQL分库分表方案

1. MySQL分库分表方案 1.1. 问题: 1.2. 回答: 1.2.1. 最好的切分MySQL的方式就是:除非万不得已,否则不要去干它. 1.2.2. 你的SQL语句不再是声明式的(declarative) 1.2.3. 你招致了大量的网络延时 1.2.4. 你失去了SQL的许多强大能力 1.2.5. MySQL没有API保证异步查询返回顺序结果 1.2.6. 总结 MySQL分库分表方案 翻译一个stackoverflow上的问答,关于分库分表的缺点的,原文链接: MySQL shard

【MySQL】MySQL中针对大数据量常用技术_创建索引+缓存配置+分库分表+子查询优化（转载）

原文地址:http://blog.csdn.net/zwan0518/article/details/11972853 目录(?)[-] 一查询优化 1创建索引 2缓存的配置 3slow_query_log分析 4分库分表 5子查询优化 二数据转移 21插入数据 如今随着互联网的发展,数据的量级也是撑指数的增长,从GB到TB到PB.对数据的各种操作也是愈加的困难,传统的关系性数据库已经无法满足快速查询与插入数据的需求.这个时候NoSQL的出现暂时解决了这一危机.它通过降低数据的安全性,减少对事务

oracle迁移到mysql分库分表方案之——ogg(goldengate)

之前文章主要介绍了oracle 迁移到mysql,主要是原表原结构迁移,但是实际运维中会发现,到mysql以后需要分库和分表的拆分操作,这个时候,用ogg来做,也是很强大好用的.主要结合ogg的2个参数 参数1:filterUse a FILTER clause to select rows based on a numeric value by using basic operators or one or more Oracle GoldenGate column-conversion fu

MySQL：互联网公司常用分库分表方案汇总

一.数据库瓶颈 不管是IO瓶颈,还是CPU瓶颈,最终都会导致数据库的活跃连接数增加,进而逼近甚至达到数据库可承载活跃连接数的阈值.在业务Service来看就是,可用数据库连接少甚至无连接可用.接下来就可以想象了吧(并发量.吞吐量.崩溃). 1.IO瓶颈 第一种:磁盘读IO瓶颈,热点数据太多,数据库缓存放不下,每次查询时会产生大量的IO,降低查询速度 -> 分库和垂直分表. 第二种:网络IO瓶颈,请求的数据太多,网络带宽不够 -> 分库. 2.CPU瓶颈 第一种:SQL问题,如SQL中包含joi

【转】MYSQL数据库数据拆分之分库分表总结

http://wentao365.iteye.com/blog/1740691 数据存储演进思路一:单库单表单库单表是最常见的数据库设计,例如,有一张用户(user)表放在数据库db中,所有的用户都可以在db库中的user表中查到.数据存储演进思路二:单库多表随着用户数量的增加,user表的数据量会越来越大,当数据量达到一定程度的时候对user表的查询会渐渐的变慢,从而影响整个DB的性能.如果使用MySQL, 还有一个更严重的问题是,当需要添加一列的时候,mysql会锁表,期间所有的读写操作只能

mysql分库分表总结

单库单表 单库单表是最常见的数据库设计,例如,有一张用户(user)表放在数据库db中,所有的用户都可以在db库中的user表中查到. 单库多表 随着用户数量的增加,user表的数据量会越来越大,当数据量达到一定程度的时候对user表的查询会渐渐的变慢,从而影响整个DB的性能.如果使用mysql, 还有一个更严重的问题是,当需要添加一列的时候,mysql会锁表,期间所有的读写操作只能等待. 可以通过某种方式将user进行水平的切分,产生两个表结构完全一样的user_0000,user_0001等