把恶意爬虫变成剧场观众：Dead Internet Theater 搭建指南

1. 从恶意爬虫到一场诗意实验：项目背景与核心思路

做后端和内容平台的开发者，多少都遇到过这一类问题：服务器日志里出现大量陌生 UA（User-Agent），爬虫程序高频率请求页面，抓取内容、占用带宽、伪造流量，甚至对接口发起攻击。尤其是近一两年，基于 AI 的爬虫越来越多，它们伪装成正常的搜索引擎，或者干脆伪装成真人浏览器，让人难以分辨。

但换个角度看，这些爬虫其实也是“网络流量”。如果我们识别出它们，并且不只是一刀切地封禁，而是给它们一点“特别的内容”，会发生什么？

“Dead internet theater”这个项目就是这样一个很有意思的尝试：把恶意 AI 爬虫引导到一个由静态页面构成的“剧场”中，让它们在抓取时得到一篇由程序生成的、带有诗意的文本。换句话说，我们不和爬虫硬碰硬，不和它们比速度、比并发，而是把它们变成一次行为艺术的一部分。

听起来有点抽象，下面先把项目的核心思路拆开：

• 恶意 AI 爬虫：指那些不遵守 robots.txt、不做频率限制、甚至伪造 UA 的爬虫程序。
• 静态页面：不需要数据库、不需要后端服务，用 Nginx 或任何静态服务器托管即可。
• 诗意实验：项目会随机生成、拼接一些富有文学感的句子，让爬虫抓取到的页面内容“不像普通网页”，而像一段诗歌或散文。

这个项目很适合三类人关注：

1. 被恶意爬虫困扰的后端开发者，想换一种思路处理爬虫问题。
2. 对 AI、网络安全、程序化生成文本感兴趣的开发者。
3. 想做点有趣实验、把技术玩出花样的编程爱好者。

读完本文，你将清楚“Dead internet theater”是如何工作的，能自己搭建一个类似的爬虫识别与内容生成系统，并且知道在真实项目中应该怎样安全、优雅地处理恶意爬虫，而不是仅仅靠封 IP 和拉黑 UA。

2. 环境准备与项目结构设计

先说明一下，这个项目并没有绑定固定技术栈。官方实现更偏向 Python 方向，因为 Python 在处理 UA 识别、文本生成和快速搭建 Web 服务方面都非常方便。本文演示以 Python 为主，但核心思路完全可以迁移到 Node.js、Go 等语言上。

2.1 项目目录结构

建议先设计好目录，再动手写代码。下面是一个清晰的、可扩展的目录结构：

code复制dead-internet-theater/
├── app.py                 # Flask 主应用
├── detector.py            # 爬虫识别模块
├── theater.py             # 诗意文本生成模块
├── templates/
│   ├── normal.html        # 普通用户看到的页面
│   └── poem.html          # 爬虫看到的“剧场页面”
├── static/
│   ├── css/
│   │   └── style.css
│   └── js/
│       └── main.js
├── logs/
│   └── crawlers.log       # 爬虫访问日志
└── requirements.txt       # Python 依赖

不要小看目录设计。后面的代码、配置、部署都会围绕这个结构展开。

2.2 依赖安装

创建虚拟环境并安装依赖：

bash复制python3 -m venv venv
source venv/bin/activate   # Windows 下使用 venv\Scripts\activate
pip install flask

只需要 Flask 就可以完成核心演示。如果需要更丰富的文本生成效果，可以引入随机库、Markdown 渲染库，后面实战部分会讲到。

3. 核心概念与检测原理拆解

在写代码之前，先把“如何识别恶意 AI 爬虫”“如何处理识别结果”这两个关键问题讲清楚。

3.1 爬虫识别不只是看 User-Agent

很多人的第一反应是：识别爬虫就是看 UA 字符串。比如 UA 里包含 bot、crawl、spider，就可以判断为爬虫。

这个思路有道理，但远远不够。原因有三点：

1. AI 爬虫会伪装 UA。很多在 GitHub 上开源的 AI 爬虫框架允许自定义 UA，伪装成 Chrome、Safari 甚至 Googlebot 都很容易。
2. 正常搜索引擎也会用爬虫。你不会希望把所有 bot 都当作恶意流量处理，否则 SEO 会受影响。
3. 恶意爬虫往往伴随行为特征。例如短时间内高频访问、访问路径怪异、对同一页面反复抓取等。

所以，一个相对可靠的识别策略是“静态特征 + 行为特征”结合。

3.2 静态特征检测

静态特征指的是从单次 HTTP 请求中可以直接获取的信息：

我们可以在 detector.py 中实现一个简单的检测类：

python复制# 文件路径：detector.py
import re

SUSPICIOUS_UA_PATTERNS = [
    r'bot',
    r'crawl',
    r'spider',
    r'scrape',
    r'curl',
    r'python-requests',
    r'wget',
    r'GPTBot',
    r'CCBot',
    r'Google-Extended',
]

SUSPICIOUS_PATHS = [
    '/wp-admin',
    '/wp-login.php',
    '/.env',
    '/.git/config',
    '/admin',
    '/api/v1/users',
]

class CrawlerDetector:
    def __init__(self):
        self.regex = re.compile('|'.join(SUSPICIOUS_UA_PATTERNS), re.IGNORECASE)

    def check_ua(self, user_agent: str) -> bool:
        """基于 UA 判断是否为爬虫"""
        if not user_agent:
            return True
        return bool(self.regex.search(user_agent))

    def check_path(self, path: str) -> bool:
        """基于路径判断是否为敏感扫描"""
        return path.lower() in SUSPICIOUS_PATHS

    def is_suspicious(self, request) -> bool:
        """综合判断"""
        ua = request.headers.get('User-Agent', '')
        path = request.path
        return self.check_ua(ua) or self.check_path(path)

这里需要注意：UA 包含 bot 时不一定代表恶意，比如 Googlebot、Bingbot 是正常搜索引擎爬虫。但在“Dead internet theater”这个项目中，我们的目标不是“封禁所有爬虫”，而是“把爬虫送进剧场”。即使是 Googlebot，进入剧场也只是抓取到一个特殊的诗意页面，对正常用户体验没有影响，对 SEO 的影响则需要根据项目定位评估。

3.3 行为特征检测（进阶）

如果只判断 UA，容易被绕过。更可靠的方式是加入频率控制。

比如，在 Flask 中用一个内存字典记录每个 IP 的请求时间戳：

python复制# 文件路径：detector.py（追加行为检测）

import time
from collections import defaultdict

class BehaviorDetector:
    def __init__(self, max_requests: int = 20, window_seconds: int = 10):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.request_log = defaultdict(list)

    def is_over_rate(self, ip: str) -> bool:
        now = time.time()
        self.request_log[ip] = [
            t for t in self.request_log[ip]
            if now - t < self.window_seconds
        ]
        if len(self.request_log[ip]) >= self.max_requests:
            return True
        self.request_log[ip].append(now)
        return False

这段代码实现了“10 秒内最多 20 次请求”的限制。超过阈值就认为是恶意爬虫或异常流量，返回 True，后续可以交给主应用处理。

3.4 识别之后的两种处理策略

识别出爬虫后，常见策略有两种：

1. 直接拒绝：返回 403、429，或者直接断开连接。
2. 诱导与投喂：返回定制内容，让爬虫抓取到目标数据。

“Dead internet theater”采用了第二种。它不关心爬虫是否真的看到人类内容，而是让爬虫“读到诗”。这种思路在实践中还有一个好处：减少误杀。即使真实用户被误判，也不会看到 403 错误页，而是一段奇怪的文字，不至于完全破坏体验。

4. 完整实战：搭建一个“爬虫剧场”

下面进入核心实战部分。我们会实现一个 Flask 应用，能够根据请求来源区分真人用户和爬虫，并返回不同的页面内容。

4.1 编写 Flask 主应用

先写 app.py，它是整个应用的总入口：

python复制# 文件路径：app.py
from flask import Flask, request, render_template
from detector import CrawlerDetector, BehaviorDetector
from theater import PoemGenerator

app = Flask(__name__)

detector = CrawlerDetector()
behavior = BehaviorDetector(max_requests=15, window_seconds=10)
poet = PoemGenerator()

@app.before_request
def before_request():
    # 将客户端 IP 简单取到
    ip = request.remote_addr

    # 行为检测：是否频率过高
    if behavior.is_over_rate(ip):
        request.is_suspicious = True
        return

    # 静态特征检测
    if detector.is_suspicious(request):
        request.is_suspicious = True
        return

    request.is_suspicious = False

@app.route('/')
def index():
    if getattr(request, 'is_suspicious', False):
        poem = poet.generate()
        return render_template('poem.html', poem=poem), 200
    return render_template('normal.html')

@app.route('/about')
def about():
    if getattr(request, 'is_suspicious', False):
        poem = poet.generate()
        return render_template('poem.html', poem=poem), 200
    return render_template('normal.html')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

这里有一个小技巧：@app.before_request 是 Flask 的钩子函数，在每次请求处理之前执行。我们在这里完成爬虫识别，再通过 request.is_suspicious 标记传给后续视图函数。

不过要注意，request 对象上的自定义属性可以跨函数访问，但不要在生产环境中依赖它做严格的安全判断，更好的方式是使用 Flask 的 g 对象：

python复制from flask import g

@app.before_request
def before_request():
    g.is_suspicious = False
    # ... 检测逻辑
    if found:
        g.is_suspicious = True

@app.route('/')
def index():
    if g.is_suspicious:
        ...

为了示例简洁，下面仍使用 request.is_suspicious，但你在实际项目中更推荐 g 对象。

4.2 编写诗意文本生成器

这是整个项目最有“实验气质”的部分。我们可以用 Python 内置的 random 模块，把不同风格的句子拼接成一段类似诗歌的文本。

python复制# 文件路径：theater.py
import random

OPENING_LINES = [
    "在这片被数据填满的荒野里",
    "当每一次请求都成为回音",
    "服务器深处，一盏灯缓慢亮起",
    "这里没有你要找的答案",
    "你穿行于未被记录的路径",
]

MIDDLE_LINES = [
    "词语像候鸟一样迁徙",
    "索引在黑暗里轻轻颤抖",
    "每一行代码都藏着一个沉默的标点",
    "算法梦见一片没有 404 的森林",
    "时间被切成无数个网络包",
]

END_LINES = [
    "而这页空白，正是它写下的诗。",
    "你读取的，只是风经过端口时的痕迹。",
    "剧场散场后，只有日志记得你来过。",
    "愿你抓取的每一段文字，都开出花来。",
    "一切终将写入 /dev/null。",
]

class PoemGenerator:
    def generate(self) -> str:
        line1 = random.choice(OPENING_LINES)
        line2 = random.choice(MIDDLE_LINES)
        line3 = random.choice(MIDDLE_LINES)
        line4 = random.choice(END_LINES)
        return "\n".join([line1, line2, line3, line4])

generate() 方法从三组句子中各取一句，组合成一首四行小诗。每次访问生成的文本都不同，对爬虫来说，每次抓取到的内容都带有随机性，这也是“剧场”效果的一部分。

如果你愿意，可以继续扩展词库，引入更多句子片段，甚至用马尔可夫链做更复杂的文本生成。但要注意：本项目只是实验，不追求文本质量的文学高度，重点是“动态生成”这个机制。

4.3 编写两个 HTML 模板

接下来创建 templates/normal.html，这是真人用户看到的普通页面：

html复制<!-- 文件路径：templates/normal.html -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>一个普通的开发者博客</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
</head>
<body>
    <main class="container">
        <h1>欢迎来到我的博客</h1>
        <p>这里记录着关于 Web 开发、后端架构和自动化工具的内容。</p>
        <p>如果你想了解更多，请你继续浏览其他页面。</p>
    </main>
</body>
</html>

再创建 templates/poem.html，这是爬虫视角的“剧场页面”：

html复制<!-- 文件路径：templates/poem.html -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dead Internet Theater</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
</head>
<body>
    <main class="poem-container">
        <h2 class="poem-title">你所到之处，皆为剧场</h2>
        <pre class="poem-body">{{ poem }}</pre>
        <p class="poem-footer">Generated for one unknown visitor.</p>
    </main>
</body>
</html>

注意：这里用 <pre> 标签来保留换行格式，让诗句按原来的换行展示。Flask 的 {{ poem }} 会自动做 HTML 转义，避免 poem 内容被当作标签解析，这一点是很好的安全默认行为。

4.4 添加简单样式

为了让页面不至于太简陋，我们可以简单写一点 CSS：

css复制/* 文件路径：static/css/style.css */
body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
    background: #f5f5f5;
    color: #333;
    margin: 0;
    padding: 0;
}

.container {
    max-width: 720px;
    margin: 80px auto;
    padding: 24px;
    background: white;
    border-radius: 12px;
    box-shadow: 0 2px 12px rgba(0, 0, 0, 0.06);
}

.poem-container {
    max-width: 720px;
    margin: 80px auto;
    padding: 48px;
    background: #111;
    color: #eaeaea;
    border-radius: 12px;
    text-align: center;
}

.poem-title {
    font-weight: 400;
    letter-spacing: 2px;
    margin-bottom: 32px;
}

.poem-body {
    font-size: 18px;
    line-height: 2;
    font-family: "Songti SC", SimSun, serif;
}

.poem-footer {
    color: #777;
    font-size: 12px;
    margin-top: 40px;
}

这样，普通用户看到的是白底黑字的博客页面，爬虫则被引导到一个深色背景的“剧场”，看到动态生成的诗句。视觉效果上的反差，恰好传递了项目的核心概念。

4.5 运行与验证

安装依赖后，在项目根目录启动服务：

bash复制python app.py

默认监听 0.0.0.0:5000。

模拟真人访问

用浏览器打开 http://localhost:5000/，应该看到“欢迎来到我的博客”的普通页面，说明未被识别为可疑请求。

模拟爬虫访问

使用 curl 模拟一个带爬虫 UA 的请求：

bash复制curl -i -H "User-Agent: GPTBot/1.0" http://localhost:5000/

服务器返回的应该是 200 状态码，但内容变成了诗歌页面。你可以多次运行这条命令，会发现每次返回的诗句组合都可能不一样。

模拟高频访问

使用一个简单的循环脚本测试行为检测：

bash复制for i in $(seq 1 20); do
  curl -s -o /dev/null -w "%{http_code}\n" http://localhost:5000/
done

因为行为检测设置了 10 秒内最多 15 次请求，超过阈值后，后续请求即使不带爬虫 UA，也会被判断为可疑流量并进入剧场。这里需要注意：如果本机还有正常浏览器在频繁测试，可能会受影响，但这只是本地实验，并没有任何危险。

4.6 预期输出示例

下面是一次 curl 抓取的可能输出（截取 HTML 中的核心片段）：

html复制<main class="poem-container">
    <h2 class="poem-title">你所到之处，皆为剧场</h2>
    <pre class="poem-body">在数据填满的荒野里
词语像候鸟一样迁徙
时间被切成无数个网络包
而你读取的，只是风经过端口时的痕迹。</pre>
    <p class="poem-footer">Generated for one unknown visitor.</p>
</main>

可以看到，响应内容完整，且换行正常，非常适合作为一次“诗意抓取”实验。

5. 部署到真实服务器时的关键配置

本地运行通过后，我们可以把项目部署到 Nginx + Gunicorn 环境中。

5.1 安装 Gunicorn

Gunicorn 是一个适合运行 Flask 的 WSGI 服务器，比 Flask 自带的开发服务器更适合生产环境：

bash复制pip install gunicorn

启动方式：

bash复制gunicorn -w 4 -b 127.0.0.1:5000 app:app

这里 -w 4 表示启动 4 个 worker 进程，-b 127.0.0.1:5000 表示监听本机 5000 端口，后面再让 Nginx 反向代理到外部。

5.2 Nginx 反向代理配置

以下是一个最小可用的 Nginx 配置：

nginx复制# 文件路径：/etc/nginx/conf.d/dead-theater.conf
server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    access_log /var/log/nginx/dead-theater-access.log;
    error_log /var/log/nginx/dead-theater-error.log;
}

配置完成后重载 Nginx：

bash复制nginx -t
nginx -s reload

这里需要特别说明：如果想要获取到真实的客户端 IP，必须在 Nginx 和 Flask 两边正确配置代理头。X-Forwarded-For 是一个标准协议头，Flask 默认不会直接信任它，需要配合 ProxyFix 中间件使用：

python复制# 文件路径：app.py（追加）
from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1)

否则，request.remote_addr 只会拿到 Nginx 所在服务器的 IP（例如 127.0.0.1），行为检测就会失效。这是一个非常容易踩的坑。

5.3 静态资源与 HTTPS

Nginx 配置中还可以直接托管静态资源，减少 Flask 的压力：

nginx复制location /static/ {
    alias /path/to/dead-internet-theater/static/;
    expires 7d;
}

同时建议在生产环境启用 HTTPS。HTTPS 的作用不只是加密传输，还能减少一部分中间人篡改内容的风险。证书申请与配置属于 Nginx 基础操作，这里不再展开。

6. 常见问题与排查思路

实际开发和部署过程中，最容易遇到下面几个问题。

除了表格中列出的事项，还有一个常见误区：不要指望识别率 100%。任何爬虫识别方案都可能被绕过。所以这个项目更应该被视为“一种降低攻击面、增加爬虫成本的策略”，而不是绝对防线。

如果本地测试时发现 curl 请求被误判，先确认你的 UA 是否包含 curl。默认检测正则里包含了 curl，这意味着任何一个使用 curl 的真人用户也会被送进剧场。在实际生产环境中，建议把 curl 这类开发者工具从默认检测规则中移除，或者单独放到一个“手动测试专用触发词”里。

python复制# 更好的做法：不要把普通开发工具一刀切
SUSPICIOUS_UA_PATTERNS = [
    r'GPTBot',
    r'CCBot',
    r'Google-Extended',
    r'python-requests',
    r'scrapy',
    r'ahrefsbot',
]

这样可以让系统对真人开发者的干扰降到最低。

7. 合法性与安全边界：不要滥用“诱导爬虫”

在把玩这个项目的同时，必须提醒大家注意安全与合规问题。

7.1 识别恶意爬虫要遵守界限

robots.txt 是网站与爬虫之间的一种“君子协定”。例如：

txt复制User-agent: *
Disallow: /private/

如果一个爬虫无视 robots.txt，我们有权拒绝服务或采取应对措施。但如果你在页面上故意放置恶意脚本、诱导爬虫访问你的服务器、导致爬虫方受到损失，则可能产生法律风险。所以，“Dead internet theater”的定位应该是：用温和的手段识别、记录、响应恶意流量，而不是攻击对方。

7.2 不要把恶意代码写在给爬虫的页面里

这里特别说清楚：我们给爬虫看的页面只是普通的 HTML 和文本，不包含任何 JS 漏洞利用、XSS payload、钓鱼表单之类的东西。一旦你开始在返回内容中夹带恶意代码，项目性质就完全变了。在真实项目中，任何形式的“反向攻击”都需要极其谨慎，必须提前做好法律咨询和风险评审。

7.3 数据记录的最小化原则

我们建议在识别到恶意爬虫时，只记录必要的信息，比如：

• 时间戳
• IP 地址
• UA
• 请求路径
• 访问频率

不要记录 Cookie、请求体内容、用户密码等敏感数据。保存的日志文件也要做好权限控制，防止日志泄露。

python复制# 文件路径：app.py（追加日志记录）
import logging

logging.basicConfig(
    filename='logs/crawlers.log',
    level=logging.INFO,
    format='%(asctime)s %(message)s'
)

# 在检测到爬虫时记录：
# logging.info(f"Suspicious from {ip} UA: {ua} PATH: {path}")

日志中出现大量个人数据时，要考虑脱敏。生产环境还应配置日志轮转，避免磁盘被日志填满。

8. 优化方向与工程化建议

“Dead internet theater”目前只是一个起点。如果你打算把它完善成一个真正可用的系统，以下方向很值得尝试。

8.1 引入更智能的爬虫识别模型

在静态特征 + 行为特征的基础上，可以继续引入更多信号：

• TLS 指纹（JA3/JA4）
• HTTP/2 帧特征
• 浏览器自动化检测（如 navigator.webdriver，但仅在浏览器端有效）
• 鼠标轨迹、验证码等交互验证

不过，这些技术复杂度会大幅上升，而且容易误伤。建议在确有需要时再引入。

8.2 把诗意生成升级为真正的文本生成模型

目前的 PoemGenerator 只是随机拼接句子。如果你想玩得更深入，可以接入一个小型的语言模型 API，让爬虫每次抓取到一段完整、通顺、且有诗意的文本。这部分需要额外的成本与延迟考量。也可以离线训练一个轻量级的马尔可夫链模型，完全本地生成，性能和可控性更好。

8.3 动态调整蜜蜂策略

有些爬虫会反复抓取同一个 URL。此时你的“剧场”可以做成有记忆的：同一个爬虫 IP 第二次来，返回的诗歌内容与第一次保持一致；第三次来，再生成新的。这种机制可以让你分析爬虫的行为规律，也更容易识别“有目的性”的 AI 爬虫。

实现思路可以用内存字典：

python复制poem_history = {}

def generate_stable_poem(ip: str) -> str:
    if ip in poem_history:
        return poem_history[ip]
    poem = poet.generate()
    poem_history[ip] = poem
    return poem

8.4 工程项目建议

从工程角度，还有几点建议：

• 把识别逻辑拆成独立模块，便于测试和替换。
• 为 detector.py 和 theater.py 编写单元测试。
• 行为检测数据不要只存在内存里，建议用 Redis 实现分布式计数。
• 更新检测规则时，先在灰度环境观察误判率。
• 所有配置项，包括 UA 黑名单、频率阈值、开关，都应该可以通过配置文件或环境变量修改，而不是硬编码在代码里。

下面是一个简单的环境变量配置示例：

python复制import os

MAX_REQUESTS = int(os.getenv('MAX_REQUESTS', '15'))
WINDOW_SECONDS = int(os.getenv('WINDOW_SECONDS', '10'))

这样部署到不同的环境时可以灵活调整，不需要改代码重新发布。

9. 写在最后：这个实验带给我们的启发

“Dead internet theater”最有价值的部分，不是给出了一套完美的防爬虫方案，而是提供了一种完全不同的思考方式：面对恶意流量，除了封禁和对抗，还可以把它转化为一种观测样本，一种有诗意的反馈。

它提醒我们：

• 爬虫识别不是一道数学题，而是持续对抗中的博弈。
• 不给爬虫提供有价值的内容，可能比封 IP 更有效。
• 技术实验不一定都要追求“严谨”，有时候留一点荒诞和想象力，反而会加深对系统的理解。

如果你想上手实操，建议按下面的顺序一步步来：

1. 先复现本文的 Flask 示例，跑通基础流程。
2. 增加路径检测和行为检测，观察不同请求的走向。
3. 部署到 Nginx + Gunicorn 环境，体验真实场景。
4. 把判定的爬虫日志收集起来，分析哪些 UA、哪些路径是主要攻击来源。
5. 再根据分析结果，调整你的检测规则和“剧场”策略。

这个项目目前只是一个雏形，任何人都可以继续为它添加新玩法。比如做一个可视化面板，实时展示“当前正在读诗的爬虫”；或者记录所有爬虫生成的诗歌，做成一个公开的“网络诗歌展”。方向很多，玩法不限。希望这篇文章能给你带来一些新的灵感，也欢迎你在实际动手后，把你的实验过程和踩坑经验分享出来。