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 :
- 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.
- 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
Accédez au répertoire racine des sites ServBay :
macOS :
bashcd /Applications/ServBay/www
1Windows :
cmdcd C:\ServBay\www
1Créez le répertoire du projet : Créez un dossier dédié à votre projet Slim.
bashmkdir servbay-slim-app
1Entrez dans le répertoire du projet :
bashcd servbay-slim-app
1Installez Slim via Composer : Utilisez Composer pour installer le framework Slim et son implémentation PSR-7.
bashcomposer require slim/slim "^4.0" slim/psr7 -W
1Cette commande télécharge Slim et la bibliothèque
slim/psr7
dans le dossiervendor
du projet, et génère les fichierscomposer.json
etcomposer.lock
.
Initialiser l’application Slim
- 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 dossierpublic
à la racine du projet, puis initialisez le fichier d’entrée.bashmkdir public touch public/index.php
1
2 - Modifiez le fichier d’entrée : Ouvrez
public/index.php
et ajoutez le code Slim de base suivant :phpCe code met en place une application Slim minimale, qui définit une route traitant les requêtes GET sur l’URL racine (<?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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22/
) 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).
- Ouvrez l’interface de ServBay.
- Allez dans le module Sites web (Websites).
- Cliquez pour ajouter un nouveau site.
- 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.- macOS :
- 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.
- 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.
- 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
bashcomposer require robmorgan/phinx
1 - macOS :
- Initialisez le fichier de configuration de Phinx :bashCeci crée
vendor/bin/phinx init
1phinx.yml
à la racine. Modifiez ce fichier selon vos paramètres :yamlpaths: 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- Installez Phinx via Composer dans le dossier racine du projet :
- Créer le fichier de migration : Utilisez Phinx pour générer un fichier de migration.bashUn fichier PHP est généré dans
vendor/bin/phinx create CreateUsersTable
1db/migrations
. Modifiez la méthodechange()
pour définir la structure de la tableusers
:php<?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(); } }
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écutez la migration : Exécutez Phinx dans le dossier racine du projet pour créer la table
users
.bashImportant : Avant d’utiliser les exemples ci-dessous, assurez-vous d’avoir créé la base et lancé les migrations.vendor/bin/phinx migrate
1
Utiliser le composant illuminate/database
Nous allons employer le composant Eloquent de Laravel (illuminate/database
) en tant qu’ORM/builder de requêtes.
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
bashcomposer require illuminate/database
1- macOS :
Initialiser la connexion dans
public/index.php
: Juste aprèsrequire __DIR__ . '/../vendor/autoload.php';
et avant la création de l’application Slim$app = AppFactory::create();
, ajoutez le code suivant pour la connexion :php// ... 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();) ...
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 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 :
php
// ... 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();
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
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 :
- Accédez à
https://servbay-slim-test.local/mysql-add-user
pour ajouter un utilisateur à la tableusers
. - 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
:
php
$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 ...
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
Puis ajoutez, avant $app->run();
, ces routes :
php
// ... 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();
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
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
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
.
Installer le client Memcached : Dans le dossier racine du projet :
- macOS :
/Applications/ServBay/www/servbay-slim-app
- Windows :
C:\ServBay\www\servbay-slim-app
bashcomposer require memcached/memcached
1- macOS :
Ajouter une route Memcached dans
public/index.php
: Insérez, avant$app->run();
:php// ... 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();
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
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
.
Installer le client Redis : Dans le dossier racine du projet :
- macOS :
/Applications/ServBay/www/servbay-slim-app
- Windows :
C:\ServBay\www\servbay-slim-app
bashcomposer require predis/predis
1- macOS :
Ajouter une route Redis dans
public/index.php
: Insérez, avant$app->run();
:php// ... 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();
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
38
39
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.