AI 爬虫把大学图书馆站点拖垮:按行为指纹给爬虫分类、按类发配额、用边缘缓存分层,以带宽成本结构和真实用户 P95 延迟定档

凌晨两点,某大学图书馆的统一检索入口 P95 从常态的百毫秒量级滑到秒级,全文下载开始超时。值班同学打开访问日志,最前面几行写着 GPTBot/1.2,于是加了一条 UA 黑名单。流量安静了四十分钟,然后以 Mozilla/5.0 (compatible; research-bot) 的名字重新出现,速率和刚才一模一样。

第二次修得更狠:整段云厂商 IP 拉黑。第二天早上 Googlebot 也进不来了,期刊详情页在搜索结果里被标成"无法访问",投诉来自学科馆员。

两次操作共享同一个假设:能靠 User-Agent 或 IP 归属地认出"是谁",就能决定"给不给"。这个假设在很多年前就站不住了。UA 是客户端自己随便写的字符串,校验成本为零;云厂商的 IP 段里同时住着 AI 训练爬虫、合法的学术聚合服务和一部分校园出口。

下面要解决的是一个比"封 IP"更窄的问题:只用站点自己就能采集到的访问日志,把进来的流量分成几类,按类发不同配额,并用两个可测量的量------出口带宽成本和真实用户 P95 延迟------决定每一类放在哪一档。不解决的部分也要说清楚:它不替你判断"AI 训练抓取应不应该被允许",那是馆藏政策与法律问题;本文只提供把那个判断执行下去的技术路径,以及执行错了怎么回退。

1. 先分清四类流量,再谈拦不拦

把"爬虫"当成一个整体来限流,是这件事最先出错的地方。同样一兆字节的出口带宽,来自四类客户端的回报完全不同,把它们塞进同一个令牌桶,等于用平均值去解一个代价高度不对称的问题。

搜索引擎爬虫 带来检索流量回链。它的抓取频率稳定、跟随分页、会读 robots.txt、会发条件请求。这一类必须做身份验证而不是信任:对来源 IP 做反向 DNS,结果必须落在 googlebot.com / google.com / search.msn.com 这类域名下,再对解析出的主机名做一次正向解析,确认拿回同一个 IP,两步都过才算。UA 里写着 Googlebot 的一律不算。

AI 训练抓取是一次性、深度、大批量的遍历,一次任务可能把整个馆藏目录犁一遍。它拿走的字节和搜索引擎一样多,但不带回任何点击。

AI 检索代理由用户提问触发,几秒内取三五页,取完把来源引在你的页面上。单次成本很低,丢掉它意味着图书馆的目录从 AI 回答里消失------对公共服务机构来说这是个真实的损失。

恶意抓取高并发、直打检索 API 或全文接口、大量 404,通常是商业转售或训练数据倒卖。它不读 robots,也不在乎 429。

类别 到达形态 单次请求成本 站点得到的回报 首选手段
搜索引擎 低频稳定、跟随分页 中(HTML) 检索流量回链 验身后大配额,只排队不拒绝
AI 训练抓取 高频稳定、深度遍历、偏爱 PDF 高(大字节) 无 字节配额,超额降级为只读缓存
AI 检索代理 短时突发、只取被引用的那一页 低 被引用、被链接 小配额 + 429
恶意抓取 高并发、直打 API、扫 404 高(不可缓存) 无 402/403 + 连接层限速

表里最容易被漏掉的是"单次请求成本"这一列。图书馆站点的字节分布是双峰的:书目页与查找工具页 50 KB 上下,全文 PDF 从几 MB 到几十 MB。一次 8 MB 的 PDF 抓取,按字节是 50 KB 书目页的一百六十倍,按请求数都只算一次。配额单位如果跟着请求数走,训练抓取会被系统性低估两个数量级。

2. 从访问日志还原行为指纹

nginx 默认日志给的是 IP、时间、方法、路径、状态码、字节数、UA、Referer,CDN 日志再加一列缓存状态。这些字段足够还原行为,前提是会话的键不能是 IP。爬虫队列入站时会轮换 IP,按 IP 建会话等于给每个新 IP 重新发一桶配额,它在日志里被切成几百份,永远不超额。

把键换成(IP 归属类型,UA 族),轮换就失效了:换 IP 不换 ASN,换 IP 也很少换 UA 族。

特征要选那些"换 IP 换不掉"的:

  • 到达间隔的变异系数(CV)。批量训练的节奏由调度器决定,间隔几乎恒定,CV 接近 0;用户触发的检索代理是"几秒内连着几下,然后长时间静默",CV 远大于 1。
  • 速率与并发。只看速率会漏掉"低速率、高并发"的爬虫------每秒 2 个请求但开 200 条连接,对 origin 的压力和每秒 400 个请求差不多。
  • 首段路径的香农熵 。遍历站点地图的爬虫熵高且均匀;对着 /api/search 猛打的熵接近 0,但绝对量很大。
  • PDF 占比与 404 占比。前者区分训练抓取和索引抓取,后者是扫描器最明显的指纹。
  • 条件请求命中率 。搜索引擎大量使用 If-None-Match,命中后返回 304,这类会话自己就把 origin 字节压得很低;朴素爬虫从不发条件请求。
  • 会话的绝对量。同样来自云厂商:3 秒 5 个请求更像检索代理,6 小时 5 万个请求只能是批量任务。

没有任何单一特征能定性。分类器的真实形态是一张混淆矩阵,工程上要做的是接受它,并把"错判的代价"设计成不对称的:把搜索引擎误判成恶意抓取,代价是站点从搜索索引里掉出去,要好几天才恢复;反过来只是多花一点带宽。所以没把握时,默认放进不拦的那一类。

下面这段把上面六条固化成可检查的结构。Session 的键是(ASN 类型,UA 族),classify 的返回值里带一个判据字符串,写回日志,用于日后复核分类是否发生漂移。

python 复制代码
from __future__ import annotations

import math
from collections import Counter
from dataclasses import dataclass, field
from datetime import datetime, timedelta


@dataclass(frozen=True)
class Hit:
    ts: datetime
    path: str
    status: int
    nbytes: int
    asn_kind: str                       # "datacenter" | "residential"
    verified_bot: str | None = None     # 正向 DNS 两步都过才有值


@dataclass
class Session:
    """键是 (ASN 类型, UA 族),不是 IP ------ 换 IP 不换这两样。构造前按 ts 排序。"""
    hits: list[Hit] = field(default_factory=list)

    @property
    def n(self) -> int:
        return len(self.hits)

    @property
    def span_s(self) -> float:
        if self.n < 2:
            return 1.0
        return max(1.0, (self.hits[-1].ts - self.hits[0].ts).total_seconds())

    @property
    def rps(self) -> float:
        return self.n / self.span_s

    @property
    def gap_cv(self) -> float:
        gaps = [(b.ts - a.ts).total_seconds() for a, b in zip(self.hits, self.hits[1:])]
        if len(gaps) < 2:
            return float("inf")
        mu = sum(gaps) / len(gaps)
        if mu == 0:
            return 0.0
        var = sum((g - mu) ** 2 for g in gaps) / len(gaps)
        return math.sqrt(var) / mu

    @property
    def path_entropy(self) -> float:
        seg = Counter(h.path.split("/")[1] if "/" in h.path[1:] else "" for h in self.hits)
        return -sum((c / self.n) * math.log2(c / self.n) for c in seg.values())

    @property
    def pdf_share(self) -> float:
        return sum(h.path.endswith(".pdf") for h in self.hits) / self.n

    @property
    def error_share(self) -> float:
        return sum(h.status in (403, 404) for h in self.hits) / self.n

    @property
    def verified(self) -> str | None:
        ids = {h.verified_bot for h in self.hits}
        return ids.pop() if len(ids) == 1 else None


def classify(s: Session) -> tuple[str, str]:
    """返回 (类别, 判据)。判据写回日志,用来事后复核分类是否漂移。"""
    if s.verified in ("googlebot", "bingbot"):
        return "search_engine", "fcrdns"
    if s.n < 20:
        # 样本不足时一律不拦:这一个方向上错判的代价不可逆
        return "ai_retrieval", "too-few-samples"
    if s.error_share > 0.3:
        return "hostile", "scan"
    if s.rps > 5 and s.gap_cv < 0.4 and s.pdf_share > 0.3:
        return "ai_training", "steady+pdf"
    if s.rps > 20 and s.path_entropy < 1.5:
        return "hostile", "api-hammer"
    return "ai_retrieval", "fallback"


BASE = datetime(2026, 3, 1, 2, 0, 0)


def _sess(n: int, step_s: float, jitter_s: float = 0.0, path: str = "/item/{i}",
          status: int = 200, nbytes: int = 40_000,
          asn: str = "datacenter", bot: str | None = None) -> Session:
    hits = [
        Hit(ts=BASE + timedelta(seconds=i * step_s + jitter_s * (i // 2)),
            path=path.format(i=i), status=status, nbytes=nbytes,
            asn_kind=asn, verified_bot=bot)
        for i in range(n)
    ]
    return Session(hits)


def demo() -> None:
    engine = _sess(400, 2.0, path="/journal/{i}", bot="googlebot")
    trainer = _sess(400, 0.1, path="/fulltext/{i}.pdf", nbytes=8_000_000)
    agent = _sess(60, 0.05, jitter_s=3.0, path="/record/{i}")
    scanner = _sess(300, 0.05, path="/api/search?q={i}", status=404)

    assert classify(engine) == ("search_engine", "fcrdns")
    assert classify(trainer)[0] == "ai_training"
    assert classify(agent)[0] == "ai_retrieval"
    assert classify(scanner)[0] == "hostile"
    assert classify(_sess(5, 1.0))[0] == "ai_retrieval"

最难的一格是检索代理与定向爬虫 :两者都来自云厂商,UA 都不轮换,单 IP 的请求数都不高,速率、熵、CV 全落在同一区间。真正的区分点是抓什么------检索代理抓的是"能被引用"的那一页(题录页、摘要页、目录页),定向爬虫直接冲 /fulltext/*.pdf。所以 pdf_share 在这两类之间不是辅助特征,是主判据。承认这一格的准确率上不去,比假装它准确要好,后面的配额设计就是围绕这个不确定性做的。

3. robots.txt 是声明,429 与 402 才是执行

RFC 9309(2022 年 9 月)把 robots.txt 定义成一个自愿遵守的协议。自愿这两个字决定了它的位置:它是政策声明和事后举证材料,不是限流器。一个每小时抓十万次、但每次规规矩矩先读 robots.txt 的客户端,和一个根本不读的客户端,在 robots.txt 面前的差别是零。

所以治理分三层,缺任何一层都会在某个时刻断掉。政策层是 robots.txt 加使用条款,写清楚哪类允许、哪类需要申请、哪类禁止。执行层是配额、缓存分层和状态码,真正让带宽降下来的是这一层。举证层是原始日志与分类结果,真要走到合同或法律那一步,你需要的是"某 IP 在某时段的行为记录",而不是一份 robots.txt。

状态码经常被混为一谈,它们的含义不同:

  • 429 Too Many Requests(RFC 6585)是重试契约:"你现在超了,等 Retry-After 秒再来"。合规客户端会退避,所以它适合用在你想保留的类上。
  • 403 Forbidden 是排除声明,适合你已经决定不要、且没有付费通道的类。
  • 402 Payment Required 在 RFC 9110 §15.5.3 里被列为"保留",协议没有定义自动客户端收到它应该做什么。Cloudflare 在 2025 年 7 月推出 pay-per-crawl,把 402 用作"付费才能抓"的信号,那是商业协议层面的约定,不是协议赋予的语义。给一个没有接入付费流程的爬虫返 402,它不会因此开始付钱,你只会在日志里多一列状态码。

Google 的两个 token 也常被搞混:Googlebot 管搜索索引,Google-Extended 管 Gemini 的训练与 grounding。在 robots.txt 里 disallow Google-Extended 不影响站点出现在搜索结果里。把这两个当成一个,是"为了挡住训练抓取、顺手把搜索也关掉"这类事故的常见来源。

还有一条实操细节:拒绝必须带 Retry-After,批量类不小于 60 秒。给 5 秒的 Retry-After 等于把 429 变成放大器------合规客户端会立刻重试,origin 承受的压力反而比不限流时更高。

4. 带宽成本结构决定配额的单位

请求数是错误的口径。origin 的真实成本可以拆成两项:未命中边缘缓存的字节 × 出口单价,加上未命中请求占用的 CPU。对图书馆这种以静态大文件为主的站点,第一项是大头。

缓存分层是这里唯一能改变数量级的手段:

  • 静态资源(JS/CSS/封面图):文件名带内容指纹,Cache-Control: public, max-age=31536000, immutable。
  • 全文 PDF:内容寻址、文件不变,同样一年加 immutable。一个 PDF 被不同爬虫抓五百次,origin 只出一次带宽。这是整个方案里收益最大的一条,也是最容易被忽略的一条------很多站点把 PDF 当动态资源处理。
  • 题录与详情页 HTML:短 TTL,s-maxage=120, stale-while-revalidate=600(RFC 5861)。这里要盯住 Vary 头:一旦为了"我的账户"片段把 Vary: Cookie 加到全局,缓存会被打碎成每用户一份,命中率掉到接近零,后面所有配额都失去意义。个人化片段应该走独立的、明确不缓存的接口。
  • 检索 API 与结果页:不可缓存,每次穿透。

这里有个结构性错配:最容易缓存的内容(PDF、静态页)正是训练爬虫最想要的,最难缓存的(检索 API)正是恶意抓取最爱打的。两类流量的边际成本曲线形状完全不同,配额单位也必须不同------可缓存路径按字节计,不可缓存路径按请求数加权计。

下面这段把成本口径固化成函数。它不做逐请求模拟,只做按类型的聚合折算,目的是回答一个问题:同样 200 个请求,PDF 抓取和 API 抓取在账单上差多少。单价按公开的数据传输定价量级取,实际结算以合同为准。

python 复制代码
EGRESS_YUAN_PER_GB = 0.50          # 量级参考值,替换成自己合同里的单价

# 内容类型 -> 边缘 TTL 秒;0 表示不可缓存
TIERS: dict[str, int] = {"asset": 31_536_000, "pdf": 31_536_000, "html": 120, "search": 0}


def tier_of(path: str) -> str:
    if path.startswith("/static/"):
        return "asset"
    if path.endswith(".pdf"):
        return "pdf"
    if path.startswith("/api/"):
        return "search"
    return "html"


def origin_bytes(s: Session, hit_ratio: dict[str, float]) -> int:
    """只有穿透边缘缓存的请求才产生出口带宽。"""
    out = 0.0
    for h in s.hits:
        t = tier_of(h.path)
        out += h.nbytes if TIERS[t] == 0 else h.nbytes * (1 - hit_ratio[t])
    return int(out)


def daily_yuan(sessions: list[Session], hit_ratio: dict[str, float]) -> float:
    total = sum(origin_bytes(s, hit_ratio) for s in sessions)
    return total / 1024 ** 3 * EGRESS_YUAN_PER_GB


def cost_demo() -> None:
    hit = {"asset": 0.99, "pdf": 0.95, "html": 0.80, "search": 0.0}
    pdfs = _sess(200, 0.5, path="/fulltext/{i}.pdf", nbytes=8_000_000)
    apis = _sess(200, 0.5, path="/api/search?q={i}", nbytes=20_000)

    a, b = origin_bytes(pdfs, hit), origin_bytes(apis, hit)
    assert a > 15 * b, (a, b)                       # 请求数相同,字节成本差一个数量级以上
    assert daily_yuan([pdfs], hit) > 15 * daily_yuan([apis], hit)
    assert origin_bytes(pdfs, {**hit, "pdf": 1.0}) == 0   # 全命中时 origin 带宽为零

这张账单还有个直接用途:配额怎么分,本质上是在这张账单上做分配。先算出真实用户需要多少 origin 容量,剩下的才是可分配额度;没有账单,配额就只能靠拍脑袋。

5. 分类、配额与状态码的最小实现

#mermaid-svg-R7GCUMm3KGIxJNTe{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-R7GCUMm3KGIxJNTe .error-icon{fill:#552222;}#mermaid-svg-R7GCUMm3KGIxJNTe .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-R7GCUMm3KGIxJNTe .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-R7GCUMm3KGIxJNTe .marker{fill:#333333;stroke:#333333;}#mermaid-svg-R7GCUMm3KGIxJNTe .marker.cross{stroke:#333333;}#mermaid-svg-R7GCUMm3KGIxJNTe svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-R7GCUMm3KGIxJNTe p{margin:0;}#mermaid-svg-R7GCUMm3KGIxJNTe .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-R7GCUMm3KGIxJNTe .cluster-label text{fill:#333;}#mermaid-svg-R7GCUMm3KGIxJNTe .cluster-label span{color:#333;}#mermaid-svg-R7GCUMm3KGIxJNTe .cluster-label span p{background-color:transparent;}#mermaid-svg-R7GCUMm3KGIxJNTe .label text,#mermaid-svg-R7GCUMm3KGIxJNTe span{fill:#333;color:#333;}#mermaid-svg-R7GCUMm3KGIxJNTe .node rect,#mermaid-svg-R7GCUMm3KGIxJNTe .node circle,#mermaid-svg-R7GCUMm3KGIxJNTe .node ellipse,#mermaid-svg-R7GCUMm3KGIxJNTe .node polygon,#mermaid-svg-R7GCUMm3KGIxJNTe .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-R7GCUMm3KGIxJNTe .rough-node .label text,#mermaid-svg-R7GCUMm3KGIxJNTe .node .label text,#mermaid-svg-R7GCUMm3KGIxJNTe .image-shape .label,#mermaid-svg-R7GCUMm3KGIxJNTe .icon-shape .label{text-anchor:middle;}#mermaid-svg-R7GCUMm3KGIxJNTe .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-R7GCUMm3KGIxJNTe .rough-node .label,#mermaid-svg-R7GCUMm3KGIxJNTe .node .label,#mermaid-svg-R7GCUMm3KGIxJNTe .image-shape .label,#mermaid-svg-R7GCUMm3KGIxJNTe .icon-shape .label{text-align:center;}#mermaid-svg-R7GCUMm3KGIxJNTe .node.clickable{cursor:pointer;}#mermaid-svg-R7GCUMm3KGIxJNTe .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-R7GCUMm3KGIxJNTe .arrowheadPath{fill:#333333;}#mermaid-svg-R7GCUMm3KGIxJNTe .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-R7GCUMm3KGIxJNTe .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-R7GCUMm3KGIxJNTe .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-R7GCUMm3KGIxJNTe .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-R7GCUMm3KGIxJNTe .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-R7GCUMm3KGIxJNTe .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-R7GCUMm3KGIxJNTe .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-R7GCUMm3KGIxJNTe .cluster text{fill:#333;}#mermaid-svg-R7GCUMm3KGIxJNTe .cluster span{color:#333;}#mermaid-svg-R7GCUMm3KGIxJNTe div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-R7GCUMm3KGIxJNTe .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-R7GCUMm3KGIxJNTe rect.text{fill:none;stroke-width:0;}#mermaid-svg-R7GCUMm3KGIxJNTe .icon-shape,#mermaid-svg-R7GCUMm3KGIxJNTe .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-R7GCUMm3KGIxJNTe .icon-shape p,#mermaid-svg-R7GCUMm3KGIxJNTe .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-R7GCUMm3KGIxJNTe .icon-shape .label rect,#mermaid-svg-R7GCUMm3KGIxJNTe .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-R7GCUMm3KGIxJNTe .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-R7GCUMm3KGIxJNTe .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-R7GCUMm3KGIxJNTe :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 命中
未命中
连续 3 个窗口超阈值
入站请求
边缘缓存命中?
返回边缘副本

origin 带宽为 0
10 分钟滚动窗口

key = ASN 类型 + UA 族
classify()
search_engine
ai_training
ai_retrieval
hostile
大配额桶

超额只排队,永不 403
字节配额桶

超额: cache_only → 402
小配额桶

超额: 429 + Retry-After 60
不计配额

402 或 403
origin 分级队列

真用户保留 30% 并发
双点 P95 探针

origin / edge
先砍 T 类 50%

再砍 A 类

图里有三条不变量,比代码本身重要:

  1. 已验身的搜索引擎永不被 403。 超额只排队、不拒绝。这不是礼貌------403 的代价不可逆,页面从索引里掉出去要好几天才回来,而排队只是慢一点。
  2. 未知流量默认进最宽松的不拦类。 分类器一定会错,要做的是让错的方向落在便宜的那一侧。
  3. 拒绝带 Retry-After,批量类不小于 60 秒。 否则 429 是放大器而不是闸门。

计价单位也要单独定义:PDF 与静态资源按 KB 计,检索 API 按更高的权重计,权重按单次请求的 origin CPU 成本标定。下面用 10 只是占位,真实值应该从你自己的火焰图里取。没有这个折算,"一次 PDF 抓取"和"一次 API 查询"会被当成同一件事记账。

python 复制代码
from enum import Enum


class Action(str, Enum):
    ALLOW = "allow"
    CACHE_ONLY = "cache_only"
    RATE_LIMIT = "429"
    PAYMENT = "402"
    BLOCK = "403"


# 每类的 (桶容量, 每秒补充),单位是下面 meter() 折算后的计价单位
QUOTA: dict[str, tuple[float, float]] = {
    "search_engine": (200_000, 40_000),
    "ai_retrieval":  (20_000, 4_000),
    "ai_training":   (60_000, 8_000),
    "hostile":       (0, 0),
}


class Bucket:
    def __init__(self, capacity: float, refill: float) -> None:
        self.capacity = capacity
        self.tokens = capacity
        self.refill = refill

    def take(self, cost: float) -> bool:
        if self.tokens >= cost:
            self.tokens -= cost
            return True
        return False


def meter(h: Hit) -> float:
    kb = h.nbytes / 1024
    return kb * 10 if h.path.startswith("/api/") else kb


def decide(cls: str, bucket: Bucket, cost: float,
           origin_p95_ms: float, p95_target_ms: float) -> tuple[Action, int]:
    """返回 (动作, Retry-After 秒)。"""
    if cls == "hostile":
        return (Action.PAYMENT if cost > 1024 else Action.BLOCK), 0
    if bucket.take(cost):
        return Action.ALLOW, 0
    if cls == "search_engine":
        return Action.ALLOW, 30                       # 已验身:只排队,永不拒绝
    if cls == "ai_training":
        return (Action.CACHE_ONLY if origin_p95_ms <= p95_target_ms
                else Action.PAYMENT), 0
    return Action.RATE_LIMIT, 60


def quota_demo() -> None:
    pdf_cost = meter(Hit(BASE, "/fulltext/1.pdf", 200, 8_000_000, "datacenter"))
    b = Bucket(*QUOTA["ai_training"])

    assert decide("ai_training", b, 25_000, 200, 400) == (Action.ALLOW, 0)
    assert decide("ai_training", b, 25_000, 200, 400) == (Action.ALLOW, 0)
    assert decide("ai_training", b, 25_000, 200, 400)[0] is Action.CACHE_ONLY
    assert decide("ai_training", b, 25_000, 900, 400)[0] is Action.PAYMENT
    assert decide("ai_retrieval", Bucket(*QUOTA["ai_retrieval"]), 10 ** 9, 200, 400)[0] is Action.RATE_LIMIT
    assert decide("hostile", Bucket(0, 0), pdf_cost, 200, 400)[0] is Action.PAYMENT
    assert decide("search_engine", Bucket(*QUOTA["search_engine"]), 10 ** 9, 900, 400)[0] is Action.ALLOW

注意 cache_only 这个动作。它表示:能在边缘命中就返回,命中不了才返 429。好处是"超额"不等于"断供"------一个已经被缓存的 PDF 让训练爬虫再取一次,边际成本接近零,没有理由拒绝;真正该拦的是穿透到 origin 的那部分。这一条把配额从"总开关"变成了"分流阀",也让后文的 P95 控制回路有了可用的调节粒度。

6. 真实用户 P95 是唯一该拿来定档的护栏

容量控制最常犯的错,是把"总容量没超"当成"服务正常"。

origin 能同时处理 200 个请求。如果其中 190 个是爬虫,利用率 95%,看板上一片绿;但真实用户的请求要排在 190 个爬虫请求之后,P95 会直接崩掉。在这个场景里,占用率是误导性指标,排队延迟才是。带宽账单降下来了而 P95 没降,说明瓶颈不在字节而在队列调度。

所以配额不是一个全局数字,而是一个带保留位的分级队列:给"带本站会话 Cookie 的请求"留出固定比例的 origin 并发(例如 30%),任何爬虫类都不许占用这部分。这个保留位不需要识别"人",只需要识别"带我们发的 Cookie",实现成本很低。

要诚实说明它的缺口:首次访问的用户没有 Cookie,会落进共享池,仍然可能被挤。补法是给无 Cookie 请求一个更小的队列等待上限,超时返回一个轻量页面而不是让它继续排队。

P95 要测两个点,缺一不可:

  • origin P95,只统计未命中缓存的请求。它反映队列是否拥堵,是控制回路的输入。
  • edge P95,统计全部请求。它才是用户感知到的数,是验收口径。

控制回路按"先砍谁"排序:连续 3 个 1 分钟窗口超阈值,先砍 AI 训练抓取 50%,观察两个窗口;不够再砍 AI 检索代理;搜索引擎和保留位永远不参与。恢复要慢,每 5 分钟放回 10%,否则会在阈值附近来回抖,爬虫那边看到的是一串忽开忽关的 429,行为更难预测。

砍训练抓取先,是因为它每字节的回报最低,砍掉的损失可以用"反正它本来也不带流量"来衡量。不砍检索代理,是因为它本身用量小,砍掉的边际带宽收益低,而代价(从 AI 回答里消失)是长期的、不可即时观测的。

7. 验收口径:三个指标和四个失败模式

分类准确率。 从一天日志里分层抽 200 个会话(按 ASN 类型分层,别只抽头部),人工标注,算每一类的精确率与召回率。可接受的标准是不对称的:搜索引擎这一类要求精确率接近 1,错一个的代价不可逆;AI 训练与恶意抓取要求召回率优先,漏掉一个只是多花带宽;检索代理与定向爬虫这一格允许明显更低的准确率,因为这两者本来就是同一种客户端行为在不同目的下的表现。

缓存命中与出口字节。 按内容类型分别看命中率,再看每一类每天的 origin 出口字节。判据是:抓取总量不变的前提下,出口字节应当下降。如果没有下降,先查 Vary 和 TTL,而不是去加配额------加配额是在为一个缓存配置错误付双份钱。

真实用户 P95 与 429 率。 测量点、目标值、回退规则要在上线前写死。回退必须是配置级的:分类表和配额表都是边缘上的一份配置,一次发布就能回到上一版,而不是改代码重新部署。

四个优先排查的失败模式:

  1. Vary 过宽导致缓存碎片化。 症状是 HTML 命中率接近 0,所有配额同时失效。这是最常见的"越优化越慢"。
  2. Retry-After 太短。 症状是 429 数量不降反升,origin 压力比限流前更高。
  3. 配额按 IP 计。 症状是同一个爬虫的用量在日志里被切成几百份,桶永远不满,配额形同虚设。
  4. 分类窗口太短。 爬虫每个窗口压到阈值以下、再爆发一次,会在两类之间反复横跳。加迟滞:一个会话连续 30 分钟不出现,才释放它的类别标签。

验证顺序是离线回放 → 灰度 → 全量。离线回放只能证明分类器在历史数据上成立,证明不了缓存和控制回路------那两部分必须灰度:在边缘用 5% 流量跑 24 小时,比对 P95 与 429 率,再决定是否全量。把离线回放当成端到端验证,是这个项目里最容易犯的自我欺骗。

8. 适用边界

住宅代理会让整套指纹失效。 按 ASN 类型的判断,在抓取方买了住宅代理池之后几乎没有区分力------那些 IP 看起来和校园网用户一模一样。这种情况下能用的只剩速率与路径特征,准确率会明显下降,需要把阈值调保守,并接受更高的误伤。这是这套方法最硬的天花板。

重度个人化的站点不适合这套缓存分层。 如果大部分页面都带用户态,命中率上不去,成本模型里的 (1 - hit_ratio) 接近 1,配额就成了唯一手段,而配额只能限速不能降本。

"恶意"这个词得先定义。 有些高频抓取方是签了合同的聚合服务,对它们正确的响应是合同和专用凭据,不是 403。按 ASN 拉黑还会误伤同一云上的无关租户,写规则时要把这条显式承认下来。

还有一条不属于技术范围但必须在这里说:是否允许 AI 训练抓取,是馆藏政策问题。对一所公立大学的图书馆,允许训练抓取意味着馆藏进入商业模型的训练集,禁止则意味着自己的目录从 AI 回答里消失------两边都有真实的利益相关方。技术上正确的做法是把开关做出来、把默认值写进文档、把每次变更记进日志,而不是由运维在凌晨两点替全馆做决定。

本文没有覆盖:JS 挑战与验证码(它们会破坏无障碍访问,对公共服务站点代价很高)、WAF 特征规则的具体写法、以及法律层面的追索流程。

总结

定档的顺序是固定的。先用缓存分层消掉"本来可以不花的字节",再用行为指纹把剩下的流量分四类,再按类发不同单位的配额,最后用真实用户 P95 决定收紧到什么程度。跳过第一步直接上配额,写的是为本来可以免费命中的字节服务的调度代码。

三个判断可以直接拿走。配额单位跟着成本走:可缓存路径按字节,不可缓存路径按加权请求数。拒绝方式跟着关系走:要保留的类给 429 加不短于 60 秒的 Retry-After,决定排除的类才给 403,402 是商业信号不是限流手段。未知流量默认不拦,因为误判搜索引擎的代价不可逆。

失效条件同样清楚:住宅代理、重度个人化页面,以及把有合同的合作方当成恶意爬虫。这三条任一成立,本文的阈值都要重标。

参考资料

  1. RFC 9309: Robots Exclusion Protocol(2022-09)--- https://www.rfc-editor.org/rfc/rfc9309.html
  2. RFC 9110: HTTP Semantics,§15.5.3 关于 402 的保留状态 --- https://www.rfc-editor.org/rfc/rfc9110.html
  3. RFC 6585: Additional HTTP Status Codes,429 的定义 --- https://www.rfc-editor.org/rfc/rfc6585.html
  4. RFC 9111: HTTP Caching --- https://www.rfc-editor.org/rfc/rfc9111.html
  5. RFC 5861: HTTP Cache-Control Extensions for Stale Content --- https://www.rfc-editor.org/rfc/rfc5861.html
  6. Google Search Central: Verify Googlebot(反向+正向 DNS 两步验证)--- https://developers.google.com/search/docs/crawling-indexing/verifying-googlebot
  7. Google Search Central: Google crawlers and user-triggered fetchers(含 Google-Extended)--- https://developers.google.com/search/docs/crawling-indexing/overview-google-crawlers
  8. Google Search Central: Introduction to robots.txt --- https://developers.google.com/search/docs/crawling-indexing/robots/intro
  9. OpenAI: GPTBot 说明与 robots.txt 控制方式 --- https://platform.openai.com/docs/gptbot
  10. Anthropic: 站点如何控制 Claude 爬虫 --- https://support.anthropic.com/en/articles/8896518-does-anthropic-crawl-data-from-the-web-and-how-can-site-owners-block-the-crawler
  11. Cloudflare: Introducing pay per crawl(2025-07,402 作为付费抓取信号)--- https://blog.cloudflare.com/introducing-pay-per-crawl/
  12. Common Crawl: CCBot 说明 --- https://commoncrawl.org/ccbot
  13. IETF HTTPAPI: RateLimit header fields 草案 --- https://datatracker.ietf.org/doc/draft-ietf-httpapi-ratelimit-headers/
  14. AWS S3 定价页,Data Transfer OUT 一节(出口带宽计价方式)--- https://
相关推荐
碧海银沙音频科技研究院28 分钟前
BP寻呼机原理
人工智能·嵌入式硬件
万俟淋曦42 分钟前
[ROS 系列学习教程] 建模与仿真 - 使用 ros_control 控制六轴串联机械臂
人工智能·ai·机器人·ros·机械臂·robotics·具身智能
IT_陈寒1 小时前
Vue开发者必知:5个让你效率翻倍的隐藏技巧
前端·人工智能·后端
深蓝AI5 小时前
12000 名工程师的高盛,只用四个月就收回了交易员的 AI 编程权限
人工智能·程序员
怕浪猫9 小时前
这个十几个agent 协作项目值得关注
人工智能·面试·github
starzy199010 小时前
深入理解Scala隐式类:扩展方法机制
开发语言·人工智能·scala
深蓝AI11 小时前
为什么 agent 的 demo 都很惊艳,上了生产就不靠谱
人工智能·程序员
数字新视界11 小时前
信创动环监控在机房环境管理中的智能化应用与实践分析
大数据·人工智能·物联网·信息与通信·动环监控系统
岁月宁静11 小时前
DeepSeek Harness 实战与架构解析:让 Agent 从“会聊”到“能交付”
人工智能·python·agent