Logstash mit Elasticsearch und Kibana

Aus Cowwwiki
Wechseln zu: Navigation, Suche

Mit Logstash, Elasticsearch und Kibana ist es nun für jedermann möglich die eigenen Logs zu analysieren und auszuwerten. Alle verwendeten Tools sind Open Source und somit kostenfrei. Grenzen sind der Auswertung so gut wie keine gesetzt. Voraussetzung ist allerdings, dass man sich mit seinen Logs auseinandersetzt und sie strukturiert. Je strukturierter die Logs, desto besser lassen sich später die Daten verknüpfen und auswerten.

Kibana3 Dashboard.png


Voraussetzungen

Es gibt mehrere Möglichkeiten, wie Logstash, Elasticsearch und Kibana zusammenarbeiten wollen. In diesem Tutorial wird die Konfiguration wie folgt aussehen:

  • Server, z. B. logstashserver
    • elasticsearch
    • logstash
  • Clients, z. B. webserver
    • logstash-forwarder


Logstash benötigt Java. Wer auf seinen Clients Java schon installiert hat, kann auf den Logstash-Forwarder verzichten und Logstash direkt auf dem Client installieren. Logstash würde dann von den Clients in Elasticsearch schreiben. Wenn man nicht überall Java installieren möchte, kann man nach diesem Tutorial vorgehen. Anstelle von Logstash wird nämlich auf den Clients ein sog. Logstash-Fowarder eingerichtet, welcher über das Lumberjack-Protokoll (Port 5000 tcp) die Logs an den Logstash-Server schickt. Der Logstash-Server muss für diesen Zweck eine Input-Konfiguration besitzen und verarbeitet die Logs dann mit den entsprechenden Filtern und schickt sie an Elasticsearch.

Installation

Dieses Tutorial ist auf Basis von Ubuntu 12.04 LTS aufgesetzt. Mit anderen apt-basierten Systemen sollte das Vorgehen ähnlich laufen.

Elasticsearch

Bevor sich Elasticsearch installieren lässt, muss ein PPA hinzugefügt werden. Dazu wird zuerst der GPG-Key hinzugefügt und anschließend die neue Paketquelle in die Apt-Listen hinzugefügt:

wget -qO - http://packages.elasticsearch.org/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb http://packages.elasticsearch.org/elasticsearch/1.4/debian stable main" > /etc/apt/sources.list.d/elasticsearch.list
apt-get update && apt-get install elasticsearch


Nach der Installation sollten folgende Hardeningmaßnahmen vorgenommen werden. Dazu wird die Datei /etc/elasticsearch/elasticsearch.yml geöffnet und um folgende Parameter ergänzt bzw. angepasst:

script.disable_dynamic: true
network.host: localhost


Elasticsearch ist nun einsatzbereit und kann über das Init-Script gestartet werden. Damit es beim Booten automatisch startet muss der Service allerdings noch in die entsprechenden Run-Level eingetragen werden

update-rc.d elasticsearch defaults 95 10


Logstash

Als nächstes richten wir Logstash ein. In diesem Tutorial wird Logstash als Server fungieren, in dem es die über das Lumberjack-Protokoll geschickten Logs der anderen Systeme entgegennimmt, strukturiert und schließlich an Elasticsearch schickt.

Bevor Logstash installiert werden kann, muss eine Java-Umgebung eingerichtet sein. Das funktioniert auch prima mit OpenJDK und erfordert kein Oracle-Java.

apt-get install openjdk-7-jre


Zur Installation von Logstash benötigt man wieder ein PPA. Der GPG-Key hingegen ist der gleiche, wie wir ihn bereits bei der Einrichtung von Elasticsearch verwendet haben. Daher muss nun lediglich die Paketquelle hinzugefügt werden:

echo "deb http://packages.elasticsearch.org/logstash/1.4/debian stable main" > /etc/apt/sources.list.d/logstash.list
apt-get update && apt-get install logstash


Die Logstash-Konfigurationen werden im Verzeichnis /etc/logstash/conf.d abgelegt. Statt einem großen File werden wir die Konfiguration wie folgt strukturieren:

Logstash Konfigurationsdateien
01-lumberjack-input Listener für den Logstash-Forwarder. Nimmt Logs der anderen Systeme entgegen.
10-syslog-filter Filter, um Syslog-Nachrichten zu strukturieren
20-apache-filter Filter, um Apache-Nachrichten zu strukturieren
99-elasticsearch-output Strukturierter Output soll an Elasticsearch gereicht werden


Hinweis: Die Zahlenpräfixe dienen dazu, dass Logstash die Konfigurationen in der Reihenfolge abarbeitet. Alle Filter-Konfigurationen sollten sich deshalb zwischen dem Input und dem Output befinden.


SSL Zertifikate erzeugen

Da wir nicht auf jedem Client Logstash installieren werden, sondern stattdessen den schlankeren Logstash-Forwarder verwenden, muss für die Kommunikation ein Zertifikat erstellt werden. Ich lege die Zertifikate unter /etc/logstash/tls ab:

mkdir -p /etc/logstash/tls/private; mkdir -p /etc/logstash/tls/certs
cd /etc/logstash/tls; openssl req -x509 -batch -nodes -days 3650 -newkey rsa:2048 -keyout private/logstash-forwarder.key -out certs/logstash-forwarder.crt


Das File logstash-forwarder.crt werden wir später auf die Clients verteilen. Mit diesem Zertifikat kann sich der Client auf dem Logstash-Server authentifizieren.

01-lumberjack-input

Diese Datei definiert die Konfiguration des Logstash-Servers. Die Logstash-Forwarder auf den Clients werden ihre Logs an diesen Input weiterleiten. Anhand des SSL-Zertifikats wird überprüft, ob der Client berechtigt ist.

input {
  lumberjack {
    port => 5000
    type => "logs"
    ssl_certificate => "/etc/logstash/tls/certs/logstash-forwarder.crt"
    ssl_key => "/etc/logstash/tls/private/logstash-forwarder.key"
  }
}

10-syslog.conf

Zwischen Input und Output werden die Filter platziert, die durch Logstash verarbeitet werden sollen. Dieser Filter strukturiert z. B. die Syslog-Nachrichten

filter {
  if [type] == "syslog" {
    grok {
      match => { "message" => "%{SYSLOGTIMESTAMP:syslog_timestamp} %{SYSLOGHOST:syslog_hostname} %{DATA:syslog_program}(?:\[%{POSINT:syslog_pid}\])?: %{GREEDYDATA:syslog_message}" }
      add_field => [ "received_at", "%{@timestamp}" ]
      add_field => [ "received_from", "%{host}" ]
    }
    syslog_pri { }
    date {
      match => [ "syslog_timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
    }
  }
}

20-apache.conf

Noch interessanter ist der Apache-Filter, da wir hier neben der Strukturierung auch noch weitere Möglichkeiten haben. So können z. B. die Informationen aus den Access-Logs um weitere nützliche Angaben angereichert werden. Ein Beispiel ist die Verwendung von GeoIP, das neben dem Herkunftsland auch gleich die Koordinaten für Map in Kibana mitliefert.

filter {
  if [type] =~ "apache_access" {
    grok {
      match => { "message" => "%{COMBINEDAPACHELOG}" }
    }
  
    date {
      match => [ "timestamp" , "dd/MMM/yyyy:HH:mm:ss Z" ]
    }
    geoip {
      database => "/opt/logstash/vendor/geoip/GeoLiteCity.dat"
      source => "clientip"
      add_field => [ "[geoip][coordinates]", "%{[geoip][longitude]}" ]
      add_field => [ "[geoip][coordinates]", "%{[geoip][latitude]}"  ]
    }
    mutate {
      convert => [ "[geoip][coordinates]", "float" ]
    }
  }
}

99-elasticsearch-output.conf

Zu guter Letzt wollen wir die strukturierten und angereicherten Daten an Elasticsearch senden.

output {
  elasticsearch { host => localhost }
  stdout { codec => rubydebug }
}


Logstash-Forwarder

Bevor sich Logstash-Forwarder installieren lässt, muss ein PPA hinzugefügt werden. Dazu fügen wir wieder den GPG-Key hinzu und erweitern die Apt-Listen um die neue Paketquelle:

wget -qO - http://packages.elasticsearch.org/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb http://packages.elasticsearch.org/logstashforwarder/debian stable main" >> /etc/apt/sources.list.d/logstashforwarder.list
apt-get update && apt-get install logstash-forwarder


Jetzt noch das Init-Script nach /etc/init.d/ kopieren und in entsprechende Run-Level eintragen, damit der Logstash-Forwarder beim Booten automatisch startet:

cd /etc/init.d/; wget http://wiki.easycow.de/downloads/logstash-forwarder
update-rc.d logstash-forwarder defaults


Nun fehlt nur noch die Konfiguration und das Zertifikat. Das Zertifikat legen wir /etc/logstash-forwarder ab:

mkdir -p /etc/logstash-forwarder/tls/certs/


Die Konfiguration wird in /etc/logstash-forwarder/logstash-forwarder gespeichert:

logstash-forwarder

{
  "network": {
    "servers": [ "192.168.1.60:5000" ],
    "timeout": 15,
    "ssl ca": "/etc/logstash-forwarder/tls/certs/logstash-forwarder.crt"
  },

  "files": [  
   {  
     "paths": [  
       "/var/log/syslog",
       "/var/log/auth.log"
     ],
     "fields": {  
       "type": "syslog"
      }
   },
   {  
     "paths": [  
       "/var/log/apache2/*access*.log"
     ],
     "fields": {  
       "type": "apache_access"
     }
   }
 ]
}

Es können hier neben den Syslog- und Apache-Meldungen natürlich noch weitere Dateien hinzugefügt werden. Das hier definierte Feld 'type' steht dann in Logstash auch zur Verfügung und kann ausgewertet werden.


Kibana

Kibana ist das dazugehörige Webfrontend. Es handelt sich um eine HTML5-Applikation, die komplett im Browser läuft. Ein Webserver wird nur für die Auslieferung benötigt. Wir verwenden in diesem Tutorial deshalb das leichtgewichtige Nginx. Zuerst laden wir das aktuelle Kibana herunter:

cd ~; wget https://download.elasticsearch.org/kibana/kibana/kibana-3.1.2.tar.gz
tar xvf kibana-3.1.2.tar.gz


Nun passen wir den Port an - wir ersetzen den standardmäßig konfigurierten Port 9200 durch 80

vim ~/kibana-3.1.2/config.js
elasticsearch: "http://"+window.location.hostname+":80",


Als nächstes erstellen wir ein Verzeichnis für den Webserver und verschieben den Inhalt dorthin:

mkdir -p /var/www/kibana3
sudo cp -R ~/kibana-3.1.2/* /var/www/kibana3/

Nginx

Damit wir Kibana im Browser aufrufen können, müssen wir noch Nginx einrichten.

apt-get install nginx


Für Kibana gibt es bereits eine Vorlage für die Konfiguration des Virtualhosts. Diese laden wir herunter:

cd ~; wget https://gist.githubusercontent.com/thisismitch/2205786838a6a5d61f55/raw/f91e06198a7c455925f6e3099e3ea7c186d0b263/nginx.conf


In der heruntergeladenen Vorlage muss jetzt noch der Server und die Verzeichnisse angepasst werden:

server {
  listen                *:80 ;

  server_name           kibana.myhost.org
  access_log            /var/log/nginx/kibana.myhost.org.access.log;;

  location / {
    root  /var/www/kibana3;
    index  index.html  index.htm;
  }
  location ~ ^/_aliases$ {
    proxy_pass http://127.0.0.1:9200;
    proxy_read_timeout 90;
  }
  location ~ ^/.*/_aliases$ {
    proxy_pass http://127.0.0.1:9200;
    proxy_read_timeout 90;
  }
  location ~ ^/_nodes$ {
    proxy_pass http://127.0.0.1:9200;
    proxy_read_timeout 90;
  }
  location ~ ^/.*/_search$ {
    proxy_pass http://127.0.0.1:9200;
    proxy_read_timeout 90;
  }
  location ~ ^/.*/_mapping {
    proxy_pass http://127.0.0.1:9200;
    proxy_read_timeout 90;
  }

  # Password protected end points
  location ~ ^/kibana-int/dashboard/.*$ {
    proxy_pass http://127.0.0.1:9200;
    proxy_read_timeout 90;
    limit_except GET {
      proxy_pass http://127.0.0.1:9200;
      auth_basic "Restricted";
      auth_basic_user_file /etc/nginx/conf.d/kibana.myhost.org.htpasswd;
    }
  }
  location ~ ^/kibana-int/temp.*$ {
    proxy_pass http://127.0.0.1:9200;
    proxy_read_timeout 90;
    limit_except GET {
      proxy_pass http://127.0.0.1:9200;
      auth_basic "Restricted";
      auth_basic_user_file /etc/nginx/conf.d/kibana.myhost.org.htpasswd;
    }
  }
}


Anschließend wird die Vorlage in das Nginx-Verzeichnis /etc/nginx/sites-available/default kopiert

cp nginx.conf /etc/nginx/sites-available/default


Um die Seite mit htpasswd abzusichern, installieren wir noch die Apache2-Utils

apt-get install apache2-utils


Und fügen dann einen Benutzer unserer Wahl hinzu:

sudo htpasswd -c /etc/nginx/conf.d/kibana.myhost.org.htpasswd myuser


Damit die ganzen Änderungen wirksam werden muss Nginx neugestartet werden

service nginx restart


Kibana kann jetzt mit http://kibana.myhost.org im Browser aufgerufen werden.

Quellen

http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/setup-repositories.html

https://www.digitalocean.com/community/tutorials/how-to-use-logstash-and-kibana-to-centralize-and-visualize-logs-on-ubuntu-14-04

https://www.digitalocean.com/community/tutorials/adding-logstash-filters-to-improve-centralized-logging

http://www.logstash.net/docs/1.4.2/repositories