Tworzenie i uruchamianie projektu FuelPHP w lokalnym środowisku ServBay

Czym jest FuelPHP?

FuelPHP to elastyczny i modułowy framework PHP, zaprojektowany do tworzenia nowoczesnych aplikacji internetowych. Bazuje na wzorcu architektonicznym HMVC (Hierarchical Model-View-Controller) i oferuje bogaty zestaw narzędzi wspomagających szybkie oraz efektywne budowanie wysokiej jakości aplikacji webowych. FuelPHP jest ceniony przez programistów PHP za wyjątkową elastyczność, wysoką wydajność i łatwość rozbudowy.

Główne cechy i zalety FuelPHP

Architektura HMVC: Wsparcie dla wielopoziomowego wzorca MVC sprzyja organizacji kodu, ponownemu wykorzystaniu komponentów oraz rozwojowi modułowemu, co jest szczególnie przydatne w dużych i złożonych projektach.
Wysoka wydajność: FuelPHP został zoptymalizowany pod kątem szybkości i efektywnego wykorzystania zasobów, co umożliwia obsługę dużej liczby jednoczesnych żądań.
Łatwość rozbudowy: Framework posiada rozbudowany system rozszerzeń, który pozwala łatwo integrować biblioteki zewnętrzne oraz dodawać własne funkcjonalności zgodnie z wymaganiami projektu.
Bezpieczeństwo: Wbudowane mechanizmy zabezpieczeń obejmują automatyczną walidację danych wejściowych, filtrowanie wyjść (ochrona przed XSS), zabezpieczenie CSRF, prewencję SQL Injection i inne, dzięki czemu aplikacje są bardziej bezpieczne.
Aktywna społeczność: Wokół FuelPHP działa aktywna społeczność deweloperów oferująca szybkie wsparcie oraz wiele zasobów zewnętrznych.

Dzięki tym zaletom FuelPHP umożliwia szybkie budowanie wydajnych, bezpiecznych i łatwych w utrzymaniu aplikacji webowych, odpowiednich zarówno dla małych, jak i dużych przedsiębiorstw.

Tworzenie środowiska programistycznego FuelPHP z ServBay

ServBay to lokalne środowisko programistyczne stworzone specjalnie dla deweloperów. Oferuje gotowe do użycia usługi takie jak PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis i wiele innych niezbędnych narzędzi. Dzięki ServBay możesz skonfigurować kompletne środowisko pracy dla projektu FuelPHP bez ręcznego instalowania i konfigurowania zależności.

Ten przewodnik szczegółowo krok po kroku opisuje wykorzystanie środowiska PHP, serwera WWW (Caddy), bazy danych oraz usług cache dostarczanych przez ServBay do stworzenia i uruchomienia projektu FuelPHP. Skorzystamy z funkcji Strony ("Websites") ServBay, aby skonfigurować serwer oraz uzyskać łatwy dostęp i możliwość szybkiego testowania projektu.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

ServBay został prawidłowo zainstalowany i uruchomiony na macOS.
Środowisko PHP jest włączone w ServBay (domyślnie jest aktywne).
Usługi bazy danych (np. MySQL) oraz cache (np. Redis, Memcached), których planujesz używać, są uruchomione i działają poprawnie w ServBay.
Composer jest dostarczany wraz z ServBay, nie musisz instalować go osobno.

Tworzenie projektu FuelPHP

Zalecana ścieżka dla projektów

ServBay zaleca, aby wszystkie projekty były przechowywane w katalogu /Applications/ServBay/www, co ułatwia zarządzanie i konfigurację. W niniejszym przewodniku również korzystamy z tej lokalizacji.

Przejdź do katalogu głównego stron WWW
Otwórz Terminal i przejdź do katalogu polecanego przez ServBay:
bash
```
cd /Applications/ServBay/www
```
1
Utwórz katalog projektu
Stwórz nowy folder dla projektu FuelPHP i przejdź do niego:
bash
```
mkdir servbay-fuelphp-app
cd servbay-fuelphp-app
```
1
2
Utwórz projekt FuelPHP przy użyciu Composer
Użyj Composer w bieżącym katalogu, by pobrać i zainicjować szkielet FuelPHP:
bash
```
composer create-project fuel/fuel .
```
1
Composer pobierze framework FuelPHP oraz wszystkie jego zależności do folderu servbay-fuelphp-app.

Konfiguracja serwera WWW (funkcja Strony ServBay)

Aby uzyskać dostęp do aplikacji FuelPHP przez przeglądarkę, musisz skonfigurować dla niej wirtualny host za pomocą funkcji Strony ("Websites") ServBay.

Otwórz główny interfejs ServBay.
Wybierz z menu po lewej opcję Strony.
Kliknij przycisk Dodaj stronę w prawym górnym rogu.
W oknie konfiguracyjnym uzupełnij następujące dane:
- Nazwa: Przypisz łatwo rozpoznawalną nazwę, np. My First FuelPHP Dev Site.
- Domena: Ustal lokalną domenę, np. servbay-fuelphp-test.local (ServBay automatycznie przypisze ją do localhost).
- Typ strony: Wybierz PHP.
- Wersja PHP: Wskaż wersję PHP, np. 8.3.
- Katalog główny strony: Określ folder z plikiem startowym aplikacji. Publiczny plik wejściowy FuelPHP to public/index.php, zatem wskaż podkatalog public: /Applications/ServBay/www/servbay-fuelphp-app/public.
Zapisz konfigurację, klikając Dodaj.

ServBay samodzielnie zaktualizuje konfigurację Caddy i przeładuje serwis, uaktywniając nową domenę.

Szczegółowy opis dodawania strony znajdziesz w dokumentacji ServBay: Dodawanie pierwszej strony.

Konfiguracja połączeń usług w projekcie FuelPHP

Typowe projekty FuelPHP wymagają ustawienia połączeń do bazy danych i usług cache.

Konfiguracja bazy danych

Ustawienia bazy danych znajdziesz w pliku fuel/app/config/development/db.php. Edytuj ten plik i dopasuj go do swojej konfiguracji – poniżej przykład dla domyślnego serwera MySQL ServBay:

php

<?php
/**
 * Ustawienia bazy danych dla środowiska developerskiego. Są one scalane z ustawieniami globalnymi.
 */
return [
    'default' => [
        'connection' => [
            'dsn'      => 'mysql:host=localhost;dbname=fuel_dev', // Upewnij się, że baza fuel_dev istnieje
            'username' => 'root', // Domyślny użytkownik MySQL w ServBay
            'password' => 'root', // Domyślne hasło MySQL w ServBay (do użytku tylko lokalnie!)
        ],
        'identifier' => '`', // MySQL wymaga odwrotnego apostrofu jako identyfikatora
    ],
];

Uwaga:

Baza danych fuel_dev musi zostać utworzona ręcznie w narzędziu do zarządzania bazą, np. phpMyAdmin lub Adminer. Domyślne hasło użytkownika root to również root – rekomendowane tylko do zastosowań lokalnych.
'identifier' => ''` jest wymagane dla MySQL, żeby poprawnie cytować nazwy tabel i pól.

Konfiguracja cache (Memcached i Redis)

FuelPHP obsługuje różne mechanizmy cache. Skonfiguruj je w pliku fuel/app/config/cache.php. Upewnij się, że odpowiednie usługi (Memcached/Redis) są włączone w ServBay.

Konfiguracja Memcached (fuel/app/config/cache.php):

Aby używać Memcached jako domyślnego cache:

php

<?php
return [
    'driver' => 'memcached', // Domyślny driver - memcached
    'memcached' => [
        'cache_id' => 'fuel', // Identyfikator cache
        'servers' => [
             'default' => [
                'host'   => '127.0.0.1', // Adres domyślny
                'port'   => 11211,      // Domyślny port
                'weight' => 100,
            ],
        ],
        'compression' => false, // Czy włączyć kompresję
    ],
    // ... inne ustawienia driverów cache
];

PHP w ServBay posiada zazwyczaj włączone rozszerzenie Memcached.

Konfiguracja Redis (fuel/app/config/redis.php):

Dla Redisa konfiguracja znajduje się zwykle w osobnym pliku redis.php:

php

<?php
return [
    'default' => [
        'hostname' => '127.0.0.1', // Adres domyślny Redisa
        'port'     => 6379,      // Domyślny port Redisa
        'database' => 0,         // Indeks bazy danych
    ],
    // Możesz zdefiniować więcej połączeń
];

PHP w ServBay posiada zazwyczaj włączone rozszerzenie Redis.

Przykłady korzystania z bazy danych i cache

Aby zobrazować integrację FuelPHP z usługami bazy danych i cache, przygotowaliśmy przykładowy kod.

Przygotowanie tabeli bazy danych (migracje FuelPHP)

System Oil w FuelPHP pozwala zarządzać migracjami – wersjonowanymi zmianami struktury bazy danych.

Utwórz plik migracji
W katalogu głównym projektu (servbay-fuelphp-app) wygeneruj migrację dla tabeli users:
bash
```
php oil generate migration create_users_table
```
1
Plik migracji pojawi się w katalogu fuel/app/migrations ze znacznikiem czasowym w nazwie.

Edytuj plik migracji

Otwórz właśnie utworzony plik (fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php) i wypełnij metody up() i down() odpowiednią logiką:

php

<?php
namespace Fuel\Migrations;

use Fuel\Core\DBUtil;

class Create_users_table
{
    public function up()
    {
        // Tworzenie tabeli users
        DBUtil::create_table('users', [
            'id'          => ['type' => 'int', 'constraint' => 11, 'auto_increment' => true],
            'name'        => ['type' => 'varchar', 'constraint' => 100],
            'email'       => ['type' => 'varchar', 'constraint' => 100, 'unique' => true],
        ], ['id'], true, 'InnoDB', 'utf8mb4_unicode_ci'); // Primary key, indexy, silnik, charset
    }

    public function down()
    {
        // Usuwanie tabeli users (rollback)
        DBUtil::drop_table('users');
    }
}

Wykonaj migrację
W katalogu głównym projektu uruchom migracje:
bash
```
php oil refine migrate
```
1
Jeśli wszystko przebiegło pomyślnie, tabela users zostanie utworzona w bazie fuel_dev.

Dodanie przykładowych akcji kontrolera

Edytuj plik fuel/app/classes/controller/welcome.php, aby dodać przykładowe akcje dla obsługi bazy i cache:

php

<?php
use Fuel\Core\Controller;
use Fuel\Core\Response;
use Fuel\Core\Cache;
use Fuel\Core\DB; // Dołącz DB facade
use Fuel\Core\Redis; // Dołącz Redis facade

class Controller_Welcome extends Controller
{
    // Domyślna akcja główna
    public function action_index()
    {
        return Response::forge('Hello ServBay!');
    }

    // Przykład z Memcached
    public function action_memcached()
    {
        // Pobierz dane z cache
        $value = Cache::get('servbay_memcached_key');

        if ($value === false) {
            // Jeśli brak w cache - ustaw dane
            $value = 'Hello Memcached from ServBay!';
            Cache::set('servbay_memcached_key', $value, 60); // 60 sek. w cache
            $value .= ' (from cache)';
        } else {
            $value .= ' (cached)';
        }

        return Response::forge($value);
    }

    // Przykład z Redis
    public function action_redis()
    {
        // Pobierz instancję Redis (domyślne połączenie)
        $redis = \Redis_Db::instance();
        // Alternatywnie: \Redis_Db::instance('connection_name')

        // Zapisz dane do Redisa
        $redis->set('servbay_redis_key', 'Hello Redis from ServBay!');

        // Pobierz z Redisa
        $value = $redis->get('servbay_redis_key');

        return Response::forge($value);
    }

    // Przykład zapisu do MySQL
    public function action_mysql_add()
    {
        try {
            // Dodaj wpis do users
            $result = DB::insert('users')->set([
                'name' => 'ServBay Demo User ' . time(), // Unikalność przez timestamp
                'email' => 'demo_user_' . time() . '@servbay.test',
            ])->execute(); // execute() zwraca tablicę z nowym ID

            return Response::forge('User added with ID: ' . $result[0]);
        } catch (\Database_Exception $e) {
            // Obsługa wyjątków (np. duplikat email)
            return Response::forge('Error adding user: ' . $e->getMessage(), 500);
        }
    }

    // Przykład odczytu z MySQL
    public function action_mysql()
    {
        // Wczytaj wszystkie rekordy
        $users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();

        // Zwróć listę użytkowników jako JSON
        return Response::forge(json_encode($users, JSON_PRETTY_PRINT));
    }
}

Uwagi:

W kodzie znajdują się wywołania façade DB i Redis (use Fuel\Core\DB;, use Fuel\Core\Redis;) dla wygody.
Klucze w Memcached i Redis zaczynają się od servbay_ dla uniknięcia konfliktów.
W akcji zapisu do MySQL zastosowano timestamp oraz prostą obsługę błędów.
W FuelPHP 1.x Redis inicjuje się przez \Redis_Db::instance().

Konfiguracja trasowania żądań

Aby móc wywoływać przykładowe akcje przez dedykowane adresy URL, należy dodać odpowiednie trasy w pliku fuel/app/config/routes.php:

php

<?php
return array(
    '_root_'  => 'welcome/index',  // Domyślna trasa: akcja index kontrolera welcome
    '_404_'   => 'welcome/404',    // Trasa błędu 404

    // Trasy do nowych akcji przykładowych
    'memcached'   => 'welcome/memcached',
    'redis'       => 'welcome/redis',
    'mysql_add'   => 'welcome/mysql_add',
    'mysql'       => 'welcome/mysql',

    // ... inne trasy
);

Dostęp i testowanie strony

Teraz możesz odwiedzić skonfigurowaną wcześniej domenę, np. https://servbay-fuelphp-test.local i sprawdzić działanie projektu FuelPHP oraz jego integrację z usługami.

Strona główna: https://servbay-fuelphp-test.local
- Oczekiwany wynik: Hello ServBay!
Test Memcached: https://servbay-fuelphp-test.local/memcached
- Pierwsze wejście: Hello Memcached from ServBay! (from cache) (przy działającym cache)
- Kolejne wejścia: Hello Memcached from ServBay! (cached) (dopóki cache jest aktywny)
Test Redis: https://servbay-fuelphp-test.local/redis
- Oczekiwany wynik: Hello Redis from ServBay! (gdy Redis działa)
Dodaj użytkownika do MySQL: https://servbay-fuelphp-test.local/mysql_add
- Oczekiwany wynik: User added with ID: [nowe ID] (przy poprawnej konfiguracji)
Lista użytkowników z MySQL: https://servbay-fuelphp-test.local/mysql
- Oczekiwany wynik: tablica JSON z danymi z tabeli users (jeśli istnieją rekordy)

O HTTPS: ServBay domyślnie generuje certyfikat SSL dla strony lokalnej oraz instaluje CA ServBay User CA lub Public CA. Jeśli otrzymujesz ostrzeżenia w przeglądarce, potwierdź zaufanie do certyfikatu CA w systemie.

Ważne informacje

Upewnij się, że we frontendzie ServBay uruchomione są usługi: wybrana wersja PHP, Caddy (lub Nginx/Apache), MySQL (jeśli używasz bazy), Redis (jeśli używasz Redis), Memcached (jeśli używasz Memcached) itp.
Baza fuel_dev musi zostać założona ręcznie (lub skorzystaj z innej istniejącej, zgodnie z konfiguracją w db.php). Narzędzie migracji FuelPHP (oil refine migrate) utworzy tabele, ale nie samą bazę.
Publiczny plik wejściowy FuelPHP to public/index.php – dlatego w konfiguracji strony w ServBay katalog główny musi wskazywać podkatalog public.

Podsumowanie

Dzięki ServBay możesz łatwo stworzyć kompletne środowisko programistyczne dla FuelPHP na macOS. Ten przewodnik w sposób praktyczny opisuje proces tworzenia projektu, konfiguracji strony, ustawień bazy danych oraz usług cache – a także weryfikację ich działania przy użyciu przykładowego kodu. Przedinstalowane usługi oraz uproszczona konfiguracja w ServBay zdecydowanie przyspieszają i ułatwiają pracę dewelopera.

Mamy nadzieję, że ten poradnik pomoże Ci szybko rozpocząć własną przygodę z dewelopmentem FuelPHP w środowisku ServBay!

Tworzenie i uruchamianie projektu FuelPHP w lokalnym środowisku ServBay ​

Czym jest FuelPHP? ​

Główne cechy i zalety FuelPHP ​

Tworzenie środowiska programistycznego FuelPHP z ServBay ​

Wymagania wstępne ​

Tworzenie projektu FuelPHP ​

Konfiguracja serwera WWW (funkcja Strony ServBay) ​

Konfiguracja połączeń usług w projekcie FuelPHP ​

Konfiguracja bazy danych ​

Konfiguracja cache (Memcached i Redis) ​

Przykłady korzystania z bazy danych i cache ​

Przygotowanie tabeli bazy danych (migracje FuelPHP) ​

Dodanie przykładowych akcji kontrolera ​

Konfiguracja trasowania żądań ​

Dostęp i testowanie strony ​

Ważne informacje ​

Podsumowanie ​