06.12.2024

Construirea unui API Laravel securizat cu autentificare JWT

Atunci când construiți API-uri cu Laravel, asigurarea unei autentificări sigure este crucială, în special atunci când aveți de-a face cu datele utilizatorilor. JSON Web Tokens (JWT) oferă o metodă robustă de gestionare a autentificării în aplicații fără statel, permițând transmiterea sigură a informațiilor despre utilizator între părți. Acest ghid vă va ghida prin procesul de construire a unui API Laravel sigur folosind autentificarea JWT.

Condiții prealabile

Cunoștințe de bază de PHP și Laravel.
Laravel instalat pe calculatorul dvs. (de preferință Laravel 9 sau mai nou).
Composer instalat.
MySQL sau o altă bază de date configurată pentru aplicația dvs.

Pasul 1: Creați un nou proiect Laravel

În primul rând, creați un nou proiect Laravel utilizând Composer:

composer create-project laravel/laravel laravel-jwt-api

Navigați la directorul proiectului dvs:

cd laravel-jwt-api

Pasul 2: Instalarea pachetului de autentificare JWT

Cel mai frecvent utilizat pachet pentru autentificarea JWT în Laravel este

tymon/jwt-auth

. Instalați-l folosind Composer:

composer require tymon/jwt-auth

După instalarea pachetului, publicați configurația JWT:

php artisan vendor:publish --provider="Tymon\JWTAuth\Providers\LaravelServiceProvider"

Acest lucru va crea un fișier

config/jwt.php

în proiectul dvs.

Pasul 3: Generarea cheii secrete JWT

Generați o cheie secretă pe care JWT o va utiliza pentru semnarea jetoanelor:

php artisan jwt:secret

Aceasta va adăuga o intrare

JWT_SECRET

la fișierul

.env

, care este utilizată pentru codificarea și decodificarea jetoanelor.

Pasul 4: Configurați autentificarea

Pentru a configura autentificarea JWT, trebuie să configurați paza implicită pentru API-ul dvs. Actualizați fișierul

config/auth.php

după cum urmează:

'defaults' => [
 'guard' => 'api',
 'passwords' => 'users',

],‘guards’ => [
‘api’ => [
‘driver’ => ‘jwt’,
‘provider’ => ‘users’,
],
],

Acest lucru îi spune lui Laravel să utilizeze driverul

jwt

pentru cererile API și să se autentifice cu furnizorul

users

Pasul 5: Crearea modelului de utilizator și a migrației

Dacă nu ați creat încă un model de

utilizator

, îl puteți crea împreună cu fișierul său de migrare:

php artisan make:model User -m

Deschideți fișierul de migrare generat în

database/migrations/

și adăugați câmpurile necesare, precum

numele

e-mailul

și

parola

public function up()
 {
 Schema::create('users', function (Blueprint $table) {
 $table->id();
 $table->string('nume');
 $table->string('email')->unique();
 $table->string('parola');
 $table->timestamps();
 });
 }

Rulați migrarea pentru a crea tabelul de

utilizatori

php artisan migrate

Pasul 6: Implementarea metodelor JWT în modelul utilizatorului

În modelul

User

(app/Models/User.php

), implementați interfața

JWTSubject

și metodele necesare:

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 [];
}
}

Pasul 7: Crearea controlorilor de autentificare

Creați un controler pentru gestionarea autentificării utilizatorilor:

php artisan make:controller AuthController

În

AuthController.php

, adăugați metode pentru înregistrarea unui utilizator, conectarea și deconectarea:

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,
‘password’ => Hash::make($request->password),
]);$token = JWTAuth::fromUser($user);

return response()->json([‘token’ => $token], 201);
}

public function login(Cerere $request)
{
$credentials = $request->only(’email’, ‘password’);

dacă (!$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’ => ‘Successfully logged out’]);
}

public function me()
{
return response()->json(Auth::user());
}
}

Pasul 8: Definirea rutelor API

Adăugați rute pentru autentificare în

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’);

Aceste rute gestionează înregistrarea utilizatorului, autentificarea, deconectarea și preluarea utilizatorului autentificat.

Pasul 9: Protejarea rutelor API

Pentru a proteja alte rute API, puteți utiliza middleware-ul

auth:api

. De exemplu, dacă aveți o rută de resurse pentru

mesaje

Route::middleware('auth:api')->group(function () {
 Route::resource('posts', PostController::class);
 });

Acest lucru asigură faptul că numai utilizatorii autentificați pot accesa aceste rute.

Pasul 10: Testarea API-ului

Puteți testa API-ul utilizând instrumente precum Postman sau cURL.

Înregistrați un utilizator:
POST /api/register Content-Type: application/json{
“name”: “John Doe”,
“email”: “john@example.com”,
“parola”: “parola”,
“password_confirmation”: “parolă”
}
Log in:
POST /api/login Content-Type: application/json{
“email”: “john@example.com”,
“parola”: “parola”
}
Aceasta va returna un token pe care îl puteți utiliza pentru a autentifica alte cereri.
Accesați ruta protejată: Pentru a accesa o rută protejată precum
GET /api/me
, includeți simbolul în antetul
Authorization
:
Authorization: Bearer

Pasul 11: Actualizarea jetoanelor JWT (opțional)

Pentru a actualiza un jeton, puteți adăuga o metodă în

AuthController

public function refresh()
 {
 $token = Auth::refresh();
 return response()->json(['token' => $token]);
 }

Adăugați ruta pentru reîmprospătare:

Route::post('refresh', [AuthController::class, 'refresh'])->middleware('auth:api');

Concluzii

Urmând acest ghid, ați construit un API Laravel sigur cu autentificare JWT, permițând înregistrarea utilizatorilor, autentificarea și accesul la rute protejate. JWT vă permite să mențineți un mecanism de autentificare fără statel, care este deosebit de util pentru scalarea API-urilor. Cu această configurare, puteți personaliza în continuare logica de autentificare a aplicației dvs. și puteți integra caracteristici suplimentare, cum ar fi controlul accesului bazat pe roluri și token-uri de reîmprospătare pentru sesiuni de lungă durată.