عندما تكتب لأول مرة docker run -it alpine sh يحدث شيء يبدو كالسحر: في أقل من ثانية تجد نفسك داخل Linux آخر، له اسم جهاز خاص، وقائمة عمليات لا يظهر فيها غير الـ Shell الذي فتحته ورقمه 1، وعنوان شبكة خاص، ونظام ملفات كامل لا يرى ملفاتك. والسؤال الطبيعي بعدها: ما هذا الشيء بالضبط؟ هل هو جهاز افتراضي صغير؟ وإذا كان كذلك فكيف يقلع في جزء من الثانية بينما يحتاج أي جهاز افتراضي إلى إقلاع نظام كامل؟ وإذا لم يكن كذلك فأين يعيش، ومن يمنعه من رؤية بقية الجهاز؟
والإجابة القصيرة أن الـ Container ليس جهازاً على الإطلاق، وإنما عملية Process عادية تعمل على نواة المضيف Host نفسها، طلب Docker من النواة أن تريها نسخة خاصة من العالم، وأن تحد ما تأخذه من الذاكرة والمعالج. وهذه الإجابة صحيحة ولكنها لا تكفي لتفهم لماذا يتصرف الـ Container كما يتصرف، ولماذا يقتل فجأة برمز 137، ولماذا تختفي ملفاته عند حذفه، ولماذا لا ينصح بالاعتماد عليه وحده لعزل عميل عن عميل. لذلك سوف نأخذ في هذا المقال Container حقيقياً ونفتحه من الخارج قطعة قطعة، ثم نبني واحداً بأيدينا بأدوات Linux فقط دون Docker، ونرى في كل خطوة المخرج الحقيقي للأوامر. وهذا المقال هو أول مقالات مرحلة Docker، فإذا كنت جديداً على الطرفية فابدأ بمقال سطر الأوامر في Linux للمبتدئين ثم ارجع إلى هنا.
وسوف نناقش في هذا المقال ما يلي:
- المشكلة التي جاءت ال 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 كيف يعمل هذا من الداخل وكم يكلف. والسؤال الذي قاد إلى ال Containers كان: إذا كانت كل التطبيقات تعمل على Linux أصلاً، فلماذا نحمل نواة كاملة لكل تطبيق؟ لماذا لا تعزل النواة الواحدة التطبيقات بعضها عن بعض؟
والفكرة ليست جديدة. فالأمر chroot من أقدم أوامر Unix، وهو يغير المجلد الذي تراه العملية كجذر لنظام الملفات، فلا تستطيع فتح ملف خارجه بالمسار العادي. ثم جاءت Jails في FreeBSD عام 2000 فعزلت العمليات والشبكة أيضاً. وفي Linux دخلت الفكرة على مراحل كما يشرح مقال LWN عن مساحات الأسماء: مساحة نقاط التركيب Mount Namespace عام 2002، ثم بقية الأنواع على مدى عشر سنوات، ومعها مجموعات التحكم cgroups التي بدأها مهندسون في Google تحت اسم Process Containers ودخلت النواة في الإصدار 2.6.24 عام 2008. ثم جمع مشروع LXC هذه الأدوات في 2008، وفي 2013 ظهر Docker فأضاف ما كان ينقصها ليستخدمها كل مطور: صيغة Image تحمل التطبيق مع كل ما يحتاجه، وسجلاً Registry تنشر فيه ال Images وتسحبها منه بأمر واحد. وفي 2015 تأسست مبادرة OCI لتوحيد صيغة ال Image وطريقة تشغيلها، ولذلك تعمل نفس ال Image اليوم مع Docker وPodman وKubernetes.
وبالتالي فكل ما سوف تراه في هذا المقال ثلاث أدوات في النواة، ولا يوجد شيء اسمه «Container» داخل نواة Linux: مساحات الأسماء Namespaces تحدد ما تراه العملية، ومجموعات التحكم cgroups تحدد ما تأخذه، ونظام الملفات المتراكب OverlayFS يعطيها نظام ملفاتها. وDocker برنامج يجمع هذه الثلاث بالترتيب الصحيح ويخفي تفاصيلها خلف أمر واحد.
ال Container من الخارج: عملية برقمين
الآن سوف نشغل Container عادياً ونبحث عنه من الخارج. الأمر التالي يشغل Container من Alpine باسم جهاز web1، يدور في حلقة لا تنتهي، ثم ندخل إليه ونسأله عن نفسه:
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 إلى الاسم والرقم):
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:
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'والمخرج سوف يكون كما يلي:
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 المضيف نفسه من وجهة نظر النواة، وسوف نعود إلى خطورة ذلك في قسم حدود العزل.

ولاحظ أن «المضيف» هنا هو الجهاز الافتراضي الخفيف الذي يشغله Docker Desktop على Windows، والعملية رقم 1 فيه اسمها /initd. أما على سيرفر Linux عادي فسوف تجد systemd في هذا المكان، كما شرحنا في مقال الخدمات والسجلات مع systemd، والفكرة نفسها لا تتغير.
مساحات الأسماء Namespaces: ماذا ترى العملية؟
مساحة الأسماء Namespace طريقة تقول بها النواة للعملية: «هذا هو العالم الذي تراه»، فلكل نوع من الموارد التي لها أسماء في النظام (أرقام العمليات، أسماء الواجهات، نقاط التركيب، اسم الجهاز) قائمة خاصة بكل مساحة. وتشبيه ذلك مبنى مكاتب فيه شركات كثيرة، ولكل شركة دليل هاتف داخلي يبدأ بالرقم 100: الرقم 100 في الشركة الأولى ليس نفس الرقم 100 في الثانية، ولا يعرف أحدهما دليل الآخر، مع أن المبنى والكهرباء والمصاعد واحدة. والنواة هنا هي المبنى، وكل Container شركة بدليلها الخاص.
وفي Linux اليوم ثمانية أنواع، تصفها صفحة namespaces(7)، والرسم التالي يجمعها مع الإصدار الذي أضافها وما أنشأه 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 وأفضل الممارسات.
- مساحة user: تربط أرقام المستخدمين في الداخل بأرقام أخرى في الخارج، فيكون root في الداخل مستخدماً عادياً بلا صلاحيات في الخارج. وDocker لا يستخدمها افتراضياً إلا إذا فعلت userns-remap، وهذا ما رأيناه في المخرج.
- مساحة 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:
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'والمخرج سوف يكون كما يلي:
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 كل متحكم له شجرة مستقلة، فيمكن أن تكون العملية في مجموعة للذاكرة ومجموعة أخرى مختلفة للمعالج، وهذا جعل الإدارة معقدة وبعض الحالات غير منطقية، مثل حساب الكتابة على القرص التي تمر بالذاكرة. أما cgroup v2 فشجرة واحدة موحدة Unified Hierarchy، وكل مجموعة مجلد واحد فيه كل المتحكمات المفعلة، وفيه ملفات أحداث مثل memory.events تخبرك كم مرة وصلت المجموعة إلى حدها وكم عملية قتلت فيها. وأغلب التوزيعات الحديثة تستخدم v2 افتراضياً، منها Debian 11 وUbuntu 21.10 وما بعدهما، ولذلك فالمهم أن تعرف الاثنين: v1 لأنك سوف تجدها في أنظمة قديمة وفي بيئات مثل جهازنا، وv2 لأنها ما سوف تجده على السيرفر.

ماذا يحدث عندما يتجاوز ال Container حد الذاكرة؟ OOM Kill
الحد على الورق لا يعني شيئاً حتى نراه يعمل، لذلك سوف نطلب ذاكرة أكثر من الحد. والأداة dd تحجز في الذاكرة مخزناً مؤقتاً Buffer بحجم الخيار bs ثم تملؤه، فإذا جعلناه 100 MB داخل حد 64 MB فهي تطلب أكثر مما يسمح لها:
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والمخرج سوف يكون كما يلي:
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 بصلاحيات كاملة:
[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، أي أن النواة سمحت بالوصول إلى الحد تماماً ثم تحركت.
OOMKilled تساوي true؟ إذا كانت كذلك فالحل زيادة الحد أو إصلاح استهلاك التطبيق، وإذا كانت false فهناك من أرسل SIGKILL، وغالباً هو docker stop بعد انتهاء مهلته، وهذا موضوع مقال أوامر Docker.مختبر cgroup v2: جهاز افتراضي صغير بنواة حديثة
بما أن Docker Desktop عندنا على cgroup v1، وأردنا أن نرى cgroup v2 كما سوف تراها على سيرفرك، احتجنا نواة حديثة نتحكم في إقلاعها. والطريقة الأخف التي وجدناها أن نشغل جهازاً افتراضياً صغيراً بـ QEMU مع KVM داخل Container، بنواة vmlinuz-virt من Alpine 3.24 (Linux 6.18.60)، ونظام ملفات كامل محمل في الذاكرة Initramfs، دون قرص ولا شبكة. وقد شرحنا ما يفعله KVM داخل المعالج في مقال دعم المعالج للأجهزة الافتراضية VT-x وAMD-V، أما هنا فهو مجرد وسيلة لتشغيل نواة أخرى. وهذا أمر الإقلاع كاملاً، وطريقة إقلاع نواة مباشرة دون قرص موصوفة في توثيق QEMU:
#!/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، ثم يشغل المختبر ويطفئ الجهاز:
#!/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 على أي توزيعة حديثة عند الإقلاع. - الجهاز كله يعمل في الذاكرة ويطفئ نفسه، فيمكن تشغيله مرات كثيرة دون أن يترك شيئاً خلفه.
والسطور الأولى من مخرج المختبر تؤكد أننا في البيئة المطلوبة:
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 التي تشغل برنامجاً في مساحات أسماء جديدة. وأول خطوة فك نظام الملفات وإنشاء المجموعة:
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والمخرج سوف يكون كما يلي:
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»، وهو قلب المختبر كله:
#!/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)، فيتفرعunshareليصبح ابنه هو العملية رقم 1. - بعد
--mountصار لنا جدول Mounts خاص، فنركب/devصغيراً داخل نظام الملفات الجديد فيه أربعة أجهزة فقط، ولا يظهر هذا التركيب في الجهاز الأصلي. chrootيجعل/ct1/rootfsهو الجذر، ثم نركب/procجديداً حتى يعرض الأمرpsعمليات مساحتنا فقط، ونعطي الجهاز اسماً، ثمexecيستبدل الـ Shell بالبرنامج المطلوب فيصبح هو العملية رقم 1.
والرسم التالي يلخص الخطوات بالترتيب، وكل واحدة تضيف عزلاً لا تضيفه التي قبلها:

والآن نشغل Shell كـ Container ونسأله عن عالمه:
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)"والمخرج سوف يكون كما يلي:
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 ثم ننظر إليه من الخارج:
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والمخرج سوف يكون كما يلي:
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 كتبناه بأيدينا:
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والمخرج سوف يكون كما يلي:
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 ثوان:
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والمخرج سوف يكون كما يلي:
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:
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، فأعطت تجربة الذاكرة هذا المخرج بدلاً من القتل:
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.
والمشكلة الثانية أطرف، فقد كتبنا تجربة المعالج أولاً هكذا: 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. والفرق أن 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:
FROM alpine:3.24
RUN echo "version 1" > /app.txt
RUN rm /etc/motdثم سألنا Docker عن طبقات ال Image الأصلية وطبقات Image الجديدة وتاريخها:
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والمخرج سوف يكون كما يلي (قسمنا الأسطر الطويلة):
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 عن الفرق:
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والمخرج سوف يكون كما يلي:
C /app.txt
C /etc
D /etc/issue
A /data.txtالأمر docker diff يقرأ الطبقة القابلة للكتابة ويعرض ما فيها: A ملف أضيف، وC ملف أو مجلد تغير، وD ملف حذف. ولكن أين هذه الطبقة؟ لنبحث عنها من المضيف في جدول نقاط التركيب الخاص بالعملية، وهو الملف /proc/<pid>/mountinfo:
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):
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 في النواة، وهو يجمع عدة مجلدات فوق بعضها ويعرضها كمجلد واحد. والمجلدات السفلى lowerdir للقراءة فقط، والعليا upperdir تستقبل كل كتابة. ولنرى ما في كل مجلد دخلنا إلى مساحة الأسماء الخاصة بـ containerd حيث توجد هذه المسارات:
=== 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 فيها 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، فكانت طبقاته كما يلي:
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 عن طريقة التخزين، والمسار الذي رأيته يخص مخزن containerd الذي صار افتراضياً في الإصدارات الحديثة من Docker.
السجل Registry وال Tag وال Digest
بقي أن نعرف كيف وصلت ال Image إلى جهازك. ال Images تحفظ في سجل Registry مثل Docker Hub، وعندما تكتب alpine:3.24 فالجزء 3.24 هو ال Tag، وهو اسم يشير إلى محتوى، ويستطيع ناشر ال Image أن ينقله إلى محتوى آخر متى شاء. وهذا ما يحدث فعلاً مع alpine:3.24، فكلما صدر إصدار تصحيحي مثل 3.24.5 سوف يشير ال Tag إليه. والطريقة الوحيدة لتشير إلى محتوى لا يتغير هي ال Digest، وهو هاش SHA-256 للمحتوى نفسه. ولنرى ما يقف خلف ال Tag:
docker pull alpine:3.24
docker buildx imagetools inspect alpine:3.24والمخرج سوف يكون كما يلي (اختصرنا قائمة المنصات):
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، فيها 16 عنصراً: Image لكل منصة من ثماني منصات (Intel وAMD بنوعيهما، وARM بثلاثة أنواع، وPowerPC وRISC-V وIBM Z)، وثماني شهادات Attestations تصف كيف بنيت كل واحدة. وعندما تسحب ال Image يختار Docker العنصر الذي يطابق معالجك، ولذلك يعمل نفس الأمر على حاسوب Intel وعلى Raspberry Pi. ثم فتحنا Manifest المنصة linux/amd64:
docker buildx imagetools inspect alpine:3.24@sha256:0f49f331d9212aff11b932863be4eb01cdf962969aa86dab7d1ee21ac6f5f52b --rawوالمخرج سوف يكون كما يلي (حذفنا بعض الحقول):
{
"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 كما تحدده مواصفة OCI: ملف Config صغير بحجم 611 بايت، وطبقة واحدة مضغوطة بـ gzip حجمها 3,853,673 بايت. ولاحظ أن هاش الطبقة هنا 881fc932…، بينما رأينا في docker image inspect هاشاً آخر هو 75f1d965…. والسبب أن السجل يحفظ الطبقة مضغوطة ويسميها بهاش الملف المضغوط، أما Docker فيحفظ في ال Config هاش الطبقة بعد فك الضغط واسمه diff_id، لأن نفس المحتوى قد يضغط بطرق مختلفة. وكل مستوى يحمل هاش المستوى الذي تحته، فإذا تغير بايت واحد في الطبقة تغير هاشها، فتغير ال Manifest، فتغير ال Index، وهذا ما يجعل ال Digest ضماناً حقيقياً للمحتوى.

والقاعدة العملية من كل هذا: في الإنتاج لا تستخدم latest، والسبب أنه Tag ينتقل مع كل إصدار فلا تعرف ماذا سوف يعمل عند إعادة التشغيل القادمة. واستخدم Tag بإصدار محدد مثل postgres:18.1-alpine، وإذا أردت ضماناً كاملاً بأن ما اختبرته هو ما يعمل فأضف ال Digest: alpine:3.24@sha256:f59abe65…. والثمن أنك لن تحصل على التحديثات الأمنية حتى تغير ال Digest بنفسك، ولذلك تحتاج أداة تتابع ذلك، وقد قارنا بين الأدوات في دليل تحديث ال Containers بأمان.
الجهاز الافتراضي 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.

وماذا عن سرعة البدء؟ أضفنا إلى مختبر الجهاز الافتراضي خطوة تشغل ال 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. وحتى Docker Desktop الذي جربنا عليه هو جهاز افتراضي خفيف يعمل فوق WSL2، وداخله ال Containers، وقد شرحنا هذا الترتيب في مقال WSL2 للمطورين. وهناك نوع ثالث بين الاثنين هو Containers للنظام System Containers مثل LXC، التي تشغل systemd ونظاماً كاملاً بدلاً من تطبيق واحد، وقد شرحناها في دليل LXC في Proxmox.
حدود العزل: لماذا لا يكفي ال Container لعزل عميل عن عميل؟
كل ما رأيناه يعمل لأن النواة تتعاون، فمساحات الأسماء وcgroups جداول وقيود داخل النواة نفسها، وال Container يستطيع أن يطلب من النواة أي استدعاء نظام System Call لم يمنع صراحة. وهذا يعني أن ثغرة واحدة في النواة أو في البرنامج الذي ينشئ ال Container قد تخرج العملية من كل هذه الجدران دفعة واحدة. والأمثلة موثقة: في فبراير 2019 نشرت الثغرة CVE-2019-5736 في runc، وهو البرنامج الذي ينشئ ال Containers في Docker وcontainerd وKubernetes، وكانت تسمح لعملية تعمل كـ root داخل Container خبيث بأن تستبدل ملف runc نفسه على المضيف، فتنفذ أوامرها كـ root على السيرفر في المرة التالية التي يدخل فيها أحد إلى ال Container بالأمر docker exec. واضطرت كل المنصات إلى تحديث runc بسرعة، كما يشرح إعلان Kubernetes عنها. وفي يناير 2024 تكرر الأمر بشكل آخر مع الثغرة CVE-2024-21626، حيث كان 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-، ولذلك نحذفه بالاسم دون أن نلمس أي شيء آخر على الجهاز. والجهاز الافتراضي يطفئ نفسه في آخر كل تشغيل، فلا يبقى منه شيء غير ملفاته:
docker rm -f ct1-web ct1-ovl ct1-ovl2 ct1-oom
docker rmi ct1-layers:1 ct1-tools:1 ct1-qemu:1docker 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 والنسخ الاحتياطي. وهذه مقالات مرتبطة:
دليلتثبيت Docker Engine وCompose على Ubuntuكيف تثبت Docker على Ubuntu من المستودع الرسمي، وتضبطه من البداية حتى لا يمتلئ القرص أو تنكشف منافذك للإنترنت.
دليلأوامر Docker الأساسية: التشغيل والسجلات والإيقافنشغل خدمة صغيرة ونتابعها بأوامر Docker اليومية، ثم نفهم لماذا ينتظر docker stop ثم يقتل، وماذا تعني رموز الخروج 0 و1 و127 و137 و143.
دليلبيانات ال Containers: Volumes وBind Mounts والنسخ الاحتياطيأين تذهب ملفات ال Container وما الذي يحذفها، مع قياس حقيقي لسرعة مسارات Windows وLinux ونسخة احتياطية مستعادة لملفات Volume وقاعدة PostgreSQL.
دليلشبكات Docker وأفضل الممارسات مع Docker Composeلماذا يبقى المنفذ الذي تنشره في Compose مفتوحاً للإنترنت رغم ufw، وكيف تصل التطبيقات إلى بعضها عبر شبكات Docker دون نشر منافذ.
دليلالمحاكاة الافتراضية Virtualization: من Hypervisor إلى KVMماذا يحدث داخل المعالج عندما يعمل نظام كامل فوق نظام آخر، ومتى تختار جهازاً افتراضياً ومتى يكفيك Container، مع قياس حقيقي لنفس الجهاز مع KVM أو دونه.
دليلدعم المعالج للأجهزة الافتراضية: VT-x وAMD-V من الداخلنكتب مشرفاً صغيراً على KVM يشغل ضيفاً من 63 بايت، ونعد مرات الخروج VM Exit ونقيس كلفتها لنفهم ما يفعله VT-x وEPT داخل المعالج.
دليلLXC في Proxmox: Containers خفيفة لنظام Linux كاملشغلنا Debian كاملاً في Container من نوعين على Proxmox، وقسنا الذاكرة والإقلاع مقارنة بجهاز افتراضي، ورأينا ما يعنيه root داخل الـ Container على السيرفر نفسه.سجل التحديثات
- 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.