Symfony-project aanmaken en uitvoeren

ServBay is een lokaal webontwikkelplatform speciaal ontworpen voor macOS. Het integreert verschillende taalruntimes zoals PHP, Node.js, Python, Go, Java en databases zoals MySQL, PostgreSQL, MongoDB, Redis. Zowel de Apache- als de Caddy-webserver worden ondersteund. In deze gids leer je stap voor stap hoe je razendsnel een Symfony-project opzet en uitvoert op macOS met ServBay.

Wat is Symfony?

Symfony is een open-source PHP webframework ontwikkeld door SensioLabs. Het biedt ontwikkelaars een krachtig, flexibel en efficiënt hulpmiddelenpakket voor het bouwen van moderne webapplicaties en API's. Symfony volgt de gangbare webbest practices en bevat een brede verzameling functionaliteiten zoals routing, template engine (Twig), form handling, authenticatie, dependency injection en meer. Dankzij deze componenten worden veelvoorkomende webontwikkeltaken sterk vereenvoudigd.

Belangrijkste kenmerken en voordelen van Symfony

• Modulaire architectuur: De kern van Symfony bestaat uit herbruikbare componenten. Ontwikkelaars kiezen zelf welke componenten nodig zijn, ideaal voor zowel lichte als zware applicaties.
• Uitstekende prestaties: Symfony biedt hoge performance dankzij optimale architectuur, efficiënte caching en support voor de nieuwste PHP-functionaliteit.
• Sterke community support: Een omvangrijke community, talloze third-party Bundles (plug-ins) en uitgebreide documentatie zorgen ervoor dat je bij vragen snel oplossingen vindt.
• Flexibiliteit: Gemakkelijk te integreren met externe bibliotheken en uitbreidingen, geschikt voor projecten van elke omvang en complexiteit.
• Stabiliteit en onderhoudbaarheid: Symfony hanteert strikte codeconventies en design patterns, waardoor applicaties gemakkelijk te testen, onderhouden en uit te breiden zijn.

Symfony is ideaal voor zowel kleine API's als grootschalige bedrijfssystemen.

Symfony-project maken en uitvoeren met ServBay

ServBay biedt een complete omgeving voor Symfony-projecten, inclusief de juiste PHP-versie, Composer, webserver en diverse database- en cachevoorzieningen. In dit hoofdstuk leer je hoe je met ServBay een nieuw Symfony-project opzet en configureert.

Vereisten

Voordat je begint, controleer je het volgende:

1. ServBay geïnstalleerd: Je hebt ServBay succesvol geïnstalleerd en gestart op macOS. Raadpleeg zo nodig de ServBay installatiehandleiding.
2. ServBay functioneert correct: De kernservices van ServBay (zoals Caddy of Apache en benodigde databases) draaien.
3. Basiskennis: Je begrijpt de basis van PHP, Composer en Symfony.

Symfony-project aanmaken

ServBay raadt aan om al je websiteprojecten te bewaren in /Applications/ServBay/www. Zo worden ze eenvoudig herkend en beheerd.

1. Zorg dat Composer werkt

   Composer is standaard geïntegreerd in ServBay en zit in het pad. Je hoeft Composer niet los te installeren. Controleer beschikbaarheid via de terminal:

   composer --version

2. Maak een projectmap aan

   Maak een nieuwe directory aan in de aanbevolen rootmap voor je Symfony-project:

   cd /Applications/ServBay/www
   mkdir servbay-symfony-app

3. Symfony-project aanmaken met Composer

   Navigeer naar de aangemaakte projectmap en start een project op basis van website-skeleton. Dit is een basis-template voor traditionele webapplicaties.

   cd /Applications/ServBay/www/servbay-symfony-app
   composer create-project symfony/website-skeleton .

   Composer downloadt nu de kernbestanden van Symfony en alle afhankelijkheden.

Eerste configuratie

De kernconfiguratie van Symfony wordt geregeld via omgevingsvariabelen, doorgaans opgeslagen in .env in de projectroot.

1. Implementeer omgevingsvariabelen (.env)

   Open het .env bestand. Hierin staan configuraties zoals databaseverbindingen en applicatiesleutels. Pas de gegevens aan op basis van jouw situatie.

   Stel minimaal de volgende waarden goed in en stem ze af op jouw ServBay-omgeving:

   # Voorbeeld .env bestand
   APP_ENV=dev # Ontwikkelomgeving
   APP_SECRET=your_secret_key # Vervang dit door een unieke random string
   
   # Databaseverbinding (hier MySQL als voorbeeld)
   # 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"

   Vervang your_secret_key door een willekeurige, veilige string. Standaard zijn de ServBay databasegegevens: gebruiker root, wachtwoord password. Gebruik in dit voorbeeld de database servbay_symfony_app (pas eventueel aan).

Webserver configureren (ServBay Website)

Om je Symfony-project via de browser te bezoeken, gebruik je de "Website" functie van ServBay en stel je een lokale virtuele host in. De webroot van Symfony is de map public/ in je project.

Open het ServBay-configuratiepaneel, ga naar "Website"-instellingen (of "Host" bij oudere versies) en voeg een nieuwe website toe:

• Naam: Geef een herkenbare naam, bijvoorbeeld My Symfony Dev Site.
• Domein: Een lokaal ontwikkeldomein zoals servbay-symfony-test.local. ServBay koppelt dit automatisch aan je localhost.
• Websitetype: Kies PHP.
• PHP-versie: Kies een PHP-versie die compatibel is met je project, bij voorkeur de nieuwste stabiele release zoals 8.3.
• Website root: Dit is cruciaal. Voor Symfony moet deze wijzen naar de public/ map van je project: /Applications/ServBay/www/servbay-symfony-app/public.

Sla op en pas wijzigingen toe. ServBay herconfigureert dan automatisch de webserver (Caddy of Apache) en genereert en vertrouwt automatisch SSL-certificaten voor jouw lokale domein. Je kunt dus direct via HTTPS werken!

Raadpleeg voor een uitgebreide uitleg: Je eerste website toevoegen in ServBay.

Voorbeeldcode toevoegen

Om de configuratie van je site te testen voegen we een simpele route en controller toe, die een boodschap op de root zal tonen.

1. Route toevoegen (config/routes.yaml)

   Voeg onderstaande route toe aan config/routes.yaml voor het pad /, gekoppeld aan een index methode in je controller:

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

2. Controller aanmaken (src/Controller/DefaultController.php)

   Maak een nieuw PHP-bestand aan in src/Controller/ genaamd DefaultController.php en voeg het volgende toe:

   <?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
       {
           // Retourneer een simpele HTTP-respons
           return new Response('Hello ServBay and Symfony!');
       }
   }

   Dit creëert een eenvoudige controller DefaultController. De index methode is via @Route("/") gekoppeld aan de root. Als je de root bezoekt, krijg je het bericht "Hello ServBay and Symfony!".

Website bezoeken

Open nu je browser en ga naar het geconfigureerde domein https://servbay-symfony-test.local. Als alles goed staat, verschijnt:

Hello ServBay and Symfony!

Je Symfony-project draait nu succesvol met de ServBay-webserver. ServBay voorziet automatisch van HTTPS; gebruik dus https://.

Database en cache voorbeelden

Symfony gebruikt doorgaans Doctrine ORM voor relationele databases en de Symfony Cache component voor cache/NoSQL. ServBay levert verschillende databases en de benodigde PHP-extensies, zodat je deze eenvoudig in je project gebruikt.

Voorbeeld Relationele Database (Doctrine ORM)

ServBay ondersteunt MySQL en PostgreSQL. Hier volgt een voorbeeld van beide.

1. Databaseverbinding instellen

   Pas in .env een van de onderstaande DATABASE_URL variabelen aan op basis van je keuze:

   • MySQL: Standaard is de MySQL gebruiker root, wachtwoord password, poort 3306.

     # .env
     DATABASE_URL="mysql://root:[email protected]:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"

   • PostgreSQL: Standaard is de PostgreSQL gebruiker root, wachtwoord password, poort 5432.

     # .env
     DATABASE_URL="postgresql://root:[email protected]:5432/servbay_symfony_app?serverVersion=13&charset=utf8"

   Zorg dat je de betreffende databasedienst gestart hebt in het ServBay-paneel.

2. Database aanmaken

   Bestaat de database servbay_symfony_app nog niet, maak deze dan aan via een databasebeheerder als phpMyAdmin/pgAdmin, of via de Symfony CLI:

   php bin/console doctrine:database:create

3. Entity en migratiebestanden aanmaken

   Doctrine Entity's representeren tabellen. Met Maker Bundle maak je deze snel aan.

   • Entity maken (bijvoorbeeld een User):

     php bin/console make:entity User

     Volg de prompts, bijvoorbeeld voor de velden name (string) en email (string, uniek).
   • Migratie laten genereren:

     php bin/console make:migration

     Dit genereert het migratiebestand in src/Migrations.

4. Migraties uitvoeren

   Voer de migraties uit met:

   php bin/console doctrine:migrations:migrate

5. Voorbeeld databaseoperatie toevoegen

   Pas src/Controller/DefaultController.php aan zodat je met Doctrine kunt lezen en schrijven. Je moet EntityManagerInterface injecteren.

   De constructor in DefaultController injecteert nu EntityManagerInterface:

   <?php
   // src/Controller/DefaultController.php
   namespace App\Controller;
   
   use Symfony\Component\HttpFoundation\Response;
   use Symfony\Component\Routing\Annotation\Route;
   use Doctrine\ORM\EntityManagerInterface; // Importeer EntityManagerInterface
   use App\Entity\User; // Importeer User entity
   use Symfony\Component\HttpFoundation\JsonResponse; // Voor JSON responses
   
   class DefaultController
   {
       private $entityManager;
   
       // Verkrijg EntityManager via dependency injection
       public function __construct(EntityManagerInterface $entityManager)
       {
           $this->entityManager = $entityManager;
       }
   
       /**
        * @Route("/", name="app_index")
        */
       public function index(): Response
       {
           return new Response('Hello ServBay and Symfony!');
       }
   
       // ... overige methodes ...
   }

   Voeg nieuwe routes toe in config/routes.yaml:

   # config/routes.yaml
   # ... andere routes ...
   mysql_add_user:
       path: /mysql-add-user # of /pgsql-add-user afhankelijk van de gebruikte database
       controller: App\Controller\DefaultController::addUser
   mysql_get_users:
       path: /mysql-users # of /pgsql-users
       controller: App\Controller\DefaultController::getUsers

   Voeg de controller methodes toe:

   <?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;
   
   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();
           // Voorbeelddata gerelateerd aan ServBay
           $user->setName('ServBay Demo User');
           $user->setEmail('[email protected]');
   
           // Object voorbereiden voor opslag
           $this->entityManager->persist($user);
           // Uitvoeren van schrijfoperatie
           $this->entityManager->flush();
   
           return new Response('User toegevoegd!');
       }
   
       /**
        * @Route("/get-users", name="app_get_users")
        */
       public function getUsers(): JsonResponse
       {
           // Haal alle User entities uit de database
           $users = $this->entityManager->getRepository(User::class)->findAll();
   
           // Zet om naar array voor JsonResponse
           $usersArray = [];
           foreach ($users as $user) {
               $usersArray[] = [
                   'id' => $user->getId(),
                   'name' => $user->getName(),
                   'email' => $user->getEmail(),
               ];
           }
   
           // Geef antwoord in JSON-formaat terug
           return new JsonResponse($usersArray);
       }
   }

6. Voorbeeld testen

   • Ga naar https://servbay-symfony-test.local/add-user om een gebruiker toe te voegen.
   • Ga naar https://servbay-symfony-test.local/get-users om de gebruikerslijst in JSON te zien.

Cache & NoSQL (Symfony Cache)

ServBay integreert Redis en Memcached services plus benodigde PHP-extensies. Je gebruikt de Symfony Cache component direct met deze services.

1. Cacheverbinding instellen

   Configureer de cacheconnectie in .env:

   • Memcached: Standaardpoort is 11211.

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

     Zorg dat Memcached draait in het ServBay-paneel.
   • Redis: Standaardpoort is 6379.

     # .env
     CACHE_DSN=redis://127.0.0.1:6379
     # Met wachtwoord indien nodig (standaard niet nodig)
     # CACHE_DSN=redis://:[email protected]:6379

     Zorg dat Redis draait in het ServBay-paneel.

2. Voorbeeld cache-gebruik

   Pas src/Controller/DefaultController.php aan. Injecteer CacheInterface:

   Constructor met CacheInterface:

   <?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; // Importeer CacheInterface
   
   class DefaultController
   {
       private $entityManager;
       private $cache;
   
       // Injecteer CacheInterface via constructor
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... overige methodes ...
   }

   Voeg een nieuwe route toe in config/routes.yaml:

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

   Implementeer de cache-methode:

   <?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; // Importeer ItemInterface
   
   class DefaultController
   {
       private $entityManager;
       private $cache;
   
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... overige methodes ...
   
       /**
        * @Route("/cache-example", name="app_cache_example")
        */
       public function cacheExample(): Response
       {
           // Probeer data uit de cache te halen
           $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
               // Dit wordt uitgevoerd als de cache mist
               $item->expiresAfter(3600); // 1 uur geldig
   
               // Simuleer een dure operatie
               $data = "Data gegeneerd op " . date('Y-m-d H:i:s');
   
               // Geef te cachen data terug
               return $data;
           });
   
           // Of uit cache of nieuw gegenereerd
           $output = "From Cache: " . $cacheItem;
   
           return new Response($output);
       }
   }

3. Voorbeeld testen

   • Bezoek https://servbay-symfony-test.local/cache-example. De eerste keer wordt de data gegenereerd en gecached; daarna komt het direct uit Memcached of Redis.

Veelgestelde vragen (FAQ)

V: Mijn site https://servbay-symfony-test.local geeft een foutmelding of 500 error – wat nu?

A: Controleer het volgende:

1. ServBay draait, en webserverdiensten (Caddy of Apache) zijn actief.
2. De domeinnaam servbay-symfony-test.local is correct in de ServBay-websiteconfiguratie en de webroot wijst exact naar /Applications/ServBay/www/servbay-symfony-app/public.
3. Check de Symfony-logfile (var/log/dev.log) voor details.
4. Voer composer install uit in de projectroot.
5. De gebruikte PHP-versie is compatibel met je Symfony-project.

V: Databaseverbinding faalt – wat nu?

A: Controleer:

1. De benodigde database (MySQL of PostgreSQL) draait in het ServBay-paneel.
2. De DATABASE_URL in .env is correct (gebruikersnaam, wachtwoord, host 127.0.0.1, poort, database).
3. Gebruikersnaam/wachtwoord komen overeen met de defaults of zelf gekozen gegevens.
4. De database servbay_symfony_app bestaat.

V: php bin/console werkt niet?

A: Je werkt vanuit /Applications/ServBay/www/servbay-symfony-app in de terminal en ServBay’s PHP zit in je PATH (wordt normaal automatisch geregeld door ServBay). Controleer dit met which php.

Samenvatting

Met deze gids heb je succesvol geleerd hoe je met ServBay op macOS een Symfony-project opzet, configureert en start. ServBay levert hiervoor alle kerncomponenten (PHP, Composer, webserver, database, cache) en maakt omgevingsconfiguratie eenvoudig, zodat jij je kunt richten op het echte ontwikkelwerk. Je kunt nu verder de diepte in met Symfony’s mogelijkheden, én profiteren van ServBay’s overige tools en pakketten.