ما هي البنية التحتية الخلفية؟

اختيار البنية التحتية المناسبة للواجهة الخلفية أمر بالغ الأهمية عند تصميم الواجهة الخلفية الخاصة بك. يمكن أن يؤثر على أداء الواجهة الخلفية ومرونتها وقابليتها للصيانة، على سبيل المثال لا الحصر.

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

بالإضافة إلى ذلك، سنلقي نظرة على كيفية إنشاء بنية تحتية خلفية باستخدام Back4app.

الأهداف

بحلول نهاية هذا المقال، ستكون قادراً على:

• شرح ما هي البنية التحتية الخلفية
• مناقشة أنواع مختلفة من البنى التحتية الخلفية (بما في ذلك IaaS وPaaS وBaaS)
• اختر البنية التحتية الخلفية المناسبة لمشروعك
• أنشئ الواجهة الخلفية الخاصة بك باستخدام Back4app

ما هي البنية التحتية الخلفية؟

البنية التحتية للواجهة الخلفية هي مزيج من مكونات البرامج والأجهزة التي تدعم نظام الواجهة الخلفية. ويشمل ذلك الخوادم والحاويات ومكونات الشبكات وجدار الحماية والموارد الأخرى.

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

ما الذي يجب مراعاته عند اختيار البنية التحتية الخلفية؟

دعونا نناقش العوامل الأساسية التي يجب مراعاتها عند اختيار البنية التحتية الخلفية.

السرعة

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

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

السرعة هي أيضًا أحد أهم العوامل الحاسمة في تحسين محركات البحث.

المرونة

تشير المرونة إلى لغات البرمجة وأطر العمل والتقنيات الأخرى (مثل قواعد البيانات) التي تدعمها البنية التحتية للواجهة الخلفية. عند اختيار البنية التحتية للواجهة الخلفية، تأكد من اختيار شيء يدعم مجموعة متنوعة من التقنيات.

قابلية التوسع

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

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

قابلية الصيانة

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

اختر بنية تحتية خلفية مزودة بنظام CI/CD مدمج، أو قم بتنفيذ البنية التحتية الخاصة بك.

متطلبات DevOps

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

الأمن

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

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

أنواع البنية التحتية الخلفية

يمكنك استخدام الخوادم الخاصة بك (ما يسمى بالبنية التحتية التقليدية) أو الاستفادة من البنية التحتية السحابية لنشر الواجهة الخلفية.

في العقد الماضي، تحولت العديد من الشركات نحو النماذج السحابية لأنها تتيح لها توفير الوقت والمال.

دعنا نحلل بعضاً من أكثرها شيوعاً.

البنية التحتية كخدمة أو IaaS

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

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

المنصة كخدمة أو PaaS

النظام الأساسي كخدمة (PaaS) هو نموذج حوسبة سحابية يوفر بيئة سهلة الاستخدام لتطوير التطبيقات وإدارتها وتسليمها. وهي تتضمن العديد من أدوات تطوير التطبيقات المدمجة، مما يجعل من السهل إعداد تطبيقك وتشغيله.

تعمل البنية التحتية كخدمة على تبسيط إدارة البنية التحتية، مما يوفر دخولًا أسرع إلى السوق، وأمنًا محسنًا، وتوفيرًا في التكاليف، وقابلية للتوسع، وتوافرًا عاليًا، وتقليل الترميز. من ناحية أخرى، يمكن أن تربطك بقدرات البائع، وتشكل مخاطر انغلاق البائع، وتحد من المرونة والتحكم.

الواجهة الخلفية كخدمة أو BaaS

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

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

الحاويات كخدمة أو CaaS

الحاويات كخدمة (CaaS) هي نموذج حوسبة سحابية لتحميل الحاويات وإنشائها وتوسيع نطاقها وإدارتها. وعادةً ما تتضمن CaaS وقت تشغيل الحاويات، وسجل الحاويات، ووظيفة التحجيم التلقائي، ونظام CI/CD المدمج، وموازنة التحميل والمزيد!

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

كيفية إنشاء بنية تحتية خلفية؟

في هذا الجزء من المقالة، سننشئ بنية تحتية خلفية باستخدام Back4app.

ما هو تطبيق Back4app؟

Back4app هو منصة خلفية كخدمة (BaaS) استثنائية. فهي تمكّنك من إنشاء واجهات خلفية لتطبيقات الويب والجوال بسرعة.

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

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

لن تحتاج إلى مهندسين متخصصين في DevOps، وستكون تكاليف الصيانة أقل.

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

لمعرفة المزيد عن Back4app، راجع ما هو Back4app؟

نظرة عامة على المشروع

لعرض كيفية إنشاء واجهة خلفية، سنقوم ببناء واجهة خلفية بسيطة للتجارة الإلكترونية. ستسمح لنا الواجهة الخلفية بإدارة المنتجات والفئات والطلبات.

سيبدو مخطط ER الخاص بمشروعنا بهذا الشكل:

سنصنع الواجهة الخلفية بأقل قدر من التعليمات البرمجية ونوضح كيف يمكن استخدامها من جانب العميل (عبر حزم SDK و REST API و GraphQL API).

إنشاء تطبيق

للمتابعة، يلزم وجود حساب على Back4app. هل تحتاج إلى حساب؟ اشترك اليوم!

بعد تسجيل الدخول إلى حساب Back4app الخاص بك، سترى قائمة تطبيقاتك. انقر على زر “إنشاء تطبيق” لبدء عملية إنشاء التطبيق.

بعد ذلك، اختر “BaaS” لأننا نقوم بإعداد واجهة خلفية.

اختر اسم التطبيق، واختر “NoSQL”، وأنشئ التطبيق.

سيستغرق Back4app بعض الوقت لإعداد كل شيء. سيتعامل مع طبقة التطبيق، وقاعدة البيانات، والنسخ الاحتياطية، والتوسع، وغير ذلك.

بمجرد إنشاء التطبيق، سيتم نقلك إلى قاعدة بيانات التطبيق في الوقت الفعلي.

إعداد قاعدة البيانات

الآن بعد أن أنشأنا تطبيقنا دعنا نهتم بقاعدة البيانات.

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

+-------------+-------------+------------------------------------------+
| Type        | Name        | Description                              |
+-------------+-------------+------------------------------------------+
| String      | objectId    | Object's unique identifier               |
+-------------+-------------+------------------------------------------+
| Date        | updatedAt   | Date time of the last update             |
+-------------+-------------+------------------------------------------+
| Date        | createdAt   | Date time of creation                    |
+-------------+-------------+------------------------------------------+
| ACL         | ACL         | Access Control List                      |
+-------------+-------------+------------------------------------------+

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

أضف الحقول التالية:

+-----------------------------+-------------+---------------+----------+
| Type                        | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+

قم بتنفيذ نفس الخطوات لفئة المنتج:

+-----------------------------+-------------+---------------+----------+
| Type                        | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ProductCategory | categories  | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Number                      | price       | 0             | yes      |
+-----------------------------+-------------+---------------+----------+

استخدمنا نوع بيانات العلاقة للتعامل مع العلاقة من متعدد إلى متعدد.

أخيرًا، أنشئ فئة الطلب:

+-----------------------------+------------+---------------+----------+
| Data type                   | Name       | Default value | Required |
+-----------------------------+------------+---------------+----------+
| Pointer -> Product          | product    | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cFirstName | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cLastName  | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cAddress   | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| Number                      | delivered  | false         | yes      |
+-----------------------------+------------+---------------+----------+

استخدمنا نوع بيانات المؤشر للتعامل مع علاقة واحد إلى متعدد.

بمجرد الانتهاء، يجب أن ترى الفصول على الشريط الجانبي.

ملء قاعدة البيانات

للمضي قدماً، دعنا نملأ قاعدة البيانات.

ابدأ بإنشاء بعض فئات المنتجات والمنتجات والطلبات (بهذا الترتيب). إذا نفدت أفكارك، لا تتردد في استيراد هذه التجهيزات.

لاستيراد ملف JSON استخدم “خيار المزيد > استيراد > بيانات الفئة > تحديد ملف”. تأكد من استيراد ملفات JSON بالترتيب التالي:

1. فئة المنتج.json
2. المنتج.json
3. _انضم إلى ꞉الفئات ꞉المنتج.json
4. طلب.json

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

تأمين قاعدة البيانات

بشكل افتراضي، يتم إنشاء فئات قاعدة البيانات في “الوضع المحمي”. بينما في الوضع المحمي، الطريقة الوحيدة للتفاعل وإدارة الكائنات هي استخدام المفتاح الرئيسي. هذا ليس الأمثل لأننا لا نستطيع جلب أو إدارة الكائنات من جانب العميل.

لكي نتمكن من القيام بذلك، علينا تخفيف بعض القيود. يأتي Back4app/Parse مع آليتي تقييد:

1. أذونات مستوى الفئة (CLPs)
2. أذونات مستوى الوصول (ACLs)

تسمح لنا CLPs بفرض قيود على مستوى الفئة، بينما تسمح لنا ACLs بفرض قيود على مستوى الكائن. يمكن لكلتا الآليتين تقييد فئة أو كائن على دور أو مستخدم معين.

حدد فئة المنتج على الشريط الجانبي، وانقر على النص “محمي” في أعلى الشاشة. ثم قم بتعديل CLPs:

قم بتنفيذ نفس الخطوات لنموذج فئة المنتج.

ثم قم بتحديث CLPs لفئة الطلب:

انتبه إلى الصورة. هنا، نقوم هنا أيضًا بتمكين إذن الإنشاء.

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

لمعرفة المزيد، راجع مقالة Parse Server Security الخاصة بنا.

التطبيق الإداري

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

لحسن الحظ، يتيح لك Back4app تمكين وظيفة “تطبيق المسؤول” بسهولة. تطبيق المسؤول هو لوحة إدارة سهلة الاستخدام مصممة خصيصًا لفئات قاعدة البيانات الخاصة بك.

قم بتمكينه بالانتقال أولاً إلى “المزيد > تطبيق المسؤول” على الشريط الجانبي. ثم انقر على “تمكين”:

سيطالبك Back4app باختيار اسم مستخدم وكلمة مرور ونطاق فرعي. لقد قررت اختيار ما يلي:

user:        root
pass:        complexpassword123
subdomain:   https://binfra.admin.back4app.com/

عظيم، هذا كل ما عليك فعله.

يمكنك الوصول إلى لوحة الإدارة من خلال النقر على “عنوان URL لتطبيق المسؤول”. ستُفتح نافذة متصفح جديدة بالنقر عليها، وسيُطلب منك إدخال بيانات اعتماد المسؤول الخاصة بك. بمجرد تسجيل الدخول، يمكنك إنشاء الكائنات وتحديثها وحذفها.

حاول اللعب بلوحة العدادات لتعتاد عليها.

رمز السحابة

يسمح لك تطبيق Back4app بتشغيل شيفرة JavaScript مخصصة عبر ما يسمى بالشفرة السحابية. باستخدام Cloud Code، يمكنك تحديد الدوال التي يمكن تشغيلها بواسطة Parse أو طلبات HTTP أو تشغيلها بشكل دوري. بالإضافة إلى ذلك، يمكن استخدام التعليمات البرمجية السحابية لإنشاء تطبيقات الويب باستخدام Express.

وظيفة الرمز السحابي

لنفترض أننا أردنا دالة الرمز السحابي التي تحسب المبيعات الحالية.

أولاً، انتقل إلى “الرمز السحابي > الوظيفة واستضافة الويب” على الشريط الجانبي. ستلاحظ أن عرض الرمز السحابي مقسم إلى قسمين. على الجانب الأيسر، يمكنك رؤية بنية الدليل والرمز على اليمين.

بعد ذلك، افتح Cloud/main.js والصق الشيفرة التالية:

// cloud/main.js

Parse.Cloud.define("calculateSales", async (request) => {
  const orderClass = Parse.Object.extend("Order");
  const orderQuery = new Parse.Query(orderClass);
  let sales = 0;

  try {
    const orders = await orderQuery.find();

    for (var i = 0; i < orders.length; i++) {
      let order = orders[i];
      let productId = order.get("product")["id"];

      const productClass = Parse.Object.extend("Product");
      const productQuery = new Parse.Query(productClass);
      const product = await productQuery.get(productId);

      sales += product.get("price");
    }
    return { 
      sales: sales,
    };
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
    return {
      sales: 0,
    }
  }
});

Parse.Cloud.job("printSales", async (request, status) => {
  try {
    const result = await Parse.Cloud.run("calculateSales");
    console.log("Sales: " + result.sales + "$");
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
  }
});

1. لقد قمنا بتعريف دالة برمجية سحابية تسمى calculateSales(). تمر الدالة على جميع الطلبات وتجلب المنتجات المقابلة وتجمع أسعارها.
2. لقد قمنا بتعريف وظيفة كود سحابي تسمى printSales()، مما يسمح لنا بتشغيل الدالة من لوحة معلومات Parse وجدولتها بشكل دوري.

وأخيراً، انقر على “نشر” لنشر الرمز السحابي.

تأكد من أن المهمة تعمل من خلال الانتقال إلى “الرمز السحابي > الوظائف” على الشريط الجانبي ثم تشغيل مهمة printSales(). إذا كان كل شيء يعمل بشكل جيد، يجب أن ترى رسالة تقول، على سبيل المثال، المبيعات: 1440$ عند التحقق من السجلات.

جدولة الرمز السحابي

لجدولة المهمة، يجب عليك الانتقال إلى “إعدادات التطبيق > إعدادات الخادم” على الشريط الجانبي. مرر لأسفل إلى “وظائف الخلفية”، وانقر على “جدولة مهمة”، واملأ النموذج.

للتأكد من عملها، تحقق من السجلات مرة أخرى.

جانب العميل

هناك طرق متعددة للتفاعل مع الواجهة الخلفية المستندة إلى Back4app:

1. Parse SDK
2. واجهة برمجة تطبيقات RESTful API (يتم إنشاؤها تلقائياً)
3. واجهة برمجة تطبيقات GraphQL (يتم إنشاؤها تلقائيًا)

كقاعدة عامة، يجب عليك دائمًا استخدام Parse SDK إذا كانت متاحة لمنصتك. إذا لم يكن كذلك، فإما أن تستخدم RESTful API أو GraphQL API. يعتمد الاختيار بين واجهات برمجة التطبيقات على بياناتك.

تعرّف على كيفية استخدام Parse SDK مع أطر عمل مختلفة من خلال الاطلاع على المستندات.

ومع ذلك، دعنا نختبر الواجهة الخلفية باستخدام وحدة تحكم REST المدمجة.

انتقل إلى “API > REST” على الشريط الجانبي، وحاول الاستعلام عن جميع المنتجات عن طريق ملء النموذج:

يجب أن تحصل على رد مماثل:

{
    "results": [
        {
            "objectId": "4ZyHH3X0RQ",
            "name": "Fitness Tracker Watch",
            "description": "...",
            "price": 80,
            "createdAt": "2023-10-17T20:03:55.424Z",
            "updatedAt": "2023-10-17T20:24:12.322Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
        {
            "objectId": "cDqlGJzT5U",
            "name": "Organic Fruit Basket",
            "description": "...",
            "price": 40,
            "createdAt": "2023-10-17T20:04:10.063Z",
            "updatedAt": "2023-10-17T20:24:00.382Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
    // ...
}

حاول إجراء الاستعلامات التالية:

1. أحضر جميع المنتجات التي تزيد تكلفتها عن 50
2. إحضار جميع الطلبات التي لم يتم تسليمها بعد
3. إنشاء منتج جديد وإضافة فئة إليه
4. حذف أمر

الخاتمة

في الختام، أنت الآن تعرف الآن ما هي البنية التحتية للواجهة الخلفية، وعلى دراية بأنواع مختلفة من البنى التحتية للواجهة الخلفية، وتعرف كيفية اختيار البنية التحتية المناسبة لمشروعك.

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

للحصول على إرشادات حول إنشاء جانب العميل للواجهة الخلفية المستندة إلى Back4app، استكشف مقالاتنا الأخرى:

1. كيفية استضافة الواجهة الأمامية والخلفية؟
2. كيف تطور تطبيقاً لوسائل التواصل الاجتماعي؟
3. كيف تنشئ روبوت محادثة باستخدام React؟

موارد المقالة الإضافية مفتوحة المصدر على ريبو GitHub.