Einführung
Apache Kafka ist eine Open-Source-Plattform für verteilte Ereignis- und Streamverarbeitung, geschrieben in Java und entwickelt für die Verarbeitung von Echtzeit-Datenfeeds. Sie ist von Natur aus skalierbar und zeichnet sich durch hohen Durchsatz und hohe Verfügbarkeit aus. Kafka wurde von der Apache Software Foundation entwickelt und ist aufgrund seiner Zuverlässigkeit, Benutzerfreundlichkeit und Fehlertoleranz weit verbreitet. Es wird von den weltweit größten Organisationen eingesetzt, um große Datenmengen verteilt und effizient zu verwalten.
In diesem Tutorial laden Sie Apache Kafka herunter und richten es ein. Sie lernen, wie Sie Themen erstellen und löschen sowie Ereignisse mithilfe der bereitgestellten Skripte senden und empfangen. Außerdem erhalten Sie Einblicke in ähnliche Projekte mit demselben Ziel und erfahren, wie sich Kafka im Vergleich dazu schlägt.
Voraussetzungen
- Ein Rechner mit mindestens 4 GB RAM und 2 CPUs. Im Fall von Ubuntu Server
- Java 8 oder höher ist auf Ihrem Droplet oder lokalen Rechner installiert.
Schritt 1 – Apache Kafka herunterladen und konfigurieren
In diesem Abschnitt laden Sie Apache Kafka herunter und extrahieren es auf Ihrem Rechner. Aus Sicherheitsgründen richten Sie es unter Ihrem eigenen Benutzerkonto ein. Anschließend konfigurieren und starten Sie es mit KRaft.
Zuerst erstellen Sie einen separaten Benutzer, unter dem Kafka ausgeführt wird. Erstellen Sie einen Benutzer namens „kafka“, indem Sie folgenden Befehl ausführen:
sudo adduser kafkaSie werden nach Ihrem Kontopasswort gefragt. Geben Sie ein sicheres Passwort ein und überspringen Sie die Eingabe weiterer Informationen, indem Sie für jedes Feld die Eingabetaste drücken.
Wechseln Sie abschließend zum gewünschten Kafka-Benutzer:
su kafkaAls Nächstes laden Sie das Kafka-Release-Paket von der offiziellen Downloadseite herunter. Zum Zeitpunkt der Erstellung dieses Dokuments war die neueste Version 3.7.0, kompiliert für Scala 2.13. Unter macOS oder Linux können Sie Kafka mit curl installieren.
Verwenden Sie diesen Befehl, um Kafka herunterzuladen und in /tmp abzulegen:
curl -o /tmp/kafka.tgz https://downloads.apache.org/kafka/3.7.0/kafka_2.13-3.7.0.tgzDie Version wird im Hauptverzeichnis unter ~/kafka gespeichert. Sie erstellen sie durch Ausführen von:
mkdir ~/kafkaAnschließend extrahieren Sie es nach ~/kafka, indem Sie Folgendes ausführen:
tar -xzf /tmp/kafka.tgz -C ~/kafka --strip-components=1Da das heruntergeladene Archiv einen Stammordner mit dem gleichen Namen wie die Kafka-Version enthält, überspringt die Option `--strip-components=1` diesen und extrahiert alles darin enthaltene.
Zum Zeitpunkt der Veröffentlichung dieses Artikels war Kafka 3 die letzte Hauptversion, die zwei Systeme für die Metadatenverwaltung unterstützte: Apache ZooKeeper und Kafka KRaft (kurz für Kafka Raft). ZooKeeper ist ein Open-Source-Projekt der Apache Software Foundation, das einen Standard zur Koordination verteilter Daten für Anwendungen bietet.
Ab Kafka 3.3 wurde jedoch die Unterstützung für KRaft eingeführt. KRaft ist ein speziell entwickeltes System zur Koordination von Kafka-Instanzen, das die Installation vereinfacht und eine deutlich höhere Skalierbarkeit ermöglicht. Mit KRaft übernimmt Kafka selbst die volle Verantwortung für die Daten, anstatt administrative Metadaten extern zu verwalten.
ZooKeeper ist zwar noch verfügbar, die Unterstützung dafür wird aber voraussichtlich ab Kafka 4 entfernt. In diesem Tutorial richten Sie Kafka mithilfe von KRaft ein.
Sie müssen eine eindeutige Kennung für Ihren neuen Kafka-Cluster erstellen. Dieser besteht aktuell nur aus einem Knoten. Wechseln Sie in das Verzeichnis, in dem sich Kafka befindet:
cd ~/kafkaKafka mit KRaft speichert seine Konfiguration in config/kraft/server.properties, während die Konfigurationsdatei von ZooKeeper config/server.properties lautet.
Vor der ersten Ausführung müssen Sie einige Standardeinstellungen überschreiben. Öffnen Sie die Datei zur Bearbeitung mit folgendem Befehl:
nano config/kraft/server.propertiesFinden Sie die folgenden Zeilen:
...
############################# Log Basics #############################
# A comma separated list of directories under which to store log files
log.dirs=/tmp/kafka-logs
...Die Einstellung `log.dirs` legt fest, wo Kafka seine Logdateien speichert. Standardmäßig werden sie in `/tmp/kafka-logs` abgelegt, da dort – wenn auch nur temporär – garantiert Schreibzugriff besteht. Ersetzen Sie den Wert durch den angegebenen Pfad:
... ############################# Log Basics ############################# # A comma separated list of directories under which to store log files log.dirs=/home/kafka/kafka-logs ...
Da Sie einen separaten Benutzer für Kafka angelegt haben, müssen Sie den Pfad zum Logverzeichnis im Home-Verzeichnis dieses Benutzers ablegen. Falls das Verzeichnis noch nicht existiert, wird es von Kafka erstellt. Speichern und schließen Sie die Datei anschließend.
Nachdem Sie Kafka konfiguriert haben, führen Sie folgenden Befehl aus, um eine zufällige Cluster-ID zu generieren:
KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"Erstellen Sie anschließend Speicherplatz für die Protokolldateien, indem Sie den folgenden Befehl ausführen und die ID eingeben:
bin/kafka-storage.sh format -t $KAFKA_CLUSTER_ID -c config/kraft/server.propertiesDie Ausgabe lautet:
Output
Formatting /home/kafka/kafka-logs with metadata.version 3.7-IV4.Schließlich können Sie den Kafka-Server zum ersten Mal starten:
bin/kafka-server-start.sh config/kraft/server.propertiesDas Endergebnis wird in etwa so aussehen:
Output
...
[2024-02-26 10:38:26,889] INFO Awaiting socket connections on 0.0.0.0:9092. (kafka.network.DataPlaneAcceptor)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Waiting for all of the authorizer futures to be completed (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Finished waiting for all of the authorizer futures to be completed (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Waiting for all of the SocketServer Acceptors to be started (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Finished waiting for all of the SocketServer Acceptors to be started (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Transition from STARTING to STARTED (kafka.server.BrokerServer)
[2024-02-26 10:38:26,891] INFO Kafka version: 3.7.0 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,891] INFO Kafka commitId: 5e3c2b738d253ff5 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,891] INFO Kafka startTimeMs: 1708943906890 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,892] INFO [KafkaRaftServer nodeId=1] Kafka Server started (kafka.server.KafkaRaftServer)Die Ausgabe zeigt, dass Kafka erfolgreich mit KRaft initialisiert wurde und Verbindungen auf 0.0.0.0:9092 akzeptiert.
Der Prozess wird durch Drücken von STRG + C beendet. Da es nicht empfehlenswert ist, Kafka mit einer geöffneten Sitzung auszuführen, erstellen Sie im nächsten Schritt einen Dienst, um Kafka im Hintergrund auszuführen.
Schritt 2 – Erstellen Sie einen systemd-Dienst für Kafka
In diesem Abschnitt erstellen Sie einen systemd-Dienst, der Kafka permanent 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/kafka.serviceFügen Sie die folgenden Zeilen hinzu:
[Unit]
Description=kafka-server
[Service]
Type=simple
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'
ExecStop=/home/kafka/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal
[Install]
WantedBy=multi-user.targetHier geben Sie zunächst 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 automatisch neu gestartet wird, falls Kafka beendet wird.
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.
Starten Sie den Kafka-Dienst, indem Sie folgenden Befehl ausführen:
sudo systemctl start kafkaÜberprüfen Sie anhand des Status, ob der Dienst ordnungsgemäß gestartet wurde:
sudo systemctl status kafkaSie sehen eine Ausgabe, die in etwa wie folgt aussieht:
Output
● kafka.service - kafka-server
Loaded: loaded (/etc/systemd/system/kafka.service; disabled; preset: enabled)
Active: active (running) since Mon 2024-02-26 11:17:30 UTC; 2min 40s ago
Main PID: 1061 (sh)
Tasks: 94 (limit: 4646)
Memory: 409.2M
CPU: 10.491s
CGroup: /system.slice/kafka.service
├─1061 /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"
└─1062 java -Xmx1G -Xms1G -server -XX:+UseG1GC -XX:MaxGCPauseMillis=20 -XX:InitiatingHeapOccupancyPercent=35 -XX:+ExplicitGCInvokesConcurrent -XX:MaxInlineLevel=15 -Djava.awt.headless=true "-Xlog:gc*:file=/home/kafka/kafka/bin/../logs/kaf>
Feb 26 11:17:30 kafka-test1 systemd[1]: Started kafka.service - kafka-server.Um Kafka nach einem Serverneustart automatisch zu starten, aktivieren Sie den Dienst mit folgendem Befehl:
sudo systemctl enable kafkaSie haben nun einen systemd-Dienst für Kafka erstellt und aktiviert, sodass dieser bei jedem Serverstart automatisch ausgeführt wird. Im nächsten Schritt lernen Sie, wie Sie Themen in Kafka erstellen und löschen sowie Textnachrichten mithilfe der verfügbaren Skripte erzeugen und konsumieren.
Schritt 3 – Produzieren und Konsumieren von themenbezogenen Nachrichten
Nachdem Sie nun einen Kafka-Server eingerichtet haben, lernen Sie die Themen (Topics) und deren Verwaltung mithilfe der bereitgestellten Skripte kennen. Außerdem erfahren Sie, wie Sie Nachrichten an ein Thema senden und von diesem empfangen.
Wie im Artikel „Ereignisstrom“ erläutert, sind das Veröffentlichen und Empfangen von Nachrichten mit Themen verknüpft. Ein Thema kann der Kategorie zugeordnet werden, zu der eine Nachricht gehört.
Das bereitgestellte Skript kafka-topics.sh kann verwendet werden, um Themen in Kafka über die Befehlszeile zu verwalten. Um ein Thema mit dem Namen „first-topic“ zu erstellen, führen Sie folgenden Befehl aus:
bin/kafka-topics.sh --create --topic first-topic --bootstrap-server localhost:9092Alle bereitgestellten Kafka-Skripte erfordern die Angabe der Serveradresse mit --bootstrap-server.
Die Ausgabe lautet:
Output
Created topic first-topic.Um alle vorhandenen Themen aufzulisten, ersetzen Sie –create durch –list:
bin/kafka-topics.sh --list --bootstrap-server localhost:9092Sie sehen das von Ihnen erstellte Thema:
Output
first-topicDetaillierte Informationen und Statistiken zum Thema erhalten Sie durch Übergabe von --describe:
bin/kafka-topics.sh --describe --topic first-topic --bootstrap-server localhost:9092Die Ausgabe sieht folgendermaßen aus:
Output
Topic: first-topic TopicId: VtjiMIUtRUulwzxJL5qVjg PartitionCount: 1 ReplicationFactor: 1 Configs: segment.bytes=1073741824
Topic: first-topic Partition: 0 Leader: 1 Replicas: 1 Isr: 1Die erste Zeile gibt den Themennamen, die ID und den Wiederholungsfaktor an, der 1 beträgt, da das Thema nur auf dem aktuellen Rechner existiert. Die zweite Zeile ist absichtlich eingerückt und enthält Informationen zur ersten (und einzigen) Partition des Themas. Kafka ermöglicht die Partitionierung von Themen, wodurch verschiedene Teile eines Themas auf unterschiedliche Server verteilt und die Skalierbarkeit erhöht werden können. Hier gibt es jedoch nur eine Partition.
Nachdem Sie ein Thema erstellt haben, können Sie mithilfe des Skripts kafka-console-producer.sh Nachrichten dafür erzeugen. Führen Sie folgenden Befehl aus, um den Producer zu starten:
bin/kafka-console-producer.sh --topic first-topic --bootstrap-server localhost:9092Sie sehen eine leere Benachrichtigung:
>Der Anbieter wartet auf Ihre SMS. Geben Sie den Test ein und drücken Sie die Eingabetaste. Die Benachrichtigung sieht folgendermaßen aus:
>test
>Der Producer wartet nun auf die nächste Nachricht; die vorherige Nachricht wurde also erfolgreich an Kafka übermittelt. Sie können beliebig viele Nachrichten zum Testen eingeben. Um den Producer zu beenden, drücken Sie Strg+C.
Um Topic-Nachrichten abzurufen, benötigen Sie einen Consumer. Kafka stellt einen einfachen Consumer in Form von kafka-console-consumer.sh bereit. Starten Sie ihn mit folgendem Befehl:
bin/kafka-console-consumer.sh --topic first-topic --bootstrap-server localhost:9092Es erfolgt jedoch keine Ausgabe. Dies liegt daran, dass der Konsument Daten aus dem Thema streamt und momentan keine Daten erzeugt oder gesendet werden. Um Nachrichten zu konsumieren, die Sie vor dem Start des Konsumenten erzeugt haben, müssen Sie das Thema von Anfang an lesen, indem Sie Folgendes ausführen:
bin/kafka-console-consumer.sh --topic first-topic --from-beginning --bootstrap-server localhost:9092Der Konsument spielt alle Ereignisse des Themas erneut ab und ruft Nachrichten ab:
Outputtest
...Wie beim Editor können Sie durch Drücken von STRG+C das Programm beenden.
Um zu überprüfen, ob der Consumer tatsächlich Daten streamt, öffnen Sie ihn in einer separaten Terminal-Sitzung. Öffnen Sie eine zweite SSH-Sitzung und führen Sie den Consumer in der Standardkonfiguration aus:
bin/kafka-console-consumer.sh --topic first-topic --bootstrap-server localhost:9092Führen Sie in der ersten Sitzung den Konstruktor aus:
bin/kafka-console-producer.sh --topic first-topic --bootstrap-server localhost:9092Geben Sie anschließend Ihre gewünschten Nachrichten ein:
>second test
>third test
>Sie werden sofort sehen, dass sie vom Verbraucher empfangen werden:
Output
second test
third testNach Abschluss der Tests sollten sowohl der Produzent als auch der Konsument beendet werden.
Um das erste Thema zu löschen, übergeben Sie die Option `--delete` an `kafka-topics.sh`:
bin/kafka-topics.sh --delete --topic first-topic --bootstrap-server localhost:9092Es erfolgt keine Ausgabe. Sie können die Themen auflisten, um zu überprüfen, ob sie tatsächlich gelöscht wurden:
bin/kafka-topics.sh --list --bootstrap-server localhost:9092Die Ausgabe lautet:
Output
__consumer_offsets__Consumer_Equivalent ist ein internes Topic für Kafka, das die Zeitspanne speichert, die ein Consumer ein Topic gelesen hat.
Sie haben nun ein Kafka-Topic erstellt und darin Nachrichten generiert. Anschließend haben Sie die Nachrichten mithilfe des bereitgestellten Skripts konsumiert und schließlich in Echtzeit empfangen. Im nächsten Schritt erfahren Sie, wie sich Kafka im Vergleich zu anderen Event-Brokern und ähnlicher Software schlägt.
Vergleich mit ähnlichen Architekturen
Apache Kafka gilt als De-facto-Lösung für Event-Streaming-Anwendungen. Apache Pulsar und RabbitMQ sind jedoch ebenfalls weit verbreitet und zeichnen sich durch ihre Vielseitigkeit aus, auch wenn sie sich in ihrem Ansatz unterscheiden.
Der Hauptunterschied zwischen einer Message Queue und einem Event Stream besteht darin, dass die primäre Aufgabe der Message Queue darin besteht, Nachrichten unabhängig von ihrer Reihenfolge so schnell wie möglich an die Konsumenten zuzustellen. Solche Systeme speichern Nachrichten typischerweise im Arbeitsspeicher, bis sie von den Konsumenten bestätigt werden. Nachrichtenfilterung und -weiterleitung sind wichtige Aspekte, da Konsumenten Interesse an bestimmten Datenkategorien haben können. RabbitMQ ist ein gutes Beispiel für ein traditionelles Messaging-System, in dem mehrere Konsumenten ein Thema abonnieren und mehrere Kopien einer Nachricht erhalten können.
Event-Streaming hingegen legt den Fokus auf Persistenz. Ereignisse sollen archiviert, verwaltet und nur einmal verarbeitet werden. Die Weiterleitung an bestimmte Konsumenten ist unwichtig, da alle Konsumenten Ereignisse auf dieselbe Weise verarbeiten sollen.
Apache Pulsar ist ein Open-Source-Messaging-System der Apache Software Foundation, das Event-Streaming unterstützt. Im Gegensatz zu Kafka, auf dem es von Anfang an basierte, begann Pulsar als traditionelle Message-Queuing-Lösung und erweiterte sein Funktionsspektrum später um Event-Streaming. Pulsar ist daher nützlich, wenn eine Kombination beider Ansätze benötigt wird, ohne dass separate Anwendungen bereitgestellt werden müssen.
Ergebnis
Apache Kafka läuft nun sicher im Hintergrund Ihres Servers und ist als Systemdienst konfiguriert. Sie haben außerdem gelernt, wie Sie Themen über die Kommandozeile bearbeiten sowie Nachrichten erzeugen und konsumieren. Der größte Vorteil von Kafka liegt jedoch in der Vielzahl an Clients, mit denen Sie es in Ihre Anwendungen integrieren können.
