So installieren Sie Apache Kafka unter Debian 10

Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

Einführung

Apache Kafka ist ein beliebter Distributed Message Broker, der für die Verarbeitung großer Mengen von Echtzeitdaten ausgelegt ist. Ein Kafka-Cluster ist hochgradig skalierbar und fehlertolerant und bietet einen wesentlich höheren Durchsatz im Vergleich zu anderen Message Brokern wie ActiveMQ und RabbitMQ. Obwohl er im Allgemeinen als Publish/Subscribe-Messaging-System verwendet wird, verwenden ihn viele Organisationen auch für die Protokollaggregation, da er einen persistenten Speicher für veröffentlichte Nachrichten bietet.

Ein Publish/Subscribe-Messaging-System ermöglicht einem oder mehreren Producern die Veröffentlichung von Nachrichten, ohne die Anzahl der Consumer oder die Art und Weise der Nachrichtenverarbeitung zu berücksichtigen. Abonnierte Clients werden automatisch über Aktualisierungen und die Erstellung neuer Nachrichten informiert. Dieses System ist effizienter und skalierbar als Systeme, bei denen Clients in regelmäßigen Abständen abfragen, ob neue Nachrichten verfügbar sind.

In diesem Tutorial werden Sie Apache Kafka 2.1.1 sicher auf einem Debian 10-Server installieren und konfigurieren und anschließend Ihre Einrichtung testen, indem Sie eine Nachricht Hello World erzeugen und konsumieren. Sie installieren dann wahlweise KafkaT, um Kafka zu überwachen und einen Kafka-Mehrknoten-Cluster einzurichten.

Voraussetzungen

Um dem Tutorial zu folgen, benötigen Sie Folgendes:

• Einen Debian-10-Server mit mindestens 4 GB RAM und einem Benutzer ohne Root-Berechtigung und mit sudo-Privilegien. Wenn Sie keinen Benutzer ohne Root-Berechtigung eingerichtet haben, folgen Sie den Schritten in unserem Leitfaden zur Ersteinrichtung von Debian 10.
• Auf Ihrem Server installiertes OpenJDK 11. Um diese Version zu installieren, folgen Sie den Anweisungen in So installieren Sie Java mit Apt unter Debian 10 zur Installation bestimmter Versionen von OpenJDK. Kafka ist in Java geschrieben und benötigt daher eine JVM.

Schritt 1 – Erstellen eines Benutzers für Kafka

Da Kafka Anfragen über ein Netzwerk verarbeiten kann, ist die Einrichtung eines dedizierten Benutzers eine bewährte Methode. Dies minimiert den Schaden an Ihrem Debian-Rechner, sollte der Kafka-Server kompromittiert werden. In diesem Schritt erstellen Sie den dedizierten Benutzer kafka.

Melden Sie sich als Benutzer ohne Root- und mit sudo-Berechtigung an und erstellen Sie mit dem Befehl useradd einen Benutzer namens kafka:

sudo useradd kafka -m

Das Flag -m stellt sicher, dass ein Home-Verzeichnis für den Benutzer erstellt wird. Dieses Home-Verzeichnis, /home/kafka, dient als Ihr neues Arbeitsbereichsverzeichnis für die spätere Ausführung von Befehlen.

Legen Sie das Passwort mit passwd fest:

sudo passwd kafka

Geben Sie das für diesen Benutzer gewünschte Passwort ein.

Fügen Sie als Nächstes den Benutzer kafka mit dem Befehl adduser zur Gruppe sudo hinzu, damit er über die erforderlichen Berechtigungen zur Installation der Abhängigkeiten von Kafka verfügt:

sudo adduser kafka sudo

Ihr Benutzer kafka ist nun bereit. Melden Sie sich mit su bei diesem Konto an:

su -l kafka

Nachdem Sie nun den Kafka-spezifischen Benutzer erstellt haben, können Sie mit dem Herunterladen und Extrahieren der Kafka-Binärdateien fortfahren.

Schritt 2 – Herunterladen und Extrahieren der Kafka-Binärdateien

In diesem Schritt laden Sie die Kafka-Binärdateien herunter und extrahieren sie in spezielle Ordner im Home-Verzeichnis ihres Benutzers kafka.

Erstellen Sie zu Beginn ein Verzeichnis in /home/kafka namens Downloads, um Ihre Downloads zu speichern:

mkdir ~/Downloads

Installieren Sie als Nächstes curl unter Verwendung von apt-get, damit Sie Remote-Dateien herunterladen können:

sudo apt-get update && sudo apt-get install curl

Wenn Sie dazu aufgefordert werden, geben Sie Y ein, um den Download von curl zu bestätigen.

Sobald curl installiert ist, verwenden Sie es zum Herunterladen der Kafka-Binärdateien:

curl "https://archive.apache.org/dist/kafka/2.1.1/kafka_2.11-2.1.1.tgz" -o ~/Downloads/kafka.tgz

Erstellen Sie ein Verzeichnis namens kafka und wechseln Sie in dieses Verzeichnis. Dies ist das Basisverzeichnis der Kafka-Installation:

mkdir ~/kafka && cd ~/kafka

Extrahieren Sie das von Ihnen heruntergeladene Archiv mit dem Befehl tar:

tar -xvzf ~/Downloads/kafka.tgz --strip 1

Sie haben das Flag --strip 1 angegeben, um sicherzustellen, dass der Inhalt des Archivs in ~/kafka/ selbst und nicht in ein anderes Verzeichnis innerhalb des Archivs extrahiert wird, wie z. B. ~/kafka/kafka_2.12-2.1.1/.

Nachdem Sie die Binärdateien erfolgreich heruntergeladen und extrahiert haben, können Sie mit der Konfiguration von Kafka fortfahren, um das Löschen von Themen zu erlauben.

Schritt 3 – Konfigurieren des Kafka-Servers

Das Standardverhalten von Kafka erlaubt es uns nicht, ein Thema, eine Kategorie, eine Gruppe oder den Feed-Namen zu löschen, an die Nachrichten veröffentlicht werden können. Um dies zu ändern, bearbeiten Sie die Konfigurationsdatei.

Die Konfigurationsoptionen von Kafka werden in server.properties angegeben. Öffnen Sie diese Datei mit nano oder Ihrem bevorzugten Editor:

nano ~/kafka/config/server.properties

Fügen wir eine Einstellung hinzu, die es uns erlaubt, Kafka-Themen zu löschen. Fügen Sie die folgende hervorgehobene Zeile am Ende der Datei hinzu:

...
group.initial.rebalance.delay.ms

delete.topic.enable = true

Speichern Sie die Datei und beenden Sie nano. Nachdem Sie Kafka konfiguriert haben, können Sie systemd Unit-Dateien erstellen, um Kafka beim Start auszuführen und zu aktivieren.

Schritt 4 – Erstellen von Systemd Unit-Dateien und Starten des Kafka-Servers

In diesem Abschnitt erstellen Sie systemd Unit-Dateien für den Kafka-Dienst. Dies wird Ihnen bei der Durchführung allgemeiner Dienstaktionen wie dem Starten, Stoppen und Neustarten von Kafka in einer Weise helfen, die mit anderen Linux-Diensten konsistent ist.

ZooKeeper ist ein Dienst, den Kafka zur Verwaltung seines Clusterstatus und seiner Konfigurationen verwendet. Er wird häufig in verteilten Systemen als integraler Bestandteil verwendet. In diesem Tutorial verwenden Sie Zookeeper, um diese Aspekte von Kafka zu verwalten. Wenn Sie mehr darüber erfahren möchten, besuchen Sie die offiziellen ZooKeeper-Dokumentationen.

Erstellen Sie zuerst die Unit-Datei für zookeeper:

sudo nano /etc/systemd/system/zookeeper.service

Geben Sie die folgende Unit-Definition in die Datei ein:

[Unit]
Requires=network.target remote-fs.target
After=network.target remote-fs.target

[Service]
Type=simple
User=kafka
ExecStart=/home/kafka/kafka/bin/zookeeper-server-start.sh /home/kafka/kafka/config/zookeeper.properties
ExecStop=/home/kafka/kafka/bin/zookeeper-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

Der Abschnitt [Unit] legt fest, dass ZooKeeper eine Vernetzung erfordert und das Dateisystem bereit sein muss, bevor es gestartet werden kann.

Der Abschnitt [Service] legt fest, dass systemd die Shell-Dateien zookeeper-server-start.sh und zookeeper-server-stop.sh zum Starten und Stoppen des Dienstes verwenden soll. Er legt auch fest, dass ZooKeeper automatisch neu gestartet werden soll, wenn er abnormal endet.

Erstellen Sie als Nächstes die Dienstdatei systemd für kafka:

sudo nano /etc/systemd/system/kafka.service

Geben Sie die folgende Unit-Definition in die Datei ein:

[Unit]
Requires=zookeeper.service
After=zookeeper.service

[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/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.target

Der Abschnitt [Unit] legt fest, dass diese Unit-Datei von zookeeper.service abhängt. Dadurch wird sichergestellt, dass zookeeper automatisch gestartet wird, wenn der Dienst kafka startet.

Der Abschnitt [Service] legt fest, dass systemd die Shell-Dateien kafka-server-start.sh und kafka-server-stop.sh zum Starten und Stoppen des Dienstes verwenden soll. Er legt auch fest, dass ZooKeeper automatisch neu gestartet werden soll, wenn er abnormal endet.

Nachdem die Units definiert wurden, starten Sie Kafka mit dem folgenden Befehl:

sudo systemctl start kafka

Um sicherzustellen, dass der Server erfolgreich gestartet wurde, überprüfen Sie die Journalprotokolle für die Unit kafka.

sudo journalctl -u kafka

Sie sehen eine Ausgabe, die der folgenden ähnelt:

Output
Mar 23 13:31:48 kafka systemd[1]: Started kafka.service.

Sie haben nun einen Kafka-Server, der auf Port 9092, den Standardport für Kafka, lauscht.

Sie haben den Dienst kafka gestartet, aber wenn Sie Ihren Server neu starten würden, würde der Dienst noch nicht automatisch gestartet. Um kafka beim Serverstart zu aktivieren, führen Sie Folgendes aus:

sudo systemctl enable kafka

Nachdem Sie die Dienste nun gestartet und aktiviert haben, ist es an der Zeit, die Installation zu überprüfen.

Schritt 5 – Testen der Installation

Veröffentlichen und konsumieren wir eine Nachricht Hello World, um sicherzustellen, dass sich der Kafka-Server korrekt verhält. Die Veröffentlichung von Nachrichten in Kafka erfordert:

• Einen producer, der die Veröffentlichung von Datensätzen und Daten zu Themen ermöglicht.
• Einen consumer, der Nachrichten und Daten zu Themen liest.

Erstellen Sie zuerst ein Thema namens TutorialTopic, indem Sie Folgendes eingeben:

~/kafka/bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic TutorialTopic

Sie können einen Producer von der Befehlszeile aus mit dem Skript kafka-console-producer.sh erstellen. Es erwartet den Hostnamen des Kafka-Servers, den Port und einen Themennamen als Argumente.

Veröffentlichen Sie die Zeichenfolge Hello, World zum Thema TutorialTopic, indem Sie Folgendes eingeben:

echo "Hello, World" | ~/kafka/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic TutorialTopic > /dev/null

Das Flag --broker-list bestimmt die Liste der Nachrichten-Broker, an die die Nachricht gesendet werden soll, in diesem Fall localhost:9092. --topic bezeichnet das Thema als TutorialTopic.

Als Nächstes können Sie mit dem Skript kafka-console-consumer.sh einen Kafka-Consumer erstellen. Es erwartet den Hostnamen des ZooKeeper-Servers, den Port und einen Themennamen als Argumente.

Der folgende Befehl konsumiert Nachrichten von TutorialTopic. Beachten Sie die Verwendung des Flags --from-beginning, das den Verbrauch von Nachrichten erlaubt, die vor dem Start des Consumers veröffentlicht wurden:

~/kafka/bin/kafka-console-consumer.sh --bootstrap-server `localhost:9092` --topic TutorialTopic --from-beginning

--bootstrap-server bietet eine Liste von Eingängen in den Kafka-Cluster. In diesem Fall verwenden Sie localhost:9092.

Sie sehen Hello, World auf Ihrem Terminal:

Output
Hello, World

Das Skript wird kontinuierlich weiter ausgeführt und wartet darauf, dass weitere Nachrichten zu dem Thema veröffentlicht werden. Zögern Sie nicht, ein neues Terminal zu öffnen und einen Producer zu starten, um weitere Nachrichten zu veröffentlichen. Sie sollten sie alle in der Ausgabe des Consumers sehen können. Wenn Sie mehr über die Verwendung von Kafka erfahren möchten, lesen Sie die offizielle Kafka-Dokumentation.

Wenn Sie dem Testen fertig sind, drücken Sie STRG+C, um das Consumer-Skript zu stoppen. Nachdem Sie die Installation getestet haben, können Sie mit der Installation von KafkaT fortfahren, um Ihren Kafka-Cluster besser zu verwalten.

Schritt 6 – Installieren von KafkaT (optional)

KafkaT ist ein Tool von Airbnb, das die Anzeige von Details über Ihren Kafka-Cluster und die Durchführung bestimmter administrativer Aufgaben von der Befehlszeile aus erleichtert. Da es sich um ein Ruby Gem handelt, benötigen Sie Ruby, um es zu benutzen. Sie benötigen weiterhin das Paket build-essential um die anderen Gems zu erstellen, von denen es abhängt. Installieren Sie es mit apt:

sudo apt install ruby ruby-dev build-essential

Sie können KafkaT nun mit dem Befehl gem installieren:

sudo CFLAGS=-Wno-error=format-overflow gem install kafkat

Die Option CFLAGS=-Wno-error=format-overflow deaktiviert die Formatüberlauf-Warnungen und ist für das ZooKeeper Gem erforderlich, das eine Abhängigkeit von KafkaT ist.

KafkaT verwendet .kafkatcfg als Konfigurationsdatei, um die Installations- und Protokollverzeichnisse Ihres Kafka-Servers zu bestimmen. Es sollte auch einen Eintrag zum Verweis von KafkaT auf Ihre ZooKeeper-Instanz haben.

Erstellen Sie eine neue Datei namens .kafkatcfg:

nano ~/.kafkatcfg

Fügen Sie die folgenden Zeilen hinzu, um die erforderlichen Informationen über Ihren Kafka-Server und die Zookeeper-Instanz zu spezifizieren:

{
  "kafka_path": "~/kafka",
  "log_path": "/tmp/kafka-logs",
  "zk_path": "localhost:2181"
}

Sie können KafkaT nun verwenden. Als Erstes wird hier beschrieben, wie Sie es verwenden würden, um Details über alle Kafka-Partitionen anzuzeigen:

kafkat partitions

Sie sehen den folgenden Output:

Output
Topic                 Partition   Leader      Replicas        ISRs    
TutorialTopic         0             0         [0]             [0]
__consumer_offsets	  0		        0		  [0]			  [0]
...

Diese Ausgabe zeigt TutorialTopic sowie __consumer_offsets, ein internes Thema, das von Kafka zur Speicherung von clientbezogenen Informationen verwendet wird. Sie können die mit __consumer_offsets beginnenden Zeilen sicher ignorieren.

Weitere Informationen über KafkaT finden Sie in seinem GitHub Repository.

Nachdem Sie KafkaT installiert haben, können Sie Kafka optional auf einem Cluster von Debian 10-Servern einrichten, um einen Mehrfachkonten-Cluster zu erstellen.

Schritt 7 – Einrichten eines Mehrfachknoten-Clusters (optional)

Wenn Sie einen Multi-Broker-Cluster unter Verwendung von weiteren Debian 10-Servern erstellen möchten, wiederholen Sie Schritt 1, Schritt 4 und Schritt 5 auf jedem der neuen Rechner. Nehmen Sie zusätzlich die folgenden Änderungen in der Datei ~/kafka/config/server.properties für jeden Rechner vor:

• Ändern Sie den Wert der Eigenschaft broker.id so, dass er im gesamten Cluster eindeutig ist. Diese Eigenschaft identifiziert jeden Server im Cluster eindeutig und kann eine beliebige Zeichenfolge als Wert haben. Beispielsweise wären „server1“, „server2“ etc. als Identifikatoren nützlich.

• Ändern Sie den Wert der Eigenschaft zookeeper.connect so, dass alle Knoten auf die gleiche ZooKeeper-Instanz verweisen. Diese Eigenschaft gibt die Adresse der zookeeper-Instanz an und folgt dem Format <HOSTNAME/IP_ADDRESS>:<PORT>. Für dieses Tutorial würden Sie your_first_server_IP:2181 verwenden, wobei Sie your_first_server_IP durch die IP-Adresse des von Ihnen bereits eingerichteten Debian 10-Servers ersetzen.

Wenn Sie mehrere ZooKeeper-Instanzen für Ihren Cluster haben möchten, sollte der Wert der Eigenschaft zookeeper.connect auf jedem Knoten eine identische, durch Komma getrennten Zeichenfolge sein, die die IP-Adressen und die Portnummern aller ZooKeeper-Instanzen auflistet.

Schritt 8 – Einschränkung des Kafka-Benutzers

Nachdem jetzt alle Installationen abgeschlossen sind, können Sie die Admin-Berechtigungen des Benutzers kafka entfernen. Bevor Sie dies tun, melden Sie sich wieder als beliebiger Benutzer ohne Root- und mit sudo-Berechtigung an. Wenn Sie noch die gleiche Shell-Sitzung ausführen, mit der Sie das Tutorial gestartet haben, geben Sie einfach exit ein.

Entfernen Sie den Benutzer kafka aus der Gruppe sudo:

sudo deluser kafka sudo

Um die Sicherheit Ihres Kafka-Servers weiter zu verbessern, sperren Sie das Passwort des Benutzer kafka mit dem Befehl passwd. Dadurch wird sichergestellt, dass sich niemand mit diesem Konto direkt am Server anmelden kann:

sudo passwd kafka -l

Zu diesem Zeitpunkt kann sich nur der Benutzer root oder sudo als kafka anmelden, indem folgender Befehl eingegeben wird:

sudo su - kafka

Wenn Sie es in Zukunft entsperren möchten, verwenden Sie passwd mit der Option -u:

sudo passwd kafka -u

Sie haben nun erfolgreich die Admin-Berechtigungen des Benutzers kafka eingeschränkt.

Zusammenfassung

Apache Kafka wird nun sicher auf Ihrem Debian-Server ausgeführt. Sie können es in Ihren Projekten verwenden, indem Sie Kafka-Producer und -Consumer mit Kafka-Clients erstellen, die für die meisten Programmiersprachen verfügbar sind. Weitere Informationen über Kafka können Sie auch der Apache Kafka-Dokumentation entnehmen.