Graylog Log-Management Server Installation auf Ubuntu – Anleitung

Was ist Graylog?

Graylog ist ein modernes, Open-Source Log-Management-System und SIEM-Lösung (Security Information and Event Management), das es Administratoren ermöglicht, Logs von Tausenden von Geräten, Servern und Anwendungen zentral zu sammeln, zu speichern und in Echtzeit zu analysieren. Mit einer benutzerfreundlichen Web-Oberfläche bietet Graylog erweiterte Suchfunktionen, automatische Benachrichtigungen und Compliance-Reporting.

Graylog Architektur Übersicht

Graylog basiert auf einer dreischichtigen, hochperformanten Architektur:

• MongoDB: NoSQL-Datenbank für Konfigurationen, Benutzerdaten, Cluster-Metainformationen und Stream-Definitionen
• OpenSearch (oder Elasticsearch): Volltext-Suchmaschine und Datenbank für alle Log-Einträge mit umfangreichen Indexierungsmöglichkeiten
• Graylog Server: Zentrale Verarbeitungs-, Orchestrierungs- und API-Engine
• Web UI: Browser-basierte Benutzeroberfläche zur Interaktion mit Logs, Alerts und Dashboards (Port 9000)

Systemanforderungen

Komponente	Minimalanforderung	Empfohlen (Produktion)
RAM	4 GB	8 GB oder mehr
CPU	2 Kerne	4 oder mehr Kerne
Festplatte	20 GB	100 GB+ (abhängig von Log-Volumen)
Betriebssystem	Ubuntu 20.04 LTS oder 22.04 LTS
Java	OpenJDK 17 oder höher

Schritt 1: Java OpenJDK 17 installieren

Graylog und OpenSearch benötigen Java 17 oder höher. Aktualisieren Sie zuerst die Paketlisten und installieren Sie die OpenJDK Runtime:

sudo apt update
sudo apt install openjdk-17-jre-headless -y

Verifizieren Sie die Installation und überprüfen Sie die Version:

java -version

Die Ausgabe sollte anzeigen:

openjdk version "17.x.x"
OpenJDK Runtime Environment (build 17.x.x)

Schritt 2: MongoDB 6.x installieren und konfigurieren

Graylog speichert Konfigurationen und Metadaten in MongoDB. Importieren Sie den offiziellen MongoDB-GPG-Schlüssel:

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -

Fügen Sie das offizielle MongoDB-Repository hinzu (angepasst für Ubuntu 22.04 'Jammy'):

echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list

Aktualisieren Sie die Paketlisten und installieren Sie MongoDB:

sudo apt update
sudo apt install -y mongodb-org

Starten Sie MongoDB und aktivieren Sie es für den Autostart:

sudo systemctl start mongod
sudo systemctl enable mongod
sudo systemctl status mongod

Überprüfen Sie, ob MongoDB ordnungsgemäß läuft und antwortet:

mongosh --eval "db.adminCommand('ping')"

Das sollte eine erfolgreiche Antwort mit "ok: 1" zurückgeben.

Schritt 3: OpenSearch 2.x installieren und konfigurieren

OpenSearch ist die Suchmaschine und Datenbank für alle Log-Einträge. Fügen Sie zunächst das OpenSearch-Repository und seinen GPG-Schlüssel hinzu:

curl -fsSL https://artifacts.opensearch.org/publickeys/opensearch.pgp | sudo apt-key add -
echo "deb https://artifacts.opensearch.org/releases/bundle/opensearch/2.x/apt stable main" | sudo tee /etc/apt/sources.list.d/opensearch-2.x.list

Installieren Sie OpenSearch:

sudo apt update
sudo apt install -y opensearch

Konfigurieren Sie OpenSearch für Single-Node-Setup. Bearbeiten Sie die Konfigurationsdatei:

sudo nano /etc/opensearch/opensearch.yml

Fügen Sie oder ändern Sie folgende Zeilen:

cluster.name: graylog-cluster
node.name: node-1
discovery.type: single-node
plugins.security.disabled: true
action.auto_create_index: "+.watches,-*"
indices.memory.index_buffer_size: 30%
thread_pool.search.queue_size: 1000

Speichern Sie die Datei (Ctrl+O, Enter, Ctrl+X). Starten und aktivieren Sie OpenSearch:

sudo systemctl start opensearch
sudo systemctl enable opensearch
sudo systemctl status opensearch

Überprüfen Sie, ob OpenSearch läuft und antwortet. Dies kann 30 Sekunden dauern:

sleep 30 && curl -s http://localhost:9200 | grep cluster_name

Schritt 4: Graylog 6.x installieren

Laden Sie und installieren Sie das Graylog Repository-Paket:

wget https://packages.graylog2.org/repo/debian/pool/graylog-6.0-repository_latest.deb
sudo dpkg -i graylog-6.0-repository_latest.deb
sudo apt update

Installieren Sie Graylog Server:

sudo apt install -y graylog-server

Schritt 5: Graylog Server konfigurieren

Bearbeiten Sie die Graylog-Serverkonfiguration:

sudo nano /etc/graylog/server/server.conf

Generieren Sie ein sicheres Passwort-Secret (eine zufällige 96-Zeichen-Zeichenkette):

pwgen -N 1 -s 96

Kopieren Sie die Ausgabe und setzen Sie die Zeile password_secret in der Konfiguration:

password_secret = [generierter String hier einfügen]

Erstellen Sie einen SHA256-Hash für das Root-Passwort (z.B. "admin" - ändern Sie dies!):

echo -n "admin" | sha256sum

Kopieren Sie den Hash (nur die Hex-Zeichenkette vor dem Leerzeichen und Bindestrich) und setzen Sie:

root_password_sha2 = [Hash hier einfügen]

Setzen Sie die HTTP-Bindungsadresse (0.0.0.0 für Remote-Zugriff oder 127.0.0.1 wenn nur lokal) und OpenSearch-Hosts:

http_bind_address = 0.0.0.0:9000
http_publish_uri = http://SERVERIP:9000/
elasticsearch_hosts = http://localhost:9200

Speichern Sie die Konfiguration. Weitere wichtige Einstellungen:

timezone = Europe/Berlin
elasticsearch_request_timeout = 60s
message_journal_max_size = 20gb

Schritt 6: Graylog starten und aktivieren

Starten Sie den Graylog Server und aktivieren Sie den Autostart:

sudo systemctl start graylog-server
sudo systemctl enable graylog-server
sudo systemctl status graylog-server

Beobachten Sie die Server-Logs, um sicherzustellen, dass alles startet (dies kann bis zu 60 Sekunden dauern):

sudo tail -f /var/log/graylog-server/server.log

Suchen Sie nach der Meldung "Graylog server up and running" um zu bestätigen, dass der Server vollständig initialisiert ist.

Schritt 7: Web-UI zugreifen und initialisieren

Öffnen Sie Ihren Browser und navigieren Sie zu:

http://SERVERIP:9000

Melden Sie sich mit dem Benutzernamen "admin" und dem SHA256-Hash-Passwort an, das Sie in Schritt 5 konfiguriert haben. Nach dem ersten erfolgreichen Login sollten Sie das Passwort sofort ändern, indem Sie auf den Benutzernamen klicken und "Change Password" wählen.

Schritt 8: GELF UDP Input erstellen

Der GELF (Graylog Extended Log Format) Input ermöglicht es Remote-Systemen, Logs über UDP an Graylog zu senden. Dies ist das bevorzugte Protokoll für hohe Log-Volumen.

1. Klicken Sie auf "System" im Menü
2. Wählen Sie "Inputs"
3. Wählen Sie aus dem Dropdown "GELF UDP"
4. Klicken Sie "Launch new input"
5. Konfigurieren Sie die Eingabe mit folgenden Werten:
• Title: "Remote Syslog Input"
• Bind address: 0.0.0.0 (um von allen Adressen zu empfangen)
• Port: 12201 (Standard GELF UDP Port)
• Recv buffer size: 262144
6. Klicken Sie "Save"

Der Input sollte nun aktiv sein und unter "Running Inputs" angezeigt werden. Er wird Logs auf UDP Port 12201 empfangen.

Schritt 9: Rsyslog auf Client-Systemen konfigurieren

Auf jedem System, das Logs an Graylog senden soll, konfigurieren Sie rsyslog (der Standard-Log-Daemon auf Linux):

sudo nano /etc/rsyslog.d/30-graylog.conf

Fügen Sie folgende Konfiguration hinzu (ersetzen Sie GRAYLOG_SERVER mit der IP-Adresse oder dem Hostnamen Ihres Graylog-Servers):

# Forward all logs to Graylog via GELF UDP
*.* @GRAYLOG_SERVER:12201

Oder für erweiterte GELF-Formatierung:

# Forward with metadata
:app-name, isequal, "nginx" @GRAYLOG_SERVER:12201
:app-name, isequal, "apache2" @GRAYLOG_SERVER:12201
*.* @GRAYLOG_SERVER:12201

Starten Sie rsyslog neu und überprüfen Sie, ob die Konfiguration korrekt ist:

sudo systemctl restart rsyslog
sudo systemctl status rsyslog

Überprüfen Sie die rsyslog-Logs auf Fehler:

sudo grep rsyslog /var/log/syslog | tail -10

In der Graylog Web-UI sollten Sie neue Logs unter "Search" sehen. Falls nicht, überprüfen Sie die Konnektivität:

nc -zu GRAYLOG_SERVER 12201

Schritt 10: Stream für Log-Filterung und Segmentierung erstellen

Streams ermöglichen es, Logs basierend auf bestimmten Kriterien automatisch zu filtern, zu organisieren und zu routen:

1. Klicken Sie auf "Streams" im Menü
2. Klicken Sie "Create Stream"
3. Geben Sie einen Namen ein, z.B. "Production Errors" oder "Web Server Logs"
4. Optional: Beschreibung hinzufügen
5. Klicken Sie "Create Stream"
6. Konfigurieren Sie Stream-Regeln zum Filtern von Logs:
• Klicken Sie "Add Stream Rule"
• Field: "level" (oder ein anderes Feld)
• Type: "is greater than" oder "contains"
• Value: "3" (für Error-Level) oder ein anderes Suchkriterium
• Klicken Sie "Save"

Sie können mehrere Stream-Regeln hinzufügen, um komplexe Filterlogik zu erstellen. Diese Streams helfen bei der Organisation und beim Durchsatz großer Log-Mengen.

Schritt 11: Basis-Alarm (Event Definition) erstellen

Erstellen Sie automatische Benachrichtigungen, wenn bestimmte Log-Muster erkannt werden:

1. Klicken Sie auf "Alerts" im Menü
2. Wählen Sie "Event Definitions"
3. Klicken Sie "Create Event Definition"
4. Konfigurieren Sie die Event Definition:
• Title: "High Error Rate Alert" oder eine beschreibende Bezeichnung
• Description: "Benachrichtigung bei hohen Fehlerraten in 5 Minuten"
• Search Query: level:3 OR level:4 (ERROR oder FATAL Logs)
• Filter: Optionale Filters (z.B. nur für bestimmte Sources)
• Aggregation Function: "Count()"
• Threshold Type: "Threshold"
• Threshold Relation: "greater than"
• Threshold Value: 10 (mehr als 10 Fehler)
• Time Window: 5 Minutes
5. Klicken Sie "Save"

Konfigurieren Sie anschließend Benachrichtigungen, indem Sie auf die Event Definition klicken und eine "Notification" hinzufügen.

Nginx Reverse Proxy Konfiguration

Für produktive Umgebungen wird dringend empfohlen, Graylog hinter Nginx mit SSL/TLS zu betreiben, um sichere verschlüsselte Verbindungen zu ermöglichen:

sudo nano /etc/nginx/sites-available/graylog

Fügen Sie folgende Konfiguration ein:

upstream graylog_backend {
    server localhost:9000;
    keepalive 32;
}

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

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

    ssl_certificate /etc/letsencrypt/live/logs.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/logs.example.com/privkey.pem;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    client_max_body_size 50M;

    location / {
        proxy_pass http://graylog_backend;
        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;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header Connection "";
        proxy_buffering off;
        proxy_request_buffering off;
        proxy_http_version 1.1;
    }
}

Aktivieren Sie die Konfiguration:

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

Aktualisieren Sie auch die Graylog-Serverkonfiguration:

sudo nano /etc/graylog/server/server.conf

Ändern Sie diese Zeilen:

http_bind_address = 127.0.0.1:9000
http_publish_uri = https://logs.example.com/

Starten Sie Graylog neu:

sudo systemctl restart graylog-server

Backup-Strategie für Graylog

Implementieren Sie regelmäßige Backups von MongoDB und Index-Daten, um Datenverlust zu verhindern:

MongoDB Backup

Erstellen Sie ein Backup-Verzeichnis:

sudo mkdir -p /backups/graylog
sudo chown mongodb:mongodb /backups/graylog

Erstellen Sie ein MongoDB Backup:

sudo mongodump --out /backups/graylog/mongodb-$(date +%Y-%m-%d-%H%M%S) --gzip

Erstellen Sie ein automatisiertes Backup-Skript für tägliche Backups:

sudo nano /usr/local/bin/backup-graylog.sh

#!/bin/bash
BACKUP_DIR="/backups/graylog"
DATE=$(date +%Y-%m-%d_%H%M%S)
MONGO_BACKUP="$BACKUP_DIR/mongodb-$DATE"

mkdir -p $BACKUP_DIR

# MongoDB Backup
echo "Starting MongoDB backup at $DATE..."
mongodump --out $MONGO_BACKUP --gzip

# Komprimieren
tar -czf $BACKUP_DIR/graylog-backup-$DATE.tar.gz -C $BACKUP_DIR mongodb-$DATE

# Alte MongoDB Backup-Verzeichnis entfernen
rm -rf $MONGO_BACKUP

# Alte Backups löschen (älter als 30 Tage)
find $BACKUP_DIR -name "graylog-backup-*.tar.gz" -mtime +30 -delete

echo "Backup completed: $BACKUP_DIR/graylog-backup-$DATE.tar.gz"

Geben Sie ausführbare Rechte:

sudo chmod +x /usr/local/bin/backup-graylog.sh

Testen Sie das Skript:

sudo /usr/local/bin/backup-graylog.sh

Planen Sie automatische tägliche Backups mit Cron (um 2 Uhr morgens):

sudo crontab -e

Fügen Sie diese Zeile hinzu:

0 2 * * * /usr/local/bin/backup-graylog.sh >> /var/log/graylog-backup.log 2>&1

Fehlerbehebung und Troubleshooting

Graylog startet nicht

Überprüfen Sie die Logs detailliert:

sudo journalctl -u graylog-server -n 100 --no-pager

Häufige Ursachen und Lösungen:

• MongoDB oder OpenSearch läuft nicht: sudo systemctl status mongod opensearch
• Port 9000 ist bereits in Gebrauch: sudo lsof -i :9000
• Falsche password_secret oder root_password_sha2: Überprüfen Sie /etc/graylog/server/server.conf und regenerieren Sie die Werte
• OpenSearch antwortet nicht: Überprüfen Sie curl -s http://localhost:9200

Logs werden nicht empfangen

Testen Sie die UDP-Konnektivität vom Client:

nc -zu GRAYLOG_SERVER 12201

Überprüfen Sie Firewall-Regeln auf dem Server:

sudo ufw status
sudo ufw allow 12201/udp

Überprüfen Sie, ob der GELF Input aktiv ist (System > Inputs). Überprüfen Sie OpenSearch auf Fehler:

curl -s http://localhost:9200/_cluster/health | jq .

Überprüfen Sie die Graylog-Server-Logs auf Input-Fehler:

sudo tail -f /var/log/graylog-server/server.log | grep -i input

Web-UI lädt langsam oder nicht

Stellen Sie sicher, dass Graylog auf der korrekten Adresse bindet:

sudo netstat -tlnp | grep java

Überprüfen Sie die Systemressourcen:

free -h
df -h /
top -b -n 1 | head -20

Erhöhen Sie möglicherweise den Java Heap Memory in /etc/default/graylog-server:

GRAYLOG_HEAPSIZE=2g

OpenSearch Cluster-Fehler

Überprüfen Sie den Cluster-Status:

curl -s http://localhost:9200/_cat/health
curl -s http://localhost:9200/_cat/nodes

Überprüfen Sie OpenSearch-Logs:

sudo tail -f /var/log/opensearch/opensearch.log

Vergleich: Graylog vs ELK Stack vs Loki

Feature	Graylog	ELK Stack (Elasticsearch, Logstash, Kibana)	Loki (Grafana)
Einrichtung Komplexität	Einfach (All-in-One)	Komplex (3+ separate Komponenten)	Moderat (mit Promtail)
Web UI Qualität	Moderni, intuitiv, spezialisiert für Logs	Kibana (sehr ausgereift, sehr umfassend)	Via Grafana (universell, nicht spezialisiert)
Speicher-Engine	Elasticsearch oder OpenSearch	Elasticsearch	Komprimierter Object Storage (S3, etc.)
RAM-Bedarf (Basis)	4-8 GB	6-12 GB	1-2 GB
Datenspeicherung	GB bis TB	GB bis TB	TB bis PB (komprimiert)
Horizontale Skalierbarkeit	Gut (Clustering)	Excellent (Multi-Node)	Excellent (Stateless)
Lizenz/Preis	Open Source (kostenlos)	Open Source + Enterprise (Elastic Cloud)	Open Source + Grafana Cloud (optional)
Alerts/Alarme	Built-in, einfach zu konfigurieren	Via Watcher (X-Pack)	Via Grafana Alerting
Dashboard-Möglichkeiten	Gut und spezialisiert	Excellent und universell (Kibana)	Excellent und universell (Grafana)
Volltext-Suche	Excellent	Excellent	Label-basiert (keine Volltext)
Community-Größe	Mittel	Sehr groß	Wachsend
Best für	Mittelgroße bis große Bereitstellungen, fokussiert auf Logs	Enterprise, umfassende Observability	Kostengünstiges Logging in großem Maßstab

Zusammenfassung

Sie haben nun einen vollständigen, produktionsreifen Graylog Log-Management Server auf Ubuntu installiert und konfiguriert. Der Server kann Logs von tausenden von Geräten, Servern und Anwendungen sammeln, speichern und in Echtzeit analysieren. Mit konfigurierten GELF-Inputs, Streams und Alerts haben Sie ein solides Fundament für Log-Analyse und Sicherheitsüberwachung.

Für weitergehende Produktionsumgebungen sollten Sie zusätzlich implementieren: TLS/SSL-Verschlüsselung, rollenbasierte Zugriffskontrolle (RBAC), Multi-Node Clustering für Hochverfügbarkeit, Integration mit externen Authentifizierungssystemen (LDAP/Active Directory), detaillierte Backup- und Disaster-Recovery-Planung, sowie umfassendere Monitoring- und Alert-Konfigurationen.

• 📖 Log-Aggregation mit ELK Stack
• 📖 Logging Best Practices
• 📖 Logrotate Konfiguration
• 🔧 Enjyn Server Monitor – Kostenlose Uptime-Überwachung
• 🔧 Sichere Server bei Enjyn mieten