Netdata ile Docker Konteyner İzleme

Bykomut

Docker konteynerlerini izlemek, birçok sysadmin’in başını ağrıtan konulardan biri. Klasik sistem izleme araçları konteynerleri tam anlamıyla kavrayamıyor, her konteynerin kendi kaynak tüketimini, ağ trafiğini ve disk I/O’sunu ayrı ayrı görmek istiyorsun ama araçlar sana sunucunun genel görünümünü veriyor. İşte tam bu noktada Netdata devreye giriyor ve Docker dünyası için gerçekten etkileyici bir izleme deneyimi sunuyor.

Bu yazıda Netdata’yı Docker ortamında nasıl kullanacağını, konteyner metriklerini nasıl toplayacağını ve production ortamında işe yarar alarm kuralları nasıl yazacağını adım adım ele alacağız.

Netdata’nın Docker İzleme Mimarisi

Netdata, Docker konteynerlerini izlemek için birkaç farklı yöntem kullanıyor. Bunların en önemlisi cgroups entegrasyonu. Linux çekirdeğinin konteyner kaynak yönetimi için kullandığı cgroup dosya sistemi üzerinden Netdata, her konteynerin CPU, RAM, disk ve ağ kullanımını milisaniyeler içinde örnekleyebiliyor.

Netdata’yı bir Docker konteyneri olarak çalıştırıyorsan, host sistemin cgroup bilgilerine erişebilmesi için birkaç özel mount point gerekiyor. Eğer doğrudan host’a kuruyorsan bu sorun zaten yok, ama konteyner olarak çalıştırma senaryosu daha yaygın.

Netdata’yı Docker ile Çalıştırma

En yaygın kullanım şekli Netdata’yı Docker konteyneri olarak başlatmak. Aşağıdaki docker-compose dosyası production ortamı için makul bir başlangıç noktası:

cat > docker-compose.yml << 'EOF'
version: '3.8'
services:
  netdata:
    image: netdata/netdata:latest
    container_name: netdata
    hostname: prod-server-01
    pid: host
    network_mode: host
    restart: unless-stopped
    cap_add:
      - SYS_PTRACE
      - SYS_ADMIN
    security_opt:
      - apparmor:unconfined
    volumes:
      - netdataconfig:/etc/netdata
      - netdatalib:/var/lib/netdata
      - netdatacache:/var/cache/netdata
      - /etc/passwd:/host/etc/passwd:ro
      - /etc/group:/host/etc/group:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - NETDATA_CLAIM_TOKEN=
      - NETDATA_CLAIM_URL=https://app.netdata.cloud
      - NETDATA_CLAIM_ROOMS=
volumes:
  netdataconfig:
  netdatalib:
  netdatacache:
EOF

docker-compose up -d

Burada dikkat etmesi gereken birkaç nokta var:

  • /var/run/docker.sock: Netdata’nın Docker API’sine erişmesi ve konteyner isimlerini, labellarını okuması için şart
  • pid: host: Proses izleme için host PID namespace’ine erişim
  • /proc ve /sys: Kernel seviyesi metriklere erişim için
  • SYS_ADMIN: cgroup v2 okuma için gerekli capability

Docker Plugin Konfigürasyonu

Netdata’nın Docker izleme yeteneklerinin büyük kısmı go.d.plugin altındaki docker modülü üzerinden geliyor. Bu modülü aktif edip konfigüre etmek için önce config dosyasına erişmemiz gerekiyor:

# Netdata konfigürasyon dizinine git
docker exec -it netdata bash

# Plugin konfigürasyonunu düzenle
cd /etc/netdata
./edit-config go.d/docker.conf

Eğer host kurulumundaysan direkt erişebilirsin:

# go.d.plugin docker modülü konfigürasyonu
cat > /etc/netdata/go.d/docker.conf << 'EOF'
jobs:
  - name: local
    address: 'unix:///var/run/docker.sock'
    collect_container_size: yes
    
  # Uzak Docker host izleme (TCP socket açıksa)
  - name: remote-docker
    address: 'tcp://192.168.1.50:2376'
    timeout: 10
EOF

Bu konfigürasyonla Netdata her konteynerin şu metriklerini topluyor:

  • CPU kullanımı: Her konteyner için ayrı ayrı, hem kullanıcı hem kernel space
  • Bellek kullanımı: RSS, cache, swap dahil detaylı breakdown
  • Ağ I/O: Her ağ arayüzü için gelen/giden trafik
  • Blok I/O: Disk okuma/yazma operasyonları
  • Konteyner durumu: Running, stopped, paused, dead

Gerçek Dünya Senaryosu: Prodüksiyonda Konteyner Kaynak Sızıntısı Tespiti

Geçen ay bir müşterinin production ortamında ilginç bir sorunla karşılaştım. Gece yarısı bazı mikroservisler yavaşlamaya başlıyor, sabah restart atılınca düzeliyor, ama kimse sebebini bulamıyor. Klasik “gece yeniden başlatma” anti-pattern’i.

Netdata’nın konteyner izleme grafikleri üç günlük veriyi incelediğimde şunu gördüm: bir Java mikroservisi konteyneri her gece saat 02:00-03:00 arasında bellek kullanımını düzenli olarak %15 artırıyordu. Her restart’ta sıfırlanıyor, ama bir sonraki geceye kadar tekrar birikiyor. Klasik heap leak senaryosu.

Bu tür bir tespiti yapmak için Netdata’nın alarm sistemini kurmak işleri çok kolaylaştırıyor:

# /etc/netdata/health.d/docker-containers.conf
cat > /etc/netdata/health.d/docker-containers.conf << 'EOF'
# Konteyner bellek kullanımı alarm kuralı
template: docker_container_mem_usage_high
      on: docker.container_mem_usage_percentage
   class: Utilization
    type: Docker Container
component: Memory
      os: linux
   hosts: *
  lookup: average -5m unaligned
    calc: $this
   units: %
   every: 1m
    warn: $this > 80
    crit: $this > 95
   delay: down 5m multiplier 1.5 max 1h
    info: Docker container memory utilization
      to: sysadmin

# Konteyner CPU spike alarm kuralı
template: docker_container_cpu_spike
      on: docker.container_cpu_utilization
   class: Utilization
    type: Docker Container
component: CPU
      os: linux
   hosts: *
  lookup: average -2m unaligned
    calc: $this
   units: %
   every: 30s
    warn: $this > 85
    crit: $this > 95
   delay: down 10m multiplier 1.5 max 2h
    info: Docker container CPU utilization spike
      to: sysadmin
EOF

cAdvisor Entegrasyonu ile Daha Derin Metrikler

Bazı ortamlarda Netdata’nın built-in Docker entegrasyonu yetmeyebilir. Bu durumda Google’ın cAdvisor aracını Netdata ile birlikte kullanmak mükemmel bir kombinasyon oluyor. cAdvisor daha granüler konteyner metrikleri sağlıyor ve Netdata bunu Prometheus formatından okuyabiliyor:

# docker-compose.yml'e cAdvisor ekle
cat >> docker-compose.yml << 'EOF'
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    restart: unless-stopped
    privileged: true
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
    ports:
      - "8080:8080"
    devices:
      - /dev/kmsg
EOF

Netdata’ya cAdvisor metriklerini çekecek Prometheus scrape konfigürasyonu eklemek için:

# /etc/netdata/go.d/prometheus.conf
cat > /etc/netdata/go.d/prometheus.conf << 'EOF'
jobs:
  - name: cadvisor
    url: http://cadvisor:8080/metrics
    max_time_series: 2000
    max_time_series_per_metric: 200
    
    selector:
      allow:
        - container_cpu_usage_seconds_total
        - container_memory_usage_bytes
        - container_memory_working_set_bytes
        - container_network_receive_bytes_total
        - container_network_transmit_bytes_total
        - container_fs_reads_bytes_total
        - container_fs_writes_bytes_total
        - container_oom_events_total
EOF

container_oom_events_total metriği özellikle kritik. OOM killer bir konteyneri öldürdüğünde bunu anında görmek, “konteyner neden restart attı” sorusunun cevabını verir.

Konteyner Label’larına Göre Gruplama ve Filtreleme

Production ortamında onlarca belki yüzlerce konteyner çalışıyor olabilir. Hepsini aynı ekranda görmek yerine, Docker label’larını kullanarak mantıklı gruplamalar yapabilirsin. Bu yaklaşım özellikle mikroservis mimarisinde çok işe yarıyor.

# docker-compose servislerine izleme label'ları ekle
version: '3.8'
services:
  api-gateway:
    image: nginx:latest
    labels:
      - "netdata.service=api-gateway"
      - "netdata.team=platform"
      - "netdata.tier=critical"
      - "netdata.alert-threshold-cpu=70"
      
  user-service:
    image: myapp/user-service:latest
    labels:
      - "netdata.service=user-service"
      - "netdata.team=backend"
      - "netdata.tier=high"
      
  background-worker:
    image: myapp/worker:latest
    labels:
      - "netdata.service=background-worker"
      - "netdata.team=backend"
      - "netdata.tier=medium"

Netdata bu label’ları otomatik olarak okuyor ve dashboard’da konteyner bazlı gruplamayı bu bilgilerle zenginleştiriyor.

Konteyner Sağlık Kontrolü Entegrasyonu

Docker’ın kendi healthcheck mekanizması ile Netdata’yı entegre etmek, servis seviyesi izleme için güçlü bir kombinasyon sunuyor:

# Dockerfile'da healthcheck tanımla
FROM node:18-alpine
WORKDIR /app
COPY . .
RUN npm ci --production

HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 
  CMD wget -qO- http://localhost:3000/health || exit 1

CMD ["node", "server.js"]

Bu healthcheck durumunu Netdata üzerinden izlemek için custom bir script yazabilirsin:

#!/bin/bash
# /etc/netdata/custom-plugins.d/docker-health.sh

# Çalışan tüm konteynerlerin health durumunu kontrol et
UNHEALTHY_COUNT=0
TOTAL_COUNT=0

while IFS= read -r container; do
    TOTAL_COUNT=$((TOTAL_COUNT + 1))
    HEALTH=$(docker inspect --format='{{.State.Health.Status}}' "$container" 2>/dev/null)
    
    if [ "$HEALTH" = "unhealthy" ]; then
        UNHEALTHY_COUNT=$((UNHEALTHY_COUNT + 1))
        echo "UNHEALTHY_CONTAINER: $container" >&2
    fi
done < <(docker ps --format '{{.Names}}')

# Netdata custom metric formatında yaz
echo "CHART docker.health '' 'Container Health Status' 'containers' docker docker area"
echo "DIMENSION unhealthy '' absolute 1 1"
echo "DIMENSION healthy '' absolute 1 1"
echo "BEGIN docker.health"
echo "SET unhealthy = $UNHEALTHY_COUNT"
echo "SET healthy = $((TOTAL_COUNT - UNHEALTHY_COUNT))"
echo "END"

Bu scripti Netdata’nın charts.d veya external plugins sistemiyle entegre etmek için:

# Script'e çalıştırma izni ver
chmod +x /etc/netdata/custom-plugins.d/docker-health.sh

# Netdata'ya bu plugini kullan diyoruz
cat >> /etc/netdata/netdata.conf << 'EOF'
[plugin:charts.d]
    command options = 
    
[plugin:external_exporter.docker-health]
    update every = 30
    command = /etc/netdata/custom-plugins.d/docker-health.sh
EOF

# Netdata'yı yeniden başlat
systemctl restart netdata
# ya da Docker kullanıyorsan:
docker restart netdata

Log Entegrasyonu ve Anomali Tespiti

Netdata sadece sayısal metrikler toplamakla kalmıyor, log tabanlı anomali tespiti için de kullanılabiliyor. Docker konteyner loglarındaki hata oranlarını izlemek için Netdata’nın go.d/docker_engine modülü ve özel log parsing kombinasyonu işe yarıyor:

# /etc/netdata/go.d/docker_engine.conf
cat > /etc/netdata/go.d/docker_engine.conf << 'EOF'
jobs:
  - name: local
    url: http://127.0.0.1:2375/metrics
    
  # Docker daemon metrics endpoint
  - name: docker-daemon
    url: unix:///var/run/docker.sock
EOF

Konteyner log hata sayısını izleyen özel alarm kuralı:

# /etc/netdata/health.d/docker-logs.conf
cat > /etc/netdata/health.d/docker-logs.conf << 'EOF'
# Docker konteyner restart sayısı
template: docker_container_restarts
      on: docker.container_restarts
   class: Errors
    type: Docker Container
component: Availability
      os: linux
   hosts: *
  lookup: sum -5m unaligned
    calc: $this
   units: restarts
   every: 1m
    warn: $this >= 3
    crit: $this >= 10
   delay: down 15m multiplier 1.2 max 2h
    info: Docker container restart count in last 5 minutes
      to: sysadmin

# Konteyner tamamen down olma durumu
template: docker_container_down
      on: docker.container_status
   class: Availability
    type: Docker Container
component: Uptime
      os: linux
   hosts: *
  lookup: min -1m unaligned
    calc: $this
   units: status
   every: 30s
    crit: $this == 0
   delay: down 5m
    info: Docker container is not running
      to: sysadmin
EOF

Netdata Cloud ile Merkezi İzleme

Birden fazla sunucuda Docker konteyner çalıştırıyorsan, Netdata Cloud ile hepsini tek bir ekrandan yönetmek büyük kolaylık sağlıyor. Claim işlemi için:

# Netdata agent'ı cloud'a bağla
netdata-claim.sh 
  -token=SENIN_CLAIM_TOKEN 
  -rooms=ROOM_ID 
  -url=https://app.netdata.cloud

# Docker kurulumundaysa:
docker exec netdata netdata-claim.sh 
  -token=SENIN_CLAIM_TOKEN 
  -rooms=ROOM_ID 
  -url=https://app.netdata.cloud

Production ortamında birden fazla host arasında composite charts kullanarak tüm sunucularının Docker konteyner CPU toplamını tek grafik üzerinde karşılaştırabilirsin. Bu özellikle auto-scaling yapılan ortamlarda hangi hostun ne kadar yük aldığını görmek için kritik.

Performans Tuning: Netdata’nın Kendi Kaynak Kullanımını Optimize Etme

Yüzlerce konteyner izliyorsan Netdata’nın kendisi de hatırı sayılır kaynak tüketebilir. Bunu optimize etmek için birkaç ayar:

# /etc/netdata/netdata.conf optimizasyon ayarları
cat >> /etc/netdata/netdata.conf << 'EOF'
[global]
    # Veri saklama süresi - ihtiyaca göre ayarla
    history = 3600
    
    # Update sıklığı - 1 saniye production için çoğu zaman yeterli
    update every = 1
    
    # Bellek modu - ram, save, map, none
    memory mode = save
    
[db]
    # Tier bazlı depolama - eski veriler daha az granüler saklanır
    mode = dbengine
    
    # Tier 0: Son 1 saat, 1 saniyelik çözünürlük
    dbengine page cache size MB = 32
    
    # Tier 1: Son 24 saat, 60 saniyelik çözünürlük
    dbengine tier 1 page cache size MB = 16

[plugins]
    # Kullanmadığın plugin'leri kapat
    apps = yes
    cgroups = yes
    diskspace = yes
    proc = yes
    python.d = no
    node.d = no
    
[cgroups]
    # Çok fazla konteyner varsa bu değerleri artır
    max cgroups monitored = 500
    max cgroups depth monitored = 0
EOF

Grafana ile Netdata Metriklerini Görselleştirme

Netdata’nın kendi arayüzü güçlü olsa da, bazı ekiplerin Grafana’yı tercih ettiğini biliyorum. Netdata, Prometheus formatında metrik export ediyor ve Grafana’ya kolayca bağlanabiliyor:

# Netdata Prometheus exporter endpoint'i aktifleştir
cat > /etc/netdata/go.d/prometheus.conf << 'EOF'
# Bu konfigürasyon Netdata'nın kendi metriklerini
# Prometheus'a push etmesi için değil,
# diğer Prometheus metriklerini çekmesi içindir.
EOF

# Netdata kendi metriklerini /api/v1/allmetrics endpoint'inden sunar
# Prometheus scrape konfigürasyonu:
cat >> /etc/prometheus/prometheus.yml << 'EOF'
scrape_configs:
  - job_name: 'netdata'
    metrics_path: '/api/v1/allmetrics'
    params:
      format: [prometheus_all_hosts]
    honor_labels: true
    static_configs:
      - targets: ['netdata:19999']
EOF

Sonuç

Netdata ile Docker konteyner izleme, doğru kurulup konfigüre edildiğinde production ortamında gerçekten hayat kurtarıcı oluyor. Özellikle şu noktalarda değer katıyor:

  • Anlık görünürlük: Konteyner bazlı CPU, RAM ve ağ metriklerini saniye altı gecikmeyle görme
  • OOM killer tespiti: Konteynerin neden restart attığını log karıştırmadan anlama
  • Kaynak sızıntısı tespiti: Bellek veya CPU’nun yavaş yavaş tükenen pattern’lerini yakalama
  • Multi-host izleme: Onlarca sunucudaki yüzlerce konteyneri tek ekrandan yönetme

Başlangıç için en önemli adımlar: docker.sock’u doğru mount etmek, cgroup erişimlerini vermek ve makul alarm eşikleri belirlemek. Geri kalan her şey zamanla fine-tune edilebilir.

Kendi ortamında farklı bir izleme sorunu yaşıyorsan veya bu konfigürasyonların herhangi birinde takılıp kaldıysan, yorum bırakabilirsin. Netdata topluluğu da oldukça aktif, GitHub Issues ve Discord kanalında çoğu soruya hızla yanıt bulabilirsin.

Benzer Konular

Bir yanıt yazın

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