WEBVTT

00:00:00.000 --> 00:00:06.160
אתה זקוק לסביבת בדיקות באז'ר, שום דבר מורכב, רק רשת וירטואלית, זוג מכונות וירטואליות וחשבון יחסון.

00:00:06.280 --> 00:00:10.020
אז אתה נכנס לפורטל, מוצא את כפתור קבוצת המשאבים ומתחיל ללחוץ.

00:00:10.200 --> 00:00:19.780
לחיצה אחת ליצירת הקבוצה, עוד כמה להגדרת הרשת הוירטואלית, ואז אתה עובר באשף יצירת המכונה, בוחר אזור, גודל, תמונה, מגדיר את הדיסק ומגדיר את הרשת.

00:00:19.920 --> 00:00:21.720
זה אולי 50 לחיצות כבר שם.

00:00:21.720 --> 00:00:26.960
אחר כך אתה עושה זאת שוב עבור המכונה השנייה, מגדיר את חשבון היחסון, ואז מגדיר את חוקי חומת האש.

00:00:27.100 --> 00:00:30.300
והנה העניין, כל אחת מהלחיצות האלו היא הזדמנות לטעות.

00:00:30.480 --> 00:00:36.520
בחרת אזור לא נכון, האפליקציה תרוץ לאט מהצפוי, בחרת גודל מכונה לא נכון, אתה משלם יותר מדי מהיום הראשון.

00:00:36.720 --> 00:00:40.980
שכחת לסגור פורט, הרגע חשבת את הסביבה שלך לאינטרנט בלי לשים לב.

00:00:40.980 --> 00:00:47.660
עכשיו, תכפיל את זה בשלוש סביבות, פיתוח, בדיקות וייצור, ופתאום אתה לא עושה 50 לחיצות, אלא 150.

00:00:48.180 --> 00:00:52.400
ואיפשהו בתהליך הזה, סביבת הייצור נראית שונה לחלוטין מסביבת הפיתוח.

00:00:52.580 --> 00:00:56.660
הגדרה פה, תיבת סימון שם, הבדלים קטנים שגורמים לכאבי ראש גדולים אחר כך.

00:00:56.780 --> 00:01:01.540
אבל מה אם הייתה יכול לתאר את כל הגדרות האז'ר שלך בקובץ במקום ללחוץ על כל המסקים האלו?

00:01:01.640 --> 00:01:05.720
מה אם הייתה יכול להריץ את הקובץ פעם אחת ולקבל את אותה תוצאה בכל פעם מחדש?

00:01:05.720 --> 00:01:16.500
על זה אנחנו מדברים היום. בסוף הפרק הזה, תבין מה זה באמת, תשתית כקוד, למה צוותי אז'ור מסתמכים על זה, ואיך אתה יכול להתחיל להשתמש בזה בלי להיות מפתח.

00:01:17.720 --> 00:01:22.360
מה הקצאה ידנית באמת עולה לך? בוא נעבור על הגדרה טיפוסית באז'ר.

00:01:22.540 --> 00:01:32.540
אתה צריך קבוצת משאבים בתוכה רשת וירטואלית עם כמה רשתות משנה, אז זוג מכונות וירטואליות, אחת לשרת האינטרנט ואחת לבסיס הנתונים, וחשבון נחסון לנתוני האפליקציה שלך.

00:01:32.540 --> 00:01:38.280
בפורטל מדובר בצהריים שלמים של לחיצות, והנה הבעיה, כל לחיצה היא הזדמנות לטעות.

00:01:38.420 --> 00:01:43.360
אולי בחרת אזור לא נכון כי ברירת המחדל בתפריט היא מזרח ארצות הברית ואתה התכוונת למערב אירופה.

00:01:43.480 --> 00:01:46.840
אולי בחרת גודל מכונה יקר מדי עבור מה שאתה באמת צריך.

00:01:47.020 --> 00:01:49.580
אולי בטעות הישרת פורט ניהול פתוח לאינטרנט.

00:01:49.580 --> 00:01:51.040
הטעויות האלו קורות.

00:01:51.160 --> 00:01:55.120
הן קורות כי הפורטל מקל על לחיצה מהירה ומקשה על היעטה ובדיקה של העבודה שלך.

00:01:55.240 --> 00:02:02.600
והעלות האמיתית היא לא רק הזמן שאתה מבזבז על תיקון הטעויות האלו, זה הזמן שאתה מבזבז על חזרה על אותן לחיצות עבור פיתוח, בדיקות, שלבי ביניים וייצור.

00:02:02.720 --> 00:02:03.540
כי הנה מה שקורה.

00:02:03.680 --> 00:02:06.980
אתה מקים את סביבת הפיתוח ביום שני, זה לוקח לך שלוש שעות וזה עובד בצורה מושלמת.

00:02:06.980 --> 00:02:09.080
ביום שלישי, אתה מקים את סביבת הבדיקות.

00:02:09.220 --> 00:02:12.880
אתה קצת יותר מהיר הפעם, שעתיים וחצי, אבל אתה שוכח הגדרה אחת.

00:02:12.980 --> 00:02:15.840
חוק חומת אש שהיה פתוח בפיתוח סגור בסביבת הבדיקות.

00:02:15.980 --> 00:02:18.960
היישום שלך מתנהג אחרת, ואתה מבלה שעה בניפוי שגיאות.

00:02:18.960 --> 00:02:23.260
עד שאתה מגיע לסביבת הייצור ביום שישי, הסביבה שלך לא נראית בכלל כמו הפיתוח.

00:02:23.420 --> 00:02:29.340
גדלים שונים של מכונות וירטואליות, הגדרות איחסון שונות, כמה הגדרות ששינית כמי שהוא אמר, רק תנסה את זה מהר.

00:02:29.500 --> 00:02:33.540
זוהי, סטיית תצורה, וזו התוצאה הטבעית של בניית סביבות באופן ידני.

00:02:33.680 --> 00:02:36.640
הבעיה האמיתית היא שאי אפשר לבצע ביקורת על לחיצת אכבר.

00:02:36.800 --> 00:02:38.280
אי אפשר לבטל לחיצת אכבר.

00:02:38.280 --> 00:02:43.160
אם משהו ישבר בסביבת הייצור בעוד שישה שבועות, לא תזכור איזו תיבת סימון סימנטה או ביטלטה.

00:02:43.280 --> 00:02:46.060
לא יהיה לך תיעוד של מה השתנה בין הפיתוח לייצור.

00:02:46.220 --> 00:02:50.680
אז, מה אם היית יכול לתאר את כל הגדרת האז'ר שלך בקובץ במקום ללחוץ על מסכים?

00:02:50.680 --> 00:02:53.480
קובץ אחד שאומר בדיוק איך הסביבה שלך צריכה להיראות.

00:02:53.600 --> 00:02:55.840
מריצים פעם אחת, מקבלים את אותה תוצאה בכל פעם.

00:02:56.000 --> 00:02:57.920
מריצים שוב, מקבלים את אותה תוצאה שוב.

00:02:57.920 --> 00:03:01.980
אין סטיות, אין הגדרות שנשכחו, אין סביבות ייצור שלא נראות כמו הפיתוח.

00:03:02.120 --> 00:03:05.040
תשתית כקוד, ISC, ההגדרה במשפט אחד.

00:03:05.200 --> 00:03:09.700
תשתית כקוד אומרת לתאר את התשתית שלך בקובץ שאיזור יכול לקרוא ולבנות עבורך.

00:03:09.880 --> 00:03:10.480
זה הכל.

00:03:10.640 --> 00:03:11.420
משפט אחד.

00:03:11.420 --> 00:03:14.560
אתה כותב קובץ, איזור קורא אותו, והסביבה שלך מופיעה.

00:03:14.620 --> 00:03:16.280
תחשוב על זה כמו על בניין משרדים.

00:03:16.280 --> 00:03:21.400
אם רצית להקים משרד חדש, יכולת להסתובב ולהגיד לכל עובד איפה להציב כל שולחן וכל כיסא.

00:03:21.560 --> 00:03:22.640
זו הגישה הידנית.

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

00:03:26.320 --> 00:03:28.160
או שאתה יכול לתת להם תוכנית בנייה.

00:03:28.340 --> 00:03:30.800
דף נייר אחד שאומר בדיוק לאן הכל הולך.

00:03:30.920 --> 00:03:33.480
כל חדר זהה כי כולם עקבו אחרי אותה תוכנית.

00:03:33.480 --> 00:03:36.020
קובץ האייק שלך הוא תוכנית הבנייה הזו.

00:03:36.160 --> 00:03:38.940
זה מקור אמת יחיד עבור כל סביבת האז'ר שלך.

00:03:39.080 --> 00:03:46.620
כל מה שהסביבה שלך צריכה, קבוצות משאבים, רשתות וירטואליות, מכונות, חשבונות איחסון, חוקי חומת אש הכל נמצא בקובץ אחד.

00:03:46.780 --> 00:03:48.660
עכשיו, יש כאן הבחנה חשובה.

00:03:48.780 --> 00:03:51.480
ISC משתמש במה שנקרא גישה דקלרטיבית.

00:03:51.700 --> 00:03:56.520
זו דרך מהודרת לומר שאתה אומר לאז'ר מה אתה רוצה, לא איך לבנות את זה צעד אחר צעד.

00:03:56.520 --> 00:04:02.060
אתה לא אומר, צור קבוצת משאבים, אז צור רשת וירטואלית בתוכה, אז צור תת רשת בתוכה.

00:04:02.140 --> 00:04:06.100
אתה אומר, אני רוצה קבוצת משאבים עם רשת וירטואלית שיש בתת רשת.

00:04:06.280 --> 00:04:07.480
Azure מבינה את הסדר.

00:04:07.700 --> 00:04:10.940
זה שונה מהסקריפטים שמנהלי מערכות השתמשו בהם במשך שנים.

00:04:11.160 --> 00:04:12.480
סקריפטים הם אימפרטיביים.

00:04:12.660 --> 00:04:15.340
הם אומרים למערכת בדיוק מה לעשות צעד אחר צעד.

00:04:15.480 --> 00:04:18.000
עשה את זה, אז תעשה את ההוא, אז תעשה את הדבר הזה.

00:04:18.200 --> 00:04:19.900
ואם צעד אחד נכשל, הכל קורס.

00:04:20.040 --> 00:04:21.200
ISC הוא ההפך.

00:04:21.200 --> 00:04:24.780
אתה מתאר את מצב הסיום, והמערכת מבינה איך להגיע לשם.

00:04:24.900 --> 00:04:26.160
הנה דוגמה קונקרטית.

00:04:26.320 --> 00:04:30.000
במקום להקליד 50 פקודות CLI נפרדות כדי ליצור מכונה וירטואלית,

00:04:30.200 --> 00:04:36.320
אתה כותב משהו כמו, אני צריך מכונה וירטואלית עם 8 ג'יגה בייט רם שמריצה ובונטו 22.04,

00:04:36.640 --> 00:04:39.300
מחוברת לרשת וירטואלית זו עם חשבון נחסון מצורף.

00:04:39.460 --> 00:04:40.040
זה הכל.

00:04:40.180 --> 00:04:42.020
תיאור אחד במקום 100 פקודות.

00:04:42.060 --> 00:04:45.540
וזה חשוב במיוחד עבור Azure, כי הפורטל כל כך קל להתחלה.

00:04:45.540 --> 00:04:50.820
אתה יכול להפעיל מכונה וירטואלית תוך 10 דקות בכמה קליקים, אבל הפורטל לא ניתן להרחבה.

00:04:50.980 --> 00:04:54.080
כשאתה צריך 10 סביבות במקום אחת, הפורטל הופך לנטל.

00:04:54.240 --> 00:04:56.520
ISC הוא הדרך שלך להשתחרר מהמלכודת הזו.

00:04:56.620 --> 00:05:01.700
אז זה נשמע שימושי, נכון, אבל אילו כלים מייקרוסופט באמת נותנת לך כדי לכתוב את קבצי התוכנית האלה.

00:05:01.800 --> 00:05:05.320
ערכת הכלים של Azure ISC, ARM, Bicep, והפיל שבחדר.

00:05:05.480 --> 00:05:09.380
אז אילו כלים מייקרוסופט באמת נותנת לך כדי לכתוב את קבצי התוכנית האלה.

00:05:09.380 --> 00:05:11.180
המקורי נקרא תבניות ARM.

00:05:11.340 --> 00:05:15.340
ARM מייצג Azure Resource Manager, והתבניות האלה קיימות מההתחלה.

00:05:15.500 --> 00:05:19.960
הן כתובות בג'סון, שהוא פורמט נתונים שנראה כמו קובץ הגדרות מממינוס 2015.

00:05:20.420 --> 00:05:23.500
המון סוגריים מסולסלים, המון סוגריים מרובעים, המון הזכה.

00:05:23.600 --> 00:05:26.540
אם אי פעם הסתכלת על קובץ ג'סון, אתה יודע למה אני מתכוון.

00:05:26.720 --> 00:05:28.760
זה פונקציונלי, אבל זה לא נעים לקריאה.

00:05:28.880 --> 00:05:32.280
תבניות ARM עדיין בשימוש נרחב, במיוחד בסביבות ארגוניות.

00:05:32.280 --> 00:05:37.820
חברות גדולות השקיעו שנים בבניית ספריות התבניות שלהן, והן לא עומדות לזרוק את העבודה הזו לפח.

00:05:37.940 --> 00:05:42.120
אבל אם אתה מתחיל, להסתכל על תבנית ARM בפעם הראשונה יכול להיות מאיים.

00:05:42.380 --> 00:05:43.220
זה מילולי מדי.

00:05:43.400 --> 00:05:44.240
זה קל לשבירה.

00:05:44.380 --> 00:05:46.360
פסיק אחד חסר וכל העסק נכשל.

00:05:46.520 --> 00:05:48.260
לכתוב אחד כזה ביד זה כואב.

00:05:48.400 --> 00:05:51.280
מייקרוסופט זיהתה את הבעיה הזו, אז הם בנו את בייספ.

00:05:51.460 --> 00:05:55.060
בייספ היא התשובה של מייקרוסופט לכך שתבניות ARM מסובכות מדי.

00:05:55.060 --> 00:06:00.100
זו שפה חדשה יותר שמתכמפלט לתבניות ARM מאחורי הקלעים, אבל התחביר הרבה יותר נקי.

00:06:00.260 --> 00:06:01.440
זה נראה כמו קוד אמיתי.

00:06:01.640 --> 00:06:04.680
אתה כותב משהו כמו Resource My VM Microsoft.

00:06:05.720 --> 00:06:09.540
Compute Virtual Machines במקום עמודים של ג'ייסן מקונן.

00:06:10.580 --> 00:06:12.660
זה תוכנן קודם כל עבור בני אדם.

00:06:12.820 --> 00:06:15.820
כעת, ישנה אפשרות נוספת שתשמע עליה, טראפורם.

00:06:15.960 --> 00:06:19.920
טראפורם הוא כלי של חברה בשם HashiCorp, והוא עובד עם Azure ועננים אחרים.

00:06:19.920 --> 00:06:26.180
אם עליך לנהל תשתית ב-AWS, Google Cloud ו-Azure בבת אחת, טראפורם הוא הבחירה הטובה ביותר.

00:06:26.280 --> 00:06:28.740
הוא נייד יותר, אך לניידות הזו יש מחיר.

00:06:28.880 --> 00:06:31.680
טראפורם מוסיף שכבת הפשטה בינך לבין Azure.

00:06:31.900 --> 00:06:36.320
עליך ללמוד את השפה של טראפורם, HCL, מעבר להבנת Azure עצמה.

00:06:36.480 --> 00:06:38.820
הוא עוצמתי, אך הוא מביא איתו מורכבות משלו.

00:06:38.920 --> 00:06:40.400
אז במי כדאי למתחיל לבחור?

00:06:40.560 --> 00:06:42.860
אם אתה עובד רק באז'ר, התחל עם בייספ.

00:06:43.000 --> 00:06:44.820
הסיבה פשוטה, אינטגרציה טבעית.

00:06:44.820 --> 00:06:47.280
בייספ נבנה על ידי מייקרוסופט במיוחד עבור Azure.

00:06:47.480 --> 00:06:48.720
יש לו פחות חלקים נעים.

00:06:48.880 --> 00:06:50.740
הוא מקבל תמיכה מלאה ממייקרוסופט.

00:06:50.820 --> 00:06:54.040
ומכיוון שהוא מתכמפל ל-Arm Templates, אתה לא נעול על שום דבר.

00:06:54.180 --> 00:06:57.440
תמיד תוכל לעבור ל-Arm Templates גולמיים מאוחר יותר אם תצטרך.

00:06:57.660 --> 00:07:00.940
בייספ הוא המסלול הפשוט ביותר למי שרק רוצה להתחיל.

00:07:01.100 --> 00:07:02.840
כך הכלים האלה עובדים בפועל.

00:07:02.980 --> 00:07:06.340
אתה כותב קובץ, קובץ בייספ, תבנית ARM, מה שתבחר.

00:07:06.480 --> 00:07:08.020
לאחר מכן אתה מריץ פקודה.

00:07:08.020 --> 00:07:11.220
עבור בייספ, הפקודה היא As Deployment Group Create.

00:07:11.420 --> 00:07:16.720
Azure קורא את הקובץ שלך, משווה אותו למה שקיים, ובונה את מה שחסר או משנה את מה ששונה.

00:07:16.880 --> 00:07:19.720
אתה לא צריך להגיד לאזר באיזה סדר לבצע את הדברים.

00:07:19.920 --> 00:07:22.720
הוא מבין זאת בעצמו, וכאן זה נהיה באמת מעניין.

00:07:22.880 --> 00:07:27.100
אתה יכול לחבר את זה לצינור C, CD, אינטגרציה רציפה ופריסה רציפה.

00:07:27.240 --> 00:07:30.200
זה אומר שבכל פעם שאתה דוחף שינוי למאגר הקוד שלך,

00:07:30.420 --> 00:07:33.680
Azure מריץ אוטומטית את קובץ ה-ISC ומעדכן את התשתית שלך.

00:07:33.680 --> 00:07:38.780
ללא שלבים ידניים, ללא כניסה לפורטל, רק שינויי קוד שזורמים לייצור באופן אוטומטי.

00:07:38.880 --> 00:07:41.140
אז יש לך קובץ שמתאר את התשתית שלך.

00:07:41.280 --> 00:07:43.240
אתה יכול להריץ אותו ולקבל תוצאה עקבית.

00:07:43.380 --> 00:07:45.920
אתה יכול אפילו להפוך את כל התהליך לאוטומטי בעזרת פייפליין.

00:07:46.040 --> 00:07:47.180
אבל מה זה באמת פותח?

00:07:47.320 --> 00:07:49.140
כאן הדברים נהיים עוצמתיים באמת.

00:07:49.340 --> 00:07:51.860
מה בקרת גרסאות עושה עבור סביבת האז'ר שלך?

00:07:52.020 --> 00:07:54.040
הנה הדבר שאנשים לא מדברים עליו מספיק.

00:07:54.240 --> 00:07:57.160
כוח העל האמיתי של ISC אינו פורמט התבנית עצמו.

00:07:57.160 --> 00:07:59.220
זה לא בייספ מול ARM מול טראפורם.

00:07:59.340 --> 00:08:01.480
כוח העל האמיתי הוא בקרת גרסאות.

00:08:01.620 --> 00:08:05.860
כשאתה מאחסן את קבצי ה-ISC שלך במאגר כמו GitHub או Azure Repose,

00:08:06.100 --> 00:08:07.600
כל שינוי הופך לניתן למעקב.

00:08:07.740 --> 00:08:09.840
מי שינה מה? מתי שינו זאת ולמה?

00:08:09.960 --> 00:08:14.160
אתם מקבלים היסטוריה מלאה של כל שינוי בתשתית שלכם מהיום הראשון.

00:08:14.320 --> 00:08:16.060
וזה אומר שניתן לבצע שחזור.

00:08:16.220 --> 00:08:19.120
אם פריסה גורמת לתקלה, לא צריך לנחש מה ישתבש.

00:08:19.300 --> 00:08:22.500
לא צריך לחפור ביומני הביקורת של הפורטל בתקווה למצוא תשובה.

00:08:22.500 --> 00:08:26.440
פשוט חוזרים לגרסה התקינה האחרונה של קובץ ה-ISC ומבצעים פריסה מחדש.

00:08:26.540 --> 00:08:27.520
הבעיה נעלמת.

00:08:27.700 --> 00:08:30.180
זה דבר שפשוט אי אפשר לעשות בלחיצות אכבר.

00:08:30.400 --> 00:08:32.780
זה גם אומר שהסביבות שלכם נשארות עקביות.

00:08:32.940 --> 00:08:35.640
פיתוח, בדיקות וייצור מגיעים כולם מאותם קבצים.

00:08:35.820 --> 00:08:39.040
לא קבצים דומים ולא קבצים שהתחילו זהים אך השתנו עם הזמן.

00:08:39.220 --> 00:08:40.300
אותם קבצים בדיוק.

00:08:40.460 --> 00:08:42.560
אתם פורסים את הפיתוח מענף המן שלכם.

00:08:42.560 --> 00:08:46.040
כשאתם מוכנים לבדיקות, אתם פורסים את אותם קבצים למנוי הבדיקות.

00:08:46.180 --> 00:08:49.340
כשאתם מוכנים לייצור, אתם פורסים שוב את אותם הקבצים.

00:08:49.520 --> 00:08:53.100
כל סביבה זהה לאחרת כי כל סביבה נבנתה מאותה תוכנית.

00:08:53.280 --> 00:08:57.660
ומכיוון שהקבצים האלו נמצאים במאגר, אפשר לעשות סקירות קוד לתשתית.

00:08:57.800 --> 00:09:01.860
לפני שמי שהוא פורס שינוי, חבר צוות אחר חייב לבדוק ולאשר אותו.

00:09:02.040 --> 00:09:05.060
זה עוצר טעויות לפני שהן אי פעם מגיעות לסביבה שלכם.

00:09:05.060 --> 00:09:09.740
זהו אותו תהליך שמפתחי תוכנה משתמשים בו לקוד אפליקציה, מיושם על הגדרות האז'ר שלכם.

00:09:09.860 --> 00:09:11.300
הנה דוגמה מהעולם האמיתי.

00:09:11.500 --> 00:09:14.280
מי שהוא בצוות שלכם פותח בטעות חשבון יחסון לציבור.

00:09:14.460 --> 00:09:19.220
בלי ISC, אולי לא תשימו לב עד שיגיע החשבון או שמי שהוא יגיד לכם שהנתונים שלכם חשופים.

00:09:19.360 --> 00:09:21.680
עם ISC, השינוי הזה גלוי במאגר.

00:09:21.800 --> 00:09:22.900
הוא עובר סקירת קוד.

00:09:23.100 --> 00:09:26.480
מי שהוא מבחין בו ואומר, היי, חשבון היחסון הזה לא אמור להיות ציבורי.

00:09:26.480 --> 00:09:28.760
השינוי נחסם לפני שהוא מגיע לסביבת הייצור.

00:09:28.920 --> 00:09:31.440
ואם הוא איך שהוא מצליח לעבור, אפשר לשחזר אותו תוך שניות.

00:09:31.620 --> 00:09:33.920
אפשר אפילו להשתמש בהסתרטגיות של ענפים, ברנצ'ים.

00:09:34.080 --> 00:09:35.600
רוצים להתנסות בתצורה חדשה?

00:09:35.740 --> 00:09:39.360
צרו ענף נפרד, ביצעו את השינויים, פרסו לסביבת בדיקות וראו אם זה עובד.

00:09:39.500 --> 00:09:41.600
אם כן, ביצעו מזוג חזרה לענף הראשי.

00:09:41.720 --> 00:09:44.040
אם לא, מחכו את הענף ונסו משהו אחר.

00:09:44.040 --> 00:09:47.900
סביבת הייצור שלכם לעולם לא תיפגע עד שתהיו בטוחים שהשינוי בטוח.

00:09:47.900 --> 00:09:52.300
עקביות זה נהדר, אבל ISE גם הופך את הגדרות האז'ר שלכם למאובטחות יותר.

00:09:52.500 --> 00:09:55.880
וזה משנה אם יש לכם אדם אחד שמנהל הקול או צוות שלם.

00:09:56.360 --> 00:09:58.340
הבטחה לפי תכנון לא במקרה.

00:09:58.520 --> 00:10:00.380
הנה משהו שמפתיע אנשים רבים.

00:10:00.600 --> 00:10:04.020
כשמשתמשים ב-ISE, הבטחה היא לא משהו שמוסיפים אחר כך.

00:10:04.160 --> 00:10:06.040
היא מוטמעת בתבנית כבר מההתחלה.

00:10:06.040 --> 00:10:10.600
במקום לזכור להפעיל הצפנה בכל חשבון נחסון חדש, זה כבר כלול בקובץ שלך.

00:10:10.600 --> 00:10:16.180
במקום לקוות שמישהו הגדיר נכון את חוקי חומת האש, החוקים כתובים ונאחפים בכל פעם מחדש.

00:10:16.320 --> 00:10:18.500
לרעיון הזה יש שם מדיניות כקוד.

00:10:18.640 --> 00:10:22.000
אתה מטמיע את חוקי האבטחה שלך ישירות בתוך תהליך הפריסה.

00:10:22.100 --> 00:10:29.740
כך, בכל פעם שמישהו מנסה לפרוס חשבון נחסון, הצינור בודק ש-HTTPS מופעל, שהעצפנה דלוקה ושגישה ציבורית חסומה.

00:10:29.740 --> 00:10:32.720
אם התבנית לא עומדת בחוקים האלה, הפריסה נכשלת.

00:10:32.860 --> 00:10:35.840
ההגדרה הלא מאובטחת לעולם לא תגיע לסביבה שלך.

00:10:35.980 --> 00:10:37.360
תחשוב על מה שזה מחליף.

00:10:37.500 --> 00:10:43.400
עשרות בדיקות ידניות, מישהו שזוכר לסמן את הטבע הנכונה, מישהו אחר שבודק את הטבעות האלה מאוחר יותר.

00:10:43.620 --> 00:10:44.500
כל זה נעלם.

00:10:44.660 --> 00:10:50.600
תבנית מאובטחת אחת, סט מדיניות אחד, וכל פריסה עומדת אוטומטית בקו הבסיס הביטחוני שלך.

00:10:50.740 --> 00:10:53.580
אבל הנה החלק המעניין באמת, התאוששות מאסון.

00:10:53.580 --> 00:10:56.980
הקובץ שמתאר את התשתית שלך יכול לבנות אותה מחדש בכל מקום.

00:10:56.980 --> 00:11:01.980
אם תוקף פוגע בסביבה שלך, אתה לא צריך לבזבז ימים בי להבין מה הם שינו ואיך לתקן את זה.

00:11:02.100 --> 00:11:03.160
אתה מפרק את הכל.

00:11:03.320 --> 00:11:05.200
אתה פורס מחדש מקובץ העייק שלך.

00:11:05.340 --> 00:11:07.260
הסביבה הנקיע שלך חוזרת תוך דקות.

00:11:07.440 --> 00:11:09.700
זה בלתי אפשרי כשהתשתית שלך נבנתה ידנית.

00:11:09.860 --> 00:11:12.760
ומכיוון שהכל נמצא בבקרת גרסאות, יש לך הנתיב ביקורת.

00:11:12.760 --> 00:11:14.640
כל שינוי בתשתית שלך מתועד.

00:11:14.740 --> 00:11:15.460
מי ביצע אותו?

00:11:15.640 --> 00:11:16.380
מתי ולמה?

00:11:16.380 --> 00:11:19.840
זוהי הוכחת תאימות מבלי שאף אחד יצטרך למלא גיליון אלקטרוני.

00:11:19.960 --> 00:11:23.540
עבור צוותים קטנים ללא צוות הבטחה יהודי, זה מכפיל כוח.

00:11:23.720 --> 00:11:27.720
אתה מקבל שיטות הבטחה ברמה ארגונית בלי לזכור צוות הבטחה ארגוני.

00:11:27.920 --> 00:11:31.260
זה נשמע מצוין על הנייר, אבל להתחיל יכול להרגיש מציף.

00:11:31.380 --> 00:11:33.820
תן לי לתת לך מסלול ריאלי להתקדם בו.

00:11:33.820 --> 00:11:35.640
איך להתחיל בלי לשבור שום דבר?

00:11:35.800 --> 00:11:38.100
כלל ראשון, אל תתחיל עם סביבת הייצור.

00:11:38.240 --> 00:11:39.740
אני לא יכול להדגיש זאת מספיק.

00:11:39.740 --> 00:11:42.080
ISC זה כלי עוצמתי, אבל הוא גם חדש.

00:11:42.260 --> 00:11:43.220
אתה תעשה טעויות.

00:11:43.400 --> 00:11:45.260
תעשה אותן במקום שבו זה לא משנה.

00:11:45.440 --> 00:11:47.660
בחר חלק קטן מהסביבה שלך באז'ר,

00:11:47.880 --> 00:11:51.000
קבוצת משאבים עם מכונה וירטואלית אחת או חשבון נחסון,

00:11:51.060 --> 00:11:53.620
משהו פשוט שכבר פועל, משהו שאתה יודע שעובד.

00:11:53.740 --> 00:11:54.420
הנה הטריק.

00:11:54.420 --> 00:11:58.520
פורטל אז'ור יכול למעשה ליצור תבניות ARM מהמשאבים הקיימים שלך.

00:11:58.640 --> 00:12:01.460
אתה נכנס לקבוצת המשאבים, לוחץ על ייצוא תבנית,

00:12:01.460 --> 00:12:04.960
ו-Azure נותנת לך את קובץ הג'סון שמתאר הכל בקבוצה.

00:12:05.120 --> 00:12:05.920
זה לא מושלם.

00:12:06.080 --> 00:12:08.960
התבנית המיוצאת כוללת לעיתים דברים שאתה לא צריך,

00:12:09.160 --> 00:12:10.220
אבל זו נקודת התחלה.

00:12:10.440 --> 00:12:13.200
אתה לוקח משהו שבנית ידנית וממיר אותו לקוד.

00:12:13.400 --> 00:12:16.400
זו גישת ההנדסה לאחור והיא הדרך המהירה ביותר ללמוד.

00:12:16.400 --> 00:12:19.040
התחילו עם בייספ ועם הכלים החינמיים של Azure.

00:12:19.220 --> 00:12:22.560
למייקרוסופט יש תוסף VS Code עבור בייספ שמעניק לכם הדגשת תחביר,

00:12:22.560 --> 00:12:25.060
השלמה אוטומטית ותצוגה מקדימה חזותית של מה שאתם בונים.

00:12:25.260 --> 00:12:29.340
ניתן לראות את הרשת הווירטואלית והרשתות המשנה שלכם כתרשים לפני שפורסים דבר מה.

00:12:29.500 --> 00:12:32.880
זה הופך את ההבנה של מה שהקוד שלכם עושה בפועל להרבה יותר פשוטה.

00:12:33.020 --> 00:12:34.620
השתמשו במנוי נפרד לבדיקות.

00:12:34.800 --> 00:12:38.020
לרוב המנויים של Azure יש מגבלות הוצאה וזיקויים בחינם.

00:12:38.020 --> 00:12:42.600
צרו מנוי בדיקה, פרוסו שם את ה-ISC שלכם, שברו דברים, תקנו אותם, תלמדו.

00:12:42.720 --> 00:12:46.080
כשתרגישו בטוחים, עברו למנוי שאינו מיועד לייצור Non-Production.

00:12:46.280 --> 00:12:47.800
סביבת הייצור מגיעה בסוף.

00:12:47.940 --> 00:12:49.680
הנה החלק שעשוי להפתיע אתכם.

00:12:49.840 --> 00:12:52.300
אתם לא צריכים להיות מהנדסי תוכנה כדי לעשות את זה.

00:12:52.480 --> 00:12:54.560
זווית הראייה של מפתח אזרחי היא אמיתית.

00:12:54.740 --> 00:12:58.640
בייספ, תוכנן עבור אנשים שמנהלים תשתית Azure, לא עבור מתכנתים מקצועיים.

00:12:58.640 --> 00:13:01.920
הוא קרי, יש לו פחות, תקסים, מספות תכנות מסורתיות.

00:13:02.060 --> 00:13:04.060
הוא ממוקד באז'ר ולא בשום דבר אחר.

00:13:04.180 --> 00:13:07.840
אם אתם יכולים להבין מהי מכונה וירטואלית, תוכלו ללמוד לתאר אחת בביספ.

00:13:07.940 --> 00:13:11.940
הפרויקט המעשי הראשון שלכם, אוטומציה של פירוק ובנייה מחדש של סביבת הפיתוח.

00:13:12.140 --> 00:13:17.280
כתבו קובץ בייספ שיוצר את סביבת הפיתוח שלכם, פרוסו אותו, השתמשו בו, ואז פירקו אותו ופרוסו שוב.

00:13:17.440 --> 00:13:20.000
עשו זאת כמה פעמים עד שהתהליך ירגיש שגרתי.

00:13:20.000 --> 00:13:23.800
התרגיל הזה לבדו ילמד אתכם יותר על ISC מכל מדריך אחר.

00:13:23.920 --> 00:13:25.600
כמה עצות מפוצות למתחילים.

00:13:25.600 --> 00:13:27.700
ביצעו קומית מוקדם ולעיתים קרובות.

00:13:27.840 --> 00:13:30.960
בכל פעם שחלק מהתבנית שלכם עובד, שימרו אותו במאגר שלכם.

00:13:31.100 --> 00:13:33.280
זה נותן לכם נקודות ביקורת שניתן לחזור עליהן.

00:13:33.380 --> 00:13:35.980
ותמיד הריצו את פקודת התצוגה המקדימה לפני הפריסה.

00:13:36.080 --> 00:13:37.780
בביספ, זו הפקודה What If.

00:13:37.920 --> 00:13:40.900
היא מראה לכם בדיוק מה ישתנה לפני שמשהו באמת משתנה.

00:13:40.900 --> 00:13:45.920
בלי הפתעות, גם עם הכוונות הטובות ביותר, יש כמה מלכודות שמתחילים נופלים עליהן.

00:13:46.040 --> 00:13:48.580
תנו לי לחסוך לכם כמה לילות של ניפוי שגיאות.

00:13:55.600 --> 00:13:59.420
אם אתם צריכים לגרום לתבנית לעבוד, אז אתם זורקים את סיסמת בסיס הנתונים ישר לתוך הקובץ.

00:13:59.580 --> 00:14:01.120
זה עובד, אתם ממשיכים הלאה.

00:14:01.160 --> 00:14:05.000
ועכשיו הסיסמה שלכם יושבת במאגר ה-ISC שלכם וחשופה לכל מי שיש לו גישה.

00:14:05.140 --> 00:14:06.440
ברור בדיעבד, נכון.

00:14:06.580 --> 00:14:09.780
אבל זה קל מאוד לעשות כשאתם ממוקדים רק בלהפעיל משהו.

00:14:09.920 --> 00:14:11.540
הפתרון הוא Azure Key Vault.

00:14:11.540 --> 00:14:16.380
גם בייספ וגם תבניות ARM יכולים למשוך סודות ישירות מ-Key Vault בזמן הפריסה.

00:14:16.380 --> 00:14:20.720
הקובץ שלכם מציין משוך את הסיסמה מהכספת הזו במקום להכיל את הסיסמה עצמה.

00:14:20.860 --> 00:14:22.780
הסוד לעולם לא נוגע במאגר שלכם.

00:14:22.940 --> 00:14:26.880
לעולם אל תכניס סיסמאות, מחרוזות התחברות או מפתחות API לקבצי ה-ISC שלך.

00:14:27.040 --> 00:14:29.140
השתמש ב-Key Vault בכל פעם מחדש.

00:14:29.280 --> 00:14:32.600
טעות מספר 2 היא להתייחס ל-ISC כאל סקריפט חד פעמי.

00:14:32.600 --> 00:14:36.120
אתה כותב תבנית, פורס אותה, היא עובדת, ואתה לעולם לא מסתכל עליה שוב.

00:14:36.260 --> 00:14:38.160
שישה חודשים אחר כך, משהו נשבר.

00:14:38.160 --> 00:14:41.000
אתה פותח את הקובץ ואין לך מושג מחצי ממנו עושה.

00:14:41.100 --> 00:14:43.720
הפרמטר הזה שנקרא param1, אין לי מושג.

00:14:43.840 --> 00:14:46.320
המשאב הזה עם השם המוצפן, אין לי מושג.

00:14:46.600 --> 00:14:50.360
כתוב את ה-ISC שלך כאילו מישהו אחר יתחזק אותו בעוד חצי שנה,

00:14:50.560 --> 00:14:53.460
כי המישהו האחר הזה הוא כנראה אתה, ואתה תשכח הכל.

00:14:53.460 --> 00:14:56.360
אוסף הערות, השתמש בשמות תיאוריים במקום בקיצורים,

00:14:56.520 --> 00:14:58.680
ושמור על קבצים קטנים וממוקדים בדבר אחד.

00:14:58.680 --> 00:15:02.100
קובץ בייספ, שיוצר רשת וירטואלית, צריך לעסוק ברשתות וירטואליות,

00:15:02.300 --> 00:15:03.220
לא בכל מרכז הנתונים.

00:15:03.400 --> 00:15:06.540
טעות מספר 3 היא לעקוף את הפייפליין עבור תיקונים מהירים.

00:15:06.680 --> 00:15:09.540
הפורטל תמיד מפתה, אתה צריך לשנות הגדרה אחת.

00:15:09.700 --> 00:15:13.080
ייקח 5 דקות לערוך את התבנית, לבצע קומית, ולפרוס דרך הפייפליין.

00:15:13.080 --> 00:15:17.000
או שאתה יכול פשוט להתחבר לפורטל, ללחוץ 3 פעמים, ולסיים תוך 30 שניות.

00:15:17.140 --> 00:15:19.260
השינוי המהיר הזה יוצר סחיפה, דריפט.

00:15:19.260 --> 00:15:21.980
הקוד שלך אומר דבר אחד, המציאות אומרת אחרת.

00:15:22.140 --> 00:15:26.160
בפעם הבאה שתפרוס מהתבנית שלך, Azure תנסה לבטל את השינוי הידני שלך,

00:15:26.360 --> 00:15:32.020
או גרוע מכך, היא לא תבחין בזכיפה והסביבה שלך תתפצל לאיתה עד שסביבת הייצור תתנהג אחרת לגמרי מסביבת הפיתוח.

00:15:32.220 --> 00:15:34.560
המשמעת פשוטה, בצע את השינוי בקוד.

00:15:34.560 --> 00:15:37.520
פרוס דרך הפייפליין, גם אם זה לוקח עוד 5 דקות.

00:15:37.640 --> 00:15:40.580
5 הדקות האלה יחסכו לך השעות של ניפוי שגיאות מאוחר יותר.

00:15:40.580 --> 00:15:44.040
טיפ בונוס אחד, תמיד הרץ את פקודת התצוגה המקדימה לפני החלת שינויים.

00:15:44.220 --> 00:15:45.920
בבי סאפ, זה מה שנקרא what if.

00:15:46.100 --> 00:15:48.640
זה מראה לך בדיוק מה ייווצר, ישונה או יושמד.

00:15:48.800 --> 00:15:49.460
בלי הפתעות.

00:15:49.620 --> 00:15:51.360
אתה רואה את ההשפעה לפני שהיא קוראת.

00:15:51.560 --> 00:15:52.840
זה IAC בשפה פשוטה.

00:15:53.000 --> 00:15:53.620
בלי ז'רגון.

00:15:53.840 --> 00:15:54.840
בלי קידומי מחירות.

00:15:54.840 --> 00:15:57.660
רק כלי פרקטי שהופך את החיים שלך באז'ר לקלים יותר.

00:15:57.780 --> 00:15:59.520
הדבר האחד שכדאי לנסות השבוע.

00:15:59.660 --> 00:16:00.880
אז, הנה מה שכיסינו.

00:16:00.880 --> 00:16:04.600
IAC הופך את תשתית האז'ר שלך לתוכנית עבודה מבוקרת גרסאות,

00:16:04.740 --> 00:16:05.680
אדירה ומאובטחת.

00:16:05.780 --> 00:16:09.000
קובץ אחד שמתאר הכל, שנפרס באותה דרך בכל פעם.

00:16:09.180 --> 00:16:12.740
האתגר שלך השבוע, ייצא משאב אז'ר קיים אחד כתבנית ARM.

00:16:12.920 --> 00:16:14.240
פתח אותו ב-VS Code.

00:16:14.240 --> 00:16:16.160
בדוק אם אתה יכול להבין מה הוא עושה.

00:16:16.260 --> 00:16:19.580
התרגיל הבודד הזה ילמד אותך יותר מכל הסבר שאוכל לתת.

00:16:19.720 --> 00:16:23.980
בהמשך הסדרה הזו, נעבור על כתיבת קובץ הבספ הראשון שלך צעד אחר צעד.

00:16:23.980 --> 00:16:29.440
הרשם בפלטפורמת הפודקסטים המועדפת עליך ושתף את זה עם חבר לצוות שעדיין מקליק דרך הפורטל.
