Einrichtung und Ausführung von Workerman-Anwendungen mit ServBay

Übersicht

Dieses Dokument zeigt ServBay-Nutzern, wie sie unter macOS und Windows mit dem integrierten PHP und Composer von ServBay schnell und komfortabel Workerman-basierte, hochperformante asynchrone Netzwerk-Apps entwickeln und ausführen können. Workerman ist eine leistungsstarke PHP-Bibliothek für Anwendungen, die hohe Parallelität und Echtzeitkommunikation erfordern – wie Webserver, Chatserver oder Gameserver. ServBay bietet ein sofort einsatzbereites Entwicklungsumfeld und nimmt Ihnen die aufwendige Konfiguration ab.

Was ist Workerman?

Workerman ist ein komplett in PHP entwickeltes Open-Source-Framework für asynchrone Netzwerkkommunikation mit hoher Leistung und basiert auf einem Event-Loop-Mechanismus. So ermöglicht es nicht-blockierendes I/O und kann Tausende gleichzeitige Verbindungen effizient verarbeiten. Anders als traditionelle PHP-Webentwicklung (z.B. Apache/Nginx + PHP-FPM) laufen Workerman-Anwendungen als dauerhaft aktiver Prozess, der einen bestimmten Port überwacht und Netzwerkkommunikation direkt abwickelt. Dadurch fallen die Ressourcen für ständiges Starten und Stoppen von PHP-Prozessen weg, was die Performance erheblich steigert.

Mit Workerman können Entwickler ganz einfach:

• Hochleistungs-HTTP-Server realisieren – als Ersatz für Apache/Nginx bei einfachen Webseiten oder APIs.
• Echtzeit-WebSocket-Server umsetzen, z.B. für Chat-Anwendungen oder Live-Daten-Übertragungen.
• TCP/UDP-Server für benutzerdefinierte Protokolle erstellen.
• Kommandozeilentools, Cronjobs und Microservices entwickeln.

Kernfunktionen und Vorteile von Workerman

• Absolute Performance: Ereignisgesteuerte Architektur und nicht-blockierendes I/O sorgen für die Verarbeitung von tausenden gleichzeitigen Verbindungen – Spitzenleistung!
• Protokollvielfalt: HTTP, WebSocket, TCP, UDP sind direkt unterstützt, außerdem lassen sich eigene Protokolle flexibel realisieren.
• Einfache Bedienung: Die API ist klar und unkompliziert – PHP-Entwickler können direkt starten.
• Flexible Skalierung: Multi-Prozess-Architektur ermöglicht optimale Nutzung von Multi-Core-CPUs für horizontale Skalierung und Lastverteilung. Composer-Pakete und bestehende Bibliotheken sind einfach integrierbar.
• Integration ins PHP-Ökosystem: Als PHP-Library nahtlos einbindbar und mit Composer verwaltbar.
• Daemon-Modus: Für den stabilen Dauerbetrieb im Hintergrund, optimal für produktive Umgebungen und maximale Verfügbarkeit.

Workerman eröffnet PHP-Entwicklern den Zugang zu leistungsfähigen, echtzeitfähigen und skalierbaren Netzwerkapplikationen.

Workerman-Entwicklungsumgebung mit ServBay einrichten

ServBay ist ein speziell für Webentwickler konzipiertes lokales Entwicklungswerkzeug. Es bietet sofort nutzbare Laufzeitumgebungen für PHP, Node.js, Python, Go, Java sowie vorkonfigurierte Server und Datenbanken wie Caddy, Nginx, Apache, MySQL, PostgreSQL, MongoDB, Redis und Memcached. Ein besonderer Vorteil: Composer ist bereits integriert und fertig eingerichtet – das macht die Installation und Nutzung von Workerman-Projekten extrem komfortabel.

Diese Anleitung demonstriert anhand einfacher Beispiele (HTTP-, WebSocket-, und TCP-Server), wie Sie in ServBay schnell Workerman-Anwendungen aufsetzen und starten.

TIP

Zur Übersicht empfiehlt ServBay, sämtliche Webprojektdateien in folgenden Ordnern zu speichern:

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

Alle Pfadbeispiele in dieser Anleitung beziehen sich auf diese Ordner.

Voraussetzungen

Bitte stellen Sie vor dem Start sicher:

1. ServBay ist installiert und läuft: Laden Sie die neueste Version direkt von ServBay herunter und installieren Sie sie.
2. PHP ist in ServBay aktiviert: Prüfen Sie im ServBay-Panel, ob die gewünschte PHP-Version aktiviert ist. Workerman benötigt PHP 5.4 oder höher, empfehlenswert sind PHP 7.x oder 8.x für maximale Performance.
3. Grundkenntnisse in PHP und mit der Kommandozeile: Sie sollten die PHP-Syntax und die Arbeit mit dem Terminal (Befehle ausführen) beherrschen.

Workerman installieren

1. Composer-Verfügbarkeit prüfen

Composer ist bereits in ServBay integriert. Sie müssen nichts separat installieren. Prüfen Sie, dass ServBay läuft und PHP aktiviert ist. Composer wird automatisch für die ausgewählte PHP-Version bereitgestellt. Sie können Composer direkt im ServBay-Terminal oder in der Systemkonsole nutzen (sofern PHP und Composer im PATH sind).

Kontrollieren Sie die Composer-Installation mit:

composer -v

Ist Composer korrekt eingerichtet, sehen Sie die Versionsinformationen. Bei einem Fehler prüfen Sie, ob ServBay läuft und PHP aktiviert ist.

2. Projektverzeichnis anlegen

Wechseln Sie in das empfohlene Projektverzeichnis und erstellen Sie einen neuen Ordner:

macOS:

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

Windows:

cd C:\ServBay\www
mkdir servbay-workerman-demo
cd servbay-workerman-demo

Das Projektverzeichnis heißt hier servbay-workerman-demo.

3. Workerman mit Composer installieren

Wechseln Sie ins Projektverzeichnis:

• macOS: /Applications/ServBay/www/servbay-workerman-demo
• Windows: C:\ServBay\www\servbay-workerman-demo

Installieren Sie Workerman:

composer require workerman/workerman

Composer lädt Workerman und alle Abhängigkeiten in den Ordner vendor.

Workerman HTTP-Server programmieren

Einer der häufigsten Anwendungsfälle für Workerman ist der Aufbau performanter Webserver oder API-Dienste.

Erstellen Sie im Projektordner eine Datei namens http_server.php (oder server.php) und fügen Sie folgenden PHP-Code ein:

<?php
// Lade die Composer-Autoload-Datei, damit Workerman-Klassen verfügbar sind
require __DIR__ . '/vendor/autoload.php';

// Importiere die benötigten Workerman-Klassen
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
use Workerman\Protocols\Http\Response;

// Erzeuge einen Worker-Server auf Protokoll und Adresse
// 'http://0.0.0.0:8080' bedeutet: HTTP-Server auf allen Schnittstellen, Port 8080
// 0.0.0.0 – Zugriff von lokal und im LAN; 8080 – der überwachte Port.
$http_worker = new Worker('http://0.0.0.0:8080');

// Lege die Anzahl der Worker-Prozesse fest
// Hier: 4 Prozesse für parallele Verarbeitung, an die CPU-Kerne anpassbar
$http_worker->count = 4;

// Logik für eingehende Client-Nachrichten (HTTP-Requests)
// $connection: die Verbindung zum Client (zum Antworten)
// $request: das Anfrageobjekt (URL, Header, Body etc.)
$http_worker->onMessage = function(TcpConnection $connection, Request $request) {
    // Sende eine einfache Antwort an den Client
    // Workerman kümmert sich automatisch um HTTP-Header usw.
    $connection->send(new Response(200, [], 'Hello ServBay Workerman HTTP Server!'));
};

// Starte alle Worker-Instanzen
// Hauptloop: Der Server überwacht Ports und verarbeitet Verbindungen
Worker::runAll();

Erklärung:

• require __DIR__ . '/vendor/autoload.php';: Lädt geladenen Klassen via Composer, darunter Worker, Request und Response.
• use Workerman\...: Importiert die relevanten Workerman-Klassen.
• new Worker('http://0.0.0.0:8080'): Erzeugt die Serverinstanz für HTTP auf Port 8080.
• $http_worker->count = 4;: Legt die Zahl der parallelen PHP-Prozesse zur besseren Nutzung von Mehrkern-CPUs fest.
• $http_worker->onMessage = function(...) { ... }: Definiert, was beim Empfang einer HTTP-Anfrage geschieht – z.B. Antwort versenden.
• Worker::runAll();: Startet den Worker/Event-Loop und aktiviert den Server.

Workerman HTTP-Server starten

Starten Sie im Projektverzeichnis das HTTP-Serverprogramm:

• macOS: /Applications/ServBay/www/servbay-workerman-demo
• Windows: C:\ServBay\www\servbay-workerman-demo

php http_server.php start

Betriebshinweise:

• Im Vordergrund: Mit php http_server.php start läuft Workerman sichtbar im Terminal; Logs sind direkt sichtbar. Beenden mit Ctrl+C. Optimal für Entwicklung und Fehlersuche.
• Als Daemon (Hintergrund): Für den stabilen Dauerbetrieb im Produktivsystem empfiehlt sich der Daemon-Modus:

  php http_server.php start -d

  Workerman läuft im Hintergrund; Logs werden ins Logfile geschrieben (standardmäßig im Projektordner oder konfiguriertem Pfad).

Prozessmanagement:

Workerman bietet komfortable Kontrollbefehle:

• Start: php http_server.php start (Vordergrund) oder php http_server.php start -d (Hintergrund)
• Stop: php http_server.php stop (beendet alle Prozesse sauber)
• Restart: php http_server.php restart (Stop + Start)
• Reload (sanftes Neuladen): php http_server.php reload (zur Aktualisierung, rollierender Neustart der Prozesse ohne Dienstunterbrechung; beachten Sie dafür die Lifecycle-Events)
• Status ansehen: php http_server.php status (zeigt u.a. Serverstatus, Speicherverbrauch, Verbindungszahlen)

Nach dem Start können Sie im Browser http://localhost:8080 oder http://127.0.0.1:8080 öffnen. Sie erhalten als Antwort: Hello ServBay Workerman HTTP Server!.

Mit Workerman einen WebSocket-Server erstellen

WebSocket ermöglicht eine dauerhafte bidirektionale Verbindung zwischen Client und Server, ideal für Chats, Echtzeitbenachrichtigungen, Spiele und mehr. Workerman unterstützt WebSocket hervorragend.

1. WebSocket-Server-Programm schreiben

   Erstellen Sie die Datei websocket_server.php mit folgendem Inhalt:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Initialisiere einen WebSocket-Server auf Port 8081
   // 'websocket://0.0.0.0:8081' = WebSocket auf allen Schnittstellen
   // Workerman übernimmt das Handshake
   $ws_worker = new Worker('websocket://0.0.0.0:8081');
   
   // Starte 4 parallele Prozesse
   $ws_worker->count = 4;
   
   // Logik beim Verbindungsaufbau
   // Wird ausgelöst, wenn sich ein Client verbindet
   $ws_worker->onConnect = function(TcpConnection $connection) {
       echo "Neue WebSocket-Verbindung von " . $connection->getRemoteIp() . "\n";
   };
   
   // Logik für empfangene Nachrichten
   // Wird ausgelöst, wenn Nachrichten vom Client eintreffen
   // $data: die vom Client empfangene Nachricht (dekoriert)
   $ws_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Empfangene Nachricht: " . $data . "\n";
       // Echo-Antwort zurück zum Client
       // $connection->send() versendet als WebSocket-Frame
       $connection->send('ServBay Workerman received: ' . $data);
   };
   
   // Logik bei Verbindungsabbruch
   $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 alle Worker-Instanzen
   Worker::runAll();

2. Starten des WebSocket-Servers

   Im Projektverzeichnis ausführen:

   php websocket_server.php start

   Auch hier können Sie mit -d den Server im Hintergrund laufen lassen. Nach dem Start verbinden Sie sich mit einem WebSocket-Client auf ws://localhost:8081.

   Beispiel im Browser (JavaScript-Konsole):

   var ws = new WebSocket("ws://localhost:8081");
   
   ws.onopen = function(event) {
     console.log("WebSocket-Verbindung offen");
     ws.send("Hello from Browser!"); // Sende Nachricht
   };
   
   ws.onmessage = function(event) {
     console.log("Serverantwort:", event.data); // Empfangene Nachricht anzeigen
   };
   
   ws.onclose = function(event) {
     if (event.wasClean) {
       console.log("WebSocket ordentlich geschlossen, Code=" + event.code + " Grund=" + event.reason);
     } else {
       console.error("WebSocket-Verbindung unerwartet beendet");
     }
   };
   
   ws.onerror = function(error) {
     console.error("WebSocket-Fehler:", error);
   };
   
   // Verbindung schließen (optional)
   // ws.close();

   Nach erfolgreicher Verbindung sehen Sie die Aktivitäten im Terminal und erhalten Echo-Nachrichten vom Server im Browser.

Mit Workerman einen TCP-Server erstellen

Workerman ist ebenso für generische TCP-Server geeignet, z.B. für Backend-Systeme von Spielen, IoT-Plattformen oder benutzerdefinierte Protokolle.

1. TCP-Server-Programm erstellen

   Datei tcp_server.php im Projektverzeichnis anlegen:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Initialisiere einen TCP-Server auf Port 8082
   // 'tcp://0.0.0.0:8082' = TCP-Server auf allen Schnittstellen
   // Workerman verwendet standardmäßig das Text-Protokoll ('\n' als Zeilenende), umstellbar auf andere oder benutzerdefinierte Protokolle
   $tcp_worker = new Worker('tcp://0.0.0.0:8082');
   
   // Starte 4 parallele Prozesse
   $tcp_worker->count = 4;
   
   // Logik beim Verbindungsaufbau
   $tcp_worker->onConnect = function(TcpConnection $connection) {
       echo "Neue TCP-Verbindung von " . $connection->getRemoteIp() . "\n";
       // Willkommensnachricht beim Verbindungsaufbau senden
       $connection->send("Willkommen beim ServBay Workerman TCP Server!\n");
   };
   
   // Logik für empfangene Daten
   // $data: rohe TCP-Daten (protokollabhängig aufbereitet)
   $tcp_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Empfangene Daten: " . $data;
       // Echo-Antwort zurück zum Client
       $connection->send('ServBay Workerman received: ' . $data);
   };
   
   // Logik bei Verbindungsabbruch
   $tcp_worker->onClose = function(TcpConnection $connection) {
       echo "TCP-Verbindung geschlossen\n";
   };
   
   // Starte alle Worker-Instanzen
   Worker::runAll();

2. Starten des TCP-Servers

   Im Projektverzeichnis ausführen:

   php tcp_server.php start

   Auch hier ist der Hintergrundmodus mit -d möglich. Zum Testen können Sie mit einem TCP-Client auf localhost:8082 verbinden.

   Terminal-Test:

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

   Nach erfolgreichem Verbindungsaufbau erhalten Sie die Willkommensnachricht und können beliebigen Text eingeben (mit Enter abschließen, da das Text-Protokoll Zeilenenden verwendet); der Server antwortet mit dem Echo der gesendeten Daten.

Hinweise / Tipps

• Portbelegung: Die für Workerman gewählten Ports (z.B. 8080, 8081, 8082) dürfen nicht durch macOS oder andere ServBay-Programme belegt sein. Bei einem Port-Konflikt startet Workerman nicht und meldet einen Fehler. Mit lsof -i :PORTNUMMER prüfen Sie die Belegung.
• Firewall: Die System-Firewall kann Verbindungen verhindern. Für lokale Entwicklung meist kein Problem – sollen aber Geräte im Netzwerk auf die Workerman-Instanzen zugreifen, müssen ggf. Firewallregeln angepasst werden.
• Zusammenspiel mit ServBay-Webservern: Workerman arbeitet auf eigenen Ports und ist ein eigenständiger Dienst – unabhängig von Caddy/Nginx in ServBay. Typische Workerman-Anwendungen steuern die Verbindung selbst, ein Reverse Proxy durch Caddy/Nginx ist nur bei entsprechendem Setup notwendig. Workerman ist ideal für langlaufende, hochperformante oder Echtzeitanwendungen (WebSocket usw.), wohingegen ServBay-Server wie Caddy/Nginx für klassische, kurzlebige HTTP-Verbindungen bevorzugt werden.
• PHP-Version: Die für Workerman verwendete PHP-Version in ServBay muss die Mindestanforderungen erfüllen. ServBay liefert mehrere PHP-Versionen mit und Sie können im Panel bequem wechseln.
• Abhängige PHP-Erweiterungen: Workerman nutzt verschiedene Erweiterungen für volle Funktionalität und Performance (z.B. event für maximale Geschwindigkeit, posix, pcntl für Multi-Prozess-Betrieb). ServBay hat standardmäßig alle wichtigen Extensions aktiviert, bei speziellen Problemen prüfen Sie bitte die Erweiterungs-Einstellungen im Panel.
• Logging: Im Daemon-Modus werden Log-Ausgaben in eine Datei umgeleitet. Kontrollieren Sie regelmäßig die Logs, um Überblick über Serverstatus und Fehler zu behalten.

FAQ – Häufige Fragen

• Q: Wie stoppe ich den Workerman-Server?
  • A: Im Vordergrundbetrieb (Start-Befehl) einfach Ctrl+C drücken. Läuft der Server im Hintergrund (Daemon-Modus), stoppen Sie im Projektverzeichnis mit php your_server_file.php stop.
• Q: Warum startet der Workerman-Server nicht?
  • A: Häufigster Grund ist eine belegte Portnummer. Die Fehlermeldung im Terminal gibt Aufschluss – wählen Sie ggf. einen freien Port oder beenden Sie das belegende Programm. Mit lsof -i :PORTNUMMER finden Sie den betreffenden Prozess.
• Q: Was unterscheidet ServBay mit Caddy/Nginx von Workerman und wann sollte ich welchen Server nutzen?
  • A: Die integrierten Webserver (Caddy/Nginx) sind für klassische Webanwendungen (HTTP/HTTPS, z.B. mit PHP-FPM) gedacht; Prozesse werden nach dem Request beendet. Workerman ist ein asynchrones Netzwerkframework, das als permanenter HTTP-, WebSocket- oder TCP-Server läuft und hohe Parallelität, lange Verbindungen und Echtzeitkommunikation ermöglicht. Der richtige Einsatz hängt vom Projekt ab: Standard-Websites und APIs setzten meist auf Caddy/Nginx; für Chats, Game-Backends oder IoT ist Workerman ideal. Kombinationen sind möglich, z.B. mit Reverse Proxy für spezielle Routen.
• Q: Kann ich mehrere Workerman-Anwendungen gleichzeitig in ServBay betreiben?
  • A: Ja! Jede Anwendung läuft als eigener PHP-Prozess und hört auf einem separaten Port. Starten Sie einfach mehrere Server-Skripte in verschiedenen Terminals (Vorder- oder Hintergrund), solange die Ports sich nicht überschneiden.

Fazit

Mit dieser Anleitung wissen Sie, wie Sie unter ServBay effizient und schnell Workerman-Projekte vorbereiten und betreiben. Dank der Performance und Asynchronität von Workerman können PHP-Entwickler jetzt auch hochgradig parallele Netzwerk- und Echtzeitdienste realisieren. Das „Out-of-the-box“-Umfeld von ServBay – inklusive Composer und aktuellen PHP-Versionen – sorgt dafür, dass Sie sich auf Ihre Anwendung konzentrieren können statt auf die lästige Einrichtung. Ganz gleich, ob Sie Webdienste mit hoher Geschwindigkeit oder interaktive WebSocket-Produkte entwickeln möchten: ServBay ist Ihr ideales Werkzeug für Workerman-Projekte auf dem lokalen Computer. Viel Erfolg bei Ihrer Workerman-Entdeckungsreise!