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

Qu’est-ce que Webman ?

Webman est un framework web PHP asynchrone haute performance basé sur Workerman, conçu pour la création d'applications web à forte concurrence et à haut rendement. Contrairement aux frameworks synchrones et bloquants traditionnels, Webman adopte un modèle piloté par les événements et une gestion I/O asynchrone non bloquante, ce qui lui permet d’exceller dans le traitement d’un grand nombre de requêtes simultanées. Webman propose une API simple d’utilisation et des mécanismes d’extension flexibles, ce qui le rend idéal pour le développement d’applications en temps réel, de services API, de microservices, etc.

Principales caractéristiques et avantages de Webman

• Haute performance : basé sur Workerman et utilisant le modèle événementiel asynchrone et non bloquant, il peut gérer un grand nombre de connexions simultanées, avec un débit bien supérieur aux frameworks synchrones classiques.
• Facilité d’utilisation : propose une API claire et intuitive, riche en fonctionnalités, permettant aux développeurs de démarrer et de créer des applications rapidement.
• Support multi-protocoles : support natif de protocoles applicatifs courants tels que HTTP, WebSocket, etc., facilitant la création de divers types de services.
• Extension flexible : possibilité d'étendre aisément les fonctionnalités du framework via des packages Composer, plugins et middleware.
• Faible consommation de ressources : contrairement au modèle classique Serveur Web + PHP-FPM, Webman fonctionne en mémoire résidente, consommant moins de ressources.
• Soutien communautaire solide : une communauté de développeurs active et une documentation abondante.

Webman aide les développeurs à construire rapidement des applications web et des services API hautement performants et disponibles, particulièrement adapté aux scénarios nécessitant une gestion élevée de la concurrence et une faible latence.

Créer et lancer un projet Webman simplement avec ServBay

Ce guide détaille étape par étape comment créer et exécuter un projet web simple utilisant Webman dans un environnement local ServBay. Nous montrerons comment installer Webman, écrire les routes et contrôleurs de base, ainsi qu’intégrer les bases de données (MySQL, PostgreSQL) et services de cache (Redis, Memcached) fournis par ServBay.

TIP

ServBay recommande de stocker tous vos projets web locaux dans le répertoire /Applications/ServBay/www pour simplifier la gestion centralisée, comme la configuration des sites locaux (anciennement appelés « hôtes »).

Prérequis

Avant de commencer, assurez-vous d’avoir effectué les préparatifs suivants :

1. Installation de ServBay : ServBay est déjà installé avec succès sur votre macOS. ServBay propose un environnement de développement complet, incluant PHP, Composer, MySQL, PostgreSQL, Redis, Memcached, etc., tout ce qui est requis pour ce tutoriel.
2. Activation des paquets nécessaires : Dans le panneau de contrôle ServBay, assurez-vous que les paquets suivants sont installés et fonctionnent :
   • Version de PHP de votre choix (il est conseillé d’utiliser PHP 8.x ou supérieur)
   • Composer (inclus avec ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Vérifiez que la version PHP sélectionnée a bien activé les extensions memcached, redis, pdo_mysql, pdo_pgsql. ServBay active habituellement ces extensions par défaut. Vous pouvez vérifier cela dans la configuration PHP de ServBay.
3. Accès au terminal : Familiarité avec le Terminal de macOS.

Installer Webman

1. Vérifier la disponibilité de Composer

   ServBay est livré avec Composer pré-installé, prêt à l’emploi dans le Terminal. Vérifiez avec la commande suivante :

   composer --version

   Si le numéro de version de Composer s’affiche, tout est prêt.

2. Accéder au répertoire web de ServBay

   Ouvrez le Terminal et accédez au dossier racine conseillé pour vos sites ServBay :

   cd /Applications/ServBay/www

3. Créer un projet Webman avec Composer

   Utilisez la commande create-project de Composer pour installer Webman dans le répertoire de votre choix, ici nommé servbay-webman-app :

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

   Composer téléchargera Webman et ses dépendances dans ce nouveau dossier.

4. Entrer dans le dossier du projet

   Une fois l’installation terminée, accédez au dossier créé :

   cd servbay-webman-app

5. Installer les composants nécessaires

   Pour démontrer l’intégration de la base de données et du cache, installons le package ORM illuminate/database (composant Laravel), illuminate/redis, et d’autres outils . L’option -W (--with-dependencies) permet de résoudre les conflits de dépendances et assurer la compatibilité.

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

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

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

Pour que les exemples de code fonctionnent, vous devez créer la base de données webman_app et la table users dans MySQL et PostgreSQL sur ServBay. Par défaut, le mot de passe de l’utilisateur root est password.

Utilisez l’outil de gestion de base de données de ServBay (phpMyAdmin, pgAdmin via le panneau de contrôle), ou le terminal pour exécuter ces requêtes SQL.

1. Créer 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éer 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 base 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

Ajoutons maintenant les routes, contrôleurs, et la logique d’interaction avec la base de données et le cache.

1. Configurer les routes

   Modifiez le fichier config/route.php à la racine de votre projet pour y ajouter les routes suivantes :

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Définir la route racine, relié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 plus de routes ici si besoin...

2. Créer les fichiers des contrôleurs

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

   • app/controller/IndexController.php : pour gérer 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 gérer la racine
          * @param Request $request Objet request actuel
          * @return Response Retourne un objet Response
          */
         public function index(Request $request): Response // Spécifie le type de retour
         {
             // Retourne une simple réponse textuelle
             return response('Hello ServBay & Webman!'); // Message de bienvenue mis à jour
         }
     }

   • app/controller/CacheController.php : pour illustrer l’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 Façade Redis de Webman
     
     class CacheController
     {
         /**
          * Démonstration de l'utilisation de Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Connexion au serveur Memcached, par défaut sur 127.0.0.1:11211 avec ServBay
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Définition d'un cache avec une durée de 60 secondes
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Clé et valeur modifiées
             if (!$success) {
                  return response('Échec lors de l’ajout de la clé Memcached', 500);
             }
     
             // Récupération de la valeur
             $value = $memcached->get('servbay_key'); // Clé modifiée
     
             // Retourne la valeur obtenue
             return response($value ?: 'Clé Memcached non trouvée ou expirée'); // Message si absent
         }
     
         /**
          * Démonstration de l'utilisation de Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Définir une clé cache via le Façade Redis de Webman
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Clé et valeur modifiées
     
             // Récupérer la clé cache
             $value = Redis::get('servbay_redis_key'); // Clé modifiée
     
             // Retourne la valeur obtenue
             return response($value ?: 'Clé Redis non trouvée'); // Message si absent
         }
     }

   • app/controller/DatabaseController.php : pour illustrer les opérations MySQL et PostgreSQL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Import du Façade Db de Webman
     
     class DatabaseController
     {
         /**
          * Ajoute un utilisateur à la base MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Insertion dans la BDD 'mysql' via Db Facade
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Exemple
                     'email' => '[email protected]', // Email exemple
                     'created_at' => date('Y-m-d H:i:s') // Ajout created_at
                 ]);
                 return response('Utilisateur ajouté à MySQL'); // Message de retour
             } catch (\Exception $e) {
                 return response('Erreur lors de l’ajout à MySQL : ' . $e->getMessage(), 500); // Erreur détaillée
             }
         }
     
         /**
          * Liste les utilisateurs MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Récupération utilisateurs via Db Facade
                 $users = Db::connection('mysql')->table('users')->get();
                 // Retourne la liste des utilisateurs au format JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Type explicitement JSON
             } catch (\Exception $e) {
                  return response('Erreur lors de la récupération depuis MySQL : ' . $e->getMessage(), 500);
             }
         }
     
         /**
          * Ajoute un utilisateur à PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Insertion dans la BDD 'pgsql'
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User',
                     'email' => '[email protected]',
                     'created_at' => date('Y-m-d H:i:s')
                 ]);
                 return response('Utilisateur ajouté à PostgreSQL');
              } catch (\Exception $e) {
                 return response('Erreur lors de l’ajout à PostgreSQL : ' . $e->getMessage(), 500);
              }
         }
     
         /**
          * Liste les utilisateurs PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Récupération utilisateurs
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Retourne la liste des utilisateurs au format JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']);
              } catch (\Exception $e) {
                 return response('Erreur lors de la récupération depuis PostgreSQL : ' . $e->getMessage(), 500);
              }
         }
     }

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

   Editez le fichier config/database.php à la racine du projet afin de renseigner les paramètres de connexion. Par défaut, ServBay utilise 127.0.0.1 : port 3306 pour MySQL, 5432 pour PostgreSQL, utilisateur root, mot de passe password.

   <?php
   /**
    * Configuration des bases de données
    */
   return [
       // Connexion utilisée par défaut
       'default' => 'mysql',
   
       // Liste des connexions
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Adresse et port MySQL par défaut ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nom de la base créée précédemment
               'database'  => 'webman_app',
               // Identifiant par défaut ServBay
               'username'  => 'root',
               // Mot de passe par défaut ServBay
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Adresse et port PostgreSQL par défaut ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nom de la base créée auparavant
               'database' => 'webman_app',
                // Identifiant par défaut
               'username' => 'root',
                // Mot de passe par défaut
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // ou require, verify-ca, verify-full
           ],
           // Ajoutez d’autres connexions ici si besoin...
       ],
   ];

   Attention : en production, pensez à changer le mot de passe par défaut et évitez de le coder en dur dans vos sources.

Lancer le projet Webman

Les projets Webman se lancent généralement via le script start.php, qui démarre le processus Workerman. Contrairement au schéma Nginx/Apache + PHP-FPM classique, Webman tourne en mémoire de façon asynchrone.

Dans le dossier du projet (/Applications/ServBay/www/servbay-webman-app), lancez :

php start.php start

Après exécution, vous verrez les informations de démarrage de Webman. Par défaut, il écoute en HTTP sur 127.0.0.1:8787.

• Note : la commande php utilise l’exécutable PHP de votre environnement ServBay. ServBay configure votre terminal pour que vous puissiez utiliser directement la version PHP qu’il gère.
• 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 Webman : php start.php restart.
• Pour un redémarrage en douceur (sans interrompre les requêtes), lancez : php start.php reload.

Tester le projet

Après lancement de Webman sur 127.0.0.1:8787, vous pouvez tester vos fonctionnalités dans le navigateur en visitant :

• http://localhost:8787/ : devrait afficher Hello ServBay & Webman!.
• http://localhost:8787/memcached : affichera Hello Memcached from ServBay! — preuve que la connexion Memcached fonctionne.
• http://localhost:8787/redis : affichera Hello Redis from ServBay! — la connexion Redis fonctionne.
• http://localhost:8787/mysql-add : affichera Utilisateur ajouté à MySQL, et insèrera un enregistrement dans la table users de la BDD MySQL.
• http://localhost:8787/mysql : retournera un JSON listant les utilisateurs de la table users sous MySQL.
• http://localhost:8787/pgsql-add : affichera Utilisateur ajouté à PostgreSQL, et insèrera un enregistrement dans la table users de la BDD PostgreSQL.
• http://localhost:8787/pgsql : retournera un JSON listant les utilisateurs de la table users sous PostgreSQL.

En cas de problème, vérifiez la sortie du Terminal, ainsi que l’état des services MySQL, PostgreSQL, Redis, Memcached dans ServBay, et assurez-vous que les extensions PHP requises sont bien activées.

FAQ – Problèmes courants

• Q : La commande php start.php start est introuvable ?
  • R : Assurez-vous d’être dans le dossier servbay-webman-app avec le Terminal (cd ...). Vérifiez aussi que ServBay a bien configuré votre PATH système (ce qu’il fait normalement automatiquement).
• Q : Connexion échouée sur localhost:8787 ?
  • R : Consultez la sortie du Terminal lors de l’exécution de php start.php start pour y voir d’éventuelles erreurs. Vérifiez aussi qu’aucun autre service n’occupe le port 8787. Si nécessaire, modifiez le port dans le fichier config/server.php de Webman.
• Q : Problèmes de connexion à la base de données ?
  • R : Vérifiez que MySQL et PostgreSQL tournent bien dans ServBay. Contrôlez les infos de connexion dans config/database.php (hôte, port, nom de base, identifiant, mot de passe — par défaut utilisateur root, mot de passe password). Assurez-vous d’avoir bien créé la base webman_app et la table users.
• Q : Échec de connexion à Memcached ou Redis ?
  • R : Vérifiez que les services Memcached et Redis sont actifs dans ServBay. Contrôlez l’adresse et le port dans app/controller/CacheController.php (127.0.0.1:11211 et 127.0.0.1:6379). Vérifiez que les extensions memcached et redis sont bien activées dans votre version PHP.

Résumé

En suivant ces étapes, vous avez créé, configuré et démarré avec succès un projet Webman basique dans l’environnement de développement local ServBay. Vous savez maintenant profiter du guichet unique ServBay pour déployer rapidement un environnement projet pour Webman et y intégrer base de données et cache. Les performances de Webman associées à la commodité de ServBay offrent une base puissante pour vos applications PHP asynchrones. Nous espérons que ce tutoriel vous aidera à tirer le meilleur parti de ServBay et Webman pour concevoir des applications web performantes.