פתרון בעיות של צווארי בקבוק ב-Dataflow

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

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

הסבר על צווארי בקבוק

כש-Dataflow מריץ פייפליין זורם, המשימה מורכבת מסדרה של רכיבים, כמו ערבובים בסטרימינג, שרשורי עיבוד של פונקציות בהגדרת המשתמש (DoFn) ונקודות ביקורת של מצב מתמיד. כדי להקל על זרימת הנתונים, ב-Dataflow נעשה שימוש בתורים לחיבור הרכיבים האלה. הנתונים נשלחים מהמקור upstream אל המקור downstream.

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

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

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

‫Dataflow מזהה צוואר בקבוק כשהעיכוב חורג מהסף של חמש דקות. אם העיכוב לא חורג מהסף הזה, Dataflow לא מזהה צוואר בקבוק.

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

סוגי צווארי בקבוק

כש-Dataflow מזהה צוואר בקבוק, ממשק המעקב מציין את חומרת הבעיה. צווארי הבקבוק מתחלקים לקטגוריות הבאות:

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

הגורמים לצווארי בקבוק

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

פעולות עם זמן עיבוד ארוך

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

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

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

ה-Key Commit גדול מדי

ראו חריגה מסוג "שמירת המפתח גדולה מדי".

אין הרשאה לכיור של BigQuery

השגיאה הזו מציינת שלחשבון השירות שמריץ את צינור עיבוד הנתונים אין את ההרשאות הנדרשות כדי לכתוב למשאב BigQuery.

כדי לאמת את הבעיה הזו באמצעות יומני ה-worker:

  1. במסוף Google Cloud , פותחים את הדף Job details ב-Dataflow.
  2. בחלונית התחתונה, לוחצים על הכרטיסייה Logs ובוחרים באפשרות Worker Logs.
  3. מחפשים הודעות שגיאה שמעידות על דחיית הרשאות או גישה (לדוגמה, PERMISSION_DENIED,‏ 403 Forbidden,‏ Access Denied או actuallyForbidden).
  4. בודקים את הודעת היומן כדי לזהות את הטבלה או את מערך הנתונים של היעד, ואת ההרשאה הספציפית שחסרה (למשל bigquery.tables.updateData).

כדי לפתור את הבעיה:

  • מוודאים שלחשבון השירות הוקצה התפקיד BigQuery Data Editor (roles/bigquery.dataEditor) במערך הנתונים ובטבלה של היעד.
  • אם אתם כותבים בין פרויקטים, ודאו שההרשאות ניתנות לחשבון השירות ישירות בפרויקט היעד שמארח את מערך הנתונים ב-BigQuery, ושהתקשורת בין שני הפרויקטים מותרת ב-VPC Service Controls (אם הוא מופעל).

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

המשאב של כיור BigQuery מוצה

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

כדי לאמת את הבעיה הזו באמצעות יומני ה-worker:

  1. במסוף Google Cloud , פותחים את הדף Job details ב-Dataflow.
  2. בחלונית התחתונה, לוחצים על הכרטיסייה Logs ובוחרים באפשרות Worker Logs.
  3. חפשו הודעות שגיאה שמציינות שהמשאבים או המכסות מוצו, או שחרגתם ממגבלות הקצב (לדוגמה, RESOURCE_EXHAUSTED,‏ 429 Too Many Requests,‏ quotaExceeded או rateLimitExceeded).
  4. בודקים את הודעת היומן כדי לוודא איזו פעולה ואיזו מכסה חרגו מהמגבלה (לדוגמה, מגבלות החיבור או הקיבולת של Storage Write API AppendRows, או מגבלות הקצב של הזנת זרם נתונים).

כדי לפתור את הבעיה:

  • בודקים באיזו הטמעה של BigQuery sink משתמשים בצינור עיבוד הנתונים (לדוגמה, Storage Write API או הזנת זרם נתונים).
  • במסוף Google Cloud , בודקים את השימוש במכסות של BigQuery. חפשו מכסות שקשורות לסוג הכיור, כמו חיבורים בו-זמניים, תפוקה או שורות של הזנת זרם נתונים לשנייה.
  • אם אתם מתקרבים למגבלות האלה או חורגים מהן באופן קבוע, כדאי לבקש הגדלה של המכסה.

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

כשל ב-RPC של כיור BigQuery

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

כדי לאמת את הבעיה הזו באמצעות יומני ה-worker:

  1. במסוף Google Cloud , פותחים את הדף Job details ב-Dataflow.
  2. בחלונית התחתונה, לוחצים על הכרטיסייה Logs ובוחרים באפשרות Worker Logs.
  3. מחפשים הודעות שגיאה או חריגות שקשורות לפעולות כתיבה ב-BigQuery (לדוגמה, DEADLINE_EXCEEDED,‏ UNAVAILABLE,‏ INVALID_ARGUMENT או שגיאות אימות סכימה).
  4. בודקים את דוח הקריסות ואת הודעת השגיאה כדי לזהות את מצב הכשל הספציפי שהוחזר על ידי BigQuery API.

כדי לפתור את הבעיה:

  • אחרי שמזהים את הודעת השגיאה או את קוד הסטטוס הספציפיים ביומני ה-worker, אפשר לעיין בחומר העזר בנושא הודעות שגיאה ב-BigQuery כדי לקבל הנחיות ספציפיות לפתרון הבעיה שגרמה לשגיאה.
  • אם אתם משתמשים ב-Storage Write API בצינור עיבוד הנתונים, תוכלו לקרוא את הקטע טיפול בשגיאות במאמרי העזרה של ה-API של BigQuery Storage Write API כדי לדעת איך לטפל בשגיאות ספציפיות בכתיבה ובסטרימינג.
הוויסות של כיור BigQuery

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

כדי לבדוק אם הבעיה נפתרה:

  1. במסוף Google Cloud , פותחים את הדף Job details ב-Dataflow.
  2. לוחצים על הכרטיסייה Job metrics או Step info כדי לוודא שזמן העיבוד של שלב ה-sink ב-BigQuery ארוך יותר.
  3. במסוף Google Cloud , פותחים את הדף Quotas & System Limits של פרויקט היעד ב-BigQuery ובודקים אם השימוש מתקרב למכסות הכתיבה ב-BigQuery.

כדי לפתור את הבעיה:

  • בודקים באיזו הטמעה של sink ב-BigQuery משתמש ה-pipeline, למשל Storage Write API או הזנת זרם נתונים.
  • במסוף Google Cloud , בודקים את השימוש במכסות של BigQuery. חפשו מכסות שקשורות לסוג הכיור, כמו קצב העברת הנתונים של פעולת append ב-Storage Write API, חיבורים בו-זמניים או שורות של הזנת זרם נתונים לשנייה. גם אם הבקשות לא נכשלות עם שגיאות מכסה מפורשות, BigQuery יכול להגביל את הבקשות כשהשימוש מתקרב למגבלות המכסה.
  • אם אתם מגיעים למגבלות האלה באופן קבוע, כדאי לבקש הגדלה של המכסה.

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

זמן עיבוד ארוך בכל הפעולות

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

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

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

קריאה איטית של מצב קבוע

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

כתיבה איטית של מצב מתמיד

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

ההתחייבות נדחתה

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

אין מספיק מחיצות מקור ב-Apache Kafka

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

  • מגדילים את מספר המחיצות של Kafka.
  • כשמגדירים את Kafka IO read, כדאי לכלול חלוקה מחדש באמצעות .withRedistribute() כדי להפוך את הנתונים למקבילים בצורה יעילה יותר. כדי להגדיר גבול עליון למספר הכולל של המפתחות, צריך לכלול את .withRedistributeNumKeys(N) כאשר N > partitions. מספר מוגבל של מפתחות מאפשר לאגד רשומות בצורה יעילה.
  • כדי לצמצם את העלות של ערבוב החלוקה מחדש, משתמשים ב-.withOffsetDeduplication(). המצב הזה מצמצם את כמות הנתונים שצריך לשמור כחלק מהערבוב, ועדיין מספק עיבוד של פעם אחת בדיוק.

מידע נוסף זמין בקטע מקביליות בדף קריאה מ-Apache Kafka ל-Dataflow.

‫Apache Kafka Source Large Volume of Persisted State

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

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

מידע נוסף זמין במאמר קריאה מ-Apache Kafka ל-Dataflow.

אין מספיק מקביליות במקור

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

מפתחות חמים או מקביליות לא מספיקה של מפתחות

במשימה יש מפתחות חמים או שאין מספיק מקביליות של מפתחות.

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

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

הקצאת-חסר של מעבדים וירטואליים (vCPU)

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

ניצול גבוה של vCPU, בהמתנה להגדלת קנה המידה

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

עומס לא מאוזן על ה-vCPU שיוצר צווארי בקבוק בחלק מה-workers החריגים

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

כדי לפתור את הבעיה, נסו את הפתרונות הבאים:

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

ל-Dataflow אין אפשרות לתקשר עם כל ה-worker VMs. בודקים את הסטטוס של ה-worker VMs של המשימה. סיבות אפשריות:

  • יש בעיה בהקצאת ה-worker VMs.
  • מאגר ה-worker VM נמחק בזמן שהמשימה פועלת.
  • בעיות ברשת.
יש שגיאות במשיכה ממקור Pub/Sub.

יש שגיאות במשיכת נתונים מהמקור ב-Pub/Sub. מוודאים שהנושא והמינויים הנדרשים קיימים, ובודקים את המכסה וההגדרות. אפשר גם לבדוק אם יש שגיאות ביומנים.

אין מספיק מקביליות במקור Pub/Sub

בחישוב של מקור ה-Pub/Sub אין מספיק מפתחות Pub/Sub. כדי להגדיל את מספר המפתחות, מגדירים את אפשרות השירות num_pubsub_keys. מידע נוסף זמין במאמר מקביליות של מקור Pub/Sub.

מקור Pub/Sub הוגבל מסיבה לא ידועה

החישוב של מקור Pub/Sub מוגבל בזמן הקריאה מ-Pub/Sub, מסיבה לא ידועה. יכול להיות שזו בעיה זמנית. בודקים אם יש בעיות בהגדרות של Pub/Sub, אם חסרות הרשאות IAM או אם הגעתם למגבלות המכסות. אם אף אחד מהתחומים הקודמים הוא לא שורש הבעיה והבעיה נמשכת, פנו לתמיכה.

הפרסום בכיור של Pub/Sub איטי או תקוע

החישוב של כיור Pub/Sub איטי או תקוע. יכול להיות שהבעיה נגרמה בגלל בעיה בהגדרות או בגלל מגבלת מכסה.

זמן המתנה ארוך בתור העבודה

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

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

(key count / total harness threads) * latency per bundle

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

בעיה זמנית בקצה העורפי של מנוע הסטרימינג

יש בעיה בהגדרות או בתפעול של ה-backend של Streaming Engine. יכול להיות שזו בעיה זמנית. אם הבעיה נמשכת, פנו לתמיכה.

סיבה שלא ניתן לקבוע

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

מדדי צוואר בקבוק

המדדים הבאים של המשימה מספקים מידע על צווארי בקבוק:

המאמרים הבאים