Wie man Kafka sichert und überwacht

Einführung

Apache Kafka unterstützt verschiedene Sicherheitsprotokolle und Authentifizierungsabläufe, um sicherzustellen, dass nur autorisierte Personen und Anwendungen eine Verbindung zum Cluster herstellen können. In der Standardkonfiguration erlaubt Kafka zwar allen Zugriff, es sind jedoch keine Sicherheitsprüfungen aktiviert. Dies ist zwar für Erkundungs- und Entwicklungszwecke nützlich, Produktionsumgebungen müssen jedoch vor der Freigabe für die Öffentlichkeit angemessen abgesichert werden. Zudem müssen solche Umgebungen überwacht werden, um einen reibungslosen Betrieb zu gewährleisten und potenzielle Ausfälle zu verhindern.

In diesem Tutorial optimieren Sie Ihre Kafka-Installation durch die Konfiguration von TLS-Verschlüsselung und SASL-Authentifizierung für einen standardisierten Anmeldevorgang mit Benutzername und Passwort. Sie erfahren, wie Sie die bereitgestellten Producer- und Consumer-Skripte für die Verbindung zu einem sicheren Cluster konfigurieren. Anschließend lernen Sie, wie Sie Kafka-Metriken exportieren und in Grafana visualisieren. Außerdem erfahren Sie, wie Sie über die benutzerfreundliche, webbasierte Oberfläche von AKHQ auf Ihre Clusterknoten und -themen zugreifen.

Voraussetzungen

• Ein Server mit mindestens 4 GB RAM und 2 Prozessoren. Für Ubuntu Server folgen Sie bitte den Anweisungen zur Ersteinrichtung des Servers.
• Apache Kafka ist auf Ihrem Droplet installiert und konfiguriert. Anweisungen zur Einrichtung finden Sie im Tutorial „Erste Schritte mit Kafka“. Sie müssen lediglich Schritt 1 und Schritt 2 ausführen.
• Machen Sie sich mit der Funktionsweise von Java bei der Verwaltung von Schlüsseln und Zertifikaten vertraut. Weitere Informationen finden Sie im Tutorial „Java Keytool Essentials: Arbeiten mit Java-Keystores“.
• Grafana ist auf Ihrem Server oder lokalen Rechner installiert. Eine Anleitung zur Installation und Absicherung von Grafana unter Ubuntu finden Sie im entsprechenden Tutorial. Sie müssen nur die ersten vier Schritte ausführen.
• Eine vollständig registrierte Domain verweist auf Ihren Server. In diesem Tutorial wird durchgehend „Ihre_Domain“ verwendet und verweist auf dieselbe Domain, die auch von Grafana benötigt wird. Sie können eine Domain bei Namecheap erwerben, eine kostenlose Domain bei Freenom erhalten oder einen Domain-Registrar Ihrer Wahl nutzen.

Schritt 1 – Kafka-Sicherheitsprotokolle konfigurieren

In der Standardkonfiguration erlaubt Kafka jedem, sich ohne Überprüfung des Ursprungs der Anfrage zu verbinden. Das bedeutet, dass Ihr Cluster standardmäßig für alle zugänglich ist. Dies ist zwar für Testzwecke vorteilhaft, da es den Wartungsaufwand für lokale Rechner und private Installationen reduziert, jedoch sollten in Produktionsumgebungen und öffentlichen Kafka-Installationen Sicherheitsfunktionen aktiviert sein, um unberechtigten Zugriff zu verhindern.

In diesem Schritt konfigurieren Sie Ihren Kafka-Broker so, dass die TLS-Verschlüsselung für den Datenverkehr zwischen Broker und Konsumenten verwendet wird. Außerdem richten Sie SASL als Authentifizierungsframework für die Authentifizierung beim Verbindungsaufbau zum Cluster ein.

TLS-Zertifikatgenerierung und -speicherung

Um die für die Einrichtung von TLS benötigten Zertifikate und Schlüssel zu generieren, verwenden Sie das Skript aus dem Repository der Confluent Platform Security Tools. Klonen Sie es zunächst in Ihr Home-Verzeichnis, indem Sie folgenden Befehl ausführen:

git clone https://github.com/confluentinc/confluent-platform-security-tools.git ~/kafka-ssl

Geh dorthin:

cd ~/kafka-ssl

Das verwendete Skript heißt kafka-generate-ssl-automatic.sh und fordert Sie auf, Ihr Land, Bundesland/Kanton, Ihre Organisation und Ihre Stadt als Umgebungsvariablen anzugeben. Diese Parameter werden zur Generierung der Zertifikate verwendet, ihr Inhalt ist jedoch irrelevant. Sie müssen außerdem ein Passwort angeben, das zum Schutz des erstellten Java-Truststores und Keystores dient.

Um die erforderlichen Umgebungsvariablen festzulegen, führen Sie die folgenden Befehle aus und ersetzen Sie dabei Ihr_tls_passwort durch den gewünschten Wert:

export COUNTRY=US
export STATE=NY
export ORGANIZATION_UNIT=SE
export CITY=New York
export PASSWORD=your_tls_password

Beachten Sie, dass das Passwort mindestens sechs Zeichen lang sein muss.

Erteilen Sie dem Skript Ausführungsrechte, indem Sie Folgendes ausführen:

chmod +x kafka-generate-ssl-automatic.sh

Führen Sie es anschließend aus, um die benötigten Dateien zu generieren:

./kafka-generate-ssl-automatic.sh

Es wird eine umfangreiche Ausgabe erzeugt. Nach Abschluss des Vorgangs listen Sie die Dateien im Verzeichnis auf:

ls -l

Die Ausgabe sollte folgendermaßen aussehen:

Outputrw-rw-r-- 1 kafka kafka 964 May 13 09:33 README.md
-rw-rw-r-- 1 kafka kafka 1063 May 13 09:34 cert-file
-rw-rw-r-- 1 kafka kafka 1159 May 13 09:34 cert-signed
-rwxrw-r-- 1 kafka kafka 6016 May 13 09:33 kafka-generate-ssl-automatic.sh
-rwxrwxr-x 1 kafka kafka 7382 May 13 09:33 kafka-generate-ssl.sh
drwxrwxr-x 2 kafka kafka 4096 May 13 09:34 keystore
-rw-rw-r-- 1 kafka kafka 184929 May 13 09:33 single-trust-store-diagram.pages
-rw-rw-r-- 1 kafka kafka 36980 May 13 09:33 single-trust-store-diagram.pdf
drwxrwxr-x 2 kafka kafka 4096 May 13 09:34 truststore

Sie werden sehen, dass Zertifikat, Vertrauensstellung und Keystore erfolgreich erstellt wurden.

Kafka für TLS und SASL konfigurieren

Nachdem Sie nun die notwendigen Dateien zur Aktivierung der TLS-Verschlüsselung haben, konfigurieren Sie Kafka so, dass es diese verwendet und Benutzer mithilfe von SASL authentifiziert.

Sie werden die Datei server.properties im Abschnitt config/kraft des Installationsverzeichnisses bearbeiten. Sie haben Kafka im Rahmen der Voraussetzungen in Ihrem Home-Verzeichnis installiert. Sie können dorthin wechseln, indem Sie folgenden Befehl ausführen:

cd ~/kafka

Öffnen Sie die Hauptkonfigurationsdatei zur Bearbeitung:

nano config/kraft/server.properties

Finden Sie die folgenden Zeilen:

...
listeners=PLAINTEXT://:9092,CONTROLLER://:9093
# Name of listener used for communication between brokers.
inter.broker.listener.name=PLAINTEXT
# Listener name, hostname and port the broker will advertise to clients.
# If not set, it uses the value for "listeners".
advertised.listeners=PLAINTEXT://localhost:9092

Ändern Sie sie wie folgt, wobei Sie PLAINTEXT durch BROKER ersetzen:

...
listeners=BROKER://:9092,CONTROLLER://:9093
# Name of listener used for communication between brokers.
inter.broker.listener.name=BROKER
# Listener name, hostname and port the broker will advertise to clients.
# If not set, it uses the value for "listeners".
advertised.listeners=BROKER://localhost:9092

Suchen Sie dann die Zeile listener.security.protocol.map:

# Maps listener names to security protocols, the default is for them to be the same. See the config documentation for more details
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Ordnen Sie BROKER SASL_SSL zu, indem Sie die Definition mit dem Wert einbetten:

# Maps listener names to security protocols, the default is for them to be the same. See the config documentation for more details
listener.security.protocol.map=BROKER:SASL_SSL,CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Hier haben Sie die BROKER-Aliasdefinition hinzugefügt, die Sie in den Listenern verwendet haben, und sie SASL_SSL zugeordnet, was bedeutet, dass sowohl SSL (die frühere Bezeichnung für TLS) als auch SASL verwendet werden sollen.

Gehen Sie anschließend zum Ende der Datei und fügen Sie die folgenden Zeilen hinzu:

ssl.truststore.location=/home/kafka/kafka-ssl/truststore/kafka.truststore.jks
ssl.truststore.password=your_tls_password
ssl.keystore.location=/home/kafka/kafka-ssl/keystore/kafka.keystore.jks
ssl.keystore.password=your_tls_password
ssl.key.password=your_tls_password
ssl.client.auth=required
sasl.enabled.mechanisms=PLAIN
sasl.mechanism.controller.protocol=PLAIN
sasl.mechanism.inter.broker.protocol=PLAIN
authorizer.class.name=org.apache.kafka.metadata.authorizer.StandardAuthorizer
allow.everyone.if.no.acl.found=false
super.users=User:admin

Zuerst definieren Sie die Speicherorte und Passwörter für die von Ihnen erstellten Trust- und Key-Stores. Sie setzen den Parameter `ssl.client.auth` auf `required`, wodurch Kafka angewiesen wird, Verbindungen ohne gültiges TLS-Zertifikat abzulehnen. Anschließend aktivieren Sie den SASL-Mechanismus durch die Einstellung `PLAIN`. `PLAIN` unterscheidet sich von `PLAINTEXT` dadurch, dass es eine verschlüsselte Verbindung erfordert; beide basieren auf einer Kombination aus Benutzername und Passwort.

Abschließend legen Sie „StandardAuthorizer“ als Autorisierungsklasse fest. Diese prüft die Anmeldeinformationen anhand der Konfigurationsdatei, die Sie in Kürze erstellen werden. Anschließend setzen Sie den Parameter „allow.everyone.if.no.acl.found“ auf „false“, um den Zugriff für Verbindungen mit ungültigen Anmeldeinformationen einzuschränken. Außerdem wählen Sie den Administratorbenutzer als Superuser aus, da mindestens ein solcher Benutzer für administrative Aufgaben im Cluster erforderlich ist.

Vergessen Sie nicht, your_tls_password durch das Passwort zu ersetzen, das Sie im vorherigen Abschnitt in das Skript eingegeben haben. Speichern und schließen Sie anschließend die Datei.

Nachdem Sie Kafka konfiguriert haben, müssen Sie eine Datei erstellen, die die für die Verbindung zulässigen Anmeldeinformationen definiert. Kafka unterstützt den Java Authentication and Authorization Service (JAAS), ein Framework zur Implementierung von Authentifizierungsabläufen, und akzeptiert Anmeldeinformationen im JAAS-Format.

Sie speichern diese Einstellungen in einer Datei namens kafka-server-jaas.conf im Verzeichnis config/kraft. Erstellen und öffnen Sie die Datei zur Bearbeitung, indem Sie folgenden Befehl ausführen:

nano config/kraft/kafka-server-jaas.conf

Fügen Sie die folgenden Zeilen hinzu:

KafkaServer {
org.apache.kafka.common.security.plain.PlainLoginModule required
username="admin"
password="admin"
user_admin="admin";
};

Benutzername und Passwort legen die primären Zugangsdaten fest, die für die Kommunikation zwischen den Brokern im Cluster mit mehreren Knoten verwendet werden. Die Zeile „user_admin“ definiert einen Benutzer mit dem Benutzernamen „admin“ und dem Passwort „admin“, der sich von extern mit dem Broker verbinden kann. Speichern und schließen Sie die Datei anschließend.

Kafka benötigt die Datei `kafka-server-jaas.conf`, da diese die Hauptkonfiguration abschließt. Sie müssen die Konfiguration des Kafka-Systemd-Dienstes anpassen und einen Verweis darauf übergeben. Führen Sie folgenden Befehl aus, um den Dienst zur Bearbeitung zu öffnen:

sudo systemctl edit --full kafka

Mit dem Parameter „–full“ erhalten Sie Zugriff auf alle Inhalte des Dienstes. Suchen Sie die Zeile „ExecStart“:

...
User=kafka
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/kraft/server.properties > /home/kafka/kafka/kafka.log 2>&1'
...

Fügen Sie darüber die folgende Zeile ein, sodass es so aussieht:

...
User=kafka
Environment="KAFKA_OPTS=-Djava.security.auth.login.config=/home/kafka/kafka/config/kraft/kafka-server-jaas.conf"
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/kraft/server.properties > /home/kafka/kafka/kafka.log 2>&1'
...

Dadurch wird der Parameter `java.security.auth.login.config` in der Konfiguration auf den Pfad der JAAS-Konfigurationsdatei gesetzt und somit von der Hauptkonfiguration von Kafka getrennt. Speichern und schließen Sie die Datei anschließend. Laden Sie die Dienstdefinition neu, indem Sie folgenden Befehl ausführen:

sudo systemctl daemon-reload

Starten Sie anschließend Kafka neu:

sudo systemctl restart kafka

Sie haben nun die TLS-Verschlüsselung und die SASL-Authentifizierung für Ihre Kafka-Installation konfiguriert und lernen jetzt, wie Sie sich mithilfe der bereitgestellten Konsolenskripte damit verbinden.

Schritt 2 – Verbindung zu einem sicheren Cluster herstellen

In diesem Schritt lernen Sie, wie Sie mithilfe der bereitgestellten Konsolenskripte und JAAS-Konfigurationsdateien eine Verbindung zu einem sicheren Kafka-Cluster herstellen.

Die für die Manipulation von Nachrichtenproduktions- und -konsumthemen bereitgestellten Skripte verwenden intern ebenfalls Java und akzeptieren daher eine JAAS-Konfiguration, die die Speicherorte des Vertrauens- und Schlüsselspeichers sowie die SASL-Authentifizierung beschreibt.

Sie speichern diese Konfiguration in einer Datei namens client-jaas.conf in Ihrem Home-Verzeichnis. Erstellen Sie die Datei und öffnen Sie sie zur Bearbeitung:

nano ~/client-jaas.conf

Fügen Sie die folgenden Zeilen hinzu:

security.protocol=SASL_SSL
ssl.truststore.location=/home/kafka/kafka-ssl/truststore/kafka.truststore.jks
ssl.truststore.password=your_tls_password
ssl.keystore.location=/home/kafka/kafka-ssl/keystore/kafka.keystore.jks
ssl.keystore.password=your_tls_password
sasl.mechanism=PLAIN
sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="admin" password="admin";
ssl.endpoint.identification.algorithm=

Wie zuvor stellen Sie das Protokoll auf SASL_SSL ein und geben die Pfade und Passwörter für die erstellten Keystores und Truststores an. Anschließend wählen Sie den SASL-Mechanismus PLAIN und geben die Anmeldeinformationen für den Benutzer „admin“ an. Um Verbindungsprobleme zu vermeiden, löschen Sie explizit den Parameter „ssl.endpoint.identification.algorithm“, da die initialen Skripte den Hostnamen des Rechners, auf dem sie ausgeführt werden, als Zertifikatsendpunkt festlegen, was möglicherweise nicht korrekt ist.

Ersetzen Sie your_tls_password durch den entsprechenden Wert, speichern und schließen Sie anschließend die Datei.

Um diese Datei an die Skripte zu übergeben, können Sie den Parameter `--command-config` verwenden. Erstellen Sie mit folgendem Befehl ein neues Thema im Cluster:

bin/kafka-topics.sh --bootstrap-server localhost:9092 --create --topic new_topic --command-config ~/client-jaas.conf

Der Befehl sollte erfolgreich ausgeführt werden:

Output...
Created topic new_topic.

Um zu überprüfen, ob es erstellt wurde, listen Sie alle Threads im Cluster auf, indem Sie folgenden Befehl ausführen:

bin/kafka-topics.sh --bootstrap-server localhost:9092 --list --command-config ~/client-jaas.conf

Die Ausgabe zeigt, dass new_topic existiert:

Output__consumer_offsets
new_topic
...

In diesem Abschnitt haben Sie Ihre Kafka-Installation so konfiguriert, dass sie TLS-Verschlüsselung für den Datenverkehr und SASL für die Authentifizierung mit Benutzername und Passwort verwendet. Nun erfahren Sie, wie Sie verschiedene Kafka-Metriken über JMX mithilfe von Prometheus exportieren.

Schritt 3 – Kafka-JMX-Metriken mit Prometheus überwachen

In diesem Abschnitt verwenden Sie Prometheus, um Kafka-Metriken zu erfassen und diese in Grafana abzufragen. Dazu müssen Sie einen JMX-Exporter für Kafka einrichten und diesen mit Prometheus verbinden.

Kafka und Prometheus konfigurieren

Bevor Sie fortfahren, müssen Sie Prometheus installieren. Auf Ubuntu-Systemen können Sie apt verwenden. Die zugehörigen Paketquellen erhalten Sie durch folgenden Befehl:

sudo apt update

Installieren Sie anschließend Prometheus:

sudo apt install prometheus -y

Für andere Plattformen folgen Sie bitte den Installationsanweisungen auf der offiziellen Website.

Nach der Installation müssen Sie die JMX-Exporter-Bibliothek für Prometheus zu Ihrer Kafka-Installation hinzufügen. Gehen Sie zur Versionsseite und wählen Sie die neueste Version mit „javaagent“ im Namen aus. Zum Zeitpunkt der Erstellung dieses Dokuments war die aktuellste verfügbare Version 0.20.0. Verwenden Sie den folgenden Befehl, um die Bibliothek in das Verzeichnis „libs/“ herunterzuladen, in dem Kafka installiert ist:

curl https://repo.maven.apache.org/maven2/io/prometheus/jmx/jmx_prometheus_javaagent/0.20.0/jmx_prometheus_javaagent-0.20.0.jar -o ~/kafka/libs/jmx_prometheus_javaagent.jar

Die JMX-Exportbibliothek wird nun von Kafka ausgewählt.

Bevor Sie den Exporter aktivieren, müssen Sie festlegen, welche Metriken er an Prometheus melden soll. Diese Konfiguration speichern Sie in einer Datei namens `jmx-exporter.yml` im Verzeichnis `config/` Ihrer Kafka-Installation. Das JMX-Exporter-Projekt stellt eine geeignete Standardkonfiguration bereit. Führen Sie daher den folgenden Befehl aus, um diese als `jmx-exporter.yml` im Verzeichnis `config/` Ihrer Kafka-Installation zu speichern:

curl https://raw.githubusercontent.com/prometheus/jmx_exporter/main/example_configs/kafka-2_0_0.yml -o ~/kafka/config/jmx-exporter.yml

Als Nächstes müssen Sie den Kafka-Systemd-Dienst so anpassen, dass der Exporter aktiviert wird. Ändern Sie dazu die Umgebungsvariable KAFKA_OPTS, um den Exporter und seine Konfiguration einzuschließen. Führen Sie folgenden Befehl aus, um den Dienst zu bearbeiten:

sudo systemctl edit --full kafka

Ändern Sie die Zeile „Umgebung“ wie folgt:

Environment="KAFKA_OPTS=-Djava.security.auth.login.config=/home/kafka/kafka/config/kraft/kafka-server-jaas.conf -javaagent:/home/kafka/kafka/libs/jmx_prometheus_javaagent.jar=7075:/home/kafka/kafka/config/jmx-exporter.yml"

Hier verwenden Sie das Argument -javaagent, um den JMX-Exporter mit seiner Konfiguration zu initialisieren.

Wenn Sie fertig sind, speichern und schließen Sie die Datei und starten Sie Kafka anschließend mit folgendem Befehl:

sudo systemctl restart kafka

Überprüfen Sie nach einer Minute, ob der JMX-Exporter läuft, indem Sie abfragen, ob Port 7075 belegt ist:

sudo ss -tunelp | grep 7075

Die Ausgabe sollte folgendermaßen aussehen:

Outputtcp LISTEN 0 3 *:7075 *:* users:(("java",pid=6311,fd=137)) uid:1000 ino:48151 sk:8 cgroup:/system.slice/kafka.service v6only:0 <->

Diese Zeile zeigt an, dass Port 7075 von einem Java-Prozess verwendet wird, der vom Kafka-Dienst gestartet wurde und auf den JMX-Exporter verweist.

Nun konfigurieren Sie Prometheus zur Überwachung exportierter JMX-Metriken. Die Hauptkonfigurationsdatei befindet sich unter /etc/prometheus/prometheus.yml. Öffnen Sie diese zum Bearbeiten:

sudo nano /etc/prometheus/prometheus.yml

Finden Sie die folgenden Zeilen:

...
# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
# The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
- job_name: 'prometheus'
# Override the global default and scrape targets from this job every 5 seconds.
scrape_interval: 5s
scrape_timeout: 5s
# metrics_path defaults to '/metrics'
# scheme defaults to 'http'.
static_configs:
- targets: ['localhost:9090']
- job_name: node
# If prometheus-node-exporter is installed, grab stats about the local
# machine by default.
static_configs:
- targets: ['localhost:9100']

Fügen Sie im Abschnitt scrape_configs, der die von Prometheus zu überwachenden Endpunkte festlegt, einen neuen Abschnitt zum Abrufen von Kafka-Metriken hinzu:

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
# The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
- job_name: 'prometheus'
# Override the global default and scrape targets from this job every 5 seconds.
scrape_interval: 5s
scrape_timeout: 5s
# metrics_path defaults to '/metrics'
# scheme defaults to 'http'.
static_configs:
- targets: ['localhost:9090']
- job_name: node
# If prometheus-node-exporter is installed, grab stats about the local
# machine by default.
static_configs:
- targets: ['localhost:9100']
- job_name: 'kafka'
static_configs:
- targets: ['your_domain:7075']

Ein Kafka-Job hat ein Ziel, das auf einen JMX-Exportendpunkt verweist.

Denken Sie daran, „your_domain“ durch Ihren Domainnamen zu ersetzen. Speichern und schließen Sie die Datei anschließend. Starten Sie dann Prometheus mit folgendem Befehl:

sudo systemctl restart prometheus

Öffnen Sie in Ihrem Browser Port 9090 Ihrer Domain. Sie gelangen so zur Prometheus-Oberfläche. Klicken Sie im Abschnitt „Status“ auf „Ziele“, um die Jobs aufzulisten.

Beachten Sie, dass Prometheus den Kafka-Job übernommen hat und nun dessen Metriken erfasst. Im Folgenden erfahren Sie, wie Sie in Grafana darauf zugreifen.

Metriken in Grafana abfragen

Als Voraussetzung müssen Sie Grafana auf Ihrem Droplet installiert und unter Ihrer Domain platziert haben. Rufen Sie Grafana in Ihrem Browser auf und klicken Sie in der Seitenleiste im Bereich „Verbindungen“ auf „Neue Verbindung hinzufügen“. Geben Sie anschließend „Prometheus“ in das Suchfeld ein.

Klicken Sie auf Prometheus und anschließend oben rechts auf die Schaltfläche „Neue Datenquelle hinzufügen“. Sie werden aufgefordert, die Adresse der Prometheus-Instanz einzugeben:

Geben Sie http://your_domain_name:9090 ein und ersetzen Sie dabei Ihren tatsächlichen Domainnamen. Scrollen Sie anschließend nach unten und klicken Sie auf „Speichern & Testen“. Sie sollten eine Erfolgsmeldung erhalten.

Die Prometheus-Verbindung wurde zu Grafana hinzugefügt. Klicken Sie in der Seitenleiste auf „Erkunden“. Sie werden dann aufgefordert, eine Metrik auszuwählen. Geben Sie „kafka_“ ein, um alle Metriken des Clusters aufzulisten, wie hier gezeigt:

Wählen Sie beispielsweise die Metrik „kafka_log_log_size“ aus, die die Größe des internen Festplattenprotokolls in jeder Partition anzeigt, und klicken Sie dann oben rechts auf „Abfrage ausführen“. Anschließend werden Ihnen die resultierenden Größen im Zeitverlauf für jedes der verfügbaren Themen angezeigt:

Sie haben nun die von Kafka bereitgestellten JMX-Exportmetriken eingerichtet und Prometheus so konfiguriert, dass diese abgerufen werden. Anschließend haben Sie sich von Grafana aus mit den Kafka-Metriken verbunden und eine Abfrage durchgeführt. Im Folgenden erfahren Sie, wie Sie einen Kafka-Cluster über eine Weboberfläche verwalten.

Schritt 4 – Kafka-Cluster mit AKHQ verwalten

In diesem Schritt lernen Sie, wie Sie AKHQ, eine Webanwendung zur Verwaltung von Kafka-Clustern, einrichten und verwenden. Mit AKHQ können Sie Topics, Partitionen, Consumer-Gruppen und Konfigurationsparameter auflisten und bearbeiten sowie Nachrichten von Topics zentral erzeugen und konsumieren.

Sie speichern die ausführbare Datei und ihre Konfigurationsdatei in einem Verzeichnis namens akhq. Erstellen Sie dieses Verzeichnis in Ihrem Home-Verzeichnis, indem Sie Folgendes ausführen:

mkdir ~/akhq

Geh dorthin:

cd ~/akhq

Öffnen Sie in Ihrem Browser die offizielle Release-Seite und kopieren Sie den Link zur neuesten JAR-Datei. Zum Zeitpunkt der Erstellung dieses Dokuments war die neueste Version 0.24.0. Führen Sie folgenden Befehl aus, um die Datei in Ihr Home-Verzeichnis herunterzuladen:

curl -L https://github.com/tchiotludo/akhq/releases/download/0.24.0/akhq-0.24.0-all.jar -o ~/akhq/akhq.jar

Sie haben AKHQ nun heruntergeladen und können die Konfiguration für die Verbindung zu Ihrem Cluster festlegen. Speichern Sie die Konfiguration in einer Datei namens akhq-config.yml. Erstellen und öffnen Sie die Datei zur Bearbeitung, indem Sie folgenden Befehl ausführen:

nano ~/akhq/akhq-config.yml

Fügen Sie die folgenden Zeilen hinzu:

akhq:
connections:
localhost-sasl:
properties:
bootstrap.servers: "localhost:9092"
security.protocol: SASL_SSL
sasl.mechanism: PLAIN
sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username="admin" password="admin";
ssl.truststore.location: /home/kafka/kafka-ssl/truststore/kafka.truststore.jks
ssl.truststore.password: secret
ssl.keystore.location: /home/kafka/kafka-ssl/keystore/kafka.keystore.jks
ssl.keystore.password: secret
ssl.key.password: secret
ssl.endpoint.identification.algorithm: ""

Dies ist eine grundlegende AKHQ-Konfiguration, die einen Cluster unter localhost:9092 mit den angegebenen SASL- und TLS-Parametern definiert. Es werden auch mehrere Cluster gleichzeitig unterstützt, da Sie beliebig viele Verbindungen definieren können. Dadurch ist AKHQ vielseitig für die Kafka-Verwaltung einsetzbar. Speichern und schließen Sie die Datei nach Abschluss der Konfiguration.

Als Nächstes müssen Sie einen systemd-Dienst definieren, der AKHQ im Hintergrund ausführt. Systemd-Dienste können fortlaufend gestartet, gestoppt und neu gestartet werden.

Die Dienstkonfiguration speichern Sie in einer Datei namens code-server.service im Verzeichnis /lib/systemd/system, wo systemd seine Dienste speichert. Erstellen Sie diese Datei mit Ihrem Texteditor:

sudo nano /etc/systemd/system/akhq.service

Fügen Sie die folgenden Zeilen hinzu:

[Unit]
Description=akhq
[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c 'java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar'
Restart=on-abnormal
[Install]
WantedBy=multi-user.target

Zuerst geben Sie die Dienstbeschreibung an. Anschließend definieren Sie im Feld [Service] den Diensttyp (einfach bedeutet, dass der Befehl einfach ausgeführt werden soll) und geben den auszuführenden Befehl an. Sie legen außerdem fest, dass der Dienst unter dem Benutzer „kafka“ ausgeführt wird und dass er bei Beendigung automatisch neu gestartet werden soll.

Der Abschnitt [Installieren] weist das System an, diesen Dienst zu starten, sobald Sie sich an Ihrem Server anmelden können. Speichern und schließen Sie die Datei nach Abschluss der Installation.

Laden Sie die Diensteinstellungen durch Ausführen von:

sudo systemctl daemon-reload

Starten Sie den AKHQ-Dienst, indem Sie folgenden Befehl ausführen:

sudo systemctl start akhq

Überprüfen Sie anschließend anhand des Status, ob der Dienst ordnungsgemäß gestartet wurde:

sudo systemctl status akhq

Die Ausgabe sollte folgendermaßen aussehen:

Output● akhq.service - akhq
Loaded: loaded (/etc/systemd/system/akhq.service; disabled; vendor preset: enabled)
Active: active (running) since Wed 2024-05-15 07:37:10 UTC; 3s ago
Main PID: 3241 (sh)
Tasks: 21 (limit: 4647)
Memory: 123.3M
CPU: 4.474s
CGroup: /system.slice/akhq.service
├─3241 /bin/sh -c "java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar"
└─3242 java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar

AKHQ läuft jetzt im Hintergrund. Standardmäßig wird es auf Port 8080 angezeigt. Rufen Sie in Ihrem Browser Ihre Domain mit diesem Port auf, um darauf zuzugreifen. Sie sehen dann die Standardansicht mit einer Liste der Themen.

Sie können auf die Zeile mit dem Thema in der Tabelle doppelklicken, um eine detaillierte Ansicht zu erhalten:

AKHQ ermöglicht es Ihnen, die Nachrichten im Thema sowie die Partitionen, Verbrauchergruppen und deren Konfiguration anzuzeigen. Sie können das Thema auch mithilfe der Schaltflächen unten rechts leeren oder kopieren.

Da das Thema „new_topic“ leer ist, drücken Sie die Schaltfläche „In Thema exportieren“. Dadurch öffnet sich die Benutzeroberfläche zur Auswahl der Parameter der neuen Nachricht:

AKHQ füllt den Themennamen automatisch für Sie aus. Geben Sie im Feld „Wert“ „Hallo Welt!“ ein und klicken Sie anschließend auf „Produzieren“. Die Nachricht wird an Kafka gesendet und ist im Daten-Tab sichtbar.

Da der Inhalt einer Nachricht sehr umfangreich sein kann, zeigt AKHQ nur die erste Zeile an. Um die vollständige Nachricht anzuzeigen, klicken Sie auf den dunklen Bereich nach der Zeile.

In der linken Seitenleiste können Sie die Broker im Cluster durch Klicken auf „Knoten“ auflisten. Derzeit besteht der Cluster nur aus einem Knoten:

Durch Doppelklicken auf einen Knoten wird dessen Konfiguration geöffnet, sodass Sie alle Einstellungen remote ändern können:

Nachdem Sie Ihre Änderungen vorgenommen haben, können Sie diese mit einem Klick auf die Schaltfläche „Konfigurationen aktualisieren“ unten rechts übernehmen. Ebenso können Sie die Konfiguration jedes einzelnen Designs anzeigen und ändern, indem Sie es auswählen und zum Tab „Konfigurationen“ wechseln.

In diesem Abschnitt haben Sie AKHQ eingerichtet, eine Webanwendung mit einer benutzerfreundlichen Oberfläche zur Fernverwaltung und -anzeige von Kafka-Knoten und -Themen. Sie ermöglicht das Erstellen und Empfangen von Nachrichten in Themen sowie das Aktualisieren von Konfigurationsparametern sowohl von Themen als auch von Knoten.

Ergebnis

In diesem Tutorial haben Sie Ihre Kafka-Installation durch die Konfiguration von TLS für die Verschlüsselung und SASL für die Benutzerauthentifizierung abgesichert. Außerdem haben Sie Metrikexporte mit Prometheus eingerichtet und diese in Grafana visualisiert. Anschließend haben Sie die Verwendung von AKHQ, einer Webanwendung zur Verwaltung von Kafka-Clustern, kennengelernt.