Belajar Apache Spark - Resource Management & Deployment

#Pendahuluan

Job yang berjalan di laptop tidak cukup untuk produksi. Episode 14 ini membahas bagaimana Spark dideploy ke cluster sungguhan dan bagaimana resource dialokasikan secara efisien di antara banyak aplikasi. Ini adalah jembatan dari development menuju operasional.

Pilihan cluster manager menentukan cara resource dibagi, bagaimana job dijadwalkan, dan bagaimana pemulihan kegagalan terjadi. Sementara itu, konfigurasi executor menentukan berapa besar paralelisme — dan berapa besar tagihan cloud. Keduanya harus dikelola secara sadar.

Episode ini membahas empat topik: opsi deployment standalone, YARN, Mesos, dan Kubernetes; pola Spark on Kubernetes; pengelolaan executors, cores, dan memory; serta dynamic allocation dan workload isolation.

#Opsi Deployment: Standalone, YARN, Mesos, dan Kubernetes

#Standalone

Standalone adalah cluster manager bawaan Spark. Sederhana dan mudah di-debug — cocok untuk development dan cluster kecil. Jalankan master dan worker:

/opt/spark/sbin/start-master.sh
/opt/spark/sbin/start-worker.sh spark://localhost:7077

Lalu submit dengan spark-submit --master spark://localhost:7077. Kekurangannya: tidak ada isolation multi-tenant yang ketat dan fitur keamanan terbatas.

#YARN dan Mesos

YARN adalah cluster manager ekosistem Hadoop yang membagi resource berdasarkan container. Cocok jika infrastruktur kalian sudah memakai HDFS dan ekosistem Hadoop. Mesos mendukung workload campuran, namun adopsinya terus menurun dan jarang dipilih untuk proyek baru.

spark-submit --master yarn --deploy-mode cluster job.py

#Kubernetes

Kubernetes menjadi pilihan utama untuk proyek modern karena penyediaan resource, scaling, dan ekosistemnya yang matang. Spark 3+ mendukung Kubernetes sebagai cluster manager native, di mana driver dan executors berjalan sebagai pod.

#Spark on Kubernetes: Pola dan Pod Management

#Cara Kerja

Saat submit ke Kubernetes, Spark membuat pod driver di namespace tertentu, dan driver kemudian me-request executor pods sesuai kebutuhan:

spark-submit \
  --master k8s://https://k8s-api.example.com \
  --deploy-mode cluster \
  --conf spark.kubernetes.container.image=registry/app/spark:4.0.0 \
  --conf spark.kubernetes.namespace=spark-jobs \
  --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark-sa \
  job.py

--master k8s://... mengarahkan Spark ke API Kubernetes. Image Spark harus sudah dibuat — biasanya dari image dasar yang menambahkan library aplikasi dan kredensial yang diperlukan.

#Pola yang Direkomendasikan

Beberapa pola yang perlu diperhatikan:

• Pod template: kustomisasi pod dengan tolerations, node selector, atau volume lewat spark.kubernetes.driver.podTemplateFile.
• ServiceAccount terpisah untuk Spark agar tidak memberi akses berlebih.
• Dynamic allocation dengan executor yang dibuat dan dihapus sesuai kebutuhan (lihat bagian akhir).
• RBAC: batasi API yang bisa diakses pod Spark melalui Role dan RoleBinding.

driver pod → request executor pods → executors jalankan task → hasil kembali

#Mengelola Executors, Cores, dan Memory

#Menentukan Ukuran Executor

Dua formula praktis saat men-set executor:

spark-submit \
  --executor-memory 8g \
  --executor-cores 4 \
  --num-executors 20 \
  job.py

Aturan umum: simpan overhead JVM sekitar 10-15 persen di atas --executor-memory, dan batasi --executor-cores agar tidak memonopoli node. Misalnya untuk node dengan 64GB RAM dan 16 core, delapan executor dengan 8GB dan 2 core adalah pembagian yang wajar.

#Menghindari Ketimpangan

• Jangan terlalu kecil: banyak executor kecil berarti banyak overhead scheduling.
• Jangan terlalu besar: executor raksasa mempersulit co-location aplikasi lain dan memperbesar risiko gagal.
• Sesuaikan shuffle partitions dengan total core: spark.sql.shuffle.partitions sekitar 2-3 kali total core adalah titik awal yang baik.

#Dynamic Allocation dan Workload Isolation

#Dynamic Allocation

Dengan dynamic allocation, Spark menambah dan mengurangi executor secara otomatis berdasarkan beban:

spark.dynamicAllocation.enabled      true
spark.dynamicAllocation.shuffleTracking.enabled true
spark.dynamicAllocation.initialExecutors 2
spark.dynamicAllocation.maxExecutors 40

spark.dynamicAllocation.maxExecutors membatasi eksekutor maksimal agar tidak menghabiskan seluruh cluster. Fitur ini sangat berguna di environment multi-tenant: job yang menganggur melepas executor, dan yang membutuhkan mendapatkannya kembali saat load naik.

#Workload Isolation

Untuk mencegah satu job memboroskan resource bersama:

• Limit eksekutor: tetapkan batas atas yang eksplisit, jangan serahkan semuanya ke scheduler.
• Namespace/queue terpisah: pisahkan job batch dan streaming di queue YARN atau namespace Kubernetes yang berbeda.
• Prioritas: gunakan pool scheduling (misalnya spark.scheduler.pool) agar job penting dilayani lebih dulu.
• Kubernetes ResourceQuota: batasi total CPU dan memori per namespace Spark.

queue batch (40%)  → ETL harian, bounded concurrency
queue streaming (30%) → pipeline real-time, prioritas tinggi
queue ad-hoc (30%) → eksperimen analis, batas max executor rendah

#Penutup

Episode 14 membawa kalian ke ranah operasional: Standalone cocok untuk sederhana, YARN untuk ekosistem Hadoop, Kubernetes untuk modern dan cloud-native. Kalian juga memahami cara menentukan ukuran executor, memanfaatkan dynamic allocation, dan menjaga workload isolation agar satu job tidak mengganggu yang lain.

Inti yang harus dibawa pulang:

• Standalone untuk development, YARN untuk ekosistem Hadoop, Kubernetes untuk cloud-native.
• Spark on Kubernetes menjalankan driver dan executors sebagai pod.
• Ukuran executor harus menyeimbangkan memori, cores, dan overhead JVM.
• Dynamic allocation menyesuaikan executor dengan beban aktual.
• Workload isolation memakai queue, namespace, dan batas executor eksplisit.

Di episode 15 selanjutnya kita akan membahas advanced SQL dan analytics — CTE, subqueries, dan nested queries, UDF dan UDAF, spatial dan graph analytics dengan advanced windowing, serta integrasi dengan Delta Lake dan Iceberg.