Paperless-ngx Paperless-ngx: Migration Postgresql zu MariaDB

[Adama]

Da ja seit Version 1.9.0 von Paperless-ngx auch MariaDB unterstützt wird, hab ich mich gefragt, wozu also ein extra Container für die Datenbank wenn ich schon MariaDB auf der Syno habe.

Wie kann ich also meine bestehende Installation nach MariaDB migrieren.

Erst habe ich nach Möglichkeiten gesucht, Postgresql direkt nach MariaDB zu migrieren, was wohl geht, aber nicht so einfach läuft, wie ich mir vorgestellt habe. Dann ist mir eingefallen, dass Paperless-ngx eine Export-Funktion hat. Die Export-Funktion macht es tatsächlich einfach, von Postgresql zu MariaDB zu migrieren.

Hier meine Migration, die über eine Parallel-Installation geht, um einerseits sicherzustellen, dass die Ur-Installation erst mal unbeteiligt bleibt und andererseits die Daten nach der Migration zu testen.

Unter 6. habe ich zwei Compose-Files ergänzt, die für eine reine MariaDB-Installation genutzt werden können. Einmal mit der MariaDB der Syno, einmal mit einem MariaDB-Container in einem eigenen Netz.

1. Datenbank in MariaDB anlegen:

(Per SSH an der Syno anmelden)

mysql -u root -p

create database paperless;
create user 'paperless'@'localhost' identified by '<das geheime passwort>';
grant all privileges on paperless.* to 'paperless'@'%' identified by '<das geheime passwort>';

2. Parallel-Installation erstellen

Das habe ich mit folgenden compose-Dateien gemacht:

.env

COMPOSE_PROJECT_NAME=paperless_test

docker-compose.env

COMPOSE_PROJECT_NAME=paperless_test
USERMAP_UID=<uid>
USERMAP_GID=<gid>
PAPERLESS_OCR_LANGUAGE=deu
PAPERLESS_SECRET_KEY=<secret key>
PAPERLESS_TIME_ZONE=Europe/Berlin
PAPERLESS_OCR_IMAGE_DPI=300
PAPERLESS_TASK_WORKERS=2
PAPERLESS_THREADS_PER_WORKER=2
PAPERLESS_FILENAME_FORMAT={created_year}/{created_month}/{correspondent}/{created}_{document_type}
PAPERLESS_URL=<url:port>
PAPERLESS_ENABLE_UPDATE_CHECK=true

docker-compose.yml

version: "3.4"
services:
  broker:
    container_name: Paperless_Broker_Test
    image: docker.io/library/redis:7
    restart: unless-stopped
    volumes:
      - /volume1/docker/broker_test:/data

  webserver:
    container_name: Paperless_Test
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - broker
    ports:
      - 8101:8000
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - /volume1/docker/paperless_data_test:/usr/src/paperless/data
      - /volume1/DockerData/Paperless_Test/media:/usr/src/paperless/media
      - /volume1/DockerData/Paperless_Test/export:/usr/src/paperless/export
      - /volume1/Temp/consume_test:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBENGINE: mariadb
      PAPERLESS_DBHOST: <ip der syno>
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: <das geheime passwort>
      PAPERLESS_DBPORT: 3307

In der Konsole mit "docker-compose up -d" starten. Dann mit "docker-compose run --rm webserver createsuperuser" einen Admin-Benutzer anlegen.

Nachdem die Container gestartet sind, einmal testen, ob man sich an Paperless-ngx anmelden kann. Geht das problemlos, kann die Datenmigration starten.

3. Datenexport:

Über SSH am produktiven Paperless-Container anmelden und Daten etc. exportieren:

docker exec -u root -it Paperless /bin/bash
document_exporter ../export -c -f
exit

4.Datenimport:

Den Inhalt des produktiven export-Ordners mit der File Station in den export-Ordner der Testinstallation verschieben. Drauf achten, dass wirklich alle Dateien verschoben wurden.
Über SSH am Paperless_Test-Container anmelden und Daten etc. importieren.

docker exec -u root -it Paperless_Test /bin/bash
document_importer ../export
exit

Jetzt könnt ihr euch wieder an der Testinstallation anmelden. Ihr werdet feststellen, dass das jetzt mit den Anmeldedaten der produktiven Umgebung geht und ihr solltet alles in der Testinstallation finden, was ihr auch in der produktiven Installation habt.

5. Umstellen des produktiven Containers

Ich hab mich jetzt dazu entschieden, den produktiven Container einfach von Postgresql auf die jetzt bestehende MariaDB umzuschwenken.

Das könnt ihr erreichen, wenn ihr eure compose-Datei für den produktiven Container entsprechend anpasst. Im folgenden Beispiel seht ihr meine compose-Datei. Die Zeilen mit <ENTF> am Anfang müssen auskommentiert oder gelöscht werden, die Zeilen mit <EINFG> müssen entsprechend der Testinstallation hinzugefügt werden.

version: "3.4"
services:
  broker:
    container_name: Paperless_Broker
    image: redis:latest
    restart: unless-stopped
    volumes:
      - /volume1/docker/broker:/data
    networks:
      net:

<ENTF>  db:
<ENTF>    container_name: Paperless_DB
<ENTF>    image: postgres:15
<ENTF>    restart: unless-stopped
<ENTF>    volumes:
<ENTF>      - /volume1/DockerDB/Paperless/pgdata:/var/lib/postgresql/data
<ENTF>    environment:
<ENTF>      POSTGRES_DB: paperless
<ENTF>      POSTGRES_USER: paperless
<ENTF>      POSTGRES_PASSWORD: paperless
<ENTF>    networks:
<ENTF>      net:

  webserver:
    container_name: Paperless
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
<ENTF>      - db
      - broker
    ports:
      - 8100:8000
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - /volume1/docker/paperless_data:/usr/src/paperless/data
      - /volume1/DockerData/Paperless/media:/usr/src/paperless/media
      - /volume1/DockerData/Paperless/export:/usr/src/paperless/export
      - /volume1/Temp/consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
<ENTF>      PAPERLESS_DBHOST: db
<EINFG>      PAPERLESS_DBENGINE: mariadb
<EINFG>      PAPERLESS_DBHOST: <ip der syno>
<EINFG>      PAPERLESS_DBNAME: paperless
<EINFG>      PAPERLESS_DBUSER: paperless
<EINFG>      PAPERLESS_DBPASS: <das geheime passwort>
<EINFG>      PAPERLESS_DBPORT: 3307
    networks:
      net:
 
networks:
    net:

Ihr könnt dann mit "docker-compose up -d --remove-orphans" den Container neu erstellen. "--remove-orphans" sorgt dafür, dass der nicht mehr benötigte Postgresql-Container gelöscht wird. Das Datenbankverzeichnis bleibt erst mal bestehen und kann später, wenn alles sauber läuft, auch gelöscht werden.

Die Testumgebung inklusive der Verzeichnisse könnt ihr dann ebenfalls löschen.

P.S. Alle compose-Dateien müsst ihr natürlich gemäß eurer Umgebung anpassen. Die Containernamen müssen ebenso eure sein, da ich meine bestehende Installation als Beispiel genommen habe.

6. Zwei Compose-Files für eine MariaDB-Installation

Paperless mit MariaDB der Synology:

Spoiler: Synology-MariaDB

version: "3.4"
services:
  broker:
    container_name: Paperless_Broker
    image: redis:latest
    restart: unless-stopped
    volumes:
      - /volume1/docker/broker:/data
    networks:
      net:

  webserver:
    container_name: Paperless
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
<ENTF>      - db
      - broker
    ports:
      - 8100:8000
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - /volume1/docker/paperless_data:/usr/src/paperless/data
      - /volume1/DockerData/Paperless/media:/usr/src/paperless/media
      - /volume1/DockerData/Paperless/export:/usr/src/paperless/export
      - /volume1/Temp/consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBENGINE: mariadb
      PAPERLESS_DBHOST: <ip der syno>
      PAPERLESS_DBNAME: paperless
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: <das geheime passwort>
      PAPERLESS_DBPORT: 3307
    networks:
      net:
 
networks:
    net:

Paperless mit MariaDB in extra Container und eigenem Netz:

Spoiler: MariaDB in Container

version: "3.4"
services:
  broker:
    container_name: Paperless_Broker
    image: redis:latest
    restart: unless-stopped
    healthcheck:
      test: [ 'CMD', 'redis-cli', 'ping' ]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - /volume1/docker/paperless/broker:/data
    networks:
      net:

  webserver:
    container_name: Paperless
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - broker
    ports:
      - 8100:8000
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - /volume1/docker/paperless/main:/usr/src/paperless/data
      - /volume1/DockerData/Paperless/media:/usr/src/paperless/media
      - /volume1/DockerData/Paperless/export:/usr/src/paperless/export
      - /volume1/Temp/consume:/usr/src/paperless/consume
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBENGINE: mariadb
      PAPERLESS_DBHOST: MariaDB #Name des MariaDB-Containers
      PAPERLESS_DBNAME: paperless
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: <das geheime passwort>
      PAPERLESS_DBPORT: 3306
    networks:
      net:
      mariadb:
  
networks:
  net:
  mariadb:
    external: true

Spoiler: History

Kleine Überarbeitung
Ergänzung Compose-Files unter 6.

 

[MWa]

Da ja seit Version 1.9.0 von Paperless-ngx auch MariaDB unterstützt wird, hab ich mich gefragt, wozu also ein extra Container für die Datenbank wenn ich schon MariaDB auf der Syno habe.

Wie kann ich also meine bestehende Installation nach MariaDB migrieren.

Danke für die gute Anleitung !!
Läuft Problemlos.

 

[Adama]

Freut mich, dann hab' ich ja beim Zusammenschreiben nichts vergessen...

 

[Tuxnet]

Adams, danke für die tolle Anleitung !
Was muss ich den eintragen, um einen Datenbank Namen selber zu wählen ?

Es wird Standardmäßig immer paperless genommen.

 

[Adama]

Hi Tuxnet, Adama bitte...

Ich muss ehrlich sagen, da hab ich mir nicht den Kopf drüber zerbrochen. Bei Postgresql wird der Datenbankname angeben, bei MySQL/MariaDB nicht. Hast du mal einen Blick in die Doku geworfen, ob da was steht?

 

[EDvonSchleck]

PAPERLESS_DBNAME=<name>

Gilt für Postgres und Mariadb!

Einfach die Environments hinzufügen und gut. Steht alles in der Doku.

 

[Adama]

Ah, ok, dann weiß ich nicht, warum ich den aus meiner Compose-Datei gelöscht habe...

 

[nascherer]

Hallo und danke erst einmal für die ausführliche Anleitung, Adama.

Ich nutze auch seit ca 1/2 Jahr paperless-ngx auf meiner DS 720+ (auf 18 Gbyte RAM aufgerüstet).
Ich habe bisher keine alten Unterlagen "nach-archiviert" (schlicht keine Zeit dafür gefunden), sondern lediglich neuen Posteingang in die Paperless DB (bei mir noch SQLite) einfließen lassen.
Es sind daher erst ca 700 Files (> 99% PDF), mit einer DB (Archive + Original) Größe von ca 700 MByte.
Trotz der eher geringen DB Größe habe ich bereits das Gefühl, dass alles träger läuft als zuvor.
Perspektivisch werden hier höchstens noch Ehefrau und Kinder (noch sind sie klein) ihre Daten einpflegen, sodass auch kein hoher parallel-Zugriff zu erwarten ist.
Ich frage mich, ob es hier Erfahrungen gibt, ob bei so geringer Datengröße bereits ein Umstieg auf mariadb oder postgresql sinnvoll sein kann (generell und/oder speziell im Falle von paperless-ngx), oder ober das Umstiegs-Unterfangen vergebene Lebenszeit darstellt?
Haben die erfahrenen User hier eine Meinung zu?
Ich würde mich über ein Feedback freuen.

Gruß, nascherer

 

[Monacum]

Ich bin über die Größe der Datenbank erstaunt; ich habe bei 600 Dokumenten gerade mal 13 MB (PostgreSQL). Woran das liegen könnte, kann ich dir aber nicht sagen.

 

[ebusynsyn]

Bei mir sind es bei 949 Dokumenten (alles PDF) 70 MB (PostgreSQL).

Eine Migration zu MariaDB traue ich mir mangels Kenntnissen, trotz dieser guten Anleitung, nicht zu. Ebensowenig kann ich abschätzen, ob es - nebst dem einsparen eines Containers - Vorteile bringe, so eine Migration durchzuführen.

 

[nascherer]

Danke für die Rückmeldungen.
Tja, schon etwas komisch, dieser krasse Größenunterschied der DBs, bei 'ähnlicher' Filezahl. Ich habe relativ viele Vertragsdokumente mit hoher Seitenzahl eingescannt, vielleicht daher...?
Werde dem nochmal nachgehen...

Ansonsten grummelts mich auch vor dem Wechsel, sonst hätte ich hier nicht gefragt, weil konkrete Nachteile kann ich für meinen Usecase kaum erkennen.
Andererseits sollte mit einem vorherigem Backup und zur not neu aufgesetztem Stack auch alles wieder relativ einfach umkehrbarsein, falls es Probleme gibt, oder bestehen hier Einwände?

 

[Monacum]

Nein, hab so letztens ein Volume auf meinem NAS neu aufgesetzt, lief ohne Probleme.

 

[Nordlicht01]

Ich hatte mir die Tage erfolgreich Paperless-NGX auf meiner DS920+ aufgesetzt. Im Moment läuft Postgres als DB.

Da ich MariaDB eh laufen habe, bei ich seit gestern Abend am versuchen, Paperless-NGX in einer zweiten Instanz mit MariaDB aufzusetzen.

Ich nutze in Portainer folgende Einstellungen:

version: "3.4"
services:
  broker:
    image: docker.io/library/redis:7
    container_name: Paperless-Broker
    restart: unless-stopped
    volumes:
      - /volume1/docker/paperless/broker:/data

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    container_name: Paperless
    restart: unless-stopped
    depends_on:
      - broker
    ports:
      - "8101:8000"
    healthcheck:
      test: ["CMD", "curl", "-fs", "-S", "--max-time", "2", "http://localhost:8000"]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - /volume1/docker/paperless/data:/usr/src/paperless/data
      - /volume1/docker/paperless/media:/usr/src/paperless/media
      - /volume1/docker/paperless/export:/usr/src/paperless/export
      - /volume1/docker/paperless/consume:/usr/src/paperless/consume
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBENGINE: mariadb
      PAPERLESS_DBHOST: 192.168.178.10
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: GEHEIM
      PAPERLESS_DBPORT: 3307

Dazu folgende Environments:

COMPOSE_PROJECT_NAME=paperless_test
USERMAP_UID=1042
USERMAP_GID=100
PAPERLESS_OCR_LANGUAGE=deu
PAPERLESS_TIME_ZONE=Europe/Berlin
PAPERLESS_OCR_IMAGE_DPI=300
PAPERLESS_TASK_WORKERS=2
PAPERLESS_THREADS_PER_WORKER=2
PAPERLESS_FILENAME_FORMAT={created_year}/{created_month}/{correspondent}/{created}_{document_type}
PAPERLESS_ENABLE_UPDATE_CHECK=true

Die Datenbank habe ich mir via SSH aus dem ersten Post hier erstellt. Der Paperless Container wird gestartet und immer wieder beendet. In der Datenbank werden keine Tabellen angelegt.

Paperless-ngx docker container starting...
Creating directory /tmp/paperless
Adjusting permissions of paperless files. This may take a while.
Waiting for MariaDB to start...
Waiting for Redis...
Connected to Redis broker.
Apply database migrations...
Traceback (most recent call last):
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/base/base.py", line 282, in ensure_connection
    self.connect()
  File "/usr/local/lib/python3.9/site-packages/django/utils/asyncio.py", line 26, in inner
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/base/base.py", line 263, in connect
    self.connection = self.get_new_connection(conn_params)
  File "/usr/local/lib/python3.9/site-packages/django/utils/asyncio.py", line 26, in inner
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/mysql/base.py", line 247, in get_new_connection
    connection = Database.connect(**conn_params)
  File "/usr/local/lib/python3.9/site-packages/MySQLdb/__init__.py", line 121, in Connect
    return Connection(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/MySQLdb/connections.py", line 193, in __init__
    super().__init__(*args, **kwargs2)
MySQLdb.OperationalError: (1045, "Access denied for user 'paperless'@'192.168.240.3' (using password: YES)")
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
  File "/usr/src/paperless/src/manage.py", line 10, in <module>
    execute_from_command_line(sys.argv)
  File "/usr/local/lib/python3.9/site-packages/django/core/management/__init__.py", line 446, in execute_from_command_line
    utility.execute()
  File "/usr/local/lib/python3.9/site-packages/django/core/management/__init__.py", line 440, in execute
    self.fetch_command(subcommand).run_from_argv(self.argv)
  File "/usr/local/lib/python3.9/site-packages/django/core/management/base.py", line 402, in run_from_argv
    self.execute(*args, **cmd_options)
  File "/usr/local/lib/python3.9/site-packages/django/core/management/base.py", line 448, in execute
    output = self.handle(*args, **options)
  File "/usr/local/lib/python3.9/site-packages/django/core/management/base.py", line 96, in wrapped
    res = handle_func(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/django/core/management/commands/migrate.py", line 114, in handle
    executor = MigrationExecutor(connection, self.migration_progress_callback)
  File "/usr/local/lib/python3.9/site-packages/django/db/migrations/executor.py", line 18, in __init__
    self.loader = MigrationLoader(self.connection)
  File "/usr/local/lib/python3.9/site-packages/django/db/migrations/loader.py", line 58, in __init__
    self.build_graph()
  File "/usr/local/lib/python3.9/site-packages/django/db/migrations/loader.py", line 235, in build_graph
    self.applied_migrations = recorder.applied_migrations()
  File "/usr/local/lib/python3.9/site-packages/django/db/migrations/recorder.py", line 81, in applied_migrations
    if self.has_table():
  File "/usr/local/lib/python3.9/site-packages/django/db/migrations/recorder.py", line 57, in has_table
    with self.connection.cursor() as cursor:
  File "/usr/local/lib/python3.9/site-packages/django/utils/asyncio.py", line 26, in inner
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/base/base.py", line 323, in cursor
    return self._cursor()
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/base/base.py", line 299, in _cursor
    self.ensure_connection()
  File "/usr/local/lib/python3.9/site-packages/django/utils/asyncio.py", line 26, in inner
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/base/base.py", line 282, in ensure_connection
    self.connect()
  File "/usr/local/lib/python3.9/site-packages/django/db/utils.py", line 91, in __exit__
    raise dj_exc_value.with_traceback(traceback) from exc_value
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/base/base.py", line 282, in ensure_connection
    self.connect()
  File "/usr/local/lib/python3.9/site-packages/django/utils/asyncio.py", line 26, in inner
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/base/base.py", line 263, in connect
    self.connection = self.get_new_connection(conn_params)
  File "/usr/local/lib/python3.9/site-packages/django/utils/asyncio.py", line 26, in inner
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/django/db/backends/mysql/base.py", line 247, in get_new_connection
    connection = Database.connect(**conn_params)
  File "/usr/local/lib/python3.9/site-packages/MySQLdb/__init__.py", line 121, in Connect
    return Connection(*args, **kwargs)
  File "/usr/local/lib/python3.9/site-packages/MySQLdb/connections.py", line 193, in __init__
    super().__init__(*args, **kwargs2)
django.db.utils.OperationalError: (1045, "Access denied for user 'paperless'@'192.168.240.3' (using password: YES)")

Die in der Logdatei aufgeführte IP-Adresse 192.168.240.3 ist die vom Paperless-Container.

Wo ist mein Denkfehler? Oder macht der ganze Umzug keinen Sinn? Nach dem was ich gelesen habe, kann MariaDB einige Probleme vermeiden.

Vielen Dank und viele Grüße

Nordlicht

 

[plang.pl]

Wieso das hier: "PAPERLESS_DBHOST: 192.168.178.10"?
Ist deine DB in einem MACVLAN und hat eine eigene IP? Wenn nein, muss da der Hostname des Containers der mariadb hin

 

[alexhell]

Nach dem was ich gelesen habe, kann MariaDB einige Probleme vermeiden.

Eigentlich umgekehrt. MariaDB hat paar Sachen auf die man eher achten muss. Die Entwickler schreiben in der Doku folgendes:

For new installations, it is recommended to use PostgreSQL as the database backend.

 

[Nordlicht01]

Ich wollte MariaDB der Synology verwenden. Und habe den Eintrag aus dem ersten Post abgeleitet -> "PAPERLESS_DBHOST: <ip der syno>"

 

[plang.pl]

Achso. Damit habe ich keine Erfahrung. Ich würde das so auch nicht machen.
EDIT: Der User muss dort natürlich erst angelegt werden

 

[Nordlicht01]

Der User ist angelegt.

Du würdest die DB lieber auch als Container laufen lassen? Und dann doch bei PostgreSQL bleiben?

 

[plang.pl]

Ich nutze eine MariaDB als Docker-Container.

 

[Grischabock]

Ich habe auch meine bestehende MariaDB der Syno genutzt (da diese schon im Einsatz ist) und es klappt.

environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBENGINE: mariadb
      PAPERLESS_DBHOST: 192.168.0.0 <- DEINE SYNO IP
      PAPERLESS_DBUSER: paperless <- DEIN MARIADB BENUTZER
      PAPERLESS_DBPASS: xxxxxxxxxx <- DEIN MARIADB PASSWORT
      PAPERLESS_DBPORT: 3306 <- MARIADB PORT