其中有個留言很有意思：「如果在 MongoDB 建立 Index，那麼資料寫入的速度會比 MySQL 快很多嗎（有建立相同 Index 的情況下）？」

儘管網路上有許多資料顯示 MongoDB 建立 Index 後的效能比 MySQL 好，但這篇文章我想要透過程式來驗證兩者寫入、讀取、資料大小的差異。

非常建議看到最後，因為測試結果可能跟你想的不一樣。

文章大綱

▋ 測試參數說明
▋ 前置作業 1 ── docker image pull
▋ 前置作業 2 ── 安裝 Python 相關套件
▋ Script 設計說明
▋ MySQL 測試方案
▋ MongoDB 測試方案 1 ── 單筆資料的 Index 設計
▋ MongoDB 測試方案 2 ── Time Series Collection
▋ MongoDB 測試方案 3 ── Embedded Documents
▋ 結論：想象跟實際的落差

測試參數說明

這邊我以上一篇談到的商品統計圖表來做設計，因為主要比對效能上的差異，所以用的資料量級比較小（否則某些情境會跑到天荒地老）。

• 商品種類: 2000 筆
• 統計頻率: 1 分鐘
• 時間長度: 8 小時
• 總資料量: 96 萬筆（2000 * 8 * 60）
• 電腦規格: Apple M1 Max

前置作業 1 ── docker image pull

如果你有興趣，可以跟著文章步驟一起實作，為求公平，我這邊使用最新版的 MongoDB 跟 MySQL 來做測試（當然也可以直接滑到最後看實驗結果）。

我也有把文章的 Code 推到 Github 讓大家參考。

如果有使用 Docker，可以使用下面的 docker-compose.yaml 取的對應的資源。

version: '1.1'
services:
  mongodb:
    image: mongodb/mongodb-community-server:latest
    container_name: mongodb
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db
    networks:
      - mynetwork
  mongo-express:
    image: mongo-express:latest
    container_name: mongo-express
    ports:
      - "8081:8081"
    environment:
      ME_CONFIG_MONGODB_SERVER: mongodb
      ME_CONFIG_BASICAUTH_USERNAME: root
      ME_CONFIG_BASICAUTH_PASSWORD: example
    networks:
      - mynetwork
  mysql:
    image: mysql/mysql-server:latest
    container_name: mysql
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: example
      MYSQL_DATABASE: exampledb
    volumes:
      - mysql_data:/var/lib/mysql
      - ./mysql-conf.d:/etc/mysql/conf.d
    networks:
      - mynetwork
  phpmyadmin:
    image: phpmyadmin/phpmyadmin:latest
    container_name: phpmyadmin
    depends_on:
      - mysql
    ports:
      - "8080:80"
    environment:
      PMA_HOST: mysql
      PMA_PORT: 3306
    networks:
      - mynetwork
volumes:
  mongodb_data:
  mysql_data:
networks:
  mynetwork:
    driver: bridge

下面是對應的 GUI 連結:

• phpMyAdmin（帳號:root、密碼:example）: http://localhost:8080
• Mongo Express（帳號:root、密碼:example）: http://localhost:8081

前置作業 2 ── 安裝 Python 相關套件

我使用的 Python 版本為: 3.10.14

這邊我使用 Python 來撰寫測試用的 Script，若你尚未安裝，可以直接去官網下載: https://www.python.org/downloads/

執行下面指令便可安裝專安會用到的套件：

pip install pymysql pymongo cryptography

Script 設計說明

我總共寫了 4 個測試腳本，MySQL 1 個，MongoDB 3 個，基本上每個腳本都會做如下任務，差別在於資料結構設計不同。

1. 與資料庫（MySQL/MongoDB）建立連線
2. 建立 Table/Collection，並在「商品名稱(product_name)、紀錄時間(timestamp)」的欄位加上 index
3. 寫入資料，模擬為期 8 小時、1 分鐘寫入 2000 筆資料的情境。
4. 查詢效能測試，會亂數產生 100 次不同參數的搜尋條件。
5. 印出寫入時間/寫入總量/平均查詢時間

MySQL 測試方案

MySQL 版本: 8.0.32

這個腳本沒什麼特別的，只是在「商品名稱(product_name)、紀錄時間(timestamp)」加上了 index。

import pymysql
import random
import time
from datetime import datetime, timedelta

# MySQL 連接設定
conn = pymysql.connect(
    host='localhost',
    user='root',
    password='example',
    database='exampledb'
)
cursor = conn.cursor()

# 建立 DB 和 Table
sql_commands = [
    "CREATE DATABASE IF NOT EXISTS exampledb;",
    "USE exampledb;",
    """
    CREATE TABLE IF NOT EXISTS product_stats (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        product_name VARCHAR(255),
        timestamp DATETIME,
        data TEXT,
        INDEX idx_product_name_timestamp (product_name, timestamp)
    );
    """,
    "TRUNCATE product_stats;"
]

# 執行 SQL 指令
for command in sql_commands:
    cursor.execute(command)

conn.commit()

# 寫入資料
start_time = datetime.now()
insert_batch_size = 2000  # 每批次寫入數據量
product_size = 2000 # 要測試的商品總量
total_records = 0  # 紀錄寫入的數據總量
time_range = 8 * 60 # 總時間 8 hours

# 開始計時
insert_start_time = time.time()
# 建立數據並批量寫入
batch = []
for minute in range(time_range):
    timestamp = start_time + timedelta(minutes=minute)
    for i in range(product_size):  # 每分鐘要寫入的商品紀錄
        product_name = f"商品名稱{i}"  # 模擬 product_size 種不同商品
        stats = f"統計資料{i}"
        batch.append((product_name, timestamp, stats))
        total_records += 1
        
        # 批量寫入
        if len(batch) >= insert_batch_size:
            cursor.executemany(
                "INSERT INTO product_stats (product_name, timestamp, data) VALUES (%s, %s, %s)",
                batch
            )
            conn.commit()
            batch = []

# 寫入剩餘的數據
if batch:
    cursor.executemany(
        "INSERT INTO product_stats (product_name, timestamp, data) VALUES (%s, %s, %s)",
        batch
    )
    conn.commit()

# 計時結束
insert_end_time = time.time()

# 查詢效能測試
query_times = []
for _ in range(100):
    # 隨機生成查詢的時間區間
    start_timestamp = start_time + timedelta(minutes=random.randint(0, time_range-30))  # 最大值為 - 30 為 30 分鐘
    end_timestamp = start_timestamp + timedelta(minutes=30)

    # 查詢多筆商品名稱在特定時間範圍內的資料
    product_names = [f"商品名稱{random.randint(1, product_size)}" for _ in range(10)]  # 隨機查詢 10 個商品

    # 使用 IN 進行多商品名稱查詢
    format_strings = ','.join([f"'{name}'" for name in product_names])
    query = f"SELECT * FROM product_stats WHERE product_name IN ({format_strings}) AND timestamp BETWEEN '{start_timestamp}' AND '{end_timestamp}'"

    # 執行查詢
    start_query = time.time()
    cursor.execute(query)
    rows = cursor.fetchall()
    end_query = time.time()
    query_times.append(end_query - start_query)

print(f"MySQL 寫入時間: {insert_end_time - insert_start_time} 秒")
print(f"MySQL 寫入總量: {total_records} 條")
# 計算平均查詢時間
average_query_time = sum(query_times) / len(query_times)
print(f"MySQL 平均查詢時間: {average_query_time} 秒")

cursor.close()
conn.close()

下面為 MySQL 測試結果:

• 寫入時間: 11.6187 秒
• 平均查詢時間: 0.0058 秒
• 資料大小: 151.4 MB

MongoDB 測試方案 1 ── 單筆資料的 Index 設計

MongoDB 版本: 7.0.9

這個腳本是可以直接與 MySQL 比對的版本，因為都是採 row data 的概念，僅在「商品名稱(product_name)、紀錄時間(timestamp)」加上了 index。數據格式如下：

{
    "product_name" : "商品名稱2",
    "timestamp" : ISODate("2024-05-25T15:24:46.492+0000"),
    "data" : "統計資料2"
}

from pymongo import MongoClient, ASCENDING
import random
import time
from datetime import datetime, timedelta

# MongoDB 連接設置
client = MongoClient('mongodb://localhost:27017/')
db = client.testdb

# 清空集合並創建新集合
db.product_stats.drop()
db.create_collection('product_stats')

# 加入 index
db.product_stats.create_index([("product_name", ASCENDING), ("timestamp", ASCENDING)])

# 寫入數據
start_time = datetime.now()
insert_batch_size = 2000  # 每批次寫入數據量
product_size = 2000 # 要測試的商品總量
total_records = 0  # 記錄寫入的數據總量
time_range = 8 * 60 # 總時間 8 hours

# 開始計時
insert_start_time = time.time()

# 建立數據並批量寫入
batch = []
for minute in range(time_range):  # 8 小時
    timestamp = start_time + timedelta(minutes=minute)
    for i in range(product_size):  # 每分鐘要寫入的商品紀錄
        product_name = f"商品名稱{i}"  # 模擬 product_size 種不同商品
        stats = f"統計資料{i}"
        batch.append({
            "product_name": product_name,
            "timestamp": timestamp,
            "data": stats
        })
        total_records += 1

        # 批量寫入
        if len(batch) >= insert_batch_size:
            db.product_stats.insert_many(batch)
            batch.clear()

# 寫入剩餘的數據
if batch:
    db.product_stats.insert_many(batch)

# 計時結束
insert_end_time = time.time()

# 查詢效能測試
query_times = []
for _ in range(100):
    # 隨機生成查詢的時間區間
    start_timestamp = start_time + timedelta(minutes=random.randint(0, time_range-30))  # 最大值為 - 30 為 30 分鐘
    end_timestamp = start_timestamp + timedelta(minutes=30)

    product_names = [f"商品名稱{random.randint(1, product_size)}" for _ in range(10)]  # 隨機查詢 10 個商品
    query = {
        "product_name": {"$in": product_names},
        "timestamp": {"$gt": start_timestamp, "$lte": end_timestamp}
    }

    # 執行查詢
    start_query = time.time()
    result = db.product_stats.find(query)
    end_query = time.time()
    query_times.append(end_query - start_query)


print(f"MongoDB 寫入時間: {insert_end_time - insert_start_time} 秒")
print(f"MongoDB 寫入總量: {total_records} 條")
# 計算平均查詢時間
average_query_time = sum(query_times) / len(query_times)
print(f"MongoDB 平均查詢時間: {average_query_time} 秒")

client.close()

下面為 MongoDB 測試方案 1 的結果:

• 寫入時間: 6.8597 秒
• 平均查詢時間: 6.3467e-06 秒
• 資料大小: 97.8 MB

MongoDB 測試方案 2 ── Time Series Collection

第二個方案則是採用 MongoDB Time Series Collection 的設計，設定如下：

{
    "product_stats",
    timeseries={
        "timeField": "timestamp",
        "metaField": "product_name",
        "granularity": "minutes"
    }
}

from pymongo import MongoClient, ASCENDING
import random
import time
from datetime import datetime, timedelta

# MongoDB 連接設置
client = MongoClient('mongodb://localhost:27017/')
db = client.testdb

# 清空集合並創建新集合
db.product_stats.drop()
db.create_collection(
    "product_stats",
    timeseries={
        "timeField": "timestamp",
        "metaField": "product_name",
        "granularity": "minutes"
    }
)

# 寫入數據
start_time = datetime.now()
insert_batch_size = 2000  # 每批次寫入數據量
product_size = 2000 # 要測試的商品總量
total_records = 0  # 記錄寫入的數據總量
time_range = 8 * 60 # 總時間 8 hours

# 開始計時
insert_start_time = time.time()

# 建立數據並批量寫入
batch = []
for minute in range(time_range):  # 8 小時
    timestamp = start_time + timedelta(minutes=minute)
    for i in range(product_size):  # 每分鐘要寫入的商品紀錄
        product_name = f"商品名稱{i}"  # 模擬 product_size 種不同商品
        data = f"統計資料{i}"
        
        batch.append({
            "timestamp": timestamp,
            "product_name": product_name,
            "data": data
        })
        total_records += 1

        # 批量寫入
        if len(batch) >= insert_batch_size:
            db.product_stats.insert_many(batch)
            batch.clear()

# 寫入剩餘的數據
if batch:
    db.product_stats.insert_many(batch)

# 計時結束
insert_end_time = time.time()

# 查詢性能測試
query_times = []
for _ in range(100):
    # 隨機生成查詢的時間區間
    start_timestamp = start_time + timedelta(minutes=random.randint(0, time_range-30))  # 最大值為 - 30 為 30 分鐘
    end_timestamp = start_timestamp + timedelta(minutes=30)
    
    product_names = [f"商品名稱{random.randint(1, product_size)}" for _ in range(10)]  # 隨機查詢 10 個商品
    query = {
        "product_name": {"$in": product_names},
        "timestamp": {"$gt": start_timestamp, "$lte": end_timestamp}
    }
    
    # 執行查詢
    start_query = time.time()
    result = db.product_stats.find(query)
    end_query = time.time()
    query_times.append(end_query - start_query)

print(f"MongoDB Time Series Collection 寫入時間: {insert_end_time - insert_start_time} 秒")
print(f"MongoDB Time Series Collection 寫入總量: {total_records} 條")
# 計算平均查詢時間
average_query_time = sum(query_times) / len(query_times)
print(f"MongoDB Time Series Collection 平均查詢時間: {average_query_time} 秒")

client.close()

下面為 MongoDB 測試方案 2 的結果:

• 寫入時間: 31.0204 秒
• 平均查詢時間: 6.7949e-06 秒
• 資料大小: 53.1 MB

MongoDB 測試方案 3 ── Embedded Documents

第三個方案是上篇文章的最終方案，將統計數據紀錄到商品名稱（product_name）底下，並對「商品名稱(product_name)、紀錄時間(timestamp)」加上了 index。數據格式如下：

{
    "_id" : ObjectId("6651a4d6329cedfc74f40dde"),
    "product_name" : "商品名稱0",
    "stats" : [
        {
            "timestamp" : ISODate("2024-05-25T16:44:06.728+0000"),
            "data" : "統計資料0"
        },
        {
            "timestamp" : ISODate("2024-05-25T16:45:06.728+0000"),
            "data" : "統計資料0"
        },
        ...
    ]
}
from pymongo import MongoClient, ASCENDING, UpdateOne
import random
import time
from datetime import datetime, timedelta

# MongoDB 連接設置
client = MongoClient('mongodb://localhost:27017/')
db = client.testdb

# 清空集合並創建新集合
db.product_stats.drop()
db.create_collection('product_stats')

# 加入 index
db.product_stats.create_index([("product_name", ASCENDING), ("stats.timestamp", ASCENDING)])

# 寫入數據
start_time = datetime.now()
insert_batch_size = 2000  # 每批次寫入數據量
product_size = 2000 # 要測試的商品總量
total_records = 0  # 記錄寫入的數據總量
time_range = 8 * 60 # 總時間 8 hours

# 開始計時
insert_start_time = time.time()

# 建立數據並批量寫入
product_dict = {}
for minute in range(time_range):  # 8 小時
    timestamp = start_time + timedelta(minutes=minute)
    for i in range(product_size):  # 每分鐘要寫入的商品紀錄
        product_name = f"商品名稱{i}"  # 模擬 product_size 種不同商品
        stats = {
            "timestamp": timestamp,
            "data": f"統計資料{i}"
        }
        
        if product_name not in product_dict:
            product_dict[product_name] = []
        
        product_dict[product_name].append(stats)
        total_records += 1

        # 批量更新
        if total_records % insert_batch_size == 0:
            operations = [
                UpdateOne(
                    {"product_name": p_name},
                    {"$push": {"stats": {"$each": stats_array}}},
                    upsert=True
                )
                for p_name, stats_array in product_dict.items()
            ]
            db.product_stats.bulk_write(operations)
            product_dict.clear()

# 寫入剩餘的數據
if product_dict:
    operations = [
        UpdateOne(
            {"product_name": p_name},
            {"$push": {"stats": {"$each": stats_array}}},
            upsert=True
        )
        for p_name, stats_array in product_dict.items()
    ]
    db.product_stats.bulk_write(operations)

# 計時結束
insert_end_time = time.time()

# 查詢性能測試
query_times = []
for _ in range(100):
    # 隨機生成查詢的時間區間
    start_timestamp = start_time + timedelta(minutes=random.randint(0, time_range-30))  # 最大值為 - 30 為 30 分鐘
    end_timestamp = start_timestamp + timedelta(minutes=30)
    
    product_names = [f"商品名稱{random.randint(1, product_size)}" for _ in range(10)]  # 隨機查詢 10 個商品
    aggregate_query = [
        {"$match": {"product_name": {"$in": product_names}}},
        {"$unwind": "$stats"},
        {"$match": {"stats.timestamp": {"$gt": start_timestamp, "$lte": end_timestamp}}},
        {"$project": {
            "_id": 0,
            "product_name": 1,
            "timestamp": "$stats.timestamp",
            "data": "$stats.data"
        }}
    ]
    
    # 執行查詢
    start_query = time.time()
    result = db.product_stats.aggregate(aggregate_query)
    end_query = time.time()
    
    query_times.append(end_query - start_query)

print(f"MongoDB 寫入時間: {insert_end_time - insert_start_time} 秒")
print(f"MongoDB 寫入總量: {total_records} 條")
# 計算平均查詢時間
average_query_time = sum(query_times) / len(query_times)
print(f"MongoDB 平均查詢時間: {average_query_time} 秒")

client.close()

下面為 MongoDB 測試方案 3 的結果:

• 寫入時間: 166.6052 秒
• 平均查詢時間: 0.0032 秒
• 資料大小: 53.1 MB

結論：想象跟實際的落差

下面我先用 Table 的方式，向大家展示這四個方案的測試結果:

從寫入與讀取效能的角度來說，MongoDB 單筆 index 的方案就夠了；但如果想要壓縮資料大小，可以考慮 Time Series Collection 的方案。

至於上一篇文章原本打算使用的 Embedded Documents 方案，在寫入效能方面真的不太好，商品種類越多效能越差，真的是沒實驗過不知道。

至於 MySQL 就是一個安全牌，除非有很極致的需求，不然這個方案沒什麼大缺點。

下面整理一下我這次的實驗心得吧:

• 相同資料庫，在資料結構不同的狀況下，效能會有巨大差異。
• 如果只看搜尋效率，MongoDB 大多數情境下會贏
• 其實 MongoDB 跟 MySQL 都能處理這個案例，就看實際業務更關注哪塊的效能。

當然小弟的實驗可能有許多考量不足的地方，歡迎各位大神留言交流，謝謝。

如果你用上圖的錯誤訊息去 Google 搜尋，相信會得到很多解答；但這篇文章遇到的問題，如果用關鍵字搜尋是找不到真正解答的；也因為這次的經驗讓我對 Ubuntu Server、MySQL、apt-mark 有更深一層的認識。

大綱
ㄧ、問題描述
二、關鍵字搜尋到的方案
三、從 Error Log 猜想問題
四、問題的真實原因
五、解決方案
六、後記

ㄧ、問題描述

上週建立的中介資料庫在經歷一個假日後，在禮拜一被同事回報登入失敗。

一開始我以為是帳號密碼錯誤，又或是公司網路問題；但在成功登入 Server 後，我發現連 root 的權限都無法登入 MySQL DB，並出現如下錯誤：

ERROR 2002 (HY000): Can’t connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (2)

二、關鍵字搜尋到的方案

遇事不知求 Google，我馬上搜尋過去前輩們是怎麼解決這個問題的。

解決的方法五花八門，我這邊統整一下大致的方向：

1. 重啟 MySQL 服務
2. 調整 MySQL 資料夾權限，補齊遺漏的檔案
3. 重啟整台 Server
4. 把 MySQL 砍掉重裝

但很遺憾的，1~3 我都嘗試過了，MySQL 依舊頑強的吐一樣的錯誤，看來不能依靠網路的的解法了。

三、從 Error Log 猜想問題

因為網路上的方案都失效，所以決定換一個問題處理的方向，去找 MySQL 的 Error Log（其實一開始應該就要這樣做）。

STEP 1：前往 MySQL 的設定檔。

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

STEP 2：查看 Error Log 存放路徑。

STEP 3：查看 Error Log 內容。

sudo vim /var/log/mysql/error.log

從時間軸發現服務被完整的關閉後就無法重啟，但假日有誰會把服務給關閉呢？

於是我便詢問公司的 MIS 部門，在假日是否有對 Server 進行維護作業。

果然如我所料，對方表示在假日有對各 Server 系統做例行性維護升級，而這台 Ubuntu Server 的 MySQL 正是在這次升級後出問題。

四、問題的真實原因

既然問題是由系統升級引起的，那就比較有解決的方向了；在與 MIS 同仁討論後，我們猜想問題應該是 Ubuntu Server 升級後內建的 MySQL 版本為 8.0，但原本安裝的版本為 5.7，因此在升級後發生版本對應不到的問題。

於是我們便執行下面的指令來查看目前 apt 安裝的套件有哪些，以及對應的版本：

apt list --installed

結果如我們所想，系統更新後，新版本的 MySQL 真的把舊版本給覆蓋住了。

五、解決方案

但因為這台是給其他合作單位使用的資料庫，而對方因為總總歷史包袱只能選用 MySQL 5.7，所以我們是不能對它做升級的。

但幸好 MIS 在維護前有先將 Server 備份，因此我們如下步驟進行處理：

STEP 1：用備份將原本的 Ubuntu Server 還原。

STEP 2：下指令將 MySQL Server 版本鎖定。

apt-mark hold mysql-server

STEP 3：查看是否有鎖定成功。

apt-mark showhold

STEP 4：鎖定後再將 Ubuntu Server 做升級維護。

STEP 5：升級完成後確認 MySQL 版本有鎖定住。

mysql --version

透過上面的步驟後，MySQL 就成功復活了～

六、後記

這個問題花了不少時間才解決，主要是因為我在一開始判斷問題時就走偏了；過去我都是從錯誤訊息找答案，而這次的錯誤訊息卻把我引導到另一個錯誤的方向。

這次的經驗也讓我明白，除了發生問題的本體外，還要多觀察其他有「相依性」的資訊，否則會陷入死胡同，還期待用錯誤的方法得到正確的結果。

但同時也提醒大家，千萬不要看完這篇文章後，回去就把所有安裝的套件版本都鎖死；除非有不得已的理由，不然系統、套件都是需要定期更新的，這樣穩定性、安全性才足夠。

• 我能學到什麼 🤔：sequelize 基礎使用方式。
• 我能學會嗎 🤔：筆者從零開始建立專案，並附上詳細的指令與說明，相信大家都能學得開心。
• 文章目標 🤩：建立一個有使用者（user）、訂單（order）、購買貨物（item）的資料庫，設計 Table 彼此的關連性，透過 Query 確認資料。

大綱
一、初始化專案
二、透過 Config 建立 DB
三、用 Migration 建立 Table
四、用 Seeder 建立假資料(Dummy Data)
五、簡易 Query

大家也可以直接 Clone 筆者 GitHub 上的專案來了解喔。（如果順便按個 Star更好😀）

ㄧ、初始化專案

STEP 1：建立專案資料夾

mkdir sequelize-demo && cd  sequelize-demo
npm init

STEP 2：安裝 sequelize

npm install -g sequelize-cli
npm install --save sequelize

STEP 3：安裝你想使用的 DB（本篇文章以 MySQL 為範例）

npm install --save mysql2 #本篇文章
npm install --save pg pg-hstore # Postgres
npm install --save mariadb
npm install --save sqlite3
npm install --save tedious # Microsoft SQL Server

二、透過 Config 建立 DB

STEP 1：用指令初始化相關設定檔

sequelize init

STEP 2：調整 sequelize 的 config/config.json 檔

預設使用的環境都是development，記得調整成自己的 DB 登入參數

"development": {
    "username": "root",
    "password": "baobaoverycute",
    "database": "sequelize_demo",
    "host": "127.0.0.1",
    "dialect": "mysql"
  },

STEP 3：依照剛剛設定的 config/config.json 來建立 DB

sequelize db:create

如果想要移除該 DB，可透過指令： sequelize db:drop

三、用 Migration 建立 Table

STEP 1：新增所需 Tables & 基礎欄位

根據文章目標，我們需要建立 3 個 Tables：使用者（user）、訂單（order）、購買貨物（item）

sequelize model:generate --name user --attributes name:string,mail:string
sequelize model:generate --name order --attributes user_id:integer,total_price:integer
sequelize model:generate --name item --attributes order_id:integer,price:integer

如果沒有填寫「attributes」的參數會無法建立 Table。

STEP 2：前往 migrations 的資料夾，設計 Table 間的關聯性

調整 order Table，建立 user_id 與 user 的關聯性（一個 user 會對應到多筆 order）

user_id: {
    type: Sequelize.INTEGER,
    references: {
        model: 'users',
        key: 'id'
    },
},

調整 item Table，建立 order_id 與 item 的關聯性（一個 order 會對應到多筆 item）

oder_id: {
    type: Sequelize.INTEGER,
    references: {
        model: 'orders',
        key: 'id'
    },
},

STEP 3：修改完成之後，就可以下指令建立剛剛設定的 Table 啦～

sequelize db:migrate

下圖是用 MySQLWorkbench 產生的 ER Diagram

如果想要回溯 migration 可用如下指令：

• 退一個版本：sequelize db:migrate:undo
• 退到初始狀態：sequelize db:migrate:undo:all
• 退到指定版本：sequelize db:migrate:undo:all –to XXXXXXXXXXXXXX-create-user.js

四、用 Seeder 建立假資料(Dummy Data)

目標：建立 100 個使用者（user），每個使用者有 10 筆訂單（order），每筆訂單下面有 10 個貨物（item）。

STEP 1：先建立 Seeder 檔案

sequelize seed:generate --name demo-user
sequelize seed:generate --name demo-order
sequelize seed:generate --name demo-item

STEP 2：建立各自 Seeder 資料產生的邏輯，下面以 order 舉例：

"use strict";

module.exports = {
  async up(queryInterface, Sequelize) {
    function getRandomInt(max) {
      return Math.floor(Math.random() * max);
    }
    // 100 個使用者，每個使用者有 10 筆訂單（order）
    var orderArray = [];

    for (let i = 1; i <= 100; i++) {
      for (let j = 1; j <= 10; j++) {
        const order = {
          user_id: i,
          total_price: Math.floor(Math.random() * 1000),
          createdAt: new Date(),
          updatedAt: new Date(),
        };
        orderArray.push(order);
      }
    }

    return queryInterface.bulkInsert("Orders", orderArray);
  },

  async down(queryInterface, Sequelize) {
    return queryInterface.bulkDelete("Orders", null, {});
  },
};

原始碼：sequelize-order.js（GitHub Gist）

STEP 3：執行 Seeder

執行單個 Seeder

sequelize db:seed --seed my_seeder_file.js

執行全部 Seeder

sequelize db:seed:all

STEP 4：前往 DB ，確認資料是否有正確寫入：

建立 100 個使用者（users）。

建立 100 個使用者（users），每個使用者有 10 筆訂單（orders），共 1000 筆資料。

建立 100 個使用者（users），每個使用者有 10 筆訂單（orders），每筆訂單下面有 10 個貨物（items），共 10000 筆資料。

取消執行的 Seeder 可用如下指令：

• 取消最近的 Seeder：sequelize db:seed:undo
• 取消指定的 Seeder：sequelize db:seed:undo –seed my_seeder_file.js
• 取消全部 Seeder：sequelize db:seed:undo:all

五、簡易 Query

STEP 1：在專案資料夾下建立一個 row-queries-exmaple.js 的檔案。

STEP 2：將如下程式複製貼上，這是一個簡單 Raw Queries；會找出 price 低於 50 的 5 筆購買貨物，以及對應的使用者。

const { sequelize } = require("./models");
const { QueryTypes } = sequelize;

async function rawQueries() {
  console.time("rawQueries");
  const results = await sequelize.query("SELECT users.name, items.price FROM users\
         LEFT JOIN orders ON orders.user_id = users.id\
         LEFT JOIN items ON items.order_id = orders.id\
         WHERE items.price < 50 LIMIT 5", { type: QueryTypes.SELECT });
  console.log(JSON.stringify(results, null, 2));
  console.timeEnd("rawQueries");
}
rawQueries();

原始碼：sequelize-raw-queries.js（GitHub Gist）

STEP 3：在終端機輸入：node row-queries-exmaple.js

下圖即可看到看到搜尋結果、程式執行時間。

如果你想要知道 Table Join 時，選擇文字欄位（VARCHAR）與數值欄位（INTEGER）在效能（performance）上的差異，可以參考這篇文章。

一、模擬主從複製延遲的情境
二、了解發生問題的原因
三、解決方案：開啟 MySQL 5.7 的多 process 的功能
四、確認 Slave 已經沒有延遲

一、模擬主從複製延遲的情境

這裡我們利用 sysbench 進行情境模擬，如果不清楚如何操作的朋友請參考這篇文章：『用 sysbench 測試 MySQL 性能 — 在 mac & ubuntu 上的安裝與使用』

下面是我在 ubuntu 的測試指令，如果你是 mac 需要自己更換 .lua 的路徑

sysbench /usr/share/sysbench/oltp_write_only.lua \
--mysql-host=127.0.0.1 \
--mysql-port=3306 \
--mysql-user=user_name \
--mysql-password=user_password \
--mysql-db=test \
--db-driver=mysql \
--tables=10 \
--table_size=100000 \
--report-interval=10 \
--threads=128 \
--time=120 \
prepare

原始碼：sysbench_lag.cmd（GitHub Gist）

指令輸入後你就會發現資料庫好像頓住不會動了…

一段時間後我們進入到 Slave 的 MySQL 中會發現他與 Master 的延遲很嚴重

mysql> show slave status\G

• Seconds_Behind_Master：延遲的時間

二、了解發生問題的原因

因為我們模擬的情境會製作出相當大量的 SQL command，執行內容包含：table 內容大量更新、index 建立；可是 Slave 去讀取 Master 的 process 卻只有一個，這樣使 Master 累積了太多尚未同步到 Slave 的 SQL command，因此造成了兩邊資料庫的內容不一致。

三、解決方案：開啟 MySQL 5.7 的多 process 的功能

STEP 1：先暫停 Slave，不然無法修改變數

mysql> stop slave;

STEP 2：更改 slave_parallel_type

先看看預設值

mysql> show variables like ‘slave_parallel%’;

修改變數

mysql> set global slave_parallel_type='logical_clock';
mysql> set global slave_parallel_workers=10; #根據實際需求設定

啟動 Slave 功能

mysql> start slave;

查看剛剛設定的多 process 是否生效

mysql> show processlist;

四、確認 Slave 已經沒有延遲

在上面的設定後稍等一段時間再去查看 Slave 的延遲狀態

mysql> show slave status\G

就發現他已經變成 0 嚕～

如果你想了解資料庫主從式架構的設定歡迎參考我的文章：
👍 MySQL Master Slave Replication 主從式架構設定教學
👍 Ubuntu 用 Atlas 實現 MySQL Proxy 讀寫分離 read/write splitting

參考資訊：mysql master-slave 複寫延滯同步問題

一、在 Mac 上操作 sysbench

安裝 sysbench

如果還沒安裝過 brew 請參考官網

brew install sysbench

安裝完成後輸入指令確認安裝完成

sysbench — version

我安裝的版本為 1.0.20 這個會跟下面的指令路徑有關，如果你安裝的是其他版本要自行修改這個版本路徑

測試 MySQL 性能

mac 的範例是本地端的測試，針對 read 這塊

STEP 1：先建立好測試用的 DB

create database test;

STEP 2：建立測試資料

• mysql-user、mysql-password：改成自己 MySQL 的使用者
• mysql-db：測試的資料庫
• range_size、table_size、tables：測試的規模
• prepare：建立測資的意思

sysbench /usr/local/Cellar/sysbench/1.0.20/share/sysbench/oltp_read_only.lua \
--db-driver=mysql \
--mysql-user=user_name \
--mysql-password=user_password \
--mysql-db=test \
--range_size=100 \
--table_size=10000 \
--tables=2 \
--threads=1 \
--events=0 \
--time=60 \
--rand-type=uniform \
prepare

原始碼：sysbench_prepare.cmd（GitHub Gist）

STEP 3：進行測試

只是把指令最後面改成 run

sysbench /usr/local/Cellar/sysbench/1.0.20/share/sysbench/oltp_read_only.lua \
--db-driver=mysql \
--mysql-user=user_name \
--mysql-password=user_password \
--mysql-db=test \
--range_size=100 \
--table_size=10000 \
--tables=2 \
--threads=1 \
--events=0 \
--time=60 \
--rand-type=uniform \
run

原始碼：sysbench_run.cmd（GitHub Gist）

STEP 4：清除測試數據

只是把指令最後面改成 cleanup

sysbench /usr/local/Cellar/sysbench/1.0.20/share/sysbench/oltp_read_only.lua \
--db-driver=mysql \
--mysql-user=user_name \
--mysql-password=user_password \
--mysql-db=test \
--range_size=100 \
--table_size=10000 \
--tables=2 \
--threads=1 \
--events=0 \
--time=60 \
--rand-type=uniform \
cleanup

原始碼：sysbench_cleanup.cmd（GitHub Gist）

一、在 Ubuntu 上操作 sysbench

安裝 sysbench

sudo apt-get install sysbench -y

安裝完成後輸入指令確認安裝完成

sysbench — version

測試 MySQL 性能

ubuntu 的範例是遠端的測試，針對 write這塊

STEP 1：先建立好測試用的 DB

create database test;

STEP 2：建立測試資料

如果你的設定跟我的範例一樣可能要稍微等一下，因為範例的測資比較大筆

• mysql-host：目標測試的 ip 或是 host name
• mysql-port：目標測試的 MySQL port
• mysql-user、mysql-password：改成自己 MySQL 的使用者
• mysql-db：測試的資料庫
• range_size、table_size、tables：測試的規模
• prepare：建立測資的意思

sysbench /usr/share/sysbench/oltp_write_only.lua \
--mysql-host=127.0.0.1 \
--mysql-port=3306 \
--mysql-user=user_name \
--mysql-password=user_password \
--mysql-db=test \
--db-driver=mysql \
--tables=10 \
--table_size=10000 \
--report-interval=10 \
--threads=128 \
--time=120 \
prepare

原始碼：ubuntu_sysbench_prepare.cmd（GitHub Gist）

STEP 3：進行測試

只是把指令最後面改成 run

sysbench /usr/share/sysbench/oltp_write_only.lua \
--mysql-host=127.0.0.1 \
--mysql-port=3306 \
--mysql-user=user_name \
--mysql-password=user_password \
--mysql-db=test \
--db-driver=mysql \
--tables=10 \
--table_size=10000 \
--report-interval=10 \
--threads=128 \
--time=120 \
run

原始碼：ubuntu_sysbench_run.cmd（GitHub Gist）

STEP 4：清除測試數據

只是把指令最後面改成 cleanup

sysbench /usr/share/sysbench/oltp_write_only.lua \
--mysql-host=127.0.0.1 \
--mysql-port=3306 \
--mysql-user=user_name \
--mysql-password=user_password \
--mysql-db=test \
--db-driver=mysql \
--tables=10 \
--table_size=10000 \
--report-interval=10 \
--threads=128 \
--time=120 \
cleanup

原始碼：ubuntu_sysbench_cleanup.cmd（GitHub Gist）

以上是今天的分享，想了解更多功能請參考官方的 github

參考資源：Ubuntu 16.04中進行Sysbench環境搭建、sysbench安装和使用

一、前置作業
二、MySQL Proxy 的選擇
三、Atlas 功能介紹
四、在 Ubunut 安裝 Atlas
五、連到 Atlas 管理 server
六、實際測試透過 Atlas Proxy 是否達成讀寫分離

一、前置作業

OS version、MySQL 是筆者安裝時的環境，ip 是給大家參考對應的

準備一台要當 MySQL Proxy 的 ubuntu server

• OS version：ubuntu 16.04
• MySQL：5.7
• ip ：172.16.9.39

準備一台 Master server 負責寫入

• OS version：ubuntu 16.04
• MySQL：5.7
• ip ：172.16.9.32

準備一台以上的 Slave server 負責讀取

準備兩台以上測試 load balance 才會準確，這塊有興趣的讀者可以自己嘗試

• OS version：ubuntu 16.04
• MySQL：5.7
• ip ：172.16.9.32

在 Master Server 裡面增加給 Proxy server 使用的使用者，並創建測試用 table

/*建立proxy server使用者*/
mysql> CREATE USER 'proxy_account'@'%' IDENTIFIED BY 'proxy_password';
/*給使用者權限*/
mysql> GRANT ALL ON *.* TO 'proxy_account'@'%';
/*使權限生效*/
mysql> FLUSH PRIVILEGES;
/*創建測試用資料庫*/
CREATE DATABASE proxy_test;

原始碼：create_proxy_user.sql（GitHub Gist）

二、MySQL Proxy 的選擇

• MySQL Proxy：原本想使用官方工具來處理讀寫分離，但一上官網發現連他自己都不推薦使用😱，所以就不在多費心力研究。

• MySQL Router：根據官方的指引認真的研究這個工具後發現雖然設定上簡單，但並不是很符合需求，他的讀寫分離是同一台伺服器分成兩個 port 來處理，雖然現在主流框架都支援這樣的操作，但我認為這樣的方式並不優雅
• kingshard：是基於 Go 語言開發的 MySQL Proxy，在 github 上面擁有高人氣；但實際使用心得真的是滿滿的陰影…官方安裝指引非常的爛，鬼才知道要自己切換 branch 才能使用啊？設定檔根本要用錯誤嘗試法，沒說清楚必填選填，上面這些問題也就罷了，安裝成功後居然告訴我只有 windows 的電腦可以測試 mac 電腦不行😡，作者是在開玩笑嗎？總之我非常的不推薦。
• Atlas：是基於 MySQL-Proxy 0.8.2 版本開發的工具，由 360 公司推出，在 github 上面找到最新的版本是 2015 年推出的，至於為什麼不再更新的理由，360 公司表示因為這個工具已經夠棒了🥴，沒什麼繼續優化的必要性了；事實上這個工具也是筆者最後選用的，儘管安裝過程滿滿的坑😓

三、Atlas 功能介紹

1. 讀寫分離
2. slave server 的 load balance
3. IP filter
4. DBA 可以輕鬆的上下線 DB（有指令支持）
5. 自動移除當機的 DB（但如果當機的是 master server，就只剩讀取功能）

四、在 Ubunut 安裝 Atlas

筆者在安裝過程中感受到滿滿的惡意

STEP 1：下載 & 安裝 Atlas

你可以在官方 github release 中找到 deb 的安裝包下載他

wget https://github.com/Qihoo360/Atlas/releases/download/2.2/Atlas-2.2-debian6.0-x86_64.deb

執行安裝

dpkg -i Atlas-2.2-debian6.0-x86_64.deb

STEP 2：調整 Atlas 的設定檔

Atlas 的安裝路徑是/usr/local/mysql-proxy ，執行時的參數會參考 conf 目錄下的 test.cnf 檔案

vi /usr/local/mysql-proxy/conf/test.cnf

下面幾個需要特別調整，其他用默認的就可以了

• proxy-backend-addresses：填寫 Master server 的 ip

• proxy-read-only-backend-addresses：填寫 Slave server 的 ip

• pwds：請使用於前置作業 Master server 新增專門給 Proxy Server 使用的帳號密碼，密碼要用下面的指令作加密

# 前往加密的目錄
cd /usr/local/mysql-proxy/bin
# 對密碼加密
./encrypt proxy_password

• sql-log：預設是 OFF 不會紀錄，但為了方便觀察讀寫是否分離，我們將它設定為 REALTIME

STEP 3：啟動 Atlas

輸入下面指令即可啟動 Atlas

/usr/local/mysql-proxy/bin/mysql-proxyd test start

不過應該有 99% 的人會在這個步驟失敗

你可以在 log 裡面看錯誤訊息

vi /usr/local/mysql-proxy/log/test.log

解決方式：

# 安裝套件相關套件
apt-get install libmysqlclient-dev
apt-get install mysql-client
# 下載缺失的 libmysqlclient.so.16 套件，我是在這個網站找到的
wget http://files.directadmin.com/services/debian_5.0_64/libmysqlclient.so.16
# 將 libmysqlclient.so.16 搬移到 lib 目錄下
mv libmysqlclient.so.16 /usr/lib/x86_64-linux-gnu/

再次啟動 Atlas

/usr/local/mysql-proxy/bin/mysql-proxyd test start

看到 OK: MySQL-Proxy of test is started 的提示就成功嚕！

檢查 Atlas 服務狀態

/usr/local/mysql-proxy/bin/mysql-proxyd test status

五、連到 Atlas 管理 server

Atlas 預設的管理 port 為 2345，ip 填寫 Proxy server ip，如果 admin 的帳號密碼沒換就是跟下面一樣

mysql -h172.16.9.39 -P2345 -uuser -ppwd

查看 Atlas 的管理命令

mysql> select * from help;

查看 MySQL 讀寫分離設定是否生效

rw 為讀寫權限，ro 代表只有讀的權限

mysql> select * from backends;

到這步其實就可以完結撒花惹 😊😊😊😊😊😊

六、實際測試透過 Atlas Proxy 是否達成讀寫分離

Atlas 預設的proxy port 為 1234，ip 填寫 Proxy server ip，登入的帳號密碼填寫你在 Master 申請給 Atlas Proxy 使用的那組

mysql -h172.16.9.39 -P1234 -uproxy_account -pproxy_password

測試寫入功能

# 先選擇之前創建的測試資料庫
mysql> use proxy_test;
# 創建表並塞入一寫資料
mysql> CREATE TABLE department (id INT,name varchar(50));
mysql> INSERT INTO department VALUES (1, 'Sales');
mysql> INSERT INTO department VALUES (2, 'Operator');

測試讀取功能

# 先選擇之前創建的測試資料庫
mysql> use proxy_test;
# 讀取剛剛創建的 table
mysql> SELECT * FROM department;

觀察 sql 運行的 log

記得把 Atla 設定檔的 ssql-log 參數調整為 REALTIME 才會有喔！

前往 log file

tail /usr/local/mysql-proxy/log/sql_test.log

從下圖我們可以觀察到，負責變更資料庫的是 Master server(172.16.3.32)，讀取的則是 Slave Server(172.16.3.33)，恭喜自己大功告成

希望這篇文章有幫助到使用 Ubuntu 架設 MySQL 並且想做到讀寫分離的開發人員，網路上對這塊的資訊相對來說比較零散，有些甚至都是錯誤，整理起來這些文件也真的很費力，如果對你有幫助的話可以幫我按個拍手👏給我一點繼續分享技術文章的動力。

如果你想了解資料庫主從式架構的設定歡迎參考我的文章：
👍 MySQL Master Slave Replication 主從式架構設定教學
👍 在 MySQL 5.7 解決主從複製的延遲問題

參考資訊：下載libmysqlclient.so.16檔案、讀寫分離測試、Mysql访问中间件 — Atlas初探、Atlas、Atlas Github

Master Slave Replication 是一個 Web 工程師需要具備的基礎概念，我們可以透過這個技術有效的降低 Database server 負荷，同時給使用者提供更穩定順暢的體驗；本文除了讓你了解這個技術的原理外還會以 MySQL 這門資料庫語言一步步透過實作讓你理解如何實現它。

一、30 秒認識 Master Slave Replication 是什麼
  ∙ 為什麼需要 Master Slave Replication 的架構？
  ∙ Master Slave Replication 為什麼能夠解決這些問題？
  ∙ Master Slave Replication 的架構
二、實作 MySQL Master Slave replication
  ∙ 前置作業
  ∙ 建立MySQL Replication
三、驗證 Master、Slave DB 是否同步

一、30 秒認識 Master Slave Replication 是什麼

為什麼需要 Master Slave Replication 的架構？

• 網站需要面對大流量：新聞媒體類的網站無論哪個時段都會被大量的檢索，如果資料庫只用一個 server 來處理會無法負荷瞬間的高流量。
• 資料庫內容需要被分析：公司如果有資料分析部門，他們也會隨時監控資料庫的變化來產生報表，但如果跟一般使用者一樣 query 同一台 server 會使這台 server 增加不必要的負荷導致使用者體驗下降。

Master Slave Replication 為什麼能夠解決這些問題？

• 主從式架構：將資料庫的 server 區分成 Master(1台) 與 Slave(N台) 兩種，Master 負責資料寫入，Slave 提供資料檢索；這樣就把壓力分散到幾台 Server 上面。
• 資料庫同步：Slave 會同步 Master 的資料，這樣除了分散 server 壓力外，資料也獲得了備份。

Master Slave Replication 的架構

1. 在 master 的 server 執行的 SQL command 會被記錄在 Binary Log 裡面
2. master 將 Binary Log 傳送到 slave 的 Relay Log
3. slave 依據 Relay Log 做資料的變更

二、實作 MySQL Master Slave replication

前置作業

準備兩台 ubuntu server (自己實驗建議使用 VMWARE)，筆者環境配置如下

硬體配置一定會影響到效能，筆者只是建置一個提供實驗的環境而已

• OS version：ubuntu 16.04
• RAM：1G
• ROM：8G

給兩台 sever 安裝 MySQL

安裝指令如下

sudo apt update
sudo apt install mysql-server

安裝完成後你可以先登入 MySQL 看看安裝版本資訊

sudo mysql -u root -p

建立MySQL Replication

Master server 設定

STEP 1：設定 Master server 的 my.cnf

sudo vi /etc/mysql/my.cnf

[mysqld]
# 在這裡設定已蓋過預設的127.0.0.1(只能連本機)
bind-address = 0.0.0.0

# id為唯一值，每個server不可重覆
server-id = 1

# 指定產生bin log檔案名稱，使MySQL記錄所有DB交易記錄
log-bin=mysql-bin

原始碼：my.cnf（GitHub Gist）

儲存後，重啟 MySQL 才會生效

sudo /etc/init.d/mysql restart

STEP 2：在 Master server 建立給 Slave 複製資料的帳號

登入 MySQL

sudo mysql -u root -p

建立有 REPLICATION、SLAVE 權限的 user 帳號

/*建立使用者*/
mysql> CREATE USER 'account'@'ip' IDENTIFIED BY 'password';
/*給使用者權限*/
mysql> GRANT REPLICATION SLAVE ON *.* TO 'account'@'ip';
/*使權限生效*/
mysql> FLUSH PRIVILEGES;

原始碼：create_slave_user.sql（GitHub Gist）

STEP 3：備份 Master server 的 DB

執行此步驟時如果系統已經上線，一定要發出公告說明系統維護時間

在完成 DB Replication 前，為了保證 Master 與 Slave 的資料相同，你需要先把 DB Lock 成 read only：

mysql> FLUSH TABLES WITH READ LOCK;

備份指令：

mysqldump -uroot -p  --all-databases > master.sql

解除 read only：

mysql> UNLOCK TABLES;

STEP 4：檢查 Master 是否已經啟動

mysql> SHOW MASTER STATUS \G

Slave server 設定

STEP 1：將剛剛備份的 master.sql 還原到 Slave server 的 DB

先複製 master.sql 到 Slave server 的目錄下

sudo scp master.sql <username>@<IP or hostname>:<Destination>

下指令還原 DB

mysql -u root -p — default-character-set=utf8 < master.sql

STEP 2：設定 Slave server 的 my.cnf

sudo vi /etc/mysql/my.cnf

[mysqld]
#注意：不可與剛剛設定的 Master 重複
server-id=2 

#Slave server 的 DB 開啟唯獨避免被寫入
read-only=on

原始碼：slave_my.cnf（GitHub Gist）

儲存後，重啟 MySQL 才會生效

sudo /etc/init.d/mysql restart

STEP 3：設定 SlaveDB，指定 Master DB 登入資訊，並啟動 Replication

/* 這裡的帳號密碼就上面 Master 設定的那組 */
mysql> CHANGE MASTER TO MASTER_HOST='master_ip',
              MASTER_USER='account',
              MASTER_PASSWORD='password';

原始碼：setting_slave_info.sql（GitHub Gist）

啟動 Slave Replication：

mysql> START SLAVE;

STEP 4：檢查 replication 狀態

SHOW SLAVE STATUS \G

如果下圖紅框皆顯示 Yes 就代表你成功嚕！

如果你看到下面這個畫面，可能是因為你的 Master MySQL 的設定有問題，最有可能是『使用者帳號、密碼錯誤』、『bind-address 沒有調整』

三、驗證 Master、Slave DB 是否同步

先在 Master 確認是不是真的有跟 Slave 串接成功

show slave hosts;

確認連接成功後我們在 Master server 上面新增一個 DB

回到 Slave server 就會看到 DB 被同步過來嚕～

這篇文章是針對 MySQL Master Slave Replication 做說明，但你依照上面的做法完成後還需要思考幾個問題：

• 我們知道 Master server 是用來更新資料，Slave server 是用來檢索資料；但他們都是獨立的 ip，總不能每個 api 執行時都連不一樣的 ip 吧？
• Slave 的資料是從 Master 上複製過來的，會複製就代表會有延遲，要如何保持資料的一致性呢？

如果你想深入了解上面的問題如何解決可以參考我的文章：
👍 在 MySQL 5.7 解決主從複製的延遲問題
👍 Ubuntu 用 Atlas 實現 MySQL Proxy 讀寫分離 read/write splitting

參考資源：MySQL Master Slave replication、打造MySQL Replication

一、SQL Fiddle 簡介
二、MySQL Online 簡介
三、題目：找出每個 department 中 score 最高的兩個人並以 score 進行排序
  1. 用 SQL Fiddle 解題
  2. 用 MySQL Online 解題

一、SQL Fiddle 簡介

網址：http://sqlfiddle.com/

支援資料庫版本：

介面說明：

1. 選擇資料庫及版本
2. DDL 區域：CREATE TABLE, INSERT 都在這個地方輸入，按下『Build Schema』即可生成 Schema；要先生成Schema才能執行SQL
3. DML 區域：資料庫操作語言區域
4. Result：顯示執行結果

二、MySQL Online 簡介

網址：https://paiza.io/en/projects/new?language=mysql

介面說明：

1. 選擇測試語言：除了 MySQL 外，他還能測試 C、Java、R、php…
2. 程式碼區域：他的DDL與DML是混合在一起的，所以要測試就全部貼上去
3. Result：顯示執行結果

三、題目：找出每個 department 中 score 最高的兩個人，並符合輸出結果的排序

⚒️ 生成題目資料表的 SQL :

CREATE TABLE employee (
  id INT,
  name varchar(50),
  score INT,
  department_id  INT
);
CREATE TABLE department (
  id INT,
  name varchar(50)
);
INSERT INTO employee VALUES (1, 'John', 83,1);
INSERT INTO employee VALUES (2, 'Yannis', 88,2);
INSERT INTO employee VALUES (3, 'Victor', 83,1);
INSERT INTO employee VALUES (4, 'Jimmy', 83,3);
INSERT INTO employee VALUES (5, 'Richard', 88,1);
INSERT INTO employee VALUES (6, 'Hens', 82,2);
INSERT INTO employee VALUES (7, 'Peter', 89,2);
INSERT INTO employee VALUES (8, 'Brian', 77,1);
INSERT INTO employee VALUES (9, 'Kelvin', 90,3);
INSERT INTO employee VALUES (10, 'Ben', 80,3);

INSERT INTO department VALUES (1, 'Sales');
INSERT INTO department VALUES (2, 'Operator');
INSERT INTO department VALUES (3, 'Development');

原始碼：employee_score_question.sql（GitHub Gist）

目標輸出結果：

這個題目表面上看起來很簡單，實際做起來會遇到一些沒想到的問題，有興趣的小夥伴建議自己先玩玩不要直接看答案，文章後面也會說明這兩種編輯器的最大差異

1. 用 SQL Fiddle 解題

你的 SQL 版本會被限制在 5.6，你需要在許多好用函數都無法使用的狀態下完成這個題目

解題思路：因為 5.6 並沒有 row_number() 這個函數，所以我們要自己製作出來；另外多利用 subquery 的概念讓解答符合題目的輸出結果。

2. 用 MySQL Online 解題

你的 SQL 版本為 8.0，你解題的重點便在於對新的函數是否熟悉

解題思路：MySQL 8.0 是一個重大更新，ROW_NUMBER 這個函數就能讓你以輕鬆的姿態搞定這個題目，如果你不熟悉可以參考這份文檔。

我的解答僅供參考(尚未優化)，有興趣的朋友可以在底下留言分享你的做法喔～希望這篇文章能幫助臨時需要寫 SQL 的朋友

文章架構如下：

1. 安裝MySQL
2. 設定MySQL可以讓外網連線
3. MySQL防火牆設定
4. 建立新DB
5. 新增/刪除使用者及權限
6. 列出資料庫有權限的使用者列表
7. 列出所有User權限表
8. 修改MySQL root密碼
9. 修改整體密碼規則強度

1. 安裝MySQL

在安裝MySQL的時候會問你很多問題，如果你沒有特殊需求就都用y通過，密碼強度部分需要記住自己是怎麼設定的(因為不同密碼強度的規則差異很大，詳情可以看這篇)

sudo apt update
sudo apt install mysql-server
sudo mysql_secure_installation

安裝完成後你可以先進入MySQL看看

sudo mysql -u root -p

2. 設定MySQL可以讓外網連線

如果你所架設的MySQL是允許外網或者某個特定ip做連線的，你就做以下調整

sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf
bind-address = 0.0.0.0 //這個是指誰都可以連線的意思
sudo su
service mysql restart //設定完成後要重啟才會生效

3. MySQL防火牆設定

以下為最基礎的防火牆設定，資料庫慣用的port為3306，22是給ssh登入使用的

sudo apt-get install ufw
sudo ufw enable
sudo ufw allow 3306
sudo ufw allow 22/tcp
sudo ufw status

4. 建立新DB

sudo mysql -u root -p

進入MySQL後你可以用指令的方式建立DB如下，如果你需要修改他默認編碼也能夠透過ALTER去做修正

CREATE DATABASE db_name;
ALTER DATABASE xxx_db CHARACTER SET utf8 COLLATE utf8_bin;

5. 新增/刪除使用者及權限

新增mysql使用者及賦予權限

use mysql; //進入這個資料庫
create user ‘某某人’@‘哪個ip可以(%為全部)’ IDENTIFIED WITH mysql_native_password BY ‘密碼’;
CREATE DATABASE `資料庫名稱`;
grant all privileges on 資料庫名稱(如果沒填就是全部).* to ‘某某人’@‘哪個ip可以’ identified by ‘密碼’;

刪除使用者及其權限

REVOKE ALL PRIVILEGES, GRANT OPTION FROM ‘某某人’@‘哪個ip可以(%為全部)’;
DROP USER ‘某某人’@‘哪個ip可以(%為全部)’;
flush privileges; //刷新權限
select * from information_schema.user_privileges;//確認該User權限已被刪除

6. 列出資料庫有權限的使用者列表

select user from mysql.db where db=’資料庫名稱’;

7. 列出所有User權限表

select * from information_schema.user_privileges;

8. 修改mysql root密碼

請切記要修改root的密碼，避免駭客侵入你的伺服器後可以無所忌憚的讀取你的資料

use mysql;
// 先指定 plugin 為 mysql_native_password
UPDATE user SET plugin=’mysql_native_password’ WHERE User=’root’;
UPDATE mysql.user SET authentication_string=PASSWORD(‘password’) WHERE USER=’root’;
FLUSH PRIVILEGES;

9. 修改整體密碼規則強度

如果你在安裝時對於密碼強度的問題是隨便選的，你可以在登入MySQL後用這個指令做修正

set global validate_password_policy=0;

密碼強度檢查等級，0/LOW、1/MEDIUM、2/STRONG

0 or LOW Length
1 or MEDIUM Length; numeric, lowercase/uppercase, and special characters
2 or STRONG Length; numeric, lowercase/uppercase, and special characters;

預設是1，即MEDIUM，所以剛開始設定的密碼必須符合長度，且必須含有數字，小寫或大寫字母，特殊字元。

修改密碼長度限制

set global validate_password_length=6;

千萬不要為了圖方便而設計複雜度太低的密碼