Een CakePHP-project maken en uitvoeren met ServBay

ServBay is een lokale webontwikkelomgeving voor zowel macOS als Windows, uitgerust met geïntegreerde ondersteuning voor diverse programmeertalen zoals PHP, Node.js, Python, Go en Java. Daarnaast biedt het databaseoplossingen als MySQL, PostgreSQL, MongoDB, Redis en meer, samen met moderne webservers zoals Caddy of Nginx. Hiermee krijgen ontwikkelaars een gebruiksvriendelijk platform voor het snel beheren van lokale projecten.

In dit artikel leer je hoe je binnen ServBay een CakePHP-project kunt opzetten, configureren en gebruiken. CakePHP is een populair PHP-webframework dat het MVC-model (Model-View-Controller) volgt. Het staat bekend om zijn snelle ontwikkeling, krachtige ORM, en ingebouwde beveiligingsfunctionaliteit. In combinatie met het gemak van ServBay kun je onmiddellijk aan de slag met CakePHP-ontwikkeling.

Wat is CakePHP?

CakePHP is een open-source PHP-framework voor webapplicatieontwikkeling. Het biedt een solide fundament voor het ontwikkelen van webapplicaties — snel en gestructureerd, zonder flexibiliteit te verliezen. Door het principe ‘conventie boven configuratie’ worden alledaagse ontwikkeltaken vereenvoudigd.

Belangrijkste kenmerken en voordelen van CakePHP

• Gebaseerd op het MVC-model: Heldere code-organisatie voor eenvoudig onderhoud en uitbreiding.
• Snelle ontwikkeling: Commandlinetool ‘Bake’ genereert code, waardoor ontwikkelsnelheid toeneemt.
• Krachtige ORM (Object-Relational Mapping): Vereenvoudigt database-interactie en ondersteunt meerdere databasesystemen.
• Ingebouwde beveiliging: CSRF-bescherming, SQL-injectiepreventie en invoervalidatie.
• Flexibele template-engine: Ondersteunt verschillende oplossingen voor het weergavegedeelte.
• Actieve community en uitgebreide plugins: Veel hulpbronnen en eenvoudig uit te breiden functionaliteit.
• Uitgebreide documentatie: Alles is helder gedocumenteerd in handleidingen en API-referenties.

CakePHP is geschikt voor uiteenlopende webprojecten, van eenvoudige API's tot complexe bedrijfsapplicaties.

Een CakePHP-ontwikkelomgeving opzetten met ServBay

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

• Vooraf geïnstalleerde PHP-interpreter en veelgebruikte extensies.
• Composer (pakketbeheerder) is reeds geïnstalleerd.
• Eenvoudige configuratie van webservers (Caddy/Nginx).
• Geïntegreerde databases (MySQL, PostgreSQL, Redis, etc.).

Je bespaart tijd en moeite, omdat handmatige installatie en configuratie niet nodig zijn.

Vereisten

Voordat je begint, zorg ervoor dat je het volgende hebt gedaan:

1. Installeer ServBay: Download en installeer ServBay op macOS.
2. Start ServBay-services: Open ServBay en controleer of de benodigde pakketten (zoals PHP, jouw gekozen database zoals MySQL of PostgreSQL, en caching-services zoals Redis of Memcached) actief zijn. Dit beheer je via het tabblad "Pakketten" in ServBay.
3. Basisgebruik ServBay: Zorg dat je weet hoe je een website toevoegt en configureert binnen ServBay. Is dit nieuw voor je, lees dan eerst de ServBay basisgids.

Een CakePHP-project aanmaken

ServBay raadt aan je webprojecten in /Applications/ServBay/www te plaatsen. Zo worden ze automatisch gedetecteerd en beheerd.

1. Open Terminal

   Start de terminal-applicatie op macOS.

2. Navigeer naar de ServBay hoofdmap voor websites

   Ga naar de aanbevolen directory:

   cd /Applications/ServBay/www

3. Maak een map voor je project

   Maak een submap aan voor je CakePHP-project. Neem bijvoorbeeld servbay-cakephp-app als projectnaam:

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

4. CakePHP-project genereren met Composer

   Composer is al geïntegreerd in ServBay. Maak een project-skelet met:

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

   Deze opdracht installeert de nieuwste stabiele release van CakePHP met alle afhankelijkheden in de huidige map (.).

5. ORM-driver installeren (bij gebruik van PostgreSQL)

   Werk je met PostgreSQL, dan heb je de extra driver nodig:

   composer require cakephp/orm-pgsql

   MySQL vereist geen extra drivers: deze zijn opgenomen in de standaard CakePHP-afhankelijkheden.

Basisconfiguratie

Na aanmaken, zijn enkele instellingen nodig — vooral je databaseverbinding.

1. Instellen van variabelen en databaseverbinding

   Lokale CakePHP-configuratie gebeurt hoofdzakelijk in config/app_local.php. Pas de instellingen aan onder ‘Datasources’ met jouw databasegegevens. In ServBay is de standaardgebruikersnaam meestal root en het standaardwachtwoord password.

   Voorbeeld MySQL-verbinding:

   // config/app_local.php
   'Datasources' => [
       'default' => [
           'className' => \Cake\Database\Connection::class,
           'driver' => \Cake\Database\Driver\Mysql::class, // Of \Cake\Database\Driver\Postgres::class voor PostgreSQL
           'persistent' => false,
           'host' => '127.0.0.1', // Locatie van de database server, standaard lokaal in ServBay
           //'port' => '3306', // Standaard poort voor MySQL is 3306, voor PostgreSQL 5432
           'username' => 'root', // Standaard gebruikersnaam ServBay
           'password' => 'password', // Standaard wachtwoord ServBay
           'database' => 'servbay_cakephp_app', // Naam van je database
           'encoding' => 'utf8mb4',
           'timezone' => 'UTC',
           'flags' => [],
           'cacheMetadata' => true,
           'log' => false,
   
           /**
            * Zet identifier quoting op true als je bijvoorbeeld 'user' als tabelnaam gebruikt.
            * Gebruik je gewone namen (zoals 'cake'), zet dit op false.
            * Niet zeker? Kies true.
            */
           'quoteIdentifiers' => false,
   
           /**
            * Beperkingen:
            * - De meeste drivers ondersteunen geen isolatieniveaus via PDO-parameters.
            * - Niet alle drivers ondersteunen het instellen van tekenset via PDO.
            * - Dit geldt vooral voor packaged drivers zoals Postgres vanuit CakePHP.
            *   Bij Postgres volstaat het instellen van encoding.
            */
           'options' => [],
   
           //'url' => env('DATABASE_URL', null), // Gebruik dit indien je DATABASE_URL als variabele instelt
       ],
   ],

   Pas de driver en eventueel de port aan afhankelijk van je type database (MySQL of PostgreSQL). Zorg dat database overeenkomt met de aangemaakte database.

Webserver configureren (een website aanmaken in ServBay)

Voor browsertoegang moet je een ServBay-site configureren die op jouw projectmap wijst.

1. Open ServBay Control Panel

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

2. Ga naar het tabblad ‘Websites’

   Selecteer in de navigatie ‘Websites’ (voorheen ‘Hosts’).

3. Nieuwe website toevoegen

   Klik op + onderin om een nieuwe site toe te voegen. Vul in:

   • Naam: Een makkelijk te herkennen naam, bijvoorbeeld Mijn CakePHP Dev Site.
   • Domein: Een lokaal ontwikkeldomein, zoals servbay-cakephp-test.local. ServBay koppelt dit automatisch aan je computer.
   • Site Type: Kies PHP.
   • PHP Versie: Kies een versie die compatibel is met jouw CakePHP-versie (vanaf CakePHP 4: PHP 7.4+, vanaf CakePHP 5: PHP 8.1+), bijvoorbeeld 8.3.
   • Document Root: Belangrijk! De webroot van CakePHP bevindt zich in de map webroot binnen je project, NIET de hoofddirectory. Stel dit in als /Applications/ServBay/www/servbay-cakephp-app/webroot (vervang servbay-cakephp-app door jouw mapnaam).

4. Wijzigingen opslaan en activeren

   Klik rechtsonder op ‘Opslaan’. ServBay zal vragen om de wijzigingen toe te passen; bevestig dit. De webserver (Caddy of Nginx) wordt automatisch ingesteld om het domein servbay-cakephp-test.local te koppelen aan jouw ‘webroot’-folder.

Zie voor een uitgebreider stappenplan het gedeelte Eerste site toevoegen in de ServBay-documentatie.

Basisinstellingen testen

Je website is nu benaderbaar via de browser.

Open je browser en ga naar het ingestelde domein, bijvoorbeeld https://servbay-cakephp-test.local.

Zie je de standaard CakePHP welkomstpagina? Dan werken PHP, de webserver, en de ServBay-configuratie correct.

Database- en cache-integratie

CakePHP heeft een krachtige ORM en cache-laag waarmee je ServBay’s database- en cacheservices eenvoudig gebruikt.

Voorbeeld: relationele database (MySQL / PostgreSQL)

Hier laten we zien hoe je met CakePHP’s ORM ServBay’s MySQL- of PostgreSQL-database verbindt, een eenvoudige users-tabel aanmaakt en CRUD-operaties uitvoert.

1. Maak een database in ServBay aan

   Voor de eerste migratie moet je in ServBay een nieuwe database maken. Gebruik phpMyAdmin (voor MySQL/MariaDB), pgAdmin (voor PostgreSQL) of een extern tool zoals Navicat, DBeaver, etc. Verbind met de database (meestal 127.0.0.1, gebruiker root, wachtwoord password) en maak de database servbay_cakephp_app.

2. Maak een ORM Model-bestand

   CakePHP’s ORM gebruikt een Model-bestand voor elk databasetabel. Maak UsersTable.php aan.

   Plaats onderstaand bestand in src/Model/Table/UsersTable.php:

   <?php
   namespace App\Model\Table;
   
   use Cake\ORM\Table;
   use Cake\Validation\Validator; // Voor validatieregels indien nodig
   
   class UsersTable extends Table
   {
       /**
        * Initialiseer methode
        *
        * @param array $config De configuratie voor deze Tabel.
        * @return void
        */
       public function initialize(array $config): void
       {
           parent::initialize($config);
   
           $this->setTable('users'); // Tabelnaam vastleggen
           $this->setDisplayField('name'); // Standaard weergaveveld instellen
           $this->setPrimaryKey('id'); // Primaire sleutel instellen
   
           // Tijdstempelgedrag indien gewenst
           // $this->addBehavior('Timestamp');
       }
   
       /**
        * Standaard validatieregels.
        *
        * @param \Cake\Validation\Validator $validator Validator-instantie.
        * @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 uniek houden
   
           return $validator;
       }
   }

3. Maak een migratiebestand met Bake

   CakePHP raadt migraties aan voor het databasebeheer. Ga naar je projectdirectory (/Applications/ServBay/www/servbay-cakephp-app) en genereer een migratiebestand:

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

   Deze opdracht maakt een migratie aan voor de tabel users met de velden name (string) en een unieke email (string).

4. Migratie uitvoeren

   Voer de migratie uit, zodat de users-tabel in je database komt:

   bin/cake migrations migrate

   Bij succes zie je in de database nu de nieuwe tabel.

5. Databaseconfiguratie controleren

   Controleer of config/app_local.php onder Datasources.default overeenkomt met je database-setup.

   • MySQL Configuratie:

     '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',
             // ... overige daadwerkelijke settings
         ],
     ],

   • PostgreSQL Configuratie:

     'Datasources' => [
         'default' => [
             'className' => \Cake\Database\Connection::class,
             'driver' => \Cake\Database\Driver\Postgres::class,
             'host' => '127.0.0.1',
             // 'port' => '5432', // Standaard poort
             'username' => 'root', // Standaard gebruiker ServBay
             'password' => 'password', // Standaard wachtwoord ServBay
             'database' => 'servbay_cakephp_app',
             // ... overige daadwerkelijke settings
         ],
     ],

6. Voorbeeldroutes en controller-methoden toevoegen

   Voeg routes toe in config/routes.php voor het toevoegen en bekijken van gebruikers:

   // 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']);
   
       // Databasevoorbeeldroutes toevoegen
       $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 methoden toe in src/Controller/PagesController.php:

   <?php
   namespace App\Controller;
   
   use Cake\Http\Response;
   use Cake\ORM\TableRegistry;
   use Cake\Datasource\Exception\RecordNotFoundException; // Voor het afhandelen van ontbrekende records
   
   class PagesController extends AppController
   {
       /**
        * Toont een view
        *
        * @param array ...$path Path-segmenten.
        * @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'); // Verkrijg een instantie van Users Table
   
           // Maak een nieuw gebruikersobject aan
           $user = $usersTable->newEntity([
               'name' => 'ServBay Demo User',
               'email' => 'servbay-demo@servbay.test' // Voorbeeld-email op basis van het ServBay-merk
           ]);
   
           // Probeer op te slaan
           if ($usersTable->save($user)) {
               return new Response(['body' => 'Gebruiker succesvol toegevoegd! Gebruiker-ID: ' . $user->id]);
           } else {
               // Opslaan mislukt: validatiefout of andere problemen
               $errors = $user->getErrors(); // Verkrijg validatiefouten
               return new Response(['body' => 'Toevoegen mislukt. Fouten: ' . json_encode($errors)]);
           }
       }
   
       /**
        * Databasevoorbeeld: toon alle gebruikers
        */
       public function dbListUsers(): Response
       {
           $usersTable = TableRegistry::getTableLocator()->get('Users'); // Verkrijg een instantie van Users Table
   
           // Haal alle gebruikers op
           $users = $usersTable->find()->all();
   
           // Geef de resultaten als JSON
           return new Response(['body' => json_encode($users->toArray())]); // Zet collectie om naar array
       }
   }

7. Toegang tot databasevoorbeelden

   Open je browser:

   • Ga naar https://servbay-cakephp-test.local/db-add-user om een gebruiker toe te voegen. Je ziet een bevestiging bij succes.
   • Ga naar https://servbay-cakephp-test.local/db-list-users om alle gebruikers in de database te tonen (de net toegevoegde gebruiker staat ertussen).

Zo heb je jouw CakePHP-project succesvol gekoppeld aan een relationele database in ServBay en basale ORM-acties uitgevoerd.

Voorbeeld: caching (Memcached / Redis)

CakePHP heeft een uniforme cache-API waarmee je eenvoudig schakelt tussen engines als Memcached en Redis. ServBay levert beide PHP-extensies en services vooraf geïnstalleerd.

Zorg eerst dat Memcached of Redis is ingeschakeld in het ServBay ‘Pakketten’-tabblad.

1. Cacheverbinding configureren

   Pas in config/app_local.php het blok ‘Cache’ aan:

   • Voorbeeldconfiguratie Memcached:

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\MemcachedEngine::class,
             'servers' => ['127.0.0.1:11211'], // ServBay standaard Memcached-adres en poort
             'prefix' => 'servbay_cakephp_', // Prefix voor cache-sleutels
         ],
         // ... overige cache-instellingen
     ],

   • Voorbeeldconfiguratie Redis:

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\RedisEngine::class,
             'host' => '127.0.0.1', // ServBay standaard Redis-adres
             'port' => 6379, // Standaard Redis-poort in ServBay
             'password' => null, // Indien Redis een wachtwoord heeft, vul deze hier in
             'database' => 0, // Redis database-index
             'prefix' => 'servbay_cakephp_', // Prefix voor cache-sleutels
         ],
         // ... overige cache-instellingen
     ],

   Kies de cache-service die je gebruikt.

2. Voorbeeldroutes en controller-methoden toevoegen

   Voeg routes toe in config/routes.php voor caching:

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

   Voeg cache-methoden toe in src/Controller/PagesController.php:

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

3. Cachingvoorbeeld bezoeken

   • Voor Memcached: ga naar https://servbay-cakephp-test.local/cache-memcached. Eerste keer zie je “Cache miss”, daarna bij refresh “Cache hit”.
   • Voor Redis: ga naar https://servbay-cakephp-test.local/cache-redis. Eerste keer “Cache miss”, daarna “Cache hit”.

Je CakePHP-project is nu succesvol geïntegreerd met ServBay’s cachingservices.

Opmerkingen & tips

• Database-inloggegevens: De standaard ServBay-instellingen (root/password) zijn enkel geschikt voor lokale ontwikkeling. Gebruik in productie altijd veilige credentials.
• Web root (Document Root): Laat de ServBay ‘Document Root’ altijd naar de webroot–map van je CakePHP-project wijzen; dit is de aanbevolen aanpak voor CakePHP.
• PHP-versie: Controleer dat de gekozen PHP-versie in ServBay compatibel is met jouw CakePHP-versie. Zie de officiële CakePHP-documentatie.
• ServBay-poorten: Als standaard poorten (80, 443) bezet zijn door andere programma's, wijzig je ze via ServBay-instellingen en pas je hosts-bestand/URL's aan.

Veelgestelde vragen (FAQ)

• Q: Foutmelding “pagina niet gevonden” op servbay-cakephp-test.local?
  • A: Controleer of de ‘Document Root’ exact verwijst naar /Applications/ServBay/www/servbay-cakephp-app/webroot.
  • Check dat de webserver (Caddy/Nginx) werkt in ServBay.
  • Controleer het hosts-bestand: staat servbay-cakephp-test.local op 127.0.0.1 (meestal automatisch door ServBay)?
  • Controleer het .htaccess-bestand en webserverinstellingen (in webroot/.htaccess), meestal standaard goed.
• Q: Databaseverbinding mislukt?
  • A: Controleer of MySQL/PostgreSQL actief is in ServBay.
  • Check de settings in config/app_local.php (host, poort, gebruikersnaam, wachtwoord, database); komen ze overeen met de ServBay-services?
  • Zorg dat de database servbay_cakephp_app is aangemaakt.
• Q: Composer-commando (bin/cake) werkt niet?
  • A: Zorg dat je in de juiste directory bent (/Applications/ServBay/www/servbay-cakephp-app).
  • Controleer of PHP en Composer actief zijn in ServBay.
  • Kijk of het terminal-pad php bevat (ServBay voegt PHP normaal toe aan PATH). Eventueel gebruik je de geïntegreerde terminal in ServBay, of stel zelf je PATH in.

Conclusie

Dankzij ServBay zet je razendsnel een lokale ontwikkelomgeving op voor CakePHP-projecten. De vooraf geïntegreerde PHP-, Composer-, webserver- en database-services maken configuratie eenvoudig. In dit artikel heb je geleerd hoe je een project initialiseert, configureert, een webserver koppelt, en relationele databases en caching integreert. Zo kun jij je als ontwikkelaar focussen op het schrijven van code, in plaats van het oplossen van installatieproblemen. Profiteer van het gebruiksgemak van ServBay en start vandaag jouw CakePHP-project!