Open Archiver installieren – mit Portainer in ZimaOS

Viktor Dite, Autor des Beitrags

Von (TECHNiCKR auf YouTube) - Publiziert in Homeserver
Dipl. Informatiker und Tech-Blogger seit 2006.
Aktualisiert am


In diesem Beitrag zeige ich Dir Schritt für Schritt, wie Du Open Archiver auf Deinem Server installierst. Ich zeige Dir zwei Wege: als Stack in Portainer oder direkt per Import in ZimaOS. Das Prinzip funktioniert aber auf jedem System, das Docker unterstützt. Eine .env-Datei brauchst Du dafür nicht mehr, alle Einstellungen stehen in einer einzigen YAML, die Du Dir mit dem Generator weiter unten zusammenstellen kannst.

So installierst Du Open Archiver auf Deinem Server

Für alle, die eine visuelle Anleitung bevorzugen, habe ich den gesamten Prozess in einem Video festgehalten:

Open Archiver installieren - Schritt für Schritt & auf deutsch

Video von Viktor Dite auf seinem YouTube-Kanal TECHNiCKR · Video auf YouTube ansehen

Das Video zeigt noch den älteren Weg mit separater .env-Datei. Die Anleitung unten ist aktueller und einfacher, sie kommt ohne .env aus und funktioniert auch beim Import direkt in ZimaOS.

Du willst wissen, was Open Archiver kann und ob es das richtige Tool für Dich ist? Dann lies zuerst unseren ausführlichen Open-Archiver-Guide. Hier geht es direkt um die Installation.

Was du benötigst

Für diese Anleitung brauchst du nur:

  • Einen Server mit Docker. Ich nutze und zeige alles auf ZimaOS.
  • Für Weg 1: Portainer, ein webbasiertes Verwaltungs-Tool für Docker. In CasaOS und ZimaOS installierst Du es mit wenigen Klicks über den integrierten App-Store.
  • Für Weg 2: nichts weiter, ZimaOS bringt den Import selbst mit.

Vorbereitung für beide Wege

Wo Open Archiver seine Daten speichert

Open Archiver besteht aus fünf Containern: der App selbst, der Datenbank Postgres, dem Cache Valkey, der Suche Meilisearch und Apache Tika für Text aus Anhängen. Ihre Daten landen in einem Ordner auf Deinem Server, in dieser Anleitung /DATA/AppData/openarchiver mit den Unterordnern data, pgdata, valkeydata und meilidata.

Anlegen musst Du die Ordner nicht, Docker erstellt sie beim ersten Start.

Hinweis: In meiner ZimaOS-Installation lautet der korrekte Mountpoint /DATA/ und nicht /ZimaOS-HD/. Überprüfe das für Dein System!

Die YAML mit dem Generator erstellen

Open Archiver braucht fünf Passwörter und Schlüssel, die an mehreren Stellen zusammenpassen müssen. Das erledigt der Generator für Dich. Die Schlüssel erzeugst Du dabei selbst mit einem einzigen Befehl auf Deinem Rechner, der Generator verteilt sie nur an die richtigen Stellen.

YAML-Generator für Open Archiver

Trag deine Werte ein, die fertige YAML erscheint darunter. Alles passiert in deinem Browser, nichts wird übertragen oder gespeichert. Eine .env-Datei brauchst du nicht, alle Einstellungen stehen in der YAML.

Unter diesem Port rufst du Open Archiver später im Browser auf. Er darf auf dem Server noch nicht belegt sein.

Darin landen Archiv, Datenbank, Cache und Suchindex. Anlegen musst du nichts, Docker erstellt die Ordner beim ersten Start.

Führe diesen Befehl im Terminal deines Servers oder Rechners aus und füge die fünf Zeilen, die er ausgibt, hier ein:

for k in DB_PASSWORT REDIS_PASSWORT MEILI_KEY JWT_SECRET ENCRYPTION_KEY; do echo "$k=$(openssl rand -hex 32)"; done

Leer lassen geht auch, dann stehen Platzhalter in der YAML, die du vor dem Start ersetzen musst.


Speichere die fertige YAML an einem sicheren Ort. Ohne den ENCRYPTION_KEY kommst du nach einem Neuaufsetzen nicht mehr an deine gespeicherten Zugangsdaten.

Die Docker-Compose-YAML zum Selbst-Anpassen

Lieber von Hand? Dann nimm diese YAML. Sie funktioniert für beide Wege, Portainer ignoriert den Block x-casaos am Ende einfach.

name: openarchiver
x-oa-env: &oa-env
  NODE_ENV: production
  PORT_BACKEND: "4000"
  PORT_FRONTEND: "3000"
  # ÄNDERN: IP-Adresse deines Servers (und Port, falls du ihn änderst)
  APP_URL: &url "http://192.168.x.x:3000"
  ORIGIN: *url
  SYNC_FREQUENCY: "* * * * *"
  ALL_INCLUSIVE_ARCHIVE: "false"
  ARCHIVE_DRAFTS: "false"
  POSTGRES_DB: open_archive
  POSTGRES_USER: admin
  # ÄNDERN: DEIN_DB_PASSWORT an allen drei Stellen ersetzen
  POSTGRES_PASSWORD: "DEIN_DB_PASSWORT"
  DATABASE_URL: "postgresql://admin:DEIN_DB_PASSWORT@postgres:5432/open_archive"
  # ÄNDERN: an beiden Stellen ersetzen
  MEILI_MASTER_KEY: "DEIN_MEILI_KEY"
  MEILI_HOST: http://meilisearch:7700
  REDIS_HOST: valkey
  REDIS_PORT: "6379"
  # ÄNDERN: an beiden Stellen ersetzen
  REDIS_PASSWORD: "DEIN_REDIS_PASSWORT"
  REDIS_TLS_ENABLED: "false"
  STORAGE_TYPE: local
  STORAGE_LOCAL_ROOT_PATH: /var/data/open-archiver
  BODY_SIZE_LIMIT: 100M
  ENABLE_DELETION: "false"
  # ÄNDERN
  JWT_SECRET: "DEIN_JWT_SECRET"
  JWT_EXPIRES_IN: 7d
  # ÄNDERN: genau 64 Hex-Zeichen (openssl rand -hex 32). Nie verlieren!
  ENCRYPTION_KEY: "DEIN_ENCRYPTION_KEY"
  TIKA_URL: http://tika:9998

services:
  open-archiver:
    image: logiclabshq/open-archiver:latest
    container_name: open-archiver
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment: *oa-env
    volumes:
      - /DATA/AppData/openarchiver/data:/var/data/open-archiver
    depends_on:
      - postgres
      - valkey
      - meilisearch
    networks:
      - open-archiver-net

  postgres:
    image: postgres:17-alpine
    container_name: postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: open_archive
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: "DEIN_DB_PASSWORT"
    volumes:
      - /DATA/AppData/openarchiver/pgdata:/var/lib/postgresql/data
    networks:
      - open-archiver-net

  valkey:
    image: valkey/valkey:8-alpine
    container_name: valkey
    restart: unless-stopped
    command: valkey-server --requirepass DEIN_REDIS_PASSWORT
    volumes:
      - /DATA/AppData/openarchiver/valkeydata:/data
    networks:
      - open-archiver-net

  meilisearch:
    image: getmeili/meilisearch:v1.38
    container_name: meilisearch
    restart: unless-stopped
    environment:
      MEILI_MASTER_KEY: "DEIN_MEILI_KEY"
      MEILI_SCHEDULE_SNAPSHOT: "86400"
    volumes:
      - /DATA/AppData/openarchiver/meilidata:/meili_data
    networks:
      - open-archiver-net

  tika:
    image: apache/tika:4.1.0-full
    container_name: tika
    restart: always
    networks:
      - open-archiver-net

networks:
  open-archiver-net:
    driver: bridge

# Nur für den Import in ZimaOS oder CasaOS: Kachel mit Icon und Port im Dashboard
x-casaos:
  architectures:
    - amd64
    - arm64
  main: open-archiver
  author: LogicLabs-OU
  developer: LogicLabs-OU
  category: Utilities
  description:
    en_us: Self-hosted email archiving with full-text search.
    de_de: E-Mails selbst gehostet archivieren, mit Volltextsuche.
  icon: https://cdn.jsdelivr.net/gh/selfhst/icons/png/open-archiver.png
  tagline:
    en_us: Email archiving
    de_de: E-Mail-Archiv
  title:
    en_us: Open Archiver
  index: /
  port_map: "3000"
  scheme: http

Was du anpassen musst

Erzeuge die Schlüssel im Terminal mit openssl rand -hex 32, für jeden Wert einen eigenen. Online-Generatoren solltest Du für ein Archiv mit Deinen E-Mails nicht verwenden.

  • APP_URL: Trage die IP-Adresse Deines Servers ein. Ohne die richtige Adresse funktionieren bestimmte Aktionen in der Weboberfläche nicht.
  • DEIN_DB_PASSWORT: an allen drei Stellen denselben Wert.
  • DEIN_REDIS_PASSWORT und DEIN_MEILI_KEY: jeweils an beiden Stellen denselben Wert.
  • DEIN_JWT_SECRET: sichert die Anmeldung ab.
  • DEIN_ENCRYPTION_KEY: verschlüsselt die gespeicherten Zugangsdaten Deiner Postfächer. Er muss genau 64 Hex-Zeichen lang sein.
  • Port: Ist 3000 schon belegt, ändere die erste Zahl bei ports, den Port in APP_URL und port_map.
  • Datenordner: Soll Open Archiver woanders speichern, ändere /DATA/AppData/openarchiver an allen vier Stellen.

Weg 1: Open Archiver in Portainer installieren

  • Öffne Portainer, navigiere im Menü zu „Stacks“ und klicke auf „Add stack“.
  • Vergib einen Namen, zum Beispiel openarchiver. Wichtig: Der Name muss komplett kleingeschrieben sein und darf keine Leerzeichen enthalten.
  • Füge Deine YAML in den Web-Editor ein. Eine .env-Datei brauchst Du nicht.
  • Klicke auf „Deploy the stack“. Portainer lädt jetzt alle Images herunter und startet sie. Das kann einige Minuten dauern.

Weg 2: Open Archiver direkt in ZimaOS installieren

Open Archiver gibt es nicht im App-Store von ZimaOS, Du kannst die YAML aber direkt importieren.

  • Klicke im ZimaOS-Dashboard auf das Plus oben rechts über den Apps.
  • Klicke auf „Install custom App“ und dann auf „Import“.
  • Füge Deine YAML aus dem Generator (Installationsweg „ZimaOS oder CasaOS“) oder die YAML von oben ein.
  • Klicke auf „Submit“ und prüfe bei den Ordnern, ob die Pfade auf der gewünschten Festplatte liegen.
  • Starte die Installation. Danach erscheint Open Archiver mit eigenem Icon als Kachel im Dashboard.

Erster Start

Sobald alle Container laufen, ist die Installation abgeschlossen.

  • Öffne einen Browser und rufe die IP-Adresse deines Servers mit dem festgelegten Port auf (z.B. http://192.168.178.134:3000), unter ZimaOS geht das auch per Klick auf die Kachel.
  • Admin-Nutzer anlegen: Dich begrüßt der Willkommensbildschirm. Erstelle hier dein Administratorkonto mit Namen, E-Mail und einem starken Passwort.
  • Grundeinstellungen: Nach dem ersten Login kannst du in den Einstellungen die Sprache auf Deutsch und das Theme auf Dark umstellen.
  • E-Mail-Konten verbinden: Unter dem Menüpunkt „Erfassung“ kannst du jetzt deine E-Mail-Postfächer verbinden, die archiviert werden sollen.

Open Archiver aktualisieren

Die YAML nutzt das Image latest. Ein neues Image holt sich Docker aber nicht von selbst, sonst läuft weiter die alte Version.

  • Portainer: Öffne den Stack, klicke auf „Update the stack“ und aktiviere dabei „Re-pull image“.
  • ZimaOS: ZimaOS erkennt neue Images selbst, auch bei importierten Apps (getestet mit ZimaOS 1.8.0). Unter Einstellungen > Aktualisieren siehst Du, ob Updates anstehen. „Zu den App-Store-Updates“ führt Dich zu Meine Apps > Aktualisieren, dort steht bei Open Archiver „Image-Update verfügbar“ und Du klickst auf „Aktualisieren“. Deine Daten bleiben in den Ordnern erhalten.

Das klappt, weil die YAML latest nutzt. ZimaOS prüft nur, ob es unter dem eingetragenen Tag ein neueres Image gibt. Trägst Du eine feste Version wie v0.6.2 ein, bleibt Open Archiver auf dieser Version, und auf eine neue stellst Du dann selbst in der YAML um.

Wichtig ist das zum Beispiel bei Version 0.6.2 vom 24.10.2026, die eine kritische Sicherheitslücke schließt. Hintergründe, Prüfbefehl und Hilfe bei Fehlern nach dem Update findest Du in meinem Beitrag Open Archiver Updates und kritische Fixes.

So erstellst du ein Backup von Open Archiver (und stellst es wieder her)

Eine Archivierungslösung ist nur so gut wie ihr Backup. Wenn dein Server ausfällt, möchtest du schließlich nicht dein mühsam aufgebautes Archiv verlieren. Die gute Nachricht: Da wir alle Daten sauber in Verzeichnisse auf unserem Host-System gemappt haben (siehe „Wo Open Archiver seine Daten speichert“), ist das Backup unkompliziert.

Was musst du sichern?

Für ein vollständiges Backup von Open Archiver benötigst du exakt zwei Dinge:

  1. Deine Datenverzeichnisse: Das ist der wichtigste Teil. Sichere den kompletten Datenordner (in meinem Beispiel /DATA/AppData/openarchiver) inklusive aller Unterordner (data, pgdata, valkeydata, meilidata). Hier liegen deine archivierten E-Mails und die Datenbank.
  2. Deine YAML: Sichere unbedingt deine YAML. Hast du nach einer älteren Version dieser Anleitung mit .env-Datei installiert, gehört auch deine stack.env dazu.

Achtung: Die YAML ist überlebenswichtig!

Ich kann das nicht genug betonen: Ohne deine originale YAML (bzw. .env-Datei) ist dein Backup wertlos. Darin stehen nicht nur die Passwörter für die Datenbank, sondern vor allem der ENCRYPTION_KEY und der JWT_SECRET.

Ohne diese exakten Schlüssel kann eine neue Installation die verschlüsselten Daten in deinen gesicherten Ordnern nicht mehr entschlüsseln. Dein Archiv wäre unwiederbringlich verloren.

So stellst du das Backup auf einem neuen System wieder her:

  1. Daten kopieren: Kopiere dein gesichertes Hauptverzeichnis (z.B. openarchiver) an exakt denselben Pfad auf dem neuen System, den du auch auf dem alten System verwendet hast. Wenn der Pfad vorher /DATA/AppData/openarchiver war, muss er auch auf dem neuen System wieder so lauten.
  2. Stack neu erstellen: Öffne Portainer auf dem neuen System.
  3. Stack anlegen: Erstelle einen neuen Stack (z.B. openarchiver).
  4. Konfiguration einfügen: Kopiere den Inhalt deiner gesicherten YAML in den Web-Editor (oder importiere sie unter ZimaOS).
  5. Nur bei älteren Installationen mit .env: Aktiviere den „Advanced mode“ und kopiere den Inhalt deiner gesicherten .env-Datei in das .env-Feld (z.B. als stack.env).
  6. Stack deployen: Klicke auf „Deploy the stack“.

Da die YAML auf die Verzeichnisse zeigt, in denen deine gesicherten Daten bereits liegen, und die passenden Schlüssel zum Entsperren enthält, wird Open Archiver starten und alle deine E-Mails und Einstellungen wieder wie gewohnt anzeigen.

Open Archiver sichern am Beispiel (Docker-Umgebung)

Damit du deine E-Mails und Archive in Open Archiver sicherst, brauchst du ein konsistentes Backup aller Datencontainer. Ein einfaches rsync reicht nicht, da Open Archiver und seine Plugins parallel in Datenbanken und Dateien schreiben. Hier erfährst du, wie du ein zuverlässiges inkrementelles Backup mit automatischer Push-Benachrichtigung einrichtest.

Welche Container du sichern musst

Bevor das Backup startet, müssen alle Container, die Daten schreiben, gestoppt werden:

Container Funktion Stoppen?
open-archiver Hauptprozess ja
postgres Datenbank ja
valkey Cache/Key-Store ja
tika Text-Extraktion nein
meilisearch Volltextsuche nein

Diese Container werden im Backup-Script automatisch gestoppt und nach erfolgreicher Sicherung wieder gestartet.

Backup-Script: TAR + rsync + Gotify

Erstelle z. B. unter /usr/local/bin/openarchiver_backup.sh folgendes Script und mache es ausführbar (chmod +x):

#!/bin/bash
#
# Open-Archiver Backup Script (lokales TAR + rsync + Gotify Push)
# https://mizine.de/homeserver/open-archiver-installieren-anleitung-auf-deutsch/
#

export PATH=/usr/bin:/bin:/usr/sbin:/sbin

CONTAINERS=("open-archiver" "postgres" "valkey")
SOURCE_DIR="Dein OpenArchiver Verzeichnis"  ## Dieses Verzeichnis musst Du anpassen
DEST_DIR="Dein Backup Verzeichnis" ## Dieses Verzeichnis musst Du anpassen

LOCAL_BACKUP="/tmp/openarchiver_backup.tar"  ## Dieses Verzeichnis musst Du anpassen
SNAPSHOT_FILE="${DEST_DIR}/openarchiver_snapshot.snar"
REMOTE_BACKUP="${DEST_DIR}/openarchiver_backup.tar"
LOG_FILE="${DEST_DIR}/openarchiver_backup.log"

# Gotify Push
GOTIFY_URL="https://gotify.example.net"  ## Diese URL musst Du anpassen
GOTIFY_TOKEN="DEIN_APP_TOKEN" ## Diesen App Token musst Du anpassen

send_gotify() {
  local TITLE="$1"
  local MESSAGE="$2"
  local PRIORITY="${3:-5}"
  curl -s -X POST "${GOTIFY_URL}/message?token=${GOTIFY_TOKEN}" \
       -F "title=${TITLE}" -F "message=${MESSAGE}" -F "priority=${PRIORITY}" >/dev/null 2>&1
}

: > "$LOG_FILE"
START_TIME=$(date)
echo "--- Backup gestartet: $START_TIME ---" | tee -a "$LOG_FILE"
send_gotify "Open-Archiver Backup gestartet" "Backup gestartet: $START_TIME"

# Container stoppen
for c in "${CONTAINERS[@]}"; do
  echo "- Stoppe $c ..." | tee -a "$LOG_FILE"
  docker stop "$c" >> "$LOG_FILE" 2>&1 || echo "$c lief nicht." | tee -a "$LOG_FILE"
done

# TAR-Backup lokal erstellen
echo "Erzeuge inkrementelles TAR..." | tee -a "$LOG_FILE"
tar --listed-incremental="$SNAPSHOT_FILE" -cpf "$LOCAL_BACKUP" -C "$SOURCE_DIR" . 2>&1 | tee -a "$LOG_FILE"
TAR_EXIT=$?

# rsync-Übertragung (nur Deltas)
echo "Übertrage Backup via rsync..." | tee -a "$LOG_FILE"
rsync -av --progress --inplace "$LOCAL_BACKUP" "$REMOTE_BACKUP" >> "$LOG_FILE" 2>&1
RSYNC_EXIT=$?

# Container wieder starten
for c in "${CONTAINERS[@]}"; do
  echo "- Starte $c ..." | tee -a "$LOG_FILE"
  docker start "$c" >> "$LOG_FILE" 2>&1
done

## rm -f "$LOCAL_BACKUP" ## kommentiere aus, wenn Du das lokale Backup nach Erfolg löschen willst
END_TIME=$(date)

if [ $TAR_EXIT -eq 0 ] && [ $RSYNC_EXIT -eq 0 ]; then
  send_gotify "Open-Archiver Backup erfolgreich" "Abgeschlossen: $END_TIME"
else
  send_gotify "Open-Archiver Backup FEHLGESCHLAGEN" "Log prüfen: $LOG_FILE" 8
fi

echo "--- Backup abgeschlossen: $END_TIME ---" | tee -a "$LOG_FILE"

Was macht das Skript?

  • Das Script erstellt lokal ein unkomprimiertes TAR-Archiv, damit rsync Block-Deltas übertragen kann.
  • Die Snapshot-Datei (.snar) merkt sich, welche Dateien sich geändert haben -> echtes inkrementelles Backup.
  • Gotify schickt Push-Meldungen bei Start, Erfolg oder Fehler.
  • Am Ende werden alle Container automatisch wieder gestartet.

Automatisches Backup per Cron

Beispiel-Cronjob (täglich um 2 Uhr):

0 2 * * * /usr/local/bin/openarchiver_backup.sh

Wiederherstellung (Restore)

Wenn du dein Archiv wieder einspielen willst:

tar --listed-incremental=/dev/null -xpvf openarchiver_backup.tar -C /Dein_Open_Archiver_Docker_Verzeichnis

Anschließend deinen Docker-Stack neu deployen.

  • Sichere deswegen deine YAML (bzw. bei älteren Installationen die .env-Datei) – ohne die Schlüssel (ENCRYPTION_KEY, JWT_SECRET) kommst du nicht mehr an deine gespeicherten Zugangsdaten!
  • Test-Restore regelmäßig durchführen, z. B. auf einem Testsystem.

GoBD-konforme Archivierung mit AWS S3

Open Archiver lässt sich mit Amazon S3 als Speicherziel verbinden und in Kombination mit S3 Object Lock (WORM) GoBD-konform betreiben. Die Details zu Löschschutz, Verschlüsselung und Compliance-Optionen findest Du im Open-Archiver-Guide.

Nächste Schritte nach der Installation

Wenn Open Archiver läuft und die ersten E-Mail-Konten verbunden sind, solltest Du:

  • Backup einrichten: Nutze das Backup-Skript weiter oben oder das integrierte ZimaOS-Backup
  • YAML sicher aufbewahren: Ohne die Verschlüsselungsschlüssel ist Dein Archiv bei einem Serverausfall verloren
  • Alternativen prüfen: Lies unseren Vergleich zwischen Open Archiver und Mail Archiver, falls Du noch unsicher bist, ob Open Archiver das richtige Tool für Dich ist

Alles Weitere zu Features, Einsatzgebieten und Systemvoraussetzungen findest Du im Open-Archiver-Guide.