实时风控决策路径:同步拦截窗与异步监测

实时风控决策路径:同步拦截窗与异步监测

Hello,我是小兔大白糖。 提现按钮一点下去,风控要在几十毫秒里给出放行、挑战还是拦截——超时和误杀都不能当「以后再算」。写成这篇,把同步拦截窗和异步监测拆成两条平面,并写清降级与超时合同。

实时风控是在交易发生瞬间或准实时窗口内完成风险识别并给出决策的系统:事件接入 → 特征 → 规则/模型 → 执行 → 回流。

估计阅读时间:56 分钟

同步拦截与异步监测两条路径
同步拦截与异步监测两条路径 · 点击查看 SVG 原图

一句话结论是什么?

实时风控系统是一条毫秒级决策流水线:事件接入 → 特征聚合 → 规则/模型判定 → 决策执行 → 结果回流,核心矛盾是**"低延迟"与"高准确"的权衡**,通过本地缓存、异步特征补全、分级决策三级架构将 P99 延迟压到 50ms 以内。


1. 同步窗与异步窗各自管什么?

1.1 实时风控链路(Real-Time Risk Pipeline)

实时风控系统指在交易发生瞬间(同步拦截场景 < 50ms)或准实时窗口(异步审计场景 < 500ms)内,完成风险识别并给出决策的系统。

核心链路五步法:

事件接入(Event Ingestion)
    ↓
特征工程(Feature Engineering)
    ↓
规则判定(Rule Evaluation)
    ↓
模型打分(Model Scoring)
    ↓
决策执行(Decision Execution)
    ↓
结果回流(Feedback Loop)

1.2 同步拦截 vs 异步审计

维度同步拦截(Synchronous Block)异步审计(Async Audit)
延迟要求< 50ms< 500ms
决策动作阻断/放行/挑战标记/告警/人工复核
特征来源本地缓存 + 内存计算可查询外部服务/数据库
准确率要求极高(误杀代价高)较高(允许一定误报)
典型场景提现、大额转账、修改安全设置登录异常、行为轨迹分析

1.3 类比:机场安检

  • 同步拦截 = 登机口安检:必须在 30 秒内决定让不让你登机(快速、严格、误拦代价高)
  • 异步审计 = 行李后台扫描:飞机起飞后慢慢查,可疑的再叫回来(准实时、可回溯)
  • 特征缓存 = 安检员的"熟脸记忆":常旅客不用每次都查护照,但陌生人必须严格核对

2. 核心原理是什么?

核心原理:同步窗做低延迟拦截,异步窗做补判与监测;两条平面的超时与降级合同必须分开写。

2.1 系统全景架构

实时风控系统全景:接入、特征、决策、执行与回流
实时风控系统全景:接入、特征、决策、执行与回流 · 点击查看 SVG 原图

2.2 低延迟决策时序图

低延迟决策时序:并行取特征、规则与模型、融合决策
低延迟决策时序:并行取特征、规则与模型、融合决策 · 点击查看 SVG 原图

2.3 三级决策架构

三级决策:本地缓存 → 规则 → 模型
三级决策:本地缓存 → 规则 → 模型 · 点击查看 SVG 原图

2.4 异步特征补全机制

同步链路只能使用内存/Redis 中的热特征,但部分高价值特征(如关联图谱深度、设备历史行为序列)计算耗时长,采用异步补全 + 延迟决策模式:

异步特征补全与事后拦截
异步特征补全与事后拦截 · 点击查看 SVG 原图

3. 怎么用?关键代码与配置

3.1 风控上下文构建器(线程安全、无锁设计)

@Component
public class RiskContextBuilder {
 
    private final LoadingCache<String, UserProfile> userProfileCache;
    private final LoadingCache<String, DeviceRisk> deviceRiskCache;
    private final LoadingCache<String, IpRisk> ipRiskCache;
 
    public RiskContextBuilder(
            @Qualifier("userProfileCache") LoadingCache<String, UserProfile> userProfileCache,
            @Qualifier("deviceRiskCache") LoadingCache<String, DeviceRisk> deviceRiskCache,
            @Qualifier("ipRiskCache") LoadingCache<String, IpRisk> ipRiskCache) {
        this.userProfileCache = userProfileCache;
        this.deviceRiskCache = deviceRiskCache;
        this.ipRiskCache = ipRiskCache;
    }
 
    /**
     * 构建风控上下文 - 并行获取所有特征,超时控制
     */
    public RiskContext build(RiskEvent event) {
        // 使用 CompletableFuture 并行获取三类特征
        CompletableFuture<UserProfile> userFuture = CompletableFuture
            .supplyAsync(() -> userProfileCache.getUnchecked(event.getUserId()));
 
        CompletableFuture<DeviceRisk> deviceFuture = CompletableFuture
            .supplyAsync(() -> deviceRiskCache.getUnchecked(event.getDeviceId()));
 
        CompletableFuture<IpRisk> ipFuture = CompletableFuture
            .supplyAsync(() -> ipRiskCache.getUnchecked(event.getIp()));
 
        // 等待所有特征就绪,总超时 20ms
        CompletableFuture<Void> allDone = CompletableFuture.allOf(userFuture, deviceFuture, ipFuture);
 
        try {
            allDone.get(20, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            // 超时降级:使用默认值继续,不阻断主链路
            log.warn("Feature fetch timeout for user={}, using defaults", event.getUserId());
        } catch (Exception e) {
            log.error("Feature fetch failed", e);
        }
 
        return RiskContext.builder()
            .event(event)
            .userProfile(getOrDefault(userFuture, UserProfile.DEFAULT))
            .deviceRisk(getOrDefault(deviceFuture, DeviceRisk.DEFAULT))
            .ipRisk(getOrDefault(ipFuture, IpRisk.DEFAULT))
            .timestamp(System.currentTimeMillis())
            .build();
    }
 
    private <T> T getOrDefault(CompletableFuture<T> future, T defaultValue) {
        try {
            return future.isDone() ? future.get() : defaultValue;
        } catch (Exception e) {
            return defaultValue;
        }
    }
}

3.2 本地缓存配置(Caffeine 高性能缓存)

@Configuration
public class CacheConfig {
 
    /**
     * 用户画像缓存:写后 30 秒过期,支持异步刷新
     */
    @Bean("userProfileCache")
    public LoadingCache<String, UserProfile> userProfileCache(RedisTemplate<String, String> redis) {
        return Caffeine.newBuilder()
            .maximumSize(100_000)
            .expireAfterWrite(30, TimeUnit.SECONDS)
            .refreshAfterWrite(10, TimeUnit.SECONDS)  // 异步刷新,不阻塞读
            .recordStats()
            .build(key -> fetchUserProfileFromRedis(redis, key));
    }
 
    /**
     * 设备风险缓存:黑名单永不过期,白名单 5 分钟
     */
    @Bean("deviceRiskCache")
    public LoadingCache<String, DeviceRisk> deviceRiskCache(DeviceRiskService service) {
        return Caffeine.newBuilder()
            .maximumSize(200_000)
            .expireAfter(new Expiry<String, DeviceRisk>() {
                @Override
                public long expireAfterCreate(String key, DeviceRisk value, long currentTime) {
                    // 黑名单永不过期,普通设备 5 分钟
                    return value.isBlacklisted() ? Long.MAX_VALUE : TimeUnit.MINUTES.toNanos(5);
                }
                @Override
                public long expireAfterUpdate(String key, DeviceRisk value, long currentTime, long currentDuration) {
                    return currentDuration;
                }
                @Override
                public long expireAfterRead(String key, DeviceRisk value, long currentTime, long currentDuration) {
                    return currentDuration;
                }
            })
            .build(service::getDeviceRisk);
    }
 
    private UserProfile fetchUserProfileFromRedis(RedisTemplate<String, String> redis, String userId) {
        String json = redis.opsForValue().get("risk:user:" + userId);
        return json != null ? JsonUtils.fromJson(json, UserProfile.class) : UserProfile.DEFAULT;
    }
}

3.3 决策融合器(规则 + 模型加权仲裁)

@Service
public class DecisionFusionService {
 
    private final List<DecisionStrategy> strategies;
 
    public DecisionFusionService(List<DecisionStrategy> strategies) {
        this.strategies = strategies.stream()
            .sorted(Comparator.comparingInt(DecisionStrategy::getPriority).reversed())
            .collect(Collectors.toList());
    }
 
    /**
     * 多级决策融合
     * 优先级:硬规则 > 业务规则 > 模型评分 > 默认放行
     */
    public Decision decide(RiskContext context, RuleResult ruleResult, ModelScore modelScore) {
        // L1: 硬规则(黑名单、合规要求)—— 一票否决
        if (ruleResult.hasHardRuleHit()) {
            return Decision.builder()
                .action(Action.BLOCK)
                .reason("HARD_RULE:" + ruleResult.getHitHardRule())
                .source(DecisionSource.RULE)
                .confidence(1.0)
                .build();
        }
 
        // L2: 规则引擎综合评分
        if (ruleResult.getScore() >= 90) {
            return Decision.builder()
                .action(Action.BLOCK)
                .reason("RULE_HIGH_RISK")
                .source(DecisionSource.RULE)
                .confidence(0.95)
                .build();
        }
 
        if (ruleResult.getScore() >= 70) {
            return Decision.builder()
                .action(Action.CHALLENGE)
                .reason("RULE_MEDIUM_RISK")
                .source(DecisionSource.RULE)
                .confidence(0.85)
                .build();
        }
 
        // L3: 模型评分补充
        if (modelScore != null && modelScore.getValue() > 0.85) {
            // 规则低风险但模型高风险 → 升级处理
            return Decision.builder()
                .action(Action.CHALLENGE)
                .reason("MODEL_ESCALATION:" + modelScore.getModelName())
                .source(DecisionSource.MODEL)
                .confidence(modelScore.getValue())
                .build();
        }
 
        // L4: 默认放行
        return Decision.builder()
            .action(Action.ALLOW)
            .reason("DEFAULT")
            .source(DecisionSource.DEFAULT)
            .confidence(0.5)
            .build();
    }
}

3.4 异步决策回流(Kafka 生产者)

@Service
public class DecisionFeedbackService {
 
    private final KafkaTemplate<String, DecisionLog> kafkaTemplate;
    private final ObjectMapper objectMapper;
 
    @Value("${risk.kafka.topic.decision-log}")
    private String decisionLogTopic;
 
    /**
     * 异步发送决策日志,用于后续模型训练与规则优化
     */
    public void asyncLogDecision(RiskEvent event, Decision decision, long latencyMs) {
        DecisionLog log = DecisionLog.builder()
            .eventId(event.getEventId())
            .userId(event.getUserId())
            .action(decision.getAction().name())
            .source(decision.getSource().name())
            .confidence(decision.getConfidence())
            .latencyMs(latencyMs)
            .timestamp(Instant.now())
            .build();
 
        // 异步发送,带重试与降级
        ListenableFuture<SendResult<String, DecisionLog>> future =
            kafkaTemplate.send(decisionLogTopic, event.getUserId(), log);
 
        future.addCallback(
            result -> {},
            ex -> {
                // 降级:写入本地队列,后台线程补偿发送
                LocalQueue.offer(log);
                log.error("Failed to send decision log, queued locally", ex);
            }
        );
    }
}
public class DecisionLogConsumer {
 
    /**
     * 消费决策日志,实时更新用户行为特征
     */
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
 
        KafkaSource<DecisionLog> source = KafkaSource.<DecisionLog>builder()
            .setBootstrapServers("kafka:9092")
            .setTopics("risk-decision-log")
            .setGroupId("feature-updater")
            .setStartingOffsets(OffsetsInitializer.latest())
            .setValueOnlyDeserializer(new DecisionLogDeserializationSchema())
            .build();
 
        DataStream<DecisionLog> stream = env.fromSource(source, WatermarkStrategy.noWatermarks(), "decision-log");
 
        // 按用户ID分组,1分钟滑动窗口统计决策分布
        stream.keyBy(DecisionLog::getUserId)
            .window(SlidingProcessingTimeWindows.of(Time.minutes(5), Time.minutes(1)))
            .aggregate(new DecisionStatsAggregate())
            .addSink(new RedisFeatureUpdateSink());
 
        env.execute("Decision Log Feature Updater");
    }
 
    /**
     * 聚合函数:统计近 5 分钟内用户的决策分布
     */
    static class DecisionStatsAggregate implements AggregateFunction<DecisionLog, DecisionStats, UserFeatureUpdate> {
        @Override
        public DecisionStats createAccumulator() {
            return new DecisionStats();
        }
 
        @Override
        public DecisionStats add(DecisionLog log, DecisionStats acc) {
            acc.increment(log.getAction());
            return acc;
        }
 
        @Override
        public UserFeatureUpdate getResult(DecisionStats acc) {
            return UserFeatureUpdate.builder()
                .blockCount(acc.getBlockCount())
                .challengeCount(acc.getChallengeCount())
                .allowCount(acc.getAllowCount())
                .riskRatio(acc.getBlockCount() * 1.0 / acc.getTotal())
                .build();
        }
 
        @Override
        public DecisionStats merge(DecisionStats a, DecisionStats b) {
            return a.merge(b);
        }
    }
}

4. 业界怎么做?

4.1 蚂蚁集团:双 11 实时风控(TRaR 平台)

蚂蚁集团的实时风控平台 TRaR(Transaction Risk and Recognition)支撑了双 11 期间每秒百万级支付的实时风险决策:

架构特点:

  • L1 缓存层:基于 SOFAJRaft 实现的多级缓存,本地命中率 85%+,平均读取 < 1ms
  • 特征计算层:自研 Realtime Compute 引擎,支持 1000+ 实时特征,P99 计算延迟 < 10ms
  • 决策层:规则引擎 + XGBoost 模型并行执行,硬规则先过滤掉 60% 低风险请求
  • 异步补全:对于"需要进一步观察"的交易,先放行后由 Flink 在 500ms 内完成深度分析,必要时触发事后冻结

踩过的坑:

  • 缓存雪崩:2020 年双 11 某特征缓存集体失效,导致 Redis 集群被打满。后续引入本地缓存随机 TTL + 熔断降级机制。
  • 模型漂移:疫情期间用户行为剧变,历史模型误判率飙升。建立 PSI 实时监控,漂移超过阈值自动切回规则兜底。

4.2 字节跳动:抖音电商反欺诈(Titan 系统)

字节跳动的 Titan 风控系统处理抖音电商每日数十亿级事件,核心挑战是海量数据 + 超低延迟 + 高可变业务。

架构特点:

  • 事件接入:自研 LogBus 统一接入层,支持多协议(HTTP/gRPC/Kafka),自动限流与背压
  • 特征平台:Flink 实时特征(近线)+ Hive 离线特征(T+1),通过 Feature Store 统一接口,PSI 日监控
  • 规则引擎:自研声明式 DSL,支持热更新(秒级生效),规则编译成字节码执行,单规则 < 0.1ms
  • 模型服务:Triton Inference Server + 自定义模型格式,GPU 推理 P99 < 5ms
  • 决策回流:所有决策写入 ClickHouse,支持秒级 OLAP 查询,用于实时运营监控

关键设计:

  • Shadow Mode:新策略上线先跑 Shadow,比对与老策略的差异,确认无误后再切流量
  • 多租户隔离:不同业务线(直播、电商、广告)规则隔离,避免互相影响
  • 弹性扩缩容:基于 Kubernetes HPA,决策层 Pod 数随 QPS 自动伸缩(10s 内完成)

4.3 Goldman Sachs:全球市场监控(SecDB 风控)

高盛的 SecDB 系统对全球交易进行实时监控,侧重合规与反市场操纵:

  • Global Window + 自定义 Trigger:检测跨市场操纵行为(如先在 A 市场拉盘,再在 B 市场出货)
  • CEP 复杂事件处理:用 Flink CEP 识别 "spoofing" 模式(大单挂出后迅速撤单)
  • 低延迟要求:交易前风控(Pre-trade risk)必须在 10ms 内完成,直接嵌入交易网关
  • 审计追踪:所有决策不可篡改,写入 WORM(Write Once Read Many)存储,满足 MiFID II 合规要求

5. 业务场景怎么对照?

先对照场景选平面:资金类优先同步拦截;画像与案件类可进异步,并保留事后止损。

5.1 风控场景映射

业务场景同步/异步关键特征决策动作延迟要求
加密货币提现同步地址白名单、近期登录地、设备信任度阻断/2FA< 30ms
大额转账同步历史转账模式、收款方风险分挑战/阻断< 50ms
批量登录尝试异步IP 画像、设备指纹相似度、时间分布限速/封禁< 200ms
新设备首次交易同步+异步设备指纹、关联账户数挑战 + 事后复核< 50ms
异常交易序列异步Flink CEP 模式匹配人工复核< 500ms

5.2 常见误区 vs 正确做法

❌ 常见误区✅ 正确做法
所有交易都走完整模型推理硬规则先过滤,模型只处理边界案例
特征全部实时计算冷热分层:热点特征本地缓存,冷特征异步补全
同步等待外部服务(如第三方征信)外部服务异步化,缺失时走降级策略
决策结果只写日志不回流建立完整 Feedback Loop,驱动模型迭代
忽略 Shadow Mode 直接上线策略新策略必须 Shadow 验证,对比指标后再切量
单点模型决策,无规则兜底规则兜底 + 模型增强,模型异常自动切规则

5.3 选型建议

When to use 同步拦截:

  • 资金流出类操作(提现、转账、支付)
  • 安全设置变更(修改密码、换绑手机)
  • 高风险时段/高风险用户的所有操作

When to use 异步审计:

  • 行为分析(登录模式、浏览轨迹)
  • 事后反洗钱(AML)筛查
  • 关联图谱分析(需要跨用户聚合)

When NOT to use 纯规则引擎:

  • 攻击模式快速变化(如欺诈团伙频繁变换策略)
  • 特征维度极高(>1000 维),人工规则难以覆盖
  • 需要个性化风险评估(不同用户风险承受能力不同)

6. 高频问题怎么答?

Q1: 如何将 P99 延迟从 200ms 优化到 50ms?

答: 三级优化策略:

  1. 缓存优化:本地 Caffeine 缓存热点特征(命中率 85%+),Redis 改为 Pipeline 批量读取
  2. 计算优化:规则预编译为字节码(ASM/JANINO),模型推理用 Triton + TensorRT 加速
  3. 架构优化:规则与模型并行执行(而非串行),CompletableFuture 超时降级,外部服务全异步化

Q2: 特征缺失时如何降级?

答: 三级降级:

  • L1:本地缓存有默认值,直接填充
  • L2:关键特征缺失时,提升该维度权重,让其他特征主导决策
  • L3:过多特征缺失(>30%)时,直接路由到"保守模式"(强制挑战或人工复核)

Q3: 如何处理规则与模型的冲突?

答: 建立优先级仲裁机制:

  • 硬规则(合规/法律要求)> 一切
  • 规则引擎高风险(score > 90)> 模型低风险
  • 规则低风险 + 模型高风险 → 升级为挑战
  • 双方中风险 → 引入第三模型或人工复核

Q4: Shadow Mode 具体怎么实现?

答: 流量复制 + 决策比对:

  • 线上流量同时走老策略(生效)和新策略(仅记录决策结果)
  • 对比新老策略的决策分布差异(阻断率、挑战率、误杀率)
  • 设置可接受阈值(如阻断率差异 < 0.5%),达标后才切量
  • 代码层面通过 DecisionEngine.execute(event, Mode.SHADOW) 实现

Q5: 异步补全后如果发现高风险,交易已经成功了怎么办?

答: 设计"事后止损"机制:

  • 资金类操作:触发账户冻结 + 资金追回流程(依赖于业务系统的撤销能力)
  • 非资金类操作:标记账户 + 下次操作时拦截
  • 建立"决策置信度"概念:同步决策置信度低时,提高异步分析的优先级
  • 法律合规角度:必须在用户协议中声明保留事后审查权

Q6: 如何保证特征一致性(实时 vs 离线)?

答: 这是风控系统最核心也最难的问题:

  • 统一特征口径:Feature Store 维护一份特征逻辑定义,实时/离线共用
  • 双写验证:实时特征写入 Kafka,离线 Hive 表从 Kafka 回溯,定期比对差异
  • PSI 监控:每日计算实时/离线特征的 PSI 值,> 0.25 触发告警
  • 特征版本管理:特征逻辑变更时版本号 +1,模型训练与在线推理使用同一版本

Q7: 面对流量突增(如突发攻击)如何自保?

答: 多层熔断 + 弹性伸缩:

  • 接入层限流:API Gateway 令牌桶限流,超限返回 429
  • 特征层降级:缓存过期时间缩短 → 延长(牺牲新鲜度换稳定性)
  • 决策层降级:关闭模型推理,仅保留核心规则;关闭异步补全链路
  • 自动扩容:Kubernetes HPA 基于 CPU/QPS 自动扩容决策 Pod(10s 级)
  • 兜底策略:极端情况下全部放行或全部挑战,保证系统不崩溃

记忆口诀: 接入要快,特征要准,规则要狠,模型要稳,决策要明,回流要全。 同步求快(<50ms),异步求全(<500ms),缓存是命,降级是盾。

一句话总结:实时风控引擎是一个在 <50ms 内完成"事件接入 → 特征聚合 → 规则判定 → 模型打分 → 决策执行 → 结果回流"全链路的低延迟决策系统;其架构灵魂在于分层降级——每一层都假设下层可能失效,通过本地缓存、规则兜底、异步补全、熔断隔离等手段,在极致性能与绝对正确性之间取得平衡。


1. 这是什么?概念怎么定义

1.1 实时风控引擎的本质

实时风控引擎(Real-time Risk Engine) 是一个面向金融交易场景的低延迟在线决策系统。它在交易发生的毫秒级时间窗口内,综合用户历史行为、实时交易特征、设备环境、关联图谱等多维信息,输出 PASS(放行)、REVIEW(人工审核)或 REJECT(拦截)的决策。

核心非功能指标(SLA):

指标目标值说明
QPS100K+单集群峰值处理能力
P50 延迟< 20ms50% 请求的处理延迟
P99 延迟< 50ms99% 请求的处理延迟(长尾控制)
可用性99.99%全年不可用时间 < 52 分钟
误杀率(FPR)< 0.1%正常用户被拦截的比例
漏放率(FNR)< 0.01%风险交易被放行的比例

1.2 类比理解

类比:机场安检的"智能安检通道"

  • 接入层 = 入口闸机:核验机票/身份证(鉴权)、控制人流(限流)、分流到不同安检通道(路由)
  • 特征层 = X光机 + 金属探测器:实时扫描行李(实时特征),同时调取旅客历史记录(离线特征),判断"是否常飞这条航线""是否有前科"
  • 决策层 = 安检员 + AI 辅助判图系统:安检员(规则引擎)按手册检查,AI(模型)辅助识别可疑物品,两者综合给出"开箱检查/直接放行"
  • 执行层 = 拦截/放行动作 + 后台记录:放行则旅客通过;拦截则带入小黑屋进一步检查;同时全程录像存档(审计日志)
  • 降级策略 = 当 X 光机故障时,增加人工手检(规则兜底);当 AI 系统宕机时,资深安检员凭经验判断(模型降级);当整个系统瘫痪时,启动最高级别安检模式——所有人脱鞋开箱(保守降级)

1.3 为什么需要专门设计实时风控引擎

传统规则引擎或批处理系统无法满足金融交易的实时性要求:

  1. 延迟刚性:一笔出金交易如果在 100ms 内无法完成风控判定,用户会感知到"卡顿",体验劣化
  2. 资金损失不可逆:盗号一旦出金成功,区块链上的转账几乎无法追回——必须在转账指令提交前完成拦截
  3. 攻击速度极快:羊毛党脚本可以在 1 秒内完成注册→领券→下单→退款的全流程,只有实时引擎才能跟上
  4. 监管合规要求:MiFID II、PCI-DSS 等法规要求金融机构具备实时交易监控能力

2. 核心原理是什么?

2.1 四层架构全景图

四层架构全景:接入到反馈闭环
四层架构全景:接入到反馈闭环 · 点击查看 SVG 原图

2.2 单笔交易的完整数据流时序图

单笔提现完整数据流时序
单笔提现完整数据流时序 · 点击查看 SVG 原图

2.3 分层降级策略详解

实时风控引擎的每一层都必须设计独立降级能力,形成"纵深防御":

分层降级策略流程图
分层降级策略流程图 · 点击查看 SVG 原图

各层降级策略:

层级正常状态降级状态降级触发条件
接入层JWT 鉴权 + 限流仅 API Key 校验,限流收紧Auth Service P99 > 100ms
特征层 L1Caffeine 本地缓存直接透传(无缓存)本地内存 > 90%
特征层 L2Redis Cluster默认值 + 异步补全Redis 节点宕机 > 2 个
规则引擎全量规则执行仅执行 P0 硬规则(黑名单等)规则编译超时
模型服务XGBoost + DNN 双模型仅 XGBoost 轻量模型Triton 队列堆积 > 100
决策融合规则 + 模型加权单规则或单模型保守模式Fusion Service 超时
执行层同步拦截 + 异步审计仅同步拦截,审计延迟写入Kafka 不可用

2.4 延迟预算分解(Latency Budget)

在 50ms P99 的总预算下,各阶段的时间分配:

总预算:50ms P99
├── 接入层(Gateway + Auth + RateLimit):5ms
├── 特征层
│   ├── L1 Caffeine 查询:0.5ms
│   ├── L2 Redis 查询(未命中时):3ms
│   └── 异步特征补全(不阻塞主链路):0ms(后台线程)
├── 决策层
│   ├── 规则引擎(Rete 网络):8ms
│   ├── 模型服务(XGBoost):15ms
│   └── 决策融合:2ms
├── 执行层
│   ├── 同步执行:1ms
│   └── 异步审计(Kafka 发送):3ms
└── 网络开销 + 序列化:~12.5ms

关键优化点:

  • 并行化:规则引擎和模型服务并行执行,而非串行
  • 本地缓存:80% 的特征请求命中 L1 Caffeine,避免网络往返
  • 决策缓存:相同 (userId, amount, toAddress) 组合的请求在 1s 内直接复用决策结果
  • GC 优化:使用 G1/ZGC,确保 GC Pause < 5ms

3. 怎么用?关键代码与配置

3.1 接入层:统一网关 + 流量控制

/**
 * 风控统一接入网关:鉴权、限流、路由、协议转换
 * 基于 Spring Cloud Gateway 或自研 Netty 网关
 */
@Component
public class RiskGatewayFilter implements GlobalFilter, Ordered {
 
    @Autowired private AuthService authService;
    @Autowired private RateLimiter rateLimiter;
    @Autowired private MeterRegistry metrics;
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getPath().value();
        String clientId = request.getHeaders().getFirst("X-Client-Id");
 
        // 1. 快速拒绝:黑名单 Client
        if (isBlockedClient(clientId)) {
            metrics.counter("gateway.blocked").increment();
            return reject(exchange, HttpStatus.FORBIDDEN, "Client blocked");
        }
 
        // 2. 鉴权(异步,带超时)
        return authService.validateToken(request)
            .timeout(Duration.ofMillis(20))  // 鉴权超时 20ms
            .flatMap(authResult -> {
                if (!authResult.isValid()) {
                    metrics.counter("gateway.auth.failed").increment();
                    return reject(exchange, HttpStatus.UNAUTHORIZED, "Invalid token");
                }
 
                // 3. 限流(分布式令牌桶)
                String limitKey = "rate:" + clientId + ":" + path;
                boolean allowed = rateLimiter.isAllowed(limitKey, 10000, 1);
                if (!allowed) {
                    metrics.counter("gateway.ratelimited").increment();
                    return reject(exchange, HttpStatus.TOO_MANY_REQUESTS, "Rate limited");
                }
 
                // 4. 注入上下文(TraceId、UserId 透传)
                ServerHttpRequest mutated = exchange.getRequest().mutate()
                    .header("X-Trace-Id", MDC.get("traceId"))
                    .header("X-User-Id", authResult.getUserId())
                    .build();
 
                return chain.filter(exchange.mutate().request(mutated).build());
            })
            .onErrorResume(TimeoutException.class, e -> {
                // 鉴权超时降级:仅校验 API Key,跳过 JWT 完整解析
                metrics.counter("gateway.auth.timeout").increment();
                return apiKeyFallback(exchange, chain);
            });
    }
 
    private Mono<Void> apiKeyFallback(ServerWebExchange exchange, GatewayFilterChain chain) {
        String apiKey = exchange.getRequest().getHeaders().getFirst("X-API-Key");
        if (apiKey != null && authService.isValidApiKey(apiKey)) {
            return chain.filter(exchange);
        }
        return reject(exchange, HttpStatus.UNAUTHORIZED, "Auth timeout, fallback failed");
    }
 
    @Override
    public int getOrder() { return -100; }  // 最高优先级
}

3.2 特征层:多级缓存 + 异步补全

/**
 * 特征服务:L1 Caffeine + L2 Redis + 异步加载的三层架构
 */
@Service
public class FeatureService {
 
    // L1:本地缓存,P99 < 1ms,存储热点特征
    private final LoadingCache<String, FeatureValue> localCache = Caffeine.newBuilder()
        .maximumSize(100_000)
        .expireAfterWrite(30, TimeUnit.SECONDS)
        .refreshAfterWrite(10, TimeUnit.SECONDS)  // 异步刷新,不阻塞读
        .recordStats()
        .build(this::loadFromRedis);
 
    @Autowired private StringRedisTemplate redisTemplate;
    @Autowired private FeatureAsyncLoader asyncLoader;
    @Autowired private FeatureStore featureStore;
 
    /**
     * 批量获取特征:主链路调用,必须 < 5ms
     */
    public FeatureVector getFeatures(String entityId, List<String> featureNames) {
        FeatureVector vector = new FeatureVector(entityId);
        List<String> missingFeatures = new ArrayList<>();
 
        for (String featureName : featureNames) {
            String cacheKey = buildKey(entityId, featureName);
 
            // 1. L1 本地缓存
            FeatureValue cached = localCache.getIfPresent(cacheKey);
            if (cached != null && !cached.isExpired()) {
                vector.put(featureName, cached);
                continue;
            }
 
            // 2. L2 Redis(批量 MGET 减少 RTT)
            missingFeatures.add(featureName);
        }
 
        if (!missingFeatures.isEmpty()) {
            // 批量查询 Redis(Pipeline 优化)
            List<String> keys = missingFeatures.stream()
                .map(f -> buildKey(entityId, f))
                .toList();
            List<String> values = redisTemplate.opsForValue().multiGet(keys);
 
            for (int i = 0; i < missingFeatures.size(); i++) {
                String featureName = missingFeatures.get(i);
                String value = values.get(i);
 
                if (value != null) {
                    FeatureValue fv = FeatureValue.fromJson(value);
                    vector.put(featureName, fv);
                    localCache.put(buildKey(entityId, featureName), fv);  // 回填 L1
                } else {
                    // 3. 缺失特征:使用默认值 + 触发异步补全
                    vector.put(featureName, FeatureValue.defaultValue(featureName));
                    asyncLoader.submit(entityId, featureName);  // 后台线程补全 Redis
                }
            }
        }
 
        return vector;
    }
 
    /**
     * 异步特征补全:不阻塞主链路
     */
    @Component
    public class FeatureAsyncLoader {
 
        private final ThreadPoolExecutor executor = new ThreadPoolExecutor(
            4, 16, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000),
            new ThreadFactoryBuilder().setNameFormat("feature-loader-%d").build(),
            new ThreadPoolExecutor.DiscardPolicy()  // 队列满则丢弃,不阻塞
        );
 
        public void submit(String entityId, String featureName) {
            executor.execute(() -> {
                try {
                    // 从 Feature Store(StarRocks/Hive)查询
                    FeatureValue value = featureStore.queryOffline(entityId, featureName);
                    if (value != null) {
                        String key = buildKey(entityId, featureName);
                        redisTemplate.opsForValue().set(key, value.toJson(), Duration.ofMinutes(5));
                    }
                } catch (Exception e) {
                    log.warn("Async feature load failed: {}:{}", entityId, featureName);
                }
            });
        }
    }
 
    private String buildKey(String entityId, String featureName) {
        return String.format("feat:%s:%s", entityId, featureName);
    }
}

3.3 决策层:规则 + 模型并行执行 + 熔断降级

/**
 * 决策编排服务:并行执行规则引擎和模型服务,融合决策结果
 */
@Service
public class DecisionOrchestrator {
 
    @Autowired private RuleEngine ruleEngine;
    @Autowired private ModelService modelService;
    @Autowired private DecisionFusionService fusionService;
    @Autowired private CircuitBreakerRegistry circuitBreakerRegistry;
 
    private final ExecutorService decisionExecutor = Executors.newFixedThreadPool(32);
 
    /**
     * 核心决策方法:必须在 < 30ms 内返回
     */
    public RiskDecision decide(RiskEvent event, FeatureVector features) {
        long startTime = System.nanoTime();
 
        // 1. 决策缓存检查(相同输入短路)
        String cacheKey = buildDecisionCacheKey(event, features);
        RiskDecision cached = decisionCache.getIfPresent(cacheKey);
        if (cached != null) {
            return cached.withSource(DecisionSource.CACHE);
        }
 
        // 2. 并行执行规则 + 模型(CompletableFuture)
        CompletableFuture<RuleDecision> ruleFuture = CompletableFuture
            .supplyAsync(() -> executeRules(event, features), decisionExecutor)
            .orTimeout(15, TimeUnit.MILLISECONDS)  // 规则引擎超时 15ms
            .exceptionally(ex -> {
                log.error("Rule engine failed, using fallback", ex);
                return RuleDecision.fallback();  // 降级:返回空规则结果
            });
 
        CompletableFuture<ModelScore> modelFuture = CompletableFuture
            .supplyAsync(() -> executeModel(event, features), decisionExecutor)
            .orTimeout(25, TimeUnit.MILLISECONDS)  // 模型超时 25ms
            .exceptionally(ex -> {
                log.error("Model service failed, using fallback", ex);
                return ModelScore.fallback();  // 降级:返回中等风险分
            });
 
        // 3. 等待两者完成(取最快完成时间 + 较慢者超时)
        CompletableFuture<Void> allDone = CompletableFuture.allOf(ruleFuture, modelFuture);
        try {
            allDone.get(30, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            log.warn("Decision partial timeout, using available results");
        } catch (Exception e) {
            log.error("Decision execution failed", e);
        }
 
        RuleDecision ruleResult = getOrDefault(ruleFuture, RuleDecision.fallback());
        ModelScore modelResult = getOrDefault(modelFuture, ModelScore.fallback());
 
        // 4. 决策融合
        RiskDecision finalDecision = fusionService.fuse(ruleResult, modelResult, event);
 
        // 5. 缓存决策结果(1 秒内相同输入复用)
        decisionCache.put(cacheKey, finalDecision);
 
        // 6. 上报延迟
        long latencyMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
        Metrics.histogram("decision.latency").record(latencyMs);
 
        return finalDecision;
    }
 
    /**
     * 规则引擎执行(带熔断器)
     */
    private RuleDecision executeRules(RiskEvent event, FeatureVector features) {
        CircuitBreaker cb = circuitBreakerRegistry.circuitBreaker("rule-engine");
        return cb.executeSupplier(() -> ruleEngine.evaluate(event, features));
    }
 
    /**
     * 模型服务执行(带熔断器 + 负载均衡)
     */
    private ModelScore executeModel(RiskEvent event, FeatureVector features) {
        CircuitBreaker cb = circuitBreakerRegistry.circuitBreaker("model-service");
        return cb.executeSupplier(() -> {
            // 负载均衡:选择当前负载最低的模型实例
            ModelInstance instance = modelService.selectLeastLoadedInstance();
            return instance.predict(features.toModelInput());
        });
    }
 
    private <T> T getOrDefault(CompletableFuture<T> future, T defaultValue) {
        try {
            return future.isDone() ? future.get() : defaultValue;
        } catch (Exception e) {
            return defaultValue;
        }
    }
}
 
/**
 * 决策融合服务:规则与模型的加权决策
 */
@Service
public class DecisionFusionService {
 
    public RiskDecision fuse(RuleDecision rule, ModelScore model, RiskEvent event) {
        // 场景 1:规则引擎直接命中硬规则(如黑名单)→ 无需模型,直接拦截
        if (rule.hasHardRuleHit()) {
            return RiskDecision.reject(
                "RULE_HARD_HIT",
                rule.getHitRules(),
                1.0,
                DecisionSource.RULE
            );
        }
 
        // 场景 2:规则引擎命中软规则(如频控)+ 模型高置信度 → 拦截
        if (rule.hasSoftRuleHit() && model.getScore() > 0.9) {
            return RiskDecision.reject(
                "RULE_MODEL_AGREE",
                rule.getHitRules(),
                0.95,
                DecisionSource.FUSION
            );
        }
 
        // 场景 3:规则未命中,但模型极高置信度 → 人工审核
        if (!rule.hasAnyHit() && model.getScore() > 0.95) {
            return RiskDecision.review(
                "MODEL_HIGH_CONFIDENCE",
                model.getScore(),
                DecisionSource.MODEL
            );
        }
 
        // 场景 4:规则与模型冲突 → 保守策略(人工审核)
        if (rule.hasSoftRuleHit() && model.getScore() < 0.3) {
            return RiskDecision.review(
                "RULE_MODEL_CONFLICT",
                Map.of("rules", rule.getHitRules(), "modelScore", model.getScore()),
                DecisionSource.FUSION
            );
        }
 
        // 默认放行
        return RiskDecision.pass(DecisionSource.FUSION);
    }
}

3.4 执行层:同步拦截 + 异步审计

/**
 * 决策执行服务:同步返回 + 异步副作用
 */
@Service
public class DecisionExecutionService {
 
    @Autowired private KafkaTemplate<String, AuditEvent> kafkaTemplate;
    @Autowired private CaseManagementService caseService;
    @Autowired private AlertService alertService;
 
    /**
     * 执行决策:同步返回结果,异步触发副作用
     */
    public ExecutionResult execute(RiskEvent event, RiskDecision decision) {
        long start = System.currentTimeMillis();
 
        // 1. 同步执行:立即影响用户请求的响应
        SyncAction syncAction = determineSyncAction(decision);
        ExecutionResult result = new ExecutionResult(syncAction, decision);
 
        // 2. 异步执行:不阻塞用户响应
        CompletableFuture.runAsync(() -> {
            try {
                // 2.1 审计日志(必须成功,失败则重试)
                AuditEvent audit = buildAuditEvent(event, decision, start);
                kafkaTemplate.send("risk.audit.events", event.getUserId(), audit)
                    .whenComplete((sendResult, ex) -> {
                        if (ex != null) {
                            // 写入本地磁盘兜底,后续补偿发送
                            localAuditBackup(audit);
                        }
                    });
 
                // 2.2 高风险案件创建
                if (decision.getAction() == Action.REJECT || decision.getAction() == Action.REVIEW) {
                    caseService.createCase(event, decision);
                }
 
                // 2.3 CRITICAL 级别实时告警
                if (decision.getConfidence() > 0.95 && decision.getAction() == Action.REJECT) {
                    alertService.sendRealtimeAlert(event, decision);
                }
 
                // 2.4 决策结果回流(用于模型训练)
                FeedbackEvent feedback = new FeedbackEvent(
                    event.getEventId(),
                    decision.getAction(),
                    decision.getSource(),
                    System.currentTimeMillis()
                );
                kafkaTemplate.send("risk.feedback.events", feedback);
 
            } catch (Exception e) {
                log.error("Async execution failed for event: {}", event.getEventId(), e);
            }
        });
 
        return result;
    }
 
    private SyncAction determineSyncAction(RiskDecision decision) {
        return switch (decision.getAction()) {
            case PASS -> SyncAction.ALLOW;
            case REVIEW -> SyncAction.CHALLENGE_2FA;  // 触发二次验证
            case REJECT -> SyncAction.BLOCK;
        };
    }
 
    private void localAuditBackup(AuditEvent audit) {
        // 写入本地 WAL(Write Ahead Log),定时任务扫描补发到 Kafka
        // 这是审计数据不可丢失的最后保障
    }
}

4. 业界怎么做?

4.1 阿里巴巴蚁盾:双 11 亿级 QPS 实时风控

阿里巴巴的实时风控引擎支撑了双十一峰值 58.3 万笔/秒的交易量。

架构特点:

  • 五级决策体系:
    • L0(边缘层):CDN 节点上的简单规则(IP 黑名单、设备指纹),延迟 < 1ms
    • L1(接入层):API 网关限流 + 鉴权,延迟 < 3ms
    • L2(规则层):轻量规则引擎(本地内存),延迟 < 5ms
    • L3(模型层):XGBoost + 深度学习模型,延迟 < 15ms
    • L4(图谱层):GraphCompute 关联分析(异步),延迟 ~100ms(不阻塞主链路)
  • 热点特征本地缓存:双 11 前 1 小时,将 Top 1000 万用户的特征预加载到应用本地内存,L1 命中率 > 95%
  • 模型降级:如果模型服务响应超时,自动降级到"规则保守模式"——宁可误杀也不漏放

踩过的坑:

  1. GC 导致的 P99 抖动:早期使用 CMS,大促期间 GC Pause 达到 80ms,触发大量风控超时。解决方案:升级到 G1 GC,并设置 -XX:MaxGCPauseMillis=5;关键路径对象池化,减少临时对象分配
  2. Redis 热点 Key:双 11 零点,"全局交易计数器"成为热点 Key,Redis Cluster 单节点 CPU 打满。解决方案:本地缓存 + 分段计数(将 global:count 拆分为 global:count:0 ~ global:count:99,应用层汇总)

4.2 Stripe:机器学习驱动的实时风控架构

Stripe 为全球数百万商家提供支付处理,其风控系统 Radar 的核心是实时特征 + 深度学习模型。

架构亮点:

  • 特征实时性:每一笔支付的特征向量包含 500+ 维度,从点击支付按钮到模型打分 < 100ms
  • 模型服务化:使用自研的 Railyard 平台管理模型全生命周期(训练 → 验证 → 灰度 → 全量 → 监控 → 回滚)
  • 对抗样本防御:
    • 攻击者会试探风控边界(如"4999 元不拦截,5000 元拦截")
    • Stripe 的解决方案:模型输出加入随机噪声(score + random(-0.02, 0.02)),模糊化决策边界;同时规则层设置动态阈值
  • 反馈闭环:每笔支付的结果(是否拒付 chargeback)在 7-90 天后回流,自动触发模型重训练

量化效果:

  • fraud 识别率提升 25%
  • 误杀率降低 40%
  • 每年为商家减少数十亿美元的欺诈损失

4.3 PayPal:全球多地域风控网络

PayPal 的风控引擎需要处理跨境支付的复杂性(不同国家的监管要求、货币、时区)。

核心设计:

  • 地域化部署:在美西、美东、欧洲、新加坡部署独立的风控集群,用户请求路由到最近集群
  • 跨境特征同步:用户在美国的交易历史需要实时同步到欧洲节点(用于欧洲交易的关联分析)。使用 CRDT(Conflict-free Replicated Data Type) 实现最终一致的特征缓存
  • 监管合规隔离:欧盟用户的数据必须存储在欧盟境内(GDPR),风控引擎的欧盟集群与其他地域物理隔离,仅通过脱敏摘要通信

5. 业务场景怎么对照?

5.1 风控场景下的架构决策矩阵

业务场景QPS 要求延迟要求一致性要求架构重点
交易出金拦截50K< 30ms强一致本地缓存最大化,规则优先,模型兜底
登录风控200K< 20ms最终一致设备指纹本地计算,异步行为分析
营销反作弊100K< 50ms最终一致批量特征聚合,CEP 时序模式检测
事后审计10K< 1s强一致完整证据链,不可篡改日志

5.2 选型建议

组件推荐方案备选方案不推荐的方案
API 网关Envoy / HertzSpring Cloud GatewayNginx(动态路由能力弱)
规则引擎自研轻量(< 500 规则)Drools(> 1000 规则)Groovy Script(性能差)
模型推理Triton + TensorRTTensorFlow Serving直接 Java 调用 Python(跨进程延迟高)
特征存储Redis Cluster + CaffeineAerospike单节点 Redis(热点问题)
消息队列KafkaPulsarRabbitMQ(吞吐量不足)
流处理FlinkKafka StreamsSpark Streaming(延迟高)

5.3 常见误区 vs 正确做法

❌ 误区 1:追求 100% 实时特征一致性
    - 认为所有特征都必须实时计算,强一致同步
✅ 正确做法:分层特征策略。P0 特征(如黑名单)必须实时,P1 特征(如近 24h 交易笔数)允许 5s 延迟,P2 特征(如用户画像标签)允许 1h 延迟
 
❌ 误区 2:模型越复杂越好
    - 上线 100 层深度神经网络,推理延迟 50ms
✅ 正确做法:核心链路用轻量模型(XGBoost/LightGBM,< 5ms),复杂模型(DNN)走异步链路做二次确认。延迟是第一优先级
 
❌ 误区 3:忽略降级测试
    - 只在全组件可用的环境下测试,从未验证单组件故障场景
✅ 正确做法:混沌工程(Chaos Engineering)。定期 kill 掉 Redis 节点、模型服务实例、Kafka Broker,验证系统是否优雅降级
 
❌ 误区 4:决策结果不做版本控制
    - 模型 v2.1 拦截了某笔交易,但 3 天后模型升级到 v2.2,无法复现当时的决策逻辑
✅ 正确做法:每笔决策记录包含完整的"特征快照 + 规则版本 + 模型版本 + 决策代码版本",支持 Time-Travel 复现
 
❌ 误区 5:异步审计链路不可靠
    - 认为"同步拦截成功就万事大吉",异步审计日志丢失无所谓
✅ 正确做法:审计日志是监管合规的生命线。必须保证 At-Least-Once 投递,本地 WAL 兜底,定期对账

6. 高频问题怎么答?

Q1:实时风控引擎的 QPS 从 10K 提升到 100K,最关键的优化点是什么?

答:三个关键优化,按优先级排序:

  1. 本地缓存(L1 Caffeine):将热点特征从远程 Redis 拉到应用本地内存,减少网络 RTT(从 2-3ms 降到 0.1ms)。这是 QPS 提升 10 倍的核心
  2. 无锁数据结构:特征缓存使用 ThreadLocal + CopyOnWrite,避免锁竞争;决策结果使用原子引用切换
  3. 水平扩展 + 一致性哈希:应用节点从 10 个扩展到 100 个,Redis 从单节点升级到 Cluster(16 主 16 从),Kafka Partition 同步扩容

追问:水平扩展的瓶颈会在哪里?

  • 特征热点:如果所有请求都查同一个全局计数器(如"系统当前总交易笔数"),无论扩多少节点都解决不了。解决方案:本地缓存 + 异步批量更新
  • 模型服务:XGBoost 模型可以水平扩展(无状态),但 GPU 推理(DNN)受限于 GPU 卡数。解决方案:核心链路只用 CPU 推理,GPU 做异步二次确认

Q2:P99 延迟要求 < 50ms,但某个特征查询偶尔超过 100ms,怎么定位和处理?

答:

定位方法:

  1. 分布式追踪:每笔请求生成 TraceId,记录每个阶段的耗时(接入层、特征层、规则层、模型层、执行层)
  2. 长尾分析:对 P99 以上的请求采样,分析它们的共同特征(如"都查了某个用户的关联图谱""都命中了模型服务的某个慢节点")
  3. 火焰图:对 Java 应用做 CPU 火焰图分析,定位是否有锁竞争、GC、同步阻塞

处理策略:

  1. 超时熔断:单特征查询超时 10ms 则返回默认值,不阻塞整体决策
  2. 异步化:非关键特征(如"用户近 30 天平均交易金额")不阻塞主链路,决策时先用缓存值,异步更新
  3. 预热:对高活跃用户预加载特征到 L1 缓存

Q3:规则引擎和模型打分是并行还是串行?如果模型超时了怎么办?

答:并行执行是标准做法。

请求到达
  ├──> 规则引擎(10ms 超时)
  └──> 模型服务(20ms 超时)
       └──> 等待两者结果 → 融合决策

模型超时的处理:

  • 超时时间:设置比规则引擎更宽松的超时(如规则 10ms,模型 20ms),因为模型通常更慢
  • 降级策略:模型超时后,使用"模型缓存"(该用户最近一次的模型分数)或"默认中等风险分"
  • 决策融合调整:模型缺失时,提高规则引擎的权重(保守模式:规则命中即拦截)

追问:如果规则引擎也超时了?

  • 进入"紧急模式":所有交易走人工审核(REVIEW),或者基于最简单的硬规则(如"单笔 > 10 万 USDT 必须审核")快速决策

Q4:如何设计风控引擎的灰度发布,确保新版本不会误杀正常用户?

答:多层灰度策略:

  1. 影子模式(Shadow Mode):新版本的规则/模型并行运行,输出决策但不实际执行,只记录"如果执行了会怎样"。对比新旧版本的决策差异率
  2. 流量灰度:
    • 1% 流量 → 新版本(观察 24h)
    • 5% 流量 → 新版本(观察 3 天)
    • 20% 流量 → 新版本(观察 1 周)
    • 100% 流量 → 全量
  3. A/B 测试指标:
    • 拦截率变化(新版本不应导致拦截率突增 > 20%)
    • 误杀投诉量(客服系统对接,监控误杀申诉)
    • 漏放案例(事后审计发现的新版本漏放 vs 旧版本)
  4. 秒级回滚:决策结果绑定版本号,如果发现异常,通过配置中心秒级切换回旧版本

Q5:审计日志为什么必须保证 At-Least-Once?如果 Kafka 挂了怎么办?

答:审计日志是监管合规的"证据链",丢失审计日志等于"做了决策但无法证明为什么这么做",在金融监管场景下是严重违规。

Kafka 故障的兜底策略:

  1. 本地 WAL:Kafka 发送失败时,立即写入本地磁盘 Write Ahead Log(顺序写,性能高)
  2. 定时扫描:独立线程扫描 WAL,Kafka 恢复后批量重试发送
  3. 多机房容灾:Kafka 集群跨机房部署(3 副本分布在 2 个机房),单机房故障不丢消息
  4. 对账机制:每日对比"决策总数"与"审计日志总数",差异 > 0 则触发紧急修复
// 本地 WAL 兜底实现
public void sendAuditWithFallback(AuditEvent event) {
    try {
        kafkaTemplate.send("risk.audit", event).get(3, TimeUnit.SECONDS);
    } catch (Exception e) {
        // Kafka 失败 → 写本地 WAL
        walWriter.append(event.toBytes());
        walWriter.flush();
        metrics.counter("audit.fallback.wal").increment();
    }
}

Q6:实时风控引擎怎么做到 99.99% 可用性?单点故障在哪里?

答:99.99% = 全年不可用时间 < 52 分钟。

关键单点与消除策略:

组件单点风险消除策略
API Gateway网关进程崩溃多实例 + Nginx/Envoy 负载均衡 + 健康检查自动剔除
Redis单节点故障Cluster 模式,16 主 16 从,自动故障转移
规则引擎规则编译内存溢出多节点无状态部署,单节点故障不影响整体
模型服务GPU 节点故障模型多副本部署,CPU 推理作为 GPU 的降级方案
KafkaBroker 全挂跨机房 3 副本,最小 ISR = 2

监控告警:

  • SLO 监控:P99 延迟 > 50ms 持续 1 分钟 → P1 告警
  • 错误率监控:决策失败率 > 0.1% → P0 告警
  • 容量监控:Redis 内存使用率 > 80% → 预警扩容

7. 还要关联学什么?

文档关联点
E1 - 规则引擎设计决策层的规则引擎组件选型与实现细节
E2 - 实时风控系统架构本文的系统设计是 E2 原理篇的工程化落地
E3 - 风险评分服务决策层的模型服务化与熔断降级
E7 - 特征一致性特征层的 Feature Store 架构与一致性保障
B5 - 限流与熔断接入层的 Rate Limiting 和决策层的 Circuit Breaker
C5 - Redis 缓存策略特征层的 L2 Redis 缓存设计与热 Key 治理
D1 - Kafka 架构执行层的审计日志和反馈闭环的 Kafka 设计

记忆口诀:

  • 实时风控 = 机场安检:闸机验票(接入层)→ X光扫描(特征层)→ 安检员+AI 判图(决策层)→ 放行/开箱(执行层)
  • 分层降级 = 俄罗斯套娃:每一层都假设内层可能坏掉,外层准备好兜底方案
  • 延迟预算 = 分蛋糕:50ms 的总蛋糕,接入层切 5ms,特征层切 5ms,决策层切 25ms,执行层切 5ms,网络切 10ms——每一块都不能超支
  • P99 = 木桶最短的那块板:100 个请求里有 1 个慢,用户体验就毁了。优化长尾比优化中位数更重要

系列:risk-systems #3