System Monitorowania Prometheus: Kompletny Przewodnik Konfiguracji dla Monitorowania Infrastruktury i Aplikacji

Wraz ze wzrostem złożoności nowoczesnej infrastruktury — obejmującej mikroserwisy, kontenery i systemy rozproszone — solidny monitoring przestał być opcją. Jest to fundamentalne wymaganie dla utrzymania wydajności, niezawodności i skalowalności. Prometheus, otwartoźródłowy zestaw narzędzi do monitorowania i alertowania, stał się jednym z najszerzej stosowanych rozwiązań do zbierania i wizualizacji metryk szeregów czasowych w różnorodnych środowiskach.

Pierwotnie opracowany przez SoundCloud, a obecnie będący ukończonym projektem Cloud Native Computing Foundation (CNCF), Prometheus jest zaufanym narzędziem zespołów inżynierskich na całym świecie. Ten kompleksowy przewodnik obejmuje wszystko, co musisz wiedzieć: czym jest Prometheus, jak działa, jakie są jego podstawowe komponenty oraz kompletny proces konfiguracji krok po kroku — w tym Node Exporter, dashboardy Grafana i konfigurację alertów.

Czym jest Prometheus?

Prometheus to potężny, otwartoźródłowy system monitorowania zaprojektowany do zbierania, przechowywania i odpytywania danych szeregów czasowych — pomiarów lub zdarzeń śledzonych w czasie z wysoką rozdzielczością znaczników czasu. Umożliwia zespołom wizualizację kondycji systemu, analizę trendów i wyzwalanie inteligentnych alertów, zanim małe problemy przerodzą się w krytyczne awarie.

Kluczowe funkcje Prometheusa

Te możliwości sprawiają, że Prometheus jest idealnym wyborem dla zespołów uruchamiających obciążenia na Hostingu VPS, infrastrukturze bare-metal lub platformach kontenerowych.

Jak działa Prometheus

Prometheus opiera się na przejrzystej, dobrze zdefiniowanej architekturze zbudowanej wokół zbierania i przechowywania danych szeregów czasowych. Zrozumienie tej architektury jest niezbędne przed wdrożeniem go w środowisku produkcyjnym.

Podstawowy przepływ pracy

1. Zbieranie metryk (Scraping): Prometheus okresowo wysyła żądania HTTP do skonfigurowanych docelowych punktów końcowych — znanych jako *eksportery* — w celu zbierania metryk. Interwał pobierania jest w pełni konfigurowalny.

1. Przechowywanie szeregów czasowych: Zebrane metryki są utrwalane we wbudowanej bazie danych szeregów czasowych (TSDB) Prometheusa. Każdy punkt danych zawiera znacznik czasu Unix oraz zestaw etykiet klucz-wartość do identyfikacji.

1. Odpytywanie za pomocą PromQL: Inżynierowie używają PromQL do odpytywania przechowywanych metryk, generowania wykresów, budowania dashboardów lub definiowania warunków alertów na podstawie danych w czasie rzeczywistym i historycznych.

1. Potok alertowania: Gdy metryka przekroczy predefiniowany próg, Prometheus wysyła alert do Alertmanagera, który deduplikuje, grupuje i kieruje powiadomienia do odpowiednich kanałów.

Model oparty na pobieraniu (pull) jest świadomym wyborem architektonicznym. Upraszcza bezpieczeństwo sieci (cele nie potrzebują dostępu wychodzącego do centralnego serwera), sprawia, że konfiguracja jest przejrzysta i dobrze skaluje się w środowiskach rozproszonych.

Podstawowe komponenty Prometheusa

Prometheus to modularny ekosystem. Każdy komponent pełni określoną rolę:

1. Serwer Prometheus

Centralny silnik odpowiedzialny za pobieranie metryk z celów, przechowywanie metryk w TSDB, ocenianie reguł alertowania oraz udostępnianie API PromQL i interfejsu webowego.

2. Eksportery

Eksportery to lekkie agenty lub adaptery, które udostępniają metryki w formacie zgodnym z Prometheusem. Kluczowe eksportery to:

• Node Exporter — Zbiera metryki sprzętowe i na poziomie systemu operacyjnego: CPU, pamięć, I/O dysku, przepustowość sieci, użycie systemu plików
• Blackbox Exporter — Sonduje zewnętrzne punkty końcowe przez HTTP, HTTPS, DNS, TCP i ICMP pod kątem dostępności i opóźnień
• Eksportery baz danych — Dedykowane eksportery istnieją dla PostgreSQL, MySQL, Redis, MongoDB i wielu innych
• Eksportery specyficzne dla aplikacji — Większość nowoczesnych aplikacji i frameworków natywnie udostępnia punkt końcowy /metrics

3. Alertmanager

Obsługuje pełny cykl życia alertowania: odbieranie alertów od Prometheusa, ich deduplikację i grupowanie, stosowanie wyciszeń i reguł inhibicji oraz kierowanie powiadomień do odbiorców takich jak Slack, poczta e-mail, PagerDuty czy OpsGenie.

4. PromQL (Prometheus Query Language)

Dedykowany funkcjonalny język zapytań dla danych szeregów czasowych. PromQL obsługuje wektory natychmiastowe, wektory zakresowe, operatory agregacji, funkcje matematyczne i podzapytania — dając głęboką moc analityczną nad metrykami.

5. Pushgateway

Zaprojektowany dla efemerycznych lub wsadowych zadań, które nie mogą być bezpośrednio pobierane (np. zadanie cron działające przez 30 sekund). Zadania te przesyłają swoje metryki do Pushgateway, który Prometheus następnie pobiera w regularnych odstępach czasu.

6. Grafana

Choć nie jest częścią samego Prometheusa, Grafana jest de facto warstwą wizualizacji danych Prometheusa. Łączy się z Prometheusem jako źródłem danych i umożliwia tworzenie bogatych, interaktywnych dashboardów z panelami, zmiennymi i adnotacjami.

Konfiguracja Prometheusa na Linux krok po kroku

Poniższy przewodnik przeprowadzi Cię przez kompletne wdrożenie Prometheusa na serwerze Linux, w tym Node Exporter do metryk systemowych, Grafana do wizualizacji i Alertmanager do powiadomień.

> Wymagania wstępne: Serwer Linux (Ubuntu 20.04/22.04 lub CentOS/RHEL 8+), dostęp sudo lub root oraz podstawowa znajomość wiersza poleceń. Jeśli potrzebujesz niezawodnego środowiska serwerowego, rozważ Hosting VPS AlexHost jako wydajną podstawę o niskich opóźnieniach.

Krok 1: Instalacja Prometheusa

Pobierz i rozpakuj najnowszą wersję Prometheusa:

wget https://github.com/prometheus/prometheus/releases/download/v2.47.0/prometheus-2.47.0.linux-amd64.tar.gz
tar -xvf prometheus-2.47.0.linux-amd64.tar.gz
cd prometheus-2.47.0.linux-amd64

> Wskazówka: Przed pobraniem zawsze sprawdź oficjalną stronę wydań Prometheusa, aby uzyskać najnowszą stabilną wersję.

Utwórz dedykowanego użytkownika systemowego i strukturę katalogów:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus
sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool
sudo chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus

Utwórz usługę systemd dla Prometheusa:

sudo nano /etc/systemd/system/prometheus.service

Wklej następującą zawartość:

[Unit]
Description=Prometheus Monitoring System
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

Włącz i uruchom Prometheusa:

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

Prometheus będzie teraz dostępny pod adresem http://your-server-ip:9090.

Krok 2: Konfiguracja Prometheusa

Główny plik konfiguracyjny to /etc/prometheus/prometheus.yml. Plik ten definiuje ustawienia globalne oraz cele pobierania metryk monitorowane przez Prometheusa.

Przykład podstawowej konfiguracji:

global:
  scrape_interval: 15s        # Default scrape frequency
  evaluation_interval: 15s    # How often alerting rules are evaluated
  scrape_timeout: 10s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - localhost:9093

rule_files:
  - "/etc/prometheus/rules/*.yml"

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

Po zmodyfikowaniu tego pliku zawsze sprawdzaj poprawność konfiguracji przed ponownym uruchomieniem:

promtool check config /etc/prometheus/prometheus.yml
sudo systemctl restart prometheus

Krok 3: Instalacja Node Exporter do metryk systemowych

Node Exporter udostępnia szczegółowe metryki sprzętowe i systemu operacyjnego z systemu hosta — niezbędne do monitorowania obciążenia CPU, presji pamięci, wykorzystania dysku i przepustowości sieci.

Pobierz i zainstaluj Node Exporter:

wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
tar -xvf node_exporter-1.6.1.linux-amd64.tar.gz
sudo cp node_exporter-1.6.1.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /bin/false node_exporter
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Utwórz usługę systemd dla Node Exportera:

sudo nano /etc/systemd/system/node_exporter.service

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

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

[Install]
WantedBy=multi-user.target

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

Node Exporter udostępnia teraz metryki pod adresem http://your-server-ip:9100/metrics.

Dodaj Node Exporter jako cel pobierania metryk w prometheus.yml:

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

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

Uruchom ponownie Prometheusa i sprawdź, czy cel pojawia się jako UP w interfejsie Prometheusa w sekcji Status → Targets.

Krok 4: Wizualizacja metryk za pomocą Grafany

Grafana przekształca surowe metryki Prometheusa w przydatne, wizualnie bogate dashboardy. Jest to standardowa warstwa wizualizacji dla wdrożeń Prometheusa.

Instalacja Grafany na Ubuntu/Debian:

sudo apt-get install -y apt-transport-https software-properties-common
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Połącz Prometheusa jako źródło danych:

1. Otwórz Grafanę pod adresem http://your-server-ip:3000 (domyślne dane logowania: admin / admin)
2. Przejdź do Configuration → Data Sources → Add data source
3. Wybierz Prometheus
4. Ustaw URL na http://localhost:9090
5. Kliknij Save & Test

Zaimportuj gotowy dashboard:

• Przejdź do Dashboards → Import
• Wprowadź ID dashboardu 1860 (Node Exporter Full) z marketplace Grafany
• Wybierz źródło danych Prometheus i kliknij Import

Natychmiast uzyskasz kompleksowy widok użycia CPU, zużycia pamięci, I/O dysku, statystyk sieci i obciążenia systemu — wszystko w jednym interaktywnym dashboardzie.

Krok 5: Konfiguracja reguł alertowania i Alertmanagera

Alertowanie w Prometheusie składa się z dwóch części: reguł alertowania zdefiniowanych w Prometheusie oraz Alertmanagera, który obsługuje routing i dostarczanie.

Utwórz plik reguł alertowania:

sudo mkdir -p /etc/prometheus/rules
sudo nano /etc/prometheus/rules/system_alerts.yml

groups:
  - name: system_alerts
    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: "High CPU usage on {{ $labels.instance }}"
          description: "CPU usage has exceeded 80% for more than 5 minutes. Current value: {{ $value }}%"

      - alert: LowDiskSpace
        expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Low disk space on {{ $labels.instance }}"
          description: "Available disk space on / is below 15%. Immediate action required."

      - alert: HighMemoryUsage
        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High memory usage on {{ $labels.instance }}"
          description: "Memory usage has exceeded 85% for more than 5 minutes."

      - alert: InstanceDown
        expr: up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Instance {{ $labels.instance }} is down"
          description: "Prometheus target {{ $labels.instance }} has been unreachable for more than 1 minute."

Sprawdź poprawność pliku reguł:

promtool check rules /etc/prometheus/rules/system_alerts.yml

Zainstaluj i skonfiguruj Alertmanagera:

wget https://github.com/prometheus/alertmanager/releases/download/v0.26.0/alertmanager-0.26.0.linux-amd64.tar.gz
tar -xvf alertmanager-0.26.0.linux-amd64.tar.gz
sudo cp alertmanager-0.26.0.linux-amd64/alertmanager /usr/local/bin/
sudo mkdir /etc/alertmanager

Utwórz konfigurację Alertmanagera:

sudo nano /etc/alertmanager/alertmanager.yml

global:
  smtp_smarthost: 'smtp.yourdomain.com:587'
  smtp_from: 'alerts@yourdomain.com'
  smtp_auth_username: 'alerts@yourdomain.com'
  smtp_auth_password: 'your_password'

route:
  group_by: ['alertname', 'instance']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@yourdomain.com'
        send_resolved: true

> Uwaga: Aby zapewnić profesjonalne dostarczanie poczty e-mail w potoku alertowania, rozważ połączenie Prometheusa z Hostingiem poczty e-mail AlexHost dla niezawodnej infrastruktury SMTP.

Zaawansowana konfiguracja: odkrywanie usług

W dynamicznych środowiskach — takich jak klastry Kubernetes lub floty serwerów z automatycznym skalowaniem — statyczne listy celów szybko stają się niemożliwe do zarządzania. Prometheus obsługuje wiele mechanizmów odkrywania usług od razu po instalacji:

scrape_configs:
  - job_name: "kubernetes-pods"
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true

Obsługiwane backendy odkrywania usług obejmują Kubernetes, Consul, EC2, Azure, GCE, odkrywanie oparte na DNS i odkrywanie oparte na plikach — dzięki czemu Prometheus można dostosować do praktycznie każdej topologii infrastruktury.

Przypadki użycia Prometheusa

Prometheus doskonale sprawdza się w szerokim zakresie scenariuszy monitorowania:

Monitorowanie infrastruktury

Zbieraj metryki na poziomie serwera — CPU, pamięć, dysk, sieć — z każdego węzła w swojej flocie. Niezależnie od tego, czy korzystasz z jednego Serwera dedykowanego, czy dużego klastra, Prometheus zapewnia ujednoliconą widoczność wszystkich hostów.

Monitorowanie wydajności aplikacji (APM)

Śledź współczynniki żądań, współczynniki błędów, opóźnienia odpowiedzi (metoda RED) oraz zużycie zasobów przez aplikacje webowe i API. Biblioteki klienckie Prometheusa są dostępne dla Go, Python, Java, Ruby, Node.js i innych.

Monitorowanie Kubernetes i kontenerów

Prometheus integruje się natywnie z Kubernetes poprzez eksportery kube-state-metrics i cAdvisor, zapewniając głęboki wgląd w kondycję podów, limity zasobów, status wdrożeń i metryki na poziomie klastra.

Monitorowanie baz danych

Monitoruj wydajność zapytań, wykorzystanie puli połączeń, opóźnienie replikacji i współczynniki trafień w pamięci podręcznej dla baz danych takich jak PostgreSQL, MySQL i Redis przy użyciu dedykowanych eksporterów.

Niestandardowe metryki biznesowe

Instrumentuj własne aplikacje, aby udostępniały metryki specyficzne dla domeny — takie jak liczba przetworzonych zamówień na sekundę, aktywne sesje użytkowników lub współczynniki transakcji płatniczych — umożliwiając obserwowalność na poziomie biznesowym obok metryk technicznych.

Monitorowanie obciążeń GPU

Dla zespołów uruchamiających obciążenia związane z uczeniem maszynowym lub obliczeniami wysokiej wydajności, Prometheus może integrować się z eksporterami DCGM w celu monitorowania wykorzystania GPU, pamięci i temperatury. Doskonale współgra to z Hostingiem GPU AlexHost dla infrastruktury AI i ML.

Prometheus a alternatywne rozwiązania monitorowania

Najlepsze praktyki produkcyjne

Wdrożenie Prometheusa w środowisku produkcyjnym wymaga uwagi na kilka kwestii operacyjnych:

• Retencja danych: Domyślny okres retencji wynosi 15 dni. Dostosuj --storage.tsdb.retention.time w zależności od pojemności pamięci masowej i wymagań dotyczących zgodności. W przypadku długoterminowego przechowywania rozważ Thanos lub Cortex.
• Bezpieczeństwo: Ogranicz dostęp do interfejsu webowego i API Prometheusa za pomocą odwrotnego proxy (Nginx lub Caddy) z uwierzytelnianiem. Prometheus nie zawiera wbudowanego uwierzytelniania.
• Wysoka dostępność: Uruchom wiele instancji Prometheusa pobierających metryki z tych samych celów dla redundancji. Użyj funkcji klastrowania Alertmanagera, aby zapobiec duplikowaniu powiadomień.
• Zarządzanie kardynalnością: Unikaj etykiet o wysokiej kardynalności (np. identyfikatorów użytkowników, identyfikatorów żądań) w nazwach metryk, ponieważ mogą powodować problemy z pamięcią i wydajnością.
• Szyfrowanie TLS: Włącz TLS dla punktów końcowych pobierania metryk i API Prometheusa. Połącz to z Certyfikatem SSL, aby zabezpieczyć całą komunikację między komponentami Prometheusa.
• Planowanie zasobów: Prometheus jest intensywny pod względem pamięci. Przydziel wystarczającą ilość RAM w zależności od liczby aktywnych szeregów czasowych. Ogólna zasada to około 1–2 bajty na próbkę w pamięci.

Często zadawane pytania

P: Jaka jest różnica między Prometheusem a Grafaną?

Prometheus to backend monitorowania i alertowania — zbiera, przechowuje i odpytuje metryki. Grafana to frontend wizualizacji, który łączy się z Prometheusem (i innymi źródłami danych) w celu renderowania dashboardów. Są to narzędzia uzupełniające, a nie alternatywne.

P: Czy Prometheus może monitorować serwery Windows?

Tak. Windows Exporter (dawniej WMI Exporter) udostępnia metryki systemu Windows w formacie zgodnym z Prometheusem, obejmując CPU, pamięć, dysk, sieć, IIS i inne.

P: Jak Prometheus obsługuje wysoką dostępność?

Sam Prometheus jest zaprojektowany do działania jako pojedyncza instancja na klaster. W przypadku HA uruchamia się dwie identyczne instancje Prometheusa pobierające metryki z tych samych celów. Alertmanager obsługuje natywne klastrowanie w celu deduplikacji alertów z wielu instancji Prometheusa.

P: Do czego służy PromQL?

PromQL (Prometheus Query Language) służy do odpytywania danych szeregów czasowych przechowywanych w Prometheusie. Obsługuje zapytania natychmiastowe, zapytania zakresowe, agregacje, operacje matematyczne i funkcje — umożliwiając wszystko, od prostych wyszukiwań metryk po złożone wyrażenia wykrywania anomalii.

Podsumowanie

Prometheus to sprawdzone, produkcyjne rozwiązanie monitorowania, które zapewnia głęboki wgląd w czasie rzeczywistym w kondycję i wydajność całego stosu infrastruktury. Jego architektura oparta na pobieraniu, wielowymiarowy model danych, potężny język zapytań PromQL oraz bezproblemowe integracje z narzędziami takimi jak Grafana i Alertmanager czynią go złotym standardem nowoczesnej obserwowalności.

Niezależnie od tego, czy monitorujesz pojedynczy serwer Linux, flotę Serwerów dedykowanych, klaster Kubernetes czy złożoną aplikację mikroserwisową, Prometheus skaluje się, aby sprostać Twoim potrzebom. Postępując zgodnie z krokami opisanymi w tym przewodniku — instalując Prometheusa, wdrażając Node Exporter, konfigurując dashboardy Grafany i konfigurując inteligentne reguły alertowania — uzyskasz solidną podstawę monitorowania, która pomoże Ci wcześnie wykrywać anomalie, szybciej reagować na incydenty i stale poprawiać niezawodność systemu.

Zacznij od podstaw, iteruj nad dashboardami i progami alertów w miarę poznawania normalnego zachowania systemu i stopniowo rozszerzaj pokrycie na każdą warstwę swojego stosu. Prometheus to nie tylko narzędzie do monitorowania — to kamień węgielny nowoczesnej inżynierii niezawodności witryn.