Hochleistungs-PHP-Anwendungen mit Swoole in ServBay entwickeln

ServBay ist eine speziell für Entwickler konzipierte lokale Webentwicklungsumgebung, die zahlreiche Programmiersprachen, Datenbanken und Tools vorinstalliert bietet, um Arbeitsabläufe auf dem lokalen Rechner zu vereinfachen. In diesem Artikel erfahren Sie, wie Sie mithilfe der Swoole-Erweiterung im ServBay-Umfeld Ihre PHP-Anwendungen optimieren und leistungsstarke Netzwerkdienste aufbauen.

Was ist Swoole?

Swoole ist eine für PHP entwickelte, auf Koroutinen (Coroutines) basierende Engine für parallele, hochperformante Netzwerkkommunikation. Die Erweiterung ist in reinem C geschrieben und rüstet PHP mit asynchronen, parallelen und Coroutine-basierten Netzwerkfähigkeiten aus. Mit Swoole können PHP-Entwickler die Limitierungen traditioneller Webserver (wie Apache/Nginx + PHP-FPM) und des klassischen Request-Response-Modells überwinden, um Aufgaben effizienter zu bearbeiten – z. B. beim Erstellen speicherresidenter Webserver, asynchroner Aufgabenverarbeitung oder Echtzeitkommunikationsdiensten (wie WebSocket).

Wesentliche Merkmale von Swoole:

• Hochleistung: Implementierung in C, mit Unterstützung für asynchrone I/O, Multi-Prozess und Multi-Threading.
• Koroutinen: Swoole stellt leichte Koroutinen zur Verfügung, mit denen sich asynchrone Logik elegant synchron abbilden lässt – das vereinfacht das Programmiermodell erheblich.
• Vielfältige Protokollunterstützung: Unterstützt nativ verschiedene Netzwerkprotokolle wie TCP/UDP/HTTP/WebSocket.
• Einfache Nutzung: Klar strukturierte, PHP-typische API.
• Speicherresident: Anwendungen können als langlaufende Prozesse betrieben werden, wodurch initiale PHP-Umgebungskosten pro Request entfallen.

Mit Swoole wird PHP zur flexiblen Hochleistungs-Plattform und ist nicht mehr nur eine Scriptsprache für die Webentwicklung, sondern auch in anderen Netzwerkumgebungen bestens einsetzbar.

Swoole in ServBay aktivieren

Ein Ziel bei der Entwicklung von ServBay ist es, Entwicklern die Verwaltung und Nutzung verschiedenster PHP-Erweiterungen so einfach wie möglich zu machen. Swoole, als wichtige Erweiterung zur Hochleistungsentwicklung, ist in ServBay bereits vorinstalliert – Sie müssen sie nur aktivieren.

Voraussetzungen:

• ServBay ist installiert und läuft.
• Mindestens eine PHP-Version ist in ServBay installiert.

Aktivierungsschritte:

1. Öffnen Sie die ServBay-Oberfläche.
2. Navigieren Sie zum Bereich „Pakete (Packages)“ oder zu den PHP-Versionseinstellungen. (Hinweis: Je nach ServBay-Version kann die Bezeichnung leicht abweichen, meist finden Sie sie im Hauptmenü oder in den Einstellungen.)
3. Wählen Sie die PHP-Version aus, für die Sie Swoole aktivieren wollen.
4. Suchen und aktivieren Sie die Option für die Swoole-Erweiterung. ServBay zeigt die vorkompilierten Erweiterungen als Liste oder Schalter an.
5. Speichern Sie die Änderungen und starten Sie ServBay bzw. den jeweiligen PHP-Dienst neu. ServBay konfiguriert Ihr PHP-Setup automatisch und bindet Swoole ein.

Nach diesen Schritten können Sie Swoole in der gewählten PHP-Version direkt nutzen. Mit php -m in der Konsole prüfen Sie, ob swoole in der Liste der geladenen Erweiterungen erscheint.

TIP

Standardmäßig empfiehlt ServBay, Ihre Website- und Projektdateien im Verzeichnis /Applications/ServBay/www zu speichern. Das erleichtert die Verwaltung und Konfiguration innerhalb von ServBay. Auch in den Beispielen dieses Artikels nutzen wir diesen Pfad.

Erstellen eines einfachen Swoole-HTTP-Servers

Im nächsten Schritt erstellen wir einen grundlegenden Swoole-HTTP-Server und zeigen, wie Webanfragen darüber verarbeitet werden.

Schritt 1: Projektverzeichnis anlegen

Öffnen Sie Ihr Terminal, erstellen Sie ein neues Projektverzeichnis und wechseln Sie dorthin. Wir folgen der ServBay-Empfehlung und speichern es unter /Applications/ServBay/www:

cd /Applications/ServBay/www
mkdir servbay-swoole-http
cd servbay-swoole-http

Schritt 2: Serverskript erstellen

Erstellen Sie in servbay-swoole-http eine Datei namens server.php mit folgendem Inhalt:

<?php

use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;

// Swoole HTTP-Server-Instanz erstellen
// Lauscht auf allen Netzwerkschnittstellen (0.0.0.0) auf Port 9501
$server = new Server("0.0.0.0", 9501);

// 'start'-Event registrieren
// Wird beim erfolgreichen Serverstart ausgelöst
$server->on("start", function (Server $server) {
    echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
    // Hier lassen sich z.B. die IDs von Haupt- oder Management-Prozess ausgeben
});

// 'request'-Event registrieren
// Wird bei jedem HTTP-Request ausgelöst
$server->on("request", function (Request $request, Response $response) {
    // Antwort-Header setzen
    $response->header("Content-Type", "text/plain");

    // Logik je nach Pfad oder Parameter anpassen
    $path = $request->server['request_uri'] ?? '/';
    $content = "Hello ServBay!";

    if ($path === '/info') {
        $content = "Request path: " . $path . "\n";
        $content .= "Method: " . $request->server['request_method'] . "\n";
        $content .= "Client IP: " . $request->server['remote_addr'] . "\n";
        // Weitere Request-Infos können Sie über das $request-Objekt abrufen
    }

    // Antwort senden und Request abschließen
    $response->end($content);
});

// Server starten
$server->start();

Dieses Skript startet einen Swoole HTTP-Server am Port 9501. Bei Anfragen antwortet es mit einem einfachen Text „Hello ServBay!“. Bei Aufruf von /info gibt es zusätzliche Informationen zur Anfrage zurück.

Schritt 3: Swoole-Server starten

Stellen Sie sicher, dass Ihr Arbeitsverzeichnis servbay-swoole-http ist. Starten Sie das Skript mit Ihrer in ServBay aktivierten PHP-Version samt Swoole:

php server.php

Wenn alles korrekt läuft, sehen Sie in der Konsole folgende Ausgabe:

Swoole HTTP server is started at http://0.0.0.0:9501

Der Swoole HTTP-Server ist jetzt im Hintergrund aktiv und lauscht auf Port 9501.

Schritt 4: Server im Browser aufrufen

Öffnen Sie Ihren Webbrowser und rufen Sie die folgenden Adressen auf:

• http://localhost:9501
• http://localhost:9501/info

Sie sehen jeweils die Ausgabe „Hello ServBay!“ bzw. beim zweiten Link zusätzliche Informationen zur Anfrage.

Um den Server zu stoppen, wechseln Sie einfach ins Terminal, das das Skript ausführt, und drücken Sie Ctrl + C.

WebSocket-Verbindungen mit Swoole verarbeiten

Swoole bietet native Unterstützung für WebSocket-Protokolle – ideal für Echtzeitanwendungen wie Chats, Spieleserver oder Live-Datenübertragung.

Schritt 1: WebSocket-Serverskript erstellen

Erstellen Sie unter /Applications/ServBay/www/servbay-swoole-http (oder alternativ in einem neuen Verzeichnis, z.B. servbay-swoole-websocket) eine Datei namens websocket_server.php mit folgendem Inhalt:

<?php

use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;

// Swoole WebSocket-Server-Instanz erstellen
// Der WebSocket-Server erbt vom HTTP-Server, kann daher auch HTTP-Anfragen verarbeiten
$server = new Server("0.0.0.0", 9502); // Lauscht auf Port 9502

// 'start'-Event registrieren, wird beim Serverstart ausgelöst
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});

// 'open'-Event registrieren
// Wird bei Aufbau einer neuen WebSocket-Verbindung ausgelöst
// Das $request-Objekt enthält u.a. die Verbindungsdaten. $request->fd ist der Descriptor der Verbindung
$server->on("open", function (Server $server, Request $request) {
    echo "connection open: {$request->fd}\n";
    // Hier kann eine Willkommensnachricht an den Client gesendet werden
    $server->push($request->fd, "Welcome to ServBay WebSocket Demo!");
});

// 'message'-Event
// Wird ausgelöst, wenn eine WebSocket-Nachricht empfangen wird
// Das $frame-Objekt liefert z.B. $frame->data (Inhalt) und $frame->fd (Verbindung)
$server->on("message", function (Server $server, Frame $frame) {
    echo "received message from {$frame->fd}: {$frame->data}\n";
    // Nachricht antworten oder an alle Clients broadcasten
    // Beispiel: Antwort an den Sender
    $server->push($frame->fd, "Hello, you sent: {$frame->data}");

    // Broadcast-Beispiel (Verbindungsliste oder Durchlauf erforderlich)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // Nicht an den Absender selbst senden
    //         $server->push($fd, "User {$frame->fd} says: {$frame->data}");
    //     }
    // }
});

// 'close'-Event
// Wird ausgelöst, wenn die Verbindung eines Clients geschlossen wird
$server->on("close", function ($ser, $fd) {
    echo "connection close: {$fd}\n";
});

// Server starten
$server->start();

Dieses Skript startet einen WebSocket-Server am Port 9502 und definiert Callback-Funktionen für die wichtigsten Events: start (Serverstart), open (neue Verbindung), message (eingehende Nachricht), close (Verbindung getrennt). Im message-Event schickt der Server die eingegangene Nachricht mit einem Präfix zurück an den Absender.

Schritt 2: WebSocket-Server starten

Achten Sie darauf, dass sich Ihr Terminal im Verzeichnis mit websocket_server.php befindet. Starten Sie das Skript über ServBay mit aktivem Swoole:

php websocket_server.php

Wenn alles korrekt läuft, zeigt das Terminal diese Ausgabe:

Swoole WebSocket server is started at ws://0.0.0.0:9502

Der Swoole WebSocket-Server läuft jetzt im Hintergrund auf Port 9502.

Schritt 3: Verbindung zum WebSocket-Server herstellen

Sie haben verschiedene Möglichkeiten, um zu testen.

Methode A: Mit Browser-Entwicklertools

Die meisten modernen Browser bieten in den Entwicklertools (meist F12) einen „Netzwerk (Network)“- oder „Konsole (Console)“-Bereich zum Testen von WebSocket-Verbindungen.

1. Öffnen Sie eine beliebige Webseite (z. B. about:blank).

2. Öffnen Sie die Entwicklertools, wechseln Sie zum „Konsole (Console)“-Tab.

3. Geben Sie folgenden JavaScript-Code ein, um zu verbinden:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("WebSocket connection opened:", event);
     ws.send("Hello from Browser!"); // Nachricht senden nach Verbindungsaufbau
   };
   
   ws.onmessage = function(event) {
     console.log("Message from server:", event.data); // Antwort vom Server
   };
   
   ws.onerror = function(event) {
     console.error("WebSocket error:", event); // Fehler
   };
   
   ws.onclose = function(event) {
     console.log("WebSocket connection closed:", event); // Verbindung geschlossen
   };
   
   // Sie können jederzeit Nachrichten senden mit ws.send("Ihre Nachricht")
   // oder die Verbindung mit ws.close() beenden

4. Führen Sie diesen Code in der Konsole aus; beobachten Sie die Ausgaben sowohl im Browser als auch im Terminal, in dem das Serverskript läuft.

Methode B: Mit dem wscat-CLI-Tool

wscat ist ein praktischer WebSocket-Client für die Kommandozeile – vorausgesetzt, Node.js ist installiert.

1. wscat installieren: Falls Node.js/npm noch fehlt, installieren Sie diese zuerst. Dann installieren Sie wscat global:

   npm install -g wscat

2. Mit dem WebSocket-Server verbinden:

   wscat -c ws://localhost:9502

   Nach erfolgreicher Verbindung erhalten Sie ein Prompt >.

3. Nachricht senden: Geben Sie etwa ein:

   > Hello ServBay via wscat

   Der Server antwortet, die Ausgabe wird etwa so aussehen:

   < Hello, you sent: Hello ServBay via wscat

   Auch im Terminal mit dem laufenden Server können Sie die Interaktion verfolgen.

Verlassen Sie wscat mit Ctrl + C.

Hinweise und Tipps

• Portkonflikte: Stellen Sie sicher, dass die von den Swoole-Servern genutzten Ports (z. B. 9501, 9502) auf Ihrem System nicht durch andere Programme belegt sind. Sonst kann der Server nicht starten.
• PHP-Version: Kontrollieren Sie, dass Sie beim Start der Skripte auf die PHP-Version mit aktivierter Swoole-Erweiterung zugreifen. Mit php -v sehen Sie, welche Version aktuell verwendet wird. ServBay bietet meist ein CLI-Tool zum schnellen Umschalten.
• Erweiterungsstatus: Sollte der Server nicht starten, vergewissern Sie sich, dass Swoole für Ihre PHP-Version korrekt aktiviert wurde und ServBay bzw. der PHP-Dienst neu gestartet wurde.
• Prozessmanagement: Swoole-Server sind speicherresident. In Produktionsumgebungen sollten Sie Tools wie Supervisor, Systemd oder pm2 nutzen, um den Prozess zu überwachen und einen automatischen Neustart sicherzustellen. Im lokalen ServBay-Umfeld genügt meist die manuelle Ausführung im Terminal.

Fazit

Mit ServBay können Sie die Swoole-Erweiterung spielend leicht aktivieren und im lokalen Entwicklungsumfeld leistungsstarke PHP-Anwendungen testen – egal ob klassischer HTTP-Service oder moderne WebSocket-Echtzeitkommunikation. Die mächtigen Swoole-Funktionen, kombiniert mit dem Komfort von ServBay, eröffnen PHP-Entwicklern ganz neue Perspektiven für effiziente, skalierbare Anwendungen. Probieren Sie Swoole jetzt in ServBay aus!