🥇 الجزء التعليمي لـ Kubernetes الجزء الأول: التطبيقات والخدمات المصغرة والحاويات

بناء على طلبنا ، أنشأ هبر مركزًا Kubernetes ويسعدنا أن نضع أول مطبوعة فيها. يشترك!

Kubernetes سهل. لماذا تدفع لي البنوك الكثير من المال للعمل في هذا المجال ، بينما يمكن لأي شخص إتقان هذه التكنولوجيا في غضون ساعات قليلة؟

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

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

الآن ، دون مزيد من اللغط ، دعنا نبدأ العمل ونتحدث عن التطبيق الذي سنعمل معه.

تطبيق تجريبي

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

هذا ما تبدو عليه النافذة الرئيسية لهذا التطبيق.

تطبيق ويب لتحليل المشاعر

من وجهة نظر فنية ، يتكون التطبيق من ثلاث خدمات مصغرة ، كل منها يحل مجموعة معينة من المهام:

SA-Frontend هو خادم ويب Nginx يقدم ملفات React الثابتة.
SA-WebApp هو تطبيق ويب مكتوب بلغة Java يتعامل مع الطلبات من الواجهة الأمامية.
SA-Logic هو تطبيق Python يقوم بتحليل المشاعر النصية.

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

تتدفق البيانات في التطبيق

في الرسم البياني أعلاه ، يمكنك رؤية المراحل المرقمة للنظام ، والتي توضح تدفقات البيانات في التطبيق. دعنا نقسمهم:

يطلب المستعرض ملفًا من الخادم index.html (والذي بدوره يقوم بتحميل حزمة تطبيق React).
يتفاعل المستخدم مع التطبيق ، مما يؤدي إلى استدعاء تطبيق ويب قائم على Spring.
يقوم تطبيق الويب بإعادة توجيه طلب تحليل النص إلى تطبيق Python.
يحلل تطبيق Python شعور النص ويعيد النتيجة كاستجابة للطلب.
يرسل تطبيق Spring ردًا إلى تطبيق React (والذي يظهر بدوره نتيجة النص الذي تم تحليله للمستخدم).

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

تشغيل تطبيق يعتمد على الخدمات المصغرة الموجودة على الجهاز المحلي

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

▍ إعداد React من أجل التنمية المحلية

لتشغيل تطبيق React ، تحتاج إلى تثبيت إطار عمل Node.js و NPM على جهاز الكمبيوتر الخاص بك. بعد تثبيت كل هذا ، انتقل باستخدام المحطة الطرفية إلى مجلد المشروع sa-frontend وقم بتشغيل الأمر التالي:

npm install

بتنفيذ هذا الأمر في المجلد node_modules سيتم تحميل تبعيات تطبيق React ، وسجلاتها موجودة في الملف package.json. بعد تنزيل التبعيات في نفس المجلد ، قم بتشغيل الأمر التالي:

npm start

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

▍ إعداد تطبيق React للإنتاج

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

لإنشاء تطبيق React ، انتقل مرة أخرى باستخدام المحطة الطرفية إلى المجلد sa-frontend وقم بتشغيل الأمر التالي:

npm run build

سيؤدي هذا إلى إنشاء دليل في مجلد المشروع build. سيحتوي على جميع الملفات الثابتة المطلوبة لكي يعمل تطبيق React.

▍ خدمة الملفات الثابتة باستخدام Nginx

تحتاج أولاً إلى تثبيت خادم الويب Nginx وتشغيله. ومن يمكنك تنزيله والعثور على إرشادات لتثبيته وتشغيله. ثم تحتاج إلى نسخ محتويات المجلد sa-frontend/build إلى مجلد [your_nginx_installation_dir]/html.

باستخدام هذا الأسلوب ، يتم إنشاء الملف أثناء تجميع تطبيق React index.html سيكون متاحًا في [your_nginx_installation_dir]/html/index.html. هذا هو الملف الذي يُصدره خادم Nginx افتراضيًا عند الوصول إليه. تم تكوين الخادم للاستماع على منفذ 80، ولكن يمكنك تخصيصه بالطريقة التي تريدها عن طريق تحرير الملف [your_nginx_installation_dir]/conf/nginx.conf.

الآن افتح متصفحك وانتقل إلى localhost:80. سترى صفحة تطبيق React.

تطبيق React يخدمه خادم Nginx

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

▍ تحليل كود تطبيق الواجهة الأمامية

النظر في كود الملف App.js، يمكننا أن نرى ذلك النقر على الزر Send يستدعي طريقة analyzeSentence(). يظهر رمز هذه الطريقة أدناه. في الوقت نفسه ، انتبه إلى حقيقة أنه لكل سطر يوجد به تعليق على النموذج # Номер، هناك شرح معطى أسفل الكود. بنفس الطريقة ، سنقوم بتحليل أجزاء أخرى من الكود.

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. عنوان URL الذي يتم إرسال طلب POST إليه. يُفترض أن يكون هذا العنوان تطبيقًا ينتظر مثل هذه الطلبات.

2.تم إرسال نص الطلب إلى التطبيق. فيما يلي مثال على نص الطلب:

{
    sentence: "I like yogobella!"
}

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

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

يبدو أن الكود يعمل بشكل جيد. ما هو الخطأ هنا على أي حال؟ إذا افترضت أنه في العنوان الذي يحاول التطبيق إرسال طلب POST إليه ، لا يوجد شيء حتى الآن يمكنه قبول هذا الطلب ومعالجته ، فستكون على حق تمامًا. وهي لمعالجة الطلبات الواردة إلى العنوان http://localhost:8080/sentiment، نحتاج إلى تشغيل تطبيق ويب يعتمد على Spring.

نحتاج إلى تطبيق Spring يمكنه قبول طلب POST

▍ إعداد تطبيق ويب على أساس الربيع

من أجل نشر تطبيق Spring ، تحتاج إلى JDK8 و Maven ومتغيرات البيئة المكونة بشكل صحيح. بعد تثبيت كل هذا ، يمكنك متابعة العمل في مشروعنا.

▍ تعبئة التطبيق في ملف جرة

انتقل ، باستخدام الجهاز ، إلى المجلد sa-webapp وأدخل الأمر التالي:

mvn install

بعد تنفيذ هذا الأمر في المجلد sa-webapp سيتم إنشاء الدليل target. هذا هو المكان الذي سيتم وضع تطبيق Java فيه ، في حزمة في ملف jar ، يمثله الملف sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ إطلاق تطبيق جافا

اذهب إلى المجلد target وقم بتشغيل التطبيق بالأمر التالي:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

سيحدث خطأ أثناء تنفيذ هذا الأمر. لبدء إصلاحه ، يمكننا تحليل تفاصيل الاستثناء في بيانات تتبع المكدس:

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

بالنسبة لنا أهم شيء هنا هو ذكر استحالة إيضاح المعنى sa.logic.api.url. دعنا نحلل الكود حيث حدث الخطأ.

▍ تحليل كود تطبيق جافا

إليك مقتطف الشفرة حيث حدث الخطأ.

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

في S.entimentController هناك مجال saLogicApiUrl. يتم تحديد قيمتها من قبل الممتلكات sa.logic.api.url.
صف saLogicApiUrl يتسلسل مع القيمة /analyse/sentiment. يشكلون معًا عنوانًا لإجراء مكالمة إلى الخدمة المصغرة التي تقوم بتحليل النص.

▍ تحديد قيمة العقار

في الربيع ، المصدر الافتراضي لقيم الخصائص هو ملف application.properties، والتي يمكن العثور عليها في sa-webapp/src/main/resources. لكن استخدامه ليس الطريقة الوحيدة لتعيين قيم الممتلكات. يمكنك أيضًا القيام بذلك باستخدام الأمر التالي:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

يجب أن تشير قيمة هذه الخاصية إلى عنوان تطبيق Python الخاص بنا.

من خلال تكوينه ، نخبر تطبيق الويب Spring بالمكان الذي يجب أن يذهب إليه لتقديم طلبات تحليل النص.

من أجل عدم تعقيد حياتنا ، سنقرر أن تطبيق Python سيكون متاحًا في localhost:5000 وحاول ألا تنسى ذلك. نتيجة لذلك ، سيبدو الأمر لبدء تطبيق Spring كما يلي:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

يفتقد نظامنا إلى تطبيق Python

الآن علينا فقط تشغيل تطبيق Python وسيعمل النظام كما هو متوقع.

▍ إعداد تطبيق Python

لتشغيل تطبيق Python ، يجب أن يكون لديك Python 3 و Pip مثبتين ، ويجب أن يكون لديك متغيرات البيئة المناسبة مضبوطة بشكل صحيح.

▍ تثبيت التبعيات

انتقل إلى مجلد المشروع sa-logic/sa وقم بتشغيل الأوامر التالية:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

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

بعد تثبيت التبعيات ، نحن جاهزون لتشغيل التطبيق:

python sentiment_analysis.py

بعد تنفيذ هذا الأمر يتم إخبارنا بما يلي:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

هذا يعني أن التطبيق قيد التشغيل وينتظر الطلبات في localhost:5000/

▍ كود البحث

لنلقِ نظرة على كود تطبيق Python لفهم كيفية استجابته للطلبات:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

تهيئة الكائن Flask.
تحديد العنوان لتقديم طلبات POST إليه.
استرجاع الممتلكات sentence من نص الطلب.
تهيئة كائن مجهول TextBlob والحصول على القيمة polarity للاقتراح الأول الذي تم استلامه في متن الطلب (في حالتنا ، هذا هو الاقتراح الوحيد المقدم للتحليل).
إرجاع الرد الذي يحتوي نصه على نص العرض والمؤشر المحسوب له polarity.
بدء تشغيل تطبيق Flask ، والذي سيكون متاحًا على 0.0.0.0:5000 (يمكنك أيضًا الوصول إليه باستخدام بناء النموذج localhost:5000).

يتم الآن تشغيل الخدمات المصغرة التي يتكون منها التطبيق. هم مستعدون للتفاعل مع بعضهم البعض. إليك ما يبدو عليه مخطط التطبيق في هذه المرحلة من العمل.

يتم إحضار جميع الخدمات المصغرة التي يتكون منها التطبيق إلى حالة صحية

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

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

حاويات Docker

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

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

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

لاستكشاف ميزات الحاويات ومقارنتها بطرق أخرى لتشغيل التطبيقات ، دعنا نلقي نظرة على مثال تقديم تطبيق React باستخدام آلة افتراضية وحاوية.

▍ خدمة الملفات الثابتة لتطبيق React باستخدام آلة افتراضية

في محاولة لتنظيم صيانة الملفات الثابتة باستخدام الأجهزة الافتراضية ، سنواجه العيوب التالية:

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

يقدم خادم الويب Nginx ملفات ثابتة تعمل في جهاز افتراضي

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

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

يقدم خادم الويب Nginx ملفات ثابتة تعمل في حاوية

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

▍ إنشاء صورة حاوية لتطبيق React

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

قبل أن نبدأ العمل مع الملف Dockerfile، تذكر ما فعلناه من أجل تجهيز ملفات تطبيق React للتحميل على خادم Nginx:

بناء حزمة تطبيق React (npm run build).
بدء تشغيل خادم Nginx.
نسخ محتويات دليل build من مجلد المشروع sa-frontend إلى مجلد الخادم nginx/html.

أدناه يمكنك رؤية أوجه التشابه بين إنشاء حاوية والإجراءات المذكورة أعلاه التي تم تنفيذها على الكمبيوتر المحلي.

▍ إعداد Dockerfile لتطبيق SA-Frontend

التعليمات المراد تضمينها في Dockerfile للتطبيق SA-Frontend، تتكون من أمرين فقط. الحقيقة هي أن فريق تطوير Nginx قد أعد ملفًا أساسيًا صورة لـ Nginx ، والتي سنستخدمها لبناء صورتنا. فيما يلي الخطوتان اللتان نحتاج لوصفهما:

تحتاج إلى جعل صورة Nginx أساس الصورة.
محتوى المجلد sa-frontend/build بحاجة إلى نسخ إلى مجلد الصورة nginx/html.

إذا انتقلنا من هذا الوصف إلى الملف Dockerfile، ثم سيبدو كما يلي:

FROM nginx
COPY build /usr/share/nginx/html

كما ترون ، كل شيء هنا بسيط للغاية ، في حين أن محتويات الملف تبدو سهلة القراءة والفهم. يخبر هذا الملف النظام بأخذ الصورة nginx بكل ما هو موجود بالفعل ، وانسخ محتويات الدليل build إلى الدليل nginx/html.

هنا قد يكون لديك سؤال يتعلق بكيفية معرفة مكان نسخ الملفات بالضبط من المجلد build، أي من أين أتى المسار /usr/share/nginx/html. في الواقع ، لا يوجد شيء معقد هنا أيضًا. الحقيقة هي أنه يمكن العثور على المعلومات ذات الصلة في وصف صورة.

▍ تجميع الصورة وتحميلها على المستودع

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

لتثبيت عامل في حوض السفن.
سجل على موقع Docker Hub.
قم بتسجيل الدخول إلى حسابك عن طريق تشغيل الأمر التالي في الجهاز:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

الآن أنت بحاجة ، باستخدام المحطة ، انتقل إلى الدليل sa-frontend وقم بتشغيل الأمر التالي هناك:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

هنا وأدناه في أوامر مماثلة $DOCKER_USER_ID يجب استبداله باسم المستخدم الخاص بك على Docker Hub. على سبيل المثال ، قد يبدو هذا الجزء من الأمر كما يلي: rinormaloku/sentiment-analysis-frontend.

في هذه الحالة ، يمكن تقصير هذا الأمر بالحذف منه -f Dockerfile، لأن المجلد الذي ننفذ فيه هذا الأمر يحتوي بالفعل على هذا الملف.

من أجل إرسال الصورة النهائية إلى المستودع ، نحتاج إلى الأمر التالي:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

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

▍ بدء الحاوية

الآن يمكن لأي شخص تنزيل وتشغيل الصورة المعروفة باسم $DOCKER_USER_ID/sentiment-analysis-frontend. للقيام بذلك ، تحتاج إلى تشغيل التسلسل التالي من الأوامر:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

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

الرقم الأول 80 هو رقم منفذ المضيف (أي الكمبيوتر المحلي).
الرقم الثاني 80 هو ميناء الحاوية الذي يجب إعادة توجيه الطلب إليه.

تأمل الرسم التوضيحي التالي.

ميناء الشحن

يقوم النظام بإعادة توجيه الطلبات من المنفذ <hostPort> لكل ميناء <containerPort>. أي الوصول إلى المنفذ 80 يتم إعادة توجيه الكمبيوتر إلى منفذ 80 وعاء.

منذ الميناء 80 تم فتحه على الكمبيوتر المحلي ، يمكنك الوصول إلى التطبيق من هذا الكمبيوتر على localhost:80. إذا كان نظامك لا يدعم Docker ، فيمكنك تشغيل التطبيق على جهاز Docker الظاهري ، والذي سيبدو عنوانه كما يلي <docker-machine ip>:80. لمعرفة عنوان IP لجهاز Docker الظاهري ، يمكنك استخدام الأمر docker-machine ip.

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

▍.dockerignore الملف

بناء صورة التطبيق SA-Frontend، يمكننا أن نلاحظ أن هذه العملية بطيئة للغاية. هذا لأنه يجب إرسال سياق بناء الصورة إلى Docker daemon. يتم إعطاء الدليل الذي يمثل سياق البناء باعتباره الوسيطة الأخيرة للأمر docker build. في حالتنا ، توجد نقطة في نهاية هذا الأمر. ينتج عن هذا تضمين الهيكل التالي في سياق التجميع:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

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

node_modules
src
public

ملف .dockerignore يجب أن يكون في نفس المجلد مثل الملف Dockerfile. الآن سيستغرق تجميع الصورة بضع ثوانٍ.

دعنا الآن نتعامل مع صورة تطبيق Java.

▍ إنشاء صورة حاوية لتطبيق Java

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

افتح الملف Dockerfile، والموجود في مجلد المشروع sa-webapp. إذا قرأت نص هذا الملف ، فستلتقي فيه ببناءين جديدين فقط يبدأان بكلمات رئيسية ENV и EXPOSE:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

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

الكلمة EXPOSE يسمح لك بإخبار Docker بفتح منفذ. سنستخدم هذا المنفذ أثناء عملنا مع التطبيق. هنا يمكنك رؤية ذلك في Dockerfile للتطبيق SA-Frontend لا يوجد مثل هذا الأمر. هذا لأغراض التوثيق فقط ، بمعنى آخر ، هذا البناء مخصص للقارئ Dockerfile.

يبدو بناء الصورة ودفعها إلى المستودع تمامًا مثل المثال السابق. إذا لم تكن واثقًا جدًا من قدراتك ، فيمكن العثور على الأوامر المقابلة في الملف README.md في المجلد sa-webapp.

▍ إنشاء صورة حاوية لتطبيق Python

إذا ألقيت نظرة على محتويات الملف Dockerfile في المجلد sa-logicلن تجد أي شيء جديد هناك. يجب أن تكون أوامر بناء الصورة ودفعها إلى المستودع مألوفة لك بالفعل ، ولكن ، كما في حالة تطبيقاتنا الأخرى ، يمكن العثور عليها في الملف README.md في المجلد sa-logic.

اختبار التطبيقات المعبأة في حاويات

هل يمكنك الوثوق بشيء لم تختبره؟ لا استطيع ايضا. دعونا نختبر حاوياتنا.

لنبدأ حاوية التطبيق sa-logic وتهيئته للاستماع على المنفذ 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
لنبدأ حاوية التطبيق sa-webapp وتهيئته للاستماع على المنفذ 8080. بالإضافة إلى ذلك ، نحتاج إلى تعيين المنفذ الذي سيستمع عليه تطبيق Python للطلبات من تطبيق Java عن طريق إعادة تعيين متغير البيئة SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

لمعرفة كيفية العثور على عنوان IP للحاوية أو Docker VM ، راجع الملف README.

لنبدأ حاوية التطبيق sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

الآن كل شيء جاهز للتنقل في المتصفح إلى العنوان localhost:80 واختبر التطبيق.

يرجى ملاحظة أنه إذا قمت بتغيير المنفذ لـ sa-webapp، أو إذا كنت تقوم بتشغيل Docker VM ، فستحتاج إلى تحرير الملف App.js من المجلد sa-frontendعن طريق تغيير عنوان IP أو رقم المنفذ في الطريقة analyzeSentence()عن طريق استبدال المعلومات الحالية بدلاً من البيانات القديمة. بعد ذلك ، تحتاج إلى إعادة تجميع الصورة واستخدامها.

هذا ما يبدو عليه مخطط التطبيق لدينا الآن.

يتم تشغيل الخدمات المصغرة في حاويات

ملخص: لماذا نحتاج إلى مجموعة Kubernetes؟

لقد راجعنا الملفات للتو Dockerfile، عن كيفية إنشاء الصور ودفعها إلى مستودع Docker. بالإضافة إلى ذلك ، تعلمنا كيفية تسريع تجميع الصور باستخدام الملف .dockerignore. نتيجة لذلك ، تعمل خدماتنا المصغرة الآن في حاويات Docker. هنا قد يكون لديك سؤال مبرر تمامًا حول سبب حاجتنا إلى Kubernetes. ستخصص الإجابة على هذا السؤال للجزء الثاني من هذه المادة. في غضون ذلك ، ضع في اعتبارك السؤال التالي:
لنفترض أن تطبيق الويب الخاص بتحليل النص أصبح شائعًا في جميع أنحاء العالم. تأتيه ملايين الطلبات كل دقيقة. هذا يعني أن الخدمات المصغرة sa-webapp и sa-logic سيكون تحت ضغط هائل. كيف يتم قياس الحاويات التي تشغل الخدمات المصغرة؟

المصدر: www.habr.com

الجزء الأول من برنامج Kubernetes التعليمي: التطبيقات والخدمات المصغرة والحاويات