GitHub מא׳ עד ת׳
מדריך מעשי בעברית · מהבסיס לעבודה עצמאית

גיטהאב מא׳ עד ת׳

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

16 פרקי לימוד10 סרטוני המחשה ודמו48 שאלות תרגול15 שאלות מסכמות
מתחילים מפרק 1 ←כבר מכירים? למבחן המסכם ←למה בכלל צריך את זה? ←
על המדריך והמקורות

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

● ● ●your-project / version history
01 עורכים←02 שומרים גרסה←03 סוקרים יחד

למה בכלל צריך את זה? ארבע דוגמאות מהעבודה

לפני הפקודות והמסכים, כדאי לראות איזו בעיה אמיתית כל כלי פותר. בכל דוגמה: מה קורה בלי Git ו-GitHub, מה משתנה איתם, ומה התוצאה בסוף.

"מי דרס לי את הקובץ?"

הבעיהשני אנשים עובדים על אותו סקריפט חישוב. אחד שולח גרסה במייל, השני דורס אותה בטעות, ויום עבודה שלם הולך לאיבוד.
איך זה נפתרכל אחד עובד על ענף משלו, וכל שמירה מתועדת: מי שינה, מתי ולמה. שינוי נכנס לגרסה הראשית רק דרך Pull Request, ואם שניים נגעו באותן שורות Git מסמן את ההתנגשות במקום לדרוס בשקט.
התוצאהכל שינוי שנשמר בקומיט נשאר בהיסטוריה ואפשר לשחזר אותו. עבודה שטרם נשמרה עדיין יכולה להידרס, ולכן שומרים לעיתים קרובות ופותרים התנגשויות יחד בסקירה מסודרת.
איך עושים את זה: פרק 7 - ענפים ←

"האתר נשבר, ואף אחד לא יודע מתי"

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

"עובד חדש מצטרף לצוות"

הבעיהכדי שיתחיל לעבוד צריך לשלוח לו עשרה קבצים במייל ולהקדיש שבוע של הסברים על איך הכל בנוי.
איך זה נפתרהוא מבצע clone לריפו ומקבל את כל הקבצים ואת כל היסטוריית השינויים. הדיונים וההחלטות מתועדים ב-Issues וב-Pull Requests באתר GitHub, פתוחים לו לקריאה.
התוצאהתוך שעה הוא רואה לא רק מה הקוד עושה אלא גם למה הוא בנוי ככה, ומתחיל לתרום בעצמו.
איך עושים את זה: פרק 6 - clone, push, pull ←

"רוצים שמישהו יבדוק לפני שזה נכנס"

הבעיהשינוי חדש נכנס ישר לגרסה שכולם משתמשים בה, והטעות מתגלית רק אצל המשתמשים.
איך זה נפתרכל שינוי מוגש כ-Pull Request: הסוקר רואה בדיוק אילו שורות השתנו, מעיר הערות על שורה ספציפית, ורק אחרי אישור ממזגים ל-main.
התוצאהטעויות נתפסות לפני שהן מגיעות לכולם, והידע על השינוי לא נשאר אצל אדם אחד.
איך עושים את זה: פרק 8 - Pull Request ←

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

1קוראיםמקרה שימוש אמיתי מהעבודה, ומה צריך להבין לפני שמתחילים
2צופיםהמחשה בפתיחה והדגמות ממשק בפרקים המסומנים
3מתרגליםצעדים להעתקה עם מה שאמור לקרות, ושגיאות נפוצות להימנע מהן
4נבחניםשלוש שאלות בכל פרק, וההתקדמות נשמרת אצלכם במכשיר
ההתקדמות שלכם0/17מתחילים

הפרקים

לא נמצאו פרקים או מונחים שתואמים את החיפוש.

מילון מונחים

גיט (Git)תוכנה שרצה על המחשב ושומרת היסטוריית שינויים של קבצים.
גיטהאב (GitHub)אתר שמארח ריפואים של גיט בענן ומוסיף כלי עבודת צוות.
ריפו (Repository)תיקיית פרויקט אחת עם כל הקבצים וכל ההיסטוריה שלהם.
קומיט (Commit)שמירת תמונת מצב של הקבצים עם הודעה; נקודה אחת בהיסטוריה.
ענף (Branch)קו עבודה מקביל שלא נוגע בגרסה הראשית עד שממזגים אותו.
mainשם הענף הראשי בריפו - הגרסה שכולם עובדים מולה.
HEADמצביע על הקומיט שעליו אתם נמצאים כרגע.
מיזוג (Merge)איחוד השינויים של ענף אחד לתוך ענף אחר.
קונפליקט (Conflict)שני צדדים שינו את אותן שורות, וגיט מבקש החלטה ידנית.
Cloneהורדת עותק מלא של ריפו מגיטהאב למחשב.
Pushדחיפת קומיטים מהמחשב לגיטהאב.
Pullמשיכת שינויים חדשים מגיטהאב למחשב ומיזוגם.
Fetchהבאת מידע על שינויים חדשים בלי למזג אותם עדיין.
Remoteהקישור בין הריפו במחשב לעותק שלו בגיטהאב.
originשם ברירת המחדל של ה-remote הראשי.
Pull Request (PR)בקשה שהצוות יסקור ענף ויאשר מיזוג שלו.
סקירת קוד (Review)הערות ואישור של עמיתים על PR לפני מיזוג.
Issueכרטיס משימה, באג או רעיון בתוך הריפו.
Projectsלוח עבודה שמארגן Issues ו-PRs לפי סטטוס.
Actionsמערכת האוטומציה של גיטהאב: מריצה תהליכים על אירועים בריפו.
Workflowקובץ הגדרה של תהליך אוטומטי ב-Actions.
Pagesפרסום אתר סטטי ישירות מתוך הריפו.
READMEקובץ התצוגה הראשי של הריפו; מוצג בדף הבית שלו.
.gitignoreרשימת קבצים שגיט מתעלם מהם ולא שומר.
טוקן (PAT)מפתח גישה אישי שמחליף סיסמה בפעולות גיט מחוץ לדפדפן.
אימות דו-שלבי (2FA)שכבת אבטחה נוספת מעבר לסיסמה, בדרך כלל קוד מאפליקציה.
SSHפרוטוקול מאובטח שמחבר את המחשב לגיטהאב בלי סיסמה בכל פעם.
01

מה זה גיט, ומה זה גיטהאב

פרק 1 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם

לפני שמתחילים

Git נדרש לעבודה המקומית ולפקודות במדריך. מתקינים ובודקים אותו בפרק 3. לעבודה באתר בלבד אין צורך בהתקנה. לא צריך לדעת לתכנת כדי ללמוד את הבסיס.

קובץ בעבודהעורכים במחשב←Commitגרסה שמורה ב-Git←Pushמשתפים ב-GitHub

מקרה שימוש

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

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

מה צריך להבין

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

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

ריפו (repository) הוא תיקייה אחת עם כל הקבצים של פרויקט ועם כל ההיסטוריה שלהם.

מתי משתמשים ולמה זה חשוב

ניהול גרסאות הוא היסטוריה, לא תיקיית גיבוי

במקום קבצים בשם final-2, Git שומר נקודות החלטה: מה השתנה, מי שמר ומדוע. אפשר להשוות ולבטל שינוי. רק מה שנשמר בקומיט נמצא בהיסטוריה; שמירה בעורך אינה קומיט. קבצי טקסט מאפשרים השוואה ברמת שורה; בקובץ בינארי ההשוואה והמיזוג מוגבלים יותר.

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

צעד אחר צעד

  1. ככה נראה המסלול של שינוי אחד, מההתחלה ועד הסוף. שימו לב אליו, כי כל הפרקים הבאים הם צעדים בתוכו:
  2. יוצרים ענף (branch) - עותק עבודה מקביל שלא נוגע בגרסה הראשית.
  3. עורכים קבצים ושומרים קומיט.
  4. דוחפים (push) את הענף לגיטהאב ופותחים Pull Request - בקשה שאחרים יסתכלו על השינוי.
  5. מקבלים הערות, מתקנים, ומאשרים.
  6. ממזגים (merge) לגרסה הראשית. כולם רואים את השינוי, וההיסטוריה שמורה.

מה אמור לקרות

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

תרגיל

כתבו בשתי שורות איך אתם שומרים היום גרסאות של קובץ משותף, ואיזו בעיה אחת בשיטה הזאת גיט פותר.

בדקו את עצמכם

עמית אומר: "גיט וגיטהאב זה אותו דבר". מה התשובה המדויקת?

מה זה קומיט?

למה ממשיכים לעבוד על ענף ולא ישר על הגרסה הראשית?

מקורות: About Git · Hello World (GitHub quickstart) · About Version Control

02

חשבון ואבטחה ראשונית

פרק 2 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם

מקרה שימוש

נרשמים לגיטהאב בפעם הראשונה, ורוצים שחשבון העבודה לא ייפרץ בגלל סיסמה שדלפה.

מה צריך להבין

חשבון אישי דורש שם משתמש וכתובת מייל מאומתת. אפשר גם להירשם עם Google או Apple. שם המשתמש הופך לכתובת של הפרופיל והריפואים שלכם, אז בחרו שם שמתאים גם לעבודה.

גיטהאב ממליץ בחום להפעיל אימות דו-שלבי (2FA). השיטה המומלצת היא אפליקציית אימות (TOTP) והוספת מפתח אבטחה כגיבוי, ולא SMS. אפשר גם passkey שמחליף סיסמה.

בארגון עם חשבונות מנוהלים (Enterprise Managed Users) ההרשמה נעשית דרך הארגון, ולכן הצעדים כאן לא חלים עליו.

מתי משתמשים ולמה זה חשוב

חשבון מזהה אתכם; הרשאה קובעת מה מותר

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

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

צעד אחר צעד

  1. נכנסים ל-github.com ולוחצים Sign up. מזינים מייל, סיסמה ושם משתמש, ומאמתים את המייל.
  2. פותחים Settings, ואז Password and authentication.
  3. בוחרים Enable two-factor authentication ובוחרים Authenticator app. סורקים את קוד ה-QR באפליקציית האימות, ומקלידים את הקוד שהיא מציגה.
  4. מורידים את קודי השחזור (recovery codes) ושומרים אותם במקום בטוח, מחוץ למחשב. אלה הדרך להיכנס אם הטלפון אבד.
  5. מוסיפים שיטה נוספת: passkey או מפתח אבטחה, כדי שלא תינעלו בחוץ.

מה אמור לקרות

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

תרגיל

הפעילו 2FA בחשבון שלכם, שמרו את קודי השחזור, התנתקו והתחברו שוב כדי לוודא שהקוד עובד. אל תשתפו את קודי השחזור עם אף אחד.

בדקו את עצמכם

איזו שיטת 2FA מומלצת על ידי גיטהאב?

הטלפון עם אפליקציית האימות אבד. מה מציל אתכם?

איזה אילוץ יש לחשבון שנוצר על ידי הארגון (Enterprise Managed Users)?

מקורות: Creating an account on GitHub · Configuring 2FA · About passkeys

03

להתקין גיט ולהגדיר שם

פרק 3 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם

מקרה שימוש

רוצים לשמור קומיט ראשון מהמחשב, אבל גיט עוד לא מותקן, והקומיטים צריכים להישמר על שמכם.

מה צריך להבין

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

כתובת המייל בקומיט היא מה שמקשר אותו לחשבון בגיטהאב. אם אתם לא רוצים לחשוף מייל אמיתי, אפשר להשתמש בכתובת noreply ש-GitHub מספק בהגדרות המייל.

מתי משתמשים ולמה זה חשוב

מתי באמת צריך להתקין Git

לתרגילי שורת הפקודה במדריך צריך Git מותקן. VS Code הוא עורך, GitHub הוא שירות, ו-Git הוא מנוע ניהול הגרסאות. מתקינים ממקור רשמי ובמחשב ארגוני פועלים לפי מדיניות ההתקנה.

אפשר לקרוא קבצים, לנהל Issues ואף לערוך ולשמור שינויים בדפדפן בלי התקנת Git. לעבודה מקומית אפשר לבחור GitHub Desktop שמגיע עם Git; לתרגילי הטרמינל שלנו בודקים שהפקודה git זמינה. user.name ו-user.email אינם התחברות לחשבון ואינם סיסמה.

צעד אחר צעד

  1. מורידים ומתקינים Git מ-git-scm.com (Windows, Mac או Linux). ב-Windows מקבלים איתו גם Git Credential Manager.
  2. פותחים טרמינל (ב-Windows: Git Bash או PowerShell) ובודקים שהוא מותקן:
    git --version
  3. מגדירים שם ומייל. השם והמייל יישמרו על כל קומיט:
    git config --global user.name "השם שלכם"
    git config --global user.email "you@example.com"
  4. בודקים מה נשמר:
    git config --global --list

מה אמור לקרות

הפקודה הראשונה מדפיסה גרסה, למשל git version 2.xx.x. הפקודה האחרונה מדפיסה שורות user.name=... ו-user.email=... עם הערכים שהקלדתם.

תרגיל

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

בדקו את עצמכם

למה מגדירים user.name ו-user.email?

מה עושה הדגל --global?

אתם לא רוצים שהמייל האישי יופיע בקומיטים ציבוריים. מה עושים?

⚠ שגיאות נפוצות

  • שוכחים לסגור ולפתוח מחדש את הטרמינל אחרי ההתקנה, ואז git --version נכשל למרות שהכול הותקן.

  • מגדירים מייל שונה מזה של חשבון הגיטהאב, והקומיטים לא משויכים לפרופיל שלכם.

  • כותבים ערך עם רווח בלי מירכאות, וההגדרה נשמרת שגויה.

מקורות: Set up Git · Setting your username in Git · Setting your commit email address

04

הריפו הראשון בגיטהאב

פרק 4 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

יצירת ריפו חדש בממשק האמיתי של GitHub.

מקרה שימוש

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

מה צריך להבין

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

חשוב: ריפו ציבורי נראה לכל העולם. ריפו פרטי נראה רק למי שהוזמן. נתוני הארגון והלקוחות שייכים לריפו פרטי.

מתי משתמשים ולמה זה חשוב

מה שייך לריפו אחד

ריפו הוא גבול לפרויקט: קבצים, היסטוריה והגדרות סביב מטרה אחת. README מסביר לאדם חדש מה יש כאן ואיך להתחיל. Private מגביל גישה אך אינו היתר לשמור סודות בקוד.

קובץ .gitignore מתעלם מקבצים שעדיין לא נעקבים. הוא אינו מוחק היסטוריה ואינו מפסיק מעקב שכבר התחיל. לפני קומיט בודקים git status ובוחנים אילו קבצים באמת נכללים.

צעד אחר צעד

  1. בפינה הימנית העליונה לוחצים על + ובוחרים New repository.
  2. בשדה Repository name מקלידים שם באנגלית, בלי רווחים, למשל team-website.
  3. בוחרים Visibility: Public או Private.
  4. מפעילים Add README. אפשר גם לבחור תבנית .gitignore מהרשימה.
  5. לוחצים Create repository.

מה אמור לקרות

נפתח דף הריפו: שם הריפו למעלה, רשימת קבצים (README.md) באמצע, ומתחתיה התוכן של ה-README מוצג כטקסט מעוצב. הכתובת היא github.com/שם-המשתמש/team-website.

תרגיל

צרו ריפו פרטי בשם git-practice עם README. ערכו את ה-README ישירות באתר (סמל העיפרון), הוסיפו שורה, ושמרו (Commit changes). בדקו שהקומיט מופיע ברשימת ההיסטוריה.

בדקו את עצמכם

הפרויקט כולל נתוני לקוחות אמיתיים. איזו נראות בוחרים?

מה תפקיד קובץ README?

מה עושה .gitignore?

⚠ שגיאות נפוצות

  • פותחים ריפו ציבורי בלי לשים לב ומעלים אליו קבצים של הארגון. בודקים את שדה ה-Visibility פעמיים לפני Create.

  • מעלים קובץ עם סיסמה או מפתח. אחרי שהועלה, הסרה מההיסטוריה מסובכת - מונעים מראש עם .gitignore.

  • בוחרים שם עם רווחים או בעברית. שם באנגלית בלי רווחים חוסך בעיות בקישורים ובפקודות.

מקורות: Quickstart for repositories · About READMEs · Ignoring files · gitignore

05

גיט במחשב: init, add, commit

פרק 5 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

פקודות git אמיתיות שהורצו בסביבת בדיקה (לא צילום מסך של מסך המשתמש).

מקרה שימוש

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

מה צריך להבין

בגיט יש שלושה מקומות: תיקיית העבודה (הקבצים שאתם עורכים), Staging (מה שבחרתם לשמור עכשיו) והיסטוריה (הקומיטים). git add מעביר ל-Staging, ו-git commit שומר מה שב-Staging כקומיט.

הפקודה הכי שימושית היא git status: היא אומרת מה השתנה ומה מחכה לשמירה. הריצו אותה לפני כל פעולה.

מתי משתמשים ולמה זה חשוב

מה כל פקודה משנה, ומה היא לא עושה

git init יוצר מאגר מקומי בתיקייה, לא ריפו באתר. git add בוחר את תוכן השינוי לקומיט הבא. ערכתם שוב אחרי add? מוסיפים שוב כדי לכלול את העריכה החדשה. git commit שומר את הבחירה בהיסטוריה המקומית ולא שולח אותה לרשת.

git diff מציג שינויים שלא הוכנו לקומיט. git diff --staged מציג בדיוק מה יישמר. git log --oneline מציג היסטוריה שכבר נשמרה. עובדים בסדר: status, בדיקת diff, בחירת קבצים, בדיקת staged וקומיט שמסביר שינוי אחד.

צעד אחר צעד

  1. יוצרים תיקייה ומאתחלים בה ריפו:
    mkdir demo && cd demo
    git init
  2. יוצרים קובץ ובודקים מצב:
    echo "# Demo" > README.md
    git status
  3. מוסיפים ל-Staging ושומרים קומיט עם הודעה:
    git add README.md
    git commit -m "Add README"
  4. משנים את הקובץ, ובודקים מה השתנה לפני שמירה:
    echo "Second line" >> README.md
    git diff
  5. שומרים קומיט שני ורואים את ההיסטוריה:
    git add .
    git commit -m "Add second line"
    git log --oneline

מה אמור לקרות

git status הראשון מציג את README.md תחת Untracked files. אחרי הקומיטים, git log --oneline מציג שתי שורות, כל אחת עם קוד קצר (hash) והודעה, והחדשה למעלה. git diff מציג את השורה שנוספה עם סימן +.

תרגיל

צרו תיקייה עם שלושה קבצי טקסט, שמרו קומיט נפרד לכל קובץ עם הודעה ברורה, והריצו git log --oneline. אמורות להיות שלוש שורות.

בדקו את עצמכם

שינתם קובץ והרצתם git commit בלי git add. מה קורה?

איזו פקודה מראה מה בדיוק שונה בקבצים לפני שמירה?

מה כתוב בהודעת קומיט טובה?

⚠ שגיאות נפוצות

  • שוכחים git add לפני ה-commit, והקומיט יוצא בלי הקבצים שרציתם.

  • עושים קומיט אחד ענק בסוף היום. קומיטים קטנים עם הודעה ברורה קלים יותר לסקירה ולחזרה אחורה.

  • כותבים הודעות כמו "עדכון" או "תיקון". הודעה טובה אומרת מה השתנה ולמה.

מקורות: About Git · Set up Git · git add and staging

06

לחבר את המחשב לגיטהאב: clone, push, pull

פרק 6 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם

מקרה שימוש

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

מה צריך להבין

clone מעתיק ריפו מגיטהאב למחשב, כולל כל ההיסטוריה. push שולח קומיטים מהמחשב לגיטהאב. pull מביא מהגיטהאב שינויים שאחרים שלחו.

כתובת הריפו בגיטהאב נקראת remote, והשם הרגיל שלה הוא origin.

ב-HTTPS גיטהאב לא מקבל את סיסמת החשבון. משתמשים בGit Credential Manager (מותקן עם Git ב-Windows) שמתחבר דרך הדפדפן, או ב-Personal Access Token. פרק 15 מסביר טוקנים.

מתי משתמשים ולמה זה חשוב

Clone פעם אחת; Pull ו-Push לאורך העבודה

git clone יוצר תיקייה מתוך ריפו מרוחק ומגדיר בדרך כלל remote בשם origin. לא משכפלים בכל בוקר. git fetch מוריד מידע מהשרת בלי לשלב אותו מיד; git pull מוריד וגם משלב לפי ההגדרות.

git push שולח קומיטים שכבר קיימים, לא כל קובץ שנשמר בעורך. git remote -v בודק לאן מתחברים. ZIP נותן קבצים בלי חיבור העבודה הרגיל להיסטוריה. דחיפה שנדחתה אינה סיבה לבצע force push בלי להבין איזה מידע יידרס.

צעד אחר צעד

  1. בדף הריפו לוחצים Code ומעתיקים את כתובת ה-HTTPS. מריצים בטרמינל:
    git clone https://github.com/USER/git-practice.git
    cd git-practice
  2. עורכים קובץ ושומרים קומיט:
    echo "New line" >> README.md
    git add .
    git commit -m "Add line from my computer"
  3. שולחים לגיטהאב. בפעם הראשונה ייפתח חלון כניסה דרך הדפדפן:
    git push
  4. בפעם אחרת, אחרי ששותף שלח שינוי, מביאים אותו:
    git pull
  5. ריפו מקומי שנוצר עם git init, ואתם רוצים לחבר אותו לריפו ריק בגיטהאב:
    git remote add origin https://github.com/USER/REPO.git
    git branch -M main
    git push -u origin main

מה אמור לקרות

אחרי git push הטרמינל מציג שורות על העלאת אובייקטים וסיומת בסגנון main -> main. בדף הריפו באתר מופיע הקומיט החדש עם ההודעה שלכם. אחרי git pull ללא שינויים מופיע Already up to date.

תרגיל

שכפלו את git-practice ממחשב, הוסיפו קובץ, שלחו, וודאו באתר שהקובץ הגיע. אחר כך ערכו קובץ באתר והריצו git pull במחשב.

בדקו את עצמכם

ערכתם קובץ באתר גיטהאב. איך מקבלים אותו במחשב?

מה זה origin?

ה-push נכשל עם שגיאת הרשאה כשהקלדתם את סיסמת החשבון. למה?

⚠ שגיאות נפוצות

  • ה-push נדחה עם הודעת rejected כי מישהו דחף לפניכם. עושים pull, פותרים את ההבדלים ודוחפים שוב.

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

  • מחפשים את הקבצים במקום הישן: clone יוצר תיקייה חדשה, וצריך להיכנס אליה.

מקורות: Cloning a repository · About remote repositories · Caching your GitHub credentials in Git · git fetch · git pull

07

ענפים: עובדים בלי לשבור את הגרסה הראשית

פרק 7 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם

מקרה שימוש

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

מה צריך להבין

ענף (branch) הוא קו היסטוריה מקביל. הענף הראשי נקרא בדרך כלל main והוא הגרסה שסומכים עליה. כל שינוי נעשה בענף משלו ורק אחרי סקירה חוזר ל-main.

ענף לא מעתיק קבצים. הוא מצביע על קומיט, ולכן יצירה והחלפה בין ענפים מהירות.

שמות ענפים טובים מתארים את העבודה: fix-navigation או add-region-slicer.

מתי משתמשים ולמה זה חשוב

ענף הוא קו עבודה, לא תיקייה כפולה

ענף מרכז שינוי מסוים בלי להכניס אותו מיד לגרסה הראשית. באותה תיקייה מוצגים קבצים שונים כשעוברים ענף. בודקים git status לפני מעבר: שינוי שלא נשמר עלול לעבור איתכם או למנוע את המעבר.

git switch -c fix-navigation יוצר ענף ועובר אליו; git switch main עובר לענף קיים. שם הענף מתאר מטרה, והקומיטים הם נקודות השמירה. משימה אחת לענף מקלה על סקירה וביטול.

צעד אחר צעד

  1. מוודאים שהענף הראשי מעודכן, ופותחים ענף חדש ועוברים אליו:
    git switch main
    git pull
    git switch -c fix-navigation
  2. עורכים קובץ ושומרים קומיט כרגיל:
    echo "Navigation link fixed" >> notes.md
    git add .
    git commit -m "Fix navigation link"
  3. בודקים באיזה ענף אתם ומה הרשימה:
    git branch
  4. שולחים את הענף לגיטהאב. הדגל -u קושר אותו לענף מרוחק, ובהמשך מספיק git push:
    git push -u origin fix-navigation
  5. חוזרים לראשי כדי לראות שהשינוי לא שם:
    git switch main

מה אמור לקרות

git branch מציג רשימת ענפים וכוכבית ליד הנוכחי. אחרי push, גיטהאב מציג בדף הריפו באנר צהוב "Compare & pull request" לענף החדש. אחרי ה-switch ל-main, הקובץ notes.md כבר לא מכיל את השורה החדשה.

תרגיל

פתחו ענף בשם add-notes בריפו git-practice, הוסיפו קובץ, שמרו קומיט ושלחו. בדקו באתר שהענף מופיע ברשימת הענפים, ושב-main אין את הקובץ.

בדקו את עצמכם

למה לעבוד על ענף נפרד?

איזו פקודה פותחת ענף חדש ועוברת אליו?

איזה שם ענף עדיף?

⚠ שגיאות נפוצות

  • עורכים בטעות ישירות על main. לפני עריכה בודקים את הענף הפעיל עם git branch.

  • נשארים על ענף ישן שבועות. מושכים מ-main מדי כמה ימים כדי שהקונפליקטים יישארו קטנים.

  • נותנים שמות כלליים כמו test. שם כמו fix/navigation-link מספר מה הענף עושה.

מקורות: About branches

08

Pull Request: מבקשים שמישהו יסתכל

פרק 8 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

פתיחת Pull Request בממשק האמיתי.

מקרה שימוש

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

מה צריך להבין

Pull Request (PR) הוא בקשה למזג ענף לתוך ענף אחר, בדרך כלל main. הוא מציג את כל ההבדלים שורה אחר שורה, ומקום לדיון.

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

אפשר לפתוח Draft PR (טיוטה) כשהעבודה עוד לא מוכנה לסקירה.

מתי משתמשים ולמה זה חשוב

Pull Request הוא מקום להחלטה משותפת

PR משווה ענף שינוי לענף יעד: base הוא היעד ו-compare הוא הענף שמציע שינוי. בודקים את שניהם. הכותרת מסבירה מה השתנה והתיאור למה, איך נבדק ומה הסוקר צריך לבדוק.

קומיטים חדשים שדוחפים לאותו ענף מעדכנים את ה-PR הקיים. Draft מתאים למשוב מוקדם. פתיחת PR אינה מיזוג: השינוי נכנס ליעד רק אחרי Merge ובהתאם להרשאות ולבדיקות שהוגדרו.

צעד אחר צעד

  1. אחרי שדחפתם ענף, פותחים את דף הריפו באתר ולוחצים על הכפתור Compare & pull request.
  2. בודקים שהבסיס (base) הוא main ושההשוואה (compare) היא הענף שלכם.
  3. כותבים כותרת ותיאור. אפשר לציין Fixes #12 כדי לסגור משימה אוטומטית כשהכל ימוזג (פרק 10).
  4. בוחרים Reviewers ברשימה בצד ימין.
  5. לוחצים Create pull request. כדי לפתוח טיוטה, בוחרים בחץ ליד הכפתור את Create draft pull request.

מה אמור לקרות

נפתח דף ה-PR עם מספר (למשל #3), לשוניות Conversation, Commits, Files changed, וכפתור ירוק בתחתית שמסמן שאפשר למזג, אם אין קונפליקטים. בלשונית Files changed רואים שורות ירוקות שנוספו ואדומות שנמחקו.

תרגיל

פתחו PR מהענף add-notes אל main בריפו git-practice, כתבו תיאור בשלוש שורות: מה, למה, איך בדקתי. אל תמזגו עדיין.

בדקו את עצמכם

מה Pull Request עושה?

העבודה עוד באמצע, אבל רוצים שהצוות יראה כיוון. מה עושים?

איזו לשונית מציגה את השורות ששונו?

⚠ שגיאות נפוצות

  • פותחים PR לענף היעד הלא נכון. בודקים את שורת base ו-compare לפני היצירה.

  • פותחים PR ענק עם עשרות קבצים. PR קטן וממוקד מקבל סקירה מהירה וטובה יותר.

  • משאירים את התיאור ריק. כותבים מה השתנה, למה, ואיך בדקתם.

מקורות: Creating a pull request · Linking a pull request to an issue

09

סקירה, מיזוג וקונפליקטים

פרק 9 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

מיזוג ה-PR וסגירת ה-Issue אוטומטית.

מקרה שימוש

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

מה צריך להבין

סוקר יכול לכתוב Comment, Approve או Request changes.

יש שלוש דרכי מיזוג: Merge commit שומר את כל הקומיטים ומוסיף נקודת מיזוג. Squash and merge מאחד את כל הקומיטים לאחד, והוא מתאים כשה-PR הוא שינוי לוגי אחד. Rebase and merge מוסיף את הקומיטים בקו ישר.

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

מתי משתמשים ולמה זה חשוב

סקירה בודקת משמעות, לא רק סימון ירוק

ב-Files changed קוראים את השורות וההקשר, בודקים שהבעיה נפתרה ושאין קבצים לא קשורים. Approve הוא אישור, Comment הוא הערה ו-Request changes מבקש תיקון. בדיקה אוטומטית שעברה אינה מוכיחה שהדרישה מולאה.

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

צעד אחר צעד

  1. הסוקר נכנס ללשונית Files changed, לוחץ על + ליד שורה וכותב הערה. בסוף לוחץ Review changes ובוחר Approve או Request changes.
  2. אתם מתקנים בענף עצמו. כל קומיט חדש שנדחף נכנס אוטומטית ל-PR:
    git add .
    git commit -m "Address review comments"
    git push
  3. כשהכל מאושר, לוחצים Merge pull request (או Squash and merge דרך החץ), ואז Confirm.
  4. אחרי המיזוג לוחצים Delete branch, ומעדכנים את המחשב:
    git switch main
    git pull
  5. אם כתוב שיש קונפליקטים, מביאים את main לענף ופותרים:
    git switch my-branch
    git merge main

מה אמור לקרות

כשהמיזוג מצליח ה-PR מקבל תג סגול Merged, ו-git pull ב-main מביא את הקומיט. בקונפליקט, גיט מדפיס CONFLICT (content): Merge conflict in notes.md, והקובץ מכיל סימנים: <<<<<<<, ======= ו->>>>>>>.

תרגיל

מזגו את ה-PR שפתחתם בפרק הקודם בשיטת Squash and merge, מחקו את הענף, והריצו git pull. אחר כך נסו ליצור קונפליקט בכוונה: שנו את אותה שורה בשני ענפים ומזגו.

בדקו את עצמכם

ה-PR כולל שמונה קומיטים קטנים של "fix typo", והוא שינוי לוגי אחד. מה מתאים?

בקובץ מופיעים הסימנים <<<<<<<. מה זה אומר?

סוקר בחר Request changes. מה עושים?

⚠ שגיאות נפוצות

  • פותרים קונפליקט אבל משאירים בקובץ את סימני <<<<<<<. מחפשים אותם לפני שמסיימים.

  • מוחקים את הענף לפני שווידאו שהמיזוג באמת נכנס ל-main.

  • ממזגים בלי להריץ את הפרויקט אחרי פתרון קונפליקט. תמיד בודקים שהתוצאה עובדת.

מקורות: About pull request reviews · About pull request merges · About merge conflicts

10

Issues: מי עושה מה

פרק 10 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

פתיחת Issue בממשק האמיתי.

מקרה שימוש

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

מה צריך להבין

Issue הוא משימה, באג או שאלה שמנוהלת בתוך הריפו. לכל Issue יש מספר (#12), כותרת, תיאור ותגובות.

מוסיפים לו Labels (תוויות), Assignees (אחראים), Milestone (יעד) ואפשר גם לקשר אותו ל-Project.

קישור לקוד: אם התיאור של ה-PR כולל Fixes #12, מיזוג ה-PR סוגר את ה-Issue אוטומטית. המילים שעובדות הן closes, fixes ו-resolves וצורותיהן.

מתי משתמשים ולמה זה חשוב

Issue מתאר עבודה שצריך לבצע

Issue טוב כולל בעיה, תוצאה רצויה ותנאי סיום שאפשר לבדוק. בבאג מוסיפים צעדי שחזור ומה קרה לעומת הצפוי, בלי מידע רגיש. Assignee מציין אחראי, Labels עוזרים לסנן ו-Milestone מקבץ יעד עבודה.

Issue אינו שינוי בקבצים. מקשרים אליו את ה-PR שמיישם אותו. Fixes #12 בתיאור PR סוגר את ה-Issue כשה-PR מתמזג לענף ברירת המחדל, לא מעצם פתיחתו.

צעד אחר צעד

  1. בדף הריפו נכנסים ללשונית Issues ולוחצים New issue.
  2. כותבים כותרת, למשל "קישור בתפריט מוביל לעמוד חסר". בתיאור מפרטים מה ראיתם, מה ציפיתם, ואיך משחזרים.
  3. בצד ימין: בוחרים Assignee, Labels (bug) ו-Milestone.
  4. לוחצים Submit new issue. הוא מקבל מספר.
  5. כשפותחים PR שמתקן אותו, כותבים בתיאור:
    Fixes #1

מה אמור לקרות

הדף של ה-Issue מציג סטטוס Open, את התוויות והאחראי. אחרי מיזוג PR עם Fixes #1 ה-Issue עובר ל-Closed אוטומטית, ובציר הזמן מופיעה שורה שמציינת איזה PR סגר אותו.

תרגיל

פתחו ב-git-practice שני Issues עם תוויות, אחד מהם עם Assignee. אחר כך פתחו PR שמתקן את אחד מהם עם Fixes ומספר, ומזגו. ודאו שהוא נסגר.

בדקו את עצמכם

איך סוגרים Issue אוטומטית כשמזגים PR?

מה תפקיד Labels?

מה כדאי לכתוב בתיאור של באג?

⚠ שגיאות נפוצות

  • כותבים "לא עובד" בלי פרטים. issue טוב כולל מה ניסיתם, מה קיבלתם, ומה ציפיתם שיקרה.

  • סוגרים issue בלי לקשר אותו ל-PR שפתר אותו. הקישור שומר את ההקשר למי שיגיע אחריכם.

  • פותחים issue כפול במקום לחפש קודם אם כבר קיים.

מקורות: Quickstart for GitHub Issues · Linking a pull request to an issue

11

Projects: לוח עבודה של הצוות

פרק 11 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם

מקרה שימוש

יש 20 Issues פתוחים. המנהל רוצה לראות מה בתהליך, מה מחכה ומה הסתיים.

מה צריך להבין

Project הוא לוח מעקב שמתחבר ל-Issues ול-PRs. אפשר להציג אותו כBoard (עמודות לפי סטטוס, למשל Todo, In Progress ו-Done), Table או Roadmap.

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

מתי משתמשים ולמה זה חשוב

הלוח הוא תמונת עבודה, לא מקור הקוד

Project מארגן Issues, בקשות שינוי וטיוטות בתצוגת טבלה או לוח. אפשר לקבץ לפי סטטוס ולסנן לפי אחראי. הוא יכול לכלול פריטים מכמה ריפואים, בהתאם להרשאות.

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

צעד אחר צעד

  1. בעמוד הפרופיל או הארגון נכנסים ל-Projects ולוחצים New project.
  2. בוחרים Board (או Table או Roadmap), נותנים שם, ויוצרים.
  3. מוסיפים פריטים: לוחצים Add item, מקלידים # ובוחרים Issue מהריפו.
  4. גוררים כרטיסים בין העמודות. סטטוס הכרטיס הוא שדה שאפשר לשנות גם מתוך ה-Issue.
  5. מוסיפים שדה: Settings, New field, למשל Priority.

מה אמור לקרות

לוח עם שלוש עמודות ברירת מחדל (Todo, In Progress, Done) וכרטיסים שמייצגים Issues. כשסוגרים Issue, הכרטיס שלו עובר ל-Done.

תרגיל

צרו Project מסוג Board, הוסיפו אליו את ה-Issues של git-practice, והעבירו אחד מהם ל-In Progress.

בדקו את עצמכם

מה ההבדל בין Issue ל-Project?

איזה תצוגה מתאימה למנהל שרוצה לראות סטטוס במבט?

פרויקט אחד צריך לכלול משימות משלושה ריפואים. האם אפשר?

מקורות: Quickstart for Projects

12

עבודת צוות: הרשאות ובעלי קוד

פרק 12 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

איפה מזמינים משתפי פעולה (ללא שליחת הזמנה).

מקרה שימוש

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

מה צריך להבין

Collaborator הוא משתמש שקיבל גישה לריפו. בריפו אישי מזמינים אנשים; בארגון אפשר לנהל גישה דרך Teams. נותנים רק את ההרשאות הנחוצות.

CODEOWNERS מקשר נתיב בקבצים לסוקרים שאחראים עליו. הוא אינו נועל קבצים ואינו מעניק הרשאות. הסוקרים צריכים להיות משתמשים או צוותים קיימים עם הרשאת כתיבה, והקובץ צריך להיות בענף הבסיס של ה-PR.

בקשת סקירה אינה חסימת מיזוג: כדי לחייב אישור צריך גם כלל הגנה מתאים. זמינות CODEOWNERS תלויה בתוכנית ובנראות הריפו; ב-Free הוא זמין בריפואים ציבוריים. אפשר לתרגל בקשת סקירה ידנית בלי לשדרג תוכנית.

מתי משתמשים ולמה זה חשוב

גישה, אחריות ואישור הם דברים שונים

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

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

צעד אחר צעד

  1. בעל הריפו נכנס ל-Settings ואז Collaborators ובוחר Add people. בודקים את שם המשתמש לפני שליחת הזמנה.
  2. השותף מאשר את ההזמנה ומוודא שהוא רואה את הריפו. לא משתפים סיסמאות.
  3. השותף עובד בענף חדש באותו ריפו, דוחף שינוי ופותח PR. בשדה Reviewers מבקשים סקירה.
  4. אם התכונה זמינה, יוצרים .github/CODEOWNERS. בדוגמה הבאה מחליפים את השם במשתמש אמיתי עם הרשאת כתיבה:
    # Responsible reviewer for documentation
    /docs/ @YOUR-REVIEWER
    /.github/CODEOWNERS @YOUR-REVIEWER
  5. ממזגים את קובץ ההגדרות לענף הבסיס. בודקים PR חדש שאינו Draft ומשנה קובץ בתיקיית docs.

מה אמור לקרות

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

תרגיל

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

בדקו את עצמכם

שותף לא מצליח לדחוף לריפו הפרטי של הצוות. מה בודקים?

מה CODEOWNERS עושה?

הזמנתם Collaborator, אך הוא לא רואה את הריפו. מה כנראה חסר?

מקורות: Inviting collaborators to a personal repository · About code owners · About organizations

13

GitHub Actions: אוטומציה בתוך הריפו

פרק 13 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

יצירת workflow והרצה ראשונה, בממשק האמיתי.

מקרה שימוש

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

מה צריך להבין

Actions היא מערכת אוטומציה של גיטהאב. מגדירים Workflow בקובץ YAML בתיקייה .github/workflows. הקובץ אומר מה מפעיל אותו (on), על איזה שרת הוא רץ (runs-on) ומה השלבים (steps).

ה-Workflow רץ על שרת ש-GitHub מספק. Actions חינמי בריפואים ציבוריים. בריפואים פרטיים יש מכסת דקות חינמית ומעבר לה יש חיוב, ולכן בדקו את התוכנית לפני שמפעילים הרבה.

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

מתי משתמשים ולמה זה חשוב

אוטומציה לפי אירוע ותנאי הצלחה

Workflow הוא קובץ YAML בתוך .github/workflows. השדה on קובע את האירוע, jobs מגדיר עבודות ו-steps את הצעדים. ב-workflow שמתארח אצל GitHub ה-Runner הוא מחשב שמבצע את העבודה, לא המחשב שלכם. למשל: בדיקת בנייה אחרי PR.

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

צעד אחר צעד

  1. בדף הריפו לוחצים Add file, ואז Create new file, ונותנים את השם .github/workflows/demo.yml.
  2. מדביקים:
    name: Demo
    on: [push]
    jobs:
      check:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v6
          - run: echo "Branch is ${{ github.ref }}"
          - run: ls -la
  3. לוחצים Commit changes. הקומיט עצמו הוא push, ולכן ה-Workflow רץ.
  4. נכנסים ללשונית Actions, פותחים את הריצה האחרונה, ולוחצים על ה-Job כדי לראות את הלוג.

מה אמור לקרות

בלשונית Actions מופיעה ריצה עם סימן ירוק (הצלחה) או אדום (כישלון). בלוג רואים כל שלב, והשורה Branch is refs/heads/main ורשימת קבצי הריפו. אם יש שגיאה, השלב הכושל מסומן באדום וההודעה נמצאת בתוכו.

תרגיל

שנו את הקובץ כך שהשלב האחרון יהיה echo עם ההודעה "Hello from Actions", שמרו, וצפו בריצה החדשה. אחר כך שנו את הפקודה ל-exit 1 כדי לראות איך נראית ריצה שנכשלה, והחזירו.

בדקו את עצמכם

איפה חייבים לשמור קובץ Workflow כדי שגיטהאב יריץ אותו?

מה עושה השורה on: [push]?

מה עושים כשריצה נכשלת?

⚠ שגיאות נפוצות

  • כותבים סיסמה או מפתח ישירות בקובץ ה-yaml. סודות שומרים ב-Secrets ומשתמשים בהם עם ${{ secrets.NAME }}.

  • שמים את הקובץ במקום הלא נכון. הוא חייב לשבת בתיקייה .github/workflows ולהסתיים ב-.yml.

  • מניחים שהריצה נכשלה בגלל הקוד. פותחים את לוג הריצה וקוראים את השגיאה האדומה הראשונה.

מקורות: Quickstart for GitHub Actions

14

GitHub Pages: מפרסמים אתר מהריפו

פרק 14 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

הפעלת Pages מהענף main.

מקרה שימוש

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

מה צריך להבין

Pages לוקח קבצי HTML, CSS ו-JavaScript מהריפו ומפרסם אותם כאתר. אפשר גם להריץ תהליך בנייה לפני.

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

אתר שנקרא USER.github.io הוא אתר המשתמש. בכל ריפו אחר הכתובת היא USER.github.io/REPO.

מתי משתמשים ולמה זה חשוב

Pages מפרסם אתר סטטי, לא שרת לכל יישום

Pages מתאים ל-HTML, CSS ו-JavaScript ולתוצרים סטטיים. הוא אינו מריץ שרת Python או מסד נתונים עבורכם. JavaScript בדפדפן גלוי למבקר, ולכן לא מכניסים לתוכו סוד.

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

צעד אחר צעד

  1. בריפו ציבורי מוסיפים קובץ index.html:
    <!doctype html>
    <html lang="he" dir="rtl">
    <meta charset="utf-8">
    <title>הדף הראשון שלי</title>
    <h1>שלום מגיטהאב</h1>
  2. נכנסים ל-Settings, בצד ימין בוחרים Pages.
  3. תחת Build and deployment, ב-Source בוחרים Deploy from a branch, ובענף בוחרים main והתיקייה root. שומרים.
  4. ממתינים ורעננים את דף ה-Pages. מופיעה הכתובת של האתר.

מה אמור לקרות

בדף Settings, Pages מופיעה הודעה "Your site is live at ..." עם כתובת. פתיחת הכתובת מציגה את הדף. לפי התיעוד, העלאה ראשונה או שינוי יכולים להימשך עד 10 דקות, ובפועל זה בדרך כלל מהיר יותר.

תרגיל

פרסמו דף index.html קטן מריפו ציבורי, ושלחו את הקישור לחבר. אחר כך שנו כותרת, עשו קומיט, וצפו בשינוי מתעדכן.

בדקו את עצמכם

אתם שומרים בריפו פרטי מסמך עם נתוני לקוחות ומפעילים Pages. מה נכון?

איפה מפעילים Pages?

שיניתם קובץ והאתר עדיין ישן. מה הסבירות?

⚠ שגיאות נפוצות

  • בוחרים בהגדרות ענף או תיקייה שגויים, והאתר מציג 404. בודקים שוב ב-Settings ← Pages.

  • כותבים נתיבים שמתחילים ב-/, ואלה נשברים באתר של ריפו. נתיבים יחסיים כמו media/x.png עובדים גם תחת תת-כתובת.

  • מצפים שהשינוי יופיע מיד. פרסום לוקח דקה-שתיים, ולפעמים צריך רענון קשיח של הדפדפן.

מקורות: Quickstart for GitHub Pages · What is GitHub Pages?

15

אבטחה: טוקנים, סודות והגנה על main

פרק 15 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם▶ כולל סרטון דמו

▶ הדגמה על הממשק האמיתי

טופס Token (לא נשלח), Secrets ו-Rulesets: צפייה בלבד.

מקרה שימוש

מישהו הדביק בטעות מפתח גישה בקובץ ודחף אותו, או שמישהו דחף שינוי ישירות ל-main בלי שאף אחד ראה.

מה צריך להבין

Personal Access Token (PAT) הוא מפתח שמחליף סיסמה בסקריפטים ובכלים. גיטהאב ממליץ על Fine-grained tokens: בוחרים ריפואים מסוימים, הרשאות מינימליות ותפוגה. שמרו אותו כמו סיסמה, והוא מוצג פעם אחת בלבד.

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

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

Rulesets מגדירים חוקים על ענפים, למשל לחייב Pull Request ואישור לפני מיזוג ל-main. כך אי אפשר לדחוף ישירות.

סוד שנחשף כבר נחשב דלוף. מבטלים (Revoke) אותו מיד ויוצרים חדש, ולא מסתפקים במחיקה מהקובץ.

מתי משתמשים ולמה זה חשוב

מפתח גישה אינו חלק מהפרויקט

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

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

צעד אחר צעד

  1. יצירת טוקן: תמונת הפרופיל, Settings, Developer settings, Personal access tokens, Fine-grained tokens, Generate new token.
  2. נותנים שם, בוחרים תפוגה קצרה, ב-Repository access בוחרים ריפואים מסוימים בלבד, ובהרשאות רק את הנדרש (למשל Contents: Read).
  3. לוחצים Generate token, ומעתיקים אותו מיד לכספת סיסמאות. אחרי שסוגרים את הדף לא רואים אותו שוב.
  4. סוד ל-Workflow: בריפו Settings, Secrets and variables, Actions, New repository secret. ב-Workflow מפנים אליו כך:
    env:
      API_KEY: ${{ secrets.API_KEY }}
  5. הגנה על main: ב-Settings של הריפו פותחים את Rules ואת Rulesets, יוצרים ruleset חדש שמכוון לענף main ומפעילים חוק שמחייב Pull Request לפני מיזוג. זמינות הפיצ׳ר בריפו פרטי תלויה בתוכנית, ולכן בדקו מה מוצג אצלכם.

מה אמור לקרות

בדף הטוקנים מופיע הטוקן שיצרתם עם תפוגה והרשאות. ב-Secrets מופיע שם הסוד בלי הערך. אחרי הפעלת ruleset, ניסיון push ישיר ל-main נדחה עם הודעה שהענף מוגן ושנדרש Pull Request.

תרגיל

צרו Fine-grained token לריפו git-practice בלבד, עם Contents: Read ותפוגה של 7 ימים, ומחקו אותו מיד אחרי שראיתם איך הוא נראה. אחר כך הוסיפו סוד בשם TEST_SECRET לריפו.

בדקו את עצמכם

הדבקתם טוקן בקובץ ודחפתם לגיטהאב. מה הצעד הראשון?

איזה טוקן עדיף לפי גיטהאב?

איך משתמשים במפתח API בתוך Workflow בצורה בטוחה?

⚠ שגיאות נפוצות

  • שומרים טוקן בתוך קוד או בקובץ בריפו. טוקן שדלף מבטלים מיד ומנפיקים חדש.

  • נותנים לטוקן את כל ההרשאות. מספיקות ההרשאות המינימליות לצורך המדויק.

  • יוצרים טוקן בלי תאריך תפוגה. תוקף מוגבל מקטין נזק אם הטוקן דולף.

מקורות: Managing your personal access tokens · Using secrets in GitHub Actions · About secret scanning · About rulesets

16

סיכום: יום עבודה אחד, מההתחלה ועד הסוף

פרק 16 מתוך 17
כ-4 דקות קריאה · התרגול בקצב שלכם

מקרה שימוש

חבר חדש בצוות שואל "איך אני עובד כאן?". זה הסיכום שלכם בעמוד אחד.

מה צריך להבין

כל שינוי, קטן או גדול, עובר אותה דרך. היא נשארת אותה דרך גם כשהפרויקט גדל.

מתי משתמשים ולמה זה חשוב

מסלול אחד שמחבר בין הכלים

מתחילים ב-Issue עם תנאי סיום, מעדכנים main ופותחים ענף. בודקים diff ושומרים קומיטים קטנים. Push משתף אותם, PR מרכז סקירה ובדיקות מוסיפות ראיות לפני המיזוג.

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

צעד אחר צעד

  1. מתחילים מ-main מעודכן ופותחים ענף:
    git switch main
    git pull
    git switch -c short-description
  2. עורכים ושומרים קומיטים קטנים עם הודעות ברורות:
    git status
    git add .
    git commit -m "What changed and why"
  3. שולחים ופותחים Pull Request:
    git push -u origin short-description
  4. מגיבים להערות עם קומיטים נוספים לאותו ענף, ואחרי אישור ממזגים ומוחקים את הענף.
  5. חוזרים ל-main ומתעדכנים:
    git switch main
    git pull

מה אמור לקרות

main מכיל את השינוי, ה-PR סגור (Merged), ה-Issue המקושר סגור, והענף נמחק. בהיסטוריה (git log --oneline) רואים קומיט עם ההודעה שלכם.

תרגיל

עברו על כל המסלול פעם אחת ב-git-practice: Issue, ענף, קומיט, Push, PR עם Fixes, מיזוג, ובדיקה שה-Issue נסגר. זה התרגיל המסכם.

בדקו את עצמכם

מה הצעד הראשון לפני שמתחילים לעבוד על שינוי חדש?

איפה מתנהל הדיון על שינוי?

אחרי מיזוג ה-PR, מה עושים?

מקורות: GitHub flow

17

מבחן מסכם: מה כבר יודעים לעשות

פרק 17 מתוך 17
15 שאלות תרחיש · כ-15 דקות · ללא הגבלת זמן

בודקים הבנה, לא שינון

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

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

0 מתוך 15 נענו