使用公共模板创建沙箱-人工智能平台 PAI(PAI)-阿里云帮助中心

概述

公共模板由 EAS 平台预置，无需自建即可在任意沙箱空间下使用。每个公共模板针对特定 Agent 场景做了运行时环境的预配置（如预装库、预启动服务、预设端口）。

模板选型对照表

Agent 场景	推荐公共模板	关键能力
代码解释器 / 数据分析	`code-interpreter`	预装Python 3.11（含 numpy/pandas/matplotlib/sklearn）、JavaScript、TypeScript
浏览器自动化 / Web 搜索	`browser`	Chromium + Playwright/MCP 双协议接入
桌面 GUI 自动化 / 截图	`desktop`	Ubuntu 22.04 + 远程桌面 + UI 自动化 SDK
AI Coding（Claude）	`claude-code`	预装 Claude CLI + 百炼 API 接入
AI Coding（开源）	`opencode`	预装 opencode + opencode server
通用任务 Agent	`openclaw` / `qwenpaw`	通用任务 Agent 框架 + 百炼 API 接入

通用前置准备

使用公共模板前，请先：

创建沙箱空间。
获取SDK连接配置：在 模板详情 页单击右上角 SDK接入 获取E2B_DOMAIN 、E2B_API_KEY 以及模板id。

说明
公共模板使用沙箱空间级Token作为E2B_API_KEY 。用户可在创建沙箱空间时设置自定义Token，替代系统自动生成的。
安装 E2B SDK（仅支持使用小于v2.25.0的版本）：pip install "e2b<2.25.0"。

code-interpreter

code-interpreter 公共模板提供了 Python 3.11、JavaScript、TypeScript 的开发环境，可基于 e2b_code_interpreter SDK 进行代码执行和文件操作。

pip install e2b_code_interpreter

import os
import time
from e2b_code_interpreter import Sandbox

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"

sandbox = Sandbox.create(template="code-interpreter", timeout=300000)

# 等待沙箱就绪
print(f"Waiting for sandbox {sandbox.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if sandbox.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

# Python 代码执行
execution = sandbox.run_code("print('hello world')")
print(execution.logs)

sandbox.run_code("x = 42")
execution = sandbox.run_code("print(f'x = {x}')")
print(execution.logs.stdout)

# JavaScript
result = sandbox.commands.run("node -e \"console.log('Hello from Node.js')\"")
print(result.stdout)

# TypeScript
result = sandbox.commands.run("tsx -e \"const msg: string = 'Hello from TypeScript'; console.log(msg)\"")
print(result.stdout)

# 文件操作
entries = sandbox.files.list("/home/user")
for e in entries:
    print(f"{e.type}\t{e.name}")

sandbox.files.write("/home/user/hello.txt", "Hello from sandbox")
content = sandbox.files.read("/home/user/hello.txt")
print(content)

browser

browser 公共模板预装了 Chromium 浏览器，并提供 CDP（Chrome DevTools Protocol）和 MCP 两种访问方式（端口分别为 8080 和 50005），可为 Agent 提供自动化浏览能力。以下分别介绍通过 Playwright、MCP 直接操控沙箱中的浏览器，以及通过 browser_use 构建 DeepSearch Agent 的方式。

方式一：Playwright

客户端需安装 Playwright：

pip install playwright

通过 CDP（Chrome DevTools Protocol）WebSocket 连接沙箱内的浏览器，使用 Playwright 完整 API 执行页面导航、截图、元素提取等操控：

import asyncio
import os
import time
from urllib.parse import quote_plus

import httpx
from e2b import Sandbox
from playwright.async_api import async_playwright

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"
GATEWAY_PORT = 8080

sandbox = Sandbox.create(template="browser", timeout=300000)

print(f"Waiting for sandbox {sandbox.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if sandbox.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

# 鉴权请求头（所有请求必须）
def _auth_headers():
    return {
        "X-Access-Token": sandbox._envd_access_token,
        "E2b-Sandbox-Id": sandbox.sandbox_id,
    }

# 获取 CDP WebSocket URL
def get_cdp_url():
    gateway_host = sandbox.get_host(GATEWAY_PORT)
    resp = httpx.get(
        f"https://{gateway_host}/json/version",
        headers=_auth_headers(), timeout=10, verify=False,
    )
    resp.raise_for_status()
    guid = resp.json()["webSocketDebuggerUrl"].rsplit("/", 1)[-1]
    return f"wss://{gateway_host}/devtools/browser/{guid}"

async def search_with_playwright(query: str):
    cdp_url = get_cdp_url()
    print(f"CDP URL: {cdp_url}")

    async with async_playwright() as p:
        browser = await p.chromium.connect_over_cdp(cdp_url, headers=_auth_headers())

        if browser.contexts and browser.contexts[0].pages:
            page = browser.contexts[0].pages[0]
        else:
            page = await (await browser.new_context()).new_page()

        # 导航
        search_url = f"https://www.bing.com/search?q={quote_plus(query)}"
        await page.goto(search_url, wait_until="load", timeout=30000)
        print(f"Navigated to: {search_url}")

        # 等待搜索结果渲染
        try:
            await page.wait_for_selector("li.b_algo", timeout=10000)
        except Exception:
            await page.wait_for_timeout(3000)

        # 截图
        with open("screenshot.png", "wb") as f:
            f.write(await page.screenshot(full_page=True))
        print("Screenshot saved: screenshot.png")

        # 提取搜索结果
        results = await page.evaluate("""() => {
            const items = document.querySelectorAll('li.b_algo h2 a');
            return Array.from(items).slice(0, 5).map(a => ({
                title: a.textContent || '',
                url: a.href || ''
            }));
        }""")

        await browser.close()
    return results

if __name__ == "__main__":
    results = asyncio.run(search_with_playwright("Python latest release"))
    for i, r in enumerate(results, 1):
        print(f"  {i}. {r['title']} — {r['url']}")

方式二：MCP

客户端需安装 MCP：

pip install mcp

通过 MCP 协议调用语义化浏览器工具，无需直接管理页面对象：

import asyncio
import os
import time
from urllib.parse import quote_plus

import httpx
from e2b import Sandbox
from mcp.client.session import ClientSession
from mcp.client.streamable_http import streamable_http_client

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"
MCP_PORT = 50005

sandbox = Sandbox.create(template="browser", timeout=300000)

print(f"Waiting for sandbox {sandbox.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if sandbox.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

def _auth_headers():
    return {
        "X-Access-Token": sandbox._envd_access_token,
        "E2b-Sandbox-Id": sandbox.sandbox_id,
    }

def get_mcp_url():
    return f"https://{sandbox.get_host(MCP_PORT)}/mcp"

async def search_with_mcp(query: str):
    mcp_url = get_mcp_url()
    print(f"MCP URL: {mcp_url}")
    client = httpx.AsyncClient(headers=_auth_headers(), verify=False)

    async with client:
        async with streamable_http_client(mcp_url, http_client=client) as (
            read_stream, write_stream, _,
        ):
            async with ClientSession(read_stream, write_stream) as session:
                await session.initialize()
                print("MCP session initialized")

                # 导航
                search_url = f"https://www.bing.com/search?q={quote_plus(query)}"
                await session.call_tool("browser_navigate", {"url": search_url})
                print(f"Navigated to: {search_url}")

                # 等待页面加载
                await session.call_tool("browser_wait_for", {"time": 2})

                # 获取页面快照
                snap = await session.call_tool("browser_snapshot", {})
                result_text = " ".join(
                    getattr(item, "text", "") for item in snap.content
                )

    return result_text

if __name__ == "__main__":
    text = asyncio.run(search_with_mcp("Python latest release"))
    print(f"Result:\n{text}")

desktop

desktop 公共模板中预安装了 Ubuntu 22.04 系统，可使用 e2b_desktop SDK 在沙箱环境中执行自动化 UI 操作。

pip install e2b_desktop

import os
import time
from e2b_desktop import Sandbox

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"

create_kwargs = {
    "timeout": 3600,
    "resolution": (1920, 1080),
    "dpi": 96,
    "template": "desktop",
}
desktop = Sandbox.create(
    **create_kwargs,
    headers={"X-Sandbox-Create-Timeout": "100"},
)

print(f"Waiting for sandbox {desktop.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if desktop.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

# UI 操作
print("Moving mouse to (100, 100)...")
desktop.move_mouse(100, 100)
time.sleep(0.5)

print("Left clicking...")
desktop.left_click()
time.sleep(0.5)

print("Typing 'Hello'...")
desktop.write("Hello")
time.sleep(0.5)

print("Pressing Enter...")
desktop.press("enter")
time.sleep(0.5)

print("Opening browser to example.com...")
desktop.open("https://example.com")
time.sleep(2)

# 截图并下载
print("Taking screenshot...")
screenshot = desktop.screenshot("bytes")
if screenshot:
    screenshot_path = "/tmp/desktop_screenshot.png"
    with open(screenshot_path, "wb") as f:
        f.write(screenshot)
    print(f"Screenshot saved to {screenshot_path}")
else:
    print("Screenshot returned empty")

在所创建的 Sandbox 详情页面，单击打开VNC，可远程连接到 Sandbox 图形界面。

claude-code

claude-code 公共模板中预安装了 claude-code，基于该模板创建沙箱并提供 ANTHROPIC 相关环境变量，即可在安全隔离的环境中使用 claude-code 执行编码任务。

import os
import time
from e2b import Sandbox

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"

sandbox = Sandbox.create(
    template="claude-code",
    timeout=300000,
    envs={
        "ANTHROPIC_AUTH_TOKEN": "<YOUR-TOKEN>",
        "ANTHROPIC_BASE_URL": "<YOUR-BASE-URL>",
        "ANTHROPIC_MODEL": "<YOUR-MODEL>",
    },
)

print(f"Waiting for sandbox {sandbox.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if sandbox.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

result = sandbox.commands.run(
    'claude -p "使用 python 写一个计算斐波那契数的程序"',
)
print(result.stdout)

opencode

opencode 公共模板中预安装了 opencode，并启动了 opencode server（端口为 4096）。

opencode 配置文件 /root/.config/opencode/opencode.json 中已预置阿里云百炼的 Token Plan、Coding Plan 和按量付费模式下的模型配置。创建沙箱时通过 BAILIAN-TOKEN-PLAN-KEY、BAILIAN-CODING-PLAN-KEY 或者 BAILIAN-API-KEY 环境变量提供 Key，即可使用 E2B SDK 或通过 HTTP 请求在沙箱环境中使用 opencode 执行编码任务。

import os
import time
import requests
from e2b import Sandbox

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"

OPENCODE_SERVER_PORT = 4096

sandbox = Sandbox.create(
    template="opencode",
    timeout=300000,
    envs={"BAILIAN-API-KEY": os.getenv("BAILIAN-API-KEY")},
)

print(f"Waiting for sandbox {sandbox.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if sandbox.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

# 通过 e2b SDK 调用 opencode CLI
result = sandbox.commands.run(
    'opencode run --model=bailian-payg/qwen3.7-max "使用 python 写一个计算斐波那契数的程序"',
    timeout=120,
)
print(result.stdout)

# 通过 opencode server API 调用
BASE_URL = f"https://{sandbox.get_host(4096)}"
H = {"X-Access-Token": getattr(sandbox, '_SandboxBase__envd_access_token', None)}

# 设置 API key（opencode server 不会自动解析 {env:...} 模板）
api_key = sandbox.commands.run("printenv BAILIAN-API-KEY").stdout.strip()
requests.patch(f"{BASE_URL}/global/config", headers=H, json={
    "provider": {"bailian-payg": {"options": {
        "apiKey": api_key,
        "baseURL": "https://dashscope.aliyuncs.com/apps/anthropic/v1",
    }}}
})

# 创建会话（指定模型）
session = requests.post(f"{BASE_URL}/session", headers=H, json={
    "model": {"id": "qwen3.7-max", "providerID": "bailian-payg"},
}).json()
session_id = session["id"]
print(f"Session: {session_id}")

# 发送编码任务（同步等待完整响应）
resp = requests.post(f"{BASE_URL}/session/{session_id}/message", headers=H, json={
    "parts": [{"type": "text", "text": "用 python 写一个斐波那契程序，保存到 /workspace/fibonacci.py 并运行验证"}]
}, timeout=300).json()

# 打印 assistant 回复
for part in resp.get("parts", []):
    if part["type"] == "text":
        print(part["text"])
    elif part["type"] == "tool":
        print(f"  [tool: {part.get('name')}]")

# 验证生成的文件
print("\n--- fibonacci.py ---")
print(sandbox.commands.run("cat /workspace/fibonacci.py").stdout)
print("--- run ---")
print(sandbox.commands.run("python3 /workspace/fibonacci.py", timeout=30).stdout)

openclaw

openclaw 公共模板中预安装了 openclaw服务。参考如下代码获取URL登录到沙箱中的openclaw服务。

from e2b import Sandbox
import os
import time, httpx
from urllib.parse import urlparse, parse_qs

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"

OPENCLAW_GATEWAY_PORT = 18789

def get_gateway_token(sandbox_id, api_key, domain):
    """Get gateway authentication token via API"""
    url = f"https://api.{domain}/sandboxes/{sandbox_id}"
    headers = {
        "X-API-KEY": api_key,
        "X-Generate-Dashboard-Url": "true",
    }
    resp = httpx.get(url, headers=headers, timeout=10)
    if resp.status_code != 200:
        return None

    data = resp.json()
    dashboard_url = None
    if "metadata" in data and isinstance(data["metadata"], dict):
        meta = data["metadata"]
        dashboard_url = meta.get("sandbox.alicloud.com/dashboard-url") or meta.get("dashboard_url")
    if not dashboard_url:
        dashboard_url = data.get("dashboard_url")

    if dashboard_url:
        parsed = urlparse(dashboard_url)
        qs = parse_qs(parsed.query)
        return qs.get("token", [None])[0]
    return None


sandbox = Sandbox.create(
    template="openclaw",
    timeout=300000,
)

print(f"Waiting for sandbox {sandbox.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if sandbox.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

gateway_token = get_gateway_token(
    sandbox.sandbox_id, os.environ["E2B_API_KEY"], os.environ["E2B_DOMAIN"]
)
url = f"https://{sandbox.get_host(OPENCLAW_GATEWAY_PORT)}?token={gateway_token}"
print(f"    Sandbox Access URL: {url}")

qwenpaw

qwenpaw 公共模板预装并启动了 qwenpaw 服务。参考如下代码获取URL登录到沙箱中的qwenpaw服务。

import os
import time
from urllib.parse import urlparse, parse_qs

import httpx
from e2b import Sandbox

os.environ["E2B_DOMAIN"] = "<YOUR-DOMAIN>"
os.environ["E2B_API_KEY"] = "<YOUR-API-KEY>"

QWENPAW_PORT = 8088


def get_gateway_token(sandbox_id, api_key, domain):
    """通过 API 获取网关认证 Token"""
    url = f"https://api.{domain}/sandboxes/{sandbox_id}"
    headers = {
        "X-API-KEY": api_key,
        "X-Generate-Dashboard-Url": "true",
    }
    resp = httpx.get(url, headers=headers, timeout=10)
    if resp.status_code != 200:
        return None

    data = resp.json()
    dashboard_url = None
    if "metadata" in data and isinstance(data["metadata"], dict):
        meta = data["metadata"]
        dashboard_url = meta.get("sandbox.alicloud.com/dashboard-url") or meta.get("dashboard_url")
    if not dashboard_url:
        dashboard_url = data.get("dashboard_url")

    if dashboard_url:
        parsed = urlparse(dashboard_url)
        qs = parse_qs(parsed.query)
        return qs.get("token", [None])[0]
    return None


sandbox = Sandbox.create(
    template="qwenpaw",
    timeout=300000,
)

# 等待沙箱就绪
print(f"Waiting for sandbox {sandbox.sandbox_id} to be ready...")
for _ in range(30):
    try:
        if sandbox.is_running():
            print("Sandbox is ready.")
            break
    except Exception:
        pass
    time.sleep(2)

gateway_token = get_gateway_token(
    sandbox.sandbox_id, os.environ["E2B_API_KEY"], os.environ["E2B_DOMAIN"]
)
url = f"https://{sandbox.get_host(QWENPAW_PORT)}?token={gateway_token}"
print(f"Sandbox Access URL: {url}")