feat(llm): 上游多账号路由 + 账号级负载统计 (1.0.14)
一个 slot 挂多把上游账号 Key,解决厂商「单账号额度/并发受限」与 「同一用户缓存命中」两个矛盾诉求。 多账号路由 (plugin-llm) - models: Upstream.accounts[] (auth/note/resets) + 上游级 exhaust_status/exhaust_markers;顶层 auth 保留兼容(accounts 为空时合成单账号) - upstreams::pick_account:粘性绑定 ukb:<key> 优先 → 无绑定时 FNV-1a(下游 Key) % 可用数 冷分散 → 绑定账号冷却则重新分散 → 全冷却取最早恢复 * 分散避开厂商单账号 agent 并发上限;落点固定保住 prompt/token 缓存 - cool_until_until 天锚定冷却:boundary = day0 + ceil(已过/窗口)*窗口, 封顶次日 0 点(MiniMax 5h 窗口、24=5*4+4 → 末段 20:00-24:00 只有 4h 随天重置) - 耗尽双检测 (log 阶段):$upstream_status 命中 exhaust_status,或 usage_filter 流式扫到 marker → $llm_acct 定位本次账号 → 写冷却 uac: - shm: up:/upa:/uac:/ukb:/upe: 五类前缀;$llm_acct 变量 (NOCACHEABLE) 账号级负载统计(问题发现与跟踪) - 新增 uda:<slot>:<idx>:<day>(请求/token)与 uex:(耗尽次数) 日桶, 复用内核 usage::bump_day —— 无数据库、无新进程(项目红线) - 计数点只在 log 阶段一次;pick_account 会被 $llm_target/$llm_auth/$llm_acct 三个变量各触发一次,放进那里会三倍计数 - view() 投影带每账号 load 与 account_trend + trend_labels(日期由后端算) - 管理台「上游」页密钥列:各 Key 今日请求/token/耗尽 + 负载比例条 + 14 天迷你趋势(自绘 SVG,零第三方依赖)+ 冷却/耗尽徽标 + 上游合计 测试与验证 - 回归 279 条全绿(网关 102 + LLM 177),新增 6 条多账号/负载断言 - 假上游新增 UPSTREAM_FAIL_AUTH 模拟账号额度耗尽;靶机验证 Key 真被替换 - 前端以真实 admin.css + upstreams.js 渲染路径做无头浏览器断言: 比例条与负载成比例(412 vs 96 → 100%/23%)、每账号 14 条块、 悬停峰值日期与数据逐位吻合、单账号/无账号兜底正常、无横向溢出、零 JS 错误 文档 - 新增 docs/llm/MULTI_ACCOUNT_ROUTING.md(数据模型/路由/冷却数学/shm 布局/负载统计) - readme §11 数据模型 + §15 上游配置 + §15 用量统计 + §12.6 tag 表 + §16 变更记录 - 修正 docs/llm/*.md 中插件化前的过时路径(rust/src/* → crates/plugin-llm/src/*)
This commit is contained in:
1 parent
db99ce1521
commit
bfa3cf8ff8
21 files changed
+1506
-85
No files matched your search
@@ -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`
|
||||
|
||||
@@ -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 <key1>", "note": "acct-1", "resets": [604800, 18000]},
|
||||
{"auth": "Bearer <key2>", "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:<downstream_key> → 已有账号下标
|
||||
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:<slot>` | `base \n <naccounts>` | 上游基址 + 账号数 |
|
||||
| `upa:<slot>:<idx>` | `auth \n <resets csv>` | 单账号 auth + 重置周期 |
|
||||
| `uac:<slot>:<idx>` | `exhausted_until` | 冷却截止(TTL = until,自然到期即视为恢复) |
|
||||
| `ukb:<downstream_key>` | `acct_idx` | 粘性绑定(TTL = max resets) |
|
||||
| `upe:<slot>` | `status_csv \n markers_json` | 上游级耗尽检测配置 |
|
||||
| `uda:<slot>:<idx>:<day>` | `requests:tin:tout`(`DayBucket`) | 账号级负载日桶(TTL 90 天) |
|
||||
| `uex:<slot>:<idx>:<day>` | `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 错误。
|
||||
@@ -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` 的调用点也在此。
|
||||
> 阅读时以**模块名**为准,不要按行号定位。
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -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`。
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -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 <key1>", "note": "主账号", "resets": [604800, 18000]},
|
||||
{"auth": "Bearer <key2>", "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:<slot>:<idx>:<day>` |
|
||||
| 比例条 | 该 Key 占**本上游负载最大 Key** 的百分比(谁在扛、有没有偏斜) | 同上 |
|
||||
| 14 天迷你趋势 | 悬停显示近 14 天合计 / 峰值 / 峰值日期 | 同上 + `trend_labels` |
|
||||
| `冷却` 徽标 | 该账号当前处于额度耗尽冷却 | `uac:<slot>:<idx>` |
|
||||
| `耗尽N` 徽标 | **今日**被判额度耗尽并冷却的次数 | `uex:<slot>:<idx>:<day>` |
|
||||
| 上游级合计 | `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:<downstream_key>` 优先 → 无绑定时
|
||||
`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:<slot>:<idx>:<day>`(请求/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`)。
|
||||
|
||||
@@ -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::<Vec<crate::models::UpstreamAccount>>(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::<Vec<String>>(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<Vec<i64>> {
|
||||
let s = raw?;
|
||||
let s = s.trim();
|
||||
if s.is_empty() {
|
||||
return None;
|
||||
}
|
||||
if let Ok(v) = serde_json::from_str::<Vec<i64>>(s) {
|
||||
return Some(v);
|
||||
}
|
||||
Some(
|
||||
s.split(',')
|
||||
.filter_map(|x| x.trim().parse::<i64>().ok())
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
/// 把管理台/接口传入的模型列表串拆成模型名数组。
|
||||
///
|
||||
/// 允许的写法(混用也认):`a,b` / `a、b` / `a;b` / 一行一个。
|
||||
|
||||
@@ -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:<slot>:<idx>:<日窗id>`,
|
||||
/// value = DayBucket(requests = 转发到该账号的请求数,tin/tout = 该账号 token 消耗)。
|
||||
/// 与 `uds:`(slot 级)同构、多一维账号下标——「各上游 Key 负载」就靠它,
|
||||
/// 无需数据库(项目红线)。TTL 90 天自然淘汰。
|
||||
pub const KEY_UDAY_ACCT_PREFIX: &[u8] = b"uda:";
|
||||
|
||||
/// 键前缀:上游账号**额度耗尽次数**日桶。键 = `uex:<slot>:<idx>:<日窗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:<slot>`,
|
||||
/// 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:<slot>:<idx>`,
|
||||
/// value = `<auth> \n <resets csv>`(`resets` 为空则第二段为空)。
|
||||
///
|
||||
/// `auth` 是完整 Authorization 头值;`resets` 是该账号额度重置周期(秒,逗号分隔)。
|
||||
/// 与 `up:` 拆开存,是因为账号是热路径要枚举的对象、而 `up:` 只存 base + 账号数,
|
||||
/// 避免一次大 payload 反序列化;账号数记在 `up:<slot>` 第二段,热路径据此循环读取。
|
||||
pub const KEY_UPA_PREFIX: &[u8] = b"upa:";
|
||||
|
||||
/// 键前缀:上游账号「额度耗尽」冷却(**运行时状态**,非配置)。
|
||||
/// 键 = `uac:<slot>:<idx>`,value = `<exhausted_until>`(绝对秒)。
|
||||
///
|
||||
/// 写入时 `expires_at` 直接设为 `exhausted_until`——共享内存到期即视为不再冷却,
|
||||
/// 「额度恢复」是天然发生的,无需额外清扫。log 阶段在检测到耗尽时写;
|
||||
/// 热路径 `pick_account` 用 `get_live` 判定「该账号当前是否在冷却」。
|
||||
pub const KEY_UAC_PREFIX: &[u8] = b"uac:";
|
||||
|
||||
/// 键前缀:用户 key → 上游账号 粘性绑定。键 = `ukb:<downstream_key>`,
|
||||
/// value = `<acct_idx>`(usize 字符串)。
|
||||
///
|
||||
/// 带 TTL(取该账号最长重置周期,或兜底 7 天),**尽力粘性**:重启后丢失、重新绑定,
|
||||
/// 符合「尽可能同一用户 key 用同一上游 key」的语义。只有真正选了账号且拿到下行 key
|
||||
/// 时才写;内部测试 location(无下行 key)不写,避免污染绑定表。
|
||||
pub const KEY_UKB_PREFIX: &[u8] = b"ukb:";
|
||||
|
||||
/// 键前缀:上游级「额度耗尽」探测配置。键 = `upe:<slot>`,
|
||||
/// value = `<status csv> \n <markers json>`(`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;
|
||||
|
||||
// ===========================================================================
|
||||
// 趋势
|
||||
// ===========================================================================
|
||||
|
||||
@@ -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<usize> {
|
||||
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::<usize>().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
|
||||
|
||||
@@ -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<String> {
|
||||
let resolved = (|| -> Option<(String, String, String, usize)> {
|
||||
let slot = slot_of(r)?;
|
||||
// up:<slot> 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);
|
||||
|
||||
@@ -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<String, Upstream>;
|
||||
|
||||
/// 单个上游账号:一把上游真 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<i64>,
|
||||
}
|
||||
|
||||
/// 单个 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<String>,
|
||||
/// 完整的 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<UpstreamAccount>,
|
||||
/// 上游级「额度耗尽」探测配置(同一厂商所有账号共享错误形态)。
|
||||
///
|
||||
/// 命中下列任一即判该账号额度耗尽、进入冷却:上游返回这些 HTTP 状态码,
|
||||
/// **或** 响应体(流式也能扫,见 `usage_filter`)含任一 `exhaust_markers` 子串。
|
||||
/// 空 = 用 `config::EXHAUST_STATUS_DEFAULT`(默认 `[402, 429, 403]`)。
|
||||
#[serde(default)]
|
||||
pub exhaust_status: Vec<i64>,
|
||||
/// 响应体「额度耗尽」标记子串(大小写敏感,逐字节匹配)。
|
||||
/// 例:MiniMax 余额不足可配 `"status_code":1004` 或 `余额不足`。
|
||||
#[serde(default)]
|
||||
pub exhaust_markers: Vec<String>,
|
||||
/// 兼容旧版单 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<UpstreamAccount> {
|
||||
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<i64> {
|
||||
if self.exhaust_status.is_empty() {
|
||||
EXHAUST_STATUS_DEFAULT.to_vec()
|
||||
} else {
|
||||
self.exhaust_status.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<String, String> {
|
||||
// 共享内存同步(写穿 / 装载)
|
||||
// ===========================================================================
|
||||
|
||||
/// 一个 slot 最多支持的账号下标(清理残留旧账号下标时遍历的上界)。
|
||||
/// 实际部署不会接近这个数;超出部分不被支持(管理台会拦)。
|
||||
const ACCOUNT_INDEX_MAX: usize = 64;
|
||||
|
||||
/// `up:<slot>` payload:`base \n <账号数>`。
|
||||
fn up_payload(base: &str, n: usize) -> String {
|
||||
format!("{base}\n{n}")
|
||||
}
|
||||
|
||||
/// `upa:<slot>:<idx>` payload:`auth \n <resets csv>`(resets 空则第二段为空)。
|
||||
fn upa_payload(auth: &str, resets: &[i64]) -> String {
|
||||
let csv = resets
|
||||
.iter()
|
||||
.map(|x| x.to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join(",");
|
||||
format!("{auth}\n{csv}")
|
||||
}
|
||||
|
||||
/// 把一条上游配置同步进共享内存。**所有写操作之后必须调用它**。
|
||||
///
|
||||
/// 关闭(`enabled=false`)时是**删除**而不是写入空值——热路径
|
||||
/// 「查不到 = 不可用」,这样停用即刻生效,且不留残留条目。
|
||||
/// 关闭(`enabled=false`)时是**删除**整个 slot 的键(up/upa/uac/upe),而不是
|
||||
/// 写入空值——热路径「查不到 = 不可用」,停用即刻生效且不留残留。
|
||||
///
|
||||
/// 多账号布局(见 `config` 的键前缀注释):
|
||||
/// * `up:<slot>` = `base \n <账号数>`
|
||||
/// * `upa:<slot>:<i>` = `auth \n <resets csv>`(每个账号一条)
|
||||
/// * `upe:<slot>` = `<status csv> \n <markers json>`(上游级耗尽探测配置)
|
||||
/// * `uac:<slot>:<i>`(冷却运行时态)**不在此清除**——保留到自然到期,
|
||||
/// 这样「正在冷却的账号」不会因为一次普通的 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:<slot>` = `<status csv> \n <markers json>`。
|
||||
fn write_upe(slot: &str, up: &Upstream) {
|
||||
let status = up
|
||||
.effective_exhaust_status()
|
||||
.iter()
|
||||
.map(|x| x.to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.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:<slot>`:`(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::<usize>().unwrap_or(0);
|
||||
Some((base.to_owned(), n))
|
||||
}
|
||||
|
||||
/// 读 `upa:<slot>:<i>`:`(auth, resets)`。
|
||||
pub fn read_upa(slot: &str, i: usize) -> Option<(String, Vec<i64>)> {
|
||||
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::<i64>().ok())
|
||||
.collect()
|
||||
};
|
||||
Some((auth.to_owned(), resets))
|
||||
}
|
||||
|
||||
/// 读 `upe:<slot>`:`(status 列表, markers 列表)`。
|
||||
pub fn read_upe(slot: &str) -> (Vec<i64>, Vec<String>) {
|
||||
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::<i64>().ok())
|
||||
.collect()
|
||||
};
|
||||
let markers = serde_json::from_str::<Vec<String>>(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<i64>)> = Vec::new();
|
||||
let mut cooled: Vec<(usize, String, i64, Vec<i64>)> = 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::<i64>().ok())
|
||||
.unwrap_or(0);
|
||||
cooled.push((i, auth, eu, resets));
|
||||
} else {
|
||||
avail.push((i, auth, resets));
|
||||
}
|
||||
}
|
||||
|
||||
let chosen: (usize, String, Vec<i64>) = if !avail.is_empty() {
|
||||
// 粘性绑定优先
|
||||
let bound = key.and_then(|k| {
|
||||
state::get(KEY_UKB_PREFIX, k.as_bytes())
|
||||
.and_then(|(v, _)| v.trim().parse::<usize>().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: 同构)
|
||||
// ===========================================================================
|
||||
|
||||
/// 账号级日桶键 = `<slot>:<idx>:<日窗id>`
|
||||
fn acct_day_key(slot: &str, idx: usize, day: i64) -> String {
|
||||
format!("{slot}:{idx}:{day}")
|
||||
}
|
||||
|
||||
/// 记一次转发落到 `<slot>#<idx>`(请求数 +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<String> {
|
||||
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<Value> {
|
||||
let days = days_req.clamp(1, TREND_DAYS_MAX);
|
||||
let stamps: Vec<i64> = (0..days).rev().map(|i| now - i * 86400).collect();
|
||||
let ids: Vec<i64> = stamps.iter().map(|t| util::day_id(*t)).collect();
|
||||
let mut out = Vec::with_capacity(n);
|
||||
for idx in 0..n {
|
||||
let req: Vec<i64> = ids
|
||||
.iter()
|
||||
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).requests)
|
||||
.collect();
|
||||
let tin: Vec<i64> = ids
|
||||
.iter()
|
||||
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tin)
|
||||
.collect();
|
||||
let tout: Vec<i64> = ids
|
||||
.iter()
|
||||
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tout)
|
||||
.collect();
|
||||
let ex: Vec<i64> = 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<Vec<String>>,
|
||||
auth_raw: Option<&String>,
|
||||
accounts: Option<Vec<UpstreamAccount>>,
|
||||
exhaust_status: Option<Vec<i64>>,
|
||||
exhaust_markers: Option<Vec<String>>,
|
||||
enabled: bool,
|
||||
note: Option<&String>,
|
||||
) -> Result<Upstream, String> {
|
||||
@@ -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<UpstreamAccount> = 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<String, String> {
|
||||
///
|
||||
/// **绝不回显完整 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<Value> = 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::<Vec<_>>()
|
||||
.join(", ")
|
||||
}
|
||||
|
||||
pub fn view_all(list: &[(String, Upstream)], port: &str) -> Vec<Value> {
|
||||
list.iter().map(|(slot, up)| view(slot, up, port)).collect()
|
||||
}
|
||||
|
||||
@@ -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<u64> {
|
||||
// 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:<slot>` 读入,随请求池整体回收)
|
||||
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:<slot>` 读入耗尽探测配置(状态码 + 响应体标记)
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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:<slot>:<idx>:<day>;
|
||||
# 额度耗尽另记 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")
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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:
|
||||
|
||||
+1
-1
@@ -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=$!
|
||||
|
||||
|
||||
@@ -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}
|
||||
+1
-1
@@ -246,7 +246,7 @@ window.IP = (function () {
|
||||
var overlay = document.createElement("div");
|
||||
overlay.className = "modal-overlay";
|
||||
overlay.innerHTML =
|
||||
'<div class="modal-card" role="dialog" aria-modal="true">' +
|
||||
'<div class="modal-card' + (opts.wide ? " modal-wide" : "") + '" role="dialog" aria-modal="true">' +
|
||||
'<div class="modal-head"><h3>' + esc(opts.title || "") + '</h3>' +
|
||||
'<button type="button" class="modal-close" aria-label="关闭">×</button></div>' +
|
||||
'<div class="modal-body">' + (opts.html || "") + '</div>' +
|
||||
|
||||
+135
-12
@@ -4,6 +4,32 @@
|
||||
|
||||
var $ = IP.$;
|
||||
|
||||
/// 迷你趋势:一组数值画成等宽竖条 SVG(14 点)。0 用浅灰、有值用蓝。
|
||||
/// 用于「密钥」列里每把上游 Key 的近 14 天请求量,一眼看出负载分布;
|
||||
/// 悬停给出合计 / 峰值 / 首个非零日,便于「跟踪」(不必逐条点开)。
|
||||
function spark(arr, labels) {
|
||||
arr = arr || [];
|
||||
if (!arr.length) return "";
|
||||
var max = Math.max.apply(null, arr.concat([1]));
|
||||
var sum = arr.reduce(function (a, b) { return a + b; }, 0);
|
||||
var w = 140, h = 22, n = arr.length, gap = 1;
|
||||
var bw = (w - (n - 1) * gap) / n;
|
||||
var bars = arr.map(function (v, i) {
|
||||
var bh = Math.max(1, Math.round(v / max * (h - 2)));
|
||||
var x = i * (bw + gap);
|
||||
var y = h - bh;
|
||||
return "<rect class='" + (v === 0 ? "s-zero" : "s-bar") + "' x='" + x.toFixed(1) +
|
||||
"' y='" + y.toFixed(1) + "' width='" + bw.toFixed(1) + "' height='" + bh.toFixed(1) + "' rx='0.5'></rect>";
|
||||
}).join("");
|
||||
var tip = "近 " + n + " 天:" + sum + " 请求,峰值 " + max;
|
||||
if (labels && labels.length === n) {
|
||||
var peak = arr.indexOf(max);
|
||||
if (peak >= 0 && max > 0) tip += "(" + labels[peak] + ")";
|
||||
}
|
||||
return "<svg class='spark-svg' viewBox='0 0 " + w + " " + h + "' width='" + w + "' height='" + h +
|
||||
"'><title>" + IP.esc(tip) + "</title>" + bars + "</svg>";
|
||||
}
|
||||
|
||||
/// 由 base_url(协议中立,端口跟随当前访问管理台所用的 Host)推导两种协议的完整 API 地址。
|
||||
/// base 写了路径(钉死粒度)时不重复追加对应后缀
|
||||
function apiUrls(base) {
|
||||
@@ -14,9 +40,33 @@
|
||||
};
|
||||
}
|
||||
|
||||
/// 单账号行 HTML(编辑态用,i 为序号;a 为已有账号视图,可能来自后端 view())
|
||||
function acctRowHtml(a, i) {
|
||||
a = a || {};
|
||||
var masked = a.auth_mask
|
||||
? "<code class='mono'>" + IP.esc(a.auth_mask) + "</code><span class='muted'>(留空=保留原值)</span>"
|
||||
: "<span class='muted'>新账号</span>";
|
||||
return "<div class='acct-row' data-idx='" + i + "'>" +
|
||||
"<div class='acct-head'>" +
|
||||
"<span class='badge b-gray'>#" + i + "</span>" + masked +
|
||||
(a.cooled ? "<span class='badge b-err'>冷却中</span>" : "") +
|
||||
"<button type='button' class='btn-sm btn-danger acct-del'>删除</button>" +
|
||||
"</div>" +
|
||||
"<input class='field-mono acct-auth' placeholder='sk-...(编辑时留空=保留原值)' autocomplete='off'>" +
|
||||
"<input class='acct-note' placeholder='备注,如 minimax-周额度' value='" + IP.esc(a.note || "") + "'>" +
|
||||
"<input class='acct-resets' placeholder='重置周期(秒),逗号分隔,如 604800,14400' value='" + IP.esc((a.resets || []).join(",")) + "'>" +
|
||||
"</div>";
|
||||
}
|
||||
|
||||
// 弹窗表单:up 存在 = 编辑(slot 只读、auth 留空表示不改),否则 = 新建
|
||||
function formHtml(up) {
|
||||
var edit = !!(up && up.slot);
|
||||
var accts = (up && up.accounts) ? up.accounts : [];
|
||||
var rows = accts.length
|
||||
? accts.map(acctRowHtml).join("")
|
||||
: "<div class='muted acct-empty'>还没有账号,点下方「+ 添加账号」</div>";
|
||||
var statusVal = up && up.exhaust_status && up.exhaust_status.length ? up.exhaust_status.join(",") : "402,429,403";
|
||||
var markerVal = up && up.exhaust_markers && up.exhaust_markers.length ? up.exhaust_markers.join(",") : "";
|
||||
return '' +
|
||||
'<form id="upForm" class="grid-form up-form">' +
|
||||
'<div><label>slot(URL 前缀)</label>' +
|
||||
@@ -24,10 +74,17 @@
|
||||
'<div><label>备注</label><input id="upNote" type="text" placeholder="可选" value="' + IP.esc(up ? up.note : "") + '"></div>' +
|
||||
'<div class="span-all"><label>上游地址(含路径段,如 <code>/v1</code>)</label>' +
|
||||
'<input id="upBase" class="field-mono" type="text" placeholder="https://api.deepseek.com/v1" value="' + IP.esc(up ? up.base : "") + '" required></div>' +
|
||||
'<div class="span-all"><label>上游密钥(' + (edit ? '留空 = 不修改' : '新建必填') + ')</label>' +
|
||||
'<input id="upAuth" class="field-mono" type="text" placeholder="sk-..." autocomplete="off" ' + (edit ? '' : 'required') + '></div>' +
|
||||
'<div class="span-all"><label>该上游挂载的模型(逗号 / 换行分隔,可留空)</label>' +
|
||||
'<div class="span-all"><label>多账号(同一厂商多把 Key,额度耗尽自动切换同厂商下一个)</label>' +
|
||||
'<div id="upAccounts" class="acct-list">' + rows + '</div>' +
|
||||
"<button type='button' class='btn-sm' id='addAcct'>+ 添加账号</button>" +
|
||||
'</div>' +
|
||||
'<div class="span-all"><label>挂载模型(逗号 / 换行分隔,可留空)</label>' +
|
||||
'<textarea id="upModels" rows="3" placeholder="deepseek-chat, deepseek-reasoner" style="resize:vertical;font-family:ui-monospace,Menlo,Consolas,monospace;font-size:12.5px">' + IP.esc(up ? IP.arr(up.models).join(", ") : "") + '</textarea></div>' +
|
||||
'<div class="span-all"><label>额度耗尽探测(可选;命中即冷却该账号)</label>' +
|
||||
"<div class='acct-row' style='border:0;padding:0;display:flex;gap:8px;flex-wrap:wrap'>" +
|
||||
"<input id='upExhaustStatus' class='field-mono' style='flex:1;min-width:160px' placeholder='HTTP 状态码,逗号分隔,默认 402,429,403' value='" + IP.esc(statusVal) + "'>" +
|
||||
"<input id='upExhaustMarkers' class='field-mono' style='flex:2;min-width:240px' placeholder='响应体标记子串,逗号分隔,如 \"status_code\":1004,余额不足' value='" + IP.esc(markerVal) + "'>" +
|
||||
"</div></div>" +
|
||||
'</form>';
|
||||
}
|
||||
|
||||
@@ -35,21 +92,59 @@
|
||||
IP.modal({
|
||||
title: up && up.slot ? "编辑 LLM 上游" : "新建 LLM 上游",
|
||||
submitText: "保存上游",
|
||||
wide: true,
|
||||
html: formHtml(up),
|
||||
onMount: function (card, close) {
|
||||
var list = card.querySelector("#upAccounts");
|
||||
function nextIdx() { return list.querySelectorAll(".acct-row").length; }
|
||||
card.querySelector("#addAcct").addEventListener("click", function () {
|
||||
var empty = list.querySelector(".acct-empty");
|
||||
if (empty) empty.remove();
|
||||
var div = document.createElement("div");
|
||||
div.innerHTML = acctRowHtml(null, nextIdx());
|
||||
list.appendChild(div.firstChild);
|
||||
});
|
||||
list.addEventListener("click", function (e) {
|
||||
if (e.target.classList.contains("acct-del")) {
|
||||
var row = e.target.closest(".acct-row");
|
||||
if (row) row.remove();
|
||||
// 重排序号
|
||||
list.querySelectorAll(".acct-row").forEach(function (r, i) {
|
||||
r.setAttribute("data-idx", i);
|
||||
var badge = r.querySelector(".badge");
|
||||
if (badge) badge.textContent = "#" + i;
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
var form = card.querySelector("#upForm");
|
||||
form.addEventListener("submit", function (e) {
|
||||
e.preventDefault();
|
||||
var accounts = [];
|
||||
list.querySelectorAll(".acct-row").forEach(function (row) {
|
||||
var resetsRaw = row.querySelector(".acct-resets").value.trim();
|
||||
var resets = resetsRaw
|
||||
? resetsRaw.split(",").map(function (s) { return parseInt(s.trim(), 10); })
|
||||
.filter(function (n) { return !isNaN(n) && n > 0; })
|
||||
: [];
|
||||
accounts.push({
|
||||
auth: row.querySelector(".acct-auth").value.trim(),
|
||||
note: row.querySelector(".acct-note").value.trim(),
|
||||
resets: resets
|
||||
});
|
||||
});
|
||||
var payload = {
|
||||
slot: card.querySelector("#upSlot").value.trim(),
|
||||
base: card.querySelector("#upBase").value.trim(),
|
||||
note: card.querySelector("#upNote").value.trim(),
|
||||
// 模型清单总是显式提交:编辑框里就是"当前值",清空即清空(可预期)
|
||||
models: card.querySelector("#upModels").value
|
||||
models: card.querySelector("#upModels").value,
|
||||
accounts: JSON.stringify(accounts)
|
||||
};
|
||||
// 密钥留空时不传该字段:后端对「缺省」保留旧值,对「空串」是清空
|
||||
var auth = card.querySelector("#upAuth").value.trim();
|
||||
if (auth) payload.auth = auth;
|
||||
var st = card.querySelector("#upExhaustStatus").value.trim();
|
||||
if (st) payload.exhaust_status = st;
|
||||
var mk = card.querySelector("#upExhaustMarkers").value.trim();
|
||||
if (mk) payload.exhaust_markers = mk.split(",").map(function (s) { return s.trim(); }).filter(Boolean);
|
||||
IP.api("POST", "/api/admin/upstreams/save", payload)
|
||||
.then(function (r) { IP.toast(r.msg); close(); return IP.reload(); })
|
||||
.catch(function (err) { IP.toast(err.message, true); });
|
||||
@@ -70,9 +165,38 @@
|
||||
var toggle = enabled
|
||||
? "<button class='btn-sm btn-danger' data-act='toggle-up' data-slot='" + IP.esc(u.slot) + "' data-enabled='0'>停用</button>"
|
||||
: "<button class='btn-sm btn-ok' data-act='toggle-up' data-slot='" + IP.esc(u.slot) + "' data-enabled='1'>启用</button>";
|
||||
var key = u.auth_set
|
||||
? "<code class='mono'>" + IP.esc(u.auth_mask) + "</code>"
|
||||
: "<span class='muted'>未设置</span>";
|
||||
|
||||
// 账号视图:数量 + 各账号掩码 + 冷却标记 + 今日负载 + 比例条 + 14天迷你趋势
|
||||
var accts = IP.arr(u.accounts);
|
||||
var maxLoad = accts.reduce(function (m, a) {
|
||||
return Math.max(m, (a.load && a.load.requests) || 0);
|
||||
}, 0);
|
||||
var trend = IP.arr(u.account_trend);
|
||||
var trendLabels = IP.arr(u.trend_labels);
|
||||
var totalReq = accts.reduce(function (s, a) { return s + ((a.load && a.load.requests) || 0); }, 0);
|
||||
var keyCell = accts.length
|
||||
? "<div class='muted' style='font-size:12px'>" + accts.length + " 把 Key · 今日合计 " + totalReq + " 请求</div>" +
|
||||
accts.map(function (a, i) {
|
||||
var m = a.auth_mask || (a.auth_set ? "已设" : "未设");
|
||||
var load = a.load || { requests: 0, tokens_in: 0, tokens_out: 0, exhausts: 0 };
|
||||
// 比例条 = 该 Key 占「本上游最大负载 Key」的百分比(不是占总量):
|
||||
// 目的是让「谁在扛、有没有偏斜」一眼可见,本上游内部相对量最有信息量
|
||||
var pct = maxLoad > 0 ? Math.round(load.requests / maxLoad * 100) : 0;
|
||||
var exBadge = load.exhausts > 0
|
||||
? " <span class='badge b-err' title='今日额度耗尽并被冷却的次数'>耗尽" + load.exhausts + "</span>"
|
||||
: "";
|
||||
var series = (trend[i] && trend[i].requests) || [];
|
||||
return "<div class='acct-load'>" +
|
||||
"<code class='mono'>" + IP.esc(m) + "</code>" +
|
||||
(a.cooled ? " <span class='badge b-err'>冷却</span>" : "") + exBadge +
|
||||
"<div class='load-line'>今日 " + load.requests + " 请求 · 入 " + load.tokens_in + " / 出 " + load.tokens_out + " tok</div>" +
|
||||
"<div class='load-bar'><span style='width:" + pct + "%'></span></div>" +
|
||||
"<div class='spark'>" + spark(series, trendLabels) + "</div>" +
|
||||
"</div>";
|
||||
}).join("")
|
||||
: (u.auth_set
|
||||
? "<code class='mono'>" + IP.esc(u.auth_mask) + "</code>"
|
||||
: "<span class='muted'>未设置</span>");
|
||||
|
||||
var models = IP.arr(u.models);
|
||||
var modelCell = models.length
|
||||
@@ -100,7 +224,7 @@
|
||||
"<div class='row-actions' style='margin-top:6px'>" + urlBtns + "</div>" +
|
||||
"<div class='muted' style='font-size:11.5px;margin-top:4px'>点击复制 API 地址</div></td>" +
|
||||
"<td class='mono base-cell'>" + IP.esc(u.base) + "</td>" +
|
||||
"<td>" + key + "</td>" +
|
||||
"<td>" + keyCell + "</td>" +
|
||||
"<td>" + (models.length ? "<span class='badge b-blue'>" + models.length + " 个</span>" + modelCell : modelCell) + "</td>" +
|
||||
"<td>" + IP.esc(u.note || "-") + "</td>" +
|
||||
"<td>" + (enabled ? "<span class='badge b-ok'>启用中</span>" : "<span class='badge b-gray'>已停用</span>") + "</td>" +
|
||||
@@ -160,7 +284,6 @@
|
||||
});
|
||||
}).catch(function () {
|
||||
IP.toast("✗ " + slot + " 不通:网络错误或超时", true);
|
||||
restore();
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
+1
-1
@@ -21,7 +21,7 @@
|
||||
</div>
|
||||
<table>
|
||||
<thead><tr>
|
||||
<th>slot</th><th>上游地址</th><th>密钥</th><th>模型</th><th>备注</th><th>状态</th><th>创建时间</th><th>操作</th>
|
||||
<th>slot</th><th>上游地址</th><th>密钥 / 负载</th><th>模型</th><th>备注</th><th>状态</th><th>创建时间</th><th>操作</th>
|
||||
</tr></thead>
|
||||
<tbody id="upstreamsBody"></tbody>
|
||||
</table>
|
||||
|
||||
Reference in new issue
Block a user