PracticU

ארכיטקטורה של Kubernetes

בלי כתוביותעם כתוביות
PracticU › קורס קוברנטיקס - Kubernetes › ארכיטקטורה של Kubernetes
מילון מושגים:
Kubernetes - מערכת לניהול ותזמור של קונטיינרים בקנה מידה גדול, שמפעילה, מרחיבה ומתחזקת אותם אוטומטית.
API - ממשק תכנותי שמגדיר כיצד תוכנה אחת פונה לאחרת ומחליפה איתה נתונים ופעולות.
מאזן עומסים - רכיב שמחלק בקשות נכנסות בין כמה שרתים, כדי לשפר ביצועים, זמינות ועמידות בעומס.
פרוקסי - שרת מתווך שמעביר בקשות בין לקוח ליעד, ויכול לשמש להסתרה, לסינון, למטמון או לבקרת גישה.
חומת אש - מערכת שמסננת תעבורת רשת לפי כללים, ומתירה או חוסמת חיבורים כדי להגן על מחשב או רשת.
בקשה - פנייה שלקוח שולח לשרת כדי לקבל מידע או לבצע פעולה. השרת מחזיר עליה תגובה.
HTTP - פרוטוקול להעברת דפי אינטרנט ונתונים בין דפדפן לשרת. הגרסה המאובטחת שלו היא HTTPS.
Docker - פלטפורמה להרצת אפליקציות בתוך קונטיינרים מבודדים וקלים, כדי שירוצו באופן אחיד בכל סביבה.

ארכיטקטורה של Kubernetes
ההרצאה עוברת על הרכיבים של קלסטר Kubernetes ועל הדרך שבה הם מדברים זה עם זה, עם דגש על כך שכל התקשורת עוברת דרך שרת ה-API.
הרכיבים
1. Worker nodes ו-masters: ה-workers מריצים את הפודים והקונטיינרים, והמשתמשים מגיעים אליהם דרך load balancer חיצוני. ה-masters עוקבים אחרי המצב והעומס ומחליטים אם להרים או להוריד פוד.
2. כמה masters: הקלסטר ממשיך לעבוד כשהרוב זמין. עם שלושה masters אפשר לאבד אחד, ועם חמישה אפשר לאבד שניים. ההחלטה תלויה בתסריט שרוצים להתכונן אליו, ובכמה זמן לוקח להחליף שרת בארגון. ברשת קטנה אפשר לשים worker ו-master על אותו שרת, ואפילו קלסטר שלם על שרת אחד.
3. kubelet: רץ בכל worker, מריץ ומוריד קונטיינרים, בודק שהם חיים ומעדכן את שרת ה-API. kube-proxy אחראי על התקשורת בין הפודים ומול המשתמשים, כולל routing וה-firewall (IP tables).
4. API server: נקרא גם Control plane. כולם מדברים איתו, כולל מנהל הרשת עם kubectl ששולח בקשות HTTP. הוא היחיד שניגש לדאטה בייס שבו נשמר כל המידע.
דוגמה לתהליך
מנהל הרשת מבקש לפחות שלושה פודים. ה-API server מעביר ל-controller manager, שמשווה בין המצב הקיים לרצוי ומחליט להוסיף פוד. ההחלטה נשמרת בדאטה בייס. ה-Scheduler בוחר באיזה node להריץ אותה (למשל זה שיש בו פחות פודים). ה-kubelet שואל את ה-API server אם יש הוראות, ומעביר אותן דרך ממשק אחיד לתוכנה שמריצה קונטיינרים. פעם זה היה Docker ועכשיו containerd, וה-ממשק מאפשר להחליף אותה בקלות.
בקיצור, ה-controller manager מחליט מה לעשות וה-Scheduler בוחר איפה.
אחרי ההרצאה אפשר לתאר את תפקיד כל רכיב בקלסטר ולמה הכול עובר דרך ה-API server.
השיעור הבא בקורס: תקשורת בתוך קוברנטיס Kubernetes

פרקי ההרצאה: ארכיטקטורה של Kubernetes

  1. 00:00

    worker nodes ומאסטרים בקלסטר

  2. 00:56

    התקנת התפקידים על שרת אחד

  3. 01:57

    למה צריך רוב מאסטרים זמין

  4. 02:49

    בחירת מספר המאסטרים לפי תסריט

  5. 03:27

    תפקיד ה-kubelet וה-cube proxy

  6. 04:24

    שליחת הוראות דרך kubectl ו-API server

תמלול ההרצאה: ארכיטקטורה של Kubernetes

הטקסט המלא של הדקות הראשונות בהרצאה «ארכיטקטורה של Kubernetes» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:02

    שלום לכולם. בסרטון זה נדבר על המרכיבים שיש לנו בתוך הקוברנטיס. קודם כל יש לנו חלוקה בין שרתים שמריצים את הפודים ואת הקונטיינרים שנקראים worker nodes, שתכלס עליהם רצים הקונטיינרים, השרתים שלנו והיוזרים מתחברים אליהם ומקבלים את השירות שלהם דרך load balancer חיצוני.

  2. 00:24

    ויש לנו את המאסטרים שמנהלים את כל הקלסטר ומחליטים על איזה worker יעבוד איזה קונטיינר. הם אלו שעוקבים אחרי המצב של הקלסטר, אחרי העומס של הקלסטר.

  3. 00:37

    הם מקבלים את ההחלטות. האם צריך להרים עוד פוד, עוד קונטיינר או שצריך להוריד קונטיינר? תלוי בעומס, תלוי בדרישות, תלוי במה שמנהל רשת העביר.

  4. 00:48

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

  5. 01:04

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

  6. 01:19

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

  7. 01:30

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

  8. 01:50

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

  9. 02:15

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

  10. 02:31

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

  11. 02:46

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

  12. 03:12

    בכל מקרה, כדי שכל הקוברנטיס יעבוד תקין צריך שהקלסטר של המאסטרים יענה לשאילתות שמגיעות מ-kublet service, מהמרכיב הזה, לתוך API server, וכדי ש-API server בתוך המאסטר יעבוד צריך שהקלסטר של המאסטרים יעבוד תקין.

  13. 03:31

    ה-kublet service הוא זה שאחראי על הרצה של הקונטיינרים, לבדוק את התקינות שלהם, להרים קונטיינר חדש, להוריד קונטיינר. הוא מתעדכן מול API server במאסטר, לבדוק את המצב שהוא צריך לתחזק אצלו, והחבר שלו cube proxy אחראי על כל הנושא של תקשורת.

  14. 03:49

    תקשורת בין הפודים, תקשורת מול היוזרים. הוא מתעסק בכל ה networking, routing, ניהול של ה-firewall, של IP tables. כל הנושא של תקשורת זה ב-cube proxy. כל הנושא של ניהול פוד של הקונטיינר זה kubelet.

  15. 04:04

    בכל מקרה, שניהם מתקשרים מול שרת API במאסטר. שימו לב שכל התקשורת בקלסטר מתבצעת מול שרת API שנמצא בתוך המאסטר. יש לו עוד שם Control plane.

  16. 04:17

    אז גם ה-worker nodes וגם כל המרכיבים של המאסטר, כולם מתקשרים אחד עם השני דרך שרת API. גם המנהל הרשת עם הכלי שלו kubectl שולח את ההוראות שלו לשרת API.

  17. 04:31

    למעשה kubectl הזה מאחורי הקלעים שולח בקשות HTTP לתוך שרת API, ושרת API מתקשר מול כל הרכיבים האחרים כולל הדאטה בייס. למעשה כל המידע נשמר בדאטה בייס והיחיד שניגש לדאטה בייס זה שרת API.

  18. 04:46

    אז נניח שמנהל רשת דרך kubectl או דרך שילטות HTTP רגילה מעביר בקשה לשרת API שיהיו מינימום שלושה פודים, שלושה קונטיינרים מאפליקציה מסוימת. שרת API מעביר בקשה ל-controller manager.

  19. 05:02

    התוכנה הזאת משווה בין המצב הקיים בתוך

לקורס המלא: קורס קוברנטיס – Kubernetes

ההרצאה הקודמת: הסבר על Kubernetes - הבדל בין קונטיינר ומכונה וירטואלית

ההרצאה הבאה: תקשורת בתוך קוברנטיס - Kubernetes

הרצאות קשורות מקורסים אחרים

  • ארכיטקטורה של MVC
  • הסבר על ארכיטקטורה REST
  • הסבר על Kubernetes
  • לוח אם ומעבד - ארכיטקטורה של המעבד

קורסים נוספים במסלול

  • קורס AWS - ניהול מכונה וירטואלית בענן
  • קורס Terraform - DevOps - Azure & AWS
  • קורס Docker - עם Swarm Cluster
  • קורס DevOps - Ansible
  • קורס PowerShell
  • קורס Git ו-GitHub עם Visual Studio