בחירת שרת Git עצמאי: Forgejo, Gitea או cgit
השוואת ארבע אפשרויות להקמת שרת Git עצמאי לפי צריכת RAM. גלו אילו פתרונות מתאימים לשרת VPS עם 1GB זיכרון, החל ממאגרי SSH פשוטים ועד להתקנות מורכבות של GitLab.
איזה שרת Git בניהול עצמי כדאי להריץ
שרת Git בניהול עצמי אינו מוצר יחיד, והזיכרון (RAM) בשרת ה-VPS שלכם יקבע איזו גרסה תוכלו להריץ. Git אינו זקוק ל-daemon משלו: מאגר (repository) מסוג bare יחד עם חשבון SSH הם כל מה שצריך כדי להקים שרת עובד על השרת הקטן ביותר שניתן לשכור. כל מה שמעבר לכך הוא יישום אינטרנט שאתם בוחרים להריץ לצד ה-Git, וכל עלייה ברמת המורכבות דורשת זיכרון שייתכן שאין ב-VPS קטן. אם אינכם בטוחים היכן מסתיים Git והיכן מתחיל GitHub, המדריך מה ההבדל בין Git, GitHub ושרת Git עצמאי מבהיר את ההפרדה הזו לפני שתבחרו את רמת השירות שלכם.
ישנם ארבעה שלבים. מאגר bare מעל SSH, ללא שום תהליך מאזין נוסף מעבר למה שכבר רץ. cgit, ממשק אינטרנט מהיר לקריאה בלבד ללא מסד נתונים. Forgejo או Gitea, פלטפורמת ניהול מלאה הכוללת חשבונות, ניהול משימות (issues) ו-pull requests, הצורכת כמה מאות מגה-בייט. GitLab, הדורש שרת גדול פי כמה מהאפשרויות האחרות.
החליטו לפי העבודה שאתם צריכים לבצע, ולאחר מכן השוו את דרישות הזיכרון לתוכנית האירוח שאתם משלמים עליה.
כמה זיכרון RAM דורשת כל אפשרות בפועל
רק שניים מהפרויקטים הללו מפרסמים נתוני חומרה. התייחסו לנתון מפורסם כאל רף מינימלי ולא כאל הבטחה, ומדדו את המופע שלכם לאחר שהוא רץ, בעזרת systemd-cgtop או ps -o rss= -C forgejo.
הנתונים שמאחורי התרשים
[
{
"label": "Gitea, small team",
"ram_gb": 1
},
{
"label": "GitLab, memory constrained",
"ram_gb": 8
},
{
"label": "GitLab, single node baseline",
"ram_gb": 16
}
]Gitea מתעדת 1 GB של זיכרון RAM עם 2 ליבות CPU ככמות שמספיקה בדרך כלל לצוותים ופרויקטים קטנים, ומציינת ש-Raspberry Pi 3 מספיק לעומסי עבודה קטנים. GitLab מתעדת 16 GB כבסיס להתקנת צומת בודד, ו-8 GB כרף התחתון למה שהדף שלה מגדיר כסביבה מוגבלת בזיכרון. תיעוד ההתקנה של Forgejo לא מספק נתון RAM. מדובר ב-fork של Gitea והוא מתנהג באופן דומה, לכן הנתון של Gitea הוא המדריך המפורסם הקרוב ביותר שיש לכם.
המשמעות של זה בשרת VPS עם 1 GB זיכרון: מאגרים (repositories) חשופים ו-cgit יתאימו ויישאר מקום פנוי, כיוון שאף אחד מהם לא מריץ שירות תושב (resident service). Forgejo או Gitea יתחילו וישרתו צוות קטן על גבי SQLite, אך אתם יושבים על הרף המינימלי המתועד, לכן השאירו את PostgreSQL ואת ה-runner של ה-CI (אינטגרציה רציפה) מחוץ לשרת הזה. אם ממשק האינטרנט נעלם ללא שגיאה, הריצו את sudo dmesg -T | grep -Ei 'oom|out of memory|killed process' וחפשו שורה כמו Out of memory: Killed process 1181 (forgejo), שמשמעותה היא שה-kernel out of memory killer סיים את התהליך. GitLab על שרת עם 1 GB אינו בעיית כוונון. הוא פשוט לא ירוץ.
Tier 0: מאגר נתונים בסיסי (bare) על גבי SSH
ל-Git אין daemon רשת שצריך להפעיל. git push מעל SSH מריץ git-receive-pack בצד המרוחק כתהליך Unix רגיל, לכן כל חשבון שניתן לגשת אליו באמצעות מפתח הוא כבר Git remote. צרו חשבון אחד עבור מאגרי הנתונים, ושמרו את המאגרים מחוץ לתיקיית הבית שלו, כדי שצפייה דרך האינטרנט שתוסיפו בעתיד לא תדרוש גישה לתיקיית הבית הזו.
sudo adduser --system --shell /bin/bash --gecos 'Git Version Control' \
--group --disabled-password --home /home/git git
sudo install -d -m 0755 -o git -g git /srv/git
sudo -u git git init --bare /srv/git/project.git--bare יוצר מאגר ללא עותק עבודה (working copy), וזה מה ששרת אמור להחזיק. דחיפה (push) לענף שנמצא בשימוש במאגר שיש לו עותק עבודה נדחית כברירת מחדל עם refusing to update checked out branch: refs/heads/main, וזו הטעות הנפוצה ביותר ברמה זו.
כעת העניקו לחשבון מפתח ושכפלו (clone) אותו.
sudo -u git install -d -m 700 /home/git/.ssh
sudo -u git tee -a /home/git/.ssh/authorized_keys <<'EOF'
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIexamplekeyhere alice@laptop
EOF
sudo -u git chmod 600 /home/git/.ssh/authorized_keysgit remote add origin git@vps.example.com:/srv/git/project.git
git push -u origin mainדחיפה ראשונה שהצליחה מסתיימת ב-* [new branch] main -> main. דחיפה שמסתיימת ב-git@vps.example.com: Permission denied (publickey) לא עברה אימות, לכן קראו את לוג השרת בעזרת sudo journalctl -u ssh -n 20. שורה המכילה Authentication refused: bad ownership or modes for file /home/git/.ssh/authorized_keys מציינת שהבעלות או הרשאות הקובץ שגויות, כיוון ש-sshd דוחה קובץ מפתח עם בעלים לא מהימנים או הרשאות המאפשרות למשתמשים אחרים לכתוב אליו.
אם ה-origin של הפרויקט כבר מצביע על GitHub, הפקודה git remote add origin תיעצר עם error: remote origin already exists., ו-הוספת שרת זה ככתובת דחיפה שנייה באותו remote תאפשר ל-git push לעדכן את שניהם.
לאחר מכן, בטלו את הגישה ל-shell עבור החשבון.
command -v git-shell | sudo tee -a /etc/shells
sudo chsh -s "$(command -v git-shell)" gitgit-shell מקבל רק את הפקודות המעטות ש-Git שולח מעל SSH, לכן התחברות אינטראקטיבית תיעצר כעת עם הודעה במקום להציג שורת פקודה:
fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.זהו השרת כולו. אין מסד נתונים ואין תהליך אינטרנטי שצריך לעדכן. מה שאתם מוותרים עליו הוא כל מה שפלטפורמת ניהול קוד (forge) מספקת: אין דפדפן קבצים, אין מערכת לניהול משימות (issue tracker), אין pull requests, ואין הרשאות ברמת המשתמש. כל מפתח בקובץ זה יכול לקרוא ולכתוב לכל מאגר שנמצא בבעלות המשתמש git.
דרגה 1: cgit מספק תצוגת אינטרנט ללא מסד נתונים
cgit היא תוכנית CGI (Common Gateway Interface) הכתובה בשפת C. שרת האינטרנט מריץ אותה פעם אחת עבור כל בקשה; היא קוראת את המאגרים ישירות מהדיסק ואינה שומרת מצב משל עצמה. בגרסה Ubuntu 24.04 היא זמינה ברכיב ה-universe.
sudo apt update
sudo apt install -y cgit fcgiwrap nginx
sudo install -d -o www-data -g www-data /var/cache/cgitהצביעו על ספריית המאגרים בתוך /etc/cgitrc:
root-title=Git on example.com
css=/cgit.css
logo=/cgit.png
cache-size=1000
cache-root=/var/cache/cgit
snapshots=tar.gz zip
scan-path=/srv/gitscan-path סורק את הספרייה הזו ומציג כל מאגר שהוא מוצא, כך שמאגר bare חדש מופיע ללא צורך בתצורה נוספת. cache-size הוא מספר הדפים השמורים במטמון, והמטמון נשאר כבוי כל עוד הערך הוא אפס. קראו את מה שהחבילה שלכם כבר הציבה ב-/etc/cgitrc לפני שתוסיפו שורות, שכן חבילות Debian ו-Ubuntu כוללות הגדרות ברירת מחדל משלהן.
כל רשומה מציגה את השורה הראשונה של קובץ ה-description של המאגר, לכן מאגר bare חדש יציג את עצמו כ-Unnamed repository; edit this file 'description' to name the repository.. תקנו זאת פעם אחת עבור כל מאגר:
echo 'Project X, internal tooling' | sudo -u git tee /srv/git/project.git/descriptionקובץ האתר של nginx, וכיצד לבדוק אותו
server {
listen 80;
server_name git.example.com;
root /usr/share/cgit;
try_files $uri @cgit;
location @cgit {
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME /usr/lib/cgit/cgit.cgi;
fastcgi_param PATH_INFO $uri;
fastcgi_param QUERY_STRING $args;
fastcgi_param HTTP_HOST $server_name;
fastcgi_pass unix:/run/fcgiwrap.socket;
}
}sudo systemctl enable --now fcgiwrap.socket
sudo nginx -t && sudo systemctl reload nginx
systemctl show fcgiwrap.socket -p Listenroot /usr/share/cgit מגיש את cgit.css ואת cgit.png כקבצים רגילים, ו-try_files מעביר את כל השאר ל-CGI בכתובת /usr/lib/cgit/cgit.cgi. דף 502, עם connect() to unix:/run/fcgiwrap.socket failed (2: No such file or directory) בתוך /var/log/nginx/error.log, מציין שיחידת ה-socket אינה רצה או שהיא מאזינה בנתיב אחר. השורה systemctl show מדפיסה את הנתיב שבו היא משתמשת בפועל.
כדאי להכיר שתי מגבלות לפני שמסתמכים על פתרון זה. cgit הוא לקריאה בלבד ואין בו אפשרות התחברות בתצורה זו, לכן כל מה שנמצא תחת scan-path הוא ציבורי: הרחיקו מאגרים פרטיים מספרייה זו, או הוסיפו אימות HTTP בסיסי (basic authentication) לפני האתר כולו. בנוסף, ה-CGI רץ תחת המשתמש של שרת האינטרנט, לכן משתמש זה זקוק להרשאות מעבר ב-/srv/git ולקריאה של כל מאגר. ספרייה שהמשתמש אינו יכול להיכנס אליה תופיע כאינדקס ריק במקום כהודעת שגיאה.
שכבה 2: Forgejo או Gitea לניהול Issues ו-Pull Requests
Forgejo ו-Gitea מבוססים על אותו רעיון: קובץ binary יחיד של Go שמריץ פלטפורמת פיתוח (forge) עם משתמשים, ארגונים, Issues, Pull Requests, גרסאות (releases), מאגר חבילות ומערכת CI מובנית. ה-binary יחד עם SQLite מהווים את כל ההתקנה, וזו הסיבה שהם מתאימים לחומרה ש-GitLab לא תרוץ עליה. קובץ ה-Compose להלן הוא זה המופיע בתיעוד של Forgejo, עם תגית ה-image המצוינת נכון ל-24 באוקטובר 2026.
networks:
forgejo:
external: false
services:
server:
image: codeberg.org/forgejo/forgejo:17
container_name: forgejo
environment:
- USER_UID=1000
- USER_GID=1000
restart: always
networks:
- forgejo
volumes:
- ./forgejo:/data
- /etc/localtime:/etc/localtime:ro
ports:
- '3000:3000'
- '222:22'תגית ה-17 הזו עוקבת אחר סדרת v17. הגרסה Forgejo v17.0.1, ששוחררה ב-26 באוקטובר 2026, היא הגרסה היציבה הנוכחית, ו-Forgejo תומכת ב-v17 עד ה-28 בינואר 2027. סדרת v16 הישנה איבדה תמיכה ב-29 באוקטובר 2026, לכן התקנה קיימת שעדיין נמצאת על תגית 16 צריכה לעבור שדרוג כעת. מעבר מגרסה ראשית אחת לבאה אחריה בשלב מאוחר יותר הוא שדרוג ידני, לכן זול יותר להתחיל מהגרסה הנוכחית.
docker compose up -d
docker compose ps
curl -sI http://127.0.0.1:3000 | head -1השורה curl אמורה להדפיס שורת סטטוס HTTP. לפני שתסיימו את הגדרות ההרצה הראשונה, ייתכן שתקבלו הפניה ל-/install, שעדיין מעידה על כך שהשירות פעיל. אם המכולה (container) נסגרת במקום זאת, הסיבה הנפוצה היא בעיית בעלות: ספריית ./forgejo חייבת להיות שייכת ל-UID (מזהה משתמש) ב-USER_UID, אחרת התהליך לא יוכל לכתוב לספריית הנתונים שלו. Docker Compose על גבי VPS מכסה את מבנה הקבצים הזה ואת כלל הבעלות על ה-volumes במלואו.
שתי תשובות בדף ההגדרה קובעות אם כתובות ה-clone יעבדו. פורט ה-SSH חייב להיות הצד של ה-host במיפוי ה-SSH, שבקובץ ה-Compose לעיל הוא 222, מכיוון שהוא ממפה את פורט 222 של ה-host לפורט 22 של המכולה. שום דבר לא מחייב דווקא את 222: כל פורט פנוי ב-host יעבוד, כל עוד המיפוי והתשובה הזו תואמים. כמו כן, ה-domain חייב להיות השם שאנשים באמת יקלידו. אם תטעו באחד מהם, כל דף מאגר יציג פקודת clone שתיכשל עבור כל מי שיעתיק אותה. שניהם נמצאים לאחר מכן בסעיף [server] של app.ini, בתור SSH_PORT, SSH_DOMAIN ו-ROOT_URL.
עבור מופע ציבורי, פרסמו את פורט ה-web על כתובת ה-loopback בלבד ('127.0.0.1:3000:3000') והציבו לפניו nginx עבור TLS (אבטחת שכבת תעבורה). Gitea מותקנת באותה דרך מ-image ה-docker.gitea.com/gitea שבו משתמש התיעוד שלה, או כ-binary יחיד עם יחידת systemd אחת ו-app.ini אחד. הגרסה היציבה הנוכחית שלה היא v28.3.0, שפורסמה ב-1 בנובמבר 2026. עם v28.0.0 בסוף ספטמבר, הפרויקט הסיר את הקידומת הישנה 1., כך שהגרסה שאחרי 1.27 היא 28, ולא 1.28.
הישארו עם SQLite כל עוד אתם יכולים. הוא שומר על המופע כתהליך אחד וקובץ אחד, והוא שורד אתחול ללא צורך בשירות נוסף לניטור. PostgreSQL מצדיק את העלות שלו כאשר כמה אנשים כותבים בו-זמנית, מכיוון ש-SQLite מבצע סריאליזציה לכתיבות והרצות CI ארוכות כותבות ללא הרף. שני הפרויקטים יכולים להעביר מופע קיים ל-PostgreSQL בשלב מאוחר יותר, כך שזו לא החלטה שאתם תקועים איתה.
Forgejo או Gitea: מה ההבדל בפועל
השושלת משותפת. Gitea פוצלה מ-Gogs בשנת 2016. בסוף 2022 השליטה על ה-domain והסימן המסחרי של Gitea עברה לחברה, Gitea Ltd, ומספר מתחזקים יחד עם Codeberg הקימו את Forgejo. Forgejo מפותחת על ידי הקהילה שלה תחת המטריה של Codeberg e.V., עמותה ללא מטרות רווח הרשומה בגרמניה שמחזיקה ב-domains של הפרויקט, בעוד שהניהול נשאר בידי התורמים של Forgejo עצמה. היא עברה מרישיון MIT ל-GPLv3 (הרישיון הציבורי הכללי של GNU גרסה 3) בשנת 2024. Gitea נשארת תחת רישיון MIT ומפותחת עם תמיכה מסחרית מאחוריה.
ביום-יום, קבוצות התכונות קרובות מאוד. המסלול ביניהן אינו כזה. Forgejo v10.0, מינואר 2025, הייתה הגרסה האחרונה שיכלה לקלוט מסד נתונים של Gitea ישירות, ורק מ-Gitea v1.22 ומטה. Gitea נמצאת בגרסה v28.3.0 נכון ל-2 בנובמבר 2026, כך שלמופע Gitea נוכחי אין מעבר נתמך ישיר ל-Forgejo. בחרו אחד לפני שאתם ממלאים אותו בנתונים, והתייחסו לכל מעבר מאוחר יותר כאל ייצוא וייבוא מחדש.
כלל קצר לבחירה. אם ממשל חשוב לכם, או אם אתם רוצים פרויקט תחת מטרייה של ארגון ללא כוונת רווח, הפעילו את Forgejo. אם אתם רוצים בסיס התקנות רחב יותר ואפשרות לתמיכה מסחרית, הפעילו את Gitea. שני הפרויקטים מתוחזקים באופן פתוח ומפרסמים גרסאות לעיתים קרובות: Forgejo מפרסם גרסה יציבה מדי שלושה חודשים וגרסת LTS (long term support) מדי שנה. נכון ל־29 October 2026, הגרסה הנוכחית היא v17.0.1 ו־v15.0.11 היא גרסת ה־LTS. Forgejo תומך ב־v17 עד 28 January 2027 וב־v15 עד 15 July 2027, בעוד שהתמיכה ב־v16 הסתיימה ב־29 October 2026. לכן, בדקו את דף הגרסאות לפני שאתם מקבעים גרסה ראשית. אם אף אחד מהכללים האלה אינו מכריע, ההשוואה המלאה בין Forgejo ל־Gitea מפרטת את ההבדלים בין ה־Actions שלהם ובין מאגרי החבילות שלהם. זהו הפרט שחשוב להכריע בו לפני שהנתונים שלכם יהפכו מעבר ביניהם ליקר.
דרגה 3: העלות של GitLab לפני שמתחילים לעבוד
GitLab CE היא מחלקה אחרת של תוכנה. מופע (instance) אחד הוא אוסף של שירותים הפועלים יחד: Puma עבור יישום ה-web, Sidekiq עבור משימות רקע, PostgreSQL, Redis, Gitaly עבור גישה למאגרים, ו-nginx בחזית. חבילת ה-Omnibus מתקינה את כולם יחד, מה שהופך את ההתקנה לפשוטה ואת רף צריכת הזיכרון לגבוה.
דף הדרישות של GitLab מגדיר 16 GB של RAM ו-8 vCPU כבסיס להתקנה על צומת יחיד, כאשר 8 GB מצוינים כרף תחתון בסביבות מוגבלות זיכרון. אותו דף מנחה לבטל את ה-swap, כיוון שביצוע swap תחת עומס פוגע משמעותית בביצועי המופע. אלו הנתונים הרשמיים נכון לאוקטובר 2026, והם עלו עם השנים, לכן יש לעיין בדף שוב לפני קביעת גודל השרת.
בתמורה למשאבים אלו מקבלים יכולות ממשיות: registry למכולות, registry לחבילות, הרשאות מפורטות ו-CI שנבדק בהיקפים גדולים; מרכז הציות (compliance center) ונתיבי ביקורת (audit trails) ברמת פרויקט או קבוצה דורשים מנוי בתשלום של GitLab. אם אף אחד בצוות שלכם לא יכול לציין פריט מהרשימה הזו שהם זקוקים לו ברבעון הנוכחי, אתם משלמים על VPS גדול יותר מבלי לקבל דבר בתמורה.
מודל הגישה ב-SSH: משתמש git אחד ומפתחות רבים
במערכת OpenSSH, כל השכבות כאן מאמתות את המשתמש באותה הדרך. קיים חשבון Unix אחד בשם git, וכל מפתח ציבורי מוכנס לקובץ ~/.ssh/authorized_keys של אותו חשבון. האימות מתבצע באמצעות המפתח. ההרשאות נקבעות לפי האפשרויות שאתם כותבים לפני המפתח באותה שורה.
שורה פשוטה של מפתח מעניקה למחזיק בו את כל ההרשאות שיש לחשבון זה. עבור חשבון שעדיין משתמש ב-/bin/bash כ-login shell שלו, פקודה מאולצת (forced command) מצמצמת את הגישה ל-Git בלבד:
restrict,command="git-shell -c \"$SSH_ORIGINAL_COMMAND\"" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIexamplekeyhere alice@laptopהפקודה restrict, הזמינה החל מגרסה OpenSSH 7.2, מכבה את העברת הפורטים (port forwarding), העברת הסוכן (agent forwarding), וכן הקצאת X11 ו-PTY (מסוף מדומה) במילה אחת. הפקודה command= מחליפה את כל מה שהלקוח ביקש בפקודה שאתם מציינים, ו-Git עדיין עובד מכיוון ששרת ה-SSH מציב את הפקודה המקורית של הלקוח בתוך $SSH_ORIGINAL_COMMAND.
מערכת ניהול מאגרים (forge) כותבת את הקובץ הזה עבורכם, וזהו ההבדל האמיתי בין שכבה 0 לשכבה 2. כאשר הן פועלות מאחורי שרת ה-OpenSSH של המערכת, שהוא ברירת המחדל שלהן, Forgejo ו-Gitea כותבות מחדש את authorized_keys עם שורה אחת לכל מפתח רשום, כאשר כל שורה נושאת פקודה מאולצת המזהה את המפתח לפי ה-id שלו במסד הנתונים:
command="/usr/local/bin/forgejo --config=/etc/forgejo/app.ini serv key-3",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty,no-user-rc,restrict ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIexamplekeyhere aliceהפקודה המאולצת הזו היא הדרך שבה חשבון Unix משותף הופך להרשאות פרטניות לכל משתמש: key-3 מודיע למערכת הניהול איזה משתמש מתחבר, והיא בודקת את המשתמש מול המאגר לפני שמתבצעת העברת אובייקטים כלשהי. אל תערכו ידנית את הקובץ הזה בשרת שמנוהל על ידי מערכת ניהול, מכיוון שהוא נכתב מחדש מתוך מסד הנתונים והשורה שלכם תימחק. אם אתם מפעילים את שרת ה-SSH המובנה של מערכת הניהול, או גורמים ל-OpenSSH לבקש ממנה מפתחות דרך AuthorizedKeysCommand, מערכת הניהול אינה זקוקה לקובץ הזה כלל, ושני הפרויקטים ממליצים לכבות את יצירתו במקרה השני. מפתחות פריסה (deploy keys) מגיעים מאותו מנגנון: מפתח פריסה הוא מפתח SSH רגיל הרשום עבור מאגר בודד, בדרך כלל לקריאה בלבד, כאשר הבדיקה מתבצעת במערכת הניהול במקום ב-sshd.
שני הרגלים חשובים יותר מכל הגדרה שצוינה לעיל. הנפיקו מפתח אחד לכל אדם או לכל מכונה, לעולם אל תשתמשו במפתח משותף, מכיוון שביטול מפתח משותף מחייב החלפה שלו עבור כולם בבת אחת. הסירו מפתחות ביום שבו מישהו עוזב, שכן מפתח ישן בקובץ הזה הוא גישה קבועה שאף אחד לא מנטר. ניהול תקין של מפתחות SSH בשרת מכסה סוגי מפתחות וסיסמאות, וכל האמור שם תקף גם כאן ללא שינוי. אם השרת חדש, עשר הדקות הראשונות ב-VPS חדש הוא הצעד הנכון לביצוע לפני שאתם מציבים עליו מאגרים.
האם ניתן להריץ GitHub Actions על שרת Git עצמאי?
ניתן להריץ תהליכי עבודה (workflows) הכתובים בתחביר של GitHub Actions. לא ניתן להריץ את GitHub עצמו. התכונה Forgejo Actions זמינה כברירת מחדל החל מגרסה Forgejo v1.21 והיא קוראת קובצי workflow מתוך .forgejo/workflows בכל מאגר. Gitea Actions פועל באותו אופן וקורא מתוך .gitea/workflows. שניהם דורשים תוכנה נוספת, ה-runner, המותקנת ורשומה מול המופע (instance) שלכם באמצעות אסימון (token) מהגדרות הניהול. פעולות (actions) רבות שפורסמו ירוצו ללא שינוי.
היערכו לשתי השלכות. עם תוויות ה-container הרגילות, ה-runner מפעיל container עבור כל משימה, ולכן הוא זקוק למנוע container ולתקציב זיכרון משלו; זו הסיבה שהוא אינו אמור לשבת על אותו שרת של 1 GB שעליו רץ ה-forge. שני ה-runners יכולים גם להריץ משימות ישירות על ה-host, באמצעות תווית המסתיימת ב-:host ב-Forgejo, מה שאינו דורש מנוע אך גם אינו מציב שכבת container בין המשימה לבין המכונה. ה-runner מבצע כל מה שקובץ ה-workflow מורה לו, כפי שמתועד במפורש בתיעוד של Forgejo: ה-runner מבצע הרצת קוד מרחוק (remote code execution). הקצו לו host משלו במידת האפשר, או לכל הפחות משתמש ללא הרשאות מיוחדות (unprivileged user) ואסימון רישום המוגבל למאגר אחד בלבד.
אם המאגרים שלכם נשארים ב-GitHub ואתם רק רוצים את כוח העיבוד על חומרה שבשליטתכם, מדובר בתצורה שונה עם שלבים אחרים: runner עצמאי של GitHub Actions מתחבר למאגר ב-GitHub ואינו דורש דבר מכל זה. אם אתם עדיין שוקלים מה העלות של עזיבה, מה ש-GitHub באמת נותן לכם מפריד בין אירוח ה-Git לבין הרשת שסביבו.
גיבויים: מאגרים הם רק חצי מהמצב
מאגר (repository) מסוג bare הוא ספרייה, לכן העתקה שלו מעתיקה את כל תוכנו. ביצוע mirror clone ממכונה אחרת מהווה גיבוי אמיתי, והוא מתעדכן במקומו:
git clone --mirror git@vps.example.com:/srv/git/project.git
cd project.git && git remote updateפעולה זו מושכת כל ref וכל object. היא אינה מושכת hooks בצד השרת או את הקובץ description, לכן שמרו גם עותק ברמת הקבצים של הספרייה אם אתם משתמשים ב־hooks.
מערכת ניהול מאגרים (forge) שומרת issues, pull requests, משתמשים, מפתחות והרשאות בתוך מסד הנתונים שלה, ועותק של המאגרים בלבד משליך את כל המידע הזה. שני הפרויקטים מפיצים פקודת dump שכותבת את מסד הנתונים, המאגרים, התצורה והקבצים המצורפים לארכיון אחד:
sudo -u git forgejo dump -c /etc/forgejo/app.ini -f /var/backups/forgejo-dump.zipתחת Docker אותה פקודה רצה בתוך המכולה, ונתיב התצורה תלוי ב־image, לכן בדקו לפני שתקלידו:
docker compose exec server ls /data/gitea/conf
docker compose exec -u git server forgejo dump -c /data/gitea/conf/app.iniהריצו את הפקודה כמשתמש שבבעלותו הנתונים, וכתבו את הארכיון לספרייה שהמשתמש הזה מורשה לכתוב אליה. לאחר מכן העתיקו את הארכיון מחוץ לשרת, כיוון שגיבוי שקיים רק על המכונה שנגבית אינו נחשב לגיבוי. שחזור הוא השלב שאנשים נוטים לדלג עליו: פרקו dump אחד על מכונה פנויה כבר עכשיו, כדי שתלמדו את התהליך ברגע של רגיעה ולא בזמן תקלה.
בחירה לפי תרחיש
אדם אחד עם מחשב נייד ושרת VPS, ללא צורך בדפדפן: השתמשו ב-bare repositories מעל SSH. אין שירות נוסף שרץ ואין מה לעדכן.
אותו תרחיש, בתוספת רצון לקרוא קוד בדפדפן ולשלוח קישורים אליו: הוסיפו את cgit. עדיין ללא מסד נתונים, ועדיין ללא שירותים תושבים.
צוות שמבצע ביקורת קוד הדדית ועוקב אחר משימות: השתמשו ב-Forgejo או ב-Gitea, על שרת עם 2 GB RAM ומעלה. העבירו את ה-CI runner לשרת שני ברגע שהמשימות הופכות למורכבות.
ארגון הזקוק ל-container registry ולתיעוד פעולות (audit trails), עם 16 GB RAM פנויים בשרת: השתמשו ב-GitLab. מתחת לתקציב זה, אל תתקינו אותו.
מעבר בין שלוש הרמות הראשונות הוא זול, כיוון שבכולן המאגרים הם ספריות Git רגילות על הדיסק. התחילו ברמה הנמוכה ביותר שמבצעת את העבודה. אם אתם בוחנים אילו שירותים נוספים ראויים למקום על אותו שרת, הרשימה המקוצרת של שירותים שכדאי לארח עצמאית מציבה שרת Git לצד שירותים אחרים המתחרים על ה-RAM הזמין.
FAQ
האם VPS עם 1 GB RAM יכול להריץ את Forgejo או Gitea?
כן, עבור צוות קטן, תוך שימוש ב-SQLite, ובתנאי שאין שירותים כבדים אחרים על השרת. התיעוד של Gitea מציין כי 1 GB RAM ושני ליבות CPU מספיקים בדרך כלל לצוותים ופרויקטים קטנים; Forgejo הוא פיצול (fork) של Gitea בעל דרישות דומות. אל תוסיפו PostgreSQL או CI runner לאותו שרת. אם השירות נעלם ללא שגיאה בלוגים שלו, הריצו את sudo dmesg -T | grep -Ei 'oom|out of memory|killed process': שורה המציינת את התהליך שנסגר מעידה על כך שמנגנון ה-out of memory killer של ה-kernel סיים אותו. במקרה כזה, הפתרון הוא שדרוג לחבילת שרת גדולה יותר ולא שינוי הגדרות.
מה ההבדל בין Forgejo לבין Gitea?
השניים חולקים היסטוריית קוד ומירב התכונות. Gitea פוצלה מ-Gogs בשנת 2016, ו-Forgejo פוצלה מ-Gitea בסוף 2022 לאחר שהשליטה בסימן המסחרי של Gitea עברה לחברה מסחרית. Forgejo מפותח על ידי הקהילה תחת המטרייה של Codeberg e.V., עמותה ללא מטרות רווח בגרמניה, ומופץ תחת רישיון GPLv3; Gitea נשאר תחת רישיון MIT עם תמיכה מסחרית. ההבדל המעשי הוא בנתיב ההגירה. גרסה Forgejo v10.0, מינואר 2025, הייתה הגרסה האחרונה שיכלה לקלוט בסיס נתונים של Gitea ישירות, וזאת רק מ-Gitea v1.22 ומטה; לכן, אין כיום נתיב נתמך למעבר ישיר (in-place) ממופע Gitea קיים.
האם ניתן להריץ workflows של GitHub Actions על שרת Git בניהול עצמי?
הן Forgejo Actions והן Gitea Actions מריצים workflows שנכתבו בתחביר YAML של GitHub Actions, הנקראים מתוך .forgejo/workflows ו-.gitea/workflows. עליכם להתקין תוכנת runner נפרדת ולרשום אותה מול המופע שלכם. פעולות (actions) רבות שפורסמו עובדות ללא שינוי. ה-runner מריץ קוד שרירותי מהמאגרים שלכם, ובעזרת תגיות container סטנדרטיות, הוא מפעיל container לכל משימה. לכן, הקצו לו מארח נפרד, או לפחות משתמש ללא הרשאות root, והרחיקו אותו משרת ה-1 GB שמריץ כבר את ה-forge.
כיצד מגבים שרת Git בניהול עצמי?
עבור מאגרים חשופים (bare repositories), הפקודה git clone --mirror ממכונה אחרת מעתיקה כל ref ואובייקט, ו-git remote update בתוך אותו mirror מרעננת אותו. עבור Forgejo או Gitea, המאגרים הם רק חלק מהמצב, כיוון שנושאים (issues), בקשות מיזוג (pull requests), משתמשים ומפתחות שמורים בבסיס הנתונים. השתמשו בכלי הגיבוי המובנה, sudo -u git forgejo dump -c /etc/forgejo/app.ini, או באותה פקודה בתוך ה-container אם מדובר בהתקנת Docker. העתיקו את הארכיון מחוץ לשרת, ובצעו שחזור למכונה חלופית פעם אחת כדי לוודא שהתהליך עובד.