Tworzenie i uruchamianie projektów FuelPHP w lokalnym środowisku ServBay

Czym jest FuelPHP?

FuelPHP to elastyczny, modułowy framework PHP, zaprojektowany z myślą o budowie nowoczesnych aplikacji webowych. Wykorzystuje wzorzec HMVC (Hierarchical Model-View-Controller), dostarczając bogaty zestaw funkcji i narzędzi, które wspierają programistów w szybkim i efektywnym tworzeniu zaawansowanych aplikacji. Dzięki swojej wyjątkowej elastyczności, wysokiej wydajności oraz łatwości rozbudowywania, FuelPHP jest częstym wyborem wśród developerów PHP.

Kluczowe cechy i zalety FuelPHP

Architektura HMVC: Wspiera hierarchiczny wzorzec Model-View-Controller, co ułatwia organizację kodu, jego ponowne użycie i tworzenie modułów — szczególnie w dużych lub rozbudowanych projektach.
Wysoka wydajność: FuelPHP został zaprojektowany z naciskiem na optymalizację, oferując szybkie i wydajne działanie nawet pod dużym obciążeniem.
Łatwa rozbudowa: Framework pozwala na łatwą integrację bibliotek zewnętrznych lub dodanie autorskich funkcjonalności według wymagań projektu.
Bezpieczeństwo: Posiada wbudowane mechanizmy zabezpieczające, m.in. automatyczną walidację danych wejściowych, filtrowanie wyjściowe (zapobieganie XSS), ochronę CSRF, zapobieganie SQL Injection i inne.
Silna społeczność: FuelPHP oferuje wsparcie aktywnej społeczności developerów, liczne zasoby i szybką pomoc.

Dzięki tym cechom FuelPHP umożliwia szybkie tworzenie wydajnych, bezpiecznych i łatwych w utrzymaniu aplikacji webowych, niezależnie od skali — od małych po rozwiązania enterprise.

Przygotowanie środowiska developerskiego FuelPHP w ServBay

ServBay to dedykowane środowisko lokalne dla programistów webowych, zawierające preinstalowane usługi takie jak PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis oraz wiele innych narzędzi. Dzięki ServBay możesz błyskawicznie uruchomić projekt FuelPHP bez ręcznej instalacji i konfiguracji zależności.

Ten przewodnik szczegółowo opisuje wykorzystanie PHP, Caddy oraz usług bazodanowych i cache ServBay do stworzenia i uruchomienia projektu FuelPHP. Skorzystamy z funkcji strony ServBay do skonfigurowania serwera WWW i uproszczonego dostępu do projektu.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

ServBay jest poprawnie zainstalowany i działa na Twoim macOS.
Środowisko PHP jest aktywne w ServBay (domyślnie aktywne).
Usługi bazy danych (np. MySQL) oraz cache (Redis, Memcached), które planujesz użyć, są uruchomione.
ServBay posiada wbudowany Composer, nie musisz go instalować oddzielnie.

Tworzenie projektu FuelPHP

Rekomendowana lokalizacja projektu

ServBay rekomenduje umieszczanie projektów webowych w katalogu /Applications/ServBay/www — ułatwia to zarządzanie oraz konfigurację. Ten przewodnik korzysta z tego katalogu jako przykładu.

Przejście do katalogu stron
Otwórz Terminal i zmień katalog na rekomendowany przez ServBay dla projektów:
bash
```
cd /Applications/ServBay/www
```
1
Utworzenie folderu projektu
Utwórz nowy katalog dla projektu FuelPHP i przejdź do niego:
bash
```
mkdir servbay-fuelphp-app
cd servbay-fuelphp-app
```
1
2
Inicjalizacja projektu FuelPHP przez Composer
W nowym katalogu uruchom Composer, aby pobrać i zainicjować FuelPHP. Kropka oznacza instalację w bieżącym katalogu:
bash
```
composer create-project fuel/fuel .
```
1
Composer automatycznie pobierze FuelPHP oraz niezbędne zależności do katalogu servbay-fuelphp-app.

Konfiguracja serwera WWW (funkcja strony ServBay)

Aby uzyskać dostęp do projektu FuelPHP przez przeglądarkę, należy użyć funkcji strony ServBay do skonfigurowania wirtualnego hosta.

Otwórz interfejs główny ServBay.
Kliknij menu Strony w bocznej nawigacji.
Naciśnij przycisk Dodaj stronę w prawym górnym rogu.
W oknie konfiguracji podaj:
- Nazwa: np. My First FuelPHP Dev Site, aby łatwo rozpoznać projekt.
- Domena: np. servbay-fuelphp-test.local — ServBay samodzielnie skonfiguruje przekierowanie na lokalny adres.
- Typ strony: wybierz PHP.
- Wersja PHP: np. 8.3.
- Katalog główny strony: wskaż folder wejściowy FuelPHP — plik startowy to public/index.php, więc wskaż katalog public: /Applications/ServBay/www/servbay-fuelphp-app/public.
Zapisz konfigurację klikając Dodaj.

ServBay automatycznie uaktualni konfigurację Caddy i przeładuje usługę, aktywując nową domenę.

Więcej szczegółów znajdziesz w dodawaniu pierwszej strony w dokumentacji ServBay.

Konfiguracja połączenia z usługami w projekcie FuelPHP

Projekt FuelPHP wymaga skonfigurowania połączenia z bazą danych, memcached i/lub Redis.

Konfiguracja bazy danych

Ścieżka do pliku konfiguracyjnego bazy danych to fuel/app/config/development/db.php. Edytuj go, podając dane dostępowe. Przykładowa konfiguracja dla domyślnej bazy MySQL ServBay:

php

<?php
/**
 * The development database settings. These get merged with the global settings.
 */
return [
    'default' => [
        'connection' => [
            'dsn'      => 'mysql:host=localhost;dbname=fuel_dev', // Upewnij się, że baza fuel_dev istnieje
            'username' => 'root', // Domyślny użytkownik MySQL ServBay
            'password' => 'root', // Domyślne hasło MySQL ServBay (tylko do lokalnego developmentu!)
        ],
        'identifier' => '`', // MySQL wymaga apostrofów jako identyfikatorów
    ],
];

Uwaga:

Musisz ręcznie utworzyć bazę danych fuel_dev poprzez narzędzie do zarządzania bazą (np. phpMyAdmin, Adminer). Domyślne dane logowania (root/root) używa się tylko lokalnie.
'identifier' => ''` jest niezbędne dla prawidłowego cytowania nazw tabel i kolumn w MySQL.

Konfiguracja cache (Memcached & Redis)

FuelPHP obsługuje kilka backendów cache. Ustawienia znajdują się w fuel/app/config/cache.php. Upewnij się, że Memcached i/lub Redis są uruchomione w ServBay.

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

php

<?php
return [
    'driver' => 'memcached', // Domyślny driver cache: memcached
    'memcached' => [
        'cache_id' => 'fuel', // Identyfikator cache
        'servers' => [
             'default' => [
                'host'   => '127.0.0.1', // Domyślny adres Memcached
                'port'   => 11211,      // Domyślny port Memcached
                'weight' => 100,
            ],
        ],
        'compression' => false, // Kompresja cache
    ],
    // ... inne konfiguracje cache
];

Wersja PHP w ServBay zwykle jest już wyposażona w rozszerzenie Memcached.

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

php

<?php
return [
    'default' => [
        'hostname' => '127.0.0.1', // Domyślny adres Redis
        'port'     => 6379,      // Domyślny port Redis
        'database' => 0,         // Index bazy Redis
    ],
    // Możesz skonfigurować wiele połączeń Redis
];

ServBay instaluje najczęściej obsługę Redis w PHP z automatu.

Przykłady użycia bazy danych i cache

Poniżej przykłady integracji FuelPHP z bazą danych i cache.

Tworzenie tabeli bazy danych (FuelPHP Migrations)

FuelPHP udostępnia narzędzie Oil do zarządzania migracjami bazy danych.

Stworzenie pliku migracji
W katalogu projektu (servbay-fuelphp-app) wygeneruj migrację dla tabeli users:
bash
```
php oil generate migration create_users_table
```
1
Otrzymasz nowy plik migracji w fuel/app/migrations.

Edycja pliku migracji

W nowym pliku migracji (fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php) zdefiniuj schemat w metodzie up(), a w down() przywracanie:

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'); // Klucz główny, indeksy, engine i charset
    }

    public function down()
    {
        // Usunięcie tabeli 'users'
        DBUtil::drop_table('users');
    }
}

Uruchomienie migracji
W katalogu projektu użyj narzędzia Oil, aby utworzyć tabelę:
bash
```
php oil refine migrate
```
1
Po pomyślnej migracji tabela users pojawi się w bazie fuel_dev.

Przykładowy kod kontrolera

Edytuj fuel/app/classes/controller/welcome.php, dodając metody pokazujące pracę z bazą danych i cache:

php

<?php
use Fuel\Core\Controller;
use Fuel\Core\Response;
use Fuel\Core\Cache;
use Fuel\Core\DB; // Import DB facade
use Fuel\Core\Redis; // Import Redis facade

class Controller_Welcome extends Controller
{
    // Akcja domyślna strony głównej
    public function action_index()
    {
        return Response::forge('Hello ServBay!');
    }

    // Akcja Memcached
    public function action_memcached()
    {
        // Pobranie danych z cache
        $value = Cache::get('servbay_memcached_key');

        if ($value === false) {
            // Brak w cache, ustaw nową wartość
            $value = 'Hello Memcached from ServBay!';
            Cache::set('servbay_memcached_key', $value, 60); // 60 sekund cache
            $value .= ' (from cache)';
        } else {
            $value .= ' (cached)';
        }

        return Response::forge($value);
    }

    // Akcja Redis
    public function action_redis()
    {
        // Pobranie instancji Redis (domyślne połączenie)
        $redis = \Redis_Db::instance();
        // Lub, przy wielu połączeniach: \Redis_Db::instance('connection_name')

        // Ustawienie danych w Redis
        $redis->set('servbay_redis_key', 'Hello Redis from ServBay!');

        // Pobranie danych z Redis
        $value = $redis->get('servbay_redis_key');

        return Response::forge($value);
    }

    // Akcja dodająca użytkownika do MySQL
    public function action_mysql_add()
    {
        try {
            // Wstawienie rekordu do tabeli 'users'
            $result = DB::insert('users')->set([
                'name' => 'ServBay Demo User ' . time(), // Gwarancja unikalności przez timestamp
                'email' => 'demo_user_' . time() . '@servbay.test',
            ])->execute(); // Zwraca tablicę z nowym ID

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

    // Akcja odczytująca użytkowników z MySQL
    public function action_mysql()
    {
        // Pobranie wszystkich rekordów z tabeli 'users'
        $users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();

        // Zwrócenie listy użytkowników w formie JSON
        return Response::forge(json_encode($users, JSON_PRETTY_PRINT));
    }
}

Uwagi:

Skorzystano z fasad DB i Redis (use Fuel\Core\DB;, use Fuel\Core\Redis;) dla wygody.
Klucze Memcached i Redis poprzedzono prefiksem servbay_, aby uniknąć konfliktów.
Wstawianie użytkownika do MySQL korzysta z timestamp oraz prostego mechanizmu obsługi błędów.
Redis w FuelPHP 1.x pobiera się przez \Redis_Db::instance().

Konfiguracja tras

Aby udostępnić nowe akcje w kontrolerze przez URL, dopisz odpowiednie trasy w pliku fuel/app/config/routes.php. Domyślna trasa kieruje na kontroler welcome, ale nowe akcje (memcached, redis, itd.) należy wskazać jawnie.

W pliku fuel/app/config/routes.php dodaj/zmodyfikuj:

php

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

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

    // ... dalsza konfiguracja
);

Dostęp i testowanie strony

Teraz możesz przetestować projekt FuelPHP i jego integrację z usługami pod adresem https://servbay-fuelphp-test.local poprzez przeglądarkę.

Strona domyślna: https://servbay-fuelphp-test.local
- Wynik: Hello ServBay!
Test Memcached: https://servbay-fuelphp-test.local/memcached
- Pierwsze wejście: Hello Memcached from ServBay! (from cache) (jeśli cache działa).
- Kolejne wejścia: Hello Memcached from ServBay! (cached) (jeśli cache działa i nie wygasł).
Test Redis: https://servbay-fuelphp-test.local/redis
- Wynik: Hello Redis from ServBay! (przy poprawnej pracy Redis).
Dodanie użytkownika do MySQL: https://servbay-fuelphp-test.local/mysql_add
- Wynik: User added with ID: [nowe ID] (przy poprawnej pracy bazy i tabeli).
Odczyt listy użytkowników z MySQL: https://servbay-fuelphp-test.local/mysql
- Wynik: tablica JSON z rekordami z tabeli users.

O HTTPS: ServBay domyślnie generuje certyfikat SSL dla lokalnych stron, z użyciem CA użytkownika lub publiczną CA ServBay. Jeśli przeglądarka zgłasza problem z certyfikatem, sprawdź czy zaufałeś CA ServBay na swoim systemie.

Dodatkowe wskazówki

Upewnij się, że w interfejsie ServBay wszystkie usługi (PHP, Caddy/Nginx/Apache, MySQL, Redis, Memcached) są w trybie pracy.
Stwórz ręcznie bazę fuel_dev w narzędziu do zarządzania bazą danych przed uruchomieniem migracji — narzędzie oil refine migrate tworzy tylko tabele.
Publiczny plik wejściowy FuelPHP to public/index.php — konfigurując stronę w ServBay, wybierz jako katalog główny folder public projektu.

Podsumowanie

Dzięki ServBay możesz w prosty sposób uruchomić kompletną platformę developerską dla FuelPHP na macOS. Przewodnik obejmuje: tworzenie projektu, konfigurację strony w ServBay, podłączenie bazy danych i systemów cache, aż po testowanie kodu na konkretnych przykładach. Preinstalowane usługi oraz uproszczona konfiguracja ServBay znacząco przyspieszają pracę programisty.

Mamy nadzieję, że ten poradnik ułatwi Ci start i rozwijanie projektów FuelPHP w ServBay!

Tworzenie i uruchamianie projektów FuelPHP w lokalnym środowisku ServBay ​

Czym jest FuelPHP? ​

Kluczowe cechy i zalety FuelPHP ​

Przygotowanie środowiska developerskiego FuelPHP w ServBay ​

Wymagania wstępne ​

Tworzenie projektu FuelPHP ​

Konfiguracja serwera WWW (funkcja strony ServBay) ​

Konfiguracja połączenia z usługami w projekcie FuelPHP ​

Konfiguracja bazy danych ​

Konfiguracja cache (Memcached & Redis) ​

Przykłady użycia bazy danych i cache ​

Tworzenie tabeli bazy danych (FuelPHP Migrations) ​

Przykładowy kod kontrolera ​

Konfiguracja tras ​

Dostęp i testowanie strony ​

Dodatkowe wskazówki ​

Podsumowanie ​