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

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

FileRuolo
aggregate.yamlIntento dello sviluppatore: importa il modulo del livello di lettura Thanos (core/thanos).
manifest-helm-synth.yamlMappa 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.yamlDocumento 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:

Terminal window
aggrega scaffold --example thanos-stack

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

Terminal window
cd thanos-stack

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
aggrega build --release release-helm-synth.yaml --auto-pull

Gli 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:10901

L’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-store della 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’endpoint pubblicato 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_key e s3_secret_key, e associa la Feature di credenziale core/referenced-secret con ciascuna due volte: agli slot access_key_id e secret_access_key dell’object store, e come credential_id e credential della 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 su k8s-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 tramite aggregates.metrics.parameters, la Release li soddisfa, e il Manifest mappa la Feature su k8s-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.