Le système d'autorisation de Laravel contrôle ce qu'un utilisateur authentifié est autorisé à faire (distinct de l'authentification — qui il est). Les Gates sont des simples closures pour les permissions ; les Policies sont des classes qui organisent la logique d'autorisation autour d'un modèle spécifique (par ex. qui peut mettre à jour un Post).
// define a gate (e.g. in a service provider)
Gate::define('edit-settings', fn($user) => $user->isAdmin());
// check it
if (Gate::allows('edit-settings')) { ... }
Gate::authorize('edit-settings'); // throws a 403 if denied
Les Gates sont utiles pour les permissions simples et autonomes non liées à un modèle spécifique.
<?php
// php artisan make:policy PostPolicy --model=Post
class PostPolicy {
public function update(User $user, Post $post): bool {
return $user->id === $post->user_id; // only the author can update
}
public function delete(User $user, Post $post): bool {
return $user->id === $post->user_id || $user->isAdmin();
}
}
Une classe Policy regroupe les règles d'autorisation pour un modèle — chaque méthode répond « cet utilisateur peut-il effectuer cette action sur ce modèle ? ». Cela maintient la logique d'autorisation organisée par ressource.
// in a controller
public function update(Request $request, Post $post) {
$this->authorize('update', $post); // checks PostPolicy::update — throws 403 if denied
// ... proceed (we know the user is authorized)
}
// the user model
if ($request->user()->can('update', $post)) { ... }
{{-- in Blade — show UI only if authorized --}}
@can('update', $post)
<a href="{{ route('posts.edit', $post) }}">Edit</a>
@endcan
Les méthodes authorize()/can() (et @can dans Blade) vérifient automatiquement la policy — levant une 403 ou masquant l'interface utilisateur quand l'utilisateur n'est pas autorisé.
L'autorisation est essentielle et critique pour la sécurité — contrôler ce que les utilisateurs authentifiés sont autorisés à faire (pas seulement s'ils sont connectés) est fondamental pour la sécurité de l'application, et les policies et gates de Laravel fournissent un moyen propre et organisé de le gérer.
Comprendre la distinction entre authentification (qui vous êtes — connexion) et autorisation (ce que vous pouvez faire — permissions) est fondamental, et les défaillances d'autorisation conduisent à des vulnérabilités graves (utilisateurs accédant ou modifiant des données qu'ils ne devraient pas — le contrôle d'accès brisé est un risque de sécurité majeur).
Le système de Laravel offre deux outils complémentaires : les Gates pour les permissions simples et autonomes (vérifications basées sur des closures), et les Policies — l'approche courante et recommandée — qui organisent les règles d'autorisation d'un modèle dans une classe dédiée (par ex. qui peut mettre à jour ou supprimer un Post), maintenant la logique d'autorisation structurée et maintenable par ressource.
Comprendre comment définir des policies/gates et les appliquer ($this->authorize(), $user->can(), @can dans Blade — vérifier les permissions dans les contrôleurs, lever des 403, et afficher l'interface utilisateur conditionnellement) est important pour construire des applications sécurisées où les utilisateurs ne peuvent effectuer que les actions autorisées.
Puisque presque chaque application réelle a besoin d'un contrôle d'accès fin (garantir que les utilisateurs ne peuvent modifier que leurs propres ressources, restreindre les actions admin, etc.), et puisque mal gérer l'autorisation crée des failles de sécurité dangereuses, connaître les policies et gates de Laravel — la manière appropriée et organisée d'implémenter l'autorisation — est une connaissance importante pertinente pour les seniors qui est essentielle pour construire des applications qui appliquent correctement qui peut faire quoi, une exigence fréquente et critique dans les systèmes réels.