Installation von Forgejo mit Docker auf Debian

Einführung

Forgejo ist eine Open-Source-Plattform zur Verwaltung von Git-Repositories. In diesem Tutorial zeige ich dir Schritt für Schritt, wie du Forgejo mit Docker auf einem Cloud Server mit Debian 13 installierst und konfigurierst.

Voraussetzungen

• 1 Server (z.B. bei Hetzner)
  • Debian 13
  • Zugriff auf den root-Benutzer oder einen Benutzer mit sudo-Rechten

Beispiel-Benennungen

• Benutzername: holu
• E-Mail: email@example.com
• Server: <203.0.113.1>

Schritt 1 - Verbindung mit SSH herstellen

Erstelle zunächst einen SSH-Schlüssel auf deinem lokalen Rechner, falls du noch keinen hast:

ssh-keygen -t ed25519 -C "email@example.com"

Dieser wird unter ~/.ssh/id_ed25519.pub gespeichert. Füge den Inhalt dieser Datei in die Hetzner Console unter "Sicherheit" » "SSH-Key hinzufügen" hinzu, damit du dich später mit deinem Server verbinden kannst.

Nun erstellst du einen neuen Server in der Hetzner Console. Wähle dabei Debian 13 als Betriebssystem aus und füge den zuvor erstellten SSH-Key hinzu. Sobald der Server erstellt ist, erhältst du die IP-Adresse deines Servers.

Als nächstes musst du dich mit deinem Server verbinden. Öffne ein Terminal und gib den folgenden Befehl ein, wobei du 203.0.113.1 durch die tatsächliche IP-Adresse deines Servers ersetzt:

ssh root@203.0.113.1 -p 22

Schritt 2 - System aktualisieren

Nachdem du dich erfolgreich mit deinem Server verbunden hast, solltest du zunächst sicherstellen, dass dein System auf dem neuesten Stand ist. Führe dazu die folgenden Befehle aus:

sudo apt update
sudo apt upgrade -y

Diese Befehle aktualisieren die Paketliste und installieren die neuesten Versionen der Pakete auf deinem Server.

Schritt 3 - Docker installieren

Forgejo benötigt Docker, um die Anwendung in Containern auszuführen. Installiere Docker wie in der offiziellen Dokumentation erklärt mit den folgenden Befehlen:

# Add Docker's official GPG key:
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Nach der Installation kannst du überprüfen, ob Docker korrekt installiert wurde, indem du den folgenden Befehl ausführst:

sudo systemctl status docker

Wenn Docker erfolgreich installiert wurde, solltest du eine Ausgabe sehen, die anzeigt, dass der Docker-Dienst aktiv und laufend ist.

Klicke hier für einen Beispiel-Output

holu@example-server:~$ sudo systemctl status docker
● docker.service - Docker Application Container Engine
     Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; preset: enabled)
     Active: active (running) since Mon 2026-06-16 09:53:17 UTC; 16s ago
 Invocation: 0d4362e8d4fe443b82ab32bb44d415ca
TriggeredBy: ● docker.socket
       Docs: https://docs.docker.com
   Main PID: 5592 (dockerd)
      Tasks: 10
     Memory: 28.5M (peak: 30.6M)
        CPU: 312ms
     CGroup: /system.slice/docker.service
             └─5592 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Jun 16 09:53:16 example-server dockerd[5592]: time="2026-06-16T09:53:16.841295340Z" level=info msg="Deleting nftabl>
Jun 16 09:53:16 example-server dockerd[5592]: time="2026-06-16T09:53:16.857299194Z" level=info msg="Deleting nftabl>
Jun 16 09:53:17 example-server dockerd[5592]: time="2026-06-16T09:53:17.258842559Z" level=info msg="Loading contain>
Jun 16 09:53:17 example-server dockerd[5592]: time="2026-06-16T09:53:17.264163432Z" level=info msg="Docker daemon" >
Jun 16 09:53:17 example-server dockerd[5592]: time="2026-06-16T09:53:17.264254553Z" level=info msg="Initializing bu>
Jun 16 09:53:17 example-server dockerd[5592]: time="2026-06-16T09:53:17.273451918Z" level=warning msg="git source c>
Jun 16 09:53:17 example-server dockerd[5592]: time="2026-06-16T09:53:17.278429176Z" level=info msg="Completed build>
Jun 16 09:53:17 example-server dockerd[5592]: time="2026-06-16T09:53:17.288867661Z" level=info msg="Daemon has comp>
Jun 16 09:53:17 example-server dockerd[5592]: time="2026-06-16T09:53:17.288964362Z" level=info msg="API listen on />
Jun 16 09:53:17 example-server systemd[1]: Started docker.service - Docker Application Container Engine.

Wenn Docker nicht läuft, kannst du es mit dem folgenden Befehl starten:

sudo systemctl start docker

Füge deinen Benutzer anschließend der Docker-Gruppe hinzu:

sudo usermod -aG docker holu

Beende kurz die Verbindung zum Server und verbinde dich anschließend wieder damit, um die Gruppen deines Benutzers zu aktualisieren. Du kannst groups ausführen, um zu prüfen ob "docker" ebenfalls gelistet wird.

Schritt 4 - Forgejo installieren

Nachdem Docker installiert ist, kannst du nun Forgejo installieren. Erstelle zunächst ein Verzeichnis für Forgejo und wechsle in dieses Verzeichnis:

mkdir forgejo
cd forgejo

Mit dem folgenden Befehl lädst du das Forgejo-Docker-Image der Version 15 herunter.

docker pull codeberg.org/forgejo/forgejo:15

Nun erstellst du eine docker-compose.yml Datei, um die Forgejo-Instanz zu konfigurieren. Erstelle die Datei mit dem folgenden Inhalt:

networks:
  forgejo:
    external: false

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

Diese Konfiguration erstellt einen Docker-Container für Forgejo, der auf Port 3000 für die Weboberfläche und Port 222 für SSH-Verbindungen zugänglich ist. Die Daten von Forgejo werden im Verzeichnis ./forgejo auf deinem Server gespeichert, damit sie auch nach einem Neustart des Containers erhalten bleiben. USER_UID und USER_GID legen fest, unter welcher Benutzer- und Gruppen-ID Forgejo im Container ausgeführt wird.

Speichere die Datei und starte den Forgejo-Container mit dem folgenden Befehl:

docker compose up -d

Dieser Befehl startet den Forgejo-Container im Hintergrund. Du kannst den Status des Containers mit dem folgenden Befehl überprüfen:

docker ps -a

Wenn der Container erfolgreich gestartet wurde, solltest du ihn in der Liste der laufenden Container sehen.

Schritt 5 - Zugriff auf die Forgejo-Weboberfläche

Nachdem der Forgejo-Container läuft, kannst du nun auf die Weboberfläche zugreifen. Öffne einen Webbrowser und gib die IP-Adresse deines Servers gefolgt von :3000 ein, z.B. http://203.0.113.1:3000. Du solltest die Anmeldeseite von Forgejo sehen.

Die Standardwerte können übernommen werden, da Forgejo automatisch SQLite als Datenbank verwendet. Klicke auf den unteren Punkt "Administratorkonto-Einstellung" und erstelle ein neues Administratorkonto, indem du einen Benutzernamen, eine E-Mail-Adresse und ein Passwort eingibst.

Zum Schluss klicke auf "Forgejo installieren", um die Installation abzuschließen. Du wirst automatisch über den eben erstellen Admin-Account eingeloggt und kannst nun mit der Verwaltung deiner Git-Repositories beginnen.

Um weitere Benutzer hinzuzufügen:

• Klicke auf das Benutzer-Symbol oben rechts
• In dem Aufklappmenü, das sich öffnet, klicke auf "Administration"
• In der linken Menüleiste, gehe zu "Identität u. Zugriff" » "Benutzerkonten"

Ergebnis

Du hast jetzt eine laufende Forgejo-Instanz. Als nächstes kannst du:

License: MIT