Prometheus-övervakning: Fullständig uppsättning och bästa praxis

Prometheus har blivit standarden för övervakning av molnbaserade applikationer och infrastruktur, och erbjuder insamling av mätvärden, frågefunktioner och integration med visualiseringsverktyg.

Vad är Prometheus?

Prometheus är ett öppet källkodsovervaknings- och varningssystem som ursprungligen utvecklades av SoundCloud 2012 och nu är ett certifierat projekt av Cloud Native Computing Foundation (CNCF). Det är specifikt utformat för tillförlitlighet och skalbarhet i dynamiska molnmiljöer, vilket gör det till det främsta valet för övervakning av mikrotjänster, containrar och Kubernetes-kluster.

Nyckelfunktioner

Tidsbaserad databas: Prometheus lagrar all data som tidsbaserade serier, identifierade av mätvärdesnamn och nyckelvärdpar (etiketter), vilket möjliggör flexibla och kraftfulla frågefunktioner.

Dragmodell: Till skillnad från traditionella skickmodeller drar Prometheus aktivt mätvärden från konfigurerade mål vid angivna intervall, vilket gör det mer tillförlitligt och enklare att konfigurera.

PromQL-frågespråk: Ett kraftfullt funktionellt frågespråk låter dig analysera dina mätvärdesdata i realtid, utföra aggregeringar, transformationer och komplexa beräkningar.

Tjänstupptäckt: Automatisk upptäckt av övervakningsmål genom olika mekanismer inklusive Kubernetes, Consul, EC2 och statiska konfigurationer.

Inga externa beroenden: Prometheus fungerar som en enda binärfil utan några krävda externa beroenden, vilket förenklar distributionen och minskar den operationella komplexiteten.

Inbyggd varningshantering: AlertManager hanterar varningar från Prometheus, vilket ger avidentifiering, gruppering och vägledning till meddelandekanaler som e-post, PagerDuty eller Slack.

Arkitekturoversikt

Förståelse för Prometheus arkitektur är avgörande för effektiv distribution. De huvudsakliga komponenterna inkluderar:

• Prometheus Server: Samlar in och lagrar mätvärden, utvärderar regler och hanterar frågor
• Klientbibliotek: Instrumenterar applikationskod för att exponera mätvärden
• Exporter: Ansluter tredjepartssystem till Prometheus-format
• AlertManager: Hanterar varningar och meddelanden
• Pushgateway: Tar emot mätvärden från kortlivade jobb som inte kan dras

Den typiska dataflödet: Applikationer exponerar mätvärdesändpunkter → Prometheus drar dessa ändpunkter → Data lagras i tidsbaserad databas → PromQL-frågor hämtar och analyserar data → Varningar genereras baserat på regler → AlertManager bearbetar och vägleder meddelanden.

När du distribuerar infrastruktur på Ubuntu 24.04, erbjuder Prometheus en utmärkt grund för omfattande övervakning.

Installation av Prometheus på Ubuntu

Låt oss gå igenom installationen av Prometheus på ett Linux-system. Vi kommer att använda Ubuntu som exempel, men processen är liknande för andra distributioner.

Ladda ner och installera

Först, skapa en dedikerad användare för Prometheus:

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

Ladda ner den senaste versionen av Prometheus:

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

Kopiera binärfiler och skapa kataloger:

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

För pakethantering på Ubuntu, hänvisa till vår omfattande Ubuntu Pakethanteringsguide.

Konfigurera Prometheus

Redigera /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']

Skapa Systemd-tjänst

Skapa /etc/systemd/system/prometheus.service:

[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

Starta och aktivera Prometheus:

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

Åtkomst till Prometheus webbgränssnitt vid http://localhost:9090.

Installation av Node Exporter

Node Exporter exponerar hårdvaru- och OS-mätvärden för Linux-system. Installera det för att övervaka dina servrar:

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

Skapa systemd-tjänst /etc/systemd/system/node_exporter.service:

[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

Starta Node Exporter:

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

Node Exporter exponerar nu mätvärden på port 9100.

Förstå PromQL

PromQL (Prometheus Query Language) är hjärtat i att fråga Prometheus-data. Här är grundläggande frågemönster:

Grundläggande frågor

Välj alla tidsbaserade serier för en mätning:

node_cpu_seconds_total

Filtrera efter etikett:

node_cpu_seconds_total{mode="idle"}

Flera etikettsfilter:

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

Intervallvektorer och aggregeringar

Beräkna hastighet över tid:

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

Summera över alla CPU:er:

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

Grupp efter etikett:

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

Praktiska exempel

CPU-användningsprocent:

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

Minneanvändning:

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Diskanvändning:

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Nätverkstrafikhastighet:

rate(node_network_receive_bytes_total[5m])

Docker-distribution

Att köra Prometheus i Docker containrar erbjuder flexibilitet och enklare hantering:

Skapa docker-compose.yml:

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:

Starta stacken:

docker-compose up -d

Kubernetes-övervakning

Prometheus utmärker sig vid övervakning av Kubernetes-kluster. kube-prometheus-stack Helm-kartan erbjuder en komplett övervakningslösning.

Installera med Helm:

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

Detta installerar:

• Prometheus Operator
• Prometheus-instans
• AlertManager
• Grafana
• Node Exporter
• kube-state-metrics
• Förkonfigurerade instrumentpaneler och varningar

Åtkomst till Grafana:

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

Standardautentiseringsuppgifter: admin/prom-operator

För olika Kubernetes-distributioner, är distributionsprocessen liknande med mindre justeringar för plattformspecifika funktioner.

Att Konfigurera Alarm

AlertManager hanterar alarmer som skickas av Prometheus. Konfigurera alarmregler och meddelandekanaler.

Alarmregler

Skapa /etc/prometheus/alert_rules.yml:

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: "Hög CPU-användning på {{ $labels.instance }}"
          description: "CPU-användning är över 80% (aktuellt värde: {{ $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: "Hög minnesanvändning på {{ $labels.instance }}"
          description: "Minnesanvändning är över 85% (aktuellt värde: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Låg diskutrymme på {{ $labels.instance }}"
          description: "Tillgängligt diskutrymme är under 15% på {{ $labels.mountpoint }}"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Instans {{ $labels.instance }} är ned"
          description: "{{ $labels.job }} instans {{ $labels.instance }} har varit ned i mer än 2 minuter"

AlertManager Konfiguration

Skapa /etc/prometheus/alertmanager.yml:

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: 'Alarm: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

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

Integration med Grafana

Medan Prometheus har ett grundläggande webbgränssnitt, Grafana erbjuder överlägsen visualisering för att skapa omfattande instrumentpaneler.

Lägg till Prometheus som datakälla

1. Öppna Grafana och navigera till Konfiguration → Datakällor
2. Klicka på “Lägg till datakälla”
3. Välj “Prometheus”
4. Ange URL till http://localhost:9090 (eller din Prometheus-server)
5. Klicka på “Spara & Test”

Populära instrumentpanel-ID

Importera fördefinierade instrumentpaneler från grafana.com:

• Node Exporter Full (ID: 1860): Kompletta Linux-mått
• Kubernetes Cluster Monitoring (ID: 7249): K8s-översikt
• Docker Container Monitoring (ID: 193): Containermått
• Prometheus Stats (ID: 2): Prometheus interna mått

Skapa anpassade instrumentpaneler

Skapa paneler med PromQL-frågor:

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

Populära Exporter

Utöka Prometheus-övervakningen med specialiserade exporter:

Blackbox Exporter

Testar ändpunkter över HTTP, HTTPS, DNS, TCP och 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

Databashanterings Exporter

• mysqld_exporter: MySQL/MariaDB-mått
• postgres_exporter: PostgreSQL-mått
• mongodb_exporter: MongoDB-mått
• redis_exporter: Redis-mått

Applikations Exporter

• nginx_exporter: NGINX-webbserver-mått
• apache_exporter: Apache HTTP-server-mått
• haproxy_exporter: HAProxy-lastbalanseringsmått

Molnexporter

• cloudwatch_exporter: AWS CloudWatch-mått
• stackdriver_exporter: Google Cloud-mått
• azure_exporter: Azure Monitor-mått

Bäst praxis

Databehållning

Konfigurera lämplig behållning baserat på dina behov:

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

Posteringsregler

Beräkna vanligt efterfrågade uttryck i förväg:

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)

Etikett hantering

• Håll etikettskardinalitet låg
• Använd konsekventa namnkonventioner
• Undvik etiketter med hög kardinalitet (användar-ID, tidsstämplar)

Säkerhet

• Aktivera autentisering och HTTPS
• Begränsa åtkomst till Prometheus-API
• Använd nätverksregler i Kubernetes
• Implementera RBAC för känsliga mått

Höga tillgänglighet

• Kör flera Prometheus-instanser
• Använd Thanos eller Cortex för långtidslagring
• Implementera federation för hierarkiska uppsättningar

Felsökning av vanliga problem

Hög minnesanvändning

• Minska skrapfrekvensen
• Minska behållningstiden
• Optimera PromQL-frågor
• Implementera posteringsregler

Saknade mått

• Kontrollera målningsstatus i /targets
• Verifiera nätverksanslutning
• Validera skrapkonfiguration
• Kontrollera exporterloggar

Långsamma frågor

• Använd posteringsregler för komplexa aggregationer
• Optimera etikettfilter
• Minska tidsintervallet
• Lägg till index om du använder fjärrlagring

Prestandaoptimering

Frågeoptimering

# Dåligt: Hög kardinalitet
sum(rate(http_requests_total[5m]))

# Bra: Gruppera efter relevanta etiketter
sum by (status, method) (rate(http_requests_total[5m]))

Resursbegränsningar

För Kubernetes-distributioner:

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

Slutsats

Prometheus erbjuder en robust, skalbar övervakningslösning för modern infrastruktur. Dess pull-baserade arkitektur, kraftfulla frågespråk och omfattande ekosystem av exporter gör det idealiskt för övervakning av allt från nakna servrar till komplexa Kubernetes-kluster.

Genom att kombinera Prometheus med Grafana för visualisering och AlertManager för meddelanden skapar du en omfattande observabilitetsplattform som kan hantera övervakningsbehov på företagsnivå. Den aktiva gemenskapen och CNCF-stödet säkerställer fortsatt utveckling och support.

Börja med grundläggande måttinsamling, lägg gradvis till exporter för dina specifika tjänster och förfina dina alarmregler baserat på verklig erfarenhet. Prometheus skalas med din infrastruktur, från enskilda serverdistributioner till övervakningsarkitekturer över flera datacenter.

Relaterade resurser

• Hur man installerar Ubuntu 24.04 & användbara verktyg
• Ubuntu Pakethantering: APT och dpkg Cheatsheet
• Installera och använda Grafana på Ubuntu: Komplett guide
• Kubernetes Cheatsheet
• Kubernetes distributioner - snabb översikt av kubeadm, k3s, MicroK8s, Minikube, Talos Linux och RKE2
• Docker Cheatsheet

Externa referenser

• Prometheus officiella dokumentation
• PromQL frågeexempel
• Lista över Prometheus exporter
• Grafana Prometheus integrationsguide
• kube-prometheus-stack Helm Chart
• Prometheus bästa praxis
• AlertManager konfiguration