从Node-RED到Go规则引擎:标准语法与Rete匹配实践
Node-RED 这类可视化流编排工具,在 IoT 和自动化场景里确实好用,但把它当成一个正经的规则引擎来用,很多坑要等到规则数量上来、并发压力上去之后才暴露。我们团队去年做边缘网关的风控模块,最初就是基于 Node-RED 搭的,后来连续被多线程性能、规则状态管理、灰度发布三件事反复折腾,最终决定跳出 Node-RED,基于标准规则语法做了一个 Go 先行实现的自研规则引擎。这篇文章把我们在技术选型、语法设计、引擎实现、压测踩坑中的完整思路写下来,希望对正在选型规则引擎的团队有帮助。
1. Node-RED 真正的天花板:从一次多线程压测说起
1.1 我们最初为什么选 Node-RED
说实话,Node-RED 对于原型验证和中小体量的自动化任务是加分项。它的可视化画布让业务方也能看懂整个流转链路,自带的 MQTT、HTTP、WebSocket 节点基本覆盖了接入层需求,一个节点拖出来、连上线、注入 JSON 就能跑。团队当时做边缘网关的规则预警,规则量在 100 条以内时,Node-RED 开发效率确实很高,一个同事半天就能把大部分规则节点接完。
但“快”不等于“稳”。规则引擎业务的本质是对大量离散事实做模式匹配,而不是单纯的消息转发。随着规则从几十条增长到几百条,画布上节点之间的连线越来越像一张蜘蛛网,维护成本开始指数级上升。这个时候再去依赖 Node-RED 自带的数独式编排,已经谈不上开发效率了,只能叫“在存量复杂度之上继续堆复杂度”。
1.2 单事件循环与多线程需求之间的错位
很多人在搜索 “node-red 多线程” 时,其实想解决的是同一个问题:Node-RED 默认运行在单个 Node.js 进程里,所有 flow 共享一个事件循环。对纯 IO 型场景这没有问题,但风控规则里经常要做时间窗口统计、频次汇总、名单比对,这些计算一旦变重,事件循环里的长任务会让整个 flow 出现几十毫秒甚至几百毫秒的吞吐抖动。
我们当时压测一组“5 分钟窗口内同一用户交易次数超过 10 次”的规则,消息量为每秒 300 条时,Node-RED 进程的 CPU 会阶段性拉满,后面进来的 MQTT 消息集体排队。尽管社区有 node-red-contrib-concurrent 这类并行节点可以做 worker 拆分,但拆分规则里的人为控制,本质上就是让开发者替框架承担并发设计。真正到了需要横向扩容、需要多实例共享规则状态的时候,Node-RED 的粘性会话和无状态执行模型会制造比它解决的问题更多的麻烦:规则命中后的状态到底存在哪?多实例间怎么同步?一个流程里挂掉的子流程如何补偿?
1.3 超过 200 条规则之后的失控感
另一个被低估的痛点,是规则版本与灰度发布。在 Node-RED 里,流程图是配置即运行时的,线上改了节点立刻生效,这等于说所有规则共用一套运行时 Schema,任何一个写错字段的 Function 节点都可能导致整条链路的消息解析崩掉。规则超过 200 条后,我们发现很难再说清楚“某条规则现在在哪个环境”这类问题,更别提把规则的命中率、误杀率做成可观测指标了。
这些问题的本质在于:Node-RED 更像一个可以编排数据的流工具,而一个规则引擎必须拥有独立的规则生命周期、一致的语义模型、可预测的单条规则能耗。这也是我们最终决定重写引擎的核心动机。我们需要的是一个能嵌入现有 Go 微服务、按标准规则语法定义、可单测可压测可观测的规则运行时,而不是一张被越拖越复杂的流程图。
2. “标准语法”是什么,我们如何做出取舍
2.1 规则引擎的标准语法不止一种
当团队决定脱离可视化编排,自研规则引擎时,摆在面前的第一步不是写代码,而是定义规则语言。严格来说,业界已经有几套事实标准:Drools 的 DRL(Drools Rule Language)、对象管理组推出的 DMN(Decision Model and Notation)、还有老牌的 CLIPS 规则语法。每套语言的抽象层级不同,适合的人群也不同。
其中 DMN 是标准组织定义的决策模型,适合业务分析师与开发之间的对齐,但落到引擎实现上需要引入 FEEL 表达式引擎,对 Go 生态相对陌生;CLIPS 历史悠久,但语法与现代应用开发的心智模型比较脱节;DRL 则是 Drools 生态中最流行的声明式规则语言,网上资料多,开发者上手快,而且它的 when / then 结构天然适合描述业务约束。
我们最终的选择是:以类 DRL 的声明式规则语法作为主语法基线,同时预留 DMN 模型的导入入口。我不建议从一开始就做多语法支持,先把一门口碑好的语法吃透,再考虑扩展,否则引擎的核心就会被“表达式适配”拖垮。
2.2 标准语法的三个实在收益
第一,可读性和一致性。规则不是一次性代码,上线之后要持续被审计、修改。标准语法让团队新人都能快速看懂一条规则做了什么,而这种可读性在可视化画布里很难获得——你看到的是一个节点,但你不知道它的判断条件在哪个配置项里。
第二,低迁移成本。Drools 用户积累了大量 DRL 规则资产,如果我们的引擎兼容这套语法,那别人迁移过来时不需要重写语义,只需要改运行时 API。做工具的,最怕的就是“导入即改写”的隐形迁移成本,标准语法直接把这个成本搬走了。
第三,可测试性。文本规则可以进入 Git,可以做 diff,可以在 CI 里做规则级单测。我们在项目里给规则专门做了一个 engine_linter,在提交阶段检查:规则是否可达、是否存在循环依赖、salience 数值是否合理。可视化流程很难做到这种细粒度检查,这算是脱离画布后最值钱的收获之一。
2.3 语法与语义对齐的细节
一套规则引擎活得好不好,语法只是外壳,语义才是内脏。我们在实现类 DRL 语法时,对四个语义做了明确规定:
- 规则间的执行顺序只由
salience显式控制,禁止依赖事实插入顺序决定规则优先级; - 规则条件中引用的事实对象,必须在
when的赋值子句中先声明;未声明的属性访问直接编译报错; then部分不允许做外部副作用,只允许修改事实属性、新增事实或调用引擎注册好的 action;- 同一批规则里命中的多条规则进入议程(Agenda),按 salience 降序执行,同 salience 时按规则名自然排序。
这段语义收敛的过程很值得。因为标准语法大家都会读,但底层引擎是否严格执行语义,决定了系统跑久了会不会出现“看起来对了但没人知道为什么对”的规则。我们坚持在源码层面把这些语义作为不变量,虽然初期实现多花了一点时间,但后续调试成本大幅下降。
下面是一段示例规则,表达的是“5 分钟内同一用户下单超过 3 次且单笔金额超 1000,则置为风险订单”:
从这条例子能看到标准语法的好处:复杂的时间窗口约束不再需要写成一段命令式循环,规则把“条件断言”和“结果动作”分离,引擎负责找到满足全部约束的事实组合。这就是声明式规则引擎和普通脚本的核心差异所在。
3. Go 先行实现:为什么是 Go 而不是 Java 或 Rust
3.1 先明确选型坐标系
做规则引擎首先要选基础语言,这不是拍脑袋的环节。团队当时在三个候选里评估:Java(事实最强、Drools 生态成熟)、Rust(性能上限高、但团队学习曲线陡)、Go(工程化轻、并发模型顺手、和现有微服务体系一致)。
Java 阵营理论上可以直接基于 Drools 或者开源的 EasyRules 做封装,开发量最小,但团队想要的是一个可以被嵌入边缘网关、静态编译成单一二进制的轻量运行时。Java 的 JVM 启动、内存占用和部署方式显然不占优。Rust 虽然性能好,可团队里能熟练用 Rust 做工程交付的人太少,规则引擎这种偏业务建模的组件,如果研发周期拉长到 3 个月以上,ROI 就不太划算了。
3.2 Go 的优势不是性能,而是工程契合度
Go 在规则引擎里真正的优势,第一是 goroutine 并发模型。规则匹配过程中的事实分组、条件求值天然可以拆成并行任务,sync.Map 加 errgroup 就能把“按用户维度拆分工作内存再执行”这件事实现在几十行代码内,这种模式的阅读门槛比 Java 的线程池低得多。
第二是静态编译和部署。规则引擎最终要被嵌入团队现有的 Go 微服务平台,交叉编译成 Linux arm64 二进制就能直接丢到边缘网关上跑,不依赖脚本运行时,也不需要在生产服务器上安装 Node.js。这个部署模型带来的运维简化,是 Node-RED 时代完全无法想象的。
第三是 Go 的类型系统和 json tag 在事实对象建模上的便利。规则里的字段最终都来自收到的 JSON 消息,Go 结构体可以天然成为工作内存的事实类型,字段名映射、时间解析、默认值处理都有现成方案。
3.3 已知的技术债,我们选择先认下来
当然,Go 实现规则引擎也有短板。最明显的是没有现成的 Rete 算法高性能实现,Drools 家族积累了几十年的模式匹配优化在 Go 生态里基本没有同价位替代品,这意味着我们必须在引擎内部重新实现一遍节点共享和 Join 优化。
引用类型和指针对象太多的话,Go 的 GC 压力也会上来。规则匹配会创建大量临时绑定对象,如果不注意内存复用,一个 10 万事实的大批次就会让堆内存冲上天。我们在设计时就确定了原则:事实对象尽量用值类型为主的 struct,规则上下文里的绑定关系用对象池复用。
这些“债”都是可承受的技术债,而且是自己设计引擎必然要还的。反而用脚本语言起家的可视化规则引擎,一旦遇到高吞吐场景,欠的债会更难还。这也是我们坚持 Go 先行实现的核心理由——不被既有框架的表象限制,把规则的求值路径彻底掌控在自己手里。
4. 核心架构落地:Rete 匹配网络在 Go 里的真实形态
4.1 为什么选 Rete 而不是线性扫描
规则引擎最简单的实现方式是“规则列表 + 全量条件循环”,规则少时怎么跑都行,规则一多就废了。比如 500 条规则、每条规则 4 个条件,每条事实都要执行 2000 次条件判断,100 万条事实就是 20 亿次比较,这个量不用压测都能算出来。
Rete 算法的核心思路是“共享子条件”:把条件拆成 Alpha 节点、Beta 节点,构成一个判别网络,事实插入后的匹配结果可以增量复用。上一个匹配周期里已经成立的模式,下一次无需重新判断。这非常契合风控场景里事实高频流入、规则低频变更的特点——规则网络是相对静态的,事实才是动态的。
我们落地 Rete 网络时没有完全照搬 Drenth 的实现,而是做了一套针对 Go 语言特性的精简版:
4.2 工作内存与事实插入流程
工作内存(Working Memory)是规则的“事实存储层”,所有被插入的事实类型都会注册到引擎的类型索引里。一个事实进来后,引擎不会遍历所有规则,而是先交给根节点按事实类型分发,再走 Alpha 网络做单条件过滤,最后在 Beta 节点做多条件 Join。
这里有个关键设计:Join 条件的分组键。我们规定 Beta 节点的 joinKey 必须是“在同一规则内、两个模式共同引用的事实字段”。比如 User.id == Order.userId 这个 Join,会把 userId 作为 map 的 key,这样内存中匹配的是同一 key 下的小集合,而不是两个全量集合的笛卡尔积。
插入流程的核心代码如下,展示了引擎对外暴露的简化接口:
propagateToBeta 会沿着 Alpha 节点的下游依次执行 Join,命中后在 Beta 节点内存里追加绑定对,并在最后汇总成候选项,进 Agenda。这套链路虽然看起来节点多,但每个节点只做一件事,定位问题的时候整个流程非常清晰。
4.3 冲突解决:Agenda 里的有序执行
当多条规则在同一批事实里都命中时,引擎不能全部同时执行,必须按照 Agenda(议程)排序。我们的 Agenda 使用一个小顶堆实现,排序权重等于 salience,同分时按规则名的字典序执行,保证了同批规则执行的可重入性。
Agenda 的另一个职责是防循环。规则执行过程中如果修改了事实,可能再次激活新的规则,形成级联。我们给 Session 设置了 MaxFireLimit,默认 1000 次,超出后中断本次触发并返回错误。生产环境里把该值调小到 200,避免因规则误写导致的引擎死循环拖垮整个进程。
值得提醒的是,工作内存中的事实不是无限保留的。我们提供了一个时间窗口策略:事实在插入时可以附加 TTL(例如 5m),到期后由后台 goroutine 自动移出内存。这个策略直接承接了类似“5 分钟窗口”这一类时间约束的诉求,也避免了内存无限增长。类似的设计在搜索引擎里叫倒排,在规则引擎里叫事实过期,本质都是内存换时间,但要控制边界。
5. 完整实战:一条风控订单拦截规则从编写到上线
5.1 场景定义
先描述场景:一个电商下单接口,希望拦截“近 5 分钟同一收货手机号累计下单金额超过 5000 元”的订单。注意这里的关键词是“累计金额”,它不是一个普通字段,而是要对历史订单做聚合计算。这比案例示例里单纯“次数判断”更复杂。
我们把订单事实 Order 定义为拥有 mobile、amount、createdAt 字段的 Go 结构体。规则语法中,如果引擎直接支持 sum(amount) 聚合函数,就会让规则大幅简化。我们在 Lua 风格的 action 函数里注册了一个名为 aggSum 的内置聚合器,让规则语言保持声明式。
这是一段核心规则:
5.2 在 Go 服务里集成引擎的完整流程
接下来是把规则引擎嵌进服务的完整三步。先从加载规则开始:
然后在 HTTP handler 里创建 Session,逐条插入事实,并且把历史事实一并通过时间窗口回调从 Redis 拉回。为了性能,我们将同一个 mobile 的历史订单聚合为一条 OrderGroup 事实,而不是把每个订单都插入工作内存,这是我们在压测后做出的重要优化。
FireAllRules 返回所有命中的规则名和绑定的消息对象,方便上层做审计日志。我们在线上把审计日志单独接到了 ClickHouse,这套链路不只是拦截,更是一种可观测的规则验证体系。
5.3 调试心得:单测规则比单测代码更重要
规则引擎上线后,最怕遇到“规则本身错了”。我们在 CI 里加了一层规则测试门禁:每个规则文件旁边放一个 .drl_test.yaml,描述给定样本数据应该命中/不命中的规则名。引擎会加载这些样本,插入工作内存后断言结果。
比如这个“近 5 分钟累计超 5000”的规则,就配了两组数据:一组是三条订单同一手机号累计 5200 元,断言拦截;另一组是五条订单不同手机号,断言不拦截。这样的测试能防止后来者改一条共享规则时,把别人的风控也顺带破坏。在实际项目中,这比任何代码 review 都更能守住规则系统的稳定性。
调试时还有一个很容易被忽略的细节:规则的字段名与 Go 结构体 Tag 保持一致。如果规则文件里写了 orderNo,而结构体 Tag 是 order_no,那么编译期不会报错,运行时只能得到一直为 false 的匹配。我们特意在加载规则时做了反射检查,规则里引用的任何字段如果在目标结构体上不存在,直接抛编译错误,而不是留到线上跑挂了再发现。
6. 压测结论与踩过的四个大坑
6.1 第一版压测结果
规则引擎写完后,我们立刻做了一轮基准压测。机器是 8C16G 的容器,场景是 200 条规则、每条规则平均 3 个条件,工作内存里预置不同规模的历史事实,然后连续灌入 10 万条实时订单。结果如下表:
| 场景 | 事实总量 | 规则数 | 总耗时 | 平均单条耗时 | 峰值内存 | 说明 |
|---|---|---|---|---|---|---|
| 小规模 | 1 万事实 | 200 | 1.2s | 12µs | 210MB | 全量匹配 + 聚合 |
| 中规模 | 10 万事实 | 200 | 8.7s | 87µs | 620MB | 内存随事实量线性上涨 |
| 大规模 | 50 万事实 | 200 | 39.5s | 395µs | 1.3GB | 接近极限,建议分片执行 |
看到 50 万事实数据时,我们意识到一个很现实的问题:就算匹配网络再快,事实量超过一定数量后内存消耗就会失控。后来我们改变了策略,不再把所有历史事实一次性载入工作内存,而是提前在 SQL 侧或者 Redis 侧完成聚合,工作内存里只保留“含义最紧凑的事实”。上面例子里的 OrderGroup 就是对历史订单聚合之后的紧凑事实。这个调整后,中规模场景内存从 620MB 降到了 240MB,吞吐反而提升了接近 1 倍。
压测结论明确:规则引擎的性能瓶颈,通常不是规则匹配本身,而是工作内存事实模型的紧凑程度。事实先压缩再匹配,是收益最高的优化手段。
6.2 四个踩过的坑,逐个说出根因
第一个坑是规则级联死循环。当一个规则执行后的副作用满足另一个规则的条件时,会触发级联,我们最初没有给 FireAllRules 加执行次数上限,结果一个 A 置 B、B 又置 A 的规则对,让引擎在死循环里空转直到 OOM。现在引擎默认带 MaxFireLimit,而且每条规则的副作用只能修改事实属性,不能用规则代码直接调用外部服务,这是语义层面防止循环的关键。
第二个坑是共享工作内存的竞态问题。最开始我们把工作内存只分到 Session 级别,但业务里一个订单可能同时被多个 goroutine 处理,多个 goroutine 共享 Session 存在数据竞争。解决方案是给每个请求独立 Session,或者让共享 Session 内部加分段锁。我们选择了前者,因为独立 Session 的隔离性最直观,虽然事实插入的重复成本高一点,但相比排查数据竞争带来的心智成本,完全值得。
第三个坑是 Go map 的迭代顺序不稳定导致规则执行顺序不定。我们起初用 map 存储规则按名索引,结果 FireAllRules 遍历的规则顺序每次都不一样,压测和试运行都对,一到线上问题就随机。整条链路排查了很久,最后定位在 map 无序。我们改用“有序 slice + 规则名索引”的结构,问题立刻消失。写规则引擎时,凡是会影响执行结果的地方,绝对不能用无序结构。
第四个坑是字段反射的性能陷阱。reflect 虽然在插入阶段看起来只调用几次,但每条事实的字段求值都会触发反射,单条事实在十位字段上的反射开销会放大到毫秒级。我们在规则编译阶段做了字段索引预计算:把每个条件表达式编译成对应的 struct field 序号,执行时直接按序号取值,绕开反射。编译后的求值速度提升了一个数量级。
7. 下一步规划:标准语法的更进一步与 WASM 热更新
到现在为止,这套 Go 先行实现的规则引擎已经在团队的边缘网关稳定运行了三个月,规则总量稳定在 300 条左右,支持了订单拦截、频控、设备指纹异常等 5 个线上场景。不过它距离“可社区化、可产品化”还有几步,我们在接下来的迭代里已经有明确方向。
首先是语法纯度进一步提升。我们希望把类 DRL 的解析从手写递归下降替换为基于 ANTLR 的完整文法,用来支持更多高级特性,比如跨规则的临时变量、函数调用、复合条件对象。同时打算加入 DMN 决策表的导入能力,让不写代码的业务同学通过表格就能维护一部分映射型规则标准,共通语义但独立执行,两个入口都统一到同一套事实模型上。
其次是规则热更新。Go 二进制静态编译的优点同时也是缺点:规则变了也要重新编译。我们现在是提前把规则编译进二进制,线上要改规则必须发版,这在部分业务里是不能接受的。长期方案是用 WASM 虚拟机承载规则动作:Go 引擎只负责模式匹配,匹配到的规则结果交给 WASM 里的 action 函数执行,这样动作可以独立于引擎热加载。Go 集成了 wasmtime 这类运行时,在性能和隔离性上都有保障。虽然会牺牲一点点吞吐,但换来规则动作的按需更新,对很多业务是刚需。
最后想说的是,不要把“标准语法”当成银弹,它的价值是让规则脱离某个特定工具而存在,让人可以用管理代码的工程手段去管理规则。Node-RED 没有错,它只是在复杂度到达某个阈值后,不再适合作为规则引擎使用。而我们从 Go 先行实现出发,把标准语法的路子趟通了一遍,这个方案目前在成本和性能上都能兼顾生产需求。之后如果继续演进,我会把语法规范、引擎 API 和压测基线逐步整理成公开文档再放出来,供有同样需求的团队参考。