@umacloud/knowledge 1.0.1

package/data-engineering/04-antipatterns/data-pipeline-antipatterns.md

@@ -0,0 +1,684 @@
+---
+id: data-pipeline-antipatterns
+title: 数据管道反模式完全指南
+domain: data-engineering
+category: 04-antipatterns
+difficulty: intermediate
+tags: [antipatterns, backfill, capability, data, data-engineering, failure, observability, pipeline]
+quality_score: 70
+last_updated: 2026-06-15
+---
+# 数据管道反模式完全指南
+
+> 适用范围：ETL / ELT / 流处理 / 批处理管道
+> 约束级别：SHALL（必须在 Pipeline Review 和架构评审阶段拦截）
+> 适用工具：Apache Spark / Flink / Airflow / dbt / Kafka / Prefect
+
+---
+
+## 1. 无幂等性（Non-Idempotent Pipeline）
+
+### 描述
+管道任务重试或重跑时产生重复数据或副作用。在分布式系统中网络超时、节点故障是常态，任何任务都可能被执行多次。无幂等性的管道会导致数据重复、金额多扣、指标膨胀等严重问题。
+
+### 错误示例
+```python
+# Airflow -- 非幂等的 INSERT
+@task
+def load_daily_sales(ds):
+    db.execute(f"""
+        INSERT INTO sales_summary (date, total_amount, order_count)
+        SELECT '{ds}', SUM(amount), COUNT(*)
+        FROM orders
+        WHERE order_date = '{ds}'
+    """)
+    # 重试一次 -> 同一天的数据插入两行
+    # 调度重跑 -> 数据翻倍
+```
+
+```python
+# Spark -- 非幂等的 append 模式
+def process_daily(date):
+    df = spark.read.parquet(f"s3://raw/orders/{date}/")
+    result = df.groupBy("category").agg(sum("amount"))
+    result.write.mode("append").parquet("s3://warehouse/daily_sales/")
+    # 重跑时在同一目录追加重复数据
+```
+
+### 正确示例
+```python
+# Airflow -- 幂等方案：先删后插 (UPSERT)
+@task
+def load_daily_sales(ds):
+    db.execute(f"""
+        DELETE FROM sales_summary WHERE date = '{ds}';
+        INSERT INTO sales_summary (date, total_amount, order_count)
+        SELECT '{ds}', SUM(amount), COUNT(*)
+        FROM orders
+        WHERE order_date = '{ds}';
+    """)
+    # 无论执行多少次，结果始终正确
+```
+
+```python
+# Spark -- 幂等方案：分区覆写
+def process_daily(date):
+    df = spark.read.parquet(f"s3://raw/orders/{date}/")
+    result = df.groupBy("category").agg(sum("amount"))
+    result.write.mode("overwrite").partitionBy("date").parquet(
+        "s3://warehouse/daily_sales/"
+    )
+    # 覆写当日分区，重跑结果一致
+```
+
+```sql
+-- PostgreSQL -- UPSERT (ON CONFLICT)
+INSERT INTO sales_summary (date, category, total_amount, order_count)
+SELECT order_date, category, SUM(amount), COUNT(*)
+FROM orders
+WHERE order_date = '2024-06-15'
+GROUP BY order_date, category
+ON CONFLICT (date, category)
+DO UPDATE SET
+    total_amount = EXCLUDED.total_amount,
+    order_count = EXCLUDED.order_count,
+    updated_at = NOW();
+```
+
+### 幂等性检查清单
+| 操作类型 | 幂等实现方式 |
+|---------|------------|
+| 文件写入 | 覆写目标分区 / 使用唯一文件名 |
+| 数据库写入 | DELETE + INSERT / UPSERT / MERGE |
+| API 调用 | 请求带幂等键（Idempotency Key） |
+| 消息发送 | 消费端去重 / Exactly-once 语义 |
+
+---
+
+## 2. 无监控与告警（Missing Observability）
+
+### 描述
+管道没有执行状态监控、数据量监控、延迟监控和异常告警。当管道静默失败、数据量异常下降或延迟超标时，团队无法及时感知，导致下游报表和业务系统使用错误数据。
+
+### 错误示例
+```python
+# Airflow DAG -- 无任何监控
+@dag(schedule="0 2 * * *", catchup=False)
+def daily_etl():
+    @task
+    def extract():
+        data = fetch_from_api()
+        save_to_staging(data)
+        # 如果 API 返回空数据？ 无人知晓
+        # 如果只返回了昨天数据的 10%？ 无人知晓
+
+    @task
+    def transform():
+        process_staging_data()
+        # 如果转换逻辑有 bug 丢了 30% 的行？ 无人知晓
+
+    @task
+    def load():
+        load_to_warehouse()
+        # 如果目标表被锁导致超时？ 日志被淹没
+```
+
+### 正确示例
+```python
+# Airflow DAG -- 完整监控体系
+from airflow.providers.slack.operators.slack_webhook import SlackWebhookOperator
+
+def on_failure(context):
+    """任务失败时发送告警"""
+    task_id = context["task_instance"].task_id
+    dag_id = context["dag"].dag_id
+    execution_date = context["execution_date"]
+    log_url = context["task_instance"].log_url
+    SlackWebhookOperator(
+        task_id="slack_alert",
+        slack_webhook_conn_id="slack_ops",
+        message=f":red_circle: Pipeline Failed\n"
+                f"DAG: {dag_id}\nTask: {task_id}\n"
+                f"Date: {execution_date}\nLog: {log_url}",
+    ).execute(context)
+
+@dag(
+    schedule="0 2 * * *",
+    catchup=False,
+    default_args={"on_failure_callback": on_failure},
+    sla_miss_callback=sla_alert,  # SLA 超时告警
+)
+def daily_etl():
+
+    @task
+    def extract(**context):
+        data = fetch_from_api()
+        row_count = len(data)
+
+        # 数据量异常检测
+        expected_min = get_expected_min_rows(context["ds"])
+        if row_count < expected_min * 0.5:
+            raise ValueError(
+                f"Row count {row_count} is below 50% of expected {expected_min}"
+            )
+
+        # 推送指标到 Prometheus / DataDog
+        metrics.gauge("pipeline.extract.row_count", row_count,
+                      tags={"dag": "daily_etl", "date": context["ds"]})
+        metrics.timer("pipeline.extract.duration", context["task_instance"].duration)
+
+        save_to_staging(data)
+        return {"row_count": row_count}
+
+    @task
+    def data_quality_check(extract_result, **context):
+        """独立的数据质量检查任务"""
+        checks = [
+            ("null_check", "SELECT COUNT(*) FROM staging WHERE id IS NULL"),
+            ("dup_check", "SELECT COUNT(*) - COUNT(DISTINCT id) FROM staging"),
+            ("range_check", "SELECT COUNT(*) FROM staging WHERE amount < 0"),
+        ]
+        for name, sql in checks:
+            bad_count = db.execute(sql).scalar()
+            if bad_count > 0:
+                raise DataQualityError(f"{name} failed: {bad_count} bad rows")
+
+        metrics.gauge("pipeline.quality.pass_rate", 1.0,
+                      tags={"dag": "daily_etl"})
+```
+
+### 监控维度矩阵
+| 维度 | 指标 | 告警阈值 | 工具 |
+|------|------|---------|------|
+| 执行状态 | 成功/失败/跳过 | 失败即告警 | Airflow callback |
+| 数据量 | 输入行数 / 输出行数 | < 预期 50% 或 > 200% | 自定义 check |
+| 延迟 | 任务耗时 / 数据时效 | > SLA 阈值 | Airflow SLA |
+| 数据质量 | 空值率 / 重复率 / 范围异常 | > 阈值 | Great Expectations / dbt tests |
+| 资源 | CPU / 内存 / 磁盘 | > 80% | Prometheus + Grafana |
+
+---
+
+## 3. 硬编码 Schema（Hardcoded Schema）
+
+### 描述
+在管道代码中硬编码列名、数据类型和表结构，当上游 Schema 发生变更（加列、改名、改类型）时管道静默产出错误数据或直接崩溃。
+
+### 错误示例
+```python
+# 硬编码列索引 -- 上游加列后全部错位
+def parse_csv_row(row):
+    return {
+        "user_id": row[0],
+        "name": row[1],
+        "email": row[2],    # 上游在 name 后加了 nickname 列
+        "amount": row[3],   # 实际取到的是 email
+    }
+
+# 硬编码 DataFrame 列名 -- 无验证
+def transform(df):
+    df["total"] = df["price"] * df["quantity"]
+    df["category_name"] = df["cat"]  # 上游把 cat 改成了 category
+    return df  # KeyError 或静默产出 NaN
+```
+
+### 正确示例
+```python
+# Schema 注册 + 验证
+from pydantic import BaseModel, validator
+from typing import Optional
+
+class OrderSchema(BaseModel):
+    """订单数据 Schema -- 版本化管理"""
+    order_id: str
+    user_id: int
+    amount: float
+    currency: str = "CNY"
+    status: str
+    created_at: datetime
+
+    @validator("amount")
+    def amount_must_be_positive(cls, v):
+        if v < 0:
+            raise ValueError("amount must be positive")
+        return v
+
+    @validator("status")
+    def status_must_be_valid(cls, v):
+        valid = {"pending", "paid", "shipped", "completed", "cancelled"}
+        if v not in valid:
+            raise ValueError(f"invalid status: {v}, expected one of {valid}")
+        return v
+
+def transform(raw_data: list[dict]) -> list[OrderSchema]:
+    """解析时验证 Schema，不匹配立即报错"""
+    validated = []
+    errors = []
+    for i, row in enumerate(raw_data):
+        try:
+            validated.append(OrderSchema(**row))
+        except ValidationError as e:
+            errors.append({"row": i, "error": str(e)})
+
+    error_rate = len(errors) / len(raw_data) if raw_data else 0
+    if error_rate > 0.01:  # 错误率 > 1% 则中断
+        raise SchemaValidationError(
+            f"Schema validation failed: {len(errors)} errors "
+            f"({error_rate:.1%}), first 5: {errors[:5]}"
+        )
+    return validated
+```
+
+```python
+# dbt -- Schema 测试 (schema.yml)
+# models/staging/schema.yml
+"""
+version: 2
+models:
+  - name: stg_orders
+    columns:
+      - name: order_id
+        tests: [not_null, unique]
+      - name: amount
+        tests:
+          - not_null
+          - dbt_utils.accepted_range:
+              min_value: 0
+              max_value: 1000000
+      - name: status
+        tests:
+          - accepted_values:
+              values: ['pending', 'paid', 'shipped', 'completed', 'cancelled']
+"""
+```
+
+---
+
+## 4. 忽略数据质量（Ignoring Data Quality）
+
+### 描述
+管道只负责搬运数据，不检查数据的完整性、准确性、一致性和时效性。脏数据流入下游后导致报表失真、模型预测偏差、业务决策错误，修复成本远大于预防成本。
+
+### 错误示例
+```python
+# 直接加载，不做任何质量检查
+def load_user_events(date):
+    df = spark.read.json(f"s3://raw/events/{date}/")
+    df.write.mode("overwrite").saveAsTable("warehouse.user_events")
+    # 可能包含：空 user_id、未来日期的时间戳、负数的 duration
+    # 下游看板显示 DAU 虚高（空 user_id 被计为一个用户）
+```
+
+### 正确示例
+```python
+# Great Expectations -- 数据质量检查
+import great_expectations as gx
+
+def validate_user_events(df, date):
+    context = gx.get_context()
+    validator = context.sources.pandas_default.read_dataframe(df)
+
+    # 完整性检查
+    validator.expect_column_values_to_not_be_null("user_id")
+    validator.expect_column_values_to_not_be_null("event_type")
+    validator.expect_column_values_to_not_be_null("timestamp")
+
+    # 准确性检查
+    validator.expect_column_values_to_be_between(
+        "timestamp",
+        min_value=f"{date}T00:00:00Z",
+        max_value=f"{date}T23:59:59Z",
+    )
+    validator.expect_column_values_to_be_in_set(
+        "event_type",
+        ["page_view", "click", "purchase", "signup"],
+    )
+
+    # 一致性检查
+    validator.expect_column_values_to_be_between("duration_ms", min_value=0, max_value=3600000)
+
+    # 量级检查
+    validator.expect_table_row_count_to_be_between(min_value=10000, max_value=10000000)
+
+    result = validator.validate()
+    if not result.success:
+        failed = [r for r in result.results if not r.success]
+        raise DataQualityError(f"Quality check failed: {len(failed)} checks failed")
+
+    return df
+```
+
+### 数据质量维度
+| 维度 | 检查项 | 工具 |
+|------|--------|------|
+| 完整性 | 非空、必填字段 | Great Expectations / dbt tests |
+| 准确性 | 值域、格式、参照完整性 | Pydantic / 自定义规则 |
+| 一致性 | 跨表/跨系统数据一致 | dbt_utils.equality / 自定义 |
+| 时效性 | 数据新鲜度 | dbt source freshness / 自定义 |
+| 唯一性 | 主键唯一、业务键唯一 | dbt unique test |
+| 量级合理性 | 行数在预期范围 | 自定义阈值检查 |
+
+---
+
+## 5. 单点故障（Single Point of Failure）
+
+### 描述
+管道中的关键组件（调度器、数据源连接、中间存储）只有单个实例，该实例故障时整条管道中断。在生产环境中任何组件都可能故障，必须有冗余和故障转移机制。
+
+### 错误示例
+```python
+# 单一数据源 -- 无备用
+def extract():
+    # 唯一数据源，如果 API 挂了整条管道停摆
+    data = requests.get("https://api.partner.com/data", timeout=30).json()
+    return data
+
+# 单一调度器 -- 无 HA
+# Airflow 只部署了一个 Scheduler 实例
+# Scheduler 进程挂了 -> 所有 DAG 停止调度
+
+# 中间结果存本地磁盘 -- 无冗余
+def transform(data):
+    df = pd.DataFrame(data)
+    df.to_parquet("/tmp/staging/result.parquet")  # 机器重启 -> 数据丢失
+```
+
+### 正确示例
+```python
+# 数据源冗余 + 重试 + 降级
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=60),
+    reraise=True,
+)
+def fetch_from_primary():
+    return requests.get("https://api.partner.com/data", timeout=30).json()
+
+def extract():
+    try:
+        return fetch_from_primary()
+    except Exception as e:
+        logger.warning(f"Primary source failed: {e}, falling back to replica")
+        # 降级到备用数据源
+        return requests.get("https://api-backup.partner.com/data", timeout=60).json()
+
+# 中间结果存到分布式存储
+def transform(data):
+    df = pd.DataFrame(data)
+    # S3 自带 3 副本冗余
+    df.to_parquet("s3://pipeline-staging/daily/result.parquet")
+```
+
+```yaml
+# Airflow HA 部署 -- Kubernetes
+# 多 Scheduler 实例（Airflow 2.0+ 原生支持）
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: airflow-scheduler
+spec:
+  replicas: 2  # 双 Scheduler，自动 Leader 选举
+  selector:
+    matchLabels:
+      app: airflow-scheduler
+  template:
+    spec:
+      containers:
+        - name: scheduler
+          image: apache/airflow:2.8.0
+          command: ["airflow", "scheduler"]
+          env:
+            - name: AIRFLOW__SCHEDULER__STANDALONE_DAG_PROCESSOR
+              value: "False"
+```
+
+---
+
+## 6. 无回溯能力（No Backfill Capability）
+
+### 描述
+管道只能处理当天数据，无法重新处理历史数据。当发现历史数据有误、逻辑变更需要回刷、或新增指标需要回算时，只能手动补数据或等自然累积。
+
+### 错误示例
+```python
+# 只处理"当前"数据，无参数化日期
+def daily_etl():
+    today = datetime.now().strftime("%Y-%m-%d")
+    df = spark.read.parquet(f"s3://raw/events/{today}/")
+    result = df.groupBy("category").agg(sum("amount"))
+    result.write.mode("overwrite").saveAsTable("warehouse.daily_summary")
+    # 如何回刷上个月的数据？ 改代码？ 手动循环？
+
+# 输出不按日期分区 -- 无法局部重跑
+def load(df):
+    df.write.mode("append").parquet("s3://warehouse/all_data/")
+    # 回刷某一天会导致重复，无法只覆写那一天
+```
+
+### 正确示例
+```python
+# Airflow -- 参数化日期 + 分区输出
+@dag(
+    schedule="0 2 * * *",
+    start_date=datetime(2024, 1, 1),
+    catchup=True,  # 允许回溯执行
+)
+def daily_etl():
+
+    @task
+    def extract(ds=None):
+        """ds 由 Airflow 自动传入逻辑日期"""
+        df = spark.read.parquet(f"s3://raw/events/{ds}/")
+        return df
+
+    @task
+    def transform(df, ds=None):
+        result = df.groupBy("category").agg(sum("amount").alias("total"))
+        result = result.withColumn("date", lit(ds))
+        return result
+
+    @task
+    def load(result, ds=None):
+        # 按日期分区覆写，幂等 + 可回溯
+        result.write.mode("overwrite").partitionBy("date").parquet(
+            "s3://warehouse/daily_summary/"
+        )
+
+    raw = extract()
+    transformed = transform(raw)
+    load(transformed)
+
+# 回溯命令：
+# airflow dags backfill daily_etl -s 2024-01-01 -e 2024-01-31
+```
+
+---
+
+## 7. 过度微批处理（Over-Micro-Batching）
+
+### 描述
+对不需要低延迟的场景使用过于频繁的微批处理（如每秒或每分钟），导致大量小文件（Small File Problem）、调度开销远大于计算开销、存储系统元数据压力大。
+
+### 错误示例
+```python
+# 每分钟跑一次 Spark 作业 -- 90% 时间在调度和初始化
+@dag(schedule="* * * * *")  # 每分钟
+def micro_batch_etl():
+    @task
+    def process():
+        spark = SparkSession.builder.getOrCreate()  # ~15s 启动
+        df = spark.read.parquet("s3://raw/latest/")  # ~5s 读取
+        df.write.parquet(f"s3://output/{ts}/")        # ~3s 写入
+        # 实际计算 < 2s，调度和初始化 > 20s
+        # 每天产生 1440 个小文件
+
+# Kafka -> S3 每条消息一个文件
+def process_message(message):
+    key = f"s3://events/{message['id']}.json"
+    s3.put_object(Bucket="events", Key=key, Body=json.dumps(message))
+    # 每天 100 万消息 = 100 万个小文件
+    # S3 LIST 操作 O(n)，下游 Spark 读取极慢
+```
+
+### 正确示例
+```python
+# 根据 SLA 选择合适的批次频率
+# 报表场景 -> 每日批处理
+@dag(schedule="0 2 * * *")  # 每天凌晨 2 点
+def daily_batch():
+    ...
+
+# 准实时场景 -> 每 5-15 分钟微批
+@dag(schedule="*/15 * * * *")  # 每 15 分钟
+def near_realtime():
+    ...
+
+# 真正的实时场景 -> 使用流处理引擎
+# Flink / Spark Structured Streaming
+def realtime_stream():
+    df = (
+        spark.readStream
+        .format("kafka")
+        .option("kafka.bootstrap.servers", "kafka:9092")
+        .option("subscribe", "events")
+        .load()
+    )
+
+    result = df.groupBy(
+        window("timestamp", "5 minutes"),
+        "category",
+    ).agg(sum("amount"))
+
+    result.writeStream \
+        .format("delta") \
+        .option("checkpointLocation", "s3://checkpoints/events/") \
+        .outputMode("update") \
+        .trigger(processingTime="1 minute") \
+        .start("s3://warehouse/realtime_summary/")
+```
+
+### 批次频率选择指南
+| 数据时效要求 | 推荐方案 | 适用场景 |
+|------------|---------|---------|
+| T+1（隔天） | 日批 Spark / dbt | 报表、BI、数仓 |
+| 小时级 | 每小时微批 | 运营看板、趋势监控 |
+| 分钟级 | Structured Streaming / Flink | 实时推荐、风控预警 |
+| 秒级/毫秒级 | Flink / Kafka Streams | 交易监控、欺诈检测 |
+
+---
+
+## 8. 忽视背压（Ignoring Backpressure）
+
+### 描述
+数据生产速度超过消费速度时，系统不限制上游流入速率，导致消费端 OOM、消息堆积、端到端延迟剧增。背压是流处理系统的核心挑战之一。
+
+### 错误示例
+```python
+# Kafka 消费者 -- 无流量控制
+def consume_forever():
+    consumer = KafkaConsumer("events", bootstrap_servers="kafka:9092")
+    for message in consumer:
+        # 同步处理，如果处理慢于生产速度
+        # consumer lag 持续增长 -> 最终 OOM 或数据过期被删除
+        result = heavy_transform(message.value)
+        db.insert(result)  # 如果 DB 慢，这里阻塞
+```
+
+```python
+# Spark Streaming -- 无速率限制
+df = (
+    spark.readStream
+    .format("kafka")
+    .option("subscribe", "high_volume_events")  # 每秒 100K 消息
+    .load()
+)
+# 默认读取所有可用数据 -> 每个微批次数据量爆炸 -> OOM
+```
+
+### 正确示例
+```python
+# Kafka 消费者 -- 控制消费速率 + 异步处理
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+
+class BackpressureConsumer:
+    def __init__(self, max_inflight=100):
+        self.semaphore = asyncio.Semaphore(max_inflight)
+        self.consumer = KafkaConsumer(
+            "events",
+            bootstrap_servers="kafka:9092",
+            max_poll_records=500,          # 每次 poll 最多 500 条
+            max_poll_interval_ms=300000,   # 处理超时 5 分钟
+            enable_auto_commit=False,
+        )
+
+    async def process_with_backpressure(self):
+        for message in self.consumer:
+            await self.semaphore.acquire()  # 控制并发
+            asyncio.create_task(self._process(message))
+
+    async def _process(self, message):
+        try:
+            result = await heavy_transform(message.value)
+            await db.insert(result)
+            self.consumer.commit()
+        finally:
+            self.semaphore.release()
+```
+
+```python
+# Spark Streaming -- 配置速率限制
+df = (
+    spark.readStream
+    .format("kafka")
+    .option("subscribe", "high_volume_events")
+    .option("maxOffsetsPerTrigger", 100000)  # 每个微批最多 10 万条
+    .option("minOffsetsPerTrigger", 10000)   # 最少 1 万条（避免过于频繁）
+    .load()
+)
+
+# Flink -- 内置背压机制
+# Flink 基于 Credit-based 流控，下游处理不过来时自动减慢上游
+# 监控 Flink Web UI 的 Backpressure 面板
+# 如果持续背压，需要：增加并行度 / 优化处理逻辑 / 扩容
+```
+
+### 背压处理策略
+| 策略 | 实现方式 | 适用场景 |
+|------|---------|---------|
+| 速率限制 | maxOffsetsPerTrigger / max_poll_records | 所有场景 |
+| 缓冲队列 | 内存队列 + 溢出到磁盘 | 突发流量 |
+| 丢弃策略 | 丢弃最旧 / 采样 | 可容忍数据丢失的监控场景 |
+| 动态扩容 | K8s HPA / 自动增加分区消费者 | 云原生环境 |
+| 异步 + 批量写入 | 攒批后批量写入 DB / S3 | 写入密集场景 |
+
+---
+
+## 反模式速查矩阵
+
+| # | 反模式 | 风险等级 | 典型后果 | 检测方式 |
+|---|--------|:-------:|---------|---------|
+| 1 | 无幂等性 | CRITICAL | 数据重复、金额错误 | 重跑验证 + Code Review |
+| 2 | 无监控 | HIGH | 静默故障、脏数据流入下游 | 运维审计 |
+| 3 | 硬编码 Schema | HIGH | Schema 变更后管道崩溃或静默错误 | Schema Registry + 测试 |
+| 4 | 忽略数据质量 | HIGH | 报表失真、模型偏差 | 数据质量测试 |
+| 5 | 单点故障 | HIGH | 管道完全中断 | 架构评审 + 混沌测试 |
+| 6 | 无回溯能力 | MEDIUM | 无法修复历史数据 | 回溯测试 |
+| 7 | 过度微批处理 | MEDIUM | 小文件、资源浪费 | 文件数监控 + 成本分析 |
+| 8 | 忽视背压 | HIGH | OOM、数据丢失、延迟爆炸 | 消费者 lag 监控 |
+
+---
+
+## Agent Checklist
+
+- [ ] 所有管道任务具备幂等性，重跑不产生重复数据
+- [ ] 管道具备完整监控：执行状态、数据量、延迟、质量
+- [ ] 告警覆盖所有关键失败场景，on-call 流程已建立
+- [ ] Schema 通过注册中心或 Pydantic/dbt 测试验证
+- [ ] 数据质量检查覆盖完整性、准确性、一致性、时效性
+- [ ] 关键组件无单点故障，调度器和存储有冗余
+- [ ] 管道支持参数化日期回溯，输出按日期分区
+- [ ] 批次频率与业务 SLA 匹配，无过度微批
+- [ ] 流处理场景已配置背压控制和速率限制
+- [ ] Consumer lag 和处理延迟有监控和告警