Apache Kafka mit Docker bereitstellen und konfigurieren

Apache Kafka ist ein Open-Source-Nachrichtensystem, das Daten schnell verarbeiten, speichern und übertragen kann. Unternehmen setzen es häufig ein, um eine große Anzahl von Nachrichten in einer organisierten Warteschlange zu versenden, auf die Menschen in Echtzeit mit ihren Geräten zugreifen können. Es lässt sich überall einsetzen, von der Bestandsverwaltung bis zur Patientenüberwachung.

Es gibt viele Möglichkeiten, Kafka einzurichten und zu betreiben, aber die Verwendung von Docker bietet mehrere Vorteile, etwa eine einfachere Einrichtung, bessere Reproduzierbarkeit und höhere Skalierbarkeit. Das liegt daran, dass Docker-Container es Ihnen ermöglichen, Kafka in isolierte Umgebungen zu verpacken, sodass es nicht mit den anderen Anwendungen auf Ihrem Server in Konflikt gerät.

In dieser Anleitung erfahren Sie, wie Sie mit Docker einen Apache-Kafka-Cluster auf einem Ubuntu-VPS bereitstellen. Wir gehen jeden Schritt durch – von der Einrichtung von Docker bis zur Konfiguration und Ausführung von Kafka-Containern.

Voraussetzungen

Bevor Sie mit der Bereitstellung von Kafka auf Docker beginnen, benötigen Sie einen Hosting-Anbieter, der die grundlegenden Hardwareanforderungen erfüllt. Wir empfehlen einen VPS-Server mit:

• Mindestens 4 GB RAM (16 GB für den Produktivbetrieb empfohlen)
• 2 CPU -Kerne (für den Produktivbetrieb werden 4 oder mehr CPU -Kerne benötigt)
• 500 GB Festplattenspeicher (SSDs werden für eine höhere Geschwindigkeit bevorzugt)

Beachten Sie, dass diese Anforderungen je nach Ihrem konkreten Anwendungsfall und der erwarteten Last variieren können. Für Entwicklungs- und Testzwecke können Sie zunächst Hardware mit geringeren Spezifikationen einsetzen und bei Bedarf aufrüsten.

Einige weitere allgemeine Voraussetzungen sind:

• Ubuntu 24.04 ist auf Ihrem VPS-Server vorinstalliert
• SSH-Zugriff mit Root- oder Sudo-Rechten
• Eine zuverlässige Netzwerkverbindung (empfohlen: 1 GbE oder schneller)
• Grundlegende Kenntnisse von Docker-Konzepten wie Containern, Images und Volumes

Apache Kafka mit Docker bereitstellen

Sehen wir uns an, wie Sie Apache Kafka mit Docker auf einem Ubuntu-VPS bereitstellen. Wir führen Sie Schritt für Schritt durch den gesamten Prozess – von der Einrichtung von Docker Compose bis hin zum Testen Ihrer Kafka-Bereitstellung.

1. Richten Sie Ihre Umgebung ein

Stellen Sie zunächst sicher, dass Ihre VPS-Umgebung korrekt konfiguriert ist und für die Bereitstellung von Kafka bereitsteht.

Am einfachsten starten Sie mit der Ubuntu-24.04-Vorlage mit Docker von Hostinger, die Docker, Docker Engine und Docker Compose bereits vorinstalliert enthält. Wenn Sie dies lieber manuell erledigen möchten, können Sie Docker auch auf einem regulären Ubuntu-VPS installieren, indem Sie unserer umfassenden Docker-Einrichtungsanleitung folgen.

Gehen Sie wie folgt vor, um die Vorlage auf Ihrem VPS zu verwenden:

1. Melden Sie sich bei hPanel an und navigieren Sie zu VPS → Verwalten.
2. Gehen Sie zu Einstellungen → Betriebssystem & Panel → Betriebssystem.
3. Wählen Sie Anwendung → Ubuntu 24.04 mit Docker aus.

Anschließend müssen Sie über ein Terminal auf Ihren VPS-Server zugreifen, um mit den restlichen Schritten fortzufahren. Sie können dies entweder mit dem integrierten Browser-Terminal von Hostinger tun oder über SSH mit dem Terminal unter Windows oder macOS eine Verbindung zu Ihrem VPS-Server herstellen.

Wenn Sie damit fertig sind, überprüfen Sie im Terminal mit den folgenden Befehlen, ob die neuesten Versionen von Docker und Docker Compose auf Ihrem System installiert sind:

docker --version

docker compose --version

Falls Docker Compose aus irgendeinem Grund noch nicht installiert ist, können Sie es jetzt mit folgendem Befehl installieren:

sudo apt install docker compose-plugin

Da die Vorlage die Ressourcen entsprechend Ihrem VPS-Tarif im Voraus reserviert, müssen Sie in der Regel nichts weiter konfigurieren.

2. Apache Kafka mit Docker bereitstellen

Apache Kafka ist ein verteiltes System, in dem verschiedene Komponenten reibungslos zusammenarbeiten. Kafka verwendet Broker, um Nachrichten zu speichern und zu verarbeiten, während ZooKeeper traditionell die Metadaten des Clusters verwaltet und die Broker koordiniert. Jeder Broker kann Tausende von Lese- und Schreibvorgängen pro Sekunde verarbeiten, wodurch Kafka sich hervorragend für die hochskalierbare Verarbeitung von Echtzeitdatenströmen eignet.

Die einfachste Möglichkeit, Kafka mit Docker bereitzustellen, besteht darin, die offiziellen Docker-Images von Confluent Inc. zu verwenden. Das Image confluentinc/cp-kafka stellt die Community-Version von Kafka bereit, und confluentinc/cp-zookeeper bietet den ZooKeeper-Dienst.

Diese Docker-Images erleichtern die Bereitstellung, indem sie für konsistente Umgebungen sorgen, die Konfiguration vereinfachen und eine einfache Skalierung ermöglichen.

Für den Einstieg müssen wir zunächst die erforderlichen Verzeichnisse für die Datenspeicherung erstellen und die richtigen Berechtigungen setzen:

mkdir -p ./kafka/data ./zookeeper/data ./zookeeper/log

chmod -R 777 ./kafka ./zookeeper

Um Kafka mit Docker einzurichten, müssen Sie eine Datei namens docker-compose.yml erstellen. Diese Datei sollte sich im Stammverzeichnis Ihres Projekts innerhalb des Ubuntu‑VPS befinden (Beispiel: /kafka). Mehr dazu im nächsten Schritt.

3. Erstellen Sie eine Docker-Compose-Datei

Die Docker-Compose-Datei dient als Blaupause für Ihre Kafka-Bereitstellung und legt alle erforderlichen Dienste und deren Konfigurationen fest. Erstellen Sie in Ihrem Projektverzeichnis eine neue Datei mit dem Namen `docker-compose.yml` und konfigurieren Sie sie mit den folgenden grundlegenden Komponenten:

version: '3.8'

networks:

  kafka-net:

    driver: bridge

services:

  zookeeper:

    image: confluentinc/cp-zookeeper:7.8

    container_name: zookeeper

    ports:

      - "2181:2181"

    environment:

      ZOOKEEPER_CLIENT_PORT: 2181

      ZOOKEEPER_TICK_TIME: 2000

      ZOOKEEPER_INIT_LIMIT: 5

      ZOOKEEPER_SYNC_LIMIT: 2

    volumes:

      - zookeeper_data:/var/lib/zookeeper/data

      - zookeeper_log:/var/lib/zookeeper/log

    networks:

      - kafka-net

    healthcheck:

      test: ["CMD", "nc", "-z", "localhost", "2181"]

      interval: 30s

      timeout: 10s

      retries: 3

  kafka:

    image: confluentinc/cp-kafka:7.8

    container_name: kafka

    depends_on:

      - zookeeper

    ports:

      - "9092:9092"

      - "29092:29092"

    environment:

      KAFKA_BROKER_ID: 1

      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181

      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://your-vps-ip:9092

      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT

      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT

      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

      KAFKA_LOG_DIRS: "/var/lib/kafka/data"

      KAFKA_LOG_RETENTION_HOURS: 168

      KAFKA_MESSAGE_MAX_BYTES: 1000000

      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"

      KAFKA_DELETE_TOPIC_ENABLE: "true"

      KAFKA_NUM_PARTITIONS: 3

      KAFKA_DEFAULT_REPLICATION_FACTOR: 1

    volumes:

      - kafka_data:/var/lib/kafka/data

      - kafka_logs:/var/log/kafka

    networks:

      - kafka-net

    healthcheck:

      test: ["CMD", "nc", "-z", "localhost", "9092"]

      interval: 30s

      timeout: 10s

      retries: 3

volumes:

  kafka_data:

    driver: local

  kafka_logs:

    driver: local

  zookeeper_data:

    driver: local

  zookeeper_log:

    driver: local

Diese Einrichtung umfasst die folgenden Hauptkomponenten:

• Kafka-Container-Einstellungen wie Broker-ID, Listener-Konfigurationen und die Verbindung zu ZooKeeper. 
• ZooKeeper-Diensteinstellungen, einschließlich Client-Port und Tick-Time, für die Verwaltung der Cluster-Koordination. 
• Netzwerkkonfigurationen, die es Kafka- und ZooKeeper-Containern ermöglichen, über das interne Docker-Netzwerk zu kommunizieren. 
• Volume-Zuordnungen für Kafka und ZooKeeper, um sicherzustellen, dass Daten erhalten bleiben, selbst wenn Container neu gestartet werden. 

Das Ergebnis ist ein Kafka-Cluster mit einem einzelnen Broker und einer einzelnen ZooKeeper-Instanz, das sich ideal für Entwicklung und Tests eignet. Es verwendet die neuesten Images der Confluent Community Platform, eine zuverlässige und gut gepflegte Distribution von Apache Kafka.

4. Kafka starten

Starten Sie Ihren Kafka-Cluster mit dem Docker-Compose-Befehl:

docker compose up -d

Stellen Sie sicher, dass beide Dienste ordnungsgemäß laufen, indem Sie den Containerstatus und die Protokolle überprüfen:

docker compose ps

docker compose logs kafka

docker compose logs zookeeper

Sie sollten beide Container im Status Up sehen, ohne Fehlermeldungen in den Protokollen. Der Kafka-Broker benötigt in der Regel einige Sekunden, um vollständig zu starten, nachdem ZooKeeper bereit ist.

5. Die Bereitstellung testen

Überprüfen wir die Bereitstellung, indem wir ein Test-Thema erstellen und Nachrichten austauschen. Erstellen Sie zunächst ein neues Topic mit dem Namen test-topic:

docker compose exec kafka kafka-topics --create --topic test-topic --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1

Öffnen Sie jetzt zwei Terminalfenster, um das Erzeugen und Empfangen von Nachrichten zu testen. Starten Sie im ersten Terminal den Konsolen-Producer:

docker compose exec kafka kafka-console-producer --topic test-topic --bootstrap-server localhost:9092

Starten Sie im zweiten Terminal den Konsolen-Consumer:

docker compose exec kafka kafka-console-consumer --topic test-topic --bootstrap-server localhost:9092 --from-beginning

Geben Sie im Producer-Terminal einige Nachrichten ein und drücken Sie nach jeder Nachricht die Eingabetaste. Diese Nachrichten sollten in Echtzeit im Consumer-Terminal erscheinen und bestätigen, dass Ihre Kafka-Bereitstellung korrekt funktioniert. Um den Producer oder den Consumer zu beenden, drücken Sie Strg+C.

6. Optimieren Sie Ihre Apache-Kafka-Bereitstellung

Die Optimierung Ihrer Kafka-Bereitstellung ist entscheidend, um eine hohe Leistung und Zuverlässigkeit sicherzustellen. Hier sind einige Ansätze, die Sie verwenden können:

Konfiguration von Umgebungsvariablen

Passen Sie Ihre Kafka-Konfiguration mithilfe von Umgebungsvariablen an. Stellen Sie Kafka-Properties ein, indem Sie KAFKA_ voranstellen, sie in Großbuchstaben umwandeln und Punkte durch Unterstriche ersetzen.

Verwenden Sie zum Beispiel KAFKA_BROKER_ID und KAFKA_ZOOKEEPER_CONNECT, um grundlegende Broker-Einstellungen festzulegen. Mit dieser Methode verwalten Sie verschiedene Konfigurationen einfacher, ohne Core-Dateien bearbeiten zu müssen.

Kafka-Broker skalieren

Um Ihr Kafka-Cluster mit Docker Compose zu skalieren, können Sie die Anzahl der Broker-Instanzen anpassen. Der Befehl docker compose up –scale kafka=n funktioniert, aber es ist besser, in Ihrer Datei docker-compose.yml separate Broker-Services zu definieren. Dadurch werden Broker-ID-Konflikte vermieden und eine reibungslose Cluster-Koordination sichergestellt, während Sie zugleich mehr Kontrolle über Konfigurationen und Ressourcenzuweisung erhalten.

Konfiguration des externen Zugriffs

Wenn Sie Kafka für externe Anwendungen verfügbar machen müssen, setzen Sie die Eigenschaft KAFKA_ADVERTISED_LISTENERS korrekt, um die Konnektivität sicherzustellen. Für Produktionsumgebungen sollten Sie Node-Ports oder Load-Balancer verwenden, um einen sicheren und zuverlässigen externen Zugriff zu gewährleisten.

Um eine optimale Leistung aufrechtzuerhalten, achten Sie auf die Hardware und die Konfigurationen. Verwenden Sie schnelle SSDs für die Speicherung, verwalten Sie Partitionen effizient und legen Sie geeignete Replikationsfaktoren fest. Überwachen Sie regelmäßig die Systemmetriken und passen Sie die Konfigurationen entsprechend Ihrer Arbeitslast und Ihrem Anwendungsfall an.

Für Produktionsumgebungen sollte Sicherheit mit TLS-Verschlüsselung und MFA oberste Priorität haben. Tools wie Prometheus und Grafana helfen dabei, die Cluster-Gesundheit und -Performance zu überwachen, sodass Sie Engpässe erkennen und beheben können, bevor sie zu Problemen werden.

Fazit

Die Bereitstellung von Apache Kafka mit Docker bietet eine einfache und effiziente Möglichkeit, eine leistungsstarke Event-Streaming-Plattform aufzusetzen. In dieser Anleitung werden die wichtigsten Schritte erläutert – von der Vorbereitung Ihres Hostinger-VPS bis zur Einrichtung einer Docker-Compose-Datei, die sowohl Kafka als auch ZooKeeper verwaltet.

Aber Kafka einzurichten ist erst der Anfang. Sein tatsächliches Potenzial zeigt sich erst, wenn es Teil eines größeren Datenökosystems ist.

Beachten Sie, dass dieses Handbuch zwar ideal für Entwicklung und Tests ist, produktive Umgebungen jedoch zusätzliche Schritte für Sicherheit, Monitoring und Hochverfügbarkeit erfordern. Wenn Ihr Bedarf steigt, können Sie Ihren Kafka-Cluster skalieren, indem Sie Broker hinzufügen, Partitionen effizient verwalten und ihn für bestimmte Workloads optimieren.

Häufig gestellte Fragen (FAQ) zur Bereitstellung von Kafka in Docker

Alle Tutorial-Inhalte auf dieser Website unterliegen Hostingers strengen redaktionellen Standards und Normen.

Erstellt von

Faradilla Ayunindya

Faradilla, auch bekannt als Ninda, ist Content Marketing Specialist bei Hostinger mit über fünf Jahren Erfahrung und einem zehnjährigen Hintergrund als Linguistin. Sie möchte Technologie für alle zugänglich machen, indem sie komplexe Anleitungen in klare und leicht verständliche Schritt-für-Schritt-Guides verwandelt. In ihrer Freizeit interessiert sie sich für Biowissenschaften oder schaut gerne lustige Tiervideos. Vernetzen Sie sich mit ihr auf LinkedIn.

Mehr von Faradilla Ayunindya