Installationshandbuch für Forward Email Self-Hosting für Ubuntu

Überblick

Diese Anleitung enthält Schritt-für-Schritt-Anweisungen zur Installation der selbstgehosteten Lösung von Forward Email auf Ubuntu-Systemen. Sie ist speziell auf die Ubuntu-LTS-Versionen 20.04, 22.04 und 24.04 zugeschnitten.

Voraussetzungen

Stellen Sie vor Beginn der Installation sicher, dass Sie über Folgendes verfügen:

Ubuntu Server: 20.04, 22.04 oder 24.04 LTS
Root-Zugriff: Sie müssen Befehle als Root ausführen können (Sudo-Zugriff)
Domänenname: Eine Domäne, die Sie mit DNS-Verwaltungszugriff steuern
Server bereinigen: Es wird empfohlen, eine neue Ubuntu-Installation zu verwenden
Internetverbindung: Erforderlich zum Herunterladen von Paketen und Docker-Images

Systemanforderungen

RAM: Mindestens 2 GB (4 GB für die Produktion empfohlen)
Lagerung: Mindestens 20 GB verfügbarer Speicherplatz (50 GB+ für die Produktion empfohlen)
CPU: mindestens 1 vCPU (für die Produktion werden 2+ vCPUs empfohlen)
Netzwerk: Öffentliche IP-Adresse mit folgenden zugänglichen Ports:
- 22 (SSH)
- 25 (SMTP)
- 80 (HTTP)
- 443 (HTTPS)
- 465 (SMTPS)
- 993 (IMAPS)
- 995 (POP3S)

Schritt-für-Schritt-Installation

Schritt 1: Erstmalige Systemeinrichtung

Stellen Sie zunächst sicher, dass Ihr System auf dem neuesten Stand ist, und wechseln Sie zum Root-Benutzer:

# Update system packages sudo apt update && sudo apt upgrade -y Switch to root user (required for the installation)

sudo su -

Schritt 2: Konfigurieren Sie DNS-Resolver

Konfigurieren Sie Ihr System so, dass es die DNS-Server von Cloudflare zur zuverlässigen Zertifikatsgenerierung verwendet:

# Stop and disable systemd-resolved if running if systemctl is-active --quiet systemd-resolved; then rm /etc/resolv.conf systemctl stop systemd-resolved systemctl disable systemd-resolved systemctl mask systemd-resolved fi Configure Cloudflare DNS resolvers

tee /etc/resolv.conf > /dev/null <<EOF nameserver 1.1.1.1 nameserver 2606:4700:4700::1111 nameserver 1.0.0.1 nameserver 2606:4700:4700::1001 nameserver 8.8.8.8 nameserver 2001:4860:4860::8888 nameserver 8.8.4.4 nameserver 2001:4860:4860::8844 EOF

Schritt 3: Systemabhängigkeiten installieren

Installieren Sie die erforderlichen Pakete für die E-Mail-Weiterleitung:

# Update package list
apt-get update -y
Install basic dependencies
apt-get install -y 

ca-certificates 

curl 

gnupg 

git 

openssl 

docker-compose 

snapd

Schritt 4: Installieren Sie Snap-Pakete

Installieren Sie AWS CLI und Certbot per Snap:

# Install AWS CLI snap install aws-cli --classic Install Certbot and DNS plugin

snap install certbot --classic snap set certbot trust-plugin-with-root=ok snap install certbot-dns-cloudflare

Schritt 5: Docker installieren

Installieren Sie Docker CE und Docker Compose:

# Add Docker's official GPG key
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | tee /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc
Add Docker repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list
Update package index and install Docker
apt-get update -y
apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Verify Docker installation
docker --version
docker compose version

Schritt 6: Docker-Dienst konfigurieren

Stellen Sie sicher, dass Docker automatisch startet und ausgeführt wird:

# Enable and start Docker service systemctl unmask docker systemctl enable docker systemctl start docker Verify Docker is running

docker info

Wenn Docker nicht startet, versuchen Sie, es manuell zu starten:

# Alternative startup method if systemctl fails
nohup dockerd >/dev/null 2>/dev/null &
sleep 5
docker info

Schritt 7: Firewall konfigurieren

Richten Sie eine UFW-Firewall ein, um Ihren Server zu sichern:

# Set default policies ufw default deny incoming ufw default allow outgoing Allow SSH (important - don't lock yourself out!) ufw allow 22/tcp Allow email-related ports ufw allow 25/tcp # SMTP ufw allow 80/tcp # HTTP (for Let's Encrypt) ufw allow 443/tcp # HTTPS ufw allow 465/tcp # SMTPS ufw allow 993/tcp # IMAPS ufw allow 995/tcp # POP3S ufw allow 2993/tcp # IMAP (alternative port) ufw allow 2995/tcp # POP3 (alternative port) ufw allow 3456/tcp # Custom service port ufw allow 4000/tcp # Custom service port ufw allow 5000/tcp # Custom service port Allow local database connections ufw allow from 127.0.0.1 to any port 27017 # MongoDB ufw allow from 127.0.0.1 to any port 6379 # Redis Enable firewall echo "y" | ufw enable Check firewall status

ufw status numbered

Schritt 8: Weiterleitungs-E-Mail-Repository klonen

Laden Sie den Quellcode für die E-Mail-Weiterleitung herunter:

# Set up variables REPO_FOLDER_NAME="forwardemail.net" REPO_URL="https://github.com/forwardemail/forwardemail.net.git" ROOT_DIR="/root/$REPO_FOLDER_NAME" Clone the repository git clone "$REPO_URL" "$ROOT_DIR" cd "$ROOT_DIR" Verify the clone was successful

ls -la

Schritt 9: Umgebungskonfiguration einrichten

Bereiten Sie die Umgebungskonfiguration vor:

# Set up directory variables SELF_HOST_DIR="$ROOT_DIR/self-hosting" ENV_FILE_DEFAULTS=".env.defaults" ENV_FILE=".env" Copy default environment file cp "$ROOT_DIR/$ENV_FILE_DEFAULTS" "$SELF_HOST_DIR/$ENV_FILE" Create SSL directory mkdir -p "$SELF_HOST_DIR/ssl" Create database directories

mkdir -p "$SELF_HOST_DIR/sqlite-data" mkdir -p "$SELF_HOST_DIR/mongo-backups" mkdir -p "$SELF_HOST_DIR/redis-backups"

Schritt 10: Konfigurieren Sie Ihre Domäne

Legen Sie Ihren Domänennamen fest und aktualisieren Sie die Umgebungsvariablen:

# Replace 'yourdomain.com' with your actual domain
DOMAIN="yourdomain.com"
Function to update environment file
update_env_file() {
local key="$1"
local value="$2"
if grep -qE "^${key}=" "$SELF_HOST_DIR/$ENV_FILE"; then
sed -i -E "s|^${key}=.*|${key}=${value}|" "$SELF_HOST_DIR/$ENV_FILE"
else
echo "${key}=${value}" >> "$SELF_HOST_DIR/$ENV_FILE"
fi
}
Update domain-related environment variables
update_env_file "DOMAIN" "$DOMAIN"
update_env_file "NODE_ENV" "production"
update_env_file "HTTP_PROTOCOL" "https"
update_env_file "WEB_HOST" "$DOMAIN"
update_env_file "WEB_PORT" "443"
update_env_file "CALDAV_HOST" "caldav.$DOMAIN"
update_env_file "CARDDAV_HOST" "carddav.$DOMAIN"
update_env_file "API_HOST" "api.$DOMAIN"
update_env_file "APP_NAME" "$DOMAIN"
update_env_file "SMTP_HOST" "smtp.$DOMAIN"
update_env_file "SMTP_PORT" "465"
update_env_file "IMAP_HOST" "imap.$DOMAIN"
update_env_file "IMAP_PORT" "993"
update_env_file "POP3_HOST" "pop3.$DOMAIN"
update_env_file "POP3_PORT" "995"
update_env_file "MX_HOST" "mx.$DOMAIN"
update_env_file "SMTP_EXCHANGE_DOMAINS" "mx.$DOMAIN"
update_env_file "SELF_HOSTED" "true"
update_env_file "WEBSITE_URL" "$DOMAIN"
update_env_file "AUTH_BASIC_ENABLED" "true"

Schritt 11: SSL-Zertifikate generieren

Option A: Manuelle DNS-Challenge (für die meisten Benutzer empfohlen)

# Generate certificates using manual DNS challenge
certbot certonly \
  --manual \
  --agree-tos \
  --preferred-challenges dns \
  -d "*.$DOMAIN" \
  -d "$DOMAIN"

Wichtig: Wenn Sie dazu aufgefordert werden, müssen Sie TXT-Einträge in Ihrem DNS erstellen. Möglicherweise werden mehrere Herausforderungen für dieselbe Domäne angezeigt. erstelle sie ALLE. Entfernen Sie beim Hinzufügen des zweiten nicht den ersten TXT-Eintrag.

Option B: Cloudflare DNS (wenn Sie Cloudflare verwenden)

Wenn Ihre Domäne Cloudflare für DNS verwendet, können Sie die Zertifikatsgenerierung automatisieren:

# Create Cloudflare credentials file cat > /root/.cloudflare.ini <<EOF dns_cloudflare_email = "your-email@example.com" dns_cloudflare_api_key = "your-cloudflare-global-api-key" EOF Set proper permissions chmod 600 /root/.cloudflare.ini Generate certificates automatically

certbot certonly --dns-cloudflare --dns-cloudflare-credentials /root/.cloudflare.ini -d "$DOMAIN" -d "*.$DOMAIN" --non-interactive --agree-tos --email "your-email@example.com"

Zertifikate kopieren

Kopieren Sie die Zertifikate nach der Generierung in das Anwendungsverzeichnis:

# Copy certificates to application SSL directory cp /etc/letsencrypt/live/$DOMAIN*/* "$SELF_HOST_DIR/ssl/" Verify certificates were copied

ls -la "$SELF_HOST_DIR/ssl/"

Schritt 12: Verschlüsselungsschlüssel generieren

Erstellen Sie die verschiedenen Verschlüsselungsschlüssel, die für einen sicheren Betrieb erforderlich sind:

# Generate helper encryption key
helper_encryption_key=$(openssl rand -base64 32 | tr -d /=+ | cut -c -32)
update_env_file "HELPER_ENCRYPTION_KEY" "$helper_encryption_key"
Generate SRS secret for email forwarding
srs_secret=$(openssl rand -base64 32 | tr -d /=+ | cut -c -32)
update_env_file "SRS_SECRET" "$srs_secret"
Generate TXT encryption key
txt_encryption_key=$(openssl rand -hex 16)
update_env_file "TXT_ENCRYPTION_KEY" "$txt_encryption_key"
Generate DKIM private key for email signing
openssl genrsa -f4 -out "$SELF_HOST_DIR/ssl/dkim.key" 2048
update_env_file "DKIM_PRIVATE_KEY_PATH" "/app/ssl/dkim.key"
Generate webhook signature key
webhook_signature_key=$(openssl rand -hex 16)
update_env_file "WEBHOOK_SIGNATURE_KEY" "$webhook_signature_key"
Set SMTP transport password
update_env_file "SMTP_TRANSPORT_PASS" "$(openssl rand -base64 32)"
echo "✅ All encryption keys generated successfully"

Schritt 13: SSL-Pfade in der Konfiguration aktualisieren

Konfigurieren Sie die SSL-Zertifikatpfade in der Umgebungsdatei:

# Update SSL paths to point to the correct certificate files
sed -i -E \
  -e 's|^(.*_)?SSL_KEY_PATH=.*|\1SSL_KEY_PATH=/app/ssl/privkey.pem|' \
  -e 's|^(.*_)?SSL_CERT_PATH=.*|\1SSL_CERT_PATH=/app/ssl/fullchain.pem|' \
  -e 's|^(.*_)?SSL_CA_PATH=.*|\1SSL_CA_PATH=/app/ssl/chain.pem|' \
  "$SELF_HOST_DIR/$ENV_FILE"

Schritt 14: Basisauthentifizierung einrichten

Erstellen Sie temporäre Anmeldeinformationen für die Basisauthentifizierung:

# Generate a secure random password
PASSWORD=$(openssl rand -base64 16)
Update environment file with basic auth credentials
update_env_file "AUTH_BASIC_USERNAME" "admin"
update_env_file "AUTH_BASIC_PASSWORD" "$PASSWORD"
Display credentials (save these!)
echo ""
echo "🔐 IMPORTANT: Save these login credentials!"
echo "=================================="
echo "Username: admin"
echo "Password: $PASSWORD"
echo "=================================="
echo ""
echo "You'll need these to access the web interface after installation."
echo ""

Schritt 15: Bereitstellen mit Docker Compose

Starten Sie alle E-Mail-Weiterleitungsdienste:

# Set Docker Compose file path DOCKER_COMPOSE_FILE="$SELF_HOST_DIR/docker-compose-self-hosted.yml" Stop any existing containers docker compose -f "$DOCKER_COMPOSE_FILE" down Pull the latest images docker compose -f "$DOCKER_COMPOSE_FILE" pull Start all services in detached mode docker compose -f "$DOCKER_COMPOSE_FILE" up -d Wait a moment for services to start sleep 10 Check service status

docker compose -f "$DOCKER_COMPOSE_FILE" ps

Schritt 16: Installation überprüfen

Überprüfen Sie, ob alle Dienste ordnungsgemäß ausgeführt werden:

# Check Docker containers
docker ps
Check service logs for any errors
docker compose -f "$DOCKER_COMPOSE_FILE" logs --tail=50
Test web interface connectivity
curl -I https://$DOMAIN
Check if ports are listening
netstat -tlnp | grep -E ':(25|80|443|465|587|993|995)'

Konfiguration nach der Installation

Einrichten von DNS-Einträgen

Sie müssen die folgenden DNS-Einträge für Ihre Domäne konfigurieren:

MX-Eintrag

@ MX 10 mx.yourdomain.com

A-Aufzeichnungen

@ A YOUR_SERVER_IP
mx A YOUR_SERVER_IP
smtp A YOUR_SERVER_IP
imap A YOUR_SERVER_IP
pop3 A YOUR_SERVER_IP
api A YOUR_SERVER_IP
caldav A YOUR_SERVER_IP
carddav A YOUR_SERVER_IP

SPF-Eintrag

@ TXT "v=spf1 mx ~all"

DKIM-Eintrag

Holen Sie sich Ihren öffentlichen DKIM-Schlüssel:

# Extract DKIM public key
openssl rsa -in "$SELF_HOST_DIR/ssl/dkim.key" -pubout -outform DER | openssl base64 -A

DKIM-DNS-Eintrag erstellen:

default._domainkey TXT "v=DKIM1; k=rsa; p=YOUR_DKIM_PUBLIC_KEY"

DMARC-Eintrag

_dmarc TXT "v=DMARC1; p=quarantine; rua=mailto:dmarc@yourdomain.com"

Öffnen Sie Ihren Webbrowser und navigieren Sie zu https://yourdomain.com
Geben Sie die grundlegenden Authentifizierungsdaten ein, die Sie zuvor gespeichert haben
Schließen Sie den Assistenten für die Ersteinrichtung ab
Erstellen Sie Ihr erstes E-Mail-Konto

Sicherungskonfiguration

S3-kompatibles Backup einrichten

Konfigurieren Sie automatische Sicherungen auf S3-kompatiblem Speicher:

# Create AWS credentials directory
mkdir -p ~/.aws
Configure AWS credentials
cat > ~/.aws/credentials <<EOF
[default]
aws_access_key_id = YOUR_ACCESS_KEY_ID
aws_secret_access_key = YOUR_SECRET_ACCESS_KEY
EOF
Configure AWS settings
cat > ~/.aws/config <<EOF
[default]
region = auto
output = json
EOF
For non-AWS S3 (like Cloudflare R2), add endpoint URL
echo "endpoint_url = YOUR_S3_ENDPOINT_URL" >> ~/.aws/config

Einrichten von Backup-Cron-Jobs

# Make backup scripts executable
chmod +x "$ROOT_DIR/self-hosting/scripts/backup-mongo.sh"
chmod +x "$ROOT_DIR/self-hosting/scripts/backup-redis.sh"
Add MongoDB backup cron job (runs daily at midnight)
(crontab -l 2>/dev/null; echo "0 0 * * * $ROOT_DIR/self-hosting/scripts/backup-mongo.sh >> /var/log/mongo-backup.log 2>&1") | crontab -
Add Redis backup cron job (runs daily at midnight)
(crontab -l 2>/dev/null; echo "0 0 * * * $ROOT_DIR/self-hosting/scripts/backup-redis.sh >> /var/log/redis-backup.log 2>&1") | crontab -
Verify cron jobs were added
crontab -l

Automatische Aktualisierung der Konfiguration

Richten Sie automatische Updates für Ihre Forward Email-Installation ein:

# Create auto-update command
DOCKER_UPDATE_CMD="docker compose -f $DOCKER_COMPOSE_FILE pull && docker compose -f $DOCKER_COMPOSE_FILE up -d"
Add auto-update cron job (runs daily at 1 AM)
(crontab -l 2>/dev/null; echo "0 1 * * * $DOCKER_UPDATE_CMD >> /var/log/autoupdate.log 2>&1") | crontab -
Verify the cron job was added
crontab -l

Wartung und Überwachung

Protokollspeicherorte

Docker Compose-Protokolle: docker compose -f $DOCKER_COMPOSE_FILE logs
Systemprotokolle: /var/log/syslog
Sicherungsprotokolle: /var/log/mongo-backup.log, /var/log/redis-backup.log
Protokolle automatisch aktualisieren: /var/log/autoupdate.log

Regelmäßige Wartungsaufgaben

Überwachen des Speicherplatzes: df -h
Servicestatus prüfen: docker compose -f $DOCKER_COMPOSE_FILE ps
Protokolle überprüfen: docker compose -f $DOCKER_COMPOSE_FILE logs --tail=100
Systempakete aktualisieren: apt update && apt upgrade
Zertifikate erneuern: Zertifikate werden automatisch erneuert, aber das Ablaufdatum wird überwacht

Zertifikatserneuerung

Zertifikate sollten automatisch erneuert werden, Sie können sie jedoch bei Bedarf manuell erneuern:

# Manual certificate renewal certbot renew Copy renewed certificates cp /etc/letsencrypt/live/$DOMAIN*/* "$SELF_HOST_DIR/ssl/" Restart services to use new certificates

docker compose -f "$DOCKER_COMPOSE_FILE" restart

Fehlerbehebung

Häufige Probleme

1. Der Docker-Dienst startet nicht

# Check Docker status systemctl status docker Try alternative startup

nohup dockerd >/dev/null 2>/dev/null &

2. Die Zertifikatsgenerierung schlägt fehl

Stellen Sie sicher, dass die Ports 80 und 443 zugänglich sind
Überprüfen Sie, ob DNS-Einträge auf Ihren Server verweisen
Überprüfen Sie die Firewall-Einstellungen

3. Probleme bei der E-Mail-Zustellung

Überprüfen Sie, ob die MX-Einträge korrekt sind
Überprüfen Sie SPF-, DKIM- und DMARC-Einträge
Stellen Sie sicher, dass Port 25 nicht von Ihrem Hosting-Anbieter blockiert wird

4. Weboberfläche nicht zugänglich

Überprüfen Sie die Firewall-Einstellungen: ufw status
SSL-Zertifikate überprüfen: openssl x509 -in $SELF_HOST_DIR/ssl/fullchain.pem -text -noout
Überprüfen Sie die grundlegenden Authentifizierungsdaten

Hilfe bekommen

Dokumentation: https://forwardemail.net/self-hosted
GitHub-Probleme: https://github.com/forwardemail/forwardemail.net/issues
Community-Unterstützung: Sehen Sie sich die GitHub-Diskussionen des Projekts an

Bewährte Sicherheitspraktiken

Halten Sie das System auf dem neuesten Stand: Aktualisieren Sie Ubuntu und Pakete regelmäßig
Monitorprotokolle: Einrichten der Protokollüberwachung und -warnung
Regelmäßiges Backup: Testen Sie Sicherungs- und Wiederherstellungsverfahren
Verwenden Sie sichere Passwörter: Generieren Sie sichere Passwörter für alle Konten
Fail2Ban aktivieren: Erwägen Sie die Installation von fail2ban für zusätzliche Sicherheit
Regelmäßige Sicherheitsüberprüfungen: Überprüfen Sie regelmäßig Ihre Konfiguration

Abschluss

Ihre selbstgehostete Installation von Forward Email sollte nun abgeschlossen sein und unter Ubuntu ausgeführt werden. Beachten Sie Folgendes:

Konfigurieren Sie Ihre DNS-Einträge richtig
Testen Sie das Senden und Empfangen von E-Mails
Richten Sie regelmäßige Backups ein
Überwachen Sie Ihr System regelmäßig
Halten Sie Ihre Installation auf dem neuesten Stand

Weitere Konfigurationsoptionen und erweiterte Funktionen finden Sie in der offiziellen Forward Email-Dokumentation unter https://forwardemail.net/self-hosted#configuration.

Installationshandbuch für Forward Email Self-Hosting für Ubuntu

Schritt 1: Erstmalige Systemeinrichtung

Switch to root user (required for the installation)

Schritt 2: Konfigurieren Sie DNS-Resolver

Configure Cloudflare DNS resolvers

Schritt 3: Systemabhängigkeiten installieren

Install basic dependencies

Schritt 4: Installieren Sie Snap-Pakete

Install Certbot and DNS plugin

Schritt 5: Docker installieren

Add Docker repository

Update package index and install Docker

Verify Docker installation

Schritt 6: Docker-Dienst konfigurieren

Verify Docker is running

Schritt 7: Firewall konfigurieren

Allow SSH (important - don't lock yourself out!)

Allow email-related ports

Allow local database connections

Enable firewall

Check firewall status

Schritt 8: Weiterleitungs-E-Mail-Repository klonen

Clone the repository

Verify the clone was successful

Schritt 9: Umgebungskonfiguration einrichten

Copy default environment file

Create SSL directory

Create database directories

Schritt 10: Konfigurieren Sie Ihre Domäne

Function to update environment file

Update domain-related environment variables

Schritt 11: SSL-Zertifikate generieren

Option A: Manuelle DNS-Challenge (für die meisten Benutzer empfohlen)

Option B: Cloudflare DNS (wenn Sie Cloudflare verwenden)

Set proper permissions

Generate certificates automatically

Zertifikate kopieren

Verify certificates were copied

Schritt 12: Verschlüsselungsschlüssel generieren

Generate SRS secret for email forwarding

Generate TXT encryption key

Generate DKIM private key for email signing

Generate webhook signature key

Set SMTP transport password

Schritt 13: SSL-Pfade in der Konfiguration aktualisieren

Schritt 14: Basisauthentifizierung einrichten

Update environment file with basic auth credentials

Display credentials (save these!)

Schritt 15: Bereitstellen mit Docker Compose

Stop any existing containers

Pull the latest images

Start all services in detached mode

Wait a moment for services to start

Check service status

Schritt 16: Installation überprüfen

Check service logs for any errors

Test web interface connectivity

Check if ports are listening

Einrichten von DNS-Einträgen

MX-Eintrag

A-Aufzeichnungen

SPF-Eintrag

DKIM-Eintrag

DMARC-Eintrag

Erste Anmeldung

S3-kompatibles Backup einrichten

Configure AWS credentials

Configure AWS settings

For non-AWS S3 (like Cloudflare R2), add endpoint URL

Einrichten von Backup-Cron-Jobs

Add MongoDB backup cron job (runs daily at midnight)

Add Redis backup cron job (runs daily at midnight)

Verify cron jobs were added

Add auto-update cron job (runs daily at 1 AM)

Verify the cron job was added

Protokollspeicherorte

Regelmäßige Wartungsaufgaben

Zertifikatserneuerung

Copy renewed certificates

Restart services to use new certificates