ควรเลือกอะไร หากต้องเลือกระหว่าง Yarn-Client และ Yarn-Cluster

สำหรับมือใหม่หัดใช้ Spark ว่าด้วยเรื่อง Deploy Mode ในคำสั่ง spark-submit

PCP

Published in

ป้า ๆ ขอคุยเรื่อง Data หน่อย

4 min readAug 23, 2020

TL;DR

Yarn-Client Mode: เหมาะกับการใช้งานในช่วง Development เนื่องจากสามารถเขียนโปรแกรมแบบ Interactive ได้ ซึ่งจะทำให้เห็นผลลัพธ์ของการทำงานและ Debug ได้ง่าย แต่มีข้อเสียคือ โหมดนี้นำเอา Driver Program ทั้งหมดมาไว้ที่ Edge Node จึงมีความเสี่ยงมากหาก Edge Node มีปัญหา เพราะโปรแกรมที่รันอยู่จะหยุดการทำงานทั้งหมด
Yarn-Cluster Mode: เหมาะสมกับการใช้งานในช่วง Production เนื่องจากจะนำ Driver Program ไปรันไว้บน Worker Node ซึ่งจะช่วยลดความเสี่ยงในการรันงานเนื่องจาก Driver Program ที่ถูกสร้างขึ้นจะกระจายไปตาม Worker Node ที่ต่างกันออกไป การที่ Worker Node ใดมีปัญหา ไม่ได้หมายความว่าโปรแกรมที่รันอยู่จะหยุดการทำงานทั้งหมด

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

หนึ่งในเทคโนโลยีที่ถูกใช้กันอย่างแพร่หลายนั้นคงหนีไม่พ้นการใช้งาน Hadoop Cluster ที่นอกจากจะสามารถประมวลผลข้อมูลจำนวนมหาศาลได้ในระยะเวลาที่สั้นลงแล้ว ยังช่วยในเรื่องของการเก็บข้อมูลให้มีความปลอดภัย (ในแง่ของการสูญหายของข้อมูลขณะประมวลผลข้อมูล) มากขึ้นด้วย

สำหรับมือใหม่ที่เพิ่งเริ่มต้นใช้งาน PySpark นั้น คงมีความสงสัยไม่ต่างจากตัวผมมากนัก คือจะสั่งรันโปรแกรมแต่ละที ต้องมีการกำหนดค่าต่าง ๆ ของคำสั่ง spark-submit มากมายจนน่าปวดหัว ดังนั้นวันนี้ผมจะพามารู้จักกับหนึ่งในสิ่งที่ควรรู้ เมื่อต้องการ Deploy โปรแกรมขึ้นไปบน Production

Deploy Mode มีไว้ทำอะไร ?

เมื่อเราต้องการเริ่มต้นการทำงานของโปรแกรม การกำหนด Deploy Mode จะเป็นการส่งสัญญาณบอกให้ Hadoop Cluster รู้ว่า ควรเริ่มต้นการทำงานที่ใด โดยที่แต่ละโหมดก็จะมีประโยชน์ในการใช้งานแตกต่างกันไป

และตัวละครสำคัญที่จะเข้ามามีส่วนเกี่ยวข้องในกระบวนการนี้ ก็คือ Edge Node

แล้ว Edge Node คืออะไร ?

Edge Node นั้นมีบทบาทสำคัญใน Hadoop Cluster มาก สามารถกล่าวได้ว่า Hadoop Cluster ที่ไม่มี Edge Node ก็เหมือนกับบ้านที่ไม่มีประตูทางเข้า เนื่องจาก Edge Node จะคอยเป็นประตู (Gateway) ให้ผู้ใช้งานอย่างเรา ๆ สามารถเข้าไปคุยกับ Hadoop Cluster ได้

การเริ่มต้นการทำงาน ต้องใช้คำสั่งอะไร ?

การจะเริ่มต้นการใช้งานของ Hadoop Cluster นั้น สิ่งต้องทำเป็นอย่างแรก ก็คือตั้งค่าระบบและจองพื้นที่การทำงานให้กับตัวโปรแกรมของเรา ด้วยการใช้คำสั่ง spark-submit และหน้าด่านที่จะรับคำสั่งนี้จากเรานั้น ก็หนีไม่พ้น Edge Node เจ้ากรรมของเรานั่นเอง ดังรูปที่ 1

รูปที่ 1 รูปแสดงการใช้คำสั่ง spark-submit ไปยัง Hadoop Cluster

โดยคำสั่งที่ใช้ในการกำหนด Deploy Mode มีดังนี้

./bin/spark-submit \
  --deploy-mode <deploy-mode> \
  ... # other options

มันเกิดอะไรขึ้นต่อ ?

เมื่อเราทำการสั่ง Hadoop Cluster ด้วยการใช้ spark-submit แล้ว เจ้า Driver Program จะถูกสร้างขึ้น เพื่อรับผิดชอบงานส่วนที่เราต้องการให้ Hadoop Cluster ทำงานให้ หรือถ้าให้เจาะจงไปกว่านี้ คือ Driver Program ของเราจะเป็นหัวหน้าคนงานที่จะคอยควบคุมลูกน้องให้ทำงานที่เราต้องการให้อีกที

แต่โดยนิสัยส่วนตัวแล้ว ลูกน้องของ Driver Program ค่อนข้างดื้อรั้น เพราะเมื่อไหร่ที่ Driver Program หัวหน้าของมันนั้นหายไป ลูกน้องผู้น่ารักทั้งหมดนั้นก็พร้อมใจที่จะเลิกงานทันที ซึ่งลูกน้องคนนี้มีชื่อว่า Executor Program

แล้วประเด็นมันอยู่ที่ไหน ?

อย่างที่เรารู้กันแล้วว่า เจ้า Deploy Mode จะเป็นตัวบอกว่า ควรเริ่มต้นการทำงานที่ใด แต่มันก็ยังดูเป็นประโยคที่กำกวมอยู่ เพราะในประโยค มันไม่ได้บอกว่า “ใคร” เป็นคนเริ่มต้นการทำงาน ซึ่งเมื่อเรารู้จัก Driver Program แล้ว ก็คงบอกได้ง่าย ๆ ว่า “ใคร” ในที่นี้ก็คือเจ้า Driver Program นี่แหละ

ดังนั้นประโยคเต็ม ๆ ของเราในที่นี้ก็คือ เจ้า Deploy Mode จะเป็นตัวบอกว่า ควรให้หัวหน้าคนงานอย่าง Driver Program ไปเริ่มต้นการทำงาน ณ ที่แห่งใดใน Hadoop Cluster

หากเข้าใจวิธีการทำงานข้างบนหมดแล้ว ก็ขอบอกไว้เลยว่า มันไม่มีอะไรยากไปกว่านี้แล้ว ซึ่งก็หมายความว่า พวกเราพร้อมแล้วที่จะไปรู้จักกับ Yarn-Client และ Yarn-Cluster

โหมด Yarn-Client มีประโยชน์อย่างไร ?

Yarn-Client เป็นโหมดที่เหมาะสมกับช่วงพัฒนาโปรแกรม เนื่องจากจะรองรับการเขียนโปรแกรมแบบ Interactive (REPL) กล่าวคือ หากต้องการที่จะทดสอบชุดคำสั่งใด ๆ ก็ตาม ก็สามารถที่จะเห็นผลลัพธ์ได้ทันที ดังตัวอย่างในรูปที่ 2

รูปที่ 2 รูปตัวอย่างการเขียนโปรแกรมแบบ Interactive (REPL) บน Python Console

ซึ่งช่องทางในการเขียนโปรแกรมแบบ Interactive (REPL) ในที่นี้ ก็คือ Spark Shell ที่อยู่คู่กับ Hadoop Cluster มาตั้งแต่วัยเก๋า

แล้วมันทำงานยังไง ?

เมื่อเรารู้กันแล้วว่า หากเราใช้คำสั่ง spark-submit ไปที่ Edge Node แล้ว เจ้า Driver Program ก็จะถูกสร้างขึ้น ซึ่งตำแหน่งของ Driver Program ที่ถูกสร้างขึ้นสำหรับ Deploy Mode ที่เป็นโหมด Yarn-Client นี้ ก็คือที่ Edge Node เจ้ากรรมของเราเลยนี่แหละ ดังรูปที่ 3

รูปที่ 3 รูปแสดงตำแหน่งที่ Driver Program ถูกเรียกขึ้นมาเมื่อใช้ Deploy Mode เป็นโหมด Yarn-Client

ซึ่งคำสั่งที่ใช้ในการกำหนด Deploy Mode เป็นโหมด Yarn-Client จะมีดังนี้

./bin/spark-submit \
  --master yarn \
  --deploy-mode client \
  ... # other options

และเมื่อ Driver Program หัวหน้าคนงานของเราถูกสร้างขึ้นมาแล้ว มันก็จะไปปลุกลูกน้องที่ชื่อ Executor Program ต่อที่ Worker Node ที่ยังมีพื้นที่ทำงาน (Resources) ว่าง ๆ อยู่ภายใน Hadoop Cluster ดังรูปที่ 4

รูปที่ 4 รูปแสดงการทำงานของ Driver Program เมื่อใช้โหมด Yarn-Client

แต่… ข้อจำกัดมันอยู่ตรงนี้

ให้ลองคิดดูเล่น ๆ ว่ามันจะเกิดอะไรขึ้น ถ้ามีคนเริ่มต้นการทำงานของโปรแกรมภายใน Hadoop Cluster พร้อมกันหลาย ๆ คนด้วยโหมด Yarn-Client ดังรูปที่ 5

รูปที่ 5 รูปแสดงการทำงานเมื่อใช้ Deploy Mode เป็นโหมด Yarn-Client

แน่นอน… หากมีการเริ่มต้นการทำงานของโปรแกรมเยอะ เจ้า Edge Node เจ้ากรรมของเรามันก็คงรับไม่ไหว ก็พี่แกเล่นเอา Driver Program ของคนใช้งานทั้งหมดมาไว้ที่เดียวกัน

ดังนั้น พื้นที่ทำงาน (Resources) ของเครื่อง Edge Node เครื่องเดียวมันก็คงรับไม่ไหว และหาก Edge Node เกิดท้อจนหายไปเมื่อไหร ่ก็ต้องพบกับคราวซวย เพราะ Driver Program ทั้งหมดที่อยู่บน Edge Node ก็จะไม่มีที่อยู่ดังรูปที่ 6

รูปที่ 6 รูปแสดงข้อเสียเมื่อใช้ Deploy Mode เป็นโหมด Yarn-Client

และเมื่อ Driver Program หัวหน้าคนงานของเราไม่มีที่อยู่ ลูกน้องที่น่ารักอย่าง Executor Program ของเราก็มีอันต้องหายไป นับว่าเป็นความเสี่ยงก้อนโตที่อาจเกิดขึ้นได้เมื่อใช้โหมด Yarn-Client

และก็ด้วยความเสี่ยงตรงนี้เอง จึงเป็นจุดที่ทำให้โหมด Yarn-Cluster เป็นเหมือนพระเอกขี่ม้าขาวเข้ามาช่วยแก้ไขปัญหา

โหมด Yarn-Cluster ช่วยอะไรเราได้ ?

Yarn-Cluster เป็นโหมดที่จะช่วยลดความเสี่ยงจากการที่ Edge Node รวบรวม Driver Program ทุกตัวมาไว้ที่ตัวมันเอง ด้วยการปัด Driver Program ที่จะถูกสร้างขึ้น ให้ไปเกิดที่ Worker Node ที่ว่างงานของ Hadoop Cluster โดยตรงดังรูปที่ 7

รูปที่ 7 รูปแสดงตำแหน่งที่ Driver Program ถูกเรียกขึ้นมาเมื่อใช้ Deploy Mode เป็นโหมด Yarn-Cluster

ก็แน่นอนล่ะ ไม่ได้มีการกินรวบแบบโหมด Yarn-Client มันก็ต้องช่วยแก้ปัญหาอยู่แล้ว แต่ก็ต้องอย่าลืมว่าโหมด Yarn-Cluster ไม่รองรับการเขียนโปรแกรมแบบ Interactive นะจ๊ะ

และคำสั่งที่ใช้ในการกำหนด Deploy Mode เป็นโหมด Yarn-Cluster ก็คือ

./bin/spark-submit \
  --master yarn \
  --deploy-mode cluster \
  ... # other options

ดังนั้น พอ Edge Node ไม่มีภาระในการรับเลี้ยง Driver Program แล้ว ก็จะทำให้ทำได้อย่างราบรื่นมากขึ้น แถมความเสี่ยงก้อนโตก็ถูกกระจายออกไป เพราะ Driver Program จะถูกแจกจ่ายไปยัง Worker Node ที่แตกต่างกันออกไป หาก Worker Node ใดมีปัญหา ก็ไม่ได้หมายความว่าโปรแกรมทั้งหมดจะถูกปิดตัวลง

รูปที่ 8 รูปแสดงการทำงานหลังสั่ง spark-submit เมื่อใช้ Deploy Mode เป็นโหมด Yarn-Cluster

นอกจากนี้ อีกหนึ่งข้อดีในการใช้โหมด Yarn-Cluster คือ หาก Edge Node เจ้ากรรมของเราไม่ได้ถูกตั้งไว้ภายใน Hadoop Cluster แล้ว การใช้โหมดนี้ยังช่วยลดความหน่วงในการติดต่อสื่อสารระหว่าง Driver Program กับ Executor Program ระหว่างการทำงานด้วย

ทั้งนี้ หากไม่มีการกำหนดว่า Deploy Mode จะเป็นค่าไหน ตัว Spark เวอร์ชัน 3.0 จะตั้งค่าเริ่มต้น (Default) ให้ Deploy Mode เป็นโหมด Client เสมอ

Note

จริง ๆ แล้วยังมี Component อื่นที่ควรกล่าวถึงอีก แต่เพื่อให้ง่ายต่อการอธิบายสำหรับคนที่เพิ่งเริ่มต้นใช้งานนั้น จึงขอละ Component อื่นไว้ป้องกันการสับสน
หากมีข้อผิดพลาดหรือข้อเสนอแนะประการใดสามารถแนะนำได้โดยการกด Respond และเขียนความคิดเห็นไว้ได้เลยครับ ขอบคุณทุกความคิดเห็นนะครับ