Cara Install Apache Kafka di VPS Ubuntu

Pengantar

Apache Kafka merupakan platform yang digunakan untuk mengelola dan memproses aliran data secara real-time. Kafka banyak digunakan pada aplikasi yang membutuhkan pertukaran data dalam jumlah besar, seperti sistem monitoring, aplikasi keuangan, layanan notifikasi, hingga arsitektur microservices.

Berbeda dengan database yang umumnya digunakan untuk menyimpan dan mengambil data, Kafka berfungsi sebagai message broker dan event streaming platform. Data dari satu aplikasi dapat dikirim ke Kafka, kemudian aplikasi lain dapat mengambil dan memproses data tersebut sesuai kebutuhan.

Menjalankan Apache Kafka di VPS Ubuntu dapat menjadi pilihan praktis untuk kebutuhan development, testing, maupun layanan internal. Dengan VPS, Kafka dapat berjalan pada server yang dapat diakses oleh aplikasi lain melalui jaringan.

Pada artikel ini, kita akan membahas cara install Apache Kafka di VPS Ubuntu secara bertahap, mulai dari persiapan server, instalasi Java, konfigurasi Kafka, menjalankan service, hingga melakukan pengujian sederhana.

Persiapan VPS Ubuntu

Sebelum melakukan instalasi Apache Kafka, pastikan VPS sudah memenuhi spesifikasi berikut :

OS: Ubuntu 24.04 LTS
CPU: 2 vCPU
RAM: 4 GB
Storage: 40 GB
Akses: SSH
User: root atau user dengan akses sudo

Untuk kebutuhan production, spesifikasi server sebaiknya disesuaikan dengan jumlah message, jumlah producer dan consumer, retention data, serta kebutuhan throughput.

Membuat User Kafka

Membuat User Kafka
Sebelum memulai instalasi, siapkan VPS Ubuntu 24.04 yang dapat diakses melalui SSH.
- Buat user khusus untuk menjalankan Kafka:
```
sudo adduser kafka
```
- Masuk menggunakan user tersebut:
```
su - kafka
```
  Catatan:
  Kafka sebaiknya tidak dijalankan menggunakan user root. User kafka tidak harus memiliki akses sudo. Perintah yang membutuhkan hak administrator dapat dijalankan menggunakan user yang memiliki akses sudo.

Install Java 17

Install OpenJDK 17
Apache Kafka membutuhkan Java untuk menjalankan broker. Pada tutorial ini digunakan OpenJDK 17. Jika menggunakan user kafka tanpa akses sudo, kembali ke user administrator terlebih dahulu.
- Update repository Ubuntu:
```
sudo apt update
```
- Install OpenJDK 17:
```
sudo apt install openjdk-17-jdk -y
```
- Periksa versi Java:
```
java -version
```
  Contoh hasil:
```
openjdk version "17.x.x"
```
- Periksa lokasi Java:
```
readlink -f $(which java)
```
  Pada Ubuntu 24.04, lokasi Java 17 umumnya:
```
/usr/lib/jvm/java-17-openjdk-amd64
```
  Lokasi tersebut akan digunakan sebagai nilai JAVA_HOME.

Download Apache Kafka

Download dan Ekstrak Apache Kafka
- Masuk kembali menggunakan user kafka:
```
su - kafka
```
- Masuk ke home directory:
```
cd ~
```
- Download Apache Kafka 4.1.2:
```
wget https://archive.apache.org/dist/kafka/4.1.2/kafka_2.13-4.1.2.tgz
```
- Ekstrak file yang sudah diunduh:
```
tar -xzf kafka_2.13-4.1.2.tgz
```
- Ubah nama direktori agar lebih mudah digunakan:
```
mv kafka_2.13-4.1.2 kafka
```
- Kafka sekarang berada di:
```
/home/kafka/kafka
```
- Masuk ke direktori Kafka:
```
cd ~/kafka
```

Konfigurasi Environment Kafka

Konfigurasi Environment Kafka
Tambahkan JAVA_HOME dan KAFKA_HOME ke environment user Kafka.
- Edit file .bashrc:
```
nano ~/.bashrc
```
- Tambahkan konfigurasi berikut:
```
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
export KAFKA_HOME=/home/kafka/kafka
export PATH=$PATH:$KAFKA_HOME/bin
```
- Terapkan konfigurasi:
```
source ~/.bashrc
```
- Periksa versi Kafka:
```
kafka-topics.sh --version
```
  Jika berhasil, hasilnya:
```
4.1.2
```

Konfigurasi Kafka Menggunakan KRaft

Inisialisasi Storage Kafka dengan KRaft
Kafka versi modern dapat menggunakan KRaft untuk mengelola metadata tanpa membutuhkan Apache ZooKeeper. Untuk kebutuhan pembelajaran menggunakan satu VPS, Kafka dapat dijalankan dalam mode standalone.
- Masuk ke direktori Kafka:
```
cd ~/kafka
```
- Buat Cluster ID:
```
KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"
```
- Tampilkan Cluster ID:
```
echo $KAFKA_CLUSTER_ID
```
  Contoh hasil:
```
rswFi7XDSTKv6FpRfx_6IQ
```
  Nilai Cluster ID dapat berbeda pada setiap instalasi.
- Selanjutnya, format storage Kafka:
```
bin/kafka-storage.sh format \
  --standalone \
  -t $KAFKA_CLUSTER_ID \
  -c config/server.properties
```
  Jika berhasil, akan muncul pesan seperti:
```
Formatting dynamic metadata voter directory /tmp/kraft-combined-logs with metadata.version 4.1-IV1.
```
  Pada tahap ini, storage Kafka untuk mode KRaft sudah berhasil diinisialisasi.

Membuat Kafka sebagai Service systemd

Menjalankan Kafka sebagai Service systemd
Menjalankan Kafka secara manual kurang praktis pada server karena prosesnya bergantung pada terminal yang digunakan. Agar Kafka dapat berjalan otomatis, buat service systemd.
- Buat file service:
```
sudo nano /etc/systemd/system/kafka.service
```
- Masukkan konfigurasi berikut:
```
[Unit]
Description=Apache Kafka Server
After=network.target

[Service]
Type=simple
User=kafka
Group=kafka

Environment="JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64"
Environment="KAFKA_HOME=/home/kafka/kafka"

ExecStart=/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/server.properties
ExecStop=/home/kafka/kafka/bin/kafka-server-stop.sh

Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
```
- Simpan file tersebut, kemudian reload konfigurasi systemd:
```
sudo systemctl daemon-reload
```
- Aktifkan Kafka agar otomatis berjalan saat VPS melakukan boot:
```
sudo systemctl enable kafka
```
- Jalankan service Kafka:
```
sudo systemctl start kafka
```
- Atau langsung aktifkan dan jalankan dengan:
```
sudo systemctl enable --now kafka
```
- Periksa status Kafka:
```
sudo systemctl status kafka
```
  Jika berhasil, status akan menunjukkan:
```
Active: active (running)
```
- Periksa apakah Kafka sudah diaktifkan untuk startup otomatis:
```
sudo systemctl is-enabled kafka
```
  Hasil yang diharapkan:
```
enabled
```
  Dengan konfigurasi tersebut, Kafka sekarang berjalan sebagai service systemd dan tidak perlu dijalankan secara manual menggunakan perintah:
```
bin/kafka-server-start.sh config/server.properties
```

Membuat Topic Kafk

Membuat Topic Kafka
Setelah Kafka berjalan sebagai service, buat topic untuk melakukan pengujian.
- Masuk ke direktori Kafka:
```
cd ~/kafka
```
- Buat topic bernama tutorial-topic:
```
bin/kafka-topics.sh \
  --create \
  --topic tutorial-topic \
  --bootstrap-server localhost:9092
```
  Jika berhasil, akan muncul:
```
Created topic tutorial-topic.
```
- Untuk melihat daftar topic:
```
bin/kafka-topics.sh \
  --list \
  --bootstrap-server localhost:9092
```
  Hasil yang diharapkan:
```
tutorial-topic
```
  Topic tersebut nantinya digunakan sebagai tempat producer mengirim pesan dan consumer membaca pesan.

Menguji Producer dan Consumer

Menguji Producer dan Consumer
Setelah broker dan topic tersedia, langkah berikutnya adalah menguji komunikasi antara producer dan consumer.

Secara sederhana, producer bertugas mengirim pesan ke Kafka broker. Pesan tersebut kemudian disimpan pada topic tutorial-topic dan dapat dibaca oleh consumer.

Karena Kafka sudah berjalan menggunakan systemd, kita tidak perlu menjalankan broker dari terminal lagi. Cukup buka dua terminal SSH tambahan, yaitu satu terminal untuk producer dan satu terminal untuk consumer.

Gambar 1. Topologi pengujian producer dan consumer pada Apache Kafka

Pada pengujian ini, producer akan mengirimkan pesan ke topic tutorial-topic. Kafka broker kemudian menyimpan pesan tersebut, sedangkan consumer membaca pesan dari topic dan menampilkannya pada terminal.
Menjalankan Consumer
Buka terminal pertama, kemudian masuk sebagai user kafka:
```
su - kafka
cd ~/kafka
```
Jalankan consumer:
```
bin/kafka-console-consumer.sh \
  --topic tutorial-topic \
  --bootstrap-server localhost:9092
```
Setelah perintah dijalankan, terminal akan menunggu pesan.

Catatan:
Biarkan terminal consumer tetap terbuka.
Menjalankan Producer
Buka terminal SSH kedua, kemudian masuk sebagai user kafka:
```
su - kafka
cd ~/kafka
```
Jalankan producer:
```
bin/kafka-console-producer.sh --topic tutorial-topic --bootstrap-server localhost:9092
```
Masukkan beberapa pesan, misalnya:
```
Halo Kafka
Ini pesan pertama
Kafka berjalan di VPS Ubuntu
```
Setiap kali menekan Enter, pesan akan dikirim ke topic tutorial-topic.

Kembali ke terminal consumer. Pesan yang dikirim melalui producer akan muncul secara otomatis:
```
Halo Kafka
Ini pesan pertama
Kafka berjalan di VPS Ubuntu
```
Jika pesan berhasil muncul pada terminal consumer, berarti pengujian Kafka sudah berhasil. Producer dapat mengirim pesan ke broker, Kafka menyimpan pesan pada topic, dan consumer dapat membaca pesan tersebut.

Membaca Pesan dari Awal

Membaca Pesan dari Awal
Kafka menyimpan pesan berdasarkan konfigurasi retention. Jika ingin membaca pesan yang sudah ada sebelumnya, gunakan opsi from-beginning.
```
bin/kafka-console-consumer.sh \
  --topic tutorial-topic \
  --from-beginning \
  --bootstrap-server localhost:9092
```
Dengan opsi tersebut, consumer akan membaca pesan yang tersedia mulai dari awal offset yang dapat dibaca.

Jika hanya ingin menerima pesan baru, jalankan consumer tanpa opsi from-beginning:
```
bin/kafka-console-consumer.sh \
  --topic tutorial-topic \
  --bootstrap-server localhost:9092
```

Membersihkan Data Pengujian

Menghapus dan Membuat Ulang Topic
Ketika melakukan banyak pengujian, topic dapat berisi berbagai pesan percobaan. Untuk memulai pengujian dari kondisi kosong, topic dapat dihapus kemudian dibuat kembali.
- Pertama, hentikan producer dan consumer dengan menekan:
```
Ctrl+C
```
- Kemudian hapus topic:
```
bin/kafka-topics.sh \
  --delete \
  --topic tutorial-topic \
  --bootstrap-server localhost:9092
```
- Periksa daftar topic:
```
bin/kafka-topics.sh \
  --list \
  --bootstrap-server localhost:9092
```
- Jika tutorial-topic sudah tidak muncul, buat kembali:
```
bin/kafka-topics.sh \
  --create \
  --topic tutorial-topic \
  --bootstrap-server localhost:9092
```
  Topic sekarang dapat digunakan kembali untuk pengujian baru.

Kesimpulan

Instalasi Apache Kafka di VPS Ubuntu dapat dilakukan menggunakan Java 17 dan mode KRaft tanpa membutuhkan Apache ZooKeeper.

Pada tutorial ini, Apache Kafka 4.1.2 berhasil dijalankan pada Ubuntu 24.04 menggunakan user khusus kafka. Kafka juga dikonfigurasi sebagai service systemd agar berjalan di background dan otomatis aktif setelah VPS melakukan restart.

Pengujian dilakukan dengan membuat topic tutorial-topic, kemudian menjalankan producer dan consumer pada dua terminal berbeda. Producer mengirimkan pesan ke Kafka, sedangkan consumer membaca pesan dari topic tersebut.

Dengan konfigurasi ini, VPS sudah memiliki Kafka broker yang dapat digunakan untuk mempelajari konsep lanjutan seperti topic, partition, offset, consumer group, retention, dan integrasi Kafka dengan aplikasi.