Self-hosted Git సర్వర్‌కు Forgejo, Gitea లేదా cgit?

ఏ self-hosted Git సర్వర్‌ను నడపాలి

self-hosted Git సర్వర్ ఒకే ఉత్పత్తి కాదు. మీ VPS లోని RAM (random access memory) పరిమాణం మీరు ఉపయోగించగల దాని సంస్కరణను నిర్ణయిస్తుంది. Git కు ప్రత్యేక daemon అవసరం లేదు. మీరు అద్దెకు తీసుకోగల అతి చిన్న server లో bare repository మరియు SSH (secure shell) account ఉంటే, అది ఇప్పటికే పనిచేసే server అవుతుంది. దానికంటే పై స్థాయిలో మీరు అదనంగా నడపాలని ఎంచుకునే web application ఉంటుంది. ప్రతి తదుపరి స్థాయికి చిన్న VPS వద్ద అందుబాటులో లేకపోవచ్చు అనేంత memory అవసరం అవుతుంది.

ఇందులో నాలుగు స్థాయిలు ఉన్నాయి. SSH ద్వారా bare repository, ఇప్పటికే listening లో ఉన్న వాటికి అదనంగా మరేదీ listening చేయదు. cgit, database లేకుండా వేగవంతమైన read-only web view. Forgejo లేదా Gitea, కొన్ని వందల megabytes లో accounts, issues మరియు pull requests కలిగిన పూర్తి forge. GitLab, మిగతా వాటికంటే అనేక రెట్లు పెద్ద server ను ఆశిస్తుంది.

మీకు అవసరమైన పనిని ఆధారంగా నిర్ణయం తీసుకోండి. తరువాత మీరు చెల్లిస్తున్న plan కు సంబంధించిన memory పరిమాణంతో ఆ సంఖ్యను సరిపోల్చండి.

ప్రతి ఎంపికకు వాస్తవంగా ఎంత RAM అవసరం

ఈ ప్రాజెక్టుల్లో రెండు మాత్రమే hardware అవసరాన్ని ప్రచురించాయి. ప్రచురించిన అవసరాన్ని హామీగా కాకుండా కనీస స్థాయిగా పరిగణించండి. మీ instance నడిచిన తర్వాత 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
  }
]

చిన్న బృందాలు మరియు ప్రాజెక్ట్‌లకు 2 CPU cores తో 1 GB RAM సాధారణంగా సరిపోతుందని Gitea documentation పేర్కొంటుంది. చిన్న workloads కు Raspberry Pi 3 సరిపోతుందని కూడా అది చెబుతుంది. ఒకే node installation కు 16 GB baseline అని GitLab documentation పేర్కొంటుంది. GitLab యొక్క స్వంత పేజీ పేర్కొనే memory constrained environment కు కనీస స్థాయి 8 GB అని కూడా అందులో ఉంది. Forgejo ఎలాంటి hardware requirement ను ప్రచురించలేదు. ఇది Gitea యొక్క fork మరియు దాని మాదిరిగానే పనిచేస్తుంది. అందువల్ల మీకు లభించే సమీపమైన published guide Gitea figure.

1 GB VPSలో దీని అర్థం: bare repositories మరియు cgit కు తగినంత memory మిగులుతుంది, ఎందుకంటే ఇవి రెండూ నిరంతరం నడిచే service ను అమలు చేయవు. Forgejo లేదా Gitea start అవుతుంది మరియు SQLiteపై చిన్న బృందానికి సేవ అందిస్తుంది. అయితే మీరు documentationలో పేర్కొన్న కనీస స్థాయిపైనే ఉన్నారు. అందువల్ల PostgreSQL మరియు CI (continuous integration) runner ను ఆ serverలో ఆపివుంచండి. Error లేకుండా web interface కనిపించకుండా పోతే, sudo dmesg -T | grep -i oom అమలు చేసి Out of memory: Killed process 1181 (forgejo) వంటి line కోసం చూడండి. అప్పుడు kernel out of memory killer ఆ process ను terminate చేసిందని అర్థం. 1 GB serverలో GitLab సమస్య tuning కు సంబంధించినది కాదు. అది నడవదు.

స్థాయి 0: SSH ద్వారా bare repository

మీరు ప్రారంభించాల్సిన network daemon Gitలో లేదు. SSH ద్వారా git push ను నడిపితే, అది మరో వైపు git-receive-pack ను సాధారణ Unix processగా అమలు చేస్తుంది. అందువల్ల keyతో చేరగలిగే ఏ account అయినా ఇప్పటికే Git remoteగా ఉంటుంది. Repositories కోసం ఒక account సృష్టించండి. Repositoriesను దాని home directory బయట ఉంచండి. Ubuntu 24.04లో కొత్త home directoryకి mode 0750 ఉంటుంది. తరువాత జోడించే web view దానిలోని ఫైళ్లను చదవలేకపోవచ్చు.

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కి push చేయడాన్ని refusing to update checked out branch: refs/heads/main తో నిరాకరిస్తుంది. ఈ స్థాయిలో ఇది అత్యంత సాధారణ తప్పు.

ఇప్పుడు ఆ accountకు 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 authenticate కాలేదు. అందువల్ల server logను sudo journalctl -u ssh -n 20 తో చదవండి. Authentication refused: bad ownership or modes for file /home/git/.ssh/authorized_keys అని చూపించే పంక్తి file mode తప్పుగా ఉందని సూచిస్తుంది. ఇతర users write చేయగలిగే key fileను sshd పట్టించుకోదు.

తరువాత ఆ account నుంచి shellను తొలగించండి.

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

Git SSH ద్వారా పంపే కొద్దిపాటి commandsను మాత్రమే git-shell అంగీకరిస్తుంది. అందువల్ల interactive login ఇప్పుడు prompt చూపకుండా ఒక messageతో ఆగిపోతుంది:

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 లేవు, ప్రతి userకు విడి permissions లేవు. ఆ fileలోని ప్రతి key, git userకు చెందిన ప్రతి repositoryని చదవగలదు మరియు మార్చగలదు.

దశ 1: database లేకుండా cgit వెబ్ వీక్షణను అందిస్తుంది

cgit అనేది Cలో రాసిన CGI (common gateway interface) ప్రోగ్రామ్. ప్రతి అభ్యర్థనకు web server దీన్ని ఒకసారి నడుపుతుంది. ఇది repositories ను నేరుగా disk నుంచి చదువుతుంది. దీనికి స్వంత state ఏదీ ఉండదు. Ubuntu 24.04లో ఇది universe componentలో అందుబాటులో ఉంటుంది.

sudo apt update
sudo apt install -y cgit fcgiwrap nginx
sudo install -d -o www-data -g www-data /var/cache/cgit

/etc/cgitrc లోని repository directory ను దీనికి చూపించండి:

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 ఆ directory ను పరిశీలించి, అందులో కనిపించే ప్రతి repository ను జాబితా చేస్తుంది. అందువల్ల కొత్త bare repo అదనపు configuration లేకుండానే కనిపిస్తుంది. cache-size cached pages సంఖ్య. ఇది zeroగా ఉంటే caching నిలిపివేయబడుతుంది. మీరు అదనపు lines చేర్చే ముందు, package ఇప్పటికే /etc/cgitrc లో ఉంచిన configuration ను చదవండి. Debian మరియు Ubuntu packageలు తమ స్వంత కొన్ని defaults ను అందిస్తాయి.

ప్రతి entry repository యొక్క description fileలోని మొదటి line ను చూపిస్తుంది. అందువల్ల కొత్త bare repo తనను తాను Unnamed repository; edit this file 'description' to name the repository. గా చూపిస్తుంది. ప్రతి repositoryకి దీన్ని ఒక్కసారి సరిచేయండి:

echo 'Project X, internal tooling' | sudo -u git tee /srv/git/project.git/description

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

దీనిపై ఆధారపడి నిర్మించే ముందు తెలుసుకోవాల్సిన రెండు పరిమితులు ఉన్నాయి. cgit read-onlyగా ఉంటుంది. దీనిలో login ఉండదు. అందువల్ల scan-path లోని ప్రతిదీ publicగా ఉంటుంది. Private repositoryని ఆ directory వెలుపల ఉంచండి. లేదా మొత్తం site ముందు HTTP basic authentication అమలు చేయండి. CGI web server userగా నడుస్తుంది. కాబట్టి ఆ userకు /srv/git లోకి ప్రవేశించే మరియు ప్రతి repositoryని చదివే permissions అవసరం. ప్రవేశించలేని directory errorగా కాకుండా empty indexగా కనిపిస్తుంది.

Tier 2: issues మరియు pull requests కోసం Forgejo లేదా Gitea

Forgejo మరియు Gitea ఒకే భావనపై ఆధారపడతాయి: users, organisations, issues, pull requests, releases, package registry మరియు built-in CI system అందించే web forge ను నడిపే ఒక Go binary. Binary మరియు SQLite మాత్రమే మొత్తం installation కు అవసరం. అందుకే GitLab నడపలేని hardware పైనా ఇవి సరిపోతాయి. కింద ఉన్న Compose file Forgejo documentation లోనిదే. అందులో పేర్కొన్న image tag ను August 2026 నాటికి ఉపయోగించారు.

networks:
  forgejo:
    external: false

services:
  server:
    image: codeberg.org/forgejo/forgejo:16
    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'

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

curl line ఒక HTTP status line ను print చేయాలి. First-run setup పూర్తిచేయకముందు అది /install కు redirect కావచ్చు. అయినా service అందుబాటులో ఉందని దాని అర్థం. Container బదులుగా exit అయితే సాధారణ కారణం ownership. ./forgejo directory కి USER_UID లోని UID (user id) యాజమాన్యంగా ఉండాలి. లేకపోతే process తన data directory లో రాయలదు. VPSలో Docker Compose ఆ file layout మరియు volume ownership rule ను పూర్తిగా వివరిస్తుంది.

Setup page లోని రెండు సమాధానాలు clone URLs పనిచేస్తాయో లేదో నిర్ణయిస్తాయి. SSH port 222 అయి ఉండాలి. Compose file host port 222 ను container లోని port 22 కు map చేస్తుంది. Domain ను users వాస్తవంగా type చేసే పేరుగా నమోదు చేయాలి. వీటిలో ఏదైనా తప్పుగా ఉంటే ప్రతి repository page లో కనిపించే clone command ను copy చేసిన ప్రతి ఒక్కరికీ అది విఫలమవుతుంది. తరువాత ఇవి రెండూ app.ini లోని [server] section లో SSH_PORT, SSH_DOMAIN మరియు ROOT_URL గా ఉంటాయి.

Public instance కోసం web port ను loopback address కు మాత్రమే publish చేయండి ('127.0.0.1:3000:3000'). TLS (transport layer security) కోసం దాని ముందు nginx ను ఉంచండి. gitea/gitea image నుంచి Gitea ను కూడా ఇదే విధంగా install చేయవచ్చు. లేదా ఒక systemd unit మరియు ఒక app.ini తో single binary గా నడపవచ్చు. August 2026 నాటికి దాని current stable release 1.27.1.

సాధ్యమైనంతకాలం SQLite ను ఉపయోగించండి. దీనివల్ల instance ఒక process మరియు ఒక file కే పరిమితం అవుతుంది. అదనపు service ను supervise చేయాల్సిన అవసరం లేకుండా reboot ను కూడా ఇది తట్టుకుంటుంది. ఒకేసారి అనేక users write చేసినప్పుడు PostgreSQL ఉపయోగించడం సముచితం. SQLite writes ను serialise చేస్తుంది, కాగా దీర్ఘమైన CI runs నిరంతరం write చేస్తాయి. రెండు projects కూడా ఇప్పటికే ఉన్న instance ను తరువాత PostgreSQL కు మార్చడానికి అనుమతిస్తాయి. కాబట్టి ఇది తిరిగి మార్చలేని నిర్ణయం కాదు.

Forgejo లేదా Gitea: వాస్తవంగా ఏమి భిన్నంగా ఉంటుంది

వీటి మూల చరిత్ర ఒకటే. Gitea, 2016లో Gogs నుంచి fork అయింది. 2022 చివర్లో Gitea domain మరియు trademark పై నియంత్రణ Gitea Ltd అనే కంపెనీకి వెళ్లింది. దాంతో పలువురు maintainers, Codeberg కలిసి Forgejo ను ప్రారంభించారు. Forgejo ను జర్మనీలో నమోదైన non-profit association అయిన Codeberg e.V. ప్రచురిస్తుంది. ఇది 2024లో MIT licence నుంచి GPLv3 (GNU general public license version 3) కు మారింది. Gitea మాత్రం MIT licence లోనే ఉంది. దీని అభివృద్ధికి commercial backing ఉంది.

రోజువారీ వినియోగంలో feature sets దాదాపు ఒకేలా ఉంటాయి. అయితే వాటి మధ్య మార్పిడి మార్గం ఒకేలా లేదు. January 2025లో విడుదలైన Forgejo v10.0, Gitea database ను నేరుగా తీసుకోగలిగిన చివరి release. అది కూడా Gitea v1.22 లేదా అంతకంటే పాత version నుంచి మాత్రమే. August 2026 నాటికి Gitea 1.27.1లో ఉంది. అందువల్ల ప్రస్తుత Gitea instance ను Forgejo కు supported in-place switch ద్వారా మార్చలేరు. డేటా నింపే ముందు ఒకదాన్ని ఎంచుకోండి. తరువాత మార్చాల్సి వస్తే export చేసి మళ్లీ re-import చేయాల్సి ఉంటుందని పరిగణించండి.

ఎంపికకు ఒక సంక్షిప్త నియమం ఉంది. governance మీకు ముఖ్యమైతే, లేదా project non-profit సంస్థ వద్దనే కొనసాగాలని కోరుకుంటే, Forgejo నడపండి. ఎక్కువ install base మరియు commercial support option కావాలంటే, Gitea నడపండి. రెండూ open గా maintain చేయబడుతున్నాయి. తరచుగా releases కూడా ఇస్తాయి. Forgejo ప్రతి మూడు నెలలకు ఒక stable release ను, ప్రతి సంవత్సరం ఒక LTS (long term support) release ను విడుదల చేస్తుంది. August 2026 నాటికి v16.0.2 ప్రస్తుత release, v15.0.6 LTS release.

Tier 3: GitLab ఏ పని చేయకముందే అయ్యే ఖర్చు

GitLab CE వేరే తరగతికి చెందిన software. ఒక instance అనేది పరస్పరం కలిసి పనిచేసే services సమూహం: web application కోసం Puma, background jobs కోసం Sidekiq, PostgreSQL, Redis, repository access కోసం Gitaly, అలాగే ముందు భాగంలో nginx. Omnibus package వీటన్నింటినీ కలిసి install చేస్తుంది. అందువల్ల install సులభంగా ఉంటుంది, కానీ కనీస memory అవసరం ఎక్కువగా ఉంటుంది.

GitLab requirements page ప్రకారం, ఒకే node installation కు baseline గా 16 GB RAM మరియు 8 vCPU అవసరం. Memory పరిమితి ఉన్న environment లో 8 GB ను కనిష్ఠ స్థాయిగా పేర్కొంది. అదే page swap ను disable చేయమని చెబుతుంది. ఎందుకంటే load సమయంలో swapping జరిగితే instance పనితీరు తీవ్రంగా తగ్గుతుంది. ఇవి August 2026 నాటికి ప్రచురించిన గణాంకాలు. సంవత్సరాలు గడిచేకొద్దీ ఇవి పెరిగాయి. కాబట్టి server పరిమాణాన్ని నిర్ణయించే ముందు ఆ page ను మళ్లీ చదవండి.

ఆ బడ్జెట్‌కు మీకు వాస్తవమైన ప్రయోజనాలు లభిస్తాయి: container registry, package registry, సున్నితమైన స్థాయిలో permissions, compliance మరియు audit features, అలాగే పెద్ద స్థాయిలో పరీక్షించబడిన CI. ఈ త్రైమాసికంలో తమకు ఆ జాబితాలోని ఏదైనా అవసరమని మీ బృందంలో ఎవరూ చెప్పలేకపోతే, మీరు ప్రతిఫలం లేకుండా పెద్ద VPS కోసం చెల్లిస్తున్నట్టే.

SSH యాక్సెస్ మోడల్: ఒక git user మరియు అనేక keys

ఇక్కడి ప్రతి tier ఒకే విధంగా authentication చేస్తుంది. git అనే Unix account ఒకటి ఉంటుంది. ప్రతి public key ఆ account కు చెందిన ~/.ssh/authorized_keys లో ఉంటుంది. Authentication కు key ఉపయోగపడుతుంది. Authorisation కోసం అదే line లో key ముందు మీరు రాసే options వర్తిస్తాయి.

సాధారణ key line ఆ account చేయగలిగే ప్రతిదాన్ని దాన్ని కలిగి ఉన్న వ్యక్తికి అందిస్తుంది. 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) allocation ను ఒకే పదంతో ఆపివేస్తుంది. command= client కోరిన దాని స్థానంలో మీరు పేర్కొన్న command ను అమలు చేస్తుంది. Git తన request ను $SSH_ORIGINAL_COMMAND లో పంపుతుంది కాబట్టి Git ఇప్పటికీ పనిచేస్తుంది.

Forge ఆ file ను మీ కోసం రాస్తుంది. ఇదే tier 0 మరియు tier 2 మధ్య అసలు తేడా. Forgejo మరియు Gitea, నమోదు చేసిన ప్రతి key కు ఒక line చొప్పున authorized_keys ను తిరిగి రాస్తాయి. ప్రతి line లో database id ద్వారా ఆ key ను గుర్తించే 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 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIexamplekeyhere alice

ఈ shared Unix account ను ప్రతి user కు వేర్వేరు permissionలుగా మార్చేది ఆ forced command. key-3 ద్వారా ఏ user connect అవుతున్నాడో forge తెలుసుకుంటుంది. ఏ objects తరలించే ముందు ఆ user కు repository పై అనుమతి ఉందో forge తనిఖీ చేస్తుంది. Forge నిర్వహించే serverలో ఆ file ను స్వయంగా మార్చకండి. ఇది database నుంచి తిరిగి రాయబడుతుంది, కాబట్టి మీ line తొలగిపోతుంది. Deploy keys కూడా ఇదే విధానంతో వస్తాయి. Deploy key అనేది ఒకే repositoryకి నమోదు చేసిన సాధారణ SSH key. ఇది సాధారణంగా read-onlyగా ఉంటుంది. తనిఖీ sshdలో కాకుండా forgeలో జరుగుతుంది.

పై configuration కంటే రెండు అలవాట్లు ముఖ్యమైనవి. ప్రతి వ్యక్తికి లేదా ప్రతి machineకు ఒక key చొప్పున జారీ చేయండి. ఎప్పుడూ shared key ఉపయోగించకండి. Shared keyను revoke చేయాలంటే అందరి కోసం ఒకేసారి దాన్ని మార్చాల్సి వస్తుంది. అలాగే ఎవరైనా సంస్థను విడిచిన రోజే వారి keys తొలగించండి. లేకపోతే ఆ fileలోని పాత keyను ఎవరూ పర్యవేక్షించని శాశ్వత loginగా మిగిలిపోతుంది. Serverలో మంచి SSH key నిర్వహణ లో key types మరియు passphrases గురించి వివరాలు ఉన్నాయి. అవన్నీ ఇక్కడ కూడా ఎలాంటి మార్పు లేకుండా వర్తిస్తాయి. Server కొత్తదైతే repositories ఉంచే ముందు కొత్త VPSలో మొదటి పది నిమిషాలు చేయడం సరైన చర్య.

నేను GitHub Actions ను నా స్వంత Git సర్వర్‌పై నడపవచ్చా?

GitHub Actions syntaxలో రాసిన workflows ను మీరు నడపవచ్చు. కానీ GitHub ను మీరు నడపలేరు. Forgejo Actions Forgejo v1.21 నుంచి డిఫాల్ట్‌గా ప్రారంభించబడి ఉంది. ఇది ప్రతి repositoryలోని .forgejo/workflows నుంచి workflow files ను చదువుతుంది. Gitea Actions కూడా ఇదే విధంగా పనిచేస్తుంది. ఇది .gitea/workflows ను చదువుతుంది. రెండింటికీ runner అనే రెండో program అవసరం. దాన్ని మీ instanceలో install చేసి, admin settings నుంచి పొందిన tokenతో register చేయాలి. ప్రచురించబడిన అనేక actions ను ఎలాంటి మార్పులు లేకుండా నడపవచ్చు. అయితే GitHub APIని పిలిచేవి లేదా GitHub-hosted infrastructureపై ఆధారపడేవి పనిచేయవు.

రెండు పరిణామాలను ముందుగానే పరిగణించండి. Runner ప్రతి job కోసం ఒక containerను ప్రారంభిస్తుంది. అందువల్ల దానికి container engine మరియు ప్రత్యేక memory budget అవసరం. ఇదే కారణంగా దాన్ని forge ఉన్న 1 GB serverలో ఉంచకూడదు. Workflow fileలో ఉన్న ఆదేశాలనే runner అమలు చేస్తుంది. Forgejo documentation దీన్ని స్పష్టంగా చెబుతుంది: runner remote code executionను నిర్వహిస్తుంది. సాధ్యమైనప్పుడు దానికి ప్రత్యేక host ఇవ్వండి. కనీసం దానికి ప్రత్యేక unprivileged userను, ఒక repositoryకి మాత్రమే పరిమితమైన registration tokenను ఉపయోగించండి.

మీ repositories GitHubలోనే ఉండి, మీరు నియంత్రించే hardwareపై మాత్రమే compute నిర్వహించాలనుకుంటే, అది వేరే setup. దానికి వేరే దశలు అవసరం: self-hosted GitHub Actions runner GitHub repositoryకి అనుసంధానమవుతుంది. దీనికి పై setupలోని ఏదీ అవసరం లేదు. GitHubను వదిలివెళ్లడానికి అయ్యే ఖర్చును మీరు ఇంకా అంచనా వేస్తుంటే, GitHub వాస్తవంగా ఏమి అందిస్తుంది Git hostingను దాని చుట్టూ ఉన్న network నుంచి వేరు చేసి వివరిస్తుంది.

Backups: repositories స్థితిలో సగం మాత్రమే

Bare repository ఒక directory. అందువల్ల దాన్ని copy చేస్తే, అందులోని మొత్తం data copy అవుతుంది. మరో machine నుంచి mirror clone తీసుకోవడం నిజమైన backup, అలాగే అది స్థానంలోనే refresh అవుతుంది:

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

ఇది ప్రతి ref మరియు ప్రతి object ను తీసుకుంటుంది. అయితే server-side hooks లేదా description file తీసుకురాదు. కాబట్టి hooks ఉపయోగిస్తే directory యొక్క file-level copy ను కూడా ఉంచండి.

Forge issues, pull requests, users, keys మరియు permissions ను database లో ఉంచుతుంది. Repositories మాత్రమే copy చేస్తే ఇవన్నీ కోల్పోతారు. రెండు projects కూడా 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 లోపల run అవుతుంది. Configuration path image పై ఆధారపడి ఉంటుంది. కాబట్టి type చేయడానికి ముందు path ను పరిశీలించండి:

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

Data కు owner అయిన user గా దీన్ని run చేయండి. ఆ user write చేయగల directory లో archive ను రాయండి. తరువాత archive ను server వెలుపలికి copy చేయండి. ఎందుకంటే backup చేస్తున్న machine లో మాత్రమే ఉన్న backup నిజమైన backup కాదు. Restore చేయడం చాలామంది వదిలేసే దశ. ఇప్పుడు ఒక dump ను spare box పై unpack చేయండి. అప్పుడు outage సమయంలో కాకుండా, ప్రశాంతమైన సమయంలో procedure నేర్చుకుంటారు.

సందర్భాన్ని బట్టి ఎంపిక చేయండి

ల్యాప్‌టాప్ మరియు ఒక VPS ఉన్న ఒక వ్యక్తికి, బ్రౌజింగ్ అవసరం లేకపోతే: SSH ద్వారా bare repositories. అదనపు service ఏదీ నడవదు. upgrade చేయాల్సినది ఏదీ ఉండదు.

అదే పరిస్థితిలో code ను browserలో చదివి, దానికి links పంపాలనుకుంటే: cgit ను జోడించండి. Database ఇప్పటికీ అవసరం లేదు. నిరంతరం నడిచే service కూడా ఉండదు.

ఒకరి code ను మరొకరు review చేసి, issues ను track చేసే team కోసం: 2 GB RAM లేదా అంతకంటే ఎక్కువ ఉన్న serverలో Forgejo లేదా Gitea. Jobs వాస్తవ workload పొందడం ప్రారంభించినప్పుడు CI runner ను రెండవ machineకు తరలించండి.

Container registry మరియు audit trails అవసరమైన organisation కోసం, serverకు 16 GB RAM కేటాయించగలిగితే: GitLab. ఆ కంటే తక్కువ budget ఉంటే దీన్ని ప్రారంభించవద్దు.

మొదటి మూడు స్థాయిలలో పై స్థాయికి మారడం తక్కువ ఖర్చుతో పూర్తవుతుంది, ఎందుకంటే వాటన్నింటిలో repositories diskపై ఉన్న సాధారణ Git directoriesగానే ఉంటాయి. పని పూర్తిచేసే కనిష్ఠ స్థాయి నుంచే ప్రారంభించండి. అదే serverలో మరే సేవలకు స్థలం కేటాయించాలో నిర్ణయిస్తున్నట్లయితే, self-hostingకు విలువైన సేవల సంక్షిప్త జాబితా అదే RAM కోసం పోటీ పడే ఇతర services పక్కన Git serverను ఉంచి చూపిస్తుంది.

FAQ

1 GB VPS పై Forgejo లేదా Gitea నడుస్తుందా?

అవును. చిన్న బృందం కోసం SQLite ఉపయోగిస్తూ, ఆ సర్వర్‌పై ఇతర భారమైన సేవలు ఏవీ లేకపోతే నడుస్తుంది. చిన్న బృందాలు మరియు ప్రాజెక్ట్‌లకు 1 GB RAM, 2 CPU cores సాధారణంగా సరిపోతాయని Gitea documentation పేర్కొంటుంది. Forgejo కూడా Gitea fork కావడంతో దాని అవసరాలు దాదాపు ఇవే. ఆ మెషీన్‌పై PostgreSQL లేదా CI runner ను జోడించవద్దు. స్వంత log లో ఎలాంటి error లేకుండానే సేవ కనిపించకుండా పోతే sudo dmesg -T | grep -i oom ను అమలు చేయండి. హతమైన process పేరును చూపించే line కనిపిస్తే, kernel out of memory killer దాన్ని ఆపిందని అర్థం. ఈ సందర్భంలో tuning flag కాకుండా పెద్ద plan అవసరం.

Forgejo మరియు Gitea మధ్య తేడా ఏమిటి?

వాటికి codebase చరిత్ర మరియు చాలా features ఉమ్మడిగా ఉన్నాయి. Gitea, 2016లో Gogs నుంచి fork అయింది. Gitea trademark పై నియంత్రణ ఒక కంపెనీకి మారిన తరువాత, 2022 చివర్లో Forgejo, Gitea నుంచి fork అయింది. Forgejo ను జర్మనీలోని non-profit సంస్థ Codeberg e.V. GPLv3 కింద ప్రచురిస్తుంది. Gitea మాత్రం commercial backing తో MIT license కింద కొనసాగుతోంది. ఆచరణలో ప్రధాన తేడా migration path. January 2025లో విడుదలైన Forgejo v10.0, Gitea database ను నేరుగా స్వీకరించగలిగిన చివరి release. అది కూడా Gitea v1.22 లేదా అంతకంటే పాత version నుంచి మాత్రమే. అందువల్ల ప్రస్తుత Gitea instance కు supported in-place switch లేదు.

Self-hosted Git server పై GitHub Actions workflows ను నడపవచ్చా?

Forgejo Actions మరియు Gitea Actions రెండూ GitHub Actions YAML syntax లో రాసిన workflows ను నడుపుతాయి. అవి .forgejo/workflows మరియు .gitea/workflows నుంచి చదవబడతాయి. మీరు ప్రత్యేకమైన runner program ను install చేసి, దాన్ని మీ instance కు register చేయాలి. ప్రచురించబడిన అనేక actions ఎలాంటి మార్పులు లేకుండా పనిచేస్తాయి. అయితే GitHub API ను పిలిచే actions పనిచేయవు. Runner మీ repositories నుంచి arbitrary code ను అమలు చేస్తుంది మరియు ప్రతి job కోసం ఒక 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 అమలు చేస్తే దాని data refresh అవుతుంది. Forgejo లేదా Gitea విషయంలో repositories state లో ఒక భాగం మాత్రమే. Issues, pull requests, users మరియు keys database లో ఉంటాయి. Built-in dump, sudo -u git forgejo dump -c /etc/forgejo/app.ini ను ఉపయోగించండి. Docker install అయితే అదే command ను container లో అమలు చేయండి. Archive ను server వెలుపలికి కాపీ చేయండి. తరువాత అది పనిచేస్తుందని నిర్ధారించుకోవడానికి, spare machine పై ఒకసారి restore చేయండి.