Redlock Nedir? .NET ile Dağıtık Kilitleme (Distributed Lock) Uygulaması Nasıl Gerçekleştirilir?
Bu içeriğimizde distributed lock (dağıtık kilit) algoritmalarından biri olan Redlock davranışı üzerine teorik ve pratik olarak incelemede bulunacak ve neden bu davranışa ihtiyaç duyulduğu ve nasıl çalıştığından öte TTL’in neden önemli olduğundan, quorum/majority kavramlarının neler olduğuna kadar derin bir seviyede değerlendirmede bulunuyor olacağız. Hem satırlara eşlik edecek siz değerli okuyucularıma hem de bu satırlarla cebelleşip anlamlı kelam ortaya koymaya çalışan ben deniz şahsıma fazlasıyla katkıda bulunacağına inandığım bu içeriğe hazırsanız başlayalım…
Önce temel problemi ele alarak başlayalım istiyorum… Bir distributed sistemde lock davranışını neden uygularız? Bu sorunun cevabını verdiğimiz taktirde oluşacak farkındalık esasında bu içeriğin odak noktası olacaktır…
El cevap, bir sistemde (ki bu sistem distributed olsun ya da olmasın fark etmez) aynı kaynağa aynı anda birden fazla işlem uygulanıyorsa, doğal olarak bu işlemlerin birbirlerini etkilemesi istenmeyecek, işlem neticelerinde oluşan etkilerin birbirlerinden izole bir şekilde ve ayırtedilebilir bir vaziyette olması tercih edilecektir. Neden mi? Buna şu örnekle daha net bir şekilde izahat getirebiliriz:
│ Database │
└──────┬───────┘
│
┌────────────┴────────────┐
│ │
Application A Application B
Misal olarak, A ve B uygulamalarının aynı banka sistemine bağlı uygulamalar olduğunu varsayalım. Normal şartlarda bu iki uygulamanın aynı bakiye üzerinde gerçekleştirdiği işlemler birbirlerini etkilemeyecek şekilde yönetiliyorsa, uygulamalardan biri işlemi diğerinden önce başlatacak ve kendi işlemini tamamlayarak bakiyeyi güncellemiş olacaktır. Ardından diğer uygulama işlemini gerçekleştirdiğinde, önceki işlemin güncellediği bakiye değerini esas alarak kendi işlemini gerçekleştirecektir. Böylece her iki işlem de bir önceki işlemin sonucunu dikkate alarak güncel bakiye üzerinden yürütülmüş olacaktır. Evet! Bu normal şartlarda böyle olması gerekmektedir. Ancak! her iki uygulama da işlevlerini aynı anda mevcut bakiye değerini okuyup yapmaya kalkarsa (ki bu önlem alınmadığı sürece mümkündür) ciddi beklenmeyen sonuçlarla karşılaşabilme ihtimali yüksek olasıdır.
A → 100 ₺ çek
Bakiye = 900 ₺
B → 100 ₺ çek
Bakiye = 800₺
A → 100 ₺ çek
B → 100 ₺ çek
Bakiye = 800₺
İşte böyle durumlara karşın bizlerin önlem alması gerekmektedir. Bu önlem de aklın yolu bir olarak, herhangi bir T zamanda ilgili kaynağa karşın yalnızca bir process’in ya da thread’in erişeceğinin garantisini sağlamaktır. Ee bunun için de lock davranışını uygulamaktayız…
Yani sistem distributed olsun ya da olmasın lock her yer de aynı şey mi? diye akıllarınızda sual canlanmış olabilir… Mantıksal olarak düşünürsek eğer bu soruya evet cevabını verebiliriz ancak tabi ki de yapısal olarak distributed lock’un daha farklı bir yaklaşım gerektirdiğini söylemekte fayda görmekteyiz!
Şöyle ki;
lock (someObject)
{
DoSomething();
}
ifadesini ele alalım… Bu lock yapılanması aynı process içerisindeki thread’ler arasında çalışacaktır. Örneğin;
int data = 1000;
var _lock = new Lock();
var task1 = Task.Run(async () =>
{
while (data > 0)
{
lock (_lock)
Console.WriteLine($"Task 1 : {data -= 100}");
await Task.Delay(1000);
}
});
var task2 = Task.Run(async () =>
{
while (data > 0)
{
lock (_lock)
Console.WriteLine($"Task 2 : {data += 200}");
await Task.Delay(100);
}
});
var task3 = Task.Run(async () =>
{
while (data > 0)
{
lock (_lock)
Console.WriteLine($"Task 3 : {data %= 3}");
await Task.Delay(1000);
}
});
await Task.WhenAll(task1, task2, task3);
tarzı bir çalışmada lock gayet kullanışlı olacaktır. Ancak sistem şöyleyse;
│
┌──────────┼──────────┐
│ │ │
Server A Server B Server C
Server A’daki lock(...), Server B’yi ilgilendirmeyecektir. Bundan kaynaklı tüm server’lar aynı anda lock’u alabilecektir. İşte böyle bir senaryoda distributed lock gerekmektedir.
Distributed Lock Nedir?
Distributed lock, farklı makinelerde/process’lerde çalışan uygulamaların ortak bir kilit mekanizması üzerinden birbirlerini koordine etmesini sağlayan davranışsal bir yapılanmadır. Burada ortak kilit mekanizması Redis ya da ZooKeeper gibi bir teknoloji olabilir.
Distributed lock esasında, bir kaynağın sahibi benim bilgisini distributed sistemde güvenli biçimde koordine etme probleminin ta kendisidir.
Dolayısıyla konu bir process içerisinde basit bir lock tanımından çok daha karmaşıktır.
Bizler bu içeriğimizde distributed lock’ı Redis üzerinden ele almaya çalışıyor olacağız. Neden mi? Çünkü Redis’in SET [key] [value] NX PX [milliseconds] tarzı atomik işlemlere yatkınlığından dolayı…
[key]: Lock key’e karşılık gelir.[value]: Lock sahibi için benzersiz random bir değerdir.NX: Key yoksa oluşturması gerektiğini ifade eder.PX 10000: 10 saniye sonra bu değerin otomatik expire edileceğini ifade eder.
Böylece misal olarak SET lock:order:123 abc123 NX PX 10000 talimatından sonra 10 saniye içerisinde SET lock:order:123 xyz789 NX PX 10000 talimatı gelirse eğer Redis’te eğer aynı key mevcut olacağından dolayı bu kayıt işlenmeyecek ve böylece distributed lock yapılanmasına uygun bir zemin edinilmiş olunacaktır.
Peki hoca! [value] neden benzersiz random bir değer olmalı?
Value’nun server’lar açısından benzer olması birbirlerini etkileyebilecek ciddi bir ortama sebebiyet verebilmektedir. Şöyle ki; Server A tarafından lock:order:123 key’ine karşılık lock alındığını düşünelim. Diyelim ki 10 saniye sonra bu lock’ın TTL’i dolmuş ve Server B tarafından aynı key karşılığında lock alınmış olsun. Ancak Server A lock’ı bırakmak için geç kalmış olsun ve Server B lock’u aldıktan sonra bırakmaya çalışıyor olsun. İşte böyle bir durumda esasında Server A artık lock sahibi olmayacak ancak lock’u bırakmaya çalışırken Server B’nin de lock’unu silme ihtimaliyle karşı karşıya kalınmış olunacaktır. Bu nedenle lock value’su benzersiz olarak tasarlanmaktadır ki böylece lock’u bırakacak server, süreç içerisinde değer karşılaştırması yaparak doğru lock’u bırakıp bırakmadığını sağlayabilecektir.
Redlock’a Gelirsek…
Velhasıl, şu ana kadar anlattığımız yapı neticesinde aşağıdaki gibi bir mimari şekillenmektedir:
│
▼
Redis
│
▼
SET [key] [value] NX PX [milliseconds]
Evet, burada tek Redis instance’ı üzerinden bir distributed lock yaklaşımı sergilemiş oluyoruz. Zaten Redis’in de önerdiği basit lock modeli kabaca bu şekildedir. Ancak burada ciddi bir sorun söz konusudur! Redis sunucusu yamulursa ne olacağı sorunu!
Zaten şu ana kadar tasarladığımız modelde esasında Redlock davranışını uygulamış olmamaktayız. Redlock, esasında bu son kaygıyı yaşadıktan sonra ortaya koyacağımız yaklaşımın ta kendisidir.
Redlock Nedir? diye sorarsanız temel fikrini şöyle izah edebiliriz;
Redlock, tek Redis sunucusuna güvenmek yerine, birbirinden bağımsız birden fazla Redis master üzerinde aynı lock’u almaya çalışmaktır!
Örneğin 5 adet Redis instance’ı olsun;
│ Redis Node 1 │
├──────────────┤
│ Redis Node 2 │
├──────────────┤
│ Redis Node 3 │
├──────────────┤
│ Redis Node 4 │
├──────────────┤
│ Redis Node 5 │
└──────────────┘
Herhangi bir server lock almak istediğinde bu Redis instance’ların hepsine gidecek ve çoğunluğu elde etmeye çalışacaktır.
/ / | \ \
/ / | \ \
▼ ▼ ▼ ▼ ▼
R1 R2 R3 R4 R5
Yani 5 adet node varsa,
quorum = N / 2 + 1
quorum = 3
şeklinde bir formülasyonla
R2 → OK
R3 → OK
R4 → FAIL
R5 → FAIL
şeklinde lock alınmış olacaktır.
Redis’in resmi Redlock algoritması konuyu 5 bağımsız master örneği üzerinden anlatmaktadır. Ancak bir çok kaynak ve kişi, en az 3 instance üzerinden lock alınmasını şart koşmaktadır.
Redlock’un Çalışma Algoritması
Şimdi de Redlock’un çalışma algoritmasını adım adım bir seyir eşliğinde inceleyelim. Bunun için 5 adet Redis instance’ının olduğu bir senaryo üzerinden örneklendirmede bulunacağız…
R1
R2
R3
R4
R5
Lock TTL’in 10 saniye ve server’ın oluşturduğu random token’ın ise 8f92a1… şeklinde olduğunu varsayalım.
Evet, şimdi adım adım akışın mantığını inceleyebiliriz:
- Adım 1 (zamanı alma)
Server:
start = currentTime()
Örneğin:
10:00:00.000 - Adım 2 (tüm Redis node’larınalock isteği gönderme)
Her Redis’e:
SET resource-lock 8f92a1 NX PX 10000
gibi bir talimat gönderilir.
Redis’ler:R1 → OK
R2 → OK
R3 → OK
R4 → FAIL
R5 → FAILşeklinde cevap döner.
- Adım 3 (Lock alma süresini kontrol etme)
Redlock yaklaşımında server 3 Redis’ten OK aldım diyerek hemen lock’u alamamaktadır! Bir yandan da bu lock’u almak ne kadar sürdü? sorusunu sormaktadır.Örneğin;
TTL = 10 saniyeLock acquisition time = 150 ms
ise
validity = 10,000 – 150
= 9,850 msolacaktır…
Bu demek oluyor ki; Redlock davranışında lock, ancak çoğunluk (majority) elde edilmişse ve toplam edinme süresi (acquisition) kilit geçerliliği (lock validity) süresinden küçükse başarılı kabul edilir.
Neden acquisition süresini TTL’den düşüyoruz? diye sorarsanız eğer bunun nedeni lock’un aslında sonsuza kadar bizim olmamasıdır! Redis’e ulaşmak ve bir lock’u almaya çalışmak esasında lock sürecinin bir parçasıdır. Bundan dolayı gerçek etkin TTL, esas TTL ile lock’un edinme süresinin farkıyla ortaya çıkmaktadır.
Effective TTL = Original TTL – Acquisition Time
- Adım 4 (lock’u alma)
Yukarıdaki adımlarda şartlar geçerli olduğu taktirde yeterli çoğunluk (quorum = 3) sağlanıyorsa eğer ilgili sunucu için lock başarıyla alınacaktır (LOCK ACQUIRED) - Adım 5 (ya lock başarısız olursa!)
Tabi ki de yeterli çoğunluğun sağlanamadığı durumlarda lock alınamayacak, süreç başarısız olacaktır. Misal olarak 5 Redis instance’lı bir çalışmada quorum’un 3 / 5 olması gerekirken aşağıdaki gibi bir senaryoyla karşılaşılırsa;R1 → OK
R2 → FAIL
R3 → FAIL
R4 → FAIL
R5 → FAILgeçmiş olsun… Burada lock failed olacaktır. Hatta ilgili server daha önceden R1’de lock oluşturmuş olsa dahi şu neticede onu bırakacaktır/bırakmalıdır!
8 Kritik Soru / 8 Kritik Cevap
Şimdi konuyu daha net bir şekilde pekiştirebilmemizi sağlayacak içeriğin en verimli noktasına geldik diyebiliriz… Redlock yaklaşımına dair olabilecek en kritik soruları sorup cevaplandıracağız.
Soru 1 | Redlock senaryosunda neden bağımsız Redis master’lar var?
Redlock mimarisinde Redis’in klasik master-replica (primary-replica) yapısından farklı olarak, birbirinden bağımsız çalışan birden fazla Redis master instance’ı kullanılmaktadır. Örneğin beş farklı Redis sunucusu (R1, R2, R3, R4, R5) bulunduğunda uygulama aynı lock’u bu sunucuların her birinde oluşturmaya çalışmakta ve lock’un başarıyla alınmış sayılması için bu sunucuların çoğunluğunda, yani en az üçünde, lock’un elde edilmesi gerekmektedir. Böylece tek bir Redis sunucusunun veya birden fazla sunucunun devre dışı kalması durumunda sistem tamamen kullanılamaz hale gelmemekte, örneğin R1 ve R2 çalışmıyor olsa bile R3, R4 ve R5 üzerinde lock alınabiliyorsa 3/5 çoğunluğu sağlanmış olacağından lock geçerli kabul edilecektir.
Buradaki temel amaç, lock mekanizmasının tek bir Redis sunucusunun veya onun replica’sının oluşturduğu tek bir failure domain’e bağımlı olmamasıdır. Başka bir ifadeyle Redlock, Redis verisini çoğaltarak yüksek erişilebilirlik sağlamaktan ziyade, aynı dağıtık lock bilgisini birbirinden bağımsız Redis master’lar üzerinde tutarak yeterli sayıda node’un aynı anda erişilebilir olması durumunda lock mekanizmasının çalışmaya devam etmesini hedeflemektedir.
Soru 2 | Redlock neden normal Redis lock’tan daha karmaşıktır?
Redlock, distributed sistemlerde bir kaynağa aynı anda yalnızca bir uygulama instance’ının erişmesini sağlamak amacıyla Redis üzerinde kullanılan bir distributed lock algoritmasıdır. Klasik bir Redis lock’unda tek bir Redis sunucusuna SET [key] [value] NX PX [milliseconds] gibi bir komut gönderilerek lock oluşturulurken, Redlock’ta birbirinden bağımsız birden fazla Redis master instance’ına aynı lock oluşturulmaya çalışılmaktadır ve bilindiği üzere çoğunluğun sağlanması (quorum) durumunda lock alınmaktadır.
Ancak yalnızca çoğunluğun sağlanması yeterli değildir. Lock’un oluşturulması sırasında geçen süre de hesaplanır ve lock’un belirlenen TTL süresi içerisinde hala geçerli olup olmadığı kontrol edilir. Lock oluşturulurken her uygulamaya benzersiz bir token verilir. Bu token sayesinde lock’u yalnızca onu alan uygulamanın kaldırabilmesi sağlanır. Lock’un bir TTL süresi vardır ve bu süre dolduğunda uygulama çalışmaya devam etse bile lock geçerliliğini kaybedebilir.
Bu nedenle Redlock, özellikle uzun süren işlemlerde lock yenileme ve daha kritik senaryolarda fencing token gibi ek mekanizmalar gerektirebilir. Misal olarak; bir uygulama lock’u aldıktan sonra uzun süre duraklarsa eğer lock’un TTL’i dolabilir ve başka bir uygulama aynı kaynağın lock’unu alabilir. İlk uygulama daha sonra çalışmasına devam ederse bu durumda iki uygulama aynı anda işlem yapıyor hale gelebilir. Fencing token bu vaziyette eski uygulamanın geç gelen işlemlerinin reddedilmesini sağlayarak veri bütünlüğünü korumaya yardımcı olacaktır.
Dolayısıyla Redlock yaklaşımını yalnızca ‘Redis üzerinde lock tutmak’ olarak değil, birden fazla Redis nodu’u üzerinde quorum, TTL, zamanlama ve lock sahipliği kontrollerini kullanarak dağıtık uygulamalar arasında geçici kaynak sahipliği sağlamaya çalışan bir koordinasyon mekanizması olarak düşünmek en doğrusudur.
Soru 3 | Neden Redis’lere kısa timeout koyuyoruz?
Çünkü bir Redis node’u cevap vermiyorsa sistemin orada sonsuza kadar beklemesini istemeyiz! Keza bir kesinti durumunda Redis node’unun timeout süresi ne kadar uzunsa bu, lock’un geçerlilik (validity) süresinden o kadar törpülenecektir. Bu yüzden Redlock yaklaşımında node başına düşen timeout sürelerinin toplam lock TTL’inden küçük olması önerilmektedir.
Soru 4 | Lock’un sahibi olmak ile lock’un hala geçerli olması farklı şeylerdir!
Distributed lock mekanizmalarında lock’u bir zamanlar almış olmak ile lock’un hala geçerli olması aynı şey değildir! Örneğin; A uygulaması bir kaynağın lock’unu 10 saniyelik TTL ile aldığında, işlemine 2. saniyede başlayıp 8. saniyede devam ediyor olabilir. Ancak işlem 11. saniyeye kadar sürerse 10. saniyede lock’un süresi dolmuş ve A’nın lock üzerindeki geçerliliği sona ermiş olacaktır. Bu sırada B uygulaması lock’un boşaldığını görerek aynı kaynağın lock’unu alabilir ve böylece A ile B aynı anda ilgili işlem üzerinde çalışıyor olabilir.
Buradaki kritik nokta, A process’inin hala çalışıyor olmasının A’nın hala lock sahibi olduğunu anlamına gelmemesidir. Lock’un geçerliliğini process’in yaşam süresi değil, lock için belirlenen TTL belirlemektedir. Bu nedenle özellikle uzun süren işlemlerde yalnızca lock’u aldım bilgisine güvenmek yeterli değildir! Lock’un süresinin dolup dolmadığının takip edilmesi, gerektiğinde lock’un güvenli şekilde yenilenmesi ve kritik kaynaklarda eski bir client’ın lock’u kaybettikten sonra işlem yapmasını engellemek için fencing token gibi ek mekanizmaların kullanması elzemdir.
Soru 5 | Redlock neden tartışmalıdır?
Redlock’u araştırırsanız eğer Redis’in resmi dokümantasyonuna karşın Martin Kleppmann’ın bu davranışın pek de güvenilir olmadığına dair düşünceleri olduğunu göreceksiniz. Redis dokümanları; Redlock davranışını tek instace lock’una göre hata toleransı (fault-tolerant) daha yüksek bir distributed lock yaklaşımı olarak sunmaktadır. Aynı dokümantasyon ise güncel olarak fencing token, clock davranışı ve uzun süren işlemler konusunda açıkca uyarmaktadır. Martin Kleppman ise Redlock’un correctness-critical locking için pek de güvenilir olmadığını savunmaktadır.
Martin Kleppman’ın eleştirisinin temel noktaları şunlardır:
- Cloak’a (sistem saatine) fazla bağımlılık
Redlock’un çalışma mantığında zaman önemli bir rol oynamaktadır. Çünkü önceki satırlarda ifade etmeye çalıştığımız gibi uygulama lock’ı aldıktan sonra lock’ın belirli bir TTL süresi boyunca geçerli olduğunu varsayar ve lock’ın alınması için geçen süreyi de bu geçerlilik hesabına dahil eder.Ancak distributed sistemlerde makinelerin sistem saatleri tamamen kusur değildir. Saatlerde küçük farklılıklar (clock drift), zaman senkronizasyonundaki problemler veya sistem saatinin beklenmedik şekilde ileri-geri hareket etmesi gibi durumlar meydana gelebilmektedir. Redlock’ın güvenlik mantığı belirli zamanlama varsayımlarına dayandığından, bu varsayımlar ciddi şekilde bozulduğunda iki farklı client’ın aynı kaynağı aynı anda kullanabilmesi ihtimali ortaya çıkabilmektedir. Bu nedenle Redlock’un özellikle veri bütünlüğünün doğrudan lock’un doğruluğuna bağlı olduğu kritik sistemlerde kullanılması tartışmalıdır.
- Process’in duraklaması (pause) problemi
Bir uygulama Redlock üzerinden lock’u başarıyla aldıktan sonra işlemine devam ederken process herhangi bir nedenle uzun süre çalışamaz hale gelebilir. Örneğin garbage collection, CPU yetersizliği, sanal makinenin duraklaması, container’ın askıya alınması veya işletim sistemi kaynak problemleri nedeniyle uygulama bir süre cevap veremeyebilir. Bu sırada Redis’teki lock’un TTL süresi dolarsa Redis artık lock’un başka bir client tarafından alınmasına izin vermektedir.Örneğin A uygulaması lock’u almış olsun… Daha sonra uzun süre durmuş ve bu sırada lock’un süresi dolmuşsa B uygulaması aynı lock’u almış olabilir. A ise duraklamadan çıktıktan sonra lock’un artık kendisine ait olmadığını fark etmeden çalışmaya devam edebilir. Böylece A ve B aynı kaynağa aynı anda müdahale edebilir. Buradaki temel problem, A’nın process’inin hala hayatta olması ile A’nın lock üzerindeki hakkının devam ediyor olması arasında doğrudan bir ilişki bulunmamasıdır!
- Fencing token bulunmaması
Redlock lock oluştururken her client için benzersiz bir random value kullanmaktadır. Misal olarak; A uygulaması abc123, B uygulaması ise xyz789 token’ını alabilir. Bu token’lar lock’un sahibini ayırt etmek için kullanışlıdır, ancak bu değerler arasında ‘hangisi daha yeni?’ şekilde bir sıralama bulunmamaktadır! Bu nedenle A lock’u aldıktan sonra lock’un süresi dolup B lock’u aldıysa ve A daha sonra gecikmiş bir işlem gönderirse, kaynak sistemine yalnızca A’nın eski token’ını göstererek ‘Ben senden önce lock almıştım, sie layhN…’ diyememektedir!Fencing token yaklaşımında ise her yeni lock sahibine monotonik(yön değiştirmeden sadece artan veya azalan) olarak artan bir değer verilir. Örneğin A 41, B 42 değerlerini alır ve kaynak yalnızca daha yüksek token değerine sahip işlemleri kabul eder. Böylece A’nın gecikmiş 41 numaralı işlemi B’nin 42 numaralı işleminden sonra gelirse kaynak bunu eski bir işlem olarak algılayıp reddedebilir. Redlock’a yönelik önemli eleştirilerden biri de lock mekanizmasının tek başına bu tür bir fencing garantisi sağlamamasıdır!
Buradaki tartışmalardan yola çıkarak ‘Redlock hiçbir şekilde kullanılmamalıdır!’ gibi basit bir sonuca varılmamalıdır! Eğer lock yalnızca aynı işin birden fazla instance tarafından gereksiz yere aynı anda çalıştırılmasını engellemek gibi bir optimzasyon amacıyla kullanılıyorsa, olası bir lock ihlalinin sonucu genellikle yalnızca gereksiz işlem yapılması olacaktır.
Ancak lock’un doğruluğu para transferi, stok işlemleri, kritik veri güncellemeleri veya başka bir client’ın işlemiyle çakışması durumunda veri bütünlüğünün bozulacağı bir senaryoda sistemin tek güvenlik mekanizmasıyla, Redlock’a yalnızca ‘çoğunluk sağlandı, dolayısıyla kesinlikle tek sahip benim’ şeklinde güvenmek hiç doğru değildir! Böyle durumlarda database transaction, optimistic concurrency, idempotency vs. gibi koordinasyon mekanizmaları cidden değerlendirilmelidir!
Soru 6 | Redlock güvenli mi, güvensiz mi?
Elbette ki bu soruyu tek kalemde cevaplamak doğru değildir! Farklı açılardan olayı ele almak gerekir:
- Eğer lock yalnızca optimizasyon amacı taşıyorsa…
Amaç olarak aynı işin birden fazla uygulama instance’ı tarafından aynı anda çalıştırılmasını mümkün olduğunca engellemek istiyorsak tabi ki de Redlock yaklaşımı yahut genel olarak Redis tabanlı distributed lock mekanizmaları oldukça kullanışlıdır diyebiliriz. Bu tarz ihtiyaç durumlarında tasarlanan lock mekanizmalarının amacı elbette veri bütünlüğünü matematiksel olarak garanti etmek değil, gereksiz tekrarlı işlemleri azaltmaktır.Buna şöyle bir örnek üzerinden anlam katabiliriz; üç farklı uygulama instance’ının aynı scheduled job’u aynı anda çalıştırmasını engellemek, aynı cache’in birden fazla sunucu tarafından aynı anda yeniden oluşturulmasını önlemek veya aynı background job’un gereksiz yere birkaç kez çalışmasını azaltmak için Redis lock’u tercih edebiliriz. Bu tür senaryolarda lock herhangi bir nedenle kaybedilirse en kötü ihtimalle aynı iş iki kez çalışacak, belki de gereksiz bir database sorgusu işlenecek yahut cache’in iki kez oluşturulması gibi basit bir durum söz konusu olacaktır. Yani sistemin temel veri doğrulu bozulmayacaktır!
Burada yakalanması gereken nokta şudur ki, lock’un bir güvenlik sınıfı değil, sistemin daha verimli çalışmasını sağlayan bir koordinasyon aracı olmasıdır. İşte bu kullanım amacı doğrultusunda Redis lock/Redlock mantıklı tercih olacaktır…
- Yok eğer lock doğruluk (correctness) için kullanılıyorsa…
İşte bu vaziyette durum tamamen farklıdır… Eğer “bu lock’a aynı anda yalnızca bir uygulama sahip olabilir ve bunun ihlal edilmesi durumunda veritabanındaki para, stok yahut kritik iş verisi kesinlikle bozulur” deniyorsa yalnızda Redlock’un lock mekanizmasına güvenmek, evet, risklidir!Çünkü daha önce bahsedildiği üzere TTL’in dolması, process’in uzun süre duraklaması, network gecikmelerinin olması, clock problemlerinin yaşanması ve eski client’ın lock’u kaybettikten sonra çalışmaya devam etmesi gibi durumlar ortaya çıkabilir.
Örneğin; A uygulaması lock’u aldıktan sonra uzun süre duraklarsa lock’un TTL’i dolabilir ve bu süreçte B uygulaması aynı lock’u alıp işlemini gerçekleştirebilir. A uygulaması daha sonra tekrar çalışarak eski işlemini yürütebilir. Eğer kaynak sisteminin A’nın artık geçerli olmadığını anlayabileceği bir mekanizması yoksa iki client’ın işlemleri birbirine karışabilir. Böyle bir durumda ‘Redlock var, dolayısıyla aynı anda yalnızca bir uygulama çalışabilir’ şeklinde bir güvenceyle varsayımda bulunmak pek yeterli bir güvenlik garantisi sağlamayacaktır!
- Asıl ayrıma gelirsek eğer…
Redlock’un güvenli olup olmadığını değerlendirirken ana odak düşüncemiz “lock’un ihlal edilmesi durumunda ne olur?” sorusu merkezli olmalıdır! Eğer lock’un ihlal edilmesi yalnızca aynı işin iki kez çalışmasına yol açıyorsa Redis lock oldukça makul bir çözümdür diyebiliriz. Fakat lock’un ihlal edilmesi para transferi gibi kritik bir işlevin iki kez gerçekleşmesine ya da stok gibi hassasiyet gerektiren süreçlerin kalıcı bozulmasına neden oluyorsa, distributed lock’u sistemin tek doğruluk mekanizması haline getirmek doğru yaklaşım olmayacaktır!Böyle durumlarda sürekli söylediğimiz gibi database transaction, optimistic concurrency, unique constraint, idempotency yahut fencing token gibi mekanizmalarla asıl kaynağın kendisi de korunmalıdır!
Kısacası, Redlock’u %100 güvenilir bir distributed mutex olarak değil, belirli failure ve timing varsayımları altında distributed uygulamalar arasında geçici koordinasyon sağlayan bir mekanizma olarak değerlendirmek en doğrusudur! Lock’un amacı yalnızca gereksiz eşzamanlı çalışmaları engellemekse oldukça kullanışlıdır. Fakat lock’un bozulduğu durumlarda sistemin doğrudan bozulacağı senaryolar söz konusu ise Redlock’un yanına mutlaka daha güçlü bir doğruluk mekanizması gerekmektedir.
Soru 7 | Redlock ile Redis Cluster aynı şey mi?
Redis Cluster ile Redlock yaklaşımı tabi ki de aynı şey değildir!
Redis Cluster, Redis’in verileri birden fazla Redis server’ına dağıtarak ölçeklenebilirlik, veri dağıtımı ve yüksek erişilebilirlik sağlaması için kullanılan bir tasarımsal yapıdır. Örneğin veriler farklı shard’lara dağıtılarak tek bir Redis sunucusunun taşıyabileceğinden daha büyük bir veri yükü yönetilebilir.
Redlock ise tamamen farklı bir probleme, distributed locking’e odaklanan davranıştır. Amacı, aynı kaynağa erişmeye çalışan birden fazla uygulama sunucusundan yalnızca birinin belirli bir işlem üzerinde çalışmasını sağlamaktır. Redlock bunu birden fazla bağımsız Redis master üzerinde aynı kilidi oluşturmaya çalışarak ve çoğunluk sağlandığında kilidi elde edilmiş kabul ederek yapar.
Dolayısıyla Redis Cluster’ın temel amacı veriyi dağıtmak ve Redis altyapısını ölçeklemekken, Redlock’ın amacı ise distributed sistemlerde ortak bir kaynağın kullanımını koordine etmek ve kilitlemektir. Kısaca, Redis Cluster bir veri altyapısı/cluster mimarisiyken, Redlock ise bir distributed lock algoritmasıdır. Buradan yola çıkarak, Redis Cluster’ın kullanıldığı durumlarda otomatik olarak Redlock yaklaşımının kullanıldığı anlamı çıkarılmamalıdır!
Soru 8 | Distributed lock ile database transaction birbirinin alternatifi mi?
Distributed lock mekanizmaları ile veritabanı transaction ve concurrency kontrol mekanizmaları birbirinin alternatifi değildir. Her biri farklı ihtiyaçları karşılamaktadır.
| Mekanizma | Amacı | Örnek |
|---|---|---|
| Distributed Lock | Birden fazla uygulama sunucusu arasında kaynak kullanımını koordine eder. | Aynı raporun iki sunucuda eş zamanlı oluşturulmasını önlemeye çalışmak. |
| Database Transaction | Birden fazla veritabanı işleminin bütünlüğünü korur. | Sipariş oluşturma ve stok düşme işlemlerini tutarlı biçimde gerçekleştirmek. |
| Concurrency Control | Eş zamanlı işlemlerin aynı veri üzerinde çakışmasını yönetir. | Stok güncellerken koşullu UPDATE veya optimistic concurrency kullanmak. |
Yani distributed lock uygulamalar arasındaki koordinasyonu, transaction veritabanı işlemlerinin bütünlüğünü, concurrency control ise eş zamanlı işlemlerin çakışmasının yönetimini hedefler. Bu mekanizmalar birlikte kullanılabilir; ancak her problem için üçünün de kullanılması gerekmez.
Asp.NET Core’da Redlock Nasıl Uygulanır?
Tabi ki de her çalışmada yaptığımız gibi bu yaklaşımı da teoride bırakmayacak, Docker üzerinden ayağa kaldıracağımız 5 ayrı Redis Master’ı ile Redlock’u pratikte uygulayacağız. Ve bu uygulama sürecinde Redis server’larını yapılandıracak, lock alıp bırakacak, eş zamanlı istekler üzerinden çalışmamızı test edecek ve Redis server’larından bazıları kapandığı taktirde ne olacağı üzerine incelemede bulunacağız.
Mimarimiz şöyle olacaktır;
Bağımsız
Bağımsız
Bağımsız
Bağımsız
Bağımsız
Senaryomuza gelirsek eğer gerçekçi olması için bir sipariş akışını simüle edeceğiz. Aynı siparişin aynı anda iki farklı sunucuda işlenmemesi (örneğin müşteriden iki kez para çekilmemesi) ve süreçte olası race condition durumlarını önlemek için yapacağımız çalışmalar Redlock örneği için oldukça uygun olacaktır.
- RedLock.net
C# tarafında Redlock algoritmasını uygulayan kütüphanedir. Redis bağlantılarını yönetir, lock almaya çalışır, çoğunluğu kontrol eder ve lock yaşam süresini yönetir. Bu nedenle tüm sunuculara kendimiz ayrı ayrıSETveDELkomutlarını göndermek için algoritmayı baştan yazmak yerine, bu kütüphaneden istifade edeceğiz. - StackExchange.Redis
Şimdi adım adım geliştirmeye başlayalım:
- Adım 1 (Redis Master’larının Dockerize Edilmesi)
Her şeyden önce distributed lock davranışının altyapısını kurgulayabilmek için Redis master’larının dockerize edilmesi gerekmektedir. Bunun için aşağıdaki docker-compose.yml dosyasını tasarlayalım.services:
redis-1:
image: redis:7.4-alpine
container_name: redis-1
ports: [“6381:6379”]
redis-2:
image: redis:7.4-alpine
container_name: redis-2
ports: [“6382:6379”]
redis-3:
image: redis:7.4-alpine
container_name: redis-3
ports: [“6383:6379”]
redis-4:
image: redis:7.4-alpine
container_name: redis-4
ports: [“6384:6379”]
redis-5:
image: redis:7.4-alpine
container_name: redis-5
ports: [“6385:6379”]Dikkat ederseniz hiçbir Redis instance’ında bir replikasyon, cluster yapısı yahut sentinel mimarisi bulunmamaktadır. Yani her biri, birbirinden habersiz 5 ayrı master’dır. Redlock’un güvenliği tam olarak bu bağımsızlığa dayanmaktadır. Bir lock, node’ların çoğunluğu (5’te 3) onu kabul ederse geçerli sayılacaktır. Bu sayede 2 node düşse bile sistem çalışmaya devam edecektir.
Tabi bu instance’ların ayağa kaldırılması için ilgili dizinde aşağıdaki docker talimatının verilmesi gerekmektedir:
docker compose up -d
- Adım 2 (Projenin Oluşturulması, Kütüphanelerin Yüklenmesi ve Temel Yapılandırmaların Sağlanması)
Bu süreçte bize eşlik edecek altyapı bir Asp.NET Core Web API projesi olacaktır. Projeyi oluşturduktan sonra ilk olarak Redlock algoritmasının .NET implementasyonunu sağlayacak olan RedLock.net kütüphanesini ve Redis’le uygulamanın haberleşmesini sağlayacak olan StackExchange.Redis kütüphanesini kuralım.Ardından bir önceki adımda ayağa kaldırdığımız Redis node’larının portlarını hızlıca tüketebilmek için appsettings.json dosyasına tanımlayalım.
{ "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*", "Redlock": { "Nodes": [ "localhost:6381", "localhost:6382", "localhost:6383", "localhost:6384", "localhost:6385" ] } } - Adım 3 (Redlock Davranışının Yapılandırılması)
Şimdi Redlock davranışını üstlenecek ve tek satırda çağrılabilir hale getirecek olan bir yapılandırmada bulunalım:public static class RedlockSetup { extension(IServiceCollection serviceCollection) { public IServiceCollection AddRedlock(IConfiguration configuration) { var nodes = configuration.GetSection("Redlock:Nodes").Get<string[]>() ?? throw new InvalidOperationException("Redlock:Nodes tanımlı değil!"); //Her master için ayrı bir bağlantı gerçekleştiriyoruz. var multiplexers = nodes.Select(node => new RedLockMultiplexer(ConnectionMultiplexer.Connect(new ConfigurationOptions { EndPoints = { node }, AbortOnConnectFail = false, BacklogPolicy = BacklogPolicy.FailFast }))).ToList(); //Tüm master'lar tek bir lock factory'de toplanıyor. Burası Redlock davranışının kalbi olarak yorumlanabilir! serviceCollection.AddSingleton<IDistributedLockFactory>(serviceProvider => RedLockFactory.Create(multiplexers, serviceProvider.GetRequiredService<ILoggerFactory>())); return serviceCollection; } } }Bu yapılandırma görüldüğü üzere bir extension metoda dayanmaktadır. İşlevsel olarak her master’a ayrı bir bağlantı sağlamakta ve bu bağlantıları
RedLockMultiplexerile RedLock.net’e tanıtan bir encapsulation oluşturmaktadır. Burada özellikle dikkat edilmesi gereken husus, bu Redis master’ları için ayrı bağlantı ve kurulumun yapılmasıdır! Eğer kiConnectionMultiplexer.Connect("localhost:6381,localhost:6382,...")şeklinde bir yapılandırmayla tek bağlantıya Redis adreslerini veriyor olsaydık, StackExchange.Redis kütüphanesi onları tek bir sistemin parçaları sanacaktı ve her yazışmada tek bir master’a gönderim sağlayacaktı. Ancak bu durum Redlock davranışına uygun olmayacaktı!Ayrıca 14 ile 16. satır aralığındaki yapılandırmalara göz atarsak eğer Redlock’un hata toleransının göz önüne alındığını söyleyebiliriz.
AbortOnConnectFail = false: Açılışta bir node kapalı olsa bile uygulama başlatılacak, bağlantı arka planda toparlanacaktır. Bu ayar olmasaydı tek bir kapalı node’un olması durumunda uygulama çökertilecektir. Oysa Redlock’un amacı birkaç node düşse bile çalışmaya devam edebilmektir.BacklogPolicy.FailFast: StackExchange.Redis kütüphanesi varsayılan olarak bağlantı kopukken gelen komutları kuyrukta bekletir. Ancak lock durumlarında bunu istemeyiz. Ölü node hemen “hata” desin, karar ayaktaki node’larla verilsin.
20. satırda ise
RedLockFactory.Createmetodu ile tüm bağımsız Redis instance’larını tek bir lock factory’de topluyoruz. Bu factory içerisinde çoğunluk eşiği listenin uzunluğundan hesaplanmakta ve alınan her lock tüm node’larda denenerek, yeterli çoğunluk sağlandığı taktirde geçerli sayılmaktadır. Çoğunluk sağlanamazsa varsayılan olarak 3 tura kadar(her tur arası 0-400 ms rastgele bekleyecek) bu işlem yeniden denenecektir.Ayrıca bu metoda
ILoggerFactorynesnesini verdiğimiz için de RedLock.net her lock’un sonucunu, süreci rahat bir şekilde gözlemleyebilmemiz için console’a yazdırmış olacaktır. - Adım 4 (Lock’ı Kullanan Servisin Yapılandırılması)
Şimdi de sipariş sürecinde aynı anda iki farklı sunucuyla işleyişin yapılmasını engellemek ve olası race condition durumlarına karşın önlem alabilmek için ilgili siparişi yalnızca lock eldeyken işleyecek bir servis geliştiriyor olacağız!public class OrderProcessor(IDistributedLockFactory distributedLockFactory, ILogger<OrderProcessor> logger) { public async Task<ProcessResult> ProcessAsync(string orderId) { var resource = $"order:{orderId}"; //Neyi lock'luyoruz? var expiry = TimeSpan.FromSeconds(30); //Lock ne kadar süreyle geçerli olacak? //Lock burada alınıyor await using var redLock = await distributedLockFactory.CreateLockAsync(resource, expiry); var nodes = redLock.InstanceSummary.ToString(); //Node'ların "oy" dökümü! if (!redLock.IsAcquired) { var reason = redLock.Status == RedLockStatus.Conflicted ? $"Sipariş {orderId} şu anda başka bir yerde işlenmektedir." : $"Lock alınamadı! ({redLock.Status}): Redis node'larının çoğunluğuna ulaşılamamaktadır!"; return new ProcessResult(false, reason, nodes); } #region Kritik Bölge | Bu sipariş için aynı anda yalnızca TEK bir işlem burada olabilir! logger.LogInformation($"Sipariş {orderId} işleniyor..."); await Task.Delay(TimeSpan.FromSeconds(10)); logger.LogInformation($"Sipariş {orderId} tamamlandı."); return new ProcessResult(true, $"Sipariş {orderId} tamamlandı.", nodes); #endregion } }Burada 9. satırdaki
CreateLockAsyncmetodu ile Redlock algoritmasını başlatıyoruz! Bu metot çağrıldığı anda tüm Redis node’larına paralel olarakSET redlock:order:1001talimatı gönderilir. Bu talimat doğrultusunda yeterli çoğunluk sağlandıysa ve bu işlem TTL’den kısa sürdüyse lock alınmış sayılacaktır.NX PX 30000 Lock alınmaya çalışıldığında 3 sonuç söz konusu olabilir;
- Conflicted: Node’ların çoğunluğuna ulaşıldığını ama lock başkasında olduğu için alınamadığını ifade eder! Yani sipariş o an başka bir sunucuda işleniyorsa bu state geçerli olacaktır.
- NoQuorum: Node’ların çoğunluğuna ulaşılamadığı için lock’un alınamadığını ifade eder.
- Expired: Nadiren görülüyor olsa da lock’u almanın TTL’den uzun sürdüğünü ifade eder.
11. satırda ise
InstanceSummarymetodu ile node’ların oy dökümünü Acquired: 5, Conflicted: 0, Error: 0 formatında ediniyor ve bunu response’a koyuyoruz. - Adım 5 (Program.cs Dosyasının Yapılandırılması)
Ve son olarak geliştirilen tüm çalışmaları Program.cs dosyasında yapılandıralım:using RedlockExample.RedlockConfigurations; using System.Text.Encodings.Web; var builder = WebApplication.CreateBuilder(args); builder.Services.AddRedlock(builder.Configuration); builder.Services.AddSingleton<OrderProcessor>(); builder.Services.ConfigureHttpJsonOptions(o => o.SerializerOptions.Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping); var app = builder.Build(); app.MapPost("/orders/{orderId}/process", async (string orderId, OrderProcessor orderProcessor) => { var result = await orderProcessor.ProcessAsync(orderId); return result.Success ? Results.Ok(result) : Results.Conflict(result); }); app.Run(); - Adım 6 (Test Edilmesi)
Test için uygulamayı derleyelim ve aşağıdaki talimatlarla iki instance olarak ayağa kaldıralım:dotnet build
dotnet run –no-build — –urls http://localhost:5001 # 1. terminal
dotnet run –no-build — –urls http://localhost:5002 # 2. terminalŞimdi teste geçebiliriz;
- Test 1
Bir terminal üzerinden aşağıdaki curl isteğinde bulunalım.curl -X POST http://localhost:5001/orders/1001/processBu istek 10 saniye sürecektir. Bu süre dolmadan aşağıdaki ikinci curl isteğini de başka bir terminalden bulunalım.
curl -X POST http://localhost:5002/orders/1001/processİsteklerin neticeleri aşağıdaki gibi olacaktır:
- Test 2
Şimdi de lock’un Redis’teki halini test edeceğiz. Bunun için de sipariş süreci işlerken şu talimatları çalıştıralım…docker exec redis-1 redis-cli GET redlock:order:1001
docker exec redis-1 redis-cli PTTL redlock:order:1001
docker exec redis-2 redis-cli GET redlock:order:1001
docker exec redis-2 redis-cli PTTL redlock:order:1001
docker exec redis-3 redis-cli GET redlock:order:1001
docker exec redis-3 redis-cli PTTL redlock:order:1001
docker exec redis-4 redis-cli GET redlock:order:1001
docker exec redis-4 redis-cli PTTL redlock:order:1001
docker exec redis-5 redis-cli GET redlock:order:1001
docker exec redis-5 redis-cli PTTL redlock:order:1001
Burada görüldüğü üzere tüm node’lardan aynı değer (LockId) dönmektedir. Yani tüm node’lar da aynı değerin gözükmesi, aynı lock isteğinin tüm node’ların hepsinde de kazandığı anlamına gelmektedir. Ve kalan ömür ise ortalama 25 saniyelerde seyretmektedir. Ayrıca şunu da bilmekte fayda var ki, LockId değerinin 1, 3, 5 gibi sabit olarak gelmemesinin sebebi lock’ın kime ait olduğunun ayırt edilmesi içindir. Çünkü lock bırakılırken, RedLock.net kütüphanesi Lua script aracılığıyla mevcut key’in o anki LockId olup olmadığını kontrol edebilmek için bu değer ile de eşleştirme yapacaktır.
- Test 3
Ve son olarak da node’ları düşürerek bir test gerçekleştirelim istiyorum. Bunun için aşağıdaki talimatlardan istifade edebiliriz:docker stop redis-4 redis-5
curl -X POST http://localhost:5001/orders/2001/process
docker stop redis-3
curl -X POST http://localhost:5001/orders/2002/process
docker start redis-3 redis-4 redis-5Bu talimatlar eşliğinde istekler yapıldığında sırasıyla aşağıdaki cevaplar alınmış olacaktır:
2 node kapalıyken → {“success”:true,”message”:”Sipariş 2001 tamamlandı.”,”nodes”:”Acquired: 3, Conflicted: 0, Error: 2″}
3 node kapalıyken → {“success”:false,”message”:”Lock alınamadı! (NoQuorum): Redis node’larının çoğunluğuna ulaşılamamaktadır!”,”nodes”:”Acquired: 2, Conflicted: 0, Error: 3″}Evet, 2 node kapalıyken ayakta kalan 3 node çoğunluğu sağlamakta ve işi yapabilmektedir, ancak 3 node kapalıyken çoğunluk diye bir şey kalmamakta ve uygulama işi yapmayı reddetmektedir.
- Test 1
İşte bu kadar…
Redlock’un Lock Renewal Problemi
Redlock davranışı sergilenirken, lock altında gerçekleştirilen bir işlemin lock’un belirlenen yaşam süresinden (TTL) daha uzun sürmesi olasıdır. Örneğin, lock’un geçerlilik süresi 10 saniye olarak belirlenmişken işlem 30 saniye sürüyorsa, işlem tamamlanmadan lock’un süresi dolabilir. Bu durumu önlemek için lock’un süresini uzatma (lock renewal) mekanizmasından yararlanılabilir.
Bu mekanizmada, Redis üzerindeki lock key’inin hala aynı rastgele sahiplik değerini taşıdığı kontrol edilmelidir ve lock’ın kalan süresi uzatılmalıdır. Uzatma işleminin de yeterli sayıda Redis master üzerinde başarılı olması gerekecektir. Ancak lock’un süresini düzenli olarak uzatmak, lock’un sonsuza kadar güvenli biçimde uygulamanın kontrolünde kalacağı anlamına gelmemektedir.
Özellikle network partition ya da uygulama sürecinin geçici olarak duraklaması gibi durumlarda veya Redis server’lardaki arızalar veya zamanlama sorunları nedeniyle lock kaybedilebilmektedir. Bu nedenle, özellikle kritik işlemlerde yalnızca lock yenileme mekanizmasına güvenilmemeli, lock geçerliliğini yitirdiğinde eski işlemin veri üzerinde hatalı değişiklik yapmasını önleyecek ek güvenlik önlemleri de alınmış olmalıdır.
Redlock’u Nerede Kullanmalıyız?
Redlock, özellikle aynı işin birden fazla uygulama instance2ı tarafından eş zamanlı olarak yapılmasını önlemek veya azaltmak amacıyla kullanılabilir. Misal olarak; background job’ların tekrar tekrar çalıştırılmasını engellemek, önbellek yenileme (cache rebuild) işlemlerini koordine etmek, scheduled task’ların birden fazla sunucuda aynı anda yürütülmesini azaltmak ve geçici kaynakların kullanımını düzenlemek için değerlendirilebilir.
Bu tür senaryolarda lock’un kaybedilmesi durumunda sistemin aynı işi birden falza kez gerçekleştirilmesi veya gereksiz kaynak tüketilmesi gibi sonuçlar ortaya çıkabilir… Ancak uygulama doğru tasarlanmışsa veritabanında kritik verilerin bozulmaması, para kaybo yaşanmaması ve iş açısından önemli durumların tutarlılığının korunması sağlanabilir. Dolayısıyla Redlock davranışı, lock mekanizmasının temel amacı olan veri tutarlılığını tek başına garanti etmemekte, gayenin gereksiz tekrarlı işleri azaltmak ve kaynak kullanımını optimize etmek olduğu senaryolara daha uygun bir çözüm sağlamaktadır.
Nihai olarak;
Redlock davranışının amacı birden fazla Redis node’u üzeirnden lock acquisition’ı quorum ile koordine etmektir. Fakat lock’un süresinin dolması, process’in pause olması yahut network gecikmeleri gibi durumlarda eski client hala çalışıyor problemi ortaya çıkabilir. Bu nedenle fencing token konusuna özellikle dikkat edilmesi gerektiğini son kez hatırlatmak istiyorum.
İlgilenenlerin faydalanması dileğiyle…
Sonraki yazılarımda görüşmek üzere…
İyi çalışmalar…

