公开数据采集跑到一定规模之后,最先崩掉的往往不是解析逻辑,而是调度。
单机跑几百个页面时,一个 for 循环加 sleep 就够了。但当任务扩展到几万条URL、多个目标站点、多个采集节点同时运行时,问题会集中暴露:任务分配不均导致某些节点空转、某些节点过载;请求频率没有统一控制,单IP在短时间内打出高频请求,触发目标站点限流;代理IP的提取、轮换和失效处理散落在各个节点里,无法统一观测。
这三个问题对应调度架构的三个核心模块:任务分片、频率控制、出口管理。这篇文章按这三个模块拆解设计思路,并给出一个可运行的整合示例,代理部分以短效动态IP的通用接入模式为例。
一、先明确边界:调度架构管什么、不管什么
调度架构的职责,是让采集任务在多个执行单元、多个网络出口之间合理分配,并在目标站点可接受的频率内稳定运行。
它不解决以下问题:
- 目标站点是否允许采集(这取决于 robots.txt 和服务条款);
- 采集到的数据是否合法可用(这取决于数据用途);
- 代理IP的来源是否合规(这取决于服务商选择)。
调度架构解决的是工程效率问题:在合规前提下,用尽可能少的无效请求、尽可能低的封禁概率,把任务稳定跑完。这个边界先划清楚,后面的设计才有意义。
二、整体架构:三层分离
一个可扩展的调度架构,建议把职责拆成三层:
text
┌─────────────────────────────────────────────┐
│ 调度层(Scheduler) │
│ 任务分片 / 优先级队列 / 进度追踪 / 失败重派 │
└──────────────────┬──────────────────────────┘
│ 下发分片任务
┌──────────────────▼──────────────────────────┐
│ 执行层(Worker) │
│ 请求发起 / 解析 / 重试 / 结果上报 │
└──────────────────┬──────────────────────────┘
│ 获取出口 / 上报结果
┌──────────────────▼──────────────────────────┐
│ 出口层(Proxy Manager) │
│ IP池管理 / 频率控制 / 健康检查 / 轮换 │
└─────────────────────────────────────────────┘
调度层只负责任务的拆分和分配,不关心请求怎么发、从哪个IP发。
执行层是实际干活的Worker,从调度层领取分片,向出口层申请代理,发起请求并解析结果。
出口层统一管理代理IP池和请求频率,是“所有对外请求的闸门”。
三层分离的好处是:任务量增长时扩展Worker,出口被封时调整出口层策略,两者互不干扰。
三、任务分片:按“目标站点+批次”切,而不是按URL均分
3.1 为什么不能简单均分
最直觉的分片方式是“把URL列表平均切成N份,每个Worker一份”。这个做法在单目标站点、同质请求的场景下能用,但在多目标站点场景下会出问题:
- 不同站点的反爬强度不同,均分会让某个Worker恰好分到大量高难度站点,成为瓶颈;
- 同一个站点的URL如果被分散到多个Worker,各自的请求频率难以统一控制,容易在站点侧叠加成高频;
- 某个Worker失败时,它手里的分片需要重新分配,均分结构下重派逻辑复杂。
3.2 按“站点+批次”分片
更合理的分片维度是 (target_domain, batch_id):同一个目标站点的一批URL组成一个分片,分片是调度的最小单位。
```python
from dataclasses import dataclass
from collections import defaultdict
@dataclass
class Shard:
"""一个分片:同一目标站点的一批URL"""
shard_id: str
domain: str
urls: list
status: str = "pending" # pending / running / done / failed
attempts: int = 0
max_attempts: int = 3
def build_shards(urls: list, batch_size: int = 50) -> list:
"""按目标域名分组,再按批次切分"""
by_domain = defaultdict(list)
for url in urls:
domain = url.split("/")[2] if "://" in url else url.split("/")[0]
by_domain[domain].append(url)
shards = []
for domain, domain_urls in by_domain.items():
for i in range(0, len(domain_urls), batch_size):
batch = domain_urls[i:i + batch_size]
shards.append(Shard(
shard_id=f"{domain}#{i // batch_size}",
domain=domain,
urls=batch,
))
return shards
按站点分片有三个好处:频率控制可以按分片维度做(同一个站点的请求频率在出口层统一约束);失败重派以分片为单位,粒度合适;某个站点整体不可用时,只会影响它自己的分片,不会拖累其他站点。
3.3 优先级与重派
分片进入队列时带优先级,优先级可以来自业务规则(核心品牌相关页面优先)或时效性(最近发布的页面优先)。失败分片的重派要设置 max_attempts,超过次数后进入“死信队列”,由人工确认是目标站点变更还是代理问题,而不是无限重试。
四、频率控制:按目标站点做令牌桶,不按Worker做
4.1 频率控制的维度
频率控制最容易做错的地方,是按Worker或按IP做限流。按Worker限流的问题在于,Worker数量增加时,对同一站点的总请求频率会线性上升;按IP限流的问题在于,换一个IP就重置了计数,短效代理频繁换IP时,限流形同虚设。
正确的维度是按目标站点限流。无论多少个Worker、多少个出口IP,对同一个目标站点的请求总速率有一个全局上限。这个上限应当保守设置,参考站点的 Crawl-delay(如果有)和行业惯例(比如每个域名每秒1到2次请求是常见的安全起点)。
4.2 令牌桶实现
令牌桶适合这种“允许短时突发、但长期速率受限”的场景:
```python
import time
import threading
class DomainRateLimiter:
"""按目标域名的全局令牌桶限流"""
def __init__(self, rate_per_sec: float = 1.0, burst: int = 3):
self.rate = rate_per_sec
self.burst = burst
self.buckets = {} # domain -> (tokens, last_refill)
self.lock = threading.Lock()
def acquire(self, domain: str, timeout: float = 30.0) -> bool:
"""获取一个令牌,阻塞直到拿到或超时"""
deadline = time.time() + timeout
while time.time() < deadline:
with self.lock:
tokens, last = self.buckets.get(domain, (self.burst, time.time()))
now = time.time()
# 按流逝时间补充令牌
tokens = min(self.burst, tokens + (now - last) * self.rate)
if tokens >= 1:
self.buckets[domain] = (tokens - 1, now)
return True
self.buckets[domain] = (tokens, now)
time.sleep(0.05) # 没拿到令牌,短暂等待后重试
return False
这个实现是进程内的。多Worker部署时,需要换成基于Redis的分布式令牌桶,或者由出口层统一做限流——后者更简单,因为所有请求本来就要经过出口层。
五、出口管理:短效动态IP的池化与轮换
出口层是调度架构里唯一直接和代理IP打交道的地方。执行层的Worker不持有IP,每次请求向出口层“借”一个出口,用完归还。
5.1 为什么把出口管理独立出来
如果每个Worker自己维护代理池,会带来三个问题:IP无法共享(Worker A 手里有闲置IP,Worker B 却在等IP);失效状态不一致(A判定失效的IP,B还在用);频率控制分散(各Worker独立限流,叠加后超限)。
把出口管理收敛成独立服务后,IP池、健康状态、限流规则都在一个地方维护,Worker只负责“申请—使用—上报结果”。
5.2 短效动态IP的接入模式
短效动态IP服务通常提供一个HTTP提取接口,通过 num(提取数量)、ttl(存活时长)、type(返回格式)等参数控制单次获取的IP规格。不同服务商的参数名和返回格式略有差异,但接入模式是通用的:批量提取 → 入队 → Worker按需取用。
下面以一个抽象化的提取函数示意这种模式,实际接入时替换为所用服务商的接口地址和参数即可:
```python
import requests
def fetch_short_proxies(api_url: str, api_key: str,
num: int = 10, ttl: int = 3) -> list:
"""
短效代理IP提取的通用模式。
api_url / api_key / 参数名需按实际服务商的接口文档替换。
"""
try:
resp = requests.get(
api_url,
params={"key": api_key, "num": num, "time": ttl},
timeout=10,
)
data = resp.json()
# 返回结构因服务商而异,此处假定 data 字段为列表
items = data.get("data", []) if isinstance(data, dict) else []
return [
f"http://{item['ip']}:{item['port']}"
for item in items
if "ip" in item and "port" in item
]
except Exception:
return []
5.3 池化:提取与使用分离
出口层内部维护一个本地队列。后台线程按固定频率预取IP入队,Worker从队列取用。这样API调用的延迟不会阻塞Worker的请求。
```python
import threading
from collections import deque
class ProxyExitManager:
"""出口管理器:预取IP、按域名限流、失败剔除"""
def __init__(self, api_url: str, api_key: str,
limiter: DomainRateLimiter,
low_watermark: int = 5, batch_size: int = 10, ttl: int = 3):
self.api_url = api_url
self.api_key = api_key
self.limiter = limiter
self.low = low_watermark
self.batch = batch_size
self.ttl = ttl
self.queue = deque()
self.lock = threading.Lock()
self._start_refill_thread()
def _start_refill_thread(self):
def loop():
while True:
self._refill_if_needed()
threading.Event().wait(5)
t = threading.Thread(target=loop, daemon=True)
t.start()
def _refill_if_needed(self):
with self.lock:
if len(self.queue) >= self.low:
return
new_ips = fetch_short_proxies(
self.api_url, self.api_key, self.batch, self.ttl
)
with self.lock:
self.queue.extend(new_ips)
def acquire(self, domain: str) -> str | None:
"""为指定域名申请一个出口,先过限流"""
if not self.limiter.acquire(domain):
return None
with self.lock:
return self.queue.popleft() if self.queue else None
def report(self, proxy: str, success: bool):
"""上报结果,失败IP直接丢弃(短效代理不需要保留坏IP)"""
if not success:
pass # 短效IP失败即弃,不做复杂评分
短效IP的失败处理比长效IP简单:失败即弃,不恋战。重试的价值在于换一个出口再试,而不是在同一个坏出口上等待。
5.4 核心源和长尾源的出口策略分开
不是所有任务都适合短效动态IP。核心源(品牌官方账号、重点新闻站)需要高频巡检和会话连续性,短效IP的“失败即换”会导致登录态中断。实践中建议分层:
| 信源类型 | 出口策略 | 原因 |
| 核心源 | 粘性会话或较长存活周期的IP | 需要会话连续性 |
| 长尾源 | 短效动态IP,按批次提取 | 请求分散,成本效率优先 |
| 补充源 | 按目标站点单独分组 | 隔离风险 |
六、整合:一次完整的调度循环
把三层串起来,一次采集任务的生命周期大致如下:
```python
def run_worker(shards: list, exit_mgr: ProxyExitManager):
"""执行层Worker:领取分片,逐条请求"""
for shard in shards:
if shard.status != "pending":
continue
shard.status = "running"
success_count = 0
for url in shard.urls:
proxy = exit_mgr.acquire(shard.domain)
if not proxy:
# 限流等待超时,分片放回待处理
shard.status = "pending"
break
proxies = {"http": proxy, "https": proxy}
try:
resp = requests.get(url, proxies=proxies, timeout=(5, 12))
resp.raise_for_status()
# 解析与入库逻辑省略
exit_mgr.report(proxy, success=True)
success_count += 1
except requests.exceptions.RequestException:
exit_mgr.report(proxy, success=False)
continue
# 分片状态判定
if success_count == len(shard.urls):
shard.status = "done"
else:
shard.attempts += 1
shard.status = "failed" if shard.attempts >= shard.max_attempts else "pending"
这个示例刻意简化了状态持久化、分布式锁和死信队列。生产环境中,分片状态应该持久化到数据库或Redis,多个Worker从同一个队列领取分片时需要用原子操作避免重复领取。
七、几个工程上的判断
第一,频率控制的粒度要小于等于分片的粒度。 按站点限流时,同一个站点的所有分片共享一个令牌桶。如果限流按Worker做,Worker数量一多,站点侧的实际频率就失控了。
第二,出口层的队列水位要监控。 队列长期为空,说明提取速度跟不上消耗,需要提高提取频率或批量;队列长期满,说明提取过度,IP在队列里超龄失效,浪费成本。
第三,分片失败不等于任务失败。 一个分片失败,要先判断是目标站点变更(需要更新解析逻辑)、代理不可用(换出口重试)、还是限流过严(调整频率)。不加区分地重试,只会重复消耗资源。
第四,采集缺口要显式记录。 某个分片达到重试上限后进入死信队列,系统应当明确标记“这块数据没采到”,而不是把零结果当成“没有数据”。对舆情监测和价格监控这类业务,漏采比重复更危险。
八、合规提醒
本文讨论的调度架构用于公开可访问数据的合规采集。在实际使用中需要遵守以下边界:
- 遵守目标网站的 robots.txt 协议和服务条款,对明确禁止采集的路径主动屏蔽;
- 频率控制不仅是为了“防封”,也是为了不对目标服务器造成实质性负载压力,令牌桶的速率应当保守设置;
- 仅采集公开可访问的内容,不通过代理和调度架构突破登录、付费或权限限制;
- 代理资源的使用应当遵守目标网站的服务条款和相关法律法规,不使用来源不明的资源;
- 采集的数据仅用于合法用途,不侵犯他人隐私和知识产权。
调度架构解决的是“采得稳、采得省”,采集合规性取决于采集的目标、范围和用途本身。
九、总结
公开数据采集的调度架构,可以收束为三个模块的设计决策:
| 模块 | 核心决策 | 关键点 |
| 任务分片 | 按“目标站点+批次”切分 | 频率控制可按站点维度统一,失败重派粒度合适 |
| 频率控制 | 按目标站点做全局令牌桶 | 不按Worker或IP限流,速率保守设置 |
| 出口管理 | 独立出口层,提取与使用分离 | 短效IP失败即弃,核心源与长尾源策略分层 |
三层分离的价值在于:任务量增长时扩展执行层,出口策略调整时只改出口层,两者互不干扰。调度层只负责“把任务分给谁”,不关心“从哪个IP发出去”。