Tworzenie i uruchamianie projektu Slim w ServBay

W tym artykule dowiesz się, jak szybko utworzyć, skonfigurować i uruchomić projekt Slim Framework PHP w nowoczesnym, lokalnym środowisku deweloperskim ServBay. ServBay to zintegrowany pakiet z PHP, serwerami WWW (Caddy/Nginx/Apache) oraz wieloma bazami danych, co czyni go idealną platformą do rozwoju aplikacji Slim.

Czym jest Slim?

Slim to lekki mikroframework PHP zaprojektowany do szybkiego tworzenia prostych, ale skutecznych aplikacji webowych i API. Zapewnia podstawowe funkcje routingu, obsługi żądań i odpowiedzi, i doskonale sprawdza się w projektach wymagających szybkiego wdrożenia oraz jako fundament bardziej rozbudowanych aplikacji.

Kluczowe cechy i zalety Slim

• Lekkość: Trzon frameworka Slim jest minimalny, zajmuje niewiele zasobów i uruchamia się błyskawicznie — świetny wybór dla aplikacji małych i średnich oraz mikroserwisów.
• Elastyczność: Slim jest łatwo rozszerzalny i pozwala na integrację z dowolnymi bibliotekami czy komponentami (np. silniki szablonów, ORM, narzędzia autoryzujące), dając swobodę wyboru narzędzi spełniających Twoje potrzeby.
• Łatwość użycia: Slim oferuje czytelne API i dobrze napisaną dokumentację, dzięki czemu deweloperzy mogą szybko nauczyć się frameworka i rozpocząć pracę.
• Zaawansowane funkcje routingu: Obsługuje wiele metod HTTP (GET, POST, PUT, DELETE itd.) oraz zaawansowaną konfigurację tras — w tym grupowanie tras, middleware i parametry.
• Wsparcie dla middleware: Slim pozwala na stosowanie warstw middleware, które mogą obsługiwać np. autoryzację, logowanie, CORS przed przekazaniem żądania do logiki aplikacji lub przed wysłaniem odpowiedzi do klienta.

Slim świetnie sprawdza się przy budowaniu RESTful API, szybkich prototypach oraz aplikacjach o wybranej, wyizolowanej funkcjonalności.

Tworzenie i uruchamianie projektu Slim przy użyciu ServBay

W tym przewodniku wykorzystamy prekonfigurowane środowisko PHP oraz opcję Strony w ServBay do ustawienia serwera WWW i umożliwienia dostępu do aplikacji Slim.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

1. ServBay jest zainstalowany i uruchomiony: Sprawdź, czy ServBay jest poprawnie zainstalowany na Twoim macOS lub Windows i aplikacja działa.
2. ServBay zawiera Composer: Composer jest zintegrowany z ServBay domyślnie, nie musisz instalować go osobno.

Tworzenie projektu Slim

ServBay zaleca organizację wszystkich projektów webowych w dedykowanym folderze, co ułatwia zarządzanie:

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

1. Przejście do katalogu głównego ServBay:

   macOS:

   cd /Applications/ServBay/www

   Windows:

   cd C:\ServBay\www

2. Utwórz katalog projektu: Utwórz folder na aplikację Slim.

   mkdir servbay-slim-app

3. Przejdź do katalogu projektu:

   cd servbay-slim-app

4. Instalacja Slim za pomocą Composer: W katalogu projektu uruchom Composer dla instalacji Slim Framework oraz implementacji PSR-7.

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

   Komenda pobierze Slim Framework i bibliotekę slim/psr7 do katalogu vendor oraz utworzy pliki composer.json i composer.lock.

Inicjalizacja aplikacji Slim

1. Utwórz plik wejściowy: Aplikacje Slim mają zwykle jeden plik wejściowy (np. public/index.php). Utwórz folder public i plik index.php w katalogu projektu.

   mkdir public
   touch public/index.php

2. Edytuj plik wejściowy: Otwórz public/index.php i dodaj podstawową konfigurację Slim:

   <?php
   // Załaduj automatyczny loader Composera
   require __DIR__ . '/../vendor/autoload.php';
   
   // Importuj interfejsy PSR-7 i fabrykę Slim
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Utwórz instancję aplikacji Slim
   $app = AppFactory::create();
   
   // Dodaj przykładową trasę obsługującą żądanie GET na '/'
   $app->get('/', function (Request $request, Response $response, $args) {
       // Zapisz tekst do ciała odpowiedzi
       $response->getBody()->write("Hello ServBay!");
       // Zwróć odpowiedź
       return $response;
   });
   
   // Uruchom aplikację Slim
   $app->run();

   Ten kod tworzy najprostszą aplikację Slim, definiując trasę obsługującą GET dla adresu głównego (/) oraz zwracając odpowiedź "Hello ServBay!".

Konfiguracja strony w ServBay

Aby uzyskać dostęp do projektu Slim z poziomu przeglądarki, musisz skonfigurować Stronę (w starszych wersjach: „Host”) w ServBay.

1. Otwórz interfejs aplikacji ServBay.
2. Przejdź do modułu Strony (Websites).
3. Kliknij „Dodaj nową stronę”.
4. Uzupełnij konfigurację według swojego projektu:

   • Nazwa: My First Slim Dev Site (lub dowolna inna)

   • Domena: servbay-slim-test.local (zalecane końcówki .local lub .test dla stron lokalnych)

   • Typ strony: PHP

   • Wersja PHP: wybierz właściwą, np. 8.3

   • Katalog główny: wybierz folder public w projekcie:

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

     Slim domyślnie obsługuje plik index.php w katalogu public, więc serwer WWW powinien kierować żądania do tego folderu.

5. Zapisz konfigurację strony. ServBay automatycznie zaktualizuje konfigurację serwera WWW.

Szczegółową instrukcję znajdziesz tutaj: Dodawanie pierwszej strony.

Dostęp do swojego Slim Site

Po zakończonej konfiguracji, otwórz przeglądarkę i odwiedź domenę https://servbay-slim-test.local.

Jeśli wszystko poszło dobrze, zobaczysz tekst Hello ServBay! na stronie, co oznacza, że Twój projekt Slim działa prawidłowo pod kontrolą serwera ServBay.

Przykłady integracji z bazą danych

Sam Slim nie oferuje warstwy abstrakcji bazy danych, ale można go łatwo integrować z różnymi bibliotekami PHP. Tutaj pokażemy przykład z Eloquent ORM (komponent illuminate/database z Laravel), integrację z MySQL, PostgreSQL oraz przykładową obsługę Memcached i Redis.

Wymagania wstępne: Tworzenie bazy danych i migracje

Zanim zintegrujesz bazę danych, utwórz ją w ServBay i przygotuj strukturę tabel.

1. Tworzenie bazy danych:

   • W ServBay przejdź do odpowiedniego pakietu (np. MySQL lub PostgreSQL).
   • Użyj narzędzia administracyjnego ServBay (phpMyAdmin/MariaDB czy pgAdmin dla PostgreSQL) lub klienta CLI, aby utworzyć nową bazę, np. servbay_slim_app.
   • Domyślne hasło użytkownika root w ServBay to zazwyczaj password (możesz je sprawdzić/zaktualizować w aplikacji ServBay).

2. Instalacja i konfiguracja Phinx (narzędzie migracji): Phinx pozwala na wersjonowanie struktury bazy.

   • Zainstaluj Phinx w folderze projektu:

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

     composer require robmorgan/phinx

   • Inicjuj konfigurację Phinx:

     vendor/bin/phinx init

     Powstanie plik phinx.yml — edytuj go, wpisując dane dostępowe:

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development # lub nazwa Twojego środowiska
     
         development: # skonfiguruj wg typu bazy
             adapter: mysql # lub pgsql
             host: 127.0.0.1
             name: servbay_slim_app # nazwa bazy
             user: root
             pass: password # hasło do bazy
             port: 3306 # domyślny port MySQL, PostgreSQL to 5432
             charset: utf8mb4 # dla MySQL
             collation: utf8mb4_unicode_ci # dla MySQL
     
     version_order: creation

3. Tworzenie pliku migracyjnego: Za pomocą Phinx utwórz migrację:

   vendor/bin/phinx create CreateUsersTable

   W folderze db/migrations powstanie plik PHP. W metodzie change() zdefiniuj strukturę tabeli users:

   <?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() // Dodaje pola created_at i updated_at
                 ->create();
       }
   }

4. Wykonanie migracji: W folderze projektu uruchom Phinx, aby utworzyć tabelę users:

   vendor/bin/phinx migrate

   WAŻNE: Przed użyciem kodów z poniższych przykładów, wykonaj migrację i stwórz bazę danych.

Użycie komponentu illuminate/database

Wykorzystamy illuminate/database Laravel jako ORM/builder zapytań.

1. Instalacja illuminate/database: W folderze projektu:

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

   composer require illuminate/database

2. Inicjalizacja połączenia w public/index.php: Zaraz po require __DIR__ . '/../vendor/autoload.php';, przed $app = AppFactory::create();, dodaj:

   // ... inne require i use ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // Import Capsule
   
   // Inicjalizacja Eloquent ORM
   $capsule = new Capsule;
   
   // Dodaj konfigurację połączenia (dostosuj driver i parametry)
   $capsule->addConnection([
       'driver' => 'mysql', // lub 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app', // nazwa bazy
       'username' => 'root',
       'password' => 'password',
       'charset' => 'utf8mb4', // dla MySQL
       'collation' => 'utf8mb4_unicode_ci', // dla MySQL
       'prefix' => '',
       // Dla PostgreSQL dodaj schema
       // 'schema' => 'public',
   ]);
   
   // Dostęp globalny
   $capsule->setAsGlobal();
   
   // Start Eloquent
   $capsule->bootEloquent();
   
   // ... Tworzenie instancji Slim ($app = AppFactory::create();) ...

Przykład MySQL

Jeśli uruchomiłeś pakiet MySQL w ServBay, utworzyłeś bazę servbay_slim_app i tabelę users (Phinx), dodaj następujące trasy w public/index.php przed $app->run();:

// ... wcześniejsza inicjalizacja i trasa '/' ...

use Illuminate\Database\Capsule\Manager as Capsule; // Upewnij się, że zaimportowano

// Trasa dodająca użytkownika
$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', // Zapewnia unikalność adresu
            '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); // Kod błędu
    }
    return $response;
});

// Trasa pobierająca wszystkich użytkowników
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // Wynik w JSON
        $response = $response->withHeader('Content-Type', 'application/json'); // Nagłówek Content-Type
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

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

Jak korzystać:

• Wejdź na https://servbay-slim-test.local/mysql-add-user — dodasz użytkownika do MySQL.
• Wejdź na https://servbay-slim-test.local/mysql-get-users — uzyskasz listę użytkowników w formacie JSON.

Przykład PostgreSQL

Załóżmy, że masz uruchomiony pakiet PostgreSQL w ServBay, bazę servbay_slim_app i tabelę users (Phinx, adapter: pgsql, port: 5432).

W public/index.php skonfiguruj połączenie, zmieniając driver na pgsql oraz dodając schema:

$capsule->addConnection([
    'driver' => 'pgsql', // Ustaw na pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // Dla PostgreSQL to najczęstszy wybór
    'prefix' => '',
    'schema' => 'public', // Wymagane dla PostgreSQL
]);
// ... Pozostała inicjalizacja Eloquent bez zmian ...

Dodaj trasy w public/index.php przed $app->run();:

// ... wcześniejsze inicjalizacje i trasy (w tym MySQL, jeśli potrzebujesz) ...

use Illuminate\Database\Capsule\Manager as Capsule; // Upewnij się, że zaimportowano

// Trasa dodająca użytkownika do 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',
            '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;
});

// Trasa pobierająca użytkowników z PostgreSQL
$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();

Jak korzystać:

• Wejdź na https://servbay-slim-test.local/pgsql-add-user — dodasz użytkownika do PostgreSQL.
• Wejdź na https://servbay-slim-test.local/pgsql-get-users — otrzymasz listę z PostgreSQL w formie JSON.

Przykład Memcached

ServBay dostarcza pakiet Memcached oraz rozszerzenie PHP ext-memcached. Potrzebujesz tylko klienta PHP, np. memcached/memcached.

1. Instalacja klienta Memcached: W folderze projektu:

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

   composer require memcached/memcached

2. Dodaj trasę Memcached w public/index.php: Przed $app->run(); dodaj:

   // ... wcześniejsze inicjalizacje i trasy ...
   
   // Trasa Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Utwórz instancję klienta Memcached
       $memcached = new Memcached();
       // Dodaj serwer Memcached (ServBay domyślnie: 127.0.0.1:11211)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Spróbuj pobrać dane z cache
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Jeśli brak danych w pamięci, wygeneruj je i zapis do cache
           $cachedData = 'Hello Memcached from ServBay! This was not cached.';
           // Zapisz do cache na 60 sekund
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // Dane są w cache — wyświetl je
           $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
       }
   
       return $response;
   });
   
   // ... $app->run();

Jak korzystać: Wejdź na https://servbay-slim-test.local/memcached-example. Pierwsze wywołanie pokaże "This was not cached.", kolejne (przed wygaśnięciem cache) — "This was served from cache.".

Przykład Redis

ServBay udostępnia pakiet Redis oraz rozszerzenie PHP ext-redis. Potrzebujesz klienta, np. predis/predis.

1. Instalacja klienta Redis: W folderze projektu:

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

   composer require predis/predis

2. Dodaj trasę Redis w public/index.php: Przed $app->run(); dodaj:

   // ... wcześniejsze inicjalizacje, trasy baz danych, Memcached ...
   
   use Predis\Client as RedisClient; // Import klasa klienta Predis
   
   // Trasa Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Utwórz instancję klienta Redis (ServBay domyślnie: 127.0.0.1:6379)
           $redis = new RedisClient([
               'scheme' => 'tcp',
               'host' => '127.0.0.1',
               'port' => 6379,
           ]);
   
           $cacheKey = 'my_servbay_redis_cache_key';
           // Pobierz dane z cache
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Jeśli brak danych w pamięci, wygeneruj i zapisz do Redis
               $cachedData = 'Hello Redis from ServBay! This was not cached.';
               // Zapisz do cache na 60 sekund
               $redis->setex($cacheKey, 60, $cachedData); // SETEX key sekundy wartość
               $response->getBody()->write($cachedData);
           } else {
               // Dane są w cache — wyświetl je
               $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
           }
       } catch (\Exception $e) {
           // Obsługa błędu połączenia/operacji
           $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
           $response = $response->withStatus(500);
       }
   
   
       return $response;
   });
   
   // ... $app->run();

Jak korzystać: Wejdź na https://servbay-slim-test.local/redis-example. Pierwsze wywołanie da "This was not cached.", kolejne (przed wygaśnięciem cache) — "This was served from cache.".

Podsumowanie

Dzięki powyższym krokom utworzysz projekt Slim Framework w lokalnym środowisku ServBay oraz skonfigurujesz Stronę do hostowania i dostępu do niej przez przeglądarkę. Zintegrujesz też pakiety bazodanowe ServBay — MySQL, PostgreSQL, Memcached, Redis — i odpowiednie rozszerzenia PHP, aby włączyć obsługę baz danych i cache w aplikacji Slim. ServBay upraszcza budowę i zarządzanie lokalnym środowiskiem, pozwalając Ci skupić się na samej aplikacji Slim.