Creare ed eseguire un progetto FuelPHP nell’ambiente locale ServBay

Cos'è FuelPHP?

FuelPHP è un framework PHP flessibile e modulare, progettato per sviluppare applicazioni web moderne. Segue il pattern HMVC (Hierarchical Model-View-Controller), offrendo una ricca dotazione di funzionalità e strumenti pensati per aiutare gli sviluppatori a creare applicazioni web di alta qualità in modo rapido ed efficiente. Grazie alla sua straordinaria flessibilità, alle ottime performance e alla facilità di estensione, FuelPHP è la scelta preferita di molti sviluppatori PHP.

Caratteristiche e vantaggi principali di FuelPHP

• Architettura HMVC: Supporta il pattern HMVC, che facilita l’organizzazione, il riutilizzo e la modularità del codice, ideale per progetti grandi e complessi.
• Prestazioni elevate: FuelPHP è ottimizzato per le performance, noto per la sua velocità ed efficienza nell’uso delle risorse, ed è capace di gestire richieste contemporanee in modo efficace.
• Facile da estendere: Il framework offre potenti meccanismi di estensione. È semplice integrare librerie di terze parti o aggiungere funzionalità personalizzate, adattandosi alle esigenze specifiche di ogni progetto.
• Sicurezza: FuelPHP integra molteplici funzioni di sicurezza come la validazione automatica degli input, il filtraggio degli output (contro XSS), la protezione CSRF, la prevenzione delle SQL injection, aiutando gli sviluppatori a realizzare applicazioni sicure.
• Forte supporto dalla community: Una community attiva di sviluppatori garantisce supporto rapido e molte risorse di terze parti.

Grazie a queste caratteristiche, FuelPHP permette di sviluppare applicazioni web performanti, sicure e facili da mantenere, adatte a progetti di qualsiasi dimensione, dal più piccolo al livello enterprise.

Configurare l’ambiente di sviluppo FuelPHP con ServBay

ServBay è un ambiente di sviluppo locale pensato per gli sviluppatori web, fornito di PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis e molti altri strumenti essenziali. Con ServBay puoi configurare rapidamente l’ambiente necessario per eseguire i tuoi progetti FuelPHP, senza dover installare e gestire manualmente le dipendenze.

Questa guida mostra come sfruttare l’ambiente PHP, il server web (Caddy) e i servizi database/cache offerti da ServBay per creare ed eseguire un progetto FuelPHP. Utilizzeremo la funzione Siti Web di ServBay per configurare il server web e rendere il progetto rapidamente accessibile e testabile.

Prerequisiti

Prima di iniziare, assicurati che:

• ServBay sia correttamente installato e attivo su macOS.
• L’ambiente PHP sia abilitato (di default in ServBay).
• I servizi database scelti (es. MySQL) e di cache (es. Redis, Memcached) siano avviati e funzionanti in ServBay.
• Composer è già integrato in ServBay, non è necessaria alcuna installazione aggiuntiva.

Creazione del progetto FuelPHP

Percorso consigliato per i progetti

ServBay consiglia di organizzare tutti i progetti web nella directory /Applications/ServBay/www, per facilitare la gestione e la configurazione. Anche questa guida utilizzerà tale percorso come esempio.

1. Naviga nella directory principale del sito

   Apri il Terminale e spostati nella directory radice consigliata da ServBay:

   cd /Applications/ServBay/www

2. Crea la cartella del progetto

   Crea una nuova cartella per il tuo progetto FuelPHP ed entra al suo interno:

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

3. Crea il progetto FuelPHP con Composer

   All’interno della directory del progetto, usa Composer per scaricare e inizializzare FuelPHP. Il punto indica la creazione nel percorso corrente:

   composer create-project fuel/fuel .

   Composer scaricherà automaticamente FuelPHP e tutte le dipendenze nella cartella servbay-fuelphp-app.

Configurazione del server web (tramite la funzione Siti Web di ServBay)

Per rendere accessibile il tuo progetto FuelPHP tramite browser, configura un host virtuale usando la funzione Siti Web di ServBay.

1. Apri l’interfaccia principale di ServBay.
2. Clicca sul menù Siti Web nella barra laterale.
3. Premi il pulsante Aggiungi sito web in alto a destra.
4. Nella finestra di configurazione inserisci:
   • Nome: Dai un nome facilmente riconoscibile, per esempio My First FuelPHP Dev Site.
   • Dominio: Scegli un dominio locale, ad esempio servbay-fuelphp-test.local. ServBay lo farà puntare automaticamente al tuo ambiente locale.
   • Tipo sito web: Seleziona PHP.
   • Versione di PHP: Scegli la versione che preferisci, ad esempio 8.3.
   • Directory radice sito: Indica la cartella di ingresso del progetto, cioè la sottocartella public contenente index.php: /Applications/ServBay/www/servbay-fuelphp-app/public.
5. Clicca Aggiungi per salvare la configurazione.

ServBay aggiornerà la configurazione di Caddy e riavvierà i servizi, rendendo attivo il nuovo dominio.

Per istruzioni dettagliate, consulta la documentazione di ServBay alla voce Aggiungi il primo sito web.

Configurare i servizi nel progetto FuelPHP

Nei progetti FuelPHP è necessario configurare le connessioni ai servizi come database e cache.

Configurazione del database

La configurazione del database si trova in fuel/app/config/development/db.php. Modifica questo file con i dati della tua connessione. Se usi il MySQL di default di ServBay:

<?php
/**
 * Impostazioni del database per l'ambiente development, che vengono unite a quelle globali.
 */
return [
    'default' => [
        'connection' => [
            'dsn'      => 'mysql:host=localhost;dbname=fuel_dev', // Assicurati che il database fuel_dev esista
            'username' => 'root', // Utente di default MySQL ServBay
            'password' => 'root', // Password di default MySQL ServBay (solo per lo sviluppo locale!)
        ],
        'identifier' => '`', // MySQL richiede backtick come identificatore
    ],
];

Note:

• Devi creare manualmente il database fuel_dev tramite uno strumento come phpMyAdmin o Adminer. Username predefinito ServBay: root, password: root (solo per ambienti di sviluppo).
• 'identifier' => ''` è richiesto da MySQL per referenziare correttamente tabelle e colonne.

Configurazione della cache (Memcached e Redis)

FuelPHP supporta diversi sistemi di cache. Configura il driver e i parametri di connessione in fuel/app/config/cache.php. Verifica che Memcached e/o Redis siano avviati in ServBay.

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

Se utilizzi Memcached come cache principale:

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

Le versioni PHP fornite da ServBay includono generalmente il modulo Memcached.

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

Se usi Redis, configura il file dedicato:

<?php
return [
    'default' => [
        'hostname' => '127.0.0.1', // Indirizzo di default Redis
        'port'     => 6379,      // Porta di default Redis
        'database' => 0,         // Indice database Redis
    ],
    // Puoi definire più connessioni Redis
];

ServBay fornisce il modulo Redis nelle versioni PHP preinstallate.

Esempi di servizi database e cache

Ecco come FuelPHP interagisce con il database e la cache tramite codice d’esempio.

Preparare la tabella database (Migrations con FuelPHP)

FuelPHP include Oil, uno strumento per gestire le migrazioni del database (versionamento schema).

1. Genera una migrazione

   Dal percorso radice del progetto (servbay-fuelphp-app), genera una migrazione per la tabella users con Oil:

   php oil generate migration create_users_table

   Questo comando crea un file migrazione con timestamp nella cartella fuel/app/migrations.

2. Modifica la migrazione

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

   <?php
   namespace Fuel\Migrations;
   
   use Fuel\Core\DBUtil;
   
   class Create_users_table
   {
       public function up()
       {
           // Crea 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'); // Imposta chiave primaria, indice, engine e charset
       }
   
       public function down()
       {
           // Elimina tabella users (rollback)
           DBUtil::drop_table('users');
       }
   }

3. Applica la migrazione

   Dalla directory del progetto (servbay-fuelphp-app), avvia la migrazione:

   php oil refine migrate

   Se tutto è corretto, la tabella users verrà creata nel database fuel_dev.

Aggiungere codice di esempio nel Controller

Modifica il file fuel/app/classes/controller/welcome.php per aggiungere esempi di utilizzo database e cache:

<?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 per la homepage predefinita
    public function action_index()
    {
        return Response::forge('Hello ServBay!');
    }

    // Action esempio Memcached
    public function action_memcached()
    {
        // Prova a recuperare il dato dalla cache
        $value = Cache::get('servbay_memcached_key');

        if ($value === false) {
            // Se non trovato, imposta un nuovo valore
            $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);
    }

    // Action esempio Redis
    public function action_redis()
    {
        // Ottieni istanza Redis (connessione predefinita)
        $redis = \Redis_Db::instance(); // In FuelPHP 1.x si usa Redis_Db::instance()
        // Per più connessioni: \Redis_Db::instance('connection_name')

        // Imposta un dato su Redis
        $redis->set('servbay_redis_key', 'Hello Redis from ServBay!');

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

        return Response::forge($value);
    }

    // Action esempio inserimento in MySQL
    public function action_mysql_add()
    {
        try {
            // Inserisci nuovo utente nella tabella users
            $result = DB::insert('users')->set([
                'name' => 'ServBay Demo User ' . time(), // Unico col timestamp
                'email' => 'demo_user_' . time() . '@servbay.test',
            ])->execute(); // execute() restituisce un array con l’ID inserito

            return Response::forge('User added with ID: ' . $result[0]);
        } catch (\Database_Exception $e) {
            // Cattura eccezioni DB come e-mail duplicata
            return Response::forge('Error adding user: ' . $e->getMessage(), 500);
        }
    }

    // Action esempio lettura dati da MySQL
    public function action_mysql()
    {
        // Recupera tutti gli utenti dalla tabella users
        $users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();

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

Note:

• I facade DB e Redis vengono importati per utilizzo diretto.
• Le chiavi di cache (Memcached/Redis) includono il prefisso servbay_ per evitare conflitti.
• Nell’esempio MySQL per inserimento sono stati aggiunti timestamp e gestione dell’errore, con una risposta più realistica.
• In FuelPHP 1.x si usa \Redis_Db::instance() per ottenere un’istanza Redis.

Configurare le rotte

Per accedere agli action appena creati tramite URL, configura le rotte in fuel/app/config/routes.php. Le rotte per Controller_Welcome sono già incluse di default, ma aggiungi esplicitamente le action memcached, redis, mysql_add, mysql.

Modifica o aggiungi nel file le seguenti righe:

<?php
return array(
    '_root_'  => 'welcome/index',  // Rotta di default per la homepage
    '_404_'   => 'welcome/404',    // Rotta per pagina errore 404

    // Rotte per i nuovi action di esempio
    'memcached'   => 'welcome/memcached',
    'redis'       => 'welcome/redis',
    'mysql_add'   => 'welcome/mysql_add',
    'mysql'       => 'welcome/mysql',

    // ... altre rotte
);

Accedere e testare il sito web

Ora puoi testare il progetto FuelPHP e i servizi da browser, accedendo al dominio configurato su ServBay (https://servbay-fuelphp-test.local).

• Homepage: https://servbay-fuelphp-test.local
  • Output atteso: Hello ServBay!
• Test Memcached: https://servbay-fuelphp-test.local/memcached
  • Primo accesso: Hello Memcached from ServBay! (from cache) (se la cache funziona)
  • Accessi successivi: Hello Memcached from ServBay! (cached) (se la cache funziona ed è ancora valida)
• Test Redis: https://servbay-fuelphp-test.local/redis
  • Output atteso: Hello Redis from ServBay! (se Redis è funzionante)
• Aggiungi utente in MySQL: https://servbay-fuelphp-test.local/mysql_add
  • Output atteso: User added with ID: [ID inserito] (se il DB, la tabella e il servizio funzionano)
• Recupera lista utenti da MySQL: https://servbay-fuelphp-test.local/mysql
  • Output atteso: un array JSON con tutti gli utenti della tabella users (se ci sono dati nel DB)

Informazioni su HTTPS: ServBay genera automaticamente i certificati SSL per i siti locali, usando ServBay User CA o ServBay Public CA. Se il browser segnala certificato non affidabile, assicurati di aver aggiunto la CA di ServBay come attendibile nel sistema.

Note e raccomandazioni

• Controlla dall’interfaccia ServBay che la versione PHP, Caddy (o Nginx/Apache), MySQL (se usi DB), Redis (se usi Redis), Memcached (se usi Memcached) siano in esecuzione.
• Assicurati di aver creato manualmente il database fuel_dev tramite lo strumento DB di ServBay (o di aver configuato un altro DB esistente). Le migrazioni con FuelPHP (oil refine migrate) creano solo le tabelle, non il database.
• L’entry point pubblico di FuelPHP è public/index.php, quindi nel setup dei Siti Web su ServBay, la radice deve puntare alla sottocartella public del progetto.

Conclusione

Con ServBay puoi allestire facilmente un ambiente di sviluppo locale completo per FuelPHP su macOS. Questa guida ha illustrato come realizzare un nuovo progetto FuelPHP, configurare la funzione Siti Web di ServBay, integrare i servizi database e cache e verificare il funzionamento tramite esempi pratici. I servizi preconfigurati e la semplicità di ServBay ti aiuteranno a sviluppare con maggiore rapidità.

Buon lavoro e buona programmazione su FuelPHP con ServBay!