> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# ما هي ال Containers؟ الفرق بينها وبين الأجهزة الافتراضية
- URL: https://arabroot.io/articles/ما-هي-ال-containers-والفرق-بينها-وبين-الاجهزة-الافتراضية/
- Published: 2026-11-18T16:17:37.000Z
- Updated: 2026-11-18T17:27:16.000Z
- Description: نفتح Container حقيقياً من الخارج ثم نبني واحداً بأيدينا بـ unshare وchroot وcgroup v2، لنفهم ما الذي يعزله فعلاً وأين تقف حدوده أمام الجهاز الافتراضي.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, الحاويات Containers وتنسيقها مع Kubernetes, Docker والحاويات, لينكس والسيرفرات, الاستضافة الذاتية, Docker

عندما تكتب لأول مرة `docker run -it alpine sh` يحدث شيء يبدو كالسحر: في أقل من ثانية تجد نفسك داخل Linux آخر، له اسم جهاز خاص، وقائمة عمليات لا يظهر فيها غير الـ Shell الذي فتحته ورقمه 1، وعنوان شبكة خاص، ونظام ملفات كامل لا يرى ملفاتك. والسؤال الطبيعي بعدها: ما هذا الشيء بالضبط؟ هل هو جهاز افتراضي صغير؟ وإذا كان كذلك فكيف يقلع في جزء من الثانية بينما يحتاج أي جهاز افتراضي إلى إقلاع نظام كامل؟ وإذا لم يكن كذلك فأين يعيش، ومن يمنعه من رؤية بقية الجهاز؟

والإجابة القصيرة أن الـ Container ليس جهازاً على الإطلاق، وإنما عملية Process عادية تعمل على نواة المضيف Host نفسها، طلب Docker من النواة أن تريها نسخة خاصة من العالم، وأن تحد ما تأخذه من الذاكرة والمعالج. وهذه الإجابة صحيحة ولكنها لا تكفي لتفهم لماذا يتصرف الـ Container كما يتصرف، ولماذا يقتل فجأة برمز 137، ولماذا تختفي ملفاته عند حذفه، ولماذا لا ينصح بالاعتماد عليه وحده لعزل عميل عن عميل. لذلك سوف نأخذ في هذا المقال Container حقيقياً ونفتحه من الخارج قطعة قطعة، ثم نبني واحداً بأيدينا بأدوات Linux فقط دون Docker، ونرى في كل خطوة المخرج الحقيقي للأوامر. وهذا المقال هو أول مقالات مرحلة Docker، فإذا كنت جديداً على الطرفية فابدأ بمقال [سطر الأوامر في Linux للمبتدئين](https://arabroot.io/articles/%D8%B3%D8%B7%D8%B1-%D8%A7%D9%84%D8%A7%D9%88%D8%A7%D9%85%D8%B1-%D9%81%D9%8A-linux-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/) ثم ارجع إلى هنا.

وسوف نناقش في هذا المقال ما يلي:

- المشكلة التي جاءت ال Containers لحلها، ومن أين جاءت أفكارها.
- ال Container من خارجه: رقمان لنفس العملية، ومساحات الأسماء Namespaces التي يعيش فيها.
- مجموعات التحكم cgroups: كيف تحد النواة الذاكرة والمعالج، والفرق بين cgroup v1 وcgroup v2، ومشكلة واجهتنا على Docker Desktop.
- بناء Container بأيدينا داخل جهاز افتراضي: unshare مع chroot مع cgroup v2، وقتل حقيقي بسبب الذاكرة، وتقييد حقيقي للمعالج.
- الفرق بين ال Image وال Container، وطبقات OverlayFS كما تظهر على القرص فعلاً.
- السجل Registry وال Tag وال Digest، ولماذا يحمل اسم واحد مثل `alpine:3.24` ست عشرة قائمة.
- الجهاز الافتراضي مقابل ال Container، وحدود العزل، والأخطاء الشائعة، وجدول قرار.

## ماذا كانت المشكلة قبل ال Containers؟

لنبدأ بالمشكلة نفسها قبل الأداة. أي تطبيق تكتبه لا يعمل وحده، وإنما يحتاج إصداراً محدداً من لغة البرمجة، ومكتبات نظام بإصدارات معينة، وملفات إعداد في أماكن معروفة، ومتغيرات بيئة، وربما أداة سطر أوامر يستدعيها. وعلى جهاز المطور تكون كل هذه الأشياء موجودة بالصدفة لأنه ثبتها خلال شهور من العمل، أما على السيرفر فتكون مختلفة قليلاً، وعلى سيرفر الاختبار مختلفة قليلاً بطريقة أخرى. والنتيجة الجملة التي يعرفها كل من عمل في فريق: «يعمل على جهازي». والمشكلة الثانية أن تطبيقين على نفس السيرفر قد يحتاج أحدهما Python 3.9 والآخر Python 3.13، أو يحتاجان نفس المنفذ، أو يكتب أحدهما في مجلد يقرؤه الآخر، فيكسر تحديث أحدهما الآخر دون أن يلمسه أحد.

والحل الأول الذي استخدمته الشركات لسنوات هو الجهاز الافتراضي Virtual Machine: لكل تطبيق جهاز كامل بنظامه ومكتباته، فلا يرى أحدهما الآخر. وهذا حل صحيح ولكنه ثقيل، فكل جهاز يحمل نواة كاملة وخدمات نظام كاملة ويأخذ من الذاكرة والقرص ما يكفي لتشغيل نظام، ويحتاج إقلاعاً وتحديثات أمنية خاصة به. وقد شرحنا في مقال [المحاكاة الافتراضية من Hypervisor إلى KVM](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%8A-%D8%A7%D9%84%D9%85%D8%AD%D8%A7%D9%83%D8%A7%D8%A9-%D8%A7%D9%84%D8%A7%D9%81%D8%AA%D8%B1%D8%A7%D8%B6%D9%8A%D8%A9-virtualization-%D9%85%D9%86-hypervisor-%D8%A7%D9%84%D9%89-kvm/) كيف يعمل هذا من الداخل وكم يكلف. والسؤال الذي قاد إلى ال Containers كان: إذا كانت كل التطبيقات تعمل على Linux أصلاً، فلماذا نحمل نواة كاملة لكل تطبيق؟ لماذا لا تعزل النواة الواحدة التطبيقات بعضها عن بعض؟

والفكرة ليست جديدة. فالأمر [chroot](https://man7.org/linux/man-pages/man2/chroot.2.html?ref=arabroot.io) من أقدم أوامر Unix، وهو يغير المجلد الذي تراه العملية كجذر لنظام الملفات، فلا تستطيع فتح ملف خارجه بالمسار العادي. ثم جاءت [Jails في FreeBSD](https://docs.freebsd.org/en/books/handbook/jails/?ref=arabroot.io) عام 2000 فعزلت العمليات والشبكة أيضاً. وفي Linux دخلت الفكرة على مراحل كما يشرح [مقال LWN عن مساحات الأسماء](https://lwn.net/Articles/531114/?ref=arabroot.io): مساحة نقاط التركيب Mount Namespace عام 2002، ثم بقية الأنواع على مدى عشر سنوات، ومعها [مجموعات التحكم cgroups](https://lwn.net/Articles/236038/?ref=arabroot.io) التي بدأها مهندسون في Google تحت اسم Process Containers ودخلت النواة في الإصدار [2.6.24](https://kernelnewbies.org/Linux%5F2%5F6%5F24?ref=arabroot.io) عام 2008\. ثم جمع مشروع [LXC](https://linuxcontainers.org/lxc/introduction/?ref=arabroot.io) هذه الأدوات في 2008، وفي 2013 ظهر Docker فأضاف ما كان ينقصها ليستخدمها كل مطور: صيغة Image تحمل التطبيق مع كل ما يحتاجه، وسجلاً Registry تنشر فيه ال Images وتسحبها منه بأمر واحد. وفي 2015 تأسست [مبادرة OCI](https://opencontainers.org/about/overview/?ref=arabroot.io) لتوحيد صيغة ال Image وطريقة تشغيلها، ولذلك تعمل نفس ال Image اليوم مع Docker وPodman وKubernetes.

وبالتالي فكل ما سوف تراه في هذا المقال ثلاث أدوات في النواة، ولا يوجد شيء اسمه «Container» داخل نواة Linux: مساحات الأسماء Namespaces تحدد ما تراه العملية، ومجموعات التحكم cgroups تحدد ما تأخذه، ونظام الملفات المتراكب OverlayFS يعطيها نظام ملفاتها. وDocker برنامج يجمع هذه الثلاث بالترتيب الصحيح ويخفي تفاصيلها خلف أمر واحد.

## ال Container من الخارج: عملية برقمين

الآن سوف نشغل Container عادياً ونبحث عنه من الخارج. الأمر التالي يشغل Container من Alpine باسم جهاز `web1`، يدور في حلقة لا تنتهي، ثم ندخل إليه ونسأله عن نفسه:

```bash
docker run -d --name ct1-web --hostname web1 alpine:3.24 sh -c 'while true; do sleep 3600; done'
docker exec ct1-web sh -c 'hostname; ps; ls -l /proc/1/ns'
```

والمخرج سوف يكون كما يلي (اختصرنا سطور `ls` إلى الاسم والرقم):

```text
web1
PID   USER     TIME  COMMAND
    1 root      0:00 sh -c while true; do sleep 3600; done
    7 root      0:00 sleep 3600
    8 root      0:00 sh -c hostname; ps; ls -l /proc/1/ns
   14 root      0:00 ps
cgroup -> cgroup:[4026531835]
ipc -> ipc:[4026533064]
mnt -> mnt:[4026533062]
net -> net:[4026533066]
pid -> pid:[4026533065]
time -> time:[4026533173]
user -> user:[4026531837]
uts -> uts:[4026533063]
```

من الداخل يبدو كل شيء كجهاز صغير مستقل: الـ Shell الذي شغلناه هو العملية رقم 1، ولا توجد أي عملية أخرى من المضيف، واسم الجهاز `web1`. والآن ننظر من الخارج. نسأل Docker عن رقم هذه العملية عند المضيف، ثم نشغل Container مساعداً بالخيار `--pid=host` حتى يرى عمليات المضيف كلها، وفيه أدوات util-linux:

```bash
docker inspect -f '{{.State.Pid}}' ct1-web
docker run --rm --privileged --pid=host ct1-tools:1 sh -c '
  ls -l /proc/1/ns; ls -l /proc/77653/ns
  lsns -p 77653
  ps -o pid,ppid,cmd -p 77653; ps -o pid,ppid,cmd --ppid 77653
  grep NSpid /proc/77653/status'
```

والمخرج سوف يكون كما يلي:

```text
77653
--- PID 1 of the host:
cgroup -> cgroup:[4026531835]
ipc -> ipc:[4026532242]
mnt -> mnt:[4026532372]
net -> net:[4026532265]
pid -> pid:[4026532373]
time -> time:[4026531834]
user -> user:[4026531837]
uts -> uts:[4026532254]
--- lsns -p 77653
        NS TYPE   NPROCS   PID USER COMMAND
4026531835 cgroup    142     1 root /initd
4026531837 user      142     1 root /initd
4026533062 mnt         2 77653 root sh -c while true; do sleep 3600; done
4026533063 uts         2 77653 root sh -c while true; do sleep 3600; done
4026533064 ipc         2 77653 root sh -c while true; do sleep 3600; done
4026533065 pid         2 77653 root sh -c while true; do sleep 3600; done
4026533066 net         2 77653 root sh -c while true; do sleep 3600; done
4026533173 time        2 77653 root sh -c while true; do sleep 3600; done
  PID  PPID CMD
77653 77618 sh -c while true; do sleep 3600; done
77689 77653 sleep 3600
NSpid:	77653	1
```

في المخرج أعلاه لاحظ التالي:

- نفس الـ Shell الذي رأى نفسه بالرقم 1 يظهر عند المضيف بالرقم 77653، والسطر `NSpid: 77653 1` يقول ذلك صراحة: النواة تعطي العملية رقمين، رقمها في مساحة أسماء المضيف ورقمها في مساحة الأسماء الخاصة بها. وابنها `sleep` رقمه 7 من الداخل و77689 من الخارج.
- أبو العملية هو 77618، وهي `containerd-shim-runc-v2`، أي البرنامج الصغير الذي يبقى بجانب كل Container ليجمع رمز خروجه ويمرر مخرجه إلى Docker. فلا يوجد «جهاز» في الشجرة، وإنما عملية عادية لها أب عادي.
- العمود `NPROCS` يقول إن مساحات `mnt` و`uts` و`ipc` و`pid` و`net` و`time` فيها عمليتان فقط هما الـ Shell وابنه، وأرقامها 4026533062 وما بعدها تختلف عن أرقام العملية 1 في المضيف، فهذه مساحات أنشأها Docker لهذا الـ Container.
- أما `user` و`cgroup` فرقمهما هو نفس رقم المضيف، وفيهما 142 عملية هي كل عمليات الجهاز. وهذا يعني أن المستخدم root داخل الـ Container هو root المضيف نفسه من وجهة نظر النواة، وسوف نعود إلى خطورة ذلك في قسم حدود العزل.

![رسم يقارن بين رؤية العملية من المضيف حيث تظهر في شجرة واحدة تحت containerd-shim برقم 77653 وابنها sleep برقم 77689، ورؤيتها من الداخل حيث رقمها 1 واسم الجهاز web1، مع مساحات الأسماء الخاصة بها mnt وuts وipc وpid وnet وtime والمساحتين المشتركتين user وcgroup](https://arabroot.io/content/images/2026/11/containers-basics-01-process.webp)

نفس العملية برقمين: 1 من الداخل و77653 من المضيف

ولاحظ أن «المضيف» هنا هو الجهاز الافتراضي الخفيف الذي يشغله Docker Desktop على Windows، والعملية رقم 1 فيه اسمها `/initd`. أما على سيرفر Linux عادي فسوف تجد `systemd` في هذا المكان، كما شرحنا في مقال [الخدمات والسجلات مع systemd](https://arabroot.io/articles/%D8%A7%D9%84%D8%AE%D8%AF%D9%85%D8%A7%D8%AA-services-%D9%88%D8%A7%D9%84%D8%B3%D8%AC%D9%84%D8%A7%D8%AA-logs-%D9%85%D8%B9-systemd-%D9%88-journalctl/)، والفكرة نفسها لا تتغير.

## مساحات الأسماء Namespaces: ماذا ترى العملية؟

مساحة الأسماء Namespace طريقة تقول بها النواة للعملية: «هذا هو العالم الذي تراه»، فلكل نوع من الموارد التي لها أسماء في النظام (أرقام العمليات، أسماء الواجهات، نقاط التركيب، اسم الجهاز) قائمة خاصة بكل مساحة. وتشبيه ذلك مبنى مكاتب فيه شركات كثيرة، ولكل شركة دليل هاتف داخلي يبدأ بالرقم 100: الرقم 100 في الشركة الأولى ليس نفس الرقم 100 في الثانية، ولا يعرف أحدهما دليل الآخر، مع أن المبنى والكهرباء والمصاعد واحدة. والنواة هنا هي المبنى، وكل Container شركة بدليلها الخاص.

وفي Linux اليوم ثمانية أنواع، تصفها صفحة [namespaces(7)](https://man7.org/linux/man-pages/man7/namespaces.7.html?ref=arabroot.io)، والرسم التالي يجمعها مع الإصدار الذي أضافها وما أنشأه Docker منها للـ Container الذي فحصناه:

![ثماني بطاقات لأنواع مساحات الأسماء: mnt لنقاط التركيب منذ 2.4.19، وuts لاسم الجهاز وipc للذاكرة المشتركة منذ 2.6.19، وpid لأرقام العمليات منذ 2.6.24، وnet للشبكة، وtime للساعات منذ 5.6، وuser للمستخدمين منذ 3.8 ولا يستخدمها Docker افتراضياً، وcgroup منذ 4.6](https://arabroot.io/content/images/2026/11/containers-basics-02-namespaces.webp)

ستة أنواع أنشأها Docker للـ Container، ونوعان بقيا مشتركين مع المضيف

وفيما يلي ما يعنيه كل نوع في الحياة العملية:

- مساحة نقاط التركيب mnt: لكل Container قائمة Mounts خاصة، وأهمها الجذر `/` الذي يأتي من ال Image. وعندما تركب Volume داخل Container فهو يظهر في هذه القائمة وحدها، ولا يراه المضيف في `/proc/mounts` الخاص به.
- مساحة اسم الجهاز uts: لكل Container اسم جهاز Hostname خاص، ولذلك يظهر رقم ال Container الطويل كاسم جهاز إذا لم تحدد `--hostname`.
- مساحة ipc: الذاكرة المشتركة Shared Memory وطوابير الرسائل بين العمليات، وهي مهمة لقواعد البيانات مثل PostgreSQL التي تستخدم ذاكرة مشتركة بين عملياتها.
- مساحة pid: أرقام العمليات تبدأ من 1، وأول عملية تأخذ دور init داخل ال Container مع كل مسؤولياته، وهذه النقطة سبب مشاكل كثيرة في إيقاف ال Containers سوف نراها في مقال أوامر Docker.
- مساحة net: واجهات شبكة وعناوين IP وجداول توجيه وقواعد جدار ناري خاصة، وهذا ما يجعل كل Container يستطيع الاستماع على المنفذ 80 دون تعارض، وقد شرحنا ما يبنيه Docker فوقها في دليل [شبكات Docker وأفضل الممارسات](https://arabroot.io/articles/%D8%B4%D8%A8%D9%83%D8%A7%D8%AA-docker-%D9%88%D8%A3%D9%81%D8%B6%D9%84-%D8%A7%D9%84%D9%85%D9%85%D8%A7%D8%B1%D8%B3%D8%A7%D8%AA/).
- مساحة user: تربط أرقام المستخدمين في الداخل بأرقام أخرى في الخارج، فيكون root في الداخل مستخدماً عادياً بلا صلاحيات في الخارج. وDocker لا يستخدمها افتراضياً إلا إذا فعلت [userns-remap](https://docs.docker.com/engine/security/userns-remap/?ref=arabroot.io)، وهذا ما رأيناه في المخرج.
- مساحة cgroup: تخفي مسار مجموعة التحكم الحقيقي، فيرى ال Container مجموعته كأنها الجذر. ومع cgroup v1 يتركها Docker مشتركة، ومع cgroup v2 ينشئ واحدة خاصة.
- مساحة time: تسمح بإزاحة ساعتي `CLOCK_MONOTONIC` و`CLOCK_BOOTTIME`، وهي أحدثها، وتستخدم في نقل Container حي من جهاز إلى آخر دون أن يرى ساعته ترجع.

وقد يتساءل البعض: إذا كانت العملية لا ترى عمليات المضيف، فهل يرى المضيف عملياتها؟ والإجابة نعم، كما رأينا في المخرج السابق، لأن مساحات الأسماء متداخلة في اتجاه واحد: المساحة الأب ترى كل ما في المساحات الأبناء، والعكس غير صحيح. وهذا ما يسمح لك بمراقبة كل ال Containers من المضيف بأدوات عادية مثل `top` و`ps`، ويعني أيضاً أن من يملك root على المضيف يملك كل ال Containers.

## مجموعات التحكم cgroups: كم تأخذ العملية؟

مساحات الأسماء تحدد ما تراه العملية، ولكنها لا تمنعها من أخذ كل الذاكرة أو كل المعالج، فتطبيق فيه تسرب ذاكرة Memory Leak داخل Container يستطيع إسقاط السيرفر كله إذا لم يحده شيء. وهنا يأتي دور مجموعات التحكم Control Groups واختصاراً cgroups: شجرة من المجموعات، كل عملية تنتمي إلى مجموعة واحدة، ولكل مجموعة ملفات تكتب فيها الحدود وتقرأ منها الاستهلاك. والمتحكمات Controllers هي التي تطبق الحدود: `memory` للذاكرة، و`cpu` لوقت المعالج، و`pids` لعدد العمليات، و`io` للقرص، وغيرها.

وعندما تكتب `docker run -m 64m --cpus 0.5` فإن Docker ينشئ مجموعة لل Container ويكتب فيها هذه الأرقام. والطريقة الأسهل لترى ذلك أن تقرأ الملفات من داخل ال Container نفسه، وهذا ما فعلناه على Docker Desktop:

```bash
docker run --rm -m 64m --memory-swap 64m --cpus 0.5 alpine:3.24 sh -c '
  ls /sys/fs/cgroup
  cat /sys/fs/cgroup/memory.max
  cat /sys/fs/cgroup/memory/memory.limit_in_bytes
  cat /sys/fs/cgroup/cpu/cpu.cfs_quota_us /sys/fs/cgroup/cpu/cpu.cfs_period_us'
```

والمخرج سوف يكون كما يلي:

```text
blkio
cpu
cpuacct
cpuset
devices
freezer
hugetlb
memory
misc
net_cls
net_prio
perf_event
pids
rdma
systemd
cat: can't open '/sys/fs/cgroup/memory.max': No such file or directory
67108864
50000
100000
```

وهنا واجهنا أول مشكلة حقيقية في هذا المقال. كنا نتوقع أن نجد الملف `memory.max` لأنه اسم ملف حد الذاكرة في cgroup v2، وهو ما تجده على أي سيرفر حديث، ولكن Docker Desktop على جهازنا يعمل بنواة WSL2 من سلسلة 5.15 ما زالت تركب cgroup v1، والقائمة أعلاه تفضح ذلك: مجلد لكل متحكم (`memory` و`cpu` و`pids`...)، وملف الحد اسمه `memory.limit_in_bytes` وقيمته 67108864 أي 64 MiB بالضبط. وحد المعالج نصف معالج مكتوب بطريقة v1: 50000 ميكروثانية من كل 100000\. ويمكنك أن تعرف أي نسخة عندك بأمر واحد: `docker info --format '{{.CgroupVersion}}'`، وقد أعطانا هنا `1`.

والفرق بين النسختين ليس في أسماء الملفات فقط. ففي [cgroup v1](https://docs.kernel.org/admin-guide/cgroup-v1/cgroups.html?ref=arabroot.io) كل متحكم له شجرة مستقلة، فيمكن أن تكون العملية في مجموعة للذاكرة ومجموعة أخرى مختلفة للمعالج، وهذا جعل الإدارة معقدة وبعض الحالات غير منطقية، مثل حساب الكتابة على القرص التي تمر بالذاكرة. أما [cgroup v2](https://docs.kernel.org/admin-guide/cgroup-v2.html?ref=arabroot.io) فشجرة واحدة موحدة Unified Hierarchy، وكل مجموعة مجلد واحد فيه كل المتحكمات المفعلة، وفيه ملفات أحداث مثل `memory.events` تخبرك كم مرة وصلت المجموعة إلى حدها وكم عملية قتلت فيها. وأغلب التوزيعات الحديثة تستخدم v2 افتراضياً، منها Debian 11 وUbuntu 21.10 وما بعدهما، ولذلك فالمهم أن تعرف الاثنين: v1 لأنك سوف تجدها في أنظمة قديمة وفي بيئات مثل جهازنا، وv2 لأنها ما سوف تجده على السيرفر.

![مقارنة بين cgroup v1 على Docker Desktop حيث شجرة لكل متحكم وملف memory.limit_in_bytes بقيمة 67108864 وخطأ عدم وجود memory.max، وcgroup v2 في الجهاز الافتراضي حيث مجلد واحد ct1 فيه memory.max وcpu.max وpids.max وmemory.events، مع بطاقتين عن قتل OOM برمز 137 وتقييد المعالج دون قتل](https://arabroot.io/content/images/2026/11/containers-basics-03-cgroups.webp)

نفس الحدود بملفات مختلفة في cgroup v1 وcgroup v2

### ماذا يحدث عندما يتجاوز ال Container حد الذاكرة؟ OOM Kill

الحد على الورق لا يعني شيئاً حتى نراه يعمل، لذلك سوف نطلب ذاكرة أكثر من الحد. والأداة `dd` تحجز في الذاكرة مخزناً مؤقتاً Buffer بحجم الخيار `bs` ثم تملؤه، فإذا جعلناه 100 MB داخل حد 64 MB فهي تطلب أكثر مما يسمح لها:

```bash
docker run --name ct1-oom -m 64m --memory-swap 64m alpine:3.24 dd if=/dev/zero of=/dev/null bs=100M count=1
echo "exit=$?"
docker inspect ct1-oom --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}}'
docker run --rm -m 64m --memory-swap 64m alpine:3.24 dd if=/dev/zero of=/dev/null bs=40M count=1
```

والمخرج سوف يكون كما يلي:

```text
exit=137
OOMKilled=true ExitCode=137
1+0 records in
1+0 records out
41943040 bytes (40.0MB) copied, 0.060600 seconds, 660.1MB/s
```

لم تطبع `dd` أي رسالة في المحاولة الأولى، لأنها لم تجد فرصة: قتلتها النواة بالإشارة SIGKILL، ورمز الخروج 137 هو 128 مضافاً إليه رقم الإشارة 9، وهذا عرف في Linux تجده في كل مكان. وDocker يعرف السبب ويكتب `OOMKilled=true`، وأما المحاولة الثانية بحجم 40 MB فمرت دون مشكلة. وإذا أردت أن ترى القرار من جهة النواة فهو في سجلها، وهذا ما وجدناه بالأمر `dmesg` من Container بصلاحيات كاملة:

```text
[26054.751947] dd invoked oom-killer: gfp_mask=0xcc0(GFP_KERNEL), order=0, oom_score_adj=0
[26055.137947] memory: usage 65516kB, limit 65536kB, failcnt 0
[26055.205057] oom-kill:constraint=CONSTRAINT_MEMCG,...,oom_memcg=/docker/3b477e9bec8c...,task=dd,pid=85357,uid=0
[26055.223292] Memory cgroup out of memory: Killed process 85357 (dd) total-vm:104028kB, anon-rss:64848kB, file-rss:876kB, shmem-rss:0kB, UID:0 pgtables:180kB oom_score_adj:0
```

والكلمة المهمة هنا `CONSTRAINT_MEMCG`: القتل لم يحدث لأن الجهاز كله نفدت ذاكرته، فذاكرة الجهاز 31 GB، وإنما لأن مجموعة التحكم الخاصة بهذا ال Container وصلت إلى حدها، فاختارت النواة عملية من داخل المجموعة نفسها وقتلتها. وهذا هو المطلوب بالضبط: التطبيق المعطوب يموت وحده، وبقية السيرفر لا تشعر بشيء. ولاحظ أن الاستهلاك عند القتل كان 65516 KB من حد 65536 KB، أي أن النواة سمحت بالوصول إلى الحد تماماً ثم تحركت.

💡

إذا رأيت Container يتوقف برمز 137 فاسأل أولاً: هل `OOMKilled` تساوي `true`؟ إذا كانت كذلك فالحل زيادة الحد أو إصلاح استهلاك التطبيق، وإذا كانت `false` فهناك من أرسل SIGKILL، وغالباً هو `docker stop` بعد انتهاء مهلته، وهذا موضوع مقال أوامر Docker.

## مختبر cgroup v2: جهاز افتراضي صغير بنواة حديثة

بما أن Docker Desktop عندنا على cgroup v1، وأردنا أن نرى cgroup v2 كما سوف تراها على سيرفرك، احتجنا نواة حديثة نتحكم في إقلاعها. والطريقة الأخف التي وجدناها أن نشغل جهازاً افتراضياً صغيراً بـ QEMU مع KVM داخل Container، بنواة `vmlinuz-virt` من [Alpine 3.24](https://alpinelinux.org/downloads/?ref=arabroot.io) (Linux 6.18.60)، ونظام ملفات كامل محمل في الذاكرة Initramfs، دون قرص ولا شبكة. وقد شرحنا ما يفعله KVM داخل المعالج في مقال [دعم المعالج للأجهزة الافتراضية VT-x وAMD-V](https://arabroot.io/articles/%D8%AF%D8%B9%D9%85-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-%D9%84%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-%D8%A7%D9%84%D8%A7%D9%81%D8%AA%D8%B1%D8%A7%D8%B6%D9%8A%D8%A9-vt-x-%D9%88-amd-v-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)، أما هنا فهو مجرد وسيلة لتشغيل نواة أخرى. وهذا أمر الإقلاع كاملاً، وطريقة إقلاع نواة مباشرة دون قرص موصوفة في [توثيق QEMU](https://www.qemu.org/docs/master/system/linuxboot.html?ref=arabroot.io):

```bash
#!/bin/sh
# boots the lab VM: kernel + initramfs, serial console, KVM
LAB=${1:-hand-container.sh}
exec qemu-system-x86_64 -enable-kvm -cpu host -smp 2 -m 512 -nographic -no-reboot \
  -kernel /w/vmlinuz-virt -initrd /w/initrd.gz \
  -append "console=ttyS0 rdinit=/init quiet LAB=$LAB"
```

والملف `/init` داخل ال Initramfs هو أول ما تشغله النواة، وهو سكربت قصير يركب الأنظمة الأساسية ومنها cgroup v2، ثم يشغل المختبر ويطفئ الجهاز:

```bash
#!/bin/sh
# /init of the lab VM: mounts the basics, runs the lab, powers off
export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
mount -t proc proc /proc
mount -t sysfs sys /sys
mount -t devtmpfs dev /dev
mount -t cgroup2 cgroup2 /sys/fs/cgroup
mount -t tmpfs tmp /tmp
echo "init reached at uptime $(cut -d' ' -f1 /proc/uptime)s"
sh /lab/${LAB:-hand-container.sh} 2>&1
echo "lab done"
poweroff -f
```

وفي الإعداد أعلاه لاحظ التالي:

- السطر `export PATH` لم يكن في النسخة الأولى، والنتيجة كانت `unshare: failed to execute chroot: No such file or directory` مع أن `chroot` موجود. والسبب أن النواة تشغل `/init` ببيئة شبه فارغة، فلا يعرف `unshare` أين يبحث عن البرامج. وهذا درس صغير يتكرر في ال Containers: البرنامج الذي يبدأ كأول عملية لا يرث بيئة الطرفية التي تعرفها.
- السطر `mount -t cgroup2` يركب شجرة cgroup v2 الموحدة وحدها، وهذا ما يفعله systemd على أي توزيعة حديثة عند الإقلاع.
- الجهاز كله يعمل في الذاكرة ويطفئ نفسه، فيمكن تشغيله مرات كثيرة دون أن يترك شيئاً خلفه.

والسطور الأولى من مخرج المختبر تؤكد أننا في البيئة المطلوبة:

```text
init reached at uptime 1.19s
### 1. the machine
6.18.60-0-virt
cgroup2fs
cpuset cpu io memory hugetlb pids dmem
```

النواة 6.18، ونوع نظام الملفات في `/sys/fs/cgroup` هو `cgroup2fs`، والمتحكمات المتاحة مكتوبة في الملف `cgroup.controllers`. ولاحظ أن النواة وصلت إلى `/init` بعد 1.19 ثانية فقط من بدء الإقلاع، وفي تشغيلات أخرى بين 0.75 و2.3 ثانية بحسب انشغال الجهاز، لأنها نواة صغيرة بلا أقراص ولا خدمات، وسوف نعود إلى هذا الرقم في المقارنة مع ال Container.

## Container بأيدينا: unshare مع chroot مع cgroup v2

الآن نصل إلى أهم تجربة في المقال. سوف نصنع Container دون Docker، من ثلاثة أشياء: نظام ملفات Alpine المضغوط Minirootfs الذي ينشره المشروع بحجم 3.7 MB، ومجموعة تحكم cgroup نكتب حدودها بأيدينا، والأداة [unshare](https://man7.org/linux/man-pages/man1/unshare.1.html?ref=arabroot.io) التي تشغل برنامجاً في مساحات أسماء جديدة. وأول خطوة فك نظام الملفات وإنشاء المجموعة:

```bash
mkdir -p /ct1/rootfs
tar -xzf /lab/alpine-minirootfs-3.24.4-x86_64.tar.gz -C /ct1/rootfs
echo "+memory +cpu +pids" > /sys/fs/cgroup/cgroup.subtree_control
mkdir /sys/fs/cgroup/ct1
echo 32M > /sys/fs/cgroup/ct1/memory.max
echo "20000 100000" > /sys/fs/cgroup/ct1/cpu.max
echo 64 > /sys/fs/cgroup/ct1/pids.max
```

والمخرج سوف يكون كما يلي:

```text
bin  etc   lib	  mnt  proc  run   srv	tmp  var
dev  home  media  opt  root  sbin  sys	usr
8.3M	/ct1/rootfs
0
memory.max = 33554432
cpu.max = 20000 100000
pids.max = 64
```

في المخرج والأوامر أعلاه لاحظ التالي:

- نظام ملفات Alpine كاملاً 8.3 MB بعد فكه، وفيه كل مجلدات Linux المعروفة، وهذا هو ما يوجد داخل ال Image الرسمية `alpine:3.24` تقريباً كما سوف نرى.
- الرقم 0 هو عدد الملفات في `/ct1/rootfs/dev`: المجلد فارغ تماماً، ولم ننتبه لذلك في المحاولة الأولى، وسوف نرى ماذا كلفنا.
- في cgroup v2 لا تعمل المتحكمات في مجموعة فرعية حتى تفعلها في أبيها بالملف `cgroup.subtree_control`، وهذا ما يفعله السطر الذي يكتب `+memory +cpu +pids`.
- كتبنا الحد `32M` فحولته النواة إلى 33554432 بايت، وحد المعالج يعني 20000 ميكروثانية في كل فترة طولها 100000، أي 20% من معالج واحد، وحد العمليات 64 يمنع ما يسمى قنبلة التفرع Fork Bomb من إسقاط الجهاز.

ثم السكربت الذي يشغل أي أمر «كـ Container»، وهو قلب المختبر كله:

```bash
#!/bin/sh
# start.sh: runs "$@" as a container: own cgroup, own namespaces, own root filesystem
ROOT=/ct1/rootfs
echo $$ > /sys/fs/cgroup/ct1/cgroup.procs            # 1. join the cgroup; children inherit it
exec unshare --pid --fork --mount --uts --ipc --net \
  sh -c '                                            # 2. new namespaces; this sh is already inside them
    mount -t tmpfs -o mode=755 dev "$0/dev"         # 3. a private /dev with only what a program needs
    mknod -m 666 "$0/dev/null" c 1 3
    mknod -m 666 "$0/dev/zero" c 1 5
    mknod -m 666 "$0/dev/urandom" c 1 9
    exec chroot "$0" /bin/sh -c "mount -t proc proc /proc; hostname ct1-box; exec \"\$@\"" sh "$@"
  ' "$ROOT" "$@"                                     # 4. chroot, mount /proc, set the hostname, run the program
```

وفي السكربت أعلاه لاحظ التالي:

- الخطوة الأولى تكتب رقم السكربت نفسه في `cgroup.procs`، فينتقل إلى المجموعة `ct1`، وكل عملية يشغلها بعد ذلك ترث المجموعة تلقائياً، ولذلك يأتي هذا السطر قبل كل شيء.
- الخيار `--fork` ضروري مع `--pid`، لأن مساحة أرقام العمليات الجديدة لا تنطبق على العملية التي طلبتها وإنما على أبنائها، كما تشرح صفحة [pid\_namespaces(7)](https://man7.org/linux/man-pages/man7/pid%5Fnamespaces.7.html?ref=arabroot.io)، فيتفرع `unshare` ليصبح ابنه هو العملية رقم 1.
- بعد `--mount` صار لنا جدول Mounts خاص، فنركب `/dev` صغيراً داخل نظام الملفات الجديد فيه أربعة أجهزة فقط، ولا يظهر هذا التركيب في الجهاز الأصلي.
- `chroot` يجعل `/ct1/rootfs` هو الجذر، ثم نركب `/proc` جديداً حتى يعرض الأمر `ps` عمليات مساحتنا فقط، ونعطي الجهاز اسماً، ثم `exec` يستبدل الـ Shell بالبرنامج المطلوب فيصبح هو العملية رقم 1.

والرسم التالي يلخص الخطوات بالترتيب، وكل واحدة تضيف عزلاً لا تضيفه التي قبلها:

![خمس خطوات من اليمين إلى اليسار: الانضمام إلى cgroup بكتابة الرقم في cgroup.procs، ثم unshare بخمس مساحات أسماء جديدة، ثم /dev خاص من tmpfs وmknod، ثم chroot إلى نظام ملفات Alpine، ثم exec بعد تركيب proc وتغيير hostname، والنتيجة hostname ct1-box وPID 1 وواجهة lo فقط ومجموعة /ct1](https://arabroot.io/content/images/2026/11/containers-basics-04-by-hand.webp)

ما يفعله Docker في كل docker run، مكتوباً بخمس خطوات

والآن نشغل Shell كـ Container ونسأله عن عالمه:

```bash
sh /lab/start.sh sh -c '
  echo "hostname: $(hostname)"
  echo "--- ps:"; ps
  echo "--- ip link:"; ip link
  echo "--- os-release:"; grep PRETTY /etc/os-release
  echo "--- my cgroup:"; cat /proc/self/cgroup
  echo "--- /dev:"; ls /dev
'
echo "VM hostname is still: $(hostname)"
```

والمخرج سوف يكون كما يلي:

```text
hostname: ct1-box
--- ps:
PID   USER     TIME  COMMAND
    1 root      0:00 sh -c    echo "hostname: $(hostname)"   echo "--- ps:"; ps
    9 root      0:00 ps
--- ip link:
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
--- os-release:
PRETTY_NAME="Alpine Linux v3.24"
--- my cgroup:
0::/ct1
--- /dev:
null     urandom  zero
VM hostname is still: (none)
```

وبهذا الشكل نكون قد صنعنا Container حقيقياً بأوامر Linux فقط، وفي المخرج أعلاه لاحظ التالي:

- اسم الجهاز داخله `ct1-box`، أما الجهاز الافتراضي فبقي باسمه الفارغ `(none)`، فتغيير الاسم لم يخرج من مساحة uts الجديدة.
- `ps` لا يرى غير عمليتين: الـ Shell برقم 1 و`ps` نفسه، مع أن الجهاز الافتراضي فيه أكثر من 60 عملية.
- الشبكة فيها واجهة `lo` واحدة وهي مطفأة `DOWN`، فهذا Container بلا أي شبكة. وما يضيفه Docker هنا زوج من الواجهات الافتراضية veth، طرف داخل ال Container وطرف على جسر Bridge في المضيف، وهو ما شرحناه في دليل شبكات Docker.
- النظام يرى نفسه Alpine 3.24، مع أن النواة تحته هي نواة الجهاز الافتراضي، وهذه هي الفكرة كلها: نظام الملفات من توزيعة، والنواة من المضيف.
- السطر `0::/ct1` يقول إن العملية في المجموعة `ct1`، والصيغة `0::` خاصة بـ cgroup v2 (شجرة واحدة رقمها 0)، بينما رأينا في v1 سطراً لكل متحكم.

### نفس ال Container من الجهاز الافتراضي

كما فعلنا مع Docker، نشغل أمراً طويلاً في Container ثم ننظر إليه من الخارج:

```bash
sh /lab/start.sh sleep 30 &
sleep 1
C=$(pgrep -f "^sleep 30$" | head -1)
echo "sleep runs as PID $C on the VM"
grep NSpid /proc/$C/status
lsns -p $C
cat /sys/fs/cgroup/ct1/cgroup.procs
```

والمخرج سوف يكون كما يلي:

```text
sleep runs as PID 484 on the VM
NSpid:	484	1
        NS TYPE   NPROCS PID USER COMMAND
4026531834 time       68   1 root /bin/sh /init
4026531835 cgroup     68   1 root /bin/sh /init
4026531837 user       68   1 root /bin/sh /init
4026532115 mnt         2 482 root unshare --pid --fork --mount --uts --ipc --net
4026532116 uts         2 482 root unshare --pid --fork --mount --uts --ipc --net
4026532117 ipc         2 482 root unshare --pid --fork --mount --uts --ipc --net
4026532118 pid         1 484 root └─sleep 30
4026532119 net         2 482 root unshare --pid --fork --mount --uts --ipc --net
482
484
```

الصورة نفسها التي رأيناها مع Docker: العملية رقمها 484 في الجهاز و1 في داخل ال Container، وخمس مساحات أسماء جديدة. ولاحظ تفصيلاً صغيراً يشرح الخيار `--fork`: مساحات `mnt` و`uts` و`ipc` و`net` فيها عمليتان هما `unshare` (482) وابنه، أما مساحة `pid` ففيها عملية واحدة فقط هي `sleep`، لأن `unshare` نفسه بقي في مساحة أرقام المضيف وابنه وحده دخل المساحة الجديدة. والعمليتان معاً في الملف `cgroup.procs`، فالحدود تنطبق على الاثنين.

### حد الذاكرة memory.max في التطبيق

نكرر تجربة `dd`، ولكن هنا بحد 32 MB كتبناه بأيدينا:

```bash
sh /lab/start.sh dd if=/dev/zero of=/dev/null bs=64M count=1
echo "exit code: $?"
cat /sys/fs/cgroup/ct1/memory.events
dmesg | grep -E "Memory cgroup out of memory|oom-kill:" | tail -2
sh /lab/start.sh dd if=/dev/zero of=/dev/null bs=16M count=1
```

والمخرج سوف يكون كما يلي:

```text
Killed
exit code: 137
low 0
high 0
max 71
oom 2
oom_kill 1
oom_group_kill 0
[    4.016210] oom-kill:constraint=CONSTRAINT_MEMCG,nodemask=(null),cpuset=/,mems_allowed=0,oom_memcg=/ct1,task_memcg=/ct1,task=dd,pid=499,uid=0
[    4.016226] Memory cgroup out of memory: Killed process 499 (dd) total-vm:67172kB, anon-rss:31872kB, file-rss:0kB, shmem-rss:784kB, UID:0 pgtables:108kB oom_score_adj:0
1+0 records in
1+0 records out
16777216 bytes (16.0MB) copied, 0.091584 seconds, 174.7MB/s
```

وهنا نرى ما يضيفه cgroup v2\. السطر `Killed` كتبه الـ Shell عندما مات ابنه بالإشارة 9، والرمز 137 هو نفس الرمز الذي أعطاه Docker. أما الملف `memory.events` فهو عداد لا تجده في v1 بهذا الوضوح: `max 71` تعني أن المجموعة اصطدمت بحدها 71 مرة واستطاعت النواة في أغلبها أن تستعيد ذاكرة من ذاكرة الملفات المؤقتة Page Cache دون قتل أحد، و`oom 2` مرتان لم تجد فيهما ما تستعيده، و`oom_kill 1` عملية واحدة قتلت. وهذا الملف هو ما تقرؤه أدوات المراقبة لتنبهك قبل أن يصبح القتل عادة يومية. وسطر `dmesg` يذكر `oom_memcg=/ct1`، أي أن السبب مجموعتنا بالاسم.

### حد المعالج cpu.max: لا قتل وإنما انتظار

المعالج مورد يختلف عن الذاكرة، فالبرنامج الذي يتجاوز حصته لا يقتل، وإنما يوقف حتى تبدأ الفترة التالية، وهذا ما يسمى الخنق Throttling. ولنرى ذلك نشغل حلقة لا تفعل شيئاً سوى استهلاك المعالج لمدة 5 ثوان:

```bash
grep -E "usage_usec|nr_periods|nr_throttled|throttled_usec" /sys/fs/cgroup/ct1/cpu.stat
sh /lab/start.sh sh -c 'timeout 5 sh -c "while :; do :; done"; echo "loop ended with $?"'
grep -E "usage_usec|nr_periods|nr_throttled|throttled_usec" /sys/fs/cgroup/ct1/cpu.stat
```

والمخرج سوف يكون كما يلي:

```text
usage_usec 342578
nr_periods 21
nr_throttled 14
throttled_usec 870411
Terminated
loop ended with 143
usage_usec 1409033
nr_periods 75
nr_throttled 67
throttled_usec 4881317
```

الفرق بين القراءتين هو ما استهلكته الحلقة: `usage_usec` زاد بمقدار 1,066,455 ميكروثانية، أي 1.07 ثانية من المعالج خلال 5 ثوان من الوقت الحقيقي، وهذا 21% تقريباً، قريب جداً من الحد 20%. و`nr_periods` زاد 54 فترة خنقت النواة الحلقة في 53 منها، أي أن الحلقة استهلكت حصتها في كل فترة تقريباً ثم انتظرت. وانتهت الحلقة بالرمز 143، أي 128 مضافاً إليه 15 وهو رقم SIGTERM الذي أرسله `timeout`.

وماذا يحدث إذا شغلنا نفس الحلقة في مجموعة ليس فيها `cpu.max`؟ فعلنا ذلك في مجموعة ثانية اسمها `ct1-free`:

```text
max 100000
usage_usec 4162645
nr_throttled 0
```

القيمة `max` تعني «بلا حد»، والحلقة أخذت 4.16 ثانية من 5، ولم تخنق مرة واحدة. ولماذا لم تأخذ 5 ثوان كاملة؟ لأن الجهاز الذي نجرب عليه كان مشغولاً بأعمال أخرى، ومتوسط الضغط Load Average على المضيف كان بين 14 و16 على 8 معالجات، فالمعالج الافتراضي نفسه لم يحصل على معالج حقيقي كامل طوال الوقت. وهذا درس مهم: غياب الحد لا يعني أن التطبيق يأخذ ما يريد، وإنما يعني أنه ينافس كل شيء آخر على الجهاز، ولذلك يستخدم البعض `cpu.weight` (الخيار `--cpu-shares` في Docker) لتحديد الأولوية بدلاً من حد ثابت.

### مشكلتان واجهتنا في Container اليد

لم يعمل المختبر من أول مرة، والمشكلتان التاليتان تشرحان شيئاً يفعله Docker عنك دون أن تنتبه.

المشكلة الأولى كانت في نسخة من `start.sh` لم تكن تركب `/dev`، فأعطت تجربة الذاكرة هذا المخرج بدلاً من القتل:

```text
dd: can't open '/dev/zero': No such file or directory
exit code: 1
```

نظام ملفات Alpine المضغوط يأتي بمجلد `/dev` فارغ، لأن الأجهزة ليست ملفات عادية تحفظ في أرشيف، وإنما يصنعها من يشغل النظام. وDocker يفعل ذلك في كل Container: يركب `/dev` من نوع tmpfs ويضع فيه الأجهزة الآمنة فقط (`null` و`zero` و`random` و`urandom` و`tty` وغيرها)، ويمنع ال Container من صنع غيرها، وهذه القائمة جزء من [مواصفة تشغيل OCI](https://github.com/opencontainers/runtime-spec?ref=arabroot.io).

والمشكلة الثانية أطرف، فقد كتبنا تجربة المعالج أولاً هكذا: `sh /lab/start.sh timeout 5 sh -c 'while :; do :; done'`، وانتظرنا 5 ثوان، ثم دقيقة، ثم دقيقتين، والجهاز لا يكمل، حتى أوقفناه من الخارج. والسبب أن `timeout` في BusyBox يتفرع فيبقى الأب ينفذ الأمر بينما الابن يراقب ويرسل SIGTERM، فصارت الحلقة نفسها هي العملية رقم 1 في مساحة الأسماء الجديدة، والنواة لا توصل للعملية رقم 1 أي إشارة لم تكتب لها معالجاً Handler، فتجاهلت الحلقة SIGTERM إلى الأبد. والحل كان أن نجعل الـ Shell هو العملية رقم 1 والحلقة ابناً له، كما في الأمر الذي رأيته أعلاه. وهذه المشكلة نفسها هي سبب أن `docker stop` ينتظر عشر ثوان مع بعض التطبيقات ثم يقتلها برمز 137، وسوف نشرحها بالتفصيل مع حلها `--init` في مقال أوامر Docker.

### لماذا لا يستخدم Docker الأمر chroot؟

استخدمنا `chroot` لأنه أبسط ما يشرح الفكرة، ولكن Docker ومعه كل أدوات OCI يستخدم استدعاء النظام [pivot\_root](https://man7.org/linux/man-pages/man2/pivot%5Froot.2.html?ref=arabroot.io). والفرق أن `chroot` يغير الجذر الذي تراه العملية فقط، ويبقى الجذر القديم مركباً في جدول ال Mounts، والعملية التي تملك صلاحية `CAP_SYS_CHROOT` تستطيع الخروج منه بحيل معروفة موثقة في صفحة `chroot(2)` نفسها. أما `pivot_root` فيبدل الجذر داخل مساحة نقاط التركيب، ثم يفصل runc الجذر القديم نهائياً، فلا يبقى طريق إليه. والتشبيه هنا: `chroot` يغلق باب الغرفة ويترك المفتاح في القفل، و`pivot_root` يغلقه ويزيل الباب من المخطط. لذلك لا تستخدم `chroot` كأداة عزل أمني، وإنما كأداة لإصلاح نظام أو بناء حزم.

## ال Image وال Container: القالب والنسخة الحية

الآن وقد عرفنا ما يحدث للعملية، بقي سؤال: من أين جاء نظام الملفات؟ في المختبر فككنا أرشيفاً بأيدينا، أما Docker فيأخذه من ال Image. وال Image قالب للقراءة فقط Read-only: مجموعة طبقات Layers من الملفات مع ملف إعداد يقول ما الأمر الذي يعمل افتراضياً وما متغيرات البيئة. وال Container نسخة حية من هذا القالب، تضيف فوقه طبقة واحدة قابلة للكتابة، وعملية تعمل، ومساحات أسماء ومجموعة تحكم. وتشبيه ذلك الكلاس والكائن Object في البرمجة: كلاس واحد تصنع منه كائنات كثيرة، لكل كائن حالته، والكلاس نفسه لا يتغير.

ولنرى الطبقات فعلاً بنينا Image صغيرة من ثلاثة أسطر، تضيف ملفاً ثم تحذف ملفاً موجوداً في Alpine:

```bash
FROM alpine:3.24
RUN echo "version 1" > /app.txt
RUN rm /etc/motd
```

ثم سألنا Docker عن طبقات ال Image الأصلية وطبقات Image الجديدة وتاريخها:

```bash
docker build -t ct1-layers:1 -f Dockerfile.layers .
docker image inspect alpine:3.24 --format '{{.Id}} {{json .RepoDigests}} {{range .RootFS.Layers}}{{.}} {{end}}'
docker image inspect ct1-layers:1 --format '{{range .RootFS.Layers}}{{.}} {{end}}'
docker history ct1-layers:1
```

والمخرج سوف يكون كما يلي (قسمنا الأسطر الطويلة):

```text
sha256:f59abe656b692d901e184be3445e084786602108599d2a51d229c0f5a48c71bf
["alpine@sha256:f59abe656b692d901e184be3445e084786602108599d2a51d229c0f5a48c71bf"]
sha256:75f1d9657d880da5f75298e8f40e9928bb6e260c50d26f97af196845307e3064

sha256:75f1d9657d880da5f75298e8f40e9928bb6e260c50d26f97af196845307e3064
sha256:d0863ae10734ef56f1a87b3140a5a3db8ae6218075eeab9e412c429bdcb4aef4
sha256:7caa7391b08e0a766fe20dbc0077d54cc23f82304dc047b1081d2ee0020c8aa3

CREATED BY                                                SIZE
RUN /bin/sh -c rm /etc/motd # buildkit                    8.19kB
RUN /bin/sh -c echo "version 1" > /app.txt # buildkit     8.19kB
CMD ["/bin/sh"]                                           0B
ADD alpine-minirootfs-3.24.4-x86_64.tar.gz / # buildkit   9.09MB
```

في المخرج أعلاه لاحظ التالي:

- ال Image الرسمية `alpine:3.24` فيها طبقة واحدة فقط، صنعها السطر `ADD alpine-minirootfs-3.24.4-x86_64.tar.gz`، أي نفس الأرشيف الذي فككناه بأيدينا في الجهاز الافتراضي. فلا يوجد سحر هنا: Image التوزيعة أرشيف نظام ملفاتها.
- ال Image الجديدة فيها ثلاث طبقات: نفس طبقة Alpine بنفس الهاش `75f1d965…`، ثم طبقة لكل سطر `RUN`. ولأن الهاش واحد فطبقة Alpine موجودة على القرص مرة واحدة مهما بنيت عليها من Images.
- السطر `CMD` لم يصنع طبقة، لأنه لا يغير أي ملف، وإنما يغير ملف الإعداد فقط، وحجمه 0B.
- حتى سطر الحذف صنع طبقة، وهذه نقطة يقع فيها كثيرون: حذف ملف في طبقة لاحقة لا يقلل حجم ال Image، لأن الملف ما زال في الطبقة التي أضافته، وكل ما تفعله الطبقة الجديدة أنها تخفيه. وهذا سبب أن ملف أسرار تضيفه ثم تحذفه في Dockerfile يبقى داخل ال Image لمن يفتح طبقاتها، وهو موضوع مقال كتابة Dockerfile صحيح.

### ماذا يحدث على القرص؟ طبقات OverlayFS

الآن نشغل Container من ال Image الجديدة، ونغير فيه ثلاثة أشياء: نعدل ملفاً من ال Image، ونضيف ملفاً جديداً، ونحذف ملفاً من Alpine، ثم نسأل Docker عن الفرق:

```bash
docker run -d --name ct1-ovl ct1-layers:1 sleep 3600
docker exec ct1-ovl sh -c 'echo hello > /data.txt; rm /etc/issue; echo "version 2" > /app.txt'
docker diff ct1-ovl
```

والمخرج سوف يكون كما يلي:

```text
C /app.txt
C /etc
D /etc/issue
A /data.txt
```

الأمر [docker diff](https://docs.docker.com/reference/cli/docker/container/diff/?ref=arabroot.io) يقرأ الطبقة القابلة للكتابة ويعرض ما فيها: `A` ملف أضيف، و`C` ملف أو مجلد تغير، و`D` ملف حذف. ولكن أين هذه الطبقة؟ لنبحث عنها من المضيف في جدول نقاط التركيب الخاص بالعملية، وهو الملف `/proc/<pid>/mountinfo`:

```bash
P=$(docker inspect -f '{{.State.Pid}}' ct1-ovl)
docker run --rm --privileged --pid=host ct1-tools:1 sh -c "awk '\$5==\"/\"' /proc/$P/mountinfo | tr ',' '\n'"
```

والمخرج سوف يكون كما يلي (اختصرنا المسار الطويل `/var/lib/desktop-containerd/daemon/io.containerd.snapshotter.v1.overlayfs/snapshots` إلى `S`):

```text
1114 564 0:111 / / rw
relatime - overlay overlay rw
lowerdir=S/88479/fs:S/88478/fs:S/88477/fs:S/79343/fs
upperdir=S/88480/fs
workdir=S/88480/work
```

جذر ال Container نظام ملفات من نوع `overlay`، أي [OverlayFS](https://docs.kernel.org/filesystems/overlayfs.html?ref=arabroot.io) في النواة، وهو يجمع عدة مجلدات فوق بعضها ويعرضها كمجلد واحد. والمجلدات السفلى `lowerdir` للقراءة فقط، والعليا `upperdir` تستقبل كل كتابة. ولنرى ما في كل مجلد دخلنا إلى مساحة الأسماء الخاصة بـ containerd حيث توجد هذه المسارات:

```text
=== snapshot 79343
./srv ./run ./var ./var/log ...            count: 516
=== snapshot 88477
./app.txt                                  count: 2
=== snapshot 88478
./etc ./etc/motd                           count: 3
=== snapshot 88479
./etc/resolv.conf ./etc/mtab ./etc/hosts ./etc/hostname ./dev/pts ./dev/shm ./dev/console ./.dockerenv
=== snapshot 88480
./app.txt ./etc ./etc/issue ./data.txt     count: 5

S/88478/fs/etc/:
c--------- 1 root root 0, 0 Nov 18 15:34 motd
S/88480/fs/etc/:
c--------- 2 root root 0, 0 Nov 18 15:34 issue

8.7M	S/79343/fs
16K	S/88480/fs
```

وهذه هي الصورة الكاملة لنظام ملفات ال Container، والرسم التالي يرتبها من الأسفل إلى الأعلى:

![خمس طبقات فوق بعضها: 79343 وهي alpine بحجم 8.7 ميغابايت، ثم 88477 وفيها app.txt بالنسخة الأولى، ثم 88478 وفيها ملف حذف لـ motd، ثم 88479 طبقة init من Docker فيها hosts وresolv.conf، ثم 88480 الطبقة القابلة للكتابة فيها app.txt بالنسخة الثانية وdata.txt وملف حذف لـ issue، وفي الأسفل ما يراه البرنامج: version 2 وعدم وجود issue وmotd](https://arabroot.io/content/images/2026/11/containers-basics-05-overlay.webp)

كل كتابة تذهب إلى الطبقة العليا، والطبقات السفلى لا تتغير أبداً

في المخرج والرسم أعلاه لاحظ التالي:

- الطبقة 79343 فيها 516 ملفاً ومجلداً بحجم 8.7 MB، وهي Alpine كاملة. أما الطبقة القابلة للكتابة 88480 فحجمها 16 KB فقط، وفيها ما غيرناه وحده. وهذا سبب أن ال Container يبدأ في جزء من الثانية: لا ينسخ Docker أي شيء من ال Image، وإنما ينشئ مجلداً فارغاً ويركبه فوق الطبقات الموجودة.
- الملف المحذوف لا يحذف من الطبقة السفلى، لأنها للقراءة فقط، وإنما تكتب النواة في الطبقة العليا ملفاً خاصاً بنفس الاسم من نوع جهاز حرفي رقمه `0, 0` اسمه Whiteout، ومعناه «اعتبر هذا الملف غير موجود». ونفس الطريقة استخدمها سطر `RUN rm /etc/motd` في الطبقة 88478.
- تعديل `/app.txt` نسخ الملف كاملاً إلى الطبقة العليا ثم عدله، وهذا ما يسمى النسخ عند الكتابة Copy-up. ومع ملف صغير لا يهم، ولكن تعديل بايت واحد في ملف كبير بحجم 2 GB داخل Container ينسخ الملف كله أولاً، ولذلك لا تضع قواعد البيانات ولا الملفات التي تتغير كثيراً في الطبقة القابلة للكتابة، وإنما في Volume، وهذا موضوع مقال بيانات ال Containers.
- الطبقة 88479 ليست من ال Image ولا من ال Container، وإنما طبقة صغيرة يضيفها Docker لكل Container فيها ملفات مثل `/etc/hosts` و`/etc/resolv.conf` الفارغة التي يركب فوقها الملفات الحقيقية.

وماذا لو شغلنا Container ثانياً من نفس ال Image؟ فعلنا ذلك باسم `ct1-ovl2`، فكانت طبقاته كما يلي:

```text
version 1
lowerdir=S/88488/fs:S/88478/fs:S/88477/fs:S/79343/fs
upperdir=S/88489/fs
```

ال Container الثاني يرى `version 1` لأن تعديل الأول بقي في طبقته العليا ولم يلمس ال Image، وهو يستخدم نفس الطبقات السفلى 79343 و88477 و88478 بالضبط، وله طبقة init وطبقة عليا خاصتان. فلو شغلت مئة Container من نفس ال Image فطبقاتها على القرص مرة واحدة، وفي ذاكرة الملفات المؤقتة مرة واحدة أيضاً. وتفاصيل ذلك في [توثيق Docker عن طريقة التخزين](https://docs.docker.com/engine/storage/drivers/?ref=arabroot.io)، والمسار الذي رأيته يخص [مخزن containerd](https://docs.docker.com/engine/storage/containerd/?ref=arabroot.io) الذي صار افتراضياً في الإصدارات الحديثة من Docker.

## السجل Registry وال Tag وال Digest

بقي أن نعرف كيف وصلت ال Image إلى جهازك. ال Images تحفظ في سجل Registry مثل [Docker Hub](https://hub.docker.com/%5F/alpine?ref=arabroot.io)، وعندما تكتب `alpine:3.24` فالجزء `3.24` هو ال Tag، وهو اسم يشير إلى محتوى، ويستطيع ناشر ال Image أن ينقله إلى محتوى آخر متى شاء. وهذا ما يحدث فعلاً مع `alpine:3.24`، فكلما صدر إصدار تصحيحي مثل 3.24.5 سوف يشير ال Tag إليه. والطريقة الوحيدة لتشير إلى محتوى لا يتغير هي ال Digest، وهو هاش SHA-256 للمحتوى نفسه. ولنرى ما يقف خلف ال Tag:

```bash
docker pull alpine:3.24
docker buildx imagetools inspect alpine:3.24
```

والمخرج سوف يكون كما يلي (اختصرنا قائمة المنصات):

```text
3.24: Pulling from library/alpine
Digest: sha256:f59abe656b692d901e184be3445e084786602108599d2a51d229c0f5a48c71bf
Status: Image is up to date for alpine:3.24

Name:      docker.io/library/alpine:3.24
MediaType: application/vnd.oci.image.index.v1+json
Digest:    sha256:f59abe656b692d901e184be3445e084786602108599d2a51d229c0f5a48c71bf
Manifests:
  Name:        docker.io/library/alpine:3.24@sha256:0f49f331d9212aff11b932863be4eb01cdf962969aa86dab7d1ee21ac6f5f52b
  MediaType:   application/vnd.oci.image.manifest.v1+json
  Platform:    linux/amd64
    org.opencontainers.image.version:         3.24.4
  Name:        docker.io/library/alpine:3.24@sha256:7d08e6cd44b4e0c144e32a527544890794b73795ad1e8d60bfd8578e3eccf79d
  Platform:    unknown/unknown
    vnd.docker.reference.type:                attestation-manifest
  ...
      1   Platform:    linux/386
      1   Platform:    linux/amd64
      1   Platform:    linux/arm/v6
      1   Platform:    linux/arm/v7
      1   Platform:    linux/arm64/v8
      1   Platform:    linux/ppc64le
      1   Platform:    linux/riscv64
      1   Platform:    linux/s390x
      8   Platform:    unknown/unknown
```

ال Digest الذي طبعه `docker pull` ليس هاش Image واحدة، وإنما هاش قائمة اسمها [Image Index](https://github.com/opencontainers/image-spec/blob/main/image-index.md?ref=arabroot.io)، فيها 16 عنصراً: Image لكل منصة من ثماني منصات (Intel وAMD بنوعيهما، وARM بثلاثة أنواع، وPowerPC وRISC-V وIBM Z)، وثماني شهادات Attestations تصف كيف بنيت كل واحدة. وعندما تسحب ال Image يختار Docker العنصر الذي يطابق معالجك، ولذلك يعمل نفس الأمر على حاسوب Intel وعلى Raspberry Pi. ثم فتحنا Manifest المنصة `linux/amd64`:

```bash
docker buildx imagetools inspect alpine:3.24@sha256:0f49f331d9212aff11b932863be4eb01cdf962969aa86dab7d1ee21ac6f5f52b --raw
```

والمخرج سوف يكون كما يلي (حذفنا بعض الحقول):

```json
{
  "schemaVersion": 2,
  "mediaType": "application/vnd.oci.image.manifest.v1+json",
  "config": {
    "mediaType": "application/vnd.oci.image.config.v1+json",
    "digest": "sha256:3ea06e4cb95e726ea6c6cc4377570ac4c4050d78710004cbd631ca809daf7e8e",
    "size": 611
  },
  "layers": [
    {
      "mediaType": "application/vnd.oci.image.layer.v1.tar+gzip",
      "digest": "sha256:881fc932939efef04ca120ad44bbd2c0917851eb247aa4995428afb1e80ede17",
      "size": 3853673
    }
  ],
  "annotations": {
    "org.opencontainers.image.created": "2026-11-05T18:00:01Z",
    "org.opencontainers.image.version": "3.24.4"
  }
}
```

وهذا هو ال [Manifest](https://github.com/opencontainers/image-spec/blob/main/manifest.md?ref=arabroot.io) كما تحدده مواصفة OCI: ملف [Config](https://github.com/opencontainers/image-spec/blob/main/config.md?ref=arabroot.io) صغير بحجم 611 بايت، وطبقة واحدة مضغوطة بـ gzip حجمها 3,853,673 بايت. ولاحظ أن هاش الطبقة هنا `881fc932…`، بينما رأينا في `docker image inspect` هاشاً آخر هو `75f1d965…`. والسبب أن السجل يحفظ الطبقة مضغوطة ويسميها بهاش الملف المضغوط، أما Docker فيحفظ في ال Config هاش الطبقة بعد فك الضغط واسمه `diff_id`، لأن نفس المحتوى قد يضغط بطرق مختلفة. وكل مستوى يحمل هاش المستوى الذي تحته، فإذا تغير بايت واحد في الطبقة تغير هاشها، فتغير ال Manifest، فتغير ال Index، وهذا ما يجعل ال Digest ضماناً حقيقياً للمحتوى.

![سلسلة من ال Tag alpine:3.24 الذي يشير إلى Image Index بهاش f59abe65 فيه ستة عشر عنصراً لثماني منصات، يختار منها Docker Manifest المنصة linux/amd64 بهاش 0f49f331، وهو يشير إلى Config بهاش 3ea06e4c وطبقة مضغوطة بهاش 881fc932 وdiff_id بعد فك الضغط 75f1d965](https://arabroot.io/content/images/2026/11/containers-basics-06-digest.webp)

ال Tag اسم متحرك، وال Digest هاش لا يتغير ما دام المحتوى لم يتغير

والقاعدة العملية من كل هذا: في الإنتاج لا تستخدم `latest`، والسبب أنه Tag ينتقل مع كل إصدار فلا تعرف ماذا سوف يعمل عند إعادة التشغيل القادمة. واستخدم Tag بإصدار محدد مثل `postgres:18.1-alpine`، وإذا أردت ضماناً كاملاً بأن ما اختبرته هو ما يعمل فأضف ال Digest: `alpine:3.24@sha256:f59abe65…`. والثمن أنك لن تحصل على التحديثات الأمنية حتى تغير ال Digest بنفسك، ولذلك تحتاج أداة تتابع ذلك، وقد قارنا بين الأدوات في دليل [تحديث ال Containers بأمان](https://arabroot.io/articles/%D8%AA%D8%AD%D8%AF%D9%8A%D8%AB-%D8%A7%D9%84-containers-%D8%A8%D8%A7%D9%85%D8%A7%D9%86-watchtower-%D8%A7%D9%85-diun-%D8%A7%D9%85-renovate/).

## الجهاز الافتراضي VM مقابل ال Container

الآن نستطيع أن نجيب عن سؤال البداية بدقة. الجهاز الافتراضي يحاكي عتاداً كاملاً، ويقلع عليه نواة خاصة به، ولذلك يستطيع أن يشغل أي نظام: Linux بإصدار نواة مختلف، أو Windows، أو BSD. أما ال Container فعملية على نواة المضيف، ولذلك فكل Container على Docker Desktop عندنا أجاب عن `uname -r` بنفس الإجابة `5.15.167.4-microsoft-standard-WSL2`، مهما كانت التوزيعة داخله Alpine أو Debian أو Ubuntu، بينما أجاب الجهاز الافتراضي بنواته هو `6.18.60-0-virt`.

![مقارنة بين طبقات الجهاز الافتراضي حيث لكل جهاز نواته فوق المشرف KVM، وطبقات ال Containers حيث تشترك كل التطبيقات في نواة واحدة هي Linux 5.15 WSL2 فوق Namespaces وcgroups وOverlayFS](https://arabroot.io/content/images/2026/11/containers-basics-07-vm-vs-container.webp)

ال Container يستعير نواة المضيف، والجهاز الافتراضي يحمل نواته

وماذا عن سرعة البدء؟ أضفنا إلى مختبر الجهاز الافتراضي خطوة تشغل ال Container اليدوي عشرين مرة بالأمر `true`، فاستغرقت 9.3 ثانية، أي 463 ملي ثانية لكل Container، وهذا يشمل تركيب `/dev` و`/proc` وإنشاء خمس مساحات أسماء، داخل جهاز افتراضي متداخل Nested على مضيف مشغول. وعلى Docker Desktop قسنا الفرق بين وقت إنشاء ال Container ووقت بدء عمليته كما يسجلهما Docker نفسه في `docker inspect`، فكان بين 0.67 و1.37 ثانية في ثلاث محاولات على نفس المضيف المشغول. أما نواة الجهاز الافتراضي فاحتاجت 1.19 ثانية حتى تصل إلى `/init` وحده، وهي نواة صغيرة بلا أقراص ولا خدمات، بينما يحتاج نظام كامل بـ systemd وأقراص وشبكة عشرات الثواني كما قسنا في مقال المحاكاة الافتراضية. فالفرق ليس أن ال Container سريع بطبيعته، وإنما أنه لا يقلع شيئاً أصلاً: هو عملية تبدأ.

والجدول التالي يجمع الفرق من زاوية من يدير السيرفر:

| البند              | الجهاز الافتراضي VM                                                     | ال Container                                                         |
| ------------------ | ----------------------------------------------------------------------- | -------------------------------------------------------------------- |
| النواة             | نواة خاصة لكل جهاز، بأي إصدار                                           | نواة المضيف نفسها، فلا تستطيع تشغيل نواة أخرى ولا وحدات Modules خاصة |
| نظام التشغيل داخله | أي نظام يدعمه المعالج                                                   | توزيعات Linux فقط على مضيف Linux                                     |
| بدء التشغيل        | إقلاع نواة ونظام: من ثانية لنواة صغيرة مثل مختبرنا إلى دقيقة لنظام كامل | إنشاء عملية وطبقة فارغة: أقل من ثانية في الغالب                      |
| القرص              | قرص افتراضي كامل لكل جهاز                                               | طبقات مشتركة، وطبقة صغيرة لكل Container                              |
| الحدود             | عتاد افتراضي يحدده المشرف                                               | cgroups: الذاكرة والمعالج والعمليات والقرص                           |
| حد العزل           | عتاد افتراضي، والخروج منه يحتاج ثغرة في المشرف                          | واجهة النواة كلها، وثغرة فيها تصل إلى المضيف                         |
| الاستخدام الأنسب   | فصل العملاء والبيئات والأنظمة المختلفة                                  | تشغيل التطبيقات ونشرها بنفس الشكل في كل مكان                         |

وفي الواقع لا يختار أغلب الناس بينهما، وإنما يجمعون الاثنين: جهاز افتراضي عند مزود الاستضافة، وداخله Docker يشغل التطبيقات، كما في دليل [تثبيت Docker على Ubuntu](https://arabroot.io/articles/%D8%AA%D8%AB%D8%A8%D9%8A%D8%AA-docker-%D8%B9%D9%84%D9%89-ubuntu/). وحتى Docker Desktop الذي جربنا عليه هو جهاز افتراضي خفيف يعمل فوق WSL2، وداخله ال Containers، وقد شرحنا هذا الترتيب في مقال [WSL2 للمطورين](https://arabroot.io/articles/wsl2-%D9%84%D9%84%D9%85%D8%B7%D9%88%D8%B1%D9%8A%D9%86-%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-linux-%D8%AF%D8%A7%D8%AE%D9%84-windows/). وهناك نوع ثالث بين الاثنين هو Containers للنظام System Containers مثل LXC، التي تشغل systemd ونظاماً كاملاً بدلاً من تطبيق واحد، وقد شرحناها في دليل [LXC في Proxmox](https://arabroot.io/articles/lxc-%D9%81%D9%8A-proxmox-containers-%D8%AE%D9%81%D9%8A%D9%81%D8%A9-%D9%84%D9%86%D8%B8%D8%A7%D9%85-%D9%83%D8%A7%D9%85%D9%84/).

## حدود العزل: لماذا لا يكفي ال Container لعزل عميل عن عميل؟

كل ما رأيناه يعمل لأن النواة تتعاون، فمساحات الأسماء وcgroups جداول وقيود داخل النواة نفسها، وال Container يستطيع أن يطلب من النواة أي استدعاء نظام System Call لم يمنع صراحة. وهذا يعني أن ثغرة واحدة في النواة أو في البرنامج الذي ينشئ ال Container قد تخرج العملية من كل هذه الجدران دفعة واحدة. والأمثلة موثقة: في فبراير 2019 نشرت [الثغرة CVE-2019-5736](https://www.cve.org/CVERecord?id=CVE-2019-5736&ref=arabroot.io) في runc، وهو البرنامج الذي ينشئ ال Containers في Docker وcontainerd وKubernetes، وكانت تسمح لعملية تعمل كـ root داخل Container خبيث بأن تستبدل ملف runc نفسه على المضيف، فتنفذ أوامرها كـ root على السيرفر في المرة التالية التي يدخل فيها أحد إلى ال Container بالأمر `docker exec`. واضطرت كل المنصات إلى تحديث runc بسرعة، كما يشرح [إعلان Kubernetes عنها](https://kubernetes.io/blog/2019/02/11/runc-and-cve-2019-5736/?ref=arabroot.io). وفي يناير 2024 تكرر الأمر بشكل آخر مع [الثغرة CVE-2024-21626](https://github.com/opencontainers/runc/security/advisories/GHSA-xr7r-f8xq-vfvv?ref=arabroot.io)، حيث كان runc يترك وصفاً لملف مفتوح على مجلد من المضيف داخل ال Container، فيصل منه إلى نظام ملفات المضيف.

والدرس من الحادثتين ليس أن ال Containers غير آمنة، وإنما أن حدها أرق من حد الجهاز الافتراضي، ولذلك تضيف المنصات الجادة طبقات فوقها: تشغيل التطبيق بمستخدم غير root، ومساحة المستخدمين user namespace أو وضع Rootless، وإزالة الصلاحيات Capabilities غير المطلوبة، وقائمة استدعاءات مسموحة seccomp، وتحديث runc والنواة بسرعة. وقد رأينا في المختبر أن root داخل ال Container هو root المضيف لأن Docker لا يستخدم مساحة المستخدمين افتراضياً، فإذا كان على نفس السيرفر عملاء لا تثق بهم فافصلهم بأجهزة افتراضية، واجعل ال Containers داخل كل جهاز. وكل هذه الطبقات موضوع مقال أمان ال Containers وقت التشغيل في هذه المرحلة.

## أخطاء شائعة Common Mistakes

- اعتبار ال Container جهازاً افتراضياً صغيراً: تثبيت SSH داخله والدخول إليه لتحديثه يدوياً. ال Container يصنع من ال Image ويرمى، وأي تعديل يدوي داخله يضيع عند إعادة إنشائه.
- حفظ البيانات في الطبقة القابلة للكتابة: قاعدة بيانات بلا Volume تضيع بياناتها مع `docker rm`، وتدفع ثمن النسخ عند الكتابة مع كل ملف كبير.
- تشغيل Containers بلا حد ذاكرة على سيرفر مشترك: تسرب ذاكرة واحد يجعل النواة تقتل عمليات عشوائية على السيرفر كله بدلاً من قتل التطبيق المعطوب وحده.
- الخلط بين رمز 137 من الذاكرة ورمز 137 من الإيقاف: افحص `OOMKilled` قبل أن تزيد الذاكرة.
- الاعتماد على `latest` أو على Tag متحرك في الإنتاج، ثم الاستغراب من تغير السلوك بعد إعادة تشغيل عادية.
- حذف الأسرار في سطر لاحق من Dockerfile والظن أنها خرجت من ال Image، وهي ما زالت في الطبقة التي أضافتها.
- الظن أن `chroot` عزل أمني، أو أن root داخل ال Container لا يستطيع شيئاً على المضيف.
- نسخ أوامر من مقال يفترض cgroup v2 على نظام v1 أو العكس، ثم البحث عن ملف `memory.max` غير موجود. اعرف نسختك أولاً بالأمر `docker info`.

## جدول القرار Decision Table: Container أم جهاز افتراضي؟

| الحالة                                               | الأنسب                                   | والسبب                                                    |
| ---------------------------------------------------- | ---------------------------------------- | --------------------------------------------------------- |
| تطبيق ويب أو API مع قاعدة بياناته على سيرفرك         | Containers                               | بيئة ثابتة من التطوير إلى الإنتاج، وتحديث بتبديل ال Image |
| عدة تطبيقات لنفس الفريق على سيرفر واحد               | Containers مع حدود ذاكرة ومعالج          | الثقة واحدة، والحدود تمنع تطبيقاً من إسقاط الآخرين        |
| عملاء مختلفون لا يثق بعضهم ببعض                      | جهاز افتراضي لكل عميل، وContainers داخله | ثغرة في النواة المشتركة تصل إلى الجميع                    |
| تطبيق يحتاج نواة مختلفة أو وحدة نواة خاصة أو Windows | جهاز افتراضي                             | ال Container لا يملك نواة خاصة به                         |
| بيئة تريدها كسيرفر كامل فيها systemd وعدة خدمات      | LXC أو جهاز افتراضي                      | Docker مصمم لتطبيق واحد في كل Container                   |
| تجربة سريعة لأداة أو إصدار ثم حذفها                  | Container مع \--rm                       | يبدأ في ثانية ولا يترك شيئاً خلفه                         |

## حذف المختبر Cleanup

كل ما أنشأناه يحمل البادئة `ct1-`، ولذلك نحذفه بالاسم دون أن نلمس أي شيء آخر على الجهاز. والجهاز الافتراضي يطفئ نفسه في آخر كل تشغيل، فلا يبقى منه شيء غير ملفاته:

```bash
docker rm -f ct1-web ct1-ovl ct1-ovl2 ct1-oom
docker rmi ct1-layers:1 ct1-tools:1 ct1-qemu:1
```

⚠️

لا تستخدم `docker system prune` لتنظيف مختبر على جهاز فيه أعمال أخرى، لأنه يحذف كل Container متوقف وكل Image غير مستخدمة على الجهاز كله، لا ما صنعته أنت فقط. وسوف نشرح أوامر التنظيف وما يحذفه كل منها في مقال أوامر Docker.

## الخلاصة

وصلنا لنهاية الموضوع، وأهم ما فيه:

- ال Container عملية عادية على نواة المضيف، رأيناها برقم 1 من الداخل و77653 من الخارج، وأبوها `containerd-shim` وليس جهازاً.
- مساحات الأسماء تحدد ما تراه العملية، وDocker أنشأ ستاً منها وترك `user` و`cgroup` مشتركتين، فـ root في الداخل هو root المضيف.
- مجموعات التحكم تحدد ما تأخذه: تجاوز الذاكرة قتل `dd` برمز 137 و`OOMKilled=true`، وحد المعالج 20% أعطى الحلقة 1.07 ثانية من 5 دون قتل.
- Docker Desktop عندنا على cgroup v1، والسيرفرات الحديثة على v2، والملف نفسه اسمه `memory.limit_in_bytes` هناك و`memory.max` هنا.
- بنينا Container كاملاً بـ unshare وchroot وcgroup v2، وتعلمنا من مشكلتين أن Docker يصنع `/dev` لكل Container وأن العملية رقم 1 تتجاهل الإشارات التي لا تعالجها.
- ال Image طبقات للقراءة فقط، وال Container يضيف فوقها طبقة واحدة بحجم 16 KB في تجربتنا، والحذف ملف Whiteout لا يقلل الحجم.
- ال Tag اسم متحرك، وال Digest هاش لمحتوى لا يتغير، و`alpine:3.24` وحده قائمة بثماني منصات.
- الجهاز الافتراضي يحمل نواته وحده أقوى، وال Container يستعير النواة فيبدأ أسرع، والحل الشائع الجمع بينهما.

وفي المقالات التالية من هذه المرحلة بإذن الله سوف نستخدم Docker كل يوم: أوامره الأساسية وإشاراته ورموز خروجه، ثم البيانات وال Volumes والنسخ الاحتياطي. وهذه مقالات مرتبطة:

[![](https://arabroot.io/content/images/2026/11/docker-cover-cover.webp)دليلتثبيت Docker Engine وCompose على Ubuntuكيف تثبت Docker على Ubuntu من المستودع الرسمي، وتضبطه من البداية حتى لا يمتلئ القرص أو تنكشف منافذك للإنترنت.](https://arabroot.io/articles/%D8%AA%D8%AB%D8%A8%D9%8A%D8%AA-docker-%D8%B9%D9%84%D9%89-ubuntu/)[![](https://arabroot.io/content/images/2026/11/docker-commands-cover-cover.webp)دليلأوامر Docker الأساسية: التشغيل والسجلات والإيقافنشغل خدمة صغيرة ونتابعها بأوامر Docker اليومية، ثم نفهم لماذا ينتظر docker stop ثم يقتل، وماذا تعني رموز الخروج 0 و1 و127 و137 و143.](https://arabroot.io/articles/%D8%A7%D9%88%D8%A7%D9%85%D8%B1-docker-%D8%A7%D9%84%D8%A7%D8%B3%D8%A7%D8%B3%D9%8A%D8%A9-%D8%A7%D9%84%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-%D9%88%D8%A7%D9%84%D8%B3%D8%AC%D9%84%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D8%A7%D9%8A%D9%82%D8%A7%D9%81/)[![](https://arabroot.io/content/images/2026/11/docker-volumes-cover-cover.webp)دليلبيانات ال Containers: Volumes وBind Mounts والنسخ الاحتياطيأين تذهب ملفات ال Container وما الذي يحذفها، مع قياس حقيقي لسرعة مسارات Windows وLinux ونسخة احتياطية مستعادة لملفات Volume وقاعدة PostgreSQL.](https://arabroot.io/articles/%D8%A8%D9%8A%D8%A7%D9%86%D8%A7%D8%AA-%D8%A7%D9%84-containers-volumes-%D9%88-bind-mounts-%D9%88%D8%A7%D9%84%D9%86%D8%B3%D8%AE-%D8%A7%D9%84%D8%A7%D8%AD%D8%AA%D9%8A%D8%A7%D8%B7%D9%8A/)[![](https://arabroot.io/content/images/2026/10/docker-networking-cover-cover.webp)دليلشبكات Docker وأفضل الممارسات مع Docker Composeلماذا يبقى المنفذ الذي تنشره في Compose مفتوحاً للإنترنت رغم ufw، وكيف تصل التطبيقات إلى بعضها عبر شبكات Docker دون نشر منافذ.](https://arabroot.io/articles/%D8%B4%D8%A8%D9%83%D8%A7%D8%AA-docker-%D9%88%D8%A3%D9%81%D8%B6%D9%84-%D8%A7%D9%84%D9%85%D9%85%D8%A7%D8%B1%D8%B3%D8%A7%D8%AA/)[![](https://arabroot.io/content/images/2026/11/virtualization-basics-cover-cover.webp)دليلالمحاكاة الافتراضية Virtualization: من Hypervisor إلى KVMماذا يحدث داخل المعالج عندما يعمل نظام كامل فوق نظام آخر، ومتى تختار جهازاً افتراضياً ومتى يكفيك Container، مع قياس حقيقي لنفس الجهاز مع KVM أو دونه.](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%8A-%D8%A7%D9%84%D9%85%D8%AD%D8%A7%D9%83%D8%A7%D8%A9-%D8%A7%D9%84%D8%A7%D9%81%D8%AA%D8%B1%D8%A7%D8%B6%D9%8A%D8%A9-virtualization-%D9%85%D9%86-hypervisor-%D8%A7%D9%84%D9%89-kvm/)[![](https://arabroot.io/content/images/2026/11/cpu-virtualization-cover-cover.webp)دليلدعم المعالج للأجهزة الافتراضية: VT-x وAMD-V من الداخلنكتب مشرفاً صغيراً على KVM يشغل ضيفاً من 63 بايت، ونعد مرات الخروج VM Exit ونقيس كلفتها لنفهم ما يفعله VT-x وEPT داخل المعالج.](https://arabroot.io/articles/%D8%AF%D8%B9%D9%85-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-%D9%84%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-%D8%A7%D9%84%D8%A7%D9%81%D8%AA%D8%B1%D8%A7%D8%B6%D9%8A%D8%A9-vt-x-%D9%88-amd-v-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)[![](https://arabroot.io/content/images/2026/11/proxmox-lxc-cover-cover.webp)دليلLXC في Proxmox: Containers خفيفة لنظام Linux كاملشغلنا Debian كاملاً في Container من نوعين على Proxmox، وقسنا الذاكرة والإقلاع مقارنة بجهاز افتراضي، ورأينا ما يعنيه root داخل الـ Container على السيرفر نفسه.](https://arabroot.io/articles/lxc-%D9%81%D9%8A-proxmox-containers-%D8%AE%D9%81%D9%8A%D9%81%D8%A9-%D9%84%D9%86%D8%B8%D8%A7%D9%85-%D9%83%D8%A7%D9%85%D9%84/)

## سجل التحديثات

- 18 نوفمبر 2026: كتابة المقال، وتنفيذ التجارب على Docker Engine 29.8.0 (Docker Desktop، نواة WSL2 5.15 مع cgroup v1)، وجهاز افتراضي QEMU 11.0.3 مع KVM بنواة Alpine 6.18.60 وcgroup v2، وAlpine 3.24.4.