ToB企服应用市场:ToB评测及商务社交产业平台

标题: DBPack 赋能 python 微服务协调分布式事务 [打印本页]
作者: 自由的羽毛    时间: 2022-8-9 14:41
标题: DBPack 赋能 python 微服务协调分布式事务
作者：朱晗 中国电子云
什么是分布式事务

事务处理几乎在每一个信息系统中都会涉及，它存在的意义是为了保证系统数据符合期望的，且相互关联的数据之间不会产生矛盾，即数据状态的一致性。
按照数据库的经典理论，原子性、隔离性、持久性。原子性要求数据要么修改要么回滚，隔离性要求事务之间相互独立不影响，持久性要求事务的执行能正确的持久化，不丢失数据。mysql 类的行式数据库通过 mvcc 多版本视图和 wal 预写日志等技术的协作，实现了单个服务使用单个数据源或者单个服务使用多个数据源场景的多事务的原子性、隔离性和持久性。
凤凰架构这本书中有描述，单个服务使用单个数据源称之为本地事务，单个服务使用多个数据源称之为全局事务，而分布式事务特指多个服务同时访问多个数据源的事务处理机制。
DBpack 简介

分布式事务的实现有很多方式，如可靠性事务队列，TCC事务，SAGA事务等。
可靠性事务队列，也就是BASE，听起来和强一致性的ACID，"酸碱"格格不入，它作为最终一致性的概念起源，系统性地总结了一种针对分布式事务的技术手段。
TCC 较为烦琐，如同名字所示，它分为以下三个阶段。
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请求我们可以模拟分布式事务发起或者回滚。
  1. from flask import Flask, request, jsonify
  2. import requests
  4. app = Flask(__name__)
  6. create_so_url        = "http://order-svc:3001/createSo"
  7. update_inventory_url = "http://product-svc:3002/allocateInventory"
  9. @app.route('/v1/order/create', methods=['POST'])
  10. def create_1():
  11.    return create_so(rollback=False)
  12.    
  13. @app.route('/v1/order/create2', methods=['POST'])
  14. def create_2():
  15.    return create_so(rollback=True)
  17. def create_so(rollback=True):
  18.     xid = request.headers.get("x-dbpack-xid")
  20.     so_items = [dict(
  21.         product_sysno=1,
  22.         product_name="apple iphone 13",
  23.         original_price=6799,
  24.         cost_price=6799,
  25.         deal_price=6799,
  26.         quantity=2,
  27.     )]
  29.     so_master = [dict(
  30.         buyer_user_sysno = 10001,
  31.         seller_company_code = "SC001",
  32.         receive_division_sysno = 110105,
  33.         receive_address = "beijing",
  34.         receive_zip = "000001",
  35.         receive_contact = "scott",
  36.         receive_contact_phone =  "18728828296",
  37.         stock_sysno = 1,
  38.         payment_type = 1,
  39.         so_amt = 6999 * 2,
  40.         status = 10,
  41.         appid = "dk-order",
  42.         so_items = so_items,
  43.     )]
  45.     success = (jsonify(dict(success=True, message="success")), 200)
  46.     failed = (jsonify(dict(success=False, message="failed")), 400)
  47.     headers = {
  48.         "Content-Type": "application/json",
  49.         "xid": xid
  50.     }
  52.     so_req = dict(req=so_master)
  53.     resp1 = requests.post(create_so_url, headers=headers, json=so_req)
  54.     if resp1.status_code == 400:
  55.         return failed
  57.     ivt_req = dict(req=[dict(product_sysno= 1, qty=2)])
  58.     resp2 = requests.post(update_inventory_url, headers=headers, json=ivt_req)
  59.     if resp2.status_code == 400:
  60.         return failed
  62.     if rollback:
  63.         print("rollback")
  64.         return failed
  66.     return success
  68. if __name__ == "__main__":
  69.     app.run(host="0.0.0.0", port=3000)
复制代码
那么如何使用 dbpack 代理该服务呢？
  1. $./dist/dbpack start --config ../dbpack-samples/configs/config-aggregation.yaml
  3. $ cat ../dbpack-samples/configs/config-aggregation.yaml
  4. listeners:
  5.   - protocol_type: http
  6.     socket_address:
  7.       address: 0.0.0.0
  8.       port: 13000
  9.     config:
  10.       backend_host: aggregation-svc:3000
  11.     filters:
  12.       - httpDTFilter
  14. filters:
  15.   - name: httpDTFilter
  16.     kind: HttpDistributedTransaction
  17.     conf:
  18.       appid: aggregationSvc
  19.       transaction_infos:
  20.         - request_path: "/v1/order/create"
  21.           timeout: 60000
  22.         - request_path: "/v1/order/create2"
  23.           timeout: 60000
  25. distributed_transaction:
  26.   appid: aggregationSvc
  27.   retry_dead_threshold: 130000
  28.   rollback_retry_timeout_unlock_enable: true
  29.   etcd_config:
  30.     endpoints:
  31.       - etcd:2379
复制代码
可想而知，以上的微服务两个 handler 是通过 filters这部分的定义来配置拦截的。
接着是订单系统。
  1. from flask import Flask, jsonify, request
  2. from datetime import datetime
  3. import mysql.connector
  5. import time
  6. import random
  8. app = Flask(__name__)
  10. insert_so_master = "INSERT /*+ XID('{xid}') */ INTO order.so_master({keys}) VALUES ({placeholders})"
  11. insert_so_item = "INSERT /*+ XID('{xid}') */ INTO order.so_item({keys}) VALUES ({placeholders})"
  13. def conn():
  14.     retry = 0
  15.     while retry < 3:
  16.         time.sleep(5)
  17.         try:
  18.             c = mysql.connector.connect(
  19.               host="dbpack3",
  20.               port=13308,
  21.               user="dksl",
  22.               password="123456",
  23.               database="order",
  24.               autocommit=True,
  25.             )
  26.             if c.is_connected():
  27.                 db_Info = c.get_server_info()
  28.                 print("Connected to MySQL Server version ", db_Info)
  29.                 return c
  30.         except Exception as e:
  31.             print(e.args)
  32.         retry += 1
  34. connection = conn()
  35. cursor = connection.cursor(prepared=True,)
  37. @app.route('/createSo', methods=['POST'])
  38. def create_so():
  39.     xid = request.headers.get('xid')
  40.     reqs = request.get_json()
  41.     if xid and "req" in reqs:
  42.         for res in reqs["req"]:
  43.             res["sysno"] = next_id()
  44.             res["so_id"] = res["sysno"]
  45.             res["order_date"] = datetime.now()
  46.             res_keys = [str(k) for k,v in res.items() if k != "so_items" and str(v) != ""]
  47.             so_master = insert_so_master.format(
  48.                 xid=xid,
  49.                 keys=", ".join(res_keys),
  50.                 placeholders=", ".join(["%s"] * len(res_keys)),
  51.             )
  53.             try:
  54.                 cursor.execute(so_master, tuple(res.get(k, "") for k in res_keys))
  55.             except Exception as e:
  56.                 print(e.args)
  57.             
  58.             so_items = res["so_items"]
  59.             for item in so_items:
  60.                 item["sysno"] = next_id()
  61.                 item["so_sysno"] = res["sysno"]
  62.                 item_keys = [str(k) for k,v in item.items() if str(v) != "" ]
  63.                 so_item = insert_so_item.format(
  64.                     xid=xid,
  65.                     keys=", ".join(item_keys),
  66.                     placeholders=", ".join(["%s"] * len(item_keys)),
  67.                 )
  68.                 try:
  69.                     cursor.execute(so_item, tuple(item.get(k, "") for k in item_keys))
  70.                 except Exception as e:
  71.                     print(e.args)
  73.         return jsonify(dict(success=True, message="success")), 200
  74.    
  75.     return jsonify(dict(success=False, message="failed")), 400
  77. def next_id():
  78.     return random.randrange(0, 9223372036854775807)
  79.   
  81. if __name__ == '__main__':
  82.    app.run(host="0.0.0.0", port=3001)
复制代码
注意到 sql 中以注解的形式添加使用了 xid ，主要是方便配合 dbpack 识别后做出相应的分布式事务处理，也就是回滚还是commit。
这里数据库连接使用 autocommit 这种方式。同时，使用 python 中的 mysql.connector 这个 lib 来支持 sql 传输中的二段式加密传输协议，见代码中声明的prepared=true。
用以下命令，使用 dbpack 代理 order 微服务：
  1. ./dist/dbpack start --config ../dbpack-samples/configs/config-order.yaml
复制代码
最后是产品库存系统，详细代码如下：
  1. from flask import Flask, jsonify, request
  3. import time
  4. import mysql.connector
  6. app = Flask(__name__)
  8. 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;"
  10. def conn():
  11.     retry = 0
  12.     while retry < 3:
  13.         time.sleep(5)
  14.         try:
  15.             c = mysql.connector.connect(
  16.               host="dbpack2",
  17.               port=13307,
  18.               user="dksl",
  19.               password="123456",
  20.               database="product",
  21.               autocommit=True,
  22.             )
  24.             if c.is_connected():
  25.                 db_Info = c.get_server_info()
  26.                 print("Connected to MySQL Server version ", db_Info)
  27.                 return c
  28.         except Exception as e:
  29.             print(e.args)
  30.         retry += 1
  32. connection = conn()
  33. cursor = connection.cursor(prepared=True,)
  35. @app.route('/allocateInventory', methods=['POST'])
  36. def create_so():
  37.     xid = request.headers.get('xid')
  38.     reqs = request.get_json()
  39.     if xid and "req" in reqs:
  40.         for res in reqs["req"]:
  41.             try:
  42.                 cursor.execute(allocate_inventory_sql.format(xid=xid), (res["qty"], res["qty"], res["product_sysno"], res["qty"],))
  43.             except Exception as e:
  44.                 print(e.args)
  45.         
  46.         return jsonify(dict(success=True, message="success")), 200
  47.         
  48.     return jsonify(dict(success=False, message="failed")), 400
  50. if __name__ == '__main__':
  51.     app.run(host="0.0.0.0", port=3002)
复制代码
同样，用以下命令使用 dbpack 代理 product 微服务：
  1. ./dist/dbpack start --config ../dbpack-samples/configs/config-product.yaml
复制代码
我们可以使用docker-compose一键拉起以上三个微服务：
  1. docker-compose up
复制代码
正常情况下，以下请求会触发订单系统和产品库存系统的正常 commit：
  1. curl -XPOST http://localhost:13000/v1/order/create
复制代码
而以下命令虽然正常请求了订单系统和产品库存的 API，不管事务是否正常执行，由于事务发起方状态码不正常，要求"回滚"，所以会导致已经 commit 的微服务发生回滚，以此保证分布式系统的一致性：
  1. curl -XPOST http://localhost:13000/v1/order/create2
复制代码
参考资料


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4