ELK_F in Docker installieren

ELK_F in Docker installieren
25/9/2020

Die Fähigkeit, in den Daten einer Organisation zu suchen und Analysen zu erstellen, ist für jede digitale Strategie von entscheidender Bedeutung. Es gibt zwar mehrere Plattformen, die diese Art der Datenverarbeitung ermöglichen, d.h. Aufnahme, Suche, Analyse und Visualisierung von Organisationsdaten, aber der ELK (Elastic) Stack ist vielleicht die beliebteste von allen, und Ihre Organisation sollte ihn nutzen.

Docker ist eine offene Plattform für Entwickler und Systemadministratoren, um verteilte Anwendungen zu erstellen, auszuliefern und auszuführen, indem eine extrem leichte Virtualisierung auf Betriebssystemebene, auch als Container bekannt, bereitgestellt wird.

Was ist Elastic Stack?

Der ELK Stack ist eine Sammlung von drei Open-Source-Produkten: Elasticsearch, Logstash und Kibana. Elasticsearch ist eine NoSQL-Datenbank, die auf der Lucene-Suchmaschine basiert. Logstash ist ein Log-Pipeline-Tool, das Eingaben aus verschiedenen Quellen akzeptiert, verschiedene Transformationen ausführt und die Daten an verschiedene Ziele exportiert. Kibana ist eine Visualisierungsschicht, die über der Elasticsearch Datenbank arbeitet.

Filebeat ist eine Anwendung, die Daten schnell und direkt entweder an Logstash oder Elasticsearch liefert. Filebeat muss auch deshalb verwendet werden, weil es hilft, die Lasten von einzelnen Servern zu verteilen, indem es die Protokollerzeugung und -verarbeitung trennt, wo Protokolle erzeugt werden und von wo sie verarbeitet werden. Folglich trägt Filebeat dazu bei, den CPU-Overhead zu reduzieren, indem Prospektoren verwendet werden, um Protokolldateien in bestimmten Pfaden zu lokalisieren und Harvester zum Lesen der einzelnen Protokolldateien eingesetzt werden und neue Inhalte an einen Spooler gesendet werden, der die Daten kombiniert und an eine von Ihnen konfigurierte Ausgabe sendet.

  • Erstellen eines Images für jede Komponente.
  • Parametrisierung der Konfiguration und Vermeidung von Hardcoding-Credentials.
  • Einrichten von Elasticsearch als produktiver Cluster mit einem einzigen Knoten, der für die   Skalierung vorbereitet ist.
  • Einrichten der Logstash-Konfiguration und der Pipelines.
  • Einrichten der Filebeat-Konfiguration zum Lesen der Protokolldatei(en).
  • Alles zusammen in einem Docker Compose zusammenstellen.

Die beste Methode ist die Verwendung der Datei docker-compose.yml zur Ausführung aller ELKF-Anwendungen. Etwa so:

{% c-block language="markdown" %}
version: '3.2'

services:
 filebeat:
   build:
     context: filebeat/
     args:
       FILEBEAT_VERSION: $FILEBEAT_VERSION
   volumes:
   - type: bind
     source: ./$PWD/config/filebeat.yml
     target: /usr/share/filebeat/filebeat.yml
     read_only: true
   ports:
     - "5044:5044"
   command: ["--strict.perms=false"]
   depends_on:
   - logstash
   - elasticsearch
   - kibana
   networks:
   - elk

 elasticsearch:
   build:
     context: elasticsearch/
     args:
       ELK_VERSION: $ELK_VERSION
   volumes:
   - type: bind
     source: ./elasticsearch/config/elasticsearch.yml
     target: /usr/share/elasticsearch/config/elasticsearch.yml
     read_only: true
   - type: volume
     source: elasticsearch
     target: /usr/share/elasticsearch/data
   restart: always
   ipc: host
   ports:
   - "9200:9200"
   - "9300:9300"
   environment:
     ES_JAVA_OPTS: "-Xmx256m -Xms256m"
     ELASTIC_PASSWORD: changeme
     discovery.type: single-node
   networks:
   - elk

 kibana:
   build:
     context: kibana/
     args:
       ELK_VERSION: $ELK_VERSION
   volumes:
   - type: bind
     source: ./kibana/config/kibana.yml
     target: /usr/share/kibana/config/kibana.yml
     read_only: true
   restart: always
   ports:
   - "5601:5601"
   networks:
   - elk
   depends_on:
   - elasticsearch

 logstash:
   build:
     context: logstash/
     args:
       ELK_VERSION: $ELK_VERSION
   volumes:
   - type: bind
     source: ./logstash/config/logstash.yml
     target: /usr/share/logstash/config/logstash.yml
     read_only: true
   - type: bind
     source: ./logstash/pipeline
     target: /usr/share/logstash/pipeline
     read_only: true
   ipc: host
   restart: always
   ports:
   - "5000:5000/tcp"
   - "5000:5000/udp"
   - "9600:9600"
   environment:
     LS_JAVA_OPTS: "-Xmx256m -Xms256m"
   networks:
   - elk
   depends_on:
   - elasticsearch

networks:
 elk:
   driver: bridge

volumes:
 elasticsearch:
{% c-block-end %}

Die Parameter $ELK_VERSION und $FILEBEAT_VERSION müssen Sie zu einer separaten ".env" Datei hinzufügen.

Jetzt können Sie den Befehl "docker-compose.up -d" ausführen, der 4 Images herunterlädt und 4 laufende Container und ein Elk-Docker-Netzwerk erstellt, aber Ihre Daten werden noch nicht hochgeladen.

Beispiel: Sie haben ein Protokoll (JSO-Format) in einer Protokolldatei my.log in /var/log/mylog/my.log

Jetzt müssen Sie die Datei docker-compose.yml aktualisieren, um Ihre my.log so zu laden:

{% c-block language="markdown" %}
version: '3.2'

services:
 filebeat:
   build:
     context: filebeat/
     args:
       FILEBEAT_VERSION: $FILEBEAT_VERSION
   volumes:
   - type: bind
     source: ./filebeat/config/filebeat.yml
     target: /usr/share/filebeat/filebeat.yml
     read_only: true
   - /var/log/my:/data/logs:ro





{% c-block-end %}

Jetzt müssen Sie den Container Filebeat mit dem Befehl "docker-compose up -d" neu erstellen.

So können Sie überprüfen, ob Ihre Daten darin enthalten sind:

docker exec -ti <containerID> /bin/bash

ls/data/logs

Ihre Liste der Dateien ist: my.log

Jetzt verwenden den Befehl "exit" in Ihrem Dateisystem.

Konfigurieren Sie Filebeat:

Um Ihren Filebeat zu konfigurieren, müssen Sie die Datei filebeat.yml im Konfigurationsordner filebeat/config wie folgt editieren:

{% c-block language="markdown" %}
filebeat.inputs:
 - type: log
   enabled: true
   paths:
     - /data/logs/my.log
   tags: [“my-awesome-log”]
{% c-block-end %}

Die Ausgabe ist leicht zu erraten. Sie möchten, dass die Ausgabekonfiguration von Logstash wie folgt aussieht:

{% c-block language="markdown" %}
hosts: ["logstash:5044"]
{% c-block-end %}

Konfigurieren Sie Logstash:

Die vollständige Datei logstash/config/logstash.yml sieht wie folgt aus:

{% c-block language="markdown" %}
http.host: "0.0.0.0"
xpack.monitoring.elasticsearch.hosts: [ "http://elasticsearch:9200" ]
xpack.monitoring.enabled: true
xpack.monitoring.elasticsearch.username: elastic
xpack.monitoring.elasticsearch.password: changeme
{% c-block-end %}

Jetzt können Sie Ihre Logstash-Pipelines in logstash/pipeline/logstash.conf wie folgt konfigurieren:

{% c-block language="markdown" %}
input {
   beats {
       port => 5044
   }
}
output {
   elasticsearch {
       hosts => "elasticsearch:9200"
       user => "elastic"
       password => "changeme"
   }
}
{% c-block-end %}

Für mehr als eine Filebeat Form x Server können Sie mehrere Eingaben verwenden:

{% c-block language="markdown" %}
input {
   beats {
       port => 5044
   }
   beats {
       port => 5045
   }
   beats {
       port => 5046
   }
}
{% c-block-end %}

Damit Ihr Elastic die Ports 5045 und 5045 abhört, müssen Sie diese öffentlich machen.  

Bearbeiten Sie Ihre Datei docker-compose.yml wie folgt:

{% c-block language="markdown" %}
..
..
  logstash:
..
..
  ipc: host
   restart: always
   ports:
   - "5000:5000/tcp"
   - "5000:5000/udp"
   - "9600:9600"
   - "5045:5045"
   - "5046:5046"
   environment:
     LS_JAVA_OPTS: "-Xmx256m -Xms256m"
   networks:
..
..
{% c-block-end %}

Vergessen Sie nicht, Ihre Firewall von der Logstash-Seite aus einzurichten. Für Ubuntu: "sudo ufw allow from  xxx.xxx.xxx.xxx.xxx to any port 504x".

Jetzt sind Sie bereit für die Wiederholung des Befehls "docker-compose up -d". Docker wird die Container Filebeat und Logstash nachbilden, der Rest wird aktuell sein. Jetzt können Sie zur Kibana-URL gehen und Kibana so einrichten, dass das Protokoll angezeigt wird.

Richten Sie einen Beat-Index ein, um die Suche nach Daten mit Kibana zu beginnen.

ELK-Stack auf Docker-Container ausführen - Filebeat-Index

Klicken Sie auf Discover, um die neuesten Logs von Filebeat zu durchsuchen.

ELK-Stapel auf Docker-Container ausführen - Protokolle. Das ist alles für den Moment.

Wenn Sie es bis hierher geschafft haben, herzlichen Glückwunsch! Sie haben den ELK-Stapel erfolgreich angedockt. Fahren Sie mit der Erstellung einiger weiterer Logstash-Pipelines fort, um Log-Ereignisse aus verschiedenen Quellen zu streamen.

Im Internet gibt es eine Menge Handbücher zur Installation auf lokalen Rechnern aber weniger für Docker. Wenn Sie Docker für ELK_F verwenden wollen, müssen Sie auf einige Schwierigkeiten gefasst sein, da mehr Opts-Anwender die normale Installation auf localhost verwenden. Aber was ist besser als Docker? Ich mag saubere Installationen und saubere Betriebssysteme auf meinen Servern, und das ist der Grund, warum ich Installation für Docker verwendet habe.

Was hat mich überrascht?

  • Definieren von Volumes zum Lesen der Protokolldatei beim Compose für Filebeat
  • Filebeat verwendet 504x nicht, jedoch Logstash als Back-Off-Server
  • Im privaten Netz müssen Sie 5044 nicht veröffentlichen (Basis-Port für Filebeat)
  • Vergessen Sie nicht, einen anderen Port für das Logstash-Backoff zu veröffentlichen, ohne localhost zu verwenden
  • Wenn Sie localhost benutzen, müssen Sie mit Iptables spielen und das ist ....... schlecht :-)
  • LESEN von Protokollen aus Docker-Logs für alle Container (sehr wichtig)

Ich möchte Ondra Karas von CROWNINGARTS danken, der mich auf diese Idee gebracht hat.

Teilen:
Pavel ist ein erfahrener DevOps-Guru und begeisterter SysAdmin, der für Application Life Cycle, Continuous Integration und Continuous Delivery verantwortlich ist, Sowohl für Kunden als auch für interne SABO Projekte. Er schult Software-Entwickler in unserem Team und koordiniert alle DevOps-Aktivitäten. Hat immer einen Spruch parat, wechselt unberechenbar ins Polnische und kocht und backt gerne.

Weitere Artikel dieses Autors

Article collaborators

SABO Mobile IT

Für unsere Kunden aus der Industrie entwickeln wir spezialisierte Software zur Umsetzung von Industry 4.0. IoT, Machine Learning und Künstliche Intelligenz ermöglichen uns, signifikante Effizienzsteigerungen bei unseren Kunden zu erzielen.
Über uns