Integration Developer - Spring Boot - Kafka

Einleitung

In der heutigen Softwareentwicklung sind Echtzeit-Nachrichtenverarbeitungen und verteilte Systeme unverzichtbar für zahlreiche Anwendungsbereiche. Von IoT-Anwendungen über Finanztransaktionen bis hin zu E-Commerce-Plattformen sind Systeme gefragt, die große Datenmengen effizient und in Echtzeit verarbeiten können.

Eine leistungsstarke Kombination aus Spring Boot, Apache Kafka und Docker bietet Entwicklern die Werkzeuge, um:

Robuste und fehlertolerante Systeme zu entwickeln,
Skalierbare Architekturen für wachsende Datenströme zu schaffen,
Den Einsatz in Cloud- und On-Premise-Umgebungen zu optimieren.

Diese Technologien ergänzen sich hervorragend:

Spring Boot beschleunigt die Entwicklung moderner Microservices mit einer klaren Struktur und einfacher Integration von Technologien.
Apache Kafka dient als verlässliche Plattform für die Verarbeitung und Vermittlung großer Datenströme.
Docker ermöglicht die Containerisierung und das einfache Bereitstellen von Anwendungen, wodurch Entwicklungs- und Produktionsumgebungen harmonisiert werden.

Zusammen bilden sie eine ideale Grundlage, um die Herausforderungen moderner Echtzeitsysteme zu bewältigen. Dieses kleine Lernprojekt stellt eine praktische Demo dieser Technologien dar und zeigt, wie sie zusammenwirken können, um eine einfache, aber effektive Lösung für Echtzeit-Nachrichtenverarbeitung zu implementieren.

Architektur im Überblick

Das Hauptziel ist der Entwurf eines Systems, in dem zwei Spring Boot-Anwendungen über Kafka Nachrichten austauschen. Eine Anwendung (Sender) sendet eine Nachricht, die andere (Receiver) empfängt diese, verarbeitet sie und protokolliert das Ergebnis. Kafka dient hierbei als Nachrichtenvermittler und wird mit Hilfe von Docker bereitgestellt.

Systemkomponenten:

Spring Boot Anwendung (Sender): Sendet Nachrichten.
Spring Boot Anwendung (Empfänger): Empfängt Nachrichten.
Kafka Server: Verwaltet die Nachrichtenvermittlung und ist in Docker konfiguriert.
Docker Containers: Hostet Kafka und ermöglicht eine isolierte, portierbare Umgebung.

.
├── HELP.md
├── kafka.yml
├── mvnw
├── mvnw.cmd
├── pom.xml
├── postgree.yml
├── Readme.md
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── spring_boot_kafka
│   │   │               ├── config
│   │   │               │   └── KafkaTopicConfig.java
│   │   │               ├── consumer
│   │   │               │   └── KafkaConsumer.java
│   │   │               ├── controller
│   │   │               │   └── MessageController.java
│   │   │               ├── models
│   │   │               │   └── Order.java
│   │   │               ├── producer
│   │   │               │   └── KafkaProducer.java
│   │   │               └── SpringBootKafkaApplication.java

Komponenten im Detail

1. Spring Boot Anwendung (Sender)

Die Sender-Anwendung ist dafür verantwortlich, eine API bereitzustellen, über die Benutzer Nachrichten senden können. Diese Nachrichten werden dann zur Weiterverarbeitung an die Empfänger-Anwendung gesendet.

API Endpunkt: /send
HTTP Methode: POST
Payload: Ein einfacher String, der übermittelt wird.

2. Spring Boot Anwendung (Empfänger)

Der Empfänger agiert als Mittelsmann zwischen dem Sender und dem Kafka-Server. Er empfängt Nachrichten vom Sender, sendet diese an Kafka, konsumiert sie direkt und schreibt die empfangenen Nachrichten ins Log.

Verantwortlichkeiten:
Empfangen von Nachrichten.
Weiterleiten der Nachricht an Kafka.
Konsumieren und Protokollieren der Nachricht.

3. Kafka Server

Kafka fungiert als Nachrichten-Broker. Es empfängt Nachrichten von der Empfänger-Anwendung und speichert diese in Themen (Topics), bis sie konsumiert werden. Die Einrichtung und Verwaltung von Kafka wird durch Docker vereinfacht.

Konfiguration: Kafka wird in Docker bereitgestellt.
Nachrichtenvermittlung: Verarbeiten von eingehenden und ausgehenden Nachrichten zwischen den Anwendungen.

Technische Umsetzung

Kafka-Setup mit Docker

Um Kafka und Zookeeper in Docker zu betreiben, verwenden wir eine kafka.yml Docker Compose Datei, die beide Services definiert. Durch Docker wird die Bereitstellung von Kafka für Entwicklungs- und Produktionsumgebungen vereinfacht.

services:
  kafka-1:
    image: "bitnami/kafka:latest" 
    container_name: kafka-1
    environment:
      - KAFKA_ENABLE_KRAFT=yes
      - ALLOW_PLAINTEXT_LISTENER=yes
      - KAFKA_CFG_NODE_ID=1001
      - KAFKA_KRAFT_CLUSTER_ID=NDY0NTQ2ZjNmNTIwNGRiNT
      - KAFKA_CFG_PROCESS_ROLES=broker,controller
      - KAFKA_CFG_CONTROLLER_LISTENER_NAMES=CONTROLLER
      - KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP=CLIENT:PLAINTEXT,CONTROLLER:PLAINTEXT,INTERNAL:PLAINTEXT
      - KAFKA_CFG_CONTROLLER_QUORUM_VOTERS=1001@kafka-1:29092,1002@kafka-2:29093
      - KAFKA_CFG_ADVERTISED_LISTENERS=CLIENT://localhost:9092,INTERNAL://kafka-1:19092
      - KAFKA_CFG_LISTENERS=CLIENT://:9092,CONTROLLER://kafka-1:29092,INTERNAL://:19092
      - KAFKA_CFG_INTER_BROKER_LISTENER_NAME=INTERNAL
    ports:
      - "9092:9092"
    networks:
      - kafka-net

Nachrichtenfluss

Der Sender schickt eine Nachricht an den Empfänger über den /send API-Endpunkt.
Der Empfänger sendet die empfangene Nachricht an Kafka weiter.
Kafka verarbeitet die Nachricht und stellt sie dem Empfänger zum Konsum zur Verfügung.
Der Empfänger konsumiert die Nachricht und protokolliert sie.

Der Datenfluss:

Nachrichtenformat

Die Nachrichten bestehen aus einfachen Strings, die leicht zwischen den Anwendungen übertragen und verarbeitet werden können.

Leistungsmetriken

Für die Bewertung der Systemleistung sind folgende Metriken wichtig:

Durchsatz: Die Anzahl der Nachrichten, die pro Sekunde verarbeitet werden können.
Latenz: Die Zeit, die benötigt wird, um eine Nachricht zu versenden und zu empfangen.
Skalierbarkeit: Kafka und Spring Boot Anwendungen können bei Bedarf horizontal skaliert werden, um eine höhere Belastung zu bewältigen.

Bereitstellungsplan

Docker Compose: Kafka und Zookeeper werden mit Hilfe von Docker Compose bereitgestellt, was eine einfache Verwaltung und Skalierbarkeit gewährleistet.
Spring Boot Anwendungen: Beide Anwendungen können entweder lokal oder in Docker-Containern bereitgestellt werden, was Flexibilität in der Bereitstellung bietet.

Repository

Die Demo ist im folgenden Repository auf GitHub zu finden. Es kann frei damit experimentiert und nach eigenen Bedürfnissen angepasst werden.

https://github.com/integration-developer-de/Spring-Boot---Kafka---Docker

Fazit

Die Kombination aus Spring Boot, Kafka und Docker bietet eine leistungsstarke Plattform für den Aufbau verteilter, skalierbarer Nachrichtensysteme. Die Verwendung von Docker erleichtert die Bereitstellung und Wartung der Kafka-Umgebung, während Spring Boot eine einfache und effektive API für den Nachrichtenaustausch bietet. Diese Lösung ist nicht nur flexibel und skalierbar, sondern auch einfach zu implementieren und zu erweitern.

Spring Boot – Kafka – Docker