Apache-Kafka-Tutorial: Kafka mit KRaft unter Ubuntu 24.04 in­stal­lie­ren

Apache Kafka ist eine leis­tungs­fä­hi­ge Plattform für die Ver­ar­bei­tung kon­ti­nu­ier­li­cher Da­ten­strö­me. Die Open-Source-Software kommt zum Einsatz, wenn An­wen­dun­gen große Mengen an Er­eig­nis­sen in Echtzeit aus­tau­schen, speichern und ver­ar­bei­ten sollen.

Was ist Apache Kafka?

Apache Kafka ist eine verteilte Event-Streaming-Plattform. An­wen­dun­gen können mit Kafka kon­ti­nu­ier­lich Daten bzw. so­ge­nann­te Events erzeugen, speichern, über­tra­gen und ver­ar­bei­ten. Ein Event kann bei­spiels­wei­se eine Be­stel­lung in einem On­line­shop, eine Sta­tus­än­de­rung in einer Anwendung, ein Sen­sor­mess­wert oder eine Zahlung sein.

Kafka or­ga­ni­siert diese Daten in so­ge­nann­ten Topics. Ein Topic lässt sich ver­ein­facht mit einem Kanal ver­glei­chen, in den An­wen­dun­gen Daten schreiben und aus dem andere An­wen­dun­gen diese Daten wieder auslesen können.

Dabei spielen ins­be­son­de­re drei Kom­po­nen­ten eine Rolle:

• Ein Producer erzeugt Events und schreibt sie in ein Kafka-Topic.
• Ein Broker ist ein Kafka-Server, der die Events speichert und be­reit­stellt.
• Ein Consumer liest und ver­ar­bei­tet Events aus einem Topic.

Topics lassen sich zu­sätz­lich in mehrere Par­ti­tio­nen un­ter­tei­len. Dadurch können große Da­ten­men­gen auf mehrere Broker verteilt und parallel ver­ar­bei­tet werden. Mehrere Kafka-Server bilden gemeinsam einen Kafka-Cluster. Kafka wird deshalb unter anderem für Event-driven Ar­chi­tec­tures, Log- und Mo­ni­to­ring-Pipelines, Mi­cro­ser­vices, Da­ten­in­te­gra­ti­on und Echt­zeit­ana­ly­sen ein­ge­setzt.

Kafka KRaft vs. ZooKeeper

Bei älteren Kafka-Versionen war Apache ZooKeeper ein wichtiger Be­stand­teil der Ar­chi­tek­tur. ZooKeeper ver­wal­te­te unter anderem In­for­ma­tio­nen über Broker, Topics, Par­ti­tio­nen und weitere Cluster-Metadaten. In modernen Kafka-Versionen übernimmt Kafka diese Aufgabe selbst. Dafür kommt KRaft, das auf dem Raft-Kon­sens­ver­fah­ren basiert, zum Einsatz. Bestimmte Kafka-Nodes über­neh­men dabei die Rolle von Con­trol­lern und verwalten die Metadaten des Clusters.

Kafka kennt im KRaft-Modus drei mögliche Rollen:

• broker: Der Server speichert und ver­ar­bei­tet die ei­gent­li­chen Kafka-Daten.
• controller: Der Server verwaltet die Metadaten des Clusters.
• broker,controller: Der Server übernimmt beide Aufgaben.

Für Ent­wick­lungs-, Test- und Lern­um­ge­bun­gen können Broker und Con­trol­ler auf demselben Server betrieben werden. Für kritische Pro­duk­tiv­um­ge­bun­gen empfiehlt Apache hingegen, die Rollen von­ein­an­der zu trennen.

Vor­aus­set­zun­gen für die Kafka-In­stal­la­ti­on

Für dieses Apache-Kafka-Tutorial sind folgende Vor­aus­set­zun­gen er­for­der­lich:

• Ubuntu 24.04 LTS
• Apache Kafka 4.3.1
• OpenJDK 21
• User-Konto mit sudo-Rechten
• SSH-Zugang zum Server
• min­des­tens einige Gigabyte freien Spei­cher­platz

Apache Kafka 4.3 un­ter­stützt Java 17, Java 21 und Java 25 voll­stän­dig. Für diese Anleitung verwenden wir OpenJDK 21, das unter Ubuntu 24.04 direkt über die of­fi­zi­el­len Pa­ket­quel­len in­stal­liert werden kann.

Für eine reine Lern- oder Test­um­ge­bung benötigen Sie keinen Server mit mehreren Dutzend Gigabyte Ar­beits­spei­cher. Ein kleiner VPS oder Cloud Server mit bei­spiels­wei­se 2 vCPUs und 4 GB RAM reicht für das Single-Node-Setup dieses Kafka-Tutorials grund­sätz­lich aus. Bei lediglich 2 GB RAM steht weniger Spielraum für Java, Kafka und das Be­triebs­sys­tem zur Verfügung, weshalb 4 GB kom­for­ta­bler sind.

Für pro­duk­ti­ve Kafka-Systeme gelten andere An­for­de­run­gen. Dort hängen benötigte CPU-, RAM- und Spei­cher­res­sour­cen unter anderem von Nach­rich­ten­durch­satz, Anzahl der Par­ti­tio­nen, Re­pli­ka­ti­ons­fak­tor, Auf­be­wah­rungs­dau­er und Anzahl der Clients ab.

Kafka auf einem IONOS VPS oder Cloud Server in­stal­lie­ren

Für das Kafka-Tutorial können Sie bei­spiels­wei­se einen IONOS VPS oder Cloud Server verwenden. Erstellen Sie zunächst im IONOS Cloud Panel einen Server mit Ubuntu 24.04 und verbinden Sie sich an­schlie­ßend per SSH mit diesem. Für das Tutorial greifen Producer und Consumer aus­schließ­lich lokal auf Kafka zu. Der Kafka-Port 9092 muss daher nicht öf­fent­lich über die Server-Firewall er­reich­bar sein.

Schritt 1: Java-Lauf­zeit­um­ge­bung in­stal­lie­ren

Ak­tua­li­sie­ren Sie zunächst die Pa­ket­in­for­ma­tio­nen Ihres Ubuntu-Systems:

sudo apt update

An­schlie­ßend in­stal­lie­ren Sie OpenJDK 21 sowie wget, das wir später für den Kafka-Download benötigen:

sudo apt install -y openjdk-21-jdk wget

Ob Java er­folg­reich in­stal­liert wurde, über­prü­fen Sie mit:

java -version

Die Ausgabe sollte OpenJDK 21 anzeigen.

Close

Schritt 2: User für Kafka erstellen

Kafka sollte nicht dauerhaft mit Root-Rechten aus­ge­führt werden. Erstellen Sie deshalb einen eigenen Sys­tem­be­nut­zer und eine zu­ge­hö­ri­ge Gruppe:

sudo groupadd --system kafka
sudo useradd --system \
    --gid kafka \
    --home-dir /opt/kafka \
    --shell /usr/sbin/nologin \
    kafka

Der User kafka erhält bewusst keine normale Login-Shell. Er wird später aus­schließ­lich verwendet, um den Kafka-Service aus­zu­füh­ren.

Legen Sie an­schlie­ßend die Ver­zeich­nis­se für die Kafka-In­stal­la­ti­on und die ge­spei­cher­ten Kafka-Daten an:

sudo mkdir -p /opt/kafka
sudo mkdir -p /var/lib/kafka

Schritt 3: Apache Kafka her­un­ter­la­den und in­stal­lie­ren

Apache Kafka wird als kom­pri­mier­tes Archiv be­reit­ge­stellt. In unserem Apache-Kafka-Tutorial verwenden wir Kafka 4.3.1 mit Scala 2.13. Die Ver­si­ons­num­mer 2.13 innerhalb des Da­tei­na­mens be­zeich­net dabei die ver­wen­de­te Scala-Bi­när­ver­si­on; die ei­gent­li­che Kafka-Version ist 4.3.1.

Wechseln Sie zunächst in das temporäre Ver­zeich­nis:

cd /tmp

Laden Sie an­schlie­ßend das Kafka-Archiv direkt von Apache herunter:

wget https://downloads.apache.org/kafka/4.3.1/kafka_2.13-4.3.1.tgz

Entpacken Sie das Archiv nach /opt/kafka:

sudo tar -xzf kafka_2.13-4.3.1.tgz \
    -C /opt/kafka \
    --strip-components=1

Durch --strip-components=1 werden die Kafka-Dateien direkt unter /opt/kafka abgelegt und nicht in einem zu­sätz­li­chen Un­ter­ver­zeich­nis.

Über­tra­gen Sie an­schlie­ßend die Be­sitz­rech­te auf den zuvor an­ge­leg­ten Kafka-User:

sudo chown -R kafka:kafka /opt/kafka
sudo chown -R kafka:kafka /var/lib/kafka

Mit folgendem Befehl können Sie sich den Inhalt des In­stal­la­ti­ons­ver­zeich­nis­ses anzeigen lassen:

ls /opt/kafka

Sie sollten unter anderem die Ver­zeich­nis­se bin, config und libs sehen.

Close

Schritt 4: Kafka für KRaft kon­fi­gu­rie­ren

Kafka 4.3.1 enthält bereits eine für KRaft vor­ge­se­he­ne Datei unter:

/opt/kafka/config/server.properties

Öffnen Sie die Datei:

sudo nano /opt/kafka/config/server.properties

Für unser Single-Node-Tutorial übernimmt derselbe Kafka-Prozess sowohl die Broker- als auch die Con­trol­ler-Rolle. Kon­trol­lie­ren bzw. ändern Sie die folgenden Werte:

process.roles=broker,controller
node.id=1
controller.quorum.bootstrap.servers=127.0.0.1:9093
controller.listener.names=CONTROLLER
listeners=PLAINTEXT://127.0.0.1:9092,CONTROLLER://127.0.0.1:9093
advertised.listeners=PLAINTEXT://127.0.0.1:9092
inter.broker.listener.name=PLAINTEXT
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
log.dirs=/var/lib/kafka
offsets.topic.replication.factor=1

Close

Die wich­tigs­ten Ein­stel­lun­gen haben folgende Bedeutung:

• process.roles=broker,controller legt fest, dass dieser Kafka-Server sowohl Broker als auch Con­trol­ler ist. Diese kom­bi­nier­te Be­triebs­art eignet sich besonders für Ent­wick­lungs- und Test­um­ge­bun­gen.
• node.id=1 weist dem Kafka-Node eine ein­deu­ti­ge Kennung zu. In einem Cluster muss jeder Node eine eigene ID besitzen.
• controller.quorum.bootstrap.servers gibt an, über welche Adresse Kafka den KRaft-Con­trol­ler erreichen kann. Da Broker und Con­trol­ler in unserem Beispiel auf demselben Server laufen, verwenden wir Port 9093 auf der lokalen Adresse.
• Der Eintrag listeners legt fest, auf welchen Adressen Kafka Ver­bin­dun­gen annimmt. Port 9092 wird für die Kom­mu­ni­ka­ti­on mit Kafka-Clients verwendet, Port 9093 für den Con­trol­ler.
• Mit advertised.listeners teilt Kafka Clients mit, unter welcher Adresse der Broker er­reich­bar ist.
• log.dirs=/var/lib/kafka definiert das Ver­zeich­nis, in dem Kafka seine Daten speichert. Die mit Kafka ge­lie­fer­te Bei­spiel­kon­fi­gu­ra­ti­on verwendet stan­dard­mä­ßig ein Ver­zeich­nis unter /tmp. Für einen dauerhaft als Service laufenden Kafka-Server ist ein eigenes Da­ten­ver­zeich­nis wie /var/lib/kafka zweck­mä­ßi­ger.
• offsets.topic.replication.factor=1 setzt den Re­pli­ka­ti­ons­fak­tor des internen Offset-Topics passend zum Single-Broker-Setup auf 1.

Schritt 5: KRaft-Cluster in­itia­li­sie­ren

Bevor Kafka zum ersten Mal gestartet werden kann, muss der KRaft-Speicher for­ma­tiert werden. Hierbei handelt es sich um einen In­itia­li­sie­rungs­schritt, der bei einem bereits ein­ge­rich­te­ten Kafka-Server nicht bei jedem Start erneut aus­ge­führt wird.

Zunächst erzeugen Sie eine ein­deu­ti­ge Cluster-ID:

KAFKA_CLUSTER_ID=$(/opt/kafka/bin/kafka-storage.sh random-uuid)

Mit echo "$KAFKA_CLUSTER_ID" können Sie sich die erzeugte ID anzeigen lassen.

Close

An­schlie­ßend for­ma­tie­ren Sie die Kafka-Da­ten­ver­zeich­nis­se:

sudo -u kafka /opt/kafka/bin/kafka-storage.sh format \
    --standalone \
    -t "$KAFKA_CLUSTER_ID" \
    -c /opt/kafka/config/server.properties

Mit --standalone wird ein neues KRaft-Con­trol­ler-Quorum mit diesem Node als zunächst einzigem Mitglied angelegt. Dieses Verfahren ent­spricht dem aktuellen Kafka-KRaft-Modell mit dy­na­mi­schem Con­trol­ler-Quorum. Die Cluster-ID verbindet die Da­ten­ver­zeich­nis­se mit dem Kafka-Cluster. Beim Ein­rich­ten eines Clusters mit mehreren Servern muss deshalb für alle Nodes desselben Clusters dieselbe Cluster-ID verwendet werden.

Schritt 6: systemd-Service für Kafka erstellen

Bis hierhin könnten Sie Kafka manuell über kafka-server-start.sh starten. Auf einem Server ist es jedoch prak­ti­scher, Kafka als regulären Linux-Dienst über systemd aus­zu­füh­ren.

Erstellen Sie dafür eine neue Service-Datei:

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

Fügen Sie folgenden Inhalt ein:

[Unit]
Description=Apache Kafka Server (KRaft)
After=network.target
[Service]
Type=simple
User=kafka
Group=kafka
Environment="KAFKA_HEAP_OPTS=-Xms1G -Xmx1G"
ExecStart=/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/server.properties
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target

Speichern und schließen Sie die Datei an­schlie­ßend.

Schritt 7: Kafka starten

Damit systemd die neue Service-Datei erkennt, laden Sie zunächst die Kon­fi­gu­ra­ti­on neu:

sudo systemctl daemon-reload

Ak­ti­vie­ren Sie Kafka an­schlie­ßend für den au­to­ma­ti­schen Start beim Hoch­fah­ren des Servers und starten Sie den Dienst direkt:

sudo systemctl enable --now kafka

Über­prü­fen Sie den Status:

sudo systemctl status kafka --no-pager

Ist Kafka er­folg­reich gestartet, sollte der Service als active (running) angezeigt werden.

Close

Falls Kafka nicht startet, können Sie die letzten Log­mel­dun­gen mit folgendem Befehl abrufen:

sudo journalctl -u kafka -n 50 --no-pager

Schritt 8: Erstes Kafka-Topic erstellen

Nun läuft Ihr erster Kafka-Server. Im nächsten Schritt testen wir, ob sich Daten tat­säch­lich schreiben und wieder auslesen lassen. Kafka speichert Events in Topics. Erstellen Sie ein Topic mit dem Namen tutorial-topic:

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

Close

Da unser Test-Cluster nur aus einem Broker besteht, verwenden wir einen Re­pli­ka­ti­ons­fak­tor von 1.

Kafka 4.x verwendet für ad­mi­nis­tra­ti­ve Befehle --bootstrap-server.

Ob das Topic korrekt angelegt wurde, über­prü­fen Sie mit:

/opt/kafka/bin/kafka-topics.sh \
    --describe \
    --topic tutorial-topic \
    --bootstrap-server localhost:9092

Die Ausgabe enthält unter anderem den Namen des Topics sowie In­for­ma­tio­nen zur Partition und Re­pli­ka­ti­on.

Close

Schritt 9: Kafka-Producer testen

Nun benötigen Sie einen Producer, der Nach­rich­ten in das Topic schreibt. Starten Sie den mit Kafka ge­lie­fer­ten Console Producer:

/opt/kafka/bin/kafka-console-producer.sh \
    --topic tutorial-topic \
    --bootstrap-server localhost:9092

Das Terminal wartet jetzt auf Ihre Eingabe. Schreiben Sie bei­spiels­wei­se Hi Kafka! und drücken Sie [Enter]. Sie können an­schlie­ßend weitere Nach­rich­ten eingeben:

My first Kafka message
Kafka uses KRaft

Jede Zeile wird als eigenes Event in das Topic ge­schrie­ben. Mit [Strg] + [C] beenden Sie den Producer.

Schritt 10: Nach­rich­ten mit einem Kafka-Consumer lesen

Öffnen Sie eine zweite SSH-Sitzung bzw. ein zweites Ter­mi­nal­fens­ter und starten Sie dort einen Consumer:

/opt/kafka/bin/kafka-console-consumer.sh \
    --topic tutorial-topic \
    --from-beginning \
    --bootstrap-server localhost:9092

Durch --from-beginning liest der Consumer die bereits vor­han­de­nen Events des Topics von Anfang an.

Sie sollten nun bei­spiels­wei­se folgende Ausgabe sehen:

Hi Kafka!
My first Kafka message
Kafka uses KRaft

Close

Solange der Consumer läuft, werden auch neue Nach­rich­ten un­mit­tel­bar angezeigt. Lassen Sie den Consumer geöffnet und starten Sie in einem zweiten Terminal erneut den Producer. Jede dort ein­ge­ge­be­ne Nachricht sollte daraufhin direkt im Consumer-Terminal er­schei­nen.

Damit funk­tio­niert Ihr Kafka-Setup voll­stän­dig: Ein Producer schreibt Events in ein Topic, Kafka speichert sie und ein Consumer liest sie wieder aus.

Beenden Sie den Consumer mit [Strg] + [C].

Kafka verwalten: Die wich­tigs­ten systemd-Befehle

Nachdem Kafka als Service ein­ge­rich­tet wurde, lässt sich der Server mit den üblichen systemd-Befehlen verwalten.

• Kafka starten: sudo systemctl start kafka
• Kafka stoppen: sudo systemctl stop kafka
• Kafka neu starten: sudo systemctl restart kafka
• Status über­prü­fen: sudo systemctl status kafka
• Au­to­ma­ti­schen Start ak­ti­vie­ren: sudo systemctl enable kafka
• Au­to­ma­ti­schen Start de­ak­ti­vie­ren: sudo systemctl disable kafka
• Logs anzeigen: sudo journalctl -u kafka

Vom Single-Node-Setup zum Kafka-Cluster

Das bisherige Kafka-Tutorial richtet einen voll­stän­di­gen, aber sehr einfachen Kafka-Cluster mit nur einem Node ein. Das eignet sich zum Lernen, Ent­wi­ckeln und Testen, bietet jedoch keine Aus­fall­si­cher­heit. Möchten Sie einen pro­duk­ti­ven Kafka-Cluster ein­rich­ten, verteilen Sie Kafka auf mehrere Server.

Apache empfiehlt für typische feh­ler­to­le­ran­te KRaft-In­stal­la­tio­nen drei oder fünf Con­trol­ler. Bei drei Con­trol­lern kann ein Con­trol­ler ausfallen, ohne dass das Con­trol­ler-Quorum verloren geht. Bei fünf Con­trol­lern können zwei Con­trol­ler ausfallen. Eine Mehrheit der Con­trol­ler muss jederzeit er­reich­bar bleiben.

Für kritische Pro­duk­tiv­um­ge­bun­gen sollten Broker- und Con­trol­ler-Rollen nicht auf demselben Node kom­bi­niert werden. Der kom­bi­nier­te Modus ist als prak­ti­sche Lösung für kleine Um­ge­bun­gen bzw. Ent­wick­lungs­um­ge­bun­gen zu sehen, empfiehlt sich aber nicht für kritische De­ploy­ments. Zu­sätz­lich sollten bei einem Multi-Broker-Cluster die Re­pli­ka­ti­ons­fak­to­ren der Topics und der internen Kafka-Topics erhöht werden, damit Daten beim Ausfall eines Brokers weiterhin verfügbar bleiben.

Kafka für den Pro­duk­tiv­ein­satz absichern

Das Setup dieses Tutorials wurde bewusst möglichst einfach gehalten. Die Kom­mu­ni­ka­ti­on zwischen Kafka und den Clients erfolgt über Plaintext. Das bedeutet, dass Kafka in dieser Kon­fi­gu­ra­ti­on weder Trans­port­ver­schlüs­se­lung noch eine Client-Au­then­ti­fi­zie­rung verwendet.

Da Kafka in unserem Tutorial aus­schließ­lich an die IP-Adresse 127.0.0.1 gebunden ist, kann der Broker nicht direkt von anderen Rechnern an­ge­spro­chen werden. Für einen lokalen Test auf einem VPS oder Cloud Server ist das eine sinnvolle Ein­schrän­kung.

Sobald An­wen­dun­gen von anderen Servern auf Kafka zugreifen sollen, müssen Sie die Netzwerk- und Si­cher­heits­kon­fi­gu­ra­ti­on ent­spre­chend erweitern. Stellen Sie einen un­ver­schlüs­sel­ten Kafka-Broker nicht einfach über Port 9092 öf­fent­lich ins Internet.

Kafka un­ter­stützt für den Pro­duk­tiv­be­trieb unter anderem:

• TLS/SSL für die Ver­schlüs­se­lung der über­tra­ge­nen Daten
• SASL für die Au­then­ti­fi­zie­rung von Clients und Brokern
• ACLs zur Steuerung, welche User bzw. An­wen­dun­gen Topics lesen, be­schrei­ben oder verändern dürfen
• ab­ge­si­cher­te Firewall-Regeln und private Netzwerke
• getrennte Listener für interne und externe Kom­mu­ni­ka­ti­on

Bei einem Cloud-Setup empfiehlt es sich zudem, die Kom­mu­ni­ka­ti­on zwischen den Kafka-Nodes über ein privates Netzwerk ab­zu­wi­ckeln und externen Zugriff aus­schließ­lich für tat­säch­lich benötigte Clients zu­zu­las­sen.

Soll der Kafka-Broker von einem anderen Server er­reich­bar sein, müssen außerdem listeners und ins­be­son­de­re advertised.listeners angepasst werden. advertised.listeners ist gerade in Cloud- bzw. IaaS-Um­ge­bun­gen wichtig, da Kafka Clients darüber mitteilt, unter welcher Adresse sie den Broker tat­säch­lich erreichen können.

Fazit: Kafka in­stal­lie­ren

Mit Kafka 4.x hat sich die In­stal­la­ti­on der Event-Streaming-Plattform deutlich verändert. Apache ZooKeeper gehört nicht mehr zum Kafka-Stack. Die Ver­wal­tung der Cluster-Metadaten übernimmt statt­des­sen das in­te­grier­te KRaft-System. Für ein einfaches Apache-Kafka-Tutorial genügt ein einzelner Ubuntu-24.04-Server, auf dem Kafka gleich­zei­tig als Broker und Con­trol­ler läuft. Nachdem Java in­stal­liert, Kafka her­un­ter­ge­la­den und der KRaft-Speicher in­itia­li­siert wurde, lässt sich Kafka kom­for­ta­bel als systemd-Service betreiben.