本文MySQL集群采用一主多從的架構，即一個master節(jié)點多個slave節(jié)點，master負責寫數據，slave節(jié)點負責讀操作。使用mycat作為MySQL中間件向外提供讀寫服務。使用phpmyadmin提供外部服務，整體架構如下：

架構

1 搭建MySQL集群

這里采用1主2從的結構，一般在一主多從的結構中，slave節(jié)點在2-4個之間，如果slave節(jié)點多了，會影響master的性能。操作步驟如下：

• 創(chuàng)建3個MySQL容器
• 配置Master節(jié)點
• 配置Slave節(jié)點

1.1 創(chuàng)建MySQL容器

本文采用docker-compose創(chuàng)建MySQL容器，使用docker-compose需要創(chuàng)建docker-compose.yml和.env 2個文件，其中 docker-compose.yml是配置文件文件，是必需的。.env 是docker-compose的環(huán)境變量文件，是可選的。配置文件可以讀取環(huán)境變量文件中定義的變量，方便擴展。

創(chuàng)建一個docker目錄，并在docker目錄下創(chuàng)建mysql目錄，~/docker/mysql作為本項目的根目錄。在mysql根目錄下，創(chuàng)建master，slave1和slave2目錄，用于存放3個mysql實例。并在根目錄下，創(chuàng)建docker-compose的配置文件和環(huán)境變量文件。

mkdir -p ~/docker/mysql/master ~/docker/mysql/slave1 ~/docker/mysql/slave2
cd ~/docker/mysql
touch .env docker-compose.yml

目錄結構如下：

?  mysql tree -L 1 -a
.
├── .env    #docker-compose環(huán)境變量
├── docker-compose.yml #docker-compose配置文件
├── master  # 存儲master實例
├── slave1  # 存儲slave1實例
└── slave2  # 存儲slave2實例

3 directories, 2 files

設置環(huán)境變量

?  mysql vim .env

# 使用的MySQL版本
MYSQL_VERSION=mysql:5.7.30
# MySQL root用戶密碼
MYSQL_ROOT_PASSWORD=123456
# MySQL 實例存儲的根目錄
MYSQL_HOME=/Users/zebra/docker/mysql

# master配置
MASTER=master
MASTER_PORT=33061

# salve1配置
SLAVE1=slave1
SLAVE1_PORT=33062

# slave2配置
SLAVE2=slave2
SLAVE2_PORT=33063

設置配置文件docker-compose.yml

version: '3'

services: 
    master: 
        restart: always 
        image: ${MYSQL_VERSION}
        container_name: ${MASTER}
        environment: 
            # root密碼
            MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
            # 使用環(huán)境變量設置MySQL的時區(qū)
            TZ: Asia/Shanghai
        ports:
            - ${MASTER_PORT}:3306
        volumes:
            - ${MYSQL_HOME}/master/data:/var/lib/mysql
            - ${MYSQL_HOME}/master/etc/conf.d:/etc/mysql/conf.d
        command: 
            # 設置忽略大小寫
            - --lower_case_table_names=1
            # 設置默認字符集
            - --character-set-server=utf8mb4
            - --collation-server=utf8mb4_general_ci
            # 設置最大接收的數據包
            - --max_allowed_packet=128M
    slave1: 
        restart: always 
        image: ${MYSQL_VERSION}
        container_name: ${SLAVE1}
        environment: 
            # root密碼
            MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
            # 使用環(huán)境變量設置MySQL的時區(qū)
            TZ: Asia/Shanghai
        links: 
            - ${MASTER}
        ports:
            - ${SLAVE1_PORT}:3306
        volumes:
            - ${MYSQL_HOME}/slave1/data:/var/lib/mysql
            - ${MYSQL_HOME}/slave1/etc/conf.d:/etc/mysql/conf.d
        command: 
            # 設置忽略大小寫
            - --lower_case_table_names=1
            # 設置默認字符集
            - --character-set-server=utf8mb4
            - --collation-server=utf8mb4_general_ci
            # 設置最大接收的數據包
            - --max_allowed_packet=128M
    slave2: 
        restart: always 
        image: ${MYSQL_VERSION}
        container_name: ${SLAVE2}
        environment: 
            # root密碼
            MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
            # 使用環(huán)境變量設置MySQL的時區(qū)
            TZ: Asia/Shanghai
        links: 
            - ${MASTER}
        ports:
            - ${SLAVE2_PORT}:3306
        volumes:
            - ${MYSQL_HOME}/slave2/data:/var/lib/mysql
            - ${MYSQL_HOME}/slave2/etc/conf.d:/etc/mysql/conf.d
        command: 
            # 設置忽略大小寫
            - --lower_case_table_names=1
            # 設置默認字符集
            - --character-set-server=utf8mb4
            - --collation-server=utf8mb4_general_ci
            # 設置最大接收的數據包
            - --max_allowed_packet=128M

在docker-compose.yml文件中，定義了3個MySQL容器，其中2個slave容器使用links關聯了master容器，這樣可以在后續(xù)的操作中使用master主機名代替其ip地址。

在上面的配置文件，我們使用volumes選項將容器中的目錄掛載到本地。每個節(jié)點都有2個目錄，分別是：

• data目錄，映射容器中/var/lib/mysql目錄，用于存儲MySQL實例
• etc/conf.d 目錄，映射容器中/etc/mysql/conf.d目錄，用于存儲MySQL的配置文件

1.2 設置MySQL配置文件

既然知道了MySQL的配置文件存放的地方，那么我們就可以設置MySQL的配置，讓其開啟主從模塊。首先設置master的配置文件，在master目錄下創(chuàng)建etc/conf.d目錄。

# 創(chuàng)建conf.d目錄
mkdir -p master/etc/conf.d

# 編輯my.cnf配置文件
vim master/etc/conf.d/my.cnf

#my.cnf 內容

[mysqld]
# 主服務器唯一ID
server-id=1
# 啟用binlog日志
log-bin=mysql-bin
# 要復制的數據庫,這里的數據庫名為testdb,如果有多個庫，可以設置多個binlog-do-db項
binlog-do-db=testdb
# 不需要復制的數據庫
binlog-ignore-db=mysql
binlog-ignore-db=information_schema

在master的配置文件中，我們設置的要復制的數據庫名為testdb，其他需要注意的是，在MySQL集群中server-id不能重復，這里我們將master的server-id設置為1（后面的slave1設置為2，slave2設置為3）。

slave1的my.cnf文件在slave1/etc/conf.d目錄中（需要自己創(chuàng)建），配置如下：

[mysqld]
# 主服務器唯一ID
server-id=2

同理，slave2節(jié)點的my.cnf如下：

[mysqld]
# 主服務器唯一ID
server-id=3

1.3 運行MySQL容器

通過上面的配置，我們就可以通過docker-compose 啟動MySQL容器了，不過，在啟動之前，我們先來看看目錄的結構：

?  mysql tree -a .
.
├── .env                                    # docker-compose 環(huán)境變量文件
├── docker-compose.yml      # docker-compose 配置文件
├── master
│   └── etc
│       └── conf.d
│           └── my.cnf      # mysql配置文件
├── slave1
│   └── etc
│       └── conf.d
│           └── my.cnf      # mysql配置文件
└── slave2
    └── etc
        └── conf.d
            └── my.cnf      # mysql配置文件

9 directories, 5 files

在mysql根目錄中執(zhí)行如下語句，docker-compose會在當前目錄中讀取.evn和docker-compose.yml文件來啟動docker容器。

?  mysql docker-compose up -d
Creating network "mysql_default" with the default driver
Creating master ... done
Creating slave1 ... done
Creating slave2 ... done

docker-compose up 命令是啟動容器，-d選項表示后臺運行容器，如果要關閉容器使用docker-compose down命令。使用tree命令查看目錄結構

?  mysql tree -adL 2 .
.
├── master
│   ├── data        # 數據庫掛載點
│   └── etc
├── slave1
│   ├── data        # 數據庫掛載點
│   └── etc
└── slave2
    ├── data        # 數據庫掛載點
    └── etc

9 directories

可以看到目錄中多了一個data目錄，該目錄是我們在配置文件中通過volumes選項映射出來的容器卷，它將容器中的數據庫文件保存在本地目錄，避免容器銷毀后，數據也跟著銷毀。

1.4 初始化MySQL集群

現在，容器已經啟動了。之前我們在my.cnf配置中做了一部分集群的設置，但僅僅設置集群中的每個節(jié)點id，并開啟了master主機的binary log日志。我們還需要解決的是：

• master節(jié)點允許什么用戶復制哪些數據庫
• slave節(jié)點通過什么用戶到哪里去復制數據庫

登錄master節(jié)點，使用grant語句，將所有數據庫的所有對象的replication slave 權限，授權給slave用戶，并且slave用戶可以使用網絡地址訪問，其密碼是123456。

mysql> grant replication slave on *.* to 'slave'@'%' identified by '123456';
Query OK, 0 rows affected (0.01 sec)

查看master狀態(tài)：

mysql> show master status;
+------------------+----------+--------------+--------------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB         | Executed_Gtid_Set |
+------------------+----------+--------------+--------------------------+-------------------+
| mysql-bin.000003 |      430 | testdb       | mysql,information_schema |                   |
+------------------+----------+--------------+--------------------------+-------------------+
1 row in set (0.00 sec)

記住文件File和Position參數的值，File參數是binlog日志的文件，也是slave要拷貝的文件。position代表要slave拷貝的起點，如果在maste上執(zhí)行SQL語句，Position的值會發(fā)生變化，所以確定了position后，先暫時不要操作master。

登錄slave節(jié)點，使用如下語句配置slave節(jié)點的連接信息，包括登錄master的用戶名、密碼、端口信息，以及剛剛在master上查詢的file和position參數。

change master to master_host='master',
 master_user='slave', 
 master_password='123456',
 master_port=3306,
 master_log_file='mysql-bin.000003',
 master_log_pos= 430,
 master_connect_retry=30;

因為在docker-compose.yml中使用了link，所以這里的master_host 參數使用的是master的主機名。查看slave狀態(tài)：

mysql> show slave status \G;
*************************** 1. row ***************************
         Slave_IO_State: 
            Master_Host: master
            Master_User: slave
            Master_Port: 3306
          Connect_Retry: 30
        Master_Log_File: mysql-bin.000003
    Read_Master_Log_Pos: 430
         Relay_Log_File: 9e185c56ef5e-relay-bin.000001
          Relay_Log_Pos: 4
  Relay_Master_Log_File: mysql-bin.000003
       Slave_IO_Running: No
      Slave_SQL_Running: No
  ...

我們僅僅是設置了連接信息，還沒有啟動slave，所以可以看到Slave_IO_Running和Slave_SQL_Running兩個線程都是No狀態(tài)。執(zhí)行start slave語句：

mysql> start slave;
Query OK, 0 rows affected (0.01 sec)

啟動slave后，Slave_IO_Running和Slave_SQL_Running兩個線程都是Yes狀態(tài)。

到此，MySQL集群已搭建完成。Master創(chuàng)建testdb庫后，slave會同步該庫。

2 搭建MyCAT中間件

Mycat是使用Java語言進行編寫開發(fā)，使用前需要先安裝Java運行環(huán)境(JRE),由于Mycat中使用了jdk7中的一些特性，所以要求必須在JDK7以上的版本上運行。

使用Mycat可以：

• 數據庫分片（垂直和水平）
• 讀寫分離

本文只涉及到讀寫分離特性，更多的內容可參考MyCAT官網 。

2.1 目錄準備

在mysql目下創(chuàng)建一個mycat目錄，作為mycat節(jié)點的根目錄，用于存放Mycat配置和日志等數據。我們使用DockerFile文件生成Mycat鏡像，所以需要創(chuàng)建Dockerfile文件。同時，到Mycat官網下載Mycat安裝包（這里重命名為Mycat.tar.gz），地址如下：

http://dl.mycat.org.cn/1.6.7.4/Mycat-server-1.6.7.4-release/Mycat-server-1.6.7.4-release-20200105164103-linux.tar.gz

目錄結構如下：

?  mycat tree -L 1 
.
├── Dockerfile          # dockerfile 文件
└── mycat.tar.gz    # mycat 安裝包

因為后面啟動mycat容器時，我們需要將mycat的配置文件目錄conf作為數據卷掛載到容器中，所以這里需要先將mycat安裝包解壓，并復制配置文件目錄。

# 解壓mycat.tar.gz，解壓后的目錄為mycat
?  mycat tar -zxf mycat.tar.gz 

# 移動mycat/conf目錄到根目錄的conf
?  mycat mv mycat/conf conf

# 刪除mycat目錄
?  mycat rm -rf mycat

創(chuàng)建一個logs目錄，用于存放mycat日志。

?  mycat mkdir logs

目錄完成后，結構如下：

?  mycat tree -L 1
.
├── Dockerfile          # dockerfile文件
├── conf                        # mycat配置文件目錄
├── logs                        # mycat日志目錄
└── mycat.tar.gz        # mycat安裝包

2.2 制作Dockerfile文件

編輯Dockerfile文件，內容如下

FROM openjdk:8

ADD ./mycat.tar.gz /usr/local/
ENV MYCAT_HOME=/usr/local/mycat
EXPOSE 8066 9066
CMD ["/usr/local/mycat/bin/mycat", "console","&"]

使用openjdk:8作為基礎鏡像，將mycat根目錄的安裝文件添加到鏡像的/usr/local目錄下，因為使用了ADD命令，壓縮包會自動解壓，設置環(huán)境變量MYCAT_HOME，暴露端口8066和9066，8066是客戶端使用端口，9066為mycat管理端口。默認提供一個啟動命令，使用 console選項運行在前臺，保證容器啟動后不會被退出。

2.3 配置Mycat

在mycat的配置在conf目錄下：

• server.xml 配置文件包含了mycat服務器參數，以及用戶授權信息
• schema.xml 配置文件包含，邏輯庫、邏輯表以及分片的定義
• rule.xml 配置文件包含，分片規(guī)則的配置

2.3.1 配置schema.xml

配置mycat/conf/schema.xml文件：

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
    <schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" dataNode="dn1" >
  </schema>
    <dataNode name="dn1" dataHost="localhost1" database="testdb" />
    <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
        <heartbeat>select user()</heartbeat>
        <writeHost host="hostM1" url="master:3306" user="root" password="123456" >
            <readHost host="hostS1" url="slave1:3306" user="root" password="123456" />
            <readHost host="hostS2" url="slave2:3306" user="root" password="123456" />
        </writeHost>
    </dataHost>
</mycat:schema>

以上是schema的配置，更多配置可以參考官網mycat權威指南第7章。

schema標簽定義邏輯庫

schema 標簽用于定義 MyCat 實例中的邏輯庫

• name屬性為邏輯庫取名，這里為TESTDB
• checkSQLschema 屬性表示是否會去掉sql語句的schema前綴
• sqlMaxLimit 屬性，當sql語句沒有設置limit時，會默認加上 limit 100，防止查詢過多的結果
• dataNode 屬性用于指定邏輯庫要綁定到那個dataNode數據節(jié)點上。值為dataNode的name，一個邏輯庫只能綁定到一個數據節(jié)點上。

schema邏輯庫標簽中還可以定義邏輯表table標簽，一個邏輯表可以指定多個數據節(jié)點，這里沒有配置。

dataNode標簽定義數據節(jié)點

數據節(jié)點就是一個數據分片，dataNode主要是向schema標簽和table標簽提供引用。dataNode數據節(jié)點共3個屬性：

• name 屬性，為數據節(jié)點提供一個名字，方便schema和table引用。
• dataHost屬性，表示該數據節(jié)點對應的dataHost數據主機標簽，值為dataHost標簽的name屬性
• database屬性，指定到MySQL實例的具體數據庫上，因為前面我們在搭建MySQL集群時，使用的是testdb數據庫，所以這里的值為testdb。

dataHost標簽定義數據主機

dataHost代表多個MySQL實例的集合，這些數據庫實例包括寫主機（master，定義在writeHost上）和讀主機（slave，定義在readHost上）。

• name 屬性，指定數據主機的名稱，方便dataNode引用。
• maxCon MySQL實例連接池的最大連接數
• minCon MySQL實例連接池的最小連接數
• balance 屬性表示負載均衡的類型
  • balance = "0" 不開啟讀寫分離，所有的讀寫操作都發(fā)到送寫主機上
  • balance = "1" 開啟讀寫分離（常用），所有寫操作都發(fā)送給第一個寫主機上（如果定義了多個寫主機，后備寫主機 stand by writeHost），所有的讀操作通過負載均衡分配到其他主機，即所有的readHost和后備寫主機。
  • balance = "2" 開啟讀寫分離，所有寫操作都發(fā)送到寫主機上，讀操作隨機到所有主機上。也就是說，寫主機也要承擔讀的任務。
  • balance = "3" 開啟讀寫分離，讀操作隨機到讀主機上。
• writeType 屬性，表示寫主機的類型
  • writeType="0" 所有寫操作發(fā)送到配置的第一個 writeHost，第一個掛了切到還生存的第二個 writeHost， 重新啟動后以切換后的為準。
  • writeType="1" 所有寫操作都隨機的發(fā)送到配置的 writeHost（已廢棄）
• switchType 屬性，寫主機切換方式
  • -1 表示不自動切換。
  • 1 默認值，自動切換。
  • 2 基于 MySQL 主從同步的狀態(tài)決定是否切換。

heartbeat標簽定義心跳檢測

這個標簽內指明用于和后端數據庫進行心跳檢查的語句。例如,MYSQL 可以使用 select user()，Oracle 可以 使用 select 1 from dual 等。

writeHost 標簽定義寫主機

• host 屬性，定義寫主機名稱，一般Master主機名為為*M1，讀主機命名*S1
• url 屬性，后端實例連接地址，如果是使用 native 的 dbDriver，則一般為 address:port 這種形式。用 JDBC 或其他的 dbDriver，則需要特殊指定。當使用 JDBC 時則可以這么寫:jdbc:mysql://localhost:3306/。因為這里我們使用docker-compose啟動Mycat容器，所以地址可以用主機名代理，這里master:3306 表示master數據庫容器。
• user 和 password 是數據庫實例的用戶名密碼。

readHost標簽定義讀主機，其屬性與writeHost標簽相同，需要注意的是，readHost是包裹在writeHost標簽內。

2.3.2 配置server.xml

server.xml 保存了所有 mycat 需要的系統配置信息，這里我們只關系user標簽。

<?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">TESTDB</property>
        <property name="defaultSchema">TESTDB</property>
    </user>

    <user name="user">
        <property name="password">user</property>
        <property name="schemas">TESTDB</property>
        <property name="readOnly">true</property>
        <property name="defaultSchema">TESTDB</property>
    </user>
</mycat:server>

默認情況，mycat為我們創(chuàng)建了兩個用戶，root和user，root的密碼為123456。shecma屬性表示該用戶能夠操作的邏輯數據庫，對應的是schema.xml的schema標簽中的name值，這里是TESTDB。如果有多個數據庫，這里需要配置多個schema屬性。

2.4 修改docker-compose配置文件

回到mysql目錄，編輯 .env 環(huán)境變量文件，添加mycat根目錄以方面docker-compose.yml文件調用

# 在.env 文件中添加MYCAT_HOME變量，指定mycat的家目錄

# mycat 配置
MYCAT_HOME=/Users/zebra/docker/mysql/mycat

編輯 docker-compose.yml 配置文件

version: '3'

services: 
  master: ...
  slave1: ...
  slave2: ...
  mycat:
    restart: always
    build: ./mycat
    image: mycat:v1
    container_name: mycat
    links: 
        - ${MASTER}
        - ${SLAVE1}
        - ${SLAVE2}
    ports:
        - 8066:8066
        - 9066:9066
    volumes: 
        - ${MYCAT_HOME}/conf:/usr/local/mycat/conf
        - ${MYCAT_HOME}/logs:/usr/local/mycat/logs

在services中，增加mycat節(jié)點，build選項指定Dockerfile文件地址，這里使用相對路徑，表示在當前yml配置文件目錄中的mycat目錄里。image為構建后的鏡像名稱（如果沒有改鏡像就構建，有就直接調用該鏡像）。links選項表示mycat容器需要連接master，slave1和slave2容器（前面我們在mycat的schema.xml的配置中使用到了這些容器）。volumes 將本地數據卷掛載到容器中，這里掛載了配置目錄和日志目錄。

3 啟動MySQL集群

現在，已經配置好了Mycat，我們使用docker-compose up -d 啟動所有容器。如果之前啟動過，使用docker-compose down 停止后在啟動。

?  mysql docker-compose up -d
Creating network "mysql_default" with the default driver
Building mycat
Step 1/5 : FROM openjdk:8
 ---> b190ad78b520
Step 2/5 : ADD ./mycat.tar.gz /usr/local/
 ---> 7561bd31c7c9
Step 3/5 : ENV MYCAT_HOME=/usr/local/mycat
 ---> Running in a6ed86e20223
Removing intermediate container a6ed86e20223
 ---> 2aa61a702465
Step 4/5 : EXPOSE 8066 9066
 ---> Running in 164d908610bb
Removing intermediate container 164d908610bb
 ---> ee971db034c9
Step 5/5 : CMD ["/usr/local/mycat/bin/mycat", "console","&"]
 ---> Running in 2518532eaa00
Removing intermediate container 2518532eaa00
 ---> 03b97ffc1ad2
Successfully built 03b97ffc1ad2
Successfully tagged mycat:v1
WARNING: Image for service mycat was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Creating master ... done
Creating slave1 ... done
Creating slave2 ... done
Creating mycat  ... done

可以看到，在啟動時，因為本地沒有 mycat:v1 的鏡像，所以，compose會先構建該鏡像。如果mycat的鏡像已存在，docker-compose會直接使用該鏡像，如果修改了進行的Dockerfile文件，可以使用docker-compose build 重新構建，或在啟動時，通過--build選項重新構建。

外部程序可以通過8066端口連接Mycat中間件的邏輯庫TESBD。

4 添加phpmyadmin應用

在docker-compose.yml中添加phpmyadmin應用

version: '3'

services: 
  master: ...
  slave1: ...
  slave2: ...
  mycat: ...
  phpmyadmin:
    restart: always
    image: phpmyadmin/phpmyadmin:5.0
    container_name: myadmin
    links: 
        - master
    ports: 
        - 7500:80
    environment: 
        PMA_PORT: 3306
        PMA_HOST: master

phpmyadmin使用5.0target，連接master容器，并80端口與宿主機的7500端口相連接。這里需要注意的是，phpmyadmin如果直接連接mycat中間件，不能正常工作，需要連接mysql容器。