Workerman-applicaties bouwen en draaien in ServBay

Overzicht

Dit document biedt ServBay-gebruikers een stapsgewijze gids om op macOS en Windows snel high-performance asynchrone netwerkapplicaties te ontwikkelen en draaien met behulp van de geïntegreerde PHP- en Composer-omgeving van ServBay. Workerman is een krachtige PHP-bibliotheek voor het bouwen van uiteenlopende netwerksystemen waar hoge mate van gelijktijdigheid nodig is, zoals webservers, realtime communicatieservers en gameservers. Dankzij het 'out of the box'-karakter van ServBay verloopt de Workerman-inrichting bijzonder eenvoudig.

Wat is Workerman?

Workerman is een volledig in PHP geschreven, open-source high-performance asynchroon netwerkframework. Het is gebouwd rond het EventLoop-model en implementeert asynchrone non-blocking I/O, waardoor het efficiënt grote aantallen gelijktijdige verbindingen aan kan. In tegenstelling tot de klassieke PHP-webstack (zoals Apache/Nginx + PHP-FPM), draaien Workerman-applicaties resident in geheugen: ze luisteren op specifieke poorten en verwerken netwerkverbindingen direct, zonder de overhead van het creëren of vernielen van processen per verzoek. Dit zorgt voor significant betere prestaties en hogere doorvoer.

Met Workerman kunnen ontwikkelaars eenvoudig het volgende bouwen:

• High-performance HTTP-servers, die zelfs Apache/Nginx kunnen vervangen voor eenvoudige (statistische of dynamische) aanvragen.
• Realtime WebSocket-servers voor chat, data-push en soortgelijke toepassingen.
• TCP/UDP-servers voor custom protocols.
• Commandline tools, geplande taken, microservices en meer.

Kernfeatures en voordelen van Workerman

• High-performance: Gebaseerd op event-driven asynchrone non-blocking I/O, verwerkt moeiteloos grote aantallen gelijktijdige verbindingen.
• Ondersteuning voor meerdere protocollen: Out-of-the-box compatibiliteit met HTTP, WebSocket, TCP, UDP, plus flexibele interfaces voor custom protocolimplementatie.
• Gebruiksgemak: Een heldere, intuïtieve API verlaagt de leercurve van asynchrone netwerkprogrammering voor PHP-ontwikkelaars.
• Uitbreidbaarheid: Multi-process model, schaalbaar over meerdere CPU-cores en makkelijk te integreren met Composer packages en bestaande PHP-libraries.
• Integratie met PHP-ecosysteem: Als PHP-library doet Workerman naadloos mee aan het PHP-ecosysteem en gebruikt het Composer voor dependency management.
• Daemon mode: Kan als daemon in de achtergrond draaien, ideaal voor productieomgevingen waar betrouwbaarheid vereist is.

Workerman opent de deur naar high-performance, realtime en schaalbare netwerkapplicaties voor PHP-ontwikkelaars.

Workerman ontwikkelomgeving opzetten met ServBay

ServBay is een lokale ontwikkeltool, speciaal gebouwd voor webontwikkelaars. Het wordt geleverd met PHP, Node.js, Python, Go, Java en nog veel meer runtime-omgevingen, inclusief populaire databases en webservers als Caddy, Nginx, Apache, MySQL, PostgreSQL, MongoDB, Redis en Memcached. De grote troef is de 'ready to use'-aanpak, en Composer is al direct geïntegreerd en geconfigureerd, wat het starten van Workerman-projecten bijzonder toegankelijk maakt.

Deze tutorial laat met enkele basisvoorbeelden zien hoe je Workerman-applicaties bouwt en draait in ServBay, waaronder een eenvoudige HTTP-server, een WebSocket-server en een TCP-server.

TIP

Om projecten eenvoudig te beheren en consistent te houden, raadt ServBay aan om al je lokale projectbestanden op te slaan in:

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

Alle padvoorbeelden in deze gids zijn gebaseerd op deze locaties.

Voordat je begint

Controleer het volgende:

1. ServBay geïnstalleerd en actief: Download en installeer de laatste versie via ServBay Officiële website.
2. PHP geactiveerd in ServBay: Controleer in het ServBay-controlepaneel of de PHP-versie die je wilt gebruiken aanstaat. Workerman vereist PHP 5.4 of hoger, maar PHP 7.x of 8.x wordt aanbevolen.
3. Basiskennis van PHP en commandline: Je moet vertrouwd zijn met PHP-syntaxis en het gebruik van terminal/commandline tools.

Workerman installeren

1. Controleer Composer beschikbaarheid

Composer is vooraf geïnstalleerd in ServBay, je hoeft niets extra's te doen. Zorg ervoor dat ServBay actief is, en je gewenste PHP-versie geactiveerd is. Composer werkt automatisch samen met de juiste PHP-versie. Je kunt Composer gebruiken via de ServBay-terminal of je eigen terminal (mits ServBay PHP/Composer aan je PATH heeft toegevoegd).

Open een terminal en controleer Composer met:

composer -v

Als Composer goed geïnstalleerd en geconfigureerd is in de PHP-omgeving van ServBay, zie je de versiegegevens. Zie je een foutmelding, controleer dan of ServBay draait en PHP actief is.

2. Maak een projectmap aan

Navigeer naar de aanbevolen rootdirectory en maak een nieuwe projectmap aan:

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

Hier maken we de map servbay-workerman-demo aan voor de Workerman-bestanden.

3. Workerman installeren via Composer

In de projectmap installeer je de Workerman-library met Composer, de aanbevolen methode:

Projectmap locatie:

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

composer require workerman/workerman

Composer download automatisch Workerman en de afhankelijkheden naar de vendor-map.

Workerman HTTP-server schrijven

De HTTP-server is het meest gebruikte Workerman-scenario―ideaal voor webapplicaties of API-services.

Maak in je projectmap een bestand aan zoals http_server.php (kies gerust een andere naam) en voeg deze PHP-code toe:

<?php
// Laad Composer autoload voor gebruik van Workerman-klassen
require __DIR__ . '/vendor/autoload.php';

// Importeer de Workerman Worker-klasse
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
use Workerman\Protocols\Http\Response;

// Maak een Worker-instance die luistert op HTTP op poort 8080 op alle netwerken
// 'http://0.0.0.0:8080': alle interfaces (0.0.0.0), poort 8080
// 0.0.0.0 laat zowel lokaal als binnen LAN verbinding toe; 8080 is de poort
$http_worker = new Worker('http://0.0.0.0:8080');

// Stel het aantal worker-processen in
// Hier gebruiken we 4 processen, voor betere prestaties; pas aan op het aantal CPU-kernen
$http_worker->count = 4;

// Handler voor binnenkomende HTTP-requests
// $connection = de verbinding naar de client
// $request = het requestobject, met URL, headers, body, etc.
$http_worker->onMessage = function(TcpConnection $connection, Request $request) {
    // Stuur een eenvoudige string als HTTP-response naar de client
    // Workerman regelt automatisch de response headers
    $connection->send(new Response(200, [], 'Hello ServBay Workerman HTTP Server!'));
};

// Start de eventloop en run alle Worker-instances
Worker::runAll();

Toelichting op de code:

• require __DIR__ . '/vendor/autoload.php';: Laadt de Composer autoloader zodat Workerman-klassen direct te gebruiken zijn.
• use Workerman\...;: Importeert de nodige klassen.
• new Worker('http://0.0.0.0:8080'): Creëert een Workerman-worker voor HTTP op poort 8080.
• $http_worker->count = 4;: Start totaal vier PHP-processen voor gelijktijdige requestverwerking.
• $http_worker->onMessage = function(...) {...};: Callback voor volledige HTTP-verzoeken. $connection is het kanaal terug naar de client; $request bevat de client-informatie. Response maakt een volwaardige HTTP-antwoord.
• Worker::runAll();: Start de Workerman eventloop, waarna de server begint te luisteren en requests verwerkt.

De HTTP-server starten

Ga naar je projectmap en start de server met:

Projectlocatie:

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

php http_server.php start

Over de run-modus:

• Voorgrond (Foreground): Met php http_server.php start draait Workerman in de terminal, logt status en fouten, en je stopt het met Ctrl+C. Ideaal voor ontwikkeling en debugging.
• Daemon-mode (Achtergrond): In productie wil je de server als daemon op de achtergrond laten draaien met het -d argument:

  php http_server.php start -d

  Output en logs gaan nu naar logbestanden (standaard in Workerman-map of custom pad).

Procesbeheer:

Workerman ondersteunt handige commando's:

• Starten: php http_server.php start (voorgrond); php http_server.php start -d (achtergrond)
• Stoppen: php http_server.php stop (wacht verwerking netjes af)
• Herstarten: php http_server.php restart
• Reload (gecontroleerde herstart): php http_server.php reload (herstart processen één voor één, ideaal voor code-updates zonder downtime; let wel bij gebruik van onWorkerStart, etc.)
• Status: php http_server.php status (geeft inzicht in processen, memory, connecties)

Bezoek na het starten in je browser http://localhost:8080 of http://127.0.0.1:8080. Je ziet nu Hello ServBay Workerman HTTP Server! op het scherm.

Workerman gebruiken voor een WebSocket-server

WebSocket biedt een blijvende bidirectionele verbinding tussen client en server―ideaal voor realtime applicaties zoals chat, live data en games. Workerman heeft hier goede support voor.

1. WebSocket-server schrijven

   Maak een nieuw bestand websocket_server.php in je projectmap met de volgende code:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Start een WebSocket-server op poort 8081
   // 'websocket://0.0.0.0:8081' maakt en beheert handshake automatisch
   $ws_worker = new Worker('websocket://0.0.0.0:8081');
   
   // Vier processen voor performance
   $ws_worker->count = 4;
   
   // Handler bij nieuwe verbinding
   // Wordt getriggerd als een client connecteert
   $ws_worker->onConnect = function(TcpConnection $connection) {
       echo "Nieuwe WebSocket-verbinding van " . $connection->getRemoteIp() . "\n";
   };
   
   // Handler voor inkomende berichten
   // $data = bericht van client, al gedecodeerd
   $ws_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Ontvangen bericht: " . $data . "\n";
       // Stuur terug naar de client
       $connection->send('ServBay Workerman ontvangen: ' . $data);
   };
   
   // Handler bij sluiten van de verbinding
   $ws_worker->onClose = function(TcpConnection $connection) {
       echo "WebSocket-verbinding gesloten\n";
   };
   
   // Optionele handler bij fout
   $ws_worker->onError = function(TcpConnection $connection, $code, $msg) {
       echo "Fout: $code - $msg\n";
   };
   
   // Start de server
   Worker::runAll();

2. WebSocket-server starten

   Start in je projectmap met:

   php websocket_server.php start

   Je kunt -d gebruiken voor de achtergrond. Verbind vervolgens met een WebSocket-client, zoals ws://localhost:8081.

   Bijvoorbeeld, test in je browserconsole met Javascript:

   var ws = new WebSocket("ws://localhost:8081");
   
   ws.onopen = function(event) {
     console.log("WebSocket-verbinding geopend");
     ws.send("Hallo vanaf de browser!"); // Stuur bericht
   };
   
   ws.onmessage = function(event) {
     console.log("Bericht van server:", event.data); // Ontvang bericht
   };
   
   ws.onclose = function(event) {
     if (event.wasClean) {
       console.log("Netjes gesloten, code=" + event.code + " reden=" + event.reason);
     } else {
       console.error("WebSocket-verbinding gecrasht");
     }
   };
   
   ws.onerror = function(error) {
     console.error("WebSocket-fout:", error);
   };
   
   // Verbind sluiten (optioneel)
   // ws.close();

   Als de verbinding lukt zie je statusoutput in de terminal, en ontvang je echo's van de server in je browser.

Een TCP-server maken met Workerman

Workerman bouwt ook generieke TCP-servers, nuttig voor bijvoorbeeld game-backends, IoT-platforms of custom communicatieprotocollen.

1. TCP-server schrijven

   Maak het bestand tcp_server.php in je projectmap en voeg deze code toe:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Start een TCP-server op poort 8082
   // 'tcp://0.0.0.0:8082'; standaard gebruikt Workerman het tekstprotocol ('\n'), of stel je eigen protocol in
   $tcp_worker = new Worker('tcp://0.0.0.0:8082');
   
   // Vier processen voor performance
   $tcp_worker->count = 4;
   
   // Handler bij nieuwe verbinding
   $tcp_worker->onConnect = function(TcpConnection $connection) {
       echo "Nieuwe TCP-verbinding van " . $connection->getRemoteIp() . "\n";
       // Verwelkomingsbericht naar klant bij connectie
       $connection->send("Welkom bij ServBay Workerman TCP Server!\n");
   };
   
   // Handler voor inkomende data
   // $data = data van client (geparsed via gekozen protocol)
   $tcp_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Ontvangen data: " . $data;
       // Echo terug naar client
       $connection->send('ServBay Workerman ontvangen: ' . $data);
   };
   
   // Handler bij sluiten van verbinding
   $tcp_worker->onClose = function(TcpConnection $connection) {
       echo "TCP-verbinding gesloten\n";
   };
   
   // Start de server
   Worker::runAll();

2. TCP-server starten

   Start de server in de projectmap:

   php tcp_server.php start

   Ook hier kun je -d gebruiken voor achtergrondmodus. Maak verbinding met een TCP-client naar localhost:8082.

   Open bijvoorbeeld een tweede terminal en gebruik telnet of nc:

   # Telnet gebruiken
   telnet localhost 8082
   
   # Of met nc (netcat)
   nc localhost 8082

   Bij verbinding zie je het welkomstbericht, en alles wat je invoert (enter na elk bericht), wordt door de server teruggestuurd.

Belangrijke aandachtspunten

• Poortgebruik: Controleer of de poorten 8080, 8081, 8082 niet al in gebruik zijn in macOS of door ServBay-projecten. Bij een conflict start Workerman niet. Gebruik bijvoorbeeld lsof -i :poort om poortgebruik te controleren.
• Firewall: Het kan zijn dat je OS-firewall extern verkeer blokkeert. Lokale verbindingen werken meestal direct, maar voor LAN-toegang moet je firewall rules instellen.
• Relatie tot ServBay webservers: Workerman draait op eigen poorten, los van Caddy of Nginx in ServBay. Het is een apart proces en verwerkt requests direct, wat ideaal is voor langlopende of asynchrone toepassingen zoals WebSocket. Caddy/Nginx zijn bedoeld voor snelle afhandeling van normale HTTP-verzoeken. Voor reverse proxy kun je ze combineren indien gewenst.
• PHP-versie: Zorg dat je PHP-versie voldoet aan de minimale eisen van Workerman. ServBay bevat meerdere PHP-versies die je kunt activeren naar projectbehoefte.
• Extra extensies: Workerman gebruikt enkele PHP-extensies voor extra performance en functionaliteit, zoals event (geeft Workerman een flinke performanceboost als geactiveerd), posix en pcntl (voor multiprocess). ServBay activeert standaard de meeste extensies, maar controleer dit wanneer je issues tegenkomt.
• Logging: In daemonmode wordt server output naar logfiles geschreven. Check deze logfiles regelmatig voor status en foutmeldingen.

Veelgestelde vragen (FAQ)

• Q: Hoe stop ik een Workerman-server?
  • A: Draait de server op de voorgrond (start), stop met Ctrl+C in je terminal. Draait de server als daemon (start -d), gebruik dan in de projectmap het commando php jouw_server_bestand.php stop.
• Q: Waarom start mijn Workerman-server niet?
  • A: De meest voorkomende reden is dat de gekozen poort al in gebruik is. Controleer de fout in de terminal―meestal zie je de oorzaak direct. Probeer een andere poort of stop het proces dat de poort gebruikt met lsof -i :poort.
• Q: Wat is het verschil tussen ServBay's Caddy/Nginx en Workerman? Wanneer gebruik ik welke?
  • A: Caddy/Nginx zijn conventionele webservers, vooral voor standaard HTTP/HTTPS requests, vaak in combinatie met PHP-FPM; een PHP-proces handelt telkens één request af. Workerman is een asynchroon PHP-netwerkframework en draait als een resident process; het kan zelf HTTP-server zijn, maar ook WebSocket, TCP etc. Het is ideaal voor hoge concurrentie, lange connecties, realtime communicatie (zoals chat, games). Gebruik Caddy/Nginx voor traditionele websites en RESTful APIs. Voor realtime apps gebruik je Workerman. Combineer ze als reverse proxy indien gewenst.
• Q: Kan ik meerdere Workerman-applicaties tegelijk draaien in ServBay?
  • A: Ja, dat kan! Elke applicatie heeft z'n eigen PHP-server en luistert op een andere poort. Je schrijft voor elke app een apart startscript en draait elke app in een eigen terminal (of als daemon). Let hierbij op poortconflicten.

Samenvatting

Met deze gids weet je nu hoe je snel Workerman-projecten bouwt, draait en beheert in ServBay, je lokale ontwikkelplatform. Dankzij de hoge efficiëntie van Workerman kun je als PHP-ontwikkelaar krachtige en moderne netwerkapplicaties ontwikkelen. ServBay, met z’n voorgeconfigureerde Composer en PHP-omgeving, laat je focussen op de businesslogica, zonder tijd te verliezen aan complexe configuraties. Of je nu een high-performance webservice bouwt, of een realtime WebSocket-applicatie―ServBay is de ideale lokale partner voor elk Workerman-project. Veel succes en plezier met het verkennen van Workerman!