ServBay

Deutsch

English
简体中文
繁體中文
Español
العربية
Português
Русский
日本語
Français
Tiếng Việt
Türkçe
Italiano

Deutsch

English
简体中文
繁體中文
Español
العربية
Português
Русский
日本語
Français
Tiếng Việt
Türkçe
Italiano

Appearance

Slim-Projekt in ServBay erstellen und ausführen ​

In diesem Leitfaden erfahren Sie, wie Sie mit ServBay, einer leistungsstarken lokalen Webentwicklungsumgebung, schnell ein auf PHP basierendes Slim Framework-Projekt erstellen, konfigurieren und ausführen. ServBay bietet integrierte Pakete für PHP, Webserver (Caddy/Nginx/Apache) sowie zahlreiche Datenbanklösungen und ist daher die ideale Plattform für Slim-Entwicklungen.

Was ist Slim? ​

Slim ist ein leichtgewichtiges PHP-Micro-Framework, das für die schnelle Entwicklung von einfachen, aber leistungsfähigen Webanwendungen und APIs entwickelt wurde. Es liefert Kernfunktionen wie Routing, Request- und Response-Handling und eignet sich bestens für Projekte, die zügig entwickelt und bereitgestellt werden sollen oder als Grundlage für komplexere Anwendungen dienen.

Wichtige Merkmale und Vorteile von Slim ​

  • Leichtgewicht: Der Core von Slim ist sehr schlank, ressourcenschonend und startet blitzschnell – ideal für kleine bis mittelgroße Anwendungen oder Microservices.
  • Flexibilität: Slim ist modular konzipiert und lässt sich unkompliziert mit Drittanbieter-Komponenten oder Bibliotheken wie Template-Engines, ORMs oder Authentifizierungs-Lösungen integrieren. So können Sie die Tools auswählen, die am besten zu Ihrem Projekt passen.
  • Einfache Nutzung: Dank einer klaren API und guter Dokumentation verstehen und nutzen Entwickler Slim extrem schnell.
  • Leistungsfähiges Routing: Unterstützt alle gängigen HTTP-Methoden (GET, POST, PUT, DELETE usw.) und komplexe Routen-Setups mit Gruppierungen, Middleware und Parameterübergabe.
  • Middleware-Unterstützung: Die Middleware-Schicht von Slim erlaubt es, Aufgaben wie Authentifizierung, Logging oder CORS-Bearbeitung noch vor der Anwendung oder vor dem Rücksenden der Response auszuführen.

Slim ist eine hervorragende Wahl für RESTful APIs, schnelle Prototypen und abgegrenzte Funktionsmodule.

Ein Slim-Projekt mit ServBay erstellen und ausführen ​

In dieser Anleitung nutzen wir die vorkonfigurierte PHP-Umgebung und die Website-Funktion von ServBay, um den Webserver einzurichten und das Slim-Projekt bereitzustellen.

Voraussetzungen ​

Bevor Sie starten, sollten folgende Punkte erfüllt sein:

  1. ServBay installiert und gestartet: Vergewissern Sie sich, dass ServBay auf Ihrem macOS-System installiert und die Anwendung aktiv ist.
  2. Composer ist in ServBay enthalten: Composer ist in ServBay bereits vorinstalliert, eine separate Installation entfällt.

Slim-Projekt erstellen ​

Wir empfehlen, alle Ihre Websites in ServBay im Verzeichnis /Applications/ServBay/www abzulegen – das erleichtert die Verwaltung und Konfiguration.

  1. Wechseln Sie ins Webroot-Verzeichnis von ServBay:
    bash
    cd /Applications/ServBay/www
  2. Projektverzeichnis anlegen: Erstellen Sie einen neuen Ordner für Ihr Slim-Projekt.
    bash
    mkdir servbay-slim-app
  3. Wechseln Sie ins Projektverzeichnis:
    bash
    cd servbay-slim-app
  4. Slim mit Composer installieren: Installieren Sie im Projektverzeichnis Slim und dessen PSR-7-Komponente.
    bash
    composer require slim/slim "^4.0" slim/psr7 -W
    Dieser Befehl lädt das Slim Framework und die slim/psr7 Bibliothek in den vendor-Ordner Ihres Projekts und generiert die Dateien composer.json und composer.lock.

Slim-Anwendung initialisieren ​

  1. Entry-Point erstellen: In Slim-Projekten gibt es in der Regel eine zentrale Einstiegspunkt-Datei (z. B. public/index.php), die sämtliche Anfragen verarbeitet. Erstellen Sie im Projektverzeichnis den Ordner public und darin die Datei index.php.
    bash
    mkdir public
touch public/index.php
  2. Entry-Point bearbeiten: Öffnen Sie public/index.php und fügen Sie folgenden Slim-Basics-Code ein:
    php
    <?php
// Composer Autoloader laden
require __DIR__ . '/../vendor/autoload.php';

// Wichtige PSR-7- und Slim-Klassen importieren
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();

// Beispielroute: Handle GET-Anfrage auf die Root-URL '/'
$app->get('/', function (Request $request, Response $response, $args) {
    // Text in die Response schreiben
    $response->getBody()->write("Hello ServBay!");
    // Response zurückgeben
    return $response;
});

// Slim-App starten
$app->run();
    Dieser Code legt die einfachste Slim-App an: Sie definiert eine Route für die URL / und antwortet mit "Hello ServBay!".

ServBay-Website konfigurieren ​

Um Ihr Slim-Projekt im Browser erreichbar zu machen, müssen Sie in ServBay eine Website (früher „Host“) konfigurieren.

  1. Öffnen Sie das ServBay-Anwendungsfenster.
  2. Navigieren Sie zum Modul Websites.
  3. Wählen Sie die Option, eine neue Website hinzuzufügen.
  4. Füllen Sie die Konfigurationsdaten entsprechend Ihrem Projekt aus:
    • Name: My First Slim Dev Site (oder ein beliebiger Name)
    • Domain: servbay-slim-test.local (Für lokale Entwicklung werden Domains mit .local oder .test empfohlen)
    • Websitetyp: PHP
    • PHP-Version: Wählen Sie die gewünschte PHP-Version, z. B. 8.3.
    • Document Root: Wählen Sie über den Auswahl-Dialog das public-Verzeichnis Ihres Projekts, also /Applications/ServBay/www/servbay-slim-app/public. Da sich die Einstiegspunkt-Datei index.php dort befindet, sollte der Webserver auf diesen Ordner zeigen.
  5. Speichern Sie die Konfiguration. ServBay passt die Webserver-Einstellungen automatisch an und aktiviert die Website.

Ausführlichere Schritte zur Website-Einrichtung finden Sie in der Anleitung: Erste Website hinzufügen.

Ihr Slim-Projekt aufrufen ​

Nach Abschluss der Konfiguration öffnen Sie einen Browser und rufen die konfigurierte Domain https://servbay-slim-test.local auf.

Wenn alles korrekt eingerichtet ist, wird die Seite mit dem Text Hello ServBay! angezeigt. Das bedeutet, dass Ihr Slim-Projekt erfolgreich über den ServBay-Webserver läuft.

Datenbankintegration: Beispiele ​

Slim bringt keine eigene Datenbankschicht mit, lässt sich aber problemlos mit verschiedensten PHP-Datenbankbibliotheken kombinieren. Im Folgenden zeigen wir am Beispiel von Laravel’s Eloquent ORM (illuminate/database), wie Sie MySQL und PostgreSQL anbinden, sowie weiter unten die Grundintegration für Memcached und Redis.

Voraussetzungen: Datenbanken und Migrationen ​

Vor der Integration sollten Sie die entsprechenden Datenbanken in ServBay anlegen und die nötigen Tabellen für Ihre App erstellen.

  1. Datenbank erstellen:
    • Öffnen Sie das ServBay Interface und navigieren Sie zu Ihrer gewünschten Datenbank, z. B. MySQL oder PostgreSQL.
    • Erstellen Sie mit Hilfe der ServBay-Werkzeuge (z. B. phpMyAdmin für MySQL/MariaDB, pgAdmin für PostgreSQL) oder einem Kommandozeilentool eine neue Datenbank, etwa mit dem Namen servbay_slim_app.
    • Das Standard-Root-Passwort für die Datenbank ist meistens password. Sie können dies im ServBay-Interface einsehen oder anpassen.
  2. Phinx (Migrationstool) installieren und konfigurieren: Phinx ist ein beliebtes PHP-Tool für Datenbankmigrationen und unterstützt das Versionieren Ihres Datenbankschemas.
    • Installieren Sie Phinx im Projektverzeichnis /Applications/ServBay/www/servbay-slim-app:
      bash
      composer require robmorgan/phinx
    • Initialisieren Sie die Phinx-Konfiguration:
      bash
      vendor/bin/phinx init
      Dadurch wird eine Datei phinx.yml im Projektverzeichnis angelegt. Bearbeiten Sie diese und passen Sie die Datenbankverbindung wie folgt an:
      yaml
      paths:
    migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
    seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'

environments:
    default_migration_table: phinxlog
    default_environment: development # oder Ihr gewünschtes Environment

    development: # Je nach DB-Typ anpassen
        adapter: mysql # oder pgsql
        host: 127.0.0.1
        name: servbay_slim_app # Ihre Datenbank
        user: root
        pass: password # Ihr DB-Passwort
        port: 3306 # Standard-Port für MySQL, 5432 für PostgreSQL
        charset: utf8mb4 # Für MySQL empfohlen
        collation: utf8mb4_unicode_ci # Für MySQL empfohlen

version_order: creation
  3. Migrationsdatei anlegen: Erstellen Sie ein Migration-File mit Phinx.
    bash
    vendor/bin/phinx create CreateUsersTable
    Das legt eine Datei im Verzeichnis db/migrations an. Öffnen Sie diese und definieren Sie die Struktur der users-Tabelle wie folgt:
    php
    <?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 created_at und updated_at Felder hinzu
              ->create();
    }
}
  4. Migration ausführen: Führen Sie im Projektverzeichnis den Migrationsbefehl aus, um die users-Tabelle anzulegen.
    bash
    vendor/bin/phinx migrate
    Wichtig: Führen Sie diese Migration aus, bevor Sie die folgenden Datenbankcode-Beispiele anwenden!

Verwendung von illuminate/database ​

Wir nutzen für ORM und Query-Building das Laravel Datenbankpaket (illuminate/database).

  1. illuminate/database installieren: Im Wurzelverzeichnis /Applications/ServBay/www/servbay-slim-app installieren:

    bash
    composer require illuminate/database

  2. Datenbankverbindung in public/index.php initialisieren: Fügen Sie nach require __DIR__ . '/../vendor/autoload.php'; und vor der Zeile, in der $app = AppFactory::create(); steht, die folgende DB-Konfiguration ein.

    php
    // ... weitere require- und use-Befehle ...

use Illuminate\Database\Capsule\Manager as Capsule; // Capsule-Manager importieren

// Eloquent ORM initialisieren
$capsule = new Capsule;

// Datenbankverbindung anlegen (je nach DB-Typ driver und Parameter anpassen)
$capsule->addConnection([
    'driver' => 'mysql', // oder 'pgsql'
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app', // Ihr DB-Name
    'username' => 'root', // Ihr DB-Benutzername
    'password' => 'password', // Ihr DB-Passwort
    'charset' => 'utf8mb4', // Für MySQL empfohlen
    'collation' => 'utf8mb4_unicode_ci', // Für MySQL empfohlen
    'prefix' => '',
    // Für PostgreSQL schema-Parameter ergänzen
    // 'schema' => 'public',
]);

// Kapsel global verfügbar machen
$capsule->setAsGlobal();

// Eloquent starten
$capsule->bootEloquent();

// ... Slim-App-Instanz erstellen ($app = AppFactory::create(); ) ...

MySQL-Beispiel ​

Nehmen wir an, Sie haben das MySQL Paket von ServBay gestartet, die Datenbank servbay_slim_app angelegt und die Migration für die Tabelle users durchgeführt.

Fügen Sie vor dem $app->run();-Befehl in public/index.php folgende Routen ein:

php
// ... vorherige Initialisierung und '/'-Route ...

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

// Route zum Hinzufügen eines Nutzers
$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', // time() sorgt für einzigartige E-Mail
            '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 der Nutzer
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // Ergebnis als JSON ausgeben
        $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 der Tabelle users einen neuen Nutzer hinzu.
  • https://servbay-slim-test.local/mysql-get-users liest alle Nutzer aus und gibt sie im JSON-Format zurück.

PostgreSQL-Beispiel ​

Falls Sie das PostgreSQL Paket von ServBay nutzen, die Datenbank servbay_slim_app und die users-Tabelle mit Phinx angelegt haben (überprüfen Sie dazu auch Adapter- und Port-Einstellungen in Ihrer Phinx-Konfiguration – adapter: pgsql, port: 5432):

Passen Sie die Datenbank-Config in public/index.php wie folgt an:

php
$capsule->addConnection([
    'driver' => 'pgsql', // Umstellen auf pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // Für PostgreSQL gängig
    'prefix' => '',
    'schema' => 'public', // PostgreSQL benötigt einen schema-Parameter
]);
// ... restliche Eloquent-Konfiguration identisch ...

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

php
// ... vorherige Initialisierung, '/'-Route, ggf. MySQL-Routen ...

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

// Route zum Hinzufügen eines Nutzers (PostgreSQL)
$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', // time() sorgt für einzigartige E-Mail
            '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 der Nutzer
$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 Nutzer zur PostgreSQL-Tabelle users hinzu.
  • https://servbay-slim-test.local/pgsql-get-users liest alle Nutzer aus der Tabelle im JSON-Format aus.

Memcached-Beispiel ​

ServBay enthält ein Memcached-Paket sowie das PHP-Extension ext-memcached. Sie benötigen zusätzlich eine PHP-Client-Bibliothek, z. B. memcached/memcached.

  1. Memcached-Client installieren: Im Verzeichnis /Applications/ServBay/www/servbay-slim-app:

    bash
    composer require memcached/memcached

  2. Route für Memcached in public/index.php hinzufügen: Fügen Sie vor $app->run(); diese Route ein:

    php
    // ... vorherige Initialisierung und DB-Routen ...

// Route für Memcached-Nutzung
$app->get('/memcached-example', function (Request $request, Response $response, $args) {
    // Memcached-Instanz erstellen
    $memcached = new Memcached();
    // Server hinzufügen (ServBay Standard: 127.0.0.1:11211)
    $memcached->addServer('127.0.0.1', 11211);

    $cacheKey = 'my_servbay_cache_key';
    // Daten aus Cache abrufen
    $cachedData = $memcached->get($cacheKey);

    if ($cachedData === false) {
        // Wenn nichts im Cache: Daten generieren und speichern
        $cachedData = 'Hello Memcached from ServBay! This was not cached.';
        // Daten mit 60 Sekunden TTL speichern
        $memcached->set($cacheKey, $cachedData, 60);
        $response->getBody()->write($cachedData);
    } else {
        // Wenn im Cache: Daten ausgeben
        $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
    }

    return $response;
});

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

Aufruf: Rufen Sie https://servbay-slim-test.local/memcached-example auf. Beim ersten Besuch erscheint "This was not cached.", bei darauffolgenden Zugriffen (bevor der Cache abläuft) "This was served from cache.".

Redis-Beispiel ​

ServBay beinhaltet ein Redis-Paket und das PHP-Extension ext-redis. Sie benötigen einen PHP-Client wie predis/predis.

  1. Redis-Client installieren: Führen Sie im Projektverzeichnis /Applications/ServBay/www/servbay-slim-app aus:

    bash
    composer require predis/predis

  2. Route für Redis in public/index.php hinzufügen: Ergänzen Sie vor $app->run(); diese Route:

    php
    // ... vorherige Initialisierung und DB-/Memcached-Routen ...

use Predis\Client as RedisClient; // Predis-Client importieren

// Route für Redis-Nutzung
$app->get('/redis-example', function (Request $request, Response $response, $args) {
    try {
        // Redis-Client initialisieren (ServBay Standard: 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 nicht gefunden: Daten erzeugen und mit TTL speichern
            $cachedData = 'Hello Redis from ServBay! This was not cached.';
            $redis->setex($cacheKey, 60, $cachedData); // SETEX key seconds value
            $response->getBody()->write($cachedData);
        } else {
            // Falls gefunden: Daten aus Cache liefern
            $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
        }
    } catch (\Exception $e) {
        // Fehler abfangen
        $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }

    return $response;
});

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

Aufruf: Rufen Sie https://servbay-slim-test.local/redis-example auf. Beim ersten Zugriff erhalten Sie "This was not cached.", bei weiteren Zugriffen bis zum Ablauf des Caches "This was served from cache.".

Fazit ​

Mit diesem Leitfaden haben Sie erfolgreich ein Slim Framework-Projekt in der lokalen ServBay-Umgebung erstellt und mithilfe der Website-Funktion bereitgestellt. Sie haben ebenfalls gelernt, wie Sie Datenbanken und Cache-Systeme wie MySQL, PostgreSQL, Memcached und Redis per ServBay und deren zugehörige PHP-Extensions einfach integrieren können. ServBay erleichtert die Einrichtung und Verwaltung lokaler Entwicklungsumgebungen erheblich, damit Sie sich ganz auf die Entwicklung Ihrer Slim-Anwendung konzentrieren können.