Wat is Prometheus en waarom zou ik het gebruiken?

Prometheus is een open-source monitoring- en waarschuwingssysteem dat is ontworpen voor betrouwbaarheid en schaalbaarheid. Het is uitstekend in het verzamelen van tijdreeksmetrieken van verschillende doelen, het efficiënt opslaan ervan en het bieden van krachtige queryfunctionaliteiten via PromQL. Het is ideaal voor microservices, containers en cloudnative toepassingen.

Hoe verschilt Prometheus van traditionele monitoring-tools?

Prometheus gebruikt een pull-gebaseerd model waarbij het metingen ophaalt van doelen op regelmatige intervallen, in tegenstelling tot push-gebaseerde systemen. Het heeft een dimensionale data model met labels, wat het flexibel maakt voor complexe queries. Het is ontworpen voor dynamische cloudomgevingen en integreert naadloos met Kubernetes en containerorchestratieplatforms.

Wat zijn Prometheus-exporters?

Exporters zijn componenten die metrische gegevens van derde partijenystemen in een formaat uitzenden dat Prometheus kan scrapen. Populaire exporters zijn Node Exporter voor hardware/OS-metrieken, Blackbox Exporter voor het testen van eindpunten en database-specifieke exporters voor MySQL, PostgreSQL enzovoort. Ze fungeren als bruggen tussen Prometheus en systemen die metrische gegevens niet van nature uitzenden.

Kan Prometheus worden gebruikt voor loggen en tracering?

Prometheus richt zich specifiek op metrieken. Voor een volledige observabiliteitsstack kun je het combineren met Loki voor logs en Jaeger of Tempo voor gedistribueerde tracing. Deze combinatie biedt uitgebreide mogelijkheden voor monitoring, logging en tracing van moderne toepassingen.

Hoe schaal ik Prometheus voor grote implementaties?

Voor grote schaalimplementaties kunt u Prometheus-federatie gebruiken om hiërarchische opstellingen te maken, Thanos of Cortex implementeren voor langdurige opslag en globale query’s, of gebruik maken van externe opslagoplossingen. Stel juiste retentiebeleid in en gebruik opnameregels om vaak opgevraagde gegevens vooraf samen te vatten.

Wat is PromQL en hoe moeilijk is het om het te leren?

PromQL (Prometheus Query Language) is een functionele querytaal voor het selecteren en aggregeren van tijdreeksgegevens. Hoewel het een leercurve heeft, zijn basisqueries vrij eenvoudig. Begin met eenvoudige metriekqueries en leer geleidelijk aggregatiefuncties, operatoren en geavanceerde filters. De officiële documentatie bevat uitstekende voorbeelden.

Prometheus Monitoring: Volledige installatie & beste praktijken

Stel robuuste infrastructuurmonitoring op met Prometheus

Inhoud

Prometheus is geworden de standaard voor het monitoren van cloud-native toepassingen en infrastructuur, met functies voor het verzamelen van metrieken, het uitvoeren van queries en het integreren met visualisatietools.

technisch-diagram

Wat is Prometheus?

Prometheus is een open-source tool voor monitoren en waarschuwen, oorspronkelijk ontwikkeld bij SoundCloud in 2012 en nu een Cloud Native Computing Foundation (CNCF) graduate project. Het is specifiek ontworpen voor betrouwbaarheid en schaalbaarheid in dynamische cloudomgevingen, waardoor het de voorkeur is bij het monitoren van microservices, containers en Kubernetes clusters.

Belangrijke functies

Tijdreeksdatabase: Prometheus slaat alle data op als tijdreeksen, geïdentificeerd door metrieknamen en sleutel-waardeparen (labels), waardoor flexibele en krachtige queryfunctionaliteit mogelijk is.

Pull-beschikbaarheidsmodel: In tegenstelling tot traditionele push-beschikbaarheidssystemen, scant Prometheus actief metrieken van geconfigureerde doelen op aangegeven intervallen, waardoor het betrouwbaarder en gemakkelijker te configureren is.

PromQL querytaal: Een krachtige functionele querytaal die het je mogelijk maakt om je metriekdata in real-time te analyseren, met aggregaties, transformaties en complexe berekeningen.

Dienstontdekking: Automatische ontdekking van monitortargets via verschillende mechanismen, waaronder Kubernetes, Consul, EC2 en statische configuraties.

Geen externe afhankelijkheden: Prometheus werkt als een enkel binaire bestand zonder vereiste externe afhankelijkheden, waardoor het implementeren en het operationele complexiteit verminderen.

Ingebouwde waarschuwingen: AlertManager verwerkt waarschuwingen van Prometheus, met functies voor verdubbeling, groepering en routing naar meldingskanalen zoals e-mail, PagerDuty of Slack.

Overzicht van de architectuur

Het begrijpen van de Prometheus-architectuur is essentieel voor een effectieve implementatie. De belangrijkste componenten zijn:

Prometheus Server: Scant en slaat metrieken op, evalueert regels en serveert queries
Clientbibliotheken: Instrumenteer toepassingscode om metrieken te tonen
Exporters: Verbinden derde partijssystemen met Prometheusformaat
AlertManager: Verwerkt waarschuwingen en meldingen
Pushgateway: Accepteert metrieken van tijdelijke taken die niet kunnen worden gescand

De typische gegevensstroom: Toepassingen tonen metriekendoeleinden → Prometheus scant deze doelen → Gegevens worden opgeslagen in een tijdreeksdatabase → PromQL queries ophalen en analyseren gegevens → Waarschuwingen worden gegenereerd op basis van regels → AlertManager verwerkt en routeert meldingen.

Bij het implementeren van infrastructuur op Ubuntu 24.04, biedt Prometheus een uitstekende basis voor uitgebreid monitoren.

Prometheus installeren op Ubuntu

Laten we het installeren van Prometheus op een Linux-systeem doorlopen. We gebruiken Ubuntu als voorbeeld, maar het proces is vergelijkbaar voor andere distributies.

Downloaden en installeren

Eerst, maak een specifieke gebruiker aan voor Prometheus:

sudo useradd --no-create-home --shell /bin/false prometheus

Download de nieuwste Prometheus release:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.48.0/prometheus-2.48.0.linux-amd64.tar.gz
tar xvf prometheus-2.48.0.linux-amd64.tar.gz
cd prometheus-2.48.0.linux-amd64

Kopieer de binaire bestanden en maak directories:

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

sudo cp -r consoles /etc/prometheus
sudo cp -r console_libraries /etc/prometheus
sudo cp prometheus.yml /etc/prometheus/prometheus.yml
sudo chown -R prometheus:prometheus /etc/prometheus

Voor pakketbeheer op Ubuntu, verwijzen we naar onze uitgebreide Ubuntu Pakketbeheer gids.

Prometheus configureren

Bewerk /etc/prometheus/prometheus.yml:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

rule_files:
  - 'alert_rules.yml'

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

Een systemd-service aanmaken

Maak /etc/systemd/system/prometheus.service aan:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --storage.tsdb.retention.time=30d

[Install]
WantedBy=multi-user.target

Start en schakel Prometheus in:

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus
sudo systemctl status prometheus

Toegang tot de Prometheus webinterface via http://localhost:9090.

Instellen van Node Exporter

Node Exporter maakt hardware- en OS-metrieken beschikbaar voor Linux-systeem. Installeer het om je servers te monitoren:

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/node_exporter

Maak een systemd-service /etc/systemd/system/node_exporter.service aan:

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

Start Node Exporter:

sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter

Node Exporter maakt nu metrieken beschikbaar op poort 9100.

Begrijpen van PromQL

PromQL (Prometheus Query Language) is het hart van het queryen van Prometheus data. Hier zijn essentiële querypatronen:

Basisqueries

Selecteer alle tijdreeksen voor een metriek:

node_cpu_seconds_total

Filter op label:

node_cpu_seconds_total{mode="idle"}

Meerdere labelfilters:

node_cpu_seconds_total{mode="idle",cpu="0"}

Tijdreeksvectoren en aggregaties

Bereken de snelheid over tijd:

rate(node_cpu_seconds_total{mode="idle"}[5m])

Som over alle CPUs:

sum(rate(node_cpu_seconds_total{mode="idle"}[5m]))

Groeperen op label:

sum by (mode) (rate(node_cpu_seconds_total[5m]))

Praktische voorbeelden

CPU-gebruik in procent:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Geheugengebruik:

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Schijfgebruik:

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Netwerkverkeerssnelheid:

rate(node_network_receive_bytes_total[5m])

Docker-implementatie

Het uitvoeren van Prometheus in Docker containers biedt flexibiliteit en gemakkelijker beheer:

Maak docker-compose.yml aan:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  node_exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    command:
      - '--path.rootfs=/host'
    volumes:
      - '/:/host:ro,rslave'
    ports:
      - "9100:9100"
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
      - alertmanager_data:/alertmanager
    ports:
      - "9093:9093"
    restart: unless-stopped

volumes:
  prometheus_data:
  alertmanager_data:

Start de stack:

docker-compose up -d

Kubernetes monitoring

Prometheus is uitstekend voor het monitoren van Kubernetes clusters. De kube-prometheus-stack Helm chart biedt een volledige monitoringoplossing.

Installeer met Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack

Dit installeert:

Prometheus Operator
Prometheus instantie
AlertManager
Grafana
Node Exporter
kube-state-metrics
Vooraf geconfigureerde dashboards en waarschuwingen

Toegang tot Grafana:

kubectl port-forward svc/prometheus-grafana 3000:80

Standaardreferenties: admin/prom-operator

Voor verschillende Kubernetes distributies, is het implementatieproces vergelijkbaar met kleine aanpassingen voor platformspecifieke functies.

Instellen van waarschuwingen

AlertManager verwerkt waarschuwingen die door Prometheus worden verzonden. Configureer waarschuwingsregels en meldingskanalen.

Waarschuwingsregels

Maak /etc/prometheus/alert_rules.yml aan:

groups:
  - name: system_alerts
    interval: 30s
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hoog CPU-gebruik op {{ $labels.instance }}"
          description: "CPU-gebruik is boven 80% (huidige waarde: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hoog geheugengebruik op {{ $labels.instance }}"
          description: "Geheugengebruik is boven 85% (huidige waarde: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Weinig schijfruimte op {{ $labels.instance }}"
          description: "Beschikbare schijfruimte is onder 15% op {{ $labels.mountpoint }}"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Instelling {{ $labels.instance }} is uitgeschakeld"
          description: "{{ $labels.job }} instelling {{ $labels.instance }} is meer dan 2 minuten uitgeschakeld"

AlertManager configuratie

Maak /etc/prometheus/alertmanager.yml aan:

global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alerts@example.com'
  smtp_auth_username: 'alerts@example.com'
  smtp_auth_password: 'your-password'

route:
  group_by: ['alertname', 'cluster', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 12h
  receiver: 'team-email'
  routes:
    - match:
        severity: critical
      receiver: 'team-pagerduty'
    - match:
        severity: warning
      receiver: 'team-slack'

receivers:
  - name: 'team-email'
    email_configs:
      - to: 'team@example.com'
        headers:
          Subject: '{{ .GroupLabels.alertname }}: {{ .Status | toUpper }}'

  - name: 'team-slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Waarschuwing: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

  - name: 'team-pagerduty'
    pagerduty_configs:
      - service_key: 'your-pagerduty-key'

Integratie met Grafana

Hoewel Prometheus een basiswebinterface heeft, biedt Grafana betere visualisatie mogelijkheden voor het maken van uitgebreide dashboards.

Prometheus toevoegen als gegevensbron

Open Grafana en navigeer naar Configuratie → Gegevensbronnen
Klik op “Gegevensbron toevoegen”
Selecteer “Prometheus”
Stel de URL in op http://localhost:9090 (of je Prometheus-server)
Klik op “Opslaan en testen”

Populaire dashboard-IDs

Importeer vooraf gemaakte dashboards van grafana.com:

Node Exporter Full (ID: 1860): Uitgebreide Linux-metrieken
Kubernetes Cluster Monitoring (ID: 7249): K8s-overzicht
Docker Container Monitoring (ID: 193): Containermetrieken
Prometheus Stats (ID: 2): Prometheus interne metrieken

Aanmaken van aangepaste dashboards

Maak panels aan met PromQL queries:

{
  "title": "CPU-gebruik",
  "targets": [{
    "expr": "100 - (avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
  }]
}

Populaire exporters

Breid Prometheus monitoring uit met gespecialiseerde exporters:

Blackbox Exporter

Probeer eindpunten via HTTP, HTTPS, DNS, TCP en ICMP:

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: localhost:9115

Database Exporters

mysqld_exporter: MySQL/MariaDB metrieken
postgres_exporter: PostgreSQL metrieken
mongodb_exporter: MongoDB metrieken
redis_exporter: Redis metrieken

Toepassingsexporters

nginx_exporter: NGINX webserver metrieken
apache_exporter: Apache HTTP-server metrieken
haproxy_exporter: HAProxy load balancer metrieken

Cloud Exporters

cloudwatch_exporter: AWS CloudWatch metrieken
stackdriver_exporter: Google Cloud metrieken
azure_exporter: Azure Monitor metrieken

Beste praktijken

Data Retentie

Stel de juiste retentie in op basis van je behoeften:

--storage.tsdb.retention.time=30d
--storage.tsdb.retention.size=50GB

Opname-regels

Vooraf bereken frequent gemaakte expressies:

groups:
  - name: example_rules
    interval: 30s
    rules:
      - record: job:node_cpu_utilization:avg
        expr: 100 - (avg by (job) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Labelbeheer

Houd het labelcardinaliteit laag
Gebruik consistente naamgeving
Vermijd hoge-cardinaliteit labels (gebruikersids, tijdstempels)

Beveiliging

Schakel authenticatie en HTTPS in
Beperk toegang tot de Prometheus API
Gebruik netwerkbeleid in Kubernetes
Implementeer RBAC voor gevoelige metrieken

Hoog beschikbaarheid

Voer meerdere Prometheus instanties uit
Gebruik Thanos of Cortex voor langdurige opslag
Implementeer federatie voor hiërarchische opstellingen

Probleemoplossing van veelvoorkomende problemen

Hoog geheugengebruik

Verminder de scanfrequentie
Verminder de retentieperiode
Optimaliseer PromQL queries
Implementeer opnamesregels

Ontbrekende metrieken

Controleer de status van doelen in /targets
Verifieer netwerkconnectiviteit
Valideer de scanconfiguratie
Controleer de exporter logs

Snelheid van queries

Gebruik opnamesregels voor complexe aggregaties
Optimaliseer labelfilters
Verminder de tijdsbereik
Voeg indices toe als je externe opslag gebruikt

Prestatieoptimalisatie

Queryoptimalisatie

# Slecht: Hoge cardinaliteit
sum(rate(http_requests_total[5m]))

# Goed: Groeperen op relevante labels
sum by (status, method) (rate(http_requests_total[5m]))

Resourcebeperkingen

Voor Kubernetes-implementaties:

resources:
  requests:
    memory: "2Gi"
    cpu: "1000m"
  limits:
    memory: "4Gi"
    cpu: "2000m"

Conclusie

Prometheus biedt een robuuste, schaalbare monitoringoplossing voor moderne infrastructuur. Zijn pull-beschikbaarheidsarchitectuur, krachtige querytaal en uitgebreide ecosysteem van exporters maken het ideaal voor het monitoren van alles van bare-metal servers tot complexe Kubernetes clusters.

Door Prometheus te combineren met Grafana voor visualisatie en AlertManager voor meldingen, creëer je een uitgebreid observabiliteitsplatform dat in staat is om ondernemersniveau monitoringbehoeften te voldoen. Het actieve community en CNCF-ondersteuning zorgen voor voortdurende ontwikkeling en ondersteuning.

Begin met basismetriekverzameling, voeg geleidelijk exporters toe voor je specifieke diensten en verfijn je waarschuwingregels op basis van ervaring in de praktijk. Prometheus schaalt met je infrastructuur, van enkele serverimplementaties tot meerdere datacenter monitoringarchitecturen.