Autorización de masterización en Laravel: ¿Puertas versus clases de políticas?

En una aplicación web moderna, controlar quién puede acceder o modificar los recursos es crucial. Por ejemplo, en una aplicación de blog, es posible que desee asegurarse de que solo el propietario de una publicación pueda editarla o eliminarla. Laravel ofrece dos formas elegantes de manejar la autorización: Puertas y Clases de políticas. Esta guía lo guiará a través de ambos métodos y le mostrará cómo proteger sus recursos y garantizar la seguridad de su aplicación.

¿Puertas en Laravel?

Las puertas proporcionan una manera rápida y sencilla de manejar la autorización mediante cierres. Son perfectos para comprobaciones de autorización simples y están definidos en AuthServiceProvider.

Configurar una puerta

Definamos una puerta para garantizar que solo el propietario de la publicación pueda actualizar o eliminar una publicación:

1. Defina la puerta: abra AuthServiceProvider y agregue las definiciones de su puerta:
   

   // 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. Aplicación de la puerta: use la puerta en los métodos de su controlador para hacer cumplir la lógica de autorización:
   

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

Pros y contras de las puertas

Ventajas:

• Simplicidad: Rápido de configurar con un código mínimo. ⚡
• Ideal para la simplicidad: perfecto para aplicaciones de un solo recurso o escenarios sencillos. ?

Contras:

• Escalabilidad: puede volverse engorroso y difícil de administrar a medida que su aplicación crece. ?
• Mantenimiento: Puede volverse complicado si no está bien organizado. ?

Mejor caso de uso: aplicaciones pequeñas o casos de uso simples donde se necesita una verificación de autorización rápida. ?

¿Clases de políticas en Laravel? ️

Las clases de políticas ofrecen un enfoque más estructurado y escalable para manejar la autorización. Proporcionan una forma clara de gestionar reglas de autorización complejas y mantener su código organizado. Las políticas son particularmente útiles cuando se trabaja con controladores de recursos que incluyen las operaciones CRUD estándar: index, create, edit, update y destruir.

Crear y utilizar una política

1. Generar la política: Crear una clase de política usando Artisan:
   

   php artisan make:policy PostPolicy
   

2. Definir métodos de política: abra la clase de política generada y agregue métodos para manejar la autorización para cada acción:
   

   // 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. Uso de la política: aplique los métodos de la política en las acciones de su controlador:
   

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

Pros y contras de las clases de pólizas

Ventajas:

• Organización: proporciona una forma limpia y organizada de manejar una lógica de autorización compleja. ?
• Mantenibilidad: Más fácil de administrar y mantener a medida que la aplicación crece. ?️
• Soporte de marco: aprovecha el soporte de marco integrado de Laravel para una autorización consistente. ?

Contras:

• Configuración inicial: Un poco más de configuración en comparación con las puertas. ⚙️
• Complejidad: Puede ser excesivo para escenarios de autorización muy simples. ?

Mejor escenario de caso: ideal para aplicaciones con requisitos de autorización complejos o cuando se busca un código limpio y fácil de mantener. ?

Resumen

Tanto las puertas como las clases de políticas en Laravel ofrecen formas poderosas de manejar la autorización. Las puertas son excelentes para comprobaciones rápidas y sencillas, mientras que las clases de políticas proporcionan un enfoque estructurado para gestionar escenarios complejos, especialmente en controladores de recursos con métodos como index, create, edit, actualizar y destruir. Elija el método que mejor se adapte a las necesidades de su aplicación y disfrute de un código base seguro y bien organizado. ??