חזרה לפיד
articlesמקור: Lovable Blog10.11.2026

שינוי ארכיטקטורה ב-Lovable: מעבר ל-Realtime מאובטח

אמ;לק

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

סיכום בעברית: מערכת VibeSec · מדיניות המקורות

נוסף ל-VibeSec:

כותרת מקורית: How we moved our frontend off Firestore and built Lovable Realtime

שינוי ארכיטקטורה ב-Lovable: מעבר ל-Realtime מאובטח

התוכן המלא בעברית

תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.

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

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

זה הוביל אותנו לבנות את ⁦Lovable Realtime⁩, שירות בזמן אמת משלנו.

בניתי את הליבה ב-40 ימי עבודה מעשיים, והשקנו אותה לכל המשתמשים ללא תקרית אחת שפגעה במשתמשים. השירות מטפל בשיאים של למעלה מ-2 מיליון מינויים במקביל ומספק כ-2.6 מיליארד נתונים ועדכוני patch בחודש.

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

אתגרים עם ⁦Firestore⁩

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

לבסוף, כללי ההרשאה של Firestore מוגבלים בכך שהם יכולים לבצע שאילתות על נתוני Firebase בלבד. זה היווה חסם עבורנו כאשר ביקשנו לאפשר עדכוני הרשאות עבור קבוצות גדולות (למשל, היכולת לתת לכל אחד בקבוצת ההנדסה של החברה גישה לפרויקט). ארגונים משתמשים בתכונת ה-SCIM שלנו המסנכרנת משתמשים וקבוצות עם סביבת העבודה שלהם ב-Lovable. תכונות כמו SCIM דורשות טרנזקציות DB גדולות ודפוסי שאילתות מורכבים, שמסדי נתונים מבוססי מסמכים כמו Firestore אינם מספקים בדרך כלל באותה רמה של פתרונות כמו Spanner. אך ה-Firestore Security Rules לא יכולים לקרוא מ-Spanner.

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

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

דרישות ואפשרויות נשקלו

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

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

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

Replicache מאפשר לנו להביא את ה-backend שלנו: התראה מנחה את הלקוח לבצע משיכה (pull), והשרת מחשב את התצוגה המורשית שלו. עדיין היינו צריכים ליישם ניתוב התראות, תצוגות בצד השרת ומעקב אחר שינויים, כולל שינויים ב-payload שנגרמו אך ורק על ידי שינויים בהרשאות.

מערכות משולבות מסדי נתונים כגון Firestore, Firebase RTDB, Supabase Realtime, Hasura, PowerSync ו-Zero מציעות שילובים שונים של שאילתות חיות, תחזיות והרשאות בתוך הערימות הנתמכות שלהן. היינו זקוקים לשכבה אגנוסטית למסד נתונים מעל נתוני ה-Firestore ו-Spanner הקיימים שלנו, עם תוצאות שמחושבות ב-Go backend שלנו והערכה מחדש של הגישה כאשר תלויות ההרשאה משתנות. מוצרים אלה לא סיפקו את השילוב הזה ללא עבודת אינטגרציה משמעותית.

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

ה-publications של Meteor מעצבים payloads עבור כל משתמש בקוד השרת, כאשר הריאקטיביות מתמקדת ב-MongoDB. תלויות הרשאה שנקראות בנפרד מהנתונים הריאקטיביים זקוקות לטיפול מפורש. Convex קרובה למה שרצינו: פונקציית שרת הופכת למנוי ריאקטיבי המעוצב בשרת, אך היא דורשת שימוש במסד הנתונים של Convex.

בנינו תשתית שמחברת בין תלויות נתונים, שינויים בהרשאות ותוצאות מנויים המחושבות ב-backend, מבלי להעביר את הנתונים שלנו למאגר חדש.

מה שבנו

Lovable Realtime הוא שירות WebSocket ייעודי שמזרים נתונים בזמן אמת, כאשר ההרשאות וצורת הנתונים מטופלים בצד השרת ב-Go. יש לנו חיבור WebSocket אחד לכל כרטיסייה, כאשר כל המינויים מרוכזים (multiplexed) על החיבור הזה. שינויים במסד הנתונים זורמים דרך מנגנון Change Data Capture (CDC), שמפעיל אוטומטית את המינויים המושפעים כדי לחשב מחדש ולדחוף עדכונים. קוד הכותב למסד הנתונים אינו צריך להפעיל עדכוני מנוי באופן ידני. ה-backend שולט במה שכל משתמש יכול לראות ואילו שדות מוסתרים (redacted), תוך שימוש באותה תשתית הרשאות כמו ב-API שלנו.

שירות הזמן-אמת פועל ב-Go על GKE. כל פוד מכיל חיבור NATS בודד ואלפי חיבורי WebSocket. אירועי שינוי נתונים נשלחים מ-Firestore ו-Spanner לתוך גשר (bridge) ולאחר מכן מתפרסמים ב-NATS. כאשר הודעת NATS מגיעה, הפוד שולח אותה לכל מופע מנוי תואם, שמחשב מחדש את הקרנת הנתונים שלו, מבצע דה-דופליקציה (ביטול כפילויות) באמצעות hash מסוג xxh3-128, ודוחף את ה-deltas ל-frontend אם הפלט השתנה.

⁦NATS⁩ עבור ⁦pub/sub⁩

השירות משתמש ב-NATS כאפיק הודעות, בדומה ל-Redis pub/sub או Valkey pub/sub, אך עם כמה יתרונות. ראשית, הוא תומך בנושאי תווים כלליים (wildcards) היררכיים (כמו rt.data.workspace.W.project.*) שמותאמים בצד השרת בתוך מבנה trie. ב-Redis, פקודת PSUBSCRIBE סורקת את רשימת הדפוסים בכל פרסום, ו-sharded pub/sub מוותרת לחלוטין על תמיכה בדפוסים.

עם ה-wildcards של NATS, המפרסם כותב לנושא ספציפי אחד והמנויים בוחרים את רמת הפירוט שלהם. זה עובד היטב עבור מקרה השימוש שלנו, שבו יש לנו כ-40 סוגי מנויים בבעלות 7 צוותים. זה מונע את הבעיה של ריבוי פרסומים לערוצי roll-up, שבהם המפרסם חייב להכיר כל רמת פירוט שמישהו אי פעם יירשם אליה, ושערוצי ה-roll-up עצמם עלולים להיות מוצפים במהירות. ערוץ רחב ברמת ה-workspace, למשל, עלול לרכז כל אירוע באותו workspace לרסיס (shard) אחד ב-Redis משורד.

NATS תומך גם בניתוב אשכולות מבוסס-עניין (interest-based cluster routing) למדרגיות: הודעות עוברות רק לצמתים שיש להם מנוי תואם, בעוד ש-Redis cluster pub/sub הקלאסי משדר כל הודעה לכל צומת.

ניסיון במפתחים

קיימת תשתית backend ו-SDK ל-frontend. ב-frontend, אתה רק צריך לציין את שם המנוי שאליו ברצונך להירשם ואת הפרמטר:

⁦const { data, status, error } = useSubscription ( "project" , { projectId });⁩

זהו קוד מוקלד (typed) מקצה לקצה, עם פרמטרים ו-payloads שנוצרים מ-structs של Go. רכיבים מרובים שנרשמים לאותו דבר יחלקו את אותו מנוי בצד השרת באופן אוטומטי. ה-SDK גם מטפל בחיבור מחדש עם backoff (ו-jitter) ושולח מסגרות רענון של אסימון הרשאה (auth token) לשרת.

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

⁦func projectSub(call) { p := call.Params perms := requireAccess(call, ViewProject) project := get(Project, p.projectID) return toDTO(project, perms.has(ViewProjectUsage)) }⁩

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

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

לצורך צפייה וניטור (observability), כל מנוי חייב להגדיר צוות בעלים, אחרת הרישום ייכשל. התראות מנותבות לבעלי הנתונים, כאשר כל מנוי מטופל כ-API endpoint.

מקורות נתונים ריאקטיביים

אז מהו ה"פרויקט" שאנו מקבלים בדוגמה הקודמת? זה מה שאנו מכנים מקורות נתונים ריאקטיביים (Reactive Data Sources או RDS), שהם עמוד השדרה של המנויים.

⁦Project = RDS[Project]{ Query: func(ctx, p) { return db.GetProject(p.id) }, Subjects: func(p) { return []string{"rt.data.project." + p.id} }, Apply: func(cached, ev) { if ev.deleted { return nil } return decode(ev.data) }, TTL: 5 * time.Minute, }⁩

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

• היכן ניתן לקבל עדכונים עבור הנתונים הללו (⁦NATS⁩ נושאים)

• מה לעשות כשאתה מקבל עדכונים מאותם נתונים (זוהי פונקציית היישום, שפועלת כמו מפחית שמיישב את מה שהשתנה)

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

הדוגמה הזו פשוטה מאוד (בדיקה נקודתית המאזינה לדבר אחד), אבל ניתן ליצור גם RDS מורכבים יותר, כמו "עשרת הפרויקטים הנצפים ביותר ב-workspace".

הרשאה היא עוד ⁦RDS⁩

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

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

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

סימולטור מנויים

התחל עם דוגמה של workspace: הירשם, שנה את שם ה-workspace, שנה הרשאות או עדכן שדה פנימי, וראה מה מגיע ללקוח. לאחר מכן נסה שאילתה חיה עבור 10 הפרויקטים החדשים ביותר, או סקירת פרויקט המשלבת נתונים מ-Spanner ומ-Firestore. הסימולטור מראה כיצד תמונות מצב (snapshots), עדכוני patch, ביטול כפילויות ושימוש חוזר בחיבורים פועלים.

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

השקה ותפעול

#firebase#lovable#vibe-coding#realtime#architecture
קרא במקור

קריאה וכלים קשורים

אבטחת Firebaseמונחי אבטחה והסברים בעברית