使用公用模板建立執行個體 - Platform For AI

PAI-Instant Service提供 code-interpreter、browser、claude-code等預置公用模板，覆蓋代碼執行、瀏覽器自動化、案頭操作、AI Coding 等主流應用情境，開箱即用。以下介紹各公用模板的功能與使用方式。

概述

公用模板由 EAS 平台預置，無需自建即可在任意即時服務下使用。每個公用模板針對特定應用情境做了運行時環境的預配置（如預裝庫、開機前服務、預設連接埠）。

模板選型對照表

應用情境	推薦公用模板	關鍵能力
代碼解譯器 / 資料分析	`code-interpreter`	預裝Python 3.11（含 numpy/pandas/matplotlib/sklearn）、JavaScript、TypeScript
瀏覽器自動化 / Web 搜尋	`browser`	Chromium + Playwright/MCP 雙協議接入
案頭 G使用者介面自動化 / 截圖	`desktop`	Ubuntu 22.04 + 遠端桌面 + 使用者介面自動化 SDK
AI Coding（Claude）	`claude-code`	預裝 Claude CLI + 百鍊 API 接入
AI Coding（開源）	`opencode`	預裝 opencode + opencode server
通用任務應用	`openclaw` / `qwenpaw`	通用任務應用架構 + 百鍊 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），可提供自動化瀏覽能力。以下分別介紹通過 Playwright、MCP 直接操控執行個體中的瀏覽器，以及通過 browser_use 構建 DeepSearch 應用的方式。

方式一：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}")