[ טוען... ]

הגבלת מקביליות ב-Promise.all: worker pool, p-limit ו-p-map

תאריך: 21.11.2026
זמן קריאה: 21 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

איור של גל בקשות שמציף שער צר לעומת worker pool מסודר שמעביר משימות במספר מוגבל של מסלולים מקבילים

כמעט כל מפתח JavaScript כתב את השורה await Promise.all(items.map(async (item) => ...)). היא קצרה וקריאה, ועל מערך של שלושה פריטים היא עושה בדיוק את מה שצריך. הבעיה מתחילה כשהמערך גדל ל-200 לקוחות, 1,200 חשבוניות או 5,000 הודעות. כאן נכנסת הגבלת מקביליות ב-Promise.all: הדרך להריץ הרבה משימות אסינכרוניות במקביל בלי להפיל את ה-API החיצוני, את מסד הנתונים או את תהליך ה-Node.js עצמו.

הנקודה שרוב המפתחים מפספסים היא ש-Promise.all לא מתזמן עבודה ולא מכניס אותה לתור. הוא רק מחכה לה. מכיוון ש-Array.prototype.map() רץ באופן סינכרוני, Node.js מפעיל את כל ה-callbacks האסינכרוניים באותו tick של ה-event loop, וכל הבקשות כבר יצאו לדרך לפני ש-Promise.all בכלל קיבל את המערך (DEV Community). התוצאה היא ספייק תעבורה שהקוד מייצר בעצמו.

המדריך עובר על שלושת מצבי הכשל המרכזיים (thundering herd שמתבטא בשגיאות 429 ובמיצוי connection pool, לחץ זיכרון, וכתיבות יתומות), מסביר למה חלוקה לצ'אנקים קבועים היא פתרון חלקי בלבד, ובונה worker pool ב-TypeScript מאפס. אחר כך הוא מציג את הקיצורים, p-limit ו-p-map, ומיישם את העקרונות בתרחישים מוכרים לצוותים ישראליים: webhooks של n8n, קריאות ל-WhatsApp Cloud API ו-route handlers ב-Next.js.

למה Promise.all(items.map(...)) מפעיל הכל בבת אחת

כדי להבין את הבעיה צריך להפריד בין שני דברים: יצירת ה-Promise והמתנה לו. ברגע שקוראים לפונקציה אסינכרונית, העבודה שלה מתחילה. Promise.all מקבל מערך של Promises שכבר רצים, ורק אוסף את התוצאות שלהם.

// כל 5,000 הבקשות יוצאות כאן, בתוך map, באותו tick
const results = await Promise.all(
  customerIds.map(async (id) => {
    const res = await fetch(`https://api.example.com/customers/${id}`);
    return res.json();
  }),
);

במערך של 5,000 פריטים, השורה הזו פותחת 5,000 חיפושי DNS, sockets ושאילתות כמעט בו-זמנית. זה עובד מצוין לכמה קריאות בודדות, והופך לספייק תעבורה עצמי בקנה מידה (DEV Community).

ההבדל בין הדפדפן ל-Node.js

בדפדפן יש בלם מובנה: הדפדפנים מגבילים את מספר החיבורים לכל דומיין (בערך 6), והשאר ממתינים בתור. ב-Node.js אין מגבלה כזו, ו-100 בקשות פותחות 100 חיבורי TCP בבת אחת. מגבלות הקצב בצד השרת לא מבחינות בין 100 משתמשים לבין סקריפט אחד שפתח 100 חיבורים (recca0120).

מה עם ה-thread pool של libuv?

טעות נפוצה היא להניח שה-thread pool של libuv (ברירת מחדל של 4 threads, דרך UV_THREADPOOL_SIZE) יווסת את העומס. אבל I/O של רשת, כלומר ה-sockets עצמם, לא עובר דרכו (DEV Community).

יש כאן הסתייגות חשובה: חיפושי DNS דרך dns.lookup, שבו משתמשים רוב לקוחות ה-HTTP כברירת מחדל, כן רצים על ה-thread pool, כפי שמתואר בתיעוד הרשמי של Node.js (Node.js docs). המשמעות המעשית הפוכה ממה שאולי מצופה: ה-thread pool לא מגביל את מספר החיבורים, אבל אלפי lookups בבת אחת עלולים לתפוס את ארבעת ה-threads ולעכב פעולות אחרות שתלויות בהם, כמו פעולות קבצים.

מתי Promise.all ב-JavaScript הוא בדיוק הכלי הנכון

חשוב לא להגזים לכיוון השני. Promise.all מתאים מאוד לסט קטן וקבוע של קריאות בלתי תלויות. שלוש קריאות API של כ-300ms כל אחת מסתיימות בזמן של הקריאה האיטית ביותר, בערך 300ms במקום כ-900ms בהרצה סדרתית (Jamdesk). באותו אופן, בבדיקה של חמש שאילתות sleep של שנייה, הרצה מקבילית לקחה כשנייה מול כחמש שניות בהרצה סדרתית (DEV Community).

הכלל המעשי: הבעיה היא לא Promise.all עצמו, אלא מערכים גדולים בגודל דינמי שעוברים אליו בלי שום תקרה (Jamdesk). אם גודל המערך תלוי בנתוני משתמש, בתוצאת שאילתה או ב-payload של webhook, צריך concurrency limit ב-Node.js.

שלושה מצבי כשל של מקביליות בלתי מוגבלת

מאמר מקיף בנושא מונה שלושה מצבי כשל: thundering herd מול השירות שבהמשך השרשרת (מגבלות קצב ו-connection pools של מסדי נתונים שגודלם בדרך כלל 10 עד 50 חיבורים), תופעות לוואי יתומות אחרי דחייה מסוג fail-fast, ועצירות של ה-heap וה-GC ב-V8 עד כדי הריגת התהליך בגלל OOM (DEV Community). הסעיפים הבאים עוברים עליהם לפי הסדר.

מצב כשל 1: thundering herd, סערת 429 ומיצוי connection pool

ה-thundering herd מתבטא בשתי צורות עיקריות, לפי סוג השירות שמקבל את הגל.

מול API חיצוני: 429 Too Many Requests. רוב ה-APIs המסחריים מגבילים מקביליות או קצב. ב-ScrapingBee, למשל, תוכנית המנוי קובעת את רמת המקביליות המותרת, וחריגה ממנה מחזירה 429. המדריך הרשמי שלהם מזהיר במפורש ש-Promise.all על כל המערך יורה את כל הבקשות מיד (ScrapingBee).

הבעיה מחמירה כי הרבה SDKs, גם של ספקים גדולים, לא כוללים טיפול מובנה במגבלות קצב. הלקוח של Dropbox ל-Node הוא דוגמה אחת, בעוד ש-GitHub מציעה חבילה נפרדת בשם plugin-throttling (Anvil). כלומר, אין להניח שה-SDK יציל את המצב.

מול מסד הנתונים: מיצוי ה-pool. אותו דפוס מול Postgres נראה תמים: Promise.all(rows.map((r) => pool.query(...))). בפועל, מערך גדול של קריאות pool.query חורג מגודל ה-pool, השאילתות נערמות בתור וה-latency מזנק. ההמלצות הן כוונון גודל ה-pool, עיבוד באצוות ושימוש ב-p-limit או ב-Bottleneck (DEV Community).

מסקנה כללית מהאופן שבו connection pool עובד (ולא ממצא מתועד במקורות): אם אותו pool משרת גם את בקשות ה-HTTP של המשתמשים, סביר שגם הן ימתינו בתור בזמן שג'וב הרקע מחזיק את כל החיבורים. לכן כדאי לבדוק את התרחיש הזה בסביבת staging לפני שמניחים שעבודת רקע מבודדת משאר האפליקציה.

מצב כשל 2: זיכרון ו-GC

כל בקשה פתוחה מחזיקה socket, buffers, ואחר כך את גוף התשובה. כשאלפי תשובות מגיעות כמעט יחד, ה-heap מתנפח וה-garbage collector נכנס לעצירות ארוכות, ובמקרה הגרוע התהליך נהרג בגלל OOM (DEV Community).

מצב כשל 3: כתיבות יתומות, הבאג השקט ביותר

Promise.all נדחה בכשל הראשון, אבל Promises לא מתבטלים אוטומטית. שאר קריאות ה-HTTP והשינויים במסד הנתונים ממשיכים לרוץ ברקע, בלי שאף אחד מחכה להם (DEV Community). הקוד חושב שהג'וב נכשל, אבל חלק מהכתיבות כבר קרו וחלק עוד יקרו.

המאמר מתאר תרחיש להמחשה של ג'וב חיוב: 1,200 חשבוניות דרך Promise.all, שגיאת 429 תוך 400ms, timeouts ב-pool של מסד הנתונים, ו-1,199 כתיבות יתומות (DEV Community). כשמריצים ג'וב כזה שוב, חלק מהחשבוניות עלולות להיווצר פעמיים. זו הסיבה שכדאי לשלב את הנושא עם מפתחות Idempotency ב-API.

מה המספרים אומרים (ובאיזו הסתייגות)

בבנצ'מרק של אותו כותב, שהוא סימולציה שלו ולא מדידה עצמאית, 200 בקשות מדומות של 50ms נשלחו לשירות שמוגבל ל-10 חיבורים מקבילים ומחזיר 429 מעבר לכך (DEV Community):

  • Promise.all בלי הגבלה: נכשל אחרי כ-52ms, אפס משימות הושלמו.
  • Worker pool עם מגבלה של 10: כל 200 המשימות הושלמו ב-1,045ms, בלי בקשות שנזרקו.

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

הגבלת מקביליות ב-Promise.all: מצ'אנקים ל-worker pool ב-TypeScript

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

למה צ'אנקים קבועים הם לא הפתרון

הגישה האינטואיטיבית היא לחתוך את המערך לקבוצות של 10 ולהריץ await Promise.all על כל קבוצה:

for (let i = 0; i < items.length; i += 10) {
  const chunk = items.slice(i, i + 10);
  await Promise.all(chunk.map(processItem));
}

זה אכן מונע את שגיאות ה-429, אבל יוצר head-of-line blocking: בקשות מהירות עומדות בטל ומחכות לחריגה איטית אחת. בדוגמה מהמקור, תשע בקשות של 20ms מחכות לבקשה אחת של 900ms בתוך צ'אנק של 10 (DEV Community). במשך רוב הזמן הזה, תשעה מתוך עשרה "סלוטים" ריקים.

גם המדריך של ScrapingBee משתמש באצוות של Promise.all בגודל המגבלה (ScrapingBee), וזה פתרון סביר לסקריפט חד-פעמי. בעומסים לא אחידים, pool משותף שומר את כל הסלוטים עסוקים עד שהתור מתרוקן (DEV Community).

איך worker pool עובד

דפוס ה-worker pool מבוסס על N עובדים שמושכים משימות מאינדקס משותף (cursor), עם AbortController שעוצר את העבודה שעדיין בתור כשיש שגיאה קריטית (DEV Community). כל עובד הוא לולאה פשוטה:

  1. לקחת את האינדקס הבא מה-cursor ולקדם אותו.
  2. אם האינדקס מחוץ למערך, לסיים.
  3. להריץ את המשימה ולשמור את התוצאה במיקום המתאים.
  4. לחזור לשלב 1.

הסבר כללי על מודל הריצה של JavaScript, שאינו מופיע במקורות: הקריאה של cursor והקידום שלו ב-cursor++ מתבצעים כפעולה סינכרונית אחת, בלי await ביניהם. מכיוון שכל העובדים רצים על אותו event loop, עובד אחר לא יכול להתערב באמצע הפעולה, ולכן שני עובדים לא יקבלו את אותו אינדקס. ההנחה הזו נכונה רק כשכל העובדים באותו thread; עם worker_threads או כמה תהליכים, צריך מנגנון סנכרון אחר.

המימוש ב-TypeScript

export async function runPool<I, O>(
  items: readonly I[],
  limit: number,
  task: (item: I, index: number, signal: AbortSignal) => Promise<O>,
): Promise<O[]> {
  const results = new Array<O>(items.length);
  const controller = new AbortController();
  let cursor = 0;

  async function worker(): Promise<void> {
    while (!controller.signal.aborted) {
      const index = cursor++;
      if (index >= items.length) return;

      try {
        results[index] = await task(items[index], index, controller.signal);
      } catch (err) {
        // שגיאה קריטית: עוצרים את כל מה שעדיין בתור
        controller.abort(err);
        throw err;
      }
    }
  }

  const workerCount = Math.min(limit, items.length);
  const workers = Array.from({ length: workerCount }, () => worker());
  await Promise.all(workers);
  return results;
}

כמה נקודות שכדאי לשים לב אליהן:

  • Promise.all כאן בטוח. הוא מחכה ל-N עובדים, לא ל-5,000 משימות. המערך קטן וקבוע, בדיוק המקרה ש-Promise.all נועד לו.
  • התוצאות נשמרות לפי סדר הקלט, כי כל עובד כותב ל-results[index] ולא עושה push.
  • ה-signal מועבר למשימה. בלי זה, ה-abort עוצר רק משימות שעוד לא התחילו. משימות שכבר רצות ימשיכו עד הסוף.

חיבור ה-AbortSignal ל-fetch

כדי שביטול יעצור גם בקשות שכבר בדרך, מעבירים את ה-signal ל-fetch:

const invoices = await runPool(invoiceIds, 10, async (id, _i, signal) => {
  const res = await fetch(`https://billing.example.com/invoices/${id}`, {
    method: 'POST',
    signal,
  });
  if (!res.ok) throw new Error(`Invoice ${id} failed: ${res.status}`);
  return res.json();
});

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

כשלים חלקיים: תוצאות בסגנון Promise.allSettled

לא כל שגיאה צריכה לעצור את כל הג'וב. כשהרשומות בלתי תלויות זו בזו (שליחת הודעה ללקוח, סנכרון איש קשר ל-CRM), עדיף לתפוס את השגיאה בתוך העובד ולהחזיר אובייקטי תוצאה בסגנון settled (DEV Community). זה בעצם Promise.allSettled עם תקרת מקביליות:

export type Settled<T> =
  | { ok: true; value: T }
  | { ok: false; error: unknown };

export function runPoolSettled<I, O>(
  items: readonly I[],
  limit: number,
  task: (item: I, index: number, signal: AbortSignal) => Promise<O>,
): Promise<Settled<O>[]> {
  return runPool(items, limit, async (item, index, signal) => {
    try {
      return { ok: true, value: await task(item, index, signal) } as const;
    } catch (error) {
      return { ok: false, error } as const;
    }
  });
}

const outcome = await runPoolSettled(contacts, 8, syncContact);
const failed = outcome
  .map((r, i) => ({ r, contact: contacts[i] }))
  .filter(({ r }) => !r.ok);

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

הקיצור: p-limit ו-p-map

לא תמיד צריך לתחזק pool כתוב ביד. שתי ספריות קטנות פותרות את רוב המקרים, ולכל אחת יש תפקיד אחר. לפי ההשוואה של npm-compare, p-limit מתאים לכמה משימות שצריכות שליטה פשוטה, p-map מתאים למיפוי על אוסף עם מגבלה, ו-p-queue הוא חלופה כבדה יותר למספר גדול של משימות (npm-compare).

הערה על ESM ו-CommonJS

לפני ההתקנה, נקודה שלא מופיעה במקורות של המדריך ודורשת אימות מול דף החבילה והגרסה שמותקנת בפועל: בגרסאות האחרונות, p-limit ו-p-map מופצות ככל הנראה כחבילות ESM בלבד. בפרויקט שעדיין רץ כ-CommonJS (קבצי .js עם require, או קונפיגורציית TypeScript שמקמפלת ל-CommonJS), ייבוא כזה עלול להיכשל בזמן ריצה. הפתרונות הנפוצים הם מעבר ל-ESM, שימוש ב-import() דינמי, או נעילה לגרסה ישנה יותר שתומכת ב-CommonJS. ה-worker pool הכתוב ביד לא תלוי בזה בכלל, וזה יתרון נוסף שלו בפרויקטים ישנים.

p-limit: שינוי מינימלי בקוד קיים

עם p-limit עוטפים כל משימה ב-limit(() => fetch(...)) בתוך Promise.all(ids.map(...)). לכל היותר N רצות בבת אחת, השאר בתור, ו-Promise.all עדיין מחכה לכל התוצאות (recca0120):

import pLimit from 'p-limit';

const limit = pLimit(5);

const products = await Promise.all(
  ids.map((id) =>
    limit(async () => {
      const res = await fetch(`https://api.example.com/products/${id}`);
      return res.json();
    }),
  ),
);

הדוגמה במקור משתמשת ב-pLimit(5) עבור 100 בקשות (recca0120). ההבדל הקריטי מהקוד המקורי: map יוצר פונקציות עטופות שנכנסות לתור, ולא מפעיל את fetch ישירות.

היתרון הגדול של p-limit הוא limiter משותף. אפשר לייצא מופע אחד ממודול ולהשתמש בו מכמה מקומות לא קשורים בקוד, וכולם יחלקו את אותה תקרה. אפילו FxTS, ספרייה שמציעה חלופה ל-p-map, ממליצה להשאיר את p-limit למקרה הזה, כי ספריית pipeline לא ממדלת limiter אד-הוק שמשותף בין call sites (FxTS).

מה המקורות לא מכסים לגבי p-limit

חשוב להיות מדויקים לגבי גבולות הידע כאן: המקורות שעליהם מבוסס המדריך לא מתעדים את סמנטיקת השגיאות או הביטול של p-limit עצמו, כלומר מה קורה למשימות שממתינות בתור כשאחת נכשלת, או האם יש תמיכה ב-AbortSignal. מה שכן ברור הוא ההתנהגות של מה שעוטף אותו: Promise.all סביב המשימות נדחה בכשל הראשון (FxTS), ו-Promises שכבר רצים לא מתבטלים אוטומטית (DEV Community). לכן כל מה שנאמר על כתיבות יתומות ממשיך לחול. לכל פרט מעבר לזה, יש לבדוק את ה-README של הגרסה המותקנת.

p-map: מיפוי על אוסף עם concurrency מובנה

p-map שונה מ-Promise.all בכך שהוא מאפשר מגבלת מקביליות ובחירה אם לעצור בשגיאה. הוא מציע את pMapSettled כמקבילה ל-allSettled, וגם pMapKeyed ו-pMapSettledKeyed (npm):

import pMap, { pMapSettled } from 'p-map';

const controller = new AbortController();

// fail-fast עם אפשרות ביטול
const users = await pMap(
  userIds,
  async (id) => fetchUser(id),
  { concurrency: 10, signal: controller.signal },
);

// כשל חלקי: כל פריט מקבל תוצאה משלו
const results = await pMapSettled(
  userIds,
  async (id) => sendWelcomeMessage(id),
  { concurrency: 10 },
);

בין האפשרויות של p-map נמצאות signal (לביטול) ו-stopOnError. pMapSettled מקבל את אותן אפשרויות למעט stopOnError, ונדחה אם ה-signal מבוטל (npm). כשהמטרה היא להמשיך לעבד גם אחרי כשלים ולקבל תמונה מלאה של מה הצליח ומה לא, pMapSettled הוא הכלי שהתיעוד מציג לתרחיש הזה.

המלכודת: Promises שכבר רצים

זו הטעות הנפוצה ביותר עם p-map. Promises שכבר נמצאים בקלט של p-map כבר רצים, ולכן ה-concurrency לא יכול להגביל אותם. את העבודה האסינכרונית צריך להתחיל בתוך ה-mapper, לא לפניו (npm):

// שגוי: map כבר הפעיל את כל הבקשות
const started = userIds.map((id) => fetchUser(id));
await pMap(started, (p) => p, { concurrency: 10 });

// נכון: הבקשה מתחילה רק כשיש סלוט פנוי
await pMap(userIds, (id) => fetchUser(id), { concurrency: 10 });

אותו עיקרון חל גם על p-limit: Promises שכבר נוצרו לא מוגבלים. העבודה חייבת להיות עטופה בפונקציה.

FxTS concurrentPool כחלופה

למי שכבר עובד עם FxTS, concurrentPool תואם לסמנטיקה של p-map: לכל היותר n בטיסה, משימה חדשה מתחילה ברגע שאחת מסתיימת, תוצאות לפי סדר הקלט, והדחייה הראשונה מבטלת. ה-concurrent שלה, שעובד בחלון קבוע, מתנהג אחרת בעומסים לא אחידים. ל-FxTS אין מקבילה ל-stopOnError: false והיא לא מקבלת AbortSignal (FxTS).

טבלת השוואה מהירה

גישה

מתי לבחור

יתרונות

חסרונות

Promise.all רגיל

2-5 קריאות קבועות ובלתי תלויות

פשוט, מהיר כמו הקריאה האיטית ביותר

אין תקרה, fail-fast משאיר עבודה יתומה

צ'אנקים קבועים

סקריפט חד-פעמי, עומס אחיד

בלי תלויות, מונע 429

head-of-line blocking, תפוקה מבוזבזת

Worker pool ביד

שליטה מלאה בשגיאות ובביטול

בלי תלויות, כל הסלוטים עסוקים, AbortController פשוט לחיבור

קוד שצריך לתחזק, סמנטיקת כשל חלקי באחריות הצוות

p-limit

עטיפת משימות מפוזרות, limiter משותף

שינוי מינימלי, קל משקל

עדיין Promise.all מסביב, נדחה בכשל הראשון

p-map / pMapSettled

מיפוי על אוסף

concurrency מובנה, סדר תוצאות, stopOnError ו-signal

לא limiter גלובלי בין call sites

הטבלה מבוססת על ההשוואות ב-DEV Community, recca0120 ו-npm.

יישום בשטח: n8n webhooks, WhatsApp Cloud API ו-Next.js route handlers

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

webhooks של n8n שמפעילים fan-out

תרחיש נפוץ: workflow ב-n8n מקבל קריאה דרך ה-Webhook node (n8n Docs: Webhook node) עם רשימה (הזמנות מהיום, לידים מקמפיין, רשומות מ-CRM), וקורא ל-endpoint בצד השרת שמעבד את כולן. אם ה-endpoint הזה עושה Promise.all(payload.items.map(...)), גודל ה-payload קובע את עוצמת הגל, ואף אחד לא שולט בזה.

יש כאן שתי שכבות מקביליות נפרדות. השכבה הראשונה היא n8n עצמו: ב-queue mode, לפי התיעוד, ה-instance הראשי מקבל את הטריגרים ומעביר את ה-executions לתור, ו-workers נפרדים מושכים אותם ומריצים אותם, כשאפשר להגדיר כמה executions כל worker מריץ במקביל (n8n Docs: Queue mode). השכבה השנייה היא מה שקורה בתוך כל execution או בשרת שהוא קורא לו. הגבלת ה-workers של n8n לא מגבילה את ה-Promise.all שרץ בצד השרת, ולהפך.

ההמלצות המעשיות:

  • לעטוף את העיבוד בצד השרת ב-pool מוגבל, עם מגבלה שנגזרת מהשירות החלש ביותר בשרשרת (לרוב מסד הנתונים או API חיצוני).
  • לקחת בחשבון את המכפלה. אם כמה workers של n8n קוראים במקביל לאותו endpoint, כל אחד עם pool משלו, העומס הכולל הוא מספר ה-executions המקבילים כפול המגבלה הפנימית.
  • להשתמש בתוצאות בסגנון settled, ולהחזיר ל-n8n סיכום של הצלחות וכשלים במקום להיכשל על הכל.
  • להגן מפני כפילויות. אם ה-webhook נשלח שוב אחרי כשל חלקי, חלק מהרשומות כבר עובדו. מפתח idempotency לכל רשומה מונע כפילות.
  • לנטר. ג'וב שנתקע בגלל 429 נראה לפעמים כמו ג'וב שפשוט לא רץ, ולכן כדאי מנגנון heartbeat כמו זה שמתואר במדריך ניטור n8n.

קריאות ל-WhatsApp Cloud API: limiter אחד לכל הערוצים

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

Meta מפרסמת את מגבלות ה-throughput של ה-Cloud API (Meta for Developers: WhatsApp Cloud API overview) ואת מגבלות ה-messaging, שקובעות לכמה משתמשים ייחודיים אפשר לשלוח הודעות יזומות (Meta for Developers: Messaging limits). המגבלות האלה משתנות לפי סטטוס החשבון ומתעדכנות מעת לעת, ולכן הערך בקוד צריך להיגזר מהתיעוד העדכני ולא ממספר שהועתק ממדריך.

כאן p-limit מצטיין, כי limiter משותף יכול לווסת call sites לא קשורים (recca0120, FxTS):

// lib/whatsapp-limiter.ts
import pLimit from 'p-limit';

// את הערך יש להתאים למגבלות העדכניות בתיעוד של Meta
export const whatsappLimit = pLimit(Number(process.env.WA_CONCURRENCY ?? 5));

export function sendWhatsApp(payload: OutgoingMessage) {
  return whatsappLimit(() => postToWhatsAppApi(payload));
}

כל מודול שולח דרך sendWhatsApp, והתקרה נאכפת במקום אחד בתוך התהליך. חשוב לזכור שמגבלת מקביליות שונה ממגבלת קצב או ממגבלת messaging, ולכן limiter כזה הוא שכבת הגנה אחת ולא תחליף לטיפול ב-429 (ראו בהמשך).

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

route handlers ב-Next.js: היכן ה-limiter חי

ב-route handler שמקבל בקשה ומעבד מערך, ההגבלה בתוך הבקשה עובדת בדיוק כמו בכל קוד Node.js. כשהרשומות בלתי תלויות, pMapSettled מאפשר להמשיך לעבד אחרי כשלים ולספור בנפרד הצלחות וכשלים:

// app/api/sync/route.ts
import { pMapSettled } from 'p-map';

export async function POST(req: Request) {
  const { ids } = (await req.json()) as { ids: string[] };

  const results = await pMapSettled(ids, (id) => syncRecord(id), {
    concurrency: 8,
  });

  const fulfilled = results.filter((r) => r.status === 'fulfilled').length;
  const rejected = results.length - fulfilled;

  return Response.json({ fulfilled, rejected });
}

הקוד מניח שמבנה כל תוצאה זהה לזה של Promise.allSettled (שדה status עם fulfilled או rejected), בהתאם לתיאור של pMapSettled כמקבילה ל-allSettled (npm). כדאי לאמת את הטיפוסים מול הגרסה המותקנת. בנוסף, route handler הוא קוד צד שרת, ולכן הערת ה-ESM שלמעלה חלה גם כאן אם הפרויקט מוגדר כ-CommonJS.

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

  • limiter שנוצר בתוך ה-handler מגביל רק את הבקשה הזו. אם עשר בקשות מגיעות במקביל, כל אחת עם מגבלה של 8, השירות שבהמשך עלול לראות עד 80 קריאות פתוחות.
  • limiter ברמת המודול משותף בין בקשות, אבל רק בתוך אותו תהליך.
  • בפריסה עם כמה מופעים או בסביבת serverless, כל מופע מחזיק limiter משלו, ואין ביניהם תיאום. במצבים כאלה נהוג להשתמש במנגנון חיצוני (תור עבודות או מונה משותף), או לפחות לחלק את המגבלה הכוללת במספר המופעים הצפוי.

בחירת מגבלה וטיפול בשגיאת 429

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

איך בוחרים את N

אין מספר אחד נכון, אבל יש עוגנים ברורים:

  • מגבלת הספק. אם תוכנית המנוי מגדירה מקביליות מותרת, כמו ב-ScrapingBee, המגבלה בקוד צריכה להיות שווה לה או נמוכה ממנה (ScrapingBee).
  • גודל ה-connection pool. כש-pool של מסד נתונים הוא בדרך כלל 10 עד 50 חיבורים (DEV Community), ג'וב רקע שתופס את כולם משאיר מעט מאוד לשאר האפליקציה. כדאי להשאיר מרווח.
  • מדידה. להתחיל נמוך, להעלות בהדרגה ולעקוב אחרי latency, שיעור 429 ושימוש בזיכרון. ברגע שה-latency מתחיל לטפס בלי שיפור בתפוקה, הגעתם לתקרה האפקטיבית.
  • קונפיגורציה חיצונית. הגדרת המגבלה דרך משתנה סביבה מאפשרת לכוונן אותה בלי פריסה מחדש של קוד.

מקביליות מול קצב

יש הבדל בין מגבלת מקביליות (כמה בקשות פתוחות בו-זמנית) לבין מגבלת קצב (כמה בקשות ביחידת זמן). worker pool שולט רק בראשונה. חשבון פשוט: אם בקשה נמשכת 50ms ויש 10 סלוטים, התפוקה יכולה להגיע לכ-200 בקשות בשנייה, וזה עלול לחרוג ממגבלת קצב גם כשהמקביליות תקינה.

למגבלות קצב, הפתרון הנאיבי הוא השהיה בין קריאות. למשל, מגבלה של 6 בקשות ל-3 שניות מתורגמת לבקשה אחת כל 500ms (Anvil). אפשר להוסיף השהיה כזו בתוך המשימה שרצה ב-pool, או להשתמש בספרייה ייעודית כמו Bottleneck שמוזכרת במקורות (DEV Community).

ניסיונות חוזרים בלי ליצור retry storm

גם עם pool מוגבל, 429 בודדים יקרו. כפרקטיקה מקובלת בתעשייה, שאינה מפורטת במקורות של המדריך, נהוג לבצע retry עם exponential backoff ו-jitter, ולכבד את header ה-Retry-After כשהספק שולח אותו. בהקשר של pool, כדאי לבצע את ה-retry בתוך הסלוט, כך שהמשימה ממשיכה להחזיק את מקומה ב-pool בזמן ההמתנה ולא מוסיפה עומס מקבילי.

async function withRetry<T>(fn: () => Promise<T>, attempts = 4): Promise<T> {
  for (let i = 0; ; i++) {
    try {
      return await fn();
    } catch (err) {
      if (i >= attempts - 1 || !isRetryable(err)) throw err;
      const base = 2 ** i * 250;
      const jitter = Math.random() * base;
      await new Promise((r) => setTimeout(r, base + jitter));
    }
  }
}

await runPoolSettled(items, 8, (item) => withRetry(() => callApi(item)));

הפונקציה isRetryable היא נקודת ההחלטה: 429 ושגיאות רשת זמניות בדרך כלל מתאימות לניסיון חוזר, ושגיאות 400 של ולידציה לא. retry בלי תקרת מקביליות עלול להחמיר את המצב: כל הבקשות נכשלות יחד, מחכות אותו זמן ונכשלות שוב יחד. הדינמיקה הזו, והפתרונות כמו circuit breaker, מפורטים במדריך Retry storm: איך ניסיונות חוזרים מפילים את הפרודקשן.

צ'קליסט לפני פריסה

  • אין Promise.all על מערך שגודלו תלוי בנתונים חיצוניים בלי limiter.
  • העבודה מתחילה בתוך ה-mapper או בתוך limit(() => ...), לא לפני.
  • יש החלטה מודעת: fail-fast עם AbortController, או תוצאות settled.
  • AbortSignal מועבר ל-fetch, ויש timeout לכל בקשה.
  • המגבלה נגזרת ממגבלת הספק ומגודל ה-pool, ומוגדרת דרך משתנה סביבה.
  • ברור היכן ה-limiter חי: בתוך בקשה, ברמת תהליך, או מנגנון חיצוני משותף.
  • 429 מטופל עם backoff ו-jitter, בתוך הסלוט.
  • כתיבות מוגנות מכפילות באמצעות idempotency.
  • אם משתמשים ב-p-limit או ב-p-map, נבדק שהייבוא עובד בתצורת המודולים של הפרויקט (ESM או CommonJS).

שאלות נפוצות

האם Promise.all עצמו גרוע?

לא. הוא מתאים לסטים קטנים וקבועים של קריאות בלתי תלויות, בערך 2 עד 5. הבעיה היא העברת מערכים גדולים בגודל דינמי של עבודה שמתחילה מיד בלי שום תקרה (Jamdesk).

למה Promise.all מפעיל הכל בבת אחת?

כי הוא רק מחכה ל-Promises. Array.map() רץ באופן סינכרוני ומפעיל כל callback אסינכרוני באותו tick, כך שכל העבודה כבר התחילה לפני ש-Promise.all ראה את המערך (DEV Community).

למה לא פשוט לעבד בצ'אנקים של N?

צ'אנקים מונעים את שגיאות ה-429, אבל כל צ'אנק מחכה למשימה האיטית ביותר שלו (head-of-line blocking). worker pool מתחיל משימה חדשה ברגע שסלוט כלשהו מתפנה (DEV Community).

p-limit או p-map?

p-limit לעטיפת משימות בודדות או מפוזרות, במיוחד כשצריך limiter משותף לכמה מקומות בקוד. p-map למיפוי על אוסף, עם אפשרות concurrency, תוצאות לפי הסדר וגרסאות settled (npm-compare).

איך ממשיכים לעבד כשחלק מהפריטים נכשלים?

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

האם הגבלת מקביליות מחליפה טיפול ב-429?

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

סיכום

Promise.all(items.map(...)) הוא אחד הדפוסים הנפוצים והמסוכנים ב-JavaScript, דווקא כי הוא עובד מצוין בסביבת פיתוח עם עשרה פריטים. בפרודקשן, עם מערכים דינמיים, הוא יורה את כל הבקשות באותו tick, מייצר סערת 429, ממצה את ה-connection pool, מנפח את הזיכרון ומשאיר אחריו כתיבות יתומות כשמשהו נכשל.

הפתרון הוא bounded concurrency. worker pool כתוב ביד נותן שליטה מלאה, משלב בקלות AbortController ולא תלוי בתצורת המודולים של הפרויקט. p-limit מתאים לשינוי מינימלי בקוד קיים ול-limiter משותף, למשל מול WhatsApp Cloud API. p-map ו-pMapSettled מתאימים למיפוי על אוספים עם סדר תוצאות ותמיכה בכשלים חלקיים. צ'אנקים קבועים עדיפים על כלום, אבל מבזבזים תפוקה בעומסים לא אחידים.

מעבר לבחירת הכלי, הגבלת מקביליות ב-Promise.all היא רק שכבה אחת במערכת רחבה יותר: מגבלה שנגזרת מהספק ומה-pool, הבנה היכן ה-limiter חי, timeout לכל בקשה, retry עם backoff ו-jitter, ו-idempotency לכל כתיבה. בבנצ'מרק המדומה של המקור, ג'וב שנכשל תוך כ-52ms בלי שום תוצאה הפך לג'וב שסיים את כל 200 המשימות בקצת יותר משנייה. בסביבות אמיתיות המספרים יהיו שונים, אבל הכיוון זהה: עבודה מוגבלת שמסתיימת עדיפה על עבודה "מהירה" שקורסת.

מקורות

וואטסאפ