Een CakePHP-project aanmaken en draaien met ServBay

ServBay is een lokaal webontwikkelplatform speciaal ontworpen voor macOS. Het integreert omgevingen voor uiteenlopende programmeertalen zoals PHP, Node.js, Python, Go en Java, en biedt database-services zoals MySQL, PostgreSQL, MongoDB, Redis, gecombineerd met Caddy of Nginx als webserver. Het voorziet in een efficiënt ontwikkelplatform waarmee ontwikkelaars eenvoudig lokale projecten kunnen opzetten en beheren.

In dit artikel leggen we uit hoe je een CakePHP-project creëert, configureert en uitvoert in de ServBay-omgeving. CakePHP is een populair PHP-framework dat het MVC (Model-View-Controller) patroon volgt en bekend staat om z’n snelle ontwikkeling, krachtige ORM en ingebouwde beveiligingsopties. In combinatie met het gebruiksgemak van ServBay kun je vliegensvlug aan de slag met CakePHP-ontwikkeling.

Wat is CakePHP?

CakePHP is een open-source PHP webapplicatie-framework dat een solide basisstructuur biedt voor het snel en gestructureerd ontwikkelen van webapps, zonder flexibiliteit te verliezen. Het werkt volgens het principe ‘convention over configuration’, waardoor veelvoorkomende ontwikkeltaken eenvoudiger worden.

Belangrijkste kenmerken en voordelen van CakePHP

• MVC-gebaseerde structuur: Heldere code-organisatie die het onderhoud en uitbreidbaarheid vergemakkelijkt.
• Snelle ontwikkeling: Command-line tools (Bake) voor automatische codegeneratie versnellen de ontwikkelcyclus.
• Krachtige ORM (Object Relational Mapping): Maakt database-interactie eenvoudig, met ondersteuning voor diverse databasesystemen.
• Ingebouwde beveiliging: Bescherming tegen CSRF, SQL-injectie, inputvalidatie, en meer.
• Flexibele template engine: Ondersteunt meerdere view-technologieën.
• Actieve community en een scala aan plugins: Voldoende ondersteuning en uitbreidingsmogelijkheden.
• Uitgebreide documentatie: Duidelijke guides en API-referenties.

CakePHP is geschikt voor elk type webapplicatie, van simpele API’s tot grote enterprise-systemen.

CakePHP ontwikkelomgeving opzetten met ServBay

ServBay biedt een geïntegreerde omgeving voor CakePHP-ontwikkeling, waaronder:

• Voorgeselecteerde PHP-versies en -extensies.
• Vooraf geïnstalleerde Composer package manager.
• Eenvoudig te configureren webserver (Caddy/Nginx).
• Geïntegreerde databaseservices (MySQL, PostgreSQL, Redis, enz.).

Dankzij ServBay hoef je niet langer handmatig al deze componenten te installeren en configureren.

Vereisten

Zorg ervoor dat je onderstaande stappen hebt gevolgd voordat je begint:

1. Installeer ServBay: Download en installeer ServBay succesvol op je macOS-systeem.
2. Start ServBay-services: Open de ServBay-app en zorg dat de benodigde pakketten (bijvoorbeeld PHP, de gewenste database zoals MySQL of PostgreSQL, en caching-services als Redis of Memcached) lopen. In het "Pakketten" tab kun je deze aan- of uitzetten.
3. Basiskennis ServBay: Weet hoe je in ServBay een website toevoegt en instelt. Eerst de ServBay basisgebruiksgids doornemen wordt aangeraden als je hiermee onbekend bent.

CakePHP-project aanmaken

ServBay raadt aan om je webprojecten te plaatsen in de map /Applications/ServBay/www. Dit zorgt ervoor dat ServBay je websites automatisch kan herkennen en beheren.

1. Open Terminal

   Start de Terminal-app van macOS.

2. Navigeer naar de ServBay rootmap

   Ga naar de aanbevolen map voor websites:

   cd /Applications/ServBay/www

3. Maak een projectmap aan

   Maak een nieuwe submap voor je CakePHP-project. In dit voorbeeld noemen we die servbay-cakephp-app:

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

4. Maak een CakePHP-project met Composer

   Composer is reeds geïnstalleerd via ServBay. Initialiseer het project met Composer:

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

   Deze opdracht haalt de nieuwste stabiele versie van CakePHP plus alle afhankelijkheden op en installeert deze in je huidige map (.).

5. ORM-driver installeren (voor PostgreSQL)

   Wil je PostgreSQL gebruiken, installeer dan de CakePHP-ORM-driver:

   composer require cakephp/orm-pgsql

   Voor MySQL is dit niet nodig; de driver is standaard aanwezig.

Basale configuratie

Na het aanmaken, wil je nog bepaalde instellingen doen – met name voor de databaseverbinding.

1. Omgevingsvariabelen & databaseverbinding instellen

   Lokale configuraties van CakePHP worden vooral geregeld in config/app_local.php. Zoek daarin het gedeelte Datasources en vul je databasegegevens in. De standaard gebruikersnaam bij ServBay is meestal root en het standaard wachtwoord is password.

   Bijvoorbeeld, zo stel je MySQL in:

   // config/app_local.php
   'Datasources' => [
       'default' => [
           'className' => \Cake\Database\Connection::class,
           'driver' => \Cake\Database\Driver\Mysql::class, // voor PostgreSQL: \Cake\Database\Driver\Postgres::class
           'persistent' => false,
           'host' => '127.0.0.1', // Servert dus lokaal, via ServBay
           //'port' => '3306', // Standaard MySQL: 3306, PostgreSQL: 5432
           'username' => 'root',
           'password' => 'password',
           'database' => 'servbay_cakephp_app', // Zelf gekozen databasenaam
           'encoding' => 'utf8mb4',
           'timezone' => 'UTC',
           'flags' => [],
           'cacheMetadata' => true,
           'log' => false,
   
           /**
            * Zet identifier quoting op true bij gebruik van gereserveerde woorden (zoals "user") als tabelnaam.
            * Bij gewone tabellen kan dit uit.
            * Twijfel? Zet op true.
            */
           'quoteIdentifiers' => false,
   
           /**
            * Bepaalde beperkingen:
            * - De meeste drivers ondersteunen geen isolatieniveaus instellen via PDO-opties.
            * - Niet alle drivers ondersteunen het instellen van een charset via PDO-opties.
            * - PDO-opties niet ondersteund bij pakeaged drivers van CakePHP zoals Postgres.
            *   Bij Postgres hoef je alleen de encoding in te stellen.
            */
           'options' => [],
   
           //'url' => env('DATABASE_URL', null), // Gebruik deze regel indien DATABASE_URL wordt gebruikt
       ],
   ],

   Pas driver en eventuele port aan op MySQL of PostgreSQL. Zorg dat de opgegeven database overeenkomt met de naam van de database die je zult aanmaken.

Webserver configureren (website aanmaken in ServBay)

Om je CakePHP-project via de browser te bereiken, stel je in ServBay een nieuwe website in die verwijst naar je projectmap.

1. Open het ServBay-configuratiepaneel

   Klik op het ServBay-icoon om het paneel te openen.

2. Navigeer naar het tabblad “Websites”

   Kies "Websites" in het linkermenu.

3. Voeg een nieuwe website toe

   Klik linksonder op de +-knop om een website toe te voegen en vul het volgende in:

   • Naam: Iets herkenbaars zoals My CakePHP Dev Site.
   • Domein: Bijvoorbeeld servbay-cakephp-test.local. ServBay koppelt deze automatisch naar je lokale machine.
   • Sitetype: Kies PHP.
   • PHP-versie: Stem af op je CakePHP-versie (CakePHP 4+ doorgaans PHP 7.4+, CakePHP 5+ vereist meestal PHP 8.1+), kies bijvoorbeeld 8.3.
   • Document Root: Belangrijk! Stel dit in op de webroot map binnen je CakePHP-project, niet de hoofdmap. Dus /Applications/ServBay/www/servbay-cakephp-app/webroot (vervang servbay-cakephp-app naar jouw map).

4. Opslaan en toepassen

   Klik op “Opslaan” rechtsonder en bevestig de wijziging. ServBay past automatisch je setup aan, zodat verzoeken naar servbay-cakephp-test.local in het juiste project terechtkomen.

Zie Website toevoegen in de ServBay-documentatie voor meer uitleg.

Basisinstellingen verifiëren

Je kunt je nieuwe website nu in de browser bezoeken.

Typ het domein dat je net instelde in ServBay, bijvoorbeeld https://servbay-cakephp-test.local.

Bij een correcte setup krijg je de standaard CakePHP-welkomstpagina te zien. Dan weet je dat PHP, je webserver en de ServBay-configuratie werken zoals verwacht.

Databases & caching integreren

CakePHP heeft een krachtige ORM en cachelaag waarmee je eenvoudig de database- en opslagdiensten van ServBay inzet.

Voorbeeld: Relationele database (MySQL / PostgreSQL)

Hier een voorbeeld hoe je in CakePHP’s ORM verbinding maakt met een database, een users-tabel aanmaakt, en eenvoudige CRUD-operaties uitvoert.

1. Maak een database aan in ServBay

   Maak eerst een lege database (bijvoorbeeld servbay_cakephp_app) aan in de database die draait via ServBay. Hiervoor gebruik je bijvoorbeeld phpMyAdmin (voor MySQL/MariaDB), pgAdmin (voor PostgreSQL), of beheertools als Navicat/DBeaver. Verbinden kan op 127.0.0.1, met gebruiker root en wachtwoord password.

2. Maak het ORM-modelbestand aan

   De ORM van CakePHP werkt met modelbestanden. Maak een UsersTable.php aan voor de tabel users.

   Sla het volgende op als src/Model/Table/UsersTable.php:

   <?php
   namespace App\Model\Table;
   
   use Cake\ORM\Table;
   use Cake\Validation\Validator; // Validatieregels indien nodig
   
   class UsersTable extends Table
   {
       /**
        * Initializeer de tabelconfiguratie
        *
        * @param array $config De configuratie voor de tabel.
        * @return void
        */
       public function initialize(array $config): void
       {
           parent::initialize($config);
   
           $this->setTable('users'); // Specificeer tabelnaam expliciet
           $this->setDisplayField('name'); // Standaard weergave veld bij relaties
           $this->setPrimaryKey('id'); // Stel primaire sleutel velden in
   
           // Wil je automatisch timestamp-velden, activeer dan Timestamp-behavior
           // $this->addBehavior('Timestamp');
       }
   
       /**
        * Standaard validatieregels
        *
        * @param \Cake\Validation\Validator $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']); // Controleer of e-mail uniek is
   
           return $validator;
       }
   }

3. Maak met Bake een migratiebestand aan

   CakePHP raadt aan om databasemutaties via migraties bij te houden. Maak in je projectmap (/Applications/ServBay/www/servbay-cakephp-app) met Bake een migratie aan voor de users-tabel:

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

   Zo ontstaat een migratiebestand dat de tabel en bijbehorende velden definieert.

4. Voer de database-migratie uit

   Migreer de wijzigingen zodat de tabel wordt aangemaakt in de database:

   bin/cake migrations migrate

   Als dit lukt zie je de nieuwe users-tabel in je database.

5. Controleer of je databaseverbinding juist is geconfigureerd

   Check dat config/app_local.php (Datasources.default) correct ingesteld is voor jouw database.

   • MySQL-voorbeeld:

     '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',
             // ... andere opties
         ],
     ],

   • PostgreSQL-voorbeeld:

     'Datasources' => [
         'default' => [
             'className' => \Cake\Database\Connection::class,
             'driver' => \Cake\Database\Driver\Postgres::class,
             'host' => '127.0.0.1',
             // 'port' => '5432', // Standaardpoort
             'username' => 'root', // ServBay gebruikersnaam
             'password' => 'password', // ServBay wachtwoord
             'database' => 'servbay_cakephp_app',
             // ... andere opties
         ],
     ],

6. Voorbeeldroutes en controller-methodes toevoegen

   Voeg aan config/routes.php routes toe om gebruikers toe te voegen en te tonen:

   // 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) {
       // ... overige routes
       $routes->connect('/', ['controller' => 'Pages', 'action' => 'display', 'home']);
   
       // Database demo routes
       $routes->connect('/db-add-user', ['controller' => 'Pages', 'action' => 'dbAddUser']);
       $routes->connect('/db-list-users', ['controller' => 'Pages', 'action' => 'dbListUsers']);
   
       // ... overige routes
       $routes->fallbacks(DashedRoute::class);
   });

   Voeg vervolgens deze methodes toe in src/Controller/PagesController.php:

   <?php
   namespace App\Controller;
   
   use Cake\Http\Response;
   use Cake\ORM\TableRegistry;
   use Cake\Datasource\Exception\RecordNotFoundException; // Exception handling voor niet gevonden records
   
   class PagesController extends AppController
   {
       /**
        * Standaardpagina
        *
        * @param array ...$path Padsegmenten.
        * @return \Cake\Http\Response|null
        */
       public function display(...$path): ?Response
       {
           // ... standaard display-methode
           return new Response(['body' => 'Hello ServBay! Dit is de standaardpagina.']);
       }
   
       /**
        * Databasevoorbeeld: Gebruiker toevoegen
        */
       public function dbAddUser(): Response
       {
           $usersTable = TableRegistry::getTableLocator()->get('Users'); // Haal Users Table op
   
           // Maak een nieuwe gebruiker
           $user = $usersTable->newEntity([
               'name' => 'ServBay Demo User',
               'email' => '[email protected]' // Demo e-mailadres voor merkherkenning
           ]);
   
           // Sla de gebruiker op
           if ($usersTable->save($user)) {
               return new Response(['body' => 'Gebruiker succesvol toegevoegd! Gebruiker ID: ' . $user->id]);
           } else {
               $errors = $user->getErrors(); // Validatiefouten ophalen
               return new Response(['body' => 'Toevoegen mislukt. Fouten: ' . json_encode($errors)]);
           }
       }
   
       /**
        * Databasevoorbeeld: Alle gebruikers tonen
        */
       public function dbListUsers(): Response
       {
           $usersTable = TableRegistry::getTableLocator()->get('Users'); // Haal Users Table op
   
           // Haal alle gebruikers op
           $users = $usersTable->find()->all();
   
           // Geef alles als JSON terug
           return new Response(['body' => json_encode($users->toArray())]); // Zet Collection om naar array
       }
   }

7. Gebruik de databasevoorbeelden

   Open je browser:

   • Ga naar https://servbay-cakephp-test.local/db-add-user om een gebruiker aan te maken; je ziet bevestiging.
   • Ga naar https://servbay-cakephp-test.local/db-list-users om een lijst van gebruikers te tonen (waaronder de zojuist aangemaakte).

Met deze stappen heb je succesvol je CakePHP-project gekoppeld aan een ServBay-database, en basale ORM-operaties uitgevoerd.

Voorbeeld: Caching-service (Memcached / Redis)

CakePHP’s uniforme caching-API maakt schakelen tussen Memcached en Redis eenvoudig. ServBay levert standaard Memcached- en Redis-extensies en de benodigde services.

Start Memcached of Redis via het “Pakketten”-tabblad in ServBay.

1. Cacheconnectie instellen

   Bewerk in config/app_local.php in het Cache-deel de verbinding.

   • Memcached-configuratie:

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\MemcachedEngine::class,
             'servers' => ['127.0.0.1:11211'], // Standaard Memcached-port ServBay
             'prefix' => 'servbay_cakephp_', // Prefiex voor cache keys
         ],
     // ... evt. andere cachegroepen
     ],

   • Redis-configuratie:

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\RedisEngine::class,
             'host' => '127.0.0.1', // Standaard Redis-host ServBay
             'port' => 6379, // Standaard Redis-port
             'password' => null, // Zet een wachtwoord als Redis dit vereist
             'database' => 0, // Redis database-index
             'prefix' => 'servbay_cakephp_', // Prefiex voor cache keys
         ],
     // ... evt. andere cachegroepen
     ],

   Stel in naar gelang je cache-engine.

2. Voorbeeldroutes & controller-methodes

   Voeg aan config/routes.php twee routes toe:

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

   Voeg daarna deze methodes toe aan src/Controller/PagesController.php:

   <?php
   namespace App\Controller;
   
   use Cake\Http\Response;
   use Cake\Cache\Cache; // Importeer Cache-klasse
   // ... andere use-statements
   
   class PagesController extends AppController
   {
       // ... andere methodes (display, dbAddUser, dbListUsers)
   
       /**
        * Cachevoorbeeld: Gebruik van Memcached
        */
       public function cacheMemcached(): Response
       {
           // Zorg dat 'default' cache in app_local.php op Memcached staat
   
           $cacheKey = 'servbay_memcached_test_key';
           $cachedData = Cache::read($cacheKey); // Lees uit cache
   
           $responseBody = '';
   
           if ($cachedData === false) {
               // Cache niet gevonden
               $responseBody = 'Cache miss! "Hello Memcached!" in cache opslaan.';
               $dataToCache = 'Hello Memcached!';
               Cache::write($cacheKey, $dataToCache, 'default');
           } else {
               $responseBody = 'Cache hit! Data uit cache: ' . $cachedData;
           }
   
           return new Response(['body' => $responseBody]);
       }
   
       /**
        * Cachevoorbeeld: Gebruik van Redis
        */
       public function cacheRedis(): Response
       {
            // Zorg dat 'default' cache in app_local.php op Redis staat
   
           $cacheKey = 'servbay_redis_test_key';
           $cachedData = Cache::read($cacheKey);
   
           $responseBody = '';
   
           if ($cachedData === false) {
               // Cache niet gevonden
               $responseBody = 'Cache miss! "Hello Redis!" in cache opslaan.';
               $dataToCache = 'Hello Redis!';
               Cache::write($cacheKey, $dataToCache, 'default');
           } else {
               $responseBody = 'Cache hit! Data uit cache: ' . $cachedData;
           }
   
           return new Response(['body' => $responseBody]);
       }
   }

3. Cachevoorbeelden uitproberen

   Open je browser:

   • Bezoek je https://servbay-cakephp-test.local/cache-memcached bij gebruik van Memcached. Eerst zie je “Cache miss”, bij verversen komt “Cache hit”.
   • Bezoek https://servbay-cakephp-test.local/cache-redis bij gebruik van Redis. Zelfde effect.

Zo zie je dat de caching-diensten van ServBay probleemloos werken met CakePHP.

Belangrijke aandachtspunten

• Databasegegevens: De standaard root/password zijn alleen bedoeld voor lokaal gebruik. Gebruik in productie sterkere gegevens.
• Document Root: Zorg dat je ServBay website-wortel naar de webroot in je CakePHP-map wijst, niet naar de hoofdmap. Dit is best practice.
• PHP-versie: De gekozen PHP-versie in ServBay moet passen bij je CakePHP-versie. Check de officiële CakePHP-documentatie voor eisen.
• ServBay-poorten: Worden poorten 80/443 bezet door andere programma's, wijzig dan je ServBay-instellingen en gebruik desgewenst poorten in de URL of pas je hosts-bestand aan.

Veelgestelde vragen (FAQ)

• Q: “Pagina niet gevonden” bij toegang tot servbay-cakephp-test.local?
  • A: Controleer of de document root instelt op /Applications/ServBay/www/servbay-cakephp-app/webroot.
  • Kijk of de webserver (Caddy/Nginx) in ServBay draait.
  • Check je hosts-bestand of servbay-cakephp-test.local naar 127.0.0.1 wijst (ServBay regelt dit meestal zelf).
  • Kijk of .htaccess of andere configuratiebestanden in je project kloppen (standaard is webroot/.htaccess goed ingesteld).
• Q: Kan geen verbinding maken met database?
  • A: Kijk of de server (MySQL/PostgreSQL) via ServBay loopt.
  • Controleer of je in config/app_local.php de juiste host, poort, gebruikersnaam, wachtwoord en databasenaam instelt.
  • Zorg dat de database servbay_cakephp_app bestaat.
• Q: Composer of bin/cake werkt niet?
  • A: Check of je terminal in de juiste projectmap staat (/Applications/ServBay/www/servbay-cakephp-app).
  • Controleer dat PHP en Composer in ServBay aan staan.
  • Kijk of je terminal toegang heeft tot het juiste php-commando (ServBay zet PHP meestal in je PATH, anders gebruik je het ingebouwde terminalvenster van ServBay).

Samenvatting

Dankzij ServBay zet je razendsnel een lokale ontwikkelomgeving op voor CakePHP op je Mac. Met de voorgeïnstalleerde PHP, Composer, webserver en databasecomponenten wordt alles eenvoudig en snel. In deze handleiding hebben we stap voor stap uitgelegd hoe je een CakePHP-project opzet, de basis configureert, de webserver instelt, relationele database en caching koppelt — zodat je snel aan je project kan starten. Met ServBay’s gemak kun je je focussen op het programmeren en hoef je je geen zorgen te maken over complexe omgevingsinstellingen.