Installer et Exécuter des Applications Workerman dans ServBay

Aperçu

Ce document est conçu pour guider les utilisateurs de ServBay dans la mise en place et l'exécution rapide d'applications réseau asynchrones haute performance basées sur Workerman, en utilisant l'environnement PHP intégré et Composer sur macOS et Windows. Workerman est une bibliothèque PHP robuste, idéale pour le développement de services réseau à haute concurrence tels que serveurs Web, serveurs de communication temps réel, serveurs de jeux, etc. Grâce à ServBay et sa configuration prête à l'emploi, la création d'un environnement Workerman est largement simplifiée.

Qu'est-ce que Workerman ?

Workerman est un framework de communication réseau asynchrone, open source et entièrement développé en PHP. Il repose sur un mécanisme de boucle d’événements (EventLoop) et gère l’I/O asynchrone non bloquant, ce qui lui permet de traiter efficacement un très grand nombre de connexions simultanées. Contrairement aux modèles traditionnels de développement web PHP (Apache/Nginx + PHP-FPM), les applications Workerman s’exécutent en mémoire de manière persistante et écoutent sur des ports dédiés, ce qui évite le coût lié à la destruction des processus après chaque requête, améliorant ainsi considérablement les performances et la capacité de traitement.

Avec Workerman, les développeurs peuvent facilement créer :

• Serveurs HTTP performants pouvant même remplacer Apache/Nginx pour des requêtes statiques ou dynamiques simples.
• Serveurs WebSocket temps réel, idéaux pour des chatrooms, la diffusion de données en temps réel, etc.
• Serveurs TCP/UDP pour des protocoles personnalisés.
• Outils en ligne de commande, tâches planifiées, microservices, et bien plus.

Fonctionnalités et Avantages Clés de Workerman

• Performance exceptionnelle : Architecture pilotée par les événements et I/O asynchrone non bloquante permettant de gérer des dizaines de milliers de connexions simultanées.
• Multi-protocoles : Prise en charge native des protocoles HTTP, WebSocket, TCP, UDP, avec une interface flexible pour définir vos propres protocoles personnalisés.
• Facilité d’utilisation : API claire et intuitive, rendant la programmation réseau asynchrone accessible et rapide pour les développeurs PHP.
• Évolutivité flexible : Modèle multi-processus exploitable sur CPU multi-cœurs pour un scaling horizontal et équilibrage de charge ; prise en charge directe des paquets Composer et des bibliothèques PHP existantes.
• Intégration dans l’écosystème PHP : S’imbrique naturellement dans l’environnement PHP, facilitant la gestion des dépendances via Composer.
• Mode daemon : Prise en charge du fonctionnement en arrière-plan (daemon), idéal pour la production et la haute disponibilité.

Workerman ouvre aux développeurs PHP la voie vers la création d’applications réseau haute performance, temps réel et concurrentes.

Installer l'environnement de développement Workerman avec ServBay

ServBay est un outil local tout-en-un, idéal pour les développeurs Web, qui intègre les principaux environnements d’exécution (PHP, Node.js, Python, Go, Java...) ainsi que de nombreux serveurs et bases de données (Caddy, Nginx, Apache, MySQL, PostgreSQL, MongoDB, Redis, Memcached...). Sa principale force : un environnement immédiatement prêt à l’emploi. Composer y est déjà installé et configuré, ce qui facilite grandement la gestion des projets Workerman.

Ce guide présente plusieurs exemples pratiques pour vous permettre de démarrer rapidement avec Workerman dans ServBay : un serveur HTTP basique, un serveur WebSocket et un serveur TCP.

TIP

Pour une organisation optimale et conforme aux standards ServBay, il est conseillé de stocker vos projets web locaux dans les répertoires suivants :

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

Tous les exemples de chemin dans ce document se basent sur ces dossiers.

Prérequis

Avant de commencer, vérifiez les points suivants :

1. ServBay est installé et actif : Téléchargez la version la plus récente sur le site officiel de ServBay.
2. PHP est activé dans ServBay : Depuis le panneau de contrôle ServBay, assurez-vous que la version PHP désirée est activée. Workerman requiert PHP 5.4+, avec une préférence pour les versions PHP 7.x ou 8.x pour un maximum de performances.
3. Connaissances de base en PHP et en commandes terminal : Vous devez connaître la syntaxe PHP et l’utilisation basique des outils en ligne de commande.

Installation de Workerman

1. Vérifier l'accès à Composer

Composer est inclus d’office avec ServBay. Assurez-vous que ServBay fonctionne et que PHP est activé. ServBay configure automatiquement Composer pour chaque version PHP active. Composez les commandes depuis le terminal ServBay ou un terminal système (si ServBay a ajouté PHP et Composer au PATH système).

Pour vérifier la disponibilité de Composer, lancez :

composer -v

Si Composer est bien installé et configuré dans l’environnement PHP de ServBay, la version s'affichera. Si la commande échoue, vérifiez que ServBay fonctionne ainsi que l’activation de PHP.

2. Créer le dossier de projet

Accédez au répertoire racine recommandé par ServBay, créez un dossier de projet et entrez dedans :

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

Nous créons ici un dossier nommé servbay-workerman-demo pour héberger votre projet Workerman.

3. Installer Workerman avec Composer

Depuis le dossier du projet, utilisez Composer pour installer la bibliothèque Workerman :

Chemin du projet :

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

composer require workerman/workerman

Composer téléchargera Workerman et ses dépendances dans le dossier vendor.

Programmer un serveur HTTP avec Workerman

Le serveur HTTP est l’un des usages les plus courants de Workerman, parfait pour créer des applications Web ou des API rapides et performantes.

Créez un fichier nommé http_server.php (ou tout autre nom de votre choix, ex. server.php) dans votre dossier de projet et insérez le code PHP suivant :

<?php
// Inclure l’autoloader généré par Composer pour accéder aux classes Workerman
require __DIR__ . '/vendor/autoload.php';

// Importer les classes Worker, TcpConnection, Request, Response de Workerman
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
use Workerman\Protocols\Http\Response;

// Créer une instance Worker écoutant l’adresse et le protocole souhaités
// 'http://0.0.0.0:8080' instancie un serveur HTTP sur le port 8080 toutes interfaces (local et réseau)
// 0.0.0.0 permet l’accès depuis le local ou le LAN ; 8080 est ici le port d’écoute.
$http_worker = new Worker('http://0.0.0.0:8080');

// Définir le nombre de processus Workerman démarrés
// Ici, 4 processus PHP indépendants pour une meilleure concurrence, ajustable selon vos cœurs CPU
$http_worker->count = 4;

// Définit la logique à exécuter lors de la réception d’une requête HTTP
// $connection représente la connexion cliente, utilisée pour envoyer la réponse
// $request contient les détails de la requête (URL, headers, corps, etc.)
$http_worker->onMessage = function(TcpConnection $connection, Request $request) {
    // Envoie une chaîne simple en réponse HTTP
    // Workerman prend en charge la construction de la réponse HTTP standard
    $connection->send(new Response(200, [], 'Hello ServBay Workerman HTTP Server!'));
};

// Démarrer la boucle principale Workerman pour écouter et traiter les événements
Worker::runAll();

Explications du code :

• require __DIR__ . '/vendor/autoload.php';: Charge l’autoloader Composer pour activer les classes Workerman (Worker, Request, Response ...).
• use Workerman\...;: Importe les classes nécessaires.
• new Worker('http://0.0.0.0:8080'): Crée l’instance Workerman en spécifiant protocole et adresse d’écoute.
• $http_worker->count = 4;: Définit le nombre de processus pour exploiter tous les cœurs CPU possibles.
• $http_worker->onMessage = function(TcpConnection $connection, Request $request) { ... };: Callback déclenché à chaque requête HTTP complète, permettant d’accéder à la connexion et à la requête client.
• Worker::runAll();: Lance la boucle Workerman, vos workers commencent à écouter et gérer les connexions.

Lancer le serveur HTTP Workerman

Dans le dossier de projet, ouvrez le terminal et exécutez la commande suivante pour démarrer le serveur HTTP :

Chemin du projet :

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

php http_server.php start

Modes de fonctionnement :

• Mode premier plan (Foreground) : Avec php http_server.php start, Workerman s’exécute au premier plan, le terminal affiche les logs ; arrêtez par Ctrl+C. Idéal pour le développement et le debug.
• Mode daemon (arrière-plan) : Pour la production, préférez -d :

  php http_server.php start -d

  Workerman tournera discrètement, avec les logs redirigés vers un fichier.

Gestion des processus :

Workerman propose des commandes pratiques :

• Démarrer : php http_server.php start (premier plan) ou php http_server.php start -d (arrière-plan)
• Arrêter : php http_server.php stop (arrêt propre après traitement des requêtes)
• Redémarrer : php http_server.php restart
• Redémarrage doux (Reload) : php http_server.php reload (utile lors de mises à jour, redémarrage progressif sans interruption de service ; attention cependant à l’usage des hooks comme onWorkerStart)
• Voir le statut : php http_server.php status (affiche statut, mémoire, connexions...)

Après démarrage, ouvrez votre navigateur sur http://localhost:8080 ou http://127.0.0.1:8080 : le serveur affiche Hello ServBay Workerman HTTP Server!.

Créer un serveur WebSocket avec Workerman

Le protocole WebSocket permet des interactions bidirectionnelles persistantes entre client et serveur, parfait pour le temps réel (chat, push, jeu...). Workerman gère nativement WebSocket.

1. Écriture du code serveur WebSocket

   Dans le dossier projet, créez websocket_server.php avec :

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Créer le serveur WebSocket sur le port 8081
   // 'websocket://0.0.0.0:8081' instancie le serveur WebSocket
   $ws_worker = new Worker('websocket://0.0.0.0:8081');
   
   // Lancer 4 processus pour gérer les connexions
   $ws_worker->count = 4;
   
   // Logique à l’établissement de connexion
   // Déclenché à chaque nouvelle connexion client
   $ws_worker->onConnect = function(TcpConnection $connection) {
       echo "Nouvelle connexion WebSocket depuis " . $connection->getRemoteIp() . "\n";
   };
   
   // Logique à la réception de message
   // À chaque message WebSocket reçu du client
   $ws_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Message reçu : " . $data . "\n";
       // Echo au client
       $connection->send('ServBay Workerman reçu : ' . $data);
   };
   
   // Logique à la fermeture de connexion
   $ws_worker->onClose = function(TcpConnection $connection) {
       echo "Connexion WebSocket fermée\n";
   };
   
   // Gestion des erreurs (optionnelle)
   $ws_worker->onError = function(TcpConnection $connection, $code, $msg) {
       echo "Erreur : $code - $msg\n";
   };
   
   
   // Démarrer tous les workers
   Worker::runAll();

2. Démarrer le serveur WebSocket

   Dans le dossier projet, lancez :

   php websocket_server.php start

   Vous pouvez aussi utiliser -d pour un mode daemon. Une fois lancé, connectez votre client WebSocket à ws://localhost:8081.

   Exemple de test rapide en console navigateur (JavaScript) :

   var ws = new WebSocket("ws://localhost:8081");
   
   ws.onopen = function(event) {
     console.log("Connexion WebSocket ouverte");
     ws.send("Bonjour depuis le navigateur !");
   };
   
   ws.onmessage = function(event) {
     console.log("Réponse serveur :", event.data);
   };
   
   ws.onclose = function(event) {
     if (event.wasClean) {
       console.log("Connexion WebSocket fermée proprement, code=" + event.code + " raison=" + event.reason);
     } else {
       console.error("La connexion WebSocket est morte");
     }
   };
   
   ws.onerror = function(error) {
     console.error("Erreur WebSocket :", error);
   };
   
   // ws.close(); // pour fermer (optionnel)

   En cas de succès, les logs côté serveur et navigateur s’affichent, le message est renvoyé.

Créer un serveur TCP avec Workerman

Workerman permet aussi de créer des serveurs TCP génériques, utiles pour vos protocoles applicatifs divers (jeux, IoT, communication personnalisée...).

1. Écriture du code serveur TCP

   Dans le dossier projet, créez tcp_server.php :

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Instancier un serveur TCP sur le port 8082
   // 'tcp://0.0.0.0:8082' pour serveur TCP
   // Workerman utilise le protocole texte (fin de ligne '\n') par défaut, mais vous pouvez le personnaliser
   $tcp_worker = new Worker('tcp://0.0.0.0:8082');
   
   // Lancer 4 processus pour gérer les connexions
   $tcp_worker->count = 4;
   
   // Logique à l’établissement de connexion
   $tcp_worker->onConnect = function(TcpConnection $connection) {
       echo "Nouvelle connexion TCP depuis " . $connection->getRemoteIp() . "\n";
       // À la connexion, envoyer un message de bienvenue
       $connection->send("Bienvenue sur le serveur TCP ServBay Workerman!\n");
   };
   
   // Logique à la réception des données
   // $data correspond aux données TCP (déjà décodées selon le protocole)
   $tcp_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Donnée reçue : " . $data;
       // Echo au client
       $connection->send('ServBay Workerman reçu : ' . $data);
   };
   
   // Logique à la fermeture de connexion
   $tcp_worker->onClose = function(TcpConnection $connection) {
       echo "Connexion TCP fermée\n";
   };
   
   // Démarrer tous les workers
   Worker::runAll();

2. Démarrer le serveur TCP

   Dans le dossier projet, lancez :

   php tcp_server.php start

   Utilisez -d pour le mode arrière-plan. Pour tester, connectez un client TCP à localhost:8082.

   En terminal, par exemple :

   # Avec telnet
   telnet localhost 8082
   
   # Ou netcat
   nc localhost 8082

   Une fois connecté, le serveur enverra son message de bienvenue. Toute ligne entrée (suivie de retour chariot) sera réécho par le serveur.

Points d’attention

• Occupation des ports : Vérifiez que vos ports (8080, 8081, 8082 dans les exemples) ne sont pas déjà utilisés par macOS ou un autre service ServBay, sinon Workerman échouera au démarrage. Utilisez lsof -i :numéro_de_port pour contrôler l’utilisation.
• Pare-feu : Le firewall système peut limiter l’accès externe à ces ports. En développement local, c’est rarement bloquant, mais pour un accès via réseau local, vérifiez et ajustez les règles du pare-feu.
• Indépendance par rapport aux serveurs Web ServBay : Workerman écoute sur ses propres ports et fonctionne en processus séparé du Caddy/Nginx intégré à ServBay. Workerman gère directement les connexions (sauf si vous configurez un reverse-proxy). Il est vivement recommandé pour les applications haute concurrence, connexions longues ou temps réel. Les serveurs Web traditionnels ServBay servent plutôt les usages HTTP courts classiques.
• Version PHP : Vérifiez que la version PHP active dans ServBay est compatible avec Workerman (min. 5.4). ServBay offre plusieurs versions parmi lesquelles choisir selon vos besoins.
• Extensions PHP requises : Workerman exploite certaines extensions (comme event pour accelerator les performances, posix, pcntl pour la gestion des processus). ServBay active d’office les plus courantes, vérifiez en cas de problème dans le panneau ServBay.
• Logs : En mode daemon, Workerman écrit ses logs dans des fichiers. Pensez à consulter régulièrement les logs pour surveiller l’état de votre application et détecter d’éventuelles erreurs.

FAQ

• Q : Comment arrêter le serveur Workerman ?
  • R : Si le serveur tourne au premier plan (start), arrêtez-le via Ctrl+C dans votre terminal. En mode daemon (start -d), utilisez dans le dossier projet : php nom_du_fichier_serveur.php stop.
• Q : Pourquoi mon serveur Workerman ne démarre-t-il pas ?
  • R : Le cas le plus fréquent : port d’écoute déjà utilisé. Vérifiez le message d’erreur dans le terminal ; choisissez un port libre ou arrêtez le service concurrent. La commande lsof -i :numéro_de_port vous indique quel processus occupe le port.
• Q : Quelle différence entre Caddy/Nginx ServBay et Workerman ? Quand utiliser l’un ou l’autre ?
  • R : Caddy et Nginx sont des serveurs Web traditionnels, parfaits pour les requêtes HTTP/HTTPS classiques avec PHP-FPM, et des processus PHP souvent courts. Workerman est un framework réseau asynchrone : il peut servir du HTTP (processus PHP toujours en mémoire pour haut débit), ainsi que le WebSocket et TCP. Privilégiez Caddy/Nginx pour un site classique ou REST API ; Workerman pour le chat, jeu temps réel, IoT, etc. Une combinaison est possible (reverse-proxy Caddy/Nginx vers Workerman).
• Q : Peut-on faire tourner plusieurs applications Workerman en parallèle dans ServBay ?
  • R : Oui. Chaque application doit être lancée depuis un script dédié, sur des ports distincts, dans des processus PHP séparés. Il suffit de lancer chaque serveur dans un terminal différent ou en mode daemon, sans conflit de ports.

Conclusion

Avec ce guide, vous savez désormais comment installer et exécuter des projets Workerman dans ServBay. Workerman apporte la puissance du PHP asynchrone haute performance pour vos applications réseaux. Grâce à l’environnement prêt-à-l’emploi de ServBay, vous déployez et développez vos applications Workerman en local en toute simplicité, en vous concentrant sur la logique métier sans les tracas de configuration. Que vous développiez des services Web rapides ou des applications WebSocket interactives, ServBay est le partenaire idéal pour explorer tout le potentiel de Workerman. Bonne découverte !