精华内容
下载资源
问答
  • mysql读写分离配置
    2021-11-15 12:05:56

    mysql配置主从复制

    CentOS7 64位安装MySql教程

    1. 先检查系统是否装有mysql
      rpm -qa | grep mysql

    2. 下载mysql的repo源
      wget http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm
      报错: -bash: wget: 未找到命令
      安装插件 yum -y install wget

    3. 安装mysql-community-release-el7-5.noarch.rpm包
      sudo rpm -ivh mysql-community-release-el7-5.noarch.rpm

    4. 安装MySQL
      sudo yum install mysql-server

    5. 重置MySQL密码
      mysql -u root
      报错:
      ERROR 2002 (HY000): Can’t connect to local MySQL server through socket ‘/var/lib/mysql/mysql.sock’ (2)
      原因:原因是/var/lib/mysql的访问权限问题。
      chown root /var/lib/mysql/

    6. 重启MySQL服务
      service mysqld restart

    7. 接着登陆设置密码
      mysql -u root
      use mysql;
      update user set password=password(‘123456’) where user=‘root’;
      exit;

    接着继续重启MySQL服务
    service mysqld restart

    1. 接着设置Root账户远程连接密码
      mysql -u root -p
      GRANT ALL PRIVILEGES ON . TO root@"%" IDENTIFIED BY “root”; 
      exit;

    重启服务器 service mysqld restart

    1. 使用外网工具连接MySQL
      关闭防火墙
      systemctl stop firewalld.service

    MySQL主从复制配置

    主服务器节点

    vi /etc/my.cnf 新增以下内容
    server_id=177 ###服务器id
    log-bin=mysql-bin ###开启日志文件

    重启mysql服务 service mysqld restart
    验证是否已经配置成功
    show variables like ‘%server_id%’;
    能够查询对应配置文件中的server_id 说明已经配置成功
    show master status;
    能够看到同步的文件,和行数 说明已经配置成功。

    从服务器节点

    克隆服务器
    vi /etc/my.cnf
    server_id=178 ###从服务器server_id
    log-bin=mysql-bin ###日志文件同步方式
    binlog_do_db=test ###同步数据库

    重启mysql服务 service mysqld restart
    验证是否已经配置成功
    show variables like ‘%server_id%’;
    能够查询对应配置文件中的server_id 说明已经配置成功

    从服务器同步主服务器配置
    change master to master_host=‘192.168.212.200’,master_user=‘root’,master_password=‘root’,
    master_log_file=‘mysql-bin.000002’,master_log_pos=216;
    开始同步
    start slave
    检查从服务器复制功能状态
    SHOW SLAVE STATUS

    Fatal error: The slave I/O thread stops because master and slave have equal MySQL server UUIDs; these UUIDs must be different for replication to work.

    因为服务器克隆的时候导致UUID产生了重复 ,服务器全手动安装不会出现这个错误
    解决办法

    Cat /etc/my.cnf
    cd /var/lib/mysql
    rm -rf auto.cnf
    重启服务器即可
    service mysqld restart

    mysql配置读写分离

    MyCat

    linux环境安装MyCat,实现读写分离
    1.上传Mycat包
    2.解压安装包 tar -zxvf 安装包名
    3.配置schema.xml和server.xml
    4.客户端连接端口号:8066

    文件说明server.xmlMycat的配置文件,设置账号、参数等schema.xmlMycat对应的物理数据库和数据库表的配置rule.xmlMycat分片(分表分库)规则

    文件说明
    server.xmlMycat的配置文件,设置账号、参数等
    schema.xmlMycat对应的物理数据库和数据库表的配置
    rule.xmlMycat分片(分表分库)规则

    schema.xml配置

    <?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
        <!-- TESTDB1 是mycat的逻辑库名称,链接需要用的 -->
        <schema name="mycat_testdb" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1"></schema>
            <!-- database 是MySQL数据库的库名 -->
        <dataNode name="dn1" dataHost="localhost1" database="test" />
        <dataHost name="localhost1" maxCon="1000" minCon="10" balance="3" writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
            <heartbeat>select user()</heartbeat>
            <!-- 可以配置多个主从 -->
            <writeHost host="hostM1" url="192.168.213.132:3306" user="root" password="root">
                <!-- 可以配置多个从库 -->
                <readHost host="hostS2" url="192.168.213.133:3306" user="root" password="root" />
            </writeHost>
        </dataHost>
    </mycat:schema>
    
    dataNode节点中各属性说明:
    name:指定逻辑数据节点名称;
    dataHost:指定逻辑数据节点物理主机节点名称;
    database:指定物理主机节点上。如果一个节点上有多个库,可使用表达式db$0-99,     表示指定0-99这100个数据库;
    dataHost 节点中各属性说明:
        name:物理主机节点名称;
        maxCon:指定物理主机服务最大支持1000个连接;
        minCon:指定物理主机服务最小保持10个连接;
        writeType:指定写入类型;
            0,只在writeHost节点写入;
            1,在所有节点都写入。慎重开启,多节点写入顺序为默认写入根据配置顺序,第一个挂掉切换另一个;
        dbType:指定数据库类型;
        dbDriver:指定数据库驱动;
        balance:指定物理主机服务的负载模式。
            0,不开启读写分离机制;
            1,全部的readHost与stand by writeHost参与select语句的负载均衡,简单的说,当双主双从模式(M1->S1,M2->S2,并且M1与 M2互为主备),正常情况下,M2,S1,S2都参与select语句的负载均衡;
            2,所有的readHost与writeHost都参与select语句的负载均衡,也就是说,当系统的写操作压力不大的情况下,所有主机都可以承担负载均衡;
    

    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" defaultAccount="true">
            <property name="password">123456</property>
            <property name="schemas">mycat_testdb</property>
    
            <!-- 表级 DML 权限设置 -->
            <!--        
            <privileges check="false">
                <schema name="TESTDB" dml="0110" >
                    <table name="tb01" dml="0000"></table>
                    <table name="tb02" dml="1111"></table>
                </schema>
            </privileges>       
             -->
        </user>
    
        <!-- 只读用户 -->
        <user name="user">
            <property name="password">user</property>
            <property name="schemas">mycat_testdb</property>
            <property name="readOnly">true</property>
        </user>
    
    </mycat:server>
    

    Maven依赖信息

    <parent>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-parent</artifactId>
    	<version>2.0.4.RELEASE</version>
    	<relativePath /> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-aop</artifactId>
    	</dependency>
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-web</artifactId>
    	</dependency>
    	<dependency>
    		<groupId>org.mybatis.spring.boot</groupId>
    		<artifactId>mybatis-spring-boot-starter</artifactId>
    		<version>1.3.2</version>
    	</dependency>
     
    	<dependency>
    		<groupId>mysql</groupId>
    		<artifactId>mysql-connector-java</artifactId>
    		<scope>runtime</scope>
    	</dependency>
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-test</artifactId>
    		<scope>test</scope>
    	</dependency>
     
    	<dependency>
    		<groupId>com.alibaba</groupId>
    		<artifactId>druid</artifactId>
    		<version>1.0.23</version>
    	</dependency>
    </dependencies>
     
    <build>
    	<plugins>
    		<plugin>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-maven-plugin</artifactId>
    		</plugin>
    	</plugins>
    </build>
    

    application.yml

      datasource:
        ###可读数据源
        select:
          jdbc-url: jdbc:mysql://192.168.212.204:8066/TESTDB1
          driver-class-name: com.mysql.jdbc.Driver
          username: user
          password: user
        ####可写数据源  
        update:
          jdbc-url: jdbc:mysql://192.168.212.204:8066/TESTDB1
          driver-class-name: com.mysql.jdbc.Driver
          username: user
          password: user
        type: com.alibaba.druid.pool.DruidDataSource
    

    DataSourceContextHolder

    @Component
    @Lazy(false)
    public class DataSourceContextHolder {
    // 采用ThreadLocal 保存本地多数据源
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
     
    // 设置数据源类型
    public static void setDbType(String dbType) {
    contextHolder.set(dbType);
    }
     
    public static String getDbType() {
    return contextHolder.get();
    }
     
    public static void clearDbType() {
    contextHolder.remove();
    }
     
    }
    
    DataSourceConfig
    @Configuration
    public class DataSourceConfig {
     
    // 创建可读数据源
    @Bean(name = "selectDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.select") // application.properteis中对应属性的前缀
    public DataSource dataSource1() {
    return DataSourceBuilder.create().build();
    }
     
    // 创建可写数据源
    @Bean(name = "updateDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.update") // application.properteis中对应属性的前缀
    public DataSource dataSource2() {
    return DataSourceBuilder.create().build();
    }
    }
    

    DynamicDataSource

    //在Spring 2.0.1中引入了AbstractRoutingDataSource, 该类充当了DataSource的路由中介, 能有在运行时, 根据某种key值来动态切换到真正的DataSource上。
     
    @Component
    @Primary
    public class DynamicDataSource extends AbstractRoutingDataSource {
    @Autowired
    @Qualifier("selectDataSource")
    private DataSource selectDataSource;
     
    @Autowired
    @Qualifier("updateDataSource")
    private DataSource updateDataSource;
     
    /**
     * 这个是主要的方法,返回的是生效的数据源名称
     */
    @Override
    protected Object determineCurrentLookupKey() {
    System.out.println("DataSourceContextHolder:::" + DataSourceContextHolder.getDbType());
    return DataSourceContextHolder.getDbType();
    }
     
    /**
     * 配置数据源信息
     */
    @Override
    public void afterPropertiesSet() {
    Map<Object, Object> map = new HashMap<>();
    map.put("selectDataSource", selectDataSource);
    map.put("updateDataSource", updateDataSource);
    setTargetDataSources(map);
    setDefaultTargetDataSource(updateDataSource);
    super.afterPropertiesSet();
    }
    }
    
    
    SwitchDataSourceAOP
    @Aspect
    @Component
    @Lazy(false)
    @Order(0) // Order设定AOP执行顺序 使之在数据库事务上先执行
    public class SwitchDataSourceAOP {
    // 这里切到你的方法目录
    @Before("execution(* com.mayikt.service.*.*(..))")
    public void process(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    if (methodName.startsWith("get") || methodName.startsWith("count") || methodName.startsWith("find")
    || methodName.startsWith("list") || methodName.startsWith("select") || methodName.startsWith("check")) {
    DataSourceContextHolder.setDbType("selectDataSource");
    } else {
    // 切换dataSource
    DataSourceContextHolder.setDbType("updateDataSource"); }
    }
    }
    

    原理:

    1.首先在项目中,有两个数据源,分别为读和写的数据源
    2.使用aop技术拦截业务逻辑层方法的前缀,比如get,select,find,list等
    判断方法时候需要做读或者写的操作
    3.如果是写的操作的时候,传递一个key给RountingDataSource指明使用写的数据源(updateDataSource)
    读的话也是传递一个key给RountingDataSource指明使用读的数据源(selectDataSource)

    动态数据源环境配置:

    1.创建读和写的数据源
    2.将读和写的数据源注册到RountingDataSource中
    3.使用AOP技术拦截业务逻辑层方法,判断方法的前缀,是读还是写

    数据库集群会产生哪些问题?

    1. 数据库集群的时候,如果自动增长id产生重复问题,怎么解决?(自增id问题)
      a.使用uuid做主键id(不推荐,查询慢),如果是oracle推荐
      b.设置数据库的步长
      设定起始值,设定每次增加的大小
      eg:节点一:1,3,5,7,9
      节点二:2,4,6,8,10
      注意:在最开始设置好了每台节点自增方式步长后,确定好了mysql集群数量后,无法扩展新的mysql,不然生成步长的规则可能会发生变化
      2.数据关联查询问题(水平拆分)
      3.数据同步问题

    分表分库

    1.在数据库分表分库原则中,遵循两个设计理论:垂直拆分、水平拆分

    • 垂直拆分:根据不同的业务,拆分成不同的数据库,比如会员数据库、订单数据库等
      (缺点:跨数据库查询,必须采用接口形式通讯,会出现分布式事务问题,增加开发成本)
    • 水平拆分:按照某个字段的某种规则分散到多个库中,每个表中包含一部分数据。简单来说,我们可以将数据的水平切分理解为是按照数据行的切分,就是将表中的某 些行切分到一个数据库,而另外的某些行又切分到其他数据库中,主要有分表,分库两种模式,该方式提高了系统的稳定性跟负载能力,但是跨库join性能较低

    水平拆分常用的算法:取模,分片,轮询,枚举
    主键取模的缺点:不能扩容服务器

    分片枚举:
    分片枚举这种规则适用于特定的场景,比如有些业务需要按照省份或区县来做保存,而全国的省份区县固定的,这类业务使用这一规则

    Sharding-Jdbc

    通过Sharding-Jdbc实现读写分离

    Maven依赖

       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
       <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
       <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
    
       <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <optional>true</optional>
       </dependency>
       <dependency>
          <groupId>com.baomidou</groupId>
          <artifactId>mybatis-plus-boot-starter</artifactId>
          <version>3.0-beta</version>
       </dependency>
       <dependency>
          <groupId>io.shardingjdbc</groupId>
          <artifactId>sharding-jdbc-core</artifactId>
          <version>2.0.3</version>
       </dependency>
       <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
       </dependency>
    </dependencies>
    
    <build>
       <plugins>
          <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
       </plugins>
    
    </build>
    

    application.yml

    mybatis-plus:
    #  mapper-locations: classpath*:/mapper/*.xml
      global-config:
        db-config:
          column-underline: true
    #shardingjdbc配置      
    sharding:
      jdbc:
        data-sources:
         ###配置第一个从数据库
          ds_slave_0:
            password: root
            jdbc-url: jdbc:mysql://192.168.213.133:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
            driver-class-name: com.mysql.jdbc.Driver
            username: root
          ###主数据库配置  
          ds_master:
            password: root
            jdbc-url: jdbc:mysql://192.168.213.132:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
            driver-class-name: com.mysql.jdbc.Driver
            username: root
        ###配置读写分离    
        master-slave-rule:
        ###配置从库选择策略,提供轮询与随机,这里选择用轮询
          load-balance-algorithm-type: round_robin
          ####指定从数据库
          slave-data-source-names: ds_slave_0
          name: ds_ms
          ####指定主数据库
          master-data-source-name: ds_master
    

    ShardingDataSourceConfig

    @Configuration
    @EnableConfigurationProperties(ShardingMasterSlaveConfig.class)
    @Log4j2
    // 读取ds_master主数据源和读写分离配置
    @ConditionalOnProperty({ "sharding.jdbc.data-sources.ds_master.jdbc-url",
          "sharding.jdbc.master-slave-rule.master-data-source-name" })
    public class ShardingDataSourceConfig {
       @Autowired
       private ShardingMasterSlaveConfig shardingMasterSlaveConfig;
       @Bean
       public DataSource masterSlaveDataSource() throws SQLException {
          final Map<String, DataSource> dataSourceMap = Maps.newHashMap();
          dataSourceMap.putAll(shardingMasterSlaveConfig.getDataSources());
          final Map<String, Object> newHashMap = Maps.newHashMap();
          // 创建 MasterSlave数据源
          DataSource dataSource = MasterSlaveDataSourceFactory.createDataSource(dataSourceMap,
                shardingMasterSlaveConfig.getMasterSlaveRule(), newHashMap);
          log.info("masterSlaveDataSource config complete");
          return dataSource;
       }
    }
    

    ShardingMasterSlaveConfig

    @Data
    @ConfigurationProperties(prefix = "sharding.jdbc")
    public class ShardingMasterSlaveConfig {
       // 存放本地多个数据源
       private Map<String, HikariDataSource> dataSources = new HashMap<>();
       private MasterSlaveRuleConfiguration masterSlaveRule;
    }
    

    目录结构:

    通过Sharding-Jdbc实现分表分库

    总结

    Sharding-Jdbc与MyCat区别

    Mycat是一个基于第三方应用中间件数据库代理框架,客户端所有的jdbc请求都必须要先交给Mycat,再由MyCat转发到具体的真是服务器中

    Sharding-Jdbc是一个Jar形式,在本地应用层重写Jdbc原生的方法,实现数据库分片形式。
    MyCat属于服务器端数据库中间件,而Sharding-Jdbc是一个本地数据库中间件框架

    从设计理念上看确实有一定的相似性。主要流程都是SQL解析—》 SQL路由 —》SQL改写 —》 SQL执行 —》结果归并。但架构设计上是不同的。MyCat是基于Proxy,他复写了Mysql协议,将Mycat Server伪装成一个Mysql数据库,而Sharding-Jdbc是基于JDBC的扩展,是以jar包形式提供轻量级服务的

    Mycat虚拟数据库的方式实现分表分库
    sharding-JDBC基于本地AOPjdbc拦截改写sql语句

    更多相关内容
  • mysql读写分离配置

    2018-09-29 22:22:02
    mysql读写分离配置
  • 第一招、mysql服务的启动和停止 net stop mysql net start mysql 第二招、登陆mysql 语法如下: mysql -u用户名 -p用户密码 键入命令mysql -uroot -p, 回车后提示你输入密码,输入12345,然后回车即可进入到mysql中...
  • 一、环境准备 1. 查看主从复制状态 2. 查看JDK版本 3. 打开root的远程连接权限 4. 安装MyCat ...五、验证读写分离 1. 打开查询日志general_log 2. 验证读操作在slave 3. 验证写操作在master 4. 验证容灾功能...

    一、环境准备

    条件:
    master(虚拟机centos7,NAT模式,固定ip):192.168.131.129
    slave(win10,路由器局域网,DHCP协议):192.168.31.27

    • 由于MyCat是用Java写的,需要JDK1.7版本以上
    • MySQL的root账户有远程访问权限

    建议安装centos7

    [强调]:我们可能会遇到今天配置好了,明天就出错了,因为我们用的ip都是DHCP都是动态分配的,它是有过期时间的,过期以后这个ip就会重新分配。像我们这边演示用的centos7是NET模式下写的固定的ip,这个ip是不会变的,但是win10的ip直接连的是局域网的路由器,它是DHCP这个ip是会变的。所以我们如果遇到这种之前是通的,现在不通的问题,可以检查下ip是否变了,然后去改ip就可以了。

    1. 查看主从复制状态

    读写分离基于主从复制,查看主从复制状态
    在这里插入图片描述

    2. 查看JDK版本

    MyCat的运行需要java环境,需要JDK1.7版本以上,执行java -version检查JDK环境
    在这里插入图片描述

    3. 打开root的远程连接权限

    客户端的请求都是通过代理MyCat最终发送到远端的MySQL上,一般MySQL和MyCat都是不在一台机器上的,这里就涉及到了数据库的远程访问连接。

    我们可以拿root进行连接,也可以创建新的用户进行连接。root用户默认是localhost只能本地连接,不支持远程连接
    在这里插入图片描述
    所以需要root远程连接的权限打开。%表示允许任意地址连接,如果缩小权限,写成MyCat所在机器的ip地址就可以,用root连接MySQL服务器,grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;打开远程权限后再重启服务service mysqld restart在这里插入图片描述
    通过ip地址远程连接mysql使用命令mysql -h 192.168.131.129 -u root -p123456

    4. 安装MyCat

    安装lrzsz,用于windows和Linux传输文件(xftp也行)
    在这里插入图片描述
    rz命令将MyCat包传输到Linux
    在这里插入图片描述
    在这里插入图片描述
    同样地,要把Linux上的文件下载到Window上sz+文件路径
    解压MyCat包放到合适的目录下,可以放到/usr/local/mycat下,tar -zxvf
    在这里插入图片描述
    解压以后就可以看到解压的目录里面有mycat
    在这里插入图片描述mycat/bin:放的是可执行文件mycat/conf:放的MyCat的配置文件mycat/logs:放的MyCat的日志文件
    在这里插入图片描述

    • wrapper.log:记录启动过程中遇到的错误
    • mycat.log:记录运行过程中遇到的错误

    由于我们是直接解压的,没有安装,为了不用手动指定mycat的路径,我们 在/usr/bin下建立软连接,连接用户目录下的mycat和我们解压路径下的mycat
    在这里插入图片描述
    这样就不用指定路径,直接使用mycat
    在这里插入图片描述

    二、配置文件

    mycat/conf:放的MyCat的配置文件

    1. server.xml

    server.xml配置登录MyCat的账号信息,功能很强大,还可以配置白名单黑名单,限制客户的连接等

    • 用户配置
      在这里插入图片描述
      不需要和MySQL的账号密码一样,因为我们的MySQL Client直接访问的是MyCat,再由MyCat登录MySQL Server。
      USERDB是逻辑库,是一个不存在的库,最终这个库映射到后端的MySQL上,实际上它会真实地映射到MySQL库表当中,所以我们把它叫做逻辑库。这个逻辑库看起来好像在MyCat一台机器上,实际上经过分库分表操作可能分配在不同的机器上,我们只需要操作这个逻辑库就可以,其他的不用关心。多个逻辑库的话,用逗号分隔开
    • 防火墙配置
      在这里插入图片描述

    2. schema.xml

    schema.xml配置逻辑库与数据源、读写分离、分库分表等

    schema.xml配置以下三点:

    1. 逻辑库和逻辑表:MySQL Client都是操作的MyCat上的逻辑库(schema)和逻辑表
    2. 数据节点:这个库或者表的内容放在哪个节点(dataNode)上,这个节点对应具体的物理机器(dataHost)
    3. 以下三个地方需要相同(其中逻辑库、数据节点以及数据库主机名称都可以随便取)
      在这里插入图片描述
      在这里插入图片描述
    • maxCon、minCon:连接池的最大、最小连接量
    • balance:
      0:不开启读写分离
      1:全部的readHost和stand by writeHost参与select语句的负载 ,比如2套1主2从,M1叫做writeHost,S1、S2、S3、S4 叫做readHost,M2叫做stand by writeHost
      2:所有读操作随机在readHost和writeHost上分发
      3:所有读请求随机分发到writeHost对应的readHost上执行(最常使用,所有的select操作都在salve从库上执行,master主库只做写操作)
    • writeType: 0表示所有写操作发送到配置的第一个writeHost,第一个挂掉切换到还在的第二个 writeHost
    • switchType(切换的类型,当一个master挂了,切换到另一个master上):
      -1:不自动切换
      1:根据心跳select user()自动切换
      2:基于MySQL的主从同步状态决定是否进行切换,即MyCat发送show slave status给MySQL Server
    • writeHost、readHost:配置写服务器(master)和读服务器(slave),readHost标签在writeHost内,表示读服务器是slave,图中黄色框中是配置了一个一主一从,嵌套多个readHost标签就是配置一主多从。图中并列的writeHost标签表示备份的写库,当master宕机后,slave也将无法和master配合工作,会切换到备份的写库继续工作。其实图中配置的是多主多从
    • heartbeat:MyCat定时发送指定语句给MySQL Server,如果能正常返回数据,则表示正常工作;若不能正常返回数据,则表示机器故障,MyCat需要进行容灾切换

    如果slave有问题,master是正常,就会在master上做读和写操作
    如果master有问题,slave是正常,此时slave是没法单独使用的,它会在多主多从的配置中找下一套主从配置来使用
    如果主从都正常,master做写操作,slave做读操作

    三、启动服务

    查看配置文件mycat/conf/schema.xml
    在这里插入图片描述
    启动MyCat
    在这里插入图片描述
    查看服务是否正常
    在这里插入图片描述

    1. 配置文件问题一

    mycat/schema.xml中备份的主库没有结束标签
    在这里插入图片描述
    配置好后重启MyCat程序
    在这里插入图片描述
    如果配置上有问题,启动服务看不出来,应该查看mycat/logs/warpper.log,记录了mycat启动过程中的错误,vim + logs/warpper.log
    在这里插入图片描述

    2. 配置文件问题二

    mycat/schema.xml中读库的端口出错
    在这里插入图片描述
    配置好后重启MyCat程序
    在这里插入图片描述
    同样地,配置上有问题,启动服务看不出来,查看mycat/logs/warpper.log,记录了mycat启动过程中的错误
    在这里插入图片描述
    我们看到心跳不成功了,就应该判断是网络原因,或者是ip:port配置原因,于是我们看到了3309端口,就知道是配置的端口错误

    四、MyCat 9066端口和8066端口

    开启mycat后台服务
    在这里插入图片描述

    1. 9066管理端口

    在Linux Shell下登录mycat的9066端口(使用mycat/conf/server.xml中配置的登录用户名和密码登录)

    登录mycat后也是进入了一个MySQL Shell,monitor表示状态监控
    在这里插入图片描述
    show @@help可以显示MyCat的管理端支持的命令
    在这里插入图片描述
    show @@database查看逻辑库
    在这里插入图片描述
    show @@datanode查看逻辑节点和真实库之间的映射关系
    在这里插入图片描述
    show @@datasource查看数据源
    在这里插入图片描述

    2. 8066数据端口

    在Linux Shell下登录mycat的8066端口(使用mycat/conf/server.xml中配置的登录用户名和密码登录)

    OpenCloundDB表示我们看到的是一个云状数据库,云后面是如何提供的库表的服务能力,我们是不知道的。mycat就是云DB,把后端所有的细节给客户端隐藏了,客户端只需要去处理代理服务器上的DB就可以了。可以看作一个反向代理服务器
    在这里插入图片描述
    查看数据库
    在这里插入图片描述
    这个逻辑库USERDB对应的就是真实库mytest
    在这里插入图片描述
    我们作为客户端在代码上操作数据库的时候,操作的都是8066,操作的数据库是USERDB,而不是后台真实的数据库。

    五、验证读写分离

    按照上面的操作我们读写分离就正常配置好了
    在这里插入图片描述
    上面这个操作是在从库(Win10下的MySQL)上运行的,如果做update操作或者insert操作是在主库(Linux下的MySQL)上进行操作的,我们应该如何去验证呢?

    查询日志是可以把所有操作都记录下来的

    1. 打开查询日志general_log

    打开windows从库上的general_log
    在这里插入图片描述
    在这里插入图片描述
    在Linux也打开主库的general_log
    在这里插入图片描述

    2. 验证读操作在slave

    我们现在登录MyCat 8066数据端口,作为客户端代码操作也是8066端口逻辑库下面的user表
    在这里插入图片描述
    在Linux下的master服务器查看general_log,我们只看见了mycat发送的心跳包,并没有看见查询user表的SQL
    在这里插入图片描述
    在windows下的slave服务器中查看general_log,看到了mycat发送的查询user表的SQL
    在这里插入图片描述
    没有问题,现在读操作是正确发送给了slave

    3. 验证写操作在master

    我们现在登录MyCat 8066数据端口,给user表insert一条数据
    在这里插入图片描述
    在Linux下的master服务器查看general_log,我们看见了insert数据的SQL,所以写是在主库写
    在这里插入图片描述
    在windows下的slave服务器中查看general_log,没有发现insert数据的SQL
    在这里插入图片描述
    没有问题,写操作正确发送给了master

    这样我们就验证了我们主从复制是确实没有问题,是生效的,我们所有的写都是在master上进行的,读都是在slave上进行的,这就是读写分离,比我们单个主机即做写操作又做读操作肯定能提升它的能力。

    4. 验证容灾功能

    我们在mycat/conf/schema.xml中配置的是多住多从,M1挂了,读写操作会全部转发到M2

    在我们当前环境中,就是Linux上的MySQL Server挂了,所有的读写操作都会转发给Windows上的MySQL Server
    在这里插入图片描述
    关闭linux上的mysqld服务,相当于关闭了master
    在这里插入图片描述
    我们现在登录MyCat 8066数据端口,对user表分别读写操作
    在这里插入图片描述
    查看我们多主多从中备用系统的general_log,即Windows上的MySQL Server的general_log
    在这里插入图片描述
    可以看见,由于master挂了,读写操作都被转发到了备用的Windows上的MySQL Server,证明容灾没有问题

    展开全文
  • 关于mysql读写分离架构有很多,百度的话几乎都是用mysql_proxy实现的。由于proxy是基于lua脚本语言实现的,所以网上不少网友表示proxy效率不高,也不稳定,不建议在生产环境使用; amoeba是阿里开发的一款数据库...
  • springboot+mysql读写分离

    2020-07-29 15:23:58
    1、基于springboot框架,application.yml配置多个数据源,使用AOP以及AbstractRootingDataSource、ThreadLocal来实现多数据源切换,以实现读写分离mysql的主从数据库需要进行设置数据之间的同步。 2、AOP来实现...
  • MySQL读写分离配置图文详解(案例).pdf 学习资料 复习资料 教学资源
  • 配置mysql读写分离

    千次阅读 2022-04-01 18:46:13
    只需要上面只有客户端就行 然后也可以查看日志来看这个读写分离的过程 先修改日志阅读模式vim /usr/local/mycat/conf/log4j.xml 把这个位置的info改成debug 然后可以动态查看日志 tail -f /usr/local/mycat/logs/...

    准备起码三台服务器我这里准备了

    • 192.168.0.63   mycat
    • 192.168.0.64   主
    • 192.168.0.65   从
    如果是在多台 Linux 系统中组建的 MyCAT 集群,那需要在 MyCAT Server 所在的服务器上配置对
    其他 IP 和主机名的映射,配置方式如下:
    vi /etc/hosts
    例如:我有 3 台机器,配置如下:
    IP 主机名:
    192.168.0.63 xuegod63.cn
    192.168.0.64 xuegod64.cn
    192.168.0.65 xuegod65.cn
    编辑完后,保存文件

    然后是部署环境下载jbk和mycat,然后上传,

    新建/usr/java/文件夹将jdk-8u321-linux-x64.tar.gz解压到该目录

    [root@xuegod63 ~]# mkdir /usr/java
    [root@xuegod63 ~]# tar xf jdk-8u321-linux-x64.ta
    r.gz -C /usr/java/ 


    配置jdk环境变量 在vim /etc/profile.d/java.sh 底部加入如下内容:

     JAVA_HOME=/usr/java/jdk1.8.0_321
    PATH=$JAVA_HOME/bin:$PATH
    CLASSPATH=$JAVA_HOME/jre/lib/ext:$JAVA_HOME/lib/tools.jar
    export PATH JAVA_HOME CLASSPATH

    然后使环境变量生效

    [root@xuegod63 ~]# source /etc/profile.d/java.sh  #使环境生效
    [root@xuegod63 ~]# java -version #查看java版本
    java version "1.8.0_321"
    Java(TM) SE Runtime Environment (build 1.8.0_321-b07)
    Java HotSpot(TM) 64-Bit Server VM (build 25.321-b07, mixed mode)

    ,然后把mycat压缩包解压到/usr/local/下
    [root@xuegod63 ~]# tar xf Mycat-server-1.5-RELEASE-0301083012-linux.tar.gz -C /usr/local/

     然后创建mycat用户并修改密码,再修改权限

    [root@xuegod63 ~]# useradd mycat && echo 123456 | passwd --stdin mycat

    [root@xuegod63 ~]# chown -R mycat.mycat /usr/local/mycat

     配置mycat环境变量MYCAT_HOME,在/etc/profile.d 目录下创建 mycat.sh 文件,并写入如下。

    [root@xuegod63 local]# vim /etc/profile.d/mycat.sh 

    MYCAT_HOME=/usr/local/mycat PATH=$MYCAT_HOME/bin:$PATH

     使环境变量生效

    [root@xuegod63 local]# source /etc/profile.d/mycat.sh
    然后就是mycat修改 /usr/local/mycat/conf/ 中的两大表server.xml和schema.xml
    备份cp -a  server.xml server.xml.bak 
    修改 server.xml
    备份cp -a schema.xml schema.xml.bak
    修改 schema.xml

    然后到/usr/local/mycat/bin 目录下执行 ./mycat start,即可启动
    mycat 服务!
    /usr/local/mycat/bin/mycat start
    通过日志查看是否启动成功
    cat /usr/local/mycat/logs/wrapper.log

     也可以通过查看端口是否启动

     然后就是配置mysql主从,参照M-S,其他过程不变,但是两个服务器都要执行以下命令,授予全部权限

    grant all privileges on *.* to 'mycat'@"%" identified by "123456"

    然后就完成了,测试一下

    模拟slave故障,把从服务器挂掉

    [root@xuegod64 ~]# systemctl stop mysqld

    在客户端上测试读写
    [root@xuegod63 ~]# mysql -uroot -p123456 -h 192.168.1.63 - P 8066
    mysql> use HA;
    mysql> select * from test;

     说明读操作的路由切换到 master 上了,对外没有任何影响!

    模拟 master 故障:主服务器挂掉了
    [root@xuegod64 ~]# systemctl stop mysqld
    在客户端上测试读写
    [root@xuegod63 ~]# mysql -uroot -p123456 -h 192.168.1.63 - P 8066
    mysql> use HA;
    mysql> select * from test;

     发现不可以看也不可以写,这个不知道什么原因,我查查以后再做说明。

    解决了,是因为63这台服务器我下载了服务端,所以进去的是63的服务端里面,所以连接的不对。只需要上面只有客户端就行

    然后也可以查看日志来看这个读写分离的过程

    先修改日志阅读模式vim  /usr/local/mycat/conf/log4j.xml

    把这个位置的info改成debug 

    然后可以动态查看日志

    tail -f /usr/local/mycat/logs/mycat.log
     

    展开全文
  • 自己总结的mysql读写分离配置步骤,已经mycat中间件安装配置步骤
  • MySQL读写分离技术

    2021-01-27 16:18:23
    阅读目录1、简介2、基本环境3、配置主从复制4、MySQL读写分离配置4.1、安装lua4.2、安装mysql-proxy5、MySQL读写分离测试1)、修改rw-splitting.lua文件2)、修改完成后,启动mysql-proxy3)、创建用于读写分离的...
  • MySQL配置读写分离

    千次阅读 2022-04-26 20:57:04
    前置环境 事先准备3台虚拟机,其配置如下 主数据库(master)ip:192.168.126.151,装有Percona5.6.51 从数据库(slave)ip:192.168....master服务器上,使用vim /etc/my.cnf打开mysql配置文件,加入 server-id=1 l

    前置环境


    事先准备3台虚拟机,其配置如下

    • 主数据库(master)ip:192.168.126.151,装有percona5.6.51
    • 从数据库(slave)ip:192.168.126.152,装有percona5.6.51
    • mycat服务(mycat)ip:192.168.126.153,装有mycat

    另外,以上3台服务器均需配置jdk(1.8)

     

    配置主从


    master

    master服务器上,使用vim /etc/my.cnf打开mysql配置文件,加入

    server-id=1
    log-bin=mysql-bin # binlog
    

    重启mysql

    service mysql restart
    

    进入mysql通过show master status可以看到,其中File字段即为binlog文件名字
    在这里插入图片描述

    slave

    与master一样,使用vim /etc/my.cnf并添加

    server-id=2
    log-bin=mysql-bin # binlog
    

    然后在mysql中执行如下语句

    CHANGE MASTER TO MASTER_HOST="192.168.126.151", 
    MASTER_PORT=3306,
    MASTER_USER="root",
    MASTER_PASSWORD="root",
    MASTER_LOG_FILE="mysql-bin.000002",
    MASTER_LOG_POS=120
    

    以上均要与master中的值一样。

    执行start slave开启服务,并使用show slave status查看,如出现下图,则成功完成主从配置
    在这里插入图片描述
    这时我们修改master,则slave也会出现相应更改。

    注意: 如果主从是由同一台虚拟机克隆而来的话,server-uuid会一样,这时需要删除其中一台虚拟器的/var/lib/mysql/auto.cnf 文件,并进行重启,这样mysql会重新生成server_uuid

     

    取消主从

    在salve上,进入MySQL执行stop slave停止服务,然后通过执行reset slave all清空先前的配置信息,最后运行show slave status发现所有字段均为空了。

    在master上,执行reset master

    对于my.cnf配置文件,可不做修改
     

    读写分离


    读写分离即读和写操作在不同数据库上完成。通过将read和write分开,可以有效减低获取锁冲突的几率。

    但是Dao层不会关心数据库操作具体会由哪个库执行,此外,如上面配置的主数据库发生故障时,也需要我们手动切换到从数据库,因此,我们需要一个中间层(MySQL Proxy)来完成具体数据库的分派和自动切换。

    而mycat就是这个MySQL Proxy。

    在这里插入图片描述
     

    配置mycat

    进入mycat安装目录./mycat/conf,会有schema.xml和server.xml。

    在server.xml 加入

    	<!--对业务端暴露的逻辑数据库,实际并不存在,在schema.xml中配置-->
    	<user name="root">
    		<property name="password"></property>
    		<!--数据库名-->
    		<property name="schemas">mycat</property> 
    	</user>
    

    修改schema.xml

    <?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
    
    
    	<!--配置逻辑数据库-->
    	<schema name="mycat" checkSQLschema="false" sqlMaxLimit="100">
    		<!--此处name为实际要对应的表名, 并配置上数据源-->
    		<table name="test1" dataNode="dn1" />
    	</schema>
    
    	<!--可以理解为数据源-->
    	<!--此处database实际数据库名-->
    	<dataNode name="dn1" dataHost="master" database="test" />
    	
    	<!--每个dataHost可以看做一套主从架构,在外看来只是数据源-->
    	<dataHost name="master" maxCon="1000" minCon="10" balance="0"
    			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
    		
    		<!--心跳机制中执行的语句-->
    		<heartbeat>select user()</heartbeat>
    
    		<!-- can have multi write hosts -->
    		<!--配置数据库实例信息-->
    		<writeHost host="hostM1" url="192.168.126.151:3306" user="root" password="dj123456">	
    			<readHost host="hostM2" url="192.168.126.152:3306" user="root" password="dj123456"/>
    		</writeHost>
    		
    		<!-- <writeHost host="hostM2" url="localhost:3316" user="root" password="123456"/> -->
    	</dataHost>
    </mycat:schema>
    

    其中shema配置文件有些概念需要理清,可参考下图
    在这里插入图片描述

    测试


    启动mycat服务

    mycat start
    mycat status
    

    如果启动不成功,可以在./mycat/logs/wrapper.log中查看启动日志

    连接上接mycat插入数据

    在这里插入图片描述
    主库已出现数据
    在这里插入图片描述
    而从库配置为readhost,不会出现数据
    在这里插入图片描述

    展开全文
  • 使用MyCat实现mysql读写分离配置说明
  • mysql读写分离配置完整过程

    千次阅读 2018-11-19 17:48:15
    所以,我们有时候就需要对数据库进行主从配置,进行读写分离,增删改的时候用主库,读取的时候用从库,这样也能有效提高数据库的读写效率; 实践 在主mysql的ini文件添加; server-id=1 log-bin=mysql-bin ...
  • 本次要介绍的是mysql的主从复制,读写分离;及高可用MHA; 环境如下: master:CentOS7_x64 mysql5.721 172.16.3.175 db1 slave1:CentOS7_x64 mysql5.7.21 172.16.3.235 db2 slave2:CentOS7_x64 mysql5.7.21 172.16.3....
  • 要求配置2台MySQL服务器+1台代理服务器,实现MySQL代理的读写分离
  • MySQL读写分离 以“管理员身份”运行 cmd,进入mysql的bin目录 安装mysql 初始化 mysqld -initialize -insecure -user=mysql 安装mysql 服务 mysqld -install mysql-3307
  • SpringBoot实现MySQL读写分离

    千次阅读 热门讨论 2021-11-26 22:43:26
    在高并发下,需要对应用进行读写分离配置多数据源,即写操作走主库,读操作则走从库,主从数据库负责各自的读和写,缓解了锁的争用,提高了读取性能。 实现读写分离有多种方式,如使用中间件MyCat、Sharding-JDBC...
  • MyCat配置MySQL读写分离

    千次阅读 2019-06-05 15:37:22
    Mycat读写分离和自动切换机制,需要mysql的主从复制机制配合,即读从从机(slave)中读取,写向主机(master)中写入! 所以我门需要先完成mysql的主从备份, mysql主从备份 点击跳转 安装mycat 第一步: 我这里在...
  • Mycat 实现mysql读写分离配置

    千次阅读 2021-04-21 10:03:03
    之前项目中有主从复制,读写分离的场景,mycat 作为数据库分库分表中间件,这里记录一波使用操作 官网:mycat官网 一:环境&安装 环境:jdk 1.8+ centos 首先更新已安装的包: yum update 查看系统当前的java版本: ...
  • Linux 搭建mysql读写分离: 1.关闭两台服务器的防火墙:systemctl stop firewalld 主从配置: 主服务器配置 1.配置my.cnf (1).去掉log-bin=mysql-bin前的# //允许mysql使用binlog,开启主从复制(关键)。 ...
  • 相对于其他方法实现MySQL读写分离来说,采用Thinkphp框架实现MySQL读写分离简单易用,其配置文件示例代码如下: 'DB_TYPE'=> 'mysql', 'DB_DEPLOY_TYPE' => 1, //开打支持多服务器 'DB_RW_SEPARATE'=>true,//...
  • 基于Mycat的Mysql主从复制读写分离配置详解与示例,DBA必看的
  • mycat配置mysql读写分离

    2019-12-21 17:58:01
    mysql5.6主从 配置详解:https://blog.csdn.net/u010772230/article/details/103604978 第一步:配置server.xml 进入mycat,打开server.xml 第二步:配置schema.xml 删除掉schema.xml中无用的信...
  • mysql读写分离的坑 读写分离的主要目标是分摊主库的压力,由客户端选择后端数据库进行查询。还有种架构就是在MYSQL和客户端之间有一个中间代理层proxy,客户端之连接proxy,由proxy根据请求类型和上下文决定请求的...
  • MySQL读写分离又一好办法 使用 com.mysql.jdbc.ReplicationDriver 在用过Amoeba 和 Cobar,还有dbware 等读写分离组件后,今天我的一个好朋友跟我讲,MySQL自身的也是可以读写分离的,因为他们提供了一个新的驱动,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,823
精华内容 29,529
关键字:

mysql读写分离配置

mysql 订阅