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

# ما هو DevOps؟ الثقافة والممارسات قبل الأدوات
- URL: https://arabroot.io/articles/ما-هو-devops-الثقافة-والممارسات-قبل-الادوات/
- Published: 2026-11-03T09:02:03.000Z
- Updated: 2026-11-03T10:01:23.000Z
- Description: لماذا يتعطل الإصدار ليلة النشر ويبدأ البحث عن المسؤول، وكيف يغير DevOps طريقة عمل الفريق قبل أن يغير أدواته، مع تجربة تبين ما يفعله نشر يدوي نسي سيرفراً واحداً.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, DevOps والتشغيل, DevOps وCI/CD, الاستضافة الذاتية

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

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

وهذا المقال هو بداية مرحلة «DevOps والنشر المستمر CI/CD» في مسار DevOps والتشغيل، وهو مكتوب لمن يسمع المصطلح ولا يعرف من أين يبدأ. وسوف نناقش في هذا المقال ما يلي:

- لماذا ظهر DevOps، والجدار الذي كان بين فريق التطوير وفريق التشغيل.
- من أين جاء المصطلح، وما هو DevOps فعلاً وما ليس هو.
- المبادئ الثلاثة The Three Ways التي تبنى عليها كل الممارسات، وحلقة DevOps من التخطيط إلى المراقبة.
- حادثة Knight Capital، حيث كلف سيرفر واحد نسي أحدهم تحديثه أكثر من 460 مليون دولار في 45 دقيقة.
- تجربة عملية على جهازك: Gitea وثلاثة سيرفرات خلف موزع طلبات، ونشر يدوي ينسى سيرفراً، ثم سكربت ينشر من وسم Git ويتحقق من النتيجة.
- الممارسات الأساسية والثقافة التي تحتاجها، وكيف تقيس تحسنك، ومن أين يبدأ فريق صغير غداً.

## لماذا ظهر DevOps؟ جدار الارتباك Wall of Confusion

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

ولذلك سمى الناس هذه النقطة «جدار الارتباك Wall of Confusion»، والصورة المعروفة أن المطورين يرمون الإصدار من فوق الجدار ثم يعودون إلى عملهم، فإذا تعطل شيء في الإنتاج لم يكن عندهم ما يعرفون به السبب، ولم يكن عند فريق التشغيل ما يكفي من المعرفة بالكود ليصلحه، والصورة التالية تبين ذلك:

![فريق التطوير Dev على اليمين يقاس بعدد الميزات Features ويقول الكود يعمل على جهازي، وفريق التشغيل Ops على اليسار يقاس بثبات النظام Stability ويقول لا تلمسوا الإنتاج يوم الخميس، وبينهما جدار من الطوب اسمه جدار الارتباك Wall of Confusion والإصدار يرمى من فوقه، وفي الأسفل النتيجة إصدارات قليلة وكبيرة ومؤلمة وكل عطل يبدأ بسؤال من المسؤول](https://arabroot.io/content/images/2026/11/devops-intro-01-wall.webp)

كل فريق يعمل جيداً بحسب مقياسه، والمشكلة في المسافة بينهما

### فريقان بهدفين متعاكسين Conflicting Goals

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

وقد يتساءل البعض: وما المشكلة في الحذر؟ أليس الإنتاج أهم من سرعة الميزات؟ والإجابة أن الحذر بهذا الشكل لا يقلل الخطر وإنما يؤجله ويجمعه، وهذا ما نشرحه في القسم التالي.

### لماذا تصبح الإصدارات الكبيرة مؤلمة؟ Big Releases

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

ولذلك فإن واحدة من أهم الأفكار في DevOps، وهي أيضاً من نتائج أبحاث DORA كما في صفحة [العمل بدفعات صغيرة Working in Small Batches](https://dora.dev/capabilities/working-in-small-batches/?ref=arabroot.io)، أن الحل هو العكس تماماً: أن تنشر أكثر وبتغييرات أصغر، لأن التغيير الصغير أسهل في المراجعة وأسهل في الاختبار وأسهل في التراجع، ولأن الشيء الذي تفعله كل يوم تتقنه وتؤتمته، أما الشيء الذي تفعله مرة في الشهر فيبقى مخيفاً.

## من أين جاء المصطلح؟ History of DevOps

قبل DevOps بسنوات غيرت حركة التطوير الرشيق Agile طريقة عمل فرق البرمجة، فقد نشر سبعة عشر مطوراً في 2001 [بيان التطوير الرشيق Agile Manifesto](https://agilemanifesto.org/?ref=arabroot.io) الذي يفضل البرنامج الذي يعمل على الوثائق الكثيرة، والاستجابة للتغيير على اتباع الخطة. فأصبحت الفرق تكتب الكود بدورات قصيرة من أسبوعين، ولكن الكود الجاهز كل أسبوعين كان ما زال يصل إلى الإنتاج كل ثلاثة أشهر، لأن الجزء الذي بعد كتابة الكود، أي النشر والتشغيل، لم يتغير، فأصبح الجدار الذي ذكرناه هو أبطأ نقطة في الطريق كله.

وفي يونيو 2009 قدم John Allspaw وPaul Hammond من فريق Flickr محاضرة في مؤتمر Velocity بعنوان [«10+ Deploys Per Day: Dev and Ops Cooperation at Flickr»](https://www.youtube.com/watch?v=LdOe18KhtT4&ref=arabroot.io)، وشرائحها [منشورة هنا](https://www.slideshare.net/jallspaw/10-deploys-per-day-dev-and-ops-cooperation-at-flickr?ref=arabroot.io)، وكان عنوانها وحده صادماً في ذلك الوقت، فأغلب الشركات كانت تنشر مرة في الشهر أو أقل. والفكرة التي قدماها لم تكن أداة واحدة، وإنما مجموعة: بناء ونشر بأمر واحد، وتحكم بالميزات عبر مفاتيح Feature Flags، ومراقبة مشتركة يراها الفريقان، وثقة واحترام متبادل بين المطورين وفريق التشغيل، وعدم البحث عن شخص للوم عندما يحدث خطأ.

وفي العام نفسه عقد أول مؤتمر DevOpsDays في مدينة Ghent في بلجيكا، كما يذكر [موقع DevOpsDays](https://devopsdays.org/about?ref=arabroot.io)، وكان Patrick Debois منظمه الرئيسي، ومن اسم هذا المؤتمر انتشرت كلمة DevOps، أي Development مع Operations في كلمة واحدة. وبعد ذلك جاءت الكتب التي جمعت الأفكار، مثل The Phoenix Project سنة 2013 وThe DevOps Handbook سنة 2016، ثم أبحاث DORA التي قاست آلاف الفرق سنوياً لتعرف أي الممارسات ترتبط فعلاً بأداء أفضل، وما زالت تنشر [تقريراً سنوياً](https://dora.dev/research/2024/dora-report/?ref=arabroot.io) حتى اليوم.

## ما هو DevOps إذن؟ Definition

لا يوجد تعريف رسمي واحد متفق عليه، ولكن أغلب التعريفات تدور حول الفكرة نفسها، فمثلاً تعرفه [صفحة AWS عن DevOps](https://aws.amazon.com/devops/what-is-devops/?ref=arabroot.io) بأنه مزيج من الفلسفات الثقافية والممارسات والأدوات يرفع قدرة المؤسسة على تقديم التطبيقات والخدمات بسرعة عالية. والتعريف الذي نستخدمه في هذا المسار أبسط: DevOps هو طريقة عمل تجعل من يبني البرنامج ومن يشغله فريقاً واحداً بهدف واحد، وهو أن يصل التغيير إلى المستخدم بسرعة وبأمان، ثم يعود ما يتعلمه الفريق من الإنتاج إلى التطوير.

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

### ما ليس DevOps؟ Common Misconceptions

لأن الكلمة انتشرت بسرعة فقد التصقت بها معان كثيرة غير صحيحة، وهذه أشهرها:

- **DevOps ليس أداة:** لا توجد أداة تشتريها فتصبح شركتك «DevOps»، فالأدوات مثل Git وخطوط CI/CD وDocker تساعد في تطبيق الممارسات، ولكن الفريق الذي يشغل Kubernetes وما زال ينشر مرة في الشهر بموافقة ثلاثة مديرين لم يتغير فيه شيء مهم.
- **DevOps ليس اسم فريق جديد:** عندما تأخذ فريق التشغيل وتغير اسمه إلى «فريق DevOps» ويبقى الجدار في مكانه، فقد غيرت الاسم فقط، وهذا من الأنماط الخاطئة التي شرحناها في [الفرق بين DevOps وSRE وهندسة المنصات](https://arabroot.io/articles/%D8%A7%D9%84%D9%81%D8%B1%D9%82-%D8%A8%D9%8A%D9%86-devops-%D9%88-sre-%D9%88-platform-engineering/).
- **DevOps لا يعني أن المطور يفعل كل شيء وحده:** الفكرة أن يشارك المطور في مسؤولية تشغيل ما يكتبه، وأن يشارك فريق التشغيل في التصميم مبكراً، وليس أن تلغى المعرفة المتخصصة بالشبكات وقواعد البيانات والأمن.
- **DevOps لا يعني السرعة على حساب الأمان:** أبحاث DORA تبين أن الفرق الأفضل أداء تجمع السرعة والثبات معاً، لأن التغييرات الصغيرة المختبرة آلياً أقل خطراً من الكبيرة اليدوية، والمقاييس التي تقيس ذلك نشرحها في قسم القياس.

وإذا قرأت إعلاناً يطلب «مهندس DevOps» فالمقصود غالباً شخص يبني الأتمتة المشتركة، مثل خطوط CI/CD والبيئات والمراقبة، وهذا عمل مفيد ومهم، ولكن وجوده لا يعني أن الشركة طبقت DevOps إذا بقي المطورون لا يعرفون شيئاً عن تشغيل ما يكتبونه.

## المبادئ الثلاثة The Three Ways

أشهر طريقة لتلخيص أفكار DevOps هي «المبادئ الثلاثة The Three Ways» التي كتبها Gene Kim، أحد مؤلفي The Phoenix Project وThe DevOps Handbook، وشرحها في [مقال The Three Ways على موقع IT Revolution](https://itrevolution.com/articles/the-three-ways-principles-underpinning-devops/?ref=arabroot.io)، حيث يقول إن كل ممارسات DevOps تشتق منها. والصورة التالية تبين الثلاثة:

![ثلاثة صفوف: الأول التدفق Flow ويبين المطور ثم البناء والاختبار ثم النشر Deploy ثم الإنتاج Production ثم العميل بأسهم من اليمين إلى اليسار، والثاني التغذية الراجعة Feedback بسهم أخضر يعود من العميل إلى المطور عبر تنبيه Alert واختبار فشل في دقائق وملاحظة مراجعة Review، والثالث التعلم المستمر Continual Learning بدائرة بين مراجعة بلا لوم Blameless وتحسين في النظام](https://arabroot.io/content/images/2026/11/devops-intro-03-three-ways.webp)

العمل يتحرك إلى الأمام، والمعلومة تعود إلى الخلف، والفريق يتعلم من كل لفة

### المبدأ الأول: التدفق Flow

المبدأ الأول أن تنظر إلى الطريق كله من فكرة المطور إلى يد العميل، وليس إلى أداء كل قسم وحده، فقد يكون فريق التطوير سريعاً جداً في كتابة الكود، ولكن إذا كان الكود ينتظر أسبوعين في طابور الاختبار وأسبوعين في طابور النشر فسرعة المطورين لا قيمة لها للعميل. ولذلك يركز هذا المبدأ على أن يجعل العمل مرئياً، وأن يصغر حجم الدفعات، وأن يمنع العيوب من الانتقال إلى المرحلة التالية، وأن يزيل الانتظار بين المراحل، وأكثر الأدوات ارتباطاً به هي التكامل المستمر Continuous Integration والنشر المستمر Continuous Delivery، وهما موضوع [مقالات هذه المرحلة](https://arabroot.io/start/#stage-devops).

### المبدأ الثاني: التغذية الراجعة Feedback

المبدأ الثاني أن تعود المعلومة في الاتجاه المعاكس بسرعة، أي من الإنتاج ومن الاختبارات ومن الزملاء إلى من كتب الكود، فالمطور الذي يعرف بعد خمس دقائق أن تغييره أفشل اختباراً يصلحه وهو ما زال يتذكر ما كتب، أما الذي يعرف بعد ثلاثة أسابيع من رسالة غاضبة من عميل فيحتاج ساعات ليتذكر ما فعله ولماذا. ومن أمثلة التغذية الراجعة الاختبارات الآلية التي تعمل مع كل دفعة Push، ومراجعة الكود Code Review قبل الدمج، والمراقبة Monitoring والتنبيهات Alerts بعد النشر، وقد شرحنا المراقبة من البداية في [مفاهيم المراقبة Observability](https://arabroot.io/articles/%D9%85%D9%81%D8%A7%D9%87%D9%8A%D9%85-%D8%A7%D9%84%D9%85%D8%B1%D8%A7%D9%82%D8%A8%D8%A9-observability-%D9%85%D9%86-%D8%A7%D9%84%D8%A7%D8%B4%D8%A7%D8%B1%D8%A9-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D8%AA%D9%86%D8%A8%D9%8A%D9%87/).

### المبدأ الثالث: التعلم المستمر Continual Learning

المبدأ الثالث أن تبني ثقافة تجرب وتتعلم من الفشل، وأن تحول ما تعلمته إلى تحسين دائم في النظام، وليس إلى عقوبة لشخص. فعندما يتعطل الإنتاج يكون السؤال المفيد «ما الذي في نظامنا سمح لهذا الخطأ أن يصل إلى العملاء؟» وليس «من ضغط الزر؟»، والسبب أن الشخص الذي يخاف من العقوبة يخفي الأخطاء الصغيرة، فتتراكم حتى تصبح حادثة كبيرة لا يمكن إخفاؤها. وهذا ما تسميه Google مراجعة الحوادث بلا لوم Blameless Postmortem، وتشرحه في [فصل ثقافة مراجعة الحوادث في كتاب SRE](https://sre.google/sre-book/postmortem-culture/?ref=arabroot.io).

## حلقة DevOps من الفكرة إلى الإنتاج DevOps Lifecycle

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

![حلقة على شكل رقم ثمانية أفقي، نصفها الأزرق التطوير Dev وفيه التخطيط Plan والكود Code والبناء Build والاختبار Test، ونصفها البنفسجي التشغيل Ops وفيه الإطلاق Release والنشر Deploy والتشغيل Operate والمراقبة Monitor، وتحتها كل لفة صغيرة وسريعة وما تكتشفه المراقبة يعود إلى التخطيط](https://arabroot.io/content/images/2026/11/devops-intro-02-loop.webp)

ثماني مراحل في لفة واحدة، والهدف أن تصبح اللفة صغيرة وسريعة

والجدول التالي يبين ماذا يحدث في كل مرحلة، وما الذي يحولها من عمل يدوي إلى عمل آلي، وأين تجد شرحها في المسار:

| المرحلة          | ماذا يحدث فيها                                      | الممارسة التي تخدمها                         |
| ---------------- | --------------------------------------------------- | -------------------------------------------- |
| التخطيط Plan     | تحديد ما يبنى بعد ذلك، بمهام صغيرة واضحة            | مهام صغيرة، وما تكشفه المراقبة يدخل في الخطة |
| الكود Code       | كتابة الكود في فرع قصير ومراجعته                    | Git وطلبات الدمج Pull Requests ومراجعة الكود |
| البناء Build     | تحويل الكود إلى شيء يعمل: حزمة أو Docker Image      | بناء آلي في خط CI بنفس الطريقة في كل مرة     |
| الاختبار Test    | التأكد من أن التغيير لم يعطل شيئاً                  | اختبارات آلية تعمل مع كل Push                |
| الإطلاق Release  | تجهيز نسخة لها رقم ووسم Tag يمكن الرجوع إليها       | الإصدارات Versioning والوسوم في Git          |
| النشر Deploy     | وضع النسخة على السيرفرات                            | نشر آلي بأمر واحد أو من خط CD                |
| التشغيل Operate  | بقاء الخدمة تعمل: التحديثات والنسخ الاحتياطي والسعة | البنية كشيفرة IaC والنسخ الاحتياطي المختبر   |
| المراقبة Monitor | معرفة حالة الخدمة وما يواجهه المستخدمون             | المقاييس Metrics والسجلات Logs والتنبيهات    |

لاحظ أن الحلقة لا تقول من يقوم بكل مرحلة، والسبب أن هذا يختلف بين الفرق، فالمهم ألا ينقطع الطريق عند أي مرحلة بانتظار شخص واحد أو بانتقال من فريق إلى فريق دون معلومة، ولاحظ أيضاً أن الأدوات تظهر في العمود الأخير فقط، أي أنها وسيلة لكل مرحلة وليست الهدف.

## ماذا يحدث عندما يكون النشر يدوياً؟ حادثة Knight Capital

قد تبدو الأفكار السابقة كلاماً عاماً حتى ترى ما يحدث عندما تغيب، وأوضح مثال موثق على ذلك هو ما حدث لشركة Knight Capital الأمريكية للتداول في 1 أغسطس 2012، كما ورد في [بيان هيئة الأوراق المالية الأمريكية SEC](https://www.sec.gov/newsroom/press-releases/2013-222?ref=arabroot.io) و[قرارها التفصيلي](https://www.sec.gov/files/litigation/admin/2013/34-70694.pdf?ref=arabroot.io) في أكتوبر 2013.

📌

جهزت Knight كوداً جديداً لنظام توجيه الأوامر SMARS لبرنامج تداول جديد يبدأ في 1 أغسطس 2012، ونشرته على سيرفرات النظام يدوياً على مراحل بدءاً من 27 يوليو، ولكن أحد الفنيين لم ينسخ الكود الجديد إلى واحد من السيرفرات الثمانية، ولم يكن عند الشركة إجراء مكتوب يطلب أن يراجع فني ثان عملية النشر، فبقي على السيرفر الثامن كود قديم اسمه Power Peg توقف استخدامه منذ 2003\. وفي صباح يوم الإطلاق أرسل نظام داخلي 97 رسالة بريد إلكتروني تذكر الخطأ «Power Peg disabled» قبل افتتاح السوق، ولكنها لم تكن مصممة كتنبيهات ولم يتصرف بها أحد. وعندما افتتح السوق أعادت الأوامر الجديدة تشغيل الكود القديم على السيرفر الثامن، فأرسل النظام أكثر من 4 ملايين أمر خلال 45 دقيقة وهو يحاول تنفيذ 212 أمراً فقط للعملاء، وانتهى الأمر بخسارة تجاوزت 460 مليون دولار.

وإذا قرأت قرار SEC فسوف تجد أنه لا يلوم الفني الذي نسي السيرفر، وإنما يعدد ما كان غائباً في النظام: لا توجد ضوابط كافية لنشر الكود واختباره، ولا يوجد إجراء مكتوب يطلب مراجعة ثانية للنشر، ولا توجد طريقة تتحقق أن السيرفرات الثمانية تعمل بالنسخة نفسها، والرسائل التي كانت تكشف المشكلة لم تكن تنبيهات يراها من يجب أن يراها. وهذا بالضبط ما يقوله المبدأ الثالث: الخطأ البشري سوف يحدث دائماً، والسؤال هو هل يوجد في النظام ما يمسكه قبل أن يصل إلى العملاء. وقد كتب John Allspaw عن هذه الفكرة في مقاله [Each necessary, but only jointly sufficient](https://www.kitchensoap.com/2012/02/10/each-necessary-but-only-jointly-sufficient/?ref=arabroot.io)، حيث يشرح أن الحادثة الكبيرة لا يكون لها سبب واحد، وإنما عدة أسباب كل منها وحده لا يكفي.

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

## تجربة عملية: نشر يدوي مقابل سكربت نشر Deploy Script

سوف نبني على جهازك نسخة صغيرة من الموقف السابق: سيرفر Git لفريقك باستخدام [Gitea](https://arabroot.io/articles/%D8%AA%D8%AB%D8%A8%D9%8A%D8%AA-gitea-%D9%85%D8%B9-docker-compose/) يحفظ كود متجر صغير ووسوم إصداراته، وثلاثة سيرفرات ويب من nginx، وأمامها موزع طلبات Load Balancer يوزع زيارات العملاء عليها، وContainer رابع نسميه ops نعمل منه كما يعمل مسؤول النشر من جهازه. ثم ننشر إصداراً يدوياً وننسى سيرفراً، ونرى ماذا يراه العملاء، ثم نكتب سكربتاً صغيراً ينشر من وسم Git ويتحقق من كل سيرفر، ونرى ماذا يحدث عندما يتوقف سيرفر أثناء النشر. وكل ما تحتاجه هو Docker على جهازك، والصورة التالية تبين شكل المختبر بعد النشر اليدوي:

![العملاء يرسلون 30 طلباً إلى موزع الطلبات dvb-lb Load Balancer، الذي يوزعها على ثلاثة سيرفرات: dvb-web1 بالإصدار v1.1 والسعر مع الضريبة 15%، وdvb-web2 بالإصدار v1.1، وdvb-web3 باللون الأحمر بالإصدار القديم v1.0 والسعر القديم دون ضريبة، وفي الأسفل من 30 طلباً في التجربة 20 وصلت إلى v1.1 و10 إلى v1.0 أي عميل من كل ثلاثة](https://arabroot.io/content/images/2026/11/devops-intro-05-drift.webp)

شكل المختبر، والنتيجة الحقيقية بعد نشر يدوي نسي السيرفر الثالث

### تجهيز المختبر Lab Setup

نبدأ بشبكة Docker خاصة بالمختبر حتى تصل الـ Containers إلى بعضها بالاسم، ثم نشغل Gitea بقاعدة بيانات SQLite المدمجة، ونتجاوز صفحة التثبيت بالمتغير `INSTALL_LOCK` لأننا لا نحتاجها في مختبر، ثم ننشئ حساباً للفريق:

```bash
docker network create dvb-net

docker run -d --name dvb-gitea --network dvb-net -p 3471:3000 \
  -e GITEA__security__INSTALL_LOCK=true \
  -e GITEA__server__ROOT_URL=http://localhost:3471/ \
  -e GITEA__database__DB_TYPE=sqlite3 \
  -v dvb-gitea-data:/data gitea/gitea:28.3.0

docker exec -u git dvb-gitea gitea admin user create --admin \
  --username ops --password 'Lab-Pass-2026!' --email ops@example.com \
  --must-change-password=false
```

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

```text
New user 'ops' has been successfully created!
```

بعد ذلك نشغل ثلاثة سيرفرات ويب، وموزع الطلبات، وContainer العمليات ops، ونعطي الأخير أداة git وأداة docker حتى ينشر إلى السيرفرات. وموزع الطلبات هو nginx آخر بالإعداد التالي في الملف `lb.conf`:

```nginx
upstream shop {
    server dvb-web1:80;
    server dvb-web2:80;
    server dvb-web3:80;
}
server {
    listen 80;
    location / { proxy_pass http://shop; }
}
```

```bash
for n in 1 2 3; do
  docker run -d --name dvb-web$n --network dvb-net nginx:1.29-alpine
done

docker run -d --name dvb-lb --network dvb-net \
  -v "$PWD/lb.conf:/etc/nginx/conf.d/default.conf:ro" nginx:1.29-alpine

docker run -d --name dvb-ops --network dvb-net \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v "$PWD:/lab" -w /lab alpine:3.24 sleep infinity
docker exec dvb-ops apk add --no-cache git docker-cli curl
```

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

- السيرفرات الثلاثة نسخ متطابقة من nginx، ونسميها سيرفرات لأنها تمثل في المختبر ثلاثة أجهزة في الإنتاج، والنسخ إليها بالأمر `docker cp` يمثل النسخ إلى السيرفر بالأمر `scp` أو `rsync`.
- ربط `/var/run/docker.sock` داخل Container العمليات يعطيه تحكماً كاملاً في Docker على جهازك، وهذا مقبول في مختبر محلي فقط، ولا تقم به على سيرفر حقيقي والسبب أن من يملك هذا الملف يملك الجهاز، وقد شرحنا ذلك في [Gitea Actions](https://arabroot.io/articles/gitea-actions-%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-ci-cd-%D8%B9%D9%84%D9%89-%D8%AE%D8%A7%D8%AF%D9%85%D9%83/).
- لم ننشر أي منفذ Port للسيرفرات ولا لموزع الطلبات على جهازك، لأننا نصل إليها من داخل الشبكة `dvb-net` فقط.

الآن ننشئ المستودع `shop-web` في Gitea عبر الواجهة البرمجية API، ثم نكتب من Container العمليات الإصدار الأول من صفحة المتجر وهو يعرض الأسعار دون ضريبة، ثم الإصدار الثاني الذي يعرض الأسعار مع ضريبة القيمة المضافة 15%، ونضع لكل إصدار وسماً Tag، وندفع الكل إلى Gitea:

```bash
curl -s -u 'ops:Lab-Pass-2026!' -H 'Content-Type: application/json' \
  -X POST http://localhost:3471/api/v1/user/repos \
  -d '{"name":"shop-web","default_branch":"main"}'

docker exec -it dvb-ops sh
git config --global user.name "Ops Team"
git config --global user.email ops@example.com
git config --global init.defaultBranch main
mkdir -p /src/shop-web/site && cd /src/shop-web && git init -q
echo "<h1>Shop</h1><p>Prices without VAT</p>" > site/index.html
echo v1.0 > site/version.txt
git add . && git commit -qm "Shop page v1.0" && git tag v1.0
echo "<h1>Shop</h1><p>Prices include 15% VAT</p>" > site/index.html
echo v1.1 > site/version.txt
git commit -qam "Show prices with VAT" && git tag v1.1
git remote add origin http://dvb-gitea:3000/ops/shop-web.git
git push -q -u origin main --tags
git log --oneline --decorate
```

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

```text
5d1eb9e (HEAD -> main, tag: v1.1, origin/main) Show prices with VAT
aa32ee4 (tag: v1.0) Shop page v1.0
```

لاحظ أن كل إصدار له اسم ثابت هو الوسم، وأن كل وسم يشير إلى Commit محدد بالهاش، وأن الملف `version.txt` داخل الموقع يحمل اسم الإصدار نفسه، وهذا الملف الصغير هو ما سوف يجعلنا نعرف لاحقاً ماذا يعمل على كل سيرفر. وإذا كانت مفاهيم Commit والوسم والدفع جديدة عليك فقد شرحناها من البداية في [إدارة النسخ وGit للمبتدئين](https://arabroot.io/articles/%D8%A7%D8%AF%D8%A7%D8%B1%D8%A9-%D8%A7%D9%84%D9%86%D8%B3%D8%AE-%D9%88-git-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/).

### النشر اليدوي Manual Deploy: سيرفر منسي

نفرض الآن أن الإصدار v1.0 يعمل على السيرفرات الثلاثة، وجاء وقت نشر v1.1 الذي يعرض الأسعار مع الضريبة، والشخص المسؤول ينشر كما ينشر كثير من الفرق: يحضر الملفات على جهازه، ثم ينسخها إلى كل سيرفر بأمر منفصل. ولأن المختبر يجب أن يبين ما يحدث عندما تنسى خطوة، فقد نسخنا عمداً إلى السيرفرين الأول والثاني فقط، تماماً كما نسي فني Knight السيرفر الثامن:

```bash
cd /src/shop-web && git checkout -q v1.1
docker cp site/. dvb-web1:/usr/share/nginx/html/
docker cp site/. dvb-web2:/usr/share/nginx/html/
```

الأمران نجحا دون أي رسالة، ومن وجهة نظر من نفذهما فقد انتهى النشر. الآن نسأل كل سيرفر عن الإصدار الذي يعمل عليه بالسكربت الصغير `check.sh`:

```bash
#!/bin/sh
# Which version does each server answer with?
for s in $(cat servers.txt); do
  printf '%s ' "$s"; wget -qO- "http://$s/version.txt" 2>/dev/null || echo "unreachable"
done
```

والملف `servers.txt` فيه أسماء السيرفرات الثلاثة، سطر لكل سيرفر. وعند تشغيل السكربت سوف تجد ما يلي:

```text
dvb-web1 v1.1
dvb-web2 v1.1
dvb-web3 v1.0
```

هذا الانحراف Drift بين السيرفرات هو ما لم يكن أحد يراه في Knight، ولكن ماذا يرى العملاء؟ لنرسل 30 طلباً إلى موزع الطلبات ونعد الإصدارات التي تصل إليها:

```bash
for i in $(seq 30); do wget -qO- http://dvb-lb/version.txt; done | sort | uniq -c
```

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

```text
     10 v1.0
     20 v1.1
```

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

- ثلث الطلبات وصلت إلى الإصدار القديم، أي أن عميلاً من كل ثلاثة يرى أسعاراً دون ضريبة، وإذا حدث الصفحة فقد يرى السعر الآخر، وهذا أسوأ من أن يكون الموقع كله على الإصدار القديم، لأن العميل الذي يرى سعرين مختلفين للمنتج نفسه يفقد الثقة في المتجر، وفريق الدعم يتلقى شكاوى لا يستطيع إعادة إنتاجها لأن الموقع «يعمل عنده».
- في أول تجربة أرسلنا 6 طلبات فقط فوصل واحد منها إلى الإصدار القديم، وليس اثنان كما يتوقع من التوزيع بالتناوب Round Robin، والسبب أن nginx يعمل بعدة عمليات Worker Processes، وكل عملية تحفظ دور التوزيع الخاص بها، فلا تصل الطلبات إلى السيرفرات بالتساوي في عينة صغيرة. والدرس أن فحصاً سريعاً بطلبين أو ثلاثة من المتصفح قد لا يكشف المشكلة أصلاً.
- لم يفشل أي أمر ولم يظهر أي خطأ، فالمشكلة لا تكتشف إلا إذا سأل أحد السؤال الصحيح: ما الإصدار الذي يعمل على كل سيرفر الآن؟

### نشر من وسم Git Tag بسكربت يتحقق

الحل البسيط الأول الذي يخطر على البال هو قائمة خطوات مكتوبة في ملف، وهي أفضل من الذاكرة، ولكنها ما زالت تعتمد على أن ينفذ الإنسان كل سطر فيها بالترتيب دون أن يقاطعه أحد في منتصف الليل. والخطوة التالية أن تحول القائمة نفسها إلى سكربت، فالسكربت لا ينسى سيرفراً ولا يتعب، والأهم أنه يستطيع أن يتحقق من النتيجة بعد كل نشر. وهذا هو السكربت `deploy.sh`:

```bash
#!/bin/sh
# Deploy one Git tag of shop-web to every server in servers.txt, then check each one.
#   ./deploy.sh v1.1
set -eu
TAG="$1"
REPO="http://dvb-gitea:3000/ops/shop-web.git"
WORK="/tmp/release-$TAG"

rm -rf "$WORK"
git -c advice.detachedHead=false clone --quiet --depth 1 --branch "$TAG" "$REPO" "$WORK"
echo "release $TAG = commit $(git -C "$WORK" rev-parse --short HEAD)"

for s in $(cat servers.txt); do
  docker cp "$WORK/site/." "$s:/usr/share/nginx/html/"
  echo "copied to $s"
done

fail=0
for s in $(cat servers.txt); do
  got=$(docker exec "$s" cat /usr/share/nginx/html/version.txt 2>/dev/null || echo "unreachable")
  if [ "$got" = "$TAG" ]; then echo "ok   $s $got"; else echo "FAIL $s $got"; fail=1; fi
done

echo "$(date -u +%FT%TZ) $TAG $(git -C "$WORK" rev-parse --short HEAD) fail=$fail" >> deploy.log
exit $fail
```

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

- السكربت لا يأخذ الملفات من جهاز من ينشر، وإنما يستنسخ الوسم المطلوب من Gitea، وبالتالي فما ينشر هو بالضبط ما في المستودع تحت هذا الاسم، وليس نسخة على جهاز شخص فيها تعديل صغير لم يدفعه.
- قائمة السيرفرات في ملف واحد `servers.txt`، فإذا أضفت سيرفراً رابعاً أضفته في مكان واحد، ولا يمكن أن تنساه في خطوة وتتذكره في أخرى.
- الحلقة الثانية تتحقق من كل سيرفر بعد النسخ، والسكربت ينتهي برمز خروج Exit Code غير الصفر إذا اختلف أي سيرفر، وهذا الرمز هو ما سوف يجعل خط CI/CD لاحقاً يعرف أن النشر فشل.
- كل نشر يكتب سطراً في `deploy.log` فيه الوقت والوسم والـ Commit والنتيجة، فإذا سألك أحد «ماذا نشرنا أمس؟» فعندك الإجابة.

وعند أول تشغيل للسكربت ظهرت مشكلة حقيقية، فقد كان سطر الاستنساخ في البداية `git clone --quiet --depth 1 --branch "$TAG"` دون الخيار `advice.detachedHead`، فطبع Git فوق مخرج السكربت فقرة طويلة من خمسة عشر سطراً تبدأ هكذا:

```text
Note: switching to 'aa32ee4ed7db0a39820441ba7b7156660025eddb'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by switching back to a branch.
```

والسبب أن الاستنساخ على وسم وليس على فرع يجعل المستودع في حالة HEAD منفصل Detached HEAD، وGit ينبه المستخدم إلى ذلك حتى مع `--quiet` لأن التنبيه نصيحة Advice وليس رسالة تقدم. والرسالة لا تضر في هذه الحالة لأننا لن نكتب أي Commit في مجلد النشر، ولكن المشكلة الحقيقية أن مخرج النشر الذي يمتلئ بنصوص لا معنى لها يجعل من يقرؤه يتعود على تجاهله، فإذا ظهر فيه يوماً سطر خطأ مهم ضاع بين النصوص كما ضاعت رسائل Knight السبع والتسعون. لذلك أضفنا الخيار `-c advice.detachedHead=false` الذي يطفئ هذه النصيحة لهذا الأمر فقط، فأصبح المخرج قصيراً يقرأ في ثانية.

الآن ننشر v1.1 بالسكربت على السيرفرات الثلاثة، ثم نرسل 30 طلباً كما فعلنا قبل قليل:

```bash
./deploy.sh v1.1; echo "exit=$?"
for i in $(seq 30); do wget -qO- http://dvb-lb/version.txt; done | sort | uniq -c
```

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

```text
release v1.1 = commit 5d1eb9e
copied to dvb-web1
copied to dvb-web2
copied to dvb-web3
ok   dvb-web1 v1.1
ok   dvb-web2 v1.1
ok   dvb-web3 v1.1
exit=0
     30 v1.1
```

السطر الأول يربط اسم الإصدار بالـ Commit الذي نشر فعلاً، ثم ثلاثة أسطر للنسخ، ثم ثلاثة أسطر للتحقق، ورمز الخروج صفر، والطلبات الثلاثون كلها وصلت إلى v1.1، فالعملاء يرون سعراً واحداً. وفي Gitea تجد الوسوم في تبويب Releases ثم Tags، وكل وسم مع الهاش المختصر للـ Commit الخاص به، وهذا السجل هو المرجع الذي يقول ما الذي يمكن نشره وما الذي نشر:

![صفحة Tags في مستودع ops/shop-web على Gitea وفيها ثلاثة وسوم: v1.2 مع الهاش e4772e25f4، وv1.1 مع 5d1eb9e4ec، وv1.0 مع aa32ee4ed7، ولكل وسم رابطا تنزيل ZIP وTAR.GZ](https://arabroot.io/content/images/2026/11/devops-intro-04-gitea-tags.webp)

كل إصدار وسم ثابت في Gitea يشير إلى Commit محدد، والسكربت ينشر من هذا الاسم فقط

### ماذا يحدث إذا توقف سيرفر أثناء النشر؟ What If

السكربت السابق يعمل عندما يكون كل شيء سليماً، ولكن السؤال المهم في أي طريقة نشر هو ماذا يحدث عندما لا يكون كل شيء سليماً. لذلك أضفنا إصداراً ثالثاً v1.2 فيه شريط «توصيل مجاني» ودفعناه مع وسمه، ثم أوقفنا السيرفر الثاني كأنه تعطل، ثم نشرنا:

```bash
docker stop dvb-web2
./deploy.sh v1.2; echo "exit=$?"
for i in $(seq 30); do wget -qO- -T 3 http://dvb-lb/version.txt; done | sort | uniq -c
```

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

```text
release v1.2 = commit e4772e2
copied to dvb-web1
copied to dvb-web2
copied to dvb-web3
ok   dvb-web1 v1.2
FAIL dvb-web2 unreachable
ok   dvb-web3 v1.2
exit=1
wget: download timed out
wget: download timed out
...
     19 v1.2
```

وهذه النتيجة فيها ثلاث ملاحظات مهمة:

- **النسخ «نجح» إلى سيرفر متوقف:** السطر `copied to dvb-web2` ظهر مع أن السيرفر متوقف، والسبب أن `docker cp` يكتب في ملفات الـ Container حتى وهو متوقف، فالأمر لم يفشل. ومثل هذا يحدث في الواقع كثيراً، فأمر النسخ قد ينجح إلى سيرفر خدمته متوقفة أو إلى مجلد لا يقرأ منه التطبيق، ولذلك فنجاح خطوة النشر لا يثبت أن النشر نجح، وما يثبته هو سؤال الخدمة نفسها بعد النشر، وهذا ما فعلته الحلقة الثانية فأظهرت `FAIL` وأنهت السكربت بالرمز 1.
- **العملاء رأوا انتظاراً وليس إصداراً قديماً:** من 30 طلباً وصل 19 إلى v1.2، وانتهى 11 بانتهاء المهلة Timeout بعد 3 ثوان، والسبب أن موزع الطلبات ما زال يرسل جزءاً من الطلبات إلى عنوان السيرفر المتوقف، وينتظر الاتصال حتى تنتهي مهلة العميل. وهذا يعني أن موزع الطلبات يحتاج إلى فحص صحة Health Check يخرج السيرفر المعطل من التوزيع، وهو موضوع [مفاهيم التوفر العالي](https://arabroot.io/articles/%D9%85%D9%81%D8%A7%D9%87%D9%8A%D9%85-%D8%A7%D9%84%D8%AA%D9%88%D9%81%D8%B1-%D8%A7%D9%84%D8%B9%D8%A7%D9%84%D9%8A-high-availability-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/).
- **السجل يحفظ الفشل:** الملف `deploy.log` أصبح فيه ثلاثة أسطر، والثالث يقول `fail=1`، فمن يأتي في الصباح يعرف أن آخر نشر لم يكتمل دون أن يسأل أحداً.

```text
2026-11-03T09:33:39Z v1.0 aa32ee4 fail=0
2026-11-03T09:34:50Z v1.1 5d1eb9e fail=0
2026-11-03T09:35:07Z v1.2 e4772e2 fail=1
```

وبعد إعادة تشغيل السيرفر الثاني بالأمر `docker start dvb-web2` أعدنا تشغيل السكربت نفسه بالوسم نفسه، فظهرت الأسطر الثلاثة `ok` ورمز الخروج صفر، ووصلت الطلبات الثلاثون كلها إلى v1.2\. وهذه خاصية مهمة اسمها التكرار الآمن Idempotency، أي أن تشغيل النشر نفسه مرتين يعطي النتيجة نفسها، فإذا فشل النشر في منتصفه لا تحتاج إلى خطوات خاصة لإصلاحه، وإنما تصلح السبب وتعيد التشغيل.

### ما الذي تعلمناه من المختبر؟ Lessons

هذا السكربت ليس خط CI/CD، وما زال ينقصه الكثير: لا يبني ولا يختبر، ويعمل من جهاز شخص، ويتطلب أن يتذكر أحد تشغيله. ولكنه يبين في أربعين سطراً فكرة DevOps الأساسية في النشر:

- مصدر الحقيقة Source of Truth هو المستودع، والإصدار اسم ثابت فيه، وليس مجلداً على جهاز أحد.
- كل خطوة تتكرر تكتب مرة واحدة وتنفذ بالطريقة نفسها في كل مرة، فلا تعتمد على ذاكرة شخص.
- النشر لا ينتهي بالنسخ، وإنما بالتحقق من أن كل سيرفر يعمل بما هو مطلوب، وبرمز خروج واضح عند الفشل.
- كل نشر يترك أثراً يقرؤه الآخرون، ومخرجه قصير وواضح حتى لا يتعود أحد على تجاهله.

وفي مقال [CI/CD للمبتدئين](https://arabroot.io/start/#stage-devops) من هذه المرحلة سوف ننقل الفكرة نفسها إلى خط آلي في Gitea Actions يبني ويختبر وينشر مع كل دفعة Push، دون أن يحتاج أحد إلى تشغيل سكربت من جهازه، أما تاريخ طرق النشر كلها من FTP إلى GitOps فقد شرحناه في [طرق نشر التطبيقات](https://arabroot.io/articles/%D8%B7%D8%B1%D9%82-%D9%86%D8%B4%D8%B1-%D8%A7%D9%84%D8%AA%D8%B7%D8%A8%D9%8A%D9%82%D8%A7%D8%AA-%D9%85%D9%86-ftp-%D8%A7%D9%84%D9%89-gitops/).

### التنظيف Cleanup

عند الانتهاء احذف كل ما أنشأته التجربة، والـ Volume الخاص بـ Gitea معها:

```bash
docker rm -f dvb-gitea dvb-web1 dvb-web2 dvb-web3 dvb-lb dvb-ops
docker volume rm dvb-gitea-data
docker network rm dvb-net
```

## الممارسات الأساسية Core Practices

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

![سبعة أعمدة متدرجة من اليمين إلى اليسار: إدارة النسخ Version Control كل شيء في Git، ثم مراجعة الكود Code Review عينان على كل تغيير، ثم التكامل المستمر CI بناء واختبار مع كل Push، ثم النشر المستمر CD نشر بسكربت أو خط آلي، ثم المراقبة Monitoring تعرف قبل العميل، ثم مراجعة الحوادث Postmortem بلا لوم، ثم البنية كشيفرة IaC السيرفر من ملف، وسهم في الأسفل من تبدأ من هنا إلى ثم تكبر مع الفريق](https://arabroot.io/content/images/2026/11/devops-intro-06-practices.webp)

كل ممارسة تبنى على ما قبلها، فلا معنى لخط CI إذا لم يكن الكود كله في Git

- **إدارة النسخ Version Control:** الكود والإعدادات وسكربتات النشر وملفات البنية كلها في Git، وليس الكود فقط، فلا يوجد شيء في الإنتاج لا تعرف من أين جاء، وهذه من الممارسات التي تربطها DORA مباشرة بالأداء كما في صفحة [Version Control](https://dora.dev/capabilities/version-control/?ref=arabroot.io). وإذا كنت تبدأ من الصفر فابدأ بمقال [أول مستودع لك](https://arabroot.io/start/#stage-git) في مرحلة Git.
- **مراجعة الكود Code Review:** لا يدخل تغيير إلى الفرع الرئيسي قبل أن يقرأه شخص آخر، وهذا يحقق ما غاب في Knight، أي شخص ثان يرى التغيير قبل الإنتاج، ومعه تنتقل المعرفة بين أعضاء الفريق.
- **التكامل المستمر Continuous Integration:** كل دفعة إلى المستودع تبنى وتختبر آلياً خلال دقائق، فيعرف المطور أن تغييره أفشل شيئاً وهو ما زال يتذكر ما كتب، والتطبيق العملي على سيرفرك في [Gitea Actions](https://arabroot.io/articles/gitea-actions-%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-ci-cd-%D8%B9%D9%84%D9%89-%D8%AE%D8%A7%D8%AF%D9%85%D9%83/).
- **النشر المستمر Continuous Delivery:** كل نسخة نجحت في الاختبارات جاهزة للنشر بأمر واحد أو تنشر تلقائياً، كما في [أتمتة النشر Deployment Automation](https://dora.dev/capabilities/deployment-automation/?ref=arabroot.io)، ومع البيئات المختلفة مثل staging والإنتاج كما في [البيئات وGitOps](https://arabroot.io/articles/%D8%A7%D9%84%D8%A8%D9%8A%D8%A6%D8%A7%D8%AA-%D9%88%D9%85%D8%B9%D8%A7%D9%8A%D9%86%D8%A9-%D8%A7%D9%84%D9%85%D9%8A%D8%B2%D8%A7%D8%AA-%D9%88-gitops-%D9%84%D9%84%D9%81%D8%B1%D9%82/).
- **المراقبة Monitoring:** تعرف بأن الخدمة تعطلت قبل أن يتصل بك العميل، وتعرف بعد كل نشر هل تغير شيء في الأخطاء أو في سرعة الاستجابة، والمرجع الكامل في [دليل المراقبة](https://arabroot.io/articles/%D8%AF%D9%84%D9%8A%D9%84-%D8%A7%D9%84%D9%85%D8%B1%D8%A7%D9%82%D8%A8%D8%A9-monitoring-%D9%85%D8%A7%D8%B0%D8%A7-%D8%AA%D8%B1%D8%A7%D9%82%D8%A8-%D9%81%D9%8A-%D8%B3%D9%8A%D8%B1%D9%81%D8%B1%D8%A7%D8%AA%D9%83-%D9%88%D8%AA%D8%B7%D8%A8%D9%8A%D9%82%D8%A7%D8%AA%D9%83/).
- **مراجعة الحوادث Postmortem:** بعد كل عطل مهم يكتب الفريق ما حدث وما الذي سمح به وما الذي سوف يتغير، دون البحث عن شخص يلام.
- **البنية كشيفرة Infrastructure as Code:** السيرفرات وإعداداتها تكتب في ملفات داخل Git، فيصبح السيرفر الجديد نسخة مطابقة في دقائق، ولا يحدث انحراف كالذي رأيناه في المختبر، والمفاهيم في [البنية كشيفرة IaC للمبتدئين](https://arabroot.io/articles/%D8%A7%D9%84%D8%A8%D9%86%D9%8A%D8%A9-%D9%83%D8%B4%D9%8A%D9%81%D8%B1%D8%A9-iac-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/).

وقد يتساءل البعض: لماذا وضعنا البنية كشيفرة في آخر القائمة وهي من أشهر ما يقال عن DevOps؟ والإجابة أن الفريق الذي يملك سيرفرين ولا يملك اختبارات آلية ولا مراقبة سوف يستفيد من الاختبارات والمراقبة أكثر بكثير من Terraform، وأن كتابة البنية في ملفات تفيد أكثر عندما يكون عندك ما يكفي من السيرفرات والبيئات لكي يظهر الانحراف بينها.

## الثقافة Culture: ما الذي يتغير في سلوك الفريق؟

إذا طبقت كل الممارسات السابقة وبقيت الثقافة كما هي فسوف تعود المشكلة بأدوات أحدث، فخط CI الذي يفشل كل يوم ويتجاهله الجميع لا يفيد، والمراقبة التي لا ينظر إليها أحد لا تفيد، ومراجعة الكود التي يوافق فيها المراجع دون أن يقرأ لا تفيد. ولذلك فالسؤال الحقيقي هو كيف يتصرف الناس، وفيما يلي أهم ما يتغير:

- **المسؤولية المشتركة Shared Ownership:** المطور يهتم بما يحدث لكوده بعد النشر، فيرى المقاييس والسجلات ويشارك في المناوبة On-call على الأقل لخدمته، وفريق التشغيل يشارك في التصميم مبكراً ويقول رأيه في ما يصعب تشغيله قبل أن يكتب، وقد ناقشنا من يتحمل المسؤولية عند العطل في [من يتحمل المسؤولية عندما يتعطل الإنتاج؟](https://arabroot.io/articles/%D9%85%D9%86-%D9%8A%D8%AA%D8%AD%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%B3%D8%A4%D9%88%D9%84%D9%8A%D8%A9-%D8%B9%D9%86%D8%AF%D9%85%D8%A7-%D9%8A%D8%AA%D8%B9%D8%B7%D9%84-%D8%A7%D9%84%D8%A7%D9%86%D8%AA%D8%A7%D8%AC/).
- **اللوم يغلق باب التعلم:** عندما يعاقب من يعترف بالخطأ يتعلم الجميع أن يخفوا الأخطاء، وأبحاث DORA تربط الثقافة التي يسميها Ron Westrum «الثقافة المولدة Generative Culture»، حيث تتدفق المعلومات بحرية ويتعلم الفريق من الفشل، بأداء أفضل في التسليم وفي رضا الفريق، كما في صفحة [Generative Organizational Culture](https://dora.dev/capabilities/generative-organizational-culture/?ref=arabroot.io).
- **الشفافية Transparency:** لوحات المراقبة وحالة خط CI وسجل النشر يراها الجميع، وليس فريقاً واحداً، فلا يحتاج أحد إلى أن يسأل «هل نشرتم شيئاً اليوم؟».
- **إزالة العمل اليدوي المتكرر Toil:** كل مهمة يدوية تتكرر كل أسبوع هي فرصة للأتمتة، والفريق يخصص لها وقتاً من عمله وليس في وقت فراغ لا يأتي.

وهل هذا يعني أن الثقافة تتغير بقرار من المدير؟ لا، والتفصيل أن الثقافة تتغير بالممارسة نفسها أكثر مما تتغير بالكلام، فالفريق الذي يكتب أول مراجعة حادثة بلا لوم ويرى أن الشخص الذي أخطأ لم يعاقب، وإنما تغير النظام بسبب ما كتبه، سوف يكتب المراجعة التالية بصدق أكبر. وقد ناقشنا الجانب الشخصي من ذلك في [حين يلومك الفريق على عطل لم تسببه](https://arabroot.io/articles/%D8%AD%D9%8A%D9%86-%D9%8A%D9%84%D9%88%D9%85%D9%83-%D8%A7%D9%84%D9%81%D8%B1%D9%8A%D9%82-%D8%B9%D9%84%D9%89-%D8%B9%D8%B7%D9%84-%D9%84%D9%85-%D8%AA%D8%B3%D8%A8%D8%A8%D9%87/).

## كيف تعرف أنك تتحسن؟ مقاييس DORA Metrics

بدلاً من أن تسأل «هل نحن DevOps؟» وهو سؤال لا جواب له، اسأل أسئلة لها أرقام. وأشهر هذه الأسئلة [مقاييس DORA](https://dora.dev/guides/dora-metrics-four-keys/?ref=arabroot.io)، وهي اليوم خمسة، ثلاثة منها تقيس السرعة Throughput واثنان تقيس الثبات Instability:

| المقياس                                                 | ماذا يقيس                                                   | من أين تأخذه في فريق صغير                |
| ------------------------------------------------------- | ----------------------------------------------------------- | ---------------------------------------- |
| زمن التغيير Change Lead Time                            | الوقت من دخول التغيير إلى Git حتى وصوله إلى الإنتاج         | وقت ال Commit ووقت النشر في سجل النشر    |
| تكرار النشر Deployment Frequency                        | عدد مرات النشر في فترة معينة                                | عدد أسطر سجل النشر في الأسبوع            |
| زمن التعافي من نشر فاشل Failed Deployment Recovery Time | الوقت حتى تعود الخدمة بعد نشر يحتاج تدخلاً فورياً           | من وقت النشر الفاشل حتى النشر الذي أصلحه |
| نسبة فشل التغييرات Change Fail Rate                     | نسبة النشرات التي احتاجت تدخلاً فورياً بعدها                | النشرات التي تبعها تراجع أو إصلاح عاجل   |
| نسبة إعادة النشر Deployment Rework Rate                 | نسبة النشرات غير المخطط لها التي جاءت بسبب حادثة في الإنتاج | النشرات التي سببها عطل وليس خطة          |

لاحظ أن الملف `deploy.log` في المختبر، رغم بساطته، يكفي لحساب أول مقياسين تقريباً، فكل سطر فيه وقت ووسم ونتيجة، ومن وقت ال Commit في Git تعرف كم انتظر التغيير قبل أن ينشر. ولا تقم بتحويل هذه المقاييس إلى أهداف يقيم بها الأفراد، والسبب أن الناس سوف يحسنون الرقم بدلاً من العمل، فالفريق الذي يقاس بعدد النشرات سوف ينشر تغييرات فارغة، والمقاييس وجدت لكي يرى الفريق أين يتعطل طريقه، وقد شرحناها بتفصيل أكبر في [مقاييس DORA](https://arabroot.io/articles/%D8%A7%D9%84%D9%81%D8%B1%D9%82-%D8%A8%D9%8A%D9%86-devops-%D9%88-sre-%D9%88-platform-engineering/#dora).

## من أين يبدأ فريق صغير؟ First Steps

إذا كان فريقك اليوم يشبه المشهد في أول المقال فلا تبدأ بمشروع كبير اسمه «التحول إلى DevOps»، وإنما بخطوات صغيرة كل واحدة منها تزيل ألماً تعرفه، وهذا ترتيب نقترحه لفريق من ثلاثة إلى عشرة أشخاص:

1. **الأسبوع الأول:** ضع كل الكود وملفات الإعداد بدون أسرار وسكربتات النشر في Git، على سيرفر [Gitea](https://arabroot.io/articles/%D8%AA%D8%AB%D8%A8%D9%8A%D8%AA-gitea-%D9%85%D8%B9-docker-compose/) خاص بالفريق أو على منصة مستضافة، وتأكد أن ما يعمل في الإنتاج له وسم في المستودع.
2. **الأسبوع الثاني:** اكتب خطوات النشر الحالية كما هي في ملف، ثم حولها إلى سكربت واحد مثل الذي في المختبر، مع التحقق في آخره، حتى لو بقي تشغيله يدوياً.
3. **الأسبوع الثالث:** اتفق مع الفريق أن لا يدخل شيء إلى الفرع الرئيسي دون طلب دمج يراجعه شخص آخر، واجعل الطلبات صغيرة.
4. **الشهر الثاني:** شغل الاختبارات الموجودة، حتى لو كانت قليلة، آلياً مع كل دفعة Push، ثم اجعل السكربت ينشر من الخط نفسه إلى بيئة staging.
5. **الشهر الثالث:** أضف فحصاً من الخارج يتأكد أن الموقع يعمل، وتنبيهاً يصل إلى شخص مناوب، واكتب أول مراجعة حادثة بلا لوم عند أول عطل.

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

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

- **شراء الأداة قبل فهم المشكلة:** فريق يبدأ بتثبيت Kubernetes لأن الجميع يتحدث عنه، وهو لا يملك اختبارات آلية ولا يعرف كم يأخذ النشر الآن، والنتيجة نظام أعقد ينشر بنفس البطء، فابدأ بقياس الطريق الحالي ثم اختر الأداة التي تزيل أبطأ نقطة فيه.
- **تعيين «شخص DevOps» واحد:** يصبح هذا الشخص هو الجدار الجديد، فكل نشر ينتظره، وكل معرفة في رأسه، وإذا أخذ إجازة توقف كل شيء، والأفضل أن يبني هذا الشخص أدوات يستخدمها الفريق بنفسه، وأن يعرف شخصان على الأقل كل جزء.
- **الأتمتة دون تحقق:** سكربت ينسخ ولا يتحقق أخطر أحياناً من اليدوي، لأنه يعطيك ثقة لا يستحقها، كما رأيت في المختبر عندما «نجح» النسخ إلى سيرفر متوقف.
- **تجاهل الخط الأحمر:** عندما يفشل خط CI كل يوم لأسباب غير مهمة يتعلم الفريق أن اللون الأحمر طبيعي، فإذا جاء فشل حقيقي لم ينتبه له أحد، فأصلح الاختبارات المتقلبة أو احذفها بدلاً من التعود عليها.
- **نسخ ممارسات الشركات الكبيرة كما هي:** ما تفعله Google بآلاف المهندسين لا يناسب فريقاً من خمسة، فخذ الفكرة واترك الحجم.
- **ترك الكود الميت في الإنتاج:** الميزة التي توقف استخدامها ما زالت كوداً يمكن أن يعمل بالخطأ، كما حدث مع Power Peg في Knight بعد تسع سنوات من توقفه، فاحذف ما لا تستخدمه، وأزل مفاتيح Feature Flags القديمة بعد انتهاء الحاجة إليها.

## قائمة تحقق Checklist

استخدم الأسئلة التالية لتعرف أين يقف فريقك الآن، وكل إجابة «لا» هي خطوتك التالية:

| السؤال                                                | إذا كانت الإجابة لا                    |
| ----------------------------------------------------- | -------------------------------------- |
| هل كل ما يعمل في الإنتاج موجود في Git مع وسم للإصدار؟ | ابدأ من إدارة النسخ ووسوم الإصدارات    |
| هل يستطيع شخصان على الأقل في الفريق أن ينشرا إصداراً؟ | اكتب النشر في سكربت يعمل لأي شخص       |
| هل يتحقق النشر من كل سيرفر بعد أن ينتهي؟              | أضف خطوة تحقق ورمز خروج كما في المختبر |
| هل يراجع شخص آخر كل تغيير قبل أن يدمج؟                | اتفق على طلبات الدمج ومراجعة الكود     |
| هل تعمل الاختبارات آلياً مع كل دفعة Push؟             | شغل خط CI ولو باختبار واحد             |
| هل تعرف بالعطل قبل أن يخبرك العميل؟                   | أضف فحصاً من الخارج وتنبيهاً           |
| هل تستطيع أن تقول متى نشرت آخر مرة وماذا نشرت؟        | احفظ سجلاً لكل نشر                     |
| هل تكتب مراجعة لكل عطل مهم دون البحث عن شخص يلام؟     | اكتب أول مراجعة عند أول عطل قادم       |

## ماذا تقرأ بعد ذلك؟ Next Steps

هذا المقال هو بداية المرحلة، والمقالات التالية تأخذ كل ممارسة وحدها بتجربة عملية، وأقرب ما يفيدك الآن:

[![](https://arabroot.io/content/images/2026/10/git-basics-cover-cover.webp)دليلإدارة النسخ وGit للمبتدئين: لماذا نحتاجها وكيف تعمللماذا تضيع الملفات بأسماء final\_v2 ويمسح الزملاء عمل بعضهم، وكيف يحل Git ذلك على مشروع حقيقي من أول commit.](https://arabroot.io/articles/%D8%A7%D8%AF%D8%A7%D8%B1%D8%A9-%D8%A7%D9%84%D9%86%D8%B3%D8%AE-%D9%88-git-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/)[![](https://arabroot.io/content/images/2026/10/gitea-cover-cover.webp)دليلGitea: خادم Git خاص لفريقك على سيرفرككيف تثبت Gitea على سيرفرك حتى يبقى كود فريقك عندك بتجربة تشبه GitHub، مع النسخ الاحتياطي والتحديث.](https://arabroot.io/articles/%D8%AA%D8%AB%D8%A8%D9%8A%D8%AA-gitea-%D9%85%D8%B9-docker-compose/)[![](https://arabroot.io/content/images/2026/10/gitea-actions-cover-cover-2.webp)دليلGitea Actions: تشغيل CI/CD وبناء Docker Images على سيرفركاجعل سيرفرك يختبر الكود ويبني Docker Images تلقائياً مع كل push، دون أن يخرج كودك أو أسرارك إلى خدمة CI خارجية.](https://arabroot.io/articles/gitea-actions-%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-ci-cd-%D8%B9%D9%84%D9%89-%D8%AE%D8%A7%D8%AF%D9%85%D9%83/)[![](https://arabroot.io/content/images/2026/10/deployment-history-cover-cover.webp)دليلطرق نشر التطبيقات من FTP إلى GitOps، وأين تقف أنتكيف تطور نشر التطبيقات عبر السنين، وما الذي يتعطل في كل طريقة، وكيف تعرف أين تقف وما خطوتك التالية.](https://arabroot.io/articles/%D8%B7%D8%B1%D9%82-%D9%86%D8%B4%D8%B1-%D8%A7%D9%84%D8%AA%D8%B7%D8%A8%D9%8A%D9%82%D8%A7%D8%AA-%D9%85%D9%86-ftp-%D8%A7%D9%84%D9%89-gitops/)[![](https://arabroot.io/content/images/2026/10/environments-gitops-cover-cover.webp)دليلمن الفرع إلى الإنتاج: البيئات وGitOps للفرقكيف يختبر فريقك كل ميزة وحدها ويعرضها على العميل دون أن تصل ميزة غير جاهزة إلى الإنتاج.](https://arabroot.io/articles/%D8%A7%D9%84%D8%A8%D9%8A%D8%A6%D8%A7%D8%AA-%D9%88%D9%85%D8%B9%D8%A7%D9%8A%D9%86%D8%A9-%D8%A7%D9%84%D9%85%D9%8A%D8%B2%D8%A7%D8%AA-%D9%88-gitops-%D9%84%D9%84%D9%81%D8%B1%D9%82/)[![](https://arabroot.io/content/images/2026/10/platform-sre-devops-cover-cover.webp)دليلDevOps وSRE وهندسة المنصات: أين يلتقي كل منها؟ما الذي يعنيه كل مصطلح فعلاً، وكيف تحسب ميزانية الأخطاء، وما شكل الفريق المناسب لحجم شركتك.](https://arabroot.io/articles/%D8%A7%D9%84%D9%81%D8%B1%D9%82-%D8%A8%D9%8A%D9%86-devops-%D9%88-sre-%D9%88-platform-engineering/)

ابدأ بـ [إدارة النسخ وGit للمبتدئين](https://arabroot.io/articles/%D8%A7%D8%AF%D8%A7%D8%B1%D8%A9-%D8%A7%D9%84%D9%86%D8%B3%D8%AE-%D9%88-git-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/) إذا كان Git جديداً عليك، ثم [تثبيت Gitea](https://arabroot.io/articles/%D8%AA%D8%AB%D8%A8%D9%8A%D8%AA-gitea-%D9%85%D8%B9-docker-compose/) ليكون للفريق سيرفر Git خاص، ثم [Gitea Actions](https://arabroot.io/articles/gitea-actions-%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-ci-cd-%D8%B9%D9%84%D9%89-%D8%AE%D8%A7%D8%AF%D9%85%D9%83/) لتشغيل أول خط CI/CD، وإذا أردت أن ترى الطريق كله بمراحله فافتح [مرحلة DevOps والنشر المستمر في خارطة الطريق](https://arabroot.io/start/#stage-devops).

## الخلاصة Summary

- ظهر DevOps لأن فريق التطوير وفريق التشغيل كانا يعملان بهدفين متعاكسين، فأصبح النشر نادراً وكبيراً ومؤلماً، وأصبح كل عطل نقاشاً عن المسؤول.
- DevOps طريقة عمل تجعل من يبني ومن يشغل فريقاً واحداً، وتلخصها المبادئ الثلاثة: التدفق، والتغذية الراجعة، والتعلم المستمر، والأدوات وسيلة لتطبيقها وليست هي.
- حادثة Knight Capital تبين أن الخطأ البشري سوف يحدث، وأن السؤال هو هل في النظام ما يمسكه: نشر آلي، وتحقق بعد النشر، وتنبيهات يراها أحد، ومراجعة ثانية.
- في المختبر وصل ثلث الطلبات إلى الإصدار القديم بعد نشر يدوي نسي سيرفراً، وأصلح ذلك سكربت ينشر من وسم Git ويتحقق من كل سيرفر، وكشف السكربت نفسه أن النسخ قد «ينجح» إلى سيرفر متوقف.
- ابدأ بخطوات صغيرة بالترتيب: Git، ثم سكربت نشر يتحقق، ثم مراجعة الكود، ثم CI، ثم المراقبة ومراجعة الحوادث، وقس تقدمك بمقاييس DORA دون أن تحولها إلى أداة لتقييم الأفراد.

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

- نوفمبر 2026: كتابة المقال واختبار التجربة على Gitea 28.3.0 وnginx 1.29.8 وAlpine 3.24.3 مع git 2.54.0.