06.12.2024

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’,
],
],

To mówi Laravelowi, aby używał sterownika

jwt

do żądań API i uwierzytelniał się w oparciu o dostawcę

użytkowników

Krok 5: Tworzenie modelu użytkownika i migracja

Jeśli nie utworzyłeś jeszcze modelu

użytkownika

, możesz 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

nazwa

adres e-mail

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

use App\Models\User;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Hash;
 use Tymon\JWTAuth\Facades\JWTAuth;

class AuthController extends Controller
{
public function register(Request $request)
{
$request->validate([
‘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);
}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]);
}

public function logout()
{
Auth::logout();

return response()->json([‘message’ => ‘Pomyślnie wylogowano’]);
}

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;

Route::post(‘register’,[AuthController::class, ‘register’]);
Route::post(‘login’,[AuthController::class, ‘login’]);
Route::post(‘logout’,[AuthController::class, ‘logout’])->middleware(‘auth:api’);
Route::get(‘me’,[AuthController::class, ‘me’])->middleware(‘auth:api’);

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 Content-Type: application/json{
“name”: “John Doe”,
“email”: “john@example.com”,
“password”: “password”,
“password_confirmation”: “password”
}
Zaloguj się:
POST /api/login Content-Type: application/json{
“email”: “john@example.com”,
“password”: “hasło”
}
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żna 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.