แรงงาน, ผู้บริหาร, แกนในคลัสเตอร์ Spark Standalone คืออะไร?

ฉันอ่านCluster Mode Overviewและฉันยังคงไม่เข้าใจกระบวนการต่าง ๆ ในคลัสเตอร์ Spark Standaloneและการขนานกัน

ผู้ปฏิบัติงานเป็นกระบวนการ JVM หรือไม่ ฉันวิ่งbin\start-slave.shและพบว่ามันกลับกลายเป็นคนงานซึ่งจริงๆแล้วเป็น JVM

ตามลิงค์ข้างต้นผู้ปฏิบัติการเป็นกระบวนการที่เปิดตัวสำหรับแอปพลิเคชันบนโหนดผู้ปฏิบัติงานที่ทำงาน ผู้ปฏิบัติการก็เป็น JVM เช่นกัน

นี่คือคำถามของฉัน:

1. ผู้บริหารมีต่อแอปพลิเคชัน แล้วบทบาทของคนงานคืออะไร? มันประสานกับผู้ดำเนินการและสื่อสารผลลัพธ์กลับไปที่ไดรเวอร์หรือไม่ หรือคนขับรถโดยตรงพูดคุยกับผู้บริหารหรือไม่ ถ้าเป็นเช่นนั้นอะไรคือวัตถุประสงค์ของคนงาน?

2. วิธีควบคุมจำนวนตัวเรียกทำงานสำหรับแอปพลิเคชัน

3. สามารถสร้างงานให้ทำงานแบบขนานภายในตัวจัดการได้หรือไม่ ถ้าเป็นเช่นนั้นวิธีการกำหนดค่าจำนวนกระทู้สำหรับผู้ปฏิบัติการหรือไม่

4. ความสัมพันธ์ระหว่างผู้ปฏิบัติงานผู้บริหารและผู้บริหารคอร์คืออะไร (- ยอดรวมผู้บริหารคอร์)?

5. การมีคนงานเพิ่มขึ้นต่อโหนดหมายความว่าอย่างไร

Updated

ลองยกตัวอย่างเพื่อทำความเข้าใจให้ดีขึ้น

ตัวอย่างที่ 1: คลัสเตอร์แบบสแตนด์อะโลนที่มี 5 โหนดงาน (แต่ละโหนดมี 8 แกน) เมื่อฉันเริ่มโปรแกรมประยุกต์ด้วยการตั้งค่าเริ่มต้น

ตัวอย่างที่ 2 การตั้งค่า คลัสเตอร์เดียวกันเป็นตัวอย่างที่ 1 แต่ฉันเรียกใช้แอปพลิเคชันด้วยการตั้งค่าต่อไปนี้ --executor-cores 10 --total-executor-cores 10

ตัวอย่างที่ 3 การตั้งค่า คลัสเตอร์เดียวกันเป็นตัวอย่างที่ 1 แต่ฉันเรียกใช้แอปพลิเคชันด้วยการตั้งค่าต่อไปนี้ --executor-cores 10 --total-executor-cores 50

ตัวอย่างที่ 4 การกำหนดค่า คลัสเตอร์เดียวกันเป็นตัวอย่างที่ 1 แต่ฉันเรียกใช้แอปพลิเคชันด้วยการตั้งค่าต่อไปนี้ --executor-cores 50 --total-executor-cores 50

ตัวอย่างที่ 5 การกำหนดค่า คลัสเตอร์เดียวกันเป็นตัวอย่าง 1 แต่ฉันเรียกใช้แอปพลิเคชันด้วยการตั้งค่าต่อไปนี้ --executor-cores 50 --total-executor-cores 10

ในตัวอย่างเหล่านี้แต่ละตัวมีกี่ตัวดำเนินการ กี่เธรดต่อตัวดำเนินการ มีกี่คอร์? จำนวนตัวจัดการตัดสินใจในแต่ละแอปพลิเคชันอย่างไร มันเป็นเช่นเดียวกับจำนวนของคนงานเสมอหรือไม่?

Spark ใช้สถาปัตยกรรมต้นแบบ / ทาส อย่างที่คุณเห็นในรูปมันมีผู้ประสานงานกลางคนหนึ่ง (คนขับ) ที่สื่อสารกับคนงานกระจายหลายคน (ผู้บริหาร) ไดรเวอร์และตัวเรียกใช้งานแต่ละตัวทำงานในกระบวนการ Java ของตนเอง

DRIVER

ไดรเวอร์คือกระบวนการที่ใช้วิธีการหลัก ก่อนอื่นมันจะแปลงโปรแกรมผู้ใช้เป็นงานและหลังจากนั้นจะกำหนดเวลางานในตัวจัดการ

รัฟ

ผู้บริหารคือกระบวนการของโหนดผู้ปฏิบัติงานที่รับผิดชอบการทำงานแต่ละงานในงาน Spark ที่กำหนด พวกเขาจะเปิดตัวที่จุดเริ่มต้นของแอปพลิเคชั่น Spark และโดยทั่วไปจะทำงานตลอดอายุการใช้งานของแอปพลิเคชัน เมื่อพวกเขาได้ทำงานที่พวกเขาส่งผลลัพธ์ไปยังไดรเวอร์ พวกเขายังมีที่เก็บข้อมูลในหน่วยความจำสำหรับ RDD ที่แคชโดยโปรแกรมผู้ใช้ผ่านทาง Block Manager

การไหลของแอปพลิเคชัน

เมื่อคุณส่งแอปพลิเคชันไปยังคลัสเตอร์ด้วย spark-submit นี่คือสิ่งที่เกิดขึ้นภายใน:

1. แอปพลิเคชันแบบสแตนด์อโลนจะเริ่มต้นและอินSparkContextสแตนซ์ของอินสแตนซ์ (และเป็นเพียงเมื่อคุณสามารถเรียกแอปพลิเคชันเป็นไดร์เวอร์)
2. โปรแกรมไดรเวอร์ร้องขอทรัพยากรไปยังตัวจัดการคลัสเตอร์เพื่อเรียกใช้งานตัวเรียกทำงาน
3. ตัวจัดการคลัสเตอร์เรียกใช้งานตัวเรียกทำงาน
4. กระบวนการของไดรเวอร์นั้นทำงานผ่านแอพพลิเคชั่นผู้ใช้ ทั้งนี้ขึ้นอยู่กับการกระทำและการแปลงงาน RDD จะถูกส่งไปยังผู้ปฏิบัติการ
5. ผู้บริหารรันงานและบันทึกผลลัพธ์
6. หากผู้ปฏิบัติงานขัดข้องงานของมันจะถูกส่งไปยังผู้บริหารที่แตกต่างกันเพื่อดำเนินการอีกครั้ง ในหนังสือ "Learning Spark: Lightning-Fast Big Data Analysis" พวกเขาพูดถึง Spark และ Fault Tolerance:

Spark จะจัดการกับเครื่องที่ล้มเหลวหรือช้าโดยอัตโนมัติโดยการเรียกใช้งานที่ล้มเหลวหรือทำงานช้า ตัวอย่างเช่นหากโหนดที่รันพาร์ติชันของการดำเนินการ map () ขัดข้อง Spark จะรันอีกครั้งบนโหนดอื่น และแม้ว่าโหนดจะไม่พัง แต่ก็ช้ากว่าโหนดอื่นมาก Spark สามารถเปิดใช้งานสำเนา "เก็งกำไร" ของงานบนโหนดอื่นได้ล่วงหน้าและรับผลลัพธ์หากทำเสร็จ

7. ด้วย SparkContext.stop () จากไดรเวอร์หรือถ้าเมธอดหลักออก / หยุดทำงานตัวจัดการทั้งหมดจะถูกยกเลิกและทรัพยากรคลัสเตอร์จะถูกปล่อยโดยตัวจัดการคลัสเตอร์

คำถามของคุณ

1. เมื่อผู้บริหารเริ่มต้นพวกเขาจะลงทะเบียนตัวเองพร้อมคนขับและจากนั้นพวกเขาจะสื่อสารโดยตรง คนงานรับผิดชอบในการสื่อสารกับผู้จัดการคลัสเตอร์เกี่ยวกับความพร้อมใช้งานของทรัพยากร

2. ในคลัสเตอร์ YARN คุณสามารถทำได้ด้วย --num-executors ในคลัสเตอร์แบบสแตนด์อะโลนคุณจะได้รับหนึ่งผู้ปฏิบัติการต่อผู้ปฏิบัติงานเว้นแต่ว่าคุณเล่นกับ spark.executor.cores และผู้ปฏิบัติงานมีแกนหลักเพียงพอที่จะถือผู้บริหารมากกว่าหนึ่งคน (ดังที่ @JacekLaskowski ระบุ --num-executors ไม่ได้ใช้งานใน YARN อีกต่อไปhttps://github.com/apache/spark/commit/16b6d18613e150c7038c613992d80a7828413e66 )

3. คุณสามารถกำหนดจำนวนแกนต่อผู้ดำเนินการด้วย --executor-cores

4. --total-executor-cores เป็นจำนวนสูงสุดของแกนประมวลผลต่อแอ็พพลิเคชัน

5. ดังที่ Sean Owen กล่าวในหัวข้อนี้: "ไม่มีเหตุผลที่ดีที่จะเรียกใช้มากกว่าหนึ่งคนต่อหนึ่งเครื่อง" คุณจะมี JVM จำนวนมากนั่งอยู่ในเครื่องเดียว

UPDATE

ฉันไม่สามารถทดสอบสถานการณ์นี้ แต่ตามเอกสารประกอบ:

ตัวอย่างที่ 1:ประกายไฟจะได้รับแกนประมวลผลและตัวประมวลผลเท่าที่เสนอโดยตัวจัดตารางเวลา ดังนั้นในตอนท้ายคุณจะได้รับ 5 executors ต่อ 8 cores

ตัวอย่างที่ 2 ถึง 5: Spark จะไม่สามารถจัดสรรแกนได้มากเท่าที่ร้องขอในผู้ปฏิบัติงานคนเดียวดังนั้นจึงไม่มีตัวเรียกทำงานขึ้นมา

นี่คือวิธีที่ Apache Spark ทำงานภายใน: