Forward Email Självhostad Installationsguide för Ubuntu

Denna guide beskriver steg för steg hur du installerar Forward Emails självhostade lösning på Ubuntu 20.04, 22.04 och 24.04 LTS.

Innan du börjar installationen, säkerställ att du har:

  • Ubuntu Server: 20.04, 22.04 eller 24.04 LTS
  • Root-åtkomst: Du måste kunna köra kommandon som root (sudo-åtkomst)
  • Domännamn: En domän som du kontrollerar med DNS-hanteringsåtkomst
  • Ren Server: Rekommenderas att använda en färsk Ubuntu-installation
  • Internetanslutning: Krävs för att ladda ner paket och Docker-bilder

  • RAM: Minst 2GB (4GB rekommenderas för produktion)
  • Lagring: Minst 20GB ledigt utrymme (50GB+ rekommenderas för produktion)
  • CPU: Minst 1 vCPU (2+ vCPU rekommenderas för produktion)
  • Nätverk: Offentlig IP-adress med följande portar tillgängliga:
    • 22 (SSH)
    • 25 (SMTP)
    • 80 (HTTP)
    • 443 (HTTPS)
    • 465 (SMTPS)
    • 993 (IMAPS)
    • 995 (POP3S)

Steg 1: Initial Systeminställning

Först, säkerställ att ditt system är uppdaterat och byt till root-användare:

# Uppdatera systempaket
sudo apt update && sudo apt upgrade -y

# Byt till root-användare (krävs för installationen)
sudo su -

Steg 2: Konfigurera DNS-resolverare

Konfigurera ditt system att använda Cloudflares DNS-servrar för pålitlig certifikatgenerering:

# Stoppa och inaktivera systemd-resolved om den körs
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

# Konfigurera Cloudflare DNS-resolverare
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

Steg 3: Installera systemberoenden

Installera de nödvändiga paketen för Forward Email:

# Uppdatera paketlistan
apt-get update -y

# Installera grundläggande beroenden
apt-get install -y \
    ca-certificates \
    curl \
    gnupg \
    git \
    openssl \
    docker-compose \
    snapd

Steg 4: Installera Snap-paket

Installera AWS CLI och Certbot via snap:

# Installera AWS CLI
snap install aws-cli --classic

# Installera Certbot och DNS-plugin
snap install certbot --classic
snap set certbot trust-plugin-with-root=ok
snap install certbot-dns-cloudflare

Steg 5: Installera Docker

Installera Docker CE och Docker Compose:

# Lägg till Dockers officiella GPG-nyckel
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

# Lägg till Docker-förrådet
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

# Uppdatera paketindex och installera Docker
apt-get update -y
apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Verifiera Docker-installationen
docker --version
docker compose version

Steg 6: Konfigurera Docker-tjänsten

Se till att Docker startar automatiskt och körs:

# Aktivera och starta Docker-tjänsten
systemctl unmask docker
systemctl enable docker
systemctl start docker

# Verifiera att Docker körs
docker info

Om Docker inte startar, försök starta det manuellt:

# Alternativ startmetod om systemctl misslyckas
nohup dockerd >/dev/null 2>/dev/null &
sleep 5
docker info

Steg 7: Konfigurera brandväggen

Ställ in UFW-brandväggen för att säkra din server:

# Ställ in standardpolicyer
ufw default deny incoming
ufw default allow outgoing

# Tillåt SSH (viktigt - lås inte ute dig själv!)
ufw allow 22/tcp

# Tillåt e-postrelaterade portar
ufw allow 25/tcp    # SMTP
ufw allow 80/tcp    # HTTP (för Let's Encrypt)
ufw allow 443/tcp   # HTTPS
ufw allow 465/tcp   # SMTPS
ufw allow 587/tcp   # SMTP-inlämning (STARTTLS)
ufw allow 993/tcp   # IMAPS
ufw allow 995/tcp   # POP3S
ufw allow 2993/tcp  # IMAP (alternativ port)
ufw allow 2995/tcp  # POP3 (alternativ port)
ufw allow 3456/tcp  # Anpassad tjänsteport
ufw allow 4000/tcp  # Anpassad tjänsteport
ufw allow 5000/tcp  # Anpassad tjänsteport

# Tillåt lokala databasanslutningar
ufw allow from 127.0.0.1 to any port 27017  # MongoDB
ufw allow from 127.0.0.1 to any port 6379   # Redis

# Aktivera brandväggen
echo "y" | ufw enable

# Kontrollera brandväggens status
ufw status numbered

Steg 8: Klona Forward Email-förrådet

Ladda ner källkoden för Forward Email:

# Ställ in variabler
REPO_FOLDER_NAME="forwardemail.net"
REPO_URL="https://github.com/forwardemail/forwardemail.net.git"
ROOT_DIR="/root/$REPO_FOLDER_NAME"

# Klona förrådet
git clone "$REPO_URL" "$ROOT_DIR"
cd "$ROOT_DIR"

# Verifiera att kloningen lyckades
ls -la

Steg 9: Ställ in miljökonfiguration

Förbered miljökonfigurationen:

# Ställ in katalogvariabler
SELF_HOST_DIR="$ROOT_DIR/self-hosting"
ENV_FILE_DEFAULTS=".env.defaults"
ENV_FILE=".env"

# Kopiera standardmiljöfilen
cp "$ROOT_DIR/$ENV_FILE_DEFAULTS" "$SELF_HOST_DIR/$ENV_FILE"

# Skapa SSL-katalog
mkdir -p "$SELF_HOST_DIR/ssl"

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

Steg 10: Konfigurera din domän

Ange ditt domännamn och uppdatera miljövariabler:

# Byt ut 'yourdomain.com' mot din faktiska domän
DOMAIN="yourdomain.com"

# Funktion för att uppdatera miljöfilen
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
}

# Uppdatera domänrelaterade miljövariabler
update_env_file "DOMAIN" "$DOMAIN"
update_env_file "NODE_ENV" "production"
update_env_file "HTTP_PROTOCOL" "https"
update_env_file "WEB_URL" "https://$DOMAIN"
update_env_file "WEB_HOST" "$DOMAIN"
# nginx (sni-router-tjänsten) avslutar TLS på 443 och fungerar som proxy till
# webbappen på 3000 (se docker-compose-self-hosted.yml och nginx.conf). Låt
# WEB_PORT vara 3000; att sätta den till 443 krockar med nginx på värdnätverket
# och gör webbgränssnittet oåtkomligt.
update_env_file "WEB_PORT" "3000"
update_env_file "SQLITE_HOST" "sqlite.$DOMAIN"
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 "TRANSPORT_DEBUG" "true"
update_env_file "SEND_EMAIL" "true"
update_env_file "PREVIEW_EMAIL" "false"
update_env_file "MONGO_HOST" "127.0.0.1"
update_env_file "LOGS_HOST" "127.0.0.1"
update_env_file "REDIS_HOST" "127.0.0.1"
update_env_file "TURNSTILE_ENABLED" "false"
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 "MX_PORT" "25"
update_env_file "SMTP_EXCHANGE_DOMAINS" "mx.$DOMAIN"
update_env_file "SQLITE_STORAGE_PATH" "sqlite_storage"
update_env_file "SELF_HOSTED" "true"
update_env_file "ENABLE_MONITOR_SERVER" "false"
update_env_file "CACHE_RESPONSES" "true"
update_env_file "WEBSITE_URL" "$DOMAIN"
update_env_file "AUTH_BASIC_ENABLED" "true"

Steg 11: Generera SSL-certifikat

# Generera certifikat med manuell DNS-utmaning
certbot certonly \
  --manual \
  --agree-tos \
  --preferred-challenges dns \
  -d "*.$DOMAIN" \
  -d "$DOMAIN"

Viktigt: När du uppmanas måste du skapa TXT-poster i din DNS. Du kan se flera utmaningar för samma domän: skapa ALLA. Ta inte bort den första TXT-posten när du lägger till den andra.

Alternativ B: Cloudflare DNS (Om du använder Cloudflare)

Om din domän använder Cloudflare för DNS kan du automatisera certifikatgenereringen:

# Skapa Cloudflare autentiseringsfil
cat > /root/.cloudflare.ini <<EOF
dns_cloudflare_email = "your-email@example.com"
dns_cloudflare_api_key = "your-cloudflare-global-api-key"
EOF

# Sätt rätt behörigheter
chmod 600 /root/.cloudflare.ini

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

Kopiera certifikat

Efter certifikatgenereringen, kopiera dem till applikationskatalogen:

# Kopiera certifikat till applikationens SSL-katalog
cp /etc/letsencrypt/live/$DOMAIN*/* "$SELF_HOST_DIR/ssl/"

# Verifiera att certifikaten kopierades
ls -la "$SELF_HOST_DIR/ssl/"

Steg 12: Generera krypteringsnycklar

Skapa de olika krypteringsnycklar som krävs för säker drift:

# Generera hjälpkrypteringsnyckel
helper_encryption_key=$(openssl rand -base64 32 | tr -d /=+ | cut -c -32)
update_env_file "HELPER_ENCRYPTION_KEY" "$helper_encryption_key"

# Generera SRS-hemlighet för vidarebefordran av e-post
srs_secret=$(openssl rand -base64 32 | tr -d /=+ | cut -c -32)
update_env_file "SRS_SECRET" "$srs_secret"

# Generera TXT-krypteringsnyckel
txt_encryption_key=$(openssl rand -hex 16)
update_env_file "TXT_ENCRYPTION_KEY" "$txt_encryption_key"

# Generera DKIM privat nyckel för e-postsignering
openssl genrsa -f4 -out "$SELF_HOST_DIR/ssl/dkim.key" 2048
update_env_file "DKIM_PRIVATE_KEY_PATH" "/app/ssl/dkim.key"

# Generera webhook signeringsnyckel
webhook_signature_key=$(openssl rand -hex 16)
update_env_file "WEBHOOK_SIGNATURE_KEY" "$webhook_signature_key"

# Sätt SMTP transportlösenord
update_env_file "SMTP_TRANSPORT_PASS" "$(openssl rand -base64 32)"

echo "✅ Alla krypteringsnycklar genererades framgångsrikt"

Steg 13: Uppdatera SSL-sökvägar i konfigurationen

Konfigurera SSL-certifikatens sökvägar i miljöfilen:

# Uppdatera SSL-sökvägar för att peka på rätt certifikatfiler
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"

Steg 14: Ställ in grundläggande autentisering

Skapa tillfälliga autentiseringsuppgifter för grundläggande autentisering:

# Generera ett säkert slumpmässigt lösenord
PASSWORD=$(openssl rand -base64 16)

# Uppdatera miljöfilen med grundläggande autentiseringsuppgifter
update_env_file "AUTH_BASIC_USERNAME" "admin"
update_env_file "AUTH_BASIC_PASSWORD" "$PASSWORD"

# Visa uppgifterna (spara dessa!)
echo ""
echo "🔐 VIKTIGT: Spara dessa inloggningsuppgifter!"
echo "=================================="
echo "Användarnamn: admin"
echo "Lösenord: $PASSWORD"
echo "=================================="
echo ""
echo "Du kommer att behöva dessa för att komma åt webbgränssnittet efter installationen."
echo ""

Steg 15: Distribuera med Docker Compose

Starta alla Forward Email-tjänster:

# Sätt sökväg till Docker Compose-fil
DOCKER_COMPOSE_FILE="$SELF_HOST_DIR/docker-compose-self-hosted.yml"

# Stoppa eventuella befintliga containrar
docker compose -f "$DOCKER_COMPOSE_FILE" down

# Hämta de senaste bilderna
docker compose -f "$DOCKER_COMPOSE_FILE" pull

# Starta alla tjänster i bakgrunden
docker compose -f "$DOCKER_COMPOSE_FILE" up -d

# Vänta en stund för att tjänsterna ska starta
sleep 10

# Kontrollera tjänsternas status
docker compose -f "$DOCKER_COMPOSE_FILE" ps

Steg 16: Verifiera installation

Kontrollera att alla tjänster körs korrekt:

# Kontrollera Docker-containrar
docker ps

# Kontrollera tjänstloggar för eventuella fel
docker compose -f "$DOCKER_COMPOSE_FILE" logs --tail=50

# Testa webbgränssnittets anslutning
curl -I https://$DOMAIN

# Kontrollera om portar lyssnar
netstat -tlnp | grep -E ':(25|80|443|465|587|993|995)'

DNS-poster inställning

Du behöver konfigurera följande DNS-poster för din domän:

MX-post

@ MX 10 mx.yourdomain.com

A-poster

@ 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-post

@ TXT "v=spf1 mx ~all"

DKIM-post

Hämta din DKIM offentliga nyckel:

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

Skapa DKIM DNS-post:

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

DMARC-post

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

Första inloggning

  1. Öppna din webbläsare och gå till https://yourdomain.com
  2. Ange de grundläggande autentiseringsuppgifter du sparade tidigare
  3. Slutför den initiala installationsguiden
  4. Skapa ditt första e-postkonto

Ställ in S3-kompatibel backup

Konfigurera automatiska säkerhetskopior till S3-kompatibel lagring:

# Skapa AWS credentials-katalog
mkdir -p ~/.aws

# Konfigurera AWS credentials
cat > ~/.aws/credentials <<EOF
[default]
aws_access_key_id = YOUR_ACCESS_KEY_ID
aws_secret_access_key = YOUR_SECRET_ACCESS_KEY
EOF

# Konfigurera AWS inställningar
cat > ~/.aws/config <<EOF
[default]
region = auto
output = json
EOF

# För icke-AWS S3 (som Cloudflare R2), lägg till endpoint URL
echo "endpoint_url = YOUR_S3_ENDPOINT_URL" >> ~/.aws/config

Ställ in backup cron-jobb

# Gör backup-skript körbara
chmod +x "$ROOT_DIR/self-hosting/scripts/backup-mongo.sh"
chmod +x "$ROOT_DIR/self-hosting/scripts/backup-redis.sh"

# Lägg till MongoDB backup cron-jobb (körs dagligen vid midnatt)
(crontab -l 2>/dev/null; echo "0 0 * * * $ROOT_DIR/self-hosting/scripts/backup-mongo.sh >> /var/log/mongo-backup.log 2>&1") | crontab -

# Lägg till cron-jobb för Redis-säkerhetskopiering (körs dagligen kl. 00:30,
# förskjutet 30 minuter efter MongoDB-säkerhetskopian så att de två uppladdningarna inte konkurrerar om samma bandbredd)
(crontab -l 2>/dev/null; echo "30 0 * * * $ROOT_DIR/self-hosting/scripts/backup-redis.sh >> /var/log/redis-backup.log 2>&1") | crontab -

# Verifiera att cron-jobben lades till
crontab -l

Ställ in automatiska uppdateringar för din Forward Email-installation:

# Skapa auto-update kommando
DOCKER_UPDATE_CMD="docker compose -f $DOCKER_COMPOSE_FILE pull && docker compose -f $DOCKER_COMPOSE_FILE up -d"

# Lägg till auto-update cron-jobb (körs dagligen kl 01:00)
(crontab -l 2>/dev/null; echo "0 1 * * * $DOCKER_UPDATE_CMD >> /var/log/autoupdate.log 2>&1") | crontab -

# Verifiera att cron-jobbet lades till
crontab -l

Loggplatser

  • Docker Compose-loggar: docker compose -f $DOCKER_COMPOSE_FILE logs
  • Systemloggar: /var/log/syslog
  • Backup-loggar: /var/log/mongo-backup.log, /var/log/redis-backup.log
  • Auto-update-loggar: /var/log/autoupdate.log

Regelbundna underhållsuppgifter

  1. Övervaka diskutrymme: df -h
  2. Kontrollera tjänststatus: docker compose -f $DOCKER_COMPOSE_FILE ps
  3. Granska loggar: docker compose -f $DOCKER_COMPOSE_FILE logs --tail=100
  4. Uppdatera systempaket: apt update && apt upgrade
  5. Förnya certifikat: Certifikat förnyas automatiskt, men övervaka utgångsdatum

Certifikatförnyelse

Certifikat bör förnyas automatiskt, men du kan förnya manuellt vid behov:

# Manuell certifikatförnyelse
certbot renew

# Kopiera förnyade certifikat
cp /etc/letsencrypt/live/$DOMAIN*/* "$SELF_HOST_DIR/ssl/"

# Starta om tjänster för att använda nya certifikat
docker compose -f "$DOCKER_COMPOSE_FILE" restart

Vanliga problem

1. Docker-tjänsten startar inte

# Kontrollera Docker-status
systemctl status docker

# Försök alternativ start
nohup dockerd >/dev/null 2>/dev/null &

2. Certifikatgenerering misslyckas

  • Säkerställ att portar 80 och 443 är tillgängliga
  • Verifiera att DNS-poster pekar på din server
  • Kontrollera brandväggsinställningar

3. Problem med e-postleverans

  • Verifiera att MX-poster är korrekta
  • Kontrollera SPF-, DKIM- och DMARC-poster
  • Säkerställ att port 25 inte blockeras av din hosting-leverantör

4. Webbgränssnittet är inte åtkomligt

  • Kontrollera brandväggsinställningar: ufw status
  • Verifiera SSL-certifikat: openssl x509 -in $SELF_HOST_DIR/ssl/fullchain.pem -text -noout
  • Kontrollera grundläggande autentiseringsuppgifter

Få hjälp

  1. Håll systemet uppdaterat: Uppdatera regelbundet Ubuntu och paket
  2. Övervaka loggar: Sätt upp loggövervakning och larm
  3. Säkerhetskopiera regelbundet: Testa säkerhetskopierings- och återställningsprocedurer
  4. Använd starka lösenord: Generera starka lösenord för alla konton
  5. Aktivera Fail2Ban: Överväg att installera fail2ban för extra säkerhet
  6. Regelbundna säkerhetsgranskningar: Granska din konfiguration periodiskt

Din Forward Email självhostade installation bör nu vara klar och köras på Ubuntu. Kom ihåg att:

  1. Konfigurera dina DNS-poster korrekt
  2. Testa att skicka och ta emot e-post
  3. Sätt upp regelbundna säkerhetskopior
  4. Övervaka ditt system regelbundet
  5. Håll din installation uppdaterad

För ytterligare konfigurationsalternativ och avancerade funktioner, se den officiella Forward Email-dokumentationen på https://forwardemail.net/self-hosted#configuration.