Symfony Projekt erstellen und ausführen

ServBay ist eine speziell für macOS entwickelte lokale Web-Entwicklungsumgebung, die zahlreiche Laufzeitumgebungen wie PHP, Node.js, Python, Go und Java integriert sowie Datenbanken wie MySQL, PostgreSQL, MongoDB, Redis uvm. unterstützt. Außerdem stehen die Webserver Apache und Caddy zur Verfügung. Diese Anleitung zeigt Schritt für Schritt, wie Sie mit ServBay unter macOS schnell ein Symfony-Projekt aufsetzen und betreiben.

Was ist Symfony?

Symfony ist ein Open-Source PHP-Webframework von SensioLabs, das Entwicklern eine leistungsfähige, flexible und umfassende Tool-Sammlung für die Erstellung moderner Web-Anwendungen und APIs bietet. Es setzt auf gängige Best Practices im Web und stellt zahlreiche Komponenten wie Routing, Templating (Twig), Formularverarbeitung, Authentifizierung, Dependency Injection uvm. bereit, um alltägliche Webentwicklungsaufgaben massiv zu erleichtern.

Die wichtigsten Features & Vorteile von Symfony

Modulare Architektur: Im Zentrum stehen wiederverwendbare Komponenten. Entwickler können gezielt Bausteine auswählen, um von leichten bis sehr umfangreichen Anwendungen alles zu bauen.
Hohe Performance: Durch optimierte Architektur, effiziente Caching-Mechanismen und Unterstützung aktueller PHP-Features liefert Symfony hervorragende Leistungswerte.
Starke Community: Eine riesige Entwicklergemeinschaft, zahlreiche Third-Party Bundles (Plugins) und umfassende Dokumentation erleichtern die Lösung von Problemen.
Flexibilität: Einfach integrierbar mit diversen Bibliotheken und Erweiterungen; geeignet für Projekte jeder Größe und Komplexität.
Stabilität & Wartbarkeit: Klare Coding Guidelines und Design-Patterns sorgen für leicht test- und erweiterbare Anwendungen.

Symfony eignet sich für Web-Projekte aller Art, von kleinen APIs bis hin zu großen Enterprise-Systemen.

Symfony-Projekt mit ServBay erstellen und ausführen

ServBay stellt sämtliche Komponenten zur Verfügung, die Sie für ein Symfony-Projekt benötigen – PHP, Composer, Webserver, diverse Datenbanken und Caching-Services. Dieser Abschnitt zeigt, wie Sie mit ServBay ein neues Symfony-Projekt anlegen und konfigurieren.

Voraussetzungen

Stellen Sie vor dem Start Folgendes sicher:

ServBay installiert: Sie haben ServBay erfolgreich auf Ihrem macOS installiert und gestartet. Falls nicht, lesen Sie bitte die ServBay-Installationsanleitung.
ServBay läuft korrekt: Die wichtigsten ServBay-Dienste (z.B. Caddy oder Apache, sowie die gewünschten Datenbanken) sind aktiv.
Grundkenntnisse: Ein Basiswissen zu PHP, Composer und Symfony ist vorhanden.

Symfony-Projekt anlegen

ServBay empfiehlt, alle Website-Projekte im Verzeichnis /Applications/ServBay/www zu speichern – so ist eine einfache Erkennung und Verwaltung Ihrer Projekte gewährleistet.

Prüfen Sie Composer
Composer ist bereits integraler Bestandteil der ServBay-Installation, das System ist entsprechend vorkonfiguriert. Sie müssen Composer nicht separat installieren. Überprüfen Sie die Verfügbarkeit per Terminal-Befehl composer --version.
Projektverzeichnis anlegen
Erstellen Sie im empfohlenen Root-Verzeichnis einen neuen Ordner für Ihr Symfony-Projekt:
bash
```
cd /Applications/ServBay/www
mkdir servbay-symfony-app
```
1
2
Symfony-Projekt per Composer erstellen
Wechseln Sie in das neu erstellte Verzeichnis und erstellen Sie mittels Composer ein neues Projekt basierend auf dem website-skeleton. Das website-skeleton ist eine von Symfony gepflegte Vorlage für klassische Webanwendungen.
bash
```
cd /Applications/ServBay/www/servbay-symfony-app
composer create-project symfony/website-skeleton .
```
1
2
Nach Ausführen dieses Befehls lädt Composer alle für Symfony notwendigen Kernpakete und Abhängigkeiten in das aktuelle Arbeitsverzeichnis.

Initiale Konfiguration

Die zentralen Konfigurationen eines Symfony-Projekts werden meist über Umgebungsvariablen gesteuert, die in der Datei .env im Projekt-Root hinterlegt sind.

Umgebungsvariablen konfigurieren (.env)
Öffnen Sie die Datei .env im Root des Projekts. Sie enthält die wichtigsten Konfigurationen Ihrer Anwendung – etwa Datenbankverbindungen und Applikationsschlüssel. Passen Sie die Einträge nach Bedarf an.
Achten Sie auf folgende Einstellungen oder passen Sie sie Ihrer ServBay-Umgebung an:
dotenv
```
# Beispiel für .env-Datei
APP_ENV=dev # Entwicklungsumgebung
APP_SECRET=your_secret_key # Ersetzen durch eine eindeutige Zufallszeichenkette, dient der Sicherheit

# Datenbankverbindungen (Beispiel für MySQL, Details weiter unten)
# 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"
```
1
2
3
4
5
6
7
8
Ersetzen Sie your_secret_key durch einen sicheren, zufälligen Wert. Standardmäßig ist der Datenbank-User unter ServBay meist root, Passwort password (Achten Sie im Produktivbetrieb unbedingt auf sichere Zugangsdaten!). Im Beispiel verwenden wir servbay_symfony_app als Datenbanknamen.

Webserver konfigurieren (ServBay Website)

Um Ihr Symfony-Projekt im Browser aufzurufen, richten Sie in ServBay eine lokale virtuelle Website ein. Das Web-Root eines Symfony-Projekts ist stets das Unterverzeichnis public/.

Öffnen Sie das ServBay Control Panel, navigieren Sie zu „Website“-Einstellungen (bzw. „Host“-Einstellungen in älteren Versionen), und fügen Sie eine neue Website hinzu:

Name: Vergeben Sie eine leicht erkennbare Bezeichnung, z.B. My Symfony Dev Site.
Domain: Setzen Sie einen Entwicklungs-Domainnamen wie servbay-symfony-test.local. ServBay leitet diesen automatisch lokal um.
Website-Typ: Wählen Sie PHP.
PHP Version: Nutzen Sie eine zu Symfony passende PHP-Version, idealerweise die aktuellste stabile von ServBay (z.B. 8.3).
Website-Root: Entscheidend ist, dass als Wurzel das Verzeichnis public/ des Projekts angegeben wird – also /Applications/ServBay/www/servbay-symfony-app/public.

Speichern und übernehmen Sie die Änderungen. ServBay aktualisiert jetzt selbstständig die Server-Konfiguration. Die Software verwendet Caddy oder Apache als Webserver und generiert für Ihre gewählten Domains automatisch und vertrauenswürdig SSL-Zertifikate – Sie können Ihr Projekt daher direkt per HTTPS aufrufen.

Ausführliche Schritt-für-Schritt-Anleitungen finden Sie unter ServBay Ihre erste Website hinzufügen.

Beispielcode einfügen

Um zu prüfen, ob Ihre Website-Konfiguration funktioniert, fügen wir eine einfache Route und einen Controller hinzu, der beim Aufruf der Startseite einen Text ausgibt.

Route konfigurieren (config/routes.yaml)
Öffnen Sie die Datei config/routes.yaml und ergänzen Sie eine Route für /, die auf eine Controller-Methode index verweist:
yaml
```
# config/routes.yaml
index:
    path: /
    controller: App\Controller\DefaultController::index
```
1
2
3
4

Controller anlegen (src/Controller/DefaultController.php)

Erstellen Sie im Verzeichnis src/Controller/ die Datei DefaultController.php mit folgendem Inhalt:

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
    {
        // Gibt eine einfache HTTP-Antwort zurück
        return new Response('Hello ServBay and Symfony!');
    }
}

Dieser Code definiert die Controller-Klasse DefaultController. Über die Annotation @Route("/") ist die Methode index mit der Startseite / Ihrer Website verbunden. Beim Aufruf dieser Route wird der Text "Hello ServBay and Symfony!" ausgegeben.

Website aufrufen

Starten Sie jetzt Ihren Webbrowser und rufen Sie die in ServBay konfigurierte Domain https://servbay-symfony-test.local auf. Wenn alles korrekt eingerichtet ist, sehen Sie folgende Ausgabe:

Hello ServBay and Symfony!

Damit läuft Ihr Symfony-Projekt erfolgreich über den Webserver von ServBay. ServBay sorgt für automatisches HTTPS – nutzen Sie daher bitte konsequent https://....

Datenbank- und Cache-Beispiele

Symfony verwendet meist Doctrine ORM für relationale Datenbanken und die Symfony-Cache-Komponente für Caching sowie NoSQL. ServBay liefert verschiedene Datenbankdienste und die passenden PHP-Extensions gleich mit. So können Sie diese Services einfach im Symfony-Projekt einbinden.

Beispiel: Relationale Datenbanken (Doctrine ORM)

ServBay unterstützt MySQL und PostgreSQL – wir erläutern die Einrichtung mit beiden Systemen in Symfony.

Datenbankverbindung konfigurieren
Bearbeiten Sie in der .env-Datei im Root die Zeile DATABASE_URL je nach verwendeter Datenbank (Kommentierung entfernen und anpassen):
- Für MySQL: Standardmäßig ist MySQL unter ServBay mit User root, Passwort password und Port 3306 vorkonfiguriert.
  dotenv
```
# .env
DATABASE_URL="mysql://root:[email protected]:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"
```
  1
  2
- Für PostgreSQL: PostgreSQL benutzt analog User root, Passwort password und Port 5432.
  dotenv
```
# .env
DATABASE_URL="postgresql://root:[email protected]:5432/servbay_symfony_app?serverVersion=13&charset=utf8"
```
  1
  2
Stellen Sie sicher, dass der entsprechende Datenbankdienst (MySQL oder PostgreSQL) in der ServBay-Oberfläche läuft.
Datenbank anlegen
Sofern die Datenbank servbay_symfony_app noch nicht existiert, erstellen Sie sie entweder manuell über einen ServBay-Datenbankmanager (z.B. phpMyAdmin oder pgAdmin) oder per Symfony-CLI:
bash
```
php bin/console doctrine:database:create
```
1
Entity und Migration erzeugen
Zuordnungen zu Datenbanktabellen geschehen in Symfony via Doctrine Entities. Erstellen Sie diese und die zugehörigen Migrationsdateien mit dem Maker Bundle.
- Entity (z.B. User) anlegen:
  bash
```
php bin/console make:entity User
```
  1
  Beim Erstellen werden Sie nach Feldern wie name (string) und email (string, unique=yes) gefragt.
- Migration generieren: Erstellen Sie danach die Migration passend zu den aktuellen Entities:
  bash
```
php bin/console make:migration
```
  1
  Dies erzeugt unter src/Migrations eine Datei mit SQL-Befehlen für die Erstellung der Tabelle users.
Migration ausführen
Übernehmen Sie die neue Struktur per Migration in die Datenbank:
bash
```
php bin/console doctrine:migrations:migrate
```
1

Beispiel für Datenbankoperationen

Ergänzen Sie src/Controller/DefaultController.php um eine Route und Methoden, die zeigen, wie Sie mit Doctrine Daten schreiben und lesen. Der EntityManagerInterface wird dafür per Dependency Injection hereingegeben.

Fügen Sie zunächst einen Konstruktor für das Dependency Injection von EntityManagerInterface hinzu:

php

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

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface; // Import von EntityManagerInterface
use App\Entity\User; // Import der User-Entity
use Symfony\Component\HttpFoundation\JsonResponse; // Für JSON-Antworten

class DefaultController
{
    private $entityManager;

    // Dependency Injection von EntityManagerInterface
    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

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

    // ... weitere Methoden ...
}

Erweitern Sie dann config/routes.yaml um neue Routen:

yaml

# config/routes.yaml
# ... weitere Routen ...
mysql_add_user:
    path: /mysql-add-user # oder /pgsql-add-user je nach Datenbank
    controller: App\Controller\DefaultController::addUser
mysql_get_users:
    path: /mysql-users # oder /pgsql-users
    controller: App\Controller\DefaultController::getUsers

Ergänzen Sie in src/Controller/DefaultController.php die passenden Methoden:

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; // Für JSON-Antworten

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();
        // Beispiel-Daten rund um ServBay verwenden
        $user->setName('ServBay Demo User');
        $user->setEmail('[email protected]');

        // Objekt für Datenbank speichern vormerken
        $this->entityManager->persist($user);
        // Schreiben in die Datenbank auslösen
        $this->entityManager->flush();

        return new Response('User erfolgreich hinzugefügt!');
    }

    /**
     * @Route("/get-users", name="app_get_users")
     */
    public function getUsers(): JsonResponse
    {
        // Alle User-Entities aus der Datenbank laden
        $users = $this->entityManager->getRepository(User::class)->findAll();

        // In Array formatieren für JSON-Antwort
        $usersArray = [];
        foreach ($users as $user) {
            $usersArray[] = [
                'id' => $user->getId(),
                'name' => $user->getName(),
                'email' => $user->getEmail(),
            ];
        }

        // Rückgabe im JSON-Format
        return new JsonResponse($usersArray);
    }
}

Beispiel aufrufen
- Besuchen Sie https://servbay-symfony-test.local/add-user, um einen User hinzuzufügen.
- Besuchen Sie https://servbay-symfony-test.local/get-users, um die Userliste (im JSON-Format) zu sehen.

Beispiel: Cache und NoSQL (Symfony Cache)

ServBay stellt Redis und Memcached samt passender PHP-Extensions bereit. Nutzen Sie diese in Symfony per Symfony Cache-Komponente.

Cache-Verbindung einstellen

Bearbeiten Sie in .env die Cache-DSN-Einstellung.

Für Memcached: Der Standardport ist 11211.
dotenv
```
# .env
# ... weitere Konfigurationen ...
CACHE_DSN=memcached://127.0.0.1:11211
```
1
2
3
Starten Sie Memcached in der ServBay-Oberfläche.

Für Redis: Der Standardport ist 6379.

dotenv

# .env
# ... weitere Konfigurationen ...
CACHE_DSN=redis://127.0.0.1:6379
# Falls Redis ein Passwort hat (Standard: keins), so eintragen:
# CACHE_DSN=redis://:[email protected]:6379

Aktivieren Sie Redis im ServBay-Panel.

Cache-Nutzung demonstrieren

Ergänzen Sie src/Controller/DefaultController.php um einen passenden Konstruktor-Parameter für CacheInterface und richten Sie Methoden gemäß Symfony Cache-Komponente ein.

Erweitern Sie die Injects im Konstruktor so:

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; // Import von CacheInterface

class DefaultController
{
    private $entityManager;
    private $cache; // Cache-Property

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

    // ... weitere Methoden ...
}

Ergänzen Sie config/routes.yaml um einen neuen Eintrag:

yaml

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

Fügen Sie in src/Controller/DefaultController.php die neue Cache-Methode hinzu:

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; // Import von ItemInterface

class DefaultController
{
    private $entityManager;
    private $cache;

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

    // ... weitere Methoden ...

    /**
     * @Route("/cache-example", name="app_cache_example")
     */
    public function cacheExample(): Response
    {
        // Versucht, Daten aus dem Cache zu lesen
        $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
            // Bei Cache-Miss wird dieses Callback ausgeführt
            $item->expiresAfter(3600); // Ablaufzeit: 1 Stunde

            // Simuliere teure Operation, z.B. DB-Zugriff
            $data = "Daten erzeugt am " . date('Y-m-d H:i:s');

            // Daten zur Rückgabe in den Cache
            return $data;
        });

        // $cacheItem enthält jetzt die (ggf. neue) Information
        $output = "Aus dem Cache: " . $cacheItem;

        return new Response($output);
    }
}

Beispiel aufrufen
- Greifen Sie auf https://servbay-symfony-test.local/cache-example zu. Beim ersten Aufruf wird der Callback zur Datengenerierung ausgeführt und die Information gecacht. Weitere Zugriffe (bis zum Ablauf) lesen direkt aus dem Cache.

FAQ – Häufige Probleme

F: Die Seite https://servbay-symfony-test.local ist nicht erreichbar oder zeigt einen 500-Fehler. Was tun?

A: Prüfen Sie Folgendes:

Läuft ServBay sowie der Webserver (Caddy/Apache)?
Ist im ServBay-Website-Panel die Domain servbay-symfony-test.local korrekt gesetzt und zeigt der „Website-Root“ exakt auf /Applications/ServBay/www/servbay-symfony-app/public?
Siehe Symfony-Logdatei (var/log/dev.log) für Fehlerdetails.
Führen Sie im Projektroot composer install aus (installiert alle Abhängigkeiten).
Passt die genutzte PHP-Version zur Symfony-Version?

F: Datenbankverbindung schlägt fehl. Was tun?

A: Folgende Punkte prüfen:

Ist der entsprechende Datenbankdienst (MySQL/PostgreSQL) in ServBay gestartet?
Stimmen die Angaben in .env bezüglich DATABASE_URL (Nutzername, Passwort, Host 127.0.0.1, Port 3306/5432, Datenbankname)?
Passen Username und Passwort zu den hinterlegten ServBay-Standardwerten bzw. Ihrer Konfiguration?
Existiert die Datenbank servbay_symfony_app bereits?

F: Der Befehl php bin/console funktioniert nicht?

A: Prüfen Sie, ob Ihr Terminal im richtigen Verzeichnis /Applications/ServBay/www/servbay-symfony-app steht und ob das PHP von ServBay korrekt im PATH eingerichtet ist (wird normalerweise bei Installation automatisch erledigt). Ein which php im Terminal hilft ebenfalls zur Prüfung.

Fazit

Mit dieser Anleitung haben Sie erfolgreich ein Symfony-Projekt mit ServBay auf macOS erstellt, konfiguriert und gestartet. ServBay bringt sämtliche Kernkomponenten für die Symfony-Entwicklung (PHP, Composer, Webserver, Datenbank, Cache) mit und macht die Umgebungs-Einrichtung besonders zeitsparend und komfortabel. Bauen Sie Ihr Projekt darauf weiter aus und entdecken Sie zusätzlich die vielen weiteren Softwarepakete und Dienste, die ServBay Ihnen bietet.

Symfony Projekt erstellen und ausführen ​

Was ist Symfony? ​

Die wichtigsten Features & Vorteile von Symfony ​

Symfony-Projekt mit ServBay erstellen und ausführen ​

Voraussetzungen ​

Symfony-Projekt anlegen ​

Initiale Konfiguration ​

Webserver konfigurieren (ServBay Website) ​

Beispielcode einfügen ​

Website aufrufen ​

Datenbank- und Cache-Beispiele ​

Beispiel: Relationale Datenbanken (Doctrine ORM) ​

Beispiel: Cache und NoSQL (Symfony Cache) ​

FAQ – Häufige Probleme ​

Fazit ​