Zbieranie metryk: Kompleksowy przewodnik po Prometheus i Grafana

W dzisiejszym złożonym krajobrazie IT skuteczny monitoring ma kluczowe znaczenie dla utrzymania kondycji i wydajności aplikacji oraz infrastruktury. Zbieranie metryk stanowi podstawę tego monitoringu, umożliwiając śledzenie kluczowych wskaźników wydajności (KPI), identyfikowanie potencjalnych problemów i optymalizację wykorzystania zasobów. Ten kompleksowy przewodnik pokaże, jak wykorzystać Prometheus i Grafana, dwa potężne narzędzia open-source, do solidnego zbierania i wizualizacji metryk.

Czym jest zbieranie metryk?

Zbieranie metryk polega na gromadzeniu danych numerycznych, które reprezentują stan i zachowanie różnych systemów, aplikacji i komponentów infrastruktury w czasie. Metryki te mogą obejmować wykorzystanie procesora, zużycie pamięci, ruch sieciowy, czasy odpowiedzi, wskaźniki błędów i wiele innych istotnych wskaźników. Analizując te metryki, można uzyskać cenne informacje na temat wydajności i kondycji swojego środowiska.

Dlaczego zbieranie metryk jest ważne?

Proaktywne wykrywanie problemów: Identyfikacja potencjalnych problemów, zanim wpłyną na użytkowników.
Optymalizacja wydajności: Wskazywanie wąskich gardeł i obszarów do poprawy.
Planowanie pojemności: Prognozowanie przyszłych potrzeb zasobów na podstawie trendów historycznych.
Monitorowanie umów o poziomie usług (SLA): Zapewnienie zgodności z celami wydajnościowymi.
Rozwiązywanie problemów i analiza przyczyn źródłowych: Szybkie diagnozowanie i rozwiązywanie problemów.

Wprowadzenie do Prometheus i Grafana

Prometheus to otwarty system monitorowania i alertowania, pierwotnie opracowany w SoundCloud. Doskonale radzi sobie ze zbieraniem i przechowywaniem danych szeregów czasowych, czyli danych indeksowanych znacznikami czasu. Prometheus wykorzystuje model oparty na pobieraniu (pull-based model) do odpytywania o metryki z celów (np. serwerów, aplikacji) w regularnych odstępach czasu. Oferuje potężny język zapytań (PromQL) do analizy zebranych danych i definiowania reguł alertowania.

Grafana to otwarta platforma do wizualizacji i monitorowania danych. Umożliwia tworzenie interaktywnych pulpitów nawigacyjnych i wykresów do wizualizacji danych z różnych źródeł, w tym z Prometheus. Grafana oferuje bogaty zestaw opcji wizualizacji, w tym wykresy, diagramy, tabele i wskaźniki. Obsługuje również alertowanie, co pozwala na otrzymywanie powiadomień o przekroczeniu określonych progów.

Razem, Prometheus i Grafana tworzą potężne i elastyczne rozwiązanie do monitorowania, które można dostosować do szerokiej gamy środowisk i przypadków użycia. Są one szeroko stosowane w praktykach DevOps i SRE (Site Reliability Engineering) na całym świecie.

Architektura i koncepcje Prometheus

Zrozumienie podstawowych komponentów Prometheus jest niezbędne do skutecznego wdrożenia i użytkowania:

Serwer Prometheus: Główny komponent odpowiedzialny za odpytywanie, przechowywanie i zapytania o metryki.
Odkrywanie usług (Service Discovery): Automatycznie odkrywa cele do monitorowania na podstawie konfiguracji lub integracji z platformami takimi jak Kubernetes.
Eksportery: Agenci, którzy udostępniają metryki w formacie zrozumiałym dla Prometheus. Przykłady obejmują node_exporter (dla metryk systemowych) oraz różne eksportery specyficzne dla aplikacji.
Pushgateway (Opcjonalny): Umożliwia krótkotrwałym zadaniom przesyłanie metryk do Prometheus. Jest to przydatne dla zadań wsadowych, które mogą nie działać w sposób ciągły.
Alertmanager: Obsługuje alerty generowane przez Prometheus na podstawie skonfigurowanych reguł. Może kierować alerty do różnych kanałów powiadomień, takich jak e-mail, Slack czy PagerDuty.
PromQL: Język zapytań Prometheus (Prometheus Query Language) używany do odpytywania i analizowania zebranych metryk.

Przepływ pracy w Prometheus

Cele (aplikacje, serwery itp.) udostępniają metryki. Metryki te są zwykle udostępniane za pośrednictwem punktu końcowego HTTP.
Serwer Prometheus odpytuje o metryki skonfigurowane cele. Okresowo pobiera metryki z tych punktów końcowych.
Prometheus przechowuje pobrane metryki w swojej bazie danych szeregów czasowych.
Użytkownicy odpytują metryki za pomocą PromQL. Pozwala to na analizę danych oraz tworzenie wykresów i pulpitów nawigacyjnych.
Reguły alertowania są oceniane na podstawie przechowywanych metryk. Jeśli warunek reguły jest spełniony, uruchamiany jest alert.
Alertmanager obsługuje uruchomione alerty. Deduplikuje je, grupuje i kieruje do odpowiednich kanałów powiadomień.

Architektura i koncepcje Grafana

Grafana uzupełnia Prometheus, dostarczając przyjazny dla użytkownika interfejs do wizualizacji i analizy zebranych metryk:

Źródła danych: Połączenia z różnymi źródłami danych, w tym Prometheus, Graphite, InfluxDB i innymi.
Pulpity nawigacyjne (Dashboards): Zbiory paneli, które wyświetlają dane w różnych formatach (wykresy, diagramy, tabele itp.).
Panele: Indywidualne wizualizacje, które wyświetlają dane z określonego źródła danych przy użyciu określonego zapytania.
Alertowanie: Grafana ma również wbudowane funkcje alertowania, pozwalające definiować alerty na podstawie danych wyświetlanych na pulpitach nawigacyjnych. Te alerty mogą używać Prometheus jako źródła danych i wykorzystywać PromQL do złożonej logiki alertowania.
Organizacje i zespoły: Grafana obsługuje organizacje i zespoły, umożliwiając zarządzanie dostępem i uprawnieniami do pulpitów nawigacyjnych i źródeł danych.

Przepływ pracy w Grafana

Konfiguracja źródeł danych: Połącz Grafanę z serwerem Prometheus.
Tworzenie pulpitów nawigacyjnych: Projektuj pulpity do wizualizacji metryk.
Dodawanie paneli do pulpitów: Dodawaj panele, aby wyświetlać określone punkty danych z Prometheus za pomocą zapytań PromQL.
Konfiguracja alertowania (Opcjonalne): Skonfiguruj reguły alertowania w Grafanie, aby otrzymywać powiadomienia na podstawie określonych progów metryk.
Udostępnianie pulpitów nawigacyjnych: Udostępniaj pulpity swojemu zespołowi, aby współpracować przy monitorowaniu i analizie.

Konfiguracja Prometheus i Grafana

Ta sekcja zawiera przewodnik krok po kroku dotyczący konfiguracji Prometheus i Grafana.

Instalacja Prometheus

1. Pobierz Prometheus:

Pobierz najnowszą wersję Prometheus z oficjalnej strony internetowej: https://prometheus.io/download/. Wybierz odpowiedni pakiet dla swojego systemu operacyjnego (np. Linux, Windows, macOS).

2. Wypakuj archiwum:

Wypakuj pobrane archiwum do wybranego katalogu.

3. Skonfiguruj Prometheus:

Utwórz plik konfiguracyjny `prometheus.yml`. Ten plik definiuje cele, które Prometheus będzie odpytywał, oraz inne opcje konfiguracyjne. Podstawowa konfiguracja może wyglądać następująco:


global:
  scrape_interval:     15s
  evaluation_interval: 15s

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

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

Ta konfiguracja definiuje dwa zadania odpytywania (scrape jobs): jedno dla samego Prometheus (pobierające jego własne metryki) i jedno dla node_exporter działającego na localhost na porcie 9100. `scrape_interval` określa, jak często Prometheus będzie odpytywał cele.

4. Uruchom Prometheus:

Uruchom plik wykonywalny Prometheus z katalogu, do którego wypakowałeś archiwum:

./prometheus --config.file=prometheus.yml

Prometheus uruchomi się i domyślnie będzie nasłuchiwał na porcie 9090. Możesz uzyskać dostęp do interfejsu internetowego Prometheus w przeglądarce pod adresem http://localhost:9090.

Instalacja Grafana

1. Pobierz Grafana:

Pobierz najnowszą wersję Grafana z oficjalnej strony internetowej: https://grafana.com/grafana/download. Wybierz odpowiedni pakiet dla swojego systemu operacyjnego.

2. Zainstaluj Grafana:

Postępuj zgodnie z instrukcjami instalacji dla swojego systemu operacyjnego. Na przykład na Debian/Ubuntu:


sudo apt-get update
sudo apt-get install -y apt-transport-https
sudo apt-get install -y software-properties-common wget
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 -a /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana

3. Uruchom Grafana:

Uruchom usługę Grafana:

sudo systemctl start grafana-server

4. Uzyskaj dostęp do Grafana:

Grafana uruchomi się i domyślnie będzie nasłuchiwać na porcie 3000. Możesz uzyskać dostęp do interfejsu internetowego Grafana w przeglądarce pod adresem http://localhost:3000.

Domyślna nazwa użytkownika i hasło to `admin` i `admin`. Zostaniesz poproszony o zmianę hasła przy pierwszym logowaniu.

Podłączanie Grafany do Prometheus

Aby wizualizować metryki z Prometheus w Grafanie, musisz skonfigurować Prometheus jako źródło danych w Grafanie.

1. Dodaj źródło danych:

W interfejsie internetowym Grafana przejdź do Konfiguracja > Źródła danych i kliknij Dodaj źródło danych.

2. Wybierz Prometheus:

Wybierz Prometheus jako typ źródła danych.

3. Skonfiguruj połączenie z Prometheus:

Wprowadź adres URL swojego serwera Prometheus (np. `http://localhost:9090`). Skonfiguruj inne opcje w razie potrzeby (np. uwierzytelnianie).

4. Zapisz i przetestuj:

Kliknij Zapisz i przetestuj, aby zweryfikować, czy Grafana może pomyślnie połączyć się z Prometheus.

Tworzenie pulpitów nawigacyjnych w Grafanie

Gdy połączysz Grafanę z Prometheus, możesz tworzyć pulpity nawigacyjne do wizualizacji swoich metryk.

1. Utwórz nowy pulpit nawigacyjny:

W interfejsie internetowym Grafana kliknij ikonę + na pasku bocznym i wybierz Pulpit nawigacyjny.

2. Dodaj panel:

Kliknij Dodaj pusty panel, aby dodać nowy panel do pulpitu.

3. Skonfiguruj panel:

Wybierz źródło danych: Wybierz skonfigurowane wcześniej źródło danych Prometheus.
Wprowadź zapytanie PromQL: Wprowadź zapytanie PromQL, aby pobrać metrykę, którą chcesz zwizualizować. Na przykład, aby wyświetlić wykorzystanie procesora, możesz użyć następującego zapytania:


rate(process_cpu_seconds_total{job="node_exporter"}[5m])

To zapytanie oblicza tempo zmian czasu procesora wykorzystywanego przez procesy zbierane przez node_exporter w 5-minutowym interwale.

Skonfiguruj opcje wizualizacji: Wybierz typ wizualizacji (np. wykres, wskaźnik, tabela) i skonfiguruj inne opcje w razie potrzeby (np. etykiety osi, kolory).

4. Zapisz pulpit nawigacyjny:

Kliknij ikonę zapisu, aby zapisać pulpit nawigacyjny.

PromQL: Język zapytań Prometheus

PromQL to potężny język zapytań używany do pobierania i manipulowania metrykami przechowywanymi w Prometheus. Pozwala na wykonywanie szerokiego zakresu operacji, w tym:

Filtrowanie: Wybieranie metryk na podstawie etykiet.
Agregacja: Obliczanie wartości zagregowanych (np. suma, średnia, maksimum) w określonych zakresach czasowych lub dla wielu instancji.
Obliczanie tempa (rate): Obliczanie tempa zmian metryk typu licznik (counter).
Operacje arytmetyczne: Wykonywanie operacji arytmetycznych na metrykach (np. dodawanie, odejmowanie, mnożenie).
Funkcje szeregów czasowych: Stosowanie funkcji do danych szeregów czasowych (np. średnia ruchoma, wygładzanie).

Przykłady PromQL

Wykorzystanie procesora:


rate(process_cpu_seconds_total{job="node_exporter"}[5m])

Zużycie pamięci:


node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes

Wykorzystanie przestrzeni dyskowej:


(node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_free_bytes{mountpoint="/"}) / node_filesystem_size_bytes{mountpoint="/"} * 100

Tempo zapytań HTTP:


rate(http_requests_total[5m])

Nauka PromQL jest niezbędna do efektywnego korzystania z Prometheus i Grafana. Zapoznaj się z dokumentacją Prometheus, aby uzyskać kompleksowy przewodnik po tym języku.

Alertowanie za pomocą Prometheus i Alertmanager

Prometheus dostarcza solidny system alertowania, który pozwala definiować reguły na podstawie wartości metryk. Gdy warunek reguły jest spełniony, uruchamiany jest alert, a Alertmanager zajmuje się procesem powiadamiania.

Definiowanie reguł alertowania

Reguły alertowania są definiowane w pliku konfiguracyjnym `prometheus.yml`. Oto przykład reguły alertowania, która uruchamia się, gdy wykorzystanie procesora przekroczy 80%:


rule_files:
  - "rules.yml"

Następnie w pliku o nazwie `rules.yml` umieść reguły takie jak ta:


groups:
- name: example
  rules:
  - alert: HighCPUUsage
    expr: rate(process_cpu_seconds_total{job="node_exporter"}[5m]) > 0.8
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Wykryto wysokie zużycie procesora"
      description: "Zużycie procesora przekracza 80% na instancji {{ $labels.instance }}"

Wyjaśnienie:

alert: Nazwa alertu.
expr: Wyrażenie PromQL, które definiuje warunek alertu.
for: Czas, przez który warunek musi być prawdziwy, zanim alert zostanie uruchomiony.
labels: Etykiety dołączane do alertu.
annotations: Adnotacje, które dostarczają dodatkowych informacji o alercie, takich jak podsumowanie i opis.

Konfiguracja Alertmanager

Alertmanager obsługuje routing i powiadamianie o alertach. Musisz skonfigurować Alertmanager, aby określić, dokąd mają być wysyłane alerty (np. e-mail, Slack, PagerDuty). Szczegółowe instrukcje konfiguracji można znaleźć w dokumentacji Alertmanager.

Minimalna konfiguracja `alertmanager.yml` może wyglądać tak:


global:
  resolve_timeout: 5m

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 12h
  receiver: 'web.hook'

receivers:
- name: 'web.hook'
  webhook_configs:
  - url: 'http://localhost:8080/'

Ta konfiguracja wysyła alerty do webhooka na localhost na porcie 8080. Możesz dostosować sekcję `receivers`, aby zamiast tego używać usług takich jak Slack lub e-mail.

Praktyczne przykłady i przypadki użycia

Prometheus i Grafana mogą być używane do monitorowania szerokiej gamy aplikacji i komponentów infrastruktury. Oto kilka praktycznych przykładów:

Monitorowanie serwera WWW: Monitorowanie wskaźników żądań HTTP, czasów odpowiedzi i wskaźników błędów w celu zapewnienia optymalnej wydajności serwera WWW.
Monitorowanie bazy danych: Śledzenie wykorzystania puli połączeń bazy danych, czasów wykonywania zapytań i wolnych zapytań w celu identyfikacji wąskich gardeł w bazie danych.
Monitorowanie Kubernetes: Monitorowanie kondycji i wydajności klastrów Kubernetes, w tym wykorzystania zasobów przez pody i węzły.
Monitorowanie aplikacji: Zbieranie niestandardowych metryk z aplikacji w celu śledzenia określonych biznesowych wskaźników KPI i identyfikowania problemów na poziomie aplikacji.
Monitorowanie sieci: Śledzenie ruchu sieciowego, opóźnień i utraty pakietów w celu identyfikacji wąskich gardeł sieciowych i problemów z wydajnością.
Monitorowanie infrastruktury chmurowej: Monitorowanie wydajności i dostępności zasobów chmurowych, takich jak maszyny wirtualne, pamięć masowa i bazy danych. Jest to szczególnie istotne w środowiskach AWS, Azure i Google Cloud, z których wszystkie mają integracje z Prometheus i Grafana.

Przykład: Monitorowanie architektury mikroserwisów

W architekturze mikroserwisów Prometheus i Grafana mogą być używane do monitorowania kondycji i wydajności poszczególnych usług, a także całego systemu. Każda usługa może udostępniać własne metryki, takie jak wskaźniki żądań, czasy odpowiedzi i wskaźniki błędów. Prometheus może następnie pobierać te metryki, a Grafana może być używana do ich wizualizacji. Pozwala to na szybkie identyfikowanie wąskich gardeł wydajności lub awarii w określonych usługach.

Zaawansowane techniki i dobre praktyki

Aby w pełni wykorzystać możliwości Prometheus i Grafana, warto rozważyć następujące zaawansowane techniki i dobre praktyki:

Używaj znaczących etykiet: Używaj etykiet, aby dodać kontekst do swoich metryk. Ułatwia to filtrowanie i agregowanie danych. Na przykład używaj etykiet do identyfikacji usługi, środowiska i instancji, z którą powiązana jest metryka.
Monitoruj kluczowe wskaźniki wydajności (KPI): Skoncentruj się na monitorowaniu metryk, które są najważniejsze dla Twojej firmy. Pozwala to na szybkie identyfikowanie i rozwiązywanie problemów, które mają największy wpływ.
Ustaw odpowiednie progi alertowania: Ustaw progi alertowania, które są odpowiednie dla Twojego środowiska. Unikaj ustawiania zbyt czułych progów, ponieważ może to prowadzić do zmęczenia alertami.
Efektywnie używaj pulpitów nawigacyjnych: Projektuj pulpity, które są łatwe do zrozumienia i dostarczają użytecznych informacji. Używaj jasnych i zwięzłych etykiet oraz wizualizacji.
Automatyzuj wdrażanie i konfigurację: Automatyzuj wdrażanie i konfigurację Prometheus i Grafana za pomocą narzędzi takich jak Ansible, Terraform czy Kubernetes.
Zabezpiecz swoje instancje Prometheus i Grafana: Zabezpiecz swoje instancje Prometheus i Grafana, aby zapobiec nieautoryzowanemu dostępowi. Używaj uwierzytelniania i autoryzacji do kontrolowania dostępu do wrażliwych danych.
Rozważ skalowanie horyzontalne: W dużych środowiskach rozważ skalowanie horyzontalne instancji Prometheus i Grafana, aby obsłużyć zwiększone obciążenie. Można to osiągnąć, używając wielu serwerów Prometheus i instancji Grafana za load balancerem.
Wykorzystaj odkrywanie usług (Service Discovery): Wykorzystaj możliwości odkrywania usług w Prometheus, aby automatycznie odkrywać i monitorować nowe cele. Jest to szczególnie przydatne w dynamicznych środowiskach, takich jak Kubernetes.

Rozwiązywanie typowych problemów

Nawet przy starannym planowaniu i wdrożeniu możesz napotkać problemy podczas korzystania z Prometheus i Grafana. Oto niektóre typowe problemy i ich rozwiązania:

Prometheus nie pobiera metryk: Sprawdź, czy cel jest dostępny z serwera Prometheus. Sprawdź logi Prometheus pod kątem błędów. Upewnij się, że cel udostępnia metryki w prawidłowym formacie.
Grafana nie łączy się z Prometheus: Sprawdź, czy adres URL Prometheus jest poprawny w konfiguracji źródła danych Grafana. Sprawdź logi Grafana pod kątem błędów. Upewnij się, że serwer Prometheus działa i jest dostępny z serwera Grafana.
Zapytania PromQL nie zwracają danych: Sprawdź, czy zapytanie PromQL jest poprawne. Sprawdź logi Prometheus pod kątem błędów. Upewnij się, że metryka, o którą pytasz, istnieje i jest pobierana przez Prometheus.
Alerty nie są uruchamiane: Sprawdź, czy reguła alertowania jest poprawnie zdefiniowana. Sprawdź logi Prometheus pod kątem błędów. Upewnij się, że Alertmanager działa i jest poprawnie skonfigurowany.
Problemy z wydajnością: Jeśli doświadczasz problemów z wydajnością, rozważ skalowanie horyzontalne instancji Prometheus i Grafana. Zoptymalizuj zapytania PromQL, aby zmniejszyć obciążenie serwera Prometheus.

Alternatywne rozwiązania do monitorowania

Chociaż Prometheus i Grafana to potężne narzędzia, nie są jedynymi opcjami do zbierania i wizualizacji metryk. Inne popularne rozwiązania do monitorowania obejmują:

Datadog: Komercyjna platforma monitorująca, która oferuje szeroki zakres funkcji, w tym zbieranie metryk, zarządzanie logami i monitorowanie wydajności aplikacji (APM).
New Relic: Inna komercyjna platforma monitorująca, która zapewnia kompleksowe możliwości monitorowania aplikacji i infrastruktury.
InfluxDB i Chronograf: Baza danych szeregów czasowych i platforma wizualizacyjna, często używana jako alternatywa dla Prometheus i Grafana.
Elasticsearch, Logstash i Kibana (ELK Stack): Popularny otwarty stos do zarządzania i analizy logów. Chociaż jest używany głównie do logów, może być również wykorzystywany do zbierania i wizualizacji metryk.
Dynatrace: Platforma monitorująca oparta na sztucznej inteligencji, która zapewnia kompleksową widoczność wydajności aplikacji i infrastruktury.

Najlepsze rozwiązanie do monitorowania dla Twojej organizacji będzie zależeć od Twoich specyficznych wymagań i budżetu.

Podsumowanie

Zbieranie metryk jest niezbędne do utrzymania kondycji i wydajności aplikacji oraz infrastruktury. Prometheus i Grafana zapewniają potężne i elastyczne rozwiązanie open-source do zbierania, przechowywania i wizualizacji metryk. Dzięki zrozumieniu podstawowych koncepcji i przestrzeganiu dobrych praktyk przedstawionych w tym przewodniku, możesz wykorzystać Prometheus i Grafana do zbudowania solidnego systemu monitorowania, który spełni potrzeby Twojej organizacji.

Skuteczny monitoring, w połączeniu z proaktywnym alertowaniem i szybką reakcją na incydenty, jest fundamentem nowoczesnych operacji IT. Wdrożenie narzędzi takich jak Prometheus i Grafana umożliwia organizacjom dostarczanie niezawodnych i wydajnych usług swoim użytkownikom, niezależnie od ich lokalizacji czy branży.