Pipeline data lokal sering menjadi tempat pertama sebuah ide data engineering diuji. Di laptop atau workstation, Apache Spark dapat membaca...

Pipeline data lokal sering menjadi tempat pertama sebuah ide data engineering diuji. Di laptop atau workstation, Apache Spark dapat membaca berkas, membersihkan kolom, menggabungkan tabel, dan menghasilkan dataset siap analisis. Namun, menjalankannya dengan mode lokal tidak otomatis membuat proses efisien. Operasi seperti join dan agregasi dapat memindahkan banyak data antartask, menghabiskan memori, serta membuat waktu eksekusi sulit diprediksi.
Artikel ini membahas tiga tuas praktis: shuffle, jumlah partisi, dan broadcast join. Contohnya menggunakan PySpark pada satu mesin untuk membantu memahami pola kerja, bukan menjanjikan peningkatan performa tertentu. Konfigurasi yang tepat bergantung pada ukuran data, bentuk kunci, memori, penyimpanan, versi Spark, dan proses lain yang berjalan. Mulailah dengan mengukur kondisi awal, lalu ubah satu hal setiap kali.
Bacaan terkait: Mengenal Apache Parquet untuk penyimpanan data analitik.
Memahami alur kerja dan biaya shuffle
Spark membagi data menjadi partisi dan memprosesnya melalui task. Sejumlah transformasi dapat dikerjakan dalam partisi yang sama, tetapi operasi berdasarkan kunci sering memerlukan pengelompokan ulang data. Proses perpindahan data antarpartisi inilah yang disebut shuffle. Contohnya mencakup agregasi berdasarkan kategori, join tertentu, dan pengurutan global. Di mode lokal, task tetap bertukar data melalui mekanisme shuffle meskipun semuanya berjalan pada satu mesin.
Biayanya bukan sekadar transfer jaringan. Spark juga perlu menulis dan membaca data shuffle, mengelola memori, dan kadang melakukan spill ke disk ketika data perantara tidak muat dalam memori. Mesin dengan disk lambat atau ruang kosong terbatas dapat menjadi hambatan. Pengumpulan banyak data ke driver melalui collect() juga berisiko menghabiskan memori driver; ini masalah berbeda dari shuffle, walaupun keduanya bisa muncul pada job yang sama.
Mengenali operasi yang perlu perhatian
Periksa rencana eksekusi dengan explain dan cocokkan dengan Spark UI setelah action dijalankan. Operator Exchange dalam physical plan sering menandai perpindahan data atau perubahan distribusi; interpretasinya tetap bergantung pada rencana dan versi Spark. Agregasi kecil tidak selalu mahal, sedangkan join atas kunci yang sangat tidak merata bisa menghasilkan satu task yang jauh lebih berat. Jangan menghapus shuffle secara membabi buta: kadang redistribusi memang dibutuhkan untuk hasil yang benar.
Menyiapkan lab lokal yang dapat diulang
Siapkan Python dan PySpark yang kompatibel dengan Java serta versi Spark yang digunakan. Jalankan contoh berikut pada direktori kerja yang memiliki ruang disk cukup. Mode local[4] meminta empat thread pekerja lokal; sesuaikan dengan kapasitas mesin dan pekerjaan lain yang berjalan. Nilai pada contoh merupakan titik awal eksperimen, bukan rekomendasi universal untuk semua dataset.
from pyspark.sql import SparkSession, functions as F
spark = (SparkSession.builder
.appName("lab-pipeline-lokal")
.master("local[4]")
.config("spark.sql.shuffle.partitions", "16")
.config("spark.sql.adaptive.enabled", "true")
.getOrCreate())
fakta = spark.read.parquet("data/transaksi.parquet")
dimensi = spark.read.parquet("data/produk.parquet")
print("Partisi awal:", fakta.rdd.getNumPartitions())
Dataset transaksi dan produk pada contoh harus disediakan sendiri; artikel ini tidak menyertakan data atau hasil pengujian. Gunakan salinan data yang aman, tanpa informasi pribadi atau rahasia. Catat versi Spark dan Java, spesifikasi mesin, ukuran berkas, jumlah baris, serta ruang disk. Pertahankan dataset dan kondisi lingkungan yang sama saat membandingkan konfigurasi agar perubahan hasil lebih mudah dijelaskan.
Membuat baseline yang masuk akal
Jalankan pipeline utuh dengan action yang sesuai tujuan sebenarnya, misalnya menulis hasil Parquet ke direktori baru. Mengukur hanya pembuatan DataFrame tidak cukup karena transformasi Spark bersifat lazy: pekerjaan biasanya baru berjalan saat action dipanggil. Jalankan beberapa kali dan catat tiap hasil, termasuk apakah data atau metadata mungkin sudah berada di cache sistem operasi. Pisahkan waktu startup sesi dari waktu job jika keduanya menjadi perhatian.
Untuk pengujian yang adil, gunakan lokasi output berbeda atau bersihkan output uji dengan prosedur yang aman. Jangan menimpa dataset produksi. Perubahan cache, proses latar belakang, dan kompresi dapat menggeser durasi, sehingga selisih kecil perlu ditafsirkan hati-hati. Bila ingin membandingkan rencana, simpan juga output explain dan metrik UI, bukan hanya angka waktu.
Menentukan jumlah partisi secara sadar
Partisi adalah unit pembagian kerja, bukan sinonim dari jumlah file. Terlalu sedikit partisi dapat membuat sebagian core menganggur atau menghasilkan task besar yang menekan memori. Terlalu banyak partisi dapat menambah overhead penjadwalan dan menghasilkan banyak file kecil. Ukuran ideal bergantung pada kompleksitas transformasi dan distribusi data, sehingga tidak ada satu angka yang cocok untuk seluruh pipeline.
Untuk operasi Spark SQL dan DataFrame yang membutuhkan shuffle, spark.sql.shuffle.partitions mengatur jumlah partisi shuffle awal yang umum digunakan. Dengan Adaptive Query Execution (AQE), Spark dapat menggabungkan partisi shuffle pasca-shuffle berdasarkan statistik runtime ketika fitur terkait aktif. Karena itu, jumlah task aktual dapat berbeda dari nilai konfigurasi awal. Lihat dokumentasi versi yang dipakai untuk default dan opsi AQE yang berlaku.
Repartition dan coalesce tidak identik
repartition biasanya melakukan shuffle untuk mendistribusikan ulang data dan dapat menaikkan maupun menurunkan jumlah partisi. Saat diberikan kolom, ia dapat membantu menyiapkan distribusi berdasarkan kunci, tetapi tetap memiliki biaya. coalesce umumnya digunakan untuk mengurangi jumlah partisi tanpa shuffle penuh; hasilnya dapat kurang merata. Hindari menggunakannya terlalu awal jika akibatnya paralelisme menurun drastis.
# Uji terpisah: bandingkan dengan baseline, bukan keduanya sekaligus.
berdasarkan_produk = fakta.repartition(16, "produk_id")
# Contoh mengurangi partisi menjelang penulisan hasil kecil.
hasil_ringkas = berdasarkan_produk.groupBy("produk_id").agg(
F.sum("jumlah").alias("total_jumlah")
)
hasil_ringkas.coalesce(4).write.mode("errorifexists").parquet(
"output/hasil_uji_01"
)
Pemanggilan repartition di atas bukan jaminan join berikutnya bebas shuffle. Optimizer menentukan rencana berdasarkan distribusi yang dibutuhkan oleh seluruh operasi, dan tahapan lain masih dapat menambahkan exchange. Demikian juga, mengurangi partisi menjelang output adalah keputusan berbasis ukuran hasil dan kebutuhan konsumen; empat partisi pada contoh hanya nilai eksperimen.
Menangani shuffle dan kunci yang timpang
Mulailah dengan mengurangi data yang memasuki shuffle tanpa mengubah makna bisnis. Pilih kolom yang dibutuhkan, terapkan filter yang valid sedini mungkin, dan periksa apakah agregasi awal benar-benar mempertahankan hasil yang diinginkan. Pembacaan Parquet dapat memanfaatkan pemilihan kolom, tetapi dorongan filter ke sumber data bergantung pada ekspresi dan kemampuan pembaca. Gunakan physical plan untuk melihat apa yang benar-benar dipilih optimizer.
transaksi_terpilih = (fakta
.filter(F.col("status") == "selesai")
.select("produk_id", "jumlah"))
ringkasan = (transaksi_terpilih
.groupBy("produk_id")
.agg(F.sum("jumlah").alias("total_jumlah")))
ringkasan.explain("formatted")
Ketimpangan kunci atau data skew terjadi ketika sebagian kecil kunci menampung jauh lebih banyak baris daripada yang lain. Pada UI, indikasinya dapat berupa satu atau beberapa task yang jauh lebih lama, membaca lebih banyak shuffle, atau mengalami spill lebih besar. Perbedaan durasi juga bisa disebabkan faktor lain, seperti I/O atau garbage collection; periksa beberapa metrik sebelum menyimpulkan.
AQE dapat membantu menangani skew untuk jenis join dan kondisi tertentu, tetapi bukan solusi otomatis bagi semua agregasi atau semua bentuk data. Teknik seperti memberi salt pada kunci memerlukan penggabungan ulang hasil yang benar dan dapat memperbesar pekerjaan. Terapkan hanya setelah memahami semantik agregasi, mengukur distribusi, serta menguji kesetaraan hasil dengan baseline.
Memilih broadcast join dengan aman
Ketika satu tabel join cukup kecil, Spark dapat mengirim salinannya ke setiap executor agar sisi besar tidak perlu di-shuffle dengan cara yang sama seperti pada sejumlah strategi join lain. Pada mode lokal, manfaat dan biaya tetap bergantung pada rencana serta memori proses yang tersedia. Ukuran berkas di disk bukan ukuran pasti tabel setelah didekompresi dan dibangun menjadi struktur join di memori.
Memaksa petunjuk hanya setelah memeriksa ukuran
Contoh ini menggunakan petunjuk broadcast untuk dimensi produk yang diasumsikan kecil. Pastikan kolom kunci dan atribut yang dibutuhkan tersedia serta data dimensi tidak memiliki duplikasi yang tidak diharapkan. Duplikasi kunci dapat memperbanyak baris hasil join; itu persoalan kualitas data, bukan perbaikan yang boleh disembunyikan oleh tuning.
produk_kecil = dimensi.select("produk_id", "kategori")
hasil_join = transaksi_terpilih.join(
F.broadcast(produk_kecil), on="produk_id", how="inner"
)
hasil_join.explain("formatted")
hasil_join.write.mode("errorifexists").parquet("output/join_uji_01")
Periksa apakah rencana yang benar-benar dieksekusi menggunakan BroadcastHashJoin atau strategi lain; petunjuk tidak menjamin setiap jenis join mendukung strategi yang diminta. Spark juga dapat memilih broadcast secara otomatis berdasarkan statistik dan ambang yang berlaku. Memaksakan tabel yang terlalu besar berisiko menyebabkan tekanan memori, timeout, atau kegagalan job. Jika statistik tidak akurat, validasi dengan metrik dan ukuran aktual sebelum mengambil keputusan.
Membaca Spark UI dan membandingkan eksperimen
Saat aplikasi berjalan, buka Spark UI melalui alamat yang dicatat oleh Spark, lazimnya port 4040 untuk aplikasi pertama yang tersedia. Tab SQL menampilkan query dan rencananya; tab Stages dan Jobs membantu menelusuri task serta metrik shuffle. Ketersediaan halaman setelah aplikasi berhenti bergantung pada konfigurasi event log dan History Server. Hindari mengekspos UI ke jaringan publik karena informasi job dapat bersifat sensitif.
Untuk setiap percobaan, dokumentasikan konfigurasi, rencana, durasi action, shuffle read/write, spill, serta rentang durasi task. Bandingkan juga jumlah baris dan hasil agregasi dengan baseline. Perhatikan nilai null pada kunci join dan jenis join yang dipakai: perubahan dari inner ke left, misalnya, mengubah hasil dan bukan sekadar optimasi performa. Jika hasil berbeda, selidiki dahulu kebenarannya sebelum membahas kecepatan.
Urutan eksperimen yang berguna adalah baseline, penyesuaian partisi, evaluasi filter dan proyeksi, lalu uji broadcast bila dimensinya memang kecil. Kembalikan konfigurasi sebelumnya sebelum menguji variabel lain. Setelah menemukan kandidat yang menjanjikan, ulangi dalam beberapa kondisi beban yang realistis dan periksa apakah manfaatnya konsisten. Catatan kegagalan dan kondisi yang menyebabkan spill sama berharganya dengan catatan keberhasilan.
Batas contoh dan langkah berikutnya
Contoh di atas adalah rancangan lab lokal, bukan laporan benchmark. Pipeline, dataset, waktu proses, konsumsi memori, dan rencana eksekusi tersebut belum diuji dalam lingkungan pembaca maupun pada cluster produksi untuk artikel ini. Tidak ada klaim persentase peningkatan. Perilaku sebenarnya juga dapat berubah antarversi Spark dan jenis sumber data; sesuaikan pengaturan dengan dokumentasi versi yang terpasang.
Langkah berikutnya adalah menjalankan satu eksperimen yang dapat diulang pada data representatif, menyimpan metrik, dan memeriksa akurasi hasil. Jika pipeline akan dipindahkan ke cluster, ulangi pengukuran dengan konfigurasi executor, jaringan, penyimpanan, dan beban bersama yang sesuai. Praktik lokal memberi pemahaman awal, tetapi keputusan produksi memerlukan bukti dari lingkungan target.
Rujukan resmi: Spark Tuning Guide, Spark SQL Performance Tuning, dan Spark Web UI.
COMMENTS