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.
Naviga nella directory principale del sito
Apri il Terminale e spostati nella directory radice consigliata da ServBay:
bashcd /Applications/ServBay/www
1Crea la cartella del progetto
Crea una nuova cartella per il tuo progetto FuelPHP ed entra al suo interno:
bashmkdir servbay-fuelphp-app cd servbay-fuelphp-app
1
2Crea 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:
bashcomposer create-project fuel/fuel .
1Composer 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.
- Apri l’interfaccia principale di ServBay.
- Clicca sul menù Siti Web nella barra laterale.
- Premi il pulsante Aggiungi sito web in alto a destra.
- 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
contenenteindex.php
:/Applications/ServBay/www/servbay-fuelphp-app/public
.
- Nome: Dai un nome facilmente riconoscibile, per esempio
- 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
<?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
],
];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
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
<?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
];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
<?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
];
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
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).
Genera una migrazione
Dal percorso radice del progetto (
servbay-fuelphp-app
), genera una migrazione per la tabellausers
con Oil:bashphp oil generate migration create_users_table
1Questo comando crea un file migrazione con timestamp nella cartella
fuel/app/migrations
.Modifica la migrazione
Apri il file generato (
fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php
), edita il metodoup()
per definire la tabella, e il metododown()
per eliminarla:php<?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'); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Applica la migrazione
Dalla directory del progetto (
servbay-fuelphp-app
), avvia la migrazione:bashphp oil refine migrate
1Se tutto è corretto, la tabella
users
verrà creata nel databasefuel_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
<?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));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
Note:
- I facade
DB
eRedis
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
<?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
);
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
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!
- Output atteso:
- 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)
- Primo accesso:
- Test Redis:
https://servbay-fuelphp-test.local/redis
- Output atteso:
Hello Redis from ServBay!
(se Redis è funzionante)
- Output atteso:
- 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)
- Output atteso:
- 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)
- Output atteso: un array JSON con tutti gli utenti della tabella
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 sottocartellapublic
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!