Creare ed Eseguire un Progetto Yii 2 in ServBay

Panoramica: Cos’è Yii 2?

Yii 2 è un framework PHP ad alte prestazioni e basato su componenti, pensato per lo sviluppo rapido di applicazioni web moderne. Segue il modello di design MVC (Model-View-Controller) e mette a disposizione un set completo di funzionalità e strumenti per aiutare gli sviluppatori a creare applicazioni web scalabili e di alta qualità in modo efficiente. Tra le sue qualità principali si annoverano prestazioni eccellenti, un’architettura flessibile e potenti funzioni integrate come caching, sicurezza, supporto allo sviluppo di API RESTful e altro ancora, rendendolo una scelta popolare nella community di sviluppo.

Principali Caratteristiche e Vantaggi di Yii 2

• Alte prestazioni: Yii 2 è stato ottimizzato per gestire richieste ad alta concorrenza, risultando ideale per applicazioni dove la performance è fondamentale.
• Modularità: Il framework è progettato in modo altamente modulare, facilitando l’organizzazione del codice e il riutilizzo dei componenti.
• Sicurezza: Offre numerose funzionalità di sicurezza integrate, tra cui validazione dell’input, filtri sull’output, protezione contro CSRF/XSS e un sistema di autenticazione/autorizzazione.
• Facilità d’uso: L’API è intuitiva, la documentazione esaustiva e la curva di apprendimento contenuta permette di iniziare velocemente.
• Community attiva: Una grande community e una ricca libreria di estensioni di terze parti garantiscono supporto e soluzioni quando sorgono problemi.
• Strumenti integrati: Dispone di strumenti CLI per compiti come migrazioni database, generazione codice e altro, aumentando la produttività.

Yii 2 è ideale per sviluppare applicazioni enterprise, API RESTful, siti web di portali e molte altre soluzioni web moderne.

Eseguire un Progetto Yii 2 con ServBay

ServBay è un ambiente di sviluppo web locale progettato appositamente per macOS. Include PHP, diversi database (come MySQL, PostgreSQL, MongoDB, Redis), server web (Caddy, Nginx) e numerosi strumenti per sviluppatori (tra cui Composer, Node.js, Python, Go, Java). Offre agli sviluppatori una piattaforma “plug-and-play” pronta all’uso.

Questa guida ti mostrerà come creare ed eseguire un’applicazione di base Yii 2 utilizzando PHP, Composer e i servizi database integrati di ServBay. Configureremo inoltre il server web locale con la funzione “Siti” di ServBay per attivare il progetto e presentarne le principali funzionalità.

Prerequisiti

Prima di iniziare, assicurati di avere:

• Installato e avviato con successo ServBay su macOS.
• Installato e abilitato la versione PHP richiesta (ad es. PHP 8.3 o superiore) in ServBay.
• Installato e abilitato i servizi di database di cui necessiti (ad es. MySQL o PostgreSQL) e i servizi di cache (Memcached e Redis) in ServBay.

Puoi visualizzare e gestire tutti i pacchetti software installati e i loro stati direttamente dall’interfaccia principale di ServBay.

Creare un Progetto Yii 2

TIP

ServBay consiglia di mantenere i progetti nella directory /Applications/ServBay/www per assicurare ordine tra i file e una gestione ottimale tramite la funzione “Siti”.

1. Composer: Composer è già integrato in ServBay, quindi non è necessario installarlo separatamente. Puoi eseguire il comando composer direttamente dal terminale.

2. Crea la cartella del progetto: Apri il terminale, entra nella cartella root del tuo sito in ServBay e crea una nuova cartella per il progetto.

   cd /Applications/ServBay/www
   mkdir servbay-yii2-app
   cd servbay-yii2-app

3. Crea il progetto Yii 2 con Composer: All’interno della directory servbay-yii2-app, usa Composer per creare un nuovo progetto base Yii 2.

   composer create-project --prefer-dist yiisoft/yii2-app-basic .

   Questo comando scaricherà nella cartella corrente (.) il template base di Yii 2 insieme a tutte le sue dipendenze. Attendi che il processo sia completato.

4. Accedi alla cartella del progetto: Assicurati che il terminale si trovi nella root del progetto /Applications/ServBay/www/servbay-yii2-app. Tutti i prossimi comandi saranno eseguiti da qui.

   cd /Applications/ServBay/www/servbay-yii2-app

Configurazione Iniziale

Dopo la creazione del progetto Yii 2, dovresti effettuare una configurazione di base, in particolare la connessione al database e le impostazioni dei componenti.

1. Configurazione della connessione al database: Apri il file config/db.php nella root del progetto. Aggiorna le informazioni di connessione in base al servizio database utilizzato all’interno di ServBay (MySQL o PostgreSQL) e alle impostazioni corrispondenti (in genere l’utente predefinito è root e la password password, salvo tue modifiche).

   Prima di tutto, crea un nuovo database in ServBay per questo progetto, ad esempio chiamato servbay_yii2_app. Puoi farlo tramite Adminer (integrato in ServBay) o un client a tua scelta (come Sequel Ace o TablePlus). Adminer è accessibile dalla sezione database dell’applicazione ServBay.

   Per MySQL:

   <?php
   
   return [
       'class' => 'yii\db\Connection',
       'dsn' => 'mysql:host=127.0.0.1;dbname=servbay_yii2_app', // dbname deve essere il nome del database che hai creato
       'username' => 'root', // Username del database
       'password' => 'password', // Password del database
       'charset' => 'utf8mb4', // Raccomandato per supportare una gamma più ampia di caratteri
   ];

   Per PostgreSQL:

   <?php
   
   return [
       'class' => 'yii\db\Connection',
       'dsn' => 'pgsql:host=127.0.0.1;port=5432;dbname=servbay_yii2_app', // dbname è il database creato, la porta di default è 5432
       'username' => 'root', // Username del database
       'password' => 'password', // Password del database
       'charset' => 'utf8',
       'schemaMap' => [
           'pgsql' => [
               'class' => 'yii\pgsql\Schema',
               'defaultSchema' => 'public', // Schema di default per PostgreSQL
           ],
       ],
   ];

   Modifica il file config/db.php in base alle tue esigenze.

2. Configurazione di cache e componenti Redis: Apri il file config/web.php nella root del progetto. Modifica o aggiungi la sezione components per configurare Memcached e Redis. La porta predefinita per Memcached in ServBay è 11211, quella di Redis è 6379.

   <?php
   // ... altre configurazioni
   
   'components' => [
       // ... altri componenti esistenti (ad es. request, cache, user, errorHandler, log, urlManager)
   
       'cache' => [
           'class' => 'yii\caching\MemCache',
           'servers' => [
               [
                   'host' => '127.0.0.1',
                   'port' => 11211, // Porta standard Memcached
                   'weight' => 100,
               ],
           ],
       ],
   
       'redis' => [
           'class' => 'yii\redis\Connection',
           'hostname' => '127.0.0.1',
           'port' => 6379, // Porta standard Redis
           'database' => 0, // Indice del database Redis
       ],
   
       // ... altri componenti
   ],
   
   // ... altre configurazioni

   Verifica che i servizi Memcached e Redis siano avviati in ServBay. Nota che, per usare Redis come cache, è necessario il pacchetto yiisoft/yii2-redis (in genere è installato come dipendenza di base tramite composer create-project, ma in caso contrario si può aggiungere con composer require yiisoft/yii2-redis). Per Memcached si utilizza solitamente yiisoft/yii2-memcached.

Configurare il Server Web (Sito ServBay)

Utilizza la funzione “Siti” di ServBay per configurare il server web locale (Caddy o Nginx) puntando alla directory del tuo progetto Yii 2.

1. Apri ServBay: Avvia l’applicazione ServBay.
2. Naviga nelle impostazioni dei Siti: Cerca la voce “Siti” (o equivalente) e accedivi dal menu principale.
3. Aggiungi un nuovo sito: Premi il pulsante per aggiungere un sito nuovo (di solito un + o “Aggiungi”).
4. Compila le informazioni del sito:
   • Nome: Dai un nome riconoscibile, ad esempio My First Yii 2 Dev Site.
   • Dominio: Inserisci il dominio locale che userai, tipo servbay-yii2-test.local. ServBay configurerà automaticamente il DNS locale verso 127.0.0.1.
   • Tipo sito: Scegli PHP.
   • Versione PHP: Seleziona la versione PHP desiderata (ad esempio 8.3). Assicurati che sia installata e abilitata in ServBay.
   • Directory root sito: Questa impostazione è cruciale. Per il progetto base Yii 2, il punto di ingresso pubblico è la cartella web sotto la root del progetto. Quindi imposta la directory root come: /Applications/ServBay/www/servbay-yii2-app/web.
5. Salva e applica: Salva la configurazione. ServBay ricaricherà automaticamente la configurazione del server web.

Consulta la documentazione ufficiale di ServBay per le istruzioni dettagliate: Aggiunta del primo sito.

ServBay rilascerà e considererà attendibile automaticamente certificati SSL per il dominio locale tramite CA interna (User CA/Public CA), permettendoti di accedere via HTTPS.

Aggiunta di Codice Esempio per la Dimostrazione

Per mostrare l’utilizzo di database e cache, puoi aggiungere alcune azioni di esempio al controller principale di Yii 2.

Modifica il file controllers/SiteController.php nella root del progetto, aggiungendo questi metodi alla classe SiteController:

<?php

namespace app\controllers;

use Yii;
use yii\web\Controller;
use yii\web\Response;
use yii\db\Exception as DbException; // Importa la classe delle eccezioni del database

class SiteController extends Controller
{
    /**
     * Visualizza la homepage.
     *
     * @return string
     */
    public function actionIndex()
    {
        return $this->render('index');
    }

    /**
     * Esempio di utilizzo di Memcached.
     *
     * @return Response
     */
    public function actionMemcached()
    {
        $cache = Yii::$app->cache;
        $key = 'my_memcached_test_key';
        $data = 'Hello Memcached from ServBay!';
        $duration = 60; // Cache per 60 secondi

        if ($cache->set($key, $data, $duration)) {
            $value = $cache->get($key);
            return $this->asText("Memcached impostato con successo. Valore recuperato: " . $value);
        } else {
            return $this->asText("Impossibile salvare i dati in Memcached. Verifica il servizio e la configurazione di Memcached.");
        }
    }

    /**
     * Esempio di utilizzo di Redis.
     *
     * @return Response
     */
    public function actionRedis()
    {
        $redis = Yii::$app->redis;
        $key = 'my_redis_test_key';
        $data = 'Hello Redis from ServBay!';

        try {
            if ($redis->set($key, $data)) {
                $value = $redis->get($key);
                return $this->asText("Redis impostato con successo. Valore recuperato: " . $value);
            } else {
                 return $this->asText("Impossibile salvare i dati in Redis. Verifica il servizio e la configurazione di Redis.");
            }
        } catch (\yii\base\Exception $e) {
             return $this->asText("Errore Redis: " . $e->getMessage() . ". Controlla il servizio e la configurazione di Redis.");
        }
    }

    /**
     * Esempio di inserimento utente nel database.
     * Richiede che esista una tabella 'users'.
     *
     * @return Response
     */
    public function actionMysqlAdd() // Può essere usata anche per PostgreSQL se configurato correttamente
    {
        try {
            $count = Yii::$app->db->createCommand()->insert('users', [
                'name' => 'ServBay Demo User', // Nome demo legato al brand
                'email' => '[email protected]', // Email demo legata al brand
            ])->execute();
            return $this->asText("Utente aggiunto con successo. Righe interessate: " . $count);
        } catch (DbException $e) {
            return $this->asText("Impossibile aggiungere l’utente al database. Errore: " . $e->getMessage() . ". Verifica servizio database, configurazione e presenza della tabella 'users'.");
        }
    }

    /**
     * Esempio di recupero utenti dal database.
     * Richiede che esista una tabella 'users'.
     *
     * @return Response
     */
    public function actionMysql() // Può essere usata anche per PostgreSQL se configurato correttamente
    {
        try {
            $users = Yii::$app->db->createCommand('SELECT id, name, email FROM users')->queryAll();
             // Output formattato per evitare la divulgazione di dati sensibili/mix di formati
            $output = "Utenti recuperati:\n";
            foreach ($users as $user) {
                $output .= "- ID: {$user['id']}, Nome: {$user['name']}, Email: {$user['email']}\n";
            }
            return $this->asText($output);

        } catch (DbException $e) {
            return $this->asText("Impossibile recuperare utenti dal database. Errore: " . $e->getMessage() . ". Verifica servizio database, configurazione e presenza della tabella 'users'.");
        }
    }

    // Se utilizzi PostgreSQL puoi aggiungere metodi action separati, ma in genere basta usare il componente db configurato
    // public function actionPgsqlAdd() { ... }
    // public function actionPgsql() { ... }

    /**
     * Formatta l’output come testo semplice.
     * @param string $text
     * @return Response
     */
    protected function asText($text)
    {
        Yii::$app->response->format = Response::FORMAT_RAW;
        Yii::$app->response->getHeaders()->add('Content-Type', 'text/plain');
        return $text;
    }

    /**
     * Formatta l’output come JSON.
     * @param mixed $data
     * @return Response
     */
    protected function asJson($data)
    {
        Yii::$app->response->format = Response::FORMAT_JSON;
        return $data;
    }
}

Nota: ho aggiunto la gestione degli errori nelle azioni actionMysqlAdd e actionMysql e rimodellato leggermente l’output per renderlo più chiaro. I dati di esempio rispettano il naming brandizzato di ServBay.

Modifica il file views/site/index.php del progetto, cioè la view collegata all’action actionIndex. Puoi mantenere il contenuto di default o aggiornarlo:

<?php
/* @var $this yii\web\View */
/* @var $name string */
/* @var $message string */
/* @var $exception Exception */

use yii\helpers\Html;

$this->title = 'My Yii2 Application on ServBay'; // Titolo aggiornato
?>
<div class="site-index">
    <div class="jumbotron">
        <h1>Congratulazioni!</h1>
        <p class="lead">Hai creato con successo la tua applicazione Yii2 e l’hai configurata con ServBay!</p>
        <p><a class="btn btn-lg btn-success" href="https://www.yiiframework.com">Inizia con Yii</a></p>
    </div>

    <div class="body-content">
        <h2>Dimostrazioni</h2>
        <ul>
            <li><a href="<?= Html::toRoute('site/memcached') ?>">Testa Memcached</a></li>
            <li><a href="<?= Html::toRoute('site/redis') ?>">Testa Redis</a></li>
            <li><a href="<?= Html::toRoute('site/mysql-add') ?>">Aggiungi un utente a DB</a> (Richiede la tabella 'users')</li>
            <li><a href="<?= Html::toRoute('site/mysql') ?>">Recupera utenti da DB</a> (Richiede la tabella 'users')</li>
        </ul>
        <p>Assicurati che i servizi Memcached, Redis e il database prescelto (MySQL/PostgreSQL) siano avviati in ServBay e correttamente configurati in `config/web.php` e `config/db.php`.</p>
        <p>Per gli esempi database, occorre creare la tabella 'users' usando le migration di Yii (vedi sotto).</p>
    </div>
</div>

Sono stati aggiunti i link alle nuove azioni controller per facilitare i test delle funzionalità.

Database Relazionale: Creazione Struttura Tabella (Migrazione)

Per usare gli esempi database (actionMysqlAdd, actionMysql) è necessario creare la tabella users. Yii consiglia di gestire le modifiche allo schema con le migration.

1. Crea una migration: Dal terminale, assicurati di essere nella root del progetto (/Applications/ServBay/www/servbay-yii2-app) ed esegui il comando per generare una migration.

   php yii migrate/create create_users_table

   Ti verrà chiesto di confermare, inserisci yes e premi invio. Verrà creato un file PHP nella cartella migrations, con nome simile a mYYYYMMDD_HHMMSS_create_users_table.php.

2. Modifica il file di migration: Apri il nuovo file e personalizza il metodo up() per definire la tabella users.

   <?php
   
   use yii\db\Migration;
   
   /**
    * Gestisce la creazione della tabella `{{%users}}`.
    */
   class mXXXXXXXXXXXXXX_create_users_table extends Migration // XXXXXXXXXXXXXX è il timestamp
   {
       /**
        * {@inheritdoc}
        */
       public function up()
       {
           $this->createTable('{{%users}}', [ // {{%users}} permette di usare eventuali prefissi tabella
               'id' => $this->primaryKey(),
               'name' => $this->string()->notNull(),
               'email' => $this->string()->notNull()->unique(),
               'created_at' => $this->timestamp()->defaultExpression('CURRENT_TIMESTAMP'),
               'updated_at' => $this->timestamp()->defaultExpression('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'),
           ]);
   
           // Opzionale: crea un indice sulla colonna email per performance/query
           $this->createIndex(
               'idx-users-email',
               '{{%users}}',
               'email',
               true // true = indice univoco
           );
       }
   
       /**
        * {@inheritdoc}
        */
       public function down()
       {
           // Elimina indice
           $this->dropIndex(
               'idx-users-email',
               '{{%users}}'
           );
   
           // Elimina tabella
           $this->dropTable('{{%users}}');
       }
   }

   Sostituisci mXXXXXXXXXXXXXX_create_users_table con il nome effettivo del file generato.

3. Esegui la migration: Dal terminale, sempre nella root del progetto, esegui la migration che creerà la tabella users secondo la definizione sopra.

   php yii migrate

   Conferma quando richiesto digitando yes e premi invio. Se tutto è impostato correttamente, la creazione della tabella andrà a buon fine.

Accedi al Sito e Testa

Ora puoi aprire il browser e visitare il dominio configurato in ServBay, ad esempio https://servbay-yii2-test.local.

• Visitando https://servbay-yii2-test.local visualizzerai la pagina di benvenuto di Yii 2, insieme ai link demo aggiunti nell’index.
• Clicca su "Testa Memcached" o visita https://servbay-yii2-test.local/index.php?r=site/memcached: se Memcached funziona e la configurazione è corretta, vedrai il messaggio relativo al successo dell’operazione.
• Clicca su "Testa Redis" o visita https://servbay-yii2-test.local/index.php?r=site/redis: se Redis è operativo, riceverai il messaggio di conferma.
• Clicca su "Aggiungi un utente a DB" o visita https://servbay-yii2-test.local/index.php?r=site/mysql-add: assicurati che la tabella users sia creata; ogni clic aggiungerà un nuovo utente (a meno che l’email non sia già presente e sia unica).
• Clicca su "Recupera utenti da DB" o visita https://servbay-yii2-test.local/index.php?r=site/mysql: visualizzerai l’elenco degli utenti presenti nel database.

In caso di problemi, verifica che PHP, web server, database, Memcached e Redis siano avviati in ServBay, che la configurazione dei file del progetto (config/db.php, config/web.php) sia corretta e che le tabelle siano presenti.

Domande Frequenti (FAQ)

• Perché ricevo “Impossibile raggiungere il sito” o errori di certificato quando visito il dominio locale? Verifica di aver aggiunto correttamente il dominio tra i “Siti” di ServBay e che l’applicazione sia attiva. ServBay imposta automaticamente DNS locali e certificati SSL. Se hai errori di certificato, assicurati di aver considerato attendibile la CA di ServBay. Consulta la documentazione ufficiale per i dettagli.
• Il comando Composer non funziona? Verifica che Composer sia abilitato tra i pacchetti software nell’interfaccia di ServBay e che tu stia usando il terminale su macOS. ServBay aggiunge Composer al PATH automaticamente.
• Impossibile collegarsi al database? Controlla che il servizio database (MySQL/PostgreSQL) sia avviato. Ricontrolla dsn, username e password in config/db.php e assicurati che il database servbay_yii2_app esista (puoi verificare tramite Adminer integrato).
• Problemi di connessione Memcached/Redis? Verifica che i rispettivi servizi siano attivi in ServBay; controlla l’host e la porta nei componenti di config/web.php (di default 127.0.0.1 e la porta standard del servizio).
• Migrazione database (php yii migrate) fallita? Assicurati di aver configurato correttamente config/db.php, che il database sia attivo e sia già stato creato.
• Perché le azioni actionMysqlAdd/actionMysql segnalano che la tabella non esiste? Devi prima creare la tabella users tramite il comando di migration php yii migrate.
• Dove posso vedere i log degli errori PHP? ServBay centralizza log di PHP, web server, ecc. e li mostra nella sezione “Log” dell’applicazione, potrai così diagnosticare eventuali problemi.

Conclusione

ServBay ti permette di impostare facilmente un ambiente di sviluppo locale ricco di funzionalità per Yii 2 su macOS. Grazie a Composer preinstallato, gestione versione PHP, database e servizi di cache integrati, e a una configurazione siti semplificata, l’intero processo di setup e sviluppo di progetti Yii 2 su ServBay risulta notevolmente più semplice e veloce. Seguendo questa guida potrai avviare rapidamente il tuo percorso di sviluppo con Yii 2 e sfruttare al massimo gli strumenti offerti da ServBay.

Buono sviluppo!