חיבורי websocket ב-Next.js: זמן אמת על אחסון serverless

הוספה של עדכונים חיים לאפליקציית Next.js מתחילה בדרך כלל טוב. אתם פותחים websocket מתוך client component, מכוונים אותו לשרת קטן, ועם next dev הכול עובד: ההזמנה עוברת לסטטוס "נשלחה", ההודעה החדשה מופיעה, מונה המחוברים זז. ואז מגיעה הפריסה, והחיבור נופל, מתחבר מחדש, נופל שוב, או בכלל לא נפתח.
רק לעיתים רחוקות הבעיה היא בקוד. רוב אפליקציות ה-Next.js רצות על אחסון serverless, ופונקציית serverless לא יכולה להחזיק חיבור פתוח. הפוסט הזה מסביר למה, מה המחיר של הפתרונות העוקפים המקובלים, ואיך להוסיף זמן אמת לאפליקציית Next.js בלי להריץ שרת websocket.
למה פונקציית serverless לא יכולה להחזיק websocket
על אחסון serverless, route handler, server action ו-server component עובדים כולם באותה דרך. בקשה נכנסת, פונקציה עולה או מתעוררת, עונה, וזמן קצר אחר כך היא מוקפאת או נעצרת. הבקשה הבאה עשויה להגיע ל-instance אחר לגמרי.
websocket צריך בדיוק את ההפך: תהליך אחד שמחזיק חיבור פתוח לכל דפדפן כל עוד הדף פתוח, לעיתים קרובות שעות, ויכול לדחוף אליו עדכון בכל רגע. פונקציית serverless לא חיה כל כך הרבה זמן, אין לה דרך להגיע לחיבור ש-instance אחר פתח, ועל כל שנייה שבה היא פועלת יש חיוב. לכן כל כך הרבה גרסאות ראשונות עובדות בסביבת הפיתוח, שבה תהליך אחד שרץ ברציפות משרת הכול, ונכשלות ב-production.
הפתרונות העוקפים המקובלים
Polling. הדף שואל route handler כל כמה שניות אם משהו השתנה. זה עובד בכל מקום, אבל כל שאלה היא קריאה לפונקציה, ברוב הקריאות התשובה היא שאין שום דבר חדש, והדף תמיד מפגר בכמה שניות. עם 1,000 אנשים בדף שמבצע polling כל 5 שניות, אלה 200 קריאות לפונקציה בשנייה, מסביב לשעון.
Streaming מתוך route handler. אפשר להשאיר תגובה של route handler פתוחה ולהזרים דרכה events לדף. זה קרוב יותר לזמן אמת, אבל כל stream פתוח הוא פונקציה שעדיין רצה, כל פלטפורמה עוצרת פונקציות אחרי זמן מקסימלי, וה-stream חי ב-instance אחד, כך ש-event שנשלח מ-instance אחר אף פעם לא מגיע אליו.
Custom server. אפשר להריץ את Next.js מאחורי שרת Node.js משלכם, עם ספריית websocket לצידו. זה מוציא את האפליקציה מאחסון serverless: אתם מריצים שרת שחי לאורך זמן, דואגים שיישאר זמין גם בזמן פריסות, וברגע שיש לכם יותר מאחד, משתפים ביניהם כל event, בדרך כלל דרך Redis, ודואגים שכל דפדפן יישאר על שרת שמכיר אותו. בדיקת WebSocket שלנו בודקת שרת כזה מדפדפן. הפוסט על חיבורי websocket ב-Node.js מראה את השרת הזה בחמש עשרה שורות, ומה משנה השרת השני.
שרת websocket משלכם לצד האפליקציה. האפליקציה נשארת serverless, ושרת נפרד מחזיק את החיבורים. זו הדרך הנקייה ביותר מבין הארבע, ועדיין מדובר במערכת שנייה שצריך להריץ: התעודה שלה, ה-scaling שלה, הניטור שלה, ודרך לדעת מי המשתמש, כי היא לא יכולה לקרוא את ה-session של האפליקציה שלכם.
או לתת לענן לזמן אמת להחזיק את החיבורים
שירות מנוהל לזמן אמת מוריד מכם לגמרי את החלק שצריך לחיות לאורך זמן. הדפדפנים מחזיקים את החיבורים שלהם פתוחים מול השירות. קוד ה-Next.js שלכם, ב-server action או ב-route handler, שולח כל event בבקשת HTTP קצרה אחת, ובדיוק בזה פונקציית serverless טובה. השירות מוסר אותו לכל דף שצריך לקבל אותו, לא משנה איזה instance שלח אותו.
מה שחשוב הוא שזה מתאים לדרך שבה Next.js כבר עובד: השרת שלכם מחליט מי רשאי להצטרף למה, הדפים שלכם נרשמים מתוך client components, ושום דבר באחסון שלכם לא משתנה.
Next.js על WordPlus Cloud
עם WordPlus Cloud, השרת שלכם מגדיר את החדרים שלו פעם אחת, עם כלל שקובע מי רשאי להצטרף לכל אחד מהם:
import { createRealtime } from '@wordplus/realtime/server';
import { currentUserId, profileOf } from '@/lib/auth';
export const realtime = createRealtime( {
site: process.env.WORDPLUS_SITE!,
secret: process.env.WORDPLUS_SECRET!,
localKey: process.env.WORDPLUS_LOCAL_KEY!,
user: () => currentUserId(),
profile: ( user ) => profileOf( user ),
} );
// The room of an order, order:1042: its customer may join, and the last 20 updates are kept.
realtime.room( 'order:{id}', { history: 20 }, async ( user, { id } ) => user !== null && ( await ownerOf( id ) ) === user );את הבקשות של הדפים להצטרף מקבל route handler אחד מסוג catch-all, שגם מגיש את קובצי הדפדפן של ה-SDK:
import { realtime } from '@/lib/realtime';
export const GET = realtime.route;
export const POST = realtime.route;ה-layout של הדפים שדורשים התחברות מרנדר את RealtimeProvider עם realtime.config() עבור המשתמש, כך שכל הדפים שתחתיו חולקים חיבור אחד, שנשמר לאורך ניווטים בצד הלקוח. אחר כך client component מצטרף לחדר עם hook:
'use client';
import { useState } from 'react';
import { useRoom } from '@wordplus/realtime/react';
export function Status( { id, initial }: { id: string; initial: string } ) {
const [ status, setStatus ] = useState( initial );
useRoom( `order:${ id }`, { updated: ( data: { status: string } ) => setStatus( data.status ) } );
return <p>{ status }</p>;
}ו-server action שולח, אחרי שהשינוי נשמר:
'use server';
import { realtime } from '@/lib/realtime';
export async function markShipped( id: string ) {
await saveStatus( id, 'shipped' );
await realtime.to( `order:${ id }` ).emit( 'updated', { status: 'shipped' } );
}זה כל המעגל, והוא רץ על אחסון serverless כמו שהוא. ומעבר לזה:
- ההתחברות נשארת שלכם. המשתמש הוא אותו id שהאפליקציה שלכם כבר מכירה, והוא נקרא בתוך ה-route handler, כך שה-session וה-cookies שלכם עובדים שם.
- שום דבר לא הולך לאיבוד בהתחברות מחדש. חדר שומר את ה-events האחרונים שלו, כך שדף שחוזר מקבל את מה שפספס, לפי הסדר.
- חיבור אחד לכל הלשוניות. הלשוניות של דפדפן חולקות חיבור אחד, כך שאדם עם שלוש לשוניות פתוחות נספר פעם אחת.
- סגור לאורך הדרך. מה שהאפליקציה שלכם שולחת עובר מוצפן, במפתחות שרק השרת שלכם והמשתמשים שלכם מחזיקים.
- יותר מ-events. מי מחובר כרגע, שיחות שמצלצלות בכל לשונית, שיחות קבוצתיות ושידורים חיים מגיעים על אותו חיבור, עם מסך שיחה, צ׳אט ונגן מוכנים מ-Better Messages, או עם ה-components שלכם על אותו API.
המדריך ל-Next.js כולל את כל ההגדרה, ו-ההדגמה החיה היא חנות קטנה שבנויה עליו, שבה הזמנה עוברת ל"נשלחה" בחלון אחר ברגע שאתם לוחצים.
שיחות וידאו באפליקציית Next.js, צעד אחר צעד: איך לממש שיחות וידאו ב-Next.js.
WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי. ראו מה הוא עושה לאפליקציות, או את המחירים לאפליקציות. העמוד שלנו על ה-API של WebSocket מציג חדרים, נוכחות ואירועים בכל סטאק. שאלות על האינטגרציה שלכם? כתבו לנו.