Bereitstellen eines EFK-Stacks mit Docker

Die Überwachung und Analyse von Protokollen ist heutzutage von entscheidender Bedeutung, sei es für Anwendungen oder Server-/Container-Infrastrukturen. Einer der beliebtesten Software-Stacks für die Protokollanalyse und -überwachung, die Sie auswählen können, ist Elasticsearch, Fluentd und Kibana (EFK-Stack).

Der EFK-Stack ist eine verteilte und skalierbare Suchmaschine, die eine strukturierte Suche und Analyse ermöglicht. Und in diesem Tutorial erfahren Sie, wie Sie die EFK-Stack-Protokollüberwachung mit Docker einrichten und Containerprotokolle im EFK-Stack zentralisieren.

Bereit? Lesen Sie weiter und vereinfachen Sie Ihre Protokollanalyse!

Voraussetzungen

Dieses Tutorial umfasst praktische Demonstrationen. Um mitzumachen, stellen Sie sicher, dass Sie über Folgendes verfügen:

• Ein Linux-Host – Dieses Beispiel verwendet den Debian 11 Bullseye-Server mit einer Speicherkapazität von 6 GB.

• Ein Docker CE (Community Edition) und Docker Compose, installiert auf Ihrem Linux-Host.

Ein EFK-Stack-Projekt einrichten

EFK Stack ist ein unternehmenstaugliches Protokollaggregations- und Protokollanalyse-Framework für Bare-Metal- und Container-Infrastrukturen. Aber bevor Sie einen EFK-Stack bereitstellen, richten Sie zunächst ein Projektverzeichnis ein und erstellen eine Docker-Konfiguration für die Bereitstellung von EFK-Stack auf Ihrem Docker-Host.

Für dieses Beispiel verwenden Sie Docker-Images mit den folgenden Spezifikationen:

• Elasticsearch 7.17.0 – Kann Daten mit schnellen, blitzschnellen, auf Apache Lucene basierenden Suchfunktionen speichern
• Kibana 7.17.0 – Open-Source-Datenaggregation und -sammler, der JSON-Daten unterstützt, und
• Benutzerdefiniertes Fluentd-Image basierend auf v1.14.1 – Datenvisualisierungssoftware für Elasticsearch.

So richten Sie Ihr EFK-Stack-Projekt ein:

1. Öffnen Sie ein Terminal und melden Sie sich bei Ihrem Server an.

2. Führen Sie die folgenden Befehle aus, um zu überprüfen, ob Docker und Docker Compose auf Ihrem System installiert sind.

# Checking Docker version
docker --version

# Checking docker-compose version
docker-compose version

Wie Sie unten sehen, sind die installierten Versionen von Docker CE (Community Edition) v20.10.12 und Docker Compose v1.29.2.

3. Führen Sie den folgenden Befehl aus, um ein neues Projektverzeichnis zu erstellen (mkdir ) und als Arbeitsverzeichnis festlegen (cd ).

Sie können das Verzeichnis nach Belieben benennen, aber in diesem Tutorial heißt das Verzeichnis efk. In diesem Verzeichnis werden alle EFK Stack-Konfigurationsdateien in diesem Tutorial gespeichert.

mkdir -p ~/efk; cd ~/efk

4. Erstellen Sie nun eine neue Konfigurationsdatei (docker-compose.yml ) mit Ihrem bevorzugten Editor und füllen Sie die folgenden Konfigurationen aus.

Die folgende Konfiguration verwendet das Docker Compose-Skript v3 und definiert alle EFK-Stack-Container.

version: "3"

# Define the Docker volume named esdata for the Elasticsearch container.
volumes:
  esdata:

# Deploying three container services (fluentd, elasticsearch, and kibana)
services:
	# Deploy using the custom image automatically be created during the build process.
  fluentd: 
    build: ./fluentd
    links: # Sends incoming logs to the elasticsearch container.
      - elasticsearch
    depends_on:
      - elasticsearch
    ports: # Exposes the port 24224 on both TCP and UDP protocol for log aggregation
      - 24224:24224
      - 24224:24224/udp

	# Created using the Docker image elasticsearch:7.17.0
  elasticsearch:
    image: elasticsearch:7.17.0
    expose: # Exposes the default port 9200
      - 9200
    environment:
      - discovery.type=single-node # Runs as a single-node
    volumes: # Stores elasticsearch data locally on the esdata Docker volume
      - esdata:/usr/share/elasticsearch/data

	# Created using the Docker image kibana:7.17.0
  kibana:
    image: kibana:7.17.0
    links: # Links kibana service to the elasticsearch container
      - elasticsearch
    depends_on:
      - elasticsearch
    ports: # Runs kibana service on default port 5601
      - 5601:5601
    environment: # Defined host configuration
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200

5. Führen Sie den folgenden Befehl aus, um ein neues Verzeichnis fluentd zu erstellen und navigieren Sie zu diesem Verzeichnis. Der fluentd Verzeichnis wird fluentd speichern Dienstkonfigurationen.

mkdir -p fluentd/; cd fluentd/

6. Innerhalb von ~/efk/fluentd erstellen Sie ein neues Dockerfile Verwenden Sie Ihren bevorzugten Editor und füllen Sie die folgende Konfiguration aus.

Diese Konfiguration erstellt das benutzerdefinierte fluentd-Image, das den Elasticsearch-Client-Treiber und das fluentd-plugin-elasticsearch enthält.

Stellen Sie sicher, dass Sie dieselbe Version zwischen Elasticsearch und dem Elasticsearch-Client-Treiber verwenden – dieses Tutorial verwendet Version 7.17.0.

# image based on fluentd v1.14-1
FROM fluentd:v1.14-1

# Use root account to use apk
USER root

# below RUN includes plugin as examples elasticsearch is not required# you may customize including plugins as you wish
RUN apk add --no-cache --update --virtual .build-deps \
        sudo build-base ruby-dev \
&& gem uninstall -I elasticsearch \
&& gem install elasticsearch -v 7.17.0 \
&& sudo gem install fluent-plugin-elasticsearch \
&& sudo gem sources --clear-all \
&& apk del .build-deps \
&& rm -rf /tmp/* /var/tmp/* /usr/lib/ruby/gems/*/cache/*.gem

# copy fluentd configuration from host image
COPY ./conf/fluent.conf /fluentd/etc/
# copy binary start file
COPY entrypoint.sh /bin/

RUN chmod +x /bin/entrypoint.sh

USER fluent

7. Als nächstes erstellen Sie eine weitere Konfigurationsdatei (entrypoint.sh ) mit Ihrem bevorzugten Editor und füllen Sie die folgende Konfiguration aus. Dieses Skript wird ausgeführt, wenn fluentd Containerdienst startet.

Nachfolgend finden Sie das Startskript für den fluentd-Containerdienst, der den grundlegenden Befehl fluentd –config /fluentd/etc/fluentd.conf –plugin /etc/fluentd/plugins.

ausführt

#!/bin/sh

#source vars if file exists
DEFAULT=/etc/default/fluentd

if [ -r $DEFAULT ]; then
    set -o allexport
    . $DEFAULT
    set +o allexport
fi

# If the user has supplied only arguments append them to `fluentd` commandif [ "${1#-}" != "$1" ]; then
    set -- fluentd "[email protected]"
fi

# If user does not supply config file or plugins, use the defaultif [ "$1" = "fluentd" ]; then
    if ! echo [email protected] | grep -e ' \-c' -e ' \-\-config' ; then
      set -- "[email protected]" --config /fluentd/etc/${FLUENTD_CONF}
    fi

    if ! echo [email protected] | grep -e ' \-p' -e ' \-\-plugin' ; then
      set -- "[email protected]" --plugin /fluentd/plugins
    fi
fi

8. Führen Sie den folgenden Befehl aus, um ein neues Verzeichnis conf zu erstellen unter ~/efk/fluentd Verzeichnis.

mkdir -p conf

9. Erstellen Sie nun eine fluentd-Konfiguration (conf/fluentd.conf ) mit Ihrem bevorzugten Editor und füllen Sie die folgende Konfiguration aus.

Diese Konfiguration ermöglicht es dem fluentd-Containerdienst, Protokollmeldungen zu empfangen und sie an den Elasticsearch-Containerdienst weiterzuleiten.

# bind fluentd on IP 0.0.0.0
# port 24224
<source>
  @type forward
  port 24224
  bind 0.0.0.0
</source>

# sendlog to the elasticsearch
# the host must match to the elasticsearch
# container service
<match *.**>
  @type copy
  <store>
    @type elasticsearch
    host elasticsearch
    port 9200
    logstash_format true
    logstash_prefix fluentd
    logstash_dateformat %Y%m%d
    include_tag_key true
    type_name access_log
    tag_key @log_name
    flush_interval 300s
  </store>
  <store>
    @type stdout
  </store>
</match>

10. Führen Sie abschließend die folgenden Befehle aus, um die Struktur des EFK Stack-Projektverzeichnisses zu überprüfen.

Wenn Sie den Baumbefehl nicht haben, installieren Sie ihn mit dem folgenden Befehl:apt install tree -y

# Checking list of files and directory
ls

# Checking directory structure
tree

Nachfolgend finden Sie die vollständige Struktur des EFK-Stack-Projektverzeichnisses.

Bereitstellen des EFK-Stacks mit Docker

Sie haben jetzt alle Konfigurationsdateien für die Bereitstellung von EFK Stack mit Docker und Docker Compose erstellt. Der nächste Schritt besteht darin, den EFK-Stack mithilfe von docker-compose bereitzustellen Befehl, und die Bereitstellung erfolgt in Ihrem Projektverzeichnis (~/efk ).

1. Führen Sie zuerst den folgenden Befehl aus, um das Arbeitsverzeichnis in efk zu ändern Projektverzeichnis.

cd ~/efk/

2. Führen Sie als Nächstes docker-compose aus Befehl unten zum Bereitstellen (up ) das Protokollanalyse- und Protokollüberwachungssystem EFK Stack.

Dieser Befehl lädt automatisch die Docker-Images Elasticsearch und Kibana herunter. Und das Fluentd-Docker-Image wird automatisch mithilfe der Dockerfile erstellt im fließend Verzeichnis.

Die Bereitstellung kann je nach den Spezifikationen des Docker-Hosts einige Zeit dauern.

docker-compose up -d

Unten sehen Sie den Screenshot des Build-Prozesses für das Fluentd-Docker-Image.

Und unten ist der Screenshot, der zeigt, dass die Bereitstellung abgeschlossen ist und der Kibana-Containerdienst ausgeführt wird.

3. Führen Sie jeden der folgenden Befehle aus, um die Protokolle des EFK-Stack-Erstellungsprozesses zu überprüfen. Führen Sie diese Befehle immer aus, wenn Sie einen Fehler im Bereitstellungsprozess erhalten.

# Checking logs for service fluentd
docker-compose logs fluentd

# Checking logs for service kibana
docker-compose logs kibana

Unten ist die Protokollnachricht, wenn der fluentd-Containerdienst ausgeführt wird.

Und unten ist das Protokoll für den Kibana-Container.

4. Führen Sie nun den folgenden Befehl aus, um den Status aller Containerdienste zu überprüfen (ps ).

docker-compose ps

Wie Sie unten sehen, ist der Containerdienst EFK Stack Up. Notieren Sie sich den Namen des Elasticsearch-Containers (efk_elasticsearch_1), um im nächsten Schritt weiter zu überprüfen, ob der Container ordnungsgemäß ausgeführt wird.

5. Führen Sie außerdem den folgenden Befehl aus, um den Elasticsearch-Containerdienst zu überprüfen. Dieser Befehl gibt die detaillierten Einstellungen von efk_elasticsearch_1 aus Container.

docker inspect efk_elasticsearch_1

Wie Sie unten sehen können, erhält der Container efk_elasticsearch_1 eine IP-Adresse von 172.18.0.2.

6. Führen Sie zuletzt den folgenden Befehl aus, um auf den Elasticsearch-Container zuzugreifen und ihn anhand der IP-Adresse (172.18.0.2) zu überprüfen ). Port 9200 ist der Standardport für den Elasticsearch-Container.

curl 172.18.0.2:9200

Wenn der Elasticsearch-Container auf Ihrem Computer ausgeführt wird, sehen Sie eine Ausgabe ähnlich der folgenden.

Konfigurieren des Kibana-Indexmusters

Nachdem Sie die Bereitstellung des EFK-Stacks in der Docker-Umgebung abgeschlossen haben, öffnen Sie Kibana über Ihren Webbrowser. Sie richten ein Indexmuster für die Protokollüberwachung und -analyse ein.

1. Öffnen Sie Ihren bevorzugten Webbrowser und navigieren Sie zur Server-IP-Adresse, gefolgt vom Kibana-Dienstport 5601 (d. h. http://172.16.1.10:5601).

2. Klicken Sie anschließend auf Selbst erkunden Schaltfläche auf der Willkommensseite unten.

3. Klicken Sie auf Stapelverwaltung Option zum Einrichten des Kibana-Indexmusters im Abschnitt Verwaltung.

4. Auf dem Kibana Klicken Sie im linken Menübereich auf Indexmuster und klicken Sie auf Indexmuster erstellen Schaltfläche, um ein neues Indexmuster zu erstellen.

5. Geben Sie nun das Indexmuster Name ein als fließend- *, legen Sie das Zeitstempelfeld fest an @timestamp und klicken Sie auf Indexmuster erstellen Taste, um die Indexmustereinstellungen zu bestätigen.

Auf der rechten Seite sehen Sie verfügbare Indexmuster von fluentd wie fluentd-%Y%m%d. Das Datumsformat %Y%m%d basiert auf der fluentd-Konfiguration (fluentd.conf ).

6. Klicken Sie abschließend auf das Menü oben links (Ellipse) und dann auf Entdecken Menü, um die Protokollüberwachung anzuzeigen.

Unten sehen Sie den Screenshot des Dashboards zur Protokollüberwachung und -analyse von Kibana. Alle aufgelisteten Protokolle stammen aus Elasticsearch und werden von der Fluentd-Protokollaggregation versendet.

Ausführen eines Docker-Containers mit dem Fluentd-Protokolltreiber

Nachdem Sie das Kibana-Indexmuster konfiguriert haben, führen Sie einen Docker-Container mit Fluentd-Protokolllaufwerk aus und senden automatisch Protokolle an den EFK-Stack.

1. Führen Sie den folgenden Befehl aus, um das NGINX-Image herunterzuladen. Die alpine Version ist kleiner als normale Images, die auf Ubuntu, CentOS oder Fedora basieren.

docker pull nginx:alpine

2. Führen Sie als Nächstes den folgenden Befehl aus, um einen neuen NGINX-Container zu starten (nginx_container ) im getrennten Modus (-d ).

Der Befehl legt auch das Protokolllaufwerk auf Fluentd (–log-driver=fluentd) fest und macht Port 8080 auf dem Docker-Hostcomputer für den Container verfügbar (nginx_container).

docker run --name nginx_container -d --log-driver=fluentd -p 8080:80 nginx:alpine

3. Führen Sie nach dem Ausführen des Containers docker aus Befehl unten, um alle laufenden Container zu überprüfen.

docker ps

Sie sollten sehen, dass der nginx_container betriebsbereit ist und auf dem Hostport 8080 ausgeführt wird.

4. Führen Sie nun den folgenden Befehl aus, um auf nginx_container zuzugreifen und Zugriffsprotokolle generieren.

curl localhost:8080

Öffnen Sie alternativ eine neue Registerkarte in Ihrem Webbrowser und geben Sie die Server-IP-Adresse gefolgt von Port 8080 ein (d. h. http://172.168.1.10:8080).

Wenn alles gut geht, sehen Sie die Standarddatei index.html Seite aus dem nginx_container.

5. Wechseln Sie schließlich zurück zum Kibana-Dashboard und klicken Sie auf Entdecken Menü auf der linken Seite.

Klicken Sie auf die Abfrage container_name :nginx_container im Feld KQL (Kibana Query Language) und Sie sehen Protokolle von nginx_container, wie unten gezeigt.

Schlussfolgerung

In diesem Tutorial haben Sie gelernt, wie Sie EFK Stack (Elasticsearch, Fluentd und Kibana) für die Protokollüberwachung und -analyse mit Docker bereitstellen. Sie haben auch gelernt, wie Sie die Protokollierung für den Docker-Container mithilfe des Fluentd-Protokolltreibers einrichten. Und an dieser Stelle haben Sie jetzt eine voll funktionsfähige Protokollüberwachung für Anwendungen und Dienste.

Für die nächste Phase könnten Sie daran interessiert sein, KQL (Kibana Query Language) zu verwenden, um Protokollüberwachung und -analyse zu visualisieren.