Personas
La surface de rédaction d’Aggrega est répartie entre quatre rôles qui collaborent. Chaque rôle a une préoccupation distincte, un rythme de changement distinct et un ensemble distinct de types d’entités qu’il rédige en général. Comprendre quel rôle vous endossez vous indique quel fichier ouvrir et quels piliers remplir.
Cette répartition est une orientation, non une règle que le compilateur impose. Le compilateur central est mathématiquement sans parti pris : il accepte toute manière de rédiger qui passe la validation du schéma. Vous êtes libre de fusionner des rôles — un auteur seul porte couramment les quatre casquettes — ou de franchir une frontière quand une situation l’exige. Les rôles existent pour garder la charge cognitive faible et les responsabilités claires, non pour bâtir une prison. Pour le traitement architectural de cette séparation, voir Team Topologies et les quatre domaines.
Les quatre rôles
Développeur
intention applicative
Aggregate
Architecte de plateforme
le contrat du catalogue
Components
Features
Opérations de plateforme
recettes d’infrastructure
Recipes
FeatureRecipes
Plugins
de rendu par fournisseur
Opérateur de plateforme
câblage par environnement
Manifests
Releases
Qui écrit généralement quels fichiers. La répartition est une orientation, et non une règle que le compilateur impose : dans une petite équipe ou un projet mené seul, une seule personne les écrit tous.
Développeur — intention applicative
Le développeur rédige l’Aggregate : ce qu’est l’application et ce dont elle a besoin, exprimé comme une intention. Le développeur dit « j’ai besoin d’une base de données de cette taille et d’un service qui l’utilise », et non « provisionne une instance AWS RDS dans ce sous-réseau ». L’infrastructure physique est délibérément laissée au catalogue et aux opérations, de sorte que l’Aggregate reste agnostique vis-à-vis des capacités — la même intention se compile pour un ordinateur portable, un cloud ou un cluster d’entreprise sans que le fichier du développeur change.
Ce dont le développeur est responsable : les composants que l’Aggregate déclare, les values qu’il fournit, les Features dont le comportement relève de l’intention applicative (avec leurs values), les parameters qu’il expose pour la variation par environnement et les arêtes uses qui relient les composants entre eux.
Architecte de plateforme — le contrat du catalogue
L’architecte rédige les Components et les Features : les contrats réutilisables et versionnés que consomment les développeurs. Un Component déclare les valeurs qu’un développeur peut fournir (sous forme de JSON Schema), les sorties qu’il fournit aux consommateurs et les sockets qu’il expose pour le câblage. Une Feature déclare une capacité attachable. L’architecte construit la « route pavée » — le distributeur automatique auprès duquel les développeurs commandent — et garantit que ce qu’il délivre est bien formé.
Ce dont l’architecte est responsable : le schema: qui valide les valeurs du développeur, les sorties provides, les sockets usesSchema et les labels qui portent l’identité sémantique. Les architectes n’écrivent pas l’infrastructure physique ; ils en définissent l’interface.
Opérations de plateforme — recettes d’infrastructure
Les opérations rédigent les Recipes, les FeatureRecipes et les Plugins de rendu des providers : les traductions propres à chaque provider qui transforment un contrat du catalogue en infrastructure rendue. Une Recipe fait correspondre les valeurs déclarées d’un Component à un provider concret — Helm, Docker Compose, Terraform — sans modifier les valeurs destinées au développeur que le Component déclare. Une FeatureRecipe fait de même pour une Feature au moment de la liaison.
Ce dont les opérations sont responsables : les templates qui rendent la sortie native du provider à partir des values du développeur et du dimensionnement infra de l’opérateur, et les valeurs provides qu’une Recipe transmet aux consommateurs. Les ingénieurs des opérations réutilisent leur code d’infrastructure existant en l’empaquetant sous forme de Recipes ; ils ne sont jamais tenus d’apprendre un langage de politiques propre au catalogue.
Opérateur de plateforme — câblage du déploiement
L’opérateur rédige les Manifests et les Releases : la couche de routage et l’entrée de compilation par environnement. Un Manifest indique au compilateur quelle Recipe réalise chaque Component pour une cible donnée, de sorte que le même Aggregate peut atteindre des implémentations différentes d’un environnement à l’autre. Une Release est l’unique entrée de compilation — elle pointe vers l’Aggregate et le Manifest, satisfait les paramètres que le développeur a exposés, attache les Features dont les entrées sont opérationnelles, dimensionne avec infra celles que le développeur a attachées et câble ses propres arêtes dans les sockets que l’architecte a déclarés.
Ce dont l’opérateur est responsable : la table de routage du Manifest, la satisfaction des paramètres par la Release, le dimensionnement infra que reçoit chaque composant, les attachements des Features dont les entrées sont opérationnelles et l’infra par arête qu’une Release écrit sur une connexion. L’opérateur satisfait les points de variation exposés par le développeur ; la Release ne peut introduire ni nouvelles valeurs applicatives ni nouvelles ressources de calcul — celles-ci proviennent uniquement de l’Aggregate.
Les rôles sont des casquettes, pas des effectifs
Dans une grande entreprise, ces quatre rôles sont des services distincts, avec des expertises et des fréquences de changement différentes — le catalogue évolue quand l’équipe plateforme livre une nouvelle capacité, les Recipes évoluent quand l’infrastructure change, les Releases changent à chaque déploiement. Dans une petite équipe ou un projet individuel, une seule personne porte toutes les casquettes. Comme les Components et les Recipes sont des artefacts partageables et versionnés, un auteur peut souvent rester purement dans le rôle de développeur et consommer un catalogue préconstruit pour tout le reste.
Lisez ensuite Entités par rôle pour la correspondance complète entre types et rôles, y compris les types bibliothèque et plugin qui soutiennent les quatre rôles.