DBPack 賦能 python 微服務協調分佈式事務

作者：朱晗中國電子雲

什麼是分佈式事務

事務處理幾乎在每一個信息系統中都會涉及，它存在的意義是爲了保證系統數據符合期望的，且相互關聯的數據之間不會產生矛盾，即數據狀態的一致性。

按照數據庫的經典理論，原子性、隔離性、持久性。原子性要求數據要麼修改要麼回滾，隔離性要求事務之間相互獨立不影響，持久性要求事務的執行能正確的持久化，不丟失數據。mysql 類的行式數據庫通過 mvcc 多版本視圖和 wal 預寫日誌等技術的協作，實現了單個服務使用單個數據源或者單個服務使用多個數據源場景的多事務的原子性、隔離性和持久性。

鳳凰架構這本書中有描述，單個服務使用單個數據源稱之爲本地事務，單個服務使用多個數據源稱之爲全局事務，而分佈式事務特指多個服務同時訪問多個數據源的事務處理機制。

DBpack 簡介

分佈式事務的實現有很多方式，如可靠性事務隊列，TCC事務，SAGA事務等。

可靠性事務隊列，也就是BASE，聽起來和強一致性的ACID，"酸鹼"格格不入，它作爲最終一致性的概念起源，系統性地總結了一種針對分佈式事務的技術手段。

TCC 較爲煩瑣，如同名字所示，它分爲以下三個階段。

Try：嘗試執行階段，完成所有業務可執行性的檢查（保障一致性），並且預留好全部需用到的業務資源（保障隔離性）。
Confirm：確認執行階段，不進行任何業務檢查，直接使用 Try 階段準備的資源來完成業務處理。Confirm 階段可能會重複執行，因此本階段所執行的操作需要具備冪等性。
Cancel：取消執行階段，釋放 Try 階段預留的業務資源。Cancel 階段可能會重複執行，也需要滿足冪等性。

SAGA 事務將事務進行了拆分，大事務拆分若干個小事務，將整個分佈式事務 T 分解爲 n 個子事務，同時爲爲每一個子事務設計對應的補償動作。儘管補償操作通常比凍結或撤銷容易實現，但保證正向、反向恢復過程的能嚴謹地進行也需要花費不少的工夫。

DBPack 的分佈式事務致力於實現對用戶的業務無入侵，使用時下流行的sidecar架構，主要使用 ETCD Watch 機制來驅動分佈式事務提交回滾，它對 HTTP 流量和 MYSQL 流量做了攔截代理，支持 AT 模式（自動補償 SQL）和 TCC 模式（自動補償 HTTP 請求）。

DBPack 的 AT 模式性能取決於全局鎖的釋放速度，哪個事務競爭到了全局鎖就能對業務數據做修改，在單位時間內，全局鎖的釋放速度越快，競爭到鎖的事務越多，性能越高。DBPack 創建全局事務、註冊分支事務只是在 ETCD 插入兩條 KV 數據，事務提交回滾時修改對應數據的狀態，通過 ETCD Watch 機制感知到數據的變化就能立即處理數據的提交回滾，從而在交互上減少了很多 RPC 請求。

DBPack 的 TCC 模式中，請求會先到達 sidecar 後再註冊 TCC 事務分支，確保 Prepare 先於 Cancel 執行。具體到操作的業務數據，建議使用 XID 和 BranchID 加鎖。

DBpack 賦能 python 微服務

以上的前戲已鋪墊，後文以講解python 微服務代碼爲主，不涉及 dbpack 源碼，感興趣的童鞋可去自行調試瞭解。

https://github.com/CECTC/dbpack-samples/blob/main/python

這裏會提到三個微服務，首先是是事務發起方，其次是訂單系統，最後是產品庫存系統。而每一個微服務，都使用dbpack代理。事務發起方請求成功後，當訂單正常commit後，產品庫存要發生正常扣除，一旦一個微服務未完成，另一個則要發生回滾，也就是說，兩個微服務系統要保持一致。

首先，模擬分佈式事務發起方的服務，該服務會註冊兩個 handler，一個會發起正常的請求，走 dbpack 代理髮起分佈式事務，另一個會則會非正常返回。事務發起方會根據 http 的請求情況，決定是否要發起分佈式事務回滾。

以下借用了 flask web 框架實現了事務發起方的兩個handler，通過兩個http請求我們可以模擬分佈式事務發起或者回滾。

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

create_so_url        = "http://order-svc:3001/createSo"
update_inventory_url = "http://product-svc:3002/allocateInventory"

@app.route('/v1/order/create', methods=['POST'])
def create_1():
   return create_so(rollback=False)
    
@app.route('/v1/order/create2', methods=['POST'])
def create_2():
   return create_so(rollback=True)

def create_so(rollback=True):
    xid = request.headers.get("x-dbpack-xid")

    so_items = [dict(
        product_sysno=1,
        product_name="apple iphone 13",
        original_price=6799,
        cost_price=6799,
        deal_price=6799,
        quantity=2,
    )]

    so_master = [dict(
        buyer_user_sysno = 10001,
        seller_company_code = "SC001",
        receive_division_sysno = 110105,
        receive_address = "beijing",
        receive_zip = "000001",
        receive_contact = "scott",
        receive_contact_phone =  "18728828296",
        stock_sysno = 1,
        payment_type = 1,
        so_amt = 6999 * 2,
        status = 10,
        appid = "dk-order",
        so_items = so_items,
    )]

    success = (jsonify(dict(success=True, message="success")), 200)
    failed = (jsonify(dict(success=False, message="failed")), 400)
    headers = {
        "Content-Type": "application/json",
        "xid": xid
    }

    so_req = dict(req=so_master)
    resp1 = requests.post(create_so_url, headers=headers, json=so_req)
    if resp1.status_code == 400:
        return failed

    ivt_req = dict(req=[dict(product_sysno= 1, qty=2)])
    resp2 = requests.post(update_inventory_url, headers=headers, json=ivt_req)
    if resp2.status_code == 400:
        return failed

    if rollback:
        print("rollback")
        return failed

    return success

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=3000)

那麼如何使用 dbpack 代理該服務呢？

$./dist/dbpack start --config ../dbpack-samples/configs/config-aggregation.yaml

$ cat ../dbpack-samples/configs/config-aggregation.yaml
listeners:
  - protocol_type: http
    socket_address:
      address: 0.0.0.0
      port: 13000
    config:
      backend_host: aggregation-svc:3000
    filters:
      - httpDTFilter

filters:
  - name: httpDTFilter
    kind: HttpDistributedTransaction
    conf:
      appid: aggregationSvc
      transaction_infos:
        - request_path: "/v1/order/create"
          timeout: 60000
        - request_path: "/v1/order/create2"
          timeout: 60000

distributed_transaction:
  appid: aggregationSvc
  retry_dead_threshold: 130000
  rollback_retry_timeout_unlock_enable: true
  etcd_config:
    endpoints:
      - etcd:2379

可想而知，以上的微服務兩個 handler 是通過 filters這部分的定義來配置攔截的。

接着是訂單系統。

from flask import Flask, jsonify, request
from datetime import datetime
import mysql.connector

import time
import random

app = Flask(__name__)

insert_so_master = "INSERT /*+ XID('{xid}') */ INTO order.so_master({keys}) VALUES ({placeholders})"
insert_so_item = "INSERT /*+ XID('{xid}') */ INTO order.so_item({keys}) VALUES ({placeholders})"

def conn():
    retry = 0
    while retry < 3:
        time.sleep(5)
        try:
            c = mysql.connector.connect(
              host="dbpack3",
              port=13308,
              user="dksl",
              password="123456",
              database="order",
              autocommit=True,
            )
            if c.is_connected():
                db_Info = c.get_server_info()
                print("Connected to MySQL Server version ", db_Info)
                return c
        except Exception as e:
            print(e.args)
        retry += 1 
 
connection = conn()
cursor = connection.cursor(prepared=True,)

@app.route('/createSo', methods=['POST'])
def create_so():
    xid = request.headers.get('xid')
    reqs = request.get_json()
    if xid and "req" in reqs:
        for res in reqs["req"]:
            res["sysno"] = next_id()
            res["so_id"] = res["sysno"]
            res["order_date"] = datetime.now()
            res_keys = [str(k) for k,v in res.items() if k != "so_items" and str(v) != ""]
            so_master = insert_so_master.format(
                xid=xid,
                keys=", ".join(res_keys),
                placeholders=", ".join(["%s"] * len(res_keys)),
            )

            try:
                cursor.execute(so_master, tuple(res.get(k, "") for k in res_keys))
            except Exception as e:
                print(e.args)
             
            so_items = res["so_items"]
            for item in so_items:
                item["sysno"] = next_id()
                item["so_sysno"] = res["sysno"]
                item_keys = [str(k) for k,v in item.items() if str(v) != "" ]
                so_item = insert_so_item.format(
                    xid=xid,
                    keys=", ".join(item_keys),
                    placeholders=", ".join(["%s"] * len(item_keys)),
                )
                try:
                    cursor.execute(so_item, tuple(item.get(k, "") for k in item_keys))
                except Exception as e:
                    print(e.args)
 
        return jsonify(dict(success=True, message="success")), 200
    
    return jsonify(dict(success=False, message="failed")), 400 

def next_id():
    return random.randrange(0, 9223372036854775807)
  

if __name__ == '__main__':
   app.run(host="0.0.0.0", port=3001)

注意到 sql 中以註解的形式添加使用了 xid ，主要是方便配合 dbpack 識別後做出相應的分佈式事務處理，也就是回滾還是commit。

這裏數據庫連接使用 autocommit 這種方式。同時，使用 python 中的 mysql.connector 這個 lib 來支持 sql 傳輸中的二段式加密傳輸協議，見代碼中聲明的prepared=true。

用以下命令，使用 dbpack 代理 order 微服務：

./dist/dbpack start --config ../dbpack-samples/configs/config-order.yaml

最後是產品庫存系統，詳細代碼如下：

from flask import Flask, jsonify, request

import time
import mysql.connector

app = Flask(__name__)

allocate_inventory_sql = "update /*+ XID('{xid}') */ product.inventory set available_qty = available_qty - %s, allocated_qty = allocated_qty + %s where product_sysno = %s and available_qty >= %s;"

def conn():
    retry = 0
    while retry < 3:
        time.sleep(5)
        try:
            c = mysql.connector.connect(
              host="dbpack2",
              port=13307,
              user="dksl",
              password="123456",
              database="product",
              autocommit=True,
            )

            if c.is_connected():
                db_Info = c.get_server_info()
                print("Connected to MySQL Server version ", db_Info)
                return c
        except Exception as e:
            print(e.args)
        retry += 1 
 
connection = conn()
cursor = connection.cursor(prepared=True,)

@app.route('/allocateInventory', methods=['POST'])
def create_so():
    xid = request.headers.get('xid')
    reqs = request.get_json()
    if xid and "req" in reqs:
        for res in reqs["req"]:
            try:
                cursor.execute(allocate_inventory_sql.format(xid=xid), (res["qty"], res["qty"], res["product_sysno"], res["qty"],))
            except Exception as e:
                print(e.args)
        
        return jsonify(dict(success=True, message="success")), 200
        
    return jsonify(dict(success=False, message="failed")), 400

if __name__ == '__main__':
    app.run(host="0.0.0.0", port=3002)

同樣，用以下命令使用 dbpack 代理 product 微服務：

./dist/dbpack start --config ../dbpack-samples/configs/config-product.yaml

我們可以使用docker-compose一鍵拉起以上三個微服務：

docker-compose up

正常情況下，以下請求會觸發訂單系統和產品庫存系統的正常 commit：

curl -XPOST http://localhost:13000/v1/order/create

而以下命令雖然正常請求了訂單系統和產品庫存的 API，不管事務是否正常執行，由於事務發起方狀態碼不正常，要求"回滾"，所以會導致已經 commit 的微服務發生回滾，以此保證分佈式系統的一致性：

curl -XPOST http://localhost:13000/v1/order/create2

參考資料

官方倉庫：
https://github.com/CECTC/dbpack
https://github.com/CECTC/dbpack-samples
https://cectc.github.io/dbpack-doc/#/
鳳凰架構：http://icyfenix.cn/architect-perspective/general-architecture/transaction/distributed.html

DBPack 賦能 python 微服務協調分佈式事務

什麼是分佈式事務

DBpack 簡介

DBpack 賦能 python 微服務

參考資料

公司新來一個幹練小夥，把 MyBatis 替換成 MyBatis-Plus，上線後哭暈在廁所。。。

5款開源、美觀、強大的WPF UI組件庫

Testin雲測上線華爲Pura 70系列真機測試服務！

10分鐘本地運行llama3及初體驗

golang 表格

手寫協議報文 c語言手法

甲骨文(Oracle)宣佈將以74億美元收購Sun公司

DBPack 限流熔斷功能發佈說明

DBPack SQL Tracing 功能及數據加密功能詳解

DBPack 讀寫分離功能發佈公告

DBPack 賦能 python 微服務協調分佈式事務

dotnet core 也能協調分佈式事務啦！

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結