Hochleistungs-PHP-Anwendungen mit Swoole in ServBay erstellen

ServBay ist eine lokal installierte Web-Entwicklungsumgebung, die speziell für Entwickler konzipiert wurde. Sie enthält zahlreiche Programmiersprachen, Datenbanken und nützliche Tools, um lokale Entwicklungsabläufe deutlich zu vereinfachen. Dieser Artikel zeigt, wie Sie im ServBay-Umfeld mithilfe der Swoole-Erweiterung Ihre PHP-Anwendungen optimieren und performante Netzwerkdienste bereitstellen.

Was ist Swoole?

Swoole ist eine für PHP entwickelte, Coroutine-basierte, parallele und hochleistungsfähige Netzwerk-Engine. Komplett in C geschrieben, erweitert Swoole PHP um asynchrone, parallele und Coroutine-basierte Netzwerkkommunikation. Mit Swoole können PHP-Entwickler die Grenzen des klassischen Webserver-Modells (wie Apache/Nginx + PHP-FPM) überwinden und hochskalierende Aufgaben effizient ausführen – etwa den Bau von persistenten Webservern, asynchrone Aufgabenverarbeitung oder Echtzeitkommunikation (WebSocket).

Wichtige Vorteile von Swoole:

• Hochleistung: Dank C-Implementierung, asynchronem I/O, Multi-Prozess- und Multi-Thread-Unterstützung.
• Coroutinen: Bietet leichtgewichtige Coroutinen, sodass Sie mit synchronem Code asynchron programmieren und komplexe Ablaufmodelle vereinfachen können.
• Umfangreiche Protokollunterstützung: Nativ für TCP/UDP/HTTP/WebSocket und weitere Netzwerkprotokolle.
• Benutzerfreundlichkeit: Einfache und PHP-typische APIs für schnellen Einstieg.
• Dauerbetrieb: Anwendungen laufen als Daemon-Prozesse und vermeiden das wiederholte Initialisieren der PHP-Umgebung für jede Anfrage.

Mit Swoole avanciert PHP von einer klassischen Webscriptsprache zu einer vielseitigen Plattform für anspruchsvolle Netzwerkapplikationen.

Swoole in ServBay aktivieren

Ein Kernziel von ServBay ist, das Verwalten und Nutzen von PHP-Erweiterungen möglichst einfach zu machen. Swoole – eine Schlüsselkomponente für moderne PHP-Hochleistungsentwicklung – ist in ServBay bereits vorkompiliert enthalten. Die Aktivierung gelingt in wenigen Schritten.

Voraussetzungen:

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

Aktivierungsschritte:

1. Öffnen Sie das ServBay-Oberflächenprogramm.
2. Wechseln Sie zu „Pakete (Packages)“ oder zur PHP-Versionenverwaltung. (Je nach ServBay-Version unterscheiden sich die Menüpunkte; meist zu finden im Hauptfenster oder unter Einstellungen.)
3. Wählen Sie die PHP-Version, für die Swoole aktiviert werden soll.
4. Suchen Sie die Swoole-Erweiterung und schalten Sie sie ein. ServBay bietet die Extensions meist als Liste oder Schalter an.
5. Speichern Sie die Änderung und starten Sie ggf. ServBay oder den betroffenen PHP-Dienst neu. ServBay passt die Konfiguration automatisch an, damit Swoole geladen wird.

Nach erfolgreicher Aktivierung können Sie Swoole in Ihrer gewählten PHP-Version direkt nutzen. Prüfen Sie die geladene Erweiterung auch via Kommandozeile mit php -m – taucht swoole in der Liste auf, ist alles korrekt eingerichtet.

TIP

ServBay empfiehlt standardmäßig die Ablage Ihrer Webseiten und Projekte in folgenden Verzeichnissen, was die Verwaltung und Konfiguration erleichtert:

• macOS: /Applications/ServBay/www
• Windows: C:\ServBay\www

Die Beispiele in diesem Artikel verwenden ebenfalls diese Pfade.

Einen einfachen Swoole-HTTP-Server erstellen

Im folgenden Beispiel setzen wir einen simplen HTTP-Server mit Swoole auf, der HTTP-Anfragen verarbeitet.

Schritt 1: Projektverzeichnis anlegen

Öffnen Sie Ihr Terminal, erstellen Sie ein neues Projektverzeichnis und wechseln Sie hinein. Verwenden Sie den empfohlenen Pfad Ihres Betriebssystems:

macOS:

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

Windows:

cd C:\ServBay\www
mkdir servbay-swoole-http
cd servbay-swoole-http

Schritt 2: Serverskript schreiben

Erstellen Sie in Ihrem Projektordner servbay-swoole-http die Datei server.php. Ergänzen Sie darin folgenden PHP-Code:

<?php

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

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

// Callback für das 'start'-Event registrieren
// Ausgelöst wenn der Server erfolgreich startet
$server->on("start", function (Server $server) {
    echo "Swoole HTTP-Server läuft unter http://0.0.0.0:9501\n";
    // Hier können Hauptprozess-ID, Manager-ID etc. ausgegeben/geloggt werden
});

// Callback für das 'request'-Event registrieren
// Ausgelöst bei jedem HTTP-Request
$server->on("request", function (Request $request, Response $response) {
    // Response-Header setzen
    $response->header("Content-Type", "text/plain");

    // Logik basierend auf Anfrage-Pfad oder -Parametern
    $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 Anfrageinfos via $request abrufbar
    }

    // Antwort senden und Anfrage beenden
    $response->end($content);
});

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

Dieses Skript startet einen Swoole-HTTP-Server auf Port 9501 und liefert bei jeder Anfrage eine einfache Textnachricht „Hello ServBay!“. Bei Aufruf von /info werden detaillierte Request-Daten zurückgegeben.

Schritt 3: Swoole-Server starten

Stellen Sie sicher, dass Ihr Terminal im Verzeichnis servbay-swoole-http ist, und führen Sie das Skript mit der in ServBay aktivierten PHP-Version aus:

php server.php

Nach erfolgreichem Start sehen Sie im Terminal:

Swoole HTTP-Server läuft unter http://0.0.0.0:9501

Ihr Swoole-HTTP-Server ist nun im Hintergrund auf Port 9501 aktiv.

Schritt 4: Server im Browser ansprechen

Öffnen Sie einen Webbrowser und rufen Sie folgende Adressen auf:

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

Im Browser erscheint jeweils die Textausgabe „Hello ServBay!“ bzw. eine Übersicht der Request-Daten.

Um den Server zu stoppen, drücken Sie im Terminal, in dem das Skript läuft, einfach Ctrl + C.

WebSocket-Verbindungen mit Swoole verarbeiten

Swoole unterstützt das WebSocket-Protokoll nativ. Damit lassen sich beispielsweise Echtzeit-Chaträume, Game-Server oder Live-Daten-Push effizient umsetzen.

Schritt 1: WebSocket-Server-Skript schreiben

Legen Sie in Ihrem Projektverzeichnis (z. B. servbay-swoole-http oder einem neuen Ordner wie servbay-swoole-websocket) eine Datei namens websocket_server.php an und fügen Sie folgendes ein:

Projektverzeichnis-Pfade:

• macOS: /Applications/ServBay/www/servbay-swoole-http
• Windows: C:\ServBay\www\servbay-swoole-http

<?php

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

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

// 'start'-Event registrieren, ausgelöst falls Server startet
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket-Server läuft unter ws://0.0.0.0:9502\n";
});

// 'open'-Event
// Ausgelöst bei neuer WebSocket-Verbindung
// $request enthält Infos wie $request->fd (Client File Descriptor)
$server->on("open", function (Server $server, Request $request) {
    echo "Verbindung geöffnet: {$request->fd}\n";
    // Willkommensnachricht an den Client senden
    $server->push($request->fd, "Willkommen beim ServBay WebSocket Demo!");
});

// 'message'-Event
// Ausgelöst bei Empfang einer Nachricht vom Client
// $frame enthält u. a. $frame->data für Nachrichteninhalt, $frame->fd für den Client
$server->on("message", function (Server $server, Frame $frame) {
    echo "Nachricht erhalten von {$frame->fd}: {$frame->data}\n";
    // Nachricht an den Sender zurückschicken
    $server->push($frame->fd, "Hallo, deine Nachricht: {$frame->data}");

    // Beispiel für Broadcast (Verbindungsverwaltung oder Iteration nötig)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // Sender nicht erneut beschicken
    //         $server->push($fd, "Benutzer {$frame->fd} sagt: {$frame->data}");
    //     }
    // }
});

// 'close'-Event
// Ausgelöst wenn Verbindung vom Client geschlossen wird
$server->on("close", function ($ser, $fd) {
    echo "Verbindung geschlossen: {$fd}\n";
});

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

Das Skript startet einen WebSocket-Server auf Port 9502 mit Callbacks für die wichtigsten Events: start (Serverstart), open (neue Verbindung), message (Nachricht erhalten), close (Verbindung beendet). Im message-Callback sendet der Server die empfangene Nachricht mit Präfix zurück an den Absender.

Schritt 2: WebSocket-Server starten

Öffnen Sie ein Terminal im Verzeichnis der Datei websocket_server.php und führen Sie das Skript mit dem in ServBay aktivierten PHP aus:

php websocket_server.php

Bei erfolgreichem Start sehen Sie im Terminal:

Swoole WebSocket-Server läuft unter ws://0.0.0.0:9502

Ihr WebSocket-Server ist nun bereit und wartet auf Verbindungen am Port 9502.

Schritt 3: Verbindung zum WebSocket-Server herstellen

Es gibt mehrere Möglichkeiten, die Verbindung zum WebSocket-Server testweise herzustellen.

Methode A: Browser-Entwicklertools verwenden

Die meisten modernen Browser bieten im Entwicklerbereich (Tastenkürzel meist F12) einen „Netzwerk“- oder „Konsole“-Tab zum Testen von WebSocket-Verbindungen.

1. Eine beliebige Webseite öffnen (z. B. about:blank).

2. Entwicklerkonsole öffnen und zum „Konsole“-Tab wechseln.

3. Folgenden JavaScript-Code eingeben:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("WebSocket-Verbindung geöffnet:", event);
     ws.send("Hallo vom Browser!"); // Nachricht nach Verbindungsaufbau senden
   };
   
   ws.onmessage = function(event) {
     console.log("Nachricht vom Server:", event.data); // Empfangene Daten
   };
   
   ws.onerror = function(event) {
     console.error("WebSocket-Fehler:", event); // Fehlerbehandlung
   };
   
   ws.onclose = function(event) {
     console.log("WebSocket-Verbindung geschlossen:", event); // Verbindung beendet
   };
   
   // Zusätzliche Nachrichten senden via ws.send("Deine Nachricht")
   // Verbindung schließen mit ws.close()

4. Starten Sie den Code in der Console und beobachten Sie die Ausgaben sowie die Logs im Terminal, in dem websocket_server.php läuft.

Methode B: Mit dem wscat-Kommandozeilentool

wscat ist ein praktischer WebSocket-Client für die Kommandozeile, basierend auf Node.js.

1. Installation von wscat: Falls Node.js und npm noch nicht installiert sind, zuerst installieren. Dann wscat global via npm installieren:

   npm install -g wscat

2. Mit WebSocket-Server verbinden: Im Terminal eingeben:

   wscat -c ws://localhost:9502

   Nach Verbindungsaufbau erscheint die Eingabeaufforderung >.

3. Nachricht senden: Geben Sie eine beliebige Nachricht nach > ein und drücken Sie Enter:

   > Hallo ServBay via wscat

   Der Server antwortet, die Antwort wird mit < angezeigt:

   < Hallo, deine Nachricht: Hallo ServBay via wscat

   Im Terminal des WebSocket-Servers werden die Events ebenfalls geloggt.

Trennen Sie die Verbindung mit Ctrl + C.

Wichtige Hinweise

• Portkonflikte: Sorgen Sie dafür, dass die von Swoole genutzten Ports (wie 9501, 9502) nicht von anderen Anwendungen belegt sind. Im Konfliktfall startet der Server nicht.
• PHP-Version: Nutzen Sie zum Ausführen der Skripte die PHP-Version mit aktivierter Swoole-Erweiterung aus ServBay. Überprüfen Sie die Version via php -v. ServBay bietet ggf. ein Umschalt-Tool für verschiedene PHP-Installationen.
• Erweiterungsstatus: Startet der Server nicht, prüfen Sie, ob Swoole für die aktuelle PHP-Version korrekt aktiviert wurde und ob ServBay/PHP-Dienst nach Änderungen neu gestartet wurde.
• Verwaltung von Dauerprozessen: Swoole-Server laufen dauerhaft im Speicher. In produktiven Umgebungen sollte ein Prozessmanager wie Supervisor, Systemd oder pm2 verwendet werden, um nach Abstürzen automatischen Restart sicherzustellen. Für lokale Entwicklung reicht der manuelle Start im Terminal meist aus.

Fazit

Dank ServBay können Sie Swoole-Erweiterungen unkompliziert aktivieren und leistungsfähige PHP-Anwendungen lokal testen – egal ob klassische HTTP-Server oder moderne, echtzeitfähige WebSocket-Dienste. Die Synergie aus Swoole und einer bequemen Entwicklungsumgebung wie ServBay eröffnet neue Möglichkeiten für PHP-Entwickler und hilft Ihnen, skalierbare und effiziente Applikationen zu bauen. Probieren Sie Swoole in ServBay gleich heute aus!