Dans ce tutoriel, nous allons voir comment créer un API RESTful sécurisée avec Laravel 8 à l’aide du package Laravel 8 sanctum.
De même, nous vous expliquerons étape par étape comment tester l’API REST à l’aide de l’outil de test Postman.
Laravel Sanctum propose un système d’authentification sécurisé, incroyablement rapide et léger pour les applications à page unique (SPA), les applications mobiles et les API simples basées sur des jetons.
Lire aussi: Comment importer un fichier Excel dans Laravel
Sanctum est un package complet qui permet à chaque utilisateur de générer indépendamment plusieurs jetons API pour son compte. Ces jetons accordent divers rôles et étendues qui désignent les actions que les jetons sont autorisés à effectuer.
Créer un API RESTful sécurisée avec Laravel 8
Pour créer un API RESTful sécurisée avec Laravel 8, nous allons suivre les étapes suivantes pas à pas.
Créer un projet Laravel
La première étape pour créer un API RESTful sécurisée avec Laravel 8, consiste à créer d’abord un un nouveau projet Laravel 8.
Vous devez ouvrir le terminal, ajoutez la commande suivante pour créer un projet Laravel.
Mais assurez-vous que composer est installé sur votre système.
composer create-project --prefer-dist laravel/laravel laravel-sanctum-auth
Configuration de la base de données dans ENV
Vous devez ajouter la configuration de la base de données dans le fichier de configuration .env pour communiquer entre la base de données laravel et mysql.
DB_CONNECTION=mysql DB_HOST=127.0.0.1 DB_PORT=3306 DB_DATABASE=db_name DB_USERNAME=root DB_PASSWORD=
Installer le paquet Laravel Sanctum
Tapez la commande composer dans le console du terminal et exécutez-la pour commencer à installer le package sanctum dans l’application laravel.
composer require laravel/sanctum
Mise en place de Sanctum
La bibliothèque Sanctum a été ajoutée dans laravel, et vous devez maintenant ajouter le fournisseur de Sanctum. Par conséquent, publiez la configuration de Sanctum à l’aide de la commande de publication.
php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"
Ensuite, enregistrez le middleware sanctum dans le tableau api à l’intérieur du fichier app/Http/Kernel.php
protected $middlewareGroups = [
...
...
'api' => [
\Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class,
'throttle:api',
\Illuminate\Routing\Middleware\SubstituteBindings::class,
],
...
...
];
Exécutez la commande suivante pour exécuter la migration ; de même, plus tard dans la base de données, nous générerons une table de sanctum pour gérer les informations d’authentification.
php artisan migrate
Par la suite, nous devons préparer la configuration de sanctum pour le projet. Par conséquent, ajoutez la classe sanctum HasApiTokens dans le fichier app/Models/User.php.
<?php
namespace App\Models;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
// sanctum
use Laravel\Sanctum\HasApiTokens;
class User extends Authenticatable
{
use HasApiTokens, HasFactory, Notifiable;
/**
* The attributes that are mass assignable.
*
* @var array
*/
protected $fillable = [
'name',
'email',
'password',
];
/**
* The attributes that should be hidden for arrays.
*
* @var array
*/
protected $hidden = [
'password',
'remember_token',
];
/**
* The attributes that should be cast to native types.
*
* @var array
*/
protected $casts = [
'email_verified_at' => 'datetime',
];
}
Mettre à jour le modèle et exécuter la migration
Utilisez la commande php artisan pour créer une nouvelle table de migration de blog, tapez la commande dans le terminal et exécutez-la pour générer un nouveau fichier de migration.
php artisan make:migration create_blogs_table
Vous devez ajouter quelques propriétés dans le fichier de migration, alors ouvrez et ajoutez du code dans le fichier database/migrations/create_blogs_table.php.
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateBlogsTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('blogs', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('description');
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('blogs');
}
}
Ensuite, créez un fichier app/Models/Blog.php et enregistrez les propriétés de migration du produit dans le tableau $fillable.
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Blog extends Model
{
use HasFactory;
protected $fillable = [
'title',
'description'
];
}
Exécutez la commande recommandée pour exécuter la migration de la base de données :
php artisan migrate
Créer les ressources pour l’API
Il vous permet de gérer une réponse similaire à celle de votre modèle ; par exemple, nous utiliserons BlogController, qui correspondra aux propriétés du modèle Blog.
Exécutez la commande pour générer des ressources API éloquentes de blog.
php artisan make:resource Blog
Placez le code suggéré dans app/Http/Resources/Blog.php
<?php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\JsonResource;
class Blog extends JsonResource
{
public function toArray($request)
{
return [
'id' => $this->id,
'title' => $this->title,
'description' => $this->description,
'created_at' => $this->created_at->format('m/d/Y'),
'updated_at' => $this->updated_at->format('m/d/Y'),
];
}
}
Configuration des contrôleurs
Ensuite, nous devons créer trois contrôleurs pour gérer le processus d’authentification ; tout d’abord, créez un répertoire API dans le dossier Controllers ; après cela, créez trois fichiers simultanément dans le dossier, nommez-les AuthController, BaseController et BlogController.
Ces fichiers géreront individuellement les opérations de connexion, d’inscription et de blogs bruts.
Ensuite, ajoutez le code dans le fichier app/Http/Controllers/API/BaseController.php :
<?php
namespace App\Http\Controllers\API;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller as Controller;
class BaseController extends Controller
{
/**
* success response method.
*
* @return \Illuminate\Http\Response
*/
public function sendResponse($result, $message)
{
$response = [
'success' => true,
'data' => $result,
'message' => $message,
];
return response()->json($response, 200);
}
/**
* return error response.
*
* @return \Illuminate\Http\Response
*/
public function sendError($error, $errorMessages = [], $code = 404)
{
$response = [
'success' => false,
'message' => $error,
];
if(!empty($errorMessages)){
$response['data'] = $errorMessages;
}
return response()->json($response, $code);
}
}
Ouvrez et placez tout le code suggéré dans le fichier app/Http/Controllers/API/AuthController.php, cela amplifiera le processus d’enregistrement et de connexion de l’utilisateur :
<?php
namespace App\Http\Controllers\API;
use Illuminate\Http\Request;
use App\Http\Controllers\API\BaseController as BaseController;
use Illuminate\Support\Facades\Auth;
use Validator;
use App\Models\User;
class AuthController extends BaseController
{
public function signin(Request $request)
{
if(Auth::attempt(['email' => $request->email, 'password' => $request->password])){
$authUser = Auth::user();
$success['token'] = $authUser->createToken('MyAuthApp')->plainTextToken;
$success['name'] = $authUser->name;
return $this->sendResponse($success, 'User signed in');
}
else{
return $this->sendError('Unauthorised.', ['error'=>'Unauthorised']);
}
}
public function signup(Request $request)
{
$validator = Validator::make($request->all(), [
'name' => 'required',
'email' => 'required|email',
'password' => 'required',
'confirm_password' => 'required|same:password',
]);
if($validator->fails()){
return $this->sendError('Error validation', $validator->errors());
}
$input = $request->all();
$input['password'] = bcrypt($input['password']);
$user = User::create($input);
$success['token'] = $user->createToken('MyAuthApp')->plainTextToken;
$success['name'] = $user->name;
return $this->sendResponse($success, 'User created successfully.');
}
}
Rendez-vous dans le fichier app/Http/Controllers/API/BlogController.php et insérez-y le code des opérations CRUD :
<?php
namespace App\Http\Controllers\API;
use Illuminate\Http\Request;
use App\Http\Controllers\API\BaseController as BaseController;
use Validator;
use App\Models\Blog;
use App\Http\Resources\Blog as BlogResource;
class BlogController extends BaseController
{
public function index()
{
$blogs = Blog::all();
return $this->sendResponse(BlogResource::collection($blogs), 'Posts fetched.');
}
public function store(Request $request)
{
$input = $request->all();
$validator = Validator::make($input, [
'title' => 'required',
'description' => 'required'
]);
if($validator->fails()){
return $this->sendError($validator->errors());
}
$blog = Blog::create($input);
return $this->sendResponse(new BlogResource($blog), 'Post created.');
}
public function show($id)
{
$blog = Blog::find($id);
if (is_null($blog)) {
return $this->sendError('Post does not exist.');
}
return $this->sendResponse(new BlogResource($blog), 'Post fetched.');
}
public function update(Request $request, Blog $blog)
{
$input = $request->all();
$validator = Validator::make($input, [
'title' => 'required',
'description' => 'required'
]);
if($validator->fails()){
return $this->sendError($validator->errors());
}
$blog->title = $input['title'];
$blog->description = $input['description'];
$blog->save();
return $this->sendResponse(new BlogResource($blog), 'Post updated.');
}
public function destroy(Blog $blog)
{
$blog->delete();
return $this->sendResponse([], 'Post deleted.');
}
}
Créer des routes pour l’API
Vous devez utiliser des contrôleurs pour créer des routes api sanctum auth ; nous avons défini la connexion, enregistré les méthodes de publication et les ressources pour créer collectivement l’api d’authentification.
Ouvrez et insérez le code dans le fichier routes/api.php :
<?php
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\API\AuthController;
use App\Http\Controllers\API\BlogController;
/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
*/
Route::post('login', [AuthController::class, 'signin']);
Route::post('register', [AuthController::class, 'signup']);
Route::middleware('auth:sanctum')->group( function () {
Route::resource('blogs', BlogController::class);
});
Tester l’API REST avec Postman
Nous avons appris à créer un API RESTful sécurisée avec Laravel 8, nous pouvons maintenant procerder aux tests avec Postman. Vous devez démarrer le serveur de développement laravel à l’aide de la commande php artisan :
php artisan serve
Testez l’API de création d’utilisateur
Ouvrez l’application Postman, sélectionnez la méthode Post dans la liste déroulante. Entrez l’itinéraire ou l’URL dans la barre d’adresse, sélectionnez la section Corps, entrez le nom, l’e-mail, le mot de passe et confirmez le mot de passe et cliquez sur envoyer pour créer un utilisateur.
http://localhost:8000/api/register
Tester l’API de connexion
Ajoutez l’URL suivante dans la barre d’adresse du facteur, basculez la méthode sur GET, entrez l’e-mail et le mot de passe et cliquez sur envoyer pour connecter un utilisateur.
http://localhost:8000/api/login
Définir le jeton d’autorisation
Accédez à l’onglet Autorisation de l’application Postman, sélectionnez « Bearer Token » dans la liste déroulante Type, puis ajoutez le jeton d’authentification que vous avez obtenu lorsque vous êtes connecté à l’application.
Créer un article avec l’API
Ajoutez l’URL suivante dans la barre d’adresse du facteur, basculez la méthode sur POST, entrez le titre et la description, puis cliquez pour créer une publication et la stocker dans la base de données.
http://localhost:8000/api/blogs
Récupérer un article
Vous pouvez maintenant voir comment récupérer un seul article à l’aide de l’identifiant de l’article, utilisez l’URL ci-dessous :
http://localhost:8000/api/blogs/{id}
Récupérer tous les articles
Vous pouvez récupérer tous les articles à la fois, utilisez donc l’API REST suivante avec la méthode GET pour obtenir tous les enregistrements.
http://localhost:8000/api/blogs
Mettre à jour un article
Pour mettre à jour un article, ajoutez la route suivante avec la méthode Put pour mettre à jour un seul enregistrement dans la base de données.
http://localhost:8000/api/blogs/{id}
Supprimer un enregistrement
Pour supprimer un enregistrement, définissez la méthode à supprimer et utilisez l’URL suivante :
http://localhost:8000/api/blogs/{id}
Lire aussi: Comment générer des fichiers PDF dans Laravel 8
Conclusion
Dans ce tutoriel, vous avez appris comment créer un API RESTful sécurisée avec Laravel 8 en utilisant le package Laravel Sanctum.
Leave a Comment