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 :
bashcd /Applications/ServBay/www mkdir servbay-symfony-app
1
2Cré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 :bashcd /Applications/ServBay/www/servbay-symfony-app composer create-project symfony/website-skeleton .
1
2Composer 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
8Remplacez
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 souventroot
, et le mot de passepassword
(changez ces données en production !). Nous prendronsservbay_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
1
2
3
4Créer le contrôleur (
src/Controller/DefaultController.php
)Dans le dossier
src/Controller/
, créez un fichierDefaultController.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!'); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18Ce 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!
1
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 variableDATABASE_URL
selon le service utilisé.- Pour MySQL : Utilisateur par défaut :
root
, mot de passepassword
, port3306
.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 passepassword
, port5432
.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.
- Pour MySQL : Utilisateur par défaut :
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 :bashphp bin/console doctrine:database:create
1Créer une Entity et un fichier de migration
Les Entities Doctrine représentent les tables. Générer via Maker Bundle :
- Entity User :bashAjoutez les propriétés, par exemple :
php bin/console make:entity User
1name
(string),email
(string, unique=yes). - Fichier de migration : Générez la migration selon l’Entity créee :bash(Le fichier migration SQL apparaît alors dans
php bin/console make:migration
1src/Migrations/
.)
- Entity User :
Exécuter la migration
Appliquez la structure à la base de données :
bashphp bin/console doctrine:migrations:migrate
1Exemple d’opérations CRUD
Modifiez
src/Controller/DefaultController.php
pour illustrer comment ajouter et lire des données via Doctrine. InjectezEntityManagerInterface
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 ... }
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
30Ajoutez 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
1
2
3
4
5
6
7
8Ajoutez 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); } }
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67Tester 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
) :dotenvActivez Memcached via ServBay.# .env # ... autres configs ... CACHE_DSN=memcached://127.0.0.1:11211
1
2
3 - Pour Redis (port
6379
) :dotenvActivez Redis via ServBay.# .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
1
2
3
4
5
- Pour Memcached (port
Exemple d’utilisation du cache
Modifiez
DefaultController.php
pour illustrer l’usage du composant Cache de Symfony. InjectezCacheInterface
: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 ... }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25Ajoutez la route dans
config/routes.yaml
:yaml# config/routes.yaml # ... autres routes ... cache_example: path: /cache-example controller: App\Controller\DefaultController::cacheExample
1
2
3
4
5Ajoutez 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); } }
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
40
41
42
43
44
45
46
47Accé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.
- Accédez à
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.