Self-hosting paperless-ngx mit MariaDB auf einem Ubuntu Server

Möchtest Du Deine Dokumente digital organisieren? Paperless-ngx ist ein Open-Source Dokumentenmanagement-System, mit dem Du gescannte Dokumente, Rechnungen und PDFs effizient verwalten kannst. In diesem Guide zeige ich Dir, wie Du paperless-ngx selbst hostest – zusammen mit MariaDB und Docker auf Ubuntu Server, inklusive automatisierter HTTPS-Sicherheit.

Warum dieses Setup wählen?

• MariaDB bietet robuste Datenbank-Performance für große Dokumentensammlungen
• Docker vereinfacht Deployment und Updates
• Ubuntu Server liefert eine stabile, sichere Basis
• Self-hosting gibt Dir volle Kontrolle und spart Kosten

Warum paperless-ngx selbst hosten?

Selbst paperless-ngx zu hosten bringt mehrere Vorteile:

• Volle Kontrolle über Deine Daten
• Besserer Datenschutz und Sicherheit
• Deutliche Kosteneinsparungen
• Anpassbares Setup
• Kein Vendor-Lock-in

Voraussetzungen

Bevor Du loslegst, stelle sicher, dass Du Folgendes hast:

• Einen Ubuntu Server (wir empfehlen Hetzner für kostengünstiges Hosting)
• Grundlegende Kenntnisse mit der Kommandozeile
• SSH-Zugriff auf Deinen Server
• Einen Domainnamen (ist für HTTPS empfohlen, aber optional)

Schritt 1: Deinen Server aktualisieren

Führe die folgenden Befehle aus, um sicherzustellen, dass Dein Server vor der Installation gesichert und auf dem neuesten Stand ist:

sudo apt-get update
sudo apt-get upgrade -y

Schritt 2: UFW-Firewall konfigurieren

Richte die Ubuntu-Firewall (UFW) so ein, dass nur die notwendigen Ports geöffnet sind:

sudo apt install ufw -y
sudo ufw allow ssh
sudo ufw allow http
sudo ufw allow https
sudo ufw enable

Überprüfe die Firewall:

sudo ufw status verbose

Hinweis: Um Docker-Apps noch weiter abzusichern, solltest Du zusätzliche Firewall-Anpassungen für Docker-Container hier durchgehen. Am besten nutzt Du die Firewall Deines Cloud-Providers.

Schritt 3: Docker und Docker Compose installieren

Docker ist notwendig, um paperless-ngx effizient laufen zu lassen.

Installiere zuerst die notwendigen Pakete und den Docker GPG-Schlüssel:

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg -y
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
| sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Füge Docker’s Repository zu Ubuntu hinzu:

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

sudo apt-get update

Installiere Docker Engine und den Compose Plugin:

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

Überprüfe die Docker-Installation, indem Du diesen Befehl ausführst:

sudo docker run hello-world

Wenn alles funktioniert, ist Docker bereit!

Schritt 4: Caddy für automatisches HTTPS installieren und einrichten

Um Paperless mit automatischen HTTPS-Zertifikaten abzusichern, installierst Du den Caddy Server:

Installiere Caddy und seine Abhängigkeiten:

sudo apt install -y debian-keyring debian-archive-keyring \
apt-transport-https curl

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
| sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
| sudo tee /etc/apt/sources.list.d/caddy-stable.list

sudo apt update
sudo apt install caddy -y

Bearbeite anschließend die Konfiguration:

sudo nano /etc/caddy/Caddyfile

Verwende Deine Domain und passe yourdomain.com entsprechend an:

yourdomain.com {
    reverse_proxy localhost:8000
}

Vergiss nicht, auch Deine DNS-Einträge so zu konfigurieren, dass sie auf die IP Deines Servers verweisen!

Ohne Domain kannst Du vorübergehend HTTP verwenden:

:80 {
    reverse_proxy localhost:8000
}

Starte Caddy neu:

sudo systemctl restart caddy

Caddy kümmert sich dann automatisch um die Zertifikate und leitet den Traffic an Paperless weiter.

Schritt 5: paperless-ngx mit MariaDB und Docker Compose einrichten

Erstelle ein neues Verzeichnis und wechsle hinein:

mkdir ~/paperless-ngx
cd ~/paperless-ngx

Erstelle nun die Docker Compose Datei:

nano docker-compose.yml

Füge diese Konfiguration ein (ändere die Passwörter und Domain zu Deinen sicheren Werten!):

services:
  broker:
    image: docker.io/library/redis:7
    restart: unless-stopped
    volumes:
      - redisdata:/data

  db:
    image: docker.io/library/mariadb:11
    restart: unless-stopped
    environment:
      MARIADB_DATABASE: paperless
      MARIADB_USER: paperless
      MARIADB_PASSWORD: paperlesspassword
      MARIADB_ROOT_PASSWORD: rootpassword
    volumes:
      - dbdata:/var/lib/mysql

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - db
      - broker
    ports:
      - "8000:8000"
    volumes:
      - data:/usr/src/paperless/data
      - media:/usr/src/paperless/media
      - ./consume:/usr/src/paperless/consume
      - ./export:/usr/src/paperless/export
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBENGINE: mariadb
      PAPERLESS_DBHOST: db
      PAPERLESS_DBNAME: paperless
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: paperlesspassword
      PAPERLESS_SECRET_KEY: your-secure-random-secret
      PAPERLESS_ADMIN_USER: youradmin
      PAPERLESS_ADMIN_PASSWORD: adminpassword
      PAPERLESS_ADMIN_EMAIL: [email protected]
      PAPERLESS_URL: https://yourdomain.com

volumes:
  data:
  media:
  redisdata:
  dbdata:

Hinweis: Erzeuge sichere Zufallsstrings mit:

openssl rand -base64 32

Starte dann die Container:

sudo docker compose up -d

Dein paperless-ngx System läuft jetzt und Du kannst es über https://yourdomain.com erreichen.

Schritt 6: Zugriff auf paperless-ngx

Öffne in Deinem Browser Deine Adresse (https://yourdomain.com) und logge Dich mit den von Dir definierten Admin-Zugangsdaten ein.

Nach erfolgreichem Login kannst Du ganz einfach Dokumente hochladen, taggen und organisieren.

Empfohlene Sicherheitspraktiken

Schütze Deine Dokumente und Deinen Server, indem Du:

• Regelmäßige Backups Deiner Docker Volumes (insbesondere der Datenbank) erstellst.
• SSH Public/Private Key Authentifizierung aktivierst.
• fail2ban für zusätzlichen SSH-Schutz einsetzt.
• Regelmäßige Updates für Software und Docker Container durchführst.

Aktualisierung von paperless-ngx

Aktualisiere ganz schnell auf den neuesten paperless-ngx Release, indem Du Folgendes ausführst:

sudo docker compose pull
sudo docker compose up -d

Kostenvergleich: Self-Hosted vs. Managed Hosting

Das Selbst-Hosting führt in der Regel zu niedrigeren Betriebskosten und gibt Dir mehr Flexibilität als Managed Provider.

Auch wenn Self-Hosting Kosteneinsparungen bietet, erfordert es mehr technisches Know-how und kontinuierliche Wartung. Wenn Du es lieber unkompliziert haben möchtest, schau Dir Managed Hosting Optionen wie sliplane.io an.

Nächste Schritte

Da Deine paperless-ngx Instanz läuft, solltest Du:

1. Automatisierte Backups einrichten
2. Dokumentenscan-Automation konfigurieren
3. Eigene Tags und Dokumentenkategorien erstellen
4. Die Mobile App installieren für einen einfachen Zugriff

Brauchst Du eine einfachere Lösung? Dann schau Dir unser Managed Hosting bei sliplane.io an – für eine sorgenfreie paperless-ngx Bereitstellung.