הנושא של היום הוא כזה שכמעט כולם שמעו עליו, אבל מעטים מאוד באמת יודעים להסביר אותו. GitOps. בטח ראיתם אותו מוזכר במודעות דרושים, בהרצאות בכנסים או בתיעוד של Azure. אבל מה זה בעצם? האם זו סתם עוד מילת בזז בדבופס או שמדובר במשהו שונה מהותי? הנה הגרסה המקוצרת. GitOps הוא מודל תפעולי שבו Git הופך למקור האמת היחיד עבור כל התשתית שלכם, לא רק קוד האפליקציה, אלא כל מה שמריץ אותה. עד סוף הפרק הזה, תבינו מה זה באמת GitOps, למה זה הפך לסטנדרט לניהול קוברנטיס באזר, ואיך זה הופך שחזור גרסאות, רולבקס, לפשוט כמו פקודה אחת. הדרך הישנה, פריסות ידניות וזכילה בהגדרות, קונפיגיריישון דריפט. בואו נתחיל עם הבעיה ש-GitOps פותר. תארו לעצמכם שאתם מנהלים אשקול קוברנטיס באזר. יש לכם מפתחים שדוחפים קוד צינור C שבונה תמונות קונטיינרים, ומי שהוא מריץ כאבקט אל אפליי כדי לפרוס את התמונות האלו. אולי אתם, אולי חבר לצוות, או שאתם לוחצים על כפתור ב-Azure DevOps, ובכל מקרה הפריסה מתבצעת. זה עובד מצוין עד שזה מפסיק לעבוד. הנה מה שקורה אחר כך. מי שהוא בצוות צריך לתקן בג מהיר, אז הוא מתחבר ב-SSH לצומת, משתמש בפורטל של Azure, או מריץ כאבקט אל אדיט ישירות על פריסה. הוא מבצע שינוי קטן, כמו כבנון של ConfigMap, או משתנה סביבה שונה, וזה נראה תמים. או כך הם חושבים. הבעיה היא שהשינוי הזה מעולם לא חזר לג'יט, כך שלקלסטר שלכם יש עכשיו הגדרה שלא תואמת את מה שנמצא במאגר שלכם. לזה קוראים זכילה בהגדרות Configuration Drift. זכילה היא רוצה אחשקת כי היא עובדת בסדר עד הפריסה הבאה, כשמי שהוא מריץ כאבקט אל אפליי עם המניפסט המקורי ודורס את התיקון המהיר הזה. או גרוע מכך, הזכילה גורמת להתנהגות בלתי צפויה שאף אחד לא יכול להסביר. אתם מתחילים לנפות בגים, בודקים את היומנים, מסתכלים על ה-YMR בג'יט, ושום דבר לא נראה לא תקין. אבל הקלסטר עושה משהו אחר. אין לכם מושג מה השתנה, מתי זה השתנה, או מי שינה את זה. ראיתי את זה קורה. חבר לצוות מתחבר ב-SSH לצומת, משנה הגדרה כדי לבדוק משהו, שוכח להחזיר אותה, והולך הביתה. למוחרת, פריסה נשברת, ואף אחד לא יכול להסביר למה. מאגר ה-GIT נראה נקי, אבל הקלסטר הוא בלגן, ואתם תקועים שעות בניסיון להבין מה קרה. אז, הנה השאלה. מה אם הייתה דרך להכריח את הקלסטר תמיד להתאים למה שנמצא בג'יט? מה אם יכולתם להבטיח שכל מה שנמצא במאגר שלכם הוא בדיוק מה שרץ בסביבת הייצור? זה הרעיון המרכזי מאחורי גיטופס. מה זה גיטופס באמת? אז מה זה בעצם גיטופס? הנה ההגדרה הפשוטה ביותר שאני יכול לתת לך. גיט הופך למקור האמת היחיד שלך, לא רק לקוד, אלא לכל מה שהתשתית שלך צריכה כדי לפעול. כל הגדרה, כל מניפסט פריסה, כל משתנה סביבה, הכל נמצא בג'יט. שום דבר לא רץ על האשקול שלך, אלא אם כן הוא מוגדר שם. עכשיו, גיטופס הוא לא כלי שאפשר לקנות. זה מודל תפעולי כמו DevOps או DevSecOps. מערכת עקרונות שמנחה כיצד לנהל את התשתית שלך. תקן האופן גיטופס מציג ארבעה עקרונות ליבה, ואני רוצה לעבור על כל אחד מהם. ראשית, המערכת שלך חייבת להיות הצהרתית. זה אומר שאתה מתאר את המצב הסופי, לא את הצעדים להגעה אליו. אז, במקום לכתוב סקריפט שאומר, צור פריסה, הגדל לחמישה היתקים, חשוף את פורט 8080, אתה כותב קובץ YMR שאומר, אני רוצה חמישה היתקים בפורט 8080, והמערכת מבינה את הצעדים. וזה הצהרתי. שנית, זה חייב להיות מנוהל גרסאות. כל שינוי שאתה עושה למצב האשקול שלך הוא קומית בג'ית. כך, אתה מקבל היסטוריה מלאה של מי שינה מה, מתי ולמה. לא צריך יותר לנחש או לחפור ביומנים. שלישית, שינויים נמשכים, נמשכים באופן אוטומטי. האשקול פונה לג'ית כדי לראות מה חדש. בהמשך, אסביר למה זה כל כך חשוב. ורביעי, המערכת מסונקרנת ברציפות. יש סוכן תוכנה שרץ בתוך האשקול שלך ומשווה כל הזמן בין מה שיש בג'ית לבין מה שרץ בפועל. אם הם לא תואמים, הוא מתקן את ההפרש. זהו לולעת הסנקרון. תחשוב על זה ככה. ג'ית הוא התוכנית של האדריכל שלך. הוא מתאר בדיוק איך הבניין צריך להיראות. קוברנטיז הוא אתר הבנייה. וה-ITPS, אופרייטור, הוא מנהל העבודה. הוא מסתובב עם התוכנית ובודק כל קיר, כל קורא, כל חלון. עם משהו לא תואם, הוא מתקן אותו. נניח שמי שהוא מעצבת עושה שינוי לא מרושה, הוא מזהה את זה ומבטל את זה. התוכנית היא תמיד מקור האמת. אבל, כאן קורה השינוי האמיתי. איך פריסות עובדות בפועל? ב-C, CD מסורתי, אתה דוחף שינויים לאשקול. ב-G-Tops, האשקול מושך אותם, וההבדל הזה חשוב יותר ממה שהוא נשמע. פריסות מבוססות משיכה לעומת מבוססות דחיפה. בואו נדבר על איך פריסות עובדות כי כאן G-Tops משנה הכל. במודל הפאש המסורתי, צינור ה-C שלך עושה הכל. Azure Pipelines, Jenkins, GitHub Actions. הוא בונה את הקונטיינר מריץ בדיקות, ואז דוחף את התמונה הזו ישירות לאשקול הקאברנטס שלך. לצינור היבוד, Pipeline, יש אישורים שמעניקים לו גישה ישירה לאפי-איי של האשקול. הוא אומר, הנה הפריסה החדשה. החל אותה עכשיו, וזה עובד, אבל זה יוצר בעיית הבטחה. העניין הוא שאם הצינור הזה נפרץ, מי שהוא מזריק שלב זדוני, אסימון דולף או שתלות נחתפת, לצינור הזה יש קו ישיר לאשקול הייצור שלך. הוא יכול להרוס פריסות, למחוק מרחבי שמות, לשנות הגדרות, הכל עם ההרשאות שנתת לו כדי לבצע את עבודתו. כעת, תסתכל על מודל ה-G-Tops. התהליך מתחיל באותו אופן. ה-C בונה את הקונטיינר ודוחף אותו לרישום, Registry, כמו Azure Container Registry. כאן ה-C עוצר. הוא לא נוגע באשקול. במקום זאת, ה-C מעדכן מאגר GIT עם תג התמונה החדש. הוא משנה שורה אחת בקובץ YML את גרסת התמונה ומבצע קומית לשינוי. זה הכל. אין גישה ישירה לאשקול. לאחר מכן, מפעיל הגיטופס שרץ בתוך האשקול שלך מזהה את השינוי הזה. הוא מושך את המצב העדכני מגיט ומכיל אותו. האשקול פונה אל הג'יט ולא להפך. זהו מודל המבוסס על משיכה, Pool Based. האשקול שלך לעולם לא חוסף את ה-API שלו למערכות חיצוניות. הוא רק מושך מגיט. אם מי שהוא פורץ לצינור ה-C שלך, הדבר הגרוע ביותר שהוא יכול לעשות הוא לשנות מניפסט במאגר. הם לא יכולים לגעת באשקול ישירות. המפעיל מחליט מה להכיל ומתי. יש גם יתרון נוסף. אתה מפריד בין בנייה לבין פריסה. ה-C עושה את מה שהוא טוב בו, בנייה, בדיקות, שריקה. מפעיל הג'יטופס מטפל בפריסה. כל מערכת מתמקדת במשימה אחת. אם הבנייה נכשלת, שום דבר לא משתנה באשקול. אם הפריסה נכשלת, המפעיל מבצע ניסיון חוזר או מטריע בפניך. הפרדה נקייה. אז במקום שצינור ידחוף שינויים לתוך האשקול שלך, האשקול מושך את המצב הרצוי שלא מגיע. ההיפוך הפשוט הזה הופך את התשתית שלך לבטוחה יותר, ניתנת לביקורת יותר וקשה יותר לשבירה בטעות. לולאת הפיוס, אז איך המפעיל יודע מתי לעד כן? הוא לא מחכה להודעה. הוא מריץ לולאה מתמשכת, צופה בג'יט, משווה לאשקול, מכיל שינויים במידת הצורך, ואז עושה זאת שוב ושוב לנצח. זה נקרא לולאת הפיוס. היא רצה ללא הרף, כל כמה שניות או דקות, בהתאם להגדרה שלך. המפעיל אף פעם לא מפסיק לצפות. תחשוב על זה כמו על תרמוסטט בבית שלך. אתה מגדיר את הטמפרטורה הרצויה, נניח 21 מעלות. התרמוסטט בודק כל הזמן את הטמפרטורה בפועל. אם היא יורדת מתחת למד מינוס 21, החימום נדלק. אם היא עולה מעל, החימום נכבה. הוא ממשיך להתאים את עצמו כדי להתאים להגדרה שלך. מפעיל הג'יט אופס פועל באותה הדרך. גיט מחזיק במצב הרצוי, האשקול במצב הנוכחי, והמפעיל משווה ביניהם ללא הרף ומבצע התאמות. אז מה קורה כשמישהו עורך ידנית פריסה באשקול? אולי הם מריצים קאבקט אל אדיט כדי לשנות את מספר העותקים. המפעיל מזהה את ההבדל במחזור הסינקרון הבא שלו. באשקול יש כעת שלושה עותקים, אך בג'יט רשומים חמישה. לכן, המפעיל מכיל את המצב המוגדר בג'יט, והאשקול חוזר לחמישה עותקים. השינוי הבלתי מורשה נעלם. מה קורה כשדוחפים שינוי לג'יט? אותו תהליך. המפעיל מזהה את ההבדל ומכיל אותו. מפתח ממזג בקשת שינוי PR, שמעדכנת את גרסת התמונה מ-1.2 ל-1.3. המפעיל רואה את המניפסט החדש, מושך את התמונה החדשה ומפעיל את הפודים החדשים. שמטופלת על ידי בקר הרפליקסט. מפעיל הג'יט אופס דואג רק לקונפיגורציה. אם מניפסט הפריסה אומר חמישה עותקים, תמונה 1.3, ובשקול יש חמישה עותקים שמריצים 1.3, המפעיל מרוצה. לא אכפת לו אימפוד ספציפי ופעל מחדש. זו התנהגות רגילה של קוברנטיז. אך אם מישהו משנה את המניפסט בג'יט, או משנה את האשקול ישירות ויוצר סטייה, המפעיל פועל. זה מה שהופך את ג'יט אופס לבעל יכולת ריפוי עצמי. הוא לא רק פורס שינויים, הוא מונע מהתשתית שלך על לסתות ממה שהוגדר. לכן, אתה צריך מפעיל ג'יט אופס שרץ באשקול שלך. כאן נכנסים לתמונה ארגו-סי-די ופלוקס. ארגו-סי-די מול פלקס. אז אתה צריך מפעיל ג'יט אופס, ויש לך שתי אפשרויות עיקריות, שתיהן מצוינות. ארגו-סי-די ופלוקס הם פרויקטים בוגרים של CNCF, מה שאומר שהם עברו את הרף הגבוה ביותר ליציבות, קהילה ומוכנות ליצור. אבל הם ניגשים לאותה עבודה מזוויות שונות. ארגו-סי-די נבנה במקור על ידי אינטוויט, והוא מגיע עם ממשק אינטרנט. כשמתקינים את ארגו-סי-די, מקבלים לוח מכוונים שבו אפשר לראות כל אפליקציה, מצב הסינקרון, הבריאות והיסטוריית הפריסות שלה. אפשר לנווט, לראות הבדלים בין ג'יט לאשקול, להפעיל דברים ידנית ולאשר שינויים. הוא מיועד לצוותים שרוצים לוחות מכוונים ויזואליים ונקודות שליטה ידניות. פלקס הגיע מ-Waveworks, והוא מודולרי יותר. אין ממשק משתמש כברירת מחדל. עובדים דרך שורת הפקודה ומגדירים הכל כמשאבים מותאמים אישית של קוברנטיז. אתה יוצר אובייקט מאגר גיט שאומר, עקוב אחרי המאגר הזה, ואובייקט התאמה אישית שאומר, יישם את הנתיב הזה. פלקס אוסף אותו ומבצע סימקירון. זה מכריח רותח לאמץ תהליכי עבודה מקוריים של גיט, כי אין לוח מכוונים להישען עליו. עכשיו, הנה מה שחשוב למשתמשי אז'וור. פלקס היא אפשרות הג'יט אופס המוגדרת כברירת מחדל ב-Azure Kubernetes Service. מייקרוסופט בנתה את האינטגרציה המקורית סביב פלקס V2. כאשר מפעילים גיט אופס באשכול AKS דרך פורטל אז'וור, משתמשים בפלוקס מאחורי הקלעים. Azure Arc משתמשת גם היא בפלוקס לניהול ריבוי השקולות. אז, אם אתה מהנדס אז'וור, פלקס היא נקודת ההתחלה הטבעית. אבל לארגו-CD יש את החוזקות שלה. היא פופולרית יותר לתרחישי הנדסת פלטפורמה שבהם רוצים אישור בקרה מרכזי שמנהל השקולות מרובים. ממשק המשתמש מקל על צוותים שלא מרגישים בנוח עם שורת הפקודה, והיא משתלבת היטב עם ארגו-רולאוטס להפצה הדרגתית כמו פריסות כנרית, פריסות כחול, ירוק ודברים כאלה. ההבדל הארכיטקטוני המרכזי הוא זה, ארגו-CD פועלת כאפליקציה עצמאית עם שרת API משלה. פלקס פועלת כקבוצה של בקרים של קוברנטיז, המוטמעים עמוק יותר בתוך האשכול עצמו. פלקס מרגישה כחלק ממישור הבקרה של קוברנטיז, בעוד ארגו-CD מרגישה כפלטפורמה נפרדת שיושבת מעליו. פלקס גם מסתמכת רבות על קאסטומייז, שהוא כלי תבניות מקורי של קוברנטיז. ארגו-CD יכולה להשתמש בקאסטומייז, הלם, או YML פשוט. שתיהן תומכות בהלם, אבל לפלוקס יש בקר הלם יהודי שמטפל בגרסאות הלם באופן טבעי. אין כאן בחירה שגויה. שני הכלים עושים את אותה העבודה, אבל עבור מהנדסי Azure, פלקס היא הדרך הקלה ביותר. אפשר להפעיל GitOps עם פלקס בחמה לחיצות דרך פורטל Azure, להפנות למאגר Git, וזה מתחיל להסתנכרן. ללא התקנה נוספת, ללא שרת נפרד לניהול. GitOps ב-Azure, AKS, Azure Arc ו-Azure DevOps. אז, איך זה נראה בפועל כשמחברים את זה ל-Azure? בואו נתחיל עם AKS. ל-Azure Kubernetes Service יש תמיכה מובנית ב-GTops באמצעות Flux v2. בפורטל Azure, נכנסים לאשכול, מוצאים את אזור ה-GitOps ומגדירים אותו על ידי הפנייה למאגר Git. Azure Repos, GitHub, או כל מקום אחר. Flux מתחילה לעקוב, וכל מניפסט שתשים במאגר, ההוא יוכל על האשכול שלך באופן אוטומטי. אבל AKS הוא רק חלק אחד. Azure Arc מרחיבה את ה-GitOps לאשכולות שלא נמצאים באזר, מקומיים, בעננים אחרים או בקצה הרשת. מחברים אותם לאזר Arc, ומנהלים את כולם עם אותה תצורת GitOps. מאגר אחד, אשכולות רבים, מצב עקבי בכל מקום. זה מה ש-Aerts עושה. עכשיו, בואו נדבר על הפייפליין. Azure DevOps משתלב באופן טבעי במודל הזה, והנה התבנית הנפוצה. קוד המקור שלך נמצא ב-Azure Repos או ב-Github, ו-Azure Pipelines מנהל את ה-C. הוא בונה את תמונת הקונטיינר, מריץ בדיקות, שורק פגיעויות, ודוחף את התמונה ל-Azure Container Registry. לאחר מכן, הצינור מעדכן את המניפסטים בריפו של ה-GitOps שלך על ידי שינוי תגית התמונה מ-V1.2 ל-V1.3, מבצע קומית לשינוי ודוחף אותו. זה הכל. הצינור לעולם לא נוגע באשכול. קלאסטר, פלאקס שרץ בתוך AKS מזהה את השינוי ב-Git, מושך את המניפסט החדש, רואה את תגית התמונה המעודכנת ומכיל את הפריסה. פודס חדשים עולים, וההשכול מסתנקרן. אתה יכול להשתמש ב-Github Actions במקום ב-Azure Pipelines עם תעדיף. התבנית נשארת זהה. ה-C מטפל בבנייה, מעדכן את המניפסטים, ומפעיל ה-GitOps מטפל בפריסה. הכלי לא משנה, המודל הוא שקובע. הנה פרט חשוב. לעולם אל תשמור סודות ישירות ב-Git, לא מפתחות API, לא מחרוזות חיבור ולא אישורים. אפילו במאגר פרטי, סודות ב-Git מהווים סיכון. במקום זאת, השתמש ב-Azure Key Vault או ב-External Secrets Operator. המניפסט מתייחס לסוד לפי שם, והמפעיל מושך את הערך האמיתי מהוויולת בזמן הפריסה. ניתן גם להוסיף שכבת מדיניות מעל. Azure Policy עם Gatekeeper יכול לאחוב חוקים כמו איסור על קונטיינרים, מורשים או שימוש רק ברישומים מאושרים. עם מי שהוא מנסה לפרוס מניפסט שמפר את המדיניות, Gatekeeper חוסם אותו לפני שהוא מגיע לאשקול. היתרון האמיתי כאן הוא קנה מידה, Scale. עם 50 אשקולות AKS, אתה לא מנהל כל אחד בנפרד. הגדר את המצב הרצוי במאגר Git יחיד, וכל אשקול מסתנקרן למצב הזה. הוסף אשקול חדש, כוון אותו למאגר, והוא מגדיר את עצמו. צריך להדכן הגדרה בכל האשקולות. שנה קובץ אחד בג'יט והמפעילים יטפלו בשאר. זו ההבטחה של GitOps ב-Azure. מקור אמת אחד, הרבה אשקולות ללא סטיות. היתרונות המרכזיים. אז כל זה נשמע טוב בתיאוריה, אבל מה זה אומר בפועל עבור הצוות שלך? נתחיל עם מה שמושך את תשומת הלב של כולם. ביצוע Rollback הופך לעניין של מה בכך. פריסה גרועה יוצאת, האפליקציה מתחילה לזרוק שגיאות, משתמשים מתלוננים. בעולם הישן, היית ממהר למצוא את ההגדרה התקינה האחרונה, מריץ סדרת פקודות ידניות ומתפלל שלא פספסת משהו. בג'יטופס, אתה פשוט מבטל את הג'יט קומית. זה הכל, פקודה אחת. המפעיל רואה את הביטול, מושך את המצב הקודם, וההשקול חוזר למה שעבד קודם לכן. אין צורך ב-SSH, אין קאבקט-L, ובוודאי ללא פאניקה. נתיב ביקורת, audit trail, בנוי בפנים באופן אוטומטי. כל שינוי בתשתית שלך הוא קומית. אתה יודע מי ביצע אותו, מתי, ומה בדיוק השתנה. אין יותר ניחושים עם מי שהוא ערך דפלוימנט בית מינוס 2 לפנות בוקר ושכח לציין זאת. ההיסטוריה קיימת בלתי ניתנת לשינוי וניתנת לבדיקה. ריפוי עצמי, self-healing, הוא עוד דבר שנשמע כמו קסם עד שרואים אותו בפעולה. מי שהוא עורך ידנית דפלוימנט בתוך הקלאסטר. אולי מהנדס זוטר שמנסה לתקן משהו במהירות. האופרטר מזהה את הסטייה במחזור הסמכרון הבא ומבטל אותה. הקלאסטר מרפא את עצמו, ואתה אפילו לא יודע שזה קרה אלא אם בדקת את הלוגים. עקביות בין סביבות הופכת לאוטומטית. פיתוח, בדיקות, סטייג'ינג וייצור, כולם מושכים מאותו מאגר גיט. ענפים או תיקיות שונים, אבל אותו מקור אמת. אין יותר, זה עובד אצלי במכונה, כי הקלאסטר של הסטייג'ינג סתה מהייצור לפני שבועות. ההבטחה משתפרת כי הקלאסטר מושך מגיט במקום שדוחפים אליו. צינור ה-C שלך לעולם לא מחזיק אישורים שנותנים לו גישה ישירה לייצור. אם מי שהוא יפרוץ לצינור ה-C, הוא לא יוכל לגעת בקלאסטר. האופרטר מחליט מה מוכל ומתי. מינימום הרשאות כעקרון תכנון. יש גם נתונים שתומכים בזה. לפי מחקר דורה, צוותים שמאמצים גיטופס רואים ירידה של קף מינוס 25% בשגיאות פריסה. וזמן התאוששות ממוצע יורד לפחות מממינוס 2 דקות בהגדרות מיושמות היטב. זו לא תיאוריה, זה מה שארגונים מדווחים. ויש יתרון של שיתוף פעולה שקל לפספס. שינויי תשתית עוברים דרך פול רקווסטס, בדיקות קוד ובדיקות אוטומטיות, בדיוק כמו קוד אפליקציה. צוות התפעול וצוות הפיתוח שלך מדברים באותה שפה, גיט. אין יותר העברת משימות, אין יותר, פשוט תפרוס את זה בשבילי. כולם עובדים באותה הדרך, אבל עדיין יש כמה אי הבנות נפוצות שכדאי להבהיר. מיטוסים נפוצים ותחילת עבודה. נתחיל בהבהרת כמה מיטוסים נפוצים לגבי גיטופס. ראשית, אנשים רבים חושבים שגיטופס מיועד רק לקאברנטס. ובטח, זה עובד הכי טוב על קוברנטיז, אין על זה ויכוח. קוברנטיז בנויה סביב מצב הצהרתי וסמכרון, אז זה התאמה טבעית. אבל הנה העניין, אותה מקרונות חלים בכל מקום שיש לך הגדרות הצהרתיות. אפשר להשתמש בגיטופס עם טראפורם, פולומי ואפילו אנסיבר. פשוט תחסן את ההגדרות האלה בגיט ותן לצינור עבודה להכיל אותן. חלק הריפוי העצמי קשה יותר מחוץ לקאברנטס, אבל משמעת מקור האמת עובדת בכל מקום. מיטוס נוסף הוא שחייבים את ארגו-סי-די או פלקס כדי לעשות גיטופס. אם אתם רוצים את המודל המלא, פריסה מבוססת משיכה, סינקרון רציף וזיהוי שינויים, אז כן, אתם צריכים סוג כלשהו של גיטופס אופרייטור. אבל אפשר להתחיל הרבה יותר פשוט. פשוט שימו את כל המניפסטים בגיט והשתמשו בפול ריקווסטס לכל שינוי. זה לבדו מעניק לכם את רוב היתרונות של ביקורת ושיתוף פעולה. תמיד תוכלו להוסיף אופרייטור מאוחר יותר כשתצטרכו את האוטומציה. ולבסוף, יש את המיתוס שגיטופס מחליף את ה-C, CD לחלוטין. זה לא נכון. זה מחליף רק את חלק ה-CD. ה-C עדיין בונה את הקוד שלכם, מריץ בדיקות, שורק פגיעויות ודוחף אימג'ים של קונטיינרים לרגיסטרי. כל זה נשאר אותו דבר. מה שמשתנה הוא הדרך שבה האימג'ים האלה נפרסים. במקום שצינור ה-C ידחוף אותם לאשקול, ה-G-Tops Operator מושך את המניפסטים המעודכנים מגי. לכן, C ו-G-Tops עובדים יחד, לא במקום זה את זה. להתחיל זה למעשה די פשוט. בחרו אשקול AKS קטן והפעילו את פלקס דרך פורטל Azure. זה דורש רק כמה לחיצות. לאחר מכן, כוונו אותו למאגר גיט שמכיל קובץ YML פשוט של פריסה, צפו בסמכירון ואתם מוכנים לצאת לדרך. נסו לשנות ערך ב-YML, ביצעו קומית וצפו באשקול מתעדכן. זהו זרימת העבודה הראשונה שלכם ב-G-Tops. משם, תוכלו להוסיף סביבות, ללמוד Customize כפלקס משתמש בזה רבות, ולהגדיר עדכוני אימג'ים אוטומטיים עם כלים כמו Renovate או Dependable. אז זה G-Tops על קצה המזלג. זה הופך את התשתית שלכם למאגר GIT, מה שהופך הכל לניתן למעקב, לשחזור ולתיקון עצמי. אם אתם מנהלים קוברנטיס באזר, נסו את אינטגרציית ה-G-Tops ב-AKS כבר היום. ההגדרה לוקחת 10 דקות וזה ישנה את הדרך שבה אתם חושבים על פריסות. הרשמו לערוץ לעוד הסברים פשוטים על כלי הענן של מייקרוסופט.