Blog

Websockety w PHP bez własnego procesu

· Andrij Tkachenko · 10 min czytania

Pięć krótkich kart żądań, każda zamknięta znakiem zaznaczenia, obok jednego serwera, którego jedna linia rozgałęzia się do trzech okien przeglądarki

PHP potrafi obsługiwać websockety, ale nie w żądaniach, które odpowiadają na Twoje strony: PHP-FPM daje każdemu żądaniu workera, dopóki nie zostanie wysłana odpowiedź, a websocket to połączenie, które pozostaje otwarte godzinami. Dlatego websocket w PHP działa we własnym skrypcie, uruchamianym z wiersza poleceń i stale działającym, z event loopem, który obserwuje wszystkie połączenia naraz, a Twoja witryna musi przekazywać temu skryptowi każde zdarzenie do wysłania.

Ten wpis pokazuje taki serwer z Ratchetem, wyjaśnia, dlaczego nie może on żyć wewnątrz Twojej witryny i czego wymaga jego utrzymanie dla prawdziwych użytkowników, a na koniec pokazuje, jak wysyłać zdarzenia na żywo z czystego PHP w ogóle bez procesu websocket.

Dlaczego żądanie PHP nie utrzyma websocketu

Websocket to dwukierunkowe połączenie między przeglądarką a serwerem, które pozostaje otwarte, więc każda ze stron może wysyłać w dowolnej chwili. Zaczyna się jako żądanie HTTP, które prosi o upgrade, i od tej chwili nie jest już żądaniem z odpowiedzią, ale linią, która pozostaje otwarta tak długo, jak strona.

PHP zbudowano odwrotnie. Pod PHP-FPM serwer WWW przekazuje każde żądanie jednemu workerowi z puli. Worker uruchamia Twój skrypt, wysyła odpowiedź i bierze kolejne żądanie. Pula ma stały rozmiar, a podręcznik PHP podaje, że pm.max_children ustala limit żądań obsługiwanych naraz. Websocket utrzymywany w żądaniu zajmowałby swojego workera tak długo, jak jego strona pozostaje otwarta. Przy 20 workerach 20 otwartych stron zajęłoby je wszystkie i witryna przestałaby odpowiadać wszystkim pozostałym.

Serwery przed PHP widzą to tak samo. nginx domyślnie zamyka połączenie z PHP-FPM, gdy PHP nic nie wysyła przez 60 sekund, a firmy hostingowe ustawiają własne limity tego, jak długo może trwać żądanie.

Long polling i server-sent events wyglądają na obejście, ale w PHP trafiają na ten sam mur: każde czekające żądanie zajmuje workera. Właśnie na to trafia WordPress, jak wyjaśnia nasz wpis o WordPress i websocketach, i tak samo każda aplikacja PHP, z frameworkiem czy bez.

Serwer websocket w PHP

Odpowiedzią w PHP jest drugi program: skrypt, który uruchamiasz przez php z wiersza poleceń i który nigdy się nie kończy. Nasłuchuje na porcie i uruchamia event loop, który czeka naraz na wszystkich otwartych połączeniach i budzi się dla tego, które ma coś do powiedzenia. Handshake i ramkowanie protokołu WebSocket załatwia za Ciebie biblioteka. Najbardziej znana to Ratchet, zbudowany na event loopie 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();

Uruchom go przez php chat.php, a strona połączy się przez WebSocket API, które ma każda przeglądarka:

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

Otwórz tę stronę, serwowaną z localhost, w dwóch kartach, a każda wypisze to, co wysyła druga. Trzeci argument route() wymienia hosty, których strony mogą się łączyć, bo strona w dowolnej innej witrynie może otworzyć websocket do Twojego serwera, a standard zostawia odmowę Tobie. [ '*' ] wpuszcza każdą witrynę.

Na PHP 8.5 działa to bez zmian, po całym ekranie komunikatów o przestarzałym kodzie: ostatnie wydanie Ratcheta, 0.4.4, ukazało się w grudniu 2021, a jego README podaje, że projekt jest reaktywowany. AMPHP ma własny serwer websocket dla PHP 8.1 i nowszych, a rozszerzenie Swoole dodaje serwer do samego PHP. Każdy z nich to proces, który musisz utrzymywać w działaniu, i właśnie to liczy się w dalszej części.

Gdy serwer działa już pod publicznym adresem, nasz Test WebSocket połączy się z nim z przeglądarki i wyjaśni każdy kod zamknięcia. Jeśli przeglądarka zgłasza tylko, że połączenie się nie powiodło, nasz artykuł o błędzie WebSocket 1006 pokazuje, jak znaleźć przyczynę.

Co zmienia długo działający proces PHP

Dwie rzeczy w tym serwerze przesądzają o wszystkim, co dalej. $clients żyje w pamięci tego jednego procesu, a sam proces działa tygodniami. Większość kodu PHP nie jest pisana ani pod jedno, ani pod drugie.

  • Jedno wolne wywołanie zatrzymuje wszystkich. Event loop wykonuje Twój kod po kawałku. Gdy onMessage() czeka na zapytanie PDO, file_get_contents() z adresu URL albo sleep(), żadne inne połączenie nie jest obsługiwane. ReactPHP, na którym działa Ratchet, jest domyślnie nieblokujący, a blokującą pracę przekazuje workerom. Wywołania bazy danych, które Twoja witryna wykonuje wszędzie, potrzebują więc tutaj klientów zbudowanych pod event loop albo kolejki.
  • Pamięć nigdy nie wraca. Pod PHP-FPM wszystko, co zbudowało żądanie, znika, gdy ono się kończy, więc statyczny cache albo tablica, która tylko rośnie, nie szkodzi. W procesie, który działa tygodniami, rośnie, dopóki coś go nie zrestartuje.
  • Nowy kod wymaga restartu. Skrypt wczytał Twoje pliki raz, przy starcie, więc deploy nic w nim nie zmienia, dopóki skrypt nie uruchomi się od nowa.
  • Twoja witryna i serwer to dwa programy. Żądanie, które zapisało zamówienie, działa w PHP-FPM, a przeglądarki są połączone ze skryptem websocket, do którego pamięci to żądanie nie sięga. Własny przewodnik Ratcheta o wysyłaniu aktualizacji z istniejącej witryny przekazuje każdą z nich przez ZeroMQ, który wymaga biblioteki libzmq i rozszerzenia PECL. Kanał Redis albo mała trasa HTTP w skrypcie websocket robi to samo.
  • Rozpoznanie, kto się łączy. Przeglądarka wysyła plik cookie Twojej sesji razem z żądaniem upgrade, gdy websocket jest w Twojej własnej domenie, ale skrypt musi sam odczytać tę sesję, a PHP domyślnie przechowuje sesje w plikach na jednym serwerze. WebSocket w przeglądarce nie może ustawić nagłówka, więc drugim sposobem jest krótkotrwały token w adresie, podpisany przez Twoją witrynę i sprawdzany, zanim połączenie się otworzy.

Czego wymaga utrzymanie go dla prawdziwych użytkowników

Reszta listy pojawia się razem z pierwszymi prawdziwymi użytkownikami:

  • Dostęp do powłoki i menedżer procesów. Skrypt trzeba uruchomić i utrzymywać przy życiu, co README Ratcheta podaje jako wymaganie. Hosting współdzielony rzadko na to pozwala. Na własnym serwerze systemd albo Supervisor uruchamia go ponownie, gdy padnie.
  • Port, certyfikat i proxy. Przeglądarki łączą się przez wss:// w Twojej domenie, zwykle przez stojący przed skryptem nginx albo Apache. Dokumentacja nginx wyjaśnia, że proxy przekazuje dalej nagłówki Upgrade i Connection tylko wtedy, gdy mu się to każe, i że połączenie przez proxy, w którym przez 60 sekund nie ma danych, jest domyślnie zamykane.
  • Heartbeat. Serwer wysyła więc ping do każdego połączenia w stałych odstępach. Dzięki temu proxy nie zamykają cichych połączeń, a serwer znajduje te, które umarły bez słowa i które w przeciwnym razie zostają w $clients.
  • Więcej niż jeden proces. Jeden event loop korzysta z jednego rdzenia procesora. Dwa procesy albo dwa serwery znają każdy tylko własne połączenia, więc każde zdarzenie musi przejść przez wspólny dla nich kanał, zwykle Redis. Redis pub/sub dostarcza najwyżej raz, więc proces, który akurat w tej chwili łączył się ponownie, nigdy nie dostanie zdarzenia.
  • Deploye. Restart zrywa każde połączenie. WebSocket w przeglądarce sam nie łączy się ponownie, więc robi to kod Twojej strony, po opóźnieniu, które rośnie i jest inne dla każdej przeglądarki. To, co wysłano, gdy strona była rozłączona, przepada, chyba że przechowujesz ostatnie zdarzenia i odtwarzasz je od ostatniego, które widziała.

Nic z tego nie jest niezwykłe i wiele zespołów robi to dobrze. Mimo to jest to drugi system obok Twojej aplikacji PHP, pisany w stylu, którego reszta Twojego kodu nigdy nie potrzebuje.

Albo w ogóle nie utrzymuj procesu websocket

Hostowana usługa czasu rzeczywistego przejmuje połączenia od Twoich serwerów. Przeglądarki łączą się z usługą. Twój kod PHP wysyła każde zdarzenie jednym krótkim żądaniem HTTPS, z tego samego żądania, które zapisało zmianę, a usługa dostarcza je każdej stronie, która powinna je dostać. Nic w Twojej aplikacji nie działa dłużej niż żądanie, więc PHP-FPM zostaje bez zmian.

Konfiguracja Gdzie żyją połączenia Co uruchamiasz
Samo PHP-FPM Nigdzie, każde żądanie się kończy Polling, worker na każde czekanie
Skrypt websocket W jego pamięci Proces, proxy i kanał z witryny
Hostowana usługa Na jej serwerach Jedno żądanie na każde zdarzenie

PHP w WordPlus Cloud

Z WordPlus Cloud jeden pakiet Composera to cała Twoja strona serwerowa, a zawiera też pliki dla przeglądarki, więc nie musisz instalować Node:

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

Twoja aplikacja raz deklaruje swoje pokoje, każdy z regułą określającą, kto może do niego dołączyć. To pokój zamówienia, dla jego klienta:

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

Dwie krótkie trasy serwują pliki dla przeglądarki i odpowiadają stronom, które proszą o dołączenie, w imieniu użytkownika z sesji:

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;
}

Po zapisaniu własnych zmian powiadom wszystkich w pokoju:

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

Strona dostaje swoje ustawienia z <?= $realtime->head( $userId ) ?> w swoim <head>, razem z import mapą dla klienta, więc ten plik działa w takiej postaci, w jakiej jest, bez bundlera:

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

To emit to jedno żądanie HTTPS, więc działa tak samo w żądaniu PHP-FPM, w zadaniu cron i w workerze kolejki. A do tego:

  • Nic do utrzymywania w działaniu. Żadnego skryptu websocket, żadnych reguł proxy i żadnego kanału między Twoją witryną a serwerem. Dowolny z Twoich serwerów odpowiada na dowolne żądanie i wysyła do dowolnego pokoju.
  • Nic nie ginie przy ponownym połączeniu. Pokój przechowuje swoje ostatnie zdarzenia, więc strona, która wraca, dostaje to, co ją ominęło, w odpowiedniej kolejności.
  • Każda strona jednego użytkownika. $realtime->toUser( 42 )->emit( 'notice', [ 'text' => 'Your order shipped' ] ) dociera do wszystkich kart i urządzeń, które ten użytkownik ma otwarte. Użytkownik, który nie ma nic otwartego, nie dostanie nic, więc to, co musi do niego dotrzeć, wyślij e-mailem.
  • Jedno połączenie dla wszystkich kart. Karty jednej przeglądarki dzielą jedno połączenie, więc osoba z trzema otwartymi kartami jest liczona tylko raz.
  • Zapieczętowane w drodze. To, co Twój serwer wysyła do pokoju z regułą, podróżuje zaszyfrowane kluczami, które mają tylko Twój serwer i Twoi użytkownicy.
  • To, co wysyłają strony, trafia do Ciebie. Webhook dostarcza to do Twojego PHP, podpisane i sprawdzone przez pakiet, zanim zobaczy to Twój handler, i ponawiane przez 24 godziny, jeśli Twój serwer nie odpowiada.
  • Więcej niż zdarzenia. Informacja, kto jest online, rozmowy, które dzwonią w każdej karcie, rozmowy grupowe i transmisje na żywo działają przez to samo połączenie, z gotowym czatem, ekranem rozmowy i odtwarzaczem albo z Twoim własnym interfejsem na tym samym API.

W Symfony, w Slim albo we własnym routerze answerRequest() zwraca status i treść odpowiedzi zamiast respond(). Laravel ma swój broadcasting, a nasz wpis o websocketach w Laravel pokazuje tę samą chmurę za Echo.

Kiedy własny serwer sprawdzi się lepiej

Hostowana usługa nie nadaje się do każdego zadania. Twój kod PHP dowiaduje się, co wysyłają strony, przez webhook, czyli żądanie HTTP, które może dotrzeć więcej niż raz, a nie w pętli obok każdego połączenia. Miejsce gry albo systemu sterowania, w którym serwer musi odpowiadać na każdą wiadomość w ciągu milisekund, jest na własnym serwerze. To samo dotyczy Twojego własnego protokołu, którym inne programy rozmawiają przez zwykły websocket. A narzędzie dla kilkudziesięciu osób, na serwerze, który już utrzymujesz, może nigdy nie potrzebować niczego więcej niż skrypt z Ratchetem z początku tego wpisu.

Zacznij od przewodnika

Przewodnik dla PHP zawiera całą konfigurację, a demo PHP to mały sklep w czystym PHP zbudowany na niej, w którym status zamówienia zmienia się na „wysłane” w drugim oknie w chwili, gdy klikasz. To samo pytanie ma inne odpowiedzi w Node.js, gdzie jeden proces dobrze utrzymuje połączenia, oraz w Django i Flasku.

WordPlus Cloud for Apps ma cenę według jednoczesnych połączeń, od 1000 wzwyż, rozliczaną miesięcznie lub rocznie, a nasz wpis o cenach usług czasu rzeczywistego wyjaśnia, jak działa liczenie według połączeń. Zobacz, co daje aplikacjom, nasza strona o API WebSocket pokazuje pokoje, obecność i zdarzenia w każdym stacku, a cennik dla aplikacji podaje liczby. Chcesz zapytać o swoją integrację? Napisz do nas.