Aller au contenu

Comment créer un système authentification api avec Laravel 8

  1. Comment créer une application web/api avec Laravel 8
  2. Comment créer une application CRUD REST API avec Laravel
  3. Comment créer un système authentification api avec Laravel 8
  4. Comment protéger vos ressources api avec Laravel 8

Dans cet article nous allons continuer notre série des articles sur Laravel 8. Dans nos precedents articles on a vu comment installer et configurer Laravel 8 dans une machine de Windows et comment créer une application CRUD api. Pour commencer, ouvrer votre application que nous avons crée dans notre precedent tutoriel et ouvrer votre terminal et naviguer dans le dossier de votre application.

Par défaut, lorsque une application est crée avec Laravel, le modèle de l’utilisateur est automatiquement crée. Pour verifier aller dans le dossier app\Models\, vous trouverez un fichier appeler User.php et un autre fichier de migration dans le dossier app\database\migrations et remplacer le code qui est dans la méthode up avec le code ci-dessous

    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('first_name');
            $table->string('last_name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

Vous voyez dans ce code ci-haut, nous avons ajoute deux extra fields dont le first_name et last_name. puis retourner dans votre terminal pour recréer les tables de la base des données

Installation de Laravel Sanctum

Direct de la definition de Sanctum a partir de Laravel documentation, Laravel Sanctum fournit un système d’authentification ultra-léger pour les SPA (applications à page unique), les applications mobiles et les API simples basées sur des jetons. Sanctum permet à chaque utilisateur de votre application de générer plusieurs jetons API pour son compte. Ces jetons peuvent se voir attribuer des capacités / portées qui spécifient quelles actions les jetons sont autorisés à effectuer.

Pour installer Laravel Sanctum, aller dans votre terminale et taper la commande suivante

composer require laravel/sanctum 

Puis publier le dans le dossier provider de Laravel en tapant la commande suivante dans votre terminale.

php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider" 

Puis aller dans le dossier app\Models et ajouter cette code use Laravel\Sanctum\HasApiTokens; ci-dessous en bas de la ligne use Illuminate\Notifications\Notifiable; comme dans le code ci-dessous

use Illuminate\Notifications\Notifiable; 
use Laravel\Sanctum\HasApiTokens; 

Apres avoir ajouter ce ligne de code ci haut, copier la ligne ci-dessous dans la class User et remplacer le code dans la class User avec cette ligne de code

use HasApiTokens, HasFactory, Notifiable;

Puis taper la commande ci-dessous pour migrer les changes dans la base des données afin d’ajouter le tables de Token.

php artisan migrate

Creation du contrôleur Auth.

Comme on’a vu nous avons deja le modele utilisateur cree par defaut, maitenant, nous allons creer notre Controlleur Auth. Pour creer le auth controleur, ou n’importe quelle nom que vous le donner taper la commande suivante:

php artisan make:controller AuthController

Aller y dans le dossier app/Http/Controllers, vous trouverez le contrôleur que nous venons de créer. Dans ce contrôleur, on vas ajouter les méthodes d’inscription pour notre app. Copier le code ci dessous dans le AuthController

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\User;

use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\ValidationException;

class AuthController extends Controller
{

    // methode d'inscription
    public function InscrisUtilisateur(Request $request)
    {
        $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|min:8|confirmed',
            'password_confirmation' => 'required',
        ]);

        $utilisateur = new User;
        
        $utilisateur->first_name = $request->first_name;
        $utilisateur->last_name = $request->last_name;
        $utilisateur->phone_number = $request->phone_number;
        $utilisateur->email =   $request->email;
        $utilisateur->password  = bcrypt($request->password);
    
        $utilisateur->save();

        return response()->json([
            'msg'=>'Utilisateur creation reussi',
            'status_code' => 200,
            'utilisateur'=> $utilisateur
            ]);
            
    }

}

Creation de la route d’inscription

Dans la partie ci-haut, on n’a crée la méthode inscription pour nous permettre d’enregistrer un nouveau utilisateur pour notre application. Dans la méthode inscription, premièrement nous avons valider les différents fields, puis nous avons initialiser le modèle utilisateur en créant un objet utilisateur et puis nous avons appelé la requête dans la base des données et retourner le résultat en forme de JSON. Maintenant nous allons créer la route pour connecter notre contrôleur a la route de creation. Pour simplifier, on n’appellera notre inscription comme dans le code ci-dessous

// les routes du authcontroller 
Route::post('inscription', [AuthController::class, 'InscrisUtilisateur']);

Creation de la fonction de authentification

Apres avoir creer la fonction d’inscription, maintenant nous allons creer la fonction qui nous permettra d’authentifier et recevoir le token. Aller dans le controleur AuthController et ajouter le code suivant

En haut du AuthController controleur ajouter la ligne

 use Illuminate\Support\Facades\Auth; 

 puis dans le contrôleur et ajouter la méthode suivante en bas de l’autre méthode

// methode d'authentification  

        public function connexion(Request $request)
        {
        try {
            $request->validate([
            'email' => 'email|required',
            'password' => 'required'
            ]);
            
            $credentials = request(['email', 'password']);
            
            if (!Auth::attempt($credentials)) {
            return response()->json([
                'status_code' => 500,
                'message' => 'non authoriser'
            ]);
            }
            
            $user = User::where('email', $request->email)->first();
            
            $tokenResult = $user->createToken('authToken')->plainTextToken;
            
            return response()->json([
            'status_code' => 200,
            'access_token' => $tokenResult,
            'token_type' => 'Bearer',
            ]);
            
        } catch (Exception $error) {
            return response()->json([
            'status_code' => 500,
            'message' => 'Error in Login',
            'error' => $error,
            ]);
        }
        } 

Creation de la ressource de connexion

Dans la méthode de connexion que nous venons de creer ci-dessus, nous allons creer la route pour connecter la fonction de connexion au route. Aller y dans le dossier routes et ouvrer le fichier api.php, puis ajouter le code ci-dessous en bas de la route inscription

Route::post('connexion', [AuthController::class, 'connexion']);

Tester notre système d’authentification

Relancer l’application en tapant la commande

php artisan serve

pour tester notre système d’authentification, ouvrer le logiciel postman que vous avez installer pour tester la creation de l’utilisateur.

Test l’authentification

image authentification

Conclusion:

Dans cet article, nous avons vu comment créer une inscription et comment authentifier notre utilisateur et recevoir le token. Dans une prochaine poste nous allons voir comment protéger notre api que nous avons crées.