👉 Direkt auf YouTube schauen und abonnieren:
Smart Home & More auf YouTube

In diesem Video zeige ich euch, wie ihr unter Proxmox ( LXC oder VM), oder einem separaten PC Paperless NGX einrichtet. Da es recht viele Dinge dabei zu berücksichtigen gibt, habe ich euch dafür 3 Skripte erstellt.

1. Installation
2. Backup
3. Restore

Mit diesen Skripten wird euch fast die gesamte Arbeit abgenommen.

Möchtest du Paperless ngx als Home Assistant Addon installieren, findest du hier eine Anleitung dazu:
https://youtu.be/wCiSkHQtYEE

Wichtiger Hinweis ! Bitte unbedingt beachten!

Ich habe die Freigabenamen umbenannt. Im Video bin ich darauf nochmal kurz eingegangen. Die Freigaben heißen nun:

consume

backup

restore

D.h. , wenn unter Windows die Freigaben gemountet werden, müssen diese Freigabenamen verwendet werden !

Skript install_paperless.sh

Hinweis: Die Skripte wurden auf Postgres 17, Redis 8 und Gotenberg „latest“ aktualisiert ( 12.11.2025)

#!/bin/bash
set -euo pipefail

# ---------------------------------------
# Helpers
# ---------------------------------------
log()  { echo -e "\033[1;32m[INFO]\033[0m $*"; }
warn() { echo -e "\033[1;33m[WARN]\033[0m $*"; }
err()  { echo -e "\033[1;31m[ERR ]\033[0m $*"; }

# ---------------------------------------
# Passwörter & Admin
# ---------------------------------------
prompt_for_password() {
  local password password_confirm
  if [[ "$1" == "PAPERLESS_PASSWORD" ]]; then
    echo -e "\n💡 Hinweis: Dieses Passwort wird für den Linux-Benutzer 'paperless' und den Samba-Server verwendet."
    echo -e "Es wird für den Zugriff auf freigegebene Samba-Ordner benötigt.\n"
  fi
  while true; do
    echo -e "\n🔒 Bitte geben Sie das Passwort für **$1** ein:"
    read -s password
    echo -e "\n🔒 Bitte bestätigen Sie das Passwort:"
    read -s password_confirm
    if [[ "$password" == "$password_confirm" ]]; then
      echo -e "\n✅ Passwort erfolgreich gesetzt für **$1**.\n"
      eval "$2='$password'"
      break
    else
      echo -e "\n❌ Die Passwörter stimmen nicht überein. Bitte erneut eingeben.\n"
    fi
  done
}

prompt_for_admin_user() {
  echo -e "\n👤 Bitte geben Sie den **Admin-Benutzernamen** ein (Standard: paperless):"
  read -r admin_user_input
  ADMIN_USER="${admin_user_input:-paperless}"
  echo -e "\n✅ Admin-Benutzer wurde auf **'$ADMIN_USER'** gesetzt.\n"
}

# Eingaben
prompt_for_password "PAPERLESS_PASSWORD" PAPERLESS_PASSWORD
prompt_for_admin_user
prompt_for_password "ADMIN_PASSWORD" ADMIN_PASSWORD

SAMBA_PASSWORD="$PAPERLESS_PASSWORD"
DB_PASSWORD="paperless"

# ---------------------------------------
# Pakete & Docker-Repo
# ---------------------------------------
update_and_install_dependencies() {
  log "Aktualisiere Paketliste und installiere benötigte Pakete…"
  sudo apt update
  sudo apt install -y apt-transport-https curl jq gnupg openssh-server \
                      samba samba-common-bin ca-certificates lsb-release
}

add_docker_repo() {
  log "Füge Docker GPG-Schlüssel und Repository hinzu…"
  sudo mkdir -p /etc/apt/keyrings
  if [[ ! -f /etc/apt/keyrings/docker.gpg ]]; then
    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
  fi
  . /etc/os-release
  DOCKER_REPO="deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $VERSION_CODENAME stable"
  echo "$DOCKER_REPO" | sudo tee /etc/apt/sources.list.d/docker.list >/dev/null
  sudo apt update
}

# ---------------------------------------
# User/Gruppe
# ---------------------------------------
ensure_paperless_user_and_group() {
  if ! getent group paperless &>/dev/null; then
    log "Erstelle Gruppe 'paperless' mit GID 1002…"
    sudo groupadd -g 1002 paperless
  fi
  if ! id -u paperless &>/dev/null; then
    log "Erstelle Benutzer 'paperless' (UID 1002, GID 1002)…"
    sudo useradd -m -s /bin/bash -u 1002 -g paperless paperless
    echo "paperless:$PAPERLESS_PASSWORD" | sudo chpasswd
  fi
}

# ---------------------------------------
# Docker installieren
# ---------------------------------------
install_docker() {
  if ! command -v docker &>/dev/null; then
    log "Installiere Docker…"
    sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
    sudo systemctl enable --now docker
  fi
  if ! groups paperless | grep -q "\bdocker\b"; then
    log "Füge Benutzer 'paperless' zur Gruppe 'docker' hinzu…"
    sudo usermod -aG docker paperless
  fi
}

# ---------------------------------------
# AppArmor/runc-Bug NUR bei Bedarf mitigieren
# ---------------------------------------
mitigate_if_apparmor_bug() {
  . /etc/os-release
  if [[ "${ID:-}" != "ubuntu" ]]; then
    log "Nicht Ubuntu – überspringe AppArmor/runc-Erkennung."
    return 0
  fi
  if ! command -v docker >/dev/null 2>&1; then
    warn "Docker noch nicht installiert – Erkennung wird später erneut versucht."
    return 0
  fi

  sudo systemctl enable --now docker >/dev/null 2>&1 || true
  docker pull hello-world >/dev/null 2>&1 || true
  docker pull busybox:latest >/dev/null 2>&1 || true

  local TEST_OUT=0 OUTPUT
  if ! OUTPUT="$(docker run --rm --pull=never hello-world 2>&1)"; then
    TEST_OUT=1
  fi
  if [[ $TEST_OUT -ne 0 ]]; then
    if ! OUTPUT="$(docker run --rm --pull=never busybox:latest true 2>&1)"; then
      TEST_OUT=2
    else
      TEST_OUT=0
    fi
  fi

  if [[ $TEST_OUT -ne 0 ]] && echo "$OUTPUT" | grep -q 'net\.ipv4\.ip_unprivileged_port_start.*permission denied'; then
    warn "Erkannt: AppArmor/runc-Problem beim Container-Start."
    if ! dpkg -s containerd.io >/dev/null 2>&1; then
      warn "containerd.io nicht installiert (vermutlich Ubuntu-Containerd). Downgrade wird übersprungen."
      return 0
    fi
    local TARGET_VERSIONS=()
    case "$VERSION_CODENAME" in
      plucky) TARGET_VERSIONS=("1.7.28-1~ubuntu.25.04~plucky" "1.7.27-1") ;;
      noble)  TARGET_VERSIONS=("1.7.28-1~ubuntu.24.04~noble"  "1.7.27-1") ;;
      jammy)  TARGET_VERSIONS=("1.7.28-1~ubuntu.22.04~jammy"  "1.7.27-1") ;;
      *)      TARGET_VERSIONS=("1.7.27-1") ;;
    esac
    local CURR; CURR="$(dpkg-query -W -f='${Version}\n' containerd.io || true)"
    for v in "${TARGET_VERSIONS[@]}"; do
      if [[ "$CURR" == "$v" ]]; then
        log "containerd.io bereits auf gewünschter Version ($v). Setze Hold."
        sudo apt-mark hold containerd.io || true
        return 0
      fi
    done
    local AVAILABLE SELECTED
    AVAILABLE="$(apt-cache madison containerd.io | awk '{print $3}')"
    SELECTED=""
    for v in "${TARGET_VERSIONS[@]}"; do
      if echo "$AVAILABLE" | grep -qx "$v"; then SELECTED="$v"; break; fi
    done
    if [[ -z "$SELECTED" ]]; then
      warn "Keine passende containerd.io-Version im Repo gefunden – Mitigation übersprungen."
      return 0
    fi
    log "Mitigation: Downgrade/Pin containerd.io → $SELECTED"
    sudo apt-mark unhold containerd.io || true
    sudo apt-get install -y --allow-downgrades "containerd.io=${SELECTED}"
    sudo apt-mark hold containerd.io
    sudo systemctl restart containerd docker
  else
    log "Kein AppArmor/runc-Problem erkannt – keine Mitigation nötig."
  fi
}

# ---------------------------------------
# Samba
# ---------------------------------------
configure_samba() {
  sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak || true
  sudo mkdir -p /data/paperless/{backup,restore,consume,data,media,export,postgresql/_data,redis/_data}
  sudo chown -R paperless:paperless /data/paperless/
  sudo chmod -R 770 /data/paperless/

  if ! grep -q "^\[consume\]" /etc/samba/smb.conf; then
    sudo tee -a /etc/samba/smb.conf >/dev/null <<'EOF'

[consume]
   comment = Paperless Daten
   path = /data/paperless/consume
   browsable = yes
   writable = yes
   guest ok = no
   create mask = 0770
   directory mask = 0770
   valid users = paperless
EOF
  fi

  if ! grep -q "^\[backup\]" /etc/samba/smb.conf; then
    sudo tee -a /etc/samba/smb.conf >/dev/null <<'EOF'

[backup]
   comment = Paperless Backup Daten
   path = /data/paperless/backup
   browsable = yes
   writable = yes
   guest ok = no
   create mask = 0770
   directory mask = 0770
   valid users = paperless
EOF
  fi

  if ! grep -q "^\[restore\]" /etc/samba/smb.conf; then
    sudo tee -a /etc/samba/smb.conf >/dev/null <<'EOF'

[restore]
   comment = Paperless Restore Daten
   path = /data/paperless/restore
   browsable = yes
   writable = yes
   guest ok = no
   create mask = 0770
   directory mask = 0770
   valid users = paperless
EOF
  fi

  (echo "$SAMBA_PASSWORD"; echo "$SAMBA_PASSWORD") | sudo smbpasswd -a paperless -s
  sudo systemctl restart smbd
  log "Samba Shares [consume], [backup], [restore] wurden konfiguriert."
}

# ---------------------------------------
# Compose schreiben
# ---------------------------------------
write_compose() {
  log "Erstelle docker-compose.yml…"
  sudo mkdir -p /home/paperless
  sudo chown paperless:paperless /home/paperless

  cat <<EOL | sudo tee /home/paperless/docker-compose.yml >/dev/null
services:
  broker:
    image: redis:7
    container_name: broker
    restart: unless-stopped
    volumes:
      - /data/paperless/redis/_data:/data

  db:
    image: postgres:17
    container_name: db
    restart: unless-stopped
    volumes:
      - /data/paperless/postgresql/_data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: $DB_PASSWORD

  gotenberg:
    image: gotenberg/gotenberg:latest
    container_name: paperless-gotenberg-1
    restart: unless-stopped
    command:
      - "gotenberg"
      - "--chromium-disable-javascript=false"
      - "--chromium-allow-list=.*"

  tika:
    image: apache/tika:latest
    container_name: tika
    restart: unless-stopped

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    container_name: webserver
    restart: unless-stopped
    depends_on:
      - db
      - broker
      - gotenberg
      - tika
    ports:
      - "8001:8000"
    volumes:
      - /data/paperless/consume:/usr/src/paperless/consume
      - /data/paperless/data:/usr/src/paperless/data
      - /data/paperless/media:/usr/src/paperless/media
      - /data/paperless/export:/usr/src/paperless/export
    environment:
      PAPERLESS_ADMIN_USER: $ADMIN_USER
      PAPERLESS_ADMIN_PASSWORD: $ADMIN_PASSWORD
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
      PAPERLESS_TIKA_ENABLED: 1
      PAPERLESS_TIKA_GOTENBERG_ENDPOINT: http://gotenberg:3000
      PAPERLESS_TIKA_ENDPOINT: http://tika:9998
      PAPERLESS_OCR_LANGUAGE: deu
      PAPERLESS_TIME_ZONE: Europe/Berlin
      PAPERLESS_CONSUMER_ENABLE_BARCODES: "true"
      PAPERLESS_CONSUMER_ENABLE_ASN_BARCODE: "true"
      PAPERLESS_CONSUMER_BARCODE_SCANNER: ZXING
      PAPERLESS_EMAIL_TASK_CRON: '*/10 * * * *'
      USERMAP_UID: "1002"
      USERMAP_GID: "1002"
      PAPERLESS_DBSSLMODE: disable
EOL
}

# ---------------------------------------
# DB starten, pg_hba absichern, dann Rest starten
# ---------------------------------------
bringup_with_pg_hba_fix() {
  pushd /home/paperless >/dev/null

  log "Starte zunächst NUR Redis & Postgres…"
  sudo -u paperless docker compose up -d broker db

  # Auf DB warten
  log "Warte, bis Postgres erreichbar ist…"
  for i in {1..60}; do
    if sudo docker exec db pg_isready -q >/dev/null 2>&1; then
      break
    fi
    sleep 2
  done

  # Subnetz der Compose-Network ermitteln
  local NET="paperless_default"
  local SUBNET
  SUBNET="$(docker network inspect "$NET" 2>/dev/null | jq -r '.[0].IPAM.Config[0].Subnet' || true)"
  if [[ -z "${SUBNET:-}" || "${SUBNET}" == "null" ]]; then
    # Fallback: häufig 172.18.0.0/16
    SUBNET="172.18.0.0/16"
    warn "Konnte Subnetz nicht auslesen – nutze Fallback ${SUBNET}"
  else
    log "Ermitteltes Docker-Subnetz: ${SUBNET}"
  fi

  # pg_hba.conf patchen, falls Eintrag fehlt
  log "Sichere pg_hba.conf gegen 'no pg_hba.conf entry … no encryption' ab…"
  sudo docker exec db bash -lc "grep -q '${SUBNET} ' /var/lib/postgresql/data/pg_hba.conf || echo 'host all all ${SUBNET} scram-sha-256' >> /var/lib/postgresql/data/pg_hba.conf"

  # Postgres reload (ohne DB-Login)
  sudo docker exec db bash -lc 'kill -HUP 1'

  # Kurzer Probe-Connect (ohne SSL)
  export PGPASSWORD="$DB_PASSWORD"
  if ! sudo docker exec -e PGPASSWORD="$DB_PASSWORD" db psql -U paperless -d paperless -c 'SELECT 1;' >/dev/null 2>&1; then
    warn "Probe-Query fehlgeschlagen – fahre trotzdem fort (Paperless migriert beim Start)."
  else
    log "Probe-Query erfolgreich."
  fi
  unset PGPASSWORD

  log "Starte nun gotenberg, tika und webserver…"
  sudo -u paperless docker compose up -d gotenberg tika webserver
  popd >/dev/null
}

# ---------------------------------------
# MAIN
# ---------------------------------------
update_and_install_dependencies
add_docker_repo
ensure_paperless_user_and_group
install_docker
mitigate_if_apparmor_bug
configure_samba
write_compose
bringup_with_pg_hba_fix

sleep 2
sudo chown -R paperless:paperless /data/paperless

LOCAL_IP=$(hostname -I | awk '{print $1}')
echo -e "\n🚀 **Paperless ist jetzt bereit!**"
echo -e "🔗 **Zugriff im Browser:** http://$LOCAL_IP:8001\n"
echo -e "🔁 **Bitte einmal neu booten, falls Docker neu installiert wurde.**"

Um die Scripte unter Linux vom Webserver zu laden, kannst du auch folgenden Befehl verwenden.

wget https://smarthomeundmore.de/wp-content/uploads/install_paperless.sh
wget https://smarthomeundmore.de/wp-content/uploads/backup.sh
wget https://smarthomeundmore.de/wp-content/uploads/restore.sh

Danach müssen sie mit:

chmod +x install_paperless.sh
chmod +x backup.sh
chmod +x restore.sh

ausführbar gemacht werden.

Script backup.sh

#!/bin/bash
# Skript: backup.sh
# Dieses Skript führt ein Backup über docker-compose aus und verschiebt anschließend die Backup-Datei(en).

echo "Starte Backup: Ein Backup wird jetzt durchgeführt..."

# Wechsel in das Verzeichnis, in dem sich die docker-compose Datei befindet
cd /home/paperless || { echo "Fehler: Verzeichnis /home/paperless nicht gefunden."; exit 1; }

# Führe den docker-compose Befehl aus
sudo docker compose exec webserver document_exporter ../export -z

# Prüfe, ob der Befehl erfolgreich war
if [ $? -eq 0 ]; then
  echo "Backup erfolgreich abgeschlossen."
  
  # Prüfen, ob das Quellverzeichnis existiert
  if [ -d "/data/paperless/export" ]; then
    # Sicherstellen, dass das Zielverzeichnis existiert (falls nicht, wird es angelegt)
    mkdir -p /data/paperless/backup

    # Prüfen, ob im Quellverzeichnis Dateien vorhanden sind
    if compgen -G "/data/paperless/export/*" > /dev/null; then
      echo "Verschiebe Backup-Datei(en) nach /data/paperless/backup..."
      mv /data/paperless/export/* /data/paperless/backup/
      
      if [ $? -eq 0 ]; then
        echo "Datei(en) erfolgreich verschoben."
      else
        echo "Fehler beim Verschieben der Datei(en)."
      fi
    else
      echo "Keine Datei(en) im Verzeichnis /data/paperless/export gefunden."
    fi
  else
    echo "Quellverzeichnis /data/paperless/export existiert nicht."
  fi
else
  echo "Fehler beim Backup."
fi

Script restore.sh

#!/bin/bash
# Skript: restore.sh
# Dieses Skript stellt ein Backup wieder her.

set -e

echo "Starte Wiederherstellung: Das Backup wird nun wiederhergestellt..."

DOCKER_COMPOSE_FILE="/home/paperless/docker-compose.yml"

# Funktion zum Auskommentieren der Umgebungsvariablen in docker-compose.yml
comment_out_env_vars() {
  echo "Kommentiere PAPERLESS_ADMIN_USER und PAPERLESS_ADMIN_PASSWORD in der docker-compose.yml aus..."

  # Erstelle ein Backup der Datei, falls noch nicht gesichert
  if [ ! -f "${DOCKER_COMPOSE_FILE}.bak" ]; then
    sudo cp "$DOCKER_COMPOSE_FILE" "${DOCKER_COMPOSE_FILE}.bak"
  fi

  # Setze sicherheitshalber Schreibrechte
  sudo chmod u+w "$DOCKER_COMPOSE_FILE"

  # Füge das `#` nur hinzu, falls es noch nicht vorhanden ist
  sudo sed -i 's/^\( *PAPERLESS_ADMIN_USER: \)/#\1/' "$DOCKER_COMPOSE_FILE"
  sudo sed -i 's/^\( *PAPERLESS_ADMIN_PASSWORD: \)/#\1/' "$DOCKER_COMPOSE_FILE"

  echo "Variablen erfolgreich auskommentiert."
}

# Variablen auskommentieren, bevor das Skript weiterläuft
comment_out_env_vars

# Verzeichnisse definieren
BACKUP_DIR="/data/paperless/restore"
EXPORT_DIR="/data/paperless/export"
DIRECTORIES_TO_DELETE=(
  "/data/paperless/consume"
  "/data/paperless/export"
  "/data/paperless/media"
  "/data/paperless/postgresql"
  "/data/paperless/redis"
)

# Prüfe, ob das Backup-Verzeichnis existiert
if [ ! -d "$BACKUP_DIR" ]; then
  echo "Fehler: Backup-Verzeichnis $BACKUP_DIR existiert nicht."
  exit 1
fi

# Schritt 1: Docker Compose herunterfahren
echo "Wechsle in /home/paperless und fahre Docker Compose herunter..."
cd /home/paperless || { echo "Fehler: Verzeichnis /home/paperless nicht gefunden."; exit 1; }
sudo docker compose down

# Schritt 2: Lösche die angegebenen Verzeichnisse
echo "Lösche die folgenden Verzeichnisse:"
for dir in "${DIRECTORIES_TO_DELETE[@]}"; do
  echo "  $dir"
  if [ -d "$dir" ]; then
    sudo rm -rf "$dir"
    echo "    -> $dir gelöscht."
  else
    echo "    -> $dir existiert nicht, überspringe..."
  fi
done

# Schritt 3: Erstelle das Export-Verzeichnis neu
echo "Erstelle das Verzeichnis $EXPORT_DIR..."
sudo mkdir -p "$EXPORT_DIR"
if [ $? -ne 0 ]; then
  echo "Fehler: Konnte $EXPORT_DIR nicht erstellen."
  exit 1
fi

# Schritt 4: Suche nach einer Archivdatei im Backup-Verzeichnis (z. B. *.zip)
ARCHIVE_FILE=$(find "$BACKUP_DIR" -maxdepth 1 -type f -name "*.zip" | head -n 1)
if [ -z "$ARCHIVE_FILE" ]; then
  echo "Fehler: Keine Archivdatei (*.zip) im Backup-Verzeichnis gefunden."
  exit 1
fi
echo "Gefundene Archivdatei: $ARCHIVE_FILE"

# Schritt 5: Kopiere die Archivdatei in das Export-Verzeichnis
echo "Kopiere die Archivdatei nach $EXPORT_DIR..."
sudo cp "$ARCHIVE_FILE" "$EXPORT_DIR"
if [ $? -ne 0 ]; then
  echo "Fehler beim Kopieren der Archivdatei."
  exit 1
fi

# Schritt 6: Wechsel in das Export-Verzeichnis und entpacke die Archivdatei
cd "$EXPORT_DIR" || { echo "Fehler: Konnte nicht in $EXPORT_DIR wechseln."; exit 1; }

# Überprüfe, ob 'unzip' installiert ist und installiere es gegebenenfalls
if ! command -v unzip >/dev/null 2>&1; then
  echo "Das Paket 'unzip' ist nicht installiert. Versuche, es zu installieren..."
  if command -v apt-get >/dev/null 2>&1; then
    sudo apt-get update && sudo apt-get install -y unzip
  elif command -v yum >/dev/null 2>&1; then
    sudo yum install -y unzip
  else
    echo "Kein unterstützter Paketmanager gefunden. Bitte installiere 'unzip' manuell."
    exit 1
  fi
fi

# Entpacken der Archivdatei
ARCHIVE_BASENAME=$(basename "$ARCHIVE_FILE")
echo "Entpacke $ARCHIVE_BASENAME..."
unzip "$ARCHIVE_BASENAME"
if [ $? -ne 0 ]; then
  echo "Fehler beim Entpacken von $ARCHIVE_BASENAME."
  exit 1
fi
echo "Archiv erfolgreich entpackt."

# Optional: Entferne die kopierte Archivdatei, falls sie nicht mehr benötigt wird
# sudo rm "$ARCHIVE_BASENAME"

# Schritt 7: Starte Docker Compose Container neu
echo "Wechsle zurück nach /home/paperless und starte die Container..."
cd /home/paperless || { echo "Fehler: Verzeichnis /home/paperless nicht gefunden."; exit 1; }
sudo -u paperless docker compose up -d
if [ $? -ne 0 ]; then
  echo "Fehler: Docker Compose konnte nicht gestartet werden."
  exit 1
fi

sudo chown -R paperless:paperless /data/paperless/consume /data/paperless/media
sudo chmod -R 775 /data/paperless/consume /data/paperless/media
sudo chown paperless:paperless /home/paperless/docker-compose.yml


sleep 60

cd /home/paperless
# Schritt 8: Führe den Importbefehl aus
echo "Führe Importbefehl aus..."
sudo docker compose exec webserver document_importer ../export
sudo chown -R paperless:paperless /data/paperless 
if [ $? -eq 0 ]; then
  echo "Import erfolgreich abgeschlossen."
else
  echo "Fehler beim Import."
  exit 1
fi
echo " Bitte einmal das System neu booten ! "
echo "---------------------------ENDE--------------------------------"

Upgrade Postgres 16 zu Postgres 17 ( bei vorhandener Installation )

ACHTUNG: Bitte zuvor unbedingt ein Backup der virtuellen Maschine oder des LXC Containers machen !

Zunächst begebt euch im Container oder der VM in das Verzeichnis /home/paperless. Dort findet ihr eine Datei docker-compose.yml.

Als ersten Schritt müssen wir nun die Docker Container beenden.

docker compose down

mit nano docker-compose.yml kontrollieren wir die Eintragungen der Compose Datei. Dabei ist folgender Abschnitt relevant:

Hier sieht man , dass aktuell das Image postgres:16 verwendet wird. Das brauchen wir für den Migrationsprozess in genau dieser Form. Merkt euch zudem auch den POSTGRES_USER , den brauchen wir für den nächsten Schritt.

Mit Strg+X beenden wir den Dateieditor und begeben uns in die Konsole.
Dort geben wir nun folgenden Befehl zum starten der Datenbank ein:

docker compose up -d db

Im nächsten Schritt sichern wir uns nun die aktuelle Datenbank:

docker exec -t db pg_dumpall -U DATENBANKUSER > all.sql

Bei DATENBANKUSER müsst ihr den User aus eurer docker-compose.yml eintragen. Im Beispiel ist es der User paperless.

Nachdem die Sicherung erfolgt ist, beenden wir erneut die Container:

docker compose down

Jetzt können wir erneut mit:

nano docker-compose.yml

unser Compose File editieren.

Jetzt müssen folgende Eintragungen angepasst werden:

Wir ändern also image: postgres:16 in image: postgres:17 und die Zeile volumes: …../_data in …./datav17

Danach starten wir erneut den Datenbank Container mit

docker compose up -d db

Jetzt müssen wir unsere Sicherung der Datenbank und die neu initialisierte Datenbank zurückkopieren.

Das können wir mit

cat all.sql | docker exec -i db psql -U DATENBANKUSER

machen. Dabei ist DATENBANKUSER wieder unser POSTGRES Datenbank Benutzer. In unserem Beispiel paperless.

Wenn der Import Vorgang nun ohne Fehler durchgelaufen ist, können wir mit

docker compose down
docker compose up -d

alle Container wieder starten.

Redis und Gotenberg Update

Um Redis und Gotenberg auf eine neue Version zu updaten sind auch wieder Anpassungen in der docker-compose.yml nötig.

Dazu müssen zunächst die Container gestoppt werden.

docker compose down

Danach editieren wir erneut die docker-compose.yml mit

nano docker-compose.yml

und ändern folgende Zeilen:

Hier tragt die gewünschte Redis Version ein. In meinem Beispiel habe ich von Version 7 auf 8 gewechselt.

Für Gotenberg gehen wir ähnlich vor. Hier habe ich mich entschieden, die „latest“ Variante zu verwenden.

Nach den Änderungen , beendet den Editor mit Strg+X und speichert mit „Yes“ die Datei.

Jetzt müssen wir noch die Container aktualisieren.

docker compose pull

und erneut starten.

docker compose up -d

Jetzt sollten alle Container in der aktuellen eingetragenen Version zur Verfügung stehen.

Update 23.09.2025 – Paperless-ngx: 1:1-Backup & Restore (Docker/Proxmox/LXC)

Überblick

Diese Ergänzung zeigt eine einfache, robuste 1:1-Sicherung und Wiederherstellung einer Paperless-ngx-Instanz – ohne export/import und ohne Manifest-Probleme. Geeignet für Umzüge auf eine neue LXC/VM und für regelmäßige Vollbackups.

Vorteile:

• Vollständiges Abbild von /data/paperless (Dokumente, Postgres, Redis, Konfiguration)
• Versionsunabhängig (kein Versions-Matching beim Import nötig)
• Schnelle Wiederherstellung des exakten Zustands

Wichtig: Nach dem Restore sind die alten Benutzer & Passwörter der Quellinstanz wieder aktiv – auch wenn beim Neuaufsetzen andere Zugangsdaten vergeben wurden.

Voraussetzungen

• Paperless-ngx läuft via Docker Compose.
• Datenpfad: /data/paperless, Compose-Projekt: /home/paperless.
• Auf der Zielinstanz wurde Paperless vorab mit dem bekannten Install-Skript bereitgestellt (Container/Volumes/ENV).

A) Backup auf der Quellinstanz erstellen

1) In das Arbeitsverzeichnis wechseln

cd /root

2) Backup-Skript laden und ausführbar machen

wget https://smarthomeundmore.de/wp-content/uploads/backup_new.sh
chmod +x backup_new.sh

3) Backup starten

./backup_new.sh

Ablauf:

• Paperless-Container werden gestoppt.
• Ein komprimiertes Archiv wird erstellt und in /data/paperless/backup abgelegt.
• Container werden automatisch neu gestartet.

4) Backup übertragen

Das erzeugte Archiv (z. B. paperless-backup-YYYY-MM-DD_HH-MM.tar.gz) auf die Zielinstanz kopieren (z. B. mit scp oder rsync).

B) Restore auf der Zielinstanz durchführen

1) Zielumgebung bereitstellen

Paperless auf der Zielinstanz wie gewohnt mit dem Install-Skript einrichten (Compose/ENV).
Hinweis: Nach dem Restore gelten wieder die alten Credentials aus der gesicherten Instanz.

2) Backup-Datei platzieren

Backup nach /home/paperless kopieren.
Nicht nach /data/paperless/restore legen – das Restore-Skript löscht /data/paperless vollständig.

3) Restore-Skript laden und ausführbar machen

cd /root
wget https://smarthomeundmore.de/wp-content/uploads/restore_new.sh
chmod +x restore_new.sh

4) Restore ausführen (mit absolutem Pfad)

./restore_new.sh /home/paperless/paperless-backup-YYYY-MM-DD_HH-MM.tar.gz

Ablauf:

• Container werden gestoppt.
• /data/paperless wird gelöscht.
• Das Backup wird 1:1 mit korrekten Besitzrechten zurückgespielt (tar --same-owner --numeric-owner).
• Container starten automatisch wieder.

ASN QR Codes generieren

Avery Zweckform QR-Code Generator von Tobias L. Meier: https://tobiasmaier.info/asn-qr-code-label-generator/

Ergänzung & Dank an Murat

An dieser Stelle auch ein herzliches Dankeschön an Murat, der mich nach einem meiner YouTube-Videos auf eine interessante Ergänzung aufmerksam gemacht hat.

Er hatte bei der Nutzung des ASN-QR-Code-Label-Generators von Tobias Maier Schwierigkeiten, die QR-Codes korrekt und passgenau zu drucken. Deshalb hat er kurzerhand ein eigenes Projekt gestartet, mit dem sich mehr Kontrolle über den Druck realisieren lässt:

👉 ASN-QR-Code-Label-Generator von Murat auf GitHub

Vielleicht ist das auch für dich hilfreich, wenn du ähnliche Probleme beim Druck hast. Murat freut sich sicherlich über Feedback und Tests aus der Community.

Home Assistant Rest API Sensoren

Im Video habe ich auch gezeigt, wie man einen Sensor in Home Assistant erstellt, um sich die Anzahl der Dokumente im Posteingang anzeigen zu lassen. Die Informationen dazu habe ich von Flemming´s Blog, wo einige Beispielsensoren zu finden sind. Tolle Arbeit und sehr gut erklärt.

Monitoring Paperless-ngx in Home-Assistant – Flemming’s Blog

Empfohlene Hardware für die Digitalisierung und die QR Codes

Vorschau	Produkt	Preis
	ScanSnap iX1600 Desktop Dokumentenscanner Schwarz – 5 GHz – Duplex, ADF, A4,…		Bei Amazon kaufen
	AVERY Zweckform L4731REV-25 Universal-Etiketten (4.725 plus 945 Klebeetiketten…	12,99 EUR	Bei Amazon kaufen

Ein weiterer Scanner, der häufiger im Kontext mit paperless-ngx genannt wird, ist der Brother ADS-1700W. Da ich diesen allerdings nicht selber getestet habe, kann ich keine direkte Empfehlung dazu aussprechen.

Vorschau	Produkt	Preis
	Brother ADS-1700W Kompakter und intelligenter Dokumentenscanner |…	599,99 EUR	Bei Amazon kaufen

Solltest du in den Scripten noch Fehler finden, kannst du mir gerne deine Korrekturen als Mail zukommen lassen. Meine Kontakdaten findest du im Impressum.