So installieren Sie den Elasticsearch, Fluentd und Kibana (EFK) Logging-Stack auf Ubuntu 22.04
Das Überwachen und Analysieren von Protokollen ist ein wesentlicher Bestandteil der Server- oder Container-Infrastruktur und nützlich beim Umgang mit komplexen Anwendungen. Eine der beliebten Logging-Lösungen ist der Elasticsearch, Fluentd und Kibana (EFK) Stack. Bevor wir weiter in das Tutorial eintauchen, lassen Sie uns die Komponenten des Stacks kennenlernen.
Elasticsearch ist eine Echtzeit-, verteilte und skalierbare Suchmaschine, die eine Volltextsuche und Analysen ermöglicht. Es wird verwendet, um große Datenmengen zu indizieren und zu durchsuchen. Es wird häufig zusammen mit Kibana bereitgestellt, einem leistungsstarken Datenvisualisierungs-Dashboard für Elasticsearch. Kibana ermöglicht es Ihnen, die Elasticsearch-Protokolldaten zu erkunden und Dashboards sowie Abfragen zu erstellen, um Einblicke in Ihre Anwendung zu gewinnen. Fluentd sammelt, transformiert und versendet die Protokolldaten an das Elasticsearch-Backend.
In diesem Tutorial werden wir den EFK-Stack mithilfe von Docker auf einer Ubuntu 22.04-Maschine installieren und Containerprotokolle an Kibana senden, nachdem wir sie mit Fluentd gefiltert und transformiert haben.
Voraussetzungen
Ein Server, der Ubuntu 22.04 mit mindestens 6 GB RAM ausführt.
Ein Nicht-Root-Benutzer mit Sudo-Rechten.
Die unkomplizierte Firewall (UFW) ist aktiviert und läuft.
Ein vollqualifizierter Domainname (FQDN), der auf den Server zeigt, wie kibana.example.com.
Alles ist aktualisiert. $ sudo apt update && sudo apt upgrade
Schritt 1 - Firewall konfigurieren
Bevor Sie Pakete installieren, besteht der erste Schritt darin, die Firewall so zu konfigurieren, dass HTTP- und HTTPS-Verbindungen erlaubt sind.
Überprüfen Sie den Status der Firewall.
$ sudo ufw status
Sie sollten etwas sehen, das wie folgt aussieht.
Status: aktiv
Zu Aktion Von
-- ------ ----
OpenSSH ERLAUBEN Überall
OpenSSH (v6) ERLAUBEN Überall (v6)
Erlauben Sie HTTP- und HTTPS-Ports.
$ sudo ufw allow http
$ sudo ufw allow https
Überprüfen Sie den Status erneut, um zu bestätigen.
$ sudo ufw status
Status: aktiv
Zu Aktion Von
-- ------ ----
OpenSSH ERLAUBEN Überall
80/tcp ERLAUBEN Überall
443 ERLAUBEN Überall
OpenSSH (v6) ERLAUBEN Überall (v6)
80/tcp (v6) ERLAUBEN Überall (v6)
443 (v6) ERLAUBEN Überall (v6)
Schritt 2 - Docker und Docker Compose installieren
Fügen Sie den offiziellen GPG-Schlüssel von Docker hinzu.
In diesem Tutorial verwenden wir das Docker Compose v2-Plugin anstelle des älteren Legacy-Binaries. Daher hat sich der Befehl zum Ausführen von docker-compose in docker compose geändert, und dies wird hier reflektiert.
Docker läuft mit erhöhten Rechten, sodass Sie häufig sudo verwenden müssen, um Befehle auszuführen. Die bessere Option ist, Ihr Linux-Benutzerkonto zur docker-Benutzergruppe hinzuzufügen.
$ sudo usermod -aG docker ${USER}
Die ${USER}-Variable erfasst das aktuell angemeldete Systemkonto. Wenn Sie nicht mit dem Benutzer angemeldet sind, dem Sie Berechtigungen erteilen möchten, ersetzen Sie ${USER} durch den Benutzernamen.
Um die neue Gruppenmitgliedschaft anzuwenden, melden Sie sich vom Server ab und wieder an oder verwenden Sie den folgenden Befehl. Sie werden nach dem Passwort des Benutzers gefragt.
$ su - ${USER}
Schritt 3 - Erstellen Sie die Docker Compose-Datei
Zuerst erstellen Sie das Verzeichnis für das EFK-Projekt.
$ mkdir ~/efk
Wechseln Sie in das Verzeichnis.
$ cd ~/efk
Erstellen und öffnen Sie die docker-compose.yml-Datei zur Bearbeitung.
$ nano docker-compose.yml
Fügen Sie den folgenden Code ein.
services:
# Bereitstellung mit dem benutzerdefinierten Bild, das während des Build-Prozesses automatisch erstellt wird.
fluentd:
build: ./fluentd
volumes:
- ./fluentd/conf:/fluentd/etc
links: # Sendet eingehende Protokolle an den Elasticsearch-Container.
- elasticsearch
depends_on:
- elasticsearch
ports: # Exponiert den Port 24224 sowohl im TCP- als auch im UDP-Protokoll für die Protokollaggregation
- 24224:24224
- 24224:24224/udp
elasticsearch:
image: elasticsearch:8.7.1
expose:
- 9200
environment:
- discovery.type=single-node # Läuft als Einzelknoten
- xpack.security.enabled=false
volumes: # Speichert Elasticsearch-Daten lokal im esdata-Docker-Volume
- esdata:/usr/share/elasticsearch/data
kibana:
image: kibana:8.7.1
links: # Verknüpft den Kibana-Dienst mit dem Elasticsearch-Container
- elasticsearch
depends_on:
- elasticsearch
ports:
- 5601:5601
environment: # Definierte Hostkonfiguration
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
# Definieren Sie das Docker-Volume mit dem Namen esdata für den Elasticsearch-Container.
volumes:
esdata:
Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden. Wir haben konfiguriert, um drei Dienste zu starten, einen für jeden, Fluentd, Elasticsearch und Kibana.
Für Fluentd werden wir einen Container erstellen, anstatt ein fertiges Bild zu verwenden. Die Build-Dateien für Fluentd werden im nächsten Schritt eingerichtet. Wir haben ein Verzeichnis für seine Build-Dateien und ein Volume für die Konfigurationsdateien gemountet und den Port 24224 sowohl im TCP- als auch im UDP-Protokoll für die Protokollaggregation exponiert.
Der nächste Dienst ist Elasticsearch, und wir verwenden die neueste Version, die zum Zeitpunkt des Schreibens dieses Tutorials verfügbar ist. Wir haben es über den Port 9200 exponiert und einige Umgebungsvariablen eingerichtet, damit wir es als Einzelknoten-Cluster ausführen können, und die Sicherheitsfunktionen deaktiviert. Dies wird normalerweise nicht empfohlen, aber die Aktivierung der Sicherheit liegt außerhalb des Rahmens dieses Tutorials. Wir haben auch ein lokales Volume für die Elasticsearch-Daten gemountet.
Schließlich konfigurieren wir Kibana und exponieren es über den Port 5601, der verwendet wird, um auf das Dashboard zuzugreifen. Wir haben auch eine Variable eingerichtet, um den Elasticsearch-Host zu konfigurieren, damit er darauf zugreifen kann.
Schritt 4 - Einrichten der Fluentd-Build-Dateien
Erstellen Sie Fluentd und das Konfigurationsverzeichnis.
$ mkdir fluentd/conf -p
Führen Sie den Befehl tree aus, um die Verzeichnisstruktur zu überprüfen.
$ tree
Es sollte wie folgt aussehen.
Wechseln Sie in das Fluentd-Verzeichnis.
$ cd fluentd
Erstellen und öffnen Sie die Dockerfile zur Bearbeitung.
$ nano Dockerfile
Fügen Sie den folgenden Code ein. Dieser Code zieht das Fluentd Debian Docker-Image und installiert das Fluentd-Plugin für Elasticsearch.
# fluentd/Dockerfile
FROM fluent/fluentd:v1.16-debian-1
USER root
RUN ["gem", "install", "fluent-plugin-elasticsearch", "--no-document", "--version", "5.3.0"]
USER fluent
Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Wechseln Sie in das Konfigurationsverzeichnis.
$ cd conf
Erstellen und öffnen Sie die fluentd.conf-Datei zur Bearbeitung.
$ nano fluentd.conf
Fügen Sie den folgenden Code ein.
# binde fluentd an IP 0.0.0.0
# port 24224
@type forward
port 24224
bind 0.0.0.0
# sendlog an den Elasticsearch
# der Host muss mit dem Elasticsearch
# Containerdienst übereinstimmen
@type copy
@type elasticsearch_dynamic
hosts elasticsearch:9200
logstash_format true
logstash_prefix fluentd
logstash_dateformat %Y%m%d
include_tag_key true
tag_key @log_name
include_timestamp true
flush_interval 30s
@type stdout
Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Die source-Direktive oben verwendet das forward-Plugin, das Fluentd in einen TCP-Endpunkt verwandelt, um TCP-Pakete zu akzeptieren.
Die match-Direktive sucht nach Ereignissen mit übereinstimmenden Tags, was in diesem Fall bedeutet, dass sie alle Ereignisse übereinstimmt. Wir werden das elasticsearch_dynamic-Plugin für die Speicherung verwenden, das es ermöglicht, Konfigurationswerte dynamisch anzugeben. Das Feld hosts gibt den Hostnamen für die Elasticsearch-Anwendung an, der der Dienstname in der Docker-Compose-Datei ist. Das logstash_format ist auf true gesetzt, was bedeutet, dass Fluentd das konventionelle Namensformat logstash-%Y.%m.%d verwendet. Der Präfixname zum Schreiben der Ereignisse ist auf fluentd gesetzt. Das include_tag_key ist auf true gesetzt, was den Fluentd-Tag im JSON-Format hinzufügt. Der tag_key ist der Feldname, der für das Tag extrahiert werden soll. Das Setzen der Variablen include_timestamp auf true fügt ein Zeitstempelfeld zum Protokoll hinzu. Das flush_interval gibt das Intervall zwischen den Datenflüssen an. Wir verwenden auch das stdout-Plugin, um Ereignisse/Protokolle an die Standardausgabe zu drucken.
Schritt 5 - Führen Sie die Docker-Container aus
Wechseln Sie zurück in das EFK-Verzeichnis.
$ cd ~/efk
Starten Sie die Container mit dem folgenden Befehl.
$ docker compose up -d
Überprüfen Sie den Status der laufenden Container.
Wie Sie sehen können, hat der Container die IP-Adresse 172.23.0.2 erhalten. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Elasticsearch korrekt funktioniert.
Jetzt, da der EFK-Stack bereitgestellt ist, ist es Zeit, Kibana zu konfigurieren. Öffnen Sie die URL http://:5601 im Browser.
Klicken Sie auf die Schaltfläche Erforschen Sie es selbst, um zum Kibana-Dashboard zu gelangen.
Klicken Sie auf den Link Stack-Verwaltung, um die Kibana-Datenansicht einzurichten. Wählen Sie die Option Kibana >> Datenansichten aus der linken Seitenleiste, um die Seite für die Datenansicht zu öffnen.
Klicken Sie auf die Schaltfläche Datenansicht erstellen, um fortzufahren.
Geben Sie den Namen der Datenansicht und das Indexmuster als fluentd-* ein. Stellen Sie sicher, dass das Zeitstempelfeld auf @timestamp eingestellt ist. Das Quellfeld wird automatisch aktualisiert. Klicken Sie auf die Schaltfläche Datenansicht in Kibana speichern, um die Datenansicht zu erstellen.
Klicken Sie als Nächstes auf das obere Menü (Ellipsen) und klicken Sie auf die Option Entdecken, um die Protokollüberwachung anzuzeigen.
Sie erhalten die folgende Seite, die bestätigt, dass Ihre Einrichtung perfekt funktioniert. Die Protokolle stammen alle von Elasticsearch und werden von der Fluentd-Protokollaggregation versendet.
Schritt 7 - Nginx installieren
Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Sie müssen das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.
Der erste Schritt besteht darin, das Let’s Encrypt SSL-Zertifikat zu installieren. Wir müssen Certbot installieren, um das SSL-Zertifikat zu generieren. Sie können Certbot entweder über das Ubuntu-Repository installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Ubuntu 22.04 wird standardmäßig mit Snapd installiert. Führen Sie die folgenden Befehle aus, um sicherzustellen, dass Ihre Version von Snapd auf dem neuesten Stand ist.
Verwenden Sie den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem Sie einen symbolischen Link zum Verzeichnis /usr/bin erstellen.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Generieren Sie das SSL-Zertifikat für die Domain kibana.example.com.
Überprüfen Sie den Certbot-Erneuerungsplanungsdienst.
$ sudo systemctl list-timers
Sie finden snap.certbot.renew.service als einen der Dienste, die geplant sind, um ausgeführt zu werden.
NEXT LEFT LAST PASSED UNIT ACTIVATES
------------------------------------------------------------------------------------------------------------------------------------
Mon 2023-05-06 13:37:57 UTC 3h 45min left Mon 2023-05-01 07:20:42 UTC 2h 31min ago ua-timer.timer ua-timer.service
Mon 2023-05-06 14:39:29 UTC 4h 47min left Sat 2023-02-04 16:04:18 UTC 2 months ago motd-news.timer motd-news.service
Mon 2023-05-06 15:53:00 UTC 6h left n/a n/a snap.certbot.renew.timer snap.certbot.renew.service
Führen Sie einen Testlauf des Prozesses durch, um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn Sie keine Fehler sehen, sind Sie bereit. Ihr Zertifikat wird automatisch erneuert.
Schritt 9 - Nginx konfigurieren
Erstellen und öffnen Sie die Nginx-Konfigurationsdatei für Kibana.
$ sudo nano /etc/nginx/conf.d/kibana.conf
Fügen Sie den folgenden Code ein. Ersetzen Sie die IP-Adresse durch die private IP-Adresse Ihres Elasticsearch-Servers.
Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Öffnen Sie die Datei /etc/nginx/nginx.conf zur Bearbeitung.
$ sudo nano /etc/nginx/nginx.conf
Fügen Sie die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; hinzu.
server_names_hash_bucket_size 64;
Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Überprüfen Sie die Konfiguration.
$ sudo nginx -t
nginx: die Konfigurationsdatei /etc/nginx/nginx.conf Syntax ist ok
nginx: Konfigurationsdatei /etc/nginx/nginx.conf Test war erfolgreich
Starten Sie den Nginx-Dienst neu.
$ sudo systemctl restart nginx
Es gibt noch einen Schritt, der erforderlich ist. Öffnen Sie die Docker-Compose-Datei zur Bearbeitung.
$ nano ~/docker-compose.yml
Fügen Sie die Zeile SERVER_PUBLICBASEURL=https://kibana.example.com unter dem Abschnitt Umgebung unter dem Kibana-Dienst wie folgt ein.
Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden, sobald Sie fertig sind.
Stoppen und entfernen Sie die Container.
$ docker compose down --remove-orphans
Starten Sie die Container erneut mit der aktualisierten Konfiguration.
$ docker compose up -d
Ihr Kibana-Dashboard sollte über die URL https://kibana.example.com von überall zugänglich sein.
Schritt 10 - Ausführen eines Docker-Containers mit dem Fluentd-Protokolltreiber
Jetzt werden wir einen Docker-Container mit dem Fluentd-Protokolltreiber ausführen, der automatisch Protokolle an den Stack sendet. Wir werden den Nginx-Container zu Testzwecken verwenden.
Ziehen Sie das Nginx-Image aus dem Docker Hub-Registry. Wir verwenden die alpine-Version, da es die kleinste Version des Images ist.
$ docker pull nginx:alpine
Führen Sie den folgenden Befehl aus, um den Nginx-Container zu erstellen und zu starten. Wir haben den Protokolltreiber auf Fluentd und den Port auf 8080 gesetzt, da der Standardport 80 bereits vom Nginx-Server im Proxy-Modus verwendet wird.
$ docker run --name nginx-fluentd-test -d --log-driver=fluentd -p 8080:80 nginx:alpine
Überprüfen Sie den Containerstatus.
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
038c43e4e1a3 nginx:alpine "/docker-entrypoint.…" vor 12 Sekunden Hoch 11 Sekunden 0.0.0.0:8080->80/tcp, :::8080->80/tcp nginx-fluentd-test
a94ca706bd0c efk-fluentd "tini -- /bin/entryp…" vor 8 Stunden Hoch 8 Stunden 5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp efk-fluentd-1
0cf04a446425 kibana:8.7.1 "/bin/tini -- /usr/l…" vor 8 Stunden Hoch 8 Stunden 0.0.0.0:5601->5601/tcp, :::5601->5601/tcp efk-kibana-1
7c7ad8f9b123 elasticsearch:8.7.1 "/bin/tini -- /usr/l…" vor 8 Stunden Hoch 8 Stunden 9200/tcp, 9300/tcp efk-elasticsearch-1
Führen Sie den folgenden Befehl aus, um auf den Nginx-Container zuzugreifen und Zugriffsprotokolle zu generieren.
$ curl localhost:8080
Willkommen bei nginx!
Willkommen bei nginx!
Wenn Sie diese Seite sehen, wurde der Nginx-Webserver erfolgreich installiert und
funktioniert. Weitere Konfiguration ist erforderlich.
Für Online-Dokumentation und Unterstützung besuchen Sie bitte
nginx.org.
Kommerzielle Unterstützung ist verfügbar unter
nginx.com.
Danke, dass Sie nginx verwenden.
Alternativ können Sie die URL http://:8080 in Ihrem Browser öffnen, und Sie erhalten die folgende Seite.
Öffnen Sie das Kibana-Dashboard und klicken Sie auf den Link Entdecken im linken Seitenmenü. Klicken Sie auf das +-Zeichen im oberen Menü, um das Popup Filter hinzufügen zu öffnen.
Wählen Sie das Feld container_name aus dem Dropdown-Menü, is als Operator und füllen Sie den Containernamen (nginx-fluentd-test) als Feldwert aus.
Klicken Sie auf die Schaltfläche Filter hinzufügen, um die Daten aus dem Nginx-Container zu visualisieren.
Fazit
Damit endet unser Tutorial zur Installation des Elasticsearch, Fluentd und Kibana (EFK) Logging-Stacks auf einer Ubuntu 22.04-Maschine. Wenn Sie Fragen haben, posten Sie diese bitte in den Kommentaren unten.
