基於sanic的微服務基礎架構

songcser發表於2017-12-25
微服務架構

介紹

使用python做web開發面臨的一個最大的問題就是效能，在解決C10K問題上顯的有點吃力。有些非同步框架Tornado、Twisted、Gevent 等就是為了解決效能問題。這些框架在效能上有些提升，但是也出現了各種古怪的問題難以解決。

在python3.6中，官方的非同步協程庫asyncio正式成為標準。在保留便捷性的同時對效能有了很大的提升,已經出現許多的非同步框架使用asyncio。

使用較早的非同步框架是aiohttp，它提供了server端和client端，對asyncio做了很好的封裝。但是開發方式和最流行的微框架flask不同，flask開發簡單，輕量，高效。

微服務是最近最火開發模式，它解決了複雜性問題，提高開發效率，便於部署等優點。

正是結合這些優點, 以Sanic為基礎，整合多個流行的庫來搭建微服務。 Sanic框架是和Flask相似的非同步協程框架，簡單輕量，並且效能很高。

本專案就是以Sanic為基礎搭建的微服務框架。

特點

  • 使用sanic非同步框架，簡單，輕量，高效。
  • 使用uvloop為核心引擎，使sanic在很多情況下單機併發甚至不亞於Golang。
  • 使用asyncpg為資料庫驅動，進行資料庫連線，執行sql語句執行。
  • 使用aiohttp為Client，對其他微服務進行訪問。
  • 使用peewee為ORM，但是隻是用來做模型設計和migration。
  • 使用opentracing為分散式追蹤系統。
  • 使用unittest做單元測試，並且使用mock來避免訪問其他微服務。
  • 使用swagger做API標準，能自動生成API文件。

使用

專案地址： sanic-ms

Example

服務端

使用sanic非同步框架，有較高的效能，但是使用不當會造成blocking, 對於有IO請求的都要選用非同步庫。新增庫要慎重。 sanic使用uvloop非同步驅動，uvloop基於libuv使用Cython編寫，效能比nodejs還要高。

功能說明：

啟動前

@app.listener('before_server_start')
async def before_srver_start(app, loop):
    queue = asyncio.Queue()
    app.queue = queue
    loop.create_task(consume(queue, app.config.ZIPKIN_SERVER))
    reporter = AioReporter(queue=queue)
    tracer = BasicTracer(recorder=reporter)
    tracer.register_required_propagators()
    opentracing.tracer = tracer
    app.db = await ConnectionPool(loop=loop).init(DB_CONFIG)
複製程式碼
  • 建立DB連線池
  • 建立Client連線
  • 建立queue, 消耗span，用於日誌追蹤
  • 建立opentracing.tracer進行日誌追蹤

中介軟體

@app.middleware('request')
async def cros(request):
    if request.method == 'POST' or request.method == 'PUT':
        request['data'] = request.json
    span = before_request(request)
    request['span'] = span


@app.middleware('response')
async def cors_res(request, response):
    span = request['span'] if 'span' in request else None
    if response is None:
        return response
    result = {'code': 0}
    if not isinstance(response, HTTPResponse):
        if isinstance(response, tuple) and len(response) == 2:
            result.update({
                'data': response[0],
                'pagination': response[1]
            })
        else:
            result.update({'data': response})
        response = json(result)
        if span:
            span.set_tag('http.status_code', "200")
    if span:
        span.set_tag('component', request.app.name)
        span.finish()
    return response
複製程式碼
  • 建立span, 用於日誌追蹤
  • 對response進行封裝，統一格式

異常處理

對丟擲的異常進行處理，返回統一格式

任務

建立task消費queue中對span，用於日誌追蹤

非同步處理

由於使用的是非同步框架，可以將一些IO請求並行處理

Example:

async def async_request(datas):
    # async handler request
    results = await asyncio.gather(*[data[2] for data in datas])
    for index, obj in enumerate(results):
        data = datas[index]
        data[0][data[1]] = results[index]

@user_bp.get('/<id:int>')
@doc.summary("get user info")
@doc.description("get user info by id")
@doc.produces(Users)
async def get_users_list(request, id):
    async with request.app.db.acquire(request) as cur:
        record = await cur.fetch(
            """ SELECT * FROM users WHERE id = $1 """, id)
        datas = [
            [record, 'city_id', get_city_by_id(request, record['city_id'])]
            [record, 'role_id', get_role_by_id(request, record['role_id'])]
        ]
        await async_request(datas)
        return record
複製程式碼

get_city_by_id, get_role_by_id是並行處理。

相關連線

sanic

模型設計 & ORM

Peewee is a simple and small ORM. It has few (but expressive) concepts, making it easy to learn and intuitive to use。

ORM使用peewee, 只是用來做模型設計和migration, 資料庫操作使用asyncpg。

Example:

# models.py

class Users(Model):
    id = PrimaryKeyField()
    create_time = DateTimeField(verbose_name='create time',
                                default=datetime.datetime.utcnow)
    name = CharField(max_length=128, verbose_name="user's name")
    age = IntegerField(null=False, verbose_name="user's age")
    sex = CharField(max_length=32, verbose_name="user's sex")
    city_id = IntegerField(verbose_name='city for user', help_text=CityApi)
    role_id = IntegerField(verbose_name='role for user', help_text=RoleApi)

    class Meta:
        db_table = 'users'


# migrations.py

from sanic_ms.migrations import MigrationModel, info, db

class UserMigration(MigrationModel):
    _model = Users

    # @info(version="v1")
    # def migrate_v1(self):
    #     migrate(self.add_column('sex'))

def migrations():
    try:
        um = UserMigration()
        with db.transaction():
            um.auto_migrate()
            print("Success Migration")
    except Exception as e:
        raise e

if __name__ == '__main__':
    migrations()
複製程式碼
  • 執行命令 python migrations.py
  • migrate_v1函式新增欄位sex, 在BaseModel中要先新增name欄位
  • info裝飾器會建立表migrate_record來記錄migrate，version每個model中必須唯一，使用version來記錄是否執行過，還可以記錄author，datetime
  • migrate函式必須以**migrate_**開頭

相關連線

peewee

資料庫操作

asyncpg is the fastest driver among common Python, NodeJS and Go implementations

使用asyncpg為資料庫驅動, 對資料庫連線進行封裝, 執行資料庫操作。

不使用ORM做資料庫操作，一個原因是效能，ORM會有效能的損耗，並且無法使用asyncpg高效能庫。另一個是單個微服務是很簡單的，表結構不會很複雜，簡單的SQL語句就可以處理來，沒必要引入ORM。使用peewee只是做模型設計

Example:

sql = "SELECT * FROM users WHERE name=$1"
name = "test"
async with request.app.db.acquire(request) as cur:
    data = await cur.fetchrow(sql, name)

async with request.app.db.transaction(request) as cur:
    data = await cur.fetchrow(sql, name)
複製程式碼
  • acquire() 函式為非事務, 對於只涉及到查詢的使用非事務，可以提高查詢效率
  • tansaction() 函式為事務操作，對於增刪改必須使用事務操作
  • 傳入request引數是為了獲取到span，用於日誌追蹤
  • TODO 資料庫讀寫分離

相關連線

asyncpg benchmarks

客戶端

使用aiohttp中的client，對客戶端進行了簡單的封裝，用於微服務之間訪問。

Don’t create a session per request. Most likely you need a session per application which performs all requests altogether. A session contains a connection pool inside, connection reusage and keep-alives (both are on by default) may speed up total performance.

Example:

@app.listener('before_server_start')
async def before_srver_start(app, loop):
    app.client =  Client(loop, url='http://host:port')

async def get_role_by_id(request, id):
    cli = request.app.client.cli(request)
    async with cli.get('/cities/{}'.format(id)) as res:
        return await res.json()

@app.listener('before_server_stop')
async def before_server_stop(app, loop):
    app.client.close()

複製程式碼

對於訪問不同的微服務可以建立多個不同的client，這樣每個client都會keep-alives

相關連線

aiohttp

日誌 & 分散式追蹤系統

使用官方logging, 配置檔案為logging.yml, sanic版本要0.6.0及以上。JsonFormatter將日誌轉成json格式，用於輸入到ES

Enter OpenTracing: by offering consistent, expressive, vendor-neutral APIs for popular platforms, OpenTracing makes it easy for developers to add (or switch) tracing implementations with an O(1) configuration change. OpenTracing also offers a lingua franca for OSS instrumentation and platform-specific tracing helper libraries. Please refer to the Semantic Specification.

裝飾器logger

@logger(type='method', category='test', detail='detail', description="des", tracing=True, level=logging.INFO)
async def get_city_by_id(request, id):
    cli = request.app.client.cli(request)
複製程式碼
  • type: 日誌型別，如 method, route
  • category: 日誌類別，預設為app的name
  • detail: 日誌詳細資訊
  • description: 日誌描述，預設為函式的註釋
  • tracing: 日誌追蹤，預設為True
  • level: 日誌級別，預設為INFO

分散式追蹤系統

  • OpenTracing是以Dapper，Zipkin等分散式追蹤系統為依據, 建立了統一的標準。
  • Opentracing跟蹤每一個請求，記錄請求所經過的每一個微服務，以鏈條的方式串聯起來，對分析微服務的效能瓶頸至關重要。
  • 使用opentracing框架，但是在輸出時轉換成zipkin格式。 因為大多數分散式追蹤系統考慮到效能問題，都是使用的thrift進行通訊的，本著簡單，Restful風格的精神，沒有使用RPC通訊。以日誌的方式輸出, 可以使用fluentd, logstash等日誌收集再輸入到Zipkin。Zipkin是支援HTTP輸入的。
  • 生成的span先無阻塞的放入queue中，在task中消費佇列的span。後期可以新增上取樣頻率。
  • 對於DB，Client都加上了tracing

相關連線

opentracing zipkin jaeger

API介面

api文件使用swagger標準。

Example:

from sanic_ms import doc

@user_bp.post('/')
@doc.summary('create user')
@doc.description('create user info')
@doc.consumes(Users)
@doc.produces({'id': int})
async def create_user(request):
    data = request['data']
    async with request.app.db.transaction(request) as cur:
        record = await cur.fetchrow(
            """ INSERT INTO users(name, age, city_id, role_id)
                VALUES($1, $2, $3, $4, $5)
                RETURNING id
            """, data['name'], data['age'], data['city_id'], data['role_id']
        )
        return {'id': record['id']}
複製程式碼
  • summary: api概要
  • description: 詳細描述
  • consumes: request的body資料
  • produces: response的返回資料
  • tag: API標籤
  • 在consumes和produces中傳入的引數可以是peewee的model,會解析model生成API資料, 在field欄位的help_text引數來表示引用物件
  • http://host:ip/openapi/spec.json 獲取生成的json資料

相關連線

swagger

Response 資料

在返回時，不要返回sanic的response，直接返回原始資料，會在Middleware中對返回的資料進行處理，返回統一的格式，具體的格式可以[檢視]

單元測試

單元測試使用unittest。 mock是自己建立了MockClient，因為unittest還沒有asyncio的mock，並且sanic的測試介面也是傳送request請求，所以比較麻煩. 後期可以使用pytest。

Example:

from sanic_ms.tests import APITestCase
from server import app

class TestCase(APITestCase):
    _app = app
    _blueprint = 'visit'

    def setUp(self):
        super(TestCase, self).setUp()
        self._mock.get('/cities/1',
                       payload={'id': 1, 'name': 'shanghai'})
        self._mock.get('/roles/1',
                       payload={'id': 1, 'name': 'shanghai'})

    def test_create_user(self):
        data = {
            'name': 'test',
            'age': 2,
            'city_id': 1,
            'role_id': 1,
        }
        res = self.client.create_user(data=data)
        body = ujson.loads(res.text)
        self.assertEqual(res.status, 200)
複製程式碼
  • 其中_blueprint為blueprint名稱
  • 在setUp函式中，使用_mock來註冊mock資訊, 這樣就不會訪問真實的伺服器, payload為返回的body資訊
  • 使用client變數呼叫各個函式, data為body資訊，params為路徑的引數資訊，其他引數是route的引數

程式碼覆蓋

coverage erase
coverage run --source . -m sanic_ms tests
coverage xml -o reports/coverage.xml
coverage2clover -i reports/coverage.xml -o reports/clover.xml
coverage html -d reports
複製程式碼
  • coverage2colver 是將coverage.xml 轉換成 clover.xml，bamboo需要的格式是clover的。

相關連線

unittest coverage

異常處理

使用 app.error_handler = CustomHander() 對丟擲的異常進行處理

Example:

from sanic_ms.exception import ServerError

@visit_bp.delete('/users/<id:int>')
async def del_user(request, id):
    raise ServerError(error='內部錯誤',code=10500, message="msg")
複製程式碼
  • code: 錯誤碼，無異常時為0，其餘值都為異常
  • message: 狀態碼資訊
  • error: 自定義錯誤資訊
  • status_code: http狀態碼，使用標準的http狀態碼

相關文章