פתרון בעיות של שגיאות זיכרון ב-Dataflow

בדף הזה מוסבר איך למצוא ולפתור שגיאות של מחסור בזיכרון (OOM) ב-Dataflow.

איך למצוא שגיאות של אין זיכרון פנוי (OOM)

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

  • בחלונית Logs שבדף Jobs details, פותחים את הכרטיסייה Diagnostics. בכרטיסייה הזו מוצגות שגיאות שקשורות לבעיות בזיכרון ותדירות השגיאות.
  • בממשק המעקב של Dataflow, משתמשים בתרשים Memory utilization כדי לעקוב אחרי קיבולת הזיכרון והשימוש בזיכרון של ה-workers.
  • בדף Jobs details, בחלונית Logs, בוחרים באפשרות Worker logs כדי למצוא שגיאות של חוסר בזיכרון ביומני ה-worker.
  • יכול להיות ששגיאות מסוג "אין זיכרון פנוי" יופיעו גם ביומני המערכת. כדי לראות את היומנים האלה, נכנסים ל-Logs Explorer ומשתמשים בשאילתה הבאה:

    resource.type="dataflow_step"
    resource.labels.job_id="JOB_ID"
    "out of memory" OR "OutOfMemory" OR "Shutting down JVM"
    

    מחליפים את JOB_ID במזהה המשימה.

  • במשימות Java, הכלי Java Memory Monitor מדווח מדי פעם על מדדי איסוף אשפה. אם החלק של זמן ה-CPU שמשמש לאיסוף אשפה חורג מסף של 50% למשך פרק זמן ממושך, רתמת ה-SDK נכשלת. יכול להיות שתופיע שגיאה דומה לזו:

    Shutting down JVM after 8 consecutive periods of measured GC thrashing. Memory is used/total/max = ...
    

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

    ההגדרה של Java Memory Monitor מתבצעת באמצעות הממשק MemoryMonitorOptions.

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

פתרון שגיאות אין זיכרון פנוי (OOM)

שינויים בפייפליין של Dataflow יכולים לפתור שגיאות של אין זיכרון פנוי (OOM) או להפחית את השימוש בזיכרון. השינויים האפשריים כוללים את הפעולות הבאות:

בתרשים הבא מוצג תהליך העבודה לפתרון בעיות ב-Dataflow שמתואר בדף הזה.

תהליך העבודה של פתרון הבעיות בדף.

נסו את הפתרונות הבאים:

  • אם אפשר, כדאי לבצע אופטימיזציה של צינור עיבוד הנתונים כדי לצמצם את השימוש בזיכרון.
  • אם המשימה היא משימת אצווה, נסו את השלבים הבאים לפי הסדר:
    1. להשתמש בסוג מכונה עם יותר זיכרון לכל vCPU.
    2. צמצמו את מספר ה-threads כך שיהיה קטן ממספר ה-vCPU לכל worker.
    3. להשתמש בסוג מכונה בהתאמה אישית עם יותר זיכרון לכל vCPU.
  • אם המשימה היא משימת סטרימינג שמשתמשת ב-Python, צריך להפחית את מספר ה-threads לפחות מ-12.
  • אם המשימה היא משימת סטרימינג שמשתמשת ב-Java או ב-Go, נסו את הפעולות הבאות:
    1. צמצמו את מספר השרשורים לפחות מ-500 במשימות שמשתמשות ב-Portable Runner, או לפחות מ-300 במשימות שלא משתמשות ב-Portable Runner.
    2. להשתמש בסוג מכונה עם יותר זיכרון.
  • עבור צינורות Java, אם מתרחשות שגיאות של חוסר זיכרון במהלך הקצאות זיכרון תכופות או איסוף אשפה, נסה להשתמש בכלי איסוף אשפה Java אחר.

אופטימיזציה של צינור המכירות

כמה פעולות בצינור עיבוד הנתונים יכולות לגרום לשגיאות של אין זיכרון פנוי (OOM). בקטע הזה מפורטות אפשרויות לצמצום השימוש בזיכרון של צינור עיבוד הנתונים. כדי לזהות את השלבים בצינור עיבוד הנתונים שצורכים הכי הרבה זיכרון, השתמשו ב-Cloud Profiler כדי לעקוב אחרי הביצועים של צינור עיבוד הנתונים.

כדי לשפר את צינור עיבוד הנתונים, אתם יכולים להשתמש בשיטות המומלצות הבאות:

שימוש במחברי קלט/פלט מובנים של Apache Beam לקריאת קבצים

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

תכנון מחדש של פעולות כשמשתמשים ב-GroupByKey PTransforms

כשמשתמשים ב-GroupByKey PTransform ב-Dataflow, הערכים שמתקבלים לכל מפתח ולכל חלון מעובדים ב-thread יחיד. הנתונים האלה מועברים כסטרימינג מהשירות לקצה העורפי של Dataflow ל-workers, ולכן הם לא צריכים להתאים לזיכרון של ה-workers. עם זאת, אם הערכים נאספים בזיכרון, לוגיקת העיבוד עלולה לגרום לשגיאות של חוסר בזיכרון.

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

למידע נוסף על טרנספורמציות PTransform של GroupByKey, קראו את מאמרי העזרה של Apache Beam בנושא GroupByKey ב-Python ו-GroupByKey ב-Java.

ברשימה הבאה מופיעות הצעות לתכנון צינור עיבוד הנתונים כדי לצמצם את צריכת הזיכרון כשמשתמשים ב-PTransforms של GroupByKey.

  • כדי לצמצם את כמות הנתונים לכל מפתח ולכל חלון, כדאי להימנע ממפתחות עם ערכים רבים, שנקראים גם מפתחות חמים.
  • כדי לצמצם את כמות הנתונים שנאספים בכל חלון, צריך להשתמש בחלון קטן יותר.
  • אם אתם משתמשים בערכים של מפתח בחלון כדי לחשב מספר, השתמשו בטרנספורמציה Combine. אל תבצעו את החישוב במכונה אחת של DoFn אחרי איסוף הערכים.
  • לסנן ערכים או כפילויות לפני העיבוד. למידע נוסף, עיינו במסמכי התיעוד של הטרנספורמציה ב-Python Filter וב-Java Filter.

צמצום נתוני הכניסה ממקורות חיצוניים

אם אתם מבצעים קריאות ל-API חיצוני או למסד נתונים לצורך העשרת נתונים, הנתונים שמוחזרים צריכים להתאים לזיכרון של ה-worker. אם אתם שולחים קריאות באצווה, מומלץ להשתמש בטרנספורמציה GroupIntoBatches. אם נתקלים בשגיאות אין זיכרון פנוי (OOM), צריך להקטין את גודל האצווה. למידע נוסף על קיבוץ לקבוצות, עיינו במסמכי התיעוד של הטרנספורמציה ב-Python GroupIntoBatches וב-Java GroupIntoBatches.

שיתוף אובייקטים בין שרשורים

שיתוף של אובייקט נתונים בזיכרון בין מכונות DoFn יכול לשפר את יעילות הגישה והשטח. אובייקטים של נתונים שנוצרו בכל שיטה של DoFn, כולל Setup,‏ StartBundle,‏ Process,‏ FinishBundle ו-Teardown, מופעלים לכל DoFn. ב-Dataflow, לכל worker יכולים להיות כמה מכונות DoFn. כדי להשתמש בזיכרון בצורה יעילה יותר, אפשר להעביר אובייקט נתונים כ-singleton כדי לשתף אותו בין כמה DoFn. מידע נוסף זמין בפוסט בבלוג שימוש חוזר במטמון ב-DoFns.

שימוש בייצוגי רכיבים שחוסכים בזיכרון

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

הקטנת הגודל של קלט צדדי

אם ה-DoFn משתמשים בקלט צדדי, צריך להקטין את הגודל של הקלט הצדדי. בקלט צדדי שהוא אוסף של רכיבים, כדאי להשתמש בתצוגות שניתנות לחזרה, כמו AsIterable או AsMultimap, במקום בתצוגות שיוצרות את כל הקלט הצדדי בבת אחת, כמו AsList.

צמצום מספר השרשורים

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

בטבלה הבאה מוצג מספר ברירת המחדל של ה-threads שנוצרים ב-Dataflow:

סוג המשרה Python SDK ערכות SDK של Java/Go
Batch שרשור אחד לכל vCPU שרשור אחד לכל vCPU
סטרימינג באמצעות Portable Runner (לשעבר Runner v2) ‫12 שרשורים לכל vCPU ‫500 שרשורים לכל worker VM
סטרימינג בלי Portable Runner (לשעבר Runner v2) ‫12 שרשורים לכל vCPU ‫300 שרשורים לכל worker VM

כדי לצמצם את מספר השרשורים של Apache Beam SDK, מגדירים את אפשרות צינור עיבוד הנתונים הבאה:

Java

משתמשים באפשרות --numberOfWorkerHarnessThreads של צינור עיבוד הנתונים.

Python

משתמשים באפשרות --number_of_worker_harness_threads של צינור עיבוד הנתונים.

המשך

משתמשים באפשרות --number_of_worker_harness_threads של צינור עיבוד הנתונים.

במשימות באצ', צריך להגדיר ערך קטן ממספר ה-vCPU.

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

שימוש בסוג מכונה עם יותר זיכרון לכל vCPU

כדי לבחור וורקר עם יותר זיכרון לכל vCPU, אפשר להשתמש באחת מהשיטות הבאות.

  • משתמשים במכונה מרובת זיכרון (high-memory) במשפחת המכונות למטרות כלליות. במכונות מרובות זיכרון (high-memory) יש יותר זיכרון לכל vCPU מאשר במכונות לשימוש סטנדרטי (standard). שימוש במכונה מרובת זיכרון (high-memory) מגדיל גם את הזיכרון שזמין לכל worker וגם את הזיכרון שזמין לכל שרשור, כי מספר ה-vCPU נשאר זהה. לכן, שימוש במכונה מרובת זיכרון (high-memory) יכול להיות דרך חסכונית לבחור וורקר עם יותר זיכרון לכל vCPU.
  • כדי ליהנות מגמישות רבה יותר כשמציינים את מספר יחידות ה-vCPU ואת נפח הזיכרון, אפשר להשתמש בסוג מכונה בהתאמה אישית. בסוגי מכונות בהתאמה אישית, אפשר להגדיל את הזיכרון במרווחים של 256MB. המחירים של סוגי המכונות האלה שונים מהמחירים של סוגי המכונות הרגילים.
  • בחלק ממשפחות המכונות אפשר להשתמש בסוגי מכונות בהתאמה אישית עם זיכרון מורחב. זיכרון מורחב מאפשר יחס גבוה יותר של זיכרון לכל vCPU. העלות גבוהה יותר. דוגמאות לסוגי מכונות בהתאמה אישית עם זיכרון מורחב: n2-custom-1-19456-ext ו-n2-custom-8-317440-ext.

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

Java

משתמשים באפשרות --workerMachineType של צינור עיבוד הנתונים.

Python

משתמשים באפשרות --machine_type של צינור עיבוד הנתונים.

המשך

משתמשים באפשרות --worker_machine_type של צינור עיבוד הנתונים.

שימוש בתהליך אחד בלבד של Apache Beam SDK

בפייפליינים זורמים של Python ובפייפליינים של Python שמשתמשים ב-Portable Runner, אפשר לאלץ את Dataflow להפעיל רק תהליך אחד של Apache Beam SDK לכל worker.

לפני שאתם מנסים את האפשרות הזו, נסו קודם לפתור את הבעיה בשיטות האחרות. כדי להגדיר את ה-worker VM ב-Dataflow להפעיל רק תהליך Python אחד בקונטיינר, משתמשים באפשרות צינור עיבוד הנתונים הבאה:

--experiments=no_use_multiple_sdk_containers

בהגדרה הזו, צינורות עיבוד נתונים ב-Python יוצרים תהליך אחד של Apache Beam SDK לכל worker. ההגדרה הזו מונעת שכפול של האובייקטים והנתונים המשותפים כמה פעמים לכל תהליך של Apache Beam SDK. עם זאת, היא מגבילה את השימוש היעיל במשאבי המחשוב שזמינים ב-worker.

הפחתת מספר התהליכים של Apache Beam SDK לאחד לא בהכרח מפחיתה את המספר הכולל של ה-threads שמתחילים ב-worker. בנוסף, אם כל ה-threads נמצאים בתהליך אחד של Apache Beam SDK, יכול להיות שהעיבוד יהיה איטי או שצינור עיבוד הנתונים ייתקע. לכן, יכול להיות שתצטרכו גם להפחית את מספר ה-threads, כמו שמתואר בקטע הפחתת מספר ה-threads בדף הזה.

אפשר גם לאלץ את ה-workers להשתמש רק בתהליך אחד של Apache Beam SDK, באמצעות סוג מכונה עם vCPU אחד בלבד.

שימוש במנגנון אחר לאיסוף אשפה ב-Java

כברירת מחדל, ה-workers של Dataflow ב-Java משתמשים ב-Parallel collector‏ (-XX:+UseParallelGC), שממקסם את תפוקת המעבד (CPU) עם תקורה נמוכה של מטא-נתונים. עם זאת, הוא משתמש בהפסקות stop-the-world ומתעדף את התפוקה על פני צמצום טביעת הרגל של ה-heap. מכיוון שהיא מחזירה את הדור הישן רק במהלך איסוף מלא, הקצאות תכופות יכולות לדחוף את השימוש בערימה קרוב למקסימום לפני שהאיסוף פועל, במיוחד ב-JDK 21 ואילך. בשילוב עם זיכרון מחוץ לערימה, הגידול בשיא יכול לגרום להשהיות ארוכות, לניקוי זיכרון לא יעיל או לשגיאות של אין זיכרון פנוי (OOM).

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

אם מתרחשות שגיאות של אין זיכרון פנוי (OOM) או העמסה (thrashing) תכופות בהקצאות, נסו להשתמש באספן אחר באמצעות אפשרות הצינור --experiments. הערכים הנתמכים הם --experiments=java_gc=UseG1GC או --experiments=java_gc=UseZGC (ל-Java 17 ואילך).

הסבר על השימוש בזיכרון ב-Dataflow

כדי לפתור שגיאות של אין זיכרון פנוי (OOM), חשוב להבין איך צינורות עיבוד הנתונים של Dataflow משתמשים בזיכרון.

כש-Dataflow מריץ צינור עיבוד נתונים, העיבוד מופץ בין כמה מכונות וירטואליות (VM) של Compute Engine, שלרוב נקראות "רכיבי worker". ה-workers מעבדים פריטי עבודה משירות Dataflow ומקצים את פריטי העבודה לתהליכים של Apache Beam SDK. תהליך של Apache Beam SDK יוצר מכונות של DoFn. ‫DoFn היא מחלקה של Apache Beam SDK שמגדירה פונקציית עיבוד מבוזרת.

‫Dataflow מפעיל כמה שרשורים בכל worker, והזיכרון של כל worker משותף לכל השרשורים. שרשור הוא משימה אחת שניתנת להפעלה ופועלת בתוך תהליך גדול יותר. מספר ברירת המחדל של ה-threads תלוי בכמה גורמים, והוא משתנה בין משימות באצווה לבין משימות בסטרימינג.

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

צינורות עיבוד נתונים של Dataflow משתמשים בזיכרון של ה-worker בעיקר בשלוש דרכים:

זיכרון תפעולי של העובד

ה-workers של Dataflow צריכים זיכרון בשביל מערכות ההפעלה ותהליכי המערכת שלהם. השימוש בזיכרון של ה-worker הוא בדרך כלל לא יותר מ-1GB. בדרך כלל השימוש הוא פחות מ-1GB.

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

זיכרון התהליך של ה-SDK

תהליכים של Apache Beam SDK עשויים ליצור אובייקטים ונתונים שמשותפים בין שרשורים בתוך התהליך, שבדף הזה נקראים אובייקטים ונתונים משותפים של SDK. השימוש בזיכרון של האובייקטים והנתונים המשותפים האלה ב-SDK נקרא "זיכרון התהליך של ה-SDK". הרשימה הבאה כוללת דוגמאות לאובייקטים ולנתונים שמשותפים ב-SDK:

  • מקורות קלט נוספים
  • מודלים של למידת מכונה
  • אובייקטים מסוג singleton בזיכרון
  • אובייקטים של Python שנוצרו באמצעות המודול apache_beam.utils.shared
  • נתונים שנטענו ממקורות חיצוניים, כמו Cloud Storage או BigQuery

משימות סטרימינג שלא משתמשות ב-Streaming Engine מאחסנות קלט צדדי בזיכרון. בצינורות עיבוד נתונים ב-Java וב-Go, לכל worker יש עותק אחד של קלט הצד. בצינורות עיבוד נתונים ב-Python, לכל תהליך של Apache Beam SDK יש עותק אחד של קלט הצד.

במשימות סטרימינג שמשתמשות ב-Streaming Engine, הגודל של קלט צדדי מוגבל ל-80MB. קלט צדדי מאוחסן מחוץ לזיכרון של ה-worker.

השימוש בזיכרון מאובייקטים ונתונים משותפים של SDK גדל באופן ליניארי עם מספר התהליכים של Apache Beam SDK. בצינורות עיבוד נתונים ב-Java וב-Go, מופעל תהליך אחד של Apache Beam SDK לכל worker. בצינורות עיבוד נתונים ב-Python, תהליך אחד של Apache Beam SDK מופעל לכל vCPU. אובייקטים ונתונים משותפים של SDK משמשים שוב בשרשורים באותו תהליך של Apache Beam SDK.

שימוש בזיכרון של DoFn

‫DoFn היא מחלקה של Apache Beam SDK שמגדירה פונקציית עיבוד מבוזרת. כל וורקר יכול להריץ בו-זמנית DoFn מכונות. כל שרשור מפעיל מכונה אחת של DoFn. כשמעריכים את השימוש הכולל בזיכרון, כדאי לחשב את גודל קבוצת העבודה או את כמות הזיכרון שהאפליקציה צריכה כדי להמשיך לפעול. לדוגמה, אם DoFn בודד משתמש ב-5MB זיכרון לכל היותר, ול-worker יש 300 שרשורים, השימוש בזיכרון של DoFn יכול להגיע לשיא של 1.5GB, או מספר הבייטים של הזיכרון כפול מספר השרשורים. בהתאם לאופן שבו ה-workers משתמשים בזיכרון, עלייה חדה בשימוש בזיכרון עלולה לגרום לכך שה-workers יהיו ללא זיכרון פנוי (OOM).

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

Beam Python SDK

Batch סטרימינג בלי Streaming Engine מנוע סטרימינג
מקביליות

תהליך אחד לכל vCPU

שרשור אחד לכל תהליך

שרשור אחד לכל vCPU

תהליך אחד לכל vCPU

‫12 שרשורים לכל תהליך

‫12 שרשורים לכל vCPU

תהליך אחד לכל vCPU

‫12 שרשורים לכל תהליך

‫12 שרשורים לכל vCPU

מספר מקסימלי של מופעי DoFn בו-זמניים (כל המספרים האלה עשויים להשתנות בכל שלב).

‫DoFn אחת לכל שרשור

‫DoFn אחד לכל vCPU

‫DoFn אחת לכל שרשור

‫12 DoFn לכל vCPU

‫DoFn אחת לכל שרשור

‫12 DoFn לכל vCPU

Beam Java/Go SDK

Batch מכשיר סטרימינג ומנוע סטרימינג בלי Portable Runner מנוע סטרימינג עם Portable Runner
מקביליות

תהליך אחד לכל worker VM

שרשור אחד לכל vCPU

תהליך אחד לכל worker VM

‫300 שרשורים לכל תהליך

‫300 שרשורים לכל worker VM

תהליך אחד לכל worker VM

‫500 שרשורים לכל תהליך

‫500 שרשורים לכל worker VM

מספר מקסימלי של מופעי DoFn בו-זמניים (כל המספרים האלה עשויים להשתנות בכל שלב).

‫DoFn אחת לכל שרשור

‫DoFn אחד לכל vCPU

‫DoFn אחת לכל שרשור

‫300 DoFn לכל worker VM

‫DoFn אחת לכל שרשור

‫500 DoFn לכל worker VM

לדוגמה, כשמשתמשים ב-Python SDK עם worker של n1-standard-2 Dataflow:

  • משימות באצווה: Dataflow מפעיל תהליך אחד לכל vCPU (שניים במקרה הזה). כל תהליך משתמש בשרשור אחד, וכל שרשור יוצר מכונה אחת של DoFn.
  • משימות סטרימינג עם Streaming Engine: ‏Dataflow מפעיל תהליך אחד לכל vCPU (שניים בסך הכול). עם זאת, כל תהליך יכול ליצור עד 12 שרשורים, ולכל אחד מהם יש מופע DoFn משלו.

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

כשיש לכם צינור עיבוד נתונים בכמה שפות, ויותר מ-Apache Beam SDK אחד פועל ב-worker, ה-worker משתמש במידה הנמוכה ביותר האפשרית של מקביליות של שרשור לכל תהליך.

ההבדלים בין Java,‏ Go ו-Python

התהליכים והזיכרון מנוהלים באופן שונה ב-Java, ב-Go וב-Python. לכן, הגישה לפתרון בעיות של שגיאות אין זיכרון פנוי (OOM) משתנה בהתאם לשפה שבה משתמשים בפייפליין – Java,‏ Go או Python.

צינורות עיבוד נתונים ב-Java וב-Go

בצינורות עיבוד נתונים ב-Java וב-Go:

  • כל וורקר מפעיל תהליך אחד של Apache Beam SDK.
  • אובייקטים ונתונים משותפים של SDK, כמו קלט צדדי ומטמונים, משותפים בין כל ה-threads ב-worker.
  • הזיכרון שמשמש את האובייקטים והנתונים המשותפים של ה-SDK בדרך כלל לא משתנה בהתאם למספר ה-vCPU ב-worker.

צינורות עיבוד נתונים ב-Python

בצינורות עיבוד נתונים ב-Python:

  • כל worker מפעיל תהליך אחד של Apache Beam SDK לכל vCPU.
  • אובייקטים ונתונים משותפים של SDK, כמו קלט צדדי ומטמונים, משותפים בין כל ה-threads בכל תהליך של Apache Beam SDK.
  • המספר הכולל של ה-threads ב-worker משתנה באופן לינארי בהתאם למספר המעבדים הווירטואליים. כתוצאה מכך, הזיכרון שמשמש את האובייקטים והנתונים המשותפים של ה-SDK גדל באופן ליניארי עם מספר ה-vCPU.
  • השרשורים שמבצעים את העבודה מפוזרים בין התהליכים. יחידות עבודה חדשות מוקצות לתהליך שאין בו פריטי עבודה, או לתהליך עם מספר פריטי העבודה הנמוך ביותר שמוקצים באותו זמן.