Tworzenie bezpiecznego interfejsu API Laravel z uwierzytelnianiem JWT
Podczas tworzenia interfejsów API za pomocą Laravel, zapewnienie bezpiecznego uwierzytelniania ma kluczowe znaczenie, zwłaszcza gdy mamy do czynienia z danymi użytkownika. JSON Web Tokens (JWT) oferują solidną metodę obsługi uwierzytelniania w aplikacjach bezstanowych, umożliwiając bezpieczną transmisję informacji o użytkowniku między stronami. Ten przewodnik przeprowadzi Cię przez proces tworzenia bezpiecznego interfejsu API Laravel przy użyciu uwierzytelniania JWT.
Wymagania wstępne
- Podstawowa znajomość PHP i Laravel.
- Laravel zainstalowany na komputerze (najlepiej Laravel 9 lub nowszy).
- Zainstalowany Composer.
- MySQL lub inna baza danych skonfigurowana dla aplikacji.
Krok 1: Utwórz nowy projekt Laravel
Najpierw utwórz nowy projekt Laravel za pomocą Composera:
composer create-project laravel/laravel laravel-jwt-api
Przejdź do katalogu projektu:
cd laravel-jwt-api
Krok 2: Instalacja pakietu uwierzytelniania JWT
Najczęściej używanym pakietem do uwierzytelniania JWT w Laravel jest tymon/jwt-auth. Zainstaluj go za pomocą Composera:
composer require tymon/jwt-auth
Po instalacji pakietu opublikuj konfigurację JWT:
php artisan vendor:publish --provider="Tymon\JWTAuth\Providers\LaravelServiceProvider"
Spowoduje to utworzenie pliku config/jwt. php w projekcie.
Krok 3: Generowanie tajnego klucza JWT
Wygeneruj tajny klucz, którego JWT będzie używać do podpisywania tokenów:
php artisan jwt:secret
Spowoduje to dodanie wpisu JWT_SECRET do pliku .env, który jest używany do kodowania i dekodowania tokenów.
Krok 4: Konfiguracja uwierzytelniania
Aby skonfigurować uwierzytelnianie JWT, należy skonfigurować domyślnego strażnika dla interfejsu API. Zaktualizuj plik config/auth. php w następujący sposób:
'defaults' => [
'guard' => 'api',
'passwords' => 'users',
],
'guards' => [
'api' => [
'driver' => 'jwt',
'provider' => 'users',
],
],Krok 5: Utwórz model użytkownika i migrację
Jeśli model użytkownika nie został jeszcze utworzony, można go utworzyć wraz z plikiem migracji:
php artisan make:model User -m
Otwórz wygenerowany plik migracji w database/migrations/ i dodaj niezbędne pola, takie jak imię i nazwisko, adres e-mail i hasło:
public function up()
{
Schema::create('users', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('email')->unique();
$table->string('password');
$table->timestamps();
});
}
Uruchom migrację, aby utworzyć tabelę użytkowników:
php artisan migrate
Krok 6: Wdrożenie metod JWT w modelu użytkownika
W modelu użytkownika(app/Models/User.php) zaimplementuj interfejs JWTSubject i wymagane metody:
use Tymon\JWTAuth\Contracts\JWTSubject;
use Illuminate\Foundation\Auth\User as Authenticatable;
class User extends Authenticatable implements JWTSubject
{
public function getJWTIdentifier()
{
return $this->getKey(); // Zwykle klucz główny (id)
}
public function getJWTCustomClaims()
{
return [];
}
}Krok 7: Tworzenie kontrolerów uwierzytelniania
Utwórz kontroler do obsługi uwierzytelniania użytkowników:
php artisan make:controller AuthController
W pliku AuthController.php dodaj metody rejestracji użytkownika, logowania i wylogowywania:
'name' => 'required|string|max:255',
'email' => 'required|string|email|max:255|unique:users',
'password' => 'required|string|min:6|confirmed',
]);
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'hasło' => Hash::make($request->password),
]);
$token = JWTAuth::fromUser($user);
return response()->json(['token' => $token], 201);
}
// Logowanie użytkownika
public function login(Request $request)
{
$credentials = $request->only('email', 'password');
if (!$token = Auth::attempt($credentials)) {
return response()->json(['error' => 'Invalid credentials'], 401);
}
return response()->json(['token' => $token]);
}
// Wylogowanie użytkownika (Nieprawidłowy token)
public function logout()
{
Auth::logout();
return response()->json(['message' => 'Pomyślnie wylogowano']);
}
// Pobierz uwierzytelnionego użytkownika
public function me()
{
return response()->json(Auth::user());
}
}Krok 8: Definiowanie tras API
Dodaj trasy uwierzytelniania w pliku routes/api.php:
use App\Http\Controllers\AuthController;
use Illuminate\Support\Facades\Route;
Route::post('register', [AuthController::class, 'register']);
Route::post('login', [AuthController::class, 'login']);
// Chronione trasy (wymagają tokena JWT)
Route::middleware('auth:api')->group(function () {
Route::post('logout', [AuthController::class, 'logout']);
Route::get('me', [AuthController::class, 'me']);
});Te trasy obsługują rejestrację użytkownika, logowanie, wylogowanie i pobieranie uwierzytelnionego użytkownika.
Krok 9: Ochrona tras API
Aby chronić inne trasy API, można użyć oprogramowania pośredniczącego auth:api. Na przykład, jeśli masz trasę zasobów dla postów:
Route::middleware('auth:api')->group(function () {
Route::resource('posts', PostController::class);
});
Zapewnia to, że tylko uwierzytelnieni użytkownicy mogą uzyskać dostęp do tych tras.
Krok 10: Testowanie API
Możesz przetestować swój interfejs API za pomocą narzędzi takich jak Postman lub cURL.
- Zarejestruj użytkownika:
POST /api/register
Host: your-domain.com
Content-Type: application/json
{
"name": "John Doe",
"email": "john@example.com",
"password": "password",
"password_confirmation": "password"
} - Zaloguj się:
POST /api/login
Host: your-domain.com
Content-Type: application/json
{
"email": "john@example.com",
"password": "password"
}Zwróci to token, którego można użyć do uwierzytelnienia innych żądań. - Dostęp do chronionej trasy: Aby uzyskać dostęp do chronionej trasy, takiej jak GET /api/me, należy dołączyć token w nagłówku Authorization:
Authorization: Bearer
Krok 11: Odświeżanie tokenów JWT (opcjonalnie)
Aby odświeżyć token, możesz dodać metodę w AuthController:
public function refresh()
{
$token = Auth::refresh();
return response()->json(['token' => $token]);
}Dodaj trasę odświeżania:
Route::post('refresh', [AuthController::class, 'refresh'])->middleware('auth:api');
Wnioski
Postępując zgodnie z tym przewodnikiem, zbudowałeś bezpieczny interfejs API Laravel z uwierzytelnianiem JWT, umożliwiając rejestrację użytkowników, logowanie i dostęp do chronionych tras. JWT pozwala na utrzymanie bezstanowego mechanizmu uwierzytelniania, co jest szczególnie przydatne przy skalowaniu API. Dzięki tej konfiguracji można jeszcze bardziej dostosować logikę uwierzytelniania aplikacji i zintegrować dodatkowe funkcje, takie jak kontrola dostępu oparta na rolach i tokeny odświeżania dla długotrwałych sesji.
