Webman-Projekt in ServBay erstellen und ausführen

Was ist Webman?

Webman ist ein leistungsstarkes PHP-Framework für asynchrone Webanwendungen auf Basis von Workerman, das speziell für hochperformante und stark skalierende Webanwendungen entworfen wurde. Im Gegensatz zu klassischen synchronen und blockierenden Frameworks nutzt Webman ein Event-getriebenes, asynchrones Non-Blocking-I/O-Modell, was eine herausragende Performance bei vielen gleichzeitigen Anfragen ermöglicht. Webman bietet eine einfache, leicht verständliche API und ein flexibles Erweiterungsmodell und ist somit ideal für Echtzeitanwendungen, APIs, Microservices und mehr geeignet.

Hauptmerkmale und Vorteile von Webman

• Hohe Performance: Webman basiert auf Workerman und nutzt Event-Driven-Architekturen sowie asynchrone, nicht-blockierende I/O-Verarbeitung, bearbeitet enorme Mengen gleichzeitiger Verbindungen und erreicht deutlich höhere Durchsatzraten als klassische synchrone Frameworks.
• Benutzerfreundlichkeit: Intuitive und übersichtliche API mit vielen Funktionen, sodass Entwickler schnell und unkompliziert Anwendungen erstellen können.
• Multi-Protokoll-Unterstützung: Eingebaute Unterstützung für gängige Protokolle wie HTTP, WebSocket und mehr, ideal zum Aufbau unterschiedlichster Services.
• Flexible Erweiterbarkeit: Dank Composer-Paketen, Plug-ins und Middleware lässt sich der Funktionsumfang mühelos ausbauen.
• Niedriger Ressourcenverbrauch: Im Vergleich zum klassischen „Webserver + PHP-FPM“-Modell verbleibt Webman resident im Speicher und benötigt so weniger Ressourcen.
• Starke Community: Aktive Entwickler-Community und umfangreiche Dokumentation als Support.

Webman hilft Entwicklern, hochperformante und hochverfügbare Webanwendungen und API-Services schnell zu erstellen – besonders geeignet für Szenarien mit hoher Parallelität und niedrigen Latenzen.

Ein einfaches Webman-Projekt mit ServBay erstellen und ausführen

In dieser Anleitung erfahren Sie Schritt für Schritt, wie Sie mit ServBay in Ihrer lokalen Entwicklungsumgebung ein Webman-Projekt aufsetzen und betreiben. Wir zeigen die Installation von Webman, das Schreiben grundlegender Routen und Controller sowie die Integration der von ServBay bereitgestellten Datenbanken (MySQL, PostgreSQL) und Caching-Services (Redis, Memcached).

TIP

ServBay empfiehlt, alle lokalen Website-Projekte im Verzeichnis /Applications/ServBay/www abzulegen. So kann ServBay diese Projekte zentral verwalten und Sie profitieren z.B. beim Einrichten lokaler Websites (vormals „Hosts“).

Voraussetzungen

Bitte stellen Sie vor dem Start Folgendes sicher:

1. ServBay installiert: Sie haben ServBay erfolgreich unter macOS installiert. ServBay bietet eine Komplettumgebung, die alle für dieses Tutorial benötigten Pakete enthält: PHP, Composer, MySQL, PostgreSQL, Redis, Memcached usw.
2. Erforderliche Pakete aktiviert: Prüfen Sie im ServBay-Kontrollpanel, ob folgende Komponenten installiert und aktiv sind:
   • Ihre gewählte PHP-Version (empfohlen: PHP 8.x oder neuer)
   • Composer (bereits integriert in ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Überprüfen Sie, ob die gewählte PHP-Version die Extensions memcached, redis, pdo_mysql, pdo_pgsql aktiviert hat. Diese Erweiterungen sind bei ServBay in der Regel standardmäßig aktiv. Sie können dies in der PHP-Konfiguration von ServBay einsehen.
3. Terminalzugriff: Sie sind mit der Nutzung des Terminals unter macOS vertraut.

Webman installieren

1. Composer-Verfügbarkeit prüfen

   ServBay kommt mit integriertem Composer, konfiguriert zur direkten Nutzung im Terminal. Prüfen Sie die Verfügbarkeit im Terminal:

   composer --version

   Wird die Composer-Versionsnummer angezeigt, ist Composer einsatzbereit.

2. Ins ServBay-Webverzeichnis wechseln

   Öffnen Sie das Terminal und navigieren Sie ins empfohlene Projektverzeichnis:

   cd /Applications/ServBay/www

3. Webman-Projekt per Composer erstellen

   Mit Composer und dem Befehl create-project installieren Sie das Webman-Framework. Wir nennen das Projekt servbay-webman-app:

   composer create-project workerman/webman servbay-webman-app

   Composer lädt Webman und seine Kernabhängigkeiten ins Verzeichnis servbay-webman-app.

4. Ins Projektverzeichnis wechseln

   Nach der Installation gehen Sie ins neue Projektverzeichnis:

   cd servbay-webman-app

5. Benötigte Komponenten installieren

   Für Datenbank- und Cache-Funktionalität installieren wir zusätzliche Composer-Pakete. Webman verwendet dazu gewöhnlich illuminate/database (das Datenbankmodul von Laravel), illuminate/redis usw. Das Argument -W (--with-dependencies) stellt die Kompatibilität sicher, indem Abhängigkeiten automatisch aufgelöst werden.

   composer require -W illuminate/database illuminate/redis illuminate/pagination illuminate/events symfony/var-dumper

   Dieser Befehl installiert das ORM für Datenbanken, den Redis-Client, Pagination-Komponenten, Event-Dispatcher und das Debug-Tool VarDumper.

Datenbank und Tabelle anlegen

Damit der Beispielcode funktioniert, müssen Sie in ServBays MySQL- und PostgreSQL-Instanz die entsprechende Datenbank und die Tabelle users anlegen. Das Standardpasswort für den Datenbanknutzer root ist password.

Nutzen Sie zum Ausführen der folgenden SQL-Statements entweder die von ServBay bereitgestellten Datenbanktools (wie phpMyAdmin oder pgAdmin, erreichbar aus dem ServBay-Kontrollpanel) oder das Terminal.

1. Datenbank webman_app erstellen

   • MySQL:

     CREATE DATABASE IF NOT EXISTS webman_app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Tabelle users in der Datenbank webman_app anlegen

   • MySQL:

     USE webman_app;
     CREATE TABLE users (
         id INT AUTO_INCREMENT PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

   • PostgreSQL:

     \c webman_app; -- Verbindung mit der neuen Datenbank herstellen
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Webprojekt-Code schreiben

Als Nächstes hinterlegen wir Beispielcode für Routing, Controller und die Datenbank- bzw. Cache-Nutzung.

1. Routen konfigurieren

   Bearbeiten Sie die Datei config/route.php im Projektstamm und ergänzen Sie die folgenden Routen:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Root-Route, verweist auf IndexController::index
   Route::any('/', [IndexController::class, 'index']);
   
   // Routen für Caching
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Routen für Datenbanken
   Route::any('/mysql-add', [DatabaseController::class, 'mysqlAdd']);
   Route::any('/mysql', [DatabaseController::class, 'mysqlGet']);
   Route::any('/pgsql-add', [DatabaseController::class, 'pgsqlAdd']);
   Route::any('/pgsql', [DatabaseController::class, 'pgsqlGet']);
   
   // Weitere Routen können hier ergänzt werden...

2. Controller-Dateien anlegen

   Erstellen Sie im Verzeichnis app/controller die Dateien IndexController.php, CacheController.php und DatabaseController.php wie im Folgenden angegeben.

   • app/controller/IndexController.php: Für Anfragen auf die Root-URL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Response-Klasse einbinden
     
     class IndexController
     {
         /**
          * Beispielmethode für Anfragen auf die Startseite
          * @param Request $request Die aktuelle Anfrage
          * @return Response Gibt ein Response-Objekt zurück
          */
         public function index(Request $request): Response // Rückgabetyp explizit
         {
             // Einfache Textantwort zurückgeben
             return response('Hello ServBay & Webman!'); // Willkommensnachricht aktualisiert
         }
     }

   • app/controller/CacheController.php: Zeigt die Verwendung von Memcached und Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Memcached-Klasse einbinden
     use support\Redis; // Redis Facade von Webman einbinden
     
     class CacheController
     {
         /**
          * Beispiel für den Einsatz von Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Verbindung zum Memcached-Server, ServBay nutzt standardmäßig 127.0.0.1:11211
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Cache-Eintrag setzen, 60 Sekunden Gültigkeit
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Schlüssel und Wert aktualisiert
             if (!$success) {
                  return response('Failed to set Memcached key', 500);
             }
     
             // Cache-Eintrag abrufen
             $value = $memcached->get('servbay_key'); // Schlüssel aktualisiert
     
             // Ergebnis zurückgeben
             return response($value ?: 'Memcached key not found or expired'); // Fehlermeldung falls nicht gefunden
         }
     
         /**
          * Beispiel für den Einsatz von Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Cache-Eintrag mit Redis Facade setzen
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Schlüssel und Wert aktualisiert
     
             // Cache-Eintrag abrufen
             $value = Redis::get('servbay_redis_key'); // Schlüssel aktualisiert
     
             // Ergebnis zurückgeben
             return response($value ?: 'Redis key not found'); // Fehlermeldung falls nicht gefunden
         }
     }

   • app/controller/DatabaseController.php: Für MySQL- und PostgreSQL-Beispiele zur Datenbankmanipulation.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Db Facade von Webman einbinden
     
     class DatabaseController
     {
         /**
          * Einen Nutzer in MySQL hinzufügen
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Verbindung zur MySQL-DB über die Db Facade und Eintrag hinzufügen
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Beispieldaten aktualisiert
                     'email' => 'mysql_demo@servbay.test', // Beispiel-Mail aktualisiert
                     'created_at' => date('Y-m-d H:i:s') // Zeitstempel
                 ]);
                 return response('User added to MySQL'); // Rückmeldung aktualisiert
             } catch (\Exception $e) {
                 return response('Error adding user to MySQL: ' . $e->getMessage(), 500); // Fehlerhandling ergänzt
             }
         }
     
         /**
          * Nutzerliste aus MySQL abrufen
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Alle Nutzer aus MySQL-Tabelle abrufen
                 $users = Db::connection('mysql')->table('users')->get();
                 // Ergebnis als JSON zurückgeben
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type explizit
             } catch (\Exception $e) {
                  return response('Error getting users from MySQL: ' . $e->getMessage(), 500); // Fehlerhandling ergänzt
             }
         }
     
         /**
          * Nutzer zu PostgreSQL hinzufügen
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Verbindung zu PostgreSQL und Eintrag ausführen
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Beispieldaten aktualisiert
                     'email' => 'pgsql_demo@servbay.test', // Beispiel-Mail aktualisiert
                     'created_at' => date('Y-m-d H:i:s') // Zeitstempel
                 ]);
                 return response('User added to PostgreSQL'); // Rückmeldung aktualisiert
              } catch (\Exception $e) {
                 return response('Error adding user to PostgreSQL: ' . $e->getMessage(), 500); // Fehlerhandling ergänzt
              }
         }
     
         /**
          * Nutzerliste aus PostgreSQL abrufen
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Alle Nutzer aus PostgreSQL-Tabelle abrufen
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Ergebnis als JSON zurückgeben
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type explizit
              } catch (\Exception $e) {
                 return response('Error getting users from PostgreSQL: ' . $e->getMessage(), 500); // Fehlerhandling ergänzt
              }
         }
     }

3. Datenbankverbindung konfigurieren

   Bearbeiten Sie die Datei config/database.php im Projektverzeichnis, um MySQL- und PostgreSQL-Zugangsdaten einzutragen. Als Host dient standardmäßig 127.0.0.1, die Ports sind 3306 (MySQL) bzw. 5432 (PostgreSQL), der Benutzer ist root und das Passwort password.

   <?php
   /**
    * Datenbankkonfiguration
    */
   return [
       // Standardverbindung
       'default' => 'mysql',
   
       // Verbindungsdetails
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Standard-Host und Port in ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Vorausgewählte Datenbank
               'database'  => 'webman_app',
               // Standard-Benutzername
               'username'  => 'root',
               // Standard-Passwort
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Standard-Host und Port in ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Vorausgewählte Datenbank
               'database' => 'webman_app',
                // Standard-Benutzername
               'username' => 'root',
                // Standard-Passwort
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // oder require, verify-ca, verify-full
           ],
           // Weitere Datenbankverbindungen können hier ergänzt werden...
       ],
   ];

   Wichtiger Hinweis: Ändern Sie im Produktionsbetrieb aus Sicherheitsgründen das Standard-Passwort und hinterlegen Sie keine sensiblen Informationen im Quellcode.

Webman-Projekt starten

Webman-Projekte werden üblicherweise mit dem mitgelieferten Skript start.php gestartet, das die Workerman-Instanz hochfährt. Anders als bei traditionellen Setups mit Nginx/Apache und PHP-FPM läuft Webman als eigenständige, dauerhaft aktive Anwendung im Speicher.

Zum Start wechseln Sie ins Projektverzeichnis (/Applications/ServBay/www/servbay-webman-app) und führen:

php start.php start

Nach Ausführung des Befehls sehen Sie den Startbildschirm von Webman; standardmäßig lauscht der Dienst auf 127.0.0.1:8787 für HTTP-Anfragen.

• Hinweis: Das Kommando php nutzt hier die in ServBay installierte PHP-Version. Dank ServBay ist Ihr Terminal automatisch korrekt konfiguriert.
• Für Hintergrundbetrieb kann das -d-Argument verwendet werden: php start.php start -d.
• Webman stoppen mit: php start.php stop.
• Webman neu starten mit: php start.php restart.
• Für einen „Smooth Reload“ (ohne laufende Anfragen zu unterbrechen): php start.php reload.

Projekt testen

Nachdem Webman läuft und auf 127.0.0.1:8787 hört, können Sie diese URLs im Browser testen:

• http://localhost:8787/ – Es sollte Hello ServBay & Webman! ausgegeben werden.
• http://localhost:8787/memcached – Es erscheint Hello Memcached from ServBay!. Damit funktioniert der Zugriff auf Memcached via Webman.
• http://localhost:8787/redis – Es erscheint Hello Redis from ServBay!. Damit funktioniert der Zugriff auf Redis via Webman.
• http://localhost:8787/mysql-add – Es erscheint User added to MySQL. Im users-Tabellen der zuvor angelegten MySQL-Datenbank wird ein Eintrag hinzugefügt.
• http://localhost:8787/mysql – Es folgt eine JSON-Liste aller Benutzer aus den MySQL-Daten.
• http://localhost:8787/pgsql-add – Es erscheint User added to PostgreSQL. Im users-Tabellen der zuvor angelegten PostgreSQL-Datenbank wird ein Eintrag hinzugefügt.
• http://localhost:8787/pgsql – Es folgt eine JSON-Liste aller Benutzer aus den PostgreSQL-Daten.

Sollte eine der URLs nicht funktionieren, prüfen Sie die Terminal-Ausgabe von Webman auf Fehlermeldungen, ob die benötigten ServBay-Komponenten (MySQL, PostgreSQL, Redis, Memcached) laufen und die PHP-Extensions aktiviert sind.

Häufig gestellte Fragen (FAQ)

• F: Befehl php start.php start wird nicht gefunden?
  • A: Stellen Sie sicher, dass Sie das richtige Verzeichnis (servbay-webman-app) im Terminal geöffnet haben. Zudem müssen Sie sicherstellen, dass die ServBay-PHP-Version ins System-PATH eingebunden ist (wird von ServBay normalerweise automatisch erledigt).
• F: Die Verbindung zu localhost:8787 schlägt fehl?
  • A: Prüfen Sie die Webman-Ausgabe im Terminal auf Fehler. Stellen Sie sicher, dass Port 8787 frei ist. Falls belegt, können Sie den Port z.B. in der Konfigurationsdatei config/server.php anpassen.
• F: Verbindungsprobleme zur Datenbank?
  • A: Prüfen Sie, ob MySQL und PostgreSQL in ServBay laufen. Kontrollieren Sie die Einstellungen in config/database.php (Host, Port, DB-Name, Nutzer, Passwort) – Standard: Nutzer root, Passwort password. Vergewissern Sie sich, dass webman_app und die Tabelle users existieren.
• F: Memcached-/Redis-Verbindung schlägt fehl?
  • A: Prüfen Sie, ob Memcached und Redis in ServBay aktiv sind. Kontrollieren Sie die Adressen und Ports in app/controller/CacheController.php (127.0.0.1:11211 und 127.0.0.1:6379). Vergewissern Sie sich, dass die PHP-Extensions memcached und redis aktiviert sind.

Fazit

Mit den oben gezeigten Schritten haben Sie in ServBay erfolgreich ein Basis-Webman-Projekt lokal erstellt, konfiguriert und gestartet. Sie wissen jetzt, wie Sie ServBay als All-in-one-Lösung nutzen, um schnell eine Entwicklungsumgebung für Webman aufzusetzen – inklusive Datenbank- und Caching-Integration. Webmans Leistungsfähigkeit in Verbindung mit ServBays Komfort bietet Ihnen eine starke Basis für die Entwicklung performanter asynchroner PHP-Anwendungen. Wir hoffen, diese Anleitung hilft Ihnen, mit ServBay und Webman eindrucksvolle Webprojekte zu realisieren.