---
title: "OpenSandbox Là Gì: Nền Tảng Sandbox Cô Lập AI Agent Với Docker & K8s"
description: "OpenSandbox là gì? Khám phá nền tảng sandbox mã nguồn mở của Alibaba (alibaba/OpenSandbox) giúp cô lập an toàn AI agent trên môi trường Docker và Kubernetes."
pubDate: "2026-03-06"
updatedDate: "2026-09-29"
lang: "vi"
slug: "opensandbox-explained"
url: "https://hoangyell.com/vi/opensandbox-explained/"
author: "HoangYell"
translation_en: "https://hoangyell.com/opensandbox-explained/"
categories: ["AI & Agents"]
tags: ["ai", "sandbox", "mlops"]
heroImage: "https://raw.githubusercontent.com/HoangGeek/store/main/webp/ai-opensandbox-explained.webp"
---

**[OpenSandbox](https://github.com/alibaba/OpenSandbox)** của Alibaba là nền tảng sandbox mã nguồn mở toàn năng, cung cấp môi trường thực thi chuẩn hoá cho AI agents chạy trên Docker và Kubernetes.

***

## TL;DR

> **Hộp Trả Lời Nhanh (Google Search Featured Snippet):**
> - **OpenSandbox là gì?** Nền tảng và giao thức sandbox thực thi mã nguồn mở do Alibaba phát triển (`alibaba/OpenSandbox`), cung cấp môi trường cô lập chuẩn hoá cho các AI coding agent, tác tử duyệt web (browser automation), và huấn luyện học tăng cường (RL).
> - **Tại sao AI agent bắt buộc phải dùng OpenSandbox?** Các agent tự trị thường xuyên thực thi lệnh bash, chạy unit test và chỉnh sửa file. Cho agent chạy trực tiếp trên máy thật dễ dẫn đến nguy cơ xoá nhầm dữ liệu hệ thống hoặc rò rỉ token; OpenSandbox cô lập tiến trình an toàn trong Docker/Kubernetes bằng gVisor, Kata Containers hoặc Firecracker microVM.
> - **Hỗ trợ đa ngôn ngữ**: Cung cấp SDK chính thức cho Python, TypeScript/JavaScript, Java và C#.
> - **Kho mã nguồn chính thức**: [alibaba/OpenSandbox trên GitHub](https://github.com/alibaba/OpenSandbox).

- **Phù hợp nhất:** Developer chạy các agent tự trị như Claude Code, Gemini CLI, LangGraph mà không lo sập hoặc nhiễm độc máy host.
- **Tại sao quan trọng:** Xoá bỏ việc tự chế sandbox thủ công dễ vỡ, cung cấp API hợp nhất cho Docker container local và Kubernetes pods trên cloud.

Repository: [alibaba/OpenSandbox](https://github.com/alibaba/OpenSandbox)

***

## Bản Đồ Cho Người Mới

### Lộ Trình 3 Phút: Chạy Sandbox Cô Lập Đầu Tiên

1. **Cài đặt SDK**: Cài đặt SDK vào project agent của bạn: `pip install opensandbox` (hoặc `npm install @opensandbox/sdk`).
2. **Khởi động Sandbox Daemon**: Chạy máy chủ sandbox local: `docker run -d -p 8080:8080 opensandbox/server:latest`.
3. **Thực thi code không tin cậy**: Khởi tạo container microVM cô lập và chạy lệnh shell an toàn qua Python hoặc TypeScript mà không ảnh hưởng máy host.
4. **Scale lên Kubernetes**: Trỏ trực tiếp agent orchestrator từ Docker local lên cụm K8s pod production mà không cần sửa code ứng dụng. Tham khảo thêm [Strix](/vi/strix-explained/) và [PentAGI](/vi/pentagi-explained/) cho các sandbox bảo mật tự trị.

***

Đừng tiếp cận OpenSandbox như một mớ script container rối rắm. Hãy nhìn nó theo **3 tầng kiến trúc: SDK Đa Ngôn Ngữ -> Server Giao Thức Mở -> Container/microVM Cách Ly**.

1. **Lượt 1:** Phần 1: Mental model ổ cắm toàn cầu (tại sao cần môi trường cô lập).
2. **Lượt 2:** Phần 2: Đi sâu kiến trúc, công nghệ cách ly gVisor/Kata, và giao thức OSEP.
3. **Lượt 3:** Phần 3: Các vấn đề giải quyết dứt điểm (thống nhất SDK, scale từ laptop lên K8s).
4. **Lượt 4:** Phần 4: 3 bước thực chiến và chạy lệnh sandbox đầu tiên.

| Thuật ngữ | Câu hỏi giải đáp |
|:---|:---|
| **Server** | Ai khởi tạo, quản lý và dọn dẹp container sandbox? |
| **SDK** | Code Python/TypeScript của agent gọi vào sandbox bằng cách nào? |
| **gVisor / Kata** | Cơ chế nào ngăn script độc hại chọc thủng máy host? |
| **OSEP** | Giao thức sandbox phát triển và chuẩn hoá cộng đồng ra sao? |
| **Docker vs K8s** | Làm sao test local nhẹ nhàng rồi scale nghìn agent trên cloud? |

### Thử thách thực hành

1. Cài đặt `opensandbox-server` bằng uv/pip trên máy local.
2. Khởi tạo cấu hình Docker mặc định qua `opensandbox-server init-config ~/.sandbox.toml --example docker`.
3. Khởi động server với `opensandbox-server` và chạy script Python ở Phần 4 để in ra `echo 'Hello OpenSandbox!'`.
4. Kiểm tra container tự khởi chạy, in kết quả ra terminal và được dọn dẹp sạch sẽ không để lại tiến trình rác.

***

## Phần 1: Nền Tảng - Mental Model

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/opensandbox-isolation-cube-meme.webp)

Hãy tưởng tượng bạn là một AI agent. Bạn cần viết code, chạy nó, lướt web, tương tác với desktop, thậm chí có thể huấn luyện một mô hình: tất cả trong một môi trường an toàn, cách ly hoàn toàn. Hệ thống host không bị ảnh hưởng, nhưng bên trong "hộp" thì bạn có toàn quyền.

Đó chính xác là thứ mà **[OpenSandbox](https://github.com/alibaba/OpenSandbox)** của Alibaba cung cấp.

> **Mental Model**: Hãy nghĩ đến OpenSandbox như một *ổ cắm điện toàn cầu cho AI agent*: một giao thức chuẩn hoá mà bất kỳ agent nào (Claude Code, Gemini CLI, LangGraph, Google ADK, v.v.) đều có thể kết nối vào. Sandbox bọc các Docker container hoặc Kubernetes pod, rồi expose ra một API nhất quán duy nhất để tạo môi trường, chạy lệnh, quản lý file, và thực thi code.

Thay vì mỗi AI framework tự phát minh lại sandbox riêng, OpenSandbox cung cấp một **giao thức mở duy nhất** mà tất cả đều dùng chung.

***

## Phần 2: Điều Tra - Kiến Trúc Chi Tiết

### Kiến Trúc Phân Lớp

OpenSandbox được tổ chức thành các lớp rõ ràng, mỗi lớp giải quyết một vấn đề:

*Mô hình kiến trúc phân lớp điều phối vòng đời và thực thi sandbox an toàn của OpenSandbox:*

```markdy
scene width=1100 height=620
theme: light=doodle dark=nebula
layout TB

user Agent "AI Coding Agent (Claude Code / LangGraph / ADK)"
service ClientSDK "SDK Đa Ngôn Ngữ (Python / TypeScript / Java / C#)"
service Server "OpenSandbox Control Server (Vòng Đời: Create/Kill)"
module Execd "Execution Daemon (execd: Commands, Files, Interpreter)"
module Security "Lớp Cách Ly An Toàn: gVisor / Kata / Firecracker"
cloud LocalEnv "Local Runtime: Docker Engine Container"
cloud CloudEnv "Production Cloud: Kubernetes Pods + HPA Auto-Scale"

group runtimes "Hạ Tầng Thực Thi Cô Lập Chuẩn Hoá":
  Security
  LocalEnv
  CloudEnv

edge e1: Agent -> ClientSDK: "Gọi API thực thi mã / bash qua client"
edge e2: ClientSDK -> Server: "HTTP/gRPC OSEP Protocol (Lifecycle & Exec)"
edge e3: Server -> Security: "Khởi tạo container bọc kernel userspace"
edge e4: Security -> LocalEnv: "Spawn sandbox local nhẹ nhàng trên laptop"
edge e5: Security -> CloudEnv: "Scale hàng nghìn pods song song trên K8s"
edge e6: Server -> Execd: "Bơm file, chạy lệnh commands.run & code interpreter"
edge e7: Execd -> Server: "Stream stdout, stderr và filesystem diff"
edge e8: Server -> ClientSDK: "Trả kết quả an toàn tuyệt đối cho Agent"
```

### Cấu Trúc Dự Án

| Thư Mục | Mục Đích |
|---|---|
| `sdks/` | SDK client (Python, JS/TS, Java, C#) |
| `specs/` | OpenAPI + OSEP (OpenSandbox Enhancement Proposals) |
| `server/` | Máy chủ sandbox lõi |
| `kubernetes/` | Runtime Kubernetes cho triển khai phân tán |
| `components/execd/` | Execution daemon bên trong container sandbox |
| `components/ingress/` | Ingress gateway với nhiều chiến lược routing |
| `components/egress/` | Kiểm soát egress/network riêng cho từng sandbox |
| `sandboxes/` | Các Docker image sandbox đã được build sẵn |
| `examples/` | Ví dụ tích hợp end-to-end |

### Sandbox Protocol (OSEPs)

OpenSandbox sử dụng quy trình đề xuất cải tiến chính thức gọi là **OSEP (OpenSandbox Enhancement Proposals)**, tương tự như PEP của Python, để phát triển nền tảng theo hướng cộng đồng. Protocol định nghĩa hai nhóm API:

- **Lifecycle APIs**: `create`, `start`, `pause`, `resume`, `kill` → quản lý container sandbox
- **Execution APIs**: `commands.run`, `files.write`, `files.read`, `codes.run` → tương tác với nội dung bên trong

### Bảo Mật: Tuỳ Chọn Cách Ly Mạnh Mẽ

Đây là điểm OpenSandbox vượt trội so với các giải pháp Docker đơn thuần. Nó hỗ trợ native các **secure container runtime**:

- **gVisor**: kernel userspace chặn system call, không cho code truy cập trực tiếp kernel host
- **Kata Containers**: VM nhẹ với cách ly cấp phần cứng
- **Firecracker microVMs**: micro virtual machine siêu nhanh (công nghệ AWS Lambda dùng)

Mỗi lựa chọn cung cấp mức độ cách ly ngày càng mạnh hơn giữa sandbox workload và host.

***

## Phần 3: Chẩn Đoán - OpenSandbox Giải Quyết Vấn Đề Gì Cho Developer?

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/opensandbox-universal-dock-meme.webp)

### Vấn Đề 1: Mỗi AI Framework Tự Phát Minh Lại Sandbox

Trước OpenSandbox, nếu bạn muốn chạy Claude Code, Gemini CLI, và LangGraph một cách an toàn song song, bạn cần ba lớp tích hợp sandbox khác nhau. OpenSandbox thống nhất tất cả dưới **một giao thức duy nhất**.

### Vấn Đề 2: Scale Từ Laptop Lên Kubernetes Rất Khó

Docker runtime của OpenSandbox dành cho phát triển local. Kubernetes runtime (`kubernetes/`) xử lý lịch trình phân tán quy mô lớn hàng nghìn sandbox mà không cần thay đổi một dòng code ứng dụng. Cùng một lời gọi SDK, hoạt động cả local lẫn production.

### Vấn Đề 3: Nhóm Đa Ngôn Ngữ Cần SDK Đa Ngôn Ngữ

| Ngôn Ngữ | Trạng Thái |
|---|---|
| Python | ✅ Ổn định |
| JavaScript / TypeScript | ✅ Ổn định |
| Java / Kotlin | ✅ Ổn định |
| C# / .NET | ✅ Ổn định |
| Go | 🔜 Roadmap |

### Các Use Case Thực Tế

| Kịch Bản | Ví Dụ |
|---|---|
| Coding Agent | Claude Code, Gemini CLI, OpenAI Codex CLI |
| LLM Workflow | LangGraph state machine tạo sandbox jobs |
| GUI Automation | Headless Chrome + Playwright trong sandbox |
| Desktop Environment | VNC + full Linux desktop inside container |
| Remote Dev | VS Code (code-server) chạy từ sandbox |
| RL Training | Chạy training episodes trong container cô lập |
| Agent Evaluation | Môi trường eval nhất quán, cô lập, tái hiện được |

***

## Phần 4: Giải Pháp - Cách Dùng OpenSandbox

### Bắt Đầu Trong 3 Bước

**Bước 1 - Cài đặt và cấu hình server**

```bash
uv pip install opensandbox-server
opensandbox-server init-config ~/.sandbox.toml --example docker
```

**Bước 2 - Khởi động sandbox server**

```bash
opensandbox-server
```

**Bước 3 - Tạo sandbox và chạy code**

```python
import asyncio
from datetime import timedelta
from code_interpreter import CodeInterpreter, SupportedLanguage
from opensandbox import Sandbox
from opensandbox.models import WriteEntry

async def main() -> None:
    # 1. Tạo sandbox từ Docker image
    sandbox = await Sandbox.create(
        "opensandbox/code-interpreter:v1.0.1",
        entrypoint=["/opt/opensandbox/code-interpreter.sh"],
        env={"PYTHON_VERSION": "3.11"},
        timeout=timedelta(minutes=10),
    )

    async with sandbox:
        # 2. Chạy lệnh shell
        execution = await sandbox.commands.run("echo 'Hello OpenSandbox!'")
        print(execution.logs.stdout[0].text)   # Hello OpenSandbox!

        # 3. Ghi file
        await sandbox.files.write_files([
            WriteEntry(path="/tmp/hello.txt", data="Hello World", mode=644)
        ])

        # 4. Đọc lại file
        content = await sandbox.files.read_file("/tmp/hello.txt")
        print(f"Content: {content}")  # Content: Hello World

        # 5. Chạy code Python bên trong sandbox
        interpreter = await CodeInterpreter.create(sandbox)
        result = await interpreter.codes.run(
            """
            import sys
            print(sys.version)
            result = 2 + 2
            result
            """,
            language=SupportedLanguage.PYTHON,
        )
        print(result.result[0].text)       # 4
        print(result.logs.stdout[0].text)  # 3.11.x

    # Sandbox tự dọn dẹp sau khi ra khỏi context manager
```

### Tích Hợp Coding Agent (Ví Dụ Google ADK)

```python
# Dùng OpenSandbox như tool backend cho Google ADK agent
from google.adk.tools import BaseTool
from opensandbox import Sandbox

class SandboxRunTool(BaseTool):
    async def run_in_sandbox(self, code: str) -> str:
        sandbox = await Sandbox.create("opensandbox/code-interpreter:v1.0.1")
        async with sandbox:
            interpreter = await CodeInterpreter.create(sandbox)
            result = await interpreter.codes.run(code, language=SupportedLanguage.PYTHON)
            return result.result[0].text
```

### Chạy Claude Code hoặc Gemini CLI Trong Sandbox

```bash
# Clone các ví dụ
git clone https://github.com/alibaba/OpenSandbox.git
cd OpenSandbox/examples/claude-code  # hoặc gemini-cli, codex-cli, v.v.

# Theo hướng dẫn README trong từng thư mục ví dụ
```

Mỗi ví dụ đi kèm `Dockerfile` và script khởi động để đặt CLI AI tool vào trong môi trường OpenSandbox được quản lý đầy đủ.

***

## Lời khuyên cuối (Final Take)

```
┌────────────────────────────────────────────────────────────┐
│                        OpenSandbox                         │
│                                                            │
│  "Ổ cắm toàn cầu cho việc thực thi AI agent"              │
│                                                            │
│  LÀ gì:                                                    │
│  → Sandbox giao thức mở với lifecycle + execution API      │
│  → SDK đa ngôn ngữ (Python, JS, Java, C#)                 │
│  → Docker cho local dev + Kubernetes cho production        │
│                                                            │
│  GIẢI QUYẾT gì:                                            │
│  → Sandbox phân mảnh cho mỗi AI framework                 │
│  → Thực thi code không an toàn, thiếu cô lập              │
│  → Scale từ laptop lên cloud mà không cần sửa code        │
│                                                            │
│  CHO PHÉP gì:                                              │
│  → Coding agents (Claude, Gemini, Codex)                   │
│  → GUI agents (Chrome, Playwright, VNC)                    │
│  → RL training + agent evaluation                          │
│  → Remote dev (VS Code bên trong sandbox)                  │
│                                                            │
│  Cô lập: gVisor | Kata Containers | Firecracker            │
└────────────────────────────────────────────────────────────┘
```

Rủi ro lớn nhất khi chạy AI agent tự trị không phải là nó viết code dở, mà là nó tự ý thực thi các lệnh phá hoại trên môi trường host. Việc tự chắp vá các wrapper Docker sơ sài cho từng framework chỉ tạo ra những hệ thống mong manh, dễ lọt lỗ hổng bảo mật. OpenSandbox biến việc cô lập agent thành một giao thức hạ tầng tiêu chuẩn. Bằng cách chuẩn hoá môi trường chạy qua gVisor, Kata Containers và Kubernetes, nó trao cho developer chiếc khiên phòng vệ vững chắc để agent thoải mái vẫy vùng mà hạ tầng thật sự vẫn bình an vô sự.

**GitHub**: [alibaba/OpenSandbox](https://github.com/alibaba/OpenSandbox)  
**Tài liệu**: [open-sandbox.ai](https://open-sandbox.ai/)

***

## Câu Hỏi Thường Gặp Về OpenSandbox (FAQ)

### 1. OpenSandbox là gì và do ai phát triển?
OpenSandbox là nền tảng thực thi sandbox mã nguồn mở và giao thức chuẩn hóa do Alibaba phát triển. Nó cung cấp bộ API đồng nhất để khởi tạo, quản lý và dọn dẹp các môi trường cô lập an toàn cho coding agent, browser agent và các mô hình học tăng cường (RL) trên cả Docker lẫn Kubernetes.

### 2. OpenSandbox khác gì so với container Docker thông thường?
Các container Docker thông thường chia sẻ trực tiếp nhân Linux (kernel) của máy host, dễ bị tấn công leo thang đặc quyền (kernel escape) nếu AI agent chạy phải mã độc. OpenSandbox tích hợp các tầng cô lập cấp độ ảo hóa:
- **gVisor**: Đánh chặn và kiểm chứng toàn bộ syscall trong kernel tầng user-space.
- **Kata Containers / Firecracker**: Khởi động các microVM phần cứng siêu nhẹ chỉ trong vài phần trăm giây, đảm bảo cách ly phần cứng tuyệt đối nhưng vẫn giữ được sự linh hoạt của container.

### 3. Tôi có thể chạy OpenSandbox trên máy cá nhân mà không cần Kubernetes không?
Hoàn toàn được. OpenSandbox hỗ trợ chế độ phát triển local chỉ với Docker. Bạn chỉ việc cài đặt `opensandbox-server` qua pip/uv, chạy `opensandbox-server init-config --example docker`, và tương tác với sandbox bằng Python hoặc TypeScript SDK mà không cần dựng cluster.

### 4. OpenSandbox tương thích với những công cụ và framework AI nào?
OpenSandbox cung cấp sẵn các ví dụ tích hợp chính thức cho Claude Code, Gemini CLI, OpenAI Codex, và Google ADK. Bất kỳ agent tự viết nào bằng Python, TypeScript, Java hay C# đều có thể kết nối vào sandbox thông qua SDK đa ngôn ngữ.

***

### Bài Viết Kiến Trúc AI Agent Liên Quan

- **[Pi Mono: Kiến Trúc AI Coding Agent Tự Trị](/vi/pi-mono-explained/)**: Khám phá các khối nguyên thủy tổ hợp và runtime đơn luồng điều phối agent local.
- **[PentAGI: Tự Động Hóa Pentest Với AI Đa Tác Vụ](/vi/pentagi-explained/)**: Tìm hiểu cách các agent an ninh mạng khai thác container sandbox để kiểm thử lỗ hổng an toàn.
- **[Ego Lite: Agent AI Tự Trị Trong Trình Duyệt](/vi/ego-lite-browser-ai-agents/)**: Khám phá cách các không gian desktop (Spaces) cô lập tác tử duyệt web mà vẫn kế thừa phiên đăng nhập thật.
