Pola desain berorientasi layanan mikro telah membuat aplikasi kami lebih skalabel dari sebelumnya. Server API RESTful, front-end, dan bahkan database sekarang dapat diskalakan secara horizontal. Penskalaan horizontal adalah tindakan menambahkan node baru ke kluster aplikasi Anda untuk mendukung beban kerja tambahan. Sebaliknya, ini juga memungkinkan pengurangan konsumsi sumber daya, ketika beban kerja berkurang, untuk menghemat biaya. Sistem yang dapat diskalakan secara horizontal perlu sistem terdistribusi. Sistem ini yang dapat bertahan dari kegagalan beberapa VM, wadah, atau tautan jaringan dan tetap online dan sehat bagi pengguna akhir.

Ketika berbicara tentang sistem terdistribusi seperti di atas, kita mengalami masalah analitik dan pemantauan. Setiap node menghasilkan banyak informasi tentang kesehatannya sendiri (penggunaan CPU, memori, dll) dan tentang status aplikasi bersama dengan apa yang coba dilakukan pengguna. Rincian ini harus dicatat dalam:

1. Urutan yang sama di mana mereka diciptakan,
2. Dipisahkan dalam hal urgensi (analitik waktu nyata atau kumpulan data), dan yang paling penting,
3. Mekanisme pengumpulannya sendiri harus didistribusikan dan dapat diskalakan, jika tidak, kita akan mengalami satu titik kegagalan. Sesuatu yang seharusnya dihindari oleh desain sistem terdistribusi.

Mengapa Menggunakan Kafka?

Apache Kafka ditetapkan sebagai Platform Streaming Terdistribusi. Dalam bahasa Kafka, Produser terus menghasilkan data (sungai) dan Konsumen bertanggung jawab untuk memproses, menyimpan, dan menganalisisnya. Kafka Pialang bertanggung jawab untuk memastikan bahwa dalam skenario terdistribusi data dapat menjangkau dari Produsen ke Konsumen tanpa inkonsistensi. Satu set broker Kafka dan perangkat lunak lain yang disebut penjaga kebun binatang merupakan penyebaran Kafka yang khas.

Aliran data dari banyak produsen perlu dikumpulkan, dipartisi, dan dikirim ke banyak konsumen, ada banyak pengocokan yang terlibat. Menghindari inkonsistensi bukanlah tugas yang mudah. Inilah mengapa kita membutuhkan Kafka.

Skenario di mana Kafka dapat digunakan cukup beragam. Apa pun mulai dari perangkat IOT hingga cluster VM hingga server bare metal di lokasi Anda sendiri. Di mana saja di mana banyak 'hal' secara bersamaan menginginkan perhatian Anda… .Itu tidak terlalu ilmiah kan?? Nah arsitektur Kafka adalah lubang kelinci tersendiri dan layak mendapatkan perawatan independen. Pertama-tama mari kita lihat penyebaran perangkat lunak tingkat permukaan.

Menggunakan Docker Compose

Dengan cara imajinatif apa pun Anda memutuskan untuk menggunakan Kafka, satu hal yang pasti - Anda tidak akan menggunakannya sebagai satu contoh. Itu tidak dimaksudkan untuk digunakan seperti itu, dan bahkan jika aplikasi terdistribusi Anda hanya membutuhkan satu instance (broker) untuk saat ini, itu pada akhirnya akan tumbuh dan Anda perlu memastikan bahwa Kafka dapat mengikuti.

Docker-compose adalah mitra yang sempurna untuk skalabilitas semacam ini. Alih-alih menjalankan broker Kafka pada VM yang berbeda, kami menyimpannya dan memanfaatkan Docker Compose untuk mengotomatiskan penerapan dan penskalaan. Kontainer Docker sangat skalabel baik pada host Docker tunggal maupun di seluruh cluster jika kita menggunakan Docker Swarm atau Kubernetes. Jadi masuk akal untuk memanfaatkannya agar Kafka dapat diskalakan.

Mari kita mulai dengan satu contoh broker. Buat direktori bernama Apache-kafka dan di dalamnya buat komposisi buruh pelabuhan Anda.yml.

$mkdir apache-kafka
$ cd apache-kafka
$ vim docker-compose.yml

Konten berikut akan dimasukkan ke dalam komposisi buruh pelabuhan Anda.file .yml:

versi: '3'
jasa:
penjaga kebun binatang:
gambar: wurstmeister/penjaga kebun binatang
 
kafka:
gambar: wurstmeister/kafka
port:
- "9092:9092"
lingkungan Hidup:
KAFKA_ADVERTISED_HOST_NAME: localhost
KAFKA_ZOOKEEPER_CONNECT: penjaga kebun binatang: 2181

Setelah Anda menyimpan konten di atas dalam file penulisan Anda, dari direktori yang sama jalankan:

$ docker-compose up -d

Oke, jadi apa yang kita lakukan di sini?

Memahami Docker-Compose.yml

Compose akan memulai dua layanan seperti yang tercantum dalam file yml. Mari kita lihat filenya sedikit lebih dekat. Gambar pertama adalah zookeeper yang dibutuhkan Kafka untuk melacak berbagai broker, topologi jaringan, serta menyinkronkan informasi lainnya. Karena layanan zookeeper dan kafka akan menjadi bagian dari jaringan jembatan yang sama (ini dibuat saat kita menjalankan docker-compose up ), kita tidak perlu mengekspos port apa pun. Broker Kafka dapat berbicara dengan penjaga kebun binatang dan hanya itu yang dibutuhkan penjaga kebun binatang.

Layanan kedua adalah kafka itu sendiri dan kami hanya menjalankan satu contoh saja, yaitu satu broker. Idealnya, Anda ingin menggunakan banyak broker untuk memanfaatkan arsitektur terdistribusi Kafka. Layanan mendengarkan pada port 9092 yang dipetakan ke nomor port yang sama di Docker Host dan begitulah cara layanan berkomunikasi dengan dunia luar.

Layanan kedua juga memiliki beberapa variabel lingkungan. Pertama, apakah KAFKA_ADVERTISED_HOST_NAME disetel ke localhost. Ini adalah alamat tempat Kafka beroperasi, dan di mana produsen dan konsumen dapat menemukannya. Sekali lagi, ini harus disetel ke localhost melainkan ke alamat IP atau nama host dengan ini server dapat dijangkau di jaringan Anda. Kedua adalah nama host dan nomor port dari layanan penjaga kebun binatang Anda. Karena kami menamai layanan zookeeper ... yah, zookeeper itulah yang akan menjadi nama host, dalam jaringan jembatan buruh pelabuhan yang kami sebutkan.

Menjalankan alur pesan sederhana

Agar Kafka mulai bekerja, kita perlu membuat topik di dalamnya. Klien produsen kemudian dapat mempublikasikan aliran data (pesan) ke topik tersebut dan konsumen dapat membaca aliran data tersebut, jika mereka berlangganan topik tertentu.

Untuk melakukan ini, kita perlu memulai terminal interaktif dengan wadah Kafka. Daftar wadah untuk mengambil nama wadah kafkaka. Misalnya, dalam hal ini wadah kami bernama apache-kafka_kafka_1

$ buruh pelabuhan

Dengan nama wadah kafka, sekarang kita bisa masuk ke dalam wadah ini.

$ docker exec -it apache-kafka_kafka_1 bash
bash-4.4#

Buka dua terminal yang berbeda untuk menggunakan satu sebagai konsumen dan produsen lain.

Sisi Produser

Di salah satu petunjuk (yang Anda pilih untuk menjadi produser), masukkan perintah berikut:

## Untuk membuat topik baru bernama test
bash-4.4# topik kafka.sh --create --zookeeper zookeeper:2181 --replication-factor 1
--partisi 1 --ujian topik
 
## Untuk memulai produser yang menerbitkan aliran data dari input standar ke kafka
bash-4.4# kafka-konsol-produser.sh --broker-list localhost:9092 --ujian topik
>

Produser sekarang siap menerima masukan dari keyboard dan mempublikasikannya.

Sisi Konsumen

Pindah ke terminal kedua yang terhubung ke wadah kafka Anda. Perintah berikut memulai konsumen yang memakan topik pengujian:

$ kafka-konsol-konsumen.sh --bootstrap-server localhost:9092 --ujian topiktopic

Kembali ke Produser

Anda sekarang dapat mengetik pesan di prompt baru dan setiap kali Anda menekan kembali, baris baru dicetak di prompt konsumen. Sebagai contoh:

> Ini adalah pesan.

Pesan ini dikirimkan ke konsumen, melalui Kafka, dan Anda dapat melihatnya dicetak di prompt konsumen.

Pengaturan Dunia Nyata

Anda sekarang memiliki gambaran kasar tentang cara kerja pengaturan Kafka. Untuk kasus penggunaan Anda sendiri, Anda perlu menetapkan nama host yang bukan localhost, Anda memerlukan beberapa broker seperti itu untuk menjadi bagian dari klaster kafka Anda dan akhirnya Anda perlu mengatur klien konsumen dan produsen.

Berikut adalah beberapa tautan yang berguna:

1. Klien Python Confluent
2. Dokumentasi Resmi
3. Daftar demo yang berguna

Saya harap Anda bersenang-senang menjelajahi Apache Kafka.