Créer et exécuter un projet Slim dans ServBay

Ce guide explique comment créer, configurer et exécuter rapidement un projet utilisant le Slim Framework PHP dans ServBay, un puissant environnement de développement web local. ServBay propose une intégration de PHP, de serveurs web (Caddy/Nginx/Apache) et de multiples solutions de bases de données, ce qui en fait une plateforme idéale pour développer avec Slim.

Qu'est-ce que Slim ?

Slim est un micro-framework PHP léger conçu pour construire rapidement des applications web et des API simples mais puissantes. Il offre des fonctionnalités essentielles de routage, de gestion de requêtes et de réponses, ce qui le rend parfait pour des projets à déploiement rapide ou servant de socle à des applications plus complexes.

Principales fonctionnalités et avantages de Slim

• Léger : Le noyau de Slim est extrêmement minimaliste, très peu gourmand en ressources et rapide au démarrage. Il convient particulièrement à la création de petites et moyennes applications ou microservices.
• Flexible : Conçu pour être modulable, Slim s’intègre facilement à n’importe quel composant ou bibliothèque PHP externe (par exemple moteur de templates, ORM, outil d’authentification…), offrant ainsi une grande liberté pour adapter l’architecture à vos besoins spécifiques.
• Facile à utiliser : Son API claire et sa documentation concise permettent une prise en main rapide, même pour les nouveaux utilisateurs.
• Routage puissant : Prise en charge de multiples méthodes HTTP (GET, POST, PUT, DELETE, etc.) avec une gestion avancée du routing, incluant les groupes de routes, les middlewares et la capture de paramètres.
• Support des middlewares : Le système de middleware de Slim permet l’exécution de tâches comme l’authentification, le logging ou la gestion CORS avant que la requête atteigne la logique applicative ou que la réponse soit retournée au client.

Slim est ainsi le choix idéal pour créer une API RESTful, développer un prototype rapidement ou couvrir des besoins fonctionnels spécifiques.

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

Ce guide utilise l'environnement PHP préconfiguré de ServBay ainsi que sa fonctionnalité de Sites web pour préparer le serveur et rendre votre application Slim accessible.

Prérequis

Avant de commencer, assurez-vous d’avoir :

1. Installé et lancé ServBay : ServBay doit déjà être installé sur votre macOS et l’application tournée.
2. Composer intégré via ServBay : Composer est fourni par défaut avec ServBay, aucune installation supplémentaire n’est requise.

Créer un nouveau projet Slim

Il est recommandé de regrouper vos projets web sous /Applications/ServBay/www, afin de simplifier leur gestion avec ServBay.

1. Placez-vous dans le répertoire racine des sites ServBay :

   cd /Applications/ServBay/www

2. Créez un nouveau dossier de projet :

   mkdir servbay-slim-app

3. Accédez au dossier du projet :

   cd servbay-slim-app

4. Installez Slim avec Composer : Depuis le dossier du projet, lancez :

   composer require slim/slim "^4.0" slim/psr7 -W

   Cette commande télécharge le framework Slim et la bibliothèque slim/psr7 dans le dossier vendor du projet, générant également les fichiers composer.json et composer.lock.

Initialiser l'application Slim

1. Créez le fichier d’entrée du projet : Les projets Slim utilisent généralement un point d’entrée unique (souvent public/index.php) pour toutes les requêtes. Créez le dossier public à la racine du projet, puis le fichier :

   mkdir public
   touch public/index.php

2. Éditez le fichier d’entrée : Ouvrez public/index.php et ajoutez l’exemple de code Slim suivant :

   <?php
   // Charger l’autoloader Composer
   require __DIR__ . '/../vendor/autoload.php';
   
   // Importer les interfaces PSR-7 et la fabrique Slim
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Créer une instance Slim
   $app = AppFactory::create();
   
   // Définir une route GET pour la racine "/"
   $app->get('/', function (Request $request, Response $response, $args) {
       // Écrire dans le corps de la réponse
       $response->getBody()->write("Hello ServBay!");
       // Retourner la réponse
       return $response;
   });
   
   // Démarrer l'application Slim
   $app->run();

   Ce code illustre une application Slim minimale, qui définit une route GET sur l’URL racine (/) et renvoie le texte "Hello ServBay!" en réponse.

Configurer le site web dans ServBay

Afin de rendre votre projet Slim accessible via un navigateur, il faut enregistrer un site web dans ServBay (appelé « Hôte » dans les anciennes versions).

1. Ouvrez l’interface de l’application ServBay.
2. Rendez-vous dans le module Sites web.
3. Cliquez sur « Ajouter un site ».
4. Renseignez les champs suivants :
   • Nom : My First Slim Dev Site (ou le nom de votre choix)
   • Domaine : servbay-slim-test.local (utilisez idéalement une extension locale comme .local ou .test)
   • Type de site : PHP
   • Version de PHP : Sélectionnez la version PHP désirée, par exemple 8.3.
   • Racine du site : Indiquez le dossier public de votre projet, soit /Applications/ServBay/www/servbay-slim-app/public. Cela garantit que le serveur pointe vers le bon point d’entrée : index.php dans public.
5. Enregistrez la configuration du site. ServBay mettra alors à jour et appliquera automatiquement la configuration du serveur web.

Pour plus de détails, consultez le guide Ajouter un premier site web.

Accéder à votre site Slim

Une fois configuré, ouvrez votre navigateur et rendez-vous sur : https://servbay-slim-test.local.

Si tout fonctionne, la page affichera le texte « Hello ServBay! », signe que votre projet Slim fonctionne bien via ServBay.

Exemple d'intégration de bases de données

Slim ne propose pas de couche d’abstraction de base de données, mais il s’intègre très bien avec différentes bibliothèques PHP de gestion de bases de données. Dans l’exemple suivant, nous allons connecter MySQL et PostgreSQL à l’aide d’ORM Eloquent (via le composant illuminate/database de Laravel) et montrer aussi l’intégration de Memcached et Redis.

Prérequis : création de la base de données et exécution des migrations

Avant d’intégrer la base de données, créez-la au préalable dans ServBay et préparez la structure nécessaire.

1. Créer la base de données :
   • Depuis l’interface ServBay, accédez à l’outil de gestion de la base (par exemple phpMyAdmin pour MySQL/MariaDB, pgAdmin pour PostgreSQL).
   • Créez une base nommée (par exemple) servbay_slim_app.
   • Le mot de passe root par défaut dans ServBay est souvent password ; vérifiez ou modifiez-le au besoin depuis l’interface.
2. Installer et configurer Phinx (outil de migration) : Phinx permet le versionnage de vos schémas de BDD.
   • Depuis /Applications/ServBay/www/servbay-slim-app, installez Phinx :

     composer require robmorgan/phinx

   • Initialisez la configuration :

     vendor/bin/phinx init

     Cela crée un fichier phinx.yml à la racine du projet. Éditez-le selon vos informations :

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development # Ou le nom de votre environnement
     
         development: # À ajuster selon votre type de base
             adapter: mysql # ou pgsql
             host: 127.0.0.1
             name: servbay_slim_app # nom de la base
             user: root
             pass: password # mot de passe
             port: 3306 # MySQL par défaut ; PostgreSQL = 5432
             charset: utf8mb4
             collation: utf8mb4_unicode_ci
     
     version_order: creation

3. Créer un fichier de migration :

   vendor/bin/phinx create CreateUsersTable

   Un nouveau fichier PHP apparaît dans db/migrations. Modifiez le contenu de la méthode change() pour définir la table users :

   <?php
   
   declare(strict_types=1);
   
   use Phinx\Migration\AbstractMigration;
   
   final class CreateUsersTable extends AbstractMigration
   {
       /**
        * Méthode Change.
        *
        * Écrivez les migrations réversibles ici.
        *
        * Plus d'infos : https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
        *
        * Rappel : utilisez "create()" ou "update()", jamais "save()" avec la classe Table.
        */
       public function change(): void
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string')
                 ->addColumn('email', 'string', ['unique' => true])
                 ->addTimestamps() // Ajoute les champs created_at et updated_at
                 ->create();
       }
   }

4. Exécuter la migration :

   vendor/bin/phinx migrate

   Important : Complétez impérativement la création et la migration de la base avant de poursuivre les exemples code ci-dessous.

Utilisation du composant illuminate/database

Nous allons utiliser le composant DB de Laravel (illuminate/database) comme ORM et constructeur de requêtes.

1. Installer illuminate/database depuis /Applications/ServBay/www/servbay-slim-app :

   composer require illuminate/database

2. Initialiser la connexion dans public/index.php : Juste après require __DIR__ . '/../vendor/autoload.php'; et avant la création de Slim $app = AppFactory::create();, ajoutez :

   // ... autres require et use ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // Importer Capsule
   
   // Initialiser Eloquent ORM
   $capsule = new Capsule;
   
   // Ajouter la configuration de votre base de données (adaptez le driver et les données)
   $capsule->addConnection([
       'driver' => 'mysql', // ou 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app',
       'username' => 'root',
       'password' => 'password',
       'charset' => 'utf8mb4',
       'collation' => 'utf8mb4_unicode_ci',
       'prefix' => '',
       // Pour PostgreSQL, ajoutez le paramètre 'schema'
       // 'schema' => 'public',
   ]);
   
   // Rendre accessible globalement
   $capsule->setAsGlobal();
   
   // Lancer Eloquent
   $capsule->bootEloquent();
   
   // ... création de l’app Slim ($app = AppFactory::create(); ) ...

Exemple MySQL

Supposons que MySQL soit lancé via ServBay, que vous ayez créé la base servbay_slim_app et effectué la migration Phinx.

Avant $app->run(); dans public/index.php, ajoutez les routes suivantes :

// ... code initialisation et route '/'

use Illuminate\Database\Capsule\Manager as Capsule; // Assurez-vous d'importer Capsule

// Route pour ajouter un utilisateur
$app->get('/mysql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay Demo User',
            'email' => 'servbay-demo-' . time() . '@servbay.test', // pour l’unicité
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('Utilisateur ajouté à MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Erreur lors de l\'ajout : ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Route pour lister les utilisateurs
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson());
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Erreur de récupération : ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Accès :

• Rendez-vous sur https://servbay-slim-test.local/mysql-add-user pour ajouter un utilisateur à la table users.
• Rendez-vous sur https://servbay-slim-test.local/mysql-get-users pour obtenir la liste des utilisateurs au format JSON.

Exemple PostgreSQL

Supposons que PostgreSQL tourne via ServBay, la base servbay_slim_app existe et la table a été créée avec Phinx (vérifiez adapter = pgsql, port = 5432).

Dans la configuration de connexion de public/index.php, changez le driver en pgsql et ajoutez schema :

$capsule->addConnection([
    'driver' => 'pgsql', // Remplacer par pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // PostgreSQL utilise souvent utf8
    'prefix' => '',
    'schema' => 'public',
]);
// ... le reste inchangé ...

Avant $app->run(); dans public/index.php, ajoutez :

// ... initialisation, route '/', routes MySQL éventuelles ...

use Illuminate\Database\Capsule\Manager as Capsule; // Assurez-vous d'importer Capsule

// Route pour ajouter un utilisateur
$app->get('/pgsql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay PG Demo User',
            'email' => 'servbay-pg-demo-' . time() . '@servbay.test',
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('Utilisateur ajouté à PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Erreur lors de l\'ajout : ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Route pour lister les utilisateurs
$app->get('/pgsql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson());
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Erreur de récupération : ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Accès :

• https://servbay-slim-test.local/pgsql-add-user permet d’ajouter un utilisateur dans PostgreSQL (users).
• https://servbay-slim-test.local/pgsql-get-users liste les utilisateurs au format JSON.

Exemple Memcached

ServBay inclut le paquet Memcached et l’extension PHP ext-memcached. Un simple client PHP suffit, ici on utilise memcached/memcached.

1. Installer la librairie Memcached :

   composer require memcached/memcached

2. Ajouter la route Memcached dans public/index.php (avant $app->run();) :

   // ... init et autres routes ...
   
   // Route Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Instancier le client Memcached
       $memcached = new Memcached();
       // Ajouter le serveur (par défaut sur 127.0.0.1:11211)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Essayer de récupérer depuis le cache
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Pas en cache, générer la donnée et la placer en cache
           $cachedData = 'Hello Memcached from ServBay! This was not cached.';
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // En cache, utiliser la donnée existante
           $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
       }
   
       return $response;
   });
   
   // ... $app->run();

Accès : Rendez-vous sur https://servbay-slim-test.local/memcached-example : la première visite affiche "This was not cached.", les suivantes (tant que non expiré) "This was served from cache.".

Exemple Redis

ServBay fournit le paquet Redis et l’extension PHP ext-redis. On utilise ici le client predis/predis.

1. Installer predis/predis :

   composer require predis/predis

2. Ajouter la route Redis dans public/index.php (avant $app->run();) :

   // ... initialisation, autres routes ...
   
   use Predis\Client as RedisClient; // Importer Predis
   
   // Route Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Connecter à Redis (par défaut 127.0.0.1:6379)
           $redis = new RedisClient([
               'scheme' => 'tcp',
               'host' => '127.0.0.1',
               'port' => 6379,
           ]);
   
           $cacheKey = 'my_servbay_redis_cache_key';
           // Essayer de lire depuis le cache
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Si non présent, générer la donnée et la placer en cache
               $cachedData = 'Hello Redis from ServBay! This was not cached.';
               $redis->setex($cacheKey, 60, $cachedData); // Expire dans 60 secondes
               $response->getBody()->write($cachedData);
           } else {
               // Sinon : utiliser le cache
               $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
           }
       } catch (\Exception $e) {
           // Gestion des erreurs
           $response->getBody()->write('Erreur de connexion à Redis : ' . $e->getMessage());
           $response = $response->withStatus(500);
       }
   
       return $response;
   });
   
   // ... $app->run();

Accès : Rendez-vous sur https://servbay-slim-test.local/redis-example : la première visite affiche "This was not cached.", les suivantes (si le cache n’a pas expiré) "This was served from cache.".

Conclusion

En suivant ce guide, vous avez appris à créer un projet Slim Framework complet dans l’environnement local proposé par ServBay et à le mettre en ligne grâce à la fonction Sites web de ServBay. Vous savez également comment exploiter les packages ServBay pour intégrer rapidement des bases de données (MySQL, PostgreSQL) et des systèmes de cache (Memcached, Redis) à votre application Slim. ServBay simplifie au maximum la mise en place et la gestion de votre environnement de développement afin que vous puissiez vous concentrer pleinement sur votre code PHP Slim.