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

Ce guide vous explique comment créer, configurer et lancer rapidement un projet basé sur le framework Slim PHP dans ServBay, une solution complète pour le développement web local. ServBay intègre PHP, des serveurs web (Caddy/Nginx/Apache) et divers packages de bases de données, ce qui en fait la plateforme idéale pour développer avec Slim.

Qu’est-ce que Slim ?

Slim est un micro-framework PHP léger conçu pour créer rapidement des applications web simples mais puissantes et des APIs. Il fournit des fonctions essentielles telles que le routage, la gestion des requêtes et des réponses, parfait pour les projets nécessitant un développement et un déploiement rapides ou comme base pour des applications plus complexes.

Principales caractéristiques et avantages de Slim

• Légèreté : Le cœur du framework Slim est très compact, consomme peu de ressources et démarre rapidement, idéal pour les applications de petite à moyenne envergure ou les microservices.
• Flexibilité : Slim est conçu pour être extensible et s’intègre facilement avec n’importe quelle bibliothèque ou composant tiers (moteurs de template, ORM, gestion d’authentification, etc.), permettant un grand choix d’outils selon les besoins de votre projet.
• Simplicité d’utilisation : Grâce à une API claire et une documentation complète, les développeurs peuvent rapidement comprendre les concepts centraux et commencer à coder.
• Routage avancé : Slim prend en charge différents verbes HTTP (GET, POST, PUT, DELETE, etc.) et offre des configurations de routage avancées, telles que le regroupement des routes, la gestion des middlewares et la capture de paramètres.
• Support des middlewares : La couche middleware dans Slim permet d’exécuter des tâches avant que la logique de l’application ne soit lancée ou avant que la réponse ne soit envoyée au client, comme l’authentification, la journalisation ou la gestion CORS.

Slim est idéal pour concevoir des APIs RESTful, prototyper rapidement ou développer des fonctionnalités indépendantes.

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

Ce guide s’appuie sur la configuration PHP pré-intégrée de ServBay et la fonctionnalité site web pour paramétrer le serveur web, permettant un accès facilité à votre projet Slim.

Prérequis

Avant de commencer, assurez-vous que :

1. ServBay est installé et actif : ServBay doit être installé avec succès sur votre système macOS ou Windows, et l’application doit être en cours d’exécution.
2. Composer est inclus dans ServBay : ServBay intègre Composer par défaut, aucune installation séparée n’est nécessaire.

Créer un projet Slim

Il est recommandé de regrouper tous vos projets web dans le répertoire suivant, ce qui facilite la gestion et la configuration via ServBay :

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

1. Accédez au répertoire racine des sites ServBay :

   macOS :

   cd /Applications/ServBay/www

   Windows :

   cd C:\ServBay\www

2. Créez le répertoire du projet : Créez un dossier dédié à votre projet Slim.

   mkdir servbay-slim-app

3. Entrez dans le répertoire du projet :

   cd servbay-slim-app

4. Installez Slim via Composer : Utilisez Composer pour installer le framework Slim et son implémentation PSR-7.

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

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

Initialiser l’application Slim

1. Créez le fichier d’entrée : Un projet Slim utilise généralement un fichier principal (par exemple public/index.php) qui gère toutes les requêtes. Créez le dossier public à la racine du projet, puis initialisez le fichier d’entrée.

   mkdir public
   touch public/index.php

2. Modifiez le fichier d’entrée : Ouvrez public/index.php et ajoutez le code Slim de base suivant :

   <?php
   // Chargement automatique de Composer
   require __DIR__ . '/../vendor/autoload.php';
   
   // Importation des interfaces PSR-7 et de la fabrique Slim
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Création de l’application Slim
   $app = AppFactory::create();
   
   // Définition d’une route GET de base sur la racine ‘/’
   $app->get('/', function (Request $request, Response $response, $args) {
       // Écriture du contenu dans la réponse
       $response->getBody()->write("Hello ServBay!");
       // Retourne l’objet réponse
       return $response;
   });
   
   // Démarrage de l’application Slim
   $app->run();

   Ce code met en place une application Slim minimale, qui définit une route traitant les requêtes GET sur l’URL racine (/) et retourne une réponse contenant le texte "Hello ServBay!".

Configurer le site dans ServBay

Pour accéder à votre projet Slim dans le navigateur, vous devez créer un site web dans ServBay (appelé "hôte" dans les anciennes versions).

1. Ouvrez l’interface de ServBay.
2. Allez dans le module Sites web (Websites).
3. Cliquez pour ajouter un nouveau site.
4. Renseignez les paramètres selon votre projet :

   • Nom : My First Slim Dev Site (ou tout nom de votre choix)

   • Domaine : servbay-slim-test.local (il est conseillé d’utiliser une extension .local ou .test pour les domaines de développement)

   • Type de site : PHP

   • Version de PHP : Sélectionnez la version souhaitée, par exemple 8.3.

   • Racine du site (Document Root) : Cliquez sur parcourir et sélectionnez le répertoire public de votre projet :

     • macOS : /Applications/ServBay/www/servbay-slim-app/public
     • Windows : C:\ServBay\www\servbay-slim-app\public

     En effet, le fichier d’entrée de Slim (index.php) se trouve dans ce dossier, qui doit donc être la racine du site pour le serveur web.

5. Enregistrez la configuration. ServBay mettra à jour la configuration du serveur web et l’appliquera automatiquement.

Pour des instructions détaillées sur la configuration des sites, consultez Ajouter votre premier site.

Accéder à votre site Slim

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

Si tout fonctionne, la page affichera le message Hello ServBay!, indiquant que votre projet Slim s’exécute correctement sur le serveur web ServBay.

Exemple d’intégration de base de données

Le framework Slim ne fournit pas de couche d’abstraction pour la base de données, mais il s’intègre facilement avec de nombreuses bibliothèques PHP. Ici, nous utilisons l’ORM Eloquent de Laravel (via le composant illuminate/database) pour connecter MySQL et PostgreSQL, et nous proposons aussi des exemples pour Memcached et Redis.

Prérequis : créer la base de données et exécuter les migrations

Avant l’intégration de la base de données, il est nécessaire de créer les bases et la structure des tables nécessaires depuis ServBay.

1. Créer la base de données :
   • Lancez ServBay, naviguez vers le package de base de données utilisé (MySQL ou PostgreSQL).
   • Utilisez l’outil d’administration fourni, comme phpMyAdmin pour MySQL/MariaDB ou pgAdmin pour PostgreSQL, ou encore le client en ligne de commande, pour créer une nouvelle base, par ex. servbay_slim_app.
   • Le mot de passe root est généralement password par défaut, modifiable dans ServBay.
2. Installer et configurer Phinx (outil de migration) : Phinx est un outil populaire de migration PHP pour versionner le schéma de la base.
   • Installez Phinx via Composer dans le dossier racine du projet :
     • macOS : /Applications/ServBay/www/servbay-slim-app
     • Windows : C:\ServBay\www\servbay-slim-app

     composer require robmorgan/phinx

   • Initialisez le fichier de configuration de Phinx :

     vendor/bin/phinx init

     Ceci crée phinx.yml à la racine. Modifiez ce fichier selon vos paramètres :

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development # ou nom du contexte voulu
     
         development: # Adapter selon le 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. Pour PostgreSQL : 5432
             charset: utf8mb4 # Recommandé pour MySQL
             collation: utf8mb4_unicode_ci # Recommandé pour MySQL
     
     version_order: creation

3. Créer le fichier de migration : Utilisez Phinx pour générer un fichier de migration.

   vendor/bin/phinx create CreateUsersTable

   Un fichier PHP est généré dans db/migrations. Modifiez la méthode change() pour définir la structure de la table users :

   <?php
   
   declare(strict_types=1);
   
   use Phinx\Migration\AbstractMigration;
   
   final class CreateUsersTable extends AbstractMigration
   {
       /**
        * Méthode Change.
        *
        * Écrivez vos migrations réversibles ici.
        *
        * Pour en savoir plus : https://book.cakephp.org/phinx/0/fr/migrations.html#the-change-method
        *
        * Utilisez "create()" ou "update()", et non "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écutez la migration : Exécutez Phinx dans le dossier racine du projet pour créer la table users.

   vendor/bin/phinx migrate

   Important : Avant d’utiliser les exemples ci-dessous, assurez-vous d’avoir créé la base et lancé les migrations.

Utiliser le composant illuminate/database

Nous allons employer le composant Eloquent de Laravel (illuminate/database) en tant qu’ORM/builder de requêtes.

1. Installez illuminate/database : Installez-le dans le dossier racine du projet :

   • macOS : /Applications/ServBay/www/servbay-slim-app
   • Windows : C:\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 l’application Slim $app = AppFactory::create();, ajoutez le code suivant pour la connexion :

   // ... Autres require et use ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // Import du gestionnaire Capsule
   
   // Initialiser Eloquent ORM
   $capsule = new Capsule;
   
   // Configuration de connexion (adapter driver et paramètres selon la base)
   $capsule->addConnection([
       'driver' => 'mysql', // ou 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app', // nom de la base
       'username' => 'root', // identifiant
       'password' => 'password', // mot de passe
       'charset' => 'utf8mb4', // recommandé pour MySQL
       'collation' => 'utf8mb4_unicode_ci', // recommandé pour MySQL
       'prefix' => '',
       // PostgreSQL : ajoutez le paramètre schema
       // 'schema' => 'public',
   ]);
   
   // Rendre accessible globalement
   $capsule->setAsGlobal();
   
   // Démarrer Eloquent
   $capsule->bootEloquent();
   
   // ... Création de l’application Slim ($app = AppFactory::create();) ...

Exemple MySQL

Supposons que MySQL est démarré dans ServBay, que la base servbay_slim_app est créée et que la table users existe après migration.

Dans public/index.php, avant $app->run();, ajoutez ces routes :

// ... Code d’initialisation et route ‘/’ précédents ...

use Illuminate\Database\Capsule\Manager as Capsule; // Assurez-vous de bien importer

// 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', // utilisation de time() pour garantir 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); // retourne un code d’erreur
    }
    return $response;
});

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

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

Accès :

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

Exemple PostgreSQL

Supposons que PostgreSQL est démarré dans ServBay, que la base servbay_slim_app est créée et la table users présente (vérifiez que l’adapter et le port pgsql/5432 sont bien configurés dans Phinx).

En modifiant la configuration dans public/index.php, mettez le driver à pgsql et ajoutez le paramètre schema :

$capsule->addConnection([
    'driver' => 'pgsql', // passez à pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // PostgreSQL utilise généralement utf8
    'prefix' => '',
    'schema' => 'public', // spécifier le schema PostgreSQL
]);
// ... Autre initialisation Eloquent inchangée ...

Puis ajoutez, avant $app->run();, ces routes :

// ... Initialisation et route ‘/’ précédentes ...
// ... Routes MySQL (si besoin) ...

use Illuminate\Database\Capsule\Manager as Capsule; // Assurez-vous de bien importer

// 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', // unicité garantie
            '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 récupérer 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 lors de la récupération : ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

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

Accès :

• Accédez à https://servbay-slim-test.local/pgsql-add-user pour ajouter un utilisateur dans PostgreSQL.
• Accédez à https://servbay-slim-test.local/pgsql-get-users pour lister les utilisateurs au format JSON.

Exemple Memcached

ServBay intègre le package Memcached et l’extension PHP ext-memcached. Installez simplement un client PHP, ici memcached/memcached.

1. Installer le client Memcached : Dans le dossier racine du projet :

   • macOS : /Applications/ServBay/www/servbay-slim-app
   • Windows : C:\ServBay\www\servbay-slim-app

   composer require memcached/memcached

2. Ajouter une route Memcached dans public/index.php : Insérez, avant $app->run(); :

   // ... Initialisation et routes base de données précédentes ...
   
   // Route d’exemple pour Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Création du client Memcached
       $memcached = new Memcached();
       // Ajout du serveur (127.0.0.1:11211 utilisé par défaut par ServBay)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Tentative de récupération depuis le cache
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Si non présent, création et mise en cache
           $cachedData = 'Hello Memcached from ServBay! This was not cached.';
           // Enregistrement pour 60 secondes
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // Si présent, utilisation directe des données en cache
           $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 (avant expiration) affichent "This was served from cache.".

Exemple Redis

ServBay intègre Redis et l’extension PHP ext-redis. Installez simplement un client PHP, ici predis/predis.

1. Installer le client Redis : Dans le dossier racine du projet :

   • macOS : /Applications/ServBay/www/servbay-slim-app
   • Windows : C:\ServBay\www\servbay-slim-app

   composer require predis/predis

2. Ajouter une route Redis dans public/index.php : Insérez, avant $app->run(); :

   // ... Initialisation et routes base de données précédentes ...
   // ... Routes Memcached (si besoin) ...
   
   use Predis\Client as RedisClient; // Import du client Predis
   
   // Route d’exemple pour Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Création du client Redis (par défaut sur 127.0.0.1:6379 dans ServBay)
           $redis = new RedisClient([
               'scheme' => 'tcp',
               'host' => '127.0.0.1',
               'port' => 6379,
           ]);
   
           $cacheKey = 'my_servbay_redis_cache_key';
           // Lecture du cache
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Si absent, création et enregistrement avec expiration à 60s
               $cachedData = 'Hello Redis from ServBay! This was not cached.';
               $redis->setex($cacheKey, 60, $cachedData); // SETEX key seconds value
               $response->getBody()->write($cachedData);
           } else {
               // Si présent, utilisation directe
               $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
           }
       } catch (\Exception $e) {
           // Gestion des erreurs de connexion ou d’opération
           $response->getBody()->write('Erreur de connexion à Redis ou lors de l\'opération : ' . $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 (avant expiration) affichent "This was served from cache.".

Conclusion

En suivant ce guide, vous avez créé et hébergé un projet Slim Framework dans ServBay, puis configuré les packages ServBay (MySQL, PostgreSQL, Memcached, Redis) et leurs extensions PHP pour intégrer une base de données et du cache dans votre application Slim. ServBay simplifie la gestion et la mise en place de votre environnement local, vous permettant de vous concentrer sur le développement même de votre application Slim.