ServBay

Français

English
简体中文
繁體中文
Español
العربية
Português
Русский
日本語
Deutsch
Tiếng Việt
Türkçe
Italiano

Français

English
简体中文
繁體中文
Español
العربية
Português
Русский
日本語
Deutsch
Tiếng Việt
Türkçe
Italiano

Appearance

Créer et exécuter un projet CakePHP avec ServBay ​

ServBay est un environnement de développement Web local spécialement conçu pour macOS. Il intègre des environnements pour de nombreux langages tels que PHP, Node.js, Python, Go, Java, ainsi que des services de bases de données comme MySQL, PostgreSQL, MongoDB, Redis, et propose les serveurs Web Caddy ou Nginx. Il offre une plateforme pratique et efficace permettant aux développeurs de créer et de gérer facilement leurs projets locaux.

Cet article vous guide pas à pas pour créer, configurer et exécuter un projet CakePHP dans l’environnement ServBay. CakePHP est un framework populaire de développement Web PHP suivant le modèle MVC (modèle-vue-contrôleur), réputé pour son développement rapide, son ORM puissant et ses fonctionnalités de sécurité intégrées. Grâce à la simplicité de ServBay, vous pouvez commencer à développer avec CakePHP sans attendre.

Qu’est-ce que CakePHP ? ​

CakePHP est un framework PHP open source pour le développement d’applications Web. Il fournit une structure de base pour créer rapidement des applications Web structurées, sans sacrifier la flexibilité. Le framework suit le principe de la convention plutôt que la configuration, ce qui simplifie de nombreuses tâches courantes.

Principales caractéristiques et avantages de CakePHP ​

  • Basé sur le modèle MVC : Organisation claire du code, facile à maintenir et à étendre.
  • Développement rapide : Outil en ligne de commande (Bake) pour générer du code et accélérer le workflow de développement.
  • ORM puissant (Mapping Objet-Relatif) : Simplifie l’interaction avec la base de données et prend en charge de nombreux SGBD.
  • Sécurité intégrée : Protection CSRF, contre les injections SQL, validation des entrées, et bien d’autres.
  • Moteur de template flexible : Compatibilité avec différentes technologies pour la couche vue.
  • Communauté active et nombreux plugins : Support facile à trouver, vaste possibilité d’extension.
  • Documentation complète : Guides détaillés et références API disponibles.

CakePHP convient à tous types de projets Web, du simple API au système d’entreprise complexe.

Préparer un environnement CakePHP avec ServBay ​

ServBay offre un environnement intégré idéal pour le développement CakePHP, comprenant :

  • Interpréteur PHP préinstallé avec extensions courantes.
  • Gestionnaire de paquets Composer préinstallé.
  • Serveur Web configurable facilement (Caddy/Nginx).
  • Services de base de données intégrés (MySQL, PostgreSQL, Redis, etc.).

Avec ServBay, évitez les complexités de l’installation et de la configuration manuelle de chaque composant.

Prérequis ​

Avant de commencer, assurez-vous d’avoir :

  1. Installé ServBay : Téléchargez et installez ServBay correctement sur votre macOS.
  2. Démarré les services ServBay : Lancez ServBay et activez les paquets nécessaires (PHP, la base de données souhaitée comme MySQL/PostgreSQL, systèmes de cache comme Redis ou Memcached). Gérez tout cela dans l’onglet « Packages » du panneau de contrôle ServBay.
  3. Connaîtr les opérations de base de ServBay : Savoir comment ajouter et configurer un site. Si besoin, consultez d’abord le guide d’utilisation basique de ServBay.

Créer un projet CakePHP ​

ServBay recommande de rassembler tous vos fichiers de projets Web dans le dossier /Applications/ServBay/www afin de faciliter leur détection et gestion automatique.

  1. Ouvrir le terminal

    Démarrez l’application Terminal sur macOS.

  2. Naviguer vers le répertoire racine des sites ServBay

    Déplacez-vous dans le dossier recommandé :

    bash
    cd /Applications/ServBay/www

  3. Créer le dossier du projet

    Créez un sous-dossier pour votre projet CakePHP. Par exemple, ici servbay-cakephp-app :

    bash
    mkdir servbay-cakephp-app
cd servbay-cakephp-app

  4. Créer le projet CakePHP avec Composer

    Composer est préinstallé avec ServBay. Depuis le dossier du projet, créez le squelette CakePHP :

    bash
    composer create-project --prefer-dist cakephp/app .

    Cette commande installe la dernière version stable de CakePHP et ses dépendances dans le dossier courant (.).

  5. Installer le driver ORM pour PostgreSQL (si utilisé)

    Si vous prévoyez d’utiliser PostgreSQL, installez son driver ORM :

    bash
    composer require cakephp/orm-pgsql

    Pour MySQL, rien à faire : il est déjà pris en charge dans les dépendances de base de CakePHP.

Configuration initiale ​

Après avoir créé le projet, il vous faut effectuer quelques réglages, notamment la connexion à la base de données.

  1. Configurer les variables d’environnement et la connexion BDD

    La configuration locale de CakePHP se situe dans config/app_local.php. Ouvrez ce fichier, trouvez la section Datasources et ajustez les informations de connexion. Les identifiants par défaut de ServBay sont généralement root pour l’utilisateur et password pour le mot de passe.

    Exemple de configuration MySQL :

    php
    // config/app_local.php
'Datasources' => [
    'default' => [
        'className' => \Cake\Database\Connection::class,
        'driver' => \Cake\Database\Driver\Mysql::class, // ou \Cake\Database\Driver\Postgres::class pour PostgreSQL
        'persistent' => false,
        'host' => '127.0.0.1', // Adresse du serveur de base de données (local pour ServBay)
        //'port' => '3306', // Port MySQL 3306 par défaut, PostgreSQL 5432
        'username' => 'root', // utilisateur ServBay
        'password' => 'password', // mot de passe ServBay
        'database' => 'servbay_cakephp_app', // nom de la base à créer
        'encoding' => 'utf8mb4',
        'timezone' => 'UTC',
        'flags' => [],
        'cacheMetadata' => true,
        'log' => false,

        /**
         * Activez le quoting si vous utilisez des noms réservés (ex : "user") en tant que noms de table.
         * Sinon (ex : "cake"), laissez à false.
         * Si vous hésitez, laissez à true.
         */
        'quoteIdentifiers' => false,

        /**
         * Limitations actuelles :
         * - La plupart des drivers ne gèrent pas le niveau d’isolation via PDO.
         *   Cela générera une erreur si utilisé.
         * - Certains drivers n'acceptent pas le charset via PDO.
         *   Cela générera une erreur si utilisé.
         * - Les options PDO ne sont pas prises en charge pour les drivers packagés comme Postgres de CakePHP.
         *   Pour Postgres, définissez simplement l'encodage.
         */
        'options' => [],

        //'url' => env('DATABASE_URL', null), // Pour DATABASE_URL, décommentez cette ligne
    ],
],

    Ajustez le type de driver et le port selon votre base (MySQL ou PostgreSQL). Le champ database doit correspondre à la base de données que vous allez créer.

Paramétrer le serveur Web (Création du site dans ServBay) ​

Afin d’accéder à votre projet CakePHP via un navigateur, il vous faut créer un site dans ServBay pointant vers votre dossier de projet.

  1. Ouvrir le panneau de contrôle ServBay

    Cliquez sur l’icône de ServBay.

  2. Aller dans l’onglet « Sites »

    Dans la barre latérale gauche, cliquez sur « Sites » (anciennement « Hôtes »).

  3. Ajouter un nouveau site

    En bas, cliquez sur le bouton + et complétez les informations suivantes :

    • Nom : Donnez un nom distinctif (ex : My CakePHP Dev Site).
    • Domaine : Attribuez un domaine local tel que servbay-cakephp-test.local. ServBay gérera la redirection vers votre machine.
    • Type de site : Choisissez PHP.
    • Version PHP : Sélectionnez une version compatible avec CakePHP (généralement PHP 7.4+ pour CakePHP 4+, PHP 8.1+ pour CakePHP 5+, par ex : 8.3).
    • Racine du site (Document Root) : Important ! La racine pour le serveur Web doit être le dossier interne webroot de votre projet, et non le dossier principal. Indiquez /Applications/ServBay/www/servbay-cakephp-app/webroot (remplacez servbay-cakephp-app par le nom de votre projet).

  4. Enregistrer et appliquer les modifications

    Cliquez sur « Enregistrer ». Confirmez lors de la demande d’application des modifications. ServBay configurera alors Caddy ou Nginx pour router le domaine servbay-cakephp-test.local vers le dossier webroot de votre projet.

Pour plus de détails, suivez la documentation ServBay section Ajouter un premier site.

Vérifier la configuration de base ​

Vous pouvez désormais visiter votre site via le navigateur.

Ouvrez votre navigateur et rendez-vous sur le domaine que vous avez configuré, par exemple https://servbay-cakephp-test.local.

Si tout est en place, vous verrez la page d’accueil par défaut de CakePHP, prouvant que PHP, le serveur Web et la configuration ServBay fonctionnent correctement.

Intégrer la base de données et les services de cache ​

CakePHP propose un puissant ORM et une couche d'abstraction de cache permettant d’intégrer facilement les services base de données et cache proposés par ServBay.

Exemple base de données relationnelle (MySQL/PostgreSQL) ​

Voici comment utiliser l’ORM de CakePHP pour se connecter à MySQL ou PostgreSQL via ServBay, créer une table users et réaliser des opérations CRUD.

  1. Créer la base dans ServBay

    Avant la migration, créez une nouvelle base sur le serveur géré par ServBay. Utilisez l'interface phpMyAdmin (MySQL/MariaDB), pgAdmin (PostgreSQL), ou un outil tel que Navicat/DBeaver, connectez-vous (souvent à 127.0.0.1, user root, mot de passe password) et créez une base appelée servbay_cakephp_app.

  2. Créer le fichier de Model ORM

    CakePHP requiert un fichier Model pour représenter la table. Créez UsersTable.php.

    Enregistrez ceci dans src/Model/Table/UsersTable.php :

    php
    <?php
namespace App\Model\Table;

use Cake\ORM\Table;
use Cake\Validation\Validator; // Si besoin de règles de validation

class UsersTable extends Table
{
    /**
     * Initialize method
     *
     * @param array $config The configuration for the Table.
     * @return void
     */
    public function initialize(array $config): void
    {
        parent::initialize($config);

        $this->setTable('users'); // Spécifie le nom de la table
        $this->setDisplayField('name'); // Sera utilisé dans les associations par défaut
        $this->setPrimaryKey('id'); // Définit la clé primaire

        // Pour le comportement timestamp si besoin
        // $this->addBehavior('Timestamp');
    }

    /**
     * Default validation rules.
     *
     * @param \Cake\Validation\Validator $validator Validator instance.
     * @return \Cake\Validation\Validator
     */
    public function validationDefault(Validator $validator): Validator
    {
        $validator
            ->scalar('name')
            ->maxLength('name', 255)
            ->requirePresence('name', 'create')
            ->notEmptyString('name');

        $validator
            ->email('email')
            ->requirePresence('email', 'create')
            ->notEmptyString('email')
            ->add('email', 'unique', ['rule' => 'validateUnique', 'provider' => 'table']); // Email unique

        return $validator;
    }
}

  3. Créer un fichier de migration avec Bake

    Utilisez le système de migration de CakePHP pour gérer le schéma de la base. Depuis le répertoire du projet (/Applications/ServBay/www/servbay-cakephp-app) :

    bash
    bin/cake bake migration CreateUsers name:string email:string:unique

    Ceci crée une migration pour une table users avec champs name (string) et email (string unique).

  4. Exécuter la migration

    Appliquez la migration pour réellement créer la table dans la base :

    bash
    bin/cake migrations migrate

    Si réussi, la table users sera présente dans la base de données.

  5. Configurer la connexion BDD (si pas encore fait)

    Vérifiez dans config/app_local.php que la section Datasources.default reflète votre configuration.

    • Exemple pour MySQL :

      php
      'Datasources' => [
    'default' => [
        'className' => \Cake\Database\Connection::class,
        'driver' => \Cake\Database\Driver\Mysql::class,
        'host' => '127.0.0.1',
        'username' => 'root',
        'password' => 'password',
        'database' => 'servbay_cakephp_app',
        // ... autres options
    ],
],

    • Exemple pour PostgreSQL :

      php
      'Datasources' => [
    'default' => [
        'className' => \Cake\Database\Connection::class,
        'driver' => \Cake\Database\Driver\Postgres::class,
        'host' => '127.0.0.1',
        // 'port' => '5432', // Par défaut
        'username' => 'root',
        'password' => 'password',
        'database' => 'servbay_cakephp_app',
        // ... autres options
    ],
],

  6. Ajouter des routes et méthodes de contrôleur d'exemple

    Modifiez config/routes.php pour ajouter deux routes :

    php
    // config/routes.php
use Cake\Routing\RouteBuilder;
use Cake\Routing\Router;
use Cake\Routing\Route\DashedRoute;

Router::defaultRouteClass(DashedRoute::class);

Router::scope('/', function (RouteBuilder $routes) {
    // ... autres routes
    $routes->connect('/', ['controller' => 'Pages', 'action' => 'display', 'home']);

    // Routes d’exemple base de données
    $routes->connect('/db-add-user', ['controller' => 'Pages', 'action' => 'dbAddUser']);
    $routes->connect('/db-list-users', ['controller' => 'Pages', 'action' => 'dbListUsers']);

    // ... autres routes
    $routes->fallbacks(DashedRoute::class);
});

    Dans src/Controller/PagesController.php, ajoutez les méthodes suivantes :

    php
    <?php
namespace App\Controller;

use Cake\Http\Response;
use Cake\ORM\TableRegistry;
use Cake\Datasource\Exception\RecordNotFoundException; // Pour la gestion des exceptions

class PagesController extends AppController
{
    /**
     * Displays a view
     *
     * @param array ...$path Path segments.
     * @return \Cake\Http\Response|null
     */
    public function display(...$path): ?Response
    {
        // ... méthode display par défaut
        return new Response(['body' => 'Hello ServBay! Ceci est la page par défaut.']);
    }

    /**
     * Exemple BDD : ajout d’un utilisateur
     */
    public function dbAddUser(): Response
    {
        $usersTable = TableRegistry::getTableLocator()->get('Users'); // Accédez au Table Users

        // Créez un nouvel utilisateur
        $user = $usersTable->newEntity([
            'name' => 'ServBay Demo User',
            'email' => '[email protected]' // Email exemple ServBay
        ]);

        // Tente l’enregistrement
        if ($usersTable->save($user)) {
            return new Response(['body' => 'Utilisateur ajouté avec succès ! ID : ' . $user->id]);
        } else {
            // En cas d’échec, affichez les erreurs de validation
            $errors = $user->getErrors();
            return new Response(['body' => 'Échec lors de l’ajout de l’utilisateur. Erreurs : ' . json_encode($errors)]);
        }
    }

    /**
     * Exemple BDD : liste de tous les utilisateurs
     */
    public function dbListUsers(): Response
    {
        $usersTable = TableRegistry::getTableLocator()->get('Users');

        // Récupérer tous les utilisateurs
        $users = $usersTable->find()->all();

        // Encode le résultat en JSON pour l’affichage
        return new Response(['body' => json_encode($users->toArray())]);
    }
}

  7. Tester les opérations de base de données

    Dans votre navigateur :

    • Rendez-vous sur https://servbay-cakephp-test.local/db-add-user pour ajouter un utilisateur (message de confirmation attendu).
    • Rendez-vous sur https://servbay-cakephp-test.local/db-list-users pour afficher la liste des utilisateurs (devrait inclure celui ajouté ci-dessus).

Grâce à ces étapes, CakePHP est connecté à la base de données gérée par ServBay, et vous avez réalisé des opérations ORM de base.

Exemple de service de cache (Memcached/Redis) ​

CakePHP propose une API de cache unifiée et permet le choix du moteur (Memcached, Redis, etc). ServBay pré-installe les extensions nécessaires et propose les démons correspondants.

Assurez-vous que Memcached ou Redis est activé dans l’onglet "Packages" du panneau ServBay.

  1. Configurer la connexion cache

    Éditez la section Cache de config/app_local.php :

    • Exemple Memcached :

      php
      // config/app_local.php
'Cache' => [
    'default' => [
        'className' => \Cake\Cache\Engine\MemcachedEngine::class,
        'servers' => ['127.0.0.1:11211'], // Adresse/port Memcached ServBay
        'prefix' => 'servbay_cakephp_',
    ],
    // ... autres caches
],

    • Exemple Redis :

      php
      // config/app_local.php
'Cache' => [
    'default' => [
        'className' => \Cake\Cache\Engine\RedisEngine::class,
        'host' => '127.0.0.1', // Adresse Redis ServBay
        'port' => 6379,
        'password' => null, // Ajoutez le mot de passe si configuré
        'database' => 0,
        'prefix' => 'servbay_cakephp_',
    ],
    // ... autres caches
],

    Choisissez le service que vous souhaitez utiliser.

  2. Ajouter des routes et contrôleurs pour les exemples de cache

    Dans config/routes.php, ajoutez :

    php
    // config/routes.php
// ... autres routes
$routes->connect('/cache-memcached', ['controller' => 'Pages', 'action' => 'cacheMemcached']);
$routes->connect('/cache-redis', ['controller' => 'Pages', 'action' => 'cacheRedis']);
// ... autres routes

    Et dans src/Controller/PagesController.php :

    php
    <?php
namespace App\Controller;

use Cake\Http\Response;
use Cake\Cache\Cache; // Importer la classe Cache
// ... autres use

class PagesController extends AppController
{
    // ... autres méthodes (display, dbAddUser, dbListUsers)

    /**
     * Exemple de cache : Memcached
     */
    public function cacheMemcached(): Response
    {
        // Assurez-vous de bien utiliser MemcachedEngine dans la config

        $cacheKey = 'servbay_memcached_test_key';
        $cachedData = Cache::read($cacheKey);

        $responseBody = '';

        if ($cachedData === false) {
            // Cache manquant
            $responseBody = 'Cache manquant ! Écriture de "Hello Memcached !" en cache.';
            $dataToCache = 'Hello Memcached!';
            Cache::write($cacheKey, $dataToCache, 'default');
        } else {
            // Cache présent
            $responseBody = 'Cache trouvé ! Donnée : ' . $cachedData;
        }

        return new Response(['body' => $responseBody]);
    }

    /**
     * Exemple de cache : Redis
     */
    public function cacheRedis(): Response
    {
         // Assurez-vous de bien utiliser RedisEngine dans la config

        $cacheKey = 'servbay_redis_test_key';
        $cachedData = Cache::read($cacheKey);

        $responseBody = '';

        if ($cachedData === false) {
            $responseBody = 'Cache manquant ! Écriture de "Hello Redis !" en cache.';
            $dataToCache = 'Hello Redis!';
            Cache::write($cacheKey, $dataToCache, 'default');
        } else {
            $responseBody = 'Cache trouvé ! Donnée : ' . $cachedData;
        }

        return new Response(['body' => $responseBody]);
    }
}

  3. Tester l’exemple de cache

    Ouvrez votre navigateur :

    • Si Memcached est configuré, allez sur https://servbay-cakephp-test.local/cache-memcached. Au premier accès, « Cache manquant », sur rechargement, « Cache trouvé ».
    • Si Redis, visitez https://servbay-cakephp-test.local/cache-redis (idem).

Cela signifie que CakePHP est bien connecté au service de cache de ServBay.

Points d’attention ​

  • Identifiants BDD : Les identifiants par défaut (root/password) doivent être réservés au développement local. En production, choisissez des identifiants sûrs.
  • Racine du site : Veillez à bien pointer la racine du site de ServBay sur webroot de votre projet CakePHP, et non sur le dossier principal du projet.
  • Compatibilité PHP : Sélectionnez une version PHP dans ServBay compatible avec votre CakePHP. Consultez la documentation CakePHP pour connaître les exigences de version.
  • Ports ServBay : Si les ports par défaut (80, 443) sont occupés, modifiez-les dans les réglages ServBay et adaptez le fichier hosts ou l’URL de test en conséquence.

Foire Aux Questions (FAQ) ​

  • Q : J’ai une erreur « page introuvable » sur servbay-cakephp-test.local ?
    • R : Vérifiez que la « Racine du site » pointe bien vers /Applications/ServBay/www/servbay-cakephp-app/webroot.
    • Vérifiez que le serveur Web ServBay (Caddy ou Nginx) fonctionne.
    • Vérifiez que le fichier hosts redirige bien servbay-cakephp-test.local vers 127.0.0.1 (normalement automatique).
    • Vérifiez la présence et la configuration du fichier .htaccess (dans webroot/.htaccess, valeur par défaut correcte).
  • Q : La connexion à la base échoue ?
    • R : Vérifiez que le service BDD (MySQL/PostgreSQL) tourne dans ServBay.
    • Vérifiez les infos de connexion dans config/app_local.php (hôte, port, user, mot de passe, base).
    • Assurez-vous que la base servbay_cakephp_app existe bien.
  • Q : Impossible d’exécuter les commandes Composer (bin/cake) ?
    • R : Le terminal doit être positionné dans le dossier racine du projet CakePHP (/Applications/ServBay/www/servbay-cakephp-app).
    • PHP et Composer doivent être actifs dans ServBay.
    • Prévoyez que le terminal trouve bien la commande php (ServBay l’ajoute normalement au PATH). Utilisez idéalement le terminal intégré ServBay ou ajustez manuellement le PATH.

Conclusion ​

Avec ServBay, vous pouvez rapidement mettre en place un environnement de développement local CakePHP sur macOS. Grâce à l’intégration native de PHP, Composer, serveurs Web et bases de données, la configuration est grandement simplifiée. Ce guide vous a détaillé toutes les étapes, de la création du projet à la configuration serveur, l’intégration de la BDD et de systèmes de cache, pour débuter efficacement sur CakePHP. Profitez de la praticité de ServBay pour coder sereinement sans complexité liée à l’environnement technique.