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
| File | Ruolo |
|---|---|
aggregate.yaml | Intento dello sviluppatore: un singolo componente secrets (core/security/openbao) con l’interfaccia web integrata attiva. |
manifest.yaml | Mappa il tipo del componente sulla Recipe sourced ufficiale (openbao). |
release.yaml | Documento 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_enableddello 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
PersistentVolumeClaimmontato in/openbao/data, dimensionato dallostorage.sizedell’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:
aggrega scaffold --example openbao-secretsPoi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:
cd openbao-secretsBuild
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:
aggrega pull --release release.yamlaggrega build --release release.yamlGli 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
StatefulSetper il server OpenBao, - una
ConfigMapche 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
ServiceAccountper il pod del server, - un
ClusterRoleBindingche concede al server il permesso di token review che usa per autenticare i service account di Kubernetes, - un
Podhelm.sh/hook: testche 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.