Metrikinsamling: En omfattande guide med Prometheus och Grafana

I dagens komplexa IT-landskap är effektiv övervakning avgörande för att upprätthålla hälsan och prestandan hos applikationer och infrastruktur. Metrikinsamling ger grunden för denna övervakning, vilket gör att du kan spåra viktiga prestandaindikatorer (KPI:er), identifiera potentiella problem och optimera resursutnyttjandet. Den här omfattande guiden kommer att utforska hur du kan utnyttja Prometheus och Grafana, två kraftfulla open source-verktyg, för robust metrikinsamling och visualisering.

Vad är metrikinsamling?

Metrikinsamling innebär att man samlar in numeriska data som representerar tillståndet och beteendet hos olika system, applikationer och infrastrukturkomponenter över tid. Dessa värden kan inkludera CPU-användning, minnesförbrukning, nätverkstrafik, svarstider, felprocent och många andra relevanta indikatorer. Genom att analysera dessa värden kan du få värdefulla insikter i prestandan och hälsan i din miljö.

Varför är metrikinsamling viktigt?

• Proaktiv problemdetektering: Identifiera potentiella problem innan de påverkar användarna.
• Prestandaoptimering: Identifiera flaskhalsar och förbättringsområden.
• Kapacitetsplanering: Förutse framtida resursbehov baserat på historiska trender.
• Övervakning av servicenivåavtal (SLA): Säkerställ efterlevnad av prestandamål.
• Felsökning och rotorsaksanalys: Diagnostisera och lös problem snabbt.

Introduktion till Prometheus och Grafana

Prometheus är en open source-verktygslåda för systemövervakning och larm som ursprungligen utvecklades på SoundCloud. Den utmärker sig i att samla in och lagra tidsseriedata, vilket är data som indexeras av tidsstämplar. Prometheus använder en pull-baserad modell för att skrapa mätvärden från mål (t.ex. servrar, applikationer) med jämna mellanrum. Den erbjuder ett kraftfullt frågespråk (PromQL) för att analysera de insamlade data och definiera larmregler.

Grafana är en open source-plattform för datavisualisering och övervakning. Den låter dig skapa interaktiva instrumentpaneler och grafer för att visualisera data från olika källor, inklusive Prometheus. Grafana erbjuder en rik uppsättning visualiseringsalternativ, inklusive grafer, diagram, tabeller och mätare. Den stöder också larm, vilket gör att du kan få meddelanden när vissa tröskelvärden överskrids.

Tillsammans bildar Prometheus och Grafana en kraftfull och flexibel övervakningslösning som kan anpassas till ett brett spektrum av miljöer och användningsfall. De används flitigt inom DevOps- och SRE-metoder (Site Reliability Engineering) över hela världen.

Prometheus arkitektur och koncept

Att förstå kärnkomponenterna i Prometheus är avgörande för effektiv implementering och användning:

• Prometheus Server: Kärnkomponenten som ansvarar för att skrapa, lagra och fråga mätvärden.
• Tjänsteupptäckt: Upptäcker automatiskt mål att övervaka baserat på konfiguration eller integrationer med plattformar som Kubernetes.
• Exporters: Agenter som exponerar mätvärden i ett format som Prometheus kan förstå. Exempel inkluderar node_exporter (för systemmätvärden) och olika applikationsspecifika exporters.
• Pushgateway (valfritt): Tillåter kortlivade jobb att skicka mätvärden till Prometheus. Detta är användbart för batchjobb som kanske inte körs kontinuerligt.
• Alertmanager: Hanterar larm som genereras av Prometheus baserat på konfigurerade regler. Den kan dirigera larm till olika aviseringskanaler, som e-post, Slack eller PagerDuty.
• PromQL: Prometheus Query Language som används för att fråga och analysera de insamlade mätvärdena.

Prometheus arbetsflöde

1. Mål (applikationer, servrar, etc.) exponerar mätvärden. Dessa mätvärden exponeras vanligtvis via en HTTP-slutpunkt.
2. Prometheus Server skrapar mätvärden från konfigurerade mål. Den hämtar regelbundet mätvärden från dessa slutpunkter.
3. Prometheus lagrar de skrapade mätvärdena i sin tidsseriedatabas.
4. Användare frågar mätvärdena med PromQL. Detta gör att de kan analysera data och skapa grafer och instrumentpaneler.
5. Larmregler utvärderas baserat på de lagrade mätvärdena. Om ett regelvillkor uppfylls utlöses ett larm.
6. Alertmanager hanterar de utlösta larmen. Den tar bort dubbletter, grupperar och dirigerar dem till lämpliga aviseringskanaler.

Grafana arkitektur och koncept

Grafana kompletterar Prometheus genom att tillhandahålla ett användarvänligt gränssnitt för att visualisera och analysera de insamlade mätvärdena:

• Datakällor: Anslutningar till olika datakällor, inklusive Prometheus, Graphite, InfluxDB och andra.
• Instrumentpaneler: Samlingar av paneler som visar data i olika format (grafer, diagram, tabeller etc.).
• Paneler: Individuella visualiseringar som visar data från en specifik datakälla med hjälp av en specifik fråga.
• Larm: Grafana har också inbyggda larmfunktioner som låter dig definiera larm baserat på data som visas i dina instrumentpaneler. Dessa larm kan använda Prometheus som datakälla och utnyttja PromQL för komplex larmfunktionalitet.
• Organisationer och team: Grafana stöder organisationer och team, vilket gör att du kan hantera åtkomst och behörigheter till instrumentpaneler och datakällor.

Grafana arbetsflöde

1. Konfigurera datakällor: Anslut Grafana till din Prometheus-server.
2. Skapa instrumentpaneler: Designa instrumentpaneler för att visualisera dina mätvärden.
3. Lägg till paneler i instrumentpaneler: Lägg till paneler för att visa specifika datapunkter från Prometheus med hjälp av PromQL-frågor.
4. Konfigurera larm (valfritt): Konfigurera larmregler i Grafana för att få meddelanden baserat på specifika tröskelvärden för mätvärden.
5. Dela instrumentpaneler: Dela instrumentpaneler med ditt team för att samarbeta om övervakning och analys.

Installera Prometheus och Grafana

Det här avsnittet ger en steg-för-steg-guide om hur du installerar Prometheus och Grafana.

Installera Prometheus

1. Ladda ner Prometheus:

Ladda ner den senaste versionen av Prometheus från den officiella webbplatsen: https://prometheus.io/download/. Välj lämpligt paket för ditt operativsystem (t.ex. Linux, Windows, macOS).

2. Extrahera arkivet:

Extrahera det nedladdade arkivet till en katalog efter eget val.

3. Konfigurera Prometheus:

Skapa en `prometheus.yml`-konfigurationsfil. Den här filen definierar de mål som Prometheus kommer att skrapa och andra konfigurationsalternativ. En grundläggande konfiguration kan se ut så här:

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

Den här konfigurationen definierar två skrapningsjobb: ett för Prometheus själv (skrapar sina egna mätvärden) och ett för en node_exporter som körs på localhost-port 9100. `scrape_interval` anger hur ofta Prometheus kommer att skrapa målen.

4. Starta Prometheus:

Kör den körbara filen Prometheus från katalogen där du extraherade arkivet:

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

              
                Copy
              
            
          

Prometheus startar och lyssnar på port 9090 som standard. Du kan komma åt Prometheus webbgränssnitt i din webbläsare på http://localhost:9090.

Installera Grafana

1. Ladda ner Grafana:

Ladda ner den senaste versionen av Grafana från den officiella webbplatsen: https://grafana.com/grafana/download. Välj lämpligt paket för ditt operativsystem.

2. Installera Grafana:

Följ installationsanvisningarna för ditt operativsystem. Till exempel på 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

            

              
                Copy
              
            
          

3. Starta Grafana:

Starta Grafana-tjänsten:

            sudo systemctl start grafana-server
            

              
                Copy
              
            
          

4. Åtkomst till Grafana:

Grafana startar och lyssnar på port 3000 som standard. Du kan komma åt Grafana webbgränssnitt i din webbläsare på http://localhost:3000.

Standardanvändarnamnet och lösenordet är `admin` och `admin`. Du kommer att uppmanas att ändra lösenordet vid första inloggningen.

Ansluta Grafana till Prometheus

För att visualisera mätvärden från Prometheus i Grafana måste du konfigurera Prometheus som en datakälla i Grafana.

1. Lägg till datakälla:

I Grafana webbgränssnitt, navigera till Konfiguration > Datakällor och klicka på Lägg till datakälla.

2. Välj Prometheus:

Välj Prometheus som datakälltyp.

3. Konfigurera Prometheus-anslutning:

Ange URL:en till din Prometheus-server (t.ex. `http://localhost:9090`). Konfigurera andra alternativ efter behov (t.ex. autentisering).

4. Spara och testa:

Klicka på Spara och testa för att verifiera att Grafana kan ansluta till Prometheus.

Skapa instrumentpaneler i Grafana

När du har anslutit Grafana till Prometheus kan du skapa instrumentpaneler för att visualisera dina mätvärden.

1. Skapa en ny instrumentpanel:

I Grafana webbgränssnitt, klicka på +-ikonen i sidofältet och välj Instrumentpanel.

2. Lägg till en panel:

Klicka på Lägg till en tom panel för att lägga till en ny panel i instrumentpanelen.

3. Konfigurera panelen:

• Välj datakälla: Välj den Prometheus-datakälla du konfigurerade tidigare.
• Ange PromQL-fråga: Ange en PromQL-fråga för att hämta det mätvärde du vill visualisera. För att till exempel visa CPU-användning kan du använda följande fråga:

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

            

              
                Copy
              
            
          

Den här frågan beräknar förändringstakten för CPU-tid som används av processer som samlats in av node_exporter under ett 5-minutersintervall.

• Konfigurera visualiseringsalternativ: Välj visualiseringstyp (t.ex. graf, mätare, tabell) och konfigurera andra alternativ efter behov (t.ex. axelrubriker, färger).

4. Spara instrumentpanelen:

Klicka på spara-ikonen för att spara instrumentpanelen.

PromQL: Prometheus frågespråk

PromQL är ett kraftfullt frågespråk som används för att hämta och manipulera mätvärden som lagras i Prometheus. Det låter dig utföra ett brett spektrum av operationer, inklusive:

• Filtrering: Välj mätvärden baserat på etiketter.
• Aggregering: Beräkna aggregerade värden (t.ex. summa, medelvärde, maximum) över tidsintervall eller över flera instanser.
• Beräkning av takt: Beräkna förändringstakten för räknarmätvärden.
• Aritmetiska operationer: Utför aritmetiska operationer på mätvärden (t.ex. addition, subtraktion, multiplikation).
• Tidsseriefunktioner: Använd funktioner på tidsseriedata (t.ex. rörligt medelvärde, utjämning).

PromQL-exempel

• CPU-användning:

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

            

              
                Copy
              
            
          

• Minnesanvändning:

            
node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes

            

              
                Copy
              
            
          

• Diskutrymmesanvändning:

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

            

              
                Copy
              
            
          

• HTTP-begärantetakt:

            
rate(http_requests_total[5m])

            

              
                Copy
              
            
          

Att lära sig PromQL är viktigt för att effektivt använda Prometheus och Grafana. Se Prometheus dokumentation för en omfattande guide till språket.

Larm med Prometheus och Alertmanager

Prometheus tillhandahåller ett robust larmsystem som låter dig definiera regler baserat på mätvärden. När ett regelvillkor uppfylls utlöses ett larm och Alertmanager hanterar aviseringsprocessen.

Definiera larmregler

Larmregler definieras i konfigurationsfilen `prometheus.yml`. Här är ett exempel på en larmregel som utlöses när CPU-användningen överstiger 80 %:

            
rule_files:
  - "rules.yml"

            

              
                Copy
              
            
          

Placera sedan regler som dessa i en fil med namnet `rules.yml`:

            
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: "Hög CPU-användning upptäckt"
      description: "CPU-användningen är över 80 % på {{ $labels.instance }}"

            

              
                Copy
              
            
          

Förklaring:

• alert: Namnet på larmet.
• expr: PromQL-uttrycket som definierar larmvillkoret.
• for: Den tid som villkoret måste vara sant innan larmet utlöses.
• labels: Etiketter som är kopplade till larmet.
• annotations: Anteckningar som ger ytterligare information om larmet, som en sammanfattning och beskrivning.

Konfigurera Alertmanager

Alertmanager hanterar dirigeringen och aviseringen av larm. Du måste konfigurera Alertmanager för att ange var larm ska skickas (t.ex. e-post, Slack, PagerDuty). Se Alertmanagers dokumentation för detaljerade konfigurationsanvisningar.

En minimal `alertmanager.yml`-konfiguration kan se ut så här:

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

            

              
                Copy
              
            
          

Den här konfigurationen skickar larm till en webhook på localhost-port 8080. Du kan anpassa avsnittet `receivers` för att använda tjänster som Slack eller e-post istället.

Praktiska exempel och användningsfall

Prometheus och Grafana kan användas för att övervaka ett brett spektrum av applikationer och infrastrukturkomponenter. Här är några praktiska exempel:

• Webbserverövervakning: Övervaka HTTP-begärantetakter, svarstider och felprocent för att säkerställa optimal webbserverprestanda.
• Databasövervakning: Spåra databasanslutningspoolanvändning, frågekörningstider och långsamma frågor för att identifiera databasflaskhalsar.
• Kubernetes-övervakning: Övervaka hälsan och prestandan hos Kubernetes-kluster, inklusive resursutnyttjande av poddar och noder.
• Applikationsövervakning: Samla in anpassade mätvärden från dina applikationer för att spåra specifika affärs-KPI:er och identifiera problem på applikationsnivå.
• Nätverksövervakning: Spåra nätverkstrafik, latens och paketförlust för att identifiera nätverksflaskhalsar och prestandaproblem.
• Övervakning av molninfrastruktur: Övervaka prestandan och tillgängligheten för molnresurser, som virtuella maskiner, lagring och databaser. Detta är särskilt relevant för AWS-, Azure- och Google Cloud-miljöer, som alla har integrationer med Prometheus och Grafana.

Exempel: Övervakning av en mikrotjänstarkitektur

I en mikrotjänstarkitektur kan Prometheus och Grafana användas för att övervaka hälsan och prestandan hos enskilda tjänster, såväl som det övergripande systemet. Varje tjänst kan exponera sina egna mätvärden, som begärantetakter, svarstider och felprocent. Prometheus kan sedan skrapa dessa mätvärden och Grafana kan användas för att visualisera dem. Detta gör att du snabbt kan identifiera prestandaflaskhalsar eller fel i specifika tjänster.

Avancerade tekniker och bästa metoder

För att få ut det mesta av Prometheus och Grafana, överväg följande avancerade tekniker och bästa metoder:

• Använd meningsfulla etiketter: Använd etiketter för att lägga till kontext till dina mätvärden. Detta gör det lättare att filtrera och aggregera data. Använd till exempel etiketter för att identifiera den tjänst, miljö och instans som ett mätvärde är associerat med.
• Övervaka viktiga prestandaindikatorer (KPI:er): Fokusera på att övervaka de mätvärden som är mest kritiska för din verksamhet. Detta gör att du snabbt kan identifiera och åtgärda problem som har störst inverkan.
• Ange lämpliga larmtrösklar: Ange larmtrösklar som är lämpliga för din miljö. Undvik att ange trösklar som är för känsliga, eftersom detta kan leda till larmtrötthet.
• Använd instrumentpaneler effektivt: Designa instrumentpaneler som är lätta att förstå och ger användbara insikter. Använd tydliga och koncisa etiketter och visualiseringar.
• Automatisera distribution och konfiguration: Automatisera distribution och konfiguration av Prometheus och Grafana med hjälp av verktyg som Ansible, Terraform eller Kubernetes.
• Säkra dina Prometheus- och Grafana-instanser: Säkra dina Prometheus- och Grafana-instanser för att förhindra obehörig åtkomst. Använd autentisering och auktorisering för att kontrollera åtkomsten till känslig data.
• Överväg horisontell skalning: För stora miljöer, överväg att skala dina Prometheus- och Grafana-instanser horisontellt för att hantera den ökade belastningen. Detta kan uppnås genom att använda flera Prometheus-servrar och Grafana-instanser bakom en lastbalanserare.
• Utnyttja tjänsteupptäckt: Använd Prometheus tjänsteupptäcktsfunktioner för att automatiskt upptäcka och övervaka nya mål. Detta är särskilt användbart i dynamiska miljöer som Kubernetes.

Felsökning av vanliga problem

Även med noggrann planering och implementering kan du stöta på problem när du använder Prometheus och Grafana. Här är några vanliga problem och deras lösningar:

• Prometheus skrapar inte mätvärden: Verifiera att målet är tillgängligt från Prometheus-servern. Kontrollera Prometheus-loggarna för fel. Se till att målet exponerar mätvärden i rätt format.
• Grafana ansluter inte till Prometheus: Verifiera att Prometheus-URL:en är korrekt i Grafana-datakällans konfiguration. Kontrollera Grafana-loggarna för fel. Se till att Prometheus-servern körs och är tillgänglig från Grafana-servern.
• PromQL-frågor returnerar inte data: Verifiera att PromQL-frågan är korrekt. Kontrollera Prometheus-loggarna för fel. Se till att det mätvärde du frågar efter finns och skrapas av Prometheus.
• Larm utlöses inte: Verifiera att larmregeln är korrekt definierad. Kontrollera Prometheus-loggarna för fel. Se till att Alertmanager körs och är korrekt konfigurerad.
• Prestandaproblem: Om du upplever prestandaproblem, överväg att skala dina Prometheus- och Grafana-instanser horisontellt. Optimera dina PromQL-frågor för att minska belastningen på Prometheus-servern.

Alternativa övervakningslösningar

Även om Prometheus och Grafana är kraftfulla verktyg är de inte de enda alternativen för metrikinsamling och visualisering. Andra populära övervakningslösningar inkluderar:

• Datadog: En kommersiell övervakningsplattform som erbjuder ett brett utbud av funktioner, inklusive metrikinsamling, logghantering och övervakning av applikationsprestanda (APM).
• New Relic: En annan kommersiell övervakningsplattform som ger omfattande övervakningsmöjligheter för applikationer och infrastruktur.
• InfluxDB och Chronograf: En tidsseriedatabas och visualiseringsplattform som ofta används som ett alternativ till Prometheus och Grafana.
• Elasticsearch, Logstash och Kibana (ELK Stack): En populär open source-stack för logghantering och analys. Även om den främst används för loggar kan den också användas för metrikinsamling och visualisering.
• Dynatrace: En AI-driven övervakningsplattform som ger end-to-end-synlighet i applikations- och infrastrukturprestanda.

Den bästa övervakningslösningen för din organisation beror på dina specifika krav och din budget.

Slutsats

Metrikinsamling är avgörande för att upprätthålla hälsan och prestandan hos applikationer och infrastruktur. Prometheus och Grafana tillhandahåller en kraftfull och flexibel open source-lösning för att samla in, lagra och visualisera mätvärden. Genom att förstå kärnkoncepten och följa de bästa metoderna som beskrivs i den här guiden kan du utnyttja Prometheus och Grafana för att bygga ett robust övervakningssystem som uppfyller din organisations behov.

Effektiv övervakning, tillsammans med proaktiv larmhantering och snabb incidenthantering, är en hörnsten i modern IT-drift. Att använda verktyg som Prometheus och Grafana ger organisationer möjlighet att leverera tillförlitliga och välpresterande tjänster till sina användare, oavsett deras plats eller bransch.