---
title: "docker-mailserver mit Docker installieren: Vollständiger eigener Mailserver (SMTP\/IMAP\/DKIM)"
date: 2026-07-05T07:36:00+02:00
modified: 2026-11-10T16:37:00+01:00
category: email
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/docker-mailserver-eigener-mailserver
reading_time: 11
personalize_url: "https://s-edv.com/anleitungen/docker-mailserver-eigener-mailserver#tz={tz}&domain={domain}&mail_user={mail_user}"
variables:
  - name: tz
    label: "Zeitzone"
    default: "Europe/Berlin"
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
  - name: mail_user
    label: "Name des E-Mail-Kontos"
    default: "nutzer"
  - name: mail_pass
    label: "Passwort des E-Mail-Kontos"
    generated_in_browser: true
---

# docker-mailserver mit Docker installieren: Vollständiger eigener Mailserver (SMTP/IMAP/DKIM)

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{tz}}` | Zeitzone | `Europe/Berlin` |
| `{{domain}}` | Ihre Domain | `example.com` |
| `{{mail_user}}` | Name des E-Mail-Kontos | `nutzer` |
| `{{mail_pass}}` | Passwort des E-Mail-Kontos | wird im Browser des Lesers zufällig erzeugt |

Link mit eigenen Werten: https://s-edv.com/anleitungen/docker-mailserver-eigener-mailserver#tz=Europe%2FBerlin&domain=cloud.example.com&mail_user=nutzer

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

**docker-mailserver** bündelt alle Maildienste in einem gepflegten Image: Postfix für SMTP, Dovecot für IMAP, OpenDKIM, OpenDMARC, Rspamd als Spam-Filter und Fail2Ban gegen Brute-Force-Angriffe, ohne externe Datenbank, ohne Redis, ohne PostgreSQL. Die Konfiguration läuft dateibasiert. Die Anleitung richtet sich an Administratoren, die einen produktionsbereiten Mailserver für eigene Domains auf einem Linux-Server betreiben möchten.

**Kurzfassung:** Legen Sie einen Projektordner an, laden Sie die `mailserver.env` herunter und passen Sie Hostname sowie SSL-Typ an. Starten Sie den Container mit `docker compose up -d`. Legen Sie danach sofort ein E-Mail-Konto an und erzeugen Sie DKIM-Schlüssel. Tragen Sie MX-, SPF-, DKIM- und DMARC-Records im DNS ein, dann ist der Mailserver bereit. Für ClamAV werden mindestens 2 GB RAM benötigt; ohne ClamAV reicht 1 GB. Port 25 muss beim Hoster aktiv freigeschaltet sein.

## Voraussetzungen

- [ ] **Linux-Server** (Ubuntu 22.04/24.04 oder Debian 12/13 empfohlen, x86_64 oder arm64, mindestens 1 CPU-Kern, besser 2) mit **statischer öffentlicher IP-Adresse** und mindestens 20 GB freiem Speicher für Postfächer und Logs
- [ ] **Docker Engine 20.10+** und **Docker Compose v2** (Plugin, nicht das veraltete `docker-compose` v1). Falls noch nicht installiert, siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
- [ ] **RAM:** mindestens 1 GB ohne ClamAV, mindestens 2 GB mit ClamAV (`ENABLE_CLAMAV=1`)
- [ ] **Eigene Domain** mit Zugriff auf die DNS-Verwaltung (für MX, SPF, DKIM, DMARC und PTR-Record)
- [ ] **Offene Ports** 25, 465, 587 und 993, sowohl in der Server-Firewall als auch beim Hoster freigeschaltet
- [ ] **TLS-Zertifikat** für die Mail-Domain, z. B. via Let's Encrypt/Certbot. Anleitung: [Let's Encrypt mit certbot](https://s-edv.com/anleitungen/lets-encrypt-certbot-tls-zertifikate)
- [ ] **Reverse-DNS-Eintrag (PTR)** der Server-IP auf den FQDN des Mailservers, beim Hoster beantragen
- [ ] `wget` oder `curl` sowie ein Texteditor (`nano`, `vim` oder VS Code) auf dem Server

## Schritt 1: Eckdaten und Projektordner anlegen

docker-mailserver nutzt als primäre Registry die GitHub Container Registry (`ghcr.io`), Docker Hub dient als Spiegel.

| Eigenschaft | Wert |
| --- | --- |
| Image | `ghcr.io/docker-mailserver/docker-mailserver:17.0.0` |
| Aktueller stabiler Release | v17.0.0 (November 2026, Basis Debian 13, Dovecot 2.4) |
| Architektur | amd64 (x86_64) und arm64 |
| Externe Datenbank | nicht erforderlich |
| Lizenz | MIT |

| Port | Protokoll | Zweck |
| --- | --- | --- |
| 25 | SMTP | Eingehende Mails von anderen Mailservern (MX-Ziel, muss extern erreichbar sein) |
| 465 | SMTPS | Implicit TLS: Postausgang für Mail-Clients |
| 587 | Submission | STARTTLS: empfohlener Postausgangsport für Endnutzer |
| 993 | IMAPS | IMAP mit Implicit TLS: verschlüsselter Posteingang (empfohlen) |
| 143 | IMAP4 | IMAP mit STARTTLS: optional, in compose.yaml auskommentiert |

Legen Sie den Projektordner an. Alle Datenpfade liegen unter `./docker-data/dms/`, Docker legt sie beim ersten Start an:

```bash
$ sudo mkdir -p /opt/mailserver
$ cd /opt/mailserver
```

> **Prüfen:** Der Ordner existiert und Sie befinden sich darin:
>
> ```bash
> pwd
> # Erwartete Ausgabe: /opt/mailserver
> ```

## Schritt 2: Konfigurationsdatei mailserver.env anlegen

Laden Sie die offizielle Vorlage der `mailserver.env` passend zur Image-Version herunter:

```bash
$ wget https://raw.githubusercontent.com/docker-mailserver/docker-mailserver/v17.0.0/mailserver.env
```

Passen Sie die folgenden Schlüsselwerte an. In der Vorlage sind `SSL_TYPE` leer sowie Rspamd und ClamAV ausgeschaltet. Die übrigen Einstellungen bleiben auf den sicheren Standardwerten:

Datei: `mailserver.env`

```ini
# Zeitzone (AREA/ZONE-Format)
TZ={{tz}}

# TLS-Methode: letsencrypt für Produktion (Pflicht!)
SSL_TYPE=letsencrypt

# Postmaster-Adresse für Systemmeldungen
POSTMASTER_ADDRESS=postmaster@{{domain}}

# Spam-Filter: Rspamd ist der moderne Weg (ersetzt SpamAssassin)
ENABLE_RSPAMD=1

# Antivirus: benötigt ~850 MB RAM; bei < 1,5 GB freiem RAM auf 0 setzen
ENABLE_CLAMAV=1

# Brute-Force-Schutz: erfordert cap_add: NET_ADMIN in compose.yaml
ENABLE_FAIL2BAN=1

# DKIM und DMARC bleiben aktiv (Standard: 1)
ENABLE_OPENDKIM=1
ENABLE_OPENDMARC=1

# Relay-Verhalten: none = nur authentifizierte Clients (sicher, Standard)
# ACHTUNG: jeden anderen Wert nur bewusst setzen, falsch konfiguriert = Open Relay!
PERMIT_DOCKER=none

# Log-Verbosität
LOG_LEVEL=info
```

> **Achtung:** **Wichtig:** Ersetzen Sie `example.com` überall durch Ihre echte Domain. Setzen Sie `ENABLE_CLAMAV=0`, wenn Ihr Server weniger als 1,5 GB freien RAM hat.

> **Prüfen:** ```bash
> grep -E "^SSL_TYPE|^ENABLE_RSPAMD|^PERMIT_DOCKER" mailserver.env
> # Erwartete Ausgabe:
> # SSL_TYPE=letsencrypt
> # ENABLE_RSPAMD=1
> # PERMIT_DOCKER=none
> ```

## Schritt 3: compose.yaml erstellen

Erstellen Sie die `compose.yaml` im Projektordner. Der `hostname` muss exakt dem FQDN (vollständiger Hostname, z. B. `mail.{{domain}}`) entsprechen, den Sie als MX-Record eintragen, sonst werden Mails abgelehnt.

Datei: `compose.yaml`

```yaml
services:
  mailserver:
    image: ghcr.io/docker-mailserver/docker-mailserver:17.0.0
    container_name: mailserver
    # FQDN muss exakt dem MX-DNS-Record entsprechen
    hostname: mail.{{domain}}
    ports:
      - "25:25"      # SMTP (eingehend, MX-Ziel)
      - "465:465"    # SMTPS Implicit TLS
      - "587:587"    # Submission STARTTLS
      - "993:993"    # IMAPS Implicit TLS
      # - "143:143"  # IMAP4 optional
    volumes:
      - ./docker-data/dms/mail-data/:/var/mail/
      - ./docker-data/dms/mail-state/:/var/mail-state/
      - ./docker-data/dms/mail-logs/:/var/log/mail/
      - ./docker-data/dms/config/:/tmp/docker-mailserver/
      - /etc/localtime:/etc/localtime:ro
      # Gesamten /etc/letsencrypt-Ordner mounten: Symlinks zeigen auf archive/!
      - /etc/letsencrypt:/etc/letsencrypt:ro
    env_file:
      - mailserver.env
    # Fail2Ban benötigt NET_ADMIN zum Schreiben von iptables-Regeln
    cap_add:
      - NET_ADMIN
    restart: always
    stop_grace_period: 1m
    # Healthcheck bringt das Image seit v16 selbst mit (dms-healthcheck)
```

Ohne Let's-Encrypt-Zertifikat setzen Sie zum Testen vorübergehend `SSL_TYPE=self-signed` in der `mailserver.env`. Welche Zertifikatsdateien dafür nötig sind, steht unter „Kann ich den Server ohne Let's Encrypt testen?“. Für den Produktionsbetrieb ist `letsencrypt` Pflicht.

> Prüfen Sie die YAML-Syntax mit:
>
> ```bash
> docker compose config --quiet && echo "YAML gültig"
> # Erwartete Ausgabe: YAML gültig
> ```

## Schritt 4: DNS-Records konfigurieren

Setzen Sie vor dem Start zumindest MX und SPF. Ohne korrekte DNS-Records weisen andere Server Mails ab oder stufen sie als Spam ein.

| Record-Typ | Name | Wert / Ziel | Pflicht? |
| --- | --- | --- | --- |
| MX | `{{domain}}` | `mail.{{domain}}` (Priorität 10) | Pflicht |
| A | `mail.{{domain}}` | IP-Adresse des Servers | Pflicht |
| TXT (SPF) | `{{domain}}` | `v=spf1 mx -all` | Pflicht |
| TXT (DKIM) | `mail._domainkey.{{domain}}` | Inhalt aus `mail.txt` nach Setup (Schritt 6) | Pflicht |
| TXT (DMARC) | `_dmarc.{{domain}}` | `v=DMARC1; p=quarantine; rua=mailto:dmarc@{{domain}}` | Empfohlen |
| PTR (Reverse DNS) | Server-IP | `mail.{{domain}}` (beim Hoster beantragen) | Pflicht |

Den PTR/Reverse-DNS-Record müssen Sie bei Ihrem Hosting-Anbieter oder Rechenzentrum beantragen. Er lässt sich nicht selbst in der Domain-DNS-Verwaltung eintragen. Hintergründe dazu finden Sie in der Anleitung [Reverse DNS (PTR) und IPv6 für Mailserver korrekt einrichten](https://s-edv.com/anleitungen/reverse-dns-ptr-ipv6-mailserver-einrichten).

> Prüfen Sie MX- und SPF-Record mit MXToolbox oder direkt per Kommandozeile (nach DNS-Propagation, kann bis zu 48 Stunden dauern):
>
> ```bash
> dig MX {{domain}} +short
> # Erwartete Ausgabe: 10 mail.{{domain}}.
>
> dig TXT {{domain}} +short
> # Erwartete Ausgabe (unter anderem): "v=spf1 mx -all"
> ```

## Schritt 5: Container starten

Starten Sie den Mailserver-Container im Hintergrund:

```bash
$ cd /opt/mailserver
$ docker compose up -d
```

Beim ersten Start lädt ClamAV seine Signaturdatenbank (ca. 850 MB), alle Dienste initialisieren sich. Beobachten Sie den Start mit:

```bash
$ docker compose logs -f mailserver
```

Dovecot startet erst, wenn mindestens ein Konto existiert. Ohne Konto meldet das Log `You need at least one mail account to start Dovecot`, und nach 120 Sekunden fährt der Container laut Log herunter. Legen Sie deshalb direkt nach dem Start das erste Konto an (erster Befehl in Schritt 6). Im Test war der Container danach nach rund 15 Sekunden healthy.

Warten Sie, bis Postfix, Dovecot und (sofern aktiviert) ClamAV und Rspamd vollständig gestartet sind. Abbruch mit `Strg+C`.

> **Prüfen:** ```bash
> docker compose ps
> # Erwartete Ausgabe (nach dem ersten Konto aus Schritt 6):
> # NAME        IMAGE                                        STATUS
> # mailserver  ghcr.io/docker-mailserver/docker-mailserver  Up (healthy)
>
> # Prüfen, ob der SMTP-Port lauscht:
> ss -lntp | grep :25
> # Erwartete Ausgabe: LISTEN 0 ... *:25 ...
> ```

## Schritt 6: E-Mail-Konto anlegen und DKIM einrichten

Ohne Konto startet Dovecot nicht, und der Container fährt laut Log nach 120 Sekunden herunter (siehe Schritt 5). Legen Sie daher sofort mindestens ein Konto an.

**E-Mail-Konto anlegen:**

```bash
$ docker exec -it mailserver setup email add {{mail_user}}@{{domain}} {{mail_pass}}
```

**Alias für Postmaster anlegen** (empfohlen, viele Server verlangen diesen):

```bash
$ docker exec -it mailserver setup alias add postmaster@{{domain}} {{mail_user}}@{{domain}}
```

**DKIM-Schlüsselpaar generieren:**

```bash
$ docker exec -it mailserver setup config dkim
```

Der generierte öffentliche Schlüssel liegt anschließend unter:

```bash
$ cat /opt/mailserver/docker-data/dms/config/opendkim/keys/{{domain}}/mail.txt
```

Den kompletten Inhalt dieser Datei tragen Sie als DNS-TXT-Record unter `mail._domainkey.{{domain}}` ein (siehe Schritt 4, Tabelle). Beachten Sie: DNS-Propagation kann bis zu 48 Stunden dauern; DKIM-Validierung funktioniert erst danach zuverlässig. Details zur DKIM-Konfiguration mit Postfix finden Sie in der Anleitung [OpenDKIM mit Postfix einrichten](https://s-edv.com/anleitungen/opendkim-postfix-dkim-signatur-einrichten).

> **Prüfen:** ```bash
> # Kontenliste prüfen:
> docker exec -it mailserver setup email list
> # Erwartete Ausgabe: {{mail_user}}@{{domain}}
>
> # DKIM-Key-Datei vorhanden:
> ls /opt/mailserver/docker-data/dms/config/opendkim/keys/{{domain}}/
> # Erwartete Ausgabe: mail.private  mail.txt
> ```

## Schritt 7: Mailkonfiguration testen

Nach der DNS-Propagation (MX, SPF, DKIM, PTR) senden Sie eine Testmail an die Einmal-Adresse von **mail-tester.com**. Ein Score ab 8/10 zeigt eine korrekte Konfiguration; MXToolbox.com prüft ergänzend alle DNS-Records.

Verbinden Sie sich probeweise mit einem IMAP-Client (z. B. Thunderbird) mit diesen Einstellungen:

| Einstellung | Wert |
| --- | --- |
| IMAP-Server | `mail.{{domain}}`, Port 993, SSL/TLS |
| SMTP-Server | `mail.{{domain}}`, Port 587, STARTTLS |
| Benutzername | vollständige E-Mail-Adresse (`{{mail_user}}@{{domain}}`) |
| Passwort | wie in Schritt 6 gesetzt |

> **Prüfen:** ```bash
> # IMAPS-Port von außen erreichbar:
> curl -v imaps://mail.{{domain}} --ssl-reqd -u {{mail_user}}@{{domain}}:{{mail_pass}} 2>&1 | head -20
> # Erwartete Ausgabe: Verbindungsaufbau, TLS-Handshake, Zertifikatsdaten
>
> # SMTP-Submission prüfen:
> curl -v smtp://mail.{{domain}}:587 2>&1 | head -10
> # Erwartete Ausgabe: 220 mail.{{domain}} ESMTP Postfix
> ```

## Schritt 8: Updates durchführen

Updates schließen Sicherheitslücken in Postfix und den übrigen Diensten. Tragen Sie vorher die neue Versionsnummer beim `image` in der `compose.yaml` ein und lesen Sie die Release Notes, bei Hauptversionen (etwa 16 auf 17) auch die Hinweise zu geänderten Einstellungen:

```bash
$ cd /opt/mailserver
$ docker compose pull
$ docker compose up -d
```

```bash
# Alte Images aufräumen:
docker image prune -f
```

Für automatische Update-Benachrichtigungen können Sie [Diun oder WUD](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud) nutzen. Diese informieren Sie, wenn ein neues Image verfügbar ist, ohne automatisch zu deployen.

**Update von 16.0.1 auf 17.0.0:** Die Hauptversion ersetzt laut Release Notes das interne Redis für Rspamd durch Valkey. Den Zustand aus v16 (Redis 8) kann Valkey nicht laden: Nach dem Update meldete das Log im Test `Redis state '/var/mail-state/lib-redis' uses RDB format 'REDIS0012' which Valkey cannot load`, Valkey startet leer, und Rspamd muss Daten wie Bayes neu lernen. Die alten Daten bleiben unter `mail-state/lib-redis` liegen. Haben Sie `ENABLE_RSPAMD_REDIS` gesetzt, benennen Sie die Variable in `ENABLE_RSPAMD_VALKEY` um. Außerdem entfällt laut Release Notes das Xapian-Plugin für die Volltextsuche, die Variablen `LDAP_QUERY_FILTER_*` heißen jetzt `POSTFIX_*_QUERY_FILTER`, und Rspamd ist fest auf Version 4.1.5 gesetzt (im Test unter 16.0.1 noch 4.2.3). Mit compose.yaml und mailserver.env dieser Anleitung (im Test mit SSL_TYPE=self-signed) war der Container nach dem Tag-Wechsel nach rund 15 Sekunden healthy. Konto, Alias und vorhandene Mails blieben erhalten, die IMAP-Anmeldung funktionierte, ein falsches Passwort wurde abgelehnt, und eine über Port 587 versendete Mail kam mit DKIM-Signatur an. Ein bei gestopptem Container gesicherter Ordner docker-data/dms brachte nach einem Totalverlust Konto, Mails und DKIM-Schlüssel zurück; tar meldet beim Sichern nur übersprungene Sockets.

> **Prüfen:** ```bash
> docker compose ps
> # STATUS-Spalte: Up (healthy)
> docker compose logs --tail=20 mailserver
> # Keine Fehler zu Image/Port/Volume
> ```

## Troubleshooting / Typische Fehler

**Port 25 nicht erreichbar**

Viele Cloud-Anbieter (Hetzner, AWS, DigitalOcean) blockieren Port 25 standardmäßig. Lösung: Entsperrung beim Support beantragen oder einen SMTP-Relay-Dienst (Mailgun, SendGrid) als Ausgangsgateway konfigurieren.

**Falscher Hostname / Mails werden abgelehnt**

Der `hostname`-Wert in `compose.yaml` weicht vom MX-Record ab. Prüfen Sie mit `docker exec mailserver hostname`. Der Wert muss exakt `mail.{{domain}}` lauten.

**ClamAV-Prozess stirbt nach dem Start**

Zu wenig RAM. Setzen Sie `ENABLE_CLAMAV=0` bei weniger als 1,5 GB freiem Arbeitsspeicher.

**Fail2Ban: „Operation not permitted“ im Log**

`cap_add: - NET_ADMIN` fehlt in der `compose.yaml`; Fail2Ban braucht die Capability für iptables-Regeln.

**SSL_TYPE=letsencrypt, Zertifikat nicht gefunden**

Nur `/etc/letsencrypt/live/` gemountet, aber Let's-Encrypt-Zertifikate sind Symlinks auf `/etc/letsencrypt/archive/`. Immer den gesamten `/etc/letsencrypt`-Ordner mounten.

**Fehler „do not list domain in BOTH mydestination and virtual_mailbox_domains“**

Ein Alias oder Account hat denselben Wert wie der Hostname. Passen Sie `$myhostname` in einer `postfix-main.cf`-Override-Datei an.

**DKIM schlägt fehl / Score niedrig**

Der DNS-TXT-Record für `mail._domainkey.{{domain}}` fehlt oder ist noch nicht propagiert. DNS-Propagation kann bis zu 48 Stunden dauern.

**Kein PTR-Record / Mails landen im Spam**

Reverse-DNS-Eintrag fehlt. Beim Hoster beantragen, dass die Server-IP auf `mail.{{domain}}` zeigt.

**Open Relay**

`PERMIT_DOCKER` wurde auf `host` oder `network` gesetzt ohne konkreten Bedarf. Standard `none` beibehalten. Jeder andere Wert öffnet potentiell ein Open Relay.

## Häufige Fragen

### Brauche ich eine externe Datenbank (MySQL/PostgreSQL)?

Nein. Konten, Aliasse, DKIM-Schlüssel und Postfix-Overrides liegen als Textdateien im Config-Volume (`/tmp/docker-mailserver/`). Für das Backup genügt der Ordner `./docker-data/dms/`.

### Wie lege ich weitere E-Mail-Konten und Aliasse an?

Jederzeit per `docker exec`, ohne Neustart: `docker exec -it mailserver setup email add weitere@{{domain}} PASSWORT`. Aliasse analog: `docker exec -it mailserver setup alias add info@{{domain}} {{mail_user}}@{{domain}}`.

### Rspamd oder SpamAssassin: welchen Spam-Filter wählen?

Für neue Installationen **Rspamd** (`ENABLE_RSPAMD=1`): moderner, ressourceneffizienter und in neuen Setups Standard. SpamAssassin ist für Migrationen von Bestandsinstallationen gedacht. Beide gleichzeitig zu aktivieren ist nicht vorgesehen.

### Kann ich den Server ohne Let's Encrypt testen?

Ja, mit `SSL_TYPE=self-signed` in der `mailserver.env` legen Sie unter ./docker-data/dms/config/ssl/ eine eigene Test-CA und ein damit signiertes Zertifikat für den Hostnamen ab: mail.example.com-key.pem, mail.example.com-cert.pem und demoCA/cacert.pem (der Dateiname beginnt mit dem hostname aus der compose.yaml). docker-mailserver erzeugt diese Dateien nicht selbst; fehlen sie, bricht der Start mit der Meldung TLS Setup [SSL_TYPE=self-signed] | Missing expected file(s) ab, und der Container startet wegen restart: always immer wieder neu. Im Produktionsbetrieb ist `SSL_TYPE=letsencrypt` Pflicht, da andere Mailserver Verbindungen ohne gültiges Zertifikat ablehnen oder als unsicher einstufen.

### Wie überprüfe ich die Gesamtkonfiguration meines Mailservers?

Das einfachste Werkzeug ist **mail-tester.com**: Senden Sie eine Testmail an die angezeigte Adresse und prüfen Sie den Score: 8/10 oder besser ist das Ziel. Für DNS-Records nutzen Sie **MXToolbox.com** (MX, SPF, DKIM, DMARC, Blacklists). Für SPF- und DMARC-Auswertung empfiehlt sich zusätzlich [DMARC-Reports regelmäßig auszuwerten](https://s-edv.com/anleitungen/dmarc-reports-auswerten-p-none-zu-reject) und schrittweise von `p=none` auf `p=reject` zu wechseln.

### Wie läuft das Backup ab?

Sichern Sie regelmäßig den gesamten Ordner `/opt/mailserver/docker-data/dms/`. Er enthält Postfächer, Konfiguration, DKIM-Schlüssel und Logs. Da keine externe Datenbank existiert, genügt ein einfaches Dateisystem-Backup (z. B. mit restic). Eine strukturierte Backup-Strategie finden Sie in der Anleitung [3-2-1-Backup-Strategie umsetzen](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen).

## Fazit

docker-mailserver bietet einen vollständigen Mailserver in einem Container, ohne externe Datenbank und mit dateibasierter Konfiguration; Betrieb und Backup bleiben überschaubar. Voraussetzung ist DNS-Disziplin: Stimmen PTR, SPF, DKIM und DMARC nicht, landen Mails im Spam oder werden abgewiesen. Für größere Teams mit Web-Oberfläche bietet der [Mailcow-Stack](https://s-edv.com/anleitungen/mailcow-mailserver-docker-aufsetzen) ein Admin-Panel, ist aber deutlich komplexer.

## Weiterführende Anleitungen und Quellen

1. [OpenDKIM mit Postfix einrichten: DKIM-Signatur korrekt konfigurieren](https://s-edv.com/anleitungen/opendkim-postfix-dkim-signatur-einrichten)
2. [Reverse DNS (PTR) und IPv6 für Mailserver korrekt einrichten](https://s-edv.com/anleitungen/reverse-dns-ptr-ipv6-mailserver-einrichten)
3. [DMARC-Reports verstehen und auswerten: von p=none sicher zu p=reject](https://s-edv.com/anleitungen/dmarc-reports-auswerten-p-none-zu-reject)
4. [Mailcow komplett aufsetzen: eigener Mailserver mit Docker](https://s-edv.com/anleitungen/mailcow-mailserver-docker-aufsetzen)
5. [Let's Encrypt mit certbot: TLS-Zertifikate ohne Reverse-Proxy](https://s-edv.com/anleitungen/lets-encrypt-certbot-tls-zertifikate)
6. [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian)](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
7. [VPS absichern und härten: Anleitung mit UFW, SSH-Keys und Fail2Ban](https://s-edv.com/anleitungen/vps-absichern-haerten-ufw-ssh-keys-fail2ban)
8. [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)
9. [Linux-Server absichern: UFW-Firewall und Fail2ban](https://s-edv.com/anleitungen/linux-server-absichern-ufw-fail2ban)

**Quellen:** Docker Mailserver, offizielle Dokumentation (latest): [docker-mailserver.github.io](https://docker-mailserver.github.io/docker-mailserver/latest/) | GitHub Repository v17.0.0: [github.com/docker-mailserver](https://github.com/docker-mailserver/docker-mailserver)

## Passende Anleitungen auf S-EDV

1. [netcup Local Block Storage bestellen, einrichten und unter Linux einbinden](https://s-edv.com/anleitungen/netcup-local-block-storage-bestellen-linux-einbinden)
2. [Linux-Fileserver im Active Directory: Samba als Domain Member mit NTFS-ähnlichen](https://s-edv.com/anleitungen/samba-fileserver-active-directory-domain-member)
