Droits de licence contre feature flags
Un feature flag est un interrupteur opérationnel que vous contrôlez ; un droit de licence est une concession commerciale signée que le client a payée. Confondez-les et un client bascule un flag pour déverrouiller ce qu'il n'a jamais acheté. Cet article trace la frontière, montre les défaillances de la mauvaise approche, propose un tableau de décision et câble l'architecture combinée de Keyright : les droits comme barrière dure, les feature flags par-dessus pour le déploiement dans les limites de ce à quoi le client a droit.
Saisissez un système de feature flags pour verrouiller une fonction payante et le code paraît correct le premier jour. flags.IsEnabled("advanced-reports") enveloppe le bouton d’export, l’interrupteur est coupé pour les utilisateurs gratuits et activé pour les payants, et la démo marche. Puis un client ouvre le magasin de flags que vous lui avez remis, bascule l’interrupteur et obtient une fonction qu’il n’a jamais achetée ; ou votre service de déploiement passe un mauvais après-midi, le client retombe sur sa valeur par défaut, et chaque installation déverrouille trop ou trop peu d’un coup. Rien n’a été piraté. L’outil était tout simplement le mauvais : un feature flag est un interrupteur opérationnel, et vous l’avez utilisé pour tracer une frontière commerciale.
Cet article trace la frontière entre les deux, montre ce qui casse quand on la franchit, puis les combine de la bonne façon dans une application .NET sous licence Keyright : les droits comme barrière dure, les flags par-dessus pour le déploiement dans les limites de ce à quoi le client a droit.
Deux outils qui se ressemblent et ne le sont pas
Tous deux répondent à une question oui/non sur l’exécution d’une capacité, d’où la confusion facile. La différence tient à qui contrôle la réponse et à la fiabilité de cette réponse.
Un feature flag est un interrupteur mutable que vous contrôlez. Vous le posez, le changez, le déployez sur 5 % des comptes puis sur tous, le supprimez à la fin d’une expérience. C’est un mécanisme d’exploitation et de livraison. Il n’a pas d’intégrité cryptographique parce qu’il n’en a pas besoin : celui qui lit le flag (votre application) et celui qui le pose (vous) sont du même côté.
Un droit de licence est une concession signée et infalsifiable liée à ce que le client a payé. Le client détient la licence ; vous détenez la clé privée qui l’a signée. L’application vérifie la signature contre une clé publique embarquée, de sorte que le jeu de droits ne peut être ni falsifié ni modifié par la partie qu’il restreint. C’est une frontière commerciale, et toute sa valeur tient à ce que la personne de l’autre côté ne peut pas la basculer elle-même.
Défaillance 1 — des flags pour la licence
Verrouillez une capacité payante avec un flag et vous héritez de trois problèmes à la fois.
C’est contourné trivialement. Quoi qu’il stocke le flag — un fichier de configuration, une base de données locale, un cache que le SDK écrit sur disque — c’est à portée du client. Aucune signature ne le couvre, donc le modifier n’a aucune conséquence détectable. La « frontière » est un booléen que la partie restreinte peut mettre à true.
Pas de scénario hors ligne. Un service de flags hébergé répond par le réseau ; quand il est injoignable, le client sert une valeur par défaut. Une valeur par défaut répond bien à « cette expérience doit-elle être active ? » et très mal à « ce client a-t-il acheté ceci ? ». Vous finissez par choisir entre échouer ouvert (offrir des fonctions payantes pendant une panne) et échouer fermé (casser des fonctions que votre client a légitimement payées parce que votre service a cligné).
Pas d’intégrité, donc pas d’audit. Quand surgit un litige sur ce à quoi un client avait droit, une licence signée fait preuve : elle dit ce qui a été accordé, par qui, jusqu’à quand, et la signature prouve qu’elle n’a pas été altérée. La valeur d’un flag n’est qu’une ligne que quelqu’un a pu écrire.
Défaillance 2 — des droits pour un déploiement progressif
L’erreur inverse est plus subtile. Supposez que vous livriez un nouveau moteur de rapports et vouliez l’activer pour 5 % des clients ayant droit le lundi, 50 % le mercredi, tous le vendredi : un déploiement classique. Si vous le modélisez avec le droit, chaque cran du curseur est une réémission : une nouvelle licence signée, un passage par votre chaîne commerciale, une réactivation côté client. Les droits sont délibérément coûteux à changer parce qu’ils représentent de l’argent ; ce coût est justement le mauvais pour un bouton opérationnel que vous voulez tourner trois fois par semaine. Vous frapperiez aussi des concessions commerciales pour une décision sans rapport avec ce que quiconque a payé, polluant la chose dont la seule valeur est de ne refléter que l’achat.
Le tableau de décision
| Dimension | Feature flag | Droit de licence |
|---|---|---|
| Intégrité | Aucune — une valeur mutable, sans signature | Signé cryptographiquement, infalsifiable |
| Qui le contrôle | Vous (l’éditeur), à l’exécution | Accordé par vous, détenu par le client, vérifié par l’application |
| Comportement hors ligne | Retombe sur une valeur par défaut ; exige souvent le réseau | Validé localement avec la clé publique embarquée ; échoue fermé |
| Latence de changement | Secondes — on bascule et c’est en ligne | Une réémission : nouvelle signature, réactivation |
| Public | Une cohorte que vous choisissez (pourcentage, anneau, compte) | Le client précis et ce qu’il a acheté |
| Bon usage | Déploiement, expériences, coupe-circuits, boutons opérationnels | Frontières commerciales : éditions, plafonds de sièges, capacités payantes |
Lisez le tableau comme une seule règle : si la réponse doit survivre à un client adversaire et à un réseau en panne, c’est un droit ; s’il vous faut la changer vite et que vous devriez être le seul à le pouvoir, c’est un flag.
Les droits dans Keyright
Un droit Keyright se lit depuis une licence validée localement. Vous initialisez le client une fois avec votre nom de produit et votre clé publique en lecture seule, puis vous validez — hors ligne, contre la clé embarquée.
using Keyright;
static readonly KeyrightClient License = KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-analytics",
PublicKeyBase64 = "MIIBIjANBgkq...", // verify-only; ships in the binary
ServiceUrl = "https://keyright.example.com", // only needed to activate online
});
// Local, no network: verifies signature, expiry, node-lock and the entitlement set.
// Never throws for license state; fails closed to Community Edition.
LicenseInfo info = await License.ValidateAsync();
bool canExport = info.Entitlements.IsEnabled("advanced-reports");
info.Entitlements est le jeu signé que le client a payé. IsEnabled est une lecture locale pure — sans aller-retour — et, comme la validation échoue fermé, une licence absente, expirée ou altérée se résout vers Community Edition, le droit étant lu à false. Voilà la barrière dure : la capacité est indisponible sauf si la concession signée dit le contraire, et rien que le client puisse modifier ne change cette réponse.
Composer un flag avec un droit
Voici l’architecture réelle : les deux outils en couches, non substitués. Le droit décide si ce client peut un jour avoir la capacité ; le flag décide si nous l’avons déjà activée pour lui. L’ordre n’est pas négociable : le droit fait barrière, le flag ne fait que restreindre.
public sealed class ReportService
{
private readonly IFeatureFlags _flags; // your rollout system (OpenFeature, homegrown…)
public ReportService(IFeatureFlags flags) => _flags = flags;
public async Task<IActionResult> RunAdvancedReport(ReportRequest req)
{
LicenseInfo info = await License.ValidateAsync();
// 1. Hard gate: did the customer PAY for this capability? Signed, offline, fail-closed.
if (!info.Entitlements.IsEnabled("advanced-reports"))
return Forbid("advanced-reports is not part of your plan");
// 2. Rollout narrowing: is the new engine turned on for this account yet?
// This can only withhold a paid feature during rollout — never grant an unpaid one.
if (!_flags.IsEnabled("advanced-reports-v2-rollout"))
return await RunLegacyReport(req);
return await RunReportV2(req);
}
}
Lisez les deux vérifications. Celle du droit est porteuse : retirez-la et n’importe quel compte atteint la fonction. Celle du flag est restrictive : retirez-la et les clients ayant droit reçoivent simplement tous v2 d’un coup — une décision de déploiement, jamais de sécurité. Comme le flag se trouve à l’intérieur de la branche de succès du droit, il est structurellement impossible qu’un flag déverrouille une capacité non payée. Le pire qu’un flag mal configuré puisse faire, c’est garder un moment un client payant sur le chemin hérité.
La même composition exprime un déploiement progressif d’une toute nouvelle capacité payante. Accordez le droit dès la vente, puis protégez l’activation réelle derrière un flag de pourcentage pour maîtriser le rayon d’impact — sans jamais laisser le flag devenir ce qui décide si le client l’a achetée.
if (info.Entitlements.IsEnabled("live-collaboration")
&& _flags.IsEnabled("collab-ga-rollout"))
{
EnableCollaboration();
}
Le && se lit de gauche à droite et c’est tout le principe : le droit d’abord parce qu’il est la vérité commerciale, le flag ensuite parce qu’il est le bouton opérationnel. Inversez les opérandes et vous avez reconstruit la Défaillance 1.
Où s’insèrent les limites numériques
Le même partage vaut pour les frontières quantitatives. Un plafond de sièges est commercial — il est dans la licence signée — donc il relève du côté droit :
long maxSeats = info.Entitlements.GetLimit("max-seats", defaultValue: 1);
if (activeSeats >= maxSeats)
return Forbid("seat limit reached for your plan");
Un flag pourrait alors contrôler comment vous appliquez un dépassement pendant un déploiement — blocage dur contre bandeau de grâce — mais le nombre lui-même, ce qui est lié à l’argent, reste dans le droit, où il est signé et vérifiable hors ligne.
La règle, en une ligne
Verrouillez ce que le client a payé avec un droit Keyright : signé, infalsifiable, vérifié hors ligne, modifié seulement par une réémission délibérée. Verrouillez comment et quand vous le déployez avec un feature flag : rapide, à vous, jetable. Gardez le flag strictement à l’intérieur du oui du droit, et les deux se renforcent au lieu que l’un défasse l’autre en silence.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.