Mastering-Autorisierung in Laravel: Gates vs. Police-Klassen ??

In einer modernen Webanwendung ist die Kontrolle darüber, wer auf Ressourcen zugreifen oder diese ändern kann, von entscheidender Bedeutung. In einer Blog-Anwendung möchten Sie beispielsweise sicherstellen, dass nur der Eigentümer eines Beitrags diesen bearbeiten oder löschen kann. Laravel bietet zwei elegante Möglichkeiten zur Autorisierung: Gates und Policy Classes. Dieser Leitfaden führt Sie durch beide Methoden und zeigt Ihnen, wie Sie Ihre Ressourcen schützen und die Sicherheit Ihrer Anwendung gewährleisten.

Tore in Laravel?

Gates bieten eine schnelle und unkomplizierte Möglichkeit, die Autorisierung mithilfe von Schließungen abzuwickeln. Sie eignen sich perfekt für einfache Berechtigungsprüfungen und werden im AuthServiceProvider definiert.

Ein Tor aufstellen

Lassen Sie uns ein Tor definieren, um sicherzustellen, dass nur der Beitragseigentümer einen Beitrag aktualisieren oder löschen kann:

1. Definieren Sie das Gate: Öffnen Sie AuthServiceProvider und fügen Sie Ihre Gate-Definitionen hinzu:
   

   // 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. Anwenden des Gates: Verwenden Sie das Gate in Ihren Controller-Methoden, um die Autorisierungslogik durchzusetzen:
   

   // 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
   }
   

Vor- und Nachteile von Gates

Vorteile:

• Einfachheit: Schnelle Einrichtung mit minimalem Code. ⚡
• Ideal für Einfachheit: Perfekt für Anwendungen mit einer einzigen Ressource oder einfache Szenarien. ?

Nachteile:

• Skalierbarkeit: Kann umständlich und schwierig zu verwalten sein, wenn Ihre Anwendung wächst. ?
• Wartung: Kann unordentlich werden, wenn es nicht gut organisiert ist. ?

Bester Anwendungsfall: Kleine Anwendungen oder einfache Anwendungsfälle, bei denen eine schnelle Berechtigungsprüfung erforderlich ist. ?

Versicherungsklassen in Laravel ?️

Richtlinienklassen bieten einen strukturierteren und skalierbareren Ansatz für die Handhabung von Autorisierungen. Sie bieten eine klare Möglichkeit, komplexe Autorisierungsregeln zu verwalten und Ihren Code zu organisieren. Richtlinien sind besonders nützlich, wenn Sie mit Ressourcencontrollern arbeiten, die die Standard-CRUD-Operationen umfassen: index, create, edit, update und zerstören.

Erstellen und Verwenden einer Richtlinie

1. Generieren Sie die Richtlinie: Erstellen Sie eine Richtlinienklasse mit Artisan:
   

   php artisan make:policy PostPolicy
   

2. Richtlinienmethoden definieren: Öffnen Sie die generierte Richtlinienklasse und fügen Sie Methoden hinzu, um die Autorisierung für jede Aktion zu verwalten:
   

   // 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. Verwenden der Richtlinie: Wenden Sie die Richtlinienmethoden in Ihren Controller-Aktionen an:
   

   // 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
   }
   

Vor- und Nachteile von Versicherungsklassen

Vorteile:

• Organisation: Bietet eine saubere und organisierte Möglichkeit, komplexe Autorisierungslogik zu handhaben. ?
• Wartbarkeit: Einfachere Verwaltung und Wartung, wenn die Anwendung wächst. ?️
• Framework-Unterstützung: Nutzt die integrierte Framework-Unterstützung von Laravel für eine konsistente Autorisierung. ?

Nachteile:

• Ersteinrichtung: Etwas mehr Einrichtung im Vergleich zu Toren. ⚙️
• Komplexität: Kann für sehr einfache Autorisierungsszenarien übertrieben sein. ?

Best-Case-Szenario: Ideal für Anwendungen mit komplexen Autorisierungsanforderungen oder wenn sauberer, wartbarer Code angestrebt wird. ?

Zusammenfassung

Sowohl Gates als auch Policy-Klassen in Laravel bieten leistungsstarke Möglichkeiten zur Autorisierung. Gates eignen sich hervorragend für schnelle, einfache Prüfungen, während Policy-Klassen einen strukturierten Ansatz für die Verwaltung komplexer Szenarien bieten, insbesondere in Ressourcencontrollern mit Methoden wie index, create, edit, update und destroy. Wählen Sie die Methode, die den Anforderungen Ihrer Anwendung am besten entspricht, und profitieren Sie von einer sicheren, gut organisierten Codebasis! ??