מחיר הבורות ב-MongoDB (חלק 3): דפוסי עיצוב מתקדמים לביצועים
אמ;לק
החלק השלישי בסדרה מתמקד ב-Design Patterns מתקדמים ב-MongoDB ובאופטימיזציית Aggregation Pipelines. מוסבר כיצד שגיאות מידול נפוצות פוגעות בביצועי יישומים ואיך לתקנן. חיוני לקוד אמין, במיוחד כשקוד נוצר אוטומטית על ידי LLMs ללא בדיקת ביצועים.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: The Cost of Not Knowing MongoDB, Part 3: appV6R0 to appV6R4

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
ברוכים הבאים לחלק השלישי והאחרון בסדרה "The Cost of Not Knowing MongoDB". בהתבסס על האופטימיזציות הבסיסיות שנחקרו ב-Part 1 ו-Part 2, מאמר זה מתעמק בדפוסי עיצוב מתקדמים ב-MongoDB שיכולים לשנות באופן דרמטי את ביצועי האפליקציה.
ב-Part 1 שיפרנו את ביצועי האפליקציות על ידי שרשור שדות, שינוי סוגי נתונים וקיצור שמות שדות. ב-Part 2 הטמענו את ה-Bucket Pattern וה-Computed Pattern וביצענו אופטימיזציה של צינור הצבירה (aggregation pipeline) כדי להשיג ביצועים טובים עוד יותר.
במאמר אחרון זה, אנו מתייחסים לבעיות ולשיפורים שזוהו ב-appV5R4. באופן ספציפי, אנו מתמקדים בהקטנת גודל המסמך באפליקציה שלנו כדי להקל על צוואר הבקבוק של תפוקת הדיסק בשרת MongoDB. הפחתה זו תושג על ידי אימוץ סכימה דינמית ושינוי אלגוריתם דחיסת האחסון.
כל גרסאות האפליקציות והשינויים בתיקונים במאמר זה פותחו על ידי מפתח MongoDB בכיר, שכן הן בנויות על כל הגרסאות הקודמות ומשתמשות בדפוס ה-Dynamic Schema, שאינו נפוץ במיוחד.
גרסה 6 של יישום גרסה 0 (appV6R0): מסמך דלי חודשי דינמי
כפי שהוזכר ב-Issues and Improvements של appV5R4 מהמאמר הקודם, המגבלה העיקרית של השרת MongoDB שלנו היא תפוקת הדיסק שלו. כדי לטפל בזה, עלינו להקטין את גודל המסמכים המאוחסנים.
שקול את המסמך הבא מ-appV5R3, שסיפק את הביצועים הטובים ביותר עד כה:
const document = {
 _id: Buffer.from("...01202202"),
 items: [
 { date: new Date("2022-06-05"), a: 10, n: 3 },
 { date: new Date("2022-06-16"), p: 1, r: 1 },
 { date: new Date("2022-06-27"), a: 5, r: 1 },
 { date: new Date("2022-06-29"), p: 1 },
 ],
};

מערך הפריטים במסמך זה מכיל רק ארבעה אלמנטים, אך בממוצע, יהיו בו כ-10 אלמנטים, ובמקרה הגרוע ביותר, הוא יכול לכלול עד 90 אלמנטים. אלמנטים אלה הם התורמים העיקריים לגודל המסמך, ולכן הם צריכים להיות המוקד של מאמצי האופטימיזציה שלנו.
אחד המשותף בין האלמנטים הוא נוכחות שדה התאריך, כאשר ערכו כולל שנה וחודש, עבור המסמך הקודם. על ידי חשיבה מחודשת כיצד ניתן לאחסן את השדה הזה ואת ערכו, נוכל להפחית את דרישות האחסון.
פתרון לא שגרתי בו נוכל להשתמש הוא:
• שינוי סוג שדה הפריטים ממערך למסמך.
• שימוש בערך התאריך כשם השדה במסמך הפריטים.
• אחסון סיכומי הסטטוס כערך עבור כל שדה תאריך.
להלן המסמך הקודם המיוצג באמצעות רעיון הסכמה החדש:
const document = {
 _id: Buffer.from("...01202202"),
 items: {
 20220605: { a: 10, n: 3 },
 20220616: { p: 1, r: 1 },
 20220627: { a: 5, r: 1 },
 20220629: { p: 1 },
 },
};

למרות שסכימה זו עשויה שלא להקטין משמעותית את גודל המסמך בהשוואה ל-appV5R3, אנו יכולים לייעל אותה עוד יותר על ידי מינוף העובדה שהשנה כבר מוטמעת בשדה _id. זה מבטל את הצורך לחזור על השנה בשמות השדות של מסמך הפריטים.
בגישה זו, מסמך הפריטים מאמץ Dynamic Schema, כאשר שמות שדות מקודדים מידע ואינם מוגדרים מראש.
כדי להדגים אפשרויות הטמעה שונות, נבדוק מחדש את כל קריטריוני ה-bucketing המשמשים בהטמעות appV5RX, החל מ-appV5R0.
עבור appV6R0, שמתבסס על appV5R0 אך משתמש בסכימה דינמית, הנתונים מקובצים לפי שנה וחודש. שמות השדות במסמך הפריטים מייצגים רק את היום של התאריך, שכן השנה והחודש כבר מאוחסנים בשדה _id.
ניתן למצוא הסבר מפורט על היגיון ה-bucketing והפונקציות המשמשות ליישום היישום הנוכחי במבוא appV5R0.
המסמך הבא מאחסן נתונים לינואר 2022 (2022-01-XX), תוך יישום הרעיון החדש שהוצג:
const document = {
 _id: Buffer.from("...01202201"),
 items: {
 "05": { a: 10, n: 3 },
 16: { p: 1, r: 1 },
 27: { a: 5, r: 1 },
 29: { p: 1 },
 },
};

סכֵימָה
יישום היישום המוצג לעיל יכלול את סכימת המסמך TypeScript הבאה הנקראת SchemaV6R0:
export type SchemaV6R0 = {
 _id: Buffer;
 items: Record<
 string,
 {
 a?: number;
 n?: number;
 p?: number;
 r?: number;
 }
 >;
};

מהפך בתפזורת
בהתבסס על המפרט המוצג, יש לנו את הפעולה updateOne הבאה עבור כל אירוע שנוצר על ידי גרסת אפליקציה זו:
const DD = getDD(event.date); // Extract the day from the event.date

const operation = {
 updateOne: {
 filter: { _id: buildId(event.key, event.date) }, // key + year + month
 update: {
 $inc: {
 [items.${DD}.a]: event.approved,
 [items.${DD}.n]: event.noFunds,
 [items.${DD}.p]: event.pending,
 [items.${DD}.r]: event.rejected,
 },
 },
 upsert: true,
 },
};

• מקד למסמך שבו השדה _id תואם לערך המשורשר של מפתח, שנה וחודש.
• הפונקציה buildId ממירה את המפתח+שנה+חודש לפורמט בינארי.
• משתמש באופרטור $inc כדי להגדיל את השדות המתאימים לאותו DD כמו האירוע לפי ערכי הסטטוס שסופקו.
• אם שדה לא קיים במסמך הפריטים והאירוע מספק עבורו ערך, $inc מתייחס לשדה הלא קיים כבעל ערך של 0 ומבצע את הפעולה.
• אם קיים שדה במסמך הפריטים אך האירוע אינו מספק עבורו ערך (כלומר, לא מוגדר), $inc מתייחס אליו כ-0 ומבצע את הפעולה.
• מבטיח יצירת מסמך חדש אם לא קיים מסמך תואם.
הפקת דוחות
כדי לממש את פעולת ה-Get Reports, נדרשים חמישה צינורות צבירה (aggregation pipelines), אחד עבור כל טווח תאריכים. כל צינור עוקב אחר אותו מבנה, והם נבדלים רק בקריטריוני הסינון בשלב ה-$match:
const pipeline = [
 { $match: docsFromKeyBetweenDate },
 { $addFields: buildTotalsField },
 { $group: groupSumTotals },
 { $project: { _id: 0 } },
];

הקוד המלא עבור צינור הצבירה הזה הוא די מסובך. בגלל זה, יהיה לנו רק פסאודוקוד עבורו כאן.
• טווח מסנן מסמכים לפי _id כדי לאחזר רק דליים בטווח התאריכים של הדוח. יש לו את אותו היגיון כמו appV5R0.
• ההיגיון דומה לזה המשמש ב-Get Reports של appV5R3.
• האופרטור $objectToArray משמש להמרת מסמך הפריטים למערך, מה שמאפשר פעולת $reduce.
• סינון שדות הפריטים בטווח הדוח כרוך בחילוץ השנה והחודש משדה _id ואת היום משמות השדות במסמך הפריטים.
• הקוד JavaScript הבא הוא לוגיקה שווה ערך לקוד צינור הצבירה האמיתי.
// Equivalent JavaScript logic:
const [MM] = _id.slice(-2).toString(); // Get month from _id
const [YYYY] = _id.slice(-6, -2).toString(); // Get year from _id
const items_array = Object.entries(items); // Convert the object to an array of [key, value]

const totals = items_array.reduce(
 (accumulator, [DD, status]) => {
 let statusDate = new Date(${YYYY}-${MM}-${DD});

 if (statusDate >= reportStartDate && statusDate < reportEndDate) {
 accumulator.a += status.a || 0;
 accumulator.n += status.n || 0;
 accumulator.p += status.p || 0;
 accumulator.r += status.r || 0;
 }

 return accumulator;
 },
 { a: 0, n: 0, p: 0, r: 0 }
);

• קבץ את הסכומים של כל מסמך בצנרת לסיכומי סטטוס סופי באמצעות פעולות $sum.
• עצב את המסמך שהתקבל כך שיהיה פורמט הדוחות.
אינדקסים
אין צורך באינדקסים נוספים, תוך שמירה על גישת האינדקס הבודדת _id שהוקמה ביישום appV4.
סטטיסטיקת תרחיש ראשונית
סטטיסטיקות אוסף
כדי להעריך את הביצועים של appV6R0, הכנסנו 500 מיליון מסמכי אירועים לאוסף באמצעות הסכימה והפונקציה Bulk Upsert שתוארו קודם לכן. לשם השוואה, הטבלאות שלהלן כוללות גם נתונים סטטיסטיים מגרסאות אפליקציות דומות קודמות:
סטטיסטיקות אירועים
כדי להעריך את יעילות האחסון לכל אירוע, ה-Event Statistics מחושבים על ידי חלוקת גודל הנתונים הכולל וגודל האינדקס ב-500 מיליון אירועים.
זה מאתגר לבצע השוואה ישירה בין appV6R0 ל-appV5R0 מנקודת מבט של אחסון. היישום appV5R0 הוא ה-bucketing הפשוט ביותר האפשרי, כאשר מסמכי אירוע רק צורפו למערך הפריטים ללא bucketing ביום, כפי שנעשה ב-appV6R0.
עם זאת, אנו יכולים לנסות להשוות בין appV6R0 ל-appV5R3, הפתרון הטוב ביותר עד כה. ב-appV6R0 הנתונים מסודרים לפי חודש, ואילו ב-appV5R3 הם מסודרים לפי רבעונים. בהנחה שגודל המסמך משתנה באופן ליניארי עם הקריטריונים לקטגוריות (אם כי זה לא לגמרי מדויק), המסמך appV6R0 יהיה בערך 3 * 125 = 375 בתים, שהם 9.4% קטן מ-appV5R3.
אינדיקטור נוסף לשיפור הוא המדד Data Size/Events בטבלה Event Statistics. עבור appV6R0, כל אירוע משתמש בממוצע של 23.8 בתים, בהשוואה ל-27.7 בתים עבור appV5R3, המייצגים ירידה של 14.1% בגודל.
תוצאות מבחן עומסים
בעת ביצוע מבחן העומס עבור appV6R0 ושרטוט התוצאות לצד התוצאות עבור appV5R0 והיעדים (Desired rates), קיבלנו את התוצאות הבאות עבור ה-Get Reports וה-Bulk Upsert.
קצב הפקת דוחות (Get Reports rates)
שתי הגרסאות מציגות ביצועי קצב דומים מאוד, כאשר appV6R0 מציגה עליונות קלה ברבעון השני והשלישי, בעוד ש-appV5R0 עדיפה ברבעון הראשון והרביעי.
זמן אחזור (Latency) של דוחות
שתי הגרסאות מציגות ביצועי חביון דומים מאוד, כאשר appV6R0 מציג יתרונות קלים ברבעון השני והשלישי, בעוד appV5R0 עדיפה ברבעון הראשון והרביעי.
Bulk Upsert תעריפים
לשתי הגרסאות יש ערכי קצב דומים, אך ניתן לראות של-appV6R0 יש יתרון קטן בהשוואה ל-appV5R0.
Bulk Upsert זמן אחזור
למרות שלשתי הגרסאות יש ערכי חביון דומים ברבע הראשון של הבדיקה, לשלושת הרבעונים האחרונים, ל-appV6R0 יש יתרון ברור על פני appV5R0.
סיכום ביצועים
למרות ההפחתה המשמעותית בגודל המסמכים והאחסון שהושגו על ידי appV6R0, שיפור הביצועים לא היה משמעותי כמצופה. זה מצביע על כך שצוואר הבקבוק באפליקציה בעת העברת נתונים לפי חודש עשוי שלא להיות קשור לתפוקת הדיסק.
בחינת טבלת הנתונים הסטטיסטיים של האיסוף מגלה שגודל האינדקס עבור שתי הגרסאות קרוב ל-3GB. זה קרוב ל-4GB של זיכרון זמין במחשב המריץ את מסד הנתונים וחורג מה-1.5GB שהוקצו על ידי WiredTiger עבור מטמון. לכן, סביר להניח שהגורם המגביל במקרה זה הוא memory/cache ולא גודל המסמך, מה שמסביר את היעדר שיפור משמעותי בביצועים.
בעיות ושיפורים
כדי לטפל במגבלות שנצפו ב-appV6R0, אנו מציעים לאמץ את אותו קו של שיפורים שהופעל מ-appV5R0 ל-appV5R1. באופן ספציפי, אנו נחלק את האירועים לפי רבעון ב-appV6R1. גישה זו לא רק עוקבת אחר דפוס השיפורים שנקבע אלא גם מתיישבת עם הצורך לייעל את הביצועים עוד יותר.
כפי שהודגש בתוצאות מבחן העומסים, צוואר הבקבוק הנוכחי טמון בגודל האינדקס ביחס ל-cache/memory הזמינים. על ידי הגדלת מרווח ה-bucketing מחודש לרבעון, נוכל לצמצם את מספר המסמכים בפקטור של שלושה בערך. צמצום זה, בתורו, יקטין את מספר כניסות האינדקס באותו גורם, מה שיוביל לאינדקס קטן יותר.
קריאה וכלים קשורים
אבטחת MongoDB- MongoDB Atlas Security — בקרות רשת וזהויות, הצפנה וביקורת ב־Atlas; ביקורת זמינה רק בתוכניות מתאימות.
- NoSQLMap — כלי בדיקות NoSQL לשימוש מורשה בלבד; פעילות מאגר אומתה בפברואר 2026, אך המהדורה ישנה ונדרשת בדיקת התאמה.
- אבטחת נתוני תשלומים ב-MongoDB לפי תקן PCI DSS
- MongoDB מאפשרת זיכרון ארוך טווח לסוכני AI מבוססי Strands
- פרצה ב-MongoDB: תוקף ללא הרשאות יכול להפיל שרתים