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:
- Installa e avvia ServBay: Verifica che ServBay sia installato correttamente sul tuo sistema macOS e che l'applicazione sia in esecuzione.
- 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.
- Accedi alla directory root dei siti di ServBay:bash
cd /Applications/ServBay/www
1 - Crea la directory del progetto: Crea una nuova cartella per il tuo progetto Slim.bash
mkdir servbay-slim-app
1 - Entra nella directory del progetto:bash
cd servbay-slim-app
1 - Installa Slim con Composer: Installa Slim e la sua implementazione PSR-7 tramite Composer, da dentro la cartella del progetto.bashQuesto comando scaricherà Slim e la libreria
composer require slim/slim "^4.0" slim/psr7 -W
1slim/psr7
nella cartellavendor
del tuo progetto e genererà i filecomposer.json
ecomposer.lock
.
Inizializzazione dell’Applicazione Slim
- 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 cartellapublic
e poi 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 una app Slim:phpQuesto esempio imposta una Slim app minimal, definendo una rotta che risponde alle richieste GET sull’URL radice (<?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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22/
) 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”).
- Apri l’interfaccia dell’applicazione ServBay.
- Vai al modulo Siti Web.
- Clicca per aggiungere un nuovo sito web.
- 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 pointindex.php
di Slim si trova lì e il web server deve puntare a questa directory.
- Nome:
- 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.
- 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.
- 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:bashcomposer require robmorgan/phinx
1 - Inizializza la configurazione di Phinx:bashQuesto comando crea un file
vendor/bin/phinx init
1phinx.yml
nella root del progetto. Aprilo e configura i parametri della connessione al database, ad esempio:yamlpaths: 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- Dalla root del tuo progetto
- Crea una migrazione: Utilizza il comando di Phinx per creare un file di migrazione.bashQuesto comando genera un file PHP in
vendor/bin/phinx create CreateUsersTable
1db/migrations
. Modifica il metodochange()
per definire la struttura della tabellausers
:php<?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(); } }
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 - Esegui la migrazione:
Avvia il comando Phinx dalla root del progetto per creare la tabellausers
.bashImportante: Esegui sempre questi passaggi prima di avviare gli esempi di codice con database mostrati qui sotto.vendor/bin/phinx migrate
1
Utilizzo del Componente illuminate/database
Utilizzeremo il componente database di Laravel (illuminate/database
) come ORM o builder di query.
Installa illuminate/database: Dalla root
/Applications/ServBay/www/servbay-slim-app
:bashcomposer require illuminate/database
1Inizializza la connessione al database in
public/index.php
: Subito dopo la rigarequire __DIR__ . '/../vendor/autoload.php';
e prima di creare l’app Slim con$app = AppFactory::create();
, inserisci il codice per configurare la connessione:php// ... 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();) ...
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 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();
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 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 ...
2
3
4
5
6
7
8
9
10
11
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();
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
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
.
Installa il client Memcached: Dalla cartella
/Applications/ServBay/www/servbay-slim-app
:bashcomposer require memcached/memcached
1Aggiungi la rotta Memcached in
public/index.php
: Prima di$app->run();
inserisci:php// ... 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();
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 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.
Installa il client Redis: Nella cartella
/Applications/ServBay/www/servbay-slim-app
:bashcomposer require predis/predis
1Aggiungi la rotta Redis al file
public/index.php
: Prima di$app->run();
scrivi:php// ... 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();
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
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.