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 :
- Installé et lancé ServBay : ServBay doit déjà être installé sur votre macOS et l’application tournée.
- 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.
- Placez-vous dans le répertoire racine des sites ServBay :bash
cd /Applications/ServBay/www
1 - Créez un nouveau dossier de projet :bash
mkdir servbay-slim-app
1 - Accédez au dossier du projet :bash
cd servbay-slim-app
1 - Installez Slim avec Composer : Depuis le dossier du projet, lancez :bashCette commande télécharge le framework Slim et la bibliothèque
composer require slim/slim "^4.0" slim/psr7 -W
1slim/psr7
dans le dossiervendor
du projet, générant également les fichierscomposer.json
etcomposer.lock
.
Initialiser l'application Slim
- 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 dossierpublic
à la racine du projet, puis le fichier :bashmkdir public touch public/index.php
1
2 - Éditez le fichier d’entrée : Ouvrez
public/index.php
et ajoutez l’exemple de code Slim suivant :phpCe code illustre une application Slim minimale, qui définit une route GET sur l’URL racine (<?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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22/
) 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).
- Ouvrez l’interface de l’application ServBay.
- Rendez-vous dans le module Sites web.
- Cliquez sur « Ajouter un site ».
- 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
danspublic
.
- Nom :
- 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.
- 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.
- 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 :bashcomposer require robmorgan/phinx
1 - Initialisez la configuration :bashCela crée un fichier
vendor/bin/phinx init
1phinx.yml
à la racine du projet. Éditez-le selon vos informations :yamlpaths: 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- Depuis
- Créer un fichier de migration :bashUn nouveau fichier PHP apparaît dans
vendor/bin/phinx create CreateUsersTable
1db/migrations
. Modifiez le contenu de la méthodechange()
pour définir la tableusers
:php<?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(); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 - Exécuter la migration :bashImportant : Complétez impérativement la création et la migration de la base avant de poursuivre les exemples code ci-dessous.
vendor/bin/phinx migrate
1
Utilisation du composant illuminate/database
Nous allons utiliser le composant DB de Laravel (illuminate/database
) comme ORM et constructeur de requêtes.
Installer illuminate/database depuis
/Applications/ServBay/www/servbay-slim-app
:bashcomposer require illuminate/database
1Initialiser la connexion dans
public/index.php
: Juste aprèsrequire __DIR__ . '/../vendor/autoload.php';
et avant la création de Slim$app = AppFactory::create();
, ajoutez :php// ... 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(); ) ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Accès :
- Rendez-vous sur
https://servbay-slim-test.local/mysql-add-user
pour ajouter un utilisateur à la tableusers
. - 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é ...
2
3
4
5
6
7
8
9
10
11
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();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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
.
Installer la librairie Memcached :
bashcomposer require memcached/memcached
1Ajouter la route Memcached dans
public/index.php
(avant$app->run();
) :php// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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
.
Installer predis/predis :
bashcomposer require predis/predis
1Ajouter la route Redis dans
public/index.php
(avant$app->run();
) :php// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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.