Déployer et exécuter des applications Workerman avec ServBay

Vue d’ensemble

Ce document a pour objectif de guider les utilisateurs de ServBay dans la mise en place rapide et locale, sur macOS, d’applications réseau asynchrones haute performance basées sur Workerman, en profitant de l’environnement PHP et de Composer intégrés à ServBay. Workerman est une puissante bibliothèque PHP idéale pour la construction de services réseau à forte concurrence tels que les serveurs Web, les serveurs de communication temps réel, les serveurs de jeux, etc. ServBay offre une plateforme de développement prête à l’emploi qui simplifie grandement la configuration de l’environnement nécessaire à Workerman.

Qu’est-ce que Workerman ?

Workerman est un framework open source de communication réseau asynchrone, entièrement écrit en PHP. Basé sur la boucle d’événements (EventLoop), il réalise des entrées/sorties asynchrones et non bloquantes, permettant de gérer efficacement de nombreuses connexions concurrentes. Contrairement au modèle traditionnel de développement PHP Web (par exemple Apache/Nginx + PHP-FPM), Workerman fonctionne en processus résidents en mémoire, écoutant un port spécifique et traitant directement les connexions réseau, évitant ainsi la surcharge due à la création/destruction de processus pour chaque requête et améliorant significativement la performance et le débit.

Grâce à Workerman, les développeurs peuvent facilement créer :

• Des serveurs HTTP haute performance, pouvant même remplacer Apache/Nginx pour des requêtes statiques ou dynamiques simples.
• Des serveurs WebSocket temps réel pour des applications de chat, de push de données en temps réel, etc.
• Des serveurs TCP/UDP personnalisés pour tout type de protocole.
• Des outils en ligne de commande, tâches planifiées, microservices, et bien plus.

Principales fonctionnalités et avantages de Workerman

• Haute performance : Basé sur un moteur d’événements et des E/S asynchrones non bloquantes, Workerman peut gérer un grand nombre de connexions simultanées tout en offrant des performances exceptionnelles.
• Support Multi-Protocole : Prise en charge native de nombreux protocoles réseau courants tels que HTTP, WebSocket, TCP, UDP, et interfaces flexibles pour des protocoles personnalisés.
• Simplicité d’utilisation : API intuitive et facile à prendre en main, simplifiant la programmation réseau asynchrone pour les développeurs PHP.
• Extension Flexible : Modèle multi-processus permettant l’utilisation optimale des CPU multi-cœurs pour la montée en charge et la répartition de charge. Intégration aisée de packages Composer et de bibliothèques PHP existantes.
• Intégration à l’écosystème PHP : En tant que bibliothèque PHP, Workerman s’intègre parfaitement à l’écosystème existant et permet une gestion fluide des dépendances via Composer.
• Mode Démon (Daemon) : Possibilité de lancer Workerman en arrière-plan, idéal pour la production et une haute disponibilité continue des services.

Workerman ouvre aux développeurs PHP la porte des applications réseau modernes, haute performance et temps réel.

Installer un environnement Workerman avec ServBay

ServBay est un outil d’environnement de développement local conçu pour les développeurs Web, intégrant les principaux runtimes : PHP, Node.js, Python, Go, Java, ainsi que des bases de données et serveurs populaires tels que Caddy, Nginx, Apache, MySQL, PostgreSQL, MongoDB, Redis, Memcached, etc. L’un de ses plus grands atouts est la configuration “prête à l’emploi”, notamment la présence et la configuration automatique de Composer, ce qui facilite considérablement l’installation et l’exécution de Workerman.

Dans ce guide, nous allons créer quelques exemples de base pour illustrer la manière de configurer et d’exécuter rapidement des applications Workerman dans l’environnement ServBay, notamment un serveur HTTP simple, un serveur WebSocket et un serveur TCP.

TIP

Pour faciliter la gestion et assurer l’uniformité, il est recommandé de stocker tous les projets de sites locaux dans le répertoire /Applications/ServBay/www. Tous les chemins de projet dans ce guide sont basés sur ce dossier.

Prérequis

Avant de commencer, assurez-vous des points suivants :

1. ServBay est installé et fonctionne correctement : Téléchargez et installez la dernière version de ServBay sur le site officiel.
2. PHP est activé dans ServBay : Dans le panneau de contrôle ServBay, vérifiez que la version PHP souhaitée est activée. Workerman nécessite au moins PHP 5.4 ; il est conseillé d’utiliser PHP 7.x ou 8.x pour des performances optimales.
3. Bases en PHP et en ligne de commande : Vous devez connaître les fondamentaux de PHP et être à l’aise avec l’utilisation du terminal.

Installer Workerman

1. Vérifier la disponibilité de Composer

Composer est déjà inclus dans ServBay ; aucune installation supplémentaire n’est requise. Il vous suffit de lancer ServBay, d’activer la version PHP désirée, puis d’accéder au terminal ServBay ou d’utiliser un terminal externe (si PHP et Composer sont ajoutés au PATH système via ServBay).

Ouvrez un terminal et tapez pour vérifier la disponibilité de Composer :

composer -v

Si Composer est correctement installé et configuré avec PHP dans ServBay, vous verrez la version affichée. Sinon, vérifiez que ServBay est lancé et que PHP est bien activé.

2. Créer le dossier du projet

Allez dans le dossier racine recommandé par ServBay, créez et accédez à un nouveau dossier de projet :

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

Ici, le dossier servbay-workerman-demo accueillera votre projet Workerman.

3. Installer Workerman via Composer

Dans le dossier projet (/Applications/ServBay/www/servbay-workerman-demo), installez Workerman avec Composer (c’est la méthode recommandée, Composer gérera automatiquement les dépendances) :

composer require workerman/workerman

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

Écrire le code d’un serveur HTTP Workerman

Le serveur HTTP est l’un des usages les plus courants de Workerman, utile pour développer des applications Web ou des APIs performantes.

Dans le dossier projet, créez un fichier nommé http_server.php (ou tout autre nom de votre choix, comme server.php), puis ajoutez le code PHP suivant :

<?php
// Inclure le fichier d’autoload Composer pour utiliser les classes Workerman
require __DIR__ . '/vendor/autoload.php';

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

// Créer une instance Worker, spécifier le protocole et l’adresse écoutée
// 'http://0.0.0.0:8080' : serveur HTTP sur toutes les interfaces (0.0.0.0) port 8080
// 0.0.0.0 autorise l’accès aussi depuis d’autres appareils du réseau local
$http_worker = new Worker('http://0.0.0.0:8080');

// Définir le nombre de processus Worker
// Ici, on crée 4 processus PHP distincts pour gérer les requêtes (adaptez à votre CPU)
$http_worker->count = 4;

// Définir la logique de traitement quand un message client (requête HTTP) est reçu
// $connection : objet de la connexion courante, utilisé pour envoyer la réponse
// $request : objet de la requête courante (URL, Headers, Body, ...)
$http_worker->onMessage = function(TcpConnection $connection, Request $request) {
    // Envoyer une simple chaîne en réponse HTTP au client
    // Workerman s’occupe automatiquement des headers HTTP, etc.
    $connection->send(new Response(200, [], 'Hello ServBay Workerman HTTP Server!'));
};

// Lancer tous les Worker définis
// Ceci démarre la boucle principale de Workerman, écoute le port et traite les événements
Worker::runAll();

Explications du code :

• require __DIR__ . '/vendor/autoload.php'; : Charge l’autoloader Composer pour accéder aux classes de Workerman.
• use Workerman\...; : Importation des classes nécessaires.
• new Worker('http://0.0.0.0:8080') : Crée une instance Worker écoutant en HTTP sur le port 8080.
• $http_worker->count = 4; : Définit le nombre de processus Workerman (adaptez selon les cœurs CPU disponibles).
• $http_worker->onMessage = function(...) { ... }; : Callback exécuté à la réception d’une requête HTTP, l’objet $connection sert à envoyer la réponse, $request contient la requête. La classe Response formate une réponse HTTP standard.
• Worker::runAll(); : Lance le processus principal Workerman afin de gérer les connexions entrantes.

Lancer le serveur HTTP Workerman

Dans le dossier projet (/Applications/ServBay/www/servbay-workerman-demo), ouvrez un terminal et exécutez :

php http_server.php start

À propos des modes d’exécution :

• Mode premier-plan : Avec php http_server.php start, Workerman s’exécute au premier-plan, affichant logs et infos dans le terminal. Utilisez Ctrl+C pour stopper. Mode idéal pour le développement.
• Mode démon (arrière-plan) : Pour la production, ajoutez l’option -d :

  php http_server.php start -d

  Workerman fonctionnera en arrière-plan, enregistrant les logs dans un fichier (généralement dans le dossier du projet ou un chemin spécifié).

Gestion des processus :

Workerman offre plusieurs commandes utiles :

• Démarrer : php http_server.php start (avant-plan) ou php http_server.php start -d (démon)
• Arrêter : php http_server.php stop (s’arrête proprement après traitement des requêtes en cours)
• Redémarrer : php http_server.php restart (arrêt puis redémarrage)
• Rechargement fluide : php http_server.php reload (pour mettre à jour du code sans interruption de service, redémarre chaque process individuellement, attention aux callbacks dans onWorkerStart)
• État : php http_server.php status (affiche l’état, la mémoire utilisée, le nombre de connexions, etc.)

Après le démarrage, ouvrez le navigateur et accédez à http://localhost:8080 ou http://127.0.0.1:8080 : vous devriez voir le texte Hello ServBay Workerman HTTP Server!.

Créer un serveur WebSocket avec Workerman

Le protocole WebSocket permet la communication bidirectionnelle persistante entre client et serveur, idéal pour le temps réel : chat, cotations boursières, jeux, etc. Workerman prend en charge WebSocket nativement.

1. Créer le serveur WebSocket

   Dans le dossier projet, créez un fichier websocket_server.php et ajoutez :

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Créer un serveur WebSocket sur le port 8081
   // Workerman gère automatiquement la poignée de main WebSocket
   $ws_worker = new Worker('websocket://0.0.0.0:8081');
   
   // Lancer 4 processus pour traiter les connexions
   $ws_worker->count = 4;
   
   // Traitement lors d’une nouvelle connexion
   $ws_worker->onConnect = function(TcpConnection $connection) {
       echo "New WebSocket connection from " . $connection->getRemoteIp() . "\n";
   };
   
   // Traitement lors de la réception d’un message WebSocket
   $ws_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Received message: " . $data . "\n";
       // Echo du message au client
       $connection->send('ServBay Workerman received: ' . $data);
   };
   
   // Traitement lors de la fermeture de la connexion
   $ws_worker->onClose = function(TcpConnection $connection) {
       echo "WebSocket Connection closed\n";
   };
   
   // Gestion d’erreur éventuelle (optionnel)
   $ws_worker->onError = function(TcpConnection $connection, $code, $msg) {
       echo "Error: $code - $msg\n";
   };
   
   // Démarrer tous les Workers
   Worker::runAll();

2. Lancer le serveur WebSocket

   Dans le dossier projet, démarrez le serveur WebSocket :

   php websocket_server.php start

   Vous pouvez aussi utiliser -d pour le mode arrière-plan. Après le lancement, connectez-vous en WebSocket à ws://localhost:8081 à l’aide d’un outil ou directement via la Console du navigateur :

   var ws = new WebSocket("ws://localhost:8081");
   
   ws.onopen = function(event) {
     console.log("WebSocket connection opened");
     ws.send("Hello from Browser!"); // Envoyer un message
   };
   
   ws.onmessage = function(event) {
     console.log("Message from server:", event.data); // Afficher message reçu
   };
   
   ws.onclose = function(event) {
     if (event.wasClean) {
       console.log("WebSocket connection closed cleanly, code=" + event.code + " reason=" + event.reason);
     } else {
       console.error("WebSocket connection died");
     }
   };
   
   ws.onerror = function(error) {
     console.error("WebSocket error:", error);
   };
   
   // Fermer la connexion (optionnel)
   // ws.close();

   Après connexion, vous verrez les informations de connexion dans le terminal ; à l’envoi d’un message, Workerman affiche le message reçu et le navigateur reçoit en retour la réponse du serveur.

Créer un serveur TCP avec Workerman

Workerman peut aussi servir pour des serveurs TCP génériques adaptés à toutes sortes d’applications (jeux, IoT, communication personnalisée, ...).

1. Créer le serveur TCP

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

   <?php
   require __DIR__ . '/vendor/autoload.php';
   
   use Workerman\Worker;
   use Workerman\Connection\TcpConnection;
   
   // Créer un serveur TCP sur le port 8082
   // Par défaut, Workerman utilise le protocole Text (\n fin de ligne)
   $tcp_worker = new Worker('tcp://0.0.0.0:8082');
   
   // Lancer 4 processus
   $tcp_worker->count = 4;
   
   // À la connexion, envoyer un message de bienvenue
   $tcp_worker->onConnect = function(TcpConnection $connection) {
       echo "New TCP connection from " . $connection->getRemoteIp() . "\n";
       $connection->send("Welcome to ServBay Workerman TCP Server!\n");
   };
   
   // À la réception de données TCP
   $tcp_worker->onMessage = function(TcpConnection $connection, $data) {
       echo "Received data: " . $data;
       $connection->send('ServBay Workerman received: ' . $data);
   };
   
   // À la fermeture
   $tcp_worker->onClose = function(TcpConnection $connection) {
       echo "TCP Connection closed\n";
   };
   
   // Démarrer les Workers
   Worker::runAll();

2. Lancer le serveur TCP

   Dans le dossier projet, lancez le serveur TCP :

   php tcp_server.php start

   Vous pouvez aussi l’exécuter en arrière-plan avec -d. Utilisez ensuite un client TCP pour vous connecter à localhost:8082.

   Par exemple, sous macOS/Linux, ouvrez un autre terminal et tapez :

   # Avec telnet
   telnet localhost 8082
   
   # Ou avec nc (netcat)
   nc localhost 8082

   Après connexion, le serveur envoie un message de bienvenue. Tapez n’importe quel texte et validez avec entrée : Workerman affichera et renverra le message reçu.

Points d’attention

• Ports occupés : Vérifiez que les ports utilisés (8080, 8081, 8082 dans les exemples) ne sont pas déjà pris par macOS ou d’autres instances depuis ServBay. Sinon, Workerman échouera au démarrage. Vérifiez l’occupation d’un port avec lsof -i :NUMERO_PORT.
• Pare-feu : Le pare-feu de macOS peut bloquer les accès externes à ces ports. Pour usage local, ce n’est généralement pas bloquant, mais pour un accès depuis d’autres machines du réseau, ajustez les règles du pare-feu.
• Relation avec les serveurs Web ServBay : Workerman écoute son propre port, indépendant des serveurs Caddy ou Nginx de ServBay. Les applications Workerman gèrent directement les connexions (sauf si vous configurez un proxy inverse). Workerman est idéal pour le temps réel ou la haute concurrence ; Caddy/Nginx de ServBay sert surtout les requêtes HTTP courtes classiques.
• Version PHP : Assurez-vous que la version PHP utilisée avec ServBay est compatible avec Workerman (> PHP 5.4). ServBay propose plusieurs versions, choisissez et activez celle qui convient dans le panneau.
• Extensions PHP : Workerman tire parti de certaines extensions PHP pour de meilleures performances, telles que event (préféré si disponible), posix, pcntl (pour le multi-processus). Ces extensions sont activées par défaut dans ServBay, vérifiez néanmoins leur activation si vous obtenez des erreurs.
• **Logs **: En mode démon, les sorties Workerman sont redirigées vers un fichier log. Pensez à les consulter régulièrement.

Foire aux questions (FAQ)

• Q : Comment arrêter un serveur Workerman ?
  • R : S’il fonctionne au premier plan (start), tapez Ctrl+C dans le terminal. S’il est en mode démon (start -d), utilisez la commande php votre_fichier_serveur.php stop dans le dossier projet.
• Q : Pourquoi le serveur Workerman ne démarre-t-il pas ?
  • R : Le problème le plus courant est un port déjà utilisé. Vérifiez le terminal pour les messages d’erreur, modifiez le port si nécessaire ou libérez le port. Utilisez lsof -i :NUMERO_PORT pour les diagnostics.
• Q : Quelle est la différence entre les serveurs Caddy/Nginx de ServBay et Workerman ? Lequel choisir ?
  • R : Caddy/Nginx sont des serveurs Web traditionnels, faits pour les requêtes HTTP/S, typiquement utilisés avec PHP-FPM ; chaque requête peut entraîner le lancement ou la destruction de process PHP. Workerman est un framework réseau asynchrone qui peut servir HTTP, WebSocket, TCP, etc., en processus résidents : idéal pour la haute concurrence, les longues connexions, le temps réel. Pour un site ou une API standard, Caddy/Nginx suffisent ; pour du chat, du jeu, de l’IoT, Workerman est préférable. Vous pouvez aussi combiner les deux (ex : Caddy en proxy inverse vers Workerman).
• Q : Peut-on exécuter plusieurs applications Workerman simultanément sous ServBay ?
  • R : Oui. Chaque instance Workerman fonctionne dans son propre process PHP, sur un port distinct. Écrivez un script de démarrage pour chaque application et lancez-le dans un terminal séparé (avant-plan ou arrière-plan). Veillez simplement à ne pas utiliser deux fois le même port.

Conclusion

Ce guide vous a permis de découvrir comment configurer et exécuter rapidement des projets Workerman dans l’environnement local efficace qu’est ServBay. Grâce à ses performances et à l’asynchronisme, Workerman donne aux développeurs PHP le pouvoir de concevoir des applications réseau de nouvelle génération. Grâce à Composer et PHP préconfigurés par ServBay, gagnez du temps sur la configuration et concentrez-vous sur votre logique métier Workerman. Pour des services Web performants ou du temps réel via WebSocket, ServBay est le partenaire de choix pour vos développements Workerman sur macOS. Bonne exploration, et succès dans vos projets Workerman !