# Gogs mit Docker installieren: Schritt-für-Schritt-Anleitung

Gogs ist ein leichtgewichtiger, selbst gehosteter Git-Server, der sich ideal für kleine Teams und private Projekte eignet. Dank geringer Systemanforderungen und einfacher Installation können Sie innerhalb weniger Minuten eine eigene Git-Plattform betreiben. In dieser Anleitung erfahren Sie Schritt für Schritt, wie Sie Gogs mit Docker einrichten.

## Schritt 1: Voraussetzungen prüfen und passende Server-Ressourcen wählen

Bevor Sie starten, sollten Sie sicherstellen, dass Ihre Umgebung die grundlegenden Anforderungen erfüllt. Für die Installation benötigen Sie einen **Linux-Server** (z. B. Ubuntu 24.04 oder neuer), Root- oder Sudo-Zugriff sowie eine funktionierende Internetverbindung.

Darüber hinaus ist es wichtig, die passende Servergröße zu wählen. Je nach Einsatzzweck unterscheiden sich die Anforderungen teils erheblich.

### Private Code-Archive

Wenn Sie [Gogs](https://www.ionos.de/digitalguide/server/knowhow/gogs/) lediglich als persönliches Git-[Repository](https://www.ionos.de/digitalguide/server/knowhow/repository/) nutzen möchten, reichen bereits geringe Ressourcen aus. In diesem Szenario hosten Sie Ihre eigenen Projekte, ohne auf externe Plattformen angewiesen zu sein. Praktisch ist dies vor allem, wenn Sie experimentelle oder private Projekte verwalten. Die Last auf dem System bleibt gering, da **nur wenige parallele Zugriffe** stattfinden. Auch [Backups](https://www.ionos.de/digitalguide/server/sicherheit/was-ist-ein-backup/) lassen sich einfach umsetzen. Für Einsteigerinnen und Einsteiger ist dies der ideale Startpunkt, denn Sie profitieren von maximaler Kontrolle bei minimalem Aufwand.

### Internes Repository für sensible Firmendaten

Für Unternehmen ist Gogs eine geeignete Lösung, wenn Code bewusst nicht in die Cloud ausgelagert werden soll. Hier spielen **Sicherheit und Zugriffskontrolle** eine zentrale Rolle. Entsprechend sollten Sie mehr [RAM](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-arbeitsspeicher/) und [CPU](https://www.ionos.de/digitalguide/server/knowhow/cpu/) einplanen. Auch regelmäßige Backups und Zugriffsbeschränkungen sind essenziell. In solchen Setups greifen mehrere Entwicklerinnen und Entwickler im Regelfall gleichzeitig auf das System zu. Zusätzlich kann eine Integration in bestehende Infrastruktur sinnvoll sein. Insgesamt steigt daher der Ressourcenbedarf deutlich an.

### Edge Computing und IoT-Entwicklung

In [IoT](https://www.ionos.de/digitalguide/websites/online-recht/internet-of-things/)-Umgebungen entstehen häufig viele kleine Codeänderungen, die immer wieder versioniert werden müssen. Gogs eignet sich in diesen Fällen hervorragend, um die Änderungen lokal oder in [Edge](https://www.ionos.de/digitalguide/server/knowhow/edge-computing-erklaerung-und-definition/)-Umgebungen zu verwalten. Die Anforderungen für den Server liegen zwischen privaten und unternehmensweiten Setups. Wichtig ist hier vor allem eine **stabile Performance** bei vielen kleinen Schreibzugriffen. Zudem profitieren Sie von der Offline-Fähigkeit eines selbst gehosteten Systems. Gerade in verteilten Umgebungen ist das ein großer Vorteil. Auch Automatisierungen lassen sich in diesem Setup gut integrieren.

### Bildung und Workshops

In Schulungen oder Workshops greifen viele Nutzerinnen und Nutzer gleichzeitig auf das System zu. Daher sollten Sie ausreichend Ressourcen einplanen, um Performance-Probleme zu vermeiden. Besonders wichtig ist in diesen Use Cases eine einfache Benutzerverwaltung. Gogs punktet hier durch seine **intuitive Oberfläche**. Für Lernumgebungen ist das ideal. Zusätzlich lassen sich schnell neue Repositories erstellen. So können Teilnehmende direkt praktisch arbeiten. Die Systemlast ist jedoch deutlich höher als bei Einzelanwendungen.

### Spiegel-Server (Mirroring) als Backup

Wenn Sie Gogs als Backup-Lösung einsetzen, beispielsweise zur Spiegelung externer Repositories, benötigen Sie vor allem **Speicherplatz und stabile IO-Leistung**. In diesem Szenario werden regelmäßig Daten synchronisiert. Dadurch entstehen auch höhere Lastspitzen, was vor allem bei großen Projekten relevant sein kann. Eine robuste Infrastruktur ist daher entscheidend. Auch automatisierte Synchronisationen sollten zuverlässig laufen. Für produktive Umgebungen ist dies eine sinnvolle Ergänzung.

### Anforderungen im Überblick

<table>
  <thead>
    <tr>
      <th>Anwendungsgebiet</th>
      <th>CPU</th>
      <th>RAM</th>
      <th>Speicher</th>
      <th>Nutzeranzahl</th>
      <th>Besonderheiten</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><strong>Private Code-Archive</strong></td>
      <td>2 vCores</td>
      <td>2–4 GB</td>
      <td>80–120 GB NVMe</td>
      <td>1–3</td>
      <td>Minimaler Ressourcenbedarf</td>
    </tr>
    <tr>
      <td><strong>Internes Firmen-Repository</strong></td>
      <td>4–6 vCores</td>
      <td>8 GB</td>
      <td>200–300 GB NVMe</td>
      <td>3–10</td>
      <td>Höhere Sicherheit und Backups</td>
    </tr>
    <tr>
      <td><strong>Edge Computing / IoT</strong></td>
      <td>2–4 vCores</td>
      <td>4 GB</td>
      <td>100 GB NVMe</td>
      <td>3–10</td>
      <td>Viele kleine Commits</td>
    </tr>
    <tr>
      <td><strong>Bildung und Workshops</strong></td>
      <td>4 vCores</td>
      <td>6–8 GB</td>
      <td>150 GB NVMe</td>
      <td>20+</td>
      <td>Parallele Zugriffe</td>
    </tr>
    <tr>
      <td><strong>Spiegel-/Backup-Server</strong></td>
      <td>4 bis 8 vCores</td>
      <td>8–16 GB</td>
      <td>300+ GB NVMe</td>
      <td>variabel</td>
      <td>Hohe IO-Last</td>
    </tr>
  </tbody>
</table>

## Schritt 2: Docker und Docker Compose installieren

Falls [Docker](https://www.ionos.de/digitalguide/server/knowhow/was-ist-docker/) und [Docker Compose](https://www.ionos.de/digitalguide/server/konfiguration/docker-compose-tutorial/) auf Ihrem Server noch nicht installiert sind, starten Sie zunächst mit der Installation. Aktualisieren Sie dazu in einem ersten Schritt die Paketquellen Ihres Systems, damit Sie die neuesten verfügbaren Versionen installieren können. Anschließend installieren Sie Docker Engine sowie das Docker-Compose-Plugin. Für eine stabile und aktuelle Installation empfiehlt es sich, Docker **direkt aus dem offiziellen Docker-Repository** zu installieren. Die Paketversionen der Standard-Distributionen sind häufig veraltet oder unvollständig, was zu Problemen führen kann. Führen Sie dafür folgende Befehle im Terminal aus:

```bash
sudo apt update
sudo apt install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo tee /etc/apt/keyrings/docker.asc > /dev/null
sudo chmod a+r /etc/apt/keyrings/docker.asc
 
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

Nach der Installation stellen Sie sicher, dass der Docker-Dienst automatisch beim Systemstart geladen wird und starten ihn direkt:

```bash
sudo systemctl enable docker
sudo systemctl start docker
```

Zum Abschluss überprüfen Sie, ob beide Komponenten korrekt installiert wurden, indem Sie sich die Versionsnummern anzeigen lassen:

```bash
docker --version
docker compose version
```

Wenn hier Versionsinformationen ausgegeben werden, ist die Installation erfolgreich abgeschlossen und Sie können mit dem nächsten Schritt fortfahren.

[![Bild: Versionsanzeige von Docker und Docker Compose im Terminal](https://www.ionos.de/digitalguide/fileadmin/_processed_/d/1/csm_gogs-docker-version_35183e5915.webp "Versionsanzeige von Docker und Docker Compose im Terminal")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/gogs-docker-version.jpg) Die Anzeige der Versionsnummer von Docker und Docker Compose bestätigt die erfolgreiche Installation der Dienste. ## Schritt 3: Projektverzeichnis erstellen

Erstellen Sie zunächst ein **eigenes Verzeichnis** für Ihr Gogs-Projekt, damit alle Dateien sauber an einem Ort organisiert sind. So behalten Sie später leichter den Überblick und können Konfigurationen oder Daten gezielt verwalten.

```bash
mkdir gogs-docker
cd gogs-docker
```

In diesem Ordner wird anschließend die sogenannte `docker-compose.yml` gespeichert sowie ein Datenverzeichnis angelegt, in dem Gogs dauerhaft Ihre Repositories und Einstellungen ablegt. Dies klappt selbst dann, wenn der [Docker-Container](https://www.ionos.de/digitalguide/server/knowhow/docker-container/) neu gestartet wird.

## Schritt 4: Docker-Compose-Datei erstellen

Erstellen Sie nun die zentrale Konfigurationsdatei für Ihre Container-Umgebung. In dieser Datei definieren Sie, wie Gogs gestartet wird, welche Ports erreichbar sind und wo die Daten gespeichert werden. Legen Sie dazu die Datei namens `docker-compose.yml` an und öffnen Sie sie in einem Editor Ihrer Wahl:

```bash
nano docker-compose.yml
```

Fügen Sie anschließend folgenden Inhalt ein:

```yaml
services:
    gogs:
        image: gogs/gogs:latest
        container_name: gogs
        ports:
            - "3000:3000"
            - "10022:22"
        volumes:
            - ./gogs-data:/data
        restart: unless-stopped
```

Hinweis Verwenden Sie für produktive Installationen statt des dynamischen Tags `latest` eine feste Version wie beispielsweise `gogs/gogs:0.14.3` oder neuer. So stellen Sie sicher, dass Ihre Installation reproduzierbar bleibt und Updates kontrolliert durchgeführt werden können.

Der Port 3000 stellt die Weboberfläche bereit, während 10022 für Git-Zugriffe per [SSH](https://www.ionos.de/digitalguide/server/tools/secure-shell-ssh/) verwendet wird. Über das Volume `./gogs-data:/data` werden alle Daten persistent gespeichert, sodass sie auch nach einem Neustart erhalten bleiben. Speichern Sie die soeben erstellte Datei und schließen Sie den Editor.

[![Bild: docker-compose.yml im Editor](https://www.ionos.de/digitalguide/fileadmin/_processed_/4/1/csm_gogs-docker-compose_52eb290a9a.webp "docker-compose.yml im Editor")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/gogs-docker-compose.jpg) In der Datei docker-compose.yml definieren Sie Ihren Gogs-Container und legen grundlegende Konfigurationen fest.  Tipp Für den produktiven Einsatz sollten Sie Gogs nicht direkt über den offenen Port 3000 betreiben. Stattdessen empfiehlt sich der Einsatz eines Reverse Proxy. Dieser ermöglicht es Ihnen, eine eigene Domain zu nutzen und den Zugriff per HTTPS abzusichern. So schützen Sie sensible Daten wie Zugangsdaten und Repository-Inhalte vor unverschlüsselter Übertragung. Gleichzeitig lassen sich über den [Reverse Proxy](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-reverse-proxy/) zusätzliche Sicherheitsmechanismen wie Zugriffsbeschränkungen oder Weiterleitungen umsetzen.

## Schritt 5: Gogs starten

Nachdem Sie die Konfigurationsdatei erstellt haben, können Sie den Container nun starten. Wechseln Sie dafür in das Verzeichnis, in dem sich die `docker-compose.yml` befindet, und führen Sie folgenden Befehl aus:

```bash
docker compose up -d
```

Wenn Sie nicht direkt als Root-User arbeiten, führen Sie Docker-Befehle mit `sudo` aus, damit Ihr User auf den Docker-Dienst zugreifen kann.

Der Parameter `-d` sorgt dafür, dass der Container im Hintergrund im sogenannten **Detached Mode** läuft und Ihr Terminal weiterhin nutzbar bleibt. Beim ersten Start lädt Docker automatisch das benötigte Image aus dem Internet, was je nach Verbindung einen Moment dauern kann.

In der Ausgabe sollte nun ein Eintrag für Gogs erscheinen. Wenn der Status „Started“ angezeigt wird, läuft der Dienst korrekt und Sie können im nächsten Schritt die Weboberfläche aufrufen.

[![Bild: Gestarteter Gogs-Docker-Container im Terminal](https://www.ionos.de/digitalguide/fileadmin/_processed_/6/3/csm_gogs-docker-compose-up_85119f42fa.webp "Gestarteter Gogs-Docker-Container im Terminal")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/gogs-docker-compose-up.jpg) Im Terminal sollten Sie Ihren Gogs-Docker-Container mit dem Status „Started“ sehen. ## Schritt 6: Weboberfläche aufrufen und konfigurieren

Öffnen Sie nun Ihren [Browser](https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-ein-browser/) und rufen Sie die Gogs-Weboberfläche über die [IP-Adresse](https://www.ionos.de/digitalguide/server/knowhow/was-ist-eine-ip-adresse/) Ihres Servers auf:

```bash
http://SERVER-IP:3000
```

Ersetzen Sie &lt;SERVER-IP&gt; durch die tatsächliche IP-Adresse Ihres Servers. Wenn die Seite nicht erreichbar ist, prüfen Sie, ob der Container läuft und ob Port 3000 in der Firewall Ihres Servers freigegeben ist.

Hinweis Wenn Sie einen Server von IONOS nutzen, müssen Sie den **Port 3000 und optional 10022** für SSH zusätzlich in der [Firewall](https://www.ionos.de/digitalguide/server/sicherheit/was-ist-eine-firewall/) freigeben. Öffnen Sie dazu im Cloud Panel den Bereich „Netzwerk“ und dann „Firewall-Richtlinien“ und erlauben Sie eingehenden Datenverkehr für die entsprechenden Ports. Erst danach ist die Gogs-Weboberfläche von außen erreichbar.

Beim ersten Aufruf erscheint der Installationsassistent von Gogs. Für Einsteigerinnen und Einsteiger ist **SQLite als Datenbank die einfachste Wahl**, da dafür kein zusätzlicher Datenbankserver eingerichtet werden muss. Der Repository-Pfad kann in der Regel unverändert bleiben, da die Daten über das zuvor eingerichtete Volume dauerhaft unter `/data` gespeichert werden.

Da der SSH-Port des Containers über Docker auf Port 10022 des Servers weitergeleitet wird, tragen Sie im Installationsassistenten im Feld „SSH-Port“ den Wert 10022 ein. So verwendet Gogs den korrekten externen Port in den angezeigten SSH-Clone-URLs.

[![Bild: Gogs im Browser nach dem ersten Start](https://www.ionos.de/digitalguide/fileadmin/_processed_/6/8/csm_gogs-docker-erster-start_a006847486.webp "Gogs im Browser nach dem ersten Start")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/gogs-docker-erster-start.jpg) Wenn Sie Gogs das erste Mal in Ihrem Browser starten, sehen Sie den Installationsassistenten, der Sie durch die Einrichtung des Git-Servers führt. Legen Sie anschließend einen Admin-Account an. Mit diesem User verwalten Sie später Repositories, Nutzerkonten und grundlegende Einstellungen. Klicken Sie zum Abschluss auf Installieren, um die Einrichtung abzuschließen.

## Schritt 7: Erste Schritte in Gogs

Nach der erfolgreichen Installation werden Sie automatisch in das **Dashboard** von Gogs weitergeleitet. Von hier aus können Sie Ihre Git-Umgebung verwalten und direkt mit der Arbeit beginnen. Die Oberfläche ist einfach gehalten, sodass Sie sich schnell zurechtfinden.

Zunächst können Sie weitere Benutzerkonten anlegen, wenn mehrere Personen auf den Server zugreifen sollen. Anschließend erstellen Sie Ihr erstes Repository, entweder leer oder durch Import eines bereits bestehenden Projekts. Jedes Repository dient dabei als zentraler Speicherort für Ihren Code und dessen Versionshistorie.

Für die tägliche Arbeit empfiehlt es sich, den **Zugriff per SSH einzurichten**. Dazu hinterlegen Sie Ihren öffentlichen SSH-Schlüssel in den Benutzereinstellungen. Dadurch können Sie komfortabel und sicher per Git auf Ihre Repositories zugreifen, ohne jedes Mal Benutzername und Passwort eingeben zu müssen.

Tipp Wenn Sie noch unsicher sind, ob Gogs die richtige Wahl ist, lohnt sich ein Blick auf Alternativen. Während [Gitea im Vergleich zu Gogs](https://www.ionos.de/digitalguide/server/knowhow/gogs-vs-gitea/) als aktiver weiterentwickelte Variante gilt, bietet [GitLab im Vergleich zu Gogs](https://www.ionos.de/digitalguide/server/knowhow/gogs-vs-gitlab/) deutlich mehr Funktionen wie beispielsweise CI/CD, DevOps-Tools und umfangreiche Integrationen. Dafür ist GitLab auch wesentlich ressourcenintensiver und komplexer in der Einrichtung. Wenn Sie eine schlanke Lösung suchen, bleibt Gogs eine sehr gute Wahl. Für größere Teams oder automatisierte Workflows können Alternativen sinnvoller sein.

## Schritt 8: Gogs absichern und aktuell halten

Bevor Sie Gogs produktiv nutzen, sollten Sie regelmäßig Updates installieren und eine aktuelle Version mit allen Sicherheitskorrekturen verwenden. Prüfen Sie dafür die offiziellen Sicherheitsmeldungen des Projekts.

Wenn keine öffentliche Registrierung benötigt wird, deaktivieren Sie diese in der Datei `app.ini`:

```ini
[service]
DISABLE_REGISTRATION = true
```

Anschließend starten Sie den Gogs-Container neu, damit die geänderte Konfiguration übernommen wird:

```bash
docker compose restart
```

Danach können neue Benutzerkonten nur noch durch Administratorinnen und Administratoren angelegt werden.


This is a markdown version of: [https://www.ionos.de/digitalguide/server/konfiguration/gogs-docker-installation/](https://www.ionos.de/digitalguide/server/konfiguration/gogs-docker-installation/) for AI/LLM consumption.