Effiziente Dokumentenverwaltung: Paperless mit Docker Container

Effiziente Dokumentenverwaltung: Paperless mit Docker Container

In diesem Artikel zeige ich dir Schritt für Schritt, wie du Paperless mit Docker Container auf deinem Raspberry Pi installierst und konfigurierst, um deine Dokumentenverwaltung zu digitalisieren. Angesichts der zunehmenden Bedenken hinsichtlich Datenschutz und Sicherheit war es mir wichtig, eine Lösung zu finden, bei der alle Daten auf meinem eigenen System bleiben und nicht mit Cloud-Diensten geteilt werden.

Paperless-NGX als selbstgehostete Lösung auf einem Raspberry Pi zu betreiben bietet nicht nur eine kostengünstige und leistungsstarke Möglichkeit zur Verwaltung von Dokumenten, sondern stellt auch sicher, dass deine sensiblen Informationen in deinem eigenen Netzwerk bleiben und du so die Kontrolle über deine Daten behältst.

Bereit, deine Büroarbeit auf eine neue digitale Ebene zu heben und dabei höchsten Wert auf Datenschutz zu legen? Lass uns jetzt beginnen und Paperless-NGX auf deinem Raspberry Pi installieren!

DarkWolfCave.de

Was ist Paperless-NGX?

In einer zunehmend digitalisierten Welt gewinnt das Konzept der papierlosen Büroumgebung immer mehr an Bedeutung. Eine der führenden Lösungen auf diesem Gebiet ist Paperless-NGX, ein innovatives System zur Verwaltung und Archivierung von Dokumenten. Doch was genau verbirgt sich hinter diesem Begriff und warum sollte man sich dafür interessieren?

Paperless-ngx ist eine fortschrittliche Softwarelösung, die speziell für die Verwaltung und den Austausch von Dokumenten entwickelt wurde.
Das »ngx« im Namen steht für »next generation experience«, und ist eine Weiterentwicklung der ursprünglichen Version.
Die Software ermöglicht es dir, den gesamten Lebenszyklus deiner Dokumente digital zu verwalten, von der Erstellung über die Bearbeitung bis hin zur Archivierung und Wiederherstellung.

Die Vorteile von paperless-ngx

1. Datenschutz: Da alle Dokumente nur auf deinem eigenen System gespeichert werden, hast auch nur DU die volle Kontrolle über sie! Kein unfreiwilliges Sharen mit Cloud-Systemen und keine Bauchschmerzen mehr!
2. Effizienzsteigerung: Durch die Digitalisierung von Dokumenten wird der Arbeitsablauf beschleunigt und die Effizienz gesteigert. Dokumente können schnell gefunden, bearbeitet und geteilt werden, ohne dass physische Kopien erstellt werden müssen.
3. Kostenersparnis: Der Einsatz von paperless-ngx reduziert die Kosten für Papier, Druckertinte und Lagerung von Dokumenten erheblich. Auch der Platzbedarf für Aktenregale entfällt (zumindest teilweise), da alles digital gespeichert wird.
4. Sicherheit: Digitale Dokumente können durch Verschlüsselung und Zugriffsbeschränkungen sicher geschützt werden. Dies minimiert das Risiko von Datenverlusten oder unbefugtem Zugriff.
5. Umweltfreundlichkeit: Papierlose Büros tragen aktiv zum Umweltschutz bei, indem sie den Verbrauch von Papier und anderen Ressourcen reduzieren und somit die CO2-Belastung verringern. Und auch wenn du nicht viele Dokumente hast, jeder Teil zählt – also mach mit 🙂

Wie funktioniert Paperless-NGX auf einem Raspberry Pi?

Die Software von Paperless-NGX bietet eine benutzerfreundliche Oberfläche, die es dir ermöglicht, Dokumente einfach hochzuladen, zu kategorisieren und zu durchsuchen. Eine intelligente Indexierung und Suchfunktion erleichtert das Auffinden von Dokumenten enorm. Zudem unterstützt das System die Integration mit anderen Softwarelösungen und bietet APIs für eine nahtlose Einbindung in bestehende Unternehmenssysteme.
Es gibt auch Apps für Android und iPhone, mit denen du direkt »los scannen« kannst.

Voraussetzungen

Da bei mir ja so ziemlich alles auf einem Raspberry Pi laufen soll, war die erste Frage, ob auch Paperless-NGX hier mitmacht oder meinen Raspberry in die Knie zwingen würde.
Die gute Nachricht vorweg: es läuft und keiner qualmte danach.
Die etwas schlechtere Nachricht: installiere es ab einem Raspberry Pi 4 mit 64Bit!
Ältere Versionen laufen zwar auch auf einem Raspberry Pi 3, aber wenn du neu installieren willst, starte direkt mit 64Bit.

Was benötigen wir also?

• Raspberry Pi 4 oder größer – am besten mit einem 64Bit OS – denn die aktuellsten paperless-NGX Versionen laufen nur noch unter 64Bit
• Docker Umgebung
• Docker Compose
• Portainer zum Verwalten von Containern (optional)

Docker und Docker Compose installieren

Diesen Schritt kannst du überspringen, wenn bei dir bereits Docker läuft. Weiterhin fliege ich nur schnell über die notwendigen Schritte. Falls du mehr Details dazu lesen möchtest, empfehle ich dir meinen Artikel: Raspberry PI – Docker ohne Probleme installieren.

Es gibt verschiedene Wege, der einfachste ist aber wohl der über das entsprechende Script. Daher besorgen wir uns dieses und starten danach die Installation. Dieses installiert die für unser System passenden Komponenten von Docker und dem Docker-Compose-Plugin. :

(Bei dem usermod Befehl trägst du anstelle von <DEINUSER> bitte den Namen des Users ein, unter dem Docker läuft/installiert wird.
Zum Beispiel für den default user »pi«: sudo usermod -aG docker pi )

curl -fsSL https://get.Docker.com -o get-Docker.sh && chmod +x get-Docker.sh

sudo ./get-Docker.sh

sudo usermod -aG docker <DEINUSER>

newgrp docker

Zum Testen, ob Docker jetzt auch wirklich läuft, kannst du ein einfaches Hello-World starten. Der Parameter ” –rm ” sorgt dafür, dass dieser Container nur einmal temporär gestartet und direkt wieder gelöscht wird. Das Image bleibt allerdings erhalten.

docker run --rm hello-world

Auf dieser Hardware laufen meine Umgebungen

Bei mir gibt es mehrere sogenannte »Umgebungen«, die ich benutze.
Zum einen meine »Live« oder auch »Produktion« Umgebung, auf der alles läuft, was ich in meinem Netzwerk so benötige.
Dann gibt es noch Umgebungen für unterschiedliche Szenarien: ein Labor (LAB), eine Entwickler (DEV) und eine zum finalen Testen (UAT).

Hardwaretechnisch sind aber alle fast gleich ausgestattet, da ich mit diesen Kombinationen bisher nie Probleme hatte.
Lediglich setzt meine neue Live-Umgebung erstmalig auf eine NVMe-SSD.

Werbung

Aktuelle Produktions-Umgebung (live)

Vorschau	Produkt	Preis
	Raspberry Pi 5 8 GB	92,55 EUR 89,21 EUR	Bei Amazon kaufen
	offizieller Raspberry Pi 5 USB-C Netzteil 27W, USB-C…	18,90 EUR 11,30 EUR	Bei Amazon kaufen
	GeeekPi Raspberry Pi 5 Aluminiumgehäuse mit Official…	25,99 EUR 22,99 EUR	Bei Amazon kaufen
	GeeekPi N04 M.2 M-Key NVMe SSD Shield für Raspberry Pi…	12,95 EUR	Bei Amazon kaufen
	Crucial P3 Plus SSD 1TB M.2 PCIe Gen4 NVMe Interne SSD,…	69,99 EUR	Bei Amazon kaufen
	SanDisk Extreme 32 GB microSDHC Memory Card + SD…	14,99 EUR 10,49 EUR	Bei Amazon kaufen
	Transcend 32GB kleiner und kompakter USB-Stick 3.1 Gen…	14,99 EUR 12,09 EUR	Bei Amazon kaufen
	UGREEN USB C 312MB/S Kartenleser SD 4.0 Kartenleser USB…	25,99 EUR	Bei Amazon kaufen

Letzte Aktualisierung am 2024-12-04 (Preise können abweichen) / Infos zu Affiliate Links / Bilder von der Amazon Product Advertising API

Affiliate – Links

DarkWolfCave.de ist Teilnehmer des Amazon-Partnerprogramm, das zur Bereitstellung eines Mediums für Webseiten konzipiert wurde, mittels dessen durch die Platzierung von Partner-Links zu Amazon.de Entgelte verdient werden können.

Weitere Infos zu Affiliate-Links

Werbung

Test-Umgebungen (UAT/DEV/LAB)

Vorschau	Produkt	Preis
	Raspberry Pi 5 4GB	66,86 EUR	Bei Amazon kaufen
	Raspberry Pi 4 Modell B ARM (8 GB), Linux	86,65 EUR	Bei Amazon kaufen
	Raspberry Pi 4 Modell B (4 GB)	64,40 EUR	Bei Amazon kaufen
	Raspberry 4596 Pi – offizielles Netzteil für Raspberry…	11,56 EUR	Bei Amazon kaufen
	Miuzei Gehäuse für Raspberry Pi 4 mit Lüfter, 5.1V…	15,99 EUR	Bei Amazon kaufen
	SD kartenleser 5 in 1 USB 3.0, Aluminiumlegierung mit…		Bei Amazon kaufen
	Samsung MZ-76E1T0B/EU 860 EVO 1 TB SATA 2,5″ Interne…	164,90 EUR 136,00 EUR	Bei Amazon kaufen
	UGREEN Festplattengehäuse 2,5 Zoll USB C 3.2 Gen 2 auf…	19,99 EUR 13,99 EUR	Bei Amazon kaufen
	JSAUX USB 3.0 auf SATA Adapter, USB 3.0 zu 2,5 Zoll…	11,99 EUR	Bei Amazon kaufen

Letzte Aktualisierung am 2024-12-04 (Preise können abweichen) / Infos zu Affiliate Links / Bilder von der Amazon Product Advertising API

Affiliate – Links

DarkWolfCave.de ist Teilnehmer des Amazon-Partnerprogramm, das zur Bereitstellung eines Mediums für Webseiten konzipiert wurde, mittels dessen durch die Platzierung von Partner-Links zu Amazon.de Entgelte verdient werden können.

Weitere Infos zu Affiliate-Links

Paperless-NGX mit Portainer installieren und verwalten

In diesem Abschnitt erkläre ich dir, wie du Paperless-NGX unter Portainer (Stacks) laufen und verwalten lassen kannst.
Dazu verwende ich eine fertige yml-Datei, die von den Entwicklern auf Ihrer GitHub-Seite bereitgestellt wird.

Solltest du kein Portainer verwenden, dann schaue bitte in dem Abschnitt für die Docker-Compose-Installation nach.

Lade dir die yml-Datei herunter: docker-compose.portainer.yml oder kopiere dir den Inhalt direkt von hier in deinen Zwischenspeicher.
Denn wir müssen den Inhalt lediglich in Portainer hinzufügen. Ich habe mich so weit an die Vorgaben gehalten und nur zwei Einträge verändert.
Geändert habe ich die Zeitzone, sowie die am häufigst verwendete Sprache in meinen Dokumenten:

• PAPERLESS_TIME_ZONE: Europe/Berlin
• PAPERLESS_OCR_LANGUAGE: deu

# Docker Compose file for running paperless from the Docker Hub.
# This file contains everything paperless needs to run.
# Paperless supports amd64, arm and arm64 hardware.
#
# All compose files of paperless configure paperless in the following way:
#
# - Paperless is (re)started on system boot, if it was running before shutdown.
# - Docker volumes for storing data are managed by Docker.
# - Folders for importing and exporting files are created in the same directory
#   as this file and mounted to the correct folders inside the container.
# - Paperless listens on port 8010.
#
# In addition to that, this Docker Compose file adds the following optional
# configurations:
#
# - Instead of SQLite (default), PostgreSQL is used as the database server.
#
# To install and update paperless with this file, do the following:
#
# - Open portainer Stacks list and click 'Add stack'
# - Paste the contents of this file and assign a name, e.g. 'paperless'
# - Click 'Deploy the stack' and wait for it to be deployed
# - Open the list of containers, select paperless_webserver_1
# - Click 'Console' and then 'Connect' to open the command line inside the container
# - Run 'python3 manage.py createsuperuser' to create a user
# - Exit the console
#
# For more extensive installation and update instructions, refer to the
# documentation.

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:
      - "8010:8000"
    volumes:
      - data:/usr/src/paperless/data
      - media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
# The UID and GID of the user used to run paperless in the container. Set this
# to your UID and GID on the host so that you have write access to the
# consumption directory.
      USERMAP_UID: 1000
      USERMAP_GID: 1000
# Additional languages to install for text recognition, separated by a
# whitespace. Note that this is
# different from PAPERLESS_OCR_LANGUAGE (default=eng), which defines the
# language used for OCR.
# The container installs English, German, Italian, Spanish and French by
# default.
# See https://packages.debian.org/search?keywords=tesseract-ocr-&searchon=names&suite=buster
# for available languages.
      #PAPERLESS_OCR_LANGUAGES: tur ces
# Adjust this key if you plan to make paperless available publicly. It should
# be a very long sequence of random characters. You don't need to remember it.
      #PAPERLESS_SECRET_KEY: change-me
# Use this variable to set a timezone for the Paperless Docker containers. If not specified, defaults to UTC.
      #PAPERLESS_TIME_ZONE: America/Los_Angeles
      PAPERLESS_TIME_ZONE: Europe/Berlin
# The default language to use for OCR. Set this to the language most of your
# documents are written in.
      #PAPERLESS_OCR_LANGUAGE: eng
      PAPERLESS_OCR_LANGUAGE: deu


volumes:
  data:
  media:
  pgdata:
  redisdata:

Öffne deine Portainer-GUI, wähle im Menü “Stacks” und füge über “Add stacks” einen Neuen hinzu:

Hier kannst du einen Namen (paperless) vergeben und bei “Web editor” in dem Textfeld den Code von oben einfügen.
Final dann “Deploy the stack” ausführen:

Das Deployen wird eine gewisse Zeit in Anspruch nehmen. Sobald es fertig ist, solltest du die drei neuen Container in deiner Liste sehen:

Im nächsten Schritt verbinden wir uns mit dem Container “paperless_webserver_1“.
Dazu klickst du in dem Bereich “Quick Actions” auf das vorletzte Symbol >_ (Exec Console) und dann auf Connect.

In der Konsole selbst geben wir dann python3 manage.py createsuperuser ein und erstellen uns einen entsprechenden User.
Final die Konsole wieder mit “Disconnect” (oder exit) beenden:

Das war es auch schon mit der Installation.
Du kannst die Web-Gui jetzt über deine IP-Adresse des Raspberry, gefolgt von der Portnummer (zum Beispiel: 192.168.1.55:8010) erreichen und dich mit dem gerade angelegten User einloggen.

Paperless-NGX mit Docker Compose installieren

In diesem Abschnitt erkläre ich dir, wie du Paperless-NGX mit Docker Compose und yml-Dateien installieren kannst.
Dazu verwende ich eine fertige yml-Datei für Docker Compose, die von den Entwicklern auf der GitHub-Seite bereitgestellt werden.
Du nutzt bereits Portainer für deine Container? Dann sieh dir den entsprechenden Abschnitt dazu an.

In diesem Git-Hub Bereich werden uns einige fertige yml-Dateien angeboten, von denen wir auch gleich eine nutzen werden. Welche ist im Prinzip egal und deinen Bedürfnissen und Vorstellungen überlassen. Es gibt mit Sicherheit Unterschiede bei den Datenbanken, wenn du Millionen von Daten speichern willst. Aber für den Hausgebrauch ist es meiner Meinung nach vollkommen egal, welche du nimmst. Ich nutze bei mir PostgreSQL.

• docker-composer.env -> benötigen wir auf jeden Fall immer!
• docker-compose.portainer.yml -> wird für die Installation über Portainer genutzt. In diesem Abschnitt erkläre ich mehr dazu. (benötigst du für Docker Compose nicht)
• docker-compose.mariadb.yml -> mit einer MariaDatenbank
• docker-compose.postgres.yml -> mit einer PostgreSQL Datenbank
• docker-compose.sqlite.yml -> mit einer sqlite Datenbank
• *-tika.yml -> bei allen mit tika, wird eine Unterstützung von Office-Dokumente (Word, Excel, Power Point und ihre LibreOffice-Gegenstücke) in Form von Apache Tika und Gotenberg hinzugefügt.

In meinem Fall entscheide ich mich für docker-compose.postgres.yml ohne Office-Kram, da ich ohnehin nur vorhabe, PDF-Dateien entsprechend zu verarbeiten.

Starten wir damit, einen Platz auf unserem Raspberry zu erstellen, indem wir die yml-Dateien speichern werden.
Hier gehe ich davon aus, dass du bereits weißt, wie du ein Terminal auf deinem Raspberry Pi öffnen kannst und dich durch deine Verzeichnisse bewegst. Solltest du hier Hilfe benötigen, findest du in meinen Artikeln entsprechende Unterstützungen oder du schreibst mich kurz in Discord an.

# Ich speichere bei mir im Home Verzeichniss unter /docker alle weiteren yml-Dateien.
# Daher erstelle ich dort jetzt einen weiteren Unterordner und wechsel in diesen

cd ~/docker/
mkdir paperless
cd paperless

Wir benötigen auch den Inhalt der .env aus dem Github. Daher erstellen wir uns eine neue .env und fügen diesen hinzu. Speichern nicht vergessen:

sudo nano .env

COMPOSE_PROJECT_NAME=paperless

Außerdem müssen wir die docker-compose.env erstellen und anpassen.
Mit sudo nano docker-compose.env erzeugen wir uns diese und fügen die folgenden Einstellungen hinzu.
Ein paar Erklärungen noch:

• USERMAP_UID=1000 -> kannst du für den entsprechenden User mit id -u herausfinden (Default immer 1000)
• USERMAP_GID=1000 -> kannst du für den entsprechenden User mit id -g herausfinden (Default immer 1000)
• PAPERLESS_TIME_ZONE=Europe/Berlin -> Die Zeitzone
• PAPERLESS_OCR_LANGUAGE=deu -> Wenn die bevorzugte Sprache bei den Dokumenten deutsch sein soll
• PAPERLESS_OCR_LANGUAGES -> beachte das (s) am Ende! Wird eigentlich NICHT benötigt, da paperless per Default in den Sprachen Englisch, Deutsch, Italienisch, Spanisch und Französisch ausgeliefert wird.
• Ich verzichte auch bewusst auf die Domain und Key, da es nur intern und nicht ins öffentliche Internet soll. Da wären noch weitere Security Einstellungen und Überlegungen (ReverseProxy usw.) notwendig.

# The UID and GID of the user used to run paperless in the container. Set this
# to your UID and GID on the host so that you have write access to the
# consumption directory.
USERMAP_UID=1000
USERMAP_GID=1000

###############################################################################
# Paperless-specific settings                                                 #
###############################################################################

# All settings defined in the paperless.conf.example can be used here. The
# Docker setup does not use the configuration file.
# A few commonly adjusted settings are provided below.

# Use this variable to set a timezone for the Paperless Docker containers. If not specified, defaults to UTC.
PAPERLESS_TIME_ZONE=Europe/Berlin

# The default language to use for OCR. Set this to the language most of your
# documents are written in.
PAPERLESS_OCR_LANGUAGE=deu

Zu guter Letzt benötigen wir noch den Inhalt der eigentlichen yml-Datei.
Wir erstellen mit sudo nano docker-compose.yml (bitte genauso benennen) eine weitere Datei in unserem Ordner und fügen folgende Konfigurationen hinzu.
Ich habe hier lediglich den Port 8000 auf 8010 geändert, da bei mir auf 8000 bereits Portainer läuft.

»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:
      - "8010: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_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db

volumes:
  data:
  media:
  pgdata:
  redisdata:

Speichern nicht vergessen und fix mit ls -a prüfen, ob du jetzt auch wirklich alle drei Dateien in deinem Ordner sehen kannst:

• docker-compose.env docker-compose.yml .env

Alles da?! Dann direkt weiter:

• docker compose pull
  • Der Befehl docker-compose pull wird verwendet, um Docker-Images von einem Container-Registry in deinen lokalen Docker-Host zu ziehen (herunterzuladen), die in einer docker-compose.yml-Datei definiert sind. Dies ist besonders nützlich, um sicherzustellen, dass du die neuesten Versionen der benötigten Images hast, bevor du deine Container erstellst oder neu startest.
• docker compose run --rm webserver createsuperuser
  • Der Befehl docker compose run --rm webserver createsuperuser wird verwendet, um einen temporären Container für den webserver-Service zu starten und darin den Befehl createsuperuser auszuführen. Dieser Befehl wird oft in Django-Anwendungen verwendet, um einen Superuser (einen Benutzer mit Administratorrechten) zu erstellen. Und auch hier werden wir im Terminal (in dem temporären Container) dazu aufgefordert, einen User mit E-Mail und Passwort einzurichten.
• docker compose up -d
  • Der Befehl docker compose up -d wird verwendet, um Container gemäß den Anweisungen in einer docker-compose.yml-Datei zu starten und sie im Hintergrund (detached mode) auszuführen. Dies ermöglicht, dass die Container weiterhin laufen, auch wenn das Terminal geschlossen wird, und bietet eine einfache Möglichkeit, Multi-Container-Docker-Anwendungen zu starten und zu verwalten.

Im Idealfall sollte die Ausgabe 3 Container zeigen, die den Status Running oder Started haben.
Prüfen kannst du auch noch einmal direkt mit dem Docker Befehl:

»docker ps --format "{{.ID}} : {{.Names}} : {{.Image}} : {{.State}}"

Hier siehst du alle deine laufenden Container, und hoffentlich auch diese hier (natürlich mit einer anderen ID):

3d52b05524f8 : paperless-webserver-1 : ghcr.io/paperless-ngx/paperless-ngx:latest : running
ad77a4d22e54 : paperless-db-1 : postgres:16 : running
f62d3666210d : paperless-broker-1 : redis:7 : running

Die Installation ist damit abgeschlossen. Um die Web-GUI zu nutzen, öffne einfach den Webbrowser und gib die IP-Adresse deines Raspberry Pi gefolgt von der Portnummer ein (zum Beispiel: 192.168.1.55:8010). Dort kannst du dich dann mit dem zuvor erstellten Benutzer anmelden.