Ein paar irrelevante Tutorials

Paperless-NGX im Loadbalancing

Paperless-NGX ist an und für sich schon eine recht performante Lösung. Wenn aber viele Anwenderinnen und Anwender gleichzeitig damit arbeiten sollen, dann kann der Bedarf nach Skalierung der Maschinenressourcen entstehen. Ich habe mir eine Lösung überlegt, die aus drei Paperless-NGX-Webservern mit jeweils den Komponenten Redis, Gotenberg und Tika sowie traefik als Loadbalancer besteht. Damit diese drei Server eine gemeinsame Datenbasis nutzen, liegen die Dokumente auf einem gemeinsam genutzten NFS-Share und die Daten in einer abgesetzten Datenbank. Das System besteht also aus sechs Servern:

http:
  routers:
    paperless:
      rule: "Host(`paperless.local`)"
      service: paperless
      entryPoints:
        - "web"

  services:
    paperless:
      loadBalancer:
        sticky:
          Cookie:
            name: paperless_sticky
        servers:
          - url: "http://192.168.0.113:8000"
          - url: "http://192.168.0.59:8000"
          - url: "http://192.168.0.149:8000"
        healthCheck:
          path: /api/health/
          interval: 10s
          timeout: 5s
          scheme: http
          port: 8000

services:
  traefik:
    image: traefik:v2.10
    container_name: traefik
    command:
      - --api.insecure=true
      - --providers.docker=false # Docker Provider nicht noetig, 
                                 # da Services auf anderen Servern laufen
      - --providers.file=true
      - --providers.file.filename=/etc/traefik/rules.yml
      - --entrypoints.web.address=:80
    ports:
      - "80:80"
      - "8080:8080" # Dashboard (optional)
    volumes:
      - ./rules.yml:/etc/traefik/rules.yml
    networks:
      - traefik_net

networks:
  traefik_net:
    driver: bridge

In der Datei rules.yml wird die Adresse, unter der der Service nachher erreichbar sein soll, definiert. Ich nutze da das hier nur im lokalen Netz läuft, das System ohne SSL-Zertifikate. Außerdem werden hier die Server, auf denen nachher Paperless-NGX laufen wird, mit ihren jeweiligen IP-Adressen aufgelistet. Der Sticky-Teil sorgt dafür, dass man während einer Sitzung auf einem Server bleibt und der Health-Check sorgt dafür, dass traefik nach spätestens 5 Sekunden einen Server, der nicht reagiert, aus dem Spiel nimmt.

/mnt/storage/data 192.168.0.59(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)
/mnt/storage/media 192.168.0.59(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)
/mnt/storage/data 192.168.0.113(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)
/mnt/storage/media 192.168.0.113(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)
/mnt/storage/data 192.168.0.149(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)
/mnt/storage/media 192.168.0.149(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)

Die Bezeichnung Webserver trifft es nicht ganz, denn auf diesen Servern laufen neben den Webservern noch jeweils die Dienste Gotenberg und Tika für die Verarbeitung der Dokumente und die In-Memory-Datenbank redis, die die DB-Zugriffe auf die Postgresql-Datenbank puffert. Ich habe also drei Linux-Server, auf denen bereits Docker und Docker-Compose installiert ist (s.o.). Hier muss ich zunächst die NFS-Freigaben mounten. Dazu muss ich zuerst den NFS-Client mit

services:
  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - broker
      - gotenberg
      - tika
    ports:
      - "8000:8000"
    volumes:
      - ./data:/usr/src/paperless/data
      - ./media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    environment:
      PAPERLESS_DBHOST: 192.168.0.139
      PAPERLESS_DBNAME: paperless
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: 123456

      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_TIKA_ENABLED: 1
      PAPERLESS_TIKA_GOTENBERG_ENDPOINT: http://gotenberg:3000
      PAPERLESS_TIKA_ENDPOINT: http://tika:9998

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

    # The gotenberg chromium route is used to convert .eml files. We do not
    # want to allow external content like tracking pixels or even javascript.
    command:
      - "gotenberg"
      - "--chromium-disable-javascript=true"
      - "--chromium-allow-list=file:///tmp/.*"

  tika:
    image: docker.io/apache/tika:latest
    restart: unless-stopped

volumes:
  redisdata:

Paperless-NGX ist nun mit verteilten Kapazitäten verfügbar. Die Last wird auf drei Webserver und einen Datenbankserver aufgeteilt. Die Zahl der Webserver lässt sich steigern. Dabei wendet der Loadbalancer ein sogenanntes Round-Robin-Prinzip an, das heißt, bei jeder Anmeldung wird der Reihe nach der jeweils nächste Server gewählt. Dass das funktioniert, kann man ausprobieren, indem man sich zum Beispiel mit zwei Browsern anmeldet, jeweils Dokumente hochlädt und in den Protokollen der Webserver nachsieht, wer das gerade verarbeitet hat.

Paperless-NGX im Loadbalancing

Der Datenbankserver

Der Loadbalancer

Der NFS-Server und die Freigaben

Die Webserver

Ergebnis/Fazit