Heartbeat ile Uptime İzleme ve Alarm

Prod ortamda bir servis sessiz sedasız çöküp saatlerce kimsenin haberi olmadan çalışmadan durmuşsa, o acıyı bilirsiniz. Monitoring stack’in güzel dashboardları var, metrikler akıyor, loglar geliyor; ama o kritik endpoint bir türlü kontrol edilmiyor. İşte Elastic Stack’in Heartbeat bileşeni tam da bu boşluğu dolduruyor. Pasif log analizinin ötesine geçip aktif olarak “bu servis ayakta mı, cevap veriyor mu?” sorusunu sormak için tasarlanmış bir araç.

Bu yazıda Heartbeat’i sıfırdan kurup yapılandıracağız, gerçek dünya senaryolarında nasıl kullanıldığını göreceğiz ve Kibana üzerinde anlamlı alarmlar nasıl kurulur onu konuşacağız.

Heartbeat Nedir, Neden Kullanmalısınız?

Metricbeat sunucunuzun CPU ve RAM’ini izler. Filebeat loglarınızı toplar. Heartbeat ise dışarıdan bir göz gibi davranır: belirli aralıklarla hedef servislere istek atar ve cevap alıp almadığını, ne kadar sürede cevap geldiğini, SSL sertifikasının geçerli olup olmadığını kayıt altına alır.

Bunu neden önemsiyoruz? Çünkü bir servis “çalışıyor” görünebilir ama gerçekte cevap vermiyor olabilir. Nginx process’i ayaktadır, container running durumundadır, ama uygulama içindeki bir deadlock yüzünden hiçbir isteğe yanıt gelmemektedir. Heartbeat bu farkı yakalar.

Desteklediği protokoller:

ICMP: Basit ping kontrolü, host erişilebilirliği
TCP: Port bazlı kontrol, veritabanı portları, özel protokoller
HTTP/HTTPS: Web servisleri, REST API’ler, health endpoint’leri

Kurulum

Ubuntu/Debian üzerinde kurulum yapalım önce:

# Elastic GPG key ekle
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

# Repository ekle
echo "deb https://artifacts.elastic.co/packages/8.x/apt stable main" | 
  sudo tee /etc/apt/sources.list.d/elastic-8.x.list

# Kur
sudo apt-get update && sudo apt-get install heartbeat-elastic

# Servis olarak etkinleştir
sudo systemctl enable heartbeat-elastic

RPM tabanlı sistemler için:

# Repo dosyasını oluştur
cat > /etc/yum.repos.d/elastic.repo << 'EOF'
[elasticsearch]
name=Elasticsearch repository for 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
EOF

# Kur
sudo yum install heartbeat-elastic -y
sudo systemctl enable heartbeat-elastic

Ana Konfigürasyon Dosyası

/etc/heartbeat/heartbeat.yml dosyası her şeyin başladığı yer. Temel yapıya bakalım:

# heartbeat.yml

heartbeat.config.monitors:
  path: ${path.config}/monitors.d/*.yml
  reload.enabled: true
  reload.period: 5s

# Elasticsearch bağlantısı
output.elasticsearch:
  hosts: ["https://elasticsearch:9200"]
  username: "heartbeat_writer"
  password: "${HEARTBEAT_ES_PASS}"
  ssl.certificate_authorities: ["/etc/heartbeat/certs/ca.crt"]

# Kibana için setup
setup.kibana:
  host: "https://kibana:5601"
  username: "elastic"
  password: "${KIBANA_PASS}"

# İndeks adlandırması
setup.template.name: "heartbeat"
setup.template.pattern: "heartbeat-*"
setup.ilm.rollover_alias: "heartbeat"

Burada dikkat etmeniz gereken nokta: Heartbeat’i Elasticsearch’e doğrudan yazmak yerine Logstash üzerinden geçirmek de mümkün. Büyük ortamlarda bu yaklaşım daha mantıklı çünkü merkezi bir pipeline yönetimi sağlıyor.

Monitor Tanımları

Gerçek iş burada başlıyor. /etc/heartbeat/monitors.d/ altında YAML dosyaları oluşturarak farklı servis tiplerini izleyebilirsiniz.

HTTP Monitor

# /etc/heartbeat/monitors.d/web-services.yml

- type: http
  id: ecommerce-api
  name: "E-ticaret API"
  schedule: "@every 30s"
  hosts:
    - "https://api.sirket.com.tr/health"
    - "https://api-dr.sirket.com.tr/health"
  check.response:
    status: [200]
    body:
      - '"status":"healthy"'
  timeout: 10s
  ssl.verification_mode: full

- type: http
  id: payment-gateway
  name: "Ödeme Sistemi"
  schedule: "@every 10s"
  hosts: ["https://odeme.sirket.com.tr/ping"]
  check.response:
    status: [200, 204]
  timeout: 5s
  tags: ["critical", "payment"]

- type: http
  id: internal-dashboard
  name: "İç Dashboard"
  schedule: "@every 60s"
  hosts: ["http://192.168.10.50:3000/api/health"]
  username: "monitor_user"
  password: "${DASHBOARD_MONITOR_PASS}"
  check.response:
    status: [200]

check.response.body alanı çok değerli: sadece 200 dönüyor mu diye değil, dönen içerikte beklediğiniz bir string var mı diye de kontrol edebilirsiniz. Uygulamanız 200 döndürüp içinde "status":"degraded" yazıyor olabilir, bu farkı da yakalamak isteyebilirsiniz.

TCP Monitor

Veritabanı portları ve diğer TCP servisleri için:

# /etc/heartbeat/monitors.d/infrastructure.yml

- type: tcp
  id: postgresql-primary
  name: "PostgreSQL Primary"
  schedule: "@every 15s"
  hosts:
    - "db-primary.internal:5432"
  timeout: 3s
  tags: ["database", "postgresql"]

- type: tcp
  id: redis-cluster
  name: "Redis Cluster"
  schedule: "@every 15s"
  hosts:
    - "redis-01.internal:6379"
    - "redis-02.internal:6379"
    - "redis-03.internal:6379"
  timeout: 2s
  tags: ["cache", "redis"]

- type: tcp
  id: rabbitmq-amqp
  name: "RabbitMQ AMQP Port"
  schedule: "@every 30s"
  hosts: ["rabbitmq.internal:5672"]
  timeout: 5s

ICMP Monitor

Network segmentleri arası erişilebilirliği test etmek için:

# /etc/heartbeat/monitors.d/network.yml

- type: icmp
  id: core-network-devices
  name: "Ağ Cihazları Ping"
  schedule: "@every 30s"
  hosts:
    - "192.168.1.1"
    - "192.168.1.2"
    - "10.0.0.1"
  timeout: 5s
  wait: 1s
  tags: ["network", "infrastructure"]

ICMP monitörler için Heartbeat’in root ya da özel capability ile çalışması gerekebilir. Linux’ta şunu kontrol edin:

# Heartbeat process'ine ICMP için gerekli capability ver
sudo setcap cap_net_raw+eip /usr/share/heartbeat/heartbeat

# Ya da systemd override ile
sudo systemctl edit heartbeat-elastic
# [Service]
# AmbientCapabilities=CAP_NET_RAW

SSL Sertifika İzleme

Heartbeat’in en sevdiğim özelliklerinden biri SSL sertifika takibi. Sertifika süresi dolmadan uyarı almak için ekstra bir araç gerekmez:

- type: http
  id: ssl-certificate-monitor
  name: "SSL Sertifika Kontrolü"
  schedule: "@every 12h"
  hosts:
    - "https://www.sirket.com.tr"
    - "https://api.sirket.com.tr"
    - "https://panel.sirket.com.tr"
  check.response:
    status: [200, 301, 302]
  ssl.verification_mode: full
  timeout: 10s
  tags: ["ssl", "certificate"]

Kibana’da tls.certificate_not_valid_after alanını kullanarak sertifika bitiş tarihine göre alarm oluşturabilirsiniz. 30 gün, 14 gün ve 7 gün öncesinde farklı severity seviyelerinde uyarı almak iyi bir pratik.

Kibana’da Uptime Uygulaması

Heartbeat verilerini görselleştirmek için Kibana’nın yerleşik Uptime uygulaması var. Önce index pattern’ı oluşturmanız gerekiyor:

# Heartbeat index template'ini Elasticsearch'e yükle
heartbeat setup --index-management -E output.logstash.enabled=false 
  -E 'output.elasticsearch.hosts=["https://elasticsearch:9200"]' 
  -E 'output.elasticsearch.username=elastic' 
  -E "output.elasticsearch.password=${ELASTIC_PASS}" 
  -E 'output.elasticsearch.ssl.certificate_authorities=["/etc/heartbeat/certs/ca.crt"]'

Kibana Uptime bölümünde (/app/uptime) monitor’larınızı göreceksiniz. Buradan her monitor için:

Availability: Son 24 saat, 7 gün, 30 günlük uptime yüzdesi
Duration trends: Cevap süresi trendi
Status history: Geçmişteki down/up olayları
TLS bilgisi: Sertifika detayları ve kalan süre

Elasticsearch’te Veri Analizi

Ham veriye Elasticsearch üzerinden de bakabilirsiniz. Bazı faydalı sorgular:

# Son 1 saatte down olan monitörler
curl -X GET "https://elasticsearch:9200/heartbeat-*/_search" 
  -H 'Content-Type: application/json' 
  -u elastic:$ELASTIC_PASS 
  -d '{
    "query": {
      "bool": {
        "must": [
          {"term": {"monitor.status": "down"}},
          {"range": {"@timestamp": {"gte": "now-1h"}}}
        ]
      }
    },
    "aggs": {
      "down_monitors": {
        "terms": {
          "field": "monitor.name",
          "size": 20
        }
      }
    }
  }'

# Yavaş cevap veren servisler (500ms üzeri)
curl -X GET "https://elasticsearch:9200/heartbeat-*/_search" 
  -H 'Content-Type: application/json' 
  -u elastic:$ELASTIC_PASS 
  -d '{
    "query": {
      "bool": {
        "must": [
          {"term": {"monitor.status": "up"}},
          {"range": {
            "monitor.duration.us": {"gte": 500000}
          }},
          {"range": {"@timestamp": {"gte": "now-15m"}}}
        ]
      }
    },
    "_source": ["monitor.name", "monitor.duration.us", "url.full", "@timestamp"],
    "sort": [{"monitor.duration.us": {"order": "desc"}}],
    "size": 10
  }'

Kibana Alerting ile Alarm Kurulumu

Burada işler ilginçleşiyor. Kibana’nın Alerting (Stack Rules) özelliği ile Heartbeat verilerine dayalı otomatik bildirimler kurabilirsiniz.

Kibana Arayüzü: Management > Stack Management > Rules and Connectors

Önce bir connector oluşturun. Örneğin Slack için:

{
  "connector_type_id": ".slack",
  "name": "Slack Ops Channel",
  "config": {
    "webhookUrl": "https://hooks.slack.com/services/xxx/yyy/zzz"
  }
}

Sonra bir Uptime rule ekleyin:

Rule type: Uptime TLS veya Uptime monitor status
Monitor status rule için: belirli monitörler down duruma geçtiğinde tetiklensin
Check every: 1 dakika
Notify when: Monitor down olduğunda, durumu değiştiğinde veya hala down olduğunda ayrı ayrı ayarlanabilir

Kibana UI yerine API üzerinden rule oluşturmak için:

curl -X POST "https://kibana:5601/api/alerting/rule" 
  -H 'Content-Type: application/json' 
  -H 'kbn-xsrf: true' 
  -u elastic:$ELASTIC_PASS 
  -d '{
    "name": "Kritik Servisler Down Alarm",
    "rule_type_id": "xpack.uptime.alerts.monitorStatus",
    "consumer": "uptime",
    "schedule": {"interval": "1m"},
    "params": {
      "numTimes": 3,
      "timerangeCount": 15,
      "timerangeUnit": "m",
      "filters": {
        "tags": [["critical"]]
      },
      "shouldCheckStatus": true,
      "shouldCheckAvailability": true,
      "availability": {
        "range": 30,
        "rangeUnit": "d",
        "threshold": "99.9"
      }
    },
    "actions": [{
      "id": "slack-connector-id",
      "group": "xpack.uptime.alerts.actionGroups.monitorStatus",
      "params": {
        "message": "ALARM: {{context.monitorName}} servisi DOWN durumunda! URL: {{context.monitorUrl}}"
      }
    }]
  }'

Watchers ile Gelişmiş Alarm Senaryoları

Kibana Alerting yetmediği durumlarda Elasticsearch Watcher’ı devreye sokabilirsiniz. Örneğin “son 5 dakikada 3’ten fazla farklı servis down olduysa kritik alarm gönder” gibi karmaşık senaryolar için:

curl -X PUT "https://elasticsearch:9200/_watcher/watch/multi-service-down" 
  -H 'Content-Type: application/json' 
  -u elastic:$ELASTIC_PASS 
  -d '{
    "trigger": {
      "schedule": {"interval": "2m"}
    },
    "input": {
      "search": {
        "request": {
          "indices": ["heartbeat-*"],
          "body": {
            "query": {
              "bool": {
                "must": [
                  {"term": {"monitor.status": "down"}},
                  {"range": {"@timestamp": {"gte": "now-5m"}}}
                ]
              }
            },
            "aggs": {
              "unique_down": {
                "cardinality": {"field": "monitor.id"}
              }
            },
            "size": 0
          }
        }
      }
    },
    "condition": {
      "compare": {
        "ctx.payload.aggregations.unique_down.value": {
          "gte": 3
        }
      }
    },
    "actions": {
      "send_email": {
        "email": {
          "to": ["[email protected]"],
          "subject": "KRİTİK: Çoklu servis kesintisi tespit edildi",
          "body": {
            "text": "Son 5 dakikada {{ctx.payload.aggregations.unique_down.value}} farklı servis down durumunda. Lütfen acilen kontrol edin."
          }
        }
      }
    }
  }'

Gerçek Dünya: Deployment Sürecinde Heartbeat Kullanımı

Pratik bir senaryo paylaşayım. Deployment sonrası servislerin tam olarak ayağa kalktığından emin olmak için CI/CD pipeline’ınıza Heartbeat kontrolü ekleyebilirsiniz:

#!/bin/bash
# post-deploy-check.sh

ELASTICSEARCH_URL="https://elasticsearch:9200"
MONITOR_ID="ecommerce-api"
MAX_WAIT=120
INTERVAL=10
ELAPSED=0

echo "Deployment sonrası servis kontrolü başlıyor..."

while [ $ELAPSED -lt $MAX_WAIT ]; do
  STATUS=$(curl -s -u "elastic:${ELASTIC_PASS}" 
    "${ELASTICSEARCH_URL}/heartbeat-*/_search" 
    -H 'Content-Type: application/json' 
    -d "{
      "query": {
        "bool": {
          "must": [
            {"term": {"monitor.id": "${MONITOR_ID}"}},
            {"range": {"@timestamp": {"gte": "now-30s"}}}
          ]
        }
      },
      "sort": [{"@timestamp": {"order": "desc"}}],
      "size": 1
    }" | jq -r '.hits.hits[0]._source.monitor.status' 2>/dev/null)

  if [ "$STATUS" = "up" ]; then
    echo "Servis UP durumunda. Deployment başarılı."
    exit 0
  fi

  echo "Servis henüz hazır değil (durum: ${STATUS}). ${INTERVAL}s bekleniyor..."
  sleep $INTERVAL
  ELAPSED=$((ELAPSED + INTERVAL))
done

echo "HATA: Servis ${MAX_WAIT} saniye içinde UP durumuna geçmedi!"
exit 1

Heartbeat’i Kubernetes’te Çalıştırma

Kubernetes ortamında Heartbeat’i DaemonSet yerine Deployment olarak çalıştırmak genellikle daha mantıklı:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: heartbeat
  namespace: monitoring
spec:
  replicas: 2
  selector:
    matchLabels:
      app: heartbeat
  template:
    metadata:
      labels:
        app: heartbeat
    spec:
      containers:
      - name: heartbeat
        image: docker.elastic.co/beats/heartbeat:8.11.0
        args: ["-c", "/etc/heartbeat/heartbeat.yml", "-e"]
        env:
        - name: ELASTICSEARCH_HOST
          value: "https://elasticsearch:9200"
        - name: HEARTBEAT_ES_PASS
          valueFrom:
            secretKeyRef:
              name: heartbeat-secrets
              key: elasticsearch-password
        volumeMounts:
        - name: config
          mountPath: /etc/heartbeat
          readOnly: true
        securityContext:
          capabilities:
            add:
            - NET_RAW
      volumes:
      - name: config
        configMap:
          name: heartbeat-config

Performans ve Ölçeklendirme Notları

Çok sayıda monitor tanımladığınızda dikkat etmeniz gereken birkaç şey var:

scheduler.limit: Eş zamanlı çalışabilecek maksimum monitor sayısını kontrol eder. Varsayılan 0 yani sınırsız, ama büyük ortamlarda bunu sınırlamak iyi olabilir.
HTTP timeout değerleri: Çok düşük timeout koyarsanız yanlış alarm üretirsiniz. Ağ gecikmesini hesaba katın.
Schedule sıklığı: Her şeyi 10 saniyede bir kontrol etmek gerekmez. Kritiklik seviyesine göre farklılaştırın.
Index rollover: Heartbeat yoğun veri üretir. ILM policy ile eski verileri hot-warm-cold mimarisine göre yönetin.

# Heartbeat'in kaç monitor çalıştırdığını kontrol et
curl -s "https://elasticsearch:9200/heartbeat-*/_search" 
  -H 'Content-Type: application/json' 
  -u elastic:$ELASTIC_PASS 
  -d '{
    "aggs": {
      "monitor_count": {
        "cardinality": {"field": "monitor.id"}
      }
    },
    "size": 0
  }' | jq '.aggregations.monitor_count.value'

Sonuç

Heartbeat, ELK Stack içinde en az konuşulan ama pratik değeri açısından en yüksek bileşenlerden biri. Metrik ve log tabanlı izlemenin tamamlayıcısı olarak, dışarıdan aktif kontrol yaparak “servis gerçekten cevap veriyor mu?” sorusunu yanıtlıyor.

Kurulum basit, konfigürasyon YAML tabanlı ve okunabilir. Monitor tanımlarını monitors.d altında modüler tutarsanız yönetimi kolaylaşıyor. Kibana Uptime ile görselleştirme, Alerting ile bildirim ve Watcher ile karmaşık alarm mantıkları bir arada iyi çalışıyor.

Başlangıç için kritik HTTP endpoint’lerinizi, veritabanı portlarınızı ve SSL sertifikalarınızı izlemeye alın. Bunu oturtunca deployment sonrası kontroller, SLA raporlaması ve anomali tespiti gibi ileri senaryolara geçebilirsiniz. Ekibiniz “sistemi biz çökmeden önce müşteri mi bildiriyor?” sorusunu artık sormuyorsa, doğru yoldasınız demektir.

Heartbeat ile Uptime İzleme ve Alarm Kurulumu