phase 5 part 3: mongodb, elasticsearch hybrid search, data-pipeline, nodejs BFF topics with verified examples

This commit is contained in:
Shikui Wang committed 2026-10-23 16:38:52 +08:00
1 parent 9eeb10aede
commit 075872e31e
27 files changed
+2405 -52

No files matched your search

@@ -0,0 +1,100 @@
---
id: backend.data-pipeline.reliability
title: 数据管道基础:批处理与流处理、增量同步、限流重试、幂等、数据质量和告警
type: lesson
domain: backend
stack: [data-pipeline]
tags: [ETL, 批处理, 流处理, 增量同步, 水位线, 限流, 重试, 幂等, 死信, 数据质量, 告警]
level: intermediate
prerequisites: [backend.postgresql.index-tx-mvcc, backend.mq.reliability]
est_hours: 3
related: [backend.data-pipeline.scenario.third-party-sync, backend.data-pipeline.interview, backend.elasticsearch.scenario.kb-search-sync]
week: [14]
order: 1
---
# 数据管道基础:批处理与流处理、增量同步、限流重试、幂等、数据质量和告警
> BOSS直聘 2026-10-23 的调研中,部分 AI 应用岗位要求“数据处理 / 数据管道”能力:知识库文档的采集清洗、第三方平台数据对接、报表数据准备。这里讲后端工程师需要掌握的基础,不涉及大数据平台。
## 解释说明
### 批处理和流处理
| | 批处理 | 流处理 |
| --- | --- | --- |
| 触发 | 定时(每小时 / 每天) | 事件到达即处理 |
| 延迟 | 分钟到小时 | 秒级 |
| 实现 | 定时任务 + SQL / Python | 消息队列(Kafka / RabbitMQ)+ 消费者,或 CDC |
| 适合 | 报表、对账、全量重建 | 搜索同步、实时告警、实时推荐 |
很多系统两者结合:流处理保证实时,批处理定期对账兜底。
### 增量同步的关键
1. **水位线**:记录上次同步到哪里(时间戳 + 主键打破平局),失败后从水位线继续。**水位线只在本批数据成功落库后推进**。
2. **限流**:第三方接口有调用频率限制,用令牌桶控制;收到 429 时遵守 `Retry-After`。
3. **重试**:区分可重试错误(超时、5xx、429)和不可重试错误(401、参数错误);指数退避 + 抖动(避免大量客户端同时重试),有上限。
4. **幂等**:重复运行结果一致——按主键 upsert,并且比较版本号 / 更新时间,旧数据不能覆盖新数据。
5. **坏数据**:单条坏数据进入死信表,不阻塞整批;坏数据比例超过阈值说明上游出问题了,应停止并告警。
6. **数据质量检查**:行数波动、空值率、取值范围、唯一性、与源头的对账。
7. **可观测**:每次运行记录拉取数、写入数、死信数、耗时;失败和质量异常告警。
### 常用工具(了解)
定时调度:cron、Celery Beat、APScheduler;编排:Airflow、Dagster、Prefect;CDC:Debezium;数据质量:Great Expectations 一类工具。小团队先用“定时任务 + 本课的这些原则”就够了。
## 案例
每 10 分钟从电商平台开放接口同步订单到自己的数据库,供 AI 报表 Agent 查询:接口每秒限 50 次、偶尔超时;有时返回状态值异常的数据;同步中断后要能续跑;不能产生重复订单。
## 代码示例
[examples/incremental-sync](examples/incremental-sync/)(只用标准库,`python pipeline.py` 运行,`test_pipeline.py` 6 个测试通过):
```text
第一次:拉取 251,写入 250,死信 1,接口调用 5 次(含 2 次失败重试)
第二次(没有新数据):拉取 0
orders 表 250 行,水位线 ('2026-10-23T11:00:00', 'bad1')
```
幂等且防止旧版本覆盖:
```sql
INSERT INTO orders (id, amount_cents, status, updated_at) VALUES (:id, :amount_cents, :status, :updated_at)
ON CONFLICT(id) DO UPDATE SET amount_cents = excluded.amount_cents, status = excluded.status, updated_at = excluded.updated_at
WHERE excluded.updated_at > orders.updated_at
```
重试(指数退避 + 全抖动,遵守 Retry-After):
```python
def with_retry(fn, *, attempts=5, base=0.2, cap=5.0, sleep=time.sleep, rng=None):
rng = rng or random.Random()
for i in range(attempts):
try:
return fn()
except RetryableError as e:
if i == attempts - 1:
raise
delay = e.retry_after if e.retry_after is not None else rng.uniform(0, min(cap, base * 2 ** i))
sleep(delay)
```
质量检查不通过时整批回滚、水位线不前进并告警(见 `test_quality_gate_rolls_back_and_alerts`)。
## 易错点
- 先推进水位线再写数据:中途失败就丢数据。
- 只用时间戳做水位线:同一秒内有多条数据时会漏或重复;要加主键打破平局。
- **迟到数据**:来源系统的事务晚提交,`updated_at` 比水位线还早,被永远跳过。办法:每次往回多拉一个重叠窗口(例如 5 分钟),依赖幂等写入去重;再加定期对账。
- 对所有错误都重试,包括 401,结果被对方封禁。
- 没有抖动的重试,故障恢复瞬间所有任务一起打过去。
- 坏数据直接让整个任务失败,或者相反——静默丢弃没有任何记录。
## 面试常问
- 怎么设计一个可以断点续传的增量同步任务?
- 怎么保证同步任务幂等?
- 第三方接口限流和不稳定怎么处理?
- 怎么发现数据质量问题?
@@ -0,0 +1,180 @@
"""增量数据同步管道:第三方接口(限流 + 不稳定)→ 校验 → 幂等写入 → 数据质量检查 → 告警。
只用标准库(sqlite3 代替真实数据库)。`python pipeline.py` 直接运行演示,test_pipeline.py 是测试。
要点:
- 水位线(watermark):记录已同步到的 (updated_at, id),下次从这里继续,可断点续跑
- 限流:令牌桶控制调用频率,遇到 429 按 Retry-After 等待
- 重试:只重试可重试的错误,指数退避 + 抖动,有次数上限
- 幂等:按主键 upsert,并且只接受更新的版本,重复跑结果一样
- 坏数据进入死信表,不阻塞整批;质量检查不通过就告警并且不推进水位线
"""
from __future__ import annotations
import random
import sqlite3
import time
from dataclasses import dataclass, field
from typing import Callable, Iterable
class RetryableError(Exception):
"""网络超时、5xx、429 等,可以重试。"""
def __init__(self, msg: str, retry_after: float | None = None):
super().__init__(msg)
self.retry_after = retry_after
class FatalError(Exception):
"""401、参数错误等,重试没有意义。"""
class QualityError(Exception):
"""数据质量检查不通过。"""
@dataclass
class TokenBucket:
rate: float # 每秒补充的令牌数
capacity: float
now: Callable[[], float] = time.monotonic
sleep: Callable[[float], None] = time.sleep
tokens: float = field(init=False)
last: float = field(init=False)
def __post_init__(self) -> None:
self.tokens = self.capacity
self.last = self.now()
def acquire(self) -> None:
while True:
t = self.now()
self.tokens = min(self.capacity, self.tokens + (t - self.last) * self.rate)
self.last = t
if self.tokens >= 1:
self.tokens -= 1
return
self.sleep((1 - self.tokens) / self.rate)
def with_retry(fn: Callable[[], list[dict]], *, attempts: int = 5, base: float = 0.2, cap: float = 5.0,
sleep: Callable[[float], None] = time.sleep, rng: random.Random | None = None) -> list[dict]:
rng = rng or random.Random()
for i in range(attempts):
try:
return fn()
except RetryableError as e:
if i == attempts - 1:
raise
delay = e.retry_after if e.retry_after is not None else rng.uniform(0, min(cap, base * 2 ** i)) # 全抖动
sleep(delay)
raise AssertionError("unreachable")
SCHEMA = """
CREATE TABLE IF NOT EXISTS orders (id TEXT PRIMARY KEY, amount_cents INTEGER NOT NULL, status TEXT NOT NULL, updated_at TEXT NOT NULL);
CREATE TABLE IF NOT EXISTS dead_letters (source_id TEXT, reason TEXT, payload TEXT, at TEXT DEFAULT CURRENT_TIMESTAMP);
CREATE TABLE IF NOT EXISTS watermarks (job TEXT PRIMARY KEY, updated_at TEXT NOT NULL, last_id TEXT NOT NULL);
"""
VALID_STATUS = {"paid", "refunded", "cancelled"}
def validate(row: dict) -> str | None:
if not row.get("id"):
return "缺少 id"
if not isinstance(row.get("amount_cents"), int) or row["amount_cents"] < 0:
return "金额非法"
if row.get("status") not in VALID_STATUS:
return f"未知状态 {row.get('status')}"
if not row.get("updated_at"):
return "缺少 updated_at"
return None
@dataclass
class RunResult:
fetched: int = 0
written: int = 0
dead: int = 0
alerts: list[str] = field(default_factory=list)
committed: bool = False
def run_sync(conn: sqlite3.Connection, fetch_page: Callable[[str, str, int], list[dict]], *,
job: str = "orders", page_size: int = 100, bucket: TokenBucket | None = None,
max_dead_ratio: float = 0.05, alert: Callable[[str], None] = print,
sleep: Callable[[float], None] = time.sleep) -> RunResult:
"""从水位线开始分页拉取。fetch_page(after_updated_at, after_id, limit) 返回按 (updated_at, id) 升序的数据。"""
conn.executescript(SCHEMA)
wm = conn.execute("SELECT updated_at, last_id FROM watermarks WHERE job = ?", (job,)).fetchone()
after_ts, after_id = wm if wm else ("", "")
res = RunResult()
try:
with conn: # 整次运行一个事务:质量检查不过就整体回滚,水位线不前进
while True:
if bucket:
bucket.acquire()
page = with_retry(lambda: fetch_page(after_ts, after_id, page_size), sleep=sleep)
if not page:
break
for row in page:
res.fetched += 1
reason = validate(row)
if reason:
res.dead += 1
conn.execute("INSERT INTO dead_letters (source_id, reason, payload) VALUES (?, ?, ?)",
(str(row.get("id")), reason, repr(row)))
continue
# 幂等 upsert:只有来源版本更新时才覆盖,乱序或重复的数据不会把新值改回旧值
conn.execute(
"""INSERT INTO orders (id, amount_cents, status, updated_at) VALUES (:id, :amount_cents, :status, :updated_at)
ON CONFLICT(id) DO UPDATE SET amount_cents = excluded.amount_cents, status = excluded.status,
updated_at = excluded.updated_at
WHERE excluded.updated_at > orders.updated_at""", row)
res.written += 1
last = page[-1]
after_ts, after_id = last.get("updated_at") or after_ts, str(last.get("id") or after_id)
if len(page) < page_size:
break
# 数据质量检查
if res.fetched and res.dead / res.fetched > max_dead_ratio:
raise QualityError(f"坏数据比例 {res.dead}/{res.fetched} 超过阈值 {max_dead_ratio:.0%}")
conn.execute("INSERT INTO watermarks (job, updated_at, last_id) VALUES (?, ?, ?) "
"ON CONFLICT(job) DO UPDATE SET updated_at = excluded.updated_at, last_id = excluded.last_id",
(job, after_ts, after_id))
res.committed = True
except QualityError as e:
res.alerts.append(str(e))
alert(f"[告警] 任务 {job}:{e},本次结果已回滚,水位线未推进")
return res
class FakeSource:
"""模拟第三方接口:按 (updated_at, id) 分页;可以注入 429 / 超时。"""
def __init__(self, rows: list[dict], failures: Iterable[Exception] = ()):
self.rows = sorted(rows, key=lambda r: (r["updated_at"], r["id"]))
self.failures = list(failures)
self.calls = 0
def __call__(self, after_ts: str, after_id: str, limit: int) -> list[dict]:
self.calls += 1
if self.failures:
raise self.failures.pop(0)
out = [r for r in self.rows if (r["updated_at"], r["id"]) > (after_ts, after_id)]
return [dict(r) for r in out[:limit]]
if __name__ == "__main__":
rows = [{"id": f"o{i:03d}", "amount_cents": 100 * i, "status": "paid", "updated_at": f"2026-10-23T10:{i // 60:02d}:{i % 60:02d}"} for i in range(250)]
rows.append({"id": "bad1", "amount_cents": -5, "status": "paid", "updated_at": "2026-10-23T11:00:00"})
src = FakeSource(rows, failures=[RetryableError("429 Too Many Requests", retry_after=0.01), RetryableError("timeout")])
conn = sqlite3.connect(":memory:")
r1 = run_sync(conn, src, page_size=100, bucket=TokenBucket(rate=50, capacity=5), sleep=lambda s: None)
print(f"第一次:拉取 {r1.fetched},写入 {r1.written},死信 {r1.dead},接口调用 {src.calls} 次(含 2 次失败重试)")
r2 = run_sync(conn, src, page_size=100, sleep=lambda s: None)
print(f"第二次(没有新数据):拉取 {r2.fetched}")
total = conn.execute("SELECT COUNT(*) FROM orders").fetchone()[0]
print(f"orders 表 {total} 行,水位线 {conn.execute('SELECT updated_at, last_id FROM watermarks').fetchone()}")
assert (r1.written, r1.dead, r2.fetched, total) == (250, 1, 0, 250)
@@ -0,0 +1,80 @@
import sqlite3
import pytest
from pipeline import FakeSource, FatalError, RetryableError, TokenBucket, run_sync, with_retry
def make_rows(n, start=0, ts_prefix="2026-10-23T10:00:", status="paid"):
return [{"id": f"o{i:03d}", "amount_cents": i, "status": status, "updated_at": f"{ts_prefix}{i:02d}"} for i in range(start, start + n)]
def test_resume_from_watermark_and_idempotent():
conn = sqlite3.connect(":memory:")
src = FakeSource(make_rows(30))
assert run_sync(conn, src, page_size=10, sleep=lambda s: None).written == 30
again = run_sync(conn, src, page_size=10, sleep=lambda s: None)
assert again.fetched == 0 # 水位线生效,不重复拉取
src.rows += make_rows(5, start=30)
assert run_sync(conn, src, page_size=10, sleep=lambda s: None).written == 5
assert conn.execute("SELECT COUNT(*) FROM orders").fetchone()[0] == 35
def test_older_version_does_not_overwrite_newer():
conn = sqlite3.connect(":memory:")
run_sync(conn, FakeSource([{"id": "a", "amount_cents": 1, "status": "refunded", "updated_at": "2026-10-23T12:00:00"}]), job="j1")
# 另一个来源(或重放)送来旧版本
run_sync(conn, FakeSource([{"id": "a", "amount_cents": 1, "status": "paid", "updated_at": "2026-10-23T09:00:00"}]), job="j2")
assert conn.execute("SELECT status FROM orders WHERE id='a'").fetchone()[0] == "refunded"
def test_quality_gate_rolls_back_and_alerts():
conn = sqlite3.connect(":memory:")
rows = make_rows(10) + make_rows(3, start=10, status="???") # 3/13 坏数据,超过 5%
alerts = []
r = run_sync(conn, FakeSource(rows), max_dead_ratio=0.05, alert=alerts.append)
assert not r.committed and alerts
assert conn.execute("SELECT COUNT(*) FROM orders").fetchone()[0] == 0 # 整批回滚
assert conn.execute("SELECT COUNT(*) FROM watermarks").fetchone()[0] == 0 # 水位线没动
def test_retry_only_retryable_and_respects_retry_after():
sleeps = []
calls = iter([RetryableError("429", retry_after=2.0), RetryableError("timeout"), ["ok"]])
def fn():
v = next(calls)
if isinstance(v, Exception):
raise v
return v
assert with_retry(fn, sleep=sleeps.append) == ["ok"]
assert sleeps[0] == 2.0 and 0 <= sleeps[1] <= 0.4
def fatal():
raise FatalError("401")
with pytest.raises(FatalError):
with_retry(fatal, sleep=sleeps.append)
def test_retry_gives_up():
def always():
raise RetryableError("503")
with pytest.raises(RetryableError):
with_retry(always, attempts=3, sleep=lambda s: None)
def test_token_bucket_limits_rate():
clock = [0.0]
slept = []
def sleep(s):
slept.append(s)
clock[0] += s
b = TokenBucket(rate=2, capacity=2, now=lambda: clock[0], sleep=sleep)
for _ in range(6):
b.acquire()
assert clock[0] == pytest.approx(2.0) # 2 个初始令牌 + 4 个以每秒 2 个的速度补充 = 2 秒
+25 -5
View File
@@ -1,15 +1,35 @@
---
id: backend.data-pipeline.index
title: 数据管道与第三方接口对接
title: 数据管道基础
type: index
domain: backend
stack: [data-pipeline]
tags: []
tags: [ETL, 增量同步, 幂等, 数据质量]
week: [14]
---
# 数据管道与第三方接口对接
# 数据管道基础
批处理与流处理、失败重试、幂等、数据质量告警、第三方 API 限流与字段变化。
批处理与流处理、增量同步、限流重试、幂等、数据质量和告警。BOSS直聘 2026-10-23 的调研中部分 AI 应用岗位要求数据处理能力:知识库文档采集、第三方数据对接、报表数据准备都离不开它。
> 本专题建设中:课程、企业场景、面试题和示例代码会陆续补充。
## 学习路线
| 顺序 | 课程 | 级别 | 预计 |
| --- | --- | --- | --- |
| 1 | [数据管道基础:批处理与流处理、增量同步、限流重试、幂等、数据质量和告警](01-batch-stream-reliability.md) | 进阶 | 3 小时 |
## 企业场景
- [第三方平台订单同步:限流、断点续跑、迟到数据、对账和告警](scenarios/third-party-sync.md)
## 面试题
- [数据管道面试题](interview.md)
## 示例代码
- [examples/incremental-sync](examples/incremental-sync/):水位线、令牌桶、指数退避 + 抖动重试、幂等 upsert、死信、质量检查回滚(只用标准库,6 个测试通过)
## 在 16 周计划中
- [第 14 周:后端扩展与部署](../../../plan/week14-backend-extend-deploy.md)
+67
View File
@@ -0,0 +1,67 @@
---
id: backend.data-pipeline.interview
title: 数据管道面试题
type: interview
domain: backend
stack: [data-pipeline]
tags: [数据同步, 幂等, 重试, 数据质量, 面试]
level: intermediate
related: [backend.data-pipeline.reliability]
week: [14, 16]
---
# 数据管道面试题
## 基础
### 【基础】批处理和流处理的区别?
**参考答案**:批处理按时间间隔处理一批数据,延迟高、实现简单,适合报表和对账;流处理事件到达即处理,延迟低,适合实时同步和告警。常结合使用:流处理保证实时,批处理兜底对账。
**追问**:知识库文档更新后同步到向量库用哪种?→ 一般用事件驱动(流式)保证及时,再加每日对账修复遗漏。
### 【基础】什么是幂等?同步任务怎么做到幂等?
**参考答案**:同一操作执行多次与执行一次结果相同。做法:按业务主键 upsert;写入时比较版本号或更新时间;用唯一约束防止重复;外部副作用(发通知)记录已处理的 id。
**追问**:为什么还要比较版本?→ 重试和乱序可能让旧数据后到,直接覆盖会把新状态改回旧状态。
### 【基础】哪些错误应该重试?
**参考答案**:临时性错误:超时、连接失败、5xx、429;不应该重试:认证失败、权限不足、参数错误等 4xx。重试要有上限、指数退避和抖动,429 遵守 `Retry-After`。
**追问**:为什么要加抖动?→ 避免大量客户端在同一时刻重试造成“惊群”,把恢复中的服务再次打垮。
## 进阶
### 【进阶】增量同步的水位线怎么设计?
**参考答案**:使用 (更新时间, 主键) 组合,按这个顺序分页拉取;本批数据成功落库后在同一事务中推进水位线;处理迟到数据时回拉一个重叠窗口,依赖幂等写入去重;定期对账兜底。
**追问**:来源没有更新时间字段怎么办?→ 使用来源的自增 id / 变更日志 / CDC;都没有就只能定期全量比对(按哈希或汇总比较)。
### 【进阶】怎么保证数据质量?
**参考答案**:字段级校验(类型、必填、枚举、范围),坏数据进死信并保留原文;批次级检查(数量波动、空值率、唯一性);与源头对账(数量、金额汇总);异常时停止写入并告警;为质量规则写测试。
**追问**:校验失败的数据怎么处理?→ 进入死信表,修复规则或上游后重新处理;比例超阈值整批回滚,避免污染下游。
### 【进阶】多个工作进程调用同一个限流的第三方接口,怎么控制?
**参考答案**:使用集中式限流:Redis 令牌桶 / 滑动窗口(Lua 脚本保证原子),按配额维度(平台 + 应用 / 商家)计数;拿不到令牌就等待或重新入队;监控 429 比例动态调整。
**追问**:令牌桶和漏桶的区别?→ 令牌桶允许一定突发(桶内有积累的令牌);漏桶以固定速率输出,更平滑。
## 场景题
### 【场景题】同步脚本中途挂掉,重跑后出现重复数据和漏数据,你怎么改?
**参考答案**:引入水位线(落库成功后才推进)、幂等 upsert + 版本比较、重叠窗口处理迟到数据、单商家任务互斥、坏数据死信、批次质量检查和对账告警。详见[第三方订单同步场景](scenarios/third-party-sync.md)和[示例代码](examples/incremental-sync/)。
**追问**:怎么验证修好了?→ 写测试:重复执行结果不变、中途失败后续跑不丢数据、旧版本不覆盖新版本、质量检查不通过时回滚。
### 【场景题】RAG 知识库需要每天从多个来源(网盘、Wiki、工单系统)采集文档,你怎么设计管道?
**参考答案**:每个来源一个连接器,按增量(修改时间 / 变更 API)拉取;统一处理流程:解析 → 清洗 → 分块 → 嵌入 → 写入向量库 / ES(按文档 id + 分块序号幂等);删除和权限变更同步;嵌入接口限流和重试;记录每个文档的处理状态和版本;失败进死信可重试;质量检查(解析失败率、空文档、重复率);对账确认来源和索引一致。
**追问**:嵌入模型升级怎么办?→ 新建索引用新模型全量重建,评估通过后切换别名,旧索引保留回滚。
@@ -0,0 +1,81 @@
---
id: backend.data-pipeline.scenario.third-party-sync
title: 第三方平台订单同步:限流、断点续跑、迟到数据、对账和告警
type: scenario
domain: backend
stack: [data-pipeline, postgresql, redis, mq]
tags: [第三方对接, 增量同步, 限流, 对账, 迟到数据, 告警]
level: intermediate
prerequisites: [backend.data-pipeline.reliability]
est_hours: 2.5
related: [backend.data-pipeline.interview, backend.redis.lock-ratelimit]
week: [14]
---
# 第三方平台订单同步:限流、断点续跑、迟到数据、对账和告警
## 业务背景与问题
公司为商家提供 SaaS 经营分析和 AI 报表助手,需要把商家在多个电商平台的订单同步过来。现状是一个简单的定时脚本,问题频发:
1. 平台接口限流,高峰期大量 429,脚本直接失败;
2. 脚本中途挂掉后从头再跑,产生重复订单;
3. 少量订单状态和平台对不上(退款了这边还是已支付);
4. 某次平台接口返回字段变更,脏数据写入了几个小时才被商家发现。
## 约束
- 每个平台的限流规则不同,而且按“商家授权的应用”计算配额。
- 上千个商家,每个商家每 10 分钟同步一次。
- 平台没有提供变更推送,或者推送不可靠。
## 方案设计
1. **任务拆分**:调度器每 10 分钟为每个“商家 × 平台”生成一个同步任务,投递到队列;多个工作进程消费;同一个商家同一时间只运行一个任务(分布式锁或队列分区)。
2. **限流**:按“平台 + 应用”在 Redis 中做令牌桶,所有工作进程共享;429 按 `Retry-After` 退避。
3. **断点续跑**:每个任务有自己的水位线(`updated_at + id`),本页数据落库后才推进;重叠窗口回拉 5 分钟处理迟到数据;upsert 带版本比较。
4. **数据质量**:
- 字段级校验(类型、枚举、金额范围),坏数据进死信表并带原始报文;
- 批次级检查:坏数据比例、与上周同时段的数据量对比;
- 不通过就停止该平台的同步并告警,避免继续写入脏数据。
5. **对账**:每天凌晨按商家拉取前一天的订单汇总(数量、金额、各状态数量)与本地比对,差异自动补拉并记录。
6. **可观测**:每个任务记录拉取数、写入数、死信数、重试次数、耗时;面板按平台展示;连续失败、死信突增、对账差异超阈值时告警。
## 关键代码
基于 Redis 的共享令牌桶(Lua 保证原子性):
```lua
-- KEYS[1]=桶的 key ARGV: rate(每秒), capacity, now(毫秒)
local b = redis.call('HMGET', KEYS[1], 'tokens', 'ts')
local rate, cap, now = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
local tokens = tonumber(b[1]) or cap
local ts = tonumber(b[2]) or now
tokens = math.min(cap, tokens + (now - ts) / 1000 * rate)
local ok = 0
if tokens >= 1 then tokens = tokens - 1; ok = 1 end
redis.call('HSET', KEYS[1], 'tokens', tokens, 'ts', now)
redis.call('PEXPIRE', KEYS[1], math.ceil(cap / rate * 1000) + 1000)
return ok
```
单进程版本的完整实现和测试:[examples/incremental-sync](../examples/incremental-sync/)。
## 取舍
| 选择 | 优点 | 缺点 |
| --- | --- | --- |
| **队列 + 工作进程 + 共享限流(本方案)** | 可水平扩展、互不影响 | 需要队列和 Redis |
| 单个定时脚本串行同步 | 简单 | 商家多了跑不完,一个失败影响全部 |
| 引入 Airflow 等编排平台 | 可视化、重跑方便 | 学习和运维成本,对小团队偏重 |
## 易错点
- 限流计数放在进程内存中,多个工作进程加起来超过配额。
- 同一商家的两个任务并发运行,水位线互相覆盖。
- 平台字段变更时没有校验,脏数据持续写入。
- 只有“任务失败”告警,没有“数据量异常”告警:任务成功但拉回 0 条同样是问题。
## 面试怎么讲
> “我们对接了多个电商平台的订单。调度器为每个商家生成同步任务进队列,工作进程消费;限流用 Redis 令牌桶按平台和应用共享;每个任务有水位线,落库后才推进,回拉 5 分钟重叠窗口处理迟到数据,upsert 时比较更新时间防止旧数据覆盖。字段校验不过进死信,坏数据比例和数据量异常都会停止同步并告警。每天凌晨按汇总对账,差异自动补拉。”