Sunucu Kurmadan Model Kullanma: Hugging Face Inference API

Yazar:komut.io ekibi
0 Yorum

Bir yapay zeka modelini kullanmak istediğinizde aklınıza gelen ilk şey muhtemelen “bunu çalıştırmak için ne kadar RAM/GPU’ya ihtiyacım var?” sorusudur. Llama 3’ü deneyeyim dersiniz, 16GB GPU belleği yetmez. Mistral’i indireyim dersiniz, quantization ayarlarıyla boğuşursunuz. Peki ya hiç sunucu kurmadan, tek bir HTTP isteğiyle bu modelleri kullanabilseydiniz? Hugging Face Inference API tam olarak bunu sağlıyor. Bu yazıda, Inference API’yi sysadmin bakış açısıyla ele alacağız; otomasyon scriptleri, monitoring entegrasyonları ve gerçek dünya kullanım senaryolarıyla birlikte.

Inference API Nedir, Ne Değildir?

Hugging Face Inference API, Hugging Face Hub’daki binlerce modeli REST API üzerinden kullanmanıza olanak tanıyan bir servis. Siz sadece HTTP POST isteği atıyorsunuz, model inference’ı Hugging Face’in altyapısında çalışıyor ve sonucu alıyorsunuz.

Ne değildir konusunda da net olmak gerekiyor:

  • Sınırsız ücretsiz kullanım sunmaz. Free tier mevcut ama rate limit ve bazı kısıtlamalar var.
  • Her zaman düşük latency garantisi vermez. Özellikle “cold start” durumlarında model ilk yüklenirken beklemeniz gerekebilir.
  • Production ölçeğinde kurumsal SLA sunmaz (bunun için Inference Endpoints var, ona da değineceğiz).

Peki ne işe yarar? Prototipleme, CI/CD pipeline’larına AI entegrasyonu, otomasyon scriptleri, log analizi, alert mesajlarını özetleme gibi operasyonel görevler için mükemmel.

API Token Almak ve Ortam Değişkenlerini Ayarlamak

İlk adım Hugging Face hesabı açmak ve API token almak. huggingface.co adresine gidip Settings > Access Tokens bölümünden yeni bir token oluşturuyorsunuz. Read permission yeterli inference için.

Token’ı doğrudan script içine yazmak en büyük güvenlik hatalarından biri. Bunun yerine ortam değişkeni kullanın:

# .bashrc veya .zshrc'ye ekleyin
export HF_API_TOKEN="hf_xxxxxxxxxxxxxxxxxxxxxxxxxx"

# Veya /etc/environment'a sistem geneli ekleyin (dikkatli kullanın)
echo 'HF_API_TOKEN="hf_xxxxxxxxxxxxxxxxxxxxxxxxxx"' | sudo tee -a /etc/environment

# Değişkenin yüklendiğini kontrol edin
echo $HF_API_TOKEN

Servis olarak çalışacak scriptler için systemd service dosyasına EnvironmentFile direktifi kullanmak daha temiz:

# /etc/systemd/system/ai-monitor.service
[Unit]
Description=AI Log Monitor Service
After=network.target

[Service]
Type=simple
User=monitoring
EnvironmentFile=/etc/ai-monitor/secrets.env
ExecStart=/usr/local/bin/ai-monitor.py
Restart=always

[Install]
WantedBy=multi-user.target
# /etc/ai-monitor/secrets.env
HF_API_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxx

# Dosya izinlerini kısıtlayın
sudo chmod 600 /etc/ai-monitor/secrets.env
sudo chown monitoring:monitoring /etc/ai-monitor/secrets.env

İlk API İsteği: curl ile Test

Bir model kullanmadan önce API endpoint formatını anlayalım. Format şu şekilde:

https://api-inference.huggingface.co/models/{model_id}

Basit bir metin sınıflandırma örneğiyle başlayalım. Sentiment analysis için distilbert-base-uncased-finetuned-sst-2-english modelini kullanalım:

#!/bin/bash
# hf_test.sh - Basit API testi

HF_TOKEN="${HF_API_TOKEN}"
MODEL="distilbert-base-uncased-finetuned-sst-2-english"
API_URL="https://api-inference.huggingface.co/models/${MODEL}"

response=$(curl -s -X POST 
  -H "Authorization: Bearer ${HF_TOKEN}" 
  -H "Content-Type: application/json" 
  -d '{"inputs": "The server response time has degraded significantly today"}' 
  "${API_URL}")

echo "API Response: ${response}"

# JSON'dan skoru parse et
score=$(echo "${response}" | python3 -c "
import json, sys
data = json.load(sys.stdin)
if isinstance(data, list) and len(data) > 0:
    for item in data[0]:
        print(f"{item['label']}: {item['score']:.4f}")
")
echo "Parsed: ${score}"

Model ilk kez çağrıldığında yüklenme süresi gerekebilir. Bu durumda API 503 döner ve response içinde estimated_time alanı bulunur. Bunu handle etmek için retry mekanizması şart:

#!/bin/bash
# hf_query_with_retry.sh

query_hf_api() {
  local model="$1"
  local payload="$2"
  local max_retries=5
  local retry_delay=20
  local attempt=0

  while [ $attempt -lt $max_retries ]; do
    response=$(curl -s -w "n%{http_code}" -X POST 
      -H "Authorization: Bearer ${HF_API_TOKEN}" 
      -H "Content-Type: application/json" 
      -d "${payload}" 
      "https://api-inference.huggingface.co/models/${model}")

    http_code=$(echo "${response}" | tail -1)
    body=$(echo "${response}" | head -n -1)

    if [ "${http_code}" == "200" ]; then
      echo "${body}"
      return 0
    elif [ "${http_code}" == "503" ]; then
      estimated_time=$(echo "${body}" | python3 -c "
import json, sys
try:
    data = json.load(sys.stdin)
    print(int(data.get('estimated_time', ${retry_delay})) + 5)
except:
    print(${retry_delay})
")
      echo "Model yükleniyor, ${estimated_time} saniye bekleniyor... (Deneme $((attempt+1))/${max_retries})" >&2
      sleep "${estimated_time}"
    else
      echo "Hata: HTTP ${http_code} - ${body}" >&2
      return 1
    fi

    attempt=$((attempt + 1))
  done

  echo "Maksimum deneme sayısına ulaşıldı" >&2
  return 1
}

# Kullanım örneği
result=$(query_hf_api 
  "distilbert-base-uncased-finetuned-sst-2-english" 
  '{"inputs": "Database connection pool exhausted"}')

echo "Sonuç: ${result}"

Gerçek Dünya Senaryosu 1: Log Analizi ve Özetleme

Sysadmin olarak en çok zaman kaybettiğimiz işlerden biri uzun log dosyalarını okumak. Inference API’yi buna entegre etmek için summarization modellerini kullanabiliriz.

facebook/bart-large-cnn modeli bu iş için oldukça iyi çalışıyor:

#!/usr/bin/env python3
# log_summarizer.py - Kritik logları özetle ve bildir

import os
import json
import requests
import subprocess
from datetime import datetime

HF_TOKEN = os.environ.get("HF_API_TOKEN")
SUMMARIZE_MODEL = "facebook/bart-large-cnn"
API_BASE = "https://api-inference.huggingface.co/models"

def get_recent_errors(log_file, lines=50):
    """Son N satırdan ERROR içerenleri al"""
    try:
        result = subprocess.run(
            ["tail", "-n", str(lines), log_file],
            capture_output=True, text=True
        )
        errors = [line for line in result.stdout.split('n')
                  if 'ERROR' in line or 'CRITICAL' in line or 'FATAL' in line]
        return 'n'.join(errors[:20])  # Max 20 satır
    except Exception as e:
        return f"Log okuma hatası: {e}"

def summarize_text(text, max_length=150, min_length=50):
    """Hugging Face API ile metin özetle"""
    if not text or len(text.strip()) < 10:
        return "Özetlenecek içerik bulunamadı."

    # Model max token limitini aşmamak için metni kırp
    text = text[:1024]

    payload = {
        "inputs": text,
        "parameters": {
            "max_length": max_length,
            "min_length": min_length,
            "do_sample": False
        }
    }

    headers = {"Authorization": f"Bearer {HF_TOKEN}"}

    try:
        response = requests.post(
            f"{API_BASE}/{SUMMARIZE_MODEL}",
            headers=headers,
            json=payload,
            timeout=60
        )

        if response.status_code == 200:
            result = response.json()
            if isinstance(result, list) and len(result) > 0:
                return result[0].get('summary_text', 'Özet alınamadı')
        elif response.status_code == 503:
            return f"Model yükleniyor, lütfen tekrar deneyin. ({response.json().get('estimated_time', '?')} saniye)"
        else:
            return f"API Hatası: {response.status_code}"

    except requests.exceptions.Timeout:
        return "API zaman aşımı"
    except Exception as e:
        return f"İstek hatası: {e}"

def analyze_logs_and_notify(log_files):
    """Logları analiz et, özetle ve sonucu stdout'a yaz"""
    report_lines = [
        f"=== Log Analiz Raporu - {datetime.now().strftime('%Y-%m-%d %H:%M')} ===n"
    ]

    for log_file in log_files:
        errors = get_recent_errors(log_file)
        if errors:
            summary = summarize_text(errors)
            report_lines.append(f"Dosya: {log_file}")
            report_lines.append(f"Özet: {summary}")
            report_lines.append(f"Ham Hatalar:n{errors[:300]}...")
            report_lines.append("-" * 50)

    report = 'n'.join(report_lines)
    print(report)

    # İsterseniz buradan mail veya Slack webhook'a gönderin
    return report

if __name__ == "__main__":
    log_files = [
        "/var/log/nginx/error.log",
        "/var/log/postgresql/postgresql.log",
        "/var/log/application/app.log"
    ]
    analyze_logs_and_notify(log_files)

Bu scripti cron’a ekleyerek her sabah otomatik rapor alabilirsiniz:

# crontab -e
# Her gün 07:00'de çalıştır
0 7 * * * /usr/bin/python3 /usr/local/bin/log_summarizer.py >> /var/log/ai-reports/daily.log 2>&1

Gerçek Dünya Senaryosu 2: Monitoring Alert’lerini Zenginleştirme

Prometheus/Alertmanager kullanıyorsanız, alert mesajlarını daha anlamlı hale getirmek için Inference API’yi webhook olarak kullanabilirsiniz. Zero-shot classification ile alert’lerin öncelik seviyesini otomatik belirleyelim:

#!/usr/bin/env python3
# alert_classifier.py - Alert'leri sınıflandır ve öncelik ver

import os
import json
import requests
from flask import Flask, request, jsonify

app = Flask(__name__)
HF_TOKEN = os.environ.get("HF_API_TOKEN")
CLASSIFIER_MODEL = "facebook/bart-large-mnli"

PRIORITY_LABELS = [
    "critical system failure",
    "performance degradation",
    "resource warning",
    "informational notice"
]

def classify_alert(alert_message):
    """Zero-shot classification ile alert önceliği belirle"""
    payload = {
        "inputs": alert_message,
        "parameters": {
            "candidate_labels": PRIORITY_LABELS
        }
    }

    headers = {"Authorization": f"Bearer {HF_TOKEN}"}

    try:
        response = requests.post(
            f"https://api-inference.huggingface.co/models/{CLASSIFIER_MODEL}",
            headers=headers,
            json=payload,
            timeout=30
        )

        if response.status_code == 200:
            result = response.json()
            top_label = result['labels'][0]
            top_score = result['scores'][0]
            return {
                "priority": top_label,
                "confidence": round(top_score, 3),
                "all_scores": dict(zip(result['labels'], 
                                      [round(s, 3) for s in result['scores']]))
            }
    except Exception as e:
        return {"priority": "unknown", "error": str(e)}

@app.route('/webhook/alertmanager', methods=['POST'])
def process_alert():
    """Alertmanager webhook endpoint'i"""
    data = request.get_json()
    enriched_alerts = []

    for alert in data.get('alerts', []):
        message = alert.get('annotations', {}).get('description', '')
        if not message:
            message = alert.get('annotations', {}).get('summary', '')

        classification = classify_alert(message)

        enriched_alert = {
            **alert,
            "ai_classification": classification
        }
        enriched_alerts.append(enriched_alert)

        # Kritik alert'leri logla
        if 'critical' in classification.get('priority', ''):
            app.logger.warning(f"KRİTİK ALERT: {message[:100]}")

    return jsonify({"processed": len(enriched_alerts), "alerts": enriched_alerts})

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=5001, debug=False)

Text Generation ile Runbook Yardımcısı

Büyük dil modelleri için text generation endpoint’ini kullanalım. HuggingFaceH4/zephyr-7b-beta modeli instruction following konusunda oldukça başarılı:

#!/bin/bash
# runbook_helper.sh - Sorun için hızlı runbook önerisi al

PROBLEM="$1"

if [ -z "$PROBLEM" ]; then
  echo "Kullanım: $0 'sorun açıklaması'"
  exit 1
fi

MODEL="HuggingFaceH4/zephyr-7b-beta"
API_URL="https://api-inference.huggingface.co/models/${MODEL}"

# Prompt'u hazırla
PROMPT="<|system|>You are a Linux sysadmin expert. Give brief, actionable troubleshooting steps.</s><|user|>${PROBLEM}</s><|assistant|>"

# JSON payload oluştur
PAYLOAD=$(python3 -c "
import json
payload = {
    'inputs': '''${PROMPT}''',
    'parameters': {
        'max_new_tokens': 300,
        'temperature': 0.3,
        'return_full_text': False,
        'stop': ['</s>', '<|user|>']
    }
}
print(json.dumps(payload))
")

echo "Sorun analiz ediliyor: ${PROBLEM}"
echo "---"

response=$(curl -s -X POST 
  -H "Authorization: Bearer ${HF_API_TOKEN}" 
  -H "Content-Type: application/json" 
  -d "${PAYLOAD}" 
  "${API_URL}")

# Yanıtı parse et ve göster
echo "${response}" | python3 -c "
import json, sys
try:
    data = json.load(sys.stdin)
    if isinstance(data, list) and len(data) > 0:
        print(data[0].get('generated_text', 'Yanıt alınamadı'))
    elif isinstance(data, dict) and 'error' in data:
        print(f'Hata: {data["error"]}')
    else:
        print(str(data))
except Exception as e:
    print(f'Parse hatası: {e}')
    print(sys.stdin.read())
"

Kullanım örneği:

chmod +x runbook_helper.sh
./runbook_helper.sh "PostgreSQL connection pool exhausted, max_connections reached"

Rate Limiting ve Maliyet Yönetimi

Free tier’da dikkat etmeniz gereken limitler var. Bunları izlemek için basit bir rate limiter:

#!/usr/bin/env python3
# hf_rate_limiter.py - API kullanımını izle ve sınırla

import os
import time
import json
import requests
from collections import deque
from datetime import datetime, timedelta

class HFRateLimiter:
    """Token bucket algoritması ile rate limiting"""

    def __init__(self, requests_per_minute=10, requests_per_hour=100):
        self.rpm_limit = requests_per_minute
        self.rph_limit = requests_per_hour
        self.minute_window = deque()
        self.hour_window = deque()
        self.total_requests = 0
        self.failed_requests = 0

    def can_make_request(self):
        now = datetime.now()
        minute_ago = now - timedelta(minutes=1)
        hour_ago = now - timedelta(hours=1)

        # Eski kayıtları temizle
        while self.minute_window and self.minute_window[0] < minute_ago:
            self.minute_window.popleft()
        while self.hour_window and self.hour_window[0] < hour_ago:
            self.hour_window.popleft()

        if len(self.minute_window) >= self.rpm_limit:
            oldest = self.minute_window[0]
            wait_seconds = (oldest + timedelta(minutes=1) - now).total_seconds()
            return False, wait_seconds

        if len(self.hour_window) >= self.rph_limit:
            oldest = self.hour_window[0]
            wait_seconds = (oldest + timedelta(hours=1) - now).total_seconds()
            return False, wait_seconds

        return True, 0

    def record_request(self, success=True):
        now = datetime.now()
        self.minute_window.append(now)
        self.hour_window.append(now)
        self.total_requests += 1
        if not success:
            self.failed_requests += 1

    def get_stats(self):
        return {
            "total_requests": self.total_requests,
            "failed_requests": self.failed_requests,
            "current_rpm": len(self.minute_window),
            "current_rph": len(self.hour_window),
            "rpm_limit": self.rpm_limit,
            "rph_limit": self.rph_limit
        }

class HFInferenceClient:
    def __init__(self, token=None, rpm=10, rph=100):
        self.token = token or os.environ.get("HF_API_TOKEN")
        self.rate_limiter = HFRateLimiter(rpm, rph)
        self.base_url = "https://api-inference.huggingface.co/models"

    def query(self, model, payload, wait_if_limited=True):
        can_request, wait_time = self.rate_limiter.can_make_request()

        if not can_request:
            if wait_if_limited:
                print(f"Rate limit bekleniyor: {wait_time:.1f} saniye")
                time.sleep(wait_time + 1)
            else:
                raise Exception(f"Rate limit aşıldı. {wait_time:.1f}s beklemeniz gerekiyor.")

        headers = {"Authorization": f"Bearer {self.token}"}

        try:
            response = requests.post(
                f"{self.base_url}/{model}",
                headers=headers,
                json=payload,
                timeout=60
            )
            success = response.status_code == 200
            self.rate_limiter.record_request(success)
            return response
        except Exception as e:
            self.rate_limiter.record_request(False)
            raise e

    def print_stats(self):
        stats = self.rate_limiter.get_stats()
        print(f"Toplam istek: {stats['total_requests']}")
        print(f"Başarısız: {stats['failed_requests']}")
        print(f"Anlık RPM: {stats['current_rpm']}/{stats['rpm_limit']}")
        print(f"Anlık RPH: {stats['current_rph']}/{stats['rph_limit']}")

Inference Endpoints: Production İçin Bir Sonraki Adım

Eğer Inference API’yi production’da düzenli kullanmaya başlarsanız, bir süre sonra kısıtlamalarla karşılaşırsınız. Bu noktada Hugging Face Inference Endpoints devreye giriyor. Kendi dedicated endpoint’inizi oluşturuyorsunuz, istediğiniz donanım tipini seçiyorsunuz (CPU, T4 GPU, A10G gibi) ve SLA garantisiyle kullanıyorsunuz.

Önemli fark şudur: Inference API shared bir altyapıda çalışır ve cold start problemi yaşarsınız. Inference Endpoints ise dedicated ve her zaman sıcak tutulan bir instance. Saatlik ücretlendirme modeli var, kullanmadığınızda scale to zero yapabilirsiniz.

Endpoint oluşturduktan sonra kullanımı Inference API ile neredeyse aynı:

# Inference Endpoint URL formatı farklı
ENDPOINT_URL="https://xxxxxxxx.us-east-1.aws.endpoints.huggingface.cloud"

curl -X POST 
  -H "Authorization: Bearer ${HF_API_TOKEN}" 
  -H "Content-Type: application/json" 
  -d '{"inputs": "Sunucu bellek kullanımı kritik seviyeye ulaştı"}' 
  "${ENDPOINT_URL}"

Güvenlik Notları

Üretim ortamında dikkat etmeniz gerekenler:

  • Token rotasyonu: API token’larını düzenli aralıklarla yenileyin ve eski token’ları iptal edin.
  • Hassas veri göndermeyin: Log satırları içindeki IP adresleri, kullanıcı bilgileri ve şifreler gibi hassas verileri API’ye göndermeden önce maskeleme yapın. sed 's/[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}/[IP_MASKELENDI]/g' gibi basit bir işlem bile yeterli olabilir.
  • Network izolasyonu: API çağrıları yapan scriptlerin sadece api-inference.huggingface.co adresine erişebildiğinden emin olmak için egress firewall kuralları ekleyin.
  • Audit log: Hangi sistemin hangi modele ne zaman istek attığını loglamanız, sonradan yapılan analiz ve maliyet takibi için önemli.

Sonuç

Hugging Face Inference API, sysadmin iş akışlarına yapay zeka eklemek için en düşük giriş bariyerli yöntemlerden biri. GPU sunucusu kurmak yok, model indirmek yok, serving altyapısı yönetmek yok. Bir HTTP isteğiyle log özetleme, alert sınıflandırma, runbook önerisi alma gibi işleri yapabiliyorsunuz.

Tabii sınırlamaları var. Free tier’ın rate limitleri ciddi production yüklerini kaldırmaz. Cold start bekleme süreleri, latency açısından kritik sistemler için sorun oluşturabilir. Veri gizliliği konusunda ise hassas log verilerini dış API’ye göndermeden önce maskeleme yapmak şart.

Pratik tavsiyem şu: Önce bir veya iki operasyonel görevi Inference API ile otomatize edin. Log özetleme bunun için ideal başlangıç noktası. Değeri gördükçe ve kullanım arttıkça Inference Endpoints’e geçmeyi değerlendirin. Model tamamen lokal tutmak istiyorsanız o zaman Ollama veya vLLM kurulumu konusunu ayrıca araştırın; ama bu ikisi zaten sunucu ve GPU gerektiriyor, başka bir yazının konusu.

Şu an elinizde sadece bir API token ve birkaç satır bash script var. Geri kalan her şeyi Hugging Face hallediyor.

Bir yanıt yazın

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