项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群

文章目录

    • 一.项目介绍
      • 1.拓扑图
      • 2.详细介绍
    • 二.前期准备
      • 1.项目环境
      • 2.IP划分
    • 三. 项目步骤
      • 1.ansible部署软件环境
        • 1.1 安装ansible环境
        • 1.2 建立免密通道
        • 1.3 ansible批量部署软件
        • 1.4 统一5台mysql服务器的数据
      • 2.配置基于GTID的半同步主从复制
        • 2.1 在master上安装配置半同步的插件,再配置
        • 2.2配置slave3延迟备份服务器
      • 3.master创建一个计划任务,远程同步到slave4异地备份服务器
        • 3.1 在slave4远程备份服务器上操作
        • 3.2 数据源master服务器操作
        • 3.3 创建计划任务
      • 4 部署mysqlrouter中间件实现读写分离,安装keepalived部署双vip实现高可用
        • 4.1 部署mysqlrouter中间件实现读写分离
        • 4.2安装keepalived部署双vip实现高可用
      • 5.搭建DNS域名服务器
      • 6.使用sysbench进行压力测试,prometheus和grafana实现监控并出图
        • 4.1 安装prometheus server
        • 4.2 在prometheus server里添加安装了exporter程序的机器
        • 4.3 grafana部署和安装
        • 4.4 sysbench压力测试
    • 四. 项目总结
      • 1.做项目时遇到的问题
      • 2.项目心得

一.项目介绍

1.拓扑图

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第1张图片

2.详细介绍

项目名称:基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群
项目环境:centos7.9,mysql5.7.30,mysqlrouter8.0.21,keepalived 1.3.5,ansible 2.9.27等
项目描述:
本项目的目的是构建一个高可用的能实现读写分离的高效的MySQL集群,确保业务的稳定,能沟通方便的监控整个集群,同时能批量的去部署和管理整个集群。

项目步骤:
1.配置好ansible服务器并建立免密通道,一键安装MySQL、mysqlroute、node_exporters、dns等软件,在master上导出基础数据到ansible上,发布到所有slave服务器上并导入
2.安装好半同步相关的插件,开启gtid功能,启动主从复制服务,配置延迟备份服务器,从slave1上拿二进制日志
3.在master上创建一个计划任务每天2:30进行数据库的备份脚本,使用rsync+sersync远程同步到slave4异地备份服务器上
4.安装部署mysqlrouter中间件软件,实现读写分离;安装keepalived实现高可用,配置2个vrrp实例实现双vip的高可用功能
5.搭建DNS域名服务器,配置一个域名对应2个vip,实现基于DNS的负载均衡,访问同一URL解析出双vip地址
6.使用sysbench整个MySQL集群的性能(cpu、IO、内存等)进行压力测试,安装部署prometheus实现监控,grafana出图了解系统性能的瓶颈并调优

项目心得:
1.一定要规划好整个集群的架构,配置要细心,脚本要提前准备好,边做边修改,防火墙和selinux的问题一定要多注意
2.对MySQL的集群和高可用有了深入的理解,对自动化批量部署和监控有了更加多的应用和理解
3.keepalived的配置需要更加细心,对keepalievd的脑裂和vip漂移现象也有了更加深刻的体会和分析
4.认识到了系统性能资源的重要性,对压力测试下整个集群的瓶颈有了一个整体概念

二.前期准备

1.项目环境

centos7.9,mysql5.7.30,mysqlrouter8.0.21,keepalived 1.3.5,ansible 2.9.27等

2.IP划分

准备11台centos7.9的虚拟机,并且分配IP地址:

主机名 IP
DNS服务器 192.168.98.144
mysqlrouter1 192.168.98.143
mysqlrouter2 192.168.98.138
master 192.168.98.131
slave1 192.168.98.142
slave2 192.168.98.140
slave3 192.168.98.135
slave4 192.168.98.146
ansible 192.168.98.147
监控服务器 192.168.98.145
sysbench压力测试机 192.168.98.148

三. 项目步骤

1.ansible部署软件环境

配置好ansible服务器并建立免密通道,一键安装MySQL、mysqlroute、node_exporters、dns等软件,在master上导出基础数据到ansible上,发布到所有slave服务器上并导入

1.1 安装ansible环境

[root@ansible ~]# yum install epel-release -y
[root@ansible ~]# yum install ansible -y
#修改配置文件,只需要配置如下八台,监控和压力测试机单独部署
[root@localhost ~]# vim /etc/ansible/hosts
[mysqlrouter]
192.168.98.143
192.168.98.138

[mysql]
192.168.98.131
192.168.98.142
192.168.98.140
192.168.98.135
192.168.98.146

[dns]
192.168.98.144

1.2 建立免密通道

[root@localhost ~]# ssh-keygen -t rsa
[root@localhost ~]# cd .ssh
[root@localhost .ssh]# ls
id_rsa  id_rsa.pub  known_hosts
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]
[root@localhost .ssh]# ssh-copy-id -i id_rsa.pub [email protected]

1.3 ansible批量部署软件

1.3.1 在ansible机器上面创建nginx脚本

[root@localhost ~]#vim onekey_install_mysql.sh
#!/bin/bash

#解决软件的依赖关系
yum  install cmake ncurses-devel gcc  gcc-c++  vim  lsof bzip2 openssl-devel ncurses-compat-libs net-tools -y

#下载安装包到家目录下(由于文件较大请自行下载)
cd ~
#curl -O https://dev.mysql.com/downloads/file/?id=519542

#解压mysql二进制安装包
tar  xf  mysql-5.7.43-linux-glibc2.12-x86_64.tar.gz

#移动mysql解压后的文件到/usr/local下改名叫mysql
mv mysql-5.7.43-linux-glibc2.12-x86_64 /usr/local/mysql

#新建组和用户 mysql
groupadd mysql
#mysql这个用户的shell 是/bin/false 属于mysql组 
useradd -r -g mysql -s /bin/false mysql

#关闭firewalld防火墙服务,并且设置开机不要启动
service firewalld stop
systemctl  disable  firewalld

#临时关闭selinux
setenforce 0
#永久关闭selinux
sed -i '/^SELINUX=/ s/enforcing/disabled/'  /etc/selinux/config

#新建存放数据的目录
mkdir  /data/mysql -p
#修改/data/mysql目录的权限归mysql用户和mysql组所有,这样mysql用户可以对这个文件夹进行读写了
chown mysql:mysql /data/mysql/
#只是允许mysql这个用户和mysql组可以访问,其他人都不能访问
chmod 750 /data/mysql/

#进入/usr/local/mysql/bin目录
cd /usr/local/mysql/bin/

#初始化mysql
./mysqld  --initialize --user=mysql --basedir=/usr/local/mysql/  --datadir=/data/mysql  &>passwd.txt

#让mysql支持ssl方式登录的设置
./mysql_ssl_rsa_setup --datadir=/data/mysql/

#获得临时密码
tem_passwd=$(cat passwd.txt |grep "temporary"|awk '{print $NF}')
  #$NF表示最后一个字段
  # abc=$(命令)  优先执行命令,然后将结果赋值给abc 

# 修改PATH变量,加入mysql bin目录的路径
#临时修改PATH变量的值
export PATH=/usr/local/mysql/bin/:$PATH
#重新启动linux系统后也生效,永久修改
echo  "PATH=/usr/local/mysql/bin:$PATH">>/root/.bashrc

#复制support-files里的mysql.server文件到/etc/init.d/目录下叫mysqld
cp  ../support-files/mysql.server   /etc/init.d/mysqld

#修改/etc/init.d/mysqld脚本文件里的datadir目录的值
sed  -i '70c  datadir=/data/mysql'  /etc/init.d/mysqld

#生成/etc/my.cnf配置文件
cat  >/etc/my.cnf  <<EOF
[mysqld_safe]

[client]
socket=/data/mysql/mysql.sock

[mysqld]
socket=/data/mysql/mysql.sock
port = 3306
open_files_limit = 8192
innodb_buffer_pool_size = 512M
character-set-server=utf8

[mysql]
auto-rehash
prompt=\\u@\\d \\R:\\m  mysql>
EOF

#修改内核的open file的数量
ulimit -n 1000000
#设置开机启动的时候也配置生效
echo "ulimit -n 1000000" >>/etc/rc.local
chmod +x /etc/rc.d/rc.local

#启动mysqld进程
service mysqld start

#将mysqld添加到linux系统里服务管理名单里
/sbin/chkconfig --add mysqld
#设置mysqld服务开机启动
/sbin/chkconfig mysqld on

#初次修改密码需要使用--connect-expired-password 选项
#-e 后面接的表示是在mysql里需要执行命令  execute 执行
#set password='123456';  修改root用户的密码为123456
mysql -uroot -p$tem_passwd --connect-expired-password   -e  "set password='123456';"

#检验上一步修改密码是否成功,如果有输出能看到mysql里的数据库,说明成功。
mysql -uroot -p'123456'  -e "show databases;"

1.3.2 在ansible机器上面创建node_exporter脚本,为prometheus在node节点服务器上(mysql和mysqlrouter)采集数据

[root@ansible ~]# vim node_exporter.sh
#!/bin/bash

#进入root家目录
cd ~
#下载node_exporter源码(由于github无法访问,故省略该步,手动下载)
#curl -O https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
#解压node_exporters源码包
tar xf node_exporter-1.6.1.linux-amd64.tar.gz
#改名
mv  node_exporter-1.6.1.linux-amd64 /node_exporter
cd /node_exporter
#修改PATH环境变量
PATH=/node_exporter:$PATH 
echo "PATH=/node_exporter:$PATH" >>/root/.bashrc
#后台运行,监听8090端口
nohup node_exporter --web.listen-address 0.0.0.0:8090  &

1.3.3 在ansible机器上面编写playbook批量部署mysql、mysqlroute、node_exporters、dns等软件

[root@ansible ~]# vim software_install.yaml
- hosts: mysql #mysql集群
  remote_user: root
  tasks:  
  - name: copy mysql.tar.gz     #上传MySQL安装包到mysql主机组
    copy: src=/root/mysql-5.7.43-linux-glibc2.12-x86_64.tar.gz dest=/root/
  - name: copy mysql.sh     #上传脚本到mysql主机组
    copy: src=/root/onekey_install_mysql.sh dest=/root/
  - name: install mysql #安装MySQL
    script: /root/onekey_install_mysql.sh

- hosts: mysqlrouter #mysqlrouter服务器
  remote_user: root
  tasks:
  - name: copy file     #上传mysqlrouter安装包到服务器
    copy: src=/root/mysql-router-community-8.0.23-1.el7.x86_64.rpm dest=/root/
  - name: install mysqlrouter #安装mysqlrouter
    shell:  rpm -ivh mysql-router-community-8.0.23-1.el7.x86_64.rpm
  - name: install keepalived  #安装keepalived实现高可用
    yum: name=keepalived state=installed

- hosts: dns #dns服务器
  remote_user: root
  tasks:
  - name: install dns
    yum: name=bind.* state=installed


- hosts: mysqlrouter mysql #调用本地node_exporter脚本,批量安装部署node_exporter,为prometheus采集数据
  remote_user: root
  tasks:
  - name: copy file     #上传node_exporter安装包到服务器
    copy: src=/root/node_exporter-1.6.1.linux-amd64.tar.gz dest=/root/
  - name: copy file     #上传脚本到服务器
    copy: src=/root/node_exporter.sh dest=/root/
  - name: install node_exporters  #执行脚本
    script: /root/node_exporter.sh
    tags: install_exporter
  - name: start node_exporters  #后台运行node_exporters
    shell: nohup node_exporter --web.listen-address 0.0.0.0:8090 &
    tags: start_exporters  #打标签,方便后面直接跳转到此处批量启动node_exporters
[root@localhost ~]# ansible-playbook software_install.yaml

1.4 统一5台mysql服务器的数据

master服务器上面导出数据

[root@localhost ~]# mysqldump -uroot -p'123456'  --all-databases  >all_db.SQL

使用ansible导入到其他机器

#拷贝master上的MySQL数据包到ansible机器上
[root@localhost ~]#scp  [email protected]:/root/all_db.SQL   /root
#下发到mysql数据库服务器上面
[root@localhost ~]# ansible mysql -m copy -a "src=/root/all_db.SQL dest=/root/"
[root@localhost ~]# ansible mysql -m shell -a "mysql -uroot -p'123456' 

2.配置基于GTID的半同步主从复制

安装好半同步相关的插件,开启gtid功能,启动主从复制服务,配置延迟备份服务器,从slave1上拿二进制日志

2.1 在master上安装配置半同步的插件,再配置

2.1.1 在master上安装配置半同步的插件,配置半同步复制超时时间,修改配置文件/etc/my.cnf

[root@localhost ~]# mysql -uroot -p'123456'
root@(none) 11:08  mysql>install plugin rpl_semi_sync_master SONAME 'semisync_master.so';

root@(none) 11:08  mysql>exit
[root@localhost ~]# vim /etc/my.cnf
[mysqld]
#二进制日志开启
log_bin
server_id = 1
 
#开启半同步,需要提前安装半同步的插件
rpl_semi_sync_master_enabled=1
rpl_semi_sync_master_timeout=1000 # 1 second
#gtid功能
gtid-mode=ON
enforce-gtid-consistency=ON

[root@sc-master mysql]# service mysqld restart

2.1.2 在每台从服务器上配置安装半同步的插件,配置slave配置文件

[root@localhost ~]# mysql -uroot -p'123456'
root@(none) 11:12  mysql>install plugin rpl_semi_sync_slave SONAME 'semisync_slave.so';
root@(none) 11:12  mysql>set global rpl_semi_sync_slave_enabled = 1;
root@(none) 11:13  mysql>exit
[root@localhost ~]# vim /etc/my.cnf
[mysqld]
#log bin 二进制日志
log_bin
server_id = 2 #注意:每台slave的id都不一样
expire_logs_days = 15 #二进制日志保存15天

#开启半同步,需要提前安装半同步的插件
rpl_semi_sync_slave_enabled=1
#开启gtid功能
gtid-mode=ON
enforce-gtid-consistency=ON
log_slave_updates=ON

[root@sc-slave mysql]#  service mysqld restart

2.1.3 在master上新建一个授权用户,给slave1和salve2来复制二进制日志

root@(none) 12:06  mysql>grant replication slave on *.* to 'master'@'192.168.98.%' identified by '123456';

在slave1上创建授权用户,给salve3复制二进制日志

root@(none) 12:06  mysql>grant replication slave on *.* to 'slave1'@'192.168.98.%' identified by '123456';

2.1.4 在slave上配置master info的信息

在salve1和slave2上配置

#停止
root@(none) 12:06  mysql>stop slave;
#清空
root@(none) 12:07  mysql>reset slave all;
#配置
root@(none) 12:07  mysql>
change master to master_host='192.168.98.131' ,
master_user='master',
master_password='123456',
master_port=3306,
master_auto_position=1;
#开启
root@(none) 16:33  scmysql>start slave;

在slave3上配置

#停止
root@(none) 12:06  mysql>stop slave;
#清空
root@(none) 12:07  mysql>reset slave all;
#配置
root@(none) 12:07  mysql>
change master to master_host='192.168.98.142' ,
master_user='slave1',
master_password='123456',
master_port=3306,
master_auto_position=1;
#开启
root@(none) 16:33  scmysql>start slave;

2.1.5 查看

在slave上查看
root@(none) 16:34  scmysql>show slave status\G;

在master上查看
root@(none) 16:35  mysql>show variables like "%semi_sync%";

在slave上查看
root@(none) 16:35  scmysql>show variables like "%semi_sync%";

2.1.6 验证GTID的半同步主从复制

在master上面新建或者删除库,slave上面查看有没有实现

2.2配置slave3延迟备份服务器

在slave3上面操作

#停止同步服务
root@(none) 13:42  mysql>stop slave;
#延迟10分钟再备份
root@(none) 13:42  mysql>change master to master_delay = 600;
#开始同步
root@(none) 13:43  mysql>start slave;
#查看设置情况
root@(none) 13:43  mysql>show slave status\G;
SQL_Delay: 60

3.master创建一个计划任务,远程同步到slave4异地备份服务器

在master上创建一个计划任务每天2:30进行数据库的备份脚本,使用rsync+sersync远程同步到slave4异地备份服务器上

3.1 在slave4远程备份服务器上操作

3.1.1 slave4远程备份服务器一键安装rsync服务端软件并且设置开机启动

[root@localhost ~]# vim onekey_install_rsync.sh
#!/bin/bash

#创建备份目录
mkdir  /backup

#关闭firewalld防火墙服务,并且设置开机不要启动
service firewalld stop
systemctl  disable  firewalld
#临时关闭selinux
setenforce 0
#永久关闭selinux
sed -i '/^SELINUX=/ s/enforcing/disabled/'  /etc/selinux/config

#安装rsync服务端软件
yum install rsync xinetd -y

#设置开机启动
echo '/usr/bin/rsync --daemon --config=/etc/rsyncd.conf' >>/etc/rc.d/rc.local
chmod +x /etc/rc.d/rc.local

#生成/etc/rsyncd.conf配置文件
cat  >/etc/rsyncd.conf  <<EOF
uid = root
gid = root
use chroot = yes
max connections = 0
log file = /var/log/rsyncd.log
pid file = /var/run/rsyncd.pid
lock file = /var/run/rsync.lock
secrets file = /etc/rsync.pass
motd file = /etc/rsyncd.Motd

[back_data]
     path = /backup
     comment = A directory in which data is stored
     ignore errors = yes
     read only = no
     hosts allow = 192.168.98.131
EOF

#创建用户认证文件
cat  >/etc/rsync.pass  <<EOF
slave:123456
EOF

#设置文件所有者读取、写入权限
chmod 600 /etc/rsyncd.conf  
chmod 600 /etc/rsync.pass

#启动rsync
/usr/bin/rsync --daemon --config=/etc/rsyncd.conf
#启动xinetd(xinetd是一个提供保姆服务的进程,rsync是它照顾的进程)
systemctl start xinetd

xinetd是一个提供保姆服务的进程,rsync是它照顾的进程

3.1.2 查看rsync和xinetd监听的进程

[root@sc-mysql2 backup]# ps aux|grep rsync
root      9455  0.0  0.0 114844   584 ?        Ss   16:13   0:00 /usr/bin/rsync --daemon --config=/etc/rsyncd.conf
root      9457  0.0  0.0 112824   988 pts/0    S+   16:13   0:00 grep --color=auto rsync
[root@sc-mysql2 backup]# ps aux|grep xinetd
root      9425  0.0  0.0  25044   584 ?        Ss   16:00   0:00 /usr/sbin/xinetd -stayalive -pidfile /var/run/xinetd.pid
root      9465  0.0  0.0 112824   988 pts/0    S+   16:14   0:00 grep --color=auto xinetd

3.2 数据源master服务器操作

3.2.1 master服务器一键安装rsync服务端软件并且设置开机启动

[root@localhost ~]# vim onekey_install_rsync.sh
#!/bin/bash

#关闭firewalld防火墙服务,并且设置开机不要启动
service firewalld stop
systemctl  disable  firewalld
#临时关闭selinux
setenforce 0
#永久关闭selinux
sed -i '/^SELINUX=/ s/enforcing/disabled/'  /etc/selinux/config

#安装rsync服务端软件
yum install rsync xinetd -y

#设置开机启动
echo '/usr/bin/rsync --daemon --config=/etc/rsyncd.conf' >>/etc/rc.d/rc.local
chmod +x /etc/rc.d/rc.local

#生成/etc/rsyncd.conf配置文件
cat  >/etc/rsyncd.conf  <<EOF
log file = /var/log/rsyncd.log
pid file = /var/run/rsyncd.pid
lock file = /var/run/rsync.lock
motd file = /etc/rsyncd.Motd
[Sync]
    comment = Sync
    uid = root
    gid = root
    port= 873
EOF

#启动xinetd(xinetd是一个提供保姆服务的进程,rsync是它照顾的进程)
systemctl start xinetd

#创建认证密码文件,该密码应与slave服务器中的/etc/rsync.pass中的密码一致 
cat  >/etc/passwd.txt  <<EOF
123456
EOF

#设置文件所有者读取、写入权限
chmod 600 /etc/passwd.txt 

3.2.2 测试数据源master服务器192.168.98.131 到slave异地备份服务器192.168.98.146之间的数据同步

/backup(要备份的数据源目录,自己创建) [email protected]::back_data(rsyncd.conf文件配置名称)

[root@sc-mysql backup]# rsync -avH --port=873 --progress --delete  /backup  [email protected]::back_data --password-file=/etc/passwd.txt

3.2.3 数据源服务器上安装sersync工具,实现自动的实时的同步

(1)一键安装安装sersync工具

[root@localhost ~]# vim onekey_install_sersync.sh
#!/bin/bash
cd ~
#修改inotify默认参数(inotify默认内核参数值太小)
sysctl -w fs.inotify.max_queued_events="99999999"
sysctl -w fs.inotify.max_user_watches="99999999"
sysctl -w fs.inotify.max_user_instances="65535"

#下载并安装sersync
yum install wget -y
wget http://down.whsir.com/downloads/sersync2.5.4_64bit_binary_stable_final.tar.gz

#解压并改名
tar xf sersync2.5.4_64bit_binary_stable_final.tar.gz
mv /root/GNU-Linux-x86 /usr/local/sersync

#创建rsync
cd /usr/local/sersync/
cp confxml.xml confxml.xml.bak
cp confxml.xml data_configxml.xml   #data_configxml.xml 是后面需要使用的配置文件

#修改data_configxml.xml配置文件
#修改需要备份的路径为/backup
sed -i 's/watch="\/opt\/tongbu"/watch="\/backup"/' /usr/local/sersync/data_configxml.xml
#修改服务器信息为slave4远程备份服务器
sed -i 's/ip="127.0.0.1" name="tongbu1"/ip="192.168.98.146" name="back_data"/' /usr/local/sersync/data_configxml.xml
#开启身份认证,修改密码文件为/etc/passwd.txt
sed -i 's/start="false" users="root" passwordfile="\/etc\/rsync.pas"/start="true" users="root" passwordfile="\/etc\/passwd.txt"/' /usr/local/sersync/data_configxml.xml


#添加到PATH变量
PATH=/usr/local/sersync/:$PATH
echo 'PATH=/usr/local/sersync/:$PATH'  >>/root/.bashrc

#启动
sersync2 -d -r -o  /usr/local/sersync/data_configxml.xml

#设计开机启动
echo '/usr/local/sersync/sersync2 -d -r -o  /usr/local/sersync/data_configxml.xml' >>/etc/rc.local 
  • 永久修改参数方法

    [root@sc-mysql backup]# vim /etc/sysctl.conf
    fs.inotify.max_queued_events=99999999
    fs.inotify.max_user_watches=99999999
    fs.inotify.max_user_instances=65535
    

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第2张图片

(2)查看服务,新建文件进行验证

[root@sc-mysql backup]# ps aux|grep sersync
[root@master backup]# mkdir test
[root@master backup]# ls
test
[root@slave4 backup]# ls
test

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第3张图片

3.3 创建计划任务

在master上创建一个计划任务每天2:30进行数据库的备份脚本

[root@localhost ~]#crontab -e
30 2 * * * bash /root/backup_log.sh
[root@localhost ~]# vim /root/backup_log.sh
mysqldump -uroot -p'123456'  --all-databases  >/backup/all_db.SQL

4 部署mysqlrouter中间件实现读写分离,安装keepalived部署双vip实现高可用

4.1 部署mysqlrouter中间件实现读写分离

4.1.1 安装部署MySQLrouter(该步骤已经使用playbook部署完成)

  • 上传或者去官方网站下载软件

https://dev.mysql.com/get/Downloads/MySQL-Router/mysql-router-community-8.0.23-1.el7.x86_64.rpm

[root@mysql-router-1 ~]# rpm -ivh mysql-router-community-8.0.23-1.el7.x86_64.rpm 

4.1.2 修改配置文件/etc/mysqlrouter/mysqlrouter.conf

[root@mysql-router-1 mysqlrouter]# vim /etc/mysqlrouter/mysqlrouter.conf

[DEFAULT]
logging_folder = /var/log/mysqlrouter
runtime_folder = /var/run/mysqlrouter
config_folder = /etc/mysqlrouter

[logger]
level = INFO

[keepalive]
interval = 60

[routing:slave]
bind_address = 0.0.0.0:7001
destinations = 192.168.98.131:3306,192.168.98.142:3306
mode = read-only
connect_timeout = 1

[routing:master]
bind_address = 0.0.0.0:7002
destinations = 192.168.98.131:3306
mode = read-write
connect_timeout = 1

4.1.3 启动MySQL router服务,监听了7001和7002端口

[root@localhost ~]# service mysqlrouter restart
[root@localhost ~]# netstat -anplut|grep mysql
tcp        0      0 0.0.0.0:7001            0.0.0.0:*               LISTEN      8084/mysqlrouter    
tcp        0      0 0.0.0.0:7002            0.0.0.0:*               LISTEN      8084/mysqlrouter  

4.1.4 在master上创建2个测试账号,一个是读的,一个是写的()

root@(none) 15:34  mysql>grant all on *.*  to 'write'@'%' identified by '123456';
root@(none) 15:35  mysql>grant select on *.*  to 'read'@'%' identified by '123456';

由于实现了半同步复制,故需要将slave机器上面的write用户删除

[root@localhost ~]# mysql -uroot -p'123456'
root@(none) 22:05  mysql>drop user 'write'@'%';

4.1.5 在客户端上测试读写分离的效果,使用2个测试账号

#实现读功能
[root@node1 ~]# mysql -h 192.168.98.143 -P 7001 -uread -p'123456'
#实现写功能
[root@node1 ~]# mysql -h 192.168.98.138 -P 7002 -uwrite -p'123456'

mysqlrouter通过7001和7002端口实现分流,再通过mysql服务器上面的权限用户(write,read)进行读写分离

4.2安装keepalived部署双vip实现高可用

mysqlrouter1上配置

[root@localhost conf]# vim /etc/keepalived/keepalived.conf
! Configuration File for keepalived

global_defs {
   notification_email {
     [email protected]
     [email protected]
     [email protected]
   }
   notification_email_from [email protected]
   smtp_server 192.168.200.1
   smtp_connect_timeout 30
   router_id LVS_DEVEL
   vrrp_skip_check_adv_addr
   #vrrp_strict
   vrrp_garp_interval 0
   vrrp_gna_interval 0
}
vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 88
    priority 120
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.98.88
    }
}
vrrp_instance VI_2 {
    state BACKUP
    interface ens33
    virtual_router_id 99
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.98.99
    }
}
[root@localhost conf]# service keepalived restart

mysqlrouter2上配置

[root@localhost conf]# vim /etc/keepalived/keepalived.conf
! Configuration File for keepalived

global_defs {
   notification_email {
     [email protected]
     [email protected]
     [email protected]
   }
   notification_email_from [email protected]
   smtp_server 192.168.200.1
   smtp_connect_timeout 30
   router_id LVS_DEVEL
   vrrp_skip_check_adv_addr
   vrrp_strict
   vrrp_garp_interval 0
   vrrp_gna_interval 0
}

vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 88
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.98.88
    }
}
vrrp_instance VI_2 {
    state BACKUP
    interface ens33
    virtual_router_id 99
    priority 120
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.98.99
    }
}
[root@localhost conf]# service keepalived restart

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第4张图片

在客户端上使用虚拟ip进行测试读写分离的效果

#实现读功能
[root@node1 ~]# mysql -h 192.168.98.88 -P 7001 -uread -p'123456'
#实现写功能
[root@node1 ~]# mysql -h 192.168.98.99 -P 7002 -uwrite -p'123456'

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第5张图片

5.搭建DNS域名服务器

搭建DNS域名服务器,配置一个域名对应2个vip,实现基于DNS的负载均衡,访问同一URL解析出双vip地址

1.安装软件bind(该软件提供了很多的dns域名查询的命令)->由于playbook已经批量安装过,该处故省略

[root@localhost ~]# yum install bind* -y

2.关闭DNS域名服务器的防火墙服务和selinux

[root@localhost ~]# service firewalld stop
[root@localhost ~]#systemctl disable firewalld
#临时修改selinux策略
[root@localhost ~]# setenforce 0  

3.设置named服务开机启动,并且立马启动DNS服务

#设置named服务开机启动
[root@nameserver ~]# systemctl enable named  
#立马启动named进程
[root@nameserver ~]# systemctl start named  

4.修改dns配置文件,任意ip可以访问本机的53端口,并且允许dns解析

[root@localhost ~]# vim /etc/named.conf
options {
        listen-on port 53 { any; };  #修改
        listen-on-v6 port 53 { any; }; #修改
        directory       "/var/named";
        dump-file       "/var/named/data/cache_dump.db";
        statistics-file "/var/named/data/named_stats.txt";
        memstatistics-file "/var/named/data/named_mem_stats.txt";
        recursing-file  "/var/named/data/named.recursing";
        secroots-file   "/var/named/data/named.secroots";
        allow-query     { any; }; #修改
#重启named服务
[root@nameserver ~]# service named restart

5.编辑dns次要配置文件/etc/named.rfc1912.zones,增加一条主域名记录

[root@localhost ~]# vim /etc/named.rfc1912.zones
zone "liaoobo.com" IN {
        type master; #类型为主域名
        file "liaoobo.com.zone"; #liaoobo.com域名的数据文件,需要去/var/named/下创建
        allow-update { none; };
};
[root@localhost ~]# cd /var/named/
[root@localhost named]# cp -a named.localhost liaoobo.com.zone
[root@localhost named]# vim liaoobo.com.zone 
$TTL 1D
@       IN SOA  @ rname.invalid. (
                                        0       ; serial
                                        1D      ; refresh
                                        1H      ; retry
                                        1W      ; expire
                                        3H )    ; minimum
        NS      @
        A       127.0.0.1
        AAAA    ::1
www IN  A       192.168.98.88
www IN  A       192.168.98.99

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第6张图片

6.使用sysbench进行压力测试,prometheus和grafana实现监控并出图

使用sysbench整个MySQL集群的性能(cpu、IO、内存等)进行压力测试,安装部署prometheus实现监控,grafana出图了解系统性能的瓶颈并调优

4.1 安装prometheus server

1.一键源码安装prometheus

源码下载:https://github.com/prometheus/prometheus/releases/download/v2.46.0/prometheus-2.46.0.linux-amd64.tar.gz

[root@localhost ~]# vim onekey_install_prometheus.sh
#!/bin/bash

#创建存放prometheus的目录
mkdir /prom

#下载prometheus源码(由于github无法访问,故省略该步,手动下载)
#curl -O https://github.com/prometheus/prometheus/releases/download/v2.47.0/prometheus-2.47.0.linux-amd64.tar.gz

#解压并改名
tar xf ./prometheus-2.47.0.linux-amd64.tar.gz -C /prom
mv /prom/prometheus-2.47.0.linux-amd64 /prom/prometheus

#添加到PATH变量
PATH=/prom/prometheus:$PATH
echo "PATH=/prom/prometheus:$PATH " >>/root/.bashrc

#nohub后台执行启动
nohup prometheus  --config.file=/prom/prometheus/prometheus.yml &

#关闭防火墙
service firewalld stop
systemctl disable firewalld 

2.把prometheus做成一个服务来进行管理

[root@prometheus prometheus]# vim /usr/lib/systemd/system/prometheus.service
[Unit]
Description=prometheus

[Service]
ExecStart=/prom/prometheus/prometheus --config.file=/prom/prometheus/prometheus.yml
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
Restart=on-failure

[Install]
WantedBy=multi-user.target

#重新加载systemd相关的服务
[root@prometheus prometheus]# systemctl daemon-reload

第一次因为是使用nohup 方式启动的prometheus,还是需要使用后kill 的方式杀死第一次启动的进程;后面可以使用service方式管理prometheus了

[root@prometheus prometheus]# ps aux|grep prometheus
root       8431  0.2  3.2 782340 61472 pts/0    Sl   11:21   0:01 prometheus --config.file=/prom/prometheus/prometheus.yml
root       8650  0.0  0.0 112824   980 pts/0    S+   11:35   0:00 grep --color=auto prome
[root@prometheus prometheus]# kill -9 8431
[root@prometheus prometheus]#  service prometheus start
[root@prometheus prometheus]#  service prometheus stop

3 在node节点服务器上安装exporter程序->已经使用playbook安装完成

4.2 在prometheus server里添加安装了exporter程序的机器

[root@sc-prom prometheus]# vim /prom/prometheus/prometheus.yml

scrape_configs:

The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.

  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]
  #添加下面的配置采集node-liangrui服务器的metrics
  - job_name: "master"
    static_configs:
      - targets: ["192.168.98.131:8090"]  
      
  - job_name: "slave1"
    static_configs:
      - targets: ["192.168.98.142:8090"]  

  - job_name: "slave2"
    static_configs:
      - targets: ["192.168.98.140:8090"]

  - job_name: "slave3"
    static_configs:
      - targets: ["192.168.98.135:8090"]

  - job_name: "slave4"
    static_configs:
      - targets: ["192.168.98.146:8090"]

  - job_name: "mysqlrouter1"
    static_configs:
      - targets: ["192.168.98.143:8090"]
  - job_name: "mysqlrouter2"
    static_configs:
      - targets: ["192.168.98.138:8090"]


#重启prometheus服务  
[root@prometheus prometheus]# service  prometheus restart

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第7张图片

4.3 grafana部署和安装

4.3.1 先去官方网站下载

wget https://dl.grafana.com/enterprise/release/grafana-enterprise-10.1.1-1.x86_64.rpm

4.3.2 安装

[root@sc-prom grafana]# ls
grafana-enterprise-8.4.5-1.x86_64.rpm
[root@sc-prom grafana]# yum install grafana-enterprise-10.1.1-1.x86_64.rpm -y

4.3.3 启动grafana

[root@sc-prom grafana]# service grafana-server start
设置grafana开机启动
[root@prometheus grafana]# systemctl enable grafana-server  
监听的端口号是3000

4.3.4 登录,在浏览器里登录

http://192.168.98.147:3000/
默认的用户名和密码是
用户名admin
密码admin

项目02—基于keepalived+mysqlrouter+gtid半同步复制的MySQL集群_第8张图片

4.4 sysbench压力测试

ab测试机对web集群和负载均衡器进行压力测试,了解系统性能的瓶颈,对系统性能资源(如内核参数、nginx参数 )进行调优,提升系统性能

1.在压力测试机器上面设置

[root@localhost ~]# vim /etc/resolv.conf 
# Generated by NetworkManager
search localdomain
nameserver 192.168.98.144  #DNS服务器ip地址

2.使用yum安装,使用epel-release源去安装sysbench

[root@nfs-server ~]# yum install epel-release -y
[root@nfs-server ~]# yum install sysbench -y

3.在master数据库里新建sbtest的库和建10个sbtest表

[root@localhost ~]# mysql -h www.liaoobo.com -P 7002 -uwrite -p'123456'
write@(none) 12:14  mysql>create database sbtest;
[root@localhost ~]# sysbench --mysql-host=www.liaoobo.com --mysql-port=7002 --mysql-user=write --mysql-password='123456' /usr/share/sysbench/oltp_common.lua --tables=10  --table_size=10000 prepare

4.压力测试

[root@localhost sysbench]# sysbench --threads=4 --time=20 --report-interval=5  --mysql-host=www.liaoobo.com  --mysql-port=7002 --mysql-user=write  --mysql-password='123456' /usr/share/sysbench/oltp_read_write.lua  --tables=10  --table_size=100000  run
  • mysql性能测试工具——tpcc

    1.下载安装包并解压,然后打开目录进行make

    wget  http://imysql.com/wp-content/uploads/2014/09/tpcc-mysql-src.tgz
    tar xf tpcc-mysql-src.tar
    cd tpcc-mysql/src
    make
    

    之后会生成两个二进制工具tpcc_load(提供初始化数据的功能)和tpcc_start(进行压力测试)

    [root@nfs-server src]# cd ..
    [root@nfs-server tpcc-mysql]# ls
    add_fkey_idx.sql  drop_cons.sql  schema2  tpcc_load
    count.sql         load.sh        scripts  tpcc_start
    create_table.sql  README         src
    [root@nfs-server tpcc-mysql]# 
    

    3、初始化数据库

    在master服务器上连接到读写分离器上创建tpcc库,需要在测试的服务器上创建tpcc的库

    [root@sc-slave ~]# mysqladmin -uwrite -p'123456' -h www.liaoobo.com -P 7002 create  tpcc
    

    需要将tpcc的create_table.sql 和add_fkey_idx.sql 远程拷贝到master服务器上

    [root@nfs-server tpcc-mysql]# scp create_table.sql add_fkey_idx.sql [email protected]:/root
    

    然后在master服务器上导入create_table.sql 和add_fkey_idx.sql 文件

    mysql -uroot -p'123456' tpcc <create_table.sql
    mysql -uroot -p'123456' tpcc <add_fkey_idx.sql
    

    4、加载数据

    注意:server是要测试的服务器,db,user,password也是要测的服务器上mysql的信息
    ./tpcc_load [server] [db] [user] [password] [warehouse]
    服务器名 数据库名 用户名 密码 仓库数量
    真实测试中,数据库仓库一般不少于100个,如果配置了ssd,建议最少不低于1000个

    [root@nfs-server tpcc-mysql]# ./tpcc_load www.liaoobo.com:7002 tpcc write Sanchuang1234# 150
    

    5、进行测试

    ./tpcc_start -h www.liaoobo.com -p 7002 -d tpcc -u write -p 123456 -w 150 -c 12 -r 300 -l 360 -f test0.log -t test1.log - >test0.out
    

    注意:server等信息与步骤4中保持一致

四. 项目总结

1.做项目时遇到的问题

1.脚本执行出错,原因是github无法访问导致脚本执行失败
2.playbook部署mysql服务器时出错,原因是虚拟机内存不够
3.半同步复制部署不成功,原因是salve服务器上的server_id不能相同
4.keepalived的虚拟ip无法访问时,记得清除防火墙规则
5.DNS配置域名的数据文件和rsync的.conf配置文件出差,原因是不能加注释

2.项目心得

1.一定要规划好整个集群的架构,配置要细心,脚本要提前准备好,边做边修改
2.防火墙和selinux的问题一定要多注意
3.对MySQL的集群和高可用有了深入的理解,对自动化批量部署和监控有了更加多的应用和理解
4.keepalived的配置需要更加细心,对keepalievd的脑裂和vip漂移现象也有了更加深刻的体会和分析
5.认识到了系统性能资源的重要性,对压力测试下整个集群的瓶颈有了一个整体概念

你可能感兴趣的:(项目实战,mysql,keepalived,mysqlrouter,gtid半同步复制,运维,prometheus,grafana)