WebSocket : créer des applications temps réel en PHP

Les WebSockets permettent une communication bidirectionnelle temps réel entre le serveur et le client, sans le polling coûteux des requêtes HTTP répétées. Pour des fonctionnalités comme le chat, les notifications en direct ou les tableaux de bord temps réel, websocket est la technologie idéale.

HTTP vs WebSocket : la différence fondamentale

HTTP est un protocole requête-réponse : le client demande, le serveur répond, la connexion se ferme. Pour simuler du temps réel avec HTTP, on poll le serveur toutes les secondes. C'est inefficace : 99% des requêtes de polling retournent "pas de nouvelles données".

websocket établit une connexion persistante bidirectionnelle : le serveur peut pousser des données au client à tout moment. Une seule connexion TCP suffit pour des milliers d'échanges.

Ratchet : WebSocket en PHP

Ratchet est la bibliothèque websocket PHP la plus populaire, basée sur ReactPHP :

composer require cboden/ratchet

use Ratchet\MessageComponentInterface;
use Ratchet\ConnectionInterface;

class ChatServer implements MessageComponentInterface {
    private SplObjectStorage $clients;

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

    public function onOpen(ConnectionInterface $conn): void {
        $this->clients->attach($conn);
        echo "Nouvelle connexion ({$conn->resourceId})
";
    }

    public function onMessage(ConnectionInterface $from, string $msg): void {
        $data = json_decode($msg, true);
        // Broadcaster à tous sauf l'émetteur
        foreach ($this->clients as $client) {
            if ($from !== $client) {
                $client->send(json_encode([
                    'user' => $data['user'],
                    'message' => htmlspecialchars($data['message']),
                    'time' => date('H:i')
                ]));
            }
        }
    }

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

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

Démarrer le serveur WebSocket

// server.php
use Ratchet\Server\IoServer;
use Ratchet\Http\HttpServer;
use Ratchet\WebSocket\WsServer;

$server = IoServer::factory(
    new HttpServer(new WsServer(new ChatServer())),
    8080
);
$server->run();

php server.php  # Démarrer le serveur
# En production : supervisor pour maintenir le processus

Client JavaScript

const ws = new WebSocket('wss://monsite.fr:8080');

ws.onopen = () => {
  console.log('Connecté au serveur WebSocket');
  ws.send(JSON.stringify({ type: 'join', room: 'general' }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  appendMessage(data.user, data.message, data.time);
};

ws.onclose = () => {
  setTimeout(() => reconnect(), 3000); // Reconnexion automatique
};

function sendMessage(text) {
  ws.send(JSON.stringify({ user: currentUser, message: text }));
}

Authentification WebSocket

Intégrez l'authentification JWT au handshake HTTP initial. Ratchet permet d'accéder aux headers et cookies de la requête d'upgrade :

public function onOpen(ConnectionInterface $conn): void {
    $token = $conn->httpRequest->getQueryParams()['token'] ?? '';
    if (!$this->verifyToken($token)) {
        $conn->close();
        return;
    }
    $this->clients[$conn->resourceId] = ['conn' => $conn, 'user' => $this->getUser($token)];
}

Nginx comme proxy WebSocket

En production, placez nginx devant Ratchet :

location /ws {
    proxy_pass http://127.0.0.1:8080;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
}

Pour des alternatives modernes, consultez Mercure (protocol SSE) ou Soketi (alternative open source à Pusher) qui simplifient considérablement l'implémentation websocket.

Conclusion

WebSocket est la technologie incontournable pour les applications PHP nécessitant du temps réel. Ratchet facilite l'implémentation d'un serveur WebSocket complet. Associé à Redis pour la gestion des rooms et à JWT pour l'authentification, vous disposez d'une infrastructure temps réel robuste et scalable.

Les WebSockets nécessitent une infrastructure adaptée en production. Déployez derrière un proxy Nginx avec les headers Upgrade correctement configurés. Pour la scalabilité horizontale, utilisez Redis Pub/Sub comme broker centralisé ou un service managé comme Ably. Socket.io ajoute une couche d'abstraction précieuse avec reconnexion automatique, rooms et fallback vers long-polling. Pour les cas simples de notifications ou live updates, les Server-Sent Events (SSE) sont souvent suffisants et plus faciles à déployer que les WebSockets. Consultez la spécification WebSocket RFC 6455 et les benchmarks disponibles pour choisir l'approche la plus adaptée à votre volumétrie et architecture.

Performance et optimisation

Limitez la fréquence des messages WebSocket avec du throttling côté serveur pour éviter de saturer les clients. Pour les données à haute fréquence (coordonnées de jeu, données de trading), envoyez uniquement les deltas (changements) plutôt que l'état complet. Compressez les messages avec l'extension permessage-deflate pour réduire la bande passante de 60 à 80% sur les payloads textuels répétitifs.