# Rocky Linux Mailserver einrichten: Postfix, Dovecot und Roundcube unter Rocky Linux 9

Mit einem eigenen Rocky Linux Mailserver können Sie E-Mails unter Ihrer eigenen Domain senden, empfangen und verwalten. Dabei übernimmt Postfix den Versand und Empfang per SMTP, Dovecot stellt die Postfächer über IMAP bereit und Roundcube dient als Webmail-Oberfläche im Browser. Damit entsteht ein vollständiger Mailserver.

## Anforderungen für einen Rocky Linux Mailserver

Bevor Sie Rocky Linux, Postfix, Dovecot und Roundcube installieren und einen [eigenen Mailserver betreiben](https://www.ionos.at/digitalguide/e-mail/e-mail-technik/eigenen-mailserver-betreiben/), benötigen Sie einen Server, der aus dem Internet **dauerhaft erreichbar** ist. Für wenige Mailkonten reichen in der Regel ein bis zwei CPU-Kerne, etwa 2 GB Arbeitsspeicher und ausreichend [SSD](https://www.ionos.at/digitalguide/server/knowhow/was-ist-ssd/)-Speicher für Betriebssystem, Anwendungen und Postfächer aus. Entscheidend sind jedoch weniger die Hardware-Ressourcen als eine korrekt eingerichtete [Domain](https://www.ionos.at/digitalguide/domains/domaintipps/was-ist-eine-domain/) und eine feste öffentliche [IP-Adresse](https://www.ionos.at/digitalguide/server/knowhow/was-ist-eine-ip-adresse/).

Für diese Anleitung benötigen Sie:

- einen Server mit [Rocky Linux](https://www.ionos.at/digitalguide/server/konfiguration/rocky-linux/) 9.x
- Root-Rechte oder einen User mit sudo-Berechtigung
- eine eigene Domain
- einen Hostnamen für den Mailserver
- eine feste öffentliche IPv4-Adresse
- Zugriff auf die [DNS](https://www.ionos.at/digitalguide/server/knowhow/domain-name-system/)-Einstellungen Ihrer Domain
- die Möglichkeit, beim Serveranbieter einen [PTR](https://www.ionos.at/digitalguide/hosting/hosting-technik/ptr-record/)- beziehungsweise [Reverse-DNS](https://www.ionos.at/digitalguide/server/knowhow/reverse-dns/)-Eintrag festzulegen
- einen Serveranbieter, der ein- und ausgehende Verbindungen über [TCP](https://www.ionos.at/digitalguide/server/knowhow/tcp-vorgestellt/)-Port 25 erlaubt

Prüfen Sie insbesondere den letzten Punkt vor der Installation. Einige Hosting- und Cloud-Anbieter **sperren ausgehenden SMTP-Verkehr über Port 25 standardmäßig**, um Spam zu verhindern. Ohne diesen Port kann Postfix Nachrichten nicht unmittelbar an andere Mailserver im Internet zustellen. In diesem Fall benötigen Sie entweder eine Freischaltung durch den Anbieter oder einen externen [SMTP-Relay](https://www.ionos.at/digitalguide/e-mail/e-mail-technik/smtp-relay/).

Die Anleitung verwendet folgende Beispieldaten:

<table>
  <thead>
    <tr>
      <th><strong>Einstellung</strong></th>
      <th><strong>Beispiel</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Domain</td>
      <td>`example.com`</td>
    </tr>
    <tr>
      <td>Mailserver</td>
      <td>`mail.example.com`</td>
    </tr>
    <tr>
      <td>Öffentliche IPv4-Adresse</td>
      <td>`203.0.113.10`</td>
    </tr>
    <tr>
      <td>Beispieluser</td>
      <td>`alice`</td>
    </tr>
    <tr>
      <td>E-Mail-Adresse</td>
      <td>`alice@example.com`</td>
    </tr>
  </tbody>
</table>

Ersetzen Sie diese Werte an allen Stellen durch Ihre eigenen Angaben.

## Schritt 1: Rocky Linux aktualisieren und Hostnamen festlegen

Melden Sie sich zunächst per [SSH](https://www.ionos.at/digitalguide/server/tools/secure-shell-ssh/) auf Ihrem Server an und aktualisieren Sie die vorhandenen Pakete:

```bash
sudo dnf upgrade -y
```

Hinweis Da Rocky Linux jeweils **nur die neueste Minor-Version unterstützt**, sollten Sie Ihr System vor der weiteren Einrichtung vollständig aktualisieren. Ältere Minor-Versionen erhalten nach Erscheinen ihres Nachfolgers keine weiteren Sicherheits- und Fehlerkorrekturen.

Falls dabei Kernel- oder zentrale Systempakete aktualisiert wurden, starten Sie den Server anschließend neu:

```bash
sudo reboot
```

Melden Sie sich danach erneut an. Als Nächstes erhält der Server seinen vollständig qualifizierten Domainnamen, den sogenannten [Fully Qualified Domain Name beziehungsweise FQDN](https://www.ionos.at/digitalguide/domains/domainverwaltung/fqdn-fully-qualified-domain-name/). In diesem Beispiel lautet er mail.example.com:

```bash
sudo hostnamectl set-hostname mail.example.com
```

Kontrollieren Sie das Ergebnis mit:

```bash
hostname
```

Der Hostname ist bei Mailservern **besonders wichtig**. Andere Mailserver verwenden ihn unter anderem zur Identifikation Ihres Systems und vergleichen ihn mit den öffentlichen DNS- und Reverse-DNS-Einträgen.

## Schritt 2: DNS-Einträge für den Mailserver erstellen

Noch bevor Sie Postfix produktiv verwenden, sollten Sie die **wichtigsten DNS-Einträge** bei Ihrem Domainanbieter anlegen:

<table>
  <thead>
    <tr>
      <th><strong>Typ</strong></th>
      <th><strong>Name</strong></th>
      <th><strong>Wert</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>A</td>
      <td>mail</td>
      <td>203.0.113.10</td>
    </tr>
    <tr>
      <td>MX</td>
      <td>@</td>
      <td>mail.example.com mit Priorität 10</td>
    </tr>
    <tr>
      <td>TXT</td>
      <td>@</td>
      <td>v=spf1 mx -all</td>
    </tr>
  </tbody>
</table>

Der [A-Record](https://www.ionos.at/digitalguide/hosting/hosting-technik/a-record/) verbindet mail.example.com mit der öffentlichen IPv4-Adresse des Servers. Der [MX-Record](https://www.ionos.at/digitalguide/e-mail/e-mail-technik/mx-record/) legt fest, dass E-Mails für example.com an diesen Server zugestellt werden sollen. Mit dem [SPF-Eintrag](https://www.ionos.at/digitalguide/e-mail/e-mail-sicherheit/was-ist-ein-spf-record/) teilen Sie anderen Mailservern mit, dass die im MX-Record hinterlegten Server E-Mails für Ihre Domain versenden dürfen.

Zusätzlich benötigen Sie einen PTR-Record, auch Reverse-DNS-Eintrag genannt: `203.0.113.10 -> mail.example.com`. Diesen Eintrag können Sie normalerweise **nicht beim Domainanbieter konfigurieren**. Er wird vom Anbieter verwaltet, dem die öffentliche IP-Adresse gehört, also in der Regel von Ihrem Server- oder Cloudanbieter.

Forward- und Reverse-DNS müssen zueinander passen: mail.example.com sollte auf die Server-IP zeigen und die Server-IP wiederum auf mail.example.com.

### DMARC bereits vorbereiten

Zusätzlich empfiehlt es sich, einen ersten [DMARC-Eintrag](https://www.ionos.at/digitalguide/e-mail/e-mail-sicherheit/dmarc-erklaert/) anzulegen. Zum Einstieg können Sie eine reine Monitoring-Richtlinie verwenden:

```none
v=DMARC1; p=none
```

Der [TXT-Eintrag](https://www.ionos.at/digitalguide/hosting/hosting-technik/txt-record/) wird für folgenden Namen erstellt:

```none
_dmarc.example.com
```

Mit `p=none` werden Nachrichten bei einem DMARC-Fehler zunächst **nicht automatisch zurückgewiesen**. Für einen produktiven Mailserver sollten Sie später außerdem [DKIM](https://www.ionos.at/digitalguide/e-mail/e-mail-sicherheit/dkim-domainkeys/) einrichten und die DMARC-Richtlinie nach erfolgreicher Prüfung beispielsweise auf `quarantine` oder `reject` verschärfen.

Hinweis Ein technisch funktionierender SMTP-Server garantiert noch keine gute Zustellbarkeit. SPF, DKIM, DMARC, korrektes Reverse-DNS, TLS sowie die Reputation der verwendeten IP-Adresse spielen bei modernen Mailprovidern eine entscheidende Rolle. Falls Ihr Server über IPv6 verfügt, sollten Sie nur dann einen AAAA-Eintrag veröffentlichen, wenn IPv6 tatsächlich vollständig konfiguriert ist und auch für die öffentliche Mailzustellung verwendet werden kann.

## Schritt 3: Postfix, Dovecot, Nginx und PHP installieren

Installieren Sie zunächst die benötigten Serverkomponenten:

```bash
sudo dnf install -y \
    postfix \
    dovecot \
    nginx \
    firewalld \
    nano \
    tar \
    unzip \
    curl \
    sqlite \
    policycoreutils-python-utils
```

Für Roundcube benötigen Sie außerdem [PHP](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-php/):

```bash
sudo dnf module install -y php:8.3
```

Hinweis Rocky Linux 9 bietet PHP 8.3 als aktuellsten PHP-Modul-Stream in den offiziellen AppStream-Paketquellen an. Neuere PHP-Versionen wie PHP 8.5 sind zwar verfügbar, müssen unter Rocky Linux 9 jedoch über ein zusätzliches Drittanbieter-Repository wie Remi installiert werden. Für diese Anleitung verwenden Sie deshalb PHP 8.3.

Ergänzen Sie anschließend die für Roundcube benötigten PHP-Erweiterungen:

```bash
sudo dnf install -y \
    php-fpm \
    php-mbstring \
    php-xml \
    php-intl \
    php-pdo \
    php-gd \
    php-opcache \
    php-pecl-zip
```

Prüfen Sie die installierte PHP-Version:

```bash
php -v
```

Starten und aktivieren Sie anschließend [Firewall](https://www.ionos.at/digitalguide/server/sicherheit/was-ist-eine-firewall/), [Nginx](https://www.ionos.at/digitalguide/server/konfiguration/nginx-grundlagen-installation-und-einrichtung/) und PHP-FPM:

```bash
sudo systemctl enable --now firewalld
sudo systemctl enable --now nginx
sudo systemctl enable --now php-fpm
```

## Schritt 4: Benötigte Firewall-Ports freigeben

Ein Mailserver verwendet **mehrere unterschiedliche Netzwerkprotokolle**. Öffnen Sie zunächst die Ports, die für dieses Setup benötigt werden:

```bash
sudo firewall-cmd --permanent --add-service=smtp
sudo firewall-cmd --permanent --add-port=587/tcp
sudo firewall-cmd --permanent --add-service=imaps
sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --reload
```

Damit sind folgende Dienste erreichbar:

<table>
  <thead>
    <tr>
      <th><strong>Port</strong></th>
      <th><strong>Protokoll</strong></th>
      <th><strong>Aufgabe</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>25</td>
      <td>SMTP</td>
      <td>Mailaustausch zwischen Mailservern</td>
    </tr>
    <tr>
      <td>587</td>
      <td>Submission</td>
      <td>Versand durch angemeldete User</td>
    </tr>
    <tr>
      <td>993</td>
      <td>IMAPS</td>
      <td>verschlüsselter Zugriff auf Postfächer</td>
    </tr>
    <tr>
      <td>80</td>
      <td>HTTP</td>
      <td>unter anderem für die Zertifikatsausstellung</td>
    </tr>
    <tr>
      <td>443</td>
      <td>HTTPS</td>
      <td>Roundcube-Webmail</td>
    </tr>
  </tbody>
</table>

## Schritt 5: TLS-Zertifikat mit Let’s Encrypt einrichten

Mail-Passwörter und Nachrichten sollten **niemals unverschlüsselt** über das öffentliche Internet übertragen werden. Deshalb benötigen Postfix, Dovecot und Roundcube ein vertrauenswürdiges TLS-Zertifikat. Unter Rocky Linux 9 können Sie Certbot über das EPEL-Repository installieren. Installieren Sie zunächst EPEL:

```bash
sudo dnf install -y epel-release
```

Danach installieren Sie Certbot:

```bash
sudo dnf install -y certbot
```

Stellen Sie sicher, dass mail.example.com bereits per DNS auf die öffentliche IP-Adresse Ihres Servers zeigt und Port 80 erreichbar ist. Da die Nginx-Konfiguration für Roundcube erst später eingerichtet wird, verwenden Sie Certbot zunächst im **Standalone-Modus**. Dabei startet Certbot vorübergehend einen eigenen Webserver auf Port 80. Stoppen Sie deshalb zunächst Nginx:

```bash
sudo systemctl stop nginx
```

Fordern Sie anschließend das Zertifikat an:

```bash
sudo certbot certonly --standalone -d mail.example.com
```

Starten Sie Nginx nach erfolgreicher Ausstellung wieder:

```bash
sudo systemctl start nginx
```

Nach erfolgreicher Ausstellung liegen Zertifikat und privater Schlüssel unter `/etc/letsencrypt/live/mail.example.com/`.

Certbot fragt unter anderem nach einer E-Mail-Adresse und Ihrer Zustimmung zu den Nutzungsbedingungen. Nach erfolgreicher Ausstellung liegen Zertifikat und privater Schlüssel unterhalb von `/etc/letsencrypt/live/mail.example.com/`.

Nginx kann diese Dateien direkt verwenden. Für Postfix und Dovecot ist es unter Rocky Linux mit aktiviertem SELinux robuster, **Kopien** an den für die jeweiligen Dienste vorgesehenen Stellen abzulegen.

Erstellen Sie zunächst die Verzeichnisse für Dovecot:

```bash
sudo mkdir -p /etc/pki/dovecot/certs
sudo mkdir -p /etc/pki/dovecot/private
```

Kopieren Sie Zertifikat und Schlüssel für Postfix:

```bash
sudo install -m 0644 \
    /etc/letsencrypt/live/mail.example.com/fullchain.pem \
    /etc/pki/tls/certs/mailserver-fullchain.pem
sudo install -m 0600 \
    /etc/letsencrypt/live/mail.example.com/privkey.pem \
    /etc/pki/tls/private/mailserver.key
```

Kopieren Sie die Dateien anschließend für Dovecot:

```bash
sudo install -m 0644 \
    /etc/letsencrypt/live/mail.example.com/fullchain.pem \
    /etc/pki/dovecot/certs/mailserver-fullchain.pem
sudo install -m 0600 \
    /etc/letsencrypt/live/mail.example.com/privkey.pem \
    /etc/pki/dovecot/private/mailserver.key
```

Stellen Sie anschließend die vorgesehenen SELinux-Kontexte wieder her:

```bash
sudo restorecon -Rv /etc/pki/tls
sudo restorecon -Rv /etc/pki/dovecot
```

### Zertifikat automatisch erneuern

Das Certbot-Paket aus EPEL enthält einen systemd-Timer für automatische Verlängerungen. Aktivieren Sie ihn:

```bash
sudo systemctl enable --now certbot-renew.timer
```

Da Certbot für die Erneuerung ebenfalls den Standalone-Modus verwendet, muss Port 80 vorübergehend frei sein. Erstellen Sie deshalb einen Pre-Hook zum Stoppen und einen Post-Hook zum erneuten Starten von Nginx:

```bash
sudo mkdir -p /etc/letsencrypt/renewal-hooks/pre
sudo mkdir -p /etc/letsencrypt/renewal-hooks/post
```

Erstellen Sie außerdem ein Stopp-Skript mit `sudo nano /etc/letsencrypt/renewal-hooks/pre/stop-nginx.sh` und folgendem Inhalt:

```none
#!/bin/bash
systemctl stop nginx
```

Erstellen Sie das äquivalente Start-Skript mit `sudo nano /etc/letsencrypt/renewal-hooks/post/start-nginx.sh` und als Inhalt:

```none
#!/bin/bash
systemctl start nginx
```

Machen Sie beide Dateien ausführbar:

```bash
sudo chmod 700 /etc/letsencrypt/renewal-hooks/pre/stop-nginx.sh
sudo chmod 700 /etc/letsencrypt/renewal-hooks/post/start-nginx.sh
```

Da Postfix und Dovecot mit Kopien des Zertifikats arbeiten, müssen diese nach einer Verlängerung ebenfalls aktualisiert werden. Erstellen Sie hierfür:

```bash
sudo nano /etc/letsencrypt/renewal-hooks/deploy/mailserver-certs.sh
```

Fügen Sie Folgendes ein:

```none
#!/bin/bash
set -e
install -m 0644 "$RENEWED_LINEAGE/fullchain.pem" \
    /etc/pki/tls/certs/mailserver-fullchain.pem
install -m 0600 "$RENEWED_LINEAGE/privkey.pem" \
    /etc/pki/tls/private/mailserver.key
install -m 0644 "$RENEWED_LINEAGE/fullchain.pem" \
    /etc/pki/dovecot/certs/mailserver-fullchain.pem
install -m 0600 "$RENEWED_LINEAGE/privkey.pem" \
    /etc/pki/dovecot/private/mailserver.key
restorecon -R /etc/pki/tls /etc/pki/dovecot
systemctl reload postfix || true
systemctl reload dovecot || true
systemctl reload nginx || true
```

Speichern Sie die Datei und machen Sie sie ausführbar:

```bash
sudo chmod 700 /etc/letsencrypt/renewal-hooks/deploy/mailserver-certs.sh
```

Die grundsätzliche Zertifikatserneuerung können Sie anschließend testen:

```bash
sudo certbot renew --dry-run
```

## Schritt 6: Dovecot für IMAP und Maildir konfigurieren

Dovecot übernimmt in diesem Setup **zwei Aufgaben**: Es stellt die Postfächer per IMAP bereit und übernimmt die Authentifizierung der Benutzer für Postfix. Außerdem lassen wir Postfix eingehende Nachrichten per LMTP an Dovecot übergeben.

Dovecot verwendet unter Rocky Linux 9 standardmäßig NSS für die Benutzerdaten und PAM für die Authentifizierung. Somit können Sie für eine einfache Installation zunächst normale lokale Linux-Benutzer als Mailkonten verwenden.

### Nur IMAP und LMTP aktivieren

Öffnen Sie zunächst:

```bash
sudo nano /etc/dovecot/dovecot.conf
```

Setzen Sie beziehungsweise ergänzen Sie:

```none
protocols = imap lmtp
```

Damit deaktivieren Sie das nicht benötigte POP3 und aktivieren neben IMAP auch LMTP.

### Maildir als Postfachformat verwenden

Öffnen Sie die Konfigurationsdatei:

```bash
sudo nano /etc/dovecot/conf.d/10-mail.conf
```

Suchen Sie nach `mail_location` und setzen Sie:

```bash
mail_location = maildir:~/Maildir
```

Damit befindet sich das Postfach des Users `alice` später unter `/home/alice/Maildir`. Maildir speichert jede Nachricht **als separate Datei** und lässt sich für ein einfaches Postfix-Dovecot-Setup gut nachvollziehen.

### Authentifizierung konfigurieren

Öffnen Sie:

```bash
sudo nano /etc/dovecot/conf.d/10-auth.conf
```

Stellen Sie sicher, dass folgende Werte gesetzt sind:

```none
disable_plaintext_auth = yes
auth_mechanisms = plain login
```

`PLAIN` und `LOGIN` übertragen die Zugangsdaten **nicht selbst verschlüsselt**. Deshalb dürfen sie ausschließlich innerhalb einer TLS-geschützten Verbindung verwendet werden. Dovecot verhindert in seiner sicheren Standardkonfiguration eine Klartextauthentifizierung über unverschlüsselte Verbindungen.

### TLS für Dovecot einrichten

Öffnen Sie nun die SSL-Konfigurationsdatei:

```bash
sudo nano /etc/dovecot/conf.d/10-ssl.conf
```

Setzen Sie:

```none
ssl = required
ssl_cert = </etc/pki/dovecot/certs/mailserver-fullchain.pem
ssl_key = </etc/pki/dovecot/private/mailserver.key
```

Beachten Sie das `<` unmittelbar vor den Dateipfaden.

### Dovecot-Authentifizierung für Postfix freigeben

Auch die Konfigurationsdatei für Dovecot sollten Sie anpassen:

```bash
sudo nano /etc/dovecot/conf.d/10-master.conf
```

Suchen Sie den vorhandenen Block:

```none
service auth {
```

und ergänzen Sie **innerhalb dieses Blocks** folgenden Listener:

```none
unix_listener /var/spool/postfix/private/auth {
    mode = 0660
    user = postfix
    group = postfix
}
```

Postfix kann damit die Dovecot-Authentifizierung über einen lokalen Unix-Socket verwenden. Suchen Sie anschließend im selben Dokument den Abschnitt:

```none
service lmtp {
```

und konfigurieren Sie den lokalen LMTP-Socket:

```none
service lmtp {
    unix_listener lmtp {
        mode = 0600
        user = postfix
        group = postfix
    }
}
```

Dovecot erzeugt damit standardmäßig den Socket `/var/run/dovecot/lmtp` und Postfix kann eingehende Nachrichten später über diesen Socket an Dovecot übergeben.

Prüfen Sie abschließend die Dovecot-Konfiguration:

```bash
sudo doveconf -n
```

Wenn keine Fehlermeldung erscheint, können Sie Dovecot starten:

```bash
sudo systemctl enable --now dovecot
```

## Schritt 7: Postfix konfigurieren

Postfix ist der **eigentliche SMTP-Server**. Er nimmt Nachrichten anderer Mailserver auf Port 25 entgegen und ermöglicht angemeldeten Usern den Versand über Port 587. Rocky Linux beziehungsweise RHEL konfiguriert Postfix zunächst so, dass der Dienst **nur auf dem lokalen System** erreichbar ist. Für einen öffentlichen Mailserver muss `inet_interfaces` deshalb auf `all` gesetzt werden.

Die wichtigsten Einstellungen lassen sich mit `postconf` setzen. Führen Sie folgende Befehle aus:

```bash
sudo postconf -e "myhostname = mail.example.com"
sudo postconf -e "mydomain = example.com"
sudo postconf -e 'myorigin = $mydomain'
sudo postconf -e "inet_interfaces = all"
sudo postconf -e "inet_protocols = ipv4"
```

Diese Anleitung beschränkt Postfix zunächst auf IPv4. Wenn Ihr Server auch über vollständig eingerichtetes IPv6 samt AAAA- und PTR-Record verfügt, können Sie stattdessen `inet_protocols = all` verwenden.

Legen Sie anschließend fest, für welche Domain der Server selbst zuständig ist:

```bash
sudo postconf -e 'mydestination = $myhostname, localhost.$mydomain, localhost, $mydomain'
```

Beschränken Sie das ohne Anmeldung vertrauenswürdige Netzwerk auf den Server selbst:

```bash
sudo postconf -e "mynetworks = 127.0.0.0/8"
```

Tipp Tragen Sie hier nicht pauschal öffentliche oder große private Netzbereiche ein. Systeme innerhalb von `mynetworks` dürfen Nachrichten ohne SMTP-Authentifizierung weiterleiten. Eine zu großzügige Einstellung kann Ihren Server deshalb zum offenen Mail-Relay machen.

### Lokale Zustellung an Dovecot übergeben

Konfigurieren Sie Postfix so, dass Nachrichten für lokale User über LMTP an Dovecot weitergegeben werden:

```bash
sudo postconf -e "mailbox_transport = lmtp:unix:/var/run/dovecot/lmtp"
```

### SMTP-Authentifizierung mit Dovecot aktivieren

Aktivieren Sie anschließend SASL und legen Sie Dovecot als Authentifizierungsdienst fest:

```bash
sudo postconf -e "smtpd_sasl_auth_enable = yes"
sudo postconf -e "smtpd_sasl_type = dovecot"
sudo postconf -e "smtpd_sasl_path = private/auth"
sudo postconf -e "broken_sasl_auth_clients = yes"
sudo postconf -e "smtpd_sasl_security_options = noanonymous, noplaintext"
sudo postconf -e "smtpd_sasl_tls_security_options = noanonymous"
sudo postconf -e "smtpd_tls_auth_only = yes"
```

Erlauben Sie die Weiterleitung von Nachrichten ausschließlich für vertrauenswürdige lokale Prozesse und erfolgreich authentifizierte User:

```bash
sudo postconf -e "smtpd_relay_restrictions = permit_mynetworks, permit_sasl_authenticated, defer_unauth_destination"
```

Diese Einschränkung ist wichtig. Ohne eine korrekte Relay-Regel könnte ein falsch konfigurierter Mailserver von Dritten zum Spamversand missbraucht werden.

### TLS für Postfix aktivieren

Binden Sie das zuvor eingerichtete Zertifikat ein:

```bash
sudo postconf -e "smtpd_tls_cert_file = /etc/pki/tls/certs/mailserver-fullchain.pem"
sudo postconf -e "smtpd_tls_key_file = /etc/pki/tls/private/mailserver.key"
sudo postconf -e "smtpd_tls_security_level = may"
sudo postconf -e "smtp_tls_security_level = may"
```

Auf dem öffentlichen SMTP-Port 25 verwenden Sie bewusst `may`. Damit bietet Postfix TLS an, kann aber weiterhin E-Mails von beziehungsweise an ältere Mailserver übertragen, die kein TLS unterstützen.

## Schritt 8: Sicheren Submission-Port 587 aktivieren

Öffnen Sie die Postfix-Master-Konfiguration:

```bash
sudo nano /etc/postfix/master.cf
```

Suchen Sie den normalerweise auskommentierten Abschnitt für `submission`. Aktivieren beziehungsweise ergänzen Sie folgenden Block:

```none
submission inet n             -             n             -             -             smtpd
    -o syslog_name=postfix/submission
    -o smtpd_tls_security_level=encrypt
    -o smtpd_sasl_auth_enable=yes
    -o smtpd_tls_auth_only=yes
    -o smtpd_relay_restrictions=permit_sasl_authenticated,reject
    -o smtpd_recipient_restrictions=permit_sasl_authenticated,reject
```

Achten Sie darauf, dass die Zeilen mit `-o` eingerückt sind. Port 587 ist **für Mailprogramme wie Thunderbird, Outlook oder Roundcube** gedacht. Anders als beim SMTP-Verkehr zwischen Mailservern wird hier eine verschlüsselte Verbindung sowie eine erfolgreiche Benutzeranmeldung verlangt.

Prüfen Sie anschließend die Postfix-Konfiguration:

```bash
sudo postfix check
```

Starten Sie Postfix und aktivieren Sie den automatischen Start:

```bash
sudo systemctl enable --now postfix
```

## Schritt 9: Erstes Mailkonto erstellen

In dieser Einsteigerkonfiguration entsprechen Mailkonten lokalen Linux-Usern. Legen Sie beispielsweise den User `alice` an:

```bash
sudo useradd --create-home --shell /sbin/nologin alice
```

Vergeben Sie anschließend ein [sicheres Passwort](https://www.ionos.at/digitalguide/server/sicherheit/sensible-daten-durch-ein-sicheres-passwort-schuetzen/):

```bash
sudo passwd alice
```

Das Konto besitzt damit die E-Mail-Adresse `alice@example.com`.

`/sbin/nologin` verhindert, dass das Mailkonto gleichzeitig für einen normalen Shell-Login genutzt werden kann.

Legen Sie anschließend die Maildir-Verzeichnisstruktur an:

```bash
sudo -u alice mkdir -p \
    /home/alice/Maildir/cur \
    /home/alice/Maildir/new \
    /home/alice/Maildir/tmp
```

Beschränken Sie die Zugriffsrechte:

```bash
sudo chmod 700 /home/alice/Maildir
```

### Standardadressen einrichten

Öffnen Sie:

```bash
sudo nano /etc/aliases
```

Ergänzen Sie:

```none
root: alice
postmaster: alice
abuse: alice
```

Erstellen Sie anschließend die Alias-Datenbank neu:

```bash
sudo newaliases
```

Nachrichten an `postmaster@example.com` oder `abuse@example.com` landen damit im Postfach von `alice`.

## Schritt 10: Absender eines Users beschränken

Ohne zusätzliche Einschränkung könnte sich ein authentifizierter Benutzer zwar mit seinem eigenen Konto anmelden, im SMTP-Umschlag aber eine **andere Absenderadresse** verwenden. Erstellen Sie deshalb:

```bash
sudo nano /etc/postfix/sender_login_maps
```

Für das Beispielkonto tragen Sie ein:

```none
alice@example.com alice
```

Erzeugen Sie daraus eine Postfix-Lookup-Tabelle:

```bash
sudo postmap /etc/postfix/sender_login_maps
```

Aktivieren Sie sie:

```bash
sudo postconf -e "smtpd_sender_login_maps = hash:/etc/postfix/sender_login_maps"
```

Ergänzen Sie im bereits eingerichteten `submission`-Block in `/etc/postfix/master.cf` außerdem:

```none
-o smtpd_sender_restrictions=reject_authenticated_sender_login_mismatch
```

Für jedes weitere Mailkonto ergänzen Sie später eine weitere Zeile in `sender_login_maps` und führen danach erneut `postmap` aus. Postfix stellt hierfür `smtpd_sender_login_maps` und `reject_authenticated_sender_login_mismatch` bereit. Dadurch kann ein angemeldeter User nur Envelope-Absender verwenden, die seinem SMTP-Login zugeordnet wurden.

Laden Sie Postfix anschließend neu:

```bash
sudo systemctl reload postfix
```

## Schritt 11: Roundcube installieren

Für die Webmail-Oberfläche verwenden Sie die aktuellste Version von Roundcube (aktuell 1.7.4). Vom einfachen `sudo dnf install roundcubemail` ist in diesem Fall abzuraten, da eine veraltete Version installiert wird. Laden Sie deshalb auf Ihrem Computer das Complete-Paket von Roundcube von der [offiziellen Downloadseite](https://roundcube.net/download "Roundcube: Downloadseite") herunter.

Übertragen Sie die Datei anschließend beispielsweise per SCP auf Ihren Server. Verwenden Sie dafür einen Benutzer, der sich per SSH anmelden darf, nicht den zuvor angelegten Mailuser `alice`:

```bash
scp ~/Downloads/roundcubemail-1.7.4-complete.tar.gz <ssh-user>@mail.example.com:/tmp/
```

Ersetzen Sie `<ssh-user>` durch Ihren tatsächlichen SSH-Benutzernamen.

Entpacken Sie die Datei auf dem Server:

```bash
cd /tmp
tar -xzf roundcubemail-1.7.4-complete.tar.gz
sudo mv roundcubemail-1.7.4 /var/www/roundcube
```

## Schritt 12: Roundcube-Datenbank mit SQLite einrichten

Roundcube benötigt eine [Datenbank](https://www.ionos.at/digitalguide/hosting/hosting-technik/datenbanken/) für Einstellungen, Kontakte, Sitzungen und weitere Metadaten. Für einen kleinen Mailserver eignet sich [SQLite](https://www.ionos.at/digitalguide/websites/web-entwicklung/sqlite/), da kein zusätzlicher Datenbankserver notwendig ist. Erstellen Sie das Datenbankverzeichnis:

```bash
sudo install -d -o apache -g apache -m 0770 /var/lib/roundcube
```

Initialisieren Sie anschließend die Datenbank mit dem von Roundcube mitgelieferten Schema:

```bash
sudo -u apache sqlite3 /var/lib/roundcube/roundcube.db \
    < /var/www/roundcube/SQL/sqlite.initial.sql
```

Setzen Sie die Zugriffsrechte:

```bash
sudo chown apache:apache /var/lib/roundcube/roundcube.db
sudo chmod 0660 /var/lib/roundcube/roundcube.db
```

Dass der User `apache` heißt, obwohl Nginx verwendet wird, ist unter Rocky Linux nicht ungewöhnlich: Der standardmäßige PHP-FPM-Pool läuft auch bei der Verwendung mit Nginx als User `apache`.

## Schritt 13: Roundcube konfigurieren

Erstellen Sie einen zufälligen Schlüssel, mit dem Roundcube unter anderem temporär gespeicherte Zugangsdaten schützt:

```bash
openssl rand -base64 18
```

Kopieren Sie die Ausgabe. Erstellen Sie anschließend die Roundcube-Konfiguration:

```bash
sudo nano /var/www/roundcube/config/config.inc.php
```

Fügen Sie folgende Grundkonfiguration ein:

```none
<?php
$config = [];
$config['db_dsnw'] = 'sqlite:////var/lib/roundcube/roundcube.db';
$config['imap_host'] = 'ssl://mail.example.com:993';
$config['smtp_host'] = 'tls://mail.example.com:587';
$config['smtp_user'] = '%u';
$config['smtp_pass'] = '%p';
$config['mail_domain'] = 'example.com';
$config['product_name'] = 'Webmail example.com';
$config['des_key'] = 'HIER-IHREN-24-ZEICHEN-SCHLUESSEL';
$config['plugins'] = [
    'archive',
    'zipdownload',
];
$config['skin'] = 'elastic';
$config['identities_level'] = 3;
$config['enable_installer'] = false;
```

Ersetzen Sie Domain, Hostname und insbesondere `des_key` durch **Ihre eigenen Werte**. Roundcube verwendet `ssl://` für eine implizit verschlüsselte IMAP-Verbindung und `tls://` für [STARTTLS](https://www.ionos.at/digitalguide/e-mail/e-mail-technik/starttls/) beim SMTP-Versand.

Setzen Sie anschließend restriktive Zugriffsrechte auf die Konfiguration:

```bash
sudo chown root:apache /var/www/roundcube/config/config.inc.php
sudo chmod 640 /var/www/roundcube/config/config.inc.php
```

Die Verzeichnisse `temp` und `logs` müssen dagegen vom PHP-FPM-Prozess beschreibbar sein:

```bash
sudo chown -R apache:apache /var/www/roundcube/temp
sudo chown -R apache:apache /var/www/roundcube/logs
```

## Schritt 14: SELinux für Roundcube konfigurieren

[SELinux](https://www.ionos.at/digitalguide/server/sicherheit/was-ist-selinux/) sollte unter Rocky Linux aktiviert bleiben. Damit Nginx und PHP-FPM auf die Roundcube-Dateien zugreifen können, weisen Sie die passenden SELinux-Kontexte zu:

```bash
sudo semanage fcontext -a -t httpd_sys_content_t \
    '/var/www/roundcube(/.*)?'
sudo semanage fcontext -a -t httpd_sys_rw_content_t \
    '/var/www/roundcube/temp(/.*)?'
sudo semanage fcontext -a -t httpd_sys_rw_content_t \
    '/var/www/roundcube/logs(/.*)?'
sudo semanage fcontext -a -t httpd_sys_rw_content_t \
    '/var/lib/roundcube(/.*)?'
```

Wenden Sie die Regeln anschließend an:

```bash
sudo restorecon -Rv /var/www/roundcube
sudo restorecon -Rv /var/lib/roundcube
```

Damit Roundcube **Verbindungen zu Postfix und Dovecot** herstellen kann, aktivieren Sie zusätzlich:

```bash
sudo setsebool -P httpd_can_network_connect 1
```

## Schritt 15: Nginx für Roundcube konfigurieren

Erstellen Sie eine neue Nginx-Konfiguration:

```bash
sudo nano /etc/nginx/conf.d/roundcube.conf
```

Fügen Sie folgende Konfiguration ein:

```none
server {
    listen 80;
    server_name mail.example.com;
    return 301 https://$host$request_uri;
}
server {
    listen 443 ssl;
    server_name mail.example.com;
    root /var/www/roundcube/public_html;
    index index.php;
    ssl_certificate /etc/letsencrypt/live/mail.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/mail.example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    client_max_body_size 25M;
    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }
    location ~ \.php(?:/|$) {
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_pass unix:/run/php-fpm/www.sock;
    }
    location ~ /\. {
        deny all;
    }
}
```

Prüfen Sie anschließend die Konfiguration und laden Sie Nginx neu:

```bash
sudo nginx -t
sudo systemctl reload nginx
```

Rufen Sie danach im Browser `https://mail.example.com` auf. Die Roundcube-Anmeldemaske sollte erscheinen.

## Schritt 16: Mailserver testen

Prüfen Sie zunächst, ob alle Dienste laufen:

```bash
sudo systemctl status postfix dovecot nginx php-fpm
```

Mit folgendem Befehl kontrollieren Sie die geöffneten Ports:

```bash
sudo ss -tulpn
```

Für dieses Setup sollten insbesondere die **Ports 25, 587, 993, 80 und 443** erreichbar sein. Die verschlüsselte IMAP-Verbindung können Sie mit OpenSSL testen:

```bash
openssl s_client \
    -connect mail.example.com:993 \
    -servername mail.example.com
```

Für SMTP über Port 587 verwenden Sie:

```bash
openssl s_client \
    -starttls smtp \
    -connect mail.example.com:587 \
    -servername mail.example.com
```

Melden Sie sich anschließend in Roundcube mit dem zuvor angelegten User an:

- Benutzername: alice
- Passwort: das zuvor vergebene Passwort

Senden Sie testweise eine Nachricht an eine externe Adresse und anschließend eine Nachricht von einem externen Postfach an `alice@example.com`.

## Mailserver für den Produktivbetrieb erweitern

Mit der bisherigen Konfiguration verfügen Sie über einen funktionsfähigen Rocky Linux Mailserver. Für einen dauerhaft öffentlich betriebenen Server sollten Sie das Setup jedoch noch um **einige Sicherheits- und Zustellbarkeitsfunktionen erweitern**.

Dazu gehören insbesondere DKIM und DMARC, ein Spamfilter wie Rspamd, Schutz vor Brute-Force-Angriffen, regelmäßige Backups sowie kontinuierliche Sicherheitsupdates. Für größere Installationen mit mehreren Domains oder vielen Konten sind außerdem **virtuelle Mailuser** über beispielsweise MariaDB, PostgreSQL oder [LDAP](https://www.ionos.at/digitalguide/server/knowhow/ldap/) besser geeignet als lokale Linux-User.


This is a markdown version of: [https://www.ionos.at/digitalguide/e-mail/e-mail-technik/rocky-linux-mailserver/](https://www.ionos.at/digitalguide/e-mail/e-mail-technik/rocky-linux-mailserver/) for AI/LLM consumption.