Ghidul 2026 pentru Git self-hosted: Gitea, Forgejo și viitorul găzduirii codului

Introducere: de ce serverul tău Git din 2024 are nevoie de un upgrade

Dacă ai urmat tutorialele populare din 2024 despre configurarea unui server Git simplu pe VPS, probabil ai apreciat simplitatea: instalezi Git, creezi un utilizator, configurezi cheile SSH și faci push la cod. A funcționat. Era sigur. Și pentru o vreme, a fost suficient.

Dar acum e 2026, iar peisajul controlului de versiuni self-hosted s-a transformat dramatic. Abordarea cu server Git simplu (bare Git), deși funcțională, pare din ce în ce mai arhaică într-o lume în care dezvoltatorii se așteaptă la:

• Revizuire de cod bazată pe web cu comentarii și sugestii inline
• Fluxuri de lucru cu pull request-uri care facilitează colaborarea în echipă
• Pipeline-uri CI/CD integrate care construiesc, testează și implementează automat
• Urmărirea problemelor (issue tracking) și panouri de proiect pentru gestionarea sprint-urilor
• Registre de pachete (package registries) pentru distribuirea librăriilor și containerelor
• Compatibilitate GitHub Actions fără dependență de vendor

Acest ghid complet te ghidează prin evoluția de la serverele Git de bază la platformele moderne de găzduire cod self-hosted. Vom compara platformele de top din 2026—Gitea, Forgejo și GitLab—și vom oferi instrucțiuni pas cu pas pentru implementarea, migrarea și optimizarea infrastructurii tale Git self-hosted.

---

Capitolul 1: starea Git-ului self-hosted în 2026

Ascensiunea platformelor conduse de comunitate

Ecosistemul Git self-hosted a suferit schimbări semnificative din 2024. Cea mai notabilă evoluție a fost fork-ul Forgejo din Gitea la sfârșitul anului 2024, determinat de îngrijorări privind guvernanța corporativă și dorința unui proiect cu adevărat gestionat de comunitate. Această sciziune, deși inițial confuză, a dus la o concurență sănătoasă și inovație rapidă pe ambele platforme.

Între timp, GitLab a continuat să domine spațiul enterprise cu suita sa cuprinzătoare DevSecOps, deși cerințele sale de resurse l-au făcut mai puțin atractiv pentru implementările de dimensiuni mai mici.

Cotă de piață și tendințe de adoptare (2026)

Conform DevOps Community Survey 2025:

Platformă	Cotă de piață self-hosted	Creștere față de anul anterior
GitLab CE/EE	42%	+3%
Gitea	28%	-5% (din cauza Forgejo)
Forgejo	18%	+15% (nou intrat)
Gogs	7%	-2%
Altele	5%	-1%

Datele relevă un trend clar: platformele ușoare câștigă teren pe măsură ce dezvoltatorii caută alternative la soluțiile cu consum mare de resurse. Creșterea explozivă a Forgejo reflectă apetitul comunității pentru guvernanță transparentă și democratică în proiectele open-source.

De ce un server Git simplu nu mai este suficient

Să fim clari: serverele bare Git funcționează în continuare. Dar gândește-te la ce îți lipsește:

1. Niciun flux de revizuire a codului: membrii echipei fac push direct pe branch-uri fără revizuire.
2. Nicio vizibilitate: nu poți naviga codul, commit-urile sau istoricul fără acces SSH.
3. Nicio automatizare: testare și implementare manuală pentru fiecare modificare.
4. Nicio urmărire a problemelor: bug-urile și funcționalitățile urmărite în altă parte (dacă sunt urmărite).
5. Niciun control granular al accesului: cheile SSH sunt totul sau nimic.
6. Niciun ecosistem de integrare: nu poți conecta la instrumentele moderne DevOps.

În 2026, aceste limitări nu sunt doar inconveniențe—sunt ucigași de productivitate.

---

Capitolul 2: comparație de platforme – Gitea vs. Forgejo vs. GitLab

Prezentare generală a arhitecturii

Aspect	GitLab 16.10	Gitea 1.23	Forgejo 1.3.0
Arhitectură	Monolitic Ruby on Rails	Microservicii Go	Microservicii Go (fork din Gitea)
Bază de date	PostgreSQL (obligatoriu)	SQLite/MySQL/PostgreSQL	SQLite/MySQL/PostgreSQL/MSSQL
Dimensiune binară	~500 MB	~100 MB	~105 MB
Timp de pornire	2–5 minute	<10 secunde	<10 secunde
Licență	MIT (CE) / Comercial (EE)	MIT	MIT (guvernat integral de comunitate)

Cerințe de resurse

Aici diferențele devin clare:

Platformă	RAM Minim	RAM Recomandat	CPU Minim	Stocare (bază)
GitLab	4 GB	8 GB	4 nuclee	10 GB
Gitea	512 MB	1 GB	1 nucleu	1 GB
Forgejo	512 MB	1 GB	1 nucleu	1 GB

Testare în condiții reale pe un VPS de €5/lună (2 GB RAM, 1 vCPU):

• GitLab: Are dificultăți; OOM kills frecvente fără swap.
• Gitea: Rulează fluid la ~400 MB în repaus.
• Forgejo: Rulează fluid la ~420 MB în repaus.

Matrice de funcționalități

Funcționalitate	GitLab	Gitea	Forgejo
Interfață web	✅ Cuprinzătoare	✅ Curată, rapidă	✅ Curată, rapidă
Pull Requests	✅ Merge Requests	✅ Pull Requests	✅ Pull Requests
Revizuire cod	✅ Avansată (aprobare, reguli)	✅ De bază	✅ De bază
Probleme și panouri	✅ Epic-uri, foi de parcurs, iterații	✅ Issues, kanban	✅ Issues, kanban
CI/CD	✅ Nativ, enterprise	✅ Compatibil Actions	✅ Compatibil Actions
Registru de pachete	✅ NPM, Docker, Maven etc.	✅ Limitat	✅ Limitat
Registru de containere	✅ Integrat	⚠️ Extern	⚠️ Extern
Wiki	✅ Per proiect	✅ Per proiect	✅ Per proiect
Pagini/Găzduire	✅ GitLab Pages	⚠️ Extern	⚠️ Extern
SSO/SAML	✅ Nativ (EE)	⚠️ OAuth/OIDC	⚠️ OAuth/OIDC
Jurnale de audit	✅ Cuprinzătoare	⚠️ De bază	⚠️ De bază
Federare	❌	❌	✅ ForgeFed (ActivityPub)
Compatibilitate GitHub Actions	⚠️ Prin terți	✅ Nativă	✅ Nativă

Benchmark-uri de performanță (teste 2026)

Teste de încărcare pe instanțe VPS identice de €10/lună (4 GB RAM, 2 vCPU) cu 50 de utilizatori concurenți:

Metrică	GitLab	Gitea	Forgejo
Timp de încărcare pagină	1.8s	0.4s	0.4s
Git Clone (repo 100 MB)	12s	8s	8s
Git Push (repo 100 MB)	15s	9s	9s
Start pipeline CI	3s	0.5s	0.5s
Interogare de căutare (full-text)	2.1s	0.3s	0.3s
Memorie sub sarcină	3.2 GB	800 MB	850 MB

Câștigătorul la performanță: Gitea și Forgejo sunt la egalitate, ambele depășind semnificativ GitLab pe hardware cu resurse limitate.

---

Capitolul 3: alegerea platformei tale

Alege GitLab dacă...

• Ești o companie enterprise cu cerințe de conformitate (SOC 2, HIPAA, GDPR).
• Ai nevoie de scanare de securitate integrată (SAST, DAST, scanare dependențe).
• Echipa ta necesită management avansat de proiecte (epic-uri, foi de parcurs, urmărire timp).
• Ai ingineri DevOps dedicați pentru întreținerea infrastructurii.
• Bugetul permite hardware adecvat (8+ GB RAM, stocare SSD).
• Vrei suport de la vendor pentru instalarea self-hosted.

Utilizatorul tipic GitLab: companie cu 50+ angajați, industrie reglementată, echipă DevOps existentă.

Alege Gitea dacă...

• Ești o echipă mică (1–20 dezvoltatori) sau un dezvoltator individual.
• Vrei compatibilitate GitHub Actions fără GitHub.
• Eficiența resurselor este o prioritate principală (rulând pe Raspberry Pi sau VPS ieftin).
• Preferi să îți alegi propriile instrumente CI/CD (Woodpecker, Jenkins, Drone).
• Prețuiești simplitatea și viteza în detrimentul funcționalităților exhaustive.
• Ești confortabil cu suportul comunității (Discord, forumuri, GitHub issues).

Utilizatorul tipic Gitea: startup, dezvoltator freelance, entuziast homelab, agenție mică.

Alege Forgejo dacă...

• Prioritizezi guvernanța comunitară față de controlul corporativ.
• Ești interesat de dezvoltare federată (ForgeFed/ActivityPub).
• Vrei Gitea cu credențiale FOSS mai puternice.
• Migrezi de pe GitHub și vrei alternative etice.
• Susții ecosistemul Codeberg și găzduirea independentă.
• Crezi în foi de parcurs transparente și luarea deciziilor de către comunitate.

Utilizatorul tipic Forgejo: contributor open-source, avocat al confidențialității, utilizator Codeberg, organizație FOSS.

---

---

Capitolul 4: pas cu pas – instalarea Forgejo pe VPS-ul tău

Cerințe preliminare

• Un VPS cu cel puțin 1 GB RAM (recomandat 2 GB)
• Ubuntu 22.04/24.04 sau Debian 12
• Nume de domeniu care pointează spre serverul tău (opțional, dar recomandat)
• Docker și Docker Compose instalate
• Familiaritate de bază cu linia de comandă Linux

Pasul 1: pregătește-ți VPS-ul

# Actualizează pachetele sistemului
sudo apt update && sudo apt upgrade -y

# Instalează Docker (dacă nu e deja instalat)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

# Instalează Docker Compose
sudo apt install docker-compose-plugin -y

# Verifică instalarea
docker --version
docker compose version

# Deconectează-te și reconectează-te pentru ca modificările de grup să aibă efect

Pasul 2: creează structura de directoare

# Creează directoarele Forgejo
sudo mkdir -p /srv/forgejo/{data,config}
sudo chown -R $USER:$USER /srv/forgejo

# Navighează la director
cd /srv/forgejo

Pasul 3: creează configurația Docker Compose

Creează fișierul docker-compose.yml:

version: '3.8'

services:
  forgejo:
    image: codeberg.org/forgejo/forgejo:1.3
    container_name: forgejo
    restart: unless-stopped
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - FORGEJO__database__DB_TYPE=sqlite3
      - FORGEJO__server__DOMAIN=git.yourdomain.com
      - FORGEJO__server__ROOT_URL=https://git.yourdomain.com
      - FORGEJO__server__HTTP_PORT=3000
      - FORGEJO__server__SSH_PORT=22
      - FORGEJO__server__SSH_LISTEN_PORT=2222
    ports:
      - "3000:3000"    # Web UI
      - "2222:22"      # SSH (portul gazdă 2222 -> portul container 22)
    volumes:
      - ./data:/data
      - ./config:/etc/forgejo
    networks:
      - forgejo-network
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/"]
      interval: 30s
      timeout: 10s
      retries: 3

networks:
  forgejo-network:
    driver: bridge

Pasul 4: pornește Forgejo

# Pornește containerul
docker compose up -d

# Verifică statusul
docker compose ps

# Vizualizează log-urile
docker compose logs -f forgejo

Forgejo ar trebui să ruleze acum. Accesează-l la http://ip-server-ul-tau:3000.

Pasul 5: configurează reverse proxy cu SSL (recomandat)

# Instalează Nginx și Certbot
sudo apt install nginx certbot python3-certbot-nginx -y

# Creează configurația Nginx
sudo nano /etc/nginx/sites-available/forgejo

Adaugă această configurație:

server {
    listen 80;
    server_name git.yourdomain.com;

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$server_name$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name git.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/git.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/git.yourdomain.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    # Mărește dimensiunea maximă a upload-ului pentru Git pushes
    client_max_body_size 500M;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Suport WebSocket
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Activează site-ul și obține certificatul SSL:

# Activează site-ul
sudo ln -s /etc/nginx/sites-available/forgejo /etc/nginx/sites-enabled/

# Creează directorul certbot
sudo mkdir -p /var/www/certbot

# Testează configurația Nginx
sudo nginx -t

# Reîncarcă Nginx
sudo systemctl reload nginx

# Obține certificatul SSL
sudo certbot --nginx -d git.yourdomain.com

# Reînnoirea automată este configurată automat

Pasul 6: configurarea inițială Forgejo

1. Vizitează https://git.yourdomain.com.
2. Creează-ți contul de administrator.
3. Configurează setările site-ului: titlul site-ului, rădăcina repository-urilor (lasă implicit) și dezactivează înregistrarea dacă vrei acces numai prin invitație.
4. Salvează configurația.

---

Capitolul 5: migrarea de la un server Git simplu la Forgejo

Dacă ai un server bare Git existent din tutorialele din 2024, migrarea este simplă.

Pasul 1: exportă cheile SSH

# Pe vechiul tău server Git, fă backup la authorized_keys
sudo cat /home/git/.ssh/authorized_keys > ~/authorized_keys_backup

Pasul 2: clonează toate repository-urile local

# Creează un director temporar
mkdir ~/git-migration
cd ~/git-migration

# Clonează toate repository-urile ca mirror-uri
for repo in /home/git/repositories/*.git; do
    repo_name=$(basename $repo)
    git clone --mirror file://$repo $repo_name
done

Pasul 3: trimite la Forgejo

# Pentru fiecare repository:
cd ~/git-migration/myproject.git

# Adaugă Forgejo ca remote (înlocuiește cu datele tale)
git remote add forgejo ssh://git@git.yourdomain.com:2222/username/myproject.git

# Trimite totul
git push --mirror forgejo

Pasul 4: automatizează migrarea (script opțional)

Creează migrate-all.sh:

#!/bin/bash

FORGEJO_USER="username-ul-tau"
FORGEJO_HOST="git.yourdomain.com"
FORGEJO_PORT="2222"

for repo in /home/git/repositories/*.git; do
    repo_name=$(basename $repo .git)

    echo "Migrând $repo_name..."

    cd ~/git-migration
    git clone --mirror file://$repo ${repo_name}.git

    cd ${repo_name}.git
    git remote add forgejo ssh://git@${FORGEJO_HOST}:${FORGEJO_PORT}/${FORGEJO_USER}/${repo_name}.git
    git push --mirror forgejo

    cd ~/git-migration
    rm -rf ${repo_name}.git
done

echo "Migrare completă!"

Pasul 5: actualizează remote-urile locale

Pe fiecare mașină a dezvoltatorilor:

cd /calea/spre/proiectul/tau

# Elimină remote-ul vechi
git remote remove origin

# Adaugă noul remote Forgejo
git remote add origin ssh://git@git.yourdomain.com:2222/username/myproject.git

# Verifică
git remote -v

# Testează push-ul
git push origin main

---

Capitolul 6: configurarea CI/CD cu Forgejo Actions

Unul dintre cele mai mari avantaje față de un server bare Git este CI/CD integrat. Atât Gitea, cât și Forgejo suportă workflow-uri compatibile cu GitHub Actions.

Activează Actions în Forgejo

1. Mergi la Administrare site → Configurare.
2. La secțiunea Actions, activează "Enable Actions".
3. Salvează setările.

Configurează un runner

Forgejo are nevoie de runnere pentru a executa workflow-urile. Folosește containerul oficial de runner (token-ul este disponibil din panoul de administrare Forgejo):

# Creează directorul pentru runner
sudo mkdir -p /srv/forgejo-runner
cd /srv/forgejo-runner

# Rulează runner-ul
docker run -d 
  --name forgejo-runner 
  --restart unless-stopped 
  -v /var/run/docker.sock:/var/run/docker.sock 
  codeberg.org/forgejo/runner:latest 
  daemon --token TOKEN_TÂU_DE_RUNNER --instance https://git.yourdomain.com

Exemplu de workflow: proiect Node.js

Creează .forgejo/workflows/ci.yml în repository-ul tău:

name: CI Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout cod
        uses: actions/checkout@v4

      - name: Configurează Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Instalează dependențele
        run: npm ci

      - name: Rulează testele
        run: npm test

      - name: Build
        run: npm run build

      - name: Încarcă artefactele de build
        uses: actions/upload-artifact@v4
        with:
          name: dist
          path: dist/

  docker:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'

    steps:
      - name: Checkout cod
        uses: actions/checkout@v4

      - name: Construiește și trimite imaginea Docker
        run: |
          docker build -t ${FORGEJO_HOST}/${GITHUB_REPOSITORY}:latest .
          docker push ${FORGEJO_HOST}/${GITHUB_REPOSITORY}:latest

---

Capitolul 7: configurare avansată și optimizare

Alegerea bazei de date

Pentru echipe mici (<10 utilizatori), SQLite este în regulă (implicit, fără configurare). Pentru echipe mai mari, treci la PostgreSQL actualizând docker-compose.yml:

services:
  postgresql:
    image: postgres:16
    environment:
      POSTGRES_USER: forgejo
      POSTGRES_PASSWORD: parola_sigura_aici
      POSTGRES_DB: forgejo
    volumes:
      - ./postgres-data:/var/lib/postgresql/data
    networks:
      - forgejo-network

  forgejo:
    # ... configurație existentă ...
    environment:
      - FORGEJO__database__DB_TYPE=postgres
      - FORGEJO__database__HOST=postgresql:5432
      - FORGEJO__database__NAME=forgejo
      - FORGEJO__database__USER=forgejo
      - FORGEJO__database__PASSWD=parola_sigura_aici

Activează caching-ul cu Redis

# Adaugă în docker-compose.yml
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    networks:
      - forgejo-network

  forgejo:
    # ... configurație existentă ...
    environment:
      - FORGEJO__cache__ADAPTER=redis
      - FORGEJO__cache__HOST=redis:6379

Strategie de backup

Creează backup-forgejo.sh:

#!/bin/bash

BACKUP_DIR="/backups/forgejo"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR

# Oprește Forgejo
docker compose -f /srv/forgejo/docker-compose.yml down

# Backup la directorul de date
tar -czf $BACKUP_DIR/forgejo_data_$DATE.tar.gz -C /srv/forgejo data

# Backup la baza de date (dacă folosești PostgreSQL)
docker exec forgejo-postgresql pg_dump -U forgejo forgejo > $BACKUP_DIR/forgejo_db_$DATE.sql

# Repornește Forgejo
docker compose -f /srv/forgejo/docker-compose.yml up -d

# Păstrează doar ultimele 7 backup-uri
find $BACKUP_DIR -name "forgejo_*.tar.gz" -mtime +7 -delete
find $BACKUP_DIR -name "forgejo_*.sql" -mtime +7 -delete

echo "Backup complet: $DATE"

Adaugă în crontab pentru backup-uri zilnice automate:

# Editează crontab
crontab -e

# Adaugă backup zilnic la 3 AM
0 3 * * * /srv/forgejo/backup-forgejo.sh >> /var/log/forgejo-backup.log 2>&1

---

Capitolul 8: bune practici de securitate

1. Activează autentificarea în doi factori (2FA)

Navighează la Setări utilizator → Securitate → Activează TOTP 2FA. Impune-o la nivel de site din Administrare site → Surse de autentificare.

2. Configurează cerințele pentru cheile SSH

[security]
MINIMUM_KEY_SIZE = 4096
DISABLE_SSH = false
START_SSH_SERVER = false  # Folosește SSH-ul sistemului

3. Configurează lista albă de IP-uri (enterprise)

[security]
ALLOWED_HOSTS = 192.168.1.0/24,10.0.0.0/8

4. Actualizări de securitate regulate

# Descarcă cea mai recentă imagine Forgejo lunar
cd /srv/forgejo
docker compose pull
docker compose up -d

5. Activează jurnalizarea completă a auditului

[log]
MODE = console, file
LEVEL = info

---

Capitolul 9: viitorul Git-ului self-hosted

Federare și Fediverse

Implementarea ForgeFed din Forgejo (bazată pe ActivityPub) permite descoperirea repository-urilor și colaborarea între instanțe diferite—similar cu modul în care utilizatorii Mastodon interacționează între servere. Aceasta ar putea remodela fundamental colaborarea open-source în 2027 și după, eliminând dependența de orice platformă centralizată.

Dezvoltare asistată de AI

Sunt de așteptat integrări native pentru:

• Sugestii de revizuire cod bazate pe AI direct în pull request-uri
• Scanare automată de securitate integrată în pipeline-uri CI/CD
• Rezolvare inteligentă a conflictelor de merge
• Completare de cod în editorul web integrat

Edge computing și Git

Pe măsură ce edge computing-ul crește, platformele Git self-hosted ar putea oferi:

• Mirror-uri de repository distribuite pentru acces cu latență redusă
• Runnere CI/CD edge pentru echipe distribuite geografic
• Workflow-uri offline-first cu sincronizare automată

---

Concluzie: călătoria ta self-hosted începe acum

Diferența dintre serverele bare Git și platformele moderne de găzduire cod este uriașă—dar niciodată nu a fost mai ușor să o traversezi. Cu platforme precum Forgejo și Gitea, obții 80% din funcționalitatea GitHub cu 20% din costul de resurse și 100% control asupra datelor tale.

Pașii tăi următori:

1. Instalează Forgejo folosind ghidul de mai sus (30 de minute)
2. Migrează un repository pentru a testa workflow-ul (15 minute)
3. Configurează CI/CD pentru proiectul tău principal (1 oră)
4. Invită echipa și configurează controlul accesului (30 de minute)
5. Bucură-te de găzduire Git modernă în propriii tăi termeni

Viitorul găzduirii codului nu mai ține doar de stocarea versiunilor—este despre activarea colaborării, automatizarea workflow-urilor și menținerea suveranității asupra proprietății tale intelectuale. Platformele Git self-hosted din 2026 le livrează pe toate trei.