Software Architecture

لأكثر من عقد من الزمان، ساد Spring Boot باعتباره المعيار الفعلي لبناء تطبيقات Java للمؤسسات. إن نظامها البيئي الغني، ونموذج الاتفاقية فوق التكوين، ومحرك حقن التبعية القوي، والدعم المجتمعي الواسع، جعل من Java حجر الأساس للأنظمة الخلفية في جميع أنحاء العالم. ومع ذلك، فإن التحول نحو البنيات السحابية الأصلية، وتنسيق Kubernetes، وحاويات Docker، والتنفيذ بدون خادم (AWS Lambda، Knative) قد أدى إلى ظهور تحديات تقنية جديدة للبنية التحتية الخلفية: كفاءة الذاكرة، والتوسع الفوري، وزمن الوصول البارد.

منذ ما يقرب من ثلاثة عقود، كانت Java هي القوة المهيمنة في تطوير برمجيات المؤسسات. إن نظامها البيئي الغني، وأساسها القوي الموجه للكائنات، واستقلال النظام الأساسي عبر Java Virtual Machine (JVM)، والأطر التي تم اختبارها في المعركة مثل Spring Boot، جعلها ملك البنية التحتية الخلفية بلا منازع. ومع ذلك، فإن التحول نحو البنى السحابية الأصلية، تنسيق Kubernetes، الحاويات (Docker)، والحوسبة بدون خادم (AWS Lambda، Knative) كشف عن ثغرة أمنية خطيرة في أطر عمل تطبيقات Java التقليدية: عبء كبير للذاكرة وأوقات بدء تشغيل بطيئة.

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

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

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

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

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

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

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

في البنية المتجانسة، تتواصل المكونات عبر استدعاءات الأسلوب داخل الذاكرة، والتي تكون فورية وموثوقة للغاية. ومع ذلك، عند الانتقال إلى بنية الخدمات الصغيرة، يتم فصل هذه المكونات بحدود الشبكة. يصبح الاتصال عبارة عن مكالمة شبكة خارج العملية (Inter-Process Communication أو IPC). لسنوات، كان REST (نقل الحالة التمثيلية) عبر HTTP/1.1 مع حمولات JSON هو المعيار الافتراضي لإنشاء واجهات برمجة تطبيقات الويب. على الرغم من أن REST يعد ممتازًا لخدمات الويب العامة والتفاعل بين العميل والخادم، إلا أنه يقدم اختناقات كبيرة عند استخدامه للاتصالات الداخلية بين الخدمات ذات التردد العالي وزمن الوصول المنخفض.

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

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

في هندسة البرمجيات الحديثة، لم يعد بناء التطبيقات التي يمكنها أداء مهام متعددة في وقت واحد ترفًا، بل أصبح متطلبًا أساسيًا. بدءًا من خوادم الويب عالية الإنتاجية ووصولاً إلى خدمات البث في الوقت الفعلي، يقع التزامن في قلب الأداء. لعقود من الزمن، اعتمدت لغات البرمجة التقليدية مثل C++ وJava وPython على نماذج الترابط الأصلية لنظام التشغيل للتعامل مع المهام المتزامنة. ومع ذلك، عندما صممت Google Go (Golang) في أواخر العقد الأول من القرن الحادي والعشرين، اتخذت مسارًا مختلفًا جذريًا. بدلاً من الكشف عن سلاسل عمليات نظام التشغيل الأولية، قدم Go Goroutines وM:N Scholer المتخصص.

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