首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >多租户沙箱:把「发布」做成一次可回读的事务

多租户沙箱:把「发布」做成一次可回读的事务

原创
作者头像
OneCode
发布于 2026-10-31 08:13:52
发布于 2026-10-31 08:13:52
1650
举报
文章被收录于专栏:ooderAgentooderAgent

0. 开篇:从「小龙虾」到部门自治

0.1 今天说「沙箱」,多半指的是 AI 沙箱

这个词源自安全领域——NIST 的定义是「受限的、受控的执行环境,除显式授权外不得访问任何系统资源」。但 2025 年之后,工程团队口中的沙箱已经换了所指:给带终端能力的 AI Agent 用的执行空间。

社区里那只「小龙虾」(一个能自己读写文件、执行命令的个人 AI 助手)把这件事讲得最直白:

Agent 拿到一个能执行命令的临时空间,任务开始创建,任务结束销毁;就算它把目录删光,宿主也毫发无损。

这就是 AI 沙箱。它的四个默认假设是:单用户、无身份、无持久化、无产物链。实现分档也很清楚,选型讨论基本都落在这张表里:

实现

隔离机制

启动开销

典型取向

Firecracker microVM

独立 guest kernel(KVM)

百毫秒~秒

隔离优先(强多租户)

gVisor

用户态内核接管系统调用

~100ms

折中(密度与兼容)

容器(namespace + cgroup)

共享内核,靠内核能力裁剪

几十~百毫秒

内部可信代码

WASM / V8 isolate

运行时能力裁剪,无系统调用

毫秒

启动优先(生态受限)

隔离强度 ↑

如果只到这里,问题很简单:挑一个隔离档,接一个 SDK,收工。企业里之所以不是这样,是因为 AI 沙箱的四个默认假设,在企业的每一条边界上恰好都不成立。

0.2 六个差异:AI 沙箱 vs 企业多租户沙箱

AI 沙箱(小龙虾式)

企业多租户沙箱

一句话:AI 沙箱优化的是"这一次能不能跑",企业沙箱优化的是"第一百次还能不能证明——是谁跑的、跑的哪版、能不能退回去"。

0.3 本文说的沙箱

把 AI 沙箱的执行能力,接到企业的治理边界上,收敛成一句定义:

多租户代码执行沙箱:以租户为隔离键,为每个租户提供 受限执行 + 独立环境 + 确定性构建 + 可控生命周期 的代码运行空间,并为每一次执行留下可回读的证据。

一句话概括:它不是一台机器,而是一份租约——有边界、有配额、有到期时间、有审计记录。

0.4 泛化:C 端能自己编码时,沙箱从工具变成治理边界

企业系统常见的分层是 A / B / C:

部门自主

在 C 层由平台团队统一编写的年代,沙箱是可选项——改的人懂规矩,评审也在同一个屋檐下。一旦把 C 层的编码权交给部门(这是「业务自主、快速响应」的必然结果),三件事会同时发生:

所以结论不是「沙箱让开发更快」,而是:

结论

沙箱是 C 端自治的执行器:它把「你能改什么、改完能不能跑、跑错了怎么退」变成机器可判定的规则。

部门越多、C 端越自主,这条边界越贵。没有它,A/B 层的稳定性会被 C 层的自由度持续稀释。这也是我们宁愿自建、也不接受「接一个 SaaS 沙箱」的根本原因——SaaS 能租给你执行空间,租不到你对 A/B/C 边界的裁决权。

0.5 读者、范围与诚实声明

读者:正在把 AI 生成的代码搬进真实环境的团队——尤其是「一个平台托管多个客户的多套工程」这种形态。

你会读到:

  • 一套 六面存储边界,用来回答「这段东西应该放在哪」;
  • 一套 三级隔离(分区 → 运行时 → 实例)+ 四要素,用来说明「多租户到底隔离了什么」,以及「为什么自建」;
  • 一条 Agent 驱动的六步交付链,包含事件面、控制面、安全面;
  • 一个 教育场景 的端到端实录:从模板仓库到学生能点开的页面;
  • 一章 没有删掉的失败清单。

阅读约定 · 已落地 ≠ 目标态

诚实声明(很重要):本文区分「已落地」与「目标态」。所有带「实测」字样的段落有真实运行记录;标 目标态 的是设计,不是现状。写架构文章最大的失真是把目标态当现状讲,我们从第一段就避免它。

脱敏说明:文中域名、IP、端口、主机路径均为示例值;量级数字(账号数、制品大小、规则条数)保留。


1. 起点:三个断点,而不是三个功能缺失

平台最早的形态是「一个 Studio + 一个沙箱 + 一个仓库」。当第 2 个、第 10 个工程进来时,我们并没有遇到「功能不够」,而是遇到三处边界没定义。

#

现象

根因(边界问题)

后果

断点 1

沙箱被杀后,没人拉起,只能人工登录重启

技能中心只是注册中心 + 分配台账,从不负责生命周期

演示前一天晚上挂掉,第二天现场救火

断点 2

点「发布」提示成功,但用户打开页面是旧版

发布只把 artifactId 打进日志,台账在内存,重启即丢

「发布了但不知道成没成」

断点 3

改了一处沙箱地址,另一条链路仍然打旧端口

同一个地址有 4 份副本 + 2 处硬编码,另有 2 处口径冲突

排查 3 小时,最后发现是拼写

三件事指向同一个结论:

缺的不是能力,是「谁拥有这份状态」的约定。

于是我们停下来,先定边界,再写代码。


2. 先定边界:六面存储

任何「代码平台」都会长出一堆存储:仓库、检出版、构建缓存、制品库、依赖库、运行态内容、业务表。它们长得像,但生命周期完全不同。我们把它们拆成六面,并给两两之间画红线。

面

存什么

版本化方式

是否可重建

Git

源码与声明(工程描述、流程声明、页面声明)

commit / diff / 回滚

否(唯一真源)

Workspace

检出目录、编译中间物、临时脚本

无

是(可随时丢弃)

Artifact

发布包 + 校验和清单

版本号 + sha256,发布后只读

否(不可变)

Maven

依赖与平台库

SNAPSHOT / RELEASE

是(可从私服再拉)

VFS

视图制品 .cls、流程定义、知识、对话

版本空间 {n}

否(有业务语义)

DB

结构化数据与台账

行级 + 审计

否

再补四条两两红线,它们是后面所有设计的“护栏”:

  1. Git ↔ VFS:Git 存源,VFS 存产物。把 .cls 提交回 Git,等于把编译输出当源码。
  2. VFS ↔ Artifact:VFS 可编辑,Artifact 不可变。两者混用,回滚就变成“改回来”。
  3. Workspace ↔ Maven:代码和依赖不能同一个目录。租户的本地库必须独占,否则 A 租户的 install 会污染 B 租户的解析结果。
  4. VFS ↔ DB:大于 1MB 的内容进 VFS,DB 只存指针。否则备份与迁移会被二进制撑爆。

这四条红线是事故预防,不是洁癖。第 4 条我们踩过一次:把 40MB 的流程定义塞进 DB,备份窗口从 2 分钟变成 40 分钟。


3. 隔离的分级:从「分区」到「实例」

3.1 业界的隔离阶梯

隔离不是一个开关,而是一段阶梯。每一级都真实存在于生产环境,只是名字不同:

级别(业务叫法)

English

隔离机制

启动开销

密度

逃逸风险

业界代表

目录分区

Workdir Partition

同进程同用户,靠路径白名单 + 配额

0

极高

高(共享内存、环境变量)

早期共享 CI runner

运行时隔离

Dedicated Runtime

每租户独立进程 / JVM + 独立端口 + 独立依赖库

秒级

高

中(同内核、同用户)

systemd unit + 独立 JVM

容器隔离

Container Isolation

namespace + cgroup + seccomp / capabilities

百毫秒级

中

中低(共享内核)

Docker、Daytona

内核隔离

Kernel-level Isolation

用户态内核接管系统调用

~100ms

中

低

gVisor(Modal、Cloud Run)

硬件虚拟化

MicroVM Isolation

独立 guest kernel(KVM)

百毫秒~秒

低

极低

Firecracker(E2B、Fly.io)

语言级隔离

Language Runtime Isolation

运行时能力裁剪,无系统调用

毫秒

极高

低(但生态受限)

WASM isolate、V8 isolate

一句话读法:隔离强度与启动速度、生态兼容性成反比。没有最优解,只有与威胁模型匹配的解。

这也是 AI 沙箱选型争论的根源:E2B 选 microVM(隔离优先)、Modal 选 gVisor(密度与兼容折中)、Cloudflare 选 V8 isolate(启动优先)——三家在解同一道题,只是威胁模型不同。反过来,对「内部可信、只会写 bug 不会写恶意代码」的场景,把隔离档拉到 microVM 往往是过度设计。

3.2 为什么自建:自建的是编排,不是原语

一个常见误区:把「自建沙箱」理解成「自己写一个隔离内核」。那是在重复造 Firecracker,投入产出比极差。我们真正自建的,是任何现成产品都不会替你做的那些事。

维度

买 SaaS 执行沙箱

自建

结论

代码与数据位置

源码出内网、经第三方

源码不出内网

必须自建(学生数据 + 客户源码)

身份与租户

另一套账号体系,需二次映射

与组织账号、Git 组织、授权同源

必须自建(映射成本高于自建)

私有依赖

访问不到内网私服与内部制品

直连私有 Maven / Git

必须自建

交付链耦合

只能"跑完返回结果"

编译产物要回写菜单、授权、自检

必须自建(SaaS 不给插桩点)

离线部署

依赖公网出口

客户内网可整包落地

必须自建

底层原语

—

容器运行时、Git 服务、密码学

不自建(Gitea / containerd / 标准库)

峰值成本

按秒计费,上课峰值不可控

自有机房,峰谷比约 20:1

自建更优

七行里五行「必须自建」、一行明确「不自建」、一行「更优」。这就是我们的充分论据:

结论

自建的不是隔离原语,而是「租户身份 → 代码 → 制品 → 授权」这条链的编排权。

原语一律用成熟件。判断标准也很简单:如果一件事已经有十年以上的成熟实现,就不要自己写;如果一件事只在你这里成立(身份怎么来、产物往哪去、谁有权装),就只能自己写。

另外三条现实约束,是更直接的推手:

  1. 教学峰谷极端:上课 40 分钟内有 200+ 并发构建,其余时间接近 0。按秒计费的模型在这种曲线下不可控。
  2. 交付链必须可插桩:编译完要生成视图制品、打制品清单、写回实例台账、跑三项自检——这些是产品语义,闭源 SaaS 没有钩子。
  3. 审计与合规:谁、在什么时间、以哪个租户身份、跑了哪条命令,必须以自己的台账为准,且不能出内网。

3.3 我们的三级与现状

档位用业务语言命名,不用字母代号(避免与上文的 A/B/C 分层混淆):

档位(业务叫法)

English

形态

隔离强度

适用

状态

分区级共享

Shared Host · Partitioned Workspace

单进程,每租户独立工作区 / 端口段 / .m2

弱:崩溃互相影响,挡不住恶意代码

演示、单客户

当前

运行时级独占

Dedicated Runtime

每租户一个 JVM,端口段 20000–29999

中:进程级故障隔离 + 资源配额

起步(下一档)

目录 / 端口 / .m2 已就绪

实例级独占

Dedicated Instance · Container / microVM

每租户容器或 microVM,cgroup + 网络策略

强:内核级隔离

规模化

目标态

为什么不一步到「实例级独占」?因为迁移成本不对称:从分区级到运行时级,改动集中在启动脚本与端口编排;从运行时级到实例级,要换镜像、换网络模型、换日志采集。先走中间这一档,能拿到大部分收益(故障隔离 + 资源配额),只付小部分代价。

这与业界节奏也吻合:容器长期是默认答案,2025 年后 microVM 因「快照恢复 + 强隔离」重新变便宜;但对内部可信、只会写 bug 不会写恶意代码的场景,运行时隔离仍是性价比最高的位置。

我们当前处于分区级共享。把它写进文章,是因为多数团队也停在这里,而公开文档通常只写实例级。把现状说清楚,后面的「失败清单」才有意义。

3.4 四要素

无论哪一档,隔离永远是四件事,缺一不可:

要素

机制

失效后果

文件

每实例独立 workspace-root,只允许根内读写

一个租户能读到另一个租户的源码

端口

租户段分配(20000 + n),落 ports.tsv

第二个租户起不来,或流量串到别人实例

资源

cgroup CPU/Mem、JVM -Xmx、ulimit、并发配额

一个死循环编译拖垮整机

网络

出网白名单(仅私服 + 内网 Git)+ 请求令牌

沙箱变成公网可用的免费算力

3.5 目录即契约

每租户的落盘结构是契约,不是约定俗成:

目录契约

复制

代码语言:javascript
复制
/data/tenants/{tenant}/
├─ workspace/{project}/        # git clone 落点,唯一可写工作区
├─ .m2/repository/             # 租户独占地本地库(强制)
├─ .m2/settings.xml            # 镜像 + 只读共享库 + 租户快照仓
├─ build/                      # 构建输出与日志
├─ logs/                       # 运行日志(被观测面读取)
└─ quota.json                  # CPU/内存/磁盘/并发/出站白名单

这条契约带来一个直接好处:「这个租户占了什么」永远可回答。排查时不需要问人,quota.json + ports.tsv + 目录大小就是答案。


4. 隔离编译:把每个租户的 Maven 关进笼子

多租户最容易出事的地方不是代码,是 .m2。共享本地库在单租户下是“加速”,在多租户下是“串味”。

4.1 三条硬规则

XML复制

代码语言:javascript
复制
<!-- settings.xml(每租户一份) -->
<localRepository>/data/tenants/{tenant}/.m2/repository</localRepository>
<mirrors>
  <mirror>
    <id>mirror</id>
    <mirrorOf>*,!ooder-*</mirrorOf>   <!-- 平台制品不走镜像 -->
  </mirror>
</mirrors>
  1. 强制 -Dmaven.repo.local,构建脚本传入,不依赖环境变量。依靠 MAVEN_OPTS 的做法在 CI 里 100% 会漏。
  2. 共享库只读挂载:把平台预先灌好的库以 file:// 作为 secondary repository 挂进去,只读。这样公共依赖不必每租户下一遍,但租户又写不进去。
  3. 镜像排除平台 group:mirrorOf=*,!ooder-*,否则平台自己的 RELEASE 会被公共镜像 404 掉。

4.2 实测结果(可复现)

观测项

结果

租户 t1 mvn install 后制品落点

只在 /data/tenants/t1/.m2/repository

共享库是否被污染

否,共享库 143 个平台制品,无新增

两租户库体积

t1 = 29MB(含三件示例全量依赖),t2 = 4KB(空库)

冒烟:拉一个公共依赖

dependency:get commons-lang3 落入租户库,共享库无变化

t2 = 4KB 这个数字很关键:它证明两个租户之间没有任何隐式共享。

4.3 目标态:私服分租户

目标态

代码语言:javascript
复制
Nexus
├─ ooder-releases        (只读,平台发布)
└─ {tenant}-snapshots    (读写,租户自己发布)

目标态。当前只有共享本地库,没有仓管,这是「失败清单」里的一条。


5. 私有 Git:让账号即租户身份

不自研 Git。自研 Git 服务是典型的「投入半年,得到一个更差的 Gitea」。

组织服务(账号真源)→技能中心(管理面)→Gitea(代码存储)→沙箱(只读 clone)

5.1 命名即权限

对象

规则

为什么

Organization

= 租户 id

一个租户一个命名空间,权限天然收敛

Repository

= 工程 id(ouc-dsm)

与制品、端口、URL 路径同键

Member

{tenant}.{account}

同名人不冲突

角色

组织角色 → owners / writers / readers

平台只做映射,不做自定义 RBAC

两个踩过的坑,都是“看起来能省事”的地方:

  • Gitea 不允许用户名含连续下划线,最初设计 {tenant}__{user} 直接建号失败。改成点号分隔,并对超 39 字符的做「截断 + 6 位 hash」。
  • 同名重复 fork 会被拒绝(ouc-dsm 二次 fork 报错)。改为「同源 push」而不是再 fork 一次。

5.2 账号同步:845 个,失败 0

同步不是“导入一次”,而是一条持续链路:

组织变更事件→技能中心 /internal/git/sync→Gitea

↳ 每 5 分钟全量对账

  • 首次全量:845 个唯一账号全部建号并入团队,失败 0(原始 847 行,2 组重名去重)。
  • 停用 = 禁用,不删仓。删仓是数据事故,禁用是可逆操作。
  • 每次同步写一条对账日志,包含「新增 / 更新 / 禁用 / 失败」四类计数。

5.3 凭据:不存口令,只存引用

这是本节最重要的一条设计:

管理员重置临时口令→basic-auth 建个人访问令牌→立即置回「强制改密」→ 临时口令用完即弃,平台只存 tokenId

Gitea 1.23 的个人令牌接口没有“管理员代签”能力(作用域里没有 sudo),所以只能用「临时口令 + 建令牌 + 立刻作废」这条迂回路径。代价是几秒的窗口,收益是数据库里永远没有可用口令。

5.4 fork 链路(3+N 统一)

建 Org / 同步成员

→import 模板仓→fork 到租户→沙箱 clone→隔离编译(私有 .m2)→打制品 manifest→安装授节点驻留→菜单投影→自检

七个示例(3 个 OUC 工程 + 4 个业务 Agent)走的是同一条链路,差别只在模板仓和 manifest。


6. 研发 Agent 驱动的六步闭环

6.1 为什么入口只能有一个

多智能体最容易做成“每个 Agent 一个聊天框”。用户体验上这是灾难:用户不知道“我该去哪个框里问”。

我们的做法是 单一入口 + 能力下沉:

  • 执行体唯一归属:一个执行动作只属于一个桶,别处只能调用,不能复制。
  • 产物必须回流:任何 Agent 产出都要落回工程台账,否则下一次对话它“忘了”。

6.2 六步

驻留 + 自检

步

动作

输入

输出

失败语义

1

选沙箱

租户 + 工程

目标实例 + buildId

无可用实例 → 拒绝,不降级

2

检出

仓库地址 + 分支

workspace/{t}/{p}/src

clone 失败 → 不进编译

3

隔离编译

源码 + 租户 settings

jar + .cls 视图制品

编译失败 → 保留日志,不产制品

4

推送发布

制品 + tenant/project/buildId

artifactId

缺任一字段 → 400

5

回读状态

buildId

RUNNING/SUCCEEDED/FAILED

超时 → 标记 UNKNOWN,不猜

6

驻留 + 自检

制品 + 菜单/工具声明

实例行 + 菜单 + 自检结果

自检 FAIL → 不进市场

第 4 步的「缺字段 400」是刻意设计的:早期版本会静默落到 default/default,结果两个租户的发布混在一个工作区——这类 bug 只在客户现场才暴露。fail-closed 比“容错”便宜。

6.3 状态机与 buildId

creating→ready→deploying→verifying→active→draining→destroyed

失败分支回滚到 prev 版本,回到ready

  • buildId 是幂等键:同一 buildId 重放返回同一结果,不重复部署。
  • 状态回写到实例台账(DEPLOY_STATUS / DEPLOY_AT / DEPLOY_REASON),于是「线上是哪个版本」这句话第一次有了数据库答案。
  • 部署四阶段 prepare → install → verify → switch,版本目录并存 + 指针切换,回滚是切指针,不是重装。

6.4 事件面:让“执行”在对话里可见

Agent 干活时,用户最怕“黑箱转圈”。我们让每条命令都有结构化事件,而不是一段文本:

事件

关键字段

用途

flow_tool_call

工具名 / 入参 / 结果

工具调用链

cli_command(start)

command / cwd / risk / needsConfirm

命令卡上屏

cli_command(exit)

exitCode / 耗时 / 输出尾

结果与失败定位

前端据此渲染三样东西:风险徽标(high/medium/low)、cwd 与退出码、输出尾(先脱敏后截尾)。高危命令会多一条守卫说明,而不是一个“确定吗?”的弹窗。

6.5 控制面:长命令必须有后台作业

同步执行 exec 只适合秒级命令(默认 30s 超时)。构建、打包、mvn install 动辄几分钟,必须有作业模型:HTTP

代码语言:javascript
复制
POST /jobs              → { jobId }
GET  /jobs/{id}          → 状态
GET  /jobs/{id}/output?offset=N  → 增量输出 + eof
POST /jobs/{id}/cancel   → 杀进程树

三条工程细节:

  • 增量读取:用 offset 而不是整段重发,否则前端会被 256KB 输出拖死。
  • 进程树取消:只杀父进程会留孤儿 JVM,占着端口和内存。
  • 输出环形缓冲 + 出口脱敏:日志里最常见的就是 token 和连接串。

6.6 安全面:唯一判定源 + 执行侧拦截

安全策略最容易腐化的形态是“每个模块一份黑名单”。我们有三个地方会判断命令风险(执行器、面板、工具),早期各写一套,结果是面板说高危、执行器放行。

收敛成一条:

  • 执行侧不再有自己的子串表,改为委托策略;沙箱侧另有一份 DEFAULT_DENY_PATTERNS 与 HIGH 逐条对应(纵深防御,不是重复实现)。
  • 文案从“建议不要执行”改为“执行侧会拦截”——因为前者会让人以为能绕过。
  • outputTail 先脱敏再截尾:PEM 私钥块、CLI 密钥选项、key=value、URL 内嵌凭据、裸令牌前缀。顺序很重要,先截尾会把半截密钥漏出去。

实测(临时开闸):git push --force、chmod -R 777、kill -9、curl | sh、sudo rm -rf、rm -rf / 全部 403 且命中具体规则;echo ok 正常 200;关闸后返回“未开启”。


7. 教育场景:一条链跑通

7.1 场景设定

一所学校接入平台,租户 t1。计算机课上,学生要完成「教务选课系统」的实验:

  • 教师从模板仓出发,学生fork 到自己租户;
  • 学生改完页面,点「发布」,得到一个可以点开的页面;
  • 教师能看见谁发布成功、谁自检失败。

这不是演示脚本,而是真实的教学流程:学生不需要懂 Maven、不需要碰服务器。

7.2 七步实录

#

步骤

调用面

产物

校验点

1

建租户

技能中心 provision

Git Org + 团队 + 端口段 + 租户目录

跨租户访问返回 404

2

fork 模板

Git 管理面

t1/ouc-dsm

仓库可见、成员可写

3

沙箱检出

Agent 工具

workspace/t1/ouc-dsm/src

路径必须含 t1

4

隔离编译

租户 settings + 独占 .m2

jar + .cls

共享库无新增

5

打制品

构建期生成 manifest

manifest.json + checksums.json

sha256 可复算

6

发布安装

技能中心 submit → approve → artifact → install → grant

实例行 + 菜单

tenant/project/workspace 三列落库

7

自检

自检端点

menus / entry / tools 三项

三项全 PASS 才进市场

7.3 为什么是三个示例,而不是一个

三个 OUC 示例承担三条代码生产管线,用同一套交付链验证不同入口:

示例

对应管线

验证点

ouc-dsm

DBFirst(表 → 实体 → API → 视图)

数据模型驱动是否可复现

ouc-org

ViewFirst(视图 → API → 事件 → 仓储)

页面先行是否不丢契约

ouc-bpmdemo

DesignerFirst(画布 → 组件 → 模块 → 全栈)

低代码产物能否走同一条发布链

三条管线共用 同一套命令、同一份 manifest 格式、同一组门禁。这是「统一」最实在的判据:换一条管线,运维手册不用改。

7.4 实测结果

观测项

结果

三件制品构建

全部成功,产物落在租户库

共享库污染

无(仍为 143 个平台制品)

自检

menus / entry / tools 三项全 PASS

菜单显示

正确(运行时 name 缺失回落 title)

遗留

菜单路由暂指向工作台占位页,正式页待生成

「name 回落 title」看起来是个小 bug,实际是契约不一致:manifest 里写 title,运行时读 name,中间没人校验。修法不是加 if,而是在契约测试里加一条「二者必居其一」。

7.5 向教师与教务扩展(不展开)

同一套链路上,教师侧只是换掉「制品」的内容:布置作业(表单 schema + .cls 双产物)、考勤(流程定义落 VFS)、课程治理(流程声明 + Grant)。判定「做完」的标准是统一的五条闭环,每条都要四段齐全且每段有按钮:定义 → 存储 → 运行消费 → 发布回写。只有 API 没按钮、只有页面没工具,都不算完成。


8. 没有删掉的失败清单

写架构文章最容易犯的错,是把“我们打算做”写成“我们已经做了”。下面这些是当前真实缺口。

失败清单 · 当前真实缺口

#

缺口

根因

现状处置

1

沙箱仍是分区级共享(单进程)

每租户 JVM 需要进程池 + 端口编排

目录/端口/.m2 已按租户隔离,进程尚未拆分

2

作业台账在内存,重启即丢

没落库

TTL 30 分钟 + 环形缓冲,接受“重启丢失”

3

沙箱启停端点默认关闭

安全评审结论:写操作风险高于收益

只放行只读观测(状态 + 日志),写操作需固定 root-owned 脚本 + 参数数组 + 无 shell + 限流/幂等/冷却 + 独立审计表

4

无私服(Nexus)

只有共享本地库

目标态,见 §4.3

5

密钥出现在进程命令行

历史启动脚本明文传参

迁 EnvironmentFile(0600)+ 启动脚本不再传明文;残留 5 个实例待下次重启消失

6

日志/发布只读面依赖内存态

未落 SC_BUILD_*

已登记,未做

7

部署脚本 300+ 个,无统一入口

逐年累积

收敛为单入口子命令(plan/build/deploy/verify/switch/status),脚本降为底层实现

还有两个「看起来是坑,其实是红线」的事故,值得单独记:

两起事故 · 红线

  • 同一个类两条加载路径(lib/ 与 export/{project}/target/classes)→ 双 ClassLoader → isAssignableFrom 假阴性 → 依赖注入恒为 null。修法不是加日志,而是规定一个工程只走一条路径。
  • .cls 在部署后现场生成 → 代码回滚了、页面没回滚。修法是把 .cls 定义成构建产物,随制品发布,禁止部署后生成。

9. 十条约带走

  1. 先定边界,再定组件。六面存储定完,一半的争论自动消失。
  2. 租户是隔离键,不是标签。它必须同时出现在目录、端口、数据库列、Git Org、URL 路径里。
  3. 地址必须单点。同一个配置键出现 6 份副本时,改一处不生效是必然事件。
  4. 发布必须有 buildId。没有幂等键,就没有“重试”,只有“再来一次”。
  5. 回读比推送重要。推送是“我发了”,回读才是“它成了”。
  6. 制品不可变。发布后只读 + sha256,回滚才有意义。
  7. .cls 是编译输出,不是运行产物。
  8. 一个工程只走一条加载路径。否则你会花两天查一个 ClassLoader 问题。
  9. 安全要“唯一判定源 + fail-close”。黑名单堆叠的终点,是三个模块三种结论。
  10. 观测三件:状态、日志、自检。缺任何一件,规模化以后就只能靠 SSH。

附录 A:制品清单(manifest)最小形态

JSON

复制

代码语言:javascript
复制
{
  "project": "ouc-org",
  "version": "0.1.0-test",
  "baseline": { "studio": "x.y", "studioLib": "x.y" },
  "artifacts": {
    "domain": { "file": "domain/ooder-domain-org.jar", "sha256": "…" },
    "biz":    { "file": "biz/ooder-biz-org.jar",    "sha256": "…" },
    "views":  { "dir": "views", "count": 146, "sha256": "…" }
  },
  "requires": { "jdk": "25", "tables": ["fc_*"], "ports": [] },
  "spec": { "skillForm": "APP", "menus": [], "tools": [] }
}

要点:制品不可变,环境只保存一个指向 version 的指针。


附录 B:关键台账字段(脱敏后)

表

新增字段

作用

实例表

TENANT / PROJECT / WORKSPACE

回答「哪套工程在哪个租户的哪个沙箱」

实例表

BUILD_ID / DEPLOY_STATUS / DEPLOY_AT / DEPLOY_REASON

回答「线上是哪个版本、为什么失败」

节点表

TENANT

回答「这个节点服务谁」(多租户写 *)

Git 台账

ORG / REPO / MEMBER / SYNC_LOG

回答「谁在什么时间被同步/禁用」

运维审计

NODE_OPS_LOG(只增不改)

回答「谁重启了哪台机器」


附录 C:配置键收敛

PROPERTIES

复制

代码语言:javascript
复制
ooder.sandbox.url            # 唯一地址键(旧键 deprecated)
ooder.sandbox.token          # 沙箱鉴权(不得为空,否则 fail-open)
ooder.sandbox.enabled        # 单一开关,插件不再自带默认值
ooder.tenant.strict          # 严格模式:缺租户 → 400
ooder.sandbox.jobs.*         # 作业 TTL / 输出上限 / 超时

原则:一个语义一个键,一个键一个默认值,默认值写在 application.properties,插件只引用不定义。


附录 D:AI 沙箱的公开参考

主题

出处

「沙箱」词源定义

NIST CSRC Glossary: Sandbox(引 NIST SP 800-125 / SP 800-95)

microVM 隔离实现

Firecracker(AWS 开源)

用户态内核隔离实现

gVisor 官方文档

AI 沙箱的隔离模型横向对比

E2B: Code Execution Sandboxes for AI Agents、Blaxel: Sub-second sandbox startup

引用仅用于说明「同为 AI 沙箱,不同实现的隔离档与取舍不同」,不构成对任何产品的选型推荐。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

目录
  • 0. 开篇:从「小龙虾」到部门自治
  • 0.1 今天说「沙箱」,多半指的是 AI 沙箱
  • 0.2 六个差异:AI 沙箱 vs 企业多租户沙箱
  • 0.3 本文说的沙箱
  • 0.4 泛化:C 端能自己编码时,沙箱从工具变成治理边界
  • 0.5 读者、范围与诚实声明
  • 1. 起点:三个断点,而不是三个功能缺失
  • 2. 先定边界:六面存储
  • 3. 隔离的分级:从「分区」到「实例」
  • 3.1 业界的隔离阶梯
  • 3.2 为什么自建:自建的是编排,不是原语
  • 3.3 我们的三级与现状
  • 3.4 四要素
  • 3.5 目录即契约
  • 4. 隔离编译:把每个租户的 Maven 关进笼子
  • 4.1 三条硬规则
  • XML复制
  • 4.2 实测结果(可复现)
  • 4.3 目标态:私服分租户
  • 5. 私有 Git:让账号即租户身份
  • 5.1 命名即权限
  • 5.2 账号同步:845 个,失败 0
  • 5.3 凭据:不存口令,只存引用
  • 5.4 fork 链路(3+N 统一)
  • 6. 研发 Agent 驱动的六步闭环
  • 6.1 为什么入口只能有一个
  • 6.2 六步
  • 6.3 状态机与 buildId
  • 6.4 事件面:让“执行”在对话里可见
  • 6.5 控制面:长命令必须有后台作业
  • 6.6 安全面:唯一判定源 + 执行侧拦截
  • 7. 教育场景:一条链跑通
  • 7.1 场景设定
  • 7.2 七步实录
  • 7.3 为什么是三个示例,而不是一个
  • 7.4 实测结果
  • 7.5 向教师与教务扩展(不展开)
  • 8. 没有删掉的失败清单
  • 9. 十条约带走
  • 附录 A:制品清单(manifest)最小形态
  • 附录 B:关键台账字段(脱敏后)
  • 附录 C:配置键收敛
  • 附录 D:AI 沙箱的公开参考
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档