So installierst du Apache Kafka auf Rocky Linux

Apache Kafka ist ein verteilter Datenspeicher zur Verarbeitung von Streaming-Daten in Echtzeit. Er wird von der Apache Software Foundation entwickelt und ist in Java und Scala geschrieben. Apache Kafka wird zum Aufbau von Echtzeit-Datenstrom-Pipelines und Anwendungen verwendet, die sich an den Datenstrom anpassen, insbesondere für Unternehmensanwendungen und geschäftskritische Anwendungen. Es ist eine der beliebtesten Datenstromplattformen, die von Tausenden von Unternehmen für Hochleistungsdatenpipelines, Streaming-Analysen und Datenintegration genutzt wird.

Apache Kafka kombiniert Messaging, Speicherung und Stream-Verarbeitung an einem Ort. Ermöglicht es den Nutzern, leistungsstarke Datenströme zum Sammeln, Verarbeiten und Streamen von Daten in Echtzeit einzurichten. Es wird in modernen verteilten Anwendungen eingesetzt und kann Milliarden von Streaming-Ereignissen verarbeiten.

In diesem Lernprogramm werden wir Apache Kafka auf dem Rocky Linux Server installieren und die grundlegende Nutzung von Kafka als Message Broker für das Streaming von Daten über das Kafka-Plugin lernen.

Voraussetzungen

Um diesem Tutorial zu folgen, brauchst du die folgenden Voraussetzungen

• Einen Rocky Linux Server – Du kannst Rocky Linux v8 oder v9 verwenden.
• Einen Nicht-Root-Benutzer mit sudo Root-Rechten.

Installation von Java OpenJDK

Apache Kafka ist eine Java-basierte Anwendung. Um Kafka zu installieren, musst du zunächst Java auf deinem System installieren. Zum Zeitpunkt der Erstellung dieses Artikels benötigt die neueste Version von Apache Kafka mindestens Java OpenJDK v11.

Im ersten Schritt installierst du Java OpenJDK 11 aus dem offiziellen Rocky Linux Repository.

Führe den folgenden dnf-Befehl aus, um Java OpenJDK 11 auf deinem Rocky Linux-System zu installieren.

sudo dnf install java-11-openjdk

Wenn du aufgefordert wirst, die Installation zu bestätigen, gib y ein und drücke ENTER, um fortzufahren.

Nachdem Java installiert ist, überprüfe die Java-Version mit dem folgenden Befehl. Du wirst sehen, dass Java OpenJDK 11 auf deinem Rocky Linux System installiert ist.

java version

Jetzt, wo Java installiert ist, beginnst du als Nächstes mit der Installation von Apache Kafka.

Herunterladen von Apache Kafka

Apache Kafka bietet mehrere Binärpakete für verschiedene Betriebssysteme, einschließlich Linux/Unix. In diesem Schritt erstellst du einen neuen Systembenutzer für Kafka, lädst das Kafka-Binärpaket herunter und konfigurierst die Apache Kafka-Installation.

Führe den folgenden Befehl aus, um einen neuen Systembenutzer namens„kafka“ anzulegen. Dadurch wird ein neuer Systembenutzer für Kafka mit dem Standard-Stammverzeichnis „/opt/kafka“ erstellt, das als Kafka-Installationsverzeichnis verwendet wird.

sudo useradd -r -d /opt/kafka -s /usr/sbin/nologin kafka

Verschiebe nun dein Arbeitsverzeichnis nach „/opt“. Dann lädst du das Apache Kafka Binärpaket mit dem unten stehenden curl-Befehl herunter. Du siehst nun die Datei„kafka.tar.gz„.

cd /opt
sudo curl -fsSLo kafka.tgz https://downloads.apache.org/kafka/3.3.1/kafka_2.12-3.3.1.tgz

Entpacke die Datei „kafka.tar.gz“ mit dem Befehl tar und benenne das entpackte Verzeichnis in „/opt/kafka“ um.

tar -xzf kafka.tgz
sudo mv kafka_2.12-3.3.1 /opt/kafka

Als Nächstes änderst du mit dem Befehl chmod den Eigentümer des Verzeichnisses „/opt/kafka“ auf den Benutzer„kafka„.

sudo chown -R kafka:kafka /opt/kafka

Danach erstellst du ein neues Logs-Verzeichnis für Apache Kafka. Bearbeite dann die Standardkonfiguration „server.properties“ mit dem nano-Editor.

sudo -u kafka mkdir -p /opt/kafka/logs
sudo -u kafka nano /opt/kafka/config/server.properties

Das Kafka-Logs-Verzeichnis wird zum Speichern von Apache Kafka-Logs verwendet und du musst das Logs-Verzeichnis in der Kakfka-Konfiguration sertver.properties definieren.

Entferne den Kommentar in der Option „log.dirs“ und ändere den Wert in„/opt/kafka/logs„.

# logs configuration for Apache Kafka
log.dirs=/opt/kafka/logs

Speichere die Datei und beende den Editor, wenn du fertig bist.

Du hast nun die grundlegende Installation und Konfiguration von Apache Kafka abgeschlossen. Als Nächstes wirst du Apache Kafka als Systemd-Dienst einrichten und ausführen.

Kafka als Systemd-Dienst betreiben

Das Apache Kafka-Paket enthält eine weitere Anwendung, Zookeeper, die dazu dient, die Dienste zu zentralisieren und die Wahl des Kafka-Controllers, die Konfigurationen der Topics und die ACLs (Access Control Lists) für den Apache Kafka-Cluster zu verwalten.

Um Apache Kafka zu starten, musst du zuerst Zookeeper auf deinem System ausführen. In diesem Schritt erstellst du eine neue systemd-Dienstdatei sowohl für Zookeeper als auch für Apache Kafka. Beide Dienste werden außerdem unter demselben Benutzer„kafka“ laufen.

Erstelle eine neue Dienstdatei für Zookeeper „/etc/systemd/system/zookeeper.service“ mit dem folgenden Befehl.

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

Füge die Konfiguration in die Datei ein.

[Unit]
Requires=network.target remote-fs.target
After=network.target remote-fs.target
[Service]
Type=simple
User=kafka
ExecStart=/opt/kafka/bin/zookeeper-server-start.sh /opt/kafka/config/zookeeper.properties
ExecStop=/opt/kafka/bin/zookeeper-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

Speichere die Datei und beende den Editor, wenn du fertig bist.

Als Nächstes erstellst du mit dem folgenden Befehl eine neue Servicedatei für Apache Kafka„/etc/systemd/system/kafka.service„.

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

Füge die folgende Konfiguration in die Datei ein. Im Abschnitt „[Unit]“ kannst du sehen, dass der Kafka-Dienst zuerst nach dem„zookeeper.service“ ausgeführt werden muss und immer nach dem„zookeeper.service“ läuft.

[Unit]
Requires=zookeeper.service
After=zookeeper.service
[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c '/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/server.properties > /opt/kafka/logs/start-kafka.log 2>&1'
ExecStop=/opt/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

Speichere die Datei und beende den Editor, wenn du fertig bist.

Als nächstes führst du den folgenden systemctl-Befehl aus, um den systemd-Manager neu zu laden und die neuen Dienste anzuwenden.

sudo systemctl daemon-reload

Starte nun die Dienste zookeeper und kafka mit dem folgenden Befehl.

sudo systemctl start zookeeper
sudo systemctl start kafka

Aktiviere die Dienste kafka und zookeeper mit dem folgenden systemctl-Befehl, damit sie beim Systemstart automatisch ausgeführt werden.

sudo systemctl enable zookeeper
sudo systemctl enable kafka

Überprüfe abschließend den Zookeeper- und den Kafka-Dienst mit dem folgenden Befehl.

sudo systemctl status zookeeper
sudo systemctl status kafka

In der unten stehenden Ausgabe kannst du sehen, dass der Zookeeper-Dienst läuft und aktiviert ist.

Und unten siehst du den Status des Kafka-Dienstes: Er läuft und ist aktiviert.

Nachdem du die Installation von Apache Kafka abgeschlossen hast und es nun läuft, lernst du als Nächstes die grundlegende Verwendung von Apache Kafka als Nachrichtenbroker für die Erzeugung von Nachrichten kennen und erfährst, wie du das Kafka-Plugin zum Streamen von Daten in Echtzeit verwendest.

Grundlegende Bedienung mit der Kafka-Konsole Producer und Consumer

Bevor du beginnst, solltest du wissen, dass alle Befehle, die in diesem Beispiel verwendet werden, im Kafka-Paket enthalten sind, das im Verzeichnis „/opt/kafka/bin“ verfügbar ist.

In diesem Schritt lernst du, wie du Kafka-Themen erstellst und auflistest, den Producer startest und Daten einfügst, Daten über das Consumer-Skript streamst und schließlich deine Umgebung aufräumst, indem du das Kafka-Thema löschst.

Führe den folgenden Befehl aus, um ein neues Kafka-Topic zu erstellen. Du verwendest das Skript„kafka-topics.sh„, um ein neues Topic mit dem Namen„TestTopic“ mit einer Replikation und einer Partition zu erstellen.

sudo -u kafka /opt/kafka/bin/kafka-topics.sh \
--create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic TestTopic

Führe nun den folgenden Befehl aus, um die Liste der Topics in deinem Kafka zu überprüfen. Du solltest sehen, dass das„TestTopic“ auf deinem Kafka-Server erstellt wurde.

sudo -u kafka /opt/kafka/bin/kafka-topics.sh --list --bootstrap-server localhost:9092

Als Nächstes kannst du das Skript„kafka-console-producser.sh“ verwenden, um Nachrichten zu erzeugen und dann Daten einzufügen, die verarbeitet werden sollen.

Führe den folgenden Befehl aus, um den Kafka Console Producer zu starten und gib das Thema„TestTopic“ an.

sudo -u kafka /opt/kafka/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic TestTopic

Nachdem du den Kafka Console Producer gestartet hast, gibst du eine beliebige Nachricht ein, die verarbeitet werden soll.

Als nächstes öffnest du eine neue Terminalsitzung und meldest dich am Server an. Öffne dann den Kafka Console Consumer über das Skript„kafka-conosle-consumer.sh„.

Führe den unten stehenden Befehl aus, um den Kafka Console Consumer zu starten und gib das Topic„TestTopic“ an.

sudo -u kafka /opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic TestTopic --from-beginning

Auf dem Screenshot unten siehst du, dass alle Nachrichten vom Kafka Console Producer an die Consumer Console weitergeleitet werden. Du kannst auch andere Nachrichten auf dem Console Producer eingeben und die Nachricht wird automatisch weiterverarbeitet und auf dem Bildschirm des Console Consumer angezeigt.

Drücke nun Strg+c, um sowohl Kafka Console Producer als auch Kafka Console Consumer zu beenden.

Um deine Kafka-Umgebung zu bereinigen, kannst du das„TestTopic“ mit dem folgenden Befehl löschen und entfernen.

sudo -u kafka /opt/kafka/bin/kafka-topics.sh --bootstrap-server localhost:9092 --delete --topic TestTopic

Daten streamen mit dem Kafka Connect Plugin

Apache Kafka bietet mehrere Plugins, mit denen du Daten aus verschiedenen Quellen streamen kannst. Zusätzliche Kafka-Bibliotheks-Plugins sind standardmäßig im Verzeichnis „/opt/kafka/libs“ verfügbar. Du musst die Kafka-Plugins über die Konfigurationsdatei „/opt/kafka/config/connect-standalone.properties“ aktivieren. In diesem Fall für den Kafka-Standalone-Modus.

Führe den folgenden Befehl aus, um die Kafka-Konfigurationsdatei„/opt/kafka/config/connect-standalone.properties“ zu bearbeiten.

sudo -u kafka nano /opt/kafka/config/connect-standalone.properties

Entferne den Kommentar in der Zeile „plugin.path“ und ändere den Wert in das Bibliotheksverzeichnis des Plugins„/opt/kakfa/libs„.

plugin.path=/opt/kafka/libs

Speichere die Datei und beende den Editor, wenn du fertig bist.

Als Nächstes führst du den folgenden Befehl aus, um eine neue Datei„/opt/kafka/test.txt“ zu erstellen, die als Datenquelle für den Kafka-Stream verwendet werden soll.

sudo -u kafka echo -e "Test message from file\nTest using Kafka connect from file" > /opt/kafka/test.txt

Führe nun den folgenden Befehl aus, um den Kafka-Consumer im Standalone-Modus mit den Konfigurationsdateien„connect-file-source.properties“ und„connect-file-sink.properties“ zu starten.

Dieser Befehl und die Konfiguration sind ein Standardbeispiel für den Kafka-Datenstrom mit der Quelldatei„test.txt“, die du gerade erstellt hast. In diesem Beispiel wird auch automatisch ein neues Topic „connect-test“ erstellt, auf das du über die Kafka Console Consumer zugreifen kannst.

cd /opt/kafka
sudo -u kafka /opt/kafka/bin/connect-standalone.sh config/connect-standalone.properties config/connect-file-source.properties config/connect-file-sink.properties

Öffne nun eine weitere Terminalsitzung und führe den folgenden Befehl aus, um die Kafka Console Consumer zu starten. Gib auch das Thema „connect-test“ an. Du wirst die Nachricht aus der Datei„test.txt“ sehen.

sudo -u kafka /opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic connect-test --from-beginning

Jetzt kannst du die Datei„test.txt“ aktualisieren und die neuen Nachrichten werden automatisch verarbeitet und an den Kafka Console Consumer gestreamt.

Führe den folgenden Befehl aus, um die Datei„test.txt“ mit neuen Nachrichten zu aktualisieren.

sudo -u kafka echo "Another test message from file test.txt" >> test.txt

In der folgenden Ausgabe kannst du sehen, dass die neuen Nachrichten automatisch von Kafka verarbeitet werden, wenn sich die Datei„test.txt“ ändert. Damit hast du die grundlegende Verwendung des Kafka-Connect-Plugins zum Streamen von Nachrichten über Dateien abgeschlossen.

Fazit

In diesem Leitfaden hast du gelernt, wie du Apache Kafka auf dem Rocky Linux System installierst. Außerdem hast du die grundlegenden Funktionen der Kafka Producer Console zum Erstellen und Verarbeiten von Nachrichten und der Kafka Consumer Console zum Empfangen von Nachrichten kennengelernt. Schließlich hast du auch gelernt, wie du Kafka-Plugins aktivierst und das Kafka Connect Plugin nutzt, um Nachrichten in Echtzeit aus einer Datei zu streamen.