Créer et exécuter un projet FuelPHP dans l’environnement de développement local ServBay
Qu’est-ce que FuelPHP ?
FuelPHP est un framework PHP flexible et modulaire, pensé pour concevoir des applications web modernes. Il suit le modèle de conception HMVC (Hierarchical Model-View-Controller) et met à disposition de nombreuses fonctionnalités et outils pour permettre aux développeurs de construire rapidement des applications web de qualité. Très souple, performant et facilement extensible, FuelPHP est un choix de prédilection pour de nombreux développeurs PHP.
Caractéristiques et avantages principaux de FuelPHP
- Architecture HMVC : Prend en charge le modèle de conception MVC hiérarchique, favorisant une organisation du code plus claire, une meilleure réutilisation et une approche modulaire, idéale pour les projets volumineux ou complexes.
- Hautes performances : Conçu pour l’efficacité, FuelPHP offre une rapidité d’exécution et une utilisation optimale des ressources, ce qui lui permet de bien gérer les requêtes simultanées.
- Facilité d’extension : Sa puissante architecture permet d’intégrer facilement des bibliothèques tierces ou d’ajouter des fonctionnalités personnalisées, s’adaptant ainsi à des besoins spécifiques.
- Sécurité : Inclut de nombreuses protections natives comme la validation automatique des entrées, l’échappement des sorties (contre les attaques XSS), la protection CSRF, ou encore la prévention des injections SQL afin de créer des applications plus sûres.
- Forte communauté : Une communauté de développeurs dynamique assure un excellent support, ainsi qu’un écosystème riche en ressources tierces.
Grâce à ces atouts, FuelPHP aide les développeurs à créer des applications web performantes, sécurisées et faciles à maintenir, adaptées aussi bien aux petits projets qu’aux solutions d’entreprise à grande échelle.
Installer l’environnement de développement FuelPHP avec ServBay
ServBay est un environnement de développement web local conçu pour les développeurs et pré-équipé de nombreux services (PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis, etc.). Avec ServBay, il est facile de mettre en place tous les prérequis pour un projet FuelPHP, sans avoir à installer ou configurer chaque dépendance manuellement.
Ce tutoriel décrit comment utiliser l’environnement PHP de ServBay, ainsi que le serveur web (Caddy), la base de données et les services de cache, pour créer et lancer un projet FuelPHP. Nous utiliserons la fonction Sites Web de ServBay pour configurer le serveur et simplifier l’accès ainsi que les tests du projet.
Pré-requis
Avant de commencer, veillez à rassembler les éléments suivants :
- ServBay doit être installé et fonctionner correctement sous macOS.
- L’environnement PHP de ServBay doit être activé (il l’est par défaut).
- Les services de base de données (ex : MySQL) ou de cache (ex : Redis, Memcached) dont vous avez besoin doivent être démarrés et opérationnels dans ServBay.
- Composer est préinstallé avec ServBay, inutile de l’installer séparément.
Créer un projet FuelPHP
Chemin recommandé pour l’emplacement du projet
ServBay recommande de placer ses projets web dans le dossier /Applications/ServBay/www
pour en faciliter la gestion et la configuration. Ce chemin sera utilisé dans notre exemple.
Se placer dans le répertoire racine des sites web
Ouvrez le terminal et rendez-vous dans le dossier recommandé :
bashcd /Applications/ServBay/www
1Créer le dossier du projet
Créez un nouveau dossier pour votre projet FuelPHP et entrez dedans :
bashmkdir servbay-fuelphp-app cd servbay-fuelphp-app
1
2Initialiser le projet FuelPHP avec Composer
Dans le dossier projet, téléchargez et initialisez FuelPHP avec Composer. Le
.
signifie que le projet sera créé dans le dossier courant :bashcomposer create-project fuel/fuel .
1Composer va automatiquement installer FuelPHP et toutes ses dépendances dans le répertoire
servbay-fuelphp-app
.
Configurer le serveur web (fonction Sites Web de ServBay)
Pour accéder à votre projet FuelPHP depuis un navigateur, il faut configurer un hôte virtuel avec la fonction Sites Web de ServBay.
- Ouvrez l’interface principale de ServBay.
- Cliquez sur le menu Sites Web dans la barre latérale.
- Cliquez sur Ajouter un site en haut à droite.
- Renseignez les informations suivantes dans la fenêtre de configuration :
- Nom : Choisissez un nom évocateur, ex :
My First FuelPHP Dev Site
. - Domaine : Définissez un domaine local, ex :
servbay-fuelphp-test.local
. ServBay le redirigera automatiquement vers votre machine. - Type de site : Choisissez
PHP
. - Version PHP : Sélectionnez la version PHP souhaitée, ex :
8.3
. - Dossier racine : Indiquez le répertoire contenant le point d’entrée de FuelPHP. L’entrée publique de FuelPHP est
public/index.php
, spécifiez donc le sous-dossierpublic
de votre projet :/Applications/ServBay/www/servbay-fuelphp-app/public
.
- Nom : Choisissez un nom évocateur, ex :
- Cliquez sur Ajouter pour sauvegarder.
ServBay va mettre à jour la configuration Caddy et recharger les services afin que le nouveau domaine soit accessible.
Pour plus de détails, consultez la documentation ServBay : Ajouter un premier site web.
Configurer la connexion aux services dans le projet FuelPHP
Un projet FuelPHP doit habituellement renseigner les informations de connexion à la base de données et au cache.
Configuration de la base de données
Le fichier de configuration de la base de données de FuelPHP se situe ici : fuel/app/config/development/db.php
. Éditez ce fichier et entrez les paramètres de connexion à la base. En supposant l’utilisation du service MySQL par défaut proposé par ServBay :
<?php
/**
* Paramètres de la base de données en développement. Fusionne avec la configuration globale.
*/
return [
'default' => [
'connection' => [
'dsn' => 'mysql:host=localhost;dbname=fuel_dev', // Assurez-vous que la base fuel_dev existe
'username' => 'root', // Utilisateur MySQL par défaut ServBay
'password' => 'root', // Mot de passe par défaut ServBay (conseillé seulement en local !)
],
'identifier' => '`', // MySQL exige l’utilisation de backticks pour les identifiants
],
];
2
3
4
5
6
7
8
9
10
11
12
13
14
Remarques :
- Il faut créer manuellement la base
fuel_dev
via un outil de gestion ServBay (phpMyAdmin ou Adminer). Le compte MySQLroot
par défaut a comme mot de passeroot
, ce réglage n’est recommandé que pour du développement local. 'identifier' => '
'` est nécessaire pour MySQL, afin de bien entourer les noms de tables et de champs.
Configuration du cache (Memcached et Redis)
FuelPHP prend en charge plusieurs systèmes de cache, à configurer dans fuel/app/config/cache.php
. Assurez-vous que Memcached et/ou Redis sont démarrés sous ServBay.
Configuration Memcached (fuel/app/config/cache.php
) :
Pour utiliser Memcached comme cache par défaut :
<?php
return [
'driver' => 'memcached', // Sélectionne memcached comme moteur
'memcached' => [
'cache_id' => 'fuel', // ID du cache
'servers' => [
'default' => [
'host' => '127.0.0.1', // Adresse Memcached locale
'port' => 11211, // Port Memcached par défaut
'weight' => 100,
],
],
'compression' => false, // Active ou non la compression
],
// ... Autres configurations de cache
];
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
L’extension Memcached est généralement déjà activée dans le PHP de ServBay.
Configuration Redis (fuel/app/config/redis.php
) :
Pour Redis, configurez la connexion comme suit, habituellement dans un fichier dédié redis.php
:
<?php
return [
'default' => [
'hostname' => '127.0.0.1', // Adresse locale Redis
'port' => 6379, // Port Redis par défaut
'database' => 0, // Index de la base Redis
],
// Il est possible de définir d'autres connexions Redis
];
2
3
4
5
6
7
8
9
L’extension Redis est elle aussi généralement activée par défaut dans ServBay.
Exemples d’utilisation de la base de données et du cache
Pour illustrer l’utilisation de la base de données et du cache dans FuelPHP, ajoutons quelques exemples.
Préparer la table via les migrations FuelPHP
L’outil Oil de FuelPHP sert à gérer les migrations de base de données (versionnage du schéma).
Générer un fichier de migration
Depuis la racine du projet (
servbay-fuelphp-app
), créez un fichier de migration pour la tableusers
:bashphp oil generate migration create_users_table
1Un nouveau fichier de migration sera créé dans
fuel/app/migrations
, avec un timestamp dans son nom.Éditer le fichier de migration
Ouvrez le fichier (
fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php
), décrivez la structure de la table dansup()
, et la suppression dansdown()
:php<?php namespace Fuel\Migrations; use Fuel\Core\DBUtil; class Create_users_table { public function up() { // Crée la table users DBUtil::create_table('users', [ 'id' => ['type' => 'int', 'constraint' => 11, 'auto_increment' => true], 'name' => ['type' => 'varchar', 'constraint' => 100], 'email' => ['type' => 'varchar', 'constraint' => 100, 'unique' => true], ], ['id'], true, 'InnoDB', 'utf8mb4_unicode_ci'); // Définit la clé primaire, index, moteur et encodage } public function down() { // Supprime la table users (rollback) DBUtil::drop_table('users'); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Lancer la migration
Depuis la racine du projet :
bashphp oil refine migrate
1Si tout va bien, la table
users
sera créée dans la basefuel_dev
.
Ajouter du code d’exemple dans le contrôleur
Éditez fuel/app/classes/controller/welcome.php
et ajoutez des méthodes pour tester la base et le cache :
<?php
use Fuel\Core\Controller;
use Fuel\Core\Response;
use Fuel\Core\Cache;
use Fuel\Core\DB; // Import du facade DB
use Fuel\Core\Redis; // Import du facade Redis
class Controller_Welcome extends Controller
{
// Action d'accueil par défaut
public function action_index()
{
return Response::forge('Hello ServBay!');
}
// Exemple Memcached
public function action_memcached()
{
// Tente de récupérer la donnée du cache
$value = Cache::get('servbay_memcached_key');
if ($value === false) {
// Si non présent, définit la valeur dans le cache
$value = 'Hello Memcached from ServBay!';
Cache::set('servbay_memcached_key', $value, 60); // Cache pour 60 secondes
$value .= ' (from cache)';
} else {
$value .= ' (cached)';
}
return Response::forge($value);
}
// Exemple Redis
public function action_redis()
{
// Obtenir une instance Redis (connexion par défaut)
$redis = \Redis_Db::instance(); // Pour FuelPHP 1.x
// Ou pour plusieurs connexions : \Redis_Db::instance('connection_name')
// Stocke des données dans Redis
$redis->set('servbay_redis_key', 'Hello Redis from ServBay!');
// Récupère la donnée
$value = $redis->get('servbay_redis_key');
return Response::forge($value);
}
// Exemple écriture MySQL
public function action_mysql_add()
{
try {
// Ajoute un utilisateur
$result = DB::insert('users')->set([
'name' => 'ServBay Demo User ' . time(), // Unicité par timestamp
'email' => 'demo_user_' . time() . '@servbay.test',
])->execute(); // Retourne un array avec l’ID inséré
return Response::forge('User added with ID: ' . $result[0]);
} catch (\Database_Exception $e) {
// Gestion erreur (email dupliqué, etc.)
return Response::forge('Error adding user: ' . $e->getMessage(), 500);
}
}
// Exemple lecture MySQL
public function action_mysql()
{
// Sélectionne tous les utilisateurs
$users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();
// Retourne la liste au format JSON
return Response::forge(json_encode($users, JSON_PRETTY_PRINT));
}
}
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
À savoir :
- Les facades
DB
etRedis
sont importés (use Fuel\Core\DB;
,use Fuel\Core\Redis;
) pour une utilisation directe. - Les clés Memcached et Redis commencent par
servbay_
pour éviter les conflits. - L’exemple MySQL utilise un timestamp pour la valeur et une gestion d’erreur basique, le tout avec un libellé explicite.
- Sous FuelPHP 1.x, on utilise
\Redis_Db::instance()
pour se connecter à Redis.
Configurer les routes
Pour accéder aux actions du contrôleur via des URLs, ajoutez les routes nécessaires dans le fichier fuel/app/config/routes.php
. Par défaut, Controller_Welcome
est déjà accessible, mais les actions memcached
, redis
, mysql_add
, mysql
doivent être explicitement routées.
Modifiez le tableau ainsi :
<?php
return array(
'_root_' => 'welcome/index', // Route par défaut vers l’action index du contrôleur welcome
'_404_' => 'welcome/404', // Route pour la page 404
// Routes pour les actions d’exemple
'memcached' => 'welcome/memcached',
'redis' => 'welcome/redis',
'mysql_add' => 'welcome/mysql_add',
'mysql' => 'welcome/mysql',
// ... Autres routes
);
2
3
4
5
6
7
8
9
10
11
12
13
Accéder et tester le site
Vous pouvez maintenant tester votre projet FuelPHP et les connexions aux services en accédant au domaine https://servbay-fuelphp-test.local
que vous avez configuré dans ServBay.
- Page d’accueil :
https://servbay-fuelphp-test.local
- Résultat attendu :
Hello ServBay!
- Résultat attendu :
- Test Memcached :
https://servbay-fuelphp-test.local/memcached
- Première visite :
Hello Memcached from ServBay! (from cache)
(si le service fonctionne) - Visite suivante :
Hello Memcached from ServBay! (cached)
(si le cache est encore valide)
- Première visite :
- Test Redis :
https://servbay-fuelphp-test.local/redis
- Résultat attendu :
Hello Redis from ServBay!
(si Redis fonctionne)
- Résultat attendu :
- Ajouter un utilisateur dans MySQL :
https://servbay-fuelphp-test.local/mysql_add
- Résultat attendu :
User added with ID: [nouvel ID]
(si MySQL/table existent)
- Résultat attendu :
- Lire la liste des utilisateurs MySQL :
https://servbay-fuelphp-test.local/mysql
- Résultat attendu : Un tableau JSON, listant tous les enregistrements de la table
users
(si la table existe et contient des données)
- Résultat attendu : Un tableau JSON, listant tous les enregistrements de la table
À propos de HTTPS : ServBay génère automatiquement les certificats SSL pour les sites locaux, via ServBay User CA ou Public CA. Si le navigateur signale un certificat non fiable, veillez à ajouter le certificat de l’Autorité ServBay dans le trousseau système.
Points importants
- Vérifiez que chaque service nécessaire (PHP, Caddy/Nginx/Apache, MySQL, Redis, Memcached selon besoin) est en fonctionnement dans l’interface principale de ServBay.
- Assurez-vous d’avoir créé la base de données
fuel_dev
via l’outil de gestion ServBay (sinon précisez une base existante dansdb.php
). Les migrations FuelPHP (oil refine migrate
) créent les tables mais pas la base elle-même. - Le fichier d’entrée publique de FuelPHP est
public/index.php
: le dossier racine paramétré dans ServBay doit impérativement pointer sur le dossierpublic
de votre projet.
Conclusion
Grâce à ServBay, l’installation d’un environnement de développement complet pour FuelPHP sur macOS devient simple et rapide. Ce guide vous a montré comment créer un projet FuelPHP, configurer la fonction Sites Web de ServBay, assurer la connexion aux bases de données et aux systèmes de cache, et valider le fonctionnement avec des exemples de code. Les nombreux services intégrés et l’automatisation des configurations offertes par ServBay augmentent considérablement votre productivité.
Nous espérons que ce tutoriel vous aidera à bien démarrer vos projets FuelPHP avec ServBay !