Open Archiver installieren – mit Portainer in ZimaOS

In diesem Beitrag zeige ich Dir Schritt für Schritt, wie Du Open Archiver auf Deinem Server installierst. Als Basis verwende ich ZimaOS mit Portainer – das Prinzip funktioniert aber auf jedem System, das Docker unterstützt. Die komplette Installation dauert ca. 30–35 Minuten.

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:

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 zwei Dinge auf deinem Server:

• Ein Betriebssystem: Ich nutze und zeige alles auf ZimaOS.
• Portainer: Ein webbasiertes Verwaltungs-Tool für Docker.

Solltest du Portainer noch nicht haben, kannst du es in CasaOS und ZimaOS ganz einfach über den integrierten App-Store mit wenigen Klicks installieren.

Schritt 1: Den Docker-Stack in Portainer erstellen

Wir installieren Open Archiver als sogenannten „Stack“. Das ist eine Gruppe von Diensten (Containern), die zusammenarbeiten und über eine einzige Konfigurationsdatei gesteuert werden.

• Dateien von GitHub besorgen: Wir benötigen zwei Konfigurationsdateien aus dem offiziellen Repository: docker-compose.yml und env.example.
• Neuen Stack anlegen: Ö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.
• docker-compose einfügen: Kopiere den gesamten Inhalt der docker-compose.yml-Datei in den Web-Editor von Portainer.
• .env-Variablen hinzufügen: Aktiviere den „Advanced mode“. Kopiere jetzt den Inhalt der env.example-Datei in das .env-Feld. Ändere anschließend den Dateinamen von .env zu stack.env.

Schritt 2: Datenverzeichnisse anlegen

Damit deine archivierten E-Mails und Einstellungen nicht verloren gehen, müssen wir die Daten persistent auf deiner Festplatte speichern. Das nennt man „Volume-Mapping“.

• Hauptordner erstellen: Lege in der Dateiverwaltung von ZimaOS unter /DATA/AppData ein neues Verzeichnis mit dem Namen openarchiver an.
• Pfad kopieren: Klicke auf den Ordner, um seinen vollständigen Pfad zu kopieren.
• Unterordner erstellen: Lege innerhalb deines openarchiver-Ordners die passenden Unterverzeichnisse an:
• Pfade in Portainer anpassen: Gehe zurück zum docker-compose-Editor in Portainer. Ersetze nun bei den Diensten die relativen Pfade (z. B. ./pgdata) durch die vollständigen Pfade, die du gerade für die Unterordner erstellt hast.

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

Schritt 3: Die Konfiguration anpassen (Sicherheit geht vor!)

Jetzt geht es an die .env-Datei in Portainer. Hier legen wir wichtige sicherheitsrelevante Einstellungen fest.

• PORT: Lege den Port fest, unter dem Open Archiver erreichbar sein soll (z. B. 3000). Prüfe, ob dieser Port auf deinem System noch frei ist.
• MASTER_KEY: Ersetze den vorgegebenen Wert durch ein langes, zufälliges Passwort.
• REDIS_PASSWORD: Ändere auch dieses Passwort zu etwas Sicherem.
• SECRET_KEY: Hier wird ein 32-Byte-Schlüssel verlangt. Nutze dafür einen Online-Generator (suche nach „256-bit key generator“), um einen sicheren Schlüssel zu erstellen, und füge ihn hier ein.
• ENCRYPTION_KEY: Auch hier muss ein sicherer und einzigartiger Schlüssel eingetragen werden.
• ORIGIN (Extrem wichtig!): Dieser Eintrag fehlt standardmäßig, ist aber für die Funktionalität entscheidend. Füge eine neue Zeile hinzu und trage dort die URL deines Servers ein. Das Format ist: http://DEINE-SERVER-IP:PORT. Ohne diesen Eintrag funktionieren sonst bestimmte Aktionen in der Weboberfläche nicht.

Schritt 4: Deployment und erster Start

Wenn alles konfiguriert ist, klicke auf „Deploy the stack“. Portainer beginnt nun, alle notwendigen Komponenten herunterzuladen und zu starten. Das kann einige Minuten dauern. Sobald alle Container einen grünen „running“-Status haben, 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).
• 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.

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 Schritt 2), 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 Hauptordner, den du in Schritt 2 angelegt hast (in meinem Beispiel /DATA/AppData/openarchiver) inklusive aller Unterordner (data, pgdata, milydata usw.). Hier liegen deine archivierten E-Mails und die Datenbank.
2. Deine Konfigurationsdateien: Sichere unbedingt deine docker-compose.yml und ganz besonders deine stack.env-Datei (oder wie auch immer du deine .env-Datei in Portainer genannt hast).

Achtung: Die .env-Datei ist überlebenswichtig!

Ich kann das nicht genug betonen: Ohne deine originale .env-Datei ist dein Backup wertlos. Darin stehen nicht nur die Passwörter für die Datenbank, sondern vor allem der MASTER_ENCRYPTION_KEY und der SECRET_KEY, die du in Schritt 3 festgelegt hast.

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 docker-compose.yml in den Web-Editor.
5. .env-Variablen einfügen: 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 docker-compose.yml auf die Verzeichnisse zeigt, in denen deine gesicherten Daten bereits liegen, und die .env-Datei die passenden Schlüssel zum Entsperren liefert, 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:

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 .env Datei aus dem Open-Archiver-Verzeichnis – ohne die Schlüssel (MASTER_KEY, SECRET_KEY, ENCRYPTION_KEY) kannst du keine Mails entschlüsseln!
• 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
• .env-Datei 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.