Zum Inhalt springen
Startseite » Blog » Kafka-Cluster mit Kafdrop und Docker

Kafka-Cluster mit Kafdrop und Docker

Einleitung

In diesem Lernprojekt wird ein Kafka-Cluster mit drei Kafka-Broker-Instanzen erstellt. Zur Überwachung des Clusters dient Kafdrop als Benutzeroberfläche, während die gesamte Infrastruktur mithilfe von Docker containerisiert wird. Zusätzlich integrieren wir Java-basierte Producer und Consumer, um Daten in Kafka zu produzieren und zu konsumieren.

Die Erstellung und Verwaltung von Kafka-Topics ist für Integration Developer von zentraler Bedeutung. Ein entscheidender Faktor ist die Echtzeit-Datenverarbeitung, die es ermöglicht, Daten umgehend zu verarbeiten und darauf zu reagieren. Schließlich fördert Kafka die Interoperabilität zwischen verschiedenen Systemen, indem es eine nahtlose Kommunikation zwischen unterschiedlichen Anwendungen ermöglicht. Ein tiefes Verständnis dieser Konzepte ist somit unerlässlich für die Entwicklung robuster und effektiver Datenintegrationslösungen.

Technologiestack

1. Apache Kafka-Cluster (3 Broker-Instanzen)

Ein Kafka-Cluster besteht aus mehreren Kafka-Broker-Instanzen, die zusammenarbeiten, um Daten zuverlässig zu speichern und zu verteilen. In diesem Setup verwenden wir drei Kafka-Instanzen, die als Broker fungieren. Diese Broker teilen sich die Last, indem sie die Partitionen der Kafka-Themen auf verschiedene Server verteilen. Dabei sorgt Kafka für hohe Verfügbarkeit und Ausfallsicherheit durch Replikation von Daten auf mehrere Broker.

  • Partitionierung: Daten werden in Partitionen aufgeteilt, um die Verarbeitung und Speicherung zu skalieren.
  • Replikation: Die Daten werden auf mehrere Broker repliziert, um im Falle eines Ausfalls die Datenkonsistenz zu gewährleisten.
  • Controller: Eine der Broker-Instanzen fungiert als Controller, der den Cluster verwaltet und für das Zuweisen von Partitionen verantwortlich ist.

2. Kafdrop – Kafka UI für Monitoring

Kafdrop ist eine leichtgewichtige Web-Benutzeroberfläche zur Verwaltung und Überwachung von Kafka-Clusters. Es ermöglicht eine übersichtliche Darstellung der Kafka-Cluster-Metriken und bietet Einblicke in folgende Bereiche:

  • Topics und Partitionen: Über Kafdrop können wir Topics und deren Partitionen visualisieren und überwachen.
  • Producer und Consumer: Kafdrop bietet eine Übersicht über die aktiven Producer und Consumer, die Nachrichten in den Kafka-Topics produzieren bzw. konsumieren.
  • Nachrichtenfluss: Du kannst in Echtzeit die Nachrichten innerhalb der Topics anzeigen und analysieren.
  • Zustandsüberwachung: Du siehst direkt, ob ein Broker ausgefallen ist oder ob Replikationen fehlerhaft sind.

Kafdrop wird in diesem Projekt als Docker-Container betrieben und bietet eine benutzerfreundliche Oberfläche für Kafka-Administratoren, um die Cluster-Aktivitäten zu überwachen und zu steuern.

3. Docker für Containerisierung

Wir verwenden Docker zur Containerisierung der Kafka-Broker um eine konsistente Umgebung zu schaffen, die plattformunabhängig und einfach skalierbar ist. Die Vorteile der Containerisierung durch Docker sind:

  • Isolation: Jede Komponente (Kafka-Broker, Kafdrop) läuft in einem separaten Container, wodurch Ressourcen isoliert und Konflikte vermieden werden.
  • Skalierbarkeit: Du kannst leicht neue Kafka-Broker hinzufügen oder entfernen, indem du einfach neue Docker-Container startest oder stoppst.
  • Leichte Verwaltung: Durch Docker Compose wird das Starten, Stoppen und Verwalten des gesamten Kafka-Clusters vereinfacht, da alle Container durch eine Konfigurationsdatei (in unserem Beispiel kafka.yml) verwaltet werden.

4. Java-basierte Producer und Consumer

Die Producer und Consumer, die Daten in Kafka produzieren und konsumieren, sind in diesem Projekt in Java implementiert. Java bietet robuste Bibliotheken wie die Apache Kafka Java API, die es Entwicklern ermöglicht, nahtlos mit Kafka zu interagieren.

  • Producer: Der Producer sendet Daten an die Kafka-Topics. In Java wird dies mit der KafkaProducer-Klasse erreicht. Typische Anwendungsfälle sind das Senden von Nachrichten, wie z.B. Bestellungen (in unserem Beispiel kafka.orders).
  • Consumer: Der Consumer liest die Daten aus den Kafka-Topics. In Java wird dies durch die KafkaConsumer-Klasse realisiert. Er kann Nachrichten von spezifischen Partitionen lesen und diese weiterverarbeiten, z.B. für Echtzeitanalysen oder Datenverarbeitung.

Durch den Einsatz von Java als Programmiersprache für Producer und Consumer profitieren wir von der ausgereiften Multithreading- und Performance-Unterstützung, die Java bietet.

Voraussetzungen für die Einrichtung

Bevor du mit der Einrichtung beginnst, stelle sicher, dass dein System die folgenden Voraussetzungen erfüllt:

1. Docker ist installiert

  • Lade Docker Desktop von der offiziellen Website herunter: Docker Desktop Download.
  • Führe die Installationsdatei aus und folge den Anweisungen auf dem Bildschirm, um Docker auf deinem System zu installieren.

2. Git ist installiert

  • Besuche die offizielle Git-Website: Git Download.
  • Lade die passende Version für dein Betriebssystem herunter und folge den Installationsanweisungen.

3. Java 21 ist installiert

  • Lade Java 21 von der Oracle-Website herunter: Java 21 Download.
  • Führe die Installationsdatei aus und folge den Anweisungen zur Installation von Java 21.

4. Maven ist installiert

  • Besuche die offizielle Maven-Website: Maven Download. Wähle die für deine Plattform passende Version aus und installiere diese.

Einrichtung des Kafka-Clusters

Wir verwenden Docker Compose, um das Kafka-Cluster zu starten. Docker Compose ermöglicht es, Multi-Container-Anwendungen zu definieren und effizient zu verwalten.

Schritt 1: Git-Repository klonen

  1. Öffne ein Terminal:
  • Windows: PowerShell
  • macOS/Linux: Terminal
  1. Navigiere zu dem Verzeichnis, in dem das Projekt abgelegt werden soll:
   cd pfad/zu/deinem/Zielverzeichnis
  1. Klone das Repository:
   git clone https://github.com/integration-developer-de/kafka_kafdrop_docker

Github -> https://github.com/integration-developer-de/kafka_kafdrop_docker

Schritt 2: Wechsel ins Projektverzeichnis

Navigiere in das Projektverzeichnis:

cd dein-projektverzeichnis

Schritt 3: Starte das Kafka-Cluster mit Docker Compose

Docker Compose wird verwendet, um alle benötigten Kafka-Broker und Kafdrop in separaten Containern zu starten.

  1. Cluster starten:
   docker-compose -f kafka.yml up -d
  1. Überprüfe, ob die Container laufen:
   docker ps

oder direkt im docker desktop ->

docker-compose container

Erstellen von Kafka-Topics

Nachdem das Kafka-Cluster läuft, besteht der nächste Schritt darin, Kafka-Themen (Topics) zu erstellen. Topics sind essenziell, um Nachrichtenströme in Kafka zu verwalten. Wir erstellen das Topic über Kafdrop:

Schritt 4: Erstelle das Topic „kafka.orders“

Um ein Topic mit dem Namen kafka.orders mit 3 Partitionen und 3 Replikaten zu erstellen, öffne einen Webbrowser und rufe die Kafdrop-Benutzeroberfläche auf, indem du die folgende URL aufrufst::

http://localhost:9000

Schritt 5: Neues Kafka-Topic erstellen

  1. Klicke in der Kafdrop-Oberfläche auf den Tab „Topics“ im Hauptmenü.
  2. Wähle die Option „Create Topic“ (Topic erstellen) aus, um ein neues Kafka-Topic hinzuzufügen.

Schritt 6: Topic-Details eingeben

  • Topic Name: Gib den Namen des neuen Topics ein, zum Beispiel kafka.orders.
  • Partitions: Lege die Anzahl der Partitionen fest, zum Beispiel 3. Dies bestimmt, wie viele Unterteilungen des Topics auf die Broker verteilt werden.
  • Replication Factor: Gib die Anzahl der Replikationen an, zum Beispiel 3. Damit wird festgelegt, wie oft die Daten auf verschiedene Broker repliziert werden.

Schritt 7: Topic erstellen

Nachdem du die erforderlichen Details eingegeben hast, klicke auf „Create“ (Erstellen), um das Kafka-Topic zu erzeugen.

kafdrop_topic

Java Consumer starten und Nachrichten an das Topic senden

In diesem Abschnitt wird erklärt, wie du einen Java Consumer startest und Nachrichten an ein Kafka-Topic generierst. Diese Schritte sind wichtig, um Datenströme zu testen und zu verarbeiten.

Schritt 8: Abhängigkeiten herunterladen

Um die Abhängigkeiten herunterzuladen und das Projekt zu erstellen, führe den folgenden Befehl im Terminal im Projektverzeichnis aus

mvn clean install

Schritt 9: KafkaTestProducer.java ausführen

Führe die KafkaTestProducer.java Klasse im Terminal aus, indem du den folgenden Befehl eingibst und diesen an dein System anpasst:

cd /pfad/zum/projekt ; /usr/bin/env java -cp /pfad/zur/classdatei com.learning.kafka.KafkaTestProducer
java_kafka_producer

Schritt 10: KafkaTestConsumer.java ausführen

Führe die KafkaTestConsumer.java Klasse im Terminal aus, indem du den folgenden Befehl eingibst und diesen an dein System anpasst:

cd /pfad/zum/projekt ; /usr/bin/env java -cp /pfad/zur/classdatei com.learning.kafka.KafkaTestConsumer
java_consumer

Das war’s! Der bereitgestellte Code bietet einen schnellen Einstieg in die Welt von Kafka. Für weiterführende Informationen und detaillierte Anleitungen empfehle ich die offizielle Kafka-Dokumentation: Kafka Documentation.

Weitere Beiträge

Schlagwörter: