הדרכה: ארכיטקטורת יישומי ניצוצות ואשכולות

קבל את הספר המלא
ניתוח נתונים עם ניצוץ באמצעות פיתון (Addison-Wesley Data & Analytics Series) MSRP $ 44.99 ראה זאת

מאמר זה הוא קטע מתוך ספרו של פירסון אדיסון-ווסלי "נתוני נתונים עם ניצוץ באמצעות פיתון" מאת ג'פרי אבן. הודפס כאן באישור פירסון © 2018. למידע נוסף בקר באתר informit.com/aven/infoworld.

לפני שתתחיל את דרכך כמתכנת אפאצ'י ספארק, עליך להבין היטב את ארכיטקטורת היישומים של Spark ואת אופן הביצוע של יישומים באשכול Spark. מאמר זה בוחן מקרוב את המרכיבים של יישום Spark, בוחן כיצד רכיבים אלה עובדים יחד, ובודק כיצד יישומי Spark פועלים באשכולות עצמאיים ו- YARN.

אנטומיה של יישום Spark

יישום Spark מכיל מספר רכיבים, שכולם קיימים בין אם אתה מפעיל את Spark במכונה אחת או על פני אשכול של מאות או אלפי צמתים.

לכל רכיב תפקיד ספציפי בביצוע תוכנית Spark. חלק מתפקידים אלה, כמו רכיבי הלקוח, הם פסיביים במהלך הביצוע; תפקידים אחרים פעילים בביצוע התוכנית, כולל רכיבים המבצעים פונקציות חישוב.

המרכיבים של יישום Spark הם:

  • הנהג
  • המאסטר
  • מנהל האשכול
  • המוציאים לפועל

כולם פועלים על צמתים עובדים, גם עובדים.

איור 1 מציג את כל רכיבי ה- Spark בהקשר של יישום עצמאי של Spark.

פירסון אדיסון-ווסלי

כל רכיבי ה- Spark - כולל תהליכי מנהל ההתקן, המאסטר והמבצע - פועלים במכונות וירטואליות של Java. JVM הוא מנוע זמן ריצה חוצה פלטפורמות שיכול לבצע הוראות שחוברו לקוד התצוגה של Java. Scala, ש- Spark כתוב בתוכו, מתכנס לקוד Byte ומופעל על ידי JVM.

חשוב להבחין בין רכיבי יישום זמן הריצה של Spark לבין המיקומים וסוגי הצומת עליהם הם פועלים. רכיבים אלה פועלים במקומות שונים תוך שימוש במצבי פריסה שונים, לכן אל תחשוב על רכיבים אלה במונחים פיזיים של צומת או מופע. לדוגמא, כאשר מריצים את Spark ב- YARN, יהיו מספר וריאציות של איור 1. עם זאת, כל הרכיבים בתמונה עדיין מעורבים ביישום ויש להם את אותם התפקידים.

נהג ניצוץ

חיי יישום Spark מתחילים ומסתיימים עם מנהל התקן ה- Spark. מנהל ההתקן הוא התהליך בו משתמשים הלקוחות להגשת בקשות ב- Spark. הנהג אחראי גם על תכנון ותיאום ביצוע תוכנית Spark והחזרת מעמד ו / או תוצאות (נתונים) ללקוח. הנהג יכול להתגורר פיזית בלקוח או בצומת באשכול, כפי שתראה בהמשך.

SparkSession

מנהל התקן ה- Spark אחראי על יצירת ה- SparkSession. האובייקט SparkSession מייצג חיבור לאשכול Spark. ה- SparkSession מופעל בתחילת יישום Spark, כולל הקונכיות האינטראקטיביות, ומשמש לכלל התוכנית.

לפני Spark 2.0, נקודות כניסה ליישומי Spark כללו את SparkContext, המשמש ליישומי ליבת Spark; ה- SQLContext ו- HiveContext, המשמשים ליישומי Spark SQL; ו- StreamingContext, המשמש ליישומי הזרמת ניצוצות. אובייקט SparkSession שהוצג ב- Spark 2.0 משלב את כל האובייקטים הללו לנקודת כניסה אחת שיכולה לשמש עבור כל יישומי Spark.

באמצעות אובייקטים SparkContext ו- SparkConf, האובייקט SparkSession מכיל את כל מאפייני התצורה של זמן הריצה שהוגדר על ידי המשתמש, כולל מאפייני תצורה כגון המאסטר, שם היישום ומספר המבצעים. איור 2 מציג את אובייקט SparkSession וחלק ממאפייני התצורה שלו pysparkבמעטפת.

פירסון אדיסון-ווסלי

שם SparkSession

שם האובייקט למופע SparkSession הוא שרירותי. כברירת מחדל, המינוי של SparkSession בקליפות האינטראקטיביות של Spark נקרא spark. לצורך עקביות, אתה תמיד מגדיר את SparkSession כ- spark; עם זאת, השם נתון לשיקול דעתו של המפתח.

הקוד שלהלן מדגים כיצד ליצור SparkSession ביישום Spark שאינו אינטראקטיבי, כגון תוכנית המוגשת באמצעות spark-submit.

מ- pyspark.sql יבוא SparkSession

ניצוץ = SparkSession.builder \

  .master ("ניצוץ: // ניצוץ: 7077") \

  .appName ("יישום הניצוץ שלי") \

  .config ("spark.submit.deployMode", "client") \

  .getOrCreate ()

numlines = spark.sparkContext.textFile ("file: /// opt / spark / licens") \

  .לספור()

הדפס ("המספר הכולל של השורות הוא" + str (מספר שורות))

תכנון יישומים

אחד התפקידים העיקריים של הנהג הוא לתכנן את היישום. הנהג לוקח את קלט עיבוד היישום ומתכנן את ביצוע התוכנית. מנהל ההתקן מבצע את כל הטרנספורמציות המבוקשות (פעולות מניפולציה של נתונים) והפעולות (בקשות לפלט או בקשות לביצוע תוכניות) ויוצר גרף מחזורי מכוון (DAG) של צמתים, שכל אחד מהם מייצג צעד טרנספורמטיבי או חישובי.

גרף אצטלי מכוון (DAG)

DAG הוא מבנה מתמטי המשמש בדרך כלל במדעי המחשב כדי לייצג את זרימת הנתונים ואת התלות שלהם. DAGs מכילים קודקודים (או צמתים) וקצוות. קודקודים בהקשר של זרימת נתונים הם שלבים בתהליך התהליך. קצוות ב- DAG מחברים קודקודים זה לזה בכיוון מכוון ובאופן שאי אפשר לקבל אזכורים מעגליים.

DAG יישום ספארק מורכב משימות ו בשלבים . משימה היא היחידה הקטנה ביותר לעבודה הניתנת לתזמון בתוכנית Spark. שלב הוא מכלול משימות שניתן להריץ יחד. השלבים תלויים זה בזה; במילים אחרות, יש תלות בימתית .

במובן של תזמון תהליכים, DAGs אינם ייחודיים ל- Spark. לדוגמה, הם משמשים בפרויקטים אחרים של מערכות אקולוגיות של נתונים גדולים, כגון Tez, Drill ו- Presto לתזמון. DAGs הם בסיסיים עבור Spark, ולכן כדאי להכיר את הרעיון.

תזמור יישומים

הנהג גם מתאם את הפעלת השלבים והמשימות שהוגדרו ב- DAG. פעילויות הנהג העיקריות הכרוכות בתזמון והפעלת המשימות כוללות את הפעולות הבאות:

  • מעקב אחר משאבים זמינים לביצוע משימות.
  • תזמון משימות להפעלת "קרוב" לנתונים במידת האפשר (המושג יישוב נתונים).

פעולות אחרות

בנוסף לתכנון ותזמור ביצוע תוכנית Spark, הנהג אחראי גם להחזרת התוצאות מיישום. אלה יכולים להיות קודי החזרה או נתונים במקרה של פעולה שמבקשת להחזיר נתונים ללקוח (למשל, שאילתה אינטראקטיבית).

מנהל ההתקן משרת גם את ממשק המשתמש של היישום ביציאה 4040, כפי שמוצג באיור 3. ממשק משתמש זה נוצר באופן אוטומטי; הוא אינו תלוי בקוד שהוגש או באופן הגשתו (כלומר שימוש אינטראקטיבי pyspark או לא אינטראקטיבי spark-submit).

פירסון אדיסון-ווסלי

אם יישומים הבאים מופעלים באותו מארח, יציאות עוקבות משמשות לממשק המשתמש של היישום (לדוגמה, 4041, 4042 וכן הלאה).

עובדי ניצוץ ומוציאים לפועל

מבצעי ניצוצות הם התהליכים שבהם פועלות משימות Spark DAG. הפועלים שומרים משאבי מעבד וזיכרון בצמתים עבדים, או עובדים, באשכול Spark. מנהל ביצוע מוקדש ליישום ספארק ספציפי ומסתיים לאחר סיום היישום. תוכנית Spark מורכבת בדרך כלל ממנהלים רבים, שלעתים קרובות עובדים במקביל.

בדרך כלל, צומת פועל - המארח את תהליך המבצע - כולל מספר סופי או קבוע של מבצעים המוקצים בכל נקודת זמן. לכן, לאשכול - בהיותו מספר ידוע של צמתים - יש מספר סופי של מוציאים לפועל בכל זמן נתון. אם יישום דורש ביצועים מעבר לקיבולת הפיזית של האשכול, הם אמורים להתחיל כשמבצעים אחרים משלימים ומשחררים את המשאבים שלהם.

כאמור, JVM מארחים מבצעי ספארק. ל- JVM למנהל ביצוע מוקצה ערמה , שהיא שטח זיכרון ייעודי לאחסון וניהול אובייקטים.

כמות הזיכרון מחויבת ערימת JVM עבור לפועל מוגדרת על ידי הנכס spark.executor.memoryאו כמו --executor-memoryהטיעון לבית pyspark, spark-shellאו spark-submitהפקודות.

מנהלים מאחסנים נתוני פלט ממשימות בזיכרון או בדיסק. חשוב לציין כי עובדים ומוציאים לפועל מודעים רק למשימות המוקצות להם, ואילו הנהג אחראי על הבנת מערך המשימות השלם והתלות בהתאמה הכוללת יישום.

על ידי שימוש בממשק המשתמש של יישום ה- Spark ביציאה 404 x של מארח מנהל ההתקן, תוכל לבדוק את הביצועים עבור היישום, כפי שמוצג באיור 4.

פירסון אדיסון-ווסלי

עבור פריסות אשכולות עצמאיות של Spark, צומת עובד חושף ממשק משתמש ביציאה 8081, כפי שמוצג באיור 5.

פירסון אדיסון-ווסלי

מנהל ספארק ומנהל אשכולות

מנהל התקן ה- Spark מתכנן ומתאם את מערך המשימות הנדרש להפעלת יישום Spark. המשימות עצמן מתבצעות במבצעים שמתארחים בצמתים עובדים.

המאסטר ומנהל האשכול הם התהליכים המרכזיים העוקבים אחר שמורות, והקצאת משאבי האשכול המבוזרים (או מכולות, במקרה של YARN או Mesos) עליהם פועלים. המאסטר ומנהל האשכול יכולים להיות תהליכים נפרדים, או שהם יכולים להשתלב בתהליך אחד, כפי שקורה כאשר מריצים את Spark במצב עצמאי.

מאסטר ניצוצות

מאסטר ה- Spark הוא התהליך שמבקש משאבים באשכול והופך אותם לזמינים למנהל ההתקשרות. בכל מצבי הפריסה, המאסטר מנהל משא ומתן על משאבים או מכולות עם צמתים עובדים או צמתים עבדים ועוקב אחר מעמדם ומפקח על התקדמותם.

בעת הפעלת Spark במצב עצמאי, תהליך ה- Master Spark משרת ממשק משתמש אינטרנט ביציאה 8080 במארח הראשי, כפי שמוצג באיור 6.

פירסון אדיסון-ווסלי

מאסטר ניצוצות מול נהג ניצוצות

חשוב להבחין בין פונקציות זמן הריצה של מנהל ההתקן ושל המאסטר. ניתן להסיק את שם המאסטר שמשמעותו שתהליך זה מסדיר את ביצוע הבקשה - אך זה לא המקרה. המאסטר פשוט מבקש משאבים ומעמיד לרשות הנהג משאבים אלה. למרות שהמאסטר עוקב אחר מצבם ובריאותם של משאבים אלה, הוא אינו מעורב בביצוע היישום ובתיאום משימותיו ושלביו. זה תפקידו של הנהג.

מנהל אשכולות

מנהל האשכולות הוא התהליך האחראי על ניטור צמתים העובדים ושמירת משאבים על צמתים אלה על פי בקשת המאסטר. לאחר מכן, המאסטר מעמיד לרשות הנהג משאבי אשכול אלה בדמות מבצעים.

כפי שצוין קודם, מנהל האשכולות יכול להיות נפרד מתהליך האב. זה המקרה בעת הפעלת Spark on Mesos או YARN. במקרה של ניצוץ במצב עצמאי, תהליך המאסטר מבצע גם את הפונקציות של מנהל האשכולות. למעשה, הוא פועל כמנהל אשכול משלו.

דוגמה טובה לפונקציית מנהל האשכולות היא תהליך YARN ResourceManager ליישומי Spark הפועלים באשכולות Hadoop. ResourceManager מתזמן, מקצה ומפקח על תקינות המכולות הפועלות ב- YARN NodeManagers. יישומי ניצוץ משתמשים במכולות אלה כדי לארח תהליכי מבצעים, כמו גם את תהליך האב אם היישום פועל במצב אשכול.

יישומי ניצוץ באמצעות מתזמן העצמאי

בפרק 2, "פריסת ניצוץ", הסברתי את מתזמן העצמאי כאפשרות פריסה עבור ניצוץ. שם פרסתי אשכול עצמאי רב-צמתי פונקציונלי באחד התרגילים בפרק 2. כפי שצוין קודם לכן, באשכול ניצוץ הפועל במצב עצמאי, תהליך המאסטר של הניצוץ מבצע גם את פונקציית מנהל האשכול, ומפקח על המשאבים הזמינים אשכול והענקתם לתהליך האב לשימוש ביישום Spark.

יישומי ניצוץ הפועלים ב- YARN

Hadoop היא פלטפורמת פריסה נפוצה ונפוצה מאוד עבור Spark. כמה מומחים בתעשייה מאמינים כי Spark תחליף בקרוב את MapReduce כפלטפורמת העיבוד העיקרית ליישומים ב- Hadoop. יישומי ניצוץ ב- YARN חולקים את אותה ארכיטקטורת זמן ריצה אך יש הבדלים קלים במימוש.

ResourceManager כמנהל האשכולות

בניגוד למתזמן העצמאי, מנהל האשכולות באשכול YARN הוא YARN ResourceManager. ResourceManager עוקב אחר השימוש והזמינות במשאבים בכל הצמתים באשכול. הלקוחות מגישים בקשות Spark אל YARN ResourceManager. ה- ResourceManager מקצה את המכולה הראשונה ליישום, מיכל מיוחד שנקרא ApplicationMaster.

ApplicationMaster כמאסטר הניצוצות

ה- ApplicationMaster הוא תהליך המאסטר של Spark. כפי שתהליך האב מתבצע בפריסות אשכולות אחרות, ApplicationMaster מנהל משא ומתן על משאבים בין מנהל ההתקנה למנהל האשכולות (או ResourceManager במקרה זה); לאחר מכן היא מעמידה לרשות הנהג משאבים (מכולות) אלה לשימוש כמבצעים להפעלת משימות ואחסון נתונים ליישום.

ApplicationMaster נשאר למשך כל חיי היישום.

מצבי פריסה ליישומי Spark הפועלים ב- YARN

ניתן להשתמש בשני מצבי פריסה בעת הגשת יישומי Spark לאשכול YARN: מצב לקוח ומצב אשכול. בואו נסתכל עליהם עכשיו.

מצב לקוח

במצב לקוח, תהליך הנהג פועל על הלקוח שמגיש את היישום. זה בעצם לא מנוהל; אם מארח הנהג נכשל, היישום נכשל. מצב לקוח נתמך עבור שני פעילויות באתר הפגז אינטראקטיבי ( pyspark, spark-shellוכן הלאה) והגשת בקשה אינטראקטיבי ( spark-submit). הקוד שלהלן מראה כיצד להתחיל pysparkהפעלה באמצעות מצב פריסת הלקוח.

$ SPARK_HOME / bin / pyspark \

- מנהל חוט לקוח \

- מספר מבצעים 1 \

- זיכרון נהג 512m \

- זיכרון ביצועים 512m \

ליבות -ביצוע 1

# או

$ SPARK_HOME / bin / pyspark \

חוט מאסטר \

לקוח במצב פריסה \

- מספר מבצעים 1 \

- זיכרון נהג 512m \

- זיכרון ביצועים 512m \

ליבות -ביצוע 1

איור 7 מספק סקירה של יישום Spark הפועל ב- YARN במצב לקוח.

פירסון אדיסון-ווסלי

השלבים המוצגים באיור 7 הם:

  1. הלקוח מגיש יישום Spark למנהל האשכולות (YARN ResourceManager). תהליך הנהג, SparkSession ו- SparkContext נוצרים ומופעלים על הלקוח.
  2. ResourceManager מקצה ApplicationMaster (מאסטר ה- Spark) ליישום.
  3. ApplicationMaster מבקש להשתמש במכולות לשימוש עבור מבצעים מ- ResourceManager. עם המכולות שהוקצו, המוציאים לפועל.
  4. הנהג, הממוקם על הלקוח, ואז מתקשר עם הביצועים לעיבוד מרשל של משימות ושלבים של תוכנית Spark. הנהג מחזיר ללקוח את ההתקדמות, התוצאות והסטטוס.

מצב פריסת הלקוח הוא המצב הפשוט ביותר לשימוש. עם זאת, היא חסרה את הגמישות הנדרשת עבור מרבית יישומי הייצור.

מצב אשכול

בניגוד למצב פריסת הלקוח, כאשר יישום Spark פועל במצב אשכול YARN, הנהג עצמו פועל על האשכול כתהליך משנה של ApplicationMaster. זה מספק גמישות: אם תהליך ApplicationMaster המארח את מנהל ההתקן נכשל, ניתן לאתחל אותו מחדש בצומת אחר באשכול.

הקוד שלהלן מראה כיצד להגיש בקשה באמצעות spark-submitמצב הפריסה של אשכול YARN. מכיוון שהמנהל ההתקן הוא תהליך אסינכרוני הפועל באשכול, מצב אשכול אינו נתמך ליישומי מעטפת אינטראקטיביים ( pysparkוגם spark-shell).

$ SPARK_HOME / bin / spark-submit \

- אשכול אשכולות \

- מספר מבצעים 1 \

- זיכרון נהג 512m \

- זיכרון ביצועים 512m \

ליבות -ביצוע 1

$ SPARK_HOME / דוגמאות / src / main / python / pi.py 10000

# או

חוט מאסטר \

אשכול מצב פריסה \

- מספר מבצעים 1 \

- זיכרון נהג 512m \

- זיכרון ביצועים 512m \

ליבות -ביצוע 1

$ SPARK_HOME / דוגמאות / src / main / python / pi.py 10000

איור 8 מספק סקירה כללית של יישום Spark הפועל ב- YARN במצב אשכול.

פירסון אדיסון-ווסלי

השלבים המוצגים באיור 8 הם:

  1. הלקוח, תהליך משתמש שמפעיל spark-submit, מגיש יישום Spark למנהל האשכולות (YARN ResourceManager).
  2. ResourceManager מקצה ApplicationMaster (מאסטר ה- Spark) ליישום. תהליך מנהל ההתקן נוצר באותו צומת אשכול.
  3. ApplicationMaster מבקש מכולות עבור מבצעים מ- ResourceManager. מבצעת שרצים במיכלים שהוקצה ל- ApplicationMaster על ידי ResourceManager. לאחר מכן הנהג מתקשר עם המוציאים לפועל לעיבוד משימות ושלבי תוכנית ה- Spark.
  4. מנהל ההתקן, הפועל על צומת באשכול, מחזיר ללקוח התקדמות, תוצאות ומעמד.

ממשק המשתמש של יישום ה- Spark, כפי שמוצג לעיל, זמין ממארח ​​ApplicationMaster באשכול; קישור לממשק משתמש זה זמין ממשק המשתמש של YARN ResourceManager.

מצב מקומי ביקר שוב

במצב מקומי, הנהג, המאסטר והמבצע כולם פועלים ב- JVM יחיד. כפי שצוין קודם בפרק זה, הדבר שימושי לפיתוח, בדיקת יחידות וניקוי באגים, אך השימוש בו מוגבל להפעלת יישומי ייצור מכיוון שהוא אינו מופץ ואינו משתנה. יתר על כן, משימות כושלות ביישום Spark הפועל במצב מקומי אינן מבוצעות מחדש כברירת מחדל. אתה יכול לבטל התנהגות זו, עם זאת.

בעת הפעלת Spark במצב מקומי, ממשק המשתמש של היישום זמין בכתובת // localhost: 4040. ממשקי המשתמש הראשיים והעובדים אינם זמינים כאשר הם פועלים במצב מקומי.