Blog

WebSockets in PHP, ohne einen eigenen Prozess zu betreiben

· Andrij Tkachenko · 10 Min. Lesezeit

Fünf kurze Anfragekarten, jede mit einem Häkchen abgeschlossen, neben einem einzigen Server, dessen Linie sich zu drei Browserfenstern verzweigt

PHP kann WebSockets bedienen, aber nicht aus den Anfragen, die Ihre Seiten beantworten: PHP-FPM gibt jeder Anfrage einen Worker, bis ihre Antwort gesendet ist, und ein WebSocket ist eine Verbindung, die stundenlang offen bleibt. Ein WebSocket in PHP läuft deshalb in einem eigenen Skript, das von der Kommandozeile gestartet wird und weiterläuft, mit einem Event Loop, der alle Verbindungen gleichzeitig im Blick behält, und Ihre Website muss diesem Skript jedes Event übergeben, das es senden soll.

Dieser Beitrag zeigt einen solchen Server mit Ratchet, warum er nicht in Ihrer Website leben kann, was sein Betrieb für echte Nutzer verlangt und wie Sie aus reinem PHP Live-Events senden, ganz ohne WebSocket-Prozess.

Warum eine PHP-Anfrage keinen WebSocket halten kann

Ein WebSocket ist eine Verbindung in beide Richtungen zwischen einem Browser und einem Server, die offen bleibt, sodass jede Seite jederzeit senden kann. Er beginnt als HTTP-Anfrage, die um ein Upgrade bittet, und ist von da an keine Anfrage mit einer Antwort mehr, sondern eine Leitung, die so lange offen bleibt wie die Seite.

PHP ist andersherum gebaut. Unter PHP-FPM gibt der Webserver jede Anfrage an einen Worker aus einem Pool. Der Worker führt Ihr Skript aus, sendet die Antwort und nimmt die nächste Anfrage. Der Pool hat eine feste Größe, und das PHP-Handbuch sagt, dass pm.max_children festlegt, wie viele Anfragen höchstens gleichzeitig bedient werden. Ein WebSocket, der in einer Anfrage gehalten wird, würde seinen Worker beschäftigt halten, solange seine Seite offen bleibt. Bei 20 Workern würden 20 offene Seiten alle belegen, und die Website würde allen anderen nicht mehr antworten.

Die Server vor PHP sehen es genauso. nginx schließt die Verbindung zu PHP-FPM standardmäßig, wenn PHP 60 Sekunden lang nichts sendet, und Hosts setzen eigene Grenzen dafür, wie lange eine Anfrage laufen darf.

Long Polling und Server-Sent Events sehen nach einem Ausweg aus, und in PHP stoßen sie an dieselbe Wand: Jede wartende Anfrage belegt einen Worker. WordPress stößt genau daran, wie unser Beitrag zu WordPress und WebSockets erklärt, und jede PHP-App ebenso, mit Framework oder ohne.

Ein WebSocket-Server in PHP

Die Antwort in PHP ist ein zweites Programm: ein Skript, das Sie mit php von der Kommandozeile starten und das nie endet. Es lauscht auf einem Port und betreibt einen Event Loop, der auf alle offenen Verbindungen gleichzeitig wartet und für die eine aufwacht, die etwas zu sagen hat. Eine Bibliothek übernimmt für Sie den Handshake und das Framing des WebSocket-Protokolls. Die bekannteste ist Ratchet, gebaut auf dem Event Loop von 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();

Starten Sie es mit php chat.php, und eine Seite verbindet sich über die WebSocket-API, die jeder Browser hat:

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

Öffnen Sie diese Seite in zwei Tabs, ausgeliefert von localhost, und jeder gibt aus, was der andere sendet. Das dritte Argument von route() nennt die Hosts, deren Seiten sich verbinden dürfen, denn eine Seite auf jeder anderen Website kann einen WebSocket zu Ihrem Server öffnen, und der Standard überlässt es Ihnen, sie abzulehnen. [ '*' ] lässt jede Website herein.

Auf PHP 8.5 läuft das so, wie es ist, nach einer ganzen Bildschirmseite an Deprecation-Hinweisen: Das letzte Release von Ratchet, 0.4.4, erschien im Dezember 2021, und seine README sagt, dass das Projekt wiederbelebt wird. AMPHP hat einen eigenen WebSocket-Server für PHP 8.1 und neuer, und die Erweiterung Swoole fügt PHP selbst einen Server hinzu. Jeder davon ist ein Prozess, den Sie am Laufen halten, und genau darauf kommt es im Folgenden an.

Läuft der Server auf einer öffentlichen Adresse, verbindet sich unser WebSocket-Test aus einem Browser damit und erklärt jeden Close-Code. Meldet ein Browser nur, dass die Verbindung fehlgeschlagen ist, zeigt unser Beitrag zum WebSocket-Fehler 1006, wie Sie die Ursache finden.

Was ein dauerhaft laufender PHP-Prozess ändert

Zwei Dinge in diesem Server bestimmen alles, was folgt. $clients lebt im Speicher dieses einen Prozesses, und der Prozess läuft wochenlang weiter. Der meiste PHP-Code ist für keins von beiden geschrieben.

  • Ein langsamer Aufruf hält alle auf. Der Event Loop führt Ihren Code Stück für Stück aus. Während onMessage() auf eine PDO-Abfrage, ein file_get_contents() einer URL oder ein sleep() wartet, wird keine andere Verbindung bedient. ReactPHP, auf dem Ratchet läuft, ist standardmäßig nicht blockierend und gibt blockierende Arbeit an Worker ab. Die Datenbankaufrufe, die Ihre Website überall macht, brauchen hier also Clients, die für den Loop gebaut sind, oder eine Queue.
  • Speicher wird nie zurückgegeben. Unter PHP-FPM ist alles, was eine Anfrage aufgebaut hat, mit ihrem Ende verschwunden, sodass ein statischer Cache oder ein Array, das nur wächst, keinen Schaden anrichtet. In einem Prozess, der wochenlang läuft, wächst es, bis etwas ihn neu startet.
  • Neuer Code braucht einen Neustart. Das Skript hat Ihre Dateien einmal geladen, beim Start, sodass ein Deploy darin nichts ändert, bis es neu startet.
  • Ihre Website und der Server sind zwei Programme. Die Anfrage, die eine Bestellung gespeichert hat, läuft in PHP-FPM, und die Browser sind mit dem WebSocket-Skript verbunden, an dessen Speicher diese Anfrage nicht herankommt. Ratchets eigene Anleitung zum Senden von Updates aus einer bestehenden Website reicht jedes davon über ZeroMQ weiter, was die Bibliothek libzmq und eine PECL-Erweiterung voraussetzt. Ein Redis-Kanal oder eine kleine HTTP-Route im WebSocket-Skript erledigt dieselbe Aufgabe.
  • Wissen, wer sich verbindet. Ein Browser sendet Ihr Session-Cookie mit dem Upgrade, wenn der WebSocket auf Ihrer eigenen Domain liegt, aber das Skript muss diese Session selbst lesen, und PHP speichert Sessions standardmäßig in Dateien auf einem einzigen Server. Der WebSocket eines Browsers kann keinen Header setzen, also ist der andere Weg ein kurzlebiges Token in der Adresse, von Ihrer Website signiert und geprüft, bevor die Verbindung steht.

Was der Betrieb für echte Nutzer verlangt

Der Rest der Liste kommt mit den ersten echten Nutzern:

  • Shell-Zugang und ein Prozessmanager. Das Skript muss gestartet und am Leben gehalten werden, was die README von Ratchet als Voraussetzung nennt. Shared Hosting erlaubt das selten. Auf einem eigenen Server startet systemd oder Supervisor es nach einem Absturz neu.
  • Ein Port, ein Zertifikat und ein Proxy. Browser verbinden sich über wss:// auf Ihrer Domain, meist über nginx oder Apache davor. Die nginx-Dokumentation erklärt, dass ein Proxy die Header Upgrade und Connection nur weiterreicht, wenn man es ihm sagt, und dass er eine Verbindung über den Proxy, auf der 60 Sekunden lang keine Daten fließen, standardmäßig schließt.
  • Ein Heartbeat. Deshalb sendet der Server in festen Abständen einen Ping an jede Verbindung. Das hält Proxys davon ab, eine stille Verbindung zu schließen, und es findet die Verbindungen, die abgebrochen sind, ohne sich abzumelden, und die sonst in $clients bleiben.
  • Mehr als ein Prozess. Ein Event Loop nutzt einen Kern der CPU. Zwei Prozesse oder zwei Server kennen jeweils nur ihre eigenen Verbindungen, also muss jedes Event durch einen Kanal laufen, den sie sich teilen, meist Redis. Redis Pub/Sub stellt höchstens einmal zu, sodass ein Prozess, der sich in diesem Moment gerade neu verbindet, das Event nie bekommt.
  • Deploys. Ein Neustart trennt jede Verbindung. Der WebSocket eines Browsers verbindet sich nicht von selbst neu, also tut es der Code Ihrer Seite, nach einer Wartezeit, die wächst und für jeden Browser anders ist. Was gesendet wurde, während eine Seite weg war, ist verloren, es sei denn, Sie heben die letzten Events auf und spielen sie ab dem letzten, das die Seite gesehen hat, erneut ab.

Nichts davon ist ungewöhnlich, und viele Teams machen das gut. Trotzdem ist es ein zweites System neben Ihrer PHP-App, geschrieben in einem Stil, den der Rest Ihres Codes nie braucht.

Oder Sie betreiben gar keinen WebSocket-Prozess

Ein gehosteter Echtzeit-Dienst nimmt Ihren Servern die Verbindungen ab. Die Browser verbinden sich mit dem Dienst. Ihr PHP-Code sendet jedes Event in einer kurzen HTTPS-Anfrage, direkt aus der Anfrage, die die Änderung gespeichert hat, und der Dienst stellt es jeder Seite zu, die es bekommen soll. Nichts in Ihrer App läuft länger als eine Anfrage, also bleibt PHP-FPM, wie es ist.

Aufbau Wo die Verbindungen leben Was Sie brauchen
Nur PHP-FPM Nirgends, jede Anfrage endet Polling, einen Worker pro wartender Anfrage
Ein WebSocket-Skript In seinem Speicher Einen Prozess, einen Proxy und einen Kanal von Ihrer Website
Ein gehosteter Dienst Auf seinen Servern Eine Anfrage für jedes Event

PHP auf WordPlus Cloud

Mit WordPlus Cloud ist ein einziges Composer-Paket Ihre Serverseite, und es bringt auch die Browserdateien mit, sodass Sie kein Node installieren müssen:

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

Ihre App legt ihre Räume einmal fest, jeweils mit einer Regel dafür, wer beitreten darf. Das hier ist der Raum einer Bestellung, für ihren Kunden:

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

Zwei kurze Routen liefern die Browserdateien aus und antworten den Seiten, die beitreten wollen, für den Nutzer der 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;
}

Sobald Ihre eigene Arbeit gespeichert ist, sagen Sie es allen im Raum:

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

Die Seite bekommt ihre Einstellungen von <?= $realtime->head( $userId ) ?> in ihrem <head>, mit einer Import Map für den Client, sodass diese Datei läuft, wie sie ist, ohne 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 ) );

Dieses emit ist eine HTTPS-Anfrage, also läuft es in einer PHP-FPM-Anfrage genauso wie in einem Cronjob oder einem Queue-Worker. Darüber hinaus:

  • Nichts, was Sie am Laufen halten müssen. Kein WebSocket-Skript, keine Proxy-Regeln und kein Kanal zwischen Ihrer Website und einem Server. Jeder Ihrer Server beantwortet jede Anfrage und sendet an jeden Raum.
  • Nichts geht bei einer Neuverbindung verloren. Ein Raum bewahrt seine letzten Events auf, sodass eine Seite, die zurückkommt, bekommt, was sie verpasst hat, in der richtigen Reihenfolge.
  • Jede Seite eines Nutzers. $realtime->toUser( 42 )->emit( 'notice', [ 'text' => 'Your order shipped' ] ) erreicht alle Tabs und Geräte, die dieser Nutzer offen hat. Ein Nutzer, der nichts offen hat, bekommt nichts, also senden Sie für das, was ihn unbedingt erreichen muss, eine E-Mail.
  • Eine Verbindung für alle Tabs. Die Tabs eines Browsers teilen sich eine Verbindung, sodass eine Person mit drei offenen Tabs einmal zählt.
  • Unterwegs versiegelt. Was Ihr Server an einen Raum mit einer Regel sendet, wird verschlüsselt übertragen, mit Schlüsseln, die nur Ihr Server und Ihre Nutzer haben.
  • Was Seiten senden, kommt bei Ihnen an. Ein Webhook bringt es zu Ihrem PHP, signiert und vom Paket geprüft, bevor Ihr Handler es sieht, und wird 24 Stunden lang erneut versucht, wenn Ihr Server nicht antwortet.
  • Mehr als Events. Online-Status, Anrufe, die in jedem Tab klingeln, Gruppenanrufe und Livestreams laufen über dieselbe Verbindung, mit fertigem Chat, Anrufbildschirm und Player oder mit Ihrer eigenen Oberfläche auf derselben API.

In Symfony, Slim oder einem eigenen Router liefert answerRequest() anstelle von respond() den Status und den Body, mit denen Sie antworten. Laravel hat sein Broadcasting, und unser Beitrag zu WebSockets in Laravel zeigt dieselbe Cloud hinter Echo.

Wann ein eigener Server besser passt

Ein gehosteter Dienst passt nicht für jede Aufgabe. Ihr PHP-Code erfährt über einen Webhook, was Seiten senden, also über eine HTTP-Anfrage, die mehr als einmal ankommen kann, und nicht in einer Schleife neben jeder Verbindung. Ein Spiel oder ein Steuerungssystem, bei dem der Server jede Nachricht innerhalb von Millisekunden beantworten muss, gehört auf einen eigenen Server. Dasselbe gilt für ein eigenes Protokoll, das andere Programme über einen einfachen WebSocket sprechen. Und ein Tool für ein paar Dutzend Personen, auf einem Server, den Sie ohnehin betreiben, braucht vielleicht nie mehr als das Ratchet-Skript am Anfang dieses Beitrags.

Beginnen Sie mit der Anleitung

Die PHP-Anleitung enthält die ganze Einrichtung, und die PHP-Demo ist ein kleiner Shop in reinem PHP, der darauf aufbaut und in dem eine Bestellung in einem anderen Fenster auf „versendet“ wechselt, während Sie klicken. Dieselbe Frage hat andere Antworten in Node.js, wo ein Prozess Verbindungen gut hält, und in Django und Flask.

Für WordPlus Cloud for Apps gelten Preise nach gleichzeitigen Verbindungen, ab 1.000, monatlich oder jährlich abgerechnet, und unser Beitrag zu Echtzeit-Preisen erklärt, wie das Zählen nach Verbindungen funktioniert. Sehen Sie, was sie für Apps leistet. Unsere Seite zur WebSocket-API zeigt Räume, Präsenz und Ereignisse in jedem Stack, und die Preise für Apps nennen die Beträge. Fragen zu Ihrer Integration? Schreiben Sie uns.