Anlegen und Ausführen eines FuelPHP-Projekts in der lokalen ServBay-Entwicklungsumgebung

Was ist FuelPHP?

FuelPHP ist ein flexibles, modular aufgebautes PHP-Framework, das speziell für die Entwicklung moderner Webanwendungen entworfen wurde. Es basiert auf dem Hierarchischen Modell-View-Controller-Muster (HMVC – Hierarchical Model-View-Controller) und stellt eine Vielzahl leistungsfähiger Funktionen und Werkzeuge bereit, um Entwicklern zu helfen, schnell und effizient hochwertige Webprojekte umzusetzen. Dank seiner außerordentlichen Flexibilität, starken Performance und Erweiterbarkeit zählt FuelPHP zu den bevorzugten Frameworks vieler PHP-Entwicklerinnen und -Entwickler.

Hauptmerkmale und Vorteile von FuelPHP

HMVC-Architektur: Unterstützung des hierarchischen MVC-Modells zur besseren Organisation, Wiederverwendung und Modularisierung von Code, besonders geeignet für große oder komplexe Projekte.
Hohe Performance: FuelPHP ist auf Performance-Optimierung ausgelegt und bekannt für Effizienz und sparsamen Ressourceneinsatz; es kann auch bei hoher gleichzeitiger Last zuverlässig arbeiten.
Einfache Erweiterbarkeit: Mit starken Erweiterungsmechanismen kann FuelPHP problemlos um Drittanbieter-Bibliotheken oder eigene Funktionen ergänzt werden, damit Ihr Projekt allen Anforderungen gerecht wird.
Sicherheit: Standardmäßig werden Sicherheitsfeatures wie automatisierte Eingabevalidierung, Ausgabefilter (XSS-Schutz), CSRF-Abwehr, sowie Schutz vor SQL-Injection geboten, um sicherere Anwendungen zu ermöglichen.
Starke Community-Unterstützung: FuelPHP verfügt über eine lebendige Entwickler-Community, bei der bei Fragen schnell Hilfe und viele Ressourcen zu finden sind.

Mit diesen Eigenschaften unterstützt FuelPHP Entwickler bei der schnellen Erstellung leistungsstarker, sicherer und wartbarer Web-Apps, von kleinen Websites bis zu großen Enterprise-Lösungen.

Mit ServBay eine FuelPHP-Entwicklungsumgebung aufbauen

ServBay ist eine lokale Webentwicklungsumgebung, die speziell für Entwickler konzipiert ist und PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis und zahlreiche weitere Tools bereits vorinstalliert bietet. Mit ServBay lässt sich die Infrastruktur für FuelPHP-Projekte ganz einfach einrichten, ohne dass manuelle Installationen und aufwändiges Konfigurieren notwendig wäre.

In diesem Leitfaden erfahren Sie, wie Sie mit der von ServBay bereitgestellten PHP-Umgebung, dem Caddy-Webserver sowie Datenbank- und Cache-Diensten ein FuelPHP-Projekt erstellen und ausführen. Wir nutzen dabei die Website-Funktion von ServBay, um den Webserver zu konfigurieren und so einen schnellen Zugriff und einfaches Testen des Projekts zu ermöglichen.

Voraussetzungen

Bitte stellen Sie vor Beginn sicher, dass folgende Bedingungen erfüllt sind:

Sie haben ServBay auf macOS erfolgreich installiert und gestartet.
Die PHP-Umgebung in ServBay ist aktiviert (dies ist standardmäßig der Fall).
Die von Ihnen gewünschten Datenbankdienste (z.B. MySQL) und Cache-Dienste (z.B. Redis, Memcached) sind in ServBay gestartet und laufen fehlerfrei.
Composer wird von ServBay bereits bereitgestellt, eine zusätzliche Installation ist nicht nötig.

Ein FuelPHP-Projekt erstellen

Empfohlener Speicherort für das Projekt

ServBay empfiehlt, Webprojekte einheitlich im Verzeichnis /Applications/ServBay/www abzulegen. Dies vereinfacht Verwaltung und Konfiguration mit ServBay. Auch im Folgenden nutzen wir diesen Pfad als Beispiel.

Zum Web-Root wechseln
Öffnen Sie Ihr Terminal und wechseln Sie ins empfohlene ServBay-Webverzeichnis:
bash
```
cd /Applications/ServBay/www
```
1
Projektverzeichnis anlegen
Erstellen Sie einen neuen Ordner für Ihr FuelPHP-Projekt und wechseln Sie hinein:
bash
```
mkdir servbay-fuelphp-app
cd servbay-fuelphp-app
```
1
2
Projekt mit Composer erstellen
Im Projektordner laden und initialisieren Sie das FuelPHP-Framework per Composer. Das . steht für den aktuellen Ordner:
bash
```
composer create-project fuel/fuel .
```
1
Composer lädt automatisch FuelPHP und alle Abhängigkeiten in das Verzeichnis servbay-fuelphp-app.

Webserver konfigurieren (mit der ServBay-Website-Funktion)

Damit Ihr FuelPHP-Projekt über den Browser erreichbar ist, richten Sie mit der Website-Funktion von ServBay eine virtuelle Host-Konfiguration ein.

Öffnen Sie die Hauptoberfläche von ServBay.
Klicken Sie in der Seitenleiste auf Websites.
Klicken Sie oben rechts auf Website hinzufügen.
Füllen Sie im folgenden Konfigurationsfenster die Felder wie folgt aus:
- Name: Vergeben Sie einen leicht wiederzuerkennenden Namen, z.B. My First FuelPHP Dev Site.
- Domain: Setzen Sie eine lokale Domain wie servbay-fuelphp-test.local. ServBay kümmert sich um die Zuordnung zur lokalen Adresse.
- Websitetyp: Wählen Sie PHP.
- PHP-Version: Wählen Sie die gewünschte PHP-Version, z.B. 8.3.
- Web-Root-Verzeichnis: Geben Sie das Einstiegverzeichnis Ihres FuelPHP-Projekts an. Das öffentliche Entrypoint liegt unter public/index.php, also setzen Sie das Verzeichnis auf das public-Unterverzeichnis Ihres Projekts: /Applications/ServBay/www/servbay-fuelphp-app/public.
Mit einem Klick auf Hinzufügen speichern Sie die Konfiguration.

ServBay erstellt und lädt die Caddy-Konfiguration automatisch neu, damit die Domain sofort funktioniert.

Detaillierte Informationen zum Anlegen von Websites finden Sie in der ServBay-Dokumentation unter Erste Website hinzufügen.

Verbindungseinstellungen für Dienste im FuelPHP-Projekt

In der Regel konfigurieren Sie im FuelPHP-Projekt Ihre Verbindungen zu Datenbank, Caching und anderen Services individuell.

Datenbank-Konfiguration

Die Einstellungen zur Datenbank finden Sie in der Datei fuel/app/config/development/db.php. Bearbeiten Sie die Datei und tragen Sie Ihre Zugangsdaten ein. Für die Standard-MySQL-Instanz von ServBay zum Beispiel:

php

<?php
/**
 * Die Entwicklungsdatenbank-Einstellungen. Diese werden mit den globalen Einstellungen gemerged.
 */
return [
    'default' => [
        'connection' => [
            'dsn'      => 'mysql:host=localhost;dbname=fuel_dev', // Stellen Sie sicher, dass die fuel_dev-Datenbank existiert
            'username' => 'root', // Standardnutzer bei ServBay MySQL
            'password' => 'root', // Standardpasswort für ServBay MySQL (nur für lokale Entwicklung!)
        ],
        'identifier' => '`', // MySQL verwendet das Backtick (`)
    ],
];

Hinweis:

Sie müssen die Datenbank fuel_dev per Datenbankverwaltungstool (z.B. phpMyAdmin oder Adminer in ServBay) manuell anlegen. Als Standardnutzer ist root mit Passwort root vorbelegt – ausschließlich für die lokale Entwicklung empfohlen.
'identifier' => ''` wird für MySQL benötigt, damit Tabellen- und Feldnamen korrekt eingefasst werden.

Cache-Konfiguration (Memcached und Redis)

FuelPHP unterstützt verschiedene Caching-Backends. Passen Sie in der Datei fuel/app/config/cache.php die Einstellungen und Treiber an. Achten Sie darauf, dass Memcached und/oder Redis in ServBay gestartet sind.

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

Soll Memcached als Standardcache eingesetzt werden:

php

<?php
return [
    'driver' => 'memcached', // Standardtreiber auf memcached setzen
    'memcached' => [
        'cache_id' => 'fuel', // Cache-ID
        'servers' => [
             'default' => [
                'host'   => '127.0.0.1', // Standard-Adresse von Memcached
                'port'   => 11211,      // Standardport von Memcached
                'weight' => 100,
            ],
        ],
        'compression' => false, // Kompression aktiviert/deaktiviert
    ],
    // ... weitere Cache-Treiber
];

Die von ServBay bereitgestellten PHP-Versionen enthalten in der Regel Memcached standardmäßig als Erweiterung.

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

Beim Einsatz von Redis passen Sie die Redis-Konfiguration entsprechend an. Diese liegt meist in einer eigenen Datei redis.php:

php

<?php
return [
    'default' => [
        'hostname' => '127.0.0.1', // Standard-Adresse von Redis
        'port'     => 6379,      // Standardport von Redis
        'database' => 0,         // Redis-Datenbank-Index
    ],
    // Sie können beliebig viele Verbindungen anlegen
];

Auch für Redis ist die benötigte PHP-Erweiterung in ServBay in der Regel schon vorinstalliert.

Beispiele: Datenbank- und Cache-Dienste in Aktion

Zur Demonstration, wie FuelPHP mit Datenbanken und Cache spricht, zeigen wir Ihnen Beispielcode.

Anlegen einer Datenbank-Tabelle (mit FuelPHP-Migrations)

Über das Oil-Tool von FuelPHP lassen sich Migrationen, also Datenbank-Strukturänderungen, komfortabel verwalten.

Migrationsdatei erzeugen
Erstellen Sie eine neue Migration, um z.B. eine Tabelle users zu definieren:
bash
```
php oil generate migration create_users_table
```
1
Diese Datei erhalten Sie im Ordner fuel/app/migrations – im Dateinamen ist ein Zeitstempel enthalten.

Migrationsdatei bearbeiten

Öffnen Sie die neue Datei (fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php). Ergänzen Sie die Methode up() um die Tabellendefinition, und legen Sie in down() die Rückruffunktion an:

php

<?php
namespace Fuel\Migrations;

use Fuel\Core\DBUtil;

class Create_users_table
{
    public function up()
    {
        // Tabelle users anlegen
        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'); // Hauptschlüssel, Index, Engine und Zeichensatz setzen
    }

    public function down()
    {
        // Tabelle users löschen (Rollback)
        DBUtil::drop_table('users');
    }
}

Migration ausführen
Führen Sie folgendes im Projektverzeichnis (servbay-fuelphp-app) aus, um die Migration zu starten:
bash
```
php oil refine migrate
```
1
Im Erfolgsfall wird die Tabelle users in der Datenbank fuel_dev erstellt.

Beispiel-Controller erweitern

Öffnen Sie die Datei fuel/app/classes/controller/welcome.php und ergänzen Sie Methoden, um Datenbank- und Cache-Operationen zu demonstrieren:

php

<?php
use Fuel\Core\Controller;
use Fuel\Core\Response;
use Fuel\Core\Cache;
use Fuel\Core\DB; // Importiert das DB-Facade
use Fuel\Core\Redis; // Importiert das Redis-Facade

class Controller_Welcome extends Controller
{
    // Standard-Home-Action
    public function action_index()
    {
        return Response::forge('Hello ServBay!');
    }

    // Memcached-Beispiel
    public function action_memcached()
    {
        // Versucht, einen Wert aus dem Cache zu holen
        $value = Cache::get('servbay_memcached_key');

        if ($value === false) {
            // Falls nicht im Cache, Wert setzen
            $value = 'Hello Memcached from ServBay!';
            Cache::set('servbay_memcached_key', $value, 60); // 60 Sekunden cachen
            $value .= ' (from cache)';
        } else {
            $value .= ' (cached)';
        }

        return Response::forge($value);
    }

    // Redis-Beispiel
    public function action_redis()
    {
        // Redis-Instanz (Standardverbindung) abrufen
        $redis = \Redis_Db::instance(); // In FuelPHP 1.x: Redis_Db::instance()
        // Alternativ ggf. mit mehreren Verbindungen: \Redis_Db::instance('connection_name')

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

        // Wert aus Redis lesen
        $value = $redis->get('servbay_redis_key');

        return Response::forge($value);
    }

    // MySQL-Write-Beispiel
    public function action_mysql_add()
    {
        try {
            // Neuen Datensatz in Tabelle users speichern
            $result = DB::insert('users')->set([
                'name' => 'ServBay Demo User ' . time(), // Zeitstempel für Einzigartigkeit
                'email' => 'demo_user_' . time() . '@servbay.test',
            ])->execute(); // execute() gibt das neue Insert-ID-Array zurück

            return Response::forge('User added with ID: ' . $result[0]);
        } catch (\Database_Exception $e) {
            // Fehler z.B. bei doppelter Email abfangen
            return Response::forge('Error adding user: ' . $e->getMessage(), 500);
        }
    }

    // MySQL-Lese-Beispiel
    public function action_mysql()
    {
        // Alle user-Datensätze abfragen
        $users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();

        // Ergebnis als JSON zurückgeben
        return Response::forge(json_encode($users, JSON_PRETTY_PRINT));
    }
}

Hinweis:

Die DB- und Redis-Facades (use Fuel\Core\DB;, use Fuel\Core\Redis;) werden zu Beginn importiert.
Für Memcached und Redis werden Präfixe wie servbay_ genutzt, um Schlüsselkonflikte zu vermeiden.
Beim MySQL-Write-Beispiel wird ein Zeitstempel für die Felder generiert; Fehler werden abgefangen und per Fehlerausgabe zurückgegeben.
In FuelPHP 1.x wird auf Redis mit \Redis_Db::instance() zugegriffen.

Routing einstellen

Damit die neu hinzugefügten Methoden per URL erreichbar sind, ergänzen oder passen Sie in fuel/app/config/routes.php die Routen entsprechend an:

php

<?php
return array(
    '_root_'  => 'welcome/index',  // Standardroute zeigt auf Welcome-Controller, index-Action
    '_404_'   => 'welcome/404',    // 404-Seiten-Route

    // Routen für beispielhafte Actions
    'memcached'   => 'welcome/memcached',
    'redis'       => 'welcome/redis',
    'mysql_add'   => 'welcome/mysql_add',
    'mysql'       => 'welcome/mysql',

    // ... weitere Routen
);

Website aufrufen und testen

Nun können Sie Ihr FuelPHP-Projekt und alle konfigurierten Services bequem testen, indem Sie die in ServBay registrierte Domain https://servbay-fuelphp-test.local im Browser aufrufen.

Homepage aufrufen: https://servbay-fuelphp-test.local
- Erwartete Ausgabe: Hello ServBay!
Memcached testen: https://servbay-fuelphp-test.local/memcached
- Erste Abfrage: Hello Memcached from ServBay! (from cache) (sofern der Cachingdienst läuft)
- Bei erneutem Aufruf: Hello Memcached from ServBay! (cached)
Redis testen: https://servbay-fuelphp-test.local/redis
- Erwartete Ausgabe: Hello Redis from ServBay! (wenn Redis läuft)
User zu MySQL hinzufügen: https://servbay-fuelphp-test.local/mysql_add
- Erwartete Ausgabe: User added with ID: [neu vergebene ID]
User-Liste auslesen: https://servbay-fuelphp-test.local/mysql
- Erwartete Ausgabe: Ein JSON-Array mit allen Datensätzen aus der Tabelle users

Hinweis zu HTTPS: ServBay stellt standardmäßig für lokale Websites SSL-Zertifikate bereit – entweder durch das ServBay User CA oder Public CA. Falls Ihr Browser eine Warnung über ein nicht vertrauenswürdiges Zertifikat anzeigt, stellen Sie sicher, dass Sie das ServBay-CA-Zertifikat in Ihrem System als vertrauenswürdig hinzugefügt haben.

Hinweise & Tipps

Kontrollieren Sie im ServBay-Hauptbildschirm, dass alle von Ihnen benötigten Dienste (PHP-Version, Caddy/Nginx/Apache, MySQL, Redis, Memcached etc.) laufen.
Überprüfen Sie, dass Sie die Datenbank fuel_dev in Ihrem Datenbank-Tool angelegt haben (oder in db.php eine andere existierende Datenbank konfiguriert haben). Das Migrations-Tool von FuelPHP (oil refine migrate) erzeugt Tabellen in der Datenbank, erstellt diese jedoch nicht selbst.
Das zentrale Entrypoint von FuelPHP ist die Datei public/index.php. Daher muss in der ServBay-Website-Konfiguration das Web-Root-Verzeichnis zwingend auf das public-Unterverzeichnis Ihres Projekts zeigen.

Fazit

Mit ServBay haben Sie die Möglichkeit, auf macOS im Handumdrehen eine komplette FuelPHP-Entwicklungsumgebung mit minimalem Konfigurationsaufwand einzurichten. In dieser Anleitung wurden die Erstellung eines FuelPHP-Projekts, die Konfiguration der Website-Funktion von ServBay, die Integration von Datenbank- und Cache-Diensten sowie die Überprüfung über Beispielcode Schritt für Schritt erläutert. Dank der vorkonfigurierten Services und der einfachen Handhabung in ServBay können Sie Ihre Entwicklungszeit und -effizienz erheblich steigern.

Wir hoffen, dieser Guide unterstützt Sie optimal bei Ihrem Start in die FuelPHP-Entwicklung mit ServBay!

Anlegen und Ausführen eines FuelPHP-Projekts in der lokalen ServBay-Entwicklungsumgebung ​

Was ist FuelPHP? ​

Hauptmerkmale und Vorteile von FuelPHP ​

Mit ServBay eine FuelPHP-Entwicklungsumgebung aufbauen ​

Voraussetzungen ​

Ein FuelPHP-Projekt erstellen ​

Webserver konfigurieren (mit der ServBay-Website-Funktion) ​

Verbindungseinstellungen für Dienste im FuelPHP-Projekt ​

Datenbank-Konfiguration ​

Cache-Konfiguration (Memcached und Redis) ​

Beispiele: Datenbank- und Cache-Dienste in Aktion ​

Anlegen einer Datenbank-Tabelle (mit FuelPHP-Migrations) ​

Beispiel-Controller erweitern ​

Routing einstellen ​

Website aufrufen und testen ​

Hinweise & Tipps ​

Fazit ​