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

OpenBao — server di gestione dei segreti su Kubernetes

Questo esempio compila uno stack piccolo e reale — un singolo server di secret OpenBao — a partire da un unico Aggregate scritto dallo sviluppatore per Kubernetes, basato sul chart Helm ufficiale di OpenBao.

OpenBao archivia, genera e controlla l’accesso a token, password, certificati e altri segreti dietro un’API HTTP autenticata, e cifra il proprio stato a riposo su un volume di dati durevole. Qui viene eseguito come un singolo server standalone che mantiene il proprio stato nel backend di archiviazione su file integrato, quindi viene renderizzato come un server con stato in esecuzione, basato su un volume persistente, anziché come una risorsa cloud gestita. Il server viene inizializzato e dissigillato a runtime all’interno del cluster — il suo root token e le sue chiavi di unseal sono prodotti dal server in esecuzione dopo l’avvio — quindi nell’Aggregate non viene dichiarata alcuna credenziale e nessun segreto viene materializzato in fase di build.

File

FileRuolo
aggregate.yamlIntento dello sviluppatore: un singolo componente secrets (core/security/openbao) con l’interfaccia web integrata attiva.
manifest.yamlMappa il tipo del componente sulla Recipe sourced ufficiale (openbao).
release.yamlDocumento dell’operatore per il target Kubernetes: il dimensionamento di calcolo del server e la dimensione del volume di dati.

Che cosa dimostra

  • Un’unica superficie di authoring. Un unico Aggregate è la fonte di verità su che cosa è il server di segreti; il Manifest dice come realizzarlo.
  • Un valore dello sviluppatore arriva fino al rendering. Il valore ui_enabled dello sviluppatore viene scritto nella configurazione del server che il chart monta, e attiva o disattiva l’interfaccia web integrata.
  • Un server con stato su un volume persistente. La Recipe sourced configura la modalità standalone con il backend di archiviazione su file, quindi il server mantiene il proprio stato cifrato su un PersistentVolumeClaim montato in /openbao/data, dimensionato dallo storage.size dell’operatore.
  • Nessuna credenziale in fase di rendering. OpenBao si inizializza e si dissigilla da solo a runtime, quindi il build non cabla alcuna credenziale e non emette alcun Secret. L’output renderizzato è identico byte per byte tra un’esecuzione e l’altra dello stesso input.
  • Un’immagine riproducibile. La Recipe fissa l’immagine del server a un tag di release risolvibile (quay.io/openbao/openbao:2.5.5), quindi il carico di lavoro renderizzato fa riferimento a una versione fissata.

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 openbao-secrets

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

Terminal window
cd openbao-secrets

Build

Questo workspace non contiene alcun .aggrega-config.yaml, quindi le entità della libreria standard si risolvono dal registry dell’hub, hub.aggrega.ai, e non serve alcun flag di catalogo:

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

Gli artefatti renderizzati finiscono sotto dist/. Il build risolve il chart upstream tramite riferimento OCI con aggrega pull e lo fissa in un lockfile.

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 `openbao-secrets`, chiama una volta lo strumento `scaffold` con `example` impostato a `openbao-secrets` e senza `dir`: scrive l’esempio in una nuova cartella `openbao-secrets`. Poi chiama lo strumento `build` con `workspace_root` impostato a `openbao-secrets`, `release` impostato a `release.yaml`, `auto_pull` impostato a true e `write` impostato a true. Dimmi quali file ha scritto la build; si trovano in `openbao-secrets/dist/`.

Che cosa viene renderizzato

Il build emette lo stack OpenBao essenziale a singolo carico di lavoro come sette oggetti Kubernetes:

  • uno StatefulSet per il server OpenBao,
  • una ConfigMap che contiene la configurazione del server (il backend di archiviazione su file e il listener dell’API),
  • due Service — il servizio principale dell’API e il servizio headless interno che lo StatefulSet usa per una rete stabile dei pod,
  • un ServiceAccount per il pod del server,
  • un ClusterRoleBinding che concede al server il permesso di token review che usa per autenticare i service account di Kubernetes,
  • un Pod helm.sh/hook: test che verifica che il server sia pronto.

Non ci sono CustomResourceDefinition — OpenBao è un server autonomo, non un controller che estende l’API del cluster. L’immagine del server è fissata al suo tag di release, quindi il carico di lavoro fa riferimento a un tag di immagine fissato.