Skip to main content

什么是 OpenSandbox​

OpenSandbox是阿里巴巴开源的通用AI应用沙箱平台，项目地址为 https://github.com/alibaba/OpenSandbox，已被 CNCF Landscape 收录。

该项目以Apache 2.0协议开源，旨在为AI应用提供一套多语言SDK、统一沙箱API和灵活运行时的完整解决方案，覆盖以下典型场景：

  • Coding Agent（编程智能体）：如Claude Code、Qwen Code、Codex CLI等在沙箱中安全执行AI生成的代码
  • GUI Agent（图形界面智能体）：在沙箱中运行桌面环境、浏览器自动化（Playwright、Chrome）
  • 智能体评估（Agent Evaluation）：大批量并行沙箱支持智能体的自动化评测
  • AI代码执行（AI Code Execution）：多语言代码解释器，为数据分析、在线教育等提供安全执行环境
  • 强化学习训练（RL Training）：在隔离沙箱中运行强化学习训练循环

OpenSandbox

解决的核心问题​

随着AI智能体系统的快速发展，让大语言模型（LLM）直接生成代码并在宿主机上执行存在显著的安全与工程挑战。现有方案在安全隔离、扩展性与开发体验上普遍存在以下痛点：

痛点OpenSandbox的解法
AI生成的代码直接在宿主机执行，存在命令注入、文件越权等安全风险每个沙箱运行在独立容器中，支持gVisor/Kata/Firecracker等安全运行时，与宿主机完全隔离
多语言智能体框架需要各自维护沙箱接入逻辑，开发重复且维护成本高提供Python/Java/Go/TypeScript/C#五种SDK，统一的生命周期与执行API
沙箱的出入口网络缺乏管控，存在数据泄露和恶意外联风险内置Ingress网关和Egress出口控制，支持FQDN级别的出口策略，默认默认拒绝所有出站流量
大规模智能体评估和RL训练场景下，沙箱调度和资源管理复杂原生支持Kubernetes运行时，对接BatchSandbox/agent-sandbox进行大规模分布式沙箱调度
沙箱内的代码执行缺乏标准化协议，难以跨运行时复用定义execd执行协议（OpenAPI规范），将命令执行、文件操作、代码解释器统一标准化
现有代码执行平台难以与MCP等AI工具协议直接集成提供官方MCP Server，可直接被Claude Code、Cursor等客户端调用

核心优势​

统一沙箱协议​

OpenSandbox定义了两套核心OpenAPI规范：沙箱生命周期规范（sandbox-lifecycle.yml）和沙箱执行规范（execd-api.yaml）。这一协议层保证了SDK与运行时实现之间的解耦，任何满足协议的自定义运行时都可无缝接入生态。

多语言原生SDK支持​

官方提供覆盖主流编程语言的SDK，开发者无需适配底层API即可完整操控沙箱：

语言包名安装方式
Pythonopensandboxpip install opensandbox
Java/Kotlincom.alibaba.opensandbox:sandboxMaven/Gradle
JavaScript/TypeScript@alibaba-group/opensandboxnpm install @alibaba-group/opensandbox
C#/.NETAlibaba.OpenSandboxdotnet add package Alibaba.OpenSandbox
Gogithub.com/alibaba/OpenSandbox/sdks/sandbox/gogo get

双运行时支持​

  • Docker运行时：适合本地开发和单机部署，生产就绪，配置简单
  • Kubernetes运行时：适合大规模分布式部署，支持BatchSandbox和agent-sandbox两种工作负载提供者

强安全隔离​

支持以下安全容器运行时，在容器级别之上提供更强的隔离保障：

运行时隔离机制启动开销最适场景
runc（默认）进程级cgroup约0ms受信任工作负载、本地开发
gVisor用户态内核（系统调用拦截）约10~50ms通用工作负载，低开销
Kata（QEMU）完整虚拟机（QEMU超虚拟化）约500ms最强兼容性与隔离需求
Kata（Firecracker）轻量MicroVM约125ms高密度部署，极小内存占用
Kata（CLH）Cloud Hypervisor约200ms性能与隔离的均衡选择

沙箱隔离模型：每人独占一个沙箱​

OpenSandbox的沙箱在设计上是独占的（per-session/per-user），不支持多人共用同一个沙箱实例。 以Codex CLI沙箱为例：

  • 沙箱内仅有一个execd守护进程入口，没有实现用户级隔离或多路复用
  • 每个沙箱拥有唯一的文件系统命名空间，多人写入同一工作区会产生冲突
  • 进程空间在沙箱内完全可见，不同用户的进程可以相互感知，破坏隔离语义
  • 沙箱的TTL到期或Kill操作是整体生效的，一个用户的操作会影响所有使用者

正确的使用模式是：每位开发者/每次会话独占一个沙箱实例，平台负责按需批量创建和回收。这正是OpenSandbox的Kubernetes运行时（BatchSandbox/agent-sandbox）所擅长的场景——面向大规模并发用户快速分配和调度沙箱资源，既保持了强隔离，又实现了弹性扩缩容。

完整的网络策略​

  • Ingress入口网关：基于请求头或URI路径将外部流量路由到指定沙箱的指定端口，支持Header模式和URI模式
  • Egress出口控制：以Sidecar方式注入沙箱网络命名空间，通过DNS代理和nftables实现基于FQDN的出站流量管控，默认拒绝所有出站流量

MCP原生集成​

官方提供opensandbox-mcp服务，将沙箱创建、命令执行、文件操作等能力以MCP协议暴露，可直接被Claude Code、Cursor等智能体客户端调用，无需编写额外的集成代码。

架构设计​

OpenSandbox采用四层架构：SDK层、协议规范层、运行时层和沙箱实例层，各层职责清晰、边界明确。

SDK 层​

SDK层为开发者提供高层次的编程抽象，封装了与生命周期API和执行API的所有通信细节。各语言SDK的核心组件完全一致：

  • Sandbox类：沙箱生命周期管理（创建、查询、暂停、恢复、销毁）
  • Commands组件：在沙箱内执行Shell命令，支持前台同步执行与后台异步执行，通过SSE流式输出
  • Filesystem组件：沙箱内的文件系统操作，包括增删改查、批量上传下载、glob搜索
  • CodeInterpreter组件：多语言有状态代码解释器，基于Jupyter内核协议

协议规范层​

OpenSandbox以OpenAPI规范定义了两套核心传输契约，确保SDK与任意满足协议的运行时实现之间的互操作性：

生命周期规范（sandbox-lifecycle.yml） 核心接口：

操作接口说明
创建沙箱POST /sandboxes从容器镜像创建新沙箱实例
列举沙箱GET /sandboxes分页查询沙箱列表
获取沙箱GET /sandboxes/{id}查询沙箱详情与状态
删除沙箱DELETE /sandboxes/{id}终止并销毁沙箱
暂停沙箱POST /sandboxes/{id}/pause暂停运行中的沙箱
恢复沙箱POST /sandboxes/{id}/resume恢复暂停的沙箱
续期沙箱POST /sandboxes/{id}/renew-expiration延长沙箱TTL
获取端点GET /sandboxes/{id}/endpoints/{port}获取指定端口的公网URL

执行规范（execd-api.yaml） 核心接口（由注入每个沙箱的execd守护进程实现）：

类别接口说明
健康检查GET /ping存活探针
代码执行POST /code执行代码，SSE流式输出结果
代码执行POST /code/context创建有状态执行上下文
命令执行POST /command执行Shell命令
文件操作GET /files/info获取文件元数据
文件操作GET /files/search按glob模式搜索文件
文件操作POST /files/mv移动/重命名文件
文件操作POST /files/permissions修改文件权限

运行时层（Server）​

OpenSandbox Server是基于FastAPI构建的生产级服务，作为控制平面负责管理沙箱生命周期。核心能力包括：

  • 标准化的REST生命周期接口
  • 可插拔的运行时后端（Docker/Kubernetes）
  • 可配置的TTL清理模式（自动过期或手动DELETE）
  • API Key认证
  • 多种网络模式（host/bridge/自定义网络）
  • 支持CPU/内存资源限额
  • 异步沙箱创建，降低响应延迟
  • 重启后自动恢复过期计时器

execd 执行守护进程​

execd是注入到每个沙箱容器中的轻量级执行守护进程，是沙箱执行能力的核心载体。SDK通过execd暴露的HTTP API与沙箱内部进行交互，执行命令、操作文件、运行代码。

execd的镜像由[runtime].execd_image配置项指定，在沙箱创建时由运行时自动注入，用户无需手动管理。

Ingress 入口网关​

Ingress网关是HTTP/WebSocket反向代理，将外部流量路由到对应的沙箱实例及其端口。支持两种路由模式：

Header模式（默认）：基于OpenSandbox-Ingress-To请求头或Host请求头路由，格式为<sandbox-id>-<port>。

# 通过请求头路由到沙箱的 8080 端口
curl -H "OpenSandbox-Ingress-To: my-sandbox-8080" https://ingress.opensandbox.io/api/users

URI模式：基于URI路径路由，格式为/<sandbox-id>/<port>/<path>。

# 通过 URI 路由，请求转发给沙箱的 /api/users
curl https://ingress.opensandbox.io/my-sandbox/8080/api/users

Ingress网关还支持按访问自动续期（OSEP-0009）：当沙箱被访问时，自动通过Redis队列向Server发送续期信号，实现"按需保活"。

Egress 出口控制​

Egress Sidecar以Sidecar容器的形式与沙箱应用容器共享网络命名空间，提供FQDN级别的出站流量管控：

工作机制：

  • DNS代理（第一层）：在127.0.0.1:15353运行自定义DNS代理，iptables规则将所有53端口的DNS请求重定向到此代理，对不在允许列表中的域名返回NXDOMAIN
  • nftables网络过滤（第二层，dns+nft模式）：将已解析的允许域名IP动态写入nftables，实现IP层的默认拒绝+域名放行

核心特性：

  • 支持通配符域名（如*.pypi.org）
  • 无需应用程序感知（透明拦截）
  • 运行时通过HTTP API动态更新策略
  • 支持DoH/DoT阻断
  • 支持出站被拒时通过Webhook发送告警

使用与配置​

快速启动服务端​

OpenSandbox Server以Python包的形式分发，推荐使用uv安装：

pip install opensandbox-server

初始化配置文件（以Docker运行时为例）：

opensandbox-server init-config ~/.sandbox.toml --example docker

启动服务：

opensandbox-server
# 或
opensandbox-server --config /path/to/sandbox.toml

健康检查：

curl http://127.0.0.1:8080/health
# → {"status": "healthy"}

服务启动后可访问Swagger UI（http://localhost:8080/docs）查看完整API文档。

核心配置项参考​

配置文件为TOML格式，默认路径~/.sandbox.toml，支持通过SANDBOX_CONFIG_PATH环境变量或--config参数覆盖。

[server]服务配置：

配置项类型默认值说明
hoststring"0.0.0.0"HTTP API监听地址
portinteger8080监听端口
log_levelstring"INFO"日志级别
api_keystringnull若设置则启用API Key认证，通过OPEN-SANDBOX-API-KEY请求头传递
eipstringnull沙箱端点URL中使用的公网IP或主机名
max_sandbox_timeout_secondsintegernull沙箱TTL上限（秒），不设置则不做限制

[runtime]运行时配置（必填）：

配置项类型说明
typestring"docker"或"kubernetes"
execd_imagestring注入沙箱的execd守护进程OCI镜像地址

[docker]Docker运行时配置：

配置项类型默认值说明
network_modestring"host"网络模式：host/bridge/自定义网络，Egress功能需要bridge模式
no_new_privilegesbooleantrue阻止沙箱容器提权
pids_limitinteger4096沙箱最大进程数，null表示不限制
drop_capabilitieslist见源码从沙箱容器中移除的Linux Capabilities

[kubernetes]Kubernetes运行时配置：

配置项类型默认值说明
namespacestringnull沙箱工作负载所在命名空间
workload_providerstringnull"batchsandbox"或"agent-sandbox"
sandbox_create_timeout_secondsinteger60等待沙箱就绪的超时时间（秒）
informer_enabledbooleantrue是否启用Informer缓存，减少API Server压力

[secure_runtime]安全运行时配置：

配置项类型说明
typestring"gvisor"/"kata"/"firecracker"，为空则使用标准runc

完整Docker运行时配置示例：

[server]
host = "0.0.0.0"
port = 8080
log_level = "INFO"
api_key = "your-secret-api-key"

[runtime]
type = "docker"
execd_image = "sandbox-registry.cn-zhangjiakou.cr.aliyuncs.com/opensandbox/execd:latest"

[docker]
network_mode = "bridge"
no_new_privileges = true
pids_limit = 4096

[egress]
image = "sandbox-registry.cn-zhangjiakou.cr.aliyuncs.com/opensandbox/egress:latest"

使用 CLI 工具​

OpenSandbox提供osb命令行工具，覆盖常见的沙箱操作流程：

# 安装
pip install opensandbox-cli

# 初始化配置
osb config init
osb config set connection.domain localhost:8080
osb config set connection.protocol http

# 创建沙箱
osb sandbox create --image python:3.12 --timeout 30m -o json

# 在沙箱中执行命令
osb command run <sandbox-id> -o raw -- python -c "print(1 + 1)"

# 查看沙箱列表
osb sandbox list

# 删除沙箱
osb sandbox delete <sandbox-id>

配置 MCP Server​

OpenSandbox MCP Server可将沙箱能力以MCP协议暴露给Claude Code、Cursor等智能体客户端：

pip install opensandbox-mcp
opensandbox-mcp --domain localhost:8080 --protocol http

在MCP客户端中添加如下配置：

{
  "mcpServers": {
    "opensandbox": {
      "command": "opensandbox-mcp",
      "args": ["--domain", "localhost:8080", "--protocol", "http"]
    }
  }
}

使用示例​

以下示例均使用Go SDK（github.com/alibaba/OpenSandbox/sdks/sandbox/go）演示，运行前需确保OpenSandbox Server已启动，并通过环境变量OPEN_SANDBOX_DOMAIN和OPEN_SANDBOX_API_KEY配置连接信息。

示例一：基础沙箱创建与命令执行​

最基础的使用场景：创建一个Python沙箱，在其中执行Shell命令，程序退出时自动销毁沙箱。

package main

import (
    "context"
    "fmt"
    "os"
    "time"

    opensandbox "github.com/alibaba/OpenSandbox/sdks/sandbox/go"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()

    config := opensandbox.ConnectionConfig{
        Domain:   getEnv("OPEN_SANDBOX_DOMAIN", "localhost:8080"),
        APIKey:   os.Getenv("OPEN_SANDBOX_API_KEY"),
        Protocol: "http",
    }

    // 创建沙箱，defer Kill 确保程序退出时自动销毁
    sb, err := opensandbox.CreateSandbox(ctx, config, opensandbox.SandboxCreateOptions{
        Image: "python:3.12",
    })
    if err != nil {
        fmt.Fprintf(os.Stderr, "创建沙箱失败: %v\n", err)
        os.Exit(1)
    }
    defer sb.Kill(context.Background())

    fmt.Printf("沙箱已就绪: %s\n", sb.ID())

    // 在沙箱中执行命令
    exec, err := sb.RunCommand(ctx, `python -c "print('Hello from sandbox!')"`, nil)
    if err != nil {
        fmt.Fprintf(os.Stderr, "命令执行失败: %v\n", err)
        os.Exit(1)
    }
    fmt.Println(exec.Text())
}

func getEnv(key, fallback string) string {
    if v := os.Getenv(key); v != "" {
        return v
    }
    return fallback
}

示例二：多语言代码解释器​

CodeInterpreter组件支持在有状态会话中执行多种编程语言的代码块，变量在同一上下文（Context）中跨次调用持久化。

package main

import (
    "context"
    "fmt"
    "os"
    "time"

    opensandbox "github.com/alibaba/OpenSandbox/sdks/sandbox/go"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
    defer cancel()

    config := opensandbox.ConnectionConfig{
        Domain: getEnv("OPEN_SANDBOX_DOMAIN", "localhost:8080"),
        APIKey: os.Getenv("OPEN_SANDBOX_API_KEY"),
    }

    // 创建代码解释器沙箱（使用官方 code-interpreter 镜像）
    ci, err := opensandbox.CreateCodeInterpreter(ctx, config, opensandbox.CodeInterpreterCreateOptions{
        ReadyTimeout: 60 * time.Second,
    })
    if err != nil {
        fmt.Fprintf(os.Stderr, "创建代码解释器失败: %v\n", err)
        os.Exit(1)
    }
    defer ci.Kill(context.Background())
    fmt.Printf("代码解释器已就绪: %s\n", ci.ID())

    // 创建 Python 执行上下文（变量在同一上下文中持久存在）
    pyCtx, err := ci.CreateContext(ctx, opensandbox.CreateContextRequest{Language: "python"})
    if err != nil {
        fmt.Fprintf(os.Stderr, "创建 Python 上下文失败: %v\n", err)
        os.Exit(1)
    }

    // 第一次执行：定义变量
    ci.ExecuteCode(ctx, opensandbox.RunCodeRequest{
        Context: pyCtx,
        Code:    "import platform\npy_ver = platform.python_version()\nprint('Python:', py_ver)",
    }, nil)

    // 第二次执行：复用上一次定义的变量 py_ver（跨调用持久化）
    pyResult, _ := ci.ExecuteCode(ctx, opensandbox.RunCodeRequest{
        Context: pyCtx,
        Code:    "print('Version again:', py_ver)",
    }, nil)
    fmt.Println("[Python]", pyResult.Text())

    // 创建 Java 执行上下文并执行
    javaCtx, _ := ci.CreateContext(ctx, opensandbox.CreateContextRequest{Language: "java"})
    javaResult, _ := ci.ExecuteCode(ctx, opensandbox.RunCodeRequest{
        Context: javaCtx,
        Code:    `System.out.println("Hello from Java!"); int r = 2 + 3; System.out.println("2+3=" + r);`,
    }, nil)
    fmt.Println("[Java]", javaResult.Text())
}

func getEnv(key, fallback string) string {
    if v := os.Getenv(key); v != "" {
        return v
    }
    return fallback
}

示例三：在沙箱中运行 Codex CLI​

将Codex CLI运行在隔离沙箱中，实现AI编程智能体的安全执行。注意：每位开发者应独占一个沙箱实例，不应将同一个沙箱实例共享给多人使用（详见"沙箱隔离模型"章节）。

package main

import (
    "context"
    "fmt"
    "os"
    "time"

    opensandbox "github.com/alibaba/OpenSandbox/sdks/sandbox/go"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
    defer cancel()

    openaiKey := os.Getenv("OPENAI_API_KEY")
    if openaiKey == "" {
        fmt.Fprintln(os.Stderr, "OPENAI_API_KEY 不能为空")
        os.Exit(1)
    }

    config := opensandbox.ConnectionConfig{
        Domain: getEnv("OPEN_SANDBOX_DOMAIN", "localhost:8080"),
        APIKey: os.Getenv("OPEN_SANDBOX_API_KEY"),
    }

    // 每位开发者独占一个沙箱，将 OpenAI 认证信息注入环境变量
    sb, err := opensandbox.CreateSandbox(ctx, config, opensandbox.SandboxCreateOptions{
        Image: "sandbox-registry.cn-zhangjiakou.cr.aliyuncs.com/opensandbox/code-interpreter:v1.0.2",
        Env: map[string]string{
            "OPENAI_API_KEY": openaiKey,
        },
    })
    if err != nil {
        fmt.Fprintf(os.Stderr, "创建沙箱失败: %v\n", err)
        os.Exit(1)
    }
    defer sb.Kill(context.Background())

    // 安装 Codex CLI（Node.js 已预装在 code-interpreter 镜像中）
    if _, err := sb.RunCommand(ctx, "npm i -g @openai/codex@latest", nil); err != nil {
        fmt.Fprintf(os.Stderr, "安装 Codex CLI 失败: %v\n", err)
        os.Exit(1)
    }

    // 运行 Codex CLI 执行编码任务
    result, err := sb.RunCommand(ctx,
        `codex --approval-mode=full-auto "Write a Go hello world program"`, nil)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Codex CLI 执行失败: %v\n", err)
        os.Exit(1)
    }
    fmt.Println(result.Text())
}

func getEnv(key, fallback string) string {
    if v := os.Getenv(key); v != "" {
        return v
    }
    return fallback
}

示例四：并发多沙箱任务编排​

OpenSandbox的每个沙箱独立隔离，天然适合并发编排。下面演示用Go协程并发创建多个沙箱，每个任务在独立沙箱中互不干扰地并行执行：

package main

import (
    "context"
    "fmt"
    "os"
    "sync"
    "time"

    opensandbox "github.com/alibaba/OpenSandbox/sdks/sandbox/go"
)

// runTask 在独立沙箱中执行单个任务，任务结束后自动销毁沙箱
func runTask(ctx context.Context, config opensandbox.ConnectionConfig, taskID int, code string) (string, error) {
    sb, err := opensandbox.CreateSandbox(ctx, config, opensandbox.SandboxCreateOptions{
        Image: "python:3.12",
        Metadata: map[string]string{
            "task_id": fmt.Sprintf("%d", taskID),
        },
    })
    if err != nil {
        return "", fmt.Errorf("任务 %d 沙箱创建失败: %w", taskID, err)
    }
    defer sb.Kill(context.Background())

    exec, err := sb.RunCommand(ctx, fmt.Sprintf("python -c %q", code), nil)
    if err != nil {
        return "", fmt.Errorf("任务 %d 执行失败: %w", taskID, err)
    }
    return exec.Text(), nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
    defer cancel()

    config := opensandbox.ConnectionConfig{
        Domain: getEnv("OPEN_SANDBOX_DOMAIN", "localhost:8080"),
        APIKey: os.Getenv("OPEN_SANDBOX_API_KEY"),
    }

    // 三个任务并发运行，每个任务在独立沙箱中执行，互不干扰
    tasks := []string{
        "print('Task 1:', sum(range(100)))",
        "print('Task 2:', 2**32)",
        "print('Task 3:', ','.join(str(i) for i in range(5)))",
    }

    var wg sync.WaitGroup
    results := make([]string, len(tasks))
    errs := make([]error, len(tasks))

    for i, code := range tasks {
        wg.Add(1)
        go func(idx int, c string) {
            defer wg.Done()
            results[idx], errs[idx] = runTask(ctx, config, idx+1, c)
        }(i, code)
    }

    wg.Wait()

    for i, result := range results {
        if errs[i] != nil {
            fmt.Fprintf(os.Stderr, "任务 %d 错误: %v\n", i+1, errs[i])
        } else {
            fmt.Printf("任务 %d 输出: %s\n", i+1, result)
        }
    }
}

func getEnv(key, fallback string) string {
    if v := os.Getenv(key); v != "" {
        return v
    }
    return fallback
}

示例五：Egress 出口策略配置​

在沙箱创建时指定网络策略，仅允许访问pypi.org安装Python包，其他所有出站请求均被拒绝：

package main

import (
    "context"
    "fmt"
    "os"
    "time"

    opensandbox "github.com/alibaba/OpenSandbox/sdks/sandbox/go"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
    defer cancel()

    config := opensandbox.ConnectionConfig{
        Domain: getEnv("OPEN_SANDBOX_DOMAIN", "localhost:8080"),
        APIKey: os.Getenv("OPEN_SANDBOX_API_KEY"),
    }

    // 通过 NetworkPolicy 指定出口规则，默认拒绝所有出站流量
    // 只允许访问 pypi.org 及其子域名
    sb, err := opensandbox.CreateSandbox(ctx, config, opensandbox.SandboxCreateOptions{
        Image: "python:3.12",
        NetworkPolicy: &opensandbox.NetworkPolicy{
            DefaultAction: "deny",
            Egress: []opensandbox.NetworkRule{
                {Action: "allow", Target: "*.pypi.org"},
                {Action: "allow", Target: "pypi.org"},
            },
        },
    })
    if err != nil {
        fmt.Fprintf(os.Stderr, "创建沙箱失败: %v\n", err)
        os.Exit(1)
    }
    defer sb.Kill(context.Background())

    // 安装依赖（仅 pypi.org 出站被允许，其他外联请求将被拒绝）
    result, err := sb.RunCommand(ctx, "pip install requests", nil)
    if err != nil {
        fmt.Fprintf(os.Stderr, "安装失败: %v\n", err)
        os.Exit(1)
    }
    fmt.Println(result.Text())
}

func getEnv(key, fallback string) string {
    if v := os.Getenv(key); v != "" {
        return v
    }
    return fallback
}

支持的沙箱环境​

OpenSandbox内置并维护了多种专用沙箱镜像，覆盖主要AI智能体应用场景：

类别镜像/示例说明
代码解释器opensandbox/code-interpreter支持Python/Java/Go/JavaScript/Bash的多语言执行环境
Claude Codeclaude-code示例在沙箱中运行Anthropic Claude Code CLI
Qwen Codeqwen-code示例在沙箱中运行通义千问代码智能体
Gemini CLIgemini-cli示例在沙箱中运行Google Gemini CLI
Codex CLIcodex-cli示例在沙箱中运行OpenAI Codex CLI
Kimi Codekimi-cli示例在沙箱中运行Kimi Code CLI（月之暗面）
浏览器自动化opensandbox/playwright无头Chromium + Playwright，用于网页抓取与GUI Agent
Chrome DevToolschrome示例暴露DevTools端口的无头Chromium，用于远程调试
桌面环境desktop示例VNC桌面（Xvfb + x11vnc），用于GUI Agent测试
VS Code Webvscode示例在沙箱中运行code-server，提供浏览器访问的IDE环境
强化学习训练rl-training示例在沙箱内运行RL训练循环
LangGraphlanggraph示例LangGraph智能体与沙箱工具编排
Google ADKgoogle-adk示例Google Agent Development Kit集成示例

与同类项目的对比​

以下对比基于三个项目的公开源码与官方文档，围绕定位、安全模型、SDK 支持、部署方式、网络控制、AI 集成等核心维度展开。

OpenSandbox（阿里巴巴）​

OpenSandbox 以协议标准化为核心设计理念，通过 OpenAPI 规范定义沙箱生命周期接口（sandbox-lifecycle.yml）和执行接口（execd-api.yaml），将沙箱能力抽象为统一的API层。同一套接口可接入 Docker、Kubernetes/BatchSandbox 不同运行时，以及 gVisor、Kata-Containers（支持 QEMU、Firecracker、CLH）等多种安全运行时，适合需要在多种AI框架和运行环境之间灵活切换的团队。

其内置的 Egress 边车组件基于 FQDN 白名单 + nftables 实现出站流量拦截，Ingress 网关支持基于Header和 URI 的路由，网络策略开箱即用。官方 MCP Server（opensandbox-mcp）使 Claude Code、Cursor 等工具可直接通过 MCP 协议操作沙箱。项目已进入 CNCF Landscape，是三者中唯一具备沙箱协议标准化愿景的项目。

Daytona（daytonaio）​

Daytona 定位为面向 AI 生成代码的弹性基础设施，强调快速启动（< 90ms）、状态持久化与平台完整性。每个沙箱是一个以 OCI/Docker 标准容器为基础的隔离执行单元，拥有独立分配的 vCPU、RAM、磁盘和网络栈。架构分为三个平面：接口层（CLI、Dashboard、SDK、REST API），控制面（NestJS API 负责编排、Snapshot Manager、SSH Gateway、Proxy）和计算面（Runner 节点 + 沙箱内 Daemon 代理）。

底层实现上，Runner 直接调用 Docker SDK 创建容器（--privileged 特权模式），并通过宿主机 iptables 规则对每个容器的 IP 单独设置出入站限制，实现比 Docker 原生网络隔离更细粒度的管控。< 90ms 冷启动依赖预热池（Warm Pool）——提前维持一批待命容器，请求到来时直接分配。Daytona 目前仅支持 Docker 运行时，没有 gVisor/Kata 等内核级安全运行时，也无 Kubernetes 适配器，计算节点选择由内置的 7 维加权调度器管理。

面向开发者的功能极为完整：Dashboard（Web UI）、Web Terminal、SSH、VNC、VPN、预览 URL、LSP 支持、Computer Use、Git 操作、日志流等。Snapshots 功能支持将容器状态序列化为 OCI 镜像，后续沙箱可直接从快照启动，为跨会话的 Agent 工作流提供持久化保障。多语言 SDK 覆盖 Python、TypeScript、Ruby、Go、Java 共五种语言。已推出托管云服务（app.daytona.io），同时支持自托管（Docker Compose）和混合部署（托管控制面 + 自有计算节点）。

OpenShell（NVIDIA）​

OpenShell 是三者中安全机制最为深度的项目，定位为自主 AI Agent 的安全隐私运行时。核心思路是"纵深防御"：在Linux内核层面叠加四层隔离——Landlock LSM（文件系统访问控制）、Seccomp BPF（系统调用过滤）、网络命名空间（隔离出站流量，经 HTTP CONNECT 代理中转）和 OPA/Rego 策略引擎（基于进程身份 + 目标 FQDN + HTTP Method/Path 的七层决策）。

网络侧还引入了 Privacy Router（推理路由器），能够透明拦截对AI Inference API的请求，剥离调用方凭据并注入后端凭据，避免API Key泄露至沙箱文件系统。策略以声明式 YAML 描述，静态字段（文件系统/进程）在创建时锁定，动态字段（网络/推理路由）支持热更新（openshell policy set），无需重启沙箱。内置对 Claude Code、OpenCode、Codex、GitHub Copilot CLI 的原生支持，凭据通过 Provider 机制注入为环境变量（从不写入磁盘）。基础设施以 K3s（轻量级 Kubernetes）内嵌于单一 Docker 容器中运行，支持 GPU 直通（--gpu，实验性）。当前为 Alpha 阶段，主打单机开发者场景，企业级多租户部署在路线图中。

三维对比速查表​

维度OpenSandbox（阿里巴巴）Daytona（daytonaio）OpenShell（NVIDIA）
项目定位协议标准化的AI沙箱平台AI代码执行弹性基础设施自主Agent安全隐私运行时
开源协议Apache 2.0Apache 2.0 / AGPL-3.0Apache 2.0
核心语言Python（服务端）+ 多语言 SDKGo（CLI/Runner）+ TypeScript（API）+ 多语言 SDKRust（核心）+ Python SDK
多语言 SDKPython·Java/Kotlin·TypeScript·C#/.NET·GoPython·TypeScript·Ruby·Go·JavaPython（主要），CLI 为主入口
沙箱隔离机制gVisor/Kata（QEMU/Firecracker/CLH）/runc（可选）OCI/Docker 容器（--privileged）+ iptables 双重网络隔离；无 gVisor/Kata 硬化运行时Landlock LSM + Seccomp BPF + 网络命名空间 + OPA 策略引擎（四层纵深防御）
容器运行时Docker / containerd（经 Kubernetes CRI）；安全运行时（gVisor/Kata）均为 OCI兼容 shim仅 Docker Engine（Runner 以 DinD 模式运行，内部依赖 Docker 守护进程；无裸 containerd CRI 接入）containerd（K3s 默认容器运行时；沙箱以 K8s Pod 运行于内嵌 K3s 集群中）
网络出口控制Egress 边车：FQDN 白名单 + nftablesnetwork_block_all 全封断 / network_allow_list CIDR 白名单 + iptables 细粒度规则OPA/Rego 七层策略 + 热更新；Privacy Router 推理路由
AI 推理隐私保护无内置机制无内置机制有（Privacy Router：剥离来源凭据，注入后端凭据）
凭据管理无内置机制无内置机制Provider 机制（环境变量注入，从不落盘）
MCP 集成官方 MCP Server（opensandbox-mcp）官方 MCP Server无
GPU 支持无无--gpu 直通（实验性）
状态快照无Snapshots（OCI 镜像快照，跨会话持久化）无
部署方式Docker / KubernetesDocker Compose（自托管）/ 托管云 / 混合部署K3s-in-Docker（单容器）/ 远程主机
人工操作界面CLI（osb）Dashboard·Web Terminal·SSH·VNC·VPN·预览 URLTUI（类 k9s）·SSH
协议标准化OpenAPI 规范（sandbox-lifecycle.yml + execd-api.yaml）；CNCF Landscape自有 REST API（无统一沙箱协议规范）gRPC（proto/sandbox.proto）；无通用标准
大规模调度Kubernetes 原生（BatchSandbox/agent-sandbox）多 Region + 多 Runner 节点水平扩展Alpha 阶段，单机为主；企业级多租户待支持
调度器Kubernetes 原生调度器（kube-scheduler）—— K8s 运行时模式；Docker 模式无集中调度自研 7 维加权调度器（按 CPU/内存/磁盘/已分配资源等评分，选最优 Runner 节点；无 Kubernetes 依赖）K3s 内嵌 kube-scheduler；Alpha 阶段为单节点，多节点调度尚未支持
成熟度生产可用，CNCF Landscape生产可用，已有托管云Alpha，主打开发者个人场景
适用场景AI框架集成、代码沙箱标准化、大规模 K8s 批量任务AI Coding Agent 平台、持久化 Agent 工作流、组织级管控单机 Coding Agent 安全运行、AI 推理隐私保护

如何选择​

  • 若需要将沙箱能力统一接入多个 AI 框架，或需要大规模 Kubernetes 批量沙箱调度，OpenSandbox 的协议标准化设计和原生 K8s 支持是最优选。
  • 若需要构建一个面向组织的 AI Coding Agent 平台，需要完整的用户管理、持久化快照、Dashboard、多区域部署和丰富的人工交互界面（VNC/SSH/VPN），Daytona 提供了最完整的平台工程体验。
  • 若是开发者个人使用 Claude Code/Codex 等 Agent，关注凭据安全、推理隐私和网络访问控制，希望用声明式 YAML 策略精细限制 Agent 的文件/网络行为，OpenShell 提供了目前最深度的安全纵深防御机制，但需接受其 Alpha 阶段的稳定性现状。

总结​

OpenSandbox以协议标准化为核心，构建了一套从SDK到运行时、从网络管控到安全隔离的完整AI应用沙箱平台。其主要价值体现在：

  • 统一的沙箱协议解决了不同AI框架、不同运行时之间的接入碎片化问题
  • 多语言SDK 让各技术栈的团队都能以最小成本接入沙箱能力
  • Docker+Kubernetes双运行时兼顾了本地开发便利性和生产大规模部署需求
  • gVisor/Kata/Firecracker安全运行时为多租户场景下的AI代码执行提供了硬件级隔离保障
  • Egress/Ingress网络策略提供了开箱即用的精细网络访问控制，有效降低出站数据泄露风险
  • MCP原生集成让其能够无缝嵌入以Claude Code、Cursor为代表的新一代AI编程工具链

对于正在构建Coding Agent、智能体评估平台或AI代码执行服务的团队，OpenSandbox提供了一个经过生产验证、协议规范明确、生态持续扩展的基础设施选择。