Creare e Avviare un Progetto FuelPHP nell’Ambiente di Sviluppo Locale ServBay

Cos’è FuelPHP?

FuelPHP è un framework PHP flessibile e modulare, progettato per costruire applicazioni web moderne. Segue il pattern architetturale HMVC (Hierarchical Model-View-Controller), offrendo numerose funzionalità e strumenti pensati per aiutare gli sviluppatori a creare rapidamente applicazioni web robuste ed efficienti. Grazie alla sua straordinaria flessibilità, alle alte prestazioni e alla facilità di estensione, FuelPHP è una scelta popolare tra molti sviluppatori PHP.

Caratteristiche Principali e Vantaggi di FuelPHP

Architettura HMVC: Supporta un modello di sviluppo MVC gerarchico, che favorisce l’organizzazione, il riutilizzo e la modularità del codice; ideale per progetti di grandi dimensioni o complessi.
Alte Prestazioni: FuelPHP nasce con grande attenzione all’ottimizzazione delle prestazioni, essendo noto per la sua velocità ed efficienza nell’utilizzo delle risorse, riuscendo a gestire anche carichi di lavoro elevati.
Facile da Estendere: Il framework offre un potente sistema di estensioni, consentendo di integrare facilmente librerie di terze parti o aggiungere funzionalità personalizzate per rispondere a esigenze specifiche.
Sicurezza Avanzata: Include molteplici funzionalità di sicurezza nativamente, tra cui la validazione automatica degli input, il filtraggio dell’output (contro XSS), la protezione CSRF, la prevenzione SQL injection e molto altro, aiutando a costruire applicazioni più sicure.
Forte Supporto della Community: FuelPHP vanta una community di sviluppatori attiva, che offre supporto tempestivo e numerose risorse di terze parti.

Queste caratteristiche permettono agli sviluppatori di costruire rapidamente applicazioni web performanti, sicure e facili da mantenere, adatte sia a progetti di piccole dimensioni che a soluzioni enterprise su larga scala.

Configurare un Ambiente di Sviluppo FuelPHP con ServBay

ServBay è un ambiente di sviluppo web locale progettato per gli sviluppatori e pre-installa servizi e strumenti come PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis e molto altro. Con ServBay puoi predisporre facilmente tutto il necessario per i tuoi progetti FuelPHP, senza dover installare o configurare manualmente le varie dipendenze.

Questa guida illustra in dettaglio come utilizzare PHP, il server web (Caddy), i servizi di database e cache offerti da ServBay per creare e avviare un progetto FuelPHP. Useremo la funzione Siti Web di ServBay per configurare il server virtuale e semplificare l’accesso e il testing del progetto.

Prerequisiti

Prima di iniziare, assicurati che siano rispettate le seguenti condizioni:

ServBay è installato e funzionante su macOS.
Il supporto a PHP in ServBay è abilitato (impostazione predefinita).
Il database che desideri utilizzare (ad es. MySQL) e i servizi di cache (es. Redis, Memcached) sono avviati e operativi in ServBay.
Composer è già incluso in ServBay, non serve alcuna installazione aggiuntiva.

Creazione di un Progetto FuelPHP

Percorso consigliato per i progetti

ServBay consiglia agli sviluppatori di archiviare tutti i siti nel percorso /Applications/ServBay/www, facilitando così la gestione e la configurazione. Questa guida userà proprio questa directory come esempio.

Accedi alla directory root dei siti
Apri il Terminale e spostati nella cartella dove verranno salvati i progetti:
bash
```
cd /Applications/ServBay/www
```
1
Crea la directory del progetto
Crea una nuova cartella per il progetto FuelPHP ed entra al suo interno:
bash
```
mkdir servbay-fuelphp-app
cd servbay-fuelphp-app
```
1
2
Crea il progetto FuelPHP con Composer
All’interno della directory del progetto, utilizza Composer per installare FuelPHP. Il punto . indica la cartella corrente:
bash
```
composer create-project fuel/fuel .
```
1
Composer scaricherà automaticamente FuelPHP e tutte le dipendenze all’interno della cartella servbay-fuelphp-app.

Configurazione del Server Web (tramite Funzione Siti Web di ServBay)

Per accedere al progetto FuelPHP tramite browser, è necessario configurare un host virtuale tramite la funzione Siti Web di ServBay.

Apri l’interfaccia principale di ServBay.
Fai clic sulla voce Siti Web nella barra laterale.
Premi il pulsante Aggiungi sito in alto a destra.
Compila le seguenti informazioni nella finestra di configurazione:
- Nome: Dai un nome significativo al sito, ad esempio My First FuelPHP Dev Site.
- Dominio: Imposta un dominio di sviluppo locale, come servbay-fuelphp-test.local. ServBay lo collegherà automaticamente in locale.
- Tipo di sito: Scegli PHP.
- Versione PHP: Seleziona la versione desiderata, ad esempio 8.3.
- Directory Sito Web: Indica la directory di ingresso del progetto. Per FuelPHP il file di ingresso è public/index.php, quindi imposta la root sul sottocartella public del progetto: /Applications/ServBay/www/servbay-fuelphp-app/public.
Fai clic su Aggiungi per salvare la configurazione.

ServBay aggiornerà automaticamente la configurazione di Caddy e ricaricherà i servizi affinché il nuovo dominio sia disponibile.

Per istruzioni dettagliate sull’aggiunta di un sito, consulta la documentazione ServBay alla pagina Aggiungi il primo sito.

Configurare i Servizi del Progetto FuelPHP

Un progetto FuelPHP necessita generalmente della configurazione per database, cache e altri servizi.

Configurazione del Database

La configurazione del database di FuelPHP si trova in fuel/app/config/development/db.php. Modifica questo file con i dati di accesso del database. Nell’ipotesi che tu voglia utilizzare il MySQL di default di ServBay:

php

<?php
/**
 * Impostazioni del database di sviluppo. Si uniscono alle impostazioni globali.
 */
return [
    'default' => [
        'connection' => [
            'dsn'      => 'mysql:host=localhost;dbname=fuel_dev', // Assicurati che il database fuel_dev esista
            'username' => 'root', // Utente MySQL predefinito di ServBay
            'password' => 'root', // Password di default di MySQL su ServBay (solo per sviluppo locale!)
        ],
        'identifier' => '`', // Per MySQL servono gli apici inversi
    ],
];

Nota:

Ricordati di creare manualmente un database chiamato fuel_dev tramite gli strumenti di gestione di ServBay (phpMyAdmin, Adminer, ecc). L’utente MySQL predefinito root con password root è pensato solo per lo sviluppo locale.
'identifier' => ''` è necessario per MySQL per assicurare che i nomi di tabelle e campi siano correttamente referenziati.

Configurazione della cache (Memcached e Redis)

FuelPHP supporta diversi driver cache. Puoi configurare le connessioni in fuel/app/config/cache.php. Assicurati che i servizi Memcached e/o Redis siano attivi in ServBay.

Configurazione Memcached (fuel/app/config/cache.php):

Per usare Memcached come driver principale:

php

<?php
return [
    'driver' => 'memcached', // Imposta memcached come driver predefinito
    'memcached' => [
        'cache_id' => 'fuel', // ID cache
        'servers' => [
             'default' => [
                'host'   => '127.0.0.1', // Indirizzo standard di Memcached
                'port'   => 11211,      // Porta standard di Memcached
                'weight' => 100,
            ],
        ],
        'compression' => false, // Abilitare la compressione?
    ],
    // ... Altre configurazioni per cache driver
];

Normalmente il PHP incluso in ServBay ha già il modulo Memcached abilitato.

Configurazione Redis (fuel/app/config/redis.php):

Per utilizzare Redis, configura il file dedicato con i parametri di connessione:

php

<?php
return [
    'default' => [
        'hostname' => '127.0.0.1', // Indirizzo standard Redis
        'port'     => 6379,      // Porta standard Redis
        'database' => 0,         // Indice del database
    ],
    // Puoi configurare più connessioni Redis se servono
];

Normalmente il PHP incluso in ServBay include il modulo Redis.

Esempi di Database e Servizi di Cache

Per mostrare come FuelPHP interagisce con database e servizi di cache, ecco alcuni esempi pratici.

Preparare una Tabella Database (usando le Migrations di FuelPHP)

FuelPHP offre lo strumento Oil per gestire le migration del database, un sistema di versionamento della struttura dati.

Crea un file di migration
Dal root del progetto (servbay-fuelphp-app), usa Oil per generare una migration che creerà la tabella users:
bash
```
php oil generate migration create_users_table
```
1
Verrà così creato un file nella directory fuel/app/migrations, con un nome che include data e ora.

Modifica il file di migration

Apri il file creato (fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php), edita il metodo up() per definire la tabella e il metodo down() per eliminarla se necessario:

php

<?php
namespace Fuel\Migrations;

use Fuel\Core\DBUtil;

class Create_users_table
{
    public function up()
    {
        // Crea la tabella users
        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'); // Chiave primaria, indicizzazione, engine e charset
    }

    public function down()
    {
        // Elimina la tabella users (rollback)
        DBUtil::drop_table('users');
    }
}

Esegui le migration
Dal root del progetto, avvia la migration per creare la tabella:
bash
```
php oil refine migrate
```
1
Se tutto va a buon fine, la tabella users sarà presente in fuel_dev.

Esempio di Codice Controller

Modifica il file fuel/app/classes/controller/welcome.php, aggiungendo alcuni metodi per mostrare l’uso di database e cache:

php

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

class Controller_Welcome extends Controller
{
    // Action di default della homepage
    public function action_index()
    {
        return Response::forge('Hello ServBay!');
    }

    // Esempio Action Memcached
    public function action_memcached()
    {
        // Prova a recuperare i dati dalla cache
        $value = Cache::get('servbay_memcached_key');

        if ($value === false) {
            // Se non c’è in cache, imposta il dato
            $value = 'Hello Memcached from ServBay!';
            Cache::set('servbay_memcached_key', $value, 60); // Cache per 60 secondi
            $value .= ' (from cache)';
        } else {
            $value .= ' (cached)';
        }

        return Response::forge($value);
    }

    // Esempio Action Redis
    public function action_redis()
    {
        // Ottieni istanza Redis (connessione predefinita)
        $redis = \Redis_Db::instance(); // In FuelPHP 1.x si usa Redis_Db::instance()
        // Se ci sono più connessioni si può usare \Redis_Db::instance('nome_connessione')

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

        // Recupera dati da Redis
        $value = $redis->get('servbay_redis_key');

        return Response::forge($value);
    }

    // Esempio di inserimento tramite MySQL
    public function action_mysql_add()
    {
        try {
            // Inserisce un record nella tabella users
            $result = DB::insert('users')->set([
                'name' => 'ServBay Demo User ' . time(), // Nome univoco con timestamp
                'email' => 'demo_user_' . time() . '@servbay.test',
            ])->execute(); // execute() restituisce un array con il nuovo ID

            return Response::forge('User added with ID: ' . $result[0]);
        } catch (\Database_Exception $e) {
            // Gestione errori di database, ad es. email duplicata
            return Response::forge('Error adding user: ' . $e->getMessage(), 500);
        }
    }

    // Esempio di lettura dati MySQL
    public function action_mysql()
    {
        // Recupera tutti i record dalla tabella users
        $users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();

        // Restituisce la lista utenti in formato JSON
        return Response::forge(json_encode($users, JSON_PRETTY_PRINT));
    }
}

Nota:

Si importano le facciate DB e Redis (use Fuel\Core\DB;, use Fuel\Core\Redis;) per un uso diretto.
I nomi delle chiavi Memcached e Redis sono prefissati con servbay_ per evitare conflitti.
L’esempio di inserimento MySQL usa un timestamp per unicità e gestisce eventuali errori con un output più chiaro.
In FuelPHP 1.x per Redis si usa \Redis_Db::instance().

Configura le Route

Per accedere tramite URL alle nuove action del controller, modifica fuel/app/config/routes.php aggiungendo le seguenti route:

php

<?php
return array(
    '_root_'  => 'welcome/index',  // Homepage reindirizza a welcome/index
    '_404_'   => 'welcome/404',    // Pagina di errore 404

    // Route per le nuove action di esempio
    'memcached'   => 'welcome/memcached',
    'redis'       => 'welcome/redis',
    'mysql_add'   => 'welcome/mysql_add',
    'mysql'       => 'welcome/mysql',

    // ... altre route
);

Accesso e Test del Sito

A questo punto puoi testare il progetto e i servizi visitando nel browser il dominio configurato in ServBay, ad esempio https://servbay-fuelphp-test.local.

Homepage: https://servbay-fuelphp-test.local
- Risultato atteso: Hello ServBay!
Test Memcached: https://servbay-fuelphp-test.local/memcached
- Alla prima visita: Hello Memcached from ServBay! (from cache) (se la cache funziona)
- Visite successive: Hello Memcached from ServBay! (cached) (se la cache è ancora valida)
Test Redis: https://servbay-fuelphp-test.local/redis
- Risposta attesa: Hello Redis from ServBay! (se Redis è attivo e configurato)
Aggiunta utente in MySQL: https://servbay-fuelphp-test.local/mysql_add
- Risposta attesa: User added with ID: [ID appena inserito] (se il database e la tabella esistono)
Lettura utenti da MySQL: https://servbay-fuelphp-test.local/mysql
- Risposta attesa: un array JSON con tutti i record della tabella users (se il database è configurato con dati)

Nota su HTTPS: ServBay configura automaticamente i certificati SSL per i siti locali e li firma con la propria User CA o Public CA. Se il browser segnala il certificato come non attendibile, assicurati di aver aggiunto la CA di ServBay tra i certificati fidati del sistema.

Considerazioni Importanti

Assicurati che dalla schermata principale di ServBay tutte le componenti necessarie — versione PHP scelta, Caddy (o Nginx/Apache), MySQL, Redis, Memcached — siano in esecuzione.
Ricordati di creare manualmente il database fuel_dev tramite gli strumenti di amministrazione di ServBay (o indicane uno esistente in db.php). Lo strumento di migration di FuelPHP (oil refine migrate) crea le tabelle ma non i database.
Il file di ingresso pubblico di FuelPHP è public/index.php: nella configurazione del Sito Web su ServBay la directory root deve quindi puntare al sottocartella public del progetto.

Conclusioni

Con ServBay puoi configurare in modo estremamente rapido e semplice un ambiente di sviluppo locale completo per i tuoi progetti FuelPHP su macOS. Questa guida ti ha mostrato come creare un progetto FuelPHP, configurare la funzione Siti Web di ServBay, collegare i servizi di database e cache e verificare il funzionamento tramite del codice di esempio. Grazie ai servizi pre-integrati e alle procedure semplificate offerte da ServBay, la tua produttività nello sviluppo sarà nettamente superiore.

Speriamo che questa guida ti aiuti a iniziare al meglio il tuo viaggio di sviluppo con FuelPHP su ServBay!

Creare e Avviare un Progetto FuelPHP nell’Ambiente di Sviluppo Locale ServBay ​

Cos’è FuelPHP? ​

Caratteristiche Principali e Vantaggi di FuelPHP ​

Configurare un Ambiente di Sviluppo FuelPHP con ServBay ​

Prerequisiti ​

Creazione di un Progetto FuelPHP ​

Configurazione del Server Web (tramite Funzione Siti Web di ServBay) ​

Configurare i Servizi del Progetto FuelPHP ​

Configurazione del Database ​

Configurazione della cache (Memcached e Redis) ​

Esempi di Database e Servizi di Cache ​

Preparare una Tabella Database (usando le Migrations di FuelPHP) ​

Esempio di Codice Controller ​

Configura le Route ​

Accesso e Test del Sito ​

Considerazioni Importanti ​

Conclusioni ​