Prometheus Kurulumu ve Temel Yapılandırma

Bykomut

Sunucu izleme konusunda bir noktaya gelirsiniz: logları tek tek incelemek, top komutu açık tutmak ve “bir şeyler ters gidiyor” hissini yaşamak artık yetmez hale gelir. İşte tam o noktada Prometheus devreye giriyor. Açık kaynaklı bu monitoring sistemi, özellikle mikroservis mimarileri ve containerized ortamlar için neredeyse endüstri standardı haline geldi. Bu yazıda Prometheus’u sıfırdan kurarak gerçek dünya senaryolarına göre yapılandıracağız.

Prometheus Nedir ve Neden Kullanmalısınız

Prometheus, SoundCloud tarafından 2012’de geliştirilen ve 2016’da CNCF (Cloud Native Computing Foundation) bünyesine giren bir monitoring ve alerting sistemidir. Temel felsefesi şu: metrikler sisteminizden çekilir (pull model), zaman serisi olarak depolanır ve PromQL adı verilen güçlü bir sorgu diliyle analiz edilir.

Pull model yaklaşımı sayesinde hangi sistemin izleneceği merkezi olarak yönetilir. Push modeline göre daha güvenli ve kontrol edilebilir bir mimari sunar. Bir servis çöktüğünde “metrik gelmiyor” durumu bile bir uyarı tetikleyebilir.

Prometheus’un öne çıkan özellikleri:

  • Çok boyutlu veri modeli: Her metrik, key-value çiftleri şeklinde etiketlerle zenginleştirilir
  • PromQL: Güçlü ve esnek bir sorgu dili
  • Servis keşfi: Kubernetes, Consul, DNS gibi sistemlerle entegrasyon
  • Alertmanager: Gelişmiş uyarı yönetimi ve yönlendirme
  • Uzun vadeli depolama: Thanos veya Cortex gibi çözümlerle ölçeklendirilebilir

Kurulum Öncesi Hazırlık

Kuruluma geçmeden önce ortamımızı hazırlayalım. Bu yazıda Ubuntu 22.04 LTS üzerinde çalışacağız ama adımların büyük çoğunluğu diğer dağıtımlarda da aynı.

Öncelikle sistemi güncelleyelim ve gerekli bağımlılıkları yükleyelim:

sudo apt update && sudo apt upgrade -y
sudo apt install -y wget curl tar htop

Prometheus’u sistem kullanıcısı olarak çalıştırmak güvenlik açısından kritik. prometheus adında bir kullanıcı ve grup oluşturuyoruz:

sudo groupadd --system prometheus
sudo useradd --system --no-create-home --shell /bin/false 
  --gid prometheus prometheus

--no-create-home ve --shell /bin/false parametrelerine dikkat edin. Bu kullanıcının sisteme login yapamamasını garantiliyoruz. Üretim ortamında minimum yetki prensibi (principle of least privilege) ihmal edilmemeli.

Prometheus’un ihtiyaç duyacağı dizinleri oluşturalım:

sudo mkdir -p /etc/prometheus
sudo mkdir -p /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Prometheus Binary Kurulumu

Prometheus’u paket yöneticisi yerine doğrudan binary olarak kurmayı tercih ediyorum. Böylece versiyon kontrolü tamamen bizde olur. Güncel versiyonu Prometheus GitHub sayfasından kontrol edin; bu yazı yazılırken 2.48.x stabil sürümdü.

cd /tmp
PROMETHEUS_VERSION="2.48.1"
wget https://github.com/prometheus/prometheus/releases/download/v${PROMETHEUS_VERSION}/prometheus-${PROMETHEUS_VERSION}.linux-amd64.tar.gz

tar -xzf prometheus-${PROMETHEUS_VERSION}.linux-amd64.tar.gz
cd prometheus-${PROMETHEUS_VERSION}.linux-amd64

İndirdiğimiz paketin içeriğini yerleştiriyoruz:

sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles/ console_libraries/ /etc/prometheus/
sudo cp prometheus.yml /etc/prometheus/prometheus.yml

sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool
sudo chown -R prometheus:prometheus /etc/prometheus/consoles
sudo chown -R prometheus:prometheus /etc/prometheus/console_libraries

Kurulumu doğrulayalım:

prometheus --version
promtool --version

promtool özellikle değerli bir araç. Yapılandırma dosyalarını ve alerting kurallarını production’a almadan önce doğrulamak için kullanacağız.

Temel Yapılandırma Dosyası

Prometheus’un kalbi olan prometheus.yml dosyasını düzenleyelim. Varsayılan dosya iyi bir başlangıç noktası ama gerçek dünya için biraz daha detaylı bir yapılandırma gerekiyor:

sudo nano /etc/prometheus/prometheus.yml

Aşağıdaki yapılandırmayı kullanabilirsiniz:

global:
  scrape_interval: 15s
  evaluation_interval: 15s
  scrape_timeout: 10s
  external_labels:
    monitor: 'production-cluster'
    environment: 'prod'

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # Alertmanager kurulduğunda buraya eklenecek
          # - alertmanager:9093

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

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
    metrics_path: '/metrics'
    scheme: 'http'

  - job_name: 'node-exporter'
    static_configs:
      - targets:
          - 'localhost:9100'
          - '192.168.1.10:9100'
          - '192.168.1.11:9100'
    relabel_configs:
      - source_labels: [__address__]
        regex: '([^:]+):.*'
        target_label: instance
        replacement: '${1}'

Bu yapılandırmadaki önemli parametreler:

  • scrape_interval: Her hedeften kaç saniyede bir metrik çekileceği. 15 saniye çoğu senaryo için idealdir. Çok düşük değer hem Prometheus’u hem hedef sistemi yorar.
  • evaluation_interval: Alerting kurallarının kaç saniyede bir değerlendirileceği.
  • scrape_timeout: Bir hedeften metrik çekilirken ne kadar bekleneceği. Bu değer scrape_interval’dan küçük olmalı.
  • external_labels: Tüm metriklere otomatik eklenen etiketler. Birden fazla Prometheus instance’ı varsa kritik önem taşır.

Yapılandırmayı doğrulayalım:

promtool check config /etc/prometheus/prometheus.yml

Hatasız çıktı şöyle görünmeli: SUCCESS: /etc/prometheus/prometheus.yml is valid prometheus config file syntax

Systemd Servis Dosyası Oluşturma

Prometheus’u sistem servisi olarak çalıştırmak için bir systemd unit file oluşturuyoruz:

sudo nano /etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus Monitoring System
Documentation=https://prometheus.io/docs/introduction/overview/
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/ 
    --storage.tsdb.retention.time=30d 
    --storage.tsdb.retention.size=10GB 
    --web.console.libraries=/etc/prometheus/console_libraries 
    --web.console.templates=/etc/prometheus/consoles 
    --web.listen-address=0.0.0.0:9090 
    --web.enable-lifecycle 
    --log.level=info

Restart=on-failure
RestartSec=5s
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

Servis parametrelerinin açıklamaları:

  • –storage.tsdb.retention.time=30d: Verileri 30 gün sakla. Disk durumunuza göre ayarlayın.
  • –storage.tsdb.retention.size=10GB: Maksimum 10GB disk kullan. İki kural birlikte çalışır, hangisi önce tetiklenirse eskiler silinir.
  • –web.enable-lifecycle: HTTP üzerinden reload ve shutdown imkanı sağlar. curl -X POST http://localhost:9090/-/reload ile yapılandırmayı servis yeniden başlatmadan yükleyebilirsiniz.
  • LimitNOFILE=65536: Açık dosya limiti. Yoğun ortamlarda önemli.

Servisi aktif edelim:

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

Tarayıcınızdan http://sunucu-ip:9090 adresine gidin. Prometheus web arayüzünü görmelisiniz. Expression browser’da up yazarak aktif hedefleri kontrol edebilirsiniz.

Node Exporter Kurulumu

Prometheus tek başına sadece kendi metriklerini toplar. Sunucu kaynaklarını (CPU, RAM, disk, network) izlemek için Node Exporter şart. Üretim ortamında izlemek istediğiniz her sunucuya Node Exporter kurmalısınız.

cd /tmp
NODE_EXPORTER_VERSION="1.7.0"
wget https://github.com/prometheus/node_exporter/releases/download/v${NODE_EXPORTER_VERSION}/node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64.tar.gz

tar -xzf node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64.tar.gz
sudo cp node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64/node_exporter /usr/local/bin/

sudo useradd --system --no-create-home --shell /bin/false node_exporter

Node Exporter için systemd servisi:

sudo nano /etc/systemd/system/node_exporter.service
[Unit]
Description=Node Exporter
Documentation=https://prometheus.io/docs/guides/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 
    --collector.filesystem.mount-points-exclude='^/(sys|proc|dev|host|etc)($$|/)' 
    --collector.systemd 
    --web.listen-address=:9100

Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter

Node Exporter çalıştıktan sonra http://sunucu-ip:9100/metrics adresine gidin. Yüzlerce metrik göreceksiniz. Bu sayfalarda gezinmek başlangıçta ezici gelebilir ama zamanla hangi metriklerin ne anlama geldiğini öğreniyorsunuz.

Güvenlik Yapılandırması

Prometheus ve Node Exporter varsayılan olarak herhangi bir kimlik doğrulaması yapmaz. Üretim ortamında bu kabul edilemez. En azından şu önlemleri alın.

Güvenlik duvarı yapılandırması. Prometheus portunuzu (9090) ve Node Exporter portunuzu (9100) sadece yetkili IP adreslerine açın:

sudo ufw allow from 192.168.1.0/24 to any port 9090
sudo ufw allow from 192.168.1.0/24 to any port 9100
sudo ufw deny 9090
sudo ufw deny 9100

Nginx reverse proxy ile TLS. Prometheus arayüzüne HTTPS üzerinden erişmek için Nginx kullanabilirsiniz:

sudo apt install -y nginx apache2-utils
sudo htpasswd -c /etc/nginx/.htpasswd prometheus_admin
server {
    listen 443 ssl;
    server_name prometheus.sirketiniz.com;

    ssl_certificate /etc/letsencrypt/live/prometheus.sirketiniz.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/prometheus.sirketiniz.com/privkey.pem;

    location / {
        auth_basic "Prometheus";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://localhost:9090;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Alerting Kuralları Oluşturma

Metrik toplamak güzel ama asıl değer, sorunları erkenden fark etmektir. Temel alerting kuralları için bir dosya oluşturalım:

sudo mkdir -p /etc/prometheus/rules
sudo nano /etc/prometheus/rules/node_alerts.yml
groups:
  - name: node_alerts
    interval: 30s
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Yüksek CPU kullanımı: {{ $labels.instance }}"
          description: "{{ $labels.instance }} üzerinde CPU kullanımı son 5 dakikadır %{{ $value | humanize }} seviyesinde."

      - alert: CriticalCPUUsage
        expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 95
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Kritik CPU kullanımı: {{ $labels.instance }}"
          description: "ACIL: {{ $labels.instance }} üzerinde CPU kullanımı %{{ $value | humanize }}."

      - alert: LowDiskSpace
        expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 15
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Düşük disk alanı: {{ $labels.instance }}"
          description: "{{ $labels.instance }} kök dosya sisteminde sadece %{{ $value | humanize }} boş alan kaldı."

      - alert: HighMemoryUsage
        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Yüksek bellek kullanımı: {{ $labels.instance }}"
          description: "{{ $labels.instance }} üzerinde bellek kullanımı %{{ $value | humanize }}."

      - alert: NodeDown
        expr: up{job="node-exporter"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Sunucu erişilemiyor: {{ $labels.instance }}"
          description: "{{ $labels.instance }} 1 dakikadır erişilemiyor. Acil müdahale gerekebilir."

Kuralları doğrulayın ve Prometheus’u yeniden yükleyin:

promtool check rules /etc/prometheus/rules/node_alerts.yml
curl -X POST http://localhost:9090/-/reload

PromQL ile Temel Sorgular

Prometheus web arayüzünde Expression browser üzerinden bazı temel sorgular çalıştıralım. Bu sorgular Grafana dashboard’ları oluştururken de kullanacaksınız.

# CPU kullanım yüzdesi (tüm instance'lar)
100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# Kullanılabilir bellek GB cinsinden
node_memory_MemAvailable_bytes / 1024 / 1024 / 1024

# Disk kullanım yüzdesi
100 - ((node_filesystem_avail_bytes{mountpoint="/"} * 100) / node_filesystem_size_bytes{mountpoint="/"})

# Network trafiği (bytes/saniye, son 5 dakika ortalaması)
irate(node_network_receive_bytes_total{device!="lo"}[5m])

# 1 dakikadaki load average
node_load1

# Uptime
(node_boot_time_seconds - time()) * -1

Bu sorgular gerçek dünyada ne işe yarar? Bir müşteri “site yavaşladı” dediğinde ilk 30 saniye içinde CPU, bellek, disk ve network metriklerini yan yana görüp bottleneck’i tespit edebilirsiniz. Bunu loglarla yapmaya kalkarsanız saatler geçer.

Çoklu Sunucu Ortamı için Yapılandırma

Gerçek dünyada tek sunucu izlemiyorsunuz. 20-30 sunucudan oluşan bir ortamda static config yerine file-based service discovery kullanmak daha yönetilebilir:

sudo nano /etc/prometheus/targets/nodes.json
[
  {
    "targets": ["web01.sirket.local:9100", "web02.sirket.local:9100"],
    "labels": {
      "group": "web",
      "environment": "production"
    }
  },
  {
    "targets": ["db01.sirket.local:9100", "db02.sirket.local:9100"],
    "labels": {
      "group": "database",
      "environment": "production"
    }
  },
  {
    "targets": ["staging01.sirket.local:9100"],
    "labels": {
      "group": "web",
      "environment": "staging"
    }
  }
]

prometheus.yml içinde bu dosyayı kullanalım:

scrape_configs:
  - job_name: 'node-exporter'
    file_sd_configs:
      - files:
          - '/etc/prometheus/targets/*.json'
        refresh_interval: 30s

Bu yaklaşımın güzelliği şu: yeni sunucu eklediğinizde sadece JSON dosyasını güncelliyorsunuz. Prometheus servisini yeniden başlatmaya gerek yok, 30 saniye içinde yeni hedefi otomatik keşfediyor.

Performans ve Depolama Optimizasyonu

Yoğun ortamlarda Prometheus’un kaynak tüketimi ciddi boyutlara ulaşabilir. Birkaç pratik öneri:

Bellek kullanımı. Prometheus varsayılan olarak mevcut RAM’in yaklaşık %25’ini kullanır. Bunu kontrol etmek için:

# Mevcut chunk'ları ve bellek kullanımını izleyin
curl -s http://localhost:9090/api/v1/query?query=process_resident_memory_bytes | python3 -m json.tool

TSDB (Time Series Database) optimizasyonu. Çok fazla unique label kombinasyonu “high cardinality” sorununa yol açar. Örneğin her HTTP isteği için benzersiz user_id etiketi eklemek, Prometheus’u öldürür. Etiket tasarımına dikkat edin.

WAL (Write-Ahead Log) boyutunu izleyin:

du -sh /var/lib/prometheus/wal/
du -sh /var/lib/prometheus/

Disk kullanımı beklenenden hızlı büyüyorsa scrape_interval’ı artırmayı veya gereksiz metrikleri filtrelemeyi düşünün.

Sorun Giderme

Kurulum sonrasında sık karşılaşılan sorunlar ve çözümleri:

Hedef “DOWN” görünüyor. İlk kontrol noktanız Prometheus web arayüzündeki Status > Targets sayfası. Hata mesajını okuyun. Genellikle:

  • Bağlantı reddedildi: Node Exporter çalışmıyor veya firewall bloklıyor
  • Bağlantı zaman aşımı: Ağ sorunu veya scrape_timeout çok düşük
  • Kimlik doğrulama hatası: TLS veya basic auth yapılandırma yanlışlığı

Prometheus çok fazla bellek tüketiyor. Aktif zaman serisi sayısını kontrol edin:

curl -s 'http://localhost:9090/api/v1/query?query=prometheus_tsdb_head_series' | grep -o '"value":[.*]'

1 milyonun üzerinde aktif seri varsa cardinality sorununu araştırın.

Yapılandırma reload çalışmıyor. --web.enable-lifecycle flag’inin eklendiğinden emin olun:

curl -v -X POST http://localhost:9090/-/reload

Sonuç

Prometheus kurulumu ilk bakışta karmaşık görünse de aslında oldukça sistematik bir süreç. Binary kurulum, sistem kullanıcısı, systemd servisi ve temel yapılandırma adımlarını tamamladıktan sonra ortamınızı izlemeye hazır bir sisteme sahipsiniz.

Bu yazıda ele aldığımız konular, Prometheus’un %80’lik kullanım senaryosunu kapsıyor. Node Exporter metrikleri, temel alerting kuralları ve file-based service discovery ile küçük-orta ölçekli ortamları rahatça yönetebilirsiniz.

Sonraki adım olarak Alertmanager kurarak uyarıları e-posta, Slack veya PagerDuty’ye yönlendirmeyi ve Grafana ile görsel dashboard’lar oluşturmayı inceleyeceğiz. Prometheus’u Grafana ile birleştirdiğinizde, o “bir şeyler ters gidiyor” hissi yerini “tam olarak ne olduğunu biliyorum” güvenine bırakıyor.

Sorularınızı ve karşılaştığınız sorunları yorumlarda paylaşabilirsiniz. Özellikle yüksek cardinality sorunları ve Kubernetes entegrasyonu konularında okuyucu talepleri olursa ayrı yazılar hazırlayabiliriz.

Benzer Konular

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir