Workerman-Anwendungen in ServBay aufsetzen und ausführen

Überblick

Dieses Dokument richtet sich an ServBay-Nutzer und erläutert Schritt für Schritt, wie Sie mit der integrierten PHP-Umgebung und Composer in ServBay schnell und unkompliziert performante, auf Workerman basierende, asynchrone Netzwerkanwendungen auf Ihrem lokalen macOS-System entwickeln und betreiben können. Workerman ist eine leistungsstarke PHP-Bibliothek, hervorragend geeignet zum Bau aller Arten von netzwerkbasierten Hochlast-Diensten – etwa Webserver, Server für Echtzeitkommunikation oder Spiele-Backends. Mit ServBay steht dafür eine „Ready to use“-Plattform zur Verfügung, die die Einrichtung der Workerman-Umgebung erheblich vereinfacht.

Was ist Workerman?

Workerman ist ein komplett in PHP geschriebenes, quelloffenes, leistungsstarkes und asynchrones Netzwerkkommunikations-Framework. Es basiert auf dem EventLoop-Prinzip und setzt auf asynchrone, nicht-blockierende I/O, wodurch sich sehr viele parallele Netzwerkverbindungen effizient bedienen lassen. Im Unterschied zu klassischen PHP-Web-Setups (wie Apache/Nginx + PHP-FPM) laufen Workerman-Anwendungen typischerweise dauerhaft im Speicher, überwachen einen oder mehrere Ports und verarbeiten Netzwerkkommunikation direkt und ohne die herkömmlichen Prozessstarts/Zerstörungen. Dies vermeidet Overhead, erhöht die Performance und steigert den Datendurchsatz erheblich.

Mit Workerman lassen sich unter anderem einfach realisieren:

• Hochleistungs-HTTP-Server, die – je nach Szenario – sogar einen Apache/Nginx im Handling einfacher (statischer oder dynamischer) Anfragen ersetzen können.
• Echtzeit-WebSocket-Server für Anwendungen wie Chats oder Data Push-Dienste.
• TCP-/UDP-Server für beliebige Protokolle und individuelle Netzwerkkommunikation.
• Kommandozeilen-Tools, Cronjobs, Microservices und vieles mehr.

Kerneigenschaften und Vorteile von Workerman

• Hohe Performance: Eventgesteuert und asynchron – optimal für zahlreiche parallele Verbindungen und exzellente Geschwindigkeit.
• Multi-Protokoll-Unterstützung: Native Unterstützung für HTTP, WebSocket, TCP, UDP und einfache Erweiterbarkeit für eigene Protokolle.
• Benutzerfreundlichkeit: Schlanke und durchdachte APIs reduzieren die Komplexität von asynchroner Netzwerkprogrammierung; PHP-Entwickler steigen sofort durch.
• Flexible Skalierung: Unterstützung für Multi-Process, zur optimalen Ausnutzung von Multi-Core-Systemen, horizontale Skalierung sowie Lastverteilung; Composer- und PHP-Library-Integration ganz ohne Aufwand.
• Integration in die PHP-Community: Bibliothek im PHP-Ökosystem; Composer-Support ermöglicht komfortables Dependency-Management.
• Daemon-Modus: Für produktiven Einsatz als Daemon (Hintergrundprozess) geeignet, um dauerhaften, robusten Service sicherzustellen.

Workerman erweitert den Horizont für PHP-Entwickler – es wird einfach, hochleistungsfähige, Echtzeit-, und hochparallele Netzwerkapplikationen mit PHP zu schreiben.

Workerman-Entwicklungsumgebung mit ServBay einrichten

ServBay ist die maßgeschneiderte lokale Entwicklungsplattform für Webentwickler, vorinstalliert mit Laufzeitumgebungen für PHP, Node.js, Python, Go, Java sowie Datenbanken wie MySQL, PostgreSQL, MongoDB, Redis, Memcached und Webservern wie Caddy, Nginx und Apache. Alle Features stehen „Out of the Box“ bereit – so ist Composer für PHP bereits korrekt konfiguriert, was das Aufsetzen und Verwalten von Workerman-Projekten erheblich beschleunigt.

Diese Anleitung zeigt anhand einfacher Beispiele, wie Sie in ServBay schnell verschiedene Workerman-Server einrichten und starten, darunter ein HTTP-, ein WebSocket- und ein TCP-Server.

TIP

Um Ordnung und Übersichtlichkeit bei Ihren Webprojekten zu gewährleisten, empfiehlt ServBay, alle lokalen Website-Dateien im Verzeichnis /Applications/ServBay/www anzulegen. Alle in dieser Dokumentation genannten Beispielpfade beziehen sich auf dieses Verzeichnis.

Voraussetzungen

Bitte stellen Sie sicher, dass folgende Voraussetzungen erfüllt sind:

1. ServBay ist installiert und läuft ordnungsgemäß: Laden Sie die neueste Version von der ServBay-Website herunter und installieren Sie sie.
2. PHP ist in ServBay aktiviert: Öffnen Sie das ServBay-Control-Panel und stellen Sie die gewünschte PHP-Version bereit. Workerman benötigt mindestens PHP 5.4 – empfohlen wird PHP 7.x oder 8.x für beste Performance.
3. Grundkenntnisse in PHP und Kommandozeile: Sie sollten mit grundlegender PHP-Syntax sowie dem Umgang mit Terminalbefehlen vertraut sein.

Workerman installieren

1. Composer-Verfügbarkeit prüfen

Composer ist bereits in ServBay vorinstalliert, Sie müssen nichts weiter installieren. Achten Sie darauf, dass ServBay läuft und die gewünschte PHP-Version aktiviert ist, da ServBay dann automatisch den passenden Composer konfiguriert. Composer kann sowohl über das ServBay Terminal als auch, falls Sie PHP und Composer in den System-PATH übernommen haben, direkt über Ihre Shell genutzt werden.

Überprüfen Sie mit folgendem Terminalbefehl, ob Composer bereitsteht:

composer -v

Wenn Composer in der PHP-Umgebung von ServBay korrekt installiert und konfiguriert ist, sehen Sie die Versionsinformationen. Wird der Befehl nicht gefunden, prüfen Sie, ob ServBay läuft und die gewünschte PHP-Version aktiviert ist.

2. Projektverzeichnis anlegen

Navigieren Sie in das von ServBay empfohlene Webverzeichnis und legen Sie dort ein neues Projektverzeichnis an:

cd /Applications/ServBay/www
mkdir servbay-workerman-demo
cd servbay-workerman-demo

Im Beispiel nennen wir das Projektverzeichnis servbay-workerman-demo.

3. Workerman mit Composer installieren

Führen Sie folgende Schritte im neuen Projektverzeichnis (/Applications/ServBay/www/servbay-workerman-demo) aus, um Workerman inklusive aller Abhängigkeiten zu installieren:

composer require workerman/workerman

Composer lädt Workerman und sämtliche Abhängigkeiten in das vendor-Verzeichnis im aktuellen Ordner.

Workerman HTTP-Server programmieren

Ein HTTP-Server – das Standardbeispiel für Workerman – eignet sich ideal als schnelle Web- oder API-Basis.

Erstellen Sie im Projektordner eine Datei http_server.php (alternativ z. B. server.php) mit folgendem PHP-Code:

<?php
// Lade die von Composer erzeugte Autoload-Datei, um Workerman-Klassen verwenden zu können
require __DIR__ . '/vendor/autoload.php';

// Importiere die Workerman Worker-Klasse
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
use Workerman\Protocols\Http\Response;

// Erzeuge einen Worker, bestimme Protokoll und Adresse
// 'http://0.0.0.0:8080' startet einen HTTP-Server, der auf allen Netzwerkadressen (0.0.0.0) Port 8080 überwacht
// 0.0.0.0 erlaubt Zugriffe aus dem eigenen Netz; 8080 ist der Lausche-Port
$http_worker = new Worker('http://0.0.0.0:8080');

// Setze die Zahl der PHP-Prozesse (Worker)
// Im Beispiel starten wir 4 Prozesse; bei Bedarf an die Anzahl Ihrer CPU-Kerne anpassen
$http_worker->count = 4;

// Definiere, was bei Eingang einer Clientnachricht (HTTP-Request) passieren soll
// $connection ist das aktuelle Verbindungsobjekt, ermöglicht Rückantworten an den Client
// $request ist das aktuelle Request-Objekt mit Infos zu URL, Header, Body etc.
$http_worker->onMessage = function(TcpConnection $connection, Request $request) {
    // Sende einen einfachen String als HTTP-Response
    // Workerman übernimmt das Setzen der HTTP-Header automatisch
    $connection->send(new Response(200, [], 'Hello ServBay Workerman HTTP Server!'));
};

// Starte alle definierten Worker
// Dies ist die zentrale Eventloop – nach dem Start lauschen die Worker-Prozesse und verarbeiten Traffic
Worker::runAll();

Erläuterung zum Code:

• require __DIR__ . '/vendor/autoload.php';: Lädt den von Composer erzeugten Autoloader, sodass Sie die Workerman-Klassen (Worker, Request, Response etc.) verwenden können.
• use Workerman\...;: Bindet die jeweils benötigten Klassen ein.
• new Worker('http://0.0.0.0:8080'): Erstellt ein Workerman-Server-Objekt für das HTTP-Protokoll, an Port 8080, auf allen Adressen.
• $http_worker->count = 4;: Definiert die Zahl paralleler PHP-Arbeitsprozesse.
• $http_worker->onMessage = function(TcpConnection $connection, Request $request) { ... };: Gibt eine Callback-Funktion an, die bei jedem eingehenden HTTP-Request ausgeführt wird. $connection ermöglicht die Antwort an den Client, $request umfasst alle Request-Daten; das Response-Objekt formatiert die HTTP-Antwort.
• Worker::runAll();: Startet den Eventloop und aktiviert alle konfigurierten Worker.

Workerman HTTP-Server starten

Starten Sie aus dem Projektverzeichnis (/Applications/ServBay/www/servbay-workerman-demo) das HTTP-Server-Skript:

php http_server.php start

Hinweis zu den Betriebsmodi:

• Vordergrundmodus (Foreground): Mit php http_server.php start läuft Workerman im Vordergrund. Sie sehen laufend Logmeldungen und stoppen den Server per Ctrl+C. Perfekt für das Entwickeln und Debuggen.
• Daemon-Modus (Hintergrund): Für den Produktiveinsatz empfiehlt sich die Hintergrundausführung per -d-Option:

  php http_server.php start -d

  Die Serverprozesse laufen dann als Daemon und loggen alle Ausgaben in eine Datei im Workerman-Ordner (oder im spezifizierten Pfad).

Prozessmanagement:

Workerman bringt komfortable Steuerungsbefehle mit:

• Starten: php http_server.php start (Vordergrund) bzw. php http_server.php start -d (Hintergrund)
• Stoppen: php http_server.php stop (beendet nach Abschluss offener Requests elegant)
• Neustart: php http_server.php restart (stoppt und startet neu)
• Sanft neustarten (Reload): php http_server.php reload (insbes. bei Codeänderungen; einzelne Worker-Prozesse werden nacheinander neu gestartet, Dienste bleiben verfügbar. Beachten Sie ggf. bestimmte Callback-Methoden wie onWorkerStart!)
• Statusprüfung: php http_server.php status (zeigt Laufzeitstatus, Speicherverbrauch, Zahl der Verbindungen usw.)

Nach dem Start können Sie im Browser http://localhost:8080 oder http://127.0.0.1:8080 aufrufen. Sie sollten nun die Meldung Hello ServBay Workerman HTTP Server! sehen.

Einen WebSocket-Server mit Workerman erstellen

WebSocket bietet eine dauerhafte, bidirektionale Verbindung und eignet sich ideal für Echtzeitanwendungen (Chats, Ticker, Multiplayer-Spiele etc.). Workerman unterstützt WebSockets direkt.

1. WebSocket-Server programmieren

   Legen Sie die Datei websocket_server.php im Projektordner an:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Erzeuge einen WebSocket-Server an Port 8081
   // 'websocket://0.0.0.0:8081' erstellt einen WebSocket-Server
   // Workerman übernimmt automatisch den gesamten WebSocket-Handshake
   $ws_worker = new Worker('websocket://0.0.0.0:8081');
   
   // Nutze 4 Prozesse für parallele Verbindungen
   $ws_worker->count = 4;
   
   // Was passiert bei neuer Verbindung:
   $ws_worker->onConnect = function(TcpConnection $connection) {
       echo "Neue WebSocket-Verbindung von " . $connection->getRemoteIp() . "\n";
   };
   
   // Was tun bei Nachrichteneingang:
   $ws_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Nachricht empfangen: " . $data . "\n";
       // Sende die empfangene Nachricht zurück
       $connection->send('ServBay Workerman hat empfangen: ' . $data);
   };
   
   // Was tun bei Verbindungsende:
   $ws_worker->onClose = function(TcpConnection $connection) {
       echo "WebSocket-Verbindung geschlossen\n";
   };
   
   // Fehlerbehandlung (optional)
   $ws_worker->onError = function(TcpConnection $connection, $code, $msg) {
       echo "Fehler: $code - $msg\n";
   };
   
   
   // Starte die Worker
   Worker::runAll();

2. WebSocket-Server starten

   Führen Sie im Projektverzeichnis folgendes aus:

   php websocket_server.php start

   Sie können auch mit -d als Daemon starten. Verbinden Sie sich anschließend z.B. mit einem WebSocket-Client zu ws://localhost:8081.

   Testen lässt sich dies etwa in der Browser-Konsole mit JavaScript:

   var ws = new WebSocket("ws://localhost:8081");
   
   ws.onopen = function(event) {
     console.log("WebSocket-Verbindung geöffnet");
     ws.send("Hallo vom Browser!"); // Nachricht senden
   };
   
   ws.onmessage = function(event) {
     console.log("Nachricht vom Server:", event.data); // Empfangene Nachricht
   };
   
   ws.onclose = function(event) {
     if (event.wasClean) {
       console.log("WebSocket-Verbindung sauber geschlossen, Code=" + event.code + " Grund=" + event.reason);
     } else {
       console.error("WebSocket-Verbindung abgebrochen");
     }
   };
   
   ws.onerror = function(error) {
     console.error("WebSocket-Fehler:", error);
   };
   
   // Zum Schließen (optional)
   // ws.close();

   Nach erfolgreicher Verbindung werden im Terminal Verbindungsinformationen angezeigt; Nachrichten werden dort und im Browserjournal zurückgegeben.

Mit Workerman einen TCP-Server bauen

Sie können mit Workerman beliebige TCP-Server entwerfen, etwa für Spiele-Backends, IoT-Anwendungen oder proprietäre Netzprotokolle.

1. TCP-Server programmieren

   Datei tcp_server.php erstellen und Folgendes einfügen:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // TCP-Server auf Port 8082 erzeugen
   // 'tcp://0.0.0.0:8082' definiert einen TCP-Server
   // Workerman nutzt standardmäßig das Textprotokoll (Zeilenende '\n'); andere (auch eigene) Protokolle sind konfigurierbar
   $tcp_worker = new Worker('tcp://0.0.0.0:8082');
   
   // Starte 4 Worker-Prozesse
   $tcp_worker->count = 4;
   
   // Neues Verbindungs-Handler
   $tcp_worker->onConnect = function(TcpConnection $connection) {
       echo "Neue TCP-Verbindung von " . $connection->getRemoteIp() . "\n";
       // Sende Willkommensnachricht beim Verbindungsaufbau
       $connection->send("Willkommen beim ServBay Workerman TCP Server!\n");
   };
   
   // Nachrichtenempfangs-Handler
   // $data enthält die dekodierten TCP-Nutzdaten des Clients
   $tcp_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Daten empfangen: " . $data;
       // Echo zurück an Client
       $connection->send('ServBay Workerman hat empfangen: ' . $data);
   };
   
   // Verbindungsende-Handler
   $tcp_worker->onClose = function(TcpConnection $connection) {
       echo "TCP-Verbindung geschlossen\n";
   };
   
   // Worker starten
   Worker::runAll();

2. TCP-Server ausführen

   Im Projektverzeichnis ausführen:

   php tcp_server.php start

   Für den Daemon-Modus wieder -d anhängen. Zum Testen z.B. mit Netcat oder Telnet verbinden:

   # Mit telnet
   telnet localhost 8082
   
   # Oder mit nc (netcat)
   nc localhost 8082

   Nach erfolgreicher Verbindung erhalten Sie eine Willkommensnachricht vom Server. Senden Sie eine beliebige Textzeile (mit Enter, da das Textprotokoll als Zeilentrenner arbeitet) – sie wird vom Server zurückgegeben.

Hinweise und Tipps

• Portbelegung: Stellen Sie sicher, dass die Ports (im Beispiel: 8080, 8081, 8082) nicht bereits von macOS oder anderen ServBay-Diensten genutzt werden. Bei Konflikten kann Workerman nicht gestartet werden; prüfen Sie dies ggf. mit lsof -i :Portnummer.
• Firewall: Die macOS-Firewall könnte Verbindungen blockieren, insbesondere aus dem lokalen Netzwerk. Für reine lokale Entwicklung kein Problem – aber für LAN-Zugriffe müssen Sie die Firewall ggf. konfigurieren.
• Zusammenspiel mit ServBay-Webservern: Workerman benutzt eigene Ports/Prozesse und ist unabhängig von Caddy/Nginx/Apache in ServBay. Die Kommunikation läuft direkt, nicht über einen Reverse-Proxy (außer, wenn explizit konfiguriert). Workerman empfiehlt sich für Langzeitverbindungen/hohe Parallelität (z. B. WebSockets), während die ServBay-Webserver ideal für klassische HTTP-Workloads sind.
• PHP-Version beachten: Prüfen Sie, dass die für Workerman verwendete PHP-Version den Mindestvorgaben genügt – ServBay liefert mehrere PHP-Versionen, wählbar im Control Panel.
• Erforderliche PHP-Extensions: Für optimale Performance nutzt Workerman einige Extensions wie event (schnelleres Event Looping, falls installiert und aktiviert), posix, pcntl (multiprozessfähig). Bei Problemen prüfen Sie die Extension-Einstellungen der jeweiligen PHP-Version im ServBay-Panel.
• Logs: Im Daemon-Betriebsmodus schreibt Workerman Logausgaben in Dateien. Prüfen Sie diese regelmäßig, um Betriebsstatus und mögliche Fehler rasch zu erkennen.

Häufig gestellte Fragen (FAQ)

• Q: Wie stoppe ich einen Workerman-Server?
  • A: Läuft der Server im Vordergrund (start), stoppen Sie ihn mit Ctrl+C. Im Daemon-Modus (start -d) beenden Sie ihn per php Ihr_Server_Script.php stop im Projektverzeichnis.
• Q: Warum startet mein Workerman-Server nicht?
  • A: Häufigster Grund sind Portkonflikte – prüfen Sie die Terminal-Fehlermeldung und den Status mit lsof -i :Portnummer. Wechseln Sie ggf. auf einen freien Port oder beenden Sie konkurrierende Anwendungen.
• Q: Was ist der Unterschied zwischen ServBay’s Caddy/Nginx und Workerman – wann verwende ich was?
  • A: Caddy/Nginx sind klassische Webserver für HTTP/HTTPS-Anfragen (oft über PHP-FPM), beenden nach jedem Request die PHP-Prozesse häufig wieder. Workerman läuft als asynchroner PHP-Server (ggf. für HTTP, aber auch für WebSockets, TCP usw.), arbeitet speichereffizient bei langanhaltenden, parallelen Verbindungen und Echtzeit-Anwendungen. Sie wählen je nach Einsatzzweck: Für traditionelle Websites/API Caddy/Nginx, für Chat, Games, IoT oder hohe Parallelität empfiehlt sich Workerman. Eine Kombination (Reverse Proxy auf Workerman) ist ebenfalls möglich.
• Q: Kann ich in ServBay mehrere Workerman-Anwendungen parallel betreiben?
  • A: Ja. Jede Workerman-Anwendung läuft in einem eigenen PHP-Prozess und muss ausschließlich einen eigenen (freien) Port nutzen. Erstellen Sie für jede App ein separates Startskript und rufen Sie jeweils php Ihr_app_server.php start (ggf. auch im Hintergrund) in eigenen Terminals auf.

Fazit

Mit dieser Anleitung wissen Sie nun, wie Sie Workerman-Projekte in der leistungsfähigen und bequemen Local-Dev-Umgebung ServBay einrichten und starten. Dank der hohen Performance und asynchronen Architektur von Workerman bauen PHP-Entwickler im Handumdrehen die Netzwerkanwendungen von morgen. Durch Composer- und PHP-Integration in ServBay arbeiten Sie effizienter und können sich ganz auf Ihre Business-Logik konzentrieren, ohne sich mit komplizierter Umgebungskonfiguration aufhalten zu müssen. Ob schneller Webservice, Echtzeit-WebSocket-App oder ein anderer skalierbarer Netzwerkdienst – ServBay ist Ihr idealer lokaler Workerman-Partner. Viel Erfolg und Spaß beim Entdecken von Workerman!