Mayıs 22 2026

Zabbix + Alertmanager: PagerDuty ve Slack Entegrasyonu

Gece saat 03:00. Cep telefonunuz ardı ardına titriyor. Zabbix size “CPU usage high on prod-db-01” başlıklı tam 142 adet SMS göndermiş. Gözlerinizi oğuşturarak bilgisayarı açıyorsunuz ve durumun aslında sadece planlı bir veritabanı yedeğinden (backup job) ibaret olduğunu, diskin veya veritabanının çökmediğini görüyorsunuz. Bu esnada sinirden köpürürken kendinize şu soruyu soruyorsunuz: “Neden bu alarmları gruplayamadım? Neden nöbetçi arkadaşım yerine tüm ekip ayağa kalktı?”

İşte tam bu noktada, geleneksel izleme canavarımız zabbix ile modern bulut dünyasının alarm yönetim standardı olan alertmanager‘ı evlendirmenin vakti gelmiş demektir. Bu makalede, Zabbix’in topladığı metrik ve trigger’ları Alertmanager’a köprüleyecek, oradan da slack ve pagerduty entegrasyonları ile akıllı, gürültüsüz ve insan odaklı bir oncall yönetim yapısı kuracağız.

Neden Doğrudan Zabbix Değil de Alertmanager?

Zabbix, metrik toplama (polling), agent yönetimi ve esnek trigger tanımlama konularında harika bir araçtır. Ancak iş alarm yönetimine (alert routing, deduplication, inhibition ve silencing) geldiğinde Zabbix’in aksiyon (Action) arayüzü hantal kalır. GitOps felsefesine uygun değildir, sürüm kontrolü (version control) zordur ve karmaşık eskalasyon senaryolarında konfigürasyon cehennemine dönüşebilir.

Alertmanager ise Prometheus ekosisteminin kalbidir ancak sadece Prometheus ile sınırlı olmak zorunda değildir. Bize sunduğu avantajlar şunlardır:

  • Deduplication (Tekilleştirme): Aynı anda patlayan 50 benzer alarmı tek bir Slack mesajında birleştirir.
  • Inhibition (Bastırma): Eğer bir veri merkezi (datacenter) çöktüyse, o veri merkezinin içindeki 100 makine için “Node Down” alarmı göndermez; sadece “Datacenter Offline” alarmını geçirir, diğerlerini bastırır.
  • Dynamic Routing (Dinamik Yönlendirme): Alarma basılan etiketlere (labels) göre alarmı anında doğru ekibe (DBA, Network, Frontend) yönlendirir.

Adım 1: Zabbix Webhook ile Alertmanager API Köprüsü Kurmak

İlk yapmamız gereken iş, Zabbix’te bir trigger tetiklendiğinde bunu Alertmanager’ın /api/v2/alerts endpoint’ine gönderecek bir “Media Type” tanımlamaktır. Alertmanager, kendisine gönderilen JSON payload’unda belirli standartlar bekler.

Zabbix arayüzünde Administration -> Media Types sekmesine gidin ve “Create media type” butonuna tıklayın. Tipi Webhook olarak seçin ve aşağıdaki parametreleri ekleyin:

// Zabbix Webhook Script içeriği
try {
    var params = JSON.parse(value),
        req = new HttpRequest(),
        payload = [];

    if (typeof params.AlertmanagerURL === 'undefined') {
        throw 'AlertmanagerURL parametresi eksik.';
    }

    // Alertmanager API v2 formatı
    var alert = {
        "labels": {
            "alertname": params.AlertName,
            "severity": params.Severity,
            "instance": params.HostName,
            "service": params.Service || "infrastructure",
            "environment": params.Environment || "production"
        },
        "annotations": {
            "summary": params.TriggerDescription,
            "value": params.TriggerValue,
            "zabbix_url": params.ZabbixURL + "/tr_events.php?triggerid=" + params.TriggerID
        }
    };

    // Zabbix alarm durumuna göre durumu eşle (Eğer OK ise çözüldü olarak gönder)
    if (params.TriggerStatus === 'OK') {
        alert["endsAt"] = new Date().toISOString();
    } else {
        alert["startsAt"] = new Date().toISOString();
    }

    payload.push(alert);

    req.addHeader('Content-Type: application/json');
    var response = req.post(params.AlertmanagerURL + '/api/v2/alerts', JSON.stringify(payload));

    if (req.getStatus() !== 200 && req.getStatus() !== 201) {
        throw 'HTTP hatası: ' + req.getStatus() + '\nResponse: ' + response;
    }

    return 'OK';
} catch (error) {
    Zabbix.log(3, 'Alertmanager webhook hatası: ' + error);
    throw error;
}

Bu JS kodu, Zabbix trigger’ı tetiklendiğinde ya da çözüldüğünde (OK durumuna geçtiğinde) Alertmanager’a RFC3339 formatında zaman damgasıyla birlikte durumu iletir. Böylece Alertmanager alarmın çözüldüğünü (resolved) anlar ve Slack/PagerDuty üzerindeki açık alarmı otomatik olarak kapatır.

Adım 2: Alertmanager Konfigürasyonu (`alertmanager.yml`)

Şimdi Alertmanager tarafında bu alarmları nasıl karşılayacağımızı ve nereye yönlendireceğimizi tanımlayalım. production ortamlarında genellikle kritik alarmların PagerDuty’ye (ve dolayısıyla nöbetçi mühendisin telefonuna), uyarı seviyesindeki alarmların ise sadece Slack kanalına gitmesini isteriz.

global:
  resolve_timeout: 5m

route:
  group_by: ['alertname', 'instance', 'environment']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'slack-default'
  routes:
    # Kritik üretim alarmları hem Slack'e hem PagerDuty'ye gitsin
    - match:
        severity: 'disaster'
        environment: 'production'
      receiver: 'pagerduty-critical'
      continue: true
    
    # Tüm üretim alarmları Slack kanalına düşsün
    - match:
        environment: 'production'
      receiver: 'slack-production'

receivers:
- name: 'slack-default'
  slack_configs:
  - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
    channel: '#ops-alerts-test'
    send_resolved: true
    text: "Alarm: {{ .CommonAnnotations.summary }}\nSeverity: {{ .CommonLabels.severity }}\nHost: {{ .CommonLabels.instance }}"

- name: 'slack-production'
  slack_configs:
  - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/YYYYYYYYYYYYYYYYYYYYYYYY'
    channel: '#prod-alerts'
    send_resolved: true
    title: "[{{ .Status | toUpper }}] {{ .CommonLabels.alertname }}"
    text: "Host: {{ .CommonLabels.instance }}\nDetay: {{ .CommonAnnotations.summary }}\nZabbix Linki: {{ .CommonAnnotations.zabbix_url }}"

- name: 'pagerduty-critical'
  pagerduty_configs:
  - service_key: 'YOUR_PAGERDUTY_INTEGRATION_KEY_HERE'
    severity: 'critical'
    send_resolved: true
    client: 'Alertmanager'
    client_url: 'https://alertmanager.kertenkerem.net'
    description: "{{ .CommonAnnotations.summary }} - Host: {{ .CommonLabels.instance }}"

Adım 3: PagerDuty Üzerinde Akıllı On-Call ve Eskalasyon Politikaları

Alertmanager entegrasyonunu tamamladıktan sonra topu pagerduty tarafına atıyoruz. PagerDuty üzerinde bir servis (Service) oluşturup entegrasyon tipini “Prometheus/Alertmanager” olarak seçtiğinizde size yukarıdaki YAML dosyasında kullandığımız service_key (Integration Key) değerini verecektir.

Ancak iş sadece entegrasyonla bitmiyor. Gerçek bir oncall kültüründe şu üç yapıyı kurmanız gerekir:

1. Schedules (Nöbet Takvimleri)

Haftalık rotasyonlar tanımlayın. Örneğin, her Salı günü saat 09:00’da nöbet bir sonraki mühendise devretsin. PagerDuty üzerinde Primary ve Secondary (yedek) olmak üzere iki farklı takvim oluşturmak hayat kurtarır. Eğer Primary nöbetçisi o an ulaşılamaz durumdaysa (örneğin uçaktaysa), sistem otomatik olarak yedek nöbetçiyi arar.

2. Escalation Policies (Eskalasyon Politikaları)

Alarmların sahipsiz kalmaması için eskalasyon zinciri şarttır. Örnek bir kurumsal politika şu şekilde olmalıdır:

  • Adım 1: Alarm tetiklendiğinde o anki nöbetçiyi (Primary) ara ve SMS gönder. (0. dakika)
  • Adım 2: Eğer 10 dakika içinde “Acknowledge” (onay) gelmezse, yedek nöbetçiyi (Secondary) ara. (10. dakika)
  • Adım 3: Eğer hala ses çıkmıyorsa, tüm DevOps ekibine push notification at ve takım liderini devreye sok. (20. dakika)

3. Slack Entegrasyonu ve ChatOps

PagerDuty Slack uygulamasını kurarak, Slack kanalı üzerinden tek tıkla alarmı üstlenebilir (Acknowledge) veya çözebilirsiniz (Resolve). Bu, gece yarısı telefondan PagerDuty uygulamasına girmeye çalışırken harcayacağınız 30 saniyeyi size geri kazandırır.

Alert Fatigue (Alarm Yorgunluğu) ile Savaşmak

Sistemi kurduk ancak her gün 500 defa çalan bir pager sistemi, bir süre sonra mühendislerin uyarıları görmezden gelmesine (alert fatigue) sebep olur. Bunu engellemek için şu taktikleri uygulayın:

  • Sadece aksiyon alınabilir alarmları PagerDuty’ye gönderin: “Disk doluluğu %81 oldu” bir PagerDuty alarmı değildir, sadece Slack’e gitmelidir. Ancak “Disk doluluğu %95 ve 10 dakika içinde tamamen dolacak” alarmı nöbetçiyi yataktan kaldırmalıdır.
  • Inhibit Rules kullanın: Switch çöktüğünde arkasındaki 30 sunucu için tek tek “ping down” alarmı almamak için Alertmanager inhibit kurallarını tanımlayın.
  • Susturma (Silences): Planlı bakım çalışmalarından önce Alertmanager veya PagerDuty arayüzünden ilgili servisleri mutlaka susturun (Silence).

Özet

Zabbix’in köklü izleme yeteneklerini Alertmanager’ın modern yönlendirme mimarisiyle birleştirmek, altyapı yönetiminde adeta çağ atlatır. Bu sayede hem production ortamınızdaki anomalileri saniyeler içinde yakalarsınız, hem de ekibinizin akıl sağlığını gereksiz gürültülü alarmlardan korumuş olursunuz.

Bir sonraki yazımızda Alertmanager üzerinde gelişmiş inhibit_rules yazımını inceleyeceğiz. O zamana kadar, alarmınız az, uykunuz bol olsun!

Category: Genel | LEAVE A COMMENT
Temmuz 26 2024

Zabbix’te LLD (Low-Level Discovery) ile Dinamik Host Keşfi

DevOps dünyasında “bunu elle hallederiz ya” dediğiniz her an, arkadan sinsice yaklaşan teknik borç (technical debt) canavarının nefesini ensenizde hissedersiniz. Konu sistem izleme ve monitoring olduğunda da durum farklı değil. Dinamik olarak ölçeklenen, sürekli yeni servislerin ayağa kalktığı modern altyapılarda, her yeni disk partition, ağ arayüzü veya çalışan custom servis için Zabbix’e manuel host veya item eklemek tam bir işkencedir. İşte bu noktada, zabbix dünyasının can kurtaran simidi olan lld (low-level discovery) devreye giriyor. Bu yazıda, modern altyapıların vazgeçilmezi olan otomasyon felsefesine sadık kalarak, LLD ile dinamik keşif süreçlerini, kendi custom template’lerimizi yazmayı ve trigger tanımlamayı pratik örneklerle ele alacağız.

LLD (Low-Level Discovery) Nedir ve Neden Hayat Kurtarır?

Geleneksel monitoring yaklaşımlarında, bir sunucunun üzerindeki diskleri izlemek istediğinizde /dev/sda1, /dev/sdb1 gibi diskleri tek tek elle tanımlamanız gerekirdi. Peki ya yarın sisteme yeni bir NVMe disk eklenirse? Ya da Kubernetes worker node’u üzerinde dinamik olarak yüzlerce ephemeral disk mount edilirse? Hepsini manuel olarak takip edip sisteme girmek imkansızdır.

LLD, hedef makinede belirli bir script veya agent modülü çalıştırarak mevcut kaynakları tarar, bunları bir JSON array yapısı haline getirir ve Zabbix Server’a raporlar. Zabbix Server bu JSON’ı okuyarak dinamik olarak item’lar, trigger’lar ve hatta grafikler oluşturur (bunlara prototype denir). Kaynak ortadan kalktığında ise (örneğin bir disk unmount edildiğinde) belirlediğiniz koruma süresi (keep lost resources period) sonunda bu item’ları otomatik olarak temizler. İşte gerçek otomasyon budur!

Adım 1: LLD’nin Kalbi – JSON Çıktısı ve custom LLD Makroları

Zabbix’in bir kaynağı dinamik olarak keşfedebilmesi için tek bir şartı vardır: Çıktının belirli bir JSON formatında olması. Zabbix 5.0 öncesinde katı bir {"data": [...]} formatı zorunluyken, modern Zabbix versiyonlarında (5.0 ve sonrası) düz bir JSON array de kabul edilmektedir.

LLD süreçlerinde en kritik bileşen, iki süslü parantez ve diyez işaretiyle başlayan LLD Makrolarıdır (örneğin: {#SERVICE_NAME}). Bu makrolar, keşfedilen her bir bileşenin benzersiz kimliğini temsil eder.

Gelin, sunucumuzda koşan aktif TCP portlarını otomatik keşfedecek basit bir bash script yazalım. Bu scripti hedef sunucuya yerleştireceğiz.

#!/bin/bash
# discover_ports.sh
# Sunucuda dinlenen TCP portlarını listeleyen ve JSON üreten script

ports=$(netstat -tuln | awk 'NR>2 {print $4}' | awk -F':' '{print $NF}' | sort -u | grep -E '^[0-9]+$')

echo "["
first=1
for port in $ports; do
    # JSON yapısını bozmamak için virgül kontrolü
    if [ $first -eq 0 ]; then
        echo ","
    fi
    # Servis adını bulmaya çalışalım (opsiyonel)
    service_name=$(lsof -i :$port -t | xargs ps -p -o comm= 2>/dev/null | head -n1)
    if [ -z "$service_name" ]; then
        service_name="unknown"
    fi
    printf '  { "{#TCP_PORT}": "%s", "{#PORT_SERVICE}": "%s" }' "$port" "$service_name"
    first=0
done
echo ""
echo "]"

Bu scripti çalıştırdığınızda aşağıdaki gibi temiz bir JSON çıktısı almalısınız:

[
  { "{#TCP_PORT}": "22", "{#PORT_SERVICE}": "sshd" },
  { "{#TCP_PORT}": "80", "{#PORT_SERVICE}": "nginx" },
  { "{#TCP_PORT}": "5432", "{#PORT_SERVICE}": "postgres" }
]

Adım 2: Zabbix Agent Konfigürasyonu (UserParameter)

Yazdığımız bu scripti Zabbix Agent’ın çalıştırabilmesi için bir UserParameter tanımlamamız gerekiyor. Hedef sunucudaki Zabbix Agent konfigürasyon dosyasına (/etc/zabbix/zabbix_agentd.d/custom_lld.conf) şu satırı ekliyoruz:

UserParameter=custom.ports.discovery,/etc/zabbix/scripts/discover_ports.sh

Script dosyasının izinlerini ayarlamayı ve Zabbix kullanıcısının çalıştırabileceğinden emin olmayı unutmayın:

chmod +x /etc/zabbix/scripts/discover_ports.sh
systemctl restart zabbix-agent

Şimdi Zabbix Server veya Proxy üzerinden bu anahtarın çalışıp çalışmadığını zabbix_get yardımıyla test edelim. Bu adım debug süreçleri için hayati önem taşır:

zabbix_get -s 192.168.1.50 -k custom.ports.discovery

JSON çıktısını terminalde gördüyseniz, tebrikler! Altyapı hazır, şimdi Zabbix arayüzüne geçebiliriz.

Adım 3: Template, Discovery Rule ve Item Prototype Tanımlama

Zabbix Web UI üzerinde yeni bir template (örneğin: Template App Custom Port Discovery) oluşturun veya var olan bir template içerisine girin.

1. Discovery Rule Oluşturma

  • Template içinden Discovery rules sekmesine gelin ve Create discovery rule butonuna tıklayın.
  • Name: Active TCP Ports Discovery
  • Type: Zabbix agent (veya active agent kullanıyorsanız active seçin)
  • Key: custom.ports.discovery
  • Update interval: 1h (Sık sık port değişmiyorsa 1 saat idealdir, sistemi yormaya gerek yok)
  • Keep lost resources period: 7d (Sönen portlar 7 gün sonra sistemden silinsin)

2. Item Prototype Oluşturma

Keşfedilen her bir portun ayakta olup olmadığını kontrol edecek asıl izleme bileşenini (item) burada tanımlayacağız. Oluşturduğumuz Discovery rule içindeki Item prototypes sekmesine gidin ve Create item prototype deyin.

  • Name: Port {#TCP_PORT} ({#PORT_SERVICE}) Status
  • Type: Simple check (veya Zabbix Agent net.tcp.service kontrolü)
  • Key: net.tcp.service[tcp,,{#TCP_PORT}]
  • Type of information: Numeric (unsigned)

Burada dikkat ettiyseniz Key alanında doğrudan {#TCP_PORT} makrosunu kullandık. Zabbix LLD motoru, JSON’dan gelen her satır için bu item şablonunu çoğaltacak ve dinamik olarak net.tcp.service[tcp,,22], net.tcp.service[tcp,,80] gibi gerçek izleme item’ları üretecektir.

Adım 4: Akıllı Alarmlar İçin Trigger Prototype Yazmak

Item’ları oluşturduk ancak port kapandığında alarm almamız gerekiyor. Bunun için yine aynı Discovery rule altındaki Trigger prototypes sekmesini kullanıyoruz.

  • Name: Port {#TCP_PORT} ({#PORT_SERVICE}) is DOWN on {HOST.NAME}
  • Severity: Average veya High
  • Expression: last(/Template App Custom Port Discovery/net.tcp.service[tcp,,{#TCP_PORT}])=0

Bu trigger prototype sayesinde, yeni bir port sisteme dahil olduğunda hem izleme kalemi (item) hem de alarm mekanizması (trigger) sıfır manuel müdahale ile anında aktif hale gelecektir. Nginx’i mi restart ettiniz? Port kapandığı an alarmınız hazır!

Pro-Tip: Filtreleri Kullanarak Gürültüyü Engellemek (Noise Reduction)

LLD çok güçlüdür ancak bazen “gürültüye” sebep olabilir. Örneğin dinamik ephemeral portları (örneğin 32768-60999 arasını) veya her ayağa kalkan anlamsız portu izlemek istemeyebilirsiniz. LLD içerisindeki Filters sekmesi bu iş için biçilmiş kaftandır.

Keşif kuralınızın (Discovery Rule) altındaki Filters sekmesine gelin:

  • Label A: Macro: {#TCP_PORT} – Regular expression: ^(80|443|22|5432|3306)$

Bu kuralı eklediğinizde, Zabbix script çıktısındaki tüm portları değil, sadece sizin regex filtrenize uyan kritik portları (HTTP, HTTPS, SSH, PostgreSQL, MySQL) izlemeye alacaktır.

Özet ve Kapanış

Zabbix’te dinamik keşif (LLD) mimarisini kurmak, DevOps mühendislerinin altyapı büyürken geceleri rahat uyumasını sağlayan en kritik adımlardan biridir. Bu makalede ele aldığımız mantığı sadece port keşfi için değil; docker container’ları, SSL sertifika süreleri, log dosyaları, hatta AWS üzerindeki dinamik kaynaklar için bile uygulayabilirsiniz. Tek yapmanız gereken, hedefi tarayan ve standart bir JSON çıktısı üreten ufak bir script yazıp bunu Zabbix makroları ile eşleştirmek.

Otomasyonun olmadığı yerde monitoring sadece bir yükten ibarettir. LLD ile kalın, sistemlerinizi kendi kendine keşfeden akıllı yapılara dönüştürün!

Category: Genel | LEAVE A COMMENT
Temmuz 19 2024

Zabbix 7.x ile Kubernetes Cluster Monitoring

Kubernetes ekosisteminde monitoring denildiğinde akla ilk gelen Prometheus-Grafana ikilisi olsa da, modern devops dünyasında zabbix 7.x sürümüyle kartları yeniden dağıtıyor. Bu yazımızda, legacy sistemlerden aşina olduğumuz bu devasa canavarın, kubernetes cluster’larındaki container metriklerini auto-discovery (LLD) yetenekleriyle nasıl saniyeler içinde yakaladığını, verileri nasıl işlediğini ve Grafana ile nasıl görselleştirdiğini ele alacağız. “Prometheus kurduk ama RAM tüketimi ocağımıza incir ağacı dikti” diyenlerdenseniz, kemerlerinizi bağlayın; Zabbix 7.x’in hafif ve güçlü Kubernetes entegrasyonuna dalıyoruz.

Neden Zabbix 7.x? (Eski Dostun Yeni Numaraları)

Yıllarca Zabbix’i sadece VM’lerin CPU ve disk doluluk oranlarını izlemek için kullandıysanız, kendinizi güncellemenin vakti geldi demektir. Zabbix 7.x, Kubernetes dünyasını yabancı bir gezegen gibi görmüyor. HTTP agent, out-of-the-box gelen gelişmiş Kubernetes template’leri ve JSONPath preprocessing yetenekleri sayesinde API Server üzerinden doğrudan cluster’ın kalbine inebiliyor.

Peki neden Prometheus yerine Zabbix? Cevap basit: Unified Monitoring ve Uzun Vadeli Veri Saklama (Long-term Retention). Eğer cluster dışında fiziksel switch’leriniz, legacy veritabanlarınız ve sanal makineleriniz varsa, hepsini tek bir panele toplamak ve bunu yaparken TSDB (Time Series Database) kaynaklı çılgın RAM maliyetlerinden kaçınmak istiyorsanız, Zabbix 7.x tam size göre.

Adım 1: Kubernetes Cluster Üzerinde Zabbix Helm Deployment

Zabbix’in cluster içindeki gözü kulağı olacak Zabbix Agent 2 ve Zabbix Proxy yapılandırmasını kurarak işe başlıyoruz. Kubernetes API’si ile güvenli bir şekilde konuşabilmek için service account ve rol tanımlamalarına ihtiyacımız var. Neyse ki resmi Helm chart bu işi bizim yerimize hallediyor.

İlk olarak Zabbix topluluk reposunu sistemimize ekleyelim:

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

Şimdi, cluster metriklerini toplamak için optimize edilmiş bir values.yaml dosyası hazırlayalım. Bu dosyada Zabbix Server adresimizi ve cluster adımızı belirtiyoruz. Aşağıdaki konfigürasyonu zabbix-values.yaml olarak kaydedebilirsiniz:

zabbixProxy:
  enabled: true
  resources:
    limits:
      cpu: 500m
      memory: 512Mi
    requests:
      cpu: 100m
      memory: 128Mi
  env:
    - name: ZBX_HOSTNAME
      value: "k8s-production-proxy"
    - name: ZBX_SERVER_HOST
      value: "zabbix-server.kertenkerem.local" # Zabbix Server IP veya FQDN'iniz

zabbixAgent:
  enabled: true
  resources:
    limits:
      cpu: 200m
      memory: 256Mi
    requests:
      cpu: 50m
      memory: 64Mi
  env:
    - name: ZBX_HOSTNAMEITEM
      value: "system.hostname"

Bu konfigürasyon ile cluster içinde bir DaemonSet olarak Zabbix Agent 2 ve cluster dışındaki ana sunucumuza verileri güvenli ve sıkıştırılmış şekilde iletecek bir Zabbix Proxy ayağa kaldırıyoruz. Kurulumu şu komutla tetikleyelim:

kubectl create namespace monitoring
helm install zabbix zabbix-community/zabbix-helm-ch --namespace monitoring -f zabbix-values.yaml

Adım 2: Auto-Discovery (LLD) ile Metrik Avcılığı

Kubernetes dinamik bir yapıya sahiptir; pod’lar saniyeler içinde ölür, yenileri doğar. Statik IP’ler veya host tanımlamaları burada sökmez. Zabbix 7.x, bu kaosu çözmek için Low-Level Discovery (LLD) mekanizmasını kullanır. Kubernetes API Server üzerinden pods, nodes, namespaces ve services discovery kurallarını çalıştırır.

Zabbix Web UI arayüzüne giriş yaptıktan sonra şu adımları izleyin:

1. API Token Oluşturma

Zabbix Server’ın cluster API’si ile konuşabilmesi için Helm kurulumu sırasında otomatik oluşturulan service account token’ını almamız gerekiyor:

kubectl get secret $(kubectl get serviceaccount zabbix-service-account -n monitoring -o jsonpath="{.secrets[0].name}") -n monitoring -o jsonpath="{.data.token}" | base64 --decode

Not: Kubernetes 1.24 ve üzeri kullanıyorsanız, secret manuel oluşturulmuş olabilir. Helm chart bunu sizin için halletmediyse, service account için bir `kubernetes.io/service-account-token` tipinde Secret oluşturup token’ı oradan okumalısınız.

2. Zabbix Üzerinde Host Tanımlama

  • Configuration -> Hosts -> Create Host yolunu izleyin.
  • Host Name alanına Kubernetes Cluster Production yazın.
  • Templates kısmına “Kubernetes by HTTP” template’ini ekleyin. Bu template, Zabbix 7.0 ile gelen out-of-the-box harika bir canavardır.
  • Macros sekmesine geçiş yapın ve aşağıdaki kritik değişkenleri tanımlayın:
{$KUBE.API.URL} -> https://<kubernetes-api-endpoint>:6443
{$KUBE.API.TOKEN} -> <Bir önceki adımda elde ettiğiniz token>

Bu tanımlamadan sonra Zabbix, HTTP agent yardımıyla cluster API’nize sorgu atmaya başlayacak. Birkaç dakika içinde “Discovery rules” altındaki kuralların tetiklendiğini ve cluster’ınızdaki tüm node’ların, pod’ların ve container’ların otomatik olarak sisteme “Graph” ve “Item” olarak eklendiğini göreceksiniz. İşte auto-discovery’nin gücü!

Adım 3: Grafana Entegrasyonu (Görsel Şölen)

Zabbix’in kendi arayüzündeki grafikler son yıllarda iyileşmiş olsa da, hiçbirimiz yöneticilerimize veya development ekiplerine o 90’lardan kalma görünümlü panelleri göstermek istemeyiz. Bize Grafana lazım.

Grafana üzerinde Zabbix veri kaynağını (datasource) aktifleştirmek için şu adımları izliyoruz:

grafana-cli plugins install alexanderzobnin-zabbix-app
systemctl restart grafana-server

Grafana arayüzüne gidip Connections -> Data Sources -> Add New Data Source dedikten sonra listeden Zabbix’i seçiyoruz. Konfigürasyon ayarlarında dikkat etmeniz gereken kritik noktalar şunlar:

  • URL: http://zabbix-server-ip/zabbix/api_jsonrpc.php
  • Access: Server (Default)
  • Zabbix API Connection: Zabbix admin kullanıcı adı ve şifreniz.

Bağlantıyı test edip kaydettikten sonra, Kubernetes cluster metriklerimizi içeren dashboard’ları tasarlayabiliriz. Örneğin, her pod’un CPU tüketimini dinamik olarak çeken bir panel yazmak istersek, Grafana query alanına şu regex’i girebiliriz:

Group: Kubernetes
Host: /.*/
Application: CPU
Item: /Calculated CPU usage percent/

Bu sorgu sayesinde, cluster’a yeni bir mikroservis deploy edildiğinde hiçbir manuel müdahale yapmadan o servisin CPU grafiği saniyeler içinde Grafana panelinizde belirecektir.

Adım 4: Akıllı Alerting Kuralları

Gecenin saat 3’ünde “Pod restart attı” diye uyanmak istemiyorsanız, Zabbix’in esnek trigger yapısını doğru kurgulamanız gerekir. Klasik CPU doldu alert’leri yerine Kubernetes dünyasına uygun akıllı trigger’lar yazmalıyız.

Örnek 1: CrashLoopBackOff Durumu tespiti

Bir pod sürekli hata alıp kapanıyorsa ve restart sayısı artıyorsa, bu kritik bir durumdur. Zabbix template’i içinde gelen varsayılan kuralı özelleştirebiliriz:

last(/Kubernetes by HTTP/kube.pod.restart_rate[{#POD.NAME}]) > 3 and last(/Kubernetes by HTTP/kube.pod.status[{#POD.NAME}]) = 0

Bu trigger, pod’un son 5 dakika içindeki restart hızı 3’ten fazla ise ve pod “Ready” durumunda değilse alarm üretir. Geçici network kesintilerinde boşuna Slack kanallarınızı spam’lemez.

Örnek 2: Node Disk Basıncı (Disk Pressure)

Kubelet’in node üzerindeki pod’ları evict etmeye başlamadan (yani sistem dışına atmadan) önce diskin dolduğunu anlamamız gerekir:

last(/Kubernetes by HTTP/kube.node.status.disk_pressure[{#NODE.NAME}]) = 1

Bu alarm tetiklendiğinde, Zabbix’in Webhook entegrasyonu sayesinde Slack veya PagerDuty üzerinden anlık bildirim alabilir, hatta otomatik aksiyon (Remote Command) tanımlayarak ilgili node üzerindeki gereksiz docker imajlarını temizleyen bir script çalıştırabilirsiniz.

Zabbix 7.x Kubernetes Monitoring’in Avantaj ve Dezavantajları

Her sistemde olduğu gibi bu mimarinin de güçlü ve zayıf yanları var. Kararınızı vermeden önce bunları masaya yatıralım:

Avantajları Dezavantajları
Düşük kaynak tüketimi (RAM/CPU dostu) Kubernetes native olmaması (Prometheus operator kadar cluster içine entegre değil)
Merkezi yönetim ve güçlü LLD yetenekleri Custom Metric API ile HPA (Horizontal Pod Autoscaler) entegrasyonu görece zor
Uzun vadeli verileri saklamada veritabanı esnekliği (PostgreSQL/TimescaleDB) Grafana template kütüphanesinin Prometheus kadar zengin olmaması

Sonuç

Zabbix 7.x, Kubernetes cluster’larını izlemek için hantal ve “outdated” bir çözüm olmaktan çok uzak. Aksine, kaynak tüketimini minimize etmek isteyen ve tüm IT altyapısını (fiziksel, sanal, container) tek bir merkezi noktadan yönetmeyi hedefleyen kıdemli sistem ve devops mühendisleri için biçilmiş kaftan. Auto-discovery mekanizmasının gücü ve Grafana’nın görsel yetenekleri birleştiğinde, production ortamınızda uçtan uca izlenebilirlik (observability) sağlamak işten bile değil.

Siz de cluster’larınızda Zabbix kullanmayı denediniz mi? Yaşadığınız tecrübeleri veya takıldığınız yerleri yorumlarda bizimle paylaşın, debugging seansına beraber devam edelim!

Category: Genel | LEAVE A COMMENT