Utiliser Passport pour implémenter l'authentification Auth dans Laravel5.5

Cet article présente principalement l'utilisation de Passport pour implémenter l'authentification Auth dans Laravel5.5. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Démarrez avec Laravel5. .3 Passport est utilisé comme autorisation API. Passport est basé sur OAuth2. L'article suivant vous présente principalement la méthode d'utilisation de Passport pour implémenter l'authentification Auth dans Laravel5.5. L'article le présente en détail à travers un exemple de code. peut s’y référer. Jetons un coup d’œil ci-dessous.

Préface

Récemment, j'écris un projet de séparation front-end et back-end, je voulais à l'origine utiliser Jwt-auth + Dingo. pour le développer, mais cela semble un peu fastidieux. J'ai donc pensé au Passport de Laravel et à la nouvelle ressource Api en 5.5. Laravel Passport est un ensemble d'implémentation de serveur OAuth2 encapsulé

OAuth est un standard de réseau ouvert pour l'autorisation, largement utilisé dans le monde. La version actuelle est la version 2.0.

OAuth 2.0 est actuellement une approche populaire, et elle a été utilisée pour la première fois par Google, Yahoo, Microsoft, Facebook, etc. La raison pour laquelle il est marqué comme 2.0 est qu'il existait à l'origine un protocole 1.0, mais ce protocole 1.0 était trop compliqué et pas facile à utiliser, il n'a donc pas été popularisé. 2.0 est un nouveau design avec un protocole simple et clair, mais il n'est pas compatible avec 1.0 et n'a rien à voir avec 1.0.

Je n’entrerai donc pas dans les détails ici, voyons d’abord comment l’installer.

Installer

Installer Passport

1. Exécutez la commande suivante dans votre Shell

composer require laravel/passport

Si la version de Laravel que vous utilisez est inférieure à 5.5, vous devez l'ajouter manuellement au tableau des fournisseurs dans le fichier config/ Fichier app.php Le code suivant

Laravel\Passport\PassportServiceProvider::class,

2. Exécutez le fichier de migration

Exécuter. comme suit dans votre commande Shell

php artisan migrate

Le fournisseur de services Passport utilise le framework pour enregistrer son propre répertoire de migration, donc après avoir enregistré le service, vous pouvez directement exécutez php artisan migrate pour fournir Passport Générez la table de données requise

3 Générez la clé de cryptage

Exécutez la commande suivante dans votre Shell

<🎜. >

php artisan passport:install

Cette commande créera la clé de cryptage requise pour générer un jeton d'accès sécurisé. En même temps, cette commande créera également le client « Accès personnel » utilisé pour générer. le jeton d'accès et "Autorisation par mot de passe".

4. Ajouter un trait

Ajouter le trait LaravelPassportHasApiTokens au modèle AppUser

<?php
namespace App;
use Laravel\Passport\HasApiTokens;
use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
class User extends Authenticatable
{
 use HasApiTokens, Notifiable;
}

5. Enregistrez la route

Appelez la fonction

dans la méthode de démarrage d'AuthServiceProvider. Passport::routes

class AuthServiceProvider extends ServiceProvider
{
 public function boot()
 {
  $this->registerPolicies();
  Passport::routes();
 }
}

Si votre programme nécessite une authentification OAuth de séparation front-end et back-end au lieu d'une authentification multiplateforme, vous pouvez alors utiliser l'authentification OAuth Méthode routers() Transmettez une fonction anonyme pour personnaliser l'itinéraire que vous devez enregistrer. Voici le formulaire d'authentification qui sépare le front-end et le back-end, je n'ai donc besoin que de fournir une authentification Auth à l'un de mes clients front-end, donc J'ai uniquement enregistré l'itinéraire pour obtenir le Token, et en même temps je lui ai également donné un préfixe personnalisé.

Passport::routes(function(RouteRegistrar $router) {
 $router->forAccessTokens();
},['prefix' => 'api/oauth']);

6. Changez le pilote du watcher

Changez le fichier de configuration config/auth. php L'option pilote de l'API des gardes d'autorisation est remplacée par passeport. Cet ajustement permettra à votre application d'utiliser TokenGuard de Passport lors de la vérification des requêtes API entrantes, comme pour la partie front-end mentionnée dans les documents restants, car je n'ai besoin de l'utiliser que pour l'authentification Auth et je n'ai pas besoin d'implémenter la fonction OAuth complète. , nous n'avons pas du tout besoin d'utiliser la page frontale.

Utiliser

'guards' => [
 'web' => [
  'driver' => 'session',
  'provider' => 'users',
 ],
 'api' => [
  'driver' => 'passport',
  'provider' => 'users',
 ],
],

Pour faciliter le retour des données par l'API, j'ai encapsulé plusieurs fonctions

La fonction de réponse peut effectuer des retours de base réussis et échoués qui sont réencapsulés sur la fonction de réponse pour renvoyer les données de réussite et d'échec de la demande.

Ensuite, nous devons utiliser une couche de proxy.

Parlons d'abord de la raison de l'utilisation d'un proxy. Le processus d'authentification Passport est que l'application esclave prend le jeton client généré par l'application principale

function respond($status, $respond)
{
 return response()->json(['status' => $status, is_string($respond) ? 'message' : 'data' => $respond]);
}
function succeed($respond = 'Request success!')
{
 return respond(true, $respond);
}
function failed($respond = 'Request failed!')
{
 return respond(false, $respond);
}

et le mot de passe du compte saisi par l'utilisateur doit demander le passeport de l'application principale. Route de jeton pour obtenir un jeton d'accès (jeton d'accès) et un jeton d'actualisation (jeton d'actualisation), puis utiliser le jeton d'accès obtenu pour accéder à la route sous auth:api. Mais nous n'avons pas d'application subordonnée. Le front-end qui sépare le front-end demande ce jeton d'accès. Si vous souhaitez extraire ce jeton d'accès du front-end, vous devez écrire le jeton client dans le front-end. très déraisonnable, nous pouvons donc écrire un proxy en interne, et l'application elle-même prend le jeton client pour se demander d'obtenir le jeton d'accès. Cela peut être un peu compliqué. Le processus de demande est probablement le suivant

1. Le front-end porte le mot de passe du compte saisi par l'utilisateur du serveur de requête

.

2.服务端带着从前端接收到账号与密码，并在其中添加 Client_id 与 Client_token，然后带着这些参数请求自身的 Passport 认证路由，然后返回认证后的 Access token 与 refresh token

下面是代码实现,我在 AppHttpControllersTraits 下新建了一个 ProxyHelpers 的 Trait，当然，这个函数是我根据我的业务逻辑自己封装的，如果不适合你的业务逻辑你可以自行调整。

<?php

namespace App\Http\Controllers\Traits;

use GuzzleHttp\Client;
use App\Exceptions\UnauthorizedException;
use GuzzleHttp\Exception\RequestException;

trait ProxyHelpers
{
 public function authenticate()
 {
  $client = new Client();
  try {
   $url = request()->root() . &#39;/api/oauth/token&#39;;
   $params = array_merge(config(&#39;passport.proxy&#39;), [
    &#39;username&#39; => request(&#39;email&#39;),
    &#39;password&#39; => request(&#39;password&#39;),
   ]);
   $respond = $client->request(&#39;POST&#39;, $url, [&#39;form_params&#39; => $params]);
  } catch (RequestException $exception) {
   throw new UnauthorizedException(&#39;请求失败，服务器错误&#39;);
  }
  if ($respond->getStatusCode() !== 401) {
   return json_decode($respond->getBody()->getContents(), true);
  }
  throw new UnauthorizedException(&#39;账号或密码错误&#39;);
 }
}

config/passport.php 内容如下

<?php
return [
 &#39;proxy&#39; => [
  &#39;grant_type&#39; => env(&#39;OAUTH_GRANT_TYPE&#39;),
  &#39;client_id&#39;  => env(&#39;OAUTH_CLIENT_ID&#39;),
  &#39;client_secret&#39; => env(&#39;OAUTH_CLIENT_SECRET&#39;),
  &#39;scope&#39;   => env(&#39;OAUTH_SCOPE&#39;, &#39;*&#39;),
 ],
];

env 文件内容如下

OAUTH_GRANT_TYPE=password
OAUTH_CLIENT_ID=2
OAUTH_CLIENT_SECRET=2HaTQJF33Sx98HjcKDiSVWZjrhVYGgkHGP8XLG1O
OAUTH_SCOPE=*

我们需要用到的 client token 是 id 为 2 的 client token，不要搞错了哟～

然后我们只需要在控制器中 use 这个 Trait，然后调用 $this->authenticate() 就可以得到认证成功的 token，如果请求失败的话，你可以使用 catch 来捕捉错误抛出异常。

 public function login(Request $request)
{
  $needs = $this->validate($request, rules('login'));
  $user = User::where('email', $needs['email'])->first();

  if (!$user) {
   throw new UnauthorizedException('此用户不存在');
  }
  $tokens = $this->authenticate();
  return succeed(['token' => $tokens, 'user' => new UserResource($user)]);
}

得到的 tokens 返回如以下格式

{
 "token_type": "Bearer",
 "expires_in": 31536000,
 "access_token": "token_str",
 "refresh_token": "token_str"
}

做完这一切后你就可以在前端向这样子请求服务端了

axios.post('yourdomain/login',login_form).then(resource => { 
})

如果请求成功，那么你将会得到 用户的信息和 access token，refresh token。

然后在你的前端 http 请求 header 里需要加入一个参数 Authorization

axios.defaults.headers.common['Authorization'] = token.token_type + ' ' + token.access_token

然后在你需要使用到 auth 认证的路由里使用中间件 auth:api，一切就大功告成啦～

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

Laravel5.2使用Captcha生成验证码实现登录的方法

关于Laravel中日期时间处理包Carbon的使用

关于laravel 5.1下php artisan migrate的使用

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!