La fiche applicative est un petit fichier, application.yaml, placé à la
racine du dépôt d'une application, c'est-à-dire le dossier où l'on garde son
code et son historique. Elle déclare qui répond de l'application, quelles
données elle garde, quels outils de l'entreprise elle utilise et quelle classe
de C1 à C4 son auteur demande. Un décideur la lit comme un formulaire. Un
ingénieur la valide avec un schéma JSON, qui refuse une fiche incomplète.
Cette page montre la fiche du portail-achats et explique chaque champ. Vous
lancez ensuite la validation avec l'outil check-jsonschema. La page dit
enfin pourquoi la fiche reste une simple demande, que ni elle ni son schéma ne
doivent être modifiables par le demandeur, puis comment signer une décision et
vérifier la signature.
Ce que vous allez apprendre
Section intitulée « Ce que vous allez apprendre »- Expliquer à quoi sert une fiche applicative avant d'accueillir une application.
- Lire les champs d'une fiche et dire qui répond de l'application.
- Écrire la fiche du portail-achats avec ses champs obligatoires.
- Valider une fiche avec un schéma JSON et lire un message de refus.
- Dire ce que le schéma contrôle, et ce qu'il laisse à un autre contrôle.
- Expliquer pourquoi une application ne peut pas s'autoriser elle-même.
- Signer une décision avec
ssh-keygen, la vérifier, et lire quatre échecs de vérification.
Prérequis
Section intitulée « Prérequis »- La leçon Classer une application avant de l'accueillir, qui définit la classe de C1 à C4 et les quatre critères que la fiche reprend.
- La leçon Gouvernance : encadrer sans bloquer, qui dit qui décide selon la classe et pourquoi la décision se sépare de la demande.
- Aucune compétence technique pour lire la fiche. Pour rejouer la validation et le lab, il faut savoir ouvrir un terminal (prompt et terminal) et lancer un script Python (premiers pas en Python). Ces deux pages enseignent ces gestes ; passez-les si vous les maîtrisez déjà.
pipx, l'outil qui installe un programme Python dans son propre espace (guide pipx), pour installercheck-jsonschema. À défaut depipx, un environnement virtuel etpipfont le même travail.
À quoi sert une fiche applicative ?
Section intitulée « À quoi sert une fiche applicative ? »La fiche applicative donne à chaque application un état civil écrit : un responsable, des données déclarées et des flux connus. Une application créée avec l'IA naît vite, souvent dans un service métier comme les achats. Si personne ne note qui en répond et ce qu'elle touche, elle devient orpheline le jour où son auteur change de poste, comme le décrit la leçon Risques des applications générées par l'IA.
Le mot « contrat » est volontaire. La fiche engage celui qui la dépose sur ce que l'application fait. Si l'application lit autre chose que ce qui est déclaré, la fiche est fausse, et la plateforme peut s'en apercevoir en comparant les deux, puisque tous les accès au système d'information (le SI) passent par la passerelle décrite dans l'architecture d'accueil.
La fiche reprend les quatre critères de la grille de classement : données, flux vers le SI, utilisateurs et criticité. Elle y ajoute ce que la grille ne demande pas : un propriétaire métier et un propriétaire technique, la finalité et la durée de conservation de chaque donnée, les dépendances dont l'arrêt arrête l'application et une date d'expiration.
À quoi ressemble la fiche du portail-achats ?
Section intitulée « À quoi ressemble la fiche du portail-achats ? »La fiche du portail-achats tient en une trentaine de lignes de YAML. YAML est un format de texte où l'indentation montre ce qui appartient à quoi ; un champ suivi de lignes en retrait contient ces lignes. Le portail-achats est l'application d'exemple de la formation : une acheteuse l'a créée avec l'IA pour lire les commandes de l'ERP, le logiciel de gestion de l'entreprise.
id: portail-achatsnom: Portail achatsgenere_par_ia: trueproprietaire_metier: identifiant: m.durand nom: Marie Durand, responsable des achatsproprietaire_technique: identifiant: k.benali nom: Karim Benali, équipe plateformeclasse_declaree: C3donnees: - categorie: personnelles description: Nom et courriel des contacts chez les fournisseurs finalite: Joindre un contact fournisseur au sujet d'une commande conservation_jours: 365flux_si: - cible: erp-commandes mode: lecture operations: - lister les commandes - lire une commandeutilisateurs: equipecriticite_metier: importantedependances_critiques: - erp-commandes - postgresqldate_creation: 2026-11-15expire_le: 2027-05-15Les personnes de cet exemple sont inventées. Pour lire cette fiche sans connaître YAML, le tableau pose la question à laquelle chaque champ répond.
| Champ | Question à laquelle il répond |
|---|---|
id, nom | De quelle application parle-t-on ? |
genere_par_ia | Un modèle a-t-il écrit une partie du code ? |
proprietaire_metier | Qui répond du besoin et de l'usage ? |
proprietaire_technique | Qui répond du fonctionnement et des correctifs ? |
classe_declaree | Quelle classe le demandeur réclame-t-il ? |
donnees | Quelles données, de quel type, pour quoi faire, et combien de temps ? |
flux_si | Que lit ou que modifie l'application dans le SI ? |
utilisateurs, criticite_metier | Qui s'en sert, et que perd-on si elle s'arrête ? |
dependances_critiques | Quels services, s'ils tombent, arrêtent l'application ? |
date_creation, expire_le | Jusqu'à quand cette déclaration vaut-elle ? |
Un décideur peut déjà tirer deux conclusions de cette fiche. D'abord, la classe C3 est cohérente avec la grille : les données sont personnelles, le flux est une lecture de l'ERP et l'arrêt de l'application est important, soit trois critères au score 2. Ensuite, une durée de conservation est écrite, 365 jours, au lieu d'être laissée à l'oubli.
Quels champs sont obligatoires, et pourquoi ?
Section intitulée « Quels champs sont obligatoires, et pourquoi ? »Tous les champs de la fiche sont obligatoires, parce que chacun correspond à une décision qu'on ne peut pas prendre sans lui. Quelques-uns demandent une explication.
Les deux propriétaires doivent être renseignés, chacun avec un identifiant et un nom. Sans propriétaire métier, personne ne décide si l'application doit continuer ; sans propriétaire technique, personne ne la corrige. Une application dont l'auteur est parti garde ainsi deux noms à qui poser la question.
À partir de la classe C3, le propriétaire métier ne peut pas être la personne qui a demandé l'application : celui qui demande n'est pas celui qui répond du besoin. Le schéma ne le voit pas, car il ne connaît pas le demandeur. Un autre contrôle, dit « de politique » et présenté plus bas, le vérifie : il lit le demandeur dans le registre du dépôt de politique.
Chaque entrée de donnees porte une finalite et une conservation_jours
strictement positive. Une donnée sans durée de conservation reste
indéfiniment, et le propriétaire ne s'est jamais demandé quand l'effacer. Exiger
le nombre force cette question.
La finalité dit pourquoi on garde la donnée, et c'est elle qui permet de juger la durée. Le RGPD (article 5, paragraphe 1, point e) interdit de garder une donnée personnelle, sous une forme qui identifie la personne, plus longtemps que cette finalité ne le demande. On ne peut donc pas dire si 365 jours est trop long sans savoir à quoi sert la donnée.
La liste flux_si est obligatoire même quand l'application ne touche pas le
SI : on écrit alors une liste vide (flux_si: []). Une absence de champ ne dit
rien ; une liste vide dit « aucun flux », ce qui est une déclaration.
Le même raisonnement vaut pour une application qui ne garde aucune donnée : le
schéma accepte donnees: [], et la fiche le dit ainsi, plutôt que d'inventer
une entrée de catégorie aucune avec une durée de conservation sans objet.
Comment valider la fiche avec un schéma JSON ?
Section intitulée « Comment valider la fiche avec un schéma JSON ? »On valide la fiche en la confrontant à un schéma JSON, un fichier qui décrit les champs exigés, leur type et leurs valeurs permises. JSON Schema est un standard : le schéma est lui-même écrit en JSON, et un outil compare un fichier à ce schéma. La page Valider un fichier YAML contre un schéma détaille l'outil, et Écrire un JSON Schema détaille le langage du schéma.
Le schéma de la fiche tient en une soixantaine de lignes. Il déclare la liste
des champs required, interdit tout champ inconnu avec
"additionalProperties": false, et limite chaque valeur : une classe parmi
C1 à C4, un id de 3 à 40 caractères en minuscules, chiffres et tirets,
une finalite d'au moins 10 caractères, une conservation_jours entière
strictement supérieure à zéro.
{ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Fiche applicative", "type": "object", "additionalProperties": false, "required": [ "id", "nom", "genere_par_ia", "proprietaire_metier", "proprietaire_technique", "classe_declaree", "donnees", "flux_si", "utilisateurs", "criticite_metier", "dependances_critiques", "date_creation", "expire_le" ], "properties": { "id": { "type": "string", "pattern": "^[a-z0-9-]{3,40}$" }, "nom": { "type": "string", "minLength": 1 }, "genere_par_ia": { "type": "boolean" }, "proprietaire_metier": { "$ref": "#/$defs/personne" }, "proprietaire_technique": { "$ref": "#/$defs/personne" }, "classe_declaree": { "enum": ["C1", "C2", "C3", "C4"] }, "donnees": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["categorie", "description", "finalite", "conservation_jours"], "properties": { "categorie": { "enum": ["internes", "personnelles", "sensibles"] }, "description": { "type": "string", "minLength": 1 }, "finalite": { "type": "string", "minLength": 10 }, "conservation_jours": { "type": "integer", "exclusiveMinimum": 0 } } } }, "flux_si": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["cible", "mode", "operations"], "properties": { "cible": { "type": "string", "minLength": 1 }, "mode": { "enum": ["lecture", "ecriture"] }, "operations": { "type": "array", "minItems": 1, "items": { "type": "string" } } } } }, "utilisateurs": { "enum": ["auteur_seul", "equipe", "toute_entreprise", "externes"] }, "criticite_metier": { "enum": ["aucune", "utile", "importante", "critique"] }, "dependances_critiques": { "type": "array", "items": { "type": "string" } }, "date_creation": { "type": "string", "format": "date" }, "expire_le": { "type": "string", "format": "date" } }, "$defs": { "personne": { "type": "object", "additionalProperties": false, "required": ["identifiant", "nom"], "properties": { "identifiant": { "type": "string", "minLength": 1 }, "nom": { "type": "string", "minLength": 1 } } } }}Dans ce schéma, $defs range une définition réutilisable, ici personne, et
$ref y renvoie : les deux propriétaires obéissent ainsi aux mêmes règles sans
qu'on les recopie.
Ce fichier s'enregistre sous le nom application.schema.json, dans le dossier
politique/schemas/, et la fiche dans un dossier candidat/. Les deux dossiers
représentent deux dépôts distincts : le dépôt candidat est celui du demandeur,
le dépôt de politique est celui de l'organisation. La raison de cette séparation
est donnée plus bas. L'outil check-jsonschema, version 0.38.2, s'installe avec
pipx.
Sur Debian et Ubuntu, pipx s'installe par le gestionnaire de paquets. La
commande pipx ensurepath ajoute son dossier au PATH, la liste des dossiers
où le terminal cherche les programmes, et il faut ensuite ouvrir un nouveau
terminal pour qu'elle prenne effet. Le détail se trouve dans la
section pipx
de la page sur les environnements virtuels.
sudo apt install pipxpipx ensurepath# ouvrir un nouveau terminal, puis :pipx install check-jsonschema==0.38.2check-jsonschema --versioncheck-jsonschema --version doit afficher check-jsonschema, version 0.38.2. Avant de
s'en servir sur une fiche, on peut demander à l'outil de vérifier que le schéma
lui-même est un schéma valide :
check-jsonschema --check-metaschema politique/schemas/application.schema.jsonLa sortie attendue est ok -- validation done. On valide ensuite la fiche du
portail-achats contre ce schéma.
cd candidatcheck-jsonschema --schemafile ../politique/schemas/application.schema.json application.yamlecho "code de sortie : $?"Pour une fiche conforme, la commande affiche ok -- validation done et
le code de sortie vaut 0. Une chaîne de CI, c'est-à-dire la suite de
contrôles automatiques lancée à chaque modification du code, s'appuie sur ce code :
0 laisse passer, une autre valeur bloque.
Comment lire un refus du schéma ?
Section intitulée « Comment lire un refus du schéma ? »Un refus nomme le champ en faute et la règle violée. Pour le voir, on part
de la fiche du portail-achats et on y introduit une seule erreur à la fois.
L'outil affiche chaque message sous la forme fichier::chemin: message et rend
le code de sortie 1. Dans ces sorties, la fiche s'appelle application.yaml,
comme dans l'exemple : avec un autre nom de fichier, c'est ce nom qui apparaît.
Les messages ont été relevés avec check-jsonschema 0.38.2 le 2026-11-15. La
phrase de la règle vient de la bibliothèque Python jsonschema, que l'outil
emploie : chez vous, une autre version de cette bibliothèque peut la formuler
autrement. Cherchez donc le chemin et la règle violée, plutôt que le texte
mot pour mot.
Un refus s'affiche précédé de la ligne Schema validation errors were encountered. Voici la sortie complète pour une classe C5 :
Schema validation errors were encountered. application.yaml::$.classe_declaree: 'C5' is not one of ['C1', 'C2', 'C3', 'C4']Le tableau suivant donne neuf erreurs possibles, avec la ligne de message qu'elles provoquent. Il sert d'exemple de lecture : repérez le champ en faute, puis la règle.
| Erreur introduite dans la fiche | Message de l'outil |
|---|---|
Le bloc proprietaire_technique est supprimé | application.yaml::$: 'proprietaire_technique' is a required property |
La ligne conservation_jours: 365 est supprimée | application.yaml::$.donnees[0]: 'conservation_jours' is a required property |
La ligne finalite est supprimée | application.yaml::$.donnees[0]: 'finalite' is a required property |
La ligne finalite est réduite à finalite: court (moins de 10 caractères) | application.yaml::$.donnees[0].finalite: 'court' is too short |
Un champ classe_retenue: C1 est ajouté | application.yaml::$: Additional properties are not allowed ('classe_retenue' was unexpected) |
La classe déclarée vaut C5 | application.yaml::$.classe_declaree: 'C5' is not one of ['C1', 'C2', 'C3', 'C4'] |
La ligne devient conservation_jours: 0 | application.yaml::$.donnees[0].conservation_jours: 0 is less than or equal to the minimum of 0 |
La ligne devient id: ab (2 caractères) | application.yaml::$.id: 'ab' does not match '^[a-z0-9-]{3,40}$' |
La ligne devient date_creation: 2026-13-40 | application.yaml::$.date_creation: '2026-13-40' is not a 'date' |
Un id de plus de 40 caractères, ou écrit avec des majuscules ou un tiret bas,
est refusé par la même règle, avec un message de la même forme.
Pour lire un message, regardez d'abord le chemin à gauche : $ désigne la
racine du fichier, et $.donnees[0] la première entrée de la liste des données.
Le cas du champ classe_retenue mérite attention. Un candidat qui écrit
lui-même une classe_retenue dans sa fiche est refusé, parce que la fiche ne
contient que des demandes. Ce champ appartient à un autre fichier, présenté plus bas.
Que ne vérifie pas le schéma ?
Section intitulée « Que ne vérifie pas le schéma ? »Un schéma contrôle la forme d'un fichier, pas la vérité de ce qu'il déclare ni les calculs entre champs. Il garantit qu'un propriétaire est nommé, pas que la personne nommée existe. Il garantit qu'une classe est l'une des quatre valeurs, pas qu'elle est juste.
Deux contrôles restent donc à un autre outil. Le premier recalcule la classe à partir des quatre critères, selon la règle de la leçon Classer une application, et refuse la fiche si la classe déclarée est inférieure à la classe calculée. Le second compare l'échéance à la durée maximale de la classe, 6 mois au plus pour une C3.
Cette comparaison se fait à deux endroits, avec deux points de départ. Pour la
fiche, expire_le se compte depuis date_creation : la fiche du portail-achats
porte une échéance au 2027-05-15, six mois après sa création. Une échéance plus
lointaine, comme le 2027-06-15, est refusée.
Pour la décision signée, expire_le se compte depuis date_decision, la date
où l'on signe, et non depuis la création de la fiche. La décision peut être
signée des jours après la fiche : son échéance doit rester dans les six mois de
sa propre date, sinon la barrière de la plateforme la refuse.
Aucun de ces deux contrôles ne s'exprime proprement dans un schéma JSON, car ils comparent plusieurs champs ou dépendent d'une décision qui n'est pas dans la fiche. Le même contrôle de politique vérifie aussi, dès C3, que le propriétaire métier n'est pas le demandeur, comme dit plus haut.
Pourquoi une application ne peut-elle pas s'autoriser elle-même ?
Section intitulée « Pourquoi une application ne peut-elle pas s'autoriser elle-même ? »La fiche est écrite par le demandeur, donc elle ne peut être qu'une demande : l'autorisation vit dans un dépôt qu'il ne peut pas modifier. Si la décision ou le schéma se trouvaient dans le dépôt de l'application, son auteur pourrait les changer, et le contrôle ne contrôlerait plus rien.
Le schéma suit la même logique que la décision. Un schéma gardé dans le dépôt
candidat s'affaiblit en une ligne : l'auteur retire proprietaire_technique de
la liste required, et sa fiche, devenue incomplète, passe la validation.
Gardé dans un dépôt de politique, le schéma s'impose au candidat sans qu'il
puisse le toucher. C'est la séparation des tâches décrite dans
Séparation des privilèges,
appliquée aux fichiers : celui qui demande n'est pas celui qui fixe les règles.
Le schéma suivant montre qui écrit quoi, et ce que lit chaque contrôle : le contrôle de politique, qui juge la fiche, et la barrière de la plateforme, le contrôle automatique qui autorise ou refuse un déploiement.
Sur le schéma, regardez d'où viennent les flèches. Le contrôle de politique
(valider_fiche.py) lit la fiche, le schéma et le registre des demandes : c'est
lui qui vérifie la forme de la fiche. La barrière de la plateforme ne lit de la
fiche que son empreinte, et reçoit du dépôt de politique le registre, les
décisions et les clés habilitées. La flèche épaisse qui arrive sur la barrière
part du dossier des décisions : c'est lui qui décide, la fiche ne fait que
demander. La classe retenue, celle qui dicte les contrôles, est écrite là et
nulle part ailleurs, ce qui explique le refus du champ classe_retenue plus
haut.
Qui signe la décision, et pourquoi pas le demandeur ?
Section intitulée « Qui signe la décision, et pourquoi pas le demandeur ? »La décision est un fichier signé, et la personne qui signe dépend de la classe. En C2, le propriétaire technique signe une décision légère dans le dépôt de politique, et il ne peut pas être le demandeur. Dès C3, c'est un responsable habilité, lui aussi distinct du demandeur ; la C4 en demande deux. La leçon Gouvernance détaille qui décide à chaque classe.
Une signature numérique repose sur deux clés. La clé privée, que seul le
signataire détient, produit la signature ; la clé publique, que tout le monde
peut lire, la vérifie. La signature prouve qui a signé et que le fichier n'a pas
changé depuis. Le fichier allowed_signers liste les clés publiques des
signataires acceptés. L'outil OpenSSH signe un fichier avec ssh-keygen -Y sign
et vérifie la signature avec ssh-keygen -Y verify, contre allowed_signers.
Le demandeur ne peut pas s'autoriser lui-même, et ce n'est pas faute de clé :
il peut très bien en détenir une habilitée. Deux règles l'en empêchent. D'abord,
la barrière ne lit les décisions que dans le dépôt de politique, jamais dans le
dépôt candidat : une décision ajoutée dans son propre dépôt n'est pas regardée.
Ensuite, le dépôt de politique tient un registre des demandes,
politique/demandes.toml, qui nomme qui a demandé. La barrière y lit le
demandeur et refuse toute décision signée par cette même personne, même si
sa clé figure dans allowed_signers.
Le responsable qui signe ne choisit pas non plus la classe. Il reprend celle
que fixe le RSSI, le responsable de la sécurité des systèmes d'information. La
barrière refuse toute classe_retenue inférieure à la classe calculée à partir
de la fiche. Abaisser une classe exige une décision écrite du RSSI, que décrit
la leçon
Gouvernance.
Que contient une décision ?
Section intitulée « Que contient une décision ? »Avant de signer, il faut un fichier à signer : la décision. Elle se range dans
politique/decisions/, sous le nom <id-application>-<date>.yaml, et sa
signature .yaml.sig se pose à côté. La barrière refuse une décision à laquelle
il manque l'un de ces neuf champs : id, application, fiche_sha256,
classe_retenue, decision, demandeur, decideur, date_decision et
expire_le. Voici celle du portail-achats, signée le 2026-11-15 par un
responsable habilité :
id: portail-achats-2026-11-15application: portail-achatsfiche_sha256: <empreinte de candidat/application.yaml>classe_retenue: C3decision: accepterisques_acceptes: []conditions: []demandeur: j.petitdecideur: identifiant: m.durand role: responsable_servicedate_decision: 2026-11-15expire_le: 2027-05-15Le champ decision vaut accepte, accepte_sous_conditions ou refuse : seuls
les deux premiers autorisent. Les listes risques_acceptes et conditions
restent vides ici ; la barrière ne les contrôle pas. Le demandeur est la
personne qui a fait la demande, celle que nomme politique/demandes.toml.
Dans fiche_sha256, le texte entre chevrons est un espace réservé : vous le
remplacez par une vraie empreinte, expliquée juste après.
Ici, le décideur s'écrit m.durand, et non une adresse de messagerie, parce que
la barrière compare des identifiants écrits en texte : un même identifiant
doit s'écrire pareil dans demandes.toml, dans allowed_signers et dans
decideur.identifiant. C'est d'ailleurs decideur.identifiant que l'option
-I de ssh-keygen cherche dans allowed_signers. Le champ demandeur de la
décision ne protège rien à lui seul, puisque le signataire l'écrit lui-même : la
barrière s'appuie sur le registre demandes.toml, que le signataire ne peut pas
modifier, et compare aussi au champ demandeur de la décision. Le rôle de m.durand est responsable_service, celui qu'exige la
classe C3.
Une décision ne couvre que la version exacte de la fiche qu'elle cite, par
son champ fiche_sha256. On calcule cette empreinte avec
sha256sum candidat/application.yaml et on recopie les 64 caractères
hexadécimaux. Si le demandeur modifie la fiche après l'accord, par
exemple pour ajouter un flux en écriture, l'empreinte change et la décision ne
couvre plus la fiche : la barrière refuse. Le demandeur ne peut donc pas
s'autoriser après coup en élargissant ce qu'on lui a accordé.
En résumé, la barrière refuse une décision quand la signature est invalide ou
que le signataire est absent de allowed_signers, quand le décideur est le
demandeur (celui de la décision comme celui du registre), quand son rôle ne
convient pas à la classe (responsable_service en C3 ; en C4, en plus
securite), quand decision vaut refuse, quand la classe est inconnue ou
inférieure à la classe calculée, quand l'empreinte de la fiche diffère, ou
quand l'échéance dépasse la durée de la classe ou est passée.
Comment signer et vérifier une décision ?
Section intitulée « Comment signer et vérifier une décision ? »Voici le geste complet : créer la clé du signataire, déclarer sa clé publique
dans allowed_signers, puis signer et vérifier. Les commandes ont été relevées
avec OpenSSH 10.0p2 le 2026-11-15. Pour l'essai, enregistrez la décision
ci-dessus sous le nom portail-achats-2026-11-15.yaml dans un dossier de
travail, avec une vraie empreinte, et lancez les commandes depuis ce dossier.
La première commande crée une clé de démonstration : cle pour la clé privée,
cle.pub pour la clé publique. Elle n'a pas de phrase de passe (-N ''), alors
qu'une vraie clé de signataire en porte une. La seconde commande écrit la ligne
de allowed_signers : l'identité m.durand, l'option namespaces, puis
le type et le texte de la clé publique, que cut extrait de cle.pub en
laissant de côté son commentaire.
ssh-keygen -t ed25519 -f cle -C m.durand -N ''echo "m.durand namespaces=\"decision-applicative\" $(cut -d' ' -f1,2 cle.pub)" > allowed_signersLa ligne obtenue a la forme
m.durand namespaces="decision-applicative" ssh-ed25519 AAAA…. Un espace
de noms est une étiquette qui attache une signature à un usage précis, ici
decision-applicative. L'option namespaces limite la clé à cette étiquette :
elle ne peut pas valider une signature faite pour un autre usage. Dans les deux
commandes suivantes, -n donne l'espace de noms de la signature et -I
l'identité à chercher dans allowed_signers. La signature utilise cle, la clé
privée du signataire.
ssh-keygen -Y sign -f cle -n decision-applicative portail-achats-2026-11-15.yamlssh-keygen -Y verify -f allowed_signers -I m.durand -n decision-applicative -s portail-achats-2026-11-15.yaml.sig < portail-achats-2026-11-15.yamlLa première commande écrit portail-achats-2026-11-15.yaml.sig. La seconde affiche, pour une
signature valable, une ligne de la forme
Good "decision-applicative" signature for m.durand with ED25519 key SHA256:…,
qui rappelle le type et l'empreinte de la clé, et rend le code 0. Pour voir la
barrière refuser, vous pouvez provoquer quatre échecs. Dans chacun, la commande
rend le code 255, et le tableau donne le message qui les distingue :
| Cas | Message de ssh-keygen -Y verify |
|---|---|
Mauvais espace de noms avec -n | Couldn't verify signature: namespace does not match |
| Fichier modifié après la signature | Signature verification failed: incorrect signature |
Signature faite avec -n autre et vérifiée avec -n autre, alors que allowed_signers limite la clé à decision-applicative | allowed_signers:1: key is not permitted for use in signature namespace "autre" |
Identité absente de allowed_signers, ou clé différente | Could not verify signature. seul |
Les trois premiers cas ajoutent aussi Could not verify signature.. Le dernier
cas ne dit pas ce qui manque : le message ne distingue pas une identité absente
d'une clé différente, donc vérifiez les deux.
Qu'impose l'organisation au poste de celui qui crée l'application ?
Section intitulée « Qu'impose l'organisation au poste de celui qui crée l'application ? »Ce que l'organisation impose aux postes de ceux qui créent les applications avec un agent de code (permissions, serveurs MCP autorisés, réglages administrés) relève d'un autre guide : Sécuriser Claude Code, dans sa section sur la politique d'entreprise.
Quels symptômes trahissent une fiche mal posée ?
Section intitulée « Quels symptômes trahissent une fiche mal posée ? »Les problèmes courants se reconnaissent à leur symptôme : un champ oublié, une finalité trop courte, une classe déclarée trop bas, un schéma rangé au mauvais endroit, une échéance trop longue, un propriétaire métier qui est le demandeur. Le tableau relie chaque symptôme à sa cause probable et à la correction.
| Symptôme | Cause probable | Correction |
|---|---|---|
is a required property sur un propriétaire | Un champ a été oublié ou laissé en commentaire | Renseigner l'identifiant et le nom d'une personne réelle |
'court' is too short sur finalite | La finalité tient en un mot au lieu de dire pourquoi on garde la donnée | Écrire une phrase d'au moins 10 caractères qui dit à quoi sert la donnée |
| La fiche passe, mais la plateforme la refuse | La classe déclarée est inférieure à la classe calculée | Relire les quatre critères, en prenant le score supérieur en cas de doute |
| Le schéma accepte une fiche qui devrait échouer | Le schéma est dans le dépôt de l'application et a été modifié | Le replacer dans le dépôt de politique et vérifier son historique |
Le contrôle de politique refuse la fiche : expire_le dépasse six mois après date_creation | L'échéance de la fiche a été choisie par confort | La ramener à la durée maximale de la classe, comptée depuis date_creation |
La barrière refuse une décision dont l'expire_le est trop lointain | La durée de la décision se compte depuis date_decision, pas depuis la fiche | Fixer expire_le au plus à la durée de la classe après date_decision |
| Le contrôle de politique refuse la fiche : le propriétaire métier est le demandeur | La fiche nomme le demandeur comme propriétaire métier, ce que la politique interdit dès C3 | Nommer comme propriétaire métier quelqu'un d'autre que le demandeur |
| La barrière refuse une décision pourtant signée | La fiche a changé depuis la signature, l'empreinte fiche_sha256 ne correspond plus | Faire signer une nouvelle décision pour la fiche modifiée |
Mettre en pratique
Section intitulée « Mettre en pratique »Le lab vous fait reprendre la fiche du portail-achats, rédigée par un agent de
code pour qu'elle « puisse être déployée », puis signer la décision en
approbateur dans le dépôt de politique. Il vérifie que la fiche passe le schéma
du dépôt de politique, que les propriétaires sont nommés et que le propriétaire
métier n'est pas la demandeuse, que chaque donnée porte sa finalité et sa durée
de conservation, et que seule une décision signée du dépôt de politique autorise
le portail-achats : la même décision posée dans le dépôt candidat n'autorise
rien. Le lab valide avec son propre script, valider_fiche.py, plutôt qu'avec
check-jsonschema, et il ne rejoue pas les quatre échecs de vérification de
signature vus plus haut. Le lab vous donne son propre dossier : ses
propriétaires, les durées de conservation du délégué à la protection des
données (DPO), les données et les flux diffèrent de
l'exemple de cette page, et son script affiche ses messages sous une autre forme
que check-jsonschema. Il demande un terminal, Python 3.11 ou plus et OpenSSH
(ssh-keygen).
À retenir
Section intitulée « À retenir »- La fiche applicative est un état civil écrit (un responsable, des données et des flux déclarés) : un décideur la lit, un ingénieur la valide avec un schéma JSON et
check-jsonschema. - Deux propriétaires, métier et technique, et, pour chaque donnée, une
finaliteet uneconservation_jourspositive sont exigés ; dès C3, le propriétaire métier n'est pas le demandeur. - Un refus du schéma donne un chemin et une règle violée ; la phrase exacte varie avec la version de la bibliothèque.
- Un schéma contrôle la forme, pas la vérité : le calcul de la classe et l'échéance restent à un autre contrôle.
- La classe déclarée est une demande ; la classe retenue et le schéma vivent dans le dépôt de politique, sinon l'auteur les modifie.
- Une application ne s'autorise jamais elle-même : la décision est signée par le propriétaire technique en C2, par un responsable habilité dès C3 (deux en C4), et jamais par le demandeur.
- Une décision cite l'empreinte de la fiche (
fiche_sha256) : modifier la fiche après l'accord invalide la décision. - Une signature
ssh-keygense vérifie contreallowed_signers; un mauvais espace de noms, un fichier modifié ou une clé non permise la font échouer avec le code 255.
Contrôle de connaissances
Section intitulée « Contrôle de connaissances »Ces huit questions portent sur le rôle de la fiche, ses champs obligatoires (dont la finalité de chaque donnée), la validation par schéma, la séparation entre la demande et la décision, et la signature d'une décision.
Contrôle de connaissances
Validez vos connaissances avec ce quiz interactif
Informations
- Le chronomètre démarre au clic sur Démarrer
- Questions à choix multiples, vrai/faux et réponses courtes
- Vous pouvez naviguer entre les questions
- Les résultats détaillés sont affichés à la fin
Lance le quiz et démarre le chronomètre
Vérification
(0/0)Score par domaine
Un domaine regroupe plusieurs guides et reçoit plusieurs questions : son score est plus fiable qu'un score par thème, qui porte souvent sur une seule question.
Bilan
Points forts
Aucun sujet réussi à 80 % sur au moins deux questions pour l’instant.
Points faibles
Aucun sujet sous le seuil de réussite.
À faire ensuite
Des indices pour retenter votre chance ?
Continuer le cours : Sécuriser Claude Code : le poste, le projet et la politique d'entreprise
Nouveau quiz complet avec des questions aléatoires
Retravailler uniquement les questions ratées
Retour à la liste des certifications