Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Stack Thanos — un niveau de lecture de métriques sur un stockage d’objets, composé comme un module

Cet exemple compile une petite stack réelle — le niveau de lecture/requête d’un système de métriques Thanos — en manifestes Kubernetes synthétisés à partir d’un seul Aggregate écrit par le développeur.

Le niveau de lecture n’est pas un composant unique. C’est un module : un sous-agrégat réutilisable qui compose trois composants à charge de travail unique —

  • un stockage d’objets compatible S3 qui conserve des blocs de métriques historiques sur un volume et les sert via l’API S3,
  • un Store Gateway qui lit ces blocs depuis le stockage d’objets et les sert aux querier via sa StoreAPI, en ne conservant qu’un cache local éphémère, et
  • un front-end Query qui répond à PromQL et répartit les requêtes sur la StoreAPI du Store Gateway, sans aucun état propre.

Le module câble ses propres arêtes internes — le Store Gateway vers le stockage d’objets, et Query vers le Store Gateway — et exporte Query comme son endpoint public query. L’Aggregate de premier niveau importe le module par son nom et rend la stack composée ; l’opérateur dimensionne les composants internes du module dans la Release.

Fichiers

FichierRôle
aggregate.yamlIntention du développeur : importe le module de niveau de lecture Thanos (core/thanos).
manifest-helm-synth.yamlAssocie les types stockage d’objets, Store Gateway et Query à leurs Recipes helm synth, et la Feature d’identifiants que le module rattache à la réalisation qui émet un Secret à partir de chacun des deux paramètres de clé du module.
release-helm-synth.yamlEnregistrement de l’opérateur pour la cible Kubernetes. Dimensionne les composants internes du module par leurs ID à portée de module ; tout ce qui est laissé aux valeurs par défaut du schéma est rendu de manière autonome.

Prérequis d’exécution

Ce module est uniquement le niveau de lecture/requête. Le stockage d’objets crée le bucket thanos dans lequel lit le Store Gateway avant de servir, si bien que la seule chose à fournir à l’exécution, en dehors des manifestes rendus, est un composant d’écriture qui produit des blocs de métriques. Le niveau de lecture sert des blocs ; il ne les crée pas. Un composant d’écriture — un niveau Thanos Receive ou une instance Prometheus avec le sidecar Thanos — doit envoyer des blocs de métriques dans le même bucket. Tant qu’un composant d’écriture n’a pas téléversé de blocs, le Store Gateway sert un ensemble de résultats vide.

Générer l’exemple

Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example thanos-stack

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :

Terminal window
cd thanos-stack

Build

Ce workspace ne contient aucun .aggrega-config.yaml, si bien que les entités de la bibliothèque standard sont résolues depuis le registre du hub, hub.aggrega.ai, et aucune option de catalogue n’est nécessaire ; --auto-pull écrit pendant le build le lockfile qui manque à un clone récent :

Terminal window
aggrega build --release release-helm-synth.yaml --auto-pull

Les artefacts rendus atterrissent sous dist/. La cible Kubernetes rend des manifestes simples hors ligne — aucun pull de chart n’est requis.

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.

Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier de l’espace de travail ne contient pas encore de dossier `thanos-stack`, appelez une fois l’outil `scaffold` avec `example` défini sur `thanos-stack` et sans `dir` : il écrit l’exemple dans un nouveau dossier `thanos-stack`. Appelez ensuite l’outil `build` avec `workspace_root` défini sur `thanos-stack`, `release` défini sur `release-helm-synth.yaml`, `auto_pull` défini sur true et `write` défini sur true. Indiquez-moi quels fichiers le build a écrits ; ils se trouvent sous `thanos-stack/dist/`.

À quoi ressemble la stack composée

Le Store Gateway est rendu comme un Deployment sans état plus un Service ClusterIP exposant son port gRPC StoreAPI et son port HTTP. Son conteneur est démarré avec thanos store et un unique flag inline --objstore.config dont la valeur est la section S3 construite à partir de l’endpoint que publie le stockage d’objets — son nom de Service interne au cluster et son port, avec insecure: true parce que cet endpoint est servi en HTTP simple. Cette configuration sélectionne la chaîne d’identifiants du SDK AWS, si bien qu’elle ne porte aucun secret ; les deux moitiés de la clé d’accès arrivent comme variables d’environnement lues depuis des 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 est rendu comme un Deployment sans état plus un Service ClusterIP sur son port HTTP. Son conteneur est démarré avec thanos query et contacte la StoreAPI du Store Gateway sur l’endpoint composé à partir de l’arête store :

args:
- query
- --http-address
- 0.0.0.0:10902
- --grpc-address
- 0.0.0.0:10901
- --endpoint
- metrics-zdstore-default:10901

Le stockage d’objets est rendu comme un StatefulSet SeaweedFS d’un réplica avec une demande de volume montée sur /data, un Service ClusterIP sur le port S3, 8333, et le Service headless que nomme le StatefulSet. Un conteneur init crée le bucket thanos avant que le serveur ne serve. Le compte du serveur est la même paire de clés, lue depuis deux Secrets qui lui sont propres, metrics-zdobjstore-access-key-id et metrics-zdobjstore-secret-access-key. Les quatre Secrets sont émis à côté des charges de travail, deux pour les emplacements de clé du stockage d’objets et deux pour la paire de clés que porte la connexion s3 du Store Gateway, chacun portant la valeur par défaut de développement du module.

Ce qu’il démontre

  • Composition en module. Une capacité à plusieurs charges de travail — un niveau de lecture de métriques qui est en réalité un stockage d’objets plus un Store Gateway plus un front-end de requête — est empaquetée comme un sous-agrégat composant trois composants à charge de travail unique, et non comme un composant monolithique. Le module est importé par son nom et réutilisé partout où un niveau de lecture Thanos est nécessaire.
  • Réutilisation d’un backend livré. Le stockage d’objets est le composant core/storage/s3-object-store de la bibliothèque standard, réutilisé tel quel ; le niveau de lecture n’ajoute aucune logique de stockage propre. Le Manifest sélectionne sa réalisation SeaweedFS, si bien que le stockage s’exécute dans le cluster à côté du niveau de lecture.
  • Arêtes internes au module. Le Store Gateway déclare une utilisation du stockage d’objets et Query déclare une utilisation du Store Gateway ; l’endpoint publié par le stockage d’objets et l’hôte et le port publiés par le Store Gateway sont acheminés vers le consommateur sur chaque arête, et la Recipe de chaque consommateur construit son adresse à partir d’eux. Le compilateur achemine les chaînes sans les interpréter.
  • Un endpoint public. Le module exporte Query sous le nom query, le nom public stable auquel se connecte un consommateur — découplé des noms des composants internes du module.
  • Configuration sans secret. La configuration du stockage d’objets sélectionne la chaîne d’identifiants du SDK AWS, si bien que la configuration rendue ne porte aucun secret ; les identifiants circulent uniquement comme variables d’environnement.
  • Une paire de clés partagée, prise par référence. Le Store Gateway s’authentifie auprès du stockage d’objets avec le propre compte de celui-ci, si bien que les deux partagent une seule paire de clés. Le module prend chaque moitié comme paramètre, s3_access_key et s3_secret_key, et rattache la Feature d’identifiants core/referenced-secret avec chacune deux fois : aux emplacements access_key_id et secret_access_key du stockage d’objets, et comme credential_id et credential de la connexion du Store Gateway au stockage d’objets, la connexion sur laquelle la passerelle les présente. Chaque charge de travail les lit toutes deux depuis des Secrets au lieu de les porter inline. Comme le module rattache cette Feature, le Manifest l’associe. Cet exemple laisse les paramètres aux valeurs par défaut de développement du module et associe la Feature à k8s-secret-from-parameter, qui émet un Secret portant chaque valeur, si bien que la stack fonctionne de façon autonome. Pour une Release qui porte un trafic réel, l’Aggregate déclare ses propres paramètres et les transmet vers le bas via aggregates.metrics.parameters, la Release les satisfait, et le Manifest associe la Feature à k8s-existing-secret, qui lit chaque paramètre comme le nom d’un Secret qui existe déjà dans le namespace.
  • Images reproductibles. Chaque composant épingle un tag d’image explicite, si bien que les manifestes rendus référencent des images stables.