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 Gerät mit mindestens 4 GB RAM und 2 CPUs.
- 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. Mit dem folgenden Befehl erstellen Sie einen Benutzer mit dem Namen Kafka Erstellen:
sudo adduser kafkaSie werden nach Ihrem Kontopasswort gefragt. Geben Sie ein sicheres Passwort ein und drücken Sie die Eingabetaste. EINGEBEN Für jedes Feld müssen keine zusätzlichen Informationen ausgefüllt werden.
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 ist die neueste Version 3.6.1. Wenn Sie macOS oder Linux verwenden, können Sie Kafka mit curl installieren.
Verwenden Sie diesen Befehl, um Kafka herunterzuladen und zu installieren in /tmp Ort:
curl -o /tmp/kafka.tgz https://dlcdn.apache.org/kafka/3.6.1/kafka_2.13-3.6.1.tgzSie haben die Version unter ~/kafkaSie speichern die Datei im Hauptverzeichnis. Erstellen Sie sie durch Ausführen von:
mkdir ~/kafkaDann, indem man es ausführt, ~/kafka Extrakt:
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 Erstellung dieses Dokuments 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, das eine standardisierte Methode zur Koordination verteilter Daten für Anwendungen bietet und ebenfalls von der Apache Software Foundation entwickelt wird.
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 vorerst nur aus einem Knoten. Wechseln Sie in das Verzeichnis, in dem sich Kafka aktuell befindet:
cd ~/kafkaKafka mit KRaft konfiguriert sich selbst in config/kraft/server.properties speichert, während die Konfigurationsdatei ZooKeeper config/server.properties Es ist.
Vor der ersten Ausführung müssen Sie einige Standardeinstellungen überschreiben. Öffnen Sie die Datei zur Bearbeitung mit folgendem Befehl:
nano config/kraft/server.properties...
############################# Log Basics #############################
# A comma separated list of directories under which to store log files
log.dirs=/tmp/kafka-logs
...Einstellungen log.dirs Gibt an, wo Kafka seine Logdateien speichert. Standardmäßig werden sie in folgendem Verzeichnis gespeichert: /tmp/kafka-logs Dadurch werden sie gespeichert, da sie garantiert beschreibbar sind, wenn auch nur vorübergehend. 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.6-IV2.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.6.1 (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 herstellt. 0.0.0.0:9092 Akzeptiert.
Wann STRG + C Drücken Sie [Taste], um den Prozess zu beenden. Da es nicht empfehlenswert ist, Kafka mit einer geöffneten Sitzung auszuführen, erstellen Sie im nächsten Schritt einen Dienst, der Kafka im Hintergrund ausführt.
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.
Speichern Sie die Dienstkonfiguration in einer Datei mit dem Namen code-server.service In der Liste /lib/systemd/system Sie sparen, wo systemd Hier werden Ihre Dienste gespeichert. Erstellen Sie es 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 Leistungsbeschreibung an. Dann im [ServiceSie definieren den Diensttyp (einfach bedeutet, dass der Befehl einfach ausgeführt werden soll) und geben den auszuführenden Befehl an. Außerdem legen Sie den Benutzer fest, unter dem der Befehl ausgeführt werden soll. Kafka ist der Fall, und der Dienst sollte automatisch neu gestartet werden, wenn Kafka beendet wird.
Abschnitt [installierenDiese Zeile weist das System an, diesen Dienst zu starten, sobald eine Anmeldung am Server möglich ist. Nach Abschluss der Arbeiten speichern und schließen Sie die Datei.
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 einen Kafka-Server eingerichtet haben, lernen Sie Themen 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 über Ereignisströme erläutert, hängen das Veröffentlichen und Empfangen von Nachrichten mit Themen zusammen. Ein Thema kann einer Kategorie zugeordnet sein, zu der eine Nachricht gehört.
Aus dem bereitgestellten Skript kafka-topics.sh Sie können Themen in Kafka verwalten über CLI Wird verwendet, um ein Thema zu erstellen namens erstes Thema 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. --bootstrap-server Angeben.
Die Ausgabe lautet:
Output
Created topic first-topic.Um alle verfügbaren Themen aufzulisten, anstatt --erstellen In --Liste Schicken:
bin/kafka-topics.sh --list --bootstrap-server localhost:9092Sie sehen das von Ihnen erstellte Thema:
Output first-topic
Detaillierte Informationen und Statistiken zu diesem Thema finden Sie unter --beschreiben Erhalten:
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: 1
Die 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 Produzent wartet auf Ihre SMS. Nehmen Sie am Test teil und EINGEBEN Drücken Sie die Taste. Die Benachrichtigung sieht dann 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, STRG+C Drücken.
Um Nachrichten aus einem Thema abzurufen, benötigen Sie einen Consumer. Kafka stellt einen einfachen Consumer in folgender Form bereit: kafka-console-consumer.sh Es bietet Folgendes. Führen Sie es aus, indem Sie Folgendes starten:
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 der Baumeister, um zu gehen, STRG+C Drücken.
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 test
Nach Abschluss der Tests sollten sowohl der Produzent als auch der Konsument beendet werden.
Um das erste Thema zu löschen, --löschen Zu kafka-topics.sh Überweisen:
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 Kafka-Topic, das die Lesezeit eines Consumers für ein Topic speichert. Sie haben nun ein Kafka-Topic erstellt und darin Nachrichten angelegt. 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 verhält.
Vergleich mit ähnlichen Architekturen
Apache Kafka gilt als optimale Lösung für Event-Streaming-Anwendungen. Apache Pulsar und RabbitMQ sind ebenfalls weit verbreitet und zeichnen sich durch ihre Vielseitigkeit aus, auch wenn sie unterschiedliche Ansätze verfolgen. Der Hauptunterschied zwischen Message Queues und Event-Streams besteht darin, dass Message Queues Nachrichten unabhängig von ihrer Reihenfolge so schnell wie möglich an Clients zustellen. Solche Systeme speichern Nachrichten üblicherweise im Arbeitsspeicher, bis sie von den Konsumenten bestätigt werden. Nachrichtenfilterung und -routing sind wichtige Aspekte, da Konsumenten Interesse an bestimmten Datenkategorien haben können. RabbitMQ ist ein gutes Beispiel für ein traditionelles Messaging-System, bei dem mehrere Konsumenten ein Thema abonnieren und mehrere Kopien einer Nachricht erhalten können. Event-Streaming hingegen konzentriert sich auf die Persistenz. Ereignisse sollten archiviert, übersichtlich verwaltet und nur einmal verarbeitet werden. Ihr Routing zu bestimmten Konsumenten ist nicht wichtig, da alle Konsumenten Ereignisse auf dieselbe Weise verarbeiten. Apache Pulsar ist ein Open-Source-Messaging-System der Apache Software Foundation, das Event-Streaming unterstützt. Anders als Kafka, auf dem Pulsar von Grund auf basiert, begann es als traditionelle Message-Queuing-Lösung und erweiterte sein Funktionsspektrum später um Event-Streaming-Funktionen. Pulsar ist daher nützlich, wenn eine Kombination beider Methoden 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.
