Een FuelPHP-project maken en uitvoeren in de ServBay lokale ontwikkelomgeving

Wat is FuelPHP?

FuelPHP is een flexibel en modulair PHP-framework, ontworpen voor het bouwen van moderne webapplicaties. Het volgt het gelaagde Model-View-Controller ontwerpprincipe (HMVC - Hierarchical Model-View-Controller) en biedt een scala aan krachtige functies en tools die ontwikkelaars helpen snel en efficiënt hoogwaardige webapplicaties te maken. Dankzij de uitstekende flexibiliteit, hoge prestaties en uitbreidbaarheid is FuelPHP een populaire keuze onder PHP-ontwikkelaars.

Belangrijkste kenmerken en voordelen van FuelPHP

• HMVC-architectuur: Ondersteunt het gelaagde MVC-ontwerppatroon, waardoor codeorganisatie, hergebruik en modulaire ontwikkeling eenvoudiger worden — ideaal voor grote of complexe projecten.
• Hoge prestaties: FuelPHP is geoptimaliseerd voor snelheid en efficiënt gebruik van bronnen en staat bekend om het effectief verwerken van grote aantallen verzoeken.
• Uitbreidbaarheid: Het framework bevat krachtige extensiemechanismen, zodat ontwikkelaars eenvoudig externe libraries kunnen integreren en maatwerkfunctionaliteit kunnen toevoegen voor specifieke projectbehoeften.
• Veiligheid: FuelPHP beschikt over ingebouwde beveiligingsmaatregelen zoals automatische inputvalidatie, outputfiltering (beschermt tegen XSS), CSRF-bescherming, SQL-injectiepreventie en meer — essentieel voor het ontwikkelen van veilige applicaties.
• Sterke community support: FuelPHP heeft een actieve ontwikkelaarscommunity, waar je snel hulp en veel externe bronnen kunt vinden.

Dankzij deze eigenschappen kunnen ontwikkelaars met FuelPHP efficient, veilig en onderhoudbaar webapplicaties bouwen, geschikt voor projecten van klein tot grootzakelijk niveau.

ServBay gebruiken voor een FuelPHP-ontwikkelomgeving

ServBay is een lokale webontwikkelomgeving, speciaal ontworpen voor ontwikkelaars, en wordt geleverd met vooraf geïnstalleerde diensten zoals PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis en meer. Met ServBay kun je moeiteloos de benodigde omgeving voor je FuelPHP-project instellen, zonder handmatig verschillende dependencies te hoeven installeren of configureren.

Deze handleiding laat zien hoe je ServBay gebruikt om een PHP-omgeving en webserver (Caddy), database en cache-diensten te configureren voor een FuelPHP-project. We maken gebruik van de website-functie van ServBay voor webserverconfiguratie, zodat je snel je project kunt testen en openen.

Voorwaarden

Voordat je begint, zorg ervoor dat je aan onderstaande voorwaarden voldoet:

• ServBay is succesvol geïnstalleerd en actief op macOS.
• De PHP-omgeving binnen ServBay is ingeschakeld (standaard ingeschakeld).
• De database-dienst (bijv. MySQL) en cache-diensten (zoals Redis, Memcached) die je wilt gebruiken, zijn gestart en werken correct.
• Composer is standaard meegeleverd in ServBay, aparte installatie is niet nodig.

Een FuelPHP-project aanmaken

Aanbevolen projectlocatie

ServBay raadt aan om webprojecten te plaatsen in de map /Applications/ServBay/www, wat het beheer en de configuratie in ServBay vergemakkelijkt. Dit pad wordt in deze handleiding als voorbeeld gebruikt.

1. Ga naar de webroot

   Open je terminal en ga naar de aanbevolen webroot-map van ServBay:

   cd /Applications/ServBay/www

2. Maak een projectmap aan

   Maak een nieuwe map voor je FuelPHP-project en ga hierin:

   mkdir servbay-fuelphp-app
   cd servbay-fuelphp-app

3. Maak een FuelPHP-project aan met Composer

   Gebruik Composer in je projectmap om het FuelPHP-framework te downloaden en te initialiseren. De . betekent dat het project in de huidige map wordt aangemaakt:

   composer create-project fuel/fuel .

   Composer downloadt automatisch het FuelPHP-framework en bijbehorende dependencies naar de map servbay-fuelphp-app.

De webserver configureren (ServBay Website-functie gebruiken)

Om je FuelPHP-project via een browser toegankelijk te maken, moet je met de website-functie van ServBay een virtual host instellen.

1. Open ServBay's hoofdinterface.
2. Klik op Website in het zijmenu.
3. Klik op de knop Website toevoegen rechtsboven.
4. Vul in het configuratievenster de volgende gegevens in:
   • Naam: Kies een herkenbare naam, bijvoorbeeld Mijn eerste FuelPHP ontwikkelsite.
   • Domein: Voer een lokaal ontwikkeldomein in, bijvoorbeeld servbay-fuelphp-test.local. ServBay wijst dit automatisch toe aan je lokale omgeving.
   • Website-type: Selecteer PHP.
   • PHP-versie: Kies de gewenste PHP-versie, bijvoorbeeld 8.3.
   • Webroot: Geef de rootdirectory van je FuelPHP-project op. Het publieke instappunt van FuelPHP is public/index.php, dus de webroot moet naar de public submap van het project wijzen: /Applications/ServBay/www/servbay-fuelphp-app/public.
5. Klik op Toevoegen om de configuratie op te slaan.

ServBay werkt direct de Caddy-configuratie bij en herstart de service, zodat het nieuwe domein actief is.

Voor een gedetailleerde uitleg over het toevoegen van websites kun je ServBay's documentatie raadplegen: Eerste website toevoegen.

Projectservices configureren in FuelPHP

Een FuelPHP-project vereist meestal dat je verbindingen instelt voor database, cache en andere services.

Databaseconfiguratie

FuelPHP's database-instellingen vind je in het bestand fuel/app/config/development/db.php. Bewerk dit bestand om de databasegegevens van jouw omgeving in te vullen. Als je ServBay's standaard MySQL-dienst gebruikt:

<?php
/**
 * Database-instellingen voor ontwikkeling. Deze worden toegevoegd aan de globale settings.
 */
return [
    'default' => [
        'connection' => [
            'dsn'      => 'mysql:host=localhost;dbname=fuel_dev', // Zorg dat de database fuel_dev bestaat
            'username' => 'root', // Standaard gebruiker ServBay MySQL
            'password' => 'root', // Standaard wachtwoord (alleen voor lokale ontwikkeling!)
        ],
        'identifier' => '`', // MySQL gebruikt backticks als identifier
    ],
];

Let op:

• Je moet handmatig een database met de naam fuel_dev aanmaken in ServBay's databasebeheer (zoals phpMyAdmin of Adminer). Standaard zijn gebruikersnaam en wachtwoord beide root — aanbevolen enkel voor lokale ontwikkeling.
• 'identifier' => ''` is noodzakelijk voor MySQL, zodat tabel- en veldnamen correct worden aangeduid.

Cacheconfiguratie (Memcached en Redis)

FuelPHP ondersteunt verschillende cache-drivers. Je configureert deze in fuel/app/config/cache.php. Zorg dat Memcached en/of Redis in ServBay zijn gestart.

Memcached-configuratie (fuel/app/config/cache.php):

Als Memcached je standaard cache is:

<?php
return [
    'driver' => 'memcached', // Stel memcached in als standaard driver
    'memcached' => [
        'cache_id' => 'fuel', // Cache-ID
        'servers' => [
             'default' => [
                'host'   => '127.0.0.1', // Standaard Memcached-adres
                'port'   => 11211,      // Standaard Memcached-poort
                'weight' => 100,
            ],
        ],
        'compression' => false, // Compressie aan/uit
    ],
    // ... overige cache drivers
];

De PHP-versies in ServBay zijn doorgaans standaard voorzien van de Memcached-extensie.

Redis-configuratie (fuel/app/config/redis.php):

Voor Redis stel je de connectiegegevens in dit aparte bestand in:

<?php
return [
    'default' => [
        'hostname' => '127.0.0.1', // Standaard Redis-adres
        'port'     => 6379,      // Standaard Redis-poort
        'database' => 0,         // Redis database-index
    ],
    // Je kunt meerdere Redis-verbindingen instellen
];

ServBay PHP-varianten bevatten normaliter de Redis-extensie.

Voorbeelden van database- en cacheservices

Om te demonstreren hoe FuelPHP met database en cache samenwerkt, voegen we wat voorbeeldcode toe.

Database-tabellen aanmaken (FuelPHP Migrations gebruiken)

FuelPHP biedt het tool Oil voor databasemigraties. Hiermee versieer je het database-schema.

1. Maak een migratiebestand aan

   Gebruik Oil in de projectroot (servbay-fuelphp-app) om een migratiebestand aan te maken voor de structuur van de tabel users:

   php oil generate migration create_users_table

   Dit maakt een nieuw migratiebestand aan in fuel/app/migrations, met een tijdsaanduiding in de bestandsnaam.

2. Bewerk het migratiebestand

   Open het aangemaakte bestand (fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php) en vul de up()-methode met de tabelstructuur; down() stelt een rollback in:

   <?php
   namespace Fuel\Migrations;
   
   use Fuel\Core\DBUtil;
   
   class Create_users_table
   {
       public function up()
       {
           // Maak de users-tabel aan
           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'); // Zet de primary key, indexing, engine en charset
       }
   
       public function down()
       {
           // Verwijder de users-tabel (Rollback)
           DBUtil::drop_table('users');
       }
   }

3. Voer de migratie uit

   Gebruik Oil in je projectmap om de migratie uit te voeren en de tabel te maken:

   php oil refine migrate

   Als alles gelukt is, is de users-tabel aangemaakt in de fuel_dev database.

Voorbeeld controllercode toevoegen

Bewerk fuel/app/classes/controller/welcome.php en voeg methodes toe om database- en cache-functionaliteit te demonstreren:

<?php
use Fuel\Core\Controller;
use Fuel\Core\Response;
use Fuel\Core\Cache;
use Fuel\Core\DB; // Importeer DB-facade
use Fuel\Core\Redis; // Importeer Redis-facade

class Controller_Welcome extends Controller
{
    // Standaard hoofdpagina
    public function action_index()
    {
        return Response::forge('Hello ServBay!');
    }

    // Memcached voorbeeld
    public function action_memcached()
    {
        // Haal data uit de cache
        $value = Cache::get('servbay_memcached_key');

        if ($value === false) {
            // Niet gevonden in cache, stel data in
            $value = 'Hello Memcached from ServBay!';
            Cache::set('servbay_memcached_key', $value, 60); // 60 seconden cache
            $value .= ' (from cache)';
        } else {
            $value .= ' (cached)';
        }

        return Response::forge($value);
    }

    // Redis voorbeeld
    public function action_redis()
    {
        // Krijg een Redis-instantie (standaardverbinding)
        $redis = \Redis_Db::instance(); // FuelPHP 1.x gebruikt deze
        // Of voor meerdere connecties: \Redis_Db::instance('connection_name')

        // Zet data in Redis
        $redis->set('servbay_redis_key', 'Hello Redis from ServBay!');

        // Haal data uit Redis
        $value = $redis->get('servbay_redis_key');

        return Response::forge($value);
    }

    // MySQL schrijfvoorbeeld
    public function action_mysql_add()
    {
        try {
            // Voeg een rij toe aan de users-tabel
            $result = DB::insert('users')->set([
                'name' => 'ServBay Demo User ' . time(), // Unieke naam op basis van timestamp
                'email' => 'demo_user_' . time() . '@servbay.test',
            ])->execute(); // execute() retourneert een array met het nieuwe ID

            return Response::forge('User added with ID: ' . $result[0]);
        } catch (\Database_Exception $e) {
            // Foutafhandeling, bijvoorbeeld dubbele email
            return Response::forge('Error adding user: ' . $e->getMessage(), 500);
        }
    }

    // MySQL leesvoorbeeld
    public function action_mysql()
    {
        // Selecteer alle rijen uit gebruikers-tabel
        $users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();

        // Geef een JSON-array terug van gebruikers
        return Response::forge(json_encode($users, JSON_PRETTY_PRINT));
    }
}

Let op:

• DB en Redis facades (use Fuel\Core\DB;, use Fuel\Core\Redis;) worden geïmporteerd om direct te kunnen gebruiken.
• Voor Memcached en Redis worden sleutels met de prefix servbay_ gebruikt om conflicten te voorkomen.
• MySQL schrijven bevat tijdstempels en eenvoudige foutafhandeling; de voorbeeldteksten zijn praktisch toepasselijk.
• In FuelPHP 1.x haal je de Redis-instantie op met \Redis_Db::instance().

Routing instellen

Om je aangepaste controller acties via URLs bereikbaar te maken, stel je routes in via fuel/app/config/routes.php. FuelPHP heeft standaard een route naar Controller_Welcome, maar voor memcached, redis, mysql_add en mysql moet je deze handmatig toevoegen.

Voeg in fuel/app/config/routes.php het volgende toe:

<?php
return array(
    '_root_'  => 'welcome/index',  // Standaard route naar de index-actie van welcome-controller
    '_404_'   => 'welcome/404',    // 404 errorpage route

    // Routes voor de toegevoegde voorbeelden
    'memcached'   => 'welcome/memcached',
    'redis'       => 'welcome/redis',
    'mysql_add'   => 'welcome/mysql_add',
    'mysql'       => 'welcome/mysql',

    // ... overige routes
);

De site bezoeken en testen

Nu kun je je FuelPHP-project bezoeken en de services testen onder het domein dat je in ServBay hebt ingesteld, bijvoorbeeld https://servbay-fuelphp-test.local.

• Standaardpagina: https://servbay-fuelphp-test.local
  • Verwachte output: Hello ServBay!
• Memcached testen: https://servbay-fuelphp-test.local/memcached
  • Eerste bezoek: Hello Memcached from ServBay! (from cache) (als cache werkt)
  • Herhaal: Hello Memcached from ServBay! (cached) (als cache werkt en nog niet verlopen is)
• Redis testen: https://servbay-fuelphp-test.local/redis
  • Output: Hello Redis from ServBay! (bij een werkende Redis-dienst)
• Gebruiker toevoegen aan MySQL: https://servbay-fuelphp-test.local/mysql_add
  • Output: User added with ID: [nieuw ID] (als MySQL werkt en database & tabel bestaan)
• Gebruikerslijst uitlezen uit MySQL: https://servbay-fuelphp-test.local/mysql
  • Output: Een JSON-array met alle records uit de users-tabel (als MySQL werkt en er data is)

Over HTTPS: ServBay genereert automatisch SSL-certificaten voor lokale sites die vertrouwd worden via ServBay User CA of ServBay Public CA. Geeft je browser een waarschuwing over het certificaat, dan moet je ServBay's CA-certificaat als vertrouwd instellen op je systeem.

Let op

• Controleer dat alle benodigde diensten (PHP-versie, Caddy/Nginx/Apache, MySQL, Redis, Memcached) actief zijn in ServBay's hoofdinterface.
• Zorg dat de database fuel_dev handmatig is aangemaakt in de databasebeheer-tool van ServBay (of werk in je db.php met een bestaande database). Migrations (oil refine migrate) maken tabellen aan in een bestaande database, maar maken de database zelf niet aan.
• Het publieke instappunt voor FuelPHP is public/index.php. Let dus op dat de website rootdirectory in ServBay bij de siteconfiguratie naar de public-map wijst.

Samenvatting

ServBay maakt het eenvoudig om op macOS een complete lokale ontwikkelomgeving voor je FuelPHP-project op te zetten. In deze handleiding heb je geleerd hoe je een FuelPHP-project aanmaakt, ServBay's website-functie configureert, de koppelingen met database- en cache-diensten instelt en deze functionaliteit test met voorbeeldcode. Dankzij de ingebouwde services en het eenvoudige configuratieproces van ServBay kun je snel efficiënt ontwikkelen.

We hopen dat deze gids je een vliegende start geeft met FuelPHP-ontwikkeling in ServBay!