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

Redis — un Aggregate, due target, autenticazione facoltativa

Questo esempio essenziale compila una singola cache in memoria Redis (protocollo di rete di Redis) a partire da un unico Aggregate scritto dallo sviluppatore in due realizzazioni:

  • Docker Compose per lo sviluppo locale, e
  • la Recipe helm sintetizzata che esegue l’immagine upstream ufficiale redis direttamente su Kubernetes (nessun chart esterno).

La Recipe helm sintetizzata è il percorso Kubernetes: dipende solo da un tag di immagine ufficiale anziché da un chart di terze parti, e il suo insieme di risorse renderizzato è esattamente ciò che dichiara il carico di lavoro.

Lo stesso aggregate.yaml guida entrambe. Per ogni realizzazione cambia solo il livello di Recipe selezionato dal Manifest. Un secondo Aggregate, aggregate-auth.yaml, mostra la stessa cache con una credenziale facoltativa per la password associata per il percorso Compose; aggregate-helm-synth-auth.yaml associa una credenziale referenziabile per il percorso helm sintetizzato.

Le Recipes Redis del catalogo che questo esempio mappa, compose/redis e helm/redis, dichiarano la licenza AGPL-3.0. L’esempio valkey-cache distribuisce Valkey, che parla lo stesso protocollo di rete; la sua Recipe helm/valkey dichiara BSD-3-Clause.

File

FileRuolo
aggregate.yamlIntento dello sviluppatore: un componente cache di tipo core/datastore/redis, nessuna credenziale — la cache funziona senza autenticazione.
aggregate-auth.yamlLa stessa cache con una credenziale per la password associata allo slot facoltativo password del componente (percorso Compose).
aggregate-helm-synth-auth.yamlLa stessa cache con una credenziale referenziabile associata per il percorso helm sintetizzato — il valore viene materializzato come un Secret Kubernetes a cui fa riferimento il Deployment.
manifest-compose.yamlMappa il tipo Redis sulla Recipe Compose (compose/redis) e la credenziale su dotenv-secret.
manifest-helm-synth.yamlMappa il tipo Redis sulla Recipe helm sintetizzata (helm/redis) e la credenziale su k8s-secret-from-parameter.
release-compose.yaml / release-helm-synth.yamlDocumenti dell’operatore per le due realizzazioni, nessuna autenticazione.
release-compose-auth.yaml / release-helm-synth-auth.yamlDocumenti dell’operatore che abilitano l’autenticazione.

Che cosa dimostra

  • Un’unica superficie di authoring, molti target. Un unico Aggregate è la fonte di verità su che cosa è lo stack. Ogni Manifest dice come realizzarlo.
  • Un datastore con ruolo di cache. Qui Redis è usato come cache in memoria e non conserva nulla in modo durevole, quindi il componente è tipizzato come un semplice server anziché come stateful-server. Su Kubernetes la Recipe sintetizzata renderizza un Deployment, non uno StatefulSet, e non richiede alcun volume persistente; su Compose il servizio non dichiara alcun volume di dati.
  • Sintesi del Workload (Kubernetes). La Recipe helm sintetizzata dichiara un Workload — un Deployment più un Service ClusterIP che esegue l’immagine ufficiale redis — che il provider helm traduce in manifest Kubernetes senza alcun chart esterno. L’insieme di risorse renderizzato è esattamente ciò che dichiara il Workload. Poiché il nome redis è portato sia da una Recipe Compose sia da una helm sintetizzata, i Manifests vi fanno riferimento con ambito di provider come compose/redis e helm/redis.
  • Autenticazione facoltativa tramite uno slot di credenziali. Il componente dichiara un unico slot facoltativo password nel proprio featuresSchema. Quando non è associata alcuna credenziale (l’Aggregate di base), la Recipe renderizza la cache con l’autenticazione disabilitata — in modo identico byte per byte a una Recipe senza slot. Quando è associata una credenziale, entrambi i target avviano Redis con --requirepass, così il server richiede la password: su Compose (aggregate-auth.yaml) il valore viene passato al server come quell’argomento; sul percorso Kubernetes sintetizzato (aggregate-helm-synth-auth.yaml) viene materializzato come un Secret a cui fa riferimento il Deployment.

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 redis-cache

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

Terminal window
cd redis-cache

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
# Local development (Docker Compose), no authentication
aggrega build --release release-compose.yaml --auto-pull
# Kubernetes (synthesized helm Recipe, official image), no authentication
aggrega build --release release-helm-synth.yaml --auto-pull
# The same realizations with authentication enabled
aggrega build --release release-compose-auth.yaml --auto-pull
aggrega build --release release-helm-synth-auth.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 Workspace non contiene ancora una cartella `redis-cache`, chiama una volta lo strumento `scaffold` con `example` impostato a `redis-cache` e senza `dir`: scrive l’esempio in una nuova cartella `redis-cache`. Poi chiama lo strumento `build` una volta per ogni Release, in quest’ordine — `release-compose.yaml`, `release-helm-synth.yaml`, `release-compose-auth.yaml` e `release-helm-synth-auth.yaml` — ogni volta con `workspace_root` impostato a `redis-cache`, `release` impostato a quel file, `auto_pull` impostato a true e `write` impostato a true. Dimmi quali file ha scritto ogni build; si trovano in `redis-cache/dist/`.

Nota sulla consegna delle credenziali

Sul percorso Compose la credenziale è un segreto inject-value (aggregate-auth.yaml): il suo valore viene consegnato sulla pipe d’ambiente del componente con la variabile indicata dal suo values.key, REDIS_PASSWORD, e la Recipe lo passa al server come --requirepass. L’immagine ufficiale redis non legge alcuna variabile per la password, quindi il valore viene passato come argomento e compare nel comando del servizio. Un’associazione il cui valore non raggiunge la Recipe con alcuna variabile che essa legga arresta la build, indicando lo slot, anziché lasciare la cache aperta.

Il percorso helm sintetizzato usa una credenziale referenziabile (aggregate-helm-synth-auth.yaml): il valore viene materializzato come Secret Kubernetes, il Deployment vi fa riferimento tramite un secretKeyRef env, e Redis viene avviato con --requirepass che legge quella variabile d’ambiente. La password in chiaro quindi non compare mai nel manifest del Deployment — solo nel Secret. È questo che abilita davvero l’autenticazione sull’immagine ufficiale redis, che da sola non legge una password dall’ambiente.

Il valore origin negli Aggregates autenticati è un segnaposto di sviluppo; fornisci un valore reale tramite la tua sorgente di credenziali per qualsiasi distribuzione reale.