89088414/16gagent
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

📄 docs: 添加游戏加速器完整技术方案（14部分）

Browse Source
This commit is contained in:
大海
2026-06-06 11:46:01 +08:00
parent a188ee1426
commit b87cac57ce
14 changed files with 5422 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game-accelerator-tech-plan/01-行业分析.md
+467
View File
@@ -0,0 +1,467 @@
# 第一部分：行业分析 — 游戏加速器工作原理与架构
## 1.1 游戏加速器的本质
游戏加速器**不是**VPN。VPN的核心目标是加密和隐私，而加速器的核心目标是**降低延迟、减少丢包、稳定连接**。
```
┌─────────────────────────────────────────────────────────────────────┐
│ 为什么游戏会卡？ │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 玩家(北京联通) ──→ 公共互联网 ──→ 游戏服务器(上海电信) │
│ │
│ 问题链路： │
│ 北京联通 → 骨干网拥堵节点 → 跨运营商互联点(带宽有限) → 上海电信 │
│ │
│ 实测数据： │
│ - 直连延迟：120-180ms（高峰期可达300ms+） │
│ - 丢包率：5-15%（高峰期20%+） │
│ - 抖动：±50ms │
│ │
└─────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────┐
│ 加速后效果 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 玩家(北京联通) ──→ 加速节点(北京BGP) ──→ 专线 ──→ 出口(上海电信) │
│ │
│ 优化链路： │
│ 北京联通 → 本地BGP接入节点 → 企业级专线/优化路由 → 上海电信出口 │
│ │
│ 实测数据： │
│ - 加速延迟：30-50ms │
│ - 丢包率：<1% │
│ - 抖动：±5ms │
│ │
└─────────────────────────────────────────────────────────────────────┘
```
## 1.2 加速器工作原理详解
### 1.2.1 核心原理：路由优化
```
┌──────────────────────────────────────────────────────────────────────┐
│ 路由优化原理 │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ 问题根源：公共BGP路由选择了"最短AS路径"而非"最低延迟路径" │
│ │
│ 直连路径（BGP默认）: │
│ 玩家 ──AS4837(联通骨干)──→ AS4134(电信骨干)──→ 游戏服务器 │
│ 延迟：150ms 丢包：10% │
│ │
│ 加速路径（人工优化）: │
│ 玩家 ──AS4837(联通)──→ 接入节点 ──AS9929(联通优质)──→ 出口 ──→ 服务器│
│ 延迟：45ms 丢包：0.5% │
│ │
│ 关键技术： │
│ 1. BGP路由宣告控制 — 通过AS号宣告控制流量走向 │
│ 2. 企业级专线 — 租用运营商专线（CN2、AS9929等） │
│ 3. 智能DNS — 就近解析到最优接入节点 │
│ 4. 实时探测 — 持续监控链路质量，动态切换 │
│ │
└──────────────────────────────────────────────────────────────────────┘
```
### 1.2.2 UDP加速原理
```
┌───────────────────────────────────────────────────────────────────┐
│ UDP加速原理 │
├───────────────────────────────────────────────────────────────────┤
│ │
│ 大多数游戏使用UDP传输实时数据（位置、动作、状态） │
│ │
│ 原始UDP包: │
│ ┌────────┬────────┬──────────┬────────────┐ │
│ │ IP头 │ UDP头 │ 游戏数据 │ (无校验) │ │
│ └────────┴────────┴──────────┴────────────┘ │
│ │
│ 加速UDP包（隧道封装）: │
│ ┌────────┬────────┬────────┬────────┬──────────┬────────────┐ │
│ │ 外层IP │ 外层UDP│ 隧道头 │ 序列号 │ 原始UDP │ HMAC校验 │ │
│ └────────┴────────┴────────┴────────┴──────────┴────────────┘ │
│ │
│ 加速策略: │
│ 1. 序列号 + 时间戳 — 检测乱序和丢包 │
│ 2. FEC前向纠错 — 冗余数据包，丢1包可恢复 │
│ 3. 选择性重传 — 只重传关键数据包（非全部） │
│ 4. 多路径 — 同时走多条链路，取最快到达的 │
│ 5. 拥塞控制 — 根据链路状况动态调整发送速率 │
│ │
└───────────────────────────────────────────────────────────────────┘
```
### 1.2.3 TCP加速原理
```
┌───────────────────────────────────────────────────────────────────┐
│ TCP加速原理 │
├───────────────────────────────────────────────────────────────────┤
│ │
│ TCP问题： │
│ - 三次握手增加初始延迟 │
│ - 拥塞控制算法（CUBIC）不适合长距离链路 │
│ - 丢包导致整窗口重传 │
│ - 队头阻塞（Head-of-Line Blocking） │
│ │
│ 加速方案（TCP优化代理）: │
│ │
│ 玩家 ←──TCP──→ 接入节点 ←──优化TCP/UDP──→ 出口 ←──TCP──→ 服务器 │
│ │
│ 接入节点: │
│ 1. 本地TCP终结 — 玩家到节点是短距离TCP，握手快 │
│ 2. 连接池复用 — 多个玩家共享长连接 │
│ 3. 协议优化 — 使用BBR/CUBIC+等拥塞控制算法 │
│ 4. 数据压缩 — 减少传输量 │
│ │
│ 效果: │
│ - 首包延迟降低60-80% │
│ - 吞吐量提升30-50% │
│ │
└───────────────────────────────────────────────────────────────────┘
```
### 1.2.4 QoS优化原理
```
┌───────────────────────────────────────────────────────────────────┐
│ QoS优化原理 │
├───────────────────────────────────────────────────────────────────┤
│ │
│ 游戏流量 vs 普通流量的优先级差异: │
│ │
│ 优先级 流量类型 延迟要求 丢包容忍 │
│ ───── ────────── ──────── ──────── │
│ P0 游戏实时数据 <50ms <0.1% │
│ P1 游戏语音 <100ms <1% │
│ P2 游戏登录/匹配 <500ms <0.01% │
│ P3 游戏更新/下载 不限 <0.001% │
│ P4 其他流量 尽力而为 尽力而为 │
│ │
│ 实现方式: │
│ 1. 流量分类 — DSCP标记 + 端口/协议识别 │
│ 2. 队列调度 — 优先队列（PQ）+ 加权公平队列（WFQ） │
│ 3. 流量整形 — 限制P3/P4流量，保证P0/P1带宽 │
│ 4. 拥塞避免 — 主动丢弃低优先级包，保护高优先级包 │
│ │
└───────────────────────────────────────────────────────────────────┘
```
### 1.2.5 智能路由原理
```
┌───────────────────────────────────────────────────────────────────┐
│ 智能路由原理 │
├───────────────────────────────────────────────────────────────────┤
│ │
│ 核心思想：实时感知网络状态，动态选择最优路径 │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 探测模块 │───→│ 评分模块 │───→│ 决策模块 │───→│ 切换模块 │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │ │
│ 实时探测 多维评分 最优选择 无缝切换 │
│ - Ping - 延迟 - 权重计算 - 会话保持 │
│ - Jitter - 丢包 - 约束满足 - 状态迁移 │
│ - 带宽 - 抖动 - 成本优化 - 数据同步 │
│ - 负载 - 负载 - 亲和性 │
│ │
│ 评分公式: │
│ Score = W1×(1/RTT) + W2×(1-Loss) + W3×(1/Jitter) + W4×(1/Load) │
│ │
│ 其中: │
│ - W1=0.4 (延迟权重最高) │
│ - W2=0.3 (丢包次之) │
│ - W3=0.2 (抖动) │
│ - W4=0.1 (负载) │
│ │
│ 切换触发条件: │
│ - 当前节点延迟 > 最优节点延迟 × 1.5 │
│ - 当前节点丢包率 > 5% │
│ - 连续3次探测质量下降 │
│ - 节点负载 > 80% │
│ │
└───────────────────────────────────────────────────────────────────┘
```
### 1.2.6 Anycast与BGP的作用
```
┌───────────────────────────────────────────────────────────────────┐
│ Anycast与BGP的作用 │
├───────────────────────────────────────────────────────────────────┤
│ │
│ Anycast: 同一个IP地址在多个地理位置部署 │
│ BGP: 边界网关协议，互联网路由的核心 │
│ │
│ 应用场景 — 就近接入: │
│ │
│ 玩家A(北京) ──→ 103.x.x.1 ──→ 北京节点 ← BGP宣告 103.x.x.0/24│
│ 玩家B(上海) ──→ 103.x.x.1 ──→ 上海节点 ← BGP宣告 103.x.x.0/24│
│ 玩家C(广州) ──→ 103.x.x.1 ──→ 广州节点 ← BGP宣告 103.x.x.0/24│
│ │
│ 同一个IP，不同地区的玩家自动路由到最近的节点 │
│ │
│ BGP在加速器中的作用: │
│ 1. 多线接入 — 一个节点同时接入电信/联通/移动 │
│ 2. 路由控制 — 通过AS-path prepend、MED控制流量走向 │
│ 3. 故障切换 — 链路故障时自动切换到备用路径 │
│ 4. 负载均衡 — ECMP等多路径负载均衡 │
│ │
│ BGP多线机房示意: │
│ ┌────────────────────────────────────────┐ │
│ │ BGP多线机房 │ │
│ │ ┌──────┐ ┌──────┐ ┌──────┐ │ │
│ │ │电信AS│ │联通AS│ │移动AS│ │ │
│ │ │4134 │ │4837 │ │9808 │ │ │
│ │ └──┬───┘ └──┬───┘ └──┬───┘ │ │
│ │ └────┬────┴────┬────┘ │ │
│ │ │ BGP │ │ │
│ │ │ Router │ │ │
│ │ └────┬────┘ │ │
│ │ │ │ │
│ │ ┌────┴────┐ │ │
│ │ │加速节点 │ │ │
│ │ └─────────┘ │ │
│ └────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────┘
```
### 1.2.7 多路径传输原理
```
┌───────────────────────────────────────────────────────────────────┐
│ 多路径传输原理 │
├───────────────────────────────────────────────────────────────────┤
│ │
│ 核心思想：同时使用多条网络路径传输，提高可靠性 │
│ │
│ ┌────────┐ ┌────────┐ │
│ │ │──── 路径1(联通) ────→ │ │
│ │ 玩家 │──── 路径2(电信) ────→ 节点A │──→ 游戏服务器 │
│ │ │──── 路径3(移动) ────→ │ │
│ └────────┘ └────────┘ │
│ │
│ 策略: │
│ 1. 冗余模式 — 同一份数据走所有路径，取第一个到达的 │
│ 优点：延迟最低 缺点：带宽消耗大 │
│ │
│ 2. 负载均衡 — 数据分散到多条路径 │
│ 优点：带宽高 缺点：乱序问题 │
│ │
│ 3. 主备模式 — 主路径故障时切换到备用路径 │
│ 优点：简单 缺点：切换有延迟 │
│ │
│ 4. 智能模式 — 根据链路质量动态分配（推荐） │
│ - 实时探测各路径质量 │
│ - 关键数据走最优路径 │
│ - 冗余数据走次优路径 │
│ - 动态调整比例 │
│ │
│ 实现协议: │
│ - MPTCP (Multipath TCP) — TCP层多路径 │
│ - QUIC — 应用层多路径支持 │
│ - 自定义 — 隧道层实现多路径 │
│ │
└───────────────────────────────────────────────────────────────────┘
```
## 1.3 国内主流加速器架构分析
### 1.3.1 UU加速器（网易）
```
架构特点：
- 依托网易自有机房 + 第三方IDC
- 全球200+节点
- 自研协议栈
- 游戏深度适配（网易系游戏优先）
技术栈：
- 客户端：WFP驱动 + 用户态隧道
- 协议：自研UDP隧道 + TCP优化
- 调度：基于大数据的智能路由
- 节点：BGP多线 + CN2优质线路
优势：
- 网易系游戏加速效果极佳
- 节点覆盖广
- 品牌认知度高
劣势：
- 非网易系游戏优化一般
- 价格较高
```
### 1.3.2 雷神加速器
```
架构特点：
- 按时计费模式
- 节点质量高
- 电竞向优化
技术栈：
- 客户端：WinDivert + 自研隧道
- 协议：UDP Relay为主
- 调度：实时链路探测 + 评分
- 节点：多云部署（阿里云/腾讯云/华为云）
优势：
- 电竞场景优化好
- 按时计费灵活
- 节点质量稳定
劣势：
- 价格偏高
- 移动端支持弱
```
### 1.3.3 迅游加速器
```
架构特点：
- 上市公司（迅游科技）
- 国内节点最多
- 游戏覆盖最广
技术栈：
- 客户端：NDIS Filter + WFP
- 协议：自研协议（专利技术）
- 调度：分布式调度系统
- 节点：自建 + 合作IDC
优势：
- 节点数量最多
- 游戏覆盖最广
- 技术积累深
劣势：
- 软件臃肿
- 广告多
- 用户体验一般
```
## 1.4 国际主流加速器架构
### 1.4.1 ExitLag
```
特点：
- 专注游戏加速
- 全球节点覆盖
- 多路径传输技术（MUX）
- 支持FPS/MOBA/MMO
技术亮点：
- MUX协议 — 多路径传输
- 实时路由优化
- 低延迟优先策略
```
### 1.4.2 WTFast
```
特点：
- GPN（Gamers Private Network）
- 全球60+国家节点
- 支持1000+游戏
- AI驱动的路由优化
技术亮点：
- AI智能路由
- 自适应协议选择
- 云端节点管理
```
### 1.4.3 Mudfish
```
特点：
- 按流量计费
- 技术向产品
- 支持自定义节点
- 开源友好
技术亮点：
- 节点自定义
- 流量精细化管理
- 低价格策略
```
## 1.5 真实链路案例分析
### 案例1：北京联通 → 日本东京（原神国际服）
```
直连链路：
北京联通(AS4837) → 骨干网 → 上海NAP点 → 中日海缆 → 日本NTT(AS2914) → 东京
延迟：180-250ms
丢包：8-15%
抖动：±40ms
加速链路：
北京联通 → 本地BGP接入节点 → CN2专线(AS4809) → 东京出口节点 → 游戏服务器
延迟：45-60ms
丢包：<1%
抖动：±5ms
优化效果：
- 延迟降低：70-75%
- 丢包降低：90%+
- 抖动降低：87%
```
### 案例2：上海电信 → 美国洛杉矶（Steam游戏）
```
直连链路：
上海电信(AS4134) → 骨干网 → 上海出口 → 太平洋海缆 → 美国Level3(AS3356) → 洛杉矶
延迟：200-300ms
丢包：10-20%
抖动：±60ms
加速链路：
上海电信 → 本地接入节点 → 专线/优化路由 → 洛杉矶出口节点 → 游戏服务器
延迟：120-150ms
丢包：<2%
抖动：±10ms
优化效果：
- 延迟降低：40-50%
- 丢包降低：85%+
- 抖动降低：83%
```
### 案例3：跨运营商（移动 → 电信服务器）
```
直连链路：
移动用户(AS9808) → 移动骨干网 → 互联点(带宽有限) → 电信骨干(AS4134) → 服务器
延迟：80-150ms
丢包：5-12%
原因：运营商互联点带宽有限，高峰时段严重拥堵
加速链路：
移动用户 → 移动接入节点 → BGP多线节点 → 电信出口 → 服务器
延迟：25-40ms
丢包：<1%
原因：通过BGP多线节点绕过拥堵的互联点
```
## 1.6 行业技术趋势
```
2024-2026年技术趋势：
1. QUIC协议普及 — 基于UDP的可靠传输，天然适合游戏加速
2. AI驱动调度 — 机器学习预测链路质量，提前切换
3. 边缘计算 — MEC节点下沉，加速节点更靠近用户
4. 5G融合 — 5G网络切片提供专属游戏通道
5. 协议栈优化 — 从用户态向内核态演进，性能提升
6. 云原生架构 — 节点容器化，弹性伸缩
```
game-accelerator-tech-plan/02-整体系统架构设计.md
+673
View File
@@ -0,0 +1,673 @@
# 第二部分：整体系统架构设计
## 2.1 全局架构总览
```
┌─────────────────────────────────────────────────────────────────────────────────┐
│ 加速器系统全局架构 │
├─────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────── 客户端层 ───────────────────────┐ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Windows │ │ Mac │ │ Android │ │ iOS │ │ │
│ │ │ Client │ │ Client │ │ Client │ │ Client │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ │ └─────────────┴─────────────┴─────────────┘ │ │
│ │ │ HTTPS/WSS │ │
│ └─────────────────────────┼───────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────┼──── API Gateway层 ───────────┐ │
│ │ ┌────┴────┐ │ │
│ │ │ Nginx │ (负载均衡/限流/WAF) │ │
│ │ │ OpenResty│ │ │
│ │ └────┬────┘ │ │
│ └─────────────────────────┼───────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────┼──── 微服务层 ────────────────┐ │
│ │ ┌──────────┐ ┌────────┴───┐ ┌──────────┐ ┌────────┐ │ │
│ │ │ 用户中心 │ │ 订单中心 │ │ 会员中心 │ │ 风控 │ │ │
│ │ │ User │ │ Order │ │ VIP │ │ Risk │ │ │
│ │ └──────────┘ └────────────┘ └──────────┘ └────────┘ │ │
│ │ ┌──────────┐ ┌────────────┐ ┌──────────┐ ┌────────┐ │ │
│ │ │ 节点管理 │ │ 调度中心 │ │ 游戏配置 │ │ 监控 │ │ │
│ │ │ Node │ │ Dispatch │ │ Game │ │ Monitor│ │ │
│ │ └──────────┘ └────────────┘ └──────────┘ └────────┘ │ │
│ │ ┌──────────┐ ┌────────────┐ ┌──────────┐ │ │
│ │ │ 日志中心 │ │ 通知中心 │ │ 配置中心 │ │ │
│ │ │ Log │ │ Notify │ │ Config │ │ │
│ │ └──────────┘ └────────────┘ └──────────┘ │ │
│ └────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────┼──── 数据层 ──────────────────┐ │
│ │ ┌──────┐ ┌──────┐ ┌───┴───┐ ┌──────┐ ┌──────────┐ │ │
│ │ │MySQL │ │Redis │ │MongoDB│ │Kafka │ │ClickHouse│ │ │
│ │ │主数据 │ │缓存 │ │日志 │ │消息 │ │分析 │ │ │
│ │ └──────┘ └──────┘ └───────┘ └──────┘ └──────────┘ │ │
│ └────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────┼──── 加速网络层 ──────────────┐ │
│ │ ┌──────────┐ ┌────────┴───┐ ┌──────────┐ │ │
│ │ │ 接入节点 │ │ 中转节点 │ │ 出口节点 │ │ │
│ │ │ Access │ │ Relay │ │ Exit │ │ │
│ │ │ (200+) │ │ (50+) │ │ (100+) │ │ │
│ │ └──────────┘ └────────────┘ └──────────┘ │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────┘
```
## 2.2 客户端模块设计
### 2.2.1 模块总览
```
┌─────────────────────────────────────────────────────────────────┐
│ Windows 客户端架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ UI 层 (Electron/Tauri) │ │
│ │ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ │
│ │ │ 登录 │ │ 主页 │ │ 游戏 │ │ 加速 │ │ 设置 │ │ │
│ │ └──────┘ └──────┘ └──────┘ └──────┘ └──────┘ │ │
│ └───────────────────────────┬─────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────┼──── 业务层 ─────────────────┐ │
│ │ ┌──────────┐ ┌──────────┼──────────┐ ┌──────────┐ │ │
│ │ │ 登录模块 │ │ 游戏识别 ││ 测速模块 │ │ 诊断模块 │ │ │
│ │ │ Auth │ │ GameDetect│ SpeedTest │ │ Diagnose │ │ │
│ │ └──────────┘ └──────────┴──────────┘ └──────────┘ │ │
│ │ ┌──────────┐ ┌──────────────┐ ┌──────────┐ │ │
│ │ │ 自动更新 │ │ 崩溃上报 │ │ 数据统计 │ │ │
│ │ │ Updater │ │ CrashReport │ │ Analytics│ │ │
│ │ └──────────┘ └──────────────┘ └──────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────┼──── 核心层 ─────────────────┐ │
│ │ ┌──────────────────┐ ┌──┴────────────┐ ┌───────────┐ │ │
│ │ │ 流量捕获模块 │ │ 隧道模块 │ │ 路由模块 │ │ │
│ │ │ TrafficCapture │ │ Tunnel │ │ Router │ │ │
│ │ │ (WFP/WinDivert) │ │ (UDP/QUIC) │ │ (Smart) │ │ │
│ │ └──────────────────┘ └───────────────┘ └───────────┘ │ │
│ │ ┌──────────────────┐ ┌───────────────┐ ┌───────────┐ │ │
│ │ │ 协议识别模块 │ │ 加密模块 │ │ 压缩模块 │ │ │
│ │ │ ProtocolDetect │ │ Crypto │ │ Compress │ │ │
│ │ └──────────────────┘ └───────────────┘ └───────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────┼──── 驱动层 ─────────────────┐ │
│ │ ┌──────────────────────────────────────────────────┐ │ │
│ │ │ WFP Callout Driver │ │ │
│ │ │ (Windows Filtering Platform) │ │ │
│ │ └──────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
```
### 2.2.2 各模块详细设计
#### 模块1：登录模块（Auth Module）
```
职责：
- 用户注册/登录（手机号/邮箱/第三方OAuth）
- Token管理（JWT Access Token + Refresh Token）
- 设备绑定与管理
- 多设备限制（防共享账号）
- 自动登录与Token刷新
技术实现：
┌──────────┐ ┌──────────┐ ┌──────────┐
│ 登录页面 │────→│ Auth API │────→│ 用户中心 │
└──────────┘ └──────────┘ └──────────┘
│ │ │
│ ┌────┴────┐ ┌────┴────┐
│ │ JWT签发 │ │ Redis │
│ │ RS256 │ │ Session │
│ └─────────┘ └─────────┘
│
└──→ 本地存储加密Token（Keychain/DPAPI）
数据流：
1. 用户输入凭证 → HTTPS POST /api/v1/auth/login
2. 服务端验证 → 签发JWT（有效期2h）+ Refresh Token（有效期30d）
3. 客户端存储Token → 后续请求自动携带Authorization头
4. Token过期 → 使用Refresh Token自动刷新
5. Refresh Token过期 → 重新登录
```
#### 模块2：游戏识别模块（Game Detection Module）
```
职责：
- 自动识别已安装游戏
- 匹配游戏配置（服务器地址、端口、协议）
- 支持手动添加游戏
- 游戏版本检测
技术实现：
┌──────────────────────────────────────────────────────────┐
│ 游戏识别流程 │
├──────────────────────────────────────────────────────────┤
│ │
│ 方式1：进程名匹配 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 进程快照 │───→│ 进程名 │───→│ 匹配游戏 │ │
│ │ CreateTool│ │ 比对 │ │ 配置库 │ │
│ │ Snapshot │ │ │ │ │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 方式2：注册表扫描 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 注册表 │───→│ 安装路径 │───→│ EXE信息 │ │
│ │ HKLM\...\│ │ 提取 │ │ 匹配 │ │
│ │ Uninstall │ │ │ │ │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 方式3：Steam库扫描 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Steam │───→│ appinfo │───→│ 游戏列表 │ │
│ │ library │ │ .vdf解析 │ │ 匹配 │ │
│ │folders │ │ │ │ │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 游戏配置数据库结构 (GameConfig): │
│ { │
│ "game_id": "genshin_impact", │
│ "name": "原神", │
│ "process_names": ["GenshinImpact.exe", "YuanShen.exe"],│
│ "servers": [ │
│ { │
│ "name": "亚服", │
│ "ip_ranges": ["47.245.0.0/16"], │
│ "ports": [443, 80, 22102], │
│ "protocol": "tcp+udp", │
│ "region": "asia" │
│ } │
│ ], │
│ "capture_mode": "process", │
│ "tunnel_mode": "udp_relay" │
│ } │
│ │
└──────────────────────────────────────────────────────────┘
```
#### 模块3：流量捕获模块（Traffic Capture Module）
```
职责：
- 捕获指定游戏进程的网络流量
- 区分游戏流量和非游戏流量
- 支持TCP和UDP流量
- 零拷贝转发（性能优化）
技术实现（Windows）：
方案对比：
┌──────────────┬────────────┬────────────┬───────────┬──────────┐
│ 方案 │ 兼容性 │ 性能 │ 稳定性 │ 推荐度 │
├──────────────┼────────────┼────────────┼───────────┼──────────┤
│ WFP │ Win7+ │ 高 │ 高 │ ★★★★★ │
│ WinDivert │ Win7+ │ 中高 │ 中高 │ ★★★★ │
│ TUN/TAP │ 全平台 │ 中 │ 中 │ ★★★ │
│ NDIS Filter │ Win7+ │ 高 │ 中 │ ★★★ │
│ LSP/WFP │ Win7+ │ 中 │ 低 │ ★★ │
└──────────────┴────────────┴────────────┴───────────┴──────────┘
推荐方案：WFP (Windows Filtering Platform)
原因：
1. 微软官方支持，稳定性最高
2. 内核态过滤，性能最好
3. 支持按进程过滤
4. 支持Win7-Win11全系列
WFP架构：
┌─────────────────────────────────────────────────────────┐
│ 用户态 (Ring 3) │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 加速器客户端进程 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 流量管理 │ │ 隧道封装 │ │ 策略引擎 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └──────────────────────────┬──────────────────────┘ │
│ │ IOCTL │
├─────────────────────────────┼───────────────────────────┤
│ 内核态 (Ring 0) │
│ ┌──────────────────────────┴──────────────────────┐ │
│ │ WFP Callout Driver │ │
│ │ ┌──────────────────────────────────────────┐ │ │
│ │ │ ALE Layer (Application Layer Enforcement)│ │ │
│ │ │ - ALE_AUTH_CONNECT_V4 │ │ │
│ │ │ - ALE_AUTH_RECV_ACCEPT_V4 │ │ │
│ │ │ ↓ 按进程PID过滤 │ │ │
│ │ │ ↓ 按目标IP/端口过滤 │ │ │
│ │ │ ↓ 决定：放行/拦截/重定向 │ │ │
│ │ └──────────────────────────────────────────┘ │ │
│ │ ┌──────────────────────────────────────────┐ │ │
│ │ │ Transport Layer │ │ │
│ │ │ - FWPM_LAYER_OUTBOUND_TRANSPORT_V4 │ │ │
│ │ │ - FWPM_LAYER_INBOUND_TRANSPORT_V4 │ │ │
│ │ │ ↓ 数据包级别的过滤和修改 │ │ │
│ │ └──────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘
```
#### 模块4：隧道模块（Tunnel Module）
```
职责：
- 封装游戏流量为隧道协议
- 加密传输（防止DPI检测和中间人攻击）
- 多节点间中转
- 协议自适应（根据网络状况选择最优协议）
技术实现：
┌──────────────────────────────────────────────────────────┐
│ 隧道协议栈 │
├──────────────────────────────────────────────────────────┤
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Layer 5: 应用层 │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ 游戏原始数据 │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Layer 4: 隧道封装层 │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ 隧道头 | 序列号 | 时间戳 | 校验和 | 原始数据 │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Layer 3: 加密层 │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ AES-256-GCM / ChaCha20-Poly1305 │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Layer 2: 传输层 │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ UDP Relay / QUIC / KCP / 自定义协议 │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Layer 1: 网络层 │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ IP / IPv4 / IPv6 │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────┘
```
#### 模块5：测速模块（Speed Test Module）
```
职责：
- 测试到各节点的延迟、丢包、抖动
- 测试带宽
- 节点评分
- 历史数据存储
技术实现：
┌──────────────────────────────────────────────────────────┐
│ 测速算法设计 │
├──────────────────────────────────────────────────────────┤
│ │
│ 1. 延迟测试（RTT） │
│ - 发送UDP探测包，记录往返时间 │
│ - 连续发送10个包，取中位数（去除异常值） │
│ - 每30秒更新一次 │
│ │
│ 2. 丢包率测试 │
│ - 发送20个UDP包，统计未收到回复的数量 │
│ - 丢包率 = 未回复数 / 总发送数 │
│ - 连续3轮测试取平均值 │
│ │
│ 3. 抖动测试（Jitter） │
│ - Jitter = Σ|RTTi - RTTi-1| / (N-1) │
│ - 连续10个包的RTT标准差 │
│ │
│ 4. 带宽测试 │
│ - 发送递增大小的数据包 │
│ - 测量吞吐量上限 │
│ - TCP + UDP分别测试 │
│ │
│ 5. 综合评分公式 │
│ Score = 100 │
│ - RTT扣分: max(0, (RTT - 30) × 0.5) │
│ - Loss扣分: Loss × 200 │
│ - Jitter扣分: Jitter × 2 │
│ Score = max(0, Score) │
│ │
│ 评分等级: │
│ 90-100: 极佳（绿色） │
│ 70-89: 良好（黄色） │
│ 50-69: 一般（橙色） │
│ <50: 较差（红色） │
│ │
└──────────────────────────────────────────────────────────┘
```
#### 模块6：诊断模块（Diagnostic Module）
```
职责：
- 网络环境诊断
- 加速效果诊断
- 问题排查与上报
- 一键诊断报告生成
诊断项：
┌────────────────┬──────────────────────────────────────┐
│ 诊断项 │ 说明 │
├────────────────┼──────────────────────────────────────┤
│ DNS解析 │ 检测DNS是否正常，是否被污染 │
│ 网络连通性 │ Ping测试各节点可达性 │
│ 路由追踪 │ Traceroute分析路由路径 │
│ 端口检测 │ 检测游戏所需端口是否可达 │
│ MTU检测 │ 检测最大传输单元，避免分片 │
│ NAT类型 │ 检测NAT类型（影响P2P游戏） │
│ 防火墙 │ 检测防火墙是否阻止游戏流量 │
│ 驱动状态 │ 检测WFP驱动是否正常加载 │
│ 系统兼容性 │ 检测操作系统版本兼容性 │
└────────────────┴──────────────────────────────────────┘
```
#### 模块7：自动更新模块（Updater Module）
```
职责：
- 增量更新（只下载变化的部分）
- 静默更新（后台自动完成）
- 回滚机制（更新失败可回退）
- 灰度发布
技术实现：
┌──────────────────────────────────────────────────────────┐
│ 自动更新流程 │
├──────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 检查更新 │───→│ 下载差异 │───→│ 校验文件 │ │
│ │ GET /api │ │ bsdiff │ │ SHA256 │ │
│ │ /version │ │ 增量包 │ │ 签名验证 │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │ │ │
│ │ ┌───────────────────┘ │
│ │ ↓ │
│ │ ┌──────────┐ ┌──────────┐ │
│ │ │ 备份当前 │───→│ 应用更新 │ │
│ │ │ 版本 │ │ 替换文件 │ │
│ │ └──────────┘ └──────────┘ │
│ │ │ │
│ │ ┌───────────────┘ │
│ │ ↓ │
│ │ ┌──────────┐ ┌──────────┐ │
│ │ │ 验证更新 │───→│ 重启应用 │ │
│ │ │ 启动测试 │ │ 完成更新 │ │
│ │ └──────────┘ └──────────┘ │
│ │ │
│ │ 更新失败？→ 回滚到备份版本 │
│ │
└──────────────────────────────────────────────────────────┘
```
#### 模块8：崩溃上报模块（Crash Report Module）
```
职责：
- 捕获未处理异常
- 生成MiniDump文件
- 收集系统环境信息
- 上传崩溃报告
技术实现：
- Windows: SetUnhandledExceptionFilter + MiniDumpWriteDump
- 收集信息：CPU/内存/磁盘/网络/驱动版本/系统版本
- 上传：压缩后HTTPS上传到崩溃收集服务
- 分析：服务端自动符号解析，生成可读堆栈
```
## 2.3 服务端微服务架构
### 2.3.1 服务关系图
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 微服务架构关系图 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ │
│ │ API Gateway │ │
│ │ (OpenResty) │ │
│ └──────┬───────┘ │
│ │ │
│ ┌──────────┬──────────┼──────────┬──────────┐ │
│ ↓ ↓ ↓ ↓ ↓ │
│ ┌──────────┐┌──────────┐┌──────────┐┌──────────┐┌──────────┐ │
│ │ 用户中心 ││ 订单中心 ││ 节点管理 ││ 调度中心 ││ 游戏配置 │ │
│ │ ││ ││ ││ ││ │ │
│ │ - 注册 ││ - 创建 ││ - 节点 ││ - 路由 ││ - 游戏 │ │
│ │ - 登录 ││ 订单 ││ 注册 ││ 决策 ││ 列表 │ │
│ │ - Token ││ - 支付 ││ - 健康 ││ - 负载 ││ - 服务器 │ │
│ │ - 设备 ││ - 退款 ││ 检查 ││ 均衡 ││ 配置 │ │
│ │ - 会员 ││ - 续费 ││ - 节点 ││ - 智能 ││ - 版本 │ │
│ │ ││ ││ 发现 ││ 选路 ││ 更新 │ │
│ └────┬─────┘└────┬─────┘└────┬─────┘└────┬─────┘└────┬─────┘ │
│ │ │ │ │ │ │
│ └───────────┴───────────┴─────┬─────┴───────────┘ │
│ │ │
│ ┌──────────┬────────────────┼──────────┬──────────┐ │
│ ↓ ↓ ↓ ↓ ↓ │
│ ┌──────────┐┌──────────┐ ┌──────────┐┌──────────┐┌──────────┐ │
│ │ 监控中心 ││ 风控中心 │ │ 日志中心 ││ 通知中心 ││ 配置中心 │ │
│ │ ││ │ │ ││ ││ │ │
│ │ - 指标 ││ - 异常 │ │ - 日志 ││ - 推送 ││ - 动态 │ │
│ │ 采集 ││ 检测 │ │ 收集 ││ - 短信 ││ 配置 │ │
│ │ - 告警 ││ - 频控 │ │ - 分析 ││ - 邮件 ││ - 灰度 │ │
│ │ - 面板 ││ - 黑名单 │ │ - 存储 ││ - 站内信 ││ - 版本 │ │
│ └──────────┘└──────────┘ └──────────┘└──────────┘└──────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
### 2.3.2 各服务详细设计
#### 用户中心（User Service）
```
职责：
- 用户注册、登录、注销
- Token签发与验证
- 设备绑定与管理
- 会员状态管理
- 用户信息CRUD
接口设计：
POST /api/v1/auth/register # 注册
POST /api/v1/auth/login # 登录
POST /api/v1/auth/logout # 登出
POST /api/v1/auth/refresh # 刷新Token
GET /api/v1/user/profile # 获取用户信息
PUT /api/v1/user/profile # 更新用户信息
POST /api/v1/user/bindDevice # 绑定设备
DELETE /api/v1/user/unbindDevice # 解绑设备
GET /api/v1/user/devices # 设备列表
POST /api/v1/user/changePassword # 修改密码
POST /api/v1/user/resetPassword # 重置密码
技术栈：
- Go (Gin框架)
- MySQL (用户数据)
- Redis (Session/Token缓存)
- gRPC (服务间通信)
```
#### 订单中心（Order Service）
```
职责：
- 订单创建与管理
- 支付对接（支付宝/微信/Apple Pay）
- 退款处理
- 订单统计
接口设计：
POST /api/v1/order/create # 创建订单
GET /api/v1/order/{id} # 查询订单
GET /api/v1/order/list # 订单列表
POST /api/v1/order/pay # 发起支付
POST /api/v1/order/callback # 支付回调
POST /api/v1/order/refund # 申请退款
GET /api/v1/order/statistics # 订单统计
支付流程：
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│ 创建 │───→│ 支付 │───→│ 回调 │───→│ 激活 │
│ 订单 │ │ 请求 │ │ 验签 │ │ 会员 │
└────────┘ └────────┘ └────────┘ └────────┘
│ │ │ │
MySQL 支付宝/ 异步通知 更新用户
订单表 微信支付 验证签名 会员状态
```
#### 节点管理（Node Service）
```
职责：
- 节点注册与发现
- 节点健康检查
- 节点配置下发
- 节点状态监控
节点数据结构：
{
"node_id": "cn-bj-01",
"name": "北京BGP节点01",
"region": "china",
"city": "beijing",
"isp": ["unicom", "telecom", "mobile"],
"ip": "103.x.x.1",
"port": 8000,
"capacity": 10000,
"current_load": 3500,
"status": "online",
"quality_score": 95,
"bandwidth_mbps": 10000,
"location": {"lat": 39.9042, "lng": 116.4074}
}
健康检查机制：
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ 心跳上报 │───→│ 状态检查 │───→│ 质量探测 │───→│ 告警决策 │
│ 每10秒 │ │ CPU/内存 │ │ Ping/丢包│ │ 自动摘除 │
│ UDP心跳 │ │ 带宽/连接│ │ 延迟/抖动│ │ 通知运维 │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
```
#### 调度中心（Dispatch Service）
```
职责：
- 智能选路（为用户选择最优节点）
- 负载均衡
- 链路质量监控
- 路由策略管理
调度流程：
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ 用户请求 │───→│ 节点筛选 │───→│ 质量评分 │───→│ 最优选择 │
│ 加速游戏 │ │ 区域匹配 │ │ 多维权重 │ │ 返回节点 │
│ │ │ 负载过滤 │ │ 计算排序 │ │ │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
评分算法：
Score(i) = α × (1 / RTT_i) + β × (1 - Loss_i) + γ × (1 / Jitter_i) + δ × (1 - Load_i)
其中：
- α = 0.4（延迟权重）
- β = 0.3（丢包权重）
- γ = 0.2（抖动权重）
- δ = 0.1（负载权重）
约束条件：
- RTT_i < 100ms
- Loss_i < 5%
- Load_i < 80%
- 节点支持该游戏
```
## 2.4 API设计规范
### 2.4.1 RESTful API规范
```
基础规范：
- 基础URL: https://api.accelerator.com/v1
- 认证方式: Bearer Token (JWT)
- 数据格式: JSON
- 编码: UTF-8
- 时间格式: ISO 8601 (UTC)
响应格式：
{
"code": 0, // 0=成功, 非0=错误码
"message": "success", // 错误描述
"data": {}, // 业务数据
"timestamp": 1717651200, // 时间戳
"request_id": "uuid" // 请求追踪ID
}
错误码设计：
┌──────────┬────────────────────────────────┐
│ 错误码 │ 说明 │
├──────────┼────────────────────────────────┤
│ 0 │ 成功 │
│ 1001 │ 参数错误 │
│ 1002 │ 未登录 │
│ 1003 │ Token过期 │
│ 1004 │ 无权限 │
│ 2001 │ 用户不存在 │
│ 2002 │ 密码错误 │
│ 2003 │ 设备已达上限 │
│ 3001 │ 订单不存在 │
│ 3002 │ 支付失败 │
│ 4001 │ 节点不可用 │
│ 4002 │ 无可用节点 │
│ 5001 │ 服务器内部错误 │
└──────────┴────────────────────────────────┘
```
### 2.4.2 gRPC服务定义
```protobuf
// 用户服务
service UserService {
rpc Login(LoginRequest) returns (LoginResponse);
rpc GetProfile(GetProfileRequest) returns (UserProfile);
rpc UpdateProfile(UpdateProfileRequest) returns (UserProfile);
rpc BindDevice(BindDeviceRequest) returns (BindDeviceResponse);
}
// 调度服务
service DispatchService {
rpc GetBestNode(DispatchRequest) returns (NodeInfo);
rpc ReportQuality(QualityReport) returns (QualityReportResponse);
rpc GetNodeList(NodeListRequest) returns (NodeListResponse);
}
// 节点服务
service NodeService {
rpc RegisterNode(NodeRegisterRequest) returns (NodeRegisterResponse);
rpc Heartbeat(HeartbeatRequest) returns (HeartbeatResponse);
rpc GetNodeStatus(NodeStatusRequest) returns (NodeStatus);
}
```
game-accelerator-tech-plan/03-核心网络架构.md
+330
View File
@@ -0,0 +1,330 @@
# 第三部分：核心网络架构
## 3.1 节点体系设计
### 3.1.1 三层节点架构
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 三层节点架构 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 接入层 (Access Layer) │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 北京BGP │ │ 上海BGP │ │ 广州BGP │ │ 深圳BGP │ │ │
│ │ │ 103.x.1 │ │ 103.x.2 │ │ 103.x.3 │ │ 103.x.4 │ │ │
│ │ │ 电信/联通 │ │ 电信/联通 │ │ 电信/联通 │ │ 电信/联通 │ │ │
│ │ │ /移动 │ │ /移动 │ │ /移动 │ │ /移动 │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ └───────┼──────────────┼──────────────┼──────────────┼─────────────┘ │
│ │ │ │ │ │
│ └──────────────┴──────┬───────┴──────────────┘ │
│ │ │
│ ┌─────────────────────────────┼─────────────────────────────────────┐ │
│ │ 中转层 (Relay Layer) │ │
│ │ ┌──────────────┴──────────────┐ │ │
│ │ │ │ │ │
│ │ ┌───────────┴───┐ ┌──────────┴───────┐ │ │
│ │ │ 国内中转集群 │ │ 国际中转集群 │ │ │
│ │ │ CN2专线/AS9929 │ │ PCCW/NTT/Telia │ │ │
│ │ │ │ │ │ │ │
│ │ │ 上海←→北京 │ │ 香港←→东京 │ │ │
│ │ │ 上海←→广州 │ │ 香港←→新加坡 │ │ │
│ │ │ 北京←→成都 │ │ 东京←→洛杉矶 │ │ │
│ │ └───────────────┘ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────────┼─────────────────────────────────────┐ │
│ │ 出口层 (Exit Layer) │ │
│ │ ┌──────────────┴──────────────┐ │ │
│ │ │ │ │ │
│ │ ┌───────────┴───┐ ┌──────────┴───────┐ │ │
│ │ │ 国内游戏出口 │ │ 海外游戏出口 │ │ │
│ │ │ │ │ │ │ │
│ │ │ 电信游戏专区 │ │ 日本(东京/大阪) │ │ │
│ │ │ 联通游戏专区 │ │ 韩国(首尔) │ │ │
│ │ │ 移动游戏专区 │ │ 新加坡 │ │ │
│ │ │ │ │ 美国(LA/西雅图) │ │ │
│ │ │ │ │ 德国(法兰克福) │ │ │
│ │ │ │ │ 英国(伦敦) │ │ │
│ │ └───────────────┘ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
### 3.1.2 各节点职责
```
┌──────────────┬──────────────────────────────────────────────────────────┐
│ 节点类型 │ 职责 │
├──────────────┼──────────────────────────────────────────────────────────┤
│ 接入节点 │ 1. 就近接入用户流量（Anycast/BGP多线） │
│ (Access) │ 2. 用户身份验证 │
│ │ 3. 流量分类与标记（QoS） │
│ │ 4. 初始路由决策 │
│ │ 5. 连接管理 │
│ │ 6. 负载均衡 │
│ │ │
│ │ 部署要求： │
│ │ - BGP多线接入（电信+联通+移动） │
│ │ - 带宽：1Gbps-10Gbps │
│ │ - 地理位置：靠近用户密集区 │
│ │ - 数量：200+ │
├──────────────┼──────────────────────────────────────────────────────────┤
│ 中转节点 │ 1. 流量中转与转发 │
│ (Relay) │ 2. 协议转换（如需要） │
│ │ 3. 流量压缩与加密 │
│ │ 4. 链路质量监控 │
│ │ 5. 多路径管理 │
│ │ 6. FEC前向纠错 │
│ │ │
│ │ 部署要求： │
│ │ - 优质线路（CN2/AS9929/国际专线） │
│ │ - 带宽：10Gbps-100Gbps │
│ │ - 地理位置：骨干网核心节点 │
│ │ - 数量：50+ │
├──────────────┼──────────────────────────────────────────────────────────┤
│ 出口节点 │ 1. 就近出口到游戏服务器 │
│ (Exit) │ 2. NAT/代理功能 │
│ │ 3. 协议适配 │
│ │ 4. 游戏服务器健康检查 │
│ │ 5. 流量统计与计费 │
│ │ │
│ │ 部署要求： │
│ │ - 靠近游戏服务器机房 │
│ │ - 带宽：1Gbps-10Gbps │
│ │ - 地理位置：游戏服务器集中区 │
│ │ - 数量：100+ │
└──────────────┴──────────────────────────────────────────────────────────┘
```
### 3.1.3 节点间通信
```
┌──────────────────────────────────────────────────────────────────┐
│ 节点间通信协议 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 控制面（Control Plane）： │
│ - 协议：gRPC + Protobuf │
│ - 功能：节点注册、配置下发、状态同步、路由更新 │
│ - 传输：TCP (TLS) │
│ - 频率：心跳每10秒，配置变更实时推送 │
│ │
│ 数据面（Data Plane）： │
│ - 协议：自定义UDP协议 / QUIC │
│ - 功能：游戏流量转发 │
│ - 传输：UDP │
│ - 特点：低延迟、高吞吐、前向纠错 │
│ │
│ 管理面（Management Plane）： │
│ - 协议：HTTPS REST API │
│ - 功能：运维管理、监控数据采集、日志收集 │
│ - 传输：TCP (TLS) │
│ │
│ 节点发现机制： │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 节点启动 │───→│ 注册中心 │───→│ 广播通知 │ │
│ │ 启动上报 │ │ etcd │ │ 其他节点 │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 健康检查机制： │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 心跳上报 │───→│ 超时检测 │───→│ 故障处理 │ │
│ │ 每10秒 │ │ 30秒超时 │ │ 自动摘除 │ │
│ │ UDP │ │ 3次重试 │ │ 告警通知 │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 3.2 全球节点规划
### 3.2.1 中国大陆节点
```
┌────────┬──────────┬────────────┬──────────┬──────────┬──────────────┐
│ 城市 │ 节点数量 │ 机房类型 │ 带宽 │ ISP │ 用途 │
├────────┼──────────┼────────────┼──────────┼──────────┼──────────────┤
│ 北京 │ 5 │ BGP多线 │ 10Gbps │ 三线 │ 华北接入 │
│ 上海 │ 5 │ BGP多线 │ 10Gbps │ 三线 │ 华东接入+中转 │
│ 广州 │ 4 │ BGP多线 │ 10Gbps │ 三线 │ 华南接入 │
│ 深圳 │ 3 │ BGP多线 │ 10Gbps │ 三线 │ 华南接入 │
│ 成都 │ 3 │ BGP多线 │ 5Gbps │ 三线 │ 西南接入 │
│ 武汉 │ 2 │ BGP多线 │ 5Gbps │ 三线 │ 华中接入 │
│ 杭州 │ 2 │ BGP多线 │ 5Gbps │ 三线 │ 华东接入 │
│ 南京 │ 2 │ BGP多线 │ 5Gbps │ 三线 │ 华东接入 │
│ 西安 │ 2 │ BGP多线 │ 5Gbps │ 三线 │ 西北接入 │
│ 重庆 │ 2 │ BGP多线 │ 5Gbps │ 三线 │ 西南接入 │
├────────┼──────────┼────────────┼──────────┼──────────┼──────────────┤
│ 合计 │ 30 │ │ │ │ │
└────────┴──────────┴────────────┴──────────┴──────────┴──────────────┘
专用线路：
- CN2 GT: 上海 ←→ 北京/广州/成都
- AS9929 (联通A网): 北京 ←→ 上海/广州
- 9929/CN2 混合: 国内核心城市互联
部署方案：
┌──────────────────────────────────────────────────────────────┐
│ 单节点部署架构 │
├──────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 物理服务器 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ CPU: 32核│ │ RAM: 64G │ │ SSD: 1T │ │ │
│ │ │ E5-2680 │ │ DDR4 │ │ NVMe │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 网卡 │ │ 网卡 │ │ 网卡 │ │ │
│ │ │ 10GbE │ │ 10GbE │ │ 1GbE │ │ │
│ │ │ (数据) │ │ (管理) │ │ (IPMI) │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 软件栈 │ │
│ │ ┌────────────────────────────────────────────────┐ │ │
│ │ │ OS: Ubuntu 22.04 LTS / Debian 12 │ │ │
│ │ │ 内核: 6.1+ (开启BBR拥塞控制) │ │ │
│ │ │ 容器: Docker + containerd │ │ │
│ │ │ 编排: K3s (轻量Kubernetes) │ │ │
│ │ └────────────────────────────────────────────────┘ │ │
│ │ ┌────────────────────────────────────────────────┐ │ │
│ │ │ 服务容器: │ │ │
│ │ │ - accelerator-relay (转发服务) │ │ │
│ │ │ - accelerator-health (健康检查) │ │ │
│ │ │ - accelerator-monitor (监控Agent) │ │ │
│ │ │ - node-exporter (系统指标) │ │ │
│ │ └────────────────────────────────────────────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────┘
```
### 3.2.2 海外节点
```
┌──────────────┬──────────┬────────────┬──────────┬──────────────────┐
│ 地区 │ 城市 │ 节点数量 │ 带宽 │ 用途 │
├──────────────┼──────────┼────────────┼──────────┼──────────────────┤
│ 亚太 │ 香港 │ 4 │ 10Gbps │ 国际接入+中转 │
│ │ 东京 │ 3 │ 10Gbps │ 日服游戏出口 │
│ │ 大阪 │ 2 │ 5Gbps │ 日服备用 │
│ │ 首尔 │ 2 │ 5Gbps │ 韩服游戏出口 │
│ │ 新加坡 │ 3 │ 10Gbps │ 东南亚接入 │
│ │ 悉尼 │ 1 │ 2Gbps │ 澳服出口 │
├──────────────┼──────────┼────────────┼──────────┼──────────────────┤
│ 北美 │ 洛杉矶 │ 3 │ 10Gbps │ 美西接入+出口 │
│ │ 西雅图 │ 2 │ 5Gbps │ 美西北出口 │
│ │ 达拉斯 │ 2 │ 5Gbps │ 美南出口 │
│ │ 圣何塞 │ 2 │ 5Gbps │ 硅谷出口 │
│ │ 弗吉尼亚 │ 2 │ 5Gbps │ 美东出口 │
├──────────────┼──────────┼────────────┼──────────┼──────────────────┤
│ 欧洲 │ 法兰克福 │ 2 │ 5Gbps │ 欧洲接入 │
│ │ 伦敦 │ 2 │ 5Gbps │ 英国出口 │
│ │ 阿姆斯特丹│ 1 │ 2Gbps │ 欧洲中转 │
├──────────────┼──────────┼────────────┼──────────┼──────────────────┤
│ 合计 │ │ 31 │ │ │
└──────────────┴──────────┴────────────┴──────────┴──────────────────┘
```
## 3.3 节点部署方案
### 3.3.1 云服务器方案
```
┌──────────────┬────────────┬────────────┬────────────┬──────────────┐
│ 云服务商 │ 适用场景 │ 优势 │ 劣势 │ 月成本(单节点)│
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ 阿里云 │ 国内接入 │ 节点多 │ 带宽贵 │ ¥3000-8000 │
│ │ BGP接入 │ 稳定性好 │ │ (5Mbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ 腾讯云 │ 国内接入 │ 游戏优化 │ 海外节点少 │ ¥3000-8000 │
│ │ 游戏加速 │ 专线资源 │ │ (5Mbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ 华为云 │ 国内+海外 │ 全球布局 │ 价格较高 │ ¥4000-10000 │
│ │ │ 专线资源 │ │ (5Mbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ AWS │ 海外节点 │ 全球覆盖 │ 国内差 │ $200-500 │
│ │ │ 弹性伸缩 │ │ (5Mbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ GCP │ 海外节点 │ 网络质量好 │ 国内差 │ $200-500 │
│ │ │ 全球网络 │ │ (5Mbps) │
└──────────────┴────────────┴────────────┴────────────┴──────────────┘
```
### 3.3.2 裸金属方案
```
┌──────────────┬────────────┬────────────┬────────────┬──────────────┐
│ IDC/服务商 │ 适用场景 │ 优势 │ 劣势 │ 月成本(单节点)│
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ UCloud │ 国内BGP │ 性价比高 │ 节点少 │ ¥2000-5000 │
│ │ 游戏加速 │ 游戏优化 │ │ (10Gbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ Vultr │ 海外节点 │ 按时计费 │ 国内没有 │ $100-300 │
│ │ │ 全球30+ │ │ (1Gbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ Hetzner │ 欧洲节点 │ 性价比极高 │ 只有欧洲 │ €50-150 │
│ │ │ 带宽大 │ │ (1Gbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ OVH │ 欧洲+北美 │ DDoS防护 │ 客服差 │ €100-300 │
│ │ │ 带宽大 │ │ (1Gbps) │
├──────────────┼────────────┼────────────┼────────────┼──────────────┤
│ 自建IDC │ 核心节点 │ 完全控制 │ 成本高 │ ¥10000+ │
│ │ 中转节点 │ 定制化 │ 运维复杂 │ (10Gbps) │
└──────────────┴────────────┴────────────┴────────────┴──────────────┘
```
### 3.3.3 成本分析
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 节点成本预算 (月度) │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 国内节点 (30个)： │
│ ┌──────────┬──────────┬──────────┬──────────┬──────────┐ │
│ │ 类型 │ 数量 │ 单价/月 │ 总价/月 │ 带宽 │ │
│ ├──────────┼──────────┼──────────┼──────────┼──────────┤ │
│ │ 接入节点 │ 25 │ ¥3,000 │ ¥75,000 │ 5Gbps │ │
│ │ 中转节点 │ 5 │ ¥8,000 │ ¥40,000 │ 10Gbps │ │
│ │ 小计 │ 30 │ │ ¥115,000 │ │ │
│ └──────────┴──────────┴──────────┴──────────┴──────────┘ │
│ │
│ 海外节点 (31个)： │
│ ┌──────────┬──────────┬──────────┬──────────┬──────────┐ │
│ │ 类型 │ 数量 │ 单价/月 │ 总价/月 │ 带宽 │ │
│ ├──────────┼──────────┼──────────┼──────────┼──────────┤ │
│ │ 接入节点 │ 15 │ $200 │ $3,000 │ 2Gbps │ │
│ │ 中转节点 │ 6 │ $500 │ $3,000 │ 5Gbps │ │
│ │ 出口节点 │ 10 │ $300 │ $3,000 │ 3Gbps │ │
│ │ 小计 │ 31 │ │ $9,000 │ │ │
│ └──────────┴──────────┴──────────┴──────────┴──────────┘ │
│ │
│ 专线费用： │
│ ┌──────────────────────┬──────────┬──────────┐ │
│ │ 线路 │ 月租 │ 说明 │ │
│ ├──────────────────────┼──────────┼──────────┤ │
│ │ CN2 GT (上海←→北京) │ ¥5,000 │ 100Mbps │ │
│ │ CN2 GT (上海←→广州) │ ¥5,000 │ 100Mbps │ │
│ │ AS9929 (国内核心) │ ¥8,000 │ 200Mbps │ │
│ │ 国际专线 (上海←→东京)│ ¥15,000 │ 100Mbps │ │
│ │ 国际专线 (香港←→LA) │ ¥20,000 │ 100Mbps │ │
│ │ 小计 │ ¥53,000 │ │ │
│ └──────────────────────┴──────────┴──────────┘ │
│ │
│ 月度总成本： │
│ 国内节点: ¥115,000 │
│ 海外节点: ¥65,000 (按$1=¥7.2计算) │
│ 专线费用: ¥53,000 │
│ 其他(域名/CDN/证书): ¥5,000 │
│ ───────────────────────── │
│ 总计: ¥238,000/月 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/04-流量转发系统设计.md
+641
View File
@@ -0,0 +1,641 @@
# 第四部分：流量转发系统设计
## 4.1 MVP阶段 — UDP Relay
### 4.1.1 协议设计
```
┌──────────────────────────────────────────────────────────────────┐
│ UDP Relay 协议报文结构 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 报文头 (16字节): │
│ ┌────────┬────────┬────────┬────────┬────────┬────────┐ │
│ │ Magic │ Version│ Type │ Flags │ SeqNum │ Length │ │
│ │ 2B │ 1B │ 1B │ 1B │ 4B │ 4B │ │
│ │ 0xACE0 │ 0x01 │ │ │ │ │ │
│ └────────┴────────┴────────┴────────┴────────┴────────┘ │
│ │
│ 字段说明： │
│ ┌──────────┬──────────┬────────────────────────────────────┐ │
│ │ 字段 │ 大小 │ 说明 │ │
│ ├──────────┼──────────┼────────────────────────────────────┤ │
│ │ Magic │ 2 bytes │ 魔数 0xACE0，用于识别协议 │ │
│ │ Version │ 1 byte │ 协议版本号（当前0x01） │ │
│ │ Type │ 1 byte │ 报文类型 │ │
│ │ │ │ 0x01=DATA, 0x02=ACK, 0x03=HEARTBEAT │ │
│ │ │ │ 0x04=CONTROL, 0x05=FEC │ │
│ │ Flags │ 1 byte │ 标志位 │ │
│ │ │ │ bit0: 加密 │ │
│ │ │ │ bit1: 压缩 │ │
│ │ │ │ bit2: FEC │ │
│ │ │ │ bit3: 重传 │ │
│ │ │ │ bit4-7: 保留 │ │
│ │ SeqNum │ 4 bytes │ 序列号（用于乱序检测和重传） │ │
│ │ Length │ 4 bytes │ 载荷长度 │ │
│ └──────────┴──────────┴────────────────────────────────────┘ │
│ │
│ 扩展头（可选，当Flags中有加密/压缩时）： │
│ ┌────────┬────────┬────────┬────────┬────────┐ │
│ │ ExtLen │ ExtType│ IV │ Padding│ HMAC │ │
│ │ 1B │ 1B │ 12B │ 可变 │ 16B │ │
│ └────────┴────────┴────────┴────────┴────────┘ │
│ │
│ 完整报文： │
│ ┌────────────┬────────────┬────────────┬────────────┐ │
│ │ 报文头 │ 扩展头 │ 加密载荷 │ HMAC校验 │ │
│ │ 16B │ 可变 │ 可变 │ 16B │ │
│ └────────────┴────────────┴────────────┴────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.1.2 数据流转时序图
```
┌──────────────────────────────────────────────────────────────────┐
│ UDP Relay 数据流时序图 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 玩家客户端 接入节点 中转节点 游戏服务器│
│ │ │ │ │ │
│ │ 1.游戏UDP包 │ │ │ │
│ │─────────────────→│ │ │ │
│ │ │ │ │ │
│ │ │ 2.封装为 │ │ │
│ │ │ Relay包 │ │ │
│ │ │ (加序列号) │ │ │
│ │ │ │ │ │
│ │ │ 3.加密+转发 │ │ │
│ │ │───────────────→│ │ │
│ │ │ │ │ │
│ │ │ │ 4.解密+解封装 │ │
│ │ │ │ │ │
│ │ │ │ 5.转发原始包 │ │
│ │ │ │─────────────────→│ │
│ │ │ │ │ │
│ │ │ │ 6.游戏响应 │ │
│ │ │ │←─────────────────│ │
│ │ │ │ │ │
│ │ │ 7.封装+加密 │ │ │
│ │ │←───────────────│ │ │
│ │ │ │ │ │
│ │ 8.解密+解封装 │ │ │ │
│ │←─────────────────│ │ │ │
│ │ │ │ │ │
│ │ 9.返回游戏 │ │ │ │
│ │ │ │ │ │
│ │
│ 总延迟增加：2-10ms（取决于节点间距离） │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.1.3 伪代码实现
```go
// UDP Relay 核心转发逻辑
package relay
import (
"crypto/aes"
"crypto/cipher"
"encoding/binary"
"net"
"sync"
"time"
)
// 协议常量
const (
Magic = 0xACE0
Version = 0x01
TypeDATA = 0x01
TypeACK = 0x02
TypeHEART = 0x03
TypeCONTROL = 0x04
TypeFEC = 0x05
HeaderSize = 16
)
// RelayHeader 报文头
type RelayHeader struct {
Magic uint16
Version uint8
Type uint8
Flags uint8
SeqNum uint32
Length uint32
}
// Session 会话状态
type Session struct {
SessionID uint64
ClientAddr *net.UDPAddr
ServerAddr *net.UDPAddr
SendSeq uint32
RecvSeq uint32
AESKey []byte
LastActive time.Time
RTT time.Duration
LossRate float64
mu sync.Mutex
}
// RelayServer 转发服务器
type RelayServer struct {
listenAddr *net.UDPAddr
conn *net.UDPConn
sessions sync.Map // map[uint64]*Session
aesGCM cipher.AEAD
}
// Start 启动转发服务
func (s *RelayServer) Start() error {
conn, err := net.ListenUDP("udp4", s.listenAddr)
if err != nil {
return err
}
s.conn = conn
buf := make([]byte, 65535)
for {
n, clientAddr, err := conn.ReadFromUDP(buf)
if err != nil {
continue
}
go s.handlePacket(buf[:n], clientAddr)
}
}
// handlePacket 处理收到的包
func (s *RelayServer) handlePacket(data []byte, clientAddr *net.UDPAddr) {
// 解析报文头
if len(data) < HeaderSize {
return
}
header := parseHeader(data[:HeaderSize])
if header.Magic != Magic {
return
}
switch header.Type {
case TypeDATA:
s.handleData(header, data[HeaderSize:], clientAddr)
case TypeHEART:
s.handleHeartbeat(header, clientAddr)
case TypeACK:
s.handleACK(header, clientAddr)
}
}
// handleData 处理数据包
func (s *RelayServer) handleData(header RelayHeader, payload []byte, clientAddr *net.UDPAddr) {
// 获取或创建会话
session := s.getOrCreateSession(clientAddr)
// 解密载荷
plaintext, err := s.decrypt(payload, session.AESKey)
if err != nil {
return
}
// 更新序列号
session.mu.Lock()
session.RecvSeq = header.SeqNum
session.LastActive = time.Now()
session.mu.Unlock()
// 转发到游戏服务器
_, err = s.conn.WriteToUDP(plaintext, session.ServerAddr)
if err != nil {
// 记录错误，触发重连
s.handleForwardError(session, err)
}
// 发送ACK（如果需要可靠传输）
if header.Flags&0x01 != 0 {
s.sendACK(session, header.SeqNum)
}
}
// handleHeartbeat 处理心跳
func (s *RelayServer) handleHeartbeat(header RelayHeader, clientAddr *net.UDPAddr) {
session := s.getSession(clientAddr)
if session == nil {
return
}
session.mu.Lock()
session.LastActive = time.Now()
// 计算RTT（心跳包中有时间戳）
session.mu.Unlock()
// 回复心跳
s.sendHeartbeatReply(session)
}
// ForwardLoop 转发循环（从游戏服务器到客户端）
func (s *RelayServer) ForwardLoop(session *Session) {
buf := make([]byte, 65535)
for {
n, err := session.ServerConn.Read(buf)
if err != nil {
break
}
// 加密
ciphertext := s.encrypt(buf[:n], session.AESKey)
// 封装
header := RelayHeader{
Magic: Magic,
Version: Version,
Type: TypeDATA,
SeqNum: session.SendSeq,
Length: uint32(len(ciphertext)),
}
session.mu.Lock()
session.SendSeq++
session.mu.Unlock()
// 发送
packet := append(header.Bytes(), ciphertext...)
s.conn.WriteToUDP(packet, session.ClientAddr)
}
}
// encrypt AES-256-GCM加密
func (s *RelayServer) encrypt(plaintext []byte, key []byte) []byte {
block, _ := aes.NewCipher(key)
gcm, _ := cipher.NewGCM(block)
nonce := make([]byte, gcm.NonceSize())
// 生成随机nonce
return gcm.Seal(nil, nonce, plaintext, nil)
}
// CheckSessionTimeout 会话超时检查
func (s *RelayServer) CheckSessionTimeout() {
ticker := time.NewTicker(10 * time.Second)
for range ticker.C {
s.sessions.Range(func(key, value interface{}) bool {
session := value.(*Session)
if time.Since(session.LastActive) > 60*time.Second {
// 会话超时，清理
s.sessions.Delete(key)
session.Close()
}
return true
})
}
}
```
## 4.2 商业版阶段 — QUIC Tunnel
### 4.2.1 为什么选择QUIC
```
┌──────────────────────────────────────────────────────────────────┐
│ QUIC vs UDP Relay vs TCP │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 特性 │ UDP Relay │ QUIC │ TCP │
│ ──────────────┼───────────┼────────────┼──────────── │
│ 连接建立延迟 │ 0-RTT │ 0-RTT │ 3-RTT (TLS) │
│ 多路复用 │ ✗ │ ✓ │ ✗ (HOL阻塞) │
│ 可靠传输 │ 可选 │ 可选 │ 必须 │
│ 流量控制 │ 手动 │ 内置 │ 内置 │
│ 拥塞控制 │ 手动 │ BBR/Cubic │ Cubic │
│ 连接迁移 │ 手动 │ 内置 │ ✗ │
│ 加密 │ 手动 │ 内置(TLS1.3)│ 需要TLS │
│ 前向纠错 │ 手动 │ 可扩展 │ ✗ │
│ 多路径 │ 手动 │ 扩展中 │ MPTCP │
│ ──────────────┼───────────┼────────────┼──────────── │
│ 适合场景 │ 简单转发 │ 游戏加速 │ 文件传输 │
│ │
│ 结论：QUIC是最优选择 │
│ - 0-RTT连接建立（快速切换节点） │
│ - 多路复用无HOL阻塞（多游戏流量并行） │
│ - 内置加密（安全性） │
│ - 连接迁移（IP变化不断线） │
│ - 可扩展（加FEC、多路径） │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.2.2 QUIC Tunnel协议设计
```
┌──────────────────────────────────────────────────────────────────┐
│ QUIC Tunnel 架构 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 应用层 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Stream 0│ │ Stream 1│ │ Stream 2│ │ Stream N│ │ │
│ │ │ 游戏数据│ │ 控制流 │ │ 心跳流 │ │ 其他 │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ QUIC层 │ │
│ │ ┌──────────────────────────────────────────────────┐ │ │
│ │ │ QUIC Frames: │ │ │
│ │ │ - STREAM (数据帧) │ │ │
│ │ │ - ACK (确认帧) │ │ │
│ │ │ - CRYPTO (加密握手) │ │ │
│ │ │ - PADDING (填充) │ │ │
│ │ │ - CONNECTION_CLOSE (关闭) │ │ │
│ │ │ - FEC (前向纠错，自定义扩展) │ │ │
│ │ └──────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ TLS 1.3层 │ │
│ │ ┌──────────────────────────────────────────────────┐ │ │
│ │ │ - 握手加密 │ │ │
│ │ │ - 会话密钥轮换 │ │ │
│ │ │ - 证书验证 │ │ │
│ │ └──────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ UDP层 │ │
│ │ ┌──────────────────────────────────────────────────┐ │ │
│ │ │ - UDP Socket │ │ │
│ │ │ - BBR拥塞控制 │ │ │
│ │ │ - 多路径支持 │ │ │
│ │ └──────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.2.3 Multipath多路径传输
```
┌──────────────────────────────────────────────────────────────────┐
│ Multipath 多路径设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────┐ ┌────────┐ │
│ │ │──── Path 1 (联通) ───→ │ │
│ │ 客户端 │──── Path 2 (电信) ───→ 接入节点│──→ 游戏服务器 │
│ │ │──── Path 3 (移动) ───→ │ │
│ └────────┘ └────────┘ │
│ │
│ 路径管理： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ PathTable: │ │
│ │ ┌─────────┬────────┬────────┬────────┬────────┐ │ │
│ │ │ PathID │ RTT │ Loss │ Bw │ Weight │ │ │
│ │ ├─────────┼────────┼────────┼────────┼────────┤ │ │
│ │ │ path-1 │ 30ms │ 0.1% │ 50Mbps │ 0.5 │ │ │
│ │ │ path-2 │ 45ms │ 0.5% │ 30Mbps │ 0.3 │ │ │
│ │ │ path-3 │ 60ms │ 1.0% │ 20Mbps │ 0.2 │ │ │
│ │ └─────────┴────────┴────────┴────────┴────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 数据分配策略： │
│ 1. 关键数据（游戏动作）→ 走最优路径（path-1） │
│ 2. 状态数据（位置同步）→ 分散到多路径 │
│ 3. 冗余数据（FEC）→ 走次优路径 │
│ 4. 实时监控路径质量，动态调整权重 │
│ │
│ 路径切换： │
│ - 主路径故障 → 无缝切换到备用路径 │
│ - 切换延迟 < 100ms │
│ - 连接保持（Session ID不变） │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.2.4 FEC前向纠错
```
┌──────────────────────────────────────────────────────────────────┐
│ FEC前向纠错设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 原理：发送N个数据包 + K个冗余包，丢任意K个包都能恢复 │
│ │
│ 编码方式：Reed-Solomon码 │
│ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 示例：RS(10,4) — 10个数据包 + 4个冗余包 │ │
│ │ │ │
│ │ 发送端： │ │
│ │ D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 ← 数据包 │ │
│ │ P1 P2 P3 P4 ← 冗余包(校验包) │ │
│ │ ───────────────────────────────── │ │
│ │ 共14个包，允许丢4个包 │ │
│ │ │ │
│ │ 接收端（假设D2,D5,D8,P2丢失）： │ │
│ │ D1 ✗ D3 D4 ✗ D6 D7 ✗ D9 D10 │ │
│ │ ✗ P3 P4 │ │
│ │ ───────────────────────────────── │ │
│ │ 通过RS解码恢复D2,D5,D8,P2 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 动态FEC参数调整： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 丢包率 │ FEC比例 │ 说明 │ │
│ ├─────────────┼────────────┼──────────────────────────────│ │
│ │ < 1% │ N=10, K=1 │ 低冗余，节省带宽 │ │
│ │ 1% - 5% │ N=10, K=2 │ 中等冗余 │ │
│ │ 5% - 10% │ N=10, K=3 │ 高冗余 │ │
│ │ > 10% │ N=10, K=4 │ 最大冗余，保护关键数据 │ │
│ │ > 20% │ 切换路径 │ 丢包太严重，切换链路 │ │
│ └─────────────┴────────────┴──────────────────────────────┘ │
│ │
│ 实现代码（Go）： │
│ │
│ type FECEncoder struct { │
│ dataShards int // 数据分片数 │
│ parityShards int // 冗余分片数 │
│ enc reedsolomon.Encoder │
│ } │
│ │
│ func (f *FECEncoder) Encode(data []byte) [][]byte { │
│ // 将数据分割为dataShards个分片 │
│ shards := f.splitData(data, f.dataShards) │
│ // 生成parityShards个冗余分片 │
│ err := f.enc.Encode(shards) │
│ // 返回所有分片（数据+冗余） │
│ return shards │
│ } │
│ │
│ func (f *FECEncoder) Decode(shards [][]byte) ([]byte, error) { │
│ // 通过RS解码恢复丢失的分片 │
│ err := f.enc.Reconstruct(shards) │
│ // 合并分片为原始数据 │
│ return f.mergeShards(shards[:f.dataShards]), err │
│ } │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.2.5 动态拥塞控制
```
┌──────────────────────────────────────────────────────────────────┐
│ 动态拥塞控制设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 目标：在不丢包的前提下，最大化利用带宽 │
│ │
│ 算法选择：BBR (Bottleneck Bandwidth and Round-trip) │
│ │
│ BBR工作原理： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 测量瓶颈带宽 (BtlBw) │ │
│ │ - 跟踪最大交付速率 │ │
│ │ - 滑动窗口取最大值 │ │
│ │ │ │
│ │ 2. 测量最小RTT (RTprop) │ │
│ │ - 跟踪最小往返时间 │ │
│ │ - 10秒窗口取最小值 │ │
│ │ │ │
│ │ 3. 计算发送速率 │ │
│ │ cwnd = BtlBw × RTprop × gain │ │
│ │ pacing_rate = BtlBw × gain │ │
│ │ │ │
│ │ 4. 四个阶段循环： │ │
│ │ Startup → Drain → ProbeBW → ProbeRTT │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 游戏场景优化： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 1. 低延迟优先 │ │
│ │ - 限制最大cwnd，避免缓冲区膨胀 │ │
│ │ - pacing_rate不超过实际带宽的80% │ │
│ │ │ │
│ │ 2. 快速恢复 │ │
│ │ - 丢包时快速降低发送速率 │ │
│ │ - 恢复时快速提升（比标准BBR更快） │ │
│ │ │ │
│ │ 3. 多流公平 │ │
│ │ - 多个游戏流共享带宽时公平分配 │ │
│ │ - 优先级流获得更多带宽 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.2.6 UDP重传优化
```
┌──────────────────────────────────────────────────────────────────┐
│ UDP重传优化设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 问题：标准UDP不重传，丢包就丢了 │
│ 方案：选择性重传 + 优先级重传 │
│ │
│ 数据分类： │
│ ┌──────────┬────────────────┬────────────┬──────────────┐ │
│ │ 优先级 │ 数据类型 │ 重传策略 │ 超时时间 │ │
│ ├──────────┼────────────────┼────────────┼──────────────┤ │
│ │ P0 │ 玩家操作指令 │ 必须重传 │ 50ms │ │
│ │ P1 │ 游戏状态同步 │ 选择重传 │ 100ms │ │
│ │ P2 │ 位置更新 │ 不重传 │ - │ │
│ │ P3 │ 视觉效果数据 │ 不重传 │ - │ │
│ └──────────┴────────────────┴────────────┴──────────────┘ │
│ │
│ 重传流程： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 发送端: │ │
│ │ 1. 发送数据包，记录发送时间 │ │
│ │ 2. 等待ACK │ │
│ │ 3. 超时未收到ACK → 检查优先级 │ │
│ │ 4. P0/P1 → 立即重传 │ │
│ │ 5. P2/P3 → 放弃，等新数据 │ │
│ │ │ │
│ │ 接收端: │ │
│ │ 1. 收到数据包 → 发送ACK │ │
│ │ 2. 检测到序列号跳跃 → 发送NACK（选择性否定确认） │ │
│ │ 3. 乱序到达 → 缓存并重排序（10ms窗口） │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 伪代码： │
│ │
│ type RetransmitQueue struct { │
│ pending map[uint32]*Packet │
│ mu sync.Mutex │
│ } │
│ │
│ func (q *RetransmitQueue) Add(pkt *Packet) { │
│ q.mu.Lock() │
│ defer q.mu.Unlock() │
│ pkt.SendTime = time.Now() │
│ q.pending[pkt.SeqNum] = pkt │
│ } │
│ │
│ func (q *RetransmitQueue) CheckTimeout() []*Packet { │
│ q.mu.Lock() │
│ defer q.mu.Unlock() │
│ var retransmit []*Packet │
│ now := time.Now() │
│ for seq, pkt := range q.pending { │
│ if now.Sub(pkt.SendTime) > pkt.Timeout { │
│ if pkt.Priority <= P1 { │
│ retransmit = append(retransmit, pkt) │
│ pkt.SendTime = now │
│ pkt.RetransmitCount++ │
│ } else { │
│ delete(q.pending, seq) │
│ } │
│ } │
│ } │
│ return retransmit │
│ } │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 4.2.7 智能链路切换
```
┌──────────────────────────────────────────────────────────────────┐
│ 智能链路切换设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 切换触发条件： │
│ 1. 当前链路延迟 > 最优链路延迟 × 1.5 │
│ 2. 当前链路丢包率 > 5% │
│ 3. 连续3次探测质量下降 │
│ 4. 当前链路断开 │
│ │
│ 切换流程： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 探测新 │───→│ 建立新 │───→│ 迁移会话 │ │ │
│ │ │ 链路质量 │ │ 连接 │ │ 状态 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────────────┘ │ │
│ │ │ ↓ │ │
│ │ │ ┌──────────┐ ┌──────────┐ │ │
│ │ │ │ 切换流量 │───→│ 关闭旧 │ │ │
│ │ │ │ 到新链路 │ │ 连接 │ │ │
│ │ │ └──────────┘ └──────────┘ │ │
│ │ │ │ │
│ │ └─── 整个过程 < 200ms，用户无感知 │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 会话保持： │
│ - 使用SessionID标识会话 │
│ - 切换时携带SessionID到新链路 │
│ - 新链路通过SessionID恢复会话状态 │
│ - 序列号连续（不因切换而重置） │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/05-客户端开发方案.md
+720
View File
@@ -0,0 +1,720 @@
# 第五部分：客户端开发方案
## 5.1 Windows客户端（优先）
### 5.1.1 网络驱动方案对比
```
┌──────────────────────────────────────────────────────────────────────────────┐
│ Windows 网络驱动方案对比 │
├──────────────┬──────────────┬──────────────┬──────────────┬─────────────────┤
│ 方案 │ WFP │ WinDivert │ TUN/TAP │ NDIS Filter │
├──────────────┼──────────────┼──────────────┼──────────────┼─────────────────┤
│ 层级 │ 内核态 │ 用户态 │ 用户态 │ 内核态 │
│ 兼容性 │ Win7+ │ Win7+ │ 全平台 │ Win7+ │
│ 性能 │ ★★★★★ │ ★★★★ │ ★★★ │ ★★★★ │
│ 稳定性 │ ★★★★★ │ ★★★★ │ ★★★ │ ★★★ │
│ 进程过滤 │ ✓ │ ✓ │ ✗ │ ✗ │
│ IP/端口过滤 │ ✓ │ ✓ │ ✓ │ ✓ │
│ 协议过滤 │ ✓ │ ✓ │ ✗ │ ✓ │
│ 驱动签名 │ 需要 │ 需要 │ 需要 │ 需要 │
│ 开发难度 │ 高 │ 中 │ 低 │ 高 │
│ 微软官方 │ ✓ │ ✗(第三方) │ ✗ │ ✓ │
│ 蓝屏风险 │ 低 │ 低 │ 无 │ 中 │
├──────────────┼──────────────┼──────────────┼──────────────┼─────────────────┤
│ 推荐度 │ ★★★★★ │ ★★★★ │ ★★★ │ ★★★ │
├──────────────┴──────────────┴──────────────┴──────────────┴─────────────────┤
│ │
│ ★ 推荐方案：WFP (Windows Filtering Platform) │
│ │
│ 理由： │
│ 1. 微软官方支持，Win7-Win11全系列 │
│ 2. 内核态过滤，性能最优 │
│ 3. 支持按进程PID过滤（核心需求） │
│ 4. 支持ALE层（应用层强制）和传输层过滤 │
│ 5. 稳定性最高，蓝屏风险最低 │
│ 6. 支持Win10/11的Modern Standby │
│ │
│ 备选方案：WinDivert（开发阶段快速原型验证） │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
```
### 5.1.2 WFP驱动架构详细设计
```
┌──────────────────────────────────────────────────────────────────┐
│ WFP Callout Driver 架构 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ 用户态 (Ring 3) │ │
│ │ ┌──────────────────────────────────────────────────┐ │ │
│ │ │ Accelerator Client Process │ │ │
│ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │
│ │ │ │ 流量管理 │ │ 隧道引擎 │ │ 策略引擎 │ │ │ │
│ │ │ │ Engine │ │ Tunnel │ │ Policy │ │ │ │
│ │ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │
│ │ │ └──────────────┴──────────────┘ │ │ │
│ │ │ │ │ │ │
│ │ │ DeviceIoControl │ │ │
│ │ │ │ │ │ │
│ │ │ ┌──────────────────────────────────────────┐ │ │ │
│ │ │ │ WFP Control Interface │ │ │ │
│ │ │ │ - 添加/删除过滤规则 │ │ │ │
│ │ │ │ - 获取流量统计 │ │ │ │
│ │ │ │ - 配置驱动参数 │ │ │ │
│ │ │ └──────────────────────────────────────────┘ │ │ │
│ │ └──────────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ 内核态 (Ring 0) │ │
│ │ ┌──────────────────────────────────────────────────┐ │ │
│ │ │ WFP Callout Driver (.sys) │ │ │
│ │ │ │ │ │
│ │ │ ┌────────────────────────────────────────────┐ │ │ │
│ │ │ │ ALE Layer (Application Layer Enforcement) │ │ │ │
│ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │
│ │ │ │ │ ALE_AUTH_CONNECT_V4 │ │ │ │ │
│ │ │ │ │ - 拦截出站连接请求 │ │ │ │ │
│ │ │ │ │ - 获取进程PID、目标IP、端口 │ │ │ │ │
│ │ │ │ │ - 查询策略：是否需要加速 │ │ │ │ │
│ │ │ │ │ - 决定：放行(FWP_ACTION_PERMIT) │ │ │ │ │
│ │ │ │ │ 拦截(FWP_ACTION_BLOCK) │ │ │ │ │
│ │ │ │ │ 重定向(修改目标地址) │ │ │ │ │
│ │ │ │ └──────────────────────────────────────┘ │ │ │ │
│ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │
│ │ │ │ │ ALE_AUTH_RECV_ACCEPT_V4 │ │ │ │ │
│ │ │ │ │ - 拦截入站连接请求 │ │ │ │ │
│ │ │ │ │ - 用于P2P游戏场景 │ │ │ │ │
│ │ │ │ └──────────────────────────────────────┘ │ │ │ │
│ │ │ └────────────────────────────────────────────┘ │ │ │
│ │ │ │ │ │
│ │ │ ┌────────────────────────────────────────────┐ │ │ │
│ │ │ │ Transport Layer │ │ │ │
│ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │
│ │ │ │ │ OUTBOUND_TRANSPORT_V4 │ │ │ │ │
│ │ │ │ │ - 出站数据包级别过滤 │ │ │ │ │
│ │ │ │ │ - 修改目标地址（重定向到隧道） │ │ │ │ │
│ │ │ │ │ - 添加标记用于回程识别 │ │ │ │ │
│ │ │ │ └──────────────────────────────────────┘ │ │ │ │
│ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │
│ │ │ │ │ INBOUND_TRANSPORT_V4 │ │ │ │ │
│ │ │ │ │ - 入站数据包过滤 │ │ │ │ │
│ │ │ │ │ - 识别隧道回程包并还原 │ │ │ │ │
│ │ │ │ └──────────────────────────────────────┘ │ │ │ │
│ │ │ └────────────────────────────────────────────┘ │ │ │
│ │ │ │ │ │
│ │ │ ┌────────────────────────────────────────────┐ │ │ │
│ │ │ │ Network Layer │ │ │ │
│ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │
│ │ │ │ │ IP_PACKET_V4 │ │ │ │ │
│ │ │ │ │ - 数据包级别统计 │ │ │ │ │
│ │ │ │ │ - 流量计数 │ │ │ │ │
│ │ │ │ └──────────────────────────────────────┘ │ │ │ │
│ │ │ └────────────────────────────────────────────┘ │ │ │
│ │ │ │ │ │
│ │ │ ┌────────────────────────────────────────────┐ │ │ │
│ │ │ │ 数据结构 │ │ │ │
│ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │
│ │ │ │ │ FilterRule { │ │ │ │ │
│ │ │ │ │ ProcessId uint32 │ │ │ │ │
│ │ │ │ │ DestIP net.IP │ │ │ │ │
│ │ │ │ │ DestPort uint16 │ │ │ │ │
│ │ │ │ │ Protocol uint8 // TCP/UDP │ │ │ │ │
│ │ │ │ │ Action uint8 // Permit/Block │ │ │ │ │
│ │ │ │ │ TunnelType uint8 // UDP/QUIC │ │ │ │ │
│ │ │ │ │ NodeID string // 目标节点 │ │ │ │ │
│ │ │ │ │ } │ │ │ │ │
│ │ │ │ └──────────────────────────────────────┘ │ │ │ │
│ │ │ └────────────────────────────────────────────┘ │ │ │
│ │ └──────────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 5.1.3 游戏流量识别
```
┌──────────────────────────────────────────────────────────────────┐
│ 游戏流量识别方案 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 识别维度： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 1. 进程识别（最可靠） │ │
│ │ - 获取进程PID │ │
│ │ - 查询进程路径 │ │
│ │ - 匹配游戏配置库 │ │
│ │ 示例： │ │
│ │ PID=1234 → C:\Genshin Impact\GenshinImpact.exe │ │
│ │ → 匹配为"原神" │ │
│ │ │ │
│ │ 2. IP识别（精准） │ │
│ │ - 维护游戏服务器IP列表 │ │
│ │ - 查询目标IP是否属于某游戏 │ │
│ │ 示例： │ │
│ │ 目标IP=47.245.x.x → 属于"原神亚服" │ │
│ │ │ │
│ │ 3. 域名识别（灵活） │ │
│ │ - DNS请求拦截 │ │
│ │ - 查询域名是否属于某游戏 │ │
│ │ 示例： │ │
│ │ 域名=*.mihoyo.com → 属于"原神" │ │
│ │ │ │
│ │ 4. 端口识别（辅助） │ │
│ │ - 特定端口通常对应特定游戏 │ │
│ │ 示例： │ │
│ │ 端口27015-27030 → 可能是Steam游戏 │ │
│ │ │ │
│ │ 5. 协议特征识别（深度包检测） │ │
│ │ - 分析数据包载荷特征 │ │
│ │ - 匹配已知游戏协议 │ │
│ │ 示例： │ │
│ │ 前4字节=0x01020304 → "某某游戏"协议头 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 识别优先级：进程 > IP > 域名 > 端口 > 协议特征 │
│ │
│ 游戏配置数据库结构： │
│ │
│ // GameConfig 游戏配置 │
│ { │
│ "game_id": "genshin_impact", │
│ "name": "原神", │
│ "icon": "genshin.png", │
│ "category": "mmorpg", │
│ "process_names": [ │
│ "GenshinImpact.exe", │
│ "YuanShen.exe" │
│ ], │
│ "install_paths": [ │
│ "C:\\Program Files\\Genshin Impact\\", │
│ "D:\\Games\\Genshin Impact\\" │
│ ], │
│ "servers": [ │
│ { │
│ "name": "亚服", │
│ "region": "asia", │
│ "ip_ranges": [ │
│ "47.245.0.0/16", │
│ "8.219.0.0/16" │
│ ], │
│ "domains": [ │
│ "*.mihoyo.com", │
│ "*.hoyoverse.com" │
│ ], │
│ "ports": [443, 80, 22102], │
│ "protocol": "tcp+udp" │
│ }, │
│ { │
│ "name": "美服", │
│ "region": "america", │
│ "ip_ranges": ["47.252.0.0/16"], │
│ "ports": [443, 80, 22102], │
│ "protocol": "tcp+udp" │
│ } │
│ ], │
│ "capture_mode": "process_ip", │
│ "tunnel_mode": "udp_relay", │
│ "priority": "high", │
│ "qos_class": "realtime" │
│ } │
│ │
│ // ServerConfig 服务器配置 │
│ { │
│ "server_id": "asia_01", │
│ "game_id": "genshin_impact", │
│ "name": "亚服-东京", │
│ "ip": "47.245.1.1", │
│ "port": 22102, │
│ "protocol": "udp", │
│ "location": {"lat": 35.6762, "lng": 139.6503}, │
│ "isp": "softbank" │
│ } │
│ │
│ // RouteConfig 路由配置 │
│ { │
│ "route_id": "genshin_asia_route_01", │
│ "game_id": "genshin_impact", │
│ "source_region": "china_north", │
│ "dest_region": "japan", │
│ "access_node": "cn-bj-01", │
│ "relay_nodes": ["cn-sh-01", "hk-01"], │
│ "exit_node": "jp-tokyo-01", │
│ "protocol": "quic", │
│ "fec_level": 2, │
│ "priority": "high" │
│ } │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 5.2 自动选路系统
### 5.2.1 测速算法
```
┌──────────────────────────────────────────────────────────────────┐
│ 测速算法详细设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 1. 延迟测试（RTT） │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 算法：UDP Ping │ │
│ │ │ │
│ │ 输入：目标节点IP、端口 │ │
│ │ 输出：RTT（毫秒） │ │
│ │ │ │
│ │ 步骤： │ │
│ │ 1. 发送UDP探测包（带时间戳） │ │
│ │ 2. 等待回复 │ │
│ │ 3. 计算 RTT = 收到时间 - 发送时间 │ │
│ │ 4. 连续发送10个包，间隔100ms │ │
│ │ 5. 去除最高和最低值，取平均 │ │
│ │ │ │
│ │ 伪代码： │ │
│ │ func measureRTT(node string) float64 { │ │
│ │ var rtts []float64 │ │
│ │ for i := 0; i < 10; i++ { │ │
│ │ start := time.Now() │ │
│ │ sendUDPPing(node) │ │
│ │ waitPong() │ │
│ │ rtt := time.Since(start).Milliseconds() │ │
│ │ rtts = append(rtts, float64(rtt)) │ │
│ │ time.Sleep(100 * time.Millisecond) │ │
│ │ } │ │
│ │ sort.Float64s(rtts) │ │
│ │ // 去除最高最低，取平均 │ │
│ │ return average(rtts[1:9]) │ │
│ │ } │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 2. 丢包率测试 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 算法：统计法 │ │
│ │ │ │
│ │ 步骤： │ │
│ │ 1. 发送20个UDP包，间隔50ms │ │
│ │ 2. 等待2秒收集回复 │ │
│ │ 3. 统计收到的回复数 │ │
│ │ 4. 丢包率 = (20 - 回复数) / 20 │ │
│ │ 5. 重复3轮，取平均 │ │
│ │ │ │
│ │ 伪代码： │ │
│ │ func measureLoss(node string) float64 { │ │
│ │ var losses []float64 │ │
│ │ for round := 0; round < 3; round++ { │ │
│ │ sent := 20 │ │
│ │ received := 0 │ │
│ │ for i := 0; i < sent; i++ { │ │
│ │ sendUDPPing(node) │ │
│ │ time.Sleep(50 * time.Millisecond) │ │
│ │ } │ │
│ │ // 收集回复 │ │
│ │ timeout := time.After(2 * time.Second) │ │
│ │ for { │ │
│ │ select { │ │
│ │ case <-pongChan: │ │
│ │ received++ │ │
│ │ case <-timeout: │ │
│ │ goto done │ │
│ │ } │ │
│ │ } │ │
│ │ done: │ │
│ │ loss := float64(sent-received) / float64(sent) │ │
│ │ losses = append(losses, loss) │ │
│ │ } │ │
│ │ return average(losses) │ │
│ │ } │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 3. 抖动测试（Jitter） │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 算法：RTT标准差 │ │
│ │ │ │
│ │ 公式：Jitter = sqrt(Σ(RTTi - RTT_avg)² / N) │ │
│ │ │ │
│ │ 步骤： │ │
│ │ 1. 使用RTT测试的10个样本 │ │
│ │ 2. 计算平均值 │ │
│ │ 3. 计算每个样本与平均值的差的平方和 │ │
│ │ 4. 开方得到标准差 │ │
│ │ │ │
│ │ 伪代码： │ │
│ │ func measureJitter(rtts []float64) float64 { │ │
│ │ avg := average(rtts) │ │
│ │ var sum float64 │ │
│ │ for _, rtt := range rtts { │ │
│ │ diff := rtt - avg │ │
│ │ sum += diff * diff │ │
│ │ } │ │
│ │ return math.Sqrt(sum / float64(len(rtts))) │ │
│ │ } │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 4. 带宽测试 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 算法：递增探测法 │ │
│ │ │ │
│ │ 步骤： │ │
│ │ 1. 发送递增大小的数据包：1KB, 4KB, 16KB, 64KB, 256KB │ │
│ │ 2. 测量每个大小的传输时间 │ │
│ │ 3. 计算吞吐量 = 大小 / 时间 │ │
│ │ 4. 取最大吞吐量作为带宽估计 │ │
│ │ │ │
│ │ 伪代码： │ │
│ │ func measureBandwidth(node string) float64 { │ │
│ │ sizes := []int{1024, 4096, 16384, 65536, 262144} │ │
│ │ var maxBw float64 │ │
│ │ for _, size := range sizes { │ │
│ │ data := make([]byte, size) │ │
│ │ start := time.Now() │ │
│ │ sendData(node, data) │ │
│ │ waitACK() │ │
│ │ elapsed := time.Since(start).Seconds() │ │
│ │ bw := float64(size) * 8 / elapsed / 1e6 │ │
│ │ if bw > maxBw { │ │
│ │ maxBw = bw │ │
│ │ } │ │
│ │ } │ │
│ │ return maxBw // Mbps │ │
│ │ } │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 5.2.2 评分算法
```
┌──────────────────────────────────────────────────────────────────┐
│ 节点评分算法 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 综合评分公式： │
│ │
│ Score(i) = 100 │
│ - RTT_penalty(i) │
│ - Loss_penalty(i) │
│ - Jitter_penalty(i) │
│ - Load_penalty(i) │
│ + Bonus(i) │
│ │
│ 各项扣分计算： │
│ │
│ 1. RTT扣分： │
│ RTT_penalty = max(0, (RTT - RTT_base) × RTT_factor) │
│ 其中： │
│ - RTT_base = 30ms（基准延迟） │
│ - RTT_factor = 0.5（每ms扣0.5分） │
│ - 最大扣分：50分 │
│ │
│ 2. 丢包扣分： │
│ Loss_penalty = Loss_rate × Loss_factor │
│ 其中： │
│ - Loss_rate = 丢包率（0-1） │
│ - Loss_factor = 200（每1%丢包扣2分） │
│ - 最大扣分：50分 │
│ │
│ 3. 抖动扣分： │
│ Jitter_penalty = Jitter × Jitter_factor │
│ 其中： │
│ - Jitter = 抖动值（ms） │
│ - Jitter_factor = 2（每ms抖动扣2分） │
│ - 最大扣分：30分 │
│ │
│ 4. 负载扣分： │
│ Load_penalty = (Load_rate - Load_threshold) × Load_factor │
│ 其中： │
│ - Load_rate = 负载率（0-1） │
│ - Load_threshold = 0.5（50%以下不扣分） │
│ - Load_factor = 40 │
│ - 最大扣分：20分 │
│ │
│ 5. 加分项： │
│ - 专线节点：+10分 │
│ - BGP多线：+5分 │
│ - 同ISP：+5分 │
│ - 同城市：+10分 │
│ │
│ 评分等级： │
│ ┌──────────┬──────────┬──────────────────────────┐ │
│ │ 分数 │ 等级 │ 说明 │ │
│ ├──────────┼──────────┼──────────────────────────┤ │
│ │ 90-100 │ 极佳 │ 最优选择，绿色显示 │ │
│ │ 70-89 │ 良好 │ 推荐选择，黄色显示 │ │
│ │ 50-69 │ 一般 │ 可用，橙色显示 │ │
│ │ <50 │ 较差 │ 不推荐，红色显示 │ │
│ └──────────┴──────────┴──────────────────────────┘ │
│ │
│ 伪代码实现： │
│ │
│ func calculateScore(node *Node, user *User) float64 { │
│ score := 100.0 │
│ │
│ // RTT扣分 │
│ rttPenalty := math.Max(0, (node.RTT-30)*0.5) │
│ rttPenalty = math.Min(rttPenalty, 50) │
│ score -= rttPenalty │
│ │
│ // 丢包扣分 │
│ lossPenalty := node.LossRate * 200 │
│ lossPenalty = math.Min(lossPenalty, 50) │
│ score -= lossPenalty │
│ │
│ // 抖动扣分 │
│ jitterPenalty := node.Jitter * 2 │
│ jitterPenalty = math.Min(jitterPenalty, 30) │
│ score -= jitterPenalty │
│ │
│ // 负载扣分 │
│ if node.LoadRate > 0.5 { │
│ loadPenalty := (node.LoadRate - 0.5) * 40 │
│ score -= loadPenalty │
│ } │
│ │
│ // 加分项 │
│ if node.IsDedicatedLine { score += 10 } │
│ if node.IsBGP { score += 5 } │
│ if node.ISP == user.ISP { score += 5 } │
│ if node.City == user.City { score += 10 } │
│ │
│ return math.Max(0, math.Min(100, score)) │
│ } │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 5.2.3 节点选择算法
```
┌──────────────────────────────────────────────────────────────────┐
│ 节点选择算法 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 输入： │
│ - 用户信息：地理位置、ISP、当前网络状况 │
│ - 游戏信息：目标服务器地址、协议类型 │
│ - 节点列表：所有可用节点及其状态 │
│ │
│ 输出： │
│ - 最优节点（主节点） │
│ - 备用节点列表（2-3个） │
│ - 推荐路由路径 │
│ │
│ 算法流程： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Step 1: 候选节点筛选 │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ for each node in all_nodes: │ │ │
│ │ │ if node.status != "online": │ │ │
│ │ │ skip │ │ │
│ │ │ if node.load_rate > 0.9: │ │ │
│ │ │ skip │ │ │
│ │ │ if not node.supports_game(game_id): │ │ │
│ │ │ skip │ │ │
│ │ │ candidates.add(node) │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Step 2: 地理位置匹配 │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ // 优先选择同区域节点 │ │ │
│ │ │ same_region = filter(candidates, same_region) │ │ │
│ │ │ if len(same_region) > 0: │ │ │
│ │ │ candidates = same_region │ │ │
│ │ │ │ │ │
│ │ │ // 优先选择同ISP节点 │ │ │
│ │ │ same_isp = filter(candidates, same_isp) │ │ │
│ │ │ if len(same_isp) > 0: │ │ │
│ │ │ candidates = same_isp │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Step 3: 质量评分 │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ for each node in candidates: │ │ │
│ │ │ node.score = calculateScore(node, user) │ │ │
│ │ │ │ │ │
│ │ │ // 按评分排序 │ │ │
│ │ │ candidates.sort_by_score_desc() │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Step 4: 选择最优 │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ best_node = candidates[0] │ │ │
│ │ │ backup_nodes = candidates[1:3] // 取2个备用 │ │ │
│ │ │ │ │ │
│ │ │ // 构建路由路径 │ │ │
│ │ │ route = build_route(user, best_node, game_server) │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 5.2.4 自动切换算法
```
┌──────────────────────────────────────────────────────────────────┐
│ 自动切换算法 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 切换触发条件（满足任一即触发）： │
│ 1. 当前节点RTT > 最优节点RTT × 1.5 │
│ 2. 当前节点丢包率 > 5% │
│ 3. 连续3次探测质量下降 │
│ 4. 当前节点负载 > 80% │
│ 5. 当前节点离线 │
│ 6. 用户手动切换 │
│ │
│ 切换决策流程： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 每隔10秒执行一次检测： │ │
│ │ │ │
│ │ func autoSwitchCheck() { │ │
│ │ // 1. 测试当前节点质量 │ │
│ │ currentQuality = testNode(currentNode) │ │
│ │ │ │
│ │ // 2. 测试备用节点质量 │ │
│ │ for each backup in backupNodes: │ │
│ │ backup.quality = testNode(backup) │ │
│ │ │ │
│ │ // 3. 找到最优节点 │ │
│ │ bestBackup = findBest(backupNodes) │ │
│ │ │ │
│ │ // 4. 判断是否需要切换 │ │
│ │ needSwitch := false │ │
│ │ │ │
│ │ // 条件1：延迟差异 │ │
│ │ if currentQuality.RTT > bestBackup.RTT * 1.5 { │ │
│ │ needSwitch = true │ │
│ │ } │ │
│ │ │ │
│ │ // 条件2：丢包率 │ │
│ │ if currentQuality.LossRate > 0.05 { │ │
│ │ needSwitch = true │ │
│ │ } │ │
│ │ │ │
│ │ // 条件3：连续下降 │ │
│ │ if qualityDeclineCount >= 3 { │ │
│ │ needSwitch = true │ │
│ │ qualityDeclineCount = 0 │ │
│ │ } │ │
│ │ │ │
│ │ // 条件4：负载过高 │ │
│ │ if currentNode.LoadRate > 0.8 { │ │
│ │ needSwitch = true │ │
│ │ } │ │
│ │ │ │
│ │ // 5. 执行切换 │ │
│ │ if needSwitch && bestBackup.Score > 60 { │ │
│ │ switchTo(bestBackup) │ │
│ │ } │ │
│ │ } │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 切换执行流程（无缝切换）： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ func switchTo(newNode *Node) { │ │
│ │ // 1. 预建立新连接 │ │
│ │ newConn = establishConnection(newNode) │ │
│ │ │ │
│ │ // 2. 迁移会话状态 │ │
│ │ migrateSession(currentSession, newConn) │ │
│ │ │ │
│ │ // 3. 切换流量 │ │
│ │ redirectTraffic(newConn) │ │
│ │ │ │
│ │ // 4. 验证新连接 │ │
│ │ if verifyConnection(newConn) { │ │
│ │ // 5. 关闭旧连接 │ │
│ │ closeConnection(oldConn) │ │
│ │ currentNode = newNode │ │
│ │ log("Switch success") │ │
│ │ } else { │ │
│ │ // 切换失败，回滚 │ │
│ │ rollback(oldConn) │ │
│ │ log("Switch failed, rolled back") │ │
│ │ } │ │
│ │ } │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 5.3 macOS/iOS/Android客户端
```
┌──────────────────────────────────────────────────────────────────┐
│ 跨平台客户端方案 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ macOS客户端： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 技术栈：Swift + Network Extension (NEPacketTunnelProvider)│ │
│ │ │ │
│ │ 流量捕获： │ │
│ │ - Network Extension (NEPacketTunnelProvider) │ │
│ │ - 系统级VPN框架，稳定性高 │ │
│ │ - 支持按App过滤（macOS 11+） │ │
│ │ │ │
│ │ 隧道实现： │ │
│ │ - 用户态UDP隧道 │ │
│ │ - 或QUIC隧道（quic-go Swift binding） │ │
│ │ │ │
│ │ 限制： │ │
│ │ - 需要App Store审核 │ │
│ │ - Network Extension有沙箱限制 │ │
│ │ - 无法实现内核态驱动 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ iOS客户端： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 技术栈：Swift + Network Extension │ │
│ │ │ │
│ │ 流量捕获： │ │
│ │ - NEPacketTunnelProvider (Packet Tunnel) │ │
│ │ - 支持按App过滤（iOS 14+） │ │
│ │ - 系统级VPN框架 │ │
│ │ │ │
│ │ 限制： │ │
│ │ - App Store审核严格（需说明加速器用途） │ │
│ │ - 沙箱限制更严格 │ │
│ │ - 后台运行限制 │ │
│ │ - 无法实现内核态操作 │ │
│ │ │ │
│ │ 适用游戏： │ │
│ │ - 手游（原神、PUBG Mobile等） │ │
│ │ - 云游戏 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ Android客户端： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 技术栈：Kotlin + VpnService │ │
│ │ │ │
│ │ 流量捕获： │ │
│ │ - VpnService (系统级VPN) │ │
│ │ - 支持TUN设备 │ │
│ │ - 可获取进程UID │ │
│ │ │ │
│ │ 优势： │ │
│ │ - 开发灵活度最高 │ │
│ │ - 可获取进程信息 │ │
│ │ - 支持自定义协议 │ │
│ │ - Google Play审核相对宽松 │ │
│ │ │ │
│ │ 适用游戏： │ │
│ │ - 手游（全品类） │ │
│ │ - 云游戏 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/06-智能调度系统.md
+351
View File
@@ -0,0 +1,351 @@
# 第六部分：智能调度系统
## 6.1 实时链路探测
```
┌──────────────────────────────────────────────────────────────────┐
│ 实时链路探测系统 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 探测架构： │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 探测集群 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 探测节点 │ │ 探测节点 │ │ 探测节点 │ ... │ │
│ │ │ (北京) │ │ (上海) │ │ (广州) │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ │ │ │ │ │ │
│ │ └──────────────┴──────────────┘ │ │
│ │ │ │ │
│ │ ┌──────┴──────┐ │ │
│ │ │ 数据汇聚 │ │ │
│ │ │ (ClickHouse)│ │ │
│ │ └──────┬──────┘ │ │
│ │ │ │ │
│ │ ┌──────┴──────┐ │ │
│ │ │ 分析引擎 │ │ │
│ │ │ (实时计算) │ │ │
│ │ └──────┬──────┘ │ │
│ │ │ │ │
│ │ ┌──────┴──────┐ │ │
│ │ │ 调度决策 │ │ │
│ │ │ (路由更新) │ │ │
│ │ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 探测指标： │
│ ┌──────────────┬──────────────┬──────────────┬──────────────┐ │
│ │ 指标 │ 方法 │ 频率 │ 精度 │ │
│ ├──────────────┼──────────────┼──────────────┼──────────────┤ │
│ │ Ping │ ICMP/UDP │ 每5秒 │ ±1ms │ │
│ │ Jitter │ RTT标准差 │ 每5秒 │ ±2ms │ │
│ │ Loss │ 统计法 │ 每10秒 │ ±0.1% │ │
│ │ RTT │ TCP/UDP │ 每5秒 │ ±1ms │ │
│ │ Bandwidth │ 递增探测 │ 每分钟 │ ±10% │ │
│ │ Node Load │ 心跳上报 │ 每10秒 │ ±5% │ │
│ └──────────────┴──────────────┴──────────────┴──────────────┘ │
│ │
│ 探测数据存储： │
│ - 实时数据：Redis（最新值，TTL 5分钟） │
│ - 历史数据：ClickHouse（聚合后，保留30天） │
│ - 告警数据：MySQL（持久化） │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 6.2 调度算法设计
### 6.2.1 基础版本（规则引擎）
```
┌──────────────────────────────────────────────────────────────────┐
│ 基础调度算法（规则引擎） │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 输入： │
│ - 用户位置（城市、ISP） │
│ - 游戏服务器位置 │
│ - 节点列表及其状态 │
│ │
│ 输出： │
│ - 最优节点 │
│ - 路由路径 │
│ │
│ 规则优先级： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 规则1：同城市同ISP → 直连 │ │
│ │ 条件：user.city == node.city && user.isp == node.isp │ │
│ │ 动作：直接选择该节点 │ │
│ │ 优先级：1（最高） │ │
│ │ │ │
│ │ 规则2：同城市跨ISP → BGP节点 │ │
│ │ 条件：user.city == node.city && user.isp != node.isp │ │
│ │ 动作：选择BGP节点 │ │
│ │ 优先级：2 │ │
│ │ │ │
│ │ 规则3：同区域跨城市 → 区域核心节点 │ │
│ │ 条件：user.region == node.region && user.city != node.city│ │
│ │ 动作：选择区域核心节点 │ │
│ │ 优先级：3 │ │
│ │ │ │
│ │ 规则4：跨区域 → 中转节点 │ │
│ │ 条件：user.region != node.region │ │
│ │ 动作：选择最优中转节点 │ │
│ │ 优先级：4 │ │
│ │ │ │
│ │ 规则5：跨境 → 国际专线节点 │ │
│ │ 条件：user.country != node.country │ │
│ │ 动作：选择国际专线节点 │ │
│ │ 优先级：5（最低） │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 伪代码实现： │
│ │
│ func basicSchedule(user *User, game *Game) *Node { │
│ candidates := getCandidateNodes(game) │
│ │
│ // 规则1：同城市同ISP │
│ for _, node := range candidates { │
│ if node.City == user.City && node.ISP == user.ISP { │
│ return node │
│ } │
│ } │
│ │
│ // 规则2：同城市BGP │
│ for _, node := range candidates { │
│ if node.City == user.City && node.IsBGP { │
│ return node │
│ } │
│ } │
│ │
│ // 规则3：同区域核心节点 │
│ for _, node := range candidates { │
│ if node.Region == user.Region && node.IsCore { │
│ return node │
│ } │
│ } │
│ │
│ // 规则4：中转节点 │
│ bestScore := 0.0 │
│ var bestNode *Node │
│ for _, node := range candidates { │
│ score := calculateScore(node, user) │
│ if score > bestScore { │
│ bestScore = score │
│ bestNode = node │
│ } │
│ } │
│ return bestNode │
│ } │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 6.2.2 高级版本（多因子加权）
```
┌──────────────────────────────────────────────────────────────────┐
│ 高级调度算法（多因子加权） │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 输入因子： │
│ ┌──────────────┬──────────┬──────────┬──────────────────────┐ │
│ │ 因子 │ 权重 │ 范围 │ 说明 │ │
│ ├──────────────┼──────────┼──────────┼──────────────────────┤ │
│ │ RTT │ 0.35 │ 0-500ms │ 往返延迟 │ │
│ │ Loss Rate │ 0.25 │ 0-100% │ 丢包率 │ │
│ │ Jitter │ 0.15 │ 0-100ms │ 抖动 │ │
│ │ Node Load │ 0.10 │ 0-100% │ 节点负载 │ │
│ │ ISP Match │ 0.05 │ 0/1 │ ISP匹配 │ │
│ │ Geo Distance │ 0.05 │ 0-10000km│ 地理距离 │ │
│ │ Line Quality │ 0.05 │ 0-1 │ 线路质量 │ │
│ └──────────────┴──────────┴──────────┴──────────────────────┘ │
│ │
│ 评分公式： │
│ │
│ Score(i) = Σ(Wj × normalize(Fij)) │
│ │
│ 其中： │
│ - Wj = 第j个因子的权重 │
│ - Fij = 节点i在第j个因子上的值 │
│ - normalize() = 归一化到[0,1]区间 │
│ │
│ 归一化方法： │
│ - RTT: norm = 1 - (RTT / max_RTT) │
│ - Loss: norm = 1 - Loss │
│ - Jitter: norm = 1 - (Jitter / max_Jitter) │
│ - Load: norm = 1 - Load │
│ - ISP Match: norm = 1 if match else 0 │
│ - Geo Distance: norm = 1 - (dist / max_dist) │
│ - Line Quality: norm = Quality_Score │
│ │
│ 伪代码实现： │
│ │
│ type ScheduleFactor struct { │
│ Name string │
│ Weight float64 │
│ MaxVal float64 │
│ } │
│ │
│ var factors = []ScheduleFactor{ │
│ {"rtt", 0.35, 500}, │
│ {"loss", 0.25, 1.0}, │
│ {"jitter", 0.15, 100}, │
│ {"load", 0.10, 1.0}, │
│ {"isp_match", 0.05, 1.0}, │
│ {"geo_dist", 0.05, 10000}, │
│ {"line_quality", 0.05, 1.0}, │
│ } │
│ │
│ func advancedSchedule(user *User, game *Game) *Node { │
│ candidates := getCandidateNodes(game) │
│ │
│ var bestNode *Node │
│ bestScore := -1.0 │
│ │
│ for _, node := range candidates { │
│ score := 0.0 │
│ │
│ // RTT因子 │
│ rttNorm := 1.0 - (node.RTT / 500.0) │
│ score += 0.35 * rttNorm │
│ │
│ // 丢包因子 │
│ lossNorm := 1.0 - node.LossRate │
│ score += 0.25 * lossNorm │
│ │
│ // 抖动因子 │
│ jitterNorm := 1.0 - (node.Jitter / 100.0) │
│ score += 0.15 * jitterNorm │
│ │
│ // 负载因子 │
│ loadNorm := 1.0 - node.LoadRate │
│ score += 0.10 * loadNorm │
│ │
│ // ISP匹配 │
│ ispNorm := 0.0 │
│ if node.ISP == user.ISP { │
│ ispNorm = 1.0 │
│ } │
│ score += 0.05 * ispNorm │
│ │
│ // 地理距离 │
│ dist := haversine(user.Lat, user.Lng, node.Lat, node.Lng)│
│ distNorm := 1.0 - (dist / 10000.0) │
│ score += 0.05 * distNorm │
│ │
│ // 线路质量 │
│ score += 0.05 * node.LineQuality │
│ │
│ if score > bestScore { │
│ bestScore = score │
│ bestNode = node │
│ } │
│ } │
│ │
│ return bestNode │
│ } │
│ │
└──────────────────────────────────────────────────────────────────┘
```
### 6.2.3 AI版本（机器学习）
```
┌──────────────────────────────────────────────────────────────────┐
│ AI调度算法（机器学习） │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 模型选择：XGBoost / LightGBM │
│ 原因： │
│ - 推理速度快（<1ms） │
│ - 可解释性好 │
│ - 特征重要性可分析 │
│ - 训练数据要求相对低 │
│ │
│ 特征工程： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 用户特征： │ │
│ │ - user_city (one-hot编码) │ │
│ │ - user_isp (one-hot编码) │ │
│ │ - user_latency_avg (历史平均延迟) │ │
│ │ - user_loss_avg (历史平均丢包率) │ │
│ │ - user_bandwidth (用户带宽) │ │
│ │ - time_of_day (时段，0-23) │ │
│ │ - day_of_week (星期，0-6) │ │
│ │ - is_peak_hour (是否高峰时段) │ │
│ │ │ │
│ │ 节点特征： │ │
│ │ - node_city (one-hot编码) │ │
│ │ - node_isp (one-hot编码) │ │
│ │ - node_rtt (当前延迟) │ │
│ │ - node_loss (当前丢包率) │ │
│ │ - node_jitter (当前抖动) │ │
│ │ - node_load (当前负载) │ │
│ │ - node_bandwidth (节点带宽) │ │
│ │ - node_line_type (线路类型，0-5) │ │
│ │ │ │
│ │ 游戏特征： │ │
│ │ - game_id (游戏ID) │ │
│ │ - game_region (游戏区域) │ │
│ │ - game_protocol (游戏协议，TCP/UDP/混合) │ │
│ │ - game_server_distance (游戏服务器距离) │ │
│ │ │ │
│ │ 交叉特征： │ │
│ │ - user_node_distance (用户到节点距离) │ │
│ │ - user_node_isp_match (ISP是否匹配) │ │
│ │ - node_game_distance (节点到游戏服务器距离) │ │
│ │ - historical_score (历史评分) │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 标签： │
│ - 实际加速效果评分（0-100） │
│ - 用户满意度（点击"反馈"按钮） │
│ - 是否掉线（0/1） │
│ │
│ 训练流程： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 数据收集 │───→│ 特征工程 │───→│ 模型训练 │ │ │
│ │ │ 30天数据 │ │ 特征提取 │ │ XGBoost │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ │ │ │ │
│ │ │ ┌───────────────────┘ │ │
│ │ │ ↓ │ │
│ │ │ ┌──────────┐ ┌──────────┐ │ │
│ │ │ │ 模型评估 │───→│ 模型部署 │ │ │
│ │ │ │ A/B测试 │ │ 在线推理 │ │ │
│ │ │ └──────────┘ └──────────┘ │ │
│ │ │ │ │
│ │ └─── 每周重新训练，持续优化 │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 推理流程： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ func aiSchedule(user *User, game *Game) *Node { │ │
│ │ candidates := getCandidateNodes(game) │ │
│ │ │ │
│ │ // 提取特征 │ │
│ │ features := extractFeatures(user, candidates, game) │ │
│ │ │ │
│ │ // 模型推理 │ │
│ │ scores := model.Predict(features) │ │
│ │ │ │
│ │ // 选择最高分节点 │ │
│ │ bestIdx := argmax(scores) │ │
│ │ return candidates[bestIdx] │ │
│ │ } │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ A/B测试： │
│ - 10%用户使用AI调度 │
│ - 90%用户使用高级调度 │
│ - 对比指标：延迟、丢包率、用户满意度 │
│ - 显著提升后全量切换 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/07-数据库设计.md
+478
View File
@@ -0,0 +1,478 @@
# 第七部分：数据库设计
## 7.1 MySQL数据库设计
### 7.1.1 用户相关表
```sql
-- ============================================================
-- 用户表 (users)
-- ============================================================
CREATE TABLE `users` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '用户ID',
`uuid` CHAR(36) NOT NULL COMMENT '用户UUID',
`phone` VARCHAR(20) DEFAULT NULL COMMENT '手机号（加密存储）',
`email` VARCHAR(100) DEFAULT NULL COMMENT '邮箱（加密存储）',
`password_hash` VARCHAR(255) NOT NULL COMMENT '密码哈希（bcrypt）',
`salt` VARCHAR(32) NOT NULL COMMENT '密码盐值',
`nickname` VARCHAR(50) NOT NULL DEFAULT '' COMMENT '昵称',
`avatar` VARCHAR(255) NOT NULL DEFAULT '' COMMENT '头像URL',
`gender` TINYINT NOT NULL DEFAULT 0 COMMENT '性别：0未知 1男 2女',
`status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态：0禁用 1正常 2待验证',
`register_source` VARCHAR(20) NOT NULL DEFAULT 'web' COMMENT '注册来源',
`register_ip` VARCHAR(45) NOT NULL DEFAULT '' COMMENT '注册IP',
`last_login_at` DATETIME DEFAULT NULL COMMENT '最后登录时间',
`last_login_ip` VARCHAR(45) DEFAULT NULL COMMENT '最后登录IP',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
`deleted_at` DATETIME DEFAULT NULL COMMENT '软删除时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_uuid` (`uuid`),
UNIQUE KEY `uk_phone` (`phone`),
UNIQUE KEY `uk_email` (`email`),
KEY `idx_status` (`status`),
KEY `idx_created_at` (`created_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
-- ============================================================
-- 设备表 (devices)
-- ============================================================
CREATE TABLE `devices` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '设备ID',
`user_id` BIGINT UNSIGNED NOT NULL COMMENT '用户ID',
`device_id` VARCHAR(64) NOT NULL COMMENT '设备唯一标识（硬件指纹）',
`device_name` VARCHAR(100) NOT NULL DEFAULT '' COMMENT '设备名称',
`device_type` VARCHAR(20) NOT NULL COMMENT '设备类型：windows/mac/android/ios',
`os_version` VARCHAR(50) NOT NULL DEFAULT '' COMMENT '系统版本',
`client_version` VARCHAR(20) NOT NULL DEFAULT '' COMMENT '客户端版本',
`push_token` VARCHAR(255) DEFAULT NULL COMMENT '推送Token',
`status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态：0禁用 1正常',
`last_active_at` DATETIME DEFAULT NULL COMMENT '最后活跃时间',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_user_device` (`user_id`, `device_id`),
KEY `idx_user_id` (`user_id`),
KEY `idx_device_id` (`device_id`),
KEY `idx_last_active` (`last_active_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='设备表';
-- ============================================================
-- 会员表 (memberships)
-- ============================================================
CREATE TABLE `memberships` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '会员ID',
`user_id` BIGINT UNSIGNED NOT NULL COMMENT '用户ID',
`plan_id` VARCHAR(50) NOT NULL COMMENT '套餐ID',
`plan_name` VARCHAR(100) NOT NULL COMMENT '套餐名称',
`status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态：0过期 1有效 2暂停',
`start_at` DATETIME NOT NULL COMMENT '开始时间',
`expire_at` DATETIME NOT NULL COMMENT '过期时间',
`auto_renew` TINYINT NOT NULL DEFAULT 0 COMMENT '是否自动续费',
`total_traffic` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT '总流量（字节）',
`used_traffic` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT '已用流量（字节）',
`device_limit` INT NOT NULL DEFAULT 1 COMMENT '设备数量限制',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_user_id` (`user_id`),
KEY `idx_status` (`status`),
KEY `idx_expire_at` (`expire_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='会员表';
-- ============================================================
-- 订单表 (orders)
-- ============================================================
CREATE TABLE `orders` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '订单ID',
`order_no` VARCHAR(32) NOT NULL COMMENT '订单号',
`user_id` BIGINT UNSIGNED NOT NULL COMMENT '用户ID',
`plan_id` VARCHAR(50) NOT NULL COMMENT '套餐ID',
`plan_name` VARCHAR(100) NOT NULL COMMENT '套餐名称',
`amount` DECIMAL(10,2) NOT NULL COMMENT '订单金额',
`currency` VARCHAR(3) NOT NULL DEFAULT 'CNY' COMMENT '货币类型',
`pay_method` VARCHAR(20) NOT NULL COMMENT '支付方式：alipay/wechat/apple',
`pay_amount` DECIMAL(10,2) DEFAULT NULL COMMENT '实付金额',
`pay_time` DATETIME DEFAULT NULL COMMENT '支付时间',
`status` TINYINT NOT NULL DEFAULT 0 COMMENT '状态：0待支付 1已支付 2已取消 3已退款',
`coupon_id` BIGINT DEFAULT NULL COMMENT '优惠券ID',
`discount_amount` DECIMAL(10,2) NOT NULL DEFAULT 0 COMMENT '优惠金额',
`remark` VARCHAR(255) DEFAULT NULL COMMENT '备注',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
`expired_at` DATETIME DEFAULT NULL COMMENT '过期时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_order_no` (`order_no`),
KEY `idx_user_id` (`user_id`),
KEY `idx_status` (`status`),
KEY `idx_created_at` (`created_at`),
KEY `idx_pay_time` (`pay_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';
```
### 7.1.2 节点相关表
```sql
-- ============================================================
-- 节点表 (nodes)
-- ============================================================
CREATE TABLE `nodes` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '节点ID',
`node_id` VARCHAR(50) NOT NULL COMMENT '节点标识',
`name` VARCHAR(100) NOT NULL COMMENT '节点名称',
`region` VARCHAR(20) NOT NULL COMMENT '区域：china/asia/europe/america',
`country` VARCHAR(10) NOT NULL COMMENT '国家代码',
`city` VARCHAR(50) NOT NULL COMMENT '城市',
`isp` VARCHAR(20) NOT NULL COMMENT '运营商：telecom/unicom/mobile/bgp',
`ip` VARCHAR(45) NOT NULL COMMENT '节点IP',
`port` INT NOT NULL DEFAULT 8000 COMMENT '服务端口',
`type` VARCHAR(20) NOT NULL COMMENT '类型：access/relay/exit',
`capacity` INT NOT NULL DEFAULT 10000 COMMENT '最大连接数',
`current_load` INT NOT NULL DEFAULT 0 COMMENT '当前连接数',
`bandwidth_mbps` INT NOT NULL DEFAULT 1000 COMMENT '带宽（Mbps）',
`used_bandwidth_mbps` INT NOT NULL DEFAULT 0 COMMENT '已用带宽',
`status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态：0离线 1在线 2维护',
`quality_score` DECIMAL(5,2) NOT NULL DEFAULT 0 COMMENT '质量评分',
`latitude` DECIMAL(10,7) DEFAULT NULL COMMENT '纬度',
`longitude` DECIMAL(10,7) DEFAULT NULL COMMENT '经度',
`cloud_provider` VARCHAR(20) DEFAULT NULL COMMENT '云服务商',
`line_type` VARCHAR(20) NOT NULL DEFAULT 'bgp' COMMENT '线路类型',
`is_dedicated` TINYINT NOT NULL DEFAULT 0 COMMENT '是否专线',
`supported_games` JSON DEFAULT NULL COMMENT '支持的游戏列表',
`config` JSON DEFAULT NULL COMMENT '节点配置',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_node_id` (`node_id`),
KEY `idx_region` (`region`),
KEY `idx_country_city` (`country`, `city`),
KEY `idx_status` (`status`),
KEY `idx_type` (`type`),
KEY `idx_quality_score` (`quality_score`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='节点表';
-- ============================================================
-- 线路表 (routes)
-- ============================================================
CREATE TABLE `routes` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '线路ID',
`route_id` VARCHAR(50) NOT NULL COMMENT '线路标识',
`game_id` VARCHAR(50) NOT NULL COMMENT '游戏ID',
`source_region` VARCHAR(50) NOT NULL COMMENT '源区域',
`dest_region` VARCHAR(50) NOT NULL COMMENT '目标区域',
`access_node_id` VARCHAR(50) NOT NULL COMMENT '接入节点ID',
`relay_node_ids` JSON DEFAULT NULL COMMENT '中转节点ID列表',
`exit_node_id` VARCHAR(50) NOT NULL COMMENT '出口节点ID',
`protocol` VARCHAR(20) NOT NULL DEFAULT 'udp_relay' COMMENT '协议',
`priority` TINYINT NOT NULL DEFAULT 0 COMMENT '优先级',
`status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态：0禁用 1启用',
`avg_latency` DECIMAL(8,2) DEFAULT NULL COMMENT '平均延迟',
`avg_loss` DECIMAL(5,4) DEFAULT NULL COMMENT '平均丢包率',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_route_id` (`route_id`),
KEY `idx_game_id` (`game_id`),
KEY `idx_source_region` (`source_region`),
KEY `idx_dest_region` (`dest_region`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='线路表';
```
### 7.1.3 游戏相关表
```sql
-- ============================================================
-- 游戏表 (games)
-- ============================================================
CREATE TABLE `games` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '游戏ID',
`game_id` VARCHAR(50) NOT NULL COMMENT '游戏标识',
`name` VARCHAR(100) NOT NULL COMMENT '游戏名称',
`name_en` VARCHAR(100) NOT NULL DEFAULT '' COMMENT '英文名',
`icon` VARCHAR(255) NOT NULL DEFAULT '' COMMENT '图标URL',
`category` VARCHAR(30) NOT NULL COMMENT '分类：fps/moba/mmorpg/rts/other',
`platform` VARCHAR(20) NOT NULL DEFAULT 'pc' COMMENT '平台：pc/mobile/console',
`is_popular` TINYINT NOT NULL DEFAULT 0 COMMENT '是否热门',
`is_enabled` TINYINT NOT NULL DEFAULT 1 COMMENT '是否启用',
`process_names` JSON DEFAULT NULL COMMENT '进程名列表',
`server_config` JSON DEFAULT NULL COMMENT '服务器配置',
`default_protocol` VARCHAR(20) NOT NULL DEFAULT 'udp_relay' COMMENT '默认协议',
`priority` TINYINT NOT NULL DEFAULT 0 COMMENT '优先级',
`sort_order` INT NOT NULL DEFAULT 0 COMMENT '排序',
`description` TEXT COMMENT '描述',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_game_id` (`game_id`),
KEY `idx_category` (`category`),
KEY `idx_is_popular` (`is_popular`),
KEY `idx_sort_order` (`sort_order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='游戏表';
-- ============================================================
-- 游戏服务器表 (game_servers)
-- ============================================================
CREATE TABLE `game_servers` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '服务器ID',
`game_id` VARCHAR(50) NOT NULL COMMENT '游戏ID',
`name` VARCHAR(100) NOT NULL COMMENT '服务器名称',
`region` VARCHAR(20) NOT NULL COMMENT '区域',
`ip` VARCHAR(45) NOT NULL COMMENT '服务器IP',
`ip_range` VARCHAR(18) DEFAULT NULL COMMENT 'IP段',
`port` INT DEFAULT NULL COMMENT '端口',
`protocol` VARCHAR(10) NOT NULL DEFAULT 'udp' COMMENT '协议',
`location` JSON DEFAULT NULL COMMENT '地理位置',
`status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
KEY `idx_game_id` (`game_id`),
KEY `idx_region` (`region`),
KEY `idx_ip` (`ip`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='游戏服务器表';
```
### 7.1.4 测速与日志表
```sql
-- ============================================================
-- 测速记录表 (speed_tests)
-- ============================================================
CREATE TABLE `speed_tests` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID',
`user_id` BIGINT UNSIGNED NOT NULL COMMENT '用户ID',
`node_id` VARCHAR(50) NOT NULL COMMENT '节点ID',
`game_id` VARCHAR(50) DEFAULT NULL COMMENT '游戏ID',
`rtt` DECIMAL(8,2) NOT NULL COMMENT '延迟（ms）',
`jitter` DECIMAL(8,2) NOT NULL COMMENT '抖动（ms）',
`loss_rate` DECIMAL(5,4) NOT NULL COMMENT '丢包率',
`bandwidth_mbps` DECIMAL(10,2) DEFAULT NULL COMMENT '带宽（Mbps）',
`score` DECIMAL(5,2) NOT NULL COMMENT '评分',
`client_ip` VARCHAR(45) NOT NULL COMMENT '客户端IP',
`isp` VARCHAR(20) DEFAULT NULL COMMENT '运营商',
`city` VARCHAR(50) DEFAULT NULL COMMENT '城市',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
KEY `idx_user_id` (`user_id`),
KEY `idx_node_id` (`node_id`),
KEY `idx_created_at` (`created_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='测速记录表';
-- ============================================================
-- 加速会话表 (sessions)
-- ============================================================
CREATE TABLE `sessions` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '会话ID',
`session_id` VARCHAR(64) NOT NULL COMMENT '会话标识',
`user_id` BIGINT UNSIGNED NOT NULL COMMENT '用户ID',
`device_id` VARCHAR(64) NOT NULL COMMENT '设备ID',
`game_id` VARCHAR(50) NOT NULL COMMENT '游戏ID',
`node_id` VARCHAR(50) NOT NULL COMMENT '节点ID',
`route_id` VARCHAR(50) DEFAULT NULL COMMENT '线路ID',
`protocol` VARCHAR(20) NOT NULL COMMENT '协议',
`start_at` DATETIME NOT NULL COMMENT '开始时间',
`end_at` DATETIME DEFAULT NULL COMMENT '结束时间',
`duration` INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '时长（秒）',
`total_bytes_up` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT '上行流量（字节）',
`total_bytes_down` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT '下行流量（字节）',
`avg_latency` DECIMAL(8,2) DEFAULT NULL COMMENT '平均延迟',
`avg_loss` DECIMAL(5,4) DEFAULT NULL COMMENT '平均丢包率',
`status` TINYINT NOT NULL DEFAULT 1 COMMENT '状态：0异常断开 1正常结束 2进行中',
`disconnect_reason` VARCHAR(50) DEFAULT NULL COMMENT '断开原因',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_session_id` (`session_id`),
KEY `idx_user_id` (`user_id`),
KEY `idx_game_id` (`game_id`),
KEY `idx_start_at` (`start_at`),
KEY `idx_status` (`status`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='加速会话表';
-- ============================================================
-- 操作日志表 (operation_logs)
-- ============================================================
CREATE TABLE `operation_logs` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID',
`user_id` BIGINT UNSIGNED DEFAULT NULL COMMENT '用户ID',
`admin_id` BIGINT UNSIGNED DEFAULT NULL COMMENT '管理员ID',
`action` VARCHAR(50) NOT NULL COMMENT '操作类型',
`resource` VARCHAR(50) NOT NULL COMMENT '资源类型',
`resource_id` VARCHAR(50) DEFAULT NULL COMMENT '资源ID',
`detail` JSON DEFAULT NULL COMMENT '详情',
`ip` VARCHAR(45) NOT NULL COMMENT '操作IP',
`user_agent` VARCHAR(255) DEFAULT NULL COMMENT 'UserAgent',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
KEY `idx_user_id` (`user_id`),
KEY `idx_admin_id` (`admin_id`),
KEY `idx_action` (`action`),
KEY `idx_created_at` (`created_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='操作日志表';
```
### 7.1.5 风控相关表
```sql
-- ============================================================
-- 风控事件表 (risk_events)
-- ============================================================
CREATE TABLE `risk_events` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID',
`user_id` BIGINT UNSIGNED NOT NULL COMMENT '用户ID',
`event_type` VARCHAR(30) NOT NULL COMMENT '事件类型：abnormal_login/shared_account/ddos',
`risk_level` TINYINT NOT NULL COMMENT '风险等级：1低 2中 3高',
`detail` JSON DEFAULT NULL COMMENT '详情',
`ip` VARCHAR(45) NOT NULL COMMENT 'IP',
`device_id` VARCHAR(64) DEFAULT NULL COMMENT '设备ID',
`status` TINYINT NOT NULL DEFAULT 0 COMMENT '状态：0待处理 1已处理 2已忽略',
`handle_admin_id` BIGINT UNSIGNED DEFAULT NULL COMMENT '处理管理员ID',
`handle_at` DATETIME DEFAULT NULL COMMENT '处理时间',
`handle_remark` VARCHAR(255) DEFAULT NULL COMMENT '处理备注',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
KEY `idx_user_id` (`user_id`),
KEY `idx_event_type` (`event_type`),
KEY `idx_risk_level` (`risk_level`),
KEY `idx_status` (`status`),
KEY `idx_created_at` (`created_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='风控事件表';
-- ============================================================
-- 黑名单表 (blacklist)
-- ============================================================
CREATE TABLE `blacklist` (
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID',
`type` VARCHAR(20) NOT NULL COMMENT '类型：ip/device/user',
`value` VARCHAR(100) NOT NULL COMMENT '值',
`reason` VARCHAR(255) NOT NULL COMMENT '原因',
`expire_at` DATETIME DEFAULT NULL COMMENT '过期时间',
`admin_id` BIGINT UNSIGNED NOT NULL COMMENT '操作管理员ID',
`created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_type_value` (`type`, `value`),
KEY `idx_expire_at` (`expire_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='黑名单表';
```
### 7.1.6 索引设计说明
```
┌──────────────────────────────────────────────────────────────────┐
│ 索引设计原则 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 1. 主键索引：所有表使用自增BIGINT作为主键 │
│ │
│ 2. 唯一索引： │
│ - 业务唯一标识（uuid, node_id, game_id, order_no等） │
│ - 防止重复数据 │
│ │
│ 3. 普通索引： │
│ - 查询频繁的字段（user_id, status, created_at等） │
│ - 组合索引遵循最左前缀原则 │
│ │
│ 4. 索引优化： │
│ - 避免在频繁更新的列上建索引 │
│ - 控制单表索引数量（不超过5个） │
│ - 使用覆盖索引优化查询 │
│ │
│ 5. 分库分表策略： │
│ ┌──────────────┬──────────────┬──────────────────────────┐ │
│ │ 表名 │ 分表策略 │ 说明 │ │
│ ├──────────────┼──────────────┼──────────────────────────┤ │
│ │ sessions │ 按月分表 │ 数据量大，按月归档 │ │
│ │ speed_tests │ 按月分表 │ 数据量大，按月归档 │ │
│ │ operation_logs│ 按月分表 │ 日志类，按月归档 │ │
│ │ risk_events │ 按季度分表 │ 数据量适中 │ │
│ │ orders │ 按年分表 │ 订单数据，按年归档 │ │
│ │ 其他表 │ 不分表 │ 数据量可控 │ │
│ └──────────────┴──────────────┴──────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 7.2 Redis设计
```
┌──────────────────────────────────────────────────────────────────┐
│ Redis 数据结构设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 1. 用户会话缓存 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: session:{session_id} │ │
│ │ Type: Hash │ │
│ │ Fields: │ │
│ │ user_id: 用户ID │ │
│ │ device_id: 设备ID │ │
│ │ node_id: 节点ID │ │
│ │ game_id: 游戏ID │ │
│ │ start_at: 开始时间 │ │
│ │ status: 状态 │ │
│ │ TTL: 24小时 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 2. 节点状态缓存 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: node:{node_id}:status │ │
│ │ Type: Hash │ │
│ │ Fields: │ │
│ │ load: 当前负载 │ │
│ │ rtt: 平均延迟 │ │
│ │ loss: 丢包率 │ │
│ │ jitter: 抖动 │ │
│ │ score: 评分 │ │
│ │ last_heartbeat: 最后心跳时间 │ │
│ │ TTL: 60秒（心跳超时） │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 3. Token缓存 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: token:{user_id} │ │
│ │ Type: String │ │
│ │ Value: JWT Token │ │
│ │ TTL: 2小时 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 4. 验证码缓存 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: sms:{phone} │ │
│ │ Type: String │ │
│ │ Value: 验证码 │ │
│ │ TTL: 5分钟 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 5. 限流计数器 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: rate:{api}:{ip} │ │
│ │ Type: String (INCR) │ │
│ │ Value: 计数 │ │
│ │ TTL: 1分钟 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 6. 节点评分排行榜 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: nodes:{region}:ranking │ │
│ │ Type: Sorted Set │ │
│ │ Member: node_id │ │
│ │ Score: quality_score │ │
│ │ TTL: 5分钟 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 7. 在线用户统计 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: online:users │ │
│ │ Type: HyperLogLog │ │
│ │ 功能: UV统计（去重计数） │ │
│ │ TTL: 永不过期 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 8. 游戏配置缓存 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Key: game:{game_id}:config │ │
│ │ Type: String (JSON) │ │
│ │ Value: 游戏完整配置 │ │
│ │ TTL: 1小时 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/08-后台管理系统.md
+229
View File
@@ -0,0 +1,229 @@
# 第八部分：后台管理系统
## 8.1 功能模块总览
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 管理后台功能架构 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 管理后台 (Admin Panel) │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 用户管理 │ │ 节点管理 │ │ 游戏管理 │ │ 订单管理 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 套餐管理 │ │ 实时监控 │ │ 告警系统 │ │ 财务统计 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 系统配置 │ │ 权限管理 │ │ 操作日志 │ │ 风控管理 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
## 8.2 页面结构与菜单设计
```
┌──────────────────────────────────────────────────────────────────┐
│ 后台菜单结构 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 📊 仪表盘 (Dashboard) │
│ ├─ 数据概览 │
│ ├─ 实时在线人数 │
│ ├─ 今日收入 │
│ └─ 关键指标趋势 │
│ │
│ 👥 用户管理 (User Management) │
│ ├─ 用户列表 │
│ │ ├─ 搜索/筛选 │
│ │ ├─ 用户详情 │
│ │ ├─ 封禁/解封 │
│ │ └─ 导出 │
│ ├─ 设备管理 │
│ │ ├─ 设备列表 │
│ │ └─ 设备解绑 │
│ └─ 会员管理 │
│ ├─ 会员列表 │
│ ├─ 会员详情 │
│ └─ 手动延期/调整 │
│ │
│ 🖥️ 节点管理 (Node Management) │
│ ├─ 节点列表 │
│ │ ├─ 添加/编辑节点 │
│ │ ├─ 启用/禁用 │
│ │ ├─ 节点详情 │
│ │ └─ 批量操作 │
│ ├─ 线路管理 │
│ │ ├─ 线路列表 │
│ │ ├─ 添加/编辑线路 │
│ │ └─ 线路测试 │
│ ├─ 节点监控 │
│ │ ├─ 实时状态 │
│ │ ├─ 历史趋势 │
│ │ └─ 告警记录 │
│ └─ 节点部署 │
│ ├─ 部署任务 │
│ └─ 部署历史 │
│ │
│ 🎮 游戏管理 (Game Management) │
│ ├─ 游戏列表 │
│ │ ├─ 添加/编辑游戏 │
│ │ ├─ 启用/禁用 │
│ │ └─ 游戏配置 │
│ ├─ 服务器管理 │
│ │ ├─ 服务器列表 │
│ │ └─ 添加/编辑服务器 │
│ └─ 游戏分类 │
│ └─ 分类管理 │
│ │
│ 💰 订单管理 (Order Management) │
│ ├─ 订单列表 │
│ │ ├─ 搜索/筛选 │
│ │ ├─ 订单详情 │
│ │ └─ 导出 │
│ ├─ 支付管理 │
│ │ ├─ 支付记录 │
│ │ └─ 退款管理 │
│ └─ 对账管理 │
│ ├─ 日对账 │
│ └─ 月对账 │
│ │
│ 📦 套餐管理 (Plan Management) │
│ ├─ 套餐列表 │
│ │ ├─ 添加/编辑套餐 │
│ │ ├─ 启用/禁用 │
│ │ └─ 套餐排序 │
│ ├─ 优惠券管理 │
│ │ ├─ 优惠券列表 │
│ │ └─ 创建优惠券 │
│ └─ 促销活动 │
│ └─ 活动管理 │
│ │
│ 📊 实时监控 (Real-time Monitoring) │
│ ├─ 全局概览 │
│ │ ├─ 在线用户地图 │
│ │ ├─ 节点状态地图 │
│ │ └─ 流量实时曲线 │
│ ├─ 节点监控 │
│ │ ├─ 节点列表（实时） │
│ │ └─ 节点详情（实时） │
│ ├─ 用户监控 │
│ │ ├─ 在线用户列表 │
│ │ └─ 用户会话详情 │
│ └─ 告警中心 │
│ ├─ 告警列表 │
│ ├─ 告警规则 │
│ └─ 告警历史 │
│ │
│ 🔔 告警系统 (Alert System) │
│ ├─ 告警规则 │
│ │ ├─ 规则列表 │
│ │ └─ 添加/编辑规则 │
│ ├─ 告警通知 │
│ │ ├─ 通知渠道配置 │
│ │ └─ 通知模板 │
│ └─ 告警历史 │
│ └─ 历史记录 │
│ │
│ 💵 财务统计 (Financial Statistics) │
│ ├─ 收入统计 │
│ │ ├─ 日/周/月/年收入 │
│ │ ├─ 收入趋势 │
│ │ └─ 收入构成 │
│ ├─ 成本统计 │
│ │ ├─ 节点成本 │
│ │ ├─ 带宽成本 │
│ │ └─ 其他成本 │
│ ├─ 利润分析 │
│ │ └─ 盈亏分析 │
│ └─ 报表导出 │
│ └─ 导出功能 │
│ │
│ ⚙️ 系统配置 (System Config) │
│ ├─ 基础配置 │
│ │ ├─ 系统参数 │
│ │ └─ 功能开关 │
│ ├─ 支付配置 │
│ │ ├─ 支付宝配置 │
│ │ ├─ 微信支付配置 │
│ │ └─ Apple Pay配置 │
│ ├─ 推送配置 │
│ │ └─ 推送渠道配置 │
│ └─ 版本管理 │
│ ├─ 客户端版本 │
│ └─ 灰度发布 │
│ │
│ 🔐 权限管理 (Permission Management) │
│ ├─ 管理员列表 │
│ │ ├─ 添加/编辑管理员 │
│ │ └─ 启用/禁用 │
│ ├─ 角色管理 │
│ │ ├─ 角色列表 │
│ │ └─ 权限配置 │
│ └─ 操作日志 │
│ └─ 日志查询 │
│ │
│ 🛡️ 风控管理 (Risk Control) │
│ ├─ 风控事件 │
│ │ ├─ 事件列表 │
│ │ └─ 事件处理 │
│ ├─ 黑名单管理 │
│ │ ├─ IP黑名单 │
│ │ ├─ 设备黑名单 │
│ │ └─ 用户黑名单 │
│ └─ 风控规则 │
│ └─ 规则配置 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 8.3 权限设计
```
┌──────────────────────────────────────────────────────────────────┐
│ RBAC权限模型 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 权限模型：RBAC (Role-Based Access Control) │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 用户 │───→│ 角色 │───→│ 权限 │ │
│ │ (Admin) │ │ (Role) │ │ (Perm) │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 预设角色： │
│ ┌──────────────┬────────────────────────────────────────────┐ │
│ │ 角色 │ 权限范围 │ │
│ ├──────────────┼────────────────────────────────────────────┤ │
│ │ 超级管理员 │ 所有权限 │ │
│ │ 运维管理员 │ 节点管理、监控、告警 │ │
│ │ 客服管理员 │ 用户管理、订单管理 │ │
│ │ 财务管理员 │ 订单管理、财务统计 │ │
│ │ 游戏管理员 │ 游戏管理 │ │
│ │ 只读管理员 │ 仅查看，无操作权限 │ │
│ └──────────────┴────────────────────────────────────────────┘ │
│ │
│ 权限粒度： │
│ - 模块级：如"用户管理" │
│ │ └─ 功能级：如"用户列表"、"用户详情"、"用户编辑" │
│ │ └─ 操作级：如"查看"、"创建"、"编辑"、"删除"、"导出" │
│ │
│ 权限标识： │
│ - user:list:view — 查看用户列表 │
│ - user:list:export — 导出用户列表 │
│ - user:detail:view — 查看用户详情 │
│ - user:detail:edit — 编辑用户 │
│ - user:ban — 封禁用户 │
│ - node:list:view — 查看节点列表 │
│ - node:list:edit — 编辑节点 │
│ - order:list:view — 查看订单列表 │
│ - order:refund — 退款操作 │
│ - ...更多 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/09-监控与运维.md
+146
View File
@@ -0,0 +1,146 @@
# 第九部分：监控与运维
## 9.1 监控架构
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ 监控架构总览 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 数据采集层 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │Prometheus│ │ Filebeat │ │ Loki │ │ Jaeger │ │ │
│ │ │ 指标采集 │ │ 日志采集 │ │ 日志聚合 │ │ 链路追踪 │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ └───────┼──────────────┼──────────────┼──────────────┼─────────────────┘ │
│ │ │ │ │ │
│ ┌───────┼──────────────┼──────────────┼──────────────┼─────────────────┐ │
│ │ ↓ ↓ ↓ ↓ 存储层 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │Prometheus│ │Elastic │ │ Loki │ │ Jaeger │ │ │
│ │ │ TSDB │ │search │ │ Storage │ │ Storage │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ └───────┼──────────────┼──────────────┼──────────────┼─────────────────┘ │
│ │ │ │ │ │
│ ┌───────┼──────────────┼──────────────┼──────────────┼─────────────────┐ │
│ │ ↓ ↓ ↓ ↓ 展示层 │ │
│ │ ┌──────────────────────────────────────────────────────────────┐ │ │
│ │ │ Grafana │ │ │
│ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │
│ │ │ │ 系统面板 │ │ 业务面板 │ │ 日志面板 │ │ 链路面板 │ │ │ │
│ │ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │ │
│ │ └──────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 告警层 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │AlertMana │ │ 企微/钉钉│ │ 短信/电话│ │ │
│ │ │ ger │ │ Webhook │ │ 通知 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
```
## 9.2 监控指标
```
┌──────────────────────────────────────────────────────────────────┐
│ 核心监控指标 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 系统指标（基础设施）： │
│ ┌──────────────┬──────────────┬──────────────┬──────────────┐ │
│ │ 指标 │ 采集方式 │ 频率 │ 告警阈值 │ │
│ ├──────────────┼──────────────┼──────────────┼──────────────┤ │
│ │ CPU使用率 │ node_exporter│ 15秒 │ >80% │ │
│ │ 内存使用率 │ node_exporter│ 15秒 │ >85% │ │
│ │ 磁盘使用率 │ node_exporter│ 15秒 │ >90% │ │
│ │ 磁盘IO │ node_exporter│ 15秒 │ >80% │ │
│ │ 网络带宽 │ node_exporter│ 15秒 │ >80% │ │
│ │ 网络连接数 │ node_exporter│ 15秒 │ >8000 │ │
│ └──────────────┴──────────────┴──────────────┴──────────────┘ │
│ │
│ 业务指标（加速器）： │
│ ┌──────────────┬──────────────┬──────────────┬──────────────┐ │
│ │ 指标 │ 采集方式 │ 频率 │ 告警阈值 │ │
│ ├──────────────┼──────────────┼──────────────┼──────────────┤ │
│ │ 节点在线率 │ 心跳统计 │ 1分钟 │ <95% │ │
│ │ 带宽利用率 │ 流量统计 │ 1分钟 │ >80% │ │
│ │ 用户在线数 │ 会话统计 │ 实时 │ - │ │
│ │ 平均延迟 │ 探测数据 │ 5秒 │ >100ms │ │
│ │ 丢包率 │ 探测数据 │ 10秒 │ >5% │ │
│ │ 加速成功率 │ 会话统计 │ 1分钟 │ <95% │ │
│ │ 掉线率 │ 会话统计 │ 1分钟 │ >5% │ │
│ │ 新用户注册数 │ 业务统计 │ 1小时 │ - │ │
│ │ 支付成功率 │ 支付统计 │ 实时 │ <98% │ │
│ └──────────────┴──────────────┴──────────────┴──────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 9.3 告警规则
```
┌──────────────────────────────────────────────────────────────────┐
│ 告警规则配置 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 告警级别： │
│ ┌──────────┬────────────────────────────────────────────────┐ │
│ │ 级别 │ 说明 │ │
│ ├──────────┼────────────────────────────────────────────────┤ │
│ │ P0-紧急 │ 服务完全不可用，需要立即处理 │ │
│ │ P1-严重 │ 服务部分不可用，需要15分钟内处理 │ │
│ │ P2-警告 │ 服务异常但可用，需要1小时内处理 │ │
│ │ P3-通知 │ 信息性通知，工作时间处理 │ │
│ └──────────┴────────────────────────────────────────────────┘ │
│ │
│ 告警规则示例： │
│ │
│ # P0 - 节点全部离线 │
│ - alert: AllNodesDown │
│ expr: up{job="accelerator-node"} == 0 │
│ for: 1m │
│ labels: │
│ severity: critical │
│ annotations: │
│ summary: "节点 {{ $labels.node }} 离线" │
│ │
│ # P1 - 节点负载过高 │
│ - alert: NodeHighLoad │
│ expr: node_load_rate > 0.8 │
│ for: 5m │
│ labels: │
│ severity: warning │
│ annotations: │
│ summary: "节点 {{ $labels.node }} 负载过高: {{ $value }}" │
│ │
│ # P2 - 延迟过高 │
│ - alert: HighLatency │
│ expr: node_rtt_ms > 100 │
│ for: 5m │
│ labels: │
│ severity: warning │
│ annotations: │
│ summary: "节点 {{ $labels.node }} 延迟过高: {{ $value }}ms"│
│ │
│ # P2 - 丢包率过高 │
│ - alert: HighLossRate │
│ expr: node_loss_rate > 0.05 │
│ for: 3m │
│ labels: │
│ severity: warning │
│ annotations: │
│ summary: "节点 {{ $labels.node }} 丢包率: {{ $value }}" │
│ │
│ 通知渠道： │
│ - P0: 电话 + 短信 + 企微 + 钉钉 │
│ - P1: 短信 + 企微 + 钉钉 │
│ - P2: 企微 + 钉钉 │
│ - P3: 企微 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/10-安全设计.md
+183
View File
@@ -0,0 +1,183 @@
# 第十部分：安全设计
## 10.1 用户认证
```
┌──────────────────────────────────────────────────────────────────┐
│ 用户认证体系 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 认证流程： │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 用户登录 │───→│ 身份验证 │───→│ Token签发│───→│ 返回客户端│ │
│ │ 提交凭证 │ │ 密码校验 │ │ JWT生成 │ │ 缓存Token │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ Token机制（JWT）： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Access Token: │ │
│ │ - 有效期：2小时 │ │
│ │ - 签名算法：RS256 (RSA + SHA256) │ │
│ │ - 包含信息：user_id, device_id, role, exp │ │
│ │ - 存储位置：客户端内存（不持久化） │ │
│ │ │ │
│ │ Refresh Token: │ │
│ │ - 有效期：30天 │ │
│ │ - 存储位置：Redis + 客户端安全存储 │ │
│ │ - 一次性使用（刷新后失效） │ │
│ │ - 支持主动撤销 │ │
│ │ │ │
│ │ Token刷新流程： │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │Access │───→│过期检测│───→│Refresh │───→│新Token │ │ │
│ │ │过期 │ │自动刷新│ │验证 │ │签发 │ │ │
│ │ └────────┘ └────────┘ └────────┘ └────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 密码安全： │
│ - 哈希算法：bcrypt (cost=12) │
│ - 盐值：每个用户独立随机盐值 │
│ - 最小长度：8位 │
│ - 复杂度要求：大小写+数字+特殊字符 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 10.2 设备绑定与防共享
```
┌──────────────────────────────────────────────────────────────────┐
│ 设备绑定与防共享 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 设备指纹生成： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 组合以下信息生成唯一指纹： │ │
│ │ - CPU ID │ │
│ │ - 主板序列号 │ │
│ │ - 硬盘序列号 │ │
│ │ - MAC地址 │ │
│ │ - 操作系统版本 │ │
│ │ - 客户端版本 │ │
│ │ │ │
│ │ 指纹算法：SHA256(组合字符串) │ │
│ │ 指纹格式：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 设备限制策略： │
│ ┌──────────────┬──────────────┬────────────────────────────┐ │
│ │ 套餐类型 │ 设备限制 │ 说明 │ │
│ ├──────────────┼──────────────┼────────────────────────────┤ │
│ │ 免费版 │ 1台 │ 绑定后不可更换 │ │
│ │ 月卡/季卡 │ 2台 │ 可解绑，30天冷却期 │ │
│ │ 年卡 │ 3台 │ 可解绑，30天冷却期 │ │
│ │ 电竞版 │ 5台 │ 可解绑，7天冷却期 │ │
│ └──────────────┴──────────────┴────────────────────────────┘ │
│ │
│ 防共享检测： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 规则1：同时在线检测 │ │
│ │ - 同一账号在不同设备同时在线 │ │
│ │ - 触发条件：不同设备指纹 + 相同账号 + 时间重叠 │ │
│ │ - 处理：通知用户 + 限制新设备登录 │ │
│ │ │ │
│ │ 规则2：异地登录检测 │ │
│ │ - 同一账号在短时间内不同地区登录 │ │
│ │ - 触发条件：城市变化 + 时间<30分钟 │ │
│ │ - 处理：要求二次验证 │ │
│ │ │ │
│ │ 规则3：频繁切换设备 │ │
│ │ - 同一账号频繁在不同设备切换 │ │
│ │ - 触发条件：24小时内切换>3次设备 │ │
│ │ - 处理：冻结账号24小时 + 人工审核 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 10.3 数据加密
```
┌──────────────────────────────────────────────────────────────────┐
│ 数据加密方案 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 传输加密： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 客户端 ←──TLS 1.3──→ API Gateway │ │
│ │ - 证书：Let's Encrypt + 自签证书 │ │
│ │ - 密钥交换：X25519 │ │
│ │ - 加密套件：TLS_AES_256_GCM_SHA384 │ │
│ │ │ │
│ │ 客户端 ←──自定义加密──→ 加速节点 │ │
│ │ - 密钥交换：ECDH (Curve25519) │ │
│ │ - 数据加密：AES-256-GCM │ │
│ │ - 完整性：HMAC-SHA256 │ │
│ │ - 密钥轮换：每24小时 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 存储加密： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 敏感字段加密（应用层）： │ │
│ │ - 手机号：AES-256-GCM 加密存储 │ │
│ │ - 邮箱：AES-256-GCM 加密存储 │ │
│ │ - 支付信息：不存储（支付平台处理） │ │
│ │ │ │
│ │ 数据库加密（存储层）： │ │
│ │ - MySQL TDE (Transparent Data Encryption) │ │
│ │ - 备份文件加密 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 客户端安全： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ - 本地配置加密存储（DPAPI/Keychain） │ │
│ │ - 代码混淆（VMProtect/Themida） │ │
│ │ - 反调试检测 │ │
│ │ - 完整性校验 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 10.4 防DDoS与防作弊
```
┌──────────────────────────────────────────────────────────────────┐
│ 防DDoS与防作弊 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 防DDoS： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 层级1：云服务商防护 │ │
│ │ - 阿里云DDoS防护（10Gbps基础防护） │ │
│ │ - Cloudflare Spectrum（游戏流量防护） │ │
│ │ │ │
│ │ 层级2：接入层防护 │ │
│ │ - SYN Cookie │ │
│ │ - 连接数限制 │ │
│ │ - IP限速 │ │
│ │ │ │
│ │ 层级3：应用层防护 │ │
│ │ - 请求频率限制 │ │
│ │ - 异常流量检测 │ │
│ │ - 自动封禁 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 防作弊： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 1. 加速时长作弊 │ │
│ │ - 服务端计时，不信任客户端 │ │
│ │ - 心跳验证（防止篡改时间） │ │
│ │ │ │
│ │ 2. 流量作弊 │ │
│ │ - 流量统计双端校验 │ │
│ │ - 异常流量检测 │ │
│ │ │ │
│ │ 3. 账号共享 │ │
│ │ - 设备指纹检测 │ │
│ │ - 同时在线限制 │ │
│ │ - 异地登录检测 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/11-商业化设计.md
+214
View File
@@ -0,0 +1,214 @@
# 第十一部分：商业化设计
## 11.1 套餐体系
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 套餐体系设计 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 免费版 │ │
│ │ - 价格：¥0 │ │
│ │ - 设备：1台 │ │
│ │ - 流量：每月10GB │ │
│ │ - 节点：基础节点（国内） │ │
│ │ - 游戏：5款指定游戏 │ │
│ │ - 速度：限速50Mbps │ │
│ │ - 广告：有广告 │ │
│ │ - 目的：获客引流，转化付费 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 月卡 │ │
│ │ - 价格：¥30/月 │ │
│ │ - 设备：2台 │ │
│ │ - 流量：无限 │ │
│ │ - 节点：全节点（国内+海外） │ │
│ │ - 游戏：全游戏支持 │ │
│ │ - 速度：不限速 │ │
│ │ - 广告：无广告 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 季卡（推荐） │ │
│ │ - 价格：¥78/季（¥26/月，8.7折） │ │
│ │ - 设备：2台 │ │
│ │ - 权益：同月卡 │ │
│ │ - 附加：优先客服 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 年卡（超值） │ │
│ │ - 价格：¥238/年（¥19.8/月，6.6折） │ │
│ │ - 设备：3台 │ │
│ │ - 权益：同月卡 │ │
│ │ - 附加：优先客服 + 专属节点 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 电竞版 │ │
│ │ - 价格：¥50/月 │ │
│ │ - 设备：5台 │ │
│ │ - 权益：全节点 + 电竞专线 │ │
│ │ - 特色：最低延迟 + 专属客服 + 掉线补偿 │ │
│ │ - 目标：电竞玩家、职业选手 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 海外版 │ │
│ │ - 价格：$9.99/月 │ │
│ │ - 设备：3台 │ │
│ │ - 节点：全球节点 │ │
│ │ - 特色：优化国际链路 │ │
│ │ - 目标：海外华人、国际玩家 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 企业版 │ │
│ │ - 价格：¥999/月起 │ │
│ │ - 设备：不限 │ │
│ │ - 节点：专属节点 │ │
│ │ - 特色：SLA保障 + 专属技术支持 + API接口 │ │
│ │ - 目标：电竞俱乐部、游戏公司 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
## 11.2 用户增长预测
```
┌──────────────────────────────────────────────────────────────────┐
│ 用户增长预测（3年） │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 假设条件： │
│ - 游戏加速器市场年增长率：15% │
│ - 产品竞争力：中等偏上 │
│ - 营销投入：逐步增加 │
│ │
│ ┌──────────┬──────────┬──────────┬──────────┬──────────┐ │
│ │ 指标 │ 第1年 │ 第2年 │ 第3年 │ 说明 │ │
│ ├──────────┼──────────┼──────────┼──────────┼──────────┤ │
│ │ 注册用户 │ 50,000 │ 200,000 │ 500,000 │ │ │
│ │ 付费用户 │ 5,000 │ 30,000 │ 100,000 │ │ │
│ │ 付费率 │ 10% │ 15% │ 20% │ │ │
│ │ ARPU/月 │ ¥25 │ ¥28 │ ¥30 │ │ │
│ │ DAU │ 2,000 │ 15,000 │ 50,000 │ │ │
│ │ MAU │ 10,000 │ 60,000 │ 200,000 │ │ │
│ │ 留存率 │ 30% │ 40% │ 45% │ 次月留存 │ │
│ └──────────┴──────────┴──────────┴──────────┴──────────┘ │
│ │
│ 增长策略： │
│ 1. 产品打磨期（1-6个月） │
│ │ - 产品上线，积累种子用户 │
│ │ - 通过游戏社区推广 │
│ │ - 目标：1万注册用户 │
│ │ │
│ 2. 口碑传播期（7-12个月） │
│ │ - 用户口碑传播 │
│ │ - KOL合作推广 │
│ │ - 目标：5万注册用户 │
│ │ │
│ 3. 规模增长期（13-24个月） │
│ │ - 加大营销投入 │
│ │ - 渠道合作 │
│ │ - 目标：20万注册用户 │
│ │ │
│ 4. 品牌建设期（25-36个月） │
│ │ - 品牌广告 │
│ │ - 赛事赞助 │
│ │ - 目标：50万注册用户 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 11.3 收入模型
```
┌──────────────────────────────────────────────────────────────────┐
│ 收入模型预测（3年） │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┬──────────────┬──────────────┬──────────────┐ │
│ │ 收入来源 │ 第1年 │ 第2年 │ 第3年 │ │
│ ├──────────┼──────────────┼──────────────┼──────────────┤ │
│ │ 月卡收入 │ ¥360,000 │ ¥2,160,000 │ ¥7,200,000 │ │
│ │ 季卡收入 │ ¥156,000 │ ¥936,000 │ ¥3,120,000 │ │
│ │ 年卡收入 │ ¥238,000 │ ¥1,428,000 │ ¥4,760,000 │ │
│ │ 电竞版 │ ¥60,000 │ ¥360,000 │ ¥1,200,000 │ │
│ │ 海外版 │ ¥36,000 │ ¥360,000 │ ¥1,440,000 │ │
│ │ 企业版 │ ¥0 │ ¥120,000 │ ¥600,000 │ │
│ ├──────────┼──────────────┼──────────────┼──────────────┤ │
│ │ 总收入 │ ¥850,000 │ ¥5,364,000 │ ¥18,320,000 │ │
│ └──────────┴──────────────┴──────────────┴──────────────┘ │
│ │
│ 收入结构（第3年）： │
│ - 月卡：39% │
│ - 季卡：17% │
│ - 年卡：26% │
│ - 电竞版：7% │
│ - 海外版：8% │
│ - 企业版：3% │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 11.4 成本模型
```
┌──────────────────────────────────────────────────────────────────┐
│ 成本模型预测（3年） │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────┬──────────────┬──────────────┬───────────┐ │
│ │ 成本项目 │ 第1年 │ 第2年 │ 第3年 │ │
│ ├──────────────────┼──────────────┼──────────────┼───────────┤ │
│ │ 服务器/带宽 │ ¥2,856,000 │ ¥5,712,000 │ ¥11,424,000│
│ │ 人力成本 │ ¥1,200,000 │ ¥2,400,000 │ ¥4,800,000│
│ │ 营销费用 │ ¥500,000 │ ¥1,500,000 │ ¥3,000,000│
│ │ 办公/其他 │ ¥300,000 │ ¥500,000 │ ¥800,000 │
│ │ 第三方服务 │ ¥200,000 │ ¥400,000 │ ¥800,000 │
│ ├──────────────────┼──────────────┼──────────────┼───────────┤ │
│ │ 总成本 │ ¥5,056,000 │ ¥10,512,000 │ ¥20,824,000│
│ └──────────────────┴──────────────┴──────────────┴───────────┘ │
│ │
│ 成本说明： │
│ - 服务器/带宽：按用户数线性增长，每用户约¥10/月 │
│ - 人力成本：3人→5人→10人 │
│ - 营销费用：逐步增加 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 11.5 盈亏分析
```
┌──────────────────────────────────────────────────────────────────┐
│ 盈亏分析 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┬──────────────┬──────────────┬──────────────┐ │
│ │ 指标 │ 第1年 │ 第2年 │ 第3年 │ │
│ ├──────────┼──────────────┼──────────────┼──────────────┤ │
│ │ 总收入 │ ¥850,000 │ ¥5,364,000 │ ¥18,320,000 │ │
│ │ 总成本 │ ¥5,056,000 │ ¥10,512,000 │ ¥20,824,000 │ │
│ │ 净利润 │ -¥4,206,000 │ -¥5,148,000 │ -¥2,504,000 │ │
│ │ 利润率 │ -495% │ -96% │ -14% │ │
│ └──────────┴──────────────┴──────────────┴──────────────┘ │
│ │
│ 盈亏平衡点分析： │
│ - 月均成本（第3年）：¥1,735,000 │
│ - 月均ARPU：¥30 │
│ - 盈亏平衡付费用户数：57,833 │
│ - 按10%付费率计算：需要578,330注册用户 │
│ - 预计第3年末达到 │
│ │
│ 融资需求： │
│ - 天使轮：¥500万（覆盖第1年亏损+初始投入） │
│ - A轮：¥2000万（覆盖第2年亏损+扩张） │
│ - 预计第3年末实现盈亏平衡 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/12-开发实施计划.md
+228
View File
@@ -0,0 +1,228 @@
# 第十二部分：开发实施计划
## 12.1 团队配置方案
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 团队配置方案 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 3人团队（最小可行）： │
│ ┌──────────────┬──────────────────────────────────────────────────┐ │
│ │ 角色 │ 职责 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 全栈工程师 │ 客户端开发 + 服务端开发 + 部署运维 │ │
│ │ (Tech Lead) │ 技术架构设计 + 核心代码编写 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 后端工程师 │ 服务端开发 + 节点管理 + 数据库 │ │
│ │ │ API开发 + 微服务 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 前端/客户端 │ Windows客户端 + 管理后台 │ │
│ │ 工程师 │ UI/UX + 自动更新 │ │
│ └──────────────┴──────────────────────────────────────────────────┘ │
│ │
│ 5人团队（标准配置）： │
│ ┌──────────────┬──────────────────────────────────────────────────┐ │
│ │ 角色 │ 职责 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 技术负责人 │ 架构设计 + 技术决策 + 代码审查 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 后端工程师×2 │ 服务端开发 + 节点管理 + 调度系统 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 客户端工程师 │ Windows客户端 + macOS客户端 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 前端工程师 │ 管理后台 + 官网 + 用户中心 │ │
│ └──────────────┴──────────────────────────────────────────────────┘ │
│ │
│ 10人团队（完整配置）： │
│ ┌──────────────┬──────────────────────────────────────────────────┐ │
│ │ 角色 │ 职责 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 技术总监 │ 技术战略 + 架构设计 + 团队管理 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 后端工程师×3 │ 核心服务 + 调度系统 + 监控系统 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 客户端工程师 │ Windows + macOS + 移动端 │ │
│ │ ×2 │ 驱动开发 + 跨平台 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 前端工程师×2 │ 管理后台 + 官网 + 用户中心 │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 运维工程师 │ 节点部署 + 监控 + CI/CD │ │
│ ├──────────────┼──────────────────────────────────────────────────┤ │
│ │ 测试工程师 │ 功能测试 + 性能测试 + 安全测试 │ │
│ └──────────────┴──────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
## 12.2 技术栈
```
┌──────────────────────────────────────────────────────────────────┐
│ 技术栈选择 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 客户端： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Windows: │ │
│ │ - 语言：C++ (核心) + C# (UI) │ │
│ │ - UI框架：WPF / WinUI 3 │ │
│ │ - 驱动：WFP Callout Driver (C/C++) │ │
│ │ - 网络：Winsock2 + 自研隧道库 │ │
│ │ - 加密：OpenSSL / libsodium │ │
│ │ - 构建：CMake + MSBuild │ │
│ │ │ │
│ │ macOS: │ │
│ │ - 语言：Swift │ │
│ │ - UI：SwiftUI │ │
│ │ - 网络：Network Extension │ │
│ │ │ │
│ │ 跨平台考虑： │ │
│ │ - 核心网络库：Rust/C++（跨平台编译） │ │
│ │ - UI：原生开发（性能最优） │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 服务端： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 语言：Go (主) + Rust (性能敏感模块) │ │
│ │ 框架：Gin (HTTP) + gRPC (RPC) │ │
│ │ 数据库：MySQL 8.0 + Redis 7.0 + ClickHouse │ │
│ │ 消息队列：Kafka / NATS │ │
│ │ 服务发现：etcd │ │
│ │ 配置中心：Nacos / Apollo │ │
│ │ 容器化：Docker + K3s │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 管理后台： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 框架：React + Ant Design Pro │ │
│ │ 语言：TypeScript │ │
│ │ 构建：Vite │ │
│ │ 图表：ECharts / AntV │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ DevOps： │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ CI/CD：GitHub Actions / GitLab CI │ │
│ │ 容器：Docker + Docker Compose │ │
│ │ 编排：K3s (轻量K8s) │ │
│ │ 监控：Prometheus + Grafana │ │
│ │ 日志：ELK + Loki │ │
│ │ 追踪：Jaeger │ │
│ │ IaC：Terraform + Ansible │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 12.3 开发阶段（甘特图）
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 开发路线图（5人团队，12个月） │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 第一阶段：MVP（第1-4个月） │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 月份 │ 1月 │ 2月 │ 3月 │ 4月 │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 后端 │ ████ │ ████ │ ████ │ ██ │ │
│ │ 用户系统 │ ████████ │ │ │ │ │
│ │ 节点管理 │ │ ████████ │ │ │ │
│ │ 调度系统 │ │ │ ████████ │ ████ │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 客户端 │ ████ │ ████ │ ████ │ ██ │ │
│ │ WFP驱动 │ ████████ │ ████████ │ │ │ │
│ │ 基础UI │ │ ████████ │ ████████ │ │ │
│ │ 隧道模块 │ │ │ ████████ │ ████ │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 运维 │ ██ │ ██ │ ██ │ ██ │ │
│ │ 节点部署 │ ████████ │ │ │ │ │
│ │ 基础监控 │ │ ████████ │ │ │ │
│ │ CI/CD │ │ │ ████████ │ ████ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ MVP交付物：Windows客户端 + 10个节点 + 基础用户系统 + 5款游戏 │
│ │
│ 第二阶段：Beta（第5-8个月） │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 月份 │ 5月 │ 6月 │ 7月 │ 8月 │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 后端 │ ████ │ ████ │ ████ │ ██ │ │
│ │ 支付系统 │ ████████ │ │ │ │ │
│ │ 智能调度 │ │ ████████ │ │ │ │
│ │ 监控告警 │ │ │ ████████ │ ████ │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 客户端 │ ████ │ ████ │ ████ │ ██ │ │
│ │ 智能选路 │ ████████ │ │ │ │ │
│ │ 自动更新 │ │ ████████ │ │ │ │
│ │ 崩溃上报 │ │ │ ████████ │ ████ │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 管理后台 │ ████████ │ ████████ │ ████████ │ ████████ │ │
│ │ 用户管理 │ ████████ │ │ │ │ │
│ │ 节点管理 │ │ ████████ │ │ │ │
│ │ 订单管理 │ │ │ ████████ │ │ │
│ │ 监控面板 │ │ │ │ ████████ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ Beta交付物：完整功能 + 30个节点 + 支付系统 + 管理后台 + 50款游戏 │
│ │
│ 第三阶段：商业版（第9-12个月） │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 月份 │ 9月 │ 10月 │ 11月 │ 12月 │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 后端 │ ████ │ ████ │ ████ │ ██ │ │
│ │ QUIC隧道 │ ████████ │ │ │ │ │
│ │ FEC/多路径│ │ ████████ │ │ │ │
│ │ AI调度 │ │ │ ████████ │ ████ │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 客户端 │ ████ │ ████ │ ████ │ ██ │ │
│ │ macOS │ ████████ │ ████████ │ │ │ │
│ │ 移动端 │ │ ████████ │ ████████ │ │ │
│ │ 优化体验 │ │ │ ████████ │ ████ │ │
│ │ ─────────┼──────────┼──────────┼──────────┼────────── │ │
│ │ 运维 │ ████ │ ████ │ ████ │ ██ │ │
│ │ 全球节点 │ ████████ │ ████████ │ │ │ │
│ │ 安全加固 │ │ ████████ │ ████████ │ │ │
│ │ 性能优化 │ │ │ ████████ │ ████ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ 商业版交付物：全平台 + 60+节点 + 完整商业化 + 200+游戏 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
## 12.4 风险点
```
┌──────────────────────────────────────────────────────────────────┐
│ 风险分析与应对 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┬──────────┬──────────────────────────────────┐ │
│ │ 风险 │ 概率 │ 应对措施 │ │
│ ├──────────────┼──────────┼──────────────────────────────────┤ │
│ │ WFP驱动开发 │ 高 │ 备选WinDivert方案 │ │
│ │ 难度大 │ │ 参考开源项目 │ │
│ │ │ │ 预留2个月buffer │ │
│ ├──────────────┼──────────┼──────────────────────────────────┤ │
│ │ 节点成本超 │ 中 │ 按需扩展，不预购 │ │
│ │ 预算 │ │ 优先使用云服务器 │ │
│ │ │ │ 与云厂商谈合作价 │ │
│ ├──────────────┼──────────┼──────────────────────────────────┤ │
│ │ 游戏兼容性 │ 中 │ 优先支持热门游戏 │ │
│ │ 问题 │ │ 建立游戏兼容性测试体系 │ │
│ │ │ │ 与游戏社区合作测试 │ │
│ ├──────────────┼──────────┼──────────────────────────────────┤ │
│ │ 竞争激烈 │ 高 │ 差异化定位（电竞向） │ │
│ │ │ │ 产品体验优先 │ │
│ │ │ │ 价格策略灵活 │ │
│ ├──────────────┼──────────┼──────────────────────────────────┤ │
│ │ 政策监管 │ 低 │ 合规经营 │ │
│ │ │ │ 取得必要资质 │ │
│ │ │ │ 内容安全审查 │ │
│ ├──────────────┼──────────┼──────────────────────────────────┤ │
│ │ 人才招聘 │ 中 │ 核心岗位提前招聘 │ │
│ │ 困难 │ │ 开源社区寻找 │ │
│ │ │ │ 外包非核心模块 │ │
│ └──────────────┴──────────┴──────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/13-源码级设计.md
+577
View File
@@ -0,0 +1,577 @@
# 第十三部分：源码级设计
## 13.1 项目目录结构
```
game-accelerator/
├── README.md
├── LICENSE
├── Makefile
├── docker-compose.yml
├── .github/
│ └── workflows/
│ ├── ci.yml
│ ├── release.yml
│ └── deploy.yml
│
├── docs/ # 文档
│ ├── architecture.md
│ ├── api.md
│ ├── deployment.md
│ └── contributing.md
│
├── proto/ # Protobuf定义
│ ├── user.proto
│ ├── node.proto
│ ├── dispatch.proto
│ ├── game.proto
│ └── common.proto
│
├── client/ # 客户端
│ ├── windows/ # Windows客户端
│ │ ├── CMakeLists.txt
│ │ ├── src/
│ │ │ ├── main.cpp
│ │ │ ├── core/
│ │ │ │ ├── tunnel.h/cpp # 隧道模块
│ │ │ │ ├── protocol.h/cpp # 协议处理
│ │ │ │ ├── crypto.h/cpp # 加密模块
│ │ │ │ ├── session.h/cpp # 会话管理
│ │ │ │ └── config.h/cpp # 配置管理
│ │ │ ├── capture/
│ │ │ │ ├── wfp_driver.h/cpp # WFP驱动交互
│ │ │ │ ├── traffic_filter.h/cpp # 流量过滤
│ │ │ │ └── game_detect.h/cpp # 游戏检测
│ │ │ ├── network/
│ │ │ │ ├── udp_relay.h/cpp # UDP转发
│ │ │ │ ├── quic_tunnel.h/cpp # QUIC隧道
│ │ │ │ ├── fec.h/cpp # 前向纠错
│ │ │ │ └── multipath.h/cpp # 多路径
│ │ │ ├── scheduler/
│ │ │ │ ├── node_selector.h/cpp # 节点选择
│ │ │ │ ├── speed_test.h/cpp # 测速
│ │ │ │ └── auto_switch.h/cpp # 自动切换
│ │ │ └── ui/
│ │ │ ├── main_window.h/cpp # 主窗口
│ │ │ ├── login_dialog.h/cpp # 登录对话框
│ │ │ ├── game_list.h/cpp # 游戏列表
│ │ │ └── settings.h/cpp # 设置页面
│ │ ├── driver/ # WFP驱动
│ │ │ ├── driver.c
│ │ │ ├── callout.c
│ │ │ ├── filter.c
│ │ │ └── utils.c
│ │ └── resources/
│ │ ├── icons/
│ │ └── strings/
│ │
│ ├── macos/ # macOS客户端
│ │ ├── Package.swift
│ │ ├── Sources/
│ │ │ ├── Accelerator/
│ │ │ │ ├── Core/
│ │ │ │ ├── Network/
│ │ │ │ └── UI/
│ │ │ └── NetworkExtension/
│ │ └── Tests/
│ │
│ ├── android/ # Android客户端
│ │ ├── build.gradle.kts
│ │ ├── app/
│ │ │ └── src/
│ │ │ └── main/
│ │ │ ├── java/
│ │ │ │ └── com/accelerator/
│ │ │ │ ├── core/
│ │ │ │ ├── vpn/
│ │ │ │ ├── ui/
│ │ │ │ └── service/
│ │ │ └── res/
│ │ └── build.gradle.kts
│ │
│ └── ios/ # iOS客户端
│ ├── Accelerator.xcodeproj
│ ├── Accelerator/
│ │ ├── Core/
│ │ ├── Network/
│ │ └── UI/
│ └── PacketTunnel/
│
├── server/ # 服务端
│ ├── go.mod
│ ├── go.sum
│ ├── cmd/ # 入口
│ │ ├── api-gateway/ # API网关
│ │ │ └── main.go
│ │ ├── user-service/ # 用户服务
│ │ │ └── main.go
│ │ ├── order-service/ # 订单服务
│ │ │ └── main.go
│ │ ├── node-service/ # 节点服务
│ │ │ └── main.go
│ │ ├── dispatch-service/ # 调度服务
│ │ │ └── main.go
│ │ ├── game-service/ # 游戏服务
│ │ │ └── main.go
│ │ ├── relay-service/ # 转发服务
│ │ │ └── main.go
│ │ └── monitor-service/ # 监控服务
│ │ └── main.go
│ │
│ ├── internal/ # 内部包
│ │ ├── model/ # 数据模型
│ │ │ ├── user.go
│ │ │ ├── node.go
│ │ │ ├── order.go
│ │ │ ├── game.go
│ │ │ └── session.go
│ │ ├── repository/ # 数据访问层
│ │ │ ├── mysql/
│ │ │ │ ├── user_repo.go
│ │ │ │ ├── node_repo.go
│ │ │ │ └── order_repo.go
│ │ │ └── redis/
│ │ │ ├── cache.go
│ │ │ └── session.go
│ │ ├── service/ # 业务逻辑层
│ │ │ ├── auth/
│ │ │ │ ├── auth.go
│ │ │ │ ├── jwt.go
│ │ │ │ └── password.go
│ │ │ ├── user/
│ │ │ │ ├── user.go
│ │ │ │ └── device.go
│ │ │ ├── node/
│ │ │ │ ├── node.go
│ │ │ │ ├── health.go
│ │ │ │ └── discovery.go
│ │ │ ├── dispatch/
│ │ │ │ ├── scheduler.go
│ │ │ │ ├── scorer.go
│ │ │ │ └── router.go
│ │ │ ├── order/
│ │ │ │ ├── order.go
│ │ │ │ └── payment.go
│ │ │ └── relay/
│ │ │ ├── udp_relay.go
│ │ │ ├── quic_tunnel.go
│ │ │ └── fec.go
│ │ ├── handler/ # HTTP/RPC处理器
│ │ │ ├── http/
│ │ │ │ ├── user_handler.go
│ │ │ │ ├── node_handler.go
│ │ │ │ └── order_handler.go
│ │ │ └── grpc/
│ │ │ ├── dispatch_handler.go
│ │ │ └── node_handler.go
│ │ ├── middleware/ # 中间件
│ │ │ ├── auth.go
│ │ │ ├── rate_limit.go
│ │ │ ├── cors.go
│ │ │ └── logger.go
│ │ ├── config/ # 配置
│ │ │ └── config.go
│ │ └── pkg/ # 公共包
│ │ ├── crypto/
│ │ │ ├── aes.go
│ │ │ └── ecdh.go
│ │ ├── network/
│ │ │ ├── bbr.go
│ │ │ └── fec.go
│ │ └── utils/
│ │ ├── ip.go
│ │ └── geo.go
│ │
│ └── migrations/ # 数据库迁移
│ ├── 001_users.up.sql
│ ├── 001_users.down.sql
│ ├── 002_nodes.up.sql
│ └── ...
│
├── admin/ # 管理后台
│ ├── package.json
│ ├── tsconfig.json
│ ├── vite.config.ts
│ ├── src/
│ │ ├── App.tsx
│ │ ├── main.tsx
│ │ ├── pages/
│ │ │ ├── Dashboard/
│ │ │ ├── Users/
│ │ │ ├── Nodes/
│ │ │ ├── Games/
│ │ │ ├── Orders/
│ │ │ ├── Monitoring/
│ │ │ └── Settings/
│ │ ├── components/
│ │ │ ├── Layout/
│ │ │ ├── Charts/
│ │ │ └── Common/
│ │ ├── services/
│ │ │ ├── api.ts
│ │ │ ├── user.ts
│ │ │ ├── node.ts
│ │ │ └── order.ts
│ │ ├── stores/
│ │ │ ├── auth.ts
│ │ │ └── app.ts
│ │ └── utils/
│ │ ├── request.ts
│ │ └── auth.ts
│ └── public/
│
├── deploy/ # 部署配置
│ ├── docker/
│ │ ├── Dockerfile.api-gateway
│ │ ├── Dockerfile.user-service
│ │ ├── Dockerfile.relay-service
│ │ └── ...
│ ├── k8s/
│ │ ├── namespace.yaml
│ │ ├── configmap.yaml
│ │ ├── secrets.yaml
│ │ ├── deployments/
│ │ │ ├── api-gateway.yaml
│ │ │ ├── user-service.yaml
│ │ │ └── ...
│ │ ├── services/
│ │ └── ingress/
│ ├── terraform/
│ │ ├── main.tf
│ │ ├── variables.tf
│ │ ├── outputs.tf
│ │ └── modules/
│ │ ├── alicloud/
│ │ ├── aws/
│ │ └── gcp/
│ └── ansible/
│ ├── playbooks/
│ └── roles/
│
├── scripts/ # 脚本
│ ├── build.sh
│ ├── deploy.sh
│ ├── test.sh
│ └── seed_data.sh
│
└── test/ # 测试
├── unit/
├── integration/
├── e2e/
└── performance/
```
## 13.2 核心模块接口定义
### 13.2.1 用户服务接口
```go
// server/internal/service/user/user.go
package user
import (
"context"
"time"
)
// Service 用户服务接口
type Service interface {
// Register 用户注册
Register(ctx context.Context, req *RegisterRequest) (*RegisterResponse, error)
// Login 用户登录
Login(ctx context.Context, req *LoginRequest) (*LoginResponse, error)
// Logout 用户登出
Logout(ctx context.Context, userID uint64) error
// RefreshToken 刷新Token
RefreshToken(ctx context.Context, refreshToken string) (*TokenPair, error)
// GetProfile 获取用户信息
GetProfile(ctx context.Context, userID uint64) (*UserProfile, error)
// UpdateProfile 更新用户信息
UpdateProfile(ctx context.Context, userID uint64, req *UpdateProfileRequest) error
// ChangePassword 修改密码
ChangePassword(ctx context.Context, userID uint64, req *ChangePasswordRequest) error
// BindDevice 绑定设备
BindDevice(ctx context.Context, userID uint64, device *DeviceInfo) error
// UnbindDevice 解绑设备
UnbindDevice(ctx context.Context, userID uint64, deviceID string) error
// GetDevices 获取设备列表
GetDevices(ctx context.Context, userID uint64) ([]*DeviceInfo, error)
}
// RegisterRequest 注册请求
type RegisterRequest struct {
Phone string `json:"phone" validate:"required"`
Password string `json:"password" validate:"required,min=8"`
Code string `json:"code" validate:"required"` // 验证码
}
// LoginRequest 登录请求
type LoginRequest struct {
Phone string `json:"phone"`
Email string `json:"email"`
Password string `json:"password" validate:"required"`
DeviceID string `json:"device_id" validate:"required"`
}
// LoginResponse 登录响应
type LoginResponse struct {
AccessToken string `json:"access_token"`
RefreshToken string `json:"refresh_token"`
ExpiresIn int64 `json:"expires_in"`
User *UserProfile `json:"user"`
}
// TokenPair Token对
type TokenPair struct {
AccessToken string `json:"access_token"`
RefreshToken string `json:"refresh_token"`
ExpiresIn int64 `json:"expires_in"`
}
// UserProfile 用户信息
type UserProfile struct {
ID uint64 `json:"id"`
UUID string `json:"uuid"`
Phone string `json:"phone"`
Email string `json:"email"`
Nickname string `json:"nickname"`
Avatar string `json:"avatar"`
Status int `json:"status"`
CreatedAt time.Time `json:"created_at"`
}
// DeviceInfo 设备信息
type DeviceInfo struct {
DeviceID string `json:"device_id"`
DeviceName string `json:"device_name"`
DeviceType string `json:"device_type"`
OSVersion string `json:"os_version"`
LastActive time.Time `json:"last_active"`
}
```
### 13.2.2 调度服务接口
```go
// server/internal/service/dispatch/dispatch.go
package dispatch
import (
"context"
)
// Service 调度服务接口
type Service interface {
// GetBestNode 获取最优节点
GetBestNode(ctx context.Context, req *DispatchRequest) (*NodeInfo, error)
// GetNodeList 获取节点列表
GetNodeList(ctx context.Context, req *NodeListRequest) (*NodeListResponse, error)
// ReportQuality 上报链路质量
ReportQuality(ctx context.Context, report *QualityReport) error
// GetRoute 获取路由路径
GetRoute(ctx context.Context, req *RouteRequest) (*RouteInfo, error)
// SwitchNode 切换节点
SwitchNode(ctx context.Context, sessionID string, newNodeID string) error
}
// DispatchRequest 调度请求
type DispatchRequest struct {
UserID uint64 `json:"user_id"`
GameID string `json:"game_id"`
ServerIP string `json:"server_ip"`
UserIP string `json:"user_ip"`
UserISP string `json:"user_isp"`
UserCity string `json:"user_city"`
Protocol string `json:"protocol"`
}
// NodeInfo 节点信息
type NodeInfo struct {
NodeID string `json:"node_id"`
Name string `json:"name"`
IP string `json:"ip"`
Port int `json:"port"`
Region string `json:"region"`
City string `json:"city"`
ISP string `json:"isp"`
Score float64 `json:"score"`
RTT float64 `json:"rtt"`
LossRate float64 `json:"loss_rate"`
LoadRate float64 `json:"load_rate"`
Protocol string `json:"protocol"`
}
// QualityReport 质量报告
type QualityReport struct {
UserID uint64 `json:"user_id"`
SessionID string `json:"session_id"`
NodeID string `json:"node_id"`
RTT float64 `json:"rtt"`
LossRate float64 `json:"loss_rate"`
Jitter float64 `json:"jitter"`
Timestamp int64 `json:"timestamp"`
}
// RouteInfo 路由信息
type RouteInfo struct {
AccessNode *NodeInfo `json:"access_node"`
RelayNodes []*NodeInfo `json:"relay_nodes"`
ExitNode *NodeInfo `json:"exit_node"`
Protocol string `json:"protocol"`
TotalRTT float64 `json:"total_rtt"`
}
```
### 13.2.3 RPC定义
```protobuf
// proto/dispatch.proto
syntax = "proto3";
package dispatch;
option go_package = "github.com/accelerator/proto/dispatch";
// 调度服务
service DispatchService {
// 获取最优节点
rpc GetBestNode (DispatchRequest) returns (DispatchResponse);
// 获取节点列表
rpc GetNodeList (NodeListRequest) returns (NodeListResponse);
// 上报质量
rpc ReportQuality (QualityReport) returns (QualityReportResponse);
// 获取路由
rpc GetRoute (RouteRequest) returns (RouteResponse);
// 切换节点
rpc SwitchNode (SwitchNodeRequest) returns (SwitchNodeResponse);
}
message DispatchRequest {
uint64 user_id = 1;
string game_id = 2;
string server_ip = 3;
string user_ip = 4;
string user_isp = 5;
string user_city = 6;
string protocol = 7;
}
message DispatchResponse {
NodeInfo node = 1;
repeated NodeInfo backup_nodes = 2;
RouteInfo route = 3;
}
message NodeInfo {
string node_id = 1;
string name = 2;
string ip = 3;
int32 port = 4;
string region = 5;
string city = 6;
string isp = 7;
double score = 8;
double rtt = 9;
double loss_rate = 10;
double load_rate = 11;
}
message RouteInfo {
NodeInfo access_node = 1;
repeated NodeInfo relay_nodes = 2;
NodeInfo exit_node = 3;
string protocol = 4;
double total_rtt = 5;
}
message QualityReport {
uint64 user_id = 1;
string session_id = 2;
string node_id = 3;
double rtt = 4;
double loss_rate = 5;
double jitter = 6;
int64 timestamp = 7;
}
message QualityReportResponse {
bool success = 1;
}
message NodeListRequest {
string region = 1;
string game_id = 2;
int32 page = 3;
int32 page_size = 4;
}
message NodeListResponse {
repeated NodeInfo nodes = 1;
int32 total = 2;
}
message SwitchNodeRequest {
string session_id = 1;
string new_node_id = 2;
}
message SwitchNodeResponse {
bool success = 1;
NodeInfo new_node = 2;
}
```
## 13.3 消息队列设计
```
┌──────────────────────────────────────────────────────────────────┐
│ Kafka Topic 设计 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ Topic列表： │
│ ┌────────────────────┬──────────┬──────────────────────────┐ │
│ │ Topic │ 分区数 │ 说明 │ │
│ ├────────────────────┼──────────┼──────────────────────────┤ │
│ │ user.events │ 6 │ 用户事件（登录/注册等） │ │
│ │ order.events │ 6 │ 订单事件（创建/支付等） │ │
│ │ session.events │ 12 │ 会话事件（开始/结束等） │ │
│ │ quality.reports │ 12 │ 链路质量报告 │ │
│ │ node.events │ 6 │ 节点事件（上线/下线等） │ │
│ │ risk.events │ 3 │ 风控事件 │ │
│ │ log.events │ 12 │ 日志事件 │ │
│ └────────────────────┴──────────┴──────────────────────────┘ │
│ │
│ 消息格式（JSON）： │
│ { │
│ "event_id": "uuid", │
│ "event_type": "user.login", │
│ "timestamp": 1717651200, │
│ "source": "user-service", │
│ "data": { ... } │
│ } │
│ │
│ 消费者组： │
│ - user-service-group: 消费user.events │
│ - order-service-group: 消费order.events │
│ - monitor-group: 消费所有事件（监控用） │
│ - analytics-group: 消费所有事件（分析用） │
│ │
└──────────────────────────────────────────────────────────────────┘
```
game-accelerator-tech-plan/14-最终输出.md
+185
View File
@@ -0,0 +1,185 @@
# 第十四部分：最终输出
## 14.1 方案总结
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 技术方案总结 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 本方案覆盖了从0到1打造商业级网游加速器的完整技术体系，共14个部分： │
│ │
│ ✅ 第一部分：行业分析 — 加速器工作原理、主流架构、真实链路案例 │
│ ✅ 第二部分：整体系统架构 — 客户端+服务端微服务+数据层完整架构 │
│ ✅ 第三部分：核心网络架构 — 三层节点体系+全球节点规划+部署方案 │
│ ✅ 第四部分：流量转发系统 — UDP Relay→QUIC Tunnel演进路径 │
│ ✅ 第五部分：客户端开发 — WFP驱动+游戏识别+智能选路完整设计 │
│ ✅ 第六部分：智能调度系统 — 基础/高级/AI三级调度算法 │
│ ✅ 第七部分：数据库设计 — MySQL+Redis完整表结构和索引设计 │
│ ✅ 第八部分：后台管理系统 — 12个功能模块+RBAC权限设计 │
│ ✅ 第九部分：监控与运维 — Prometheus+Grafana+ELK+Jaeger完整方案 │
│ ✅ 第十部分：安全设计 — 认证/加密/防DDoS/防作弊完整方案 │
│ ✅ 第十一部分：商业化设计 — 7种套餐+增长预测+收入成本模型 │
│ ✅ 第十二部分：开发实施计划 — 3/5/10人团队+12个月路线图 │
│ ✅ 第十三部分：源码级设计 — 完整目录结构+接口定义+RPC+MQ设计 │
│ ✅ 第十四部分：最终输出 — 本总结 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
## 14.2 关键技术指标
```
┌──────────────────────────────────────────────────────────────────┐
│ 关键技术指标 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 性能指标： │
│ ┌──────────────────┬────────────────────────────────────────┐ │
│ │ 指标 │ 目标值 │ │
│ ├──────────────────┼────────────────────────────────────────┤ │
│ │ 加速延迟 │ 国内<50ms, 亚洲<100ms, 全球<200ms │ │
│ │ 丢包率 │ <1% │ │
│ │ 抖动 │ <10ms │ │
│ │ 连接建立时间 │ <500ms │ │
│ │ 切换延迟 │ <200ms │ │
│ │ 单节点并发 │ 10,000+ │ │
│ │ 单节点带宽 │ 10Gbps │ │
│ └──────────────────┴────────────────────────────────────────┘ │
│ │
│ 可用性指标： │
│ ┌──────────────────┬────────────────────────────────────────┐ │
│ │ 指标 │ 目标值 │ │
│ ├──────────────────┼────────────────────────────────────────┤ │
│ │ 服务可用性 │ 99.9% │ │
│ │ 节点在线率 │ 99.5% │ │
│ │ API响应时间 │ <100ms (P99) │ │
│ │ 故障恢复时间 │ <5分钟 │ │
│ └──────────────────┴────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 14.3 成本预算总结
```
┌──────────────────────────────────────────────────────────────────┐
│ 成本预算总结 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 初始投入（第1年）： │
│ ┌──────────────────┬────────────────────────────────────────┐ │
│ │ 项目 │ 金额 │ │
│ ├──────────────────┼────────────────────────────────────────┤ │
│ │ 服务器/带宽 │ ¥2,856,000 │ │
│ │ 人力成本 │ ¥1,200,000 │ │
│ │ 营销费用 │ ¥500,000 │ │
│ │ 办公/其他 │ ¥300,000 │ │
│ │ 第三方服务 │ ¥200,000 │ │
│ ├──────────────────┼────────────────────────────────────────┤ │
│ │ 总计 │ ¥5,056,000 │ │
│ └──────────────────┴────────────────────────────────────────┘ │
│ │
│ 融资需求： │
│ - 天使轮：¥500万（覆盖第1年+初始投入） │
│ - A轮：¥2000万（覆盖第2年+扩张） │
│ - 预计第3年末盈亏平衡 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 14.4 风险与建议
```
┌──────────────────────────────────────────────────────────────────┐
│ 核心风险与建议 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 1. 技术风险 │
│ 风险：WFP驱动开发难度大 │
│ 建议：备选WinDivert方案，参考开源项目 │
│ │
│ 2. 成本风险 │
│ 风险：节点成本超预算 │
│ 建议：按需扩展，与云厂商谈合作价 │
│ │
│ 3. 竞争风险 │
│ 风险：市场竞争激烈 │
│ 建议：差异化定位（电竞向），产品体验优先 │
│ │
│ 4. 合规风险 │
│ 风险：政策监管 │
│ 建议：合规经营，取得必要资质 │
│ │
│ 5. 人才风险 │
│ 风险：核心人才招聘困难 │
│ 建议：核心岗位提前招聘，开源社区寻找 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## 14.5 下一步行动
```
┌──────────────────────────────────────────────────────────────────┐
│ 下一步行动建议 │
├──────────────────────────────────────────────────────────────────┤
│ │
│ 第1周： │
│ □ 确认技术方案细节 │
│ □ 搭建开发环境 │
│ □ 初始化代码仓库 │
│ │
│ 第2-4周： │
│ □ 完成用户系统开发 │
│ □ 完成节点管理系统 │
│ □ 部署第一批节点（3-5个） │
│ │
│ 第2-3月： │
│ □ 完成Windows客户端核心功能 │
│ □ 完成WFP驱动开发 │
│ □ 完成基础调度系统 │
│ │
│ 第4月： │
│ □ MVP版本发布 │
│ □ 邀请种子用户测试 │
│ □ 收集反馈并优化 │
│ │
│ 第5-8月： │
│ □ 完成支付系统 │
│ □ 完成管理后台 │
│ □ 扩展到30个节点 │
│ □ Beta版本发布 │
│ │
│ 第9-12月： │
│ □ 完成QUIC隧道 │
│ □ 完成macOS/移动端 │
│ □ 扩展到60+节点 │
│ □ 正式商业发布 │
│ │
└──────────────────────────────────────────────────────────────────┘
```
---
> 📌 **文档说明**
>
> 本技术方案由小龙生成，共14个部分，覆盖游戏加速器从0到1的完整技术体系。
>
> 所有文件位于：`/Users/a1234/.openclaw/workspace/game-accelerator-tech-plan/`
>
> 文件列表：
> - 01-行业分析.md
> - 02-整体系统架构设计.md
> - 03-核心网络架构.md
> - 04-流量转发系统设计.md
> - 05-客户端开发方案.md
> - 06-智能调度系统.md
> - 07-数据库设计.md
> - 08-后台管理系统.md
> - 09-监控与运维.md
> - 10-安全设计.md
> - 11-商业化设计.md
> - 12-开发实施计划.md
> - 13-源码级设计.md
> - 14-最终输出.md