DOKS Kümesi için Prometheus İzleme Yığını Kurulum Rehberi

DOKS Kümesi için Prometheus İzleme Yığını Kurulum Rehberi

Prometheus, modern bulut tabanlı sistemlerin izlenmesi için fiili standart haline gelmiş, açık kaynaklı bir izleme ve uyarılandırma aracıdır. Özellikle Kubernetes ortamlarında, dinamik ve dağıtık yapıların karmaşıklığını yönetmek için vazgeçilmez bir çözüm sunar. Bu kapsamlı rehberde, DigitalOcean Kubernetes (DOKS) kümeniz üzerinde Prometheus izleme yığınını nasıl kuracağınızı, yapılandıracağınızı ve yöneteceğinizi adım adım inceleyeceğiz. Amacımız, kümenizin performansını, sağlığını ve kaynak kullanımını detaylı bir şekilde gözlemleyebileceğiniz sağlam bir izleme altyapısı oluşturmaktır.

Giriş ve Genel Bakış

Bulut yerlisi uygulamaların yaygınlaşmasıyla birlikte, sistemlerin izlenmesi ve yönetimi her zamankinden daha kritik hale gelmiştir. Mikroservis mimarileri ve kapsayıcı teknolojileri, geleneksel izleme yaklaşımlarını yetersiz bırakırken, Prometheus gibi araçlar bu yeni nesil altyapıların ihtiyaçlarını karşılamak üzere tasarlanmıştır.

Prometheus Nedir ve Neden Kullanılır?

Prometheus, SoundCloud tarafından geliştirilen ve daha sonra Cloud Native Computing Foundation (CNCF) bünyesine katılan, metrik tabanlı bir izleme sistemidir. Temel özellikleri şunlardır:

* Çok Boyutlu Veri Modeli: Metrikler, anahtar-değer çiftleri (etiketler) ile tanımlanır, bu da güçlü sorgulama ve filtreleme yetenekleri sağlar.
* Esnek Sorgulama Dili (PromQL): Prometheus’un kendi sorgulama dili olan PromQL ile karmaşık analizler yapabilir, metrikleri birleştirebilir ve işleyebiliriz.
* Çekme Modeli (Pull Model): Prometheus sunucusu, hedeflenen uç noktalardan (exporter’lar) metrikleri belirli aralıklarla çeker. Bu, dinamik ortamlarda hedef keşfini kolaylaştırır.
* Güçlü Uyarılandırma: Alertmanager bileşeni sayesinde, belirlenen kurallar doğrultusunda uyarılar tetiklenebilir ve çeşitli bildirim kanallarına gönderilebilir.
* Grafana Entegrasyonu: Grafana ile mükemmel entegrasyonu sayesinde, toplanan metrikler görsel olarak zengin ve etkileşimli panolar (dashboard) aracılığıyla sunulur.

Prometheus, özellikle Kubernetes gibi dinamik ve ölçeklenebilir ortamlarda, pod’ların, servislerin, düğümlerin ve uygulamaların durumunu gerçek zamanlı olarak izlemek için idealdir.

DOKS ve Prometheus Entegrasyonu

DigitalOcean Kubernetes (DOKS), DigitalOcean’ın yönetilen Kubernetes hizmetidir. DOKS, geliştiricilerin Kubernetes kümelerini hızlı ve kolay bir şekilde kurmalarına, yönetmelerine ve ölçeklendirmelerine olanak tanır. DOKS kümesi, DigitalOcean’ın yüksek performanslı sanal makineleri (Droplets), blok depolama (Block Storage) ve yük dengeleyicileri (Load Balancers) gibi temel altyapı bileşenleri üzerine inşa edilmiştir.

DOKS kümesi üzerinde Prometheus izleme yığını kurmak, kümenizin sağlığını ve performansını sürekli olarak gözlemlemenizi sağlar. Bu, potansiyel sorunları proaktif olarak tespit etmenize, kaynak kullanımını optimize etmenize ve uygulama kararlılığını artırmanıza yardımcı olur. DOKS’un sağladığı yönetilen hizmetler (örneğin, Block Storage ile Persistent Volumes) Prometheus’un depolama ihtiyaçlarını karşılamayı kolaylaştırır.

İzleme Yığını Bileşenleri

Prometheus izleme yığını, sadece Prometheus sunucusundan ibaret değildir. Genellikle aşağıdaki bileşenleri içerir:

* Prometheus Server: Metrikleri toplar, depolar ve sorgular.
* Alertmanager: Prometheus tarafından tetiklenen uyarıları yönetir, gruplandırır ve bildirim kanallarına yönlendirir.
* Grafana: Prometheus’tan alınan metrikleri görselleştirmek için kullanılan açık kaynaklı bir analiz ve izleme platformudur.
* Exporters: Prometheus’un metrikleri çekebilmesi için hedeflenen sistemlerden metrikleri Prometheus formatında sunan aracılardır. Önemli exporter’lar şunlardır:
* Node Exporter: Sunucu seviyesi CPU, bellek, disk, ağ gibi metrikleri sağlar.
* Kube-state-metrics: Kubernetes API’sinden pod, dağıtım (deployment), servis, düğüm gibi Kubernetes nesnelerinin durum metriklerini sunar.
* cAdvisor (Container Advisor): Kubelet içinde yer alan bu araç, kapsayıcıların kaynak kullanım metriklerini (CPU, bellek, ağ, dosya sistemi) toplar. Prometheus, Kubelet’in /metrics uç noktasından bu verilere erişir.
* Pushgateway (İsteğe Bağlı): Kısa ömürlü işler veya toplu işler gibi doğrudan Prometheus tarafından çekilemeyen metrikleri toplamak için kullanılır.

Bu bileşenlerin bir araya gelmesiyle, DOKS kümenizin her seviyesinde kapsamlı bir izleme yeteneği elde edersiniz.

Ön Koşullar ve Hazırlıklar

Prometheus izleme yığınını DOKS kümenize kurmadan önce bazı temel araçların ve yapılandırmaların hazır olması gerekmektedir.

DOKS Kümesi Hazırlığı

Öncelikle çalışan bir DigitalOcean Kubernetes kümesine ihtiyacınız var. Eğer henüz bir DOKS kümeniz yoksa, DigitalOcean kontrol panelinden veya doctl CLI aracıyla kolayca bir küme oluşturabilirsiniz. Bu rehber, mevcut bir DOKS kümeniz olduğunu varsaymaktadır.

kubectl Kurulumu ve Yapılandırması

kubectl, Kubernetes kümeleriyle etkileşim kurmak için kullanılan komut satırı aracıdır. DOKS kümenize bağlanmak için kubectl‘in sisteminizde kurulu ve kümenizin yapılandırma dosyasına (kubeconfig) işaret ediyor olması gerekir.

Kurulum talimatları için Kubernetes dokümantasyonuna bakabilirsiniz. DOKS kümenizin kubeconfig dosyasını DigitalOcean kontrol panelinden indirip $HOME/.kube/config dizinine yerleştirmeniz veya mevcut yapılandırmanıza eklemeniz yeterlidir.

Bağlantıyı test etmek için:

kubectl get nodes

Bu komut, kümenizdeki düğümleri listelemelidir.

Helm Kurulumu

Helm, Kubernetes uygulamalarını yönetmek için kullanılan bir paket yöneticisidir. Prometheus izleme yığını gibi karmaşık uygulamaları tek bir komutla dağıtmak ve yönetmek için Helm chart’larını kullanacağız.

Helm’i sisteminize kurmak için:

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

Kurulumu doğrulamak için:

helm version

Gerekli İzinler (RBAC)

Prometheus ve diğer izleme bileşenlerinin Kubernetes API’sine erişerek metrikleri toplayabilmesi için uygun Role-Based Access Control (RBAC) izinlerine ihtiyacı vardır. Helm chart’ları genellikle bu izinleri otomatik olarak oluşturur, ancak özel durumlarda veya manuel kurulumlarda bu izinlerin doğru yapılandırıldığından emin olmak önemlidir. Varsayılan olarak, Prometheus Helm chart’ı gerekli ServiceAccount, ClusterRole ve ClusterRoleBinding nesnelerini oluşturacaktır.

İzleme için Bir Namespace Oluşturma

İzleme yığını bileşenlerini diğer uygulamalarınızdan ayrı tutmak ve yönetimi kolaylaştırmak için ayrı bir Kubernetes namespace’i oluşturmak iyi bir uygulamadır.

kubectl create namespace monitoring

Bu namespace’i, tüm Prometheus bileşenlerini kurarken kullanacağız.

Prometheus İzleme Yığını Kurulumu (Helm ile)

Prometheus izleme yığınını DOKS kümenize kurmanın en kolay ve önerilen yolu, Prometheus Community Helm Charts’ı kullanmaktır. Bu chart, Prometheus, Alertmanager, Grafana ve ilgili exporter’ları tek bir pakette sunar.

Helm Repository Ekleme

Öncelikle Prometheus Community Helm repository’sini Helm’inize eklemelisiniz:

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

Değerler Dosyasının (values.yaml) Özelleştirilmesi

Helm chart’ları, values.yaml dosyası aracılığıyla özelleştirilebilir. Prometheus izleme yığını chart’ı oldukça kapsamlı olduğu için, kendi values.yaml dosyanızı oluşturarak varsayılan ayarları geçersiz kılmanız gerekecektir. Bu, kurulumunuzu DOKS ortamınıza ve özel ihtiyaçlarınıza göre uyarlamanızı sağlar.

Örnek bir values.yaml dosyası oluşturalım. Bu dosya, DOKS için önemli olabilecek bazı yapılandırmaları içerecektir:

# values.yaml
Genel Ayarlar
global:
  rbac:
    create: true # RBAC kaynaklarını oluştur
  storageClass: do-block-storage # DigitalOcean Block Storage sınıfını kullan

Prometheus Server Ayarları
prometheus:
  prometheusSpec:
    # Prometheus sunucusu için depolama
    storageSpec:
      volumeClaimTemplate:
        spec:
          storageClassName: do-block-storage # DOKS için varsayılan Block Storage sınıfı
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 20Gi # Prometheus metrikleri için 20GB depolama
    retention: 15d # Metrikleri 15 gün sakla
    # scrapeInterval: 30s # Metrik çekme aralığı (varsayılan 15s)
    # resource limits/requests
    resources:
      requests:
        cpu: 200m
        memory: 512Mi
      limits:
        cpu: 1
        memory: 1Gi

  # Kube-state-metrics entegrasyonu
  kubeStateMetrics:
    enabled: true
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 200m
        memory: 256Mi

  # Node Exporter entegrasyonu
  nodeExporter:
    enabled: true
    hostRootFs: true # Host dosya sistemini izle
    resources:
      requests:
        cpu: 50m
        memory: 64Mi
      limits:
        cpu: 100m
        memory: 128Mi

Alertmanager Ayarları
alertmanager:
  enabled: true
  alertmanagerSpec:
    storage:
      volumeClaimTemplate:
        spec:
          storageClassName: do-block-storage
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 2Gi # Alertmanager için 2GB depolama
    # Alertmanager yapılandırması (örnek Slack entegrasyonu)
    config:
      global:
        resolve_timeout: 5m
      route:
        group_by: ['alertname', 'cluster', 'service']
        group_wait: 30s
        group_interval: 5m
        repeat_interval: 1h
        receiver: 'slack-notifications'
      receivers:
      - name: 'slack-notifications'
        slack_configs:
        - channel: '#alerts' # Slack kanalınız
          api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX' # Slack Webhook URL'niz
          send_resolved: true
          text: '{{ template "slack.default.text" . }}'

  # Alertmanager için Ingress (isteğe bağlı)
  ingress:
    enabled: true
    ingressClassName: nginx # Nginx Ingress Controller kullanıyorsanız
    annotations:
      kubernetes.io/ingress.class: nginx
      kubernetes.io/tls-acme: "true" # Cert-manager kullanıyorsanız
    hosts:
      - alertmanager.yourdomain.com # Kendi alan adınızı kullanın
    paths:
      - /
    pathType: Prefix
    tls:
      - secretName: alertmanager-tls # Cert-manager tarafından oluşturulan secret
        hosts:
          - alertmanager.yourdomain.com

Grafana Ayarları
grafana:
  enabled: true
  adminPassword: your-secure-password # Güvenli bir parola belirleyin
  # Varsayılan veri kaynağı olarak Prometheus'u ekle
  defaultDashboardsEnabled: true
  defaultDatasources:
    datasources.yaml:
      apiVersion: 1
      datasources:
        - name: Prometheus
          type: prometheus
          url: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090 # Prometheus servisine işaret et
          access: proxy
          isDefault: true
          version: 1
          editable: false

  # Grafana için Ingress
  ingress:
    enabled: true
    ingressClassName: nginx
    annotations:
      kubernetes.io/ingress.class: nginx
      kubernetes.io/tls-acme: "true"
    hosts:
      - grafana.yourdomain.com
    paths:
      - /
    pathType: Prefix
    tls:
      - secretName: grafana-tls
        hosts:
          - grafana.yourdomain.com
  
  # Grafana kaynak limitleri
  resources:
    requests:
      cpu: 100m
      memory: 256Mi
    limits:
      cpu: 200m
      memory: 512Mi

Pushgateway (isteğe bağlı)
kube-prometheus-stack: # Bu, ana chart adı, alt bileşenleri bu şekilde yapılandırabilirsiniz
  prometheus-pushgateway:
    enabled: false # Genellikle varsayılan olarak devre dışıdır, ihtiyacınız yoksa açmayın

values.yaml dosyasındaki önemli noktalar:

* global.storageClass: do-block-storage: DigitalOcean’ın yönetilen blok depolama hizmetini kullanmak için varsayılan depolama sınıfını belirtir. Bu, Prometheus ve Alertmanager’ın kalıcı depolama (Persistent Volume Claims) kullanmasını sağlar. DOKS kümenizde bu depolama sınıfının mevcut olduğundan emin olun.
* prometheus.prometheusSpec.storageSpec: Prometheus sunucusunun metrikleri depolayacağı Persistent Volume Claim (PVC) ayarları. storage: 20Gi ile depolama boyutunu belirleyebilirsiniz.
* alertmanager.alertmanagerSpec.storage: Alertmanager’ın durumunu depolayacağı PVC ayarları.
* alertmanager.config: Alertmanager’ın uyarıları nasıl yöneteceğini ve hangi kanallara göndereceğini tanımlar. Örnek olarak Slack entegrasyonu gösterilmiştir. api_url kısmını kendi Slack Webhook URL’nizle değiştirmeyi unutmayın.
* grafana.adminPassword: Grafana’ya ilk giriş için yönetici parolasını ayarlayın. Güvenli bir parola kullanın ve bunu asla açık metin olarak kaynak kontrol sistemine commit etmeyin. Gerçek uygulamalarda Kubernetes Secret’ları veya dış bir vault çözümü kullanmanız önerilir.
* grafana.ingress ve alertmanager.ingress: Prometheus ve Alertmanager’a dışarıdan erişim sağlamak için Ingress kaynaklarını yapılandırır. Bu, bir Ingress Controller’ınızın (örneğin Nginx Ingress Controller) kurulu olduğunu varsayar. hosts ve secretName kısımlarını kendi alan adlarınıza ve TLS secret’larınıza göre güncelleyin.
* defaultDashboardsEnabled ve defaultDatasources: Grafana’nın varsayılan panoları ve Prometheus veri kaynağını otomatik olarak eklemesini sağlar.

Bu values.yaml dosyasını my-prometheus-values.yaml gibi bir isimle kaydedin.

Kurulum Komutu

values.yaml dosyanızı hazırladıktan sonra, Helm ile Prometheus izleme yığınını kurabilirsiniz:

helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  -f my-prometheus-values.yaml \
  --version 58.4.0 # Mevcut en son stabil sürümü kullanın

* kube-prometheus-stack: Helm release’ine verdiğimiz isim.
* prometheus-community/kube-prometheus-stack: Kullanılacak Helm chart’ının adı.
* --namespace monitoring: Bileşenlerin monitoring namespace’ine kurulmasını sağlar.
* -f my-prometheus-values.yaml: Özelleştirdiğimiz values.yaml dosyasını kullanır.
* --version: Chart’ın belirli bir sürümünü belirtmek iyi bir uygulamadır.

Kurulumun Doğrulanması

Kurulum tamamlandıktan sonra, tüm pod’ların ve servislerin doğru bir şekilde çalıştığını kontrol edin:

kubectl get pods -n monitoring
kubectl get svc -n monitoring
kubectl get pvc -n monitoring

Tüm pod’ların Running durumunda olması ve PVC’lerin Bound olarak görünmesi gerekmektedir.

Prometheus ve Alertmanager Erişimi

İzleme yığını kurulduktan sonra, Prometheus, Alertmanager ve Grafana web arayüzlerine erişmemiz gerekir.

Port-forwarding ile Geçici Erişim

Geliştirme veya sorun giderme amaçlı geçici erişim için kubectl port-forward kullanabilirsiniz:

* Prometheus:

kubectl port-forward -n monitoring svc/kube-prometheus-stack-prometheus 9090:9090

Tarayıcınızda http://localhost:9090 adresine giderek Prometheus UI’a erişebilirsiniz.

* Alertmanager:

kubectl port-forward -n monitoring svc/kube-prometheus-stack-alertmanager 9093:9093

Tarayıcınızda http://localhost:9093 adresine giderek Alertmanager UI’a erişebilirsiniz.

* Grafana:

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

Tarayıcınızda http://localhost:3000 adresine giderek Grafana UI’a erişebilirsiniz.

Bu yöntem, komut satırı açık kaldığı sürece çalışır ve sadece yerel makinenizden erişim sağlar. Üretim ortamları için kalıcı ve güvenli erişim sağlamak amacıyla Ingress kullanmak daha iyidir.

Ingress Yapılandırması ile Kalıcı Erişim

Dışarıdan erişim sağlamak için bir Kubernetes Ingress Controller’a ihtiyacınız vardır. Eğer DOKS kümenizde henüz bir Ingress Controller kurulu değilse, Nginx Ingress Controller’ı kurmanız önerilir.

Nginx Ingress Controller Kurulumu (Eğer yoksa):

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install ingress-nginx ingress-nginx/ingress-nginx \
  --namespace ingress-nginx --create-namespace \
  --set controller.service.type=LoadBalancer # DOKS için LoadBalancer kullan

Bu komut, DigitalOcean Load Balancer ile entegre bir Nginx Ingress Controller kuracaktır. Yük dengeleyicinin bir dış IP adresi alması biraz zaman alabilir.

Ingress Controller kurulduktan sonra, my-prometheus-values.yaml dosyasında Prometheus, Alertmanager ve Grafana için tanımladığınız Ingress kaynakları otomatik olarak oluşturulacaktır. hosts alanlarını kendi alan adlarınızla güncellediğinizden emin olun ve DNS kayıtlarınızı (A kaydı) Ingress Controller’ın dış IP adresine işaret edecek şekilde ayarlayın.

Örneğin, grafana.yourdomain.com adresini Ingress Controller’ın dış IP’sine işaret ettikten sonra, tarayıcınızdan bu adrese giderek Grafana’ya erişebilirsiniz. TLS/SSL için Cert-Manager gibi bir araç kullanarak otomatik sertifika sağlamanız da şiddetle tavsiye edilir.

Grafana ile Görselleştirme

Grafana, Prometheus’tan toplanan metrikleri görselleştirmek için en popüler araçtır. Helm chart ile kurduğunuzda, Grafana otomatik olarak Prometheus veri kaynağını yapılandırır ve birçok kullanışlı dashboard’u yükler.

Grafana’ya İlk Giriş

Grafana UI’a eriştiğinizde, admin kullanıcı adı ve my-prometheus-values.yaml dosyasında belirlediğiniz adminPassword ile giriş yapın. İlk girişte şifrenizi değiştirmek isteyebilirsiniz.

Prometheus Veri Kaynağının Doğrulanması

Sol menüden “Connections” -> “Data sources” bölümüne gidin. Burada Prometheus adında bir veri kaynağının zaten yapılandırılmış olduğunu görmelisiniz. Bu veri kaynağının URL’si, Prometheus servisine işaret etmelidir (örn: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090). “Test” düğmesine tıklayarak bağlantının başarılı olduğunu doğrulayın.

Önceden Tanımlanmış Dashboard’ların Kullanımı

Helm chart, Kubernetes izlemesi için birçok hazır dashboard ile birlikte gelir. Sol menüden “Dashboards” -> “Browse” bölümüne gidin. Burada “Kubernetes / Compute Resources / Cluster”, “Kubernetes / Compute Resources / Namespace (Pods)”, “Node Exporter Full” gibi panoları göreceksiniz. Bu panolar, kümenizin genel durumu, düğüm kaynak kullanımı, pod kaynakları ve daha fazlası hakkında değerli bilgiler sağlar.

Bir dashboard’a tıklayarak kümenizin metriklerini görsel olarak inceleyebilirsiniz. Örneğin, “Kubernetes / Compute Resources / Cluster” panosu, kümenizin genel CPU ve bellek kullanımını, pod sayısını ve ağ trafiğini gösterir.

Özel Dashboard Oluşturma (Kısa Bir Örnek)

Kendi özel dashboard’larınızı oluşturmak için:
1. Sol menüden “Dashboards” -> “New dashboard” -> “Add a new panel” seçeneğine tıklayın.
2. “Query” sekmesinde, veri kaynağı olarak “Prometheus”u seçin.
3. PromQL sorgunuzu girin. Örneğin, tüm pod’ların CPU kullanımını görmek için:

sum(rate(container_cpu_usage_seconds_total{namespace="default", container!="POD", container!=""}[5m])) by (pod)

4. Görselleştirme tipini (Graph, Stat, Gauge vb.) seçin.
5. Panelin başlığını ve diğer ayarlarını yapılandırın.
6. “Apply” ve ardından “Save dashboard” düğmesine tıklayın.

Bu şekilde, uygulamalarınıza veya özel izleme ihtiyaçlarınıza yönelik kendi panolarınızı oluşturabilirsiniz.

Uyarılandırma (Alerting) ve Bildirimler

İzleme sadece veri toplamakla kalmaz, aynı zamanda belirlenen koşullar karşılandığında sizi bilgilendirmelidir. Prometheus, uyarı kurallarını tanımlamak için PromQL’i kullanır ve Alertmanager bu uyarıları yönetir ve bildirimleri gönderir.

Alertmanager Yapılandırmasına Genel Bakış

my-prometheus-values.yaml dosyasında Alertmanager için temel bir yapılandırma örneği vermiştik. Bu yapılandırma, uyarıları nasıl gruplandıracağını, bekleme sürelerini ve hangi alıcılara göndereceğini belirtir.

* route: Uyarıların nasıl yönlendirileceğini belirler. group_by, aynı özelliklere sahip uyarıları bir araya getirerek bildirim fırtınasını önler. receiver ise uyarıların hangi bildirim kanalına gönderileceğini tanımlar.
* receivers: Slack, email, PagerDuty gibi bildirim kanallarını tanımlar. Her alıcı, kendi yapılandırma parametrelerine sahiptir.

Daha karmaşık Alertmanager yapılandırmaları için resmi dokümantasyona başvurmanız önerilir.

Prometheus Kurallarının (PrometheusRule) Tanımlanması

Prometheus uyarı kuralları, PrometheusRule özel kaynak tanımları (Custom Resource Definitions – CRD) kullanılarak Kubernetes’te yönetilir. Helm chart, bu CRD’leri otomatik olarak kurar.

Örnek bir uyarı kuralı (cpu-usage-alert.yaml):

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: kubernetes-cpu-usage-alerts
  namespace: monitoring
spec:
  groups:
  - name: kubernetes.rules
    rules:
    - alert: HighPodCpuUsage
      expr: |
        sum(rate(container_cpu_usage_seconds_total{namespace="default", container!="POD", container!=""}[5m])) by (pod, namespace) /
        sum(kube_pod_container_resource_limits{namespace="default", resource="cpu", unit="core"}) by (pod, namespace) * 100
        > 80
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "Pod {{ $labels.pod }} in namespace {{ $labels.namespace }} has high CPU usage"
        description: "Pod {{ $labels.pod }} in namespace {{ $labels.namespace }} has been using more than 80% of its CPU limit for 5 minutes."

Bu kural, default namespace’indeki herhangi bir pod’un CPU kullanımının 5 dakika boyunca %80’in üzerinde kalması durumunda bir uyarı tetikler.

Bu kuralı kümenize uygulamak için:

kubectl apply -f cpu-usage-alert.yaml -n monitoring

Prometheus sunucusu bu kuralı otomatik olarak algılayacak ve izlemeye başlayacaktır.

Bildirim Kanalları Yapılandırması

Alertmanager, Slack, Email, PagerDuty, Opsgenie gibi birçok bildirim kanalını destekler. my-prometheus-values.yaml dosyasındaki Slack örneğini kullanarak, Alertmanager’ın uyarıları Slack kanalınıza nasıl göndereceğini ayarlayabilirsiniz.

Slack Webhook URL’si: Slack’te bir “Incoming Webhooks” uygulaması oluşturarak bir Webhook URL’si almanız gerekir. Bu URL’yi api_url alanına yapıştırın.

Diğer Kanallar:
* Email: SMTP sunucu bilgilerinizi Alertmanager yapılandırmasına eklemeniz gerekir.
* PagerDuty/Opsgenie: API anahtarlarınızı ve servis entegrasyonlarını yapılandırmanız gerekir.

Uyarı Test Etme

Uyarı yapılandırmanızın doğru çalıştığını test etmek için:
1. Prometheus UI’a gidin (http://localhost:9090 veya Ingress üzerinden).
2. “Alerts” sekmesine tıklayın. Burada tanımlanan tüm uyarı kurallarını ve durumlarını görebilirsiniz.
3. Test amaçlı, bir uygulamanızda kasıtlı olarak yüksek CPU veya bellek kullanımı yaratın. Bir süre sonra (kuralınızdaki for süresi geçtikten sonra), Prometheus UI’da uyarının PENDING veya FIRING durumuna geçtiğini görmelisiniz.
4. Alertmanager UI’a gidin (http://localhost:9093 veya Ingress üzerinden). Burada tetiklenen uyarıları ve bunların nasıl gruplandığını görebilirsiniz.
5. Yapılandırdığınız bildirim kanalına (örneğin Slack) bir bildirim gelip gelmediğini kontrol edin.

Ek Bileşenler ve Optimizasyonlar

Prometheus izleme yığını, kümenizin her yönünü izlemek için çeşitli exporter’lar ve optimizasyon stratejileriyle genişletilebilir.

Kube-state-metrics

kube-state-metrics, Kubernetes API’sinden metrikleri (örneğin, pod’ların durumu, deployment’ların replica sayısı, servislerin endpoint’leri) çeken ve Prometheus formatında sunan bir servistir. Helm chart ile kurduğunuzda genellikle varsayılan olarak etkinleştirilir. Bu metrikler, Kubernetes nesnelerinin sağlığını ve durumunu izlemek için hayati öneme sahiptir.

Node Exporter

node-exporter, her bir Kubernetes düğümünün (node) işletim sistemi seviyesindeki metriklerini (CPU kullanımı, bellek, disk I/O, ağ trafiği vb.) toplar. Bu metrikler, düğümlerin performansını ve sağlığını anlamak için önemlidir. Helm chart ile kurduğunuzda genellikle DaemonSet olarak her düğüme dağıtılır.

cAdvisor / Kubelet Metrikleri

Kubelet, her Kubernetes düğümünde çalışan bir ajandır. Kubelet, cAdvisor’ı kullanarak pod’ların ve kapsayıcıların kaynak kullanım metriklerini (CPU, bellek, ağ) toplar ve bunları /metrics uç noktasında Prometheus formatında sunar. Prometheus sunucusu, otomatik servis keşfi sayesinde bu uç noktalardan metrikleri çekebilir.

Depolama Optimizasyonu

Prometheus, topladığı metrikleri zaman serisi veritabanında (TSDB) depolar. Bu veritabanı, özellikle büyük kümelerde hızla büyüyebilir.

* Persistent Volume (PV) ve Persistent Volume Claim (PVC): DOKS’ta DigitalOcean Block Storage ile kalıcı depolama kullanmak, Prometheus verilerinin pod yeniden başlatmalarında bile korunmasını sağlar. do-block-storage gibi bir storageClassName belirtmek, DOKS’un yönetilen depolamasını kullanmanızı sağlar.
* Depolama Boyutu: values.yaml dosyasında storage: 20Gi gibi bir değerle depolama boyutunu belirleyebilirsiniz. Bu değeri kümenizin büyüklüğüne ve metrik saklama süresine (retention) göre ayarlamanız önemlidir.
* Uzaktan Depolama (Remote Storage): Çok büyük ölçekli veya uzun süreli veri saklama ihtiyaçları için Prometheus, verileri S3 uyumlu depolama (örneğin DigitalOcean Spaces) veya diğer zaman serisi veritabanlarına (Thanos, Cortex) uzaktan yazabilir. Bu, bu rehberin kapsamı dışındadır ancak ileri düzey bir optimizasyondur.

Kaynak Optimizasyonu

Prometheus ve diğer bileşenler de kümenizdeki diğer uygulamalar gibi kaynak tüketir. values.yaml dosyasında resources.requests ve resources.limits belirterek bu bileşenlerin CPU ve bellek kullanımını kontrol altında tutabilirsiniz. Bu, kümenizin istikrarı ve verimli kaynak kullanımı için önemlidir.

Güvenlik

* RBAC: Helm chart, gerekli RBAC kurallarını otomatik olarak oluştursa da, özel izleme senaryolarında ek izinler gerekebilir.
* Ağ Politikaları (Network Policies): Prometheus bileşenleri arasına ağ politikaları uygulayarak, yalnızca yetkili trafik akışına izin verebilirsiniz. Örneğin, Prometheus sunucusunun yalnızca exporter’lardan metrik çekmesine izin vermek gibi.
* TLS/SSL: Grafana ve Alertmanager’a dışarıdan erişirken mutlaka TLS/SSL kullanın. Ingress yapılandırmasında tls bölümünü kullanarak Cert-Manager ile otomatik sertifika sağlamak iyi bir çözümdür.
* Kimlik Doğrulama: Grafana için güçlü bir yönetici parolası kullanın ve mümkünse LDAP, OAuth gibi harici kimlik doğrulama sistemlerini entegre edin.

Sorun Giderme ve Yaygın Problemler

Kurulum veya kullanım sırasında karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

* Pod’lar Başlamıyor (CrashLoopBackOff, Pending):
* kubectl describe pod -n monitoring: Pod’un durumunu ve olaylarını kontrol edin. Olası nedenler arasında kaynak yetersizliği (CPU/bellek limitleri), yanlış yapılandırma veya Persistent Volume sorunları olabilir.
* kubectl logs -n monitoring: Pod günlüklerini inceleyin.
* PVC Bağlantı Sorunları: Eğer Prometheus veya Alertmanager pod’ları Pending durumunda kalıyorsa ve PVC’ler Bound değilse, storageClassName‘in doğru olduğundan ve depolama sınıfının mevcut olduğundan emin olun (kubectl get storageclass).

* Metrikler Gelmiyor veya Eksik:
* Prometheus Hedefleri: Prometheus UI’da “Status” -> “Targets” bölümüne gidin. Tüm hedeflerin UP durumda olduğundan emin olun. Eğer bir hedef DOWN ise, ilgili exporter pod’unun çalıştığından ve Prometheus’un ona erişebildiğinden emin olun.
* Servis Keşfi: Prometheus’un Kubernetes servis keşfi mekanizmasını kullanarak hedefleri doğru bir şekilde bulduğundan emin olun.
* Ağ Politikaları: Eğer ağ politikaları kullanıyorsanız, Prometheus’un exporter’lara ve Kubelet’e metrik çekmek için gerekli erişime sahip olduğundan emin olun.

* Grafana’ya Erişilemiyor:
* Port-forwarding: Eğer port-forwarding kullanıyorsanız, komutun hala çalıştığından ve doğru portları yönlendirdiğinden emin olun.
* Ingress: Eğer Ingress kullanıyorsanız:
* Ingress Controller’ın çalıştığından ve bir dış IP’ye sahip olduğundan emin olun.
* DNS kayıtlarınızın Ingress Controller’ın IP adresine doğru işaret ettiğinden emin olun.
* kubectl get ingress -n monitoring komutuyla Ingress kaynağının durumunu kontrol edin ve olayları inceleyin (kubectl describe ingress -n monitoring).
* values.yaml dosyasındaki Ingress yapılandırmasının doğru olduğundan emin olun.

* Uyarılar Tetiklenmiyor veya Bildirimler Gelmiyor:
* Prometheus Uyarıları: Prometheus UI’da “Alerts” sekmesini kontrol edin. Uyarı kuralınızın FIRING durumuna geçip geçmediğini görün. Eğer geçmiyorsa, PromQL sorgunuzu ve for süresini gözden geçirin.
* Alertmanager Yapılandırması: Alertmanager UI’da “Status” -> “Config” bölümünden yapılandırmanızın doğru yüklendiğinden emin olun. “Alerts” sekmesinde tetiklenen uyarıları ve bunların hangi alıcılara yönlendirildiğini kontrol edin.
* Bildirim Kanalı: Slack webhook URL’si veya email SMTP ayarları gibi bildirim kanalı yapılandırmasının doğru olduğundan emin olun. Harici servislerde (Slack, PagerDuty) API anahtarlarının veya webhook URL’lerinin geçerli olduğundan emin olun.

Sonuç ve İleri Adımlar

Bu rehberde, DigitalOcean Kubernetes (DOKS) kümeniz için Prometheus izleme yığınını Helm kullanarak nasıl kuracağınızı, temel bileşenleri nasıl yapılandıracağınızı ve Grafana ile nasıl görselleştireceğinizi detaylı bir şekilde inceledik. Artık kümenizin ve uygulamalarınızın performansını, sağlığını ve kaynak kullanımını proaktif bir şekilde izleyebilen sağlam bir altyapıya sahipsiniz.

Prometheus, esnekliği ve geniş ekosistemi sayesinde daha da ileriye taşınabilir. İşte atabileceğiniz bazı ileri adımlar:

* Uygulama Metrikleri: Uygulamalarınıza Prometheus istemci kütüphanelerini entegre ederek özel uygulama metriklerini (örneğin, istek sayısı, hata oranları, işlem süreleri) toplayın ve izleyin.
* Daha Fazla Exporter: Veritabanları (PostgreSQL exporter, MySQL exporter), mesaj kuyrukları (Kafka exporter) veya diğer üçüncü taraf hizmetler için ek exporter’lar kurarak tüm altyapınızın kapsamlı bir görünümünü elde edin.
* Thanos veya Cortex: Uzun vadeli depolama, yüksek erişilebilirlik ve küresel sorgulama yetenekleri için Thanos veya Cortex gibi Prometheus ölçeklendirme çözümlerini keşfedin.
* Otomatik Sertifikalar (Cert-Manager): Ingress’leriniz için otomatik olarak TLS sertifikaları sağlamak üzere Cert-Manager’ı kurun.
* Gelişmiş Alertmanager Yapılandırması: Farklı uyarı tipleri için farklı bildirim kanalları veya daha karmaşık yönlendirme kuralları (silence, inhibition) yapılandırın.
* GitOps Yaklaşımı: Tüm Kubernetes ve Helm yapılandırmalarınızı Git’te depolayarak ve Flux CD veya Argo CD gibi araçlarla otomatik dağıtım yaparak GitOps prensiplerini uygulayın.

DOKS kümenizi Prometheus ile izlemek, operasyonel verimliliğinizi artıracak ve uygulamalarınızın daha kararlı çalışmasını sağlayacaktır. Bu güçlü araçları etkin bir şekilde kullanarak, bulut yerlisi ortamlarınızın tam potansiyelini ortaya çıkarabilirsiniz.