Apache Kafka - Die Message-Pipeline erwacht in unserem Labor zum Leben - PMC-Services
Take A Look At Apache Kafka

Apache Kafka – Die Message-Pipeline erwacht in unserem Labor zum Leben

Seit geraumer Zeit führt im Umfeld von Big Data an Apache Kafka kein Weg mehr vorbei. Grund genug, uns die Funktionsweise des viel seits gelobten und nach dem deutschen Schriftsteller Franz Kafka (schon irgendwie passend, Schriftsteller und schreiboptimiertes System :-)) benannten Tools einmal genauer und näher anzuschauen.

Doch sprechen wir zuerst über den konkreten Kundennutzen den Kafka als Daten-Streaming System oder Message Broker mit sich bringt. In der heutigen Zeit ist der Datenaustausch zwischen verteilten Systemen in einer heterogenen und mitunter auch historisch gewachsenen IT-Landschaft meiner Erfahrung nach noch immer eine sehr große Herausforderung. Kafka bietet den Ansatz diese Probleme zu lösen bzw. die Kommunikation der Systeme untereinander zu vereinfachen. Dabei spielen Entkopplung der Datenströme von der Verarbeitungslogik, als auch die Pufferung nicht gesendeter Nachrichten eine große Rolle, aber auch Themen wie ein hoher Datendurchsatz, Partitionierung, Latenz und Zuverlässigkeit sind enorm wichtig. Alle genannten Punkte sind durch das Kafka-Entwicklerteam noch effizienter als bei bestehenden Message-Systemen gestaltet. Somit sind diverse Einsatzzwecke, wie beispielsweise Echtzeit-Tracking, Messaging oder die Überwachung operativer Kennzahlen, denkbar.

Apacha Kafka ist eine unter Java und Scala entwickelte Stream-Processing Platform, die ursprünglich durch LinkedIn entwickelt und später über die Apache Software Foundation als Open-Source Projekt zur Verfügung gestellt wurde. Das Ziel von Apache Kafka war von Anfang auf die schnelle und effiziente Verarbeitung von Echtzeit-Datenstreams ausgerichtet. Das soll zur Geschichte und der groben Einführung aber erst einmal reichen. Schauen wir uns als nächstes den Aufbau bzw. die Architektur von Kafka an.

Apache Kafka aus technischer Sicht

Apache Kafka folgt dabei dem folgenden Design-Pattern.

Kafka Übersicht 1

Nachrichten können über beliebige Kanäle, sogenannte Producer, produziert und an das Kafka-Cluster übergegeben werden. Dabei wird jede einzelne Nachricht immer an ein Topic gesendet. Beim Lesevorgang wird dann durch einen Consumer auch immer aus einem Topic gelesen. Das heißt, dass sich ein Consumer Nachrichten im Pull-Verfahren aus einem Topic auslesen kann.

Kafka Topics sind in mehrere Partitionen unterteilt. Diese helfen bei der Paralleliserung eines Topics, indem sie die Daten in mehrere Broker aufteilen. Dabei kann jede Partition auch auf einem separaten Server liegen, was wiederum erlaubt, dass mehrere Consumer parallel von einem Topic lesen können. Auch Consumer können auf ähnliche Weise parallelisiert werden, sodass mehrere Consumer parallel von mehreren Topics lesen können, was natürlich einen immens hohen Datendurchsatz ermöglicht. Hier sieht man nun auch, warum Kafka im Big Data Umfeld so beliebt ist.

Kafka-Cluster Überischt

So, nun aber genug der Theorie, starten wir mit dem Hands-On.

Vorbereitung

Zum Start laden wir uns über den Download-Bereich der offiziellen Apache Kafka-Website das aktuelle Paket von Kafka herunter und entpacken es an einem beliebigen Ort auf unserer Festplatte. Wir haben dies für diesen Fall auf separaten Festplatten-Partition D:\Spielwiese\kafka_2.11-1.0.0 abgelegt. Einen Installer oder ähnliches gibt es nicht. Vielleicht wäre es wichtig, noch ein paar Worte über die Voraussetzungen zu verlieren. Natürlich wird  JAVA benötigt und die Windows PATH-Variable sollte entsprechend konfiguriert sein, mehr braucht es für den Anfang nicht. Apache Kafka selbst bringt auch direkt Zookeeper im heruntergeladenen Paket mit. Zookeeper ist, wie auch Kafka, ein Apache Open-Source Projekt und dient der dedizierteren, hierarchischen Speicherung von Key-Value Werten. Von Kafka wird Zookeeper für die Koordination der verschiedenen Consumer verwendet.

Start der Dienste

Nachdem wir nun alles erst einmal grundsätzlich eingerichtet haben, wird es Zeit, die Dienste zum ersten Mal zu starten. Dafür müssen wir natürlich zum einen Zookeeper als benötigten „Basisdienst“ starten, als auch Kafka selbst. Starten wir also mit Zookeeper. Wir navigieren mit unserem Command-Line-Tool (ich habe jetzt die normale Windows-Eingabeaufforderung verwendet) in folgendes Unterverzeichnis unserer neu angelegten Kafka-Installation: D:\Spielwiese\kafka_2.11-1.0.0\bin\windows. Bevor wir den Server starten ist es wichtig, in diesem Verzeichnis auch die entsprechenden Konfigurationsfiles abzulegen. Die beiden Files tragen den Namen zookeeper.properties und server.properties und man findet sie unter kafka_2.11-1.0.0\config. Nun geben wir folgenden Befehl ein:

Zookeeper starten

Der Server startet nun und schreibt eine ganze Menge Output auf die Konsole. Sollte der Start mit einer Fehlermeldung abbrechen, dann tragt diese bitte in die Kommentare ein, dann werde ich bei Gelegenheit versuchen zu helfen. Danach öffnet ihr eine neue Konsole und startet auch noch Kafka, wie eben gezeigt aus dem gleichen Verzeichnis, nur über den folgenden Befehl:

Kafka starten

Topic anlegen und erste Nachrichten publishen

Kafka schreibt noch mehr an Informationen in die Konsole und gibt dann irgendwann den Status bekannt, dass der Server läuft. Nun ist es an der Zeit, unser erstes Topic anzulegen. Dies tun wir, indem wir ein neues Konsolen-Fenster öffnen und den folgenden Befehl unter dem bekannten Verzeichnis eingeben:
D:\Spielwiese\kafka_2.11-1.0.0\bin\windows>kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic testkafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

Dies legt uns ein neues Topic mit dem Namen test an, unter welchem wir nun gleich fröhlich Nachrichten publishen können. Um zu überprüfen ob alles geklappt hat, oder auch um uns die vorhandenen Topics anschauen zu können, geben wir den folgenden Befehl ein. Dies listet und wie unten gezeigt auch gleich unser neu angelegtes Topic „test“ auf.

D:\Spielwiese\kafka_2.11-1.0.0\bin\windows>kafka-topics.bat --list --zookeeper localhost:2181
test

Jetzt wollen wir aber auch einmal die ersten Test-Nachrichten publishen. Dafür nutzen wir die von Kafka zur Verfügung gestellte Producer-API über die Konsole. Und das geht über folgenden Befehl:

D:\Spielwiese\kafka_2.11-1.0.0\bin\windows>kafka-console-producer.bat --broker-list localhost:9092 --topic test

Es öffnet sich nun so etwas wie ein Editor in der Kommandozeile, über den nun Zeichenketten eingegeben werden und über „Enter“ abgesendet werden können.

Senden von Messsages an unser Topic

Nun haben wir die Producer-Seite abgedeckt. Aber wie sieht die Consumer-Seite aus? Natürlich wäre eine Simulation auch über die Kommandozeile möglich, ich möchte es in diesem Labor-Tutorial jedoch über eine node.js-Applikation verproben. Zum Einen weil ich node.js sehr, sehr gerne mag, es einfach und schnell aufgesetzt ist und aus meiner Sicht (zumindest was Microservices angeht) zumindest mittelfristig die Plattform der Zukunft ist.

Wir bauen uns einen Consumer mit node.js

Ziel unseres Consumers ist vorerst nicht mehr als eine Ausgabe der bezogenen Messages auf einer separaten Konsole. Hierzu habe ich in Webstorm ein neues, leeres Projekt mit dem Namen „kafka“ angelegt. Als erstes lege ich hier eine neue pakage.json Datei an und installiere danach gleich ein node-Modul mit dem Namen no-kafka an.

Das Projekt ist unter diesem Link zu finden. Es gibt natürlich auch noch eine Menge anderer Module, die einen ähnlichen Scope haben. Ich habe mich nun aber einfach mal für das genannte Modul entschieden, da es mir einen recht guten Eindruck vermittelte, was die Dokumentation und Aktualität angeht. Ob es für einen produktiven Einsatz geeignet ist, müssen wir zu einem anderen Zeitpunkt evaluieren. Wie gesagt, starten wir einfach mal mit diesem Modul und installieren es über den Node-Paket-Manager npm und dem Befehl: npm install no-kafka --save.

Nachdem wir das Paket erfolgreich installieren konnten, legen wir eine Datei server.js auf dem root-Verzeichnis des Projektes (also auf Eben der package.json) an. In dieser Datei geben wir das folgende Coding ein:

var Kafka = require('no-kafka');
var consumer = new Kafka.SimpleConsumer();

// data handler function can return a Promise
var dataHandler = function (messageSet, topic, partition) {
    messageSet.forEach(function (m) {
        console.log(topic, partition, m.offset, m.message.value.toString('utf8'));
    });
};

return consumer.init().then(function () {
    // Subscribe partitons 0 and 1 in a topic:
    return consumer.subscribe('test', [0, 1], dataHandler);
});

Wenn wir das Projekt nun über den Befehl node server.js starten, in der Windows-Eingabeaufforderung in unserem „Kafka-Command-Line-Editor“ eine neue Meldung verfassen und die Konsole in WebStorm im Auge behalten, die entsprechende Ausgabe aus unserem Topic „test“. Damit haben wir den Durchstich geschafft. Wohin uns das Ganze als nächstes führt, sehen wir in einem der folgenden Blogs.

Steffen Stähle

Digitaler Transformer aus Leidenschaft - Ist der festen Überzeugung, dass die Unternehmens-IT sich in den nächsten Jahren drastisch ändern wird und deshalb immer auf der Suche nach Optimierungspotential um Arbeitsabläufe mit modernen Technologien und Architekturen noch effizienter zu gestalten.