Créer et exécuter un projet FuelPHP dans l’environnement local ServBay

Qu’est-ce que FuelPHP ?

FuelPHP est un framework PHP flexible et modulaire, conçu pour faciliter la création d’applications web modernes. Il adopte le modèle HMVC (Hierarchical Model-View-Controller), offrant une structure claire, de nombreuses fonctionnalités et des outils pour aider les développeurs à concevoir rapidement des applications web de haute qualité. FuelPHP se distingue par sa grande souplesse, ses excellentes performances et une architecture facilement extensible, ce qui en fait le choix privilégié de nombreux développeurs PHP.

Principales caractéristiques et avantages de FuelPHP

Architecture HMVC : prise en charge du modèle MVC hiérarchique, pour une meilleure organisation du code, la réutilisation et le développement modulaire, particulièrement adapté aux projets complexes ou de grande taille.
Haute performance : FuelPHP est optimisé pour la rapidité et la gestion efficace des ressources, apte à supporter de fortes charges et de nombreux accès simultanés.
Facile à étendre : le framework propose un système d’extension puissant permettant d’intégrer aisément des bibliothèques tierces ou d’ajouter des fonctionnalités sur mesure selon les besoins du projet.
Sécurité renforcée : il intègre de nombreuses fonctionnalités de sécurité, telles que la validation automatique des entrées, le filtrage des sorties (pour contrer les attaques XSS), la protection CSRF, et la prévention des injections SQL.
Communauté active : FuelPHP bénéficie d’une communauté de développeurs dynamique permettant d'obtenir rapidement de l’aide et des ressources additionnelles.

Grâce à ces atouts, FuelPHP permet aux développeurs de bâtir aisément des applications web performantes, sécurisées et maintenables, adaptées autant aux petits projets qu'aux applications d’entreprise.

Déployer un environnement de développement FuelPHP avec ServBay

ServBay est une solution locale dédiée aux développeurs web, intégrant tous les indispensables : PHP, serveurs Caddy/Nginx/Apache, bases MySQL/PostgreSQL/MongoDB, Redis et bien plus. ServBay facilite la mise en place de l’environnement nécessaire à un projet FuelPHP, éliminant la complexité de l’installation et de la configuration manuelle des dépendances.

Ce guide détaille comment utiliser ServBay pour bénéficier d’un environnement PHP complet, de serveurs web (Caddy), et des services de base de données et de cache afin de créer et exécuter un projet FuelPHP. Nous utiliserons la fonctionnalité Site de ServBay, afin de configurer le serveur web et faciliter l’accès et les tests du projet en quelques étapes.

Prérequis

Avant de commencer, assurez-vous que :

ServBay est installé et fonctionne sur macOS.
L’environnement PHP dans ServBay est activé (c'est le cas par défaut).
Les services de base de données (ex. MySQL) et de cache (ex. Redis, Memcached) que vous souhaitez utiliser sont lancés et opérationnels dans ServBay.
Composer est intégré à ServBay, inutile de l’installer séparément.

Créer un projet FuelPHP

Chemin recommandé pour vos projets

ServBay recommande de placer les sites web dans le dossier /Applications/ServBay/www, facilitant ainsi la gestion et la configuration. Ce guide utilisera également ce chemin comme exemple.

Accédez au dossier racine des sites
Ouvrez le terminal et naviguez jusqu’au dossier conseilé par ServBay :
bash
```
cd /Applications/ServBay/www
```
1
Créez le dossier du projet
Créez un nouveau répertoire pour votre projet FuelPHP, puis entrez dedans :
bash
```
mkdir servbay-fuelphp-app
cd servbay-fuelphp-app
```
1
2
Créez le projet FuelPHP avec Composer
Depuis ce dossier, lancez Composer pour télécharger et initialiser FuelPHP (le point . indique le dossier courant) :
bash
```
composer create-project fuel/fuel .
```
1
Composer va télécharger FuelPHP et ses dépendances dans servbay-fuelphp-app.

Configurer le serveur Web (fonction Site de ServBay)

Pour accéder au projet FuelPHP via le navigateur, configurez un hôte virtuel avec la fonctionnalité Site de ServBay.

Ouvrez l’interface principale de ServBay.
Cliquez sur le menu Site dans la barre latérale.
Cliquez sur le bouton Ajouter un site en haut à droite.
Complétez la fenêtre de configuration qui s’ouvre :
- Nom : choisissez un nom explicite, ex. Mon premier site FuelPHP Dev.
- Domaine : définissez un nom de domaine local, ex. servbay-fuelphp-test.local. ServBay s’occupe de lier ce domaine à votre machine.
- Type de site : sélectionnez PHP.
- Version PHP : choisissez la version souhaitée, ex. 8.3.
- Répertoire racine du site : indiquez le dossier d’entrée du projet FuelPHP. FuelPHP utilise public/index.php comme point d’entrée, donc le répertoire doit être /Applications/ServBay/www/servbay-fuelphp-app/public.
Cliquez sur Ajouter pour sauvegarder.

ServBay mettra à jour la configuration de Caddy et rechargera les services ; le nouveau domaine sera immédiatement disponible.

Retrouvez le détail de cette démarche dans la documentation ServBay : Ajouter votre premier site.

Paramétrer la connexion aux services FuelPHP

Votre projet FuelPHP requiert généralement la configuration des connexions à la base de données et aux services de cache.

Configuration de la base de données

La configuration s’effectue dans le fichier fuel/app/config/development/db.php. Modifiez ce fichier, par exemple pour utiliser MySQL par défaut dans ServBay :

php

<?php
/**
 * Les paramètres de la base de données en environnement development. Fusionnés avec les global.
 */
return [
    'default' => [
        'connection' => [
            'dsn'      => 'mysql:host=localhost;dbname=fuel_dev', // Vérifiez que la base fuel_dev existe
            'username' => 'root', // Utilisateur MySQL par défaut ServBay
            'password' => 'root', // Mot de passe par défaut (usage local uniquement !)
        ],
        'identifier' => '`', // L’identifiant MySQL nécessite les backticks
    ],
];

Remarque :

Créez manuellement la base de données fuel_dev via un outil comme phpMyAdmin ou Adminer. L’utilisateur par défaut est root (mot de passe : root), recommandé uniquement en environnement local.
'identifier' => ''` est nécessaire pour les schémas MySQL, garantissant une gestion correcte des noms de table et des champs.

Configuration du cache (Memcached et Redis)

FuelPHP prend en charge différents pilotes de cache. Les paramètres se trouvent dans fuel/app/config/cache.php. Assurez-vous que Memcached et/ou Redis sont démarrés dans ServBay.

Configuration Memcached (fuel/app/config/cache.php) :

Pour utiliser Memcached comme cache par défaut :

php

<?php
return [
    'driver' => 'memcached', // définit le pilote par défaut comme memcached
    'memcached' => [
        'cache_id' => 'fuel', // ID du cache
        'servers' => [
             'default' => [
                'host'   => '127.0.0.1', // Adresse Memcached par défaut
                'port'   => 11211,      // Port par défaut
                'weight' => 100,
            ],
        ],
        'compression' => false, // Compression activée ou non
    ],
    // ... autres pilotes de cache
];

Les versions PHP fournies par ServBay incluent généralement l’extension Memcached.

Configuration Redis (fuel/app/config/redis.php) :

Si vous souhaitez utiliser Redis, spécifiez les paramètres dans le fichier dédié :

php

<?php
return [
    'default' => [
        'hostname' => '127.0.0.1', // Adresse Redis par défaut
        'port'     => 6379,      // Port Redis par défaut
        'database' => 0,         // Index de la base Redis
    ],
    // Possibilité de configurer plusieurs connexions
];

L’extension Redis est aussi préinstallée avec les versions PHP de ServBay.

Exemples d’utilisation base de données et cache

Pour illustrer l’interaction avec la base de données et les services de cache dans FuelPHP, ajoutons quelques exemples de code.

Création de table en base (avec les migrations FuelPHP)

FuelPHP intègre l’outil Oil pour gérer les migrations, permettant un contrôle de version du schéma de la base.

Créer le fichier de migration
Depuis la racine du projet (servbay-fuelphp-app), générez une migration pout la table users :
bash
```
php oil generate migration create_users_table
```
1
Un fichier sera créé sous fuel/app/migrations avec un horodatage.

Modifier le fichier migration

Ouvrez ce fichier (fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php), puis remplissez les méthodes up() (création) et down() (suppression) :

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 charset
    }

    public function down()
    {
        // Supprime la table users (rollback)
        DBUtil::drop_table('users');
    }
}

Exécuter la migration
Depuis la racine du projet, appliquez la migration :
bash
```
php oil refine migrate
```
1
Si tout est correct, la table users sera créée dans la base fuel_dev.

Ajouter un code d’exemple de contrôleur

Dans le fichier fuel/app/classes/controller/welcome.php, ajoutez des méthodes pour illustrer l’utilisation base de données et cache :

php

<?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 par défaut de l’accueil
    public function action_index()
    {
        return Response::forge('Hello ServBay!');
    }

    // Action exemple Memcached
    public function action_memcached()
    {
        // Tente de récupérer une valeur depuis le cache
        $value = Cache::get('servbay_memcached_key');

        if ($value === false) {
            // Si absent du cache, on le définit
            $value = 'Hello Memcached from ServBay!';
            Cache::set('servbay_memcached_key', $value, 60); // stocké 60sec
            $value .= ' (from cache)';
        } else {
            $value .= ' (cached)';
        }

        return Response::forge($value);
    }

    // Action exemple Redis
    public function action_redis()
    {
        // Récupère l’instance par défaut de Redis
        $redis = \Redis_Db::instance(); // FuelPHP 1.x : Redis_Db::instance()
        // Ou utilisez \Redis_Db::instance('connection_name') si plusieurs connexions

        // Définir une entrée dans Redis
        $redis->set('servbay_redis_key', 'Hello Redis from ServBay!');

        // Lire la valeur depuis Redis
        $value = $redis->get('servbay_redis_key');

        return Response::forge($value);
    }

    // Action exemple écriture MySQL
    public function action_mysql_add()
    {
        try {
            // Insère un nouvel utilisateur
            $result = DB::insert('users')->set([
                'name' => 'ServBay Demo User ' . time(), // Unicité via timestamp
                'email' => 'demo_user_' . time() . '@servbay.test',
            ])->execute(); // execute() retourne l'ID inséré

            return Response::forge('User added with ID: ' . $result[0]);
        } catch (\Database_Exception $e) {
            // Gestion des erreurs, ex. email en doublon
            return Response::forge('Error adding user: ' . $e->getMessage(), 500);
        }
    }

    // Action 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));
    }
}

Remarque :

Utilisez DB et Redis (importés via use Fuel\Core\DB; et use Fuel\Core\Redis;).
Les clés cache sont préfixées servbay_ pour éviter les collisions.
Les exemples MySQL utilisent le timestamp et une gestion d’erreur simplifiée.
Pour FuelPHP 1.x, utilisez toujours \Redis_Db::instance().

Configurer les routes

Pour accéder aux différentes méthodes du contrôleur via l’URL, modifiez fuel/app/config/routes.php :

php

<?php
return array(
    '_root_'  => 'welcome/index',  // La route par défaut pointe vers le contrôleur welcome
    '_404_'   => 'welcome/404',    // Route pour la page d’erreur 404

    // Routes pour les exemples ajoutés
    'memcached'   => 'welcome/memcached',
    'redis'       => 'welcome/redis',
    'mysql_add'   => 'welcome/mysql_add',
    'mysql'       => 'welcome/mysql',

    // ... autres routes
);

Accéder et tester le site

Vous pouvez désormais tester le projet FuelPHP et les services via le navigateur en visitant le domaine configuré, https://servbay-fuelphp-test.local.

Page d’accueil : https://servbay-fuelphp-test.local
- Attendu : Hello ServBay!
Test Memcached : https://servbay-fuelphp-test.local/memcached
- Premier accès : Hello Memcached from ServBay! (from cache)
- Accès suivant : Hello Memcached from ServBay! (cached)
Test Redis : https://servbay-fuelphp-test.local/redis
- Attendu : Hello Redis from ServBay!
Ajouter un utilisateur MySQL : https://servbay-fuelphp-test.local/mysql_add
- Attendu : User added with ID: [ID inséré]
Liste utilisateurs MySQL : https://servbay-fuelphp-test.local/mysql
- Attendu : un tableau JSON listant les enregistrements en base

À propos du HTTPS : ServBay configure automatiquement les certificats SSL pour vos sites locaux, signés par ServBay User CA ou ServBay Public CA. Si le navigateur signale un problème de certificat, veillez à ajouter ServBay CA aux certificats reconnus par le système.

Points d’attention

Vérifiez dans l’interface principale de ServBay que les services nécessaires (version PHP, Caddy ou Nginx/Apache, MySQL, Redis, Memcached, etc.) sont actifs.
Créez la base fuel_dev manuellement via phpMyAdmin ou Adminer, ou bien indiquez une base existante dans db.php. Le système de migration de FuelPHP créera les tables, mais pas la base elle-même.
Le fichier d’entrée public de FuelPHP est public/index.php. Le répertoire racine dans la configuration du site ServBay doit impérativement pointer sur le dossier public du projet.

Conclusion

Grâce à ServBay, il devient simple et rapide de déployer l’environnement complet nécessaire au développement de projets FuelPHP sur macOS. Ce guide vous a expliqué comment créer un projet FuelPHP, configurer la fonctionnalité Site de ServBay, relier base de données et systèmes de cache, et valider le bon fonctionnement via des exemples pratiques. ServBay, avec ses nombreux services intégrés et la simplicité de sa configuration, accélère nettement votre travail quotidien.

Nous espérons que ce guide vous aidera à démarrer efficacement avec FuelPHP au sein de ServBay !

Créer et exécuter un projet FuelPHP dans l’environnement local ServBay ​

Qu’est-ce que FuelPHP ? ​

Principales caractéristiques et avantages de FuelPHP ​

Déployer un environnement de développement FuelPHP avec ServBay ​

Prérequis ​

Créer un projet FuelPHP ​

Configurer le serveur Web (fonction Site de ServBay) ​

Paramétrer la connexion aux services FuelPHP ​

Configuration de la base de données ​

Configuration du cache (Memcached et Redis) ​

Exemples d’utilisation base de données et cache ​

Création de table en base (avec les migrations FuelPHP) ​

Ajouter un code d’exemple de contrôleur ​

Configurer les routes ​

Accéder et tester le site ​

Points d’attention ​

Conclusion ​