Mycat

最新推荐文章于 2023-01-04 17:33:06 发布

这结局或许就完美在可悲

最新推荐文章于 2023-01-04 17:33:06 发布

阅读量346

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_45650737/article/details/109563508

版权

笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.官网：http：//www.mycat.io/
2.读写分离
3.数据分片

垂直拆分（分库）
水平拆分（分表）
垂直+水平拆分（分库分表）

4.多数据源组合：
5.原理：

Mycat的原理中最重要的一个词是“拦截”，它拦截了用户发送过来的SQL语句，首先对SQL语句,首先对
SQL语句做了一些特定的分析:如分片分析，路由分析，读写分离分析，缓存分析等，然后将此SQL发往
后端的真实数据库，并将返回的结果做适当的处理，最终在返回给用户。

6.安装启动:

1.rpm方式
   .rpm安装包，按顺序安装
2.yum方式
   需要网络
3.jar包解压即可使用 采取这种
cp -r
4.解压后编译安装

配置文件

三个配置文件：
1.schema.xml:定义逻辑库，表、分片节点等内容
2.rule.xml:定义分片规则
3.server.xml：定义用户以及系统相关变量，如端口等

启动前

修改server.xml
<usr name="mycat">
     <property name="passward">123456</property>
     <property name="schemas">TESTDB</property>
修改schema.xml
     schema中间全部删掉
只保留如下配置
<schema name="TESTDB" scheckSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
</schema>
<dataNode name="dn1" datahost="host1" database="testdb">
<dataHost name="host1" macCon="1000" minCon="10" balance="0"
          writeType="0" dbType="mysql" dbDriver="native" SwitchType="1" slaveThreshold="100">
          <heartbeat>select user()</heartbeat>
          <writeHost host="hostM1" usrl="数据库地址：端口号" user="root" password="123">
          <readHost host="hostS1" url="数据库地址：端口号" user="" password="">
linux验证数据库访问          
mysql -uroot -p123 -h 地址 -P 端口号
启动：
启动程序：
1.控制台启动:去mycat/bin 目录下执行 ./mycat console
2.后台启动:去mycat/bin 目录下执行 ./mycat start
为了能第一时间看到启动日志，方便定位问题，选择1.控制台启动

登陆：

1.登陆后台管理窗口
  此方式用于管理维护Mycat
   mysql -umycat -p123456 -P 9066 -h [地址]
2.登陆数据窗口
  mysql -umycat -p123456 -h [地址] -P 8066

搭建读写分离
我们通过Mycat和MySQL的主从复制配合搭建数据的读写分离，实现MySQL的高可用性。我们将搭建:一主一从、双柱双从两种读写分离模式。
一主一从：
一个主机用于处理所有写请求，一台从机负责所有读请求。
在这里插入图片描述
主从复制原理

主从复制搭建：
主从读写分离：

验证读写分离：
1.在写主机插入：insert into mytbl values(1,@@hostname)
 主从主机数据不一致了
2.在mycat里查询：select * from mytbl；
修改<dataHost>的balance属性，通过此属性配置读写分离的类型
负载均衡类型，目前的取值有4种
1.balance="0" ,不开启读写分离机制，所有读操作都发送到当前可用的writeHost上。
2.balance="1",全部的readHost与stand by writeHost参与语句的复制均衡，简单来说，当双主双从模式(M1->s1,M2->S2,并且M1与M2互为主备)，正常情况下，M2,S1,S2都参与select语句的负载均衡。
3.balance="2",所有读操作随机的在write、readhost上分发
4.balance="3",所有读请求随机分发到readhost执行，writeHost不负担读压力。
实际开发要么1要么3

双主双从复制原理

一个主机用于处理所有写请求，它的从机s1和另一台主机m2还有它的从机s2负责所有读请求。当m1主
机宕机后，m2主机负责写请求，m1、m2互为备机

Master1配置：

添加：
#在作为从数据库的时候，有写入操作也要更新二进制日志文件
log-slave-updates
#表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围1-65535
auto-increment-increment=2
#表示自增长字段从哪个数开始，指字段一次递增多少，它的取值范围是1-65535
auto-increment-offset=1

Master2配置：

跟msater1一致 修改下面一个就是以及serverid=3
#表示自增长字段从哪个数开始，指字段一次递增多少，它的取值范围是1-65535
auto-increment-offset=2

master1与master2互相注册互相守望即可
slave1：
slave2:

跟slave一致 配置serverId启用中继日志即可

双主双从读写分离：

修改schema.xml配置文件 balance = 1
<dataHost name="host1" macCon="1000" minCon="10" balance="0"
          writeType="0" dbType="mysql" dbDriver="native" SwitchType="1" slaveThreshold="100">
          <heartbeat>select user()</heartbeat>
          <writeHost host="hostM1" usrl="数据库地址：端口号" user="root" password="123">
          <readHost host="hostS1" url="数据库地址：端口号" user="" password="">
          </writeHost>
          
          <writeHost host="hostM2" usrl="数据库地址：端口号" user="root" password="123">
          <readHost host="hostS2" url="数据库地址：端口号" user="" password="">
          </writeHost>
</dataHost>          
#balance="1":全部的readHost与stand by writeHost参与select语句的负载均衡。
#writeType="0":所有写操作发送到配置的第一个writeHost,第一个挂了切到还生存的第二个
#writeType="1":所有写操作发送到配置的writeHost,1.5以后废弃不推荐
#writeHost , 重新启动以后切换后的为准，切换记录在配置文件中:dnindex.properties
#switchType="1":1 默认值，自动切换
               -1 表示不自动切换    
                2 基于Mysql主从同步的状态决定是否切换。

垂直分库划分原则

原理：
一个数据库由很多表构成，每个表对应着不同的业务，垂直切分是指按照业务将表进行分类，分不到不
同的数据库上面，这样也就将数据或者说压力分担到不同的库上面

垂直分库

<schema name="TESTDB" scheckSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
     <table name="customer" dataNode="dn2"></table>
</schema>
<dataNode name="dn1" datahost="host1" database="order">
<dataNode name="dn2" datahost="host2" database="order">
<dataHost name="host1" macCon="1000" minCon="10" balance="0"
          writeType="0" dbType="mysql" dbDriver="native" SwitchType="1" slaveThreshold="100">
          <heartbeat>select user()</heartbeat>
          <writeHost host="hostM1" usrl="数据库地址：端口号" user="root" password="123">
          <readHost host="hostS1" url="数据库地址：端口号" user="" password="">
          </writeHost>
</dataHost>     
<dataHost name="host2" macCon="1000" minCon="10" balance="0"
          writeType="0" dbType="mysql" dbDriver="native" SwitchType="1" slaveThreshold="100">
          <heartbeat>select user()</heartbeat>
          <writeHost host="hostM2" usrl="数据库地址：端口号" user="root" password="123">
          <readHost host="hostS2" url="数据库地址：端口号" user="" password="">
          </writeHost>
</dataHost>

拦截转发
两个服务器创建数据库启动mycat use TESTDB
水平分表划分原则

水平拆分是按照某个字段的某种规则来分散到多个库之中，每个表中包含一部分数据。简单来说，我们
可以将数据的水平切分理解为是按照数据行的切分，就是将表中的某些行切分到一个数据库，而另外的
某些行又切分到其他的数据库中

客户id 取模分配

修改配置文件schema.xml
#为orders表设置数据节点dn1、dn2,并指定分配规则为mod_rule
<schema name="TESTDB" scheckSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
     <table name="customer" dataNode="dn2"></table>
     <table name="orders" dataNode="dn1,dn2" rule="mod_rule"></table>
</schema>
修改配置文件rule.xml
#在rule配置文件里新增分片规则mod_rule,并指定规则适用字段为customer_id.
#还有选择分配算法mod-long(对字段求模运算),customer_id对两个节点求模，根据结果分片
#配置算法mod-long参数count为2（2台机器） algorithm(算法)
<tableRule name="mod_rule">
    <rule>
       <columns>customer_id</columns>
       <algorithm>mod-long</algorithm>
    </rule>
</tableRule>
<function name="mod-long" class="io.mycat.route.function.partitionByPod">
  <property name="count">2</property>
</function>

mycat 插入数据字段必须写全
Mycat分片如何“join”

1.ER表
Mycat借鉴了NewSQL领域的新秀Foundation DB 的设计思路，Foundation DB创新性的提出了Table 
Group概念，其将子表的存储位置依赖于主表，并且物理上紧邻存放，因此彻底解决了Join的效率和性
能问题，根据这一思路，提出了E-R关系的数据分配策略，子表的记录与所关联的附表记录存放在同一
个数据分片上（外键关联）
修改schema.xml
<schema name="TESTDB" scheckSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
     <table name="customer" dataNode="dn2"></table>
     <table name="orders" dataNode="dn1,dn2" rule="mod_rule">
        <childTable name="orders_detail" primaryKey="id" joinKey="order_id" parentKey="id">
     </table>
</schema>

水表分表全局表

在分片的情况下，当业务表因为规模而进行分片以后，业务表与这些附属的字典表之间的关联，就成了比较棘手的问题，考虑到字典表具有以下特性：
1.变动不频繁
2.数据总量变化不大
3.数据规模不大，很少又超过10万条记录
鉴于此，MYCAT定义了一种特殊的表，称之为“全局表” 全局表具有以下特征：
1.全局表的插入、更新操作会实时在所有节点执行，保持各个分片的数据一致性
2.全局表的查询操作，只从一个节点获取
3.全局表可以跟任何一个表进行JOIN操作
  将字典表或者符合字典表特性的一些定义为全局表，则从另外一个方面，很好的解决了数据JOIN的难题。通过全局表+基于E-R关系的分片策略，MYCAT可以满足80%以上企业应用开发。
  dict_order_type表名dn1,dn2 同时创建 冗余数据
  <table name="dict_order_type" dataNode="dn1,dn2" type="global"></table>

常用分片规则

1.取模：
  此规则为对分片字段取模，也是分片水平不最常用的规则。
2.分片枚举
  通过在配置文件种配置的灭据id,自己配置分片，本规则适用于特定的场景，比如有些业务需要按照
  省份或区县来做保存，而全国省份区县固定的，这类业务适用本规
  <table name="orders_ware_info" dataNode="dn1,dn2" rule="sharding_by_intfile">
  </table>
  <tableRule name="sharding_by_intfile">
    <rule>
       <columns>areacode</columns>
       <algorithm>hash-int</algorithm>
    </rule>
</tableRule>
<function name="hash-int" class="io.mycat.route.functio.PartitionByFileMap">
    <property name="mapFile">partion-hash-int.txt</property>
    <property name="type">1</property>
    <property name="defaultNode">0</property>
</function>
#mapfile:标识配置文件名称，type:0为int型、非0为String
#defaultNode:默认节点：小于0表示不设置默认节点，大于等于0表示设置默认节点
设置默认节点如果碰到不识别的枚举值，就让他路由到默认节点，如不设置不识别就报错
3.修改partition-hash-int.txt
110(arecode)=0  0表示第一个节点
120(arecode)=1  1表示第二个节点
4.重启mycat
5.访问创建表

3.范围越大

此分片适用于，提前规划好某个字段范围属于哪个分片
 <table name="payment_info" dataNode="dn1,dn2" rule="auto_sharding_long">
  </table>
  <tableRule name="auto_sharding_long">
    <rule>
       <columns>order_id</columns>
       <algorithm>rang-long</algorithm>
    </rule>
</tableRule>
<function name="rang-long" class="io.mycat.route.functio.AutoPartionByLong">
    <property name="mapFile">autopartition-long.txt</property>
    <property name="defaultNode">0</property>
</function>
配置autopartition-long.txt
1-102=0
103-200=1
重启mycat

4.按日期分片

此规则按天分片，设定时间格式、范围
 <table name="login_info" dataNode="dn1,dn2" rule="sharding_by_date">
  </table>
  <tableRule name="sharding_by_date">
    <rule>
       <columns>login_date</columns>
       <algorithm>shardingByDate</algorithm>
    </rule>
</tableRule>
<function name="sharding_by_date" class="io.mycat.route.functio.PartitionByDate">
    <property name="dateFormat">yyyy-MM-dd</property>
    <property name="sBeginDate">2019-01-01</property>
    <property name="sEndDate">2019-01-04</property>
    <property name="sPartionDay">2</property>
</function>
sBeginDate:开始日期
sEndDate：结束日期，则代表数据达到了这个日期的分片后循环从开始分片插入
sPartionDay:分区天数，即默认从开始日期算起，分隔2天一个分区
2019-01-01 -2019-01-02 分到节点1
2019-01-03 -2019-01-04 分到节点2
2019-01-05 -2019-01-06 分到节点1

全局序列

在实现分库分表的情况下，数据库自增主键已无法保证自增主键的唯一。为此，Mycat提供了全局
sequence,并且提供了包含本地配置和数据库配置等多种实现方式。
1.本地配置
  此方式Mycat将sequence配置到文件中，当使用到sequence中的配置后，Mycat会更新下classpath中的sequence-conf.properties文件中的sequence当前的值
  优点：本地加载，读取速度较快
  缺点：抗风险能力差，Mycat所在主机宕机后无法读取本地文件
配置过程 ，mycat按照主机 sequence-conf.properties
2.数据库方式 实际项目采用
  利用数据库一个表 来进行计数累加，但是并不是每次生成序列化都读写数据库，这样效率太低。Mycat会与家长一部分号段到Mycat的内存中，这样大部分读写序列都是内存中完成的。
如果内存用完了 Mycat会在向数据库要一次  
实现过程：
一.在dn1上创建全局系列表
create table mycat_sequence(name varchar(50) not null,current_value int not null,increment int not null default 100,primary key(name)) engine=innodb;
二.创建全局序列所需要的函数
DELIMITER $$
  CREATE FUNCTION mycat_seq_curral(seq_name varchar(50))RETURNS VARCHAR(64)
DETERMINISTIC
BEGIN
DECLARE retval VARCHAR(64);
SET retval="-999999999,null";
SELECT CONCAT(CAST(current_value AS CHAR),",",CAST(increment AS CHAR))INFO RETVAL FROM MYCAT_SEQUENCE WHERE NAME=seq_name;
RETURN retval;
END$$
DELIMITER; 

DELIMITER $$
  CREATE FUNCTION mycat_seq_setval(seq_name varchar(50),VALUE INTEGER)RETURNS VARCHAR(64)
DETERMINISTIC
BEGIN
UPDATE MYCAT_SEQUENCE;
SET current_value=VALUE
WHERE NAME=seq_name;
RETURN mycat_seq_currval(seq_name);
END$$
DELIMITER; 

DELIMITER $$
  CREATE FUNCTION mycat_seq_nextval(seq_name varchar(50))RETURNS VARCHAR(64)
DETERMINISTIC
BEGIN
UPDATE MYCAT_SEQUENCE;
SET current_value=current_value+increment WHERE NAME=seq_name;
RETURN mycat_seq_currval(seq_name);
END$$
DELIMITER; 
三.初始化系列表记录：
INSERT INTO MYCAT_SEQUENCE(NAME,current_vale,increment) VALUES ('ORDERS',400000,100);
四、修改mycat配置
修改sequence_db_conf.properties
vim sequence_db_conf.properties
意思是 ORDERS这个序列在dn1这个节点上
GLOBAL=dn1
COMPANY=dn1
CUSTOMER=dn1
ORDERS=dn1
五.修改server.xml
全局系列剋下：0-本地文件，1-数据库方式，2-时间戳方式。
<property name="sequenceHandlerType">1<property>

3.时间戳方式  不采用
  全局系列ID=64位二进制（42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加)换算成十进制为18位数的long类型，每毫秒可以并发12位二进制的累加
  优点：配置简单
  缺点：18位ID过长
4.自主生成全局序列
  可以在java项目里自己生成全局序列，如下：
1.根据业务逻辑组合

基于HA机制Mycat高可用

在实际项目中，Mycat服务也需要考虑高可用，如果Mycat所在服务器出现宕机，或Mycat服务故障，
需要有备机提供服务，需要考虑Mycat集群;

高可用方案:

我们可以使用HAProxy+Keepalived配合两台Mycat搭起Mycat集群，实现高可用性。HAProxy实现了
Mycat多节点的集群高可用和负载均衡，而HAProxy自身的高可用则可以通过Keepalived来实现。

在这里插入图片描述
1.Mycat1 192.168.140.128 host79
2.Mycat2 192.168.140.127 host80
3.HAProxy(master) 192.168.140.126 host81
4.Keepalived(master) 192.168.140.126 host81
5.HAProxy(backup) 192.168.140.125 host82
6.Keepalived(backup) 192.168.140.125 host82
安装配置HAProxy

1.准备好HAProxy安装包，传到opt目录下
2.解压到/usr/local/src
tar -zxvf happroxy-1.5.18.tar.gz -C /usr/local/src
3.进入解压后的目录，查看内核版本，进行编译
cd /usr/local/src/haproxy-1.5.18
uname -r
make TARGET=linux310 PREFIX=/usr/local/haproxy ARCH=x86_64 
TARGET=linux310,内核版本，使用uname -r查看内核，如3.10.0-514.el7,此时该参数就为linux310;
ARCH=x86_64 系统位参数
PREFIX=/usr/local/haproxy 为haprpxy安装路劲
4.编译完成后，进行安装
make install PREFIX=/usr/local/haproxy
5.安装完成后，创建目录、创建HAProxy配置文件
mkdir -p /usr/data/haproxy/
vim /usr/local/haproxy/haproxy.conf
6.向配置文件中插入以下配置信息,并保存
global
        log 127.0.0.1     local0
        #log 127.0.0.1    local1 notice
        #log loghost      local0 info
        maxconn 4096
        chroot /usr/local/haproxy  #程序目录
        pidfile /usr/data/haproxy/haproxy.pid  #指定进程id存放位置
        uid 99
        gid 99
        daemon
        #debug
        #quiet
default  
       log      global
       mode     tcp
       option redispatch
       retries 3
       maxconn 2000
       timeout connect 5000
       timeout client  50000
       timeout server  50000
listen proxy_status
      bind:48066
          mode tcp
          balance roundrobin
          server mycat_1 192.168.140.128:8066 check inter 10s       
          server mycat_1 192.168.140.127:8066 check inter 10s  
          
frontend admin_stats   #指定控制台
    bind:7777
         mode http
         stats enable
         option httplog
         maxconn 10
         stats uri /admin
         stats auth admin:123123  #指定用户名密码
         stats hide-version
         stats admin if TRUE
启动127，128mycat服务
启动HAProxy
/usr/local/haproxy/sbin/haproxy -f/usr/local/haproxy/haproxy.conf
查看HAProxy进程
ps -ef|grep haproxy
打开浏览器访问
http://192.168.140.125:7777/admin
验证负载均衡，通过HAProxy访问Mycat
mysql -umycat -p123456 -h 192.168.140.126 -P 48066

配置keepalived

1.准备好Keepalived安装包，传到/opt目录下
2.解压到/usr/local/src
tar -zxvf keepalived-1.4.2.tar.gz -C /usr/local/src
3.安装依赖插件
yum install -y gcc openssl-devel popt-devel
4.进入到解压后的目录，进行配置，进行编译
cd /usr/local/src/keepalived-1.4.2
./configure --prefix=/usr/local/keepalived
5.进行编译,完成后进行安装
make && make install
6.运行前配置
cp /usr/local/src/keepalived-1.4.2/keepalived/init.d/keepalived /etc/init.d
mkdir /etc/keepalived
cp /usr/local/keepalived/etc/keepalived/keepalived.conf /etc/keepalived/
cp /usr/local/etc/keepalived.1.4.2/keepalived/etc/sysconfig/keepalived /etc/sysconfig/
cp /usr/local/keepalived/sbin/keepalived /usr/sbin/
7.修改配置文件 126 125按如下配置
vim /etc/local/keepalived/keepalived.conf
! Configuration File for keepalived
global_defs{
  notification_email{
  xlcocoon@foxmail.com  #指定发邮箱地址 不是很重要
  }
  notification_email_from keepalived@showjoy.com
  smtp_server 127.0.0.1
  smtp_connect_timeout 30
  router_id LVS_DEVEL
  vrrp_skip_check_adv_addr
  vrrp_garp_interval 0
  vrrp_gna_interval 0
}

vrrp_instance VI_I {
  #主机配置MASTER,备机配BACKUP
  state MASTER
  #所在机器网卡
  interface ens33
  virtual_router_id 51
  #数值越大优先级越高
  priority 100
  advert_int 1
  authentication {
      auth_type PASS
      auth_pass 1111
  }
  virtual_ipaddress {
  #虚拟IP
      192.168.140.220
  } 
}
virtual_server 192.168.140.220 48066{
    delay_loop 6
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP
    real_server 192.168.140.125 48066{
        weight 1
        TCP_CHECK{
            connect_timeout 3
            retry 3
            delay_before_retry 3
        }
    }
    real_server 192.168.140.126 48066{
        weight 1
        TCP_CHECK{
            connect_timeout 3
            nb_get_retry 3
            delay_before_retry 3
        }
    }
}

2.启动验证

1.启动Keepalived
service keepalived start
2.登陆验证
mysql -umycat -p123456 -h 192.168.140.200 -P 48066

Mycat安全配置权限user

1.user 标签权限控制 通过server.xml配置
<usr name="mycat">
     <property name="passward">123456</property>
     <property name="schemas">TESTDB</property>
     <property name="readOnly">true</property>#配置只读模式 默认false
<user>     
2.privileges 标签权限控制 对表权限进行控制
<usr name="mycat">
     <property name="passward">123456</property>
     <property name="schemas">TESTDB</property>
     <privileges check ="true">
        <schema name="TESTDB" dm1="1111">
            <table name="orders" dm1="0000"></table>
        </schema>
     </privileges>   
<user>   
0000禁止更删改查
0010 只允许查询
1110 只允许新增
1111 更删改查都可以

Mycat安全SQL拦截白名单

firewall标签用来定义防火墙；firewall下whitehost标签来定义IP白名单，blacklist用来定义SQL黑名单
1.白名单
可以通过设置白名单，实现某主机某用户可以访问Mycat,而其他用户禁止访问
通过server.xml配置
<firewall>
    <whitehost>
        <host host="192.168.140.128" user="mycat">
    </whitehost>
</firewall>
2.黑名单
可以通过设置黑名单，实现Mycat对具体SQL操作的拦截,如增删改查
通过server.xml配置
<firewall>
    <whitehost>
        <host host="192.168.140.128" user="mycat">
    </whitehost>
    <blacklist check="true">
        <property name="deleteAllow">false</property>
    </blacklist>
</firewall>

在这里插入图片描述
监控平台简介：
Mycat-web监控平台
引入zookeeper作为配置中心,可以管理多个节点
Mycat-web主要管理和监控Mycat的流量、连接、活动线程和内存，具备IP白名单，邮件警告等模块，还可以统计SQL并分析慢SQL和高频SQL等。为优化SQL提供依据；
监控平台安装zookeeper

1.下载安装包：http://zookeeper.apache.org/
2.解压到opt  cp -r zookeeper-3.4.11 /myzookeeper
配置修改
启动
3.下载mycat-web :www.mycat.io下载 /opt
cp -r mycat-web/ /usr/local
4.进入到mycat-web的目录下运行启动命令
cd /usr/local/mycat-web/
./start.sh &
默认端口号8082
通过http://192.168.140.127:8082

监控平台指标
在这里插入图片描述

这结局或许就完美在可悲

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mycat

1.官网：http：//www.mycat.io/2.读写分离3.数据分片垂直拆分（分库）水平拆分（分表）垂直+水平拆分（分库分表）4.多数据源组合：5.原理：Mycat的原理中最重要的一个词是“拦截”，它拦截了用户发送过来的SQL语句，首先对SQL语句,首先对SQL语句做了一些特定的分析:如分片分析，路由分析，读写分离分析，缓存分析等，然后将此SQL发往后端的真实数据库，并将返回的结果做适当的处理，最终在返回给用户。6.安装启动:...
复制链接

扫一扫

专栏目录