Laravel API : Créez et testez une

API dans Laravel

Downloaded on: 20 November 2023

 Ship and manage your
web projects faster
Deploy your projects on Google Cloud Platform's top tier
infrastructure. You'll get 25+ data centers to choose
from, 24/7/365 expert support, and advanced security
with DDoS protection.

Try for free

Laravel Eloquent est un moyen simple d’interagir avec votre base de données. Il s’agit d’un
mappeur objet-relationnel (Object-Relational Mapper ou ORM) qui simplifie les complexités
des bases de données en fournissant un modèle pour interagir avec les tables.

En tant que tel, Laravel Eloquent dispose d’excellents outils pour créer et tester des API afin
de soutenir votre développement. Dans cet article pratique, vous verrez à quel point il est
facile de créer et de tester des API à l’aide de Laravel.

Dans cette démonstration, vous commencerez par créer un modèle que vous pourrez utiliser
pour construire l’API et la table de la base de données. Ensuite, vous verrez comment ajouter
un contrôleur en tant que couche de logique commerciale et une route pour compléter l’API.
Vous apprendrez ensuite à tester les API à l’aide de Postman avant de vous concentrer sur
l’authentification et la gestion des erreurs.

Pré-requis
Pour commencer, voici ce dont vous aurez besoin :
 Laravel version 8 ou 9
Composer
Postman
XAMPP
Connaissance de base des API et de PHP

Principes de base des API

Commencez par créer un nouveau projet Laravel à l’aide de <code>composer</code> :

composer create-project laravel/laravel laravel-api-create-test

Pour démarrer le serveur, exécutez la commande suivante, qui lance le serveur d’application
sur le port 8000 :

cd laravel-api-create-test
php artisan serve

L’écran suivant devrait s’afficher :

 — Laravel

Ensuite, créez un modèle avec un drapeau -m pour la migration en utilisant le code ci-
dessous :

php artisan make:model Product -m

Mettez maintenant à jour le fichier de migration pour y inclure le champ nécessaires. Ajoutez
les champs title et description pour le modèle de produit et ces deux champs de table dans le
fichier database/migrations/{date_stamp}_create_products_table.php.
 $table->string('title');
$table->longText('description');

L’étape suivante consiste à rendre ces champs remplissables. Dans app/Models/Product

.php, rendez les champs title et description remplissables.

protected $fillable = ['title', 'description'];

Comment créer un contrôleur

Créez maintenant un fichier contrôleur pour le produit en exécutant la commande suivante.
Cela créera le fichier app/Http/Controllers/Api/ProductController.php.

php artisan make:controller ApiProductController --model=Product

Ajoutez maintenant la logique de création et de récupération des produits. Dans la méthode

index, ajoutez le code suivant pour récupérer tous les produits :
 $products = Product::all();
return response()->json([
'status' => true,
'products' => $products
]);

Ensuite, vous devez ajouter une classe StoreProductRequest pour stocker les nouveaux
produits dans la base de données. Ajoutez la classe suivante au début du même fichier.

public function store(StoreProductRequest $request)

{
$product = Product::create($request->all());

return response()->json([
'status' => true,
'message' => "Product Created successfully!",
'product' => $product
], 200);
}

Maintenant, vous allez créer la requête, ce que vous pouvez faire en exécutant la commande
suivante :

php artisan make:request StoreProductRequest

Si vous souhaitez ajouter des validations, vous pouvez utiliser le fichier
app/Http/Requests/StoreProductRequest.php. Pour cette démonstration, il n’y a pas de
validations.

Comment créer une route

La dernière étape avant de tester l’API consiste à ajouter une route. Pour cela, ajoutez le
code suivant dans le fichier routes/api.php. Ajoutez l’instruction use au début du fichier et
l’instruction Route dans le corps du texte :

use App\Http\Controllers\Api\ProductController;
Route::apiResource('products', ProductController::class);

Avant de commencer à tester l’API, assurez-vous que la table products se trouve dans votre
base de données. Si elle n’existe pas, créez-en une à l’aide d’un panneau de contrôle tel que
XAMPP. Vous pouvez également exécuter la commande suivante pour migrer la base de
données :

php artisan migrate

Comment tester une API

Avant de tester l’API, assurez-vous que la méthode <code>authorize</code> à l’intérieur de
app/Http/Requests/StoreProductRequest.php est configurée pour renvoyer
<code>true</code>.
Vous pouvez maintenant créer un nouveau produit à l’aide de Postman. Commencez par
envoyer une requête POST à l’URL suivante : http://127.0.0.1:8000/api/products/. Comme il
s’agit d’une requête POST pour la création d’un nouveau produit, vous devez transmettre un
objet JSON avec un titre et une description.

{
"title":"Apple",
"description":"Best Apples of the world"
}

— Création d’un nouveau produit dans Postman

Après avoir cliqué sur le bouton Envoyer, vous devriez voir ce qui suit :
 — Postman après avoir cliqué sur Envoyer

Maintenant, récupérez les produits créés en utilisant la requête GET. L’URL est la même. Les
résultats ressembleront à ce qui suit :
— Les produits récupérés par la requête GET.
Comment authentifier une API à l’aide de Sanctum
L’authentification est cruciale pour sécuriser une API. Laravel facilite cette tâche en
fournissant la fonctionnalité du jeton Sanctum, que vous pouvez utiliser en tant que
middleware. Il sécurise l’API à l’aide de jetons générés lorsque l’utilisateur se connecte à
l’aide des informations d’identification correctes. N’oubliez pas que les utilisateurs ne peuvent
pas accéder à l’API sécurisée sans jeton.

La première étape pour ajouter l’authentification consiste à ajouter un paquetage Sanctum à

l’aide du code ci-dessous :

composer require laravel/sanctum

Ensuite, publiez le fichier de configuration de Sanctum :

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

Ensuite, ajoutez le token de Sanctum en tant que middleware. Dans le fichier

app/Http/Kernel.php, utilisez la classe suivante et remplacez middlewareGroups par le
code suivant dans l’API des groupes middleware protégés.

use Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful;
 protected $middlewareGroups = [
'web' => [
\App\Http\Middleware\EncryptCookies::class,
\Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
\Illuminate\Session\Middleware\StartSession::class,
// \Illuminate\Session\Middleware\AuthenticateSession::class,
\Illuminate\View\Middleware\ShareErrorsFromSession::class,
\App\Http\Middleware\VerifyCsrfToken::class,
\Illuminate\Routing\Middleware\SubstituteBindings::class,
],

'api' => [
EnsureFrontendRequestsAreStateful::class,
'throttle:api',
\Illuminate\Routing\Middleware\SubstituteBindings::class,
],
];

L’étape suivante consiste à créer un site UserController et à ajouter le code permettant

d’obtenir le jeton d’authentification.

php artisan make:controller UserController

Après avoir créé le site UserController, naviguez jusqu’au fichier

app/Http/Controllers/UserController.php et remplacez le code existant par le code suivant :
 <?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\Hash;
class UserController extends Controller
{
//

function index(Request $request)

{
$user= User::where('email', $request->email)->first();
// print_r($data);
if (!$user || !Hash::check($request->password, $user->password
return response([
'message' => ['These credentials do not match our reco
], 404);
}

$token = $user->createToken('my-app-token')->plainTextToken;

$response = [
'user' => $user,
'token' => $token
];

return response($response, 201);

}
}

Avant de tester l’authentification, créez un utilisateur employant des seeders. La commande

suivante crée un fichier UsersTableSeeder.
 php artisan make:seeder UsersTableSeeder

Dans le fichier database/seeders/UsersTableSeeder.php, remplacez le code existant par le

code suivant pour ensemencer l’utilisateur :

<?php

namespace Database\Seeders;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

class UsersTableSeeder extends Seeder

{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('users')->insert([
'name' => 'John Doe',
'email' => 'john@doe.com',
'password' => Hash::make('password')
]);
}
}

Exécutez maintenant le seeder à l’aide de la commande suivante :

 php artisan db:seed --class=UsersTableSeeder

La dernière étape du flux d’authentification consiste à utiliser le middleware créé pour

protéger la route. Naviguez jusqu’au fichier routes/api.php et ajoutez la route des produits à
l’intérieur du middleware.

use App\Http\Controllers\UserController;

Route::group(['middleware' => 'auth:sanctum'], function () {

Route::apiResource('products', ProductController::class);
});

Route::post("login",[UserController::class,'index']);

Après avoir ajouté une route au middleware, vous obtiendrez une erreur de serveur interne si
vous essayez de récupérer les produits.
 — Une erreur de serveur interne après l’ajout d’une route

Mais une fois que vous vous êtes connecté, que vous avez obtenu un jeton et que vous
l’avez utilisé dans l’en-tête, vous serez authentifié et vous pourrez commencer à travailler.
Vous pouvez envoyer une requête POST à http://127.0.0.1:8000/api/login avec le corps
suivant :

{
"email":"john@doe.com",
"password":"password"
}
 — Authentification réussie

Utilisez le jeton reçu comme jeton de support et ajoutez-le à l’en-tête Authorization.

 — Ajout du jeton Bearer en tant qu’en-tête d’autorisation

Comment gérer les erreurs de l’API

Chaque fois que vous envoyez une requête au serveur, celui-ci répond. Avec la réponse, il
envoie également un code d’état en fonction de la nature de la réponse. Par exemple, un
code d’état 200 indique que la demande a abouti, tandis qu’un code d’état 404 indique que le
serveur n’a pas trouvé la ressource demandée.
Cependant, un code d’état ne suffit pas. Un message d’erreur lisible par l’homme est
nécessaire. Laravel propose de nombreuses façons de gérer les erreurs. Vous pouvez utiliser
un bloc try-catch, la méthode fallback ou envoyer une réponse personnalisée. Le code
suivant que vous avez ajouté à l’adresse UserController en fait la démonstration.

if (!$user || !Hash::check($request->password, $user->password)) {

return response([
'message' => ['These credentials do not match our records.']
], 404);
}

Résumé
Le modèle éloquent de Laravel facilite la création, la validation et le test des API. Son
mapping objet-relationnel fournit une approche directe pour interagir avec la base de
données.

De plus, en tant que middleware, le jeton Sanctum de Laravel peut vous aider à sécuriser
rapidement vos API.

Et si vous avez besoin d’une optimisation supplémentaire, la solution d’hébergement de

bases de données de Kinsta simplifie la mise en place et la gestion des bases de données
pour tous vos projets web.