• 基于mysql主从同步的proxy读写分离

    mysql-proxy 简介

    MySQL Proxy是一个处于你的client端和MySQL server端之间的简单程序，它可以监测、分析或改变它们的通信。它使用灵活，没有限制，常见的用途包括：负载平衡，故障、查询分析，查询过滤和修改等等。

    MySQL Proxy就是这么一个中间层代理，简单的说，MySQL Proxy就是一个连接池，负责将前台应用的连接请求转发给后台的数据库，并且通过使用lua脚本，可以实现复杂的连接控制和过滤，从而实现读写分离和负载平衡。对于应用来说，MySQL Proxy是完全透明的，应用则只需要连接到MySQL Proxy的监听端口即可。当然，这样proxy机器可能成为单点失效，但完全可以使用多个proxy机器做为冗余，在应用服务器的连接池配置中配置到多个proxy的连接参数即可。

    MySQL Proxy更强大的一项功能是实现“读写分离”，基本原理是让主数据库处理事务性查询，让从库处理SELECT查询。数据库复制被用来把事务性查询导致的变更同步到集群中的从库。

    架构示意图

    1
    2
    3
    4
    5
                       ___ master_mysql(10.10.10.3)
                      |          |
       mysql-proxy(10.10.10.2)   |
                      |___       |
                           slave_mysql(10.10.10.4)

    (一)mysql主从同步

    1、mysql-master设置

    (1)

    1
    2
    3
    server-id = 1    //master端ID号
    binlog-ignore-db =    //设置不同步的sql库
    binlog-do-db=    //设置同步的数据

    (2)设置完上面以后重启mysql

    (3)添加用户访问主库,并且只有备份权限

    1
    2
    mysql > grant replication slave  on *.* to 'rsync'@'10.10.%' identified by '1q2w3e4rys' with grant option;
    mysql > flush privileges;

    (4)锁表,主库数据继续写入 

    1
    mysql > flush tables with read lock;

    (5)记录 master file与position的值,slave库配置同步时候要使用

    (6)导出mysql主库数据

    1
    mysqldump -uuser -p databases > databases.sql

    注:这里有个问题,当主库数据上G,较大时需要做如下操作

    1
    2
    --max_allowed_packet=XXX    //客户端/服务器之间通信的缓存区的最大大小;
    --net_buffer_length=XXX    //TCP/IP和套接字通信缓冲区大小,创建长度达net_buffer_length的行;

    注意：max_allowed_packet和net_buffer_length不能比目标数据库的配置数值大,否则可能出错。

    首先确定目标库的参数值       

    1
    2
    mysql>show variables like 'max_allowed_packet';
    mysql>show variables like 'net_buffer_length';

    根据参数值书写mysqldump命令,如:

    1
    mysql > mysqldump -uuser -p? 数据库名 -e --max_allowed_packet=1048576 --net_buffer_length=16384 > databases.sql

    (7)master库同步到slave服务器上

    1
    # scp databases.sql  root@host:/path

    2、mysql-slave设置

    (1)

    1
    server-id = 2

    (2)登录mysql创建sql数据库

    1
    mysql > CREATE DATABASE `?sql_db?` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

    (3)导入master库数据到slave库中

    1
    mysql -uuser -p? sql_db < databases.sql

    (4)登录mysql停止slave

    1
    mysql > stop slave;

    (5)配置从库同步

    1
    mysql > change master to master_host=’10.10.10.2’,master_user=’rsync’,master_password=’1q2w3e4rys’,master_port=3306,master_log_file=’mysql-bin.000047’,master_log_pos=107;

    (6)启动同步功能

    1
    mysql > start slave;

    (7)解除主库锁表

    1
    unlock tables;

    (8)查看slave同步状态

    1
    mysql > show slave statusG    //多执行几遍,查看数据写入后的状态

    注：查看上面的Slave_IO_Running: Yes 和Slave_SQL_Running: Yes  2个都为yes则证明主从同步正常,如果有任一个显示NO,则证明同步有问题.可以查看数据库日志文件,里面基本上会显示出错误之处,根据错误一步一步排查,基本上都可以解决的.

    (二)mysql-proxy读写分离

    1、安装mysql-proxy

    (1)

    1
    2
    3
    4
    # wget http://ftp.ntu.edu.tw/pub/MySQL/Downloads/MySQL-Proxy/mysql-proxy-0.8.5-linux-el6-x86-64bit.tar.gz
    # tar xf mysql-proxy-0.8.5-linux-el6-x86-64bit.tar.gz -C /usr/local
    # cd /usr/local
    # ln -sv mysql-proxy-0.8.5-linux-el6-x86-64bit mysql-proxy

    2、设置mysql-proxy属主属组

    (1)

    1
    2
    # groupadd mysql-proxy
    # useradd -g mysql-proxy -s /sbin//nologin -M mysql-proxy

    3、配置mysql-proxy

    (1)为mysql-proxy提供SysV服务脚本,脚本如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    #!/bin/bash
    #
    # mysql-proxy This script starts and stops the mysql-proxy daemon
    #
    # chkconfig: - 78 30
    # processname: mysql-proxy
    # description: mysql-proxy is a proxy daemon for mysql
      
    # Source function library.
    . /etc/rc.d/init.d/functions
      
    prog="/usr/local/mysql-proxy/bin/mysql-proxy"
      
    # Source networking configuration.
    if [ -f /etc/sysconfig/network ]; then
        . /etc/sysconfig/network
    fi
      
    # Check that networking is up.
    [ ${NETWORKING} = "no" ] && exit 0
      
    # Set default mysql-proxy configuration.
    ADMIN_USER="admin"
    ADMIN_PASSWD="admin"
    ADMIN_LUA_SCRIPT="/usr/local/mysql-proxy/share/doc/mysql-proxy/admin.lua"
    PROXY_OPTIONS="--daemon"
    PROXY_PID=/var/run/mysql-proxy.pid
    PROXY_USER="mysql-proxy"
      
    # Source mysql-proxy configuration.
    if [ -f /etc/sysconfig/mysql-proxy ]; then
        . /etc/sysconfig/mysql-proxy
    fi
      
    RETVAL=0
      
    start() {
        echo -n $"Starting $prog: "
        daemon $prog $PROXY_OPTIONS --pid-file=$PROXY_PID --proxy-address="$PROXY_ADDRESS" --user=$PROXY_USER --admin-username="$ADMIN_USER" --admin-lua-script="$ADMIN_LUA_SCRIPT" --admin-password="$ADMIN_PASSWORD"
        RETVAL=$?
        echo
        if [ $RETVAL -eq 0 ]; then
            touch /var/lock/subsys/mysql-proxy
        fi
    }
      
    stop() {
        echo -n $"Stopping $prog: "
        killproc -p $PROXY_PID -d 3 $prog
        RETVAL=$?
        echo
        if [ $RETVAL -eq 0 ]; then
            rm -f /var/lock/subsys/mysql-proxy
            rm -f $PROXY_PID
        fi
    }
    # See how we were called.
    case "$1" in
        start)
            start
            ;;
        stop)
            stop
            ;;
        restart)
            stop
            start
            ;;
        condrestart|try-restart)
            if status -p $PROXY_PIDFILE $prog >&/dev/null; then
                stop
                start
            fi
            ;;
        status)
            status -p $PROXY_PID $prog
            ;;
        *)
            echo "Usage: $0 {start|stop|restart|reload|status|condrestart|try-restart}"
            RETVAL=1
            ;;
    esac
      
    exit $RETVAL

    (2)将上述内容保存为/etc/rc.d/init.d/mysql-proxy,给予执行权限,而后加入到服务列表。

    1
    2
    # chmod +x /etc/rc.d/init.d/mysql-proxy
    # chkconfig --add mysql-proxy

    (3)为服务脚本提供配置文件/etc/sysconfig/mysql-proxy,内容如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    # Options for mysql-proxy 
    ADMIN_USER="admin"
    ADMIN_PASSWORD="admin"
    ADMIN_ADDRESS=""
    ADMIN_LUA_SCRIPT="/usr/local/mysql-proxy/share/doc/mysql-proxy/admin.lua"
    PROXY_ADDRESS=""
    PROXY_USER="mysql-proxy"
    PROXY_OPTIONS="--daemon --log-level=info --log-use-syslog --plugins=proxy --plugins=admin --proxy-backend-addresses=10.10.10.3:3306 --proxy-read-only-backend-addresses=10.10.10.4:3306 --proxy-lua-script=/usr/local/mysql-proxy/share/doc/mysql-proxy/rw-splitting.lua"

    (4)mysql-proxy配置选项注解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    --help
    --help-admin
    --help-proxy
    --help-all ———— 以上四个选项均用于获取帮助信息；
      
    --proxy-address=host:port ———— 代理服务监听的地址和端口；
    --admin-address=host:port ———— 管理模块监听的地址和端口；
    --proxy-backend-addresses=host:port ———— 后端mysql服务器的地址和端口；
    --proxy-read-only-backend-addresses=host:port ———— 后端只读mysql服务器的地址和端口；
    --proxy-lua-script=file_name ———— 完成mysql代理功能的Lua脚本；
    --daemon ———— 以守护进程模式启动mysql-proxy；
    --keepalive ———— 在mysql-proxy崩溃时尝试重启之；
    --log-file=/path/to/log_file_name ———— 日志文件名称；
    --log-level=level ———— 日志级别；
    --log-use-syslog ———— 基于syslog记录日志；
    --plugins=plugin,.. ———— 在mysql-proxy启动时加载的插件；
    --user=user_name ———— 运行mysql-proxy进程的用户；
    --defaults-file=/path/to/conf_file_name ———— 默认使用的配置文件路径；其配置段使用[mysql-proxy]标识；
    --proxy-skip-profiling ———— 禁用profile；
    --pid-file=/path/to/pid_file_name ———— 进程文件名；

    (5)复制如下内容建立admin.lua文件,将其保存至/usr/local/mysql-proxy/share/doc/mysql-proxy/目录中.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    --[[ $%BEGINLICENSE%$
     Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
      
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; version 2 of the
     License.
      
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
      
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
     02110-1301  USA
      
     $%ENDLICENSE%$ --]]
      
    function set_error(errmsg) 
        proxy.response = {
            type = proxy.MYSQLD_PACKET_ERR,
            errmsg = errmsg or "error"
        }
    end
      
    function read_query(packet)
        if packet:byte() ~= proxy.COM_QUERY then
            set_error("[admin] we only handle text-based queries (COM_QUERY)")
            return proxy.PROXY_SEND_RESULT
        end
      
        local query = packet:sub(2)
      
        local rows = { }
        local fields = { }
      
        if query:lower() == "select * from backends" then
            fields = { 
                { name = "backend_ndx", 
                  type = proxy.MYSQL_TYPE_LONG },
      
                { name = "address",
                  type = proxy.MYSQL_TYPE_STRING },
                { name = "state",
                  type = proxy.MYSQL_TYPE_STRING },
                { name = "type",
                  type = proxy.MYSQL_TYPE_STRING },
                { name = "uuid",
                  type = proxy.MYSQL_TYPE_STRING },
                { name = "connected_clients", 
                  type = proxy.MYSQL_TYPE_LONG },
            }
      
            for i = 1, #proxy.global.backends do
                local states = {
                    "unknown",
                    "up",
                    "down"
                }
                local types = {
                    "unknown",
                    "rw",
                    "ro"
                }
                local b = proxy.global.backends[i]
      
                rows[#rows + 1] = {
                    i,
                    b.dst.name,          -- configured backend address
                    states[b.state + 1], -- the C-id is pushed down starting at 0
                    types[b.type + 1],   -- the C-id is pushed down starting at 0
                    b.uuid,              -- the MySQL Server's UUID if it is managed
                    b.connected_clients  -- currently connected clients
                }
            end
        elseif query:lower() == "select * from help" then
            fields = { 
                { name = "command", 
                  type = proxy.MYSQL_TYPE_STRING },
                { name = "description", 
                  type = proxy.MYSQL_TYPE_STRING },
            }
            rows[#rows + 1] = { "SELECT * FROM help", "shows this help" }
            rows[#rows + 1] = { "SELECT * FROM backends", "lists the backends and their state" }
        else
            set_error("use 'SELECT * FROM help' to see the supported commands")
            return proxy.PROXY_SEND_RESULT
        end
      
        proxy.response = {
            type = proxy.MYSQLD_PACKET_OK,
            resultset = {
                fields = fields,
                rows = rows
            }
        }
        return proxy.PROXY_SEND_RESULT
    end

    (6)测试

    1
    2
    #mysql -uadmin -padmin -h110.10.10.2 --port=4041 
    mysql > SELECT * FROM backends;
    1
    2
    3
    4
    5
    6
    7
    +-------------+-------------------+-------+------+------+-------------------+
    | backend_ndx | address           | state | type | uuid | connected_clients |
    +-------------+-------------------+-------+------+------+-------------------+
    |           1 | 10.10.10.3:3306   | up    | rw   | NULL |                 0 | 
    |           2 | 10.10.10.4:3306   | up    | ro   | NULL |                 0 | 
    +-------------+-------------------+-------+------+------+-------------------+
    2 rows in set (0.00 sec)

    本文出自 “阿俊博客” 博客，请务必保留此出处http://ssc4469.blog.51cto.com/6315913/1854011
  • 相关阅读:
    Leetcode
    算法
    手写代码注意点 -- HashMap
    Batch
    Batch
    Tomcat
    微服务
    Java 基础
    Maven
    算法
  • 原文地址：https://www.cnblogs.com/firstdream/p/6640070.html
Copyright © 2020-2023  润新知