SSD Nodes Learn Hosting plans →

Self-hosted Git server: Forgejo, Gitea அல்லது cgit தேர்வு?

உங்கள் 1 GB RAM கொண்ட VPS-க்கு ஏற்ற Git server எது? SSH bare repos, cgit, Forgejo, Gitea மற்றும் GitLab ஆகிய நான்கு முறைகளை RAM பயன்பாட்டின் அடிப்படையில் ஒப்பிட்டு விளக்குகிறோம்.

எந்த self-hosted Git server-ஐ நீங்கள் இயக்க வேண்டும்

Self-hosted Git server என்பது ஒரே ஒரு தயாரிப்பு அல்ல. உங்கள் VPS-ல் உள்ள RAM (random access memory) அளவே நீங்கள் எந்தப் பதிப்பை இயக்க முடியும் என்பதைத் தீர்மானிக்கிறது. Git-க்கு என்று தனியாக daemon தேவையில்லை: ஒரு bare repository மற்றும் ஒரு SSH (secure shell) கணக்கு இருந்தாலே, நீங்கள் வாடகைக்கு எடுக்கக்கூடிய மிகச்சிறிய server-லும் அது வேலை செய்யும். அதற்கு மேல் உள்ள அனைத்தும் நீங்கள் கூடுதலாக இயக்கத் தேர்ந்தெடுக்கும் web application-கள் ஆகும். ஒவ்வொரு அடுத்த கட்டத்திற்கும் கூடுதல் memory தேவைப்படும், இது சிறிய VPS-ல் கிடைக்காமல் போகலாம். Git எங்கே முடிகிறது, GitHub எங்கே தொடங்குகிறது என்பதில் உங்களுக்கு இன்னும் தெளிவு தேவைப்பட்டால், Git, GitHub மற்றும் உங்கள் சொந்த Git server ஆகியவற்றிற்கு இடையிலான வேறுபாடுகள் என்ற பகுதி, நீங்கள் ஒரு நிலையைத் தேர்ந்தெடுக்கும் முன் அந்த வேறுபாட்டை விளக்குகிறது.

இதில் நான்கு நிலைகள் உள்ளன. SSH வழியாக இயங்கும் bare repository, இது ஏற்கனவே இயங்கிக்கொண்டிருக்கும் சேவைகளைத் தவிர வேறு எதையும் listening நிலையில் வைக்காது. cgit, இது database இல்லாத, வேகமான read-only web view ஆகும். Forgejo அல்லது Gitea, இது கணக்குகள், issues மற்றும் pull requests வசதிகளுடன் கூடிய முழுமையான forge, இதற்கு சில நூறு megabytes memory போதும். GitLab, இது மற்றவற்றை விட பல மடங்கு பெரிய server-ஐ எதிர்பார்க்கிறது.

நீங்கள் செய்ய வேண்டிய வேலையின் அடிப்படையில் முடிவெடுங்கள், பின்னர் நீங்கள் பணம் செலுத்தும் plan-ல் உள்ள memory அளவோடு ஒப்பிட்டுப் பாருங்கள்.

ஒவ்வொரு விருப்பத்திற்கும் உண்மையில் எவ்வளவு RAM தேவைப்படுகிறது

இந்தத் திட்டங்களில் இரண்டு மட்டுமே வன்பொருள் குறித்த புள்ளிவிவரங்களை வெளியிடுகின்றன. வெளியிடப்பட்ட புள்ளிவிவரத்தை ஒரு வாக்குறுதியாகக் கருதாமல், ஒரு குறைந்தபட்ச அளவீடாகக் கருதுங்கள். உங்கள் instance இயங்கத் தொடங்கியதும், systemd-cgtop அல்லது ps -o rss= -C forgejo மூலம் அதை நீங்களே அளவிடுங்கள்.

விளக்கப்படம்RAM the projects document, official docs, October 2026
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "label": "Gitea, small team",
    "ram_gb": 1
  },
  {
    "label": "GitLab, memory constrained",
    "ram_gb": 8
  },
  {
    "label": "GitLab, single node baseline",
    "ram_gb": 16
  }
]

சிறிய குழுக்கள் மற்றும் திட்டங்களுக்கு 2 CPU cores உடன் 1 GB RAM பொதுவாகப் போதுமானது என்று Gitea ஆவணப்படுத்துகிறது; சிறிய வேலைப்பளுக்களுக்கு Raspberry Pi 3 போதுமானது என்றும் அது குறிப்பிடுகிறது. GitLab ஒரு single node installation-க்கு 16 GB-ஐ அடிப்படை அளவாகவும், அதன் சொந்தப் பக்கத்தில் memory constrained environment என்று அழைக்கப்படும் சூழலுக்கு 8 GB-ஐ குறைந்தபட்ச அளவாகவும் குறிப்பிடுகிறது. Forgejo-வின் நிறுவல் ஆவணங்கள் RAM அளவு எதையும் குறிப்பிடவில்லை. இது Gitea-வின் ஒரு fork என்பதால், அதன் செயல்பாடும் அதே போன்றதே; எனவே, Gitea-வின் புள்ளிவிவரமே உங்களிடம் உள்ள மிக நெருக்கமான வழிகாட்டியாகும்.

1 GB VPS-ல் இதன் பொருள் என்னவென்றால்: bare repositories மற்றும் cgit ஆகியவை மீதமுள்ள இடத்துடன் இயங்கும், ஏனெனில் இவை இரண்டிற்கும் resident service தேவையில்லை. Forgejo அல்லது Gitea ஆகியவை SQLite-ல் இயங்கி ஒரு சிறிய குழுவிற்குச் சேவை செய்யும், ஆனால் நீங்கள் ஆவணப்படுத்தப்பட்ட குறைந்தபட்ச அளவிலேயே இருப்பதால், அந்த server-ல் PostgreSQL மற்றும் CI (continuous integration) runner-ஐச் சேர்க்க வேண்டாம். பிழைச் செய்தி ஏதுமின்றி web interface மறைந்துவிட்டால், sudo dmesg -T | grep -Ei 'oom|out of memory|killed process'-ஐ இயக்கி Out of memory: Killed process 1181 (forgejo) போன்ற வரியைத் தேடுங்கள்; இது kernel out of memory killer அந்தச் சேவையை நிறுத்திவிட்டது என்பதைக் குறிக்கிறது. 1 GB server-ல் GitLab-ஐ இயக்குவது என்பது tuning தொடர்பான பிரச்சனை அல்ல. அது இயங்காது.

Tier 0: SSH வழியாக ஒரு bare repository

Git-க்கு நீங்கள் தொடங்க வேண்டிய எந்த network daemon-ம் தேவையில்லை. SSH வழியாக git push இயங்கும்போது, அது தொலைதூர முனையில் ஒரு சாதாரண Unix process-ஆக git-receive-pack-ஐ இயக்குகிறது. எனவே, ஒரு key மூலம் நீங்கள் அணுகக்கூடிய எந்தவொரு கணக்கும் ஏற்கனவே ஒரு Git remote-ஆகச் செயல்படும். repositories-க்காக ஒரு கணக்கை உருவாக்கி, அவற்றை அதன் home directory-க்கு வெளியே வைக்கவும். இதன் மூலம், பிற்காலத்தில் சேர்க்கப்படும் web view-க்கு அந்த home directory-க்கான அணுகல் தேவைப்படாது.

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 இல்லாத ஒரு repository-ஐ உருவாக்குகிறது; இதுவே ஒரு server-ல் இருக்க வேண்டிய அமைப்பாகும். Working copy உள்ள ஒரு repository-ன் checked-out branch-க்கு push செய்வது refusing to update checked out branch: refs/heads/main மூலம் இயல்பாகவே மறுக்கப்படும்; இந்த நிலையில் இதுவே மிகவும் பொதுவான தவறு.

இப்போது அந்த கணக்கிற்கு ஒரு key-ஐ வழங்கி, அதை 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_keys
git remote add origin git@vps.example.com:/srv/git/project.git
git push -u origin main

வெற்றிகரமாக முடிந்த முதல் push, * [new branch] main -> main-உடன் முடிவடையும். git@vps.example.com: Permission denied (publickey)-உடன் முடிவடையும் push, அங்கீகரிக்கப்படவில்லை என்று பொருள். எனவே, sudo journalctl -u ssh -n 20 மூலம் server log-ஐப் பார்க்கவும். Authentication refused: bad ownership or modes for file /home/git/.ssh/authorized_keys என்று ஒரு வரி இருந்தால், ownership அல்லது file mode தவறாக உள்ளது என்று பொருள். ஏனெனில், நம்பகத்தன்மையற்ற owner அல்லது பிற பயனர்கள் எழுதக்கூடிய அனுமதிகளைக் கொண்ட key file-ஐ sshd நிராகரித்துவிடும்.

திட்டத்தின் origin ஏற்கனவே GitHub-ஐக் குறிப்பிட்டிருந்தால், git remote add origin என்பது error: remote origin already exists.-உடன் நின்றுவிடும். அந்த remote-ல் இந்த server-ஐ இரண்டாவது push URL-ஆகச் சேர்ப்பதன் மூலம், ஒரே git push கட்டளை மூலம் இரண்டையும் update செய்ய முடியும்.

இப்போது அந்தக் கணக்கிற்கான shell அணுகலை நீக்கவும்.

command -v git-shell | sudo tee -a /etc/shells
sudo chsh -s "$(command -v git-shell)" git

git-shell என்பது Git, SSH வழியாக அனுப்பும் சில கட்டளைகளை மட்டுமே ஏற்கும். எனவே, இப்போது interactive login செய்ய முயன்றால், prompt-க்கு பதிலாக ஒரு செய்தி மட்டுமே தோன்றும்:

fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.

இதுவே முழுமையான server அமைப்பு. இதில் database கிடையாது, upgrade செய்ய வேண்டிய web process-ம் கிடையாது. ஒரு forge வழங்கும் வசதிகள் எதையும் நீங்கள் பெறமாட்டீர்கள்: browsing, issue tracker, pull requests மற்றும் பயனர் வாரியான அனுமதிகள் இதில் இல்லை. அந்த file-ல் உள்ள ஒவ்வொரு key-ம் git பயனர் கொண்டுள்ள அனைத்து repository-களையும் படிக்கவும் எழுதவும் முடியும்.

நிலை 1: cgit தரவுத்தளம் இன்றி இணையக் காட்சியை வழங்குகிறது

cgit என்பது C மொழியில் எழுதப்பட்ட ஒரு CGI (common gateway interface) நிரலாகும். இணைய சேவையகம் ஒவ்வொரு கோரிக்கைக்கும் இதை ஒருமுறை இயக்கும்; இது களஞ்சியங்களை (repositories) நேரடியாக வட்டில் (disk) இருந்து வாசிக்கும், மேலும் இது எந்தவொரு நிலையையும் (state) சேமிப்பதில்லை. 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/git

scan-path அந்த அடைவை ஆய்வு செய்து, அதில் கண்டறியும் ஒவ்வொரு களஞ்சியத்தையும் பட்டியலிடும். எனவே, புதிய bare repo எவ்வித கூடுதல் உள்ளமைப்பும் இன்றி தானாகவே தோன்றும். cache-size என்பது தேக்ககப்படுத்தப்பட்ட (cached) பக்கங்களின் எண்ணிக்கை; இது பூஜ்ஜியமாக இருக்கும் வரை தேக்ககம் (caching) முடக்கப்பட்டிருக்கும். நீங்கள் புதிய வரிகளைச் சேர்ப்பதற்கு முன், /etc/cgitrc-ல் உங்கள் தொகுப்பு ஏற்கனவே என்னென்ன உள்ளமைவுகளைச் சேர்த்துள்ளது என்பதைப் படிக்கவும், ஏனெனில் Debian மற்றும் Ubuntu தொகுப்புகள் சில இயல்புநிலை அமைப்புகளைக் கொண்டுள்ளன.

ஒவ்வொரு பதிவும் களஞ்சியத்தின் description கோப்பின் முதல் வரியைக் காட்டும். எனவே, ஒரு புதிய bare repo தன்னை 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 site கோப்பு மற்றும் அதைச் சரிபார்க்கும் முறை
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 Listen

root /usr/share/cgit ஆனது cgit.css மற்றும் cgit.png ஆகியவற்றை சாதாரண கோப்புகளாக வழங்குகிறது, மேலும் try_files மற்ற அனைத்தையும் /usr/lib/cgit/cgit.cgi-ல் உள்ள CGI-க்கு அனுப்புகிறது. /var/log/nginx/error.log-ல் connect() to unix:/run/fcgiwrap.socket failed (2: No such file or directory) பிழையுடன் கூடிய 502 பக்கம் தோன்றினால், socket unit இயங்கவில்லை அல்லது அது வேறொரு பாதையில் கேட்கிறது (listen) என்று பொருள். systemctl show வரி அது உண்மையில் பயன்படுத்தும் பாதையை அச்சிடும்.

இதை உருவாக்கும் முன் இரண்டு வரம்புகளைத் தெரிந்துகொள்வது அவசியம். இந்த உள்ளமைவில் cgit என்பது read-only மற்றும் இதில் login வசதி இல்லை, எனவே scan-path-க்குக் கீழ் உள்ள அனைத்தும் பொதுவானவை: தனிப்பட்ட களஞ்சியங்களை அந்த அடைவுக்கு வெளியே வைக்கவும் அல்லது முழு தளத்திற்கும் முன்னால் HTTP basic authentication-ஐச் சேர்க்கவும். மேலும், CGI இணைய சேவையகப் பயனராக (web server user) இயங்குகிறது, எனவே அந்தப் பயனர் /srv/git-ஐ அணுகவும் ஒவ்வொரு களஞ்சியத்தையும் வாசிக்கவும் அனுமதி தேவை. அந்தப் பயனர் நுழைய முடியாத ஒரு அடைவு, பிழைக்கு பதிலாக காலியான பட்டியலாகவே காட்டும்.

Tier 2: சிக்கல்கள் மற்றும் pull request-களுக்கான Forgejo அல்லது Gitea

Forgejo மற்றும் Gitea ஆகிய இரண்டும் ஒரே மாதிரியானவை: பயனர்கள், நிறுவனங்கள், சிக்கல்கள் (issues), pull requests, releases, package registry மற்றும் உள்ளமைக்கப்பட்ட CI அமைப்பு ஆகியவற்றை உள்ளடக்கிய ஒரு web forge-ஐ வழங்கும் ஒற்றை Go binary. Binary மற்றும் SQLite மட்டுமே முழு நிறுவல் என்பதால், GitLab-ஐ இயக்க முடியாத வன்பொருளிலும் இவை இயங்கும். கீழே உள்ள Compose file, Forgejo ஆவணத்தில் உள்ளதாகும்; இதில் 24 அக்டோபர் 2026 நிலவரப்படி உள்ள image tag பயன்படுத்தப்பட்டுள்ளது.

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 tag, v17 வரிசையைப் பின்பற்றுகிறது. 26 அக்டோபர் 2026 அன்று வெளியான Forgejo v17.0.1 தற்போதைய stable release ஆகும்; Forgejo v17 பதிப்பிற்கு 28 ஜனவரி 2027 வரை ஆதரவு அளிக்கிறது. பழைய v16 வரிசைக்கான ஆதரவு 29 அக்டோபர் 2026 அன்று முடிந்துவிட்டது, எனவே 16 tag-ல் உள்ள தற்போதைய நிறுவல்கள் உடனடியாக upgrade செய்யப்பட வேண்டும். ஒரு major version-லிருந்து அடுத்த பதிப்பிற்கு மாறுவது கைமுறை (manual) upgrade என்பதால், தற்போதைய பதிப்பிலேயே தொடங்குவது சிறந்தது.

docker compose up -d
docker compose ps
curl -sI http://127.0.0.1:3000 | head -1

curl வரி, HTTP status வரியை அச்சிட வேண்டும். முதல்முறை அமைப்பை (first-run setup) முடிப்பதற்கு முன், இது /install-க்கு redirect செய்யக்கூடும், இது service இயங்குகிறது என்பதையே குறிக்கும். மாறாக container நின்றுவிட்டால், அதற்கு உரிமையாளர் (ownership) தொடர்பான சிக்கலே காரணமாக இருக்கும்: ./forgejo directory, USER_UID-ல் உள்ள UID (user id)-க்கு சொந்தமானதாக இருக்க வேண்டும், இல்லையெனில் அந்த process-ஆல் தனது தரவு directory-ல் எழுத முடியாது. Docker Compose on a VPS அந்த file அமைப்பு மற்றும் volume ownership விதியை முழுமையாக விளக்குகிறது.

setup பக்கத்தில் உள்ள இரண்டு பதில்கள், clone URLs சரியாக வேலை செய்யுமா என்பதைத் தீர்மானிக்கின்றன. SSH port என்பது SSH mapping-ன் host பக்கமாக இருக்க வேண்டும்; மேலே உள்ள Compose file-ல் இது 222 ஆகும், ஏனெனில் இது host port 222-ஐ container-ன் port 22-க்கு map செய்கிறது. 222 என்ற எண்ணிற்கு என்று தனி முக்கியத்துவம் இல்லை: mapping மற்றும் இந்த பதில் ஒத்துப்போகும் வரை எந்தவொரு இலவச host port-ம் வேலை செய்யும். மேலும், domain என்பது பயனர்கள் உண்மையில் தட்டச்சு செய்யும் பெயராக இருக்க வேண்டும். இதில் எதில் தவறு செய்தாலும், repository பக்கத்தில் உள்ள clone கட்டளை அனைவருக்கும் தோல்வியடையும். இவை அமைக்கப்பட்ட பிறகு app.ini-ன் [server] பகுதியில் SSH_PORT, SSH_DOMAIN மற்றும் ROOT_URL என இருக்கும்.

பொதுவான instance-க்கு, web port-ஐ loopback முகவரியில் மட்டும் ('127.0.0.1:3000:3000') வெளியிட்டு, TLS (transport layer security)-க்காக அதன் முன்னால் nginx-ஐ வைக்கவும். Gitea-வும் அதன் ஆவணங்களில் உள்ள docker.gitea.com/gitea image மூலமாகவோ அல்லது ஒரு systemd unit மற்றும் ஒரு app.ini கொண்ட ஒற்றை binary-ஆகவோ இதே முறையில் நிறுவப்படும். இதன் தற்போதைய stable release v28.4.0, 15 நவம்பர் 2026 அன்று வெளியானது. செப்டம்பர் இறுதியில் v28.0.0 பதிப்புடன், இந்தத் திட்டம் பழைய 1. முன்னொட்டை நீக்கிவிட்டது, எனவே 1.27-க்கு அடுத்த வெளியீடு 1.28 அல்ல, 28 ஆகும்.

முடிந்தவரை SQLite-லேயே இருக்கவும். இது instance-ஐ ஒரே process மற்றும் ஒரே file-ஆக வைத்திருக்கும், மேலும் reboot-க்குப் பிறகு கூடுதல் service எதையும் கண்காணிக்க வேண்டிய அவசியமில்லை. பல பயனர்கள் ஒரே நேரத்தில் எழுதும் சூழலில் PostgreSQL பயனுள்ளதாக இருக்கும், ஏனெனில் SQLite எழுதும் பணிகளை வரிசைப்படுத்தும் (serialise) மற்றும் நீண்ட CI ஓட்டங்கள் தொடர்ந்து எழுதிக்கொண்டே இருக்கும். இரண்டு திட்டங்களிலும் ஏற்கனவே உள்ள instance-ஐப் பிறகு PostgreSQL-க்கு மாற்ற முடியும், எனவே இது மாற்ற முடியாத முடிவு அல்ல.

Forgejo அல்லது Gitea: உண்மையில் என்ன வேறுபாடு

இவற்றின் தோற்றம் ஒன்றுதான். Gitea, 2016-ல் Gogs-லிருந்து பிரிக்கப்பட்டது (fork). 2022-ன் இறுதியில் Gitea domain மற்றும் வர்த்தக முத்திரையின் கட்டுப்பாடு Gitea Ltd என்ற நிறுவனத்திடம் சென்றது, அப்போது பல பராமரிப்பாளர்கள் இணைந்து Codeberg-உடன் சேர்ந்து Forgejo-வைத் தொடங்கினர். Forgejo, ஜெர்மனியில் பதிவுசெய்யப்பட்ட இலாப நோக்கற்ற அமைப்பான Codeberg e.V.-ன் கீழ் அதன் சமூகத்தால் உருவாக்கப்படுகிறது; இது திட்டத்தின் domain-களைக் கொண்டுள்ளது, அதே சமயம் நிர்வாகம் Forgejo-வின் பங்களிப்பாளர்களிடமே உள்ளது. இது 2024-ல் MIT உரிமத்திலிருந்து GPLv3 (GNU general public license version 3)-க்கு மாறியது. Gitea, MIT உரிமத்திலேயே நீடிக்கிறது மற்றும் வணிக ரீதியான ஆதரவுடன் உருவாக்கப்படுகிறது.

தினசரி பயன்பாட்டில், இவற்றின் அம்சங்கள் நெருக்கமானவை. ஆனால் அவற்றுக்கு இடையேயான மாற்றம் எளிதானதல்ல. ஜனவரி 2025-ல் வெளியான Forgejo v10.0, Gitea database-ஐ நேரடியாகப் பெறக்கூடிய கடைசி பதிப்பாகும், அதுவும் Gitea v1.22 அல்லது அதற்கு முந்தைய பதிப்புகளிலிருந்து மட்டுமே. 16 நவம்பர் 2026 நிலவரப்படி Gitea v28.4.0-ல் உள்ளது, எனவே தற்போதைய Gitea instance-ஐ Forgejo-விற்கு நேரடியாக மாற்ற ஆதரவு இல்லை. தரவுகளை நிரப்புவதற்கு முன்பே ஒன்றைத் தேர்வு செய்யவும்; பிற்காலத்தில் மாற்றுவதை export மற்றும் re-import என கருதவும்.

தேர்வு செய்வதற்கான ஒரு எளிய விதி: நிர்வாகம் உங்களுக்கு முக்கியம் என்றாலோ அல்லது இலாப நோக்கற்ற அமைப்பின் கீழ் உள்ள திட்டத்தை விரும்பினாலோ, Forgejo-வைப் பயன்படுத்தவும். உங்களுக்குப் பெரிய பயனர் தளம் மற்றும் வணிக ரீதியான ஆதரவு தேவைப்பட்டால், Gitea-வைப் பயன்படுத்தவும். இரண்டுமே வெளிப்படையாகப் பராமரிக்கப்படுகின்றன மற்றும் அடிக்கடி வெளியிடப்படுகின்றன: Forgejo மூன்று மாதங்களுக்கு ஒருமுறை stable release-ஐயும், ஒவ்வொரு ஆண்டும் LTS (long term support) release-ஐயும் வெளியிடுகிறது. 29 அக்டோபர் 2026 நிலவரப்படி v17.0.1 தற்போதைய பதிப்பாகவும், v15.0.11 LTS பதிப்பாகவும் உள்ளது. Forgejo v17-க்கு 28 ஜனவரி 2027 வரையிலும், v15-க்கு 15 ஜூலை 2027 வரையிலும் ஆதரவு அளிக்கிறது, அதே சமயம் v16-க்கான ஆதரவு 29 அக்டோபர் 2026-ல் முடிந்துவிட்டது, எனவே ஒரு major version-ஐத் தேர்ந்தெடுக்கும் முன் அதன் releases பக்கத்தைச் சரிபார்க்கவும். இந்த விதிகளால் முடிவு செய்ய முடியாவிட்டால், Forgejo மற்றும் Gitea-வின் முழு ஒப்பீடு அவற்றின் Actions மற்றும் package registries எவ்வாறு வேறுபடுகின்றன என்பதை விளக்குகிறது; தரவுகளைச் சேர்த்த பிறகு மாற்றத்தை கடினமாக்காமல், இந்த விவரங்களை முன்கூட்டியே முடிவு செய்வது நல்லது.

Tier 3: GitLab எதையும் செய்வதற்கு முன்பே ஏற்படும் செலவுகள்

GitLab CE என்பது ஒரு தனித்துவமான மென்பொருள் வகையைச் சேர்ந்தது. ஒரு instance என்பது ஒன்றிணைந்து செயல்படும் பல சேவைகளின் தொகுப்பாகும்: web application-க்காக Puma, background jobs-க்காக Sidekiq, PostgreSQL, Redis, repository access-க்காக Gitaly மற்றும் முன்பக்கத்தில் nginx. Omnibus package இவை அனைத்தையும் ஒன்றாக நிறுவுவதால், நிறுவல் எளிதாகிறது, ஆனால் குறைந்தபட்ச memory தேவை அதிகமாகிறது.

GitLab-ன் requirements பக்கம், ஒரு single node நிறுவலுக்கு 16 GB RAM மற்றும் 8 vCPU-ஐ அடிப்படைத் தேவையாகக் குறிப்பிடுகிறது; memory குறைவாக உள்ள சூழலில் 8 GB குறைந்தபட்சத் தேவையாகக் குறிப்பிடப்பட்டுள்ளது. அதே பக்கம் swap-ஐ disable செய்யுமாறு அறிவுறுத்துகிறது, ஏனெனில் சுமை அதிகமாக இருக்கும்போது swap பயன்படுத்துவது instance-ன் செயல்திறனை மோசமாகப் பாதிக்கும். இவை அக்டோபர் 2026 நிலவரப்படி வெளியிடப்பட்ட புள்ளிவிவரங்கள்; இவை காலப்போக்கில் அதிகரித்துள்ளன, எனவே server-ன் அளவைத் தீர்மானிக்கும் முன் அந்தப் பக்கத்தை மீண்டும் ஒருமுறை சரிபார்க்கவும்.

இந்த முதலீட்டிற்கு நீங்கள் பெறுபவை: container registry, package registry, நுணுக்கமான permissions மற்றும் பெரிய அளவில் சோதிக்கப்பட்ட CI. compliance center மற்றும் project அல்லது group audit trails போன்ற வசதிகளுக்குக் கட்டணத்துடன் கூடிய GitLab tier தேவைப்படும். உங்கள் குழுவில் உள்ள எவருக்கும் இந்த பட்டியலில் உள்ள எந்தவொரு வசதியும் இந்த காலாண்டில் தேவைப்படாது என்றால், நீங்கள் எதற்கும் பயன்படாத ஒரு பெரிய VPS-க்காகப் பணம் செலுத்துகிறீர்கள் என்று அர்த்தம்.

SSH அணுகல் மாதிரி: ஒரு git பயனர் மற்றும் பல சாவிகள்

System OpenSSH-ஐப் பயன்படுத்தும்போது, அனைத்து நிலைகளும் ஒரே முறையில் அங்கீகரிக்கப்படுகின்றன. git என்ற பெயரில் ஒரு Unix கணக்கு மட்டுமே இருக்கும், மேலும் அனைத்து public key-களும் அந்த கணக்கின் ~/.ssh/authorized_keys கோப்பில் சேர்க்கப்படும். Authentication என்பது சாவியை அடிப்படையாகக் கொண்டது. Authorisation என்பது அதே வரியில் சாவிக்கு முன்னால் நீங்கள் குறிப்பிடும் விருப்பத்தேர்வுகளைப் பொறுத்தது.

சாதாரண சாவி வரி, அந்த கணக்கிற்கு என்னென்ன அதிகாரங்கள் உள்ளனவோ அவை அனைத்தையும் சாவி வைத்திருப்பவருக்கு வழங்கும். இன்னும் /bin/bash-ஐ login shell-ஆகப் பயன்படுத்தும் கணக்கிற்கு, ஒரு forced command மூலம் அதை Git-க்கு மட்டும் கட்டுப்படுத்தலாம்:

restrict,command="git-shell -c \"$SSH_ORIGINAL_COMMAND\"" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIexamplekeyhere alice@laptop

OpenSSH 7.2 முதல் கிடைக்கும் restrict, port forwarding, agent forwarding, X11 மற்றும் PTY (pseudo terminal) ஒதுக்கீடு ஆகியவற்றை ஒரே சொல்லில் முடக்குகிறது. command=, client கோரிய கட்டளைக்கு பதிலாக நீங்கள் குறிப்பிடும் கட்டளையை இயக்கும். SSH server, client-ன் அசல் கட்டளையை $SSH_ORIGINAL_COMMAND-ல் வைப்பதால் Git தொடர்ந்து வேலை செய்யும்.

ஒரு forge மென்பொருள் உங்களுக்காக அந்தக் கோப்பை எழுதும்; இதுவே tier 0 மற்றும் tier 2-க்கு இடையிலான உண்மையான வேறுபாடு. Forgejo மற்றும் Gitea ஆகியவை system OpenSSH server-க்கு பின்னால் இயங்கும்போது (இதுவே இயல்புநிலை), அவை authorized_keys கோப்பை ஒவ்வொரு பதிவு செய்யப்பட்ட சாவிக்கும் ஒரு வரி என்ற வீதத்தில் மீண்டும் எழுதும். ஒவ்வொன்றும் அந்தச் சாவியை அதன் database id மூலம் அடையாளம் காணும் ஒரு forced command-ஐக் கொண்டிருக்கும்:

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

அந்த forced command மூலமே ஒரு பகிரப்பட்ட Unix கணக்கு, தனிநபர் சார்ந்த அனுமதியாக மாறுகிறது: key-3, எந்த பயனர் இணைகிறார் என்பதை forge-க்குத் தெரிவிக்கும். தரவுகள் பரிமாறப்படுவதற்கு முன்பே, அந்தப் பயனர் அந்த repository-க்கு உரியவரா என்பதை அது சரிபார்க்கும். Forge மூலம் நிர்வகிக்கப்படும் கணினியில் அந்தக் கோப்பை நீங்களாகத் திருத்த வேண்டாம்; ஏனெனில் அது database-லிருந்து மீண்டும் எழுதப்படும்போது உங்கள் வரி நீக்கப்பட்டுவிடும். நீங்கள் forge-ன் உள்ளமைக்கப்பட்ட SSH server-ஐ இயக்கினால், அல்லது AuthorizedKeysCommand மூலம் OpenSSH-ஐ forge-லிருந்து சாவிகளைப் பெறச் சொன்னால், forge-க்கு அந்தக் கோப்பு தேவைப்படாது. இரண்டாவது சூழலில், அந்தக் கோப்பை உருவாக்குவதை நிறுத்திவிடுமாறு இரு திட்டங்களும் பரிந்துரைக்கின்றன. Deploy keys அதே பொறிமுறையில்தான் செயல்படுகின்றன: ஒரு deploy key என்பது ஒரு குறிப்பிட்ட repository-க்காகப் பதிவு செய்யப்பட்ட சாதாரண SSH சாவி. இது பொதுவாக read-only முறையில் இருக்கும், மேலும் சரிபார்ப்பு sshd-க்கு பதிலாக forge-ல் நடைபெறும்.

மேலே உள்ள configuration-ஐ விட இரண்டு பழக்கங்கள் மிக முக்கியமானவை. ஒரு நபருக்கு அல்லது ஒரு இயந்திரத்திற்கு ஒரு சாவி மட்டுமே வழங்கவும்; ஒருபோதும் சாவியைப் பகிர வேண்டாம். ஏனெனில், பகிரப்பட்ட சாவியை நீக்குவது என்பது அனைவருக்குமான சாவியை ஒரே நேரத்தில் மாற்றுவதாகும். மேலும், ஒருவர் வெளியேறிய அன்றே அவருடைய சாவியை நீக்கிவிடவும். ஏனெனில், அந்தக் கோப்பில் இருக்கும் பழைய சாவி, யாரும் கவனிக்காத ஒரு நிரந்தரமான login-ஆக மாறிவிடும். சர்வரில் சிறந்த SSH சாவி மேலாண்மை என்பது சாவி வகைகள் மற்றும் passphrases பற்றி விளக்குகிறது, அது இங்கும் அப்படியே பொருந்தும். நீங்கள் புதிய server-ஐப் பயன்படுத்துகிறீர்கள் என்றால், repository-களை வைப்பதற்கு முன் புதிய VPS-ல் முதல் பத்து நிமிடங்கள் என்ற வழிகாட்டியைப் பின்பற்றுவது சிறந்தது.

எனது சொந்த Git server-ல் GitHub Actions-ஐ இயக்க முடியுமா?

GitHub Actions syntax-ல் எழுதப்பட்ட workflows-ஐ நீங்கள் இயக்க முடியும். ஆனால், GitHub-ஐ உங்களால் இயக்க முடியாது. Forgejo v1.21 பதிப்பிலிருந்து Forgejo Actions இயல்பாகவே செயல்படுத்தப்பட்டுள்ளது; இது ஒவ்வொரு repository-லும் உள்ள .forgejo/workflows கோப்புகளிலிருந்து workflow-களை வாசிக்கும். Gitea Actions-ம் இதே முறையில் செயல்பட்டு .gitea/workflows கோப்பை வாசிக்கும். இவை இரண்டுக்கும் runner எனப்படும் இரண்டாவது நிரல் தேவை; இதை நிறுவி, admin settings-லிருந்து பெறப்பட்ட token மூலம் உங்கள் instance-உடன் பதிவு செய்ய வேண்டும். வெளியிடப்பட்ட பல actions-களை மாற்றமின்றி இயக்க முடியும்.

இரண்டு விளைவுகளைக் கவனத்தில் கொள்ளவும். வழக்கமான container labels-ஐப் பயன்படுத்தும்போது, ஒவ்வொரு job-க்கும் runner ஒரு container-ஐத் தொடங்கும். எனவே, இதற்கு ஒரு container engine மற்றும் அதற்கெனத் தனி மெமரி ஒதுக்கீடு தேவை. இதனால்தான், 1 GB அளவுள்ள forge server-ல் இதை நிறுவக்கூடாது. Forgejo-வில் :host என முடியும் label-ஐப் பயன்படுத்தி, இரண்டு runner-களுமே நேரடியாக host-ல் job-களை இயக்க முடியும். இதற்கு engine தேவையில்லை, ஆனால் job-க்கும் அந்த machine-க்கும் இடையில் எந்த container பாதுகாப்பும் இருக்காது. மேலும், workflow கோப்பில் என்ன சொல்லப்பட்டிருக்கிறதோ அதை runner அப்படியே செயல்படுத்தும். இதை Forgejo-வின் ஆவணங்கள் தெளிவாகக் குறிப்பிடுகின்றன: runner remote code execution-ஐச் செய்கிறது. முடிந்தவரை இதற்கெனத் தனி host-ஐ ஒதுக்குங்கள்; அல்லது குறைந்தபட்சம், தனி சலுகைகள் இல்லாத (unprivileged) user-ஐ உருவாக்கி, ஒரு குறிப்பிட்ட repository-க்கு மட்டும் கட்டுப்படுத்தப்பட்ட registration token-ஐப் பயன்படுத்துங்கள்.

உங்கள் repositories GitHub-லேயே இருந்து, நீங்கள் கட்டுப்படுத்தும் hardware-ல் மட்டும் compute வசதி தேவைப்பட்டால், அது வேறுபட்ட அமைப்பு மற்றும் படிகளைக் கொண்டது: a self-hosted GitHub Actions runner ஒரு GitHub repository-உடன் இணையும், இதற்கு மேலே சொன்னவை எதுவும் தேவையில்லை. GitHub-ஐ விட்டு வெளியேறுவதால் ஏற்படும் செலவுகளை நீங்கள் இன்னும் கணக்கிட்டுக்கொண்டிருந்தால், what GitHub actually gives you என்ற கட்டுரை Git hosting-க்கும் அதைச் சுற்றியுள்ள network வசதிகளுக்கும் உள்ள வேறுபாட்டை விளக்கும்.

Backups: repositories மட்டும் முழுமையான தரவுகள் அல்ல

Bare repository என்பது ஒரு directory மட்டுமே, எனவே அதை நகலெடுப்பது அதிலுள்ள அனைத்தையும் நகலெடுக்கும். மற்றொரு machine-லிருந்து mirror clone செய்வது ஒரு உண்மையான backup ஆகும், இது அந்த இடத்திலேயே புதுப்பிக்கப்படும்:

git clone --mirror git@vps.example.com:/srv/git/project.git
cd project.git && git remote update

இது ஒவ்வொரு ref மற்றும் ஒவ்வொரு object-ஐயும் இழுக்கும். இது server-side hooks அல்லது description கோப்பை இழுக்காது, எனவே நீங்கள் hooks பயன்படுத்தினால் அந்த directory-ன் file-level நகலையும் வைத்துக்கொள்ளுங்கள்.

ஒரு forge அதன் database-ல் issues, pull requests, users, keys மற்றும் permissions ஆகியவற்றை வைத்திருக்கும், repositories-ஐ மட்டும் நகலெடுப்பது இவை அனைத்தையும் இழக்கச் செய்யும். இரண்டு திட்டங்களும் database, repositories, configuration மற்றும் attachments ஆகியவற்றை ஒரே archive-ஆக எழுதும் dump command-ஐ வழங்குகின்றன:

sudo -u git forgejo dump -c /etc/forgejo/app.ini -f /var/backups/forgejo-dump.zip

Docker-ல் அதே command container-க்குள் இயங்கும், மேலும் configuration path அந்த image-ஐப் பொறுத்தது, எனவே தட்டச்சு செய்வதற்கு முன் கவனிக்கவும்:

docker compose exec server ls /data/gitea/conf
docker compose exec -u git server forgejo dump -c /data/gitea/conf/app.ini

தரவுகளுக்கு உரிமையாளராக உள்ள user-ஆக அதை இயக்கவும், அந்த user-க்கு எழுத அனுமதி உள்ள directory-ல் archive-ஐ எழுதவும். பின்னர் அந்த archive-ஐ server-லிருந்து வெளியே நகலெடுக்கவும், ஏனெனில் backup செய்யப்படும் machine-லேயே இருக்கும் backup, உண்மையான backup ஆகாது. மீட்டெடுப்பது (restoring) மக்கள் தவிர்க்கும் ஒரு படிநிலை: இப்போது ஒரு spare box-ல் ஒரு dump-ஐ unpack செய்து பாருங்கள், அப்போதுதான் ஒரு outage ஏற்படும்போது பதற்றமில்லாமல் அந்த நடைமுறையை நீங்கள் கற்றுக்கொள்ள முடியும்.

சூழல் வாரியான தேர்வு

ஒரு நபர், ஒரு மடிக்கணினி மற்றும் ஒரு VPS, உலாவல் (browsing) தேவையில்லை என்றால்: SSH வழியாக bare repositories-ஐப் பயன்படுத்தவும். கூடுதல் service எதுவும் இயங்காது, எதையும் upgrade செய்ய வேண்டியதில்லை.

அதே சூழல், ஆனால் குறியீட்டை (code) உலாவியில் பார்க்கவும், அதற்கான இணைப்புகளை அனுப்பவும் விரும்பினால்: cgit-ஐச் சேர்க்கவும். இதற்கும் database தேவையில்லை, பின்னணியில் இயங்கும் service-களும் இல்லை.

குறியீட்டை ஆய்வு செய்து (review), சிக்கல்களைக் கண்காணிக்கும் (track issues) குழுவிற்கு: 2 GB RAM அல்லது அதற்கு மேல் இருந்தால் Forgejo அல்லது Gitea-வைப் பயன்படுத்தவும். CI வேலைகள் அதிகரிக்கும்போது, CI runner-ஐ மற்றொரு server-க்கு மாற்றவும்.

Container registry மற்றும் audit trails தேவைப்படும் நிறுவனத்திற்கு, 16 GB RAM வசதி இருந்தால்: GitLab-ஐப் பயன்படுத்தவும். இந்த அளவிற்குக் குறைவான RAM இருந்தால், GitLab-ஐத் தொடங்க வேண்டாம்.

முதல் மூன்று நிலைகளில் இருந்து அடுத்த நிலைக்கு மாறுவது எளிது, ஏனெனில் இவை அனைத்திலும் repositories என்பவை வட்டில் (disk) உள்ள சாதாரண Git directories-தான். உங்கள் தேவைக்கு ஏற்ற மிகக் குறைந்த நிலையில் தொடங்கவும். அதே server-ல் வேறு என்னென்ன சேவைகளை இயக்கலாம் என்று நீங்கள் திட்டமிட்டால், சுய-வழங்கலில் (self-hosting) மதிப்புமிக்க சேவைகளின் பட்டியல் Git server-ஐ மற்ற சேவைகளுடன் ஒப்பிட்டு, RAM பயன்பாட்டிற்கு ஏற்ப தேர்வு செய்ய உதவும்.

FAQ

1 GB VPS-ல் Forgejo அல்லது Gitea-வை இயக்க முடியுமா?

ஆம், ஒரு சிறிய குழுவிற்கு, SQLite-ல், அந்த server-ல் வேறு கனமான சேவைகள் எதுவும் இல்லாத பட்சத்தில் இயக்க முடியும். Gitea-வின் ஆவணங்களின்படி, 1 GB RAM மற்றும் 2 CPU cores சிறிய குழுக்கள் மற்றும் திட்டங்களுக்குத் பொதுவாகப் போதுமானது; Forgejo என்பது Gitea-வின் ஒரு fork என்பதால் அதன் தேவைகளும் அதே போன்றதே. அந்த machine-ல் PostgreSQL அல்லது CI runner-ஐச் சேர்க்க வேண்டாம். அதன் சொந்த log-ல் எந்தப் பிழையும் இன்றி சேவை மறைந்துவிட்டால், sudo dmesg -T | grep -Ei 'oom|out of memory|killed process'-ஐ இயக்கவும்: கொல்லப்பட்ட process-ன் பெயரைக் கொண்ட ஒரு வரி இருந்தால், kernel out of memory killer அதை நிறுத்திவிட்டது என்று அர்த்தம். இதற்குத் தீர்வு tuning flag அல்ல, மாறாக அதிக வசதி கொண்ட plan-க்கு மாறுவதே ஆகும்.

Forgejo மற்றும் Gitea-விற்கு இடையே உள்ள வேறுபாடு என்ன?

இவை இரண்டும் ஒரே codebase வரலாற்றையும் பெரும்பாலான அம்சங்களையும் பகிர்ந்து கொள்கின்றன. Gitea 2016-ல் Gogs-லிருந்து பிரிக்கப்பட்டது (fork), Gitea-வின் வர்த்தக முத்திரை ஒரு நிறுவனத்தின் கட்டுப்பாட்டிற்குச் சென்ற பிறகு, 2022-ன் இறுதியில் Forgejo, Gitea-விலிருந்து பிரிக்கப்பட்டது. Forgejo ஜெர்மனியில் உள்ள ஒரு இலாப நோக்கற்ற அமைப்பான Codeberg e.V.-ன் கீழ் அதன் சமூகத்தால் உருவாக்கப்பட்டு, GPLv3 உரிமத்தின் கீழ் வெளியிடப்படுகிறது; Gitea வணிக ரீதியான ஆதரவுடன் MIT உரிமத்திலேயே நீடிக்கிறது. நடைமுறை ரீதியான வேறுபாடு என்னவென்றால், அது இடம்பெயர்வு (migration) பாதையில் உள்ளது. ஜனவரி 2025-ல் வெளியான Forgejo v10.0, Gitea database-ஐ நேரடியாகப் பயன்படுத்தக்கூடிய கடைசி பதிப்பாகும், அதுவும் Gitea v1.22 அல்லது அதற்கு முந்தைய பதிப்பிலிருந்து மட்டுமே முடியும். எனவே, தற்போதுள்ள ஒரு Gitea instance-ஐ நேரடியாக மாற்றும் வசதி (in-place switch) இல்லை.

self-hosted Git server-ல் GitHub Actions workflows-ஐ இயக்க முடியுமா?

Forgejo Actions மற்றும் Gitea Actions ஆகிய இரண்டும் GitHub Actions YAML syntax-ல் எழுதப்பட்ட workflows-ஐ .forgejo/workflows மற்றும் .gitea/workflows கோப்புகளிலிருந்து படிக்கின்றன. நீங்கள் ஒரு தனி runner நிரலை நிறுவி, அதை உங்கள் instance-உடன் இணைக்க வேண்டும். வெளியிடப்பட்ட பல actions மாற்றங்கள் இன்றி வேலை செய்யும். Runner உங்கள் repositories-லிருந்து தன்னிச்சையான குறியீட்டை (arbitrary code) இயக்குகிறது மற்றும் வழக்கமான container labels-உடன் ஒவ்வொரு பணிக்கும் ஒரு container-ஐத் தொடங்குகிறது. எனவே, அதற்குத் தனி host-ஐ அல்லது குறைந்தபட்சம் தனி unprivileged user-ஐ ஒதுக்குங்கள், மேலும் ஏற்கனவே forge இயங்கிக்கொண்டிருக்கும் 1 GB server-ல் அதை இயக்க வேண்டாம்.

self-hosted Git server-ஐ எவ்வாறு backup எடுப்பது?

Bare repositories-க்கு, மற்றொரு machine-லிருந்து git clone --mirror கட்டளையைப் பயன்படுத்தி ஒவ்வொரு ref மற்றும் object-ஐயும் நகலெடுக்கலாம், மேலும் அந்த mirror-க்குள் git remote update கட்டளையைப் பயன்படுத்தி அதைப் புதுப்பிக்கலாம். Forgejo அல்லது Gitea-வைப் பொறுத்தவரை, repositories என்பது நிலையின் ஒரு பகுதி மட்டுமே, ஏனெனில் issues, pull requests, users மற்றும் keys ஆகியவை database-ல் உள்ளன. உள்ளமைக்கப்பட்ட dump வசதியான sudo -u git forgejo dump -c /etc/forgejo/app.ini-ஐப் பயன்படுத்தவும், அல்லது Docker நிறுவலாக இருந்தால் container-க்குள் அதே கட்டளையைப் பயன்படுத்தவும். அந்த archive-ஐ server-லிருந்து நகலெடுத்து, ஒருமுறை spare machine-ல் restore செய்து பாருங்கள், அப்போதுதான் அந்த நடைமுறை சரியாக வேலை செய்கிறது என்பதை நீங்கள் உறுதிப்படுத்த முடியும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?

#git#self-hosting#forgejo#gitea#ssh