diff --git a/game-accelerator-tech-plan/01-行业分析.md b/game-accelerator-tech-plan/01-行业分析.md new file mode 100644 index 0000000..3a06c3e --- /dev/null +++ b/game-accelerator-tech-plan/01-行业分析.md @@ -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. 云原生架构 — 节点容器化，弹性伸缩 +``` diff --git a/game-accelerator-tech-plan/02-整体系统架构设计.md b/game-accelerator-tech-plan/02-整体系统架构设计.md new file mode 100644 index 0000000..e3ea706 --- /dev/null +++ b/game-accelerator-tech-plan/02-整体系统架构设计.md @@ -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); +} +``` diff --git a/game-accelerator-tech-plan/03-核心网络架构.md b/game-accelerator-tech-plan/03-核心网络架构.md new file mode 100644 index 0000000..bb0b98a --- /dev/null +++ b/game-accelerator-tech-plan/03-核心网络架构.md @@ -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/月 │ +│ │ +└─────────────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/04-流量转发系统设计.md b/game-accelerator-tech-plan/04-流量转发系统设计.md new file mode 100644 index 0000000..f33cc45 --- /dev/null +++ b/game-accelerator-tech-plan/04-流量转发系统设计.md @@ -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恢复会话状态 │ +│ - 序列号连续（不因切换而重置） │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/05-客户端开发方案.md b/game-accelerator-tech-plan/05-客户端开发方案.md new file mode 100644 index 0000000..4069953 --- /dev/null +++ b/game-accelerator-tech-plan/05-客户端开发方案.md @@ -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审核相对宽松 │ │ +│ │ │ │ +│ │ 适用游戏： │ │ +│ │ - 手游（全品类） │ │ +│ │ - 云游戏 │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/06-智能调度系统.md b/game-accelerator-tech-plan/06-智能调度系统.md new file mode 100644 index 0000000..b436ce2 --- /dev/null +++ b/game-accelerator-tech-plan/06-智能调度系统.md @@ -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%用户使用高级调度 │ +│ - 对比指标：延迟、丢包率、用户满意度 │ +│ - 显著提升后全量切换 │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/07-数据库设计.md b/game-accelerator-tech-plan/07-数据库设计.md new file mode 100644 index 0000000..50f9122 --- /dev/null +++ b/game-accelerator-tech-plan/07-数据库设计.md @@ -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小时 │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/08-后台管理系统.md b/game-accelerator-tech-plan/08-后台管理系统.md new file mode 100644 index 0000000..0294210 --- /dev/null +++ b/game-accelerator-tech-plan/08-后台管理系统.md @@ -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 — 退款操作 │ +│ - ...更多 │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/09-监控与运维.md b/game-accelerator-tech-plan/09-监控与运维.md new file mode 100644 index 0000000..b665399 --- /dev/null +++ b/game-accelerator-tech-plan/09-监控与运维.md @@ -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: 企微 │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/10-安全设计.md b/game-accelerator-tech-plan/10-安全设计.md new file mode 100644 index 0000000..2a2dffa --- /dev/null +++ b/game-accelerator-tech-plan/10-安全设计.md @@ -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. 账号共享 │ │ +│ │ - 设备指纹检测 │ │ +│ │ - 同时在线限制 │ │ +│ │ - 异地登录检测 │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/11-商业化设计.md b/game-accelerator-tech-plan/11-商业化设计.md new file mode 100644 index 0000000..9425f70 --- /dev/null +++ b/game-accelerator-tech-plan/11-商业化设计.md @@ -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年末实现盈亏平衡 │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/12-开发实施计划.md b/game-accelerator-tech-plan/12-开发实施计划.md new file mode 100644 index 0000000..2974c2c --- /dev/null +++ b/game-accelerator-tech-plan/12-开发实施计划.md @@ -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 │ │ +│ ├──────────────┼──────────┼──────────────────────────────────┤ │ +│ │ 节点成本超 │ 中 │ 按需扩展，不预购 │ │ +│ │ 预算 │ │ 优先使用云服务器 │ │ +│ │ │ │ 与云厂商谈合作价 │ │ +│ ├──────────────┼──────────┼──────────────────────────────────┤ │ +│ │ 游戏兼容性 │ 中 │ 优先支持热门游戏 │ │ +│ │ 问题 │ │ 建立游戏兼容性测试体系 │ │ +│ │ │ │ 与游戏社区合作测试 │ │ +│ ├──────────────┼──────────┼──────────────────────────────────┤ │ +│ │ 竞争激烈 │ 高 │ 差异化定位（电竞向） │ │ +│ │ │ │ 产品体验优先 │ │ +│ │ │ │ 价格策略灵活 │ │ +│ ├──────────────┼──────────┼──────────────────────────────────┤ │ +│ │ 政策监管 │ 低 │ 合规经营 │ │ +│ │ │ │ 取得必要资质 │ │ +│ │ │ │ 内容安全审查 │ │ +│ ├──────────────┼──────────┼──────────────────────────────────┤ │ +│ │ 人才招聘 │ 中 │ 核心岗位提前招聘 │ │ +│ │ 困难 │ │ 开源社区寻找 │ │ +│ │ │ │ 外包非核心模块 │ │ +│ └──────────────┴──────────┴──────────────────────────────────┘ │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/13-源码级设计.md b/game-accelerator-tech-plan/13-源码级设计.md new file mode 100644 index 0000000..07f71ba --- /dev/null +++ b/game-accelerator-tech-plan/13-源码级设计.md @@ -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: 消费所有事件（分析用） │ +│ │ +└──────────────────────────────────────────────────────────────────┘ +``` diff --git a/game-accelerator-tech-plan/14-最终输出.md b/game-accelerator-tech-plan/14-最终输出.md new file mode 100644 index 0000000..27ec623 --- /dev/null +++ b/game-accelerator-tech-plan/14-最终输出.md @@ -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