Jak monitorować Kubernetes za pomocą Grafany i Prometheusa

Monitorowanie Kubernetes za pomocą Grafany i Prometheusa: przewodnik krok po kroku

Monitorowanie Kubernetes za pomocą Grafany i Prometheusa: przewodnik krok po kroku

Kubernetes stał się fundamentalną warstwą dla nowoczesnego wdrażania aplikacji, jednak jego dynamiczna, rozproszona natura sprawia, że kompleksowa obserwowalność jest obowiązkowym wymogiem dla udanej eksploatacji. Musisz rozumieć stan swoich węzłów, wydajność podów i kondycję klastra, aby zapewnić niezawodność i uniknąć kosztownych przestojów. Ten przewodnik oferuje jasną, krok po kroku ścieżkę do opanowania monitorowania Kubernetes za pomocą Grafany i Prometheusa, przekształcając surowe metryki w użyteczne informacje, które pozwolą Ci proaktywnie zarządzać swoją infrastrukturą.

Czego się nauczysz

Pod koniec tego przewodnika zrozumiesz, jak wdrożyć pełny, gotowy do produkcji stos monitorowania w swoim klastrze Kubernetes, korzystając z branżowego standardu kube-prometheus-stack. Będziesz mógł podłączyć Gfanę do Prometheusa, zaimportować gotowe dashboardy do natychmiastowej wizualizacji i uzyskać jasny plan konfiguracji alertów i wizualizacji dostosowanych do Twoich konkretnych potrzeb. Najważniejszy wniosek: Helm chart kube-prometheus-stack to najszybszy i najbardziej niezawodny sposób na wdrożenie pełnoprawnego monitorowania Kubernetes.

Branżowy standard stosu monitorowania dla Kubernetes

Połączenie Prometheusa i Grafany jest de facto standardem dla monitorowania Kubernetes. Według danych branżowych około 75% organizacji korzystających z Kubernetes wybiera Prometheusa i Gfanę do swoich potrzeb w zakresie obserwowalności. To nie tylko trend; to świadectwo mocy i elastyczności tego zestawu narzędzi open source.

• Prometheus to projekt Cloud Native Computing Foundation (CNCF), zaprojektowany z myślą o niezawodności i skalowalności. Działa poprzez zbieranie metryk z różnych celów (np. podów Twojej aplikacji lub węzłów Kubernetes) w określonych odstępach czasu i przechowywanie ich w bazie danych szeregów czasowych. Następnie możesz odpytywać te dane za pomocą PromQL (języka zapytań Prometheusa), potężnego i elastycznego języka do agregacji i analizy metryk.
• Grafana to warstwa wizualizacji. Bezproblemowo integruje się z Prometheusem, przekształcając surowe zebrane dane w piękne, interaktywne dashboardy i wykresy w czasie rzeczywistym. Taka wizualna reprezentacja znacznie ułatwia identyfikację trendów, wykrywanie anomalii i rozwiązywanie problemów z wydajnością na pierwszy rzut oka. Grafana może również służyć jako jednolity interfejs dla innych źródeł danych, ale dla Kubernetes Prometheus jest jej najważniejszym partnerem.

Wymagania wstępne do konfiguracji

Zanim zaczniesz, upewnij się, że masz zainstalowane i skonfigurowane następujące narzędzia. Ten przewodnik zakłada posiadanie działającego klastra Kubernetes, czy to lokalnego środowiska programistycznego, takiego jak Minikube, czy klastra produkcyjnego w chmurze.

• Działający klaster Kubernetes: Potrzebujesz klastra do wdrożenia stosu monitorowania. Do lokalnych testów świetnie nadają się Minikube lub Kind.
• Helm: Menedżer pakietów Kubernetes jest niezbędny do wdrożenia kube-prometheus-stack. Upewnij się, że masz zainstalowany Helm v3.2+ na swoim lokalnym komputerze.
• kubectl: Narzędzie wiersza poleceń Kubernetes musi być skonfigurowane do interakcji z Twoim klastrem.

Wdrożenie krok po kroku: użycie kube-prometheus-stack

Najbardziej efektywnym i zalecanym sposobem wdrożenia Prometheusa i Grafany do monitorowania Kubernetes jest użycie Helm chart kube-prometheus-stack. Ten chart jest utrzymywany przez społeczność Prometheus i łączy wszystkie niezbędne komponenty w jeden łatwy w zarządzaniu pakiet. Obejmuje:

• Prometheus Operator: Zarządza instancjami Prometheusa i Alertmanagera.
• Prometheus: Główny serwer metryk.
• Alertmanager: Obsługuje alerty wysyłane przez Prometheusa.
• Grafana: Platforma wizualizacyjna.
• Node Exporter: Zbiera metryki na poziomie węzłów (CPU, pamięć, dysk) z Twoich węzłów Kubernetes.
• kube-state-metrics: Generuje metryki o stanie obiektów Kubernetes, takich jak pody, wdrożenia i usługi.

1. Dodanie repozytorium Helm społeczności Prometheus

Najpierw dodaj oficjalne repozytorium Helm i zaktualizuj je, aby uzyskać najnowsze wersje chartów.

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

2. Instalacja stosu

Możesz zainstalować stos za pomocą jednego polecenia Helm, konfigurując go za pomocą różnych parametrów. Ten przykład tworzy przestrzeń nazw monitoring i włącza trwałe przechowywanie danych dla Prometheusa i Grafany.

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  --set grafana.service.type=NodePort \
  --set grafana.service.nodePort=30094 \
  --set grafana.adminPassword=admin \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.accessModes=["ReadWriteOnce"] \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.resources.requests.storage=50Gi \
  --set prometheus.prometheusSpec.retention=30d

• grafana.adminPassword=admin: Ustawia hasło administratora dla Grafany. Zmień je w środowisku produkcyjnym.
• --set grafana.service.type=NodePort: Udostępnia Gfanę z zewnątrz klastra przez NodePort dla wygodnego dostępu.
• prometheus.prometheusSpec.retention=30d: Ustawia okres przechowywania danych Prometheusa na 30 dni, co jest niezbędne do długoterminowej analizy trendów.

3. Weryfikacja instalacji

Upewnij się, że wszystkie pody w przestrzeni nazw monitoring działają.

kubectl get pods -n monitoring

Wynik powinien pokazywać kilka podów ze statusem Running, w tym pody dla Grafany, Prometheusa, Alertmanagera, node-exporter i kube-state-metrics.

Podłączanie Grafany do źródła danych Prometheus

Helm chart kube-prometheus-stack często automatycznie konfiguruje Prometheusa jako źródło danych w Grafanie. Jednak warto sprawdzić połączenie.

Dostęp do interfejsu Grafany

Aby uzyskać dostęp do interfejsu internetowego Grafany, możesz użyć przekierowania portów do lokalnych testów lub otworzyć usługę za pomocą LoadBalancera lub Ingressa w środowisku produkcyjnym.

Opcja A: Przekierowanie portów (do szybkiego dostępu lokalnego)

To najprostszy sposób na tymczasowy dostęp do dashboardu.

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

Teraz otwórz przeglądarkę i przejdź pod adres http://localhost:3000.

⚠️ Ważne: Przekierowanie portów nadaje się tylko do lokalnych testów i programowania. Do stałej konfiguracji produkcyjnej należy udostępnić Gfanę za pomocą usługi typu LoadBalancer lub Ingress Controller.

Opcja B: LoadBalancer (zalecane dla środowisk chmurowych)

Jeśli pracujesz u dostawcy chmury, takiego jak UpCloud, AWS lub GCP, możesz po prostu zmienić usługę Grafany na użycie LoadBalancera.

kubectl patch svc prometheus-grafana -n monitoring -p '{"spec": {"type": "LoadBalancer"}}'

Następnie uzyskaj zewnętrzny adres IP:

kubectl get svc -n monitoring prometheus-grafana

Otwórz Gfanę pod adresem http://<ZEWNĘTRZNY-IP>:80.

Logowanie

Użyj domyślnych danych logowania:

• Nazwa użytkownika: admin
• Hasło: Hasło, które ustawiłeś podczas instalacji (np. admin lub prom-operator).

Po zalogowaniu przejdź do Configuration > Data Sources, aby upewnić się, że źródło danych Prometheus istnieje i działa. Kliknij na nie i użyj przycisku Test, aby sprawdzić połączenie.

Tworzenie dashboardów: od gotowych do niestandardowych

Po podłączeniu Grafany do Prometheusa możesz zacząć wizualizować metryki Kubernetes. Najszybszym sposobem na uzyskanie wartościowych informacji jest zaimportowanie gotowych dashboardów ze społeczności Grafany.

Importowanie gotowych dashboardów

Grafana oferuje obszerną bibliotekę dashboardów społecznościowych, które można zaimportować za pomocą ich unikalnych identyfikatorów.

1. Najedź kursorem na ikonę + na panelu bocznym i wybierz Import.
2. Wprowadź identyfikator dashboardu w polu "Find and import dashboards". Dwa najbardziej zalecane dashboardy:
   • 1860: Node Exporter Full — dostarcza szczegółowych metryk o węzłach Twojego klastra, w tym CPU, pamięci, dysku i sieci.
   • 8588: Kubernetes Deployment Statefulset Daemonset — oferuje przegląd Twoich obciążeń Kubernetes.
3. Kliknij Load, następnie wybierz swoje źródło danych Prometheus i kliknij Import.

Te dashboardy dadzą Ci natychmiastowy, wszechstronny przegląd stanu klastra bez konieczności pisania zapytań PromQL.

Tworzenie niestandardowych dashboardów za pomocą PromQL

Chociaż gotowe dashboardy są świetnym punktem wyjścia, często konieczne jest tworzenie niestandardowych widoków dostosowanych do konkretnych aplikacji. Tutaj z pomocą przychodzi PromQL.

Aby utworzyć nowy dashboard, kliknij ikonę + i wybierz New Dashboard. Następnie kliknij Add visualization i wybierz swoje źródło danych Prometheus.

Oto kilka podstawowych zapytań PromQL do monitorowania Kubernetes:

• Użycie CPU na pod:

  sum(rate(container_cpu_usage_seconds_total{namespace!="kube-system", pod!=""}[5m])) by (pod)

• Użycie pamięci na pod:

  sum(container_memory_working_set_bytes{namespace!="kube-system", pod!=""}) by (pod) / 1024 / 1024 / 1024

• Status podów według fazy:

  sum(kube_pod_status_phase) by (phase)

  To zapytanie jest idealne do panelu Stat, pozwalając na pierwszy rzut oka zobaczyć, czy wszystkie pody działają.

Konfiguracja alertów i powiadomień

Monitorowanie to tylko połowa sukcesu; musisz także otrzymywać powiadomienia, gdy coś pójdzie nie tak. To zadanie Alertmanagera, który jest częścią kube-prometheus-stack.

Konfiguracja reguł alertów

Możesz skonfigurować Alertmanager do wysyłania powiadomień do różnych kanałów, takich jak Slack, e-mail lub PagerDuty. Powszechną i skuteczną konfiguracją jest wysyłanie alertów do dedykowanego kanału Slack.

1. Najpierw utwórz webhook przychodzący w swoim workspace Slack.
2. Następnie zmodyfikuj konfigurację Alertmanagera. Można to zrobić, dostarczając niestandardowy plik values.yaml podczas aktualizacji Helm lub edytując sekret bezpośrednio.
3. Zaktualizuj sekcję alertmanager w swoim pliku values.yaml, podając trasę i odbiorcę odnoszącego się do URL Twojego webhooka Slack:

alertmanager:
  config:
    route:
      receiver: 'slack-notifications'
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 1h
    receivers:
      - name: 'slack-notifications'
        slack_configs:
          - api_url: 'https://hooks.slack.com/services/your/webhook/url'
            send_resolved: true
            title: '{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})'
            text: >-
              {{ range .Alerts }}
              *Alert:* {{ .Labels.alertname }}
              *Poważność:* {{ if .Labels.severity }}{{ .Labels.severity }}{{ else }}b/d{{ end }}
              *Krótki opis:* {{ if .Annotations.summary }}{{ .Annotations.summary }}{{ else }}b/d{{ end }}
              *Opis:* {{ if .Annotations.description }}{{ .Annotations.description }}{{ else }}b/d{{ end }}
              {{- end }}

Po zastosowaniu tych zmian za pomocą helm upgrade alerty będą wysyłane do Twojego kanału Slack.

Najlepsze praktyki dla monitorowania produkcyjnego

Aby Twój stos monitorowania był niezawodny i skalowalny w środowisku produkcyjnym, postępuj zgodnie z tymi kluczowymi zaleceniami.

• Skonfiguruj trwałe przechowywanie: Podczas wdrażania w środowisku produkcyjnym zawsze włączaj trwałe przechowywanie zarówno dla Prometheusa, jak i Grafany. Gwarantuje to, że Twoje metryki i konfiguracje dashboardów przetrwają restart podów i aktualizacje klastra. W kube-prometheus-stack jest to kontrolowane przez ustawienia persistence i storageSpec w chartcie Helm.
• Optymalizuj wydajność zapytań: Zapytania o wysokiej kardynalności mogą spowolnić Twoje dashboardy i samego Prometheusa. Aby utrzymać wydajność, zawsze agreguj zapytania PromQL u źródła. Na przykład zamiast zapytania container_cpu_usage_seconds_total agreguj je według przestrzeni nazw: sum by (namespace) (rate(container_cpu_usage_seconds_total[5m])). Zmniejsza to ilość danych, które Grafana musi przetworzyć.
• Ustaw odpowiednie okresy przechowywania: Domyślny okres przechowywania dla Prometheusa wynosi 15 dni. Dostosuj go do swoich potrzeb. Dłuższy okres przechowywania (np. 30–60 dni) jest przydatny do długoterminowej analizy trendów, ale będzie wymagał więcej miejsca na dane.
• Zarządzaj konfiguracją jako kodem: W miarę ewolucji Twoich potrzeb w zakresie monitorowania prawdopodobnie będziesz konfigurować dashboardy i reguły alertów. Eksportuj swoje dashboardy w formacie JSON i przechowuj je w systemie kontroli wersji (np. Git) wraz z regułami alertów. Ta praktyka, znana jako GitOps, sprawia, że Twoja konfiguracja monitorowania jest powtarzalna i weryfikowalna.
• Skonfiguruj interwały zbierania: Domyślny interwał zbierania dla Prometheusa wynosi 30 sekund. W przypadku krytycznych metryk o wysokiej szybkości zmian możesz chcieć zbierać dane częściej, ale pamiętaj, że zwiększa to obciążenie Prometheusa i serwera API Twojego klastra. Możesz skonfigurować te interwały w wartościach Helm.

Często zadawane pytania

1. Jaki jest najprostszy sposób monitorowania Kubernetes za pomocą Grafany i Prometheusa? Najprostszą i zalecaną metodą jest użycie Helm chart kube-prometheus-stack. Łączy on Prometheusa, Gfanę, Alertmanager, node-exporter i kube-state-metrics w jeden pakiet, który można wdrożyć za pomocą zaledwie kilku poleceń.

2. Czy używanie kube-state-metrics jest obowiązkowe do monitorowania Kubernetes? Tak, kube-state-metrics to krytyczny komponent, który generuje metryki o stanie obiektów Kubernetes, takich jak liczba gotowych podów lub status wdrożenia. Bez niego nie miałbyś wglądu w stan swoich zasobów Kubernetes wyższego poziomu.

3. Jak przyspieszyć ładowanie moich dashboardów Kubernetes? Wolne dashboardy są często spowodowane nieefektywnymi zapytaniami PromQL. Kluczowym rozwiązaniem jest agregowanie zapytań w celu zmniejszenia kardynalności. Na przykład zamiast wyświetlania danych dla każdego poda, sumuj je na poziomie przestrzeni nazw za pomocą zapytań typu sum by (namespace) (rate(...)).

4. Jaki jest najlepszy sposób otrzymywania alertów z mojego monitorowania Kubernetes? Prometheus współpracuje z Alertmanagerem, który może wysyłać powiadomienia do różnych kanałów. Popularną i prostą metodą jest skonfigurowanie Alertmanagera do wysyłania alertów do kanału Slack za pomocą webhooka przychodzącego. Zapewnia to alerty w czasie rzeczywistym z możliwością natychmiastowej reakcji.

5. Czy muszę ręcznie instalować Node Exporter na każdym węźle? Nie. Podczas wdrażania Helm chart kube-prometheus-stack automatycznie wdraża DaemonSet Node Exporter. Gwarantuje to, że pod Node Exporter uruchamia się na każdym węźle Twojego klastra, umożliwiając Prometheusowi zbieranie metryk na poziomie węzłów, takich jak użycie CPU, pamięci i dysku, bez żadnej ręcznej interwencji.

Źródła

1. UpCloud Global. (2025). Monitoring on UpCloud with Prometheus: Part 3.
2. Ubuntu Documentation. (2026). How to use Prometheus with Canonical Kubernetes.
3. Sfeir Institute. (2026). Create Effective Grafana Dashboards for Kubernetes Monitoring.
4. Ory. (2025). Monitoring.
5. GitHub - AkramGalal. (2025). deploying-prometheus-grafana-K8s-using-helm.
6. Go Packages. (2025). kube-prometheus.
7. GitHub - dotdc. (2026). grafana-dashboards-kubernetes.
8. Scaleway. (2025). Kubernetes Kapsule cluster monitoring with Prometheus & Grafana.
9. Mirantis. (2025). How to Set Up Prometheus & Grafana in K8s with Alertmanager & Slack Alerts.
10. Microsoft Learn. (2025). Using ConfigMap to customize Prometheus metric collection in Azure Monitor.
11. GitHub - Rurutia1027. (2025). Hands-on-Lab.K8s-Monitoring.

— Editorial Team