# 413 GitOps with Yaron from Soluto

- Podcast: רברס עם פלטפורמה (Reversim Podcast), in Hebrew
- Episode: 413
- Date: 2021-07-17
- Duration: 32:44
- Guests: Yaron Idan (ירון עידן) — מוביל צוות DevOps, Soluto
- Topics: infra, architecture
- Page: https://www.reversim.com/2021/07/413-gitops-with-yaron-from-soluto.html
- Audio: https://m.reversim.com/reversim131_uijet.mp3

## Summary

עקרונות גישת GitOps לניהול תהליכי CD וסנכרון מצב הסביבות מול Git, מניסיונה של Soluto.

## Show notes

זהו פרק [413](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/413)של רברס עם פלטפורמה, הוקלט ב-8 ביולי 2021, וזה הטייק השני - הטייק הראשון היה מוצלח במיוחד, אבל הוא לא הוקלט . . .

אז הנה אתם פה, בטייק 2, יחד איתנו - כן, אני יודע שבשבילכם זה הטייק הראשון, בסדר - אז היום אנחנו נמצאים באולפן שלנו ביוקנעם עילית (!), אורי נמצא בחופש ומחליף את אורי [יונתן](https://www.linkedin.com/in/yonatanm/?originalSubdomain=il)מ-[Outbrain](https://www.outbrain.com/)- היי יונתן, מה נשמע?

(יונתן) היי, מה העניינים?

(רן) מצויין, ברוך הבא - ואיתנו נמצא גם [ירון](https://www.linkedin.com/in/yaron-idan/)מחברת [Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/)- היי ירון!

(ירון) היי, מה העניינים? נעים מאוד . . . .

(רן) טוב שבאת - היום אנחנו הולכים לדבר על [GitOps](https://about.gitlab.com/topics/gitops/), בפעם הראשונה.

ולפני שנדבר על [GitOps](https://about.gitlab.com/topics/gitops/), נעשה סבב היכרות קצר -

יונתן, היית כאן הרבה פעמים בפודקאסט לפני זה [הקדמה והיכרות - [בפרק הקודם](https://www.reversim.com/2021/06/412-serverless-at-via.html)], אבל בוא ספר לנו בכל זאת עוד קצת על עצמך -

- (יונתן) אז אני הגעתי ל-[Outbrain](https://www.outbrain.com/) לפני 10 שנים, כמהנדס Backend, ובחמש השנים האחרונות אני מנהל את הפיתוח.
- ומאזין ותיק של רברסים [וגם אורח - [328 The tension between Agility and Ownership](https://www.reversim.com/2017/12/328-tension-between-agility-and.html) או [Final Class 23: IDEs](https://www.reversim.com/2012/10/final-class-23-ides.html) או [131 uijet](http://m.reversim.com/reversim131_uijet.mp3) או [088 Final Class 2](http://m.reversim.com/reversim88_sgura2.mp3), וכמובן [412 Serverless at Via](https://www.reversim.com/2021/06/412-serverless-at-via.html)]

(רן) מצויין - טוב שאתה פה.

ירון - שני משפטים עליך?

- (ירון) אז אני [ירון עידן](https://www.linkedin.com/in/yaron-idan/), אני מוביל את צוות ה-DevOps ב-[Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/)
- אני משחק עם מחשבים כבר יותר מ-20 שנה - התחלתי בצבא בתור DBA ואחרי זה עברתי להיות מפתח.
- לפני כמה שנים כבר גיליתי את עולם ה-DevOps ועברתי אליו לחלוטין - ומאז אני מאוד נהנה מהעולם הזה.
- ב-[Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/) אני עושה את זה כבר משהו כמו חמש שנים.
- אני אספר גם קצת על [Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/), החברה שבה אני עובד - [Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/) היא חברה שרוצה להפוך את הטכנולוגיה לדבר יותר ידידותי, בעיקר עבור אנשים שעבורם טכנולוגיה “זו לא השפה הראשונה שלהם”.

- אז המשתמשים שלנו יכולים לגשת לממשקים ב-Web או ב-Mobile ובעצם לקבל את המיטב מהמנויים הדיגיטליים שלהם

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

- ובצד השני - יש להם גם את היכולת לפתוח איזשהו צ’אט, איזשהו Session של Chat עם Expert-ים - וגם הם משתמשים בפלטפורמה שאנחנו מפתחים בתל אביב, שנקראית [Anywhere Expert](https://medium.com/soluto-engineering/how-we-improved-customer-experience-and-saved-millions-of-dollars-with-data-science-8ee2908d0114), והיא מאפשרת לתומכים טכניים להיות מסוגלים לעשות את הסשנים האלה מהבית שלהם, מתוך איזושהי אפליקציה, כמו ב-[Uber](https://www.uber.com/il/en/)

- כבר לא צריכים לשבת בתוך איזה Cubical עם אוזניית מדונה ב-Setting קצת אפרורי - אלא ממש להשתחרר ולעשות את זה בתנאים שלהם.
- זה מייצר Disruption ענק לכל התעשייה הזאת של Tech-support בארה”ב - שם נמצאים רוב הלקוחות שלנו.

- (רן) אז זה, למעשה, Marketplace של תומכים ונתמכים -

- מצד אחד יש את הנתמכים, שאלו אנשים שיש להם, לצורך העניין, בעיה עם הטלפון או עם מכונת הכביסה או כל מכשיר אחר
- ומצד שני התומכים, שבזמנם . . . אולי בנוסף על עבודתם, כמו שאמרת כמו ב-[Uber](https://www.uber.com/il/en/), עושים השלמת הכנסה בזמנם החופשי.

- (ירון) כן - אנחנו אוהבים לחשוב על זה שאנחנו מצליחים לתרום לשני הצדדים הרבה מאוד

- גם לגרום לאנשים להרגיש שהם מוציאים את המיטב ממה שהם שילמו עליו כסף
- וגם לגרום לאנשים לעשות את העבודה שלהם בתנאים יותר משחררים [אה . . . ]

(רן) אז הנה שאלה מפתיעה, שהרבה זמן לא שאלו אותך - אמרת שאתה כבר מתכנת הרבה זמן, אז תהיתי מה היה המעבד הראשון שסבל את נחת זרועך?

- (ירון) אז יש לי [Deja Vu](https://www.youtube.com/watch?v=z_KmNZNT5xw) . . . אני חושב שזה היה [386](https://www.youtube.com/watch?v=M7YxGEG6BAQ)לדעתי? אבל נראה לי שעברתי על כל הסדרה, ואיפשהו בילדות מצאתי מצאתי איזושהי חוברת כזאת בעברית שמלמדת לתכנת ב-[Basic](https://time.com/69316/basic/), התחלתי לפתוח אותה - ומאז לא הפסקתי.
- (רן) עדיין ב-[Basic](https://time.com/69316/basic/)?
- (ירון) התקדמתי מאז - עכשיו אני ב-[Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)). . . [אין יותר טוב מזה]
- (רן) יפה . . . [Turbo Pascal](https://en.wikipedia.org/wiki/Turbo_Pascal) [אוקיי, יש יותר טוב…], [Object Pascal](https://delphi.fandom.com/wiki/Object_Pascal) . . . נחמד - הכחול והתכלת הזה, מקסים, הנדסת אנוש למופת.
- [אתה לא ציני, נכון? זה היה נפלא]

בסדר - אז אנחנו התכנסנו היום כדי לדבר על [GitOps](https://about.gitlab.com/topics/gitops/).

כולם, פחות או יותר, יודעים מה זה [Git](https://git-scm.com/), וכולם, פחות או יותר, יודעים מה זה Ops - החלק המעניין של DevOps, להזכירכם . . . אבל מה זה [GitOps](https://about.gitlab.com/topics/gitops/)? מה זה השילוב הזה ביניהם?

- (ירון) אז כן - דבר ראשון, הטרנד היום זה באמת לשים סיומת של Ops על הכל . . . יש [DataOps](https://www.ibm.com/analytics/dataops) ויש [MLOps](https://cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning), אז עכשיו יש גם Buzzword חדש שהוא [GitOps](https://about.gitlab.com/topics/gitops/).
- אנחנו ב-[Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/) עושים את זה כבר הרבה שנים, בלי לתת לזה את השם הזה, אבל אני כן אתן את ההרחבה של “מה זה בעצם אומר?”

- אז [GitOps](https://about.gitlab.com/topics/gitops/) היא איזושהי מכניקה של [CD](https://www.atlassian.com/continuous-delivery/principles/continuous-integration-vs-delivery-vs-deployment), איזושהי אימפלמנטציה (Implementation), שמאפשרת למפתח לדלבר (Deliver) את המוצר שלו ל-Production בצורה שבה [Git](https://git-scm.com/), או הקוד שיושב בתוך [Git](https://git-scm.com/), ייצג את המצב של Production.
- אז אם ב-[Continuous Delivery](https://www.atlassian.com/continuous-delivery/principles/continuous-integration-vs-delivery-vs-deployment) רגיל, יש איזושהו [מבוך רציני](https://www.nationalgeographic.com/history/history-magazine/article/minotaur-in-greek-roman-mythology), שהקוד צריך לעבור מהרגע שהוא Committed ל-Branch הראשי, ועד שבאמת אפשר לראות אותו ב-Production - אז [GitOps](https://about.gitlab.com/topics/gitops/) מנסה לחסל כמה שיותר מהמחסומים האלה
- ובאמצעות איזשהו רכיב שעושה פעולה שנקראת [Reconciliation](https://web.archive.org/web/20210728200625/https://platform.deloitte.com.au/articles/gitops-is-reconciling-desired-state-in-git-with-a-runtime-environment), לבדוק מה המצב של הקוד ב-[Git](https://git-scm.com/), ולראות האם Production עונה על אותן הגדרות - ואם יש צורך אז לסנכרן בין שני הרכיבים האלה.

(רן) כשאתה אומר “מבוך” ,אתה מתייחס, נגיד, לפרישה בהתחלה כ-[Canary](https://martinfowler.com/bliki/CanaryRelease.html), ואחר כך אולי פרישה של 25% ב-Data Center אחד ואחר כך ב-Data Center אחר? זה המבוך שאליו אתה מתייחס?

- (ירון) אז האמת שהמבוך הזה יכול להיות קיים גם ב-[GitOps](https://about.gitlab.com/topics/gitops/), אבל אנחנו, ספציפית ב-[Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/) כן משתמשים ב-[Canary](https://martinfowler.com/bliki/CanaryRelease.html)

- הוא אפילו ניהיה הרבה יותר נגיש עבורנו בזכות השימוש שלנו ב-[GitOps](https://about.gitlab.com/topics/gitops/)
- שני הדברים האלו הם לא Mutually-exclusive

- המבוך שאני מתאר זה בעיקר להיכנס לתשתית של ה-CI, ללחוץ על “Deploy”, לראות שמשהו נתקע, להיזכר שהיה צריך לשדרג את ה-Script שעושה את זה . . .

(רן) כן . . . בעצם אתה מדבר על ההתערבות האנושית שנדרשת אחרי שהקוד כבר נמצא ב-Master . . .

- (ירון) נכון - וגם זיהוי של טעויות שמתרחשות בזמן ה-Deployment -

- נניח, אצלנו ראינו הרבה פעמים שבגלל התאימות היחסית של Pipelines של Deployment, הרבה פעמים יש שגיאה ב-Production, והיא לא משתקפת חזרה ל-Pipeline של ה-Continuous Delivery -
- ואז המפתח פשוט יושב ואומר “טוב, זה כנראה לוקח לו הרבה זמן . . . זה כנראה הגמדים שלוקחים את הקופסאות ל-[AWS](https://aws.amazon.com/)התעכבו בדרך . . . “
- ורק אחרי 20 דקות או 30 דקות יש איזושהי הבנה שמשהו השתבש בצורה נוראית . . .

(רן) זאת אומרת - ברגע שאני עושה Merge של Branch ל-Master - אני אף פעם לא אעשה הרי Commit ל-Master, זה אסור . . . - ברגע שאני עושה עושה Merge ל-Master, אני צריך להניח שהכל, כאילו, ב-Production, נכון?

- (ירון) לאו דווקא
- יש כלים של [GitOps](https://about.gitlab.com/topics/gitops/) שלוקחים את זה בתור ה-[First Class Citizen](https://www.reddit.com/r/learnprogramming/comments/gumexu/what_are_first_class_citizens/), הם באמת בונים על זה שתיהיה סדרה של הגנות

- בין אם זה טסטים ו-[Smoke Tests](https://www.youtube.com/watch?v=xT6GIkGbDMM) או [Canary](https://martinfowler.com/bliki/CanaryRelease.html)ו-Gradual releases, כמו שהזכרת
- והם פשוט מניחים שהמשתמש עושה בהם שימוש.

- אנחנו מעדיפים Deployments יותר קונטקסטואליים, ובגלל זה בהתחלה התחלנו להשתמש ב-[Flux](https://github.com/fluxcd/flux), שהוא כלי של [WeaveWorks](https://www.weave.works/)שלוקח את המתודלוגיה הזאת קדימה, ומנסה באמת “לאסור על ה-user” ליצור שינויים . . . ליצור הבדלים בין Production לקוד.

- ועברנו ל-[Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/)- כלי של [Intuit](https://www.intuit.com/) - שחולק איתו הרבה מהקוד, אבל משנה הרבה מהדינמיקה והמכניקה.

- הוא מאפשר באמת קודם כל להכניס את הקוד לתוך ה-Master - ורק אחר כך להגיד למפתח “תעשה את הסנכרון שלך בצורה מודעת”.

- יש גם אופציה ליצור Sync אוטומטי, ואז ברגע שההגנות האלו נמצאות ובאמת יש את הבטחון לדעת שמה שנכנס ל-Master יכול להגיע ל-Production, ניתן להדליק את ה-Flag הזה ולהינות מחיים עם הרבה פחות Toil, הרבה פחות עבודה ידנית.

(רן) אז דיברת על Reconciliation ועל זה שיש הפרשים בין מה שקיים ב-Master, שאמור לתאר את סביבת ה-Production, לבין סביבת ה-Production האמיתית, וההפרשים האלה יכולים לנבוע מכמה דברים -

- קוד שנכנס ל-Master, אבל עדיין לא עבר Deployment,
- אבל זה יכול גם להיות לנבוע מזה שהלך איזשהו איש Ops ושינה את ה-Production . . . נכנס ל-[AWS](https://aws.amazon.com/) או עשה SSH לאיזשהו שרת ושינה שם משהו
- ואולי יש Drift-ים מכל מיני סוגים, ואני בטוח שכל מי שנמצא בעולם האופרציה נתקל בדברים האלה.

אבל איך . . . מתי זה הגיע לנקודה שבה זה ממש הפריע לכם, ואמרתם “[עד](https://www.youtube.com/watch?v=GwmJ76VjXaE)[כאן!](https://www.youtube.com/watch?v=GwmJ76VjXaE) פה אנחנו חייבים לקום ולעשות איזשהו מעשה! אצלנו לא יהיה הבדל בין Master ל-Production!” . . . היה איזשהו אירוע מכונן שגרם לכם לעשות את זה?

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

- כמו שאמרתי - עשינו את זה עוד הרבה לפני שקראו לזה [GitOps](https://about.gitlab.com/topics/gitops/), והתחלנו במקומות הרבה יותר Low-stakes מסביבת ה-Production, שמגישה תוכן לקרוב למאה מיליון משתמשים היום . . .

- איפה שהתחלנו זה בתשתית הניטור שלנו - זה היה כבר לפני יותר מחמש שנים.
- רצינו לעשות דמוקרטיזציה של הניטור, לא רצינו שזה יהיה משהו שמפתח אומר “אני רוצה לנטר בבקשה . . . קח את השליפה הזו ושים אותה בבקשה על הכלי”
- וכדי שזה יקרה, יצרנו איזשהו Repository, שמנו בו קובץ [JSON](https://www.json.org/json-en.html)ענק ואמרנו למפתחים: “פשוט תכתבו פה את כל מה שאתם רוצים לנטר, וזה יגיע “בדרך קסם” אל התשתית”.

- אז זה היה ה-Production הראשון אצלנו שבעצם כל Commit ל-Master הסתנכרן עם הקוד, והיופי של זה היה שבאמת יכולנו לשחק פה ב-Stakes יותר נמוכים.

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

(רן) אז למעשה, המוטיבציה הראשונית שלכם הייתה לספק חווייית-מפתח יותר טובה - במקום שהוא ילך ויפנה אליכם ויבקש “תוסיפו לי בבקשה Monitoring” או שבמקום שיצטרך להכיר את כל החוכמות של כלי הניטור, הוא יכול לערוך איזשהו קובץ [JSON](https://www.json.org/json-en.html)ולעשות Commit - ומבחינתו זה ממשק העריכה - ועכשיו הוא מבין שברגע שהוא עשה Commit, יש איזשהו Hook שלוקח את הקובץ הזה ועושה לו Apply ל-Production.

אז מבחינתך זה איזושהי חוויית מפתח יותר טובה - אבל זה עדיין . . . זאת אומרת, אני לא רואה עדיין איך זה בא ומטפל בתקלות Production . . .

(יונתן) לכאורה, יכולת לממש את זה גם, נניח, עם CI/CD רגיל, נכון? בלי “הקונץ” הזה של הסנכרון או לבדוק את הפערים?

- (ירון) נכון - ואני אפילו אגיד שבאיזשהו שלב עברנו לזה: היה לנו Repository אחד מרכזי ואז הכנסנו איזושהי תשתית “כמו CD”, שלוקחת Commit-ים מ-Repository אחד ומזריקה אותם ל-Repo המרכזי הזה.
- ושם כבר התחילו להרגיש את החסרונות שאמרתי -

- הכלי היה נשבר הרבה פעמים
- היו נוצרים מצבים שבהם ה-Pipeline הקלאסי הזה, שמנסה להגיע למקום ה-[GitOps](https://about.gitlab.com/topics/gitops/)-י, נתקע בגלל כל מיני טעיות שלא חזינו מראש, והיה קשה לקבל Visibility על דבר כזה.
- זה דורש יצירה של המון כלים, רק כדי שהדבר הזה יעבוד בצורה שהיא Flowless.

(יונתן) עוד משהו שרציתי לשאול - איך ה-[GitOps](https://about.gitlab.com/topics/gitops/) אל מול [Infra-as-a-Code](https://www.redhat.com/en/topics/automation/what-is-infrastructure-as-code-iac#:~:text=Infrastructure%20as%20Code%20(IaC)%20is,to%20edit%20and%20distribute%20configurations.) - זה משלים את זה? זה השלב הבא של זה?

- (ירון) זאת שאלה מעולה, כי באמת הרבה פעמים, את ה-[Infra-as-a-Code](https://www.redhat.com/en/topics/automation/what-is-infrastructure-as-code-iac#:~:text=Infrastructure%20as%20Code%20(IaC)%20is,to%20edit%20and%20distribute%20configurations.) אנחנו עדיין עושים עם כלים שהם יותר “Push-יים” כאלה

- אנחנו עבדנו קצת עם [Terraform](https://www.terraform.io/), נטינו יותר לכלי שנקרא [Pulumi](https://www.pulumi.com/), שהוא סוג-של-כזה-Wrapper סביב [Terraform](https://www.terraform.io/), עם שפות תכנות יותר נפוצות.

- ושם מרגישים בדיוק את העניין הזה - שכדי עכשיו לשנות את ה-Infrastructure שלי, אני צריך לעשות Apply . . .

- ולפני שאני צריך לעשות Apply, אני ארצה לעשות איזשהו Preview, ולהציג אותו למפתחים, כדי שהם יבינו איזה שינוי הולך לקרות.
- ואז המנגנון הכמעט-אימפרטיבי (Imperative) הזה הוא נורא מורגש - נורא מורגש שהולך להיות איזשהו שינוי, וצריך לעשות איזושהי פעולה כדי שזה יקרה.
- ואחד הכלים שאנחנו מסתכלים עליהם יותר ויותר נקרא [Xstate](https://xstate.js.org/docs/guides/actors.html), וזה כלי שבאמת שם את ה-Infrastructure שרוצים ליצור כ-Custom resources בתוך Cluster של [Kubernetes](https://kubernetes.io/), ואז יש איזשהו Reconciliator, שבמקום לעבור עם ה-API של [Kubernetes](https://kubernetes.io/), הוא עובד עם ה-API של [AWS](https://aws.amazon.com/)או [Azure](https://azure.microsoft.com/en-us/)או [GCP](https://cloud.google.com/)- יוצר שם את אובייקטים.
- וזה שוב - שינוי תפיסה יחסית מאסיבי, כי זה אומר שברגע שמפתח עשה commit ל-Master, אז [Xstate](https://xstate.js.org/docs/guides/actors.html) תופס אותו ומסנכרן אותו לענן

- אין איזשהו שלב באמצע של Apply, של Preview . . . כל הדברים האלה חייבים לקרות ב-PR, לפני שהקוד משתנה.

(רן) מצד אחד - זה נשמע נורא אלגנטי . . . כאילו פיהם וליבם של Production ו-Master שווים. מגניב, נורא סימטרי כזה, נורא פשוט . . .

מצד שני - גם נשמע נורא מסוכן: עשיתי Commit . . . סליחה - עשיתי Merge ל-Master, לא עשיתי Commit ל-Master. . . עשיתי Merge ל-Master, ואולי אני לא כל כך יודע מה זה הולך לייצר, זאת אומרת - אני לא יודע שזה עכשיו אולי הולך לייצר בלגאן לא נורמלי בתוך Production. . . אין לי איזשהו מקום קטן שבו אני יכול ככה להתנסות, בקטנה, לפני שאני עושה את ה-Commit? איך מטפלים? איך עושים מיטיגציה (Mitigation) למוטת הכנף הענקית שפתאום כל אחד מקבל?

- (ירון) זו שאלה נהדרת, כי היא מחזירה לשאלה הקודמת ששאלת - של בעצם “איזו בעיה ניסינו לפתור?”
- כי דווקא בניגוד או בהיפוך כזה של התמונה הזאת, החוסר ביטחון הגיע לפני שהיה לנו את ה-[GitOps](https://about.gitlab.com/topics/gitops/)

- הייתה לנו בעיה שהתשתית… פשוט כשעובדים עם תשתיות כמו [Kubernetes](https://kubernetes.io/)אז התשתית נהיית מאוד מאוד מורכבת
- היא גם נהיית במצב שכדי להרים Cluster חדש, במקרה של איזושהי בעית Production, בנאדם צריך לעשות פעולה ידנית, שיכול להיות שיכולה לארוך כמה שעות - וזה היה מצב מאוד לא נוח.
- קשה היה לדעת, כשיש לי מספר מוגבל של Cluster-ים - במקרה שלנו שניים - ואם עכשיו אחד מהם נופל אז אני צריך להיכנס למרוץ נגד השעון כדי ש-Cluster חדש יעלה.
- וזה גם עיכב אותנו מלייצר, אולי, את מה שרמזת אליו - שזה איזשהו מקום, איזשהו “מגרש משחקים” או ארגז חול בצד, שבו אפשר לעשות את כל השינויים בצורה בטוחה, ולדעת שלא משנה מה אני אשבור - Production לא ידע מזה.
- וזאת בעיה אחת שבאמת נאבקנו בה הרבה לפני שהגענו לעולם ה-[GitOps](https://about.gitlab.com/topics/gitops/) המובטח.

- בעיה נוספת, שגם אותה אני אסביר איך [GitOps](https://about.gitlab.com/topics/gitops/) פתר עבורנו, זה הארגונומיה של המפתחים מול [Kubernetes](https://kubernetes.io/)

- כי מפתחים אצלנו היו רגילים לעבוד מול אילו-שהם Self-contained Services, שרצים על [PaaS](https://azure.microsoft.com/en-us/overview/what-is-paas/#:~:text=Platform%20as%20a%20service%20(PaaS,%2C%20cloud%2Denabled%20enterprise%20applications.), כמו [Heroku](https://www.heroku.com/)

- במקרה שלנו זה היה [Azure](https://azure.microsoft.com/en-us/), אבל זו הייתה איזושהי סביבה סגורה, מכונות וירטואליות שכל מפתח קיבל, שמריצות את ה-Services שלו.

- ופתאום לעבור ל-Cluster שהוא [Multi-tenant](https://cloud.google.com/kubernetes-engine/docs/concepts/multitenancy-overview), שכולם עובדים ביחד, שצריך לדעת לא “לדרוך אחד לשני על הבהונות” . . . שיש בהם הרבה-הרבה אובייקטים חדשים שהמפתחים לא מכירים - יצר שינוי פרספקטיבה, שלא היה קל להנחיל לצוותי הפיתוח.
- אנחנו בצוות עבדנו עם [Kubernetes](https://kubernetes.io/) הרבה, אבל המפתחים לא תמיד רצו להבין את המורכבות הזאת, והיה קשה לחשוף אותם לזה בצורה שתפגע איפשהו באיזון הזה . . .

(רן) אז גם בהקשר הזה, זה נשמע כאילו אתה בעצם מייצר ממשק למפתחים עבור [Kubernetes](https://kubernetes.io/) . . . זאת אומרת: “אתם לא צריכים ללכת ולהשתמש ב-[Kubectl](https://kubernetes.io/docs/reference/kubectl/overview/) או בכלים אחרים” אלא אתם צריכים, לצורך העניין, “לעשות Commit לאיזשהו קובץ [JSON](https://www.json.org/json-en.html)ומשם אנחנו כבר נטפל בזה”.

- (ירון) נכון . . . אז היום הכל [YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.), אבל כן - זה השינוי המרכזי שעשינו . . .
- (רן) . . . השתדרגנו . . .
- (ירון) . . . עכשיו יש מקפים במקום סוגריים מסולסלים . . .
- (יונתן) תזהיר את [אבישי](https://web.archive.org/web/20210729123354/http://notarbut.co/ep_54_cost_savings/)-[יש לו איזה משהו נגד YAML-ים](https://www.reversim.com/2017/07/summit-2016-operations-you-keep-using.html?view=sidebar) . .
- (רן) מאזיננו [אבישי](https://www.linkedin.com/in/nukemberg/?originalSubdomain=il)- תסתום רגע את האוזניים . . . כל העולם [YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.) כבר, אין מה לעשות . . .
- (ירון) בהרבה מקומות ראיתי שכבר מגייסים מפתחי [YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.) . . .
- (רן) כן - אולי המפתחי [XML](https://en.wikipedia.org/wiki/XML#:~:text=Extensible%20Markup%20Language%20(XML)%20is,free%20open%20standards%E2%80%94define%20XML.)בפנסיה יהפכו למפתחי [YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.) . . .

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

- (יונתן) אתה לא עושה Commit ל-Master, רן . . . . תזכור - עוד פעם, אני אעשה לך Reject . . .

(רן) איך נפלתי . . . זה הפרוידיאני בי שמדבר . . .

אז כל פעם שאני עושה Commit ל-Branch, ו-Merge ל-Master, אחרי Code review, כמובן, ומתקן את כל ההערות, ועובר CI - אז לאפליקציה האחרונה המגניבה שכתבתי למכונת הכביסה של סבתי - אז זה מיד הולך לכל מכונות הכביסה בעולם? לכל הטלפונים בעולם? זאת אומרת - זה באמת מה שאנחנו רוצים?

- (ירון) אז התשובה היא “לא” . . . כמו שאמרתי, יש לנו מידה מאוד חזקה של Control, כי ככה רצינו לבצע את השינוי הזה

- לא רצינו להפחיד אנשים ולהגיד לכל מי שעובד על הקוד אצלנו “תזהרו מאוד מה-Master!”

- הרעיון היה באמת לאפשר לאנשים יותר Visibility, יותר שקיפות - ולאט-לאט להגיע למודל הבגרות הזה, שבו אנחנו מרגישים בנוח לסנכרן דברים בצורה אוטומטית.
- זה אומר שהיום, רב שירותי ה-Backend שלנו נפרשים באמצעות כלי [GitOps](https://about.gitlab.com/topics/gitops/)

- באמצעות [Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/), שציינתי קודם

- מה שהמפתחים מקבלים מזה זה להחליף את ה-Pipeline המסועף והקשה להבנה באיזשהו Commit ל-Master

- עכשיו, במקום לעשות את ה-Deployment בשלב הזה של ה-Pipeline, יש רק Commit אחד, שמשנה את ה-Version ש-[Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/) מסתכל עליו.
- ברגע שנעשה שינוי ה-Version הזה, המפתח הולך ל-UI אחר, של [Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/) - הוא רואה בצורה מאוד מאוד ברורה שהשתנה שדה מסויים ב-[YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.) של ה-Deployment שלו, עם ה-Tag.
- וזה מייצר הרבה דברים מאוד טובים עבורנו - כי גם אם עכשיו מבצעים סנכרון של הדבר הזה, אז זה כבר לא איזשהו Context-switch של לעבור עכשיו ולהסתכל מה המצב - [Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/) ממש מראה יפה, עם לבבות ירוקים [green heart](https://web.archive.org/web/20210618111021/https://coolsymbol.com/copy/Green_Heart_Emoji_Symbol_%F0%9F%92%9A) או לבבות אדומים-שבורים broken heart, מה הסטטוס של הגרסא הישנה והגרסא החדשה.

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

- במצב הנוכחי, זה דווקא הגביר מאוד את ה-Control ואת השליטה שלנו ב-Production, ולא יצר אי-יציבות וחסר ודאות.

(יונתן) ה-State הזה, נניח של שינוי הגרסא - נניח שאני מהנדס, ויש לי גרסא חדשה - אתה אומר, בעצם, שדבר ראשון אני צריך לעשות Branch ו-Commit ו-Merge, בגלל שאני רוצה גרסא חדשה, עם איזשהו Tag - זה ב-Repository של האפליקציה שלי או שזה ב-Repository של האפליקציה שמנהלת את ה-[GitOps](https://about.gitlab.com/topics/gitops/)?

- (ירון) זו שאלה נהדרת, כי באמת אנחנו עושים משהו לא מסורתי שם -
- אנחנו כן עושים את כל השינויים האלו ב-Repository של הקוד, ובדרך כלל - אני מקשיב בכנסים, קראתי פוסט יפה של מישהי מ-[Riskified](https://www.riskified.com/)שכותבת [איך הם עובדים עם Argo](https://medium.com/riskified-technology/gitops-deployment-and-kubernetes-f1ab289efa4b) - וראיתי שהקונצנזוס, פחות או יותר, הוא להפריד את ה-Repository שהמכונות קוראות וה-Repository שבני האדם קוראים . . .

- אז בדרך כלל, מה שמקובל זה ליצור, נגיד, את “Yaron-API”, להגיד שזה הולך להיות ה-Service שלי, ופה אני, כבן אדם, כותב קוד - ואז לתת למכונה לעשות את ה-Commit לאיזשהו Repository אחר, שיקרה “Yaron-API-Deployment”, ומשם לקחת את ה-State שה-[Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/) מסתכל עליו.

- אנחנו, פשוט בגלל שרצינו את הנושא הזה שאמרתי קודם - רצינו לשפר ארגונומיה של מפתחים - לא רצינו שיהיה להם את ה-Context-Switch הזה, את המעבר כל הזמן בין ה-Repo שבו הקוד כתוב לבין ה-Repo שבו ה-Deployment קורה . . .

(יונתן) גם יש עוד יתרון - אתה תעשה [git-log](https://git-scm.com/docs/git-log) ותראה את ה-Deployments ולא . . .

- הרבה אנשים אומרים הפוך . . . הם אומרים “אני לא רוצה לראות Commit-ים של מכונה” [אחלה שם לפודקאסט, אגב], זה לא קדוש.

- אבל אנחנו מאמינים שה-Commit-ים האלה באמת, כמו שאתה אומר, מייצגים את השינוי של ה-State.

(רן) אני מניח שהויכוח הזה, או הדילמה הזו, במצב של Mono-Repo היא פחות רלוונטית - עדיין יש התלבטות, נניח שאנחנו בעולם של Mono-Repo, ואני מבין שאתם לא - יש את ההתלבטות של האם לשים את הקונפיגורציה קרוב לקוד, או את כל הקונפיגורציה במקום אחד, לצורך העניין באיזשהו Branch או תת-עץ של ה-Mono-Repo.

גם אני הייתי בהתלבטות הזאת הרבה פעמים, ואני חושב שיש פה Trade-off - מצד אחד זה נחמד שהקונפיגורציה קרובה לקוד, ולפעמים ממש בתוך הקוד; ומצד שני, זה גם נחמד לקבל איזשהו מבט על כל הקונפיגורציה של כל ה-Service-ים השונים, וככה להבין איך הדברים קורים.

אז אני מבין שאתם יותר נוטים לשים את הקונפיגורציה קרוב לקוד, אם אפשר לקרוא לזה “קונפיגורציה”, בוא נקרא לזה . . .?

- (ירון) אז גם פה יש כמה תשובות . . .
- דבר ראשון - אנחנו לא נגד Mono-Repo, אנחנו מאוד-מאוד בגישה של “לתת למפתחים ולמפתחות פשוט להחליט מה הכי טוב ב-Context של המשימה הנוכחית”

- ולכן יש אצלנו קבוצה שלמה שעובדת בתוך Mono-Repo אחד, שמחזיק את כל ה-Service-ים, בלי שום קונטקסט
- ויש לנו קבוצה שעובדת עם Repo-per-Service
- ויש קבוצה שלישית, שעובדת עם Mono-Repos קונטקסטואליים . . .

(יונתן) אתם לא נגד Mono-Repo - פשוט יש לכם הרבה כאלה, זה מה שאתה אומר . . .

- [“רבים מידידי הטובים ביותר” וכו’…]

- (ירון) בדיוק . . . אנחנו אוליגו-Repo . . .
- (רן) לא, יש לזה גם שם - Multi-Mono-Repo . . . כתבו את זה לפנינו . . .
- (ירון) כן . . . אז לא הגענו למצב שבאמת אנחנו יכולים להגיע לרמות של[Facebook, והקסמים שהם עשו עם Mono-Repos](https://engineering.fb.com/2014/01/07/core-data/scaling-mercurial-at-facebook/) שם.

- בסוף, Mono-Repo ענק שמחזיק את כל הקוד זו לדעתי משימה הנדסית כבירה, וצריך לעשות אותה בצורה מאוד מחושבת.
- ושוב - בגלל הצורה ה-Distributed והלא-פרספקטיבית שאנחנו עובדים בה, שאנחנו לא רוצים להגיד לאנשים איך לעבוד, אז כמעט בלתי אפשרי לחשוב על “כל המפתחים ב-[Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/)כותבים ל-Repository אחד”,

- כי דברים קמים, אנשים רוצים לשנות דברים, להתנסות עם משהו חדש
- וברגע שאנחנו מאפשרים את זה, אז לא נקבל אף פעם את השליטה של להגיד לאנשים “כל ה-Commit-ים שלכם עכשיו יהיו רק ב-Soluto-Code”

- [וגם אז - רק אם הם [טובים](https://www.youtube.com/watch?v=jDQzS6bjy48)]

- וזה נחמד, כי זה כן גורם לנו להתקדם קדימה . . .

(רן) כן . . . אני חייב להעיר שאם כל זה שאני מכבד את שיקול דעתם של המפתחים, ואני הרבה פעמים גם לא רוצה להגיד למפתחים אחרים מה לעשות - אני חייב להגיד שלפעמים יש הרבה חוכמה בכן להגיד למפתחים מה לעשות,

- כי אני חושב שהרבה פעמים ההחלטות הן שרירותיות, והחלטה אחת טובה כהחלטה אחרת - הבעיה שכששתי החלטות, ששתיהן שקולות, אבל כששתי החלטות נלקחות, אז אתה בבלגן . . .
- אז דווקא בקטע הזה אני נוטה להיות קצת יותר הדוק, ולבוא ולהגיד “חבר’ה, נכון - יש פה שתי דעות, אבל אני בוחר את זאת, “כי ככה” - ובואו נתגלגל עם זה הלאה”
- כי אחרת פשוט נוצר [בלגאן](https://www.youtube.com/watch?v=QKSkcE8NQiI)- וראיתי את זה קורה בחברות גדולות . . . ראיתי את זה קורה ב-Google,אני מבין ממה שאתה אומר שזה קורה גם ב-Facebook . . .
- מתקבלות החלטות שרירותיות, וכל המפתחים לפעמים אולי מקטרים - אבל הולכים לפיהן
- וזה עושה הרבה טוב, בסופו של דבר - “[המסר](https://www.youtube.com/watch?v=MkTw3_PmKtc)[שלי לאומה](https://www.youtube.com/watch?v=MkTw3_PmKtc)” הוא של “לא לפחד לקבל החלטות בשביל המפתחים”, ובסופו של דבר, בשורה התחתונה, אני חושב שזה עושה טובה, כי זה יותר קל כשדברים הם אחידים.

- (ירון) זה מעניין מאוד - ואני חושב שמה שאתה מציין הוא גם פונקציה של גדילה.

- אני חושב שיש שלב מסויים שבו חברה יכולה להרשות לעצמה להתפזר יותר ולנסות יותר דברים, ויש שלב מסויים שבו צריך להתכנס ולהגיד “אוקיי, ה-Business הגיע ל-SLA מאוד גבוה שהוא צריך לספק, החברה גדולה מספיק כדי שלא נוכל לתת ל-15 Frankenstein-ים לרוץ במקביל, המפלצות של . . .
- (רן) כל מפלצת טובה . . . כל מפלצת לכשלעצמה היא בסדר . . . אני לא אומר שההחלטות הן לא נכונות, הבעיה שיש החלטות אחרות, והחלטות סותרות לפעמים, החלטות שלא עובדות טוב אחת עם השנייה

- או אפילו אם לא סותרות - לייצר Infrastructure שמתאים גם . . . לצורך העניין אפשר לקחת שפות תכנות - Infrastructure שמתאים גם ל-[Python](https://www.python.org/)וגם ל-[Ruby](https://www.ruby-lang.org/en/)וגם ל-[Java](https://www.java.com/en/)זה אפשרי, אני בטוח שזה אפשרי - זה רק יותר קשה.
- אז אתה יודע - שפות תכנות אפשר בדרך כלל, רוב החברות מתקבעות, זו לא הבעיה - אבל עדיין יש עוד הרבה בחירות אחרות:

- איך עושים Messaging, איך שומרים, באיזה Database משתמשים וכו’.

- (יונתן) אני חושב שאני מסכים - מבחינתי, המדד של מתי צריך לקחת כזאת החלטה או “דיקטטורה נאורה” שכזאת זה כשאתה צריך “לעבוד לרוחב”

- דיברת על תשתיות - ברגע שאתה צריך להתחיל . . . כשתשתיות נהייה “עניין”, אז קשה לתמוך בוריאנטים השונים . . .
- [[כן](https://twitter.com/RanBalicer/status/1415416913350602755). . .]

(רן) בוא נחזור רגע אחורה ל-[GitOps](https://about.gitlab.com/topics/gitops/) . . . אז נלך, שנייה, Back-to-Basics: הבנו את הקונספט של “Mater ו-Production צריכים להיות שווים”. אז אני, אתה יודע, מתחיל ככה ב-Back-to-Basics ואני רוצה לעשות [GitOps](https://about.gitlab.com/topics/gitops/), אוקיי? אז מה אני עושה? אני מייצר [Git-Hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks), ובעצם אני צריך לדאוג לשני דברים . . .

1. אחד זה שיהיה לי קוד שיודע לתאר את סביבת ה-Production, נגיד - כמה Server-ים, כמה Services, מה ה-Multiplicity שלהם, כל מיני דברים . . . מה שיודע. . . לצורך העניין קובץ [YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.)שיודע לתאר את סביבת ה-Production, ובטח יש שפות למכביר שיודעות לעשות את זה.

- אז אני צריך קוד שיודע לתאר את סביבת ה-Production

2. ושתיים - אני צריך לדעת לעשות איזשהו [Git-Hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks), נגיד, שכל פעם שעושים Commit אז Production מתעדכן לפי מה השינוי האחרון.

- אז זה אולי [GitOps](https://about.gitlab.com/topics/gitops/) בממש-ככה-30,000 רגל - ואתה הזכרת שיש כמה כלים שיודעים לעשות את זה - הזכרת קודם את [Flux](https://github.com/fluxcd/flux) של [WeaveWorks](https://www.weave.works/) והזכרת את [Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/)של [Intuit](https://www.intuit.com/) - ואני מניח שיש עוד כלים אחרים בשכונה.

אז אם [קם הבנאדם בבוקר](https://www.youtube.com/watch?v=tYLlPN5ruzc) ואומר “יאללה - בא לי [GitOps](https://about.gitlab.com/topics/gitops/)!” [חמור מאוד] או “אני חייב [GitOps](https://about.gitlab.com/topics/gitops/)!” [תופעת לוואי חדשה?] או “המנהלים שלי אומרים לי שאני צריך [GitOps](https://about.gitlab.com/topics/gitops/) . . . “ [המקרה היותר נפוץ?] - איך אתה ממליץ לו להתחיל?

- (ירון) אז אני אזכיר פה את [Kelsey Hightower](https://twitter.com/kelseyhightower?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor), שהוא מן בחור כזה [שאוהב לדבר על Kubernetes](https://github.com/kelseyhightower/kubernetes-the-hard-way), מ-Google [[בדיוק](https://twitter.com/kelseyhightower/status/1415156964380880898)[זז שם קצת](https://twitter.com/kelseyhightower/status/1415156964380880898)], ואני מאוד אוהב גם את הצורה שבה הוא מנגיש ידע מורכב

- נגיד, לפני הרבה שנים הוא כתב את [Kubernetes-the-hard-way](https://github.com/kelseyhightower/kubernetes-the-hard-way) [אבל כבר קישרתי לזה…], שזה מעיין מדריך על איך להרים את [Kubernetes](https://kubernetes.io/) מ-Scratch, לעשות את כל הפעולות שעשויות, עבורנו, בצורה ידנית - וכשעברתי דרכו הרגשתי היכרות הרבה יותר טובה עם התשתית הזו, שהיום מעירה אותי בלילה אם יש לה בעיה . . .
- והוא עושה הרצאה מדהימה - יש כבר כנסים שנקראים [GitOps Days](https://www.gitopsdays.com/) מרוב שהדבר הזה טרנדי - הוא עשה [הרצאה ממש מעניינת בכנס שהיה בשנה שעברה, שבה הוא מראה איך עושים Reconciliation Loop מ-Scratch](https://www.youtube.com/watch?v=jbDidLauGtQ) . . .

- הוא ממש כזה . . . מראים קוד שהוא כותב ב-Go תוך כדי על המסך, תוך כדי הכנס - והדבר הזה מייצר, במקרה שלו, פונקציות של [Cloud Run](https://cloud.google.com/run), שזה איזשהו Serverless כזה של Google.
- אני חושב ש[ההרצאה הזאת](https://www.youtube.com/watch?v=jbDidLauGtQ) היא פתיח מדהים בשביל לעשות דימיסטיפיקציה (Demystify) למשהו שבאמת, כמו שאמרת, יכול להישמע מורכב ויכול להישמע אפילו די מפחיד, כי זה מראה שהדבר הזה יכול להיות מאוד נשלט.

- אחרי שעוברים את המשוכה הזאת, של להבין את הקונספט, הייתי כן ממליץ לבחור את אחד מהכלים הגדולים - בין אם זה [Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/) או [Flux](https://github.com/fluxcd/flux), כי הם כרגע הכלים ששולטים בשוק
- אבל גם חשוב מאוד, כנראה, להבין את הבעיה - אם [Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/) ו-[Flux](https://github.com/fluxcd/flux) מתאימים מאוד לתחזוקה של [Kubernetes](https://kubernetes.io/), אז אם רוצים לתחזק משהו שהוא מחוץ ל-[Kubernetes](https://kubernetes.io/), צריך לבחור משהו שהוא כלי שיודע לעשות את זה גם בלי הכוח הזה.
- וכמו שאמרתי - גם [Puppet](https://puppet.com/)ו-[Chef](https://www.chef.io/)יודעים לעשות את זה עבור מכונות Linux, ויש כלי שנקרא [Atlantis](https://www.runatlantis.io/), שיודע לעשות את זה עבור [Terraform](https://www.terraform.io/)

- ואז בעצם כל אחד מהכלים האלה יכול להיות Entry-point ל-[GitOps](https://about.gitlab.com/topics/gitops/), לא משנה מה האתגר שכרגע עומד מולכם.

- (רן) נזכיר, אני חושב ששווה אולי לבוא ולמצוא את המקבילות בין הכלים השונים - אז גם מי שמכיר את [Puppet](https://puppet.com/)ואת [Chef](https://www.chef.io/) - הם כולם עובדים באיזשהו Mode של Reconciliation Loop

- זאת אומרת - מסתכלים מה המצב הרצוי ועושים Apply, וכל פעם עושים Reconciliation
- זאת אומרת שאם משהו שהגדרת, לצורך העניין, שצריך להיות קובץ במערכת על מחשב והוא לא שם - אז הוא בכל פעם ייצר אותו מחדש אם הוא ימחק.
- גם [Puppet](https://puppet.com/)וגם [Chef](https://www.chef.io/) עובדים באותה צורה - וגם [Kubernetes](https://kubernetes.io/) הרבה פעמים עובד באותה צורה,

- זאת אומרת שגם ל [Kubernetes](https://kubernetes.io/) יש Reconciliation Loop שמסתכל על ה-Resource-ים ועושה Apply ל-Resource מחדש בכל פעם שצריך
- כמובן שלא סתם . . .

- אז בהקשר הזה, המוטיב הזה של ה-Reconciliation Loop עובר, כנראה, בהרבה מאוד מהכלים שהזכרת.

- (יונתן) לפי מה שירון . . . לפי מה שתיארת, יש יכולת גם לעדכון מהצד השני - יכול להיות שזה לא שב-Production, לא רק שחסר קובץ, אלא שמישהו, לא יודע, שינה אותו, או שמישהו נכנס ל-UI של ה- Management של [Kubernetes](https://kubernetes.io/) ושינה את ה-State Loader - איך ה-Flow המרכזי . . . מה יקרה אז?
- (ירון) זה בעיני הדבר . . . זה ממש ה-Added-Value, אולי אפילו ה-Killer-Feature של [GitOps](https://about.gitlab.com/topics/gitops/), כי אלו הפתעות שתמיד היו תופסות אותנו במקום הכי לא מוכן, ואני מאמין שזה קרה להרבה צוותי Production [מה?! מה פתאום?]

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

- ואז בדרך כלל מגלים את זה חודשים, אם לא שנים, אחר כך, כשהידע כבר נשכח . . .
- יש את הפתגם הזה - שקוד שכתבת אחרי חצי שנה הוא כמו קוד שנכתב על ידי מישהו אחר [יש לזה אפילו שם - [Eagleson's law](https://www.reddit.com/r/ProgrammerHumor/comments/6h8gnl/eaglesons_law/)] . . . אז גם עבור שינויים ב-Production הדבר הזה תקף - מה גם שהם הרבה פחות מתועדים . . .

- ב-[GitOps](https://about.gitlab.com/topics/gitops/), בצורה שאנחנו עובדים, [Argo מחובר ל-Slack](https://argoproj.github.io/argo-events/sensors/triggers/slack-trigger/) - וכל פעם שמישהו עושה Deployment יש הודעה חמודה כזו עם check mark button שאומרת “הקוד שלך שינה בהצלחה את ה-Production”

- אם במקרה, נגיד, הקוד שלי מסתמך על איזשהו [Redis](https://redis.io/)חיצוני, וה-[Redis](https://redis.io/) הזה פתאום נפל, אז אני אקבל “לב שבור ועצוב [broken heart](https://web.archive.org/web/20210618113420/https://coolsymbol.com/copy/Broken_Heart_Emoji_Symbol_%F0%9F%92%94)” שאומר לי “רוץ מהר! משהו השתנה, זה כבר לא נראה כמו ה-Production, אני שבור וקשה לי” . . .

- (יונתן) אוקיי . . .

(רן) מה ה-Hack החביב עליך? נגיד, מסוג הדברים שהתעוררת בשתיים-[שלוש בלילה](https://www.youtube.com/watch?v=TQRsPayhkxE), וגילית “מי לעזאזל עשה את זה?!”? . . .

- אני אתחיל עם שלי - נניח שאתה נכנס ואתה מגלה שמישהו, לפני חצי שנה, כמו שאתה אומר, ערך את קובץ ה-Host והוסיף שם איזשהו Entry, כי כנראה פעם זה תיקן לו איזשהו משהו . . . עכשיו את מגלה ש Name Resolution מחוץ ל-Host עובד שונה לחלוטין ממה ש-Name Resolution עושה בתוך ה-Host - וזה מסביר הרבה דברים, בדרך כלל . . .
- (יונתן) סתם, פתאום התחלתי לחשוב האם זה יכול לעזור באילו-שהן בעיות של Security? או של מישהו ששינה משהו עקיף ב-Production, והוא לא עשה Git-Merge וכל הסיפור הזה . . . .
- (ירון) אז בהחלט . . .
- אני רק אגיד על ה-Hack-ים - שזה תמיד יהיה נס, אין ספק . . .
- ה-Hack החביב עלי זה שכשעובדים ב-High Availability, שולחים גרסא אחת של Production ל-Site אחד וגרסא שנייה ל-Site אחר - ועכשיו לך תבין למה חצי מה-Traffic מחזיר תשובה אחת וחצי מחזיר משהו אחר . . .
- (רן) יש את הסיפור המפורסם על ה-Trading. . .
- (ירון) כן, [Knight](https://www.businessinsider.com/look-how-knight-capitals-trading-volume-is-just-withering-away-2012-8)- מסכנים . . .
- (רן) . . . ש[הם עדכנו גרסא, אבל כנראה נשאר שרת אחד או שניים, שאולי היו Offline בזמן עדכון הגרסא](https://www.henricodolfing.com/2019/06/project-failure-case-study-knight-capital.html) - וזה גרם לחברה לפשוט את הרגל, חברה של שווי, בגדול, של מיליארד דולר, שהפסידו ב-Algo-Trading את כל הכסף שלהם בגלל איזה Deployment שלא עלה נכון . . .
- (ירון) כן, זה [סיפור נורא כשקוראים אותו](https://news.ycombinator.com/item?id=7652036), ופרקי הידיים מלבינים כי אתה חושב שאולי זה קורה לך עכשיו . . .
- (רן) ממש עכשיו . . . אבל ממש ממש עכשיו . . .
- (יונתן) . . תן לי רגע רק לבדוק את ה-Inspection . . .
- אז בנוגע ל-Security - יש כאן באמת יתרון אדיר, כי גם - ב-Continuous Delivery מסורתי, אני חייב לתת לתשתית שלי את היכולת לגשת ל-Production,
- ונגיד, אם זה [Jenkins](https://www.jenkins.io/)שיושב אצלך בשרת, אז לא אכפת לך כנראה לשים שם איזושהי גישת-כתיבה ל-Production

- אנחנו עובדים עם SaaS, עם [code](https://codefresh.io/)[fresh](https://codefresh.io/)- חברה ישראלית שעושה CI ממש נחמד לדברים שהם [Docker](https://www.docker.com/)ו-[Kubernetes](https://kubernetes.io/)
- ועדיין, עם כל האהבה והרצון הטוב - אנחנו מעדיפים שהם לא יוכלו לגשת ל-Production . . .
- ברגע שאנחנו עושים את ההפרדה הזאת, הם יכולים לגשת רק עד הקוד - והמוצר היחיד שיכול לגשת ל-Production הוא[ה-Reconciler של](https://www.weave.works/technologies/gitops/)[GitOps](https://www.weave.works/technologies/gitops/), שבמקרה שלנו זה שרת של [Argo](https://www.intuit.com/blog/technology/introducing-argo-flux/) שיושב על ה-Cluster

- ואז ה-Attack surface הוא הרבה יותר נמוך - כי הוא מלכתחילה יושב שם ומלכתחילה עושה שינויים, וזה טבעי שאצלו ישבו המפתחות [[חביתוש](https://www.youtube.com/watch?v=CISthFaavIE)?].

- ואני אעשה גם איזה Shout-out לפרויקט Open-Source שכתבנו ב-[Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/) ושנקרא [kamus](https://github.com/Soluto/kamus) - והוא גם מתבסס על [GitOps](https://about.gitlab.com/topics/gitops/)

- הרעיון שעשינו שם הוא שהראינו שה-Secret-ים ב-[Kubernetes](https://kubernetes.io/) הם עוד לא בשלים, פחות או יותר - [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/)ב-[Kubernetes](https://kubernetes.io/) הוא פשוט איזשהו אובייקט מקודד ב-Base 64, וזה אומר שכל מי שניגש ל-UI ב-[Kubernetes](https://kubernetes.io/) ולוחץ על הכפתור של העין פשוט רואה את ה-Secret, פשוט רואה את ה-Plain-text, ולא הרגשנו עם זה בנוח . . .
- אז כתבנו Controller, שאפשר להתקין על כל Cluster, ומה שה-Controller הזה עושה הוא לאפשר למפתחים להצפין את הערכים מקומית אצלם על המחשב, לעשות להם Commit ל-[Git](https://git-scm.com/)

- ואז לכל Container נוסף איזשהו [Init-Container](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/), שעושה Encryption על ה-Cluster.

- זה גם מאוד מחזק את ה-Security, כי ה-Decryption יכול לקרות מעכשיו רק בסביבת ה-Production
- זה דומה, נגיד, ל-[Vault](https://www.vaultproject.io/docs/platform/k8s), אבל מגיע עם Operation overhead הרבה יותר נמוך.

(רן) הזכרת מקודם - ואולי בזה, ככה, נסיים את הערב - הזכרת מקודם שעם המעבר ל-[Kubernetes](https://kubernetes.io/), מפתחים הרגישו איזושהי עלייה ברמת המורכבות, שהם פתאום צריכים להבין יותר Production, ואז יצרתם ממשק משתמש, או לפחות אני תיארתי את זה ככה - יצרתם ממשק משתמש, ממשק מפתח, באמצעות [GitOps](https://about.gitlab.com/topics/gitops/).

האבחנה שרציתי להגיד זה

1. ש-[Kubernetes](https://kubernetes.io/) מאפשר [GitOps](https://about.gitlab.com/topics/gitops/), נכון? אולי זה לא הכלי היחיד שמאפשר [GitOps](https://about.gitlab.com/topics/gitops/), אבל בהחלט אחד הכלים שמאפשרים [GitOps](https://about.gitlab.com/topics/gitops/).

- כי הוא נותן לך לתאר את סביבת ה-Production ולעשות לה Apply יחסית בקלות
- אז [Kubernetes](https://kubernetes.io/) אמנם מאפשר [GitOps](https://about.gitlab.com/topics/gitops/)

2. מצד שני, לפני [Kubernetes](https://kubernetes.io/) אולי לא היה צריך [GitOps](https://about.gitlab.com/topics/gitops/), כי הדברים היו יותר פשוטים . . .

אז אני סתם תוהה האם זו אבחנה שנראית לך מוצדקת, נכונה?

- (ירון) אני חושב שכולם מכירים את [ה-Death-Star של Netflix, שמראה פשוט מיליארד שירותי microService שמדברים אחד עם השני](https://twitter.com/ryan_marsh/status/980217902740762624/photo/1)
- והם כתבו את [Spinnaker](https://spinnaker.io/), שזה כלי שהוא מזכיר . . . הוא מאוד מאפשר את הסיבוכיות שיכולה להגיע בדברים של [Continuous Delivery](https://aws.amazon.com/devops/continuous-delivery/#:~:text=Continuous%20delivery%20is%20a%20software,for%20a%20release%20to%20production.)

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

- ושוב אני אצטט את [Kelsey Hightower](https://twitter.com/kelseyhightower?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) שאומר שהקסם והחידוש ב-[Kubernetes](https://kubernetes.io/) זה שהתשתית מתוארת כדאטה, לא כקונפיגורציה (Configuration)

- זו לא סדרה ל צעדים אימפרטיביים (Imperative) שדרושים כדי שמכונת Linux תוכל להגיש קוד ב-[Ruby](https://www.ruby-lang.org/en/) - זה תמיד יהיה דאטה - זה תמיד יהיה קבצים ב-[YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.)שנשמרים ב-Database, והם אלה שמאפשרים את העלייה של Production.

(רן) כן - וזה אולי אחד מהדברים שמאפשרים לעשות [GitOps](https://about.gitlab.com/topics/gitops/) בצורה יחסית פשוטה, כי כל מה שצריך לעשות זה Commit לקובץ [YAML](https://circleci.com/blog/what-is-yaml-a-beginner-s-guide/#:~:text=YAML%20is%20a%20digestible%20data,JSON%2C%20another%20data%20serialization%20language.) - ולעשות Apply . . .

- (ירון) בהחלט

(רן) טוב - אז תודה רבה, ירון, היה סופר-סופר מרתק. יש משהו שהיית רוצה עוד להגיד לפני שנסיים?

- (ירון) אז אני אשמח להגיד ש[אנחנו מגייסים](https://web.archive.org/web/20221127175638/https://www.solutotlv.com/join-soluto-engineering) - גם לצוות שלי וגם למגוון תפקידים ב-[Soluto](https://web.archive.org/web/20210713201510/https://www.solutotlv.com/)
- אם כל מה ששמעתם פה נשמע לכם מעניין, מבחינת החזון של החברה או מבחינת הדברים היותר Geek-יים - בואו, תתראיינו, תתקבלו . . .

(רן) מעולה . . .

(יונתן) אה, אפשר למסור ד”ש, רן?

(רן) קדימה, נו . . . עם איזה שיר? רגע, שאני אכין את [התקליטייה](https://e.walla.co.il/item/2781810). . .

(יונתן) שנכין בתקליטייה . . . אז [למאזין אורי להב, ששט לו בדוגית בחופי הים התיכון](https://www.spreaker.com/user/pimedia/5-6p4YQJ) . . .

(רן) אורי - מתגעגעים אליך, חזור הביתה!

טוב - אז תודה רבה לשניכם, ויאללה, נשתמע . . . להתראות.

[ובהצלחה ל-Reversim Summit 2021 . . .](https://twitter.com/rantav/status/1415780773702029327)

הקובץ נמצא [כאן](https://m2.reversim.com/reversim413_gitops.mp3), האזנה נעימה ותודה רבה לעופר פורר על התמלול
