A GitLab felügyelete és monitorozása Prometheus és Grafana segítségével

A modern szoftverfejlesztés gerince a hatékony verziókövetés, CI/CD pipeline-ok és a kollaboráció. Ebben a kontextusban a GitLab kiemelkedik mint egy minden-az-egyben platform, amely a teljes DevOps életciklust lefedi. De mi történik akkor, ha a fejlesztői folyamatok motorja elkezd akadozni? Egy lassú build, egy elakadó deployment vagy egy elérhetetlen Git-tárhely azonnal megbéníthatja a csapatot és komoly bevételkiesést okozhat. Éppen ezért elengedhetetlen a GitLab infrastruktúra folyamatos és proaktív felügyelete és monitorozása. Ebben a cikkben bemutatjuk, hogyan alkothat tökéletes párost a Prometheus és a Grafana a GitLab robusztus és megbízható működésének biztosításához.

Miért kritikus a GitLab monitorozása?

A GitLab nem csupán egy Git-tárhely; egy összetett rendszer, amely számos komponenst foglal magában, mint például webkiszolgálók (Unicorn/Puma), háttérfeladatok (Sidekiq), Git műveletek (Gitaly), adatbázis (PostgreSQL), gyorsítótár (Redis) és természetesen a CI/CD futtatók. Bármelyik komponens meghibásodása vagy túlterhelése láncreakciót indíthat el, ami a szolgáltatás teljes leállásához vezethet. A hatékony monitorozás lehetővé teszi, hogy:

Proaktívan felismerjük a problémákat: Mielőtt egy hiba szolgáltatáskiesést okozna, a riasztások jeleznek a potenciális veszélyekre (pl. telítődő lemez, túlterhelt CPU, hosszú Sidekiq üzenetsor).
Optimalizáljuk a performanciát: A metrikák alapján azonosíthatjuk a szűk keresztmetszeteket, és finomhangolhatjuk az erőforrás-allokációt vagy a konfigurációt.
Biztosítsuk a megbízhatóságot és rendelkezésre állást: Folyamatos betekintést nyerünk a rendszer állapotába, így garantálhatjuk a fejlesztők és felhasználók számára a zavartalan működést.
Tervezzük a kapacitást: Az idősoros adatok segítségével előre jelezhetjük a jövőbeli erőforrásigényeket, elkerülve a váratlan meglepetéseket.
Gyorsítsuk a hibakeresést (troubleshooting): Amikor probléma adódik, a részletes metrikák azonnal a hiba forrásához vezethetnek, drasztikusan csökkentve az MTTR-t (Mean Time To Recovery).

A Hatékonyság Párosa: Prometheus és Grafana

Amikor a modern infrastruktúra monitorozásról van szó, a Prometheus és a Grafana szinte elválaszthatatlan párosként merül fel. Lássuk, miért:

Prometheus: A metrikák motorja

A Prometheus egy nyílt forráskódú rendszerfelügyeleti és riasztási eszköztár. Főbb jellemzői:

Pull-alapú gyűjtés: A Prometheus időnként lekérdezi a konfigurált célpontokról (ún. exporterekről) a metrikákat HTTP-n keresztül. Ez a modell jól skálázható és rugalmas.
Idősoros adatbázis (TSDB): A gyűjtött adatokat egy rendkívül hatékony, helyi idősoros adatbázisban tárolja. Ez optimalizált a nagy mennyiségű idősoros adat tárolására és lekérdezésére.
PromQL: A Prometheus saját lekérdezőnyelve, a PromQL, rendkívül erőteljes és rugalmas. Lehetővé teszi komplex aggregációk, szűrések és matematikai műveletek végrehajtását a metrikákon.
Szolgáltatás-felfedezés: Képes automatikusan felfedezni az új monitorozandó célpontokat a különböző felhő- vagy konténer-orkesztrációs rendszerekben.
Riasztáskezelés (Alertmanager): A Prometheus riasztásokat generálhat a metrikák alapján, és az Alertmanager kezeli ezeket, szűri, csoportosítja és megfelelő értesítési csatornára továbbítja (pl. email, Slack, PagerDuty).

A GitLab szerencsére „Prometheus-kompatibilis”. Ez azt jelenti, hogy a GitLab maga is egy exporterként működik, és a legtöbb belső komponensének (Sidekiq, Gitaly, Puma, Redis, PostgreSQL, Node Exporter metrikák) metrikáit közvetlenül elérhetővé teszi egy dedikált HTTP végponton.

Grafana: A vizualizáció mestere

Míg a Prometheus a metrikák gyűjtéséért és tárolásáért felel, a Grafana a vizualizációért és a felhasználóbarát felület biztosításáért. Főbb jellemzői:

Adatforrás agnosztikus: Támogatja a Prometheust, de számos más adatforrást is képes kezelni (pl. InfluxDB, PostgreSQL, Elasticsearch, Zabbix, stb.).
Rugalmas dashboardok: Lenyűgöző és interaktív dashboardokat hozhatunk létre, amelyek különböző diagramtípusokat, táblázatokat és vizualizációkat tartalmazhatnak. A dashboardok könnyedén testreszabhatók és megoszthatók.
Riasztáskezelés: Bár a Prometheus kezeli a riasztások magját, a Grafana is képes riasztásokat generálni a dashboardokon megjelenített adatok alapján, és azokat különböző csatornákon keresztül továbbítani.
Sablonok és változók: Lehetővé teszi dinamikus dashboardok létrehozását, ahol a felhasználók választhatnak különböző szolgáltatások, szerverek vagy időszakok közül.

A Grafana segítségével a komplex Prometheus metrikákat érthető és áttekinthető formában jeleníthetjük meg, ami elengedhetetlen a gyors döntéshozatalhoz és a problémák azonosításához.

GitLab konfiguráció Prometheus monitorozáshoz

A GitLab beépített támogatással rendelkezik a Prometheus-alapú monitorozáshoz. Az EE (Enterprise Edition) verzióban ez alapértelmezett, de az CE (Community Edition) esetén is könnyen konfigurálható.

Prometheus metrikák engedélyezése a GitLabben:
A GitLab admin felületén a /admin/application_settings/metrics_and_profiling útvonalon engedélyezhetjük a Prometheus metrikákat. Itt láthatjuk azt a végpontot (általában /metrics), ahol a GitLab a saját belső metrikáit és a beépített exporterek (Node Exporter, Redis, PostgreSQL, Sidekiq, Gitaly stb.) metrikáit kiteszi. Fontos, hogy ez a végpont védett legyen (pl. tűzfallal vagy reverse proxy-val), mivel bizalmas információkat is tartalmazhat.
Prometheus szerver konfigurálása:
A Prometheus konfigurációs fájljában (általában prometheus.yml) fel kell vennünk a GitLab instance-t mint scrape_config célt.


scrape_configs:
  - job_name: 'gitlab'
    scrape_interval: 15s
    static_configs:
      - targets: ['GITLAB_SZERVER_IP_VAGY_HOSTNEV:9090'] # Az a port, ahol a GitLab kiteszi a metrikákat (alapértelmezettként ez általában a GitLab web interface portja, pl. 80/443, és a /metrics útvonalon érhetők el)
        metrics_path: '/-/metrics' # A GitLab dedikált metrika végpontja

Fontos, hogy a targets mezőbe a GitLab szerver IP címét vagy hosztnevét, valamint azt a portot írjuk, amelyen a GitLab eléri a webes felületét, mivel a /-/metrics végpont azon keresztül érhető el. A Prometheus ekkor elkezdi gyűjteni a metrikákat a megadott GitLab instance-ről.

Fontos GitLab metrikák

A GitLab számos metrikát szolgáltat, amelyek kulcsfontosságúak a teljesítmény és az egészségi állapot nyomon követéséhez. Néhány kategória és példa:

Rendszerszintű metrikák (Node Exporter):
- node_cpu_seconds_total: CPU kihasználtság
- node_memory_MemAvailable_bytes: Rendelkezésre álló memória
- node_disk_io_time_seconds_total: Lemez I/O aktivitás
- node_network_receive_bytes_total, node_network_transmit_bytes_total: Hálózati forgalom
GitLab alkalmazás metrikák (Puma/Unicorn):
- gitlab_puma_workers_total, gitlab_puma_workers_running: Puma worker processek száma és állapota
- gitlab_http_requests_total: HTTP kérések száma
- gitlab_http_request_duration_seconds_bucket: HTTP kérések válaszideje (histogram)
- gitlab_http_requests_total{status="5xx"}: Szerver oldali hibák száma
Háttérfeladatok (Sidekiq):
- gitlab_sidekiq_jobs_total: Feldolgozott Sidekiq jobok teljes száma
- gitlab_sidekiq_jobs_failed_total: Elbukott Sidekiq jobok száma
- gitlab_sidekiq_queue_size: Üzenetsor mérete (backlog)
- gitlab_sidekiq_queue_duration_seconds_sum: Jobok várakozási ideje az üzenetsorban
Git műveletek (Gitaly):
- gitlab_gitaly_requests_total: Gitaly RPC kérések száma
- gitlab_gitaly_requests_duration_seconds_bucket: Gitaly RPC kérések válaszideje
- gitlab_gitaly_errors_total: Gitaly hibák száma
Adatbázis (PostgreSQL):
- postgresql_connections: Aktív adatbázis kapcsolatok száma
- postgresql_up: Adatbázis elérhetősége
- postgresql_query_duration_seconds_bucket: Lekérdezések időtartama
CI/CD pipeline metrikák:
- gitlab_ci_pipelines_total: Futó pipeline-ok száma
- gitlab_ci_job_duration_seconds_bucket: CI jobok futási ideje
- gitlab_ci_runners_active_total: Aktív CI runner-ek száma

Grafana dashboardok a GitLabhez

Miután a Prometheus gyűjti az adatokat, a Grafana a következő lépés a vizualizációhoz:

Prometheus adatforrás hozzáadása:
A Grafana felületén egyszerűen hozzáadhatjuk a Prometheus szerverünket mint adatforrást, megadva annak URL-jét (pl. http://localhost:9090, ha a Prometheus a Grafana-val azonos szerveren fut).

Dashboardok importálása vagy létrehozása:

Importálás: A Grafana Labs hivatalos honlapján számos előre elkészített GitLab dashboard található (keressünk rá „GitLab overview”, „GitLab Sidekiq” stb. kulcsszavakra). Ezeket egyszerűen importálhatjuk a Grafana-ba a dashboard ID-jának megadásával. Ezek a dashboardok kiváló kiindulópontot jelentenek.

Egyedi dashboardok létrehozása: Saját dashboardokat is építhetünk a specifikus igényeink szerint. Néhány példa PromQL lekérdezés, amit használni lehet:


# CPU kihasználtság (százalékban)
100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# Memória kihasználtság (GB-ban)
(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / (1024 * 1024 * 1024)

# HTTP 5xx hibák aránya az összes kéréshez képest
sum(rate(gitlab_http_requests_total{status=~"5xx"}[5m])) / sum(rate(gitlab_http_requests_total[5m])) * 100

# Sidekiq üzenetsor mérete
sum(gitlab_sidekiq_queue_size) by (queue)

# Gitaly RPC hívások átlagos válaszideje
rate(gitlab_gitaly_requests_duration_seconds_sum[5m]) / rate(gitlab_gitaly_requests_duration_seconds_count[5m])

A Grafana vizuálisan gazdag környezetet biztosít, ahol a fenti metrikák időbeli alakulását grafikonokon, számlálókon vagy táblázatokon keresztül követhetjük nyomon. Ez lehetővé teszi a trendek, anomáliák és hirtelen változások gyors felismerését.

Riasztások konfigurálása Prometheus és Grafana segítségével

A monitorozás igazi ereje abban rejlik, hogy képes jelezni, ha beavatkozásra van szükség. A Prometheus és a Grafana ebben is hatékonyan kiegészítik egymást:

Prometheus riasztási szabályok (Alerting Rules):
A Prometheus konfigurációs fájljában (vagy külön fájlokban) definiálhatunk riasztási szabályokat PromQL lekérdezések segítségével. Például:


# alerts.yml
groups:
  - name: gitlab-alerts
    rules:
      - alert: HighCPULoad
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Magas CPU terhelés a GitLab szerveren ({{ $labels.instance }})"
          description: "A CPU terhelés {{ $value | humanize }}% fölé emelkedett 5 percen keresztül."

      - alert: GitLabSidekiqQueueTooLarge
        expr: sum(gitlab_sidekiq_queue_size) by (queue) > 1000
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Túl nagy Sidekiq üzenetsor ({{ $labels.queue }})"
          description: "A Sidekiq üzenetsor mérete meghaladja az 1000-et 5 percen keresztül."

Ezek a szabályok az Alertmanager felé továbbítják a riasztásokat, ha a feltételek teljesülnek. Az Alertmanager felel a riasztások deduplikálásáért, csoportosításáért és a megfelelő értesítési csatornákra (pl. email, Slack, PagerDuty, Webhook) történő küldéséért.

Grafana riasztások:
A Grafana is képes riasztásokat generálni közvetlenül a dashboardok paneljeiről. Ez különösen hasznos, ha a vizualizált adatokon alapuló riasztásokat szeretnénk létrehozni, és a riasztási feltételeket a Grafana felhasználói felületén szeretnénk kezelni. A Grafana riasztások számos értesítési csatornát támogatnak, hasonlóan az Alertmanagerhez.

A leggyakoribb riasztások közé tartoznak a magas CPU vagy memória kihasználtság, a lemezterület kifogyása, a Sidekiq üzenetsorok túl nagy mérete, a HTTP 5xx hibák jelentős növekedése, a Gitaly hibák, vagy a CI/CD jobok túl hosszú futási ideje.

Fejlett monitorozási technikák és best practice-ek

Elosztott GitLab setupok monitorozása: Ha több GitLab szerverrel rendelkezünk (pl. sharding, clustering), érdemes lehet egy központi Prometheus szervert használni, vagy több Prometheus instance-t és egy központi Thanos rendszert a hosszú távú tároláshoz és a globális lekérdezéshez.
Egyedi metrikák: Ha a GitLab-en futtatunk olyan saját alkalmazásokat vagy scripteket, amelyeknek metrikáit is gyűjteni szeretnénk, létrehozhatunk saját Prometheus exportereket, vagy használhatunk push gateway-t a rövid életű jobok metrikáinak gyűjtésére.
Log monitorozás kiegészítésként: Bár a Prometheus és Grafana a metrikákra fókuszál, a hibakereséshez gyakran szükség van a logokra is. Fontolja meg egy logaggregációs rendszer (pl. ELK Stack, Loki) bevezetését is, hogy a metrikákkal együtt a logokat is elemezni tudja.
Automatizálás: A Prometheus és Grafana telepítését és konfigurálását automatizálja IaC (Infrastructure as Code) eszközökkel (pl. Ansible, Terraform), hogy a folyamat megismételhető és hibamentes legyen.
Rendszeres felülvizsgálat: Ne feledje, hogy a monitorozás nem egyszeri feladat. Rendszeresen tekintse át a dashboardokat és a riasztási szabályokat, finomhangolja azokat az aktuális igények és a rendszer viselkedése alapján.

Összegzés

A GitLab infrastruktúra megfelelő felügyelete és monitorozása elengedhetetlen a modern DevOps kultúrában. A Prometheus és a Grafana együttesen egy rendkívül erőteljes és rugalmas megoldást kínálnak a GitLab minden aspektusának nyomon követésére. A metrikák gyűjtésétől a vizualizáción át a proaktív riasztásokig, ez a páros biztosítja, hogy a fejlesztési folyamatok motorja zökkenőmentesen és hatékonyan működjön. Befektetve a megfelelő monitorozási stratégiába, garantálhatja a GitLab rendszere stabilitását, optimalizálhatja a teljesítményt, és biztosíthatja a folyamatos, zavartalan munkavégzést csapata számára. Ne várja meg, amíg a problémák felmerülnek – legyen egy lépéssel előrébb a proaktív monitorozással!