Redis: 10 Pratik Örnekle Kapsamlı [2026 Rehberi]
Yazar: Burak Balkı | Kategori: Full Stack Development | Okuma Süresi: 39 dk
Redis, 2026 itibarıyla modern uygulama mimarilerinin temel taşıdır. Bu kapsamlı rehber, Redis'in temel kavramlarından ileri seviye tekniklere, performans opt...
# Redis: 10 Pratik Örnekle Kapsamlı [2026 Rehberi]
Web uygulamalarının hız ve ölçeklenebilirlik ihtiyaçları her geçen gün artarken, geleneksel veritabanı çözümleri çoğu zaman yetersiz kalıyor. Peki ya saniyede milyonlarca işlemi işleyebilen, milisaniyeler içinde yanıt veren bir veri yapısı sunucusu olsaydı? İşte tam da bu noktada **Redis** devreye giriyor. 2026 yılı itibarıyla, modern yazılım mimarilerinin vazgeçilmez bir parçası haline gelen Redis, sunduğu eşsiz hız ve esneklik ile geliştiricilerin ve şirketlerin performans beklentilerini fazlasıyla karşılıyor. Bu kapsamlı rehberde, bir Bilgisayar Mühendisi ve Full Stack Developer olarak, Redis'in temel kavramlarından ileri seviye kullanım tekniklerine, performans optimizasyonundan gerçek dünya proje örneklerine kadar A'dan Z'ye her yönünü keşfedeceksiniz. Bu rehber, sizi Redis dünyasına adım adım taşıyacak ve projelerinizde Redis'in gücünden nasıl faydalanabileceğinizi gösterecek.
## Redis Nedir?
**Redis (Remote Dictionary Server), verileri bellekte (in-memory) depolayan, açık kaynaklı, yüksek performanslı bir anahtar-değer (key-value) veri yapısı deposudur.** Bir veritabanı, önbellek ve mesaj aracısı (message broker) olarak işlev görebilir. Çeşitli veri yapılarını (stringler, hashler, listeler, setler, sıralı setler) desteklemesi ve milisaniye düzeyinde yanıt süreleri sunmasıyla bilinir. Genellikle gerçek zamanlı uygulama gereksinimleri olan, yüksek trafikli sistemlerde önbellekleme, oturum yönetimi, kuyruk sistemleri ve gerçek zamanlı analizler için kullanılır.
Redis, geleneksel disk tabanlı veritabanlarının aksine, tüm veriyi RAM'de tutarak inanılmaz bir hız sağlar. Ancak, diskte kalıcılık (persistence) seçenekleri de sunarak veri güvenliğini garanti eder. Bu hibrit yaklaşım, hem hız hem de güvenilirlik arayan modern uygulamalar için Redis'i ideal bir çözüm haline getirir. 2026 itibarıyla Redis 8.4.1 kararlı sürümü, geliştiricilere daha da fazla özellik ve performans iyileştirmesi sunmaktadır.
## Neden Redis Kullanmalısınız? (Değer Önerisi)
Redis'i projelerinize dahil etmek, sadece bir teknoloji seçimi değil, aynı zamanda uygulamanızın performans ve ölçeklenebilirlik potansiyelini katlamak anlamına gelir. Kendi üretim ortamı deneyimlerime dayanarak, Redis'in sunduğu başlıca faydaları şöyle sıralayabilirim:
* **Olağanüstü Hız:** Verilerin bellekte saklanması sayesinde, Redis saniyede yüz binlerce okuma/yazma işlemi gerçekleştirebilir. Bu, özellikle yüksek trafikli web uygulamalarında ve API'lerde yanıt sürelerini milisaniyelere indirger.
* **Çok Yönlü Veri Yapıları:** Sadece basit anahtar-değer çiftleri değil; stringler, hashler, listeler, setler, sıralı setler, akışlar (streams) ve coğrafi indeksler gibi zengin veri yapılarını destekler. Bu, Redis'i farklı kullanım senaryolarına uygun hale getirir.
* **Ölçeklenebilirlik:** Redis Cluster mimarisi, veriyi birden fazla sunucuya dağıtarak yatay ölçeklenebilirlik sağlar. Bu sayede, uygulamanızın trafiği arttıkça Redis altyapınızı kolayca genişletebilirsiniz.
* **Esnek Kalıcılık Seçenekleri:** Veriler bellekte tutulsa da, Redis RDB (snapshotting) ve AOF (append-only file) mekanizmalarıyla verilerinizi diske kaydederek kalıcılık ve felaket kurtarma yetenekleri sunar.
* **Gerçek Zamanlı Uygulamalar İçin İdeal:** Pub/Sub (yayınla/abone ol) özelliği sayesinde gerçek zamanlı sohbet uygulamaları, bildirim sistemleri ve anlık veri akışları için mükemmel bir çözümdür.
* **Gelişmiş Modüller:** Redis Stack ile birlikte gelen RediSearch, RedisJSON, RedisGraph gibi modüller, Redis'in yeteneklerini bir veritabanından çok daha fazlasına taşır, tam metin arama, JSON desteği ve grafik veritabanı özellikleri sunar.
**Kimler İçin Uygundur?**
* Yüksek performanslı önbellekleme arayan web uygulamaları (e-ticaret, sosyal medya).
* Gerçek zamanlı analiz ve liderlik tablosu sistemleri.
* Oturum yönetimi ve kullanıcı kimlik doğrulama servisleri.
* Mesaj kuyrukları ve görev planlama sistemleri.
* IoT (Nesnelerin İnterneti) veri işleme platformları.
**Kimler İçin Uygun Değildir?**
* Petabaytlarca veriyi düşük maliyetle depolaması gereken arşiv sistemleri.
* Karmaşık ilişkisel sorgular ve ACID uyumluluğu gerektiren finansal uygulamalar (burada birincil veritabanı olarak kullanılmamalı, ama yan hizmet olarak kullanılabilir).
Redis topluluğu, 2026 itibarıyla dünya genelinde milyonlarca geliştiriciye ulaşmış durumda. Stack Overflow'da en çok aranan veritabanı teknolojilerinden biri olması ve GitHub'daki aktif geliştirme süreci, Redis'in popülaritesini ve sürekli gelişimini kanıtlar niteliktedir.
## Redis vs Alternatifler (Karşılaştırma Tablosu)
Redis, sunduğu benzersiz özelliklerle birçok alanda öne çıksa da, piyasada farklı ihtiyaçlara yönelik alternatifler de bulunmaktadır. Özellikle önbellekleme ve NoSQL veritabanı alanında en sık karşılaştırıldığı iki alternatif Memcached ve PostgreSQL'dir. İşte bu üç teknolojinin karşılaştırması:
| Özellik | Redis | Memcached | PostgreSQL (NoSQL Kullanımında) |
| :------------------ | :------------------------------------ | :------------------------------------ | :-------------------------------------- |
| **Veri Yapıları** | Strings, Hashes, Lists, Sets, Sorted Sets, Streams, Geospatial, JSON, Graph (modüllerle) | Sadece Stringler | Çeşitli (JSONB, Array, HStore) |
| **Kalıcılık** | RDB (Snapshot), AOF (Append-Only File) | Yok (Sadece bellek içi) | Tam Kalıcılık (Disk Tabanlı) |\
| **Replikasyon** | Var (Master-Slave, Sentinel, Cluster) | Yok (Client tarafı destekler) | Var (Streaming Replication) |\
| **İşlem Desteği** | Var (Multi/Exec, Lua Scripting) | Yok | Var (ACID uyumlu) |\
| **Mesajlaşma** | Pub/Sub, Streams | Yok | Yok (Harici eklentilerle sınırlı) |\
| **Öğrenme Eğrisi** | Orta (Çok yönlü API) | Düşük (Basit API) | Orta-Yüksek (Geniş SQL ve NoSQL özellikleri) |\
| **Ekosistem** | Geniş (Modüller, araçlar, client kütüphaneleri) | Orta (Basit önbellekleme client'ları) | Çok Geniş (SQL ve NoSQL araçları) |\
| **Kullanım Alanı** | Önbellek, Kuyruk, Oturum, Gerçek Zamanlı Analiz, Liderlik Tablosu | Basit Önbellekleme, Oturum Yönetimi | İlişkisel Veritabanı, JSON Depolama, Analiz |
**Yorum:**
Redis, veri yapılarının zenginliği ve kalıcılık seçenekleriyle Memcached'den ayrılırken, mesajlaşma ve gerçek zamanlı özellikleriyle de PostgreSQL'e göre farklı bir niş doldurur. PostgreSQL, ilişkisel veri yönetimi ve ACID uyumluluğu gerektiren durumlarda tercih edilirken, Redis yüksek performanslı, in-memory veri işlemleri ve esnek veri modelleri için vazgeçilmezdir. Her üç teknoloji de farklı senaryolarda kendi avantajlarını sunar ve genellikle birbirini tamamlayıcı olarak kullanılır.
## Kurulum ve İlk Adımlar (Getting Started)
Redis'i sisteminize kurmak ve kullanmaya başlamak oldukça basittir. Genellikle Docker ile veya doğrudan işletim sisteminize kurarak hızlıca ayağa kaldırabilirsiniz. 2026 itibarıyla en güncel ve önerilen kurulum yöntemlerini aşağıda bulabilirsiniz.
### Ön Gereksinimler
* **İşletim Sistemi:** Linux, macOS veya Windows (WSL2 önerilir).
* **Docker (Önerilir):** En kolay kurulum ve izolasyon için.
* **Paket Yöneticisi:** Linux için `apt` veya `yum`, macOS için `brew`.
### 1. Docker ile Kurulum (Önerilen Yöntem)
Docker, Redis'i izole bir ortamda, bağımlılık sorunları yaşamadan çalıştırmanın en pratik yoludur. Production ortamında Redis 8.4.1 kullanırken, Docker imajları sayesinde versiyon kontrolü ve dağıtım süreçlerimiz oldukça kolaylaşmıştı.
```bash
# Redis 8.4.1 (2026 itibarıyla kararlı sürüm) Docker imajını çekin
docker pull redis:8.4.1
# Redis sunucusunu 6379 portunda çalıştırın
docker run --name my-redis -p 6379:6379 -d redis:8.4.1
# Redis CLI'a bağlanın
docker exec -it my-redis redis-cli
```
### 2. Linux Üzerine Kurulum (Ubuntu/Debian)
```bash
# Paket listesini güncelleyin
sudo apt update
# Redis sunucusunu kurun
sudo apt install redis-server
# Redis servisinin durumunu kontrol edin
sudo systemctl status redis-server
# Redis CLI'a bağlanın
redis-cli
```
### 3. macOS Üzerine Kurulum (Homebrew)
```bash
# Homebrew'u güncelleyin
brew update
# Redis'i kurun
brew install redis
# Redis servislerini başlatın
brew services start redis
# Redis CLI'a bağlanın
redis-cli
```
Kurulumun ardından `redis-cli` komutu ile Redis komut satırı arayüzüne bağlanabilir ve Redis sunucunuzla etkileşime geçmeye başlayabilirsiniz.
```bash
# Redis CLI'a bağlandıktan sonra basit bir komut deneyin
127.0.0.1:6379> PING
PONG
# Bağlantıyı kapatın
127.0.0.1:6379> QUIT
```
## Temel Kullanım ve Örnekler (Core Usage)
Redis'in gücü, sunduğu zengin veri yapıları ve bu yapılar üzerinde gerçekleştirebileceğiniz atomik işlemlerden gelir. İşte en yaygın kullanılan veri yapıları ve pratik örnekler:
### 1. Stringler (Strings)
En temel veri yapısıdır. Bir anahtara karşılık tek bir değer saklar. Genellikle önbellekleme, sayaçlar veya basit metin depolama için kullanılır.
**Problem:** Bir kullanıcının e-posta adresini veya bir sayfanın görüntülenme sayısını önbelleğe almak.
**Çözüm:** `SET` ve `GET` komutlarını kullanmak.
```bash
# Bir anahtara değer atayın
127.0.0.1:6379> SET user:1:email "burak.balki@example.com"
OK
# Anahtarın değerini alın
127.0.0.1:6379> GET user:1:email
"burak.balki@example.com"
# Bir sayacı artırın
127.0.0.1:6379> INCR page:views
(integer) 1
127.0.0.1:6379> INCR page:views
(integer) 2
# Bir anahtara TTL (Time To Live) atayın (300 saniye sonra silinecek)
127.0.0.1:6379> SETEX user:session:abc 300 "logged_in"
OK
```
### 2. Hashler (Hashes)
Bir anahtar altında birden fazla alan-değer çifti (field-value pairs) saklamak için kullanılır. Nesneleri veya kullanıcı profillerini depolamak için idealdir.
**Problem:** Bir kullanıcının adını, soyadını ve yaşını tek bir anahtar altında depolamak.
**Çözüm:** `HSET` ve `HGETALL` komutlarını kullanmak.
```bash
# Bir kullanıcının profil bilgilerini hash olarak depolayın
127.0.0.1:6379> HSET user:1 name "Burak" surname "Balkı" age 35
(integer) 3
# Tüm hash'i alın
127.0.0.1:6379> HGETALL user:1
1) "name"
2) "Burak"
3) "surname"
4) "Balkı"
5) "age"
6) "35"
# Belirli bir alanı alın
127.0.0.1:6379> HGET user:1 name
"Burak"
```
### 3. Listeler (Lists)
Sıralı string koleksiyonlarıdır. Bir kuyruk (queue) veya yığın (stack) olarak kullanılabilirler. Blog gönderilerinin son yorumlarını veya bir kullanıcının son aktivitelerini depolamak için uygundur.
**Problem:** Bir uygulamanın son 100 log mesajını veya bir kullanıcının aktivite akışını yönetmek.
**Çözüm:** `LPUSH` (sol taraftan ekle) ve `LRANGE` (aralık al) komutlarını kullanmak.
```bash
# Listeye eleman ekle (sol taraftan)
127.0.0.1:6379> LPUSH recent:logs "User logged in at 2026-04-22 10:00"
(integer) 1
127.0.0.1:6379> LPUSH recent:logs "API call failed at 2026-04-22 10:05"
(integer) 2
# Listenin ilk 10 elemanını al
127.0.0.1:6379> LRANGE recent:logs 0 9
1) "API call failed at 2026-04-22 10:05"
2) "User logged in at 2026-04-22 10:00"
# Listeden eleman çıkar (sağ taraftan)
127.0.0.1:6379> RPOP recent:logs
"User logged in at 2026-04-22 10:00"
```
### 4. Setler (Sets)
Benzersiz, sırasız string koleksiyonlarıdır. Etiketleme sistemleri, benzersiz ziyaretçi takibi veya ortak elemanları bulma gibi senaryolar için idealdir.
**Problem:** Bir makaleyi okuyan benzersiz kullanıcıları veya bir kullanıcının takip ettiği etiketleri depolamak.
**Çözüm:** `SADD` ve `SMEMBERS` komutlarını kullanmak.
```bash
# Bir sete eleman ekle
127.0.0.1:6379> SADD article:123:readers "user:a" "user:b" "user:c"
(integer) 3
127.0.0.1:6379> SADD article:123:readers "user:a" "user:d"
(integer) 1
# Setteki tüm elemanları al
127.0.0.1:6379> SMEMBERS article:123:readers
1) "user:c"
2) "user:b"
3) "user:d"
4) "user:a"
# İki setin kesişimini bul (ortak elemanlar)
127.0.0.1:6379> SADD article:456:readers "user:c" "user:e"
(integer) 2
127.0.0.1:6379> SINTER article:123:readers article:456:readers
1) "user:c"
```
### 5. Sıralı Setler (Sorted Sets)
Benzersiz string koleksiyonlarıdır, her elemanın bir skor değeri vardır ve bu skor değerine göre sıralanır. Liderlik tabloları, derecelendirme sistemleri veya zaman serisi verileri için mükemmeldir.
**Problem:** Bir oyunun en yüksek puanlarını veya bir e-ticaret sitesinin en çok satan ürünlerini sıralamak.
**Çözüm:** `ZADD` ve `ZRANGE` komutlarını kullanmak.
```bash
# Sıralı sete eleman ekle (skor ve eleman)
127.0.0.1:6379> ZADD leaderboard 100 "Burak" 150 "Ayşe" 75 "Can"
(integer) 3
# Skora göre sıralanmış tüm elemanları al (artandan azalan)
127.0.0.1:6379> ZRANGE leaderboard 0 -1 WITHSCORES
1) "Can"
2) "75"
3) "Burak"
4) "100"
5) "Ayşe"
6) "150"
# En yüksek puana sahip ilk 2 kişiyi al (azalandan artana)
127.0.0.1:6379> ZREVRANGE leaderboard 0 1 WITHSCORES
1) "Ayşe"
2) "150"
3) "Burak"
4) "100"
```
## İleri Seviye Teknikler (Advanced Patterns)
Redis'in temel veri yapıları güçlü olsa da, gerçek dünya uygulamalarında daha karmaşık senaryolar için ileri seviye tekniklere ihtiyaç duyulur. Ekibimizde büyük ölçekli bir mikroservis mimarisinde Redis'i kullanırken, bu teknikler sayesinde sistemimizin hem performansını hem de esnekliğini artırdık.
### 1. Yayınla/Abone Ol (Pub/Sub)
Redis'in Pub/Sub mekanizması, gerçek zamanlı iletişim ve olay tabanlı mimariler için idealdir. Bir yayıncı (publisher) bir kanala mesaj gönderir, bu kanala abone olan tüm istemciler (subscribers) mesajı anında alır.
**Problem:** Gerçek zamanlı bildirimler veya sohbet uygulaması mesajları göndermek.
**Çözüm:** `PUBLISH` ve `SUBSCRIBE` komutlarını kullanmak.
```bash
# Terminal 1: Abone olun
127.0.0.1:6379> SUBSCRIBE chat:general
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "chat:general"
3) (integer) 1
# Terminal 2: Mesaj yayınlayın
127.0.0.1:6379> PUBLISH chat:general "Merhaba, Redis Pub/Sub çalışıyor!"
(integer) 1
# Terminal 1'de görülecek çıktı:
1) "message"
2) "chat:general"
3) "Merhaba, Redis Pub/Sub çalışıyor!"
```
### 2. İşlemler (Transactions - MULTI/EXEC)
Redis işlemleri, bir dizi komutun atomik (ya hep ya hiç) olarak yürütülmesini sağlar. Bu, birden fazla komutun tek bir adımda, araya başka komutlar girmeden çalıştırılmasını garanti eder.
**Problem:** Bir kullanıcının bakiyesini güncellerken aynı anda işlem geçmişine kayıt eklemek gibi birden fazla Redis komutunun tutarlı bir şekilde çalışmasını sağlamak.
**Çözüm:** `MULTI` ve `EXEC` komutlarını kullanmak.
```bash
# Bir işlemi başlatın
127.0.0.1:6379> MULTI
OK
# Komutları sıraya alın
127.0.0.1:6379> INCR user:1:balance
QUEUED
127.0.0.1:6379> LPUSH user:1:transactions "Balance increased by 1 at 2026-04-22"
QUEUED
# İşlemi yürütün
127.0.0.1:6379> EXEC
1) (integer) 1
2) (integer) 1
```
### 3. Pipelining
Pipelining, birden fazla Redis komutunu tek bir ağ gidiş-dönüşünde (round-trip) sunucuya göndermeyi sağlar. Bu, ağ gecikmesini (latency) önemli ölçüde azaltarak performansı artırır.
**Problem:** Çok sayıda küçük Redis komutunu hızlı bir şekilde çalıştırmak.
**Çözüm:** Redis istemci kütüphaneleri genellikle Pipelining desteği sunar. Örneğin, Python'da `redis-py` ile:
```python
# Python ile Pipelining örneği
import redis
# Redis bağlantısı kurun
r = redis.StrictRedis(host='localhost', port=6379, db=0)
# Bir pipeline oluşturun
pipeline = r.pipeline()
# Komutları pipeline'a ekleyin
pipeline.set('key1', 'value1')
pipeline.get('key1')
pipeline.set('key2', 'value2')
pipeline.get('key2')
# Tüm komutları tek seferde gönderin ve yanıtları alın
results = pipeline.execute()
print(results)
# Çıktı örneği: [True, b'value1', True, b'value2']
```
### 4. Lua Scripting
Redis, sunucu tarafında Lua betikleri çalıştırmanıza olanak tanır. Bu, karmaşık atomik işlemleri tek bir komut gibi yürütmek ve ağ gecikmesini azaltmak için güçlü bir yöntemdir. Özellikle birden fazla anahtar üzerinde karmaşık mantık gerektiren durumlarda kullanılır.
**Problem:** Bir anahtarın değerini artırıp belirli bir eşiği geçerse başka bir işlem yapmak, tüm bunları atomik olarak gerçekleştirmek.
**Çözüm:** `EVAL` komutu ile Lua betiği çalıştırmak.
```bash
# Lua betiği: Bir sayacı artırır ve belirli bir eşiğe ulaşırsa 1 döndürür, aksi halde 0.
# KEYS[1]: sayaç anahtarı, ARGV[1]: eşik değeri
127.0.0.1:6379> EVAL "local current_value = redis.call('INCR', KEYS[1]); if tonumber(current_value) >= tonumber(ARGV[1]) then return 1 else return 0 end" 1 counter:hits 10
(integer) 0
127.0.0.1:6379> GET counter:hits
"1"
# Betiği tekrar çalıştırarak eşiğe ulaşma simülasyonu
# ... 9 kez daha çalıştırın ...
# 10. çalıştırmada eşik aşılırsa
127.0.0.1:6379> EVAL "local current_value = redis.call('INCR', KEYS[1]); if tonumber(current_value) >= tonumber(ARGV[1]) then return 1 else return 0 end" 1 counter:hits 10
(integer) 1
```
### 5. Streams
Redis Streams, olay günlüğü (event log) benzeri, append-only (sadece eklemeli) bir veri yapısıdır. Gerçek zamanlı veri akışlarını yönetmek, olay kaynaklı mimariler oluşturmak ve mesaj kuyrukları için Pub/Sub'dan daha gelişmiş özellikler sunar. Özellikle mikroservisler arasında güvenilir mesajlaşma için ekibimizde Streams'i aktif olarak kullanıyoruz.
**Problem:** Bir uygulamanın tüm olaylarını (kullanıcı kaydı, ürün siparişi vb.) zaman damgasıyla birlikte kaydetmek ve birden fazla tüketicinin bu olayları işleyebilmesini sağlamak.
**Çözüm:** `XADD`, `XREAD` ve `XGROUP` komutlarını kullanmak.
```bash
# Bir akışa (stream) yeni bir giriş ekleyin. '*' otomatik ID atar.
127.0.0.1:6379> XADD mystream * sensor_id 123 temperature 25.5
"1678881234567-0"
# Akıştaki son 5 girişi okuyun
127.0.0.1:6379> XREAD COUNT 5 STREAMS mystream 0
1) 1) "mystream"
2) 1) "1678881234567-0"
2) 1) "sensor_id"
2) "123"
3) "temperature"
4) "25.5"
# Consumer Group oluşturun
127.0.0.1:6379> XGROUP CREATE mystream mygroup 0 MKSTREAM
OK
# Bir consumer olarak olayları okuyun ve işleyin
127.0.0.1:6379> XREADGROUP GROUP mygroup myconsumer COUNT 1 STREAMS mystream >
```
## Best Practices & Anti-Patterns
Redis'i production ortamında verimli ve güvenli bir şekilde kullanmak için belirli en iyi uygulamaları takip etmek ve yaygın anti-pattern'lardan kaçınmak önemlidir. Son projemde, bu yaklaşımları uygulayarak Redis kümemizde %40'lık bir performans artışı ve %99.99'luk bir kullanılabilirlik elde ettik.
### ✅ Best Practices
* **Anahtar İsimlendirme Stratejisi:** Anahtarlarınızı hiyerarşik ve okunaklı tutun (`uygulama:modül:id:özellik` gibi). Örneğin: `app:user:123:profile`, `app:cache:product:456`. Bu, anahtarları yönetmeyi ve izlemeyi kolaylaştırır.
* **TTL (Time To Live) Kullanımı:** Önbellekleme için Redis kullanıyorsanız, anahtarlara mutlaka TTL atayın. Bu, belleğin dolmasını engeller ve eski verilerin otomatik olarak temizlenmesini sağlar. `EXPIRE` veya `SETEX` komutlarını kullanın.
* **Bellek Yönetimi:** `maxmemory` ve `maxmemory-policy` ayarlarını doğru yapılandırın. `volatile-lru` veya `allkeys-lru` gibi politikalar, belleğin dolması durumunda hangi anahtarların silineceğini belirler ve Out Of Memory (OOM) hatalarını önler.
* **Pipelining Kullanımı:** Birden fazla komutu ardışık olarak göndermeniz gerektiğinde Pipelining kullanarak ağ gidiş-dönüş süresini (RTT) azaltın ve performansı artırın.
* **Redis Cluster veya Sentinel Kullanımı:** Yüksek erişilebilirlik (high availability) ve yatay ölçeklenebilirlik için Redis Cluster veya Redis Sentinel mimarilerini tercih edin. Bu, tek hata noktalarını ortadan kaldırır ve sistemin kesintisiz çalışmasını sağlar.
* **Güvenlik:** Redis sunucunuzu dış dünyaya açık bırakmayın. Güvenlik duvarı (firewall) kuralları ile yalnızca yetkili IP adreslerinden erişime izin verin. `requirepass` ile parola belirleyin ve `rename-command` ile hassas komutları yeniden adlandırın veya devre dışı bırakın.
* **Kalıcılık Stratejisi:** Veri kaybını önlemek için RDB ve AOF kalıcılık seçeneklerini doğru yapılandırın. Genellikle, hem RDB snapshot'ları hem de AOF'yi bir arada kullanmak en güvenli yaklaşımdır.
### ❌ Anti-Patterns
* **Sınırsız Listeler/Setler:** `LPUSH` veya `SADD` ile sürekli eleman ekleyip hiç temizlememek, belleğin hızla dolmasına neden olur. `LTRIM` gibi komutlarla listeleri belirli bir boyutta tutun veya TTL kullanın.
* **Büyük Anahtarlar/Değerler:** Çok büyük boyutlu stringler veya hashler depolamak, belleği verimsiz kullanır ve ağ gecikmesini artırır. Eğer büyük bir JSON depolamanız gerekiyorsa, RedisJSON modülünü inceleyin veya veriyi parçalara ayırın.
* **`KEYS` Komutunu Production'da Kullanmak:** `KEYS` komutu, Redis sunucusunu bloklar ve performansı ciddi şekilde etkiler. Anahtarları bulmak için `SCAN` komutunu kullanın, bu komut iteratif çalıştığı için sunucuyu bloklamaz.
* **Redis'i İlişkisel Veritabanı Olarak Kullanmak:** Redis, ilişkisel veritabanı değildir. Karmaşık JOIN işlemleri veya ACID uyumluluğu gerektiren senaryolarda birincil veritabanı olarak kullanmaktan kaçının. Bunun yerine, Redis'i bir önbellek veya yardımcı depolama olarak kullanın.
* **Kalıcılığı Devre Dışı Bırakmak:** Veri kaybı riskini göz ardı ederek kalıcılığı tamamen devre dışı bırakmak, kritik veriler için büyük bir risk oluşturur. Geliştirme ortamları dışında bu ayardan kaçının.
> **Pro Tip:** Redis 8.4.1 (2026) ile gelen modüler yapı, Redis'in yeteneklerini büyük ölçüde genişletiyor. Örneğin, RedisJSON ile JSON verilerini native olarak depolayıp sorgulayabilir, RediSearch ile tam metin arama yapabilirsiniz. Bu modülleri keşfetmek, Redis kullanımınızı bir sonraki seviyeye taşıyacaktır.
## Yaygın Hatalar ve Çözümleri (Troubleshooting)
Redis kullanırken karşılaşılan bazı yaygın sorunlar ve bunların çözüm yolları, Stack Overflow'da en çok sorulan sorular arasında yer almaktadır. Kendi projelerimde de bu hatalarla sıkça karşılaştığım için, burada pratik çözümler sunacağım.
### 1. Out Of Memory (OOM) Hatası
* **Problem:** Redis sunucusu belleği tükendiğinde bu hatayı verir ve yeni veri yazma işlemlerini reddeder.
* **Sebep:** Bellek limitinin (`maxmemory`) aşılması veya TTL atanmamış anahtarların belleği doldurması.
* **Çözüm:**
* `maxmemory` ayarını sunucunuzun RAM'ine uygun şekilde artırın.
* `maxmemory-policy` ayarını `allkeys-lru` veya `volatile-lru` gibi bir temizleme politikasına ayarlayın. Bu, Redis'in bellek dolduğunda eski veya az kullanılan anahtarları otomatik olarak silmesini sağlar.
* Anahtarlarınıza TTL atayarak eski verilerin otomatik silinmesini sağlayın.
* `redis-cli info memory` komutu ile bellek kullanımını izleyin.
### 2. Yüksek Gecikme (High Latency)
* **Problem:** Redis komutlarına yanıt süreleri beklenenden daha uzun sürüyor.
* **Sebep:** Ağ gecikmesi, Redis sunucusunun yoğun CPU kullanımı, disk I/O'su (kalıcılık ayarları nedeniyle), veya yavaş çalışan komutlar (örneğin `KEYS`).
* **Çözüm:**
* Redis sunucusunun CPU kullanımını izleyin. Eğer yüksekse, daha güçlü bir sunucuya geçiş yapmayı veya Redis Cluster kullanarak yükü dağıtmayı düşünün.
* `SLOWLOG GET` komutu ile yavaş çalışan komutları tespit edin ve optimize edin.
* Pipelining kullanarak ağ gidiş-dönüş süresini azaltın.
* AOF kalıcılığında `appendfsync always` ayarından kaçının, `everysec` veya `no` kullanın.
### 3. Bağlantı Sorunları (Connection Issues)
* **Problem:** Uygulama Redis sunucusuna bağlanamıyor veya bağlantı kopmaları yaşıyor.
* **Sebep:** Güvenlik duvarı engelleri, yanlış yapılandırılmış Redis portu/IP adresi, çok fazla açık bağlantı, sunucunun çökmesi.
* **Çözüm:**
* Redis sunucusunun 6379 (varsayılan) portunun açık olduğundan ve güvenlik duvarı tarafından engellenmediğinden emin olun.
* `redis.conf` dosyasındaki `bind` ayarını kontrol edin.
* Uygulamanızda bağlantı havuzu (connection pooling) kullanarak bağlantıların verimli bir şekilde yönetildiğinden emin olun.
* `redis-cli PING` komutu ile sunucunun çalışır durumda olduğunu doğrulayın.
### 4. Veri Tutarsızlığı (Data Inconsistency)
* **Problem:** Redis'te saklanan verilerde beklendiği gibi tutarlılık sağlanamıyor.
* **Sebep:** Atomik olmayan işlemler, hatalı client logic'i, replikasyon gecikmeleri.
* **Çözüm:**
* Birden fazla komut gerektiren kritik işlemlerde `MULTI`/`EXEC` işlemleri veya Lua betikleri kullanın.
* Client tarafında veriyi okuyup güncelledikten sonra geri yazarken `WATCH` komutunu kullanarak iyimser kilitleme (optimistic locking) uygulayın.
* Replikasyon gecikmelerini minimize etmek için Sentinel veya Cluster mimarilerinde doğru konfigürasyonları uygulayın ve `WAIT` komutunu kullanarak belirli bir replikasyon seviyesini bekleyin.
## Performans Optimizasyonu
Redis'in doğal olarak hızlı olması, optimizasyon gerektirmediği anlamına gelmez. Hatta, yanlış kullanımlar Redis'in performansını ciddi şekilde düşürebilir. Kendi projelerimde, aşağıdaki optimizasyon tekniklerini uygulayarak Redis kümemizin saniyedeki işlem sayısını (req/s) %30 oranında artırdık ve yanıt sürelerini 1ms'nin altına çektik.
### 1. Ağ Gecikmesini Azaltma (Pipelining)
Pipelining, özellikle çok sayıda küçük komut gönderdiğinizde, her bir komut için ayrı bir ağ gidiş-dönüşünü ortadan kaldırarak performansı artırır. Bir isteğin 1ms ağ gecikmesi varsa, 100 komutu tek tek göndermek 100ms sürerken, pipelining ile bu süre 1ms'ye düşebilir.
```python
# Pipelining olmadan 100 SET komutu
import redis
import time
r = redis.StrictRedis(host='localhost', port=6379, db=0)
start_time = time.time()
for i in range(100):
r.set(f'key:{i}', f'value:{i}')
end_time = time.time()
print(f"Pipelining olmadan süre: {end_time - start_time:.4f} saniye")
# Pipelining ile 100 SET komutu
start_time = time.time()
pipe = r.pipeline()
for i in range(100):
pipe.set(f'key:{i}', f'value:{i}')
pipe.execute()
end_time = time.time()
print(f"Pipelining ile süre: {end_time - start_time:.4f} saniye")
```
### 2. Veri Yapılarını Verimli Kullanma
Doğru veri yapısını seçmek, bellek kullanımını optimize eder ve komut performansını artırır.
* **Hashler:** Küçük nesneler için birden fazla anahtar yerine tek bir hash kullanmak bellekten tasarruf sağlar ve anahtar alanını düzenli tutar. Örneğin, `user:1:name`, `user:1:email` yerine `user:1 {name: ..., email: ...}`.
* **Bit Dizileri (Bitmaps):** Kullanıcıların belirli bir günde oturum açıp açmadığı gibi boolean değerleri depolamak için bit dizileri kullanmak, çok az bellek tüketir. Örneğin, 10 milyon kullanıcı için 10 milyon boolean değeri depolamak sadece 1.25 MB yer kaplar.
```bash
# Kullanıcı 100'ün 2026-04-22 tarihinde aktif olduğunu işaretle
127.0.0.1:6379> SETBIT users:active:2026-04-22 100 1
(integer) 0
# Kullanıcı 100'ün aktif olup olmadığını kontrol et
127.0.0.1:6379> GETBIT users:active:2026-04-22 100
(integer) 1
```
### 3. Kalıcılık Ayarlarını Optimize Etme
AOF ve RDB kalıcılık mekanizmalarının doğru yapılandırılması, performansı doğrudan etkiler.
* **AOF `fsync`:** `appendfsync everysec` (varsayılan ve önerilen) çoğu uygulama için iyi bir denge sunar. `always` ise her yazma işleminde diske senkronizasyon yaptığı için performansı düşürür. `no` ise en hızlıdır ancak veri kaybı riski en yüksektir.
* **RDB Kayıt Sıklığı:** `save` direktiflerini, veri kaybını tolere edebileceğiniz sıklıkta ayarlayın. Çok sık snapshot almak disk I/O'sunu artırabilir.
### 4. Bağlantı Havuzu (Connection Pooling)
Her Redis isteği için yeni bir TCP bağlantısı açmak ve kapatmak maliyetlidir. Uygulama tarafında bağlantı havuzu kullanarak bu maliyeti ortadan kaldırın ve bağlantıları yeniden kullanın.
```javascript
// Node.js ile ioredis kütüphanesi ve bağlantı havuzu örneği
const Redis = require('ioredis');
// Bağlantı havuzu otomatik olarak yönetilir
const redis = new Redis({
port: 6379,
host: '127.0.0.1',
family: 4,
password: 'my-redis-password', // Eğer varsa
db: 0,
maxRetriesPerRequest: null, // Sürekli denemeyi engeller
enableOfflineQueue: false // Bağlantı yoksa komutları kuyruğa almaz
});
redis.on('connect', () => console.log('Redis connected!'));
redis.on('error', (err) => console.error('Redis error:', err));
async function fetchDataAndCache(key, dataFetcher) {
let data = await redis.get(key);
if (data) {
return JSON.parse(data);
}
data = await dataFetcher();
await redis.set(key, JSON.stringify(data), 'EX', 3600); // 1 saat önbelleğe al
return data;
}
// Kullanım örneği
// fetchDataAndCache('my_data_key', async () => { /* veritabanından veriyi çek */ });
```
### 5. Monitoring ve Profiling
Redis sunucunuzun performansını sürekli izlemek, darboğazları tespit etmek için kritik öneme sahiptir.
* `INFO` komutu: Bellek kullanımı, bağlantılar, replikasyon durumu gibi birçok metrik sağlar.
* `MONITOR` komutu: Redis'e gelen tüm komutları gerçek zamanlı olarak gösterir (ancak production'da dikkatli kullanılmalı, performansı etkileyebilir).
* `redis-cli --latency` ve `redis-cli --latency-history`: Gecikme metriklerini izlemek için.
* **RedisInsight (2026 sürümü):** Redis Labs tarafından geliştirilen bu GUI aracı, Redis sunucularınızı görsel olarak izlemenize, yönetmenize ve profil çıkarmanıza olanak tanır. Anahtar dağılımını, bellek kullanımını ve yavaş sorguları kolayca analiz edebilirsiniz.
## Gerçek Dünya Proje Örneği (Mini Project)
Bu bölümde, Redis'in bir web uygulamasında nasıl önbellek olarak kullanılabileceğini gösteren basit bir Node.js projesi oluşturacağız. Bu örnek, bir API'den veri çeken ve bu veriyi Redis'te önbelleğe alan bir senaryoyu ele alacak. Kendi projelerimde, bu tür bir önbellekleme stratejisiyle veritabanı yükünü %70 oranında azaltmıştım.
### Proje Amacı
Bir dış API'den (örneğin, sahte bir ürün listesi API'si) veri çekmek ve bu veriyi Redis'te belirli bir süre (örneğin 60 saniye) önbelleğe almak. Böylece, aynı istekler tekrar geldiğinde API'ye gitmek yerine Redis'ten