Gitea auf einem VPS mit Docker selbst hosten (2026)

Jedes Team erreicht diesen Punkt. Eine Plattform ändert ihre Preise, schränkt private Repositories ein oder wird schlicht mehr zur Last als zum Gewinn. Einen eigenen Git-Server zu betreiben bedeutete früher wochenlanges Setup und eine feste Ops-Stelle für die Wartung. Mit Docker und einem preiswerten VPS ist es heute eine Sache von einem Nachmittag.

Wenn du deinen Git-Server auf einem VPS selbst hostest, bekommst du volle Hoheit über deinen Code, keine Abrechnung pro Sitzplatz und keinen Zugriff Dritter auf deine Repositories. Für einen einzelnen Entwickler oder ein kleines Team ist diese Kombination schwer zu schlagen. Gitea macht das praktikabel: Es ist eine vollständige Git-Hosting-Plattform, die auf bescheidener Hardware problemlos läuft, den kompletten Code-Review-Workflow abdeckt und in unter einer Stunde von null auf HTTPS steht.

Was ist Gitea?

Gitea ist ein quelloffener, selbstgehosteter Git-Dienst, geschrieben in Go. Das Projekt startete 2016 als Fork von Gogs und ist zu einer voll ausgestatteten Plattform für Repositories, Pull Requests, Issues, Wikis, Webhooks und eine integrierte Package Registry herangewachsen. Die Weboberfläche ähnelt GitHub so weit, dass Entwickler auf der Suche nach einer selbstgehosteten GitHub-Alternative sich vom ersten Tag an zurechtfinden.

Die Go-Runtime hält die Binary klein und den Speicherverbrauch niedrig. Laut Systemanforderungen reicht 1 GB RAM für kleine Teams und Projekte in der Regel aus. Genau das macht Gitea für einen kleinen VPS geeignet statt für eine dedizierte Maschine.

Forgejo ist ein aktiv gepflegter Community-Fork von Gitea, entstanden 2022, als Bedenken zur Governance des Projekts aufkamen. Beide teilen sich dieselbe Codebasis und Docker-Image-Struktur, sodass das in dieser Anleitung beschriebene Setup für beide gilt. Falls du dich noch nicht entschieden hast: Die FAQ am Ende geht genauer auf die Unterschiede ein.

Warum Gitea auf einem VPS selbst hosten?

Die Hauptgründe, warum Entwickler Gitea selbst hosten, haben sich nicht geändert. Sie kommen aber häufiger zur Sprache, seit die meisten gehosteten Plattformen auf Abrechnung pro Sitzplatz umgestellt haben:

• Code-Hoheit. Die Repositories liegen auf deinem Server. Kein Anbieter kann dein Konto löschen, private Repositories einschränken oder dir das Preismodell unter den Füßen wegziehen.
• Keine Kosten pro Platz. Ob 3 Nutzer oder 30: Die monatliche Rechnung bleibt gleich, nämlich das, was dein VPS kostet. Bei wenigen Euro pro Monat für einen Einsteiger-VPS von Contabo geht die Rechnung schnell zugunsten des Selbsthostens auf, sobald du mehr als zwei oder drei aktive Mitwirkende hast.
• Schlank von Grund auf. Gitea läuft auf Hardware, mit der schwerere Plattformen zu kämpfen hätten. Ein kleiner VPS bewältigt den täglichen Push-und-Pull-Betrieb eines echten Teams ohne Mühe.
• Datenstandort. Wenn dein Team oder deine Kunden verlangen, dass der Code innerhalb der EU bleibt, erfüllt Contabo diese Anforderung ohne Aufpreis. Es gibt keine separate „DSGVO-konforme Stufe“, für die du extra zahlst.

Voraussetzungen

Bevor du loslegst, stelle sicher, dass du für ein Gitea-Docker-Setup Folgendes hast:

• Einen VPS mit Ubuntu 22.04 oder 24.04 – ein Einsteiger-VPS von Contabo reicht für die meisten Teams
• Docker und Docker Compose installiert – folge unserer Docker-Installationsanleitung für Ubuntu oder nutze einfach das Docker-Add-On für deinen VPS bei Contabo
• Eine Domain oder Subdomain mit einem A-Record, der auf die IP-Adresse deines VPS zeigt (für HTTPS in Schritt 4 nötig)
• Root- oder sudo-SSH-Zugriff auf den Server

Schritt 1: VPS vorbereiten und Docker installieren

Bestell einen VPS auf der Contabo VPS-Seite. Erstelle ein sicheres Passwort und bewahre es gut auf. Deine IP-Adresse und weitere Informationen findest du in deiner „Ihre Logindaten!“-Mail, die du nach der Bestellung erhältst.

Melde dich per SSH an:

ssh root@YOUR_SERVER_IP

Aktualisiere alle Pakete, bevor du irgendetwas anderes machst:

apt update && apt upgrade -y

Stelle sicher, dass Docker für das Gitea-Docker-Setup installiert ist. Bei Contabo wählst du beim Checkout einfach das Docker-Add-On, das den VPS bereits mit installiertem und konfiguriertem Docker bereitstellt. Beide Wege führen am Ende zur selben funktionierenden Docker Engine, nur mit unterschiedlichem Aufwand und Timing. Prüfe die Versionen:

docker --version
docker compose version
sudo systemctl status docker

Lege ein eigenes Verzeichnis für den Gitea-Stack an:

mkdir -p /opt/gitea && cd /opt/gitea

Halte die Installation in /opt/gitea, damit Volumes, Compose-Dateien und alle künftigen Konfigurationsänderungen an einem Ort liegen.

Schritt 2: Gitea docker-compose.yml mit PostgreSQL

SQLite funktioniert für sehr kleine Setups, aber PostgreSQL ist die richtige Wahl für alles, was ein Team betrifft. Es verarbeitet gleichzeitige Schreibvorgänge sauber und macht Backups unkompliziert.

Bevor du den Befehl unten ausführst, ersetze zwei Werte:

• Beide Vorkommen von changeme durch ein echtes Passwort
• Beide Vorkommen von git.yourdomain.com durch deine tatsächliche Domain

Füge dann den gesamten Block für die Gitea-Installation in einem Rutsch in dein Server-Terminal ein:

cat > /opt/gitea/docker-compose.yml << 'EOF'
services:
  db:
    image: postgres:16
    restart: always
    environment:
      POSTGRES_USER: gitea
      POSTGRES_PASSWORD: changeme
      POSTGRES_DB: gitea
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - gitea_net

  gitea:
    image: gitea/gitea:latest
    restart: always
    depends_on:
      - db
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=postgres
      - GITEA__database__HOST=db:5432
      - GITEA__database__NAME=gitea
      - GITEA__database__USER=gitea
      - GITEA__database__PASSWD=changeme
      - GITEA__server__ROOT_URL=https://git.yourdomain.com
      - GITEA__server__SSH_DOMAIN=git.yourdomain.com
      - GITEA__server__SSH_PORT=222
    ports:
      - "127.0.0.1:3000:3000"
      - "222:22"
    volumes:
      - gitea_data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    networks:
      - gitea_net

networks:
  gitea_net:

volumes:
  postgres_data:
  gitea_data:
EOF

Der Befehl erstellt die Datei stillschweigend und bringt dich ohne Bestätigungsmeldung zurück zum Prompt – das ist normal. Prüfe, ob die Datei korrekt geschrieben wurde:

cat /opt/gitea/docker-compose.yml

Die Ausgabe sollte das vollständige YAML mit deinem Passwort und deiner Domain zeigen. Sobald das passt, geht es weiter mit Schritt 3 deines Gitea-Setups.

Schritt 3: Erstkonfiguration und Admin-Konto

1. Starte den Stack im Detached-Modus:

docker compose up -d

2. Warte etwa 10 Sekunden und bestätige dann, dass beide Container laufen:

docker compose ps

Sowohl db als auch gitea sollten den Status „running“ zeigen. Falls gitea neu startet, prüfe die Logs mit docker compose logs gitea – ein Datenbankverbindungsfehler an dieser Stelle bedeutet meist, dass die beiden changeme-Passwörter in deiner Compose-Datei nicht übereinstimmen.

3. Öffne http://YOUR_SERVER_IP:3000 in deinem Browser. Der Gitea-Setup-Assistent lädt beim ersten Aufruf.

• Bevor du den Assistenten öffnest, ändere ROOT_URL in deiner docker-compose.yml vorübergehend auf deine Server-IP:

GITEA__server__ROOT_URL=http://YOUR_SERVER_IP:3000

• Starte den Container neu und öffne dann den Assistenten. In Schritt 4 stellst du das auf deine echte Domain um, sobald nginx steht.

4. Die Datenbankfelder sollten bereits deine Compose-Datei widerspiegeln. Scrolle zum Abschnitt Administrator Account Settings ganz unten und lege Benutzernamen, E-Mail-Adresse und Passwort für den ersten Admin-Nutzer fest.

5. Klicke auf Install Gitea. Gitea schreibt die Konfiguration, initialisiert die Datenbank und leitet dich zur Login-Seite weiter.

6. Melde dich mit dem Benutzernamen genau so an, wie du ihn eingegeben hast – Gitea unterscheidet Groß- und Kleinschreibung, Admin und admin sind also verschieden. Beim ersten Login fordert Gitea dich auf, dein Passwort zu aktualisieren. Mach das, und du landest auf dem Dashboard.

Sobald du auf dem Dashboard bist, setze das Port-Binding in deiner docker-compose.yml wieder auf 127.0.0.1:3000:3000 zurück und starte den Container neu, bevor du zu Schritt 4 übergehst:

docker compose up -d gitea

Damit schließt du den direkten Zugriff auf Port 3000 und bereitest Gitea darauf vor, hinter nginx zu laufen.

Schritt 4: Reverse Proxy und HTTPS hinzufügen

Mit laufendem Gitea folgt als Nächstes das Einrichten eines Reverse Proxy für Gitea per nginx mit einem TLS-Zertifikat von Let’s Encrypt. So bekommst du eine echte https://-Adresse und schließt den direkten Zugriff auf Port 3000.

Du brauchst eine Domain oder Subdomain, die auf deine Server-IP zeigt, bevor es weitergeht. Falls du eine neue Domain benötigst, gibt es hier eine Schritt-für-Schritt-Anleitung, um eine Domain bei Contabo zu bekommen.

Installiere nginx und Certbot:

apt install nginx certbot python3-certbot-nginx -y

Hol dir ein TLS-Zertifikat:

certbot --nginx -d your.domain.com

Certbot fragt nach einer E-Mail-Adresse und bittet dich, den Nutzungsbedingungen zuzustimmen. Falls es nach einer Weiterleitung von HTTP auf HTTPS fragt, wähle Option 2. Bei Erfolg siehst du die bestätigten Zertifikatspfade in der Ausgabe.

Erstelle die nginx-Konfiguration für Gitea:

cat > /etc/nginx/sites-available/gitea << 'EOF'
server {
    listen 80;
    server_name your.domain.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name your.domain.com;

    ssl_certificate /etc/letsencrypt/live/your.domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your.domain.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;

    client_max_body_size 512M;

    location / {
        proxy_pass http://127.0.0.1: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;
    }
}
EOF

Aktiviere sie, entferne die Default-Site und lade nginx neu:

ln -s /etc/nginx/sites-available/gitea /etc/nginx/sites-enabled/
rm /etc/nginx/sites-enabled/default
nginx -t && systemctl reload nginx

Stelle Gitea auf deine Domain um:

Öffne deine docker-compose.yml und ändere diese beiden Zeilen auf deine echte Domain:

- GITEA__server__ROOT_URL=https://your.domain.com
- GITEA__server__SSH_DOMAIN=your.domain.com

Setze gleichzeitig das Port-Binding wieder auf localhost-only zurück:

- "127.0.0.1:3000:3000"

Starte Gitea dann neu:

docker compose up -d gitea

Öffne https://your.domain.com in deinem Browser. Du solltest die Gitea-Oberfläche über HTTPS sehen, mit gültigem Schloss-Symbol.

Schritt 5: SSH für Git-Operationen konfigurieren

Teste die Gitea-SSH-Verbindung von deinem lokalen Rechner aus:

ssh -p 222 -T [email protected]

Bei der ersten Verbindung siehst du eine Abfrage zur Host-Authentizität – tippe yes, um fortzufahren. Die erwartete Antwort ist Permission denied (publickey). Das bestätigt, dass SSH funktioniert; der Fehler bedeutet nur, dass du noch keinen Schlüssel hinzugefügt hast.

Um deinen öffentlichen SSH-Schlüssel hinzuzufügen, melde dich bei Gitea an und gehe zu User Settings > SSH / GPG Keys. Füge deinen öffentlichen Schlüssel ein und speichere. Sobald er hinzugefügt ist, klonst du ein Repository mit:

git clone ssh://[email protected]:222/username/repo.git

Gitea generiert die korrekte Klon-URL automatisch in der Repository-Oberfläche – kopier sie von dort, statt sie von Hand zusammenzubauen.

Nächste Schritte: Gitea-Server absichern und sichern

Eine laufende Gitea-Instanz ist noch keine produktionsreife. Zwei Dinge zählen, bevor du sie für fertig erklärst:

• Server härten. Deaktiviere den Root-SSH-Login, konfiguriere fail2ban für wiederholte Authentifizierungsfehler, deaktiviere die öffentliche Registrierung in den Gitea-Einstellungen, falls du sie nicht brauchst, und beschränke den eingehenden Traffic mit der Contabo Firewall im Customer Control Panel auf die Ports 22, 80, 443 und 222. Das Härten des Servers ist im Handumdrehen erledigt.
• Volumes sichern. Deine Daten liegen in den Docker-Volumes gitea_data und postgres_data. Stoppe den Stack, packe jedes Volume in ein lokales Archiv und kopiere es regelmäßig vom Server weg auf Contabo Object Storage oder ein anderes entferntes Ziel für dein Gitea-Backup.

Keines von beiden ist optional, wenn fremder Code oder fremde Arbeit von der Instanz abhängt.

Troubleshooting

Der Gitea-Container startet ständig neu. Führe docker compose logs gitea aus und suche nach der ersten Fehlerzeile. Ein password authentication failed-Fehler bedeutet, dass der Wert von GITEA__database__PASSWD nicht zu POSTGRES_PASSWORD passt. Korrigiere beide und führe dann erneut docker compose up -d aus.

Der Login leert das Formular ohne Fehlermeldung. Das heißt, der Login klappt, aber Gitea leitet dich zurück zur Login-Seite. Die Ursache ist fast immer ein ROOT_URL-Mismatch: Gitea versucht, zur konfigurierten Domain weiterzuleiten, scheitert und landet wieder beim Login. Stelle sicher, dass ROOT_URL in deiner docker-compose.yml zu der Adresse passt, über die du Gitea tatsächlich aufrufst, und starte den Container neu.

Großer Push mit 413 abgelehnt. Füge client_max_body_size im nginx-Server-Block hinzu oder erhöhe den Wert und lade nginx neu.

SSH-Klon scheitert mit Connection refused. Bestätige, dass Port 222 in deiner Firewall offen ist. Wenn du die Contabo Firewall aus dem Customer Control Panel nutzt, füge eine eingehende Regel für TCP-Port 222 hinzu.

Port 3000 vom Browser aus nicht erreichbar. Gitea ist standardmäßig an 127.0.0.1:3000 gebunden, akzeptiert also nur Verbindungen vom Server selbst. Das ist Absicht: nginx leitet die Anfragen weiter. Falls du Port 3000 zum Testen direkt aufrufen musst, ändere das Binding vorübergehend auf 0.0.0.0:3000:3000 in deiner docker-compose.yml und starte den Container neu. Setze es vor dem Produktivbetrieb wieder zurück.

Warum Gitea auf Contabo betreiben?

Gitea ist eine schlanke Arbeitslast. Ein Einsteiger-VPS hat reichlich Ressourcen, um die tägliche Git-Aktivität eines kleinen bis mittleren Teams zu bewältigen, mit Luft für die Datenbank, nginx und gelegentliche Admin-Aufgaben. Wenn du später CI/CD-Runner auf dieselbe Maschine legst, verschafft dir ein Plan höher bequemen Spielraum ohne nennenswerten Kostensprung.

Für Teams mit Anforderungen an den Datenstandort hat Contabo Rechenzentren in Europa und weltweit. Wähl bei der Bereitstellung die Region, die zu deinen Compliance-Anforderungen passt – keine Premium-Stufe, kein Papierkram.

FAQ: Gitea selbst hosten