בלוג

חיבורי websocket ב-PHP בלי תהליך משלכם

· Andrij Tkachenko · 9 דקות קריאה

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

PHP יכול להגיש חיבורי websocket, אבל לא מתוך הבקשות שעונות לדפים שלכם: PHP-FPM נותן לכל בקשה worker עד שהתשובה שלה נשלחת, ו-websocket הוא חיבור שנשאר פתוח שעות. לכן websocket ב-PHP רץ בסקריפט משלו, שמופעל משורת הפקודה ונשאר רץ, עם event loop שמשגיח על כל החיבורים בבת אחת, והאתר שלכם צריך למסור לסקריפט הזה כל event שיש לשלוח.

הפוסט הזה מציג שרת כזה עם Ratchet, מסביר למה הוא לא יכול לחיות בתוך האתר שלכם, מה נדרש כדי להריץ אותו למשתמשים אמיתיים, ואיך לשלוח events חיים מ-PHP רגיל בלי תהליך websocket בכלל.

למה בקשת PHP לא יכולה להחזיק websocket

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

PHP נבנה בדיוק הפוך. תחת PHP-FPM, שרת הווב מעביר כל בקשה ל-worker אחד מתוך pool. ה-worker מריץ את הסקריפט שלכם, שולח את התשובה ולוקח את הבקשה הבאה. ל-pool יש גודל קבוע, ו-התיעוד של PHP אומר ש-pm.max_children קובע את המגבלה על מספר הבקשות שמקבלות מענה בבת אחת. websocket שמוחזק בתוך בקשה היה מעסיק את ה-worker שלו כל עוד הדף שלו פתוח. עם 20 workers, ‏20 דפים פתוחים היו תופסים את כולם, והאתר היה מפסיק לענות לכל השאר.

גם השרתים שעומדים לפני PHP רואים את זה כך. nginx סוגר את החיבור ל-PHP-FPM כש-PHP לא שולח כלום במשך 60 שניות, כברירת מחדל, וספקי אחסון קובעים מגבלות משלהם על משך הזמן שבקשה רשאית לרוץ.

Long polling ו-server-sent events נראים כמו דרך לעקוף את זה, וב-PHP הם נתקלים באותו קיר: כל בקשה שממתינה תופסת worker. WordPress נתקל בדיוק בזה, כמו שמסביר הפוסט שלנו על WordPress ו-websocket, וכך גם כל אפליקציית PHP, עם framework או בלי.

שרת websocket ב-PHP

התשובה ב-PHP היא תוכנה שנייה: סקריפט שמפעילים עם php משורת הפקודה, ושאף פעם לא מסתיים. הוא מאזין על פורט ומריץ event loop, שמחכה לכל החיבורים הפתוחים בבת אחת ומתעורר בשביל זה שיש לו מה לומר. ספרייה עושה בשבילכם את ה-handshake ואת ה-framing של פרוטוקול WebSocket. המוכרת ביותר היא Ratchet, שבנויה על ה-event loop של ReactPHP:

Shell
composer require cboden/ratchet
PHP
<?php
// chat.php
require __DIR__ . '/vendor/autoload.php';

use Ratchet\ConnectionInterface;
use Ratchet\MessageComponentInterface;

class Chat implements MessageComponentInterface {
    private SplObjectStorage $clients;

    public function __construct() {
        $this->clients = new SplObjectStorage();
    }

    public function onOpen( ConnectionInterface $conn ) {
        $this->clients->attach( $conn );
    }

    // Pass each message to everyone else connected.
    public function onMessage( ConnectionInterface $from, $msg ) {
        foreach ( $this->clients as $client ) {
            if ( $client !== $from ) {
                $client->send( $msg );
            }
        }
    }

    public function onClose( ConnectionInterface $conn ) {
        $this->clients->detach( $conn );
    }

    public function onError( ConnectionInterface $conn, \Exception $e ) {
        $conn->close();
    }
}

// ws://localhost:8080/chat, for pages served from localhost.
$app = new Ratchet\App( 'localhost', 8080 );
$app->route( '/chat', new Chat(), [ 'localhost' ] );
$app->run();

הפעילו אותו עם php chat.php, ודף מתחבר דרך ה-API של WebSocket שיש בכל דפדפן:

JavaScript
const socket = new WebSocket( 'ws://localhost:8080/chat' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );

פתחו את הדף הזה בשתי לשוניות, כשהוא מוגש מ-localhost, וכל אחת מדפיסה את מה שהשנייה שולחת. הארגומנט השלישי של route() מפרט את ה-hosts שהדפים שלהם רשאים להתחבר, כי דף בכל אתר אחר יכול לפתוח websocket לשרת שלכם, ו-התקן משאיר לכם לסרב לו. [ '*' ] מכניס כל אתר.

ב-PHP 8.5 זה רץ כמו שהוא, אחרי מסך שלם של הודעות deprecation: הגרסה האחרונה של Ratchet, ‏0.4.4, יצאה בדצמבר 2021, וה-README שלה אומר שמחזירים את הפרויקט לפעילות. ל-AMPHP יש שרת websocket משלו ל-PHP 8.1 ומעלה, וההרחבה Swoole מוסיפה שרת ל-PHP עצמו. כל אחד מהם הוא תהליך שאתם שומרים רץ, וזה החלק שחשוב בהמשך.

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

מה משנה תהליך PHP שרץ לאורך זמן

שני דברים בשרת הזה קובעים את כל מה שבא אחריו. $clients חי בזיכרון של התהליך הזה בלבד, והתהליך ממשיך לרוץ שבועות. רוב קוד ה-PHP לא נכתב לאף אחד מהשניים.

  • קריאה איטית אחת עוצרת את כולם. ה-event loop מריץ את הקוד שלכם חלק אחד בכל פעם. בזמן ש-onMessage() מחכה לשאילתת PDO, ל-file_get_contents() של כתובת URL או ל-sleep(), אף חיבור אחר לא מקבל מענה. ReactPHP, ש-Ratchet רץ עליו, לא חוסם כברירת מחדל ושולח עבודה חוסמת ל-workers. לכן הקריאות למסד הנתונים, שהאתר שלכם עושה בכל מקום, צריכות כאן לקוחות שנבנו ל-loop, או תור.
  • זיכרון לא מוחזר לעולם. תחת PHP-FPM, כל מה שבקשה בנתה נעלם כשהיא מסתיימת, ולכן cache סטטי או מערך שרק גדל לא מזיקים. בתהליך שרץ שבועות, הם גדלים עד שמשהו מפעיל אותו מחדש.
  • קוד חדש דורש הפעלה מחדש. הסקריפט טען את הקבצים שלכם פעם אחת, כשהוא עלה, ולכן deploy לא משנה בו כלום עד שהוא עולה שוב.
  • האתר שלכם והשרת הם שתי תוכנות. הבקשה ששמרה הזמנה רצה ב-PHP-FPM, והדפדפנים מחוברים לסקריפט ה-websocket, שהבקשה הזו לא יכולה להגיע לזיכרון שלו. המדריך של Ratchet עצמו לשליחת עדכונים מאתר קיים מעביר כל אחד מהם דרך ZeroMQ, שדורש את הספרייה libzmq והרחבת PECL. ערוץ Redis, או route קטן של HTTP בסקריפט ה-websocket, עושים את אותה עבודה.
  • לדעת מי מתחבר. דפדפן שולח את ה-cookie של ה-session שלכם יחד עם ה-upgrade כשה-websocket נמצא בדומיין שלכם, אבל הסקריפט צריך לקרוא את ה-session הזה בעצמו, ו-PHP שומר sessions בקבצים על שרת אחד כברירת מחדל. ה-WebSocket של הדפדפן לא יכול להגדיר header, ולכן הדרך האחרת היא token קצר מועד בכתובת, שהאתר שלכם חותם עליו ושנבדק לפני שהחיבור נפתח.

מה נדרש כדי להריץ אותו למשתמשים אמיתיים

שאר הרשימה מגיע יחד עם המשתמשים האמיתיים הראשונים:

  • גישת shell ומנהל תהליכים. צריך להפעיל את הסקריפט ולשמור אותו בחיים, וה-README של Ratchet מציין את זה כדרישה. אחסון משותף כמעט אף פעם לא מאפשר את זה. על שרת משלכם, systemd או Supervisor מפעילים אותו מחדש כשהוא קורס.
  • פורט, תעודה ו-proxy. דפדפנים מתחברים ב-wss:// בדומיין שלכם, בדרך כלל דרך nginx או Apache שעומדים לפני הסקריפט. התיעוד של nginx מסביר ש-proxy מעביר הלאה את ה-headers Upgrade ו-Connection רק כשמגדירים לו לעשות זאת, ושהוא סוגר חיבור דרך proxy שלא עובר בו מידע במשך 60 שניות כברירת מחדל.
  • heartbeat. לכן השרת שולח ping לכל חיבור לפי טיימר. כך proxies לא סוגרים חיבור שקט, וכך גם מתגלים חיבורים שמתו בלי להודיע על כך, שאחרת נשארים ב-$clients.
  • יותר מתהליך אחד. event loop אחד משתמש בליבה אחת של ה-CPU. שני תהליכים, או שני שרתים, מכירים כל אחד רק את החיבורים שלו, ולכן כל event צריך לעבור בערוץ שהם חולקים, בדרך כלל Redis. ה-pub/sub של Redis מוסר לכל היותר פעם אחת, כך שתהליך שבאותו רגע התחבר מחדש אף פעם לא מקבל את ה-event.
  • deploys. הפעלה מחדש מנתקת כל חיבור. ה-WebSocket של הדפדפן לא מתחבר מחדש מעצמו, ולכן הקוד של הדף שלכם עושה את זה, אחרי השהיה שגדלה ושונה בכל דפדפן. מה שנשלח בזמן שדף לא היה מחובר אבד, אלא אם אתם שומרים את ה-events האחרונים ושולחים אותם שוב, החל מהאחרון שהדף ראה.

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

או לא להחזיק תהליך websocket בכלל

שירות מנוהל לזמן אמת מוציא את החיבורים מהשרתים שלכם. הדפדפנים מתחברים לשירות. קוד ה-PHP שלכם שולח כל event בבקשת HTTPS קצרה אחת, מתוך אותה בקשה ששמרה את השינוי, והשירות מוסר אותו לכל דף שצריך לקבל אותו. שום דבר באפליקציה שלכם לא רץ יותר מבקשה, ולכן PHP-FPM נשאר כמו שהוא.

הגדרה איפה החיבורים חיים מה מריצים
PHP-FPM בלבד בשום מקום, כל בקשה מסתיימת polling, ‏worker לכל המתנה
סקריפט websocket בזיכרון שלו תהליך, proxy וערוץ מהאתר שלכם
שירות מנוהל על השרתים שלו בקשה אחת לכל event

PHP על WordPlus Cloud

עם WordPlus Cloud, חבילת Composer אחת היא צד השרת שלכם, והיא כוללת גם את קובצי הדפדפן, כך שאין צורך להתקין Node:

Shell
composer require wordplus/realtime-php      # PHP 8.1 or later, with sodium

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

PHP
// src/realtime.php, required by every request that needs it
use WordPlus\Realtime\Realtime;

$realtime = Realtime::fromEnvironment();   // WORDPLUS_SITE, WORDPLUS_SECRET, WORDPLUS_LOCAL_KEY

// The room of an order, order:1042: its customer may join, and the last 20 updates are kept.
$realtime->room( 'order:{id}', function ( $user, array $p ) {
    if ( null === $user ) {
        return false;
    }

    return order_owner( $p['id'] ) === $user;
}, [ 'history' => 20 ] );

שני routes קצרים מגישים את קובצי הדפדפן ועונים לדפים שמבקשים להצטרף, עבור המשתמש של ה-session:

PHP
// public/index.php, or your router
if ( $realtime->respondFile() ) {
    exit;
}

if ( preg_match( '#^/api/realtime/(auth|calls|keys|webhook)$#', parse_url( $_SERVER['REQUEST_URI'], PHP_URL_PATH ), $route ) ) {
    session_start( [ 'read_and_close' => true ] );
    $realtime->respond( $route[1], $_SESSION['user_id'] ?? null );
    exit;
}

אחרי שהעבודה שלכם נשמרה, הודיעו לכל מי שבחדר:

PHP
set_status( $id, 'shipped' );
$realtime->to( "order:$id" )->emit( 'updated', [ 'status' => 'shipped' ] );

הדף מקבל את ההגדרות שלו מ-<?= $realtime->head( $userId ) ?> ב-<head> שלו, יחד עם import map ללקוח, כך שהקובץ הזה רץ כמו שהוא, בלי bundler:

public/order.js
import { connect } from '@wordplus/realtime';

const rt = await connect( window.wordplusRealtimeConfig );

const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );

ה-emit הזה הוא בקשת HTTPS אחת, ולכן הוא רץ אותו דבר בבקשה של PHP-FPM, ב-cron job או ב-queue worker. ומעבר לזה:

  • אין מה להשאיר רץ. אין סקריפט websocket, אין כללי proxy ואין ערוץ בין האתר שלכם לשרת. כל אחד מהשרתים שלכם עונה לכל בקשה ושולח לכל חדר.
  • שום דבר לא הולך לאיבוד בהתחברות מחדש. חדר שומר את ה-events האחרונים שלו, כך שדף שחוזר מקבל את מה שפספס, לפי הסדר.
  • כל הדפים של משתמש אחד. $realtime->toUser( 42 )->emit( 'notice', [ 'text' => 'Your order shipped' ] ) מגיע לכל לשונית ולכל מכשיר שפתוחים אצלו. משתמש שאין אצלו שום דבר פתוח לא מקבל כלום, ולכן שלחו אימייל על מה שחייב להגיע אליו.
  • חיבור אחד לכל הלשוניות. הלשוניות של דפדפן חולקות חיבור אחד, כך שאדם עם שלוש לשוניות פתוחות נספר פעם אחת.
  • סגור לאורך הדרך. מה שהשרת שלכם שולח לחדר עם כלל עובר מוצפן, במפתחות שרק השרת שלכם והמשתמשים שלכם מחזיקים.
  • מה שדפים שולחים מגיע אליכם. webhook מביא אותו ל-PHP שלכם, חתום ונבדק על ידי החבילה לפני שה-handler שלכם רואה אותו, ונשלח שוב במשך 24 שעות אם השרת שלכם לא עונה.
  • יותר מ-events. מי מחובר כרגע, שיחות שמצלצלות בכל לשונית, שיחות קבוצתיות ושידורים חיים מגיעים על אותו חיבור, עם צ׳אט, מסך שיחה ונגן מוכנים, או עם ממשק משלכם על אותו API.

ב-Symfony, ב-Slim או ב-router משלכם, answerRequest() נותן את הסטטוס ואת ה-body לתשובה, במקום respond(). ל-Laravel יש את ה-broadcasting שלו, ו-הפוסט שלנו על חיבורי websocket ב-Laravel מראה את אותו ענן מאחורי Echo.

מתי שרת משלכם מתאים יותר

שירות מנוהל לא מתאים לכל משימה. קוד ה-PHP שלכם שומע את מה שדפים שולחים דרך webhook, בקשת HTTP שיכולה להגיע יותר מפעם אחת, ולא דרך לולאה לצד כל חיבור. משחק או מערכת בקרה, שבהם השרת צריך לענות על כל הודעה תוך אלפיות שנייה, מקומם על שרת משלהם. כך גם פרוטוקול משלכם, שתוכנות אחרות מדברות בו על websocket רגיל. וכלי לכמה עשרות אנשים, על שרת שאתם כבר מריצים, אולי לעולם לא יצטרך יותר מסקריפט ה-Ratchet שבתחילת הפוסט הזה.

התחילו מהמדריך

המדריך ל-PHP כולל את כל ההגדרה, ו-ההדגמה של PHP היא חנות קטנה ב-PHP רגיל שבנויה עליו, שבה הזמנה עוברת ל"נשלחה" בחלון אחר ברגע שאתם לוחצים. לאותה שאלה יש תשובות אחרות ב-Node.js, שבו תהליך אחד מחזיק חיבורים היטב, וב-Django וב-Flask.

WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי, ו-הפוסט שלנו על תמחור של זמן אמת מסביר איך עובדת ספירה לפי חיבור. ראו מה הוא עושה לאפליקציות, העמוד שלנו על ה-API של WebSocket מציג חדרים, נוכחות ואירועים בכל סטאק, ו-המחירים לאפליקציות כוללים את המספרים. שאלות על האינטגרציה שלכם? כתבו לנו.