# Apache Kafka untuk Programmer Pemula: Kenapa Industri Membutuhkannya?

Ketika mulai masuk ke dunia industri, kamu akan sering mendengar istilah seperti *event streaming*, *real-time processing*, atau *data pipeline*. Salah satu teknologi yang sangat sering muncul dalam konteks ini adalah **Apache Kafka**.

Banyak pemula bingung:

> “Kenapa tidak cukup pakai database saja?” “Kenapa harus pakai Kafka yang terlihat kompleks?”

Artikel ini akan menjawab itu secara bertahap—dari masalah nyata sampai alasan kenapa Kafka digunakan di sistem skala besar.

* * *

## Masalah di Dunia Nyata (Yang Tidak Terlihat Saat Belajar)

Bayangkan kamu membangun aplikasi seperti:

*   E-commerce
    
*   Fintech
    
*   Aplikasi tracking user
    

Setiap detik bisa terjadi:

*   Ribuan transaksi
    
*   Ribuan klik user
    
*   Banyak service saling komunikasi
    

Kalau semua langsung ditangani secara synchronous:

```text
User → Server → Database → Response
```

Masalahnya:

*   Sistem cepat overload
    
*   Sulit scale
    
*   Data sulit dilacak
    
*   Tidak bisa diproses ulang
    

* * *

## Solusi Lama: Message Queue (RabbitMQ)

Salah satu solusi adalah menggunakan queue:

```text
Producer → Queue → Consumer
```

Ini bagus untuk:

*   Task async (email, payment, dll)
    
*   Mengurangi beban sistem
    

Tapi ada keterbatasan:

*   Data biasanya hilang setelah diproses
    
*   Tidak bisa “diputar ulang”
    
*   Kurang cocok untuk analisis data besar
    

* * *

## Masuk Kafka: Cara Berpikir yang Berbeda

Kafka bukan sekadar queue. Kafka adalah:

> **Sistem log terdistribusi untuk menyimpan dan memproses event secara real-time**

Alih-alih “mengirim tugas”, Kafka menyimpan **riwayat kejadian (event history)**.

* * *

## Analogi Sederhana

### RabbitMQ

Seperti:

```text
Kirim paket → diterima → selesai
```

* * *

### Kafka

Seperti:

```text
Semua aktivitas direkam seperti CCTV
→ bisa ditonton ulang kapan saja
```

* * *

## Konsep Inti Kafka

### 1\. Producer

Pengirim data

Contoh:

```text
User klik → kirim event
```

* * *

### 2\. Topic

Tempat data disimpan

```text
topic: user_activity
```

* * *

### 3\. Consumer

Pembaca data

```text
Analytics Service membaca data
```

* * *

### 4\. Offset

Penanda posisi baca

```text
Consumer bisa lanjut dari posisi terakhir
```

* * *

## Cara Kerja Kafka (Flow)

```text
Producer → Topic (disimpan) → Consumer membaca
```

Berbeda dengan queue:

*   Data tidak hilang
    
*   Bisa dibaca berkali-kali
    
*   Bisa diproses oleh banyak consumer
    

* * *

## Kenapa Kafka Dibutuhkan?

### 1\. Menyimpan Event (Bukan Sekadar Kirim)

Semua kejadian disimpan:

```text
User login
User beli barang
User klik tombol
```

Ini penting untuk:

*   audit
    
*   tracking
    
*   debugging
    

* * *

### 2\. Bisa Replay Data

Misalnya:

*   Ada bug di sistem analytics
    
*   Kamu ingin hitung ulang data
    

Dengan Kafka:

```text
→ tinggal baca ulang dari awal
```

* * *

### 3\. Skalabilitas Tinggi

Kafka didesain untuk:

*   jutaan event per detik
    
*   distributed system
    

* * *

### 4\. Banyak Consumer Sekaligus

Satu event bisa dipakai banyak service:

```text
User beli barang
→ Analytics
→ Recommendation system
→ Fraud detection
→ Notification
```

Tanpa Kafka:

*   harus kirim satu per satu
    
*   jadi kompleks
    

Dengan Kafka:

*   cukup publish sekali
    

* * *

### 5\. Decoupling (Tidak Saling Bergantung)

Service tidak perlu tahu siapa yang membaca data

```text
Producer tidak peduli consumer siapa saja
```

* * *

## Contoh Real Case

### E-commerce Tracking

```text
User membuka produk
→ event masuk Kafka
→ dipakai oleh:
   - analytics
   - rekomendasi produk
   - marketing
```

* * *

### Fintech

```text
Transaksi terjadi
→ masuk Kafka
→ dipakai oleh:
   - ledger
   - fraud detection
   - reporting
```

* * *

## Perbedaan Mindset (Penting!)

### Tanpa Kafka

```text
"Ambil data dari database"
```

* * *

### Dengan Kafka

```text
"Dengarkan event yang terjadi"
```

* * *

## Contoh Sederhana (Pseudo Code)

### Producer

```js
producer.send({
  topic: "orders",
  messages: [{ value: "order-123" }]
});
```

* * *

### Consumer

```js
consumer.subscribe({ topic: "orders" });

consumer.run({
  eachMessage: async ({ message }) => {
    console.log(message.value.toString());
  }
});
```

* * *

## Kapan Harus Pakai Kafka?

Gunakan Kafka jika:

*   Butuh real-time processing
    
*   Data harus disimpan & bisa diulang
    
*   Sistem besar (microservices)
    
*   Banyak consumer
    

* * *

## Kapan Tidak Perlu Kafka?

Jangan gunakan Kafka jika:

*   Aplikasi masih kecil
    
*   Hanya butuh task async sederhana
    
*   Belum paham konsep dasar async
    

Gunakan:

*   langsung API
    
*   atau RabbitMQ
    

* * *

## Roadmap Belajar Kafka

### Step 1

Pahami:

```text
producer → topic → consumer
```

* * *

### Step 2

Belajar:

*   event-driven architecture
    
*   perbedaan queue vs log
    

* * *

### Step 3

Coba:

*   kirim event sederhana
    
*   baca event
    

* * *

### Step 4

Lanjut:

*   partition
    
*   offset
    
*   consumer group
    

* * *

## Penutup

Kafka bukan sekadar teknologi, tapi perubahan cara berpikir:

*   Dari request → response
    
*   Menjadi event → stream
    
*   Dari data sekarang
    
*   Menjadi sejarah data
    

Kalau kamu memahami ini, kamu sudah mulai masuk ke level arsitektur industri.

* * *

## Langkah Selanjutnya

Kalau kamu ingin benar-benar siap kerja:

*   Praktikkan Kafka secara langsung
    
*   Bandingkan dengan RabbitMQ
    
*   Bangun mini project event-driven
    

Dan ingat:

> Industri tidak mencari yang tahu semuanya, tapi yang paham konsep dengan benar.

* * *

Sumber: AI