Ne Zaman Kullanılır? (When to Use?)

• ✅ Cache, session, queue, pub/sub
• ⚠️ Ana DB olarak kullanma
• ❌ İlişkisel sorgular

Önerilen Kullanım: Uygulama cache + session store + mesaj kuyruğu Alternatifler: Memcached (basit cache), Valkey (Redis forku), KeyDB (multi-threaded)

Redis

Redis (Remote Dictionary Server), bellekte çalışan (in-memory) anahtar-değer (key-value) veri yapısına sahip bir veritabanıdır. Düşük gecikme süresi (sub-millisecond latency) ile yüksek performanslı okuma/yazma işlemleri sunar.

Kurulum (Installation)

Ubuntu / Debian

sudo apt update
sudo apt install redis-server -y
sudo systemctl start redis-server
sudo systemctl enable redis-server

# Bağlantı testi
redis-cli ping
# PONG

macOS

brew install redis
brew services start redis

Docker

docker run -d --name redis \
  -p 6379:6379 \
  redis:7-alpine \
  --requirepass "sifre123"

Docker Compose

version: "3.8"
services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    command: redis-server --requirepass sifre123 --appendonly yes
    volumes:
      - redis_data:/data

volumes:
  redis_data:

---

1) Veri Tipleri (Data Types)

1.1 String

En temel veri tipidir. Metin, sayı, JSON veya binary veri saklayabilir. Maksimum 512 MB.

# Temel işlemler
SET kullanici:1:ad "Fahri"
GET kullanici:1:ad            # "Fahri"

# Süreli kayıt (TTL ile)
SET oturum:abc123 "user:1" EX 3600   # 1 saat sonra silinir
SET temp:veri "deger" PX 5000        # 5000 milisaniye

# Sadece yoksa yaz (distributed lock için önemli)
SET kilit:siparis:42 "worker-1" NX EX 30

# Sayaç işlemleri
SET sayac:ziyaret 0
INCR sayac:ziyaret              # 1
INCRBY sayac:ziyaret 10         # 11
DECR sayac:ziyaret              # 10

# Birden fazla anahtar
MSET ad "Fahri" soyad "Aydin" yas "30"
MGET ad soyad yas               # "Fahri" "Aydin" "30"

1.2 Hash

Bir anahtar altında alan-değer (field-value) çiftleri saklar. Nesne/obje modellemesi için idealdir.

# Hash oluştur
HSET kullanici:1 ad "Fahri" soyad "Aydin" email "f@a.dev" yas 30

# Okuma
HGET kullanici:1 ad              # "Fahri"
HGETALL kullanici:1              # tüm alanlar ve değerler
HMGET kullanici:1 ad email       # birden fazla alan

# Güncelleme
HSET kullanici:1 yas 31
HINCRBY kullanici:1 yas 1        # 32

# Alan var mı?
HEXISTS kullanici:1 email        # 1 (evet)

# Alan silme
HDEL kullanici:1 email

# Alan sayısı
HLEN kullanici:1                 # 3

1.3 List

Sıralanmış (ordered) eleman koleksiyonu. Kuyruk (queue) ve yığın (stack) yapılarını destekler.

# Başa ve sona ekleme
LPUSH kuyruk:email "mail-1"     # sola (başa) ekle
RPUSH kuyruk:email "mail-2"     # sağa (sona) ekle
LPUSH kuyruk:email "mail-0"

# Okuma (index bazlı)
LRANGE kuyruk:email 0 -1        # tüm elemanlar
LRANGE kuyruk:email 0 2         # ilk 3 eleman
LINDEX kuyruk:email 0           # ilk eleman

# Çıkarma (pop)
LPOP kuyruk:email               # baştan çıkar
RPOP kuyruk:email               # sondan çıkar

# Bloklu çıkarma (consumer için)
BLPOP kuyruk:email 30           # 30 sn bekle, eleman gelirse çıkar

# Uzunluk
LLEN kuyruk:email

# Kırpma (sadece son N elemanı tut)
LTRIM bildirimler 0 99          # son 100 bildirim

1.4 Set

Benzersiz (unique) ve sıralamasız elemanlar koleksiyonu. Küme işlemleri (union, intersection, difference) desteklenir.

# Eleman ekleme
SADD etiketler:makale:1 "redis" "cache" "nosql"
SADD etiketler:makale:2 "redis" "docker" "devops"

# Tüm elemanlar
SMEMBERS etiketler:makale:1

# Üyelik kontrolü
SISMEMBER etiketler:makale:1 "redis"   # 1 (evet)

# Eleman sayısı
SCARD etiketler:makale:1               # 3

# Küme işlemleri
SINTER etiketler:makale:1 etiketler:makale:2    # kesişim: "redis"
SUNION etiketler:makale:1 etiketler:makale:2    # birleşim
SDIFF etiketler:makale:1 etiketler:makale:2     # fark

# Rastgele eleman
SRANDMEMBER etiketler:makale:1 2       # 2 rastgele eleman

# Silme
SREM etiketler:makale:1 "nosql"

1.5 Sorted Set (ZSet)

Her elemana bir skor (score) atanmış sıralanmış küme. Liderlik tablosu, öncelik kuyruğu gibi senaryolar için idealdir.

# Eleman ekleme (skor ile)
ZADD lider:tablo 1500 "oyuncu:ali"
ZADD lider:tablo 2200 "oyuncu:veli"
ZADD lider:tablo 1800 "oyuncu:ayse"

# Sıralı listeleme (düşükten yükseğe)
ZRANGE lider:tablo 0 -1 WITHSCORES

# Ters sıralama (yüksekten düşüğe)
ZREVRANGE lider:tablo 0 2 WITHSCORES   # ilk 3

# Skor güncelleme
ZINCRBY lider:tablo 300 "oyuncu:ali"    # 1800

# Sıralama (rank)
ZRANK lider:tablo "oyuncu:veli"         # 0-bazlı sıralama
ZREVRANK lider:tablo "oyuncu:veli"      # ters sıralama

# Skor aralığında sorgulama
ZRANGEBYSCORE lider:tablo 1000 2000 WITHSCORES

# Eleman sayısı
ZCARD lider:tablo

# Belirli skor aralığındaki eleman sayısı
ZCOUNT lider:tablo 1500 2000

# Silme
ZREM lider:tablo "oyuncu:ali"

1.6 Stream

Append-only log veri yapısı. Event sourcing, mesaj kuyruğu ve gerçek zamanlı veri akışı için kullanılır.

# Mesaj ekleme
XADD olaylar:siparis * eylem "olusturuldu" siparis_id "42" tutar "150.00"
XADD olaylar:siparis * eylem "odendi" siparis_id "42"

# Okuma (baştan)
XRANGE olaylar:siparis - +            # tüm mesajlar
XRANGE olaylar:siparis - + COUNT 10   # ilk 10

# Sondan okuma
XREVRANGE olaylar:siparis + - COUNT 5

# Uzunluk
XLEN olaylar:siparis

# Consumer Group oluşturma
XGROUP CREATE olaylar:siparis siparis-grubu $ MKSTREAM

# Consumer olarak okuma
XREADGROUP GROUP siparis-grubu worker-1 COUNT 5 BLOCK 2000 STREAMS olaylar:siparis >

# Onaylama (acknowledge)
XACK olaylar:siparis siparis-grubu "1234567890-0"

# Bekleyen mesajları görüntüleme
XPENDING olaylar:siparis siparis-grubu

---

2) Anahtar Yönetimi (Key Management)

# Anahtar varlığını kontrol et
EXISTS kullanici:1              # 1 veya 0

# Anahtarı sil
DEL kullanici:1                 # anında siler
UNLINK kullanici:1              # arka planda asenkron siler (büyük key için)

# Anahtar tipini öğren
TYPE kullanici:1                # string, hash, list, set, zset, stream

# Anahtar arama (dikkat: üretimde KEYS kullanma)
KEYS kullanici:*                # TEHLİKELİ - bloklayıcı
SCAN 0 MATCH kullanici:* COUNT 100   # güvenli alternatif

# Yeniden adlandırma
RENAME eski_ad yeni_ad

# Rastgele anahtar
RANDOMKEY

TTL (Time To Live) Yönetimi

# Süre atama
EXPIRE anahtar 3600             # 3600 saniye
PEXPIRE anahtar 5000            # 5000 milisaniye
EXPIREAT anahtar 1735689600     # Unix timestamp

# Kalan süre
TTL anahtar                     # saniye cinsinden (-1: süresiz, -2: yok)
PTTL anahtar                    # milisaniye cinsinden

# Süreyi kaldır (kalıcı yap)
PERSIST anahtar

---

3) Yaygın Kalıplar (Common Patterns)

3.1 Cache-Aside (Lazy Loading)

Veri önce cache'e bakılır, yoksa DB'den okunur ve cache'e yazılır.

İstek --> Cache var mı?
            |
        Evet --> Cache'den dön
            |
        Hayır --> DB'den oku --> Cache'e yaz --> Dön

async function kullaniciBul(id) {
  const cacheKey = `kullanici:${id}`;

  // 1. Cache'e bak
  const cached = await redis.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }

  // 2. DB'den oku
  const kullanici = await db.query("SELECT * FROM kullanicilar WHERE id = $1", [id]);

  // 3. Cache'e yaz (1 saat TTL)
  await redis.set(cacheKey, JSON.stringify(kullanici), "EX", 3600);

  return kullanici;
}

// Güncelleme yapıldığında cache'i temizle
async function kullaniciGuncelle(id, veri) {
  await db.query("UPDATE kullanicilar SET ... WHERE id = $1", [id]);
  await redis.del(`kullanici:${id}`);
}

3.2 Write-Through Cache

Yazma işlemi hem DB'ye hem cache'e aynı anda yapılır.

async function kullaniciKaydet(id, veri) {
  // DB ve cache'e aynı anda yaz
  await db.query("INSERT INTO kullanicilar ...", [veri]);
  await redis.set(`kullanici:${id}`, JSON.stringify(veri), "EX", 3600);
}

3.3 Pub/Sub (Yayın/Abone - Publish/Subscribe)

Kanallar üzerinden mesaj yayınlama ve dinleme. Chat uygulamaları, bildirimler, gerçek zamanlı güncellemeler için kullanılır.

# Terminal 1: Abone ol
SUBSCRIBE bildirimler
SUBSCRIBE kanal:sohbet:genel

# Terminal 2: Mesaj yayınla
PUBLISH bildirimler "Yeni sipariş oluşturuldu"
PUBLISH kanal:sohbet:genel "Merhaba!"

# Desen bazlı abonelik
PSUBSCRIBE kanal:sohbet:*

// Yayıncı (Publisher)
await redis.publish("bildirimler", JSON.stringify({
  tip: "siparis",
  mesaj: "Yeni sipariş #42",
  zaman: Date.now()
}));

// Abone (Subscriber) - ayrı bir bağlantı gerekir
const sub = redis.duplicate();
sub.subscribe("bildirimler");
sub.on("message", (kanal, mesaj) => {
  console.log(`[${kanal}] ${mesaj}`);
});

3.4 Rate Limiting (Hız Sınırlandırma)

Belirli bir zaman diliminde istek sayısını sınırlandırma. API koruması için kritiktir.

// Sliding Window Rate Limiter
async function hizKontrol(ip, limit = 100, pencere = 60) {
  const anahtar = `rl:${ip}`;
  const simdi = Date.now();
  const pencereBaslangic = simdi - pencere * 1000;

  const pipeline = redis.pipeline();
  pipeline.zremrangebyscore(anahtar, 0, pencereBaslangic); // eski kayıtları sil
  pipeline.zadd(anahtar, simdi, `${simdi}`);               // yeni isteği ekle
  pipeline.zcard(anahtar);                                  // toplam sayıyı al
  pipeline.expire(anahtar, pencere);                        // TTL ayarla

  const sonuclar = await pipeline.exec();
  const istekSayisi = sonuclar[2][1];

  return {
    izinVar: istekSayisi <= limit,
    kalanHak: Math.max(0, limit - istekSayisi),
    toplam: istekSayisi
  };
}

// Basit Fixed Window
async function basitHizKontrol(ip, limit = 100) {
  const anahtar = `rl:${ip}:${Math.floor(Date.now() / 60000)}`;
  const sayi = await redis.incr(anahtar);
  if (sayi === 1) await redis.expire(anahtar, 60);
  return sayi <= limit;
}

3.5 Session Yönetimi (Session Management)

const session = require("express-session");
const RedisStore = require("connect-redis").default;

app.use(session({
  store: new RedisStore({ client: redis }),
  secret: "gizli-anahtar",
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: true,
    httpOnly: true,
    maxAge: 24 * 60 * 60 * 1000  // 1 gün
  }
}));

3.6 Distributed Lock (Dağıtık Kilit)

Birden fazla süreç/sunucu arasında kaynak erişimini senkronize etmek için kullanılır.

// Basit Distributed Lock (Redlock algoritması)
async function kilitAl(kaynakAdi, ttl = 10000) {
  const kilitId = crypto.randomUUID();
  const anahtar = `kilit:${kaynakAdi}`;

  // NX: sadece yoksa yaz, PX: milisaniye TTL
  const sonuc = await redis.set(anahtar, kilitId, "NX", "PX", ttl);

  if (sonuc === "OK") {
    return kilitId;
  }
  return null; // kilit alınamadı
}

async function kilitBirak(kaynakAdi, kilitId) {
  // Lua script ile atomik kontrol ve silme
  const script = `
    if redis.call("get", KEYS[1]) == ARGV[1] then
      return redis.call("del", KEYS[1])
    else
      return 0
    end
  `;
  await redis.eval(script, 1, `kilit:${kaynakAdi}`, kilitId);
}

// Kullanım
async function siparisIsle(siparisId) {
  const kilit = await kilitAl(`siparis:${siparisId}`);
  if (!kilit) {
    throw new Error("Sipariş başka bir worker tarafından işleniyor");
  }

  try {
    // iş mantığı
    await islemleriYap(siparisId);
  } finally {
    await kilitBirak(`siparis:${siparisId}`, kilit);
  }
}

---

4) Persistence (Kalıcılık)

Redis bellekte çalışır, ancak verileri diske yazabilir.

4.1 RDB (Snapshotting)

Belirli aralıklarla tüm verisetinin snapshot'ını diske yazar.

# redis.conf
save 900 1        # 900 sn içinde en az 1 değişiklik varsa kaydet
save 300 10       # 300 sn içinde en az 10 değişiklik
save 60 10000     # 60 sn içinde en az 10000 değişiklik

dbfilename dump.rdb
dir /var/lib/redis/

4.2 AOF (Append Only File)

Her yazma işlemini log dosyasına ekler. Daha güvenilir ama daha yavaş.

# redis.conf
appendonly yes
appendfilename "appendonly.aof"

# Senkronizasyon politikası
appendfsync always     # her işlemde (en güvenli, en yavaş)
appendfsync everysec   # her saniye (önerilen)
appendfsync no         # işletim sistemine bırak (en hızlı)

4.3 Hibrit (RDB + AOF)

# redis.conf (Redis 7+)
aof-use-rdb-preamble yes   # AOF dosyasının başına RDB snapshot ekler

Özellik	RDB	AOF	Hibrit
Veri kaybı riski	Yüksek (son snapshot arası)	Düşük (max 1 sn)	En düşük
Dosya boyutu	Küçük	Büyük	Orta
Yeniden yükleme hızı	Hızlı	Yavaş	Hızlı
Performans etkisi	Düşük	Orta	Orta

---

5) Pipelining ve Transaction

5.1 Pipelining

Birden fazla komutu tek seferde göndererek ağ gecikmesini azaltır.

# redis-cli ile
redis-cli --pipe <<EOF
SET anahtar1 "deger1"
SET anahtar2 "deger2"
SET anahtar3 "deger3"
INCR sayac
EOF

// Node.js ioredis ile
const pipeline = redis.pipeline();
pipeline.set("a", "1");
pipeline.set("b", "2");
pipeline.get("a");
pipeline.incr("sayac");
const sonuclar = await pipeline.exec();
// [[null, "OK"], [null, "OK"], [null, "1"], [null, 1]]

5.2 Transaction (MULTI/EXEC)

Atomik işlem grubu. Ya hepsi ya hiçbiri mantığı ile çalışır.

MULTI
SET bakiye:1 900
SET bakiye:2 1100
EXEC

const sonuc = await redis
  .multi()
  .decrby("bakiye:gonderen", 100)
  .incrby("bakiye:alan", 100)
  .exec();

5.3 Lua Scripting

Atomik ve sunucu tarafında çalışacak karmaşık işlemler için.

# Atomik "oku ve güncelle" işlemi
EVAL "
  local mevcut = tonumber(redis.call('GET', KEYS[1]) or '0')
  if mevcut >= tonumber(ARGV[1]) then
    redis.call('DECRBY', KEYS[1], ARGV[1])
    return 1
  else
    return 0
  end
" 1 stok:urun:42 5

// ioredis ile Lua script tanımlama
redis.defineCommand("stokDus", {
  numberOfKeys: 1,
  lua: `
    local mevcut = tonumber(redis.call('GET', KEYS[1]) or '0')
    if mevcut >= tonumber(ARGV[1]) then
      redis.call('DECRBY', KEYS[1], ARGV[1])
      return 1
    else
      return 0
    end
  `
});

const sonuc = await redis.stokDus("stok:urun:42", 5);

---

6) Redis Cluster

6.1 Cluster Mimarisi (Cluster Architecture)

Redis Cluster, verileri 16384 hash slot'a böler ve bu slotları düğümler (node) arasında dağıtır.

Slot 0-5460     --> Node A (master) + Node D (replica)
Slot 5461-10922 --> Node B (master) + Node E (replica)
Slot 10923-16383 --> Node C (master) + Node F (replica)

6.2 Cluster Kurulumu (Cluster Setup)

## 6 düğümlü cluster oluşturma (3 master + 3 replica)
redis-cli --cluster create \
  127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 \
  127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \
  --cluster-replicas 1

# Cluster durumunu kontrol et
redis-cli -c -p 7000 cluster info
redis-cli -c -p 7000 cluster nodes

6.3 Cluster ile Bağlantı (Cluster Connection)

// ioredis Cluster
const Redis = require("ioredis");

const cluster = new Redis.Cluster([
  { host: "127.0.0.1", port: 7000 },
  { host: "127.0.0.1", port: 7001 },
  { host: "127.0.0.1", port: 7002 }
], {
  redisOptions: {
    password: "sifre123"
  },
  scaleReads: "slave"  // okuma işlemlerini replica'lardan yap
});

6.4 Sentinel (Yüksek Erişilebilirlik / High Availability)

Cluster yerine basit master-replica yapısı için Sentinel otomatik failover sağlar.

const redis = new Redis({
  sentinels: [
    { host: "sentinel-1", port: 26379 },
    { host: "sentinel-2", port: 26379 },
    { host: "sentinel-3", port: 26379 }
  ],
  name: "ana-sunucu",
  password: "sifre123"
});

---

7) Entegrasyonlar (Integrations)

7.1 Node.js (ioredis)

npm install ioredis

const Redis = require("ioredis");

// Temel bağlantı
const redis = new Redis({
  host: "127.0.0.1",
  port: 6379,
  password: "sifre123",
  db: 0,
  retryStrategy(times) {
    const gecikme = Math.min(times * 50, 2000);
    return gecikme;
  },
  maxRetriesPerRequest: 3
});

// Bağlantı olayları
redis.on("connect", () => console.log("Redis bağlandı"));
redis.on("error", (err) => console.error("Redis hatası:", err));

// Temel işlemler
await redis.set("anahtar", "deger", "EX", 3600);
const deger = await redis.get("anahtar");

// Hash işlemleri
await redis.hset("kullanici:1", { ad: "Fahri", email: "f@a.dev" });
const kullanici = await redis.hgetall("kullanici:1");

// Pipeline
const pipe = redis.pipeline();
pipe.set("a", 1);
pipe.set("b", 2);
pipe.get("a");
await pipe.exec();

// Bağlantı havuzu yok - ioredis tek bağlantı ile multiplexing yapar
// Birden fazla bağlantı gerekirse ayrı instance oluştur

// Kapatma
await redis.quit();

7.2 Laravel (PHP)

Laravel varsayılan olarak Redis desteği ile gelir.

composer require predis/predis
# veya phpredis extension kullan

// .env
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=sifre123
REDIS_PORT=6379

// config/database.php zaten yapılandırılmış olarak gelir

use Illuminate\Support\Facades\Redis;
use Illuminate\Support\Facades\Cache;

// Doğrudan Redis kullanımı
Redis::set('anahtar', 'deger');
$deger = Redis::get('anahtar');

// Hash
Redis::hset('kullanici:1', 'ad', 'Fahri');
Redis::hgetall('kullanici:1');

// Cache Facade (önerilen)
Cache::put('anahtar', 'deger', now()->addHours(1));
$deger = Cache::get('anahtar', 'varsayilan');
Cache::forget('anahtar');

// Cache remember pattern
$kullanici = Cache::remember("kullanici:{$id}", 3600, function () use ($id) {
    return User::find($id);
});

// Rate Limiting (middleware)
// app/Http/Kernel.php veya bootstrap/app.php
RateLimiter::for('api', function (Request $request) {
    return Limit::perMinute(60)->by($request->ip());
});

// Queue (Redis driver)
// .env: QUEUE_CONNECTION=redis
dispatch(new SiparisIsle($siparis));

// Session (Redis driver)
// .env: SESSION_DRIVER=redis

7.3 Python (redis-py)

pip install redis

import redis
import json

# Bağlantı
r = redis.Redis(
    host="127.0.0.1",
    port=6379,
    password="sifre123",
    db=0,
    decode_responses=True  # byte yerine string dön
)

# Bağlantı havuzu
havuz = redis.ConnectionPool(
    host="127.0.0.1",
    port=6379,
    password="sifre123",
    max_connections=20
)
r = redis.Redis(connection_pool=havuz)

# Temel işlemler
r.set("anahtar", "deger", ex=3600)
deger = r.get("anahtar")

# Hash
r.hset("kullanici:1", mapping={"ad": "Fahri", "email": "f@a.dev"})
kullanici = r.hgetall("kullanici:1")

# Pipeline
pipe = r.pipeline()
pipe.set("a", 1)
pipe.set("b", 2)
pipe.get("a")
sonuclar = pipe.execute()  # [True, True, "1"]

# Pub/Sub
ps = r.pubsub()
ps.subscribe("bildirimler")
for mesaj in ps.listen():
    if mesaj["type"] == "message":
        print(mesaj["data"])

# Cache decorator
from functools import wraps

def redis_cache(ttl=3600):
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            anahtar = f"cache:{f.__name__}:{args}:{kwargs}"
            sonuc = r.get(anahtar)
            if sonuc:
                return json.loads(sonuc)
            deger = f(*args, **kwargs)
            r.set(anahtar, json.dumps(deger), ex=ttl)
            return deger
        return wrapper
    return decorator

@redis_cache(ttl=600)
def kullanici_bul(kullanici_id):
    # DB'den oku
    return {"id": kullanici_id, "ad": "Fahri"}

---

8) Güvenlik (Security)

8.1 Kimlik Doğrulama (Authentication)

# redis.conf
requirepass "guclu-ve-uzun-sifre-kullan"

# Redis 6+ ACL (Access Control List)
ACL SETUSER uygulama on >sifre123 ~uygulama:* +get +set +del +hset +hget +hgetall
ACL SETUSER sadece_oku on >okusifre ~* +get +mget +hgetall -@write

# ACL listele
ACL LIST
ACL WHOAMI

8.2 Ağ Güvenliği (Network Security)

# redis.conf
bind 127.0.0.1 -::1          # sadece localhost'tan erişim
protected-mode yes             # harici erişimi engelle

# Tehlikeli komutları devre dışı bırak
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command DEBUG ""
rename-command CONFIG "gizli_config_komutu"

8.3 TLS/SSL

# redis.conf
tls-port 6380
port 0                        # şifrelenmemiş portu kapat
tls-cert-file /etc/redis/tls/redis.crt
tls-key-file /etc/redis/tls/redis.key
tls-ca-cert-file /etc/redis/tls/ca.crt

// ioredis TLS bağlantısı
const redis = new Redis({
  host: "redis.example.com",
  port: 6380,
  tls: {
    ca: fs.readFileSync("/path/to/ca.crt"),
    cert: fs.readFileSync("/path/to/client.crt"),
    key: fs.readFileSync("/path/to/client.key")
  }
});

---

9) İzleme ve Hata Ayıklama (Monitoring & Debugging)

# Gerçek zamanlı komut izleme
redis-cli MONITOR

# Yavaş komutları logla
CONFIG SET slowlog-log-slower-than 10000   # 10ms üstü
CONFIG SET slowlog-max-len 128
SLOWLOG GET 10                              # son 10 yavaş komut

# Bellek kullanımı
INFO memory
MEMORY USAGE anahtar                       # belirli anahtarın bellek kullanımı

# Genel istatistikler
INFO all
INFO stats
INFO replication
INFO keyspace

# İstemci bağlantıları
CLIENT LIST
CLIENT GETNAME
INFO clients

# Büyük anahtarları bul
redis-cli --bigkeys
redis-cli --memkeys

---

10) Performans İpuçları (Performance Tips)

Yap (Do)

• Anlamlı ve tutarlı anahtar isimlendirme kullan: nesne:id:alan (örnek: kullanici:42:profil)
• Büyük verileri silmek için DEL yerine UNLINK kullan (non-blocking)
• Pipeline kullanarak ağ gidiş-dönüşünü azalt
• Uygun TTL değerleri belirle, belleği gereksiz doldurma
• Büyük hash/list/set yerine parçalanmış (sharded) yapılar kullan
• SCAN kullan, KEYS kullanma (üretimde)
• Connection pooling veya multiplexing kullan
• Sentinel veya Cluster ile yüksek erişilebilirlik sağla

Yapma (Don't)

• Redis'i birincil veritabanı olarak kullanma (veri kaybı riski)
• Çok büyük value'lar saklama (>100KB performansı düşürür)
• KEYS * komutunu üretimde kullanma (tüm sunucuyu bloklar)
• Her işlem için yeni bağlantı açma (bağlantı maliyeti yüksek)
• FLUSHALL / FLUSHDB komutlarını korumasız bırakma
• Persistence olmadan kritik veri saklama
• Tek bir Redis instance'ına aşırı yüklenme (Cluster kullan)
• Lua scriptlerde uzun süreli işlemler yapma (sunucuyu bloklar)

Bellek Optimizasyonu (Memory Optimization)

# redis.conf
maxmemory 2gb
maxmemory-policy allkeys-lru   # bellek dolunca en az kullanılanı sil

# Diğer politikalar:
# volatile-lru    : TTL olan anahtarlardan LRU ile sil
# allkeys-lru     : tüm anahtarlardan LRU ile sil
# volatile-ttf    : en kısa TTL'yi önce sil
# allkeys-random  : rastgele sil
# noeviction      : yazma işlemlerini reddet (varsayılan)

---

11) Redis vs Alternatifler (Alternatives Comparison)

Özellik	Redis	Memcached	Valkey	KeyDB
Veri tipleri	Zengin	Sadece string	Zengin (Redis uyumlu)	Zengin (Redis uyumlu)
Persistence	Evet (RDB/AOF)	Hayır	Evet	Evet
Cluster	Evet	Hayır (istemci taraflı)	Evet	Evet
Pub/Sub	Evet	Hayır	Evet	Evet
Multi-threaded	Hayır (tek thread)	Evet	Hayır	Evet
Lisans	SSPL (v7.4+)	BSD	BSD	BSD
Lua scripting	Evet	Hayır	Evet	Evet

---

İlgili Rehberler (Related Guides)

Veritabanı (Database)

• Veritabanı Genel Bakış
• MySQL
• PostgreSQL
• SQLite
• MSSQL
• MongoDB

Diğer Kategoriler (Other Categories)

• Backend Genel Bakış
• Frontend Genel Bakış
• DevOps Genel Bakış
• Teknoloji Genel Bakış