Architecture

RGPD et architecture applicative : ce qu’il faut anticiper dès la conception

RGPD et architecture logicielle : privacy by design, gestion des données personnelles, droits des utilisateurs, hébergement, audit. Le guide pour CTO et lead dev.

Mohamed A.
2 septembre 2026
16 min de lecture
RGPD et architecture applicative : ce qu’il faut anticiper dès la conception

Le RGPD n’est pas qu’un sujet juridique. Pour un CTO ou un lead dev, c’est avant tout une contrainte d’architecture : la conformité se joue autant dans le schéma de base de données, les flux de données et les choix d’infrastructure que dans la rédaction d’une politique de confidentialité.

Traiter le RGPD après la mise en production revient systématiquement à faire des compromis coûteux : migrations de schéma sous pression, refactoring de la couche de persistance, ou pire, incapacité technique à répondre à une demande de droit à l’oubli dans les délais légaux. L’approche « Privacy by Design » (article 25 du RGPD) impose au contraire de traduire les exigences légales en décisions techniques dès la phase de conception.

Cet article détaille les décisions d’architecture à anticiper, avec des exemples concrets d’implémentation sur un stack Symfony — l’un des frameworks les plus adaptés à ce type d’exigence grâce à la richesse de son écosystème (Doctrine, Messenger, Serializer, Security).

1. Traduire le RGPD en exigences techniques

Le RGPD repose sur des principes juridiques qui ont chacun une traduction directe en architecture logicielle :

Principe RGPDTraduction technique
Minimisation des donnéesModélisation stricte des entités, pas de champs « au cas où »
Limitation de la conservationPolitique de purge automatisée, TTL sur les données
Intégrité et confidentialitéChiffrement at-rest et in-transit, contrôle d’accès
Droit d’accès / portabilitéEndpoints d’export structurés, sérialisation maîtrisée
Droit à l’effacementProcédures d’anonymisation/suppression en cascade
ConsentementTraçabilité horodatée et versionnée du consentement
Responsabilité (accountability)Logs d’audit, traçabilité des accès aux données sensibles

Un CTO doit pouvoir répondre, pour chaque donnée personnelle stockée : pourquoi je la collecte, combien de temps je la garde, qui peut y accéder, comment je la supprime, comment je la chiffre. Si l’architecture ne permet pas de répondre à ces questions rapidement, c’est un signal qu’il faut revoir la conception.

2. Cartographier les données avant d’écrire la moindre entité

Avant toute implémentation, il faut établir un registre technique des données personnelles (au-delà du registre RGPD légal tenu par le DPO). Concrètement, cela veut dire classer chaque champ selon sa sensibilité :

  • Données d’identification directe : nom, email, téléphone
  • Données sensibles (article 9) : santé, origine, opinions — nécessitent un traitement renforcé
  • Données techniques identifiantes : adresse IP, identifiants de session, cookies
  • Données dérivées : scoring, profilage, historique de comportement

Cette classification guide directement les choix Doctrine : quels champs chiffrer, quels champs exclure des exports de logs, quels champs anonymiser en priorité lors d’une purge.

3. Minimisation des données dans le modèle Doctrine

La minimisation commence dans l’entité elle-même. Un exemple typique d’anti-pattern est de stocker une date de naissance complète quand seule une tranche d’âge est nécessaire fonctionnellement.

php
// src/Entity/User.php
#[ORM\Entity]
class User
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;
 
    #[ORM\Column(length: 180, unique: true)]
    private string $email;
 
    // Minimisation : on stocke une tranche d'âge, pas la date de naissance
    #[ORM\Column(enumType: AgeRange::class)]
    private AgeRange $ageRange;
 
    // Champ chiffré (voir section 4)
    #[ORM\Column(type: EncryptedTextType::NAME, nullable: true)]
    private ?string $phoneNumber = null;
 
    #[ORM\Column]
    private \DateTimeImmutable $createdAt;
 
    // Champ obligatoire pour la politique de rétention
    #[ORM\Column(nullable: true)]
    private ?\DateTimeImmutable $anonymizedAt = null;
}

Chaque champ personnel doit pouvoir justifier sa présence. En revue de code, ajouter une checklist RGPD sur les migrations Doctrine (php bin/console make:migration) permet de matérialiser cette discipline en équipe.

4. Chiffrement des données sensibles avec un Doctrine Type custom

Plutôt que de chiffrer manuellement chaque champ dans les services métier (source d’oublis), la bonne pratique sur Symfony est de créer un Doctrine Type personnalisé qui chiffre/déchiffre de manière transparente au niveau de la couche de persistance.

php
// src/Doctrine/Type/EncryptedTextType.php
namespace App\Doctrine\Type;
 
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\StringType;
 
class EncryptedTextType extends StringType
{
    public const NAME = 'encrypted_text';
 
    public function convertToDatabaseValue($value, AbstractPlatform $platform): ?string
    {
        if ($value === null) {
            return null;
        }
 
        return EncryptionService::encrypt($value);
    }
 
    public function convertToPHPValue($value, AbstractPlatform $platform): ?string
    {
        if ($value === null) {
            return null;
        }
 
        return EncryptionService::decrypt($value);
    }
 
    public function getName(): string
    {
        return self::NAME;
    }
}
php
// src/Service/EncryptionService.php
namespace App\Doctrine\Type;
 
final class EncryptionService
{
    private static string $key; // injectée via un compiler pass ou un paramètre statique sécurisé
 
    public static function encrypt(string $plainText): string
    {
        $nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
        $cipher = sodium_crypto_secretbox($plainText, $nonce, self::$key);
 
        return base64_encode($nonce . $cipher);
    }
 
    public static function decrypt(string $encoded): string
    {
        $decoded = base64_decode($encoded);
        $nonce = substr($decoded, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
        $cipher = substr($decoded, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
 
        return sodium_crypto_secretbox_open($cipher, $nonce, self::$key);
    }
}

L’enregistrement du type se fait dans config/packages/doctrine.yaml :

yaml
doctrine:
    dbal:
        types:
            encrypted_text: App\Doctrine\Type\EncryptedTextType

Points d’attention pour un CTO :

  • La clé de chiffrement ne doit jamais être versionnée : passer par un vault (Hashicorp Vault, AWS KMS, ou a minima des variables d’environnement gérées via Symfony Secrets bin/console secrets:set).
  • Un champ chiffré ainsi n’est plus indexable ni recherchable en base — cela doit être arbitré en amont avec l’équipe produit.
  • Cette approche protège la confidentialité « at rest » ; elle ne dispense pas de sécuriser les flux « in transit » (TLS obligatoire de bout en bout, y compris entre services internes).

5. Le droit à l’effacement : anonymisation plutôt que suppression brute

Supprimer purement et simplement un utilisateur casse souvent l’intégrité référentielle (commandes, factures, logs métier). La pratique recommandée est l’anonymisation irréversible plutôt que le DELETE en cascade, sauf obligation légale contraire.

php
// src/Service/Gdpr/UserAnonymizer.php
namespace App\Service\Gdpr;
 
use App\Entity\User;
use Doctrine\ORM\EntityManagerInterface;
 
final class UserAnonymizer
{
    public function __construct(private EntityManagerInterface $em) {}
 
    public function anonymize(User $user): void
    {
        $anonymousId = bin2hex(random_bytes(8));
 
        $user->setEmail("anonymized-{$anonymousId}@deleted.local");
        $user->setPhoneNumber(null);
        $user->setFirstName('Anonyme');
        $user->setLastName('Anonyme');
        $user->setAnonymizedAt(new \DateTimeImmutable());
 
        // Les entités liées (commandes, tickets) conservent une clé étrangère
        // vers un utilisateur anonymisé, sans donnée personnelle résiduelle.
 
        $this->em->flush();
    }
}

Cette logique est ensuite exposée via une commande Symfony, déclenchable manuellement par le DPO ou automatiquement via un workflow (formulaire de demande RGPD → ticket → validation → exécution) :

php
// src/Command/GdprAnonymizeUserCommand.php
namespace App\Command;
 
use App\Repository\UserRepository;
use App\Service\Gdpr\UserAnonymizer;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
 
#[AsCommand(name: 'gdpr:anonymize-user', description: 'Anonymise un utilisateur suite à une demande RGPD')]
class GdprAnonymizeUserCommand extends Command
{
    public function __construct(
        private UserRepository $userRepository,
        private UserAnonymizer $anonymizer,
    ) {
        parent::__construct();
    }
 
    protected function configure(): void
    {
        $this->addArgument('userId', InputArgument::REQUIRED);
    }
 
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $user = $this->userRepository->find($input->getArgument('userId'));
 
        if (!$user) {
            $output->writeln('<error>Utilisateur introuvable.</error>');
            return Command::FAILURE;
        }
 
        $this->anonymizer->anonymize($user);
        $output->writeln('<info>Utilisateur anonymisé avec succès.</info>');
 
        return Command::SUCCESS;
    }
}

Le RGPD impose un délai de traitement d’un mois maximum pour ce type de demande (article 12). Avoir cette commande prête en amont, plutôt que de la développer dans l’urgence à la première demande utilisateur, fait gagner un temps précieux.

6. Limitation de la conservation : purge automatisée

Chaque type de donnée doit avoir une durée de conservation définie et appliquée techniquement — pas seulement documentée dans une politique de confidentialité. Avec le composant Symfony Scheduler, il est possible d’automatiser cette purge :

php
// src/Scheduler/GdprRetentionSchedule.php
namespace App\Scheduler;
 
use App\Message\PurgeExpiredDataMessage;
use Symfony\Component\Scheduler\Attribute\AsSchedule;
use Symfony\Component\Scheduler\RecurringMessage;
use Symfony\Component\Scheduler\Schedule;
use Symfony\Component\Scheduler\ScheduleProviderInterface;
 
#[AsSchedule('gdpr')]
class GdprRetentionSchedule implements ScheduleProviderInterface
{
    public function getSchedule(): Schedule
    {
        return (new Schedule())
            ->add(
                RecurringMessage::cron('0 3 * * *', new PurgeExpiredDataMessage())
            );
    }
}

Le message est ensuite traité par un handler qui applique la politique de rétention propre à chaque entité (ex : logs de connexion conservés 12 mois, paniers abandonnés anonymisés après 90 jours) :

php
// src/MessageHandler/PurgeExpiredDataHandler.php
namespace App\MessageHandler;
 
use App\Message\PurgeExpiredDataMessage;
use App\Repository\UserRepository;
use App\Service\Gdpr\UserAnonymizer;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
 
#[AsMessageHandler]
class PurgeExpiredDataHandler
{
    private const INACTIVITY_THRESHOLD_DAYS = 730; // 24 mois
 
    public function __construct(
        private UserRepository $userRepository,
        private UserAnonymizer $anonymizer,
    ) {}
 
    public function __invoke(PurgeExpiredDataMessage $message): void
    {
        $threshold = new \DateTimeImmutable('-' . self::INACTIVITY_THRESHOLD_DAYS . ' days');
        $inactiveUsers = $this->userRepository->findInactiveSince($threshold);
 
        foreach ($inactiveUsers as $user) {
            $this->anonymizer->anonymize($user);
        }
    }
}

Cette approche transforme une exigence de conformité en un job d’infrastructure classique, testable et supervisable comme n’importe quel batch métier.

7. Consentement : le tracer, le versionner, l’exposer

Le consentement ne peut pas être un simple booléen hasConsented = true. Il doit être horodaté, versionné (le texte de la politique de confidentialité évolue) et révocable.

php
// src/Entity/ConsentRecord.php
#[ORM\Entity]
class ConsentRecord
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;
 
    #[ORM\ManyToOne(targetEntity: User::class)]
    private User $user;
 
    #[ORM\Column(length: 50)]
    private string $purpose; // ex: "newsletter", "cookies_analytics"
 
    #[ORM\Column(length: 20)]
    private string $policyVersion; // ex: "v2.3"
 
    #[ORM\Column]
    private bool $granted;
 
    #[ORM\Column]
    private \DateTimeImmutable $recordedAt;
 
    #[ORM\Column(nullable: true)]
    private ?string $ipAddress = null;
}

Un enregistrement par finalité (purpose) permet de gérer indépendamment le consentement marketing, l’usage de cookies analytiques, ou le partage avec des tiers — conformément au principe de granularité exigé par la CNIL.

8. Traçabilité et logs d’audit

L’article 5.2 du RGPD (accountability) impose de pouvoir démontrer la conformité, pas seulement de l’affirmer. Techniquement, cela implique de tracer qui accède à quelle donnée personnelle et quand — en particulier côté back-office/admin.

Le bundle gedmo/doctrine-extensions (extension Loggable) permet d’implémenter cela rapidement :

php
// src/Entity/User.php
use Gedmo\Mapping\Annotation as Gedmo;
 
#[ORM\Entity]
#[Gedmo\Loggable]
class User
{
    #[ORM\Column(length: 180)]
    #[Gedmo\Versioned]
    private string $email;
    // ...
}

Pour les accès en lecture aux données sensibles (consultation d’un dossier client par un agent support, par exemple), un event listener sur les actions du back-office reste nécessaire : Gedmo trace les modifications, pas les consultations. Un EventSubscriber sur les contrôleurs d’administration, journalisant utilisateur + entité consultée + horodatage dans une table dédiée ou vers un outil de log centralisé (ELK, Datadog), complète le dispositif.

9. Portabilité des données : export structuré via le Serializer

Le droit à la portabilité (article 20) impose de fournir les données dans un format structuré et lisible par machine. Le composant Serializer de Symfony, avec des groupes dédiés, permet d’exposer exactement le périmètre de données concerné — ni plus, ni moins :

php
// src/Entity/User.php
use Symfony\Component\Serializer\Annotation\Groups;
 
class User
{
    #[Groups(['gdpr_export'])]
    private string $email;
 
    #[Groups(['gdpr_export'])]
    private string $firstName;
 
    // Les champs techniques internes (rôles, hash de mot de passe) sont exclus
    private string $password;
}
php
// src/Controller/Api/GdprExportController.php
#[Route('/api/account/gdpr-export', methods: ['GET'])]
public function export(SerializerInterface $serializer): JsonResponse
{
    $user = $this->getUser();
    $json = $serializer->serialize($user, 'json', ['groups' => 'gdpr_export']);
 
    return new JsonResponse($json, json: true);
}

Cette approche évite l’écueil classique où un développeur, sous pression pour livrer une fonctionnalité d’export, sérialise l’entité entière — exposant potentiellement des champs internes non destinés à l’utilisateur.

10. Environnements de développement et de test : ne jamais dupliquer la prod telle quelle

Un point souvent négligé : copier la base de production vers un environnement de staging ou de recette expose les mêmes données personnelles avec un niveau de sécurité généralement plus faible. La bonne pratique consiste à générer un jeu de données anonymisé pour ces environnements, via une commande dédiée exécutée après tout import :

php
#[AsCommand(name: 'app:anonymize-dataset', description: 'Anonymise un dump pour les environnements non-prod')]
class AnonymizeDatasetCommand extends Command
{
    // Remplace emails, téléphones, noms par des valeurs générées (ex: Faker)
    // tout en conservant la cohérence relationnelle du jeu de données.
}

Cette contrainte doit être intégrée dans le pipeline CI/CD dès la mise en place de l’infrastructure, pas ajoutée après un incident.

11. Hébergement et sous-traitants : une décision d’architecture, pas seulement contractuelle

Le choix de l’hébergeur, du fournisseur d’emailing, ou de la solution d’analytics a un impact RGPD direct via les transferts de données hors UE. Un CTO doit intégrer ce critère dans les choix techniques dès la sélection des outils :

  • Privilégier des hébergeurs européens ou disposant de clauses contractuelles types (SCC) à jour.
  • Vérifier la localisation des sauvegardes, pas seulement de la base primaire.
  • Documenter chaque sous-traitant technique traitant des données personnelles (CDN, service d’emailing transactionnel, outil de monitoring qui logue des IP).

Checklist CTO : RGPD dès la conception

  • Registre technique des données personnelles à jour, par entité et par champ
  • Politique de rétention définie et automatisée pour chaque type de donnée
  • Chiffrement en place pour les champs sensibles, gestion des clés externalisée
  • Procédure d’anonymisation testée et exécutable en moins d’un mois
  • Consentement tracé, versionné, granulaire par finalité
  • Logs d’audit sur les accès et modifications de données sensibles
  • Endpoint de portabilité limitant l’export au strict périmètre légal
  • Environnements non-prod alimentés par des données anonymisées
  • Cartographie des sous-traitants et de la localisation des données

Conclusion

Le RGPD, traité comme une contrainte d’architecture dès la conception, devient un exercice technique maîtrisable : classification des données, chiffrement transparent au niveau de la persistance, automatisation de la rétention et de l’anonymisation, traçabilité du consentement. Traité après coup, il se transforme en dette technique et en risque juridique.

L’écosystème Symfony — Doctrine, Messenger, Scheduler, Serializer — offre les briques nécessaires pour industrialiser cette conformité sans réinventer la roue à chaque projet. C’est précisément l’un des critères qui rend ce framework pertinent pour des applications métier manipulant des données personnelles sensibles à grande échelle.

Vous concevez ou refondez une application manipulant des données sensibles ? Notre agence de développement Symfony accompagne les CTO et équipes techniques dans la mise en conformité RGPD dès l’architecture, sans compromis sur les délais de livraison.

FAQ

RGPD et architecture applicative

Qu’est-ce que le Privacy by Design ?

C’est le principe, posé par l’article 25 du RGPD, qui impose d’intégrer la protection des données personnelles dès la conception d’un produit ou d’un système, et non a posteriori. En pratique, cela se traduit par des choix d’architecture logicielle : minimisation des données collectées, chiffrement natif, purge automatisée, et non par une simple couche de conformité ajoutée en fin de projet.

Combien de temps conserver les données personnelles selon le RGPD ?

Le RGPD n’impose pas de durée universelle : chaque catégorie de donnée doit avoir une durée de conservation justifiée par sa finalité (ex. logs de connexion, données de prospection, historique de commande), documentée dans le registre des traitements et appliquée techniquement via une purge ou une anonymisation automatisée.

Faut-il chiffrer toutes les données personnelles d’une application ?

Non : le chiffrement doit cibler en priorité les données les plus sensibles (identifiants directs, données de contact, données de santé ou financières), en fonction d’une classification préalable. Chiffrer systématiquement tous les champs complexifie les requêtes et les performances sans bénéfice de conformité proportionné.

Comment implémenter le droit à l’oubli techniquement ?

Le droit à l’oubli se traduit techniquement par une procédure d’anonymisation irréversible plutôt que par une suppression brute des enregistrements, afin de préserver l’intégrité référentielle des données liées (commandes, factures, logs). Sur Symfony, cela s’implémente via un service dédié déclenché par une commande console ou un workflow métier, exécutable dans le délai légal d’un mois.

Tags

#Architecture logicielle RGPD #Conformité RGPD #Privacy by design #RGPD #RGPD architecture applicative #RGPD Symfony #Sécurité et conformité applicative #Symfony