精华内容
下载资源
问答
  • Python微服务开发
    2021-03-06 04:30:20

    目 录

    第 1 章 理解微服务 1

    1.1 SOA的起源 2

    1.2 单体架构 2

    1.3 微服务架构 5

    1.4 微服务的益处 7

    1.4.1 分离团队的关注点 7

    1.4.2 更小的项目 8

    1.4.3 扩展和部署 8

    1.5 微服务的缺陷 9

    1.5.1 不合理的拆分 9

    1.5.2 更多的网络交互 9

    1.5.3 数据的存储和分享 10

    1.5.4 兼容性问题 10

    目 录

    第 1 章 理解微服务 1

    1.1 SOA的起源 2

    1.2 单体架构 2

    1.3 微服务架构 5

    1.4 微服务的益处 7

    1.4.1 分离团队的关注点 7

    1.4.2 更小的项目 8

    1.4.3 扩展和部署 8

    1.5 微服务的缺陷 9

    1.5.1 不合理的拆分 9

    1.5.2 更多的网络交互 9

    1.5.3 数据的存储和分享 10

    1.5.4 兼容性问题 10

    1.5.5 测试 10

    1.6 使用Python实现微服务 11

    1.6.1 WSGI标准 12

    1.6.2 greenlet和gevent模块 13

    1.6.3 Twisted和Tornado模块 15

    1.6.4 asyncio模块 16

    1.6.5 语言性能 18

    1.7 本章小结 20

    第 2 章 Flask框架 21

    2.1 选择Python版本 22

    2.2 Flask如何处理请求 23

    2.2.1 路由匹配 26

    2.2.2 请求 30

    2.2.3 响应 32

    2.3 Flask的内置特性 33

    2.3.1 Session对象 34

    2.3.2 全局值 34

    2.3.3 信号 35

    2.3.4 扩展和中间件 37

    2.3.5 模板 38

    2.3.6 配置 40

    2.3.7 Blueprint 42

    2.3.8 错误处理和调试 43

    2.4 微服务应用的骨架 47

    2.5 本章小结 49

    第 3 章 良性循环:编码、测试和写文档 51

    3.1 各种测试类型的差异 52

    3.1.1 单元测试 53

    3.1.2 功能测试 56

    3.1.3 集成测试 58

    3.1.4 负载测试 59

    3.1.5 端到端测试 61

    3.2 使用WebTest 62

    3.3 使用pytest和Tox 64

    3.4 开发者文档 67

    3.5 持续集成 71

    3.5.1 Travis-CI 72

    3.5.2 ReadTheDocs 73

    3.5.3 Coveralls 73

    3.6 本章小结 75

    第 4 章 设计Runnerly 77

    4.1 Runnerly应用 77

    4.2 单体设计 79

    4.2.1 模型 80

    4.2.2 视图与模板 80

    4.2.3 后台任务 84

    4.2.4 身份验证和授权 88

    4.2.5 单体设计汇总 92

    4.3 拆分单体 93

    4.4 数据服务 94

    4.5 使用Open API 2.0 95

    4.6 进一步拆分 97

    4.7 本章小结 98

    第 5 章 与其他服务交互 101

    5.1 同步调用 102

    5.1.1 在Flask应用中使用Session 103

    5.1.2 连接池 107

    5.1.3 HTTP缓存头 108

    5.1.4 改进数据传输 111

    5.1.5 同步总结 115

    5.2 异步调用 116

    5.2.1 任务队列 116

    5.2.2 主题队列 117

    5.2.3 发布/订阅模式 122

    5.2.4 AMQP上的RPC 122

    5.2.5 异步总结 122

    5.3 测试服务间交互 123

    5.3.1 模拟同步调用 123

    5.3.2 模拟异步调用 124

    5.4 本章小结 127

    第 6 章 监控服务 129

    6.1 集中化日志 129

    6.1.1 设置Graylog 131

    6.1.2 向Graylog发送日志 134

    6.1.3 添加扩展字段 136

    6.2 性能指标 137

    6.2.1 系统指标 138

    6.2.2 代码指标 140

    6.2.3 Web服务器指标 142

    6.3 本章小结 143

    第 7 章 保护服务 145

    7.1 OAuth2协议 146

    7.2 基于令牌的身份验证 147

    7.2.1 JWT标准 148

    7.2.2 PyJWT 150

    7.2.3 基于证书的X.509身份验证 151

    7.2.4 TokenDealer微服务 154

    7.2.5 使用TokenDealer 157

    7.3 Web应用防火墙 160

    7.4 保护代码 166

    7.4.1 断言传入的数据 166

    7.4.2 限制应用的范围 170

    7.4.3 使用Bandit linter 171

    7.5 本章小结 174

    第 8 章 综合运用 175

    8.1 构建ReactJS仪表盘 176

    8.1.1 JSX语法 176

    8.1.2 React组件 177

    8.2 ReactJS与Flask 181

    8.2.1 使用 bower、npm和babel 182

    8.2.2 跨域资源共享 185

    8.3 身份验证与授权 188

    8.3.1 与数据服务交互 188

    8.3.2 获取Strava令牌 189

    8.3.3 JavaScript身份验证 191

    8.4 本章小结 192

    第 9 章 打包和运行Runnerly 195

    9.1 打包工具链 196

    9.1.1 一些定义 196

    9.1.2 打包 197

    9.1.3 版本控制 204

    9.1.4 发布 206

    9.1.5 分发 208

    9.2 运行所有微服务 210

    9.3 进程管理 213

    9.4 本章小结 216

    第 10 章 容器化服务 217

    10.1 何为Docker? 218

    10.2 Docker简介 219

    10.3 在Docker中运行Flask 221

    10.4 完整的栈——OpenResty、Circus和Flask 223

    10.4.1 OpenResty 224

    10.4.2 Circus 226

    10.5 基于Docker的部署 228

    10.5.1 Docker Compose 230

    10.5.2 集群和初始化简介 231

    10.6 本章小结 233

    第 11 章 在AWS上部署 235

    11.1 AWS总览 236

    11.2 路由:Route53、ELB和AutoScaling 237

    11.3 执行:EC2和Lambda 237

    11.4 存储:EBS、S3、RDS、ElasticCache和CloudFront 238

    11.4.1 消息:SES、SQS和SNS 240

    11.4.2 初始化资源和部署:CloudFormation和ECS 241

    11.5 在AWS上部署简介 242

    11.5.1 创建AWS账号 242

    11.5.2 使用CoreOS在EC2上部署 244

    11.6 使用ECS 部署 247

    11.7 Route53 251

    11.8 本章小结 253

    第 12 章 接下来做什么? 255

    12.1 迭代器和生成器 256

    12.2 协同程序 259

    12.3 asyncio库 260

    12.4 aiohttp框架 262

    12.5 Sanic 262

    12.6 异步和同步 264

    12.7 本章小结 265

    更多相关内容
  • Python微服务开发.rar

    2020-07-26 15:12:13
    Python 微服务开发的范例程序 微服务是一种软件开发技术- 面向服务的体系结构(SOA)架构样式的一种变体,将应用程序构造为一组松散耦合的服务。在微服务体系结构中,服务是细粒度的,协议是轻量级的。
  • 微服务的起源微服务没有官方标准。当人们试图解释什么是微服务时经常会提到面向服务的体系结构(SOA Service-Oriented Architecture)。SOA predates microservices, and its core principle is the idea that you ...

    微服务的起源

    微服务没有官方标准。当人们试图解释什么是微服务时经常会提到面向服务的体系结构(SOA Service-Oriented Architecture)。

    SOA predates microservices, and its core principle is the idea that you organize applications into a discrete unit of functionality that can be accessed remotely and acted upon and updated independently.

    中文翻译:SOA早于微服务,其核心原则是将应用程序组织成独立的功能单元,可以远程访问并独立操作和更新。

    Wikipedia上述定义中的每个单元都是独立服务,它实现了业务的一个方面,并通过某个接口提供其功能。虽然SOA明确指出服务应该是独立的流程,但它并不强制应该使用哪些协议来使这些流程相互交互,并且对于如何部署和组织应用程序保持相当模糊。

    SOA服务可以通过进程间通信(IPC Inter-Process Communication)使用同一台机器上的套接字,共享内存,间接消息队列,甚至远程过程调用(RPC Remote ProcedureCalls)进行通信。

    通常微服务是SOA的专业版,如果我们想要给出什么是微服务的完整定义,那么最好的方法是首先看看大多数软件是如何构建的。

    集中式架构

    比如:酒店预订网站。

    除了静态HTML内容,该网站还有预订功能,可以让用户预订世界上任何城市的酒店。用户可以搜索酒店,然后使用信用卡预订。

    当用户在酒店网站上执行搜索时,该应用程序将执行以下步骤:

    它针对酒店的数据库运行了几个SQL查询。

    向合作伙伴的服务发出HTTP请求,以便在列表中添加更多酒店。

    使用HTML模板引擎生成HTML结果页面。

    一旦用户找到了完美的酒店并点击它进行预订,应用程序就会执行以下步骤:

    如果需要,客户将在数据库中创建,并且必须进行身份验证。

    通过与银行网络服务进行交互来执行付款。

    出于法律原因,该应用将付款详细信息保存在数据库中。

    使用PDF生成器生成收据。

    使用电子邮件服务向用户发送回顾电子邮件。

    使用电子邮件服务将预订电子邮件转发给第三方酒店。

    添加数据库条目以跟踪预订。

    这是简化但非常现实模型,应用程序与包含酒店信息,预订详细信息,账单,用户信息等的数据库进行交互。它还与外部服务交互,用于发送电子邮件,付款以及从合作伙伴处获取更多酒店。

    在旧的LAMP(Linux-Apache-MySQL-Perl / PHP / Python)体系结构中,每个传入的请求都会在数据库上生成一连串的SQL查询,并对外部服务进行一些网络调用,然后服务器生成HTML响应使用模板引擎。

    下图说明了这种集中式架构:

    0063d24828c8

    图片.png

    好处:

    整个应用程序都在一个代码库中,当项目编码开始时,它使一切变得更简单。构建良好的测试覆盖率非常简单,您可以在代码库中以干净,结构化的方式组织代码。将所有数据存储到单个数据库中也简化了应用程序的开发。您可以调整数据模型,以及代码如何查询方式。

    部署也毫不费力:我们可以标记代码库,打包,然后在某个地方运行它。为了扩展它,我们可以运行预订应用程序的多个实例,并运行一些具有一些复制机制的数据库。

    如果您的应用程序较小,此模型运行良好,并且易于单个团队维护。

    如果项目通常在增长,将整个应用程序放在一个代码库中会带来一些令人讨厌的问题。例如,如果您需要进行范围较大的彻底更改(例如更改银行服务或数据库层),整个应用程序将进入非常不稳定的状态。这些变化在项目的生命周期中是一个大问题,他们需要进行大量额外测试才能部署新版本。

    由于系统的不同部分具有不同的正常运行时间和稳定性要求,因此小的变化也会产生附带损害。由于创建PDF的功能导致服务器崩溃,因此将计费和预留流程置于风险中是一个问题。

    不受控制的增长是另一个问题。应用程序必然会获得新功能,并且开发人员离开并加入项目时,代码组织可能会开始变得混乱,测试速度会慢一些。这种增长通常最终会出现难以维护的意大利面条代码库,每次开发人员重构数据模型时都会需要复杂的迁移计划。

    大型软件项目通常需要几年时间才能成熟,然后它们慢慢开始变成难以理解的混乱,难以维护。项目的开发人员梦想着用最新的框架从头开始构建应用程序。通过这样做,他们通常会再次遇到同样的问题 - 重复同样的故事。

    将应用程序拆分为单独的部分,即使生成的代码仍将在单个进程中运行。开发人员通过使用外部库和框架构建应用程序来实现此目的。这些工具可以是内部工具,也可以来自开源软件(OSS Open Source Software)社区。

    如果使用像Flask这样的框架,用Python构建Web应用程序,可以让您专注于业务逻辑,并使得将一些代码外部化为Flask扩展和小型Python包非常有吸引力。将代码拆分为小包通常是控制应用程序增长的好主意。

    例如,酒店预订应用程序中的PDF生成器可以是一个单独的Python包,它使用Reportlab和一些模板来完成工作。有可能这个包可以在其他一些应用程序中重用,甚至可能发布到社区的Python包索引(Python Package Index PyPI)。

    但是你仍在构建一个单独的应用程序,并且仍然存在一些问题,例如无法以不同方式扩展,或者由错误依赖引入的其他问题。您甚至会遇到新的挑战,因为您现在正在使用依赖。如果你的应用程序的一部分使用了库,但是PDF生成器只能使用该库的特定版本。

    微服务实现

    微服务会将代码组织到几个单独的组件中,这些组件在不同的进程中运行。

    0063d24828c8

    图片.png

    组件列表

    预订UI:前端服务,它生成Web用户界面,并与所有其他微服务交互。

    PDF报告服务:非常简单的服务,可以为收据或给定模板和某些数据的任何其他文档创建PDF。

    搜索:可以查询的服务,以获取给定城市名称的酒店列表。该服务有自己的数据库。

    付款:与第三方银行服务交互并管理开票数据库的服务。它还会发送成功付款的电子邮件。

    预订:存储预订,并生成PDF。

    用户:存储用户信息,并通过电子邮件与用户交互。

    身份验证:基于OAuth 2的服务,返回身份验证令牌,每个微服务都可以在调用其他令牌时进行身份验证。

    每个组件使用HTTP协议进行通信,并通过RESTful Web服务提供接口

    没有集中式数据库,因为每个微服务在内部处理自己的数据结构,而进出的数据使用JSON等语言无关的格式。它可以使用XML或YAML,只要它可以由任何语言生成和使用,并通过HTTP请求和响应传播。

    Booking UI服务有点特别,因为它生成用户界面(UI)。根据用于构建UI的前端框架,如果界面使用基于JavaScript的静态客户端工具直接在浏览器中生成界面,则Booking UI输出可以是HTML和JSON的混合,甚至是简单的JSON。

    微服务是专注于特定任务,是轻量级的应用程序,它提供了缩小的功能列表,具有明确定义的合同。它是单一责任的组件,可以独立开发和部署。

    另外可以考虑将基于UDP的小型服务等作为微服务交换二进制数据。本书中,我们所有的微服务是使用HTTP协议的简单Web应用程序,并且当它不是UI时使用和生成JSON。

    微服务的好处

    更加专注

    小项目,更简单

    更多扩展和部署选项

    微服务的陷阱

    不合逻辑的分割

    过早分割是万恶之源。

    更多的网络消息

    数据存储和分片

    在保持微服务独立的同时尽可能避免数据重复是设计基于微服务的应用程序的最大挑战之一。

    兼容性问题

    测试

    展开全文
  • 介绍使用python做web开发面临的一个最大的问题就是性能,在解决C10K问题上显的有点吃力。有些异步框架Tornado、Twisted、Gevent 等就是为了解决性能问题。这些框架在性能上有些提升,但是也出现了各种古怪的问题难以...

    介绍

    使用python做web开发面临的一个最大的问题就是性能,在解决C10K问题上显的有点吃力。有些异步框架Tornado、Twisted、Gevent 等就是为了解决性能问题。这些框架在性能上有些提升,但是也出现了各种古怪的问题难以解决。

    在python3.6中,官方的异步协程库asyncio正式成为标准。在保留便捷性的同时对性能有了很大的提升,已经出现许多的异步框架使用asyncio。

    使用较早的异步框架是aiohttp,它提供了server端和client端,对asyncio做了很好的封装。但是开发方式和最流行的微框架flask不同,flask开发简单,轻量,高效。正是结合这些优点, 以Sanic为基础,集成多个流行的库来搭建微服务。 Sanic框架是和Flask相似的异步协程框架,简单轻量,并且性能很高。本项目就是以Sanic为基础搭建的python微服务框架。(思想适用于其他语言)

    微服务设计原则个人总结:

    20180417165910418

    X 轴 :指的是水平复制,很好理解,就是讲单体系统多运行几个实例,做个集群加负载均衡的模式。

    Z 轴 :是基于类似的数据分区,比如一个互联网打车应用突然或了,用户量激增,集群模式撑不住了,那就按照用户请求的地区进行数据分区,北京、上海、四川等多建几个集群。简单理解数据库拆分,比如分库分表

    Y 轴 :就是我们所说的微服务的拆分模式,就是基于不同的业务拆分。

    微服务总体架构:

    20180417170359792

    特点

    使用sanic异步框架,简单,轻量,高效。

    使用uvloop为核心引擎,使sanic在很多情况下单机并发甚至不亚于Golang。

    使用asyncpg为数据库驱动,进行数据库连接,执行sql语句执行。

    使用aiohttp为Client,对其他微服务进行访问。

    使用peewee为ORM,但是只是用来做模型设计和migration。

    使用opentracing为分布式追踪系统。

    使用unittest做单元测试,并且使用mock来避免访问其他微服务。

    使用swagger做API标准,能自动生成API文档。

    服务端

    使用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 defcros(request):

    if request.method == 'POST' or request.method == 'PUT':

    request['data'] = request.json

    span = before_request(request)

    request['span'] = span

    @app.middleware('response')

    async defcors_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 defasync_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('/')

    @doc.summary("get user info")

    @doc.description("get user info by id")

    @doc.produces(Users)

    async defget_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是并行处理。

    相关连接

    模型设计 & 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

    classUsers(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)

    classMeta:

    db_table = 'users'

    # migrations.py

    from sanic_ms.migrations import MigrationModel, info, db

    classUserMigration(MigrationModel):

    _model = Users

    # @info(version="v1")

    # def migrate_v1(self):

    # migrate(self.add_column('sex'))

    defmigrations():

    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_开头

    相关连接

    数据库操作

    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 数据库读写分离

    相关连接

    客户端

    使用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 defbefore_srver_start(app, loop):

    app.client = Client(loop, url='http://host:port')

    async defget_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 defbefore_server_stop(app, loop):

    app.client.close()

    对于访问不同的微服务可以创建多个不同的client,这样每个client都会keep-alives

    日志 & 分布式追踪系统

    装饰器logger

    @logger(type='method', category='test', detail='detail', description="des", tracing=True, level=logging.INFO)

    async defget_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

    相关连接

    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 defcreate_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数据

    相关连接

    Response 数据

    在返回时,不要返回sanic的response,直接返回原始数据,会在Middleware中对返回的数据进行处理,返回统一的格式,具体的格式可以[查看]

    单元测试

    单元测试使用unittest。 mock是自己创建了MockClient,因为unittest还没有asyncio的mock,并且sanic的测试接口也是发送request请求,所以比较麻烦. 后期可以使用pytest。

    Example:

    from sanic_ms.tests import APITestCase

    from server import app

    classTestCase(APITestCase):

    _app = app

    _blueprint = 'visit'

    defsetUp(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'})

    deftest_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的。

    相关连接

    异常处理

    使用 app.error_handler = CustomHander() 对抛出的异常进行处理

    Example:

    from sanic_ms.exception import ServerError

    @visit_bp.delete('/users/')

    async defdel_user(request, id):

    raise ServerError(error='内部错误',code=10500, message="msg")

    code: 错误码,无异常时为0,其余值都为异常

    message: 状态码信息

    error: 自定义错误信息

    status_code: http状态码,使用标准的http状态码

    展开全文
  • 给大家带来的一篇关于微服务相关的电子书...内容介绍Python微服务开发 资料配套源码应用Python小工具生态体系减少微服务多元性的好用方式Web运用常常布署到云主机,运用编码必须与众多第三方平台服务项目互动。从基...

    给大家带来的一篇关于微服务相关的电子书资源,介绍了关于Python、微服务方面的内容,本书是由清华大学出版社出版,格式为zip,资源大小117 KB,塔里克·齐亚德编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:9.9。

    内容介绍

    1-1ZZ40U429506.jpg

    Python微服务开发 资料配套源码

    应用Python小工具生态体系减少微服务多元性的好用方式

    Web运用常常布署到云主机,运用编码必须与众多第三方平台服务项目互动。从基础理论上讲,可应用分布式架构来高效率地搭建该类运用,但在具体中,充分考虑各一部分间的互动难度系数,搭建分布式架构并非易事。

    《Python微服务开发》将具体指导你选用*的、成熟期的搭建方法,绕开普遍圈套,摆脱难题,*终开发出好几个较小的标准单元,将其组成Web运用。这书紧靠好用,将具体指导你了解和应用TDD标准,应用Python 3以及非凡的小工具生态体系来搭建任何。根据学习培训这书,你将遵照*对策,应用Flask和Tox等小工具来搭建服务项目,保持服务项目中间的安全性联接,在nginx中撰写Lua脚本制作来搭建Web运用服务器防火墙作用(如速度限定),了解Docker在微服务中饰演的人物角色,合用Docker器皿和AWS来布署服务项目。

    *终,你将开发出1个应用场景微服务的详细Python运用,并熟练把握搭建、设计构思、检测和布署Python微服务的基本概念。

    ● 讨论微服务的含意和设计构思方法

    ● 有效应用Python 3、Flask和Tox等小工具来搭建服务项目

    ● 应用TDD方式

    ● 讨论撰写微服务文本文档的方法

    ● 配备和装包编码的*方法

    ● 与别的服务项目互动的方法及其有关挑戰

    ● 服务项目的安全系数,及其服务项目的监控器和拓展

    ● 用Docker器皿和AWS布署服务项目

    全书共12章,內容包含:了解微服务、应用flask、测试驱动开发与文本文档化、设计构思Forrest、与别的服务项目互动、维护服务项目安全性、应用微服务、装包Forrest、将服务项目Docker化、在AWS上布署、超前的逻辑思维等。

    目录

    第 1 章 理解微服务 1

    1.1 SOA的起源 2

    1.2 单体架构 2

    1.3 微服务架构 5

    1.4 微服务的益处 7

    1.4.1 分离团队的关注点 7

    1.4.2 更小的项目 8

    1.4.3 扩展和部署 8

    1.5 微服务的缺陷 9

    1.5.1 不合理的拆分 9

    1.5.2 更多的网络交互 9

    1.5.3 数据的存储和分享 10

    1.5.4 兼容性问题 10

    1.5.5 测试 10

    1.6 使用Python实现微服务 11

    1.6.1 WSGI标准 12

    1.6.2 greenlet和gevent模块 13

    1.6.3 Twisted和Tornado模块 15

    1.6.4 asyncio模块 16

    1.6.5 语言性能 18

    1.7 本章小结 20

    第 2 章 Flask框架 21

    2.1 选择Python版本 22

    2.2 Flask如何处理请求 23

    2.2.1 路由匹配 26

    2.2.2 请求 30

    2.2.3 响应 32

    2.3 Flask的内置特性 33

    2.3.1 Session对象 34

    2.3.2 全局值 34

    2.3.3 信号 35

    2.3.4 扩展和中间件 37

    2.3.5 模板 38

    2.3.6 配置 40

    2.3.7 Blueprint 42

    2.3.8 错误处理和调试 43

    2.4 微服务应用的骨架 47

    2.5 本章小结 49

    第 3 章 良性循环:编码、测试和写文档 51

    3.1 各种测试类型的差异 52

    3.1.1 单元测试 53

    3.1.2 功能测试 56

    3.1.3 集成测试 58

    3.1.4 负载测试 59

    3.1.5 端到端测试 61

    3.2 使用WebTest 62

    3.3 使用pytest和Tox 64

    3.4 开发者文档 67

    3.5 持续集成 71

    3.5.1 Travis-CI 72

    3.5.2 ReadTheDocs 73

    3.5.3 Coveralls 73

    3.6 本章小结 75

    第 4 章 设计Runnerly 77

    4.1 Runnerly应用 77

    4.2 单体设计 79

    4.2.1 模型 80

    4.2.2 视图与模板 80

    4.2.3 后台任务 84

    4.2.4 身份验证和授权 88

    4.2.5 单体设计汇总 92

    4.3 拆分单体 93

    4.4 数据服务 94

    4.5 使用Open API 2.0 95

    4.6 进一步拆分 97

    4.7 本章小结 98

    第 5 章 与其他服务交互 101

    5.1 同步调用 102

    5.1.1 在Flask应用中使用Session 103

    5.1.2 连接池 107

    5.1.3 HTTP缓存头 108

    5.1.4 改进数据传输 111

    5.1.5 同步总结 115

    5.2 异步调用 116

    5.2.1 任务队列 116

    5.2.2 主题队列 117

    5.2.3 发布/订阅模式 122

    5.2.4 AMQP上的RPC 122

    5.2.5 异步总结 122

    5.3 测试服务间交互 123

    5.3.1 模拟同步调用 123

    5.3.2 模拟异步调用 124

    5.4 本章小结 127

    第 6 章 监控服务 129

    6.1 集中化日志 129

    6.1.1 设置Graylog 131

    6.1.2 向Graylog发送日志 134

    6.1.3 添加扩展字段 136

    6.2 性能指标 137

    6.2.1 系统指标 138

    6.2.2 代码指标 140

    6.2.3 Web服务器指标 142

    6.3 本章小结 143

    第 7 章 保护服务 145

    7.1 OAuth2协议 146

    7.2 基于令牌的身份验证 147

    7.2.1 JWT标准 148

    7.2.2 PyJWT 150

    7.2.3 基于证书的X.509身份验证 151

    7.2.4 TokenDealer微服务 154

    7.2.5 使用TokenDealer 157

    7.3 Web应用防火墙 160

    7.4 保护代码 166

    7.4.1 断言传入的数据 166

    7.4.2 限制应用的范围 170

    7.4.3 使用Bandit linter 171

    7.5 本章小结 174

    第 8 章 综合运用 175

    8.1 构建ReactJS仪表盘 176

    8.1.1 JSX语法 176

    8.1.2 React组件 177

    8.2 ReactJS与Flask 181

    8.2.1 使用 bower、npm和babel 182

    8.2.2 跨域资源共享 185

    8.3 身份验证与授权 188

    8.3.1 与数据服务交互 188

    8.3.2 获取Strava令牌 189

    8.3.3 JavaScript身份验证 191

    8.4 本章小结 192

    第 9 章 打包和运行Runnerly 195

    9.1 打包工具链 196

    9.1.1 一些定义 196

    9.1.2 打包 197

    9.1.3 版本控制 204

    9.1.4 发布 206

    9.1.5 分发 208

    9.2 运行所有微服务 210

    9.3 进程管理 213

    9.4 本章小结 216

    第 10 章 容器化服务 217

    10.1 何为Docker? 218

    10.2 Docker简介 219

    10.3 在Docker中运行Flask 221

    10.4 完整的栈——OpenResty、Circus和Flask 223

    10.4.1 OpenResty 224

    10.4.2 Circus 226

    10.5 基于Docker的部署 228

    10.5.1 Docker Compose 230

    10.5.2 集群和初始化简介 231

    10.6 本章小结 233

    第 11 章 在AWS上部署 235

    11.1 AWS总览 236

    11.2 路由:Route53、ELB和AutoScaling 237

    11.3 执行:EC2和Lambda 237

    11.4 存储:EBS、S3、RDS、ElasticCache和CloudFront 238

    11.4.1 消息:SES、SQS和SNS 240

    11.4.2 初始化资源和部署:CloudFormation和ECS 241

    11.5 在AWS上部署简介 242

    11.5.1 创建AWS账号 242

    11.5.2 使用CoreOS在EC2上部署 244

    11.6 使用ECS 部署 247

    11.7 Route53 251

    11.8 本章小结 253

    第 12 章 接下来做什么? 255

    12.1 迭代器和生成器 256

    12.2 协同程序 259

    12.3 asyncio库 260

    12.4 aiohttp框架 262

    12.5 Sanic 262

    12.6 异步和同步 264

    12.7 本章小结 265

    学习笔记

    Python+Socket实现基于TCP协议的客户与服务端中文自动回复聊天功能示例

    本文实例讲述了Python+Socket实现基于TCP协议的客户与服务端中文自动回复聊天功能。分享给大家供大家参考,具体如下: 【吐槽】 网上的代码害死人,看着都写的言之凿凿,可运行就是有问题。 有些爱好代码、喜欢收藏代码的朋友,看到别人的代码就粘贴复制过来。可是起码你也试试运行看啊大哥 【正文】 昨日修改运行了UDP协议的C/S聊天程序,可是TCP协议的怎么都不行。各种试,各种坑。 做了下面几个修改后,终于可以了: 1、对发送、接收的信息,分别进行编码和解码 2、 客户端的第10行bind改为connect ( 这真是个大坑!! ) (本文基于windows 7 + python 3.4) 完整代码如下(人头担保,本人亲测正常……

    python使用socket创建tcp服务器和客户端

    python使用socket创建tcp服务器和客户端。 服务器端为一个时间戳服务器,在接收到客户端发来的数据后,自动回复。 客户端,等待用户输入,回车后向服务器发送用户输入的内容。 分别在python2.7和python3.6下测试。在启动时需要先启动服务器端,在启动客户端。 python2.7下 服务器端代码为 #coding:utf-8from socket import *from time import ctimeprint("=====================时间戳TCP服务器=====================");HOST = '' #主机号为空白表示可以使用任何可用的地址。PORT = 21567 #端口号BUFSIZ = 1024 #接收数据缓冲大小ADDR = (HOST, PORT)tcpSerSock = socket(AF_INET, SOCK_STREAM) #创建TCP服务器套接字tcpSerSock.bind(ADDR) #套接字与地址绑定tcpSerSock.listen(5) #监听……

    python 多线程对post请求服务器测试并发的方法

    如下所示: # -*- coding: utf-8 -*-import requestsimport threadingimport timeclass postrequests(): def __init__(self): self.url = '请求网址' self.files = { 'unknown_image':open('刘诗诗.jpg','rb')} def post(self): try: r = requests.post(self.url,files=self.files) print(r.text) except Exception as e: print(e)def login(): login = postrequests() return login.post()# if __name__ == '__main__':# login()try: i = 0 # 开启线程数目 tasks_number = 150 print('测试启动') time1 = time.clock() while i tasks_number: t = threading.Thread(target=login) t.start() i +=1 time2 = time.clock() times = time2 - time1 print(times/tasks_number)except Exception as e: print(e) 以上这篇python 多线程对post请求服务器测试并发的方法就是小编分享给大家的全部内容了,希望……

    Python实现向服务器请求压缩数据及解压缩数据的方法示例

    本文实例讲述了Python实现向服务器请求压缩数据及解压缩数据的方法。分享给大家供大家参考,具体如下: 向服务器请求压缩数据格式,并解压缩数据 #!/usr/bin/env python# encoding=utf-8import urllib2, httplibdef writeFile(fname, data): f = open(fname, "w") f.write(data) f.close()if __name__ == '__main__': httplib.HTTPConnection.debuglevel = 1 request = urllib2.Request('http://www.163.com/') request.add_header('Accept-encoding', 'gzip') # 向服务器请求压缩数据 opener = urllib2.build_opener() f = opener.open(request) data = f.read() # 读取页面返回的数据 f.close() print "压缩的数据长度为:%d" %len(data) writeFile("a.html", data) import StringIO, gzip compressedstream = StringIO.StringIO(data) gziper = gzip.GzipFile……

    以上就是本次介绍的微服务电子书的全部相关内容,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

    展开 +

    收起 -

    展开全文
  • 编辑推荐:本文来自于网络,文章详细介绍了API的优先方法以及如何用python建立一个简单的...除此之外,使用Connexion将使你在Python开发API变得更加流畅。Google在收购Apigee时强调了应用程式界面在当今应用程序架...
  • A micro-framework for the OMG, and code written in Python 3.6
  • Python构建、测试、部署和扩展微服务 本文为 Python Microservices Development 的选择性翻译,本书暂时无中文版,有能力请直接看原版 什么是微服务? A microservice is a lightweight application, which ...
  • Python 微服务方案

    2021-09-08 00:10:12
    介绍使用python做web开发面临的一个最大的问题就是性能,在解决C10K问题上显的有点吃力。有些异步框架Tornado、Twisted、Gevent 等就是为了解决性能问题。这些框架...
  • python中的微服务框架有Istio、Dubbo和nameko三种 1.Istio Istio是一个用来连接、管理和保护微服务的开放平台,使用Istio可以建立已部署服务网络,且Istio具备负载均衡、服务间认证、监控等功能。 2.Dubbo Dubbo...
  • without compromising any credentials问题的来源配置是软件开发中一个古...
  • Python 微服务开发

    2020-11-26 07:34:50
    开发团队在变革中改造和重建技术架构,企业管理者们切实感受到微服务带来的巨大好处。但不可否认,微服务架构带来了额外复杂性。对开发者提出了更高的要求,开发者不仅要编写业务代码,还需要具有部署和运维等...
  • python微服务案例代码 分为DJango框架及Flask框架 前端Vue 使用RabbitMQ进行服务治理-服务注册与发现
  • 前言在今天的文章中小码哥将会给大家分享一个目前工作中遇到的一个比较有趣的案例,就是如何将Python写的微服务融入到以Java技术栈为主的Spring Cloud微服务体系中?也许有朋友会有疑问,到底什么样的场景需要用...
  • Nameko 是一个 Python微服务框架,可以让你专注于应用逻辑
  • 使用Python做微服务的不多,限于团队主要都是Python开发,所以来聊一聊Python微服务。 一、微服务是什么? 一种软件开发技术- 面向服务的体系结构(SOA)架构样式的一种变体,将应用程序构造为一组松散耦合的服务。...
  • /etc/timezone &&\ apt-get install -y --no-install-recommends tzdata python3.6 python3-dev python3-tk \ python3-pip python3-setuptools ffmpeg openjdk-8-jdk-headless libsm6 libglib2.0-0 COPY ./...
  • 微服务架构(Python)

    千次阅读 2021-02-03 03:18:49
    在后端开发方面,Java的使用呢要远比Python广泛,所以Java的微服务框架非常流行,但Python微服务框架却很少有人问津。在大多数需要微服务的场合下直接用Java的各种工具就可以解决问题,但如果业务代码使用Python写...
  • Java微服务 vs Python微服务 PK 微服务能力 Python微服务生态 备注 后台框架/微服务框架 django/Nameko java有完整微服务框架方案 多环境配置 无 微服务注册发现 无 三方注册中心也比较成熟,可以对接...
  • 随着第三方框架的逐渐完善,实施微服务架构的开发成本越来越低,分布式架构成为主流势不可挡。一个完善的架构或系统中包含了许多的知识点,而每一个知识点则又可以引出非常多的内容,过度地专注于细节反而会拖慢达成...
  • △点击上方“Python猫”关注,回复“1”领取电子书Nameko即滑姑,学名:光帽鳞伞1. 前言大家好,我是猫哥!考虑到 Python 性能及效率性,Python Web 端一直不温不...
  • 通过阅读本书,开发人员能够实现微服务的快速落地。《微服务架构实战》共12章,分为概念篇、开发篇、运维篇和实战篇。概念篇详细阐述微服务的由来和设计要点。开发篇介绍Spring Boot、Docker和Spring Clou...
  • 微信号:zhangjun695339 目录 · · · · · · 前言 xiv 第1章 微服务 1 1.1 什么是微服务 2 1.1.1 很小,专注于做好一件事 2 1.1.2 自治性 3 1.2 主要好处 3 1.2.1 技术异构性 3 1.2.2 弹性...
  • 一:什么是微服务?  微服务是一种架构风格,一个大型复杂软件应用由一个或多个微服务组成。 系统中的各个微服务可被独立部署,各个微服务之间是松耦合的。 每个微服务仅关注于完成一件任务并很好地完成该任务。 ...
  • python 微服务方案

    万次阅读 多人点赞 2018-04-17 17:08:09
    介绍使用python做web开发面临的一个最大的问题就是性能,在解决C10K问题上显的有点吃力。有些异步框架Tornado、Twisted、Gevent 等就是为了解决性能问题。这些框架在性能上有些提升,但是也出现了各种古怪的问题难以...
  • Python Microservices Development By 作者: Tarek Ziadé ISBN-10 书号: 1785881116 ISBN-13 书号:: 9781785881114 Release 出版日期: 2017-10-05 pages 页数: (398 ) $44.99 Book Description Key Features A very...
  • Python微服务框架nameko的简单使用

    万次阅读 2019-10-24 14:27:59
    Java的微服务框架非常流行,但是Python微服务框架
  • python微服务

    2021-10-19 20:17:59
    特点 使用sanic异步框架,简单,轻量,高效。...使用aiohttp为Client,对其他微服务进行访问。 使用peewee为ORM,但是只是用来做模型设计和migration。 使用opentracing为分布式追踪系统。 使用unit

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,186
精华内容 12,074
关键字:

python微服务开发