Websocket in PHP senza un processo tutto tuo

PHP può servire websocket, ma non dalle richieste che rispondono alle tue pagine: PHP-FPM assegna a ogni richiesta un worker finché la sua risposta non è stata inviata, e un websocket è una connessione che resta aperta per ore. Quindi un websocket in PHP gira in uno script a parte, avviato dalla riga di comando e tenuto in esecuzione, con un event loop che sorveglia tutte le connessioni insieme, e il tuo sito deve passare a quello script ogni evento da inviare.
Questo articolo mostra un server del genere con Ratchet, perché non può vivere dentro il tuo sito, cosa serve per farlo funzionare con utenti reali, e come inviare eventi in tempo reale da PHP puro senza alcun processo websocket.
Perché una richiesta PHP non può tenere aperto un websocket
Un websocket è una connessione bidirezionale tra un browser e un server che resta aperta, così ciascuna delle due parti può inviare in qualsiasi momento. Nasce come una richiesta HTTP che chiede un upgrade, e da quel momento non è più una richiesta con una risposta ma una linea che resta aperta finché lo è la pagina.
PHP è pensato al contrario. Con PHP-FPM, il web server passa ogni richiesta a uno dei worker di un pool. Il worker esegue il tuo script, invia la risposta e prende la richiesta successiva. Il pool ha una dimensione fissa, e il manuale di PHP spiega che pm.max_children fissa il limite di richieste servite contemporaneamente. Un websocket tenuto in una richiesta terrebbe occupato il suo worker finché la sua pagina resta aperta. Con 20 worker, 20 pagine aperte li occuperebbero tutti, e il sito smetterebbe di rispondere a chiunque altro.
I server che stanno davanti a PHP la vedono allo stesso modo. Di default, nginx chiude la connessione con PHP-FPM quando PHP non invia nulla per 60 secondi, e gli hosting fissano limiti propri sulla durata di una richiesta.
Il long polling e i server-sent events sembrano un modo per aggirarlo, e in PHP vanno a sbattere contro lo stesso muro: ogni richiesta in attesa occupa un worker. WordPress si scontra proprio con questo, come spiega il nostro articolo su WordPress e i websocket, e lo stesso vale per ogni app PHP, con un framework o senza.
Un server websocket in PHP
In PHP la risposta è un secondo programma: uno script che avvii con php dalla riga di comando, e che non finisce mai. Ascolta su una porta ed esegue un event loop, che aspetta su tutte le connessioni aperte insieme e si sveglia per quella che ha qualcosa da dire. Una libreria si occupa per te dell’handshake e del framing del protocollo WebSocket. La più nota è Ratchet, costruita sull’event loop di 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();Avvialo con php chat.php, e una pagina si collega con l’API WebSocket che ogni browser ha:
const socket = new WebSocket( 'ws://localhost:8080/chat' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Apri quella pagina in due schede, servita da localhost, e ognuna stampa ciò che invia l’altra. Il terzo argomento di route() elenca gli host le cui pagine possono collegarsi, perché una pagina di qualsiasi altro sito può aprire un websocket verso il tuo server, e lo standard lascia a te il compito di rifiutarlo. Con [ '*' ] entra qualsiasi sito.
Su PHP 8.5 funziona così com’è, dopo una schermata di avvisi di deprecazione: l’ultima release di Ratchet, la 0.4.4, è uscita a dicembre 2021, e il suo README dice che il progetto è in fase di rilancio. AMPHP ha un proprio server websocket per PHP 8.1 e successivi, e l’estensione Swoole aggiunge un server a PHP stesso. Ognuno di loro è un processo da tenere in esecuzione, ed è questa la parte che conta in ciò che segue.
Quando il server gira su un indirizzo pubblico, il nostro test WebSocket ci si collega da un browser e spiega qualsiasi codice di chiusura. Se il browser segnala soltanto che la connessione non è riuscita, il nostro articolo sull’errore WebSocket 1006 mostra come trovarne la causa.
Cosa cambia un processo PHP di lunga durata
Due cose in quel server decidono tutto ciò che segue. La variabile $clients vive nella memoria di questo solo processo, e il processo resta in esecuzione per settimane. La maggior parte del codice PHP non è scritta né per l’una né per l’altra.
- Una sola chiamata lenta ferma tutti. L’event loop esegue il tuo codice un pezzo alla volta. Mentre
onMessage()aspetta una query PDO, unfile_get_contents()di un URL o unosleep(), nessun’altra connessione viene servita. ReactPHP, su cui gira Ratchet, è non bloccante di default e affida il lavoro bloccante a dei worker. Quindi qui le chiamate al database che il tuo sito fa ovunque hanno bisogno di client fatti per il loop, o di una coda. - La memoria non viene mai restituita. Con PHP-FPM, tutto ciò che una richiesta ha costruito sparisce quando finisce, quindi una cache statica o un array che non fa che crescere non fa danni. In un processo che gira per settimane, cresce finché qualcosa non lo riavvia.
- Il codice nuovo richiede un riavvio. Lo script ha caricato i tuoi file una volta sola, all’avvio, quindi un deploy non cambia nulla al suo interno finché non riparte.
- Il tuo sito e il server sono due programmi. La richiesta che ha salvato un ordine gira in PHP-FPM, e i browser sono collegati allo script websocket, la cui memoria quella richiesta non può raggiungere. La guida di Ratchet stesso per inviare aggiornamenti da un sito esistente fa passare ognuno di essi tramite ZeroMQ, che richiede la libreria libzmq e un’estensione PECL. Un canale Redis, o una piccola route HTTP nello script websocket, fa lo stesso lavoro.
- Sapere chi si sta collegando. Il browser invia il tuo cookie di sessione con l’upgrade quando il websocket è sul tuo stesso dominio, ma lo script deve leggere quella sessione da solo, e di default PHP tiene le sessioni in file su un solo server. Il
WebSocketdel browser non può impostare un header, quindi l’altra strada è un token di breve durata nell’indirizzo, firmato dal tuo sito e verificato prima che la connessione si apra.
Cosa serve per farlo funzionare con utenti reali
Il resto dell’elenco arriva con i primi utenti reali:
- Accesso alla shell e un process manager. Lo script va avviato e tenuto in vita, cosa che il README di Ratchet indica come requisito. Gli hosting condivisi lo permettono di rado. Su un server tutto tuo, systemd o Supervisor lo riavviano quando va in crash.
- Una porta, un certificato e un proxy. I browser si collegano via
wss://sul tuo dominio, di solito passando da nginx o Apache messi davanti. La documentazione di nginx spiega che un proxy inoltra gli headerUpgradeeConnectionsolo se glielo si chiede, e che di default chiude una connessione che passa dal proxy e resta senza dati per 60 secondi. - Un heartbeat. Per questo il server invia un ping a ogni connessione a intervalli regolari. Così i proxy non chiudono quelle silenziose, e si scoprono le connessioni morte senza avvisare, che altrimenti restano in
$clients. - Più di un processo. Un event loop usa un solo core della CPU. Due processi, o due server, conoscono ciascuno soltanto le proprie connessioni, quindi ogni evento deve passare per un canale condiviso, di solito Redis. Il pub/sub di Redis consegna al massimo una volta, quindi un processo che in quel momento si stava riconnettendo non riceve mai l’evento.
- Deploy. Un riavvio fa cadere ogni connessione. Il
WebSocketdel browser non si riconnette da solo, quindi lo fa il codice della tua pagina, dopo un ritardo che cresce ed è diverso per ogni browser. Ciò che è stato inviato mentre una pagina era scollegata è perso, a meno che tu non conservi gli eventi recenti e li reinvii a partire dall’ultimo che ha visto.
Niente di tutto questo è insolito, e molti team lo fanno bene. Resta comunque un secondo sistema accanto alla tua app PHP, scritto in uno stile di cui il resto del tuo codice non ha mai bisogno.
Oppure non tenere nessun processo websocket
Un servizio in tempo reale gestito toglie le connessioni ai tuoi server. I browser si collegano al servizio. Il tuo codice PHP invia ogni evento con una breve richiesta HTTPS, dalla stessa richiesta che ha salvato la modifica, e il servizio lo consegna a ogni pagina che deve riceverlo. Nulla nella tua app dura più di una richiesta, quindi PHP-FPM resta com’è.
| Configurazione | Dove vivono le connessioni | Cosa fai girare |
|---|---|---|
| Solo PHP-FPM | Da nessuna parte, ogni richiesta finisce | Polling, un worker per ogni attesa |
| Uno script websocket | Nella sua memoria | Un processo, un proxy e un canale dal tuo sito |
| Un servizio gestito | Sui suoi server | Una richiesta per ogni evento |
PHP su WordPlus Cloud
Con WordPlus Cloud, un unico pacchetto Composer è il tuo lato server, e contiene anche i file per il browser, quindi non c’è Node da installare:
composer require wordplus/realtime-php # PHP 8.1 or later, with sodiumLa tua app dichiara le sue stanze una volta sola, ciascuna con una regola su chi può entrare. Questa è la stanza di un ordine, per il suo cliente:
// 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 ] );Due brevi route servono i file per il browser e rispondono alle pagine che chiedono di entrare, per l’utente della sessione:
// 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;
}Dopo aver salvato il tuo lavoro, avvisa tutti nella stanza:
set_status( $id, 'shipped' );
$realtime->to( "order:$id" )->emit( 'updated', [ 'status' => 'shipped' ] );La pagina riceve le sue impostazioni da <?= $realtime->head( $userId ) ?> nel suo <head>, con una import map per il client, così questo file funziona così com’è, senza 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 ) );Quella chiamata a emit è una sola richiesta HTTPS, quindi funziona allo stesso modo in una richiesta PHP-FPM, in un cron job o in un queue worker. In più:
- Nulla da tenere in esecuzione. Nessuno script websocket, nessuna regola nel proxy e nessun canale tra il tuo sito e un server. Ognuno dei tuoi server risponde a qualsiasi richiesta e invia a qualsiasi stanza.
- Nulla si perde alla riconnessione. Una stanza conserva i suoi ultimi eventi, così una pagina che torna riceve ciò che si è persa, in ordine.
- Ogni pagina di un utente.
$realtime->toUser( 42 )->emit( 'notice', [ 'text' => 'Your order shipped' ] )raggiunge ogni scheda e ogni dispositivo che ha aperti. Un utente che non ha nulla aperto non riceve nulla, quindi invia un’email per ciò che deve raggiungerlo. - Una sola connessione per tutte le schede. Le schede di un browser condividono un’unica connessione, così una persona con tre schede aperte conta una volta sola.
- Sigillato lungo il tragitto. Ciò che il tuo server invia a una stanza con una regola viaggia cifrato con chiavi che hanno solo il tuo server e i tuoi utenti.
- Ciò che inviano le pagine arriva a te. Un webhook lo porta al tuo PHP, firmato e verificato dal pacchetto prima che lo veda il tuo handler, e ritentato per 24 ore se il tuo server non risponde.
- Non solo eventi. Chi è online, chiamate che squillano in ogni scheda, chiamate di gruppo e live streaming arrivano sulla stessa connessione, con chat, schermata di chiamata e player pronti all’uso, oppure con la tua interfaccia sulla stessa API.
In Symfony, Slim o un router tutto tuo, answerRequest() restituisce lo stato e il corpo con cui rispondere, al posto di respond(). Laravel ha il suo broadcasting, e il nostro articolo sui websocket in Laravel mostra lo stesso cloud dietro Echo.
Quando è meglio un server tutto tuo
Un servizio gestito non va bene per ogni lavoro. Il tuo codice PHP riceve ciò che inviano le pagine tramite un webhook, una richiesta HTTP che può arrivare più di una volta, e non tramite un loop accanto a ogni connessione. Un gioco o un sistema di controllo in cui il server deve rispondere a ogni messaggio entro pochi millisecondi va su un proprio server. Lo stesso vale per un protocollo tutto tuo che altri programmi parlano su un websocket puro. E a uno strumento per qualche decina di persone, su un server che gestisci già, potrebbe non servire mai più dello script Ratchet all’inizio di questo articolo.
Parti dalla guida
La guida per PHP contiene tutta la configurazione, e la demo per PHP è un piccolo negozio in PHP puro costruito su di essa, dove un ordine passa a spedito in un’altra finestra mentre fai clic. La stessa domanda ha altre risposte in Node.js, dove un solo processo regge bene le connessioni, e in Django e Flask.
WordPlus Cloud for Apps ha un prezzo in base alle connessioni simultanee, a partire da 1.000, con fatturazione mensile o annuale, e il nostro articolo sui prezzi dei servizi in tempo reale spiega come funziona il conteggio a connessione. Scopri cosa fa per le app. La nostra pagina sull’API WebSocket mostra stanze, presenza ed eventi in ogni stack, e i prezzi per le app riportano le cifre. Domande sulla tua integrazione? Scrivici.