🥇מדריך Kubernetes, חלק 1: יישומים, מיקרו-שירותים ומכולות

לבקשתנו, הבר יצר רכזת קוברנט ואנו שמחים להציב בו את הפרסום הראשון. הירשם!

Kubernetes זה קל. למה הבנקים משלמים לי הרבה כסף כדי לעבוד בתחום הזה, בעוד שכל אחד יכול לשלוט בטכנולוגיה הזו תוך שעות ספורות?

אם אתה מטיל ספק בכך שניתן ללמוד Kubernetes כל כך מהר, אני מציע לך לנסות זאת בעצמך. כלומר, לאחר שליטת בחומר זה, תוכל להריץ יישום המבוסס על מיקרו-שירותים באשכול Kubernetes. אני יכול להבטיח זאת, מכיוון שדווקא באותה מתודולוגיה שבה נעשה שימוש כאן אני מלמד את הלקוחות שלנו לעבוד עם Kubernetes. מה מייחד את המדריך הזה מאחרים? למעשה, יש הרבה דברים. אז, רוב החומרים האלה מתחילים בהסבר של דברים פשוטים - המושגים של Kubernetes והתכונות של הפקודה kubectl. מחברי החומרים הללו מניחים שהקוראים שלהם מכירים את פיתוח האפליקציות, שירותי מיקרו ומכולות Docker. נלך בדרך אחרת. ראשית, נדבר על איך להפעיל אפליקציה המבוססת על מיקרו-שירותים במחשב. לאחר מכן נסתכל על בניית תמונות מיכל עבור כל שירות מיקרו. ואחרי זה, נכיר את Kubernetes ונבחן פריסת אפליקציה המבוססת על microservices באשכול המנוהל על ידי 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. כתובת האתר שאליה מתבצעת בקשת ה-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.

אנחנו צריכים יישום אביב שיכול לקבל בקשת POST

▍הגדרת אפליקציית אינטרנט מבוססת Spring

על מנת לפרוס אפליקציית Spring, תזדקק ל-JDK8 ול-Maven ומשתני סביבה מוגדרים כהלכה. לאחר שתתקין את כל זה, תוכל להמשיך לעבוד על הפרויקט שלנו.

▍אריזה של יישום לקובץ jar

נווט, באמצעות מסוף, לתיקיה sa-webapp והזן את הפקודה הבאה:

mvn install

לאחר הפעלת פקודה זו בתיקייה sa-webapp תיווצר ספרייה target. כאן תמוקם אפליקציית Java, ארוזה בקובץ jar, המיוצג על ידי הקובץ sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍הפעלת יישום Java

לך לתיקייה 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. בואו ננתח את הקוד שבו מתרחשת השגיאה.

▍ניתוח קוד יישומי Java

הנה קטע הקוד שבו מתרחשת השגיאה.

@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();
    }
}

ב-SentimentController יש שדה 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.

מכולות דוקר

קוברנט היא מערכת לאוטומציה של פריסה, קנה מידה וניהול של אפליקציות מכולות. זה נקרא גם "מתזמר מיכל". אם Kubernetes עובד עם קונטיינרים, אז לפני השימוש במערכת זו עלינו לרכוש תחילה קונטיינרים אלה. אבל קודם כל, בואו נדבר על מה הם מיכלים. אולי ניתן למצוא את התשובה הטובה ביותר לשאלה מה זה תיעוד לדוקר:

תמונת מכולה היא חבילה קלת משקל, עצמאית וניתנת להפעלה המכילה יישום הכולל את כל מה שצריך להפעלתה: קוד יישום, סביבת זמן ריצה, כלי מערכת וספריות והגדרות. ניתן להשתמש בתוכניות ממכולות בסביבות שונות. 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.

בשלב זה, לאחר שהשקת בהצלחה את מיכל היישומים הקדמי, אתה אמור להיות מסוגל לפתוח את הדף שלו בדפדפן.

▍קובץ .docerignore

איסוף תמונת אפליקציה SA-Frontend, יכולנו לשים לב שהתהליך הזה מתברר כאיטי ביותר. זה קורה בגלל שהקשר של בניית התמונה חייב להישלח לדמון Docker. הספרייה המייצגת את הקשר ה-build מצוינת כארגומנט האחרון של הפקודה 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 לגישה ל-API של האפליקציה שמבצעת ניתוח טקסט.

מילת מפתח 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 או מחשב וירטואלי, עיין בקובץ README.

בואו נפעיל את מיכל היישומים sa-frontend:

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

עכשיו הכל מוכן לעבור לכתובת בדפדפן localhost:80 ונסה את האפליקציה.

שים לב שאם שינית את היציאה עבור sa-webapp, או אם אתה מפעיל מכונה וירטואלית של Docker, תצטרך לערוך את הקובץ App.js מתוך תיקייה sa-frontendעל ידי שינוי כתובת ה-IP או מספר היציאה בשיטה analyzeSentence(), החלפת מידע עדכני במקום נתונים מיושנים. לאחר מכן, עליך להרכיב מחדש את התמונה ולהשתמש בה.

כך נראה דיאגרמת היישום שלנו כעת.

שירותי מיקרו פועלים במכולות

סיכום: למה אנחנו צריכים אשכול Kubernetes?

זה עתה בדקנו את התיקים Dockerfile, דיבר על איך לבנות תמונות ולדחוף אותן למאגר Docker. בנוסף, למדנו כיצד להאיץ את הרכבת התמונות באמצעות הקובץ .dockerignore. כתוצאה מכך, שירותי המיקרו שלנו פועלים כעת בקונטיינרים של Docker. כאן אולי יש לך שאלה מוצדקת לחלוטין לגבי למה אנחנו צריכים Kubernetes. החלק השני של חומר זה יוקדש למענה על שאלה זו. בינתיים, שקול את השאלה הבאה:
הבה נניח שיישום האינטרנט שלנו לניתוח טקסט הפך לפופולרי ברחבי העולם. מיליוני בקשות מגיעות אליו מדי דקה. זה אומר שמיקרו-שירותים sa-webapp и sa-logic יהיה תחת עומס עצום. כיצד להתאים קונטיינרים המריצים שירותי מיקרו?

מקור: www.habr.com