Dès qu'une application Symfony dépasse "admin peut tout faire, utilisateur peut voir ses propres données", les if ($user->getId() === $post->getAuthorId()) commencent à se disperser dans les contrôleurs, puis dans les templates Twig, puis dans les commandes console. Le jour où la règle change (ajouter un rôle de modérateur, autoriser l'édition pendant 24h seulement après publication), il faut retrouver toutes ces occurrences, et il en manque toujours une. Les Voters existent précisément pour éviter ce scénario.
Le problème concret
Un blog multi-auteurs avec rôles ROLE_USER, ROLE_EDITOR et ROLE_ADMIN. La règle métier : un auteur peut éditer son propre article tant qu'il n'est pas publié ; un éditeur peut éditer n'importe quel article, publié ou non ; un admin peut tout faire, y compris supprimer. Cette règle doit s'appliquer de façon identique dans le contrôleur (refuser l'accès à la route d'édition), dans le template (cacher le bouton "Modifier" si l'action est refusée) et potentiellement dans une commande CLI d'administration.
Pourquoi disperser la logique d'autorisation casse à l'usage
Le problème n'est pas seulement esthétique. Une règle d'autorisation dupliquée dans N endroits a N occasions de diverger silencieusement :
- Le contrôleur vérifie
$user === $post->getAuthor(), mais le template vérifie justeis_granted('ROLE_EDITOR'), ce qui autorise visuellement un bouton que le contrôleur refusera ensuite, ou pire, l'inverse : affiche un bouton qui fonctionne par erreur parce qu'un contrôleur annexe a oublié la vérification. - Une nouvelle route (export PDF, duplication d'article) est ajoutée sans reprendre la vérification existante, parce que le développeur ne sait pas où elle vit exactement.
- Les tests unitaires de la règle métier n'existent nulle part de façon isolée, puisque la règle est mélangée à la logique HTTP du contrôleur.
Un Voter centralise la décision "ce sujet, pour cet utilisateur, peut-il faire cette action" en un seul endroit testable indépendamment du framework HTTP.
Construire le Voter
<?php
// src/Security/Voter/PostVoter.php
namespace App\Security\Voter;
use App\Entity\Post;
use App\Entity\User;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\Voter\Voter;
class PostVoter extends Voter
{
public const EDIT = 'POST_EDIT';
public const DELETE = 'POST_DELETE';
public const VIEW = 'POST_VIEW';
protected function supports(string $attribute, mixed $subject): bool
{
return in_array($attribute, [self::EDIT, self::DELETE, self::VIEW], true)
&& $subject instanceof Post;
}
protected function voteOnAttribute(string $attribute, mixed $subject, TokenInterface $token): bool
{
$user = $token->getUser();
if (!$user instanceof User) {
return false; // utilisateur non authentifié : refus par défaut
}
/** @var Post $post */
$post = $subject;
return match ($attribute) {
self::VIEW => $post->isPublished() || $this->isOwnerOrEditor($post, $user),
self::EDIT => $this->canEdit($post, $user),
self::DELETE => in_array('ROLE_ADMIN', $user->getRoles(), true),
default => false,
};
}
private function canEdit(Post $post, User $user): bool
{
if (in_array('ROLE_ADMIN', $user->getRoles(), true)
|| in_array('ROLE_EDITOR', $user->getRoles(), true)) {
return true;
}
return $post->getAuthor() === $user && !$post->isPublished();
}
private function isOwnerOrEditor(Post $post, User $user): bool
{
return $post->getAuthor() === $user
|| in_array('ROLE_EDITOR', $user->getRoles(), true);
}
}
Le point clé de supports() : il ne traite que les attributs et le type de sujet qu'il connaît, et renvoie false sinon, pour laisser le AccessDecisionManager de Symfony interroger d'autres Voters éventuels sans conflit. voteOnAttribute() ne doit jamais lever d'exception pour un cas non géré : un match avec un default => false explicite évite qu'un attribut oublié n'autorise accidentellement une action.
Utiliser le Voter dans le contrôleur
#[Route('/post/{id}/edit', name: 'post_edit')]
public function edit(Post $post, Request $request): Response
{
$this->denyAccessUnlessGranted(PostVoter::EDIT, $post);
// ... logique d'édition, atteinte seulement si l'accès est accordé
}
denyAccessUnlessGranted lève une AccessDeniedException (traduite en 403 par Symfony) si le Voter refuse, sans avoir à écrire de condition explicite dans le contrôleur. La règle métier devient un appel d'une ligne, identique pour toutes les routes concernées.
Utiliser le Voter dans Twig
{% if is_granted('POST_EDIT', post) %}
<a href="{{ path('post_edit', {id: post.id}) }}">Modifier</a>
{% endif %}
{% if is_granted('POST_DELETE', post) %}
<a href="{{ path('post_delete', {id: post.id}) }}" class="text-danger">Supprimer</a>
{% endif %}
La fonction Twig is_granted() appelle exactement le même Voter que le contrôleur. C'est ce qui élimine la divergence entre "ce que le bouton affiche" et "ce que le contrôleur autorise réellement" : il n'y a plus qu'une seule source de vérité pour la règle.
Tester le Voter de façon isolée
// tests/Security/Voter/PostVoterTest.php
public function testAuthorCanEditUnpublishedPost(): void
{
$author = new User();
$post = (new Post())->setAuthor($author)->setPublished(false);
$token = new UsernamePasswordToken($author, 'main', ['ROLE_USER']);
$voter = new PostVoter();
$this->assertSame(
VoterInterface::ACCESS_GRANTED,
$voter->vote($token, $post, [PostVoter::EDIT]),
);
}
public function testAuthorCannotEditPublishedPost(): void
{
$author = new User();
$post = (new Post())->setAuthor($author)->setPublished(true);
$token = new UsernamePasswordToken($author, 'main', ['ROLE_USER']);
$voter = new PostVoter();
$this->assertSame(
VoterInterface::ACCESS_DENIED,
$voter->vote($token, $post, [PostVoter::EDIT]),
);
}
C'est ce bénéfice qui justifie le détour : la règle métier d'autorisation devient testable en isolation complète, sans monter le kernel HTTP, sans fixtures de base de données, juste des objets PHP et des assertions.
Les compromis
- Voter unique vs multiple Voters par entité : un seul Voter par type d'entité (comme ci-dessus) reste lisible jusqu'à une dizaine d'attributs. Au-delà, ou si la logique de rôles devient transverse à plusieurs entités (ex. "un modérateur peut tout modérer"), il vaut mieux extraire cette logique dans un service dédié injecté dans plusieurs Voters, plutôt que de dupliquer
in_array('ROLE_ADMIN', ...)partout. voteOnAttributeavec logique métier directe vs délégation à l'entité : mettre$post->isPublished()dans le Voter est acceptable pour une règle de visibilité simple. Si la règle devient complexe (fenêtre de 24h, état de workflow avec plusieurs transitions), il est préférable de déléguer à une méthode de l'entité ou à un service métier dédié, pour garder le Voter en simple point d'orchestration et pas dépositaire de règles métier non testées ailleurs.- Stratégie du
AccessDecisionManager: par défaut Symfony utiliseaffirmative(un seul Voter qui accorde suffit). Si plusieurs Voters peuvent s'appliquer au même attribut avec des avis contradictoires, la stratégieunanimousest plus sûre pour des permissions sensibles, au prix d'une configuration plus stricte à revoir si un nouveau Voter est ajouté.
Quand les Voters ne suffisent plus
Les Voters couvrent très bien l'autorisation au niveau d'une entité ou d'une action ponctuelle. Pour un système de permissions configurable par l'utilisateur final (ACL fine, partage de ressources avec des permissions custom par équipe, à la manière de Google Drive), la complexité dépasse ce que des Voters codés en dur peuvent raisonnablement exprimer : il faut alors un modèle de permissions en base de données, avec son propre moteur de résolution, les Voters ne faisant plus qu'interroger ce modèle plutôt que porter la règle en dur dans le code PHP.
Factoriser une règle transverse dans un service dédié
Dans un vrai projet, plusieurs entités partagent souvent la même notion de "propriétaire" ou de "rôle privilégié". Dupliquer in_array('ROLE_ADMIN', ...) dans chaque Voter fonctionne au début, puis devient une source de divergence dès qu'un rôle intermédiaire (ROLE_MODERATOR) doit être ajouté à certains Voters et pas à d'autres par erreur d'oubli.
// src/Security/PermissionResolver.php
namespace App\Security;
use App\Entity\User;
class PermissionResolver
{
public function hasElevatedAccess(User $user): bool
{
return array_intersect(['ROLE_ADMIN', 'ROLE_EDITOR'], $user->getRoles()) !== [];
}
public function isOwner(User $user, object $subject): bool
{
return method_exists($subject, 'getAuthor') && $subject->getAuthor() === $user;
}
}
class PostVoter extends Voter
{
public function __construct(private PermissionResolver $permissions) {}
private function canEdit(Post $post, User $user): bool
{
if ($this->permissions->hasElevatedAccess($user)) {
return true;
}
return $this->permissions->isOwner($user, $post) && !$post->isPublished();
}
}
Ce découplage a un effet secondaire utile : PermissionResolver devient injectable et testable indépendamment de n'importe quel Voter, et un nouveau Voter sur une autre entité (commentaires, pièces jointes) réutilise la même logique de rôle élevé sans la recopier.
Un piège fréquent : vérifier l'autorisation après avoir déjà chargé la ressource
Un détail d'implémentation qui revient souvent en revue de code : charger la ressource avant de vérifier l'autorisation expose, même brièvement, un éventuel comportement métier (envoi d'un e-mail de notification, incrémentation d'un compteur de vues) à un utilisateur qui n'aurait jamais dû accéder à cette ressource.
#[Route('/post/{id}', name: 'post_show')]
public function show(Post $post): Response
{
// Mauvais ordre : l'EventSubscriber sur postLoad a déjà pu s'exécuter
$this->denyAccessUnlessGranted(PostVoter::VIEW, $post);
return $this->render('post/show.html.twig', ['post' => $post]);
}
Avec le ParamConverter de Symfony, l'entité est hydratée avant même d'entrer dans le corps de la méthode, donc tout événement Doctrine lié au chargement (postLoad) s'exécute avant la vérification du Voter. Si un tel événement a un effet de bord métier, il faut soit déplacer la vérification d'autorisation plus tôt via un #[IsGranted] sur la route elle-même, soit s'assurer que les effets de bord liés au chargement restent strictement neutres.
#[Route('/post/{id}', name: 'post_show')]
#[IsGranted(PostVoter::VIEW, subject: 'post')]
public function show(Post $post): Response
{
return $this->render('post/show.html.twig', ['post' => $post]);
}
L'attribut #[IsGranted] ne change pas le moment exact de l'hydratation Doctrine, mais il rend la vérification visible dès la signature de la méthode, ce qui facilite l'audit en revue de code par rapport à un appel enfoui dans le corps de la fonction.
À retenir
Un Voter centralise une règle d'autorisation en un seul endroit interrogé de façon identique par le contrôleur, Twig et les commandes console, ce qui élimine la divergence silencieuse entre ce qu'affiche l'UI et ce qu'autorise réellement le backend. Le vrai gain n'est pas la syntaxe Symfony, c'est de rendre la règle métier testable indépendamment du framework HTTP.
