Creare ed Eseguire un Progetto Slim su ServBay

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

Cos'è Slim?

Slim è un microframework PHP leggero e flessibile, pensato per la creazione rapida di applicazioni web e API potenti ma semplici. Offre routing, gestione delle richieste e delle risposte come funzionalità core, il che lo rende perfetto sia per progetti da realizzare e distribuire rapidamente sia come base per applicazioni più complesse.

Caratteristiche principali e vantaggi di Slim

• Leggerezza: Il core di Slim è minimale, occupa poche risorse e garantisce un avvio veloce. È ideale per applicazioni di piccole e medie dimensioni o per microservizi.
• Flessibilità: Slim è pensato per essere modulare e può integrarsi facilmente con qualsiasi componente o libreria di terze parti (motori template, ORM, sistemi di autenticazione, ecc.), lasciandoti la libertà di scegliere gli strumenti migliori per il tuo progetto.
• Facilità d'uso: La sua API semplice e la documentazione chiara consentono agli sviluppatori di comprendere e iniziare ad usare Slim in tempi brevi.
• Routing avanzato: Supporta diversi metodi HTTP (GET, POST, PUT, DELETE, ecc.) e configurazioni di routing flessibili, inclusi raggruppamenti, parametri e middleware.
• Middleware: Lo strato middleware di Slim ti permette di eseguire azioni (come autenticazione, logging, gestione CORS) prima che la logica dell'app riceva una richiesta o prima che venga spedita una risposta al client.

Slim è la scelta ideale per la creazione di API RESTful, prototipazione rapida o l'implementazione di funzioni stand-alone e dedicate.

Creare ed Eseguire un Progetto Slim con ServBay

Questa guida sfrutta l’ambiente PHP preconfigurato su ServBay e la sua funzione Siti web per impostare il server e permettere l'accesso al progetto Slim tramite poche configurazioni.

Prerequisiti

Assicurati di aver completato questi passaggi prima di iniziare:

1. Installa ed esegui ServBay: Verifica che ServBay sia installato con successo sul tuo macOS o Windows, e che l'applicazione sia avviata.
2. ServBay include Composer: Composer è integrato di default in ServBay, non serve installarlo separatamente.

Creazione del Progetto Slim

ServBay raccomanda di organizzare tutti i progetti web nella cartella specificata di seguito, facilitando la gestione e la configurazione:

• macOS: /Applications/ServBay/www
• Windows: C:\ServBay\www

1. Accedi alla cartella principale di ServBay:

   macOS:

   cd /Applications/ServBay/www

   Windows:

   cd C:\ServBay\www

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

   mkdir servbay-slim-app

3. Accedi alla cartella del progetto:

   cd servbay-slim-app

4. Installa Slim tramite Composer: All'interno della directory del progetto, usa Composer per installare Slim e la sua implementazione PSR-7.

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

   Questo comando scarica Slim e la libreria slim/psr7 nella cartella vendor del progetto, generando i file composer.json e composer.lock.

Inizializzazione dell'Applicazione Slim

1. Crea il file di ingresso: Di solito Slim gestisce tutte le richieste tramite un singolo file d'ingresso (esempio public/index.php). Crea la directory public nella radice del progetto e 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 avviare un'app Slim:

   <?php
   // Carica file autoload di Composer
   require __DIR__ . '/../vendor/autoload.php';
   
   // Importa interfacce PSR-7 e la factory di Slim
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Crea un'istanza di Slim
   $app = AppFactory::create();
   
   // Aggiungi una rotta di base: gestisce le richieste GET alla radice '/'
   $app->get('/', function (Request $request, Response $response, $args) {
       // Scrivi contenuto nella risposta
       $response->getBody()->write("Hello ServBay!");
       // Restituisci la risposta
       return $response;
   });
   
   // Avvia l'app Slim
   $app->run();

   Questo codice avvia una semplice applicazione Slim che risponde alle richieste GET alla URL principale (/) restituendo il testo "Hello ServBay!".

Configurazione del Sito in ServBay

Per accedere al progetto Slim dal browser, devi configurare un Sito web in ServBay (chiamato “Host” nelle versioni precedenti).

1. Apri l'interfaccia dell'app ServBay.
2. Vai alla sezione Siti web.
3. Clicca su “Aggiungi nuovo sito web”.
4. Compila la configurazione in base al tuo progetto:

   • Nome: My First Slim Dev Site (oppure scegli ciò che preferisci)

   • Dominio: servbay-slim-test.local (si raccomanda un dominio .local o .test per sviluppo locale)

   • Tipo di sito: PHP

   • Versione PHP: seleziona quella desiderata, es. 8.3.

   • Radice del sito (Document Root): naviga e scegli la directory public del progetto:

     • macOS: /Applications/ServBay/www/servbay-slim-app/public
     • Windows: C:\ServBay\www\servbay-slim-app\public

     Questo perché il file principale index.php di Slim si trova nella cartella public, e il server web deve indirizzare lì le richieste.

5. Salva la configurazione. ServBay aggiornerà automaticamente i settaggi del server web.

Per una guida dettagliata a questa procedura, consulta Aggiungi il primo sito web.

Accedi al tuo sito Slim

Dopo la configurazione, apri il browser e visita il dominio scelto, ad esempio: https://servbay-slim-test.local.

Se tutto è corretto, dovresti vedere la pagina con la scritta Hello ServBay!. Questo conferma che il tuo progetto Slim è attivo tramite il web server di ServBay.

Esempi di Integrazione Database

Slim Framework non offre un layer di astrazione per i database, ma puoi integrarlo facilmente con le librerie PHP dedicate. Qui usiamo Eloquent ORM di Laravel (tramite il componente illuminate/database) per mostrare come collegarsi a MySQL e PostgreSQL, oltre ad esempi pratici per Memcached e Redis.

Prerequisiti: creazione database e migrazione

Prima di integrare un database, crea la struttura necessaria direttamente da ServBay.

1. Crea il database:
   • Apri ServBay, vai alle sezione dei pacchetti database (come MySQL o PostgreSQL).
   • Usa gli strumenti di gestione offerti (phpMyAdmin per MySQL/MariaDB, pgAdmin per PostgreSQL) o client da terminale per creare il database, ad esempio chiamandolo servbay_slim_app.
   • Di default, la password per l’utente root del database per ServBay è solitamente password; puoi comunque verificarla o cambiarla dalle impostazioni.
2. Installa e configura Phinx (tool migrazioni DB): Phinx ti aiuta a gestire le versioni della struttura database.
   • Nella root del progetto, installa Phinx con Composer:
     • macOS: /Applications/ServBay/www/servbay-slim-app
     • Windows: C:\ServBay\www\servbay-slim-app

     composer require robmorgan/phinx

   • Inizializza la configurazione di Phinx:

     vendor/bin/phinx init

     Verrà creato il file phinx.yml: modificalo così da includere i parametri del tuo database:

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development # oppure come preferisci
     
         development: # configura secondo il DB usato
             adapter: mysql # oppure pgsql
             host: 127.0.0.1
             name: servbay_slim_app # nome database scelto
             user: root
             pass: password # password del database
             port: 3306 # porta predefinita MySQL, PostgreSQL è 5432
             charset: utf8mb4 # consigliato per MySQL
             collation: utf8mb4_unicode_ci # consigliato per MySQL
     
     version_order: creation

3. Crea il file di migrazione: Usa Phinx per generare una nuova migrazione:

   vendor/bin/phinx create CreateUsersTable

   Troverai un file PHP nella directory db/migrations. Aprilo e definisci la tabella users nel metodo change():

   <?php
   
   declare(strict_types=1);
   
   use Phinx\Migration\AbstractMigration;
   
   final class CreateUsersTable extends AbstractMigration
   {
       /**
        * Change Method.
        *
        * Scrivi qui le tue migrazioni reversibili.
        *
        * Maggiori info qui: https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
        *
        * Ricorda di usare "create()" o "update()" e NON "save()" 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: Lanciando Phinx dalla root del progetto creerai la tabella users.

   vendor/bin/phinx migrate

   Attenzione: Prima di eseguire gli esempi di codice, assicurati che il database sia configurato correttamente.

Utilizzo del componente illuminate/database

Usiamo Eloquent ORM tramite illuminate/database per la gestione del database.

1. Installa illuminate/database: Scaricalo nella root del progetto:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require illuminate/database

2. Inizializza la connessione in public/index.php: Subito dopo require __DIR__ . '/../vendor/autoload.php'; e prima di $app = AppFactory::create();, aggiungi:

   // ... altri require e use ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // importa Capsule
   
   // Inizializza Eloquent ORM
   $capsule = new Capsule;
   
   // Configura la connessione al database (modifica 'driver' se necessario)
   $capsule->addConnection([
       'driver' => 'mysql', // oppure 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app', // nome database
       'username' => 'root',
       'password' => 'password',
       'charset' => 'utf8mb4', // consigliato per MySQL
       'collation' => 'utf8mb4_unicode_ci', // consigliato per MySQL
       'prefix' => '',
       // Per PostgreSQL, aggiungi schema:
       // 'schema' => 'public',
   ]);
   
   // Rende Capsule utilizzabile globalmente
   $capsule->setAsGlobal();
   
   // Avvia Eloquent
   $capsule->bootEloquent();
   
   // ... prosegui con la creazione app Slim ...

Esempio MySQL

Supponendo che tu abbia attivato il pacchetto MySQL su ServBay, creato il database e la tabella users, aggiungi queste rotte nel file public/index.php prima di $app->run();:

// ... init precedente e rotta '/' ...

use Illuminate\Database\Capsule\Manager as Capsule; // importa Capsule

// 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', // usa time() per unicità
            '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);
    }
    return $response;
});

// Rotta per ottenere utenti
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // risultato in 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 accedere:

• Vai su https://servbay-slim-test.local/mysql-add-user per aggiungere un utente nella tabella users.
• Vai su https://servbay-slim-test.local/mysql-get-users per ottenere tutti gli utenti in formato JSON.

Esempio PostgreSQL

Se preferisci PostgreSQL e hai configurato il pacchetto, database e tabella (users), aggiorna la configurazione cambiando driver in pgsql e aggiungi il parametro schema:

$capsule->addConnection([
    'driver' => 'pgsql',
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // di solito per PostgreSQL
    'prefix' => '',
    'schema' => 'public', // richiesto da PostgreSQL
]);
// ... resto della configurazione come sopra ...

Aggiungi queste rotte sempre prima di $app->run(); nel file public/index.php:

// ... init precedente, rotta '/', rotte MySQL se servono ...

use Illuminate\Database\Capsule\Manager as Capsule; // importa Capsule

// Rotta per aggiungere utente PostgreSQL
$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',
            '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 PostgreSQL
$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 accedere:

• Vai su https://servbay-slim-test.local/pgsql-add-user per aggiungere un utente in PostgreSQL.
• Vai su https://servbay-slim-test.local/pgsql-get-users per visualizzare tutti gli utenti in formato JSON.

Esempio Memcached

ServBay offre il pacchetto Memcached e l'estensione PHP ext-memcached. Installa il client PHP memcached/memcached.

1. Installa la libreria client: Scarica il pacchetto dalla root del progetto:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require memcached/memcached

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

   // ... init, rotte db ...
   
   // Rotta esempio Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Crea istanza Memcached
       $memcached = new Memcached();
       // Aggiungi server Memcached (default ServBay: 127.0.0.1:11211)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Prova a leggere dalla cache
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Se la cache è vuota, genera e salva il dato
           $cachedData = 'Hello Memcached from ServBay! This was not cached.';
           // Salva in cache per 60 secondi
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // Se la cache c'è, usa il dato in cache
           $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
       }
   
       return $response;
   });
   
   // ... $app->run();

Come accedere: Visita https://servbay-slim-test.local/memcached-example. La prima volta vedrai "This was not cached.", le volte successive "This was served from cache." finché il dato non scade.

Esempio Redis

ServBay include Redis e l'estensione PHP ext-redis. Installa un client PHP come predis/predis.

1. Installa la libreria client: Scaricala dalla root del progetto:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require predis/predis

2. Aggiungi la rotta Redis: Prima di $app->run(); inserisci:

   // ... init, rotte db, rotte Memcached se vuoi ...
   
   use Predis\Client as RedisClient; // importa Predis
   
   // Rotta esempio Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Crea un client Redis (default ServBay: 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 leggere dalla cache
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Se la cache è vuota, genera e salva il dato
               $cachedData = 'Hello Redis from ServBay! This was not cached.';
               // Salva in cache per 60 secondi
               $redis->setex($cacheKey, 60, $cachedData); // SETEX key seconds value
               $response->getBody()->write($cachedData);
           } else {
               // Se la cache c'è, usa il dato in cache
               $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
           }
       } catch (\Exception $e) {
           // Gestione errori di connessione o operazioni
           $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
           $response = $response->withStatus(500);
       }
   
   
       return $response;
   });
   
   // ... $app->run();

Come accedere: Vai su https://servbay-slim-test.local/redis-example. La prima richiesta mostra "This was not cached.", poi "This was served from cache." finché non scade.

Conclusione

Seguendo questi passaggi, hai creato un progetto Slim Framework PHP su ServBay, configurato il sito web e lo hai reso accessibile localmente. Hai anche imparato come integrare diversi pacchetti database e cache (MySQL, PostgreSQL, Memcached, Redis) tramite estensioni PHP, rendendo il tuo ambiente locale pronto per lo sviluppo serio di applicazioni Slim. ServBay semplifica la gestione delle componenti e ti permette di concentrarti esclusivamente sul tuo codice Slim.