Apa yang dimaksud dengan pekerja, pelaksana, inti dalam kluster Spark Standalone?

Saya membaca Ikhtisar Mode Cluster dan saya masih tidak dapat memahami proses yang berbeda di cluster Standalone Spark dan paralelisme.

Apakah pekerja itu proses JVM atau tidak? Saya menjalankan bin\start-slave.shdan menemukan bahwa itu memunculkan pekerja, yang sebenarnya adalah JVM.

Sesuai tautan di atas, pelaksana adalah proses yang diluncurkan untuk aplikasi pada simpul pekerja yang menjalankan tugas. Seorang pelaksana juga seorang JVM.

Ini adalah pertanyaan saya:

1. Pelaksana adalah per aplikasi. Lalu apa peran pekerja? Apakah itu berkoordinasi dengan pelaksana dan mengkomunikasikan hasilnya kembali ke pengemudi? Atau apakah pengemudi langsung berbicara dengan pelaksana? Kalau begitu, apa tujuan pekerja itu?

2. Bagaimana cara mengontrol jumlah pelaksana untuk suatu aplikasi?

3. Bisakah tugas dilakukan untuk berjalan secara paralel di dalam pelaksana? Jika demikian, bagaimana cara mengkonfigurasi jumlah utas untuk pelaksana?

4. Apa hubungan antara pekerja, pelaksana dan inti pelaksana (--total-pelaksana-inti)?

5. Apa artinya memiliki lebih banyak pekerja per node?

Diperbarui

Mari kita ambil contoh untuk memahami lebih baik.

Contoh 1: Cluster mandiri dengan 5 node pekerja (setiap node memiliki 8 core) Ketika saya memulai aplikasi dengan pengaturan default.

Contoh 2 Konfigurasi cluster yang sama seperti contoh 1, tetapi saya menjalankan aplikasi dengan pengaturan berikut --executor-core 10 --total-executor-core 10.

Contoh 3 Konfigurasi cluster yang sama seperti contoh 1, tetapi saya menjalankan aplikasi dengan pengaturan berikut --executor-core 10 --total-executor-core 50.

Contoh 4 Konfigurasi cluster yang sama dengan contoh 1, tetapi saya menjalankan aplikasi dengan pengaturan berikut --executor-core 50 --total-executor-core 50.

Contoh 5 Konfigurasi cluster yang sama seperti contoh 1, tetapi saya menjalankan aplikasi dengan pengaturan berikut --executor-core 50 --total-executor-core 10.

Dalam masing-masing contoh ini, Berapa banyak pelaksana? Berapa banyak utas per pelaksana? Berapa core? Bagaimana jumlah pelaksana diputuskan per aplikasi? Apakah selalu sama dengan jumlah pekerja?

Spark menggunakan arsitektur master / slave. Seperti yang Anda lihat pada gambar, ia memiliki satu koordinator pusat (Pengemudi) yang berkomunikasi dengan banyak pekerja terdistribusi (pelaksana). Driver dan masing-masing pelaksana berjalan dalam proses Java mereka sendiri.

SOPIR

Driver adalah proses di mana metode utama berjalan. Pertama mengubah program pengguna menjadi tugas dan setelah itu menjadwalkan tugas pada pelaksana.

Pengajar

Pelaksana adalah proses simpul pekerja yang bertugas menjalankan tugas individu dalam pekerjaan Spark yang diberikan. Mereka diluncurkan pada awal aplikasi Spark dan biasanya berjalan selama seumur hidup aplikasi. Setelah mereka menjalankan tugas, mereka mengirim hasilnya ke pengemudi. Mereka juga menyediakan penyimpanan dalam-memori untuk RDD yang di-cache oleh program-program pengguna melalui Block Manager.

ALIRAN PELAKSANAAN APLIKASI

Dengan mengingat hal ini, ketika Anda mengirimkan aplikasi ke kluster dengan percikan-kirim, inilah yang terjadi secara internal:

1. Aplikasi mandiri memulai dan membuat SparkContextinstance (dan hanya saat itulah Anda dapat memanggil aplikasi driver).
2. Program driver meminta sumber daya ke manajer kluster untuk meluncurkan pelaksana.
3. Manajer kluster meluncurkan pelaksana.
4. Proses driver dijalankan melalui aplikasi pengguna. Bergantung pada tindakan dan transformasi atas tugas RDD dikirim ke pelaksana.
5. Pelaksana menjalankan tugas dan menyimpan hasilnya.
6. Jika ada pekerja mogok, tugasnya akan dikirim ke pelaksana yang berbeda untuk diproses lagi. Dalam buku "Learning Spark: Lightning-Fast Big Data Analysis" mereka berbicara tentang Spark dan Fault Tolerance:

Spark secara otomatis menangani mesin yang gagal atau lambat dengan menjalankan kembali tugas yang gagal atau lambat. Misalnya, jika simpul yang menjalankan partisi dari operasi map () macet, Spark akan menjalankannya kembali di simpul lain; dan bahkan jika node tidak crash tetapi hanya jauh lebih lambat daripada node lain, Spark dapat terlebih dahulu meluncurkan salinan "spekulatif" dari tugas pada node lain, dan mengambil hasilnya jika selesai.

7. Dengan SparkContext.stop () dari driver atau jika metode utama keluar / lumpuh semua pelaksana akan dihentikan dan sumber daya gugus akan dirilis oleh manajer gugus.

PERTANYAAN ANDA

1. Ketika pelaksana dimulai, mereka mendaftarkan diri dengan pengemudi dan mulai berkomunikasi langsung. Para pekerja bertugas mengkomunikasikan kepada manajer klaster tentang ketersediaan sumber daya mereka.

2. Dalam gugus BENANG Anda bisa melakukannya dengan --num-executors. Dalam sebuah cluster mandiri Anda akan mendapatkan satu eksekutor per pekerja kecuali jika Anda bermain dengan spark.executor.cores dan seorang pekerja memiliki core yang cukup untuk menampung lebih dari satu eksekutor. (Seperti yang ditunjukkan @JacekLaskowski, --num-executors tidak lagi digunakan di BENANG https://github.com/apache/spark/commit/16b6d18613e150c7038c613992d80a7828413e66 )

3. Anda dapat menetapkan jumlah inti per eksekutor dengan --executor-core

4. --total-executor-core adalah jumlah maksimal core executor per aplikasi

5. Seperti dikatakan Sean Owen di utas ini : "tidak ada alasan yang baik untuk menjalankan lebih dari satu pekerja per mesin". Anda akan memiliki banyak JVM yang duduk di satu mesin misalnya.

MEMPERBARUI

Saya belum bisa menguji skenario ini, tetapi menurut dokumentasi:

CONTOH 1: Spark akan dengan rakus memperoleh inti dan pelaksana sebanyak yang ditawarkan oleh penjadwal. Jadi pada akhirnya Anda akan mendapatkan 5 eksekutor dengan masing-masing 8 core.

CONTOH 2 sampai 5: Spark tidak akan dapat mengalokasikan core sebanyak yang diminta dalam satu pekerja, karenanya tidak ada pelaksana yang akan diluncurkan.

Inilah cara Apache Spark bekerja secara internal: