Ziel: Stabiler Betrieb mit DokuWiki, File Browser, Cockpit und Gogs (Git) auf einem Raspberry Pi 4 mit 2GB RAM. Wichtig: Alle Befehle sind copy-paste-fertig – einfach ins Terminal einfügen!

Alles hier ist so geschrieben, dass du es 1:1 ins Terminal kopieren kannst. Unter jedem Block steht kurz, was er macht.

getconf LONG_BIT

Ausgabe: 64 → Dein System läuft in 64-Bit (wichtig für Docker-Images).

free -h

Zeigt freien RAM an (sollte ~1.5GB frei sein, bevor wir starten).

df -h

Zeigt freien Speicherplatz (mind. 10GB frei auf / empfohlen).

sudo apt update && sudo apt full-upgrade -y
sudo reboot

Aktualisiert alle Pakete und startet neu (wichtig nach Kernel-Updates).

Optional (nur Raspberry Pi OS):

sudo raspi-config

→ Advanced Options → Expand Filesystem (nutze die volle SSD-Größe).

sudo apt install -y mc git curl wget

• mc (Midnight Commander) – Textbasierter Dateimanager
• git – Wird für Gogs benötigt
• curl/wget – Download-Tools

Root: /srv/docker/corestack Pro Dienst ein Ordner:

• /srv/docker/corestack/wikicore (DokuWiki)
• /srv/docker/corestack/filebrowser (File Browser)
• /srv/docker/corestack/gogs (Git-Repository)
• /srv/docker/corestack/shared (Gemeinsame Daten)

sudo mkdir -p /srv/docker/corestack/{wikicore,filebrowser,gogs,shared}
sudo chown -R $USER:$USER /srv/docker/corestack

Erklärung:

• mkdir -p erstellt alle Ordner inkl. Zwischenverzeichnisse
• chown setzt dich als Besitzer (kein sudo mehr nötig)

cd /srv/docker/corestack

Ab hier arbeitest du im CoreStack-Root.

sudo apt install -y cockpit
sudo systemctl enable --now cockpit.socket

Zugriff:

https://<PI-IP>:9090

Nutze Cockpit für:

• System-Logs
• Dienste verwalten
• Updates
• Speicherplatz überwachen

sudo apt-get install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

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

sudo usermod -aG docker $USER
newgrp docker
docker version
docker compose version

Teste Docker:

docker run --rm hello-world

→ Sollte „Hello from Docker!“ ausgeben.

docker network create dc-net
docker network ls | grep dc-net

Zweck: Alle Container kommunizieren über dc-net (z. B. dc-gogs statt IP-Adressen).

Jeder Dienst hat seinen eigenen Ordner mit docker-compose.yml. RAM-Limits sind strikt gesetzt!

Pfad: /srv/docker/corestack/wikicore/

Datei: /srv/docker/corestack/wikicore/.env

TZ=Europe/Berlin
PUID=1000
PGID=1000
WIKICORE_PORT=8080

Hinweis: PUID/PGID mit id -u und id -g prüfen.

Datei: /srv/docker/corestack/wikicore/docker-compose.yml

services:
  wikicore:
    image: lscr.io/linuxserver/dokuwiki:latest
    container_name: dc-wikicore
    environment:
      - TZ=${TZ}
      - PUID=${PUID}
      - PGID=${PGID}
    volumes:
      - ./config:/config
    ports:
      - "${WIKICORE_PORT}:80"
    networks:
      - dc-net
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 256M  # RAM-Limit

networks:
  dc-net:
    external: true

cd /srv/docker/corestack/wikicore
docker compose up -d
docker compose ps

Zugriff:

http://<PI-IP>:8080

Pfad: /srv/docker/corestack/filebrowser/

Viele Docker‑Images laufen nicht als root, sondern als normaler Benutzer im Container.
Damit der Container Daten speichern kann, müssen die gemounteten Ordner die passenden Rechte haben.

Wir verwenden dafür die Benutzer‑ID 1000, die auf den meisten Linux‑Systemen dem ersten Benutzer entspricht.

Ordner erstellen

sudo mkdir -p /srv/docker/corestack/filebrowser/config
cd /srv/docker/corestack/filebrowser

Rechte setzen

sudo chown -R 1000:1000 config

Damit darf der Container später in diesen Ordner schreiben.

Warum ist das wichtig?
Wenn die Rechte nicht stimmen, erscheint später ein Fehler wie:

Permission denied
cp: can't create '/config/settings.json'

Nach dem Setzen der Rechte kann der Container problemlos starten.

Datei: /srv/docker/corestack/filebrowser/.env

TZ=Europe/Berlin
PUID=1000
PGID=1000
FILEBROWSER_PORT=8081

Datei: /srv/docker/corestack/filebrowser/docker-compose.yml

services:
  filebrowser:
    image: filebrowser/filebrowser:latest
    container_name: dc-filebrowser
    environment:
      - TZ=${TZ}
      - PUID=${PUID}
      - PGID=${PGID}
    volumes:
      - /srv/docker/corestack/shared:/srv  # Gemeinsamer Ordner
      - ./config:/config
    ports:
      - "${FILEBROWSER_PORT}:80"
    networks:
      - dc-net
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 128M  # RAM-Limit

networks:
  dc-net:
    external: true

cd /srv/docker/corestack/filebrowser
docker compose up -d
docker compose ps

Zugriff:

http://<PI-IP>:8081

Pfad: /srv/docker/corestack/gogs/

Datei: /srv/docker/corestack/gogs/.env

TZ=Europe/Berlin
GOGS_HTTP_PORT=3000
GOGS_SSH_PORT=2222

Datei: /srv/docker/corestack/gogs/docker-compose.yml

services:
  gogs:
    image: gogs/gogs:latest
    container_name: dc-gogs
    environment:
      - TZ=${TZ}
    volumes:
      - ./data:/data
    ports:
      - "${GOGS_HTTP_PORT}:3000"  # Web-UI
      - "${GOGS_SSH_PORT}:22"     # Git über SSH
    networks:
      - dc-net
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 256M  # RAM-Limit

networks:
  dc-net:
    external: true

cd /srv/docker/corestack/gogs
docker compose up -d
docker compose ps

1. Öffne ''http://<PI-IP>:3000'' im Browser
2. **Datenbank:** Wähle **SQLite3** (kein PostgreSQL nötig!)
3. **Domain:** ''<PI-IP>'' (oder Hostname, falls DNS eingerichtet)
4. **SSH-Port:** ''2222'' (falls Git über SSH genutzt wird)
5. **Admin-Benutzer erstellen** und speichern

Zugriff:

http://<PI-IP>:3000

Git SSH:

ssh -p 2222 git@<PI-IP>

# 1) DokuWiki (leichtgewichtig)
cd /srv/docker/corestack/wikicore && docker compose up -d
 
# 2) File Browser
cd /srv/docker/corestack/filebrowser && docker compose up -d
 
# 3) Gogs (Git)
cd /srv/docker/corestack/gogs && docker compose up -d

cd /srv/docker/corestack/<stack>
docker compose pull
docker compose up -d
docker image prune -f

Erklärung:

• pull lädt neue Images
• up -d aktualisiert den Container
• image prune -f löscht alte Images

Wichtige Pfade sichern:

• /srv/docker/corestack/wikicore/config/ (DokuWiki)
• /srv/docker/corestack/gogs/data/ (Git-Repos + Config)
• /srv/docker/corestack/filebrowser/config/ (File Browser Einstellungen)
• /srv/docker/corestack/shared/ (Gemeinsame Daten)

Backup-Befehl (Beispiel):

cd /srv/docker/corestack
tar -czvf backup_$(date +%Y-%m-%d).tar.gz wikicore/config gogs/data filebrowser/config shared/

Ersetze <PI-IP> durch die IP deines Raspberry Pi:

http://<PI-IP>:3000

http://<PI-IP>:8080

http://<PI-IP>:8081

https://<PI-IP>:9090

sudo apt install htop
htop

Ziel: < 1.8GB RAM-Verbrauch (sonst Swapping → Performance-Einbruch). Optimierungstipps:

• Gogs: In app.ini MAX_LOAD = 5 setzen (begrenzt gleichzeitige Anfragen)
• DokuWiki: PHP-Cache aktivieren (in php.ini)

Falls du später mehr Dienste (z. B. n8n, code-server) nutzen willst:

• Raspberry Pi 4 mit 4GB oder 8GB RAM nachrüsten (~50–100€)
• Dann die ursprüngliche CoreStack-Doku verwenden

Fertig! 🎉 Dein Raspberry Pi 4 (2GB RAM) läuft jetzt stabil mit:

• ✅ DokuWiki (Dokumentation)
• ✅ File Browser (Dateimanagement)
• ✅ Gogs (Git-Repository)
• ✅ Cockpit (Systemverwaltung)

Viel Erfolg mit deinem neuen Home-Server! 🚀