Forgejo auf Debian 13 mit rootless Podman

Forgejo als rootless Podman-Container unter einem eigenen Benutzer: ein Quadlet für systemd, Caddy davor, SSH auf Port 2222 und die Probleme, auf die ich gestoßen bin.

Artikel Erstellt Aktualisiert Auch auf Englisch: Forgejo on Debian 13 with Rootless Podman

Geprüft von adrian am

Forgejo läuft auf meinem VPS als rootless Podman-Container unter einem eigenen Benutzer, mit Caddy als Reverse Proxy, einem Quadlet für systemd und SSH auf einem eigenen Port. Vorher hatte der Server die Grundeinrichtung bekommen.

Getestet mit:

  • Debian 13 (Trixie)
  • Podman 5.4.2
  • VPS: 4 CPU-Kerne, 4 GB RAM (Hetzner)
  • Caddy als Reverse Proxy

1. Voraussetzungen installieren

sudo apt install podman uidmap passt slirp4netns
  • uidmap: nötig für rootless Podman (Zuordnung der User-Namespaces).
  • passt: Netzwerk-Backend für rootless Container.
  • slirp4netns: alternatives Netzwerk-Backend.

2. Den Hostnamen in /etc/hosts eintragen

Damit sudo nicht mit unable to resolve host warnt:

sudo nano /etc/hosts

Diese Zeile ergänzen:

127.0.0.1 <hostname>

3. Einen eigenen Benutzer anlegen

Forgejo läuft rootless unter einem eigenen Benutzer git:

sudo useradd -m -s /bin/bash git
sudo loginctl enable-linger git

enable-linger hält den systemd-User-Service am Laufen, auch ohne angemeldete Sitzung.

4. Zum Benutzer git wechseln

sudo su - git

5. Verzeichnisse anlegen

mkdir -p ~/forgejo-data
mkdir -p ~/.config/containers/systemd

6. Das Image ziehen

podman pull codeberg.org/forgejo/forgejo:10-rootless

Das Image kommt direkt von Codeberg, nicht von Docker Hub.

7. Rechte für das Volume setzen

Das rootless Image läuft im Container mit einer anderen UID. Die Rechte setzt du mit podman unshare:

podman unshare chown -R 1000:1000 ~/forgejo-data

8. Die Quadlet-Datei anlegen

Quadlets sind systemd-Unit-Dateien für Podman-Container.

cat > ~/.config/containers/systemd/forgejo.container << 'EOF'
[Unit]
Description=Forgejo
After=network-online.target

[Container]
ContainerName=forgejo
Image=codeberg.org/forgejo/forgejo:10-rootless
Network=host

Volume=%h/forgejo-data:/var/lib/gitea
Volume=/etc/timezone:/etc/timezone:ro
Volume=/etc/localtime:/etc/localtime:ro

Label=io.containers.autoupdate=registry

[Service]
Restart=always

[Install]
WantedBy=default.target
EOF

Wichtig: SSH von außen funktioniert nur mit Network=host. Mit pasta, dem Standard-Netzwerk-Backend für rootless Container, werden SSH-Verbindungen von außen nicht richtig weitergeleitet.

9. Den Container starten

systemctl --user daemon-reload
systemctl --user start forgejo.service
systemctl --user status forgejo.service

10. Ersteinrichtung im Browser

http://VPS-IP:3000 öffnen, dann erscheint der Einrichtungsassistent. Meine Einstellungen:

  • Datenbank: SQLite (reicht für den persönlichen Gebrauch)
  • Domain: git.your-domain.com
  • Root-URL: https://git.your-domain.com/
  • Einen Admin-Account anlegen

11. app.ini anpassen

Nach der Ersteinrichtung passt du die Konfiguration an:

podman unshare nano ~/forgejo-data/custom/conf/app.ini

Im Block [server] ergänzen:

[server]
SSH_DOMAIN = git.your-domain.com
SSH_PORT = 2222
SSH_LISTEN_PORT = 2222
START_SSH_SERVER = true
BUILTIN_SSH_SERVER_USER = git

Im Block [service]:

[service]
DISABLE_REGISTRATION = true

Forgejo neu starten:

systemctl --user restart forgejo.service

12. Caddy als Reverse Proxy einrichten

Als normaler Benutzer eine neue Datei anlegen:

sudo nano /etc/caddy/sites/forgejo.caddy

Inhalt:

git.your-domain.com {
    reverse_proxy localhost:3000
}

Caddy neu laden:

sudo systemctl reload caddy

Caddy holt sich das TLS-Zertifikat von Let's Encrypt selbst.

13. DNS einrichten

Bei Cloudflare (oder einem anderen DNS-Anbieter):

Typ Name Inhalt Proxy
A * IP-Adresse des VPS DNS only
A @ IP-Adresse des VPS DNS only

Wichtig: Der Cloudflare-Proxy (die orange Wolke) muss aus sein, damit Caddy das TLS-Zertifikat selbst holen kann.

14. Firewall (Hetzner)

In der Hetzner Cloud Console unter Firewall, eingehende Regeln:

Protokoll Port Quelle
TCP 80 0.0.0.0/0, ::/0
TCP 443 0.0.0.0/0, ::/0
TCP 2222 0.0.0.0/0, ::/0
TCP 22 0.0.0.0/0, ::/0

15. Den SSH-Schlüssel einrichten

Den lokalen SSH-Schlüssel anzeigen:

cat ~/.ssh/id_ed25519.pub

In Forgejo eintragen unter Profil → Einstellungen → SSH- / GPG-Schlüssel → Schlüssel hinzufügen.

SSH testen:

ssh -p 2222 -T [email protected]
# Hi there, username! You've successfully authenticated...

Lokale ~/.ssh/config:

Host git.your-domain.com
    Port 2222
    User git
    IdentityFile ~/.ssh/id_ed25519

16. Das Repository pushen

cd /path/to/project
git remote set-url origin ssh://[email protected]:2222/username/repo.git
git push -u origin main

Bekannte Probleme und Lösungen

newuidmap: executable file not found

sudo apt install uidmap

pasta: executable file not found

sudo apt install passt

Permission denied beim Volume

podman unshare chown -R 1000:1000 ~/forgejo-data

SSH funktioniert von außen nicht

Rootless Podman mit pasta leitet SSH-Verbindungen von außen nicht weiter. Die Lösung ist Network=host in der Quadlet-Datei.

fail2ban sperrt SSH-Verbindungen

Nach zu vielen Fehlversuchen wird die IP-Adresse gesperrt:

sudo fail2ban-client status sshd
sudo fail2ban-client set sshd unbanip YOUR_IP

Damit fail2ban Port 2222 in Ruhe lässt, legst du /etc/fail2ban/jail.local an:

[sshd]
port = ssh
sudo systemctl restart fail2ban

Zwei Container laufen gleichzeitig

Nach einer Umbenennung können alte Container weiterlaufen und den Port belegen:

sudo podman ps  # show all running containers
sudo podman rm -f <old-container-id>
sudo podman rmi localhost/old-image-name:latest

Podman-Build nutzt einen alten Cache

Der Build-Service braucht --no-cache. In /etc/systemd/system/[email protected]:

ExecStart=/usr/bin/podman-compose up -d --build --no-cache

Nützliche Befehle

# Status prüfen (als Benutzer git)
systemctl --user status forgejo.service

# Logs verfolgen
journalctl --user -u forgejo.service -f

# Container neu starten
systemctl --user restart forgejo.service

# Konfiguration bearbeiten
podman unshare nano ~/forgejo-data/custom/conf/app.ini

# Automatische Updates
podman auto-update

# Laufende Container anzeigen
podman ps

Ressourcen

Forgejo braucht wenig: im Betrieb etwa 130 bis 145 MB RAM, auf einer Maschine mit 4 GB.

Der nächste Schritt war, aus Forgejo selbst zu deployen, mit einem Forgejo Actions Runner auf demselben VPS.

Beruht auf

  • Forgejo on Debian 13 with Rootless Podman (raw/2026/2026-04-03/forgejo-on-debian-13-with-rootless-podman.md) [post]

Mehr dazu

Thema

  • Self-Hosting Dienste auf einem Server betreiben, über den du selbst verfügst, statt die gehostete Fassung eines Anbieters zu nutzen.

Grundlage für

  • Forgejo Actions Runner einrichten Push-to-Deploy mit einem eigenen Forgejo Actions Runner auf demselben VPS: eigener Benutzer, kein Docker, enge sudo-Rechte, Secrets in Forgejo.

Baut auf

  • Einen neuen Debian-VPS einrichten Die ersten Schritte auf einem frischen Debian-VPS: aktuelle Pakete, automatische Sicherheitsupdates, ein Benutzer ohne root und SSH nur mit Schlüssel.

Nutzt

  • Caddy Webserver und Reverse Proxy, der TLS-Zertifikate selbst holt und erneuert, eingerichtet in einem kurzen Caddyfile.
  • Forgejo Git-Plattform zum Selbsthosten: Repositories, Benutzer, SSH-Zugang und CI/CD mit Forgejo Actions und eigenen Runnern. Codeberg läuft damit.
  • Podman Container-Engine ohne Hintergrunddienst, unter Linux standardmäßig rootless, mit denselben Befehlen auf dem Mac und auf dem Server.

In der Graph-Ansicht zeigen