Die Open-Source-Software Apache Kafka zählt zu den besten Lösungen zur Spei­che­rung und Ver­ar­bei­tung von Da­ten­strö­men. Die Messaging- und Streaming-Plattform, die unter der Apache-2.0-Lizenz steht, überzeugt durch Feh­ler­to­le­ranz, her­vor­ra­gen­de Ska­lier­bar­keit sowie eine hohe Lese- und Schreib­ge­schwin­dig­keit. Basis dieser für Big-Data-An­wen­dun­gen überaus in­ter­es­san­ten Merkmale ist ein Rech­ner­ver­bund (Cluster), der es er­mög­licht, Daten verteilt zu speichern und zu re­pli­zie­ren. Vier ver­schie­de­ne Schnitt­stel­len er­mög­li­chen die Kom­mu­ni­ka­ti­on mit dem Cluster, wobei ein einfaches TCP-Protokoll als Ver­stän­di­gungs­grund­la­ge dient.

In diesem Kafka-Tutorial sollen die ersten Schritte mit der in Scala ge­schrie­be­nen Anwendung erläutert werden – beginnend mit der In­stal­la­ti­on von Kafka und der für die Nutzung er­for­der­li­chen Software Apache ZooKeeper.

Vor­aus­set­zun­gen für die Nutzung von Apache Kafka

Um einen leis­tungs­fä­hi­gen Kafka-Cluster betreiben zu können, benötigen Sie die passende Hardware. Das Ent­wick­ler-Team empfiehlt den Einsatz von Intel Xeon Maschinen mit Quad-Core und 24 Gigabyte Ar­beits­spei­cher. Ganz prin­zi­pi­ell benötigen Sie aus­rei­chend Speicher, um jederzeit die Lese- und Schreib­zu­grif­fe aller An­wen­dun­gen zwi­schen­spei­chern zu können, die aktiv auf den Cluster zugreifen. Da ins­be­son­de­re der hohe Da­ten­durch­satz zu den Vorzügen von Apache Kafka zählt, ist auch die Wahl der passenden Fest­plat­ten von enormer Wich­tig­keit. Die Apache Software Foun­da­ti­on empfiehlt SATA-Fest­plat­ten­lauf­wer­ke (8 x 7200 UpM) – hin­sicht­lich der Ver­mei­dung von Leis­tungs­eng­päs­sen gilt der Grundsatz: Je mehr Fest­plat­ten, desto besser.

Auch hin­sicht­lich der Software müssen einige Vor­aus­set­zun­gen erfüllt werden, um Apache Kafka für das Ma­nage­ment ein­ge­hen­der und aus­ge­hen­der Da­ten­strö­me nutzen zu können. Bei der Wahl des Be­triebs­sys­tems sollten Sie bei­spiels­wei­se ein UNIX-System wie Solaris oder eine Linux-Dis­tri­bu­ti­on be­vor­zu­gen, da Windows-Platt­for­men nur ein­ge­schränkt un­ter­stützt werden. Da Apache Kafka in der nach Java kom­pi­lie­ren­den Sprache Scala ge­schrie­ben ist, muss außerdem eine möglichst aktuelle Version des Java SE De­ve­lo­p­ment Kits (JDK) auf Ihrem System in­stal­liert sein. Selbiges enthält unter anderem die Java-Lauf­zeit­um­ge­bung, die für das Ausführen von Java-An­wen­dun­gen benötigt wird. Eine weitere Pflicht­kom­po­nen­te ist der Service Apache ZooKeeper, der die Syn­chro­ni­sa­ti­on ver­teil­ter Prozesse er­mög­licht.

gZj16chk0Ss.jpg Zur Anzeige dieses Videos sind Cookies von Drittanbietern erforderlich. Ihre Cookie-Einstellungen können Sie hier aufrufen und ändern.

Apache-Kafka-Tutorial: So in­stal­lie­ren Sie Kafka, ZooKeeper und Java

Welche Software-Kom­po­nen­ten er­for­der­lich sind, haben wir im vor­an­ge­gan­ge­nen Teil dieses Kafka-Tutorials erklärt. Sofern sie nicht bereits auf Ihrem System ein­ge­rich­tet ist, beginnen Sie am besten mit der In­stal­la­ti­on der Java-Lauf­zeit­um­ge­bung. Viele neuere Versionen von Linux-Dis­tri­bu­tio­nen – wie Ubuntu, das in diesem Apache-Kafka-Tutorial bei­spiel­haft als Be­triebs­sys­tem dient (Version 17.10) – haben mit OpenJDK bereits eine kos­ten­freie JDK-Im­ple­men­tie­rung im of­fi­zi­el­len Pakete-Re­po­si­to­ry. Sie können das Java-Kit also ganz einfach über dieses in­stal­lie­ren, indem Sie Sie folgenden Befehl in das Terminal eingeben:

sudo apt-get install openjdk-8-jdk

Direkt im Anschluss an die Java-In­stal­la­ti­on fahren Sie mit der In­stal­la­ti­on des Prozess-Syn­chro­ni­sa­ti­ons-Dienstes Apache ZooKeeper fort. Auch für diesen hält das Ubuntu-Pa­ket­ver­zeich­nis ein ein­satz­fer­ti­ges Paket bereit, das sich fol­gen­der­ma­ßen über die Kom­man­do­zei­le ausführen lässt:

sudo apt-get install zookeeperd

Mit einem weiteren Befehl können Sie an­schlie­ßend über­prü­fen, ob der ZooKeeper-Dienst aktiv ist:

sudo systemctl status zookeeper

Läuft Apache ZooKeeper, sieht das Aus­ga­be­re­sul­tat wie folgt aus:

Läuft der Syn­chro­ni­sa­ti­ons­ser­vice nicht, können Sie ihn jederzeit mit diesem Befehl starten:

sudo systemctl start zookeeper

Damit ZooKeeper immer au­to­ma­tisch beim Sys­tem­start aus­ge­führt wird, legen Sie zum Abschluss noch einen Autostart-Eintrag an:

sudo systemctl enable zookeeper

Schließ­lich erstellen Sie noch ein Be­nut­zer­pro­fil für Kafka, das für die spätere Nutzung des Servers er­for­der­lich ist. Öffnen Sie hierfür erneut das Terminal und geben Sie folgenden Befehl ein:

sudo useradd kafka -m

Mithilfe des Passwort-Managers passwd fügen Sie dem Benutzer an­schlie­ßend ein Passwort hinzu, indem Sie das folgende Kommando und an­schlie­ßend das ge­wünsch­te Kennwort eintippen:

sudo passwd kafka

Im nächsten Schritt gewähren Sie dem Benutzer „kafka“ sudo-Rechte:

sudo adduser kafka sudo

Mit dem neu erstellen Be­nut­zer­pro­fil können Sie sich nun jederzeit einloggen:

su - kafka

An dieser Stelle des Tutorials ist es an der Zeit, Kafka her­un­ter­zu­la­den und zu in­stal­lie­ren. Es gibt eine Reihe ver­trau­ens­wür­di­ger Quellen, die sowohl ältere als auch aktuelle Versionen der Stream-Ver­ar­bei­tungs-Software zum Download zur Verfügung stellen. Direkt aus erster Hand erhalten Sie die In­stal­la­ti­ons­da­tei­en bei­spiels­wei­se über das Down­load­ver­zeich­nis der Apache Software Foun­da­ti­on. Es ist sehr emp­feh­lens­wert, mit einer aktuellen Kafka-Version zu arbeiten, weshalb Sie den folgenden Download-Befehl vor der Eingabe in das Terminal unter Umständen ent­spre­chend anpassen müssen:

wget http://www.apache.org/dist/kafka/2.1.0/kafka_2.12-2.1.0.tgz

Da es sich bei der her­un­ter­ge­la­de­nen Datei um eine kom­pri­mier­te Datei handelt, entpacken Sie diese im nächsten Schritt:

sudo tar xvzf kafka_2.12-2.1.0.tgz --strip 1

Mithilfe des Pa­ra­me­ters „--strip 1“ sorgen Sie dafür, dass die ex­tra­hier­ten Dateien direkt im Ver­zeich­nis „~/kafka“ ge­spei­chert werden. An­dern­falls würde Ubuntu auf Basis der in diesem Kafka-Tutorial ver­wen­de­ten Version alle Dateien im Ver­zeich­nis „~/kafka/kafka_2.12-2.1.0“ ablegen. Vor­aus­set­zung ist, dass Sie zuvor mithilfe von mkdir ein Ver­zeich­nis mit dem Namen „kafka“ erzeugt haben und in dieses ge­wech­selt sind (via „cd kafka“).

Kafka: Tutorial zur Ein­rich­tung des Streaming- und Messaging-Systems

Nachdem Sie nun Apache Kafka sowie die Java-Lauf­zeit­um­ge­bung und ZooKeeper in­stal­liert haben, können Sie den Kafka-Service prin­zi­pi­ell jederzeit ausführen. Bevor Sie dies tun, sollten Sie jedoch noch ein paar kleine Kon­fi­gu­ra­tio­nen vornehmen, damit die Software optimal für die be­vor­ste­hen­den Aufgaben ein­ge­stellt ist.

Löschen von Topics frei­schal­ten

Kafka erlaubt im Standard-Set-up nicht, Topics – also die Speicher- und Ka­te­go­ri­sie­rungs­ein­hei­ten eines Kafka-Clusters – zu löschen, was sich jedoch pro­blem­los über die Kafka-Kon­fi­gu­ra­ti­ons­da­tei server.pro­per­ties ändern lässt. Sie öffnen diese Datei, die sich im Ordner „config“ befindet, mit dem folgenden Terminal-Befehl im Standard-Text­edi­tor nano:

sudo nano ~/kafka/config/server.properties

Am Ende dieser Kon­fi­gu­ra­ti­ons­da­tei fügen Sie nun einen neuen Eintrag hinzu, der das Löschen von Kafka-Topics frei­schal­tet:

delete.topic.enable=true
Tipp

Vergessen Sie nicht, den neuen Eintrag in der Kafka-Kon­fi­gu­ra­ti­ons­da­tei zu speichern, bevor Sie den nano-Editor wieder schließen!

.service-Dateien für ZooKeeper und Kafka anlegen

Im nächsten Schritt dieses Kafka-Tutorials geht es darum, Unit-Dateien für ZooKeeper und Kafka zu erstellen, die es er­mög­li­chen, ge­wöhn­li­che Aktionen wie das Starten, Beenden oder Neu­star­ten der beiden Dienste passend zu anderen Linux-Services aus­zu­füh­ren. Dafür ist es notwendig, für beide An­wen­dun­gen .service-Dateien für den Sit­zungs­ma­na­ger systemd zu erstellen und ein­zu­rich­ten.

So erstellen Sie die passende ZooKeeper-Datei für den Ubuntu-Sit­zungs­ma­na­ger systemd

Erstellen Sie zunächst die Datei für den Syn­chro­ni­sa­ti­ons­ser­vice ZooKeeper, indem Sie folgenden Befehl in das Terminal eingeben:

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

Dadurch wird die Datei nicht nur erstellt, sondern auch gleich im nano-Editor geöffnet. Geben Sie dort nun folgende Zeilen ein und speichern Sie die Datei im Anschluss:

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

In­fol­ge­des­sen versteht systemd, dass ZooKeeper erst dann gestartet werden kann, wenn das Netzwerk und das Da­tei­sys­tem bereit sind, was in der Sektion [Unit] definiert ist. Unter [Service] ist spe­zi­fi­ziert, dass der Sit­zungs­ma­na­ger für den Start bzw. den Stopp von ZooKeeper die Dateien zookeeper-server-start.sh bzw. zookeeper-server-stop.sh nutzen soll. Zudem ist ein au­to­ma­ti­scher Neustart für solche Fälle definiert, in denen der Service un­vor­her­ge­se­hen gestoppt wurde. Der [Install]-Eintrag reguliert, wann die Datei gestartet wird, wobei „multi-user.target“ der Standard-Wert für ein Mehr­be­nut­zer­sys­tem (z. B. einen Server) ist.

Kafka-Datei für den Ubuntu-Sit­zungs­ma­na­ger systemd erstellen – so funk­tio­niert‘s

Die .service-Datei für Apache Kafka erstellen Sie mit folgendem Terminal-Kommando:

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

An­schlie­ßend kopieren Sie folgenden Inhalt in die neue Datei, die bereits im nano-Editor geöffnet wurde:

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

Im [Unit]-Bereich dieser Datei ist die Ab­hän­gig­keit des Kafka-Services von ZooKeeper spe­zi­fi­ziert. Somit ist si­cher­ge­stellt, dass auch der Syn­chro­ni­sa­ti­ons­dienst startet, wenn die kafka.service-Datei aus­ge­führt wird. Unter [Service] sind die Shell-Dateien kafka-server-start.sh und kafka-server-stop.sh für das Starten bzw. Beenden des Kafka-Servers ein­ge­tra­gen. Der au­to­ma­ti­sche Neustart nach vor­an­ge­gan­ge­nem Ver­bin­dungs­ab­bruch sowie der Mehr­be­nut­zer­sys­tem-Eintrag sind in dieser Datei ebenfalls zu finden.

Kafka: Erster Start und Erstellen eines Autostart-Eintrags

Nachdem Sie die Sit­zungs­ma­na­ger-Einträge für Kafka und ZooKeeper er­folg­reich angelegt haben, können Sie Kafka nun fol­gen­der­ma­ßen starten:

sudo systemctl start kafka

Das Programm systemd verwendet stan­dard­mä­ßig ein zentrales Protokoll bzw. Journal, in das au­to­ma­tisch alle Log-Meldungen ge­schrie­ben werden. Aufgrund dieses Umstands können Sie ganz einfach über­prü­fen, ob der Kafka-Server wie gewünscht gestartet wurde:

sudo journalctl -u kafka

Der Output sollte in etwa fol­gen­der­ma­ßen aussehen:

Funk­tio­niert der manuelle Start von Apache Kafka, ak­ti­vie­ren Sie zum Abschluss noch den au­to­ma­ti­schen Start im Rahmen des System-Boots:

sudo systemctl enable kafka

Apache-Kafka-Tutorial: Erste Schritte mit Apache Kafka

Um Apache Kafka zu testen, soll an dieser Stelle des Kafka-Tutorials eine erste Nachricht mithilfe der Messaging-Plattform ver­ar­bei­tet werden. Zu diesem Zweck benötigen Sie einen Producer und einen Consumer – also eine Instanz, die das Schreiben und Ver­öf­fent­li­chen von Daten in Topics er­mög­licht, sowie eine Instanz, die Daten eines Topics auslesen kann. Zuerst erzeugen Sie al­ler­dings das Topic, das in diesem Fall den Namen Tu­to­ri­al­To­pic erhalten soll. Da es sich um ein einfaches Test-Topic handelt, soll es lediglich eine einzelne Partition sowie eine einzige Replik enthalten:

> bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic TutorialTopic

Im zweiten Schritt erstellen Sie einen Producer, der dem gerade kreierten Topic die erste Beispiel-Nachricht „Hallo Welt!“ hinzufügt. Zu diesem Zweck nutzen Sie das Shell-Skript kafka-console-producer.sh, das den Hostnamen und den Port des Servers (im Beispiel: Kafka-Stan­dard­pfad) sowie den Namen des Topics als Argumente erwartet:

echo "Hallo Welt!" | ~/kafka/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic TutorialTopic > /dev/null

Mithilfe des Skripts kafka-console-consumer.sh erzeugen Sie ab­schlie­ßend einen Kafka-Consumer, der Nach­rich­ten von Tu­to­ri­al­To­pic ver­ar­bei­tet und wie­der­gibt. Als Argumente werden wiederum Hostname und Port des Kafka-Servers sowie der Topic-Name benötigt. Zudem wird das Argument „--from-beginning“ angehängt, damit die „Hallo Welt!“-Nachricht, die in diesem Fall noch vor dem Start des Consumers ver­öf­fent­licht wurde, auch tat­säch­lich von diesem ver­ar­bei­tet werden kann:

> bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic TutorialTopic --from-beginning

Als Folge prä­sen­tiert das Terminal die „Hallo Welt!”-Nachricht, wobei das Skript kon­ti­nu­ier­lich wei­ter­läuft und auf weitere Nach­rich­ten wartet, die zu dem Test-Topic ver­öf­fent­licht werden. Sorgen Sie also durch den Producer in einem anderen Ter­mi­nal­fens­ter für weiteren Daten-Input, sollten Sie diese ebenfalls im Ter­mi­nal­fens­ter sehen, in dem das Consumer-Skript aus­ge­führt wird.

Zum Hauptmenü