Créer et lancer un projet Symfony

ServBay est un environnement de développement Web local spécialement conçu pour macOS. 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, Redis, et prend en charge les serveurs Web Apache et Caddy. Ce guide détaille comment utiliser ServBay pour installer et exécuter rapidement un projet Symfony sur macOS.

Qu'est-ce que Symfony ?

Symfony est un framework PHP open-source créé par SensioLabs. Il a pour objectif de fournir aux développeurs une panoplie d'outils efficaces, flexibles et puissants pour construire des applications Web modernes et des API. Il suit les meilleures pratiques du Web standard, et offre de nombreux composants fonctionnalités comme le routage, le moteur de templates (Twig), la gestion de formulaire, l’authentification, l’injection de dépendances, simplifiant grandement les tâches courantes du développement Web.

Principales caractéristiques et avantages de Symfony

Architecture modulaire : Au cœur de Symfony se trouve une bibliothèque de composants réutilisables. Les développeurs peuvent choisir les composants nécessaires pour réaliser des applications allant du plus léger au plus complexe.
Haute performance : Grâce à son architecture optimisée, à son système de cache efficace et au support des dernières fonctionnalités de PHP, Symfony offre d’excellentes performances.
Forte communauté : Une grande communauté, de nombreux bundles (extensions) tiers et une documentation exhaustive facilitent la résolution des problèmes.
Flexibilité : Symfony s’intègre facilement avec d’autres bibliothèques et extensions, adapté à des projets de toutes tailles et complexités.
Stabilité et maintenabilité : En respectant de bonnes pratiques de codage et les patterns de design, les applications construites sont faciles à tester, maintenir et faire évoluer.

Symfony est adapté aussi bien à la création d’API légères qu’à des solutions Web d’entreprise à grande échelle.

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

ServBay fournit tout l’environnement nécessaire à l’exécution d’un projet Symfony : versions de PHP, Composer, serveur Web, bases de données et services de cache. Cette section vous guide pas à pas pour créer un nouveau projet Symfony et le configurer avec ServBay.

Prérequis

Avant de commencer, assurez-vous d’avoir effectué les opérations suivantes :

Installer ServBay : ServBay est installé et lancé sur votre macOS. Si ce n'est pas déjà fait, consultez le Guide d'installation de ServBay.
ServBay fonctionne correctement : Les services de base de ServBay (tels que Caddy ou Apache, et la base de données souhaitée) sont en fonctionnement.
Connaissances de base : Vous avez des notions sur PHP, Composer et Symfony.

Créer un projet Symfony

ServBay recommande de regrouper tous vos sites dans le dossier /Applications/ServBay/www afin de faciliter la reconnaissance et la gestion de vos projets.

Vérifier la disponibilité de Composer
Composer est fourni avec ServBay et l’environnement est déjà configuré. Vous n'avez rien à installer. Vérifiez sa disponibilité en tapant dans votre terminal composer --version.
Créer un répertoire pour le projet
Depuis le répertoire racine 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 répertoire nouvellement créé et utilisez Composer pour générer la structure du projet basée sur website-skeleton, qui fournit les dépendances de base d’une application web.
bash
```
cd /Applications/ServBay/www/servbay-symfony-app
composer create-project symfony/website-skeleton .
```
1
2
Cette commande télécharge Symfony et toutes ses dépendances dans le dossier courant.

Configuration initiale

La configuration centrale d’un projet Symfony s’effectue généralement via des variables d’environnement, stockées dans le fichier .env à la racine du projet.

Configurer les variables d’environnement (.env)
Ouvrez le fichier .env et ajustez les paramètres à vos besoins, notamment la connexion à la base de données et la clé secrète de l’application.
Adaptez notamment les paramètres suivants selon 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 unique et aléatoire pour la sécurité

# Connexions à la base de données (exemples : MySQL, PostgreSQL, SQLite)
# 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 valeur sécurisée. Pour vos connexions MySQL/PostgreSQL, l’utilisateur par défaut sur ServBay est généralement root et le mot de passe password (pensez à modifier ces valeurs pour la production). Nous utiliserons servbay_symfony_app comme exemple de base de données.

Configurer un serveur Web (site ServBay)

Pour accéder à votre projet Symfony, vous allez configurer un hôte virtuel local via la fonctionnalité « Site » de ServBay. Le répertoire web racine de Symfony est le dossier public/ du projet.

Depuis le panneau de contrôle ServBay, accédez à la page « Sites » (ou « Hôtes » sur les anciennes versions), puis ajoutez un nouveau site :

Nom : Choisissez un nom facile à reconnaître, par exemple My Symfony Dev Site.
Domaine : Définissez un nom de domaine local comme servbay-symfony-test.local. ServBay le redirigera automatiquement en local.
Type de site : Sélectionnez PHP.
Version PHP : Sélectionnez une version compatible avec votre projet Symfony, par exemple 8.3 (la dernière version stable de ServBay de préférence).
Racine du site web : Ce point est crucial pour Symfony : indiquez le dossier /Applications/ServBay/www/servbay-symfony-app/public.

Une fois la configuration faite, enregistrez et appliquez les changements. ServBay mettra à jour la configuration du serveur Web automatiquement, en générant et en faisant confiance au certificat SSL local (grâce à Caddy ou Apache). Vous pouvez alors accéder à votre site via HTTPS.

Pour plus de détails, consultez Ajouter son premier site avec ServBay.

Ajouter du code d'exemple

Pour vérifier que votre configuration fonctionne, ajoutons une route et un contrôleur simples qui renverront du texte à la racine du site.

Configurer la route (config/routes.yaml)

Modifiez ou ajoutez dans config/routes.yaml :

yaml

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

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

Dans src/Controller/, créez le fichier DefaultController.php :

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

Ce code crée un contrôleur simple DefaultController dont la méthode index est reliée à la racine /. Un accès à / renvoie simplement « Hello ServBay and Symfony! ».

Accéder au site

Ouvrez votre navigateur et rendez-vous sur le domaine configuré, par exemple : https://servbay-symfony-test.local. Si tout est correct, vous verrez :

Hello ServBay and Symfony!

Votre projet Symfony fonctionne donc avec le serveur Web de ServBay. Notez que ServBay gère le HTTPS local automatiquement, il est donc conseillé d'utiliser https://.

Exemples pour bases de données et cache

Symfony utilise généralement Doctrine ORM pour les bases de données relationnelles, et le composant Symfony Cache pour la gestion du cache/NoSQL. ServBay propose plusieurs services de bases de données et les extensions PHP correspondantes, facilement intégrables dans votre projet.

Exemple base de données relationnelle (Doctrine ORM)

ServBay prend en charge MySQL et PostgreSQL. Voici comment les utiliser sous Symfony.

Configurer la connexion à la base
Éditez le fichier .env à la racine du projet, selon le moteur choisi.
- Pour MySQL : Utilisateur = 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 = 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
N’oubliez pas de démarrer le service base de données voulu depuis le panneau de contrôle ServBay.
Créer la base de données
Si la base servbay_symfony_app n’existe pas, créez-la via un outil graphique (phpMyAdmin, pgAdmin) ou en ligne de commande :
bash
```
php bin/console doctrine:database:create
```
1
Créer une Entity et la migration
Utilisez Maker Bundle pour générer une entity et un fichier de migration.
- Créer une entity User :
  bash
```
php bin/console make:entity User
```
  1
  Ajoutez les champs demandés (par exemple name et email, ce dernier unique).
- Créer une migration :
  bash
```
php bin/console make:migration
```
  1
  Cela crée un fichier dans src/Migrations pour générer la table users.
Appliquer la migration
Exécutez la migration pour appliquer le schéma à la base :
bash
```
php bin/console doctrine:migrations:migrate
```
1

Exemple d’opérations sur la base

Modifiez src/Controller/DefaultController.php pour injecter EntityManagerInterface et interagir avec la base de données.

Injection du service 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 la réponse JSON

class DefaultController
{
    private $entityManager;

    // Injection de l’EntityManager
    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 de nouvelles 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 utilisée
    controller: App\Controller\DefaultController::addUser
mysql_get_users:
    path: /mysql-users # ou /pgsql-users
    controller: App\Controller\DefaultController::getUsers

Ajoutez les méthodes correspondantes dans src/Controller/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();
        // Exemple avec les données associées à ServBay
        $user->setName('ServBay Demo User');
        $user->setEmail('demo-user@servbay.test');

        // Prépare l’objet à être enregistré
        $this->entityManager->persist($user);
        // Effectue l’enregistrement
        $this->entityManager->flush();

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

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

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

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

Tester les routes
- Rendez-vous sur https://servbay-symfony-test.local/add-user pour ajouter un utilisateur.
- Accédez à https://servbay-symfony-test.local/get-users pour voir la liste (JSON) des utilisateurs ajoutés.

Exemple cache et NoSQL (Symfony Cache)

ServBay intègre Redis et Memcached, ainsi que les extensions PHP nécessaires. Utilisez le composant Symfony Cache pour interagir facilement avec ces services.

Configurer la connexion au cache
Ajoutez la configuration adéquate dans votre .env :
- Pour Memcached : Port par défaut : 11211.
  dotenv
```
# .env
# ... autres paramètres ...
CACHE_DSN=memcached://127.0.0.1:11211
```
  1
  2
  3
  Vérifiez que le service Memcached est bien démarré dans ServBay.
- Pour Redis : Port par défaut : 6379.
  dotenv
```
# .env
# ... autres paramètres ...
CACHE_DSN=redis://127.0.0.1:6379
# Si Redis a un mot de passe (par défaut : non), utilisez :
# CACHE_DSN=redis://:your_password@127.0.0.1:6379
```
  1
  2
  3
  4
  5
  Lancez le service Redis dans ServBay si nécessaire.

Exemple d’utilisation du cache

Dans src/Controller/DefaultController.php, injectez CacheInterface et créez une méthode d’exemple.

D’abord, modifiez le constructeur pour prendre en compte 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; // Importer l’interface

class DefaultController
{
    private $entityManager;
    private $cache; // Propriété pour le cache

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

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

Ajoutez une nouvelle 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 côté 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
    {
        // Récupérer depuis le cache (« get »)
        $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
            // Si la donnée n’est pas en cache, ce bloc s’exécute
            $item->expiresAfter(3600); // Expire dans 1h

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

            // On retourne la donnée à mettre en cache
            return $data;
        });

        // $cacheItem provient du cache ou vient d’être généré
        $output = "Depuis le cache : " . $cacheItem;

        return new Response($output);
    }
}

Tester l’exemple
- Visitez https://servbay-symfony-test.local/cache-example. La première visite génère et stocke la donnée, les suivantes (tant que non expiré) la liront depuis Memcached ou Redis.

Foire aux questions (FAQ)

Q : Que faire si l’accès à https://servbay-symfony-test.local affiche une erreur 404 ou 500 ?

R : Vérifiez les points suivants :

ServBay et les services Web (Caddy ou Apache) sont bien lancés.
La configuration du site dans ServBay : le domaine servbay-symfony-test.local est correct, et la racine pointe bien sur /Applications/ServBay/www/servbay-symfony-app/public.
Consultez les logs Symfony (var/log/dev.log) pour plus de détails.
Exécutez composer install pour vous assurer que toutes les dépendances sont installées.
Vérifiez que la version de PHP est compatible Symfony.

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

R : Points à vérifier :

Le bon service MySQL/PostgreSQL est lancé via ServBay.
Le paramètre DATABASE_URL du .env contient les bons identifiants (utilisateur, mot de passe, hôte, port, nom de base).
Vérifiez que l’utilisateur et le mot de passe correspondent à ceux de ServBay.
La base servbay_symfony_app existe bien.

Q : La commande php bin/console ne fonctionne pas ?

R : Assurez-vous que votre terminal se trouve bien dans /Applications/ServBay/www/servbay-symfony-app, et que la version PHP de ServBay est bien intégrée dans votre PATH système (généralement automatique lors de l’installation de ServBay). Vous pouvez vérifier avec which php.

Conclusion

Grâce à ce guide, vous aurez créé, configuré et lancé un projet Symfony de base sur macOS avec ServBay. ServBay propose tous les composants essentiels (PHP, Composer, serveur Web, base de données, cache) et simplifie la gestion de l’environnement pour permettre aux développeurs de se concentrer sur la création d’applications. Sur cette base, vous pouvez continuer l’apprentissage de Symfony et tirer profit des autres logiciels et services proposés par ServBay.

Créer et lancer 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éer un projet Symfony ​

Configuration initiale ​

Configurer un serveur Web (site ServBay) ​

Ajouter du code d'exemple ​

Accéder au site ​

Exemples pour bases de données et cache ​

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

Exemple cache et NoSQL (Symfony Cache) ​

Foire aux questions (FAQ) ​

Conclusion ​

Créer et lancer 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éer un projet Symfony

Configuration initiale

Configurer un serveur Web (site ServBay)

Ajouter du code d'exemple

Accéder au site

Exemples pour bases de données et cache

Exemple base de données relationnelle (Doctrine ORM)

Exemple cache et NoSQL (Symfony Cache)

Foire aux questions (FAQ)

Conclusion