Aller au contenu
English
Compte : non connecté, synchronisation possible Mon apprentissage
Selectionner le thème
English

Fiche applicative : déclarer une application avec un contrat validé

Par mis à jour le

Améliorer cette page

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.

  • 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.
  • 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 installer check-jsonschema. À défaut de pipx, un environnement virtuel et pip font le même travail.

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.

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-achats
nom: Portail achats
genere_par_ia: true
proprietaire_metier:
identifiant: m.durand
nom: Marie Durand, responsable des achats
proprietaire_technique:
identifiant: k.benali
nom: Karim Benali, équipe plateforme
classe_declaree: C3
donnees:
- categorie: personnelles
description: Nom et courriel des contacts chez les fournisseurs
finalite: Joindre un contact fournisseur au sujet d'une commande
conservation_jours: 365
flux_si:
- cible: erp-commandes
mode: lecture
operations:
- lister les commandes
- lire une commande
utilisateurs: equipe
criticite_metier: importante
dependances_critiques:
- erp-commandes
- postgresql
date_creation: 2026-11-15
expire_le: 2027-05-15

Les 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.

ChampQuestion à laquelle il répond
id, nomDe quelle application parle-t-on ?
genere_par_iaUn modèle a-t-il écrit une partie du code ?
proprietaire_metierQui répond du besoin et de l'usage ?
proprietaire_techniqueQui répond du fonctionnement et des correctifs ?
classe_declareeQuelle classe le demandeur réclame-t-il ?
donneesQuelles données, de quel type, pour quoi faire, et combien de temps ?
flux_siQue lit ou que modifie l'application dans le SI ?
utilisateurs, criticite_metierQui s'en sert, et que perd-on si elle s'arrête ?
dependances_critiquesQuels services, s'ils tombent, arrêtent l'application ?
date_creation, expire_leJusqu'à 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.

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.

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.

Fenêtre de terminal
sudo apt install pipx
pipx ensurepath
# ouvrir un nouveau terminal, puis :
pipx install check-jsonschema==0.38.2
check-jsonschema --version

check-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 :

Fenêtre de terminal
check-jsonschema --check-metaschema politique/schemas/application.schema.json

La sortie attendue est ok -- validation done. On valide ensuite la fiche du portail-achats contre ce schéma.

Fenêtre de terminal
cd candidat
check-jsonschema --schemafile ../politique/schemas/application.schema.json application.yaml
echo "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.

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 ficheMessage de l'outil
Le bloc proprietaire_technique est suppriméapplication.yaml::$: 'proprietaire_technique' is a required property
La ligne conservation_jours: 365 est suppriméeapplication.yaml::$.donnees[0]: 'conservation_jours' is a required property
La ligne finalite est suppriméeapplication.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 C5application.yaml::$.classe_declaree: 'C5' is not one of ['C1', 'C2', 'C3', 'C4']
La ligne devient conservation_jours: 0application.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-40application.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.

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.

Deux dépôts alimentent deux contrôles. Le dépôt candidat, que le demandeur écrit, contient la fiche application.yaml, qui est une demande. Le dépôt de politique, que le demandeur ne peut pas modifier, contient le schéma application.schema.json, le registre demandes.toml qui nomme le demandeur, le dossier decisions avec la classe retenue et la décision signée, et le fichier allowed_signers des clés habilitées. Le contrôle de politique lit la fiche, le schéma et le registre, et refuse une fiche non conforme. La barrière de la plateforme ne lit de la fiche que son empreinte : elle cherche dans le dépôt de politique une décision signée par une clé habilitée, et autorise le déploiement seulement si tout concorde, sinon elle refuse.Dépôt de politique : ledemandeur ne peut pas écrireDépôt candidat : le demandeurécritempreinteapplication.yamlla fiche : une demandeschemas/application.schema.jsonla forme exigéedemandes.tomlqui a demandédecisions/classe retenue,décision signéeallowed_signersles clés habilitéesContrôle de politiquevalider_fiche.pyBarrière de la plateformeDéploiement autoriséRefus
Source · SVG
Échap pour fermer, + et − pour zoomer, défilement pour se déplacer. 100 %

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.

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-15
application: portail-achats
fiche_sha256: <empreinte de candidat/application.yaml>
classe_retenue: C3
decision: accepte
risques_acceptes: []
conditions: []
demandeur: j.petit
decideur:
identifiant: m.durand
role: responsable_service
date_decision: 2026-11-15
expire_le: 2027-05-15

Le 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.

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.

Fenêtre de terminal
ssh-keygen -t ed25519 -f cle -C m.durand -N ''
echo "m.durand namespaces=\"decision-applicative\" $(cut -d' ' -f1,2 cle.pub)" > allowed_signers

La 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.

Fenêtre de terminal
ssh-keygen -Y sign -f cle -n decision-applicative portail-achats-2026-11-15.yaml
ssh-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.yaml

La 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 :

CasMessage de ssh-keygen -Y verify
Mauvais espace de noms avec -nCouldn't verify signature: namespace does not match
Fichier modifié après la signatureSignature verification failed: incorrect signature
Signature faite avec -n autre et vérifiée avec -n autre, alors que allowed_signers limite la clé à decision-applicativeallowed_signers:1: key is not permitted for use in signature namespace "autre"
Identité absente de allowed_signers, ou clé différenteCould 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ômeCause probableCorrection
is a required property sur un propriétaireUn champ a été oublié ou laissé en commentaireRenseigner l'identifiant et le nom d'une personne réelle
'court' is too short sur finaliteLa 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 refuseLa classe déclarée est inférieure à la classe calculéeRelire les quatre critères, en prenant le score supérieur en cas de doute
Le schéma accepte une fiche qui devrait échouerLe 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_creationL'échéance de la fiche a été choisie par confortLa 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 lointainLa durée de la décision se compte depuis date_decision, pas depuis la ficheFixer 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 demandeurLa fiche nomme le demandeur comme propriétaire métier, ce que la politique interdit dès C3Nommer comme propriétaire métier quelqu'un d'autre que le demandeur
La barrière refuse une décision pourtant signéeLa fiche a changé depuis la signature, l'empreinte fiche_sha256 ne correspond plusFaire signer une nouvelle décision pour la fiche modifiée

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).

  • 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 finalite et une conservation_jours positive 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-keygen se vérifie contre allowed_signers ; un mauvais espace de noms, un fichier modifié ou une clé non permise la font échouer avec le code 255.

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

8 questions
8 min.
70% requis

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