深度解析 Cloudflare Dynamic Workers：AI Agent 代码执行的终极沙箱方案

"如果要支持消费者级别的 Agent，每个用户有多个 Agent，每个 Agent 都写代码，容器是不够的。我们需要更轻量的东西。" — Kenton Varda, Cloudflare

引言：AI Agent 的代码执行困境

AI Agent 正在改变软件开发的方式。从简单的工具调用到自主编写代码执行任务，Agent 的能力边界不断拓展。但这里有一个核心问题：AI 生成的代码在哪里执行？

直接 eval()？不行——恶意用户可以诱导 AI 注入漏洞。 用容器？太重——启动慢、内存大、需要预热。

Cloudflare 在 2026 年 3 月给出的答案是 Dynamic Workers：基于 Isolate 的轻量级沙箱，比容器快 100 倍，内存效率高 10-100 倍。

本文将深入解析 Dynamic Workers 的技术原理、架构设计、实际应用和最佳实践。

一、问题溯源：为什么容器不够用？

1.1 传统容器方案的技术瓶颈

容器（Docker、containerd 等）是目前最主流的代码隔离方案。但在 AI Agent 场景下，它存在根本性问题：

1.2 规模化困境的计算

假设一个消费者级 AI 应用：

• 100 万日活用户
• 每用户平均 10 次 Agent 交互/天
• 每次交互执行 1 段 AI 生成的代码

容器方案的成本：

并发需求 = 100万 × 10 × (执行时间/86400秒)
如果每段代码执行 1 秒，峰值并发约 115 个容器

但问题是：
- 无法预测峰值
- 冷启动体验差
- 预热池成本高
- 复用破坏隔离

1.3 核心矛盾

容器是为「长时间运行的服务」设计的，不是为「一次性代码执行」设计的。

AI Agent 需要的是：

• 每次请求创建新沙箱
• 毫秒级启动
• 用完即销毁
• 完全隔离，不复用

二、Dynamic Workers：技术架构深度解析

2.1 核心概念：Isolate

Isolate = V8 JavaScript 引擎的独立实例

V8 是 Chrome 浏览器的 JavaScript 引擎，它的设计目标之一就是安全隔离——每个网页运行在独立的 Isolate 中，互不干扰。

┌─────────────────────────────────────────────────────────┐
│                    V8 引擎架构                           │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │  Isolate 1  │  │  Isolate 2  │  │  Isolate 3  │    │
│  │  (网页 A)   │  │  (网页 B)   │  │  (网页 C)   │    │
│  │             │  │             │  │             │    │
│  │  独立堆内存  │  │  独立堆内存  │  │  独立堆内存  │    │
│  │  独立上下文  │  │  独立上下文  │  │  独立上下文  │    │
│  └─────────────┘  └─────────────┘  └─────────────┘    │
│                                                         │
│              所有 Isolate 共享 V8 运行时                │
│                                                         │
└─────────────────────────────────────────────────────────┘

2.2 Isolate vs 容器：技术对比

2.3 Dynamic Workers 的工作流程

// 1. AI 生成代码
let agentCode = `
  export default {
    async myAgent(param, env, ctx) {
      let history = await env.CHAT_ROOM.getHistory(100);
      return history.filter(msg => msg.author === "alice");
    }
  }
`;

// 2. 准备 RPC binding（API 访问权限）
let chatRoomRpcStub = ...; // 预先定义的 API

// 3. 动态加载 Worker
let worker = env.LOADER.load({
  compatibilityDate: "2026-03-01",
  mainModule: "agent.js",
  modules: { "agent.js": agentCode },
  
  // 注入 API 权限
  env: { CHAT_ROOM: chatRoomRpcStub },
  
  // 网络隔离
  globalOutbound: null,  // 或自定义拦截器
});

// 4. 执行代码
let result = await worker.getEntrypoint().myAgent(param);

// 5. Worker 自动销毁（或可复用）

流程图：

┌──────────┐     ┌──────────────────────────────────────────┐
│   LLM    │     │           Cloudflare Workers             │
│          │     │                                          │
│ 生成代码  │────▶│  ┌────────────────────────────────────┐ │
│          │     │  │         Host Worker                 │ │
│          │     │  │  env.LOADER.load({ code, env, ... })│ │
└──────────┘     │  └──────────────┬─────────────────────┘ │
                 │                 │                        │
                 │                 ▼                        │
                 │  ┌────────────────────────────────────┐  │
                 │  │       Dynamic Worker (Isolate)     │  │
                 │  │                                    │  │
                 │  │  ┌──────────────────────────────┐  │  │
                 │  │  │   Agent Code                 │  │  │
                 │  │  │                              │  │  │
                 │  │  │  await env.CHAT_ROOM.xxx()   │  │  │
                 │  │  └──────────────────────────────┘  │  │
                 │  │                 │                   │  │
                 │  │                 │ RPC               │  │
                 │  │                 ▼                   │  │
                 │  │  ┌──────────────────────────────┐  │  │
                 │  │  │   Cap'n Web RPC Bridge       │  │  │
                 │  │  │   (自动生成，无感知)          │  │  │
                 │  │  └──────────────────────────────┘  │  │
                 │  └────────────────────────────────────┘  │
                 │                                          │
                 └──────────────────────────────────────────┘

2.4 Cap'n Web RPC：跨沙箱通信

Workers Runtime 自动在沙箱和宿主代码之间建立 Cap'n Web RPC 桥接：

// Agent 代码看起来像调用本地库
let history = await env.CHAT_ROOM.getHistory(100);

// 实际上跨越了安全边界
// Host Worker → Cap'n Web RPC → Dynamic Worker

优势：

• Agent 无需知道自己在沙箱中
• API 调用语法与本地代码一致
• 安全边界对 Agent 透明

三、Code Mode：Token 效率的革命性提升

3.1 Tool Call vs Code Mode：本质区别

Tool Call 模式（传统 MCP）：

┌─────────────────────────────────────────────────────────┐
│                    对话上下文                           │
├─────────────────────────────────────────────────────────┤
│                                                         │
│ 用户: 帮我获取 Alice 最近的 10 条消息                   │
│                                                         │
│ Agent: 调用工具 getHistory({ limit: 100 })              │
│                                                         │
│ Tool Response: [                                        │
│   { author: "bob", text: "hello" },                    │
│   { author: "alice", text: "hi" },  ← 100条消息       │
│   { author: "charlie", text: "..." },                  │
│   ...                                                   │
│ ]                                                       │
│ ⬆️ 约 5000 tokens 进入上下文                            │
│                                                         │
│ Agent: 调用工具 filter({ messages: [...], author: "alice" })│
│                                                         │
│ Tool Response: [                                        │
│   { author: "alice", text: "hi" },                     │
│   { author: "alice", text: "..." },                    │
│ ]                                                       │
│ ⬆️ 又约 2000 tokens 进入上下文                          │
│                                                         │
│ Agent: 返回结果给用户                                   │
│                                                         │
└─────────────────────────────────────────────────────────┘

总计上下文: ~7000+ tokens（仅中间数据）

Code Mode 模式：

┌─────────────────────────────────────────────────────────┐
│                    对话上下文                           │
├─────────────────────────────────────────────────────────┤
│                                                         │
│ 用户: 帮我获取 Alice 最近的 10 条消息                   │
│                                                         │
│ Agent: 生成代码                                         │
│   let history = await env.CHAT.getHistory(100);        │
│   return history.filter(m => m.author === "alice")     │
│     .slice(0, 10);                                      │
│ ⬆️ 约 40 tokens                                         │
│                                                         │
│ 沙箱执行中...（中间数据不进入上下文）                   │
│                                                         │
│ 执行结果: [                                             │
│   { author: "alice", text: "hi" },                     │
│   { author: "alice", text: "..." },                    │
│   ... (共 10 条)                                        │
│ ]                                                       │
│ ⬆️ 约 200 tokens（仅最终结果）                          │
│                                                         │
└─────────────────────────────────────────────────────────┘

总计上下文: ~240 tokens

3.2 Token 节省的量化分析

3.3 为什么代码更高效？

1. 结构紧凑

JSON Tool Call:
{"name": "getHistory", "arguments": {"limit": 100, "filter": {...}}}
≈ 60 tokens

代码:
getHistory(100)
≈ 5 tokens

2. 逻辑内联

Tool Call:
调用 A → 结果进入上下文 → 调用 B(带结果) → 结果进入上下文
        ↑ 每次 API 返回都消耗 token

代码:
const a = await A();
const b = B(a);
return b;
        ↑ 中间变量在沙箱内存，不消耗 token

3. 批量操作

Tool Call 循环:
for (let id of ids) {
  await toolCall("delete", { id });  // N 次调用
}
// N × (调用 token + 返回 token)

代码批量:
await Promise.all(ids.map(id => api.delete(id)));
// 1 次调用，1 次返回

四、TypeScript API：Agent 与 API 的完美契约

4.1 为什么选择 TypeScript？

4.2 TypeScript vs OpenAPI 对比

TypeScript 接口（约 80 字符）：

interface ChatRoom {
  getHistory(limit: number): Promise<Message[]>;
  subscribe(callback: (msg: Message) => void): Promise<Disposable>;
  post(text: string): Promise<void>;
}
type Message = { author: string; time: Date; text: string; }

等效的 OpenAPI 规范（约 1500 字符）：

openapi: 3.1.0
info:
  title: ChatRoom API
  version: 1.0.0
paths:
  /messages:
    get:
      operationId: getHistory
      parameters:
        - name: limit
          in: query
          required: true
          schema:
            type: integer
            minimum: 1
      responses:
        "200":
          description: A list of messages
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/Message"
    post:
      operationId: postMessage
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [text]
              properties:
                text:
                  type: string
      responses:
        "204":
          description: Message posted
  /messages/stream:
    get:
      operationId: subscribeMessages
      responses:
        "200":
          content:
            text/event-stream:
              schema:
                $ref: "#/components/schemas/Message"
components:
  schemas:
    Message:
      type: object
      required: [author, time, text]
      properties:
        author:
          type: string
        time:
          type: string
          format: date-time
        text:
          type: string

Token 对比：

• TypeScript: ~30 tokens
• OpenAPI: ~300 tokens
• 节省 90%

4.3 实战：定义 Agent 可用的 API

// 1. 定义 TypeScript 接口
interface AgentAPI {
  // 数据库操作
  db: {
    query(sql: string): Promise<any[]>;
    insert(table: string, data: object): Promise<void>;
    update(table: string, id: string, data: object): Promise<void>;
  };
  
  // 文件操作
  storage: {
    read(path: string): Promise<string>;
    write(path: string, content: string): Promise<void>;
    delete(path: string): Promise<void>;
  };
  
  // 通知
  notify: {
    send(userId: string, message: string): Promise<void>;
    broadcast(channel: string, message: string): Promise<void>;
  };
}

// 2. 实现接口
const agentAPI: AgentAPI = {
  db: {
    query: async (sql) => { /* ... */ },
    insert: async (table, data) => { /* ... */ },
    update: async (table, id, data) => { /* ... */ },
  },
  storage: {
    read: async (path) => { /* ... */ },
    write: async (path, content) => { /* ... */ },
    delete: async (path) => { /* ... */ },
  },
  notify: {
    send: async (userId, message) => { /* ... */ },
    broadcast: async (channel, message) => { /* ... */ },
  },
};

// 3. 注入到 Dynamic Worker
let worker = env.LOADER.load({
  modules: { "agent.js": agentCode },
  env: { 
    API: agentAPI  // 自动建立 RPC 桥接
  },
  globalOutbound: null,
});

五、安全架构：久经考验的多层防御

5.1 Isolate 沙箱的安全挑战

Isolate 比硬件虚拟机（VM）攻击面更复杂：

5.2 Cloudflare 的多层防御体系

┌─────────────────────────────────────────────────────────────┐
│                    多层安全架构                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Layer 5: 代码扫描                                          │
│  ├── 自动检测恶意模式                                       │
│  └── 阻止或加强隔离                                         │
│                                                             │
│  Layer 4: 动态风险评估                                      │
│  ├── 基于行为动态隔离租户                                   │
│  └── 可疑代码单独隔离                                       │
│                                                             │
│  Layer 3: 自定义第二层沙箱                                  │
│  ├── 独立于 V8 的隔离层                                     │
│  └── 基于风险评估动态调整                                   │
│                                                             │
│  Layer 2: V8 沙箱扩展                                       │
│  ├── 利用硬件特性（MPK）                                    │
│  └── 限制内存访问范围                                       │
│                                                             │
│  Layer 1: V8 Isolate                                        │
│  ├── JavaScript 语言级隔离                                  │
│  └── 独立堆内存、上下文                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

5.3 关键安全措施

5.4 凭证注入：密钥永不泄露

// 传统方式：密钥在代码中
const response = await fetch("https://api.example.com/data", {
  headers: {
    "Authorization": "Bearer sk-secret-key-12345"  // Agent 知道密钥！
  }
});

// 凭证注入方式：Agent 不知道密钥
// Host Worker 配置
let worker = env.LOADER.load({
  modules: { "agent.js": agentCode },
  globalOutbound: {
    // 拦截所有 HTTP 请求
    async fetch(request) {
      // 检查目标 URL
      if (request.url.startsWith("https://api.example.com/")) {
        // 注入凭证
        let newRequest = new Request(request, {
          headers: {
            ...request.headers,
            "Authorization": "Bearer sk-secret-key-12345"
          }
        });
        return fetch(newRequest);
      }
      // 其他请求拒绝
      return new Response("Forbidden", { status: 403 });
    }
  }
});

// Agent 代码（不知道密钥）
const response = await fetch("https://api.example.com/data");
// 凭证被自动注入，Agent 无法泄露它不知道的东西

六、实际应用案例

6.1 Cloudflare MCP Server

背景：暴露整个 Cloudflare API 给 AI Agent

传统方案问题：

• Cloudflare API 有数百个端点
• 每个端点定义为一个 Tool
• Token 消耗巨大

Dynamic Workers 方案：

// 只需要 2 个工具
const tools = {
  // 搜索 API 文档
  search: async (query: string) => { /* ... */ },
  
  // 执行代码
  execute: async (code: string) => {
    // 在 Dynamic Worker 中执行
    return await executor.execute(code, bindings);
  }
};

效果：

• 整个 Cloudflare API 用 不到 1000 tokens 描述
• Agent 写代码调用 API，无需逐个学习 Tool

6.2 Zite：AI 生成应用平台

场景：用户通过聊天生成 CRUD 应用，连接 Stripe、Airtable、Google Calendar 等

需求：

• 每个自动化独立沙箱
• 支持数百个第三方集成
• 每天百万级执行请求

Dynamic Workers 方案：

// 每个用户的自动化运行在独立 Dynamic Worker
let automation = await env.LOADER.load({
  modules: { "automation.js": generatedCode },
  env: {
    STRIPE: stripeClient,
    AIRTABLE: airtableClient,
    GOOGLE: googleClient,
  },
  globalOutbound: null,  // 完全隔离
});

Zite CTO Antony Toron 评价：

"Cloudflare 的 Dynamic Workers 在即时性、隔离性、安全性三个方面都达标，在我们基准测试中，速度和库支持都超过了其他平台。现在 Zite 每天通过 Dynamic Workers 处理数百万执行请求。"

6.3 AI 生成应用预览

场景：AI 生成完整应用，需要快速预览

传统方案：

• 容器启动 500ms
• 用户等待体验差
• 或者预热池成本高

Dynamic Workers 方案：

• 毫秒级启动
• 即时预览
• 无需预热

// 预览 AI 生成的 Hono 应用
const worker = env.LOADER.get("preview-app", async () => {
  const { mainModule, modules } = await createWorker({
    files: {
      "src/index.ts": generatedHonoApp,
      "package.json": JSON.stringify({
        dependencies: { hono: "^4.0.0" }
      })
    }
  });
  return { mainModule, modules, compatibilityDate: "2026-01-01" };
});

// 直接处理请求
return await worker.getEntrypoint().fetch(request);

七、辅助库与工具链

7.1 @cloudflare/codemode

核心功能：简化 AI 生成代码的执行

import { DynamicWorkerExecutor, createCodeTool } from "@cloudflare/codemode";

// 创建执行器
const executor = new DynamicWorkerExecutor({
  loader: env.LOADER,
  globalOutbound: null,  // 完全隔离
  // 或传入自定义 fetcher 拦截网络请求
});

// 创建 Code Mode 工具
const codemode = createCodeTool({
  tools: myTools,  // Agent 可用的 API
  executor,
});

// 集成到 LLM 调用
return generateText({
  model,
  messages,
  tools: { codemode },
});

高级用法：

// 包装现有 MCP Server
import { codeMcpServer } from "@cloudflare/codemode";

const wrapped = codeMcpServer({
  server: existingMcpServer,
  executor,
});
// 原来数百个 Tool 变成 1 个 code() Tool

7.2 @cloudflare/worker-bundler

核心功能：动态打包 npm 依赖

import { createWorker } from "@cloudflare/worker-bundler";

const worker = env.LOADER.get("dynamic-app", async () => {
  const { mainModule, modules } = await createWorker({
    files: {
      "src/index.ts": `
        import { Hono } from 'hono';
        import { cors } from 'hono/cors';
        
        const app = new Hono();
        app.use('*', cors());
        app.get('/', (c) => c.text('Hello!'));
        
        export default app;
      `,
      "package.json": JSON.stringify({
        dependencies: { hono: "^4.0.0" }
      })
    }
  });
  
  return { mainModule, modules, compatibilityDate: "2026-01-01" };
});

// 执行
await worker.getEntrypoint().fetch(request);

特性：

• 自动从 npm 解析依赖
• 使用 esbuild 打包
• 支持全栈应用（服务端 + 客户端 + 静态资源）

7.3 @cloudflare/shell

核心功能：虚拟文件系统

import { Workspace } from "@cloudflare/shell";
import { stateTools } from "@cloudflare/shell/workers";

// 创建工作空间（持久化存储）
const workspace = new Workspace({
  sql: ctx.storage.sql,  // D1 或 DO 的 SQL 后端
  r2: env.MY_BUCKET,     // 大文件自动存 R2
  name: () => workspaceName,
});

// Agent 代码操作文件
const agentCode = `
  async () => {
    // 搜索文件
    const hits = await state.searchFiles("src/**/*.ts", "answer");
    
    // 批量编辑（事务）
    const plan = await state.planEdits([
      { kind: "replace", path: "/src/app.ts", search: "42", replacement: "43" },
      { kind: "writeJson", path: "/src/config.json", value: { version: 2 } }
    ]);
    
    // 原子应用（失败自动回滚）
    return await state.applyEditPlan(plan);
  }
`;

// 执行
const executor = new DynamicWorkerExecutor({ loader: env.LOADER });
const result = await executor.execute(agentCode, [stateTools(workspace)]);

特性：

• 持久化存储（SQLite + R2）
• 事务性写入（自动回滚）
• 批量操作减少 RPC 往返

八、定价与成本分析

8.1 官方定价

Beta 期间：$0.002 费用豁免

8.2 成本估算

场景：AI Agent 代码执行平台，每天 100 万次执行

假设：
- 每次执行 1 个独立 Worker
- 每次执行 100ms CPU 时间
- 每次执行 1 次调用

计算：
- Worker 加载：1,000,000 × $0.002 = $2000/天（Beta 期间免费）
- CPU 时间：1,000,000 × 0.1s × $0.02/秒 = $2000/天
- 调用次数：1,000,000 × $0.011/百万调用 ≈ $0.01/天

总计：约 $2000/天（主要是 CPU 时间）

对比容器方案：

• 容器预热池：需要持续运行数百个容器
• 内存成本：100 容器 × 200MB × $0.01/GB/小时 ≈ $480/天
• 但冷启动体验差，复用破坏隔离

8.3 成本优化建议

九、与其他方案对比

9.1 主流沙箱方案对比

9.2 为什么 Isolate 更适合 AI Agent？

十、最佳实践

10.1 API 设计原则

// ✅ 好的设计：简洁、类型清晰
interface GoodAPI {
  getUser(id: string): Promise<User>;
  listUsers(filter?: { role?: string }): Promise<User[]>;
  updateUser(id: string, data: Partial<User>): Promise<void>;
}

// ❌ 坏的设计：过于复杂、参数冗长
interface BadAPI {
  executeOperation(
    operation: "get" | "list" | "update",
    resource: string,
    parameters: Record<string, any>,
    options?: {
      timeout?: number;
      retries?: number;
      cache?: boolean;
      // ...很多可选参数
    }
  ): Promise<any>;
}

10.2 安全配置清单

// ✅ 推荐的安全配置
let worker = env.LOADER.load({
  modules: { "agent.js": agentCode },
  
  // 1. 明确指定允许的 API
  env: { 
    API: agentAPI,  // 只暴露必要的 API
  },
  
  // 2. 阻止或控制网络访问
  globalOutbound: null,  // 完全阻止
  // 或
  globalOutbound: {
    async fetch(request) {
      // 白名单检查
      const allowedDomains = ["api.example.com"];
      const url = new URL(request.url);
      if (allowedDomains.includes(url.hostname)) {
        return fetch(request);
      }
      return new Response("Forbidden", { status: 403 });
    }
  },
  
  // 3. 设置合理的 compatibilityDate
  compatibilityDate: "2026-03-01",
});

10.3 错误处理

try {
  let result = await worker.getEntrypoint().myAgent(param);
  return result;
} catch (error) {
  // 区分错误类型
  if (error.message.includes("timeout")) {
    // 超时：可能是代码死循环
    console.error("Agent code timeout");
  } else if (error.message.includes("memory")) {
    // 内存不足：代码占用太多内存
    console.error("Agent code OOM");
  } else if (error.message.includes("permission")) {
    // 权限错误：尝试访问未授权的 API
    console.error("Agent permission denied");
  }
  throw error;
}

十一、未来展望

11.1 技术演进方向

11.2 对 AI Agent 生态的影响

┌─────────────────────────────────────────────────────────────┐
│                 AI Agent 技术栈演进                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  第一阶段：Tool Call                                         │
│  ├── LLM 输出 JSON 调用工具                                 │
│  ├── 每次调用结果进入上下文                                 │
│  └── Token 消耗大，能力受限                                 │
│                                                             │
│  第二阶段：Code Mode + Dynamic Workers                       │
│  ├── LLM 输出代码                                           │
│  ├── 代码在沙箱内执行                                       │
│  ├── 中间数据不消耗 token                                   │
│  └── Token 效率提升 10-100 倍                               │
│                                                             │
│  第三阶段：自主 Agent                                        │
│  ├── Agent 自主编写、测试、部署代码                         │
│  ├── Dynamic Workers 作为执行层                             │
│  └── 真正的"AI 程序员"                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

十二、总结

核心要点

一句话总结

Dynamic Workers 为 AI Agent 提供了毫秒级启动、无限扩展、久经考验的代码执行沙箱，结合 Code Mode 实现 10-100 倍的 token 效率提升，是 AI Agent 时代的基础设施级创新。

参考资料

• Dynamic Workers 官方文档
• Code Mode 博客
• Cloudflare MCP Server
• How Workers Work
• Cloudflare 安全模型
• @cloudflare/codemode
• @cloudflare/worker-bundler
• @cloudflare/shell

本文由 AI 助手基于 Cloudflare 官方博客深度研究整理