Microservice-orientierte Design Patterns haben unsere Anwendungen skalierbarer denn je gemacht. RESTful API Server, Frontend und sogar die Datenbanken sind jetzt horizontal skalierbar. Horizontale Skalierung ist das Hinzufügen neuer Knoten zu Ihrem Anwendungscluster, um zusätzliche Arbeitslast zu unterstützen. Umgekehrt ermöglicht es auch, den Ressourcenverbrauch zu reduzieren, wenn die Arbeitsbelastung sinkt, um Kosten zu sparen. Horizontal skalierbare Systeme müssen verteilte Systeme sein. Diese Systeme können den Ausfall mehrerer VMs, Container oder Netzwerkverbindungen überstehen und dennoch für den Endbenutzer online und fehlerfrei bleiben.

Wenn wir wie oben über verteilte Systeme sprechen, stoßen wir auf das Problem der Analyse und Überwachung. Jeder Knoten generiert viele Informationen über seinen eigenen Zustand (CPU-Auslastung, Arbeitsspeicher usw.) und über den Anwendungsstatus zusammen mit dem, was die Benutzer zu tun versuchen. Diese Angaben müssen festgehalten werden in:

1. Die gleiche Reihenfolge, in der sie erstellt werden,
2. Getrennt nach Dringlichkeit (Echtzeitanalysen oder Datenstapel) und vor allem,
3. Der Mechanismus, mit dem sie gesammelt werden, muss selbst verteilt und skalierbar sein, sonst haben wir einen Single Point of Failure. Etwas, das das verteilte Systemdesign vermeiden sollte.

Warum Kafka . verwenden?

Apache Kafka wird als Distributed Streaming Platform vorgestellt. In der Kafka-Sprache, Hersteller kontinuierlich Daten generieren (Ströme) und Verbraucher sind für die Verarbeitung, Speicherung und Analyse verantwortlich. Kafka Makler sind dafür verantwortlich, dass in einem verteilten Szenario die Daten ohne Inkonsistenz vom Hersteller bis zum Verbraucher gelangen können. Eine Reihe von Kafka-Brokern und eine andere Software namens Tierpfleger einen typischen Kafka-Einsatz darstellen.

Der Datenstrom vieler Hersteller muss aggregiert, partitioniert und an mehrere Verbraucher gesendet werden, es ist eine Menge Mischen erforderlich. Inkonsistenz zu vermeiden ist keine leichte Aufgabe. Deshalb brauchen wir Kafka.

Die Einsatzszenarien von Kafka sind sehr vielfältig. Alles von IOT-Geräten über VM-Cluster bis hin zu Ihren eigenen Bare-Metal-Servern vor Ort. Überall, wo viele „Dinge“ gleichzeitig Ihre Aufmerksamkeit wollen… .Das ist nicht sehr wissenschaftlich, oder?? Nun, die Kafka-Architektur ist ein eigener Kaninchenbau und verdient eine unabhängige Behandlung. Sehen wir uns zunächst eine sehr oberflächliche Bereitstellung der Software an.

Docker Compose verwenden

Wie auch immer Sie sich für Kafka entscheiden, eines ist sicher - Sie werden es nicht als einzelne Instanz verwenden. Es ist nicht dafür gedacht, und selbst wenn Ihre verteilte App vorerst nur eine Instanz (Broker) benötigt, wird sie irgendwann wachsen und Sie müssen sicherstellen, dass Kafka mithalten kann.

Docker-compose ist der perfekte Partner für diese Art der Skalierbarkeit. Anstatt Kafka-Broker auf verschiedenen VMs auszuführen, containerisieren wir sie und nutzen Docker Compose, um die Bereitstellung und Skalierung zu automatisieren. Docker-Container sind sowohl auf einzelnen Docker-Hosts als auch über einen Cluster hoch skalierbar, wenn wir Docker Swarm oder Kubernetes verwenden. Es ist also sinnvoll, es zu nutzen, um Kafka skalierbar zu machen.

Beginnen wir mit einer einzelnen Broker-Instanz. Erstellen Sie ein Verzeichnis namens apache-kafka und erstellen Sie darin Ihr Docker-Compose.yml.

$ mkdir apache-kafka
$ cd apache-kafka
$ vim docker-compose.yml

Die folgenden Inhalte werden in Ihr docker-compose eingefügt.yml-Datei:

Version: '3'
Dienstleistungen:
Tierpfleger:
Bild: Wurstmeister/Zookeeper
 
Kafka:
Bild: wurstmeister/kafka
Häfen:
- "9092:9092"
Umgebung:
KAFKA_ADVERTISED_HOST_NAME: localhost
KAFKA_ZOOKEEPER_CONNECT: Tierpfleger:2181

Nachdem Sie den obigen Inhalt in Ihrer Compose-Datei gespeichert haben, führen Sie aus demselben Verzeichnis Folgendes aus:

$ docker-compose up -d

Okay, was haben wir hier gemacht?

Docker-Compose verstehen.yml

Compose startet zwei Dienste wie in der yml-Datei aufgeführt listed. Schauen wir uns die Datei etwas genauer an. Das erste Bild ist der Tierpfleger, den Kafka benötigt, um den Überblick über verschiedene Broker, die Netzwerktopologie sowie die Synchronisierung anderer Informationen zu behalten. Da sowohl der Zookeeper- als auch der Kafka-Dienst Teil desselben Bridge-Netzwerks sein werden (dieses wird erstellt, wenn wir docker-compose up ausführen), müssen wir keine Ports freigeben. Der Kafka-Makler kann mit dem Tierpfleger sprechen und das ist alles, was der Tierpfleger braucht.

Der zweite Dienst ist kafka selbst und wir betreiben nur eine einzelne Instanz davon, also einen Broker. Idealerweise möchten Sie mehrere Broker verwenden, um die verteilte Architektur von Kafka . zu nutzen. Der Dienst lauscht auf Port 9092, der auf die gleiche Portnummer auf dem Docker Host abgebildet ist und so kommuniziert der Dienst mit der Außenwelt.

Der zweite Dienst hat auch ein paar Umgebungsvariablen. Zuerst ist KAFKA_ADVERTISED_HOST_NAME auf localhost eingestellt. Unter dieser Adresse ist Kafka tätig, wo Hersteller und Verbraucher sie finden. Dies sollte wiederum auf localhost eingestellt sein, sondern auf die IP-Adresse oder den Hostnamen mit dem die Server in Ihrem Netzwerk erreichbar sind. Zweitens sind der Hostname und die Portnummer Ihres Zookeeper-Dienstes. Da wir den Zookeeper-Dienst benannt haben … na ja, Zookeeper, so wird der Hostname innerhalb des erwähnten Docker Bridge-Netzwerks sein.

Ausführen eines einfachen Nachrichtenflusses

Damit Kafka mit der Arbeit beginnen kann, müssen wir darin ein Thema erstellen. Die Producer-Clients können dann Datenströme (Nachrichten) zu dem genannten Thema veröffentlichen und Verbraucher können den genannten Datenstrom lesen, wenn sie dieses spezielle Thema abonniert haben.

Dazu müssen wir ein interaktives Terminal mit dem Kafka-Container starten. Listen Sie die Container auf, um den Namen des Kafka-Containers abzurufen. In diesem Fall heißt unser Container beispielsweise apache-kafka_kafka_1

$ docker ps

Mit dem Namen des Kafka-Containers können wir jetzt in diesen Container fallen.

$ docker exec -it apache-kafka_kafka_1 bash
bash-4.4#

Öffnen Sie zwei so unterschiedliche Terminals, um eines als Verbraucher und ein anderes als Produzent zu verwenden.

Herstellerseite

Geben Sie in einer der Eingabeaufforderungen (die Sie als Produzent auswählen) die folgenden Befehle ein:

## So erstellen Sie ein neues Thema namens test
bash-4.4# Kafka-Themen.sh --create --zookeeper zookeeper:2181 --replication-factor 1
--Partitionen 1 --topic test
 
## So starten Sie einen Producer, der Datenströme von der Standardeingabe in kafka . veröffentlicht
bash-4.4# Kafka-Konsolen-Produzent.sh --broker-list localhost:9092 --topic test
>

Der Produzent ist nun bereit, Eingaben über die Tastatur entgegenzunehmen und zu veröffentlichen.

Verbraucherseite

Gehen Sie weiter zum zweiten Terminal, das mit Ihrem Kafka-Container verbunden ist. Der folgende Befehl startet einen Consumer, der das Testthema füttert:

$ kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test

Zurück zum Hersteller

Sie können jetzt Nachrichten in die neue Eingabeaufforderung eingeben und jedes Mal, wenn Sie die Eingabetaste drücken, wird die neue Zeile in der Verbrauchereingabeaufforderung gedruckt. Beispielsweise:

> Dies ist eine Nachricht.

Diese Nachricht wird über Kafka an den Verbraucher übermittelt und Sie können sie an der Verbraucheraufforderung ausgedruckt sehen.

Real-World-Setups

Sie haben jetzt ein grobes Bild davon, wie das Kafka-Setup funktioniert. Für Ihren eigenen Anwendungsfall müssen Sie einen Hostnamen festlegen, der nicht localhost ist, Sie benötigen mehrere solcher Broker, um Teil Ihres Kafka-Clusters zu sein, und schließlich müssen Sie Consumer- und Producer-Clients einrichten set.

Hier ein paar nützliche Links:

1. Python-Client von Confluentfluent
2. Offizielle Dokumentation
3. Eine nützliche Demoliste

Ich wünsche Ihnen viel Spaß beim Erkunden von Apache Kafka.