Ein Self-Hosted-Groupware-Stack aufbauen: SOGo 6, Stalwart und OpenLDAP in Docker

SOGo 6 Evaluation: Ein technischer Deep Dive

Eine gründliche Evaluierung von SOGo 6, der Next.js/Flask-Groupware-Suite, bereitgestellt mit dem Stalwart-Mailserver und OpenLDAP via Docker Compose. Behandelt Architektur, Feature-Implementierung, SSO, MFA und über 1.800 bestandene Tests.

SOGo 6 ist ein grundlegender Neubau der SOGo-Groupware-Suite. Nach 20 Jahren AngularJS und Objective-C in SOGo 5 liefert die neue Version ein Python/Flask-REST-API-Backend, ein Next.js-16-Frontend, PostgreSQL für Persistenz, Redis für Caching und Task-Queues sowie eine richtige Admin-API, die das alte sogo-tool-CLI ersetzt. Die erste öffentliche Beta ist für Sommer 2026 geplant.

Dieser Artikel beschreibt einen produktionsnahen Docker-Compose-Stack, der SOGo 6 mit Stalwart (einem All-in-One-IMAP/SMTP/Sieve-Mailserver) und OpenLDAP (für Benutzerauthentifizierung) verbindet. Der vollständige Quellcode befindet sich unter github.com/tobias-weiss-ai-xr/sogo6-stalwart-openldap-dockerized.

Architektur

Der Stack umfasst acht Services auf einem gemeinsamen Docker-Netzwerk:

Ein Nginx-Reverse-Proxy terminiert TLS auf den Ports 80/443, leitet /api/ an das Flask-Backend weiter und alles andere an das Next.js-Frontend. Ein MailDev-Container fängt ausgehende E-Mails während des Tests ab.

Jeder Service hat Ressourcen-Limits, Health Checks und Abhängigkeitsreihenfolge in der docker-compose.yaml. Der gesamte Speicherbedarf liegt bei etwa 2 GB.

Komponenten im Detail

SOGo 6 Server (Flask)

Das Backend ist eine Gunicorn/Flask-Anwendung mit einer RESTful-API. Sie verbindet sich mit PostgreSQL für Datenpersistenz (Kalender, Adressbücher, Benutzereinstellungen), Redis für Session-Caching und die Celery-Task-Queue sowie OpenLDAP für die Authentifizierung.

Wichtige Umgebungsvariablen:

SOGO_DB_URI: postgresql://sogo:sogo@sogo6-postgres:5432/sogo
SOGO_REDIS_URI: redis://sogo6-redis:6379/0
SOGO_LDAP_URI: ldap://sogo6-ldap:389
SOGO_LDAP_BASE_DN: dc=example,dc=org
SOGO_LDAP_BIND_DN: cn=admin,dc=example,dc=org
SOGO_SMTP_SERVER: sogo6-stalwart
SOGO_SMTP_PORT: 20025

SOGo 6 teilt die Konfiguration in zwei Ebenen:

• Prozess-Einstellungen — obligatorische Boot-Parameter (DB-URI, Redis-URI, Secrets) via Umgebungsvariablen oder process.conf-Datei. Der Container mountet diese read-only unter /etc/sogo/process.conf.
• Dynamische Einstellungen — alles Weitere (IMAP/SMTP-Server, Nutzerquellen, Domain-Overrides, Mail-Filter) in PostgreSQL gespeichert und über die Admin-API oder Web-UI verwaltbar. Werden ohne Neustart angewendet.

Der Server bietet zwei API-Bereiche:

SOGo 6 UI (Next.js)

Das Frontend ist eine Next.js-16-Anwendung (React 19, TypeScript, Tailwind CSS). Die einzige Konfiguration ist die API-Basis-URL — sie leitet alle Datenanfragen an das Flask-Backend weiter. Der UI-Container ist zustandslos und unabhängig skalierbar.

Stalwart Mail Server

Stalwart ist ein in Rust geschriebener All-in-One-Mailserver. Er ersetzt den klassischen Stack aus Postfix + Dovecot + Rspamd durch eine einzige Binärdatei, die alle gängigen Mail-Protokolle unterstützt:

• JMAP — modernes JSON-over-HTTP-Mail-Protokoll mit Push-Benachrichtigungen und WebSocket-Support
• IMAP4rev2 mit IMAP4rev1-Fallback
• SMTP mit Sieve-Scripting (jede IANA-registrierte Erweiterung)
• POP3 mit STLS für Legacy-Clients
• ManageSieve für nutzerverwaltete serverseitige Filter

In diesem Stack verwendet Stalwart PostgreSQL als Storage-Backend (separate Datenbank von SOGo). Die Konfiguration ist eine einzelne JSON-Datei:

{
  "@type": "PostgreSql",
  "host": "sogo6-postgres",
  "port": 5432,
  "database": "stalwart",
  "authUsername": "stalwart",
  "authSecret": {
    "@type": "Value",
    "secret": "stalwart_sogo6_2026"
  }
}

Stalwart v0.16 (hier verwendet) führte eine vereinheitlichte JMAP-basierte Management-API und einen stalwart-cli apply-Befehl für deklarative Konfiguration ein — passt natürlich zu Infrastructure-as-Code-Workflows.

Port-Mappings exposen alle Mail-Protokolle zum Host für Client-Tests:

OpenLDAP

OpenLDAP stellt das Benutzerverzeichnis bereit. Das Docker-Image wird mit eingebauten Seed-Daten gebaut — drei Testnutzer (zwei Standard, ein Admin) werden aus einer LDIF-Datei beim ersten Start geladen.

dn: uid=testuser@example.org,ou=users,dc=example,dc=org
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: shadowAccount
uid: testuser@example.org
cn: Test User
sn: User
mail: testuser@example.org
userPassword: password123

Der Health Check führt eine LDAP-Suche gegen den Base-DN durch, um zu verifizieren, dass slapd reagiert.

Ein Hinweis: Die ch_calloc-Assertion von OpenLDAP schlägt fehl, wenn Docker ein hohes ulimit -n setzt. Das Custom-Entrypoint-Skript umgeht dies, indem es ulimit -n 1024 vor dem Start von slapd setzt.

Nginx Reverse Proxy

Nginx terminiert TLS (selbstsignierte Zertifikate, generiert vom mitgelieferten gen-certs.sh-Skript) und leitet Traffic weiter:

• /api/* → sogo6-server:5000 (Flask-Backend)
• /* → sogo6-ui:3000 (Next.js-Frontend)
• HTTP auf Port 80 leitet zu HTTPS weiter

Die Konfiguration unterstützt WebSocket-Upgrade-Header für Server-Sent Events und zukünftige Echtzeit-Features.

Interaktion der Komponenten

Authentifizierungs-Flow

1. Nutzer gibt Anmeldedaten im Next.js-UI ein
2. Frontend sendet POST an /api/user/v1/auth/login
3. Flask-Backend bindet an OpenLDAP mit dem konfigurierten SOGO_LDAP_BIND_DN und verifiziert das Passwort gegen den inetOrgPerson-Eintrag
4. Bei Erfolg gibt das Backend ein JWT-Token zurück
5. Nachfolgende API-Aufrufe enthalten das JWT im Authorization: Bearer-Header

Mail-Flow

1. Nutzer verfasst eine E-Mail im SOGo-UI
2. Flask-Backend sendet via SMTP an Stalwart (sogo6-stalwart:25)
3. In der Produktion liefert Stalwart an externe Empfänger aus. In diesem Test-Stack fängt MailDev alle ausgehenden E-Mails auf Port 25 ab und stellt eine Web-UI unter http://localhost:1080 zur Inspektion bereit
4. Eingehende E-Mails (in der Produktion) werden von Stalwart gespeichert und via IMAP dem SOGo-Backend bereitgestellt

Kalender und Kontakte

SOGo 6 implementiert CalDAV- und CardDAV-Server. Kalenderereignisse und Adressbucheinträge werden in PostgreSQL gespeichert. LDAP-Kontakte werden in Echtzeit aus OpenLDAP gelesen.

Deployment

Voraussetzungen

• Docker und Docker Compose v2.20+
• Git
• ~2 GB freier RAM (getestet auf einem 1-GB-DigitalOcean-Droplet)

Schritt 1: Klonen und Bauen

git clone https://github.com/tobias-weiss-ai-xr/sogo6-stalwart-openldap-dockerized.git
cd sogo6-stalwart-openldap-dockerized
bash sogo6/scripts/setup.sh

Das Setup-Skript:

• Klont die SOGo6-UI- und SOGo6-server-Repositories
• Baut Docker-Images für Frontend und Backend
• Generiert einen Secrets-Vault (secrets/sogo6.vault.env, gitignored)
• Generiert selbstsignierte TLS-Zertifikate (sogo6/nginx/certs/)
• Baut das Custom-OpenLDAP-Image mit Seed-Daten

Schritt 2: Stack starten

docker compose up -d

Docker Compose startet Services in Abhängigkeitsreihenfolge — PostgreSQL, Redis, LDAP und Stalwart werden healthy, bevor das Flask-Backend startet, und das Backend muss healthy sein, bevor das Next.js-Frontend startet.

Schritt 3: Systemkonfiguration initialisieren

bash sogo6/scripts/init-sogo6.sh

Dieses Skript ruft die Admin-API auf, um Folgendes zu konfigurieren:

• LDAP als Authentifizierungsquelle
• Stalwart als IMAP/SMTP-Server
• Standard-Domain-Einstellungen für example.org
• Systemparameter, die erforderlich sind, bevor die Benutzer-API Anfragen annimmt

Schritt 4: Verifikation

docker compose ps                          # Alle 8 Services healthy
curl http://localhost:3000/env              # Next.js-Frontend antwortet
curl http://localhost:5001/api/user/v1/system  # Flask-API antwortet
curl http://localhost:1080                  # MailDev-Web-UI

Zugriffspunkte

Test-Zugangsdaten

Testabdeckung

Das Repository liefert 129 shell-basierte Integrationstests, die nichts weiter als bash, curl und openssl benötigen. Sie umfassen:

Alles ausführen mit bash tests/run-all-tests.sh. Python-Integrationstests (pytest + psycopg2) und Playwright-E2E-Tests sind als optionale Extras verfügbar.

Betrieb

Secrets-Management

bash sogo6/scripts/manage-secrets.sh          # Vault generieren
bash sogo6/scripts/manage-secrets.sh --list     # Secrets maskiert auflisten
bash sogo6/scripts/manage-secrets.sh --env-file  # Export für docker-compose

Backup

bash sogo6/scripts/backup.sh

Erstellt ein zeitgestempeltes Archiv aller Docker-Volumes (PostgreSQL, Redis, Stalwart, LDAP-Daten und -Konfiguration) in ./backups/.

Datenbank-Reset

docker compose down -v
docker compose up -d
bash sogo6/scripts/init-sogo6.sh

TLS-Zertifikate

Für Produktions-Tests die selbstsignierten Zertifikate in sogo6/nginx/certs/ durch echte Zertifikate ersetzen und neu generieren:

bash sogo6/scripts/gen-certs.sh

SOGo 5 vs. SOGo 6: Was hat sich geändert?

Das SOGo-Team kündigte auf der FOSDEM 2026 an, dass die öffentliche Beta für Sommer 2026 geplant ist. Das erste Release umfasst die vollständige Web-Anwendung (E-Mail, Kalender, Kontakte), wird aber zunächst keinen Desktop-Sync-Server enthalten.

Quellcode

Der gesamte Code ist Open Source unter der MIT-Lizenz:

• Dockerisierter Stack: github.com/tobias-weiss-ai-xr/sogo6-stalwart-openldap-dockerized
• SOGo 6 UI: github.com/tobias-weiss-ai-xr/SOGo6-UI
• SOGo 6 Server: github.com/tobias-weiss-ai-xr/SOGo6-server
• SOGo 5 Produktions-Image: github.com/tobias-weiss-ai-xr/docker-sogo