读写分离 订阅
为了确保数据库产品的稳定性,很多数据库拥有双机热备功能。也就是,第一台数据库服务器,是对外提供增删改业务的生产服务器;第二台数据库服务器,主要进行读的操作。· 展开全文
为了确保数据库产品的稳定性,很多数据库拥有双机热备功能。也就是,第一台数据库服务器,是对外提供增删改业务的生产服务器;第二台数据库服务器,主要进行读的操作。·
信息
外文名
Read/Write Splitting
原    理
让主数据库处理事务性增、改、删操作,而从数据库处理SELECT查询操作
中文名
读写分离
诞生原因
为了确保数据库产品的稳定性
读写分离简介
读写分离(Read/Write Splitting)。1.原理:让主数据库(master)处理事务性增、改、删操作(INSERT、UPDATE、DELETE),而从数据库(slave)处理SELECT查询操作。2.诞生原因:2.1 为了确保数据库产品的稳定性,很多数据库拥有双机热备功能。也就是,第一台数据库服务器,是对外提供增删改查业务的生产服务器;第二台数据库服务器,仅仅接收来自第一台服务器的备份数据(注意,不同数据库产品,第一台数据库服务器,向第二台数据库服务器发送备份数据的方式不同)。当第一台数据库崩溃后,第二台数据库服务器,可以立即上线来代替第一台数据库服务器,并且,在第一台数据库服务器崩溃后,宝贵的数据,依然会存在于第二台数据库服务器里(根据目前业界的备份数据发送方式来看,当第一台数据库崩溃后,第一台数据库里的仍然会有少量的新数据,没能来得及被发送到第二台数据库服务器,所以,这部分数据就丢失了)。2.2 一般来说,为了配置方便,以及稳定性,这两台数据库服务器,都用的是相同的配置(思考一下,如果两台服务器的配置不同,会导致什么结果)。2.3 从上文的描述中,大家能看到,在实际运行中,第一台数据库服务器的压力,远远大于第二台数据库服务器。因此,很多人希望合理利用第二台数据库服务器的空闲资源。那么,第二台数据库服务器能做些什么事情呢?2.4 从数据库的基本业务来看,数据库的操作无非就是增删改查这4个操作。但对于“增删改”这三个操作,如果是双机热备的环境中做,一台机器做了这三个操作的某一个之后,需要立即将这个操作,同步到另一台服务器上。单向的同步,不复杂。但如果两台机器都需要向对方进行同步,那逻辑就非常复杂,而且还会大大降低性能。(从保证ACID特性的角度,思考一下为什么双向同步会非常复杂且低性能?而单向同步却不会?)出于这个原因,第二台备用的服务器,就只做了查询操作。进一步,为了降低第一台服务器的压力,干脆就把查询操作全部丢给第二台数据库服务器去做,第一台数据库服务器就只做增删改了。2.4 到这一步,就实现了所谓的读写分离。这样做,缺点也非常明显了。本来第二台数据库服务器,是用来做热备的,它就应该在一个压力非常小的环境下,保证运行的稳定性。而读写分离,却增加了它的压力,也就增加了不稳定性。因此,读写分离,实质上是一个在资金比较缺乏,但又需要保证数据安全的需求下,在双机热备方案上,做出的一种折中的扩展方案。
收起全文
精华内容
下载资源
问答
  • 读写分离

    2018-12-20 18:14:49
    mysql读写分离的原理读写分离的过程半同步复制并行复制读写分离出现的问题主从复制数据丢失产生原因解决方案:半同步复制主从复制延迟问题产生原因解决方案: 什么是读写分离? 读操作访问从库,写操作访问主库 针对...

    什么是读写分离?

    读操作访问从库,写操作访问主库
    针对读多写少的系统,通过增加从库的数量,增加读的并发,同时也增加了写并发
    

    mysql读写分离的原理

    1.原生支持读写分离
    2.开启binlog日志,记录所有的修改操作的sql
    

    读写分离的过程

    i.主库开启binlog日志,添加增删改操作
    ii.从库读取主库binlog日志,写到relay日志中(5.6.x版本后多线程)
    iii.从库读取relay日志,修改数据(串行化执行sql,瓶颈)
    

    在这里插入图片描述

    半同步复制

    从库写入relay日志后返回成功(binlog日志通过io线程到达从库relay日志的过程)
    

    并行复制

    mysql5.7,并发同步操作不同库(减少同步延迟)(relay日志到sql线程的过程)
    

    读写分离出现的问题

    主从复制数据丢失
    产生原因
    binlog日志还未同步到从数据的relay日志中,此时主宕机,数据丢失
    
    解决方案:半同步复制
    从库写入relay日志后返回成功。
    
    主从复制延迟问题
    产生原因
    主库并发过大导致延迟增加
    i.如果并发低,效率还是很高的
    ii.	1000/s,从库几ms延迟
    iii.2000/s,从库几十ms延迟
    iv.再往上,从库延迟几秒
    
    解决方案:
    1.降低主库并发(分库)
    2.并行复制(只是解决了只是解决了多个库的并发问题)
    3.代码逻辑(不要一插入就查询)
    4.如果非要一插入就查询,那么就直连主库。
    
    展开全文
  • 文章目录简介什么是数据库读写分离为什么要搞数据库读写分离配置主从同步的基本步骤实践阶段技术栈docker容器安装(若在不同服务器搭建数据库,此步可省略)Mysql主从同步配置Django项目搭建 简介 什么是数据库读写...

    简介

    什么是数据库读写分离

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

    为什么要搞数据库读写分离

    在实际的生产环境中,对数据库的读和写都在同一个数据库服务器中,是不能满足实际需求的。无论是在安全性、高可用性还是高并发等各个方面都是完全不能满足实际需求的。因此,通过主从复制的方式来同步数据,再通过读写分离来提升数据库的并发负载能力。

    配置主从同步的基本步骤

    有很多种配置主从同步的方法,可以总结为如下的步骤:

    1. 在主服务器上,必须开启二进制日志机制和配置一个独立的ID
    2. 在每一个从服务器上,配置一个唯一的ID,创建一个用来专门复制主服务器数据的账号
    3. 在开始复制进程前,在主服务器上记录二进制文件的位置信息
    4. 如果在开始复制之前,数据库中已经有数据,就必须先创建一个数据快照(可以使用mysqldump导出数据库,或者直接复制数据文件)
    5. 配置从服务器要连接的主服务器的IP地址和登陆授权,二进制日志文件名和位置

    实践阶段

    测试环境

    Mysql5.7.29主服务器:ubuntu16
    Mysql5.7.29从服务器:ubuntu16上的docker容器
    WEB框架:Django1.8

    docker容器安装(若在不同服务器搭建数据库,此步可省略)

    docker三个核心概念: Repository(仓库) -> Image(镜像) -> Container(容器)

    卸载可能存在的旧版本

    sudo apt-get remove docker docker-engine docker-ce docker.io
    

    更新apt包

    sudo apt-get update
    

    安装以下包以使apt可以通过HTTPS使用存储库(repository):

    sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
    

    在这里插入图片描述
    添加GPG密钥

    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
    

    设置stable存储库

    sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
    

    再次更新apt包

    sudo apt-get update
    

    安装最新版本的Docker CE(社区免费版)

    sudo apt-get install -y docker-ce
    

    在这里插入图片描述

    验证docker: sudo docker version 或 sudo docker info
    在这里插入图片描述

    查看docker服务是否启动

    systemctl status docker
    

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200324163304257.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1B5dGhvbmljYw==,size_16,color_FFFFFF,t_70
    经典的hello world

    运行docker命令时需要root权限或者加sudo

    sudo docker pull hello-world拉取dockerHub上的hello-world镜像
    sudo docker images查看镜像信息
    在这里插入图片描述
    可以看到已存在hello-world镜像

    **字段解释**
    	REPOSITORY: 来自于哪个仓库;
    	TAG: 镜像的标签信息,比如 5.7、latest 表示不同的版本信息;
    	IMAGE ID: 镜像的 ID, 如果您看到两个 ID 完全相同,那么实际上,它们指向的是同一个镜像,只是标签名称不同罢了;
    	CREATED: 镜像最后的更新时间;
    	SIZE: 镜像的大小,优秀的镜像一般体积都比较小
    

    生成该镜像的实例容器(镜像与容器的关系就像类和实例类对象)

    sudo docker run hello-world
    

    在这里插入图片描述
    有以上输出,表示docker安装成功.

    Docker服务相关命令

    开启Docker服务
    systemctl start docker

    停止Docker服务
    systemctl stop docker

    重启Docker服务
    systemctl restart docker

    开机自启Docker服务
    systemctl enable docker

    创建mysql容器

    家目录下创建mysql_slave目录作为容器挂载数据卷
    mkdir mysql_slave

    进入mysql_slave目录
    cd mysql_slave

    创建data目录
    mkdir data

    将宿主机的mysql配置文件目录拷到当前数据卷目录下
    cp -a /etc/mysql/mysql.conf.d ./

    将配置文件拷贝过来后,编辑mysql.conf.d目录下的mysqld.cnf 文件

    宿主机中的mysql做为主服务器,其server-id设为1,从服务器只要不是1都行,这边取2
    server-id = 2

    创建容器(如果没有该镜像,则自动从dockerHub拉取该镜像并创建容器)
    docker run -id
    -p 3308:3306
    –name=mysql-slave
    -e MYSQL_ROOT_PASSWORD=mysql
    -v /root/mysql_slave/data:/var/lib/mysql
    -v /root/mysql_slave/mysql.conf.d:/etc/mysql/mysql.conf.d
    mysql:5.7.29

    参数解释:
    -p 指定映射的端口,左边为宿主机端口,右边为容器端口,这样就可以通过映射的3308端口在宿主机以外的外部机器访问该容器中的mysql
    -id 表示该容器作为守护进程在后台运行,创建后马上运行,但是不会进入shell终端,退出后也不会真正退出
    –name 指定实例容器的名称
    -e 指定数据库密码
    -v 指定要挂载的目录或文件,必须写绝对路径,左边为宿主机路径,右边为容器路径
    mysql:5.7.29 指定要创建的容器的镜像及其版本,由于宿主机中mysql是5.7.29版本,所以我们这里创建mysql5.7.29的容器

    查看运行中的容器

    docker ps
    

    在这里插入图片描述

    Mysql主从同步配置

    宿主机中导出mysql主服务器sql文件

    mysqldump -uroot -pmysql --all-databases --lock-all-tables > ~/master_db.sql

    参数解释:
    -u :用户名
    -p :示密码
    –all-databases :导出所有数据库
    –lock-all-tables :执行操作时锁住所有表,防止操作时有数据修改
    ~/master_db.sql :导出的备份数据(sql文件)位置,可自己指定

    在这里插入图片描述
    在宿主机中根据映射的端口将sql文件导入容器数据库中

    mysql -uroot -pmysql -h127.0.0.1 --port=3308 < ~/master_db.sql
    

    编辑设置mysqld的配置文件,设置log_bin和server-id

    sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf
    

    在这里插入图片描述
    在这里插入图片描述
    重启mysql服务

    sudo service mysql restart
    

    在这里插入图片描述
    登入mysql,创建用于从服务器同步数据使用的帐号并刷新缓存

    mysql –uroot –pmysql
    
    GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' identified by 'slave';
    
    FLUSH PRIVILEGES;
    

    在这里插入图片描述
    获取主服务器的二进制日志信息(File为使用的日志文件名字,Position为使用的文件位置,这两个参数须记下,配置从服务器时会用到)

    SHOW MASTER STATUS;
    

    在这里插入图片描述
    进入docker容器配置mysql从服务器

    执行以下命令进入指定名称的容器的shell终端

    docker exec -it mysql-slave bash
    

    在这里插入图片描述
    进入容器中的mysql数据库并设置连接到master主服务器

    mysql -uroot -pmysql
    
    change master to master_host='192.168.254.137', master_user='slave', master_password='slave',master_log_file='mysql-bin.000001', master_log_pos=590;
    

    参数解释:
    master_host:主服务器宿主机Ubuntu的ip地址
    master_log_file: 前面查询到的主服务器日志文件名
    master_log_pos: 前面查询到的主服务器日志文件位置

    在这里插入图片描述
    开启同步,查看同步状态
    在这里插入图片描述

    Django项目搭建

    项目创建
    django-admin startproject test2
    
    应用创建
    python manage.py startapp booktest
    
    模板定义

    为应用booktest下的视图index创建模板index.html,目录结构如下图:
    在这里插入图片描述
    打开templtes/booktest/index.html文件,定义代码如下:

    <html>
    <head>
        <title>案例</title>
    </head>
    <body>
    <a href="/create/">创建</a>
    <ul>
    {%for book in list%}
        <li>{{book.btitle}}--<a href="/delete{{book.id}}/">删除</a></li>
    {%endfor%}
    </ul>
    </body>
    </html>
    
    编辑设置文件

    添加应用名称
    在这里插入图片描述
    定义模板文件路径
    在这里插入图片描述
    注释原有的sqlite连接配置,写入如下代码:

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': 'test2',  # 数据库名字,
            'USER': 'root',  # 数据库登录用户名
            'PASSWORD': 'mysql',  # 数据库登录密码
            'HOST': '192.168.254.137',  # 数据库所在主机
            'PORT': '3306',  # 数据库端口
        },
        'slave': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': 'test2',  # 数据库名字,
            'USER': 'root',  # 数据库登录用户名
            'PASSWORD': 'mysql',  # 数据库登录密码
            'HOST': '192.168.254.137',  # 数据库所在主机
            'PORT': '3308',  # 数据库端口
        },
    }
    

    在这里插入图片描述

    模型类编写

    打开booktest/models.py文件,定义模型类源码如下

    from django.db import models
    
    # 定义图书模型类BookInfo
    class BookInfo(models.Model):
        btitle = models.CharField(max_length=20)  # 图书名称
        bpub_date = models.DateField()  # 发布日期
        bread = models.IntegerField(default=0)  # 阅读量
        bcomment = models.IntegerField(default=0)  # 评论量
        isDelete = models.BooleanField(default=False)  # 逻辑删除
    
    
    # 定义英雄模型类HeroInfo
    class HeroInfo(models.Model):
        hname = models.CharField(max_length=20)  # 英雄姓名
        hgender = models.BooleanField(default=True)  # 英雄性别
        isDelete = models.BooleanField(default=False)  # 逻辑删除
        hcomment = models.CharField(max_length=200)  # 英雄描述信息
        hbook = models.ForeignKey('BookInfo')  # 英雄与图书表的关系为一对多,所以属性定义在英雄模型类中
    
    迁移
    安装pymysql
    pip install pymysql
    
    安装成功之后,在test2/_init_.py文件中加上如下代码:
    import pymysql
    pymysql.install_as_MySQLdb()
    
    生成迁移文件
    python manage.py makemigrations
    
    执行迁移文件在数据库生成表
    python manage.py migrate
    

    打开数据库的命令行,查看当前所有表如下图:
    在这里插入图片描述

    测试数据

    在数据库命令行中,复制如下语句执行,向booktest_bookinfo表中插入测试数据:

    insert into booktest_bookinfo(btitle,bpub_date,bread,bcomment,isDelete) values
    ('射雕英雄传','1980-5-1',12,34,0),
    ('天龙八部','1986-7-24',36,40,0),
    ('笑傲江湖','1995-12-24',20,80,0),
    ('雪山飞狐','1987-11-11',58,24,0);
    

    再复制如下语句执行,向booktest_heroinfo表中插入测试数据:

    insert into booktest_heroinfo(hname,hgender,hbook_id,hcomment,isDelete) values
    ('郭靖',1,1,'降龙十八掌',0),
    ('黄蓉',0,1,'打狗棍法',0),
    ('黄药师',1,1,'弹指神通',0),
    ('欧阳锋',1,1,'蛤蟆功',0),
    ('梅超风',0,1,'九阴白骨爪',0),
    ('乔峰',1,2,'降龙十八掌',0),
    ('段誉',1,2,'六脉神剑',0),
    ('虚竹',1,2,'天山六阳掌',0),
    ('王语嫣',0,2,'神仙姐姐',0),
    ('令狐冲',1,3,'独孤九剑',0),
    ('任盈盈',0,3,'弹琴',0),
    ('岳不群',1,3,'华山剑法',0),
    ('东方不败',0,3,'葵花宝典',0),
    ('胡斐',1,4,'胡家刀法',0),
    ('苗若兰',0,4,'黄衣',0),
    ('程灵素',0,4,'医术',0),
    ('袁紫衣',0,4,'六合拳',0);
    
    视图编写

    打开booktest/views.py文件,定义视图代码如下:

    from django.shortcuts import render,redirect
    from booktest.models import *
    from datetime import date
    
    #查询所有图书并显示
    def index(request):
    	#使用从服务器进行读操作
        list=BookInfo.objects.using('slave').all()
        return render(request,'booktest/index.html',{'list':list})
    
    #默认使用主服务器进行写操作
    #创建新图书
    def create(request):
        book=BookInfo()
        book.btitle = '流星蝴蝶剑'
        book.bpub_date = date(1995,12,30)
        book.save()
        #转向到首页
        return redirect('/')
    
    #逻辑删除指定编号的图书
    def delete(request,id):
        book=BookInfo.objects.get(id=int(id))
        book.delete()
        #转向到首页
        return redirect('/')
    
    url路由配置

    打开test2/urls.py文件,配置url如下:

    from django.conf.urls import include, url
    from django.contrib import admin
    
    urlpatterns = [
        url(r'^admin/', include(admin.site.urls)),
        #引入booktest的url配置
        url(r'^',include('booktest.urls')),
    ]
    

    在booktest应用下创建urls.py文件,代码如下:

    from django.conf.urls import url
    from booktest import views
    
    urlpatterns=[
        url(r'^$',views.index),
        url(r'^delete(\d+)/$',views.delete),
        url(r'^create/$',views.create),
    ]
    
    运行
    python manage.py runserver 127.0.0.1
    

    html界面中点击创建或删除后,由主服务器执行写操作,由从服务器同步主服务器数据执行读操作,可以看到渲染的数据在增加或减少
    在这里插入图片描述

    展开全文
  • Redis主从配置读写分离

    万次阅读 2019-07-15 00:00:01
    1.主从概念 一个master可以拥有多个slave,一个slave又可以拥有多个slave,如此下去,... 通过主从配置可以实现读写分离 2.配置主(绑定本机ip) 修改/etc/redis/redis.conf文件 sudo vim redis.co...

    1.主从概念

    • 一个master可以拥有多个slave,一个slave又可以拥有多个slave,如此下去,形成了强⼤的多级服务器集群架构
    • master用来写数据,slave用来读数据,经统计:网站的读写比率是10:1
    • 通过主从配置可以实现读写分离

    2.配置主(绑定本机ip)

    • 修改/etc/redis/redis.conf文件

      sudo vim redis.conf
      bind 192.168.26.128

    • 重启redis服务

      sudo service redis stop
      redis-server /etc/redis/redis.conf

    3.配置从

    • 复制etc/redis/redis.conf文件

      sudo cp redis.conf ./slave.conf

    • 修改redis/slave.conf文件

      sudo vim slave.conf

    • 编辑内容(绑定主客户端ip,隶属主客户端ip和端口)

      bind 192.168.26.128
      slaveof 192.168.26.128 6379
      port 6378

    • redis服务

      sudo redis-server /etc/redis/slave.conf

    4.查看主从关系

    redis-cli -h 192.168.26.128 info Replication

    注:若执行此命令出错,修改主客户端配置文件并重启:protected-mode no

    5.数据库操作

    • 进入主客户端

      redis-cli -h 192.168.26.128 -p 6379

      set name zhangsan

    • 进入从的客户端

      redis-cli -h 192.168.26.128 -p 6378

      get name

     发现已同步成功。

    展开全文
  • MYSQL读写分离

    2020-11-05 22:58:08
    MYSQL读写分离一、概述1.1 为什么要读写分离?1.2 原理1.3 目前比较常见的MySQL读写分离分为二种:2.2:实验配置阶段 一、概述 1.1 为什么要读写分离? 在企业应用中,在大量的数据请求下,单台数据库将无法承担...

    一、概述

    1.1 背景

    • 在企业应用中,在大量的数据请求下,单台数据库将无法承担所有的读写操作
    • 配置多台数据库服务器以实现读写分离
    • 读写分离建立在主从复制的基础上

    1.2 原理

    • 读写分离就是只在主服务器上写,只在从服务器上读
    • 主数据库处理事务性查询,而从数据库处理 select 查询
    • 数据库复制被用来把事务性查询导致的变更同步到集群中的从数据库

    1.3 目前比较常见的MySQL读写分离分为二种:

    第一种

    基于程序代码内部实现

    在代码中根据select、insert进行路由分类,这类方法也是目前生产环境应用广泛的,优点是性能较好,因为在程序代码中实现,不需要增加额外的设备作为硬件开支;缺点是需要开发人员来实现,运维人员无从下手。

    第二种

    基于中间代理层实现

    代理一般位于客户端和服务器之间,代理服务器接受到客户端的请求后通过判断后转发到后端数据库,有二个代表性程序:

    MySQL-Proxy ----MySQL的开源项目,通过自带的lua脚本进行SQL判断,MySQL官方不建议用这个在生产环境中
    Amoeba(变形虫) ----由陈思儒开发,曾就职于阿里巴巴,该程序由Java语言开发,阿里将其用于生产环境

    二、实验配置阶段

    2.1主从同步部分

    主服务器:

    1.时间同步

    [root@master ~]# yum -y install ntp ntpdate
    [root@master ~]# ntpdate ntp.aliyun.com
    [root@master ~]# vi /etc/ntp.conf 
    server 127.127.1.0             #本地是时钟源
    fudge 127.127.1.0 stratum 8    #设置时间层级为8
    [root@master ~]# systemctl start ntpd
    

    2.mysql主服务器配置

    [root@master ~]# vi /etc/my.cnf
    server-id = 1               #指定id号,服务器的唯一标识,不能相同
    log-bin=master-bin           #主服务器日志文件
    log-slave-updates=true       #从服务器更新二进制日志
    [root@master ~]# systemctl restart mysqld
    [root@master ~]# mysql -u root -pqwe123
    mysql> GRANT REPLICATION SLAVE ON *.* TO 'myslave'@'10.0.0.%' IDENTIFIED BY 'abc123';
    mysql> flush privileges;
    mysql> show master status;
    +-------------------+----------+--------------+------------------+-------------------+
    | File              | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
    +-------------------+----------+--------------+------------------+-------------------+
    | master-bin.000006 |      120 |              |                  |                   |
    +-------------------+----------+--------------+------------------+-------------------+
    1 row in set (0.00 sec)
    #特别注意File和Position对应的master-bin.000006以及120两个参数,从服务器同步时需要用到
    

    从服务器

    1.时间同步

    [root@slave-1 ~]# yum -y install ntpdate
    [root@slave-1 ~]# ntpdate 10.0.0.40
    

    2.mysql主服务器配置

    [root@slave-1 ~]# vi /etc/my.cnf
    server-id = 12       
    relay-log=relay-log-bin     #从主服务器上同步日志文件记录到本地  
    relay-log-index=slave-relay-bin.index   #定义relay-log的位置和名称
    [root@slave-1 ~]# systemctl restart mysqld
    [root@slave-1 ~]# mysql -u root -pqwe123
    mysql> change master to master_host='10.0.0.40',master_user='myslave',master_password='abc123',master_log_file='master-bin.000006',master_log_pos=120;
    mysql> start slave;    #开启从服务 
    mysql> show slave status\G;    #查看状态
    *************************** 1. row ***************************
                   Slave_IO_State: Waiting for master to send event
                      Master_Host: 10.0.0.40
                      Master_User: myslave
                      Master_Port: 3306
                    Connect_Retry: 60
                  Master_Log_File: master-bin.000004
              Read_Master_Log_Pos: 120
                   Relay_Log_File: localhost-relay-bin.000002
                    Relay_Log_Pos: 284
            Relay_Master_Log_File: master-bin.000004
                 Slave_IO_Running: Yes
                Slave_SQL_Running: Yes
                  Replicate_Do_DB: 
              Replicate_Ignore_DB: 
               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: 120
                  Relay_Log_Space: 461
                  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: 
      Replicate_Ignore_Server_Ids: 
                 Master_Server_Id: 1
                      Master_UUID: d67a9e7a-189b-11eb-8dfe-000c29302649
                 Master_Info_File: /usr/local/mysql/data/master.info
                        SQL_Delay: 0
              SQL_Remaining_Delay: NULL
          Slave_SQL_Running_State: Slave has read all relay log; waiting for the slave I/O thread to update it
               Master_Retry_Count: 86400
                      Master_Bind: 
          Last_IO_Error_Timestamp: 
         Last_SQL_Error_Timestamp: 
                   Master_SSL_Crl: 
               Master_SSL_Crlpath: 
               Retrieved_Gtid_Set: 
                Executed_Gtid_Set: 
                    Auto_Position: 0
    1 row in set (0.00 sec)
    

    实验验证

    主服务器

    mysql> create database follow;
    Query OK, 1 row affected (0.00 sec)
    
    mysql> show databases;
    +--------------------+
    | Database           |
    +--------------------+
    | information_schema |
    | follow             |
    | mysql              |
    | performance_schema |
    +--------------------+
    4 rows in set (0.00 sec)
    

    从服务器

    mysql> show databases;
    +--------------------+
    | Database           |
    +--------------------+
    | information_schema |
    | follow             |
    | mysql              |
    | performance_schema |
    +--------------------+
    4 rows in set (0.01 sec)
    

    2.2读写分离部分

    1.安装jdk环境

    [root@amoeba packages]# tar zxf jdk-8u91-linux-x64.tar.gz
    [root@amoeba packages]# mv jdk1.8.0_91/ /usr/local/java
    [root@amoeba packages]# vi /etc/profile
    #末尾添加
    export JAVA_HOME=/usr/local/java    
    export JRE_HOME=/usr/local/java/jre
    export AMOEBA_HOME=/usr/local/amoeba
    export PATH=$PATH:$JAVA_HOME/bin:$AMOEBA_HOME/bin
    [root@amoeba packages]# source /etc/profile
    

    2.安装amoeba代理

    [root@amoeba packages]# unzip amoeba-mysql-3.0.5-RC-distribution.zip
    [root@amoeba packages]# mv amoeba-mysql-3.0.5-RC /usr/local/amoeba
    [root@amoeba ~]# chmod -R 755 /usr/local/amoeba/
    [root@amoeba ~]# vi /usr/local/amoeba/jvm.properties
     32 #JVM_OPTIONS="-server -Xms256m -Xmx1024m -Xss196k -XX:PermSize=16m -XX:MaxPe    rmSize=96m"
     33 JVM_OPTIONS="-server -Xms1024m -Xmx1024m -Xss256k"
    

    3.在三台MySQL上添加权限开放给amoeba访问

    mysql> grant all on *.* to 'test'@'10.0.0.%' identified by 'abc123';
    

    4.修改amoeba主配置文件

    [root@amoeba ~]# vi /usr/local/amoeba/conf/amoeba.xml
    #26,28行修改如下 修改客户端连接amoeba前端服务器时使用的用户名和密码
    <property name="user">amoeba</property>
    <property name="password">123123</property>
    
    #83行修改如下(去掉注释)
    <property name="defaultPool">master</property>
    <property name="writePool">master</property>
    <property name="readPool">slaves</property>
    

    5.修改dbServers.xml 文件

    [root@amoeba ~]# vi /usr/local/amoeba/conf/dbServers.xml 
    指定为amoeba创建的允许读取数据库的用户名和密码
    22                         <!-- mysql schema -->
    23                         <property name="schema">mysql</property> ###5.7版本没有默认的test数据库
    24                         <!-- mysql user -->
    25                         <property name="user">test</property>
    26                         <!-- mysql password -->
    27                         <property name="password">abc123</property>
    
    配置三个服务器主机名和地址
             <dbServer name="master"  parent="abstractServer">
                     <factoryConfig>
                             <property name="ipAddress">10.0.0.40</property>
                     </factoryConfig>
             </dbServer>
    
             <dbServer name="slave1"  parent="abstractServer">
                     <factoryConfig>
                             <property name="ipAddress">10.0.0.41</property>
                     </factoryConfig>
             </dbServer>
     
             <dbServer name="slave2"  parent="abstractServer">
                     <factoryConfig>
                             <property name="ipAddress">10.0.0.42</property>
                     </factoryConfig>
             </dbServer>
    
    指定名为slaves的poolNames中pools的主机名
             <dbServer name="slaves" virtual="true">
                             <property name="poolNames">slave1,slave2</property>
             </dbServer>
    

    6.启动amoeba服务器准备测试

    [root@amoeba ~]# /usr/local/amoeba/bin/launcher
    [root@amoeba ~]# netstat -anpt | grep 8066
    tcp6       0      0 :::8066                 :::*                    LISTEN      3226/java
    

    7.验证
    在master新建库和表

    mysql> create database amoeba;
    mysql> use amoeba;
    mysql> create table test(id int(2),name varchar(64));
    

    在两台从服务器上停止服务

    mysql> stop slave;
    

    在主服务上插入内容不会同步(通过amoeba操作)

    主服务器

    mysql> insert into test values(1,'alice');
    

    从服务器

    mysql> select * from amoeba.test;
    Empty set (0.00 sec)
    

    在从服务器1上直接插入内容

    mysql> insert into amoeba.test values(2,'ben');
    mysql> select * from amoeba.test;
    +------+------+
    | id   | name |
    +------+------+
    |    2 | ben  |
    +------+------+
    

    在从服务器2上直接插入内容

    mysql> insert into amoeba.test values(3,'chalice');
    mysql> select * from amoeba.test;
    +------+---------+
    | id   | name    |
    +------+---------+
    |    3 | chalice |
    +------+---------+
    

    在客户端amoeba上测试读操作

    
    [root@localhost ~]# mysql -uamoeba -p123123 -h 10.0.0.49 -P 8066
    mysql> use amoeba;
    mysql> select * from test;
    +------+------+
    | id   | name |
    +------+------+
    |    2 | ben  |
    +------+------+
    1 row in set (0.01 sec)
    
    mysql> select * from test;
    +------+---------+
    | id   | name    |
    +------+---------+
    |    3 | chalice |
    +------+---------+
    1 row in set (0.00 sec)
    

    第一次向从服务器1读数据,第二次向从服务器2读数据,不会读取到主服务器的数据

    在客户端测试写操作

    客户端
    mysql> insert into test values(4,'david');
    Query OK, 1 row affected (0.01 sec)
    
    mysql> select * from test;
    +------+------+
    | id   | name |
    +------+------+
    |    2 | ben  |
    +------+------+
    1 row in set (0.00 sec)
    
    mysql> select * from test;
    +------+---------+
    | id   | name    |
    +------+---------+
    |    3 | chalice |
    +------+---------+
    1 row in set (0.00 sec)
    
    主:
    mysql> select * from amoeba.test;
    +------+-------+
    | id   | name  |
    +------+-------+
    |    1 | alice |
    |    4 | david |
    +------+-------+
    2 rows in set (0.00 sec)
    

    在客户端上看不到新插入的数据,只能在主服务器端看到,说明写操作在主服务器上,证明已经实现读写分离。

    在客户端amoeba上看不到新插入的数据,因为同步没有开启,只有主服务器上可以看到数据

    mysql> select * from test;
    +------+------+
    | id   | name |
    +------+------+
    |    2 | ben  |
    +------+------+
    
    mysql> select * from test;
    +------+---------+
    | id   | name    |
    +------+---------+
    |    3 | chalice |
    +------+---------+
    1 row in set (0.01 sec)
    

    开启同步

    从1:
    mysql> start slave;
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select * from amoeba.test;
    +------+-------+
    | id   | name  |
    +------+-------+
    |    2 | ben   |
    |    1 | alice |
    |    4 | david |
    +------+-------+
    3 rows in set (0.00 sec)
    
    从2:
    mysql> start slave;
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select * from amoeba.test;
    +------+---------+
    | id   | name    |
    +------+---------+
    |    3 | chalice |
    |    1 | alice   |
    |    4 | david   |
    +------+---------+
    3 rows in set (0.00 sec)
    
    主:
    mysql> select * from test;
    +------+-------+
    | id   | name  |
    +------+-------+
    |    1 | alice |
    |    4 | david |
    +------+-------+
    2 rows in set (0.00 sec)
    
    
    客户端:
    mysql> select * from test;
    +------+-------+
    | id   | name  |
    +------+-------+
    |    2 | ben   |
    |    1 | alice |
    |    4 | david |
    +------+-------+
    3 rows in set (0.00 sec)
    
    mysql> select * from test;
    +------+---------+
    | id   | name    |
    +------+---------+
    |    3 | chalice |
    |    1 | alice   |
    |    4 | david   |
    +------+---------+
    3 rows in set (0.01 sec)
    
    展开全文
  • springboot数据库读写分离,代码实现一主两从的读写分离,业务代码不影响,正常写就可以。可以根据自己需要修改
  • sharding-proxy shardingsphere mysql分库分表 mysql读写分离 sharing-jdbc mycat对比
  • MySQL读写分离

    2019-05-24 10:36:41
    @MySQL读写分离 一 :MySQL主从复制原理图 二 :为什么MySQL要读写分离? 三 :MySQL读写分离,主从复制面试题爬坑 1、面试题 你们有没有做MySQL读写分离?如何实现mysql的读写分离?MySQL主从复制原理的是啥?...
  • Spring Boot 读写分离

    万次阅读 2019-07-03 19:21:31
    Spring Boot 读写分离简单实现: 一、数据源配置 此处只简单配置两个数据源,master(主-写)和slave(从-读) @PropertySource读取指定目录下配置文件 import javax.sql.DataSource; import org.slf4j.Logger; ...
  • mybatis读写分离

    千次阅读 2019-01-10 11:23:01
    mybatis读写分离实现方式有很多种,当然如果没有太过复杂的处理,可以使用阿里云数据库自带的读写分离连接,那样会更加简洁。本文主要对mybatis实现读写分离。主要的实现方式有一下四种: 方案1 通过MyBatis配置...
  • MyBatis做读写分离

    2016-08-28 16:27:39
    MyBatis做读写分离
  • rds读写分离

    2019-06-16 17:28:00
    RDS读写分离,海量数据一键搞定 RDS读写分离,海量数据一键搞定
  • MongoDB读写分离

    2020-05-30 13:27:58
    在结构优化、索引优化之后,为了进一步优化系统,想到读写分离。 java端配置读写分离 这里,mongo采用的是副本集(Replica Set)的部署方式 这里采用的事xml配置文件形式: read-preference=“SECONDARY_PREFERRED”...
  • 小程序读写分离

    2019-09-14 06:18:33
    小程序读写分离小程序读写分离小程序读写分离小程序读写分离小小程序读写分离小程序读写分离小程序读写分离程序读写分离 转载于:https://my.oschina.net/u/3017386/...
  • 在linux下用于部署读写分离的中间件maxscale。它是实现mysql数据库的读写分离
  • Mysql读写分离

    千次阅读 2018-10-28 20:48:20
    Mysql读写分离 1、什么是读写分离读写分离,基本的原理是让主数据库处理事务性增、改、删操作(INSERT、UPDATE、DELETE),而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中...
  • Linux 使用Mycat实现读写分离(基于Mysql的读写分离

    万次阅读 多人点赞 2018-06-13 22:28:29
    各位同学大家好,今天给大家分享一下用Mycat进行数据库的读写分离,本篇文章是基于上一篇的mysql主从复制。Linux上实现Mysql的主从复制(为Mycat读写分离作准备) 在上一篇文章中,我们在两个服务器使用同版本的...
  • 主要介绍了CodeIgniter读写分离实现方法,结合实例形式较为详细的分析了CodeIgniter读写分离的相关配置与功能实现技巧,需要的朋友可以参考下
  • 有一些技术同学可能对于“读写分离”了解不多,认为数据库的负载问题都可以使用“读写分离”来解决。 这其实是一个非常大的误区,我们要用“读写分离”,首先应该明白“读写分离”是用来解决什么样的问题的,而不是...
  • redis读写分离demo

    2018-01-09 17:07:05
    简单的redis读写分离demo 用的是依赖注入的方式,redis用的是主从复制
  • mongoDB读写分离

    千次阅读 2019-05-30 13:54:42
    在结构优化、索引优化之后,为了进一步优化系统,想到读写分离。 java端配置读写分离 这里,mongo采用的是副本集(Replica Set)的部署方式 这里采用的事xml配置文件形式: read-preference=“SECONDARY_PREFERRED”...
  • mysql读写分离

    2018-09-30 16:57:44
    什么是读写分离 在数据库集群架构中,让主库负责处理事务性查询,而从库只负责处理select查询,让两者分工明确达到提高数据库整体读写性能。当然,主数据库另外一个功能就是负责将事务性查询导致的数据变更同步到从...
  • 数据库读写分离主要解决高并发时,提高系统的吞吐量。因为大部分场景下都是读多写少。下图是数据库读写分离模型。 每次请求打到这个系统后:读请求,直接读从库写请求,先写入主库,然后主库将数据同步到其他从库在...
  • 配置 Mysql 读写分离+强制走写节点+根据主从延时的读写分离http://www.linuxmysql.com/14/2019/1008.htm

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,748
精华内容 14,699
关键字:

读写分离