אתה זקוק לסביבת בדיקות באז'ר, שום דבר מורכב, רק רשת וירטואלית, זוג מכונות וירטואליות וחשבון יחסון. אז אתה נכנס לפורטל, מוצא את כפתור קבוצת המשאבים ומתחיל ללחוץ. לחיצה אחת ליצירת הקבוצה, עוד כמה להגדרת הרשת הוירטואלית, ואז אתה עובר באשף יצירת המכונה, בוחר אזור, גודל, תמונה, מגדיר את הדיסק ומגדיר את הרשת. זה אולי 50 לחיצות כבר שם. אחר כך אתה עושה זאת שוב עבור המכונה השנייה, מגדיר את חשבון היחסון, ואז מגדיר את חוקי חומת האש. והנה העניין, כל אחת מהלחיצות האלו היא הזדמנות לטעות. בחרת אזור לא נכון, האפליקציה תרוץ לאט מהצפוי, בחרת גודל מכונה לא נכון, אתה משלם יותר מדי מהיום הראשון. שכחת לסגור פורט, הרגע חשבת את הסביבה שלך לאינטרנט בלי לשים לב. עכשיו, תכפיל את זה בשלוש סביבות, פיתוח, בדיקות וייצור, ופתאום אתה לא עושה 50 לחיצות, אלא 150. ואיפשהו בתהליך הזה, סביבת הייצור נראית שונה לחלוטין מסביבת הפיתוח. הגדרה פה, תיבת סימון שם, הבדלים קטנים שגורמים לכאבי ראש גדולים אחר כך. אבל מה אם הייתה יכול לתאר את כל הגדרות האז'ר שלך בקובץ במקום ללחוץ על כל המסקים האלו? מה אם הייתה יכול להריץ את הקובץ פעם אחת ולקבל את אותה תוצאה בכל פעם מחדש? על זה אנחנו מדברים היום. בסוף הפרק הזה, תבין מה זה באמת, תשתית כקוד, למה צוותי אז'ור מסתמכים על זה, ואיך אתה יכול להתחיל להשתמש בזה בלי להיות מפתח. מה הקצאה ידנית באמת עולה לך? בוא נעבור על הגדרה טיפוסית באז'ר. אתה צריך קבוצת משאבים בתוכה רשת וירטואלית עם כמה רשתות משנה, אז זוג מכונות וירטואליות, אחת לשרת האינטרנט ואחת לבסיס הנתונים, וחשבון נחסון לנתוני האפליקציה שלך. בפורטל מדובר בצהריים שלמים של לחיצות, והנה הבעיה, כל לחיצה היא הזדמנות לטעות. אולי בחרת אזור לא נכון כי ברירת המחדל בתפריט היא מזרח ארצות הברית ואתה התכוונת למערב אירופה. אולי בחרת גודל מכונה יקר מדי עבור מה שאתה באמת צריך. אולי בטעות הישרת פורט ניהול פתוח לאינטרנט. הטעויות האלו קורות. הן קורות כי הפורטל מקל על לחיצה מהירה ומקשה על היעטה ובדיקה של העבודה שלך. והעלות האמיתית היא לא רק הזמן שאתה מבזבז על תיקון הטעויות האלו, זה הזמן שאתה מבזבז על חזרה על אותן לחיצות עבור פיתוח, בדיקות, שלבי ביניים וייצור. כי הנה מה שקורה. אתה מקים את סביבת הפיתוח ביום שני, זה לוקח לך שלוש שעות וזה עובד בצורה מושלמת. ביום שלישי, אתה מקים את סביבת הבדיקות. אתה קצת יותר מהיר הפעם, שעתיים וחצי, אבל אתה שוכח הגדרה אחת. חוק חומת אש שהיה פתוח בפיתוח סגור בסביבת הבדיקות. היישום שלך מתנהג אחרת, ואתה מבלה שעה בניפוי שגיאות. עד שאתה מגיע לסביבת הייצור ביום שישי, הסביבה שלך לא נראית בכלל כמו הפיתוח. גדלים שונים של מכונות וירטואליות, הגדרות איחסון שונות, כמה הגדרות ששינית כמי שהוא אמר, רק תנסה את זה מהר. זוהי, סטיית תצורה, וזו התוצאה הטבעית של בניית סביבות באופן ידני. הבעיה האמיתית היא שאי אפשר לבצע ביקורת על לחיצת אכבר. אי אפשר לבטל לחיצת אכבר. אם משהו ישבר בסביבת הייצור בעוד שישה שבועות, לא תזכור איזו תיבת סימון סימנטה או ביטלטה. לא יהיה לך תיעוד של מה השתנה בין הפיתוח לייצור. אז, מה אם היית יכול לתאר את כל הגדרת האז'ר שלך בקובץ במקום ללחוץ על מסכים? קובץ אחד שאומר בדיוק איך הסביבה שלך צריכה להיראות. מריצים פעם אחת, מקבלים את אותה תוצאה בכל פעם. מריצים שוב, מקבלים את אותה תוצאה שוב. אין סטיות, אין הגדרות שנשכחו, אין סביבות ייצור שלא נראות כמו הפיתוח. תשתית כקוד, ISC, ההגדרה במשפט אחד. תשתית כקוד אומרת לתאר את התשתית שלך בקובץ שאיזור יכול לקרוא ולבנות עבורך. זה הכל. משפט אחד. אתה כותב קובץ, איזור קורא אותו, והסביבה שלך מופיעה. תחשוב על זה כמו על בניין משרדים. אם רצית להקים משרד חדש, יכולת להסתובב ולהגיד לכל עובד איפה להציב כל שולחן וכל כיסא. זו הגישה הידנית. זה עובד, אבל זה איתי, וכולם יסיימו עם סידור מעט שונה. או שאתה יכול לתת להם תוכנית בנייה. דף נייר אחד שאומר בדיוק לאן הכל הולך. כל חדר זהה כי כולם עקבו אחרי אותה תוכנית. קובץ האייק שלך הוא תוכנית הבנייה הזו. זה מקור אמת יחיד עבור כל סביבת האז'ר שלך. כל מה שהסביבה שלך צריכה, קבוצות משאבים, רשתות וירטואליות, מכונות, חשבונות איחסון, חוקי חומת אש הכל נמצא בקובץ אחד. עכשיו, יש כאן הבחנה חשובה. ISC משתמש במה שנקרא גישה דקלרטיבית. זו דרך מהודרת לומר שאתה אומר לאז'ר מה אתה רוצה, לא איך לבנות את זה צעד אחר צעד. אתה לא אומר, צור קבוצת משאבים, אז צור רשת וירטואלית בתוכה, אז צור תת רשת בתוכה. אתה אומר, אני רוצה קבוצת משאבים עם רשת וירטואלית שיש בתת רשת. Azure מבינה את הסדר. זה שונה מהסקריפטים שמנהלי מערכות השתמשו בהם במשך שנים. סקריפטים הם אימפרטיביים. הם אומרים למערכת בדיוק מה לעשות צעד אחר צעד. עשה את זה, אז תעשה את ההוא, אז תעשה את הדבר הזה. ואם צעד אחד נכשל, הכל קורס. ISC הוא ההפך. אתה מתאר את מצב הסיום, והמערכת מבינה איך להגיע לשם. הנה דוגמה קונקרטית. במקום להקליד 50 פקודות CLI נפרדות כדי ליצור מכונה וירטואלית, אתה כותב משהו כמו, אני צריך מכונה וירטואלית עם 8 ג'יגה בייט רם שמריצה ובונטו 22.04, מחוברת לרשת וירטואלית זו עם חשבון נחסון מצורף. זה הכל. תיאור אחד במקום 100 פקודות. וזה חשוב במיוחד עבור Azure, כי הפורטל כל כך קל להתחלה. אתה יכול להפעיל מכונה וירטואלית תוך 10 דקות בכמה קליקים, אבל הפורטל לא ניתן להרחבה. כשאתה צריך 10 סביבות במקום אחת, הפורטל הופך לנטל. ISC הוא הדרך שלך להשתחרר מהמלכודת הזו. אז זה נשמע שימושי, נכון, אבל אילו כלים מייקרוסופט באמת נותנת לך כדי לכתוב את קבצי התוכנית האלה. ערכת הכלים של Azure ISC, ARM, Bicep, והפיל שבחדר. אז אילו כלים מייקרוסופט באמת נותנת לך כדי לכתוב את קבצי התוכנית האלה. המקורי נקרא תבניות ARM. ARM מייצג Azure Resource Manager, והתבניות האלה קיימות מההתחלה. הן כתובות בג'סון, שהוא פורמט נתונים שנראה כמו קובץ הגדרות מממינוס 2015. המון סוגריים מסולסלים, המון סוגריים מרובעים, המון הזכה. אם אי פעם הסתכלת על קובץ ג'סון, אתה יודע למה אני מתכוון. זה פונקציונלי, אבל זה לא נעים לקריאה. תבניות ARM עדיין בשימוש נרחב, במיוחד בסביבות ארגוניות. חברות גדולות השקיעו שנים בבניית ספריות התבניות שלהן, והן לא עומדות לזרוק את העבודה הזו לפח. אבל אם אתה מתחיל, להסתכל על תבנית ARM בפעם הראשונה יכול להיות מאיים. זה מילולי מדי. זה קל לשבירה. פסיק אחד חסר וכל העסק נכשל. לכתוב אחד כזה ביד זה כואב. מייקרוסופט זיהתה את הבעיה הזו, אז הם בנו את בייספ. בייספ היא התשובה של מייקרוסופט לכך שתבניות ARM מסובכות מדי. זו שפה חדשה יותר שמתכמפלט לתבניות ARM מאחורי הקלעים, אבל התחביר הרבה יותר נקי. זה נראה כמו קוד אמיתי. אתה כותב משהו כמו Resource My VM Microsoft. Compute Virtual Machines במקום עמודים של ג'ייסן מקונן. זה תוכנן קודם כל עבור בני אדם. כעת, ישנה אפשרות נוספת שתשמע עליה, טראפורם. טראפורם הוא כלי של חברה בשם HashiCorp, והוא עובד עם Azure ועננים אחרים. אם עליך לנהל תשתית ב-AWS, Google Cloud ו-Azure בבת אחת, טראפורם הוא הבחירה הטובה ביותר. הוא נייד יותר, אך לניידות הזו יש מחיר. טראפורם מוסיף שכבת הפשטה בינך לבין Azure. עליך ללמוד את השפה של טראפורם, HCL, מעבר להבנת Azure עצמה. הוא עוצמתי, אך הוא מביא איתו מורכבות משלו. אז במי כדאי למתחיל לבחור? אם אתה עובד רק באז'ר, התחל עם בייספ. הסיבה פשוטה, אינטגרציה טבעית. בייספ נבנה על ידי מייקרוסופט במיוחד עבור Azure. יש לו פחות חלקים נעים. הוא מקבל תמיכה מלאה ממייקרוסופט. ומכיוון שהוא מתכמפל ל-Arm Templates, אתה לא נעול על שום דבר. תמיד תוכל לעבור ל-Arm Templates גולמיים מאוחר יותר אם תצטרך. בייספ הוא המסלול הפשוט ביותר למי שרק רוצה להתחיל. כך הכלים האלה עובדים בפועל. אתה כותב קובץ, קובץ בייספ, תבנית ARM, מה שתבחר. לאחר מכן אתה מריץ פקודה. עבור בייספ, הפקודה היא As Deployment Group Create. Azure קורא את הקובץ שלך, משווה אותו למה שקיים, ובונה את מה שחסר או משנה את מה ששונה. אתה לא צריך להגיד לאזר באיזה סדר לבצע את הדברים. הוא מבין זאת בעצמו, וכאן זה נהיה באמת מעניין. אתה יכול לחבר את זה לצינור C, CD, אינטגרציה רציפה ופריסה רציפה. זה אומר שבכל פעם שאתה דוחף שינוי למאגר הקוד שלך, Azure מריץ אוטומטית את קובץ ה-ISC ומעדכן את התשתית שלך. ללא שלבים ידניים, ללא כניסה לפורטל, רק שינויי קוד שזורמים לייצור באופן אוטומטי. אז יש לך קובץ שמתאר את התשתית שלך. אתה יכול להריץ אותו ולקבל תוצאה עקבית. אתה יכול אפילו להפוך את כל התהליך לאוטומטי בעזרת פייפליין. אבל מה זה באמת פותח? כאן הדברים נהיים עוצמתיים באמת. מה בקרת גרסאות עושה עבור סביבת האז'ר שלך? הנה הדבר שאנשים לא מדברים עליו מספיק. כוח העל האמיתי של ISC אינו פורמט התבנית עצמו. זה לא בייספ מול ARM מול טראפורם. כוח העל האמיתי הוא בקרת גרסאות. כשאתה מאחסן את קבצי ה-ISC שלך במאגר כמו GitHub או Azure Repose, כל שינוי הופך לניתן למעקב. מי שינה מה? מתי שינו זאת ולמה? אתם מקבלים היסטוריה מלאה של כל שינוי בתשתית שלכם מהיום הראשון. וזה אומר שניתן לבצע שחזור. אם פריסה גורמת לתקלה, לא צריך לנחש מה ישתבש. לא צריך לחפור ביומני הביקורת של הפורטל בתקווה למצוא תשובה. פשוט חוזרים לגרסה התקינה האחרונה של קובץ ה-ISC ומבצעים פריסה מחדש. הבעיה נעלמת. זה דבר שפשוט אי אפשר לעשות בלחיצות אכבר. זה גם אומר שהסביבות שלכם נשארות עקביות. פיתוח, בדיקות וייצור מגיעים כולם מאותם קבצים. לא קבצים דומים ולא קבצים שהתחילו זהים אך השתנו עם הזמן. אותם קבצים בדיוק. אתם פורסים את הפיתוח מענף המן שלכם. כשאתם מוכנים לבדיקות, אתם פורסים את אותם קבצים למנוי הבדיקות. כשאתם מוכנים לייצור, אתם פורסים שוב את אותם הקבצים. כל סביבה זהה לאחרת כי כל סביבה נבנתה מאותה תוכנית. ומכיוון שהקבצים האלו נמצאים במאגר, אפשר לעשות סקירות קוד לתשתית. לפני שמי שהוא פורס שינוי, חבר צוות אחר חייב לבדוק ולאשר אותו. זה עוצר טעויות לפני שהן אי פעם מגיעות לסביבה שלכם. זהו אותו תהליך שמפתחי תוכנה משתמשים בו לקוד אפליקציה, מיושם על הגדרות האז'ר שלכם. הנה דוגמה מהעולם האמיתי. מי שהוא בצוות שלכם פותח בטעות חשבון יחסון לציבור. בלי ISC, אולי לא תשימו לב עד שיגיע החשבון או שמי שהוא יגיד לכם שהנתונים שלכם חשופים. עם ISC, השינוי הזה גלוי במאגר. הוא עובר סקירת קוד. מי שהוא מבחין בו ואומר, היי, חשבון היחסון הזה לא אמור להיות ציבורי. השינוי נחסם לפני שהוא מגיע לסביבת הייצור. ואם הוא איך שהוא מצליח לעבור, אפשר לשחזר אותו תוך שניות. אפשר אפילו להשתמש בהסתרטגיות של ענפים, ברנצ'ים. רוצים להתנסות בתצורה חדשה? צרו ענף נפרד, ביצעו את השינויים, פרסו לסביבת בדיקות וראו אם זה עובד. אם כן, ביצעו מזוג חזרה לענף הראשי. אם לא, מחכו את הענף ונסו משהו אחר. סביבת הייצור שלכם לעולם לא תיפגע עד שתהיו בטוחים שהשינוי בטוח. עקביות זה נהדר, אבל ISE גם הופך את הגדרות האז'ר שלכם למאובטחות יותר. וזה משנה אם יש לכם אדם אחד שמנהל הקול או צוות שלם. הבטחה לפי תכנון לא במקרה. הנה משהו שמפתיע אנשים רבים. כשמשתמשים ב-ISE, הבטחה היא לא משהו שמוסיפים אחר כך. היא מוטמעת בתבנית כבר מההתחלה. במקום לזכור להפעיל הצפנה בכל חשבון נחסון חדש, זה כבר כלול בקובץ שלך. במקום לקוות שמישהו הגדיר נכון את חוקי חומת האש, החוקים כתובים ונאחפים בכל פעם מחדש. לרעיון הזה יש שם מדיניות כקוד. אתה מטמיע את חוקי האבטחה שלך ישירות בתוך תהליך הפריסה. כך, בכל פעם שמישהו מנסה לפרוס חשבון נחסון, הצינור בודק ש-HTTPS מופעל, שהעצפנה דלוקה ושגישה ציבורית חסומה. אם התבנית לא עומדת בחוקים האלה, הפריסה נכשלת. ההגדרה הלא מאובטחת לעולם לא תגיע לסביבה שלך. תחשוב על מה שזה מחליף. עשרות בדיקות ידניות, מישהו שזוכר לסמן את הטבע הנכונה, מישהו אחר שבודק את הטבעות האלה מאוחר יותר. כל זה נעלם. תבנית מאובטחת אחת, סט מדיניות אחד, וכל פריסה עומדת אוטומטית בקו הבסיס הביטחוני שלך. אבל הנה החלק המעניין באמת, התאוששות מאסון. הקובץ שמתאר את התשתית שלך יכול לבנות אותה מחדש בכל מקום. אם תוקף פוגע בסביבה שלך, אתה לא צריך לבזבז ימים בי להבין מה הם שינו ואיך לתקן את זה. אתה מפרק את הכל. אתה פורס מחדש מקובץ העייק שלך. הסביבה הנקיע שלך חוזרת תוך דקות. זה בלתי אפשרי כשהתשתית שלך נבנתה ידנית. ומכיוון שהכל נמצא בבקרת גרסאות, יש לך הנתיב ביקורת. כל שינוי בתשתית שלך מתועד. מי ביצע אותו? מתי ולמה? זוהי הוכחת תאימות מבלי שאף אחד יצטרך למלא גיליון אלקטרוני. עבור צוותים קטנים ללא צוות הבטחה יהודי, זה מכפיל כוח. אתה מקבל שיטות הבטחה ברמה ארגונית בלי לזכור צוות הבטחה ארגוני. זה נשמע מצוין על הנייר, אבל להתחיל יכול להרגיש מציף. תן לי לתת לך מסלול ריאלי להתקדם בו. איך להתחיל בלי לשבור שום דבר? כלל ראשון, אל תתחיל עם סביבת הייצור. אני לא יכול להדגיש זאת מספיק. ISC זה כלי עוצמתי, אבל הוא גם חדש. אתה תעשה טעויות. תעשה אותן במקום שבו זה לא משנה. בחר חלק קטן מהסביבה שלך באז'ר, קבוצת משאבים עם מכונה וירטואלית אחת או חשבון נחסון, משהו פשוט שכבר פועל, משהו שאתה יודע שעובד. הנה הטריק. פורטל אז'ור יכול למעשה ליצור תבניות ARM מהמשאבים הקיימים שלך. אתה נכנס לקבוצת המשאבים, לוחץ על ייצוא תבנית, ו-Azure נותנת לך את קובץ הג'סון שמתאר הכל בקבוצה. זה לא מושלם. התבנית המיוצאת כוללת לעיתים דברים שאתה לא צריך, אבל זו נקודת התחלה. אתה לוקח משהו שבנית ידנית וממיר אותו לקוד. זו גישת ההנדסה לאחור והיא הדרך המהירה ביותר ללמוד. התחילו עם בייספ ועם הכלים החינמיים של Azure. למייקרוסופט יש תוסף VS Code עבור בייספ שמעניק לכם הדגשת תחביר, השלמה אוטומטית ותצוגה מקדימה חזותית של מה שאתם בונים. ניתן לראות את הרשת הווירטואלית והרשתות המשנה שלכם כתרשים לפני שפורסים דבר מה. זה הופך את ההבנה של מה שהקוד שלכם עושה בפועל להרבה יותר פשוטה. השתמשו במנוי נפרד לבדיקות. לרוב המנויים של Azure יש מגבלות הוצאה וזיקויים בחינם. צרו מנוי בדיקה, פרוסו שם את ה-ISC שלכם, שברו דברים, תקנו אותם, תלמדו. כשתרגישו בטוחים, עברו למנוי שאינו מיועד לייצור Non-Production. סביבת הייצור מגיעה בסוף. הנה החלק שעשוי להפתיע אתכם. אתם לא צריכים להיות מהנדסי תוכנה כדי לעשות את זה. זווית הראייה של מפתח אזרחי היא אמיתית. בייספ, תוכנן עבור אנשים שמנהלים תשתית Azure, לא עבור מתכנתים מקצועיים. הוא קרי, יש לו פחות, תקסים, מספות תכנות מסורתיות. הוא ממוקד באז'ר ולא בשום דבר אחר. אם אתם יכולים להבין מהי מכונה וירטואלית, תוכלו ללמוד לתאר אחת בביספ. הפרויקט המעשי הראשון שלכם, אוטומציה של פירוק ובנייה מחדש של סביבת הפיתוח. כתבו קובץ בייספ שיוצר את סביבת הפיתוח שלכם, פרוסו אותו, השתמשו בו, ואז פירקו אותו ופרוסו שוב. עשו זאת כמה פעמים עד שהתהליך ירגיש שגרתי. התרגיל הזה לבדו ילמד אתכם יותר על ISC מכל מדריך אחר. כמה עצות מפוצות למתחילים. ביצעו קומית מוקדם ולעיתים קרובות. בכל פעם שחלק מהתבנית שלכם עובד, שימרו אותו במאגר שלכם. זה נותן לכם נקודות ביקורת שניתן לחזור עליהן. ותמיד הריצו את פקודת התצוגה המקדימה לפני הפריסה. בביספ, זו הפקודה What If. היא מראה לכם בדיוק מה ישתנה לפני שמשהו באמת משתנה. בלי הפתעות, גם עם הכוונות הטובות ביותר, יש כמה מלכודות שמתחילים נופלים עליהן. תנו לי לחסוך לכם כמה לילות של ניפוי שגיאות. אם אתם צריכים לגרום לתבנית לעבוד, אז אתם זורקים את סיסמת בסיס הנתונים ישר לתוך הקובץ. זה עובד, אתם ממשיכים הלאה. ועכשיו הסיסמה שלכם יושבת במאגר ה-ISC שלכם וחשופה לכל מי שיש לו גישה. ברור בדיעבד, נכון. אבל זה קל מאוד לעשות כשאתם ממוקדים רק בלהפעיל משהו. הפתרון הוא Azure Key Vault. גם בייספ וגם תבניות ARM יכולים למשוך סודות ישירות מ-Key Vault בזמן הפריסה. הקובץ שלכם מציין משוך את הסיסמה מהכספת הזו במקום להכיל את הסיסמה עצמה. הסוד לעולם לא נוגע במאגר שלכם. לעולם אל תכניס סיסמאות, מחרוזות התחברות או מפתחות API לקבצי ה-ISC שלך. השתמש ב-Key Vault בכל פעם מחדש. טעות מספר 2 היא להתייחס ל-ISC כאל סקריפט חד פעמי. אתה כותב תבנית, פורס אותה, היא עובדת, ואתה לעולם לא מסתכל עליה שוב. שישה חודשים אחר כך, משהו נשבר. אתה פותח את הקובץ ואין לך מושג מחצי ממנו עושה. הפרמטר הזה שנקרא param1, אין לי מושג. המשאב הזה עם השם המוצפן, אין לי מושג. כתוב את ה-ISC שלך כאילו מישהו אחר יתחזק אותו בעוד חצי שנה, כי המישהו האחר הזה הוא כנראה אתה, ואתה תשכח הכל. אוסף הערות, השתמש בשמות תיאוריים במקום בקיצורים, ושמור על קבצים קטנים וממוקדים בדבר אחד. קובץ בייספ, שיוצר רשת וירטואלית, צריך לעסוק ברשתות וירטואליות, לא בכל מרכז הנתונים. טעות מספר 3 היא לעקוף את הפייפליין עבור תיקונים מהירים. הפורטל תמיד מפתה, אתה צריך לשנות הגדרה אחת. ייקח 5 דקות לערוך את התבנית, לבצע קומית, ולפרוס דרך הפייפליין. או שאתה יכול פשוט להתחבר לפורטל, ללחוץ 3 פעמים, ולסיים תוך 30 שניות. השינוי המהיר הזה יוצר סחיפה, דריפט. הקוד שלך אומר דבר אחד, המציאות אומרת אחרת. בפעם הבאה שתפרוס מהתבנית שלך, Azure תנסה לבטל את השינוי הידני שלך, או גרוע מכך, היא לא תבחין בזכיפה והסביבה שלך תתפצל לאיתה עד שסביבת הייצור תתנהג אחרת לגמרי מסביבת הפיתוח. המשמעת פשוטה, בצע את השינוי בקוד. פרוס דרך הפייפליין, גם אם זה לוקח עוד 5 דקות. 5 הדקות האלה יחסכו לך השעות של ניפוי שגיאות מאוחר יותר. טיפ בונוס אחד, תמיד הרץ את פקודת התצוגה המקדימה לפני החלת שינויים. בבי סאפ, זה מה שנקרא what if. זה מראה לך בדיוק מה ייווצר, ישונה או יושמד. בלי הפתעות. אתה רואה את ההשפעה לפני שהיא קוראת. זה IAC בשפה פשוטה. בלי ז'רגון. בלי קידומי מחירות. רק כלי פרקטי שהופך את החיים שלך באז'ר לקלים יותר. הדבר האחד שכדאי לנסות השבוע. אז, הנה מה שכיסינו. IAC הופך את תשתית האז'ר שלך לתוכנית עבודה מבוקרת גרסאות, אדירה ומאובטחת. קובץ אחד שמתאר הכל, שנפרס באותה דרך בכל פעם. האתגר שלך השבוע, ייצא משאב אז'ר קיים אחד כתבנית ARM. פתח אותו ב-VS Code. בדוק אם אתה יכול להבין מה הוא עושה. התרגיל הבודד הזה ילמד אותך יותר מכל הסבר שאוכל לתת. בהמשך הסדרה הזו, נעבור על כתיבת קובץ הבספ הראשון שלך צעד אחר צעד. הרשם בפלטפורמת הפודקסטים המועדפת עליך ושתף את זה עם חבר לצוות שעדיין מקליק דרך הפורטל.