Creazione ed esecuzione di un progetto Webman su ServBay

Che cos'è Webman?

Webman è un framework web PHP asincrono ad alte prestazioni basato su Workerman, progettato specificamente per sviluppare applicazioni web ad alta concorrenza e alte prestazioni. Diversamente dai framework sincroni e bloccanti tradizionali, Webman utilizza un modello event-driven e I/O asincrono non bloccante, eccellendo nella gestione di grandi volumi di richieste concorrenti. Webman offre un’API semplice e intuitiva e un meccanismo di estensione flessibile, rendendolo perfetto per la creazione di applicazioni real-time, servizi API, microservizi e altro ancora.

Principali caratteristiche e vantaggi di Webman

• Alte prestazioni: Basato su Workerman, sfrutta event-driven e I/O asincrono non bloccante, riuscendo a gestire un gran numero di connessioni simultanee e garantendo una velocità superiore ai tradizionali framework sincroni.
• Facile da usare: Fornisce API semplici e intuitive e numerose funzionalità integrate per permettere agli sviluppatori di iniziare rapidamente a costruire applicazioni.
• Supporto multi-protocollo: Supporto nativo per protocolli di livello applicativo comuni come HTTP e WebSocket, consentendo la realizzazione di vari tipi di servizi.
• Estendibilità flessibile: È possibile espandere facilmente le funzionalità del framework tramite pacchetti Composer, plugin e middleware.
• Basso consumo di risorse: Rispetto alla tipica combinazione server web + PHP-FPM, Webman rimane residente in memoria, consumando meno risorse di sistema.
• Forte community di supporto: Dispone di una comunità di sviluppatori attiva e di documentazione ampia.

Webman consente agli sviluppatori di realizzare rapidamente applicazioni e servizi API web ad alta disponibilità e alte prestazioni, risultando particolarmente indicato per scenari che richiedono alta concorrenza e bassa latenza.

Creare ed eseguire un semplice progetto Webman su ServBay

Questa guida illustra passo passo come creare e avviare un progetto web utilizzando Webman nell'ambiente di sviluppo locale ServBay. Verranno mostrati l’installazione di Webman, la scrittura di codice base per rotte e controller, nonché l’integrazione di database (MySQL, PostgreSQL) e servizi di cache (Redis, Memcached) forniti da ServBay.

TIP

Si consiglia di salvare tutti i progetti web locali nella cartella /Applications/ServBay/www, per permettere a ServBay una gestione unificata, come la configurazione dei siti locali.

Prerequisiti

Prima di iniziare, assicurati di aver completato i seguenti passaggi:

1. Installazione di ServBay: Devi avere installato con successo ServBay su macOS. ServBay offre un ambiente di sviluppo locale all-in-one comprendente PHP, Composer, MySQL, PostgreSQL, Redis, Memcached e tutti i pacchetti necessari per questa guida.
2. Abilitazione dei pacchetti richiesti: Tramite il pannello di controllo di ServBay, verifica che i seguenti pacchetti siano installati e in esecuzione:
   • La versione PHP scelta (si consiglia una versione recente come PHP 8.x)
   • Composer (incluso di default in ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Assicurati che per la versione PHP selezionata siano attive le estensioni memcached, redis, pdo_mysql, pdo_pgsql e altre essenziali. Queste estensioni sono solitamente abilitate di default in ServBay, ma puoi verificarle dal pannello di configurazione PHP di ServBay.
3. Accesso al terminale: Dimestichezza nell’uso del Terminale di macOS.

Installazione di Webman

1. Verificare la disponibilità di Composer

   ServBay include già Composer preinstallato e configurato per l’uso diretto dal terminale. Puoi verificarlo con il comando:

   composer --version

   Se viene visualizzata la versione di Composer, allora tutto è pronto per proseguire.

2. Entrare nella cartella web di ServBay

   Apri il terminale e naviga nella cartella principale consigliata per i siti ServBay:

   cd /Applications/ServBay/www

3. Creare un progetto Webman tramite Composer

   Usa il comando create-project di Composer per installare il framework Webman in una cartella specifica. Nominiamo il progetto servbay-webman-app:

   composer create-project workerman/webman servbay-webman-app

   Composer scaricherà Webman e tutte le dipendenze nella cartella servbay-webman-app.

4. Accedere alla cartella del progetto

   Una volta completata l’installazione, entra nella directory del progetto:

   cd servbay-webman-app

5. Installare i componenti necessari

   Per dimostrare le funzionalità di database e cache, è necessario installare alcuni ulteriori pacchetti Composer. Webman generalmente utilizza illuminate/database (componente ORM di Laravel), illuminate/redis e altri. L’opzione -W (--with-dependencies) assicura la risoluzione delle dipendenze garantendo la compatibilità.

   composer require -W illuminate/database illuminate/redis illuminate/pagination illuminate/events symfony/var-dumper

   Questo comando aggiungerà ORM database, client Redis, paginazione, event dispatcher e VarDumper per il debug.

Creazione di database e tabelle

Per consentire il funzionamento del codice d’esempio, bisogna creare su MySQL e PostgreSQL di ServBay un database e una tabella users. La password utente root di default in ServBay è password.

Puoi utilizzare strumenti di gestione database inclusi (phpMyAdmin, pgAdmin, accessibili dal pannello ServBay) oppure il terminale per eseguire le seguenti query SQL.

1. Creare il database webman_app

   • MySQL:

     CREATE DATABASE IF NOT EXISTS webman_app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Creare la tabella users nel database webman_app

   • MySQL:

     USE webman_app;
     CREATE TABLE users (
         id INT AUTO_INCREMENT PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

   • PostgreSQL:

     \c webman_app; -- Connessione al nuovo database
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Scrittura del codice per il progetto web

Aggiungiamo ora il codice per le rotte, i controller e la logica di interazione con il database e la cache.

1. Configurare le rotte

   Modifica il file config/route.php nella root del progetto aggiungendo il seguente codice per impostare le rotte di esempio:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Definisce la rotta principale e la mappa a IndexController, metodo index
   Route::any('/', [IndexController::class, 'index']);
   
   // Rotte per funzionalità cache
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Rotte per funzionalità database
   Route::any('/mysql-add', [DatabaseController::class, 'mysqlAdd']);
   Route::any('/mysql', [DatabaseController::class, 'mysqlGet']);
   Route::any('/pgsql-add', [DatabaseController::class, 'pgsqlAdd']);
   Route::any('/pgsql', [DatabaseController::class, 'pgsqlGet']);
   
   // Puoi aggiungere altre rotte qui...

2. Creare i controller

   Nella cartella app/controller crea i file IndexController.php, CacheController.php e DatabaseController.php, aggiungendo rispettivamente il seguente codice.

   • app/controller/IndexController.php — Gestione della rotta principale.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Importa la classe Response
     
     class IndexController
     {
         /**
          * Esempio di metodo che gestisce la richiesta alla radice
          * @param Request $request Oggetto della richiesta attuale
          * @return Response Restituisce un oggetto Response
          */
         public function index(Request $request): Response // Definisce il tipo di ritorno
         {
             // Restituisce una risposta di testo semplice
             return response('Hello ServBay & Webman!'); // Messaggio di benvenuto aggiornato
         }
     }

   • app/controller/CacheController.php — Esempio di utilizzo di Memcached e Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Importa la classe Memcached
     use support\Redis; // Importa la Facade Redis fornita da Webman
     
     class CacheController
     {
         /**
          * Esempio di utilizzo di Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Connessione al server Memcached, configurazione predefinita 127.0.0.1:11211 in ServBay
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Imposta una voce nella cache, valida per 60 secondi
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Imposta chiave e valore aggiornati
             if (!$success) {
                  return response('Impossibile impostare la chiave Memcached', 500);
             }
     
             // Recupera la voce dalla cache
             $value = $memcached->get('servbay_key'); // Chiave aggiornata
     
             // Restituisce il valore ottenuto
             return response($value ?: 'Chiave Memcached non trovata o scaduta'); // Messaggio se la chiave manca o è scaduta
         }
     
         /**
          * Esempio di utilizzo di Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Usa la Facade Redis di Webman per impostare una voce nella cache
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Chiave e valore aggiornati
     
             // Recupera la voce dalla cache Redis
             $value = Redis::get('servbay_redis_key'); // Chiave aggiornata
     
             // Restituisce il valore ottenuto
             return response($value ?: 'Chiave Redis non trovata'); // Messaggio se la chiave manca
         }
     }

   • app/controller/DatabaseController.php — Esempio di operazioni su database MySQL e PostgreSQL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Importa la Facade Db di Webman
     
     class DatabaseController
     {
         /**
          * Aggiunge un utente al database MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Usa la Facade Db per connettersi a 'mysql' e inserire i dati
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Nome di esempio aggiornato
                     'email' => '[email protected]', // Email di esempio aggiornata
                     'created_at' => date('Y-m-d H:i:s') // Timestamp
                 ]);
                 return response('Utente aggiunto su MySQL'); // Messaggio di esito
             } catch (\Exception $e) {
                 return response('Errore durante l\'aggiunta di utente su MySQL: ' . $e->getMessage(), 500); // Gestione errori
             }
         }
     
         /**
          * Recupera la lista utenti dal database MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Connessione a 'mysql' e recupero degli utenti
                 $users = Db::connection('mysql')->table('users')->get();
                 // Ritorna la lista utenti in formato JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type esplicito
             } catch (\Exception $e) {
                  return response('Errore durante il recupero degli utenti da MySQL: ' . $e->getMessage(), 500); // Gestione errori
             }
         }
     
         /**
          * Aggiunge un utente al database PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Usa la Facade Db per connettersi a 'pgsql' e inserire i dati
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Nome di esempio aggiornato
                     'email' => '[email protected]', // Email di esempio aggiornata
                     'created_at' => date('Y-m-d H:i:s') // Timestamp
                 ]);
                 return response('Utente aggiunto su PostgreSQL'); // Messaggio di esito
              } catch (\Exception $e) {
                 return response('Errore durante l\'aggiunta di utente su PostgreSQL: ' . $e->getMessage(), 500); // Gestione errori
              }
         }
     
         /**
          * Recupera la lista utenti dal database PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Connessione a 'pgsql' e recupero degli utenti
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Ritorna la lista utenti in formato JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type esplicito
              } catch (\Exception $e) {
                 return response('Errore durante il recupero degli utenti da PostgreSQL: ' . $e->getMessage(), 500); // Gestione errori
              }
         }
     }

3. Configurare la connessione ai database

   Modifica il file config/database.php nella root del progetto per impostare le connessioni a MySQL e PostgreSQL. Il server database di ServBay utilizza di default 127.0.0.1 come host, porta 3306 per MySQL e 5432 per PostgreSQL; la password per l’utente root è password.

   <?php
   /**
    * Configurazione database
    */
   return [
       // Connessione database predefinita
       'default' => 'mysql',
   
       // Elenco delle configurazioni di connessione
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Host e porta predefiniti di ServBay per MySQL
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nome del database precedentemente creato
               'database'  => 'webman_app',
               // Nome utente di default di ServBay
               'username'  => 'root',
               // Password di default di ServBay
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Host e porta predefiniti di ServBay per PostgreSQL
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nome del database precedentemente creato
               'database' => 'webman_app',
                // Nome utente di default di ServBay
               'username' => 'root',
                // Password di default di ServBay
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // Oppure require, verify-ca, verify-full
           ],
           // Qui puoi aggiungere altre connessioni...
       ],
   ];

   Attenzione: In ambiente di produzione, è fondamentale cambiare la password predefinita e evitare di inserire credenziali sensibili direttamente nel codice.

Avviare il progetto Webman

I progetti Webman si avviano di solito tramite lo script start.php, che lancia i processi Workerman. Diversamente dal modello classico Nginx/Apache + PHP-FPM, Webman opera come applicazione asincrona residente in memoria.

Dalla cartella progetto (/Applications/ServBay/www/servbay-webman-app), avvia il progetto Webman con il seguente comando:

php start.php start

Vedrai i messaggi di avvio di Webman; di default il server HTTP sarà in ascolto su 127.0.0.1:8787.

• Nota: Il comando php utilizza la versione fornita da ServBay. ServBay predispone automaticamente il tuo terminale per usare la versione PHP installata.
• Puoi avviare Webman in background utilizzando il parametro -d: php start.php start -d.
• Per fermare il servizio Webman, esegui: php start.php stop.
• Per riavviare Webman: php start.php restart.
• Per un riavvio soft (senza interrompere le richieste in corso): php start.php reload.

Testare il progetto

Dopo l’avvio, Webman ascolta su 127.0.0.1:8787. Puoi testare le varie funzionalità visitando le seguenti URL nel browser:

• http://localhost:8787/: visualizzerai la stringa Hello ServBay & Webman!.
• http://localhost:8787/memcached: visualizzerai Hello Memcached from ServBay!, indicando il funzionamento corretto di Memcached con Webman.
• http://localhost:8787/redis: visualizzerai Hello Redis from ServBay!, a conferma della connessione riuscita a Redis.
• http://localhost:8787/mysql-add: visualizzerai Utente aggiunto su MySQL e verrà inserita una riga nella tabella users del database MySQL.
• http://localhost:8787/mysql: vedrai una risposta JSON con la lista utenti della tabella users su MySQL.
• http://localhost:8787/pgsql-add: visualizzerai Utente aggiunto su PostgreSQL e verrà inserita una riga nella tabella users su PostgreSQL.
• http://localhost:8787/pgsql: troverai la lista utenti della tabella users di PostgreSQL in formato JSON.

In caso di problemi con queste URL, controlla l’output del terminale di Webman per eventuali errori e verifica che i pacchetti MySQL, PostgreSQL, Redis, Memcached risultino attivi in ServBay e che le estensioni PHP necessarie siano abilitate.

Domande Frequenti (FAQ)

• D: Il comando php start.php start non viene trovato?
  • R: Assicurati di aver eseguito il comando cd nella cartella del progetto servbay-webman-app. Verifica inoltre che il PHP installato da ServBay sia stato aggiunto correttamente al PATH di sistema (normalmente gestito automaticamente da ServBay).
• D: Errore di connessione a localhost:8787?
  • R: Controlla l'output del terminale dove hai eseguito php start.php start per eventuali errori. Accertati che la porta 8787 non sia utilizzata da altri programmi. Se necessario, puoi cambiare la porta modificando il file di configurazione (ad esempio in config/server.php).
• D: Fallimento della connessione al database?
  • R: Controlla che i pacchetti MySQL e PostgreSQL siano in esecuzione su ServBay. Verifica che le impostazioni in config/database.php (host, porta, nome database, utente e password) siano coerenti con quanto impostato in ServBay (utente predefinito root, password password). Accertati di aver creato il database webman_app e la tabella users.
• D: Errore di connessione a Memcached o Redis?
  • R: Verifica che i pacchetti Memcached e Redis siano attivi su ServBay. Controlla che gli indirizzi e le porte nei file di controller (app/controller/CacheController.php) siano corretti (127.0.0.1:11211 per Memcached, 127.0.0.1:6379 per Redis). Assicurati che le estensioni PHP memcached e redis siano attive.

Conclusione

Seguendo questi passaggi, hai creato, configurato e avviato con successo un progetto Webman di base nell’ambiente di sviluppo locale ServBay. Hai imparato a sfruttare i servizi integrati di ServBay per configurare velocemente Webman integrando database e memorie cache. L’unione della potenza di Webman con la praticità di ServBay offre un supporto eccellente per lo sviluppo di applicazioni PHP asincrone ad alte prestazioni. Speriamo che questa guida ti aiuti a sfruttare al meglio ServBay e Webman per creare applicazioni web di qualità.