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

ServBay est une solution de développement web local compatible macOS et Windows, intégrant des environnements pour PHP, Node.js, Python, Go, Java et divers services de base de données comme MySQL, PostgreSQL, MongoDB, Redis, ainsi que les serveurs web Caddy ou Nginx. Il offre une plateforme pratique et efficace pour installer, gérer et exploiter vos projets locaux en toute simplicité.

Dans ce guide, vous apprendrez à créer, configurer et lancer un projet CakePHP au sein de ServBay. CakePHP est un framework PHP populaire basé sur le modèle MVC (modèle-vue-contrôleur), reconnu pour son développement rapide, son ORM puissant et ses fonctionnalités de sécurité intégrées. Avec ServBay, amorcez votre développement CakePHP sans contraintes techniques.

Qu’est-ce que CakePHP ?

CakePHP est un framework open source dédié au développement d’applications web en PHP. Il propose une architecture de base permettant de créer rapidement et de façon structurée des applications, sans sacrifier la flexibilité. Sa philosophie “la convention plutôt que la configuration” simplifie de nombreuses tâches courantes.

Atouts et fonctionnalités majeures de CakePHP

• Basé sur le modèle MVC : Structure claire, favorisant la maintenance et l’évolution.
• Développement accéléré : Outils CLI (“Bake”) pour générer du code, accélérant le cycle de développement.
• ORM robuste (Object-Relational Mapping) : Simplifie les interactions avec les bases de données, compatible avec de nombreux systèmes.
• Sécurité intégrée : Protection CSRF, contre les injections SQL, validation des entrées, etc.
• Moteur de templates flexible : Prise en charge de technologies variées pour la couche vue.
• Communauté active et riche écosystème de plugins : Support facile et nombreuses fonctionnalités extensibles.
• Documentation exhaustive : Guides complets et référence API.

CakePHP est adapté à tous types de projets web, qu’il s’agisse d’APIs simples ou d’applications d’envergure.

Créer un environnement CakePHP avec ServBay

ServBay facilite le développement CakePHP grâce à :

• Un interpréteur PHP préinstallé avec les extensions courantes.
• L’intégration native du gestionnaire de paquets Composer.
• Des serveurs web facilement configurables (Caddy/Nginx).
• Des bases de données intégrées (MySQL, PostgreSQL, Redis, etc.).

Grâce à ServBay, évitez les installations et configurations fastidieuses de chaque composant.

Prérequis

Avant de commencer, vérifiez les points ci-dessous :

1. Installation de ServBay : Téléchargez et installez ServBay sur votre Mac.
2. Démarrage des services ServBay : Lancez ServBay et activez les paquets nécessaires (PHP, la base de données désirée comme MySQL ou PostgreSQL, les services de cache tels que Redis ou Memcached). Gérez ces services depuis l’onglet “Paquets” du panneau de contrôle ServBay.
3. Maîtrise des opérations de base ServBay : Sachez comment ajouter et configurer un site dans ServBay. Si besoin, consultez le guide de démarrage ServBay.

Création du projet CakePHP

ServBay recommande d’héberger vos fichiers web dans le dossier /Applications/ServBay/www, optimisant leur détection et gestion.

1. Ouvrir le Terminal

   Lancez l’application Terminal sur macOS.

2. Se rendre dans le répertoire racine des projets ServBay

   Rendez-vous dans le dossier conseillé :

   cd /Applications/ServBay/www

3. Créer un dossier pour le projet

   Créez un nouveau sous-répertoire pour votre application CakePHP (exemple : servbay-cakephp-app) :

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

4. Initialiser la structure du projet CakePHP avec Composer

   Composer étant déjà installé via ServBay, utilisez-le pour créer votre projet CakePHP :

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

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

5. Installer le driver ORM (pour PostgreSQL uniquement)

   Si vous prévoyez d’utiliser PostgreSQL, installez le driver ORM spécifique :

   composer require cakephp/orm-pgsql

   Pour MySQL, pas besoin d’installation supplémentaire : le support est inclus d’office.

Configuration initiale

Après la création du projet, configurez les paramètres de base, notamment la connexion à la base de données.

1. Configurer les variables d’environnement & la base de données

   La configuration locale se fait principalement dans le fichier config/app_local.php. Editer la section Datasources pour renseigner les informations de connexion ; les identifiants par défaut ServBay sont généralement root (utilisateur) et password (mot de passe).

   Exemple pour MySQL :

   // 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, généralement en local
           //'port' => '3306', // MySQL utilise 3306, PostgreSQL utilise 5432
           'username' => 'root', // identifiant par défaut ServBay
           'password' => 'password', // mot de passe par défaut ServBay
           'database' => 'servbay_cakephp_app', // nom de la base à créer
           'encoding' => 'utf8mb4',
           'timezone' => 'UTC',
           'flags' => [],
           'cacheMetadata' => true,
           'log' => false,
   
           /**
            * Activez quoteIdentifiers si 'user' est utilisé comme nom de table, sinon laissez à false pour des noms typiques comme 'cake'.
            */
           'quoteIdentifiers' => false,
   
           /**
            * Limitations actuelles :
            * - La plupart des pilotes ne gèrent pas les niveaux d'isolation via les options PDO.
            * - Tous les pilotes ne gèrent pas le charset via PDO.
            * - Les pilotes packagés comme Postgres pour CakePHP ne supportent pas les options PDO.
            *   Pour Postgres, seul l'encodage est requis.
            */
           'options' => [],
   
           //'url' => env('DATABASE_URL', null), // pour une configuration via l’environnement, activez cette ligne
       ],
   ],

   Adaptez le champ driver et éventuellement le port selon votre type de base. Vérifiez que le nom de la base correspond à celui prévu.

Configuration du serveur web (création du site dans ServBay)

Pour accéder au projet CakePHP via le navigateur, configurez un “site” ServBay pointant sur votre dossier de projet.

1. Ouvrir le panneau de contrôle ServBay

   Cliquez sur l’icône ServBay pour ouvrir le panneau.

2. Accéder à l’onglet “Sites”

   Sélectionnez “Sites” dans la barre latérale (anciennement appelé "Hôte").

3. Ajouter un nouveau site

   Cliquez sur le bouton + pour créer un site. Renseignez :

   • Nom : Nom reconnaissable, ex : Mon site CakePHP Dev.
   • Domaine : Un domaine local, ex : servbay-cakephp-test.local (ServBay le gérera en local).
   • Type de site : Choisissez PHP.
   • Version PHP : Sélectionnez la version compatible (CakePHP 4+ nécessite PHP 7.4+, CakePHP 5+ nécessite PHP 8.1+, ex : 8.3).
   • Racine documentaire : Important ! La racine du serveur web n’est pas le dossier du projet mais le dossier interne webroot. Choisissez /Applications/ServBay/www/servbay-cakephp-app/webroot (changez servbay-cakephp-app selon le nom réel du projet).

4. Enregistrer et appliquer

   Validez via le bouton “Enregistrer”. Dès confirmation, ServBay configure automatiquement Caddy ou Nginx pour le domaine servbay-cakephp-test.local, et pointe vers le dossier webroot de votre projet.

Consultez les étapes détaillées dans la documentation ServBay, rubrique ajouter votre premier site.

Vérification de la configuration

À présent, vous pouvez tester votre site depuis le navigateur.

Accédez à l’URL du domaine configuré, ex : https://servbay-cakephp-test.local.

En cas de configuration correcte, la page d’accueil par défaut CakePHP s’affiche, indiquant que PHP, le serveur web et ServBay fonctionnent bien.

Intégrer base de données et cache

CakePHP bénéficie d’un ORM puissant et d’une couche d’abstraction pour le cache, facilitant la connexion aux services ServBay.

Exemple base relationnelle (MySQL / PostgreSQL)

Voici comment relier CakePHP à une base MySQL ou PostgreSQL sous ServBay, créer une table users et effectuer des opérations CRUD.

1. Créer la base de données dans ServBay

   Avant toute migration, créez la base sur le serveur ServBay. Utilisez le gestionnaire ServBay (phpMyAdmin pour MySQL/MariaDB, pgAdmin pour PostgreSQL, ou Navicat/DBeaver...) pour vous connecter (127.0.0.1, utilisateur root, mot de passe password), puis créez la base servbay_cakephp_app.

2. Créer le fichier Model ORM

   L’ORM CakePHP requiert un fichier model pour chaque table. Créez UsersTable.php pour la table users.

   À placer dans src/Model/Table/UsersTable.php :

   <?php
   namespace App\Model\Table;
   
   use Cake\ORM\Table;
   use Cake\Validation\Validator; // pour la validation des données
   
   class UsersTable extends Table
   {
       /**
        * Méthode d’initialisation
        *
        * @param array $config Configuration du modèle
        * @return void
        */
       public function initialize(array $config): void
       {
           parent::initialize($config);
   
           $this->setTable('users'); // définit le nom de la table cible
           $this->setDisplayField('name'); // champ affiché par défaut
           $this->setPrimaryKey('id'); // clé primaire
   
           // Pour le comportement Timestamp (horodatage)
           // $this->addBehavior('Timestamp');
       }
   
       /**
        * Règles de validation par défaut
        *
        * @param \Cake\Validation\Validator $validator Instance Validator
        * @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 doit être unique
   
           return $validator;
       }
   }

3. Générer le fichier de migration avec Bake

   Utilisez l’outil “Bake” pour créer la migration de la table users. Depuis le dossier racine du projet :

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

   Ce script produit un fichier de migration pour créer la table avec les champs name (string) et email (string, unique).

4. Exécuter la migration de la base

   Pour créer effectivement la table sur la base :

   bin/cake migrations migrate

   Si tout fonctionne, la table users apparaît dans la base de données.

5. Vérifier la configuration de la base (si nécessaire)

   Vérifiez la section Datasources.default dans config/app_local.php pour correspondre à votre type de base et vos infos d’accès.

   • Configuration MySQL :

     '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
         ],
     ],

   • Configuration PostgreSQL :

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

6. Ajouter routes et contrôleurs d’exemple

   Dans config/routes.php, ajoutez des routes pour manipuler les utilisateurs :

   // 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']);
   
       // Route 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
   namespace App\Controller;
   
   use Cake\Http\Response;
   use Cake\ORM\TableRegistry;
   use Cake\Datasource\Exception\RecordNotFoundException; // pour la gestion des exceptions de lecture
   
   class PagesController extends AppController
   {
       /**
        * Affiche une vue
        *
        * @param array ...$path Segments du chemin
        * @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 base de données : Ajouter un utilisateur
        */
       public function dbAddUser(): Response
       {
           $usersTable = TableRegistry::getTableLocator()->get('Users'); // récupère l’instance de Users
   
           // Crée une nouvelle entité utilisateur
           $user = $usersTable->newEntity([
               'name' => 'ServBay Demo User',
               'email' => 'servbay-demo@servbay.test' // email d’exemple ServBay
           ]);
   
           // Tente de sauvegarder l’entité
           if ($usersTable->save($user)) {
               return new Response(['body' => 'Utilisateur ajouté avec succès ! ID utilisateur : ' . $user->id]);
           } else {
               // Échec, probablement dû à une erreur de validation
               $errors = $user->getErrors(); // récupère les erreurs de validation
               return new Response(['body' => 'Échec de l’ajout de l’utilisateur. Erreurs : ' . json_encode($errors)]);
           }
       }
   
       /**
        * Exemple base de données : Liste tous les utilisateurs
        */
       public function dbListUsers(): Response
       {
           $usersTable = TableRegistry::getTableLocator()->get('Users'); // récupère l’instance de Users
   
           // Recherche tous les utilisateurs
           $users = $usersTable->find()->all();
   
           // Convertit le résultat en JSON
           return new Response(['body' => json_encode($users->toArray())]); // convertir la collection en tableau
       }
   }

7. Tester les exemples base de données

   Ouvrez votre navigateur :

   • Rendez-vous sur https://servbay-cakephp-test.local/db-add-user pour ajouter un utilisateur (un message de succès devrait s’afficher).
   • Puis sur https://servbay-cakephp-test.local/db-list-users pour afficher la liste des utilisateurs (dont celui ajouté précédemment).

Voilà, votre projet CakePHP est relié à la base relationnelle ServBay et effectue des opérations ORM de base.

Exemple de service de cache (Memcached / Redis)

CakePHP propose une API de cache unifiée compatible Memcached et Redis. ServBay inclut les extensions PHP nécessaires ainsi que les services associés.

Vérifiez d’abord que Memcached ou Redis sont activés via le panneau ServBay (onglet “Paquets”).

1. Configurer la connexion au cache

   Modifiez config/app_local.php, section Cache.

   • Exemple Memcached :

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\MemcachedEngine::class,
             'servers' => ['127.0.0.1:11211'], // adresse et port Memcached par défaut ServBay
             'prefix' => 'servbay_cakephp_', // préfixe des clés cache
         ],
         // ... autres configurations cache
     ],

   • Exemple Redis :

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\RedisEngine::class,
             'host' => '127.0.0.1', // adresse Redis par défaut ServBay
             'port' => 6379, // port Redis par défaut
             'password' => null, // renseignez si nécessaire
             'database' => 0, // index base Redis
             'prefix' => 'servbay_cakephp_', // préfixe des clés cache
         ],
         // ... autres configurations cache
     ],

   Adaptez selon le service utilisé.

2. Ajouter routes et fonctions d’exemple cache

   Dans config/routes.php, ajoutez :

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

   Dans src/Controller/PagesController.php, intégrez :

   <?php
   namespace App\Controller;
   
   use Cake\Http\Response;
   use Cake\Cache\Cache; // Import Cache
   // ... autres imports
   
   class PagesController extends AppController
   {
       // ... méthodes display, dbAddUser, dbListUsers
   
       /**
        * Exemple cache : utilisation de Memcached
        */
       public function cacheMemcached(): Response
       {
           // Vérifiez que le cache 'default' est configuré en MemcachedEngine
   
           $cacheKey = 'servbay_memcached_test_key';
           $cachedData = Cache::read($cacheKey); // tente de lire en cache
   
           $responseBody = '';
   
           if ($cachedData === false) {
               // Cache “manqué”
               $responseBody = 'Cache manqué ! Écriture "Hello Memcached!" en cache.';
               $dataToCache = 'Hello Memcached!';
               Cache::write($cacheKey, $dataToCache, 'default'); // écrit dans le cache 'default' (Memcached)
           } else {
               // Cache “touché”
               $responseBody = 'Cache touché ! Donnée du cache : ' . $cachedData;
           }
   
           return new Response(['body' => $responseBody]);
       }
   
       /**
        * Exemple cache : utilisation de Redis
        */
       public function cacheRedis(): Response
       {
            // Vérifiez que le cache 'default' utilise RedisEngine
   
           $cacheKey = 'servbay_redis_test_key';
           $cachedData = Cache::read($cacheKey); // lecture du cache
   
           $responseBody = '';
   
           if ($cachedData === false) {
               // Cache “manqué”
               $responseBody = 'Cache manqué ! Écriture "Hello Redis!" en cache.';
               $dataToCache = 'Hello Redis!';
               Cache::write($cacheKey, $dataToCache, 'default'); // écrit dans le cache 'default' (Redis)
           } else {
               // Cache “touché”
               $responseBody = 'Cache touché ! Donnée du cache : ' . $cachedData;
           }
   
           return new Response(['body' => $responseBody]);
       }
   }

3. Tester le cache

   Naviguez vers :

   • https://servbay-cakephp-test.local/cache-memcached (pour Memcached : “manqué” au premier accès, “touché” ensuite).
   • https://servbay-cakephp-test.local/cache-redis (pour Redis : idem).

Ainsi, votre projet utilise le service de cache fourni et configuré par ServBay.

Points d’attention

• Identifiants base de données : Les accès par défaut ServBay (root/password) sont prévus pour un usage local, pensez à les renforcer en production.
• Racine du site : Indiquez toujours le dossier webroot en racine du site ServBay, et non le dossier projet principal.
• Compatibilité PHP : Adaptez la version PHP à celle requise par CakePHP (consultez la documentation officielle).
• Ports ServBay : Si ServBay ne peut utiliser les ports 80 ou 443, modifiez ses paramètres, et ajustez votre fichier hosts ou l’URL d’accès.

FAQ (Foire Aux Questions)

• Q : Je reçois “Page not found” sur servbay-cakephp-test.local ?
  • R : Vérifiez que la “Racine documentaire” ServBay pointe bien vers /Applications/ServBay/www/servbay-cakephp-app/webroot.
  • Assurez-vous que le serveur web (Caddy/Nginx) ServBay est actif.
  • Vérifiez que le domaine est bien relié à 127.0.0.1 dans hosts (ServBay le gère, mais il peut être utile de vérifier).
  • Vérifiez le fichier .htaccess dans webroot ou la configuration serveur (par défaut, la config CakePHP est correcte).
• Q : La connexion base de données échoue ?
  • R : Confirmez que le service base ServBay (MySQL/PostgreSQL) est bien lancé.
  • Contrôlez la configuration de connexion (config/app_local.php) : host, port, identifiant, mot de passe, nom de base.
  • Vérifiez que la base servbay_cakephp_app est bien créée.
• Q : Composer ou la commande bin/cake ne fonctionne pas ?
  • R : Vérifiez que le terminal est bien ouvert dans le dossier racine du projet.
  • PHP et Composer doivent être actifs dans ServBay.
  • Vérifiez la disponibilité de php dans le PATH (SerBvay ajoute PHP au PATH, utilisez éventuellement son terminal ou ajustez PATH à la main).

Résumé

ServBay vous permet d’installer rapidement un environnement local pour vos projets CakePHP. Grâce à ses intégrations de PHP, Composer, base de données et serveur web, vous pouvez vous concentrer sur le code sans perdre de temps sur la configuration technique. Ce tutoriel couvre toutes les étapes : de la création du projet à la connexion base de données et au cache, pour que vous puissiez débuter très vite le développement sous CakePHP. Profitez de la simplicité ServBay pour coder sereinement !