diff --git a/CLAUDE.md b/CLAUDE.md index 591d80e..64dd4e5 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -113,7 +113,7 @@ rust/ | crate | 模块 | 键空间 | | --- | --- | --- | | `plugin-domain` | `domains`(申请/审批/写穿)、`resolve`(ResolveHandler + `$proxy_backend_addr`)、`api`、`config/models/store` | `sub:` | -| `plugin-llm` | `llm`(slot 解析/变量求值)、`upstreams`(CRUD/写穿/健康)、`usage_filter`(body filter 抓 usage,走 `loc::enabled`+`ctx_index`)、`llm_audit`(对话审计落盘)、`stats`(用量账本+趋势)、`handlers`(Llm/LlmHealth/Audit)、`api`、`config/models/store` | `up:` `uh:` `ust:` `ums:` `utt:` `utms:` `ud:` `udu:` `uds:` | +| `plugin-llm` | `llm`(slot 解析/变量求值)、`upstreams`(CRUD/写穿/健康/**多账号路由**/账号负载)、`usage_filter`(body filter 抓 usage+耗尽 marker,走 `loc::enabled`+`ctx_index`)、`llm_audit`(对话审计落盘)、`stats`(用量账本+趋势)、`handlers`(Llm/LlmHealth/Audit)、`api`、`config/models/store` | `up:` `upa:` `uac:` `ukb:` `upe:` `uh:` `ust:` `ums:` `utt:` `utms:` `ud:` `udu:` `uds:` `uda:` `uex:` | | `plugin-apix` | `apix`(slug/拼体/写穿)、`handlers`(ApiProxyHandler)、`api`、`config/models/store` | `ax:` | gateway 只剩:模块壳(7 条指令 + `ModuleConfig` 开关 + 变量/装载装配循环)、 @@ -192,7 +192,7 @@ POST /openai/v1/chat/completions Authorization: Bearer sk_<本网关签 | 位置 | 职责 | | --- | --- | | `crates/plugin-llm/src/llm.rs` | 热路径:slot 解析、Bearer 提取、身份查询、OpenAI 兼容错误体、三个变量的 get_handler | -| `crates/plugin-llm/src/upstreams.rs` | 上游校验/读写/写穿共享内存,是域名插件在 LLM 侧的翻版;`models` 登记 + `available()` / `models_flat()` 模型发现 | +| `crates/plugin-llm/src/upstreams.rs` | 上游校验/读写/写穿共享内存,是域名插件在 LLM 侧的翻版;`models` 登记 + `available()` / `models_flat()` 模型发现;**多账号路由**(`pick_account` 粘性 + FNV-1a 冷分散 + 天锚定冷却 `cool_until_until`)与**账号级负载**(`uda:`/`uex:` 日桶,`view()` 投影) | | `crates/plugin-llm/src/stats.rs` | 用量账本(`ust:` 每账号 / `ums:` 每账号×上游,请求级、只读 shm)与 `overview()` 投影;**唯一写点在 `LlmHandler` 鉴权全通过之后** | | `data/llm-upstreams.json` | 上游表(**含真实密钥**);`base` 可带路径,`auth` 是完整的 Authorization 值,`models` 仅供模型发现 | | `conf/nginx.conf` | `lm.mayishangshu.cn:18098` server;SSE 三件套 + `proxy_ssl_server_name` | @@ -262,12 +262,15 @@ location 与 80 端口 LLM server 是两份拷贝,改一处记得同步另一 | `/v1/models` 反而 404 | `is_models_probe` 的位置错了:**必须在解析 slot 之前**,否则被当成 `slot=v1` | | 用量一直是 0 | 被拒的请求(401/403/404/429)**不计用量**;或 `stats::record` 被挪出了"鉴权全通过之后" | | 删了账号还在用量榜上 | 没调 `stats::forget`(清 `ust:` / `ums:` 前缀) | +| 账号负载数是真实值的 3 倍 | `bump_acct_load` 被放进了 `pick_account` —— `$llm_target`/`$llm_auth`/`$llm_acct` 三个变量各触发一次。**只能在 log 阶段记一次** | +| 某把 Key 耗尽后一直在冷却 / 迟迟不恢复 | `resets` 填成滚动时长(`now+5h`)而非天锚定周期;MiniMax 视角的 5h 窗口末段只有 4h(见 `upstreams::cool_until_until`) | +| 同一下游 Key 每次换上游账号 | 粘性绑定 `ukb:` 没写(下行 Key 缺失时本就不写);或该 Key 哈希落点恰好在冷却账号上 | | 流式退化成一次性返回 | `proxy_buffering off` 丢了 | | 上游报 Host / 证书错 | `proxy_set_header Host $llm_host` 或 `proxy_ssl_server_name on` 丢了 | | query 参数丢失 | 变量形式的 `proxy_pass` 不会自动追加 args,靠 `llm::upstream_uri` 拼好 | **本机验证夹具**:`tests/llm/`,由 `bash tests/run.sh llm` 一并起假上游(18999)、LLM 网关(18090) -与**管理端口 18091**(跑 `/api/v1/*` 账号态断言)后跑断言。当前规模:网关 **102 条** + LLM **160 条** +与**管理端口 18091**(跑 `/api/v1/*` 账号态断言)后跑断言。当前规模:网关 **102 条** + LLM **177 条** (`bash tests/run.sh all`,期望失败 0)。 `tests/llm/upstream.py` 会把收到的 `path` / `auth` / `host` / `body` 记到 `.run/llm/upstream.log` diff --git a/docs/llm/MULTI_ACCOUNT_ROUTING.md b/docs/llm/MULTI_ACCOUNT_ROUTING.md new file mode 100644 index 0000000..bf8c7dc --- /dev/null +++ b/docs/llm/MULTI_ACCOUNT_ROUTING.md @@ -0,0 +1,191 @@ +# LLM 上游多账号路由与额度耗尽自动切换 + +> 适用版本:`ipass-1.0.14`(插件化后的 `plugin-llm`)。 +> 涉及文件:`rust/crates/plugin-llm/src/{models,upstreams,llm,usage_filter,handlers,api}.rs`、 +> `conf/nginx.conf`(LLM server)、`tests/llm/{e2e.sh,upstream.py,fixtures/llm-upstreams.json}`。 + +--- + +## 一、解决什么问题 + +同一上游厂商(如 MiniMax)往往给**多个账号 Key**,且额度按周期清零(MiniMax 是 +「每周清零 + 每 5 小时清零」)。本特性让一个 `slot`(上游)挂多个账号,做到: + +1. **下游用户 Key → 上游账号 Key 粘性绑定**:同一下游 Key 尽量一直走同一个上游账号 + (便于对账、便于厂商侧按账号看用量),但这是**尽力语义**——重启后重新绑定。 +2. **额度耗尽自动切换**:某上游账号被厂商判额度耗尽,下次请求自动切到同厂商下一个可用账号。 +3. **重置窗口感知**:额度按周期清零,冷却时长取「最近一个重置边界」,不盲目冷却整段固定时间。 + +--- + +## 二、数据模型(`llm-upstreams.json` 的 slot) + +```json +{ + "minimax": { + "base": "https://api.minimax.chat/v1", + "models": ["abab6.5s-chat"], + "enabled": true, + "accounts": [ + {"auth": "Bearer ", "note": "acct-1", "resets": [604800, 18000]}, + {"auth": "Bearer ", "note": "acct-2", "resets": [604800, 18000]} + ], + "exhaust_status": [401, 402, 429, 403], + "exhaust_markers": ["\"status_code\":1004", "余额不足"], + "created_at": 1757500000 + } +} +``` + +| 字段 | 含义 | +|---|---| +| `accounts` | 多账号数组。**取代旧版单 `auth` 字段**;`accounts` 为空时由顶层 `auth` 兼容合成单账号 | +| `accounts[].auth` | 完整的 `Authorization` 头值(如 `Bearer sk-xxx`)。留空表示免鉴权后端 | +| `accounts[].note` | 备注(如「华东主账号」),仅展示 | +| `accounts[].resets` | 该账号的**额度重置周期(秒)数组**,如 `[604800, 18000]` = 周 + 5 小时。全空=不自动切换 | +| `exhaust_status` | 命中即判「额度耗尽」的 HTTP 状态码(**上游级,所有账号共用**)。如 `[401,402,429,403]` | +| `exhaust_markers` | 响应体含任一子串即判耗尽(逐字节匹配,大小写敏感)。用于厂商「HTTP 200 + body 报错」的场景 | + +> **敏感级别等同 `users.json`**:`accounts[].auth` 含上游真 Key,配置文件不入库 / 不进 Gitea raw。 + +--- + +## 三、路由逻辑(access 阶段 `pick_account`) + +``` +1. 查下游 Key 的粘性绑定 ukb: → 已有账号下标 +2. 无绑定 → FNV-1a(key) % 可用数 → 冷分散(不是固定 avail[0],也不是随机) +3. 绑定账号在冷却中 → 跳过,按下流 key 在剩余可用里重新分散 +4. 全部冷却中 → 选「最早恢复」的账号(min cool_until) +5. 选定后写/刷新 ukb 粘性绑定(TTL = max(resets),兜底 7 天) +``` + +### 3.1 冷分配为什么用「键哈希」而不是「随机」或「固定第 0 个」 + +三者要同时满足两个看似矛盾的目标: + +| 目标 | 为什么需要 | +|---|---| +| **均匀铺开** | MiniMax 这类厂商对**单账号有 agent 并发上限**。若所有下游 Key 都落 `account#0`,一把 Key 被打满、同 slot 的其它 Key 却闲着 | +| **分配后保持** | 同一用户的请求若被轮到不同上游账号,**prompt / token 缓存前缀对不上 → 缓存命中率暴跌**,等于白缓存 | + +- **固定 `avail[0]`**:满足「保持」但不满足「铺开」——全部压在第一个账号。 +- **随机分配**:满足「铺开」但不满足「保持」——同一用户每次请求都可能换账号,缓存必然失效。 +- **FNV-1a(key) % n**:`key` 固定 ⇒ 落点固定(满足保持);不同 `key` 哈希值不同 ⇒ 落到不同账号(满足铺开)。 + 且**确定性可复现**——本机回归能用同一段哈希精确预测首次落点,不必依赖全局随机源。 + (随机源仅在**没有下游 Key** 时兜底:管理台「测试」按钮这类内部探测流量走 `ngx_random()`,不要求粘性。) + +⚠️ 分散是**冷分配时选一次**,之后由 `ukb:` 绑定固定住;绑定账号冷却被跳过时会在剩余可用账号里按同一哈希重新分散。 + +- **粘性仅共享内存**:重启后绑定丢失,下次请求重新冷分配,符合「尽可能同一 Key 用同一上游 Key」的尽力语义。 + +--- + +## 四、耗尽检测(log 阶段,双重保险) + +| 来源 | 机制 | 适用场景 | +|---|---|---| +| HTTP 状态码 | 读 `$upstream_status` 末段,命中 `exhaust_status` → 标记 | 厂商直接回 401/402/429/403 | +| 响应体标记 | `usage_filter` 在 body **流式**扫描 `exhaust_markers`,`take_exhausted` 透给 log | 厂商「HTTP 200 + body 报错」(如 MiniMax `status_code:1004`) | + +任一命中 → 读 `$llm_acct`(本次 access 阶段选中的账号下标,确定一致)→ +`mark_exhausted(slot, idx, resets)` 写冷却。 + +--- + +## 五、冷却窗口(天锚定,关键) + +`cool_until_until(resets, now)` 的边界计算**锚定到「当天的 0 点」**,而非简单 `now + 窗口` 滚动: + +``` +day0 = RESET_DAY_OFFSET_SEC + floor((now - RESET_DAY_OFFSET_SEC) / 86400) * 86400 +elapsed = now - day0 +boundary = day0 + ceil(elapsed / 窗口) * 窗口,且封顶到 day0 + 86400(次日 0 点) +``` + +**为什么必须天锚定**(MiniMax 实测口径): +MiniMax 的 5 小时额度从当天 0 点起每 5h 清一次,但 `24 = 5×4 + 4`—— +最后一段窗口 `20:00–24:00` **只有 4 小时**,到点随「天」一起重置。 +如果简单 `now + 5h` 滚动,21:00 耗尽会冷却到次日 01:00,与厂商口径对不上; +天锚定后封顶到当日 24:00(差 3h),与厂商行为一致。 + +- `RESET_DAY_OFFSET_SEC`(默认 `28800` = 北京时间)让 MiniMax 描述的开箱即用;其他时区厂商改成 `0` 即可。 +- **多窗口取最早恢复**:`resets=[604800, 18000]` 时,周额度与 5h 额度哪个先恢复用哪个。 +- `resets` 全空 → 兜底滚动冷却 `ACCT_COOLDOWN_DEFAULT = 4h`。 + +--- + +## 六、共享内存布局 + +| 键 | 值 | 说明 | +|---|---|---| +| `up:` | `base \n ` | 上游基址 + 账号数 | +| `upa::` | `auth \n ` | 单账号 auth + 重置周期 | +| `uac::` | `exhausted_until` | 冷却截止(TTL = until,自然到期即视为恢复) | +| `ukb:` | `acct_idx` | 粘性绑定(TTL = max resets) | +| `upe:` | `status_csv \n markers_json` | 上游级耗尽检测配置 | +| `uda:::` | `requests:tin:tout`(`DayBucket`) | 账号级负载日桶(TTL 90 天) | +| `uex:::` | `requests`(=耗尽次数) | 账号级额度耗尽次数日桶(TTL 90 天) | + +写操作均写穿共享内存;停用(`enabled=false`)即摘 `up:` 条目,热路径「查不到=停用」。 + +--- + +## 七、账号级负载统计(问题发现与跟踪) + +**为什么用共享内存日桶而不是数据库**:项目红线是「不引入数据库 / Redis / MQ / 额外常驻进程」。 +而负载统计本质是**每请求计数器**——nginx 共享内存 zone 正是为此而生(worker 间天然共享、 +原子、TTL 自动淘汰、无文件锁);换成 SQLite 反而要在多 worker 下处理 WAL 与 busy_timeout 的写锁竞争, +在网关热路径上是退步。账号级只是给已有的上游级日桶(`uds:`)**多一维下标**, +完全复用内核 `ipass_core::usage` 的 `bump_day` 原语,零新依赖、零新文件。 + +### 7.1 计数点:**log 阶段**,且只记一次 + +``` +access : pick_account 只做决策,不记账 + ($llm_target / $llm_auth / $llm_acct 三个变量各触发一次 pick_account, + 在这里记账会把同一请求记三遍) +proxy : nginx 原生转发 +log : read_llm_acct(r) 取本次选中账号(NOCACHEABLE,与 access 同一结果) + → bump_acct_load(slot, idx) 每次真实转发 +1 + → 命中耗尽 → bump_acct_exhaust(...) +1 + → body filter 抓到 usage → add_acct_tokens(...) +``` + +口径与请求级用量一致:**只算真的转发出去的请求**(被拒的 401/403/404/429 不入账)。 + +### 7.2 展示(管理台「上游」页 · 密钥 / 负载 列) + +每个上游账号一块: + +- **今日负载行**:`今日 N 请求 · 入 X / 出 Y tok` +- **比例条**:该 Key 占「本上游负载最大的 Key」的百分比——**本上游内部相对量**最有信息量, + 谁在扛、有没有偏斜一眼可见(不占全局总量,否则多上游场景下每根条都很短) +- **14 天迷你趋势**:后端 `account_trend()` 按日窗 id 精确取键渲染(零第三方依赖的 SVG), + 悬停给出「近 14 天合计 / 峰值 / 峰值日期」 +- **徽标**:`冷却`(`uac:` 键存在)、`耗尽N`(今日被判耗尽并冷却的次数,来自 `uex:`) +- 上游级一行合计:`N 把 Key · 今日合计 M 请求` + +账号级序列**不参与任何转发决策**,纯展示;`view()` 投影见 `upstreams::view`。 + +--- + +## 八、管理台 + +- `www/assets/upstreams.js` 编辑卡支持**多账号行**:每行 auth(掩码回显)、note、resets(逗号分隔周期)。 +- 列表「密钥 / 负载」列展示账号数、冷却/耗尽状态与**各 Key 今日负载 + 比例条 + 14 天迷你趋势**(见 §七)。 +- 保存接口 `POST /api/admin/upstreams/save` 接受 `accounts`(JSON 数组); + auth 留空=保留原值(编辑时不用每次重填真 Key)。 + +--- + +## 九、验证 + +- **本机回归**:`tests/llm/e2e.sh` 多账号组(粘性 + 耗尽自动切换 + 靶机真收 Key + 账号级负载分布), + 全量 `bash tests/run.sh all` 期望 **279 条断言全绿**(gateway 102 + llm 177)。 + 假上游 `upstream.py` 支持 `UPSTREAM_FAIL_AUTH` 环境变量模拟「账号额度耗尽」。 +- **真 MiniMax 双 Key 实测**:key1 稳定 200 + 粘性 `acct=0`;key1 失效 → 自动切 key2(`acct=1`,200)。 + 真 Key 仅存临时目录、测完即删,不入库。 +- **前端渲染**:以真实 `admin.css` + 真实 `upstreams.js` 渲染路径做无头浏览器断言—— + 比例条宽度与负载成比例(412 vs 96 → 100% / 23%)、每账号 14 个条块、悬停峰值日期与数据逐位吻合、 + 单账号老记录与无账号上游兜底正常、无横向溢出、零 JS 错误。 diff --git a/docs/llm/STREAMING_USAGE.md b/docs/llm/STREAMING_USAGE.md index 57178c2..4143cd1 100644 --- a/docs/llm/STREAMING_USAGE.md +++ b/docs/llm/STREAMING_USAGE.md @@ -8,6 +8,15 @@ > **关联文档**:`docs/llm/UPSTREAM_PROTOCOL_AND_AUTH.md`(出站头 / 多协议)、 > `rust/src/stats.rs`(当前请求级计数实现)、`rust/src/config.rs` §LLM 限流。 > **最后更新**:2026-09-12(基于 ipass-1.0.6)。 +> +> ⚠️ **路径已过时**:本文写于插件化重构(`ipass-1.0.12`)之前,正文里的 +> `rust/src/*.rs` 与其中的行号均为**当时的单 crate 布局**。现对应关系: +> `rust/src/stats.rs` → `rust/crates/plugin-llm/src/stats.rs`、 +> `rust/src/config.rs` → 策略常量分家(内核 `rust/crates/ipass-core/src/config.rs` + 插件 `rust/crates/plugin-llm/src/config.rs`)、 +> `rust/src/lib.rs` → 拆为 `rust/gateway/src/lib.rs`(装配根 + 管理 API 的 `ApiHandler`) +> 与各插件的 `handlers.rs`;LLM 热路径的三个处理器(`LlmHandler` / `LlmHealthHandler` / +> `AuditHandler`)在 `rust/crates/plugin-llm/src/handlers.rs`,`stats::record` 的调用点也在此。 +> 阅读时以**模块名**为准,不要按行号定位。 --- diff --git a/docs/llm/UPSTREAM_PROTOCOL_AND_AUTH.md b/docs/llm/UPSTREAM_PROTOCOL_AND_AUTH.md index 3810b6c..014498b 100644 --- a/docs/llm/UPSTREAM_PROTOCOL_AND_AUTH.md +++ b/docs/llm/UPSTREAM_PROTOCOL_AND_AUTH.md @@ -5,8 +5,12 @@ > **结论全部来自开源实现或厂商官方文档,并附本机靶机实测证据**(本项目硬规矩: > 验证请求头替换必须看上游收到的请求)。 -涉及文件:`conf/nginx.conf`(LLM server)、`rust/src/llm.rs`、`rust/src/upstreams.rs`、 -`tests/llm/upstream.py`。 +涉及文件:`conf/nginx.conf`(LLM server)、`rust/crates/plugin-llm/src/llm.rs`、 +`rust/crates/plugin-llm/src/upstreams.rs`、`tests/llm/upstream.py` + +> 路径说明:`ipass-1.0.12` 插件化重构后,原 `rust/src/llm.rs` / `rust/src/upstreams.rs` +> 已迁入 `rust/crates/plugin-llm/src/`(本文其余段落若提到旧路径,按此对应)。 +> 多账号路由与账号级负载统计见 `docs/llm/MULTI_ACCOUNT_ROUTING.md`。 --- diff --git a/readme.md b/readme.md index eecc92e..f83711d 100755 --- a/readme.md +++ b/readme.md @@ -213,10 +213,10 @@ subdomain/ │ ├── usage.html # 用量统计(趋势 · 按人 · 按 API 组 · token) │ ├── apix.html # API 代理(列表 + 弹出卡片编辑 + 免费预估测试) │ └── assets/ # admin.css + core.js + chart.js + 各页 JS -├── tests/ # ★ 本机回归夹具(bash tests/run.sh [gateway|llm|all],262 项) +├── tests/ # ★ 本机回归夹具(bash tests/run.sh [gateway|llm|all],279 项) │ ├── run.sh # 统一入口:编译 + 渲染配置 + 起停 nginx + 跑断言 │ ├── gateway/ # 域名网关:nginx.conf.in + e2e.sh(102 条断言)+ 转发靶机 -│ └── llm/ # LLM 代理:nginx.conf.in + e2e.sh(160 条)+ 假上游 + 合成夹具 +│ └── llm/ # LLM 代理:nginx.conf.in + e2e.sh(177 条)+ 假上游 + 合成夹具 │ # (.run/ 是运行目录,已 gitignore) ├── data/ # ★ 状态目录(需可写;运行期真源在共享内存) │ ├── users.json # 账号表(含口令哈希与 API Key) @@ -509,6 +509,37 @@ LLM 代理读 `Authorization: Bearer`。重置 Key 会同时影响两个入口 - `enabled: false` 会立即从共享内存摘除,等价于停用(配置保留便于恢复) - **该文件含上游厂商真实密钥,敏感级别等同 `users.json`** +#### 一个上游挂多个账号(`accounts`,可替代单个 `auth`) + +同一厂商给了多把 Key、额度按周期清零时(典型:MiniMax「每周 + 每 5 小时」), +用 `accounts` 数组代替 `auth`,网关会把下游用户 Key **粘性绑定**到某一把上游 Key, +某把耗尽后自动切到同厂商下一把: + +```json +{ + "minimax": { + "base": "https://api.minimaxi.com", + "accounts": [ + {"auth": "Bearer ", "note": "主账号", "resets": [604800, 18000]}, + {"auth": "Bearer ", "note": "备用", "resets": [604800, 18000]} + ], + "exhaust_status": [401, 402, 429, 403], + "exhaust_markers": ["\"status_code\":1004", "余额不足"], + "enabled": true + } +} +``` + +- `resets` 是该账号的**额度重置周期(秒)**数组;冷却边界**锚定当天 0 点**(MiniMax 的 + 5 小时窗口在 20:00–24:00 只有 4 小时、随天重置,不能按 `now + 5h` 滚动) +- `exhaust_status` / `exhaust_markers` 是**上游级**耗尽判据(所有账号共用): + HTTP 状态码命中,或响应体流式扫描到标记子串,即判该账号额度耗尽 +- 无绑定时按 `FNV-1a(下游 Key) % 可用账号数` **分散**(避免全压第一个账号触发厂商 + 「单账号 agent 并发上限」),但同一 Key 落点固定 → **prompt / token 缓存能命中** +- 管理台「上游」页的**密钥 / 负载**列展示每把 Key 的今日请求 / token / 耗尽次数、 + 负载比例条与 14 天迷你趋势,用于发现「谁被打满、谁在偏斜」 +- 详见 `docs/llm/MULTI_ACCOUNT_ROUTING.md` + ### `data/api-proxies.json` ```json @@ -568,7 +599,7 @@ cp -a data /path/to/backup/ 夹具在仓库里 `tests/`,**不进 Docker**,直接在本机跑(秒级): ```bash -bash tests/run.sh # 全部:域名网关 90 条 + LLM 代理 111 条 +bash tests/run.sh # 全部:域名网关 102 条 + LLM 代理 177 条 bash tests/run.sh gateway # 只跑域名网关 bash tests/run.sh llm # 只跑 LLM 代理 ``` @@ -767,6 +798,7 @@ DRY_RUN=1 bash deploy/release.sh 1.0.3 # 只构建不推送 | `ipass-1.0.11` | **API 代理去「市场」概念**:每条代理自带 `supplier`/`base`/`key`,无平台级凭据;管理台编辑改弹出卡片(`IP.modal`)。commit `1fb83e4`。 | | `ipass-1.0.12` | **插件化重构**:workspace 化(ipass-core + 三插件 crate + gateway 唯一 cdylib),行为完全等价,262 项回归全绿。commit `ddd4172`。架构见 `docs/plugin/PLUGIN_ARCHITECTURE.md`。 | | `ipass-1.0.13` | 采纳 sso 上游化建议 4 条(`User.extra` flatten / `split_value` rposition / `iter_prefix_ex` / `users::update_extra`)。commit `ee05b27`,评估记录 `docs/plugin/SSO_UPSTREAM_DECISIONS.md`。 | +| `ipass-1.0.14` | **LLM 上游多账号路由 + 额度耗尽自动切换 + 粘性绑定**(见 §15「上游配置」与 `docs/llm/MULTI_ACCOUNT_ROUTING.md`):一个 slot 挂多个账号 Key,下游 Key 与上游账号粘性绑定(`ukb:`,仅共享内存、重启重绑);无绑定时按 `FNV-1a(下游 Key) % n` 分散(均匀铺开避开厂商单账号并发上限,同时落点固定保住 prompt/token 缓存);厂商判额度耗尽(HTTP 状态码 或 响应体 marker,流式也扫)即冷却该账号并切下一个,冷却边界**天锚定**(对齐 MiniMax「5h 窗口、末段 4h 随天重置」)。**新增账号级负载统计**(`uda:`/`uex:` 日桶,复用内核 `usage` 原语、零新依赖):管理台「上游」页密钥列展示各 Key 今日请求/token/耗尽次数 + 负载比例条 + 14 天迷你趋势。回归 279 条全绿(网关 102 + LLM 177)。 | --- @@ -902,6 +934,24 @@ curl -s -H "X-API-Key: $KEY" "$API/api/v1/usage" 与域名 / Key 等配置不同,用量是运行期指标,不落盘 - 管理台账号列表另有一列 `llm_today` 直接显示今日用量 +#### 上游账号级负载(多账号路由的「问题发现」视角) + +一个上游挂多把 Key 时,管理台「上游」页的**密钥 / 负载**列逐账号展示: + +| 展示项 | 含义 | 数据源(共享内存键) | +| --- | --- | --- | +| 今日 N 请求 · 入 X / 出 Y tok | 该 Key 今日真实转发量与 token 消耗 | `uda:::` | +| 比例条 | 该 Key 占**本上游负载最大 Key** 的百分比(谁在扛、有没有偏斜) | 同上 | +| 14 天迷你趋势 | 悬停显示近 14 天合计 / 峰值 / 峰值日期 | 同上 + `trend_labels` | +| `冷却` 徽标 | 该账号当前处于额度耗尽冷却 | `uac::` | +| `耗尽N` 徽标 | **今日**被判额度耗尽并冷却的次数 | `uex:::` | +| 上游级合计 | `N 把 Key · 今日合计 M 请求` | 账号负载求和 | + +计数点在 **log 阶段**(`access` 阶段的 `pick_account` 只做决策、不记账——它会因 +`$llm_target/$llm_auth/$llm_acct` 三个变量各触发一次),口径与请求级用量一致: +**只算真的转发出去的请求**。账号级序列**不参与任何转发决策**,纯展示。 +设计取舍与键布局见 `docs/llm/MULTI_ACCOUNT_ROUTING.md` §七。 + ### 路径拼接(版本段去重) 客户端请求路径会**原样接到上游 `base` 之后**,但有一处特例容易绊到人: @@ -968,6 +1018,11 @@ curl -s -H "X-API-Key: $KEY" "$API/api/v1/usage" `models` 用于**模型发现**;管理台「上游管理」有「模型」列与「编辑」按钮可直接维护, 支持一次粘贴多行(逗号 / 顿号 / 分号 / 换行都当分隔符)。 +**一个上游挂多个账号**:同一个 `slot` 可配 `accounts[]`(多把上游 Key + 各自的额度重置周期), +下游 Key 与上游账号**粘性绑定**、某把耗尽自动切下一把;管理台「密钥 / 负载」列逐 Key 展示 +今日请求/token/耗尽次数 + 负载比例条 + 14 天迷你趋势。字段与设计见「数据模型」小节与 +`docs/llm/MULTI_ACCOUNT_ROUTING.md`。 + `GET /api/v1/upstreams`(账号态)与 `GET /api/v1/models`(`upstreams` 分组)会给每个可用 上游回两个**拼好的完整地址**:`base_url`(OpenAI 客户端直接当 `base_url` 用)与 `anthropic_base_url`(Anthropic 客户端直接当 `ANTHROPIC_BASE_URL` 用),以及 `status` @@ -1055,6 +1110,24 @@ GET /apix/search?q=nginx Authorization: Bearer sk_<本网关签 ## 16. 变更记录 +- **2026-09-14 LLM 上游多账号路由 + 账号级负载统计(`ipass-1.0.14`)** + - **多账号**:`llm-upstreams.json` 的 slot 新增 `accounts[]`(`auth` / `note` / `resets`) + 与上游级 `exhaust_status` / `exhaust_markers`;顶层单 `auth` 保留兼容(`accounts` 为空时合成单账号)。 + - **路由**(access 阶段 `pick_account`):粘性绑定 `ukb:` 优先 → 无绑定时 + `FNV-1a(下游 Key) % 可用数` 冷分散 → 绑定账号冷却则跳过重新分散 → 全冷却选最早恢复。 + 分散解决厂商「单账号 agent 并发上限」,绑定保证同一用户落点固定以命中 prompt/token 缓存。 + - **耗尽检测**(log 阶段,双保险):`$upstream_status` 命中 `exhaust_status`,或 + body filter 流式扫到 `exhaust_markers` → `$llm_acct` 定位本次账号 → 写冷却 `uac:`。 + - **天锚定冷却**:边界 = `day0 + ceil(已过/窗口)×窗口` 且封顶次日 0 点 + (MiniMax 5h 窗口、24=5×4+4 → 20:00–24:00 末段只有 4h、随天重置;`RESET_DAY_OFFSET_SEC` 默认北京时间)。 + - **账号级负载统计**(新):`uda:::`(请求/token)与 `uex:` (耗尽次数)日桶, + 复用内核 `usage::bump_day`,**无数据库、无新进程**;计数点只在 log 阶段一次 + (`pick_account` 会被三个变量各触发一次,不能在里面记账)。管理台「上游」页密钥列展示 + 每把 Key 今日负载 + 比例条 + 14 天迷你趋势 + 冷却/耗尽徽标;`view()` 附 `trend_labels`。 + - 回归 **279 条全绿**(网关 102 + LLM 177,新增 6 条多账号/负载断言);前端以真实 + `admin.css` + `upstreams.js` 渲染路径做无头浏览器断言(比例条成比例、条块数、悬停日期、无溢出)。 + - 专章:`docs/llm/MULTI_ACCOUNT_ROUTING.md`(数据模型 / 路由 / 冷却数学 / shm 布局 / 负载统计)。 + - **2026-09-13(续11)插件化重构(`ipass-1.0.12`)** - 单 crate 拆为 **workspace**:`ipass-core`(内核)+ `plugin-domain` / `plugin-llm` / `plugin-apix` 三个插件 crate(一律 rlib)+ `gateway`(**唯一 cdylib**,产物仍为 `libipass_gateway.so`)。 diff --git a/rust/crates/plugin-llm/src/api.rs b/rust/crates/plugin-llm/src/api.rs index a1db48f..75fcba7 100644 --- a/rust/crates/plugin-llm/src/api.rs +++ b/rust/crates/plugin-llm/src/api.rs @@ -79,6 +79,32 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status { // 分隔符同时接受换行/逗号/顿号/分号——粘一份厂商文档里的模型列表是常见操作。 let models = p.get("models").map(|raw| parse_model_list(raw)); + // 多账号:前端把 `accounts` 作为 JSON 数组串传上来(每个 {auth, note, resets})。 + // 缺省/空 = 沿用旧逻辑(用 `auth` 维护单账号)。 + let accounts = p + .get("accounts") + .and_then(|s| { + let s = s.trim(); + if s.is_empty() { + None + } else { + serde_json::from_str::>(s).ok() + } + }); + + // 上游级「额度耗尽」探测配置(JSON 数组;也兼容逗号串) + let exhaust_status = parse_int_list(p.get("exhaust_status")); + let exhaust_markers = p + .get("exhaust_markers") + .and_then(|s| { + let s = s.trim(); + if s.is_empty() { + None + } else { + serde_json::from_str::>(s).ok() + } + }); + let slot_raw = p.get("slot").map(String::as_str).unwrap_or(""); match upstreams::upsert( @@ -86,6 +112,9 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status { p.get("base").map(String::as_str).unwrap_or(""), models, p.get("auth"), + accounts, + exhaust_status, + exhaust_markers, enabled, p.get("note"), ) { @@ -93,7 +122,8 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status { // 用校验后的 slot 回显;直接拿原始入参会把大小写差异带进响应 let slot = upstreams::validate_slot(slot_raw).unwrap_or_default(); util::log_notice(&format!( - "[api] 保存 LLM 上游 {slot} enabled={enabled} models={}", + "[api] 保存 LLM 上游 {slot} enabled={enabled} accounts={} models={}", + up.effective_accounts().len(), up.models.len() )); // base_url 带「调用方正在用的端口」:见 upstreams::base_url 的说明 @@ -103,6 +133,23 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status { } } +/// 解析整数列表:优先 JSON 数组,回退逗号分隔串。 +fn parse_int_list(raw: Option<&String>) -> Option> { + let s = raw?; + let s = s.trim(); + if s.is_empty() { + return None; + } + if let Ok(v) = serde_json::from_str::>(s) { + return Some(v); + } + Some( + s.split(',') + .filter_map(|x| x.trim().parse::().ok()) + .collect(), + ) +} + /// 把管理台/接口传入的模型列表串拆成模型名数组。 /// /// 允许的写法(混用也认):`a,b` / `a、b` / `a;b` / 一行一个。 diff --git a/rust/crates/plugin-llm/src/config.rs b/rust/crates/plugin-llm/src/config.rs index bb361c8..1ff77b6 100644 --- a/rust/crates/plugin-llm/src/config.rs +++ b/rust/crates/plugin-llm/src/config.rs @@ -44,6 +44,20 @@ pub const KEY_UDAY_USER_PREFIX: &[u8] = b"udu:"; /// (apix 的 slug 带 `api/` 前缀共用这片键空间,见 core config 的 APIX_STATS_PREFIX) pub const KEY_UDAY_SLOT_PREFIX: &[u8] = b"uds:"; +/// 键前缀:上游**账号级**日桶(负载分布)。键 = `uda:::<日窗id>`, +/// value = DayBucket(requests = 转发到该账号的请求数,tin/tout = 该账号 token 消耗)。 +/// 与 `uds:`(slot 级)同构、多一维账号下标——「各上游 Key 负载」就靠它, +/// 无需数据库(项目红线)。TTL 90 天自然淘汰。 +pub const KEY_UDAY_ACCT_PREFIX: &[u8] = b"uda:"; + +/// 键前缀:上游账号**额度耗尽次数**日桶。键 = `uex:::<日窗id>`, +/// value = DayBucket(requests = 该账号被判定额度耗尽并冷却的次数)。 +/// 仅作问题发现指标、不参与路由——哪把 Key 频繁撞额度一眼可见。TTL 90 天。 +pub const KEY_UEX_PREFIX: &[u8] = b"uex:"; + +/// 管理台账号级负载迷你趋势的展示天数(与项目 `uds:` 趋势的默认 14 天一致)。 +pub const ACCT_TREND_DAYS: i64 = 14; + /// 键前缀:LLM **上游健康缓存**。键 = `uh:`, /// value = `<1|0> \n <上游状态码> \n <记录时刻>`。 /// @@ -54,6 +68,61 @@ pub const KEY_UDAY_SLOT_PREFIX: &[u8] = b"uds:"; /// 最多容忍客户端中途断连导致的误标(下一次真实转发即纠正)。 pub const KEY_UH_PREFIX: &[u8] = b"uh:"; +// =========================================================================== +// 多账号路由(一个 slot 挂多个上游账号,粘性绑定 + 额度耗尽自动切换) +// =========================================================================== + +/// 键前缀:上游账号静态配置。键 = `upa::`, +/// value = ` \n `(`resets` 为空则第二段为空)。 +/// +/// `auth` 是完整 Authorization 头值;`resets` 是该账号额度重置周期(秒,逗号分隔)。 +/// 与 `up:` 拆开存,是因为账号是热路径要枚举的对象、而 `up:` 只存 base + 账号数, +/// 避免一次大 payload 反序列化;账号数记在 `up:` 第二段,热路径据此循环读取。 +pub const KEY_UPA_PREFIX: &[u8] = b"upa:"; + +/// 键前缀:上游账号「额度耗尽」冷却(**运行时状态**,非配置)。 +/// 键 = `uac::`,value = ``(绝对秒)。 +/// +/// 写入时 `expires_at` 直接设为 `exhausted_until`——共享内存到期即视为不再冷却, +/// 「额度恢复」是天然发生的,无需额外清扫。log 阶段在检测到耗尽时写; +/// 热路径 `pick_account` 用 `get_live` 判定「该账号当前是否在冷却」。 +pub const KEY_UAC_PREFIX: &[u8] = b"uac:"; + +/// 键前缀:用户 key → 上游账号 粘性绑定。键 = `ukb:`, +/// value = ``(usize 字符串)。 +/// +/// 带 TTL(取该账号最长重置周期,或兜底 7 天),**尽力粘性**:重启后丢失、重新绑定, +/// 符合「尽可能同一用户 key 用同一上游 key」的语义。只有真正选了账号且拿到下行 key +/// 时才写;内部测试 location(无下行 key)不写,避免污染绑定表。 +pub const KEY_UKB_PREFIX: &[u8] = b"ukb:"; + +/// 键前缀:上游级「额度耗尽」探测配置。键 = `upe:`, +/// value = ` \n `(`markers` 是 JSON 字符串数组)。 +/// +/// slot 级(同一厂商所有账号共享错误形态),由 `sync_shm` 写、body filter 与 log 阶段读。 +pub const KEY_UPE_PREFIX: &[u8] = b"upe:"; + +/// 默认「额度耗尽」HTTP 状态码(命中即判该账号额度耗尽并冷却)。 +/// +/// 402/429/403 是主流厂商表达「配额/额度/权限不足」的常态;5xx 与连接失败(502/504) +/// 视为机器/链路问题、**不**算额度耗尽(否则单台抖动会把整池账号都冷却掉)。 +pub const EXHAUST_STATUS_DEFAULT: &[i64] = &[402, 429, 403]; + +/// 账号冷却默认下限(秒):`resets` 全空时仍给一个兜底冷却,避免单账号被瞬间连续打死。 +/// 实际冷却 = `min(resets)`,`resets` 空则用此值(4 小时,对齐 MiniMax「每 4 小时清零」口径)。 +pub const ACCT_COOLDOWN_DEFAULT: i64 = 4 * 3600; + +/// 粘性绑定 TTL 兜底(秒):账号 `resets` 全空时绑定的最长保留时长(7 天)。 +pub const AFFINITY_TTL_DEFAULT: i64 = 7 * 86400; + +/// 「额度重置窗口」锚定的天偏移(秒):决定「天 0 点」按哪个时区算。 +/// +/// MiniMax 等国内厂商的免费额度按**北京时间**清零,故默认 `28800`(= UTC+8); +/// 因此 5 小时窗口是「北京时间当天 0 点起每 5 小时」,一天 24h 不能被 5 整除, +/// 末段窗口(20:00–24:00)只有 4 小时、随「天」一起重置(见 `upstreams::cool_until_until`)。 +/// 其他时区的厂商改这里(如 UTC 设 `0`)。 +pub const RESET_DAY_OFFSET_SEC: i64 = 28800; + // =========================================================================== // 趋势 // =========================================================================== diff --git a/rust/crates/plugin-llm/src/handlers.rs b/rust/crates/plugin-llm/src/handlers.rs index a0a50b5..49653d3 100644 --- a/rust/crates/plugin-llm/src/handlers.rs +++ b/rust/crates/plugin-llm/src/handlers.rs @@ -131,20 +131,34 @@ impl HttpRequestHandler for LlmHandler { /// `$upstream_status` 的变量索引,postconfiguration 时解析一次(log 阶段复用)。 static UPSTREAM_STATUS_IDX: AtomicIsize = AtomicIsize::new(-1); -/// postconfiguration:预取 `$upstream_status` 变量索引(upstream 模块的 -/// preconfiguration 已注册该内建变量,此阶段取 index 一定成功)。 +/// `$llm_acct` 的变量索引(本插件注册),log 阶段读它拿到「本次请求打到的上游账号下标」, +/// 用于额度耗尽时精确标记那一个账号进入冷却。postconfiguration 时解析一次。 +static LLM_ACCT_IDX: AtomicIsize = AtomicIsize::new(-1); + +/// postconfiguration:预取 `$upstream_status` 与 `$llm_acct` 变量索引。 /// 失败返回 false,gateway 会 EMERG 退出。 pub fn prefetch_upstream_status_index(cf: *mut ngx_conf_t) -> bool { - let mut name = ngx_str_t { + let mut status_name = ngx_str_t { len: "upstream_status".len() as usize, data: b"upstream_status\0".as_ptr() as *mut u8, }; // SAFETY: cf 由 nginx 传入且有效;name 指向栈上合法 ngx_str_t - let idx = unsafe { ngx_http_get_variable_index(cf, &mut name) }; - if idx == -1 { + let sidx = unsafe { ngx_http_get_variable_index(cf, &mut status_name) }; + if sidx == -1 { return false; } - UPSTREAM_STATUS_IDX.store(idx as isize, Ordering::Relaxed); + UPSTREAM_STATUS_IDX.store(sidx as isize, Ordering::Relaxed); + + let mut acct_name = ngx_str_t { + len: "llm_acct".len() as usize, + data: b"llm_acct\0".as_ptr() as *mut u8, + }; + // SAFETY: 同上;本插件已在 preconfiguration 用 add_var 注册过 llm_acct + let aidx = unsafe { ngx_http_get_variable_index(cf, &mut acct_name) }; + if aidx == -1 { + return false; + } + LLM_ACCT_IDX.store(aidx as isize, Ordering::Relaxed); true } @@ -210,15 +224,60 @@ impl HttpRequestHandler for LlmHealthHandler { } if let Some(slot) = llm::slot_of(r) { + let now = util::now(); // 上游回了头 = 它活着:2xx~4xx 都算正常(4xx 是它对我们请求的意见, // 不是机器死了);5xx / 连接失败(502) / 等头超时(504) 才算失效 upstreams::mark_health(&slot, (200..500).contains(&code), code); + + // 账号级负载:每次真实转发都记到选中的上游账号(负载分布 / 问题发现)。 + // 只在这里记一次(read_llm_acct 触发一次 pick_account),绝不放在 + // pick_account 里——否则 $llm_target/$llm_auth/$llm_acct 三变量各触发一次 + // 会把同一请求记三遍。 + if let Some(idx) = read_llm_acct(r) { + upstreams::bump_acct_load(&slot, idx, now); + + // 额度耗尽检测:状态码命中 或 响应体命中标记 → 标记该账号冷却 + 耗尽计数 +1。 + // 状态码来自 `$upstream_status`,标记来自 body filter 的 `take_exhausted` + // (流式也能扫到)。 + let (status_list, _) = upstreams::read_upe(&slot); + let status_exhausted = status_list.iter().any(|&s| s == code); + let body_exhausted = usage_filter::take_exhausted(r); + if status_exhausted || body_exhausted { + if let Some((_, resets)) = upstreams::read_upa(&slot, idx) { + upstreams::mark_exhausted(&slot, idx, &resets, now); + } + upstreams::bump_acct_exhaust(&slot, idx, now); + } + } } Status::NGX_DECLINED } } +/// 从 `$llm_acct` 索引读本次请求选中的上游账号下标(NOCACHEABLE,读时重算,确定一致)。 +/// +/// 读不到(未求值/解析失败)返回 None——不标记,避免误伤。 +fn read_llm_acct(r: *mut ngx_http_request_t) -> Option { + let idx = LLM_ACCT_IDX.load(Ordering::Relaxed); + if idx < 0 { + return None; + } + // SAFETY: 索引在 postconfiguration 已解析;变量为 NOCACHEABLE,读即触发 get_handler + unsafe { + let v = ngx_http_get_indexed_variable(r, idx as ngx_uint_t); + if v.is_null() || (*v).not_found() != 0 || (*v).data.is_null() { + return None; + } + let s = core::str::from_utf8(core::slice::from_raw_parts( + (*v).data, + (*v).len() as usize, + )) + .ok()?; + s.trim().parse::().ok() + } +} + // =========================================================================== // log 阶段:对话审计 + token 入账 // =========================================================================== @@ -254,6 +313,11 @@ impl HttpRequestHandler for AuditHandler { if let Some(name) = user.as_deref() { stats::add_tokens(name, &slot, tin, tout, util::now()); } + // 账号级 token 负载(与账号级请求数同一个日桶维度 uda:) + let now = util::now(); + if let Some(idx) = read_llm_acct(r) { + upstreams::add_acct_tokens(&slot, idx, tin as i64, tout as i64, now); + } } // SAFETY: 同上;capture 内部任何失败只记日志,绝不 panic diff --git a/rust/crates/plugin-llm/src/llm.rs b/rust/crates/plugin-llm/src/llm.rs index 7add883..9eb9a05 100644 --- a/rust/crates/plugin-llm/src/llm.rs +++ b/rust/crates/plugin-llm/src/llm.rs @@ -39,7 +39,7 @@ use serde_json::json; use crate::config; use crate::upstreams; -use ipass_core::{http, state, util}; +use ipass_core::{auth, http, state, util}; // =========================================================================== // 变量分派标记 @@ -54,12 +54,15 @@ pub const VAR_TARGET: usize = 1; pub const VAR_HOST: usize = 2; /// `$llm_auth`:上游 Authorization 头值 pub const VAR_AUTH: usize = 3; +/// `$llm_acct`:本次请求选中的上游账号下标(多账号路由用;log 阶段据此标记耗尽)。 +/// 由 `pick_account` 在变量求值时计算(与 `$llm_auth` 同源,保证一致)。 +pub const VAR_ACCT: usize = 4; // =========================================================================== // preconfiguration:注册变量 // =========================================================================== -/// 注册 LLM 三件套只读变量(gateway preconfiguration 经插件循环调用)。 +/// 注册 LLM 四件套只读变量(gateway preconfiguration 经插件循环调用)。 /// /// 名字里的 `llm_` 前缀不要省:nginx 变量名全局唯一, /// 将来接入别的模块时才不会撞名。 @@ -70,10 +73,12 @@ pub unsafe fn preconfig(cf: *mut ngx_conf_t) -> bool { let mut target = ngx_string!("llm_target"); let mut host = ngx_string!("llm_host"); let mut auth_var = ngx_string!("llm_auth"); + let mut acct_var = ngx_string!("llm_acct"); unsafe { add_var(cf, &raw mut target, VAR_TARGET) && add_var(cf, &raw mut host, VAR_HOST) && add_var(cf, &raw mut auth_var, VAR_AUTH) + && add_var(cf, &raw mut acct_var, VAR_ACCT) } } @@ -308,11 +313,14 @@ unsafe fn set_value( Status::NGX_OK.into() } -/// 三个 LLM 变量共用一个 get_handler,靠 `var.data` 分派(值由 `preconfiguration` 写入)。 +/// 四个 LLM 变量共用一个 get_handler,靠 `var.data` 分派(值由 `preconfiguration` 写入)。 /// -/// 共用的代价是每个变量各查一次共享内存:一次读锁 + 一次 BTreeMap 查找 + -/// 一次小分配,量级在微秒以内,相对一次 LLM 推理完全可忽略; -/// 换来的是不必维护三份几乎相同的代码。 +/// 共用代价:每个变量各调一次 `pick_account`(一次读锁 + 几次 BTreeMap 查找 + 一次 +/// 小分配,微秒级),相对一次 LLM 推理完全可忽略;换来不必维护四份相近代码。 +/// +/// `$llm_acct` 的求值会顺带把「用户 key → 账号」粘性绑定写进共享内存 +/// (仅当下行 key 存在且绑定变化),是幂等副作用。log 阶段读取 `$llm_acct` 即得到 +/// 本次请求实际打到的账号下标(用于额度耗尽时精确标记那一个账号)。 pub extern "C" fn var_get( r: *mut ngx_http_request_t, v: *mut ngx_http_variable_value_t, @@ -320,21 +328,29 @@ pub extern "C" fn var_get( ) -> ngx_int_t { // SAFETY: r/v 由 nginx 传入且有效;slot_of/upstream_uri 只读请求结构 unsafe { - let resolved = (|| -> Option { + let resolved = (|| -> Option<(String, String, String, usize)> { let slot = slot_of(r)?; - // up: payload = `base \n auth`(见 upstreams::split_payload) - let (payload, _) = state::get(config::KEY_UP_PREFIX, slot.as_bytes())?; - let (base, auth) = upstreams::split_payload(&payload); - Some(match data { - VAR_TARGET => join_target(base, &upstream_uri(r)), - VAR_HOST => host_of(base).to_owned(), - VAR_AUTH => auth.to_owned(), - _ => return None, - }) + let key = auth::downstream_key(r); + let now = util::now(); + // 选账号:粘性绑定 + 跳过冷却中账号,返回 (下标, auth, base) + let (idx, auth, base) = upstreams::pick_account(&slot, key.as_deref(), now)?; + let target = join_target(&base, &upstream_uri(r)); + let host = host_of(&base).to_owned(); + Some((target, host, auth, idx)) })(); match resolved { - Some(value) => set_value(r, v, &value), + Some((target, host, auth, idx)) => { + // 四个分支各取一个字段(只有命中分支的 String 被移动出去) + let value = match data { + VAR_TARGET => target, + VAR_HOST => host, + VAR_AUTH => auth, + VAR_ACCT => idx.to_string(), + _ => return Status::NGX_ERROR.into(), + }; + set_value(r, v, &value) + } None => { (*v).set_not_found(1); (*v).set_valid(0); diff --git a/rust/crates/plugin-llm/src/models.rs b/rust/crates/plugin-llm/src/models.rs index ab21180..8ca4815 100644 --- a/rust/crates/plugin-llm/src/models.rs +++ b/rust/crates/plugin-llm/src/models.rs @@ -3,15 +3,39 @@ use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; +use crate::config::EXHAUST_STATUS_DEFAULT; + /// 上游表:`slot` 就是 LLM 客户端 URL 的第一段路径:`/openai/v1/chat/completions` /// 里的 `openai`。**刻意不按 body 里的 `model` 字段路由**——请求体要到 /// content 阶段才读得到,而 access 阶段(转发决策点)读不到, /// 按 model 分流就得放弃 `proxy_pass` 自己实现 upstream,代价差一个数量级。 pub type UpstreamTable = BTreeMap; +/// 单个上游账号:一把上游真 Key + 它的额度重置周期。 +/// +/// 一个 `slot`(一家厂商)可挂多个账号——不同账号通常是同一厂商的多把免费/付费 Key, +/// 各自有独立的周期性额度。网关按「用户 key → 上游账号」做粘性路由,账号额度耗尽时 +/// 自动切到同厂商下一个可用账号(见 `upstreams::pick_account` 与 `handlers` 的耗尽标记)。 +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct UpstreamAccount { + /// 完整的 Authorization 头值,如 `Bearer sk-xxx` + pub auth: String, + /// 备注(区分多账号用,如 `minimax-周额度` / `minimax-4h额度`) + #[serde(default)] + pub note: String, + /// 该账号额度重置周期(秒)。如 MiniMax = `[604800, 14400]`(每周 + 每 4 小时)。 + /// + /// 空 = 不配置重置窗口:额度耗尽后给一个兜底冷却(见 `config::ACCT_COOLDOWN_DEFAULT`), + /// 仍参与轮换,避免单账号被瞬间连续打死。 + #[serde(default)] + pub resets: Vec, +} + /// 单个 LLM 上游。 /// /// 字段名与旧版 `data/llm-upstreams.json` **逐字对应**,以便新版直接接管旧数据文件。 +/// 旧文件只有顶层 `auth`(单账号),新版通过 `effective_accounts()` 自动合成单账号, +/// 因此存量数据零改动即可继续工作。 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Upstream { /// 上游基址,含 scheme,如 `https://api.openai.com`(可带端口) @@ -24,10 +48,6 @@ pub struct Upstream { /// 留空表示"清单未知"——模型发现接口就不列该上游的模型,但转发照常可用。 #[serde(default)] pub models: Vec, - /// 完整的 Authorization 头值,如 `Bearer sk-xxx`。 - /// 留空表示不透传鉴权头(本地免鉴权后端,如 vLLM / Ollama) - #[serde(default)] - pub auth: String, /// 关闭后该 slot 立即停止转发(保留配置便于恢复) #[serde(default = "default_true")] pub enabled: bool, @@ -35,8 +55,55 @@ pub struct Upstream { pub note: String, #[serde(default)] pub created_at: i64, + /// 多账号列表。空时由 legacy `auth` 合成单账号(向后兼容旧数据)。 + #[serde(default)] + pub accounts: Vec, + /// 上游级「额度耗尽」探测配置(同一厂商所有账号共享错误形态)。 + /// + /// 命中下列任一即判该账号额度耗尽、进入冷却:上游返回这些 HTTP 状态码, + /// **或** 响应体(流式也能扫,见 `usage_filter`)含任一 `exhaust_markers` 子串。 + /// 空 = 用 `config::EXHAUST_STATUS_DEFAULT`(默认 `[402, 429, 403]`)。 + #[serde(default)] + pub exhaust_status: Vec, + /// 响应体「额度耗尽」标记子串(大小写敏感,逐字节匹配)。 + /// 例:MiniMax 余额不足可配 `"status_code":1004` 或 `余额不足`。 + #[serde(default)] + pub exhaust_markers: Vec, + /// 兼容旧版单 key 数据:旧 `auth` 字段。 + /// `accounts` 非空时忽略;`accounts` 空且 `auth` 非空 → 合成单账号(resets 空 = 不自动切换)。 + #[serde(default)] + pub auth: String, } fn default_true() -> bool { true } + +impl Upstream { + /// 实际生效的账号列表。 + /// + /// `accounts` 非空 → 用它;否则 `auth` 非空 → 合成单账号(resets 空,等同无限额度, + /// 不会因「耗尽」被冷却,单账号时自然也不存在可切换对象)。两者皆空 → 空表(上游不可用)。 + pub fn effective_accounts(&self) -> Vec { + if !self.accounts.is_empty() { + self.accounts.clone() + } else if !self.auth.is_empty() { + vec![UpstreamAccount { + auth: self.auth.clone(), + note: String::new(), + resets: Vec::new(), + }] + } else { + Vec::new() + } + } + + /// 生效的「额度耗尽」状态码清单(空 → 默认 `[402, 429, 403]`)。 + pub fn effective_exhaust_status(&self) -> Vec { + if self.exhaust_status.is_empty() { + EXHAUST_STATUS_DEFAULT.to_vec() + } else { + self.exhaust_status.clone() + } + } +} diff --git a/rust/crates/plugin-llm/src/upstreams.rs b/rust/crates/plugin-llm/src/upstreams.rs index 784591a..0cf8d2b 100644 --- a/rust/crates/plugin-llm/src/upstreams.rs +++ b/rust/crates/plugin-llm/src/upstreams.rs @@ -16,13 +16,16 @@ use serde_json::{Value, json}; use crate::config::{ - KEY_UH_PREFIX, KEY_UP_PREFIX, MODEL_NAME_MAX_LEN, UPSTREAM_BASE_MAX_LEN, - UPSTREAM_MODELS_MAX, UPSTREAM_SLOT_MAX_LEN, + ACCT_COOLDOWN_DEFAULT, ACCT_TREND_DAYS, AFFINITY_TTL_DEFAULT, EXHAUST_STATUS_DEFAULT, + KEY_UAC_PREFIX, KEY_UDAY_ACCT_PREFIX, KEY_UEX_PREFIX, KEY_UH_PREFIX, KEY_UKB_PREFIX, + KEY_UPA_PREFIX, KEY_UPE_PREFIX, KEY_UP_PREFIX, MODEL_NAME_MAX_LEN, RESET_DAY_OFFSET_SEC, + TREND_DAYS_MAX, TREND_KEEP_SECS, UPSTREAM_BASE_MAX_LEN, UPSTREAM_MODELS_MAX, + UPSTREAM_SLOT_MAX_LEN, }; -use crate::models::Upstream; +use crate::models::{Upstream, UpstreamAccount}; use crate::store; use ipass_core::config::LLM_PUBLIC_HOST; -use ipass_core::{state, util}; +use ipass_core::{state, usage, util}; /// 共享内存 payload 的内部分隔符:base 与 auth 之间。 /// @@ -117,40 +120,135 @@ pub fn validate_base(raw: &str) -> Result { // 共享内存同步(写穿 / 装载) // =========================================================================== +/// 一个 slot 最多支持的账号下标(清理残留旧账号下标时遍历的上界)。 +/// 实际部署不会接近这个数;超出部分不被支持(管理台会拦)。 +const ACCOUNT_INDEX_MAX: usize = 64; + +/// `up:` payload:`base \n <账号数>`。 +fn up_payload(base: &str, n: usize) -> String { + format!("{base}\n{n}") +} + +/// `upa::` payload:`auth \n `(resets 空则第二段为空)。 +fn upa_payload(auth: &str, resets: &[i64]) -> String { + let csv = resets + .iter() + .map(|x| x.to_string()) + .collect::>() + .join(","); + format!("{auth}\n{csv}") +} + /// 把一条上游配置同步进共享内存。**所有写操作之后必须调用它**。 /// -/// 关闭(`enabled=false`)时是**删除**而不是写入空值——热路径 -/// 「查不到 = 不可用」,这样停用即刻生效,且不留残留条目。 +/// 关闭(`enabled=false`)时是**删除**整个 slot 的键(up/upa/uac/upe),而不是 +/// 写入空值——热路径「查不到 = 不可用」,停用即刻生效且不留残留。 +/// +/// 多账号布局(见 `config` 的键前缀注释): +/// * `up:` = `base \n <账号数>` +/// * `upa::` = `auth \n `(每个账号一条) +/// * `upe:` = ` \n `(上游级耗尽探测配置) +/// * `uac::`(冷却运行时态)**不在此清除**——保留到自然到期, +/// 这样「正在冷却的账号」不会因为一次普通的 upsert(比如改备注)而莫名复活。 pub fn sync_shm(slot: &str, up: &Upstream) { - if up.enabled { - if !state::put(KEY_UP_PREFIX, slot.as_bytes(), payload_of(up).as_bytes(), 0) { + if !up.enabled { + remove_slot_shm(slot); + return; + } + let accts = up.effective_accounts(); + + if !state::put( + KEY_UP_PREFIX, + slot.as_bytes(), + up_payload(&up.base, accts.len()).as_bytes(), + 0, + ) { + util::log_err(&format!( + "[upstreams] 上游 base 写共享内存失败 slot={slot} —— 该上游会 404(共享内存可能已满)" + )); + } + write_upe(slot, up); + + for (i, a) in accts.iter().enumerate() { + let ak = format!("{slot}:{i}"); + if !state::put( + KEY_UPA_PREFIX, + ak.as_bytes(), + upa_payload(&a.auth, &a.resets).as_bytes(), + 0, + ) { util::log_err(&format!( - "[upstreams] 上游配置写共享内存失败 slot={slot} —— 该上游会 404(共享内存可能已满)" + "[upstreams] 上游账号写共享内存失败 slot={slot}#{i} —— 该账号会 404" )); } - } else { - state::remove(KEY_UP_PREFIX, slot.as_bytes()); + } + // 清掉被删/被减的账号下标(i >= 现账号数),避免旧 upa/uac 残留被误读 + for i in accts.len()..ACCOUNT_INDEX_MAX { + state::remove(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes()); + state::remove(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes()); } } -fn payload_of(up: &Upstream) -> String { - format!("{}{}{}", up.base, PAYLOAD_SEP, up.auth) +/// 删除一个 slot 在共享内存里的全部键(up / upe / upa* / uac*)。 +pub fn remove_slot_shm(slot: &str) { + state::remove(KEY_UP_PREFIX, slot.as_bytes()); + state::remove(KEY_UPE_PREFIX, slot.as_bytes()); + for i in 0..ACCOUNT_INDEX_MAX { + state::remove(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes()); + state::remove(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes()); + } +} + +/// 写上游级「额度耗尽」探测配置:`upe:` = ` \n `。 +fn write_upe(slot: &str, up: &Upstream) { + let status = up + .effective_exhaust_status() + .iter() + .map(|x| x.to_string()) + .collect::>() + .join(","); + let markers = serde_json::to_string(&up.exhaust_markers).unwrap_or_else(|_| "[]".to_owned()); + let payload = format!("{status}\n{markers}"); + if !state::put(KEY_UPE_PREFIX, slot.as_bytes(), payload.as_bytes(), 0) { + util::log_err(&format!("[upstreams] 上游耗尽配置写共享内存失败 slot={slot}")); + } } /// 全量重载上游表(启动装载 / 批量变更后)。返回装载条数。 /// -/// 只清 `up:` 前缀,不会误伤转发映射与管理会话。 +/// 清 `up:` / `upa:` / `uac:` / `upe:` 四类前缀(**不**清 `ukb:` 粘性绑定—— +/// 重启后重新绑定本就是预期语义)。 pub fn reload_shm() -> usize { state::clear_prefix(KEY_UP_PREFIX); + state::clear_prefix(KEY_UPA_PREFIX); + state::clear_prefix(KEY_UAC_PREFIX); + state::clear_prefix(KEY_UPE_PREFIX); let mut expected = 0; let mut loaded = 0; for (slot, up) in store::read_upstreams() { - if up.enabled { - expected += 1; + if !up.enabled { + continue; } - if up.enabled && state::put(KEY_UP_PREFIX, slot.as_bytes(), payload_of(&up).as_bytes(), 0) { + expected += 1; + let accts = up.effective_accounts(); + if state::put( + KEY_UP_PREFIX, + slot.as_bytes(), + up_payload(&up.base, accts.len()).as_bytes(), + 0, + ) { loaded += 1; } + write_upe(&slot, &up); + for (i, a) in accts.iter().enumerate() { + let ak = format!("{slot}:{i}"); + state::put( + KEY_UPA_PREFIX, + ak.as_bytes(), + upa_payload(&a.auth, &a.resets).as_bytes(), + 0, + ); + } } if loaded != expected { util::log_err(&format!( @@ -160,16 +258,324 @@ pub fn reload_shm() -> usize { loaded } -/// 拆 payload:`base \n auth` → `(base, auth)`。 +/// 读 `up:`:`(base, 账号数)`。 +pub fn read_up(slot: &str) -> Option<(String, usize)> { + let (payload, _) = state::get(KEY_UP_PREFIX, slot.as_bytes())?; + let (base, nstr) = payload.split_once('\n').unwrap_or((&payload, "0")); + let n = nstr.trim().parse::().unwrap_or(0); + Some((base.to_owned(), n)) +} + +/// 读 `upa::`:`(auth, resets)`。 +pub fn read_upa(slot: &str, i: usize) -> Option<(String, Vec)> { + let (payload, _) = state::get(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes())?; + let (auth, rest) = payload.split_once('\n').unwrap_or((&payload, "")); + let resets = if rest.trim().is_empty() { + Vec::new() + } else { + rest.split(',') + .filter_map(|s| s.trim().parse::().ok()) + .collect() + }; + Some((auth.to_owned(), resets)) +} + +/// 读 `upe:`:`(status 列表, markers 列表)`。 +pub fn read_upe(slot: &str) -> (Vec, Vec) { + let (payload, _) = match state::get(KEY_UPE_PREFIX, slot.as_bytes()) { + Some(p) => p, + None => return (EXHAUST_STATUS_DEFAULT.to_vec(), Vec::new()), + }; + let (status_str, markers_str) = payload.split_once('\n').unwrap_or((&payload, "[]")); + let status = if status_str.trim().is_empty() { + EXHAUST_STATUS_DEFAULT.to_vec() + } else { + status_str + .split(',') + .filter_map(|s| s.trim().parse::().ok()) + .collect() + }; + let markers = serde_json::from_str::>(markers_str.trim()) + .unwrap_or_else(|_| Vec::new()); + (status, markers) +} + +/// 某账号当前是否在「额度耗尽」冷却中(冷却键带 TTL,到期自动不再冷却)。 +pub fn is_cooled(slot: &str, i: usize, now: i64) -> bool { + state::get_live(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes(), now).is_some() +} + +/// 标记某账号额度耗尽,进入冷却直到「下一个重置边界」。 /// -/// 无分隔符时视为「只有 base、无鉴权头」——兼容手工编辑文件时漏写分隔的情况。 -pub fn split_payload(payload: &str) -> (&str, &str) { - match payload.split_once(PAYLOAD_SEP) { - Some((b, a)) => (b, a), - None => (payload, ""), +/// 重置窗口**锚定到「天」边界**(不是从 `now` 起的滚动窗口):MiniMax 这类厂商的 +/// 5 小时额度是「从当天 0 点起每 5 小时」清零,而一天 24 小时不能被 5 整除 +/// (24 = 5×4 + 4),所以最后一段窗口(20:00–24:00)只有 4 小时,到点随「天」一起重置。 +/// 因此冷却边界 = 当天 0 点 + ceil(已过秒数 / 窗口) × 窗口,且**不超过「下一天 0 点」** +/// (否则会跨到次日 01:00 之类,与厂商口径不符)。多窗口取最早边界(先到先恢复)。 +/// `resets` 全空 → 兜底 `ACCT_COOLDOWN_DEFAULT`(滚动 4 小时,非天锚定)。 +/// +/// 写入 `expires_at = until`,共享内存自然到期即视为恢复——无需额外清扫。 +pub fn mark_exhausted(slot: &str, i: usize, resets: &[i64], now: i64) { + let until = if resets.is_empty() { + now + ACCT_COOLDOWN_DEFAULT + } else { + cool_until_until(resets, now) + }; + if !state::put( + KEY_UAC_PREFIX, + format!("{slot}:{i}").as_bytes(), + until.to_string().as_bytes(), + until, + ) { + util::log_err(&format!( + "[upstreams] 账号冷却写共享内存失败 slot={slot}#{i} —— 该账号不会被自动跳过" + )); + } else { + util::log_warn(&format!( + "[upstreams] slot={slot} 账号#{i} 额度耗尽,冷却至 {}(约 {}s 后)", + util::fmt_time(until), + until.saturating_sub(now) + )); } } +/// 计算「额度耗尽后冷却到哪个时刻」(天锚定,末窗封顶到次日 0 点)。 +/// +/// 见 `mark_exhausted` 注释:窗口从「天 0 点」(按 `RESET_DAY_OFFSET_SEC` 偏移, +/// 默认北京时间)起算,一天内的末段窗口因不能被整除而随「天」重置。 +fn cool_until_until(resets: &[i64], now: i64) -> i64 { + const DAY: i64 = 86400; + let off = RESET_DAY_OFFSET_SEC; + // 最近一个「天 0 点」:t ≤ now 且 (t - off) 是 DAY 的整数倍 + let k = (now - off).div_euclid(DAY); + let day0 = off + k * DAY; + let elapsed = now - day0; + let mut best = i64::MAX; + for &w in resets { + if w <= 0 { + continue; + } + // 下一个整周期边界;末段窗口封顶到「下一天 0 点」(与厂商天重置对齐) + let boundary = (day0 + (elapsed / w + 1) * w).min(day0 + DAY); + best = best.min(boundary); + } + best +} + +/// 粘性绑定 TTL:取该账号最长重置周期,空则兜底 7 天。 +fn affinity_ttl(resets: &[i64]) -> i64 { + if resets.is_empty() { + AFFINITY_TTL_DEFAULT + } else { + *resets.iter().max().unwrap() + } +} + +/// 冷分配(无粘性绑定时)按下流 key 选一个「可用」账号下标。 +/// +/// 用 **FNV-1a 哈希(key) % n** 做确定性分散——同时满足了两件事: +/// * **均匀铺开**:不同下游 key 哈希值不同 → 落到不同上游账号,避免所有请求都压在 +/// `account#0` 触发 MiniMax 这类厂商的「agent 并发上限」; +/// * **分配后保持**:同一 key 哈希值固定 → 永远落到同一账号(粘性绑定的前提), +/// 于是同一用户的请求始终由同一个上游账号处理,**prompt / token 缓存得以命中** +/// (否则同一会话的请求被轮到不同账号,缓存前缀对不上 → 命中率暴跌、等于白缓存)。 +/// +/// 下流 key 不存在(内部「测试」按钮 location 不带 Bearer)→ 退化为 nginx 自带伪随机 +/// `ngx_random()`,仅用于分散探测/压测流量,不要求粘性。 +fn cold_index(key: Option<&str>, n: usize) -> usize { + if n == 0 { + return 0; + } + let r = match key { + Some(k) => { + // FNV-1a 64:快、无依赖、同 key 同值(偏移 0xcbf29ce484232325 / 素数 0x100000001b3)。 + // 选它是因为确定性可复现——本机回归能用同一段哈希精确预测首次落点, + // 既验证「分散」又验证「分配后保持」而不依赖全局随机源。 + let mut h: u64 = 0xcbf2_9ce4_8423_2325; + for &b in k.as_bytes() { + h ^= b as u64; + h = h.wrapping_mul(0x100_0000_01b3); + } + h + } + None => nginx_sys::ngx_random() as u64, + }; + (r % n as u64) as usize +} + +/// 选上游账号:实现「用户 key → 上游账号」粘性 + 跳过冷却中账号 + 全冷却 best-effort。 +/// +/// 返回 `(选中账号下标, 该账号 auth, 上游 base)`。选不到返回 `None`(上游不可用)。 +/// +/// 决策顺序: +/// 1. 枚举该 slot 全部账号,区分「可用」(未冷却)与「冷却中」(带 `exhausted_until`); +/// 2. 有可用账号: +/// * 已粘性绑定 → 用绑定的那个(若该账号已不可用则按下流 key 重新分散); +/// * 未绑定 → 按下流 key 的 FNV-1a 哈希**分散**选一个(`cold_index`): +/// 把不同用户铺到不同上游账号,避免全部压在 `account#0` 触发 MiniMax 这类厂商的 +/// 「agent 并发上限」;同时同一 key 哈希固定 → 永远落同一账号(粘性前提), +/// 于是同一用户的请求始终由同一上游账号处理,**prompt / token 缓存得以命中**; +/// 3. 全部冷却 → 挑 `exhausted_until` 最早的一个 best-effort 继续转发 +/// (让上游回真实错误,而不是网关发明一个 5xx;冷却到期后会自动恢复); +/// 4. 真正选了账号且拿到下行 key 时,写 `ukb:` 粘性绑定(变化才写,避免每请求写)。 +/// +/// ⚠️ 只读 `up:` / `upa:` / `uac:` / `ukb:`,**不回源读文件**;未命中即视为不可用。 +pub fn pick_account( + slot: &str, + key: Option<&str>, + now: i64, +) -> Option<(usize, String, String)> { + let (base, n) = read_up(slot)?; + if n == 0 { + return None; + } + + let mut avail: Vec<(usize, String, Vec)> = Vec::new(); + let mut cooled: Vec<(usize, String, i64, Vec)> = Vec::new(); + for i in 0..n { + let (auth, resets) = read_upa(slot, i)?; + if is_cooled(slot, i, now) { + let eu = state::get(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes()) + .and_then(|(v, _)| v.trim().parse::().ok()) + .unwrap_or(0); + cooled.push((i, auth, eu, resets)); + } else { + avail.push((i, auth, resets)); + } + } + + let chosen: (usize, String, Vec) = if !avail.is_empty() { + // 粘性绑定优先 + let bound = key.and_then(|k| { + state::get(KEY_UKB_PREFIX, k.as_bytes()) + .and_then(|(v, _)| v.trim().parse::().ok()) + }); + if let Some(b) = bound { + if let Some(a) = avail.iter().find(|(i, _, _)| *i == b) { + (a.0, a.1.clone(), a.2.clone()) + } else { + // 绑定的账号已被删/减:按下流 key 重新分散(不退化成永远 acct0) + let a = &avail[cold_index(key, avail.len())]; + (a.0, a.1.clone(), a.2.clone()) + } + } else { + // 无绑定:按下流 key 哈希分散选一个(均匀铺开 + 粘性前提) + let a = &avail[cold_index(key, avail.len())]; + (a.0, a.1.clone(), a.2.clone()) + } + } else if !cooled.is_empty() { + // 全冷却:挑最快恢复的一个 + let c = cooled + .into_iter() + .min_by_key(|(_, _, eu, _)| *eu) + .map(|(i, auth, _, resets)| (i, auth, resets)) + .unwrap(); + (c.0, c.1, c.2) + } else { + return None; + }; + + // 写粘性绑定(仅当下行 key 存在且绑定变化) + if let Some(k) = key { + let cur = state::get(KEY_UKB_PREFIX, k.as_bytes()).map(|(v, _)| v.trim().to_owned()); + if cur.as_deref() != Some(&chosen.0.to_string()) { + let ttl = affinity_ttl(&chosen.2); + state::put( + KEY_UKB_PREFIX, + k.as_bytes(), + chosen.0.to_string().as_bytes(), + now + ttl, + ); + } + } + + Some((chosen.0, chosen.1, base)) +} + +// =========================================================================== +// 账号级负载统计(shm 日桶,无数据库;与 uds:/udu: 同构) +// =========================================================================== + +/// 账号级日桶键 = `::<日窗id>` +fn acct_day_key(slot: &str, idx: usize, day: i64) -> String { + format!("{slot}:{idx}:{day}") +} + +/// 记一次转发落到 `#`(请求数 +1)。log 阶段每真实转发调用一次。 +/// +/// ⚠️ 只在这里记——`pick_account` 会被 `$llm_target/$llm_auth/$llm_acct` 三个变量 +/// 各触发一次,若在里面记会三倍计数;log 阶段经 `read_llm_acct` 取一次下标即可。 +pub fn bump_acct_load(slot: &str, idx: usize, now: i64) { + let d = usage::DayBucket { requests: 1, ..Default::default() }; + usage::bump_day(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS); +} + +/// 账号级 token 负载(来源:body filter 从上游响应抓到的 usage)。log 阶段入账。 +pub fn add_acct_tokens(slot: &str, idx: usize, tin: i64, tout: i64, now: i64) { + let d = usage::DayBucket { tin, tout, ..Default::default() }; + usage::bump_day(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS); +} + +/// 账号级额度耗尽次数 +1(仅指标,不参与路由)。 +pub fn bump_acct_exhaust(slot: &str, idx: usize, now: i64) { + let d = usage::DayBucket { requests: 1, ..Default::default() }; + usage::bump_day(KEY_UEX_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS); +} + +/// 读某账号今日负载:`(requests, tin, tout, exhausts)`。 +pub fn read_acct_load(slot: &str, idx: usize, now: i64) -> (i64, i64, i64, i64) { + let day = util::day_id(now); + let b = usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, day)); + let e = usage::day_bucket(KEY_UEX_PREFIX, &acct_day_key(slot, idx, day)); + (b.requests, b.tin, b.tout, e.requests) +} + +/// 最近 `days` 天的日期标签(`MM-DD`),与 [`account_trend`] 的序列**逐位对齐**。 +/// +/// 由后端算而不是前端 `Date` 推导:日窗口径(`util::day_id` 的本地自然日) +/// 只应有一处定义,前端各算一份迟早会在跨时区/跨零点时对不上。 +pub fn trend_labels(now: i64, days_req: i64) -> Vec { + let days = days_req.clamp(1, TREND_DAYS_MAX); + (0..days).rev().map(|i| util::fmt_day(now - i * 86400)).collect() +} + +/// 某 slot 各账号最近 `days` 天的负载序列(图表数据源,默认 14 天)。 +/// +/// 每个账号一条:`requests / in / out / exhausts` 四个等长数组,键精确取、 +/// 不随历史增长。前端用 `requests` 画迷你趋势,一眼看出「哪把 Key 哪天扛了多少」。 +pub fn account_trend(slot: &str, n: usize, now: i64, days_req: i64) -> Vec { + let days = days_req.clamp(1, TREND_DAYS_MAX); + let stamps: Vec = (0..days).rev().map(|i| now - i * 86400).collect(); + let ids: Vec = stamps.iter().map(|t| util::day_id(*t)).collect(); + let mut out = Vec::with_capacity(n); + for idx in 0..n { + let req: Vec = ids + .iter() + .map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).requests) + .collect(); + let tin: Vec = ids + .iter() + .map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tin) + .collect(); + let tout: Vec = ids + .iter() + .map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tout) + .collect(); + let ex: Vec = ids + .iter() + .map(|d| usage::day_bucket(KEY_UEX_PREFIX, &acct_day_key(slot, idx, *d)).requests) + .collect(); + out.push(json!({ + "idx": idx, + "requests": req, + "in": tin, + "out": tout, + "exhausts": ex, + })); + } + out +} + // =========================================================================== // 查询 // =========================================================================== @@ -256,14 +662,23 @@ pub fn models_flat(allowed: &[String]) -> Vec<(String, String)> { /// 新增或覆盖一个上游。 /// -/// `auth = None` 表示**保持原值**(表单只改 base 时不必回填密钥); -/// `Some("")` 表示显式清空。`models = None` 同款语义(保持原清单)。 -/// `enabled = false` 会立刻从共享内存移除。 +/// 参数语义(兼容旧调用方,同时支持多账号): +/// * `models = None` / `auth_raw = None` / `note = None` 都表示**保持原值**; +/// `Some("")` 表示显式清空。 +/// * `accounts = Some(..)` 表示用多账号列表**整体替换**(此时顶层 `auth` 不再生效, +/// 写入时被清为 `""`,避免 `auth` 与 `accounts[0]` 重复);`None` 表示沿用旧逻辑 +/// —— 用 `auth_raw` 维护单账号(legacy `auth` 字段)。 +/// * `exhaust_status` / `exhaust_markers` 同理:`Some` 覆盖,`None` 保持原值。 +/// +/// `enabled = false` 会立刻从共享内存摘除。 pub fn upsert( slot_raw: &str, base_raw: &str, models: Option>, auth_raw: Option<&String>, + accounts: Option>, + exhaust_status: Option>, + exhaust_markers: Option>, enabled: bool, note: Option<&String>, ) -> Result { @@ -279,10 +694,37 @@ pub fn upsert( // 先克隆出来:下面 insert 需要可变借用,不能与这里的不可变借用并存 let existing = table.get(&key).cloned(); - let auth = match auth_raw { - Some(a) => util::trim(a).to_owned(), - None => existing.as_ref().map(|e| e.auth.clone()).unwrap_or_default(), + // 多账号:整体替换(清掉顶层 auth,避免重复);否则走 legacy 单 auth + let (accounts, legacy_auth) = match accounts { + Some(list) => { + let existing_accounts = existing + .as_ref() + .map(|e| e.effective_accounts()) + .unwrap_or_default(); + // 账号 auth 留空 = 保留该下标原账号的密钥(编辑时前端只发掩码外的空串) + let merged: Vec = list + .into_iter() + .enumerate() + .map(|(i, mut a)| { + if a.auth.trim().is_empty() { + if let Some(old) = existing_accounts.get(i) { + a.auth = old.auth.clone(); + } + } + a + }) + .collect(); + (merged, String::new()) + } + None => ( + Vec::new(), + match auth_raw { + Some(a) => util::trim(a).to_owned(), + None => existing.as_ref().map(|e| e.auth.clone()).unwrap_or_default(), + }, + ), }; + let note = match note { Some(n) => util::trim(n).to_owned(), None => existing.as_ref().map(|e| e.note.clone()).unwrap_or_default(), @@ -291,13 +733,37 @@ pub fn upsert( Some(m) => m, None => existing.as_ref().map(|e| e.models.clone()).unwrap_or_default(), }; + let exhaust_status = match exhaust_status { + Some(s) => s, + None => existing + .as_ref() + .map(|e| e.exhaust_status.clone()) + .unwrap_or_default(), + }; + let exhaust_markers = match exhaust_markers { + Some(m) => m, + None => existing + .as_ref() + .map(|e| e.exhaust_markers.clone()) + .unwrap_or_default(), + }; let created_at = existing .as_ref() .map(|e| e.created_at) .filter(|&t| t > 0) .unwrap_or_else(util::now); - let item = Upstream { base, models, auth, enabled, note, created_at }; + let item = Upstream { + base, + models, + enabled, + note, + created_at, + accounts, + exhaust_status, + exhaust_markers, + auth: legacy_auth, + }; table.insert(key.clone(), item.clone()); Ok(item) })?; @@ -330,11 +796,42 @@ pub fn remove(slot_raw: &str) -> Result { /// /// **绝不回显完整 auth**——管理台页面会被截图、被浏览器插件读取, /// 回显上游真 Key 等于把公司所有厂商密钥摆在一个 HTML 里。 +/// +/// 多账号:列出每个账号的掩码 auth / 备注 / 重置周期 / 当前是否冷却, +/// 便于运维直观看到「哪把 Key 在额度耗尽冷却中」。 pub fn view(slot: &str, up: &Upstream, port: &str) -> Value { let (status, code, checked_at) = match health(slot) { Some((ok, c, ts)) => (if ok { "ok" } else { "failed" }, c, ts), None => ("unknown", 0, 0), }; + let now = util::now(); + let accounts: Vec = up + .effective_accounts() + .into_iter() + .enumerate() + .map(|(i, a)| { + let (lr, lin, lout, lex) = read_acct_load(slot, i, now); + json!({ + "idx": i, + "auth_set": !a.auth.is_empty(), + "auth_mask": if a.auth.is_empty() { "-".to_owned() } else { util::mask_key(&a.auth) }, + "note": a.note, + "resets": a.resets, + "resets_text": resets_text(&a.resets), + "cooled": is_cooled(slot, i, now), + "load": { + "requests": lr, + "tokens_in": lin, + "tokens_out": lout, + "exhausts": lex, + }, + }) + }) + .collect(); + let has_auth = accounts.iter().any(|a| a["auth_set"] == Value::Bool(true)); + // 各账号最近 14 天负载序列(图表数据源):用于管理台展示「哪把 Key 哪天扛了多少」 + let acct_trend = account_trend(slot, accounts.len(), now, ACCT_TREND_DAYS); + let labels = trend_labels(now, ACCT_TREND_DAYS); json!({ "slot": slot, "base": up.base, @@ -342,10 +839,15 @@ pub fn view(slot: &str, up: &Upstream, port: &str) -> Value { "anthropic_base_url": anthropic_base_url(slot, up, port), "models": up.models, "model_count": up.models.len(), - "auth_set": !up.auth.is_empty(), - "auth_mask": if up.auth.is_empty() { "-".to_owned() } else { util::mask_key(&up.auth) }, + "account_count": accounts.len(), + "auth_set": has_auth, "enabled": up.enabled, "note": up.note, + "exhaust_status": up.effective_exhaust_status(), + "exhaust_markers": up.exhaust_markers, + "accounts": accounts, + "account_trend": acct_trend, + "trend_labels": labels, "created_at": up.created_at, "created_at_text": util::fmt_time(up.created_at), "status": status, @@ -355,6 +857,31 @@ pub fn view(slot: &str, up: &Upstream, port: &str) -> Value { }) } +/// 把重置周期数组渲染成人类可读文本,如 `[604800, 14400]` → "每周, 每4小时"。 +fn resets_text(resets: &[i64]) -> String { + const H1: i64 = 3600; + const H2: i64 = 2 * 3600; + const H4: i64 = 4 * 3600; + const H6: i64 = 6 * 3600; + const H12: i64 = 12 * 3600; + const D1: i64 = 86400; + const W1: i64 = 7 * 86400; + resets + .iter() + .map(|&s| match s { + H1 => "每1小时".to_owned(), + H2 => "每2小时".to_owned(), + H4 => "每4小时".to_owned(), + H6 => "每6小时".to_owned(), + H12 => "每12小时".to_owned(), + D1 => "每天".to_owned(), + W1 => "每周".to_owned(), + _ => format!("每{}秒", s), + }) + .collect::>() + .join(", ") +} + pub fn view_all(list: &[(String, Upstream)], port: &str) -> Vec { list.iter().map(|(slot, up)| view(slot, up, port)).collect() } diff --git a/rust/crates/plugin-llm/src/usage_filter.rs b/rust/crates/plugin-llm/src/usage_filter.rs index 9f6c518..2c28e65 100644 --- a/rust/crates/plugin-llm/src/usage_filter.rs +++ b/rust/crates/plugin-llm/src/usage_filter.rs @@ -41,6 +41,9 @@ use ngx::ffi::{ngx_chain_t, ngx_http_request_t, ngx_int_t}; use ipass_core::loc::{self, Switch}; use ipass_core::plugin; +use crate::llm; +use crate::upstreams; + /// 尾部窗口容量:SSE 最终 usage 块 / 非 stream JSON 的尾部都远小于此。 const TAIL_CAP: usize = 32 * 1024; @@ -146,12 +149,25 @@ fn last_u64(hay: &[u8], keys: &[&[u8]]) -> Option { // per-request 扫描窗口(挂在模块 ctx 上,请求池分配、随请求回收) // =========================================================================== +/// 内联缓存「额度耗尽」探测配置的上限(避免每 chunk 查 shm,且不引入堆分配/泄漏)。 +/// marker 最长 128 字节、最多 4 个,超出部分截断/忽略(v1 够用,详见 `take_exhausted`)。 +const MAX_MARKERS: usize = 4; +const MARKER_CAP: usize = 128; + #[repr(C)] struct ScanCtx { tail: [u8; TAIL_CAP], len: usize, tin: u64, tout: u64, + /// 响应体命中「额度耗尽」标记(流式也能扫到,log 阶段据此标记账号冷却) + exhausted: bool, + /// 内联缓存的耗尽探测配置(首次扫描时从 `upe:` 读入,随请求池整体回收) + status: [i64; 8], + status_n: usize, + markers: [[u8; MARKER_CAP]; MAX_MARKERS], + marker_len: [usize; MAX_MARKERS], + marker_n: usize, } impl ScanCtx { @@ -243,8 +259,28 @@ unsafe fn scan(r: *mut ngx_http_request_t, in_: *mut ngx_chain_t) { } *slot = p; ctx = p; + // 首次扫描:从 `upe:` 读入耗尽探测配置(状态码 + 响应体标记) + let c = &mut *ctx; + if let Some(s) = llm::slot_of(r) { + let (status, markers) = upstreams::read_upe(&s); + let n = status.len().min(c.status.len()); + c.status[..n].copy_from_slice(&status[..n]); + c.status_n = n; + let m = markers.len().min(MAX_MARKERS); + for i in 0..m { + let bytes = markers[i].as_bytes(); + let cap = bytes.len().min(MARKER_CAP); + if cap > 0 { + c.markers[i][..cap].copy_from_slice(&bytes[..cap]); + c.marker_len[i] = cap; + } + } + c.marker_n = m; + } } + // ctx 此刻一定非 null 且指向有效内存;用 &mut 引用操作,避免裸指针隐式自动取引用报错 + let c = &mut *ctx; let mut cl = in_; while !cl.is_null() { let buf = (*cl).buf; @@ -256,10 +292,26 @@ unsafe fn scan(r: *mut ngx_http_request_t, in_: *mut ngx_chain_t) { if !pos.is_null() && !last.is_null() && last > pos { // SAFETY: 内存 buf 的 pos..last 由 nginx 保证有效 let data = slice::from_raw_parts(pos, last as usize - pos as usize); - (*ctx).append(data); + c.append(data); + // 扫「额度耗尽」标记(逐字节子串匹配,流式响应也能命中) + if !c.exhausted && c.marker_n > 0 { + for i in 0..c.marker_n { + let ml = c.marker_len[i]; + if ml == 0 { + continue; + } + let needle = &c.markers[i][..ml]; + if data.len() >= needle.len() + && data.windows(needle.len()).any(|w| w == needle) + { + c.exhausted = true; + break; + } + } + } } if (*buf).last_buf() != 0 { - (*ctx).finish(); + c.finish(); } } } @@ -282,3 +334,25 @@ pub fn take(r: *mut ngx_http_request_t) -> (u64, u64) { } } } + +/// log 阶段读取本请求响应体是否命中「额度耗尽」标记。 +/// +/// 与 [`take`] 同生命周期:ctx 随请求池回收,无需清理钩子。 +/// 仅 LLM location 的 body filter 会置位;其它请求恒为 false(靠状态码判定兜底)。 +pub fn take_exhausted(r: *mut ngx_http_request_t) -> bool { + if r.is_null() { + return false; + } + unsafe { + let slot = ctx_slot(r); + if slot.is_null() { + return false; + } + let c = *slot; + if c.is_null() { + false + } else { + (*c).exhausted + } + } +} diff --git a/tests/llm/e2e.sh b/tests/llm/e2e.sh index a18e7ef..f394e68 100755 --- a/tests/llm/e2e.sh +++ b/tests/llm/e2e.sh @@ -26,6 +26,8 @@ PY=${PY:-python3} # fixtures 里的固定 Key(见 fixtures/users.json) ALICE_KEY=sk_alice_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa BOB_KEY=sk_bob_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +# 多账号路由验证用 admin:白名单为空=不限、无配额限制、且本套件中途会删除 bob 故不复用 +ADMIN_KEY=sk_admin_0000000000000000000000000000000000000000000000ab pass=0; fail=0 ck() { @@ -513,6 +515,92 @@ curl -s -H "Authorization: Bearer $ALICE_KEY" -X POST $GW/openai/v1/chat/complet sleep 0.3 TOK=$(curl -s -b "$JAR" $API/api/admin/usage) +echo "【多账号路由】粘性绑定 + 额度耗尽自动切换" +# 用 admin(白名单为空=不限;本套件中途会删除 bob,故不复用 bob) +ck "admin 基础鉴权(openai,白名单不限)→ 200" 200 "$(code -H "Authorization: Bearer $ADMIN_KEY" -X POST $GW/openai/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"gpt-4o","messages":[{"role":"user","content":"hi"}],"max_tokens":8}')" +acct_of() { curl -s -D - -o /dev/null -X POST "$GW/$1/v1/chat/completions" \ + -H "Authorization: Bearer $ADMIN_KEY" -H 'Content-Type: application/json' \ + -d '{"model":"'"$2"'","messages":[{"role":"user","content":"hi"}],"max_tokens":8}' \ + | grep -i '^X-Upstream-Acct' | tr -d '\r' | awk '{print $2}'; } +code_of() { curl -s -o /dev/null -w '%{http_code}' -X POST "$GW/$1/v1/chat/completions" \ + -H "Authorization: Bearer $ADMIN_KEY" -H 'Content-Type: application/json' \ + -d '{"model":"'"$2"'","messages":[{"role":"user","content":"hi"}],"max_tokens":8}'; } + +ck "sticky 首次请求命中 acct=0" 0 "$(acct_of sticky sticky-model)" +ck "sticky 首次请求 200" 200 "$(code_of sticky sticky-model)" +ck "sticky 粘性:第 2 次仍 acct=0" 0 "$(acct_of sticky sticky-model)" +ck "sticky 粘性:第 3 次仍 acct=0" 0 "$(acct_of sticky sticky-model)" + +# 切换:multi slot accounts[0]=bad(命中假上游 UPSTREAM_FAIL_AUTH → 401+marker)→ 自动切 acct=1 +mh() { curl -s -D - -o /dev/null -X POST "$GW/$1/v1/chat/completions" \ + -H "Authorization: Bearer $ADMIN_KEY" -H 'Content-Type: application/json' \ + -d '{"model":"'"$2"'","messages":[{"role":"user","content":"hi"}],"max_tokens":8}' \ + | grep -iE '^HTTP/|^X-Upstream-Acct' | tr -d '\r'; } +M1=$(mh multi multi-model) +ck "multi 初次请求打到 acct=0(bad)" 0 "$(echo "$M1" | awk '/X-Upstream-Acct/{print $2}')" +ck "multi 初次请求 401(触发冷却)" 401 "$(echo "$M1" | awk '/^HTTP/{print $2}')" +M2=$(mh multi multi-model) +ck "multi 冷却中切到 acct=1" 1 "$(echo "$M2" | awk '/X-Upstream-Acct/{print $2}')" +ck "multi 切到 acct=1 后 200" 200 "$(echo "$M2" | awk '/^HTTP/{print $2}')" +M3=$(mh multi multi-model) +ck "multi 冷却期间保持 acct=1(不回退坏账号)" 1 "$(echo "$M3" | awk '/X-Upstream-Acct/{print $2}')" +# 靶机验证:再发一次确认切换后的账号,读靶机实际收到的 auth(证明下行 Key 真被换成对应账号 Key) +M4=$(mh multi multi-model) +ck "multi 切换后下游 Key 真换成 acct-good" "Bearer acct-good" "$(up_hdr Authorization)" + +# ---- 账号级负载统计(管理台「密钥 / 负载」列的数据源)---- +# 每次真实转发在 log 阶段落到「本次选中的那个账号」的日桶 uda:::; +# 额度耗尽另记 uex:。用同一份 /api/admin/upstreams 投影断言负载分布是否正确。 +UPS=$(curl -s -b "$JAR" $API/api/admin/upstreams) +acct_num() { # $1=slot $2=idx $3=度量路径(如 load.requests)→ 取账号级数值 + printf '%s' "$UPS" | "$PY" -c ' +import sys, json +slot, idx, path = sys.argv[1], int(sys.argv[2]), sys.argv[3] +d = json.load(sys.stdin) +items = d["data"]["items"] if isinstance(d.get("data"), dict) else (d.get("data") or []) +for u in items: + if u.get("slot") == slot: + for a in u.get("accounts", []): + if a.get("idx") == idx: + cur = a + for k in path.split("."): + cur = cur.get(k) if isinstance(cur, dict) else None + print(cur if cur is not None else 0) + sys.exit(0) +print(0) +' "$1" "$2" "$3" +} +ck "★sticky 账号#0 记到今日请求(负载分布生效)" yes "$([ "$(acct_num sticky 0 load.requests)" -ge 3 ] && echo yes || echo no)" +ck "★sticky 账号#1 未被分配(0 请求,粘性=集中在一把 Key)" 0 "$(acct_num sticky 1 load.requests)" +ck "★multi 账号#0 记到 1 次额度耗尽" yes "$([ "$(acct_num multi 0 load.exhausts)" -ge 1 ] && echo yes || echo no)" +ck "★multi 账号#1 记到今日请求(切换后负载落在新 Key)" yes "$([ "$(acct_num multi 1 load.requests)" -ge 3 ] && echo yes || echo no)" +ck "账号级趋势序列含 14 天" 14 \ + "$(printf '%s' "$UPS" | "$PY" -c ' +import sys, json +d = json.load(sys.stdin) +items = d["data"]["items"] if isinstance(d.get("data"), dict) else (d.get("data") or []) +for u in items: + if u.get("slot") == "sticky": + t = u.get("account_trend") or [{}] + print(len(t[0].get("requests") or [])) + break +else: + print(0) +')" +# 日期标签与趋势序列逐位对齐(图表悬停提示用;由后端算,避免前后端各自推导时区) +ck "账号趋势带 14 个日期标签(与序列对齐)" 14 \ + "$(printf '%s' "$UPS" | "$PY" -c ' +import sys, json +d = json.load(sys.stdin) +items = d["data"]["items"] if isinstance(d.get("data"), dict) else (d.get("data") or []) +for u in items: + if u.get("slot") == "sticky": + print(len(u.get("trend_labels") or [])) + break +else: + print(0) +')" + # ---- 趋势(日桶)---- # 口径与请求级用量一致:只统计真正转发出去的请求与上游 usage 里的 token TR=$(curl -s -b "$JAR" "$API/api/admin/trend?days=7") diff --git a/tests/llm/fixtures/llm-upstreams.json b/tests/llm/fixtures/llm-upstreams.json index 13aa3bd..051b74d 100644 --- a/tests/llm/fixtures/llm-upstreams.json +++ b/tests/llm/fixtures/llm-upstreams.json @@ -30,5 +30,30 @@ "enabled": true, "note": "base 自带 /v1(厂商文档的常见写法),用于验证版本段不重复拼接", "created_at": 1757500000 + }, + "multi": { + "base": "http://127.0.0.1:18999", + "models": ["multi-model"], + "enabled": true, + "accounts": [ + {"auth": "Bearer acct-bad", "note": "bad", "resets": [18000, 604800]}, + {"auth": "Bearer acct-good", "note": "good", "resets": [18000, 604800]} + ], + "exhaust_status": [401, 402, 429, 403], + "exhaust_markers": ["\"status_code\":1004"], + "note": "一坏一好,验证额度耗尽自动切换(bad 命中假上游 UPSTREAM_FAIL_AUTH)", + "created_at": 1757500000 + }, + "sticky": { + "base": "http://127.0.0.1:18999", + "models": ["sticky-model"], + "enabled": true, + "accounts": [ + {"auth": "Bearer g-a", "note": "a", "resets": [18000]}, + {"auth": "Bearer g-b", "note": "b", "resets": [18000]} + ], + "exhaust_status": [401], + "note": "两账号均好,验证同一下游 key 粘性绑定到首个账号", + "created_at": 1757500000 } } diff --git a/tests/llm/nginx.conf.in b/tests/llm/nginx.conf.in index 427b5c0..f465402 100644 --- a/tests/llm/nginx.conf.in +++ b/tests/llm/nginx.conf.in @@ -72,6 +72,10 @@ http { proxy_set_header X-Real-IP $remote_addr; proxy_set_header Connection ""; + # 调试可见:暴露本次请求选中的上游账号下标(多账号路由验证用)。 + # 仅测试配置暴露;生产是否暴露由部署决定(不影响安全,只泄露账号序号)。 + add_header X-Upstream-Acct $llm_acct always; + # SSE 流式两件套(响应方向;请求方向不再 no_buffering,理由见 # 生产 conf/nginx.conf——与对话审计的 client_body_in_file_only 互斥) proxy_buffering off; diff --git a/tests/llm/upstream.py b/tests/llm/upstream.py index 96a5441..44f93ba 100644 --- a/tests/llm/upstream.py +++ b/tests/llm/upstream.py @@ -16,6 +16,9 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer LOG = os.environ.get("UPSTREAM_LOG", "/tmp/upstream.log") PORT = int(os.environ.get("UPSTREAM_PORT", "18999")) +# 故障注入(多账号路由测试):收到的 Authorization 含此子串时模拟「上游账号额度耗尽」, +# 回 401 + 响应体标记(与 MiniMax 的 status_code:1004 同构),验证网关自动切换。 +FAIL_AUTH = os.environ.get("UPSTREAM_FAIL_AUTH", "") class H(BaseHTTPRequestHandler): @@ -61,6 +64,20 @@ class H(BaseHTTPRequestHandler): body = self.rfile.read(n) self._record(body) + # 故障注入(多账号路由测试):收到的 Authorization 含 UPSTREAM_FAIL_AUTH 子串时, + # 模拟「上游账号额度耗尽」——回 401 + 响应体标记(与 MiniMax 的 status_code:1004 同构), + # 验证网关「状态码 + body marker 双重检测 → 标记冷却 → 下次自动切到下一个账号」。 + if FAIL_AUTH and FAIL_AUTH in self.headers.get("Authorization", "-"): + payload = json.dumps( + {"base_resp": {"status_code": 1004, "status_msg": "exhausted"}} + ).encode() + self.send_response(401) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(payload))) + self.end_headers() + self.wfile.write(payload) + return + # 故障注入:body 带 `"boom":true` 时回 500,用来验证网关的 # 上游健康标记(log 阶段把 5xx 写进 uh: 缓存 → 列表标红) if b'"boom"' in body: diff --git a/tests/run.sh b/tests/run.sh index 71cd9df..39dedba 100755 --- a/tests/run.sh +++ b/tests/run.sh @@ -155,7 +155,7 @@ except Exception: sys.exit(1)' && sleep 0.2 || break done - UPSTREAM_LOG="$RUN/upstream.log" UPSTREAM_PORT=18999 "$PY" "$HERE/llm/upstream.py" \ + UPSTREAM_LOG="$RUN/upstream.log" UPSTREAM_PORT=18999 UPSTREAM_FAIL_AUTH="acct-bad" "$PY" "$HERE/llm/upstream.py" \ >"$RUN/logs/upstream.out" 2>&1 & up_pid=$! diff --git a/www/assets/admin.css b/www/assets/admin.css index 9b82e90..b7d5df3 100644 --- a/www/assets/admin.css +++ b/www/assets/admin.css @@ -183,3 +183,23 @@ button.host-copy:hover{text-decoration:underline solid} /* 弹窗内表单同样限宽两列,窄屏单列;spa-all 跨整行由通用 .grid-form 规则保证 */ .modal-body .grid-form.up-form{grid-template-columns:repeat(2,1fr)} @media (max-width:600px){.modal-body .grid-form.up-form{grid-template-columns:1fr}} +/* 多账号上游:宽弹窗 + 账号行 */ +.modal-card.modal-wide{max-width:860px} +.acct-list{display:flex;flex-direction:column;gap:10px;margin-bottom:8px} +.acct-row{border:1px solid var(--border);border-radius:8px;padding:10px 12px;background:var(--bg); + display:flex;flex-direction:column;gap:8px} +.acct-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap} +.acct-row .acct-auth,.acct-row .acct-note,.acct-row .acct-resets{width:100%} +.acct-row .acct-del{margin-left:auto} +.acct-empty{font-size:12.5px;padding:6px 0} + +/* 上游「密钥」列:每账号负载块(请求/token/耗尽 + 比例条 + 14天迷你趋势)*/ +.acct-load{padding:4px 0;border-bottom:1px dashed #eef1f5} +.acct-load:last-child{border-bottom:0} +.acct-load .load-line{font-size:11.5px;color:var(--muted);margin:2px 0 3px} +.acct-load .load-bar{height:5px;background:#eef1f5;border-radius:3px;overflow:hidden} +.acct-load .load-bar span{display:block;height:100%;background:var(--c-req);border-radius:3px} +.spark{margin-top:3px} +.spark-svg{display:block} +.spark-svg .s-bar{fill:var(--c-req)} +.spark-svg .s-zero{fill:#e6eaf0} diff --git a/www/assets/core.js b/www/assets/core.js index a698025..c132393 100644 --- a/www/assets/core.js +++ b/www/assets/core.js @@ -246,7 +246,7 @@ window.IP = (function () { var overlay = document.createElement("div"); overlay.className = "modal-overlay"; overlay.innerHTML = - '