Ubuntu 14.04 Sunucusunda Graphite Kurulumu ve Kullanımı

Ubuntu 14.04 Sunucusunda Graphite Kurulumu ve Kullanımı

Giriş

Günümüzün hızla değişen dijital dünyasında, sunucu ve uygulama performansını sürekli olarak izlemek, olası sorunları proaktif bir şekilde tespit etmek ve sistem davranışları hakkında derinlemesine bilgi edinmek kritik öneme sahiptir. Zaman serisi verilerini toplama, depolama ve görselleştirme yeteneği, bu ihtiyaçları karşılamanın temel taşlarından biridir. İşte tam bu noktada Graphite devreye girer.

Graphite, binlerce veya milyonlarca metrik noktasını gerçek zamanlı olarak depolayabilen, sorgulayabilen ve grafikleyebilen, açık kaynaklı, ölçeklenebilir bir izleme sistemidir. Özellikle sunucuların, ağ cihazlarının, uygulamaların ve diğer altyapı bileşenlerinin performans verilerini toplamak ve görselleştirmek için tasarlanmıştır. Bu makalede, eski ama hala birçok sistemde kullanılan Ubuntu 14.04 sunucusu üzerinde Graphite’ı nasıl kuracağınızı ve kullanacağınızı adım adım detaylı bir şekilde anlatacağız. Ubuntu 14.04’ün eski bir işletim sistemi olduğunu ve güvenlik güncellemelerini artık almadığını belirtmek önemlidir; bu nedenle üretim ortamlarında daha güncel bir işletim sistemi kullanmanız şiddetle tavsiye edilir. Ancak, bu makale özel olarak Ubuntu 14.04’e odaklanacaktır.

Graphite Nedir ve Neden Kullanılır?

Graphite, temel olarak üç ana bileşenden oluşan bir ekosistemdir:

1. Carbon: Metrik verilerini alan ve işleyen bir servis.
2. Whisper: Zaman serisi verilerini depolamak için kullanılan bir dosya tabanlı veritabanı.
3. Graphite-web: Depolanan verileri sorgulamak, grafiklemek ve görselleştirmek için kullanılan bir web arayüzü ve API.

Graphite’ın sunduğu temel faydalar şunlardır:

• Ölçeklenebilirlik: Binlerce farklı metriği ve milyonlarca veri noktasını kolayca işleyebilir ve depolayabilir.
• Esneklik: Herhangi bir uygulama veya sistemden metrik göndermek için basit bir TCP/UDP arayüzü sunar.
• Zengin Görselleştirme: Güçlü bir web arayüzü sayesinde karmaşık grafikler oluşturabilir, verileri farklı açılardan inceleyebilir ve özel panolar (dashboards) oluşturabilirsiniz.
• Açık Kaynak: Geniş bir topluluk tarafından desteklenir ve sürekli geliştirilir.
• Entegrasyon Kolaylığı: StatsD gibi araçlarla kolayca entegre olarak uygulama metriklerini toplamak için ideal bir çözümdür. Grafana gibi modern görselleştirme araçlarıyla da harika bir uyum içindedir.

Graphite Bileşenleri Detaylı İnceleme

Graphite ekosistemini daha iyi anlamak için her bir bileşenin görevlerini daha yakından inceleyelim:

1. Carbon:

   Carbon, Graphite’ın veri alım katmanıdır. Çeşitli portlar üzerinden gelen metrik verilerini dinler ve Whisper veritabanına yazar. Carbon’un temel olarak üç farklı alt bileşeni bulunur:

   • carbon-cache: Metrikleri alır, önbelleğe alır ve yapılandırılan saklama politikalarına göre Whisper dosyalarına yazar. Genellikle her Graphite sunucusunda bir tane çalışır.
   • carbon-relay: Gelen metrikleri birden fazla carbon-cache örneğine yönlendirmek için kullanılır. Bu, yatay ölçeklenebilirlik ve yüksek kullanılabilirlik sağlamak için önemlidir.
   • carbon-aggregator: Gelen metrikleri belirli kurallara göre birleştirir (örneğin, saniyede 10 metrik alıp bunları dakikada bir ortalama olarak kaydetmek). Bu, depolama alanından tasarruf etmeye ve daha yüksek seviyeli özet metrikler oluşturmaya yardımcı olur.
2. Whisper:

   Whisper, Graphite’ın özel zaman serisi veritabanı formatıdır. RRDtool’a benzer şekilde, önceden belirlenmiş boyutlarda ve sabit zaman aralıklarında veri depolayan sabit boyutlu dosyalar kullanır. Bu, disk kullanımının tahmin edilebilir olmasını sağlar ve eski verilerin otomatik olarak temizlenmesine olanak tanır. Whisper dosyaları, farklı detay seviyelerinde (örneğin, ilk 7 gün için 1 dakikalık çözünürlük, sonraki 30 gün için 5 dakikalık çözünürlük gibi) veri saklama politikalarını (retention policies) destekler.

3. Graphite-web:

   Graphite-web, Django web çerçevesi üzerine inşa edilmiş bir Python uygulamasıdır. Kullanıcıların depolanan metrik verilerini keşfetmelerini, grafikler oluşturmalarını, panolar tasarlamalarını ve verileri çeşitli formatlarda (JSON, CSV, PNG) dışa aktarmalarını sağlayan bir API ve kullanıcı arayüzü sunar. Carbon’dan gelen verileri doğrudan Whisper dosyalarından okuyarak görselleştirir.

Ön Gereksinimler ve Sistem Ayarları

Graphite kurulumuna başlamadan önce Ubuntu 14.04 sunucunuzun hazır olduğundan emin olmalısınız. Bu bölüm, gerekli paketleri kurma ve sistemi hazırlama adımlarını içerir.

Sistem Güncellemesi

Herhangi bir kuruluma başlamadan önce sistem paket listesini güncellemek ve mevcut paketleri yükseltmek iyi bir uygulamadır:

sudo apt-get update
sudo apt-get upgrade -y

Gerekli Paketlerin Kurulumu

Graphite ve bileşenlerinin çalışması için bazı temel Python kütüphanelerine, geliştirme araçlarına ve bir web sunucusuna ihtiyacımız olacak. Ubuntu 14.04 genellikle Python 2.7 ile gelir ve Graphite’ın eski sürümleri bu Python sürümünü kullanır. Python 3 desteği daha sonraki Graphite sürümlerinde eklenmiştir, ancak 14.04 için Python 2.7 tabanlı kurulum yapacağız.

sudo apt-get install -y python-dev python-pip build-essential \
libffi-dev libcairo2-dev pkg-config python-cairo apache2 libapache2-mod-wsgi

• python-dev: Python C API’sini kullanmak için gerekli olan başlık dosyalarını ve statik kütüphaneleri sağlar.
• python-pip: Python paketlerini yönetmek için kullanılan pip aracını kurar.
• build-essential: Derleme için gerekli temel paketleri (gcc, make vb.) içerir.
• libffi-dev: C kodundan Python kodunu çağırmak için kullanılan bir kütüphane olan libffi‘nin geliştirme dosyaları.
• libcairo2-dev: Cairo grafik kütüphanesinin geliştirme dosyaları. Graphite, grafik oluşturmak için Cairo’yu kullanır.
• pkg-config: Derleme sırasında kütüphanelerin konumunu ve bağımlılıklarını bulmaya yardımcı olan bir araç.
• python-cairo: Python için Cairo bağlayıcıları.
• apache2: Web sunucusu.
• libapache2-mod-wsgi: Apache’nin Python web uygulamalarını (Django gibi) çalıştırmasını sağlayan modül.

Graphite Kurulum Adımları

Artık sistemimiz hazır olduğuna göre, Graphite bileşenlerini kurmaya başlayabiliriz.

Adım 1: Python Paketlerini Kurma

Graphite bileşenlerini pip kullanarak kuracağız. Bu, en basit ve önerilen yöntemdir.

sudo pip install carbon whisper graphite-web

Bu komut, carbon, whisper ve graphite-web paketlerini sistem genelinde kuracaktır. Kurulum tamamlandığında, bu paketlerin çalıştırılabilir dosyaları genellikle /usr/local/bin dizinine, kütüphane dosyaları ise /usr/local/lib/python2.7/dist-packages dizinine yerleşir.

Adım 2: Konfigürasyon Dosyaları için Dizin Yapısı Oluşturma

pip ile kurulum, konfigürasyon dosyalarını doğrudan oluşturmaz. Bu dosyaları örneklerinden kopyalamamız ve uygun bir yere yerleştirmemiz gerekecektir. Standart bir Graphite kurulumunda konfigürasyon dosyaları genellikle /opt/graphite/conf dizininde bulunur. Ancak biz pip ile kurduğumuz için, bu dosyaları uygun bir sistem dizinine, örneğin /etc/carbon ve /etc/graphite-web‘e kopyalayacağız. Ayrıca, Whisper verileri için bir dizin ve loglar için bir dizin oluşturalım.

sudo mkdir -p /etc/carbon /etc/graphite-web
sudo mkdir -p /var/lib/graphite/whisper
sudo mkdir -p /var/log/graphite
sudo chown -R www-data:www-data /var/lib/graphite/whisper # Apache kullanıcısına yazma izni
sudo chown -R www-data:www-data /var/log/graphite # Apache kullanıcısına yazma izni

www-data kullanıcısı Apache’nin varsayılan kullanıcısıdır ve Graphite-web’in bu dizinlere erişmesi gerekecektir. Carbon servisi için de ayrı bir kullanıcı oluşturulabilir veya root ile çalıştırılabilir, ancak daha güvenli bir yöntem, Carbon için ayrı bir kullanıcı oluşturup ona izin vermektir. Bu makalede basitleştirmek adına, Carbon’un da aynı kullanıcı veya root yetkileriyle çalıştığını varsayacağız, ancak üretim ortamlarında güvenlik göz önünde bulundurulmalıdır.

Adım 3: Carbon Yapılandırması

Carbon’un yapılandırma dosyaları, carbon paketinin yüklendiği dizinde örnek olarak bulunur. Bunları /etc/carbon dizinine kopyalayalım ve düzenleyelim.

# Örnek konfigürasyon dosyalarının bulunduğu dizini bulalım
GRAPHITE_CONF_DIR=$(python -c "import carbon; print carbon.__path__[0] + '/conf'")

sudo cp $GRAPHITE_CONF_DIR/carbon.conf.example /etc/carbon/carbon.conf
sudo cp $GRAPHITE_CONF_DIR/storage-schemas.conf.example /etc/carbon/storage-schemas.conf
sudo cp $GRAPHITE_CONF_DIR/storage-aggregation.conf.example /etc/carbon/storage-aggregation.conf

carbon.conf Ayarları

Bu dosya, Carbon bileşenlerinin nasıl çalışacağını tanımlar. Varsayılan ayarlar çoğu zaman yeterli olsa da, bazı önemli parametreleri kontrol etmeliyiz.

sudo nano /etc/carbon/carbon.conf

[cache] bölümünde aşağıdaki ayarları kontrol edin:

[cache]
ENABLE_LOGGING = True
LOCAL_DATA_DIR = /var/lib/graphite/whisper
USER = www-data # Carbon servisini www-data kullanıcısı olarak çalıştırmak için (isteğe bağlı)
LINE_RECEIVER_INTERFACE = 0.0.0.0
LINE_RECEIVER_PORT = 2003
PICKLE_RECEIVER_INTERFACE = 0.0.0.0
PICKLE_RECEIVER_PORT = 2004
CACHE_QUERY_INTERFACE = 0.0.0.0
CACHE_QUERY_PORT = 7002

LOCAL_DATA_DIR‘in Whisper dosyalarının depolanacağı dizin olduğunu doğrulayın. USER ayarı, Carbon’un hangi kullanıcı altında çalışacağını belirler. Eğer Carbon’u ayrı bir kullanıcı altında çalıştırmak isterseniz, bu kullanıcıyı oluşturup buraya yazmanız ve ilgili dizinlere (/var/lib/graphite/whisper ve /var/log/graphite) yazma izinleri vermeniz gerekir. Aksi takdirde, bu satırı yorum satırı yapın ve Carbon’u root veya başka bir yetkili kullanıcı ile başlatın.

storage-schemas.conf Ayarları

Bu dosya, Whisper veritabanlarının metrikleri hangi çözünürlükte ve ne kadar süreyle saklayacağını tanımlar. Bu, Graphite’ın kalbi sayılır çünkü disk kullanımını ve veri detayını doğrudan etkiler.

sudo nano /etc/carbon/storage-schemas.conf

Varsayılan olarak birkaç örnek şema bulunur. Kendi şemanızı oluşturabilir veya mevcut olanları düzenleyebilirsiniz. Örneğin, aşağıdaki şema tüm metrikleri (name = .*) ilk 7 gün boyunca 1 dakikalık çözünürlükte ve sonraki 30 gün boyunca 5 dakikalık çözünürlükte saklayacaktır:

[carbon]
pattern = ^carbon\.
retentions = 60s:90d

[default_1min_for_7days]
pattern = .*
retentions = 60s:7d,5m:30d

Açıklama:

• pattern = .: Bu kuralın tüm metrik adlarıyla eşleştiğini belirtir. Metrik adlarını düzenli ifadelerle eşleştirebilirsiniz (örn. ^servers\.web.).
• retentions = 60s:7d,5m:30d: Bu, bir virgülle ayrılmış bir dizi saklama kuralıdır.
  • 60s:7d: Metrikleri 60 saniyelik aralıklarla (1 dakika) 7 gün boyunca sakla.
  • 5m:30d: 5 dakikalık aralıklarla 30 gün boyunca sakla. Bu, ilk 7 günden sonraki verilerin ortalamasının alınarak daha düşük çözünürlükte saklanacağı anlamına gelir.

Bu ayarları kaydedin ve kapatın.

storage-aggregation.conf Ayarları

Bu dosya, Graphite’ın farklı çözünürlük seviyelerine geçerken metrik verilerini nasıl birleştireceğini (aggregate) tanımlar. Örneğin, 1 dakikalık veriden 5 dakikalık veriye geçerken ortalama mı, toplam mı, minimum mu yoksa maksimum mu alınacağını belirtir.

sudo nano /etc/carbon/storage-aggregation.conf

Varsayılan ayarlar çoğu zaman yeterlidir. İşte bir örnek:

[min]
pattern = \.min$
xFilesFactor = 0.1
aggregationMethod = min

[max]
pattern = \.max$
xFilesFactor = 0.1
aggregationMethod = max

[sum]
pattern = \.sum$
xFilesFactor = 0
aggregationMethod = sum

[count]
pattern = \.count$
xFilesFactor = 0
aggregationMethod = sum

[default_average]
pattern = .*
xFilesFactor = 0.5
aggregationMethod = average

Açıklama:

• pattern = .*: Bu kuralın tüm metrik adlarıyla eşleştiğini belirtir.
• xFilesFactor = 0.5: Bir üst çözünürlük seviyesine geçerken, bir veri noktasının geçerli sayılabilmesi için ne kadarının (0.0 ile 1.0 arasında) mevcut olması gerektiğini belirtir. Örneğin, 0.5 ise, 5 dakikalık bir ortalama oluşturmak için en az 2.5 dakikalık veri olması gerekir.
• aggregationMethod = average: Metriklerin birleştirilmesi sırasında kullanılacak yöntemi belirtir (average, sum, min, max, last).

Bu ayarları kaydedin ve kapatın.

Adım 4: Graphite-web Yapılandırması

Graphite-web, Django tabanlı bir uygulama olduğu için kendi yapılandırma dosyalarına sahiptir. En önemli dosya local_settings.py‘dir.

local_settings.py Dosyasını Oluşturma

Örnek local_settings.py.example dosyasını kopyalayalım ve düzenleyelim. Bu dosya genellikle graphite_web paketinin içindedir.

# Örnek konfigürasyon dosyalarının bulunduğu dizini bulalım
GRAPHITE_WEB_CONF_DIR=$(python -c "import graphite.app; print graphite.app.__path__[0] + '/conf'")

sudo cp $GRAPHITE_WEB_CONF_DIR/local_settings.py.example /etc/graphite-web/local_settings.py

Şimdi bu dosyayı düzenleyelim:

sudo nano /etc/graphite-web/local_settings.py

Aşağıdaki ayarları güncelleyin:

# Bu satırı bulun ve rastgele bir anahtar değeri atayın
SECRET_KEY = 'buraya_rastgele_uzun_bir_string_yazin' # Örneğin: os.urandom(24).encode('hex') ile oluşturulabilir

Veritabanı ayarları (SQLite varsayılan olarak gelir, basit kurulum için yeterlidir)
DATABASES = {
    'default': {
        'NAME': '/var/lib/graphite/graphite.db',
        'ENGINE': 'django.db.backends.sqlite3',
        'USER': '',
        'PASSWORD': '',
        'HOST': '',
        'PORT': ''
    }
}

Zaman dilimi ayarı
TIME_ZONE = 'Europe/Istanbul' # Kendi zaman diliminize göre ayarlayın

Whisper veri dizinini belirtin
WHISPER_DIR = '/var/lib/graphite/whisper'

Log dizinini belirtin
LOG_DIR = '/var/log/graphite'

Statik dosyaların bulunduğu dizin
STATIC_ROOT = '/var/www/html/graphite/static' # Apache ile sunulacak statik dosyalar için

SECRET_KEY için güçlü, rastgele bir dize oluşturduğunuzdan emin olun. Django uygulamasının güvenliği için bu çok önemlidir. os.urandom(24).encode('hex') gibi bir Python komutuyla kolayca oluşturabilirsiniz. DATABASES ayarı varsayılan olarak SQLite kullanır; bu, küçük kurulumlar için uygundur. Üretim ortamlarında PostgreSQL veya MySQL gibi daha güçlü bir veritabanı kullanmanız önerilir. TIME_ZONE‘u kendi bölgenize göre ayarlayın. WHISPER_DIR ve LOG_DIR‘in daha önce oluşturduğumuz dizinleri işaret ettiğinden emin olun. STATIC_ROOT ise Apache’nin sunacağı statik dosyaların toplanacağı dizin olacak.

Veritabanı Başlatma ve Yönetici Oluşturma

Graphite-web’in veritabanı şemasını oluşturması ve bir yönetici kullanıcı oluşturması gerekir. Bu işlemi, Django’nun manage.py komutuyla yaparız.

# manage.py dosyasının bulunduğu dizini bulalım
GRAPHITE_WEB_APP_DIR=$(python -c "import graphite.app; print graphite.app.__path__[0]")

sudo PYTHONPATH=$GRAPHITE_WEB_APP_DIR:$GRAPHITE_WEB_CONF_DIR:$PYTHONPATH \
django-admin.py syncdb --settings=graphite.app.settings --pythonpath=$GRAPHITE_WEB_APP_DIR

Bu komut çalıştırıldığında, Django veritabanı tablolarını oluşturacak ve sizden bir yönetici kullanıcı adı, e-posta ve parola oluşturmanızı isteyecektir. Bu bilgileri web arayüzüne giriş yapmak için kullanacaksınız.

Statik Dosyaları Toplama

Django, web sunucusu tarafından doğrudan sunulacak olan tüm statik dosyaları (CSS, JavaScript, resimler) tek bir dizinde toplamanıza olanak tanır. Daha önce STATIC_ROOT olarak belirttiğimiz dizini oluşturalım ve dosyaları oraya toplayalım:

sudo mkdir -p /var/www/html/graphite/static
sudo chown -R www-data:www-data /var/www/html/graphite

sudo PYTHONPATH=$GRAPHITE_WEB_APP_DIR:$GRAPHITE_WEB_CONF_DIR:$PYTHONPATH \
django-admin.py collectstatic --noinput --settings=graphite.app.settings --pythonpath=$GRAPHITE_WEB_APP_DIR

--noinput, soruları otomatik olarak yanıtlar (örneğin, mevcut dosyaların üzerine yazma sorusu). Bu işlem tamamlandığında, Graphite-web’in statik dosyaları /var/www/html/graphite/static dizininde bulunacaktır.

Adım 5: Web Sunucusu (Apache) Yapılandırması

Graphite-web bir Django uygulaması olduğu için, bir web sunucusu (Apache veya Nginx) ve bir WSGI (Web Server Gateway Interface) sunucusu (mod_wsgi veya Gunicorn) aracılığıyla sunulması gerekir. Bu makalede Apache ve mod_wsgi kullanacağız.

graphite.wsgi Dosyasını Oluşturma

Apache’nin Graphite-web uygulamasını çalıştırması için bir WSGI dosyasına ihtiyacımız var. Bu dosyayı /etc/graphite-web/graphite.wsgi olarak oluşturalım:

sudo nano /etc/graphite-web/graphite.wsgi

İçeriği aşağıdaki gibi olmalı:

import sys
import os

Graphite-web uygulamasının kök dizini
GRAPHITE_ROOT = '/usr/local/lib/python2.7/dist-packages/graphite/app' # pip ile kurulumda bu yol olabilir
GRAPHITE_CONF = '/etc/graphite-web'

sys.path.insert(0, GRAPHITE_ROOT)
sys.path.insert(0, GRAPHITE_CONF) # local_settings.py için

os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' # Django ayarları için
os.environ['GRAPHITE_SETTINGS_MODULE'] = 'local_settings' # Graphite'ın özel ayarları için

from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()

GRAPHITE_ROOT değişkeninin, pip tarafından kurulan Graphite-web uygulamasının kök dizinini doğru bir şekilde gösterdiğinden emin olun. Genellikle /usr/local/lib/python2.7/dist-packages/graphite/app şeklindedir.

Apache Sanal Host Ayarı

Şimdi Apache için bir sanal host yapılandırması oluşturalım. Bu, Apache’nin belirli bir URL’ye gelen istekleri Graphite-web uygulamasına yönlendirmesini sağlayacaktır.

sudo nano /etc/apache2/sites-available/graphite.conf

İçeriği aşağıdaki gibi olmalı:

    ServerName your_server_ip_or_domain # Sunucunuzun IP adresi veya alan adını buraya yazın
    DocumentRoot "/var/www/html/graphite"

    # Statik dosyalar için
    Alias /static/ "/var/www/html/graphite/static/"
    
        Order deny,allow
        Allow from all
    

    # Graphite-web uygulaması için
    WSGIScriptAlias / /etc/graphite-web/graphite.wsgi
    
        Order deny,allow
        Allow from all
    

    ErrorLog ${APACHE_LOG_DIR}/graphite_error.log
    CustomLog ${APACHE_LOG_DIR}/graphite_access.log combined

ServerName‘i sunucunuzun IP adresi veya alan adıyla değiştirmeyi unutmayın. Bu yapılandırma, tüm gelen istekleri graphite.wsgi dosyasına yönlendirecek ve statik dosyaları doğrudan Apache üzerinden sunacaktır.

Apache Sitesini Etkinleştirme ve Yeniden Başlatma

Yeni sanal host yapılandırmasını etkinleştirelim ve Apache’yi yeniden başlatalım:

sudo a2ensite graphite.conf
sudo service apache2 restart

Eğer bir hata alırsanız, Apache’nin hata loglarını (/var/log/apache2/error.log veya /var/log/apache2/graphite_error.log) kontrol edin.

Adım 6: Graphite Bileşenlerini Başlatma

Carbon cache servisini başlatmamız gerekiyor. Bu servisi kalıcı hale getirmek için bir init.d betiği kullanacağız.

Carbon Cache Servisini Başlatma

Öncelikle, Carbon’un çalıştırılabilir dosyasının yolunu bulalım (genellikle /usr/local/bin/carbon-cache.py).

sudo /usr/local/bin/carbon-cache.py start

Bu komut Carbon’u başlatır, ancak sunucu yeniden başlatıldığında otomatik olarak başlamaz. Bunu sağlamak için bir init.d betiği oluşturalım.

Init Script Oluşturma (Ubuntu 14.04 için)

Aşağıdaki betiği /etc/init.d/carbon-cache olarak kaydedin:

sudo nano /etc/init.d/carbon-cache

İçeriği:

#!/bin/bash
### BEGIN INIT INFO
Provides:          carbon-cache
Required-Start:    $network $local_fs $remote_fs
Required-Stop:     $network $local_fs $remote_fs
Default-Start:     2 3 4 5
Default-Stop:      0 1 6
Short-Description: Start/stop carbon-cache
Description:       Carbon-cache daemon for Graphite
### END INIT INFO

Varsayılan değerler
NAME=carbon-cache
DAEMON=/usr/local/bin/$NAME.py # carbon-cache.py dosyasının yolu
CONF_DIR=/etc/carbon
LOG_DIR=/var/log/graphite
PID_FILE=/var/run/carbon-cache.pid
USER=www-data # Carbon'u hangi kullanıcı altında çalıştıracağınız (isteğe bağlı)

PYTHONPATH'i ayarlayın
export PYTHONPATH=/usr/local/lib/python2.7/dist-packages:$PYTHONPATH

Log dizinini ve PID dosyasının dizinini oluşturun
mkdir -p $(dirname $PID_FILE)
mkdir -p $LOG_DIR
chown -R $USER:$USER $LOG_DIR

case "$1" in
  start)
    echo "Starting $NAME..."
    start-stop-daemon --start --quiet --pidfile $PID_FILE --chuid $USER --exec $DAEMON -- --config=$CONF_DIR/carbon.conf --logdir=$LOG_DIR start
    echo "$NAME started."
    ;;
  stop)
    echo "Stopping $NAME..."
    start-stop-daemon --stop --quiet --pidfile $PID_FILE
    echo "$NAME stopped."
    ;;
  restart)
    echo "Restarting $NAME..."
    start-stop-daemon --stop --quiet --pidfile $PID_FILE
    sleep 1
    start-stop-daemon --start --quiet --pidfile $PID_FILE --chuid $USER --exec $DAEMON -- --config=$CONF_DIR/carbon.conf --logdir=$LOG_DIR start
    echo "$NAME restarted."
    ;;
  status)
    PID=$(cat $PID_FILE 2>/dev/null)
    if [ -n "$PID" ] && ps -p $PID > /dev/null; then
      echo "$NAME is running with PID $PID"
    else
      echo "$NAME is not running"
    fi
    ;;
  *)
    echo "Usage: /etc/init.d/$NAME {start|stop|restart|status}"
    exit 1
    ;;
esac

exit 0

Bu betiği kaydettikten sonra, çalıştırılabilir hale getirin ve sistem başlangıcında otomatik olarak başlaması için kaydedin:

sudo chmod +x /etc/init.d/carbon-cache
sudo update-rc.d carbon-cache defaults
sudo service carbon-cache start

sudo service carbon-cache status komutuyla Carbon’un çalıştığını doğrulayabilirsiniz. Ayrıca, /var/log/graphite/carbon-cache/carbon-cache.log dosyasını kontrol ederek herhangi bir hata olup olmadığını görebilirsiniz.

Graphite’a Veri Gönderme

Graphite’ın çalıştığından emin olduktan sonra, ona metrik verileri göndermenin zamanı geldi. Graphite, varsayılan olarak 2003 numaralı TCP portundan basit metin tabanlı metrikleri dinler.

Netcat ile Basit Bir Test

En basit test yöntemi netcat kullanmaktır. Bir metrik şu formatta gönderilir: metrik.adı değeri zaman_damgası.

echo "test.metric 42 $(date +%s)" | nc -q0 localhost 2003

Bu komut, test.metric adında, değeri 42 olan ve geçerli Unix zaman damgasına sahip bir metrik gönderir. -q0 parametresi, netcat‘in veriyi gönderdikten hemen sonra bağlantıyı kapatmasını sağlar.

Python ile Veri Gönderme

Daha programatik bir şekilde veri göndermek için basit bir Python betiği kullanabiliriz:

import socket
import time
import random

CARBON_SERVER = 'localhost'
CARBON_PORT = 2003

def send_metric(metric_name, value):
    timestamp = int(time.time())
    message = "%s %s %s\n" % (metric_name, value, timestamp)
    print "sending message:\n%s" % message
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.connect((CARBON_SERVER, CARBON_PORT))
        sock.sendall(message)
    except Exception as e:
        print "Error sending data: %s" % e
    finally:
        sock.close()

if __name__ == '__main__':
    while True:
        # Rastgele bir CPU kullanımı metriği gönderelim
        cpu_usage = random.uniform(0, 100)
        send_metric("server.ubuntu1404.cpu.usage", cpu_usage)

        # Rastgele bir bellek kullanımı metriği gönderelim
        mem_usage = random.uniform(20, 80)
        send_metric("server.ubuntu1404.memory.usage", mem_usage)

        time.sleep(5) # Her 5 saniyede bir veri gönder

Bu betiği bir dosyaya kaydedip (örn. send_metrics.py) çalıştırarak (python send_metrics.py), Graphite’a sürekli olarak örnek veriler gönderebilirsiniz.

StatsD ile Entegrasyon: Gerçek dünya uygulamalarında, metrikleri doğrudan Graphite’a göndermek yerine genellikle StatsD gibi bir aracı kullanılır. StatsD, uygulama metriklerini toplar, toplar ve belirli aralıklarla Graphite’a gönderir. Bu, uygulama tarafındaki yükü azaltır ve metrik gönderme işlemini basitleştirir.

Graphite Web Arayüzünü Kullanma

Artık metrikleriniz Graphite’a akmaya başladığına göre, web arayüzünü kullanarak bunları görselleştirebilirsiniz.

Web Arayüzüne Erişim

Web tarayıcınızı açın ve sunucunuzun IP adresine veya alan adına gidin (örn. http://your_server_ip/). Graphite-web giriş ekranını görmelisiniz. Daha önce syncdb komutuyla oluşturduğunuz yönetici kullanıcı adı ve şifrenizle giriş yapın.

Grafik Oluşturma ve Keşfetme

Giriş yaptıktan sonra, sol tarafta bir metrik ağacı (metric tree) göreceksiniz. Gönderdiğiniz metrikler (örn. test.metric veya server.ubuntu1404.cpu.usage) burada hiyerarşik bir yapıda listelenmelidir. Metrik ağacından bir veya daha fazla metrik seçerek sağ taraftaki panelde anında bir grafik oluşturabilirsiniz.

Graphite’ın web arayüzü, grafiklerinizi özelleştirmek için zengin işlevler sunar:

• Grafik Fonksiyonları: Grafiğin altındaki “Functions” menüsünden çeşitli fonksiyonları uygulayabilirsiniz (örn. sumSeries(), averageSeries(), scale(), derivative()). Bu fonksiyonlar, verileri dönüştürmenize, birleştirmenize veya farklı şekillerde analiz etmenize olanak tanır.
• Zaman Aralığı: Grafiğin üst kısmındaki zaman aralığı seçicileri kullanarak verileri farklı zaman dilimlerinde (son 1 saat, son 24 saat, son 7 gün vb.) görüntüleyebilirsiniz.
• Görsel Ayarlar: Grafiğin başlığını, eksen etiketlerini, renkleri ve diğer görsel özelliklerini ayarlayabilirsiniz.
• Stacking: Birden fazla metrik serisini üst üste yığarak toplam değeri görselleştirebilirsiniz.

Panelleri Kaydetme

Oluşturduğunuz grafikleri daha sonra kolayca erişmek için panolara (dashboards) kaydedebilirsiniz. “Save” butonuna tıklayarak mevcut grafiği bir pano olarak kaydedebilir veya mevcut bir panoya ekleyebilirsiniz. Bu, farklı sistemler veya uygulamalar için özel izleme panoları oluşturmanıza olanak tanır.

İleri Düzey Kullanım ve İpuçları

Graphite’ın temel kurulumu ve kullanımı basit olsa da, daha karmaşık senaryolar ve üretim ortamları için bazı ileri düzey konuları göz önünde bulundurmak önemlidir:

• Veritabanı Seçimi (PostgreSQL/MySQL): Basit kurulumlar için SQLite yeterli olsa da, Graphite-web’in meta verilerini depolamak için üretim ortamlarında PostgreSQL veya MySQL gibi daha güçlü, ölçeklenebilir ve yedeklenebilir bir veritabanı kullanılması şiddetle tavsiye edilir.
• Carbon Kümelemesi (Relay, Aggregator): Yüksek hacimli metrikler için tek bir carbon-cache örneği yetersiz kalabilir. carbon-relay kullanarak metrikleri birden fazla carbon-cache sunucusuna dağıtabilir, carbon-aggregator ile de metrikleri daha düşük çözünürlüklere indirgeyerek depolama maliyetlerini optimize edebilirsiniz.
• Grafana Entegrasyonu: Graphite’ın kendi web arayüzü işlevsel olsa da, Grafana çok daha modern, esnek ve özellik açısından zengin bir görselleştirme aracıdır. Grafana, Graphite’ı bir veri kaynağı olarak kullanarak çok daha etkileyici ve interaktif panolar oluşturmanıza olanak tanır. Çoğu modern Graphite kurulumu, görselleştirme katmanı olarak Grafana’yı tercih eder.
• Graphite’ın Kendini İzlemesi: Carbon ve Graphite-web’in kendi performans metriklerini de Graphite’a göndermesini sağlayarak izleme sisteminizin sağlığını izleyebilirsiniz.
• Yedekleme Stratejileri: Whisper dosyaları ve Graphite-web veritabanı (graphite.db veya PostgreSQL/MySQL) düzenli olarak yedeklenmelidir. Whisper dosyaları sabit boyutlu olduğu için, dizini kopyalamak yeterlidir.
• Sistem Kaynakları: Graphite, özellikle yüksek metrik hacimlerinde CPU, bellek ve disk I/O yoğun bir uygulama olabilir. Sunucunuzun yeterli kaynaklara sahip olduğundan emin olun ve performansı izleyin.

Sorun Giderme

Kurulum veya kullanım sırasında sorunlarla karşılaşmanız durumunda aşağıdaki adımları izleyebilirsiniz:

• Log Dosyalarını Kontrol Etme:
  • Carbon logları: /var/log/graphite/carbon-cache/carbon-cache.log
  • Apache logları: /var/log/apache2/error.log ve /var/log/apache2/graphite_error.log
  • Graphite-web logları: /var/log/graphite/webapp.log (eğer local_settings.py‘de etkinleştirildi ve doğru ayarlandıysa)

  Bu log dosyaları, hataların nedenini anlamak için en iyi başlangıç noktasıdır.