Pipeline data streaming end-to-end untuk mendeteksi aktivitas Distributed Denial of Service (DDoS) secara near real-time menggunakan Apache Kafka, Apache Spark Structured Streaming, dan Machine Learning.
Proyek ini mengintegrasikan teknologi data streaming dan analitik untuk memproses trafik jaringan secara berkelanjutan, melakukan klasifikasi aktivitas jaringan, serta menghasilkan informasi yang dapat digunakan untuk mendukung proses deteksi serangan siber.
- Gambaran Proyek
- Dataset
- Teknologi yang Digunakan
- Arsitektur Sistem
- Alur Proses Data
- Random Forest
- Struktur Proyek
- Implementasi dan Hasil
- Kesimpulan
- Cara Menjalankan
- Pengembangan Selanjutnya
Bagaimana cara mendeteksi serangan DDoS pada data yang terus mengalir?
Proyek ini menjawab pertanyaan tersebut dengan membangun pipeline data streaming end-to-end menggunakan Apache Kafka, Apache Spark Structured Streaming, dan model Random Forest. Data trafik jaringan diproses secara berkelanjutan, ditransformasikan melalui tahapan preprocessing dan feature engineering, kemudian diklasifikasikan sebagai Normal atau DDoS Attack secara near real-time.
- Real-Time Data Ingestion menggunakan Apache Kafka.
- Stream Processing menggunakan Apache Spark Structured Streaming.
- Machine Learning Inference menggunakan Random Forest.
- Near Real-Time DDoS Detection.
- Output disimpan dalam format Parquet.
Menghasilkan pipeline data streaming yang dapat mendeteksi anomali serangan DDoS.
Pipeline ini menggunakan dataset CIC-DDoS2019, salah satu dataset keamanan siber yang banyak digunakan untuk penelitian dan pengembangan sistem deteksi serangan Distributed Denial of Service (DDoS).
Dataset berisi rekaman trafik jaringan yang mencakup aktivitas normal maupun berbagai skenario serangan DDoS. Karakteristik tersebut menjadikan CIC-DDoS2019 sebagai sumber data yang sesuai untuk membangun dan mengevaluasi sistem deteksi serangan berbasis data streaming.
Berikut contoh tampilan data:
Gambar 1. Contoh data trafik jaringan pada dataset CIC-DDoS2019.
| Atribut | Keterangan |
|---|---|
| Nama Dataset | CIC-DDoS2019 |
| Pengembang | Canadian Institute for Cybersecurity (CIC) |
| Format Data | CSV |
| Banyak Attribut Data | 88 kolom data |
| Domain | Network Traffic Analysis |
| Kategori Data | Normal Traffic dan DDoS Attack |
| Tujuan Penggunaan | DDoS Detection & Classification |
- Berisi data trafik jaringan normal dan serangan DDoS yaitu UDP, LDAP, Syn, MSSQL, Portmap, NetBIOS, dan UDPLAG.
- Menyediakan puluhan fitur statistik yang menggambarkan karakteristik aliran trafik jaringan.
- Banyak digunakan sebagai benchmark pada penelitian keamanan siber dan machine learning.
- Mendukung pengembangan model klasifikasi untuk membedakan aktivitas normal dan aktivitas serangan.
- Cocok digunakan sebagai sumber data untuk simulasi pemrosesan data secara streaming.
Pada proyek ini, data dari dataset CIC-DDoS2019 digunakan sebagai sumber data yang dikirim secara streaming melalui Apache Kafka sebelum diproses menggunakan Apache Spark Structured Streaming dan dianalisis menggunakan model Random Forest.
Berikut teknologi yang digunakan dalam pengembangan pipeline deteksi DDoS secara streaming.
| Teknologi | Versi | Peran |
|---|---|---|
| Java | 11 & 17 | Implementasi Kafka Producer |
| Scala | 2.13.12 | Implementasi Spark Structured Streaming |
| Python (PySpark) (Google Colab) | - | Pengembangan Machine Learning Random Forest |
| Apache Kafka | 3.8.0 | Real-Time Data Ingestion dan Message Broker |
| Apache Spark | 3.5.3 | Pemrosesan data streaming |
| Apache Spark MLlib | 3.5.3 | Pelatihan dan inferensi model Machine Learning |
| Random Forest | - | Klasifikasi trafik jaringan |
| Parquet | - | Format penyimpanan hasil prediksi |
| Maven | 3.9.9 | Dependency Management |
| Ubuntu (WSL) | 22.04 LTS | Lingkungan menjalankan Server Kafka, eksekusi Program Producer dan Spark Structured Streaming |
Arsitektur sistem terdiri dari beberapa komponen yang saling terintegrasi untuk mendukung proses pelatihan model Machine Learning dan pemrosesan data streaming secara end-to-end. Secara umum, sistem dibangun melalui dua alur utama, yaitu alur pengembangan model dan alur pemrosesan data streaming.
Gambar 2. Arsitektur sistem Real-Time DDoS Detection Pipeline.
| Label | Komponen | Fungsi |
|---|---|---|
| 1 | Data Preparation | Menyiapkan dataset untuk pelatihan model dan simulasi data streaming |
| 2 | Random Forest Training | Melatih, mengevaluasi, dan menyimpan model Machine Learning |
| 3 | Kafka Producer | Mengirim data trafik jaringan ke Kafka Topic |
| 4 | Kafka Topic | Media distribusi data streaming antar komponen |
| 5 | Spark Structured Streaming | Memproses data dan melakukan deteksi DDoS menggunakan model Random Forest |
Alur pertama berfokus pada pembangunan model Machine Learning yang digunakan untuk mendeteksi aktivitas DDoS. Dataset hasil persiapan data digunakan untuk melatih model Random Forest, kemudian dilakukan evaluasi dan penyimpanan model. Model yang telah disimpan selanjutnya digunakan oleh Spark Structured Streaming untuk melakukan proses inferensi pada data yang mengalir melalui pipeline.
Data Preparation
│
▼
Random Forest Training
│
▼
Saved Model
│
▼
Spark Structured Streaming
Alur kedua merupakan jalur utama pemrosesan data secara streaming. Data trafik jaringan dikirimkan oleh Kafka Producer menuju Kafka Topic sebagai media perantara. Selanjutnya, Apache Spark Structured Streaming membaca data dari Kafka, melakukan transformasi data, dan mengaplikasikan model Random Forest untuk mengklasifikasikan trafik sebagai aktivitas normal atau serangan DDoS.
Data Preparation
│
▼
Kafka Producer
│
▼
Kafka Topic
│
▼
Spark Structured Streaming
│
▼
Prediction Result
Kedua alur tersebut saling melengkapi untuk membentuk pipeline deteksi DDoS secara end-to-end, mulai dari pembangunan model hingga proses analisis data streaming menggunakan model yang telah dilatih sebelumnya.
Pipeline memproses data melalui beberapa tahapan, mulai dari pembacaan dataset menggunakan Kafka Producer hingga analisis trafik menggunakan Spark Structured Streaming untuk menghasilkan informasi deteksi serangan DDoS.
Gambar 3. Alur proses data pada Kafka Producer.
Kafka Producer bertanggung jawab membaca data dari dataset CIC-DDoS2019 dan mengirimkannya ke Kafka Topic sebagai sumber data bagi pipeline streaming. Sebelum data dikirim, setiap record melewati beberapa tahapan pemrosesan untuk memastikan struktur dan format data sesuai dengan kebutuhan sistem. Dari gambar, dapat dijelaskan secara ringkas alur proses datanya seperti berikut.
| No. | Tahap | Ringkasan |
|---|---|---|
| 1 | Pembacaan Data | Membaca dataset CIC-DDoS2019 dan mengidentifikasi struktur kolom dari file CSV. |
| 2 | Split Data | Memisahkan setiap baris menjadi atribut-atribut individual berdasarkan delimiter CSV. |
| 3 | Avro Record Mapping | Mengubah data ke objek Apache Avro sesuai skema yang telah ditentukan. |
| 4 | Pengaturan Input Rate | Mengontrol kecepatan pengiriman data untuk mensimulasikan trafik streaming. |
| 5 | Pembentukan Producer Record | Membentuk Kafka Producer Record yang berisi metadata dan payload data. |
| 6 | Pengiriman Data | Mengirim record ke Kafka Topic sebagai sumber data streaming. |
| 7 | Logging dan Monitoring | Mencatat aktivitas pengiriman untuk monitoring dan evaluasi performa pipeline. |
Melalui tahapan tersebut, data mentah dari dataset dapat ditransformasikan menjadi record streaming yang siap diproses oleh Apache Spark Structured Streaming.
Gambar 4. Alur proses data pada Spark Structured Streaming.
Spark Structured Streaming bertanggung jawab memproses data yang diterima dari Kafka Topic dan melakukan deteksi serangan DDoS menggunakan model Machine Learning Random Forest. Setiap data yang diterima akan melewati beberapa tahapan pemrosesan sebelum menghasilkan output akhir. Dari gambar, dapat dijelaskan secara ringkas alur proses datanya seperti berikut.
| No. | Tahap | Deskripsi |
|---|---|---|
| 1 | Pembacaan Data | Spark membaca data secara kontinu dari Kafka Topic. |
| 2 | Deserialisasi Avro | Payload Avro dikonversi menjadi struktur data yang dapat diproses oleh Spark. |
| 3 | Ekstraksi Kolom | Data hasil deserialisasi dipetakan ke atribut dataset CIC-DDoS2019. |
| 4 | Feature Engineering | Fitur-fitur yang digunakan model digabungkan menjadi vektor input. |
| 5 | Prediksi Random Forest | Model melakukan klasifikasi trafik menjadi Normal atau DDoS Attack. |
| 6 | Perhitungan Metrik | Sistem mencatat waktu pemrosesan dan metrik performa pipeline. |
| 7 | Penyimpanan Hasil | Hasil deteksi disimpan dalam format Apache Parquet. |
Melalui tahapan tersebut, data yang awalnya berada dalam Kafka Topic dapat diproses secara streaming hingga menghasilkan informasi deteksi serangan DDoS secara near real-time dan disimpan dalam format Parquet untuk kebutuhan analisis lebih lanjut.
Bagian ini menjelaskan proses pengembangan model Machine Learning yang digunakan untuk mendeteksi aktivitas Distributed Denial of Service (DDoS). Model dikembangkan menggunakan dataset CIC-DDoS2019 dan selanjutnya diintegrasikan ke dalam pipeline streaming sebagai komponen inferensi.
Model dikembangkan menggunakan algoritma Random Forest Classifier dengan konfigurasi sebagai berikut.
| Parameter | Nilai |
|---|---|
| Algoritma | Random Forest Classifier |
| Library | Spark MLlib (atau Scikit-Learn jika memang digunakan) |
| Dataset | CIC-DDoS2019 |
| Jumlah Fitur | 27 |
| Target | Label (Normal / DDoS Attack) |
| Output | Prediction |
Catatan: Tambahkan parameter seperti
numTrees,maxDepth,seed, dan parameter lainnya sesuai konfigurasi model yang digunakan pada penelitian.
Dataset CIC-DDoS2019 memiliki 88 atribut, namun tidak seluruh atribut digunakan sebagai masukan model. Pipeline memanfaatkan 27 fitur yang merepresentasikan karakteristik utama lalu lintas jaringan sehingga mampu mempertahankan performa klasifikasi sekaligus mengurangi kompleksitas pemrosesan.
Fitur yang digunakan mencakup beberapa kelompok informasi berikut.
| Kelompok Fitur | Contoh |
|---|---|
| Flow Statistics | Flow Duration |
| Packet Count | Total Fwd Packets, Total Backward Packets |
| Packet Size | Packet Length Mean, Packet Length Std |
| Traffic Rate | Flow Bytes/s, Flow Packets/s |
| Inter Arrival Time | Flow IAT Mean, Flow IAT Std |
| TCP Flags | SYN Flag Count, ACK Flag Count |
Model dievaluasi menggunakan data pengujian untuk mengukur kemampuan klasifikasi terhadap trafik normal maupun serangan DDoS sebelum diintegrasikan ke dalam pipeline streaming. Dimana hasil Confusion Matrix didapat sebagai berikut:
Gambar 5. Confusion Matrix Random Forest.
Dengan Hasil Perhitungan Evaluasi sebagai berikut,
Gambar 6. Hasil evaluasi Random Forest.
Random Forest dipilih sebagai model klasifikasi karena memiliki beberapa keunggulan untuk kasus deteksi serangan jaringan, antara lain:
- Memberikan akurasi klasifikasi yang tinggi pada data tabular.
- Mampu menangani data berdimensi tinggi tanpa proses yang kompleks.
- Memiliki ketahanan terhadap overfitting melalui pendekatan ensemble.
- Memiliki waktu inferensi yang cepat sehingga sesuai untuk pipeline data streaming.
- Mudah diintegrasikan dengan Apache Spark MLlib.
real-time-ddos-detection-pipeline/
│
├── assets/
│
├── KafkaProducer/
│ ├── src/
│ ├── logs/
│ └── pom.xml
│
├── SparkStructuredStreaming/
│ ├── config/
│ ├── rf_model_ddos_detection/
│ ├── src/
│ └── build.sbt
│
├── Model/
│
├── RunningProgram/
│ ├── config/
│ ├── dataset/
│ ├── log/
│ ├── rf_model_ddos_detection/
│ └── ...
│
└── README.md
| Folder | Deskripsi |
|---|---|
assets |
Berisi gambar, diagram, dan dokumentasi yang digunakan pada README. |
KafkaProducer |
Modul Apache Kafka Producer untuk membaca dataset dan mengirimkan data ke Kafka Topic. |
SparkStructuredStreaming |
Modul Apache Spark Structured Streaming untuk membaca data dari Kafka, melakukan transformasi, menjalankan inferensi Random Forest, dan menyimpan hasil ke Parquet. |
Model |
Berisi proses pengembangan model Random Forest, mulai dari preprocessing, pelatihan model, evaluasi, hingga penyimpanan model. |
RunningProgram |
Berisi keseluruhan file-file menjalankan Pipeline Data Streaming. |
Bagian ini menjelaskan implementasi setiap komponen utama pada pipeline beserta hasil yang diperoleh. Setiap tahapan dilengkapi dengan bukti implementasi berupa tangkapan layar (screenshot) maupun log sistem untuk menunjukkan bahwa proses berjalan sesuai dengan rancangan arsitektur dan alur data yang telah dijelaskan sebelumnya.
Kafka Producer merupakan komponen pertama pada pipeline yang bertugas membaca data dari dataset CIC-DDoS2019, mengubah setiap record ke dalam format Apache Avro, kemudian mengirimkannya secara bertahap ke Kafka Topic. Mekanisme pengiriman dilakukan secara terkontrol sesuai input rate yang telah ditentukan sehingga mampu mensimulasikan aliran trafik jaringan pada skenario streaming.
Gambar 7. Hasil Log Implementasi Kafka Producer.
Gambar di atas menunjukkan bahwa Kafka Producer berhasil mengirimkan data ke Kafka Topic. Selama proses berlangsung, producer mencatat informasi penting seperti Flow ID, waktu pengiriman (producer timestamp), waktu data diterima broker Kafka, serta nilai latency pengiriman. Informasi tersebut digunakan untuk memvalidasi keberhasilan proses pengiriman sekaligus mendukung proses evaluasi performa pipeline.
| Aktivitas | Status |
|---|---|
| Membaca dataset CIC-DDoS2019 | ✅ Berhasil |
| Mapping data ke Apache Avro | ✅ Berhasil |
| Pembentukan Kafka Producer Record | ✅ Berhasil |
| Pengiriman data ke Kafka Topic | ✅ Berhasil |
| Logging informasi pengiriman | ✅ Berhasil |
Spark Structured Streaming berperan sebagai mesin pemrosesan utama pada pipeline. Data yang diterima dari Kafka Topic dibaca secara kontinu menggunakan mekanisme micro-batch, kemudian diproses melalui serangkaian tahapan mulai dari deserialisasi data Apache Avro, ekstraksi atribut, feature engineering, hingga proses inferensi menggunakan model Machine Learning Random Forest.
Selain menghasilkan prediksi terhadap setiap data yang diproses, Spark juga melakukan pencatatan waktu pemrosesan untuk menghitung end-to-end latency. Hasil akhir setiap micro-batch kemudian disimpan dalam format Apache Parquet sebagai keluaran pipeline.
Untuk Lebih Lengkap-nya Hasil Tiap Bagian Dapat Ditunjukkan Sebagai Berikut:
Spark Structured Streaming membaca data secara kontinu dari Kafka Topic menggunakan mekanisme micro-batch. Setiap batch berisi sekumpulan record yang telah dikirim oleh Kafka Producer, lengkap dengan metadata seperti topic, partition, offset, dan timestamp. Metadata tersebut dimanfaatkan untuk memastikan proses pembacaan data berlangsung secara berurutan dan mendukung proses monitoring selama pipeline berjalan.
Gambar 8. Pengambilan data secara streaming dari Kafka Topic.
Data yang diterima dari Kafka masih berupa byte stream hasil serialisasi Apache Avro. Pada tahap ini, Spark melakukan proses deserialisasi menggunakan skema Avro yang telah ditentukan sehingga setiap record dapat dikembalikan ke struktur data semula. Setelah proses ini selesai, seluruh atribut dataset berhasil diekstraksi menjadi kolom-kolom terstruktur yang siap digunakan pada tahapan data cleaning, feature engineering, dan proses inferensi model Machine Learning.
Gambar 9. Implementasi proses deserialisasi data Apache Avro.
Sebelum dilakukan proses prediksi, setiap data yang diterima dari Kafka terlebih dahulu melalui tahap data cleaning. Tahap ini bertujuan memastikan data memiliki kualitas yang baik sehingga dapat diproses oleh model Machine Learning tanpa menimbulkan kesalahan selama proses inferensi.
Proses data cleaning yang diterapkan meliputi penanganan nilai NaN, Infinity, dan -Infinity dengan menggantinya menjadi nilai 0. Pendekatan ini dipilih untuk menjaga konsistensi struktur data sekaligus menghindari kegagalan proses transformasi fitur maupun prediksi model pada data streaming.
Gambar 10. Hasil pengecekan proses Data Cleaning pada Spark Structured Streaming.
Setelah proses data cleaning selesai, data ditransformasikan menjadi format yang sesuai untuk kebutuhan model Machine Learning. Pada tahap ini, sebanyak 27 fitur yang telah ditentukan digabungkan menjadi sebuah kolom vektor (features) menggunakan VectorAssembler dari Apache Spark ML.
Gambar 11. Implementasi proses Feature Engineering.
Representasi dalam bentuk vektor memungkinkan seluruh atribut numerik diproses secara efisien oleh model Random Forest tanpa perlu melakukan transformasi tambahan pada setiap proses micro-batch. Dengan demikian, setiap data yang mengalir pada pipeline memiliki struktur yang konsisten dan siap digunakan pada tahap inferensi.
Setelah kolom features berhasil dibentuk, setiap data diproses menggunakan model Random Forest yang telah dilatih sebelumnya. Model melakukan inferensi terhadap setiap record pada aliran data (stream) dan menghasilkan nilai prediksi yang menunjukkan apakah trafik jaringan termasuk Normal atau DDoS Attack.
Gambar 12. Implementasi proses inferensi menggunakan Random Forest.
Proses inferensi dilakukan secara otomatis pada setiap micro-batch tanpa memerlukan pelatihan ulang model. Pendekatan ini memungkinkan pipeline melakukan analisis terhadap data yang terus mengalir dengan waktu respons yang rendah dan hasil prediksi yang konsisten.
Setelah proses inferensi selesai, hasil deteksi disimpan secara otomatis ke dalam file berformat Apache Parquet. Penyimpanan dilakukan pada setiap micro-batch sehingga seluruh hasil prediksi dapat terdokumentasi secara berkelanjutan tanpa mengganggu proses streaming yang sedang berlangsung.
Gambar 13. Implementasi penyimpanan hasil deteksi ke dalam format Apache Parquet.
Format Parquet dipilih karena bersifat columnar storage, memiliki ukuran penyimpanan yang lebih efisien, serta memberikan performa baca yang tinggi untuk kebutuhan analisis data skala besar. Dengan demikian, hasil deteksi yang dihasilkan pipeline dapat dimanfaatkan kembali untuk proses evaluasi, visualisasi, maupun analisis lanjutan.
| Aktivitas | Status |
|---|---|
| Membaca data dari Kafka Topic | ✅ Berhasil |
| Deserialisasi Apache Avro | ✅ Berhasil |
| Ekstraksi atribut dataset | ✅ Berhasil |
| Feature Engineering | ✅ Berhasil |
| Inferensi Random Forest | ✅ Berhasil |
| Perhitungan end-to-end latency | ✅ Berhasil |
| Penyimpanan hasil ke Parquet | ✅ Berhasil |
Proyek ini berhasil membangun sebuah pipeline data streaming end-to-end untuk deteksi serangan Distributed Denial of Service (DDoS) menggunakan Apache Kafka, Apache Spark Structured Streaming, dan model Machine Learning Random Forest.
Pipeline mampu mengalirkan data dari dataset CIC-DDoS2019 melalui Kafka Producer, memprosesnya secara streaming menggunakan Spark Structured Streaming, melakukan data cleaning, feature engineering, serta inferensi menggunakan model Random Forest, kemudian menyimpan hasil deteksi ke dalam format Apache Parquet.
Melalui proyek ini, berhasil diimplementasikan beberapa konsep penting dalam pengembangan sistem data modern, antara lain:
- Distributed Data Ingestion menggunakan Apache Kafka.
- Stream Processing menggunakan Apache Spark Structured Streaming.
- Integrasi Machine Learning pada pipeline streaming.
- Penyimpanan data menggunakan format Apache Parquet.
- Pengembangan pipeline data streaming end-to-end untuk deteksi serangan siber.
Proyek ini menjadi implementasi nyata integrasi teknologi Big Data dan Machine Learning dalam membangun sistem analisis data streaming yang terstruktur, modular, dan siap dikembangkan lebih lanjut.
Beberapa pengembangan yang dapat dilakukan pada proyek ini di masa mendatang antara lain:
- Mengintegrasikan pipeline dengan sumber data jaringan secara langsung (live network traffic) sehingga tidak lagi bergantung pada dataset statis.
- Menambahkan dashboard monitoring menggunakan Grafana atau Kibana untuk memvisualisasikan hasil deteksi secara real-time.
- Mengimplementasikan deployment menggunakan Docker dan Kubernetes agar pipeline lebih mudah dikelola dan diskalakan.
- Mengintegrasikan penyimpanan hasil deteksi ke dalam data lake atau cloud storage untuk kebutuhan analisis jangka panjang.
- Mengevaluasi performa model Machine Learning lain, seperti XGBoost atau LightGBM, sebagai pembanding terhadap Random Forest.
- Mengembangkan mekanisme online learning sehingga model dapat diperbarui secara berkala berdasarkan data terbaru.
Proyek ini merupakan implementasi dari penelitian tugas akhir mengenai pembangunan pipeline data streaming end-to-end untuk deteksi serangan Distributed Denial of Service (DDoS) menggunakan Apache Kafka, Apache Spark Structured Streaming, dan model Machine Learning Random Forest.
Dokumentasi penelitian yang memuat landasan teori, metodologi, perancangan sistem, implementasi, serta hasil evaluasi dapat diakses melalui tautan berikut:
📄 Hasil Laporan TA (sementara)
Catatan: Dokumen tersebut masih merupakan versi sementara dan akan terus diperbarui hingga penelitian dinyatakan selesai.
Febrianto Kudadiri
Mahasiswa Teknik Informatika yang memiliki minat pada bidang Data Engineer Enthusiast | Big Data | Machine Learning Software Engineering | Full Stack Developer
- GitHub: https://github.com/EgoEquusFebrianto
- Email: febrianto.kudadiri.04@gmail.com
- LinkedIn: Febrianto Kudadri
Proyek ini dirilis di bawah MIT License.
Silakan menggunakan, mempelajari, memodifikasi, maupun mengembangkan proyek ini sesuai dengan ketentuan yang tercantum pada berkas LICENSE.