Tworzenie i uruchamianie projektu Webman w ServBay

Co to jest Webman?

Webman to wysokowydajny asynchroniczny framework PHP oparty o Workerman, stworzony z myślą o budowaniu aplikacji internetowych obsługujących dużą liczbę połączeń jednocześnie. W przeciwieństwie do tradycyjnych blokujących, synchronicznych frameworków, Webman korzysta z modelu zdarzeniowego i asynchronicznego I/O, przez co doskonale radzi sobie z obsługą licznych równoczesnych żądań. Zawiera intuicyjne API i elastyczne mechanizmy rozbudowy, przez co sprawdza się zarówno w aplikacjach realtime, usługach API, mikrousługach i wielu innych zastosowaniach.

Najważniejsze cechy i zalety Webman

• Wysoka wydajność: Zbudowany na Workermanie, korzystający z event-driven oraz asynchronicznego I/O, obsługuje ogromną liczbę równoczesnych połączeń; jego przepustowość znacząco przewyższa tradycyjne synchroniczne frameworki.
• Łatwy w użyciu: Przyjazne, przejrzyste API oraz bogata funkcjonalność pozwalają programistom szybko rozpocząć pracę.
• Obsługa wielu protokołów: Wbudowane wsparcie dla HTTP, WebSocket i innych popularnych protokołów, co ułatwia budowę różnego typu usług.
• Elastyczna rozbudowa: Możliwość rozszerzania funkcji przez Composer, pluginy oraz mechanizmy middleware.
• Niskie zużycie zasobów: W przeciwieństwie do tradycyjnych serwerów www + PHP-FPM, Webman działa w pamięci RAM, co oznacza mniejsze obciążenie systemowe.
• Silna społeczność: Aktywna społeczność deweloperów i bogata dokumentacja.

Webman pozwala programistom szybko i skutecznie tworzyć wysoko wydajne, dostępne aplikacje webowe oraz API, szczególnie tam, gdzie istotna jest obsługa wielu użytkowników jednocześnie i niska latencja.

Tworzenie i uruchamianie prostego projektu Webman w ServBay

Ten poradnik szczegółowo opisuje, jak w lokalnym środowisku ServBay utworzyć i uruchomić prosty projekt Webman. Pokażemy instalację Webman, napisanie bazowego kodu routerów i kontrolerów oraz podłączenie baz danych dostarczanych przez ServBay (MySQL, PostgreSQL) i systemów cache (Redis, Memcached).

TIP

ServBay zaleca umieszczać wszystkie lokalne projekty stron w katalogu /Applications/ServBay/www, co ułatwia ich centralne zarządzanie, np. konfigurację lokalnych stron ("hostów").

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

1. Instalacja ServBay: Masz zainstalowany ServBay na macOS, zapewniający kompletne środowisko developerskie — w tym PHP, Composer, MySQL, PostgreSQL, Redis i Memcached.
2. Aktywne niezbędne pakiety: Przez panel ServBay sprawdź, czy zainstalowane i uruchomione są poniższe komponenty:
   • Wybrana wersja PHP (zalecana najnowsza, np. PHP 8.x)
   • Composer (dołączony do ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Upewnij się, że wybrana wersja PHP posiada aktywne rozszerzenia memcached, redis, pdo_mysql, pdo_pgsql i inne wymagane. ServBay domyślnie je włącza; możesz zweryfikować to w ustawieniach PHP ServBay.
3. Dostęp do terminala: Znajomość obsługi aplikacji Terminal w macOS.

Instalacja Webman

1. Sprawdź dostępność Composer

   ServBay jest wyposażony w Composer, gotowy do użycia w terminalu. Możesz to sprawdzić komendą:

   composer --version

   Jeśli pojawi się informacja o wersji Composer, narzędzie jest gotowe.

2. Wejdź do katalogu stron ServBay

   Otwórz terminal i przejdź do katalogu zalecanego do tworzenia stron internetowych:

   cd /Applications/ServBay/www

3. Utwórz projekt Webman za pomocą Composer

   Użyj polecenia create-project, by pobrać Webman do wskazanego katalogu — nazwijmy go servbay-webman-app:

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

   Composer pobierze Webman i jego zależności do katalogu servbay-webman-app.

4. Wejdź do katalogu projektu

   Po instalacji przejdź do utworzonego katalogu:

   cd servbay-webman-app

5. Instalacja wymaganych pakietów

   By móc wykorzystać bazę danych i cache, zainstaluj dodatkowe biblioteki Composer (np. illuminate/database z Laravel, illuminate/redis). Flaga -W (--with-dependencies) zapewnia rozwiązanie konfliktów zależności.

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

   Polecenie zainstaluje ORM do bazy danych, klienta Redis, paginację, obsługę zdarzeń i narzędzie do debugowania VarDumper.

Tworzenie bazy danych i tabel

Aby kod testowy działał, należy utworzyć bazę danych i tabelę users w MySQL i PostgreSQL ServBay. Domyślne hasło użytkownika root to password.

Możesz wykorzystać narzędzia takie jak phpMyAdmin lub pgAdmin dostępne z panelu ServBay, albo użyć poniższych poleceń SQL w konsoli.

1. Tworzenie bazy webman_app:

   • MySQL:

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

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Tworzenie tabeli users w bazie webman_app:

   • 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; -- przełącz do utworzonej bazy
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Pisanie kodu projektu Web

Teraz dodamy kod na routery, kontrolery i obsługę baz danych oraz cache.

1. Konfiguracja routerów

   Edytuj plik config/route.php w katalogu głównym projektu, dodając poniższy kod definiujący trasy:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Definicja trasy dla strony głównej, obsługiwanej przez metodę index kontrolera IndexController
   Route::any('/', [IndexController::class, 'index']);
   
   // Trasy dotyczące cache
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Trasy dotyczące bazy danych
   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']);
   
   // Możesz tutaj dodać więcej tras...

2. Tworzenie plików kontrolerów

   Utwórz w katalogu app/controller pliki IndexController.php, CacheController.php i DatabaseController.php z poniższym kodem.

   • app/controller/IndexController.php: obsługuje żądania do strony głównej.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // import klasy Response
     
     class IndexController
     {
         /**
          * Przykładowa metoda obsługi strony głównej
          * @param Request $request bieżący obiekt żądania
          * @return Response zwraca obiekt Response
          */
         public function index(Request $request): Response // jawne określenie zwracanego typu
         {
             // Zwróć prostą odpowiedź tekstową
             return response('Hello ServBay & Webman!'); // aktualizacja komunikatu powitalnego
         }
     }

   • app/controller/CacheController.php: demonstracja użycia Memcached i Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // import klasy Memcached
     use support\Redis; // import klasy Redis z Webman
     
     class CacheController
     {
         /**
          * Przykład użycia Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Połączenie z serwerem Memcached, domyślnie ServBay działa na 127.0.0.1:11211
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Ustawienie wartości cache, ważność 60 sekund
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // aktualizacja klucza i wartości
             if (!$success) {
                  return response('Failed to set Memcached key', 500);
             }
     
             // Pobranie wartości z cache
             $value = $memcached->get('servbay_key'); // aktualizacja klucza
     
             // Zwrot pobranej wartości
             return response($value ?: 'Memcached key not found or expired'); // dodano komunikat dla braku danych
         }
     
         /**
          * Przykład użycia Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Ustawienie wartości przez Webman Redis
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // aktualizacja klucza i wartości
     
             // Pobranie wartości przez Webman Redis
             $value = Redis::get('servbay_redis_key'); // aktualizacja klucza
     
             // Zwrot pobranej wartości
             return response($value ?: 'Redis key not found'); // dodano komunikat dla braku danych
         }
     }

   • app/controller/DatabaseController.php: demonstracja operacji na MySQL i PostgreSQL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // import Db z Webman
     
     class DatabaseController
     {
         /**
          * Dodawanie użytkownika do bazy MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Połączenie z bazą MySQL i dodanie wpisu
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // przykładowe dane
                     'email' => 'mysql_demo@servbay.test', // przykładowy email
                     'created_at' => date('Y-m-d H:i:s') // dodanie daty utworzenia
                 ]);
                 return response('User added to MySQL'); // aktualizacja komunikatu odpowiedzi
             } catch (\Exception $e) {
                 return response('Error adding user to MySQL: ' . $e->getMessage(), 500); // obsługa błędów
             }
         }
     
         /**
          * Pobieranie użytkowników z bazy MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Pobranie wszystkich użytkowników z MySQL
                 $users = Db::connection('mysql')->table('users')->get();
                 // Zwrócenie listy użytkowników w formacie JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // jawne określenie Content-Type
             } catch (\Exception $e) {
                  return response('Error getting users from MySQL: ' . $e->getMessage(), 500); // obsługa błędów
             }
         }
     
         /**
          * Dodawanie użytkownika do bazy PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Połączenie z bazą PostgreSQL i dodanie wpisu
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // przykładowe dane
                     'email' => 'pgsql_demo@servbay.test', // przykładowy email
                     'created_at' => date('Y-m-d H:i:s') // dodanie daty utworzenia
                 ]);
                 return response('User added to PostgreSQL'); // komunikat odpowiedzi
              } catch (\Exception $e) {
                 return response('Error adding user to PostgreSQL: ' . $e->getMessage(), 500); // obsługa błędów
              }
         }
     
         /**
          * Pobieranie użytkowników z bazy PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Pobranie wszystkich użytkowników z PostgreSQL
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Zwrócenie listy użytkowników w formacie JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // jawne określenie Content-Type
              } catch (\Exception $e) {
                 return response('Error getting users from PostgreSQL: ' . $e->getMessage(), 500); // obsługa błędów
              }
         }
     }

3. Konfiguracja połączeń do baz danych

   Edytuj plik config/database.php i skonfiguruj połączenie do MySQL oraz PostgreSQL. W ServBay domyślny host to 127.0.0.1, porty: 3306 (MySQL), 5432 (PostgreSQL), użytkownik root, hasło password.

   <?php
   /**
    * Konfiguracja bazy danych
    */
   return [
       // Domyślne połączenie
       'default' => 'mysql',
   
       // Lista konfiguracji połączeń do baz
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Domyślny host i port MySQL w ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nazwa utworzonej bazy
               'database'  => 'webman_app',
               // Domyślny użytkownik MySQL
               'username'  => 'root',
               // Domyślne hasło MySQL
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Domyślny host i port PostgreSQL w ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nazwa utworzonej bazy
               'database' => 'webman_app',
                // Domyślny użytkownik PostgreSQL
               'username' => 'root',
                // Domyślne hasło PostgreSQL
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // lub require, verify-ca, verify-full
           ],
           // Tutaj możesz dodać kolejne połączenia do baz...
       ],
   ];

   Ważne: W środowisku produkcyjnym koniecznie zmień domyślne hasło bazy i unikaj zapisywania wrażliwych danych w kodzie.

Uruchamianie projektu Webman

Projekt Webman uruchamia się poprzez skrypt start.php, który aktywuje proces Workerman — w odróżnieniu od tradycyjnego trybu przez Nginx/Apache + PHP-FPM, Webman działa jako aplikacja asynchroniczna rezydująca w pamięci.

Uruchom projekt w katalogu /Applications/ServBay/www/servbay-webman-app:

php start.php start

Po wykonaniu komendy pojawią się informacje o starcie Webman. Domyślnie nasłuchuje HTTP na adresie 127.0.0.1:8787.

• Uwaga: Używasz polecenia php z wersji zainstalowanej przez ServBay. ServBay automatycznie konfiguruje środowisko terminala, aby korzystać z właściwego PHP.
• Możesz uruchomić Webman w tle przez dodanie -d: php start.php start -d.
• Aby zatrzymać usługę Webman, użyj: php start.php stop.
• By zrestartować, skorzystaj z: php start.php restart.
• Dla płynnego restartu (bez przerywania obsługi żądań): php start.php reload.

Testowanie projektu

Po starcie Webman i nasłuchiwaniu na 127.0.0.1:8787 możesz przetestować funkcje projektu w przeglądarce, odwiedzając:

• http://localhost:8787/ — powinieneś zobaczyć komunikat Hello ServBay & Webman!.
• http://localhost:8787/memcached — pojawi się Hello Memcached from ServBay!, co świadczy o poprawnym podłączeniu do Memcached przez Webman.
• http://localhost:8787/redis — zobaczysz Hello Redis from ServBay!, czyli Webman poprawnie łączy się z Redis.
• http://localhost:8787/mysql-add — komunikat User added to MySQL, dodający wpis do tabeli users w bazie MySQL.
• http://localhost:8787/mysql — zwróci listę użytkowników z MySQL w formie JSON.
• http://localhost:8787/pgsql-add — komunikat User added to PostgreSQL z dodaniem wpisu do tabeli w PostgreSQL.
• http://localhost:8787/pgsql — lista użytkowników z PostgreSQL w formacie JSON.

Jeśli napotkasz problemy, sprawdź błędy w terminalu Webman oraz upewnij się, że usługi MySQL, PostgreSQL, Redis, Memcached są aktywne i odpowiednie rozszerzenia PHP są włączone.

FAQ — Najczęstsze problemy

• P: Komenda php start.php start nie działa?
  • O: Upewnij się, że jesteś w katalogu projektu servbay-webman-app. Sprawdź, czy PHP od ServBay jest dostępne w PATH (ServBay zwykle ustawia to automatycznie).
• P: Nie można połączyć się z localhost:8787?
  • O: Sprawdź, czy nie pojawiły się błędy podczas uruchamiania w terminalu. Upewnij się, że port 8787 nie jest zajęty przez inną aplikację; w razie potrzeby zmień port w pliku config/server.php.
• P: Błąd połączenia z bazą danych?
  • O: Upewnij się, że usługi MySQL oraz PostgreSQL w ServBay są uruchomione, a dane w config/database.php (host, port, baza, użytkownik, hasło) są poprawne (domyślny user: root, hasło: password). Sprawdź, czy utworzyłeś bazę webman_app oraz tabelę users.
• P: Problemy z połączeniem do Memcached lub Redis?
  • O: Upewnij się, że usługi Memcached i Redis działają w ServBay, a adres i port w app/controller/CacheController.php są poprawne (127.0.0.1:11211 dla Memcached, 127.0.0.1:6379 dla Redis). Sprawdź, czy wersja PHP ma włączone rozszerzenia memcached i redis.

Podsumowanie

Wykonując powyższe kroki, utworzyłeś i poprawnie skonfigurowałeś prosty projekt Webman w lokalnym środowisku ServBay. Poznałeś szybki sposób uruchamiania aplikacji Webman w ServBay oraz integrację bazy danych i cache. Połączenie wysokiej wydajności Webman z wygodą ServBay stanowi solidną bazę dla tworzenia asynchronicznych aplikacji PHP. Mamy nadzieję, że ten poradnik pomoże Ci wydajnie zbudować własne aplikacje webowe z użyciem ServBay oraz Webman.