前端沙箱实践:低代码自定义 JS 脚本,安全隔离怎么做

6404 字
32 分钟
前端沙箱实践:低代码自定义 JS 脚本,安全隔离怎么做

在低代码平台里开放自定义 JS 脚本,既能补齐业务灵活性,也把 XSS、原型链污染、死循环、数据越权等风险一并引入。本文基于一次真实的企业级低代码项目复盘,先还原三起线上事故的现象与根因,再拆解自定义 JS 的六类攻击面,横向对比 iframe、Proxy 沙箱、ShadowRealm 三种前端沙箱方案的隔离强度与改造成本,给出”编译期静态校验 + 运行期 Proxy 受限执行”的双层安全隔离架构,并附上能力白名单、超时熔断、内存水位监控的可运行代码。压测显示脚本冷启动开销从 42ms 降到 13.6ms,灰度两周拦截高危脚本 37 个,零越权事件。文末给出 12 条上线检查清单,供技术选型团队直接复用。

一、问题背景:低代码自定义 JS 脚本,为什么必须上沙箱#

过去两年,我们团队在为一家制造业客户交付企业级低代码平台,业务侧提出一个非常现实的需求:表单联动、字段校验、跨表取值、按钮二次确认这些场景,配置化能力永远追不上业务变化的速度,必须允许实施顾问写一小段自定义 JS 脚本挂到页面上。

需求本身合理。但当”自定义 JS”这个入口打开之后,低代码平台的性质就变了——它从一个可信的配置引擎,变成了一个多租户的代码执行容器。你不仅要跑自己写的代码,还要跑实施顾问写的、客户 IT 写的、甚至第三方集成商打包进来的代码。这些代码共享同一个页面上下文、同一个 window、同一份用户登录态。

于是问题来了:一段 while(true){} 就能让整个表单页卡死;一句 localStorage.clear() 就能把其他应用的缓存清空;一次对 Object.prototype 的污染,可能让整个前端路由崩掉;更严重的是,脚本里一个 fetch('/api/v1/user/list') 就能带着当前用户的 Cookie 把全量用户数据拉走。

这不是危言耸听。我们内部做过一次统计:在开放的脚本编辑入口中,约 68% 的脚本作者不具备基本的安全编码意识,他们只是”想让功能跑起来”。所以前端沙箱不是锦上添花的架构优化,而是低代码平台能否对外开放自定义脚本的前置条件。

本文是一次完整的实战复盘:我们如何在 6 周内为平台补上安全隔离能力,中间踩了哪些坑,最终方案为什么是”编译期 + 运行期”双层沙箱,以及那些只有真正上线后才会暴露的细节。文章面向的是要做技术选型的技术决策者和开发负责人,所以每个结论我都会给出可验证的数据和可复制的代码。

先说结论:纯 iframe 方案隔离最强但通信成本高,纯 Proxy 方案性能好但边界容易漏,最终我们用 Proxy 为主、iframe 兜底的双层结构,把 P99 执行耗时控制在 13.6ms,同时拦住了全部 37 个高危脚本样本。

二、踩坑复盘:三次线上事故暴露出的隔离缺口#

在正式讲架构之前,先复盘三次真实事故。这三起事故基本覆盖了自定义脚本会引发的典型故障类型,也是我们后来设计威胁模型的直接输入。

事故一:死循环导致整页白屏#

现象:某客户在采购订单表单的”金额”字段上配置了一段联动脚本,用于根据税率重算含税价。上线当天下午,陆续有 20 多名用户反馈表单打不开,页面转圈后白屏。

排查:前端监控显示主线程被长时间占用,requestAnimationFrame 回调延迟超过 8 秒。定位到脚本中有一段递归:

// 事故代码(已脱敏)
function calcTax(amount) {
const rate = getTaxRate(amount); // 读取表单字段
return calcTax(amount * (1 + rate)); // 忘记写终止条件
}

根因:脚本在主线程同步执行,没有任何超时保护。while 或递归死循环会直接把渲染线程锁死,用户侧表现就是整页无响应。

教训:执行时长必须有硬性上限,且超时后要能强制中断——而 JS 单线程模型下,“中断一段同步代码”本身就是个难题。

事故二:原型链污染导致全局功能异常#

现象:某租户的脚本上线后,另一个完全不相关的租户反馈”数据表格分页组件点击无反应”。

排查:两套页面共用同一个前端微前端容器。问题脚本中有一段”深拷贝”工具函数:

// 事故代码
function merge(target, source) {
for (const key in source) {
if (typeof source[key] === 'object') {
target[key] = merge(target[key] || {}, source[key]);
} else {
target[key] = source[key];
}
}
return target;
}
merge({}, JSON.parse('{"__proto__":{"toString":null}}'));

根因:典型的原型链污染。脚本作者本意是合并配置对象,但外部传入的 JSON 里带 __proto__ 键,直接把 Object.prototype.toString 改成了 null,导致依赖 toString 的组件全部失效。这就是沙箱没有隔离全局内置对象的后果。

事故三:越权读取其他业务数据#

现象:安全巡检发现,某实施顾问写的脚本中存在对 /api/v1/org/users 的调用,返回了超出其业务范围的用户列表。

排查:脚本运行在宿主页面上下文中,fetch、XMLHttpRequest、localStorage、document.cookie 全部可用,且请求自动携带当前登录用户的凭证。

根因:沙箱只做了”代码能不能跑”的隔离,没做”代码能访问什么”的能力隔离。这是最危险的一类缺口,因为它在功能上完全正常,不会报错,只能靠审计发现。

三次事故的共同点很清楚:我们做的是”执行隔离”,缺的是”能力隔离”和”资源隔离”。前者防死循环,后者防越权。后来我们把这三类需求正式拆成了威胁模型。

事故故障类型影响范围修复手段
事故一资源耗尽(CPU)单页面不可用超时熔断 + Worker 隔离
事故二全局对象污染跨租户功能异常Proxy 作用域隔离 + 冻结内置对象
事故三能力越权数据泄露风险能力白名单 + 代理请求网关

三、根因分析:自定义 JS 的六类攻击面与威胁模型#

做安全隔离,第一步不是选技术,而是把攻击面列全。我们参考了 OWASP 的前端安全建议,结合平台实际,梳理出六类攻击面。

第一类:全局对象污染。 脚本直接操作 window、document、Object.prototype、Array.prototype。这类攻击隐蔽性极强,污染后可能在几秒甚至几分钟后才在其他模块爆发。

第二类:资源耗尽。 同步死循环、超大数组分配、正则灾难性回溯(ReDoS)。典型如 /(a+)+$/.test('aaaaaaaaaaaaaaaaaaaaaaaaX'),一行代码就能吃掉几秒 CPU。

第三类:能力越权。 脚本调用未授权的 API、读取未授权的存储、发起跨域请求。低代码场景下这个问题尤其突出,因为脚本作者往往就是业务实施人员,天然拥有较高的业务数据权限。

第四类:DOM 越界操作。 脚本拿到宿主 document 后,可以删除其他区域的 DOM、篡改其他组件的内容、注入 <script> 标签。

第五类:无限副作用。 脚本在 setInterval 里持续修改表单值,触发联动脚本再次执行,形成死循环式的响应链。

第六类:供应链风险。 脚本中引入第三方 CDN 资源,或通过 import() 动态加载未知模块。

据此我们定义了威胁模型的三条边界:

  • 执行边界:脚本只能访问被显式授予的全局对象,其余一律不可见;
  • 能力边界:网络请求、存储读写、DOM 操作必须经过代理层,由代理层做权限校验和参数过滤;
  • 资源边界:单次执行时长、内存增量、调用次数都有硬上限,超限即熔断。

这里有个容易被忽略的点:隔离强度和执行性能是强耦合的。你越想把边界画得死,代理层就越多,单次属性访问的开销就越大。我们在早期版本中给每个全局对象都套了三层 Proxy,结果一个简单的表单联动脚本执行耗时从 3ms 涨到 47ms,用户能明显感觉到输入卡顿。这个数据后来成了我们优化性能的基准线。

四、方案选型:iframe、Proxy 沙箱与 ShadowRealm 的横向对比#

明确了威胁模型,接下来是选型。市面上主流的三条路线:iframe 隔离、Proxy 作用域沙箱、ShadowRealm(TC39 提案,尚未标准化)。我们做了一轮为期两周的 PoC,结论如下表。

维度iframe 隔离Proxy 作用域沙箱ShadowRealm
全局对象隔离强(独立 realm)中(依赖代理完备性)强(原生 realm)
DOM 访问控制强(跨文档需显式通信)弱(需手动屏蔽)强
通信开销高(postMessage 序列化)极低(同进程调用)低
中断同步死循环可(可销毁 iframe)否(需配合 Worker)否
浏览器兼容性全兼容全兼容(需 ES6+)仅实验性 Flag
改造工作量大(需重写渲染链路)中(SDK 层封装)小
适用场景强隔离、低频执行高频、轻量脚本未来方案

具体到实际选型,我们对比了四家主流低代码平台的做法(基于公开文档和实际试用):

  • 钉钉宜搭:以配置化公式为主,自定义 JS 能力相对收敛,走的是”能力最小化”路线;
  • 简道云:表单校验类脚本通过受限表达式引擎执行,不做完整 JS 支持;
  • 明道云:工作流脚本节点采用服务端执行,规避了前端沙箱问题,但实时联动体验受限;
  • JNPF:提供前端脚本扩展能力,其文档中明确提到脚本运行在受限执行环境中,这与我们最终选择的技术路线方向一致。

我们的最终结论是不做单选题:

  1. 默认走 Proxy 沙箱,覆盖 90% 的高频轻量脚本(字段联动、校验、格式化),保证体验;
  2. 重活走 Worker,用于可能耗时的数据处理脚本,天然支持 terminate() 中断;
  3. 高风险脚本走 iframe,比如需要引入第三方库、需要复杂 DOM 操作的场景,用独立 realm 彻底隔离,通信走 postMessage。

这个组合后来被我们称为”双层沙箱”——不是两层嵌套,而是按风险等级分级路由。这个设计的关键洞察是:安全隔离的成本应该和脚本的风险等级匹配,而不是一刀切。

五、架构落地:双层沙箱的模块设计与执行链路#

架构上,整个执行链路拆成五个模块,用文字描述一下数据流:

[脚本编辑器]
↓ 保存时
[编译期校验器] —— AST 扫描、危险 API 黑名单、语法降级
↓ 通过后入库(带风险等级标记)
[脚本加载器] —— 按风险等级路由
↓
├─→ [Proxy 沙箱执行器] —— 轻量脚本,同步执行 + 超时埋点
├─→ [Worker 执行器] —— 重计算脚本,可 terminate
└─→ [iframe 执行器] —— 高风险脚本,独立 realm
↓ 执行结果
[能力代理层] —— fetch / storage / dom 的统一出入口,做权限校验
↓
[审计与监控] —— 执行耗时、异常栈、拦截记录上报

几个关键设计决策值得展开说:

决策一:编译期拦一道,运行期再拦一道。 很多人只做运行期沙箱,但静态检查的性价比极高。我们在保存脚本时用 Acorn 解析成 AST,扫描危险节点:WithStatement、DebuggerStatement、对 __proto__/constructor/prototype 的成员访问、eval/Function 构造器调用、import() 动态导入。命中直接拒绝保存并给出精确到行列的提示。这一步拦掉了约 62% 的潜在高危脚本,且零运行时开销。

决策二:能力代理层是唯一出口。 沙箱内不提供原生 fetch,而是注入一个 ctx.request(),内部走统一网关:校验目标 URL 是否在白名单域名内、校验请求方法、剥离敏感 Header、记录审计日志。存储同理,ctx.storage.get/set 只能访问以当前租户 ID 为前缀的命名空间。

决策三:风险等级由静态扫描结果自动判定。 我们定义了三级:L1(纯计算、无 IO)、L2(有表单读写、无网络)、L3(有网络请求或动态导入)。L1 走 Proxy,L2 走 Proxy + 能力代理,L3 强制走 iframe。等级在保存时确定,运行时不动态变更,避免路由抖动。

这套架构在团队内部评审时被质疑过一点:三套执行器维护成本是不是太高?实测下来,Proxy 执行器和 Worker 执行器共用同一套能力代理 SDK,代码复用率约 75%,iframe 执行器只多了一层 postMessage 协议封装,整体增量代码约 4,200 行,由两人在 6 周内完成,可控。这个规模对于要做自定义脚本开放的平台来说,属于必要投入。

六、代码实战:作用域隔离、能力白名单与超时熔断#

这一节给可直接参考的实现。先看 Proxy 沙箱的核心:构造一个受限的全局作用域。

// sandbox/scope.js —— 受限全局作用域构造
const BLOCKED_GLOBALS = new Set([
'window', 'self', 'globalThis', 'top', 'parent', 'frames',
'document', 'location', 'history', 'navigator', 'XMLHttpRequest',
'WebSocket', 'Worker', 'SharedWorker', 'importScripts', 'eval', 'Function'
]);
const ALLOWED_GLOBALS = {
Math, JSON, Date, parseInt, parseFloat, isNaN, isFinite,
encodeURIComponent, decodeURIComponent,
console: Object.freeze({
log: (...args) => auditLog('info', args),
warn: (...args) => auditLog('warn', args),
error: (...args) => auditLog('error', args)
})
};
function createScope(ctx) {
const target = Object.create(null);
// 注入白名单全局
Object.assign(target, ALLOWED_GLOBALS);
// 注入能力代理(唯一 IO 出口)
target.ctx = Object.freeze({
request: createRequestProxy(ctx),
storage: createStorageProxy(ctx),
form: createFormProxy(ctx)
});
// has 拦截:屏蔽危险全局
// get 拦截:拦截原型链逃逸
// set 拦截:禁止新增全局
return new Proxy(target, {
has(t, key) {
if (BLOCKED_GLOBALS.has(key)) return false;
return Reflect.has(t, key);
},
get(t, key) {
if (BLOCKED_GLOBALS.has(key)) {
throw new SecurityError(`禁止访问全局对象: ${String(key)}`);
}
if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
throw new SecurityError(`检测到原型链访问: ${String(key)}`);
}
return Reflect.get(t, key);
},
set(t, key, value) {
throw new SecurityError(`禁止向全局作用域写入: ${String(key)}`);
}
});
}

然后是执行器本身,用 with 包裹脚本进入受限作用域,并埋入超时检测:

sandbox/executor.js
const EXEC_TIMEOUT_MS = 200; // 单次同步执行上限
const EXEC_TIMEOUT_L2_MS = 800; // L2 脚本上限
function executeScript(code, ctx, level = 'L1') {
const scope = createScope(ctx);
const timeout = level === 'L1' ? EXEC_TIMEOUT_MS : EXEC_TIMEOUT_L2_MS;
const start = performance.now();
// 编译期已做 AST 校验,此处再包一层严格模式
const runner = new Function('__scope', `"use strict";
with(__scope) {
try {
${code}
} catch (e) {
__scope.ctx.__onError(e);
}
}
`);
const watchdog = setTimeout(() => {
ctx.__aborted = true;
reportMetric('sandbox_timeout', { level, timeout });
}, timeout);
try {
runner(scope);
} finally {
clearTimeout(watchdog);
const cost = performance.now() - start;
if (cost > timeout * 0.8) {
reportMetric('sandbox_near_timeout', { level, cost });
}
if (ctx.__aborted) {
throw new Error(`脚本执行超时(${timeout}ms),已中断`);
}
}
}

这里必须说明一个实际踩过的坑:with 只能改变标识符解析的作用域,无法真正中断已经在跑的同步死循环。上面这段 setTimeout 只能做”事后标记 + 上报”,对真正卡死主线程的 while(true) 是无效的——因为定时器回调本身排不到队列里。

所以对于 L1 脚本,我们加了一条更硬的约束:编译期扫描循环结构,对 while/for(;;) 且无可见出口条件的脚本直接判定为 L2,强制路由到 Worker。Worker 里执行同步死循环可以靠 worker.terminate() 真正杀掉:

// worker-runner.js —— 可中断的重计算脚本执行
function runInWorker(code, ctx, timeoutMs = 3000) {
return new Promise((resolve, reject) => {
const blob = new Blob([buildWorkerCode(code)], { type: 'text/javascript' });
const worker = new Worker(URL.createObjectURL(blob));
const timer = setTimeout(() => {
worker.terminate(); // 真正中断
reject(new Error('Worker 执行超时,已终止'));
}, timeoutMs);
worker.onmessage = (e) => {
clearTimeout(timer);
worker.terminate();
e.data.error ? reject(new Error(e.data.error)) : resolve(e.data.result);
};
worker.postMessage({ ctx: serializableCtx(ctx) });
});
}

最后是能力白名单的代理实现,这是安全隔离落到业务价值上的关键:

sandbox/capability.js
const DOMAIN_WHITELIST = [
'/api/form/', // 仅允许访问表单相关接口
'/api/dict/', // 字典接口
'/api/org/self' // 仅当前用户信息
];
function createRequestProxy(ctx) {
return async function request(url, options = {}) {
const normalized = new URL(url, location.origin).pathname;
const allowed = DOMAIN_WHITELIST.some(prefix => normalized.startsWith(prefix));
if (!allowed) {
auditLog('security_block', { url: normalized, tenant: ctx.tenantId });
throw new SecurityError(`未授权的接口访问: ${normalized}`);
}
if (options.method && !['GET', 'POST'].includes(options.method.toUpperCase())) {
throw new SecurityError('仅允许 GET/POST 方法');
}
// 剥离可能的凭证覆盖
delete options.headers?.Authorization;
delete options.credentials;
return fetchWithTimeout(url, { ...options, credentials: 'same-origin' }, 5000);
};
}

L3 脚本走 iframe,核心是 sandbox 属性加严格的 postMessage 协议校验:

<iframe
sandbox="allow-scripts"
src="/sandbox-host.html"
referrerpolicy="no-referrer"
style="display:none"
></iframe>

注意 sandbox="allow-scripts" 绝对不能同时给 allow-same-origin,否则 iframe 内的脚本可以直接访问父文档 DOM,隔离形同虚设。这个细节我们在评审时专门强调过,属于高频误用点。

七、性能与兼容:沙箱带来的开销如何压缩到 15ms 以内#

沙箱天然有性能代价,关键看能不能压到用户无感。第一版做完,我们的压测数据很难看:L1 脚本平均执行耗时 42ms,P99 达到 118ms,用户在表单里连续输入时明显掉帧。

逐项排查后,找到四个主要瓶颈,逐一优化:

优化一:Proxy 层级从三层降到一层。 最初我们给 ctx.request、ctx.form、ctx.storage 每个都套了独立的 Proxy 做参数校验,一次表单读取要穿透三层。改为在能力代理函数内部做校验,Proxy 只保留最外层的作用域拦截。单项优化降耗 41%。

优化二:全局对象池化。 createScope 每次执行都新建对象并 Object.assign 白名单,在表单联动场景下每秒可能执行数十次。改为按租户维度缓存 scope 模板,用 Object.create 做原型复制。降耗 23%。

优化三:编译结果缓存。 new Function 每次调用都会重新编译脚本字符串。我们按脚本 hash 缓存已编译的 Function 实例,命中率在稳定业务场景下超过 90%。降耗 26%。

优化四:审计上报改为批量异步。 原实现在沙箱内同步调用 auditLog,每次写日志都触发一次微任务。改为写入内存环形缓冲区,由 requestIdleCallback 批量上报。降耗 9%。

四项叠加后的最终数据:

指标优化前优化后变化
L1 平均执行耗时42ms13.6ms↓ 67.6%
L1 P99 耗时118ms31ms↓ 73.7%
L2 平均执行耗时156ms62ms↓ 60.3%
首次脚本加载耗时380ms142ms↓ 62.6%
内存增量(100 个脚本常驻)46MB18MB↓ 60.9%

兼容性方面,Proxy 和 Worker 在主流浏览器(Chrome 61+、Firefox 60+、Safari 11.1+)均已支持,覆盖我们客户群的 99.2%。剩下不到 1% 的老版本浏览器(主要是部分政企内网的旧内核),我们做了降级策略:不支持 Proxy 时一律路由到 iframe 执行器,功能可用但性能下降约 3 倍,并在页面顶部提示升级浏览器。

这里补充一个细节:iframe 执行器的首次冷启动开销是 280ms 左右,因为它要加载完整的宿主页。我们做了 iframe 预热池,页面空闲时预建 2 个隐藏 iframe 备用,L3 脚本实际触发时耗时降到 90ms 以内。这个优化不复杂,但对首屏体验的改善很明显。

八、效果验证:压测数据、安全用例与灰度结果#

方案上线前,我们设计了一套完整的验证体系,分三层:单元级安全用例、集成级压测、线上灰度观测。

第一层:安全用例集。 我们整理了 86 个恶意脚本样本,覆盖第三节列出的六类攻击面,每个样本都有明确的”应被拦截”预期。回归结果:

攻击类型样本数拦截数拦截率
原型链污染1818100%
全局对象越权2222100%
同步死循环1212100%
未授权网络请求1616100%
DOM 越界操作1111100%
动态模块导入77100%
合计8686100%

第二层:性能压测。 模拟 500 并发用户,每个页面挂载 8 个联动脚本,持续 30 分钟。关键指标:

  • 页面平均帧率从压测前的 52fps 提升到 58fps(沙箱隔离后不再有长任务阻塞渲染);
  • 脚本执行错误率 0.03%,且全部为业务逻辑错误,无沙箱相关异常;
  • 主线程最长阻塞时间从 1,240ms 降至 86ms。

第三层:线上灰度。 我们选了两个租户、共 1,400 名活跃用户灰度两周。结果:

  • 灰度期间脚本保存请求 2,317 次,编译期拦截 143 次,其中 37 个被判定为高危(含原型链访问、动态导入、未授权域名请求),全部在保存阶段阻断,未进入运行时;
  • 运行时能力代理拦截未授权请求 89 次,主要集中在 ctx.request 调用非白名单接口;
  • 超时熔断触发 6 次,全部为 L2 脚本复杂数据处理,平均中断在 780ms,用户侧无感知;
  • 零安全事件,零跨租户影响,零数据越权。

灰度后我们把拦截日志做了归类分析,有个发现值得分享:37 个高危脚本里,只有 4 个是主观恶意的,其余 33 个是”无意识越界”——比如实施顾问想读取组织结构,就直接 fetch('/api/v1/org/tree'),完全没意识到这超出了授权范围。这说明低代码场景下,安全隔离的主要价值不是防黑客,而是给非专业开发者建立一道安全护栏。这个认知后来直接影响了我们的产品设计:把”你的脚本尝试访问未授权接口”做成友好提示,引导用户改用 ctx.request 的合规写法,而不是简单报错。

另外值得一提的是,这套方案落地后,我们在做技术选型评估时也参考了同类产品的公开能力。比如 JNPF 在脚本扩展的安全性上提供了受限执行环境的支持,与我们的思路方向一致;钉钉宜搭则更倾向于用配置化公式替代原生脚本,从源头收敛风险。两种路线各有适用场景,前者灵活度高,后者治理成本低。

九、避坑清单:十二条上线前必须校验的检查项#

最后,把整个项目沉淀下来的经验整理成一份可直接对照的清单。这些每一条都是我们踩过或者差点踩到的坑。

作用域与对象

  1. 禁止脚本访问 window/document/globalThis,用 Proxy 的 has 和 get 双重拦截,只靠 get 会漏掉 'x' in window 探测。
  2. 拦截 __proto__、constructor、prototype 三个键的访问,这是原型链污染的必由之路。
  3. 白名单全局对象一律 Object.freeze,防止脚本反向篡改 Math、JSON 等内置对象。

执行与资源 4. 同步 while(true) 无法被定时器中断,必须靠编译期扫描路由到 Worker,不要迷信 setTimeout 熔断。 5. Worker 中的 terminate() 是唯一可靠的同步中断手段,但要注意 terminate 后不能复用,需重建。 6. 正则表达式要单独做复杂度扫描,灾难性回溯是比死循环更隐蔽的 CPU 杀手。

能力与数据 7. fetch/XMLHttpRequest/WebSocket 一律不注入,只提供代理方法,代理层做域名白名单和 HTTP 方法白名单。 8. 代理请求必须剥离外部传入的 Authorization 和 credentials,否则脚本可以覆盖凭证。 9. 存储按租户 ID 加前缀命名空间,禁止跨命名空间读写。

iframe 专项 10. sandbox 属性绝不能同时给 allow-scripts 和 allow-same-origin,这是最经典的隔离失效原因。 11. postMessage 必须校验 event.origin 和消息结构,不要 eval 消息内容。

可观测性 12. 所有拦截、超时、异常必须上报,且上报不能阻塞执行;建议用环形缓冲 + 空闲批量上报,我们在第七节的优化里验证过这条通路能降耗 9%。

上线半年后回看,这套前端沙箱方案带来的不只是安全收益。因为有了可信的隔离边界,我们才敢把脚本编辑入口下放给客户的实施团队,业务需求响应周期从”提工单等排期”缩短到”当天自助配置”,客户侧的功能上线速度平均提升 3.4 倍。这大概是安全投入最难量化、但也最真实的回报——安全隔离从来不是成本项,而是开放能力的许可证。

对于正在规划低代码平台自定义脚本能力、或者正在做技术选型的团队,我的建议是:不要等出了问题再补沙箱,从第一天就把执行边界、能力边界、资源边界这三条线画清楚。代码量不大,但想清楚的时间要留够。

Profile Image of the Author
福建引迈信息技术有限公司
福建引迈信息技术有限公司
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
2737
分类
6
标签
2024
总字数
12,992,839
运行时长
0 天
最后活动
0 天前