Open Archiver installieren – mit Portainer in ZimaOS

Gehören dir deine E-Mails wirklich noch? Oft liegen sie bei verschiedenen Anbietern und sind von deren Geschäftsbedingungen abhängig. Mit Open Archiver holst du dir die Kontrolle zurück und baust dir dein eigenes, sicheres und langfristiges E-Mail-Archiv mit Open Archiver auf deinem Server auf.

In diesem Beitrag zeige ich dir detailliert, wie du Open Archiver installierst. Als Basis verwende ich mein bevorzugtes System für einen Homeserver, ZimaOS , und wir wickeln die Installation einfach und schnell über Portainer in Docker-Containern ab. Aber keine Sorge: Das Prinzip funktioniert auch auf jedem anderen Betriebssystem, das Docker unterstützt.

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:

Warum du deine E-Mails selbst archivieren solltest

• Datenhoheit: Deine E-Mails sind dein Eigentum. Du entscheidest, wo sie liegen.
• Unabhängigkeit: Egal, ob ein Anbieter den Dienst einstellt oder du dein Konto wechselst – dein Archiv bleibt dir erhalten.
• Zentraler Zugriff: Durchsuche die E-Mails all deiner Konten an einem einzigen Ort.
• Sicherheit & Backup: Du hast die volle Kontrolle über die Sicherheitsmaßnahmen und kannst deine eigene Backup-Strategie umsetzen.

Ist Open Archiver sicher?

Den Anstoß für dieses Projekt gab mir übrigens ein Video von Apfelcast , eine klare Empfehlung für jeden, der Open-Source-Lösungen im unternehmerischen Umfeld einsetzen möchte. Aus diesen Grund darfst Du davon ausgehen, dass Open Archiver sicher genug ist, um es auf alle Mails loszulassen, sonst würde Apfelcast sicher keine Werbung für deren Umsetzung im unternehmerischen Umfeld dafür machen.

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.

GOPD-konform Open Archiver mit Amazon AWS

Open Archiver lässt sich mit einem professionellen Cloud-Speicher wie Amazon Web Services (AWS) verbinden. Anstatt die E-Mails auf der lokalen Festplatte zu speichern, nutzt man Amazon S3 als Speicherziel.

Seit dem Update 0.4.0 gibt es eine neue, instanzweite Einstellung (ENABLE_DELETION Umgebungsvariable), um das Löschen von E-Mails und Erfassungsquellen komplett zu deaktivieren.

Ebenso lässt sich jetzt endlich eine DAteiverschlüsselung aktivieren, sodass die heruntergeladenen E-Mails nicht mehr in Plaintext auf dem Server liegen.

Revisionssicherheit durch S3 Object Lock: Mit der Funktion „S3 Object Lock“ im Compliance-Modus bietet AWS eine echte WORM-Funktionalität (Write Once, Read Many). Einmal in einem solchen Bucket gespeichert, kann eine E-Mail für einen festgelegten Zeitraum von absolut niemandem mehr gelöscht oder verändert werden – nicht einmal vom AWS-Account-Besitzer selbst. Damit ist die GoBD-Konformität auf Speicher-Ebene sichergestellt.

Der Kompromiss sind die Kosten: Diese professionelle Lösung ist natürlich nicht kostenlos. AWS rechnet Speichervolumen, Datenübertragungen und API-Anfragen ab. Je nach E-Mail-Aufkommen können hier schnell relevante monatliche Kosten entstehen. Es lohnt sich daher, die potenziellen AWS-Kosten genau zu kalkulieren und mit fertigen, spezialisierten E-Mail-Archivierungsdiensten zu vergleichen. Diese könnten am Ende sogar die günstigere und vor allem, die wartungsärmere Alternative sein.

Mein Fazit

Open Archiver ist ein fantastisches Projekt für Technik-Enthusiasten und Privatpersonen, die die Kontrolle über ihre E-Mail-Daten zurückgewinnen wollen. Die Installation ist machbar und die Funktionalität absolut sinnig.

Für den unternehmerischen Einsatz ist die Software in Kombination mit einem sicheren Backend wie AWS S3 umsetzbar und kann die Anforderungen an eine professionelle Archivierung erfüllen – allerdings zu entsprechenden Kosten.