Utiliser Swoole dans ServBay pour créer des applications PHP haute performance

ServBay est un environnement de développement web local conçu spécialement pour les développeurs, pré-intégrant de nombreux langages, bases de données et outils afin de simplifier le workflow local. Cet article explique comment exploiter l’extension Swoole dans ServBay pour propulser vos applications PHP et créer des services réseau haute performance.

Qu’est-ce que Swoole ?

Swoole est un moteur de communication réseau parallèle et haute performance basé sur les coroutines, conçu pour PHP. Écrit en pur C, il offre à PHP la puissance du networking asynchrone, parallèle et basé sur les coroutines. Grâce à Swoole, les développeurs PHP surpassent le schéma traditionnel request-response du serveur web (Apache/Nginx + PHP-FPM), pour traiter aisément des tâches concurrentes comme des serveurs web résidents en mémoire, du traitement de tâches asynchrones, des services temps réel (WebSocket), etc.

Principales caractéristiques de Swoole :

• Haute performance : Implémenté en C, supporte IO asynchrone, multi-processus/thread.
• Coroutines : Permet la programmation asynchrone via des coroutines légères, rendant le code asynchrone aussi simple qu’un code synchrone.
• Support de protocoles variés : Support natif pour TCP, UDP, HTTP, WebSocket et bien plus.
• Facilité d’utilisation : Fournit une API simple dans l’esprit PHP.
• Processus résidents : Les applications tournent comme des processus persistants, évitant la surcharge d’initialisation à chaque requête PHP traditionnelle.

Grâce à Swoole, PHP ne se limite plus au scripting web : il devient capable de gérer des scénarios réseau haute performance.

Activer Swoole dans ServBay

L’un des buts de ServBay est de donner aux développeurs une gestion simple et rapide des extensions PHP. Swoole, incontournable pour le développement haute performance moderne avec PHP, est déjà préinstallé dans ServBay. Son activation est très simple.

Prérequis :

• ServBay doit être installé et en cours d’exécution.
• Au moins une version de PHP doit être installée dans ServBay.

Étapes d’activation :

1. Ouvrez l’interface de ServBay.
2. Naviguez vers “Packages” ou la gestion des versions PHP. (Selon la version de ServBay, le nom peut différer, mais généralement il est accessible via l’interface principale ou les paramètres.)
3. Sélectionnez la version de PHP sur laquelle vous souhaitez activer Swoole.
4. Repérez Swoole dans la liste des extensions et cochez pour l’activer. ServBay affiche les extensions prêtes à l’emploi sous forme de liste ou interrupteurs.
5. Enregistrez les modifications et redémarrez ServBay ou le service PHP concerné si besoin. ServBay adaptera la configuration PHP pour charger automatiquement Swoole.

Après ces étapes, Swoole sera opérationnel dans la version PHP choisie. Vous pouvez vérifier son activation avec la commande php -m et repérer swoole dans la liste des extensions chargées.

TIP

ServBay recommande par défaut de placer vos sites et fichiers projets dans les dossiers suivants, facilitant leur gestion et configuration :

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

Les exemples de cet article suivent cette organisation.

Créer un serveur HTTP Swoole simple

Voyons comment mettre en place un serveur HTTP basique avec Swoole et servir des requêtes web.

Étape 1 : Créer le dossier projet

Ouvrez le terminal et créez un nouveau dossier projet dans l’emplacement conseillé :

macOS :

cd /Applications/ServBay/www
mkdir servbay-swoole-http
cd servbay-swoole-http

Windows :

cd C:\ServBay\www
mkdir servbay-swoole-http
cd servbay-swoole-http

Étape 2 : Écrire le script serveur

Dans le dossier servbay-swoole-http, créez le fichier server.php et ajoutez :

<?php

use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;

// Créer une instance du serveur HTTP Swoole
// Écoute sur toutes les interfaces réseau (0.0.0.0), port 9501
$server = new Server("0.0.0.0", 9501);

// Enregistre le callback pour l’événement 'start'
// Déclenché au lancement réussi du serveur
$server->on("start", function (Server $server) {
    echo "Le serveur HTTP Swoole démarre sur http://0.0.0.0:9501\n";
    // Ici, vous pouvez journaliser l’ID du processus principal, ID du gestionnaire, etc.
});

// Enregistre le callback pour l’événement 'request'
// Déclenché à chaque nouvelle requête HTTP reçue
$server->on("request", function (Request $request, Response $response) {
    // Définir les en-têtes de réponse
    $response->header("Content-Type", "text/plain");

    // Traiter selon le chemin ou les paramètres de la requête
    $path = $request->server['request_uri'] ?? '/';
    $content = "Hello ServBay!";

    if ($path === '/info') {
        $content = "Chemin de la requête : " . $path . "\n";
        $content .= "Méthode : " . $request->server['request_method'] . "\n";
        $content .= "IP client : " . $request->server['remote_addr'] . "\n";
        // Plus d’informations disponibles via l’objet $request
    }

    // Envoyer le corps de réponse et terminer la requête
    $response->end($content);
});

// Démarrer le serveur
$server->start();

Ce script démarre un serveur HTTP Swoole sur le port 9501. Lors des requêtes, il renvoie "Hello ServBay!". Si vous accédez au chemin /info, il fournit des informations à propos de la requête.

Étape 3 : Lancer le serveur Swoole

Dans le terminal, positionnez-vous dans servbay-swoole-http et utilisez la version PHP avec Swoole activée :

php server.php

Si tout fonctionne, vous verrez :

Le serveur HTTP Swoole démarre sur http://0.0.0.0:9501

Cela indique que le serveur est bien actif sur le port 9501.

Étape 4 : Accéder au serveur Swoole

Ouvrez votre navigateur web et visitez :

• http://localhost:9501
• http://localhost:9501/info

Le premier affiche Hello ServBay!, le second les infos de la requête.

Pour arrêter le serveur, dans le terminal où il tourne, appuyez sur Ctrl + C.

Gérer les connexions WebSocket avec Swoole

Swoole supporte nativement WebSocket, idéal pour les applications temps réel comme les chats, serveurs de jeu ou push de données.

Étape 1 : Créer le script serveur WebSocket

Dans votre dossier projet (ex. servbay-swoole-http ou créez-en un nouveau comme servbay-swoole-websocket), ajoutez un fichier websocket_server.php :

Chemin du projet :

• macOS : /Applications/ServBay/www/servbay-swoole-http
• Windows : C:\ServBay\www\servbay-swoole-http

<?php

use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;

// Créer une instance du serveur WebSocket Swoole
// Le serveur WebSocket hérite du serveur HTTP, il peut aussi traiter des requêtes HTTP
$server = new Server("0.0.0.0", 9502); // Écoute sur le port 9502

// Callback événement 'start', au démarrage du serveur
$server->on("start", function (Server $server) {
    echo "Le serveur WebSocket Swoole démarre sur ws://0.0.0.0:9502\n";
});

// Callback événement 'open'
// Déclenché à l’ouverture d’une nouvelle connexion WebSocket
// L’objet $request contient les infos client, $request->fd est le file descriptor client
$server->on("open", function (Server $server, Request $request) {
    echo "connexion ouverte : {$request->fd}\n";
    // Envoyer un message de bienvenue au client
    $server->push($request->fd, "Bienvenue sur la démo ServBay WebSocket !");
});

// Callback événement 'message'
// Déclenché à la réception d’un message WebSocket du client
// L’objet $frame contient le message, $frame->data = contenu, $frame->fd = client
$server->on("message", function (Server $server, Frame $frame) {
    echo "message reçu de {$frame->fd}: {$frame->data}\n";
    // Répondre au client ou diffuser à tous
    // Exemple : réponde à l’expéditeur
    $server->push($frame->fd, "Hello, vous avez envoyé : {$frame->data}");

    // Exemple de diffusion (il faut gérer une liste de connexions ou boucler)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // Ne pas renvoyer à l’expéditeur
    //         $server->push($fd, "Utilisateur {$frame->fd} dit : {$frame->data}");
    //     }
    // }
});

// Callback événement 'close'
// Déclenché à la fermeture de la connexion client
$server->on("close", function ($ser, $fd) {
    echo "connexion fermée : {$fd}\n";
});

// Démarrer le serveur
$server->start();

Ce script démarre un serveur WebSocket Swoole sur le port 9502, gérant les événements clés : start, open, message, close. À chaque message du client, il ajoute un préfixe et renvoie la réponse.

Étape 2 : Lancer le serveur WebSocket

Dans le terminal, dans le dossier du script, exécutez :

php websocket_server.php

Si tout fonctionne, le terminal affiche :

Le serveur WebSocket Swoole démarre sur ws://0.0.0.0:9502

Le serveur WebSocket écoute désormais le port 9502.

Étape 3 : Se connecter au serveur WebSocket

Vous avez plusieurs moyens de tester la connexion.

Méthode A : Outils développeur du navigateur

La plupart des navigateurs modernes disposent d’un panneau “Console” ou “Network” (via F12).

1. Ouvrez une page (ex. about:blank).

2. Ouvrez la console du navigateur.

3. Exécutez ce JavaScript pour créer la connexion :

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("Connexion WebSocket ouverte :", event);
     ws.send("Hello from Browser!"); // Après connexion, envoyez un message
   };
   
   ws.onmessage = function(event) {
     console.log("Message du serveur :", event.data); // Réception d’un message
   };
   
   ws.onerror = function(event) {
     console.error("Erreur WebSocket :", event); // S’il y a une erreur
   };
   
   ws.onclose = function(event) {
     console.log("Connexion WebSocket fermée :", event); // Fermeture de la connexion
   };
   
   // Utilisez ws.send("votre message") pour envoyer
   // ws.close() pour fermer la connexion

4. Observez les logs dans la console et dans le terminal du serveur.

Méthode B : Outil en ligne de commande wscat

wscat est un client WebSocket en CLI basé sur Node.js.

1. Installer wscat : Si Node.js et npm ne sont pas installés, installez-les d’abord, puis :

   npm install -g wscat

2. Connectez-vous au serveur WebSocket :

   wscat -c ws://localhost:9502

   Une invite > s’affiche.

3. Envoyez un message : Tapez un texte puis validez :

   > Hello ServBay via wscat

   Vous devriez recevoir une réponse du serveur, en général précédée de < :

   < Hello, vous avez envoyé : Hello ServBay via wscat

   Les journaux s’affichent aussi dans le terminal du serveur.

Pour déconnecter wscat, tapez Ctrl + C.

Points d’attention

• Conflits de ports : Vérifiez que les ports utilisés (ex. 9501, 9502) ne sont pas occupés par d’autres programmes. En cas de conflit, le serveur ne pourra démarrer.
• Version de PHP : Assurez-vous que le PHP utilisé en CLI correspond à la version activée avec Swoole dans ServBay. Vérifiez avec php -v. ServBay propose souvent un outil pour alterner les versions de PHP.
• État de l’extension : Si le serveur ne démarre pas, vérifiez que l’extension Swoole est bien activée pour la version PHP utilisée et que ServBay (ou le service PHP) a été redémarré.
• Gestion des processus résidents : Swoole démarre comme un processus en mémoire. En production, utilisez un superviseur de processus (Supervisor, Systemd, pm2…) pour veiller à la relance automatique. Sur ServBay en développement local, lancer le serveur à la main est généralement suffisant.

Conclusion

Avec ServBay, activer et exploiter Swoole devient simple pour créer et tester localement des applications PHP performantes – du serveur HTTP classique au service WebSocket temps réel. La puissance de Swoole combinée à la simplicité de ServBay ouvre de nouveaux horizons pour les développeurs PHP, permettant de construire des applications plus puissantes et efficaces. Lancez-vous avec Swoole sur ServBay dès maintenant !