Een Symfony-project aanmaken en uitvoeren

ServBay is een lokaal webontwikkelplatform, speciaal ontworpen voor macOS en Windows, dat integraties biedt voor PHP, Node.js, Python, Go, Java en meer programmeertalen, naast databases als MySQL, PostgreSQL, MongoDB en Redis. Ook ondersteunt het de Apache en Caddy webservers. In deze gids lees je stap voor stap hoe je met ServBay razendsnel een Symfony-project kunt opzetten en uitvoeren op macOS en Windows.

Wat is Symfony?

Symfony is een krachtig, open-source PHP-webframework ontwikkeld door SensioLabs. Het biedt ontwikkelaars een uitgebreide, flexibele toolkit voor het bouwen van moderne webapplicaties en API’s. Symfony volgt de best practices van webontwikkeling en bevat tal van features zoals routing, het Twig template-engine, formulierafhandeling, authenticatie en dependency injection. Hierdoor worden veelvoorkomende webtaken aanzienlijk vereenvoudigd.

Belangrijkste kenmerken en voordelen van Symfony

• Modulaire opzet: De kern van Symfony bestaat uit een herbruikbare componentenbibliotheek. Ontwikkelaars kunnen gewenste onderdelen kiezen en zo zowel lichte als zware applicaties bouwen.
• Hoge prestaties: Dankzij geoptimaliseerde architectuur, efficiënte caching en ondersteuning voor de nieuwste PHP-functies levert Symfony uitstekende performance.
• Sterke community: Een grote en actieve gemeenschap, talloze third-party Bundles (plug-ins) en uitgebreide documentatie maken het eenvoudig om oplossingen te vinden bij problemen.
• Flexibiliteit: Eenvoudige integratie van externe libraries en extensies, geschikt voor alle soorten en groottes projecten.
• Stabiliteit & onderhoudbaarheid: Met solide codestandaarden en design patterns zijn Symfony-applicaties goed testbaar, makkelijk te onderhouden en eenvoudig uit te breiden.

Symfony is geschikt voor zowel eenvoudige API’s als grote bedrijfstoepassingen.

Een Symfony-project aanmaken en uitvoeren met ServBay

ServBay biedt een volledig uitgeruste omgeving voor het draaien van Symfony-projecten, inclusief geschikte PHP-versies, Composer, webserveropties en diverse database- en cache-services. In dit hoofdstuk leer je hoe je met ServBay een nieuw Symfony-project opzet en configureert.

Vereisten

Voordat je gaat beginnen, check het volgende:

1. ServBay installeren: Installeer en start ServBay op macOS. Zie ServBay installatiehandleiding indien nodig.
2. ServBay draait correct: Zorg dat kernservices zoals Caddy of Apache, én de benodigde databases, actief zijn.
3. Basiskennis: Je hebt een basiskennis van PHP, Composer en Symfony.

Symfony-project aanmaken

ServBay raadt aan om al je webprojecten onder de map /Applications/ServBay/www vast te leggen. Zo kunnen ServBay en jijzelf projecten makkelijk beheren.

1. Composer beschikbaarheid checken

   Composer is geïntegreerd in ServBay en de paden zijn vooraf opgenomen in de omgeving. Los installeren is niet nodig. Controleer de beschikbaarheid met het commando: composer --version in je terminal.

2. Projectmap aanmaken

   Maak een nieuwe map aan onder de aanbevolen root voor je Symfony-project:

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

3. Symfony-project genereren met Composer

   Ga naar je nieuwe projectmap en maak een nieuw Symfony-project op basis van website-skeleton. Dit is een basisstructuur waarmee je een traditionele webapp kan beginnen.

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

   Composer downloadt nu automatisch de core-bestanden en afhankelijkheden van Symfony.

Initiële configuratie

Kerninstellingen van Symfony-projecten worden doorgaans via omgevingsvariabelen geregeld, opgeslagen in het .env-bestand in de hoofdmap van je project.

1. Omgevingsvariabelen configureren (.env)

   Open het .env-bestand in je projectmap. Hier vind je configuraties, o.a. voor databaseconnecties en applicatiesleutels. Pas deze aan naar wens.

   Zorg ervoor dat de volgende instellingen in lijn zijn met je ServBay-omgeving:

   # Voorbeeld .env-bestand
   APP_ENV=dev # Ontwikkelmodus
   APP_SECRET=your_secret_key # Vervang dit door een uniek, willekeurig tekenreeks voor beveiliging
   
   # Databaseverbindingen (hieronder MySQL, PostgreSQL en 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"

   Vervang your_secret_key door een veilige, willekeurige sleutel. Standaard zijn in ServBay de databasegebruikers root en wachtwoord password (let op: verander dit absoluut voor productieomgevingen!). In deze gids nemen we servbay_symfony_app als voorbeeld-databasenaam.

Webserver instellen (ServBay website)

Om je Symfony-project via de browser toegankelijk te maken, gebruik je ServBay’s “Website”-functionaliteit om een lokale virtuele host in te stellen. De webroot van Symfony is de public/-map binnen je project.

Open het ServBay control panel en ga naar het onderdeel “Website” (of “Host” in oudere versies) en voeg een nieuwe website toe:

• Naam: Geef je site een herkenbare naam, bijv. My Symfony Dev Site.
• Domeinnaam: Kies een lokale domeinnaam, bijv. servbay-symfony-test.local. ServBay koppelt deze automatisch aan je computer.
• Type website: Selecteer PHP.
• PHP-versie: Kies een compatibele PHP-versie, bij voorkeur de nieuwste stabiele van ServBay, zoals 8.3.
• Webroot: Dit is de belangrijkste instelling. Voor Symfony moet deze naar de public/-map wijzen: /Applications/ServBay/www/servbay-symfony-app/public.

Sla de wijzigingen op. ServBay past automatisch de webserverconfiguratie aan. Standaard wordt Caddy of Apache gebruikt en de SSL-certificaten voor lokale domeinen worden automatisch aangemaakt en vertrouwd, zodat je direct via HTTPS kunt werken.

Zie ServBay Eerste Website toevoegen voor een stapsgewijze handleiding.

Basisvoorbeeldcode toevoegen

Om te testen of de websiteconfiguratie werkt, voeg je een simpele route en controller toe die een tekst laat zien op de hoofdpagina.

1. Route instellen (config/routes.yaml)

   Open config/routes.yaml en voeg een route toe voor het pad /, gekoppeld aan de index-methode van de controller:

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

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

   Maak in src/Controller/ een nieuw bestand DefaultController.php aan:

   <?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
       {
           // Geeft een eenvoudige HTTP-response terug
           return new Response('Hello ServBay and Symfony!');
       }
   }

   Dit voegt een eenvoudige controllerklasse toe die bij het bezoeken van / de tekst "Hello ServBay and Symfony!" toont.

Website bezoeken

Open nu je browser en ga naar het domein dat je in ServBay hebt ingesteld, bijvoorbeeld https://servbay-symfony-test.local. Als alles goed is, zie je het volgende:

Hello ServBay and Symfony!

De Symfony-website draait nu succesvol via de ServBay-webserver. Let op: ServBay configureert automatisch HTTPS, dus gebruik bij voorkeur https:// voor toegang.

Voorbeelden: Database en Cache

Symfony maakt meestal gebruik van Doctrine ORM voor relationele databases en de Symfony Cache-component voor caching en NoSQL-databases. ServBay levert kant-en-klare ondersteuning voor deze databases en relevante PHP-extensies.

Relationele database (Doctrine ORM)

ServBay ondersteunt zowel MySQL als PostgreSQL. Hieronder lees je hoe je deze configureert in Symfony.

1. Databaseverbinding configureren

   In .env bepaal je met DATABASE_URL welke database je gebruikt.

   • Voor MySQL: Standaard in ServBay: gebruiker root, wachtwoord password, poort 3306.

     # .env
     DATABASE_URL="mysql://root:password@127.0.0.1:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"

   • Voor PostgreSQL: Standaard in ServBay: gebruiker root, wachtwoord password, poort 5432.

     # .env
     DATABASE_URL="postgresql://root:password@127.0.0.1:5432/servbay_symfony_app?serverVersion=13&charset=utf8"

   Zorg dat de betreffende database-service (MySQL of PostgreSQL) actief is in het ServBay control panel.

2. Database aanmaken

   Als servbay_symfony_app nog ontbreekt, kun je deze handmatig aanmaken via ServBay’s databasebeheer (bijv. phpMyAdmin of pgAdmin, beschikbaar via het control panel) of via Symfony CLI:

   php bin/console doctrine:database:create

3. Entity en migratie aanmaken

   Gebruik Maker Bundle om een Entity (bijv. User) en een migratiebestand te genereren:

   • Entity aanmaken:

     php bin/console make:entity User

     Voeg velden toe zoals name (string) en email (string, uniek).
   • Migratiebestand maken:

     php bin/console make:migration

     Dit maakt in src/Migrations een bestand met SQL-statements voor het aanmaken van de users-tabel.

4. Migratie uitvoeren

   Pas de database structuur toe met:

   php bin/console doctrine:migrations:migrate

5. Voorbeeld database-operaties toevoegen

   Verwerk voorbeeldroutes en methods in src/Controller/DefaultController.php. Hiervoor injecteer je EntityManagerInterface.

   Update eerst de constructor van je DefaultController zodat hij EntityManagerInterface ontvangt:

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

   Voeg vervolgens routes toe in config/routes.yaml:

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

   Voeg de volgende methodes toe aan src/Controller/DefaultController.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;
   
   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 met ServBay-merk
           $user->setName('ServBay Demo User');
           $user->setEmail('demo-user@servbay.test');
   
           // Object persistent maken (klaarmaken om te schrijven)
           $this->entityManager->persist($user);
           // Uitvoeren van schrijfoperatie
           $this->entityManager->flush();
   
           return new Response('Gebruiker succesvol toegevoegd!');
       }
   
       /**
        * @Route("/get-users", name="app_get_users")
        */
       public function getUsers(): JsonResponse
       {
           // Alle User-entities ophalen uit de database
           $users = $this->entityManager->getRepository(User::class)->findAll();
   
           // Resultaten converteren naar array voor JSON-output
           $usersArray = [];
           foreach ($users as $user) {
               $usersArray[] = [
                   'id' => $user->getId(),
                   'name' => $user->getName(),
                   'email' => $user->getEmail(),
               ];
           }
   
           // JSON-respons teruggeven
           return new JsonResponse($usersArray);
       }
   }

6. Voorbeeldroutes testen

   • Ga naar https://servbay-symfony-test.local/add-user om een gebruiker toe te voegen.
   • Bekijk de lijst via https://servbay-symfony-test.local/get-users (in JSON-formaat).

Cache en NoSQL-database (Symfony Cache)

ServBay biedt directe ondersteuning voor Redis en Memcached, inclusief de juiste PHP-extensies. Symfony Cache-component kan hiermee probleemloos overweg.

1. Cache-verbinding instellen

   In .env stel je de cache-service in:

   • Memcached: Standaard in ServBay draait Memcached op poort 11211.

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

     Controleer dat Memcached is gestart in het ServBay control panel.
   • Redis: Standaard draait Redis op poort 6379.

     # .env
     # ... overige instellingen ...
     CACHE_DSN=redis://127.0.0.1:6379
     # Indien Redis een wachtwoord vereist (standaard geen), gebruik:
     # CACHE_DSN=redis://:your_password@127.0.0.1:6379

     Zorg dat Redis actief is in het ServBay control panel.

2. Voorbeeld caching toevoegen

   Update je controller zodat je CacheInterface als dependency ontvangt:

   <?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; // CacheInterface importeren
   
   class DefaultController
   {
       private $entityManager;
       private $cache;
   
       // Constructor ontvangt CacheInterface
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... overige methods ...
   }

   Voeg in config/routes.yaml een cache-route toe:

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

   Voeg dan deze methode toe aan je controller:

   <?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; // ItemInterface importeren
   
   class DefaultController
   {
       private $entityManager;
       private $cache;
   
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... overige methods ...
   
       /**
        * @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) {
               // Wordt uitgevoerd als er geen geldige cache gevonden is
               $item->expiresAfter(3600); // Cache blijft 1 uur geldig
   
               // Simuleer een zware operatie, bijvoorbeeld complexe databasequery
               $data = "Data gegenereerd op " . date('Y-m-d H:i:s');
   
               // Geef te cachen data terug
               return $data;
           });
   
           // $cacheItem bevat nu cached data (indien beschikbaar) of verse data
           $output = "Uit Cache: " . $cacheItem;
   
           return new Response($output);
       }
   }

3. Voorbeeldroute testen

   • Ga naar https://servbay-symfony-test.local/cache-example. Bij je eerste bezoek wordt er nieuwe data gegenereerd en gecached. Als je opnieuw laadt binnen de cacheperiode, komt de data direct uit Memcached of Redis.

Veelgestelde vragen (FAQ)

Vraag: Ik krijg een foutmelding (pagina niet gevonden of 500) bij bezoek aan https://servbay-symfony-test.local. Wat nu?

Antwoord: Check het volgende:

1. Is ServBay actief, en is de webserver (Caddy/Apache) gestart?
2. Staan domeinnaam (servbay-symfony-test.local) en de webroot juist ingesteld (moet wijzen naar /Applications/ServBay/www/servbay-symfony-app/public)?
3. Bekijk de Symfony-log (var/log/dev.log) voor details over fouten.
4. Voer in het project composer install uit om afhankelijkheden te installeren.
5. Controleer dat je PHP-versie compatibel is met Symfony.

Vraag: Databaseverbinding werkt niet, wat kan ik doen?

Antwoord: Check deze punten:

1. Is de juiste database-service (MySQL/postgreSQL) gestart in ServBay?
2. Kloppen de gegevens in .env (DATABASE_URL) zoals gebruikersnaam, wachtwoord, host (127.0.0.1), poort (MySQL: 3306, PostgreSQL: 5432) en databasenaam?
3. Komt de gebruiker en het wachtwoord overeen met ServBay-standaard of jouw gewijzigde instellingen?
4. Bestaat de database servbay_symfony_app al?

Vraag: php bin/console werkt niet?

Antwoord: Zorg dat je in de terminal werkt in /Applications/ServBay/www/servbay-symfony-app, en dat ServBay's PHP netjes in je PATH staat (de installer regelt dit doorgaans automatisch). Check met which php of je de ServBay-versie gebruikt.

Samenvatting

Je hebt nu succesvol een basis Symfony-project aangemaakt, geconfigureerd en uitgevoerd met ServBay op macOS. ServBay voorziet in alle essentiële Symfony-componenten (PHP, Composer, webserver, database, cache) en maakt het instellen van je ontwikkelomgeving eenvoudig. Op basis van deze start kun je verder met geavanceerde Symfony-functionaliteiten en andere services en tools die ServBay biedt.