06.12.2024

Construire une API Laravel sécurisée avec l’authentification JWT

Lors de la création d’API avec Laravel, il est essentiel d’assurer une authentification sécurisée, en particulier lorsqu’il s’agit de données utilisateur. Les jetons Web JSON (JWT) offrent une méthode robuste pour gérer l’authentification dans les applications sans état, permettant une transmission sécurisée des informations utilisateur entre les parties. Ce guide vous guidera à travers le processus de construction d’une API Laravel sécurisée à l’aide de l’authentification JWT.

Conditions préalables

Connaissance de base de PHP et de Laravel.
Laravel installé sur votre machine (de préférence Laravel 9 ou plus récent).
Composer installé.
MySQL ou une autre base de données configurée pour votre application.

Étape 1 : Créer un nouveau projet Laravel

Tout d’abord, créez un nouveau projet Laravel à l’aide de Composer :

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

Naviguez jusqu’au répertoire de votre projet :

cd laravel-jwt-api

Étape 2 : Installer le paquetage d’authentification JWT

Le paquetage le plus utilisé pour l’authentification JWT dans Laravel est

tymon/jwt-auth

. Installez-le en utilisant Composer :

composer require tymon/jwt-auth

Après l’installation du paquet, publiez la configuration JWT :

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

Cela créera un fichier

config/jwt.php

dans votre projet.

Étape 3 : Générer la clé secrète JWT

Générer une clé secrète que JWT utilisera pour signer les jetons :

php artisan jwt:secret

Ceci ajoutera une entrée

JWT_SECRET

à votre fichier

.env

, qui sera utilisée pour encoder et décoder les jetons.

Étape 4 : Configurer l’authentification

Pour mettre en place l’authentification JWT, vous devez configurer le gardien par défaut de votre API. Mettez à jour le fichier

config/auth.php

comme suit :

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

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

Cela indique à Laravel d’utiliser le pilote

jwt

pour les demandes d’API et de s’authentifier auprès du fournisseur

users

Etape 5 : Créer le modèle d’utilisateur et la migration

Si vous n’avez pas encore créé de modèle d’

utilisateur

, vous pouvez le faire avec son fichier de migration :

php artisan make:model User -m

Ouvrez le fichier de migration généré dans

database/migrations/

et ajoutez les champs nécessaires, tels que le

nom

, l’

email

et le

mot de passe

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

Exécutez la migration pour créer la table

users

php artisan migrate

Étape 6 : Implémenter les méthodes JWT dans le modèle utilisateur

Dans le modèle

Utilisateur

(app/Models/User.php

), implémentez l’interface

JWTSubject

et les méthodes requises :

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

Étape 7 : Créer des contrôleurs d’authentification

Créez un contrôleur pour gérer l’authentification des utilisateurs :

php artisan make:controller AuthController

Dans

AuthController.php

, ajoutez des méthodes pour enregistrer un utilisateur, se connecter et se déconnecter :

use App\Models\User;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 utilisation de 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([
‘nom’ => $request->nom,
’email’ => $request->email,
‘password’ => 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’ => ‘Successfully logged out’]) ;
}

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

Étape 8 : Définir les routes API

Ajoutez des routes pour l’authentification dans

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

Ces routes gèrent l’enregistrement de l’utilisateur, la connexion, la déconnexion et la récupération de l’utilisateur authentifié.

Étape 9 : Protection des routes API

Pour protéger d’autres routes d’API, vous pouvez utiliser l’intergiciel

auth:api

. Par exemple, si vous avez une route de ressources pour les

messages

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

Cela garantit que seuls les utilisateurs authentifiés peuvent accéder à ces routes.

Étape 10 : Tester l’API

Vous pouvez tester votre API à l’aide d’outils tels que Postman ou cURL.

Enregistrez un utilisateur:
POST /api/register Content-Type : application/json{
“name” : “John Doe”,
“email” : “john@example.com”,
“password” : “password”,
“password_confirmation” : “password”
}
Se connecter:
POST /api/login Content-Type : application/json{
“email” : “john@example.com”,
“password” : “password”
}
Cela renverra un jeton que vous pourrez utiliser pour authentifier d’autres requêtes.
Accès à une route protégée : Pour accéder à une route protégée comme
GET /api/me
, incluez le jeton dans l’en-tête
Authorization
:
Authorization : Bearer

Étape 11 : Actualisation des jetons JWT (facultatif)

Pour rafraîchir un jeton, vous pouvez ajouter une méthode dans

AuthController

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

Ajouter la route pour le rafraîchissement :

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

Conclusion

En suivant ce guide, vous avez construit une API Laravel sécurisée avec l’authentification JWT, permettant l’enregistrement des utilisateurs, la connexion et l’accès aux routes protégées. JWT vous permet de maintenir un mécanisme d’authentification sans état, ce qui est particulièrement utile pour les API évolutives. Avec cette configuration, vous pouvez personnaliser davantage la logique d’authentification de votre application et intégrer des fonctionnalités supplémentaires, telles que le contrôle d’accès basé sur les rôles et les jetons de rafraîchissement pour les sessions de longue durée.