Slim-Projekt in ServBay erstellen und ausführen

Diese Anleitung zeigt Ihnen, wie Sie mit ServBay – einer leistungsstarken lokalen Webentwicklungsumgebung – schnell ein PHP-Projekt mit dem Slim Framework erstellen, konfigurieren und starten. ServBay bietet integrierte PHP-Versionen, Webserver (Caddy/Nginx/Apache) sowie verschiedene Datenbankpakete und ist somit die ideale Plattform für die Slim-Entwicklung.

Was ist Slim?

Slim ist ein leichtgewichtiges PHP-Microframework, das speziell für die schnelle Entwicklung von einfachen, dennoch leistungsfähigen Webanwendungen und APIs konzipiert wurde. Es bietet Kernfunktionen für Routing, Request- und Response-Verarbeitung und eignet sich besonders für Projekte, die rasch entwickelt und deployed werden sollen oder als Basis komplexerer Anwendungen.

Hauptmerkmale und Vorteile von Slim

• Leichtgewichtig: Der Slim-Core ist sehr klein, verbraucht wenig Ressourcen und startet schnell – ideal für kleinere bis mittelgroße Anwendungen oder Microservices.
• Flexible Integration: Slim ist modular aufgebaut und lässt sich mühelos mit Drittanbieter-Bibliotheken wie Template-Engines, ORMs oder Authentifizierungs-Lösungen verbinden. Sie haben volle Freiheit bei der Auswahl der Tools für Ihr Projekt.
• Benutzerfreundlich: Dank einer klaren API und umfassender Dokumentation lernen Entwickler die Basics schnell und können direkt loslegen.
• Leistungsstarkes Routing: Unterstützt verschiedene HTTP-Methoden (GET, POST, PUT, DELETE etc.) und komplexe Routen-Konfigurationen – inklusive Gruppen, Middleware und Parameter-Erfassung.
• Middleware-Unterstützung: In der Middleware-Schicht können Sie Aufgaben wie Authentifizierung, Logging oder CORS bequem abfangen, bevor die Logik ausgeführt oder eine Antwort gesendet wird.

Slim ist ideal für den Aufbau von RESTful APIs, schnelles Prototyping und spezielle, isolierte Funktionsbereiche.

Slim-Projekt mit ServBay erstellen und ausführen

In dieser Anleitung verwenden wir die vorkonfigurierte PHP-Umgebung von ServBay und die Websites-Funktion für die Webserver-Einrichtung, um den Zugriff auf Ihr Slim-Projekt zu ermöglichen.

Voraussetzungen

Bevor Sie starten, stellen Sie sicher:

1. ServBay installiert und läuft: Installieren Sie ServBay auf Ihrem macOS- oder Windows-System und starten Sie die Anwendung.
2. Composer in ServBay integriert: Composer ist in ServBay bereits dabei – Sie müssen es nicht extra installieren.

Slim-Projekt anlegen

Es wird empfohlen, alle Website-Projekte im folgenden Ordner zu speichern, damit ServBay die Verwaltung und Konfiguration übernehmen kann:

• macOS: /Applications/ServBay/www
• Windows: C:\ServBay\www

1. In das ServBay-Web-Verzeichnis wechseln:

   macOS:

   cd /Applications/ServBay/www

   Windows:

   cd C:\ServBay\www

2. Projektordner erstellen: Legen Sie einen neuen Ordner für Ihr Slim-Projekt an.

   mkdir servbay-slim-app

3. In das Projektverzeichnis wechseln:

   cd servbay-slim-app

4. Slim mit Composer installieren: Installieren Sie im Projektverzeichnis das Slim Framework und die PSR-7-Implementierung.

   composer require slim/slim "^4.0" slim/psr7 -W

   Dieser Befehl lädt das Slim-Framework sowie die Bibliothek slim/psr7 in den vendor-Ordner Ihres Projekts und erstellt die Dateien composer.json und composer.lock.

Slim-Anwendung initialisieren

1. Einstiegsdatei anlegen: Ein Slim-Projekt verwendet üblicherweise eine zentrale Einstiegsdatei (z.B. public/index.php) für alle Anfragen. Erstellen Sie im Projektverzeichnis einen public-Ordner und darin die Datei index.php.

   mkdir public
   touch public/index.php

2. Einstiegsdatei bearbeiten: Öffnen Sie public/index.php und fügen Sie folgenden Beispielcode ein:

   <?php
   // Composer Autoloader laden
   require __DIR__ . '/../vendor/autoload.php';
   
   // Notwendige PSR-7-Schnittstellen und Slim Factory
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Slim-App-Instanz erstellen
   $app = AppFactory::create();
   
   // Einfacher GET-Route für die Startseite '/'
   $app->get('/', function (Request $request, Response $response, $args) {
       // Inhalt in die Antwort schreiben
       $response->getBody()->write("Hello ServBay!");
       // Antwortobjekt zurückgeben
       return $response;
   });
   
   // Slim-Anwendung starten
   $app->run();

   Dieser Basis-Code richtet eine einfache Slim-Anwendung ein, die auf GET-Anfragen an die Root-URL (/) mit einem "Hello ServBay!"-Text antwortet.

ServBay-Website konfigurieren

Damit Ihr Slim-Projekt über den Browser erreichbar ist, müssen Sie in ServBay eine Website (früher "Host") konfigurieren.

1. Öffnen Sie die ServBay-Programmoberfläche.
2. Navigieren Sie zu Websites.
3. Klicken Sie auf „Neue Website hinzufügen“.
4. Füllen Sie die Konfiguration gemäß Ihres Projekts aus:

   • Name: My First Slim Dev Site (oder beliebig anderer Name)

   • Domain: servbay-slim-test.local (Für lokale Entwicklung empfiehlt sich .local oder .test)

   • Website-Typ: PHP

   • PHP-Version: Wählen Sie die gewünschte Version, z.B. 8.3.

   • Dokumentenstamm: Wählen Sie den public-Ordner Ihres Projekts aus:

     • macOS: /Applications/ServBay/www/servbay-slim-app/public
     • Windows: C:\ServBay\www\servbay-slim-app\public

     Der Webserver muss auf das Verzeichnis mit Ihrer Einstiegsdatei index.php zeigen.

5. Speichern Sie die Website-Konfiguration. ServBay aktualisiert die Webserver-Einstellungen automatisch.

Weitere Informationen finden Sie unter Erste Website hinzufügen.

Ihr Slim-Projekt im Browser aufrufen

Nach der Konfiguration öffnen Sie Ihren Webbrowser und rufen die von Ihnen gewählte Domain auf: https://servbay-slim-test.local.

Sollte alles korrekt eingerichtet sein, erscheint der Text Hello ServBay! im Browser – Ihr Slim-Projekt läuft jetzt über den ServBay-Webserver.

Beispiel: Datenbank-Integration

Slim bietet von Haus aus keine Datenbankabstraktion, lässt sich aber leicht mit verschiedenen PHP-Datenbankbibliotheken erweitern. Hier zeigen wir am Beispiel von Laravel Eloquent ORM (illuminate/database), wie Sie MySQL und PostgreSQL anbinden. Zudem erhalten Sie Beispiele für die Integration von Memcached und Redis.

Vorarbeit: Datenbank erstellen und Migration ausführen

Bevor Sie die Datenbankanbindung starten, müssen Sie eine Datenbank in ServBay anlegen und die Tabellenstruktur für Ihre Anwendung erzeugen.

1. Datenbank anlegen:
   • Öffnen Sie die ServBay-Oberfläche und wählen Sie das gewünschte Datenbank-Paket (z.B. MySQL oder PostgreSQL).
   • Verwenden Sie ein Verwaltungstool wie phpMyAdmin (für MySQL/MariaDB), pgAdmin (für PostgreSQL) oder ein CLI-Tool, um eine neue Datenbank anzulegen, z.B. servbay_slim_app.
   • Das Standard-Passwort des Root-Datenbankbenutzers ist meist password. Sie können dies in ServBay einstellen.
2. Phinx installieren (Migrationstool): Phinx dient dem Versionsmanagement Ihrer Datenbankstruktur.
   • Installieren Sie Phinx mit Composer im Projektverzeichnis:
     • macOS: /Applications/ServBay/www/servbay-slim-app
     • Windows: C:\ServBay\www\servbay-slim-app

     composer require robmorgan/phinx

   • Phinx-Konfiguration initialisieren:

     vendor/bin/phinx init

     Damit wird eine Datei phinx.yml im Projektverzeichnis erzeugt. Bearbeiten Sie diese und tragen Sie Ihre Datenbankverbindung ein, z.B.:

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development # Oder Ihr Umgebungsname
     
         development: # Je nach Typ
             adapter: mysql # Oder pgsql
             host: 127.0.0.1
             name: servbay_slim_app # Ihr Datenbankname
             user: root
             pass: password # Ihr Passwort
             port: 3306 # Default MySQL, PostgreSQL: 5432
             charset: utf8mb4 # Empfohlen für MySQL
             collation: utf8mb4_unicode_ci # Empfohlen für MySQL
     
     version_order: creation

3. Migration anlegen: Erzeugen Sie mit Phinx ein neues Migrationsskript.

   vendor/bin/phinx create CreateUsersTable

   Im Ordner db/migrations wird nun eine PHP-Datei erzeugt. Öffnen Sie diese und definieren Sie die Struktur der Tabelle users im change()-Methode:

   <?php
   
   declare(strict_types=1);
   
   use Phinx\Migration\AbstractMigration;
   
   final class CreateUsersTable extends AbstractMigration
   {
       /**
        * Change Method.
        *
        * Write your reversible migrations using this method.
        *
        * More information on writing migrations is available here:
        * https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
        *
        * Remember to call "create()" or "update()" and NOT "save()" when working
        * with the Table class.
        */
       public function change(): void
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string')
                 ->addColumn('email', 'string', ['unique' => true])
                 ->addTimestamps() // Fügt die Felder created_at und updated_at hinzu
                 ->create();
       }
   }

4. Migration ausführen: Starten Sie die Migration im Projektordner, um die Tabelle users zu erzeugen.

   vendor/bin/phinx migrate

   Wichtig: Stellen Sie vor dem Ausführen der Datenbankbeispiele sicher, dass Datenbank und Tabellenstruktur bereits angelegt sind.

Einsatz des illuminate/database-Komponenten

Wir nutzen Laravel Eloquent ORM (illuminate/database) als ORM und Query Builder.

1. Installation von illuminate/database: Installieren Sie die Komponente im Projektverzeichnis:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require illuminate/database

2. Datenbankverbindung in public/index.php konfigurieren: Fügen Sie nach require __DIR__ . '/../vendor/autoload.php';, vor $app = AppFactory::create();, diese Initialisierung ein:

   // ... weitere require- und use-Anweisungen ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // Capsule-Manager importieren
   
   // Eloquent ORM initialisieren
   $capsule = new Capsule;
   
   // Datenbankverbindung konfigurieren (passe 'driver' etc. an)
   $capsule->addConnection([
       'driver' => 'mysql', // Oder 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app', // Ihr Datenbankname
       'username' => 'root', // Ihr Benutzer
       'password' => 'password', // Ihr Passwort
       'charset' => 'utf8mb4', // empfohlen für MySQL
       'collation' => 'utf8mb4_unicode_ci', // empfohlen für MySQL
       'prefix' => '',
       // Für PostgreSQL ggf. schema ergänzen
       // 'schema' => 'public',
   ]);
   
   // Globale Erreichbarkeit aktivieren
   $capsule->setAsGlobal();
   
   // Eloquent starten
   $capsule->bootEloquent();
   
   // ... Slim-App-Instanz erstellen ($app = AppFactory::create();)

MySQL-Beispiel

Angenommen, Sie haben das MySQL-Paket in ServBay gestartet, die Datenbank servbay_slim_app angelegt und die Migration zum Erstellen der Tabelle users durchgeführt.

In public/index.php fügen Sie vor $app->run(); folgende Routen hinzu:

// ... Initialisierung und Route '/'

use Illuminate\Database\Capsule\Manager as Capsule; // Import sicherstellen

// Route zum Hinzufügen eines Benutzers
$app->get('/mysql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay Demo User',
            'email' => 'servbay-demo-' . time() . '@servbay.test', // Email bleibt eindeutig
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500); // Fehlerstatus zurückgeben
    }
    return $response;
});

// Route zum Abrufen aller Benutzer
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // Ausgabe im JSON-Format
        $response = $response->withHeader('Content-Type', 'application/json'); // Content-Type setzen
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Aufruf:

• https://servbay-slim-test.local/mysql-add-user fügt einen neuen Benutzer in die Tabelle users ein.
• https://servbay-slim-test.local/mysql-get-users holt alle Benutzer als JSON zurück.

PostgreSQL-Beispiel

Angenommen, Sie haben das PostgreSQL-Paket in ServBay gestartet, die Datenbank servbay_slim_app angelegt und die Migration zum Erstellen der Tabelle users durchgeführt (achten Sie darauf, in der Phinx-Konfiguration adapter und port auf pgsql und 5432 zu setzen).

Passen Sie in public/index.php die Verbindungsinformationen folgendermaßen an:

$capsule->addConnection([
    'driver' => 'pgsql', // jetzt pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // PostgreSQL verwendet häufig utf8
    'prefix' => '',
    'schema' => 'public', // für PostgreSQL erforderlich
]);
// ... Eloquent-Initialisierung bleibt wie oben ...

Fügen Sie vor $app->run(); folgende Routen hinzu:

// ... Initialisierung und Route '/' ...
// ... ggf. MySQL-Routen ...

use Illuminate\Database\Capsule\Manager as Capsule; // Import sicherstellen

// Route zum Hinzufügen eines Benutzers
$app->get('/pgsql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay PG Demo User',
            'email' => 'servbay-pg-demo-' . time() . '@servbay.test', // Email bleibt eindeutig
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Route zum Abrufen aller Benutzer
$app->get('/pgsql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson());
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Aufruf:

• https://servbay-slim-test.local/pgsql-add-user fügt einen neuen Benutzer in die PostgreSQL-Tabelle users ein.
• https://servbay-slim-test.local/pgsql-get-users holt alle Benutzer als JSON zurück.

Memcached-Beispiel

ServBay enthält Memcached als Paket sowie die PHP-Erweiterung ext-memcached. Sie müssen nur noch einen PHP-Client installieren, z.B. memcached/memcached.

1. Memcached-Client installieren: Führen Sie im Projektverzeichnis folgendes aus:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require memcached/memcached

2. Memcached-Routen in public/index.php ergänzen: Vor $app->run();:

   // ... Initialisierung und Datenbank-Routen ...
   
   // Beispielroute für Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Memcached-Client anlegen
       $memcached = new Memcached();
       // Memcached-Server hinzufügen (ServBay nutzt standardmäßig 127.0.0.1:11211)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Aus dem Cache lesen
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Falls kein Cache vorhanden, Daten erzeugen und speichern
           $cachedData = 'Hello Memcached from ServBay! This was not cached.';
           // Daten im Cache speichern, Gültigkeit: 60 Sek.
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // Falls Daten gecacht, diese verwenden
           $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
       }
   
       return $response;
   });
   
   // ... $app->run();

Aufruf: Öffnen Sie https://servbay-slim-test.local/memcached-example. Beim ersten Aufruf erscheint "This was not cached.", bei Folgebesuchen innerhalb der Cachezeit "This was served from cache.".

Redis-Beispiel

ServBay stellt Redis als Paket sowie die Erweiterung ext-redis bereit. Installieren Sie noch einen PHP-Client, z.B. predis/predis.

1. Redis-Client installieren: Im Projektverzeichnis:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require predis/predis

2. Redis-Route in public/index.php hinzufügen: Vor $app->run();:

   // ... Initialisierung, Datenbank- und ggf. Memcached-Routen ...
   
   use Predis\Client as RedisClient; // Predis-Client importieren
   
   // Beispielroute für Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Redis-Client instanziieren (ServBay läuft auf 127.0.0.1:6379)
           $redis = new RedisClient([
               'scheme' => 'tcp',
               'host' => '127.0.0.1',
               'port' => 6379,
           ]);
   
           $cacheKey = 'my_servbay_redis_cache_key';
           // Daten aus Cache holen
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Falls kein Cache vorhanden, Daten erzeugen und speichern
               $cachedData = 'Hello Redis from ServBay! This was not cached.';
               // Daten im Cache speichern, 60 Sek. gültig
               $redis->setex($cacheKey, 60, $cachedData); // SETEX key seconds value
               $response->getBody()->write($cachedData);
           } else {
               // Falls Daten gecacht, diese verwenden
               $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
           }
       } catch (\Exception $e) {
           // Verbindung oder Fehler abfangen
           $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
           $response = $response->withStatus(500);
       }
   
       return $response;
   });
   
   // ... $app->run();

Aufruf: Öffnen Sie https://servbay-slim-test.local/redis-example. Beim ersten Öffnen wird "This was not cached." angezeigt, Nachfolgebesuche (solange die Daten im Cache sind) zeigen "This was served from cache.".

Fazit

Mit diesen Schritten haben Sie erfolgreich ein Slim Framework-Projekt in der ServBay-Umgebung aufgesetzt und mit der Websites-Funktion veröffentlicht. Sie wissen jetzt, wie Sie die verschiedenen Pakete von ServBay (z.B. MySQL, PostgreSQL, Memcached, Redis) sowie die zugehörigen PHP-Erweiterungen nutzen, um Datenbank- und Cachefunktionen in Ihre Slim-Anwendung einzubinden. ServBay macht die Einrichtung und Verwaltung Ihrer lokalen Umgebung besonders einfach, damit Sie sich ganz auf die Entwicklung Ihrer Slim-Projekte konzentrieren können.