Cara menjalankan Apache Spark di Kubernetes dalam waktu kurang dari 5 menit

Alat seperti Ilum akan sangat membantu dalam menyederhanakan proses penginstalan Apache Spark di Kubernetes. Panduan ini akan membawa Anda, langkah demi langkah, cara menjalankan Spark dengan baik di kluster Kubernetes Anda. Dengan Ilum, menyebarkan, mengelola, dan menskalakan klaster Apache Spark dilakukan dengan mudah dan alami.

Perkenalan

Hari ini, kami akan menunjukkan cara memulai dan menjalankan Apache Spark di K8s. Ada banyak cara untuk melakukannya, tetapi sebagian besar kompleks dan membutuhkan beberapa konfigurasi. Kami akan menggunakan Ilum karena itu akan melakukan semua pengaturan cluster untuk kita. Dalam posting blog berikutnya, kita akan membandingkan penggunaannya dengan operator Spark.

Ilum adalah datalake modular gratis untuk menyebarkan dan mengelola kluster Apache Spark dengan mudah. Ini memiliki API sederhana untuk menentukan dan mengelola Spark, itu akan menangani semua dependensi. Ini membantu dengan pembuatan percikan terkelola Anda sendiri.

Dengan Ilum, Anda dapat menyebarkan kluster Spark dalam hitungan menit dan segera mulai menjalankan aplikasi Spark. Ilum memungkinkan Anda untuk dengan mudah menskalakan dan di kluster Spark, mengelola beberapa kluster Spark dari satu UI.

Dengan Ilum, memulai menjadi mudah jika Anda relatif baru mengenal Apache Spark di Kubernetes.

Panduan Langkah demi Langkah untuk Menginstal Apache Spark di Kubernetes

Mulai cepat

Kami berasumsi bahwa Anda memiliki kluster Kubernetes yang aktif dan berjalan, untuk berjaga-jaga jika tidak, lihat petunjuk ini untuk menyiapkan kluster Kubernetes di minikube. Periksa cara menginstal minikube .

Menyiapkan kluster kubernetes lokal

• Instal Minikube: Jalankan perintah berikut untuk menginstal Minikube bersama dengan sumber daya yang direkomendasikan. Ini akan menginstal Minikube dengan 6 vCPU dan memori 12288 MB termasuk add-on server metrik yang diperlukan untuk pemantauan.

minikube mulai --cpus 6 --memori 12288 --addons metrics-server 

Setelah Anda memiliki kluster Kubernetes yang sedang berjalan, hanya beberapa perintah lagi untuk menginstal Ilum:

Instal Spark di Kubernetes dengan Ilum

1. Tambah Repositori Ilum Helm

helm repo add ilum https://charts.ilum.cloud 

2. Instal Ilum di Cluster Anda

Helm install dan ile/el 

Pengaturan ini akan memakan waktu sekitar dua menit. Ilum akan menyebarkan ke kluster Kubernetes Anda, mempersiapkannya untuk menangani pekerjaan Spark.

Setelah Ilum diinstal, Anda dapat mengakses UI dengan port-forward dan localhost:9777.

3. Port Forward untuk Mengakses UI: Gunakan penerusan port Kubernetes untuk mengakses UI Ilum.

kubectl port-forward svc/ilum-ui 9777:9777 

Pakai admin/admin sebagai kredensial default. Anda dapat mengubahnya selama Proses penerapan .

Itu saja, kluster kubernetes Anda sekarang dikonfigurasi untuk menangani pekerjaan percikan. Ilum menyediakan API dan UI sederhana yang memudahkan untuk mengirimkan aplikasi Spark. Anda juga dapat menggunakan yang lama Kirim Spark .

Menyebarkan aplikasi spark di kubernetes

Sekarang mari kita mulai pekerjaan percikan sederhana. Kita akan menggunakan contoh "SparkPi" dari Spark dokumentasi . Anda dapat menggunakan file jar dari ini tautan .

Ilum akan membuat pod kubernetes driver Spark, menggunakan gambar docker versi 3.x spark. Anda dapat mengontrol jumlah pod pelaksana percikan dengan menskalakannya ke beberapa simpul. Itulah cara paling sederhana untuk mengajukan aplikasi percikan ke K8.

Menjalankan Spark di Kubernetes sangat mudah dan tanpa gesekan dengan Ilum. Ini akan mengonfigurasi seluruh klaster Anda dan memberi Anda antarmuka tempat Anda dapat mengelola dan memantau kluster Spark Anda. Kami percaya aplikasi percikan di Kubernetes adalah masa depan data besar. Dengan Kubernetes, aplikasi Spark akan dapat menangani data dalam jumlah besar dengan jauh lebih andal, sehingga memberikan wawasan yang tepat dan dapat mendorong keputusan dengan data besar.

Mengirimkan Aplikasi Spark ke Kubernetes (gaya lama)

Mengirimkan pekerjaan Spark ke kluster Kubernetes melibatkan penggunaan percikan-kirim skrip dengan konfigurasi khusus untuk Kubernetes. Berikut panduan langkah demi langkah:

Langkah :

1. Siapkan Aplikasi Spark : Kemas aplikasi Spark Anda ke dalam file JAR (untuk Scala/Java) atau skrip Python.

2. Pakai percikan-kirim untuk Menyebarkan : Jalankan metode percikan-kirim dengan opsi khusus Kubernetes:

   ./bin/spark-submit \
     --master k8s://https://<k8s-apiserver-host>:<k8s-apiserver-port> \
     --deploy-mode cluster \
     --nama spark-app \
     --class org.apache.spark.examples.SparkPi \
     --conf spark.executor.instances=3 \
     --conf spark.kubernetes.container.image=<your-spark-image> \
     local:///path/to/your-app.jar 

   Mengganti:

   • <k8s-apiserver-host> : Host server API Kubernetes Anda.
   • <k8s-apiserver-port> : Port server API Kubernetes Anda.
   • <your-spark-image> : Gambar Docker yang berisi Spark.
   • local:///path/to/your-app.jar : Jalur ke JAR aplikasi Anda dalam gambar Docker.

Konfigurasi Utama :

• --tuan : Menentukan URL API Kubernetes.
• --deploy-mode : Atur ke kelompok untuk menjalankan driver di dalam kluster Kubernetes.
• --Nama : Memberi nama aplikasi Spark Anda.
• --kelas : Kelas utama aplikasi Anda.
• --conf spark.executor.instances : Jumlah pod eksekutor.
• --conf spark.kubernetes.container.image : Gambar Docker untuk pod Spark.

Untuk detail selengkapnya, lihat Dokumentasi Apache Spark tentang Berjalan di Kubernetes .

2. Membuat Gambar Docker Kustom untuk Spark

Membangun gambar Docker kustom memungkinkan Anda mengemas aplikasi Spark dan dependensinya, memastikan konsistensi di seluruh lingkungan.

Langkah :

1. Membuat Dockerfile : Tentukan lingkungan dan dependensi.

   # Gunakan gambar dasar resmi Spark
   DARI percikan api:3.5.3
   
   # Atur variabel lingkungan
   ENV SPARK_HOME=/opt/percikan
   ENV PATH=$PATH:$SPARK_HOME/bin
   
   # Salin JAR aplikasi Anda ke dalam gambar
   SALIN your-app.jar $SPARK_HOME/examples/jars/
   
   # Atur titik masuk untuk menjalankan aplikasi Anda
   ENTRYPOINT ["spark-submit", "--class", "org.apache.spark.examples.SparkPi", "--master", "local[4]", "/opt/spark/examples/jars/your-app.jar"] 

   Dalam Dockerfile ini:

   • DARI percikan api:3.5.3 : Menggunakan gambar Spark resmi sebagai dasar.
   • ENV : Mengatur variabel lingkungan untuk Spark.
   • MENYALIN : Menambahkan JAR aplikasi Anda ke gambar.
   • TITIK MASUK : Menentukan perintah default untuk menjalankan aplikasi Spark Anda.

2. Membangun Gambar Docker : Gunakan Docker untuk membuat gambar Anda.

   docker build -t your-repo/your-spark-app:latest . 

   Mengganti repo-Anda/aplikasi-percikan Anda dengan repositori Docker dan nama gambar Anda.

3. Dorong Gambar ke Registri : Unggah gambar Anda ke registri Docker yang dapat diakses oleh kluster Kubernetes Anda.

   Docker push your-repo/your-spark-app:terbaru 

Saat menggunakan percikan-kirim adalah metode umum untuk menerapkan aplikasi Spark, ini mungkin bukan pendekatan yang paling efisien untuk lingkungan produksi. Pengiriman manual dapat menyebabkan inkonsistensi dan sulit untuk diintegrasikan ke dalam alur kerja otomatis. Untuk meningkatkan efisiensi dan pemeliharaan, disarankan untuk memanfaatkan REST API Ilum.

Mengotomatiskan Penerapan Spark dengan REST API Ilum

Ilum menawarkan API RESTful yang kuat yang memungkinkan interaksi tanpa batas dengan kluster Spark. API ini memfasilitasi otomatisasi pengiriman, pemantauan, dan manajemen pekerjaan, menjadikannya pilihan ideal untuk alur Integrasi Berkelanjutan/Penerapan Berkelanjutan (CI/CD).

Manfaat Menggunakan REST API Ilum:

• Otomatisasi : Mengintegrasikan pengiriman pekerjaan Spark ke dalam alur CI/CD, mengurangi intervensi manual dan potensi kesalahan.
• Konsistensi : Pastikan proses penerapan yang seragam di berbagai lingkungan.
• Skalabilitas : Kelola beberapa kluster dan pekerjaan Spark dengan mudah secara terprogram.

Contoh: Mengirimkan Pekerjaan Spark melalui REST API Ilum

Untuk mengirimkan pekerjaan Spark menggunakan REST API Ilum, Anda dapat membuat permintaan HTTP POST dengan parameter yang diperlukan. Berikut adalah contoh sederhana menggunakan Curl :

curl -X POST https://<ilum-server>/api/v1/job/submit \
  -H "Tipe Konten: multipart/formulir-data" \
  -F "nama=contoh-pekerjaan" \
  -F "clusterName=default" \
  -F "jobClass=org.apache.spark.examples.SparkPi" \
  -F "jars=@/path/to/your-app.jar" \
  -F "jobConfig=spark.executor.instances=3; percikan.pelaksana.memori = 4g" 

Dalam perintah ini:

• Nama : Menentukan nama pekerjaan.
• clusterName : Menunjukkan kluster target.
• jobClass : Menentukan kelas utama aplikasi Spark Anda.
• Jars : Mengunggah file JAR aplikasi Anda.
• jobConfig : Mengatur konfigurasi Spark, seperti jumlah eksekutor dan alokasi memori.

Untuk informasi terperinci tentang titik akhir dan parameter API, lihat Dokumentasi API Ilum .

Meningkatkan Efisiensi dengan Pekerjaan Spark Interaktif

Selain mengotomatiskan pengiriman pekerjaan, mengubah pekerjaan Spark menjadi layanan mikro interaktif dapat secara signifikan mengoptimalkan pemanfaatan sumber daya dan waktu respons. Ilum mendukung pembuatan sesi Spark interaktif yang berjalan lama yang dapat memproses data real-time tanpa overhead untuk menginisialisasi konteks Spark baru untuk setiap permintaan.

Keuntungan dari Pekerjaan Spark Interaktif:

• Mengurangi Latensi : Menghilangkan kebutuhan untuk memulai konteks Spark baru untuk setiap pekerjaan, yang mengarah ke eksekusi yang lebih cepat.
• Pengoptimalan Sumber Daya : Mempertahankan konteks Spark yang persisten, memungkinkan manajemen sumber daya yang efisien.
• Skalabilitas : Menangani beberapa permintaan secara bersamaan dalam sesi Spark yang sama.

Untuk mengimplementasikan pekerjaan Spark interaktif dengan Ilum, Anda dapat menentukan aplikasi Spark yang mendengarkan data yang masuk dan memprosesnya secara real-time. Pendekatan ini sangat bermanfaat untuk aplikasi yang membutuhkan pemrosesan dan respons data segera.

Untuk panduan komprehensif tentang menyiapkan pekerjaan Spark interaktif dan mengoptimalkan kluster Spark Anda, lihat posting blog Ilum: Cara Mengoptimalkan Klaster Spark Anda dengan Pekerjaan Spark Interaktif .

Dengan mengintegrasikan REST API Ilum dan mengadopsi pekerjaan Spark interaktif, Anda dapat merampingkan alur kerja Spark, meningkatkan otomatisasi, dan mencapai lingkungan pemrosesan data yang lebih efisien dan terukur.

Keuntungan Menggunakan Ilum untuk menjalankan Spark di Kubernetes

Ilum dilengkapi dengan UI intuitif dan API yang tangguh untuk menskalakan dan menangani kluster Spark, mengonfigurasi beberapa aplikasi Spark dari satu antarmuka. Berikut adalah beberapa fitur hebat dalam hal itu:

1. Kemudahan Penggunaan : Ilum menyederhanakan konfigurasi dan pengelolaan Spark di Kubernetes dengan UI Spark yang intuitif, menghilangkan proses penyiapan yang rumit.
2. Penerapan Cepat: Siapkan, sebarkan, dan skalakan klaster Spark dalam hitungan menit untuk mempercepat waktu eksekusi dan pengujian aplikasi segera.
3. Skalabilitas: Dengan menggunakan API Kubernetes, skalakan kluster Spark dengan mudah untuk memenuhi kebutuhan pemrosesan data Anda, memastikan pemanfaatan sumber daya yang optimal.
4. Modularitas : Ilum hadir dengan kerangka kerja modular yang memungkinkan pengguna untuk memilih dan menggabungkan berbagai komponen seperti Spark History Server, Apache Jupyter, Minio, dan banyak lagi.

Bermigrasi dari Benang Apache Hadoop

Sekarang Apache Hadoop Yarn berada dalam stagnasi yang dalam, semakin banyak organisasi yang ingin bermigrasi dari Yarn ke Kubernetes. Hal ini dikaitkan dengan beberapa alasan, tetapi yang paling umum adalah bahwa Kubernetes menyediakan platform yang lebih tangguh dan fleksibel dalam hal mengelola beban kerja Big Data.

Umumnya, sulit untuk melakukan migrasi platform platform pemrosesan data dari Apache Hadoop Yarn ke yang lain. Ada banyak faktor yang perlu dipertimbangkan ketika pergantian semacam itu dilakukan—kompatibilitas data, kecepatan, dan biaya pemrosesan. Namun, itu akan berjalan lancar dan berhasil jika prosedurnya direncanakan dan dilaksanakan dengan baik.

Kubernetes cukup cocok dalam hal beban kerja Big Data karena kemampuannya yang melekat untuk dapat menskalakan secara horizontal. Namun, dengan Hadoop Yarn, Anda dibatasi pada jumlah node di cluster Anda. Anda dapat menambah dan mengurangi jumlah simpul di dalam kluster Kubernetes sesuai permintaan.

Ini juga memungkinkan fitur yang tidak tersedia di Yarn, misalnya: penyembuhan diri dan penskalaan horizontal.

Saatnya Beralih ke Kubernetes?

Seiring dengan berkembangnya dunia big data, begitu pula alat dan teknologi yang digunakan untuk mengelolanya. Selama bertahun-tahun, Apache Hadoop YARN telah menjadi standar de facto untuk manajemen sumber daya di lingkungan data besar. Tetapi dengan munculnya teknologi kontainerisasi dan orkestrasi seperti Kubernetes, apakah sudah waktunya untuk beralih?

Kubernetes telah mendapatkan popularitas sebagai platform orkestrasi kontainer, dan untuk alasan yang bagus. Ini fleksibel, dapat diskalakan, dan relatif mudah digunakan. Jika Anda masih menggunakan infrastruktur berbasis VM tradisional, sekarang mungkin saatnya untuk beralih ke Kubernetes.

Jika Anda bekerja dengan kontainer, maka Anda harus peduli dengan Kubernetes. Ini dapat membantu Anda mengelola dan menyebarkan kontainer dengan lebih efektif, dan ini sangat berguna jika Anda bekerja dengan banyak kontainer atau jika Anda menyebarkan kontainer ke platform cloud.

Kubernetes juga merupakan pilihan tepat jika Anda mencari alat orkestrasi yang didukung oleh perusahaan teknologi besar. Google telah menggunakan Kubernetes selama bertahun-tahun untuk mengelola aplikasi kontainernya sendiri, dan mereka telah menginvestasikan banyak waktu dan sumber daya untuk menjadikannya alat yang hebat.

Tidak ada pemenang yang jelas dalam debat YARN vs. Kubernetes. Solusi terbaik untuk organisasi Anda akan bergantung pada kebutuhan spesifik dan kasus penggunaan Anda. Jika Anda mencari solusi manajemen sumber daya yang lebih fleksibel dan terukur, Kubernetes patut dipertimbangkan. Jika Anda memerlukan dukungan yang lebih baik untuk aplikasi lama, YARN mungkin merupakan pilihan yang lebih baik.

Platform apa pun yang Anda pilih, Ilum dapat membantu Anda memaksimalkannya. Platform kami dirancang untuk bekerja dengan YARN dan Kubernetes, dan tim ahli kami dapat membantu Anda memilih dan menerapkan solusi yang tepat untuk organisasi Anda.

Kluster Spark terkelola

Kluster Spark terkelola adalah solusi berbasis cloud yang memudahkan penyediaan dan pengelolaan kluster Spark. Ini menyediakan antarmuka berbasis web untuk membuat dan mengelola kluster Spark, serta serangkaian API untuk mengotomatiskan tugas manajemen kluster. Kluster Spark Terkelola sering digunakan oleh ilmuwan dan pengembang data yang ingin menyediakan dan mengelola kluster Spark dengan cepat tanpa harus khawatir tentang infrastruktur yang mendasarinya.

Ilum menyediakan kemampuan untuk membuat dan mengelola kluster spark Anda sendiri, yang dapat dijalankan di lingkungan apa pun, termasuk cloud, lokal, atau campuran keduanya.

Kelebihan Apache Spark di Kubernetes

Ada beberapa perdebatan tentang apakah Apache Spark harus berjalan di Kubernetes.

Beberapa orang berpendapat bahwa Kubernetes terlalu kompleks dan bahwa Spark harus terus berjalan pada manajer kluster khususnya sendiri atau tetap berada di cloud. Yang lain berpendapat bahwa Kubernetes adalah masa depan pemrosesan data besar dan bahwa Spark harus menerimanya.

Kami berada di kubu terakhir. Kami percaya bahwa Kubernetes adalah masa depan pemrosesan data besar dan bahwa Apache Spark harus berjalan di Kubernetes.

Manfaat terbesar menggunakan Spark di Kubernetes adalah memungkinkan penskalaan aplikasi Spark yang jauh lebih mudah. Ini karena Kubernetes dirancang untuk menangani penyebaran sejumlah besar kontainer bersamaan. Jadi, jika Anda memiliki aplikasi Spark yang perlu memproses banyak data, Anda cukup menyebarkan lebih banyak kontainer ke klaster Kubernetes untuk memproses data secara paralel. Ini jauh lebih mudah daripada menyiapkan kluster Spark baru di EMR setiap kali Anda perlu meningkatkan skala pemrosesan Anda. Anda dapat menjalankannya di platform cloud apa pun (AWS, Google Cloud, Azure, dll.) atau lokal. Ini berarti Anda dapat dengan mudah memindahkan aplikasi Spark dari satu lingkungan ke lingkungan lain tanpa harus khawatir mengubah pengelola klaster Anda.

Manfaat besar lainnya adalah memungkinkan alur kerja yang lebih fleksibel. Misalnya, jika Anda perlu memproses data dari beberapa sumber, Anda dapat dengan mudah menyebarkan kontainer yang berbeda untuk setiap sumber dan memproses semuanya secara paralel. Ini jauh lebih mudah daripada mencoba mengelola alur kerja yang kompleks pada satu kluster Spark.

Kubernetes memiliki beberapa fitur keamanan yang menjadikannya opsi yang lebih menarik untuk menjalankan aplikasi Spark. Misalnya, Kubernetes mendukung kontrol akses berbasis peran, yang memungkinkan Anda menyempurnakan siapa yang memiliki akses ke kluster Spark Anda.

Jadi begitulah. Ini hanyalah beberapa alasan mengapa kami percaya bahwa Apache Spark harus berjalan di Kubernetes. Jika Anda tidak yakin, kami mendorong Anda untuk mencobanya sendiri. Kami pikir Anda akan terkejut melihat seberapa baik cara kerjanya.

Sumber Daya Tambahan

• Periksa cara menginstal Minikube
• Dokumentasi Kubernetes
• Situs Resmi Ilum
• Dokumentasi Resmi Ilum
• Bagan Helm Ilum

Kesimpulan

Ilum menyederhanakan proses penginstalan dan pengelolaan Apache Spark di Kubernetes, menjadikannya pilihan ideal untuk pemula dan pengguna berpengalaman. Dengan mengikuti panduan ini, Anda akan memiliki kluster Spark fungsional yang berjalan di Kubernetes dalam waktu singkat.