הסבר על קריאות וכתיבות בקנה מידה רחב

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

‫Firestore הוא מסד נתונים גמיש וניתן להרחבה של Firebase ו- Google Cloud, שמיועד לפיתוח של אפליקציות לנייד, לאינטרנט ולשרתים. קל מאוד להתחיל להשתמש ב-Firestore ולכתוב אפליקציות עשירות ורבות עוצמה.

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

בקטעים הבאים מפורטות השיטות המומלצות לפני שמתכננים את האפליקציה.

הסבר על הרכיבים ברמה הגבוהה

בתרשים הבא מוצגים הרכיבים הכלליים שמעורבים בבקשת Firestore API.

רכיבים ברמה גבוהה

ערכות SDK וספריות לקוח של Firestore

‫Firestore תומך בערכות SDK ובספריות לקוח לפלטפורמות שונות. אפליקציה יכולה לבצע קריאות HTTP ו-RPC ישירות ל-Firestore API, אבל ספריות הלקוח מספקות שכבת הפשטה כדי לפשט את השימוש ב-API ולהטמיע שיטות מומלצות. הם יכולים גם לספק תכונות נוספות כמו גישה אופליין, מטמונים וכו'.

ממשק הקצה של Google‏ (GFE)

זהו שירות תשתית שמשותף לכל שירותי הענן של Google. ה-GFE מקבל בקשות נכנסות ומעביר אותן לשירות Google הרלוונטי (שירות Firestore בהקשר הזה). הוא גם מספק פונקציות חשובות אחרות, כולל הגנה מפני התקפות מניעת שירות.

שירות Firestore

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

שכבת האחסון של Firestore

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

טווחי מפתחות ופיצולים

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

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

שכפול סינכרוני

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

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

פריסת הנתונים

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

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

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

פריסת הנתונים

אזור יחיד לעומת מספר אזורים

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

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

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

למידע נוסף על המיקומים של אזור מסוים, קראו את המאמר מיקומים ב-Firestore.

אזור יחיד לעומת מספר אזורים

הסבר על מחזור החיים של פעולת כתיבה ב-Firestore

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

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

שלבים כלליים בעסקת כתיבה

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

בשלב הראשון של טרנזקציה, Firestore קורא את המסמך הקיים וקובע את השינויים שצריך לבצע בנתונים בטבלה Documents.

הפעולה הזו כוללת גם ביצוע עדכונים נדרשים בטבלה Indexes, באופן הבא:

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

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

אחרי חישוב המוטציות, Firestore אוסף אותן בתוך טרנזקציה ואז מבצע אותה.

הסבר על טרנזקציית כתיבה בשכבת האחסון

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

בתרשים הבא, מסד הנתונים של Firestore כולל שמונה פיצולים (מסומנים במספרים 1-8) שמתארחים בשלושה שרתי אחסון שונים באזור אחד, וכל פיצול משוכפל ב-3 (או יותר) אזורים שונים. לכל פיצול יש מנהיג Paxos, שיכול להיות באזור שונה עבור פיצולים שונים.

פיצול מסד נתונים ב-Firestore

נניח שיש לכם מסד נתונים ב-Firestore עם האוסף Restaurants:

אוסף מסעדות

הלקוח של Firestore מבקש לבצע את השינוי הבא במסמך באוסף Restaurant על ידי עדכון הערך של השדה priceCategory.

שינוי למסמך באוסף

השלבים הכלליים הבאים מתארים מה קורה כחלק מהכתיבה:

  1. יוצרים טרנזקציית קריאה-כתיבה.
  2. קוראים את המסמך restaurant1 באוסף Restaurants מהטבלה Documents משכבת האחסון.
  3. קוראים את האינדקסים של המסמך מהטבלה Indexes.
  4. מחשבים את השינויים שצריך לבצע בנתונים. במקרה הזה, יש חמש מוטציות:
    • ‫M1: מעדכנים את השורה של restaurant1 בטבלה Documents כדי לשקף את השינוי בערך של השדה priceCategory.
    • ‫M2 ו-M3: מוחקים את השורות של הערך הישן של priceCategory בטבלה Indexes לאינדקסים בסדר עולה ובסדר יורד.
    • ‫M4 ו-M5: מוסיפים את השורות של הערך החדש של priceCategory בטבלה Indexes לאינדקסים בסדר יורד ובסדר עולה.
  5. מבצעים את השינויים האלה.

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

בשלבים הבאים מתואר מה שקורה כחלק מה-commit:

  1. לקוח האחסון מנפיק אישור. ה-commit מכיל את המוטציות M1-M5.
  2. השותפים בעסקה הזו הם 3 ו-6. אחד מהמשתתפים נבחר בתור המתאם, למשל Split 3. תפקיד המתאם הוא לוודא שהטרנזקציה מתבצעת או מתבטלת באופן אטומי בכל המשתתפים.
    • הרפליקות המובילות של הפיצולים האלה אחראיות לעבודה שמבצעים המשתתפים והרכזים.
  3. כל משתתף ורכז מריצים אלגוריתם Paxos עם הרפליקות שלהם.
    • ה-leader מריץ אלגוריתם Paxos עם הרפליקות. הקוורום מושג אם רוב הרפליקות משיבות ל-leader בתגובת ok to commit.
    • לאחר מכן, כל משתתף מודיע למתאם כשהוא מוכן (השלב הראשון של אישור דו-שלבי). אם אחד מהמשתתפים לא יכול לבצע את הטרנזקציה, הטרנזקציה כולה aborts.
  4. אחרי שהרכז יודע שכל המשתתפים, כולל הוא עצמו, מוכנים, הוא מעביר את תוצאת העסקה accept לכל המשתתפים (השלב השני של אישור דו-שלבי). בשלב הזה, כל משתתף מתעד את החלטת האישור באחסון יציב והטרנזקציה מאושרת.
  5. הרכז מגיב ללקוח האחסון ב-Firestore שהעסקה בוצעה. במקביל, הרכז וכל המשתתפים מחילים את המוטציות על הנתונים.

מחזור החיים של השמירה (commit)

כאשר מסד הנתונים של Firestore קטן, יכול להיות שפיצול יחיד יהיה הבעלים של כל המפתחות במוטציות M1-M5. במקרה כזה, יש רק משתתף אחד בעסקה ואין צורך ב-two-phase commit שהוזכר קודם, כך שהכתיבה מהירה יותר.

פעולות כתיבה במספר אזורים

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

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

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

הסבר על מחזור החיים של פעולת קריאה ב-Firestore

בקטע הזה נתמקד בפעולות קריאה עצמאיות, לא בזמן אמת, ב-Firestore. באופן פנימי, שרת Firestore מטפל ברוב השאילתות האלה בשני שלבים עיקריים:

  1. סריקת טווח יחיד בטבלה Indexes
  2. חיפושים נקודתיים בטבלה Documents על סמך תוצאות הסריקה הקודמת
יכול להיות ששאילתות מסוימות ידרשו פחות עיבוד (לדוגמה, שאילתות keys-only במצב Datastore) או יותר עיבוד (לדוגמה, שאילתות IN) ב-Firestore.

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

הסבר על עסקת קריאה בשכבת האחסון

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

קריאות חזקות

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

קריאה מפוצלת אחת

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

בשלב הזה, יכולים לקרות המקרים הבאים, בהתאם לרפליקה שנבחרה:

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

לאחר מכן, Firestore מחזיר את התשובה ללקוח שלו.

קריאה מפוצלת מרובה

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

קריאות בעבר

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

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

הימנעות מנקודות חמות

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

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

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

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

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

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

פתרון בעיות

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

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