Créer des applications PHP haute performance avec Swoole dans ServBay

ServBay est un environnement de développement web local conçu spécialement pour les développeurs. Il intègre de nombreux langages, bases de données et outils afin de simplifier le développement sur votre machine. Cet article vous explique comment exploiter la puissance de l’extension Swoole dans ServBay pour vos applications PHP et construire des services réseau ultra performants.

Qu’est-ce que Swoole ?

Swoole est un moteur de communication réseau haute performance, basé sur les coroutines, conçu pour PHP. Écrit en pur C, il dote PHP de capacités de réseau asynchrones, parallèles et orientées coroutine. Grâce à Swoole, les développeurs PHP ne sont plus limités au modèle de requête-réponse traditionnel des serveurs web (Apache/Nginx + PHP-FPM). Swoole permet de gérer efficacement des tâches fortement concurrentes, telles que la création de serveurs web résidents en mémoire, le traitement de tâches asynchrones ou encore des services de communication temps réel comme WebSocket.

Principales caractéristiques de Swoole :

• Haute performance : Implémenté en C natif, prend en charge l’IO asynchrone, le multi-processus et le multi-thread.
• Coroutines : Fournit des coroutines légères, permettant l’exécution asynchrone avec un style de code synchrone, simplifiant la programmation asynchrone.
• Support de nombreux protocoles : Prise en charge native de TCP/UDP/HTTP/WebSocket et autres protocoles réseau.
• Simplicité d’utilisation : Propose une API claire et conforme aux habitudes PHP.
• Résident en mémoire : Vos applications peuvent tourner en tant que processus résidents, évitant la surcharge d’initialisation à chaque requête des applis PHP traditionnelles.

Avec Swoole, PHP n’est plus seulement un langage de script pour le web, mais devient un moteur puissant pour des applications réseau modernes à haute performance.

Activation de Swoole dans ServBay

L’un des objectifs de ServBay est de permettre aux développeurs de gérer et d’activer facilement différentes extensions PHP. Swoole, essentielle pour le développement PHP haute performance moderne, est déjà préinstallée dans ServBay. Son activation se fait en quelques clics.

Prérequis :

• ServBay installé et lancé.
• Un minimum d’une version PHP installée dans ServBay.

Étapes d’activation :

1. Ouvrez l’interface de l’application ServBay.
2. Allez dans le menu « Paquets (Logiciels) » ou dans la gestion des versions PHP. (Remarque : selon la version de ServBay, le nom peut varier, cela se trouve généralement sur la page principale ou dans les réglages.)
3. Sélectionnez la version PHP sur laquelle vous souhaitez activer Swoole.
4. Repérez l’option d’activation de l’extension Swoole et cochez-la. ServBay affiche généralement la liste des extensions précompilées via une liste ou interrupteur.
5. Enregistrez les modifications et, si nécessaire, redémarrez ServBay ou le service PHP concerné. ServBay configure alors automatiquement votre environnement PHP pour charger Swoole.

Vous pouvez alors utiliser Swoole sur la version PHP choisie. Vérifiez sa présence en lançant dans votre terminal : php -m et cherchez swoole dans les extensions listées.

TIP

Par défaut, ServBay recommande de stocker vos sites et fichiers de projet dans le dossier /Applications/ServBay/www. Cela facilite la gestion et la configuration de vos sites sous ServBay. Dans nos exemples, nous suivrons également ce chemin conseillé.

Créer un serveur HTTP Swoole basique

Voyons comment créer un serveur HTTP simple avec Swoole pour traiter des requêtes web.

Étape 1 : Créer le dossier projet

Ouvrez le terminal, créez et accédez à un nouveau dossier de projet. Suivant la recommandation de ServBay, placez-le sous /Applications/ServBay/www :

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

Étape 2 : Écrire le script du serveur

Dans le dossier servbay-swoole-http, créez un fichier nommé server.php avec le contenu suivant :

<?php

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

// Crée une instance du serveur HTTP Swoole
// Écoute sur l'interface réseau 0.0.0.0, port 9501
$server = new Server("0.0.0.0", 9501);

// Enregistre la fonction de rappel pour l’événement 'start'
// Déclenché au démarrage réussi du serveur
$server->on("start", function (Server $server) {
    echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
    // Vous pouvez ici enregistrer les PID du processus principal, manager, etc.
});

// Enregistre la fonction de rappel pour l’événement 'request'
// Déclenché à la réception d’une requête HTTP
$server->on("request", function (Request $request, Response $response) {
    // Définit l’entête de la réponse
    $response->header("Content-Type", "text/plain");

    // Logique selon le chemin ou paramètres de 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'infos sur la requête sont accessibles via $request
    }

    // Envoie la réponse et termine la requête
    $response->end($content);
});

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

Ce script lance un serveur HTTP Swoole à l’écoute sur le port 9501. À chaque requête, il répond avec le texte « Hello ServBay! ». En visitant le chemin /info, il retourne des informations sur la requête reçue.

Étape 3 : Démarrer le serveur Swoole

Assurez-vous d’être placé dans le dossier servbay-swoole-http dans votre terminal. Utilisez la version PHP de ServBay avec Swoole activé pour lancer le script :

php server.php

Si tout va bien, la sortie devrait indiquer :

Swoole HTTP server is started at http://0.0.0.0:9501

Ce qui signifie que le serveur est opérationnel et écoute sur le port 9501.

Étape 4 : Accéder au serveur Swoole

Ouvrez votre navigateur et visitez :

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

Vous verrez respectivement « Hello ServBay! » ou un texte avec les infos de la requête.

Pour arrêter le serveur, retournez sur le terminal où le script tourne et faites Ctrl + C.

Gérer des connexions WebSocket avec Swoole

Swoole prend en charge nativement le protocole WebSocket, idéal pour le temps réel : chat, jeux, push de données...

Étape 1 : Écrire le script serveur WebSocket

Dans /Applications/ServBay/www/servbay-swoole-http (ou créez un nouveau dossier comme servbay-swoole-websocket), créez le fichier websocket_server.php :

<?php

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

// Crée une instance du serveur WebSocket Swoole
// Hérite également du serveur HTTP, permet de gérer aussi les requêtes HTTP
$server = new Server("0.0.0.0", 9502); // Écoute sur le port 9502

// Événement 'start', appelé lors du démarrage du serveur
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});

// Événement 'open'
// Déclenché à l’établissement d’une nouvelle connexion WebSocket
// L’objet $request contient des infos sur le client, $request->fd est le numéro de connexion
$server->on("open", function (Server $server, Request $request) {
    echo "connection open: {$request->fd}\n";
    // Vous pouvez envoyer un message de bienvenue au client
    $server->push($request->fd, "Bienvenue dans la démo ServBay WebSocket !");
});

// Événement 'message'
// Déclenché quand le serveur reçoit un message d’un client WebSocket
// $frame->data contient le message, $frame->fd est le numéro du client expéditeur
$server->on("message", function (Server $server, Frame $frame) {
    echo "received message from {$frame->fd}: {$frame->data}\n";
    // Broadcast à tous les clients, ou réponse à l’expéditeur
    // Exemple : réponse directe
    $server->push($frame->fd, "Bonjour, vous avez envoyé : {$frame->data}");

    // Exemple de broadcast (garder la liste des FD ou itérer):
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // On n’envoie pas au client à l’origine du message
    //         $server->push($fd, "Utilisateur {$frame->fd} dit : {$frame->data}");
    //     }
    // }
});

// Événement 'close'
// Déclenché quand le client ferme la connexion
$server->on("close", function ($ser, $fd) {
    echo "connection close: {$fd}\n";
});

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

Ce script lance un serveur WebSocket sur le port 9502. Les callbacks « start », « open », « message », « close » s’occupent respectivement du démarrage, de l’arrivée d’une connexion, de la réception de message et de la fermeture. À chaque message, le serveur répond avec le contenu transmis par le client.

Étape 2 : Lancer le serveur WebSocket

Vérifiez que vous êtes dans le dossier où se trouve websocket_server.php, puis lancez :

php websocket_server.php

La sortie devrait indiquer :

Swoole WebSocket server is started at ws://0.0.0.0:9502

Le serveur WebSocket est en route, écoutant sur le port 9502.

Étape 3 : Se connecter au serveur WebSocket

Voici plusieurs moyens pour tester la connexion au serveur WebSocket.

Méthode A : Utiliser les outils de développement de votre navigateur

La plupart des navigateurs modernes disposent d’un outil « depuis F12 », comprenant un onglet « Console » ou « Réseau (Network) », utilisable pour tester les connexions WebSocket.

1. Ouvrez une page blanche (par exemple about:blank).

2. Appuyez sur F12 pour ouvrir les outils développeur, puis allez dans l'onglet « Console ».

3. Collez le code JavaScript suivant pour établir une connexion :

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("Connexion WebSocket ouverte :", event);
     ws.send("Hello from Browser!"); // Message à l'ouverture
   };
   
   ws.onmessage = function(event) {
     console.log("Message du serveur :", event.data); // Message reçu
   };
   
   ws.onerror = function(event) {
     console.error("Erreur WebSocket :", event); // En cas d’erreur
   };
   
   ws.onclose = function(event) {
     console.log("Connexion WebSocket fermée :", event); // Fermeture
   };
   
   // À tout instant, ws.send("votre message") pour envoyer, ws.close() pour fermer.

4. Exécutez le code en console : observez les messages côté navigateur et dans le terminal de websocket_server.php.

Méthode B : Utiliser l’outil en ligne de commande wscat

wscat est un client WebSocket en ligne de commande, basé sur Node.js.

1. Installer wscat : Si Node.js & npm ne sont pas installés, faites-le d’abord. Puis :

   npm install -g wscat

2. Se connecter au serveur : Dans le terminal, tapez :

   wscat -c ws://localhost:9502

   Une invite > apparaît si la connexion réussit.

3. Envoyer un message : Tapez et validez :

   > Hello ServBay via wscat

   Le serveur devrait répondre, affiché avec < :

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

   Le terminal du serveur affiche aussi les logs des connexions/messages.

Pour fermer la connexion, tapez Ctrl + C.

Points d’attention

• Conflit de ports : Vérifiez que les ports écoutés (ex : 9501, 9502) ne sont pas déjà utilisés par un autre programme sur votre machine. Sinon, Swoole ne pourra démarrer le serveur.
• Version PHP : Assurez-vous d’exécuter les scripts avec la version PHP de ServBay où l’extension Swoole est activée. Vérifiez avec php -v. ServBay offre souvent un utilitaire pour basculer la version PHP active.
• État de l'extension : Si le serveur refuse de démarrer, revérifiez que Swoole est bien activé pour la version PHP utilisée, et que ServBay ou le service PHP ont été redémarrés pour prendre en compte le changement.
• Gestion des processus résidents : Swoole fonctionne en mode processus résident. En production, utilisez un outil de gestion comme Supervisor, Systemd, pm2, etc. pour garantir que le serveur redémarre en cas de chute. Sous ServBay en local, un simple lancement manuel en terminal est généralement suffisant.

Conclusion

ServBay vous permet d’activer et d’utiliser facilement l’extension Swoole pour développer et tester localement des applications PHP haute performance, que ce soit pour des services HTTP traditionnels ou de la communication WebSocket temps réel. Grâce à la combinaison de la puissance de Swoole et de la simplicité de ServBay, les développeurs PHP ont accès à un nouveau champ des possibles pour des applications plus efficaces et performantes. Essayez Swoole dès aujourd’hui dans ServBay !