Symfony-Projekt erstellen und ausführen

ServBay ist eine speziell für macOS und Windows entwickelte lokale Webentwicklungsumgebung, die Laufzeitumgebungen für PHP, Node.js, Python, Go, Java sowie Datenbanken wie MySQL, PostgreSQL, MongoDB, Redis und Webserver wie Apache und Caddy integriert. In diesem Leitfaden erfahren Sie Schritt für Schritt, wie Sie mit ServBay auf macOS und Windows schnell ein Symfony-Projekt einrichten und ausführen.

Was ist Symfony?

Symfony ist ein Open-Source-PHP-Webframework, das von SensioLabs erstellt wurde. Es bietet Entwickler*innen ein leistungsfähiges, flexibles und effizientes Werkzeugset für die Entwicklung moderner Webanwendungen und Schnittstellen (APIs). Symfony orientiert sich an den gängigen Best Practices der Webentwicklung und stellt viele Funktionsmodule bereit, z. B. Routing, Template-Engine (Twig), Formularverarbeitung, Authentifizierung, Dependency Injection und mehr, sodass typische Entwicklungsaufgaben erheblich erleichtert werden.

Hauptmerkmale und Vorteile von Symfony

Modulares Design: Die Stärke von Symfony liegt in seiner Bibliothek wiederverwendbarer Komponenten. Entwickler*innen können selektiv benötigte Module nutzen und so Projekte von leichtgewichtig bis umfassend skalieren.
Hohe Performance: Dank der optimierten Architektur, effizientem Caching und Unterstützung der neuesten PHP-Features ist Symfony äußerst leistungsfähig.
Starke Community: Ein großes Netzwerk aus Entwickler*innen, unzählige Drittanbieter-Bundles (Plugins) und ausführliche Dokumentation sorgen für schnellen Support bei Problemen.
Flexibilität: Symfony lässt sich unkompliziert mit zahlreichen Libraries und Erweiterungen integrieren und eignet sich für Projekte jeglicher Größe und Komplexität.
Stabilität und Wartbarkeit: Durch bewährte Coding-Standards und Design-Muster sind Anwendungen einfach zu testen, zu pflegen und zu erweitern.

Symfony eignet sich sowohl für kleine API-Projekte als auch für komplexe Unternehmensanwendungen und große Websysteme.

Symfony-Projekte mit ServBay erstellen und ausführen

ServBay stellt alle notwendigen Komponenten für Symfony-Projekte bereit: passende PHP-Versionen, Composer, Webserver, unterschiedliche Datenbanken und Caching-Dienste. Dieser Abschnitt führt Sie durch die Einrichtung und Konfiguration Ihres ersten Symfony-Projekts mit ServBay.

Voraussetzungen

Bevor Sie starten, stellen Sie bitte Folgendes sicher:

ServBay installiert: Sie haben ServBay erfolgreich unter macOS installiert und gestartet. Falls ServBay noch nicht installiert ist, hilft Ihnen die ServBay Installationsanleitung.
ServBay läuft fehlerfrei: Die wichtigsten ServBay-Dienste wie Caddy oder Apache sowie die gewünschte Datenbank sind aktiv.
Grundkenntnisse: Sie kennen die Basisbegriffe von PHP, Composer und Symfony.

Symfony-Projekt erstellen

ServBay empfiehlt, Website-Projekte einheitlich im Verzeichnis /Applications/ServBay/www zu speichern. So erkennt und verwaltet ServBay Ihre Projekte optimal.

Composer-Verfügbarkeit prüfen
Composer ist bei ServBay standardmäßig installiert und konfiguriert. Sie brauchen nichts extra zu tun. Über die Konsole prüfen Sie per composer --version, ob Composer verfügbar ist.
Projektverzeichnis anlegen
Erstellen Sie im empfohlenen Webroot-Verzeichnis einen neuen Ordner für Ihr Symfony-Projekt:
bash
```
cd /Applications/ServBay/www
mkdir servbay-symfony-app
```
1
2
Symfony-Projekt mit Composer erstellen
Wechseln Sie ins neue Projektverzeichnis und erstellen Sie mit Composer ein Symfony-Projekt auf Basis des website-skeleton-Templates. Dieses enthält gängige Abhängigkeiten für klassische Webanwendungen.
bash
```
cd /Applications/ServBay/www/servbay-symfony-app
composer create-project symfony/website-skeleton .
```
1
2
Nach dem Ausführen lädt Composer die Symfony-Kerndateien und alle Abhängigkeiten ins aktuelle Verzeichnis.

Initialkonfiguration

Die wichtigsten Einstellungen für Symfony werden über Umgebungsvariablen gesteuert, meist in der Datei .env im Projekt-Root gespeichert.

Umgebungsvariablen konfigurieren (.env)
Öffnen Sie die .env-Datei im Projektordner. Sie enthält Einstellungen zu z. B. Datenbankanbindung und App-Secret. Passen Sie die Konfiguration nach Bedarf an.
Beispiel für eine typische Konfiguration:
dotenv
```
# Beispiel für .env-Datei
APP_ENV=dev # Entwicklungsmodus
APP_SECRET=your_secret_key # Ersetzen Sie dies durch einen eindeutigen, zufälligen String für die Sicherheit

# Datenbankverbindung (im Beispiel MySQL – weitere Details unten)
# 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
Ersetzen Sie your_secret_key durch einen sicheren, zufälligen Schlüssel. Der Standard-Datenbanknutzer bei ServBay heißt oft root, das Passwort ist password (bitte in Produktionsumgebungen unbedingt ändern!). Im Beispiel verwenden wir als Datenbanknamen servbay_symfony_app.

Webserver konfigurieren (ServBay Website)

Um Ihr Symfony-Projekt im Browser aufzurufen, richten Sie über ServBays "Website"-Funktion einen lokalen Host ein. Das Web-Root für Symfony-Projekte ist das public/-Verzeichnis im Projektordner.

Öffnen Sie das ServBay-Panel und gehen Sie zu den „Websites“-Einstellungen (bei älteren Versionen: „Hosts“) und legen Sie eine neue Website an:

Name: Vergeben Sie einen sprechenden Namen, z. B. My Symfony Dev Site.
Domain: Legen Sie eine lokale Entwicklungsdomain an, z. B. servbay-symfony-test.local. ServBay konfiguriert die Umleitung automatisch.
Websitetyp: Wählen Sie PHP.
PHP-Version: Wählen Sie eine mit Ihrem Symfony-Projekt kompatible Version, z. B. ServBays aktuelle Stable-Version 8.3.
Root-Verzeichnis: Wichtig! Für Symfony muss das Root auf das Verzeichnis /Applications/ServBay/www/servbay-symfony-app/public zeigen.

Nach dem Speichern übernimmt ServBay die Einstellungen automatisch und aktualisiert die Webserver-Konfiguration. ServBay generiert und vertraut standardmäßig SSL-Zertifikate für Ihre lokale Domain, sodass Sie die Website bequem per HTTPS aufrufen.

Ausführliche Schritt-für-Schritt-Anleitung: Erste Website in ServBay hinzufügen.

Beispiel-Code hinzufügen

Testen Sie die Konfiguration, indem Sie eine einfache Route und einen Controller anlegen – bei Aufruf der Domain soll Text im Browser erscheinen.

Route konfigurieren (config/routes.yaml)
Öffnen Sie die Datei config/routes.yaml und fügen Sie eine Route für den Pfad / hinzu, die auf die Methode index im Controller zeigt:
yaml
```
# config/routes.yaml
index:
    path: /
    controller: App\Controller\DefaultController::index
```
1
2
3
4

Controller erstellen (src/Controller/DefaultController.php)

Legen Sie in src/Controller/ die Datei DefaultController.php mit folgendem Inhalt an:

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!');
    }
}

Die Klasse DefaultController definiert eine Methode index, die über die Annotation @Route("/") der URL / zugeordnet ist. Beim Aufruf erscheint die Nachricht "Hello ServBay and Symfony!" im Browser.

Website aufrufen

Öffnen Sie nun Ihren Webbrowser und rufen Sie die konfigurierte Domain https://servbay-symfony-test.local auf. Bei korrekter Einrichtung sehen Sie:

Hello ServBay and Symfony!

Ihr Symfony-Projekt läuft jetzt erfolgreich über den ServBay-Webserver. SSL ist automatisch konfiguriert, daher sollten Sie die Seite via https:// aufrufen.

Beispiel für Datenbank und Caching

Symfony nutzt typischerweise Doctrine ORM für relationale Datenbanken und das Symfony-Cache-Modul für Caching sowie NoSQL-Datenbanken. ServBay bringt entsprechende Dienste und PHP-Erweiterungen direkt mit; Sie können sie einfach in Ihrem Symfony-Projekt einbinden.

Beispiel relationale Datenbank (Doctrine ORM)

ServBay unterstützt MySQL und PostgreSQL. Im Folgenden konfigurieren und nutzen wir beide Systeme.

Datenbankverbindung konfigurieren
Bearbeiten Sie die .env-Datei im Projektordner und passen Sie DATABASE_URL je nach verwendeter Datenbank an.
- Für MySQL: ServBay nutzt standardmäßig User root, Passwort password, Port 3306. Die Konfiguration:
  dotenv
```
# .env
DATABASE_URL="mysql://root:password@127.0.0.1:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"
```
  1
  2
- Für PostgreSQL: Standardnutzer root, Passwort password, Port 5432:
  dotenv
```
# .env
DATABASE_URL="postgresql://root:password@127.0.0.1:5432/servbay_symfony_app?serverVersion=13&charset=utf8"
```
  1
  2
Starten Sie die gewünschte Datenbank (MySQL oder PostgreSQL) im ServBay-Panel.
Datenbank anlegen
Falls servbay_symfony_app noch nicht existiert, können Sie sie über ServBays Datenbank-Tools (phpMyAdmin oder pgAdmin) per Hand erstellen oder per Symfony-Konsole:
bash
```
php bin/console doctrine:database:create
```
1
Entity und Migration erstellen
In Symfony wird jede Tabelle als Entity (z. B. User) beschrieben. Mit dem Maker-Bundle können Entities und Migrations einfach generiert werden.
- Entity erstellen (User):
  bash
```
php bin/console make:entity User
```
  1
  Folgen Sie den Prompts, um z. B. die Felder name (string) und email (string, unique=yes) anzulegen.
- Migration generieren: Mit make:migration wird die Migration im Ordner src/Migrations erstellt:
  bash
```
php bin/console make:migration
```
  1
Migration ausführen
Übertragen Sie die Datenbankstruktur per Migration:
bash
```
php bin/console doctrine:migrations:migrate
```
1

Beispiel für Datenbankoperationen

Passen Sie src/Controller/DefaultController.php an, um zu zeigen, wie Sie mit Doctrine Daten schreiben und lesen. Sie müssen EntityManagerInterface injizieren.

Die Konstruktor-Injektion im Controller:

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 EntityManagerInterface
use App\Entity\User; // Import User Entity
use Symfony\Component\HttpFoundation\JsonResponse; // Für JSON-Antworten

class DefaultController
{
    private $entityManager;

    // EntityManager per 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!');
    }

    // ... weitere Methoden ...
}

Routen in config/routes.yaml anlegen:

yaml

# config/routes.yaml
# ... weitere Routen ...
mysql_add_user:
    path: /mysql-add-user # Oder /pgsql-add-user für PostgreSQL
    controller: App\Controller\DefaultController::addUser
mysql_get_users:
    path: /mysql-users # Oder /pgsql-users
    controller: App\Controller\DefaultController::getUsers

Controller-Methoden ergänzen:

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();
        // Beispiel-Daten mit ServBay-Bezug
        $user->setName('ServBay Demo User');
        $user->setEmail('demo-user@servbay.test');

        // Objekt persistieren (zum Speichern vormerken)
        $this->entityManager->persist($user);
        // Daten speichern
        $this->entityManager->flush();

        return new Response('User added successfully!');
    }

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

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

        // Antwort als JSON
        return new JsonResponse($usersArray);
    }
}

Beispiel aufrufen
- Aufruf von https://servbay-symfony-test.local/add-user legt einen neuen Benutzer an.
- Mit https://servbay-symfony-test.local/get-users wird die Liste der gespeicherten Benutzer als JSON angezeigt.

Beispiel für Caching und NoSQL (Symfony Cache)

ServBay hat Redis und Memcached sowie passende PHP-Erweiterungen vorinstalliert. Sie können die Symfony-Cache-Komponente direkt nutzen.

Cache-Verbindung einrichten

Tragen Sie in die .env-Datei die Konfiguration für den gewünschten Cache ein.

Memcached (Standard-Port 11211):
dotenv
```
# .env
# ... weitere Konfiguration ...
CACHE_DSN=memcached://127.0.0.1:11211
```
1
2
3
Starten Sie Memcached im ServBay-Panel.

Redis (Standard-Port 6379):

dotenv

# .env
# ... weitere Konfiguration ...
CACHE_DSN=redis://127.0.0.1:6379
# Für Redis mit Passwort (ServBay typisch ohne Passwort):
# CACHE_DSN=redis://:your_password@127.0.0.1:6379

Starten Sie Redis im ServBay-Panel.

Cache-Beispiel einbauen

Ergänzen Sie src/Controller/DefaultController.php mit einer Beispielroute, um den Symfony-Cache mit Memcached oder Redis zu nutzen. Sie benötigen dafür CacheInterface.

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

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

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

    // ... weitere Methoden ...
}

Neue Route in config/routes.yaml:

yaml

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

Controller-Methode ergänzen:

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 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
    {
        // Holt Daten aus dem Cache (oder erzeugt sie neu)
        $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
            // Callback wird nur bei Cache-Miss ausgeführt
            $item->expiresAfter(3600); // Gültigkeit: 1 Stunde

            // Zeitaufwändige Berechnung simulieren, z. B. komplexer Datenbankzugriff
            $data = "Data generated at " . date('Y-m-d H:i:s');

            // Rückgabe der zu cachenden Daten
            return $data;
        });

        // $cacheItem ist die gecachte oder frisch erzeugte Information
        $output = "From Cache: " . $cacheItem;

        return new Response($output);
    }
}

Beispiel aufrufen
- Rufen Sie https://servbay-symfony-test.local/cache-example im Browser auf. Beim ersten Aufruf wird das Callback ausgeführt und die Daten landen im Cache. Folgeaufrufe (sofern Cache nicht abgelaufen) liefern die Daten direkt aus Memcached oder Redis.

Häufige Fragen (FAQ)

F: Ich bekomme einen Fehler oder die Seite ist unter https://servbay-symfony-test.local nicht erreichbar (404/500)?

A: Prüfen Sie bitte:

Läuft ServBay und sind die betreffenden Dienste (Caddy/Apache) aktiv?
Ist die Domain servbay-symfony-test.local korrekt hinterlegt und zeigt das Website-Root auf /Applications/ServBay/www/servbay-symfony-app/public?
Schauen Sie ins Symfony-Logfile (var/log/dev.log) für genaue Fehlerhinweise.
Führen Sie im Projektverzeichnis composer install aus, um fehlende Abhängigkeiten zu installieren.
Die PHP-Version muss mit Ihrem Symfony-Projekt kompatibel sein.

F: Datenbankverbindung scheitert?

A: Prüfen Sie bitte:

Ist der gewünschte ServBay-Datenbankdienst (MySQL/PostgreSQL) aktiv?
Ist die .env-Konfiguration (DATABASE_URL) korrekt (Benutzername, Passwort, Host (127.0.0.1), Port (MySQL 3306/PostgreSQL 5432), Datenbankname)?
Stimmen Datenbankbenutzer und Passwort mit ServBay-Standardeinstellungen oder Ihren Anpassungen überein?
Ist die Datenbank servbay_symfony_app tatsächlich angelegt?

F: php bin/console funktioniert nicht?

A: Stellen Sie sicher, dass Ihr aktuelles Verzeichnis /Applications/ServBay/www/servbay-symfony-app ist und dass ServBay PHP korrekt im System-PATH hinterlegt ist (ServBay regelt dies normalerweise automatisch). Mit which php können Sie prüfen, ob ServBay-PHP genutzt wird.

Zusammenfassung

Mit diesem Leitfaden haben Sie erfolgreich ein Symfony-Projekt unter macOS mit ServBay erstellt, konfiguriert und ausgeführt. ServBay liefert alle Kernkomponenten für die Symfony-Entwicklung (PHP, Composer, Webserver, Datenbank, Caching) und vereinfacht die Einrichtung erheblich – so können Sie sich direkt auf Ihre Anwendung konzentrieren. Nutzen Sie dieses Basisprojekt als Ausgangspunkt, um tiefer in Symfony einzusteigen und weitere Features mithilfe ServBays umfangreicher Software-Auswahl zu realisieren.

Symfony-Projekt erstellen und ausführen ​

Was ist Symfony? ​

Hauptmerkmale und Vorteile von Symfony ​

Symfony-Projekte mit ServBay erstellen und ausführen ​

Voraussetzungen ​

Symfony-Projekt erstellen ​

Initialkonfiguration ​

Webserver konfigurieren (ServBay Website) ​

Beispiel-Code hinzufügen ​

Website aufrufen ​

Beispiel für Datenbank und Caching ​

Beispiel relationale Datenbank (Doctrine ORM) ​

Beispiel für Caching und NoSQL (Symfony Cache) ​

Häufige Fragen (FAQ) ​

Zusammenfassung ​