Apache Kafka untuk Pemula - Streaming Data Real-Time dari Nol sampai Jalan

Pernahkah kamu bikin sistem yang harus ngirim notifikasi ke ribuan user secara real-time? Atau mau proses log dari banyak server tanpa bottleneck? Saya pertama kali ketemu Kafka saat ngolah data dari sensor IoT yang tembakannya gila-gila. Queue biasa kayak RabbitMQ kewalahan, pesan numpuk, consumer ngos-ngosan. Terus rekomendasinya: "Coba Kafka aja." Saya baca-baca, kelihatan ribet banget. Tapi setelah dicoba, ternyata konsepnya sederhana dan performanya gila.

Kalau kamu lagi nyari cara ngolah aliran data besar secara real-time, artikel ini buat kamu. Saya bakal jelasin Apache Kafka dari nol - mulai konsep dasar, instalasi lokal, sampai bikin producer-consumer yang beneran jalan. Praktis, langsung bisa kamu coba di laptop.

Apa Itu Apache Kafka?

Apache Kafka itu distributed event streaming platform. Dibuat pertama di LinkedIn tahun 2011, terus di-open-source-kan ke Apache Foundation. Intinya: Kafka itu kayak sistem messaging super cepat yang bisa simpan, baca, dan proses jutaan pesan per detik.

Beda sama queue tradisional (RabbitMQ, ActiveMQ), Kafka itu lebih ke append-only log. Setiap pesan yang masuk ditulis ke akhir file log (gak bisa di-edit atau dihapus langsung). Ini bikin Kafka super cepat karena sequential disk I/O jauh lebih ngebut daripada random access.

Kafka sekarang udah jadi standar industri buat event-driven architecture. Perusahaan kayak Netflix, Uber, Spotify, dan LinkedIn semuanya pakai Kafka buat ngolah data real-time mereka.

Konsep Inti yang Wajib Kamu Pahami

Sebelum mulai coding, kamu perlu ngerti 4 konsep utama Kafka. Ini penting banget karena nanti semua kode yang kamu tulis bakal ngacu ke konsep-konsep ini.

• Topic - kayak kategori atau folder. Pesan dikirim ke topic tertentu. Misal topic "user-signup", "payment-events", "sensor-data".
• Partition - topic dibagi ke beberapa partition supaya bisa diproses paralel. Setiap partition itu ordered log. Pesan dalam partition yang sama dijamin urut.
• Producer - aplikasi yang ngirim pesan ke Kafka topic. Producer nentuin pesan mau masuk partition mana (bisa round-robin atau by key).
• Consumer - aplikasi yang baca pesan dari topic. Consumer bisa jalan dalam group, dan setiap partition cuma dibaca oleh satu consumer dalam group yang sama.

Gampangnya: Producer ngirim pesan ke Topic. Topic dibagi jadi Partitions. Consumer baca dari Partitions. Kafka simpan pesannya di disk selama retention period yang kamu set (default 7 hari).

Install Kafka Lokal pakai Docker

Cara paling gampang buat mulai main-main sama Kafka itu pakai Docker. Kamu gak perlu download Kafka binary, set JAVA_HOME, atau konfigurasi Zookeeper manual. Cukup bikin docker-compose file kayak gini:

# docker-compose.yml
version: '3.8'

services:
 kafka:
 image: bitnami/kafka:3.7
 container_name: kafka-local
 ports:
 - "9092:9092"
 environment:
 # Kafka mode tanpa Zookeeper (KRaft mode)
 KAFKA_CFG_NODE_ID: "1"
 KAFKA_CFG_PROCESS_ROLES: "controller,broker"
 KAFKA_CFG_LISTENERS: "PLAINTEXT://:9092"
 KAFKA_CFG_ADVERTISED_LISTENERS: "PLAINTEXT://localhost:9092"
 KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: "CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT"
 KAFKA_CFG_CONTROLLER_QUORUM_VOTERS: "1@kafka:9093"
 KAFKA_CFG_CONTROLLER_LISTENER_NAMES: "CONTROLLER"
 KAFKA_KRAFT_CLUSTER_ID: "MkU3OEVBNTcwNTJENDM2Qk"
 volumes:
 - kafka_data:/bitnami/kafka

volumes:
 kafka_data:

Kenapa pakai Bitnami image? Karena udah pre-configured dan support KRaft mode (Kafka tanpa Zookeeper). Dulu Kafka butuh Zookeeper buat koordinasi cluster, tapi sejak Kafka 2.8+ kita bisa pakai KRaft mode yang lebih simpel.

Jalanin dengan command ini:

# Start Kafka
docker compose up -d

# Cek status
docker compose ps

# Masuk ke container buat eksplorasi
docker exec -it kafka-local /opt/bitnami/kafka/bin/kafka-topics.sh \
 --bootstrap-server localhost:9092 --list

Outputnya harusnya kosong karena kita belum bikin topic apa-apa. Aman, berarti Kafka udah jalan.

Bikin Topic Pertama Kamu

Topic di Kafka itu kayak bikin folder baru. Kamu tentuin nama, jumlah partition, dan replication factor. Untuk lokal, 1 partition dan replication factor 1 udah cukup:

# Bikin topic "test-events" dengan 1 partition
docker exec -it kafka-local /opt/bitnami/kafka/bin/kafka-topics.sh \
 --bootstrap-server localhost:9092 \
 --create \
 --topic test-events \
 --partitions 1 \
 --replication-factor 1

# Lihat detail topic
docker exec -it kafka-local /opt/bitnami/kafka/bin/kafka-topics.sh \
 --bootstrap-server localhost:9092 \
 --describe --topic test-events

Kalau berhasil, kamu bakal lihat output kayak gini:

Topic: test-events TopicId: xxxx PartitionCount: 1 ReplicationFactor: 1
 Topic: test-events Partition: 0 Leader: 1 Replicas: 1 Isr: 1

Bikin Producer pakai Python

Sekarang bagian serunya. Saya bakal bikin producer yang ngirim data dummy ke topic "test-events". Saya pakai Python dengan library kafka-python-ng (versi terbaru yang support Python 3.12).

# Install library
pip install kafka-python-ng

# producer.py
import json
import time
import random
from datetime import datetime
from kafka import KafkaProducer

# Buat koneksi ke Kafka
producer = KafkaProducer(
 bootstrap_servers=['localhost:9092'],
 value_serializer=lambda v: json.dumps(v).encode('utf-8'),
 key_serializer=lambda k: str(k).encode('utf-8'),
 acks='all', # tunggu semua replica confirm
 retries=3,
)

# Simulasi ngirim data sensor
sensor_ids = ['sensor-01', 'sensor-02', 'sensor-03']

print("Mulai ngirim data ke Kafka...")
for i in range(100):
 data = {
 'sensor_id': random.choice(sensor_ids),
 'temperature': round(random.uniform(25.0, 35.0), 2),
 'humidity': round(random.uniform(60.0, 90.0), 2),
 'timestamp': datetime.now().isoformat()
 }
 
 # Kirim ke topic, pakai sensor_id sebagai key
 # Kafka bakal pastikan pesan dengan key yang sama masuk partition yang sama
 future = producer.send(
 'test-events',
 key=data['sensor_id'],
 value=data
 )
 
 # Tunggu konfirmasi (opsional, untuk demo)
 result = future.get(timeout=10)
 print(f"Sent #{i+1}: {data['sensor_id']} -> partition {result.partition}")
 
 time.sleep(0.5)

producer.flush()
producer.close()
print("Selesai!")

Beberapa hal penting di kode di atas:

• value_serializer - konversi Python dict ke JSON bytes. Kafka cuma ngerti bytes, jadi kamu harus serialize sendiri.
• key - Kafka pakai key buat nentuin partition. Pesan dengan key yang sama selalu masuk partition yang sama, jadi urutannya terjaga per key.
• acks='all' - producer nunggu semua replica ngomong "udah tersimpan" sebelum ngirim pesan berikutnya. Paling aman tapi sedikit lebih lambat.
• future.get(timeout=10) - nunggu konfirmasi dari broker. Kalau di production, kamu bisa skip ini untuk performa maksimal (fire and forget).

Bikin Consumer pakai Python

Consumer itu aplikasi yang baca pesan dari Kafka. Bisa jalan di proses yang beda, server yang beda, bahkan bahasa pemrograman yang beda. Ini consumer yang baca data sensor tadi:

# consumer.py
import json
from kafka import KafkaConsumer

consumer = KafkaConsumer(
 'test-events',
 bootstrap_servers=['localhost:9092'],
 auto_offset_reset='earliest', # baca dari pesan paling lama
 enable_auto_commit=True,
 group_id='sensor-processor-group',
 value_deserializer=lambda x: json.loads(x.decode('utf-8')),
 key_deserializer=lambda x: x.decode('utf-8') if x else None,
)

print("Menunggu pesan dari Kafka...")
print("Tekan Ctrl+C untuk berhenti\n")

for message in consumer:
 data = message.value
 print(f"[Partition {message.partition}] "
 f"Key: {message.key} | "
 f"Temp: {data['temperature']}C | "
 f"Humidity: {data['humidity']}% | "
 f"Time: {data['timestamp']}")

Jalanin consumer dan producer di terminal yang berbeda:

# Terminal 1 - jalanin consumer dulu
python consumer.py

# Terminal 2 - jalanin producer
python producer.py

Kamu bakal lihat consumer menerima data secara real-time. Setengah detik sekali, persis kayak yang kita set di time.sleep(0.5) di producer.

Consumer Group dan Scaling

Salah satu fitur Kafka yang paling powerful itu consumer group. Kalau kamu jalanin 3 instance consumer dengan group_id yang sama, Kafka bakal otomatis bagi-bagi partition ke masing-masing consumer. Gak ada pesan yang diproses dobel.

Tapi ingat: jumlah consumer dalam satu group gak boleh lebih dari jumlah partition. Kalau kamu punya 3 partition dan jalanin 5 consumer, 2 consumer bakal idle (gak dapet kerjaan).

# Jalanin 3 consumer sekaligus (simulasi scaling)
for i in 1 2 3; do
 KAFKA_CONSUMER_ID=worker-$i python consumer.py &
done

Ini fitur yang bikin Kafka cocok buat scale out. Kamu tinggal tambah consumer kalau load naik, dan Kafka bakal otomatis rebalance.

Kafka di Production: Yang Perlu Kamu Tahu

Main-main di lokal gampang. Tapi pas mau production, ada beberapa hal yang wajib kamu perhatikan:

1. Retention Policy - Kafka simpan pesan di disk selama yang kamu set. Default 7 hari. Kalau disk penuh, Kafka bakal stop terima pesan baru. Set retention berdasarkan kebutuhan:

# Set retention 24 jam (dalam ms)
docker exec -it kafka-local /opt/bitnami/kafka/bin/kafka-configs.sh \
 --bootstrap-server localhost:9092 \
 --entity-type topics --entity-name test-events \
 --alter --add-config retention.ms=86400000

2. Monitoring - di production, kamu butuh monitoring. Kafka Manager (CMAK), Kafka UI (provectus/kafka-ui), atau Confluent Control Center. Yang gratis dan gampang setup itu provectus/kafka-ui:

# Tambahkan ke docker-compose.yml
 kafka-ui:
 image: provectuslabs/kafka-ui:latest
 ports:
 - "8080:8080"
 environment:
 KAFKA_CLUSTERS_0_NAME: "local"
 KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: "kafka:9092"
 depends_on:
 - kafka

Buka http://localhost:8080 dan kamu bisa lihat semua topic, partition, consumer group, sama message viewer yang interaktif.

3. Managed Kafka - kalau kamu gak mau repot manage Kafka sendiri, ada beberapa pilihan managed service. Confluent Cloud punya free tier yang lumayan buat mulai. AWS MSK (Managed Streaming for Kafka) bagus kalau kamu udah di AWS ecosystem. Azure Event Hubs juga compatible dengan Kafka protocol, jadi kode kamu gak perlu diubah.

4. Security - di production, wajib kasih SSL/TLS encryption dan SASL authentication. Topic-level ACL (Access Control List) buat batasin producer/consumer mana yang boleh akses topic tertentu.

Use Case Kafka yang Sering Ketemu

Beberapa skenario di mana Kafka bikin hidup kamu lebih gampang:

• Log Aggregation - kumpulin log dari banyak microservice ke satu Kafka topic, terus kirim ke Elasticsearch atau S3 buat diarsipin.
• Event Sourcing - simpan semua state change sebagai event di Kafka. Replay event kapan aja buat rebuild state.
• Real-time Analytics - stream click event atau page view ke Kafka, proses dengan Kafka Streams atau Apache Flink, tampilkan di dashboard real-time.
• CDC (Change Data Capture) - pakai Debezium buat capture perubahan database (insert/update/delete) dan stream ke Kafka. Microservice lain bisa subscribe ke perubahan ini buat sinkronisasi data.
• Notification Pipeline - semua event yang butuh notifikasi (signup, payment, order) dikirim ke topic "notifications". Consumer yang beda nangani email, push notification, dan SMS secara paralel.

Tips Performance buat Kafka Producer/Consumer

Beberapa hal yang saya pelajarin dari trial-and-error (kadang dari production incident):

• Batching - producer punya linger.ms (default 0). Set ke 5-10ms biar producer numpuk pesan dulu sebelum dikirim. Naikin throughput tanpa nambah latency yang signifikan.
• Compression - set compression_type='snappy' atau 'lz4' di producer. Sangat efektif kalau pesan kamu JSON atau text yang repetitive.
• Prefetch - consumer punya fetch.min.bytes (default 1). Set ke 10KB-1MB biar consumer fetch batch besar sekaligus, kurangi round-trip ke broker.
• Idempotent Producer - set enable_idempotence=True. Kafka bakal pastikan pesan gak dobel walau producer retry. Penting banget buat payment atau order processing.
• Schema Registry - kalau kamu pakai Avro atau Protobuf, pakai Confluent Schema Registry. Ini jaga schema compatibility, jadi consumer gak crash kalau producer nambah field baru.

Kesimpulan

Apache Kafka itu bukan sihir. Konsep dasarnya simpel: producer ngirim pesan ke topic, topic dibagi ke partition, consumer baca dari partition. Yang bikin Kafka powerful itu arsitekturnya - sequential disk I/O, replication, dan consumer group scaling.

Kalau kamu baru mulai, pakai docker-compose di atas, bikin topic, coba producer-consumer Python, dan rasain sendiri kayak apa real-time data streaming. Setelah itu, eksplor Kafka Streams buat proses data di dalam Kafka sendiri, atau coba Debezium buat CDC dari database kamu.

Oh ya, kalau kamu udah pernah main sama Kafka atau punya use case seru, ceritain dong di kolom komentar. Saya pengen tau kasus lain di mana Kafka bikin hidup lebih gampang (atau lebih susah, hehe).