Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Cycles de vie Day-2

Cycles de vie Day-2 et exécution temporelle

Un compilateur anticipé (Ahead-of-Time, AOT) agnostique vis-à-vis des capacités crée intrinsèquement un écart entre l’intention déclarative (Day-1) et la réalité opérationnelle (Day-2). Le cloud n’est pas parfaitement déterministe, le déploiement exige un séquencement temporel, et les développeurs ont besoin de déclencheurs impératifs pour les tâches de maintenance.

Aggrega comble structurellement ces écarts grâce à des polyfills architecturaux spécifiques et à un routage natif GitOps, de sorte que les configurations générées répondent à ces besoins opérationnels sans compromettre la pureté du compilateur central.

1. Le modèle d’exécution DAG (séquencement temporel)

Le problème : le déploiement d’infrastructure est un graphe orienté acyclique (DAG) du temps. Une task de migration de base de données doit s’exécuter jusqu’au bout avant que le server web ne démarre. Or les compilateurs AOT génèrent des dossiers plats de YAML statique ou de Terraform. Si vous remettez ces dossiers plats à un contrôleur GitOps (comme ArgoCD), il applique tout simultanément, ce qui fait entrer le serveur web dans une boucle de plantage pendant qu’il attend la base de données.

La solution : syncWave par frontière dans la Release L’Aggregate du développeur reste intact. Le séquencement étant une réalité opérationnelle physique, il est géré strictement dans le Domaine 4 (la Release). Chaque frontière de la Release porte un champ facultatif syncWave: <integer>, qui permet à l’opérateur de plateforme d’échelonner explicitement l’ordre de déploiement au niveau de la frontière.

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: sequenced-release
version: 1.0.0
environment: production
spec:
aggregate: my-app
manifest: prod-manifest
boundaries:
infra:
syncWave: 0
components:
core-vpc: {}
postgres-db: {}
migrations:
syncWave: 1
components:
db-migration-task: {}
apps:
syncWave: 2
components:
web-server: {}
support-agent: {}

Sémantique de la valeur de vague :

  • La vague est un entier signé ; la valeur par défaut est 0. Les valeurs négatives s’exécutent avant tout le reste (CRD, namespaces, RBAC) ; les valeurs plus grandes s’exécutent après les plus petites. Les opérateurs choisissent les valeurs selon leur topologie de déploiement.
  • Chaque instance de composant directement contenue dans une frontière hérite de la valeur de vague de la frontière dans son nœud IR. Il n’existe aucune surcharge par composant au niveau de l’écriture — l’ordre par ressource interne au provider au sein d’une même frontière relève du provider.
  • Les frontières imbriquées n’héritent pas implicitement. Une frontière imbriquée qui ne déclare pas syncWave prend la valeur par défaut 0, quelle que soit la déclaration de la frontière extérieure. Les opérateurs qui veulent « tout outer est en vague 1, y compris sa sous-frontière inner » déclarent syncWave: 1 sur les deux.

L’effet du compilateur : Le compilateur propage la valeur de wave de chaque boundary aux manifestes rendus dans cette boundary. Les Providers émettent des primitives de séquencement natives :

  • Pour Kubernetes (ArgoCD/Flux) : le provider helm émet argocd.argoproj.io/sync-wave: "<N>" en tant qu’entrée de metadata.annotations sur chaque manifeste rendu, et une ressource que le chart marque comme hook Helm reçoit en outre helm.sh/hook-weight: "<N>" pour l’ordre natif des hooks Helm. Le provider helm-chart n’émet l’annotation que sur les fichiers de template qu’une Recipe ajoute à un chart via artifacts: ; il copie sans modification les templates propres au chart, qui ne portent donc aucune wave.
  • Pour Compose : le provider compose exprime l’ordre sous forme de depends_on entre les services du fichier dans lequel une frontière est rendue, conditionné à l’état de santé de la cible là où la cible déclare un healthcheck, et à son démarrage là où elle n’en déclare pas. depends_on nomme un service au sein d’un seul fichier, de sorte que l’ordre entre deux fichiers compose n’est pas exprimable ; les opérateurs séquencent des projets compose distincts au niveau de l’invocation de docker compose up.
  • Pour CloudFormation : le provider cloudformation exprime l’ordre sous forme de DependsOn entre les ressources du modèle de stack dans lequel un groupe de dispatch est assemblé, chaque ressource nommant les ressources de la vague peuplée immédiatement précédente et la cible chaînant le reste. L’attribut régit l’ordre de suppression, en sens inverse, aussi bien que l’ordre de création ; il n’exprime aucune condition de disponibilité, car un modèle n’a aucune notion d’une ressource opérationnelle. DependsOn nomme une ressource au sein d’un seul modèle, de sorte que l’ordre entre deux stacks n’est pas exprimable ; les opérateurs séquencent des stacks distinctes au niveau du déploiement.
  • Pour Terraform : le provider terraform exprime l’ordre sous forme de depends_on entre les blocs module de la configuration racine dans laquelle une boundary est assemblée, chaque module nommant les modules de la wave peuplée immédiatement précédente et Terraform enchaînant le reste. Il ordonne les actions qu’effectue Terraform et n’exprime aucune condition de disponibilité, car une configuration n’a aucune notion d’une ressource prête à servir. depends_on nomme un module à l’intérieur d’une configuration, de sorte que l’ordre entre deux configurations racines n’est pas exprimable ; les séquencer relève de l’opérateur.

La clé interne à Aggrega aggrega.ai/sync-wave: "<N>" est livrée avec l’annotation ArgoCD à des fins d’observabilité et de provenance — comme annotation sur la sortie helm et sur les fichiers de template qu’une Recipe ajoute à un chart helm-chart, comme label de service sur compose, comme ligne du commentaire de provenance dans chaque module terraform, et sous Metadata."aggrega.ai/provenance" de chaque ressource cloudformation — tandis que c’est l’annotation ArgoCD que consomment les contrôleurs GitOps.

Unité d’écriture des vagues et unité déployable

La frontière est l’unité d’écriture des vagues. L’unité déployable est le chemin d’assemblage — la sortie sur disque produite par le compilateur, sur laquelle un pipeline CI/CD orchestre. Par défaut, une frontière correspond à un chemin d’assemblage : les composants de chaque frontière sont émis sous boundaries/<boundary-name>/<provider>/, et helm install / docker compose up s’exécute sur ce chemin.

Les opérateurs peuvent fusionner cette correspondance 1:1. Les frontières peuvent déclarer des champs de modèle de chemin directory: (et subDirectory:) qui, lorsqu’ils sont partagés entre frontières, acheminent les composants de ces frontières vers une seule sortie assemblée au chemin partagé. Deux frontières qui déclarent directory: "deploy/cluster" produisent une seule sortie assemblée contenant les composants des deux — l’unité déployable devient le chemin d’assemblage, et non l’identité de la frontière.

Les manifestes de vagues mixtes au sein d’une même sortie assemblée sont normaux et pris en charge. Lorsque la frontière A déclare syncWave: 1 et la frontière B syncWave: 2, et que les deux partagent directory: "deploy/cluster", l’unité déployable résultante contient les composants des deux frontières ; chaque manifeste porte l’annotation de vague de sa frontière d’origine. L’outillage d’exécution lit les annotations par ressource et ordonne au sein de l’unité de déploiement assemblée — le contexte de synchronisation par Application d’ArgoCD traite les manifestes de la vague 1, attend qu’ils soient Healthy, puis traite la vague 2 ; l’ordre des hooks de Helm lit helm.sh/hook-weight par ressource de hook. C’est le modèle standard d’ArgoCD : l’émission par ressource est exactement l’entrée qu’attendent les consommateurs des autres outils.

Le séquencement entre Applications (lorsqu’un opérateur exécute plusieurs Applications ArgoCD sur des sorties assemblées distinctes) relève de la configuration CI au niveau de l’opérateur — Aggrega produit les artefacts ; l’opérateur organise ses Applications ArgoCD autour d’eux via app-of-apps ou Progressive Sync. Le modèle d’annotation par ressource d’Aggrega est la forme d’entrée standard qu’attend chaque consommateur des autres outils.

2. Le polyfill d’adressage dynamique

Le problème : le cloud n’est pas déterministe au moment de la création. Des ressources comme les instances AWS RDS ou les buckets S3 génèrent des hachages d’URL aléatoires seulement après avoir été physiquement provisionnées. Comme le compilateur AOT génère la configuration avant que le cloud ne provisionne quoi que ce soit, il est physiquement impossible pour le compilateur d’injecter l’URL littérale de la base de données dans la variable d’environnement d’un conteneur.

La solution : des pointeurs déterministes via les Features d’identifiants Aggrega résout ce problème en s’appuyant sur les Features d’identifiants existantes, déplaçant la définition de « déterministe » d’une adresse IP littérale vers un pointeur déterministe. La configuration générée ne transmet pas l’URL ; elle transmet le chemin vers un Cloud Vault où l’URL existera.

  • Exemple 1 : la génération de la sortie (Terraform RDS) La Recipe Ops de la base de données crée l’instance AWS RDS. Point essentiel, la Recipe est écrite pour publier nativement l’URL dynamique nouvellement générée dans AWS Systems Manager (SSM) Parameter Store, à un chemin nommé de façon déterministe (par ex. /aggrega/prod/db-url).
  • Exemple 2 : l’injection de l’entrée (application Kubernetes) Le développeur attache la Feature d’identifiant core/referenced-secret au worker, dans un slot que déclare son Component, avec origin défini sur la chaîne du pointeur déterministe ("/aggrega/prod/db-url"). Sur une cible Kubernetes, le Manifest lie cet attachement à helm/k8s-external-secret, qui rend un ExternalSecret Kubernetes demandant à l’opérateur de secret store du cluster de récupérer cette entrée dans un Secret, et publie le nom du Secret et sa clé de données ; la Recipe du worker les lit via les attachments: de son conteneur et rend une variable d’environnement de Pod mappée sur valueFrom: secretKeyRef (voir Comment un identifiant atteint un conteneur). Le compilateur achemine la chaîne du pointeur et ne lit jamais l’URL.

À l’exécution, Terraform provisionne la base de données et enregistre l’URL dans le coffre. Le conteneur démarre, lit le Secret réconcilié depuis le coffre et se connecte. Le compilateur AOT a généré les relations au moyen de chaînes de pointeur stables, sans jamais avoir besoin de l’adresse IP littérale.

3. Actions impératives (le relais exécutable)

Le problème : l’état déclaratif est parfait pour le provisionnement Day-1, mais les développeurs doivent exécuter des actions impératives : « Lance une sauvegarde de la base tout de suite. » Un pipeline GitOps strictement déclaratif n’a aucun mécanisme natif pour redéclencher un script statique.

La solution : des tâches dormantes et la commande propre à la cible Aggrega résout ce problème tout en préservant une stricte pureté AOT. Il génère la configuration d’une tâche déployée sans démarrer, et chaque exécution est lancée sur la cible avec la commande propre à la cible.

  1. L’intention du développeur : le développeur déclare le script comme task dans l’Aggregate et attache une Feature demandant qu’il soit exécuté à la demande (par ex. core/manual-trigger). Être exécutée à la demande fait partie de ce qu’est la tâche, c’est donc le développeur qui l’attache ; une Feature dont toutes les entrées sont opérationnelles est attachée par les opérations, dans la Release.
  2. La forme dormante : la Recipe propre à la tâche sur chaque cible lit l’attachement et rend la tâche sous une forme qui se déploie sans lancer d’exécution. Sur Kubernetes, la tâche est un CronJob maintenu avec suspend: true, sur une planification indiquant une date qui n’arrive jamais, à la place du Job qui s’exécuterait dès son déploiement. Sur Docker Compose, le service de la tâche, que Compose ne redémarre pas une fois terminé, porte le profil manual, de sorte que docker compose up le laisse arrêté. Sur Amazon ECS, via Terraform ou CloudFormation, la définition de tâche est déployée seule, sans planification pour la lancer. La FeatureRecipe que le Manifest lie pour l’attachement n’ajoute aucun fichier propre sur aucune cible : le changement se trouve dans la sortie propre de la tâche.
  3. Le passage de relais : le compilateur n’atteint aucun cluster et n’appelle aucune API cloud, et le build ne lance aucune exécution et n’écrit aucun script. Chaque exécution est lancée par l’opérateur, avec la commande propre à la cible : kubectl create job <run-name> --from=cronjob/<cronjob> sur Kubernetes, docker compose run --rm <service> sur Docker Compose, et aws ecs run-task sur Amazon ECS, en lui donnant le cluster, la définition de tâche et la configuration réseau que la Release définit sous infra.overrides de la tâche. La génération de la configuration et l’exécution au runtime restent séparées.

(Remarque : sur Kubernetes et Amazon ECS, une tâche dotée d’une planification s’exécute selon celle-ci, que l’attachement soit présent ou non, et la même commande lance une exécution supplémentaire entre les exécutions planifiées ; sur Docker Compose, qui n’a pas de planificateur, la Recipe de la tâche refuse une planification. L’exemple détaillé task-run-on-demand compile un même Aggregate pour Kubernetes, Docker Compose, Terraform et CloudFormation, et montre pour chacun la sortie rendue et la commande qui lance une exécution.)

4. Pré-analyse : le hook du workspace (RBAC et quotas de la plateforme)

Le problème : certaines modifications provisionnent une infrastructure coûteuse ou critique pour la production — un grand cluster GPU, par exemple — et ne doivent pas entrer dans le pipeline GitOps sans revue. Quels contributeurs peuvent promouvoir quelles modifications vers quels environnements relève d’une décision de politique organisationnelle ; le compilateur ne doit pas la coder en dur.

La solution : un compilateur AOT pur ne peut ni interroger Active Directory ni récupérer des identifiants cloud pour savoir qui exécute le build. Pour empêcher toute génération non autorisée avant même l’exécution de la CI/CD, l’architecture repose sur une injection explicite du contexte.

Lorsque aggrega build est invoqué par un runner CI/CD, le pipeline écrit le contexte d’exécution dans un fichier de configuration qu’il transmet avec --config, en tant que with.settings du rattachement de gouvernance qui le juge (p. ex. approval: standard). Le fichier liste ses rattachements sous governance_append, de sorte qu’ils s’ajoutent aux plugins de gouvernance que rattache la configuration propre de l’espace de travail au lieu d’être remplacés par eux. Une politique au rôle ir-verdict lit ces paramètres comme input.settings. Elle reçoit le graphe assemblé et non la Release, si bien que l’environnement de la Release lui parvient sous forme d’étiquette : une politique au rôle label-transform lit input.compilation_context.environment et en étiquette chaque nœud. Le verdict compare les deux et arrête le build lorsqu’ils divergent — ici, un build de production dont les paramètres ne portent pas approval: platform-approved :

# ci-governance.yaml — written by the CI/CD runner, passed as `aggrega build --config ci-governance.yaml`
plugins:
governance_append:
- uri: governance/rego:<version>
role: label-transform
with:
sources:
- policies/environment.rego
- uri: governance/rego:<version>
role: ir-verdict
with:
sources:
- policies/approval.rego
settings:
approval: standard
# policies/environment.rego — evaluated by the governance label-transform role, during topology construction
package acme.context
import rego.v1
labels contains {"node": id, "key": "acme.com/environment", "value": input.compilation_context.environment} if {
some id, _ in input.graph.nodes
}
# policies/approval.rego — evaluated by the governance ir-verdict role over the assembled graph
package acme.approval
import rego.v1
approved if input.settings.approval == "platform-approved"
deny contains msg if {
not approved
some node in input.graph.spec.nodes
node.labels["acme.com/environment"] == "production"
msg := "a production build needs the approval platform-approved in the pipeline's governance settings."
}

Une exécution dont les paramètres ne portent aucune approbation est refusée elle aussi, car la règle demande si l’approbation est présente plutôt que si une approbation différente l’est. Cela isole le RBAC de la logique native du compilateur, en garantissant que le compilateur agit purement comme un évaluateur déterministe des données fournies.

5. FinOps shift-left (estimation des coûts via des politiques)

Le problème : des erreurs de configuration accidentelles (par ex. demander workers: 500) peuvent contourner les garde-fous financiers et déclencher d’importants dépassements de coûts cloud.

La solution (politiques Wasm d’entreprise) : comme le graphe IR contient la topologie complète et la Release le mappage physique (.infra), les entreprises peuvent évaluer le coût exact de ce qu’une Release déploie avant la génération, sans avoir besoin d’une fonctionnalité du compilateur codée en dur. Les entreprises écrivent simplement un plugin WebAssembly FinOps personnalisé et l’attachent au socket de gouvernance dans un rôle de verdict. Ce plugin personnalisé peut lire les charges utiles .infra, calculer le coût mensuel estimé et arrêter le build si le coût calculé dépasse les limites budgétaires définies en interne par l’entreprise.

6. Le cycle de vie de l’import « brownfield »

Le problème : les entreprises font déjà tourner la majeure partie de leur infrastructure. Si Aggrega est conçu pour connecter un build à une infrastructure non gérée au moyen d’un workload de référence (réseau pass-through ; voir workloads de référence), faire passer une base de données Oracle existante dans l’état Terraform généré par Aggrega amène généralement les orchestrateurs à tenter de recréer la base de données, détruisant les données existantes.

La solution (prévue) : Une Feature core/resource-adoption est prévue pour gérer le cycle de vie de l’import.

Lorsqu’un développeur modélise la base de données existante dans son Aggregate et attache la fonctionnalité resource-adoption dans un pipeline exécuté séquentiellement, le plugin de rendu Wasm est conçu pour évaluer la charge utile de base de la Recipe Ops. Au lieu d’émettre les configurations de création standard, le plugin est conçu pour produire la syntaxe d’adoption explicite de la plateforme cible (par ex. en renvoyant un JSONPatch avec des blocs Terraform import {} ou des politiques de gestion Crossplane ObserveOnly). Cela permet aux entreprises de générer en toute sécurité des configurations qui intègrent l’architecture existante dans le plan de contrôle GitOps sans interruption de service.

7. Bonnes pratiques Ops et nommage déterministe

Alors que le compilateur central s’appuie sur des identifiants de nœud internes et stables (par ex. support-db) dans le graphe IR plat, les fournisseurs cloud physiques (comme AWS, Azure et GCP) exigent souvent des chaînes globalement uniques pour l’infrastructure physique (par ex. noms de buckets S3, noms de rôles IAM ou domaines API Gateway).

Si un ingénieur Platform Ops code en dur un nom physique dans son modèle de base (par ex. bucket_name: "enterprise-data-bucket"), les artefacts générés s’appliqueront proprement la première fois. Mais si un développeur déploie un second environnement (par ex. staging vs prod), le fournisseur cloud rejettera les ressources du second environnement à l’exécution en raison d’une collision de noms.

La règle de la sortie déterministe (sécurité GitOps) : comme les contrôleurs GitOps (ArgoCD, Flux) effectuent une détection de différences au niveau de l’octet sur les artefacts rendus, le compilateur garantit que des entrées identiques produisent des sorties identiques à l’octet près. Les maps qui circulent dans le contexte de modèle (.context.inject.env, .values, .infra et le reste de la vue d’exécution) reposent sur des structures de map ordonnées qui préservent l’ordre d’insertion de l’auteur à travers toute la couche de données, et la frontière du modèle est la seule exception : {{ range }} sur ces maps itère dans l’ordre alphabétique des clés, comme le font les modèles Go, et non dans l’ordre de l’auteur. Les ingénieurs Ops peuvent compter sur le fait que cet ordre d’itération soit déterministe d’une exécution à l’autre pour une même entrée ; là où la séquence a un sens, elle est écrite sous forme de liste plutôt que reconstituée à partir d’une map. La fonction Sprig keys renvoie toutefois l’ordre d’itération des maps Go (non déterministe par conception du langage) ; les modèles qui composent une séquence de clés déterministe à partir de la sortie de keys doivent la faire passer par sortAlpha (par ex. {{ keys .values | sortAlpha }}) pour retrouver le déterminisme.

La règle d’or des Recipes Ops (le modèle Helm) : les ingénieurs Platform Ops ne doivent jamais coder en dur les noms physiques des ressources cloud. Ils doivent au contraire construire des noms uniques de façon déterministe en concaténant le contexte de déploiement Aggrega pendant la phase d’évaluation du modèle. Il s’agit d’une règle de réutilisabilité et de protection contre les collisions, et non d’une règle de déterminisme — les noms codés en dur produisent une sortie stable mais entrent fatalement en collision lorsque la même Recipe rend plusieurs instances de composant ou lorsque le même Aggregate est déployé sur plusieurs Releases.

Le compilateur fournit exactement deux variables pour garantir l’unicité globale :

  1. {{ .metadata.release_name }} : le nom de la Release qui pilote le déploiement (par ex. prod-billing).
  2. {{ .context.instance_id }} : l’ID du Component concerné dans l’Aggregate du développeur (par ex. receipt-storage).

En les concaténant (par ex. {{ .metadata.release_name }}-{{ .context.instance_id }}), les Ops garantissent que les configurations générées par les plugins Wasm utilisent des noms de ressource uniques par environnement et par composant, sans que le développeur ait à gérer des conventions de nommage physiques.