Mattermost Self-Hosted Installation – Slack-Alternative für Teams

Was ist Mattermost?

Mattermost ist eine selbst gehostete, Open-Source Team Messaging und Collaboration Plattform. Sie bietet eine Slack-ähnliche Oberfläche mit vollständiger Kontrolle über Ihre Daten und Infrastruktur.

Mattermost Editionen

Edition	Kosten	Features
Community (Free)	Kostenlos	Grundlegende Team-Messaging, bis 100 Teams
Professional	$100/Monat	LDAP/AD, Advanced Integrations, Priority Support
Enterprise	Custom	Clustering, Advanced Security, Compliance Features

Diese Anleitung konzentriert sich auf die Community Edition, die kostenlos ist und die meisten Funktionen bietet.

Hauptfunktionen

• Teams und Kanäle: Organisieren Sie Kommunikation in Teams und Kanälen
• Direct Messages: Private Gespräche zwischen Nutzern
• Threads: Gesprächsthreads zur besseren Struktur
• Integrationen: GitHub, GitLab, Jira, Jenkins, etc.
• Bots: Automatisierung durch Custom Bots
• Webhooks: Eingehende und ausgehende Webhooks
• File Sharing: Gemeinsame Nutzung und Speicherung von Dateien
• Enterprise Features: LDAP/AD, SAML SSO, Audit Logs (Professional/Enterprise)

Systemanforderungen

Komponente	Minimum	Empfohlen
CPU	2 Kerne	4+ Kerne
RAM	2 GB	4-8 GB
Speicher	10 GB	50+ GB
Benutzer	Bis 500	100-1000+

Installation mit Docker Compose

Schritt 1: Verzeichnisse vorbereiten

mkdir -p /opt/mattermost
cd /opt/mattermost
mkdir -p postgres_data mattermost_data

Schritt 2: .env Datei erstellen

Erstellen Sie /opt/mattermost/.env:

COMPOSE_PROJECT_NAME=mattermost

# PostgreSQL
POSTGRES_IMAGE_TAG=13-alpine
DB_PORT=5432
POSTGRES_DB=mattermost
POSTGRES_USER=mmuser
POSTGRES_PASSWORD=mmuser_password_secure
POSTGRES_INITDB_ARGS="-c max_connections=500"

# Mattermost
MATTERMOST_IMAGE_TAG=v7.10
MM_SERVICESETTINGS_SITEURL=https://chat.example.com
MM_SERVICESETTINGS_LISTEN_ADDRESS=:8065
MM_SERVICESETTINGS_FORWARD_80_TO_443=true

Schritt 3: docker-compose.yml erstellen

version: '3.8'

services:
  postgres:
    image: postgres:13-alpine
    container_name: mattermost-postgres
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    pids_limit: 200
    read_only: true
    tmpfs:
      - /run
      - /tmp
    volumes:
      - /opt/mattermost/postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_INITDB_ARGS: ${POSTGRES_INITDB_ARGS}
    networks:
      - mattermost-network

  mattermost:
    image: mattermost/mattermost-team-edition:${MATTERMOST_IMAGE_TAG:-latest}
    container_name: mattermost-app
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    pids_limit: 200
    depends_on:
      - postgres
    ports:
      - "8065:8065"
    volumes:
      - /opt/mattermost/mattermost_data:/mattermost/data
      - /opt/mattermost/mattermost_logs:/mattermost/logs
      - /opt/mattermost/mattermost_config:/mattermost/config
    environment:
      DB_HOST: postgres
      DB_PORT_NUMBER: 5432
      MM_DBNAME: ${POSTGRES_DB}
      MM_SQLSETTINGS_DRIVERNAME: postgres
      MM_SQLSETTINGS_DATASOURCE: "postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}?sslmode=disable&connect_timeout=10"
      MM_SERVICESETTINGS_SITEURL: ${MM_SERVICESETTINGS_SITEURL}
      MM_SERVICESETTINGS_LISTEN_ADDRESS: ${MM_SERVICESETTINGS_LISTEN_ADDRESS}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8065/api/v4/system/ping"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 40s
    networks:
      - mattermost-network

networks:
  mattermost-network:
    driver: bridge

volumes:
  postgres_data:
  mattermost_data:

Schritt 4: Mattermost starten

cd /opt/mattermost
docker-compose up -d

# Logs überprüfen
docker-compose logs -f mattermost

Mattermost ist jetzt verfügbar unter: http://localhost:8065

System Console Setup

Erste Admin-Registrierung

1. Öffnen Sie http://localhost:8065 im Browser
2. Klicken Sie "Create an account"
3. Füllen Sie das Registrierungsformular aus
4. Sie werden automatisch als erster Admin registriert
5. Nach Login: Gehen Sie zu System Console (Hamburger-Menü → Administration)

Systemkonfiguration

In der System Console können Sie konfigurieren:

• Display: Site-Name, Theme, Sprache
• Users & Teams: Registrierung, Team-Einstellungen
• Authentication: LDAP/AD, SAML, Google OAuth, etc.
• Integrations: Webhooks, Bots, Plugins
• File Storage: Lokal oder MinIO/S3
• Email: SMTP für Benachrichtigungen

Nginx Reverse Proxy mit WebSocket

Wichtig: WebSocket-Support ist für Echtzeit-Messaging erforderlich!

server {
    listen 80;
    server_name chat.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name chat.example.com;

    ssl_certificate /etc/letsencrypt/live/chat.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/chat.example.com/privkey.pem;

    client_max_body_size 100M;

    location / {
        proxy_pass http://localhost:8065;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket Support (critical!)
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400;
    }
}

Aktivieren und SSL einrichten:

ln -s /etc/nginx/sites-available/mattermost /etc/nginx/sites-enabled/
nginx -t
systemctl restart nginx

certbot certonly --nginx -d chat.example.com

Teams und Kanäle erstellen

Team erstellen

1. Klicken Sie auf "Create a team" (neben Team-Liste)
2. Geben Sie Team-Namen und URL ein
3. Wählen Sie Typ: "Open" oder "Private"
4. Team wird erstellt

Kanäle in Team erstellen

1. Im Team: Klicken Sie "+" neben Kanälen
2. Wählen Sie "Create new channel"
3. Konfigurieren Sie:
   • Name: z.B. "general", "development", "support"
   • Type: Public oder Private
   • Description: Zweck des Kanals
4. Klicken Sie "Create Channel"

Benutzererverwaltung

Benutzer manuell hinzufügen

1. Gehen Sie zu System Console → Users
2. Klicken Sie "Invite Users"
3. Geben Sie Email-Adressen ein (komma-separiert)
4. Senden Sie Einladungen

LDAP/AD Integration (Professional/Enterprise)

Für automatische Benutzerverwaltung in größeren Organisationen:

1. Gehen Sie zu System Console → Authentication → LDAP
2. Aktivieren Sie "Enable LDAP"
3. Konfigurieren Sie:
   • LDAP Server: ldap.example.com
   • Port: 389 oder 636 (für LDAPS)
   • Bind Username/Password: LDAP Admin-Credentials
   • Base DN: dc=example,dc=com
   • User Search Filter: (uid={{.Input}})
4. Speichern und testen

Email Benachrichtigungen konfigurieren

SMTP Setup

1. Gehen Sie zu System Console → Environment → SMTP
2. Aktivieren Sie "Enable SMTP"
3. Konfigurieren Sie:
   • SMTP Server: smtp.example.com
   • SMTP Port: 587 (TLS) oder 465 (SSL)
   • SMTP Username: Ihre Email
   • SMTP Password: Passwort oder App-Passwort
   • Enable TLS: Ja
   • From Email: noreply@example.com
4. Klicken Sie "Test Connection"
5. Speichern

Integrationen und Webhooks

Ausgehende Webhooks

Senden Sie Mattermost-Events an externe Services:

1. Gehen Sie zu System Console → Integrations → Webhooks (Outgoing)
2. Klicken Sie "Add Outgoing Webhook"
3. Konfigurieren Sie:
   • Title: "GitHub Notifications"
   • Callback URL: https://mattermost.example.com/hooks/incoming/...
   • Trigger Words: @github (optional)
   • Channel: #general

Eingehende Webhooks

Externe Services können Nachrichten an Mattermost senden:

1. Gehen Sie zu System Console → Integrations → Webhooks (Incoming)
2. Klicken Sie "Add Incoming Webhook"
3. Wählen Sie Kanal
4. Kopieren Sie die Webhook-URL

Beispiel - Nachricht über curl senden:

curl -i -X POST -d '{"text":"Deployment erfolgreich!"}' \
  https://chat.example.com/hooks/xxxxxxxxxxxxxxxxxxxxx

Backup und Restore

Datenbankbackup

#!/bin/bash
# /usr/local/bin/mattermost-backup.sh

BACKUP_DIR="/backup/mattermost"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR

# PostgreSQL Dump
docker exec mattermost-postgres pg_dump -U mmuser mattermost | \
    gzip > $BACKUP_DIR/mattermost-db-$DATE.sql.gz

# Mattermost Daten sichern
tar -czf $BACKUP_DIR/mattermost-data-$DATE.tar.gz /opt/mattermost/mattermost_data

echo "Backup completed: $BACKUP_DIR"

In Crontab einbinden:

# Täglich um 3 Uhr
0 3 * * * /usr/local/bin/mattermost-backup.sh

Restore durchführen

cd /opt/mattermost

# Database restore
gunzip -c /backup/mattermost/mattermost-db-20240405_030000.sql.gz | \
  docker exec -i mattermost-postgres psql -U mmuser mattermost

# Data restore
tar -xzf /backup/mattermost/mattermost-data-20240405_030000.tar.gz

Updates und Maintenance

Mattermost aktualisieren

cd /opt/mattermost

# Image pullen
docker-compose pull

# Container neu starten
docker-compose up -d

# Logs überprüfen
docker-compose logs -f mattermost

Vergleich: Mattermost vs Alternativen

Feature	Mattermost	Slack	Rocket.Chat
Selbst-gehostet	Ja	Nein (Cloud)	Ja
Kostenlos	Community Edition	Nein	Ja (Open Source)
Datenschutz	Vollständige Kontrolle	Slack Cloud	Vollständige Kontrolle
Benutzerfreundlichkeit	Sehr gute UI	Ausgezeichnet	Gut
LDAP/AD	Professional+	Mit SSO	Open Source
Mobile Apps	Ja	Ja	Ja

Best Practices

• Regular Backups: Täglich automatisiert
• HTTPS: Immer SSL/TLS verwenden
• Firewalling: Nur nötige Ports öffnen
• Monitoring: Disk-Space und CPU überwachen
• Updates: Monatlich überprüfen und durchführen
• Rollen-Management: Nicht alle als Admin

Verwandte Artikel

• 📖 Docker Compose Grundlagen Anleitung
• 📖 Nginx Reverse Proxy Konfiguration
• 📖 OpenLDAP Server Installation Konfiguration
• 🔧 Enjyn Server Monitor – Kostenlose Uptime-Überwachung
• 🔧 Sichere Server bei Enjyn mieten