Créer et exécuter un projet Webman sous ServBay

Qu'est-ce que Webman ?

Webman est un framework Web PHP asynchrone haute performance basé sur Workerman, conçu pour le développement d'applications Web à forte concurrence et performances élevées. Contrairement aux frameworks synchrones et bloquants traditionnels, Webman utilise un modèle I/O évènementiel et non bloquant, ce qui le rend particulièrement performant pour gérer de nombreux requêtes simultanées. Webman propose une API simple d’utilisation et un système d’extensions flexible, parfait pour le développement d’applications temps réel, d’API, de microservices, etc.

Principales fonctionnalités et avantages de Webman

• Haute performance : Propulsé par Workerman, bénéficie de l'I/O asynchrone et événementiel, gère un nombre massif de connexions simultanées, avec une capacité bien supérieure aux frameworks synchrones classiques.
• Simplicité d’utilisation : APIs claires et riches en fonctionnalités, permettant aux développeurs de démarrer et de créer des applications rapidement.
• Support multi-protocole : Prise en charge native de protocoles tels que HTTP, WebSocket, facilitant la création de services variés.
• Extension flexible : Extensions simplifiées via des paquets Composer, plugins ou middlewares.
• Faible consommation de ressources : Contrairement au modèle serveur Web traditionnel + PHP-FPM, Webman fonctionne en mémoire, optimisant la consommation de ressources.
• Communauté active : Bénéficie d’une communauté dynamique et de documentation abondante.

Webman aide les développeurs à concevoir rapidement des applications Web et des API robustes, particulièrement adapté aux environnements à haute concurrence et faible latence.

Créer et exécuter un projet Webman simple avec ServBay

Ce guide explique pas à pas comment créer et faire fonctionner un projet Webman dans ServBay. Il présente l’installation de Webman, l’écriture du code de base (routes & contrôleurs), et l’intégration des bases de données (MySQL, PostgreSQL) et des services de cache (Redis, Memcached) fournis par ServBay.

TIP

ServBay recommande de placer tous vos projets web locaux dans le répertoire /Applications/ServBay/www pour une gestion unifiée — configuration facile de vos sites locaux ("hôtes").

Prérequis

Avant de commencer, assurez-vous d’avoir :

1. Installé ServBay : ServBay est installé avec succès sur macOS. ServBay propose un environnement complet incluant PHP, Composer, MySQL, PostgreSQL, Redis, Memcached, etc.
2. Activé les paquets nécessaires : Depuis le panneau de contrôle ServBay, vérifiez que les paquets suivants sont installés et actifs :
   • Version PHP de votre choix (recommandé : PHP 8.x ou ultérieur)
   • Composer (intégré à ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Pour PHP, assurez-vous que les extensions memcached, redis, pdo_mysql, pdo_pgsql, etc. sont activées. ServBay les active généralement par défaut, vérifiez via l’interface de configuration PHP.
3. Accès au terminal : Vous savez utiliser l’application Terminal de macOS.

Installation de Webman

1. Vérifiez la disponibilité de Composer

   Composer est fourni de base avec ServBay et peut être utilisé directement dans le terminal. Pour vérifier :

   composer --version

   Si la version s’affiche, Composer est prêt à l’emploi.

2. Accédez au dossier des sites ServBay

   Dans le terminal, positionnez-vous dans le répertoire racine des sites recommandé par ServBay :

   cd /Applications/ServBay/www

3. Créez le projet Webman via Composer

   Installez le framework Webman dans le dossier souhaité en utilisant la commande create-project. Nommons le projet servbay-webman-app :

   composer create-project workerman/webman servbay-webman-app

   Composer télécharge Webman et ses dépendances essentielles dans le dossier servbay-webman-app.

4. Accédez au dossier du projet

   Une fois installé, entrez dans le répertoire du projet :

   cd servbay-webman-app

5. Installez les composants nécessaires

   Pour utiliser la base de données et le cache, installez des paquets supplémentaires via Composer. Webman utilise fréquemment illuminate/database (composant Laravel), illuminate/redis, etc. L’option -W (ou --with-dependencies) règle automatiquement les conflits éventuels.

   composer require -W illuminate/database illuminate/redis illuminate/pagination illuminate/events symfony/var-dumper

   Cette commande installe l’ORM, le client Redis, le composant de pagination, la gestion d’événements et l’outil de debug VarDumper.

Création de la base de données et des tables

Pour que le code d’exemple fonctionne, créez les bases de données et la table users dans MySQL et PostgreSQL via ServBay. Par défaut, l’utilisateur root a le mot de passe password.

Utilisez les outils ServBay (phpMyAdmin, pgAdmin via le panneau ServBay) ou la ligne de commande pour exécuter ces instructions SQL.

1. Créez la base de données webman_app

   • MySQL :

     CREATE DATABASE IF NOT EXISTS webman_app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

   • PostgreSQL :

     CREATE DATABASE webman_app;

2. Créez la table users dans la base webman_app

   • MySQL :

     USE webman_app;
     CREATE TABLE users (
         id INT AUTO_INCREMENT PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

   • PostgreSQL :

     \c webman_app; -- Connexion à la BDD nouvellement créée
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Écriture du code du projet Web

Nous allons maintenant ajouter les routes et contrôleurs, puis implémenter les interactions avec la base de données et le cache.

1. Configuration des routes

   Editez le fichier config/route.php à la racine du projet pour y placer ces définitions :

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Route de la racine, associée à la méthode index d’IndexController
   Route::any('/', [IndexController::class, 'index']);
   
   // Routes pour le cache
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Routes pour la base de données
   Route::any('/mysql-add', [DatabaseController::class, 'mysqlAdd']);
   Route::any('/mysql', [DatabaseController::class, 'mysqlGet']);
   Route::any('/pgsql-add', [DatabaseController::class, 'pgsqlAdd']);
   Route::any('/pgsql', [DatabaseController::class, 'pgsqlGet']);
   
   // Ajoutez d’autres routes ici si besoin...

2. Création des fichiers contrôleurs

   Dans le dossier app/controller, créez les fichiers IndexController.php, CacheController.php et DatabaseController.php avec le code suivant.

   • app/controller/IndexController.php : gestion de la route racine.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Import de la classe Response
     
     class IndexController
     {
         /**
          * Exemple de méthode pour la racine du site
          * @param Request $request Requête courante
          * @return Response Retourne un objet Response
          */
         public function index(Request $request): Response // Type de retour explicite
         {
             // Retourne une réponse texte simple
             return response('Hello ServBay & Webman!'); // Message d’accueil actualisé
         }
     }

   • app/controller/CacheController.php : exemple d’utilisation de Memcached et Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Import de la classe Memcached
     use support\Redis; // Import du facade Redis de Webman
     
     class CacheController
     {
         /**
          * Exemple d’utilisation de Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Connexion à Memcached, par défaut sur 127.0.0.1:11211 dans ServBay
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Ajout d’une donnée au cache, avec expiration 60 secondes
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Mise à jour de la clé et valeur
             if (!$success) {
                  return response('Échec lors de l’enregistrement de la clé Memcached', 500);
             }
     
             // Récupération de la donnée
             $value = $memcached->get('servbay_key'); // Mise à jour de la clé
     
             // Retourne la valeur récupérée
             return response($value ?: 'Clé Memcached introuvable ou expirée'); // Message ajouté si non trouvée
         }
     
         /**
          * Exemple d’utilisation de Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Ajout d’une donnée au cache via le facade Redis de Webman
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Mise à jour de la clé et valeur
     
             // Récupération de la donnée
             $value = Redis::get('servbay_redis_key'); // Mise à jour de la clé
     
             // Retourne la valeur récupérée
             return response($value ?: 'Clé Redis introuvable'); // Message ajouté si non trouvée
         }
     }

   • app/controller/DatabaseController.php : exemple d’opérations MySQL et PostgreSQL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Import du facade Db de Webman
     
     class DatabaseController
     {
         /**
          * Ajoute un utilisateur dans MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Connexion à la BDD MySQL via Db et insertion
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Valeur d’exemple mise à jour
                     'email' => 'mysql_demo@servbay.test', // Exemple d’email mis à jour
                     'created_at' => date('Y-m-d H:i:s') // Ajout du created_at
                 ]);
                 return response('Utilisateur ajouté dans MySQL'); // Message mis à jour
             } catch (\Exception $e) {
                 return response('Erreur lors de l’ajout d’utilisateur dans MySQL : ' . $e->getMessage(), 500); // Gestion des erreurs ajoutée
             }
         }
     
         /**
          * Récupère la liste des utilisateurs MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Connexion à MySQL via Db et récupération des données
                 $users = Db::connection('mysql')->table('users')->get();
                 // Retourne la liste des utilisateurs en JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type précisé
             } catch (\Exception $e) {
                  return response('Erreur lors de la récupération des utilisateurs MySQL : ' . $e->getMessage(), 500); // Gestion des erreurs ajoutée
             }
         }
     
         /**
          * Ajoute un utilisateur dans PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Connexion à la BDD PostgreSQL via Db et insertion
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Valeur d’exemple
                     'email' => 'pgsql_demo@servbay.test', // Exemple d’email
                     'created_at' => date('Y-m-d H:i:s') // Ajout du created_at
                 ]);
                 return response('Utilisateur ajouté dans PostgreSQL'); // Message mis à jour
              } catch (\Exception $e) {
                 return response('Erreur lors de l’ajout d’utilisateur dans PostgreSQL : ' . $e->getMessage(), 500); // Gestion des erreurs ajoutée
              }
         }
     
         /**
          * Récupère la liste des utilisateurs PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Connexion à PostgreSQL via Db et récupération des données
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Retourne la liste des utilisateurs en JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type précisé
              } catch (\Exception $e) {
                 return response('Erreur lors de la récupération des utilisateurs PostgreSQL : ' . $e->getMessage(), 500); // Gestion des erreurs ajoutée
              }
         }
     }

3. Configuration de la connexion à la base de données

   Editez le fichier config/database.php à la racine du projet pour indiquer les paramètres MySQL et PostgreSQL. Par défaut, ServBay utilise l’hôte 127.0.0.1, les ports 3306 (MySQL) et 5432 (PostgreSQL), et le mot de passe password pour l’utilisateur root.

   <?php
   /**
    * Configuration de la base de données
    */
   return [
       // Connexion par défaut
       'default' => 'mysql',
   
       // Liste des connexions disponibles
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Hôte et port par défaut ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nom de BDD créé précédemment
               'database'  => 'webman_app',
               // Utilisateur MySQL par défaut dans ServBay
               'username'  => 'root',
               // Mot de passe MySQL par défaut
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Hôte et port par défaut ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nom de BDD créé précédemment
               'database' => 'webman_app',
                // Utilisateur PostgreSQL par défaut
               'username' => 'root',
                // Mot de passe PostgreSQL par défaut
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // Ou require, verify-ca, verify-full
           ],
           // D’autres connexions peuvent être ajoutées ici...
       ],
   ];

   Remarque importante : En production, modifiez toujours les mots de passe par défaut et évitez de coder en dur des informations sensibles dans le code source.

Démarrer le projet Webman

Webman fonctionne via son script start.php qui lance le processus Workerman. Contrairement à l’exécution conventionnelle via Nginx/Apache + PHP-FPM, Webman s’exécute en mémoire en mode asynchrone.

Dans le répertoire du projet (/Applications/ServBay/www/servbay-webman-app), lancez Webman avec la commande suivante :

php start.php start

Vous verrez les informations de démarrage de Webman ; par défaut il écoute sur 127.0.0.1:8787 pour les requêtes HTTP.

• Remarque : La commande php utilise l’exécutable PHP intégré de ServBay, qui configure automatiquement l’environnement du terminal.
• Pour lancer Webman en arrière-plan : ajoutez l’option -d → php start.php start -d.
• Pour arrêter Webman : php start.php stop.
• Pour redémarrer le service : php start.php restart.
• Pour un redémarrage sans interruption : php start.php reload.

Tester le projet

Une fois Webman démarré et en écoute sur 127.0.0.1:8787, testez les différentes fonctionnalités via ces URLs dans le navigateur :

• http://localhost:8787/ : affiche Hello ServBay & Webman!.
• http://localhost:8787/memcached : affiche Hello Memcached from ServBay! — vérifie le cache Memcached via Webman.
• http://localhost:8787/redis : affiche Hello Redis from ServBay! — vérifie le cache Redis.
• http://localhost:8787/mysql-add : affiche Utilisateur ajouté dans MySQL — ajoute un enregistrement dans la table users MySQL.
• http://localhost:8787/mysql : affiche la liste des utilisateurs MySQL au format JSON.
• http://localhost:8787/pgsql-add : affiche Utilisateur ajouté dans PostgreSQL — ajoute un utilisateur dans la table PostgreSQL.
• http://localhost:8787/pgsql : affiche la liste des utilisateurs PostgreSQL en JSON.

Si vous rencontrez un problème, vérifiez la sortie du terminal pour Webman et assurez-vous que les paquets MySQL, PostgreSQL, Redis et Memcached, ainsi que les extensions PHP sont bien activés sous ServBay.

FAQ (Questions fréquentes)

• Q : Commande php start.php start introuvable ?
  • R : Vérifiez que vous êtes bien dans le dossier de projet servbay-webman-app, et que le PHP de ServBay est ajouté à votre PATH (ServBay gère cela généralement automatiquement).
• Q : Connexion refusée sur localhost:8787 ?
  • R : Consultez la sortie du terminal pour détecter d’éventuelles erreurs. Vérifiez que le port 8787 n’est pas utilisé par un autre programme. Si besoin, modifiez le port dans le fichier de configuration config/server.php.
• Q : Problème de connexion à la base de données ?
  • R : Assurez-vous que MySQL et PostgreSQL sont lancés dans ServBay. Vérifiez les paramètres du fichier config/database.php (hôte, port, nom de la BDD, utilisateur, mot de passe), qui doivent correspondre à ceux de ServBay (root et password par défaut). Assurez-vous que la BDD webman_app et la table users existent.
• Q : Memcached ou Redis ne se connectent pas ?
  • R : Vérifiez que Memcached et Redis sont actifs dans ServBay. Contrôlez les adresses et ports dans app/controller/CacheController.php (127.0.0.1:11211 et 127.0.0.1:6379 par défaut). Assurez-vous que les extensions PHP memcached et redis sont activées.

Conclusion

Vous avez maintenant créé, configuré et lancé avec succès un projet Webman de base dans l’environnement local ServBay. Ce guide vous a appris à exploiter l’installation tout-en-un de ServBay pour développer efficacement avec Webman, en intégrant base de données et cache. Les performances asynchrones de Webman, associées à la simplicité de ServBay, vous offrent une plateforme puissante pour le développement d’applications PHP modernes. Nous espérons que ce tutoriel vous permettra de tirer pleinement profit de ServBay et Webman pour concevoir des applications Web avancées.