Lier une charge de travail à ce que publie un rattachement
Une seule application sans état rendue sur Kubernetes par la synthèse de Workload du fournisseur helm — aucun chart externe. L’application s’exécute sous une identité cloud pour laquelle son Component déclare un emplacement et que la Release remplit : le rattachement qui remplit l’emplacement émet un ServiceAccount Kubernetes et en publie le nom, et la Recipe de l’application lie le pod à ce nom publié.
Le point pédagogique est le sens du flux. Le producteur énonce le nom une seule fois ; le consommateur le lit. Rien du côté consommateur ne reformule une valeur que le producteur possède déjà, si bien que les deux ne peuvent pas diverger.
Générer l’exemple
Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.
Écrivez l’exemple dans un nouveau dossier qui porte son nom :
aggrega scaffold --example workload-identity-bindingElle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :
cd workload-identity-bindingBuild
aggrega build --release release.yaml --auto-pullLe catalogue est résolu à partir de deux sources nommées dans .aggrega-config.yaml : le ./catalog propre à l’exemple (le Component local/compute/identity-app et sa Recipe de synthèse helm/identity-app) et le registre du hub (la Feature core/gcp-workload-identity et sa FeatureRecipe). --auto-pull écrit pendant le build le fichier de verrouillage qui manque à un clone neuf. Trois manifestes arrivent sous dist/helm/helm/.
Avec un assistant IA
Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.
Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier de l’espace de travail ne contient pas encore de dossier `workload-identity-binding`, appelez une fois l’outil `scaffold` avec `example` défini sur `workload-identity-binding` et sans `dir` : il écrit l’exemple dans un nouveau dossier `workload-identity-binding`. Appelez ensuite l’outil `build` avec `workspace_root` défini sur `workload-identity-binding`, `release` défini sur `release.yaml`, `auto_pull` défini sur true et `write` défini sur true. Indiquez-moi quels fichiers le build a écrits ; ils se trouvent sous `workload-identity-binding/dist/`.Le Component déclare le besoin ; la Release le comble
L’application a besoin d’une identité sous laquelle s’exécuter, si bien que son Component en déclare une, sous la forme d’un emplacement identity obligatoire :
featuresSchema: identity: required: true selector: "feature.aggrega.ai/kind!=secret" inject: []L’Aggregate n’écrit rien pour cela. L’identité sous laquelle l’application s’exécute, et sur quel cloud, relève du choix de l’opérateur pour chaque cible, si bien que la Release remplit l’emplacement avec la Feature d’identité et chaque champ dont cette Feature a besoin :
features: identity: type: core/gcp-workload-identity infra: service_account_name: app-workload-identity gcp_service_account: app-dev@example-project.iam.gserviceaccount.comUne Release qui laisse l’emplacement vide s’arrête, en nommant l’emplacement. Une Release pour un cluster EKS remplit plutôt le même emplacement avec core/aws-irsa et son role_arn, et son Manifest associe cette Feature à sa FeatureRecipe. Le sélecteur garde une information d’identification hors de l’emplacement : une Feature de type secret qui le remplit provoque un arrêt.
Le rattachement publie
La Feature déclare dans son schema.provides qu’elle publie un name, et sa FeatureRecipe le publie — à partir de la même valeur locale avec laquelle le chart émis nomme le ServiceAccount, qui est le service_account_name défini par l’opérateur lorsque la Release en écrit un :
# FeatureRecipe gcp-workload-identitylocals: sa_name: '{{ default (printf "%s-%s" .context.rendered_name (.attachment_name | replace "_" "-")) .infra.service_account_name }}'provides: name: "{{ .locals.sa_name }}"La Recipe consomme
La Recipe consommatrice lit le nom publié à .features.<instance-name>.provides.<key> :
# helm/identity-app recipe workloadserviceAccount: "{{ .features.identity.provides.name }}"containers: main: variables: IDENTITY_SERVICE_ACCOUNT: {{ .features.identity.provides.name }}Les deux lectures se résolvent vers le ServiceAccount que le rattachement a réellement émis :
[… omitted: the apiVersion]kind: ServiceAccountmetadata: name: app-workload-identity annotations: iam.gke.io/gcp-service-account: "app-dev@example-project.iam.gserviceaccount.com" [… omitted: the boundary and recipe annotations, and the labels, that every rendered document carries][… omitted: the Deployment's metadata, selector and pod template up to the containers] containers: - name: main [… omitted: the image and the port] env: [… omitted: the GREETING variable] - name: IDENTITY_SERVICE_ACCOUNT value: app-workload-identity serviceAccountName: app-workload-identityPourquoi le lire plutôt que le répéter
L’alternative consiste à écrire app-workload-identity une seconde fois du côté consommateur. Cela fonctionne jusqu’à ce que quelqu’un modifie le service_account_name de l’opérateur et ne mette à jour qu’un seul des deux endroits — à ce moment-là, le pod demande un ServiceAccount qui n’existe pas, et rien dans la compilation ne le remarque, car les deux graphies sont des chaînes valides.
Lire .features.identity.provides.name supprime la seconde graphie. La même structure s’applique à chaque rattachement : une information d’identification publie le localisateur de son Secret à .features.<slot>.provides.name, un sidecar publie son port, une identité publie son nom. La structure complète du rattachement, champ par champ, se trouve dans templates/template-context-contract.md.
Dimensionnement par l’opérateur
release.yaml satisfait le pilier de dimensionnement de l’opérateur par environnement : le tag d’image du conteneur provient de infra.image_tag (myapp:1.2), et l’identité — sa Feature et les champs de cette Feature — provient du remplissage de l’emplacement. L’Aggregate du développeur ne porte ni l’un ni l’autre.