Kafka Topic Advanced: Cara Mengirim Pesan Besar di Apache Kafka

Cara Mengirim Pesan Besar di Apache Kafka

Apache Kafka memiliki batas ukuran pesan default sebesar 1MB per pesan dalam topik. Batas ini diterapkan karena pesan yang sangat besar dianggap tidak efisien dan merupakan anti-pattern dalam desain Kafka. Namun, dalam beberapa kasus, Anda mungkin perlu mengirim pesan yang lebih besar dari batas ini, seperti file video atau data berukuran besar lainnya. Artikel ini akan menjelaskan dua pendekatan untuk menangani pesan besar di Kafka: menggunakan penyimpanan eksternal untuk pesan berukuran sangat besar (GB) dan mengubah konfigurasi untuk pesan yang sedikit lebih besar (misalnya, hingga 10MB). Kami juga akan memberikan langkah-langkah praktis untuk mengonfigurasi topik, broker, produser, dan konsumer, serta praktik terbaik untuk memastikan pengiriman yang andal.

Pendekatan untuk Mengirim Pesan Besar

Kafka menawarkan dua pendekatan utama untuk menangani pesan besar:

Pendekatan 1: Menggunakan Penyimpanan Eksternal (Pesan Berukuran GB)

  • Deskripsi: Alih-alih mengirim pesan besar langsung melalui Kafka, simpan pesan tersebut di penyimpanan eksternal (misalnya, Amazon S3, HDFS, atau sistem penyimpanan file jaringan) dan kirimkan hanya referensi (misalnya, URL atau ID file) melalui Kafka.

  • Keuntungan:

    • Mengurangi beban pada klaster Kafka karena hanya metadata kecil yang dikirim.

    • Mendukung pesan berukuran sangat besar (GB atau lebih) tanpa memengaruhi performa Kafka.

    • Skalabel untuk aplikasi yang menangani file besar, seperti video atau dataset.

  • Kekurangan:

    • Membutuhkan logika tambahan di sisi produser dan konsumer untuk mengelola penyimpanan eksternal.

    • Tidak ada pustaka bawaan untuk pendekatan ini, sehingga Anda perlu mengembangkan solusi kustom.

  • Kasus Penggunaan: File media besar (video, audio), dataset ilmiah, atau file log besar.

  • Implementasi:

    • Produser: Unggah file besar ke penyimpanan eksternal (misalnya, Amazon S3) dan kirim referensi (misalnya, URL S3) sebagai pesan Kafka.

    • Konsumer: Baca referensi dari Kafka, lalu ambil file dari penyimpanan eksternal menggunakan referensi tersebut.

    • Contoh: Untuk file video, produser mengunggah video ke S3 dan mengirimkan pesan Kafka dengan format { "file_id": "video123", "s3_url": "s3://bucket/video123.mp4" }.

  • Catatan: Pastikan penyimpanan eksternal memiliki latensi rendah dan ketahanan tinggi untuk mendukung kebutuhan aplikasi Anda.

Pendekatan 2: Mengirim Pesan Besar Langsung ke Kafka (Misalnya, <10MB)

  • Deskripsi: Tingkatkan batas ukuran pesan pada topik, broker, produser, dan konsumer untuk mengizinkan pesan yang lebih besar dari 1MB, tetapi tetap dalam batas wajar (misalnya, hingga 10MB).

  • Keuntungan:

    • Tidak memerlukan penyimpanan eksternal, sehingga lebih sederhana untuk diimplementasikan.

    • Cocok untuk pesan yang sedikit lebih besar dari default, tetapi tidak terlalu besar.

  • Kekurangan:

    • Meningkatkan ukuran pesan dapat memengaruhi performa klaster, seperti latensi dan penggunaan memori.

    • Membutuhkan konfigurasi yang konsisten di semua komponen (broker, topik, produser, konsumer) untuk menghindari kegagalan.

  • Kasus Penggunaan: Data JSON besar, file log sedang, atau dokumen dengan ukuran beberapa MB.

Konfigurasi untuk Pendekatan 2: Mengirim Pesan Besar Langsung ke Kafka

Untuk mengirim pesan hingga 10MB, Anda perlu mengubah konfigurasi pada topik, broker, produser, dan konsumer. Berikut adalah langkah-langkahnya:

Prasyarat

  • Pastikan klaster Kafka berjalan (mode Zookeeper atau KRaft).

  • Gunakan ekstensi CLI yang sesuai: .sh untuk Linux/Mac, .bat untuk Windows.

  • Pastikan broker Kafka aktif di localhost:9092 (atau alamat lain sesuai konfigurasi Anda).

Langkah-langkah Konfigurasi

1. Sisi Broker

  • Rekomendasi: Pertahankan batas ukuran pesan default di level broker (message.max.bytes=1000000) dan hanya timpa di level topik untuk fleksibilitas.

  • Parameter Penting:

    • Broker: message.max.bytes (default: 1MB, menentukan ukuran maksimum pesan yang diterima broker).

    • Topik: max.message.bytes (default: 1MB, menentukan ukuran maksimum pesan per topik).

    • Broker: replica.fetch.max.bytes (default: 1MB, menentukan ukuran maksimum data yang diambil oleh replika selama replikasi).

a. Buat Topik

Buat topik bernama large-message dengan 3 partisi dan faktor replikasi 1:

kafka-topics.sh --bootstrap-server localhost:9092 --create --topic large-message \
--partitions 3 --replication-factor 1

b. Atur Ukuran Maksimum Pesan pada Topik

Atur max.message.bytes ke 10MB (10485880 bytes) untuk topik large-message:

kafka-configs.sh --bootstrap-server localhost:9092 \
--alter --entity-type topics \
--entity-name large-message \
--add-config max.message.bytes=10485880

c. Atur Ukuran Maksimum Replikasi

Atur replica.fetch.max.bytes ke 10MB di file konfigurasi broker (server.properties):

replica.fetch.max.bytes=10485880

  • Catatan: Perubahan ini memerlukan restart broker:

    kafka-server-stop.sh
kafka-server-start.sh config/server.properties

  • Peringatan: Pastikan replica.fetch.max.bytes setidaknya sama besar atau lebih besar dari max.message.bytes untuk mencegah kegagalan replikasi.

d. Verifikasi Konfigurasi Topik

Periksa konfigurasi topik:

kafka-topics.sh --bootstrap-server localhost:9092 --describe --topic large-message

Contoh keluaran:

Topic: large-message TopicId: XYZ123 PartitionCount: 3 ReplicationFactor: 1 Configs: max.message.bytes=10485880
Topic: large-message Partition: 0 Leader: 1 Replicas: 1 Isr: 1
Topic: large-message Partition: 1 Leader: 2 Replicas: 2 Isr: 2
Topic: large-message Partition: 2 Leader: 3 Replicas: 3 Isr: 3

2. Sisi Konsumer

  • Parameter Penting: max.partition.fetch.bytes (default: 1MB, menentukan ukuran maksimum data yang diambil konsumer per partisi per permintaan).

  • Peringatan: Jika max.partition.fetch.bytes lebih kecil dari max.message.bytes, konsumer akan gagal mengambil pesan besar dan terhenti (stuck), yang sangat tidak diinginkan.

a. Konfigurasi Konsumer Konsol

Atur max.partition.fetch.bytes ke 10MB saat menjalankan konsumer konsol:

kafka-console-consumer.sh --bootstrap-server localhost:9092 \
--topic large-message \
--from-beginning \
--consumer-property max.partition.fetch.bytes=10485880

b. Konfigurasi Konsumer dalam Kode (Java)

Tambahkan properti ke konfigurasi konsumer:

properties.setProperty(ConsumerConfig.FETCH_MAX_BYTES_CONFIG, "10485880");

3. Sisi Produser

  • Parameter Penting: max.request.size (default: 1MB, menentukan ukuran maksimum permintaan yang dikirim oleh produser).

  • Peringatan: Jika max.request.size lebih kecil dari ukuran pesan, produser tidak dapat mengirim pesan besar.

a. Konfigurasi Produser Konsol

Atur max.request.size ke 10MB saat menjalankan produser konsol:

kafka-console-producer.sh --bootstrap-server localhost:9092 \
--topic large-message \
--producer-property max.request.size=10485880

b. Konfigurasi Produser dalam Kode (Java)

Tambahkan properti ke konfigurasi produser:

properties.setProperty(ProducerConfig.MAX_REQUEST_SIZE_CONFIG, "10485880");

4. Uji Pengiriman Pesan

  • Gunakan produser konsol untuk mengirim pesan besar (misalnya, file teks berukuran hingga 10MB).

  • Gunakan konsumer konsol untuk memverifikasi bahwa pesan diterima dengan benar.

  • Pantau log broker untuk mendeteksi kesalahan terkait ukuran pesan atau replikasi.

Catatan Penting

  • Konsistensi Konfigurasi: Pastikan max.message.bytes (topik), replica.fetch.max.bytes (broker), max.partition.fetch.bytes (konsumer), dan max.request.size (produser) semuanya disetel ke nilai yang sama atau lebih besar dari ukuran pesan maksimum (misalnya, 10485880 untuk 10MB).

  • Restart Broker: Perubahan replica.fetch.max.bytes memerlukan restart broker, yang dapat menyebabkan downtime sementara. Rencanakan dengan hati-hati di lingkungan produksi.

  • Batas Wajar: Hindari mengatur ukuran pesan terlalu besar (misalnya, >50MB) karena dapat menyebabkan masalah performa, seperti peningkatan latensi dan penggunaan memori.

Praktik Terbaik

  1. Gunakan Penyimpanan Eksternal untuk Pesan Sangat Besar:

    • Untuk pesan berukuran GB (misalnya, file video), gunakan pendekatan penyimpanan eksternal (Amazon S3, HDFS) untuk efisiensi dan skalabilitas.

    • Kembangkan produser dan konsumer kustom untuk menangani referensi penyimpanan eksternal.

  2. Batasi Ukuran Pesan di Kafka:

    • Untuk pesan yang sedikit lebih besar dari 1MB (misalnya, hingga 10MB), gunakan pendekatan konfigurasi, tetapi hindari ukuran pesan yang sangat besar untuk menjaga performa.

  3. Terapkan Konfigurasi di Level Topik:

    • Alih-alih mengubah message.max.bytes di level broker, gunakan max.message.bytes di level topik untuk fleksibilitas dan mengurangi dampak pada topik lain.

  4. Pantau Performa Klaster:

    • Gunakan metrik JMX seperti BytesInPerSec, BytesOutPerSec, dan ReplicationBytesInPerSec untuk memantau dampak pesan besar pada klaster.

    • Periksa log broker untuk kesalahan terkait ukuran pesan atau replikasi.

  5. Uji di Lingkungan Non-Produksi:

    • Uji pengiriman pesan besar di lingkungan pengujian untuk memastikan konfigurasi berfungsi dengan benar dan tidak menyebabkan kegagalan konsumer atau replikasi.

  6. Gunakan Kompresi untuk Mengurangi Ukuran Pesan:

    • Aktifkan kompresi di sisi produser (compression.type, misalnya gzip atau snappy) untuk mengurangi ukuran pesan sebelum dikirim:

      kafka-console-producer.sh --bootstrap-server localhost:9092 \
--topic large-message \
--producer-property compression.type=gzip \
--producer-property max.request.size=10485880

    • Kompresi dapat secara signifikan mengurangi ukuran pesan, memungkinkan pengiriman data besar dengan lebih efisien.

  7. Konsistensi Konfigurasi:

    • Pastikan semua komponen (topik, broker, produser, konsumer) memiliki konfigurasi ukuran pesan yang selaras untuk menghindari kegagalan.

  8. Pertimbangkan Mode KRaft:

    • Dalam mode KRaft (Kafka tanpa Zookeeper), manajemen metadata lebih efisien, tetapi konfigurasi untuk pesan besar tetap sama. Uji performa di lingkungan KRaft untuk memastikan kompatibilitas.

Penjelasan Tambahan

Hubungan dengan Komponen Kafka

  • Produser: Harus mengatur max.request.size untuk mendukung pengiriman pesan besar.

  • Konsumer: Harus mengatur max.partition.fetch.bytes untuk mengambil pesan besar tanpa kegagalan.

  • Broker dan Topik: Harus mendukung ukuran pesan besar melalui max.message.bytes (topik) dan replica.fetch.max.bytes (broker) untuk replikasi yang andal.

  • Kompresi: Mengaktifkan kompresi di produser dapat mengurangi ukuran pesan, mengurangi kebutuhan untuk meningkatkan batas ukuran.

Pemecahan Masalah

Jika Anda mengalami masalah saat mengirim pesan besar:

  • Konsumer Terhenti:

    • Periksa apakah max.partition.fetch.bytes cukup besar:

      kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic large-message --consumer-property max.partition.fetch.bytes=10485880

    • Pastikan konsumer tidak membaca dari offset yang menyebabkan kegagalan pengambilan.

  • Kegagalan Replikasi:

    • Verifikasi bahwa replica.fetch.max.bytes di server.properties setidaknya sama dengan max.message.bytes:

      grep replica.fetch.max.bytes config/server.properties

    • Restart broker setelah mengubah konfigurasi.

  • Produser Gagal Mengirim:

    • Pastikan max.request.size cukup besar:

      kafka-console-producer.sh --bootstrap-server localhost:9092 --topic large-message --producer-property max.request.size=10485880

Alternatif

  • Pecah Pesan Besar: Jika memungkinkan, pecah pesan besar menjadi beberapa pesan kecil (<1MB) dan kirim secara berurutan, lalu rekonstruksi di sisi konsumer.

  • Gunakan Sistem Eksternal: Untuk pesan sangat besar, penyimpanan eksternal adalah solusi yang lebih skalabel dan efisien dibandingkan meningkatkan batas ukuran pesan Kafka.

Kesimpulan

Mengirim pesan besar di Apache Kafka memerlukan pertimbangan hati-hati untuk menjaga performa dan keandalan klaster. Pendekatan penyimpanan eksternal cocok untuk pesan berukuran GB, seperti file video, dengan hanya mengirim referensi melalui Kafka. Untuk pesan hingga 10MB, Anda dapat meningkatkan batas ukuran pesan dengan mengonfigurasi max.message.bytes (topik), replica.fetch.max.bytes (broker), max.partition.fetch.bytes (konsumer), dan max.request.size (produser). Dengan mengikuti praktik terbaik seperti menggunakan kompresi, menerapkan konfigurasi di level topik, dan menguji di lingkungan non-produksi, Anda dapat mengelola pesan besar secara efisien. Pastikan semua konfigurasi selaras dan pantau performa klaster untuk mencegah masalah seperti kegagalan replikasi atau konsumer terhenti.

PreviousKafka Topic Advanced: Memilih Faktor Replikasi dan Jumlah PartisiNextKafka Topic Advanced: Konvensi Penamaan Topic Kafka

Last updated