Créer et exécuter un projet Symfony

ServBay est un environnement de développement web local conçu pour macOS et Windows. Il intègre plusieurs runtimes de langages tels que PHP, Node.js, Python, Go, Java, ainsi que des bases de données comme MySQL, PostgreSQL, MongoDB et Redis, et prend en charge les serveurs web Apache et Caddy. Ce guide détaille comment installer et lancer rapidement un projet Symfony à l’aide de ServBay sur macOS et Windows.

Qu'est-ce que Symfony ?

Symfony est un framework web PHP open-source développé par SensioLabs. Il propose aux développeurs un ensemble d’outils performants, flexibles et puissants pour créer des applications web modernes et des API. Symfony suit les bonnes pratiques du web et offre de nombreux composants, tels que le routage, le moteur de templates Twig, la gestion des formulaires, l’authentification, l’injection de dépendances, etc., facilitant grandement le développement web.

Principales caractéristiques et avantages de Symfony

Conception modulaire : Le cœur de Symfony repose sur une bibliothèque de composants réutilisables. Les développeurs sélectionnent les composants selon les besoins, afin de créer des applications légères ou complexes.
Haute performance : Grâce à une architecture optimisée, des mécanismes de cache efficaces et la compatibilité avec les dernières fonctionnalités PHP, Symfony offre d'excellentes performances.
Communauté dynamique : Une vaste communauté de développeurs, de nombreux Bundles (plugins) tiers et une documentation exhaustive permettent de trouver facilement des solutions.
Grande flexibilité : Intégration facile de bibliothèques et d’extensions tierces, adapté à des projets de toutes tailles et complexités.
Stabilité et maintenabilité : Respect des bonnes conventions de codage et des design patterns, facilitant les tests, la maintenance et l’extension des applications.

Symfony convient aussi bien au développement d’APIs légères qu’à la création de systèmes web d’entreprise complexes.

Créer et exécuter un projet Symfony avec ServBay

ServBay fournit un environnement complet pour lancer des projets Symfony, incluant les versions PHP nécessaires, Composer, les serveurs web et différents services de bases de données et de cache. Cette section vous guide pas à pas pour créer et configurer un projet Symfony avec ServBay.

Prérequis

Avant de commencer, vérifiez les éléments suivants :

Installation de ServBay : ServBay doit être installé et lancé sur votre macOS. Si ce n’est pas le cas, consultez le Guide d'installation de ServBay.
ServBay opérationnel : Ses services principaux (Caddy ou Apache, ainsi que la base de données utilisée) doivent être actifs.
Bases nécessaires : Vous devez avoir les bases sur PHP, Composer et Symfony.

Création d’un projet Symfony

Il est recommandé de rassembler vos projets web dans le dossier /Applications/ServBay/www, ce qui facilite leur gestion par ServBay.

Vérifier la disponibilité de Composer
ServBay inclut Composer et configure automatiquement les variables d’environnement, aucune installation supplémentaire n’est nécessaire. Vérifiez sa présence avec la commande composer --version dans le terminal.
Créer le dossier du projet
Dans le répertoire recommandé, créez un nouveau dossier pour votre projet Symfony :
bash
```
cd /Applications/ServBay/www
mkdir servbay-symfony-app
```
1
2
Créer le projet Symfony avec Composer
Rendez-vous dans le dossier nouvellement créé et lancez la création d’un squelette de projet basé sur website-skeleton, qui inclut les dépendances principales pour une application web standard :
bash
```
cd /Applications/ServBay/www/servbay-symfony-app
composer create-project symfony/website-skeleton .
```
1
2
Composer téléchargera le cœur de Symfony et toutes les dépendances dans ce dossier.

Configuration initiale

La configuration du projet Symfony repose généralement sur des variables d’environnement, à définir dans le fichier .env à la racine du projet.

Configurer les variables d’environnement (.env)
Ouvrez le fichier .env à la racine du projet. Ce fichier contient la configuration applicative, notamment la connexion à la base de données et la clé secrète. Modifiez-le selon vos besoins.
Assurez-vous que les paramètres suivants sont corrects par rapport à votre environnement ServBay :
dotenv
```
# Exemple de fichier .env
APP_ENV=dev # Environnement de développement
APP_SECRET=your_secret_key # Remplacez par une chaîne aléatoire unique, pour la sécurité

# Exemple de connexion à la base de données (ici MySQL, précisé plus loin)
# DATABASE_URL="mysql://db_user:db_password@127.0.0.1:3306/db_name?serverVersion=8.0&charset=utf8mb4"
# DATABASE_URL="postgresql://db_user:db_password@127.0.0.1:5432/db_name?serverVersion=13&charset=utf8"
# DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"
```
1
2
3
4
5
6
7
8
Remplacez your_secret_key par une chaîne aléatoire et sûre. Pour la base de données, l’utilisateur par défaut sur ServBay est le plus souvent root, et le mot de passe password (changez ces données en production !). Nous prendrons servbay_symfony_app comme nom de base de données d’exemple.

Configuration du serveur web (Site ServBay)

Pour accéder à votre projet Symfony depuis le navigateur, configurez un hôte virtuel local via la fonction “Site” de ServBay. Le répertoire web racine Symfony est public/.

Ouvrez le panneau de contrôle ServBay, allez sur la gestion des “Sites” (ou “Hôtes” selon la version), puis ajoutez un nouveau site :

Nom : Par exemple My Symfony Dev Site pour faciliter la reconnaissance.
Domaine : Indiquez un nom de domaine local, tel que servbay-symfony-test.local. ServBay gère l’association locale automatiquement.
Type de site : Sélectionnez PHP.
Version PHP : Choisissez la dernière version stable compatible avec Symfony, par exemple 8.3.
Répertoire racine : Point crucial : indiquez précisément le dossier public/ du projet, soit /Applications/ServBay/www/servbay-symfony-app/public.

Enregistrez la configuration et appliquez les changements : ServBay s’occupe d’actualiser le serveur web. La gestion SSL locale est automatisée (Caddy ou Apache génèrent et valident le certificat), vous pouvez donc directement accéder en HTTPS.

Pour plus de détails sur la configuration, consultez Ajouter votre premier site ServBay.

Ajouter un exemple de code de base

Pour vérifier la bonne configuration du site, créez une route et un contrôleur qui affichent un message à la racine de l’application.

Définir la route (config/routes.yaml)

Ouvrez config/routes.yaml et ajoutez :

yaml

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

Créer le contrôleur (src/Controller/DefaultController.php)

Dans le dossier src/Controller/, créez un fichier DefaultController.php avec le contenu suivant :

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
    {
        // Retourne une réponse HTTP simple
        return new Response('Hello ServBay and Symfony!');
    }
}

Ce contrôleur, nommé DefaultController, est associé à la racine / via l’annotation @Route("/") et retourne le texte "Hello ServBay and Symfony!" en réponse HTTP.

Accéder à votre site

Ouvrez votre navigateur et rendez-vous à l’adresse configurée, par exemple : https://servbay-symfony-test.local. Si tout est bien installé, vous devriez voir :

Hello ServBay and Symfony!

Cela signifie que votre projet Symfony fonctionne correctement avec le serveur web de ServBay. (L’accès en HTTPS est recommandé, car ServBay gère le certificat local automatiquement.)

Exemple de base de données et cache

Symfony utilise généralement Doctrine ORM pour les bases de données relationnelles et le composant Cache de Symfony pour la gestion du cache et des bases NoSQL. ServBay intègre divers services de bases de données et extensions PHP compatibles.

Exemple de base de données relationnelle (Doctrine ORM)

ServBay gère MySQL et PostgreSQL. Voici comment les configurer et les utiliser dans votre projet Symfony.

Configurer la connexion à la base de données
Dans le fichier .env à la racine, décommentez et modifiez la variable DATABASE_URL selon le service utilisé.
- Pour MySQL : Utilisateur par défaut : root, mot de passe password, port 3306.
  dotenv
```
# .env
DATABASE_URL="mysql://root:password@127.0.0.1:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"
```
  1
  2
- Pour PostgreSQL : Utilisateur par défaut : root, mot de passe password, port 5432.
  dotenv
```
# .env
DATABASE_URL="postgresql://root:password@127.0.0.1:5432/servbay_symfony_app?serverVersion=13&charset=utf8"
```
  1
  2
Démarrez le service correspondant (MySQL/PostgreSQL) dans le panneau ServBay.
Créer la base de données
Si servbay_symfony_app n’existe pas, créez-la via l’outil de gestion ServBay (phpMyAdmin ou pgAdmin), ou lancez la commande Symfony :
bash
```
php bin/console doctrine:database:create
```
1
Créer une Entity et un fichier de migration
Les Entities Doctrine représentent les tables. Générer via Maker Bundle :
- Entity User :
  bash
```
php bin/console make:entity User
```
  1
  Ajoutez les propriétés, par exemple : name (string), email (string, unique=yes).
- Fichier de migration : Générez la migration selon l’Entity créee :
  bash
```
php bin/console make:migration
```
  1
  (Le fichier migration SQL apparaît alors dans src/Migrations/.)
Exécuter la migration
Appliquez la structure à la base de données :
bash
```
php bin/console doctrine:migrations:migrate
```
1

Exemple d’opérations CRUD

Modifiez src/Controller/DefaultController.php pour illustrer comment ajouter et lire des données via Doctrine. Injectez EntityManagerInterface dans le contrôleur.

Injectez d'abord l'EntityManager dans le constructeur :

php

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

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface; // Importer EntityManagerInterface
use App\Entity\User; // Importer l’Entity User
use Symfony\Component\HttpFoundation\JsonResponse; // Pour le retour JSON

class DefaultController
{
    private $entityManager;

    // Injection de l’EntityManager via le constructeur
    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

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

    // ... autres méthodes ...
}

Ajoutez les routes dans config/routes.yaml :

yaml

# config/routes.yaml
# ... autres routes ...
mysql_add_user:
    path: /mysql-add-user # ou /pgsql-add-user selon la base
    controller: App\Controller\DefaultController::addUser
mysql_get_users:
    path: /mysql-users # ou /pgsql-users
    controller: App\Controller\DefaultController::getUsers

Ajoutez les méthodes dans DefaultController.php :

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; // Importer 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();
        // Données d’exemple liées à la marque ServBay
        $user->setName('ServBay Demo User');
        $user->setEmail('demo-user@servbay.test');

        // Prépare l’enregistrement
        $this->entityManager->persist($user);
        // Exécute l’ajout en base
        $this->entityManager->flush();

        return new Response('Utilisateur ajouté avec succès !');
    }

    /**
     * @Route("/get-users", name="app_get_users")
     */
    public function getUsers(): JsonResponse
    {
        // Récupère tous les utilisateurs User en base
        $users = $this->entityManager->getRepository(User::class)->findAll();

        // Conversion des entités en tableau pour JsonResponse
        $usersArray = [];
        foreach ($users as $user) {
            $usersArray[] = [
                'id' => $user->getId(),
                'name' => $user->getName(),
                'email' => $user->getEmail(),
            ];
        }

        // Retourne la réponse JSON
        return new JsonResponse($usersArray);
    }
}

Tester l’exemple
- https://servbay-symfony-test.local/add-user pour ajouter un utilisateur.
- https://servbay-symfony-test.local/get-users pour afficher la liste des utilisateurs (JSON).

Exemple de Cache et base NoSQL (Symfony Cache)

ServBay inclut Redis et Memcached, ainsi que les extensions PHP nécessaires. Utilisez le composant Symfony Cache pour en tirer parti.

Configurer la connexion au cache

Dans le fichier .env, ajustez le DSN du cache :

Pour Memcached (port 11211) :

dotenv

# .env
# ... autres configs ...
CACHE_DSN=memcached://127.0.0.1:11211

Activez Memcached via ServBay.

Pour Redis (port 6379) :

dotenv

# .env
# ... autres configs ...
CACHE_DSN=redis://127.0.0.1:6379
# Si Redis nécessite un mot de passe (par défaut aucun avec ServBay):
# CACHE_DSN=redis://:your_password@127.0.0.1:6379

Activez Redis via ServBay.

Exemple d’utilisation du cache

Modifiez DefaultController.php pour illustrer l’usage du composant Cache de Symfony. Injectez CacheInterface :

Dans le constructeur du contrôleur :

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; // Importer CacheInterface

class DefaultController
{
    private $entityManager;
    private $cache; // Attribut cache

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

    // ... autres méthodes ...
}

Ajoutez la route dans config/routes.yaml :

yaml

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

Ajoutez la méthode dans le contrôleur :

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; // Importer ItemInterface

class DefaultController
{
    private $entityManager;
    private $cache;

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

    // ... autres méthodes ...

    /**
     * @Route("/cache-example", name="app_cache_example")
     */
    public function cacheExample(): Response
    {
        // Tente de récupérer la donnée du cache
        $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
            // Si le cache est manquant, on génère la donnée
            $item->expiresAfter(3600); // Durée de vie : 1h

            // Simule une opération lourde (ex. requête complexe)
            $data = "Donnée générée le " . date('Y-m-d H:i:s');

            return $data;
        });

        // $cacheItem contient la donnée du cache ou nouvellement créée
        $output = "Depuis le cache : " . $cacheItem;

        return new Response($output);
    }
}

Accéder à l’exemple
- Accédez à https://servbay-symfony-test.local/cache-example. Lors de la première visite, la donnée est générée ; les suivantes utiliseront Memcached ou Redis, selon la configuration.

Foire aux questions (FAQ)

Q : En accédant à https://servbay-symfony-test.local, j’obtiens une erreur 404 ou 500, que faire ?

A : Vérifiez les points suivants :

ServBay est bien démarré, et les services web (Caddy ou Apache) sont actifs.
La configuration du site, notamment le domaine servbay-symfony-test.local, est correcte, et le dossier racine pointe précisément vers /Applications/ServBay/www/servbay-symfony-app/public.
Consultez le fichier de logs Symfony (var/log/dev.log) pour diagnostiquer l’erreur.
Exécutez composer install à la racine du projet pour installer toutes les dépendances.
La version PHP de ServBay est compatible avec Symfony.

Q : La connexion à la base de données échoue, que faire ?

A : Vérifiez les points suivants :

Le service de base de données choisi (MySQL ou PostgreSQL) est démarré dans ServBay.
Vérifiez la configuration DATABASE_URL dans .env (utilisateur, mot de passe, adresse IP, port et nom de base).
Les identifiants sont cohérents avec ceux paramétrés dans ServBay.
La base de données servbay_symfony_app existe bien.

Q : Les commandes php bin/console ne fonctionnent pas ?

A : Assurez-vous d'être dans le dossier du projet /Applications/ServBay/www/servbay-symfony-app dans le terminal, et que la version PHP de ServBay est bien celle utilisée (commande which php).

Conclusion

Grâce à ce guide, vous savez créer, configurer et exécuter un projet Symfony de base sur macOS avec ServBay. ServBay rassemble tous les composants nécessaires à la création d’applications Symfony (PHP, Composer, serveur web, base de données, cache), et simplifie l’ensemble de l’installation et de la configuration, pour vous permettre de vous consacrer au développement. À partir de ce projet, vous pouvez continuer à explorer Symfony et profiter des autres services et modules proposés par ServBay.

Créer et exécuter un projet Symfony ​

Qu'est-ce que Symfony ? ​

Principales caractéristiques et avantages de Symfony ​

Créer et exécuter un projet Symfony avec ServBay ​

Prérequis ​

Création d’un projet Symfony ​

Configuration initiale ​

Configuration du serveur web (Site ServBay) ​

Ajouter un exemple de code de base ​

Accéder à votre site ​

Exemple de base de données et cache ​

Exemple de base de données relationnelle (Doctrine ORM) ​

Exemple de Cache et base NoSQL (Symfony Cache) ​

Foire aux questions (FAQ) ​

Conclusion ​

Créer et exécuter un projet Symfony

Qu'est-ce que Symfony ?

Principales caractéristiques et avantages de Symfony

Créer et exécuter un projet Symfony avec ServBay

Prérequis

Création d’un projet Symfony

Configuration initiale

Configuration du serveur web (Site ServBay)

Ajouter un exemple de code de base

Accéder à votre site

Exemple de base de données et cache

Exemple de base de données relationnelle (Doctrine ORM)

Exemple de Cache et base NoSQL (Symfony Cache)

Foire aux questions (FAQ)

Conclusion