Creare ed Eseguire un Progetto Symfony

ServBay è un ambiente di sviluppo web locale progettato specificamente per macOS. Integra diversi runtime come PHP, Node.js, Python, Go, Java, oltre a database come MySQL, PostgreSQL, MongoDB, Redis e supporta sia il server web Apache che Caddy. In questa guida scoprirai come configurare ed eseguire rapidamente un progetto Symfony su macOS utilizzando ServBay.

Cos’è Symfony?

Symfony è un framework web open source PHP sviluppato da SensioLabs, pensato per offrire agli sviluppatori una serie di strumenti efficienti, flessibili e potenti per costruire applicazioni web moderne e API. Segue le migliori pratiche standard del web e mette a disposizione una vasta gamma di componenti, tra cui routing, motore di templating (Twig), gestione dei form, autenticazione, dependency injection e altro ancora, semplificando notevolmente le attività di sviluppo web più comuni.

Caratteristiche Principali e Vantaggi di Symfony

Design modulare: Il cuore di Symfony è la sua libreria di componenti riutilizzabili. Gli sviluppatori possono scegliere e utilizzare i componenti necessari, costruendo applicazioni da leggere a complesse.
Prestazioni elevate: Symfony offre ottime prestazioni grazie alla sua architettura ottimizzata, efficaci meccanismi di caching e supporto alle più recenti funzionalità PHP.
Solida community: Vanta una vasta community di sviluppatori, moltissimi bundle (plugin) di terze parti e documentazione dettagliata. Trovare soluzioni ai problemi è semplice.
Flessibilità: Facilmente integrabile con librerie e estensioni di terze parti, adatto a progetti di qualsiasi dimensione e complessità.
Stabilità e manutenibilità: Rispetta standard di codifica e design pattern di qualità, rendendo le applicazioni semplici da testare, mantenere ed espandere.

Symfony è la scelta ideale per la realizzazione di web project che vanno da piccole API a grandi sistemi aziendali.

Creare ed Eseguire un Progetto Symfony con ServBay

ServBay offre un supporto completo all’esecuzione di progetti Symfony, mettendo a disposizione le versioni PHP necessarie, Composer, server web, diversi database e servizi di caching. Questa sezione ti guiderà nella creazione e configurazione di un nuovo progetto Symfony sfruttando le funzionalità di ServBay.

Prerequisiti

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

Installazione di ServBay: ServBay deve essere installato e avviato con successo su macOS. In caso contrario, consulta la Guida all’installazione di ServBay.
ServBay funzionante: I servizi principali di ServBay (ad esempio Caddy o Apache, e i database necessari) devono essere attivi.
Conoscenze di base: È consigliato avere una comprensione di base di PHP, Composer e dei concetti fondamentali di Symfony.

Creazione di un Progetto Symfony

ServBay consiglia di archiviare tutti i progetti web nella cartella /Applications/ServBay/www, facilitando riconoscimento e gestione.

Verifica disponibilità di Composer
Composer è già incluso con ServBay e configurato nell’ambiente: non serve alcuna installazione aggiuntiva. Puoi verificare la disponibilità con il comando: composer --version
Crea la cartella del progetto
All’interno della directory consigliata, crea una nuova cartella per il tuo progetto Symfony:
bash
```
cd /Applications/ServBay/www
mkdir servbay-symfony-app
```
1
2
Crea il progetto Symfony tramite Composer
Entra nella cartella appena creata e utilizza Composer per generare la base del progetto con website-skeleton, adatta alle classiche web app.
bash
```
cd /Applications/ServBay/www/servbay-symfony-app
composer create-project symfony/website-skeleton .
```
1
2
Questo comando scaricherà Symfony e tutte le sue dipendenze nella directory corrente.

Configurazione Iniziale

I parametri principali dei progetti Symfony vengono gestiti tramite variabili d’ambiente, tipicamente raccolte nel file .env nella root del progetto.

Configura le variabili d’ambiente (.env)
Apri il file .env in root del progetto. Qui vengono impostati parametri cruciali come le informazioni di collegamento a database, chiavi segrete e altre configurazioni. Modifica o aggiungi ciò che serve in base alle tue necessità.
Verifica che le seguenti impostazioni siano coerenti con il tuo ambiente ServBay:
dotenv
```
# Esempio di file .env
APP_ENV=dev # Ambiente di sviluppo
APP_SECRET=your_secret_key # Sostituisci con una stringa unica e casuale

# Configurazione database (esempi: MySQL o PostgreSQL, vedi dettagli sotto)
# DATABASE_URL="mysql://db_user:[email protected]:3306/db_name?serverVersion=8.0&charset=utf8mb4"
# DATABASE_URL="postgresql://db_user:[email protected]:5432/db_name?serverVersion=13&charset=utf8"
# DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"
```
1
2
3
4
5
6
7
8
Sostituisci your_secret_key con una stringa sicura. Per la connessione al database, i dati di default ServBay sono di solito: utente root, password password ‒ da modificare assolutamente in produzione. Nell’esempio useremo servbay_symfony_app come nome del database.

Configurare il Server Web (Sito ServBay)

Per accedere via browser al tuo progetto Symfony, usa la funzione "Sito" di ServBay per impostare un virtual host locale. La root del sito in Symfony è sempre la cartella public/ all’interno del progetto.

Apri il pannello di controllo di ServBay, vai su “Siti” (o "Host" nelle versioni precedenti) e aggiungi un nuovo sito:

Nome: per esempio My Symfony Dev Site
Dominio: imposta un dominio locale, es. servbay-symfony-test.local (ServBay lo risolverà automaticamente)
Tipo di sito: seleziona PHP
Versione PHP: scegli quella compatibile con il tuo progetto Symfony, consigliato PHP 8.3
Root del sito: per Symfony deve puntare a /Applications/ServBay/www/servbay-symfony-app/public

Dopo la configurazione, salva e applica le modifiche. ServBay aggiornerà le impostazioni del server web e genererà automaticamente i certificati SSL per il dominio locale, permettendoti di accedere direttamente via HTTPS.

Consulta i dettagli in Aggiungi il primo sito con ServBay.

Aggiungi Codice di Esempio

Per verificare la corretta configurazione, aggiungiamo una semplice route e un controller che restituisca del testo all’accesso della root del sito.

Definisci la route (config/routes.yaml)

Apri config/routes.yaml e aggiungi:

yaml

# config/routes.yaml
index:
    path: /
    controller: App\Controller\DefaultController::index

Crea il controller (src/Controller/DefaultController.php)

Crea un nuovo file in src/Controller/ chiamato DefaultController.php con:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class DefaultController
{
    /**
     * @Route("/", name="index")
     */
    public function index(): Response
    {
        // Restituisce una risposta HTTP semplice
        return new Response('Hello ServBay and Symfony!');
    }
}

Questo controller associa il metodo index alla root / tramite annotazione @Route("/"). Visitando la root riceverai il messaggio “Hello ServBay and Symfony!”.

Visita il Sito

Ora puoi visitare nel browser il dominio che hai configurato, ad esempio: https://servbay-symfony-test.local. Se tutto è andato a buon fine, vedrai:

Hello ServBay and Symfony!

Questo conferma che il tuo progetto Symfony sta funzionando correttamente tramite ServBay. Ricorda che ServBay gestisce automaticamente HTTPS, quindi usa sempre https://.

Esempi di Database e Cache

Symfony normalmente usa Doctrine ORM per database relazionali e Symfony Cache per la gestione della cache e database NoSQL. ServBay mette a disposizione numerosi servizi di database e le relative estensioni PHP, consentendoti un'integrazione agevole.

Esempio con Database Relazionali (Doctrine ORM)

ServBay supporta MySQL e PostgreSQL. Vediamo come configurare ed usare entrambi in Symfony.

Configura la connessione al database
Modifica il file .env nella root del progetto commentando la variabile DATABASE_URL in base al database che desideri usare.
- Per MySQL: Utente di default ServBay: root, password: password, porta: 3306.
  dotenv
```
# .env
DATABASE_URL="mysql://root:[email protected]:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"
```
  1
  2
- Per PostgreSQL: Utente di default ServBay: root, password: password, porta: 5432.
  dotenv
```
# .env
DATABASE_URL="postgresql://root:[email protected]:5432/servbay_symfony_app?serverVersion=13&charset=utf8"
```
  1
  2
Assicurati che il servizio MySQL o PostgreSQL sia attivo dal pannello di ServBay.
Crea il database
Se il database servbay_symfony_app non esiste, crealo tramite strumenti come phpMyAdmin, pgAdmin (entrambi accessibili da ServBay) oppure via Symfony:
bash
```
php bin/console doctrine:database:create
```
1
Crea Entity e file di Migration
Con Doctrine puoi rappresentare tabelle tramite “Entity”. Il Maker Bundle aiuta a generarli rapidamente.
- Crea un Entity (ad esempio User):
  bash
```
php bin/console make:entity User
```
  1
  Aggiungi i campi richiesti, es. name (string) e email (string, unique=yes).
- Genera migration:
  bash
```
php bin/console make:migration
```
  1
  Questo comando genererà uno script SQL di migration nella cartella src/Migrations.
Esegui la migration
Applica la struttura del database generata tramite:
bash
```
php bin/console doctrine:migrations:migrate
```
1

Aggiungi esempio di interazione col database

Modifica src/Controller/DefaultController.php per aggiungere route e metodi di esempio per scrittura e lettura tramite Doctrine, iniettando EntityManagerInterface.

Nel costruttore di DefaultController, inserisci l’iniezione di EntityManagerInterface:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface; // Importa EntityManagerInterface
use App\Entity\User; // Importa la classe Entity User
use Symfony\Component\HttpFoundation\JsonResponse; // Per risposte JSON

class DefaultController
{
    private $entityManager;

    // Dependency injection di EntityManagerInterface
    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

    /**
     * @Route("/", name="app_index")
     */
    public function index(): Response
    {
        return new Response('Hello ServBay and Symfony!');
    }

    // ... altri metodi ...
}

Aggiorna config/routes.yaml aggiungendo le nuove route:

yaml

# config/routes.yaml
# ... altre route ...
mysql_add_user:
    path: /mysql-add-user # oppure /pgsql-add-user se usi PostgreSQL
    controller: App\Controller\DefaultController::addUser
mysql_get_users:
    path: /mysql-users # oppure /pgsql-users
    controller: App\Controller\DefaultController::getUsers

Aggiungi nei controller i seguenti metodi di esempio:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\User;
use Symfony\Component\HttpFoundation\JsonResponse; // Importa JsonResponse

class DefaultController
{
    private $entityManager;

    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

    /**
     * @Route("/", name="app_index")
     */
    public function index(): Response
    {
        return new Response('Hello ServBay and Symfony!');
    }

    /**
     * @Route("/add-user", name="app_add_user")
     */
    public function addUser(): Response
    {
        $user = new User();
        // Esempio dati legati a ServBay
        $user->setName('ServBay Demo User');
        $user->setEmail('[email protected]');

        // Persistenza dell’oggetto
        $this->entityManager->persist($user);
        // Salva effettivamente nel DB
        $this->entityManager->flush();

        return new Response('User aggiunto con successo!');
    }

    /**
     * @Route("/get-users", name="app_get_users")
     */
    public function getUsers(): JsonResponse
    {
        // Recupera tutti i record User
        $users = $this->entityManager->getRepository(User::class)->findAll();

        // Trasforma in array per la risposta JSON
        $usersArray = [];
        foreach ($users as $user) {
            $usersArray[] = [
                'id' => $user->getId(),
                'name' => $user->getName(),
                'email' => $user->getEmail(),
            ];
        }

        // Risposta in formato JSON
        return new JsonResponse($usersArray);
    }
}

Prova le route di esempio
- Visita https://servbay-symfony-test.local/add-user per aggiungere un utente.
- Visita https://servbay-symfony-test.local/get-users per vedere la lista utenti (in formato JSON).

Esempio di Cache e NoSQL (Symfony Cache)

ServBay integra Redis e Memcached e le rispettive estensioni PHP. Puoi usare Symfony Cache per sfruttarli senza sforzo.

Configura la connessione cache
Nel file .env configura la connessione:
- Per Memcached: Porta predefinita ServBay: 11211
  dotenv
```
# .env
# ... altre configurazioni ...
CACHE_DSN=memcached://127.0.0.1:11211
```
  1
  2
  3
  Verifica dal pannello di controllo che il servizio sia avviato.
- Per Redis: Porta predefinita ServBay: 6379
  dotenv
```
# .env
# ... altre configurazioni ...
CACHE_DSN=redis://127.0.0.1:6379
# Se Redis ha password (di default su ServBay non ne ha)
# CACHE_DSN=redis://:[email protected]:6379
```
  1
  2
  3
  4
  5
  Anche qui verifica che Redis sia avviato da ServBay.

Aggiungi esempio d’uso della cache

Modifica src/Controller/DefaultController.php per aggiungere una route e un metodo che usano Symfony Cache via CacheInterface.

Nel costruttore di DefaultController, inietta CacheInterface:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\User;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Contracts\Cache\CacheInterface; // Importa CacheInterface

class DefaultController
{
    private $entityManager;
    private $cache; // Proprietà cache

    // Inietta CacheInterface nel costruttore
    public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
    {
        $this->entityManager = $entityManager;
        $this->cache = $cache;
    }

    // ... altri metodi ...
}

Aggiungi la nuova route in config/routes.yaml:

yaml

# config/routes.yaml
# ... altre route ...
cache_example:
    path: /cache-example
    controller: App\Controller\DefaultController::cacheExample

Nel controller, implementa il metodo d’esempio:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\User;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Component\Cache\Item\ItemInterface; // Importa ItemInterface

class DefaultController
{
    private $entityManager;
    private $cache;

    public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
    {
        $this->entityManager = $entityManager;
        $this->cache = $cache;
    }

    // ... altri metodi ...

    /**
     * @Route("/cache-example", name="app_cache_example")
     */
    public function cacheExample(): Response
    {
        // Prova a ottenere dati dalla cache
        $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
            // Questo viene eseguito se la cache è vuota
            $item->expiresAfter(3600); // Scadenza un’ora

            // Simula una operazione costosa, per esempio una query complessa
            $data = "Dati generati il " . date('Y-m-d H:i:s');

            // Ritorna i dati da salvare
            return $data;
        });

        // $cacheItem: dati recuperati dalla cache o appena generati
        $output = "From Cache: " . $cacheItem;

        return new Response($output);
    }
}

Prova la route
- Vai su https://servbay-symfony-test.local/cache-example. Al primo accesso i dati verranno generati e messi in cache; nei successivi verranno presi direttamente da Memcached o Redis finché la cache non scade.

Domande Frequenti (FAQ)

D: Quando apro https://servbay-symfony-test.local vedo errore a pagina non trovata o errore 500. Che fare?

R: Verifica i seguenti punti:

Che ServBay sia realmente in esecuzione e il servizio web (Caddy o Apache) sia attivo.
Che la configurazione del sito in ServBay sia corretta: dominio servbay-symfony-test.local e "root del sito" impostata su /Applications/ServBay/www/servbay-symfony-app/public.
Controlla il file log di Symfony (var/log/dev.log) per dettagli sull’errore.
Esegui in root progetto composer install per assicurarti che tutte le dipendenze siano installate.
Verifica che la versione PHP sia compatibile con il progetto Symfony.

D: Errore di connessione al database. Come risolvere?

R: Controlla:

Che il database scelto (MySQL o PostgreSQL) sia avviato da ServBay.
Che la stringa DATABASE_URL nel file .env abbia nome utente, password, host (127.0.0.1), porta (MySQL: 3306, PostgreSQL: 5432) e nome DB corretti.
Che user e password corrispondano ai valori di default ServBay, o a quelli personalizzati.
Che il database servbay_symfony_app esista.

D: Il comando php bin/console non funziona.

R: Assicurati di aprire il terminale nella cartella /Applications/ServBay/www/servbay-symfony-app e che la versione di PHP fornita da ServBay sia nel PATH di sistema (di solito viene configurata automaticamente durante l’installazione). Puoi accertarti con il comando which php che venga usata la versione di ServBay.

Conclusioni

Seguendo questa guida, hai creato, configurato e avviato correttamente un progetto base Symfony su macOS utilizzando ServBay. ServBay fornisce tutti i componenti chiave per Symfony (PHP, Composer, server web, database, cache) e semplifica notevolmente tutta la fase di setup ambiente, consentendoti di concentrarti unicamente sullo sviluppo dell’applicazione. Puoi adesso continuare ad approfondire Symfony e sfruttare gli altri servizi messi a disposizione da ServBay.

Creare ed Eseguire un Progetto Symfony ​

Cos’è Symfony? ​

Caratteristiche Principali e Vantaggi di Symfony ​

Creare ed Eseguire un Progetto Symfony con ServBay ​

Prerequisiti ​

Creazione di un Progetto Symfony ​

Configurazione Iniziale ​

Configurare il Server Web (Sito ServBay) ​

Aggiungi Codice di Esempio ​

Visita il Sito ​

Esempi di Database e Cache ​

Esempio con Database Relazionali (Doctrine ORM) ​

Esempio di Cache e NoSQL (Symfony Cache) ​

Domande Frequenti (FAQ) ​

Conclusioni ​

Creare ed Eseguire un Progetto Symfony

Cos’è Symfony?

Caratteristiche Principali e Vantaggi di Symfony

Creare ed Eseguire un Progetto Symfony con ServBay

Prerequisiti

Creazione di un Progetto Symfony

Configurazione Iniziale

Configurare il Server Web (Sito ServBay)

Aggiungi Codice di Esempio

Visita il Sito

Esempi di Database e Cache

Esempio con Database Relazionali (Doctrine ORM)

Esempio di Cache e NoSQL (Symfony Cache)

Domande Frequenti (FAQ)

Conclusioni