OpenAI API Nedir? Başlangıç Rehberi

Yapay zeka uygulamaları geliştirmek artık yalnızca araştırmacıların ve büyük şirketlerin tekeli değil. OpenAI’nin sunduğu API sayesinde, bir sysadmin olarak kendi altyapınıza, otomasyon scriptlerinize veya dahili araçlarınıza güçlü dil modeli yetenekleri ekleyebilirsiniz. Log analizi yapan bir script mi istiyorsunuz? Kullanıcı taleplerini otomatik sınıflandıran bir sistem mi? Bunların hepsi artık birkaç satır kodla mümkün.

Bu yazıda OpenAI API’nin ne olduğunu, nasıl çalıştığını ve gerçek dünya sysadmin senaryolarında nasıl kullanabileceğinizi ele alacağız.

OpenAI API Nedir?

OpenAI API, OpenAI tarafından geliştirilen GPT-4, GPT-3.5, DALL-E ve Whisper gibi modellere HTTP üzerinden erişim sağlayan bir REST arayüzüdür. Yani siz kendi sunucunuzdan ya da makinenizden bu modellere istek gönderirsiniz, model size yanıt döner. Modeli kendiniz çalıştırmanıza gerek yoktur. Compute, inferans altyapısı, model güncellemeleri tamamen OpenAI tarafından yönetilir.

Bir sysadmin gözüyle bakarsak: bu, kendi GPU kümenizi kurmanıza, model dosyalarını indirip optimize etmenize gerek kalmadan, sanki bir mikroservis gibi kullanabileceğiniz bir yapay zeka servisidir. Hizmet token başına ücretlendirilir ve kullanıma göre ölçeklenir.

Temel kullanım alanları şunlardır:

Metin üretimi ve tamamlama (chat, içerik üretimi)
Metin sınıflandırma ve analiz
Kod üretimi ve açıklama
Özetleme ve dönüşüm
Ses transkripsiyonu (Whisper)
Görsel oluşturma (DALL-E)
Embedding oluşturma (semantik arama için)

API Anahtarı Alma ve Ortam Kurulumu

İlk adım bir OpenAI hesabı oluşturmak ve API anahtarı almaktır. [platform.openai.com](https://platform.openai.com) adresine giderek kayıt olabilirsiniz. API anahtarınızı aldıktan sonra bunu asla kodunuza gömmemeli, çevre değişkeni olarak saklamalısınız.

# API anahtarını ortam değişkeni olarak tanımla
export OPENAI_API_KEY="sk-proj-xxxxxxxxxxxxxxxxxxxx"

# Kalıcı hale getirmek için .bashrc veya .zshrc'ye ekle
echo 'export OPENAI_API_KEY="sk-proj-xxxxxxxxxxxxxxxxxxxx"' >> ~/.bashrc
source ~/.bashrc

Python ile çalışacaksanız openai kütüphanesini kurun:

# Python kütüphanesini kur
pip install openai

# Sanal ortam kullanmak daha temizdir
python3 -m venv /opt/ai-tools/venv
source /opt/ai-tools/venv/bin/activate
pip install openai requests python-dotenv

Anahtarınızı .env dosyasında da saklayabilirsiniz:

# .env dosyası oluştur
cat > /opt/ai-tools/.env << 'EOF'
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxx
OPENAI_ORG_ID=org-xxxxxxxxxxxxxxxxx
EOF

# Dosya izinlerini kısıtla
chmod 600 /opt/ai-tools/.env

İlk API Çağrısı: Chat Completions

OpenAI API’nin en çok kullanılan uç noktası Chat Completions endpointidir. Bu endpoint, GPT-4 ve GPT-3.5-turbo modellerine mesaj göndererek yanıt almanızı sağlar.

#!/usr/bin/env python3
# /opt/ai-tools/ilk_cagri.py

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv('/opt/ai-tools/.env')

client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "Sen deneyimli bir Linux sistem yöneticisisin. Kısa ve net yanıtlar ver."
        },
        {
            "role": "user",
            "content": "Bir sunucuda CPU kullanımı %95 seviyesinde. İlk 5 adımda ne yapmalıyım?"
        }
    ],
    max_tokens=500,
    temperature=0.3
)

print(response.choices[0].message.content)
print(f"nKullanılan token: {response.usage.total_tokens}")

Bu kodu çalıştırdığınızda modelin size adım adım bir yaklaşım önereceğini göreceksiniz. temperature parametresi yaratıcılık seviyesini kontrol eder. Düşük değer (0.1-0.3) tutarlı ve deterministik yanıtlar verir; bu sysadmin scriptleri için idealdir.

API Parametrelerini Anlamak

Chat Completions endpoint’inin önemli parametrelerini bilmek, hem maliyet kontrolü hem de kaliteli çıktı almak için kritiktir.

model: Kullanacağınız model adı. gpt-4o en güçlüsü, gpt-4o-mini en uygun fiyatlısı, gpt-3.5-turbo ise eski ama hızlı seçenektir.

messages: Konuşma geçmişini içeren liste. Her mesajın role ve content alanı vardır. Role değerleri şunlardır:

system: Modele davranış kurallarını belirler
user: Kullanıcıdan gelen mesajı temsil eder
assistant: Modelin önceki yanıtlarını temsil eder

max_tokens: Yanıtta üretilecek maksimum token sayısı. Maliyet kontrolü için önemlidir.

temperature: 0 ile 2 arasında değer alır. 0’a yakın değerler tutarlı, 1’e yakın değerler yaratıcı yanıtlar üretir.

top_p: Nucleus sampling parametresi. Temperature ile birlikte kullanılmaması önerilir.

frequency_penalty: Aynı kelimelerin tekrarlanmasını azaltır. -2.0 ile 2.0 arası değer alır.

presence_penalty: Yeni konuların gündeme gelmesini teşvik eder. -2.0 ile 2.0 arası değer alır.

stream: True yapılırsa yanıtlar token token akar, büyük yanıtlarda kullanıcı deneyimini iyileştirir.

Gerçek Dünya Senaryosu: Log Analiz Aracı

Sysadminlerin en sık yaptığı işlerden biri log incelemektir. Aşağıdaki script, bir log dosyasını alır ve GPT’ye analiz ettirir:

#!/usr/bin/env python3
# /opt/ai-tools/log_analyzer.py

import sys
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv('/opt/ai-tools/.env')
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def analyze_log(log_content, log_type="system"):
    """Log içeriğini GPT ile analiz et"""
    
    system_prompt = """Sen uzman bir Linux sistem yöneticisisin. 
    Sana verilen log çıktısını analiz ederek:
    1. Kritik hataları ve uyarıları listele
    2. Olası nedenleri açıkla
    3. Önerilen çözüm adımlarını ver
    Yanıtını Türkçe ver. Eğer log içeriği normal görünüyorsa bunu da belirt."""
    
    user_message = f"Aşağıdaki {log_type} log çıktısını analiz et:nn```n{log_content}n```"
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message}
        ],
        max_tokens=1000,
        temperature=0.2
    )
    
    return response.choices[0].message.content

def main():
    if len(sys.argv) < 2:
        print("Kullanim: python3 log_analyzer.py <log_dosyasi> [log_tipi]")
        sys.exit(1)
    
    log_file = sys.argv[1]
    log_type = sys.argv[2] if len(sys.argv) > 2 else "system"
    
    with open(log_file, 'r', encoding='utf-8', errors='ignore') as f:
        # Son 100 satırı al (token limiti için)
        lines = f.readlines()
        log_content = ''.join(lines[-100:])
    
    print(f"Analiz ediliyor: {log_file}")
    print("-" * 50)
    result = analyze_log(log_content, log_type)
    print(result)

if __name__ == "__main__":
    main()

Bu scripti gerçekte şöyle kullanırsınız:

# Nginx error logunu analiz et
python3 /opt/ai-tools/log_analyzer.py /var/log/nginx/error.log nginx

# Sistem logunu analiz et
python3 /opt/ai-tools/log_analyzer.py /var/log/syslog system

# journalctl çıktısıyla kullan
journalctl -u postgresql --since "1 hour ago" --no-pager > /tmp/pg_log.txt
python3 /opt/ai-tools/log_analyzer.py /tmp/pg_log.txt postgresql

Embedding API ile Semantik Arama

Chat Completions dışında, OpenAI’nin Embeddings API’si de son derece güçlüdür. Metinleri vektöre çevirir ve benzerlik aramaları yapmanıza olanak tanır. Örneğin dahili bir runbook veritabanı oluşturup, sorun yaşandığında semantik arama yapabilirsiniz.

#!/usr/bin/env python3
# /opt/ai-tools/runbook_search.py

import json
import numpy as np
from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv('/opt/ai-tools/.env')
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

# Örnek runbook veritabanı
RUNBOOKS = [
    {"id": 1, "title": "Disk Dolu Uyarısı", "content": "df -h komutuyla dolu diskleri bul, du -sh ile büyük dizinleri tespit et, eski logları temizle"},
    {"id": 2, "title": "MySQL Bağlantı Hatası", "content": "mysql servisini kontrol et, max_connections parametresini gözden geçir, slow query logunu incele"},
    {"id": 3, "title": "Yüksek CPU Kullanımı", "content": "top veya htop ile süreci bul, strace ile syscall analizi yap, profiling aracı kullan"},
    {"id": 4, "title": "Nginx 502 Bad Gateway", "content": "backend servisin çalışıp çalışmadığını kontrol et, upstream timeout değerlerini ayarla"},
]

def get_embedding(text):
    """Metin için embedding oluştur"""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def cosine_similarity(a, b):
    """İki vektör arasındaki kosinüs benzerliğini hesapla"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def search_runbooks(query, top_k=2):
    """Sorguya en yakın runbook'ları bul"""
    query_embedding = get_embedding(query)
    
    scores = []
    for runbook in RUNBOOKS:
        runbook_embedding = get_embedding(runbook['content'])
        score = cosine_similarity(query_embedding, runbook_embedding)
        scores.append((score, runbook))
    
    scores.sort(key=lambda x: x[0], reverse=True)
    return scores[:top_k]

# Test
query = "sunucum çok yavaş, işlemci sürekli meşgul"
results = search_runbooks(query)

print(f"Sorgu: {query}n")
for score, runbook in results:
    print(f"[{score:.3f}] {runbook['title']}: {runbook['content']}")

cURL ile Doğrudan API Kullanımı

Python kullanmak zorunda değilsiniz. Bash scriptlerinizden doğrudan cURL ile API’yi çağırabilirsiniz:

#!/bin/bash
# /usr/local/bin/ask-ai.sh
# Bash'ten doğrudan OpenAI API kullanımı

source /opt/ai-tools/.env

QUESTION="$1"

if [ -z "$QUESTION" ]; then
    echo "Kullanim: ask-ai.sh 'sorunuzu buraya yazin'"
    exit 1
fi

RESPONSE=$(curl -s https://api.openai.com/v1/chat/completions 
    -H "Content-Type: application/json" 
    -H "Authorization: Bearer $OPENAI_API_KEY" 
    -d "{
        "model": "gpt-4o-mini",
        "messages": [
            {
                "role": "system",
                "content": "Sen bir Linux sysadmin asistanisin. Kisa ve net yanit ver."
            },
            {
                "role": "user",
                "content": "$QUESTION"
            }
        ],
        "max_tokens": 300,
        "temperature": 0.3
    }")

# jq ile yanıtı parse et
echo "$RESPONSE" | jq -r '.choices[0].message.content'

# Scripti kullanılabilir yap
chmod +x /usr/local/bin/ask-ai.sh

# Kullanım örnekleri
ask-ai.sh "iptables ile belirli bir IP'yi nasıl bloklarım?"
ask-ai.sh "nginx reverse proxy konfigürasyonu için örnek ver"

Hata Yönetimi ve Rate Limiting

Prodüksiyon ortamında API’yi kullanacaksanız hata yönetimi şarttır. OpenAI API’si çeşitli HTTP hata kodları döndürebilir ve rate limit’e takılabilirsiniz.

#!/usr/bin/env python3
# /opt/ai-tools/robust_client.py

import time
import logging
from openai import OpenAI, RateLimitError, APITimeoutError, APIConnectionError
from dotenv import load_dotenv
import os

load_dotenv('/opt/ai-tools/.env')

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('/var/log/ai-tools/api.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

client = OpenAI(
    api_key=os.getenv('OPENAI_API_KEY'),
    timeout=30.0,
    max_retries=3
)

def call_with_retry(messages, model="gpt-4o-mini", max_tokens=500, retries=3):
    """Retry mekanizmalı API çağrısı"""
    
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                max_tokens=max_tokens,
                temperature=0.3
            )
            
            logger.info(f"Basarili - Token: {response.usage.total_tokens}, "
                       f"Model: {model}")
            
            return response.choices[0].message.content
            
        except RateLimitError as e:
            wait_time = 2 ** attempt * 10  # Exponential backoff
            logger.warning(f"Rate limit asildi. {wait_time}s bekleniyor... (Deneme {attempt + 1}/{retries})")
            time.sleep(wait_time)
            
        except APITimeoutError:
            logger.error(f"API timeout. Deneme {attempt + 1}/{retries}")
            if attempt == retries - 1:
                raise
                
        except APIConnectionError as e:
            logger.error(f"Baglanti hatasi: {e}")
            if attempt == retries - 1:
                raise
    
    raise Exception("Maksimum deneme sayisina ulasildi")

# Test
result = call_with_retry([
    {"role": "user", "content": "Python'da try-except bloğunu kısaca açıkla"}
])
print(result)

Token Maliyetini Hesaplamak

Token yönetimi maliyet açısından kritiktir. Bir token, yaklaşık olarak 4 karakter veya 0.75 Türkçe kelimeye karşılık gelir.

#!/usr/bin/env python3
# Token sayısını önceden tahmin et

import tiktoken

def count_tokens(text, model="gpt-4o-mini"):
    """Bir metnin kaç token tutacağını hesapla"""
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        encoding = tiktoken.get_encoding("cl100k_base")
    
    return len(encoding.encode(text))

def estimate_cost(prompt_tokens, completion_tokens, model="gpt-4o-mini"):
    """Tahmini maliyet hesapla (USD)"""
    # gpt-4o-mini fiyatları (2024 sonu itibarıyla)
    pricing = {
        "gpt-4o-mini": {"input": 0.000150 / 1000, "output": 0.000600 / 1000},
        "gpt-4o": {"input": 0.005 / 1000, "output": 0.015 / 1000},
    }
    
    if model not in pricing:
        return "Bilinmeyen model"
    
    cost = (prompt_tokens * pricing[model]["input"] + 
            completion_tokens * pricing[model]["output"])
    
    return f"${cost:.6f}"

# Örnek kullanım
sample_prompt = "Bu sunucuda hangi servisler çalışıyor ve nasıl kontrol ederim?"
token_count = count_tokens(sample_prompt)
print(f"Prompt token sayisi: {token_count}")
print(f"Tahmini maliyet (500 token yanit ile): {estimate_cost(token_count, 500)}")

# tiktoken kur
pip install tiktoken

Güvenlik ve Best Practice’ler

Prodüksiyon ortamında API kullanırken dikkat etmeniz gereken noktalar:

API anahtarı güvenliği:

Anahtarı asla Git reposuna commit etmeyin
.gitignore dosyasına .env ekleyin
Prod ortamda HashiCorp Vault veya AWS Secrets Manager kullanın
Anahtarlara IP kısıtlaması uygulayın (platform.openai.com üzerinden)

Maliyet kontrolü:

Her proje için ayrı API anahtarı oluşturun
platform.openai.com üzerinden aylık harcama limiti belirleyin
Yanıtları önbelleğe alın, aynı soruları tekrar tekrar sormayın
max_tokens parametresini gereksiz yere yüksek tutmayın

Input doğrulama:

Kullanıcı girdisini doğrudan prompt’a eklemeyin, sanitize edin
Prompt injection saldırılarına karşı dikkatli olun
Hassas log içeriklerini (şifreler, tokenlar) maskeleyerek gönderin

Loglama ve monitoring:

Her API çağrısını loglayın
Günlük/saatlik token kullanımını takip edin
Anormal kullanım için alarm kurun

# Basit kullanım istatistikleri için log parse
grep "Token:" /var/log/ai-tools/api.log | 
    awk '{sum += $NF} END {print "Toplam token: " sum}' 

# Günlük kullanım raporu
grep "$(date +%Y-%m-%d)" /var/log/ai-tools/api.log | wc -l

Sonuç

OpenAI API, sysadmin araç setinize ciddi bir güç katabilir. Log analizi, runbook arama, otomatik hata raporlama veya basit bir dahili chatbot gibi uygulamalar artık çok daha kolay hayata geçirilebilir.

Başlangıç için önerdiğim yol haritası şudur: önce gpt-4o-mini modeliyle başlayın, maliyeti düşük ve yeterince yeteneklidir. Mümkün olan her yerde system prompt’u sabit tutun ve temperature değerini düşük tutun. Yanıtları önbelleğe almak için Redis gibi bir çözüm entegre edin. Prodüksiyona geçmeden önce mutlaka rate limiting ve retry mekanizmalarını kurun.

Unutmayın, bu API bir araçtır. En iyi sonucu, prompt mühendisliğine biraz zaman ayırarak ve kullanım senaryonuza özel sistem promptları yazarak alırsınız. İlk denemelerinizde sonuçlar beklenenden farklı gelebilir, prompt’u iyileştirerek tekrarlayın. Zamanla neyin işe yarayıp neyin yaramadığını anlayacaksınız.

OpenAI API Nedir: Yapay Zeka Uygulamaları için Temel Rehber