In einer Welt, in der Datenschutz und Kontrolle über die eigene Kommunikation immer wichtiger werden, suchen immer mehr Menschen nach Alternativen zu zentralisierten Messaging-Diensten. Die gute Nachricht: Sie müssen sich nicht auf die großen Tech-Konzerne verlassen. Sie können Ihren ganz persönlichen, sicheren und datenschutzfreundlichen Messenger-Server betreiben. Und das Beste daran? Mit ejabberd und Docker ist das einfacher als Sie vielleicht denken!
Dieser umfassende Leitfaden führt Sie Schritt für Schritt durch die Einrichtung Ihres eigenen ejabberd XMPP-Servers in einem Docker Container. Egal, ob Sie absolute Kontrolle über Ihre Daten wünschen, ein sicheres Kommunikationsmittel für Ihr Team benötigen oder einfach neugierig auf die Technik sind – hier erfahren Sie alles, was Sie wissen müssen.
Warum ein eigener Messenger-Server? Datenschutz und Kontrolle
Die Entscheidung für einen eigenen Messenger-Server ist oft motiviert durch den Wunsch nach Datenschutz und digitale Souveränität. Bei populären Messaging-Diensten wissen Sie nie genau, wer Ihre Metadaten einsehen oder gar auf Ihre Kommunikationsinhalte zugreifen könnte. Mit Ihrem eigenen Server haben Sie die Zügel in der Hand:
- Volle Kontrolle über Ihre Daten: Sie entscheiden, wo Ihre Daten gespeichert werden und wer Zugriff darauf hat.
- Unabhängigkeit: Keine Abhängigkeit von den AGBs oder plötzlichen Richtlinienänderungen großer Anbieter.
- Sicherheit: Mit der richtigen Konfiguration und End-to-End-Verschlüsselung (z.B. OMEMO) können Sie ein extrem hohes Sicherheitsniveau erreichen.
- Anpassbarkeit: Erweitern Sie Ihren Server mit Modulen und Funktionen, die Sie wirklich benötigen.
- Keine Werbung: Ein werbefreies Kommunikationserlebnis für Sie und Ihre Nutzer.
ejabberd und Docker: Das Dreamteam für Ihren Messenger
Wenn es um selbst gehostete Messenger-Server geht, ist XMPP (Extensible Messaging and Presence Protocol) der Goldstandard. Es ist ein offenes, dezentrales Protokoll, das von einer Vielzahl von Clients und Servern unterstützt wird. Und unter den XMPP-Servern ist ejabberd ein Gigant.
Warum ejabberd?
- Leistungsstark und Skalierbar: ejabberd ist bekannt für seine Robustheit und kann Millionen von Benutzern und Verbindungen verwalten.
- Feature-Reich: Es unterstützt alle wichtigen XMPP-Erweiterungen (XEPs), einschließlich Gruppenchats (MUC), Dateitransfer, Offlinenachrichten, Lesebestätigungen, OMEMO-Verschlüsselung und vieles mehr.
- Open Source: Die Software ist quelloffen, was Transparenz und eine große Community für Unterstützung und Weiterentwicklung bedeutet.
- Einfache Verwaltung: Eine intuitive Weboberfläche und Befehlszeilentools erleichtern die Administration.
Warum Docker?
Die Einrichtung von Serversoftware kann manchmal komplex sein. Hier kommt Docker ins Spiel:
- Isolation: Docker-Container kapseln die Anwendung und ihre Abhängigkeiten, sodass Konflikte mit anderen Diensten auf Ihrem System vermieden werden.
- Portabilität: Einmal eingerichtet, kann Ihr ejabberd-Container problemlos auf jedem anderen System mit Docker laufen.
- Einfache Bereitstellung: Mit Docker Compose definieren Sie Ihre gesamte Serverumgebung in einer einzigen Datei und starten sie mit einem Befehl.
- Konsistenz: Die Umgebung ist immer gleich, was das Debugging und die Wartung vereinfacht.
- Ressourceneffizienz: Container sind leichtgewichtig und verbrauchen weniger Ressourcen als virtuelle Maschinen.
Voraussetzungen für Ihren ejabberd-Server
Bevor wir loslegen, stellen Sie sicher, dass Sie die folgenden Punkte erfüllt haben:
- Ein Linux-Server: Dies kann ein virtueller Server (VPS), ein dedizierter Server oder sogar ein leistungsstarker Raspberry Pi sein. Der Server sollte über eine öffentliche IP-Adresse verfügen.
- Docker und Docker Compose: Diese müssen auf Ihrem Server installiert sein. Anleitungen dazu finden Sie auf der offiziellen Docker-Website.
- Ein Domainname: Sie benötigen einen registrierten Domainnamen (z.B.
chat.ihredomain.de), unter dem Ihr Messenger-Server erreichbar sein wird. - DNS-Einträge: Sie müssen A-Records für Ihre Domain erstellen, die auf die IP-Adresse Ihres Servers zeigen. Später benötigen wir auch SRV-Records für die XMPP-Diensterkennung.
- Offene Ports: Stellen Sie sicher, dass die Ports 5222 (XMPP-Client), 5269 (XMPP-Server zu Server) und 5280/5281 (Web-Admin/HTTP-Upload) in Ihrer Firewall geöffnet sind und auf Ihren Server weitergeleitet werden. Port 80 und 443 sind ebenfalls empfehlenswert für Let’s Encrypt.
Schritt-für-Schritt-Anleitung: ejabberd im Docker Container einrichten
Schritt 1: Projektverzeichnis erstellen
Melden Sie sich per SSH auf Ihrem Server an und erstellen Sie ein Verzeichnis für Ihr Projekt. Wechseln Sie in dieses Verzeichnis:
mkdir ejabberd-server
cd ejabberd-serverSchritt 2: `docker-compose.yml` erstellen
Diese Datei definiert Ihre Docker-Dienste. Erstellen Sie eine Datei namens `docker-compose.yml` in Ihrem Projektverzeichnis und fügen Sie den folgenden Inhalt ein. Passen Sie <Ihre_Domain> und <Admin_JID> an.
version: '3.8'
services:
ejabberd:
image: ejabberd/ecs:latest # Oder eine spezifische Version, z.B. 23.10
container_name: ejabberd
hostname: <Ihre_Domain> # Wichtig für ejabberd's interne Host-Erkennung
ports:
- "5222:5222" # Client-Verbindung (XMPP)
- "5269:5269" # Server-zu-Server-Verbindung (XMPP)
- "5280:5280" # BOSH / HTTP File Upload (ohne TLS)
- "5281:5281" # Admin-Oberfläche / BOSH / HTTP File Upload (mit TLS)
- "80:80" # Für Let's Encrypt ACME Challenge
- "443:443" # Für Let's Encrypt ACME Challenge (falls benötigt)
volumes:
- ./ejabberd.yml:/home/ejabberd/conf/ejabberd.yml:ro
- ./data:/home/ejabberd/data
- ./logs:/home/ejabberd/logs
- ./upload:/home/ejabberd/upload # Für mod_http_upload
- ./certs:/home/ejabberd/certs # Für Let's Encrypt Zertifikate
environment:
# Optional: Legt den Hostnamen fest, falls nicht über hostname im Compose
- E JABBERD_HOSTNAME=<Ihre_Domain>
# Optional: Liste der Administratoren. Trennen Sie mehrere mit Komma.
- E JABBERD_ADMINS=<Admin_JID>@<Ihre_Domain>
# Autorisierungsmethode: internal, external, ldap, etc.
- E JABBERD_AUTH_METHOD=internal
# ACME-Einstellungen für Let's Encrypt
- [email protected]
- ACME_DOMAIN_SECRET=<Ihre_Domain>
- ACME_UPDATE_INTERVAL=60d
restart: unless-stopped
Wichtige Anpassungen:
- Ersetzen Sie
<Ihre_Domain>durch Ihren tatsächlichen Domainnamen (z.B.chat.example.com). - Ersetzen Sie
<Admin_JID>durch den Benutzernamen, den Sie für Ihren Administrator-Account verwenden möchten (z.B.admin). - Ersetzen Sie
[email protected]durch Ihre E-Mail-Adresse für Let’s Encrypt Benachrichtigungen.
Schritt 3: `ejabberd.yml` (Konfiguration) anpassen
Dies ist die wichtigste Konfigurationsdatei für ejabberd. Erstellen Sie eine Datei namens `ejabberd.yml` im selben Verzeichnis wie Ihre `docker-compose.yml` und fügen Sie den folgenden Inhalt ein. Dies ist eine Basis-Konfiguration, die Sie später erweitern können.
# Minimal ejabberd configuration for Docker
hosts:
- "<Ihre_Domain>" # Ihr Domainname hier
loglevel: info
# Authentication method
auth_method: internal
# List of administrators
acl:
admin:
user:
- "<Admin_JID>": "<Ihre_Domain>" # Ihr Admin-Benutzername und Domain
# Listener ports
listen:
-
port: 5222
ip: "::"
module: ejabberd_c2s
starttls: true
max_stanza_size: 262144
protocol_options:
- "no_sslv3"
- "no_tlsv1"
- "no_tlsv1_1"
tls: true
## Zertifikate werden durch ACME Modul verwaltet
-
port: 5269
ip: "::"
module: ejabberd_s2s_in
tls: true
protocol_options:
- "no_sslv3"
- "no_tlsv1"
- "no_tlsv1_1"
-
port: 5280
ip: "::"
module: ejabberd_http
request_handlers:
"/websocket": ejabberd_http_ws
"/bosh": ejabberd_http_bosh
"/upload": mod_http_upload
web_admin: true # Wichtig für die Admin-Oberfläche
-
port: 5281
ip: "::"
module: ejabberd_http
tls: true
request_handlers:
"/websocket": ejabberd_http_ws
"/bosh": ejabberd_http_bosh
"/admin": ejabberd_web_admin
"/upload": mod_http_upload
web_admin: true
# Modules
modules:
mod_adhoc: {}
mod_admin_extra: {}
mod_announce:
access: admin
mod_blocking: {}
mod_bosh: {}
mod_carboncopy: {}
mod_caps: {}
mod_csi: {}
mod_disco: {}
mod_http_upload:
host: "<Ihre_Domain>" # Der Hostname für Dateiuploads
max_size: 52428800 # 50 MB
mod_last: {}
mod_mam: # Message Archive Management
default: always
mod_muc:
host: "conference.<Ihre_Domain>" # Hostname für Gruppenchats
access:
- allow
rooms_log: true
mod_muc_admin: {}
mod_offline:
access_max_user_msgs: 5000
mod_ping: {}
mod_private: {}
mod_proxy65: # Für P2P-Dateitransfer
host: "proxy.<Ihre_Domain>"
access:
- allow
mod_pubsub:
access_createnode:
- allow
plugins:
- "flat"
- "pep" # c.f. XEP-0163: Personal Eventing Protocol
mod_register:
# Denken Sie darüber nach, dies auf "none" oder "no_vjud" zu setzen,
# sobald Sie Ihre ersten Benutzer erstellt haben, um offene Registrierung zu verhindern.
# access:
# - deny
# Wenn Sie offene Registrierung möchten, lassen Sie dies auskommentiert oder setzen Sie es auf "all".
# register_mode: all
# Wenn Sie nur Admins registrieren lassen möchten
register_mode: no_vjud # oder `none` wenn Sie die Registrierung komplett schließen
mod_roster: {}
mod_s2s_auth: {}
mod_sd_url: {}
mod_shared_roster: {}
mod_stats: {}
mod_stream_management: {}
mod_time: {}
mod_vcard: {}
mod_vcard_xupdate: {}
mod_version: {}
mod_acme: {} # Modul für Let's Encrypt Integration
Wichtige Anpassungen:
- Ersetzen Sie erneut
<Ihre_Domain>und<Admin_JID>. - Die
mod_acme: {}Zeile ist entscheidend für die automatische Let’s Encrypt Integration. - Überprüfen Sie
mod_register. Standardmäßig ist die Registrierung offen. Für einen privaten Server sollten Sieregister_mode: no_vjudoderregister_mode: noneeinstellen und Benutzer manuell über die Admin-Oberfläche oderejabberdctlerstellen.
Schritt 4: Server starten und Administrator erstellen
Nachdem Sie die `docker-compose.yml` und `ejabberd.yml` erstellt und angepasst haben, starten Sie den ejabberd-Container:
docker-compose up -dDieser Befehl lädt das ejabberd-Image herunter (falls noch nicht vorhanden), erstellt die Container und startet sie im Hintergrund (-d für detached mode). Überprüfen Sie mit docker-compose logs ejabberd ob der Start erfolgreich war und keine kritischen Fehler auftreten.
Nachdem der Container läuft, erstellen Sie den Administrator-Benutzer. Ersetzen Sie <Admin_JID>, <Ihre_Domain> und <Ihr_Admin_Passwort>:
docker-compose exec ejabberd ejabberdctl register <Admin_JID> <Ihre_Domain> <Ihr_Admin_Passwort>Zum Beispiel: docker-compose exec ejabberd ejabberdctl register admin chat.example.com supergeheim123
Schritt 5: SSL/TLS-Zertifikate einrichten (Let’s Encrypt mit ejabberd ACME)
SSL/TLS-Zertifikate sind unerlässlich für sichere Kommunikation. Glücklicherweise integriert ejabberd den ACME-Client (Automatic Certificate Management Environment), um Zertifikate von Let’s Encrypt automatisch zu beziehen und zu erneuern.
Im `docker-compose.yml` haben wir die Umgebungsvariablen ACME_EMAIL und ACME_DOMAIN_SECRET gesetzt, und in der `ejabberd.yml` das Modul mod_acme aktiviert. ejabberd wird versuchen, Zertifikate zu beziehen, sobald es startet und die Domain über HTTP Port 80 erreichbar ist. Es kann einen Moment dauern, bis das Zertifikat heruntergeladen wird.
Sie können den Status in den ejabberd-Logs verfolgen: docker-compose logs ejabberd. Suchen Sie nach Meldungen, die auf ACME oder Zertifikate hinweisen. Nach erfolgreichem Abruf wird ejabberd die neuen Zertifikate automatisch laden.
Schritt 6: Admin-Oberfläche prüfen
Öffnen Sie Ihren Webbrowser und navigieren Sie zur Admin-Oberfläche Ihres ejabberd-Servers:
https://<Ihre_Domain>:5281/admin/
Melden Sie sich mit Ihrem Administrator-Benutzernamen (z.B. [email protected]) und dem von Ihnen festgelegten Passwort an. Hier können Sie Benutzer verwalten, Module konfigurieren und den Server überwachen.
Schritt 7: DNS-SRV-Records einrichten (Ganz Wichtig!)
Damit XMPP-Clients und -Server Ihren Messenger-Dienst automatisch finden können, müssen Sie SRV-Records in den DNS-Einstellungen Ihrer Domain konfigurieren. Dies ist ein häufig übersehener, aber absolut entscheidender Schritt.
Fügen Sie die folgenden SRV-Records für <Ihre_Domain> bei Ihrem Domain-Provider hinzu. Die Priorität und das Gewicht können beliebig sein (z.B. 0 5), der Port muss stimmen:
_xmpp-client._tcp.<Ihre_Domain>. IN SRV 0 5 5222 <Ihre_Domain>.
_xmpp-server._tcp.<Ihre_Domain>. IN SRV 0 5 5269 <Ihre_Domain>.
Manche DNS-Provider verlangen, dass der Domainname ohne den abschließenden Punkt eingegeben wird, andere nicht. Überprüfen Sie die spezifischen Anforderungen Ihres Providers.
Es kann einige Stunden dauern, bis diese DNS-Änderungen weltweit propagiert sind.
Erste Schritte und weitere Konfigurationen
Benutzerregistrierung
Wie bereits erwähnt, ist die Standardeinstellung in ejabberd (und in unserer Konfiguration register_mode: no_vjud) so, dass neue Benutzer nur durch Administratoren erstellt werden können. Wenn Sie dies beibehalten möchten, erstellen Sie neue Benutzer über die Admin-Oberfläche oder mit dem Befehl:
docker-compose exec ejabberd ejabberdctl register <username> <Ihre_Domain> <password>Wenn Sie eine offene Registrierung für alle erlauben möchten (was für private Server selten empfohlen wird), ändern Sie register_mode: no_vjud in ejabberd.yml zu register_mode: all und starten Sie den Container neu.
Client-Verbindung
Sobald Ihr Server läuft und die SRV-Records propagiert sind, können Sie sich mit jedem XMPP-Client verbinden. Empfehlungen:
- Conversations (Android): Exzellenter Client mit OMEMO-Verschlüsselung, File-Transfer und vielen Features.
- Gajim (Desktop – Linux/Windows): Leistungsstarker und funktionsreicher Desktop-Client.
- Pardus (iOS): Guter Open-Source-Client für iOS.
- Dino (Linux): Moderner und benutzerfreundlicher Client.
Geben Sie einfach Ihre JID (Jabber ID, z.B. [email protected]) und Ihr Passwort ein. Dank der SRV-Records sollte der Client den Server automatisch finden.
Wichtige Module
Wir haben in unserer `ejabberd.yml` bereits einige wichtige Module aktiviert. Hier eine kurze Erklärung der wichtigsten:
- mod_mam (Message Archive Management): Speichert Chat-Verläufe auf dem Server, sodass Sie von verschiedenen Geräten darauf zugreifen können.
- mod_muc (Multi-User Chat): Ermöglicht Gruppenchats.
- mod_http_upload: Ermöglicht das Hochladen von Dateien (Bilder, Dokumente) über HTTP.
- mod_proxy65: Ermöglicht den direkten Peer-to-Peer-Dateitransfer zwischen Clients.
- mod_carbons: Synchronisiert Nachrichten über alle Ihre verbundenen Geräte.
ejabberd bietet Hunderte von Modulen. Entdecken Sie die Möglichkeiten in der ejabberd-Dokumentation, um Ihren Server perfekt auf Ihre Bedürfnisse zuzuschneiden.
Sicherheitstipps
- Starke Passwörter: Verwenden Sie einzigartige, komplexe Passwörter für alle Benutzer, insbesondere für Administratoren.
- Regelmäßige Updates: Halten Sie Ihr Docker-Image (
ejabberd/ecs:latest) und Ihre Server-Software (Docker, OS) stets aktuell. - Firewall: Beschränken Sie den Zugriff auf Ihren Server nur auf die benötigten Ports.
- Backup: Sichern Sie regelmäßig Ihre `data`, `logs`, `upload` und `certs` Verzeichnisse.
- OMEMO: Ermutigen Sie Ihre Benutzer, Clients zu verwenden, die OMEMO (End-to-End-Verschlüsselung) unterstützen und diese Funktion zu aktivieren.
Troubleshooting und häufige Probleme
- Container startet nicht: Überprüfen Sie die Syntax Ihrer `docker-compose.yml` und `ejabberd.yml`. Schauen Sie in die Logs mit
docker-compose logs ejabberd. - Keine Verbindung zum Server:
- Überprüfen Sie, ob die Ports in Ihrer Server-Firewall geöffnet sind.
- Stellen Sie sicher, dass Ihre DNS-Einträge (A-Record und SRV-Records) korrekt sind und propagiert wurden (
dig SRV _xmpp-client._tcp.<Ihre_Domain>). - Vergewissern Sie sich, dass ejabberd auf den richtigen Ports lauscht (siehe `ejabberd.yml`).
- Zertifikatsfehler (SSL/TLS):
- Stellen Sie sicher, dass Port 80 auf Ihren Server weitergeleitet wird, da Let’s Encrypt diesen für die ACME-Challenge benötigt.
- Überprüfen Sie die
ACME_EMAILundACME_DOMAIN_SECRETin Ihrer `docker-compose.yml`. - Schauen Sie in die ejabberd-Logs nach Fehlern im Zusammenhang mit ACME.
- Benutzer kann sich nicht anmelden:
- Überprüfen Sie Benutzernamen und Passwort.
- Stellen Sie sicher, dass der Benutzer auf dem Server registriert ist.
- Prüfen Sie, ob
auth_method: internalkorrekt gesetzt ist.
Fazit
Herzlichen Glückwunsch! Sie haben nun eine umfassende Anleitung zur Einrichtung Ihres eigenen ejabberd Messenger-Servers in einem Docker Container durchgearbeitet. Sie sind auf dem besten Weg, Ihre Kommunikation selbst in die Hand zu nehmen, Ihre Daten zu schützen und ein leistungsstarkes und flexibles Messaging-System zu betreiben.
Die anfängliche Einrichtung mag ein wenig einschüchternd wirken, aber mit dieser Schritt-für-Schritt-Anleitung und der Kombination aus der Stabilität von ejabberd und der Einfachheit von Docker ist es für jeden mit grundlegenden Linux-Kenntnissen machbar. Nehmen Sie die Kontrolle über Ihre digitale Kommunikation zurück und genießen Sie die Freiheit und Sicherheit, die ein eigener XMPP-Server bietet. Viel Erfolg beim Chatten!