上一篇文章我们深入探讨了如何在 256MB 内存、500MHz CPU 的资源受限网关上跑采集任务，核心结论是"优化算法比换语言更有效"。但那篇文章的前提假设仍然是"采集→上传"的单向模式。这一篇，我们要把这个假设打破------当采集网关不再只是上传数据，而是要在边缘侧做本地决策、与云端协同运行规则、甚至在云端完全不可达时独立自治数天，架构会发生什么变化？
1. 一个价值 300 万的场景
2022 年，我参与过一个化工厂的项目。现场有一个聚合反应釜，温度必须在 185±2°C 范围内，超过 187°C 必须在 100ms 内开启冷却夹套阀门。温度传感器通过 4-20mA 模拟量输入到 PLC，PLC 通过 Modbus TCP 传给采集网关，网关通过 MQTT 上传到云端 SCADA。
问题出现在网络层面：工厂的 4G 路由器在每天下午 3 点左右会出现一次 1-3 秒的抖动（原因后来定位是附近一台大型电机启动导致的电磁干扰）。在那 3 秒内，云端收不到数据，即便收到了，从 PLC 读取 → 网关解析 → MQTT 发布 → 云端 Broker → SCADA 处理 → 操作员看到 → 手动操作，全链路延迟在 400-800ms------远超过 100ms 的要求。
客户的 IT 经理说："上 5G 专网就好了。" 但是 5G 专网覆盖整个厂区的报价是 300 万，且施工周期 6 个月。
真正的解决方案不是升级网络，而是在边缘侧做决策。 冷却阀门的逻辑不需要等云端判断------它需要在网关本地毫秒级完成。
这个场景引出了本篇要解决的三个核心问题：
| 问题 | 传统做法 | 问题所在 |
|---|---|---|
| 实时控制 | 数据→云端→人工→操作 | 延迟不可控（200ms-几秒） |
| 规则管理 | 固化在网关代码中，改规则要升级固件 | 现场 1000+ 网关，升级一次半个月 |
| 离线运行 | 数据缓存，上线后补传 | 离线期间业务逻辑停摆 |
2. 云边协同的三种架构模式
2.1 模式总览
graph TB
subgraph "模式 A: 本地决策 + 云端分析"
PLC1["PLC/传感器"] -->|"实时数据"| EDGE1["边缘网关(毫秒级规则)"]
EDGE1 -->|"即时动作"| ACT1["执行器/报警"]
EDGE1 -->|"聚合数据(1s~1min)"| CLOUD1["云端 SCADA"]
CLOUD1 -->|"趋势分析/训练"| DASH1["仪表盘"]
end
subgraph "模式 B: 云端训练 + 边缘推理"
PLC2["PLC/传感器"] -->|"原始数据"| EDGE2["边缘网关(模型推理)"]
EDGE2 -->|"推理结果"| ACT2["本地决策"]
CLOUD2["云端/GPU集群"] -->|"模型更新(增量delta)"| EDGE2
EDGE2 -->|"推理日志"| CLOUD2
end
subgraph "模式 C: 边缘自治 + 云端聚合"
PLC3["PLC/传感器"] <-->|"离线运行"| EDGE3["边缘网关(完全自治)"]
EDGE3 -.->|"网络恢复后补传+仲裁"| CLOUD3["云端"]
CLOUD3 -->|"规则同步(版本化)"| EDGE3
end
三种模式的核心区别：
| 维度 | 模式 A（本地决策） | 模式 B（边缘推理） | 模式 C（边缘自治） |
|---|---|---|---|
| 决策延迟 | < 10ms | < 50ms | < 10ms |
| 云端依赖 | 依赖云端做分析 | 依赖云端更新模型 | 完全独立运行 |
| 离线能力 | 规则继续运行，分析数据暂存 | 推理继续，模型不再更新 | 全部功能正常运行 |
| 典型场景 | 阈值报警、连锁保护 | 振动分析、视觉检测 | 偏远站点、移动装备 |
| 规则复杂度 | 布尔逻辑/简单计算 | ML 模型推理 | 完整控制逻辑 |
本篇聚焦模式 A + 模式 C 的组合------最实用的云边协同架构：边缘网关运行本地规则引擎、云端负责规则管理和全局分析、离线时网关自治运行。
2.2 为什么不是模式 B ？
模式 B（云端训练+边缘推理）在概念上很吸引人，但在实际的 PLC 采集场景中，90% 的现场根本不需要 ML 模型。温度超限报警、压力突降检测、流量累积计算------这些在 500MHz 上用简单的算术逻辑就能完成，不需要 GPU、不需要 TensorFlow Lite。
如果你真的需要 ML 推理，第 12 篇的 Isolation Forest 已经能在边缘跑，合并第 9 篇的 FFT 特征提取即可。这一篇我们解决的是更基础也更普遍的问题：边缘规则引擎的设计与云边协同。 规则引擎是所有边缘智能的基石，无论上面跑的是布尔逻辑还是 ML 模型。
3. 边缘规则引擎------安全且可热加载
3.1 为什么不能直接 eval()？
这是第一个深坑。很多工程师的第一反应是：
python
# ❌ 危险做法------永远不要在生产中用
def execute_rule(expression: str, context: dict):
return eval(expression, {"__builtins__": {}}, context)即使你传入了空的 __builtins__，仍有绕过方式：
python
# eval("__import__('os').system('rm -rf /')", {"__builtins__": {}}, {})
# 上述代码在 Python 中仍可能通过 __subclasses__() 链式调用逃逸规则引擎必须安全 ，因为规则是从云端下发的------如果云端被攻破或规则传输被篡改，eval() 就是整个工厂的 RCE 后门。
3.2 安全的替代方案：AST 受限求值
python
"""
edge_rule_engine.py --- 安全可热加载的边缘规则引擎
核心设计：
1. 规则用受限的 DSL 表达（不是 Python 代码）
2. 使用 ast.parse + 自定义 NodeVisitor 做白名单校验
3. 只允许：比较运算、算术运算、逻辑运算、属性/元素访问
4. 禁止：函数调用、import、属性赋值、循环/推导式
5. 支持热加载：监听文件变化或 MQTT 消息
"""
import ast
import operator
import json
import time
import threading
from typing import Any, Dict, List, Optional, Callable
# ===== 安全求值器 =====
class SafeExpressionError(Exception):
"""表达式执行异常"""
pass
class ExpressionValidator(ast.NodeVisitor):
"""
AST 节点访问验证器
遍历表达式 AST，检查是否包含违规节点。
白名单策略：只允许明确列出的节点类型。
"""
ALLOWED_NODES = {
ast.Expression, ast.BoolOp, ast.BinOp, ast.UnaryOp,
ast.Compare, ast.Name, ast.Constant,
ast.Load, ast.Store,
ast.Attribute, ast.Subscript, ast.Slice,
ast.Index, # Python 3.8 兼容
ast.List, ast.Tuple, ast.Dict,
ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Mod,
ast.Pow, ast.FloorDiv,
ast.And, ast.Or, ast.Not,
ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE,
ast.In, ast.NotIn,
ast.USub, ast.UAdd,
ast.IfExp, # x if cond else y
}
def __init__(self):
self.errors = []
def visit(self, node):
node_type = type(node)
if node_type not in self.ALLOWED_NODES:
self.errors.append(
f"禁止节点类型: {node_type.__name__} (行 {getattr(node, 'lineno', '?')})"
)
return # 不继续深入
self.generic_visit(node)
def validate(self, expression: str) -> bool:
"""验证表达式是否安全，返回 True/False"""
self.errors = []
try:
tree = ast.parse(expression, mode='eval')
self.visit(tree)
return len(self.errors) == 0
except SyntaxError as e:
self.errors.append(f"语法错误: {e}")
return False
class SafeEvaluator:
"""
安全表达式求值器
用 ast.literal_eval + 自定义操作符映射实现受限求值。
"""
# 操作符映射
_OPERATORS = {
ast.Add: operator.add,
ast.Sub: operator.sub,
ast.Mult: operator.mul,
ast.Div: operator.truediv,
ast.Mod: operator.mod,
ast.Pow: operator.pow,
ast.FloorDiv: operator.floordiv,
ast.And: lambda a, b: a and b,
ast.Or: lambda a, b: a or b,
ast.Not: operator.not_,
ast.Eq: operator.eq,
ast.NotEq: operator.ne,
ast.Lt: operator.lt,
ast.LtE: operator.le,
ast.Gt: operator.gt,
ast.GtE: operator.ge,
ast.USub: operator.neg,
ast.UAdd: operator.pos,
}
def __init__(self):
self._validator = ExpressionValidator()
def evaluate(self, expression: str, context: Dict[str, Any]) -> Any:
"""
在受限上下文中安全求值
Args:
expression: DSL 表达式字符串，如 "temp > 185 and pressure < 10"
context: 变量上下文，如 {"temp": 186.5, "pressure": 8.2}
Returns:
求值结果（通常是 bool）
Raises:
SafeExpressionError: 表达式不安全或执行出错
"""
if not self._validator.validate(expression):
raise SafeExpressionError(
f"表达式不安全: {expression}\n -> {self._validator.errors[0]}"
)
try:
tree = ast.parse(expression, mode='eval')
return self._eval_node(tree.body, context)
except Exception as e:
raise SafeExpressionError(f"执行错误: {e}") from e
def _eval_node(self, node, context: Dict) -> Any:
"""递归求值 AST 节点"""
if isinstance(node, ast.Constant):
return node.value
elif isinstance(node, ast.Name):
if node.id in context:
return context[node.id]
raise SafeExpressionError(f"变量未定义: {node.id}")
elif isinstance(node, ast.BinOp):
left = self._eval_node(node.left, context)
right = self._eval_node(node.right, context)
op_func = self._OPERATORS.get(type(node.op))
if op_func is None:
raise SafeExpressionError(f"不支持的操作: {type(node.op).__name__}")
return op_func(left, right)
elif isinstance(node, ast.UnaryOp):
operand = self._eval_node(node.operand, context)
op_func = self._OPERATORS.get(type(node.op))
if op_func is None:
raise SafeExpressionError(f"不支持的操作: {type(node.op).__name__}")
return op_func(operand)
elif isinstance(node, ast.BoolOp):
values = [self._eval_node(v, context) for v in node.values]
op_func = self._OPERATORS.get(type(node.op))
if op_func is None:
raise SafeExpressionError(f"不支持的操作: {type(node.op).__name__}")
result = values[0]
for v in values[1:]:
result = op_func(result, v)
return result
elif isinstance(node, ast.Compare):
left = self._eval_node(node.left, context)
for op, comparator in zip(node.ops, node.comparators):
right = self._eval_node(comparator, context)
op_func = self._OPERATORS.get(type(op))
if op_func is None:
raise SafeExpressionError(f"不支持的操作: {type(op).__name__}")
if not op_func(left, right):
return False
left = right
return True
elif isinstance(node, ast.Attribute):
obj = self._eval_node(node.value, context)
if hasattr(obj, node.attr):
return getattr(obj, node.attr)
raise SafeExpressionError(f"对象没有属性 {node.attr}")
elif isinstance(node, ast.Subscript):
obj = self._eval_node(node.value, context)
key = self._eval_node(node.slice, context)
return obj[key]
elif isinstance(node, ast.IfExp):
cond = self._eval_node(node.test, context)
if cond:
return self._eval_node(node.body, context)
return self._eval_node(node.orelse, context)
raise SafeExpressionError(f"不支持的节点: {type(node).__name__}")
# ===== 规则 DSL 定义 =====
class Rule:
"""
一条规则的定义
DSL 格式（JSON）:
```json
{
"rule_id": "reactor_001_hi_temp",
"version": 3,
"name": "反应釜高温报警",
"description": "当温度 > 185 且持续超过 3 秒时触发报警",
"condition": "temp > 185 and duration > 3",
"actions": [
{"type": "alarm", "severity": "critical", "message": "反应釜超温!"},
{"type": "write_to_plc", "register": 40001, "value": 1},
{"type": "mqtt_publish", "topic": "alarms/reactor", "qos": 1}
],
"debounce_ms": 1000,
"enabled": true,
"priority": 1
}
```
"""
def __init__(self, rule_dict: dict):
self.rule_id: str = rule_dict["rule_id"]
self.version: int = rule_dict.get("version", 1)
self.name: str = rule_dict.get("name", "")
self.description: str = rule_dict.get("description", "")
self.condition: str = rule_dict["condition"]
self.actions: List[dict] = rule_dict.get("actions", [])
self.debounce_ms: int = rule_dict.get("debounce_ms", 0)
self.enabled: bool = rule_dict.get("enabled", True)
self.priority: int = rule_dict.get("priority", 10)
# 运行时状态（非序列化）
self._last_fired: float = 0.0
self._condition_met_since: Optional[float] = None
self._eval_count: int = 0
self._fire_count: int = 0
def evaluate(self, context: dict, evaluator: SafeEvaluator,
now: float) -> Optional[dict]:
"""
评估规则是否触发
Args:
context: 当前数据上下文
evaluator: 安全求值器
now: 当前时间戳 (time.perf_counter)
Returns:
如果触发，返回 action 列表；否则返回 None
"""
if not self.enabled:
return None
self._eval_count += 1
try:
result = evaluator.evaluate(self.condition, context)
except SafeExpressionError as e:
return None
if result:
if self._condition_met_since is None:
self._condition_met_since = now
# 防抖检查
elapsed = (now - self._condition_met_since) * 1000 # ms
if elapsed >= self.debounce_ms:
# 检查是否在冷却中
if (now - self._last_fired) * 1000 >= self.debounce_ms:
self._last_fired = now
self._fire_count += 1
return self.actions
else:
self._condition_met_since = None
return None
# ===== 规则引擎 =====
class RuleEngine:
"""
边缘规则引擎
核心能力：
1. 加载规则集（本地文件或 MQTT 下发）
2. 安全求值条件表达式
3. 执行触发动作
4. 热加载（不重启进程）
"""
def __init__(self, evaluator: Optional[SafeEvaluator] = None):
self.evaluator = evaluator or SafeEvaluator()
self._rules: Dict[str, Rule] = {}
self._lock = threading.Lock()
self._action_handlers: Dict[str, Callable] = {}
self._stats = {
"total_evaluations": 0,
"total_fires": 0,
"last_evaluation_time": 0.0,
}
def load_rules(self, rules: List[dict]):
"""
加载/替换规则集（原子操作，热加载安全）
Args:
rules: 规则字典列表（来自 JSON 或 MQTT）
"""
new_rules = {}
for rule_dict in rules:
rule = Rule(rule_dict)
new_rules[rule.rule_id] = rule
with self._lock:
old_count = len(self._rules)
self._rules = new_rules
print(f"规则集已更新: {old_count} → {len(new_rules)} 条规则")
def add_rule(self, rule_dict: dict):
"""添加/更新单条规则（原子操作）"""
rule = Rule(rule_dict)
with self._lock:
old = self._rules.get(rule.rule_id)
if old and old.version >= rule.version:
return # 旧版本或相同版本，忽略
self._rules[rule.rule_id] = rule
action = "更新" if old else "新增"
print(f"[规则 {action}] {rule.rule_id} v{rule.version}")
def remove_rule(self, rule_id: str):
"""删除规则"""
with self._lock:
self._rules.pop(rule_id, None)
def register_action_handler(self, action_type: str,
handler: Callable[[dict], None]):
"""注册动作处理器"""
self._action_handlers[action_type] = handler
def evaluate_all(self, context: dict) -> List[dict]:
"""
评估所有规则，返回所有触发的动作
Args:
context: 数据上下文，如 {"temp": 186.5, "pressure": 8.2}
Returns:
所有触发的动作列表
"""
now = time.perf_counter()
triggered_actions = []
with self._lock:
sorted_rules = sorted(
self._rules.values(), key=lambda r: r.priority
)
rules_copy = list(sorted_rules)
for rule in rules_copy:
actions = rule.evaluate(context, self.evaluator, now)
if actions:
for action in actions:
triggered_actions.append({
"rule_id": rule.rule_id,
"rule_name": rule.name,
"action": action,
"context": context,
"timestamp": time.time(),
})
if triggered_actions:
self._stats["total_fires"] += len(triggered_actions)
self._stats["total_evaluations"] += len(rules_copy)
self._stats["last_evaluation_time"] = now
return triggered_actions
def execute_actions(self, triggered_actions: List[dict]):
"""执行触发动作（同步调用处理器）"""
for item in triggered_actions:
action = item["action"]
action_type = action.get("type")
handler = self._action_handlers.get(action_type)
if handler:
try:
handler(action)
except Exception as e:
print(f"动作执行失败 [{action_type}]: {e}")
@property
def stats(self) -> dict:
with self._lock:
return {
**self._stats,
"rules_count": len(self._rules),
"rules": {
rid: {
"evaluations": r._eval_count,
"fires": r._fire_count,
"enabled": r.enabled,
}
for rid, r in self._rules.items()
},
}
# ===== 使用示例 =====
if __name__ == "__main__":
# 初始化安全求值器
evaluator = SafeEvaluator()
# 验证安全边界
print("=== 安全验证 ===")
dangerous_exprs = [
"__import__('os').system('rm -rf /')",
"open('/etc/passwd').read()",
"[x for x in range(10)]",
"lambda x: x + 1",
]
for expr in dangerous_exprs:
ok = evaluator._validator.validate(expr)
print(f" [{'安全' if ok else '已拦截':>4}] {expr}")
# 初始化规则引擎
engine = RuleEngine(evaluator)
# 注册动作处理器
engine.register_action_handler("alarm", lambda a:
print(f" 🔔 报警: [{a['severity']}] {a['message']}"))
engine.register_action_handler("write_to_plc", lambda a:
print(f" ⚡ PLC写入: 寄存器 {a['register']} = {a['value']}"))
engine.register_action_handler("mqtt_publish", lambda a:
print(f" 📡 MQTT发布: {a['topic']}"))
# 加载规则集
rules_config = [
{
"rule_id": "reactor_001_hi_temp",
"version": 1,
"name": "反应釜高温报警",
"condition": "temp > 185",
"debounce_ms": 2000,
"actions": [
{"type": "alarm", "severity": "critical",
"message": "反应釜超温!"},
{"type": "write_to_plc", "register": 40001, "value": 1},
],
"priority": 1,
"enabled": True,
},
{
"rule_id": "reactor_002_pressure_drop",
"version": 1,
"name": "压力突降检测",
"condition": "pressure < 5 and prev_pressure > 8",
"debounce_ms": 5000,
"actions": [
{"type": "alarm", "severity": "warning",
"message": "压力异常下降!"},
],
"priority": 2,
"enabled": True,
},
]
engine.load_rules(rules_config)
# 模拟采集数据，驱动规则引擎
print("\n=== 规则引擎运行 ===")
scenarios = [
{"temp": 182.0, "pressure": 8.5, "prev_pressure": 8.5},
{"temp": 186.5, "pressure": 8.2, "prev_pressure": 8.2}, # 触发高温
{"temp": 186.5, "pressure": 8.0, "prev_pressure": 8.0},
{"temp": 187.2, "pressure": 7.5, "prev_pressure": 7.5}, # 持续高温
{"temp": 184.0, "pressure": 4.2, "prev_pressure": 7.5}, # 触发压力突降
]
for i, ctx in enumerate(scenarios):
print(f"\n[周期 {i+1}] temp={ctx['temp']}, "
f"pressure={ctx['pressure']}")
actions = engine.evaluate_all(ctx)
if actions:
engine.execute_actions(actions)
else:
print(" (无动作)")
print("\n=== 规则统计 ===")
stats = engine.stats
print(f"总评估次数: {stats['total_evaluations']}")
print(f"总触发次数: {stats['total_fires']}")
for rid, rstats in stats['rules'].items():
print(f" {rid}: 评估={rstats['evaluations']}次, "
f"触发={rstats['fires']}次")3.3 安全边界总结
| 表达式 | AST 验证结果 | 绕过难度 |
|---|---|---|
__import__('os') |
拦截（函数调用） | 无法绕过 |
open('/etc/passwd') |
拦截（函数调用） | 无法绕过 |
| 列表推导式 | 拦截（ListComp） | 无法绕过 |
temp > 185 or tag['pressure'] < 5 |
通过 | N/A |
(temp - 180) * 0.5 + 32 > 100 |
通过 | N/A |
1 if temp > 185 else 0 |
通过 | N/A |
如果你需要在规则中支持更复杂的功能（如字符串操作、时间函数），可以扩展 ExpressionValidator.ALLOWED_NODES 并在 _eval_node 中添加对应的处理逻辑。但永远不要打开函数调用的白名单------规则引擎不是通用的代码执行环境。
4. 云边规则同步------版本化的增量下发
4.1 为什么规则同步比数据上传难？
数据上传是"边缘→云端"的单向流，失败可以重试、乱序可以重排。但规则同步是"云端→边缘"的下发流，它面临三个特有的问题：
- 事务性：5 条规则组成的规则集，如果只有 3 条到达边缘，规则集处于部分更新状态------可能导致错误动作
- 版本一致性：云端改了规则 v2，热加载后边缘正在执行 v2。但新采集的数据点可能用了 v1 的上下文------历史数据回放时用哪个版本？
- 回滚：v3 的规则有 bug，需要立即回退到 v2。如果每个网关的网络状态不同，回滚的传播时间可能长达数小时
4.2 MQTT Topic 设计
sequenceDiagram
participant Cloud as 云端规则管理器
participant MQTT as MQTT Broker
participant Edge as 边缘网关
Cloud->>MQTT: rules/v1/deploy (规则全量快照)
MQTT->>Edge: rules/v1/deploy
Edge->>MQTT: rules/v1/ack (确认版本)
Cloud->>MQTT: rules/v1/patch (增量更新: 新增/修改/删除)
MQTT->>Edge: rules/v1/patch
Edge->>MQTT: rules/v1/ack (确认patch)
Note over Cloud,Edge: 规则 v2 发布
Cloud->>MQTT: rules/v2/deploy (完整规则集)
MQTT->>Edge: rules/v2/deploy
Edge->>MQTT: rules/v2/ack
Note over Edge: 发现 v2 有bug
Edge->>MQTT: rules/rollback/request (请求回滚)
Cloud->>MQTT: rules/v1/deploy (重新下发 v1)
MQTT->>Edge: rules/v1/deploy
Topic 结构：
python
"""
mqtt_rule_sync.py --- 基于 MQTT 的规则同步实现
Topic 层级：
rules/{version}/deploy --- 云端→边缘，全量规则发布
rules/{version}/patch --- 云端→边缘，增量更新
rules/{version}/ack --- 边缘→云端，确认回执
rules/{gateway_id}/rollback --- 边缘→云端，请求回滚
"""
import json
import time
import hashlib
from typing import Optional, Callable
class RuleSyncProtocol:
"""
规则同步协议
核心保证：
- At-least-once delivery: MQTT QoS=1 + 应用层 ACK
- 幂等性: 相同 version + hash 的消息多次处理结果一致
- 原子性: 全量部署时只有确认完整接收后才替换当前规则集
"""
PROTOCOL_VERSION = 1
def __init__(self, gateway_id: str, mqtt_client):
self.gateway_id = gateway_id
self.client = mqtt_client
self._current_version = 0
self._pending_deploy: Optional[dict] = None
def build_deploy_message(self, version: int,
rules: list) -> dict:
"""构建全量部署消息"""
payload = json.dumps(rules, sort_keys=True).encode()
checksum = hashlib.sha256(payload).hexdigest()
return {
"protocol_version": self.PROTOCOL_VERSION,
"version": version,
"timestamp": time.time(),
"checksum": checksum,
"rules_count": len(rules),
"rules": rules,
}
def build_patch_message(self, version: int,
changes: dict) -> dict:
"""
构建增量更新消息
Args:
changes: {
"add_or_update": [rule1, rule2, ...],
"remove": ["rule_id_1", "rule_id_2", ...]
}
"""
payload = json.dumps(changes, sort_keys=True).encode()
checksum = hashlib.sha256(payload).hexdigest()
return {
"protocol_version": self.PROTOCOL_VERSION,
"version": version,
"timestamp": time.time(),
"checksum": checksum,
"changes": changes,
}
def send_ack(self, version: int, status: str,
checksum: str, message: str = ""):
"""发送确认回执"""
ack = {
"gateway_id": self.gateway_id,
"version": version,
"status": status, # "accepted" | "rejected" | "error"
"checksum": checksum,
"timestamp": time.time(),
"message": message,
}
topic = f"rules/{version}/ack"
self.client.publish(
topic, json.dumps(ack), qos=1, retain=False
)
def verify_checksum(self, rules: list,
expected_checksum: str) -> bool:
"""验证规则集的完整性"""
payload = json.dumps(rules, sort_keys=True).encode()
actual = hashlib.sha256(payload).hexdigest()
return actual == expected_checksum
# ===== 边缘端规则同步处理 =====
class EdgeRuleSyncHandler:
"""
边缘端规则同步处理器
职责：
1. 订阅规则下发 topic
2. 验证规则完整性 (checksum)
3. 原子性更新规则引擎
4. 发送 ACK 确认
5. 处理增量更新
"""
def __init__(self, gateway_id: str, mqtt_client,
rule_engine: 'RuleEngine'):
self.protocol = RuleSyncProtocol(gateway_id, mqtt_client)
self.rule_engine = rule_engine
self._current_version = 0
def handle_deploy(self, payload: dict):
"""
处理全量部署消息（原子性）
"""
version = payload["version"]
checksum = payload["checksum"]
rules = payload["rules"]
# 1. 版本检查（不接受旧版本或重复版本）
if version <= self._current_version:
self.protocol.send_ack(
version, "rejected", checksum,
f"当前版本 {self._current_version} 不低于 {version}"
)
return
# 2. 完整性验证
if not self.protocol.verify_checksum(rules, checksum):
self.protocol.send_ack(
version, "error", checksum, "Checksum 不匹配"
)
return
# 3. 原子性更新规则引擎
try:
self.rule_engine.load_rules(rules)
self._current_version = version
self.protocol.send_ack(version, "accepted", checksum)
print(f"规则已更新到 v{version} ({len(rules)} 条)")
except Exception as e:
self.protocol.send_ack(
version, "error", checksum, str(e)
)
def handle_patch(self, payload: dict):
"""
处理增量更新
"""
version = payload["version"]
checksum = payload["checksum"]
changes = payload["changes"]
if version != self._current_version + 1:
self.protocol.send_ack(
version, "rejected", checksum,
f"版本不连续: 当前 {self._current_version}, 收到 {version}"
)
return
# 删除规则
for rule_id in changes.get("remove", []):
self.rule_engine.remove_rule(rule_id)
# 添加/更新规则
for rule_dict in changes.get("add_or_update", []):
self.rule_engine.add_rule(rule_dict)
self._current_version = version
self.protocol.send_ack(version, "accepted", checksum)关键设计决策：
| 机制 | 为什么需要 | 出错后果 |
|---|---|---|
| Checksum 完整性验证 | 防止 MQTT 消息损坏或 TCP 分包导致的规则不完整 | 规则集损坏→意外动作→安全事故 |
| 版本连续检查 | 防止跳过中间版本导致规则状态不一致 | v2→v4 直接跳转可能漏掉 v3 到期的规则 |
| ACK 回执 | 云端知道规则是否成功到达每个网关 | 云端认为已更新，实际边缘仍是旧规则 |
| 全量部署（vs 仅增量） | 新网关加入时从零初始化 | 新网关永远在 v0 |
一个现场教训： 早期版本只使用增量更新，结果某次 patch 丢失后（MQTT QoS=1 仍可能重复或乱序），边缘端的规则集与云端永久不一致。后来我加了一条铁律：每隔 24 小时强制执行一次全量部署，以消除累积的偏差。这条规则看似浪费带宽，但它阻止了超过一半的云边不一致问题。
4.3 规则冲突检测
规则集大了之后，必然出现冲突。最典型的一种：
规则 A：当
temp > 185时，开启冷却阀（valve = 1） 规则 B：当pressure < 5时，关闭冷却阀（valve = 0）
如果 temp = 187 且 pressure = 4，两条规则同时触发，写同一个寄存器的相反值------最后执行的那条覆盖前一条。结果完全取决于规则遍历顺序。
实现一个简单的冲突检测：
python
def detect_write_conflicts(rules: list) -> list:
"""
检测规则间的"写冲突"
如果两条规则在同一个条件下可能写同一个寄存器，报告冲突。
这是一个静态分析，不需要执行规则。
"""
writes = {} # register -> [(rule_id, condition)]
conflicts = []
for rule in rules:
for action in rule.get("actions", []):
if action.get("type") == "write_to_plc":
register = action.get("register")
condition = rule.get("condition", "")
rule_id = rule.get("rule_id", "")
if register in writes:
for prev_rule_id, prev_cond in writes[register]:
conflicts.append({
"register": register,
"rule_a": prev_rule_id,
"condition_a": prev_cond,
"rule_b": rule_id,
"condition_b": condition,
"risk": "条件重叠时可能导致冲突",
})
writes.setdefault(register, []).append((rule_id, condition))
return conflicts这个函数在云端规则管理器保存新规则集时调用，云端自动发现冲突并推送给运维人员确认。
5. 边缘自治------当云端消失的 72 小时
5.1 自治架构
stateDiagram-v2
[*] --> Normal: 启动/上线
Normal --> Degraded: 网络中断 > 30s
Degraded --> Autonomous: 网络中断 > 300s
Autonomous --> Normal: 网络恢复 + 同步完成
Normal --> Normal: 心跳正常
Degraded --> Degraded: 规则继续运行
Autonomous --> Autonomous: 满负荷运行
state Normal {
[*] --> RuleEval: 规则决策
RuleEval --> CloudSync: 数据上云
CloudSync --> [*]: 云端确认
}
state Autonomous {
[*] --> LocalRuleEval: 规则决策
LocalRuleEval --> LocalStore: 数据本地缓存
LocalStore --> BacklogTracking: 记录缺失区间
BacklogTracking --> [*]: 等待网络恢复
}
边缘自治不是"停在那等网络恢复"，而是网关应在离线期间保持全部功能，并在网络恢复后自动仲裁数据一致性。
5.2 离线检测
python
"""
edge_autonomy.py --- 边缘自治模式实现
"""
import time
import threading
import json
from collections import deque
from typing import Optional
class ConnectionMonitor:
"""
云端连接监控器
通过 MQTT 心跳判断云端是否可达。
使用三档状态机：Normal → Degraded → Autonomous
"""
STATE_NORMAL = "normal"
STATE_DEGRADED = "degraded" # 网络不稳定，降级部分功能
STATE_AUTONOMOUS = "autonomous" # 完全离线，全功能本地运行
def __init__(self, mqtt_client, rule_engine: 'RuleEngine',
heartbeat_interval_s: float = 10.0):
self.client = mqtt_client
self.rule_engine = rule_engine
self.heartbeat_interval = heartbeat_interval_s
self.state = self.STATE_NORMAL
self._last_heartbeat_ack: float = time.time()
self._missed_heartbeats = 0
self._lock = threading.Lock()
self._running = True
def start(self):
"""启动心跳监控线程"""
t = threading.Thread(target=self._monitor_loop, daemon=True)
t.start()
def stop(self):
self._running = False
def on_heartbeat_ack(self):
"""收到云端心跳回执"""
with self._lock:
self._last_heartbeat_ack = time.time()
self._missed_heartbeats = 0
if self.state != self.STATE_NORMAL:
old_state = self.state
self.state = self.STATE_NORMAL
print(f"网络恢复: {old_state} → normal")
def _monitor_loop(self):
"""心跳监控循环"""
while self._running:
time.sleep(self.heartbeat_interval)
with self._lock:
elapsed = time.time() - self._last_heartbeat_ack
expected_acks = elapsed / self.heartbeat_interval
self._missed_heartbeats = int(expected_acks)
new_state = self.state
if self._missed_heartbeats >= 30: # 300s 无心跳
new_state = self.STATE_AUTONOMOUS
elif self._missed_heartbeats >= 3: # 30s 无心跳
new_state = self.STATE_DEGRADED
if new_state != self.state:
old_state = self.state
self.state = new_state
print(f"状态切换: {old_state} → {new_state} "
f"(missed={self._missed_heartbeats})")
# 根据状态切换规则引擎模式
self._apply_mode(new_state)
def _apply_mode(self, state: str):
"""根据连接状态调整规则引擎配置"""
if state == self.STATE_NORMAL:
self.rule_engine.set_mode("normal")
elif state == self.STATE_DEGRADED:
self.rule_engine.set_mode("degraded")
elif state == self.STATE_AUTONOMOUS:
self.rule_engine.set_mode("autonomous")
class BacklogTracker:
"""
在线数据区间追踪器
记录哪些时间段的数据已经成功上云，
哪些时间段的数据需要补传。
"""
def __init__(self):
# 记录未确认的数据区间 [(start_ts, end_ts), ...]
self._gaps: deque = deque()
self._lock = threading.Lock()
def mark_sent(self, start_ts: float, end_ts: float):
"""标记一个数据区间已发送（但还未确认）"""
with self._lock:
self._gaps.append((start_ts, end_ts, "pending"))
def mark_confirmed(self, end_ts: float):
"""
标记所有早于 end_ts 的区间为已确认
云端按序号递增确认，所以可以批量清理
"""
with self._lock:
while self._gaps and self._gaps[0][1] <= end_ts:
self._gaps.popleft()
@property
def pending_gaps(self) -> list:
"""返回所有未确认的区间（网络恢复后补传）"""
with self._lock:
return [(s, e) for s, e, _ in self._gaps]
@property
def max_backlog_seconds(self) -> float:
"""最长的未确认数据时长"""
with self._lock:
if not self._gaps:
return 0.0
return time.time() - self._gaps[0][0]5.3 恢复后的数据仲裁
网络恢复后，边缘网关需要面对一个棘手的问题：云端已经记录的数据 vs 边缘补传的数据------以哪个为准？
python
"""
timestamp_arbitration.py --- 边缘恢复后的时间戳仲裁
核心问题：
边缘时钟不可信（RTC 在无 NTP 时每天漂移数秒）
云端时钟可信（假设 NTP 同步）
仲裁策略：
1. 每条数据记录两个时间戳：
-采集时间戳 (ts_采集): PLC 侧的扫描时间（如可能）
-到达时间戳 (ts_到达): 数据到达云端的时间
2. 以云端到达时间为基准，对采集时间戳进行线性修正
3. 相同采集时间戳的数据，取后到达者（覆盖旧值）
"""
def reconcile_timestamps(edge_records: list,
cloud_records: list,
cloud_arrival_base: float) -> list:
"""
仲裁边缘和云端的时间戳
Args:
edge_records: 边缘缓存的数据 [{ts, value, seq}, ...]
cloud_records: 云端已存在的数据 [{ts, value, seq}, ...]
cloud_arrival_base: 最后一条云端记录到达云端的时刻
Returns:
需要补传给云端的数据列表（已去重、已排序）
"""
if not edge_records:
return []
# 1. 构建云端序列号索引（快速去重）
cloud_seqs = {r["seq"] for r in cloud_records}
# 2. 过滤：只补传云端没有的序列号
to_backfill = [r for r in edge_records
if r["seq"] not in cloud_seqs]
if not to_backfill:
return []
# 3. 时间戳修正：检测边缘时钟漂移
# 用最后一条已知的对应关系做线性校正
if cloud_records:
last_cloud = max(cloud_records, key=lambda r: r["seq"])
drift = cloud_arrival_base - last_cloud["ts"]
# 如果漂移超过 5 秒，标记并修正
if abs(drift) > 5.0:
print(f"边缘时钟漂移 {drift:.1f}s，正在进行时间戳修正")
for r in to_backfill:
r["ts"] += drift
to_backfill.sort(key=lambda r: r["ts"])
return to_backfill你可能以为边缘时钟漂移是小事------实际上它是现场最常见的坑之一。 一个只有 RTC（实时时钟）没有 NTP 的嵌入式设备，在 40°C 的现场机柜里，每天漂移 5-15 秒是常态。如果不用云端到达时间做校准，补传的数据会被打上错误的时间戳，导致时序图出现"倒退"或"断层"。
6. 完整代码：云端规则管理器
把上述组件拼装成一个完整的边缘网关采集+规则+云边同步系统：
python
"""
edge_gateway_full.py --- 边缘网关完整实现
包含：
- Modbus 采集线程
- 规则引擎评估线程
- 心跳/连接监控
- 数据缓存与补传
- MQTT 规则同步
"""
import time
import json
import threading
from collections import deque
from typing import Optional
# 导入上述组件
# from edge_rule_engine import RuleEngine, SafeEvaluator
# from mqtt_rule_sync import EdgeRuleSyncHandler
# from edge_autonomy import ConnectionMonitor, BacklogTracker
class EdgeGateway:
"""
完整的边缘网关
架构：
┌──────────────────────────────────────────┐
│ 采集线程 ──→ 环形缓冲区 ──→ 规则引擎 │
│ ↓ │
│ 数据分发器 ──→ MQTT 发布 │
│ ↓ │
│ 缓存管理器 ──→ SQLite │
│ ↓ │
│ 连接监控 ←── 心跳 │
│ ↓ │
│ 规则同步 ←── MQTT 规则 topic │
└──────────────────────────────────────────┘
"""
def __init__(self, gateway_id: str, mqtt_config: dict):
self.gateway_id = gateway_id
# 组件
self.rule_engine = RuleEngine()
self.evaluator = SafeEvaluator()
self.backlog = BacklogTracker()
# MQTT 客户端（伪代码，实际用 paho-mqtt）
self.mqtt_client = self._init_mqtt(mqtt_config)
# 连接监控
self.connection_monitor = ConnectionMonitor(
self.mqtt_client, self.rule_engine
)
# 规则同步
self.rule_sync = EdgeRuleSyncHandler(
gateway_id, self.mqtt_client, self.rule_engine
)
# 运行状态
self._running = False
self._mode = "normal" # normal | degraded | autonomous
def _init_mqtt(self, config):
"""初始化 MQTT 客户端并订阅规则 topic"""
# import paho.mqtt.client as mqtt
# client = mqtt.Client(self.gateway_id)
# client.on_message = self._on_mqtt_message
# client.connect(config["host"], config["port"])
# client.subscribe([
# ("rules/+/deploy", 1),
# ("rules/+/patch", 1),
# ])
# return client
pass # 示意，实际集成时需要替换为真实 MQTT
def _on_mqtt_message(self, topic, payload):
"""处理 MQTT 消息"""
try:
msg = json.loads(payload)
if topic.endswith("/deploy"):
self.rule_sync.handle_deploy(msg)
elif topic.endswith("/patch"):
self.rule_sync.handle_patch(msg)
except json.JSONDecodeError:
pass
def on_data_point(self, point: dict):
"""
每采集到一个数据点时调用
这是整个网关的核心路径：
采集 → 规则评估 → 动作执行 → 数据发布
"""
# 1. 规则评估
context = point # 数据点作为评估上下文
triggered = self.rule_engine.evaluate_all(context)
if triggered:
self.rule_engine.execute_actions(triggered)
# 2. 根据连接状态决定数据发布策略
state = self.connection_monitor.state
if state == ConnectionMonitor.STATE_NORMAL:
# 正常模式：实时发布 + 标记已发送
self._publish(point)
self.backlog.mark_sent(point["ts"], point["ts"])
elif state == ConnectionMonitor.STATE_DEGRADED:
# 降级模式：降低发布频率
if point["seq"] % 5 == 0:
self._publish(point)
self.backlog.mark_sent(point["ts"], point["ts"])
else: # autonomous
# 自治模式：不发布，只缓存
self._cache_locally(point)
# 记录缺失区间以便恢复后补传
self.backlog.mark_sent(point["ts"], point["ts"])
def _publish(self, point: dict):
"""发布数据点到 MQTT"""
topic = f"data/{self.gateway_id}/{point.get('tag', 'unknown')}"
# self.mqtt_client.publish(topic, json.dumps(point), qos=1)
pass
def _cache_locally(self, point: dict):
"""在自治模式下本地缓存数据"""
# 写入 SQLite（批量缓冲，第 13 篇的策略）
pass
def on_network_restore(self):
"""网络恢复后的处理"""
# 1. 补传缺失数据
gaps = self.backlog.pending_gaps
if gaps:
print(f"网络恢复，补传 {len(gaps)} 个数据区间")
# 从本地缓存读取数据并补传
# 使用时间戳仲裁算法避免重复
# 2. 检查规则版本是否最新
# 如果自治期间规则集被修改，请求全量同步
print("请求规则全量同步")
# self.mqtt_client.publish(
# f"rules/{self.gateway_id}/sync_request", "", qos=1
# )
def set_mode(self, mode: str):
"""设置运行模式，调整内部行为"""
self._mode = mode
configs = {
"normal": {"publish_interval": 1, "quality": "full"},
"degraded": {"publish_interval": 5, "quality": "reduced"},
"autonomous": {"publish_interval": 0, "quality": "full"},
}
config = configs.get(mode, configs["normal"])
print(f"网关[{self.gateway_id}] 模式: {mode} → {config}")
return config
def start(self):
"""启动网关"""
self._running = True
self.connection_monitor.start()
print(f"边缘网关 [{self.gateway_id}] 启动")
def stop(self):
"""停止网关"""
self._running = False
self.connection_monitor.stop()
print("边缘网关停止")
# ===== 使用示例 =====
if __name__ == "__main__":
gw = EdgeGateway("GW-ATEX-001", {
"host": "mqtt.cloud.example.com",
"port": 1883,
})
gw.start()
# 模拟采集点
test_points = [
{"tag": "reactor_temp", "value": 186.5, "ts": time.time(),
"seq": 1001},
{"tag": "reactor_temp", "value": 188.0, "ts": time.time(),
"seq": 1002},
]
for pt in test_points:
gw.on_data_point(pt)
gw.stop()7. 常见深坑与根本原因分析
深坑 1：规则计算导致采集周期崩溃
现象：加入规则引擎后，采集周期从稳定的 1s 变成 2-5s 且剧烈抖动。
根因 ：规则引擎的 evaluate_all() 在规则数量增加时不是线性扩展的。每条规则都做了 AST 解析→节点遍历→递归求值。当你从 10 条规则扩展到 100 条，CPU 时间从 5ms 飙升到 200ms------加上 Modbus 读取 300ms，压缩 100ms，MQTT 150ms，总预算 750ms。看似够（< 1000ms），但如果某条规则的表达式引用了大量 context 变量（foo.bar.baz.qux 这种深层属性链），单条规则的求值时间可能从 0.5ms 飙升到 50ms。
解决：
- 规则引擎和采集线程分属不同的线程，规则评估在空闲 CPU 时间片执行
- 缓存 AST 解析结果（
ast.parse只在规则加载时做一次，不在每个周期重复做） - 对规则设置 CPU 预算------如果某条规则连续 3 个周期超时，自动标记为"慢规则"并降级为每 5 周期评估一次
深坑 2：规则版本回滚导致"僵尸规则"
现象：云端将规则从 v3 回滚到 v2，但边缘网关某些规则仍然保持 v3 的行为。
根因 ：增量 patch 操作不是幂等的。v3 的 patch 内容是"删除规则 A、新增规则 B"，回滚到 v2 时云端重新下发 v2 的全量快照。但如果 v2 的全量快照中包含规则 A，而网关之前已经（通过 v3 的 patch）删除了规则 A，此时检查 _current_version 发现 v2 < v3，拒绝接收------规则 A 永远丢失。
解决 ：回滚操作必须强制忽略版本比较 ，用 force=True 参数：
python
def handle_rollback(self, payload: dict):
"""处理回滚操作（强制覆盖版本检查）"""
version = payload["version"]
rules = payload["rules"]
checksum = payload["checksum"]
# 回滚不检查 version 递增，直接替换
self.rule_engine.load_rules(rules)
self._current_version = version
self.protocol.send_ack(version, "accepted", checksum)深坑 3：自治模式下 SQLite 缓存撑爆 256MB
现象：网关离线 72 小时后，SQLite 缓存了约 62 万条记录（2000 点 × 1Hz × 72h × 3600s），数据库文件膨胀到 200MB 以上，触发 OOM。
根因 ：第 13 篇优化过的 SQLite 缓存策略（cache_size=-512、WAL 模式）在"正常采集+定期上报"场景下工作良好。但在自治模式下，数据只入不出------没有 MQTT 发布消耗缓存队列，SQLite 持续增长直到撑满。
解决 ：在自治模式下，需要主动降级数据精度 ------不是在采集时降级（会丢失原始数据），而是在落盘前做压缩：
python
class AutonomousStorageManager:
"""自治模式下的存储管理"""
def __init__(self, max_db_size_mb: int = 50):
self.max_db_size = max_db_size_mb * 1024 * 1024
def should_compress(self, db_path: str) -> bool:
"""检查是否需要对旧数据做降采样压缩"""
import os
size = os.path.getsize(db_path)
if size > self.max_db_size:
return True
return False
def downsample_old_data(self, conn):
"""
对超过 1 小时前的数据做降采样
原始: 1Hz × 3600s = 3600 条/小时
降采样: 每 10 秒取一个平均值 = 360 条/小时
压缩比: 90%
"""
conn.execute("""
INSERT OR REPLACE INTO data_cache_downsampled
SELECT
tag,
MIN(ts) as ts_start,
MAX(ts) as ts_end,
AVG(value) as value_avg,
MIN(value) as value_min,
MAX(value) as value_max,
COUNT(*) as sample_count
FROM data_cache
WHERE ts < strftime('%s', 'now', '-1 hour')
GROUP BY tag, CAST(ts / 10 AS INTEGER)
""")
conn.execute("""
DELETE FROM data_cache
WHERE ts < strftime('%s', 'now', '-1 hour')
""")
conn.commit()这个策略在自治模式启动时（ConnectionMonitor 检测到 STATE_AUTONOMOUS 时）自动启用。
8. 总结
graph TB
subgraph "边缘网关核心链路"
PLC["PLC/设备"] -->|"Modbus 采集1Hz ~ 100Hz"| RING["环形缓冲区"]
RING -->|"数据快照"| RE["规则引擎安全DSL + AST"]
RE -->|"即时动作"| ACT["执行器/报警< 10ms"]
RE -->|"触发记录"| STAT["规则统计评估/触发计数"]
RING -->|"批量"| MQTT["MQTT 发布QoS=1"]
end
subgraph "云边协同层"
CLOUD_MGR["云端规则管理器"] -->|"全量/增量版本+checksum"| RE
HB["心跳监控30s/300s 阈值"] -->|"状态切换"| RE
HB -->|"自治模式"| STORE["本地缓存+ 降采样"]
STORE -->|"网络恢复→ 补传"| CLOUD["云端"]
end
subgraph "保证机制"
CHKSUM["Checksum 完整性"]
VERSION["版本连续性 + 强制回滚"]
ARB["时间戳仲裁(边缘时钟漂移修正)"]
CONFLICT["写冲突静态检测"]
end
核心要点回顾：
| 维度 | 传统采集 | 云边协同采集 | 优势 |
|---|---|---|---|
| 决策位置 | 云端或人工 | 边缘本地（< 10ms） | 实时性提升 50-100 倍 |
| 规则管理 | 固化代码 | MQTT 热加载 + 版本化 | 无需升级固件 |
| 离线处理 | 缓存不决策 | 完全自治 + 恢复仲裁 | 业务零中断 |
| 安全考量 | 无（纯上传） | AST 白名单 + 函数调用拦截 | RCE 防护 |
| 一致性 | N/A | Checksum + 版本仲裁 + 时钟修正 | 数据可靠 |
最后一句经验之谈： 边缘计算最容易被低估的工作不是"写规则引擎"，而是处理边界情况 ------网络抖动时状态怎么切、时钟漂移时时间戳怎么修正、v3 回退到 v2 时僵尸规则怎么清理。这些边界情况在架构设计阶段看起来像"1% 的场景"，但在现场，这 1% 会吃掉你 90% 的排障时间。
所以这篇所有的代码都围绕一个核心原则：不要相信网络是可靠的、不要相信时钟是准确的、不要相信版本是连续的。 在这三个假设之上设计的边缘网关，才能在你的 4G 路由器下午三点准时抖动时，让你的冷却阀门在 10ms 内正常开启。
👉 下一篇预告：PLC 数采系列 15 从数据源到仪表盘------全链路端到端实战整合 14 篇文章，从最底层的 PLC 内存布局、Modbus 报文结构、OPC UA 握手开销，到 MQTT 云边传输、离线缓存与断点续传、安全纵深防御、高速毫秒级采集、大规模千点集群架构、数据质量异常检测、256MB 资源受限环境下的性能调优，再到本篇的云边协同规则引擎------整个数据采集的知识体系已经构建完整。下一篇，也是系列的最终篇，我们将用一套完整的端到端项目把这些知识全部串起来：从一台真实的 PLC（仿真），经过边缘网关采集、规则引擎处理、MQTT 上传云端、最终在仪表盘上展示实时数据和报警。这不仅是回顾，更是你带走的一套可直接投入生产的最小可行系统。