Websockets in PHP zonder zelf een proces te draaien

PHP kan websockets bedienen, maar niet vanuit de verzoeken die je pagina’s beantwoorden: PHP-FPM geeft elk verzoek een worker tot het antwoord is verstuurd, en een websocket is een verbinding die urenlang openblijft. Een websocket in PHP draait dus in een eigen script, gestart vanaf de commandoregel en draaiende gehouden, met een event loop die alle verbindingen tegelijk in de gaten houdt, en je site moet dat script elk event aanreiken dat het moet versturen.
In dit artikel lees je hoe zo’n server eruitziet met Ratchet, waarom hij niet in je site kan leven, wat het vraagt om hem voor echte gebruikers te draaien, en hoe je vanuit gewoon PHP live events verstuurt zonder überhaupt een websocketproces.
Waarom een PHP-verzoek geen websocket kan vasthouden
Een websocket is een verbinding in twee richtingen tussen een browser en een server die open blijft, zodat beide kanten op elk moment kunnen versturen. Hij begint als een HTTP-verzoek dat om een upgrade vraagt, en vanaf dat moment is het geen verzoek met een antwoord meer, maar een lijn die openblijft zolang de pagina openstaat.
PHP is andersom gebouwd. Onder PHP-FPM geeft de webserver elk verzoek aan één worker uit een pool. De worker draait je script, verstuurt het antwoord en neemt het volgende verzoek aan. De pool heeft een vaste grootte, en de PHP-handleiding zegt dat pm.max_children bepaalt hoeveel verzoeken er hooguit tegelijk worden afgehandeld. Een websocket die in een verzoek wordt vastgehouden, zou zijn worker bezighouden zolang de pagina openstaat. Met 20 workers zouden 20 open pagina’s ze allemaal bezetten, en de site zou niemand anders meer antwoorden.
De servers vóór PHP zien het net zo. nginx sluit standaard de verbinding met PHP-FPM als PHP 60 seconden niets verstuurt, en hosts stellen eigen grenzen aan hoe lang een verzoek mag duren.
Long polling en server-sent events lijken een uitweg, maar in PHP lopen ze tegen dezelfde muur aan: elk wachtend verzoek houdt een worker bezet. WordPress loopt precies hier tegenaan, zoals ons artikel over WordPress en websockets uitlegt, en dat geldt voor elke PHP-app, met of zonder framework.
Een websocketserver in PHP
Het antwoord in PHP is een tweede programma: een script dat je met php vanaf de commandoregel start en dat nooit eindigt. Het luistert op een poort en draait een event loop, die op alle open verbindingen tegelijk wacht en wakker wordt voor de verbinding die iets te zeggen heeft. Een bibliotheek doet de handshake en de framing van het WebSocket-protocol voor je. De bekendste is Ratchet, gebouwd op de event loop van ReactPHP:
composer require cboden/ratchet<?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();Start hem met php chat.php, en een pagina maakt verbinding met de WebSocket API die elke browser heeft:
const socket = new WebSocket( 'ws://localhost:8080/chat' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Open die pagina in twee tabbladen, geserveerd vanaf localhost, en elk tabblad print wat het andere verstuurt. Het derde argument van route() noemt de hosts waarvan de pagina’s verbinding mogen maken, want een pagina op elke andere site kan een websocket naar je server openen, en de standaard laat het weigeren aan jou over. [ '*' ] laat elke site binnen.
Op PHP 8.5 draait dit zoals het is, na een scherm vol deprecation notices: de laatste release van Ratchet, 0.4.4, verscheen in december 2021, en de README zegt dat het project nieuw leven wordt ingeblazen. AMPHP heeft een eigen websocketserver voor PHP 8.1 en later, en de extensie Swoole voegt een server toe aan PHP zelf. Elk daarvan is een proces dat je draaiende houdt, en daar gaat het hieronder om.
Draait de server op een openbaar adres, dan maakt onze WebSocket-test er vanuit een browser verbinding mee en legt elke sluitcode uit. Meldt een browser alleen dat de verbinding mislukt is, dan laat ons artikel over WebSocket-fout 1006 zien hoe je de oorzaak vindt.
Wat een langlopend PHP-proces verandert
Twee dingen in die server bepalen alles wat volgt. $clients leeft in het geheugen van dit ene proces, en het proces blijft wekenlang draaien. De meeste PHP-code is voor geen van beide geschreven.
- Eén trage aanroep legt alles stil. De event loop draait je code stukje voor stukje. Terwijl
onMessage()wacht op een PDO-query, eenfile_get_contents()van een URL of eensleep(), wordt geen enkele andere verbinding bediend. ReactPHP, waarop Ratchet draait, is standaard non-blocking en stuurt blokkerend werk naar workers. De databaseaanroepen die je site overal doet, hebben hier dus clients nodig die voor de loop gebouwd zijn, of een queue. - Geheugen komt nooit terug. Onder PHP-FPM is alles wat een verzoek opbouwde weg zodra het eindigt, dus een statische cache of een array die alleen maar groeit, kan geen kwaad. In een proces dat wekenlang draait, groeit het tot iets het herstart.
- Nieuwe code vraagt een herstart. Het script laadde je bestanden één keer, bij het starten, dus een deploy verandert er niets aan tot het opnieuw start.
- Je site en de server zijn twee programma’s. Het verzoek dat een bestelling opsloeg, draait in PHP-FPM, en de browsers zijn verbonden met het websocketscript, waarvan het geheugen voor dat verzoek onbereikbaar is. De eigen handleiding van Ratchet voor het versturen van updates vanuit een bestaande site geeft elke update door over ZeroMQ, wat de bibliotheek libzmq en een PECL-extensie vraagt. Een Redis-kanaal, of een kleine HTTP-route in het websocketscript, doet hetzelfde werk.
- Weten wie er verbinding maakt. Een browser stuurt je sessiecookie mee met de upgrade als de websocket op je eigen domein staat, maar het script moet die sessie zelf uitlezen, en PHP bewaart sessies standaard in bestanden op één server. De
WebSocketvan een browser kan geen header meegeven, dus de andere weg is een kortlevend token in het adres, ondertekend door je site en gecontroleerd voordat de verbinding opengaat.
Wat het vraagt voor echte gebruikers
De rest van de lijst komt mee met de eerste echte gebruikers:
- Shelltoegang en een procesmanager. Het script moet gestart en in leven gehouden worden, wat de README van Ratchet als vereiste noemt. Shared hosting staat dat zelden toe. Op een eigen server start systemd of Supervisor het opnieuw als het crasht.
- Een poort, een certificaat en een proxy. Browsers maken verbinding over
wss://op je domein, meestal met nginx of Apache ervoor. De nginx-documentatie legt uit dat een proxy de headersUpgradeenConnectionalleen doorgeeft als je hem dat opdraagt, en dat een verbinding via de proxy waar 60 seconden geen data over gaat, standaard wordt gesloten. - Een heartbeat. Daarom pingt de server elke verbinding op een timer. Zo sluiten proxy’s een stille verbinding niet, en zo vind je de verbindingen die zijn weggevallen zonder het te melden, die anders in
$clientsblijven staan. - Meer dan één proces. Eén event loop gebruikt één core van de CPU. Twee processen, of twee servers, kennen elk alleen hun eigen verbindingen, dus moet elk event door een kanaal dat ze delen, meestal Redis. Redis pub/sub bezorgt hooguit één keer, dus een proces dat op dat moment opnieuw verbinding maakte, krijgt het event nooit.
- Deploys. Een herstart verbreekt elke verbinding. De
WebSocketvan een browser maakt niet uit zichzelf opnieuw verbinding, dus doet de code van je pagina dat, na een wachttijd die oploopt en per browser verschilt. Wat er is verstuurd terwijl een pagina weg was, is verdwenen, tenzij je recente events bewaart en ze opnieuw afspeelt vanaf het laatste dat de pagina zag.
Niets hiervan is ongewoon, en genoeg teams doen het goed. Toch is het een tweede systeem naast je PHP-app, geschreven in een stijl die de rest van je code nooit nodig heeft.
Of draai helemaal geen websocketproces
Een gehoste realtime dienst haalt de verbindingen weg van je servers. De browsers maken verbinding met de dienst. Je PHP-code verstuurt elk event in één kort HTTPS-verzoek, vanuit hetzelfde verzoek dat de wijziging opsloeg, en de dienst bezorgt het aan elke pagina die het moet krijgen. Niets in je app draait langer dan een verzoek, dus PHP-FPM blijft zoals het is.
| Opzet | Waar verbindingen leven | Wat je draait |
|---|---|---|
| Alleen PHP-FPM | Nergens, elk verzoek eindigt | Polling, wachten kost een worker |
| Een websocketscript | In zijn geheugen | Een proces, een proxy en een kanaal vanaf je site |
| Een gehoste dienst | Op zijn servers | Eén verzoek per event |
PHP op WordPlus Cloud
Met WordPlus Cloud is één Composer-package je serverkant, en het bevat ook de browserbestanden, dus Node hoef je niet te installeren:
composer require wordplus/realtime-php # PHP 8.1 or later, with sodiumJe app legt zijn ruimtes één keer vast, elk met een regel voor wie erin mag. Dit is de ruimte van een bestelling, voor de klant ervan:
// 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 ] );Twee korte routes serveren de browserbestanden en beantwoorden de pagina’s die vragen om deel te nemen, voor de gebruiker uit de sessie:
// 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;
}Zodra je eigen werk is opgeslagen, laat je het iedereen in de ruimte weten:
set_status( $id, 'shipped' );
$realtime->to( "order:$id" )->emit( 'updated', [ 'status' => 'shipped' ] );De pagina krijgt haar instellingen van <?= $realtime->head( $userId ) ?> in haar <head>, met een import map voor de client, dus dit bestand draait zoals het is, zonder bundler:
import { connect } from '@wordplus/realtime';
const rt = await connect( window.wordplusRealtimeConfig );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );Die emit is één HTTPS-verzoek, dus hij werkt hetzelfde in een PHP-FPM-verzoek, een cronjob of een queue worker. En daarnaast:
- Niets om draaiende te houden. Geen websocketscript, geen proxyregels en geen kanaal tussen je site en een server. Elk van je servers beantwoordt elk verzoek en verstuurt naar elke ruimte.
- Niets kwijt bij opnieuw verbinden. Een ruimte bewaart de laatste events, dus een pagina die terugkomt, krijgt wat ze gemist heeft, in de juiste volgorde.
- Elke pagina van één gebruiker.
$realtime->toUser( 42 )->emit( 'notice', [ 'text' => 'Your order shipped' ] )bereikt elk tabblad en apparaat dat hij open heeft. Een gebruiker met niets open krijgt niets, dus stuur een e-mail voor wat hem moet bereiken. - Eén verbinding voor alle tabbladen. De tabbladen van een browser delen één verbinding, zodat iemand met drie tabbladen open maar één keer telt.
- Verzegeld onderweg. Wat je server verstuurt naar een ruimte met een regel, reist versleuteld met sleutels die alleen je server en je gebruikers hebben.
- Wat pagina’s versturen, komt bij jou aan. Een webhook brengt het naar je PHP, ondertekend en gecontroleerd door het package voordat je handler het ziet, en 24 uur lang opnieuw geprobeerd als je server niet antwoordt.
- Meer dan events. Wie er online is, gesprekken die in elk tabblad overgaan, groepsgesprekken en livestreams lopen over dezelfde verbinding, met een kant-en-klaar belscherm, chat en speler, of je eigen interface op dezelfde API.
In Symfony, Slim of een eigen router geeft answerRequest() je in plaats van respond() de status en de body om mee te antwoorden. Laravel heeft zijn eigen broadcasting, en ons artikel over websockets in Laravel laat dezelfde cloud achter Echo zien.
Wanneer je eigen server beter past
Een gehoste dienst past niet bij elke klus. Je PHP-code hoort wat pagina’s versturen via een webhook, een HTTP-verzoek dat meer dan eens kan aankomen, en niet in een loop naast elke verbinding. Een game of een regelsysteem waarin de server elk bericht binnen milliseconden moet beantwoorden, hoort op een eigen server. Dat geldt ook voor een eigen protocol dat andere programma’s over een gewone websocket spreken. En een tool voor enkele tientallen mensen, op een server die je al draait, heeft misschien nooit meer nodig dan het Ratchet-script bovenaan dit artikel.
Begin met de handleiding
De PHP-handleiding beschrijft de hele installatie, en de PHP-demo is een kleine webwinkel in gewoon PHP die erop is gebouwd, waar een bestelling in een ander venster de status verzonden krijgt terwijl je klikt. Dezelfde vraag heeft andere antwoorden in Node.js, waar één proces verbindingen goed vasthoudt, en in Django en Flask.
WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, en ons artikel over prijzen voor realtime legt uit hoe tellen per verbinding werkt. Bekijk wat het doet voor apps. Onze pagina over de WebSocket-API toont ruimtes, aanwezigheid en events in elke stack, en bij de prijzen voor apps vind je de cijfers. Vragen over je integratie? Schrijf ons.