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

Valkey — un Aggregate, due target, autenticazione facoltativa

Questo esempio essenziale compila una singola cache in memoria Valkey (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 valkey/valkey 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. Altri due Aggregates mostrano la stessa cache con una credenziale facoltativa per la password associata: aggregate-auth.yaml per il percorso Compose (una credenziale inject-value con cui viene avviato il server) e aggregate-helm-synth-auth.yaml per il percorso helm sintetizzato (una credenziale referenziabile materializzata come Secret Kubernetes).

File

FileRuolo
aggregate.yamlIntento dello sviluppatore: un componente cache di tipo core/datastore/valkey, 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 Valkey sulla Recipe Compose (compose/valkey) e la credenziale su dotenv-secret.
manifest-helm-synth.yamlMappa il tipo Valkey sulla Recipe helm sintetizzata (helm/valkey) 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 Valkey è 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 helm 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 valkey/valkey — 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 valkey è portato sia da una Recipe Compose sia da una helm sintetizzata, i Manifests vi fanno riferimento con ambito di provider come compose/valkey e helm/valkey.
  • 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 Valkey con --requirepass, così il server richiede la password: su Compose il valore raggiunge il server tramite la variabile VALKEY_EXTRA_FLAGS dell’immagine; su Kubernetes il percorso helm sintetizzato lo materializza 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 valkey-cache

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

Terminal window
cd valkey-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 dell’area di lavoro non contiene ancora una cartella `valkey-cache`, chiama una volta lo strumento `scaffold` con `example` impostato su `valkey-cache` e senza `dir`: scrive l’esempio in una nuova cartella `valkey-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 su `valkey-cache`, `release` impostato su quel file, `auto_pull` impostato su true e `write` impostato su true. Dimmi quali file ha scritto ciascuna build; si trovano sotto `valkey-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, VALKEY_PASSWORD, e la Recipe lo passa al server come --requirepass tramite la variabile VALKEY_EXTRA_FLAGS dell’immagine, così compare nell’ambiente del servizio ma non nella sua riga di comando. Lo script di avvio dell’immagine espande quella variabile senza virgolette, quindi una password che contiene uno spazio arresta il server all’avvio, e una che contiene *, ? o [ viene confrontata con i nomi dei file nella directory dei dati del server: scrivi quindi la password senza nessuno dei due. Un’associazione per la password il cui valore non raggiunge la Recipe con alcuna variabile che essa legga arresta la build, indicando lo slot, anziché renderizzare una cache non protetta.

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 Valkey 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 valkey/valkey, 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.