באמצעות Cloud Tasks אתם יכולים לשלוח כמויות גדולות של משימות אסינכרוניות, תוך שליטה בקצב שבו התנועה מגיעה לתורים ולשירותים במורד הזרם. אם תיישמו דפוסי הגברה הדרגתית ואמצעי בקרה על קצב, תוכלו להגדיל את עומסי העבודה בצורה חלקה בלי לגרום לעלייה חדה בזמן האחזור בתור או לעומס יתר על היעד כשהתנועה גדלה מהר יותר מהקצב שבו התשתית יכולה להסתגל.
סקירה כללית
במסמך הזה מפורטות השיטות המומלצות לשמירה על ביצועים גבוהים של Cloud Tasks בתורים עם תנועה רבה. תור עם TPS גבוה הוא תור שנוצרות או נשלחות בו 500 משימות בשנייה (TPS) או יותר. קבוצת תורים עם מספר גבוה של טרנזקציות לשנייה היא קבוצה רציפה של תורים, לדוגמה [queue0001, queue0002, …, queue0099], שנוצרות או נשלחות בהן לפחות 2,000 משימות בשנייה בסך הכול. כדי לראות את היסטוריית ה-TPS של תור או של קבוצת תורים, אפשר להשתמש במדדים של Cloud Monitoring, api/request_count לפעולות של CreateTask ו-queue/task_attempt_count לניסיונות של משימות. תורים וקבוצות של תורים עם נפח תנועה גדול נוטים לשני סוגים שונים של כשלים:
עומס יתר בתור מתרחש כשקצב יצירת המשימות ושליחתן לתור בודד או לקבוצת תורים עולה מהר יותר מהקצב שבו תשתית התור יכולה להסתגל. התשתית של Google משתמשת בשכבות דינמיות שמקצות מחדש את העומס באופן דינמי על סמך דפוסי התנועה, וההתאמה הזו לוקחת זמן. באופן דומה, עומס יתר ביעד מתרחש כשקצב שליחת המשימות גורם לעליות חדות בתנועה בתשתית היעד במורד הזרם. בשני המקרים, צריך לפעול לפי דפוס של 500/50/5: כשמגדילים את קצב הבקשות מעבר ל-500 לשנייה, מגדילים את התנועה בלא יותר מ-50% כל 5 דקות.
בנפרד מהתבנית 500/50/5 לעומסי עבודה עם מספר גבוה של TPS, ההגדלה ההדרגתית הראשונית של התור משפיעה על כל התורים כשהם מתחילים ממצב קר או לא פעיל, כולל תורים שהוגדרו לקצבי שליחה מתונים. במאמר הזה נסקור תרחישים שונים שעלולים לגרום לסיכונים בהתאמה לעומס, וניתן דוגמאות לניהול של הגדלת התור וליישום של דפוס 500/50/5.
הגדלה ראשונית של התור
התבנית 500/50/5 חלה על תורים עם מספר גבוה של TPS שכבר פועלים במצב יציב. ההתחממות הראשונית של התור היא מנגנון מערכת נפרד שחל על כל התורים, כולל תורים שמוגדרים לקצבי שליחה מתונים כמו 20-100 TPS, כשהם עוברים ממצב קר או לא פעיל לפעולה במצב יציב.
תור נכנס למצב קר או לא פעיל בכל אחד מהמצבים הבאים:
התור נוצר לאחרונה או הופעל מחדש אחרי שהושהה.
התור לא היה פעיל במשך כמה דקות, בלי הקצאות פעילות.
התור מתאושש אחרי שחזר בו מתגובות שגיאה
429או5xxשל HTTP במורד הזרם. למידע נוסף על האופן שבו השהיה לפני ניסיון חוזר (backoff) משפיעה על קצב השליחה, ראו שגיאות השהיה לפני ניסיון חוזר (backoff) וקצבים שנאכפים.
כשהמשימות מגיעות לתור קר או לא פעיל, Cloud Tasks לא שולח אותן מיד בקצב של max_dispatches_per_second שהוגדר. כדי להגן על יעדים במורד הזרם מפני עלייה פתאומית בתנועה, Cloud Tasks מתחיל לשלוח בקצב בסיסי נמוך, למשל בסביבות 1 TPS. לאחר מכן, הוא מגדיל בהדרגה את קצב השליחה שנאכף במרווחי הערכה תקופתיים. הקצב שנאכף ממשיך לעלות כל עוד הביקוש לתור נשאר רווי, ורכיבי ה-handler של היעד מחזירים תגובות HTTP 2xx. בהתאם לקצב היעד, יכול להיות שיעברו כמה דקות עד שהערכים של max_dispatches_per_second יהיו גבוהים.
אם עומס העבודה שולח תנועה עם קפיצות חדות שמופרדות על ידי תקופות קצרות של חוסר פעילות, של כמה דקות או יותר, התור מתאפס למצב קר בין פרצי התנועה וחוזר על תהליך ההתחממות בכל פרץ. כדי לצמצם את העיכובים בהגדלת העומס בעומסי עבודה שרגישים לעומסים פתאומיים, כדאי לפעול לפי השיטות המומלצות הבאות:
שמרו על זרימה קבועה של תנועה בסיסית כדי לשמור על תורים רגישים לזמן אחזור בין פרצי תנועה.
עדיף להשתמש מחדש בתורים קיימים במקום למחוק וליצור תורים חדשים לעיתים קרובות.
הקצו מספיק קיבולת יעד במורד הזרם כדי שה-handlers יחזירו תגובות HTTP מסוג
2xx, ולא יחזירו תגובות שגיאה מסוג HTTP429או5xxשיאפסו את קצב השליחה שנאכף.
אבחון של ויסות קצב הנתונים בתור
אם התור שולח משימות בקצב איטי יותר מהקצב שהגדרתם ב-max_dispatches_per_second, בדקו אם צוואר הבקבוק נובע מהגדלת קצב השליחה של תור קר או לא פעיל, מהפחתת קצב השליחה בגלל עומס ביעד או ממגבלות בו-זמניות.
הגדלת נפח התנועה בתור קר או לא פעיל
אם כל התנאים הבאים מתקיימים, סביר להניח שהסיבה היא הגדלת התור הראשונית:
- התור נוצר לאחרונה, הופעל מחדש אחרי שהושהה או היה במצב של חוסר פעילות במשך כמה דקות לפני שהגיעה תנועה.
- ניסיונות המשימה מצליחים ללא שגיאות יעד, ומוצג הערך
response_code="OK"במדד המעקבcloudtasks.googleapis.com/queue/task_attempt_count. - מספר הבקשות שנשלחות נשאר מתחת ל-
max_concurrent_dispatches, אבל הערך שלcloudtasks.googleapis.com/queue/depthאו שלcloudtasks.googleapis.com/queue/task_attempt_delaysגבוה. במקביל, קצב השליחה ב-cloudtasks.googleapis.com/queue/task_attempt_countעולה בהדרגה במרווחי הערכה תקופתיים.
איך שולחים מדדים ל-Monitoring?
עומס יתר ביעד והשהיה לפני ניסיון חוזר (backoff) במקרה של עומס
אם היעד במורד הזרם מחזיר תגובות שגיאת HTTP 429 Too Many Requests או שגיאת HTTP 5xx, כמו שגיאת HTTP 503 Service Unavailable, מערכת Cloud Tasks מפחיתה באופן דינמי את קצבי השליחה. ההאטה הזו מונעת עומס יתר על היעד.
כדי לבדוק אם שגיאות ביעד גורמות ל-Cloud Tasks לווסת את השליחות, אפשר להציג את המדד cloudtasks.googleapis.com/queue/task_attempt_count ב-Monitoring, מקובץ לפי התווית response_code. אם הפעלתם את הרישום ביומן של התור, אתם יכולים גם לבדוק את יומני התגובות לניסיונות ב-Logs Explorer:
resource.type="cloud_tasks_queue"
jsonPayload.attemptResponseLog.status!="OK"
גם ב-response_code וגם ב-jsonPayload.attemptResponseLog.status, Cloud Tasks מתעד קודי סטטוס קנוניים של gRPC במקום קודי סטטוס מספריים של HTTP. לדוגמה, קוד HTTP 429 ממופה ל-RESOURCE_EXHAUSTED, קוד HTTP 503 ממופה ל-UNAVAILABLE, קוד HTTP 500 ממופה ל-INTERNAL וקוד HTTP 504 או זמן קצוב לתפוגה ממופים ל-DEADLINE_EXCEEDED.
אם אתם רואים סטטוסים של שגיאות בחיבור לשרת כמו RESOURCE_EXHAUSTED, UNAVAILABLE או אחרים מהיעד, הגדילו את מספר המכונות של שירות היעד או את מספר הבקשות בו-זמנית ליעד לפני שתגדילו את מגבלות השליחה של התור.
למידע נוסף על הפעלת יומני תורים, ראו שימוש ב-Cloud Logging עם תורים.
צוואר בקבוק בבו-זמניות (concurrency)
לפי חוק ליטל, זמן האחזור של היעד במורד הזרם מגביל את קצב השליחה המקסימלי:
Max Throughput (tasks/sec) = min(
max_dispatches_per_second,
max_concurrent_dispatches / Downstream Latency in seconds
)
לדוגמה, אם זמן האחזור של הביצוע במורד הזרם הוא 2 שניות, והערך של max_concurrent_dispatches מוגדר ל-100, קצב העיבוד מוגבל ל-50 משימות בשנייה, גם אם הערך של max_dispatches_per_second מוגדר ל-500.
כדי לבדוק אם הבעיה היא במספר הבקשות בו-זמנית, מחלקים את הערך של max_concurrent_dispatches בזמן האחזור של התגובה ביעד, שמתועד בשדה jsonPayload.attemptResponseLog.attemptDuration ב-Logging. משווים את הסף המחושב הזה לקצב השליחה בפועל במדד המעקב cloudtasks.googleapis.com/queue/task_attempt_count. אם מספר ההקצאות בפועל מתייצב קרוב לסף הזה בזמן ש-cloudtasks.googleapis.com/queue/depth או cloudtasks.googleapis.com/queue/task_attempt_delays גדלים, בצעו אחת מהפעולות הבאות:
- אם ליעד במורד הזרם יש קיבולת פנויה, למשל כשמשימות מבלות את רוב הזמן בהמתנה לקלט/פלט חיצוני, מגדילים את
max_concurrent_dispatches. - אם יעד ה-downstream כבר נמצא בשימוש גבוה במשאבים, הגדלת
max_concurrent_dispatchesעלולה להחמיר את עומס היתר ביעד. במקום זאת, הרחיבו אופקית את מכונות היעד או צמצמו את זמן האחזור של ביצוע ה-handler.
עומס יתר בתור
תורים או קבוצות של תורים יכולים להיות עמוסים בכל פעם שיש עלייה פתאומית בתנועה. כתוצאה מכך, יכול להיות שבתורים האלה יהיו:
- זמן אחזור ארוך יותר ביצירת משימות
- שיעור שגיאות גבוה יותר ביצירת משימות
- קצב שליחה מופחת
כדי להתגונן מפני מצב כזה, צריך להגדיר אמצעי בקרה בכל מצב שבו קצב היצירה או השליחה של תור או קבוצת תורים יכול לעלות בפתאומיות. מתחילים עם מקסימום של 500 פעולות בשנייה לתור קר או לקבוצת תורים, ואז מגדילים את התנועה ב-50% כל 5 דקות. באופן תיאורטי, אפשר להגיע ל-740,000 פעולות בשנייה אחרי 90 דקות באמצעות לוח הזמנים הזה להגדלת נפח הפעילות. יש כמה נסיבות שבהן זה יכול לקרות.
לדוגמה:
- השקת תכונות חדשות שמשתמשות הרבה ב-Cloud Tasks
- העברת תנועה בין תורים
- איזון מחדש של התנועה בין יותר או פחות תורים
- הרצת משימות באצווה שמזריקות מספר גדול של משימות
במקרים כאלה ובמקרים אחרים, כדאי לפעול לפי התבנית 500/50/5.
שימוש בחלוקת התנועה ב-App Engine
אם אפליקציית App Engine יוצרת את המשימות, אתם יכולים להשתמש בחלוקת התנועה של App Engine (בסביבת ברירת המחדל ב-App Engine או בסביבה גמישה ב-App Engine) כדי למתן את העליות בתנועה. כדי לשמור על תקינות התור, אתם יכולים לפצל את התנועה בין גרסאות (סביבה רגילה או סביבה גמישה) ולהגדיל את קצב הבקשות המנוהלות לאורך זמן. לדוגמה, נניח שרוצים להגדיל את התנועה לקבוצת תורים שהורחבה לאחרונה: נניח ש-[queue0000, queue0199] הוא רצף של תורים עם מספר גבוה של TPS, שמקבלים בסך הכול 100,000 יצירות של TPS בשיא.
נניח ש-[queue0200, queue0399] הוא רצף של תורים חדשים. אחרי שמעבירים את כל התנועה, מספר התורים ברצף מוכפל וטווח התורים החדש מקבל 50% מכלל התנועה של הרצף.
כשפורסים את הגרסה שמגדילה את מספר התורים, מגדילים בהדרגה את התנועה לגרסה החדשה, וכך גם לתורים החדשים, באמצעות חלוקת התנועה:
- מתחילים להעביר 1% מהתנועה לגרסה החדשה. לדוגמה, 50% מ-1% מ-100,000 TPS מניבים 500 TPS לקבוצת התורים החדשה.
- כל 5 דקות, מגדילים ב-50% את התנועה שנשלחת לגרסה החדשה, כמו שמתואר בטבלה הבאה:
| מספר הדקות שחלפו מאז תחילת הפריסה | % מכלל התנועה שהועברה לגרסה החדשה | % מנפח התנועה הכולל לתורים החדשים | % מנפח התנועה הכולל לתורים הישנים |
|---|---|---|---|
| 0 | 1.0 | 0.5 | 99.5 |
| 5 | 1.5 | 0.75 | 99.25 |
| 10 | 2.3 | 1.15 | 98.85 |
| 15 | 3.4 | 1.7 | 98.3 |
| 20 | 5.1 | 2.55 | 97.45 |
| 25 | 7.6 | 3.8 | 96.2 |
| 30 | 11.4 | 5.7 | 94.3 |
| 35 | 17.1 | 8.55 | 91.45 |
| 40 | 25.6 | 12.8 | 87.2 |
| 45 | 38.4 | 19.2 | 80.8 |
| 50 | 57.7 | 28.85 | 71.15 |
| 55 | 86.5 | 43.25 | 56.75 |
| 60 | 100 | 50 | 50 |
עליות חדות בתנועה שנובעות מהשקות
כשמשיקים גרסה שמגדילה באופן משמעותי את התנועה לתור או לקבוצת תורים, השקה הדרגתית היא שוב מנגנון חשוב להפחתת העליות. השיקו את המכונות בהדרגה, כך שההשקה הראשונית לא תעלה על 500 פעולות בשנייה בסך הכול לתורים החדשים, והגדילו את מספר הפעולות בלא יותר מ-50% כל 5 דקות.
תורים חדשים או קבוצות תורים חדשות עם מספר גבוה של טרנזקציות לשנייה (TPS)
תורים חדשים שנוצרו פגיעים במיוחד. קבוצות של תורים, למשל [queue0000, queue0001, …, queue0199], רגישות באותה מידה כמו תורים בודדים בשלבים הראשונים של ההשקה. בתורים כאלה, השקה הדרגתית היא אסטרטגיה חשובה. להשיק שירותים חדשים או מעודכנים שיוצרים תורים או קבוצות של תורים עם מספר גבוה של TPS בשלבים. העומס הראשוני צריך להיות פחות מ-500 TPS, וצריך להגדיל את העומס ב-50% או פחות במרווחים של 5 דקות לפחות.
קבוצות תורים חדשות שהורחבו
כשמגדילים את הקיבולת הכוללת של קבוצת תורים, למשל הרחבה של [queue0000-queue0199 ל-queue0000-queue0399], צריך לפעול לפי התבנית 500/50/5. בכל הנוגע לתהליכי השקה, קבוצות חדשות של תורים מתנהגות בדיוק כמו תורים נפרדים. החילו את התבנית 500/50/5 על הקבוצה החדשה כולה, ולא רק על תורים ספציפיים בקבוצה.
כשמרחיבים את קבוצות התורים, חשוב להשתמש באסטרטגיה של השקה הדרגתית. אם מקור התנועה הוא App Engine, אתם יכולים להשתמש בחלוקת התנועה. כשמעבירים את השירות כדי להוסיף משימות למספר המוגדל של התורים, צריך להשיק את המכונות בהדרגה כדי שההשקה הראשונית לא תחרוג מ-500 פעולות בסך הכול לתורים החדשים, ולהגדיל את התנועה בלא יותר מ-50% כל 5 דקות.
הרחבת קבוצת התורים למקרי חירום
לפעמים תרצו להרחיב קבוצת תורים קיימת, למשל אם אתם צופים שמשימות יתווספו לקבוצת התורים מהר יותר מהקצב שבו הקבוצה יכולה לשלוח אותן. אם תפיצו את השמות של התורים החדשים באופן שווה בין שמות התורים הקיימים בסדר לקסיקוגרפי, תוכלו לשלוח תנועה לתורים האלה באופן מיידי. חשוב לוודא שאין יותר מ-50% תורים חדשים משולבים, ושהתנועה לכל תור היא פחות מ-500 TPS. השיטה הזו היא חלופה לשימוש בחלוקת תנועה ובהשקה הדרגתית.
כדי להשיג את סוג השמות המשולבים הזה, מוסיפים סיומת לתורים שמסתיימים במספרים זוגיים. לדוגמה, אם יש לכם 200 תורים קיימים [queue0000-queue0199] ואתם רוצים ליצור 100 תורים חדשים, בחרו את השמות [queue0000a, queue0002a, queue0004a, …, queue0198a] לתורים החדשים, במקום [queue0200-queue0299].
אם אתם צריכים להגדיל את המכסה עוד יותר, אתם יכולים להוסיף עד 50% יותר תורים כל 5 דקות.
הוספה לתור של משימות באצווה או בהיקף גדול
כשצריך להוסיף מספר גדול של משימות, למשל מיליונים או מיליארדים, דפוס הזרקה כפולה יכול להיות שימושי. במקום ליצור משימות מעבודה אחת, השתמשו בתור הזרקה. כל משימה שנוספת לתור המזריק מתפצלת ומוסיפה 100 משימות לתור או לקבוצת התורים הרלוונטיים. אפשר להאיץ את התור של המזריק עם הזמן – לדוגמה, להתחיל ב-5 TPS כדי ליצור 500 TPS בתור היעד או בקבוצת התורים, ואז להגדיל את הקצב ב-50% כל 5 דקות.
משימות עם שם
כשיוצרים משימה חדשה, Cloud Tasks מקצה לה שם ייחודי כברירת מחדל. אפשר להקצות שם למשימה באמצעות הפרמטר name. עם זאת, הפעולה הזו יוצרת תקורה משמעותית בביצועים, שגורמת לעלייה בזמני האחזור ועלולה להגדיל את שיעורי השגיאות שמשויכים למשימות בעלות שם. שמות של משימות עוקבות, כמו חותמות זמן, יכולים להגדיל את התקורה הזו באופן משמעותי.
אם אתם מקצים שמות משלכם, השתמשו בתחילית מפוזרת היטב לשמות המשימות, כמו גיבוב (hash) של התוכן. למידע נוסף על מתן שם למשימה, ראו הפניה לשדה Task.name.
עומס יתר של יעדים
אם יש עלייה פתאומית בשליחת המשימות בתור, Cloud Tasks יכול להעמיס על השירותים והמשאבים שבהם אתם משתמשים, כמו App Engine, Firestore במצב Datastore (Datastore) והרשת שלכם. אם הצטברו משימות בתור, ביטול ההשהיה של התורים האלה עלול לגרום לעומס יתר בשירותים האלה. כדי למנוע עומס יתר על היעד, כדאי לפעול לפי דפוס ה-500/50/5: אם תור שולח יותר מ-500 TPS, הגדילו את התנועה שמופעלת על ידי תור בלא יותר מ-50% כל 5 דקות. כדי לעקוב באופן יזום אחרי העלייה בתנועה, אפשר להשתמש במדדי מעקב. אתם יכולים להשתמש בהתראות של Monitoring כדי לזהות מצבים שעלולים להיות מסוכנים.
ביטול ההשהיה או המשך של תורים עם מספר גבוה של עסקאות לשנייה
כשממשיכים תור שהושהה, Cloud Tasks מבצע הגדלה ראשונית של התור ומגביר בהדרגה את קצב השליחה, מקו בסיס נמוך עד לקצב max_dispatches_per_second שהוגדר לתור. עם זאת, אם מצטברות הרבה משימות בתור עם TPS גבוה או בכמה תורים שאתם מפעילים מחדש בו-זמנית, קצב השליחה עדיין יכול לעלות מהר יותר מהיכולת של שירותי היעד להתרחב. כדי למנוע עומס יתר על היעד כשמחדשים תורים עם צבר משימות גדול, כדאי לחדש כמה תורים בהדרגה. לחלופין, אפשר להפחית באופן זמני את קצב השליחה של max_dispatches_per_second ולהגביר אותו בהדרגה לפי דפוס 500/50/5. למידע נוסף על האופן שבו Cloud Tasks מווסת ומגביר את קצב השליחה כשהתורים ממשיכים לפעול, קראו את המאמר שגיאות השהיה וקצבים שנאכפים.
משימות מתוזמנות בכמות גדולה
גם מספר גדול של משימות שמתוזמנות לשליחה בו-זמנית עלול לגרום לעומס יתר ביעד. אם אתם צריכים להפעיל מספר גדול של משימות בבת אחת, כדאי להשתמש בבקרות על קצב התור כדי להגדיל את קצב השליחה בהדרגה, או להקצות מראש את קיבולת היעד.
הגדלת מספר המשתמשים שרואים את הפוסטים שלכם
כשמעדכנים שירותים ש-Cloud Tasks קורא להם, הגדלת מספר הקריאות מרחוק עלולה ליצור סיכונים בסביבת הייצור. לדוגמה, נניח שהמשימות בתור עם מספר גבוה של שאילתות לשנייה קוראות ל-handler /task-foo. גרסה חדשה יכולה להגדיל משמעותית את עלות הקריאה ל-/task-foo, למשל אם הגרסה החדשה מוסיפה ל-handler כמה קריאות יקרות ל-Datastore.
התוצאה של השקה כזו היא עלייה משמעותית בתנועה ב-Datastore, שקשורה באופן מיידי לשינויים בתנועת המשתמשים. כדי לנהל את ההגדלה, אפשר להשתמש בהשקה הדרגתית או בחלוקת התנועה.
ניסיונות חוזרים
הקוד שלכם יכול לנסות שוב במקרה של כשל כשמבצעים קריאות ל-Cloud Tasks API. עם זאת, כשחלק משמעותי מהבקשות נכשלות עם שגיאות בצד השרת, שיעור גבוה של ניסיונות חוזרים עלול להעמיס עוד יותר על התורים ולהאט את ההתאוששות. אם הלקוח מזהה שחלק משמעותי מהבקשות נכשלות בגלל שגיאות בצד השרת, הגבילו את כמות התנועה היוצאת. לדוגמה, אפשר להשתמש באלגוריתם Adaptive Throttling שמתואר בפרק Handling Overload בספר Site Reliability Engineering. ספריות הלקוח של Google ב-gRPC מטמיעות גרסה של האלגוריתם הזה.