Monitoring Prometheus: Pełne ustawienie i najlepsze praktyki

Prometheus stworzył się w praktyce standardem monitorowania aplikacji i infrastruktury w środowisku chmurowym, oferując zbieranie metryk, ich zapytanie oraz integrację z narzędziami wizualizacji.

Co to jest Prometheus?

Prometheus to open-source narzędzie do monitorowania i powiadamiania, które zostało pierwotnie opracowane w SoundCloud w 2012 roku i obecnie jest projektem zakończonym w ramach Cloud Native Computing Foundation (CNCF). Jest specjalnie zaprojektowany do niezawodności i skalowalności w dynamicznych środowiskach chmurowych, stając się rozwiązaniem pierwszego wyboru do monitorowania mikrousług, kontenerów i klastrów Kubernetes.

Kluczowe cechy

Baza danych w formacie czasowym: Prometheus przechowuje wszystkie dane w formacie czasowym, identyfikowane przez nazwy metryk i pary klucz-wartość (etykiety), umożliwiając elastyczne i potężne możliwości zapytań.

Model oparty na wyjmowaniu (pull): W przeciwieństwie do tradycyjnych systemów opartych na wysyłaniu (push), Prometheus aktywnie pobiera metryki z konfigurowanych celów w określonych odstępach czasu, co czyni go bardziej niezawodnym i łatwiejszym w konfiguracji.

Język zapytań PromQL: Potężny język funkcyjnych zapytań umożliwia ci wyciąganie i analizowanie danych metryk w czasie rzeczywistym, wykonywanie agregacji, przekształceń i złożonych obliczeń.

Odkrywanie usług: Automatyczne odkrywanie celów monitorowania za pomocą różnych mechanizmów, w tym Kubernetes, Consul, EC2 i konfiguracji statycznych.

Brak zależności zewnętrznych: Prometheus działa jako pojedynczy plik binarny bez koniecznych zależności zewnętrznych, upraszczając wdrażanie i zmniejszając złożoność operacyjną.

Wbudowane powiadamianie: AlertManager obsługuje powiadomienia wysyłane przez Prometheus, oferując deduplikację, grupowanie i routing do kanałów powiadomień, takich jak e-mail, PagerDuty lub Slack.

Przegląd architektury

Zrozumienie architektury Prometheus jest kluczowe dla skutecznego wdrażania. Głównymi składnikami są:

• Serwer Prometheus: pobiera i przechowuje metryki, ocenia reguły i udostępnia zapytania
• Biblioteki klienta: instrumentują kod aplikacji, aby ujawnić metryki
• Eksporterzy: łączą systemy trzecie z formatem Prometheus
• AlertManager: obsługuje powiadomienia i powiadomienia
• Pushgateway: akceptuje metryki z krótkotrwałych zadań, które nie mogą być pobierane

Typowy przepływ danych: Aplikacje ujawniają punkty końcowe metryk → Prometheus pobiera te punkty końcowe → Dane są przechowywane w bazie danych w formacie czasowym → Zapytania PromQL pobierają i analizują dane → Powiadomienia są generowane na podstawie reguł → AlertManager przetwarza i kieruje powiadomienia.

Gdy wdrażasz infrastrukturę na Ubuntu 24.04, Prometheus oferuje świetną podstawę dla kompleksowego monitorowania.

Instalacja Prometheus na Ubuntu

Zróbmy przegląd instalacji Prometheus na systemie Linux. Użyjemy Ubuntu jako przykład, ale proces jest podobny dla innych dystrybucji.

Pobierz i zainstaluj

Najpierw utwórz dedykowanego użytkownika dla Prometheus:

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

Pobierz najnowsze wydanie 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

Skopiuj binarki i utwórz katalogi:

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

Aby zarządzać pakietami na Ubuntu, odnies się do naszego szczegółowego Przewodnika po zarządzaniu pakietami w Ubuntu.

Konfiguracja Prometheus

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

Utwórz usługę Systemd

Utwórz /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

Uruchom i włącz Prometheus:

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

Dostęp do interfejsu sieciowego Prometheus znajduje się pod adresem http://localhost:9090.

Konfiguracja Node Exportera

Node Exporter ujawnia metryki sprzętu i systemu operacyjnego dla systemów Linux. Zainstaluj go, aby monitorować swoje serwery:

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

Utwórz usługę Systemd /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

Uruchom Node Exporter:

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

Node Exporter teraz ujawnia metryki na porcie 9100.

Zrozumienie PromQL

PromQL (Prometheus Query Language) jest sercem zapytań w Prometheus. Oto kluczowe wzorce zapytań:

Podstawowe zapytania

Wybierz wszystkie serie czasowe dla metryki:

node_cpu_seconds_total

Filtruj według etykiety:

node_cpu_seconds_total{mode="idle"}

Wiele filtrów etykiet:

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

Wektory zakresu i agregacje

Oblicz tempo w czasie:

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

Sumuj po wszystkich procesorach:

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

Grupuj według etykiety:

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

Przykłady praktyczne

Procent wykorzystania procesora:

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

Użycie pamięci:

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Użycie dysku:

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Tempo ruchu sieciowego:

rate(node_network_receive_bytes_total[5m])

Wdrażanie w kontenerach Docker

Uruchamianie Prometheus w kontenerach Docker oferuje elastyczność i łatwiejsze zarządzanie:

Utwórz 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:

Uruchom stos:

docker-compose up -d

Monitorowanie Kubernetes

Prometheus świetnie nadaje się do monitorowania klaster Kubernetes. Helm chart kube-prometheus-stack zapewnia kompleksowe rozwiązanie monitorowania.

Zainstaluj za pomocą Helm:

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

To instaluje:

• Operatora Prometheus
• Instancję Prometheus
• AlertManager
• Grafana
• Node Exporter
• kube-state-metrics
• Zaprojektowane panele i powiadomienia

Dostęp do Grafany:

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

Domyślne poświadczenia: admin/prom-operator

Dla różnych dystrybucji Kubernetes, proces wdrażania jest podobny z drobnymi dostosowaniami dla funkcji platformy.

Konfiguracja powiadomień

AlertManager obsługuje powiadomienia wysyłane przez Prometheus. Skonfiguruj reguły powiadomień i kanały powiadomień.

Reguły powiadomień

Utwórz /etc/prometheus/alert_rules.yml:

groups:
  - name: system_alerts
    interval: 30s
    rules:
      - alert: Wysokie wykorzystanie procesora
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Wysokie wykorzystanie procesora na {{ $labels.instance }}"
          description: "Wykorzystanie procesora przekracza 80% (aktualna wartość: {{ $value }}%)"

      - alert: Wysokie wykorzystanie pamięci
        expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Wysokie wykorzystanie pamięci na {{ $labels.instance }}"
          description: "Wykorzystanie pamięci przekracza 85% (aktualna wartość: {{ $value }}%)"

      - alert: Niski stan dysku
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Niski stan dysku na {{ $labels.instance }}"
          description: "Dostępny stan dysku jest poniżej 15% na {{ $labels.mountpoint }}"

      - alert: Instancja w dół
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Instancja {{ $labels.instance }} jest w dół"
          description: "Instancja {{ $labels.job }} {{ $labels.instance }} była w dół przez więcej niż 2 minuty"

Konfiguracja AlertManager

Utwórz /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: 'Alert: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

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

Integracja z Grafaną

Choć Prometheus ma podstawowy interfejs sieciowy, Grafana oferuje lepszą wizualizację do tworzenia kompleksowych paneli.

Dodaj Prometheus jako źródło danych

1. Otwórz Grafanę i przejdź do Konfiguracja → Źródła danych
2. Kliknij “Dodaj źródło danych”
3. Wybierz “Prometheus”
4. Ustaw URL na http://localhost:9090 (lub swój serwer Prometheus)
5. Kliknij “Zapisz i przetestuj”

Popularne ID paneli

Importuj gotowe panele z grafana.com:

• Pełny Node Exporter (ID: 1860): Kompleksowe metryki systemu Linux
• Monitorowanie klastra Kubernetes (ID: 7249): Przegląd Kubernetes
• Monitorowanie kontenerów Docker (ID: 193): Metryki kontenerów
• Metryki Prometheus (ID: 2): Wewnętrzne metryki Prometheus

Tworzenie własnych paneli

Utwórz panele przy użyciu zapytań PromQL:

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

Popularne eksporterzy

Rozszerz monitorowanie Prometheus za pomocą specjalistycznych eksporterów:

Blackbox Eksporter

Testuje punkty końcowe przez HTTP, HTTPS, DNS, TCP i 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

Eksporterzy baz danych

• mysqld_exporter: Metryki MySQL/MariaDB
• postgres_exporter: Metryki PostgreSQL
• mongodb_exporter: Metryki MongoDB
• redis_exporter: Metryki Redis

Eksporterzy aplikacji

• nginx_exporter: Metryki serwera NGINX
• apache_exporter: Metryki serwera HTTP Apache
• haproxy_exporter: Metryki balansera obciążenia HAProxy

Eksporterzy chmurowe

• cloudwatch_exporter: Metryki AWS CloudWatch
• stackdriver_exporter: Metryki Google Cloud
• azure_exporter: Metryki Azure Monitor

Praktyczne zasady

Przechowywanie danych

Skonfiguruj odpowiednie przechowywanie danych w zależności od potrzeb:

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

Reguły zapisu

Wstępnie oblicz często używane wyrażenia:

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)

Zarządzanie etykietami

• Utrzymuj niską liczbę etykiet
• Używaj spójnych konwencji nazewnictwa
• Unikaj etykiet o wysokiej liczbie (identyfikatory użytkowników, znaczniki czasu)

Bezpieczeństwo

• Włącz autoryzację i HTTPS
• Ogranicz dostęp do API Prometheus
• Użyj zasad sieciowych w Kubernetes
• Zaimplementuj RBAC dla wrażliwych metryk

Wysoka dostępność

• Uruchom wiele instancji Prometheus
• Użyj Thanos lub Cortex do długoterminowego przechowywania danych
• Zaimplementuj federację dla hierarchicznych konfiguracji

Rozwiązywanie typowych problemów

Wysokie użycie pamięci

• Zmniejsz częstotliwość pobierania
• Zmniejsz okres przechowywania danych
• Optymalizuj zapytania PromQL
• Zaimplementuj reguły zapisu

Brak metryk

• Sprawdź status celów w /targets
• Weryfikuj łączność sieciową
• Sprawdź konfigurację pobierania
• Sprawdź dzienniki eksporterów

Wolne zapytania

• Użyj reguł zapisu dla złożonych agregacji
• Optymalizuj filtry etykiet
• Zmniejsz zakres czasowy
• Dodaj indeksy, jeśli używasz magazynu zdalnego

Optymalizacja wydajności

Optymalizacja zapytań

# Zły: wysoka liczba etykiet
sum(rate(http_requests_total[5m]))

# Dobry: Grupuj według odpowiednich etykiet
sum by (status, method) (rate(http_requests_total[5m]))

Limity zasobów

Dla wdrożeń Kubernetes:

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

Podsumowanie

Prometheus oferuje niezawodne i skalowalne rozwiązanie do monitorowania nowoczesnej infrastruktury. Jego architektura oparta na wyjmowaniu (pull), potężny język zapytań i szeroka ekosystema eksporterów czynią go idealnym do monitorowania wszystkiego od serwerów bare-metalowych po złożone klastry Kubernetes.

Połączenie Prometheus z Grafaną do wizualizacji i AlertManager do powiadomień tworzy kompleksową platformę obserwacji, która jest w stanie obsługiwać wymagania monitorowania na poziomie przedsiębiorstwa. Aktywna społeczność i wsparcie CNCF zapewniają dalszy rozwój i wsparcie.

Zacznij od podstawowego zbierania metryk, stopniowo dodawaj eksporterów dla swoich usług i wyrafinuj swoje reguły powiadomień na podstawie doświadczenia z rzeczywistością. Prometheus skaluje się wraz z infrastrukturą, od wdrożeń jedno-serwerowych po architektury monitorowania wielu centrum danych.

Powiązane zasoby

• Jak zainstalować Ubuntu 24.04 i przydatne narzędzia
• Zarządzanie pakietami w Ubuntu: Przewodnik APT i dpkg
• Instalacja i użycie Grafany na Ubuntu: kompletny przewodnik
• Przewodnik po Kubernetes
• Dystrybucje Kubernetes - szybki przegląd kubeadm, k3s, MicroK8s, Minikube, Talos Linux i RKE2
• Przewodnik po Docker

Zewnętrzne odniesienia

• Oficjalna dokumentacja Prometheus
• Przykłady zapytań PromQL
• Lista eksporterów Prometheus
• Przewodnik po integracji Prometheus z Grafaną
• Helm Chart kube-prometheus-stack
• Najlepsze praktyki Prometheus
• Konfiguracja AlertManager