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é :
bash
```
cd /Applications/ServBay/www
```
1
Créer le dossier du projet
Créez un nouveau dossier pour votre projet FuelPHP et entrez dedans :
bash
```
mkdir servbay-fuelphp-app
cd servbay-fuelphp-app
```
1
2
Initialiser 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 :
bash
```
composer create-project fuel/fuel .
```
1
Composer 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-dossier public de votre projet : /Applications/ServBay/www/servbay-fuelphp-app/public.
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

<?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
    ],
];

Remarques :

Il faut créer manuellement la base fuel_dev via un outil de gestion ServBay (phpMyAdmin ou Adminer). Le compte MySQL root par défaut a comme mot de passe root, 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

<?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
];

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

<?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
];

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 table users :
bash
```
php oil generate migration create_users_table
```
1
Un 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 dans up(), et la suppression dans down() :

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');
    }
}

Lancer la migration
Depuis la racine du projet :
bash
```
php oil refine migrate
```
1
Si tout va bien, la table users sera créée dans la base fuel_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

<?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));
    }
}

À savoir :

Les facades DB et Redis 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

<?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
);

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!
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)
Test Redis : https://servbay-fuelphp-test.local/redis
- Résultat attendu : Hello Redis from ServBay! (si Redis fonctionne)
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)
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)

À 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 dans db.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 dossier public 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 !

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

Qu’est-ce que FuelPHP ? ​

Caractéristiques et avantages principaux de FuelPHP ​

Installer l’environnement de développement FuelPHP avec ServBay ​

Pré-requis ​

Créer un projet FuelPHP ​

Configurer le serveur web (fonction Sites Web de ServBay) ​

Configurer la connexion aux services dans le projet FuelPHP ​

Configuration de la base de données ​

Configuration du cache (Memcached et Redis) ​

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

Préparer la table via les migrations FuelPHP ​

Ajouter du code d’exemple dans le contrôleur ​

Configurer les routes ​

Accéder et tester le site ​

Points importants ​

Conclusion ​