Développement Laravel : Comment implémenter l'authentification API OAuth2 à l'aide de Laravel Passport ?

À mesure que l'utilisation des API devient de plus en plus populaire, la protection de la sécurité et de l'évolutivité des API devient de plus en plus critique. OAuth2 est devenu un protocole de sécurité API largement adopté qui permet aux applications d'accéder à des ressources protégées via une autorisation. Pour implémenter l'authentification OAuth2, Laravel Passport fournit un moyen simple et flexible. Dans cet article, nous apprendrons comment implémenter l'authentification API OAuth2 à l'aide de Laravel Passport.

Laravel Passport est une bibliothèque de serveur OAuth2 officiellement fournie qui peut facilement ajouter l'authentification OAuth2 à votre application Laravel. Il fournit une authentification API pour les clients du framework Laravel, protégeant les API et limitant l'accès aux ressources via des jetons. En quelques étapes de configuration, vous pouvez créer un serveur OAuth2 sécurisé et fournir une authentification et une autorisation pour votre API.

Pour commencer à utiliser Laravel Passport, vous devez l'installer. Vous pouvez l'installer via le gestionnaire de packages Composer :

composer require laravel/passport

Une fois Laravel Passport installé, vous devez exécuter des migrations pour créer les tables de base de données nécessaires :

php artisan migrate

Afin d'activer Laravel Passport, vous devez enregistrer le ServiceProvider et le middleware. . Ajoutez le ServiceProvider et le middleware suivants dans le fichier config/app.php :

'providers' => [
    // ...
    LaravelPassportPassportServiceProvider::class,
],

'middleware' => [
    // ...
    LaravelPassportHttpMiddlewareCreateFreshApiToken::class,
],

Laravel Passport nécessite une table "clés" pour émettre des jetons d'accès et des jetons d'actualisation. L'exécution de la commande suivante générera ce tableau :

php artisan passport:install

Cela créera une paire de clés RSA cryptées pour la signature et la vérification des jetons, ainsi qu'un client nommé "personal_access_client" et un client nommé "password_client". Ces deux clients sont utilisés pour créer différents types de jetons. Le premier client est utilisé pour générer des jetons d'accès personnels qui permettent au client d'accéder à n'importe quel point de terminaison d'API sécurisé avec l'authentification OAuth2. Le deuxième client est utilisé pour créer des jetons d'autorisation de mot de passe qui permettent au client d'obtenir un jeton d'accès via un nom d'utilisateur et un mot de passe.

Dans ce processus, vous devez également configurer Laravel Passport dans votre fichier config/auth.php. Vous devez ajouter le pilote de passeport à la garde API afin que Laravel Passport puisse gérer tout ce qui concerne OAuth2. Un exemple est le suivant :

'guards' => [
    // ...
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],

Maintenant que la configuration est terminée, nous pouvons commencer à créer des routes et des contrôleurs API.

Tout d'abord, vous devez définir vos routes API. Par exemple, disons que vous disposez d'un point de terminaison API pour obtenir une liste de tâches :

Route::get('/tasks', 'TaskController@index')->middleware('auth:api');

Ensuite, vous devez créer un contrôleur pour gérer la demande et répondre aux tâches :

class TaskController extends Controller
{
    public function index()
    {
        $tasks = Task::all();

        return response()->json([
            'tasks' => $tasks,
        ]);
    }
}

Incluez le paramètre "auth:api" dans la méthode middleware pour nous demander d'utiliser les gardes API pour protéger les routes.

Voyons maintenant comment effectuer l'authentification OAuth2 et obtenir un jeton d'accès. Vous devez créer un client qui utilisera le flux OAuth2 d'autorisation par mot de passe pour obtenir le jeton d'accès. De cette façon, vous pouvez vous authentifier sur le point de terminaison de l'API avec des requêtes API.

Vous pouvez créer un nouveau client dans la liste des clients de Laravel Passport ou utiliser la méthode Passport::client() dans votre code pour générer un identifiant client aléatoire et un secret client pour le client. Vous pouvez enregistrer l'identifiant client et le secret client dans votre fichier .env ou vous pouvez les fournir directement dans votre méthode Passport::client(). Cette méthode créera un nouveau client et renverra l'identifiant client et le secret client :

use LaravelPassportClient;
use IlluminateSupportFacadesDB;

$client = $this->createClient();

public function createClient()
{
    $client = Client::forceCreate([
        'user_id' => null,
        'name' => 'Test Client',
        'secret' => str_random(40),
        'redirect' => '',
        'personal_access_client' => false,
        'password_client' => true,
        'revoked' => false,
    ]);

    DB::table('oauth_client_grants')->insert([
        'client_id' => $client->id,
        'grant_id' => 1,
    ]);

    return $client;
}

Maintenant que nous avons un client, nous devons utiliser Laravel Passport dans le contrôleur pour obtenir le jeton d'accès et l'utiliser pour accéder au point de terminaison de l'API protégé. Nous devons implémenter l'authentification OAuth2 dans le contrôleur en utilisant le code suivant :

use IlluminateSupportFacadesAuth;
use LaravelPassportClientRepository;

class TaskController extends Controller
{
    protected $clients;
    
    public function __construct(ClientRepository $clients)
    {
        $this->clients = $clients;
    }

    public function index()
    {
        $client = $this->clients->find(2);

        $response = $this->actingAsClient($client, function () {
            return $this->get('/api/tasks');
        });

        return $response->getContent();
    }

    protected function actingAsClient($client, $callback, $scopes = [])
    {
        $proxy = new LaravelPassportHttpControllersAccessTokenController();

        $token = $proxy->issueToken(
            $this->getPersonalAccessTokenRequest($client, $scopes)
        );

        Auth::guard('web')->loginUsingId($client->user_id);

        $callback($token);

        return $this->app->make(IlluminateHttpRequest::class);
    }

    protected function getPersonalAccessTokenRequest($client, $scopes = [])
    {
        $data = [
            'grant_type' => 'client_credentials',
            'client_id' => $client->id,
            'client_secret' => $client->secret,
            'scope' => implode(' ', $scopes),
        ];

        return IlluminateHttpRequest::create('/oauth/token', 'POST', $data);
    }
}

En utilisant la méthode actAsClient(), nous pouvons simuler l'exécution de la requête en tant que client et n'importe quelle méthode du contrôleur peut utiliser cette méthode pour l'authentification OAuth2. Nous devons transmettre un objet client, une fonction de rappel pour effectuer la requête API et éventuellement les autorisations à ajouter à la requête.

Maintenant que nous avons terminé la configuration de l'authentification OAuth2 de Laravel Passport, en utilisant le modèle de code ci-dessus, nous pouvons facilement implémenter l'authentification OAuth2 sécurisée sur nos points de terminaison API. Passport est un projet relativement nouveau. Cependant, il est parfaitement intégré à Laravel et fournit plusieurs services d'authentification OAuth2, vous permettant d'ajouter facilement une authentification et une autorisation à votre API. Si vous exécutez une application Laravel et devez ajouter l'authentification OAuth2, Laravel Passport est idéal à cet effet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!