Workerman Applicaties Opzetten en Draaien in ServBay

Overzicht

Dit document is bedoeld om ServBay gebruikers te begeleiden bij het snel opzetten en draaien van high-performance, asynchrone Workerman netwerktoepassingen in een lokale macOS ontwikkelomgeving, gebruikmakend van de geïntegreerde PHP- en Composer-omgeving van ServBay. Workerman is een krachtige PHP-bibliotheek, geschikt voor het bouwen van uiteenlopende netwerkservices die hoge gelijktijdigheid vereisen, zoals webservers, realtime communicatieservers, en gameservers. ServBay biedt een kant-en-klare ontwikkelomgeving en vereenvoudigt de Workerman-configuratie aanzienlijk.

Wat is Workerman?

Workerman is een open source, volledig in PHP geschreven high-performance asynchroon netwerkframework. Het is gebaseerd op een EventLoop event-driven architectuur die efficiënte, niet-blokkerende I/O afhandelt en zodoende tienduizenden gelijktijdige verbindingen kan verwerken. In tegenstelling tot het traditionele PHP webontwikkelingsmodel (zoals Apache/Nginx + PHP-FPM), draaien Workerman-applicaties doorgaans resident in het geheugen, luisteren ze op specifieke poorten en verwerken zij direct netwerkverbindingen en -data. Hierdoor wordt de overhead van procescreatie per request geëlimineerd en worden prestaties en throughput aanzienlijk verbeterd.

Met Workerman kunnen ontwikkelaars eenvoudig:

• High-performance HTTP-servers bouwen die zelfs eenvoudige Apache/Nginx-taakstellingen kunnen overnemen.
• Real-time WebSocket servers realiseren voor bijvoorbeeld chatoepeningen of live data-pushes.
• TCP/UDP servers voor op maat gemaakte protocollen creëren.
• Command-line tools, geplande taken, microservices, en meer ontwikkelen.

Kernfeatures en Voordelen van Workerman

• Hoge prestaties: Gebaseerd op event-driven en asynchrone I/O voor het afhandelen van enorme aantallen gelijktijdige connecties en uitstekende prestaties.
• Multi-protocol ondersteuning: Native ondersteuning voor HTTP, WebSocket, TCP, UDP, en uitbreidbare interfaces voor maatwerkprotocollen.
• Gebruiksgemak: Eenvoudige en toegankelijke API die de complexiteit van asynchrone netwerkprogrammering minimaliseert; PHP-ontwikkelaars kunnen snel aan de slag.
• Flexibele schaalbaarheid: Ondersteunt een multiprocess-model waarmee multi-core CPU's efficiënt gebruikt, horizontaal geschaald en load balanced kunnen worden. Integratie met Composer en bestaande PHP-libraries gaat moeiteloos.
• Integratie met PHP-ecosysteem: Naadloze aansluiting op bestaande PHP-packages en dependency management dankzij Composer.
• Daemon-modus: Ondersteuning voor stabiel draaien als achtergrondproces (daemon), ideaal voor productiegebruik en het waarborgen van service-uptime.

Workerman ontgrendelt de deur naar high-performance, real-time en schaalbare netwerkapplicaties voor PHP-ontwikkelaars.

Workerman Ontwikkelomgeving Bouwen met ServBay

ServBay is een speciaal ontwikkelde lokale ontwikkelomgeving voor webontwikkelaars, met geïntegreerde runtimes voor PHP, Node.js, Python, Go, Java en meer, evenals populaire databases en servers als Caddy, Nginx, Apache, MySQL, PostgreSQL, MongoDB, Redis en Memcached. De kracht van ServBay zit in het kant-en-klare karakter, met een vooraf ingestelde Composer-omgeving die de installatie en het gebruik van Workerman-projecten sterk vergemakkelijkt.

Deze gids demonstreert het snel opzetten en uitvoeren van Workerman-applicaties in ServBay aan de hand van enkele basisvoorbeelden: een HTTP-server, een WebSocket-server en een TCP-server.

TIP

Ter bevordering van beheer en consistentie raadt ServBay aan alle lokale projectbestanden te plaatsen in de /Applications/ServBay/www map. Alle voorbeeldpaden in dit document zijn hierop gebaseerd.

Vereisten

Controleer of je aan de volgende voorwaarden voldoet:

1. ServBay is geïnstalleerd en actief: Download en installeer de laatste versie van ServBay via de officiële website.
2. PHP is ingeschakeld in ServBay: Controleer in de ServBay-controlpanel dat je gewenste PHP-versie is geactiveerd. Workerman vereist minimaal PHP 5.4, maar PHP 7.x of 8.x wordt aanbevolen voor optimale prestaties.
3. Basiskennis PHP en command line: Je dient bekend te zijn met PHP-syntaxis en basishandelingen in de terminal.

Workerman Installeren

1. Controleer Composer Beschikbaarheid

Composer is standaard inbegrepen in ServBay. Je hoeft dus niets extra te installeren. Let er wel op dat ServBay is gestart en je beoogde PHP-versie actief is. Composer wordt automatisch geconfigureerd voor de geselecteerde PHP-versie. Gebruik het ServBay terminalvenster of een externe terminal (indien ServBay PHP en Composer aan je PATH toevoegde) om Composer-commando’s uit te voeren.

Open een terminal en voer uit:

composer -v

Als Composer correct is geconfigureerd in ServBay, zie je versiedetails verschijnen. Krijg je een foutmelding over een onbekend commando, controleer dan of ServBay goed draait en de juiste PHP-versie aan staat.

2. Maak een Projectmap aan

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

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

We creëren dus de map servbay-workerman-demo voor het Workerman-project.

3. Installeer Workerman met Composer

Installeer Workerman in je projectdirectory (/Applications/ServBay/www/servbay-workerman-demo) met Composer:

composer require workerman/workerman

Composer downloadt Workerman en zijn afhankelijkheden naar de vendor-map van het project.

HTTP-server Schrijven met Workerman

Een HTTP-server is een van de meest voorkomende Workerman-toepassingen en ideaal voor snelle webapps of API-services.

Maak in de projectdirectory een bestand aan, bijvoorbeeld http_server.php (of een eigen naam zoals server.php), en voeg deze PHP-code toe:

<?php
// Laad het autoload-bestand van Composer zodat Workerman-klassen beschikbaar zijn
require __DIR__ . '/vendor/autoload.php';

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

// Maak een Worker-instantie aan en geef protocol en adres op
// 'http://0.0.0.0:8080' betekent dat de HTTP-server draait op poort 8080 op alle netwerkintefaces
// 0.0.0.0 maakt toegang mogelijk vanaf localhost én andere apparaten in het netwerk; 8080 is de poort
$http_worker = new Worker('http://0.0.0.0:8080');

// Stel het aantal worker-processen in
// Hier op 4, dus starten er vier onafhankelijke PHP-processen voor requestafhandeling. Pas aan op basis van je CPU-cores
$http_worker->count = 4;

// Logica voor wanneer een client een bericht (HTTP-request) stuurt
// $connection is het actieve connectieobject voor respons; $request bevat requestdetails (URL, headers, body, etc.)
$http_worker->onMessage = function(TcpConnection $connection, Request $request) {
    // Stuur een eenvoudige string als HTTP-respons naar de client
    // Workerman verzorgt automatisch HTTP-headers en andere details
    $connection->send(new Response(200, [], 'Hello ServBay Workerman HTTP Server!'));
};

// Start alle Worker-instanties
// Dit is de hoofdloop van Workerman; workers gaan nu luisteren op poorten en handelen events af
Worker::runAll();

Uitleg bij de code:

• require __DIR__ . '/vendor/autoload.php';: Laadt het Composer autoload bestand, waardoor Workerman-klassen (Worker, Request, Response, enz.) bruikbaar worden.
• use Workerman\...;: Importeren van benodigde klassen.
• new Worker('http://0.0.0.0:8080'): Workerman worker aanmaken met HTTP-protocol en poort.
• $http_worker->count = 4;: Aantal processen, benutting van multi-core verhoogt de gelijktijdigheid.
• $http_worker->onMessage = function(...){}: Callback bij ontvangen HTTP-request; $connection handelt respons af, $request bevat informatie over de request. Response bouwt de HTTP-response.
• Worker::runAll();: Start het event loopmechanisme, zodat alle workers verbindingen accepteren en afhandelen.

Workerman HTTP-server Opstarten

Ga in je projectdirectory (/Applications/ServBay/www/servbay-workerman-demo) naar de terminal en start de server met:

php http_server.php start

Over de uitvoermodi:

• Voorgrondmodus (Foreground): Met php http_server.php start draait Workerman direct in de terminal met live logoutput. Stoppen doe je met Ctrl+C. Geschikt voor ontwikkeling en debugging.
• Daemonmodus (Achtergrond): Voor productiegebruik en continu draaien op de achtergrond, gebruik je de -d parameter:

  php http_server.php start -d

  Workerman draait dan als achtergrondproces, met logoutput naar logbestanden in de Workerman-map of opgegeven locatie.

Procesbeheer:

Workerman biedt handige managementcommando's:

• Starten: php http_server.php start (voorgrond) of php http_server.php start -d (achtergrond)
• Stoppen: php http_server.php stop (wacht netjes huidige requests af voor afsluiten)
• Herstarten: php http_server.php restart (stopt en start opnieuw)
• Vloeiende herstart: php http_server.php reload (voor code-updates; herstart processen één voor één zonder downtime; check gebruik van onWorkerStart en andere levenscyclusfuncties)
• Status bekijken: php http_server.php status (voor status, geheugengebruik, connecties, etc.)

Start de server, open een browser en bezoek http://localhost:8080 of http://127.0.0.1:8080. Je ziet de tekst Hello ServBay Workerman HTTP Server!.

WebSocket-server Bouwen met Workerman

Het WebSocket-protocol maakt een permanente, tweerichtingsverbinding mogelijk tussen client en server, ideaal voor real-time toepassingen als chat, live datafeeds en games. Workerman heeft uitstekende WebSocket-ondersteuning.

1. Schrijf de WebSocket-server

   Maak het bestand websocket_server.php aan in je projectmap en voeg deze code in:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // WebSocket-serverinstance aanmaken op poort 8081
   // 'websocket://0.0.0.0:8081' - Workerman verzorgt zelf de handshake
   $ws_worker = new Worker('websocket://0.0.0.0:8081');
   
   // Start 4 processen voor connectiebeheer
   $ws_worker->count = 4;
   
   // Logica bij nieuwe verbindingen
   // Triggered als een client verbindt
   $ws_worker->onConnect = function(TcpConnection $connection) {
       echo "Nieuwe WebSocket-verbinding van " . $connection->getRemoteIp() . "\n";
   };
   
   // Logica bij ontvangen berichten
   // Voert uit als een bericht van de client binnenkomt; $data is het gedecodeerde bericht
   $ws_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Ontvangen bericht: " . $data . "\n";
       // Echo het bericht terug naar de client
       $connection->send('ServBay Workerman ontvangen: ' . $data);
   };
   
   // Logica bij het sluiten van de verbinding
   $ws_worker->onClose = function(TcpConnection $connection) {
       echo "WebSocket verbinding gesloten\n";
   };
   
   // Optionele foutafhandelaar
   $ws_worker->onError = function(TcpConnection $connection, $code, $msg) {
       echo "Fout: $code - $msg\n";
   };
   
   // Start alle worker-processen
   Worker::runAll();

2. WebSocket-server starten

   In de projectmap kun je de WebSocket-server starten met:

   php websocket_server.php start

   Voeg indien gewenst -d toe om op de achtergrond te draaien. Na het starten kun je met een WebSocket client verbinden op ws://localhost:8081.

   Testen kan bijvoorbeeld met JavaScript in de browserconsole:

   var ws = new WebSocket("ws://localhost:8081");
   
   ws.onopen = function(event) {
     console.log("WebSocket verbinding geopend");
     ws.send("Hallo vanuit de browser!"); // bericht versturen
   };
   
   ws.onmessage = function(event) {
     console.log("Bericht van de server:", event.data); // bericht ontvangen
   };
   
   ws.onclose = function(event) {
     if (event.wasClean) {
       console.log("Schone WebSocket sluiting, code=" + event.code + " reden=" + event.reason);
     } else {
       console.error("WebSocket verbinding abrupt beëindigd");
     }
   };
   
   ws.onerror = function(error) {
     console.error("WebSocket fout:", error);
   };
   
   // Verbinding sluiten (optioneel)
   // ws.close();

   Na succesvolle verbinding zie je connectieberichten in je terminal verschijnen; stuur je een bericht, ontvang je direct een echo terug van de server.

TCP-server Bouwen met Workerman

Workerman kan ook algemene TCP-servers aanbieden, geschikt voor eigen protocoltoepassingen, games back-ends, IoT-platforms of aangepaste communicatiediensten.

1. Schrijf de TCP-server

   Maak tcp_server.php aan in het project en voeg de volgende code toe:

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // TCP-server op poort 8082; standaard Text-protocol (einde met '\n'), maar kan aangepast naar wens
   $tcp_worker = new Worker('tcp://0.0.0.0:8082');
   
   // Vier processen voor connectiebeheer
   $tcp_worker->count = 4;
   
   // Nieuwe verbinding: verwelkoming sturen
   $tcp_worker->onConnect = function(TcpConnection $connection) {
       echo "Nieuwe TCP-verbinding van " . $connection->getRemoteIp() . "\n";
       $connection->send("Welkom bij de ServBay Workerman TCP server!\n");
   };
   
   // Berichten ontvangen en terugsturen
   $tcp_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Ontvangen data: " . $data;
       $connection->send('ServBay Workerman ontvangen: ' . $data);
   };
   
   // Verbinding gesloten
   $tcp_worker->onClose = function(TcpConnection $connection) {
       echo "TCP-verbinding gesloten\n";
   };
   
   // Start alle worker-processen
   Worker::runAll();

2. TCP-server starten

   Start de TCP-server:

   php tcp_server.php start

   Je kunt de server ook in de achtergrond draaien met -d. Gebruik een TCP-client om te verbinden via localhost:8082.

   Voorbeeld met telnet of nc (netcat) op macOS/Linux:

   # met telnet
   telnet localhost 8082
   
   # of met nc (netcat)
   nc localhost 8082

   Na verbinding zie je een welkomstbericht. Typ tekst (afgesloten met Enter; standaard Text-protocol), en de server zal dit terugsturen.

Belangrijke Aandachtspunten

• Poortbezetting: Zorg dat de poorten die Workerman gebruikt (in deze voorbeelden 8080, 8081, 8082) niet al in gebruik zijn door macOS of andere ServBay-diensten. Anders start Workerman niet en krijg je een foutmelding. Check poortgebruik bijvoorbeeld met lsof -i :poortnummer.
• Firewall: De macOS-firewall kan inkomende verbindingen blokkeren. In de lokale omgeving vormt dit meestal geen probleem, maar als je verbinding wilt vanaf andere LAN-apparaten, zorg dan dat de firewallinstellingen goed staan.
• Relatie met ServBay’s webservers: Workerman draait op eigen poorten en is volledig onafhankelijk van de Caddy of Nginx processen binnen ServBay. Een Workerman-app handelt verbindingen zelfstandig af—zonder tussenkomst van Caddy/Nginx—tenzij je handmatig een reverse proxy instelt. Workerman is ideaal voor langdurige connecties of hoge gelijktijdigheid (zoals WebSocket); Caddy/Nginx zijn traditioneel bedoeld voor kortdurende HTTP-requests.
• PHP-versie: Controleer dat je PHP-versie in ServBay voldoet aan de minimaal vereiste Workerman-versie. ServBay ondersteunt meerdere PHP-versies; kies en activeer de juiste in het controlpanel.
• Vereiste extensies: Workerman gebruikt bepaalde PHP-extensies voor optimale werking, bijvoorbeeld event (voor beste prestaties), posix, en pcntl (voor multiprocess-mode). ServBay schakelt de meeste doorgaans in, maar controleer en activeer desgewenst aanvullende extensies via het controlpanel.
• Logging: In daemonmodus worden logs naar logbestanden geschreven; controleer regelmatig de logs voor applicatiestatus of mogelijke fouten.

Veelgestelde Vragen (FAQ)

• Q: Hoe stop ik een Workerman-server?
  • A: Draait de server op de voorgrond (start), stop dan eenvoudig met Ctrl+C. In de achtergrond (start -d) stop je met php your_server_file.php stop vanuit de projectmap.
• Q: Waarom start mijn Workerman-server niet op?
  • A: Meestal omdat de gekozen poort al bezet is. Check de foutmelding: doorgaans geeft deze precies aan welke poort de boosdoener is. Kies een andere poort of stop het andere proces via lsof -i :poortnummer.
• Q: Wat is het verschil tussen ServBay’s Caddy/Nginx en Workerman? Wanneer kies ik wat?
  • A: Caddy en Nginx in ServBay bieden traditioneel HTTP/HTTPS webserverfunctionaliteit en werken doorgaans samen met PHP-FPM. Na ieder request eindigt het PHP-proces mogelijk. Workerman is een asynchroon PHP-netwerkframework, draait resident in het geheugen en kan eigen HTTP, WebSocket en TCP-servers aanbieden—ideaal voor real-time en schaalbare toepassingen. Voor klassieke websites en API’s kies je doorgaans Caddy/Nginx; voor real-time communicatie, chat, games of IoT liever Workerman. Ze kunnen ook gecombineerd worden, bijvoorbeeld met reverse proxy naar Workerman.
• Q: Kan ik meerdere Workerman-apps tegelijk draaien in ServBay?
  • A: Ja, ieder Workerman-project draait als onafhankelijk PHP-proces en luistert op een eigen poort. Start ze met aparte scripts en zorg dat poorten niet overlappen; draai gerust meerdere servers naast elkaar in verschillende terminalvensters.

Samenvatting

Deze gids heeft uitgelegd hoe je snel een Workerman-project opzet en uitvoert in ServBay, een krachtige lokale ontwikkelomgeving. Dankzij Workerman’s asynchrone architectuur en hoge prestaties zet je als PHP-ontwikkelaar in een handomdraai moderne, schaalbare netwerktoepassingen neer. Met het kant-en-klare PHP- en Composer-platform van ServBay hoef je je geen zorgen te maken over moeizame configuratie: jij focust op de businesslogica van je Workerman-project. Of je nu webservices met veel verkeer of real-time WebSocket-applicaties bouwt: ServBay is jouw ideale Workerman-partner. Veel succes en plezier met jouw Workerman-avontuur!