Creare ed Eseguire un Progetto Slim in ServBay

Questa guida ti spiega come creare, configurare ed eseguire rapidamente un progetto basato su PHP Slim Framework all’interno del potente ambiente di sviluppo web locale di ServBay. ServBay integra PHP, diversi web server (Caddy/Nginx/Apache) e numerosi pacchetti di database, rendendolo la piattaforma ideale per lo sviluppo con Slim.

Cos'è Slim?

Slim è un micro-framework PHP leggero progettato per realizzare rapidamente applicazioni web e API semplici ma potenti. Fornisce funzionalità di routing, gestione delle richieste e risposte essenziali, perfetto sia per progetti che necessitano uno sviluppo e una distribuzione rapidi, sia come fondamentale punto di partenza per applicazioni più complesse.

Caratteristiche Principali e Vantaggi di Slim

• Leggerezza: Il core di Slim è estremamente compatto, consuma poche risorse e si avvia velocemente. È ideale per applicazioni di piccole e medie dimensioni o microservizi.
• Flessibilità: Slim è pensato per essere modulare e facilmente integrabile con qualsiasi libreria o componente di terze parti (template engine, ORM, librerie di autenticazione ecc.), offrendo la massima libertà nello scegliere gli strumenti più adatti alle esigenze del tuo progetto.
• Facilità d’uso: Un’API semplice e una documentazione chiara permettono agli sviluppatori di imparare velocemente i concetti chiave e iniziare subito lo sviluppo.
• Routing Potente: Supporta numerosi metodi HTTP (GET, POST, PUT, DELETE, ecc.) e configurazioni di routing avanzate, gruppi di rotte, middleware e gestione di parametri.
• Supporto Middleware: Il middleware di Slim consente di eseguire operazioni prima che la richiesta arrivi alla logica dell’applicazione o prima che la risposta venga inviata al client (ad esempio autenticazione, logging, gestione CORS e altro).

Slim è la scelta ideale per creare RESTful API, prototipi rapidi o per gestire funzionalità indipendenti e specializzate.

Creare ed Eseguire un Progetto Slim con ServBay

In questa guida sfrutteremo l'ambiente PHP preconfigurato e la funzione Siti Web di ServBay per impostare il web server e rendere accessibile il progetto Slim con semplici passaggi di configurazione.

Prerequisiti

Prima di iniziare, assicurati di aver completato questi passaggi:

1. Installa e avvia ServBay: Verifica che ServBay sia installato correttamente sul tuo sistema macOS e che l'applicazione sia in esecuzione.
2. Composer integrato: ServBay include Composer di default, quindi non è necessario installarlo separatamente.

Creazione del Progetto Slim

ServBay consiglia di organizzare tutti i progetti web nella cartella /Applications/ServBay/www per semplificarne la gestione e configurazione.

1. Accedi alla directory root dei siti di ServBay:

   cd /Applications/ServBay/www

2. Crea la directory del progetto: Crea una nuova cartella per il tuo progetto Slim.

   mkdir servbay-slim-app

3. Entra nella directory del progetto:

   cd servbay-slim-app

4. Installa Slim con Composer: Installa Slim e la sua implementazione PSR-7 tramite Composer, da dentro la cartella del progetto.

   composer require slim/slim "^4.0" slim/psr7 -W

   Questo comando scaricherà Slim e la libreria slim/psr7 nella cartella vendor del tuo progetto e genererà i file composer.json e composer.lock.

Inizializzazione dell’Applicazione Slim

1. Crea il file di ingresso: Nei progetti Slim generalmente è presente un singolo punto di ingresso, solitamente public/index.php, che gestisce tutte le richieste. Nella directory root del progetto, crea una cartella public e poi il file index.php al suo interno.

   mkdir public
   touch public/index.php

2. Modifica il file di ingresso: Apri public/index.php e aggiungi il seguente codice base per una app Slim:

   <?php
   // Carica l'autoloader di Composer
   require __DIR__ . '/../vendor/autoload.php';
   
   // Importa le interfacce PSR-7 necessarie e la classe fabrico di Slim
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Crea un’istanza dell’applicazione Slim
   $app = AppFactory::create();
   
   // Aggiunge una semplice rotta GET sul percorso '/'
   $app->get('/', function (Request $request, Response $response, $args) {
       // Scrive sul corpo della risposta
       $response->getBody()->write("Hello ServBay!");
       // Restituisce la risposta
       return $response;
   });
   
   // Avvia l’app Slim
   $app->run();

   Questo esempio imposta una Slim app minimal, definendo una rotta che risponde alle richieste GET sull’URL radice (/) con il testo "Hello ServBay!".

Configurazione del Sito Web in ServBay

Per accedere al tuo progetto Slim via browser, è necessario configurare un Sito Web in ServBay (in precedenza chiamato “host”).

1. Apri l’interfaccia dell’applicazione ServBay.
2. Vai al modulo Siti Web.
3. Clicca per aggiungere un nuovo sito web.
4. Inserisci i dati del tuo progetto:
   • Nome: My First Slim Dev Site (oppure scegli un nome preferito)
   • Dominio: servbay-slim-test.local (raccomandato l’uso di estensioni .local o .test per lo sviluppo locale)
   • Tipo di Sito Web: PHP
   • Versione PHP: seleziona la versione desiderata, ad esempio 8.3
   • Cartella Root del Sito: seleziona la cartella public del tuo progetto, cioè /Applications/ServBay/www/servbay-slim-app/public poiché l’entry point index.php di Slim si trova lì e il web server deve puntare a questa directory.
5. Salva la configurazione del sito. ServBay aggiornerà automaticamente la configurazione del server web e la renderà operativa.

Per istruzioni dettagliate sulla configurazione dei siti in ServBay, consulta Aggiungi il primo sito web.

Accedere al Tuo Sito Slim

Una volta configurato, apri il browser e visita il dominio che hai inserito, ad esempio https://servbay-slim-test.local.

Se tutto è andato a buon fine vedrai sullo schermo il messaggio Hello ServBay!. Questo conferma che il tuo progetto Slim è in esecuzione tramite il server web gestito da ServBay.

Esempi di Integrazione Database

Slim non include nativamente un livello di astrazione per database, ma può integrarsi facilmente con svariate librerie PHP per database. In questa sezione mostreremo come collegarsi a MySQL e PostgreSQL attraverso l’ORM Eloquent di Laravel (illuminate/database), oltre a esempi per Memcached e Redis.

Prerequisiti: Creazione del Database e Migrazioni

Prima di integrare un database, crea in ServBay il database necessario e imposta la struttura delle tabelle secondo le necessità dell’applicazione.

1. Crea il database:
   • Apri l’interfaccia di ServBay e seleziona il pacchetto database che ti interessa (come MySQL o PostgreSQL).
   • Utilizza gli strumenti integrati di ServBay, come phpMyAdmin per MySQL/MariaDB o pgAdmin per PostgreSQL, oppure da terminale crea un nuovo database, ad esempio servbay_slim_app.
   • La password di default per l’utente root dei database in ServBay spesso è password; puoi confermarla o modificarla nell’interfaccia.
2. Installa e configura Phinx (strumento per le migrazioni database):
   Phinx è un diffusissimo strumento per la gestione delle migrazioni del database in PHP.
   • Dalla root del tuo progetto /Applications/ServBay/www/servbay-slim-app, installa Phinx con Composer:

     composer require robmorgan/phinx

   • Inizializza la configurazione di Phinx:

     vendor/bin/phinx init

     Questo comando crea un file phinx.yml nella root del progetto. Aprilo e configura i parametri della connessione al database, ad esempio:

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development # oppure il nome dell’ambiente desiderato
     
         development: # configura in base al tipo di database scelto
             adapter: mysql # oppure pgsql per PostgreSQL
             host: 127.0.0.1
             name: servbay_slim_app # nome del tuo database
             user: root
             pass: password # la tua password
             port: 3306 # porta predefinita di MySQL; PostgreSQL usa 5432
             charset: utf8mb4 # consigliato per MySQL
             collation: utf8mb4_unicode_ci # consigliato per MySQL
     
     version_order: creation

3. Crea una migrazione: Utilizza il comando di Phinx per creare un file di migrazione.

   vendor/bin/phinx create CreateUsersTable

   Questo comando genera un file PHP in db/migrations. Modifica il metodo change() per definire la struttura della tabella users:

   <?php
   
   declare(strict_types=1);
   
   use Phinx\Migration\AbstractMigration;
   
   final class CreateUsersTable extends AbstractMigration
   {
       /**
        * Metodo Change.
        *
        * Scrivi le tue migrazioni reversibili usando questo metodo.
        *
        * Ulteriori informazioni su come scrivere migrazioni sono disponibili qui:
        * https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
        *
        * Ricorda di chiamare "create()" o "update()" e NON "save()" quando lavori
        * con la classe Table.
        */
       public function change(): void
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string')
                 ->addColumn('email', 'string', ['unique' => true])
                 ->addTimestamps() // Aggiunge i campi created_at e updated_at
                 ->create();
       }
   }

4. Esegui la migrazione:
   Avvia il comando Phinx dalla root del progetto per creare la tabella users.

   vendor/bin/phinx migrate

   Importante: Esegui sempre questi passaggi prima di avviare gli esempi di codice con database mostrati qui sotto.

Utilizzo del Componente illuminate/database

Utilizzeremo il componente database di Laravel (illuminate/database) come ORM o builder di query.

1. Installa illuminate/database: Dalla root /Applications/ServBay/www/servbay-slim-app:

   composer require illuminate/database

2. Inizializza la connessione al database in public/index.php: Subito dopo la riga require __DIR__ . '/../vendor/autoload.php'; e prima di creare l’app Slim con $app = AppFactory::create();, inserisci il codice per configurare la connessione:

   // ... altri require e use ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // Importa Capsule Manager
   
   // Inizializza Eloquent ORM
   $capsule = new Capsule;
   
   // Aggiungi la configurazione della connessione (modifica 'driver' e i parametri se usi PostgreSQL)
   $capsule->addConnection([
       'driver' => 'mysql', // oppure 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app', // nome del database
       'username' => 'root', // username
       'password' => 'password', // password
       'charset' => 'utf8mb4', // consigliato per MySQL
       'collation' => 'utf8mb4_unicode_ci', // consigliato per MySQL
       'prefix' => '',
       // Per PostgreSQL puoi aggiungere lo schema
       // 'schema' => 'public',
   ]);
   
   // Rende Capsule globalmente accessibile
   $capsule->setAsGlobal();
   
   // Avvia Eloquent
   $capsule->bootEloquent();
   
   // ... Crea l’applicazione Slim ($app = AppFactory::create();) ...

Esempio MySQL

Supponendo che il pacchetto MySQL sia attivo in ServBay, che esista il database servbay_slim_app e la tabella users sia stata creata con Phinx, aggiungi queste rotte in public/index.php prima di $app->run();:

// ... codice di inizializzazione precedente e rotta '/' ...

use Illuminate\Database\Capsule\Manager as Capsule; // Assicurati di avere l'import corretto

// Rotta per aggiungere un utente
$app->get('/mysql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay Demo User',
            'email' => 'servbay-demo-' . time() . '@servbay.test', // Garantisce email unica
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500); // Restituisce errore
    }
    return $response;
});

// Rotta per recuperare gli utenti
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // Output JSON
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Come provare:

• Accedi a https://servbay-slim-test.local/mysql-add-user per aggiungere un utente.
• Accedi a https://servbay-slim-test.local/mysql-get-users per elencare tutti gli utenti in formato JSON.

Esempio PostgreSQL

Per l’integrazione con PostgreSQL, assicurati che il pacchetto PostgreSQL sia attivo, il database servbay_slim_app sia creato e la tabella users sia presente. In Phinx configura adapter e port su pgsql e 5432.

Nel file public/index.php, modifica la configurazione della connessione così:

$capsule->addConnection([
    'driver' => 'pgsql', // Cambia in pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // utf8 comune in PostgreSQL
    'prefix' => '',
    'schema' => 'public', // Specifica lo schema per PostgreSQL
]);
// ... il resto dell’inizializzazione Eloquent rimane invariato ...

Aggiungi le seguenti rotte prima di $app->run();:

// ... codice di inizializzazione precedente e rotta '/' ...
// ... eventuali rotte MySQL ...

use Illuminate\Database\Capsule\Manager as Capsule; // Assicurati di avere l'import corretto

// Rotta per aggiungere un utente
$app->get('/pgsql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay PG Demo User',
            'email' => 'servbay-pg-demo-' . time() . '@servbay.test', // Garantisce email unica
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Rotta per ottenere gli utenti
$app->get('/pgsql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson());
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Come provare:

• Accedi a https://servbay-slim-test.local/pgsql-add-user per aggiungere un utente su PostgreSQL.
• Accedi a https://servbay-slim-test.local/pgsql-get-users per elencare gli utenti da PostgreSQL in formato JSON.

Esempio Memcached

ServBay offre il pacchetto Memcached e l’estensione PHP ext-memcached. Basta installare una libreria client PHP, ad esempio memcached/memcached.

1. Installa il client Memcached: Dalla cartella /Applications/ServBay/www/servbay-slim-app:

   composer require memcached/memcached

2. Aggiungi la rotta Memcached in public/index.php: Prima di $app->run(); inserisci:

   // ... inizializzazione e altre rotte database ...
   
   // Rotta d'esempio per Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Crea un’istanza del client Memcached
       $memcached = new Memcached();
       // Aggiunge il server Memcached (ServBay di default ascolta su 127.0.0.1:11211)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Prova a recuperare i dati dalla cache
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Non c'è nulla in cache, genera dati e inseriscili
           $cachedData = 'Hello Memcached from ServBay! This was not cached.';
           // Salva in cache con TTL a 60 secondi
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // Dato trovato in cache, lo restituisce
           $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
       }
   
       return $response;
   });
   
   // ... $app->run();

Come provare: Visita https://servbay-slim-test.local/memcached-example. La prima volta riceverai "This was not cached.", poi (prima della scadenza della cache) "This was served from cache.".

Esempio Redis

ServBay offre il pacchetto Redis e l’estensione PHP ext-redis. Usa la libreria predis/predis come client PHP.

1. Installa il client Redis: Nella cartella /Applications/ServBay/www/servbay-slim-app:

   composer require predis/predis

2. Aggiungi la rotta Redis al file public/index.php: Prima di $app->run(); scrivi:

   // ... inizializzazione, altre rotte database e (opzionale) Memcached ...
   
   use Predis\Client as RedisClient; // Importa la classe client Predis
   
   // Rotta di esempio per Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Crea un’istanza del client Redis (ServBay di default ascolta su 127.0.0.1:6379)
           $redis = new RedisClient([
               'scheme' => 'tcp',
               'host' => '127.0.0.1',
               'port' => 6379,
           ]);
   
           $cacheKey = 'my_servbay_redis_cache_key';
           // Prova a recuperare i dati dalla cache
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Se non ci sono dati in cache, genera e imposta il valore
               $cachedData = 'Hello Redis from ServBay! This was not cached.';
               // Salva in Redis con scadenza 60 secondi
               $redis->setex($cacheKey, 60, $cachedData); // SETEX key seconds value
               $response->getBody()->write($cachedData);
           } else {
               // Se i dati sono in cache, li restituisce subito
               $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
           }
       } catch (\Exception $e) {
           // Gestisci eccezioni di connessione od operazioni Redis
           $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
           $response = $response->withStatus(500);
       }
   
       return $response;
   });
   
   // ... $app->run();

Come provare: Accedi a https://servbay-slim-test.local/redis-example. La prima visita mostra "This was not cached.", quelle successive (prima della scadenza) "This was served from cache.".

Conclusioni

Seguendo questi passaggi hai creato con successo un progetto Slim Framework nell’ambiente di sviluppo locale di ServBay, configurato le funzionalità Siti Web per ospitarlo e accedervi. Inoltre, hai imparato a integrare i vari pacchetti database e cache offerti da ServBay (MySQL, PostgreSQL, Memcached, Redis) assieme alle rispettive estensioni PHP, per collegare archivi dati e cache alla tua applicazione Slim. ServBay semplifica l’installazione e la gestione dell’ambiente locale, lasciandoti più tempo ed energie da dedicare allo sviluppo delle logiche specifiche della tua app Slim.