Websockets en PHP sin mantener un proceso propio

PHP puede servir websockets, pero no desde las peticiones que responden a tus páginas: PHP-FPM da a cada petición un worker hasta que se envía su respuesta, y un websocket es una conexión que se queda abierta durante horas. Por eso, en PHP un websocket se ejecuta en un script propio, arrancado desde la línea de comandos y mantenido en marcha, con un event loop que vigila todas las conexiones a la vez, y tu sitio tiene que pasar a ese script cada evento que haya que enviar.
Este artículo muestra un servidor así con Ratchet, por qué no puede vivir dentro de tu sitio, qué exige mantenerlo para usuarios reales y cómo enviar eventos en directo desde PHP puro sin ningún proceso websocket.
Por qué una petición de PHP no puede mantener un websocket
Un websocket es una conexión en los dos sentidos entre un navegador y un servidor que se queda abierta, así que cualquiera de los dos lados puede enviar en cualquier momento. Empieza como una petición HTTP que pide un upgrade, y a partir de ahí ya no es una petición con su respuesta, sino una línea que sigue abierta mientras lo esté la página.
PHP se construyó al revés. Con PHP-FPM, el servidor web entrega cada petición a un worker de un pool. El worker ejecuta tu script, envía la respuesta y toma la siguiente petición. El pool tiene un tamaño fijo, y el manual de PHP indica que pm.max_children fija el límite de peticiones que se atienden a la vez. Un websocket mantenido en una petición tendría ocupado a su worker mientras su página siguiera abierta. Con 20 workers, 20 páginas abiertas los ocuparían todos, y el sitio dejaría de responder a todos los demás.
Los servidores que hay delante de PHP lo ven igual. nginx cierra la conexión con PHP-FPM cuando PHP no envía nada durante 60 segundos, por defecto, y los hostings ponen sus propios límites a lo que puede durar una petición.
El long polling y los server-sent events parecen una forma de esquivarlo, y en PHP chocan con el mismo muro: cada petición en espera ocupa un worker. WordPress se topa justo con esto, como explica nuestro artículo sobre WordPress y los websockets, y lo mismo le pasa a cualquier app de PHP, con framework o sin él.
Un servidor websocket en PHP
La respuesta en PHP es un segundo programa: un script que arrancas con php desde la línea de comandos y que nunca termina. Escucha en un puerto y ejecuta un event loop, que espera en todas las conexiones abiertas a la vez y se despierta para la que tenga algo que decir. Una biblioteca se encarga por ti del handshake y del framing del protocolo WebSocket. La más conocida es Ratchet, construida sobre el event loop de 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();Arráncalo con php chat.php, y una página se conecta con la API WebSocket que tienen todos los navegadores:
const socket = new WebSocket( 'ws://localhost:8080/chat' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Abre esa página en dos pestañas, servida desde localhost, y cada una imprime lo que envía la otra. El tercer argumento de route() enumera los hosts cuyas páginas pueden conectarse, porque una página de cualquier otro sitio puede abrir un websocket con tu servidor, y el estándar deja en tus manos rechazarlo. [ '*' ] deja entrar a cualquier sitio.
En PHP 8.5 esto funciona tal cual, tras una pantalla llena de avisos de deprecación: la última versión de Ratchet, la 0.4.4, salió en diciembre de 2021, y su README dice que el proyecto se está reactivando. AMPHP tiene un servidor websocket propio para PHP 8.1 y posteriores, y la extensión Swoole añade un servidor al propio PHP. Cada uno de ellos es un proceso que mantienes en marcha, y eso es lo que importa a partir de aquí.
Cuando el servidor funcione en una dirección pública, nuestro test de WebSocket se conecta a él desde un navegador y explica cualquier código de cierre. Si el navegador solo indica que la conexión falló, nuestro artículo sobre el error 1006 de WebSocket explica cómo encontrar la causa.
Qué cambia un proceso de PHP de larga duración
Dos cosas de ese servidor deciden todo lo que viene después. $clients vive en la memoria de este único proceso, y el proceso sigue en marcha durante semanas. La mayor parte del código PHP no está escrita para ninguna de las dos.
- Una llamada lenta detiene a todos. El event loop ejecuta tu código un fragmento cada vez. Mientras
onMessage()espera una consulta de PDO, unfile_get_contents()de una URL o unsleep(), no se atiende ninguna otra conexión. ReactPHP, sobre el que funciona Ratchet, no es bloqueante por defecto y manda el trabajo bloqueante a workers. Así que las llamadas a la base de datos que tu sitio hace por todas partes necesitan aquí clientes hechos para el loop, o una cola. - La memoria nunca se devuelve. Con PHP-FPM, todo lo que construyó una petición desaparece cuando termina, así que una caché estática o un array que solo crece no hace daño. En un proceso que funciona durante semanas, crece hasta que algo lo reinicia.
- El código nuevo exige un reinicio. El script cargó tus archivos una sola vez, al arrancar, así que un deploy no cambia nada en él hasta que vuelve a arrancar.
- Tu sitio y el servidor son dos programas. La petición que guardó un pedido se ejecuta en PHP-FPM, y los navegadores están conectados al script websocket, a cuya memoria esa petición no llega. La propia guía de Ratchet para enviar actualizaciones desde un sitio existente pasa cada una por ZeroMQ, que exige la biblioteca libzmq y una extensión PECL. Un canal de Redis, o una pequeña ruta HTTP en el script websocket, hace el mismo trabajo.
- Saber quién se conecta. Un navegador envía tu cookie de sesión con el upgrade cuando el websocket está en tu propio dominio, pero el script tiene que leer esa sesión por su cuenta, y PHP guarda por defecto las sesiones en archivos de un solo servidor. El
WebSocketde un navegador no puede poner una cabecera, así que la otra vía es un token de vida corta en la dirección, firmado por tu sitio y comprobado antes de que se abra la conexión.
Qué exige mantenerlo para usuarios reales
El resto de la lista llega con los primeros usuarios reales:
- Acceso por shell y un gestor de procesos. El script tiene que arrancarse y mantenerse vivo, algo que el README de Ratchet indica como requisito. El hosting compartido rara vez lo permite. En un servidor propio, systemd o Supervisor lo vuelven a arrancar cuando se cae.
- Un puerto, un certificado y un proxy. Los navegadores se conectan por
wss://en tu dominio, normalmente a través de nginx o Apache delante. La documentación de nginx explica que un proxy solo reenvía las cabecerasUpgradeyConnectionsi se le indica, y que cierra por defecto una conexión que pasa por el proxy sin datos durante 60 segundos. - Un heartbeat. Por eso el servidor envía un ping a cada conexión cada cierto tiempo. Así los proxies no cierran una que está callada, y aparecen las conexiones que murieron sin avisar, que si no se quedarían en
$clients. - Más de un proceso. Un event loop usa un núcleo de la CPU. Dos procesos, o dos servidores, conocen cada uno solo sus propias conexiones, así que cada evento tiene que cruzar un canal que compartan, normalmente Redis. El pub/sub de Redis entrega como mucho una vez, así que un proceso que en ese momento se estaba reconectando nunca recibe el evento.
- Deploys. Un reinicio corta todas las conexiones. El
WebSocketde un navegador no se reconecta por sí solo, así que lo hace el código de tu página, tras una espera que crece y que es distinta en cada navegador. Lo que se envió mientras una página estaba desconectada se pierde, a menos que guardes los eventos recientes y los reenvíes desde el último que vio.
Nada de esto es inusual, y muchos equipos lo hacen bien. Aun así, es un segundo sistema junto a tu app de PHP, escrito en un estilo que el resto de tu código nunca necesita.
O no mantengas ningún proceso websocket
Un servicio de tiempo real alojado saca las conexiones de tus servidores. Los navegadores se conectan al servicio. Tu código PHP envía cada evento en una petición HTTPS corta, desde la misma petición que guardó el cambio, y el servicio lo entrega a cada página que deba recibirlo. Nada en tu app dura más que una petición, así que PHP-FPM se queda como está.
| Configuración | Dónde viven las conexiones | Qué ejecutas |
|---|---|---|
| Solo PHP-FPM | En ninguna parte, cada petición termina | Polling, un worker por cada espera |
| Un script websocket | En su memoria | Un proceso, un proxy y un canal desde tu sitio |
| Un servicio alojado | En sus servidores | Una petición por cada evento |
PHP en WordPlus Cloud
Con WordPlus Cloud, un solo paquete de Composer es tu lado del servidor, y trae también los archivos para el navegador, así que no hay Node que instalar:
composer require wordplus/realtime-php # PHP 8.1 or later, with sodiumTu app declara sus salas una sola vez, cada una con una regla para quién puede unirse. Esta es la sala de un pedido, para su 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 ] );Dos rutas cortas sirven los archivos para el navegador y responden a las páginas que piden unirse, para el usuario de la sesión:
// 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;
}Una vez guardado tu propio trabajo, avisa a todos los de la sala:
set_status( $id, 'shipped' );
$realtime->to( "order:$id" )->emit( 'updated', [ 'status' => 'shipped' ] );La página recibe su configuración de <?= $realtime->head( $userId ) ?> en su <head>, con un import map para el cliente, así que este archivo funciona tal cual, sin 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 ) );Ese emit es una petición HTTPS, así que funciona igual en una petición de PHP-FPM, en un cron job o en un worker de colas. Más allá de eso:
- Nada que mantener en marcha. Ni script websocket, ni reglas de proxy, ni un canal entre tu sitio y un servidor. Cualquiera de tus servidores responde a cualquier petición y envía a cualquier sala.
- Nada se pierde al reconectar. Una sala guarda sus últimos eventos, así que una página que vuelve recibe lo que se perdió, en orden.
- Todas las páginas de un usuario.
$realtime->toUser( 42 )->emit( 'notice', [ 'text' => 'Your order shipped' ] )llega a todas las pestañas y dispositivos que tenga abiertos. Un usuario sin nada abierto no recibe nada, así que envía un correo para lo que tenga que llegarle sí o sí. - Una conexión para todas las pestañas. Las pestañas de un navegador comparten una conexión, así que una persona con tres pestañas abiertas cuenta una sola vez.
- Sellado en tránsito. Lo que tu servidor envía a una sala con regla viaja cifrado con claves que solo tienen tu servidor y tus usuarios.
- Lo que envían las páginas te llega a ti. Un webhook lo lleva a tu PHP, firmado y comprobado por el paquete antes de que lo vea tu handler, y se reintenta durante 24 horas si tu servidor no responde.
- Más que eventos. Quién está en línea, llamadas que suenan en todas las pestañas, llamadas en grupo y transmisiones en directo llegan por la misma conexión, con un chat, una pantalla de llamada y un reproductor listos para usar, o tu propia interfaz sobre la misma API.
En Symfony, Slim o un router propio, answerRequest() da el estado y el cuerpo con los que responder, en lugar de respond(). Laravel tiene su broadcasting, y nuestro artículo sobre websockets en Laravel muestra la misma nube detrás de Echo.
Cuándo te conviene más tu propio servidor
Un servicio alojado no sirve para todo. Tu código PHP se entera de lo que envían las páginas a través de un webhook, una petición HTTP que puede llegar más de una vez, y no a través de un bucle junto a cada conexión. Un juego o un sistema de control en el que el servidor tenga que responder a cada mensaje en milisegundos debe ir en su propio servidor. Lo mismo vale para un protocolo propio que otros programas hablen sobre un websocket puro. Y una herramienta para unas pocas decenas de personas, en un servidor que ya tienes en marcha, quizá nunca necesite más que el script de Ratchet del principio de este artículo.
Empieza por la guía
La guía de PHP tiene toda la configuración, y la demo de PHP es una pequeña tienda en PHP puro construida sobre ella, en la que un pedido pasa a enviado en otra ventana en cuanto haces clic. La misma pregunta tiene otras respuestas en Node.js, donde un solo proceso mantiene bien las conexiones, y en Django y Flask.
WordPlus Cloud for Apps tiene un precio según las conexiones simultáneas, a partir de 1.000, con facturación mensual o anual, y nuestro artículo sobre los precios de tiempo real explica cómo funciona contar por conexión. Descubre lo que hace para apps, nuestra página de la API de WebSocket muestra salas, presencia y eventos en cada stack, y los precios para apps tienen las cifras. ¿Preguntas sobre tu integración? Escríbenos.