WEBVTT

00:00:00.000 --> 00:00:03.080
ברוכים הבאים לפרק נוסף של Microsoft Knowledge Nuggets על M365.

00:00:03.220 --> 00:00:05.020
אני המערך שלכם מרקו פיטרז.

00:00:05.120 --> 00:00:07.180
הנושא של היום הוא נושא שכמעט כולם שמעו עליו,

00:00:07.320 --> 00:00:09.800
אך מעטים באמת יודעים להסביר מה זה בעצם Azure DevOps.

00:00:10.140 --> 00:00:12.600
האם זה רק כליל עם מפתחים או שזה משהו גדול בהרבה?

00:00:12.760 --> 00:00:14.180
אז אתם רוצים לבנות תוכנה.

00:00:14.360 --> 00:00:16.360
אולי זה אתר אינטרנט, אולי אפליקציה לנייד,

00:00:16.600 --> 00:00:18.520
אולי משהו שיעזור לחברה שלכם לפעול טוב יותר.

00:00:18.720 --> 00:00:20.280
ואתם מתיישבים לתכנן את זה.

00:00:20.420 --> 00:00:22.420
אתם צריכים כליל למעקב אחר משימות,

00:00:22.420 --> 00:00:24.640
מקום לשמור קוד, דרך לבדוק את העבודה,

00:00:24.900 --> 00:00:26.320
וצורך להפיץ את זה לאנשים.

00:00:26.500 --> 00:00:28.880
לפני שתשימו לב, תמצאו את עצמכם להטוטנים

00:00:28.880 --> 00:00:30.920
בין חמישה כלים שונים מחמש חברות שונות.

00:00:31.020 --> 00:00:32.740
אחד לניהול משימות, אחר לקוד,

00:00:32.900 --> 00:00:34.640
שלישי לבדיקות, רביעי לפריסה,

00:00:34.820 --> 00:00:36.660
ואף אחד מהם לא מדבר עם השני.

00:00:36.820 --> 00:00:37.480
זה בלגן.

00:00:37.660 --> 00:00:39.340
מייקרוסופט הסתכלה על הקאוס הזה

00:00:39.340 --> 00:00:40.840
ובנתה משהו כדי לתקן אותו.

00:00:40.840 --> 00:00:42.120
קוראים לזה Azure DevOps,

00:00:42.540 --> 00:00:44.340
וזה לא סתם עוד כלי שמוסיפים להרמה.

00:00:44.340 --> 00:00:46.020
זו פלטפורמה אחת מחוברת

00:00:46.020 --> 00:00:48.580
שמטפלת בכל מחזור החיים של פיתוח התוכנה,

00:00:48.820 --> 00:00:50.900
תכנון, כידוד, בדיקות ופריסה,

00:00:51.040 --> 00:00:52.040
הכל במקום אחד.

00:00:52.200 --> 00:00:53.140
בסוף הפרק הזה,

00:00:53.340 --> 00:00:55.200
תבינו מה זה Azure DevOps באמת,

00:00:55.460 --> 00:00:57.840
ואיך חמשת הרכיבים המרכזיים משתלבים יחד.

00:00:58.000 --> 00:01:00.020
חישבו על זה כמו על בניין משרדי מודרני.

00:01:00.180 --> 00:01:02.820
Word ו-Excel הם חדרים נפרדים שבהם אתם עובדים.

00:01:02.820 --> 00:01:06.640
Microsoft 365 הוא כל הבניין עם מערכות ההבטחה והטיוק.

00:01:06.840 --> 00:01:08.520
Azure DevOps הוא אותו רעיון.

00:01:08.720 --> 00:01:10.480
זה כל הבניין עבור פיתוח תוכנה,

00:01:10.720 --> 00:01:11.680
לא רק חדר בודד.

00:01:11.680 --> 00:01:13.520
אז, מה זה בדיוק Azure DevOps?

00:01:13.920 --> 00:01:15.600
הנה ההגדרה הפשוטה ביותר.

00:01:15.740 --> 00:01:19.220
Azure DevOps היא פלטפורמה מחוברת לכל מחזור החיים של פיתוח התוכנה.

00:01:19.400 --> 00:01:21.300
זה נשמע מורכב, אז בואו נפרק את זה.

00:01:21.460 --> 00:01:23.540
לפני 20 שנה, אם רציתם לבנות תוכנה,

00:01:23.780 --> 00:01:25.500
הייתם קונים מוצרים נפרדים לכל דבר.

00:01:25.680 --> 00:01:27.180
כלי אחד למעקב אחר בגים,

00:01:27.280 --> 00:01:28.340
אחר לניהול קוד מקור,

00:01:28.340 --> 00:01:29.880
שלישי לאוטומציה של בנייה,

00:01:30.060 --> 00:01:30.820
רביעי לבדיקות,

00:01:30.960 --> 00:01:31.800
חמישי לפריסה,

00:01:32.000 --> 00:01:35.040
והייתם מבלים חצי מהזמן רק בניסיון לגרום להם לשתף נתונים.

00:01:35.040 --> 00:01:37.280
מייקרוסופט בחנה את המורכבות הזו וחשבה,

00:01:37.500 --> 00:01:40.020
מה אם כל השירותים האלה יעבדו יחד תחת קורת גג אחת.

00:01:40.100 --> 00:01:41.380
אז הם בנו את Azure DevOps.

00:01:41.760 --> 00:01:42.520
זה לא כלי אחד,

00:01:42.700 --> 00:01:44.200
אלא חמישה שירותים שעובדים יחד.

00:01:44.340 --> 00:01:45.300
Azure Boards לתכנון,

00:01:45.440 --> 00:01:46.360
Azure Repose לקוד,

00:01:46.500 --> 00:01:47.760
Azure Pipelines לאוטומציה,

00:01:48.000 --> 00:01:49.080
Azure Test Plans לאיכות,

00:01:49.260 --> 00:01:50.660
ו-Azure Artifacts לשיתוף חבילות.

00:01:50.660 --> 00:01:51.880
כל אחד עושה את עבודתו,

00:01:52.020 --> 00:01:53.060
אך כולם מחוברים זה לזה.

00:01:53.180 --> 00:01:55.200
בואו נחזור לאנלוגיה של בניין המשרדים.

00:01:55.340 --> 00:01:57.160
דלפק הקבלה מנהל את מי שנכנס.

00:02:05.040 --> 00:02:06.540
צוות האבטחה מגן על הבניין.

00:02:06.720 --> 00:02:08.480
אלו הם בקרות הגישה והמדיניות שלך.

00:02:08.620 --> 00:02:09.520
לכל אחד יש תפקיד,

00:02:09.660 --> 00:02:10.940
אבל כולם תחת קורת גג אחת.

00:02:11.060 --> 00:02:11.900
הם משתפים מידע.

00:02:12.020 --> 00:02:12.920
הם עובדים יחד.

00:02:13.080 --> 00:02:13.860
זה כל העניין.

00:02:14.040 --> 00:02:15.620
והנה החלק הכי טוב למתחילים.

00:02:15.780 --> 00:02:17.500
ל-Azure DevOps יש מסלול חינמי.

00:02:17.620 --> 00:02:18.400
ניתן ליצור חשבון,

00:02:18.560 --> 00:02:20.860
להתחיל פרויקט ולהשתמש בתכונות הליבה ללא תשלום.

00:02:20.860 --> 00:02:22.920
חמישה משתמשים בחינם מקבלים גישה מלאה.

00:02:23.020 --> 00:02:25.680
מספר בלתי מוגבל של בעלי עניין מקבלים גישה מוגבלת בחינם.

00:02:25.820 --> 00:02:26.060
אז,

00:02:26.200 --> 00:02:28.780
ניתן להתחיל ממש היום ללא עלות ולבדוק אם זה מתאים לך.

00:02:28.920 --> 00:02:30.240
אין צורך בחרטיס אשראי.

00:02:30.360 --> 00:02:31.340
ללא שיחות מחירה.

00:02:31.440 --> 00:02:34.200
פשוט ייכנסו dev.azure.com וצרו חשבון.

00:02:34.360 --> 00:02:36.640
אז בואו נעבור על חמשת השירותים אחד אחד.

00:02:36.840 --> 00:02:38.980
החל מהמקום שבו העבודה שלך מתחילה.

00:02:38.980 --> 00:02:39.780
Azure Boards,

00:02:39.960 --> 00:02:41.680
מרכז הפיקוד של הפרויקט שלך.

00:02:41.780 --> 00:02:44.720
Azure Boards הוא המקום שבו מתכננים ועוקבים אחר העבודה.

00:02:44.880 --> 00:02:47.140
חשוב על זה כמרכז הפיקוד של הפרויקט שלך.

00:02:47.280 --> 00:02:50.460
אם השתמשת פעם בפתקיות דביקות על קיר כדי לעקוב אחר משימות,

00:02:50.680 --> 00:02:51.780
כבר הבנת את הרעיון.

00:02:51.940 --> 00:02:54.420
אבל במקום פתקיות פיזיות שנופלות והולכות לאיבוד,

00:02:54.660 --> 00:02:58.420
Boards נותן לוח כנבן דיגיטלי שכולם בצוות יכולים לראות ולעדכן בזמן אמת.

00:02:58.560 --> 00:02:59.440
בואו נפרק את זה.

00:02:59.440 --> 00:03:01.020
מתחילים ביצירת פריטי עבודה,

00:03:01.260 --> 00:03:01.880
Work Items.

00:03:02.000 --> 00:03:04.380
פריט עבודה הוא כל דבר שצריך לעקוב אחריו.

00:03:04.540 --> 00:03:05.440
סיפור משתמש,

00:03:05.620 --> 00:03:05.980
תכונה,

00:03:06.220 --> 00:03:06.560
אפיק,

00:03:06.760 --> 00:03:07.640
משימה או בג.

00:03:07.640 --> 00:03:09.620
לכל אחד יש שדות לתיאור,

00:03:09.800 --> 00:03:10.260
עדיפות,

00:03:10.500 --> 00:03:11.880
סטטוס ולמי הוא מוקצה.

00:03:12.040 --> 00:03:14.440
אתה מארגן את פריטי העבודה הללו בבקלוג,

00:03:14.680 --> 00:03:17.060
שהוא רשימה מתועדפת של כל מה שצריך לעשות.

00:03:17.200 --> 00:03:18.760
ניתן לקבץ אותם להיררכיות.

00:03:18.960 --> 00:03:19.640
אפיקים למעלה,

00:03:19.780 --> 00:03:20.540
תכונות מתחת,

00:03:20.700 --> 00:03:23.420
סיפורי משתמש מתחת לאלו ומשימות תחת הסיפורים.

00:03:23.420 --> 00:03:25.880
זה נותן תמונה ברורה של מה בונים ולמה.

00:03:26.020 --> 00:03:27.820
לאחר מכן מתכננים ספרינטים.

00:03:28.000 --> 00:03:29.480
ספרינט הוא פרק זמן קצוב,

00:03:29.700 --> 00:03:30.740
בדרך כלל שבועיים,

00:03:30.740 --> 00:03:33.360
שבו הצוות מתחייב להשלים קבוצת פריטי עבודה.

00:03:33.580 --> 00:03:35.500
גוררים פריטים מהבקלוג לספרינט,

00:03:35.660 --> 00:03:36.760
ופתאום יש תוכנית.

00:03:36.880 --> 00:03:39.340
כולם יודעים על מה הם עובדים ומתי זה אמור להסתיים.

00:03:39.520 --> 00:03:40.480
יש לך גם שאילטות,

00:03:40.640 --> 00:03:43.520
שאילטות מאפשרות לחפש ולסנן את פריטי העבודה שלך.

00:03:43.640 --> 00:03:46.200
הראה לי את כל הבגים שהוקצו לסרה ושעדיפותם גבוהה.

00:03:46.200 --> 00:03:49.060
הראה לי את כל סיפורי המשתמש בספרינט הנוכחי שעדיין פעילים.

00:03:49.060 --> 00:03:51.800
שאילטות הן עוצמתיות כי הן הופכות את הנתונים של אחל התשובות.

00:03:51.920 --> 00:03:54.360
ניתן לשמור אותן, לשתף אותן ולהשתמש בהן כדי לבנות לוחות מכוונים,

00:03:54.500 --> 00:03:54.860
דשבורדס.

00:03:54.940 --> 00:03:56.960
ולוחות מכוונים הם המקום שבו הכל מתחבר יחד.

00:03:57.080 --> 00:03:59.920
ניתן ליצור לוחות מכוונים מותאמים אישית עם איסומונים המציגים תרשימי ניצול,

00:04:00.060 --> 00:04:01.500
מהירות, ספירת פריטי עבודה ועוד.

00:04:01.500 --> 00:04:05.480
הצוות שלכם מקבל תצוגה חיה של ההתקדמות מבלי שאף אחד יצטרך לכתוב דוח סטטוס.

00:04:05.480 --> 00:04:07.240
הרשו לי לתת לכם דוגמה מהירה.

00:04:07.380 --> 00:04:09.520
דמיינו צוות קטן שבונה אתר אינטרנט.

00:04:09.660 --> 00:04:12.300
בעל המוצר יוצר אפוס בשם פורטל לקוחות.

00:04:12.520 --> 00:04:16.420
תחתיו הם יוצרים תכונות כמו רישום משתמשים והיסטוריית הזמנות.

00:04:16.840 --> 00:04:19.980
תחת רישום משתמש הם יוצרים סיפורי משתמש כמו

00:04:19.980 --> 00:04:23.100
כלקוח אני רוצה ליצור חשבון עם האימייל שלי.

00:04:23.480 --> 00:04:26.220
תחת הסיפור הזה מפתחים יוצרים משימות.

00:04:26.780 --> 00:04:30.900
בניית תופס רישום, הגדרת אימות אימייל, כתיבת בדיקות יחידה.

00:04:31.100 --> 00:04:32.820
כל משימה משוייכת למישהו.

00:04:32.820 --> 00:04:35.280
הצוות עוקב אחר ההתקדמות בלוח קנבן.

00:04:35.440 --> 00:04:38.520
כולם יכולים לראות מה בוצע, מה בתהליך ומה הצעד הבא.

00:04:38.620 --> 00:04:41.240
עכשיו, השבו זאת לשימוש באקסל או בלוח מחיק.

00:04:41.400 --> 00:04:42.340
אקסל הוא סטטי.

00:04:42.480 --> 00:04:44.000
אתם שולחים גיליון אלקטרוני במייל,

00:04:44.140 --> 00:04:45.620
מי שהוא מעדכן אותו ושולח בחזרה,

00:04:45.840 --> 00:04:47.640
ועד שהוא מגיע עליכם הוא כבר לא מעודכן.

00:04:47.800 --> 00:04:50.580
לוח מחיק טוב יותר לסיעור מוחות, אבל אי אפשר לחפש בו.

00:04:50.660 --> 00:04:53.460
הוא לא מחובר לחלום, ואם מי שהוא מוחק משהו, זה נעלם.

00:04:53.620 --> 00:04:54.460
לוחות הם חיים.

00:04:54.460 --> 00:04:55.580
ניתן לחפש בהם.

00:04:55.700 --> 00:04:58.200
הם מחוברים לקוד שלכם, לבדיקות שלכם ולפריסות שלכם.

00:04:58.340 --> 00:05:00.860
כשמי שהוא מעדכן פרית עבודה, כולם רואים זאת באופן מיידי.

00:05:00.960 --> 00:05:02.000
אז, תכננתם את העבודה.

00:05:02.220 --> 00:05:05.220
אתם יודעים מה צריך להיבנות, אבל אתם צריכים מקום להכסן את הקוד בפועל.

00:05:05.320 --> 00:05:06.980
כאן נכנס לתמונה Azure Repos.

00:05:07.120 --> 00:05:09.360
Azure Repos, הבית הקבוע של הקוד שלכם.

00:05:09.500 --> 00:05:10.520
אז, תכננתם את העבודה.

00:05:10.740 --> 00:05:13.640
אתם יודעים מה צריך להיבנות, אבל אתם צריכים מקום להכסן את הקוד בפועל.

00:05:13.640 --> 00:05:15.440
כאן נכנס לתמונה Azure Repos.

00:05:15.440 --> 00:05:18.480
Azure Repose הוא בקרת גרסאות עבור הקוד שלכם באמצעות Git.

00:05:18.640 --> 00:05:21.620
Git הוא התקן בתעשייה, ורוב המפתחים כבר משתמשים בו.

00:05:21.720 --> 00:05:25.380
Repose נותן לכם מקום להרח את מאגרי הגיט שלכם ממש בתוך Azure DevOps.

00:05:25.740 --> 00:05:27.180
הנה אנלוגיית כתיבת הספר.

00:05:27.360 --> 00:05:29.700
דמיינו שאתם כותבים ספר עם צוות של מחברים.

00:05:29.900 --> 00:05:32.060
אתם יכולים לשלוח פרקים הלוך ושוב במייל.

00:05:32.220 --> 00:05:35.760
מי שהוא עורך את פרק 3 ושולח, מי שהוא אחר עורך שוב.

00:05:35.800 --> 00:05:40.220
ותוך זמן קצר יש לכם קבצים בשמות פרק 3 סופי ו2 גרסה אמיתית.

00:05:40.220 --> 00:05:43.140
דוק אקס, ואף אחד לא יודע מה הגרסה האמיתית.

00:05:43.260 --> 00:05:45.960
כך נראה פיתוח תוכנה לפני בקרת גרסאות.

00:05:46.120 --> 00:05:49.500
עם Git ב-Azure Repose, כולם עובדים מאותו מאגר מרכזי.

00:05:49.660 --> 00:05:51.320
אתם יוצרים ענף, ברנץ'.

00:05:51.320 --> 00:05:55.340
חישבו על זה כעל עותק משלכם של הספר, שבו אתם יכולים לבצע שינויים מבלי להשפיע על אף אחד אחר.

00:05:55.460 --> 00:05:56.900
אתם כותבים את הפרק שלכם, בודקים אותו.

00:05:57.000 --> 00:05:59.020
וכשאתם מוכנים, אתם יוצרים בקשת מזוג, pull request.

00:05:59.020 --> 00:06:02.020
זו בקשה למזג את השינויים שלכם חזרה לתוך הספר הראשי.

00:06:02.020 --> 00:06:05.360
מחברים אחרים בודקים את השינויים שלך, משאירים הערות ותופסים טעויות.

00:06:05.540 --> 00:06:09.080
ברגע שכולם מאשרים, השינויים שלך ממוזגים וההיסטוריה כולה מתועדת.

00:06:09.200 --> 00:06:11.540
אתה יכול לראות בדיוק מי שינה מה, מתי ולמה.

00:06:11.680 --> 00:06:13.480
זו הסיבה שמתחילים צריכים להתעניין בזה.

00:06:13.660 --> 00:06:16.720
אין יותר שמות קבצים מבולגנים או תהיה אם אתה עובד על הגרסה העדכני.

00:06:16.840 --> 00:06:19.060
אין יותר דריסה מקרית של עבודה של מישהו אחר.

00:06:19.060 --> 00:06:20.680
גיט מעניקה לך רשת ביטחון.

00:06:20.760 --> 00:06:23.640
אתה יכול להתנסות, לעשות טעויות ולחזור אחורה עם מה שהוא נשבר.

00:06:23.800 --> 00:06:26.420
זה כמו שיהיה כפתור, ביטול לכל הפרויקט שלך.

00:06:26.580 --> 00:06:28.340
וכאן נכנס הקשר ל-Aboards.

00:06:28.500 --> 00:06:31.980
אתה יכול לקשר את הקומיץ ובקשות המזוג ישירות לפריטי עבודה.

00:06:32.140 --> 00:06:37.420
כשמפתח מתקן בג, הוא כולל את מזהה הבג בהודעת הקומית, והוא מקושר לפריט ב-Cboards.

00:06:37.580 --> 00:06:39.640
פתאום, יש לך יכולת עקיבות מלאה.

00:06:39.640 --> 00:06:43.260
אתה יכול לראות בדיוק אילו שינויי קוד נעשו עבור כל פיצ'ר או תיקון בג.

00:06:43.380 --> 00:06:46.800
מנהלי מוצר יכולים ללחוץ על פריט עבודה ולראות את הקוד שנכתב בפועל.

00:06:46.800 --> 00:06:50.100
מפתחים יכולים להסתכל על קומית ולראות לאיזה סיפור משתמש הוא שייך.

00:06:50.220 --> 00:06:51.040
הכל מחובר.

00:06:51.160 --> 00:06:53.220
אז, הקוד שלך כעת מאוכסן ומתועד.

00:06:53.300 --> 00:06:53.860
הוא בטוח.

00:06:54.060 --> 00:06:55.000
הוא מנוהל בגרסאות.

00:06:55.160 --> 00:06:56.400
אבל, הוא רק יושב שם.

00:06:56.540 --> 00:06:57.740
איך גורמים לו באמת לרוץ?

00:06:57.880 --> 00:07:00.980
איך הופכים את הקוד הזה ליישום עובד שאנשים יכולים להשתמש בו?

00:07:01.100 --> 00:07:02.780
כאן נכנסת Azure Pipelines.

00:07:02.780 --> 00:07:05.060
Azure Pipelines, מנוע האוטומציה.

00:07:05.200 --> 00:07:09.680
Azure Pipelines הוא מנוע האוטומציה שבנה, בודק ומפיץ את הקוד שלך באופן אוטומטי.

00:07:09.680 --> 00:07:14.200
במילים פשוטות, הוא לוקח את הקוד והופך אותו ליישום רץ בלי שתצטרך לעשות זאת ידנית.

00:07:14.280 --> 00:07:15.600
תחשוב על זה כמו מאפייה.

00:07:15.780 --> 00:07:19.840
דמיין שאתה מנהל מאפייה והופך כל כיכר לחם ביד עבור כל הזמנת לקוח.

00:07:20.000 --> 00:07:21.400
ככה נראית פריסה ידנית.

00:07:21.600 --> 00:07:26.380
מי שהוא כותב קוד, אתה מעתיק אותו ידנית לשרת, מריץ ידנית את הבנייה ובודק ידנית אם זה עובד.

00:07:26.380 --> 00:07:30.400
זה איתי, מועד לטעויות, ואם יש הרבה הזמנות, אתה פשוט לא יכול לעמוד בקצב.

00:07:30.520 --> 00:07:32.180
כאן נכנסת Azure Pipelines.

00:07:32.180 --> 00:07:34.020
אתה מאוטומט את כל התהליך.

00:07:34.160 --> 00:07:38.320
אתה מגדיר אותו פעם אחת, והוא רץ אוטומטית בכל פעם שמישהו משנה את הקוד.

00:07:38.480 --> 00:07:42.300
זה נקרא CCD, אינטגרציה רציפה ומסירה רציפה.

00:07:42.420 --> 00:07:44.500
הנה מה שאינטגרציה רציפה אומרת.

00:07:44.640 --> 00:07:50.120
בכל פעם שמפתח דוחף קוד למאגר, הצינור בונה אוטומטית את היישום ומריץ בדיקות.

00:07:50.260 --> 00:07:55.240
אם מה שהוא נשבר, אתה יודע מיד, לא שבועיים אחר כך כשמישהו מנסה לפרוס, אלא ברגע האמת.

00:07:55.420 --> 00:07:58.520
המפתח מקבל התראה ומתקן את זה, והם דוחפים שוב.

00:07:58.520 --> 00:08:02.500
בגים מתגלים מוקדם כשהתיקון שלהם זול, ולא מאוחר כשהוא יקר.

00:08:02.620 --> 00:08:06.940
אספקה רציפה פירושה שקוד שנבנה ונבדק נפרס אוטומטית לסביבות שלך.

00:08:07.060 --> 00:08:14.060
תחילה לסביבת בדיקות שבה QA יכול לאמץ זאת, אחר כך לסטאגינג לבדיקות סופיות, ולבסוף לסביבת ייצור שבה המשתמשים רואים זאת.

00:08:14.180 --> 00:08:16.160
בכל שלב ניתן להטמיע אישורים מובנים.

00:08:16.340 --> 00:08:18.800
מנהל עשוי להידרש לאשר פריסה לסביבת הייצור.

00:08:18.800 --> 00:08:21.300
מוביל QA עשוי להידרש לחתום על תוצאות הבדיקות.

00:08:21.400 --> 00:08:22.760
הפייפליין מטפל בכל זה.

00:08:22.940 --> 00:08:24.500
בואו נפרק את התכונות המרכזיות.

00:08:24.680 --> 00:08:27.200
יש לך קובצי YML, שלבים, אישורים וסוכנים.

00:08:27.380 --> 00:08:30.200
YML הוא קובץ טקסט פשוט שבו מגדירים את הפייפליין.

00:08:30.340 --> 00:08:35.020
הוא נמצא במאגר שלך לצד הקוד, מה שאומר שהאייפליין מקבל גרסאות בדיוק כמו הקוד.

00:08:35.160 --> 00:08:37.240
ניתן לראות מי שינה אותו, מתי ולמה.

00:08:37.440 --> 00:08:40.200
שלבים מאפשרים לחלק את הפייפליין למקטעים לוגיים.

00:08:40.200 --> 00:08:42.000
בנייה, בדיקה, פריסה.

00:08:42.080 --> 00:08:45.760
אישורים מאפשרים לחסום פריסות כך שרק מורשים יוכלו להעלות לסביבת הייצור.

00:08:45.960 --> 00:08:48.380
סוכנים הם המכונות שמריצות בפועל את הבנייה שלך.

00:08:48.500 --> 00:08:51.800
מייקרוסופט מספק את סוכנים מאוכסנים או שאפשר להריץ סוכנים משלך.

00:08:51.940 --> 00:08:53.180
למה זה משנה למתחילים?

00:08:53.320 --> 00:08:56.600
כי פריסות ידניות הן הגורם מספר אחת לתקלות בסביבת הייצור.

00:08:56.780 --> 00:09:00.620
מי שהוא שוכח שלב, מי שהוא מעתיק קובץ לא נכון, מי שהוא פורס לסביבה הלא נכונה.

00:09:00.620 --> 00:09:02.220
פייפליינס מבטלים את כל זה.

00:09:02.360 --> 00:09:04.260
הם רצים באותה דרך בדיוק בכל פעם.

00:09:04.460 --> 00:09:06.880
בלי טעויות אנוש, בלי שלבים נשכחים, והם מהירים.

00:09:07.060 --> 00:09:11.360
צוות אחד שקראתי עליו צמצם את הפריסות הידניות משעות ארוכות למד מינוס 10 או 15 דקות,

00:09:11.460 --> 00:09:12.940
בלבד לאחר הגדרת Azure Pipelines.

00:09:13.140 --> 00:09:15.260
זה לא שיפור קטן, זאת טרנספורמציה.

00:09:15.440 --> 00:09:17.760
אז, הקוד שלך הבנוי נבדק ופרוס.

00:09:17.760 --> 00:09:20.740
אבל לפני ששולחים אותו ללקוחות, צריך לוודא שהוא באמת עובד.

00:09:20.860 --> 00:09:23.520
לא רק שהוא מתכמפל, אלא שהוא עושה את מה שהוא אמור לעשות.

00:09:23.520 --> 00:09:25.660
כאן נכנס לתמונה Azure Test Plans.

00:09:25.800 --> 00:09:27.980
Azure Test Plans, איכות ללא ניחושים.

00:09:28.100 --> 00:09:29.880
אז, הקוד שלך נבנה ונפרס.

00:09:30.020 --> 00:09:31.040
אבל האם הוא באמת עובד?

00:09:31.160 --> 00:09:33.680
לא רק במכונה שלך, ולא רק במסלול האופטימלי.

00:09:33.820 --> 00:09:38.920
האם הוא עובד כשמישהו מקליד משהו לא נכון, כשהרשת איטית, או כשאלף איש משתמשים בו בבת אחת?

00:09:39.100 --> 00:09:41.160
כאן נכנס לתמונה Azure Test Plans.

00:09:41.160 --> 00:09:44.580
Test Plans הוא בדיקות מובנות של בדיקות ידניות ובדיקות חקירה.

00:09:44.660 --> 00:09:47.060
תחשבו על זה כמו צ'קליסט לפני טיסה של טייס.

00:09:47.060 --> 00:09:49.460
טייסים לא סתם נכנסים למטוס ומקווים לטוב.

00:09:49.620 --> 00:09:50.640
יש להם צ'קליסט.

00:09:50.780 --> 00:09:55.280
בודקים עדפים, דלק ומכשירים בכל פעם, כי פספוס של דבר אחד יכול להיות קטסטרופלי.

00:09:55.420 --> 00:09:56.520
תוכנה זה אותו הדבר.

00:09:56.740 --> 00:09:59.720
בג בסביבת הייצור עלול לעלות לכם בכסף, בלקוחות ובמוניטים.

00:09:59.860 --> 00:10:02.020
Test Plans מספק לכם את רשימת הבדיקות הזו.

00:10:02.120 --> 00:10:02.880
כך זה עובד.

00:10:03.000 --> 00:10:04.360
אתם יוצרים מקרי בדיקה.

00:10:04.360 --> 00:10:07.000
כל מקרי בדיקה מתאר דבר ספציפי לבדיקה.

00:10:07.060 --> 00:10:09.500
התחברות עם שם משתמש וסיסמת הקינים.

00:10:09.500 --> 00:10:11.600
ניסיון התחברות עם סיסמה שגויה.

00:10:11.780 --> 00:10:14.480
ניסיון שליחת תופס ללא מילוי שדות חובה.

00:10:14.600 --> 00:10:17.640
לכל מקרי בדיקה יש שלבים לביצוע ותוצאות מצופות.

00:10:17.820 --> 00:10:22.020
הבודק עובר על המקרים האלה שלב אחר שלב ומסמן כל אחד כעובר או נכשל.

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

00:10:25.580 --> 00:10:31.320
הבג נוצר כפריט עבודה בסיבורדס, מוקצה למפתח המתאים ומקושר לבדיקה למעקב מלא.

00:10:31.480 --> 00:10:33.920
ניתן לקבץ מקרי בדיקה לסביטות בדיקה.

00:10:33.920 --> 00:10:38.800
אולי יש לכם סוויטה לתהליך התשלום, אחרת לרישום משתמשים ועוד אחת ללוח הבקרה.

00:10:38.980 --> 00:10:42.800
לאחר מכן מארגנים את הסביטות האלה בתוכניות בדיקה לגרסאות או ספרינטים שונים.

00:10:43.040 --> 00:10:46.620
ניתן לראות בדיוק מה נבדק, מה עבר, מה נכשל ומה עדיין לא נבדק.

00:10:46.720 --> 00:10:49.280
החיבור ל-Aboards הוא המקום שבו זה הופך לעוצמתי.

00:10:49.280 --> 00:10:51.940
כשבדיקה נכשלת, נוצר בג ישירות בסיבורדס.

00:10:52.020 --> 00:10:56.260
המפתח רואה אותו, מתקן, דוחף את התיקון, והפייפליין בונה ופורס את הגרסה החדשה.

00:10:56.380 --> 00:10:57.920
הבודק מריץ את הבדיקה שוב.

00:10:58.060 --> 00:10:58.620
היא עוברת.

00:10:58.800 --> 00:10:59.560
הבג נסגר.

00:10:59.700 --> 00:11:04.320
כל זה קורה בתוך פלטפורמה אחת, בלי לשלוח גיליונות אלקטרוניים במייל ובלי להעתיק דוחות בגים בין מערכות.

00:11:04.440 --> 00:11:05.220
הכל מחובר.

00:11:05.360 --> 00:11:06.320
אהיה קנה איתכם.

00:11:06.460 --> 00:11:08.520
מתחילים נוטים לעיתים קרובות להתעלם מטסט פלנז.

00:11:08.660 --> 00:11:10.140
בדיקות נראות כמו עבודה נוספת.

00:11:10.280 --> 00:11:11.900
אתם רק רוצים לשחרר את הקוד שלכם.

00:11:11.900 --> 00:11:13.320
אתם רוצים לראות אותו באוויר.

00:11:13.440 --> 00:11:14.420
אבל הנה העניין.

00:11:14.420 --> 00:11:18.920
לכל מפתח שדיברתי איתו יש סיפור על בג שהגיע לעיצור וגרם לאסון.

00:11:19.120 --> 00:11:21.480
מערכת תשלומים שכימבא לקוחות פעמיים.

00:11:21.720 --> 00:11:23.560
דף התחברות שקרס תחת אומס.

00:11:23.720 --> 00:11:25.820
פיצ'ר שמחק נתונים במקום לשמור אותם.

00:11:25.940 --> 00:11:29.200
הבגים האלה הם תמיד אלו שהיו יכולים להימנע עם בדיקה פשוטה.

00:11:29.200 --> 00:11:30.780
טסט פלנז הוא ביטוח זול.

00:11:30.980 --> 00:11:32.180
זה דורש קצת זמן מראש.

00:11:32.340 --> 00:11:34.080
אבל חוסך לכם המון כאב בהמשך.

00:11:34.180 --> 00:11:36.600
ככל שהצוות גדל, תיתקלו בבעיה נוספת.

00:11:36.760 --> 00:11:38.640
תתחילו לכתוב את אותו הקוד שוב ושוב.

00:11:38.640 --> 00:11:47.960
פונקציות עזר, רכיבי לוגים, מעטפות API, תעתיקו ותדביקו קוד בין פרויקטים ומהר מאוד יהיו לכם חמש גרסאות שונות של אותו הדבר, כולן מעט שונות וכולן עלולות להיות עם בגים.

00:11:48.060 --> 00:11:49.920
כאן נכנס לתמונה Azure Artifacts.

00:11:50.080 --> 00:11:52.500
Azure Artifacts משתף את אבני הבניין שלכם.

00:11:52.500 --> 00:11:57.780
Azure Artifacts הוא מנהל חבילות עבור ספריות הקוד שלכם והדרך הטובה ביותר לחשוב עליו היא כמו על קוביות לגו.

00:11:57.900 --> 00:12:02.280
במקום לבנות כל חלק מאפס בכל פעם, אתם לוקחים קוביות מוכנות ומחברים אותן יחד.

00:12:02.280 --> 00:12:08.840
כשמישהו בצוות שלכם בונה ספריית לוגים הוא מפרסם אותה ל-Artifacts ואז כל השאר יכולים למשוך אותה לפרויקטים שלהם בשורת קוד אחת.

00:12:08.960 --> 00:12:13.360
אין צורך להעתיק קבצים, לשלוח קבצי זיק במייל או לטהות איזו גרסה היא העדכנית ביותר.

00:12:13.500 --> 00:12:15.440
הנה אנלוגיית הלגו בפירות רב יותר.

00:12:15.440 --> 00:12:17.060
דמיינו שאתם בונים טירה.

00:12:17.060 --> 00:12:25.460
אתם יכולים לגלף כל לבנה ביד, שזה אומר לכתוב הכל מאפס, או לקחת לבנים מוכנות ולהתמקד בחלקים הייחודיים של הטירה וזה בדיוק השימוש ב-Artifacts.

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

00:12:33.100 --> 00:12:42.140
Artifacts תומך בסוגי חבילות מרובים, נוגט עבור נט, npm עבור JavaScript, maven עבור Java, חבילות Python וחבילות אוניברסליות לכל דבר אחר.

00:12:42.140 --> 00:12:46.520
אתם יוצרים פיד, שהוא מאגר החבילות הפרטי שלכם, ואליו אתם מפרסמים חבילות.

00:12:46.660 --> 00:12:52.880
אתם מגדירים מקורות AppStream, כך שתוכלו גם למשוך חבילות ציבוריות מניוז'ת, org או npmjs.com דרך אותו הפיד.

00:12:53.020 --> 00:12:54.020
הכל במקום אחד.

00:12:54.220 --> 00:12:58.060
למה זה חשוב? זה חוסך זמן, מבטיח עקביות ומנהל גרסאות.

00:12:58.180 --> 00:13:03.600
כשמעדכנים ספרייה משותפת, מפרסמים גרסה חדשה ופרויקטים שמשתמשים בה יכולים לשדרג כשהם מוכנים.

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

00:13:08.120 --> 00:13:11.220
זה מבוקר ומאורגן, וזה מתחבר ישירות לפייפליינס.

00:13:11.360 --> 00:13:18.660
צינור הביילד שלכם יכול לפרסם חבילות ל-artifacts באופן אוטומטי, וצינור הפריסה יכול לצרוך חבילות מ-artifacts, כך שהתהליך כולו אוטומטי.

00:13:18.760 --> 00:13:24.500
הקוד נבנה, נבדק, נערז, מתפרסם ונצרח, הכל בלי שאף אחד יצטרך להעתיק קבצים ידני.

00:13:24.500 --> 00:13:27.000
אז, עכשיו ראיתם את כל חמשת השירותים.

00:13:27.180 --> 00:13:32.460
בורדס לתכנון, ריפוז לקוד, פייפליינס לאוטומציה, טסט פליינס לאיכות, ו-artifacts לשיתוף.

00:13:32.580 --> 00:13:36.960
אבל הקסם האמיתי הוא לא בשירות בודד, הוא באופן שבו כולם עובדים יחד.

00:13:37.120 --> 00:13:39.420
הרשו לי להראות לכם איך זה נראה בפועל.

00:13:39.540 --> 00:13:42.000
התמונה הגדולה, איך הכל משתלב יחד.

00:13:42.140 --> 00:13:47.000
הרשו לי להראות לכם איך זה נראה במציאות, בתרחיש שבו צוות בונה פיצ'ר חדש.

00:13:47.000 --> 00:13:52.000
שלב ראשון, מנהל המוצר פותח את Azure Boards ויוצר סיפור משתמש, כמו

00:13:52.000 --> 00:13:54.500
כלקוח, אני רוצה לאפס את הסיסמה שלי.

00:13:54.680 --> 00:14:00.460
הוסיפו קריטריוני קבלה, שייחו לספרינט הנוכחי, הגדירו עדיפות, ופריט העבודה הזה קיים כעת במערכת.

00:14:00.660 --> 00:14:06.020
שלב שני, המפתח פותח את Azure Repos, מושך את הקוד העדכני ויוצר ענף חדש מתוך פריט העבודה.

00:14:06.020 --> 00:14:08.620
בורדס אף מאפשר לכם לעשות זאת ישירות מהסיפור.

00:14:08.820 --> 00:14:11.580
שם הענף כולל באופן אוטומטי את מזהה פריט העבודה.

00:14:11.720 --> 00:14:16.200
הם כותבים את הקוד, מבצעים קומיט, ובהודעת הקומיט הם מוסיפים את Fixes Number 142.

00:14:16.440 --> 00:14:17.640
זהו מספר פריט העבודה.

00:14:17.800 --> 00:14:20.280
הקומיט מקושר כעת לסיפור המשתמש ב-Sea Boards.

00:14:20.460 --> 00:14:23.720
שלב שלישי, הקומיט מפעיל את Azure Pipelines באופן אוטומטי.

00:14:23.840 --> 00:14:28.060
הפייפליין לוקח את הקוד, משחזר תלויות, מריץ את ה-Bild ומריץ בדיקות יחידה.

00:14:28.060 --> 00:14:32.020
אם בדיקה קול שהיא נכשלת, הפייפליין נעצר והמפתח מקבל התראה.

00:14:32.020 --> 00:14:39.180
אם הכל עובר, הפייפליין מבצע פריסה לסביבת בדיקות, והמפתח יכול לראות את הקוד שלו רץ בשידור חי לפני שמישהו אחר נוגע בו.

00:14:39.420 --> 00:14:42.820
שלב רביעי, מהנדס ה-QA פותח את Azure Test Plans.

00:14:43.100 --> 00:14:49.500
מוצא את חבילת הבדיקות לאיפוס סיסמה, מריץ את מקרי הבדיקה הידניים, עוקב אחר הצעדים ומאמת שהתכונה עובדה.

00:14:49.500 --> 00:14:50.820
אבל הם מוצאים בג.

00:14:50.960 --> 00:14:52.940
הודעת השגיאה כתובה עם שגיאת כתיב.

00:14:53.100 --> 00:14:55.220
הם לוחצים על יצירת בג ישירות ממקרי הבדיקה.

00:14:55.220 --> 00:14:58.640
ופריט עבודה חדש מופיע בסיבורדס כשהוא מקושר לסיפור המשתמש המקורי.

00:14:58.740 --> 00:15:00.960
המפתח רואה את זה, מתקן, מבצע פוש.

00:15:01.160 --> 00:15:04.320
הפייפליין רץ שוב, הבודק מריץ מחדש את הבדיקה, והיא עוברת.

00:15:04.460 --> 00:15:09.360
שלב חמישי, התכונה מוכנה, והצוות מפרסם את ספריית האימות המשותפת ל-Azure Artifacts.

00:15:09.500 --> 00:15:12.160
כעת, צוותים אחרים יכולים להשתמש בה בפרויקטים שלהם.

00:15:12.160 --> 00:15:17.960
רכיב איפוס הסיסמה זמין כחבילה, כך שכל צוות שבונה תכונה חדשה שזקוקה לאימות יכול למשוך אותה בשורת קוד אחת.

00:15:18.060 --> 00:15:20.480
בלי כתיבה מחדש, בלי העתקה, רק הפנייה.

00:15:20.660 --> 00:15:22.340
זהו המבנה המקושר בפעולה.

00:15:22.440 --> 00:15:23.580
כל שירות הוא חדר.

00:15:23.820 --> 00:15:25.200
Boards הוא חדר התכנון.

00:15:25.400 --> 00:15:26.880
Ripples היא ספריית הקוד.

00:15:27.080 --> 00:15:28.680
Pipelines היא רצפת הייצור.

00:15:28.920 --> 00:15:30.960
Test Plans היא תחנת בקרת האיכות.

00:15:31.200 --> 00:15:32.560
ו-Artifacts הוא המחסן.

00:15:32.680 --> 00:15:37.040
אבל, הכוח האמיתי אינו באף חדר בודד, ובמסדרונות שמחברים ביניהם.

00:15:37.040 --> 00:15:39.500
פרית העבודה מקושר לקוד, הקוד מפעיל את הפייפליין.

00:15:39.640 --> 00:15:42.640
הפייפליין פורס לבדיקות, הבדיקות יוצרות בגים בחזרה ב-Sea Boards,

00:15:42.820 --> 00:15:44.380
החבילה המוכנה הולכת ל-Artifacts.

00:15:44.540 --> 00:15:47.160
הכל מדבר עם הקול, וכאן זה נהיה מעניין.

00:15:47.340 --> 00:15:49.180
בינה מלאכותית מגיעה ל-Azure DevOps.

00:15:49.560 --> 00:15:51.740
מייקרוסופט כבר משיקה אינטגרציות של Copilot,

00:15:51.940 --> 00:15:55.020
כמו סיוע בפריטי עבודה שעוזר לכם לכתוב סיפורי משתמש טובים יותר,

00:15:55.020 --> 00:15:57.660
בינה מלאכותית שיכולה לסכם שרשורי דיונים ארוכים,

00:15:57.660 --> 00:16:00.380
וקופילות לבדיקת קוד שסוקר אוטומטית Pull Requests.

00:16:00.580 --> 00:16:02.500
זה עדיין מוקדם, אבל הכיוון ברור.

00:16:02.680 --> 00:16:06.020
Azure DevOps הופך לפלטפורמה חכמה לא רק לאוסף של כלים.

00:16:06.160 --> 00:16:07.940
אז מהי הדרך הטובה ביותר להתחיל?

00:16:08.080 --> 00:16:10.600
אתם לא צריכים לאמץ את כל חמשת השירותים בבת אחת.

00:16:10.740 --> 00:16:13.420
בחרו אחד, התחילו עם Boards, צרו פרויקט,

00:16:13.420 --> 00:16:16.020
עקבו אחר כמה משימות וראו איך זה מרגיש.

00:16:16.140 --> 00:16:18.100
לאחר מכן הוסיפו Repos כשאתם מוכנים,

00:16:18.260 --> 00:16:19.880
ואז Pipelines צעד אחר צעד.

00:16:19.960 --> 00:16:21.200
הצעד הראשון שלכם.

00:16:21.340 --> 00:16:22.660
אז הנה הרעיון המרכזי.

00:16:27.660 --> 00:16:29.800
Test Plans ו-Artifacts, כולם עובדים יחד.

00:16:29.920 --> 00:16:32.280
הערך אינו בחלק בודד, אלא באופן שבו הם משתלבים.

00:16:32.400 --> 00:16:33.760
הנה הצעד הראשון שלכם.

00:16:33.920 --> 00:16:36.400
גשו dev.azure.com וצרו חשבון בחינם.

00:16:36.540 --> 00:16:38.180
לאחר מכן, התחילו פרויקט חדש.

00:16:38.300 --> 00:16:40.380
חיקרו את Boards, צרו סיפור משתמש, User Story,

00:16:40.380 --> 00:16:42.240
גירו אותו בלוח הקנבן וראו איך זה עובד.

00:16:42.360 --> 00:16:43.460
הנה האתגר שלכם.

00:16:43.600 --> 00:16:45.760
בחרו פרויקט קטן אחד, כל דבר יתאים.

00:16:45.920 --> 00:16:47.440
עקבו אחריו ב-Sea Boards למשך שבוע,

00:16:47.440 --> 00:16:49.860
הוסיפו משימות, עדכנו סטטוסים וראו איך זה מרגיש

00:16:49.860 --> 00:16:51.380
כשהעבודה שלכם דלויה ומאורגנת.

00:16:51.540 --> 00:16:53.500
בפרק הבא נצלול ל-Azure Pipelines.

00:16:53.700 --> 00:16:56.720
נבנה את ה-C, CD Pipeline הראשון שלכם צעד אחר צעד,

00:16:56.900 --> 00:16:59.360
ותראו איך להפוך בנייה ופריסות לאוטומטיות מאפס.

00:16:59.360 --> 00:17:01.580
הרשמו בפלטפורמת הפודקאסט המועדפת עליכם

00:17:01.580 --> 00:17:04.320
ושתפו את הפרק הזה עם מישהו שמתחיל את מסע הדבופס שלו.
