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-prometheus2. 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.0Laten 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-queryNu 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: 120Nu 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.
