שינויים בעולם ה-IT בחברות

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

אחד התחומים שהייתי רוצה להיכנס אליו (וזה מאוד קשה) הוא תחום ה"בין לבין": נניח ויש לנו את אלון, איש לינוקס בחברה גדולה ואלון החליט לעזוב את החברה לטובת משרה בחברה אחרת או שהחברה החליטה לאמר שלום לאלון. הכלל הפשוט הוא, שככל שהחברה גדולה יותר, כמות הזמן שיקח לאייש את המשרה – ארוכה יותר, וכאן יכולה להיווצר הזדמנות לפרילאנסר לקבל אולי עבודה למספר שבועות או חודשים לאייש את המשרה. מדוע זה קשה? כי זהו בדיוק התחום שחברות כמו מטריקס, Ness, One, SQLink ואחרות מכירות את הנפשות ומרוויחות יפה מהתחום.

יחד עם זאת, יצא לי בכמה פעמים לשוחח עם מספר מנמר"ים, CTO ומנהלי מחלקות IT. השיחה בד"כ נסובה על דברים שהם מחפשים במועמד הבא לאייש משרה בתחום ה-IT, ושמתי לב לכמה דברים מעניינים שאני רוצה לשתף עמכם:

  • הדרישות גדלו: אם פעם היו מחפשים אצל המועמד ידע ב-Windows, ידע התחלתי-בינוני בלינוקס, ידע ב-VMWare ואולי קצת ידע ב-Networking, הפעם רוצים שהמועמד יהיה בעל נסיון בתחומים שהם אינם IT כל כך: תדע Jenkins, GitLab, Code bucket – ולא מדובר על ידע של התקנת הכלי (כמה זמן לוקח להתקין Jenkins? דקות ספורות, לא כולל plugins שאינם רשמיים וכו') – אלא גם כתיבת Pipelines, ידע בניהול גרסאות ב-GIT, ידע ב-Docker, ידע ב-Kubernetes, ידע בהגדרות עננים ציבוריים (AWS, Azure ולפעמים גם GCP). לא שמעתי על הרבה שרוצים ידע ב-Terraform אבל אני מניח שאת זה הם משאירים לאיש DEVOPS (כן, Devops זה מתודות, אבל לך תתקן אנשים).
  • משכורות – אתה הולך לרכוש דירה? הולך להרחיב את המשפחה? הולכת להיות לך הוצאה גדולה? כדאי שתעזוב את תחום ה-IT לטובת תחומים אחרים יותר רווחיים. המספרים ששמעתי נעים בין 13-20K ברוטו. טוב לצעירים, פחות טוב לנשואים, אבות לילדים וכו' וכו'.
  • Kubernetes, Helm, Terraform, Ansible, AWS, Azure – ורצוי גם ידע ב-Python, אלו הדרישות שדורשים מאנשי Devops, חוץ מידע בכלי CI/CD. שימו לב: בסטארטאפים מצפים מכם שתלמדו הרבה יותר ממה שציינתי – ומהר. כלי נוסף שחברות עדיין לא ממש גילו ויש מצב שירצו להריץ אותו – נקרא KOPS. ממליץ לכם להכיר אותו.
  • שכר לאנשי Devops: משום מה במקומות רבים חושבים שהשכר של איש Devops אמור להיות שכר כמו של איש IT. עצתי לכם: תדעו למכור את עצמכם ולהתמקח. עם כל הכבוד לתחום ה-IT, איש Devops צריך לדעת הרבה יותר וללמוד מהר דברים חדשים, התחום מתקדם במהירות מטורפת!
  • אל "תינעלו" על ענן ציבורי מסוים! ידוע לי שבחברות גדולות רבות פשוט "מתים" על Azure, אבל בשוק יש המון חברות (ובמיוחד סטארטאפים) שמשתמשים ב-AWS ו-GCP ועדיף לכם להכיר את כולם. כל ספקי הענן הציבורי מציעים כמות קרדיטים חינמית בתור התחלה אבל זה לא תמיד מספיק (תזכרו: הקרדיטים הראשוניים הם לזמן קצוב בלבד של חצי שנה או שנה). לכן אני ממליץ: תתנחמדו לאנשי מכירות של ספקי הענן הציבורי ותבקשו בנימוס קרדיטים. טיפ קטן: אני ממליץ ללמוד את הנושאים דרך Linux Academy (למרות השם שלהם, הם מלמדים גם על דברים שאינם לינוקס) ולהשתמש ב-Lab שלהם, אתם תקבלו מספר מכונות וירטואליות חינמיות שפועלות במשך זמן קצוב.
  • קראו בין השורות לגבי משרות. בלא מעט מקרים באתרים כמו Alljobs ניתן לקרוא את המפרט של נושאים שהחברה רוצה שהמועמד ידע ויכיר, אבל לפעמים אפשר לראות שהחברה בעצם מחפשת איש Devops שיהיה גם איש IT ואם אפשר – שיכין קפה לפעמים. ממשרות כאלו אין הרבה לאן להתקדם, חפשו דברים שמתאימים לכם, לא להיות כלבויניקים.
  • הנה משהו מעניין ששמעתי ולא מאדם אחד: אין לכם נסיון (חוץ ממה שהתנסיתם בבית)? אל תבקשו לעבוד בחינם. אתם יכולים לדבר על משכורת התחלתית כלשהי שתעלה לאחר תקופה מסויימת/דיון שכר וכו' – והכי חשוב, להיות כן: אם אין לך נסיון מספק, תאמר זאת ותאמר שאתה מוכן בשביל זה להסתפק במשכורת כלשהי (עדיף לא לציין מספר). תנסו לתחמן, יש סיכוי גדול שיתפסו זאת ולא יזמנו אתכם להמשך תהליך.

תחום ה-IT עובר שינויים וחברות רבות מנסות "לדחוף" תחומים שאינם IT קלאסי למשרה. במקביל, יותר ויותר חברות עוברות לעננים ציבוריים וכמות משרות ה-IT מצטמצמת (רואים זאת כיום במיוחד בתחום התקשורת, אגב – זה שיש לך ידע מעולה עם CCNA זה נחמד, איך הידע שלך ב-VPC ושאר דברים הקשורים בתקשורת בענן מעבר ל-VPN?). העננים הציבוריים תופסים יותר ויותר מקום, החל מחברות קטנות, סטארטאפים ועד לחברות גדולות שכבר עושות מספר פעמים "חושבים" אם לרכוש ברזלים נוספים וכל עניין DEVOPS נהיה דבר מובן מאליו בתוך החברה.

להתקדם בתחום

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

כל השואלים יודעים ורואים במקום עבודתם ושומעים גם מחברים – על השינויים המתרחשים. על שימוש בעננים ציבוריים במסגרת העבודה, על קונטיינרים, על Devops, CI/CD, Kubernetes, ויש גם עשרות תתי נושאים. כל מי שקורא את הפוסט הזה בוודאי שמע על המושגים אבל רבים אינם יודעים בעצם מה ללמוד, מה חשוב ומה לא ובקיצור – איך להיות רלוונטי בעולם ה-IT של היום.

בעבר, החיים היו הרבה יותר פשוטים. אם היית רוצה "להתמקצע" בתחום של מיקרוסופט, אז היית לוקח איזה קורס MCSE (או איך שזה נקרא כיום, סורי, אני לא עוקב אחר שינויי השמות), לומד כלים משלימים של מיקרוסופט כמו SCCM, אקסצ'יינג', אולי PowerShell, ועם זה היית הולך לחפש עבודה. אחרים הלכו לתחומים כמו לינוקס ושלל השרותים שנמצאים בלינוקס, יש כאלו שהיו הולכים ללמוד CCNA בשביל תקשורת מחשבים, ויש כאלו שלמדו קורס כלשהו על סטורג', אחרים למדו VCP בשביל וירטואליזציה. בחברות גדולות היו מחפשים יותר דברים ספציפיים כמו אחד מהנושאים שציינתי לעיל (לדוגמא – איש וירטואליזציה), ובמקומות יותר קטנים היו מצפים שתכיר את כל הנושאים שציינתי על מנת להתקבל למקום העבודה.

אבל היום הכל משתנה. היום גם החברות הגדולות מעוניינות באנשים שיש להם ידע ונסיון במספר תחומים, גם אם העבודה היא בעקרון להתעסק בתחום מסוים. אם קובי מעולה לדוגמא בתחום סטורג' (וזה התחום שהם מחפשים אליו עובד) ורוני מכיר לא רק סטורג' אלא גם מכיר לינוקס בצורה כזו מעולה שהוא יכול להסביר תוך כדי שינה מה זה Magic SysRq key בלינוקס – אז רוני יקבל את העבודה, גם אם לרוני יש שליש מהזמן נסיון בסטורג' בהשוואה לקובי. הסיבה? לרוני יש יותר ידע שסביר להניח שיצטרכו בחברה להתגבר על אתגרים עתידיים.

אז מה אתה יכול לעשות כדי לשפר את סיכוייך למצוא עבודה טובה בעתיד?

יש כמה דברים.

אם אתה רוצה להישאר בתחום ה-IT הקלאסי (לפני כניסת הענן) אז מה שמומלץ לך זה ללמוד את התחומים "השכנים": אתה איש סיסטם מיקרוסופט? תכיר יותר את תחום הסטורג' הרגיל, תכיר יותר נטוורק לעומק (אתה יכול להשתמש בכלי כמו GNS3 לבצע סימולציות), והכי חשוב – להכיר את מערכת ההפעלה ה"מתחרה" לינוקס במובן הטרמינל (לא במובן הגרפי. ברוב המקרים אתה לא תעבוד מול תצוגה גרפית במכונות לינוקס) – מה זה לינוקס, איך הוא בנוי, פקודות לינוקס בסיסיות, כתיבת סקריפטים בסיסיים ב-BASH, הגדרות ציודים שונים, ניתובים, ניהול חבילות תוכנה, ועוד. אם אתה רוצה, יש אתר בשם Linux Academy שמלמד את הדברים (יש מנוי חודשים שעולה 50$ לחודש, שבוע ראשון בחינם). אם אתה יותר טיפוס של ספרים – יש לא מעט ספרים שמלמדים על לינוקס ויש כמובן גם קורסים בבתי הספר המקצועיים השונים שמלמדים לינוקס. לגבי סטורג' ונטוורקינג – אני ממליץ ללמוד לבד.

במקומות גדולים החל לצוץ לו תפקיד חדש לאחרונה (לא באופן רשמי, לפחות ממה שאני יודע) והוא "Cloud Admin" – מה שאתה עושה מקומית, עכשיו בענן, רק שבענן לא יחכה לך איזה סטורג' של Netapp/EMC, אין לך סוויצ'ים, אין לך פיירוול (את זה אפשר להוסיף, כ-Appliance) והכל בעצם נעשה בתוכנה, בין אם דרך ממשק ווב, אבל יותר דרך ממשק CLI וכאן כבר צריך ללמוד איך להגדיר דברים, החל ממכונות VM, נטוורקינג, דיסקים קשיחים וירטואליים ועוד ועוד. בלינק שפירסמתי לעיל יש גם קורסים לכל ספקי הענן הגדולים, כך שאפשר ללמוד שם גם איך להשתמש בענן ואיך לנהל משאבים. העננים הפופולריים ביותר הם של אמזון (AWS) ו-Azure של מיקרוסופט. קצת פחות פופולרי (והרבה יותר טכני) הוא הענן של גוגל, לכן מומלץ ללמוד לפחות את הענן שבו החברה משתמשת ואולי את הענן השני הפופולרי.

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

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

איש ה-Devops טוב צריך לדעת כמה דברים חשובים:

  • הוא צריך להכיר טוב לינוקס, ברמה של כתיבת סקריפטים, הגדרות לינוקס, ניהול חבילות
  • הוא צריך להכיר את עולם הקונטיינרים – החל משימוש ב-Docker כדי לבנות Images, והוא צריך להכיר Kubernetes (או OpenShift או Caas) כדי לבצע אורקסטרציה בין הקונטיינרים השונים שירוצו, שרותים, רשתות, Scaling ועוד.
  • הוא צריך להכיר כלי CI/CD על מנת לאפשר ביצוע Build אוטומטי דרך כלים כמו Jenkins או Teamcity לדוגמא.
  • הוא צריך להכיר כלי ניהול קוד טוב. כל כלי שיודע לעבוד עם GIT זה טוב, בין אם מדובר ב-Bit Bucket או GitLab או כלי אחר, וכדאי להכיר את הדברים לא רק ברמת ממשק הווב אלא גם להכיר את GIT עצמו.
  • "קוד כתשתית" – אחד הדברים ש"רצים חזק" כיום הם כלים שכותבים איתם "קוד" לניהול תשתית כמו הענן הפנימי שלכם בענן הציבורי, כלי כמו Terraform או Ansible או SALT הם כלים מעולים לכך.
  • שפות – BASH מאוד יעזור לכתיבת סקריפטים פשוטים, מומלץ להכיר גם Python.
  • שרותים – כל ספק ענן ציבורי מספק מאות שרותים שונים. תצטרכו עם הכלים הנ"ל להגדיר ולהשתמש בשרותים הנ"ל ואצל כל ספק ענן זה שונה. כן. Not Fun.
  • ניטור באופן שונה – מכיוון שיש הרבה שרותים שספק הענן מציע ולך אין גישה לתשתית השרותים, תצטרך להשתמש בכלים שונים לניטור, סביר להניח דרך כלי הניטור של ספק הענן.

כמו שאתם רואים – ערימה לא קטנה של דברים. אגב, כמעט את כולם ניתן ללמוד ב-Linux Academy בלינק שנתתי לעיל.

חשוב להבין – אף אחד לא מצפה שתכירו את כל מה שציינתי לעיל בעל פה ו"על השפיץ", אלא להבין את עקרון הדברים ואיך דברים עובדים ואולי שתוכל לתת דוגמא קטנה. אם לדוגמא אתה מכיר כלי כמו Bit Bucket ואין לך מושג ירוק ב-GitLab, או אם אתה לא מכיר מהזה Federation ב-Kubernetes אף אחד לא יפסול אותך בגלל זה.

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

בהצלחה.

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

אני רוצה לחזור לימים שמיקרוסופט שחררו את Windows 95. הנה מערכת הפעלה חדשה, טענה מיקרוסופט, שיכולה להריץ ריבוי משימות מבלי שאפליקציה אחת תגרום לקריסת שאר האפליקציות שרצות! כולנו כמובן יודעים את האמת הפשוטה שאפליקציות בהחלט גרמו למערכת ההפעלה לקרוס כמו כלום, אפליקציות "בלעו" זכרון וניהול הזכרון היה די כושל, בוודאי כשמשווים זאת למערכות היותר מתקדמות שמיקרוסופט הוציאו שנים לאחר מכן כמו ה-NT 4.0 וה-2000 וכו'. הסיבה המרכזית לכך היתה כמובן כל הסביבה "מתחת" – DOS, שלא היתה ממש בנויה טוב לדברים כאלו, וה-Protected Mode שאינטל הוסיפה החל במעבדי i386 לא ממש עזר הרבה (אם כי לא באשמת אינטל).

שנת 2018, חברות רבות עוברות להשתמש בקונטיינרים אבל ישנה אי נוחות מבחינת אבטחת מידע לגבי קונטיינרים. למי שלא מכיר – הסיבה שקונטיינרים רצים מהר היא בגלל שהקונטיינר אינו מכיל Kernel או דרייברים שמתממשקים ל-Kernel. קונטיינרים מקבלים שרותים מ-Kernel יחיד שרץ על אותה מכונה (פיזית או וירטואלית) וכך כל מה שיש בקונטיינרים הם ספריות ואפליקציה שצריכה לרוץ (ולצערי רבים עדיין בונים קונטיינרים שמכילים מספר אפלקציות/שרותים במקום להריץ רק אפליקציה אחת. זה "מתנקם" אחר כך באנשי Devops שעוברים להשתמש ב-Kubernetes).

מדוע אי נוחות מבחינת אבטחת מידע? כי הקונטיינר הוא לא יותר מאשר Process, שלא-כל-כך קשה "לצאת" ממנו אל ה-Host ומשם לחולל נזקים. רד-האט עם מערכת ה-OpenShift שלה לא מאפשרת (בברירת מחדל) לדוגמא לקונטיינרים לרוץ כ-root או להריץ בתוכה אפליקציות כ-root, וכל המערכת רצה עם SELinux מופעל (כ-Enforcing), כך שאם אתה מבטל SELinux, אין OpenShift. בפתרונות אחרים מבוססים Kubernetes חוסמים תקשורת בין ה-Pods, אבל זה לא תמיד יכול לסייע – במיוחד אם המערכת חשופה החוצה ומריצים מאות pods שמכילים Apache או NGINX לדוגמא.

לשם כך נצטרך קודם להיפטר מ-Docker.

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

במקום Docker, תכירו את CRI-O. (מבטאים "קריאו")

CRI-O זו מערכת חלופית ל-Docker שיודעת לבצע מה ש-Docker מבצע (ולכן היא תואמת ל-Docker), רק שהיא צורכת פחות משאבים, ואחד הדברים המעולים שיש בה הוא שניתן בעצם להגדיר קונטיינרים שאנחנו בוטחים בהם (Trusted) וקונטיינרים שאיננו בוטחים בהם (Untrusted) ולהריץ את 2 הסוגים במקביל, כאשר קונטיינרים שאיננו בוטחים בהם, ירוצו דרך מערכת QEMU כמכונה וירטואלית (sandbox) עם kernel קטן וכל השרותים הנחוצים להרצת קונטיינר. במילים אחרות – בשינוי קובץ YAML נוכל בקלות להקים את הקונטיינרים בצורה מופרדת או בצורה רגילה.

CRI-O מתחבר ל-Kubernetes בצורה חלקה ואינו מצריך הטמעת טלאים, וכמו כן CRI-O משתמש בשיטה של אינטל (שנקראה בעבר Clear Containers וכיום Kata Containers) כדי להריץ קונטיינרים בצורה מבודדת, אך שעדיין מאפשרת להשתלב בתוך אותם Namespaces לדוגמא.

להלן הדגמת וידאו קטנה איך עם CRI-O בשילוב Kubernetes מאפשר להריץ קונטיינרים שאנחנו מגדירים כ-Trusted ואיך משלבים קונטיינרים שאנחנו מגדירים כ-Untrusted ורצים בתוך סשן VM (לחצו מצד ימין למטה על האייקון עם החצים כדי לצפות בכל הטרמינל, הנגן לא יודע לבצע Scale לוורדפרס):

כפי שאנחנו יכולים לראות, השילוב רץ יפה מאוד.

לאלו המעוניינים לנסות את הדברים הללו, חשוב לשים לב לנקודות הבאות:

  • כרגע, לא ניתן להריץ את הדברים בענן ציבורי בתוך Instance רגיל אלא אך ורק בתוך Bare Metal Instances. כמו כן לא ניתן להשתמש ב-CRI-O בתוך שרותים כמו ECS.
  • אם אתם רוצים להריץ זאת בתשתית מקומית שלכם, ואתם מריצים Kubernetes על מכונות VM, יש להגדיר את אותן מכונות VM עם Nested Virtualization על מנת להריץ קונטיינרים Untrusted.
  • אם אתם רוצים לנסות את הדברים על מכונת הדסקטופ שלכם עם Minikube, יש להפעיל את minikube עם ההוראות כאן.
  • אם אתם משתמשים במערכת OpenShift (גירסה 3.11 ומעלה), ניתן להוסיף תמיכת CRI-O בנוסף לתמיכת Docker למערכת. ההוראות – כאן.
  • אם אתם משתמשים ב-CAAS של SuSE, בגירסה 3 ומעלה ניתן לבחור בין Docker ל-CRI-O. עוד פרטים ניתן לקרוא כאן.

לסיכום: CRI-O מאפשר לנו להריץ בצורה קלה ומאובטחת קונטיינרים שלא אנחנו בנינו ושהורדנו ממקורות אחרים ובמקביל הוא מאפשר לנו להריץ קונטיינרים שאנו בוטחים בהם (ושאנחנו בנינו) כפי שהרצנו עד היום, רק מבלי להשתמש ב-Docker עצמו ובמשאבים הגדולים שהוא צורך.

פוסט עדכני על קורסים בחברות

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

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

טכנית, אין לי שום בעיה להעביר קורס על לינוקס, על כלים שמשתמשים במתודות Devops (כמו GIT, Jenkins, קונטיינרים, וירטואליזציה, SDS ועוד), אבל להעביר קורס במשך יום יומיים לדוגמא על הכרת לינוקס (ויש לא מעט סוגי קורסים כאלו) – אני יכול להבטיח לכם שההשקעה (שהיא לא ממש קטנה במחיר) תרד לטמיון. מדוע? מכמה סיבות:

  • קורסים מסויימים מלמדים על כמה הפצות לינוקס במהלך הקורס. זו, לעניות דעתי, טעות. לי, אישית, כשאני לומד עדכון של הפצה שאני כבר מכיר, לוקח לי כמה שעות במשך כמה ימים ואילו הפצה חדשה לוקח לי יותר זמן ללמוד (מה לעשות, צריך גם להתפרנס, לא? 🙂 ). לעומת זאת, מישהו שהוא חדש בתחום  הלינוקס, יקח לו הרבה יותר זמן ללמוד, ולימוד הפצות שונות באמצע די מבטיח בלבול רציני. כבר ראיתי מישהו שדי חדש בלינוקס מתעקש במשך שעה לנסות להתקין חבילות תוכנה עם פקודת zypper (שקיימת להפצת SuSE) בשעה שהוא היה צריך להשתמש בפקודת yum (שקיימת בהפצות Red Hat ו-CentOS) ולכן קורס טוב לדעתי צריך להתמקד בהפצה עיקרית אחת.
  • שיטת לימוד של "נזמין את המדריך ליומיים שלוש" להדרכה, היא שיטה די בטוחה שהכסף שיושקע ילך לטמיון. לינוקס זה לא לימוד MCITP ורוב מוחלט של החומר הנלמד הם פקודות טקסטואליות שצריך לשנן, ולנסות. קורס יומיים? תהיה בטוח ש-90% מהחומר ישכח ע"י רוב התלמידים, ועל כך יכול להעיד המייל אצלי. יש צורך לפרוס את זה ליום או יומיים בשבוע לשעות ספורות.
  • רלוונטיות: מכיוון שהשוק פתוח וכל אחד יכול להציע קורסים כאוות נפשו, מגיעים אליי כל מיני שאלות אם אני יכול להעביר קורס על טכנולוגיה זו או אחרת. טכנית, אין לי בעיה להעביר, אבל התועלת לחברה חשובה לי לא פחות מכך וצריך לבדוק (כן, תחת NDA) היכן זה משתלב. כך לדוגמא פנו אליי בעבר להעביר קורס מעמיק ב-Docker. זה, לדוגמא, קורס שהתוכן שרלוונטי הוא אולי 10% כי בסופו של יום אם מתחילים לבנות בחברה קונטיינרים, משתמשים במערכת ניהול והרצת קונטיינרים כמו OpenShift או Kubernetes – כך שללמד איך לבנות קונטיינרים – כן, איך להריץ ואת החלקים הפנימיים ב-Docker – לא ממש, תשאירו את זה להדרכות על כלי הניהול.

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

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

תובנות על OpenShift בחברות גדולות

יוצא לי בלא מעט מקרים לתת יעוץ לחברות גדולות לגבי עניין המעבר ל-Devops, שימוש בקונטיינרים, Docker, שימוש ב-Jenkins ושאר כלים. כמובן, כמו תמיד, בחברות גדולות, אף אחד אינו רץ להטמיע טכנולוגיה זו או אחרת רק בגלל שחץ בן חמו (או נציגי Presale של רד-האט, אין לי קשר אליהם) המליץ עליה. יחד עם זאת, בדרך כלל ההמלצה שלי לפני שמרימים אפילו PoC של OpenShift – אני מבקש מהחברה שתתן לי להיות "הטיפש" – להיות עם צוות שינסה את הדברים החדשים ובעצם ללמוד את התהליכים שהצוות משתמש בהם – החל מכתיבת קוד, שימוש ב-SCM, קומפילציה, טסטים, תהליכים נוספים עד לתוצר הסופי (קבצים בינאריים, Artifacts וכו').

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

  1. ניהול קוד (Source Code Management – SCM)
    ברוב המקרים שישבתי לפגישת היכרות ושיחה על המערכות הקיימות, בד"כ מערכת ניהול הקוד היתה TFS של מיקרוסופט או בחלק מהמקרים SVN. מקומות בודדים הכניסו איזו "תת מערכת" של GIT (בשימוש של Gitlab או BitBucket).
    הבעיה: שום מערכת קונטיינרים המבוססת על Kubernetes לא תומכת באופן רשמי לא ב-TFS ולא ב-SVN. כולן תומכות באופן טבעי ב-GIT.
    הפתרונות שיש הם מאוד עקיפים:
    עם TFS יש פתרון די עקיף לבעיה כפי שמוסבר כאן.
    עם SVN הפתרון הוא למשוך את הקוד למכונה מקומית שמחוברת לשרת GIT, ולאחר מכן לבצע Commit, Push לשרת ה-GIT המקומי. זה פתרון די "מכוער" ובעייתי מכיוון שאם מישהו שכח להוריד ולהעלות קוד ל-GIT, ה-Build יהיה בעייתי. אגב, שרת SVN הוא יחסית קל מאוד להמרה ל-GIT, במידה והחברה מעוניינת לעבור ל-GIT.
  2. מכונות Windows ולינוקס ביחד.

    לא מעט חברות גדולות כותבות קוד ל-Windows וסקריפטים ל-Windows (ראיתי גם מקרים של Build ל-JAR/WAR שכתובים ב-Batch file), וכאן ישנה בעיה מהותית – Kuberenetes בעצמו לא רץ בצורה טובה על Windows והפתרון שיגיע בשנה הבאה יאפשר גם ל-Kubernetes וגם ל-OpenShift להשתמש ב-Nodes שהם גם Windows וגם לינוקס (אם כי שרתי ה-Master וה-Infra יצטרכו להיות מבוססי לינוקס).
    עד אז תהיה בעיה לקמפל קוד בצורה יציבה של דברים כמו DOT Net (כדאי לעבור ל-Dot Net Core שנתמך ורץ על לינוקס), ויהיה צורך להמיר קבצי batch ל-shell כדי לקמפל את הדברים על Windows.

  3. בחירת אסטרטגיה ב-OpenShift
    באופן עקרוני, שימוש ב-OpenShift מחייב בחירת אסטרטגיה, ו-OpenShift תומך ב-4 אסטרטגיות פופולריות: Docker, Source to image (S2I), Jenkins Pipeline ו-Custom (שהוא מאוד מתקדם וברוב המקרים לא יהיה בו שימוש אלא במקרים מיוחדים ששאר האסטרטגיות אינן עונות על כך)

    1. אסטרטגיית Docker מאפשרת שימוש ב-Images קיימים מבחוץ (ממקומות כמו Docker Hub לדוגמא) ושניבנו פנימית כחלק מהרמת אפליקציות. יש עם האסטרטגיה הזו 3 בעיות:
      1. רוב ה-Images שתמצאו בחוץ לא יפעלו עם OpenShift כי הם רצים כ-root ו-OpenShift בנוי בראש ובראשונה לאבטחה הדוקה ולכן הוא חוסם מיידית הרצה של Images כאלו (אפשר לבטל זאת אבל אז מישהו יחטוף על כך ממחלקת אבטחת מידע)
      2. בלא מעט מקרים שוחררו Images שמריצים מספר אפליקציות במקביל בתוך אותו Image וזה הורס כל דבר שקשור לגדילה רוחבית (Scaling) ולכן לא מומלץ להשתמש ב-Image כזה.
      3. טכנית, מבחינת אבטחה בקונטיינרים, דברים צריכים לרוץ רק ב-Foreground ולא ב-background ולכן קונטיינרים שיריצו דברים ב-background (שרותים כמו nginx, apache, postfix ועוד ועוד) – הקונטיינר "ימות" לאחר זמן קצר והמערכת תנסה להקים אותו שוב ושוב, מה שיצור loop (במיוחד אם מופעל Replication Controller – RC).
    2. אסטרטגיית Source to image (כלומר S2I): עם אסטרטגיה זו מערכת OpenShift מושכת ImageStream (כלומר Image "שלד"), יוצרת Image חדש שאליו היא "שופכת" את הקוד מ-GIT, מבצעת שינויים שצריך (הרשאות, התקנת קבצים נוספים כמו דרך PHAR ב-PHP או NPM עבור Javascript ועוד ועוד), ולבסוף בונה Image סופי שאותו המערכת מריצה ומקימה POD עם קונטיינר המכיל את ה-Image. באסטרטגיה זו ניתן "לקשור" (דרך Webhook) בין REPO של GIT לבין אפליקצייה ב-OpenShift וברגע שיש שינוי ב-GIT, המערכת תבנה אוטומטית Image חדש וכשתסיים היא תוריד את ה-POD הקיים ותפעיל מיידית את ה-POD עם הקונטיינר החדש (ניתן כמובן לבצע Blue/Green Deployment – פרטים כאן וזה קיים לא רק ברמת אפליקציות אלא גם ברמת מכונות)
    3. אסטרטגיית Jenkins: עם אסטרטגיה זו אנחנו מגדירים הכל מראש: מאיפה הקוד ימשך, מה ה-pipelines וכו' וכו' ו-OpenShift יקים בכל פעם קונטיינר Jenkins, יקמפל, יריץ את ה-pipelines, יפזר מה שצריך לפזר, יבנה Image חדש ויריץ POD עם קונטיינר המבוסס על ה-Image החדש. הדרך הזו יכולה להתאים לאלו שכבר משתמשים ב-Jenkins על לינוקס.

ישנם עוד חלקים הקשורים להקמת מערכת שיש צורך לערב הן את מחלקת אבטחת מידע והן את צוות ה-Storage. בגופים פיננסיים ובטחוניים יהיה צורך לשים דגש על שרתי Registry מקומיים (לחשיפה מופחתת לאינטרנט, אבל עדיין יש צורך לשאוב קבצי Image, בלי זה אי אפשר להקים שום דבר, ואין זה משנה אם מדובר ב-OpenShift או בכל מערכת אחרת מבוססת Kubernetes), שילוב עם Active Directory, הרשאות וכו' (מובנה ב-OpenShift, לא קיים ב-Kubernetes) ועוד דברים רבים.

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

מעבר ל-CI/CD בחברות גדולות

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

מנסיון אחר שלי עם חברה בינונית באותו נושא, דברים התקדמו בצורה מאוד יפה. בפגישה הראשונה הסברתי את נושא ה-CI/CD, בפגישה השניה דיברנו על טכנולוגיות שאתקין להם ועל מה שיש להם כרגע ואיך להעביר את הדברים, פגישה הבאה היתה תכנון ההתקנה ובמשך כמה ימים לאחר מכן ההתקנה בוצעה, לאחר מכן בוצעה המרה והטמעה של מס' טכנולוגיות שהם משתמשים ולאחר מכן היתה הדגמה של איך הדברים יעבדו. בפגישות הבאות היתה הדרכה כיצד לעבוד עם הכלים החדשים, כיצד הדברים רצים "מאחורי הקלעים" ומה ניתן לקבל מהכלים ולבסוף הדרכות כיצד כל מפתח יכול וצריך לעבוד מעתה. סה"כ זמן הפרויקט: חודשיים (2-3 פעמים בשבוע). טיפ לחבריי הפרילאנסרים – מומלץ לחשוב על מחיר שעה במקום מחיר פרויקט. זה היה הרבה יותר ממה שקבענו.

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

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

  1. לבחור צוות שיעבור ל-CI/CD מתוך כל הצוותים שיש בחברה. כדאי שבצוות יהיו אנשים עם מוטביציה ועם ראש פתוח. בלי זה – המעבר יכשל, מבטיח לכם.
  2. להעדיף כלים מבוססי קוד פתוח או פתרונות מסחריים מבוססי קוד פתוח. כלים קנייניים הם מקור לצרות בעולם ה-CI/CD שמתפתח בקצב מהיר. לעומת זאת, כלים בקוד פתוח צריכים בד"כ הרצה של פקודת YUM או APT כדי לעדכן.
  3. האם בהזדמנות זו מכניסים פתרון קונטיינרים? (אפשר לבצע CI/CD ללא קונטיינרים) – אם כן, כדאי להחליט אם הולכים על פתרון מסחרי של Kubernetes (כמו CAAS של SuSE) או על OpenShift של רד-האט שהוא גם מבוסס Kubernetes אבל נותן הרבה הרבה יותר יכולות. (ישנם כמובן גם פתרונות אחרים אבל הם לא עונים לצרכים של Enterprise).
  4. פיתוח כ-Multi Platform – חשוב במיוחד לבנקים, חברות ביטוח וחברות פיננסיות. זה נחמד וטוב לפתח ל-Windows אבל אפשר בעזרת עבודה די קצרה לעבור ל-Multi Platform. עובדים ב-JAVA? מצוין, אפשר גם עם לינוקס, צריך בסה"כ לשנות מספר סקריפטים (אם כתבתם) כדי לעבוד בלינוקס. עובדים עם Dot Net? תכירו את Dot Net Core שמאפשר לכם עבודה עם Windows ולינוקס. היתרון של עבודה עם לינוקס הוא שמגוון רחב של כלים יהיה זמין לכם (במיוחד אם אתם עובדים עם קונטיינרים).
  5. טסטים טסטים טסטים … יש עדיין מקומות שמעסיקים אנשי QA. ברוב המקומות לעומת זאת, כבר אין חיה כזו מהסיבה הפשוטה שהיום פשוט כותבים טסטים שרצים במערכת כמו Jenkins המבצעים בדיקות Unit testing ועוד מספר סוגי טסטים על מנת לוודא שמה שמפותח – הוא יציב ועובד.

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

ועוד משהו אחד שרבים לא יאהבו שאני כותב זאת: החיה הזו בשם "איש Devops" זו המצאה שגויה של אנשים שלא מבינים מה זה Devops. הבה נסתכל על משהו פשוט בחברה גדולה: החברה מחליפה תוכנת גיבוי, תוכנת Code Repository, אולי כלי אוטומציה ועוד מספר דברים. האם אותה חברה צריכה פתאום שכיר נוסף? לא, כי צוות ה-IT אמור לדעת לתמוך בכלים. אפשר לקרוא למישהו מבחוץ שילמד ויתרגל את הצוות, אבל הצוות יכול בהחלט להמשיך ולתחזק את אותם כלים. אדרבא, הן אנשי ה-IT והן צוותי הפיתוח צריכים להכיר את הכלים (ברמות מסויימות כמובן, ה-IT ברמה של Sysadmin והשאר ברמה של Usage).

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

אתם באמת צריכים איש Devops? (חלק שני)

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

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

אתן דוגמא: כפרילאנסר, אין לי שום בעיה להרים Software Defined Storage, או קונטיינרים או לבנות מערכות לינוקס גדולות לבצע תפקודים מסויימים, או מערכות וירטואליזציה סגורות או בקוד פתוח, אבל כשזה מגיע למערכות כאלו, יודעים כמה חברות גדולות יכנסו לדף ה"אודות" כדי להזמין אותי, לשפוך כמה מאות אלפי דולרים ולשלם לי כמה עשרות אלפי שקלים בפגישה הראשונה? אפס. אף אחד לא מוכן להקים מחר בבוקר מערכת כזו. כל מי שיפנה – אז הוא יצור קשר להתעניינות, אולי להיפגש ואם זה ישמע לו, הוא ירצה בתור התחלה PoC (כלומר Proof Of Concept) ורק אם ה-PoC מראה תוצאות טובות – אז החברה תיקח זמן לחשוב, אולי תסתכל על הצעות אחרות ואם הם ירצו – הם יפנו מחדש כדי להקים מערכת כזו. כל פרילאנסר שעובד עם גופים גדולים יכול לספר לכם על כך. באופן עקרוני – ככל שהגוף/חברה יותר גדולה, דברים נעשים יותר לאט. מה שאנשים מקצועניים עושים בסטארט-אפ מהבוקר שהם מתחילים לעבוד ועל הפסקת הצהרים – יתורגם לשבועות ואף לחודשים – בחברות גדולות.

בסטארטאפ, הדברים הם פשוטים: כולם עובדים יחד. יש כמובן צוותים, ובתוך כל צוות פיתוח – כל אחד כותב חלק מסוים של הקוד, וסביר להניח שהוא יכתוב את קוד ה-Units testing, את ה-UAT או את ה-User Stories (לפי ה-Agile Development) לאותו קוד שהוא כתב. בקיצור – יש הרמוניה, וכשיש דינמיקה, דברים זזים מהר, ותמיד יהיה מישהו שיהיה אחראי על אוטומציה, תשתית ושאר ירקות שקשורים ל-Devops.

בחברות גדולות לעומת זאת, דברים זזים לאט ולפעמים "נתקעים". אז אתה רוצה לעבוד במתודולוגיית Agile? כאילו ה-Devops הזה ששומעים עליו? אוקיי, נתחיל עם PoC. הגיוני, לא? רק שאז צצה לה ה"פוליטיקה" של הארגון. ההוא שם טיפוס מבודד שלא מוכן לעבוד עם אף אחד (ומה לעשות, הדבר הראשון ב-Devops זה עבודה ביחד) ההוא לא רוצה לעבוד עם ההיא וכו', אנשים לא רוצים עבודות נוספות כמו כתיבת טסטים, Stories וכו', יש חוסר רצון בולט בלעבור לכלים יותר מודרניים (גם אם אתה מציע כלים שישמרו על תאימות לדברים הקלאסיים) ובכלל – בארגונים רבים מנסים (וחברות גולגלות/כ"א די מסייעות לכך מבלי לשים לב) "לכמת" את זה למישהו מסוים, אולי 2-3 לצוות – בדיוק כמו שיש צוות לסטורג', לנטוורק, לוירטואליזציה – אז עכשיו יהיה "צוות Devops".

כאן, בשביל ה-PoC מישהו חיצוני (פרילאנסר) יכול להוות פתרון. החלק הראשון הוא ההסברה לגבי מה זה לכל הרוחות Devops, מה זה מתולודוגיית Agile software development, מה נדרש בעצם מהמפתחים, איך זה הולך להיות וכו', כלומר הרבה לפני שבכלל מרימים אפילו VM או קונטיינר אחד – יש ישיבות על גבי ישיבות, הסברה עם מצגות, צריכים הסכמות לגבי הדברים, אישורים עקרוניים מצד מנהלי צוותים שונים, חישוב ואישור תקציב – וכל זה לפני שאתה נוגע במקלדת בשביל לבנות משהו. האמינו לי, בחברה מסויימת אני אמור להקים קונטיינר יחיד ב-Docker. כמה זה מסובך? זה לא, אבל אנחנו כבר 6 חודשים בישיבות. בגלל זה, פרילאנסר מתאים לחלק של ה-PoC. הסכימה החברה לשנות את כל העבודה שלה ועבודת הצוותים? שם כבר יכול להיכנס שכיר (ולשכירים שנכנסים לגופים גדולים ההמלצה שלי: הצטיידו בטונות של סבלנות).

במהלך היום (אני קצת חולה עדיין) עברתי המון על קליפים ביוטיוב שיכולים להסביר בצורה עניינית ולא בצורה של בלה-בלה-בלה מה זה Devops ולבסוף מצאתי אחד שמסביר בצורה טובה (לדעתי) את הדברים. הוא לא נכנס לפרטים של איזה בדיוק כלי לבחור ולשם מה, אבל הוא מסביר את זה בקטגוריות. הוא גם מתייחס לדברים בחברות גדולות. אורכו של הקליפ הוא שעה וחצי, אבל יש חלקים שונים שאפשר לדלג מעליהם (השתמשו במקשים L ו-J [ללא shift] כדי לקפוץ 10 שניות כל פעם) ולדעתי הקליפ די עוזר לתפוס מה זה Devops.

לסיכום: כפי שציינתי אתמול, חברות כ"א עדיין ימשיכו לקטלג את Devops כעוד תחום, כלומר עוד מישהו נפרד תוך התעלמות מוחלטת שזה בראש ובראשונה עבודה בצוות בנושאים שונים ויש צורך בשיתוף פעולה מכולם, וחברות צריכות לזכור שבראש ובראשונה עוד לפני ששוכרים מישהו, צריך לגרום לכולם לעבוד ביחד ובשיתוף פעולה. אם כל אחד עובד בנפרד מבלי לרצות לשתף פעולה, שכירת שכיר שיעזור להכניס את החברה ל-Agile Development/Devops פשוט לא תעבוד, כי מה לעשות – אף מפתח ותיק לא ירצה להקשיב לבחור החדש.

אתם באמת צריכים איש Devops?

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

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

אני אקח ברשותכם את הדברים טיפה קדימה. אני יותר ממשיל "איש Devops" (המרכאות בכוונה) למשהו מהדת הנוצרית: לאוונגליסט. הוא האדם ש"מצעיד" את החברה ממצב עבודה "קלאסי" (כתיבת קוד, קימפול, הכנסה ל-source repository, הוצאת Build, העברה ל-QA, תיקונים, קימפול, הוצאת Beta, תיקוני באגים, עוד Beta, עוד תיקונים ושחרור גירסה – כל זה ב"מבט על" וקפיצה על כל מיני שלבים בדרך) למצב עבודה שונה וזריז בהרבה.

המצב הזה נקרא CI/CD, במצב הזה דוחפים את הקוד ל-GIT, ישנה מערכת כמו Jenkins ואחרות שבודקות את ה-GIT וברגע שיש תיוג – היא מושכת ומקמפלת. את ה-QA מחליפים ב-Unit Testing – שזהו קוד מצטבר שכותבים בחברה לבחון את הקוד הנכנס האם הוא עומד בבדיקות שונות שהמפתחים כותבים. הנה לדוגמא וידאו קליפ על Unit Testing:

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

בקיצור – לא רק הכלים שונים, השיטה שונה.

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

לכן, עבודה של איש Devops באמת אינה מתאימה לשכיר, כי מדובר במשהו שניתן לעשות בחודש, אולי חודשיים – יחד עם כל הצוות והדרגים השונים, זו עבודת פרויקט שמתאימה לפרילאנסר (אהלן) או לחברה חיצונית שתבוא ותלמד מה שצריך ללמד ולסייע בהקמת המערכת. מעבר לכך, אחרי שכולם מבינים ותהליך ה-CI/CD החל, אין ממש לאיש ה-Devops מה לעשות בחברה, ולכן צודקים חברות וסטארטאפים שמחפשים מישהו מבחוץ לזמן כלשהו כדי ללמד ולהטמיע את כל עניין ה-CI/CD ומתודלוגיות ה-Devops בחברה.

אבל מי שיציץ בפורומי מודעות דרושים, ימצא פעמים רבות מודעות שמחפשים "איש Devops" שיהיה, ותסלחו לי על הביטוי: סופר-כלבויניק. מקוששים מכל אחד מאנשי הצוות דברים שהם לא רוצים לעשות וזורקים את הכל על מישהו אחד, ושבדרך גם יעשה אוטומציה עם כלי כלשהו, שיהיה "ספץ" Linux וסקריפטים וכמובן שיהיה מומחה ב-Windows עם נסיון פיתוח. מהיכרות עם שכירים רבים, אני יכול לאמר שכאן בפירוש כיוונו לשמיים (ואני מתקשה להאמין שימצאו מישהו בדיוק עם אותה "רשימת קניות") ואין כמו פתגם שמדייק למטרה זו: תפסת מרובה, לא תפסת. הנה דוגמא של מודעה:

לסיכום: בחברה גדולה, תשתיות CI/CD יכולות להיות מוקמות ומתוחזקות ע"י צוות Linux שקיים בחברה. לגבי השאר, אותו "אוונגליסט" מגיע בשביל להקים וללמד אחרים, אז תנו לו לעשות את עבודתו. בסטאראטאפ לדעתי גם העניין הוא פחות או יותר אותו דבר: מישהו חיצוני שמגיע ומקים ומלמד את השאר, כדי שגם השאר ילמדו איך לעבוד וגם מי שאחראי על תשתית הענן (לדוגמא) יכול ללמוד איך להגדיר (ברוב המקרים לא מדובר במשהו מורכב אחרי ההקמה הראשונית). לחבריי השכירים אומר – אם עבודה כזו מתאימה לכם, אהלן וסהלן.