Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Legare un carico di lavoro a ciò che pubblica un’associazione

Una singola app stateless renderizzata su Kubernetes dalla sintesi del Workload del provider helm — nessun chart esterno. L’app viene eseguita con un’identità cloud per cui il suo Component dichiara uno slot e che la Release riempie: l’associazione che riempie lo slot emette un ServiceAccount Kubernetes e ne pubblica il nome, e la Recipe dell’app lega il pod a quel nome pubblicato.

Il punto didattico è la direzione del flusso. Il produttore indica il nome una sola volta; il consumatore lo legge. Nulla sul lato consumatore ripete un valore che il produttore possiede già, quindi i due non possono divergere.

Generare l’esempio

Puoi eseguire la build di questo esempio con i comandi qui sotto, oppure farla eseguire al tuo assistente IA.

Scrivi l’esempio in una nuova cartella che porta il suo nome:

Terminal window
aggrega scaffold --example workload-identity-binding

Poi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:

Terminal window
cd workload-identity-binding

Build

Terminal window
aggrega build --release release.yaml --auto-pull

Il catalogo viene risolto da due sorgenti indicate in .aggrega-config.yaml: il ./catalog proprio dell’esempio (il Component local/compute/identity-app e la sua Recipe di sintesi helm/identity-app) e il registry dell’hub (la Feature core/gcp-workload-identity e la sua FeatureRecipe). --auto-pull scrive durante la build il lockfile che manca a un clone appena creato. Tre manifest finiscono in dist/helm/helm/.

Con un assistente AI

Un assistente IA configurato con gli strumenti di Aggrega può fare lo stesso: incolla questo prompt nell’assistente.

Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella dell’area di lavoro non contiene ancora una cartella `workload-identity-binding`, chiama una volta lo strumento `scaffold` con `example` impostato su `workload-identity-binding` e senza `dir`: scrive l’esempio in una nuova cartella `workload-identity-binding`. Poi chiama lo strumento `build` con `workspace_root` impostato su `workload-identity-binding`, `release` impostato su `release.yaml`, `auto_pull` impostato su true e `write` impostato su true. Dimmi quali file ha scritto la build; si trovano sotto `workload-identity-binding/dist/`.

Il Component dichiara l’esigenza; la Release la soddisfa

L’app ha bisogno di un’identità con cui essere eseguita, quindi il suo Component ne dichiara una, come slot identity obbligatorio:

catalog/component/local/compute/identity-app/1.0.0/component.yaml
featuresSchema:
identity:
required: true
selector: "feature.aggrega.ai/kind!=secret"
inject: []

L’Aggregate non scrive nulla al riguardo. Con quale identità viene eseguita l’app, e su quale cloud, è una scelta dell’operatore per ogni target, quindi la Release riempie lo slot con la Feature di identità e con ogni campo di cui quella Feature ha bisogno:

release.yaml
features:
identity:
type: core/gcp-workload-identity
infra:
service_account_name: app-workload-identity
gcp_service_account: app-dev@example-project.iam.gserviceaccount.com

Una Release che lascia lo slot vuoto si arresta, indicando lo slot. Una Release per un cluster EKS riempie invece lo stesso slot con core/aws-irsa e il suo role_arn, e il suo Manifest mappa quella Feature sulla sua FeatureRecipe. Il selettore tiene una credenziale fuori dallo slot: una Feature di tipo segreto che lo riempie provoca un arresto.

L’associazione pubblica

La Feature dichiara nel proprio schema.provides di pubblicare un name, e la sua FeatureRecipe lo pubblica — dallo stesso valore locale con cui il chart emesso dà il nome al ServiceAccount, che è il service_account_name impostato dall’operatore quando la Release ne scrive uno:

# FeatureRecipe gcp-workload-identity
locals:
sa_name: '{{ default (printf "%s-%s" .context.rendered_name (.attachment_name | replace "_" "-")) .infra.service_account_name }}'
provides:
name: "{{ .locals.sa_name }}"

La Recipe consuma

La Recipe consumatrice legge il nome pubblicato in .features.<instance-name>.provides.<key>:

# helm/identity-app recipe workload
serviceAccount: "{{ .features.identity.provides.name }}"
containers:
main:
variables:
IDENTITY_SERVICE_ACCOUNT: {{ .features.identity.provides.name }}

Entrambe le letture si risolvono nel ServiceAccount che l’associazione ha effettivamente emesso:

app--identity--app-serviceaccount-app-workload-identity.yaml
[… omitted: the apiVersion]
kind: ServiceAccount
metadata:
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]
app-deployment.yaml
[… 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-identity

Perché leggerlo invece di ripeterlo

L’alternativa è scrivere app-workload-identity una seconda volta sul lato consumatore. Funziona finché qualcuno non cambia il service_account_name dell’operatore e aggiorna solo uno dei due punti — a quel punto il pod richiede un ServiceAccount che non esiste, e nulla nella compilazione se ne accorge, perché entrambe le grafie sono stringhe valide.

Leggere .features.identity.provides.name elimina la seconda grafia. La stessa struttura vale per ogni associazione: una credenziale pubblica il localizzatore del proprio Secret in .features.<slot>.provides.name, un sidecar pubblica la propria porta, un’identità pubblica il proprio nome. La struttura completa dell’associazione, campo per campo, si trova in templates/template-context-contract.md.

Dimensionamento da parte dell’operatore

release.yaml soddisfa il pilastro del dimensionamento dell’operatore per ambiente: il tag dell’immagine del container proviene da infra.image_tag (myapp:1.2), e l’identità — la sua Feature e i campi di quella Feature — proviene dal riempimento dello slot. L’Aggregate dello sviluppatore non contiene né l’uno né l’altra.