Tworzenie i uruchamianie projektu Slim w ServBay

Ten artykuł przeprowadzi Cię krok po kroku przez proces szybkiego tworzenia, konfiguracji i uruchamiania projektu opartego o Slim Framework PHP w potężnym lokalnym środowisku Web ServBay. ServBay oferuje zintegrowane pakiety PHP, serwery WWW (Caddy/Nginx/Apache) oraz bogaty wybór baz danych, co czyni go idealną platformą do rozwoju aplikacji Slim.

Czym jest Slim?

Slim to lekki mikroframework PHP stworzony z myślą o szybkim budowaniu prostych, lecz potężnych aplikacji webowych oraz API. Zapewnia kluczowe funkcje routingu, obsługi żądań i odpowiedzi, idealnie nadając się do projektów wymagających szybkiego rozwoju i wdrożenia, lub jako baza dla bardziej złożonych rozwiązań.

Główne cechy i zalety Slim

Lekkość: Slim cechuje się niewielkim rdzeniem, niskim zużyciem zasobów i szybkim startem. Doskonale sprawdza się przy tworzeniu małych i średnich aplikacji czy mikrousług.
Elastyczność: Architektura Slim jest modularna i pozwala z łatwością integrować dowolne biblioteki zewnętrzne (np. silniki szablonów, ORM, narzędzia do autoryzacji), co daje swobodę wyboru narzędzi odpowiednich dla danego projektu.
Łatwość użycia: Dzięki przejrzystemu API i dobrej dokumentacji, deweloperzy szybko przyswajają podstawy frameworka i mogą sprawnie rozpocząć pracę.
Zaawansowany routing: Obsługuje różne metody HTTP (GET, POST, PUT, DELETE itd.) oraz złożone konfiguracje tras, w tym grupowanie tras, middleware oraz przechwytywanie parametrów.
Wsparcie middleware: Warstwa middleware pozwala na wykonanie różnych operacji przed logiką aplikacji lub przed wysłaniem odpowiedzi, np. autoryzacja, logowanie, obsługa CORS itp.

Slim świetnie nadaje się do budowy RESTful API, tworzenia prototypów oraz realizacji pojedynczych, odseparowanych funkcjonalności.

Tworzenie i uruchamianie projektu Slim w ServBay

W tym przewodniku posłużymy się gotowym środowiskiem PHP oraz funkcją Strony w ServBay do konfiguracji serwera WWW i prostego udostępnienia projektu Slim.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

ServBay jest zainstalowany i uruchomiony: Upewnij się, że ServBay jest poprawnie zainstalowany na Twoim Macu z systemem macOS oraz że aplikacja działa.
Composer jest już w ServBay: ServBay domyślnie integruje Composer, więc nie musisz instalować go osobno.

Tworzenie projektu Slim

Zaleca się przechowywanie wszystkich projektów webowych w katalogu /Applications/ServBay/www, co ułatwia zarządzanie i konfigurację przez ServBay.

Przejdź do katalogu głównego serwisów ServBay:
bash
```
cd /Applications/ServBay/www
```
1
Utwórz katalog projektu: Stwórz nowy folder na potrzeby projektu Slim.
bash
```
mkdir servbay-slim-app
```
1
Wejdź do katalogu projektu:
bash
```
cd servbay-slim-app
```
1
Zainstaluj Slim przez Composer: W katalogu projektu użyj Composera do instalacji Slim Framework oraz implementacji PSR-7.
bash
```
composer require slim/slim "^4.0" slim/psr7 -W
```
1
To polecenie pobierze framework Slim oraz bibliotekę slim/psr7 do katalogu vendor w projekcie i stworzy pliki composer.json oraz composer.lock.

Inicjalizacja aplikacji Slim

Utwórz plik wejściowy: Slim zwykle korzysta z pojedynczego pliku wejściowego (np. public/index.php) do obsługi wszystkich żądań. Utwórz katalog public i w nim plik index.php.
bash
```
mkdir public
touch public/index.php
```
1
2

Edytuj plik wejściowy: Otwórz public/index.php i dodaj poniższy bazowy kod aplikacji Slim:

php

<?php
// Ładuj plik autoload Composera
require __DIR__ . '/../vendor/autoload.php';

// Importuj wymagane interfejsy PSR-7 oraz 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 prostą trasę obsługującą zapytania GET do korzenia '/'
$app->get('/', function (Request $request, Response $response, $args) {
    // Zapisz treść do odpowiedzi
    $response->getBody()->write("Hello ServBay!");
    // Zwróć obiekt odpowiedzi
    return $response;
});

// Uruchom aplikację Slim
$app->run();

Ten kod tworzy najprostszą możliwą aplikację Slim z trasą obsługującą żądania GET do głównego adresu (/) i zwracającą tekst "Hello ServBay!".

Konfiguracja strony w ServBay

Aby uzyskać dostęp do aplikacji Slim przez przeglądarkę, skonfiguruj nową stronę w ServBay (w starszych wersjach była to "host").

Otwórz interfejs aplikacji ServBay.
Przejdź do modułu Strony (Websites).
Kliknij przycisk dodawania nowej strony.
Wprowadź dane konfiguracyjne zgodnie z Twoim projektem:
- Nazwa: My First Slim Dev Site (lub inna dowolna)
- Domena: servbay-slim-test.local (zalecamy końcówki .local lub .test do zastosowań lokalnych)
- Typ strony: PHP
- Wersja PHP: wybierz wymaganą wersję, np. 8.3
- Katalog źródłowy strony: wskaż katalog public Twojego projektu, np. /Applications/ServBay/www/servbay-slim-app/public. To istotne, bo plik wejściowy index.php Slima znajduje się właśnie w tym katalogu.
Zapisz konfigurację strony. ServBay automatycznie odświeży ustawienia serwera WWW i wprowadzi zmiany.

Szczegółowe instrukcje znajdziesz w temacie Dodawanie pierwszej strony.

Odwiedzanie Twojej strony Slim

Po tej konfiguracji otwórz przeglądarkę i przejdź pod adres https://servbay-slim-test.local.

Jeśli wszystko poszło dobrze, zobaczysz na stronie napis Hello ServBay!. To oznacza, że Twój projekt Slim działa poprawnie przez serwer ServBay.

Przykłady integracji z bazami danych

Sam Slim nie posiada warstwy ORM, jednak pozwala z łatwością korzystać z dowolnych bibliotek do obsługi baz danych. Jako przykład zaintegrujemy Eloquent ORM Laravel (poprzez komponent illuminate/database), pokażemy łączenie z MySQL i PostgreSQL oraz przykładową integrację z Memcached i Redis.

Wymagania: Utworzenie bazy danych i migracje

Przed integracją upewnij się, że baza danych została utworzona w ServBay oraz przygotowane są odpowiednie struktury tabel.

Stwórz bazę danych:
- W interfejsie ServBay przejdź do wybranego pakietu bazodanowego (np. MySQL lub PostgreSQL).
- Skorzystaj z narzędzi dostępnych w ServBay (phpMyAdmin dla MySQL/MariaDB, pgAdmin dla PostgreSQL) lub klienta CLI, by utworzyć nową bazę, np. servbay_slim_app.
- Domyślne hasło użytkownika root do bazy to zazwyczaj password (możesz je sprawdzić lub zmienić w interfejsie ServBay).

Instalacja i konfiguracja Phinx (narzędzie migracji): Phinx to popularne narzędzie do migracji struktury baz danych w PHP.

W katalogu projektu /Applications/ServBay/www/servbay-slim-app zainstaluj Phinx:
bash
```
composer require robmorgan/phinx
```
1

Zainicjuj konfigurację Phinx:

bash

vendor/bin/phinx init

W katalogu głównym projektu pojawi się plik phinx.yml. Edytuj go, by ustawić połączenie z Twoją bazą, np.:

yaml

paths:
    migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
    seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'

environments:
    default_migration_table: phinxlog
    default_environment: development # lub nazwa środowiska

    development: # ustawienia zgodnie z bazą
        adapter: mysql # lub pgsql
        host: 127.0.0.1
        name: servbay_slim_app # nazwa bazy danych
        user: root
        pass: password # hasło bazy
        port: 3306 # domyślnie MySQL; PostgreSQL używa 5432
        charset: utf8mb4 # rekomendowane dla MySQL
        collation: utf8mb4_unicode_ci # rekomendowane dla MySQL

version_order: creation

Utwórz plik migracji: Utwórz migrację za pomocą Phinx:

bash

vendor/bin/phinx create CreateUsersTable

W katalogu db/migrations pojawi się nowy plik PHP. Otwórz go i w metodzie change() zdefiniuj strukturę tabeli users:

php

<?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();
    }
}

Wykonaj migracje: W katalogu projektu uruchom Phinx, by utworzyć tabelę users.
bash
```
vendor/bin/phinx migrate
```
1
WAŻNE: Przed uruchomieniem poniższych przykładów kodu bazodanowego koniecznie wykonaj migracje!

Użycie komponentu illuminate/database

Do obsługi bazy SQL użyjemy kompozycji Laravel - illuminate/database (Eloquent ORM lub Query Builder).

Instalacja illuminate/database: W głównym katalogu projektu /Applications/ServBay/www/servbay-slim-app:
bash
```
composer require illuminate/database
```
1

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

php

// ... inne require i use ...

use Illuminate\Database\Capsule\Manager as Capsule; // Import Capsule Manager

// Inicjalizacja Eloquent ORM
$capsule = new Capsule;

// Dodaj konfigurację połączenia z bazą (dostosuj driver i opcje)
$capsule->addConnection([
    'driver' => 'mysql', // lub 'pgsql'
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app', // nazwa Twojej bazy
    'username' => 'root', // użytkownik bazy
    'password' => 'password', // hasło bazy
    'charset' => 'utf8mb4', // dla MySQL
    'collation' => 'utf8mb4_unicode_ci', // dla MySQL
    'prefix' => '',
    // dla PostgreSQL potrzebny parametr schema
    // 'schema' => 'public',
]);

// Ustaw dostępność globalną
$capsule->setAsGlobal();

// Włącz Eloquent ORM
$capsule->bootEloquent();

// ... dalej tworzenie instancji Slim ...

Przykład z MySQL

Załóżmy, że MySQL działa w ServBay, baza servbay_slim_app została utworzona, a migracje zakończone sukcesem.

W pliku public/index.php, przed $app->run();, dodaj poniższe trasy:

php

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

use Illuminate\Database\Capsule\Manager as Capsule; // Sprawdź import

// 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', // Zapewnij unikalność e-maila
            '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); // Zwrot kodu błędu
    }
    return $response;
});

// Trasa pobierająca listę 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()); // Zwraca wynik jako JSON
        $response = $response->withHeader('Content-Type', 'application/json'); // Ustawia Content-Type
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

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

Odwiedź:

https://servbay-slim-test.local/mysql-add-user doda nowego użytkownika do users.
https://servbay-slim-test.local/mysql-get-users pobierze listę użytkowników jako JSON.

Przykład z PostgreSQL

Załóżmy, że PostgreSQL działa, masz utworzoną bazę servbay_slim_app i wykonałeś migracje (adapter i port w Phinx: pgsql i 5432).

W pliku public/index.php zmień konfigurację połączenia – ustaw driver na pgsql i dodaj schema:

php

$capsule->addConnection([
    'driver' => 'pgsql', // ustaw na pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // PostgreSQL najczęściej
    'prefix' => '',
    'schema' => 'public', // przeważnie domyślny schema
]);
// ... pozostała inicjalizacja Eloquent bez zmian ...

Dodaj poniższe trasy przed $app->run();:

php

// ... wcześniejsza inicjalizacja i trasa '/' ...
// ... trasy MySQL (jeśli potrzeba) ...

use Illuminate\Database\Capsule\Manager as Capsule; // Sprawdź import

// Trasa POSTGRESQL dodająca użytkownika
$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', // Zapewnij unikalność e-maila
            '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
$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();

Odwiedź:

https://servbay-slim-test.local/pgsql-add-user – doda użytkownika do tabeli users.
https://servbay-slim-test.local/pgsql-get-users – pobierz wszystkich użytkowników jako JSON.

Przykład z Memcached

ServBay udostępnia pakiet Memcached oraz rozszerzenie PHP ext-memcached. Wystarczy zainstalować klienta PHP. Skorzystaj z memcached/memcached.

Instalacja klienta Memcached: W katalogu projektu:
bash
```
composer require memcached/memcached
```
1

Dodanie trasy Memcached w public/index.php: Przed $app->run(); wklej poniższy kod:

php

// ... wcześniejsza inicjalizacja i trasy ...

// Trasa demonstrująca użycie Memcached
$app->get('/memcached-example', function (Request $request, Response $response, $args) {
    // Stwórz instancję klienta
    $memcached = new Memcached();
    // Dodaj serwer Memcached (domyślnie ServBay: 127.0.0.1:11211)
    $memcached->addServer('127.0.0.1', 11211);

    $cacheKey = 'my_servbay_cache_key';
    // Spróbuj pobrać z cache
    $cachedData = $memcached->get($cacheKey);

    if ($cachedData === false) {
        // Nie znaleziono w cache, zapisujemy nowe dane
        $cachedData = 'Hello Memcached from ServBay! This was not cached.';
        // Dane do cache na 60 sekund
        $memcached->set($cacheKey, $cachedData, 60);
        $response->getBody()->write($cachedData);
    } else {
        // Dane już są w cache
        $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
    }

    return $response;
});

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

Odwiedź: https://servbay-slim-test.local/memcached-example. Za pierwszym razem zobaczysz "This was not cached.", przy kolejnych (dopóki cache nie wygasł) – "This was served from cache."

Przykład z Redis

ServBay udostępnia Redis oraz rozszerzenie PHP ext-redis. Wystarczy dodać klienta PHP, np. predis/predis.

Instalacja klienta Redis: W katalogu projektu:
bash
```
composer require predis/predis
```
1

Dodanie trasy Redis w public/index.php: Wklej poniższy kod tuż przed $app->run();:

php

// ... wcześniejsza inicjalizacja i trasy ...
// ... trasa Memcached (jeśli potrzeba) ...

use Predis\Client as RedisClient; // Import Predis

// Trasa demonstrująca użycie Redis
$app->get('/redis-example', function (Request $request, Response $response, $args) {
    try {
        // Klient Redis (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';
        // Sprawdź dane w cache
        $cachedData = $redis->get($cacheKey);

        if ($cachedData === null) {
            // Brak w cache, generujemy i zapisujemy
            $cachedData = 'Hello Redis from ServBay! This was not cached.';
            // Zapis do cache z czasem życia 60s
            $redis->setex($cacheKey, 60, $cachedData); // SETEX key sekundy wartość
            $response->getBody()->write($cachedData);
        } else {
            // Dane już są w cache
            $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
        }
    } catch (\Exception $e) {
        // Obsługa błędów połączenia lub operacji
        $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }

    return $response;
});

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

Odwiedź: https://servbay-slim-test.local/redis-example. Za pierwszym razem zobaczysz "This was not cached.", następnie (do wygaśnięcia cache) – "This was served from cache."

Podsumowanie

Stosując powyższe kroki, utworzyłeś od podstaw projekt Slim Framework w środowisku ServBay oraz skonfigurowałeś funkcję Strony do jego hostowania i obsługi. Dodatkowo nauczyłeś się integrować oferowane przez ServBay pakiety (MySQL, PostgreSQL, Memcached, Redis) i powiązane rozszerzenia PHP, dzięki czemu możesz podłączyć bazę lub cache do swojej aplikacji Slim. ServBay upraszcza budowę i zarządzanie środowiskiem programistycznym, pozwalając Ci skupić się na rozwoju samej aplikacji.

Tworzenie i uruchamianie projektu Slim w ServBay ​

Czym jest Slim? ​

Główne cechy i zalety Slim ​

Tworzenie i uruchamianie projektu Slim w ServBay ​

Wymagania wstępne ​

Tworzenie projektu Slim ​

Inicjalizacja aplikacji Slim ​

Konfiguracja strony w ServBay ​

Odwiedzanie Twojej strony Slim ​

Przykłady integracji z bazami danych ​

Wymagania: Utworzenie bazy danych i migracje ​

Użycie komponentu illuminate/database ​

Przykład z MySQL ​

Przykład z PostgreSQL ​

Przykład z Memcached ​

Przykład z Redis ​

Podsumowanie ​

Tworzenie i uruchamianie projektu Slim w ServBay

Czym jest Slim?

Główne cechy i zalety Slim

Tworzenie i uruchamianie projektu Slim w ServBay

Wymagania wstępne

Tworzenie projektu Slim

Inicjalizacja aplikacji Slim

Konfiguracja strony w ServBay

Odwiedzanie Twojej strony Slim

Przykłady integracji z bazami danych

Wymagania: Utworzenie bazy danych i migracje

Użycie komponentu illuminate/database

Przykład z MySQL

Przykład z PostgreSQL

Przykład z Memcached

Przykład z Redis

Podsumowanie