罗罗编程学习记录
本页内容 展开查看

04.7.10 测试、调试、性能与部署

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python

覆盖范围

  • pytest:fixture、参数化、mock、异步测试
  • 测试分层、覆盖率、测试数据隔离
  • 性能分析:cProfile、py-spy、timeit
  • 日志、容器化、部署模型与容量
  • 压测、监控、灰度与回滚

04.7.10-001 pytest 的 fixture 是怎么工作的?作用域有哪些?

一句话结论

fixture 是“按需注入的测试资源”,测试函数把 fixture 名作为参数即可获得返回值;pytest 按依赖关系构建 fixture 图并缓存结果。作用域 function(默认)、class、module、package、session 决定复用范围与创建/销毁时机。

概念解释

  • @pytest.fixture(scope="session") 适合昂贵资源(数据库引擎、容器)。
  • fixture 可依赖其他 fixture,形成依赖链。

原理流程

  1. pytest 收集测试函数,解析其参数中的 fixture 名。
  2. 按依赖关系构建 fixture 图,同作用域内缓存结果。
  3. 测试结束后按作用域销毁 fixture。

代码或图示

import pytest

@pytest.fixture(scope="session")
def engine():
    return create_engine(TEST_URL)

@pytest.fixture
def session(engine):
    with Session(engine) as s:
        yield s

常见误区

  • autouse=True 自动应用(慎用,会隐藏依赖关系);conftest.py 中的 fixture 对其目录及子目录可见。
  • 作用域只能向内依赖:session 级 fixture 不能直接用 function 级,反向会报 ScopeMismatch;fixture 结果在同一作用域内缓存,不同作用域各自创建;fixture 相比 setup/teardown 可复用、可组合、可参数化,更灵活。

追问

  • 为什么 session 级 fixture 不能直接用 function 级?答:作用域只能向内依赖,反向会报 ScopeMismatch。
  • autouse 有什么风险?答:测试间隐式耦合,难以定位副作用。
  • fixture 和 setup/teardown 的区别?答:fixture 可复用、可组合、可参数化,更灵活。

04.7.10-002 用 yield 写 fixture 时清理逻辑怎么保证执行?

一句话结论

yield 之前的代码是 setup,yield 之后是 teardown;无论测试通过、失败还是报错,teardown 都会执行(除非进程崩溃)。清理代码要放在 yield 后,且不要吞异常。

概念解释

  • 多个 fixture 的 teardown 按“后进先出”顺序执行。
  • 资源清理要幂等,避免重复关闭。

原理流程

  1. yield 前代码完成资源准备。
  2. 测试函数执行。
  3. yield 后代码执行清理,setup 正序、teardown 逆序。

代码或图示

@pytest.fixture
def tx(session):
    session.begin()
    yield session
    session.rollback()

常见误区

  • teardown 抛异常会记为错误(error),可能掩盖测试失败;需要“测试失败时也回滚”的数据库事务,放在 yield 后 rollback()。
  • 进程被杀、段错误等极端情况下 teardown 不执行;异步 fixture 用 pytest-asyncio 的 async def + yield;teardown 里不建议断言,错误会与测试结果混淆。

追问

  • 为什么测试失败时 teardown 还可能不执行?答:进程被杀、段错误等极端情况。
  • 多个 yield fixture 的顺序?答:setup 正序,teardown 逆序。
  • teardown 里能断言吗?答:不建议,错误会与测试结果混淆。

04.7.10-003 mock.patch 应该打在哪个位置?

一句话结论

patch 的目标是“被测代码查找名字的地方”,不是定义的地方。若 module_a 里 from module_b import func,则要 patch module_a.func;若 import module_b 后调用 module_b.func(),则 patch module_b.func。

概念解释

  • patch("pkg.module.ClassName") 会替换该模块命名空间里的引用。
  • autospec=True 让 mock 校验调用签名,减少“假通过”。

原理流程

  1. 确定被测代码引用函数的命名空间位置。
  2. patch 替换该位置的引用。
  3. 测试结束后恢复原对象。

代码或图示

from myapp.service import send_mail   # 使用处

@patch("myapp.service.send_mail")
def test_notify(mock_send):
    notify()
    mock_send.assert_called_once()

常见误区

  • patch 定义处无效:使用处已持有原对象引用,改定义处不影响;忘记 stop() 会污染后续测试,优先用上下文管理器/装饰器。
  • MagicMock 支持魔术方法(__len__、上下文管理器),Mock 不支持;能用真实轻量实现(内存 DB、fake)时优先,mock 过度会失去测试价值;patch 内置对象(如 datetime)要 patch 使用处。

追问

  • 为什么 patch 定义处无效?答:使用处已持有原对象引用,改定义处不影响。
  • MagicMock 和 Mock 区别?答:前者支持魔术方法(__len__、上下文管理器)。
  • 什么时候不该 mock?答:能用真实轻量实现(内存 DB、fake)时优先,mock 过度会失去测试价值。

04.7.10-004 参数化测试怎么写?

一句话结论

用 @pytest.mark.parametrize("a,b,expected", [...]) 把多组输入跑成多个独立用例,失败时能定位到具体参数;多个 parametrize 装饰器会做笛卡尔积。

概念解释

  • 用 pytest.param(..., id="case-name") 给用例命名,报告更可读。
  • 参数数据可从文件/数据库加载,但要注意用例可复现。

原理流程

  1. parametrize 声明参数名与多组取值。
  2. 每组取值生成独立测试用例。
  3. 失败报告定位到具体参数与 id。

代码或图示

@pytest.mark.parametrize("raw,expected", [
    ("1", 1),
    ("-2", -2),
    pytest.param("x", None, id="invalid"),
])
def test_parse(raw, expected):
    assert parse(raw) == expected

常见误区

  • 只保留有代表性的等价类与边界,避免用例数爆炸;参数里的可变对象在同一次运行内共享,需用工厂函数生成。
  • 边界值、异常路径、空值要单独列,别只测正常路径;indirect=True 可把参数传给 fixture,而不是测试函数;fixture 参数化用 params= 或 indirect=True。

追问

  • 参数化会导致用例数爆炸怎么办?答:只保留有代表性的等价类与边界。
  • 参数里有可变对象会互相影响吗?答:会,同一次运行内共享,需用工厂函数生成。
  • 参数化和 fixture 怎么配合?答:fixture 参数化(params=)或 indirect=True。

04.7.10-005 覆盖率 100% 就代表测试充分吗?

一句话结论

不代表。覆盖率只说明“代码被执行过”,不说明断言有效、分支组合完整、边界与异常路径正确。高覆盖率 + 弱断言是“假安全”。应关注分支覆盖、关键路径覆盖与变异测试。

概念解释

  • 行覆盖 vs 分支覆盖:if 只走一个分支也可能 100% 行覆盖。
  • 覆盖率作为趋势指标,不设为硬门槛的唯一标准。

原理流程

  1. 测试运行时记录被执行的行/分支。
  2. 覆盖率统计执行比例,但不校验断言是否成立。
  3. 结合分支覆盖、关键路径与变异测试判断有效性。

代码或图示

pytest --cov=app --cov-branch --cov-report=term-missing

常见误区

  • 断言缺失时覆盖率照样很高,但测不出 bug;排除 __repr__、迁移脚本、类型检查块等无意义代码。
  • 覆盖率虚高来自只调用不校验、mock 掉真实逻辑;变异测试(mutmut)能验证断言是否真的有效;核心业务 80%+,工具与边界代码可低,重点看关键路径;提升测试有效性靠断言业务结果、覆盖异常与边界、定期变异测试。

追问

  • 覆盖率的合理目标是多少?答:核心业务 80%+,工具与边界代码可低,重点看关键路径。
  • 为什么覆盖率会虚高?答:只调用不校验、mock 掉真实逻辑。
  • 如何提升测试有效性?答:断言业务结果、覆盖异常与边界、定期变异测试。

04.7.10-006 测试应该怎么分层?

一句话结论

测试金字塔:大量单元测试(快、隔离、覆盖逻辑)、适量集成测试(DB/缓存/HTTP 真实链路)、少量端到端测试(关键用户旅程)。反模式是“冰淇淋筒”:大量 E2E 慢且脆。

概念解释

  • 单元测试不碰网络/DB,用 fake/mock,毫秒级。
  • E2E 只覆盖支付、登录、下单等关键路径。

原理流程

  1. 单元层隔离外部依赖,验证业务逻辑。
  2. 集成层验证真实组件协作。
  3. E2E 层验证关键用户旅程。

代码或图示

unit(70%) → integration(20%) → e2e(10%)

常见误区

  • 集成测试验证 SQL、序列化、事务、中间件等真实协作;分层配合 CI 阶段:提交跑单测,合并跑集成,发布前跑 E2E。
  • E2E 容易 flaky:依赖真实网络、时序、数据状态;集成测试优先 Testcontainers/临时库,保证环境一致;单测覆盖关键逻辑与边界,不为覆盖率写无意义断言;每层都要能稳定复现,避免 flaky。

追问

  • 为什么 E2E 容易 flaky?答:依赖真实网络、时序、数据状态。
  • 集成测试用真 DB 还是容器?答:优先 Testcontainers/临时库,保证环境一致。
  • 单测需要覆盖所有分支吗?答:覆盖关键逻辑与边界,不为覆盖率写无意义断言。

04.7.10-007 数据库相关测试怎么隔离?

一句话结论

三种常用方案:事务回滚(每个用例包在事务里,结束 rollback,最快)、临时库/每次重建(隔离彻底但慢)、容器化数据库(Testcontainers,环境一致)。关键是“用例之间不共享可变状态”。

概念解释

  • 事务回滚要求被测代码不自行 commit,否则回滚失效。
  • 测试数据用工厂(factory_boy)生成,避免手写 SQL 依赖顺序。

原理流程

  1. 每个用例建立独立连接/事务。
  2. 用例执行后回滚或重建数据。
  3. 并行测试使用独立库/schema,互不干扰。

代码或图示

@pytest.fixture
def db_session(engine):
    conn = engine.connect()
    tx = conn.begin()
    s = Session(bind=conn)
    yield s
    s.close(); tx.rollback(); conn.close()

常见误区

  • 事务回滚方案有时失效:代码内部 commit 会提交外层事务(需 nested/savepoint);fixture 建立 schema(迁移或 metadata.create_all),session 级复用。
  • 时间、随机数、外部 ID 要可注入,保证可复现;rollback 快且干净,truncate 适合跨连接场景;并行测试用 pytest-xdist + 每 worker 独立库/schema。

追问

  • 为什么事务回滚方案有时失效?答:代码内部 commit 会提交外层事务(需 nested/savepoint)。
  • 测试数据清理用 truncate 还是 rollback?答:rollback 快且干净,truncate 适合跨连接场景。
  • 并行测试怎么做?答:pytest-xdist + 每 worker 独立库/schema。

04.7.10-008 异步代码怎么测试?

一句话结论

用 pytest-asyncio(@pytest.mark.asyncio 或 asyncio_mode=auto)让测试函数变成协程;异步 fixture 用 async def + yield;避免在测试里调用 asyncio.run(会与 pytest 的循环冲突)。

概念解释

  • 事件循环作用域要与 fixture 作用域匹配,避免跨循环使用对象。
  • 异步 HTTP 客户端用 httpx.AsyncClient + ASGITransport 直连应用。

原理流程

  1. 测试函数声明为协程,由 pytest-asyncio 调度。
  2. 异步 fixture 完成准备与清理。
  3. 断言协程返回值与异常路径。

代码或图示

import pytest

@pytest.mark.asyncio
async def test_handler():
    assert await handler() == 1

常见误区

  • 不能在测试里 asyncio.run:pytest 已有运行中的循环,会嵌套报错;测试中可 await asyncio.sleep(0) 让任务推进,但不要依赖时序。
  • 取消与超时路径要专门测(CancelledError、TimeoutError);测试结束后确保没有遗留任务(否则会有警告);异步测试慢时并行 + 减少真实 sleep,用可控的 fake 时钟;测超时用 pytest.raises(asyncio.TimeoutError) 包 wait_for。

追问

  • 为什么不能在测试里 asyncio.run?答:pytest 已有运行中的循环,会嵌套报错。
  • 如何测超时?答:pytest.raises(asyncio.TimeoutError) 包 wait_for。
  • 异步测试慢怎么办?答:并行 + 减少真实 sleep,用可控的 fake 时钟。

04.7.10-009 如何设计可维护的测试数据?

一句话结论

用工厂(factory_boy、自写 builder)生成对象,字段有合理默认值,用例只覆盖关心的字段;数据要可复现(固定随机种子、固定时间),避免测试之间依赖创建顺序。

概念解释

  • 工厂支持序列(Factory)、关联(SubFactory)、批量创建。
  • 敏感/唯一字段用序列或 uuid,避免唯一约束冲突。

原理流程

  1. 工厂定义业务合法的默认字段。
  2. 用例按需覆盖关心字段。
  3. 唯一字段由序列/uuid 生成,保证可复现。

代码或图示

class UserFactory(factory.Factory):
    class Meta: model = User
    name = factory.Sequence(lambda n: f"u{n}")

常见误区

  • 默认值要“业务合法”,避免每个用例都补一堆字段;时间相关用 freezegun 冻结,随机用固定 seed。
  • 不要在 fixture 里写大段重复构造:维护成本高,字段变更要改多处;测试数据不要从生产导出的真实数据直接使用(隐私与体积);工厂造数据,fixture 管资源与生命周期;测试数据量取覆盖边界的最小集合,性能问题另做基准测试。

追问

  • 为什么不要在 fixture 里写大段重复构造?答:维护成本高,字段变更要改多处。
  • 工厂和 fixture 怎么分工?答:工厂造数据,fixture 管资源与生命周期。
  • 测试数据量要多大?答:覆盖边界的最小集合,性能问题另做基准测试。

04.7.10-010 怎么用 cProfile 定位性能瓶颈?

一句话结论

cProfile 按函数统计调用次数与累计/自身耗时,pstats 排序查看 cumtime(累计)与 tottime(自身)。它适合“函数级”定位,但有固定开销,且对 IO 等待不敏感。

概念解释

  • 代码内 cProfile.run(...) 或 Profile().enable/disable() 精确控制范围。
  • 生产环境用 py-spy 采样,避免 cProfile 的侵入与失真。

原理流程

  1. Profile 插桩记录每个函数调用次数与耗时。
  2. cumtime 含子调用,tottime 只含本函数。
  3. 按耗时排序向下钻取热点函数。

代码或图示

import cProfile, pstats
pr = cProfile.Profile()
pr.enable()
main()
pr.disable()
pstats.Stats(pr).sort_stats("cumtime").print_stats(20)

常见误区

  • cumtime 高但 tottime 低说明耗时在子调用里,继续向下钻;大量小函数调用开销会被放大,需结合采样工具验证。
  • cProfile 结果和实际差很多:插桩开销、IO 等待、多线程统计不清;递归函数累计时间被重复计入,看调用次数与自身时间;python -m cProfile -s cumtime script.py 可直接输出排序结果。

追问

  • cumtime 和 tottime 有什么区别?答:前者含子调用,后者只含本函数。
  • 为什么 cProfile 结果和实际差很多?答:插桩开销、IO 等待、多线程统计不清。
  • 递归函数怎么读?答:注意累计时间被重复计入,看调用次数与自身时间。

04.7.10-011 py-spy 适合什么场景?

一句话结论

py-spy 是采样型 profiler,无需改代码、可在生产使用、开销低,能生成火焰图、实时 top、dump 线程栈。适合定位“CPU 热点、卡死、线程阻塞”,但不提供精确调用计数。

概念解释

  • py-spy top --pid 实时看热点函数;py-spy dump --pid 抓当前所有线程栈,排查死锁与卡死。
  • 采样频率可调,生产用低频率减小开销。

原理流程

  1. 按固定频率采样进程线程栈。
  2. 统计栈帧出现频率,生成 top/火焰图。
  3. dump 快照查看当前阻塞位置。

代码或图示

py-spy record -o flame.svg --pid 1234 --duration 30

常见误区

  • 采样型 profiler 会漏掉短函数:极短调用可能采不到,需多次采样或结合 cProfile;火焰图宽度表示占比,越宽越耗 CPU,自下而上表示调用栈。
  • 容器里需要 ptrace 权限(SYS_PTRACE),受限环境可能不行;支持 native 栈(需符号),能看 C 扩展耗时。

追问

  • 采样型 profiler 会漏掉短函数吗?答:会,极短调用可能采不到,需多次采样或结合 cProfile。
  • 火焰图怎么读?答:宽度表示占比,越宽越耗 CPU;自下而上表示调用栈。
  • 容器里能用吗?答:需要 ptrace 权限(SYS_PTRACE),受限环境可能不行。

04.7.10-012 timeit 测基准要注意什么?

一句话结论

timeit 通过多次重复取最小值/平均值降低噪声,适合比较小段代码。注意:关闭 GC 影响、避免把 setup 算进计时、预热、使用相同输入、结果要用统计(多次运行)而非单次。

概念解释

  • timeit.repeat 多次运行取 min,比单次更稳。
  • 用 perf_counter 手动计时也可,但要注意计时范围。

原理流程

  1. 多次重复执行被测片段。
  2. 记录每次耗时,取最小值/统计分布。
  3. 同环境同输入对比两个实现。

代码或图示

import timeit
t = min(timeit.repeat("'-'.join(str(i) for i in range(100))", number=1000, repeat=5))

常见误区

  • 循环里创建对象的开销要明确是否计入;解释器优化(常量折叠、内联缓存)会让微小差异不可靠。
  • 基准测试应固定 CPU 频率/负载,避免容器抖动;取最小值更接近“无干扰”的真实性能;微基准不能代表生产,需结合真实数据量与 IO 场景;对比两个实现要同环境、同输入、多轮交替运行,看分布而非单点。

追问

  • 为什么取最小值而不是平均?答:最小值更接近“无干扰”的真实性能。
  • 微基准能代表生产吗?答:不能,需结合真实数据量与 IO 场景。
  • 怎么对比两个实现?答:同环境、同输入、多轮交替运行,看分布而非单点。

04.7.10-013 Python 性能优化的一般顺序是什么?

一句话结论

先量化再优化:算法/数据结构 → 减少 IO 与网络往返 → 批量与缓存 → 减少 Python 层循环(内建/C 扩展/向量化)→ 并发模型(异步/多进程)→ 最后才是微优化(局部变量、__slots__)。

概念解释

  • 算法降复杂度收益最大(O(n²) → O(n log n))。
  • 避免过早优化,先用 profiler 找热点。

原理流程

  1. profiler 定位热点层级。
  2. 按收益从大到小依次优化算法、IO、缓存、向量化、并发。
  3. 最后处理局部微优化。

代码或图示

算法 → IO → 缓存 → 向量化 → 并发 → 微优化

常见误区

  • 微优化通常收益最小:解释器开销占比有限,热点往往在 IO 与算法;IO 优化靠批量、连接复用、并发、压缩、分页。
  • 缓存靠本地 LRU、Redis、HTTP 缓存;向量化用 NumPy/Pandas 替代 Python 循环;并发 IO 用异步/线程,CPU 用多进程;Python 层循环是瓶颈且逻辑稳定时再上 C 扩展;优化后用基准测试 + 生产指标对比,避免“感觉快了”。

追问

  • 为什么微优化通常收益最小?答:解释器开销占比有限,热点往往在 IO 与算法。
  • 什么时候该上 C 扩展?答:Python 层循环是瓶颈且逻辑稳定时。
  • 优化后怎么验证?答:基准测试 + 生产指标对比,避免“感觉快了”。

04.7.10-014 慢查询怎么定位和优化?

一句话结论

先开慢查询日志/APM 找到具体 SQL 与耗时分布,再看执行计划(EXPLAIN):是否走索引、是否全表扫描、是否临时表/文件排序、扫描行数是否异常。优化手段:加合适索引、改写查询、减少回表、分页、缓存。

概念解释

  • ORM 要打印实际 SQL(echo=True、django-debug-toolbar)。
  • 聚合与排序尽量走索引,减少临时表。

原理流程

  1. 慢日志/APM 定位耗时 SQL。
  2. EXPLAIN 分析访问类型、索引命中、扫描行数。
  3. 针对性加索引、改写查询或缓存。

代码或图示

EXPLAIN ANALYZE SELECT id, name FROM users WHERE city = 'x' ORDER BY created_at DESC LIMIT 20;

常见误区

  • 索引要匹配查询条件顺序(最左前缀),避免函数包裹列;避免 SELECT *,只取需要字段。
  • 大偏移分页用 cursor/延迟关联;索引未命中(类型/函数/最左前缀)、回表多、数据量大都会导致加索引仍慢;N+1 看查询次数,慢查询看单条耗时分布;索引不是越多越好,写入放大与存储成本上升。

追问

  • 为什么加了索引还是慢?答:索引未命中(类型/函数/最左前缀)、回表多、数据量大。
  • N+1 和慢查询怎么区分?答:看查询次数与单条耗时分布。
  • 索引越多越好吗?答:不是,写入放大与存储成本上升。

04.7.10-015 结构化日志应该包含什么?

一句话结论

至少包含时间戳、级别、logger 名、消息、请求 ID/追踪 ID、用户/租户标识、耗时、结果状态;关键业务事件带业务 ID(订单号、任务 ID)。字段名统一、可被 JSON 解析,便于检索与聚合。

概念解释

  • 请求 ID 通过上下文变量(contextvars)贯穿全链路。
  • 日志级别语义要稳定:ERROR 需可行动,WARN 需关注,INFO 记录业务事实。

原理流程

  1. 日志事件收集统一字段。
  2. JSON formatter 序列化输出。
  3. 采集端按字段检索与聚合。

代码或图示

logger.info("order_paid", extra={"order_id": oid, "amount": amt, "cost_ms": cost})

常见误区

  • 不用字符串拼接日志:无法结构化检索,字段提取靠正则;敏感字段(手机号、token)脱敏后再输出。
  • 同一事件只打一条,避免重复日志放大成本;日志量太大时采样、分级、异步写入、只记录关键事件;追踪 ID 通过 HTTP header(traceparent)+ 日志上下文注入跨服务传递。

追问

  • 为什么不用字符串拼接日志?答:无法结构化检索,字段提取靠正则。
  • 日志量太大怎么办?答:采样、分级、异步写入、只记录关键事件。
  • 追踪 ID 怎么跨服务传递?答:HTTP header(traceparent)+ 日志上下文注入。

04.7.10-016 日志会不会成为性能瓶颈?

一句话结论

会。同步 handler 在请求线程/事件循环里做 IO 与格式化,高 QPS 下会显著增加延迟;大量日志还会撑爆磁盘与采集链路。解决:异步/队列日志、按级别与采样控制、避免热路径打大对象、集中采集。

概念解释

  • QueueHandler + QueueListener 把 IO 移出业务线程。
  • 容器 stdout 日志由采集器统一处理,避免应用内文件轮转。

原理流程

  1. 业务线程只把日志放入队列。
  2. 监听线程异步格式化与写盘/网络。
  3. 队列满时按策略丢弃或阻塞。

代码或图示

queue = queue.Queue(-1)
handler = QueueHandler(queue)
logger.addHandler(handler)
listener = QueueListener(queue, StreamHandler())
listener.start()

常见误区

  • 每条日志的 repr/JSON 序列化都是 CPU 成本;异常日志带完整 traceback,量大时开销明显;生产默认 INFO,调试用动态开关而非常开 DEBUG。
  • 异步日志队列满时按策略丢弃或阻塞,需明确取舍;不要在循环里打日志,改为聚合统计;指标看趋势与告警,日志看单次事件细节。

追问

  • 异步日志会丢吗?答:队列满时按策略丢弃或阻塞,需明确取舍。
  • 为什么不要在循环里打日志?答:放大 IO 与格式化成本,改为聚合统计。
  • 日志和指标怎么分工?答:指标看趋势与告警,日志看单次事件细节。

04.7.10-017 Python 应用的 Dockerfile 怎么写比较好?

一句话结论

用多阶段构建、固定基础镜像(python:3.12-slim)、先复制依赖清单再安装(利用层缓存)、非 root 运行、PYTHONUNBUFFERED=1、PYTHONDONTWRITEBYTECODE=1、只复制必要文件、设置 HEALTHCHECK,最后用 exec 形式启动。

概念解释

  • 依赖安装与源码复制分层,源码变更不重装依赖。
  • 固定镜像 digest 而非 latest,保证可复现。

原理流程

  1. builder 阶段安装编译依赖与 wheel。
  2. 运行阶段只复制 wheel 与必要源码。
  3. 非 root 用户启动应用。

代码或图示

FROM python:3.12-slim AS base
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
USER 10001
CMD ["gunicorn", "app:app", "-c", "gunicorn.conf.py"]

常见误区

  • 编译依赖放 builder 阶段,运行阶段只留 wheel 与运行时库;.dockerignore 排除 .git、测试、缓存、虚拟环境。
  • 非 root 用户降权,减少容器逃逸风险;--no-cache-dir 减小镜像体积,避免残留 pip 缓存;多阶段构建让编译工具链不进最终镜像;exec 形式 CMD 让应用成为 PID 1,能正确接收信号做优雅停机。

追问

  • 为什么要 --no-cache-dir?答:减小镜像体积,避免残留 pip 缓存。
  • 多阶段构建解决什么?答:编译工具链不进最终镜像,体积与攻击面都下降。
  • 为什么用 exec 形式 CMD?答:让应用成为 PID 1,能正确接收信号做优雅停机。

04.7.10-018 如何给 Python 镜像瘦身?

一句话结论

换 slim/alpine(注意 musl 兼容性)、多阶段构建、清理构建缓存与编译产物、只装运行依赖(--no-deps 配合 wheel)、移除测试与文档、合并层、用 .dockerignore 排除无关文件。

概念解释

  • Alpine 的 musl 会导致部分 wheel 不可用,需源码编译,反而变大。
  • 定期扫描镜像漏洞与体积变化。

原理流程

  1. builder 阶段预编译 wheel。
  2. 运行阶段只安装 wheel 并清理缓存。
  3. 排除无关文件与测试数据。

代码或图示

FROM python:3.12-slim AS builder
RUN pip wheel --no-cache-dir -r requirements.txt -w /wheels

FROM python:3.12-slim
COPY --from=builder /wheels /wheels
RUN pip install --no-cache-dir --no-index --find-links=/wheels -r requirements.txt && rm -rf /wheels

常见误区

  • pip install --no-cache-dir 与 rm -rf /root/.cache 都要做;不要把 .venv、.git、测试数据、notebook 打进镜像。
  • 依赖按需拆分(web/worker 镜像可不同);Alpine 基础镜像小,但编译依赖可能让最终镜像更大;纯 Web 服务通常 100~300MB;瘦身会影响调试,需保留必要诊断工具或另建 debug 镜像。

追问

  • Alpine 一定更小吗?答:基础镜像小,但编译依赖可能让最终镜像更大。
  • 镜像多大算合理?答:视运行时依赖而定,纯 Web 服务通常 100~300MB。
  • 瘦身会影响调试吗?答:会,需保留必要诊断工具或另建 debug 镜像。

04.7.10-019 gunicorn / uvicorn 的关键参数有哪些?

一句话结论

workers 决定并行进程数;worker_class 选同步/线程/异步;timeout 控制单请求超时(同步 worker 超时会杀进程);graceful_timeout 控制优雅停机;max_requests + jitter 防内存缓慢增长;keepalive 控制长连接复用。

概念解释

  • 同步 worker 被慢请求阻塞,需靠多 worker + 超时。
  • 启动参数通过配置文件/环境变量管理,避免命令行散落。

原理流程

  1. master 拉起指定数量 worker 进程。
  2. worker 按 class 处理请求,超时与最大请求数触发重启。
  3. 停机时按 graceful_timeout 排空在途请求。

代码或图示

gunicorn app:app -w 4 -k gthread --threads 8 --timeout 30 --graceful-timeout 20 \
  --max-requests 1000 --max-requests-jitter 100

常见误区

  • gthread 用线程池提升 IO 并发,但受 GIL 限制;uvicorn 的 --workers 是多进程,每进程一个事件循环;--proxy-headers 让应用信任反向代理的 X-Forwarded-*。
  • max_requests 定期重启 worker,缓解内存泄漏与碎片;timeout 太短会误杀正常慢请求,客户端收到 502/504;graceful_timeout 要小于编排平台的终止宽限期,否则会被强杀,丢失在途请求。

追问

  • max_requests 有什么用?答:定期重启 worker,缓解内存泄漏与碎片。
  • timeout 设太短会怎样?答:正常慢请求被误杀,客户端收到 502/504。
  • 为什么 graceful_timeout 要小于编排平台的终止宽限期?答:否则会被强杀,丢失在途请求。

04.7.10-020 健康检查和就绪探针有什么区别?

一句话结论

liveness(存活)判断“进程是否卡死”,失败会重启容器;readiness(就绪)判断“能否接流量”,失败会摘除端点但不重启。启动慢的服务还需要 startup 探针,避免被误杀。

概念解释

  • 健康检查要轻量,不能查数据库/下游(下游故障会引发雪崩式重启)。
  • /healthz 返回 200 即存活;/readyz 检查关键依赖。

原理流程

  1. liveness 探针周期探测进程自身是否可响应。
  2. readiness 探针探测依赖与流量接收能力。
  3. 失败时分别触发重启或摘流。

代码或图示

@app.get("/healthz")
def healthz():
    return {"ok": True}

@app.get("/readyz")
def readyz():
    return {"db": check_db(timeout=0.5)}

常见误区

  • liveness 不能查 DB:数据库抖动会导致所有实例被重启,放大故障;readiness 可检查依赖可用性,但要有超时与缓存。
  • 探针频率与超时要与启动时间匹配;停机时先把 readiness 置为失败,等待摘流量后再退出;探针超时小于平台默认,且大于正常响应时间 2~3 倍。

追问

  • 为什么 liveness 不能查 DB?答:数据库抖动会导致所有实例被重启,放大故障。
  • 探针超时设置多少?答:小于平台默认,且大于正常响应时间 2~3 倍。
  • 停机时探针怎么配合?答:先失败 readiness,等 terminationGracePeriod 内的流量排空。

04.7.10-021 优雅停机在容器里怎么落地?

一句话结论

Pod 终止时:先把 readiness 置失败 → 等待端点摘除(几秒)→ 停止接收新连接 → 等待在途请求完成(graceful timeout)→ 关闭线程池/队列/连接 → 退出。应用要正确处理 SIGTERM,不能被 SIGKILL 直接杀掉。

概念解释

  • K8s 的 terminationGracePeriodSeconds 要覆盖“摘流量 + 排空”总时长。
  • PID 1 必须能转发信号(exec 形式启动)。

原理流程

  1. 收到 SIGTERM,readiness 置失败。
  2. 等待负载均衡摘除端点。
  3. 排空在途请求后关闭资源并退出。

代码或图示

lifecycle:
  preStop:
    exec:
      command: ["sh", "-c", "sleep 5"]
terminationGracePeriodSeconds: 40

常见误区

  • preStop sleep 用于等待端点摘除:端点摘除是异步的,立即退出会有请求打到已死实例;gunicorn 收到 SIGTERM 会优雅退出(graceful_timeout)。
  • 异步任务要 cancel() 并等待收尾,队列消费者要停止拉取并完成在途消息、提交 offset;停机期间 readiness 失败后负载均衡不再转发;消息消费者优雅停:停止拉取、处理完在途、提交 offset 后退出。

追问

  • 为什么需要 preStop sleep?答:端点摘除是异步的,立即退出会有请求打到已死实例。
  • 停机期间新请求怎么办?答:readiness 失败后负载均衡不再转发。
  • 消息消费者怎么优雅停?答:停止拉取、处理完在途、提交 offset 后退出。

04.7.10-022 CI/CD 流水线应该包含哪些阶段?

一句话结论

典型阶段:依赖安装与缓存 → 静态检查(ruff/mypy)→ 单元测试 → 集成测试 → 构建镜像 → 镜像扫描 → 推送制品 → 部署到预发 → 冒烟测试 → 灰度/全量发布 → 回滚预案。

概念解释

  • 每阶段失败即阻断,快速反馈(先跑快的检查)。
  • 发布记录版本、镜像 digest、配置变更,便于回滚。

原理流程

  1. 提交后先跑静态检查与单测(快反馈)。
  2. 通过后构建镜像、扫描、推送制品。
  3. 预发冒烟后灰度发布,保留回滚预案。

代码或图示

stages: [lint, test, build, scan, deploy]

常见误区

  • 依赖与构建缓存加速,但锁文件必须固定;测试与构建使用同一镜像/环境,保证一致性。
  • 数据库迁移作为独立 Job,先于应用发布并保证向前兼容;迁移先于应用发布:新代码会读新字段,迁移需向前兼容旧代码;同一镜像 digest 逐环境晋级,避免“构建一次、多环境不一致”;代码可回滚,数据库迁移不一定,需可逆设计。

追问

  • 为什么迁移要先于应用发布?答:新代码会读新字段;迁移需向前兼容旧代码。
  • 如何避免“构建一次、多环境不一致”?答:同一镜像 digest 逐环境晋级。
  • 回滚要考虑什么?答:代码可回滚,数据库迁移不一定,需可逆设计。

04.7.10-023 怎么用 locust 做压测?

一句话结论

定义用户行为(@task)与并发用户模型(--users、--spawn-rate),逐步加压观察吞吐与延迟曲线,找到拐点;用 --headless 在 CI/预发执行,输出统计与失败率。

概念解释

  • 任务权重控制接口比例,贴近真实流量分布。
  • 压测端自身可能成为瓶颈,需多机分布式压测。

原理流程

  1. 定义用户任务与思考时间。
  2. 逐步生成并发用户加压。
  3. 观察 RPS、延迟分位、错误率,定位拐点。

代码或图示

from locust import HttpUser, task, between

class Api(HttpUser):
    wait_time = between(0.1, 0.5)
    @task(3)
    def list(self): self.client.get("/api/items")
    @task(1)
    def create(self): self.client.post("/api/items", json={"name": "x"})

常见误区

  • 用 between() 模拟思考时间,避免不真实的高压;关注 P50/P95/P99、错误率、RPS,而不只看平均值。
  • 压测数据准备与清理要纳入脚本;平均延迟没意义,长尾决定用户体验,需看 P95/P99;冷缓存会严重低估或高估性能,数据库要预热;找容量上限:逐步加压直到延迟非线性上升或错误率抬头。

追问

  • 为什么平均延迟没意义?答:长尾决定用户体验,需看 P95/P99。
  • 压测时数据库要不要预热?答:要,冷缓存会严重低估或高估性能。
  • 怎么找容量上限?答:逐步加压直到延迟非线性上升或错误率抬头。

04.7.10-024 线上监控应该看哪些指标?

一句话结论

四类黄金信号:延迟(P95/P99)、流量(QPS)、错误率、饱和度(CPU/内存/连接池/队列)。再加业务指标(下单成功率、支付转化)与依赖指标(DB/Redis/下游 RT),并配置分级告警。

概念解释

  • RED 方法(Rate/Errors/Duration)适合服务;USE(Utilization/Saturation/Errors)适合资源。
  • 指标与日志、追踪通过 request/trace ID 关联。

原理流程

  1. 采集服务、资源、业务、依赖四类指标。
  2. 按阈值与持续时间配置分级告警。
  3. 结合日志与追踪定位单次问题。

代码或图示

from prometheus_client import Histogram
LATENCY = Histogram("http_latency_seconds", "latency", ["path"])

常见误区

  • 只看 CPU 不够:IO 瓶颈、锁竞争、下游慢都可能 CPU 不高;Python 特有指标:GC 时间、线程/协程数、事件循环延迟、RSS。
  • 队列类关注积压长度与消费延迟;告警要有阈值、持续时间、分级与值班路由,避免噪声;事件循环延迟通过定时任务测“预期 vs 实际”唤醒差,持续变大说明循环被阻塞;告警太多时分级、聚合、抑制、只对可行动事件告警。

追问

  • 为什么只看 CPU 不够?答:IO 瓶颈、锁竞争、下游慢都可能 CPU 不高。
  • 事件循环延迟怎么测?答:定时任务测“预期 vs 实际”唤醒差,持续变大说明循环被阻塞。
  • 告警太多怎么办?答:分级、聚合、抑制、只对可行动事件告警。

04.7.10-025 灰度发布怎么做?出问题怎么回滚?

一句话结论

灰度按“小流量 → 逐步放量 → 全量”推进,按实例/用户/租户/地域分桶,监控关键指标与业务指标,设自动回滚阈值。回滚优先切流量/回旧版本镜像,数据库变更需向前兼容以支持代码回退。

概念解释

  • 分桶要稳定(同一用户始终进同一组),避免体验抖动。
  • 每次灰度记录版本、范围、指标基线,便于复盘。

原理流程

  1. 小流量分桶发布新版本。
  2. 监控错误率、延迟、业务成功率。
  3. 达标逐步放量,异常触发自动/手动回滚。

代码或图示

canary:
  steps: [5%, 20%, 50%, 100%]
  analysis:
    metrics: [error_rate, p99_latency]

常见误区

  • 新旧版本共存期间接口与数据格式必须兼容;自动回滚要有明确阈值与冷却时间,避免抖动误回滚。
  • 数据库迁移要可回退:代码回滚后仍需读旧结构;灰度期间发现数据写坏要立即停量 + 修复脚本 + 对账,不能只回滚代码;灰度不能覆盖所有问题,需配合压测、混沌测试与全链路演练。

追问

  • 为什么数据库迁移要可回退?答:代码回滚后仍需读旧结构。
  • 灰度期间发现数据写坏怎么办?答:立即停量 + 修复脚本 + 对账,不能只回滚代码。
  • 灰度能覆盖所有问题吗?答:不能,需配合压测、混沌测试与全链路演练。

本节高频题

  • fixture 作用域与 yield 清理(001、002)
  • patch 的位置(003)
  • 参数化(004)
  • 覆盖率有效性(005)
  • 测试分层(006)
  • 数据库测试隔离(007)
  • 异步测试(008)
  • cProfile 与 py-spy(010、011)
  • 性能优化顺序(013)
  • 慢查询定位(014)
  • 结构化日志与日志性能(015、016)
  • Dockerfile 与镜像瘦身(017、018)
  • gunicorn/uvicorn 参数(019)
  • 健康检查与优雅停机(020、021)
  • CI/CD(022)
  • 压测与监控(023、024)
  • 灰度与回滚(025)