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 :

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
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
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
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.
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\SanctumServiceProvider"

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 records.']
                ], 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' => '[email protected]',
            '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
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":"[email protected]",
    "password":"password"
}
Authentification réussie
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
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.

Jeremy Holcombe Kinsta

Rédacteur en chef du contenu et du marketing chez Kinsta, développeur web WordPress et rédacteur de contenu. En dehors de WordPress, j'aime la plage, le golf et le cinéma. J'ai aussi des problèmes avec les personnes de grande taille ;).