Blog

Des websockets en PHP sans faire tourner votre propre processus

· Andrij Tkachenko · 12 min de lecture

Cinq petites cartes de requête, chacune fermée par une coche, à côté d’un seul serveur dont l’unique ligne se ramifie vers trois fenêtres de navigateur

PHP sait servir des websockets, mais pas depuis les requêtes qui répondent à vos pages : PHP-FPM donne à chaque requête un worker jusqu’à ce que sa réponse soit envoyée, alors qu’un websocket est une connexion qui reste ouverte pendant des heures. Un websocket en PHP tourne donc dans un script à part, lancé en ligne de commande et maintenu en marche, avec une boucle d’événements qui surveille toutes les connexions à la fois, et votre site doit remettre à ce script chaque événement à envoyer.

Cet article montre un tel serveur avec Ratchet, explique pourquoi il ne peut pas vivre à l’intérieur de votre site et ce qu’il faut pour le faire tourner pour de vrais utilisateurs, puis comment envoyer des événements en direct depuis du PHP pur, sans aucun processus websocket.

Pourquoi une requête PHP ne peut pas tenir un websocket

Un websocket est une connexion bidirectionnelle entre un navigateur et un serveur qui reste ouverte, si bien que chaque côté peut envoyer à tout moment. Il commence par une requête HTTP qui demande un upgrade, et à partir de là ce n’est plus une requête suivie d’une réponse, mais une ligne qui reste ouverte aussi longtemps que la page.

PHP a été conçu à l’inverse. Sous PHP-FPM, le serveur web confie chaque requête à un worker d’un pool. Le worker exécute votre script, envoie la réponse et prend la requête suivante. Le pool a une taille fixe, et le manuel de PHP indique que pm.max_children fixe le nombre maximal de requêtes servies à la fois. Un websocket tenu dans une requête garderait son worker occupé aussi longtemps que sa page reste ouverte. Avec 20 workers, 20 pages ouvertes suffiraient à les occuper tous, et le site ne répondrait plus à personne d’autre.

Les serveurs placés devant PHP voient les choses de la même façon. Par défaut, nginx ferme la connexion vers PHP-FPM quand PHP n’envoie rien pendant 60 secondes, et les hébergeurs fixent leurs propres limites à la durée d’une requête.

Le long polling et les server-sent events ressemblent à un contournement, et en PHP ils se heurtent au même mur : chaque requête en attente occupe un worker. WordPress bute exactement là-dessus, comme l’explique notre article sur WordPress et les websockets, et il en va de même de toute application PHP, avec ou sans framework.

Un serveur websocket en PHP

En PHP, la réponse est un second programme : un script que vous lancez avec php en ligne de commande, et qui ne se termine jamais. Il écoute sur un port et fait tourner une boucle d’événements, qui attend sur toutes les connexions ouvertes à la fois et se réveille pour celle qui a quelque chose à dire. Une bibliothèque se charge pour vous du handshake et du découpage en trames du protocole WebSocket. La plus connue est Ratchet, construite sur la boucle d’événements de 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();

Lancez-le avec php chat.php, et une page se connecte avec l’API WebSocket que possède chaque navigateur :

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

Ouvrez cette page dans deux onglets, servie depuis localhost, et chacun affiche ce que l’autre envoie. Le troisième argument de route() liste les hôtes dont les pages peuvent se connecter, car une page de n’importe quel autre site peut ouvrir un websocket vers votre serveur, et le standard vous laisse le soin de le refuser. [ '*' ] laisse entrer tous les sites.

Sous PHP 8.5, il tourne tel quel, après un écran entier d’avertissements de dépréciation : la dernière version de Ratchet, la 0.4.4, date de décembre 2021, et son README indique que le projet est en train d’être relancé. AMPHP a son propre serveur websocket pour PHP 8.1 et les versions suivantes, et l’extension Swoole ajoute un serveur à PHP lui-même. Chacun d’eux est un processus que vous gardez en marche, et c’est ce point qui compte dans la suite.

Une fois que le serveur tourne sur une adresse publique, notre test WebSocket s’y connecte depuis un navigateur et explique tout code de fermeture. Si le navigateur indique seulement que la connexion a échoué, notre article sur l’erreur WebSocket 1006 montre comment en trouver la cause.

Ce que change un processus PHP qui tourne en continu

Dans ce serveur, deux choses décident de tout ce qui suit. $clients vit dans la mémoire de ce seul processus, et ce processus tourne pendant des semaines. La plupart du code PHP n’est écrit ni pour l’un ni pour l’autre.

  • Un seul appel lent arrête tout le monde. La boucle d’événements exécute votre code un morceau à la fois. Pendant que onMessage() attend une requête PDO, un file_get_contents() sur une URL ou un sleep(), aucune autre connexion n’est servie. ReactPHP, sur lequel tourne Ratchet, est non bloquant par défaut et confie le travail bloquant à des workers. Les appels à la base de données que votre site fait partout demandent donc ici des clients conçus pour la boucle, ou une file d’attente.
  • La mémoire n’est jamais rendue. Sous PHP-FPM, tout ce qu’une requête a construit disparaît quand elle se termine, si bien qu’un cache statique ou un tableau qui ne fait que grossir ne fait aucun mal. Dans un processus qui tourne pendant des semaines, il grossit jusqu’à ce que quelque chose redémarre le processus.
  • Le nouveau code demande un redémarrage. Le script a chargé vos fichiers une seule fois, à son démarrage, si bien qu’un déploiement n’y change rien tant qu’il ne redémarre pas.
  • Votre site et le serveur sont deux programmes. La requête qui a enregistré une commande tourne dans PHP-FPM, et les navigateurs sont connectés au script websocket, dont cette requête ne peut pas atteindre la mémoire. Le guide de Ratchet lui-même pour envoyer des mises à jour depuis un site existant fait passer chacune par ZeroMQ, ce qui demande la bibliothèque libzmq et une extension PECL. Un canal Redis, ou une petite route HTTP dans le script websocket, fait le même travail.
  • Savoir qui se connecte. Un navigateur envoie votre cookie de session avec l’upgrade quand le websocket est sur votre propre domaine, mais le script doit lire cette session lui-même, et PHP garde par défaut les sessions dans des fichiers, sur un seul serveur. Le WebSocket du navigateur ne peut définir aucun en-tête, si bien que l’autre voie est un token de courte durée placé dans l’adresse, signé par votre site et vérifié avant l’ouverture de la connexion.

Ce qu’il faut pour de vrais utilisateurs

Le reste de la liste arrive avec les premiers vrais utilisateurs :

  • Un accès shell et un gestionnaire de processus. Le script doit être lancé et maintenu en vie, ce que le README de Ratchet pose comme condition. Les hébergements mutualisés le permettent rarement. Sur votre propre serveur, systemd ou Supervisor le relance quand il plante.
  • Un port, un certificat et un proxy. Les navigateurs se connectent en wss:// sur votre domaine, en général à travers nginx ou Apache placé devant. La documentation de nginx explique qu’un proxy ne transmet les en-têtes Upgrade et Connection que si on le lui demande, et qu’il ferme par défaut une connexion passant par lui sans aucune donnée pendant 60 secondes.
  • Un heartbeat. Le serveur envoie donc un ping à chaque connexion à intervalle régulier. Cela empêche les proxys de fermer une connexion silencieuse, et cela repère celles qui sont mortes sans prévenir, qui resteraient sinon dans $clients.
  • Plus d’un processus. Une boucle d’événements n’utilise qu’un seul cœur du processeur. Deux processus, ou deux serveurs, ne connaissent chacun que leurs propres connexions. Chaque événement doit donc traverser un canal qu’ils partagent, en général Redis. Le pub/sub de Redis distribue au plus une fois, si bien qu’un processus qui se reconnectait à ce moment-là ne reçoit jamais l’événement.
  • Déploiements. Un redémarrage coupe toutes les connexions. Le WebSocket du navigateur ne se reconnecte pas de lui-même, c’est donc le code de votre page qui s’en charge, après un délai qui s’allonge et qui diffère pour chaque navigateur. Ce qui a été envoyé pendant l’absence d’une page est perdu, à moins que vous ne gardiez les événements récents pour les rejouer à partir du dernier qu’elle a vu.

Rien de tout cela n’est inhabituel, et beaucoup d’équipes le font bien. Cela reste tout de même un second système à côté de votre application PHP, écrit dans un style dont le reste de votre code n’a jamais besoin.

Ou ne gardez aucun processus websocket

Un service temps réel hébergé retire les connexions de vos serveurs. Les navigateurs se connectent au service. Votre code PHP envoie chaque événement par une seule courte requête HTTPS, depuis la requête même qui a enregistré le changement, et le service le distribue à chaque page qui doit le recevoir. Rien dans votre application ne dure plus longtemps qu’une requête, si bien que PHP-FPM reste tel quel.

Mise en place Où vivent les connexions Ce que vous faites tourner
PHP-FPM seul Nulle part, chaque requête se termine Du polling, un worker par attente
Un script websocket Dans sa mémoire Un processus, un proxy et un canal depuis votre site
Un service hébergé Sur ses serveurs Une requête par événement

PHP sur WordPlus Cloud

Avec WordPlus Cloud, un seul paquet Composer constitue votre côté serveur, et il apporte aussi les fichiers du navigateur, si bien qu’il n’y a pas de Node à installer :

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

Votre application déclare ses salons une fois pour toutes, chacun avec une règle qui dit qui peut le rejoindre. Voici le salon d’une commande, pour son client :

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 ] );

Deux courtes routes servent les fichiers du navigateur et répondent aux pages qui demandent à rejoindre un salon, pour l’utilisateur de la 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;
}

Une fois votre propre travail enregistré, prévenez tout le monde dans le salon :

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

La page reçoit ses réglages de <?= $realtime->head( $userId ) ?> dans son <head>, avec une import map pour le client, si bien que ce fichier tourne tel quel, sans 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 ) );

Cet emit est une seule requête HTTPS, si bien qu’il tourne de la même façon dans une requête PHP-FPM, dans une tâche cron ou dans un worker de file d’attente. Au-delà :

  • Rien à garder en marche. Aucun script websocket, aucune règle de proxy et aucun canal entre votre site et un serveur. N’importe lequel de vos serveurs répond à n’importe quelle requête et envoie à n’importe quel salon.
  • Rien de perdu à la reconnexion. Un salon garde ses derniers événements, si bien qu’une page qui revient reçoit ce qu’elle a manqué, dans l’ordre.
  • Toutes les pages d’un même utilisateur. $realtime->toUser( 42 )->emit( 'notice', [ 'text' => 'Your order shipped' ] ) atteint chaque onglet et chaque appareil qu’il a ouverts. Un utilisateur qui n’a rien d’ouvert ne reçoit rien, alors envoyez un e-mail pour ce qui doit lui parvenir.
  • Une seule connexion pour tous les onglets. Les onglets d’un même navigateur partagent une seule connexion, si bien qu’une personne avec trois onglets ouverts ne compte qu’une fois.
  • Scellé en chemin. Ce que votre serveur envoie à un salon doté d’une règle voyage chiffré, avec des clés que seuls votre serveur et vos utilisateurs détiennent.
  • Ce que les pages envoient vous parvient. Un webhook l’apporte à votre PHP, signé et vérifié par le paquet avant que votre handler ne le voie, et renvoyé pendant 24 heures si votre serveur ne répond pas.
  • Plus que des événements. La liste des personnes en ligne, les appels qui sonnent dans chaque onglet, les appels de groupe et les diffusions en direct passent par la même connexion, avec un chat, un écran d’appel et un lecteur prêts à l’emploi, ou votre propre interface sur la même API.

Dans Symfony, Slim ou votre propre router, answerRequest() donne le statut et le corps de la réponse à la place de respond(). Laravel a son broadcasting, et notre article sur les websockets dans Laravel montre le même cloud derrière Echo.

Quand votre propre serveur convient mieux

Un service hébergé ne convient pas à tous les usages. Votre code PHP reçoit ce que les pages envoient par un webhook, une requête HTTP qui peut arriver plus d’une fois, et non par une boucle à côté de chaque connexion. Un jeu ou un système de contrôle où le serveur doit répondre à chaque message en quelques millisecondes a sa place sur son propre serveur. Il en va de même d’un protocole à vous, que d’autres programmes parlent sur un simple websocket. Et un outil pour quelques dizaines de personnes, sur un serveur que vous faites déjà tourner, n’aura peut-être jamais besoin de plus que le script Ratchet du début de cet article.

Commencez par le guide

Le guide PHP détaille toute la mise en place, et la démo PHP est une petite boutique en PHP pur construite dessus, où une commande passe à « expédiée » dans une autre fenêtre au moment où vous cliquez. La même question a d’autres réponses en Node.js, où un seul processus tient bien les connexions, et dans Django et Flask.

WordPlus Cloud for Apps a un prix selon les connexions simultanées, à partir de 1 000, facturé au mois ou à l’année, et notre article sur les tarifs du temps réel explique comment fonctionne le décompte à la connexion. Découvrez ce qu’il apporte aux applications. Notre page sur l’API WebSocket montre les salles, la présence et les événements dans chaque stack, et les tarifs pour les applications donnent les chiffres. Des questions sur votre intégration ? Écrivez-nous.