Self-Hosting von paperless-ngx mit PostgreSQL auf einem Ubuntu-Server

Suchst du nach einer selbst gehosteten, papierlosen Dokumentenmanagement-Lösung, die leichtgewichtig und einfach zu warten ist? paperless-ngx in Kombination mit PostgreSQL auf einem Ubuntu Linux Server macht es einfach, kostengünstig und sicher!

Diese Schritt-für-Schritt-Anleitung zeigt dir genau, wie du deine eigene paperless-ngx-Instanz bereitstellen kannst, inklusive automatisiertem HTTPS dank Caddy.

Bevor du loslegst, brauchst du:

• Einen Ubuntu Linux Server mit SSH-Zugriff (empfohlen: Hetzner Cloud, oder jeden Server mit öffentlicher IP und SSH-Login).
• Grundkenntnisse im Umgang mit der SSH-Kommandozeile.

Schritt 1: Aktualisiere deinen Ubuntu Server

Stelle zunächst sicher, dass dein Ubuntu Server sicher und auf dem neuesten Stand ist:

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

Dein System ist jetzt auf dem neuesten Stand und bereit für die Einrichtung.

Schritt 2: Konfiguriere und sichere die UFW-Firewall

Wir sichern deinen Server, indem wir die Ubuntu-Firewall (UFW) konfigurieren. Wir erlauben nur die Ports für HTTP (80), HTTPS (443) und SSH (22):

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

Überprüfe den Firewall-Status:

sudo ufw status verbose

Da Docker UFW-Regeln umgehen kann, solltest du zusätzliche Schutzmaßnahmen in Betracht ziehen, wie sie in dieser StackOverflow-Antwort beschrieben sind.

Schritt 3: Installiere Docker Engine und Docker Compose

Docker verwaltet deine Container. Um Docker und Docker Compose zu installieren, führe diese Befehle aus:

Installiere Abhängigkeiten & 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 das offizielle Docker-Repository 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 und das Docker Compose Plugin:

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

Teste die Docker-Installation:

sudo docker run hello-world

Wenn das erfolgreich war, geht es weiter mit Caddy.

Schritt 4: Installation des Caddy-Webservers für automatisches HTTPS

Caddy automatisiert HTTPS-Zertifikate—perfekt, um deine paperless-Dokumente zu sichern.

Führe Folgendes aus, um Caddy zu installieren:

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

Jetzt konfiguriere den Reverse Proxy in deiner Caddyfile:

sudo nano /etc/caddy/Caddyfile

Ersetze yourdomain.com mit deiner Domain:

yourdomain.com {
    reverse_proxy localhost:8000
}

Falls du noch keine Domain hast, verwende vorübergehend Port 80:

:80 {
    reverse_proxy localhost:8000
}

Starte Caddy neu, um die Änderungen zu übernehmen:

sudo systemctl restart caddy

Schritt 5: Ausführen von paperless-ngx mit PostgreSQL über Docker Compose

Erstelle einen Arbeitsordner und die Docker Compose-Konfiguration für paperless-ngx:

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

Erstelle eine Datei namens docker-compose.yml mit folgendem Inhalt:

services:
  broker:
    image: docker.io/library/redis:7
    restart: unless-stopped
    volumes:
      - redisdata:/data
  db:
    image: docker.io/library/postgres:16
    restart: unless-stopped
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless
  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
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_ADMIN_USER: admin
      PAPERLESS_ADMIN_EMAIL: [email protected]
      PAPERLESS_ADMIN_PASSWORD: adminpassword
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_URL: https://paperless.sliplane.io
      PAPERLESS_SECRET_KEY: your-secure-random-secret

volumes:
  data:
  media:
  redisdata:
  pgdata:

Ich empfehle dir, einen sicheren geheimen Schlüssel für deine PAPERLESS_SECRET_KEY Umgebungsvariable zu wählen. Du kannst einen sicheren Schlüssel mit folgendem Befehl generieren:

openssl rand -base64 32

Dasselbe gilt für deine PAPERLESS_ADMIN_PASSWORD Umgebungsvariable!

Speichere und starte den paperless-ngx Container:

sudo docker compose up -d

Paperless-ngx läuft jetzt auf deinem Server!

Schritt 6: Zugriff auf deine Paperless-Installation

Öffne deinen Browser und gehe zu deiner Webadresse https://yourdomain.com. Du solltest die Login-Seite von paperless-ngx sehen, bereit für deinen im docker-compose.yml definierten Admin-Benutzer.

Nachdem du dich angemeldet hast, kannst du beginnen, deine Dokumente hochzuladen und zu organisieren:

Sicherheitsempfehlungen

Stelle die sichere Aufbewahrung deiner Dokumente und die Integrität deines Servers sicher:

• Richte regelmäßige Backup-Routinen ein.
• Sichere SSH mit starken Passwörtern oder SSH-Schlüsseln ab.
• Aktualisiere regelmäßig die Client-Software und installiere Sicherheitsupdates.
• Ziehe Tools wie fail2ban für zusätzliche Sicherheit in Betracht.

Aktualisierung deiner paperless-ngx Installation

Du kannst deine paperless-ngx Installation jederzeit einfach aktualisieren, indem du Folgendes ausführst:

sudo docker compose pull
sudo docker compose up -d

Docker holt die neuesten Images und aktualisiert automatisch deine Container.

Kostenvergleich mit Managed-Anbietern

Selbsthosting reduziert in der Regel die monatlichen Kosten im Vergleich zu Managed-Alternativen:

Selbsthosting gibt dir die volle Kontrolle, keine versteckten Gebühren und eine budgetfreundliche Infrastruktur.

Brauchst du eine einfachere Lösung? Schau dir unser Managed Hosting auf sliplane.io an für eine unkomplizierte Bereitstellung von paperless-ngx.