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

MySQL — un Aggregate, due target

Questo esempio essenziale compila un singolo database MySQL a partire da Aggregate scritti dallo sviluppatore in due target:

  • Kubernetes tramite la sintesi del Workload del provider helm (uno StatefulSet renderizzato direttamente sull’immagine ufficiale mysql, nessun chart esterno), e
  • Docker Compose per lo sviluppo locale.

Lo stesso intento dello sviluppatore guida ciascun target. Per ogni target cambia solo il livello di Recipe selezionato dal Manifest.

File

FileRuolo
aggregate-helm-synth.yamlIntento dello sviluppatore per la variante Kubernetes di base: un componente db di tipo core/datastore/mysql, i suoi valori e soltanto la credenziale obbligatoria root_password.
aggregate-helm-synth-auth.yamlIntento dello sviluppatore per la variante Kubernetes completa: entrambi gli slot di credenziale, root_password e user_password.
manifest-helm-synth.yamlMappa il tipo MySQL sulla Recipe helm sintetizzata (helm/mysql) e ciascuna credenziale sulla sua FeatureRecipe (env-secret, k8s-secret-from-parameter).
release-helm-synth.yamlDocumento dell’operatore per la variante Kubernetes di base, con il dimensionamento operativo (engine_version, storage).
release-helm-synth-auth.yamlDocumento dell’operatore per la variante Kubernetes completa.
aggregate.yamlIntento dello sviluppatore per la destinazione Compose locale: lo stesso componente db con entrambi gli slot di credenziale consegnati come credenziali inject-value.
manifest-compose.yamlMappa il tipo MySQL sulla Recipe Compose (mysql) e la credenziale su dotenv-secret.
release-compose.yamlDocumento dell’operatore per la destinazione Compose locale, che include una voce infra.overrides specifica del provider che fissa l’esatta immagine del container.

Che cosa dimostra

  • Un’unica superficie di authoring, molti target. Un Aggregate è la fonte di verità su che cosa è lo stack. Ogni Manifest dice come realizzarlo.
  • Sintesi del Workload su Kubernetes (preferita). La Recipe helm/mysql dichiara un Workload agnostico rispetto alle capacità con form: stateful; il provider helm sintetizza uno StatefulSet, un Service ClusterIP, un Service headless (l’identità di rete stabile dello StatefulSet) e un volumeClaimTemplate per la directory dei dati. L’ambiente del container contiene MYSQL_DATABASE, MYSQL_USER, MYSQL_ROOT_PASSWORD e MYSQL_PASSWORD. Il set di caratteri e la collation vengono rispettati come argomenti della riga di comando del server mysqld (--character-set-server, --collation-server), perché l’immagine ufficiale mysql li accetta come flag del server anziché come variabili d’ambiente.
  • Sintesi del Workload su Compose. La Recipe Compose dichiara un Workload agnostico rispetto alle capacità; il provider compose sintetizza un servizio docker-compose.yaml con l’immagine MySQL, il suo ambiente, un volume di dati con nome e un controllo di integrità.
  • Una via d’uscita per l’operatore. La release Compose imposta infra.overrides.image, il pilastro aperto per i fatti specifici del provider che lo schema proprio del Component non nomina, e il servizio renderizzato esegue esattamente quel riferimento all’immagine. Vedi Sovrascritture specifiche del Provider.
  • Modello di credenziali a due slot. Le password sono associazioni sul pilastro features: del componente, ciascuna una Feature etichettata feature.aggrega.ai/kind: secret, tenute separate dai values dell’applicazione. Il featuresSchema del Component dichiara uno slot Black-Box root_password e uno slot trasparente user_password.

Consegna delle credenziali su Kubernetes

root_password è uno slot Black-Box (inject: []): la consegna la controlla la Recipe. La credenziale inject-value associata mette il valore sul canale di iniezione del componente, e la Recipe lo legge come .context.inject.env.MYSQL_ROOT_PASSWORD, emettendo una semplice variabile d’ambiente del container. Per esso non viene generato alcun Secret Kubernetes.

user_password è uno slot trasparente (inject: [env, file]). La variante completa associa una credenziale referenziabile, che materializza un Secret Kubernetes e ne pubblica l’identità; la Recipe referenzia lo slot tramite containers.attachments, che il sintetizzatore renderizza come un secretKeyRef di env. Il Secret generato e il riferimento del container nominano la stessa risorsa perché entrambi leggono .features.user_password.provides.name. Anche lasciare user_password non associato (la variante di base) è valido: la Recipe ripiega su un valore predefinito di sviluppo inline (MYSQL_PASSWORD: apppass) e non viene generato alcun Secret, così una distribuzione minima viene comunque renderizzata ed eseguita.

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 mysql-standalone

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

Terminal window
cd mysql-standalone

Build

Questo workspace non contiene alcun .aggrega-config.yaml, quindi le entità della libreria standard vengono risolte dal registry dell’hub, hub.aggrega.ai, e non serve alcun flag di catalogo; --auto-pull scrive durante il build il lockfile che manca a un clone appena creato:

Terminal window
# Kubernetes — synthesized helm StatefulSet (base: root credential only)
aggrega build --release release-helm-synth.yaml --auto-pull
# Kubernetes — synthesized helm StatefulSet (full: both credential slots)
aggrega build --release release-helm-synth-auth.yaml --auto-pull
# Local development (Docker Compose)
aggrega build --release release-compose.yaml --auto-pull

Gli artefatti renderizzati finiscono sotto dist/.

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 del workspace non contiene ancora una cartella `mysql-standalone`, chiama una volta lo strumento `scaffold` con `example` impostato su `mysql-standalone` e senza `dir`: scrive l’esempio in una nuova cartella `mysql-standalone`. Poi chiama lo strumento `build` una volta per ogni Release, in questo ordine — `release-helm-synth.yaml`, `release-helm-synth-auth.yaml` e `release-compose.yaml` — ogni volta con `workspace_root` impostato su `mysql-standalone`, `release` impostato su quel file, `auto_pull` impostato su true e `write` impostato su true. Dimmi quali file ha scritto ciascuna build; si trovano in `mysql-standalone/dist/`.

Dimensionamento da parte dell’operatore

Le release Kubernetes soddisfano il pilastro del dimensionamento da parte dell’operatore per ambiente: il tag dell’immagine del container proviene da infra.engine_version (mysql:8.4), e la richiesta e la storage class del volumeClaimTemplate provengono da infra.storage. L’Aggregate dello sviluppatore non contiene mai questi campi.

Sovrascritture specifiche del Provider

I pilastri di dimensionamento sono campi con nome: il Component dichiara engine_version e storage, quindi un operatore che imposta l’uno o l’altro compila un campo che il Component ha previsto. infra.overrides è il pilastro per ciò che un Component non può prevedere — è dichiarato come un oggetto che accetta qualsiasi struttura annidata, e ogni Recipe documenta quali chiavi legge.

release-compose.yaml lo usa. La Recipe Compose legge una chiave, image, e quando è impostata il container esegue esattamente quel riferimento invece di quello che la Recipe compone a partire da engine_version:

infra:
engine_version: "8.4"
overrides:
image: "registry.internal.example/library/mysql:8.4"

Il servizio renderizzato contiene la sovrascrittura alla lettera:

services:
db:
image: registry.internal.example/library/mysql:8.4
[… omitted: the service's environment, labels, volume, network and health check]

Questo è il percorso verso un build della stessa versione del server replicato in un registry o fissato tramite digest — un dato di distribuzione che appartiene all’ambiente di destinazione, non al contratto del Component. Poiché l’insieme di chiavi è per Recipe anziché per Component, è nella Recipe che si cerca quali chiavi si applicano: la Recipe Compose qui legge image, e una Recipe che non ne legge nessuna lo dice.