מצב הגמישות המשופרת (EFM) של Managed Service for Apache Spark מנהל את הנתונים שעוברים ערבוב, כדי לצמצם את העיכובים בהתקדמות של משימות שנגרמים כתוצאה מהסרת צמתים מאשכול פעיל. ב-EFM, הנתונים של פעולת ה-shuffle נפרקים על ידי כתיבת נתונים ל-primary workers. העובדים שולפים מהצמתים המרוחקים האלה במהלך שלב ההפחתה. המצב הזה זמין רק למשימות Spark.
מכיוון ש-EFM לא מאחסן נתוני ביניים של מיון נתונים ב-workers משניים, הוא מתאים במיוחד לאשכולות שמשתמשים ב-VMs זמניים או שרק מתאימים אוטומטית לעומס של קבוצת ה-workers המשניים.
אפשר להשתמש ב-EFM ב-Managed Service for Apache Spark בגרסאות התמונה 2.0.31+, 2.1.6+, 2.2+ ואילך.
- משימות Apache Hadoop YARN שלא תומכות בהעברת AppMaster עלולות להיכשל במצב גמישות משופרת (ראו מתי להמתין לסיום של AppMasters).
- מצב גמישות משופרת לא מומלץ:
- באשכול שיש בו רק primary workers
- במשימות סטרימינג, כי יכול להיות שיעברו עד 30 דקות אחרי שהמשימה תסתיים עד שנתוני הביניים של הערבוב ינוקו.
- באשכול שמריץ מחברות, כי יכול להיות שנתוני הערבוב לא ינוקו במהלך הסשן.
- כשמשימות Spark פועלות באשכול שמופעל בו צמצום הדרגתי של כמות השרתים. צמצום הדרגתי של כמות השרתים ו-EFM יכולים לפעול למטרות מנוגדות, כי מנגנון הצמצום ההדרגתי של כמות השרתים ב-YARN שומר את הצמתים של DECOMMISSIONING עד שכל האפליקציות המעורבות מסתיימות.
- באשכול שבו פועלות גם משימות Spark וגם משימות שאינן Spark.
- מצב גמישות משופרת לא נתמך:
- כשההתאמה האוטומטית לעומס של ה-primary worker מופעלת. ברוב המקרים, ה-primary workers ימשיכו לאחסן נתוני ערבוב שלא מועברים באופן אוטומטי. הקטנת קבוצת ה-primary worker מבטלת את היתרונות של EFM.
שימוש במצב גמישות משופרת
כדי להפעיל את הגמישות המשופרת, כשיוצרים אשכול מגדירים את מאפיין האשכול dataproc:efm.spark.shuffle לערך primary-worker.
לדוגמה:
gcloud dataproc clusters create cluster-name \ --region=region \ --properties=dataproc:efm.spark.shuffle=primary-worker \ other flags ...
דוגמה ל-Apache Spark
- מריצים משימת WordCount על טקסט ציבורי של שייקספיר באמצעות קובץ ה-jar של דוגמאות Spark באשכול ה-EFM.
gcloud dataproc jobs submit spark \ --cluster=cluster-name \ --region=region \ --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \ --class=org.apache.spark.examples.JavaWordCount \ -- gs://apache-beam-samples/shakespeare/macbeth.txt
הגדרת כונני SSD מקומיים
מכיוון ש-EFM כותב נתוני ביניים של ערבוב לדיסקים שמחוברים למכונות וירטואליות, הוא נהנה מנפח העיבוד הנוסף ומפעולות הקלט/פלט לשנייה (IOPS) שמספקים כונני SSD מקומיים. כדי להקל על הקצאת המשאבים, כשמגדירים מכונות של primary worker, כדאי להגדיר מחיצה אחת של SSD מקומי לכל 4 יחידות vCPU.
כדי לצרף כונני SSD מקומיים, מעבירים את הדגל --num-worker-local-ssds לפקודה gcloud Managed Service for Apache Spark clusters create.
בדרך כלל, לא תצטרכו כונני SSD מקומיים ב-workers משניים.
הוספת כונני SSD מקומיים ל-workers המשניים של אשכול (באמצעות הדגל --num-secondary-worker-local-ssds) היא בדרך כלל פחות חשובה, כי ה-workers המשניים לא כותבים נתוני shuffle באופן מקומי.
עם זאת, מכיוון שכונני SSD מקומיים משפרים את הביצועים של הדיסק המקומי, יכול להיות שתחליטו להוסיף כונני SSD מקומיים ל-workers משניים אם אתם צופים שהמשימות יהיו מוגבלות קלט/פלט בגלל השימוש בדיסק המקומי: המשימה משתמשת בדיסק מקומי משמעותי לשטח זמני, או שהמחיצות גדולות מדי מכדי להתאים לזיכרון ויועברו לדיסק.
יחס עובדים משניים
מכיוון ש-secondary workers כותבים את נתוני ה-shuffle שלהם ל-primary workers, האשכול צריך להכיל מספר מספיק של primary workers עם מספיק משאבי מעבד, זיכרון ודיסק כדי להתאים לעומס ה-shuffle של המשימה. באשכולות עם התאמה אוטומטית לעומס, כדי למנוע מהקבוצה הראשית לשנות את הגודל ולגרום להתנהגות לא רצויה, מגדירים את minInstances לערך maxInstances במדיניות ההתאמה האוטומטית לעומס של קבוצת ה-primary worker.
אם היחס בין ה-workers המשניים ל-primary workers גבוה (לדוגמה, 10:1), כדאי לעקוב אחרי השימוש ב-CPU, ברשת ובדיסק של ה-primary workers כדי לבדוק אם יש עומס יתר. לשם כך:
נכנסים לדף VM instances במסוףGoogle Cloud .
מסמנים את התיבה שמשמאל ל-primary worker.
לוחצים על הכרטיסייה MONITORING כדי לראות את ניצול המעבד (CPU), קלט/פלט לשנייה (IOPS) של הדיסק, בייטים ברשת ומדדים אחרים של ה-primary worker.
אם יש עומס יתר על ה-primary workers, כדאי לשקול להגדיל את מספר ה-primary workers באופן ידני.
שינוי הגודל של קבוצת ה-primary worker
אפשר להגדיל את קבוצת ה-primary worker, אבל הקטנה של קבוצת ה-primary worker עלולה להשפיע לרעה על התקדמות המשימה. בפעולות שמקטינות את קבוצת ה-primary worker, צריך להשתמש בצמצום הדרגתי של כמות השרתים, שמופעל על ידי הגדרת הדגל --graceful-decommission-timeout.
אשכולות עם התאמה אוטומטית לעומס (autoscaling): באשכולות EFM עם מדיניות התאמה אוטומטית לעומס, מושבתת ההתאמה לעומס של קבוצת ה-primary worker. כדי לשנות את הגודל של קבוצת ה-primary workers באשכול עם התאמה אוטומטית לעומס:
השבתת ההתאמה האוטומטית לעומס.
gcloud dataproc clusters update \ --cluster=cluster-name \ --region=region \ --disable-autoscaling
משנים את הגודל של הקבוצה הראשית.
gcloud dataproc clusters update \ --cluster=cluster-name \ --region=region \ --num-workers=num-primary-workers \ --graceful-decommission-timeout=graceful-decommission-timeout # (if downscaling)
הפעלה מחדש של התאמה אוטומטית לעומס:
gcloud dataproc clusters update \ --cluster=cluster-name \ --region=region \ --autoscaling-policy=autoscaling-policy
מעקב אחרי השימוש בדיסק של ה-primary worker
ל-primary workers צריך להיות מספיק מקום בכונן בשביל נתוני ה-shuffle של האשכול.
אפשר לעקוב אחרי זה באופן עקיף באמצעות המדד remaining HDFS capacity.
כשהדיסק המקומי מתמלא, אין יותר מקום פנוי ל-HDFS והקיבולת שנותרה פוחתת.
כברירת מחדל, כשניצול הדיסק המקומי של ה-primary worker חורג מ-90% מהקיבולת, הצומת יסומן כ-UNHEALTHY בממשק המשתמש של צומת YARN. אם נתקלים בבעיות בנפח האחסון בדיסק, אפשר למחוק נתונים שלא בשימוש מ-HDFS או להגדיל את מאגר ה-primary workers.
הגדרה מתקדמת
חלוקה למחיצות (partitioning) ומקביליות (parallelism)
כששולחים משימת Spark, צריך להגדיר רמה מתאימה של חלוקה למחיצות. כדי להחליט על מספר המחיצות של הקלט והפלט לשלב ערבוב, צריך לבחור בין מאפייני ביצועים שונים. מומלץ להתנסות בערכים שמתאימים לצורות של המשימות שלכם.
מחיצות קלט
החלוקה למחיצות של הקלט ב-Spark וב-MapReduce נקבעת לפי מערך הנתונים של הקלט. כשקוראים קבצים מ-Cloud Storage, כל משימה מעבדת נתונים בגודל של "גודל בלוק" אחד בערך.
במשימות Spark SQL, הגודל המקסימלי של המחיצה נשלט על ידי
spark.sql.files.maxPartitionBytes. מומלץ להגדיל אותו ל-1GB:spark.sql.files.maxPartitionBytes=1073741824.ב-Spark RDD, בדרך כלל שולטים בגודל המחיצה באמצעות
fs.gs.block.size, שמוגדר כברירת מחדל ל-128MB. מומלץ להגדיל אותו ל-1GB. לדוגמה:--properties spark.hadoop.fs.gs.block.size=1073741824
מחיצות פלט
מספר המשימות בשלבים הבאים נשלט על ידי כמה מאפיינים. במשימות גדולות יותר שמעבדות יותר מ-1TB, כדאי להקצות לפחות 1GB לכל מחיצה.
ב-Spark SQL, מספר המחיצות של הפלט נשלט על ידי
spark.sql.shuffle.partitions.במשימות Spark שמשתמשות ב-API של RDD, אפשר לציין את מספר המחיצות של הפלט או להגדיר את
spark.default.parallelism.
כוונון של ערבוב הנתונים ב-primary worker
הנכס הכי משמעותי הוא --properties yarn:spark.shuffle.io.serverThreads=<num-threads>.
שימו לב שזהו מאפיין YARN ברמת האשכול, כי שרת ה-shuffle של Spark פועל כחלק מ-Node Manager. כברירת מחדל, הוא מוגדר למספר הליבות במכונה כפול 2 (לדוגמה, 16 שרשורים ב-n1-highmem-8). אם הערך של Shuffle Read Blocked Time גדול משנייה אחת, וה-primary workers לא הגיעו למגבלות הרשת, המעבד או הדיסק, כדאי להגדיל את מספר השרשורים של שרת ה-shuffle.
במכונות מסוגים גדולים יותר, כדאי להגדיל את הערך של spark.shuffle.io.numConnectionsPerPeer, שמוגדר כברירת מחדל ל-1. (לדוגמה, להגדיר 5 חיבורים לכל זוג מארחים).
הגדלת מספר הניסיונות החוזרים
כדי להגדיר את מספר הניסיונות המקסימלי שמותר למנהלי אפליקציות, למשימות ולשלבים, אפשר להגדיר את המאפיינים הבאים:
yarn:yarn.resourcemanager.am.max-attempts spark:spark.task.maxFailures spark:spark.stage.maxConsecutiveAttempts
מכיוון שהמשימות וה-app masters מסתיימים בתדירות גבוהה יותר באשכולות שמשתמשים בהרבה מכונות VM זמניות או בהתאמה אוטומטית לעומס (autoscaling) ללא צמצום הדרגתי של כמות השרתים, הגדלת הערכים של המאפיינים הקודמים באשכולות האלה יכולה לעזור (שימו לב שלא ניתן להשתמש ב-EFM עם Spark ובצמצום הדרגתי של כמות השרתים).
צמצום הדרגתי של כמות השרתים ב-YARN באשכולות EFM
אפשר להשתמש ב-YARN Graceful Decommissioning כדי להסיר צמתים במהירות, עם השפעה מינימלית על האפליקציות שפועלות. באשכולות עם התאמה לעומס (autoscaling), אפשר להגדיר את זמן הקצוב לצמצום הדרגתי של כמות השרתים ב-AutoscalingPolicy שמצורפת לאשכול ה-EFM.
שיפורים ב-EFM לצמצום הדרגתי של כמות השרתים
מכיוון שנתוני הביניים מאוחסנים במערכת קבצים מבוזרת, אפשר להסיר צמתים מאשכול EFM ברגע שכל הקונטיינרים שפועלים בצמתים האלה מסיימים לפעול. לעומת זאת, באשכולות רגילים של Managed Service for Apache Spark, הצמתים לא מוסרים עד שהאפליקציה מסיימת לפעול.
הסרת הצומת לא ממתינה לסיום של מנהלי האפליקציות שפועלים בצומת. כשהקונטיינר הראשי של האפליקציה נסגר, הוא מתוזמן מחדש בצומת אחר שלא מושבת. ההתקדמות של המשימה לא אובדת: מנהל האפליקציה החדש משחזר במהירות את המצב של מנהל האפליקציה הקודם על ידי קריאת היסטוריית המשימות.