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:
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 inAPP_URLundport_map. - Datenordner: Soll Open Archiver woanders speichern, ändere
/DATA/AppData/openarchiveran 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:
- 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. - Deine YAML: Sichere unbedingt deine YAML. Hast du nach einer älteren Version dieser Anleitung mit .env-Datei installiert, gehört auch deine
stack.envdazu.
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:
- 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/openarchiverwar, muss er auch auf dem neuen System wieder so lauten. - Stack neu erstellen: Öffne Portainer auf dem neuen System.
- Stack anlegen: Erstelle einen neuen Stack (z.B.
openarchiver). - Konfiguration einfügen: Kopiere den Inhalt deiner gesicherten YAML in den Web-Editor (oder importiere sie unter ZimaOS).
- Nur bei älteren Installationen mit .env: Aktiviere den „Advanced mode“ und kopiere den Inhalt deiner gesicherten
.env-Datei in das.env-Feld (z.B. alsstack.env). - 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
rsyncBlock-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.





















