Microservice -orientierte Entwurfsmuster haben unsere Anwendungen skalierbarer als je zuvor gemacht. Erholte API-Server, Front-End und sogar die Datenbanken sind jetzt horizontal skalierbar. Horizontale Skalierung ist das Hinzufügen neuer Knoten zu Ihrem Anwendungscluster, um zusätzliche Workloads zu unterstützen. Umgekehrt ermöglicht es auch die Reduzierung des Ressourcenverbrauchs, wenn die Arbeitsbelastung abnimmt, um Kosten zu sparen. Horizontal skalierbare Systeme müssen verteilt sein. Diese Systeme, die den Fehler mehrerer VMs, Container oder Netzwerkverbindungen überleben können, bleiben dennoch online und gesund für den Endbenutzer.

Wenn wir über verteilte Systeme wie oben sprechen, stoßen wir auf das Problem der Analytik und Überwachung. Jeder Knoten generiert viele Informationen über seine eigene Gesundheit (CPU -Nutzung, Speicher usw.) und über den Anwendungsstatus sowie über das, was die Benutzer versuchen zu tun. Diese Details müssen in:

1. Die gleiche Reihenfolge, in der sie erstellt werden,
2. In Bezug auf Dringlichkeit (Echtzeitanalytik oder Datenstapel) und vor allem in Echtzeit-Analysen getrennt,
3. Der Mechanismus, mit dem sie gesammelt werden. Etwas, das das verteilte Systemdesign vermeiden sollte.

Warum Kafka verwenden??

Apache Kafka wird als verteilte Streaming -Plattform aufgestellt. In Kafka lingo, Produzenten kontinuierlich Daten generieren (Streams) Und Verbraucher sind für die Verarbeitung, Speicherung und Analyse verantwortlich. Kafka Makler sind dafür verantwortlich, sicherzustellen, dass die Daten in einem verteilten Szenario von Herstellern an Verbraucher ohne Inkonsistenz gelangen können. Eine Reihe von Kafka -Brokern und eine weitere Software namens namens Zookeeper eine typische Kafka -Bereitstellung darstellen.

Der Datenstrom vieler Hersteller muss aggregiert, verteilt und an mehrere Verbraucher gesendet werden. Die Vermeidung von Inkonsistenz ist keine leichte Aufgabe. Deshalb brauchen wir Kafka.

Die Szenarien, in denen Kafka verwendet werden kann. Alles, von IoT-Geräten über Cluster von VMs bis hin zu Ihren eigenen On-Premise-Bare-Metal-Servern. Überall, wo viele "Dinge" gleichzeitig Ihre Aufmerksamkeit haben wollen .. .Das ist nicht sehr wissenschaftlich, ist es? Nun, die Kafka-Architektur ist ein eigenes Kaninchenloch und verdient eine unabhängige Behandlung. Lassen Sie uns zunächst eine sehr oberflächliche Bereitstellung der Software sehen.

Verwenden von Docker Compose

In welcher einfallsreichen Art, wie Sie sich für die Verwendung von Kafka entscheiden, ist eines sicher - Sie werden es nicht als einzelne Instanz verwenden. Es soll nicht so verwendet werden, 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 von Skalierbarkeit. Für die Ausführung von Kafka -Brokern auf verschiedenen VMs behaupten wir stattdessen und nutzen Docker Compose, um die Bereitstellung und Skalierung zu automatisieren. Docker -Container sind sowohl auf einzelnen Docker -Hosts als auch auf einem Cluster sehr 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 Brokerinstanz. Erstellen Sie ein Verzeichnis namens Apache-Kafka und erstellen Sie Ihr Docker-Compose.YML.

$ mkdir apache-kafka
$ CD Apache-Kafka
$ vim docker-compose.YML

Die folgenden Inhalte werden in Ihre Docker-Kompose gesteckt.YML -Datei:

Version: '3'
Dienstleistungen:
Zookeeper:
Bild: Wurstmeister/Zookeeper
Kafka:
Bild: Wurstmeister/Kafka
Häfen:
- "9092: 9092"
Umfeld:
Kafka_advertised_host_name: localhost
Kafka_zookeeper_connect: zookeeper: 2181

Sobald Sie den oben genannten Inhalt in Ihrer Komponierungsdatei gespeichert haben, aus demselben Verzeichnislauf:

$ docker -compose up -d

Okay, was haben wir hier gemacht??

Verständnis des Docker-Compose.YML

Compose startet zwei Dienste, wie in der YML -Datei aufgeführt. Schauen wir uns die Datei etwas genau an. Das erste Bild ist Zookeeper, das Kafka benötigt, um verschiedene Makler, die Netzwerk -Topologie zu verfolgen und andere Informationen zu synchronisieren. Da sowohl Zookeeper- als auch Kafka-Dienste Teil desselben Brückennetzes sein werden (dies wird erstellt, wenn wir Docker-Compose ausführen), müssen wir keine Ports freilegen. Kafka Broker kann mit Zookeeper sprechen, und das sind alle Kommunikationsanforderungen.

Der zweite Dienst ist Kafka selbst und wir führen nur eine einzige Instanz davon, das heißt ein Broker. Idealerweise möchten Sie mehrere Makler verwenden, um die verteilte Architektur von Kafka zu nutzen. Der Dienst hört auf Port 9092 zu, der auf die gleiche Portnummer des Docker -Hosts zugeordnet ist, und so kommuniziert der Service mit der Außenwelt.

Der zweite Dienst hat auch einige Umgebungsvariablen. Erstens ist kafka_advertised_host_name auf localhost festgelegt. Dies ist die Adresse, an der Kafka läuft und in der Produzenten und Verbraucher sie finden können. Dies sollte erneut der Set auf Localhost sein, sondern für die IP -Adresse oder der Hostname, mit dem die Server in Ihrem Netzwerk erreicht werden können. Zweitens ist der Hostname und die Portnummer Ihres Zookeeper -Dienstes. Da wir den Zookeeper -Service benannt haben ... nun, Zookeeper ist das, was der Hostname im Docker Bridge -Netzwerk sein wird, das wir erwähnt haben.

Ausführen eines einfachen Nachrichtenflusss

Damit Kafka mit der Arbeit beginnen kann, müssen wir ein Thema darin erstellen. Die Produzenten -Clients können dann Datenströme (Nachrichten) an diesem Thema veröffentlichen, und die Verbraucher können den genannten DataStream lesen, wenn sie dieses bestimmte Thema abonniert haben.

Dazu müssen wir ein interaktives Terminal mit dem Kafka -Behälter 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 einen als Verbraucher und einen anderen Hersteller zu verwenden.

Produzentseite

Geben Sie in einer der Eingabeaufforderungen (die Sie als Produzentin entscheiden) die folgenden Befehle ein:

## Um ein neues Thema mit dem Namen Test zu erstellen
Bash-4.4# Kafka-Topics.SH-Create-Zookeeper Zookeeper: 2181-Replikationsfaktor 1
--Partitionen 1 -topischer Test
## Um einen Produzenten zu gründen, der den DataStream von Standardeingaben zu Kafka veröffentlicht
Bash-4.4# Kafka-Console-Produzent.SH-BROKER-LIST LOCALHOST: 9092-Topic Test
>

Der Produzent ist jetzt bereit, Eingaben von der Tastatur zu nehmen und ihn zu veröffentlichen.

Verbraucherseite

Gehen Sie am zweiten Terminal, das an Ihren Kafka -Behälter angeschlossen ist. Der folgende Befehl startet einen Verbraucher, der zum Testthema füttert:

$ Kafka-Console-Consumer.SH-Bootstrap-Server localhost: 9092--topischer Test

Zurück zum Produzenten

Sie können jetzt Nachrichten in die neue Eingabeaufforderung eingeben, und jedes Mal, wenn Sie zurückgeben, wird die neue Zeile in der Verbraucheraufforderung gedruckt. Zum Beispiel:

> Dies ist eine Nachricht.

Diese Nachricht wird über Kafka an den Verbraucher übertragen, und Sie können sehen.

Reale Setups

Sie haben jetzt ein hartes Bild davon, wie Kafka -Setup funktioniert. Für Ihren eigenen Anwendungsfall müssen Sie einen Hostnamen festlegen, der nicht localhost ist. Sie benötigen mehrere solcher Makler, um Teil Ihres Kafka -Clusters zu sein. Schließlich müssen Sie Kunden für Verbraucher und Hersteller einrichten.

Hier sind einige nützliche Links:

1. Confluents Python -Kunde
2. Offizielle Dokumentation
3. Eine nützliche Liste von Demos

Ich hoffe, Sie haben Spaß, Apache Kafka zu erkunden.