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

04.7.16.5 安全、性能与生产部署

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

覆盖范围

  • CSRF/XSS/SQL 注入/点击劫持与 SECURE_*、X_FRAME_OPTIONS、ALLOWED_HOSTS
  • SECRET_KEY 管理、密码哈希与 AUTH_PASSWORD_VALIDATORS、HSTS
  • 性能优化:预取、缓存分层、索引、连接池、批量操作与查询计数
  • collectstatic/STATIC_ROOT/CDN/Nginx、gunicorn 与 ASGI 部署拓扑
  • 配置分离、DEBUG=False 坑、日志与错误上报、容量与健康检查、优雅重启
  • 测试分层:TestCase/TransactionTestCase/LiveServerTestCase/pytest-django

04.7.16.5-001 Django 生产安全基线包含哪些层面?

一句话结论

安全基线分四层:传输层(HTTPS、HSTS、安全 Cookie)、应用层(CSRF、XSS 转义、ORM 防注入、上传校验)、配置层(DEBUG=False、ALLOWED_HOSTS、SECRET_KEY 管理、密码策略)、运维层(依赖更新、最小权限、日志脱敏、错误上报)。Django 提供中间件与配置项落地这些基线,manage.py check --deploy 可扫描未加固项。

概念解释

  • 安全是纵深防御:单层被突破后还有后续拦截,不能依赖某一个中间件。
  • 基线要在上线前检查,而不是被攻击后补配置。

原理流程

  1. 梳理威胁面:表单提交、展示内容、查询、文件上传、后台入口。
  2. 配置传输与 Cookie 安全策略。
  3. 应用层启用 CSRF、自动转义、参数化查询与上传校验。
  4. 定期跑部署检查、更新依赖、审计日志与权限。

代码或图示

python manage.py check --deploy

常见误区

  • 只开 HTTPS 就认为安全:应用层 XSS/注入/上传漏洞仍可被利用。
  • 开发配置直接上生产:DEBUG=True、默认密钥、宽松主机名都是高危项。
  • 安全配置写死在代码仓库:密钥应走环境变量/配置中心,仓库不提交真实值。

追问

  • 安全基线谁负责落地?答:开发在代码与配置中实现,运维在网络/主机层加固,上线前共同验收。
  • 基线多久复查一次?答:依赖更新、架构变更后复查,定期跑部署检查与依赖扫描。
  • 内网工具需要全套安全配置吗?答:仍需关闭调试与泄露信息,暴露面可按网络位置收窄。

04.7.16.5-002 CSRF 防护在 Django 中如何实现?

一句话结论

CSRF 防护基于“Cookie 中随机 token + 表单/请求头中同一 token”配对:中间件下发 csrftoken Cookie,表单 {% csrf_token %} 写入隐藏字段;提交时比对二者,一致才放行。攻击者跨站页面读不到受害者 Cookie,无法伪造配对 token。防护针对状态改变的请求(POST/PUT/PATCH/DELETE),安全只读 GET 不参与。

概念解释

  • token 与 SECRET_KEY 及随机值绑定,不可预测。
  • 中间件在会话之前处理,不依赖登录态即可校验表单来源。

原理流程

  1. GET 响应由 CSRF 中间件设置 Cookie token。
  2. 模板渲染隐藏输入 csrfmiddlewaretoken,值与 Cookie 配对。
  3. POST 到达,中间件从表单或 X-CSRFToken 头取 token,与 Cookie 比对。
  4. 匹配放行;不匹配返回 403,记录安全日志。

代码或图示

<form method="post">
  {% csrf_token %}
  {{ form.as_p }}
  <button type="submit">保存</button>
</form>

常见误区

  • 跨子域提交未配 CSRF_TRUSTED_ORIGINS:来源校验失败 403。
  • 纯 API 无 Cookie 场景误加 CSRF 校验:Token 认证接口可按视图豁免,但浏览器表单不能豁免。
  • token 复用多个会话:每次下发的 token 应与会话/随机值绑定,不硬编码通用值。

追问

  • 为什么 GET 不校验 CSRF?答:GET 应为安全只读操作,不改变服务端状态。
  • 前后端分离怎么带 token?答:从 Cookie 读 token 放 X-CSRFToken 请求头,或后端下发可读取的元信息。
  • CSRF 与 XSS 关系?答:XSS 可读 Cookie 与 token,可绕过 CSRF,二者需同时防护。

04.7.16.5-003 什么时候需要 csrf_exempt?AJAX 如何带 CSRF 头?

一句话结论

csrf_exempt 仅用于不受浏览器 Cookie 保护的入口:第三方 webhook、纯 Token 认证 API、硬件/设备回调;浏览器页面发起的表单与 AJAX 不能豁免。AJAX 从 csrftoken Cookie 读取 token,放入 X-CSRFToken 请求头;JSON 请求体里的 token 字段不会被默认校验读取。

概念解释

  • 豁免是收窄防护,必须能说清“为什么这个入口不受 CSRF 威胁”。
  • 第三方回调通常用签名校验替代 CSRF,而不是裸开放。

原理流程

  1. 判断入口是否携带浏览器自动发送的 Cookie。
  2. 无 Cookie 自动携带 → 评估豁免或改用签名鉴权。
  3. 有 Cookie 的前端请求,JS 读 Cookie token 放请求头。
  4. 中间件校验头中 token 与 Cookie 配对。

代码或图示

from django.views.decorators.csrf import csrf_exempt
from django.http import JsonResponse

@csrf_exempt
def webhook(request):
    # 用签名校验替代 CSRF
    return JsonResponse({"ok": True})
// 前端:从 Cookie 取 token 放请求头
const token = document.cookie.match(/csrftoken=([^;]+)/)[1];
fetch("/api/order/", {
  method: "POST",
  headers: { "X-CSRFToken": token },
  body: JSON.stringify(payload),
});

常见误区

  • 全站 csrf_exempt:浏览器表单跨站伪造全部可提交。
  • 把 token 放 JSON body:CSRF 中间件默认不解析 body 取 token,校验不通过。
  • 豁免接口仍依赖 Cookie 登录:Cookie 自动携带场景下 CSRF 威胁存在,不能豁免。

追问

  • 类视图怎么豁免 CSRF?答:method_decorator(csrf_exempt, name="dispatch")。
  • webhook 怎么做校验?答:验签(HMAC/Signature 头)、时间戳防重放、来源 IP 白名单。
  • CSRF_TRUSTED_ORIGINS 配什么?答:允许跨站提交的源(含 scheme 与 host),Django 4.0 起要求完整源。

04.7.16.5-004 Django 如何防 XSS?|safe 的风险边界是什么?

一句话结论

模板默认自动转义,把 < > & " ' 转为 HTML 实体,用户内容作为文本输出不被解析为标签;|safe/mark_safe 标记内容可信、跳过转义,只有经过白名单过滤的富文本才能使用。存储型 XSS 常来自用户提交的 HTML 未过滤就 |safe 输出,反射型来自参数直接拼进页面。

概念解释

  • 转义在输出层,不改变存储内容;同一内容换安全输出方式仍需转义。
  • XSS 可窃取 Cookie、冒充用户操作,是 CSRF 防护的绕过路径。

原理流程

  1. 模板渲染变量,默认经过 HTML 转义函数。
  2. 用户输入中的标签字符变为实体,浏览器按文本显示。
  3. 可信富文本入库前经白名单库剥离脚本、事件属性、危险标签。
  4. 输出时再决定是否 |safe;不可信内容一律转义。

代码或图示

<!-- 安全:自动转义 -->
{{ comment.content }}

<!-- 仅白名单过滤后的富文本可用 -->
{{ post.rich_body|safe }}

常见误区

  • 对用户昵称、签名、评论直接 |safe:存储型 XSS 入口。
  • 后端存了过滤后内容,前端再二次拼接 HTML:拼接环节未转义仍可注入。
  • 只靠前端校验:抓包可绕过,过滤必须在服务端。

追问

  • 富文本白名单过滤用什么?答:HTML 净化库保留标签/属性白名单,剥离 script、on* 事件、javascript: 链接。
  • CSP 能补什么防护?答:内容安全策略限制脚本来源与内联执行,作为 XSS 缓解层,不能替代转义。
  • 模板 {% autoescape off %} 风险?答:块内所有变量失去转义,应只对可信片段关闭。

04.7.16.5-005 ORM 如何防 SQL 注入?哪些写法有注入风险?

一句话结论

ORM 对字段值做参数化绑定,值与 SQL 文本分离,常规 filter/exclude/get 天然防注入;风险点在原生 SQL:raw() 字符串拼接、extra() 条件拼接、Cursor.execute 直接拼用户输入、annotate/aggregates 中拼接表达式。参数槽位按驱动传参,不能把用户输入拼进 SQL 文本。

概念解释

  • 注入根源:数据被解释为 SQL 语法;参数化让数据永远是值。
  • 排序字段、表名、列名无法参数化,需白名单校验后再拼。

原理流程

  1. 常规查询:ORM 生成带参数槽位的 SQL,值由驱动绑定。
  2. 原生 SQL:raw("... WHERE name=%s", [value]) 用参数槽位传参。
  3. 标识符(列/表/排序)做白名单匹配后拼接。
  4. 禁止把请求参数直接字符串拼进 SQL 文本。

代码或图示

# 安全:参数化
Post.objects.filter(title=request.GET["q"])

# 安全:raw 参数槽位传参
from django.db import connection
with connection.cursor() as cur:
    cur.execute("SELECT id FROM post WHERE title = %s", [q])

# 危险:拼接用户输入
# cur.execute(f"SELECT ... WHERE title = '{q}'")

常见误区

  • 用 extra(where=[f"... {q}"]) 拼值:绕过参数化,注入风险。
  • 动态排序字段直接取 request.GET["order"]:列名注入,应映射白名单字段。
  • 以为 raw() 就安全:方法本身不注入,拼接方式才决定风险。

追问

  • 如何审计注入风险?答:搜索 raw(、extra(、execute( 与字符串拼接,核对参数是否经槽位传值。
  • 表名能参数化吗?答:不能,标识符需白名单校验后拼入。
  • 第三方查询构建器安全吗?答:看其值是否参数化,自定义 SQL 片段同样要审。

04.7.16.5-006 点击劫持如何防护?X_FRAME_OPTIONS 与 CSP frame-ancestors 有何区别?

一句话结论

点击劫持通过 iframe 嵌套受害页面诱导点击;防护由 X_FRAME_OPTIONS(DENY/SAMEORIGIN)控制页面能否被嵌入,XFrameOptionsMiddleware 下发该头;CSP frame-ancestors 是更现代的替代,可按源精细控制嵌入方。敏感后台、账号设置页应禁止跨域嵌入,公开嵌入内容才放开。

概念解释

  • X-Frame-Options 旧浏览器兼容好,但只能 DENY/SAMEORIGIN,不能列多个可信源。
  • frame-ancestors 支持源列表,能力更强,新浏览器优先。

原理流程

  1. 响应由中间件按 X_FRAME_OPTIONS 配置写头。
  2. 浏览器加载 iframe 时检查嵌入页面响应头。
  3. 不允许则拒绝渲染嵌套框架。
  4. 需要多可信源嵌入时配置 CSP frame-ancestors 指令。

代码或图示

# settings.py
X_FRAME_OPTIONS = "DENY"

# CSP 等价配置(按中间件/前端服务器下发)
Content-Security-Policy: frame-ancestors 'self' https://partner.example.com

常见误区

  • 公开页面与后台共用头配置:后台禁止嵌入,公开嵌入内容误锁。
  • 只设 CSP 不配旧头:老浏览器仍可被嵌套。
  • 依赖 JS 防嵌套:脚本可被绕过,HTTP 头由浏览器强制拦截。

追问

  • SAMEORIGIN 允许什么?答:同源页面互相嵌入,跨域页面禁止。
  • 哪些页面必须禁嵌入?答:登录、授权、资金、账号安全等敏感操作页。
  • 嵌入白名单怎么维护?答:frame-ancestors 列可信源,定期下线过期合作方。

04.7.16.5-007 SECURE_* 安全配置清单包含哪些项?

一句话结论

主要项:SECURE_SSL_REDIRECT(HTTP 跳转 HTTPS)、SESSION_COOKIE_SECURE/CSRF_COOKIE_SECURE(Cookie 仅 HTTPS)、SECURE_HSTS_SECONDS 与 SECURE_HSTS_INCLUDE_SUBDOMAINS/PRELOAD(HSTS)、SECURE_CONTENT_TYPE_NOSNIFF(禁止 MIME 嗅探)、SECURE_REFERRER_POLICY、SECURE_CROSS_ORIGIN_OPENER_POLICY。生产按传输层策略逐项开启,开发环境按需关闭避免不可用。

概念解释

  • 这些头由 SecurityMiddleware 统一下发。
  • 配置与反向代理有关:若 Nginx 已做 HTTPS 跳转,应用层可避免重复 301。

原理流程

  1. 配置传输策略:HTTPS 跳转、HSTS、安全 Cookie。
  2. 配置内容防护:禁止嗅探、引用策略、隔离 opener。
  3. 中间件在响应回程写入对应安全头。
  4. 浏览器按头执行传输与隔离策略。

代码或图示

SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_CONTENT_TYPE_NOSNIFF = True

常见误区

  • HTTP 开发环境开 SECURE_SSL_REDIRECT:本地请求被循环跳转。
  • HSTS 预先提交后反悔:HSTS 有效期内浏览器强制 HTTPS,撤收回滚窗口长,先小范围验证。
  • Cookie Secure 与站点未全 HTTPS 混用:Cookie 不下发,登录态丢失。

追问

  • SECURE_PROXY_SSL_HEADER 做什么?答:告知应用从代理头判断原始协议,配合 Nginx X-Forwarded-Proto 使用。
  • 哪些头必须经 HTTPS 才能生效?答:HSTS、Secure Cookie 在 HTTP 下被浏览器忽略。
  • nosniff 防什么?答:防止浏览器把非脚本内容嗅探为脚本执行。

04.7.16.5-008 SecurityMiddleware 负责哪些安全头与策略?

一句话结论

SecurityMiddleware 是最外层安全中间件:按配置下发 HSTS、SSL 重定向、X-Content-Type-Options: nosniff、X-Frame-Options(配合帧中间件)、引用策略、跨域 opener 策略与代理协议识别。它在中间件列表最前,先于会话/认证执行,保证安全头在任何业务响应上都存在。

概念解释

  • 重定向与头写入在响应回程完成,请求段主要识别代理协议。
  • 中间件顺序:Security 在 Session、CSRF、Authentication 之前。

原理流程

  1. 请求进入,按 SECURE_PROXY_SSL_HEADER 判断原始是否 HTTPS。
  2. 未 HTTPS 且开启跳转,返回 301 到 HTTPS。
  3. 响应回程叠加 HSTS、nosniff、帧选项、Referrer/Opener 策略头。
  4. 下游业务中间件与视图只关心业务逻辑。

代码或图示

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    # 其余中间件在后
]

常见误区

  • Security 中间件排到认证之后:部分响应头在短路/异常路径上缺失。
  • 重复在 Nginx 与应用写同一安全头:值冲突时以后者为准,需梳理口径。
  • 忽略代理头配置:应用认为请求是 HTTP,安全 Cookie 不下发。

追问

  • HSTS 头由哪个组件写?答:SecurityMiddleware,参数来自 SECURE_HSTS_*。
  • 中间件被移除会怎样?答:对应安全头不再下发,浏览器失去强制防护。
  • 如何验证头是否生效?答:浏览器开发者工具响应头或 curl -I 检查。

04.7.16.5-009 ALLOWED_HOSTS 起什么作用?与 DEBUG 什么关系?

一句话结论

ALLOWED_HOSTS 校验请求 Host 头是否在白名单内,防止 Host 头注入(密码重置链接、缓存键、后台 URL 被恶意域名构造)。DEBUG=True 时允许 localhost/127.0.0.1/.localhost 自动通过;DEBUG=False 时必须显式配置域名,否则所有请求返回 400。生产部署第一项检查就是补全主机白名单。

概念解释

  • Host 头可被客户端伪造,影响生成的绝对 URL 与缓存键。
  • 条目支持 .example.com 通配子域与精确域名。

原理流程

  1. 请求到达,中间件读取 Host 头。
  2. 与 ALLOWED_HOSTS 匹配:精确、子域通配或 *。
  3. 不匹配拒绝 400;匹配通过进入后续链路。
  4. DEBUG=False 未配置时框架直接拒绝全部外部主机。

代码或图示

ALLOWED_HOSTS = ["example.com", ".example.com", "api.example.com"]

常见误区

  • 生产留 ALLOWED_HOSTS = ["*"]:Host 头校验形同虚设。
  • 漏配负载均衡/CDN 回源域名:健康检查与部分请求 400。
  • 忘记 DEBUG=False 后补配置:上线即全站 400。

追问

  • Host 头注入有什么实际危害?答:篡改邮件链接域名、污染缓存键、绕过基于主机的访问控制。
  • 本地开发需要配吗?答:DEBUG=True 下本地主机自动放行,可不显式列。
  • 端口号参与匹配吗?答:匹配主机名,端口由连接层处理,配置写主机部分。

04.7.16.5-010 SECRET_KEY 泄露有什么后果?如何管理与轮换?

一句话结论

SECRET_KEY 用于签名会话、CSRF token、密码重置令牌、签名 Cookie 与消息;泄露后攻击者可伪造会话与令牌、解密签名数据。管理原则:不进仓库、按环境隔离、走环境变量/配置中心;泄露后立即轮换,旧签名全部失效(强制重新登录、令牌作废)。不同环境使用不同密钥,开发密钥不能复用到生产。

概念解释

  • 密钥强度要求随机足够长,可由 django-admin startproject 或 secrets 工具生成。
  • 轮换使旧签名验证失败,属于预期副作用,需通知用户重新登录。

原理流程

  1. 启动期从环境变量读取 SECRET_KEY,缺失则按环境策略拒绝启动。
  2. 签名/哈希函数用密钥派生 token 与校验值。
  3. 怀疑泄露:从配置中心换新值,重启进程。
  4. 旧签名会话/令牌校验失败,用户重新认证。

代码或图示

import os
SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]

常见误区

  • 仓库提交真实生产密钥:Git 历史残留,需轮换而非仅删除文件。
  • 多环境共用同一密钥:一套环境泄露波及全部环境。
  • 密钥写在 settings 默认值兜底:开发默认值可能被带到生产。

追问

  • 轮换后用户要重新登录吗?答:旧会话签名失效,需重新认证;签名 Cookie 数据同样不可信。
  • 密钥多长合适?答:Django 生成的随机串长度即可,避免短密钥与可预测值。
  • 密钥能放数据库吗?答:不建议,密钥与业务数据同库泄露风险叠加;用环境变量或密钥管理服务。

04.7.16.5-011 Django 密码哈希用哪些算法?迭代次数怎么定?

一句话结论

默认 PBKDF2(SHA256),可在 PASSWORD_HASHERS 切换 Argon2、bcrypt、MD5/SHA1 等弱哈希仅用于兼容旧数据。哈希单向存储,数据库泄露无法还原明文;迭代次数/成本因子越高抗破解越强,但登录计算越慢。新密码用强算法,旧哈希登录成功后可升级到当前默认哈希。

概念解释

  • 哈希串内含算法、迭代次数/盐值,校验时按串内参数还原计算。
  • Argon2 内存成本调高后抗 GPU/ASIC 破解能力更强,需装 argon2-cffi。

原理流程

  1. 注册/改密时 set_password 按当前默认哈希器加盐迭代。
  2. 存储格式 算法$迭代$盐$哈希。
  3. 登录 check_password 按串内参数重算比对。
  4. 旧算法哈希登录成功,可 set_password 重哈希为默认算法。

代码或图示

PASSWORD_HASHERS = [
    "django.contrib.auth.hashers.Argon2PasswordHasher",
    "django.contrib.auth.hashers.PBKDF2PasswordHasher",
    "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
]

常见误区

  • 数据库存明文或可逆加密:拖库即全部账号失陷。
  • 复用无盐通用哈希:彩虹表可批量破解,Django 哈希器自带随机盐。
  • 迭代次数调到极端:登录与注册 CPU 暴增,被拒服务放大。

追问

  • 怎么把旧用户升级到 Argon2?答:登录校验通过后用新哈希器重存密码,无需用户操作。
  • 弱哈希能从列表删除吗?答:有历史数据时先保留用于校验,迁移完成再移除。
  • 哈希计算慢影响什么?答:登录接口 CPU 与响应时间,暴力尝试也受同等成本限制。

04.7.16.5-012 AUTH_PASSWORD_VALIDATORS 校验哪些强度规则?

一句话结论

内置校验器:长度(MinimumLengthValidator)、与用户名/邮箱相似度(UserAttributeSimilarityValidator)、常见弱密码(CommonPasswordValidator)、纯数字(NumericPasswordValidator)。注册与改密流程自动跑校验,可自定义规则补充(复杂度、历史密码复用限制)。强度策略与哈希成本互补:前者防弱密码,后者拖慢破解。

概念解释

  • 校验器在表单/用户创建阶段执行,错误反馈给用户。
  • 策略按风险分级:内部系统可宽松,对外账号需长度+复杂度+常见弱密码拦截。

原理流程

  1. 配置校验器列表。
  2. 新建/修改密码表单校验密码。
  3. 逐个校验器检查相似度、长度、常见密码、纯数字。
  4. 不通过收集错误返回;通过才哈希存储。

代码或图示

AUTH_PASSWORD_VALIDATORS = [
    {"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
     "OPTIONS": {"min_length": 10}},
    {"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator"},
    {"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator"},
]

常见误区

  • 只在前端校验强度:接口可绕过,后端校验器必须启用。
  • 允许与邮箱/手机号完全相同的密码:UserAttributeSimilarityValidator 拦截高相似度。
  • 校验器报英文硬编码:按国际化项目接入翻译。

追问

  • 如何禁止复用历史密码?答:自定义校验器查历史密码哈希记录,注册/改密时比对。
  • 密码强度与 MFA 关系?答:强度降低被猜解概率,MFA 在密码泄露后提供第二层拦截。
  • 校验器能查黑名单库吗?答:自定义校验器对接泄露密码字典/接口,命中拒绝。

04.7.16.5-013 密码重置流程如何防止令牌被滥用?

一句话结论

重置流程:提交账号 → 生成有时效的签名/随机令牌 → 邮件/短信发送带令牌链接 → 用户凭令牌设新密码。防护要点:令牌短时有效、一次性使用、与账号绑定、通道可信;邮件链接防枚举,成功失败响应一致。令牌泄露不等于账号失守,过期与单次使用压缩窗口。

概念解释

  • Django 重置视图用 default_token_generator,基于用户标识、密码哈希版本与时间戳签名。
  • 改密后旧令牌自动失效(密码哈希版本变化)。

原理流程

  1. 用户提交账号,存在则生成重置令牌并发送通道消息。
  2. 链接含用户标识与令牌,服务端校验签名、时效与账号状态。
  3. 校验通过展示新密码表单,提交后更新密码哈希。
  4. 旧令牌作废,已登录会话按策略失效。

代码或图示

from django.contrib.auth.tokens import default_token_generator

def make_token(user):
    return default_token_generator.make_token(user)

def check_token(user, token):
    return default_token_generator.check_token(user, token)

常见误区

  • 令牌长期有效或可重复使用:链接泄露后长期可改密。
  • 响应区分“账号存在/不存在”:帮助枚举有效邮箱。
  • 重置链接走 HTTP:令牌在传输中被窃听,必须 HTTPS。

追问

  • 令牌为什么随密码哈希版本失效?答:生成内容含密码摘要,改密后旧签名校验失败。
  • 重置邮件被拦截怎么办?答:短信/备用邮箱通道,异常重置告警,绑定设备确认。
  • 令牌能放进 URL 日志吗?答:避免,访问日志可能记录查询参数,敏感令牌尽量走路径或 POST。

一句话结论

HttpOnly 禁 JS 读取(防 XSS 窃取)、Secure 仅 HTTPS 携带、SameSite 限制跨站发送、SESSION_COOKIE_DOMAIN/PATH 限定作用域、SESSION_COOKIE_AGE 控制有效期。生产逐项开启:HttpOnly 默认开启,Secure 与 SameSite 按站点形态配置;Cookie 不存敏感明文,只存会话 ID。

概念解释

  • 属性在响应写 Cookie 时由 Session/CSRF 中间件按对应配置下发。
  • 跨域嵌入与第三方场景 SameSite=None 必须同时 Secure。

原理流程

  1. 配置会话 Cookie 属性与有效期。
  2. 响应下发带属性的 sessionid Cookie。
  3. 浏览器按属性决定是否携带、是否允许脚本访问。
  4. 跨站请求按 SameSite 策略限制 Cookie 发送。

代码或图示

SESSION_COOKIE_HTTPONLY = True
SESSION_COOKIE_SECURE = True
SESSION_COOKIE_SAMESITE = "Lax"
SESSION_COOKIE_AGE = 3600 * 8

常见误区

  • 关闭 HttpOnly 方便前端调试:XSS 可直接读会话 Cookie,上线必须开回。
  • SameSite=None 漏配 Secure:浏览器拒绝该 Cookie,登录态丢失。
  • 父域 Cookie 过宽:同一父域其他应用可读写会话,按最小作用域设置。

追问

  • CSRF Cookie 也有 Secure 配置吗?答:有,CSRF_COOKIE_SECURE 与会话 Cookie 对称配置。
  • Cookie 能设双提交吗?答:可前端读非 HttpOnly 字段配合表单,但 Django 默认方案以 HttpOnly 会话为主。
  • 会话 ID 固定如何防?答:登录刷新 session ID,配合短有效期与服务端失效。

04.7.16.5-015 Django 如何处理跨域(CORS)?

一句话结论

Django 内核不内置 CORS 中间件,跨域响应头由 django-cors-headers 等组件下发:配置允许来源、方法、头与凭证;预检 OPTIONS 请求返回允许策略。浏览器按响应头决定前端 JS 能否读取跨域响应,服务端仍需独立鉴权,CORS 不是访问控制。

概念解释

  • CORS 是浏览器约束,服务端接口直接被脚本/工具调用不受 CORS 限制。
  • 允许凭证时不能用通配 *,必须列具体来源。

原理流程

  1. 前端跨域请求,浏览器先发 OPTIONS 预检。
  2. CORS 中间件返回 Access-Control-Allow-Origin/Methods/Headers。
  3. 预检通过,浏览器发送实际请求并带凭证(若配置)。
  4. 响应头允许前端 JS 读取返回内容。

代码或图示

CORS_ALLOWED_ORIGINS = ["https://app.example.com"]
CORS_ALLOW_CREDENTIALS = True
CORS_ALLOW_METHODS = ["GET", "POST", "PUT", "DELETE"]

常见误区

  • 把 CORS 当鉴权:未带凭证/会话的接口仍需后端校验身份。
  • 开发期 CORS_ALLOW_ALL_ORIGINS=True 带到生产:跨域读取无限制。
  • 允许凭证又配通配来源:浏览器拒绝组合,需显式列源。

追问

  • 简单请求与预检请求区别?答:方法/头/内容类型属简单范围直接发;其余先 OPTIONS 预检。
  • 跨域带 Cookie 要什么配置?答:前端 credentials="include",后端允许凭证并明确来源。
  • CORS 头在 Nginx 也能配吗?答:能,应用与代理只在一处下发,避免重复冲突。

04.7.16.5-016 文件上传有哪些安全风险?如何校验?

一句话结论

风险:可执行脚本上传后被访问执行、路径穿越写入任意目录、伪造 MIME/扩展名绕过、超大文件耗尽存储、恶意图片内嵌脚本。校验:白名单扩展名与文件头(魔数)、限制大小与数量、存储到 web 不可执行目录、随机化文件名、隔离媒体域;图片二次压缩/转码剥离内嵌内容。

概念解释

  • 浏览器 MIME 与扩展名均可伪造,不能作为唯一依据。
  • 上传目录不应有脚本执行权限,访问由独立域名/对象存储提供。

原理流程

  1. 入口校验文件大小、字段数量与扩展名白名单。
  2. 读取文件头判断真实类型,拒绝伪装文件。
  3. 随机命名落盘到非执行目录,记录原始名与类型。
  4. 访问经媒体域/对象存储,禁止在应用目录执行上传内容。

代码或图示

def validate_upload(uploaded):
    allowed = {"png", "jpg", "jpeg", "pdf"}
    ext = uploaded.name.rsplit(".", 1)[-1].lower()
    if ext not in allowed:
        raise ValidationError("扩展名不允许")
    if uploaded.size > 5 * 1024 * 1024:
        raise ValidationError("文件过大")
    # 进一步校验文件头魔数,图片重编码

常见误区

  • 按 content_type 校验类型:可伪造,必须读文件头。
  • 保留用户原始文件名落盘:路径穿越与覆盖风险,服务端生成存储名。
  • 上传目录与静态目录混放:脚本被当静态资源执行。

追问

  • SVG 上传为什么危险?答:可内嵌脚本,浏览器直接打开执行,应禁传或转栅格化。
  • 路径穿越怎么防?答:不拼接用户文件名做路径,存储后端生成安全路径,校验最终路径在目标目录内。
  • 恶意图片怎么处理?答:重新编码生成新图片,剥离元数据与内嵌脚本。

04.7.16.5-017 敏感信息如何在日志与响应中脱敏?

一句话结论

脱敏覆盖:日志不记密码、令牌、身份证/手机号/银行卡全量;响应对象不返回敏感字段;异常页面不暴露堆栈、配置、路径。日志按字段掩码(手机保留前 3 后 4),错误上报单独收集上下文并过滤敏感键。传输与存储加密是另一层,脱敏是减少二次泄露面。

概念解释

  • 日志集中采集后访问面扩大,开发/运维都可能读到。
  • 序列化响应主动剔除敏感字段,不能依赖前端不展示。

原理流程

  1. 梳理敏感字段清单:凭证、令牌、证件号、联系方式、财务信息。
  2. 日志处理器/格式化器按字段名掩码或丢弃。
  3. 序列化器/响应构造只返回必要字段。
  4. 错误上报上下文过一遍过滤器,再送 Sentry 等外部系统。

代码或图示

def mask_phone(value):
    if not value or len(value) < 7:
        return "***"
    return f"{value[:3]}****{value[-4:]}"

# 日志中禁止出现
logger.info("login user=%s", mask_phone(request.POST.get("phone", "")))

常见误区

  • 整个请求 POST 字典打日志:密码验证码一并落盘。
  • 异常栈里带局部变量:第三方错误服务拿到敏感上下文。
  • 数据库备份含明文敏感信息:备份访问面同样需要加密与权限控制。

追问

  • 密码能在日志出现一次吗?答:任何日志、异常、上报都不应记录明文密码。
  • 脱敏后如何排查问题?答:用用户 ID、会话标识关联,敏感值走受控渠道核验。
  • 响应里多余字段怎么防?答:序列化器显式声明字段,不直接 model_to_dict 全量输出。

04.7.16.5-018 DEBUG=False 后调试信息泄露如何避免?

一句话结论

DEBUG=True 错误页暴露堆栈、配置项、数据库查询与本地路径;DEBUG=False 时框架返回通用 404/500 模板,不展示内部细节。生产必须 DEBUG=False 并准备 404.html/500.html;异常细节只进服务端日志与错误上报,不回传客户端。配合 ALLOWED_HOSTS 与安全头完成上线检查。

概念解释

  • 调试页面是开发工具,生产暴露等于泄露内部实现与路径。
  • 500 模板不能读取请求敏感数据作为展示内容。

原理流程

  1. 生产配置 DEBUG=False。
  2. 异常由异常中间件转通用错误响应,渲染错误模板。
  3. 堆栈与上下文写入服务日志/错误上报。
  4. 客户端只收到状态码与友好提示。

代码或图示

# settings/prod.py
DEBUG = False
ALLOWED_HOSTS = ["example.com"]

常见误区

  • 生产临时开 DEBUG 排查问题忘记关:调试页长期暴露。
  • 500 模板里 {{ exception }} 输出异常文本:内部信息回传前端。
  • 错误上报 DSN 与项目配置泄露:上报密钥走环境变量,响应页不含后端地址。

追问

  • 生产想看调试栈怎么办?答:查服务日志/Sentry,不在浏览器暴露。
  • 404 模板也需要准备吗?答:需要,否则用框架默认通用页,样式与信息不可控。
  • DEBUG=False 静态文件会自动服务吗?答:不会,需 collectstatic 后由 Nginx/CDN 分发。

04.7.16.5-019 安全相关中间件的顺序与依赖是什么?

一句话结论

推荐顺序:SecurityMiddleware(安全头/重定向)→ SessionMiddleware(会话)→ CommonMiddleware(尾斜杠/基础头)→ CsrfViewMiddleware(CSRF 校验)→ AuthenticationMiddleware(绑定用户)→ MessageMiddleware → XFrameOptionsMiddleware。依赖方向:认证依赖会话,CSRF 可访问会话/Cookie,安全头最外层先行;顺序错乱会出现用户未绑定、防护缺失或头丢失。

概念解释

  • 请求正序、响应逆序,安全头应在最外层保证任何响应都带上。
  • 新增自定义安全中间件按依赖插入对应层。

原理流程

  1. 最外层 Security 处理协议升级与安全头。
  2. 会话加载后 CSRF 校验,再绑定用户。
  3. 消息与帧选项中间件处理附加响应。
  4. 回程逆序写头,外层兜底最终安全策略。

代码或图示

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    "django.middleware.clickjacking.XFrameOptionsMiddleware",
]

常见误区

  • Authentication 放 Session 前:用户永远匿名。
  • CSRF 放 Session 前:读不到会话数据,部分校验异常。
  • 帧选项中间件位置随意:响应头被后续中间件覆盖。

追问

  • 如何确认中间件实际顺序?答:打印 settings.MIDDLEWARE,结合响应头与绑定日志验证。
  • 限流中间件放哪?答:最外层 Security 之后,短路拒绝早于业务与认证。
  • 异常兜底中间件放哪?答:外层包裹业务链,捕获下游所有异常。

04.7.16.5-020 常见权限绕过场景有哪些?

一句话结论

典型:只在模板隐藏按钮不校验后端;详情/编辑接口按主键直取对象不查归属;列表不过滤可见范围;外键/表单字段可被篡改提交他人归属;越权访问未挂权限装饰器的视图;对象级归属判断只在创建时做、更新时漏掉。防御:查询集统一过滤、视图/服务层逐对象校验、表单剔除不可控字段、权限装饰器全覆盖。

概念解释

  • 水平越权:访问同角色他人记录;垂直越权:普通用户执行管理员操作。
  • 绕过多发生在“直接构造请求”绕过前端与导航的路径。

原理流程

  1. 梳理每个视图的对象获取与归属判断点。
  2. get_queryset 按可见范围过滤,详情再校验对象归属。
  3. 表单字段显式声明,拒绝客户端提交的归属外键。
  4. 权限装饰器/Mixin 覆盖受保护视图,测试直连越权用例。

代码或图示

def edit_note(request, pk):
    note = get_object_or_404(Note, pk=pk, author=request.user)
    # 归属已在查询集限定,无需再判断
    ...

常见误区

  • 用 User.objects.get(pk=...) 后只判 is_staff:普通用户间仍可互访。
  • 表单允许提交 author 字段:客户端改成他人 ID 归属转移。
  • 接口文档/测试只走正常路径:越权用例需要专门构造他人主键。

追问

  • 如何系统化发现越权?答:按对象维度写两个角色交叉访问用例,扫描视图是否都有归属过滤。
  • 共享对象怎么授权?答:业务模型记录成员/团队关系,检查时匹配成员集合。
  • 外键字段防篡改怎么做?答:ModelForm 不暴露归属字段,视图从 request.user 注入。

04.7.16.5-021 依赖漏洞与 Django 安全更新如何跟进?

一句话结论

跟进方式:锁定依赖版本、定期扫描已知漏洞(pip-audit/安全公告)、跟踪 Django 官方安全发布并及时升级、移除未用依赖。Django 安全版本修复认证、序列化、HTTP 头、模板等问题;升级前在测试环境跑回归,关注弃用 API 与迁移影响。最小依赖面本身就是安全基线。

概念解释

  • 漏洞来源:框架、ORM 驱动、模板/表单库、上传处理、WSGI/ASGI 服务器。
  • 安全更新通常不跨大版本,按支持版本线规划升级。

原理流程

  1. 依赖清单固定版本与哈希。
  2. 定期扫描漏洞库,核对影响组件与版本。
  3. 评估 Django 安全公告,测试环境升级并跑测试。
  4. 生产滚动升级,下线有漏洞的旧版本进程。

代码或图示

pip-audit
python -m pip install --upgrade django

常见误区

  • 长期停在旧 Django:累积未修复漏洞,升级成本随时间增大。
  • 只升级 Django 不管驱动/服务器:WSGI/ASGI 与数据库驱动同样有 CVE。
  • 生产直接追最新主版本:跨大版本需按迁移指南逐步升级,先测试回归。

追问

  • 哪里看 Django 安全公告?答:Django 官方博客与安全发布说明,订阅邮件/公告源。
  • 漏洞版本必须立刻升级吗?答:按暴露面与漏洞等级评估,外网暴露优先处理。
  • 如何减少依赖面?答:移除未用包,业务自研逻辑不引入重型框架。

04.7.16.5-022 manage.py check --deploy 检查哪些上线安全项?

一句话结论

check --deploy 扫描生产相关配置:DEBUG、ALLOWED_HOSTS、安全 Cookie、HSTS、SSL 重定向、CSRF/会话安全、静态文件与密钥强度等,输出 warning/error 提示未加固项。它是上线前自动化基线检查,不替代渗透测试与代码审计;修复后重复运行直到无高危告警。

概念解释

  • 检查项对应 SECURE_*、SESSION_COOKIE_*、CSRF_COOKIE_* 等配置。
  • 开发环境部分告警可忽略,生产配置分支必须清零高危项。

原理流程

  1. 以生产配置运行部署检查。
  2. 框架逐项比对配置与安全基线。
  3. 输出缺失/宽松项及对应文档说明。
  4. 修复配置后复跑,结合手动审计与测试验收。

代码或图示

python manage.py check --deploy

常见误区

  • 只跑默认 check:不含部署安全项,漏掉生产加固配置。
  • 告警全部忽略:把已知风险带入生产。
  • 检查通过就认为安全:配置基线之外还有代码注入、越权、上传等业务漏洞需审计。

追问

  • 检查能发现代码漏洞吗?答:不能,它只核对配置项;代码层问题靠审计与测试。
  • 哪些告警在开发环境正常?答:DEBUG、本地主机、非 Secure Cookie 等,按环境区分。
  • 检查结果纳入 CI 吗?答:可在生产配置分支跑 check --deploy,阻断高危项合并。

04.7.16.5-023 Django 性能优化从哪里入手?如何定位瓶颈?

一句话结论

先度量再优化:按“数据库查询 → 缓存 → 模板/渲染 → 进程并发 → 下游依赖”分层定位。手段:开启 SQL 查询计数与耗时日志、django-debug-toolbar 观察查询数与渲染耗时、慢查询日志、接口耗时分解、压测看吞吐与资源占用。没有度量的优化是猜测,先消除 N+1 与重复查询这类高收益项,再调并发与缓存策略。

概念解释

  • Web 常见瓶颈:数据库往返次数、大结果集遍历、模板渲染、阻塞下游、进程/连接不足。
  • 优化顺序:先查得少(索引/预取/过滤),再算得快(缓存/批量),最后扩并发。

原理流程

  1. 复现慢接口,记录响应时间与资源指标。
  2. 开启查询计数,定位 N+1、全表扫描、重复查询。
  3. 分析慢查询执行计划,补索引或改写查询。
  4. 缓存读多写少数据,批量替代循环单点操作,压测验证提升。

代码或图示

# 视图内统计查询数(开发/排查用)
from django.db import connection
def view(request):
    before = len(connection.queries)
    ...
    after = len(connection.queries)
    print("queries:", after - before)

常见误区

  • 一上来加机器/扩 worker:数据库慢查询未解决,扩容只是放大压力。
  • 过早优化轻量接口:先确认瓶颈层,避免在 CPU 友好的地方堆复杂度。
  • 优化后不回归验证:查询数、响应时间、命中率需前后对比。

追问

  • 工具链有哪些?答:debug-toolbar 看查询与模板,数据库慢日志与 EXPLAIN,APM 跟踪下游耗时。
  • 接口慢先看哪一层?答:先 SQL 往返次数与耗时,再看渲染与下游调用。
  • 优化收益如何排序?答:消除 N+1 与全表扫描通常收益最大,其次缓存与批量操作。

一句话结论

select_related 走 JOIN 一次取单值外键/一对一对象,适合向外单层关联;prefetch_related 发单独查询批量取多值外键与多对多对象,再在 Python 层组装。按关联类型选对方法:单个 FK 用前者,m2m/反向外键/多对象用后者。列表页循环访问关联对象前必须预取,否则每行一次查询形成 N+1。

概念解释

  • select_related 结果随主查询集返回,深度受 JOIN 层级限制。
  • prefetch_related 可配合 Prefetch 对象自定义查询集与过滤条件。

原理流程

  1. 视图构造查询集时声明关联预取。
  2. ORM 按类型生成 JOIN 查询或第二条批量查询。
  3. 对象组装后模板/服务层访问关联不再查库。
  4. 用查询计数验证 N+1 是否消除。

代码或图示

# 单值外键:JOIN 预取
posts = Post.objects.select_related("author").all()

# 多对多/反向外键:批量预取
posts = Post.objects.prefetch_related("tags", "comments__author").all()

常见误区

  • 多对多用 select_related:不支持,查询报错。
  • 预取了但循环内再过滤关联对象:触发额外查询,条件应下推到 Prefetch。
  • 过度预取大字段:JOIN 膨胀行宽,拖慢主查询,按页面需要选关联。

追问

  • 嵌套关联怎么预取?答:下划线链路,如 prefetch_related("comments__author")。
  • 预取能解决反向一对多吗?答:prefetch_related 取反向外键集合,select_related 只取单值侧。
  • 如何确认预取生效?答:查询计数对比,关联访问不再随列表行数增长。

04.7.16.5-025 大结果集遍历为什么用 iterator?

一句话结论

普通 QuerySet 求值后把全部对象载入内存;iterator() 按服务端游标分批取记录,降低大结果集的内存占用,适合批量导出、后台任务、数据迁移。代价是无法重复迭代、缓存复用失效,批量写操作需注意分批提交。小列表与需要重复访问的数据不必用 iterator。

概念解释

  • 默认查询集缓存结果,二次遍历不重查;iterator 不缓存,逐批释放。
  • 数据库驱动按服务端游标流式读取,避免一次性物化全部行。

原理流程

  1. 视图/任务判断结果集规模,选择 iterator(chunk_size=...)。
  2. ORM 分批拉取对象,处理一批释放一批。
  3. 内存占用与批次大小相关,不随总行数线性增长。
  4. 批量写入按批次提交事务,避免长事务与回滚过大。

代码或图示

def export_users():
    for user in User.objects.iterator(chunk_size=500):
        write_row(user)

常见误区

  • 对需要二次访问的查询集用 iterator:再次遍历重新查库。
  • 批次过大失去流式意义:按驱动与内存调整 chunk_size。
  • 遍历中修改对象状态依赖缓存:迭代器对象不跨批保留引用。

追问

  • 导出 CSV 怎么避免内存爆炸?答:流式响应 + iterator 分批写行,不在内存拼完整文件。
  • iterator 能配合预取吗?答:可,但预取结果仍按批组装,注意查询策略。
  • 大表批量更新用什么?答:bulk_update/update() 条件批量更新,避免逐行 save()。

04.7.16.5-026 页面缓存、片段缓存与低层级缓存如何选择?

一句话结论

整页缓存(cache_page)命中收益最大,只适合公开、无个性化、读多写少页面;片段缓存({% cache %})缓存页面中可复用的公共块;低层级手动缓存缓存计算结果、聚合数据、下游调用。个性化强、写频繁、实时性高的内容不进整页缓存;按页面结构拆分缓存粒度,失效时影响面最小。

概念解释

  • 缓存粒度越粗命中率越高,但一致性窗口与串号风险越大。
  • 多层缓存叠加时,每层独立失效策略需梳理。

原理流程

  1. 识别页面是否含用户专属内容与实时数据。
  2. 公开静态页整页缓存;公共侧栏/推荐块片段缓存。
  3. 聚合统计、下游结果手动缓存到低层级。
  4. 数据更新按粒度失效对应条目,避免整页刷新。

代码或图示

# 低层级:缓存聚合结果
def popular_tags():
    return cache.get_or_set("tags:popular", Tag.objects.popular, 300)

常见误区

  • 登录页面整页缓存:不同用户看到同一缓存内容。
  • 片段缓存不带用户/语言维度:变体串号。
  • 只缓存不失效:陈旧数据停留到 TTL,写频繁数据应主动清理。

追问

  • 缓存层级能叠加吗?答:能,页面 → 片段 → 数据多层,但每层都要定义失效与键维度。
  • 命中率低时降哪层?答:先收窄到低层级数据缓存,避免整页缓存分化过多变体。
  • 实时数据放哪层?答:不缓存或极短 TTL + 主动失效,关键计算直读库。

04.7.16.5-027 数据库索引与慢查询如何分析?

一句话结论

索引加速 WHERE/JOIN/ORDER BY 匹配,慢查询先看执行计划:是否走索引、扫描行数、类型扫描、临时表与排序。为高频过滤、关联、排序列建复合索引,区分区分度;避免冗余索引与过度索引拖慢写入。分析工具:数据库 EXPLAIN、慢查询日志、Django 查询计数与耗时统计。

概念解释

  • 复合索引遵循最左前缀,查询条件顺序与索引列顺序匹配才生效。
  • 索引不是越多越好:写入维护成本与存储开销随索引增长。

原理流程

  1. 从慢日志/接口定位耗时 SQL。
  2. EXPLAIN 查看访问类型、扫描行数、索引命中与排序方式。
  3. 为高频条件建/调整复合索引,改写无法走索引的条件(函数包裹列、隐式类型转换)。
  4. 上线后复查执行计划与慢查询是否下降。

代码或图示

class Post(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    created_at = models.DateTimeField()

    class Meta:
        indexes = [
            models.Index(fields=["author", "-created_at"]),
        ]

常见误区

  • 给低区分度列单独建索引:过滤效果差,占用写入成本。
  • 索引列被函数/运算包裹:索引失效,需改写条件或建表达式索引。
  • 只加索引不看执行计划:索引未被选用,扫描量未下降。

追问

  • 排序字段需要索引吗?答:ORDER BY 列与过滤列组合建复合索引,避免 filesort。
  • 联合索引列顺序怎么定?答:等值条件列在前,范围/排序列在后,按最左前缀。
  • 索引失效常见原因?答:函数包裹、隐式转换、前导通配符、OR 连接非索引列。

04.7.16.5-028 页面 P99 变高时,如何分段定位 SQL、序列化与模板渲染的耗时占比?

一句话结论

先用请求级计时把耗时切成三段:SQL(查询条数与执行时间)、Python 业务与序列化、模板渲染。占比最高的一段再往下钻:SQL 看条数放大与执行计划,模板看循环内 include 与上下文体积,序列化看是否在循环里访问 ORM 属性触发懒加载。三段是串行叠加的,只看总耗时定位不了。

概念解释

  • Django 没有开箱的分段计时,需要自埋点或依赖 APM 的 span 划分。
  • connection.queries 只在 DEBUG=True 时由 CursorDebugWrapper 记录,生产要用 execute_wrapper 或 APM。

原理流程

  1. 最外层中间件记 t0,视图返回响应后记 t1,先拿到总耗时。
  2. 包住渲染调用单独计时,得到模板耗时;render_to_string 或 TemplateResponse 渲染点都可比。
  3. SQL 侧统计查询条数与总耗时,条数异常优先查 N+1。
  4. 三段相加减去总耗时,差值即 Python 计算与服务层开销。
  5. 对占比最大的一段用采样剖析(py-spy / cProfile)确认热点函数。

代码或图示

import time
from django.db import connection
from django.template.loader import render_to_string

t0 = time.perf_counter()
html = render_to_string("order_list.html", context)
render_ms = (time.perf_counter() - t0) * 1000

sql_ms = sum(float(q["time"]) for q in connection.queries) * 1000
print({
    "render_ms": round(render_ms, 1),
    "sql_ms": round(sql_ms, 1),
    "queries": len(connection.queries),
})

生产环境改用量化埋点,避免依赖 DEBUG:

from django.db import connection

def timed_execute(execute, sql, params, many, context):
    t = time.perf_counter()
    try:
        return execute(sql, params, many, context)
    finally:
        stats["sql_ms"] += (time.perf_counter() - t) * 1000
        stats["queries"] += 1

with connection.execute_wrapper(timed_execute):
    resp = view(request)

常见误区

  • 只压测不埋点,看到 P99 升高就加机器:查询放大被掩盖,扩容只是把问题推后。
  • 把 connection.queries 留在生产:DEBUG=False 下默认不记录,强行打开会带来内存增长。
  • 只数查询条数不看单条耗时:一条缺索引的大查询同样能把 P99 拉高,两个维度都要看。

追问

  • 生产怎么稳定拿到查询条数?答:用 execute_wrapper 计数或读 APM 的 db span,不依赖 DEBUG。
  • 模板耗时怎么测才准?答:在视图外包住渲染调用取差值,别在模板内部打点。
  • 分段后每段都不高但总耗时高?答:查连接池等待、下游调用与 GC 停顿,这些发生在三段之外。

04.7.16.5-029 collectstatic 与 STATIC_ROOT 如何配合?

一句话结论

STATIC_ROOT 是收集目标目录,collectstatic 把各应用 static/ 与额外静态目录的文件复制/链接到该目录,供生产服务器或 CDN 分发;STATIC_URL 是浏览器访问静态资源的 URL 前缀。生产环境 Django 不直接服务静态文件,由 Nginx/对象存储/CDN 从 STATIC_ROOT 提供。

概念解释

  • 收集是发布步骤的一部分:代码部署后先 collectstatic 再切流量。
  • 带哈希文件名的静态文件可长期缓存,内容变更后文件名变化。

原理流程

  1. 配置 STATIC_ROOT 与 STATIC_URL。
  2. 构建/发布执行 collectstatic,汇总静态资源。
  3. Nginx/CDN 按 STATIC_URL 映射到收集目录或上传对象存储。
  4. 模板 {% static %} 标签生成带前缀的资源 URL。

代码或图示

# settings.py
STATIC_URL = "/static/"
STATIC_ROOT = BASE_DIR / "static_root"
python manage.py collectstatic --noinput

常见误区

  • 生产依赖 Django 服务静态文件:占用应用 worker,吞吐与并发下降。
  • 部署漏跑 collectstatic:页面 CSS/JS 404。
  • STATIC_ROOT 与 media 目录混用:收集过程覆盖用户上传文件。

追问

  • --noinput 做什么?答:收集时不询问覆盖确认,适合 CI/脚本。
  • 静态文件版本哈希怎么开?答:存储后端开启内容哈希,文件名带指纹便于长缓存。
  • 收集后文件要进版本库吗?答:不进,STATIC_ROOT 是生成物,发布时重新收集。

04.7.16.5-030 静态资源如何经 CDN/Nginx 分发?

一句话结论

生产拓扑:collectstatic 产物由 Nginx 直接按路径服务,或上传 CDN/对象存储;模板 STATIC_URL 指向 CDN 域名。Nginx 处理长连接、缓存头、压缩与静态资源并发,应用进程只跑业务。带内容哈希的资源可设长缓存,入口 HTML 不缓存以便及时更新引用。

概念解释

  • CDN 缓存静态资源回源策略:哈希文件不可变,长 TTL;index 页面短缓存。
  • 跨域静态资源需在 CDN/对象存储配 CORS 头。

原理流程

  1. 发布收集静态文件,同步到 Nginx 目录或上传对象存储/CDN。
  2. 浏览器按 STATIC_URL 请求资源,命中 CDN 边缘节点直接返回。
  3. 未命中回源 Nginx/对象存储,按缓存策略回填。
  4. 应用请求经反向代理到达 Django。

代码或图示

location /static/ {
    alias /var/www/ann/static_root/;
    expires 30d;
    add_header Cache-Control "public";
}

常见误区

  • 静态与动态走同一进程:worker 被资源请求占满。
  • 哈希文件名资源设短缓存:失去指纹长缓存意义。
  • CDN 回源到应用服务器:应用承压,回源应指向文件目录/对象存储。

追问

  • 模板如何引用 CDN 地址?答:STATIC_URL 配 CDN 域名,{% static %} 拼出完整 URL。
  • 静态资源更新如何刷新 CDN?答:文件名哈希变化自然引流新文件;非哈希资源需主动刷新缓存。
  • 压缩在哪里做?答:Nginx/CDN 开启 gzip/brotli,应用层不重复压缩。

04.7.16.5-031 生产环境媒体文件怎么处理?

一句话结论

用户上传的媒体文件不随应用进程服务:本地磁盘部署由 Nginx 直接映射 MEDIA_ROOT,规模上来后迁移对象存储(S3/OSS/MinIO)并经 CDN 分发;Django Storage 后端切换后业务代码不变。媒体与静态分离管理,备份与权限独立;上传目录禁止脚本执行权限。

概念解释

  • 媒体是用户运行期产物,静态是构建期产物,收集与备份策略不同。
  • 多实例部署本地磁盘不共享,必须用共享存储或对象存储。

原理流程

  1. 上传经 Storage 后端写入本地 MEDIA_ROOT 或对象存储。
  2. Nginx 映射媒体路径直出文件,或 CDN 回源对象存储。
  3. 多实例共享同一存储,避免本地磁盘各自一份。
  4. 备份媒体文件与数据库备份分开规划。

代码或图示

location /media/ {
    alias /var/www/ann/media/;
}

常见误区

  • 多副本用本地磁盘:附件只在上传节点可见,其他节点 404。
  • 媒体目录开脚本执行权限:上传恶意脚本可被执行。
  • 数据库备份包含媒体二进制:备份体积膨胀,文件应单独备份。

追问

  • 切换对象存储要改模型代码吗?答:改 Storage 后端配置,FileField.url 等接口不变。
  • 私有媒体怎么访问?答:对象存储私有读 + 临时签名 URL,或应用校验后流式下发。
  • 媒体文件能 CDN 长缓存吗?答:按文件名哈希/对象键缓存,覆盖更新需换键或刷新缓存。

04.7.16.5-032 数据库连接与 CONN_MAX_AGE 如何配置?

一句话结论

Django 持久连接由 CONN_MAX_AGE 控制:连接复用超过该秒数才关闭,减少握手与认证开销;默认 0 为每请求关闭。连接池在驱动/服务层补充,多 worker 总连接数 = worker × 池大小,必须小于数据库上限。持久连接降低延迟,但空闲连接占用服务端资源,需按并发与 DB 容量调参。

概念解释

  • Django 每请求获取连接,CONN_MAX_AGE>0 后连接在进程内复用。
  • 连接不能跨线程共享,异步/线程模型下按驱动管理连接生命周期。

原理流程

  1. 配置 CONN_MAX_AGE 与数据库连接参数。
  2. 请求需要连接时从进程复用有效连接,过期才重建。
  3. 连接持有期间占用数据库连接槽位。
  4. 监控连接数、空闲与等待,按 DB 上限调整 worker 与池大小。

代码或图示

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "CONN_MAX_AGE": 60,
        "OPTIONS": {"connect_timeout": 3},
    }
}

常见误区

  • CONN_MAX_AGE 设过长:空闲连接长期占用 DB 连接,连接数打满。
  • 只调应用侧连接数,不核对 DB max_connections:超限报错或拒绝连接。
  • 长事务持有连接过久:连接占用被拉长,并发能力下降。

追问

  • 持久连接有线程安全问题吗?答:连接按线程/协程隔离,不能跨线程复用。
  • 连接池在 Django 哪一层?答:Django 管理生命周期,池化可由驱动或外部中间件(PgBouncer)提供。
  • 连接慢怎么排查?答:看握手鉴权耗时、网络 RTT、DB 等待与连接排队。

04.7.16.5-033 异步视图在什么性能场景下有收益?

一句话结论

异步视图收益在 IO 密集等待:等待下游 API、消息、远程数据库、文件 IO 时协程挂起释放循环处理其他连接;CPU 密集或同步 ORM 为主的栈收益有限。异步链路需要组件与驱动支持,阻塞调用要包线程池;混合栈盲目异步化可能增加桥接开销而非提升吞吐。

概念解释

  • 同步 worker 阻塞时占住线程/进程,异步协程等待时不占执行线程。
  • 收益取决于等待占比:IO 等待越高,异步并发优势越明显。

原理流程

  1. 识别接口中外部等待占比与下游类型。
  2. 异步视图用异步驱动/客户端 await 等待,循环处理其他协程。
  3. 遗留同步代码经 sync_to_async 隔离到线程池。
  4. 压测对比吞吐、延迟与资源占用,决定是否保留异步实现。

代码或图示

async def merged_view(request):
    a = await fetch_remote_a()
    b = await fetch_remote_b()
    return JsonResponse({"a": a, "b": b})

常见误区

  • CPU 计算改异步:单循环被占满,不释放给其他协程。
  • 异步视图里跑同步阻塞库:卡住事件循环,需线程池包装。
  • 为追新全面异步化:存量同步组件桥接成本高,按场景逐步演进。

追问

  • 异步能减少数据库连接占用吗?答:异步驱动下连接按协程复用,连接模型与同步不同,需按驱动配置池。
  • 多个下游调用如何并行?答:asyncio.gather 并发等待,缩短总等待时间。
  • 异步部署 worker 数怎么定?答:ASGI 单循环按核数起进程,IO 密集可结合线程池容量评估。

04.7.16.5-034 批量操作如何替代循环单点写库?

一句话结论

bulk_create 一次 INSERT 多行,bulk_update 批量更新,update()/delete() 条件批量执行;循环内逐条 save() 会产生大量往返与信号触发。批量操作减少数据库交互,但绕过实例保存信号与校验,需在数据准备阶段保证合法性;大批次分批提交,避免单事务过大。

概念解释

  • 批量方法不逐实例发 SQL,往返次数从 N 降为按批次个位数。
  • 批量插入后对象主键按后端回填情况不同,后续处理需核对。

原理流程

  1. 内存中准备模型实例列表或更新字段映射。
  2. 按大小分批调用 bulk_create/bulk_update。
  3. 条件批量操作用 QuerySet.update/delete 一次执行。
  4. 每批独立提交,控制事务大小与回滚成本。

代码或图示

objs = [Note(title=t, author=user) for t in titles]
Note.objects.bulk_create(objs, batch_size=200)

Note.objects.filter(author=user).update(status="archived")

常见误区

  • 批量前没跑模型校验:绕过 full_clean,脏数据入库。
  • 依赖 post_save 信号触发副作用:批量方法不发实例保存信号,需显式处理。
  • 单批过大:长事务、锁持有久、回滚代价高,分批提交。

追问

  • bulk_create 能回填自增主键吗?答:按数据库支持情况回填,依赖主键的后续逻辑需验证。
  • 批量更新关联关系怎么做?答:m2m 用 set()/add() 批量,外键用条件 update。
  • 批量操作能走缓存失效吗?答:需要手动按条目清理相关缓存,不会自动触发信号清理。

04.7.16.5-035 如何定位慢查询与接口瓶颈?

一句话结论

分层定位:应用日志记录接口耗时与下游调用;数据库慢日志抓长 SQL 与扫描量;EXPLAIN 看执行计划;APM 串联请求各阶段。先区分是 SQL 慢、下游阻塞、渲染慢还是排队等待,再针对性优化。缺少分段计时时,先用日志在关键节点打点复现。

概念解释

  • 接口总耗时 = 排队 + 应用处理 + DB + 下游 + 渲染,各层瓶颈优化手段不同。
  • 慢 SQL 常伴随全表扫描、缺索引、回表过多与大排序。

原理流程

  1. 复现慢请求,记录时间戳与各阶段耗时。
  2. 提取 SQL 到数据库执行计划分析。
  3. 检查下游调用超时、重试与连接等待。
  4. 优化后复查慢日志与接口指标,确认下降。

代码或图示

import time, logging
logger = logging.getLogger("perf")

def timed_view(request):
    t0 = time.perf_counter()
    ...
    logger.info("elapsed=%.3f path=%s", time.perf_counter() - t0, request.path)

常见误区

  • 只看接口总时长:定位不到是 DB、下游还是渲染。
  • 慢查询只加索引不验证计划:索引可能未被选用。
  • 忽略排队等待:worker 饱和导致请求排队,表现为接口慢但单段处理不长。

追问

  • 慢查询日志开多少阈值?答:按业务基线设阈值(如超过 200ms),记录 SQL 与扫描量。
  • 如何看连接等待?答:DB 侧活跃连接、等待事件与应用侧连接池队列指标。
  • 下游慢怎么隔离?答:超时、熔断、降级与缓存,避免拖垮主链路。

04.7.16.5-036 压测关注哪些指标?瓶颈如何分层判断?

一句话结论

核心指标:QPS/吞吐、平均/P95/P99 延迟、错误率、CPU/内存/磁盘/网络、数据库连接数与慢查询、下游成功率。分层判断:CPU 饱和是计算瓶颈,DB 慢/连接满是数据层瓶颈,下游超时是外部依赖瓶颈,队列堆积是并发模型瓶颈。压测逐步加压找到拐点,对照资源水位定位最先到顶的层。

概念解释

  • 延迟尾部(P99)比平均值更反映拥塞与排队问题。
  • 拐点后吞吐不再上升而延迟陡增,说明资源触顶。

原理流程

  1. 准备代表性数据与场景脚本,逐步加压。
  2. 记录各层资源与业务指标。
  3. 找到吞吐拐点与错误率上升点。
  4. 对照 CPU/DB/下游/连接水位,定位瓶颈层并优化后复测。

代码或图示

加压 → 吞吐上升、延迟平稳
     → 某层资源触顶 → 吞吐停滞、P99 抬升、错误出现
     → 定位该层:加索引/缓存 / 扩并发 / 隔离下游

常见误区

  • 只压平均响应时间:尾部延迟与拥塞被平均掩盖。
  • 压测数据量与生产差太多:索引选择性与缓存命中率失真。
  • 单接口压测忽略共享瓶颈:DB/下游被多接口共享,整体容量需联合评估。

追问

  • worker 数压测怎么调?答:从核数经验值起步,结合线程/连接池与 CPU 水位压测确定。
  • 缓存命中率压测要记录吗?答:要,命中率下降会直接反映为 DB 压力上升。
  • 容量规划依据什么?答:峰值 QPS × 单请求资源消耗,预留冗余并留扩容空间。

04.7.16.5-037 生产配置如何与开发配置分离?

一句话结论

按环境拆分 settings:公共基础配置 + 开发/生产各自覆盖,敏感值从环境变量读取,不进版本库。常见结构:settings/base.py、settings/dev.py、settings/prod.py,通过 DJANGO_SETTINGS_MODULE 选择;生产覆盖 DEBUG、数据库、缓存、密钥、主机名、日志级别。配置变更走部署流程,代码仓库只保留模板与默认开发值。

概念解释

  • 配置与代码分离:同一镜像在不同环境读不同环境变量。
  • 环境变量适合少量键值;复杂配置可用配置中心/受控文件挂载。

原理流程

  1. 抽出公共配置到 base。
  2. 开发配置保留调试便利,生产配置加固并读环境变量。
  3. 部署时设置 DJANGO_SETTINGS_MODULE 与环境变量。
  4. 启动校验缺失必填项,避免默认值兜底到生产。

代码或图示

# settings/prod.py
from .base import *
DEBUG = False
SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]
DATABASES = {"default": {"ENGINE": "django.db.backends.postgresql",
                         "NAME": os.environ["DB_NAME"],
                         "USER": os.environ["DB_USER"],
                         "PASSWORD": os.environ["DB_PASSWORD"]}}

常见误区

  • 生产 settings 提交真实密钥:仓库历史泄露,需轮换并移出。
  • 开发默认值被生产继承:DEBUG=True、本地数据库、宽松主机名未覆盖。
  • 配置散落在多个模块硬编码:环境切换时遗漏覆盖项。

追问

  • 如何校验生产配置?答:check --deploy 与启动断言必填环境变量,缺失即拒绝启动。
  • 多环境配置放哪?答:环境变量/配置中心,仓库提供示例模板(不含真实值)。
  • 配置能热更新吗?答:Django 配置在启动期读取,变更需重启进程生效。

04.7.16.5-038 DEBUG=False 后容易踩哪些坑?

一句话结论

常见坑:静态文件不再自动服务导致 404;未配 ALLOWED_HOSTS 全站 400;模板/静态路径未收集;错误页不展示堆栈需查日志;安全 Cookie 在非 HTTPS 下不下发;部分调试中间件/工具未关闭。上线前用生产配置完整跑一遍请求链路,核对静态、登录、表单提交与错误响应。

概念解释

  • DEBUG 同时影响调试页、静态服务、主机校验与部分行为分支。
  • 问题常在“开发正常、生产报错”时暴露,需要预发环境复现。

原理流程

  1. 预发以生产配置启动。
  2. 走通静态资源、登录、表单、上传、错误页链路。
  3. 核对响应头、Cookie 与日志记录。
  4. 修复配置缺口后再切生产流量。

代码或图示

DJANGO_SETTINGS_MODULE=myapp.settings.prod python manage.py check --deploy

常见误区

  • 预发仍 DEBUG=True:生产特有问题未被发现。
  • 只检查首页:登录态、POST、上传等分支在生产配置下行为不同。
  • 错误时只看浏览器:生产堆栈在服务日志/错误上报中。

追问

  • 静态 404 怎么排查?答:确认 collectstatic 已跑、Nginx 映射 STATIC_ROOT、STATIC_URL 一致。
  • 400 主机错误怎么定位?答:核对请求 Host 与 ALLOWED_HOSTS,代理转发保留正确主机头。
  • 生产需要 debug-toolbar 吗?答:默认关闭,仅受控内网临时开启,不随生产配置启用。

04.7.16.5-039 WSGI 生产部署拓扑是什么样的?

一句话结论

典型拓扑:浏览器 → Nginx(反向代理、静态/媒体直出、TLS 终止、负载均衡)→ gunicorn/uWSGI(WSGI 应用服务器,多 worker 跑 Django)→ 数据库/缓存/下游。Nginx 处理连接与静态资源,WSGI 服务器跑 Python 业务进程;worker 数按 CPU 核数与内存估算,静态文件不经过应用进程。

概念解释

  • WSGI 是同步调用协议,适合传统同步 Django 栈。
  • 应用服务器不直接对外暴露,由 Nginx 统一入口与连接管理。

原理流程

  1. Nginx 终止 TLS,按路径分流:静态/媒体本地直出,动态请求代理到应用。
  2. gunicorn 拉起多个 worker 进程/线程处理请求。
  3. worker 加载 Django WSGI 应用,执行中间件与视图链。
  4. 结果经 Nginx 返回客户端,应用不直接处理长连接静态资源。

代码或图示

gunicorn myapp.wsgi:application --workers 4 --bind 127.0.0.1:8000
location / {
    proxy_pass http://127.0.0.1:8000;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Proto $scheme;
}

常见误区

  • 应用服务器直接绑公网:缺少 TLS、连接管理与静态分流。
  • worker 数远大于核数:上下文切换加剧,内存与连接打满。
  • Nginx 不传主机/协议头:应用生成错误 URL,安全 Cookie 判断异常。

追问

  • gunicorn worker 模型怎么选?答:默认 sync 适合一般同步栈;IO 阻塞场景可考虑线程/异步 worker 按下游类型评估。
  • 单个 worker 内存上限怎么管?答:监控 RSS,必要时 --max-requests 重启回收泄漏。
  • 多个应用实例怎么接 Nginx?答: upstream 列表多实例,Nginx 按负载策略转发。

04.7.16.5-040 ASGI 部署与 WSGI 有什么差异?

一句话结论

ASGI 部署用 uvicorn/hypercorn 等异步服务器跑 Django ASGI 应用,支持异步视图、WebSocket、长连接;WSGI 是同步逐请求模型。混合栈中 ASGI 服务器可跑同步视图并经线程池隔离,异步视图直接在事件循环执行。进程数按核数起,线程池容量控制同步代码并发;选型取决于是否用异步特性与长连接。

概念解释

  • ASGI 协议支持连接级生命周期,WebSocket 等长连接是 WSGI 无法原生承载的。
  • 同步 ORM/阻塞调用在异步循环中必须隔离到线程池,避免卡循环。

原理流程

  1. 构建 ASGI 应用(myapp.asgi:application)。
  2. uvicorn 起事件循环进程,按需多进程。
  3. 异步协程直接 await;同步视图经线程池执行。
  4. 长连接在 ASGI 连接生命周期内保持,Nginx 代理 WebSocket 升级头。

代码或图示

uvicorn myapp.asgi:application --workers 4 --host 127.0.0.1 --port 8000

常见误区

  • 纯同步栈强行上 ASGI:额外桥接无收益,WSGI 部署更简单。
  • 异步视图混入阻塞库:事件循环被卡住,并发不升反降。
  • Nginx 未配 WebSocket 升级头:长连接握手失败。

追问

  • 一个进程能并发多少协程?答:受事件循环与下游/连接约束,协程轻量但共享单循环 CPU。
  • ASGI 下静态文件谁服务?答:仍由 Nginx/CDN 直出,应用服务器不服务静态。
  • 同步与异步视图能共存吗?答:能,ASGI 服务器按视图类型调度,阻塞部分进线程池。

04.7.16.5-041 发布流程中静态文件与产物怎么处理?

一句话结论

发布顺序:拉代码 → 安装依赖 → 收集静态文件(collectstatic)→ 跑迁移 → 重启应用 → 切流量。静态产物随版本发布到对应目录或上传 CDN/对象存储,文件名带哈希便于缓存;多实例共享静态目录或共享存储,避免各实例版本不一致。构建期产物不进 Git,由发布流水线生成。

概念解释

  • 静态文件与代码版本绑定:新前端引用新哈希文件,旧 HTML 缓存窗口内可兼容。
  • 迁移与代码发布顺序需兼容:旧代码能跑新迁移结构,避免上线即报错。

原理流程

  1. 流水线在构建环境安装依赖并 collectstatic。
  2. 静态产物同步到共享目录/对象存储/CDN。
  3. 应用包部署到实例,执行迁移后重启。
  4. 灰度切流,核对静态资源版本与页面引用一致。

代码或图示

python manage.py collectstatic --noinput
python manage.py migrate
systemctl restart gunicorn

常见误区

  • 先切流量再收集静态:新页面引用的资源尚不存在。
  • 各实例本地收集不同步:资源版本混杂,部分页面 404。
  • 覆盖共享目录未按版本隔离:回滚时静态资源与代码版本错位。

追问

  • 静态资源回滚怎么做?答:目录按版本保留,回滚代码同时切回对应静态版本;对象存储保留旧键。
  • CDN 缓存旧资源怎么办?答:哈希文件名自然引流新文件;非哈希路径主动刷新。
  • 依赖安装在发布哪一步?答:构建期锁定安装,运行实例使用同一环境,避免现场解析版本。

04.7.16.5-042 迁移与代码发布的先后顺序怎么安排?

一句话结论

稳妥策略:先部署兼容旧结构的新代码 → 跑迁移 → 再全量切新功能;或先跑向后兼容的迁移(加列/加表、旧字段保留),再发布代码,最后清理旧结构。破坏性变更(删列/改类型)分两次发布:先双写兼容,再切换读取,最后删除旧列。避免“新代码依赖尚未执行的迁移”与“迁移依赖新代码才存在的数据”。

概念解释

  • 发布期可能新旧版本进程并存,数据库结构必须同时兼容两侧代码。
  • 不可逆迁移与数据回填要可回滚、可分批。

原理流程

  1. 评估迁移是否破坏旧代码可读结构。
  2. 兼容期先加后删:新增列/表并存,新旧代码都能工作。
  3. 迁移分批回填大表数据,避免长锁。
  4. 结构清理在后续版本单独执行。

代码或图示

变更步骤:加新列(兼容)→ 发布代码双写 → 回填数据 → 切读新列 → 删旧列

常见误区

  • 一次发布内删旧列再上代码:回滚时旧代码读不到列。
  • 大表迁移一次性锁表回填:写入阻塞,应分批在线回填。
  • 迁移里写业务逻辑依赖新模型:迁移环境与运行环境耦合,难以独立执行。

追问

  • 回滚时代码与迁移怎么办?答:迁移未做不可逆删除,回滚代码可继续跑在兼容结构上。
  • 多实例发布顺序?答:滚动期间所有实例兼容当前结构,迁移在兼容窗口执行。
  • 数据量大的回填怎么做?答:分批脚本/任务按主键区间更新,记录进度与可中断点。

04.7.16.5-043 应用如何做到优雅重启与平滑退出?

一句话结论

优雅重启:进程收到信号后停止接收新连接,处理完在途请求再退出,新进程接管流量。WSGI/ASGI 服务器支持 worker 平滑退出;部署用滚动重启或 reload,避免硬杀导致请求中断。配合负载均衡摘除实例、连接池关闭、后台任务收尾;短请求优先,长任务/异步任务有独立退出策略。

概念解释

  • 硬重启(kill -9)丢弃在途请求,可能造成写操作中断与连接错误。
  • 优雅退出要处理:请求完成、数据库连接归还、临时资源释放、后台任务标记。

原理流程

  1. 部署向进程发终止信号,服务器停止 accept 新连接。
  2. 等待在途请求处理完成(受退出超时约束)。
  3. 关闭连接池与临时资源,进程退出。
  4. 新进程启动并注册健康检查,LB 摘除旧实例后再下线。

代码或图示

gunicorn --graceful-timeout 30 myapp.wsgi:application

常见误区

  • 重启不经过 LB 摘除:旧实例还在接流量时被 kill。
  • 退出超时过短:在途请求被强制中断。
  • 长事务/导出任务与 Web 进程同生命周期:重启打断,应放后台任务系统。

追问

  • 后台任务退出怎么保证?答:任务消费线程收到信号后停止拉取,处理完当前批次再退出。
  • 连接池重启要清空吗?答:进程退出时归还/关闭连接,避免服务端残留空闲连接。
  • 滚动发布期间版本不一致怎么办?答:兼容结构与接口,新旧版本可并存。

04.7.16.5-044 健康检查端点如何设计?LB 如何探活?

一句话结论

健康检查区分存活探针(进程是否活着)与就绪探针(能否接流量:数据库、缓存、下游依赖可用)。轻量存活检查不查依赖,避免依赖抖动导致反复重启;就绪检查核对关键依赖后再纳入 LB 轮询。端点不泄露内部细节,可配置独立路径与鉴权;实例启动未就绪时不接流量,退出前先摘流量。

概念解释

  • 存活失败重启进程;就绪失败只摘流量,不重启。
  • 检查频率与超时按发布/抖动窗口设置,避免探针风暴。

原理流程

  1. 暴露 /health/live:返回进程状态与基本配置加载情况。
  2. /health/ready:探测数据库、缓存等关键依赖连通性。
  3. LB 按就绪探针纳入/摘除实例。
  4. 依赖恢复后就绪转绿,重新接流量。

代码或图示

def ready(request):
    check_db()
    check_cache()
    return HttpResponse("ok", status=200)

常见误区

  • 存活检查查数据库:DB 抖动时实例被反复重启,雪上加霜。
  • 检查端点公开内部状态:泄露版本、依赖地址与配置。
  • 探针超时与业务超时混用:慢依赖拖垮探活判断。

追问

  • 健康检查要鉴权吗?答:对内网 LB 可放行路径,对外不暴露敏感详情。
  • 下游非关键依赖失败算不健康吗?答:按降级策略区分,关键依赖未就绪摘流量,非关键可降级保留。
  • 启动慢怎么配合探针?答:设置启动宽限期,就绪探针通过前不接流量。

04.7.16.5-045 生产环境密钥与配置如何管理?

一句话结论

密钥(SECRET_KEY、数据库密码、第三方 Token、上报 DSN)走环境变量、密钥管理服务或受控挂载文件,不写代码、不进镜像层、不进日志;按环境隔离,定期轮换。配置项区分公开参数与敏感凭证,仓库只存示例模板;访问密钥遵循最小权限,审计读取记录。

概念解释

  • 镜像不可变:构建不含环境密钥,启动时注入。
  • 泄露处置:先轮换使旧值失效,再清理残留(仓库历史、日志、镜像层)。

原理流程

  1. 部署平台按环境注入密钥到进程环境/挂载文件。
  2. 应用启动读取,缺失必填项拒绝启动。
  3. 运行期不在日志、响应、上报上下文输出密钥。
  4. 定期轮换密钥,更新注入配置后滚动重启。

代码或图示

import os
DB_PASSWORD = os.environ.get("DB_PASSWORD")
if not DB_PASSWORD:
    raise RuntimeError("DB_PASSWORD 未配置")

常见误区

  • 密钥写在 settings 默认值:随仓库与镜像分发。
  • 备份/日志/错误上报夹带密钥:二次泄露面扩大。
  • 多环境共用一套密钥:一处泄露波及全部环境。

追问

  • 密钥轮换后旧会话怎么办?答:签名密钥轮换使旧会话/令牌失效,用户重新登录,属预期影响。
  • 配置文件怎么加密?答:受控存储加密或由配置中心下发,解密密钥与业务数据分离管理。
  • 第三方回调签名密钥放哪?答:环境变量/密钥服务,代码只引用变量名。

04.7.16.5-046 LOGGING 如何配置级别、处理器与格式?

一句话结论

Django 日志配置:LOGGING 定义 logger(命名空间与级别)、handler(控制台/文件/ syslog/上报)、formatter(时间、级别、模块、消息、请求标识)。生产 INFO 起步、关键错误 WARNING/ERROR,避免 DEBUG 落盘过大;按模块调整级别,格式带请求 ID 便于串联;处理器轮转与容量限制防止磁盘写满。

概念解释

  • 级别过滤在 logger 与 handler 两层生效,向上传播需注意重复记录。
  • 结构化日志便于采集检索,消息中不拼敏感字段。

原理流程

  1. 定义 formatter:时间、级别、logger 名、消息、请求/用户标识。
  2. 配置 handler:输出目标、级别、轮转/容量。
  3. 挂接 logger 到 handler,设置级别与传播开关。
  4. 运行期按日志量与告警级别调整。

代码或图示

LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {"simple": {"format": "%(asctime)s %(levelname)s %(name)s %(message)s"}},
    "handlers": {"console": {"class": "logging.StreamHandler", "formatter": "simple"}},
    "root": {"handlers": ["console"], "level": "INFO"},
}

常见误区

  • 生产开 DEBUG 全量日志:磁盘暴涨、敏感信息落盘。
  • 未设轮转:单文件持续增长占满磁盘。
  • logger 传播重复到多个 handler:同一条日志重复记录多次。

追问

  • 请求 ID 怎么带?答:中间件生成/读取请求标识存入线程局部,formatter 读取附加。
  • 数据库慢查询记在哪?答:Django 数据库日志/慢查询日志,应用日志补充接口维度。
  • 日志级别怎么定?答:ERROR 触发告警,WARNING 关注,INFO 记录关键流程,DEBUG 仅开发。

04.7.16.5-047 错误上报(Sentry 等)如何接入?

一句话结论

接入方式:SDK 在启动期初始化 DSN 与环境标识,捕获未处理异常、记录前后端错误与性能事件;Django 中间件/集成自动附加请求、用户与模板上下文。上报前过滤敏感数据(密码、令牌、Cookie),按环境区分采样率;告警按错误级别与影响面分级,避免海量重复噪音。

概念解释

  • 上报是补充:服务端日志仍保留,第三方平台用于聚合、分组与告警。
  • DSN 本身是写入凭证,按环境配置,不进前端公开包。

原理流程

  1. 启动期初始化 SDK,设置环境、版本、采样率。
  2. 异常被 Django 错误链捕获,SDK 收集上下文后上报。
  3. 敏感字段在 before-send 过滤器剔除。
  4. 平台分组展示堆栈与影响次数,按规则告警。

代码或图示

import sentry_sdk
sentry_sdk.init(dsn=os.environ.get("SENTRY_DSN"), environment="prod", release="1.2.0")

常见误区

  • 上报上下文带密码/Cookie:敏感数据进入第三方平台。
  • 全量采样错误:平台配额与告警噪音过载,关键错误优先。
  • 只看上报不保留本地日志:上报丢失/限流时无法回溯。

追问

  • 404 要上报吗?答:通常不计为异常,可单独统计扫描/爬取噪声。
  • 异步任务错误怎么上报?答:任务框架集成 SDK,捕获任务异常并附加任务标识。
  • 上报超时会不会拖垮业务?答:SDK 异步发送,超时/失败不阻断主流程。

04.7.16.5-048 容量规划看哪些维度?

一句话结论

按峰值 QPS、单请求 CPU/内存/连接消耗、下游与数据库容量估算:实例数 = 峰值负载 / 单实例可持续容量,预留冗余;核对数据库连接上限、缓存容量、磁盘(日志/媒体/备份)、带宽与文件句柄。压测得到单实例拐点,结合发布冗余、故障副本与增长趋势规划,上线后按监控回调。

概念解释

  • 容量不是只看 CPU:连接数、内存、下游配额常先于 CPU 触顶。
  • 峰值与平均差距大,按峰值而非均值规划。

原理流程

  1. 压测得到单实例 QPS、延迟、资源水位与拐点。
  2. 统计业务峰值 QPS 与增长预期。
  3. 反推实例数、连接数、缓存/磁盘/带宽需求。
  4. 预留故障冗余,监控水位并定期复盘调整。

代码或图示

单实例可持续 QPS → 实例数 = 峰值 QPS / 单实例 QPS × 冗余系数
连接数 = 实例数 × 单实例连接池 < 数据库上限

常见误区

  • 按平均流量规划:峰值时段资源打满。
  • 只扩应用不扩数据库:连接与慢查询成为瓶颈。
  • 忽略日志/媒体磁盘增长:运行期磁盘写满导致服务中断。

追问

  • 单实例内存怎么估?答:基线 RSS × worker 数 + 缓存/对象预留,监控泄漏趋势。
  • 突发流量怎么应对?答:水平扩容预案 + 限流降级,缓存削峰。
  • 容量复盘周期?答:按业务增长与大促节点定期复盘,监控水位触发扩容。

04.7.16.5-049 进程管理用什么方式?

一句话结论

传统主机用 systemd 或 supervisor 守护应用进程:开机拉起、崩溃重启、日志归集;容器环境由容器编排调度进程生命周期,应用以前台进程运行。进程管理负责拉起与重启,应用服务器(gunicorn/uvicorn)管理内部 worker;配置工作目录、用户、环境变量与资源限制,避免以 root 跑业务。

概念解释

  • systemd 管整机服务单元,supervisor 管多进程守护,容器编排管副本与调度。
  • 应用不自行 fork 后台常驻,生命周期交给外层管理器。

原理流程

  1. 定义服务单元:启动命令、工作目录、用户、环境变量。
  2. 管理器拉起应用服务器,内部按配置起 worker。
  3. 进程退出按策略重启,日志输出到标准输出由外部采集。
  4. 资源限制与重启策略按故障类型配置。

代码或图示

[Service]
WorkingDirectory=/var/www/ann
User=www-data
ExecStart=/usr/local/bin/gunicorn myapp.wsgi:application --workers 4
Restart=on-failure

常见误区

  • 以 root 运行业务进程:提权风险,降权到专用用户。
  • 管理器与应用服务器双层 fork:进程归属混乱,重启信号传不到 worker。
  • 日志写应用本地文件:容器/多实例归集困难,应输出标准输出统一采集。

追问

  • 容器里还要 supervisor 吗?答:一般单容器单进程,编排负责重启,无需内层守护。
  • 崩溃重启怎么限频?答:配置重启策略与退避,避免崩溃循环打满机器。
  • 环境变量在哪注入?答:服务单元/编排配置注入,不写进启动脚本提交仓库。

04.7.16.5-050 反向代理转发要配置哪些头?

一句话结论

Nginx 代理转发必须传递:Host(原始主机)、X-Forwarded-Proto(原始协议)、X-Forwarded-For(客户端 IP 链)、X-Forwarded-Host;Django 侧配合 USE_X_FORWARDED_HOST 与 SECURE_PROXY_SSL_HEADER 识别原始协议。头配置错误会导致生成错误绝对 URL、安全 Cookie 判断失败、取到代理 IP 而非真实客户端 IP。

概念解释

  • 代理头是信任边界:只信任可信代理设置的头,公网入站应覆盖伪造头。
  • SECURE_PROXY_SSL_HEADER 指定从哪个头判定 HTTPS,需与代理配置一致。

原理流程

  1. Nginx proxy_set_header 传递主机、协议、IP 链。
  2. Django 读取代理头还原请求协议与主机。
  3. 视图/中间件按还原后的协议生成 URL、判断安全 Cookie。
  4. 取真实 IP 时按可信代理链解析 X-Forwarded-For 最右可信段。

代码或图示

proxy_set_header Host $host;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
USE_X_FORWARDED_HOST = True
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")

常见误区

  • 不传 Host:应用生成 127.0.0.1 绝对链接,回调域名错误。
  • 误信公网伪造的 X-Forwarded-Proto:只在可信代理后解析该头。
  • 取客户端 IP 直接读头第一段:可被伪造,应从可信代理链尾部解析。

追问

  • X-Forwarded-For 格式?答:客户端 IP, 代理1, 代理2,应用按可信代理范围取真实地址。
  • 代理层做了 HTTPS 终止,应用怎么知道是 HTTPS?答:读 X-Forwarded-Proto,配置 SECURE_PROXY_SSL_HEADER。
  • WebSocket 代理要加什么头?答:Upgrade 与 Connection 升级头,Nginx 对应配置。

04.7.16.5-051 Django 测试基类如何分层选择?

一句话结论

TestCase 用事务包裹、速度快,适合绝大多数模型/视图/服务单测;TransactionTestCase 不包裹事务,需要提交、回滚、裸提交行为或 flush 场景时使用;LiveServerTestCase 起真实开发服务器,配合浏览器自动化做端到端;SimpleTestCase 不触数据库,适合纯工具/表单逻辑。按是否需要真实事务提交、是否需要浏览器选择基类,避免为简单场景用重型基类。

概念解释

  • 基类决定测试数据库事务隔离与服务器启动方式。
  • 端到端测试慢且脆弱,只覆盖关键链路,业务逻辑尽量在单元层覆盖。

原理流程

  1. 判断测试是否访问数据库、是否需要提交事务、是否需要浏览器。
  2. 无 DB 用 SimpleTestCase;普通 DB 测试用 TestCase。
  3. 事务边界/提交副作用用 TransactionTestCase;浏览器链路用 LiveServerTestCase。
  4. 每个用例后按基类策略回滚/重置数据。

代码或图示

from django.test import TestCase, TransactionTestCase, LiveServerTestCase

class NoteTest(TestCase):
    ...

class MigrationTest(TransactionTestCase):
    ...

class CheckoutE2E(LiveServerTestCase):
    ...

常见误区

  • 所有测试继承 TransactionTestCase:每用例 flush 重建数据,套件变慢。
  • TestCase 里测试需要真实提交的逻辑:事务未提交,观察不到外部可见副作用。
  • 浏览器测试断言业务规则:逻辑应在单元测试覆盖,E2E 只跑主流程。

追问

  • SimpleTestCase 能查库吗?答:不能,访问数据库会报错,用于纯函数与表单校验。
  • 测试顺序有保证吗?答:同文件内按定义顺序,用例间不依赖执行顺序与残留数据。
  • 异步视图用什么基类?答:Django 测试客户端支持异步调用,按视图类型选择对应的异步测试写法。

04.7.16.5-052 TestCase 的事务包裹与回滚机制是什么?

一句话结论

TestCase 在每个用例外层开事务,用例内 ORM 操作都在该事务中;用例结束后回滚整个事务,不真正提交数据库,因此快且互不污染。用例内嵌套 atomic() 保存点被回滚到外层;需要观察提交后行为(信号 transaction.on_commit、外部系统读取)时,普通 TestCase 看不到,需 TransactionTestCase 或测试内显式控制事务。

概念解释

  • 回滚替代删除:避免逐条清理测试数据,速度远高于 flush。
  • on_commit 回调在外层事务未提交时不执行。

原理流程

  1. 测试启动,外层事务开始。
  2. 用例执行,模型写入处于未提交状态。
  3. 断言查询只看到本用例数据。
  4. 结束后回滚外层事务,下一个用例从零开始。

代码或图示

from django.test import TestCase

class NoteTest(TestCase):
    def test_create(self):
        Note.objects.create(title="t")
        self.assertEqual(Note.objects.count(), 1)
    # 用例结束事务回滚,下一个用例数据为空

常见误区

  • 依赖 on_commit 回调在 TestCase 内触发:未提交,回调不执行。
  • 用例间共享状态:回滚后前一个用例数据不存在,不能跨用例依赖。
  • 在测试里手动 commit:破坏外层包裹,数据清理行为异常。

追问

  • 如何测试 on_commit 回调?答:用 TransactionTestCase 或在测试中提交事务后断言回调副作用。
  • 保存点是什么?答:嵌套 atomic() 创建的回滚点,外层回滚一并撤销。
  • 事务回滚能重置自增 ID 吗?答:不能,自增序列按数据库规则推进,数据回滚但 ID 不复用。

04.7.16.5-053 什么场景必须用 TransactionTestCase?

一句话结论

需要真实提交与回滚的场景:测试 transaction.on_commit 回调、测试迁移/数据回填脚本、观察数据库约束或触发器真实生效、用裸连接手动管理事务、每个用例需要 flush 重建全量数据。代价是每个用例后重置数据库,套件变慢;能用 TestCase 隔离就不用它。

概念解释

  • TransactionTestCase 关闭外层事务包裹,用例数据在结束后 flush/重置。
  • 外部系统(消息队列、搜索索引)只能读到已提交数据,对应场景必须真实提交。

原理流程

  1. 识别被测逻辑是否依赖“提交后可见”的副作用。
  2. 选用 TransactionTestCase,用例内操作真实提交。
  3. 断言提交后触发的回调/约束/外部读取。
  4. 用例结束重置数据,下一个用例独立。

代码或图示

from django.test import TransactionTestCase

class CommitSideEffectTest(TransactionTestCase):
    def test_on_commit_runs(self):
        with transaction.atomic():
            order = Order.objects.create()
            transaction.on_commit(lambda: publish(order))
        # 事务已提交,回调执行
        ...

常见误区

  • 只测模型字段校验却用事务基类:白白付出 flush 成本。
  • 多个 TransactionTestCase 用例串联:重置导致前一个数据不可见。
  • 外部副作用未清理:提交后消息/索引残留,污染后续用例。

追问

  • 能不能在 TestCase 里手动提交验证回调?答:会破坏包裹,规范做法是换事务基类或隔离测试。
  • flush 会重置哪些对象?答:表数据、自增序列按基类策略重置。
  • 性能上怎么权衡?答:把必须提交的少数用例单独放事务基类,其余保持 TestCase。

04.7.16.5-054 LiveServerTestCase 与浏览器自动化怎么配合?

一句话结论

LiveServerTestCase 在测试进程内启动真实 HTTP 服务器(随机端口),用例通过 self.live_server_url 拼地址,接入 Selenium/Playwright 等驱动打开页面、操作元素、断言页面状态。适合验证登录、下单、表单提交等关键端到端链路;环境需装浏览器与驱动,测试慢且对前端选择器稳定度敏感。

概念解释

  • 它起的是真实服务器与真实 HTTP 连接,覆盖静态、Cookie、重定向完整链路。
  • 浏览器驱动需要与环境浏览器版本匹配,CI 中以服务/容器提供。

原理流程

  1. 基类启动开发服务器,提供基础 URL。
  2. 测试初始化浏览器驱动,访问页面。
  3. 模拟点击、输入、提交,等待关键元素/状态。
  4. 断言页面文本、URL、数据库变化,结束关闭驱动与服务器。

代码或图示

from django.test import LiveServerTestCase
from selenium.webdriver import Chrome

class CheckoutTest(LiveServerTestCase):
    def test_submit(self):
        driver = Chrome()
        driver.get(self.live_server_url + "/notes/")
        driver.find_element("id", "title").send_keys("hello")
        driver.find_element("id", "submit").click()
        self.assertIn("hello", driver.page_source)
        driver.quit()

常见误区

  • 用例间不关闭浏览器:驱动进程与会话残留,后续用例串状态。
  • 断言前不等待异步渲染:元素未出现导致偶发失败。
  • 把 E2E 当主要测试网:前端选择器/网络波动导致套件脆弱,单元层应覆盖逻辑。

追问

  • 端口怎么分配?答:基类自动选可用端口,URL 经属性获取,不写死。
  • E2E 数据库怎么准备?答:测试数据库与基类重置机制一致,工厂数据在用例内创建。
  • CI 跑浏览器测试要什么?答:无头浏览器、驱动/服务、显示环境隔离。

04.7.16.5-055 pytest-django 如何组织测试与 fixture?

一句话结论

pytest-django 把 pytest fixture 体系接入 Django:db marker 显式允许用例访问数据库,client fixture 提供测试客户端,django_user_model/settings 等 fixture 覆盖配置;用例用函数式风格或类组织,fixture 按作用域复用数据构造。相比 Django 基类,fixture 依赖更显式,参数化与复用更灵活;项目可混用 Django 测试工具与 pytest 插件。

概念解释

  • 未标 db 的用例默认禁库,防止意外访问。
  • fixture 作用域(function/class/module)控制数据复用与清理时机。

原理流程

  1. 安装插件并配置 Django settings 路径。
  2. 用例加 @pytest.mark.django_db 或依赖 db fixture。
  3. 复用 client、user 等 fixture,自定义工厂 fixture 造数据。
  4. 用例断言响应与模型状态,fixture 结束按作用域清理。

代码或图示

import pytest

@pytest.mark.django_db
def test_note_create(client, django_user_model):
    user = django_user_model.objects.create_user(username="u", password="p")
    client.force_login(user)
    resp = client.post("/notes/", {"title": "t"})
    assert resp.status_code == 302

常见误区

  • 忘记 db marker:用例访问数据库报错。
  • fixture 作用域过大:跨用例残留数据导致偶发失败。
  • 依赖隐式全局状态:应通过 fixture 显式传入用户、客户端与数据。

追问

  • Django 原生 TestCase 能在 pytest 下跑吗?答:能,插件兼容 Django 测试类与工具。
  • 如何临时改配置?答:settings fixture 用 settings.DEBUG = False 局部覆盖,结束还原。
  • 命令行怎么指定用例?答:pytest 按路径/节点选择,--reuse-db 可加速重复运行。

04.7.16.5-056 测试数据库如何创建与迁移?

一句话结论

测试运行时从配置数据库克隆/创建测试库,按迁移状态建表;--keepdb 复用测试库加速重复运行,--migrate/--disable-migrations 控制是否跑迁移。测试库与开发库隔离,用例数据在基类策略下重置;迁移本身需要专门测试验证,关闭迁移直接建表不能替代迁移正确性检查。

概念解释

  • 首次建库执行全部迁移,后续复用可跳过重建。
  • 禁用迁移用模型当前状态建表,速度快,但不验证迁移脚本。

原理流程

  1. 测试启动读取数据库配置,生成测试库名。
  2. 创建测试库并按迁移(或当前模型)建表。
  3. 用例运行,数据隔离与重置按基类执行。
  4. 结束按策略销毁或保留测试库。

代码或图示

python manage.py test --keepdb
python manage.py test --disable-migrations

常见误区

  • 关闭迁移跑全部测试:迁移错误未被发现,生产迁移风险累积。
  • 测试库名与开发库混淆:配置隔离错误会污染开发数据。
  • --keepdb 后模型变更未重建:表结构与模型不同步。

追问

  • 迁移怎么单独测?答:保留跑迁移的测试环境/用例,验证升级降级与数据回填。
  • 测试库连接配置怎么改?答:测试运行按框架规则生成测试库,连接参数从 DATABASES 派生。
  • 并行测试会冲突吗?答:按框架并行机制分配独立测试库/分片,避免共用同一库。

04.7.16.5-057 工厂工具(Factory Boy)如何造测试数据?

一句话结论

工厂类封装模型默认字段与依赖关系,用 Factory/SubFactory 批量生成合法实例,避免测试内手写重复字段与关联对象。测试按需覆盖单个字段,批量造列表用 Factory.create_batch(n);工厂负责默认合法值,测试关注点是被测状态而非数据拼装。复杂关联在工厂内收敛,减少用例重复。

概念解释

  • 工厂生成的对象已通过模型默认约定,仍可在测试中调整状态。
  • 持久化(create)与内存(build)两种模式按需选择。

原理流程

  1. 为模型定义工厂:默认字段、子工厂关联、懒生成值。
  2. 用例调用工厂生成用户、文章等基础数据。
  3. 覆盖必要字段构造特定场景。
  4. 批量场景用批次方法造多对象,断言行为。

代码或图示

import factory

class UserFactory(factory.django.DjangoModelFactory):
    username = factory.Sequence(lambda n: f"user{n}")
    password = factory.PostGenerationMethodCall("set_password", "p")

    class Meta:
        model = "auth.User"

class NoteFactory(factory.django.DjangoModelFactory):
    author = factory.SubFactory(UserFactory)
    title = "note"

    class Meta:
        model = "notes.Note"

常见误区

  • 工厂堆砌过多默认规则:测试需要的场景被默认值掩盖。
  • 关联对象在工厂外散落创建:数据准备逻辑不可复用。
  • 批量生成未控制数量:测试数据集过大拖慢套件。

追问

  • 工厂会跑模型校验吗?答:create 持久化到测试库,模型约束生效;build 仅内存构造。
  • 唯一约束怎么避免冲突?答:Sequence/懒值生成唯一用户名、编码。
  • 与测试 fixture 怎么配合?答:工厂作为 fixture 内部调用,用例拿生成好的对象。

04.7.16.5-058 视图测试如何用测试客户端发请求并断言?

一句话结论

Client 模拟请求不经真实网络:get/post/put/delete 带路径、数据、头与会话;断言状态码、重定向、模板、上下文、响应内容与模型变化。测试覆盖正常分支、权限拒绝、表单校验失败与错误响应;URL 用反向解析 reverse,避免硬编码路径导致改版漏测。

概念解释

  • 客户端经过中间件与视图链,可验证认证、CSRF 相关测试策略。
  • 响应上下文与模板在测试环境可直接访问断言。

原理流程

  1. 准备用户与前置数据。
  2. 客户端发起请求,携带表单/JSON/查询参数。
  3. 断言状态码、重定向地址、模板名与上下文对象。
  4. 核对数据库变化与消息/会话状态。

代码或图示

from django.test import Client
from django.urls import reverse

def test_create_note(client, user):
    client.force_login(user)
    resp = client.post(reverse("note-create"), {"title": "t"})
    assert resp.status_code == 302
    assert Note.objects.filter(author=user, title="t").exists()

常见误区

  • 只断言 200 不断业务结果:页面成功但数据未写入。
  • 硬编码路径:URL 改版后测试与页面脱节。
  • 未覆盖未登录/越权分支:权限回归漏测。

追问

  • 怎么测 JSON 接口?答:content_type="application/json" 发 body,解析 resp.json() 断言字段。
  • 上传文件怎么测?答:客户端传 SimpleUploadedFile,断言字段与落盘对象。
  • 如何断言用了哪个模板?答:resp.template_name 或 assertTemplateUsed。

04.7.16.5-059 认证与权限如何在测试中模拟?

一句话结论

force_login 直接建立测试会话,跳过密码校验,适合已认证视图测试;login(username, password) 走真实认证流程,验证后端与凭证;未认证用例不登录直接请求。权限测试构造用户、组与 Permission,断言 has_perm 与视图拒绝状态码;越权用例用他人对象直连,校验归属过滤生效。

概念解释

  • force_login 只设会话身份,不验证密码与后端规则;login 调用 authenticate。
  • 权限对象按内容类型绑定模型,测试中需正确关联。

原理流程

  1. 工厂创建用户,按场景附加组/权限。
  2. 用 force_login 或 login 建立身份。
  3. 请求受保护视图,断言 200/302/403 与查询集过滤。
  4. 构造越权主键,确认他人对象不可访问。

代码或图示

def test_staff_only(client, user):
    client.force_login(user)
    resp = client.get(reverse("admin-panel"))
    assert resp.status_code == 403

def test_owner_access(client, other_user, note):
    client.force_login(other_user)
    resp = client.get(reverse("note-edit", args=[note.pk]))
    assert resp.status_code == 404

常见误区

  • 用 login 但未正确造密码:认证失败,误判视图问题。
  • 只测有权限角色:未测匿名与无权限角色被拒。
  • 越权测试用同一用户:无法验证对象级归属。

追问

  • 测登录流程本身用哪个?答:login 走认证后端,或发登录表单 POST 验证完整链路。
  • 权限批量授予怎么做?答:用户 user_permissions.add(...) 或通过组关联。
  • 会话在测试间隔离吗?答:客户端会话随用例重置,不跨用例残留。

04.7.16.5-060 如何做性能与查询数量断言?

一句话结论

测试中用 assertNumQueries 限定视图/操作产生的 SQL 次数,防止回归引入 N+1;结合工厂数据规模复现真实列表大小,断言预取生效。性能基线可记录单接口耗时与关键操作次数,CI 中守护查询数量;耗时断言受环境波动影响,更适合在压测环境度量,测试套件以查询数与逻辑正确性为主。

概念解释

  • 查询数断言防 ORM 回归:关联访问新增而未预取时用例失败。
  • 断言阈值需留合理余量,避免数据规模变化导致误报。

原理流程

  1. 准备有代表性的多条关联数据。
  2. assertNumQueries 包裹请求/操作。
  3. 断言查询次数在上限内,核对返回结果正确。
  4. 慢接口在压测环境跑耗时与资源指标,不把强耗时断言放进单测。

代码或图示

from django.test import TestCase, assertNumQueries

class NoteListTest(TestCase):
    def test_list_queries(self):
        NoteFactory.create_batch(10)
        with assertNumQueries(2):
            self.client.get(reverse("note-list"))

常见误区

  • 用单条数据断言查询数:N+1 在规模下才暴露,应造多条关联数据。
  • 查询数阈值过死:合理优化后次数变化误报,按场景复核。
  • 单测里断言毫秒耗时:环境抖动导致套件不稳定,耗时交给压测。

追问

  • 怎么统计实际查询?答:测试内访问 connection.queries,或开发期用 debug-toolbar/日志。
  • 缓存命中影响查询数吗?答:会,断言时区分冷缓存与热缓存场景,固定前提。
  • 性能回归怎么纳入 CI?答:关键接口查询数断言守门,周期性压测对比耗时与吞吐。

本节高频题

  • 04.7.16.5-002:CSRF token 配对校验流程与豁免边界。
  • 04.7.16.5-004:模板自动转义与 |safe 的使用风险。
  • 04.7.16.5-005:ORM 参数化与原生 SQL 注入风险点。
  • 04.7.16.5-007:SECURE_* 安全配置清单与 HSTS。
  • 04.7.16.5-009:ALLOWED_HOSTS 校验与 DEBUG 关系。
  • 04.7.16.5-010:SECRET_KEY 泄露后果、管理与轮换。
  • 04.7.16.5-011:密码哈希算法、迭代成本与旧哈希升级。
  • 04.7.16.5-014:会话 Cookie 安全属性逐项配置。
  • 04.7.16.5-019:安全中间件顺序与依赖关系。
  • 04.7.16.5-020:水平/垂直越权场景与防御手段。
  • 04.7.16.5-022:check --deploy 部署基线检查范围。
  • 04.7.16.5-024:select_related/prefetch_related 消除 N+1。
  • 04.7.16.5-026:页面/片段/低层级缓存的粒度选择。
  • 04.7.16.5-027:索引与慢查询执行计划分析。
  • 04.7.16.5-029:collectstatic 与 STATIC_ROOT 配合。
  • 04.7.16.5-032:持久连接 CONN_MAX_AGE 与连接数估算。
  • 04.7.16.5-039:gunicorn + Nginx WSGI 生产拓扑。
  • 04.7.16.5-040:ASGI 与 WSGI 部署差异及选型。
  • 04.7.16.5-042:迁移与代码发布顺序及兼容策略。
  • 04.7.16.5-052:TestCase 事务包裹与回滚机制。
  • 04.7.16.5-055:pytest-django fixture 与 db marker。
  • 04.7.16.5-060:查询数量断言与性能回归守护。