CLOUD & MANAGED SERVICESKUBERNETES PROMETHEUSTHANOS
23/11/2023 • Leonardo Wolo

Hoge beschikbaarheid van Prometheus met Thanos in Kubernetes

Prometheus is een populaire monitoring- en waarschuwingstool in het Kubernetes-ecosysteem. Desalniettemin kan een enkele Prometheus-instantie bij de uitbreiding van je infrastructuur moeilijkheden ondervinden met het verwerken van de groeiende werkbelasting en mogelijk een single point of failure worden.

In dit blogbericht laten we zien hoe je Prometheus kan configureren voor hoge beschikbaarheid met behulp van Thanos in Kubernetes. Daarnaast zullen we Helm gebruiken voor eenvoudige implementatie en beheer.

Ben je niet bekend met Prometheus? Dan raden we aan om eerst hun documentatie door te nemen.

Wat is Thanos?

Om Thanos succesvol te implementeren, is het van cruciaal belang om de integrale componenten van deze tool en de naadloze integratie ervan te begrijpen.

Thanos is een open-sourceproject dat de functionaliteiten van Prometheus verbetert en een schaalbare, zeer beschikbare opslagoplossing voor de lange termijn biedt. Hiermee kan je horizontale schaalbaarheid bereiken terwijl je een globale queryweergave en deduplicatie over meerdere Prometheus-instanties behoudt. Thanos fungeert als middenlaag tussen Prometheus en een opslagsysteem voor de lange termijn, zoals object storage of een gedistribueerde database. In het onderstaande diagram [1] kan je zien hoe alle componenten samenwerken.

Nu we een globaal begrip hebben van wat Thanos is, laten we elk onderdeel in detail bekijken.

Thanos Sidecar

De Thanos sidecar werkt hand in hand met elke Prometheus-instantie. Het collecteert datablokken van Prometheus en slaat deze op in een object storage of gedistribueerde database. Bovendien duwt de sidecar datablokken ontvangen van Prometheus naar het opslagsysteem.

Thanos Query

De Thanos-querier vergemakkelijkt het opvragen van gegevens die zijn opgeslagen in verschillende Prometheus-instanties en de object storage of gedistribueerde database. Het fungeert als centraal eindpunt, verzamelt zoekresultaten uit verschillende bronnen en biedt een globaal overzicht van de gegevens. Met Thanos Querier is het niet nodig om individuele Prometheus-instanties te bevragen; in plaats daarvan kan je antwoorden van store gateways en het object-storagesysteem consolideren en ontdubbelen.

Thanos Store

Thanos Store Gateway fungeert als API-gateway tussen je Thanos-cluster en de Object store. De primaire rol is het proxy-readen van queries van Thanos Query aan de onderliggende winkel. Door dit te doen, biedt het consistente globale zoekopdrachten over meerdere Prometheus-instanties. In plaats van individuele Prometheus-instanties rechtstreeks te bevragen, biedt de store gateway een uniform overzicht van de gegevens van alle instanties, waardoor het query proces wordt vereenvoudigd.

Thanos Compactor

De Thanos compactor is verantwoordelijk voor het optimaliseren van het opslagsysteem voor de lange termijn door het uitvoeren van downsampling, deduplicatie en compactie van datablokken. Het scant periodiek de blokken die zijn opgeslagen in de object storage of gedistribueerde database en past deze bewerkingen toe om de opslagefficiëntie te verbeteren en de reactietijden van zoekopdrachten te verkorten.

Integreer Thanos met Prometheus

Zoals we hebben gezien, bestaat Thanos uit verschillende componenten, maar we zullen alleen de sidecar- en query-componenten configureren. We kiezen ervoor om deze twee componenten te benadrukken omdat we prioriteit willen geven aan high availability boven uitgebreide opslagoplossingen voor de lange termijn. In onderstaand schema [2] is te zien hoe de componenten samenwerken met Prometheus.

Voordat je verdergaat, moet je ervoor zorgen dat je over het volgende beschikt.

  • Kubernetes-cluster: Stel een Kubernetes-cluster op waarin je Prometheus en Thanos wil deployen.
  • Prometheus: Zorg ervoor dat je een Prometheus-setup gereed hebt, inclusief de benodigde configuratiebestanden.

Opmerking: onze Prometheus-component wordt geïmplementeerd met behulp van de Prometheus-operator. de Thanos sidecar is geïntegreerd met de Prometheus CRD (Custom Resource Definition), wat erg handig is voor het beheer van beide componenten. Het implementeren van componenten zoals de Querier, Compactor en Store Gateway van Thanos moet afzonderlijk van de Prometheus Operator worden gedaan. Het kube- Thanos-project biedt nuttige uitgangspunten voor de implementatie van deze aanvullende Thanoscomponenten.

1.   Prometheus Custom Resource met Thanos Sidecar

De Prometheus Custom Resource Definition (CRD) biedt de mogelijkheid om een Thanos sidecar op te nemen in de Prometheus Pod. Om de sidecar in te schakelen, moet je een waarde instellen in de Thanos-sectie. Een eenvoudige configuratieoptie is bijvoorbeeld het opgeven van een geldige container image version voor de Thanos sidecar.

...
spec:
  ...
  thanos:
    version: v0.31.0
...

Na het maken van deze aanpassing wordt er gestart met een nieuwe Prometheus Pod met de Thanos sidecar container. Vanaf nu is het gewenst om het aantal replica's te wijzigen, zodat meerdere exemplaren van Prometheus in het cluster kunnen worden uitgevoerd.

Om ervoor te zorgen dat onze Thanos Query-instantie de Thanos sidecars kan ontdekken en bevragen, is het essentieel om een service op te nemen die de poorten van de Thanos sidecars toegankelijk maakt.

---
apiVersion: v1
kind: Service
metadata:
  name: prometheus-thanos-discovery
  namespace: prometheus
  labels:
    app: prometheus-thanos-discovery
    app.kubernetes.io/part-of: prometheus
spec:
  type: ClusterIP
  clusterIP: None
  ports:
    - name: grpc
      port: 10901
      targetPort: grpc
    - name: http
      port: 10902
      targetPort: http
  selector:
    app.kubernetes.io/name: prometheus
    operator.prometheus.io/name: prometheus-prometheus

2.   Thanos Query in onze cluster

Na het configureren van de Sidecar voor alle Prometheus-instanties, is de volgende stap het gebruik van Thanos' globale Query Layer voor het gelijktijdig uitvoeren van PromQL-queries over alle instanties.

De Querier-component van Thanos is ontworpen om stateless en horizontaal schaalbaar te zijn, waardoor implementatie met meerdere replica's mogelijk is. Eenmaal verbonden met de Thanos Sidecar, identificeert het automatisch de relevante Prometheus-servers waarmee contact kan worden opgenomen voor een bepaalde PromQL-query.

Bovendien implementeert de Thanos Querier de officiële HTTP API van Prometheus, waardoor compatibiliteit met externe tools zoals Grafana mogelijk wordt. Het biedt ook een aangepaste versie van de gebruikersinterface van Prometheus, waardoor ad-hoc bevragingen en monitoring van de status van de Thanos stores mogelijk zijn.

Laten we beginnen met het implementeren van de Kubernetes Thanos-query ServiceAccount.

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: thanos-query
  namespace: prometheus
  labels:
    app.kubernetes.io/component: query-layer
    app.kubernetes.io/instance: thanos-query
    app.kubernetes.io/name: thanos-query
    app.kubernetes.io/version: v0.31.0

Laten we vervolgens de Thanos-query service deployen.

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app.kubernetes.io/component: query-layer
    app.kubernetes.io/instance: thanos-query
    app.kubernetes.io/name: thanos-query
    app.kubernetes.io/version: v0.31.0
  name: thanos-query
  namespace: prometheus
spec:
  ports:
    - name: grpc
      port: 10901
      targetPort: grpc
    - name: http
      port: 9090
      targetPort: http
  selector:
    app.kubernetes.io/component: query-layer
    app.kubernetes.io/instance: thanos-query
    app.kubernetes.io/name: thanos-query

Nu komt de meest crucial stap: het deployen van de Thanos Query applicatie.

Opmerking:

  • Het container argument --endpoint=dnssrv+_grpc._tcp.prometheus-thanosdiscovery. prometheus.svc.cluster.local helpt om Thanos API servers te detecteren door middel van respectieve DNS lookups. Denk eraan om de service URL aan te passen aan je setup.
  • Het containerargument --query.replica-label=replica wijst labels toe die zullen functioneren als indicatoren voor het identificeren van replica's, waardoor gegevensontdubbeling langs die markeringen mogelijk wordt.
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/component: query-layer
    app.kubernetes.io/instance: thanos-query
    app.kubernetes.io/name: thanos-query
    app.kubernetes.io/version: v0.31.0
  name: thanos-query
  namespace: prometheus
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/component: query-layer
      app.kubernetes.io/instance: thanos-query
      app.kubernetes.io/name: thanos-query
  template:
    metadata:
      labels:
        app.kubernetes.io/component: query-layer
        app.kubernetes.io/instance: thanos-query
        app.kubernetes.io/name: thanos-query
        app.kubernetes.io/version: v0.31.0
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - podAffinityTerm:
                labelSelector:
                  matchExpressions:
                    - key: app.kubernetes.io/name
                      operator: In
                      values:
                        - thanos-query
                namespaces:
                  - prometheus
                topologyKey: kubernetes.io/hostname
              weight: 100
      serviceAccountName: thanos-query
      containers:
        - name: thanos-query
          image: "quay.io/thanos/thanos:v0.31.0"
          args:
            - query
            - --log.level=info
            - --grpc-address=0.0.0.0:10901
            - --http-address=0.0.0.0:9090
            - --query.replica-label=replica
            - --endpoint=dnssrv+_grpc._tcp.prometheus-thanos-discovery.prometheus.svc.cluster.local
          ports:
            - name: grpc
              containerPort: 10901
            - name: http
              containerPort: 9090
          livenessProbe:
            failureThreshold: 4
            httpGet:
              path: /-/healthy
              port: 9090
              scheme: HTTP
            periodSeconds: 30
          readinessProbe:
            failureThreshold: 20
            httpGet:
              path: /-/ready
              port: 9090
              scheme: HTTP
            periodSeconds: 5
          terminationMessagePolicy: FallbackToLogsOnError
          resources:
            requests:
              memory: 1.5Gi
            limits:
              memory: 1.5Gi
      terminationGracePeriodSeconds: 120

Nu alle essentiële componenten met succes in onze cluster werken, kunnen we nu doorgaan met het valideren van de functionaliteit van het opvragen van statistieken met behulp van de Thanos-query. Dit kan worden bereikt door port-forwarding naar een pod.

# Get the thanos query pods
kubectl -n <namespace> get pods
 
# Port forward to a pod
kubectl -n <namespace> port-forward <pod-name> <local-port>:<remote-port>

Door naar de Stores sectie in de Thanos Gui [3] te navigeren, kunnen we valideren of alle Prometheus-instanties zijn gevonden door de Thanos Query-applicatie.

In the Graph sectie [4], kunnen we valideren of deduplicatie werkt door een query te laten lopen waarbij deze functie is ingeschakeld en vervolgens uitgeschakeld.


Met de bevestiging dat onze Thanos-configuratie goed functioneert, omvat de laatste stap het configureren van Grafana om Thanos Query te gebruiken als eindpunt voor metrics.

Conclusie

Het configureren van Prometheus voor high availability is cruciaal voor ononderbroken monitoring en naadloze gegevensverzameling. Het open-sourceproject Thanos biedt een oplossing voor het realiseren van schaalbaarheid en langdurige dataopslag. In deze blogpost hebben we jou door het configuratieproces van Prometheus met Thanos in Kubernetes geleid met behulp van de Prometheus Operator, zodat je Thanos naadloos kan implementeren en beheren voor jouw Prometheus-installatie.

Voor meer informatie, Bezoek de officiële Thanos Documentation.

⚡️ Wil jij de energie van Kubernetes ook toepassen?