Creazione e Avvio di un Progetto CakePHP con ServBay

ServBay è un ambiente di sviluppo web locale disponibile per macOS e Windows, che integra PHP, Node.js, Python, Go, Java e molteplici servizi database come MySQL, PostgreSQL, MongoDB, Redis, abbinati ai web server Caddy o Nginx. Offre una piattaforma efficiente e versatile che consente agli sviluppatori di gestire facilmente progetti locali.

In questo articolo scoprirai come creare, configurare e avviare un progetto CakePHP nell'ambiente ServBay. CakePHP è un framework PHP popolare basato sul modello MVC (Model-View-Controller), noto per lo sviluppo rapido, il potente ORM integrato e le funzionalità di sicurezza avanzate. Usando ServBay, puoi velocizzare la configurazione e l’avvio del tuo ambiente di sviluppo CakePHP.

Cos'è CakePHP?

CakePHP è un framework open source per lo sviluppo di applicazioni web in PHP, che offre una struttura solida per lo sviluppo rapido e ordinato, senza rinunciare alla flessibilità. Si basa sul principio della convenzione rispetto alla configurazione, semplificando molte delle attività comuni degli sviluppatori.

Caratteristiche e Vantaggi Principali di CakePHP

• Architettura MVC: Organizzazione chiara del codice, facile da mantenere ed estendere.
• Sviluppo rapido: Strumenti CLI (Bake) per generazione automatica del codice e accelerazione del workflow.
• ORM potente: Semplifica l’interazione con i database e supporta diversi sistemi di database.
• Sicurezza integrata: Protezione da CSRF, SQL injection, validazione input e altre funzionalità di sicurezza.
• Motore di template flessibile: Supporto a diverse tecnologie di view.
• Comunità attiva e ricca di plugin: Supporto facile da reperire e possibilità di estendere le funzionalità.
• Documentazione dettagliata: Guide complete e reference API.

CakePHP è ideale per lo sviluppo di applicazioni web di qualsiasi scala, dalle semplici API ai sistemi enterprise complessi.

Configurare l’Ambiente CakePHP con ServBay

ServBay facilita lo sviluppo con CakePHP offrendo:

• Interprete PHP preinstallato con estensioni comuni.
• Composer preinstallato.
• Web server facilmente configurabili (Caddy/Nginx).
• Servizi database integrati (MySQL, PostgreSQL, Redis, ecc.).

Usare ServBay elimina la necessità di configurare manualmente questi componenti.

Prerequisiti

Prima di iniziare, assicurati di aver completato quanto segue:

1. Installazione di ServBay: Scarica e installa ServBay su macOS.
2. Avvio dei servizi ServBay: Avvia ServBay e accertati che i pacchetti necessari (PHP, database come MySQL o PostgreSQL, servizi di cache come Redis o Memcached) siano attivi. Puoi gestirli tramite il pannello di controllo, scheda “Pacchetti”.
3. Familiarità con le funzioni base di ServBay: Sapere come aggiungere e configurare siti web in ServBay. Se sei nuovo, consulta prima la Guida Base all’Uso di ServBay.

Creazione del Progetto CakePHP

Si consiglia di archiviare tutti i file dei progetti web nella cartella /Applications/ServBay/www, così ServBay potrà rilevarli e gestirli automaticamente.

1. Apri il Terminale

   Avvia l’app Terminale su macOS.

2. Accedi alla Directory Radice Siti Web di ServBay

   Vai nella cartella consigliata per i siti:

   cd /Applications/ServBay/www

3. Crea la Directory del Progetto

   Crea una nuova sottocartella per il tuo progetto CakePHP. Per esempio, useremo servbay-cakephp-app:

   mkdir servbay-cakephp-app
   cd servbay-cakephp-app

4. Crea il Progetto CakePHP con Composer

   Composer è già preinstallato in ServBay. Nella cartella del progetto, crea lo scheletro di CakePHP:

   composer create-project --prefer-dist cakephp/app .

   Il comando scarica l’ultima versione stabile di CakePHP e le sue dipendenze nel percorso corrente (.).

5. Installa il Driver ORM (solo per PostgreSQL)

   Se usi PostgreSQL, installa il driver ORM dedicato:

   composer require cakephp/orm-pgsql

   Per MySQL non è necessario, poiché il driver è già incluso tra le dipendenze principali di CakePHP.

Configurazione Iniziale

Dopo la creazione del progetto, configura i parametri di base, specialmente le connessioni al database.

1. Configura le Variabili d’Ambiente e la Connessione al Database

   Le configurazioni locali sono nel file config/app_local.php. Modifica la sezione Datasources impostando i dati per la connessione al database. Di default ServBay usa root come nome utente e password per la password.

   Esempio di connessione MySQL:

   // config/app_local.php
   'Datasources' => [
       'default' => [
           'className' => \Cake\Database\Connection::class,
           'driver' => \Cake\Database\Driver\Mysql::class, // oppure \Cake\Database\Driver\Postgres::class per PostgreSQL
           'persistent' => false,
           'host' => '127.0.0.1', // Indirizzo server DB, ServBay è locale
           //'port' => '3306', // Porta di default MySQL 3306, PostgreSQL 5432
           'username' => 'root', // Utente di default ServBay
           'password' => 'password', // Password di default ServBay
           'database' => 'servbay_cakephp_app', // Nome del database che creerai
           'encoding' => 'utf8mb4',
           'timezone' => 'UTC',
           'flags' => [],
           'cacheMetadata' => true,
           'log' => false,
   
           /**
            * Abilita quoteIdentifiers a true se usi nomi come "user" per le tabelle.
            * Se usi nomi come "cake" può essere false.
            * In caso di dubbio, lascia true.
            */
           'quoteIdentifiers' => false,
   
           /**
            * Attuali limitazioni:
            * - La maggior parte dei driver non supporta l’impostazione del livello di isolamento tramite le opzioni PDO.
            *   L’uso può generare errori.
            * - Non tutti i driver supportano la codifica tramite le opzioni PDO.
            *   L’uso può generare errori.
            * - Le opzioni PDO non sono supportate dai driver "pacchettizzati" come Postgres in CakePHP.
            *   Per Postgres, basta impostare l’encoding.
            */
           'options' => [],
   
           //'url' => env('DATABASE_URL', null), // Se usi la variabile DATABASE_URL, puoi attivare questa riga
       ],
   ],

   Modifica il driver e la port secondo il tipo di database che usi. Assicurati che il valore database corrisponda al nome del DB che creerai.

Configurazione Web Server (Creazione Sito in ServBay)

Per accedere al progetto CakePHP dal browser, configura un sito su ServBay da puntare sulla directory del progetto.

1. Apri il Pannello di Controllo ServBay

   Clicca sull'icona ServBay per aprire il pannello.

2. Vai alla Scheda “Siti”

   Nel pannello ServBay, seleziona “Siti” (in precedenza "Host") dalla barra laterale.

3. Aggiungi un Nuovo Sito

   Premi il pulsante + in basso per aggiungere un sito e inserisci:

   • Nome: Un nome identificativo, es. My CakePHP Dev Site.
   • Dominio: Un dominio di sviluppo locale, es. servbay-cakephp-test.local. ServBay lo indirizza a localhost.
   • Tipo sito: Seleziona PHP.
   • Versione PHP: Scegli la versione compatibile (CakePHP 4+ richiede ≥ PHP 7.4, CakePHP 5+ richiede ≥ PHP 8.1), es. 8.3.
   • Radice sito (Document Root): Importante! La root del web server è la cartella webroot interna al progetto CakePHP, non la cartella principale del progetto. Usa /Applications/ServBay/www/servbay-cakephp-app/webroot (sostituisci servbay-cakephp-app col tuo percorso reale).

4. Salva e Applica le Modifiche

   Dopo aver compilato i dati, clicca su “Salva” e conferma per applicare. ServBay configurerà il web server (Caddy/Nginx) per rispondere al dominio servbay-cakephp-test.local indirizzando le richieste alla cartella webroot del progetto.

Per dettagli step-by-step consulta la documentazione ServBay: Aggiungi il primo sito.

Verifica della Configurazione Base

A questo punto dovresti poter raggiungere il sito dal browser.

Apri il browser e visita il dominio configurato, es. https://servbay-cakephp-test.local.

Se la configurazione è corretta, vedrai la pagina di benvenuto predefinita di CakePHP, segno che PHP, web server e sito sono collegati e funzionanti.

Integrazione con Database e Servizi di Cache

CakePHP offre un ORM avanzato e un sistema di cache flessibile per integrare velocemente i servizi database e cache di ServBay.

Esempio Database Relazionale (MySQL / PostgreSQL)

Mostriamo come usare l’ORM di CakePHP per connettersi al database MySQL o PostgreSQL di ServBay, creare una tabella users e gestire operazioni CRUD.

1. Creazione del Database in ServBay

   Prima di effettuare le migrazioni, crea il database in ServBay. Usa phpMyAdmin (MySQL/MariaDB), pgAdmin (PostgreSQL) o strumenti terzi (Navicat, DBeaver) per connetterti (host 127.0.0.1, utente root, password password) e crea il database servbay_cakephp_app.

2. Creazione del File Model ORM

   CakePHP usa i file Model per rappresentare le tabelle. Crea UsersTable.php nella cartella src/Model/Table/:

   <?php
   namespace App\Model\Table;
   
   use Cake\ORM\Table;
   use Cake\Validation\Validator; // Se ti serve la validazione
   
   class UsersTable extends Table
   {
       /**
        * Metodo di inizializzazione
        *
        * @param array $config Configurazione della Tabella.
        * @return void
        */
       public function initialize(array $config): void
       {
           parent::initialize($config);
   
           $this->setTable('users'); // Imposta il nome tabella
           $this->setDisplayField('name'); // Campo visualizzato nelle relazioni
           $this->setPrimaryKey('id'); // Chiave primaria
   
           // Per abilitare timestamp automatici
           // $this->addBehavior('Timestamp');
       }
   
       /**
        * Regole di validazione di default.
        *
        * @param \Cake\Validation\Validator $validator Istanza Validator.
        * @return \Cake\Validation\Validator
        */
       public function validationDefault(Validator $validator): Validator
       {
           $validator
               ->scalar('name')
               ->maxLength('name', 255)
               ->requirePresence('name', 'create')
               ->notEmptyString('name');
   
           $validator
               ->email('email')
               ->requirePresence('email', 'create')
               ->notEmptyString('email')
               ->add('email', 'unique', ['rule' => 'validateUnique', 'provider' => 'table']); // Email unica
   
           return $validator;
       }
   }

3. Creazione del File di Migrazione con Bake

   Utilizza il comando Bake per creare la migrazione della tabella users:

   bin/cake bake migration CreateUsers name:string email:string:unique

   Questo comando genera il file di migrazione per creare la tabella con i campi name (stringa) e email (stringa, unico).

4. Esegui la Migrazione Database

   Esegui la migrazione per applicare la struttura del DB:

   bin/cake migrations migrate

   Se la migrazione va a buon fine, troverai la tabella users nel database.

5. Configurazione Connessione DB (se non già fatta)

   Verifica che config/app_local.php in Datasources.default corrisponda al database usato:

   • Esempio MySQL:

     'Datasources' => [
         'default' => [
             'className' => \Cake\Database\Connection::class,
             'driver' => \Cake\Database\Driver\Mysql::class,
             'host' => '127.0.0.1',
             'username' => 'root',
             'password' => 'password',
             'database' => 'servbay_cakephp_app',
             // ... altre configurazioni
         ],
     ],

   • Esempio PostgreSQL:

     'Datasources' => [
         'default' => [
             'className' => \Cake\Database\Connection::class,
             'driver' => \Cake\Database\Driver\Postgres::class,
             'host' => '127.0.0.1',
             // 'port' => '5432',
             'username' => 'root',
             'password' => 'password',
             'database' => 'servbay_cakephp_app',
             // ... altre configurazioni
         ],
     ],

6. Aggiunta di Route di Esempio e Metodi Controller

   Modifica config/routes.php per aggiungere le rotte di esempio:

   // config/routes.php
   use Cake\Routing\RouteBuilder;
   use Cake\Routing\Router;
   use Cake\Routing\Route\DashedRoute;
   
   Router::defaultRouteClass(DashedRoute::class);
   
   Router::scope('/', function (RouteBuilder $routes) {
       // ... altre rotte
       $routes->connect('/', ['controller' => 'Pages', 'action' => 'display', 'home']);
   
       // Rotte DB di esempio
       $routes->connect('/db-add-user', ['controller' => 'Pages', 'action' => 'dbAddUser']);
       $routes->connect('/db-list-users', ['controller' => 'Pages', 'action' => 'dbListUsers']);
   
       // ... altre rotte
       $routes->fallbacks(DashedRoute::class);
   });

   Modifica src/Controller/PagesController.php per aggiungere i metodi:

   <?php
   namespace App\Controller;
   
   use Cake\Http\Response;
   use Cake\ORM\TableRegistry;
   use Cake\Datasource\Exception\RecordNotFoundException; // Gestione errori record non trovato
   
   class PagesController extends AppController
   {
       /**
        * Visualizza una pagina
        *
        * @param array ...$path Segmenti path.
        * @return \Cake\Http\Response|null
        */
       public function display(...$path): ?Response
       {
           // ... Metodo display predefinito
           return new Response(['body' => 'Hello ServBay! Questa è la pagina predefinita.']);
       }
   
       /**
        * Esempio DB: aggiungi utente
        */
       public function dbAddUser(): Response
       {
           $usersTable = TableRegistry::getTableLocator()->get('Users'); // Ottieni tabella Users
   
           // Crea un nuovo entity utente
           $user = $usersTable->newEntity([
               'name' => 'ServBay Demo User',
               'email' => 'servbay-demo@servbay.test' // Email di esempio ServBay
           ]);
   
           // Prova a salvare nel database
           if ($usersTable->save($user)) {
               return new Response(['body' => 'Utente aggiunto con successo! User ID: ' . $user->id]);
           } else {
               // In caso di errori di validazione o altro
               $errors = $user->getErrors(); // Ottieni errori di validazione
               return new Response(['body' => 'Impossibile aggiungere utente. Errori: ' . json_encode($errors)]);
           }
       }
   
       /**
        * Esempio DB: elenca tutti gli utenti
        */
       public function dbListUsers(): Response
       {
           $usersTable = TableRegistry::getTableLocator()->get('Users'); // Ottieni tabella Users
   
           // Recupera tutti gli utenti
           $users = $usersTable->find()->all();
   
           // Codifica il risultato in JSON da mostrare
           return new Response(['body' => json_encode($users->toArray())]); // Usa toArray() per convertire la Collection
       }
   }

7. Prova le Rotte Database di Esempio

   Dal browser:

   • Vai su https://servbay-cakephp-test.local/db-add-user per aggiungere un utente; riceverai un messaggio di conferma.
   • Vai su https://servbay-cakephp-test.local/db-list-users per vedere la lista utenti (compreso quello appena inserito).

Hai così collegato il progetto CakePHP al database relazionale di ServBay ed eseguito operazioni ORM fondamentali.

Esempio Servizi Cache (Memcached / Redis)

CakePHP offre un’API cache unificata che permette di passare da Memcached a Redis con facilità. ServBay include le estensioni PHP per Memcached e Redis, e i relativi servizi.

Assicurati di aver attivato Memcached o Redis nella scheda “Pacchetti” del pannello ServBay.

1. Configura la Connessione Cache

   Modifica config/app_local.php sotto la sezione Cache:

   • Esempio Memcached:

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\MemcachedEngine::class,
             'servers' => ['127.0.0.1:11211'], // Indirizzo e porta Memcached ServBay
             'prefix' => 'servbay_cakephp_', // Prefisso chiavi cache
         ],
         // ... altre configurazioni cache
     ],

   • Esempio Redis:

     // config/app_local.php
     'Cache' => [
         'default' => [
             'className' => \Cake\Cache\Engine\RedisEngine::class,
             'host' => '127.0.0.1', // Indirizzo Redis ServBay
             'port' => 6379, // Porta di default Redis
             'password' => null, // Se Redis è protetto, inserisci la password
             'database' => 0, // Indice database Redis
             'prefix' => 'servbay_cakephp_', // Prefisso chiavi cache
         ],
         // ... altre configurazioni cache
     ],

   Scegli la configurazione del servizio cache usato.

2. Aggiungi le Route di Esempio e i Metodi Controller

   Modifica config/routes.php per aggiungere le rotte cache:

   // config/routes.php
   // ... altre rotte
   $routes->connect('/cache-memcached', ['controller' => 'Pages', 'action' => 'cacheMemcached']);
   $routes->connect('/cache-redis', ['controller' => 'Pages', 'action' => 'cacheRedis']);
   // ... altre rotte

   Modifica src/Controller/PagesController.php per aggiungere i metodi cache:

   <?php
   namespace App\Controller;
   
   use Cake\Http\Response;
   use Cake\Cache\Cache; // Importa la classe Cache
   // ... altri use
   
   class PagesController extends AppController
   {
       // ... altri metodi (display, dbAddUser, dbListUsers)
   
       /**
        * Esempio cache: Memcached
        */
       public function cacheMemcached(): Response
       {
           // Assicurati che 'default' in app_local.php usi MemcachedEngine
   
           $cacheKey = 'servbay_memcached_test_key';
           $cachedData = Cache::read($cacheKey); // Cerca dati in cache
   
           $responseBody = '';
   
           if ($cachedData === false) {
               // Cache miss
               $responseBody = 'Cache miss! Scrittura "Hello Memcached!" in cache.';
               $dataToCache = 'Hello Memcached!';
               Cache::write($cacheKey, $dataToCache, 'default'); // Scrivi in cache (Memcached)
           } else {
               // Cache hit
               $responseBody = 'Cache hit! Dato dalla cache: ' . $cachedData;
           }
   
           return new Response(['body' => $responseBody]);
       }
   
       /**
        * Esempio cache: Redis
        */
       public function cacheRedis(): Response
       {
            // Assicurati che 'default' in app_local.php usi RedisEngine
   
           $cacheKey = 'servbay_redis_test_key';
           $cachedData = Cache::read($cacheKey); // Cerca dati in cache
   
           $responseBody = '';
   
           if ($cachedData === false) {
               // Cache miss
               $responseBody = 'Cache miss! Scrittura "Hello Redis!" in cache.';
               $dataToCache = 'Hello Redis!';
               Cache::write($cacheKey, $dataToCache, 'default'); // Scrivi in cache (Redis)
           } else {
               // Cache hit
               $responseBody = 'Cache hit! Dato dalla cache: ' . $cachedData;
           }
   
           return new Response(['body' => $responseBody]);
       }
   }

3. Verifica Esempio Cache

   Dal browser:

   • Se hai configurato Memcached, visita https://servbay-cakephp-test.local/cache-memcached. Al primo accesso vedrai “Cache miss”, aggiornando la pagina comparirà “Cache hit”.
   • Se hai configurato Redis, visita https://servbay-cakephp-test.local/cache-redis. Stesso comportamento: “Cache miss” all’inizio, poi “Cache hit”.

Questo dimostra che il progetto CakePHP utilizza correttamente i servizi cache forniti da ServBay.

Note Importanti

• Credenziali database: Le credenziali di default (root/password) ServBay sono solo per sviluppo locale. In produzione usa password e utenti più sicuri.
• Radice sito: Assicurati che la “radice sito” ServBay punti a webroot del progetto CakePHP, non alla cartella principale del progetto. È best practice per CakePHP.
• Compatibilità PHP: Scegli una versione PHP compatibile con la versione CakePHP. Consulta la documentazione ufficiale CakePHP.
• Porte ServBay: Se le porte di default (80, 443) sono occupate, modifica le impostazioni ServBay e, se necessario, aggiorna il file hosts o accedi tramite il numero porta.

FAQ (Domande Frequenti)

• D: Visitando servbay-cakephp-test.local ottengo errore "pagina non trovata"?
  • R: Controlla che la “radice sito” sia impostata su /Applications/ServBay/www/servbay-cakephp-app/webroot.
  • Verifica se il web server ServBay (Caddy/Nginx) è attivo.
  • Controlla che il file hosts punti il dominio servbay-cakephp-test.local su 127.0.0.1 (ServBay lo gestisce, ma verifica).
  • Controlla che .htaccess o la configurazione del server web siano corrette (normalmente webroot/.htaccess va bene).
• D: Connessione al database fallita?
  • R: Verifica che il database (MySQL/PostgreSQL) ServBay sia attivo.
  • Controlla che i dati di connessione in config/app_local.php (host, porta, utente, password, database) siano corretti e corrispondano all’istanza DB.
  • Assicurati di aver creato il database servbay_cakephp_app.
• D: Non riesci a eseguire i comandi Composer (bin/cake)?
  • R: Assicurati di essere nella root del progetto (/Applications/ServBay/www/servbay-cakephp-app) nel terminale.
  • Verifica che PHP e Composer siano attivi in ServBay.
  • Il terminale deve riconoscere il comando php (ServBay normalmente aggiorna il PATH). Usa il terminale integrato ServBay o aggiorna manualmente il PATH.

Sommario

Con ServBay puoi creare rapidamente un ambiente locale per sviluppare progetti CakePHP in modo ottimale. ServBay integra PHP, Composer, web server e servizi database pronti all’uso, semplificando la configurazione. Questa guida mostra il workflow completo: dalla creazione del progetto, alla configurazione di base, al setup del web server, all’integrazione di database relazionali e servizi cache, per avviare la tua esperienza di sviluppo CakePHP velocemente. Con ServBay, puoi dedicarti al codice — lasciando da parte le complessità ambientali.