日期：2025年 03月 29日

標籤： Docker Docker-Compose Container Ubuntu Linux MySQL Asp.NET Core Web MVC

摘要：資料庫分散式架構

第一部分：資料庫分散式架構簡介

Step 1：資料庫分散式 - 簡介

分散式資料庫是一個邏輯上統一但實際上分散在不同地理位置的資料庫系統。

它將資料分散儲存在多個實體位置的資料庫中,這些資料庫透過網路連接並協同工作,
對使用者來說就像是在使用單一資料庫一樣。

有以下特點：

示意：

Step 2：資料庫分散式 - 用途

常見的使用情境如下：

但是資料庫分散存放會有以下問題要克服：

本篇介紹 XA 協議，解決分散式資料庫 - 克服上述 3 個困難點

Step 3：資料庫分散式 - 四大核心維度

分散式資料庫通常從以下幾個主要維度進行觀察和分析，每個分散性資料庫架構都會依照這 4 個核心維度做評估考量

Step 4：四大核心維度 - 一致性協議角度

這個角度主要關注的是「如何」實現資料一致性，以及在速度和一致性之間的取捨機制

1. 強一致性 (Paxos/Raft)：

2. 最終一致性 (Gossip)：

3. 交易一致性 (XA/TCC)：

Step 5：四大核心維度 - 一致性協議角度

這個理論影響了許多設計決策，例如在特定場景下選擇犧牲強一致性來換取更高的可用性

1. CP 型（一致性 + 分區容錯）：

2. AP 型（可用性 + 分區容錯） ：

2. CA 型（較少使用）：

Step 6：四大核心維度 - 數據分布角度

分散式資料庫的核心元素、如何儲存、分割、複製和管理資料，同時也關係到資料的完整性、安全性和效能優化

1. 分片 (Sharding)：

2. 複製 (Replication)：

3. 混合 (Hybrid)：

Step 7：四大核心維度 - 事務處理角度

這主要對應到「事務處理機制」和「一致性模型研究」中的具體實現方式

1. ACID（完整事務特性）：

2. BASE（最終一致性） ：

3. 混合：

第二部分：XA 協議概述

Step 1：XA 協議的所屬維度

XA 主要聚焦於一致性協議和事務處理這兩個維度，它是一種特定的分散式事務協議，用於確保多個獨立資源之間的事務一致性。
數據分布角度中，只要求符合強一致性處理，並不限制使用哪種保存方式。

Step 2：XA 協議架構組成

Step 3：XA 工作流程(二階段, 2PC)

以下為 XA 工作流程中，每個協議架構具體工作的內容：

3. 4. 項內容就是二階段提交(2PC)的核心思想：

Step 5： MySQL 在 XA 中的工作流程

MySQL 主要負責 Resource Manager (RM)

MySQL 會響應 XA 命令（XA START, XA END, XA PREPARE, XA COMMIT, XA ROLLBACK）

Step 6： XA 二階段提交(2PC) - 優缺點

二階段提交確保了所有資料庫要麼都提交變更，要麼都不提交，避免了系統處於不一致的狀態。
在資料庫中，這種機制可以防止一部分資料庫更新成功而另一部分失敗的情況，保持了整個系統的一致性。

延伸的優點如下：
優點結論：資料絕對完整，同步不遺失

並遺毒的缺點如下：
缺點結論：效能差

Step 7： XA 二階段提交(2PC) - 適合應用情境

XA 協議具有 資料絕對完整，同步不遺失、效能差 主要特性
因此適合的應用情境如下：

1. 金融交易：

2. 庫存與訂單系統：

3. 企業資源規劃(ERP)系統：

4. 小型至中型分散式系統：

Step 8： XA 二階段提交(2PC) - 不可用情境

XA 協議具有 資料絕對完整，同步不遺失、效能差 主要特性
因此不建議的應用情境如下：

1. 高並發系統：

2. 大規模微服務架構：

3. 長時間執行的業務流程：

4. 可用性要求極高的系統：

第三部分：XA 範例實作 - 準備環境

Step 1：Docker Compose - 下載

將範例代碼下載後，將代碼根目錄的 .sql 與 docker-compose.yml 放進 Ubuntu 的目錄下，如圖：

Step 2：Docker Compos - 安裝Mysql

輸入以下指令，進行安裝

docker-compose up -d

Step 3：Docker Compos - 內容說明

此 dokcer-compose.yml 安裝腳本，安裝了以下內容：

version: '3.8'

services:
  mysql-bank-a:
    image: mysql:8.0
    container_name: mysql-bank-a
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: Bank_A
    ports:
      - "3306:3306"
    volumes:
      - ./mysql-bank-a-data:/var/lib/mysql
      - ./init-bank-a.sql:/docker-entrypoint-initdb.d/init.sql
    command: --default-authentication-plugin=mysql_native_password
            --innodb_lock_wait_timeout=120
            --max_connections=1000
    networks:
      xa-network:
        ipv4_address: 172.20.0.2

  mysql-bank-b:
    image: mysql:8.0
    container_name: mysql-bank-b
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: Bank_B
    ports:
      - "3307:3306"
    volumes:
      - ./mysql-bank-b-data:/var/lib/mysql
      - ./init-bank-b.sql:/docker-entrypoint-initdb.d/init.sql
    command: --default-authentication-plugin=mysql_native_password
            --innodb_lock_wait_timeout=120
            --max_connections=1000
    networks:
      xa-network:
        ipv4_address: 172.20.0.3

networks:
  xa-network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

第四部分：XA 範例實作 - 代碼DEMO

Step 1：環境說明

目前我們環境架構如下，想像我們是在一家銀行內，由 A 分行內轉到 B 分行，通常情況下金錢的流動上，都是同一個用戶，因此必須強一致性 ：
1. 兩個資料庫已經啟動 & 我們目標會啟動代碼驅使兩個資料庫完成整個 XA 協議：

2. 並且 2 個資料庫有以下的資料結構

Step 2：啟動專案

範例代碼下載後，啟動專案
啟動後會出現以下兩個按鈕

Step 3：DEMO - 不使用 XA - 控制器

當點擊 不使用 XA 按鈕時，會呼叫以下 API

/// <summary>
/// 1. [不使用] XA 的 API 
/// </summary>
 [HttpGet]
public async Task<ActionResult<TransferResult>> TransferWithoutXA()
{
    // Step 1. 準備資料， A庫 寫進 B庫
    var request = new TransferRequest()
    {
        Amount = 10000,
        FromAccount = "A_Louis",
        ToAccount = "B_Louis",
    };
    // Step 2. 進行單庫寫入 (不使用XA)
    var result = await _transferService.TransferWithoutXAAsync(request);
    if (!result.Success)
        return BadRequest(result);
    return Ok(result);
}

Step 3：DEMO - 不使用 XA - 業務邏輯 - 問題出現

如果不使用 XA 的情況下，我們多個分行的資料庫會有可能在以下 危險點1 ~ 3 造成問題

        /// <summary>        
        /// 一、不使用 XA 的轉賬方法 - 可能出現的問題：
        /// 1. 當 Bank_A 扣款成功，但 Bank_B 加款失敗時，資金會丟失
        /// 2. 系統崩潰或網絡中斷時，無法確保數據一致性
        /// 3. 無法進行有效的回滾操作
        /// </summary>
        public async Task<TransferResult> TransferWithoutXAAsync(TransferRequest request)
        {
            try
            {
                // Step 1-1 : 從 Bank_A 扣款
                using (var connA = new MySqlConnection(_connectionStringBankA))
                {
                    await connA.OpenAsync();
                    using (var cmd = connA.CreateCommand())
                    {
                        var sql = $@"
UPDATE accounts
   SET balance = balance - @amount
 WHERE account_number = @account
";
                        cmd.CommandText = sql;
                        cmd.Parameters.AddWithValue("@amount", request.Amount);
                        cmd.Parameters.AddWithValue("@account", request.FromAccount);
                        await cmd.ExecuteNonQueryAsync();
                    }
                }

                // 危險點1：如果在這裡系統崩潰或者網絡中斷
                // Bank_A 的錢已經扣除，但 Bank_B 還沒收到
                // 這時資金就會丟失，而且無法自動恢復

                // Step 1-2 : 在 Bank_B 增加餘額
                using (var connB = new MySqlConnection(_connectionStringBankB))
                {
                    await connB.OpenAsync();
                    using (var cmd = connB.CreateCommand())
                    {
                        var sql = $@"
UPDATE accounts
   SET balance = balance + @amount
 WHERE account_number = @account
";
                        cmd.CommandText = sql;
                        cmd.Parameters.AddWithValue("@amount", request.Amount);
                        cmd.Parameters.AddWithValue("@account", request.ToAccount);
                        await cmd.ExecuteNonQueryAsync();
                    }
                }

                // 危險點2：如果在這裡出錯
                // 雖然兩個操作都完成了，但我們無法確認是否都成功
                // 可能會出現數據不一致的情況

                return new TransferResult
                {
                    Success = true,
                    Message = "Transfer completed",
                    TransactionId = "NO_XA_" + Guid.NewGuid().ToString()
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Transfer failed without XA");

                // Step 2: 回滾階段
                // 危險點3：即使捕獲到異常，我們也無法確保能夠正確地回滾之前的操作
                // 可能會導致數據不一致
                return new TransferResult
                {
                    Success = false,
                    Message = $"Transfer failed: {ex.Message}",
                    TransactionId = "NO_XA_" + Guid.NewGuid().ToString()
                };
            }
        }

Step 4：DEMO - 不使用 XA - 業務邏輯 - 危險點1

以危險點1 來看，當扣款成功後，但是這時程式 Crash 或者網路異常

就有可能造成以下資料流的現象，不一致的問題發生。

Step 5：DEMO - 使用 XA - 控制器

當點擊 使用 XA 按鈕時，會呼叫以下 API

/// <summary>
/// 2. [使用] XA 的 API
/// </summary>        
[HttpGet]
public async Task<ActionResult<TransferResult>> TransferWithXA()
{
    // Step1. 準備資料， A庫 寫進 B庫
    var request = new TransferRequest()
    {
        Amount = 10000,
        FromAccount = "A_Louis",
        ToAccount = "B_Louis",
    };

    // Step 2. 進行雙庫寫入 (使用XA)
    var result = await _transferService.TransferWithXAAsync(request);
    if (!result.Success)
        return BadRequest(result);

    return Ok(result);
}

Step 6：DEMO - 使用 XA - 業務邏輯 - 2PC

遵循著 二階段 (2PC) ，我們依序完成 AP, TM 的工作，並且由 MySQL 實現 RM 的腳色

/// <summary>
/// 二、使用 XA 的轉賬方法 - 解決的問題：
/// 1. 確保轉賬的原子性：要麼全部成功，要麼全部失敗
/// 2. 支持分布式事務回滾：出錯時可以安全回滾
/// 3. 保證跨庫數據一致性：兩個銀行的數據始終保持一致
/// </summary>
public async Task<TransferResult> TransferWithXAAsync(TransferRequest request)
{
    // Step 1. 產生本次 XA 的唯一碼
    string xaId = Guid.NewGuid().ToString();
    MySqlConnection connA = null;
    MySqlConnection connB = null;

    try
    {
        _logger.LogInformation($"Starting XA transaction {xaId}");

        // Step 2-1. 同時打開兩個連接
        connA = new MySqlConnection(_connectionStringBankA);
        connB = new MySqlConnection(_connectionStringBankB);
        await connA.OpenAsync();
        await connB.OpenAsync();

        // Step 2-2：開始 XA 事務
        // 說明：這確保了後續的所有操作都在一個分布式事務中
        await ExecuteXaCommandAsync(connA, $"XA START '{xaId}'");
        await ExecuteXaCommandAsync(connB, $"XA START '{xaId}'");

        // Step 2-3：行鎖
        // 說明：將此帳號鎖定，避免同時間被異動
        await ForUpdateAccount(connA, request.FromAccount);
        await ForUpdateAccount(connB, request.ToAccount);

        // Step 2-4：執行轉賬操作(業務邏輯)
        // 說明：這些操作要麼全部成功，要麼全部失敗
        await ExecuteTransferAsync(connA, request.FromAccount, -request.Amount);//A 扣
        await ExecuteTransferAsync(connB, request.ToAccount, request.Amount);//B 增加

        // Step 2-5：準備階段
        // 說明：確保所有參與者都準備好提交
        await ExecuteXaCommandAsync(connA, $"XA END '{xaId}'");
        await ExecuteXaCommandAsync(connB, $"XA END '{xaId}'");
        await ExecuteXaCommandAsync(connA, $"XA PREPARE '{xaId}'");
        await ExecuteXaCommandAsync(connB, $"XA PREPARE '{xaId}'");

        // Step 2-6：提交階段
        // 說明：只有當所有準備工作都成功後才提交
        await ExecuteXaCommandAsync(connA, $"XA COMMIT '{xaId}'");
        await ExecuteXaCommandAsync(connB, $"XA COMMIT '{xaId}'");

        _logger.LogInformation($"XA transaction completed successfully: {xaId}");

        return new TransferResult
        {
            Success = true,
            Message = "Transfer completed successfully with XA",
            TransactionId = xaId
        };
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"XA transaction failed: {xaId}");

        try
        {
            // Step 3：回滾階段
            // XA 確保了即使在錯誤情況下也能正確回滾
            if (connA?.State == System.Data.ConnectionState.Open)
                await ExecuteXaCommandAsync(connA, $"XA ROLLBACK '{xaId}'");
            if (connB?.State == System.Data.ConnectionState.Open)
                await ExecuteXaCommandAsync(connB, $"XA ROLLBACK '{xaId}'");
        }
        catch (Exception rollbackEx)
        {
            _logger.LogError(rollbackEx, $"XA rollback failed: {xaId}");
        }

        return new TransferResult
        {
            Success = false,
            Message = $"Transfer failed with XA: {ex.Message}",
            TransactionId = xaId
        };
    }
    finally
    {
        await connA?.CloseAsync();
        await connB?.CloseAsync();
    }

    #region [閉包] 私有方法

            /// <summary>
            /// 執行 XA 事務相關命令
            /// </summary>
            async Task ExecuteXaCommandAsync(MySqlConnection connection, string command)
            {
                try
                {
                    using var cmd = connection.CreateCommand();
                    cmd.CommandText = command;
                    cmd.CommandTimeout = 30; // 設置超時時間
                    _logger.LogDebug($"Executing XA command: {command}");
                    await cmd.ExecuteNonQueryAsync();
                }
                catch (MySqlException ex)
                {
                    _logger.LogError(ex, $"Error executing XA command: {command}");
                    throw new Exception($"XA command failed: {command}", ex);
                }
            }

            /// <summary>
            /// 鎖定行防止併發修改
            /// </summary>
            async Task ForUpdateAccount(MySqlConnection connection, string accountNumber)
            {
                try
                {
                    using var cmd = connection.CreateCommand();
                    cmd.CommandText = @"
                SELECT balance 
                  FROM accounts 
                 WHERE account_number = @account
                   FOR UPDATE";  // 鎖定行防止並發修改

                    cmd.Parameters.AddWithValue("@account", accountNumber);

                    using var reader = await cmd.ExecuteReaderAsync();
                    if (!await reader.ReadAsync())
                    {
                        throw new Exception($"Account not found: {accountNumber}");
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, $"Error ForUpdateAccount for account: {accountNumber}");
                    throw new Exception($"ForUpdateAccount failed for account: {accountNumber}", ex);
                }
            }

            /// <summary>
            /// 執行轉賬操作
            /// </summary>
            async Task ExecuteTransferAsync(MySqlConnection connection, string accountNumber, decimal amount)
            {
                try
                {
                    using var cmd = connection.CreateCommand();
                    cmd.CommandText = @"
                UPDATE accounts 
                   SET balance = balance + @amount
                 WHERE account_number = @account";

                    cmd.Parameters.AddWithValue("@amount", amount);
                    cmd.Parameters.AddWithValue("@account", accountNumber);

                    int rowsAffected = await cmd.ExecuteNonQueryAsync();

                    if (rowsAffected == 0)
                    {
                        throw new Exception($"Account not found or update failed: {accountNumber}");
                    }

                    _logger.LogInformation($"Transfer completed for account {accountNumber}: {amount}");
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, $"Error executing transfer for account: {accountNumber}");
                    throw new Exception($"Transfer failed for account: {accountNumber}", ex);
                }
            }

            #endregion
}

Step 7：DEMO - 使用 XA - 業務邏輯 - 強一致性

在此情境下，可以透過 XA 實現 ACID 達成強一致性的同步資料，讓分散式資料庫，都能達到一致性的資料同步。
分散式資料庫下，在評估實際情境下 XA 克服了以下 3 個問題：