WEBVTT

00:00:00.000 --> 00:00:04.880
הנושא של היום הוא כזה שכמעט כולם שמעו עליו, אבל מעטים מאוד באמת יודעים להסביר אותו.

00:00:05.080 --> 00:00:09.800
GitOps. בטח ראיתם אותו מוזכר במודעות דרושים, בהרצאות בכנסים או בתיעוד של Azure.

00:00:10.020 --> 00:00:14.880
אבל מה זה בעצם? האם זו סתם עוד מילת בזז בדבופס או שמדובר במשהו שונה מהותי?

00:00:14.960 --> 00:00:16.280
הנה הגרסה המקוצרת.

00:00:16.500 --> 00:00:24.100
GitOps הוא מודל תפעולי שבו Git הופך למקור האמת היחיד עבור כל התשתית שלכם, לא רק קוד האפליקציה, אלא כל מה שמריץ אותה.

00:00:24.100 --> 00:00:32.860
עד סוף הפרק הזה, תבינו מה זה באמת GitOps, למה זה הפך לסטנדרט לניהול קוברנטיס באזר, ואיך זה הופך שחזור גרסאות, רולבקס, לפשוט כמו פקודה אחת.

00:00:33.040 --> 00:00:36.580
הדרך הישנה, פריסות ידניות וזכילה בהגדרות, קונפיגיריישון דריפט.

00:00:36.740 --> 00:00:38.500
בואו נתחיל עם הבעיה ש-GitOps פותר.

00:00:38.500 --> 00:00:41.420
תארו לעצמכם שאתם מנהלים אשקול קוברנטיס באזר.

00:00:41.420 --> 00:00:47.660
יש לכם מפתחים שדוחפים קוד צינור C שבונה תמונות קונטיינרים, ומי שהוא מריץ כאבקט אל אפליי כדי לפרוס את התמונות האלו.

00:00:47.760 --> 00:00:52.620
אולי אתם, אולי חבר לצוות, או שאתם לוחצים על כפתור ב-Azure DevOps, ובכל מקרה הפריסה מתבצעת.

00:00:52.700 --> 00:00:54.560
זה עובד מצוין עד שזה מפסיק לעבוד.

00:00:54.680 --> 00:00:56.020
הנה מה שקורה אחר כך.

00:00:56.020 --> 00:01:03.260
מי שהוא בצוות צריך לתקן בג מהיר, אז הוא מתחבר ב-SSH לצומת, משתמש בפורטל של Azure, או מריץ כאבקט אל אדיט ישירות על פריסה.

00:01:03.260 --> 00:01:08.400
הוא מבצע שינוי קטן, כמו כבנון של ConfigMap, או משתנה סביבה שונה, וזה נראה תמים.

00:01:08.580 --> 00:01:09.500
או כך הם חושבים.

00:01:09.660 --> 00:01:15.900
הבעיה היא שהשינוי הזה מעולם לא חזר לג'יט, כך שלקלסטר שלכם יש עכשיו הגדרה שלא תואמת את מה שנמצא במאגר שלכם.

00:01:15.900 --> 00:01:18.520
לזה קוראים זכילה בהגדרות Configuration Drift.

00:01:18.640 --> 00:01:25.360
זכילה היא רוצה אחשקת כי היא עובדת בסדר עד הפריסה הבאה, כשמי שהוא מריץ כאבקט אל אפליי עם המניפסט המקורי ודורס את התיקון המהיר הזה.

00:01:25.480 --> 00:01:29.120
או גרוע מכך, הזכילה גורמת להתנהגות בלתי צפויה שאף אחד לא יכול להסביר.

00:01:29.280 --> 00:01:33.440
אתם מתחילים לנפות בגים, בודקים את היומנים, מסתכלים על ה-YMR בג'יט, ושום דבר לא נראה לא תקין.

00:01:33.560 --> 00:01:34.680
אבל הקלסטר עושה משהו אחר.

00:01:34.820 --> 00:01:37.760
אין לכם מושג מה השתנה, מתי זה השתנה, או מי שינה את זה.

00:01:37.760 --> 00:01:38.840
ראיתי את זה קורה.

00:01:38.980 --> 00:01:44.740
חבר לצוות מתחבר ב-SSH לצומת, משנה הגדרה כדי לבדוק משהו, שוכח להחזיר אותה, והולך הביתה.

00:01:44.740 --> 00:01:48.080
למוחרת, פריסה נשברת, ואף אחד לא יכול להסביר למה.

00:01:48.200 --> 00:01:53.320
מאגר ה-GIT נראה נקי, אבל הקלסטר הוא בלגן, ואתם תקועים שעות בניסיון להבין מה קרה.

00:01:53.480 --> 00:01:54.640
אז, הנה השאלה.

00:01:54.780 --> 00:01:58.360
מה אם הייתה דרך להכריח את הקלסטר תמיד להתאים למה שנמצא בג'יט?

00:01:58.360 --> 00:02:02.620
מה אם יכולתם להבטיח שכל מה שנמצא במאגר שלכם הוא בדיוק מה שרץ בסביבת הייצור?

00:02:02.780 --> 00:02:04.760
זה הרעיון המרכזי מאחורי גיטופס.

00:02:04.880 --> 00:02:06.080
מה זה גיטופס באמת?

00:02:06.280 --> 00:02:07.660
אז מה זה בעצם גיטופס?

00:02:07.660 --> 00:02:10.220
הנה ההגדרה הפשוטה ביותר שאני יכול לתת לך.

00:02:10.420 --> 00:02:15.580
גיט הופך למקור האמת היחיד שלך, לא רק לקוד, אלא לכל מה שהתשתית שלך צריכה כדי לפעול.

00:02:15.700 --> 00:02:19.960
כל הגדרה, כל מניפסט פריסה, כל משתנה סביבה, הכל נמצא בג'יט.

00:02:19.960 --> 00:02:23.040
שום דבר לא רץ על האשקול שלך, אלא אם כן הוא מוגדר שם.

00:02:23.160 --> 00:02:25.300
עכשיו, גיטופס הוא לא כלי שאפשר לקנות.

00:02:25.400 --> 00:02:27.820
זה מודל תפעולי כמו DevOps או DevSecOps.

00:02:28.020 --> 00:02:30.840
מערכת עקרונות שמנחה כיצד לנהל את התשתית שלך.

00:02:30.840 --> 00:02:35.040
תקן האופן גיטופס מציג ארבעה עקרונות ליבה, ואני רוצה לעבור על כל אחד מהם.

00:02:35.160 --> 00:02:37.500
ראשית, המערכת שלך חייבת להיות הצהרתית.

00:02:37.680 --> 00:02:40.860
זה אומר שאתה מתאר את המצב הסופי, לא את הצעדים להגעה אליו.

00:02:40.860 --> 00:02:45.620
אז, במקום לכתוב סקריפט שאומר, צור פריסה, הגדל לחמישה היתקים, חשוף את פורט 8080,

00:02:45.900 --> 00:02:51.000
אתה כותב קובץ YMR שאומר, אני רוצה חמישה היתקים בפורט 8080, והמערכת מבינה את הצעדים.

00:02:51.120 --> 00:02:51.900
וזה הצהרתי.

00:02:52.080 --> 00:02:53.820
שנית, זה חייב להיות מנוהל גרסאות.

00:02:53.820 --> 00:02:56.480
כל שינוי שאתה עושה למצב האשקול שלך הוא קומית בג'ית.

00:02:56.620 --> 00:02:59.220
כך, אתה מקבל היסטוריה מלאה של מי שינה מה, מתי ולמה.

00:02:59.360 --> 00:03:01.060
לא צריך יותר לנחש או לחפור ביומנים.

00:03:01.200 --> 00:03:03.440
שלישית, שינויים נמשכים, נמשכים באופן אוטומטי.

00:03:03.440 --> 00:03:05.400
האשקול פונה לג'ית כדי לראות מה חדש.

00:03:05.540 --> 00:03:07.400
בהמשך, אסביר למה זה כל כך חשוב.

00:03:07.560 --> 00:03:09.720
ורביעי, המערכת מסונקרנת ברציפות.

00:03:09.860 --> 00:03:14.540
יש סוכן תוכנה שרץ בתוך האשקול שלך ומשווה כל הזמן בין מה שיש בג'ית לבין מה שרץ בפועל.

00:03:14.540 --> 00:03:16.600
אם הם לא תואמים, הוא מתקן את ההפרש.

00:03:16.800 --> 00:03:18.000
זהו לולעת הסנקרון.

00:03:18.160 --> 00:03:19.160
תחשוב על זה ככה.

00:03:19.320 --> 00:03:21.120
ג'ית הוא התוכנית של האדריכל שלך.

00:03:21.260 --> 00:03:23.440
הוא מתאר בדיוק איך הבניין צריך להיראות.

00:03:23.700 --> 00:03:25.140
קוברנטיז הוא אתר הבנייה.

00:03:25.280 --> 00:03:27.640
וה-ITPS, אופרייטור, הוא מנהל העבודה.

00:03:27.780 --> 00:03:31.060
הוא מסתובב עם התוכנית ובודק כל קיר, כל קורא, כל חלון.

00:03:31.200 --> 00:03:32.960
עם משהו לא תואם, הוא מתקן אותו.

00:03:32.960 --> 00:03:37.360
נניח שמי שהוא מעצבת עושה שינוי לא מרושה, הוא מזהה את זה ומבטל את זה.

00:03:37.500 --> 00:03:39.160
התוכנית היא תמיד מקור האמת.

00:03:39.160 --> 00:03:41.160
אבל, כאן קורה השינוי האמיתי.

00:03:41.360 --> 00:03:42.680
איך פריסות עובדות בפועל?

00:03:42.840 --> 00:03:45.640
ב-C, CD מסורתי, אתה דוחף שינויים לאשקול.

00:03:45.840 --> 00:03:49.780
ב-G-Tops, האשקול מושך אותם, וההבדל הזה חשוב יותר ממה שהוא נשמע.

00:03:49.940 --> 00:03:52.680
פריסות מבוססות משיכה לעומת מבוססות דחיפה.

00:03:52.840 --> 00:03:56.240
בואו נדבר על איך פריסות עובדות כי כאן G-Tops משנה הכל.

00:03:56.240 --> 00:03:59.700
במודל הפאש המסורתי, צינור ה-C שלך עושה הכל.

00:03:59.820 --> 00:04:02.700
Azure Pipelines, Jenkins, GitHub Actions.

00:04:02.700 --> 00:04:08.080
הוא בונה את הקונטיינר מריץ בדיקות, ואז דוחף את התמונה הזו ישירות לאשקול הקאברנטס שלך.

00:04:08.220 --> 00:04:12.200
לצינור היבוד, Pipeline, יש אישורים שמעניקים לו גישה ישירה לאפי-איי של האשקול.

00:04:12.360 --> 00:04:14.040
הוא אומר, הנה הפריסה החדשה.

00:04:14.220 --> 00:04:17.700
החל אותה עכשיו, וזה עובד, אבל זה יוצר בעיית הבטחה.

00:04:17.700 --> 00:04:26.960
העניין הוא שאם הצינור הזה נפרץ, מי שהוא מזריק שלב זדוני, אסימון דולף או שתלות נחתפת, לצינור הזה יש קו ישיר לאשקול הייצור שלך.

00:04:27.100 --> 00:04:33.000
הוא יכול להרוס פריסות, למחוק מרחבי שמות, לשנות הגדרות, הכל עם ההרשאות שנתת לו כדי לבצע את עבודתו.

00:04:33.120 --> 00:04:34.760
כעת, תסתכל על מודל ה-G-Tops.

00:04:34.940 --> 00:04:36.280
התהליך מתחיל באותו אופן.

00:04:36.440 --> 00:04:39.700
ה-C בונה את הקונטיינר ודוחף אותו לרישום, Registry, כמו Azure Container Registry.

00:04:39.840 --> 00:04:40.700
כאן ה-C עוצר.

00:04:40.700 --> 00:04:41.900
הוא לא נוגע באשקול.

00:04:41.900 --> 00:04:45.380
במקום זאת, ה-C מעדכן מאגר GIT עם תג התמונה החדש.

00:04:45.500 --> 00:04:49.880
הוא משנה שורה אחת בקובץ YML את גרסת התמונה ומבצע קומית לשינוי.

00:04:50.020 --> 00:04:50.560
זה הכל.

00:04:50.720 --> 00:04:51.980
אין גישה ישירה לאשקול.

00:04:52.160 --> 00:04:55.480
לאחר מכן, מפעיל הגיטופס שרץ בתוך האשקול שלך מזהה את השינוי הזה.

00:04:55.620 --> 00:04:57.840
הוא מושך את המצב העדכני מגיט ומכיל אותו.

00:04:57.980 --> 00:04:59.860
האשקול פונה אל הג'יט ולא להפך.

00:05:00.040 --> 00:05:01.900
זהו מודל המבוסס על משיכה, Pool Based.

00:05:01.900 --> 00:05:04.740
האשקול שלך לעולם לא חוסף את ה-API שלו למערכות חיצוניות.

00:05:04.740 --> 00:05:05.820
הוא רק מושך מגיט.

00:05:05.980 --> 00:05:09.900
אם מי שהוא פורץ לצינור ה-C שלך, הדבר הגרוע ביותר שהוא יכול לעשות הוא לשנות מניפסט במאגר.

00:05:10.020 --> 00:05:11.600
הם לא יכולים לגעת באשקול ישירות.

00:05:11.780 --> 00:05:13.440
המפעיל מחליט מה להכיל ומתי.

00:05:13.620 --> 00:05:14.740
יש גם יתרון נוסף.

00:05:14.900 --> 00:05:16.620
אתה מפריד בין בנייה לבין פריסה.

00:05:16.740 --> 00:05:19.360
ה-C עושה את מה שהוא טוב בו, בנייה, בדיקות, שריקה.

00:05:19.480 --> 00:05:21.100
מפעיל הג'יטופס מטפל בפריסה.

00:05:21.200 --> 00:05:23.000
כל מערכת מתמקדת במשימה אחת.

00:05:23.000 --> 00:05:25.180
אם הבנייה נכשלת, שום דבר לא משתנה באשקול.

00:05:25.180 --> 00:05:28.080
אם הפריסה נכשלת, המפעיל מבצע ניסיון חוזר או מטריע בפניך.

00:05:28.220 --> 00:05:29.020
הפרדה נקייה.

00:05:29.160 --> 00:05:31.640
אז במקום שצינור ידחוף שינויים לתוך האשקול שלך,

00:05:31.860 --> 00:05:33.740
האשקול מושך את המצב הרצוי שלא מגיע.

00:05:33.880 --> 00:05:37.000
ההיפוך הפשוט הזה הופך את התשתית שלך לבטוחה יותר,

00:05:37.300 --> 00:05:39.680
ניתנת לביקורת יותר וקשה יותר לשבירה בטעות.

00:05:40.000 --> 00:05:40.840
לולאת הפיוס,

00:05:41.060 --> 00:05:44.200
אז איך המפעיל יודע מתי לעד כן?

00:05:44.200 --> 00:05:45.500
הוא לא מחכה להודעה.

00:05:45.580 --> 00:05:48.780
הוא מריץ לולאה מתמשכת, צופה בג'יט, משווה לאשקול,

00:05:48.780 --> 00:05:52.200
מכיל שינויים במידת הצורך, ואז עושה זאת שוב ושוב לנצח.

00:05:52.360 --> 00:05:53.720
זה נקרא לולאת הפיוס.

00:05:53.900 --> 00:05:57.580
היא רצה ללא הרף, כל כמה שניות או דקות, בהתאם להגדרה שלך.

00:05:57.740 --> 00:05:59.480
המפעיל אף פעם לא מפסיק לצפות.

00:05:59.540 --> 00:06:01.400
תחשוב על זה כמו על תרמוסטט בבית שלך.

00:06:01.560 --> 00:06:04.300
אתה מגדיר את הטמפרטורה הרצויה, נניח 21 מעלות.

00:06:04.440 --> 00:06:06.760
התרמוסטט בודק כל הזמן את הטמפרטורה בפועל.

00:06:06.760 --> 00:06:09.380
אם היא יורדת מתחת למד מינוס 21, החימום נדלק.

00:06:09.520 --> 00:06:10.980
אם היא עולה מעל, החימום נכבה.

00:06:10.980 --> 00:06:13.240
הוא ממשיך להתאים את עצמו כדי להתאים להגדרה שלך.

00:06:13.360 --> 00:06:15.140
מפעיל הג'יט אופס פועל באותה הדרך.

00:06:15.360 --> 00:06:17.980
גיט מחזיק במצב הרצוי, האשקול במצב הנוכחי,

00:06:18.160 --> 00:06:20.500
והמפעיל משווה ביניהם ללא הרף ומבצע התאמות.

00:06:20.600 --> 00:06:23.220
אז מה קורה כשמישהו עורך ידנית פריסה באשקול?

00:06:23.360 --> 00:06:26.400
אולי הם מריצים קאבקט אל אדיט כדי לשנות את מספר העותקים.

00:06:26.560 --> 00:06:29.420
המפעיל מזהה את ההבדל במחזור הסינקרון הבא שלו.

00:06:29.420 --> 00:06:32.420
באשקול יש כעת שלושה עותקים, אך בג'יט רשומים חמישה.

00:06:32.500 --> 00:06:36.160
לכן, המפעיל מכיל את המצב המוגדר בג'יט, והאשקול חוזר לחמישה עותקים.

00:06:36.300 --> 00:06:37.780
השינוי הבלתי מורשה נעלם.

00:06:37.960 --> 00:06:39.540
מה קורה כשדוחפים שינוי לג'יט?

00:06:39.700 --> 00:06:40.460
אותו תהליך.

00:06:40.620 --> 00:06:42.540
המפעיל מזהה את ההבדל ומכיל אותו.

00:06:42.680 --> 00:06:44.060
מפתח ממזג בקשת שינוי PR,

00:06:44.300 --> 00:06:47.520
שמעדכנת את גרסת התמונה מ-1.2 ל-1.3.

00:06:47.660 --> 00:06:49.300
המפעיל רואה את המניפסט החדש,

00:06:49.300 --> 00:06:52.020
מושך את התמונה החדשה ומפעיל את הפודים החדשים.

00:06:59.420 --> 00:07:01.640
שמטופלת על ידי בקר הרפליקסט.

00:07:01.760 --> 00:07:04.040
מפעיל הג'יט אופס דואג רק לקונפיגורציה.

00:07:04.200 --> 00:07:07.720
אם מניפסט הפריסה אומר חמישה עותקים, תמונה 1.3,

00:07:07.980 --> 00:07:11.840
ובשקול יש חמישה עותקים שמריצים 1.3, המפעיל מרוצה.

00:07:11.980 --> 00:07:14.180
לא אכפת לו אימפוד ספציפי ופעל מחדש.

00:07:14.360 --> 00:07:16.160
זו התנהגות רגילה של קוברנטיז.

00:07:16.300 --> 00:07:18.060
אך אם מישהו משנה את המניפסט בג'יט,

00:07:18.060 --> 00:07:20.120
או משנה את האשקול ישירות ויוצר סטייה,

00:07:20.260 --> 00:07:20.920
המפעיל פועל.

00:07:20.920 --> 00:07:23.480
זה מה שהופך את ג'יט אופס לבעל יכולת ריפוי עצמי.

00:07:23.560 --> 00:07:24.720
הוא לא רק פורס שינויים,

00:07:24.960 --> 00:07:27.320
הוא מונע מהתשתית שלך על לסתות ממה שהוגדר.

00:07:27.480 --> 00:07:30.340
לכן, אתה צריך מפעיל ג'יט אופס שרץ באשקול שלך.

00:07:30.460 --> 00:07:32.800
כאן נכנסים לתמונה ארגו-סי-די ופלוקס.

00:07:32.960 --> 00:07:34.380
ארגו-סי-די מול פלקס.

00:07:34.520 --> 00:07:36.200
אז אתה צריך מפעיל ג'יט אופס,

00:07:36.360 --> 00:07:39.140
ויש לך שתי אפשרויות עיקריות, שתיהן מצוינות.

00:07:39.140 --> 00:07:42.460
ארגו-סי-די ופלוקס הם פרויקטים בוגרים של CNCF,

00:07:42.460 --> 00:07:45.260
מה שאומר שהם עברו את הרף הגבוה ביותר ליציבות,

00:07:45.440 --> 00:07:46.600
קהילה ומוכנות ליצור.

00:07:46.740 --> 00:07:48.980
אבל הם ניגשים לאותה עבודה מזוויות שונות.

00:07:49.160 --> 00:07:51.300
ארגו-סי-די נבנה במקור על ידי אינטוויט,

00:07:51.480 --> 00:07:52.760
והוא מגיע עם ממשק אינטרנט.

00:07:52.900 --> 00:07:54.180
כשמתקינים את ארגו-סי-די,

00:07:54.440 --> 00:07:57.000
מקבלים לוח מכוונים שבו אפשר לראות כל אפליקציה,

00:07:57.260 --> 00:07:59.700
מצב הסינקרון, הבריאות והיסטוריית הפריסות שלה.

00:07:59.700 --> 00:08:02.420
אפשר לנווט, לראות הבדלים בין ג'יט לאשקול,

00:08:02.420 --> 00:08:04.640
להפעיל דברים ידנית ולאשר שינויים.

00:08:04.800 --> 00:08:08.580
הוא מיועד לצוותים שרוצים לוחות מכוונים ויזואליים ונקודות שליטה ידניות.

00:08:08.800 --> 00:08:11.180
פלקס הגיע מ-Waveworks, והוא מודולרי יותר.

00:08:11.380 --> 00:08:13.180
אין ממשק משתמש כברירת מחדל.

00:08:13.320 --> 00:08:17.020
עובדים דרך שורת הפקודה ומגדירים הכל כמשאבים מותאמים אישית של קוברנטיז.

00:08:17.160 --> 00:08:18.960
אתה יוצר אובייקט מאגר גיט שאומר,

00:08:18.960 --> 00:08:20.360
עקוב אחרי המאגר הזה,

00:08:20.500 --> 00:08:22.000
ואובייקט התאמה אישית שאומר,

00:08:22.200 --> 00:08:23.180
יישם את הנתיב הזה.

00:08:23.180 --> 00:08:25.220
פלקס אוסף אותו ומבצע סימקירון.

00:08:25.400 --> 00:08:27.780
זה מכריח רותח לאמץ תהליכי עבודה מקוריים של גיט,

00:08:27.880 --> 00:08:29.240
כי אין לוח מכוונים להישען עליו.

00:08:29.360 --> 00:08:31.260
עכשיו, הנה מה שחשוב למשתמשי אז'וור.

00:08:31.400 --> 00:08:34.600
פלקס היא אפשרות הג'יט אופס המוגדרת כברירת מחדל ב-Azure Kubernetes Service.

00:08:34.780 --> 00:08:37.560
מייקרוסופט בנתה את האינטגרציה המקורית סביב פלקס V2.

00:08:37.720 --> 00:08:40.480
כאשר מפעילים גיט אופס באשכול AKS דרך פורטל אז'וור,

00:08:40.480 --> 00:08:42.140
משתמשים בפלוקס מאחורי הקלעים.

00:08:42.140 --> 00:08:44.960
Azure Arc משתמשת גם היא בפלוקס לניהול ריבוי השקולות.

00:08:45.100 --> 00:08:47.940
אז, אם אתה מהנדס אז'וור, פלקס היא נקודת ההתחלה הטבעית.

00:08:48.080 --> 00:08:50.020
אבל לארגו-CD יש את החוזקות שלה.

00:08:50.140 --> 00:08:54.720
היא פופולרית יותר לתרחישי הנדסת פלטפורמה שבהם רוצים אישור בקרה מרכזי שמנהל השקולות מרובים.

00:08:54.880 --> 00:08:58.220
ממשק המשתמש מקל על צוותים שלא מרגישים בנוח עם שורת הפקודה,

00:08:58.220 --> 00:09:04.080
והיא משתלבת היטב עם ארגו-רולאוטס להפצה הדרגתית כמו פריסות כנרית, פריסות כחול, ירוק ודברים כאלה.

00:09:04.160 --> 00:09:06.020
ההבדל הארכיטקטוני המרכזי הוא זה,

00:09:06.240 --> 00:09:09.400
ארגו-CD פועלת כאפליקציה עצמאית עם שרת API משלה.

00:09:09.600 --> 00:09:14.020
פלקס פועלת כקבוצה של בקרים של קוברנטיז, המוטמעים עמוק יותר בתוך האשכול עצמו.

00:09:14.020 --> 00:09:16.860
פלקס מרגישה כחלק ממישור הבקרה של קוברנטיז,

00:09:17.040 --> 00:09:20.060
בעוד ארגו-CD מרגישה כפלטפורמה נפרדת שיושבת מעליו.

00:09:20.060 --> 00:09:24.000
פלקס גם מסתמכת רבות על קאסטומייז, שהוא כלי תבניות מקורי של קוברנטיז.

00:09:24.140 --> 00:09:27.480
ארגו-CD יכולה להשתמש בקאסטומייז, הלם, או YML פשוט.

00:09:27.700 --> 00:09:32.180
שתיהן תומכות בהלם, אבל לפלוקס יש בקר הלם יהודי שמטפל בגרסאות הלם באופן טבעי.

00:09:32.300 --> 00:09:33.360
אין כאן בחירה שגויה.

00:09:33.360 --> 00:09:38.220
שני הכלים עושים את אותה העבודה, אבל עבור מהנדסי Azure, פלקס היא הדרך הקלה ביותר.

00:09:38.220 --> 00:09:44.040
אפשר להפעיל GitOps עם פלקס בחמה לחיצות דרך פורטל Azure, להפנות למאגר Git, וזה מתחיל להסתנכרן.

00:09:44.220 --> 00:09:46.780
ללא התקנה נוספת, ללא שרת נפרד לניהול.

00:09:46.980 --> 00:09:50.280
GitOps ב-Azure, AKS, Azure Arc ו-Azure DevOps.

00:09:50.580 --> 00:09:53.280
אז, איך זה נראה בפועל כשמחברים את זה ל-Azure?

00:09:53.280 --> 00:09:54.840
בואו נתחיל עם AKS.

00:09:54.980 --> 00:09:58.900
ל-Azure Kubernetes Service יש תמיכה מובנית ב-GTops באמצעות Flux v2.

00:09:59.060 --> 00:10:04.920
בפורטל Azure, נכנסים לאשכול, מוצאים את אזור ה-GitOps ומגדירים אותו על ידי הפנייה למאגר Git.

00:10:04.920 --> 00:10:07.580
Azure Repos, GitHub, או כל מקום אחר.

00:10:07.740 --> 00:10:12.500
Flux מתחילה לעקוב, וכל מניפסט שתשים במאגר, ההוא יוכל על האשכול שלך באופן אוטומטי.

00:10:12.620 --> 00:10:14.360
אבל AKS הוא רק חלק אחד.

00:10:14.360 --> 00:10:20.040
Azure Arc מרחיבה את ה-GitOps לאשכולות שלא נמצאים באזר, מקומיים, בעננים אחרים או בקצה הרשת.

00:10:20.120 --> 00:10:23.580
מחברים אותם לאזר Arc, ומנהלים את כולם עם אותה תצורת GitOps.

00:10:23.740 --> 00:10:26.400
מאגר אחד, אשכולות רבים, מצב עקבי בכל מקום.

00:10:26.560 --> 00:10:27.420
זה מה ש-Aerts עושה.

00:10:27.540 --> 00:10:29.180
עכשיו, בואו נדבר על הפייפליין.

00:10:29.180 --> 00:10:32.700
Azure DevOps משתלב באופן טבעי במודל הזה, והנה התבנית הנפוצה.

00:10:32.800 --> 00:10:37.400
קוד המקור שלך נמצא ב-Azure Repos או ב-Github, ו-Azure Pipelines מנהל את ה-C.

00:10:37.400 --> 00:10:43.140
הוא בונה את תמונת הקונטיינר, מריץ בדיקות, שורק פגיעויות, ודוחף את התמונה ל-Azure Container Registry.

00:10:43.280 --> 00:10:50.040
לאחר מכן, הצינור מעדכן את המניפסטים בריפו של ה-GitOps שלך על ידי שינוי תגית התמונה מ-V1.2 ל-V1.3, מבצע קומית לשינוי ודוחף אותו.

00:10:50.200 --> 00:10:50.760
זה הכל.

00:10:50.880 --> 00:10:52.520
הצינור לעולם לא נוגע באשכול.

00:10:52.520 --> 00:10:59.440
קלאסטר, פלאקס שרץ בתוך AKS מזהה את השינוי ב-Git, מושך את המניפסט החדש, רואה את תגית התמונה המעודכנת ומכיל את הפריסה.

00:10:59.540 --> 00:11:01.700
פודס חדשים עולים, וההשכול מסתנקרן.

00:11:01.700 --> 00:11:05.380
אתה יכול להשתמש ב-Github Actions במקום ב-Azure Pipelines עם תעדיף.

00:11:05.500 --> 00:11:06.760
התבנית נשארת זהה.

00:11:06.900 --> 00:11:11.440
ה-C מטפל בבנייה, מעדכן את המניפסטים, ומפעיל ה-GitOps מטפל בפריסה.

00:11:11.560 --> 00:11:13.560
הכלי לא משנה, המודל הוא שקובע.

00:11:13.700 --> 00:11:14.660
הנה פרט חשוב.

00:11:14.660 --> 00:11:19.740
לעולם אל תשמור סודות ישירות ב-Git, לא מפתחות API, לא מחרוזות חיבור ולא אישורים.

00:11:19.860 --> 00:11:22.480
אפילו במאגר פרטי, סודות ב-Git מהווים סיכון.

00:11:22.640 --> 00:11:26.160
במקום זאת, השתמש ב-Azure Key Vault או ב-External Secrets Operator.

00:11:26.320 --> 00:11:31.520
המניפסט מתייחס לסוד לפי שם, והמפעיל מושך את הערך האמיתי מהוויולת בזמן הפריסה.

00:11:31.640 --> 00:11:33.680
ניתן גם להוסיף שכבת מדיניות מעל.

00:11:33.800 --> 00:11:40.000
Azure Policy עם Gatekeeper יכול לאחוב חוקים כמו איסור על קונטיינרים, מורשים או שימוש רק ברישומים מאושרים.

00:11:40.000 --> 00:11:45.440
עם מי שהוא מנסה לפרוס מניפסט שמפר את המדיניות, Gatekeeper חוסם אותו לפני שהוא מגיע לאשקול.

00:11:45.600 --> 00:11:47.820
היתרון האמיתי כאן הוא קנה מידה, Scale.

00:11:48.020 --> 00:11:51.500
עם 50 אשקולות AKS, אתה לא מנהל כל אחד בנפרד.

00:11:51.680 --> 00:11:56.460
הגדר את המצב הרצוי במאגר Git יחיד, וכל אשקול מסתנקרן למצב הזה.

00:11:56.980 --> 00:12:00.580
הוסף אשקול חדש, כוון אותו למאגר, והוא מגדיר את עצמו.

00:12:00.780 --> 00:12:02.900
צריך להדכן הגדרה בכל האשקולות.

00:12:03.080 --> 00:12:06.080
שנה קובץ אחד בג'יט והמפעילים יטפלו בשאר.

00:12:06.080 --> 00:12:08.320
זו ההבטחה של GitOps ב-Azure.

00:12:08.460 --> 00:12:11.260
מקור אמת אחד, הרבה אשקולות ללא סטיות.

00:12:11.660 --> 00:12:12.920
היתרונות המרכזיים.

00:12:13.080 --> 00:12:16.440
אז כל זה נשמע טוב בתיאוריה, אבל מה זה אומר בפועל עבור הצוות שלך?

00:12:16.600 --> 00:12:18.660
נתחיל עם מה שמושך את תשומת הלב של כולם.

00:12:18.860 --> 00:12:20.980
ביצוע Rollback הופך לעניין של מה בכך.

00:12:21.080 --> 00:12:24.920
פריסה גרועה יוצאת, האפליקציה מתחילה לזרוק שגיאות, משתמשים מתלוננים.

00:12:25.140 --> 00:12:28.140
בעולם הישן, היית ממהר למצוא את ההגדרה התקינה האחרונה,

00:12:28.140 --> 00:12:31.200
מריץ סדרת פקודות ידניות ומתפלל שלא פספסת משהו.

00:12:31.340 --> 00:12:33.760
בג'יטופס, אתה פשוט מבטל את הג'יט קומית.

00:12:33.980 --> 00:12:35.520
זה הכל, פקודה אחת.

00:12:35.640 --> 00:12:38.120
המפעיל רואה את הביטול, מושך את המצב הקודם,

00:12:38.300 --> 00:12:40.200
וההשקול חוזר למה שעבד קודם לכן.

00:12:40.380 --> 00:12:43.560
אין צורך ב-SSH, אין קאבקט-L, ובוודאי ללא פאניקה.

00:12:43.700 --> 00:12:46.280
נתיב ביקורת, audit trail, בנוי בפנים באופן אוטומטי.

00:12:46.400 --> 00:12:48.220
כל שינוי בתשתית שלך הוא קומית.

00:12:48.220 --> 00:12:51.020
אתה יודע מי ביצע אותו, מתי, ומה בדיוק השתנה.

00:12:51.140 --> 00:12:55.040
אין יותר ניחושים עם מי שהוא ערך דפלוימנט בית מינוס 2 לפנות בוקר ושכח לציין זאת.

00:12:55.140 --> 00:12:57.700
ההיסטוריה קיימת בלתי ניתנת לשינוי וניתנת לבדיקה.

00:12:57.820 --> 00:13:01.200
ריפוי עצמי, self-healing, הוא עוד דבר שנשמע כמו קסם עד שרואים אותו בפעולה.

00:13:01.320 --> 00:13:03.580
מי שהוא עורך ידנית דפלוימנט בתוך הקלאסטר.

00:13:03.760 --> 00:13:06.180
אולי מהנדס זוטר שמנסה לתקן משהו במהירות.

00:13:06.340 --> 00:13:09.560
האופרטר מזהה את הסטייה במחזור הסמכרון הבא ומבטל אותה.

00:13:09.560 --> 00:13:13.340
הקלאסטר מרפא את עצמו, ואתה אפילו לא יודע שזה קרה אלא אם בדקת את הלוגים.

00:13:13.460 --> 00:13:15.560
עקביות בין סביבות הופכת לאוטומטית.

00:13:15.700 --> 00:13:19.440
פיתוח, בדיקות, סטייג'ינג וייצור, כולם מושכים מאותו מאגר גיט.

00:13:19.600 --> 00:13:22.040
ענפים או תיקיות שונים, אבל אותו מקור אמת.

00:13:22.220 --> 00:13:26.780
אין יותר, זה עובד אצלי במכונה, כי הקלאסטר של הסטייג'ינג סתה מהייצור לפני שבועות.

00:13:26.880 --> 00:13:30.240
ההבטחה משתפרת כי הקלאסטר מושך מגיט במקום שדוחפים אליו.

00:13:30.240 --> 00:13:33.780
צינור ה-C שלך לעולם לא מחזיק אישורים שנותנים לו גישה ישירה לייצור.

00:13:33.900 --> 00:13:36.780
אם מי שהוא יפרוץ לצינור ה-C, הוא לא יוכל לגעת בקלאסטר.

00:13:36.900 --> 00:13:38.900
האופרטר מחליט מה מוכל ומתי.

00:13:39.060 --> 00:13:40.660
מינימום הרשאות כעקרון תכנון.

00:13:40.840 --> 00:13:42.300
יש גם נתונים שתומכים בזה.

00:13:42.480 --> 00:13:47.580
לפי מחקר דורה, צוותים שמאמצים גיטופס רואים ירידה של קף מינוס 25% בשגיאות פריסה.

00:13:47.800 --> 00:13:51.500
וזמן התאוששות ממוצע יורד לפחות מממינוס 2 דקות בהגדרות מיושמות היטב.

00:13:51.500 --> 00:13:53.920
זו לא תיאוריה, זה מה שארגונים מדווחים.

00:13:54.080 --> 00:13:56.720
ויש יתרון של שיתוף פעולה שקל לפספס.

00:13:56.900 --> 00:14:02.620
שינויי תשתית עוברים דרך פול רקווסטס, בדיקות קוד ובדיקות אוטומטיות, בדיוק כמו קוד אפליקציה.

00:14:02.760 --> 00:14:05.740
צוות התפעול וצוות הפיתוח שלך מדברים באותה שפה, גיט.

00:14:05.900 --> 00:14:08.680
אין יותר העברת משימות, אין יותר, פשוט תפרוס את זה בשבילי.

00:14:08.800 --> 00:14:13.160
כולם עובדים באותה הדרך, אבל עדיין יש כמה אי הבנות נפוצות שכדאי להבהיר.

00:14:13.600 --> 00:14:15.340
מיטוסים נפוצים ותחילת עבודה.

00:14:15.340 --> 00:14:18.100
נתחיל בהבהרת כמה מיטוסים נפוצים לגבי גיטופס.

00:14:18.220 --> 00:14:21.240
ראשית, אנשים רבים חושבים שגיטופס מיועד רק לקאברנטס.

00:14:21.340 --> 00:14:24.120
ובטח, זה עובד הכי טוב על קוברנטיז, אין על זה ויכוח.

00:14:24.300 --> 00:14:28.100
קוברנטיז בנויה סביב מצב הצהרתי וסמכרון, אז זה התאמה טבעית.

00:14:28.240 --> 00:14:32.280
אבל הנה העניין, אותה מקרונות חלים בכל מקום שיש לך הגדרות הצהרתיות.

00:14:32.420 --> 00:14:35.600
אפשר להשתמש בגיטופס עם טראפורם, פולומי ואפילו אנסיבר.

00:14:35.600 --> 00:14:38.960
פשוט תחסן את ההגדרות האלה בגיט ותן לצינור עבודה להכיל אותן.

00:14:39.080 --> 00:14:43.880
חלק הריפוי העצמי קשה יותר מחוץ לקאברנטס, אבל משמעת מקור האמת עובדת בכל מקום.

00:14:44.060 --> 00:14:47.880
מיטוס נוסף הוא שחייבים את ארגו-סי-די או פלקס כדי לעשות גיטופס.

00:14:48.000 --> 00:14:52.060
אם אתם רוצים את המודל המלא, פריסה מבוססת משיכה, סינקרון רציף וזיהוי שינויים,

00:14:52.260 --> 00:14:54.720
אז כן, אתם צריכים סוג כלשהו של גיטופס אופרייטור.

00:14:54.840 --> 00:14:56.420
אבל אפשר להתחיל הרבה יותר פשוט.

00:14:56.420 --> 00:14:59.780
פשוט שימו את כל המניפסטים בגיט והשתמשו בפול ריקווסטס לכל שינוי.

00:14:59.900 --> 00:15:02.680
זה לבדו מעניק לכם את רוב היתרונות של ביקורת ושיתוף פעולה.

00:15:02.760 --> 00:15:05.680
תמיד תוכלו להוסיף אופרייטור מאוחר יותר כשתצטרכו את האוטומציה.

00:15:05.800 --> 00:15:09.020
ולבסוף, יש את המיתוס שגיטופס מחליף את ה-C, CD לחלוטין.

00:15:09.140 --> 00:15:11.420
זה לא נכון. זה מחליף רק את חלק ה-CD.

00:15:11.600 --> 00:15:16.580
ה-C עדיין בונה את הקוד שלכם, מריץ בדיקות, שורק פגיעויות ודוחף אימג'ים של קונטיינרים לרגיסטרי.

00:15:16.580 --> 00:15:17.900
כל זה נשאר אותו דבר.

00:15:18.100 --> 00:15:20.600
מה שמשתנה הוא הדרך שבה האימג'ים האלה נפרסים.

00:15:20.740 --> 00:15:22.700
במקום שצינור ה-C ידחוף אותם לאשקול,

00:15:22.920 --> 00:15:25.700
ה-G-Tops Operator מושך את המניפסטים המעודכנים מגי.

00:15:25.820 --> 00:15:28.720
לכן, C ו-G-Tops עובדים יחד, לא במקום זה את זה.

00:15:28.880 --> 00:15:30.340
להתחיל זה למעשה די פשוט.

00:15:30.520 --> 00:15:33.880
בחרו אשקול AKS קטן והפעילו את פלקס דרך פורטל Azure.

00:15:34.100 --> 00:15:35.420
זה דורש רק כמה לחיצות.

00:15:35.600 --> 00:15:39.440
לאחר מכן, כוונו אותו למאגר גיט שמכיל קובץ YML פשוט של פריסה,

00:15:39.440 --> 00:15:41.520
צפו בסמכירון ואתם מוכנים לצאת לדרך.

00:15:41.660 --> 00:15:44.860
נסו לשנות ערך ב-YML, ביצעו קומית וצפו באשקול מתעדכן.

00:15:45.040 --> 00:15:47.080
זהו זרימת העבודה הראשונה שלכם ב-G-Tops.

00:15:47.240 --> 00:15:50.940
משם, תוכלו להוסיף סביבות, ללמוד Customize כפלקס משתמש בזה רבות,

00:15:51.120 --> 00:15:54.480
ולהגדיר עדכוני אימג'ים אוטומטיים עם כלים כמו Renovate או Dependable.

00:15:54.680 --> 00:15:56.480
אז זה G-Tops על קצה המזלג.

00:15:56.640 --> 00:15:58.720
זה הופך את התשתית שלכם למאגר GIT,

00:15:58.720 --> 00:16:02.020
מה שהופך הכל לניתן למעקב, לשחזור ולתיקון עצמי.

00:16:02.120 --> 00:16:03.820
אם אתם מנהלים קוברנטיס באזר,

00:16:04.020 --> 00:16:06.300
נסו את אינטגרציית ה-G-Tops ב-AKS כבר היום.

00:16:06.440 --> 00:16:09.920
ההגדרה לוקחת 10 דקות וזה ישנה את הדרך שבה אתם חושבים על פריסות.

00:16:10.080 --> 00:16:13.440
הרשמו לערוץ לעוד הסברים פשוטים על כלי הענן של מייקרוסופט.
