Maîtriser l'autorisation dans Laravel : Gates vs. Policy Classes ??

Dans une application Web moderne, contrôler qui peut accéder ou modifier les ressources est crucial. Par exemple, dans une application de blog, vous souhaiterez peut-être vous assurer que seul le propriétaire d'une publication peut la modifier ou la supprimer. Laravel propose deux manières élégantes de gérer les autorisations : Gates et Policy Classes. Ce guide vous guidera à travers les deux méthodes, vous montrant comment protéger vos ressources et assurer la sécurité de votre application.

Des portes à Laravel ?

Les portes offrent un moyen rapide et simple de gérer les autorisations à l'aide de fermetures. Ils sont parfaits pour les contrôles d’autorisation simples et sont définis dans AuthServiceProvider.

Installer une porte

Définissons une porte pour garantir que seul le propriétaire de la publication peut mettre à jour ou supprimer une publication :

1. Définissez la porte : ouvrez AuthServiceProvider et ajoutez vos définitions de porte :
   

   // app/Providers/AuthServiceProvider.php
   
   use Illuminate\Support\Facades\Gate;
   use App\Models\Post;
   
   public function boot()
   {
       $this->registerPolicies();
   
       Gate::define('update-post', function ($user, Post $post) {
           return $user->id === $post->user_id;
       });
   
       Gate::define('delete-post', function ($user, Post $post) {
           return $user->id === $post->user_id;
       });
   }
   

2. Application de la porte : utilisez la porte dans les méthodes de votre contrôleur pour appliquer la logique d'autorisation :
   

   // app/Http/Controllers/PostController.php
   
   use Illuminate\Http\Request;
   use Illuminate\Support\Facades\Gate;
   use App\Models\Post;
   
   public function update(Request $request, Post $post)
   {
       if (Gate::denies('update-post', $post)) {
           abort(403, 'You do not own this post. ?');
       }
   
       // Proceed with updating the post
   }
   
   public function destroy(Post $post)
   {
       if (Gate::denies('delete-post', $post)) {
           abort(403, 'You do not own this post. ?');
       }
   
       // Proceed with deleting the post
   }
   

Avantages et inconvénients des portes

Avantages :

• Simplicité : rapide à configurer avec un minimum de code. ⚡
• Idéal pour la simplicité : parfait pour les applications à ressource unique ou les scénarios simples. ?

Inconvénients :

• Évolutivité : peut devenir fastidieuse et difficile à gérer à mesure que votre application se développe. ?
• Entretien : peut devenir compliqué s'il n'est pas bien organisé. ?

Meilleur cas d'utilisation : petites applications ou cas d'utilisation simples où une vérification rapide des autorisations est nécessaire. ?

Cours de politique à Laravel ?️

Les classes de stratégie offrent une approche plus structurée et évolutive de la gestion des autorisations. Ils offrent un moyen clair de gérer des règles d'autorisation complexes et de garder votre code organisé. Les stratégies sont particulièrement utiles lorsque vous travaillez avec des contrôleurs de ressources qui incluent les opérations CRUD standard : index, create, edit, update et détruire.

Création et utilisation d'une stratégie

1. Générer la stratégie : créez une classe de stratégie à l'aide d'Artisan :
   

   php artisan make:policy PostPolicy
   

2. Définir les méthodes de stratégie : ouvrez la classe de stratégie générée et ajoutez des méthodes pour gérer l'autorisation pour chaque action :
   

   // app/Policies/PostPolicy.php
   
   namespace App\Policies;
   
   use App\Models\User;
   use App\Models\Post;
   
   class PostPolicy
   {
       /**
        * Determine if the user can view the list of posts.
        *
        * @param User $user
        * @return bool
        */
       public function viewAny(User $user)
       {
           // Example logic to allow viewing posts for authenticated users
           return true;
       }
   
       /**
        * Determine if the user can create a post.
        *
        * @param User $user
        * @return bool
        */
       public function create(User $user)
       {
           return true;
       }
   
       /**
        * Determine if the user can update the post.
        *
        * @param User $user
        * @param Post $post
        * @return bool
        */
       public function update(User $user, Post $post)
       {
           return $user->id === $post->user_id;
       }
   
       /**
        * Determine if the user can delete the post.
        *
        * @param User $user
        * @param Post $post
        * @return bool
        */
       public function delete(User $user, Post $post)
       {
           return $user->id === $post->user_id;
       }
   }
   

3. Utilisation de la stratégie : appliquez les méthodes de stratégie dans les actions de votre contrôleur :
   

   // app/Http/Controllers/PostController.php
   
   use Illuminate\Http\Request;
   use App\Models\Post;
   
   public function update(Request $request, Post $post)
   {
       $this->authorize('update', $post);
       // Proceed with updating the post
   }
   
   public function destroy(Post $post)
   {
       $this->authorize('delete', $post);
       // Proceed with deleting the post
   }
   

Avantages et inconvénients des classes de stratégie

Avantages :

• Organisation : fournit un moyen propre et organisé de gérer une logique d'autorisation complexe. ?
• Maintenabilité : plus facile à gérer et à maintenir à mesure que l'application se développe. ?️
• Prise en charge du framework : exploite la prise en charge du framework intégré de Laravel pour une autorisation cohérente. ?

Inconvénients :

• Configuration initiale : Légèrement plus de configuration par rapport aux portails. ⚙️
• Complexité : peut s'avérer excessif pour des scénarios d'autorisation très simples. ?

Meilleur scénario : idéal pour les applications avec des exigences d'autorisation complexes ou lorsque l'on vise un code propre et maintenable. ?

Résumé

Les portes et les classes de stratégie dans Laravel offrent des moyens puissants de gérer les autorisations. Les portes sont excellentes pour des vérifications simples et rapides, tandis que les classes de stratégie fournissent une approche structurée pour gérer des scénarios complexes, en particulier dans les contrôleurs de ressources avec des méthodes telles que index, create, edit, mettre à jour et détruire. Choisissez la méthode qui correspond le mieux aux besoins de votre application et profitez d’une base de code sécurisée et bien organisée ! ??