SSD Nodes Learn Hosting plans →

Self-hosted Git server: Forgejo, Gitea లేదా cgit

RAM ఆధారంగా self-hosted Git server కోసం నాలుగు మార్గాలను పోల్చండి: SSH bare repos, cgit, Forgejo లేదా Gitea, GitLab. 1 GB VPS లో ఏది నడుస్తుందో తెలుసుకోండి.

మీరు ఏ self-hosted Git server ను నడపాలి

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

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

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

ప్రతి ఎంపికకు నిజంగా అవసరమైన RAM

ఈ ప్రాజెక్ట్‌లలో రెండు మాత్రమే hardware అవసరాన్ని ప్రచురించాయి. ప్రచురించిన సంఖ్యను హామీగా కాకుండా కనిష్ఠ స్థాయిగా పరిగణించండి. Instance ప్రారంభమైన తర్వాత systemd-cgtop లేదా ps -o rss= -C forgejo తో మీ స్వంత instance వినియోగాన్ని కొలవండి.

చార్ట్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 documentation పేర్కొంటుంది. చిన్న workload‌లకు Raspberry Pi 3 సరిపోతుందని కూడా అది చెబుతుంది. Single-node installation కు 16 GB ను baseline గా GitLab documentation పేర్కొంటుంది. GitLab స్వయంగా memory-constrained environment అని పిలిచే పరిస్థితికి 8 GB తక్కువ పరిమితిగా పేర్కొంటుంది. Forgejo installation documentation లో RAM పరిమాణం పేర్కొనలేదు. ఇది Gitea యొక్క fork మరియు దాని మాదిరిగానే పనిచేస్తుంది. అందువల్ల మీకు అందుబాటులో ఉన్న అత్యంత సమీపమైన published guide Gitea సూచనే.

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

SSH ద్వారా bare repository: Tier 0

Gitకు మీరు ప్రారంభించాల్సిన network daemon ఏదీ లేదు. git push, SSH ద్వారా అవతలి చివర git-receive-pack ను సాధారణ Unix process గా నడుపుతుంది. అందువల్ల key తో మీరు చేరుకోగల ఏ account అయినా ఇప్పటికే Git remote అవుతుంది. Repositories కోసం ఒక account సృష్టించండి. తరువాత జోడించే web view కు ఆ home directory పై access అవసరం లేకుండా, repositories ను దాని 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 చేయడం defaultగా refusing to update checked out branch: refs/heads/main తో నిరాకరించబడుతుంది. ఈ tierలో ఇదే అత్యంత సాధారణ పొరపాటు.

ఇప్పుడు ఆ 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 అని చూపించే పంక్తి ownership లేదా file mode తప్పుగా ఉందని అర్థం. నమ్మదగని owner ఉన్న, లేదా ఇతర users దానిలో రాయగల permissions ఉన్న key fileను sshd నిరాకరిస్తుంది.

Project యొక్క origin ఇప్పటికే GitHubను సూచిస్తే, git remote add origin, error: remote origin already exists. తో ఆగిపోతుంది. ఆ remoteలో ఈ serverను రెండవ push URLగా జోడించడం ద్వారా ఒక git push రెండు చోట్లా update చేయవచ్చు.

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

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

git-shell, Git SSH ద్వారా పంపే కొద్ది commandsను మాత్రమే అంగీకరిస్తుంది. అందువల్ల 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 లేవు, per-user permission లేదు. ఆ fileలోని ప్రతి key, git userకు చెందిన ప్రతి repositoryని చదవగలదు మరియు మార్చగలదు.

స్థాయి 1: cgit database లేకుండా web view అందిస్తుంది

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 అనేది cache చేసే 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
nginx site file మరియు దాన్ని ఎలా తనిఖీ చేయాలి
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ను plain filesగా అందిస్తుంది. మిగతావన్నీ 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 page కనిపిస్తే, socket unit నడవడం లేదని లేదా వేరే pathలో listen చేస్తోందని అర్థం. అది వాస్తవంగా ఉపయోగిస్తున్న path ను systemctl show line చూపిస్తుంది.

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

స్థాయి 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 లో ఉన్నదే. ఇందులో 24 October 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 line ను అనుసరిస్తుంది. 26 October 2026 న విడుదలైన Forgejo v17.0.1 ప్రస్తుత stable release. Forgejo, v17 కు 28 January 2027 వరకు support ఇస్తుంది. పాత v16 line కు 29 October 2026 న support ముగిసింది. అందువల్ల 16 tag పై ఇంకా నడుస్తున్న existing install ను ఇప్పుడు upgrade చేయాలి. ఒక major version నుంచి తదుపరి major version కు మారడం తరువాత manual upgrade అవుతుంది. కాబట్టి ప్రస్తుత version తో ప్రారంభించడం తక్కువ ఖర్చుతో కూడుకున్నది.

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

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

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

Public instance కోసం web port ను loopback address ('127.0.0.1:3000:3000') పై మాత్రమే publish చేయాలి. TLS (transport layer security) కోసం దాని ముందు nginx ను ఉంచాలి. Gitea కూడా documentation ఉపయోగించే docker.gitea.com/gitea image నుంచి ఇదే విధంగా install చేయవచ్చు. లేదా ఒక systemd unit మరియు ఒక app.ini తో single binary గా నడపవచ్చు. దాని ప్రస్తుత stable release v28.4.0. ఇది 15 November 2026 న ప్రచురించబడింది. September చివరలో v28.0.0 తో project పాత 1. prefix ను తొలగించింది. అందువల్ల 1.27 తరువాతి release 28, 1.28 కాదు.

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

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

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

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

ఎంచుకోవడానికి ఒక సంక్షిప్త నియమం ఉంది. Governance మీకు ముఖ్యమైతే, లేదా non-profit umbrella కింద ఉన్న project కావాలనుకుంటే Forgejo నడపండి. పెద్ద install base మరియు commercial support option కావాలంటే Gitea నడపండి. రెండూ open గా maintain చేయబడుతున్నాయి మరియు తరచుగా release అవుతాయి. Forgejo ప్రతి మూడు నెలలకు ఒక stable release ను, ప్రతి సంవత్సరం ఒక LTS (long term support) release ను విడుదల చేస్తుంది. 29 October 2026 నాటికి v17.0.1 ప్రస్తుత release, v15.0.11 LTS. Forgejo, v17 కు 28 January 2027 వరకు మరియు v15 కు 15 July 2027 వరకు support ఇస్తుంది. v16 support 29 October 2026 న ముగిసింది. కాబట్టి major version ను pin చేయడానికి ముందు దాని releases page ను పరిశీలించండి. ఈ రెండు నియమాల్లో ఏదీ నిర్ణయానికి సహాయపడకపోతే, Forgejo మరియు Gitea యొక్క పూర్తి పోలిక వాటి Actions మరియు package registries ఎలా భిన్నంగా ఉన్నాయో వివరిస్తుంది. మీ data నింపిన తరువాత switching ఖరీదైనదిగా మారకముందే నిర్ణయించాల్సిన వివరాలు అవే.

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

GitLab CE వేరే తరగతికి చెందిన సాఫ్ట్‌వేర్. ఒక instance అనేది పరస్పరం కలిసి పనిచేసే సేవల సమాహారం: 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 constrained environment లో కనిష్ఠ పరిమితిగా 8 GB ను పేర్కొంది. అదే page swap ను disable చేయాలని సూచిస్తుంది, ఎందుకంటే load సమయంలో swapping జరిగితే instance పనితీరు తీవ్రంగా తగ్గుతుంది. ఇవి October 2026 నాటికి ప్రచురించిన సంఖ్యలు. కాలక్రమేణా ఈ అవసరాలు పెరిగాయి. కాబట్టి server పరిమాణాన్ని నిర్ణయించే ముందు ఆ page ను మళ్లీ చదవండి.

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

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

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

సాధారణ key line ఆ account చేయగలిగిన ప్రతిదానికీ key holder కు అనుమతి ఇస్తుంది. /bin/bash ను login shell గా ఇంకా ఉపయోగించే 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 స్థానంలో మీరు పేర్కొన్న command ను అమలు చేస్తుంది. SSH server client అసలు command ను $SSH_ORIGINAL_COMMAND లో ఉంచుతుంది కాబట్టి Git సరిగ్గా పనిచేస్తుంది.

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

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

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

నా స్వంత Git సర్వర్‌లో GitHub Actions ను అమలు చేయవచ్చా?

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

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

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

బ్యాకప్‌లు: repositories మొత్తం state లో సగం మాత్రమే

Bare repository ఒక directory. అందువల్ల దాన్ని copy చేస్తే అందులోని మొత్తం data copy అవుతుంది. మరో machine నుంచి mirror clone చేయడం నిజమైన backup. ఇది repository ని అదే స్థానంలో 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 తన database లో issues, pull requests, users, keys మరియు permissions ను ఉంచుతుంది. 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 పై ఆధారపడి ఉంటుంది. కాబట్టి command 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 కు ownership ఉన్న user గా దీన్ని run చేయండి. ఆ user రాయగలిగే directory లో archive ను ఉంచండి. తరువాత archive ను server వెలుపలికి copy చేయండి. Backup తీసుకుంటున్న అదే machine పై మాత్రమే ఉన్న backup ను నిజమైన backup గా పరిగణించలేరు. Restore చేయడం చాలామంది వదిలేసే దశ. ఇప్పుడే ఒక dump ను spare box పై unpack చేసి చూడండి. అప్పుడు outage సమయంలో కాకుండా, ప్రశాంతంగా ఉన్న సమయంలో procedure నేర్చుకుంటారు.

పరిస్థితి ఆధారంగా ఎంపిక చేయండి

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

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

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

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

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

FAQ

1 GB VPS Forgejo లేదా Gitea ను నడపగలదా?

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

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

వాటికి codebase చరిత్ర మరియు చాలా features ఉమ్మడిగా ఉన్నాయి. Gitea 2016లో Gogs నుంచి fork అయింది. Gitea trademark నియంత్రణ ఒక companyకి మారిన తరువాత, 2022 చివర్లో Forgejo, Gitea నుంచి fork అయింది. Forgejo ను Germanyలోని non-profit సంస్థ Codeberg e.V. పరిధిలో దాని community అభివృద్ధి చేస్తుంది. ఇది GPLv3 కింద విడుదలవుతుంది. Gitea MIT license కిందనే కొనసాగుతూ, commercial backing ను కలిగి ఉంది. ఆచరణలో ప్రధాన తేడా 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 ఎలాంటి మార్పు లేకుండా పనిచేస్తాయి. Runner మీ repositories నుంచి arbitrary code ను execute చేస్తుంది. సాధారణ container labels ఉపయోగించినప్పుడు, ప్రతి job కోసం ఒక container ను ప్రారంభిస్తుంది. అందువల్ల దీనికి ప్రత్యేక host ఇవ్వండి. కనీసం ప్రత్యేక unprivileged user అయినా ఉపయోగించండి. ఇప్పటికే forge ను నడుపుతున్న 1 GB server పై దీన్ని అమలు చేయవద్దు.

Self-hosted Git server ను ఎలా backup చేయాలి?

Bare repositories కోసం, మరో machine నుంచి git clone --mirror అమలు చేస్తే ప్రతి ref మరియు object copy అవుతుంది. ఆ mirror లో git remote update అమలు చేస్తే అది 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 వెలుపల copy చేయండి. తరువాత అది పనిచేస్తుందో తెలుసుకోవడానికి, ఒక spare machineపై ఒకసారి restore చేయండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

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