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:
- Installa ed esegui ServBay: Verifica che ServBay sia installato con successo sul tuo macOS o Windows, e che l'applicazione sia avviata.
- 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
Accedi alla cartella principale di ServBay:
macOS:
bashcd /Applications/ServBay/www
1Windows:
cmdcd C:\ServBay\www
1Crea la cartella del progetto: Crea una nuova directory per il tuo progetto Slim.
bashmkdir servbay-slim-app
1Accedi alla cartella del progetto:
bashcd servbay-slim-app
1Installa Slim tramite Composer: All'interno della directory del progetto, usa Composer per installare Slim e la sua implementazione PSR-7.
bashcomposer require slim/slim "^4.0" slim/psr7 -W
1Questo comando scarica Slim e la libreria
slim/psr7
nella cartellavendor
del progetto, generando i filecomposer.json
ecomposer.lock
.
Inizializzazione dell'Applicazione Slim
- Crea il file di ingresso: Di solito Slim gestisce tutte le richieste tramite un singolo file d'ingresso (esempio
public/index.php
). Crea la directorypublic
nella radice del progetto e il fileindex.php
al suo interno.bashmkdir public touch public/index.php
1
2 - Modifica il file di ingresso: Apri
public/index.php
e aggiungi il seguente codice base per avviare un'app Slim:phpQuesto codice avvia una semplice applicazione Slim che risponde alle richieste GET alla URL principale (<?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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22/
) 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).
- Apri l'interfaccia dell'app ServBay.
- Vai alla sezione Siti web.
- Clicca su “Aggiungi nuovo sito web”.
- 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 cartellapublic
, e il server web deve indirizzare lì le richieste.- macOS:
- 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.
- 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.
- 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
bashcomposer require robmorgan/phinx
1 - macOS:
- Inizializza la configurazione di Phinx:bashVerrà creato il file
vendor/bin/phinx init
1phinx.yml
: modificalo così da includere i parametri del tuo database:yamlpaths: 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- Nella root del progetto, installa Phinx con Composer:
- Crea il file di migrazione: Usa Phinx per generare una nuova migrazione:bashTroverai un file PHP nella directory
vendor/bin/phinx create CreateUsersTable
1db/migrations
. Aprilo e definisci la tabellausers
nel metodochange()
:php<?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(); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 - Esegui la migrazione: Lanciando Phinx dalla root del progetto creerai la tabella
users
.bashAttenzione: Prima di eseguire gli esempi di codice, assicurati che il database sia configurato correttamente.vendor/bin/phinx migrate
1
Utilizzo del componente illuminate/database
Usiamo Eloquent ORM tramite illuminate/database
per la gestione del database.
Installa illuminate/database: Scaricalo nella root del progetto:
- macOS:
/Applications/ServBay/www/servbay-slim-app
- Windows:
C:\ServBay\www\servbay-slim-app
bashcomposer require illuminate/database
1- macOS:
Inizializza la connessione in
public/index.php
: Subito doporequire __DIR__ . '/../vendor/autoload.php';
e prima di$app = AppFactory::create();
, aggiungi:php// ... 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 ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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();
:
php
// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Come accedere:
- Vai su
https://servbay-slim-test.local/mysql-add-user
per aggiungere un utente nella tabellausers
. - 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
:
php
$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 ...
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
Aggiungi queste rotte sempre prima di $app->run();
nel file public/index.php
:
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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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
.
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
bashcomposer require memcached/memcached
1- macOS:
Aggiungi la rotta in
public/index.php
: Prima di$app->run();
, inserisci:php// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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
.
Installa la libreria client: Scaricala dalla root del progetto:
- macOS:
/Applications/ServBay/www/servbay-slim-app
- Windows:
C:\ServBay\www\servbay-slim-app
bashcomposer require predis/predis
1- macOS:
Aggiungi la rotta Redis: Prima di
$app->run();
inserisci:php// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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.