Stack Thanos — un livello di lettura delle metriche su object storage, composto come modulo
Questo esempio compila uno stack piccolo e reale — il livello di lettura/query di un sistema di metriche Thanos — in manifest Kubernetes sintetizzati a partire da un unico Aggregate scritto dallo sviluppatore.
Il livello di lettura non è un singolo componente. È un modulo: un sotto-aggregato riutilizzabile che compone tre componenti a singolo carico di lavoro —
- un object store compatibile con S3 che conserva i blocchi storici delle metriche su un volume e li serve tramite l’API S3,
- uno Store Gateway che legge quei blocchi dall’object store e li serve ai querier tramite la propria StoreAPI, mantenendo solo una cache locale effimera, e
- un front end Query che risponde a PromQL e distribuisce le richieste sulla StoreAPI dello Store Gateway, senza alcuno stato proprio.
Il modulo cabla i propri archi interni — lo Store Gateway verso l’object store, e Query verso lo Store Gateway — ed esporta Query come proprio endpoint pubblico query. L’Aggregate di primo livello importa il modulo per nome e renderizza lo stack composto; l’operatore dimensiona i componenti interni del modulo nella Release.
File
| File | Ruolo |
|---|---|
aggregate.yaml | Intento dello sviluppatore: importa il modulo del livello di lettura Thanos (core/thanos). |
manifest-helm-synth.yaml | Mappa i tipi object store, Store Gateway e Query alle loro Recipes helm synth, e la Feature di credenziale che il modulo associa alla realizzazione che emette un Secret da ciascuno dei due parametri di chiave del modulo. |
release-helm-synth.yaml | Documento dell’operatore per il target Kubernetes. Dimensiona i componenti interni del modulo tramite i loro ID con ambito di modulo; tutto ciò che è lasciato ai valori predefiniti dello schema viene renderizzato in modo autonomo. |
Prerequisito di runtime
Questo modulo è solo il livello di lettura/query. L’object store crea il bucket thanos da cui lo Store Gateway legge prima di iniziare a servire, quindi l’unica cosa da fornire a runtime, al di fuori dei manifest renderizzati, è un componente di scrittura che produca blocchi di metriche. Il livello di lettura serve i blocchi; non li crea. Un componente di scrittura — un livello Thanos Receive o un’istanza Prometheus con il sidecar Thanos — deve spedire blocchi di metriche nello stesso bucket. Finché un componente di scrittura non ha caricato blocchi, lo Store Gateway serve un insieme di risultati vuoto.
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 thanos-stackPoi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:
cd thanos-stackBuild
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:
aggrega build --release release-helm-synth.yaml --auto-pullGli artefatti renderizzati finiscono sotto dist/. Il target Kubernetes renderizza manifest semplici offline — non è richiesto alcun pull di chart.
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 `thanos-stack`, chiama una volta lo strumento `scaffold` con `example` impostato su `thanos-stack` e senza `dir`: scrive l’esempio in una nuova cartella `thanos-stack`. Poi chiama lo strumento `build` con `workspace_root` impostato su `thanos-stack`, `release` impostato su `release-helm-synth.yaml`, `auto_pull` impostato su true e `write` impostato su true. Dimmi quali file ha scritto la build; si trovano sotto `thanos-stack/dist/`.Come appare lo stack composto
Lo Store Gateway viene renderizzato come un Deployment senza stato più un Service ClusterIP che espone la sua porta gRPC StoreAPI e la sua porta HTTP. Il suo container viene avviato con thanos store e un unico flag inline --objstore.config il cui valore è la sezione S3 costruita dall’endpoint che l’object store pubblica — il nome e la porta del suo Service interno al cluster, con insecure: true perché quell’endpoint è servito su HTTP semplice. Quella configurazione seleziona la catena di credenziali dell’SDK AWS, quindi non porta alcun segreto; entrambe le metà della chiave di accesso arrivano come variabili d’ambiente lette da Secrets:
args: - store - --grpc-address - 0.0.0.0:10901 - --http-address - 0.0.0.0:10902 - --data-dir - /var/thanos/store - |- --objstore.config=type: S3 config: bucket: thanos endpoint: metrics-zdobjstore-default:8333 insecure: true aws_sdk_auth: true[… omitted: the container ports for the two addresses named in the args]env: - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: name: metrics-zdstore-s3.credential-id key: s3-access-key - name: AWS_SECRET_ACCESS_KEY valueFrom: secretKeyRef: name: metrics-zdstore-s3.credential key: s3-secret-key[… omitted: the container's resources and its liveness and readiness probes]Query viene renderizzato come un Deployment senza stato più un Service ClusterIP sulla sua porta HTTP. Il suo container viene avviato con thanos query e si collega alla StoreAPI dello Store Gateway sull’endpoint composto dall’arco store:
args: - query - --http-address - 0.0.0.0:10902 - --grpc-address - 0.0.0.0:10901 - --endpoint - metrics-zdstore-default:10901L’object store viene renderizzato come uno StatefulSet SeaweedFS di una replica con un claim di volume montato su /data, un Service ClusterIP sulla porta S3, 8333, e il Service headless che lo StatefulSet nomina. Un init container crea il bucket thanos prima che il server inizi a servire. L’account del server è la stessa coppia di chiavi, letta da due Secrets propri, metrics-zdobjstore-access-key-id e metrics-zdobjstore-secret-access-key. I quattro Secrets vengono emessi accanto ai carichi di lavoro, due per gli slot di chiave dell’object store e due per la coppia di chiavi che porta la connessione s3 dello Store Gateway, ciascuno con il valore predefinito di sviluppo del modulo.
Che cosa dimostra
- Composizione come modulo. Una capacità a più carichi di lavoro — un livello di lettura delle metriche che in realtà è un object store più uno Store Gateway più un front end di query — è impacchettata come sotto-aggregato che compone tre componenti a singolo carico di lavoro, non come un unico componente monolitico. Il modulo viene importato per nome e riutilizzato ovunque serva un livello di lettura Thanos.
- Riuso di un backend già fornito. L’object store è il componente
core/storage/s3-object-storedella libreria standard, riusato così com’è; il livello di lettura non aggiunge alcuna logica di storage propria. Il Manifest seleziona la sua realizzazione SeaweedFS, così lo store viene eseguito nel cluster accanto al livello di lettura. - Archi interni dentro il modulo. Lo Store Gateway dichiara un uso dell’object store e Query dichiara un uso dello Store Gateway; l’
endpointpubblicato dall’object store e l’host e la porta pubblicati dallo Store Gateway vengono convogliati nel consumatore su ciascun arco, e la Recipe di ciascun consumatore costruisce da essi il proprio indirizzo. Il compilatore instrada le stringhe senza interpretarle. - Un endpoint pubblico. Il modulo esporta Query come
query, il nome pubblico stabile a cui si connette un consumatore — disaccoppiato dai nomi dei componenti interni del modulo. - Configurazione senza segreti. La configurazione dell’object store seleziona la catena di credenziali dell’SDK AWS, quindi la configurazione renderizzata non porta alcun segreto; le credenziali fluiscono solo come variabili d’ambiente.
- Una coppia di chiavi condivisa, presa per riferimento. Lo Store Gateway si autentica presso l’object store con l’account proprio dello store, quindi i due condividono una sola coppia di chiavi. Il modulo prende ciascuna metà come parametro,
s3_access_keyes3_secret_key, e associa la Feature di credenzialecore/referenced-secretcon ciascuna due volte: agli slotaccess_key_idesecret_access_keydell’object store, e comecredential_idecredentialdella connessione dello Store Gateway all’object store, la connessione su cui il gateway le presenta. Ogni carico di lavoro le legge entrambe da Secrets invece di portarle inline. Poiché il modulo associa quella Feature, il Manifest la mappa. Questo esempio lascia i parametri ai valori predefiniti di sviluppo del modulo e mappa la Feature suk8s-secret-from-parameter, che emette un Secret che porta ciascun valore, così lo stack funziona in modo autonomo. Per una Release che porta traffico reale, l’Aggregate dichiara parametri propri e li passa verso il basso tramiteaggregates.metrics.parameters, la Release li soddisfa, e il Manifest mappa la Feature suk8s-existing-secret, che legge ciascun parametro come il nome di un Secret che esiste già nel namespace. - Immagini riproducibili. Ogni componente fissa un tag di immagine esplicito, così i manifest renderizzati fanno riferimento a immagini stabili.