Apache Kafka untuk Arsitektur Microservices: Panduan Lengkap Event-Driven Architecture

5. Kafka vs RabbitMQ vs Pulsar vs Kinesis

Memilih message broker untuk microservices bukan keputusan sepele. Berikut perbandingan yang jujur:

6. Setup Kafka untuk Microservices

Mulai dari Docker Compose untuk development. Konfigurasi ini menggunakan KRaft mode (tanpa ZooKeeper):

Docker Compose untuk Kafka

# docker-compose.yml
version: '3.8'
services:
  kafka:
    image: apache/kafka:3.9.0
    container_name: kafka-broker
    ports:
      - "9092:9092"
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker,controller
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092,CONTROLLER://0.0.0.0:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka:9093
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_LOG_DIRS: /tmp/kraft-combined-logs
      CLUSTER_ID: 'MkU3OEVBNTcwNTJENDM2Qk'

Producer Microservice (Java)

// OrderService.java - Publish event saat order dibuat
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;

public class OrderService {
    private final KafkaProducer<String, String> producer;
    private final ObjectMapper mapper = new ObjectMapper();

    public OrderService() {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", StringSerializer.class.getName());
        props.put("value.serializer", StringSerializer.class.getName());
        props.put("acks", "all");
        props.put("enable.idempotence", true); // exactly-once delivery
        this.producer = new KafkaProducer<>(props);
    }

    public void createOrder(Order order) throws Exception {
        // Simpan order ke database...

        // Publish event ke Kafka
        OrderEvent event = new OrderEvent("OrderCreated", order.getId(),
            order.getUserId(), order.getItems(), Instant.now());

        ProducerRecord<String, String> record =
            new ProducerRecord<>("orders", order.getId(), mapper.writeValueAsString(event));

        producer.send(record, (metadata, exception) -> {
            if (exception != null) {
                // Handle error, retry atau dead letter queue
                System.err.println("Failed to publish OrderCreated: " + exception.getMessage());
            } else {
                System.out.println("OrderCreated published to " + metadata.topic()
                    + " partition " + metadata.partition());
            }
        });
    }
}

Consumer Microservice (Python)

# inventory_service.py - Subscribe ke order events
from kafka import KafkaConsumer
import json

class InventoryService:
    def __init__(self):
        self.consumer = KafkaConsumer(
            'orders',
            bootstrap_servers='localhost:9092',
            group_id='inventory-service',
            auto_offset_reset='earliest',
            enable_auto_commit=False,  # manual commit untuk at-least-once
            value_deserializer=lambda m: json.loads(m.decode('utf-8'))
        )

    def process_events(self):
        print("InventoryService listening to 'orders' topic...")
        for message in self.consumer:
            event = message.value
            print(f"Received event type: {event['type']}")

            if event['type'] == 'OrderCreated':
                self.reserve_stock(event['payload']['items'])
            elif event['type'] == 'OrderCancelled':
                self.release_stock(event['payload']['items'])

            # Manual commit setelah proses berhasil
            self.consumer.commit()

    def reserve_stock(self, items):
        for item in items:
            # Kurangi stok di database...
            print(f"Reserved {item['quantity']}x {item['name']}")
        print("Stock reserved successfully")

if __name__ == '__main__':
    service = InventoryService()
    service.process_events()

Kafka CLI Commands

# Buat topic baru
bin/kafka-topics.sh --create \
  --topic orders \
  --bootstrap-server localhost:9092 \
  --partitions 6 \
  --replication-factor 3

# Lihat daftar topic
bin/kafka-topics.sh --list --bootstrap-server localhost:9092

# Lihat detail topic
bin/kafka-topics.sh --describe --topic orders --bootstrap-server localhost:9092

# Test kirim message dari CLI
bin/kafka-console-producer.sh --topic orders --bootstrap-server localhost:9092

# Test baca message dari CLI
bin/kafka-console-consumer.sh --topic orders --bootstrap-server localhost:9092 \
  --from-beginning --group test-consumer

# Cek consumer lag
bin/kafka-consumer-groups.sh --bootstrap-server localhost:9092 \
  --describe --group inventory-service

7. Ekosistem Kafka: Lebih dari Sekadar Broker

Kafka bukan cuma message broker. Ekosistemnya punya tools kuat untuk microservices:

Data pipeline modern memanfaatkan streaming untuk real-time processing

Kafka Connect

Framework untuk integrasi data dari/to sistem eksternal tanpa menulis kode custom. Tersedia ratusan connector: PostgreSQL, MongoDB, Elasticsearch, S3, dan banyak lagi. Untuk CDC, gunakan Debezium connector yang mereplikasi perubahan database ke Kafka secara real-time.

Kafka Streams

Java library untuk stream processing. Tidak perlu cluster terpisah — berjalan sebagai bagian dari aplikasi microservice. Cocok untuk aggregasi, filtering, join, dan transformasi data secara real-time.

// Contoh Kafka Streams: Aggregasi order per user
import org.apache.kafka.streams.*;
import org.apache.kafka.streams.kstream.*;

Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "order-aggregation");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

StreamsBuilder builder = new StreamsBuilder();
KStream<String, OrderEvent> orders = builder.stream("orders");

orders.groupByKey()
    .windowedBy(TimeWindows.ofSizeWithNoGrace(Duration.ofMinutes(5)))
    .count()
    .toStream()
    .to("order-counts");

ksqlDB

SQL engine untuk query data di Kafka secara real-time. Tidak perlu menulis kode Java atau Python. Contoh: buat materialized view dari order events hanya dengan SQL.

-- Buat stream dari topic orders
CREATE STREAM orders_stream (
  event_type VARCHAR KEY,
  order_id VARCHAR,
  user_id VARCHAR,
  total_amount DECIMAL(10,2)
) WITH (
  KAFKA_TOPIC = 'orders',
  VALUE_FORMAT = 'JSON'
);

-- Agregasi: total order per user dalam 1 jam window
SELECT user_id, COUNT(*) as order_count, SUM(total_amount) as total_spent
FROM orders_stream
WINDOW TUMBLING (SIZE 1 HOUR)
GROUP BY user_id;

Schema Registry

Centralized schema management untuk memastikan producer dan consumer menggunakan format data yang konsisten. Mendukung Avro, Protobuf, dan JSON Schema. Tanpa Schema Registry, perubahan format data bisa memecah consumer secara tiba-tiba.

8. Best Practices untuk Microservices dengan Kafka

Partitioning Strategy

Gunakan message key yang tepat untuk memastikan ordering. Semua event untuk order yang sama harus masuk ke partition yang sama — maka gunakan order_id sebagai key. Jangan gunakan null key (akan di-round-robin, menghilangkan ordering guarantee).

Consumer Group Design

Setiap microservice harus punya consumer group sendiri. Hindari sharing consumer group antar service — ini membuat distribusi message tidak terduga. Jika butuh fan-out (satu event diproses banyak service), setiap service harus punya group ID unik.

Exactly-Once Semantics

Kafka mendukung exactly-once delivery melalui kombinasi idempotent producer dan transactional API. Untuk microservices, gunakan enable.idempotence=true di producer dan manual offset commit di consumer setelah proses berhasil.

Dead Letter Queue (DLQ)

Jika consumer gagal memproses event setelah N kali retry, kirim ke DLQ topic daripada memblokir seluruh consumer. Ini memastikan satu event yang bermasalah tidak menghentikan seluruh pipeline.

Monitoring Consumer Lag

Consumer lag (selisih antara offset terakhir di partition dan offset yang sudah diproses consumer) adalah metrik kunci. Jika lag terus naik, artinya consumer tidak bisa mengikuti throughput producer. Gunakan Kafka Lag Exporter dengan Prometheus dan Grafana untuk monitoring.

Retention Policy

Atur retention.ms sesuai kebutuhan. Default 7 hari. Untuk microservices yang butuh event replay jangka panjang, pertimbangkan menggunakan tiered storage (tersedia di Kafka 3.7+) untuk archive data lama ke S3/GCS dengan biaya lebih rendah.

9. Studi Kasus: E-Commerce dengan Kafka

Mari lihat bagaimana sebuah e-commerce membangun arsitektur microservices dengan Kafka sebagai backbone:

Alur satu transaksi: User checkout → OrderService publish OrderCreated → PaymentService proses payment → publish PaymentCompleted → InventoryService kurangi stok → NotificationService kirim email → AnalyticsService catat transaksi. Semua berjalan asynchronous, tidak ada service yang menunggu service lain.

10. FAQ

Jika Anda membangun stack backend yang mencakup caching dan real-time data, pertimbangkan juga membaca panduan Redis caching patterns untuk scalable web apps sebagai pelengkap arsitektur microservices ini.

Image Attribution

• Photo by Markus Spiske on Unsplash - Unsplash
• Photo by Growtika on Unsplash - Unsplash
• Photo by Samuel Angor on Unsplash - Unsplash
• Photo by Deng Xiang on Unsplash - Unsplash

Referensi

1. Apache Kafka Documentation — kafka.apache.org
2. Confluent Kafka Documentation — docs.confluent.io
3. LinkedIn Engineering Blog: Building Kafka — engineering.linkedin.com
4. Red Hat: What is Apache Kafka? — redhat.com
5. Debezium Documentation (CDC with Kafka) — debezium.io